def build_keymap(args):
"""
Function build_keymap returns a dictionary from curses keys to game.Keys.
"""
if args.vimkeys:
return {
ord('k'): Keys.UP,
ord('j'): Keys.DOWN,
ord('h'): Keys.LEFT,
ord('l'): Keys.RIGHT,
ord(' '): Keys.PROBE,
ord('f'): Keys.FLAG,
}
return {
curses.KEY_UP: Keys.UP,
curses.KEY_DOWN: Keys.DOWN,
curses.KEY_LEFT: Keys.LEFT,
curses.KEY_RIGHT: Keys.RIGHT,
ord('\n'): Keys.PROBE,
ord('f'): Keys.FLAG,
}
python类KEY_RIGHT的实例源码
def update(cls):
key = cls.getch()
if key is not None:
if key == curses.KEY_UP:
cls.PAD_Y = max(cls.PAD_Y - 1, 0)
elif key == curses.KEY_DOWN:
cls.PAD_Y = min(
cls.PAD_Y + 1,
cls.PAD_HEIGHT - (cls.HEIGHT + 1)
)
elif key == curses.KEY_LEFT:
cls.PAD_X = max(cls.PAD_X - 1, 0)
elif key == curses.KEY_RIGHT:
cls.PAD_X = min(
cls.PAD_X + 1,
cls.PAD_WIDTH - (cls.WIDTH + 1)
)
elif key == ord('q'):
cls.trigger('quit')
for y in range(cls.PAD_Y, cls.PAD_Y + cls.HEIGHT):
s = cls.MAP[y][cls.PAD_X:cls.PAD_X + cls.PAD_HEIGHT]
s = ''.join(x for x in s)
cls.addstr(s, cls.PAD_X, y)
cls.refresh()
def focus(self):
modeline.update_activeWindow("Map")
curses.curs_set(0)
while True:
event = self.mapwin.getch()
# if event == -1:
# continue
logging.info(event)
try_handle_global_event(event)
if event == curses.KEY_UP:
self.pan("up")
if event == curses.KEY_DOWN:
self.pan("down")
if event == curses.KEY_LEFT:
self.pan("left")
if event == curses.KEY_RIGHT:
self.pan("right")
if event == curses.KEY_NPAGE:
self.zoom_out(5)
if event == curses.KEY_PPAGE:
self.zoom_in(5)
def update_screen():
"""
Updates the screen each time a key is pressed.
"""
if not GUI.gui_stopped:
if GUI.key == curses.KEY_DOWN:
GUI.on_key_down()
elif GUI.key == curses.KEY_UP:
GUI.on_key_up()
elif GUI.key == curses.KEY_LEFT:
GUI.on_key_left()
elif GUI.key == curses.KEY_RIGHT:
GUI.on_key_right()
if GUI.key == ord("\n") and GUI.row_num != 0:
GUI.on_key_enter()
GUI.box.erase()
GUI.display_list()
GUI.add_bottom_menus()
GUI.screen.refresh()
GUI.box.refresh()
def __init__(self, x, y, window):
self.body_list = []
self.hit_score = 0
self.timeout = TIMEOUT
for i in range(SNAKE_LENGTH, 0, -1):
self.body_list.append(Body(x - i, y))
self.body_list.append(Body(x, y, '0'))
self.window = window
self.direction = KEY_RIGHT
self.last_head_coor = (x, y)
self.direction_map = {
KEY_UP: self.move_up,
KEY_DOWN: self.move_down,
KEY_LEFT: self.move_left,
KEY_RIGHT: self.move_right
}
def __init__(self, x, y, window):
self.body_list = []
self.hit_score = 0
self.timeout = TIMEOUT
#0 Append The Snake's range to the Body object for Snakes Body
for i in range(SNAKE_LENGTH, 0, -1):
self.body_list.append(Body(x - i, y))
#1 Define and append the snakes head
self.body_list.append(Body(x, y, '0'))
#2 define the window
self.window = window
#3 Move snake to right when game starts
self.direction = KEY_RIGHT
#4 set snakes lst head coordinate
self.last_head_coor = (x, y)
#5 define direction map
self.direction_map = {
KEY_UP: self.move_up,
KEY_DOWN: self.move_down,
KEY_LEFT: self.move_left,
KEY_RIGHT: self.move_right
}
def __init__(self, x, y, window):
self.body_list = []
self.hit_score = 0
self.timeout = TIMEOUT
for i in range(SNAKE_LENGTH, 0, -1):
self.body_list.append(Body(x - i, y))
self.body_list.append(Body(x, y, '0'))
self.window = window
self.direction = KEY_RIGHT
self.last_head_coor = (x, y)
self.direction_map = {
KEY_UP: self.move_up,
KEY_DOWN: self.move_down,
KEY_LEFT: self.move_left,
KEY_RIGHT: self.move_right
}
def __init__(self, x, y, window):
self.body_list = []
self.hit_score = 0
self.timeout = TIMEOUT
for i in range(SNAKE_LENGTH, 0, -1):
self.body_list.append(Body(x - i, y))
self.body_list.append(Body(x, y, '0'))
self.window = window
self.direction = KEY_RIGHT
self.last_head_coor = (x, y)
self.direction_map = {
KEY_UP: self.move_up,
KEY_DOWN: self.move_down,
KEY_LEFT: self.move_left,
KEY_RIGHT: self.move_right
}
def __init__(self, x, y, window):
self.body_list = []
self.hit_score = 0
self.timeout = TIMEOUT
for i in range(SNAKE_LENGTH, 0, -1):
self.body_list.append(Body(x - i, y))
self.body_list.append(Body(x, y, '0'))
self.window = window
self.direction = KEY_RIGHT
self.last_head_coor = (x, y)
self.direction_map = {
KEY_UP: self.move_up,
KEY_DOWN: self.move_down,
KEY_LEFT: self.move_left,
KEY_RIGHT: self.move_right
}
def put(self, char):
pos = self._cursor.position
cnt = len(self._text)
if isinstance(char, str) and cnt < self._max_len and ord(char) >= 0x20:
self._text = self._text[:pos] + char + self._text[pos:]
self._cursor.count = len(self._text)
self._cursor.position = pos + 1
elif char == curses.KEY_LEFT and pos > 0:
self._cursor.position = pos - 1
elif char == curses.KEY_RIGHT and pos < cnt:
self._cursor.position = pos + 1
elif char == curses.KEY_HOME:
self._cursor.position = 0
elif char == curses.KEY_END:
self._cursor.position = cnt
elif char == curses.KEY_BACKSPACE and pos > 0:
self._text = self._text[:pos - 1] + self._text[pos:]
self._cursor.count = len(self._text)
self._cursor.position = pos - 1
elif char == curses.KEY_DC:
self._text = self._text[:pos] + self._text[pos + 1:]
self._cursor.count = len(self._text)
def handle_key(self, k):
if k == ord('q'):
self.close(None)
elif k == ord('d'):
self._change_date()
elif k == ord('l'):
self._change_level()
elif k == ord('f'):
self._change_facility()
elif k == ord('h'):
self._change_host()
elif k == ord('p'):
self._change_program()
elif k == curses.KEY_NPAGE:
self._buf.go_to_next_page()
elif k == curses.KEY_PPAGE:
self._buf.go_to_previous_page()
elif k == curses.KEY_DOWN:
self._buf.go_to_next_line()
elif k == curses.KEY_UP:
self._buf.go_to_previous_line()
elif k == curses.KEY_RIGHT:
self.scroll_right()
elif k == curses.KEY_LEFT:
self.scroll_left()
def _alternative_left_right(term):
r"""
Determine and return mapping of left and right arrow keys sequences.
:arg blessed.Terminal term: :class:`~.Terminal` instance.
:rtype: dict
This function supports :func:`get_terminal_sequences` to discover
the preferred input sequence for the left and right application keys.
Return dict of sequences ``term._cuf1``, and ``term._cub1``,
valued as ``KEY_RIGHT``, ``KEY_LEFT`` (when appropriate). It is
necessary to check the value of these sequences to ensure we do not
use ``u' '`` and ``u'\b'`` for ``KEY_RIGHT`` and ``KEY_LEFT``,
preferring their true application key sequence, instead.
"""
keymap = dict()
if term._cuf1 and term._cuf1 != u' ':
keymap[term._cuf1] = curses.KEY_RIGHT
if term._cub1 and term._cub1 != u'\b':
keymap[term._cub1] = curses.KEY_LEFT
return keymap
def main(win,args):
SCSP = ScreenSpace(win)
SNK = Snake(win,args)
try:
while True:
SNK.render(SCSP,args)
SCSP.render(clear=False,ref=False)
gc = SCSP.win.getch()
if gc in [ord("a"),curses.KEY_LEFT]:
SNK.dir = SNK.turnleft()
if gc in [ord("d"),curses.KEY_RIGHT]:
SNK.dir = SNK.turnright()
if gc == ord("q"):
SCSP.destroy()
sys.exit()
SCSP.win.erase()
time.sleep(args.delay)
except KeyboardInterrupt:
pass
def runDay(scr, rollover, topString, bottomString, start=None):
if(rollover):
if(start is None):
day = date.today()
else:
day = date(start.year, start.month, start.day)
else:
if(start is None):
day = datetime.date.today()
else:
day = datetime.date(start.year, start.month, start.day)
c = curses.KEY_MAX
cursor = 3
while(c != 10):
displayDay(scr, day, cursor, topString, bottomString)
c = scr.getch()
if(c == curses.KEY_RIGHT) and cursor < len(str(day))-1:
cursor += 1
if(cursor == 4 or cursor == 7):
cursor += 1
elif(c == curses.KEY_LEFT) and cursor > 0:
cursor -= 1
if(cursor == 4 or cursor == 7):
cursor -= 1
elif(c == curses.KEY_UP):
day = alterDigitDay(cursor, day, 1)
elif(c == curses.KEY_DOWN):
day = alterDigitDay(cursor, day, -1)
else:
try:
i = int(c) - 48
if(i >= 0 and i < 10):
day = updateDigitDay(cursor, day, i)
except ValueError:
pass
return datetime.date(day.year, day.month, day.day)
def runTime(scr, rollover, topString, bottomString, start=None):
if(rollover):
if(start is None):
t = time()
else:
t = time(start.hour, start.minute, start.second)
else:
if(start is None):
t = datetime.time()
else:
t = datetime.time(start.hour, start.minute, start.second)
c = curses.KEY_MAX
cursor = 3
while(c != 10):
displayTime(scr, t, cursor, topString, bottomString)
c = scr.getch()
if(c == curses.KEY_RIGHT) and cursor < len(str(t))-1:
cursor += 1
if(cursor == 2 or cursor == 5):
cursor += 1
elif(c == curses.KEY_LEFT) and cursor > 0:
cursor -= 1
if(cursor == 2 or cursor == 5):
cursor -= 1
elif(c == curses.KEY_UP):
t = alterDigitTime(cursor, t, 1)
elif(c == curses.KEY_DOWN):
t = alterDigitTime(cursor, t, -1)
else:
try:
i = int(c) - 48
if(i >= 0 and i < 10):
t = updateDigitTime(cursor, t, i)
except ValueError:
pass
return datetime.time(t.hour, t.minute, t.second)
def processkey(self, key, win):
h, w = win.getmaxyx()
if (key == ord(' ')):
weapon = self.arsenal[self.active_weapon]
if (weapon[1] != 0):
self.shoot()
if(weapon[1] != -1):
weapon[1] = max(0, weapon[1] - 1)
return True
else:
self.weapon_display_timer = 50
elif (key == curses.KEY_LEFT):
if self.angle <= pi/2:
self.angle = pi - self.angle
else:
self.move(-1)
elif (key == curses.KEY_RIGHT):
if self.angle >= pi/2:
self.angle = pi - self.angle
else:
self.move(1)
elif (key == curses.KEY_UP):
if (self.angle <= pi/2):
self.angle = min(pi/2.001, self.angle+0.01)
else:
self.angle = max(pi/1.999, self.angle-0.01)
elif (key == curses.KEY_DOWN):
if (self.angle <= pi/2):
self.angle = max(0, self.angle-0.01+pi/8)-pi/8
else:
self.angle = min(pi*9/8, self.angle+0.01)
elif (key == ord('+')):
self.power = min(1.00, self.power+0.01)
elif (key == ord('-')):
self.power = max(0.00, self.power-0.01)
elif (key in map(lambda k : ord(str(k)), range(10))):
n = int(chr(key))
self.active_weapon = (n-1) % len(self.arsenal)
self.weapon_display_timer = 50
return False
def run_main_loop(self):
self.draw_ui()
while 1:
c = self.window.getch()
if curses.keyname(c) in [b'h', b'H']:
self.show_help()
elif curses.keyname(c) in [b'p', b'P']:
self.play()
elif curses.keyname(c) in [b'q', b'Q']:
return None
elif c == 27:
self.returnString = self.dir.get_current_path()
return self.returnString
elif c == curses.KEY_ENTER or c == 10:
self.returnString = self.dir.get_current_path()
return self.returnString
elif c == curses.KEY_UP:
if self.selected_index > 0:
self.selected_index -= 1
self.draw_ui()
elif c == curses.KEY_DOWN:
if self.selected_index < self.dir.max_entries_on_level()-1:
self.selected_index += 1
self.draw_ui()
elif c == curses.KEY_LEFT:
self.leave_dir()
self.draw_ui()
elif c == curses.KEY_RIGHT:
self.enter_dir()
self.draw_ui()
elif c == curses.KEY_RESIZE:
self.draw_ui()
def on_key(self, ch):
if ch == curses.KEY_LEFT:
if self.selected > 0:
self.selected -= 1
elif ch == curses.KEY_RIGHT:
if self.selected + 1 < len(self.items):
self.selected += 1
else:
return False
self.value = self.items[self.selected]
self.update()
return True
def on_key(self, ch):
x = self.pos
# ascii 32-126 (inclusive)
if curses.ascii.isprint(ch):
if len(self.value) < self.max_length:
self.value = self.value[:x] + chr(ch) + self.value[x:]
self.pos += 1
elif ch == curses.KEY_LEFT:
if x > 0:
self.pos -= 1
elif ch == curses.KEY_RIGHT:
if x < len(self.value):
self.pos += 1
elif ch == curses.KEY_BACKSPACE:
if x > 0:
self.value = self.value[:x - 1] + self.value[x:]
self.pos -= 1
elif ch == curses.KEY_DC:
if x < len(self.value):
self.value = self.value[:x] + self.value[x + 1:]
elif ch == curses.KEY_HOME:
self.pos = 0
elif ch == curses.KEY_END:
self.pos = len(self.value)
else:
return False
self.update()
return True
def on_key(self, ch):
if not self.active:
return
if self.selected:
if ch in (curses.ascii.ESC, curses.KEY_BACKSPACE):
self.cancel_selection()
elif ch == curses.KEY_LEFT:
if self.selection > 0 and self.selection < 4 or self.selection > 4:
self.set_selection(self.selection - 1)
elif ch == curses.KEY_RIGHT:
if self.selection < 3 or self.selection > 3 and self.selection < 7:
self.set_selection(self.selection + 1)
elif ch == curses.KEY_UP:
if self.selection > 3:
self.set_selection(self.selection - 4)
elif ch == curses.KEY_DOWN:
if self.selection < 4 and self.selected_source == 'hand':
self.set_selection(self.selection + 4)
elif ch in (curses.KEY_ENTER, curses.ascii.SP):
self.confirm_selection()
else:
if ch == curses.KEY_LEFT:
if self.selection > 0:
self.set_selection(self.selection - 1)
elif ch == curses.KEY_RIGHT:
if self.selection + 1 < len(self.selectable_sources):
self.set_selection(self.selection + 1)
elif ch in (curses.KEY_ENTER, curses.ascii.SP):
self.confirm_selection()
def poll_event(self):
"""
Checks if an event happens and returns a string related to the event.
Returns -1 if nothing happened during self.screen.timeout milliseconds.
If the event is a normal (letter) key press,
the letter is returned (case sensitive)
:return: Event type
"""
self.mutex.acquire()
ch = self.screen.getch()
self.mutex.release()
if ch == -1:
return EVENT_SKIP
elif ch == 27:
return EVENT_ESC
elif ch == curses.KEY_RESIZE:
return EVENT_RESIZE
elif ch == 10 or ch == curses.KEY_ENTER:
return EVENT_ENTER
elif ch == 127 or ch == curses.KEY_BACKSPACE:
return EVENT_BACKSPACE
elif ch == curses.KEY_UP:
return EVENT_UP
elif ch == curses.KEY_DOWN:
return EVENT_DOWN
elif ch == curses.KEY_LEFT:
return EVENT_LEFT
elif ch == curses.KEY_RIGHT:
return EVENT_RIGHT
elif ch == 3:
return EVENT_CTRL_C
elif ch == 409:
return EVENT_CLICK
elif 0 <= ch < 256:
return chr(ch)
else:
return EVENT_UNHANDLED
def test_should_move_cursor_right(self):
input = TextInput(max_len=10)
input.put('a')
input.put(curses.KEY_LEFT)
input.put(curses.KEY_RIGHT)
self.assertEqual(1, input.cursor)
def test_should_not_move_cursor_after_right_boundary(self):
input = TextInput(max_len=10)
input.put('a')
input.put(curses.KEY_RIGHT)
self.assertEqual(1, input.cursor)
def test_should_handle_key_right(self):
self._parent_window.getmaxyx.return_value = (9, 30)
win = Datetime(self._manager, 'Date', datetime.datetime.utcnow())
win.handle_key(curses.KEY_RIGHT)
win.refresh()
self._child_window.chgat.assert_called_once_with(2, 7, 2, 0)
def test_should_handle_key_left(self):
self._parent_window.getmaxyx.return_value = (9, 30)
win = Datetime(self._manager, 'Date', datetime.datetime.utcnow())
win.handle_key(curses.KEY_RIGHT)
win.handle_key(curses.KEY_LEFT)
win.refresh()
self._child_window.chgat.assert_called_once_with(2, 2, 4, 0)
def command(self, char):
"""handle page specific commands"""
if char == curses.KEY_DOWN or char == ord('j'):
if self.pad_pos < self.row_count-1:
self.pad_pos += 1
elif char == curses.KEY_UP or char == ord('k'):
if self.pad_pos > 0:
self.pad_pos -= 1
elif char == curses.KEY_NPAGE or char == ord('J'):
if self.pad_pos < self.row_count-((self.max_y)/2):
self.pad_pos += (self.max_y)/2
else:
self.pad_pos = self.row_count-1
elif char == curses.KEY_PPAGE or char == ord('K'):
if self.pad_pos > ((self.max_y)/2):
self.pad_pos -= (self.max_y)/2
else:
self.pad_pos = 0
elif char == curses.KEY_RIGHT or char == ord('l'):
if self.row_index[self.pad_pos][0] == 'vessel':
vessel = self.row_index[self.pad_pos][1]
return ('VESSEL_DETAIL', vessel)
if self.row_index[self.pad_pos][0] == 'target':
vessel = self.row_index[self.pad_pos][1]
path = self.row_index[self.pad_pos][2]
return ('TARGET_DETAIL', (vessel, path))
return (None, None)
def _create_pocket(self):
pocket_name = ""
while True:
self.screen.clear()
self._draw_tab_bar()
self.screen.addstr(2, 2, "Pocket name:")
self.screen.addstr(4, 4, pocket_name)
c = self.screen.getch()
if c == 27:
self._status = "Cancelled"
break
elif c == curses.KEY_ENTER or c == 10 or c == 13:
ec = await api.Pocket.create(self._ws, pocket_name)
if ec:
self._status = ec.name
else:
self._status = "Created"
break
elif c == curses.KEY_BACKSPACE:
pocket_name = pocket_name[:-1]
elif c == curses.KEY_LEFT or c == curses.KEY_RIGHT:
pass
else:
pocket_name += chr(c)
def _enter_password_tab2(self):
password = ""
while True:
self.screen.clear()
self._draw_tab_bar()
self.screen.addstr(2, 2, "Password:")
self.screen.addstr(4, 2, "*" * len(password))
c = self.screen.getch()
if c == curses.KEY_BACKSPACE:
password = password[:-1]
elif c == curses.KEY_ENTER or c == 10 or c == 13:
return password
elif c == curses.KEY_LEFT:
self._current_tab -= 1
if self._current_tab < 0:
self._current_tab = len(self._account_names) - 1
await self._activate_account()
return None
elif c == curses.KEY_RIGHT:
self._current_tab += 1
if self._current_tab >= len(self._account_names):
self._current_tab = 0
await self._activate_account()
return None
else:
password += chr(c)
def display(self):
self.window.clear()
self.showdetail()
while True:
self.has_focus = True
self.next_window.has_focus = False
self.window.refresh()
curses.doupdate()
self.update()
key = self.window.getch()
if key in [curses.KEY_ENTER, ord('\n')]:
return self.position
if key == curses.KEY_UP:
if self.position == 0:
self.navigate(self.last_item_index)
else:
self.navigate(-1)
elif key == curses.KEY_DOWN:
self.navigate(1)
elif key == curses.KEY_RIGHT or key == curses.KEY_LEFT:
self.has_focus = False
self.update()
self.next_window.display()
def display(self):
self.window.clear()
self.showdetail()
while True:
self.has_focus = True
self.next_window.has_focus = False
self.window.refresh()
curses.doupdate()
self.update()
key = self.window.getch()
if key in [curses.KEY_ENTER, ord('\n')]:
self.action()
return
if key == curses.KEY_UP:
if self.position == 0:
self.navigate(self.last_item_index)
else:
self.navigate(-1)
elif key == curses.KEY_DOWN:
self.navigate(1)
elif key == curses.KEY_RIGHT or key == curses.KEY_LEFT:
self.has_focus = False
self.update()
return
# TODO: scrolling this
