def main():
environ["TERM"] = 'Eterm'
initscr()
curs_set(0)
try:
win = newwin(16, 60, 0, 0)
win.keypad(True)
win.nodelay(True)
win.border('|', '|', '-', '-', '+', '+', '+', '+')
win.addch(4, 44, '@')
win.addstr(0, 5, ' Eat all the OPNFV bugs by FunTest! ')
win.addstr(15, 7, ' Left,Right,Up,Down: move; other keys: quit ')
snake = [[20, 7], [19, 7], [18, 7], [17, 7],
[16, 7], [15, 7], [14, 7], [13, 7]]
key = KEY_RIGHT
body = '~FUNTEST'
ind = 0
while key != 27:
win.addstr(0, 44, ' Score: ' + str(len(snake) - len(body)) + ' ')
win.timeout(140 - 2 * len(snake))
getkey = win.getch()
key = key if getkey == -1 else getkey
snake.insert(
0, [snake[0][0] + (key == KEY_RIGHT and 1 or
key == KEY_LEFT and -1),
snake[0][1] + (key == KEY_DOWN and 1 or
key == KEY_UP and -1)])
win.addch(snake[len(snake) - 1][1], snake[len(snake) - 1][0], ' ')
if win.inch(snake[0][1], snake[0][0]) & 255 == 32:
snake.pop()
elif win.inch(snake[0][1], snake[0][0]) & 255 == ord('@'):
c = [n for n in [[randrange(1, 58, 1), randrange(1, 14, 1)]
for x in range(len(snake))] if n not in snake]
win.addch(c == [] and 4 or c[0][1],
c == [] and 44 or c[0][0], '@')
else:
break
ind += 1
win.addch(snake[0][1], snake[0][0], body[ind % len(body)])
finally:
endwin()
print('\nSnake.PY-26ines by Kris Cieslak (defaultset.blogspot.com).')
print('OPNFV adaptation by Functest dream team.')
score = str(len(snake) - len(body) - 1)
print ('Thanks for playing, your score: %s.' % score)
print('Find and fix more bugs in your real OPNFV setup!\n')
python类KEY_RIGHT的实例源码
def keys_init(self):
"""Define methods for each key.
"""
self.keys = {
curses.KEY_BACKSPACE: self.backspace,
CTRL('h'): self.backspace,
curses.ascii.BS: self.backspace,
curses.ascii.DEL: self.backspace,
curses.ascii.ETX: self.close,
curses.KEY_DC: self.del_char,
CTRL('d'): self.del_char,
CTRL('u'): self.del_to_bol,
CTRL('k'): self.del_to_eol,
curses.KEY_DOWN: self.down,
CTRL('n'): self.down,
curses.KEY_END: self.end,
CTRL('e'): self.end,
curses.KEY_F1: self.help,
curses.KEY_HOME: self.home,
CTRL('a'): self.home,
curses.KEY_ENTER: self.insert_line_or_quit,
curses.ascii.NL: self.insert_line_or_quit,
curses.ascii.LF: self.insert_line_or_quit,
"\n": self.insert_line_or_quit,
curses.KEY_LEFT: self.left,
CTRL('b'): self.left,
curses.KEY_NPAGE: self.page_down,
curses.KEY_PPAGE: self.page_up,
CTRL('v'): self.paste,
CTRL('x'): self.quit,
curses.KEY_F2: self.quit,
curses.KEY_F3: self.quit_nosave,
curses.ascii.ESC: self.quit_nosave,
curses.KEY_RESIZE: self.resize,
-1: self.resize,
curses.KEY_RIGHT: self.right,
CTRL('f'): self.right,
curses.KEY_UP: self.up,
CTRL('p'): self.up,
}
def keypress(self, char):
# right arrow select a user/group to chat with
if char == curses.KEY_RIGHT:
self.refresh_body()
self.update_chat()
self.showing = self.selection
current_id = self.slack_client.active[self.showing].id
current_name = self.slack_client.active[self.showing].name
for m in self.slack_client.last_messages(current_id):
self.push_chat(m['user'], m['text'])
return
# moves to the user/group below current selection
elif char == curses.KEY_DOWN:
if self.selection < len(self.slack_client.active) - 1:
self.set_body_selection(self.selection + 1)
self.refresh_body()
return
# move cursor one position up
elif char == curses.KEY_UP:
if self.selection > 0:
self.set_body_selection(self.selection - 1)
self.refresh_body()
return
# send the content on the textbox
elif char == curses.KEY_ENTER or chr(char) == "\n":
# Fixme: send message as 'me', should be username
self.push_chat('me', self.text)
self.send_text()
return
# delete a character
elif chr(char) == self.del_char or chr(char) == "\x7f":
self.backspace()
return
# send the char to textbox area
else:
self.text += chr(char)
self.refresh_textarea(char)
return
# This method is callable for testing porpuses only
def runDateTime(scr, rollover, topString, bottomString, start=None):
if(rollover):
if(start is None):
d = date.today()
t = time()
else:
d = date(start.year, start.month, start.day)
t = time(start.hour, start.minute, start.second)
else:
if(start is None):
d = datetime.date.today()
t = datetime.time()
else:
d = datetime.date(start.year, start.month, start.day)
t = datetime.time(start.hour, start.minute, start.second)
c = curses.KEY_MAX
cursor = 3
while(c != 10):
displayDateTime(scr, d, t, cursor, topString, bottomString)
c = scr.getch()
if(c == curses.KEY_RIGHT) and cursor < 18:
cursor += 1
if(cursor in (4, 7, 10, 13, 16)):
cursor += 1
elif(c == curses.KEY_LEFT) and cursor > 0:
cursor -= 1
if(cursor in (4, 7, 10, 13, 16)):
cursor -= 1
elif(c == curses.KEY_UP):
if(cursor < 10):
d = alterDigitDay(cursor, d, 1)
else:
t = alterDigitTime(cursor - 11, t, 1)
elif(c == curses.KEY_DOWN):
if(cursor < 10):
d = alterDigitDay(cursor, d, -1)
else:
t = alterDigitTime(cursor - 11, t, -1)
else:
try:
i = int(c) - 48
if(i >= 0 and i < 10):
if(cursor < 10):
d = updateDigitDay(cursor, d, i)
else:
t = updateDigitTime(cursor - 11, t, i)
except ValueError:
pass
return datetime.datetime(d.year, d.month, d.day,
t.hour, t.minute, t.second)
def c_main(stdscr):
cargo_cult_routine(stdscr)
stdscr.nodelay(0)
mydir = factory(start)
mydir.expand()
curidx = 3
pending_action = None
pending_save = False
while True:
stdscr.clear()
curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLUE)
line = 0
offset = max(0, curidx - curses.LINES + 3)
for data, depth in mydir.traverse():
if line == curidx:
stdscr.attrset(curses.color_pair(1) | curses.A_BOLD)
if pending_action:
getattr(data, pending_action)()
pending_action = None
elif pending_save:
global result
result = data.name
return
else:
stdscr.attrset(curses.color_pair(0))
if 0 <= line - offset < curses.LINES - 1:
stdscr.addstr(line - offset, 0,
data.render(depth, curses.COLS))
line += 1
stdscr.refresh()
ch = stdscr.getch()
if ch == curses.KEY_UP:
curidx -= 1
elif ch == curses.KEY_DOWN:
curidx += 1
elif ch == curses.KEY_PPAGE:
curidx -= curses.LINES
if curidx < 0: curidx = 0
elif ch == curses.KEY_NPAGE:
curidx += curses.LINES
if curidx >= line: curidx = line - 1
elif ch == curses.KEY_RIGHT:
pending_action = 'expand'
elif ch == curses.KEY_LEFT:
pending_action = 'collapse'
elif ch == ESC:
return
elif ch == ord('\n'):
pending_save = True
curidx %= line
################################################################################
def on_key(self, ch):
if not self.active or self.disabled:
return
if not self.active.on_key(ch):
y, x = self.position(self.active)
if ch == curses.KEY_UP:
if y > 0:
self.set_active(self.rows[y - 1][self.defaults[y - 1]])
elif ch in (curses.KEY_DOWN, curses.KEY_ENTER):
if y < len(self.rows) - 1:
self.set_active(self.rows[y + 1][self.defaults[y + 1]])
elif ch == curses.KEY_LEFT:
if x > 0:
self.set_active(self.rows[y][x - 1])
elif ch == curses.KEY_RIGHT:
if x < len(self.rows[y]) - 1:
self.set_active(self.rows[y][x + 1])
elif ch == curses.ascii.TAB:
# Right
if x < len(self.rows[y]) - 1:
self.set_active(self.rows[y][x + 1])
# Down, ignoring defaults
elif y < len(self.rows) - 1:
self.set_active(self.rows[y + 1][0])
else:
self.set_active(self.rows[0][0])
elif ch == curses.KEY_BTAB:
# Left
if x > 0:
self.set_active(self.rows[y][x - 1])
# Up
elif y > 0:
col = len(self.rows[y - 1]) - 1
self.set_active(self.rows[y - 1][col])
else:
row = len(self.rows) - 1
col = len(self.rows[row]) - 1
self.set_active(self.rows[row][col])
def keyloop(stdscr):
# Clear the screen and display the menu of keys
stdscr.clear()
stdscr_y, stdscr_x = stdscr.getmaxyx()
menu_y = (stdscr_y-3)-1
display_menu(stdscr, menu_y)
# Allocate a subwindow for the Life board and create the board object
subwin = stdscr.subwin(stdscr_y-3, stdscr_x, 0, 0)
board = LifeBoard(subwin, char=ord('*'))
board.display(update_board=False)
# xpos, ypos are the cursor's position
xpos, ypos = board.X//2, board.Y//2
# Main loop:
while (1):
stdscr.move(1+ypos, 1+xpos) # Move the cursor
c = stdscr.getch() # Get a keystroke
if 0<c<256:
c = chr(c)
if c in ' \n':
board.toggle(ypos, xpos)
elif c in 'Cc':
erase_menu(stdscr, menu_y)
stdscr.addstr(menu_y, 6, ' Hit any key to stop continuously '
'updating the screen.')
stdscr.refresh()
# Activate nodelay mode; getch() will return -1
# if no keystroke is available, instead of waiting.
stdscr.nodelay(1)
while (1):
c = stdscr.getch()
if c != -1:
break
stdscr.addstr(0,0, '/')
stdscr.refresh()
board.display()
stdscr.addstr(0,0, '+')
stdscr.refresh()
stdscr.nodelay(0) # Disable nodelay mode
display_menu(stdscr, menu_y)
elif c in 'Ee':
board.erase()
elif c in 'Qq':
break
elif c in 'Rr':
board.makeRandom()
board.display(update_board=False)
elif c in 'Ss':
board.display()
else: pass # Ignore incorrect keys
elif c == curses.KEY_UP and ypos>0: ypos -= 1
elif c == curses.KEY_DOWN and ypos<board.Y-1: ypos += 1
elif c == curses.KEY_LEFT and xpos>0: xpos -= 1
elif c == curses.KEY_RIGHT and xpos<board.X-1: xpos += 1
else:
# Ignore incorrect keys
pass
def game_loop(stdscr, columns, rows, num_mines):
game = minesweeper.Game.create_random(columns, rows, num_mines)
Point = namedtuple('Point', ['x', 'y'], verbose=True)
cursor_pos = Point(0, 0)
while True:
stdscr.clear()
game_rect = draw_screen(stdscr, game)
# restrict cursor to the game field
cursor_pos = Point(
clamp(cursor_pos.x, game_rect.x, game_rect.x+game_rect.width-1),
clamp(cursor_pos.y, game_rect.y, game_rect.y+game_rect.height-1)
)
stdscr.move(cursor_pos.y, cursor_pos.x)
stdscr.refresh()
c = stdscr.getch()
if c == curses.KEY_LEFT:
cursor_pos = Point(cursor_pos.x-2, cursor_pos.y)
if c == curses.KEY_RIGHT:
cursor_pos = Point(cursor_pos.x+2, cursor_pos.y)
if c == curses.KEY_UP:
cursor_pos = Point(cursor_pos.x, cursor_pos.y-1)
if c == curses.KEY_DOWN:
cursor_pos = Point(cursor_pos.x, cursor_pos.y+1)
if c == curses.KEY_ENTER or c == 10:
game.toggle_mark(*cursor_to_index(cursor_pos, game_rect))
if c == " " or c == 32:
game.reveal(*cursor_to_index(cursor_pos, game_rect))
if c == 27: # Escape
selected = open_menu(stdscr, ["Continue", "New Game", "Exit"])
if selected == "Exit":
return
elif selected == "New Game":
columns, rows, num_mines = open_difficulty_menu(stdscr)
return game_loop(stdscr, columns, rows, num_mines)
if game.is_lost() or game.is_solved():
# reveal the complete solution
game.reveal_all()
stdscr.clear()
draw_screen(stdscr, game)
# wait for user to press any key
curses.curs_set(False)
c = stdscr.getch()
curses.curs_set(True)
break
def start(self):
self._status = ""
self._active_account = None
self._active_pocket = None
while True:
self._active_account, self._account_names = \
await api.Account.list(self._ws)
if self._active_account is not None:
break
await self._select_account()
self._current_tab = self._account_names.index(self._active_account)
self._current_pocket = 0
while True:
await self.display_main_window()
c = self.screen.getch()
if c == curses.KEY_RIGHT and len(self._account_names) > 1:
self._current_tab += 1
if self._current_tab >= len(self._account_names):
self._current_tab = 0
await self._activate_account()
elif c == curses.KEY_LEFT and len(self._account_names) > 1:
self._current_tab -= 1
if self._current_tab < 0:
self._current_tab = len(self._account_names) - 1
await self._activate_account()
elif c == curses.KEY_DOWN:
self._current_pocket += 1
if self._current_pocket > len(self._pockets) + 1:
self._current_pocket = 0
elif c == curses.KEY_UP:
self._current_pocket -= 1
if self._current_pocket < 0:
self._current_pocket = len(self._pockets) + 1
elif c == curses.KEY_ENTER or c == 10 or c == 13:
if self._current_pocket == len(self._pockets) + 1:
await self._create_pocket()
else:
await self._send_screen()
def _send_screen(self):
ec, self._history = await api.Wallet.history(self._ws,
self._active_pocket)
self._send_fields = ["", "", "", ""]
self._selected_send_item = 0
while True:
await self._display_history()
c = self.screen.getch()
if c == curses.KEY_UP:
self._selected_send_item -= 1
if self._selected_send_item < 0:
self._selected_send_item = 3
elif c == curses.KEY_DOWN:
self._selected_send_item += 1
if self._selected_send_item > 3:
self._selected_send_item = 0
elif c == curses.KEY_ENTER or c == 10 or c == 13:
if self._selected_send_item == 0:
break
_, addr, amount, fee = self._send_fields
try:
decimal.Decimal(amount)
except decimal.InvalidOperation:
self._status = "Invalid amount"
break
try:
decimal.Decimal(fee)
except decimal.InvalidOperation:
self._status = "Invalid fee"
break
addr_type = await api.Daemon.validate_address(self._ws,
addr)
if addr_type == "invalid":
self._status = "Invalid address"
break
dests = [(addr, amount)]
ec, tx_hash = await api.Wallet.send(self._ws, dests, fee=fee,
pocket=self._active_pocket)
if ec:
self._status = ec.name
else:
self._status = "Sent %s" % tx_hash
break
elif c == curses.KEY_BACKSPACE:
self._send_fields[self._selected_send_item] = \
self._send_fields[self._selected_send_item][:-1]
elif c == curses.KEY_LEFT or c == curses.KEY_RIGHT:
pass
else:
self._send_fields[self._selected_send_item] += chr(c)
