def Go(self):
key2Direction = {\
curses.KEY_UP : Vector((-1, 0)),\
curses.KEY_LEFT : Vector(( 0,-1)),\
curses.KEY_DOWN : Vector((+1, 0)),\
curses.KEY_RIGHT : Vector(( 0,+1)),\
}
null = Vector((0, 0))
self.alive = True
while self.alive:
# Wait a little for keypress
key = self.pad.getch()
if key in key2Direction:
if null != self.snakeDirection + key2Direction[key]:
self.snakeDirection = key2Direction[key]
elif ord('q') == key:
self.alive = False
break
self.Increment()
# Nuke curses
self.pad.keypad(0)
curses.curs_set(1)
curses.echo()
curses.endwin()
return
def dir_list(self, path="/usr/share/snmp/mibs/"):
self.window.clear()
self.window.move(0,0)
max_y, max_x = self.window.getmaxyx()
beg_y, beg_x = self.window.getbegyx()
cursor_y, cursor_x = self.window.getyx()
#first output the [..] for parent dir
self.window.addstr("../")
cursor_y = cursor_y + 1
self.window.move(cursor_y, 0)
for dirname, dirnames, filenames in os.walk(path):
for subdirname in dirnames:
self.window.attron(curses.color_pair(5))
self.window.addstr(subdirname[:25] + "/")
self.window.attroff(curses.color_pair(5))
cursor_y = cursor_y + 1
self.window.move(cursor_y, 0)
for file in filenames:
if (cursor_y + 1 < max_y):
self.window.addstr(file)
cursor_y = cursor_y + 1
self.window.move(cursor_y, 0)
self.window.move(0,0)
self.window.chgat(curses.A_REVERSE)
curses.curs_set(0)
def init_curses(self):
self.screen = curses.initscr()
curses.noecho()
curses.start_color()
curses.cbreak()
self.screen.keypad(0)
curses.curs_set(0)
def __init__(self, wallet, config, app=None):
self.stdscr = curses.initscr()
curses.noecho()
curses.cbreak()
curses.start_color()
curses.use_default_colors()
curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLUE)
curses.init_pair(2, curses.COLOR_WHITE, curses.COLOR_CYAN)
self.stdscr.keypad(1)
self.stdscr.border(0)
self.maxy, self.maxx = self.stdscr.getmaxyx()
curses.curs_set(0)
self.w = curses.newwin(10, 50, 5, 5)
self.wallet = wallet
self.config = config
set_verbosity(False)
self.tab = 0
self.pos = 0
self.popup_pos = 0
self.str_recipient = ""
self.str_description = ""
self.str_amount = ""
self.str_fee = ""
self.wallet.interface.register_callback('updated', self.refresh)
self.wallet.interface.register_callback('connected', self.refresh)
self.wallet.interface.register_callback('disconnected', self.refresh)
self.wallet.interface.register_callback('disconnecting', self.refresh)
self.tab_names = [_("History"), _("Send"), _("Receive"), _("Contacts"), _("Wall")]
self.num_tabs = len(self.tab_names)
def __init__ (self):
self.board = puzzle_2048()
self.screen = curses.initscr()
self.screen.keypad(1)
self.screen.leaveok(0)
curses.start_color()
curses.init_pair(1, curses.COLOR_GREEN, curses.COLOR_BLACK)
curses.noecho()
curses.curs_set(0)
self.screen.addstr(0,0,"To play: combine the tiles that match using the arrow keys, and press esc to exit")
#Drawing the lines for the board
self.screen.hline(5,10,"-", 29, curses.color_pair(1))
self.screen.hline(9,10,"-", 29, curses.color_pair(1))
self.screen.hline(13,10,"-", 29, curses.color_pair(1))
self.screen.hline(17,10,"-", 29, curses.color_pair(1))
self.screen.hline(21,10,"-", 29, curses.color_pair(1))
self.screen.vline(5,10,"|", 17, curses.color_pair(1))
self.screen.vline(5,17,"|", 17, curses.color_pair(1))
self.screen.vline(5,24,"|", 17, curses.color_pair(1))
self.screen.vline(5,31,"|", 17, curses.color_pair(1))
self.screen.vline(5,38,"|", 17, curses.color_pair(1))
self.Update_screen()
self.run()
def setup(self, stdscr):
if logger.isEnabledFor(logging.DEBUG):
logger.debug("GUI initialization")
self.stdscr = stdscr
try:
curses.curs_set(0)
except:
pass
curses.init_pair(1, curses.COLOR_CYAN, curses.COLOR_BLACK)
curses.init_pair(2, curses.COLOR_BLUE, curses.COLOR_BLACK)
curses.init_pair(3, curses.COLOR_YELLOW, curses.COLOR_BLACK)
curses.init_pair(4, curses.COLOR_GREEN, curses.COLOR_BLACK)
curses.init_pair(5, curses.COLOR_WHITE, curses.COLOR_BLACK)
curses.init_pair(6, curses.COLOR_BLACK, curses.COLOR_MAGENTA)
curses.init_pair(7, curses.COLOR_BLACK, curses.COLOR_GREEN)
curses.init_pair(8, curses.COLOR_MAGENTA, curses.COLOR_BLACK)
curses.init_pair(9, curses.COLOR_BLACK, curses.COLOR_GREEN)
self.log = Log()
# For the time being, supported players are mplayer and vlc.
self.player = player.probePlayer()(self.log)
self.stdscr.nodelay(0)
self.setupAndDrawScreen()
self.run()
def receive_command(self):
numlines, numcols = self.get_termsize()
# clear command line
cl = ""
for i in range(numcols-1):
cl += " "
self.screen.addstr(numlines-1, 0, cl)
# get command w/ visual response
self.dontupdate.acquire()
curses.echo()
curses.curs_set(1)
self.screen.addstr(numlines-1, 0, ":")
command = self.screen.getstr(numlines-1, 1)
curses.curs_set(0)
curses.noecho()
self.dontupdate.release()
if command == 'q':
self.running = False
else:
self.screen.addstr(numlines-1,0,"received unknown command:\"%s\"" %
(command,))
def start_combat(self, unit):
attacker = unit
self.enemy = attacker
status = self.var_handler.get('status_handler')
io = self.var_handler.get('io_handler')
command_processor = self.var_handler.get('command_processor')
player = self.var_handler.get('player')
hud = self.var_handler.get('hud_handler')
self.combat = True
io.output("You enter combat with a {0}".format(attacker.display_name), curses.color_pair(2))
status.end_sequence()
status.output("You are attacked by: {0}".format(attacker.display_name))
hud.text_update()
while self.combat:
curses.curs_set(1)
input = io.get_input(">>>>>>>:", curses.color_pair(2))
if input.split(" ")[0] in self.commands:
if "attack" in input:
output = self.attack(player, attacker)
elif input == "run":
output = self.run(attacker)
elif input.split(" ")[0] == "cast":
output = self.cast(input.split(" ")[1])
else:
output = command_processor.receive_command(input)
if attacker.state == "dead":
self.combat = False
self.enemy = None
output = (output[0] + "\nYou kill the {0}".format(attacker.display_name), output[1])
else:
output = ("You can't do that in combat", curses.color_pair(2))
io.output(output[0], output[1])
hud.text_update()
status.start_sequence()
def init(self):
self.window = curses.initscr()
self.initted = True
self.ymax, self.xmax = self.window.getmaxyx()
terminfo = curses.longname()
assert '256' in terminfo # your env TERM must be xterm-256color!
assert curses.has_colors()
curses.start_color()
curses.use_default_colors()
ctr = 1
for fg in CLRS:
for bg in CLRS:
if ctr <= curses.COLORS-1 and fg != bg:
curses.init_pair(ctr, CLRS[fg], CLRS[bg])
pairs[(fg,bg)] = curses.color_pair(ctr)
ctr += 1
curses.meta(1)
curses.noecho()
curses.cbreak()
curses.curs_set(0)
curses.delay_output(0)
curses.mouseinterval(150)
availmask,_ = curses.mousemask(curses.ALL_MOUSE_EVENTS)
assert availmask != 0 # mouse must be available!
self.window.leaveok(1)
self.window.scrollok(0)
self.window.keypad(1)
if NONBLOCKING:
self.window.nodelay(1)
self.window.timeout(NONBLOCKING_TIMEOUT)
else:
self.window.nodelay(0)
self.window.timeout(-1)
self.window.refresh()
def __init__(self, stdscr, encoding=None):
self.formatted_rows = None
self.torrent_names = None
self.cursel = 1
self.curoff = 1 # TODO: this should really be 0 indexed
self.column_string = ""
self.popup = None
self.messages = deque()
self.marked = []
self.last_mark = -1
self._sorted_ids = None
self._go_top = False
self._curr_filter = None
self.entering_search = False
self.search_string = None
self.cursor = 0
self.coreconfig = component.get("ConsoleUI").coreconfig
self.legacy_mode = None
self.__status_dict = {}
self.__torrent_info_id = None
BaseMode.__init__(self, stdscr, encoding)
component.Component.__init__(self, "AllTorrents", 1, depend=["SessionProxy"])
curses.curs_set(0)
self.stdscr.notimeout(0)
self.__split_help()
self.update_config()
component.start(["AllTorrents"])
self._info_fields = [
("Name",None,("name",)),
("State", None, ("state",)),
("Down Speed", format_utils.format_speed, ("download_payload_rate",)),
("Up Speed", format_utils.format_speed, ("upload_payload_rate",)),
("Progress", format_utils.format_progress, ("progress",)),
("ETA", deluge.common.ftime, ("eta",)),
("Path", None, ("save_path",)),
("Downloaded",deluge.common.fsize,("all_time_download",)),
("Uploaded", deluge.common.fsize,("total_uploaded",)),
("Share Ratio", format_utils.format_float, ("ratio",)),
("Seeders",format_utils.format_seeds_peers,("num_seeds","total_seeds")),
("Peers",format_utils.format_seeds_peers,("num_peers","total_peers")),
("Active Time",deluge.common.ftime,("active_time",)),
("Seeding Time",deluge.common.ftime,("seeding_time",)),
("Date Added",deluge.common.fdate,("time_added",)),
("Availability", format_utils.format_float, ("distributed_copies",)),
("Pieces", format_utils.format_pieces, ("num_pieces","piece_length")),
]
self.__status_keys = ["name","state","download_payload_rate","upload_payload_rate",
"progress","eta","all_time_download","total_uploaded", "ratio",
"num_seeds","total_seeds","num_peers","total_peers", "active_time",
"seeding_time","time_added","distributed_copies", "num_pieces",
"piece_length","save_path"]
def on_gain_focus(self):
self.state = 'current'
curses.curs_set(1)
tab = self.core.get_tab_by_name(safeJID(self.name).bare, MucTab)
if tab and tab.joined and config.get_by_tabname('send_chat_states',
self.general_jid,) and not self.input.get_text() and self.on:
self.send_chat_state('active')
def init_and_run(self, stdscr):
""" called by ncurses.wrapper """
self.stdscr = stdscr
try:
curses.curs_set(0)
except:
pass
curses.init_pair(1, curses.COLOR_CYAN, curses.COLOR_BLACK)
curses.init_pair(2, curses.COLOR_WHITE, curses.COLOR_BLACK)
curses.init_pair(3, curses.COLOR_GREEN, curses.COLOR_BLACK)
curses.init_pair(4, curses.COLOR_YELLOW, curses.COLOR_BLACK)
curses.init_pair(5, curses.COLOR_RED, curses.COLOR_BLACK)
self.max_y, self.max_x = stdscr.getmaxyx()
self.head_win = curses.newwin(4, self.max_x, 0, 0)
self.body_win = curses.newwin(self.max_y-4, self.max_x, 4, 0)
self.init_head_win()
self.init_body_win()
curses.doupdate()
self.run()
def main(argv):
global mines, board
args = map(int, argv[1:])
xw = int(args[0]) if args else 20
yw = int(args[1]) if len(args) > 1 else xw / 2
mines = int(args[2]) if len(args) > 2 else int(xw * yw / 20)
board = [' ' * xw for i in range(yw)]
mines = {(randint(0, xw), randint(0, yw)) : True for i in range(mines)}
scr = curses.initscr()
scr.keypad(1)
curses.curs_set(0)
curses.noecho()
curses.mousemask(curses.ALL_MOUSE_EVENTS)
while True:
scr.clear()
k = scr.getch()
scr.addstr(yw + 2, 0, ': ' + str(k))
if k == 27:
break
elif k == curses.KEY_MOUSE:
_, x, y, z, bstate = curses.getmouse()
scr.addstr(y, x, ' '.join(str(v) for v in (z, bstate)))
elif k == curses.KEY_DC:
boom(scr)
scr.clear()
curses.endwin()
def setup():
"""
sets environment up and creates main window
:returns: the main window object
"""
# setup the console
mmask = curses.ALL_MOUSE_EVENTS # for now accept all mouse events
main = curses.initscr() # get a window object
y,x = main.getmaxyx() # get size
if y < 24 or x < 80: # verify minimum size rqmts
raise RuntimeError("Terminal must be at least 80 x 24")
curses.noecho() # turn off key echoing
curses.cbreak() # turn off key buffering
curses.mousemask(mmask) # accept mouse events
initcolors() # turn on and set color pallet
main.keypad(1) # let curses handle multibyte special keys
main.clear() # erase everything
banner(main) # write the banner
mainmenu(main) # then the min and menu
main.attron(CPS[RED]) # make the border red
main.border(0) # place the border
main.attroff(CPS[RED]) # turn off the red
curses.curs_set(0) # hide the cursor
main.refresh() # and show everything
return main
def __init__(self, evm):
self.evm = evm
evm.RegisterListener(self)
# first we must create a window object; it will fill the whole screen
self.scrn = curses.initscr()
# turn off keystroke echo
curses.noecho()
# keystrokes are honored immediately, rather than waiting for the
# user to hit Enter
curses.cbreak()
self.scrn.keypad(1)
self.scrn.nodelay(1)
# start color display (if it exists; could check with has_colors())
curses.start_color()
curses.mousemask(curses.BUTTON1_PRESSED)
curses.curs_set(0)
# clear screen
self.scrn.clear()
i = 1
for color_background in self.list_of_colors:
for color_foreground in self.list_of_colors:
curses.init_pair(i, color_foreground, color_background)
self.mapping[color_foreground, color_background] = i
i += 1
# implement the actions done so far (just the clear())
self.scrn.refresh()
def main():
"""
Main entry point for gunicorn_console.
"""
# Set up curses.
stdscr = curses.initscr()
curses.start_color()
curses.init_pair(1, foreground_colour, background_colour)
curses.noecho()
stdscr.keypad(True)
stdscr.nodelay(True)
try:
curses.curs_set(False)
except:
pass
try:
# Run main event loop until quit.
while True:
try:
update_gunicorns()
handle_keypress(stdscr)
display_output(stdscr)
curses.napms(int(screen_delay * 1000))
except KeyboardInterrupt:
break
finally:
# Tear down curses.
curses.nocbreak()
stdscr.keypad(False)
curses.echo()
curses.endwin()
def __init__(self, player_sub):
self.player_sub = player_sub
# self.sea = sea
self.display_screen = ''
# setlocale enables UTF chars
# see: https://docs.python.org/2/library/curses.html
locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
self.strcode = locale.getpreferredencoding()
# print(self.strcode)
screen = curses.initscr()
self.screen = screen
# Applications will also commonly need to react to keys instantly, without requiring the Enter key
# to be pressed; this is called cbreak mode, as opposed to the usual buffered input mode.
curses.cbreak()
# Usually curses applications turn off automatic echoing of keys to the screen, in order to be able to read
# keys and only display them under certain circumstances. This requires calling the noecho() function.
curses.noecho()
screen.nodelay(1)
curses.curs_set(0)
screen.keypad(True)
curses.start_color()
curses.use_default_colors()
def end_interface(self): # {{{
self.stdscr.erase()
self.stdscr.refresh()
curses.curs_set(1)
curses.nocbreak()
curses.echo()
curses.endwin()
def start_interface(self): # {{{
self.stdscr = curses.initscr()
curses.noecho()
curses.cbreak()
self.stdscr.keypad(1)
curses.curs_set(0)
self.mainloop()
def main(stdscr):
"""Main function"""
# Let the cursor be invisible
curses.curs_set(False)
x = 0
y = 0
while True:
# Clear screen
stdscr.clear()
# Print a message
stdscr.addstr('Press any key (q to quit).')
stdscr.addstr(3, 0, "{},{}".format(x, y))
# Display the message
stdscr.refresh()
# Wait for a key
c = stdscr.getch()
if c == ord('q'):
break # Exit the while loop
elif c == curses.KEY_DOWN:
y -= 1
elif c == curses.KEY_UP:
y += 1
elif c == curses.KEY_LEFT:
x -= 1
elif c == curses.KEY_RIGHT:
x += 1
def setScreen(self, scr):
"""
Set the screen and create the different windows
"""
log(self.__class__.__name__, sys._getframe().f_code.co_name)
self.stdscr = scr
if self.stdscr != None:
curses.curs_set(0)
curses.start_color()
curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLUE)
curses.halfdelay(2 * 10)
# setup all windows
self.mainWindow = MainDisplay(0, self.stdscr)
# self.stdscr.hline(self.WinPositions.headerBlock+self.headerWindow.getmaxyx()[0], 0, '-', 130)
self.jobWindow = JobDisplay(0, self.stdscr)
# self.stdscr.hline(self.WinPositions.summaryBlock+self.jobsWindow.getmaxyx()[0], 0, '-', 130)
##self.stdscr.hline(self.WinPositions.submitBlock+self.submitWindow.getmaxyx()[0], 0, '-', 130)
##self.erroWindow = curses.newwin(5, self.stdscr.getmaxyx()[1], self.WinPositions.debugBlock, 0)
##self.finalWindow = curses.newwin(3, self.stdscr.getmaxyx()[1], self.WinPositions.finalizeBlock, 0)
##self.finalWindow.addstr(0, 50, "Finalization job result")
##self.stdscr.hline(self.WinPositions.finalizeBlock+self.submitWindow.getmaxyx()[0], 0, '-', 130)
##
##self.stdscr.nooutrefresh()
##self.repaint()
self.mainWindow.generate()
self.jobWindow.generate()
self.stdscr.refresh()
self.activateMainWindow()
def __init__(self, stdscr, args):
self._stdscr = stdscr
self._dbase = database.load_file(args.database,
encoding=args.encoding,
frame_id_mask=args.frame_id_mask,
strict=not args.no_strict)
self._single_line = args.single_line
self._filtered_sorted_message_names = []
self._filter = ''
self._compiled_filter = None
self._formatted_messages = {}
self._playing = True
self._modified = True
self._show_filter = False
self._queue = Queue()
self._nrows, self._ncols = stdscr.getmaxyx()
self._received = 0
self._discarded = 0
self._basetime = None
stdscr.nodelay(True)
curses.use_default_colors()
curses.curs_set(False)
curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_GREEN)
curses.init_pair(2, curses.COLOR_BLACK, curses.COLOR_CYAN)
bus = self.create_bus(args)
self._notifier = can.Notifier(bus, [self])
def __init__(self): curses.curs_set(0) curses.noecho() self.win=curses.newwin(LINES-4,COLS-4,2,2) self.win.clear() self.win.refresh() self.win.keypad(1)
def main():
global screen
screen = curses.initscr()
init_screen()
screen.refresh()
curses.curs_set(0)
import sys
if len(sys.argv) > 1 and sys.argv[1] == "-s":
screen.getch()
else:
while True:
try:
c = screen.getch()
if c == ord('n'):
curses.endwin()
show_netinfo()
screen = curses.initscr()
init_screen()
screen.refresh()
if c == 27 :
curses.endwin()
return 0
except KeyboardInterrupt:
pass
curses.endwin()
def main(scr):
curses.curs_set(False)
curses.start_color()
for i in range(1, 16):
curses.init_pair(i, i, curses.COLOR_BLACK)
scry, scrx = scr.getmaxyx()
pady = scry * 2
padx = scrx * 2
pad = curses.newpad(pady, padx)
pad.nodelay(True)
mandel(pad)
oy = 1
ox = 0
while True:
pad.refresh(oy, ox, 0, 0, scry-1, scrx-1)
key = pad.getch()
if key in (ord('q'), ord('Q')):
break
elif key in (ord('w'), curses.KEY_UP):
oy = max(oy - 1, 0)
elif key in (ord('s'), curses.KEY_DOWN):
oy = min(oy + 1, pady - scry - 1)
elif key in (ord('a'), curses.KEY_LEFT):
ox = max(ox - 2, 0)
elif key in (ord('d'), curses.KEY_RIGHT):
ox = min(ox + 2, padx - scrx)
elif key == curses.KEY_RESIZE:
scry, scrx = scr.getmaxyx()
def close(self):
curses.curs_set(1)
self.screen.immedok(False)
self.screen.keypad(0)
curses.nocbreak()
curses.echo()
curses.endwin()
def __init__(self, win, interface, level):
self.line_pos = 2
self.first_result = self.selected_result = 0
self.stdscr = win
self.results = []
self.wifispy = WifiSpy.WifiSpy(interface)
# Configure screen
curses.curs_set(0)
self.stdscr.nodelay(1)
self.stdscr.timeout(0)
# Put the interface it in managed mode
# to perform the scanning
self.wifispy.level = level
self.wifispy.set_iface_in_managed_mode()
# Show scanning message
self.stdscr.box()
self.stdscr.addstr(curses.LINES/2, curses.COLS/2 - 5, "Scanning...",
curses.A_BOLD)
self.stdscr.refresh()
# Get and populate results
self.results = self.wifispy.get_scanning_results()
# Rebuild the screen with the results
self.__clear_screen()
self.__build_screen(self.first_result, True)
self.__highlight_line(self.line_pos, self.selected_result)
def killWindow(self):
"""restore terminal window"""
curses.nocbreak()
self.stdscr.keypad(0)
curses.echo()
curses.curs_set(1)
curses.endwin()
def __init__(self, stdscr, username, filename):
"""Create the GUI with curses screen and optional filename to load."""
self._stdscr = stdscr
self._COLOR_NUM = 7
self._username = username
self._COL_MAX = 50
self._ROW_MAX = 20
# if filename already exists, try to load from it
text = ''
if filename != None and os.path.isfile(filename):
with open(filename) as f:
text = f.read()
self._filename = filename
self._buf = Buffer(text)
self._row = 0
self._col = 0
self._scroll_top = 0 # the first line number in the window
self._mode = 'normal'
self._message = ''
self._will_exit = False
self._pipe = None
self._cooperators = []
curses.curs_set(0)
def initialize(self):
"""initialize curses, then call setup (at the first time) and resize."""
self.win.leaveok(0)
self.win.keypad(1)
self.load_mode = False
curses.cbreak()
curses.noecho()
curses.halfdelay(20)
try:
curses.curs_set(int(bool(self.settings.show_cursor)))
except:
pass
curses.start_color()
curses.use_default_colors()
self.settings.signal_bind('setopt.mouse_enabled', _setup_mouse)
_setup_mouse(dict(value=self.settings.mouse_enabled))
if not self.is_set_up:
self.is_set_up = True
self.setup()
self.win.addstr("loading...")
self.win.refresh()
self._draw_title = curses.tigetflag('hs') # has_status_line
self.update_size()
self.is_on = True
if self.settings.update_tmux_title:
sys.stdout.write("\033kranger\033\\")
sys.stdout.flush()
def edit(self, initial_input=""):
old_curs_state = 0
try:
old_curs_state = curses.curs_set(1)
except:
pass
for char in list(initial_input):
self.do_command(ord(char))
self.poll_function(self.count())
abort = False
while 1:
insert = False
ch = self.win.getch()
if ch == curses.ascii.DEL:
self.do_command(curses.ascii.BS)
elif ch == curses.KEY_ENTER or ch == 10:
break
elif ch == curses.ascii.ESC:
abort = True
break
elif ch == curses.ascii.TAB:
cursor_position = self.win.getyx()
x = cursor_position[1]
last_word = ""
while True:
x -= 1
c = chr(
curses.ascii.ascii(self.win.inch(
cursor_position[0], x)))
if c == " ":
if (len(last_word) == 0) and (x > 0):
continue
else:
break
last_word = c + last_word
if x == 0:
break
self.win.move(cursor_position[0], cursor_position[1])
guess_source = None
if helpers.url_regex.match(
last_word): # this is a URL, shorten it
shorturl = helpers.ur1ca_shorten(last_word)
for n in xrange(len(last_word)):
self.win.move(self.win.getyx()[0],
self.win.getyx()[1] - 1)
self.delch()
for char in shorturl:
self.do_command(ord(char))
elif last_word[0] == "@" and hasattr(config.session_store,
"user_cache"):
last_word = last_word[1:]
guess_source = getattr(config.session_store, "user_cache")
elif last_word[0] == "!" and hasattr(config.session_store,
"group_cache"):
last_word = last_word[1:]
guess_source = getattr(config.session_store, "group_cache")
elif last_word[0] == "#" and hasattr(config.session_store,
"tag_cache"):
last_word = last_word[1:]
guess_source = getattr(config.session_store, "tag_cache")
elif last_word[0] == "/" and hasattr(config.session_store,
"commands"):
last_word = last_word[1:]
guess_source = getattr(config.session_store, "commands")
elif hasattr(
config.session_store,
"user_cache"): # if no special char, assume username
guess_source = getattr(config.session_store, "user_cache")
if guess_source is not None:
if config.config["tab_complete_mode"] == "exact":
possible_guesses = [
user for user in guess_source
if user[:len(last_word)] == last_word
]
guess = helpers.find_longest_common_start(
possible_guesses)
if len(guess) > len(last_word):
for char in guess[len(last_word):]:
self.do_command(ord(char))
elif len(possible_guesses) > 0:
self.poll_function(possible_guesses)
else:
possible_guesses = helpers.find_fuzzy_matches(
last_word, guess_source)
common_guess = helpers.find_longest_common_start(
possible_guesses)
if len(common_guess) != 0 and len(
helpers.find_fuzzy_matches(
last_word, [
common_guess,
])) > 0:
self.win.move(self.win.getyx()[0],
self.win.getyx()[1] - len(last_word))
for i in xrange(len(last_word)):
self.delch()
for char in common_guess:
self.do_command(ord(char))
if len(possible_guesses) >= 2:
self.poll_function(possible_guesses)
elif ch == curses.KEY_HOME:
self.win.move(0, 0)
elif ch == curses.KEY_END:
for y in range(self.maxy + 1):
if y == self.maxy:
self.win.move(y, self._end_of_line(y))
break
if self._end_of_line(y + 1) == 0:
self.win.move(y, self._end_of_line(y))
break
elif ch == curses.KEY_BACKSPACE or ch == curses.ascii.ctrl(
ord("h")):
cursor_y, cursor_x = self.win.getyx()
if cursor_x == 0:
if cursor_y == 0:
continue
else:
self.win.move(cursor_y - 1, self.maxx)
else:
self.win.move(cursor_y, cursor_x - 1)
self.delch()
elif ch == curses.KEY_DC or ch == curses.ascii.ctrl(ord("d")):
self.delch()
elif ch == curses.ascii.ctrl(
ord("u")): # delete entire line up to the cursor
cursor_y, cursor_x = self.win.getyx()
self.win.move(cursor_y, 0)
for char_count in xrange(0, cursor_x):
self.delch()
elif ch == curses.ascii.ctrl(
ord("w")
): # delete all characters before the current one until the beginning of the word
cursor_y, cursor_x = self.win.getyx()
x, y = cursor_x, cursor_y
only_spaces_so_far = True
while True:
if x == 0:
if y == 0:
break
else:
y -= 1
x = self.maxx
else:
x -= 1
if curses.ascii.ascii(self.win.inch(y, x)) != ord(" "):
self.win.move(y, x)
self.delch()
only_spaces_so_far = False
else:
if only_spaces_so_far:
self.win.move(y, x)
self.delch()
else:
if x == self.maxx:
self.win.move(y + 1, 0)
else:
self.win.move(y, x + 1)
break
elif ch > 127 and ch <= 256:
cursor_y, cursor_x = self.win.getyx()
if cursor_y < self.maxy:
overhang_ch = self.win.inch(cursor_y, self.maxx)
if overhang_ch <= 127:
self.win.insch(cursor_y + 1, 0, overhang_ch)
elif overhang_ch <= 256:
for c in self.unicode_demangle(overhang_ch):
self.win.insch(cursor_y + 1, 0, ord(c))
for c in self.unicode_demangle(ch):
self.win.insch(cursor_y, cursor_x, ord(c))
if cursor_x < self.maxx:
self.win.move(cursor_y, cursor_x + 1)
elif cursor_y < self.maxy:
self.win.move(cursor_y + 1, 0)
elif ch <= 127 and chr(ch) in string.printable:
cursor_y, cursor_x = self.win.getyx()
if cursor_y < self.maxy:
overhang_ch = self.win.inch(cursor_y, self.maxx)
if overhang_ch <= 127:
self.win.insch(cursor_y + 1, 0, overhang_ch)
elif overhang_ch <= 256:
for c in self.unicode_demangle(overhang_ch):
self.win.insch(cursor_y + 1, 0, ord(c))
self.win.insch(cursor_y, cursor_x, ch)
if cursor_x < self.maxx:
self.win.move(cursor_y, cursor_x + 1)
elif cursor_y < self.maxy:
self.win.move(cursor_y + 1, 0)
elif not ch:
continue
elif not self.do_command(ch):
break
self.poll_function(self.count())
self.win.refresh()
try:
curses.curs_set(
old_curs_state
) # try to restore the cursor's state before returning to normal operation
except:
pass
if abort == False:
return self.gather()
else:
self.win.clear()
self.win.refresh()
return None
def simulate_battle(cave_data, elf_attack_power):
if CURSES:
curses.curs_set(0)
field = curses.newwin(40, 40, 1, 1)
curses.start_color()
curses.use_default_colors()
for i in range(0, curses.COLORS):
curses.init_pair(i + 1, i, -1)
cm = CaveMap(cave_data, elf_attack_power)
stime = time.time()
for i in range(1000):
if CURSES:
field.clear()
cm.draw(field)
curses.curs_set(0)
for unit in cm.units:
if unit.is_alive():
if unit.unit_type == 'E':
field.addstr(unit.y, unit.x, unit.unit_type,
curses.color_pair(3))
else:
field.addstr(unit.y, unit.x, unit.unit_type,
curses.color_pair(2))
field.addstr(33, 0,
'Round {} took {} s'.format(i,
time.time() - stime))
field.refresh()
#field.getch()
stime = time.time()
else:
print('Round:', i)
print(cm)
cm.units.sort(key=lambda unit: (unit.y, unit.x))
for unit in cm.units:
if unit.is_alive():
targets = unit.get_targets(cm.units)
if targets:
target = unit.get_target_in_range(targets)
if target:
unit.attack(target)
else:
path = unit.get_path_to_closest_target(cm)
if path:
unit.coordinate = path[-2].coordinate
target = unit.get_target_in_range(targets)
if target:
unit.attack(target)
else:
hp_sum = 0
for unit in cm.units:
if unit.is_alive():
hp_sum += unit.hp
if CURSES:
field.clear()
cm.draw(field)
curses.curs_set(0)
for unit in cm.units:
if unit.is_alive():
if unit.unit_type == 'E':
field.addstr(unit.y, unit.x,
unit.unit_type,
curses.color_pair(3))
else:
field.addstr(unit.y, unit.x,
unit.unit_type,
curses.color_pair(2))
field.addstr(
33, 0, 'Round {} took {} s'.format(
i,
time.time() - stime))
field.addstr(34, 0,
'Combat ended after {} rounds'.format(i))
field.addstr(35, 0,
'Remaining hit points: {}'.format(hp_sum))
field.addstr(36, 0, 'Outcome: {}'.format(i * hp_sum))
field.addstr(
37, 0, 'Dead elfs: {}'.format(
check_for_dead_elfs(cm.units)))
field.refresh()
field.getch()
else:
print('Combat ended after {} rounds'.format(i))
print(cm)
print('Remaining hit points: {}'.format(hp_sum))
print(('Outcome: {}'.format(i * hp_sum)))
return cm
return None
def main(stdscr):
curses.curs_set(0) # hide cursor
curses.init_pair(1,curses.COLOR_YELLOW,curses.COLOR_BLACK) # Ubuntu (Yellow?)
curses.init_pair(2,curses.COLOR_BLUE,curses.COLOR_BLACK) # Kubuntu Blue on Black
curses.init_pair(3,curses.COLOR_RED,curses.COLOR_BLACK) # Edubuntu
curses.init_pair(4,curses.COLOR_CYAN,curses.COLOR_BLACK) # Xubuntu
curses.init_pair(5,curses.COLOR_BLACK,curses.COLOR_GREEN) # Pass
curses.init_pair(6,curses.COLOR_BLACK,curses.COLOR_RED) # Fail (This could be reverse edubuntu)
"""while (1):
try:
server.connect((HOST, PORT))
break
except socket.error:
# Since non-blocking, if it doesn't work immediately, EINPROGRESS
# Subsequent calls (while in progress) give EALREADY
# There are other errors (actual errors), we may want to check them
pass"""
stdscr.bkgd('*', curses.A_REVERSE )
win_sidebar = curses.newwin(21,15,0,0)
# Set up sidebar (static stuff) UGLY CHANGE!!!!!!!!!!!!! - JB
win_sidebar.border(' ','|',' ',' ',' ',curses.ACS_VLINE,' ',curses.ACS_VLINE) # Righthand Line
win_sidebar.addstr(0,0," Queue ", curses.A_UNDERLINE)
win_sidebar.addstr(1,3,"F V A T P")
for i in range(1,10):
win_sidebar.addstr(i+1,1,str(i))
for i in range(10,20):
win_sidebar.addstr(i+1,0,str(i))
# done with sidebar static stuff
win_topbar = curses.newwin(4,65,0,15)
# set up top bar (static stuff)
win_topbar.border(' ',' ',' ','-',' ',' ','-','-') # Bottom Line
for i in range(1,6):
for j in range(0,3):
win_topbar.addstr(j,i*11-1,'|') # Dividers between clients
win_topbar.addstr(0,i*11,' ******** ') # blank client names (2-6)
win_topbar.addstr(0,0,' ******** ') # blank client name (1)
# done with top bar static stuff
# Now we set up the four (up to five) tabs
tabs.append(curses.newwin(17,65,4,15)) # These panel references are
tabs.append(curses.newwin(17,65,4,15)) # important, without them
tabs.append(curses.newwin(17,65,4,15)) # our panels get GC'd
tabs.append(curses.newwin(17,65,4,15)) # Using Win instead?
# Put some test stuff in the tabs
draw_menu_order(tabs[0])
draw_menu_packages(tabs[1])
draw_menu_clients(tabs[2])
draw_menu_queue(tabs[3])
# initial updates
#get_queue()
#get_clients()
update_package_names()
global active_tab
global is_running
global keysdown
global blankkeys
global frame_count
keysdown = blankkeys
active_tab = 0
stale_queue = True
stale_client = True
stdscr.nodelay(1)
curses.meta(1)
while(is_running):
stdscr.noutrefresh()
win_sidebar.noutrefresh()
win_topbar.noutrefresh()
tabs[active_tab].touchwin() # Have to make them think this is modified
tabs[active_tab].noutrefresh()
curses.doupdate()
"""# begin socket stuff
try: #try RX
if len(server.recv(1024,socket.MSG_PEEK)) == 0:
server.close() # Bad connection, We likely want to reconnect
continue
# otherwise: do stuff with inbuf
inbuf = inbuf + server.recv(1024)
except socket.error: # Excepion (no data RX, but connection still there)
pass
if len(outbuf) > 0: # if we have stuff to send
try: # try TX
sent = server.send(outbuf)
outbuf = outbuf[sent:]
except socket.error: # We only want to catch SIGPIPE (server disconnect)
pass
# done with socket stuff"""
# Handle Communication
if stale_queue:
update_display_queue(win_sidebar)
stale_queue = False
if stale_client:
update_display_clients(win_topbar)
stale_client = False
handle_input(stdscr)
update_tab(active_tab)
#clear keys
clear_keys()
frame_count += 1
def set_cursor(self, x):
try:
curses.curs_set(x)
except Exception:
pass
import time
import locale
import curses
import sys
from pySpacebrew.spacebrew import Spacebrew
# set the encoding to use for the terminal string
locale.setlocale(locale.LC_ALL, '')
code = locale.getpreferredencoding()
# initialize the terminal display
stdscr = curses.initscr()
stdscr.keypad(1)
curses.noecho() # turn off echo
curses.curs_set(0) # turn off cursor
# get app name and server from query string
name = "pyString Example"
server = "sandbox.spacebrew.cc"
local = "localhost"
for cur_ele in sys.argv:
if "name" in cur_ele:
name = cur_ele[5:]
if "server" in cur_ele:
server = cur_ele[7:]
# configure the spacebrew client
brew = Spacebrew(name, server=local)
brew.addPublisher("chat outgoing", "string")
brew.addSubscriber("chat incoming", "string")
# SNAKES GAME
# Use ARROW KEYS to play, SPACE BAR for pausing/resuming and Esc Key for exiting
import curses
from curses import KEY_RIGHT, KEY_LEFT, KEY_UP, KEY_DOWN
from random import randint
curses.initscr()
win = curses.newwin(20, 60, 0, 0)
win.keypad(1)
curses.noecho()
curses.curs_set(0)
win.border(0)
win.nodelay(1)
key = KEY_RIGHT # Initializing values
score = 0
snake = [[4, 10], [4, 9], [4, 8]] # Initial snake co-ordinates
food = [10, 20]
wall = [15, 18]
walls = []
walls.append(wall) # First food co-ordinates
win.addch(food[0], food[1], '*')
win.addch(walls[0][0], walls[0][1], '@') # Prints the food
while key != 27: # While Esc key is not pressed
win.border(0)
win.addstr(0, 2, 'Score : ' + str(score) + ' ') # Printing 'Score' and
win.addstr(0, 27, ' SNAKE ') # 'SNAKE' strings
import curses screen = curses.initscr() curses.nocbreak() # Turn off cbreak mode curses.echo() # Turn echo back on curses.curs_set(1) # Turn cursor back on # If initialized like `my_screen = curses.initscr()` screen.keypad(0) # Turn off keypad keys
def show_cursor(self, cursor_on):
"""Change visibility of cursor."""
self.cursor_visible = cursor_on
curses.curs_set(self.cursor_shape if cursor_on else 0)
def chat_page(screen: curses.window):
global running
user_typing = False
read_str = ""
rendered_display_chats = 0
display_chats: List[str] = []
while running:
key = screen.getch()
if key == curses.KEY_MOUSE:
_, mx, my, *_ = curses.getmouse()
if my == center(screen)[0] * 2 - 2:
user_typing = True
else:
user_typing = False
elif key == 27 or key == curses.KEY_BREAK:
running = False
screen.erase()
start_index = -1
end_index = -(center(screen)[0] * 2 - 3) - 1
box2 = screen.subwin(3,
center(screen)[1] * 2,
center(screen)[0] * 2 - 3, 0)
box2.box()
start_render_from = rendered_display_chats
rendered_display_chats = len(chats)
width_limit = center(screen)[1] * 2 - 2
for chat in chats[start_render_from:]:
parts = textwrap.fill(chat, width_limit).split("\n")
display_chats.extend(parts)
for index, msg in enumerate(display_chats[start_index:end_index:-1]):
y = center(screen)[0] * 2 - 4 - index
x = 0
screen.addstr(y, x, msg)
if user_typing:
curses.curs_set(1)
screen.move(
center(screen)[0] * 2 - 2,
len(read_str[-(center(screen)[1] - 2) * 2:]))
if key:
if key == curses.KEY_ENTER or key in (10, 13):
if read_str:
send_this.append(read_str)
read_str = ""
elif key == curses.KEY_BACKSPACE or key == 8:
if read_str:
read_str = read_str[:-1]
else:
if curses.ascii.isascii(key):
letter = chr(key)
read_str += letter
screen.move(
center(screen)[0] * 2 - 2,
len(read_str[-(center(screen)[1] - 2) * 2:]))
else:
screen.move(0, center(screen)[1] * 2 - 1)
if key == ord("q"):
running = False
elif key == ord("w") or key == curses.KEY_ENTER or key in (10, 18):
user_typing = True
screen.addstr(
center(screen)[0] * 2 - 2, 1,
read_str[-(center(screen)[1] - 2) * 2 - 1:])
screen.refresh()
def drawBoard(stdscr):
curses.noecho()
curses.curs_set(0)
stdscr.keypad(True)
stdscr.clear()
curses.start_color()
curses.use_default_colors()
curses.init_color(11, 1000, 0, 0)
curses.init_color(12, 0, 1000, 0)
curses.init_pair(1, 11, -1)
curses.init_pair(2, 12, -1)
moveList = [stoneMove(2, '1', 0, 2), stoneMove(3, '2', 1, 1), stoneMove(13, curses.ACS_CKBOARD, pid=1, side=0)]
dbf = open("debug", "w")
height, width = stdscr.getmaxyx()
dbf.write(f"H: {height} W: {width}\n")
xscale = floor((width-1) / 16)
yscale = floor((height-1) / 6)
dbf.write(f"XSCL {xscale} YSCL {yscale}\n")
if xscale > 2*yscale:
xscale = yscale * 2
else:
xscale -= 1 if xscale % 2 == 1 else 0
yscale = int(xscale/2)
dbf.write(f"POST XSCL {xscale} YSCL {yscale}\n")
cellSize = (2*xscale - 1, 2*yscale - 1)
p = 0
selected = [0,0]
while True:
stdscr.erase()
for y in range(0, (6*yscale) + 1):
for x in range(0, (16*xscale) + 1):
duplet = place_table[selected[p]][p] if type(place_table[selected[p]][p]) is tuple else place_table[selected[p]]
if (xscale*(duplet[0]-1)) < x < (xscale*(duplet[0]+1)) and (yscale*(duplet[1]-1)) < y < (yscale*(duplet[1]+1)):
stdscr.addch(int((height/2 - (6*yscale)/2) + y), int((width/2 - (16*xscale)/2) + x), ' ', curses.A_REVERSE)
if y == 0:
if x in [0, (12*xscale)]:
stdscr.addch(int((height/2 - (6*yscale)/2) + y), int((width/2 - (16*xscale)/2) + x), curses.ACS_ULCORNER)
elif x in [(8*xscale), (16*xscale)]:
stdscr.addch(int((height/2 - (6*yscale)/2) + y), int((width/2 - (16*xscale)/2) + x), curses.ACS_URCORNER)
elif x < (12*xscale) and x > (8*xscale):
continue
elif x % (2*xscale) == 0:
stdscr.addch(int((height/2 - (6*yscale)/2) + y), int((width/2 - (16*xscale)/2) + x), curses.ACS_TTEE)
else:
stdscr.addch(int((height/2 - (6*yscale)/2) + y), int((width/2 - (16*xscale)/2) + x), curses.ACS_HLINE)
elif y == (6*yscale):
if x in [0, (12*xscale)]:
stdscr.addch(int((height/2 - (6*yscale)/2) + y), int((width/2 - (16*xscale)/2) + x), curses.ACS_LLCORNER)
elif x in [(8*xscale), (16*xscale)]:
stdscr.addch(int((height/2 - (6*yscale)/2) + y), int((width/2 - (16*xscale)/2) + x), curses.ACS_LRCORNER)
elif x < (12*xscale) and x > (8*xscale):
continue
elif x % (2*xscale) == 0:
stdscr.addch(int((height/2 - (6*yscale)/2) + y), int((width/2 - (16*xscale)/2) + x), curses.ACS_BTEE)
else:
stdscr.addch(int((height/2 - (6*yscale)/2) + y), int((width/2 - (16*xscale)/2) + x), curses.ACS_HLINE)
elif y % (2*yscale) != 0:
if 0 < y < (2*yscale) or (4*yscale) < y < (6*yscale):
if x < (12*xscale) and x > (8*xscale):
continue
if x in [xscale, 13*xscale] or (y in [yscale, 5*yscale] and (0 < x < 2*xscale or 12*xscale < x < 14*xscale)):
stdscr.addch(int((height/2 - (6*yscale)/2) + y), int((width/2 - (16*xscale)/2) + x), 'X')
if (x == (7*xscale) and 2*yscale < y < 4*yscale) or (y == 3*yscale and 6*xscale < x < 8*xscale):
stdscr.addch(int((height/2 - (6*yscale)/2) + y), int((width/2 - (16*xscale)/2) + x), 'X')
'''
for stone in moveList:
tmp = []
if stone.pos in [0,1,2,3,12,13,14] and stone.side == -1:
continue
if stone.pos not in [0,1,2,3,12,13,14] and stone.side != -1:
stone.side = -1
if stone.side != -1:
tmp = place_table[stone.pos][stone.side]
else:
tmp = place_table[stone.pos]
if x == tmp[0]*xscale and y == tmp[1]*yscale:
if cellSize[0] <= 3 or cellSize[1] <= 3:
stdscr.addch(int((height/2 - (6*yscale)/2) + y), int((width/2 - (16*xscale)/2) + x), stone.owner)
else:
smaller = cellSize[0] if cellSize[0] <= cellSize[1] else cellSize[1]
for y2 in range(y-int((smaller-1)/2-1), y+int((smaller-1)/2)):
for x2 in range(x-int((smaller-1)/2-1), x+int((smaller-1)/2)):
stdscr.addch(int((height/2 - (6*yscale)/2) + y2), int((width/2 - (16*xscale)/2) + x2), stone.owner)
'''
if x % (2*xscale) == 0:
stdscr.addch(int((height/2 - (6*yscale)/2) + y), int((width/2 - (16*xscale)/2) + x), curses.ACS_VLINE)
elif y in [2*yscale,4*yscale]:
if x == 0:
stdscr.addch(int((height/2 - (6*yscale)/2) + y), int((width/2 - (16*xscale)/2) + x), curses.ACS_LTEE)
elif x == (16*xscale):
stdscr.addch(int((height/2 - (6*yscale)/2) + y), int((width/2 - (16*xscale)/2) + x), curses.ACS_RTEE)
elif x == (10*xscale):
if y == (2*yscale):
stdscr.addch(int((height/2 - (6*yscale)/2) + y), int((width/2 - (16*xscale)/2) + x), curses.ACS_TTEE)
elif y == (4*yscale):
stdscr.addch(int((height/2 - (6*yscale)/2) + y), int((width/2 - (16*xscale)/2) + x), curses.ACS_BTEE)
elif x % (2*xscale) == 0:
stdscr.addch(int((height/2 - (6*yscale)/2) + y), int((width/2 - (16*xscale)/2) + x), curses.ACS_PLUS)
else:
stdscr.addch(int((height/2 - (6*yscale)/2) + y), int((width/2 - (16*xscale)/2) + x), curses.ACS_HLINE)
for y in range(0, 6*yscale, yscale):
for x in range(0, 16*xscale, xscale):
#if y in [yscale, 3*yscale, 5*yscale]:
for stone in moveList:
tmp = []
if stone.pos in [0,1,2,3,12,13,14] and stone.side == -1:
continue
if stone.pos not in [0,1,2,3,12,13,14] and stone.side != -1:
stone.side = -1
if stone.side != -1:
tmp = place_table[stone.pos][stone.side]
else:
tmp = place_table[stone.pos]
if x == tmp[0]*xscale and y == tmp[1]*yscale:
if cellSize[0] <= 3 or cellSize[1] <= 3:
stdscr.addch(int((height/2 - (6*yscale)/2) + y), int((width/2 - (16*xscale)/2) + x), stone.owner)
else:
smaller = cellSize[0] if cellSize[0] <= cellSize[1] else cellSize[1]
for y2 in range(y-int((smaller-1)/2-1), y+int((smaller-1)/2)):
for x2 in range(x-int((smaller-1)/2-1), x+int((smaller-1)/2)):
if x == x2 and y == y2:
stdscr.addch(int((height/2 - (6*yscale)/2) + y2), int((width/2 - (16*xscale)/2) + x2), curses.ACS_DIAMOND)
else:
stdscr.addch(int((height/2 - (6*yscale)/2) + y2), int((width/2 - (16*xscale)/2) + x2), stone.owner, curses.color_pair(stone.pid))
stdscr.refresh()
c = stdscr.getch()
if chr(c) == 'q':
break
elif c == curses.KEY_RESIZE:
height, width = stdscr.getmaxyx()
dbf.write(f"H: {height} W: {width}\n")
xscale = floor((width-1) / 16)
yscale = floor((height-1) / 6)
dbf.write(f"XSCL {xscale} YSCL {yscale}\n")
if xscale > 2*yscale:
xscale = yscale * 2
else:
xscale -= 1 if xscale % 2 == 1 else 0
yscale = int(xscale/2)
dbf.write(f"POST XSCL {xscale} YSCL {yscale}\n")
cellSize = (2*xscale - 1, 2*yscale - 1)
elif c == curses.KEY_UP:
selected[p] = selected[p]+1 if selected[p] != 13 else 0
elif c == curses.KEY_DOWN:
selected[p] = selected[p]-1 if selected[p] != 0 else 13
reportes.stack_report(true_stack)
misc.imprimir("Score report generated successfully!")
elif (key == 51):
reportes.scoreBoard_report(scoreBoard)
misc.imprimir("Score Board report generated successfully!")
elif (key == 52):
reportes.users_report(usuarios)
misc.imprimir("Users Report generated successfully!")
misc.clear_scr()
stdscr = curses.initscr() #initialize console
window = curses.newwin(max_x, max_y, 0, 0) #create a new curses window
window.keypad(True) #enable Keypad mode
curses.noecho() #prevent input from displaying in the screen
curses.curs_set(0) #cursor invisible (0)
paint_menu(window)
misc = Misc(window, max_x, max_y)
true_game = snake_game(None, max_x, max_y, window, usuario)
true_snake = true_game.get_new_snake()
pausa = False
keystroke = -1
while (keystroke == -1):
keystroke = window.getch() #get current key being pressed
if (keystroke == 49): #1
misc.clear_scr()
paint_title(window, ' PLAY ')
if (usuario is None):
misc.clear_scr()
misc.print_title("Creacion de Usuario:")
newUser = misc.getString()
def do_action(self, returned=False, go_back=False):
if returned:
if len(self.str) > self.visible_text_width:
text = self.str[-self.visible_text_width:]
else:
text = self.str
if self.echo_char:
text = self.echo_char * len(text)
# Add the dashes
text = text + '_' * (self.visible_text_width - len(self.str))
self.textwin.addstr(self.y, 0, text)
if not returned:
curses.curs_set(1)
self.init_text()
if self.default_string != None:
self.textwin.addstr(self.y, 0, self.default_string)
self.str = self.default_string
while True:
if len(self.str) > self.visible_text_width:
curs_loc = self.visible_text_width
else:
curs_loc = len(self.str)
ch = self.textwin.getch(self.y, curs_loc)
update_text = False
if ch in [curses.KEY_ENTER, ord('\n')]:
curses.curs_set(0)
if go_back:
return ActionResult(False, {'goBack': True})
if self.confirmation_error_msg:
if self.str != self.install_config[self.field]:
conf_message_height = 8
conf_message_width = 48
conf_message_button_y = (self.maxy -
conf_message_height) / 2 + 5
confrim_window = ConfirmWindow(
conf_message_height, conf_message_width, self.maxy,
self.maxx, conf_message_button_y,
self.confirmation_error_msg, True)
confrim_window.do_action()
return ActionResult(False, {'goBack': True})
self.set_field()
else:
if not self.validate_input():
continue
self.set_field()
curses.curs_set(0)
return ActionResult(True, None)
elif ch == curses.KEY_LEFT and not self.tab_enabled:
return ActionResult(False, {'direction': -1})
elif ch == curses.KEY_RIGHT and not self.tab_enabled:
return ActionResult(False, {'direction': 1})
elif ch in [ord('\t')]:
curses.curs_set(0)
return ActionResult(False, None)
elif ch == curses.KEY_BACKSPACE: #originally ==127
# Handle the backspace case
self.str = self.str[:len(self.str) - 1]
update_text = True
elif len(self.str) < self.maxlength and ch in self.accepted_chars:
self.str += chr(ch)
update_text = True
if update_text:
if len(self.str) > self.visible_text_width:
text = self.str[-self.visible_text_width:]
else:
text = self.str
if self.echo_char:
text = self.echo_char * len(text)
# Add the dashes
text = text + '_' * (self.visible_text_width - len(self.str))
self.textwin.addstr(self.y, 0, text)
def draw_cursor(self, stdscr, y, x):
curses.curs_set(0)
def main(screen: curses.window):
curses.mousemask(1)
screen.nodelay(1)
curses.curs_set(0)
start(screen)
chat_page(screen)
def showHelp(stdscr, args, listOfQueries, dbg):
# Clear and refresh the screen for a blank canvas
stdscr.clear()
stdscr.refresh()
# Attempt to turn on the cursor
curses.curs_set(True)
# Update the screen periodically, independent of input
stdscr.timeout(-1)
# Loop where k is the last character pressed
k = -1
while (k == -1):
# Initialization
stdscr.erase()
height, width = stdscr.getmaxyx()
y = 0
x = 0
line = f'DAQ blockages monitor for partition {args.part}, instrument "{args.inst}"'
stdscr.addstr(y, x, line, curses.color_pair(1))
y += 2
line = 'Available keystrokes:'
keys = [('Arrow keys', 'Scroll by column or row'),
('Page up/down', 'Scroll rows by page'),
('i', 'Toggle display of the process "instance" name'),
('n/p', 'Advance/retreat time by one step'),
('<space>', 'Advance time by one step'),
('+/-', 'Increase/decrease time step size by 1 second'),
('t', 'Toggle use of current vs "start" parameter time'),
('h/?', 'Help'),
('q', 'Quit'),]
stdscr.addstr(y, x, line, curses.color_pair(1))
y += 1
for key in keys:
stdscr.addstr(y, 2+x, key[0], curses.color_pair(1))
stdscr.addstr(y, 2+x+14, key[1], curses.color_pair(1))
y += 1
y += 1
line = 'Column header descriptions:'
stdscr.addstr(y, x, line, curses.color_pair(1))
y += 1
for queries in listOfQueries:
for metric, query in queries.items():
dbg.write('y, x: %d, %d, metric \'%s\', descr \'%s\'\n' % (y, x, metric, query[2]))
stdscr.addstr(y, 2+x, metric, curses.color_pair(1))
stdscr.addstr(y, 2+x+14, query[2], curses.color_pair(1))
y += 1
if y > height - 1: break
if y > height - 1: break
y = height - 1
stdscr.addstr(y, x, "Hit any character to continue", curses.color_pair(1))
# Wait for next input
k = stdscr.getch()
# Attempt to turn off the cursor
curses.curs_set(False)
# Update the screen periodically, independent of input
stdscr.timeout(1000)
stdscr.erase()
def run(self):
try:
while True:
#print 'Is the queue empty?: {}'.format(self.qscreen.empty())
if not self.qscreen.empty():
order = self.qscreen.get()
#self.logfile.write('Receiving the order'+order+'\n')
if order == 'Start':
stdscr = curses.initscr()
curses.savetty()
curses.start_color()
curses.use_default_colors()
self.screen = stdscr
curses.init_pair(1, curses.COLOR_GREEN, -1)
curses.init_pair(2, curses.COLOR_RED, -1)
curses.init_pair(3, curses.COLOR_BLUE, -1)
curses.init_pair(4, curses.COLOR_WHITE, -1)
self.screen.bkgd(' ', curses.color_pair(1))
self.screen.bkgd(' ')
curses.noecho()
curses.cbreak()
self.screen.keypad(1)
# curses.curs_set. 0 means invisible cursor, 1 visible, 2 very visible
curses.curs_set(0)
self.screen.addstr(0,0, 'Live Stream', curses.A_BOLD)
self.screen.refresh()
self.qscreen.task_done()
elif order == 'Stop':
self.screen.addstr(0,0, 'Press any key to go back to stf screen... ', curses.A_BOLD)
self.screen.getstr(0,0, 15)
curses.nocbreak()
self.screen.keypad(0)
curses.echo()
curses.curs_set(1)
stdscr.refresh()
# close
self.qscreen.task_done()
curses.resetty()
self.f.close()
return
else:
#self.screen.addstr(0,50, 'Receiving Data')
self.screen.refresh()
# Get the screen size
(x_max, y_max) = self.screen.getmaxyx()
# The order
orig_tuple = order
tuple_id = orig_tuple.get_id()
# Get the amount of letters that fit on the screen
state = orig_tuple.get_state()[-(y_max-self.y_min):]
tuple = self.get_tuple(tuple_id)
# Update the status bar
if int(tuple['x_pos']) < x_max - 3:
self.screen.addstr(0,20,tuple_id + " ", curses.A_BOLD)
self.screen.refresh()
#self.screen.addstr(int(tuple['x_pos']), int(tuple['y_pos']), state, tuple['color'] | curses.A_BOLD)
#if int(tuple['x_pos']) <= xmax:
self.screen.addstr(int(tuple['x_pos']), int(tuple['y_pos']), state, tuple['color'])
#tuple['y_pos'] += len(state)
self.screen.refresh()
self.qscreen.task_done()
except KeyboardInterrupt:
curses.nocbreak()
self.screen.keypad(0)
curses.echo()
curses.curs_set(1)
curses.resetty()
self.screen.refresh()
except Exception as inst:
print '\tProblem with Screen()'
print type(inst) # the exception instance
print inst.args # arguments stored in .args
print inst # __str__ allows args to printed directly
sys.exit(1)
def color():
curses.start_color()
curses.init_pair(1, MATRIX_COLOR_WORD, MATRIX_COLOR_BACK)
curses.curs_set(0)
curses.noecho()
def draw(stdscr, srvurl, args, listOfQueries, dbg):
start_row = 0 # In units of rows of some height
start_col = 0 # In units of columns of some width
showInstance = False
step = 5 # Seconds
time = None
if args.start is not None:
time = datetime.fromisoformat(args.start).timestamp()
tables = []
for queries in listOfQueries:
tables.append(Table(srvurl, queries, dbg))
# Clear and refresh the screen for a blank canvas
stdscr.clear()
stdscr.refresh()
# Start colors in curses
curses.start_color()
curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLACK)
curses.init_pair(2, curses.COLOR_BLACK, curses.COLOR_WHITE)
curses.init_pair(3, curses.COLOR_CYAN, curses.COLOR_BLACK)
curses.init_pair(4, curses.COLOR_RED, curses.COLOR_BLACK)
curses.init_pair(5, curses.COLOR_YELLOW, curses.COLOR_BLACK)
# Attempt to turn off the cursor
curses.curs_set(False)
# Update the screen periodically, independent of input
stdscr.timeout(1000)
try:
# Loop where k is the last character pressed
k = 0
while (k != ord('q')):
# Initialization
#stdscr.erase()
height, width = stdscr.getmaxyx()
dbg.write('height %d, width %d\n' % (height, width))
if k == curses.KEY_DOWN:
start_row += 1
elif k == curses.KEY_UP:
start_row -= 1
elif k == curses.KEY_RIGHT:
start_col += 1
elif k == curses.KEY_LEFT:
start_col -= 1
elif k == curses.KEY_NPAGE:
start_col += height
elif k == curses.KEY_PPAGE:
start_col -= height
elif (k == ord('n') or k == ord(' ')) and time is not None:
time += step
elif (k == ord('p')) and time is not None:
time -= step
elif k == ord('+') and time is not None:
step += 1
elif k == ord('-') and time is not None:
if step > 1: step -= 1
elif k == ord('t') and time is not None:
time = None
elif k == ord('t') and time is None:
if args.start is not None:
time = datetime.fromisoformat(args.start).timestamp()
elif k == ord('i'):
showInstance = not showInstance
elif k == ord('h') or k == ord('?'):
showHelp(stdscr, args, listOfQueries, dbg)
k = 0
elif k == ord('\f'): # ^l
stdscr.clear()
y = 0
for table in tables:
samples = update(table.metrics, time)
table.update(len(samples), start_row, start_col, showInstance, width)
rows = table.draw(samples, height, width, y)
y += rows + 1
stdscr.addstr(y-1, 0, ' ' * width) # Clear line between tables
if time is not None:
entry = str(datetime.fromtimestamp(time))
entry = entry + ', step = ' + str(step) + ' s'
stdscr.addstr(height - 1, 0, entry, curses.color_pair(2))
# Refresh the screen
curses.doupdate() #refresh()
# Wait for next input
k = stdscr.getch()
except:
dbg.done()
raise
else:
dbg.done()
def main():
dead = False
stdscr = curses.initscr()
curses.start_color()
curses.init_pair(1, curses.COLOR_YELLOW, curses.COLOR_BLACK)
curses.init_pair(2, curses.COLOR_GREEN, curses.COLOR_BLACK)
curses.raw()
curses.noecho()
curses.cbreak()
stdscr.nodelay(True)
stdscr.keypad(True)
curses.curs_set(0)
maxyx = stdscr.getmaxyx()
frame = 0
seconds = 0
score = 0
prevscore = 0
accelerationFlappy = 1
upthrustFlappy = 0
tubes = genTubes(stdscr)
flappyPos = [math.trunc(maxyx[0] / 2) - 20, math.trunc(maxyx[1] / 2)]
drawTitle(stdscr, prevscore)
drawControls(stdscr)
while (dead != True):
if (frame > 59):
frame = 0
seconds += 1
else:
frame += 1
upthrustFlappy -= 0.1
#draw frame
drawFlappy(stdscr, flappyPos)
drawTubes(stdscr, tubes)
drawUI(stdscr, score)
#keyboard input
try:
c = stdscr.getkey()
except:
c = 0
#moving, quitting, and all that stuff
if (c == 'q'):
gameover(stdscr, score)
break
elif (c == ' '):
upthrustFlappy += 3
elif (c == 'p'):
while (stdscr.getch() == curses.ERR):
drawFlappy(stdscr, flappyPos)
drawTubes(stdscr, tubes)
drawUI(stdscr, score)
stdscr.addstr(math.trunc(maxyx[0] / 2),
math.trunc(maxyx[1] / 2 - 3), "PAUSED")
stdscr.refresh()
time.sleep(0.016)
#game loop stuff
flappyPos[0] -= math.trunc(accelerationFlappy * upthrustFlappy)
if (frame % 2 == 0):
flappyPos[0] += accelerationFlappy
if (frame % 3 == 0):
for i in tubes:
i[0][1] -= 2
i[1][1] -= 2
if (flappyPos[0] < 0):
flappyPos[0] = 0
upthrustFlappy /= 2
for i in tubes:
if (flappyPos[0] < i[0][0] and flappyPos[1] + 6 >= i[0][1] - 9
and flappyPos[1] + 6 <= i[0][1] + 9
or flappyPos[0] + 8 > i[1][0]
and flappyPos[1] + 6 >= i[1][1] - 9
and flappyPos[1] + 6 <= i[1][1] + 9):
time.sleep(3)
curses.flash()
gameover(stdscr, score)
dead = True
score = 0
for i in tubes:
if (flappyPos[1] > i[0][1]):
score += 1
if (flappyPos[0] > maxyx[0]):
time.sleep(3)
curses.flash()
gameover(stdscr, score)
dead = True
#
stdscr.refresh()
stdscr.erase()
time.sleep(0.016)
curses.endwin()
def main(func):
# initializing curses
stdscr = curses.initscr()
# make the cursor invisible
curses.curs_set(0)
stdscr.addstr(0, 0, "Start time: ")
stdscr.addstr(1, 0, "End time: ")
stdscr.addstr(3, 0, "Difference: ")
# a counter to track the number of pressing <SPACE>
space_pressed = 0
while True:
# wait for a keypress
c = stdscr.getch()
# if <SPACE> is pressed...
if c == ord(" "):
space_pressed += 1
# print the start time
if space_pressed == 1:
start_time = datetime.now()
stdscr.addstr(0, 12, start_time.strftime("%H:%M:%S"))
# show end time and difference
elif space_pressed == 2:
end_time = datetime.now()
stdscr.addstr(1, 10, end_time.strftime("%H:%M:%S"))
difference = end_time - start_time
minutes, seconds = divmod(difference.seconds, 60)
hours, minutes = divmod(minutes, 60)
# format the output
seconds = "%02d" % seconds if seconds < 10 else seconds
minutes = "%02d" % minutes if minutes < 10 else minutes
hours = "%02d" % hours if hours < 10 else hours
stdscr.addstr(3, 12, "%s:%s:%s" % (hours, minutes, seconds))
# delete the calculated data and start again
elif space_pressed == 3:
# delete start time
for col in xrange(12, 25):
stdscr.delch(0, 12)
# delete end time
for col in xrange(10, 25):
stdscr.delch(1, 10)
# delete difference time
for col in xrange(12, 25):
stdscr.delch(3, 12)
# reset the counter and restart
space_pressed = 0
# quit the app if `q` is pressed
elif c == ord("q"):
return
def draw(stdscr, logging):
k = 0
cursor_x = 0
cursor_y = 0
curses.noecho ()
curses.curs_set (0)
curses.raw ()
stdscr.keypad (0)
# Clear and refresh the screen for a blank canvas
stdscr.clear()
stdscr.refresh()
stdscr.nodelay (True)
y, x = stdscr.getmaxyx ()
stdscr.setscrreg (1, y-1)
stdscr.scrollok (True)
# Start colors in curses
curses.start_color()
curses.init_pair(1, curses.COLOR_CYAN, curses.COLOR_BLACK)
curses.init_pair(2, curses.COLOR_RED, curses.COLOR_BLACK)
curses.init_pair(3, curses.COLOR_BLACK, curses.COLOR_WHITE)
gameState = state.State(logging)
statusbarstr = 'Enter Command: '
gameController = controller.Controller(logging)
# Loop where k is the last character pressed
error = ''
win = False
while True:
# Initialization
stdscr.erase()
height, width = stdscr.getmaxyx()
if win:
stdscr.addstr(height//2, width//2, 'You Won')
stdscr.refresh()
time.sleep(5)
break
draw_state(stdscr, gameState, logging)
if error:
stdscr.attron(curses.color_pair(2))
stdscr.addstr(height-2, 0, error)
stdscr.attroff(curses.color_pair(2))
# Render status bar
stdscr.attron(curses.color_pair(3))
stdscr.addstr(height-1, 0, statusbarstr)
#stdscr.addstr(height-1, len(statusbarstr), " " * (width - len(statusbarstr) - 1))
sub2 = stdscr.subwin(1, 8, height-1, len(statusbarstr))
tb = curses.textpad.Textbox(sub2)
stdscr.refresh()
tb.edit()
message = tb.gather()
if message and message[0] == 'q':
break
error, gameState = gameController.applyMove(message, gameState)
win = gameController.checkWinState(gameState)
stdscr.attroff(curses.color_pair(3))
# Refresh the screen
stdscr.refresh()
curses.endwin()
curses.curs_set(1)
curses.reset_shell_mode()
curses.echo()
screen = curses.initscr()
color()
lastchr = string.join(list(MATRIX_THANKS_CHARS), " ")
last_height, last_width = screen.getmaxyx()
start_width = last_width / 2 - len(lastchr) / 2
for i in range(last_height / 2):
screen.clear()
screen.addstr(i, start_width, lastchr, curses.color_pair(1))
screen.refresh()
time.sleep(0.2)
screen.getch()
curses.endwin()
try:
main()
except KeyboardInterrupt:
try:
last_main()
except KeyboardInterrupt:
curses.endwin()
curses.curs_set(1)
curses.reset_shell_mode()
curses.echo()
def inicio(c4, scr):
menu = ["Iniciar Sesion", "Crear Usuario", "Salir"]
# primer elemento para la pocision del "cursor" en el menu
# segundo elemento para la accion que se realizo
selc = (0,0)
# Primera capa se ejecuta hasta que se haya iniciado sesion
while c4.jugador == None:
print_menu(scr, menu, selc[0])
selc = mover_menu(scr, selc, len(menu)-1)
user = ""
password = ""
if selc[1] == 1:
# Limpiar pantalla antes de cambiar de menu
scr.clear()
# Opcion 0 = Iniciar Sesion
if selc[0] == 0:
selc_inicio = (0,0)
while True:
menu_inicio = ["Usuario:", "Contrasena:", "Iniciar Sesion", "Cancelar"]
print_menu(scr, menu_inicio, selc_inicio[0])
# colocar el nombre de usuario, vacio al principio,
scr.addstr(2,11,user)
selc_inicio = mover_menu(scr, selc_inicio, len(menu_inicio)-1)
if selc_inicio[1] == 1:
# Opcion 0 = Usuario
if selc_inicio[0] == 0:
print_menu(scr, menu_inicio, selc_inicio[0])
# Preparar la terminal para ingresar el usuario
curses.echo()
scr.addstr(2,11," "*len(user))
scr.move(2,11)
curses.curs_set(1)
user = scr.getstr().decode(encoding="utf-8")
# Regresar la terminal al estado anterior
curses.noecho()
curses.curs_set(0)
# Opcion 0 = Contrasena
elif selc_inicio[0] == 1:
# Preparar la terminal para ingresar la contrasena
scr.move(3,14)
curses.curs_set(1)
password = scr.getstr().decode(encoding="utf-8")
# Regresar la terminal al estado anterior
curses.curs_set(0)
# Opcion 2 = Iniciar Sesion
elif selc_inicio[0] == 2:
if c4.iniciar_sesion(user, password):
break
else:
scr.addstr(7,2,"NOMBRE DE USUARIO O CONTRASENA INCORRECTOS")
else:
break
# Salir con flecha izquierda
elif selc_inicio[1] == -1:
break
scr.clear()
# Opcion 2 = Crear Usuario, practicamente igual a iniciar sesion
elif selc[0] == 1:
selc_crear = (0,0)
while True:
menu_crear = ["Usuario:", "Contrasena:", "Crear Usuario", "Cancelar"]
print_menu(scr, menu_crear, selc_crear[0])
scr.addstr(2,11,user)
selc_crear = mover_menu(scr, selc_crear, len(menu_crear)-1)
if selc_crear[1] == 1:
if selc_crear[0] == 0:
print_menu(scr, menu_crear, selc_crear[0])
curses.echo()
scr.move(2,11)
curses.curs_set(1)
user = scr.getstr().decode(encoding="utf-8")
curses.noecho()
curses.curs_set(0)
elif selc_crear[0] == 1:
scr.move(3,14)
curses.curs_set(1)
password = scr.getstr().decode(encoding="utf-8")
curses.curs_set(0)
elif selc_crear[0] == 2:
if c4.crear_usuario(user, password):
break
else:
scr.addstr(7,2,"NOMBRE DE USUARIO NO DISPONIBLE")
else:
break
elif selc_crear[1] == -1:
break
scr.clear()
elif selc[0] == 2:
break
scr.clear()
def _init_curses_and_play(self, screen):
"""Set up an already-running curses; do interaction loop.
This method is intended to be passed as an argument to `curses.wrapper`,
so its only argument is the main, full-screen curses window.
Args:
screen: the main, full-screen curses window.
Raises:
ValueError: if any key in the `keys_to_actions` dict supplied to the
constructor has already been reserved for use by `CursesUi`.
"""
# This needs to be overwritten to use `self._env.step()` instead of
# `self._game.play()`.
# See whether the user is using any reserved keys. This check ought to be in
# the constructor, but it can't run until curses is actually initialised, so
# it's here instead.
for key, action in self._keycodes_to_actions.items():
if key in (curses.KEY_PPAGE, curses.KEY_NPAGE):
raise ValueError(
'the keys_to_actions argument to the CursesUi constructor binds '
'action {} to the {} key, which is reserved for CursesUi. Please '
'choose a different key for this action.'.format(
repr(action), repr(curses.keyname(key))))
# If the terminal supports colour, program the colours into curses as
# "colour pairs". Update our dict mapping characters to colour pairs.
self._init_colour()
curses.curs_set(0) # We don't need to see the cursor.
if self._delay is None:
screen.timeout(-1) # Blocking reads
else:
screen.timeout(
self._delay) # Nonblocking (if 0) or timing-out reads
# Create the curses window for the log display
rows, cols = screen.getmaxyx()
console = curses.newwin(rows // 2, cols, rows - (rows // 2), 0)
# By default, the log display window is hidden
paint_console = False
# Kick off the game---get first observation, repaint it if desired,
# initialise our total return, and display the first frame.
self._env.reset()
self._game = self._env.current_game
# Use undistilled observations.
observation = self._game._board # pylint: disable=protected-access
if self._repainter: observation = self._repainter(observation)
self._display(screen,
observation,
self._env.episode_return,
elapsed=datetime.timedelta())
# Oh boy, play the game!
while not self._env._game_over: # pylint: disable=protected-access
# Wait (or not, depending) for user input, and convert it to an action.
# Unrecognised keycodes cause the game display to repaint (updating the
# elapsed time clock and potentially showing/hiding/updating the log
# message display) but don't trigger a call to the game engine's play()
# method. Note that the timeout "keycode" -1 is treated the same as any
# other keycode here.
keycode = screen.getch()
if keycode == curses.KEY_PPAGE: # Page Up? Show the game console.
paint_console = True
elif keycode == curses.KEY_NPAGE: # Page Down? Hide the game console.
paint_console = False
elif keycode in self._keycodes_to_actions:
# Convert the keycode to a game action and send that to the engine.
# Receive a new observation, reward, pcontinue; update total return.
action = self._keycodes_to_actions[keycode]
self._env.step(action)
# Use undistilled observations.
observation = self._game._board # pylint: disable=protected-access
if self._repainter: observation = self._repainter(observation)
# Update the game display, regardless of whether we've called the game's
# play() method.
elapsed = datetime.datetime.now() - self._start_time
self._display(screen, observation, self._env.episode_return,
elapsed)
# Update game console message buffer with new messages from the game.
self._update_game_console(
plab_logging.consume(self._game.the_plot), console,
paint_console)
# Show the screen to the user.
curses.doupdate()
def gui(stdscr, args, tegra):
# In this program, we don't want keystrokes echoed to the console,
# so we run this to disable that
curses.noecho()
# Additionally, we want to make it so that the user does not have to press
# enter to send keys to our program, so here is how we get keys instantly
curses.cbreak()
# Define pairing colorss
curses.init_pair(1, curses.COLOR_RED, curses.COLOR_BLACK)
curses.init_pair(2, curses.COLOR_GREEN, curses.COLOR_BLACK)
curses.init_pair(3, curses.COLOR_YELLOW, curses.COLOR_BLACK)
curses.init_pair(4, curses.COLOR_BLUE, curses.COLOR_BLACK)
curses.init_pair(5, curses.COLOR_MAGENTA, curses.COLOR_BLACK)
curses.init_pair(6, curses.COLOR_CYAN, curses.COLOR_BLACK)
# Hide the cursor
curses.curs_set(0)
# Lastly, keys such as the arrow keys are sent as funny escape sequences to
# our program. We can make curses give us nicer values (such as curses.KEY_LEFT)
# so it is easier on us.
stdscr.keypad(True)
# Refreshing page curses loop
# https://stackoverflow.com/questions/54409978/python-curses-refreshing-text-with-a-loop
stdscr.nodelay(1)
# Initialization Menu
pages = JTOPGUI(stdscr, [
{
"name": "ALL",
"func": all_info
},
{
"name": "GPU",
"func": GPU
},
{
"name": "INFO",
"func": Variables
},
])
# Start with selected page
pages.set(args.page)
# Here is the loop of our program, we keep clearing and redrawing in this loop
while True:
# First, clear the screen
stdscr.erase()
# Draw pages
pages.draw(tegra)
# Draw the screen
stdscr.refresh()
# Set a timeout and read keystroke
stdscr.timeout(args.refresh)
key = stdscr.getch()
# keyboard check list
if key == curses.KEY_LEFT:
pages.decrease()
elif key == curses.KEY_RIGHT:
pages.increase()
elif key in [ord(str(n)) for n in range(10)]:
num = int(chr(key))
pages.set(num)
elif key == ord('q') or key == ord('Q'):
break
def start(self) -> None:
super().start()
with suppress(Exception):
curses.curs_set(0)
def reset(self):
curses.nocbreak()
curses.echo()
curses.curs_set(1)
curses.endwin()
def displayStrategyRun(individual):
input("press me")
#routine = gp.compile(individual, pset)
curses.initscr()
win = curses.newwin(YSIZE + 15, XSIZE + 15, 0, 0)
win.keypad(1)
curses.noecho()
curses.curs_set(0)
win.border(0)
win.nodelay(1)
win.timeout(60)
snake = None
if len(snakeList) > 0:
snake = copy.deepcopy(random.choice(snakeList))
else:
snake = SnakePlayer()
food = placeFood(snake)
for f in food:
win.addch(f[0], f[1], '@')
timer = 0
collided = False
while not collided and not timer == ((2 * XSIZE) * YSIZE):
# Set up the display
win.border(0)
win.addstr(0, 2, 'Score : ' + str(snake.score) + ' ')
win.addstr(19, 2, 'ScorA : ' + str("%4.3f" % (snake.aa)) + ' ')
win.addstr(20, 2, 'part1 : ' + str("%4.3f" % (snake.aaa)) + ' ')
win.addstr(21, 2, 'ScorB : ' + str("%4.3f" % (snake.bb)) + ' ')
win.addstr(22, 2, 'part2 : ' + str("%4.3f" % (snake.bbb)) + ' ')
win.addstr(23, 2, 'ScorC : ' + str("%4.3f" % (snake.cc)) + ' ')
win.addstr(24, 2, 'part3 : ' + str("%4.3f" % (snake.ccc)) + ' ')
win.addstr(25, 2, 'ScorD : ' + str("%4.3f" % (snake.dd)) + ' ')
win.addstr(26, 2, 'part4 : ' + str("%4.3f" % (snake.ddd)) + ' ')
win.getch()
## EXECUTE THE SNAKE'S BEHAVIOUR HERE ##
snake.updateDirection(individual, True)
snake.updatePosition()
if snake.body[0] in food:
snake.score += 1
for f in food:
win.addch(f[0], f[1], ' ')
food = placeFood(snake)
for f in food:
win.addch(f[0], f[1], '@')
timer = 0
else:
last = snake.body.pop()
win.addch(last[0], last[1], ' ')
timer += 1 # timesteps since last eaten
win.addch(snake.body[0][0], snake.body[0][1], 'o')
collided = snake.snakeHasCollided()
hitBounds = (timer == ((2 * XSIZE) * YSIZE))
curses.endwin()
print(collided)
print(hitBounds)
input("Press to continue...")
return snake.score,
def main(repo, rules, stdscr):
# initialize color pattern
curses.init_pair(COLOR_HELP, curses.COLOR_WHITE, curses.COLOR_BLUE)
curses.init_pair(COLOR_SELECTED, curses.COLOR_BLACK, curses.COLOR_WHITE)
curses.init_pair(COLOR_WARN, curses.COLOR_BLACK, curses.COLOR_YELLOW)
curses.init_pair(COLOR_OK, curses.COLOR_BLACK, curses.COLOR_GREEN)
# don't display the cursor
try:
curses.curs_set(0)
except curses.error:
pass
def rendercommit(win, state):
"""Renders the commit window that shows the log of the current selected
commit"""
pos = state["pos"]
rules = state["rules"]
rule = rules[pos]
ctx = rule.ctx
win.box()
maxy, maxx = win.getmaxyx()
length = maxx - 3
line = "changeset: {0}:{1:<12}".format(ctx.rev(), str(ctx))
win.addstr(1, 1, line[:length])
line = "user: {0}".format(util.shortuser(ctx.user()))
win.addstr(2, 1, line[:length])
bms = repo.nodebookmarks(ctx.node())
line = "bookmark: {0}".format(" ".join(bms))
win.addstr(3, 1, line[:length])
line = "files: {0}".format(",".join(ctx.files()))
win.addstr(4, 1, line[:length])
line = "summary: {0}".format(ctx.description().splitlines()[0])
win.addstr(5, 1, line[:length])
conflicts = rule.conflicts
if len(conflicts) > 0:
conflictstr = ",".join([str(r.ctx) for r in conflicts])
conflictstr = "changed files overlap with {0}".format(conflictstr)
else:
conflictstr = "no overlap"
win.addstr(6, 1, conflictstr[:length])
win.noutrefresh()
def helplines(mode):
if mode == MODE_PATCH:
help = """\
?: help, k/up: line up, j/down: line down, v: stop viewing patch
pgup: prev page, space/pgdn: next page, c: commit, q: abort
"""
else:
help = """\
?: help, k/up: move up, j/down: move down, space: select, v: view patch
d: drop, e: edit, f: fold, m: mess, p: pick, r: roll
pgup/K: move patch up, pgdn/J: move patch down, c: commit, q: abort
"""
return help.splitlines()
def renderhelp(win, state):
maxy, maxx = win.getmaxyx()
mode, _ = state["mode"]
for y, line in enumerate(helplines(mode)):
if y >= maxy:
break
addln(win, y, 0, line, curses.color_pair(COLOR_HELP))
win.noutrefresh()
def renderrules(rulesscr, state):
rules = state["rules"]
pos = state["pos"]
selected = state["selected"]
start = state["modes"][MODE_RULES]["line_offset"]
conflicts = [r.ctx for r in rules if r.conflicts]
if len(conflicts) > 0:
line = "potential conflict in %s" % ",".join(map(str, conflicts))
addln(rulesscr, -1, 0, line, curses.color_pair(COLOR_WARN))
for y, rule in enumerate(rules[start:]):
if y >= state["page_height"]:
break
if len(rule.conflicts) > 0:
rulesscr.addstr(y, 0, " ", curses.color_pair(COLOR_WARN))
else:
rulesscr.addstr(y, 0, " ", curses.COLOR_BLACK)
if y + start == selected:
addln(rulesscr, y, 2, rule, curses.color_pair(COLOR_SELECTED))
elif y + start == pos:
addln(rulesscr, y, 2, rule, curses.A_BOLD)
else:
addln(rulesscr, y, 2, rule)
rulesscr.noutrefresh()
def renderstring(win, state, output):
maxy, maxx = win.getmaxyx()
length = min(maxy - 1, len(output))
for y in range(0, length):
win.addstr(y, 0, output[y])
win.noutrefresh()
def renderpatch(win, state):
start = state["modes"][MODE_PATCH]["line_offset"]
renderstring(win, state, patchcontents(state)[start:])
def layout(mode):
maxy, maxx = stdscr.getmaxyx()
helplen = len(helplines(mode))
return {
"commit": (8, maxx),
"help": (helplen, maxx),
"main": (maxy - helplen - 8, maxx),
}
def drawvertwin(size, y, x):
win = curses.newwin(size[0], size[1], y, x)
y += size[0]
return win, y, x
state = {
"pos": 0,
"rules": rules,
"selected": None,
"mode": (MODE_INIT, MODE_INIT),
"page_height": None,
"modes": {MODE_RULES: {"line_offset": 0}, MODE_PATCH: {"line_offset": 0}},
"repo": repo,
}
# eventloop
ch = None
stdscr.clear()
stdscr.refresh()
while True:
try:
oldmode, _ = state["mode"]
if oldmode == MODE_INIT:
changemode(state, MODE_RULES)
e = event(state, ch)
if e == E_QUIT:
return False
if e == E_HISTEDIT:
return state["rules"]
else:
if e == E_RESIZE:
size = screen_size()
if size != stdscr.getmaxyx():
curses.resizeterm(*size)
curmode, _ = state["mode"]
sizes = layout(curmode)
if curmode != oldmode:
state["page_height"] = sizes["main"][0]
# Adjust the view to fit the current screen size.
movecursor(state, state["pos"], state["pos"])
# Pack the windows against the top, each pane spread across the
# full width of the screen.
y, x = (0, 0)
helpwin, y, x = drawvertwin(sizes["help"], y, x)
mainwin, y, x = drawvertwin(sizes["main"], y, x)
commitwin, y, x = drawvertwin(sizes["commit"], y, x)
if e in (E_PAGEDOWN, E_PAGEUP, E_LINEDOWN, E_LINEUP):
if e == E_PAGEDOWN:
changeview(state, +1, "page")
elif e == E_PAGEUP:
changeview(state, -1, "page")
elif e == E_LINEDOWN:
changeview(state, +1, "line")
elif e == E_LINEUP:
changeview(state, -1, "line")
# start rendering
commitwin.erase()
helpwin.erase()
mainwin.erase()
if curmode == MODE_PATCH:
renderpatch(mainwin, state)
elif curmode == MODE_HELP:
renderstring(mainwin, state, __doc__.strip().splitlines())
else:
renderrules(mainwin, state)
rendercommit(commitwin, state)
renderhelp(helpwin, state)
curses.doupdate()
# done rendering
ch = stdscr.getkey()
except curses.error:
pass
def init_curses():
curses.curs_set(0)
# self.screen.nodelay(1)
curses.mousemask(-1)
