def main(self):
curses.resize_term(49, 165)
self.window.clear()
self.window.refresh()
# draw the logo, set it to yellow colour
curses.init_pair(1, curses.COLOR_YELLOW, 0)
self.window.attron(curses.color_pair(1))
with open("./assets/ASCII_Art/leaderboard.txt", "r") as logo:
text = logo.readlines()
for row in range(1, len(text) + 1):
self.window.addstr(row, 43, text[row - 1])
self.window.refresh()
self.window.attroff(curses.color_pair(1))
six_seven = curses.newwin(40, 70, 7, 13)
six_nine = curses.newwin(40, 70, 7, 84)
score_board.ScoreBoard(six_seven, 59, 34,
'6:7').draw_score_board('6:7')
score_board.ScoreBoard(six_nine, 59, 34, '6:9').draw_score_board('6:9')
self.window.addstr(42, 64, "Press Enter to return to menu")
self.window.refresh()
key = self.window.getch()
if key == curses.KEY_ENTER or key in [10, 13]:
import winsound
winsound.PlaySound('./assets/music/clicking.wav',
winsound.SND_FILENAME)
import app
app.main(self.window)
def draw_menu(self, current_button):
self.window.clear()
curses.resize_term(49, 165)
width = 50
height = 4
start_y, start_x = 17, 55
gap = 1
for index, button in enumerate(buttons):
# draw button
if current_button == index + 1:
cur_btn = rectangle.Rectangle(self.window,
init_content=button,
top_row=True,
top_sym="X")
cur_btn.draw_rectangle(
(height * index) + gap + start_y, 0 + start_x,
(height * (index + gap)) + start_y, width + start_x)
else:
cur_btn = rectangle.Rectangle(self.window, init_content=button)
cur_btn.draw_rectangle(
(height * index) + gap + start_y, 0 + start_x,
(height * (index + gap)) + start_y, width + start_x, False)
self.window.refresh()
def main(win=None, argv=None):
if argv is None:
argv = sys.argv
curses.curs_set(0)
curses.resize_term(WINSIZE['height'], WINSIZE['width'])
dev = argv[1]
win = curses.newwin(WINSIZE['height'], WINSIZE['width'], 0, 0)
rig = control.Rig(dev)
for n in xrange(10):
rig.sendline('PS 1')
while True:
try:
rig.rxlines.get(timeout=0.5)
except gevent.queue.Empty:
break
rig.sendline('AI 1'); rig.rxlines.get()
rig.sendline('DL 1'); rig.rxlines.get()
rig.sendline('AG 0,1E'); rig.rxlines.get()
rig.sendline('AG 1,1B'); rig.rxlines.get()
rig.sendline('SQ 0,0A'); rig.rxlines.get()
rig.sendline('SQ 1,0A'); rig.rxlines.get()
rig.sendline('BC')
for n in xrange(2):
rig.sendline('BUF %s' % n)
rig.sendline('MC %s' % n)
rig.sendline('VMC %s' % n)
def rxloop():
while True:
msg = rig.rxlines.get()
update_screen(rig, win, msg)
gevent.spawn(rxloop).join()
raw_input()
def window_set(size):
curses.curs_set(0)
curses.resize_term(size[0] + 5, (size[1] + 2) * 2)
curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLUE)
curses.init_pair(2, curses.COLOR_WHITE, curses.COLOR_RED)
curses.init_pair(3, curses.COLOR_WHITE, curses.COLOR_GREEN)
def main(self):
curses.resize_term(49, 165)
# play background music
threading.Thread(target=self._play_background, daemon=True).start()
self.window.refresh()
curses.curs_set(0)
self.window.addstr(
7, 5,
f"Please enter number 1-{self.col_size} to insert: ")
# draw the logo, set it to yellow colour
curses.init_pair(1, curses.COLOR_YELLOW, 0)
self.window.attron(curses.color_pair(1))
state = 1 if self.game_mode == "6:7" else 2
with open(f"./assets/ASCII_Art/logo{state}.txt", "r") as logo:
logo_text = logo.readlines()
for row in range(1, len(logo_text) + 1):
self.window.addstr(row, 5, logo_text[row - 1])
self.window.refresh()
self.window.attroff(curses.color_pair(1))
# draw the score board
self._score_board()
# draw the game board
try:
board_win = curses.newwin(40, 100, 8, 5)
box_size = 5
except Exception:
board_win = curses.newwin(30, 100, 8, 5)
box_size = 4
self._board(board_win, box_size)
def cursesSetup(self):
# screen initialization and setup
self.screen = curses.initscr()
curses.curs_set(0)
self.screen.keypad(True)
curses.noecho()
curses.cbreak()
# self.screen.nodelay(1)
curses.start_color()
# Extra screen size just in case
curses.resize_term(40, 100)
# self.screen.border('|', '|', '-', '-', '+', '+', '+', '+')
# Colorpairs
curses.init_pair(1, curses.COLOR_WHITE,
curses.COLOR_BLACK) # Classic white fg, black bg
curses.init_pair(2, 240,
curses.COLOR_BLACK) # Wall dark-gray fg, black bg
curses.init_pair(3, curses.COLOR_GREEN,
curses.COLOR_BLACK) # Orc green fg, black bg
curses.init_pair(4, curses.COLOR_CYAN,
curses.COLOR_BLACK) # Sword blue fg, black bg
curses.init_pair(5, 11,
curses.COLOR_BLACK) # Player/XP-bar cyan fg, black bg
curses.init_pair(6, 13,
curses.COLOR_BLACK) # Fountain pink fg, black bg
curses.init_pair(7, 5,
curses.COLOR_BLACK) # Wizard purple fg, black bg
curses.init_pair(8, curses.COLOR_RED,
curses.COLOR_BLACK) # HP-bar red fg, red bg
curses.init_pair(9, curses.COLOR_YELLOW,
curses.COLOR_BLACK) # HP-bar red fg, red bg
curses.init_pair(100, curses.COLOR_BLACK,
curses.COLOR_WHITE) # Inverted (classic) colors
def resize(self, yx=None):
"""Resize UI to yx."""
if yx is None:
yx = self.screen.getmaxyx()
self.screen.erase()
curses.resize_term(yx[0], yx[1])
self.setup_windows()
def __enter__(self):
self.stdscr = curses.initscr()
curses.noecho()
curses.resize_term(self.window_h, self.window_w)
self.logpad = curses.newpad(self.logpad_h + 1, self.window_w)
self.fieldpad = curses.newpad(self.fieldpad_h + 1, self.window_w)
return self
def start(self):
curses.resize_term(self._height, self._width)
self._file = open(self._file_name, mode='rb')
self.__print_top()
self.__print_info()
self._stdscr.refresh()
self.__update_board()
while True:
try:
curses.curs_set(0)
if curses.is_term_resized(self._height, self._width):
curses.resize_term(self._height, self._width)
self._stdscr.refresh()
c = self._stdscr.getch()
if c == ord(self._char_quit):
break
elif c == ord(self._char_scroll_up):
if self._help_shown or self._exception_shown:
self.__clear_plane()
self.__update_board(scroll=-1)
elif c == 23:
if self._help_shown or self._exception_shown:
self.__clear_plane()
self.__update_board(scroll=-self._amount_lines)
elif c == ord(self._char_scroll_down):
if not self._is_end:
if self._help_shown or self._exception_shown:
self.__clear_plane()
self.__update_board(scroll=1)
elif c == 19:
if not self._is_end:
if self._help_shown or self._exception_shown:
self.__clear_plane()
self.__update_board(scroll=self._amount_lines)
elif c == ord(self._char_change_mode):
self._char_mode = not self._char_mode
if not self._help_shown and not self._exception_shown:
self.__update_board()
elif c == ord(self._char_show_help):
self.__clear_plane()
if not self._help_shown:
self.__show_help()
else:
self.__update_board()
self._help_shown = not self._help_shown
self._exception_shown = False
except Exception as exception:
self._exception_shown = True
self.__clear_plane()
self.__show_exception(exception)
self._file.close()
def main(self, window):
self.start(window)
curses.resize_term(42, 90)
while self.running:
self.event(window)
self.simulate(window)
self.render(window)
window.keypad(False)
def Redraw(self):
self.Sweep()
self.parent.Sweep()
y,x = self.parent.Dims()
c.resize_term(y,x)
self.Draw()
self.WriteMenu()
return
def __resize_terminal(self):
"""Function to run after resize events in the terminal"""
self.__get_window_dimensions()
curses.resize_term(self.rows, self.cols)
resize_window(self.header, 1, self.cols)
for layer in self.layers:
layer.resize_component(self.rows, self.cols)
def setScreenSize(self, width, height):
if PLATFORM_IS_WINDOWS:
subprocess.call(['mode', 'con:', 'cols={}'.format(width), 'lines={}'.format(height)], shell=True)
# There's no incoming sigwinch, so resize the terminal then redraw
curses.resize_term(height, width)
elif curses.is_term_resized(height, width):
# The resize is handled via sigwinch
print('\x1b[8;{};{}t'.format(height, width))
self.doResize += 1
def runmenu(menu, parent):
display("entering run...."+menu["title"])
# work out what text to display as the last menu option
if parent is None:
lastoption = "Exit"
else:
lastoption = "Return to %s menu" % parent["title"]
optioncount = len(menu["options"]) # how many options in this menu
pos=0 #pos is the zero-based index of the hightlighted menu option. Every time runmenu is called, position returns to 0, when runmenu ends the position is returned and tells the program what opt$
oldpos=None # used to prevent the screen being redrawn every time
x = None #control for while loop, let"s you scroll through options until return key is pressed then returns pos to program
# Loop until return key is pressed
while x !=ord("\n"):
# Action in loop if resize is True:
if resize is True:
y, x = screen.getmaxyx()
screen.clear()
curses.resize_term(y, x)
screen.refresh()
if pos != oldpos:
oldpos = pos
screen.border(0)
screen.addstr(2,2, menu["title"], curses.A_STANDOUT) # Title for this menu
screen.addstr(4,2, menu["subtitle"], curses.A_BOLD) #Subtitle for this menu
# Display all the menu items, showing the "pos" item highlighted
for index in range(optioncount):
textstyle = n
if pos==index:
textstyle = h
screen.addstr(5+index,4, "%s" % (menu["options"][index]["title"]), textstyle)
# Now display Exit/Return at bottom of menu
textstyle = n
if pos==optioncount:
textstyle = h
screen.addstr(5+optioncount,4, "%s" % (lastoption), textstyle)
screen.refresh()
# finished updating screen
x = screen.getch() # Gets user input
# What is user input?
if x >= ord("1") and x <= ord(str(optioncount+1)[0]):
pos = x - ord("0") - 1 # convert keypress back to a number, then subtract 1 to get index
elif x == 258: # down arrow
if pos < optioncount:
pos += 1
else: pos = 0
elif x == 259: # up arrow
if pos > 0:
pos += -1
else: pos = optioncount
# return index of the selected item
return pos
def _size_term(self):
"""Resize terminal, returns terminal size as [y,x]"""
curr_dim = self._screen.getmaxyx()
dims = [50, 150]
if curr_dim[0] < dims[0] or curr_dim[1] < dims[1]:
sys.stdout.write("\x1b[8;{rows};{cols}t".format(rows=dims[0], cols=dims[1]))
curses.resize_term(dims[0], dims[1])
return dims
else:
return curr_dim
def handle_terminal_size(self, stdscr):
if self.resize_term:
self.resize_terminal(self.height,
self.width + 2 * self.safe_columns)
curses.resize_term(self.height, self.width + 2 * self.safe_columns)
term_height, term_width = stdscr.getmaxyx()
if term_height >= self.height and term_width >= self.width:
term_size_ok = True # UI will fit in terminal.
else:
term_size_ok = False
return (term_size_ok, term_height, term_width)
def initialize(self):
curses.curs_set(0)
curses.resize_term(36, 120)
sh, sw = self.stdscr.getmaxyx()
while sh < 36 or sw < 80:
curses.resize_term(36, 120)
self.stdscr.clear()
sh, sw = self.stdscr.getmaxyx()
self.stdscr.addstr(0, 0, "Please increase screensize to at least 40x40, current %s %s"% (sh, sw))
self.stdscr.refresh()
time.sleep(0.5)
def __init__(self, jrp, stdscr):
self.jrp = jrp
self.r = 0
# Esto inicia la función encargado de gestinoar una cola de datos
self.queue = queue.Queue()
# Inicializar la interfaz
self.stdscr = stdscr
curses.noecho()
curses.cbreak()
curses.curs_set(0)
curses.doupdate()
self.stdscr.keypad(1)
self.stdscr.nodelay(1)
curses.start_color()
curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_WHITE)
curses.init_pair(2, curses.COLOR_WHITE, curses.COLOR_BLUE)
curses.resize_term(24, 80)
stdout.write("\x1b]2;Jamendo Radio Player\x07")
# Main window
self.win = curses.newwin(24, 80, 0, 0)
self.win.box()
self.win.addstr(0,2, "Jamendo Radio Player", curses.A_STANDOUT)
self.win.addstr(2,2, "Radios", curses.A_BOLD)
self.win.addstr(2, 25, 'Track info', curses.A_BOLD)
self.win.addstr(4, 25, 'Artist:', curses.A_BOLD)
self.win.addstr(6, 25, 'Title:', curses.A_BOLD)
controls = self.win.derwin(2, 78, 19, 1)
controls.bkgd(' ', curses.A_REVERSE)
controls.addstr(0, 2, 'z: Play/Pause, x: Stop, c: Change radio, d: Download actual track', 1)
controls.addstr(1, 2, 'a: Volume down, s: Volume up, q: Exit', 1)
controls.refresh()
# Subwindow for show the track tags
self.wintags = self.win.derwin(4, 45, 4, 34)
# Stattus bar
self.statusbar = self.win.derwin(2, 78, 21, 1)
self.statusbar.bkgd(' ', curses.color_pair(2))
# Actual download
self.downloadwin = self.statusbar.derwin(1, 78, 1, 0)
# Volume info
self.volumewin = self.statusbar.derwin(1, 19, 0, 58)
self.volumewin.addnstr(0, 0, 'Volume: ##########', 19)
self.win.overwrite(self.stdscr)
_thread.start_new_thread(self.__downloadFile, ())
def setsize(self):
try:
curses.resize_term(0, 0)
begx, begy = self.screen.getbegyx()
maxx, maxy = self.screen.getmaxyx()
self.screen.erase()
for w in self.winlist:
wbegx, wbegy = begx, begy
wmaxx, wmaxy = maxx, maxy
if w.align == "top":
wmaxx = w.size
begx += wmaxx
maxx -= wmaxx
elif w.align == "bottom":
wmaxx = w.size
wbegx += maxx - wmaxx
maxx -= wmaxx
elif w.align == "left":
wmaxy = w.size
begy += wmaxy
maxy -= wmaxy
elif w.align == "right":
wmaxy = w.size
wbegy += maxy - wmaxy
maxy -= wmaxy
elif w.align == "fill":
maxx = 0
maxy = 0
pass
else:
wmaxx = 0
wmaxy = 0
pass
w.setsize(wbegx, wbegy, wmaxx, wmaxy)
w.refresh()
except:
pass
finally:
self.screen.untouchwin()
self.screen.refresh()
def _resize_term(self):
if curses.is_term_resized(self.nlines, self.ncols):
self.nlines = self.window.getmaxyx()[0]
self.ncols = self.window.getmaxyx()[1]
if not SPACING:
self.drawable_cols = self.ncols
else:
self.drawable_cols = int(self.ncols / 2)
self.window.clear()
curses.resize_term(self.nlines, self.ncols)
self.window.refresh()
self._init_lines()
def resize_handler(self, signum: Optional[int],
frame) -> None: # type: ignore
# pylint: disable=unused-argument
"""Handles terminal window resizing events.
This method gets exploited to trigger a refresh of the entire TUI window.
In such a case it will be called as `resize_handler(None, None)`.
Args:
signum: signal number.
frame: unused argument, required by the function template.
"""
LOGGER.debug("Handling resize event.")
if signum == signal.SIGWINCH:
# update total dimension data
buf = struct.pack("HHHH", 0, 0, 0, 0)
# We use f_d = 0 as this redirects to STDIN under the hood, regardless of whether the
# application is actually running in the foreground or in a pseudo terminal.
buf = fcntl.ioctl(0, TIOCGWINSZ, buf)
self.height, self.width = struct.unpack("HHHH", buf)[0:2]
if signum is not None and not curses.is_term_resized(
self.height, self.width):
# when no signal number was given, this was a manually triggered event with the purpose
# of completely refreshing the screen
LOGGER.debug("Resize event did not have any effect: %dx%d",
self.width, self.height)
return
LOGGER.debug("New stdscr dimension determined to be %dx%d", self.width,
self.height)
# actually resize the terminal
curses.resize_term(self.height, self.width)
# clear and refresh for a blank canvas
self.stdscr.keypad(True)
self.stdscr.clear()
self.stdscr.refresh()
# update top statusbar
self.topbar.resize(1, self.width)
self.statusbar(self.topbar, STATE.topstatus)
self.topbar.refresh()
# update bottom statusbar
self.botbar.resize(1, self.width)
self.botbar.mvwin(self.height - 2, 0)
self.statusbar(self.botbar, self.infoline())
self.botbar.refresh()
# update prompt
self.prompt.resize(1, self.width)
self.prompt.refresh(0, 0, self.height - 1, 0, self.height,
self.width - 1)
# update viewport
self.viewport.resize(self.height - 3, self.width)
def draw(self):
"""Draw the UI."""
if self.maxyx != self.window.getmaxyx():
self.maxyx = self.window.getmaxyx()
curses.resize_term(*self.maxyx)
self.theme.refresh_layout(self.window)
for box in self.boxes:
box.clear()
box.update_rect(self.theme)
self.theme.borders(self.window)
for box in self.boxes:
if box is not None:
box.draw_()
def init_screen(stdscr):
stdscr.nodelay(1)
curses.resize_term(30, 120)
curses.curs_set(0)
curses.start_color()
curses.use_default_colors()
curses.init_pair(1, curses.COLOR_GREEN, curses.COLOR_BLACK)
curses.init_pair(2, curses.COLOR_RED, curses.COLOR_BLACK)
MAX_X = stdscr.getmaxyx()[1]
MAX_Y = stdscr.getmaxyx()[0]
DIVIDER_BOTTOM = MAX_Y - 4
return MAX_X, MAX_Y, DIVIDER_BOTTOM
def main(stdscr):
curses.curs_set(0)
curses.resize_term(50, 120)
window = curses.newwin(50, 120, 0, 0)
init_structures(window)
stdscr.keypad(True)
# Creando color
curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_WHITE)
#MENU
opt_selected = menu(window, 0)
while 1:
options = (0, 1, 2, 3, 4, 5)
key = stdscr.getch()
window.clear()
if key == curses.KEY_UP:
opt_selected -= 1
if opt_selected not in options:
opt_selected = 0
menu(window, opt_selected)
elif key == curses.KEY_DOWN:
opt_selected += 1
if opt_selected not in options:
opt_selected = 5
menu(window, opt_selected)
elif key == curses.KEY_ENTER or key in [10, 13]:
if opt_selected is 0:
snake(window)
elif opt_selected is 1:
window_score_board(window)
elif opt_selected is 2:
user_selection(window)
elif opt_selected is 3:
reports_window(window)
elif opt_selected is 4:
bulk_loading_users(window)
elif opt_selected is 5:
break
else:
menu(window, opt_selected)
elif key == 27:
menu(window, 0)
opt_selected = 0
else:
menu(window, opt_selected)
window.refresh()
def _refresh_winsize(self, screen=None):
old_winsize = self._winsize
self._winsize = self.window.getmaxyx()
if (screen is not None or old_winsize != self._winsize
or curses.is_term_resized(*old_winsize)):
curses.resize_term(*self._winsize)
if screen:
screen.pre_display(self)
self.screen = screen
self.screen.resize(self)
if screen:
self._render(time.time())
def _init_terminal(self, stdscr):
stdscr.clear()
stdscr.refresh()
min_h, min_w = 50, 100
term_height, term_width = stdscr.getmaxyx()
if term_height < min_h:
curses.resize_term(min_h, term_width)
term_height = min_h
if term_width < min_w:
curses.resize_term(term_height, min_w)
term_width = min_w
self.height, self.width = term_height, term_width
def init_main_screen(self):
if not self.screen:
self.screen = curses.initscr()
self._init_colors()
self.screen.keypad(1)
curses.noecho()
try:
curses.curs_set(0)
except:
pass
curses.resize_term(24, 80)
self.screen.clear()
self.screen.refresh()
else:
self.screen.refresh()
def main(stdscr):
# Clear screen
curses.init_pair(1, curses.COLOR_RED, curses.COLOR_BLACK)
curses.init_pair(2, curses.COLOR_GREEN, curses.COLOR_BLACK)
curses.halfdelay(2)
curses.resize_term(60, 200)
while True:
stdscr.clear()
write_header(stdscr)
write_stock_info(
stdscr,
["aapl", "msft", "googl", "amzn", "fb", "brk-a", "brk-b", "baba"])
stdscr.refresh()
process_input(stdscr.getch())
stdscr.getkey()
def __init__(self):
# Curses initialization
self.stdscr = initscr()
#self.stdscr.notimeout(0)
# Colors
curses.resize_term(HEIGHT, WIDTH)
curses.start_color()
self.br = str(curses.baudrate())
noecho()
cbreak()
self.stdscr.keypad(0) # Changed to 0
self.stdscr.nodelay(1)
curs_set(0)
self.stdscr.clear()
self.stdscr.border(0)
# stdscr functions made accessible through the Screen object
self.addstr = self.stdscr.addstr
self.getch = self.stdscr.getch
self.flushinp = curses.flushinp
self.refresh = self.stdscr.refresh
# Colours
self.init_pair = curses.init_pair
self.color_pair = curses.color_pair
self.COLOR_GREEN = curses.COLOR_GREEN
self.COLOR_BLACK = curses.COLOR_BLACK
# Effects
self.A_BLINK = curses.A_BLINK
self.A_UNDERLINE = curses.A_UNDERLINE
# List of all words to be drawn
# words: [[word, x, y, speed], ...]
self.words = []
# Buffer of current pressed keys
self.keys = []
# Score
self.score = 0
# Life
self.life = 3
# Game Over
self.game_over = False
def on_resize(self): try: screensize_y, screensize_x = self.stdscr.getmaxyx() curses.resize_term(screensize_y, screensize_x) # @UndefinedVariable height = screensize_y-self.reservedscreen; width = screensize_x self.pheight = height self.pwidth = width self.mypad.resize(self.pheight+Pad.padbuffersize, self.pwidth) (self.pposy, self.pposx) = self.mypad.getyx() (self.pmaxy, self.pmaxx) = self.mypad.getmaxyx() self.actualpmaxy = self.pmaxy-Pad.padbuffersize self.draw() except Exception as e: self.dlog.excpt(e, msg=">>>in Pad.on_resize()", cn=self.__class__.__name__)
def main(stdscr):
global log
# help(stdscr)
stdscr.keypad(True)
curses.curs_set(0)
curses.mousemask(curses.BUTTON1_CLICKED)
if platform == 'win32':
curses.resize_term(16, 34)
init_color()
log = Logger(stdscr)
board = Board(stdscr)
# board.set(Knight('BLUE'), (0, 0))
# board.set(Knight('BLUE'), (0, 1))
# board.set(Frost('RED'), (2, 2))
# board.set(Knight('RED'), (2, 3))
# board.set(Frost('RED'), (0, 2))
board.draw()
time.sleep(1)
card_selected = None
while True:
s = stdscr.getch()
# stdscr.addstr(4, x,curses.keyname(s), curses.A_BOLD)
cmd = ''
if 32 <= s <= 127:
cmd += str(curses.keyname(s))
stdscr.addstr(curses.keyname(s), curses.A_BOLD)
if s == ord('q'): # or x>=curses.LINES-3:
break
# else:
# stdscr.addstr(str(s))
if s == curses.KEY_MOUSE:
signal, pos = mouse_where(len(board.teams[board.turn].cards))
log(signal, pos)
if signal == 'END':
board.proceed()
# board.draw(stdscr)
elif signal == 'DECK':
card_selected = pos
elif signal == 'ABORT':
card_selected = None
elif signal == 'BOARD':
if card_selected is not None:
board.play(card_selected, pos)
# clear selection no matter play is valid or not
card_selected = None
board.draw()
def main():
parser = argparse.ArgumentParser()
parser.add_argument("file", help="Specify a filepath")
parser.add_argument('-o',
'--output',
help="Print output to a termonal",
action="store_true")
args = parser.parse_args()
if args.file:
chunks = build_dump(args)
else:
print(parser.usage)
curses.noecho()
curses.cbreak()
curses.resize_term(40, 125)
curses.curs_set(2)
show_menu(chunks)
curses.endwin()
def sudoku(screen, sudoku_blocks):
screen.clear()
curses.curs_set(0)
draw_frame(screen)
current_number_id = 1
draw_sudoku(screen, sudoku_blocks, current_number_id)
while True:
key = screen.getch()
if key == curses.KEY_RESIZE:
screen.clear()
curses.resize_term(0, 0)
if key == curses.KEY_RIGHT and current_number_id < 81:
current_number_id += 1
if key == curses.KEY_LEFT and current_number_id > 1:
current_number_id -= 1
if key == curses.KEY_UP and 0 < (current_number_id // 9) and 0 < current_number_id < 82:
current_number_id -= 9
if key == curses.KEY_DOWN and (current_number_id // 9) < 8 and 0 < current_number_id < 82:
current_number_id += 9
if 48 <= key <= 57:
change_number(current_number_id, key, sudoku_blocks)
if key == curses.KEY_ENTER or key in [10, 13] :
if is_sudoku_correct(screen,sudoku_blocks):
print_center(screen,"You WIN!")
time.sleep(3)
main_menu(screen,0)
break
else:
time.sleep(3)
main_menu(screen,0)
break
if key == 27:
exit_screen(screen)
draw_frame(screen)
draw_sudoku(screen, sudoku_blocks, current_number_id)
screen.refresh()
def main(window):
import GUI.game_board_page as board_page
import GUI.main_menu as main_menu
# start background music
import threading
background_music = threading.Thread(target=music, daemon=True)
# resize the window
curses.resize_term(49, 165)
# direct to menu page
background_music.start()
curses.curs_set(0)
try:
main_menu.main(window)
except Exception:
input("""If you are facing a 'addwstr() returned ERR' problem,
1. go to search bar, type scale, click the 'make everything bigger' button and adjust the scale to 125%""")
def cur(screen, life):
curses.init_pair(1, 4, curses.COLOR_CYAN)
curses.resize_term(life.max_y + 1, life.max_x * 2 + 1)
curses.curs_set(0)
screen.addstr(1,1,"*************************************", curses.color_pair(1))
screen.addstr(2,1,"* use Ctrl+C for ending the game *", curses.color_pair(1))
screen.addstr(3,1,"* press any key to start *", curses.color_pair(1))
screen.addstr(4,1,"*************************************", curses.color_pair(1))
screen.getch()
for bord in life:
screen.clear()
screen.border(0)
screen.timeout(500)
for cell in bord:
x = cell[0] * 2
y = life.max_y - cell[1]
screen.addstr(y,x," ", curses.color_pair(1))
screen.refresh()
screen.getch()
def run(self, stdscr):
"""Execute the terminal application"""
stdscr.clear()
curses.resize_term(LINES, COLUMNS)
curses.curs_set(0)
#Set the color pairs used by the application
for color in COLOR_DEFS:
curses.init_pair(*color)
self.settings = self.check_settings()
if self.settings is not None:
#Create the tornapi object
self.tornapi = TornAPI(self.settings.api_key)
#Create the windows
self.create_windows()
#Setup selection variables
user_selections=['basic', 'bars', 'travel', 'bazaar', 'attacks', 'events', 'messages']
torn_selections=['items']
#Refresh windows
#Update the user response
self.user_response = self.tornapi.get_user(selections=user_selections)
self.torninfo = TornInfo(**self.tornapi.get_torn(selections=torn_selections))
self.next_update = time.time() + int(self.settings.refresh_interval)
while True:
if time.time() >= self.next_update:
self.user_response = self.tornapi.get_user(selections=user_selections)
self.next_update = time.time() + int(self.settings.refresh_interval)
#Call the update method of every window
self.start_refresh_window()
#Wait for user input
#self.console.getstr(50, 1)
else:
#Settings are not present and could not be created
pass
def activate (self,y_max=100,x_max=225,y_pos=0,x_pos=0,entering=False):
self.screen = curses.initscr()
curses.resize_term(y_max,x_max)
self.screen.box()
curses.cbreak()
self.screen.clear()
curses.noecho()
self.screen.keypad(True)
self.bottom_window = self.create_frame(self.screen)
y_pos,x_pos, object_dict, textlist, boxedobject = self.moving_screen(self.screen,y_coord=y_pos,x_coord=x_pos,entering=entering)
curses.nocbreak()
self.screen.keypad(False)
curses.echo()
curses.endwin()
del self.screen
return y_pos,x_pos, object_dict, textlist, boxedobject
def main(screen):
board = System()
renderer = SystemRenderer()
curses.noecho()
curses.cbreak()
curses.curs_set(0)
curses.resize_term(128, 128)
curses.start_color()
screen.keypad(True)
curses.mousemask(True)
while True:
renderer.render(board, screen)
ch = screen.getch()
if ch == curses.KEY_MOUSE:
_, mx, my, _, _ = curses.getmouse()
node = get_node_at_mouse(board, my, mx)
if board.can_visit_node(node):
board.visit_node(node)
if ch == curses.KEY_ENTER:
board = System()
def start(self):
self.__stdscr = curses.initscr()
self.setup()
while True:
if self.__flags['quit']:
break
curr_time = time.time()
self.delta_time = curr_time - self.__old_time
self.__old_time = curr_time
self.update()
self.__clear_board()
for game_object in self.__game_objects:
game_object.delta_time = self.delta_time
game_object.update()
game_object.draw(self.__board)
try:
self.__update_board()
except size_error:
curses.resize_term(self.height + 5, self.width + 10)
self.__stdscr.refresh()
time.sleep(0.02)
def module_funcs(stdscr):
"Test module-level functions"
for func in [curses.baudrate, curses.beep, curses.can_change_color,
curses.cbreak, curses.def_prog_mode, curses.doupdate,
curses.filter, curses.flash, curses.flushinp,
curses.has_colors, curses.has_ic, curses.has_il,
curses.isendwin, curses.killchar, curses.longname,
curses.nocbreak, curses.noecho, curses.nonl,
curses.noqiflush, curses.noraw,
curses.reset_prog_mode, curses.termattrs,
curses.termname, curses.erasechar, curses.getsyx]:
func()
# Functions that actually need arguments
if curses.tigetstr("cnorm"):
curses.curs_set(1)
curses.delay_output(1)
curses.echo() ; curses.echo(1)
f = tempfile.TemporaryFile()
stdscr.putwin(f)
f.seek(0)
curses.getwin(f)
f.close()
curses.halfdelay(1)
curses.intrflush(1)
curses.meta(1)
curses.napms(100)
curses.newpad(50,50)
win = curses.newwin(5,5)
win = curses.newwin(5,5, 1,1)
curses.nl() ; curses.nl(1)
curses.putp('abc')
curses.qiflush()
curses.raw() ; curses.raw(1)
curses.setsyx(5,5)
curses.tigetflag('hc')
curses.tigetnum('co')
curses.tigetstr('cr')
curses.tparm('cr')
curses.typeahead(sys.__stdin__.fileno())
curses.unctrl('a')
curses.ungetch('a')
curses.use_env(1)
# Functions only available on a few platforms
if curses.has_colors():
curses.start_color()
curses.init_pair(2, 1,1)
curses.color_content(1)
curses.color_pair(2)
curses.pair_content(curses.COLOR_PAIRS - 1)
curses.pair_number(0)
if hasattr(curses, 'use_default_colors'):
curses.use_default_colors()
if hasattr(curses, 'keyname'):
curses.keyname(13)
if hasattr(curses, 'has_key'):
curses.has_key(13)
if hasattr(curses, 'getmouse'):
(availmask, oldmask) = curses.mousemask(curses.BUTTON1_PRESSED)
# availmask indicates that mouse stuff not available.
if availmask != 0:
curses.mouseinterval(10)
# just verify these don't cause errors
m = curses.getmouse()
curses.ungetmouse(*m)
if hasattr(curses, 'is_term_resized'):
curses.is_term_resized(*stdscr.getmaxyx())
if hasattr(curses, 'resizeterm'):
curses.resizeterm(*stdscr.getmaxyx())
if hasattr(curses, 'resize_term'):
curses.resize_term(*stdscr.getmaxyx())
def handle_resize(self):
self.maxy, self.maxx = self.stdscr.getmaxyx()
curses.resize_term(self.maxy, self.maxx)
self.update_title()
def main():
global screen
coordinates = recording_border()
generatemap(coordinates)
coordinates = creating(coordinates)
curses.endwin()
record = open('newmap.txt', 'w')
for i in range(0, len(coordinates)):
record.write(coordinates[i])
record.close()
print("Welcome to the map generator!\nYour new map will be saved in the 'newmap.txt' file.")
print("Use arrows to move the cursor.\nHere are your other control buttons:")
print("x: Put down a wall objective\nc: Put down a '*'(malicious) objective\nv: Put down a '+'(grav-changer) objective")
print("b: Put down a '#'(goal) objective\nn: Put down a 'N'(grav-off) objective\nq: Save and quit")
input("Press Enter to start!")
screen = curses.initscr()
curses.start_color()
curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_WHITE)
curses.init_pair(2, curses.COLOR_BLACK, curses.COLOR_RED)
curses.init_pair(3, curses.COLOR_MAGENTA, curses.COLOR_GREEN)
curses.init_pair(4, curses.COLOR_YELLOW, curses.COLOR_BLUE)
curses.init_pair(5, curses.COLOR_YELLOW, curses.COLOR_MAGENTA)
screen.keypad(1)
curses.cbreak()
curses.noecho()
screen.nodelay(1)
curses.resize_term(25, 81)
main()
def resizeScreen():
global currentStatus
stdscr.clear()
rows, columns = os.popen("stty size", "r").read().split()
curses.resize_term(int(rows), int(columns))
stdscr.refresh()
if stdscr.getmaxyx()[0] < 25 or stdscr.getmaxyx()[1] < 80:
deinitCurses()
print "Terminal must be more than 80x25!"
sys.exit()
leftHeight = stdscr.getmaxyx()[0] - 7
leftWidth = stdscr.getmaxyx()[1] / 4 - 6
leftY = 3
leftX = 4
global leftPadDim
leftPadDim = leftY + 1, leftX + 1, leftHeight + 1, leftWidth + 2
rightTitleHeight = 2
rightTitleWidth = stdscr.getmaxyx()[1] / 4 * 3 - 3
rightTitleY = leftY
rightTitleX = stdscr.getmaxyx()[1] / 4 + 1
rightHeight = leftHeight - rightTitleHeight
rightWidth = rightTitleWidth
rightY = rightTitleY + rightTitleHeight
rightX = rightTitleX
global rightPadDim
rightPadDim = rightY + 1, rightX + 1, rightHeight + 3, rightX + rightWidth - 2
global rightTitlePadDim
rightTitlePadDim = rightTitleY + 1, rightTitleX + 1, rightTitleY + 1, rightX + rightWidth - 2
statusHeight = 1
statusWidth = stdscr.getmaxyx()[1]
statusY = stdscr.getmaxyx()[0] - 2
statusX = 0
commandHeight = 1
commandWidth = stdscr.getmaxyx()[1]
commandY = stdscr.getmaxyx()[0] - 1
commandX = 0
hboxHeight = stdscr.getmaxyx()[0] * 3 / 4
hboxWidth = stdscr.getmaxyx()[1] * 3 / 4
hboxY = centerY(stdscr, hboxHeight) - 1
hboxX = centerX(stdscr, hboxWidth) + 2
left.mvderwin(leftY, leftX)
left.refresh()
left.resize(leftHeight, leftWidth)
left.refresh()
leftPanel.move(leftY, leftX)
rightPanel.move(rightY, rightX)
statusPanel.move(statusY, statusX)
commandPanel.move(statusY + 1, statusX)
right.mvderwin(rightY, rightX)
right.refresh()
right.resize(rightHeight, rightWidth)
right.refresh()
hbox.move(hboxY, hboxX)
hbox.resize(hboxHeight, hboxWidth)
hbox.refresh()
hboxShadow.move(hboxY, hboxX)
hboxShadow.resize(hboxHeight, hboxWidth)
hboxShadow.refresh()
hboxPanel.move(hboxY, hboxX)
hboxShadowPanel.move(hboxY + 1, hboxX + 2)
rightTitle.mvderwin(rightTitleY, rightTitleX)
rightTitle.refresh()
rightTitle.resize(rightTitleHeight, rightTitleWidth)
rightTitle.refresh()
###
# Set respective strings
####################################################################################
# Add string for title
if stdscr.getmaxyx()[1] > len(titlestring):
stdscr.addstr(0, centerX(stdscr, titlestring), titlestring, curses.color_pair(3) | curses.A_BOLD)
else:
stdscr.addstr(0, centerX(stdscr, 5), ". . .", curses.color_pair(3) | curses.A_BOLD)
status.mvderwin(statusY, statusX)
status.resize(statusHeight, statusWidth)
pushStatus(currentStatus)
command.mvderwin(commandY, commandX)
command.resize(commandHeight, commandWidth)
command.refresh()
###
# Backgrounds
####################################################################################
# Standard Screen
stdscr.bkgd(" ", curses.color_pair(3))
stdscr.bkgdset(" ", curses.color_pair(3))
# Left screen
left.bkgd(" ", curses.color_pair(4))
left.bkgdset(" ", curses.color_pair(4))
# Left Pad
leftPad.bkgd(" ", curses.color_pair(4))
leftPad.bkgdset(" ", curses.color_pair(4))
# Right Pad
rightPad.bkgd(" ", curses.color_pair(4))
rightPad.bkgdset(" ", curses.color_pair(4))
rightTitlePad.bkgd(" ", curses.color_pair(4))
rightTitlePad.bkgdset(" ", curses.color_pair(4))
# Right screen
right.bkgd(" ", curses.color_pair(4))
right.bkgdset(" ", curses.color_pair(4))
# Right title screen
rightTitle.bkgd(" ", curses.color_pair(4))
rightTitle.bkgdset(" ", curses.color_pair(4))
# Status screen
status.bkgd(" ", curses.color_pair(4))
status.bkgdset(" ", curses.color_pair(4))
# Command screen
command.bkgd(" ", curses.color_pair(5))
command.bkgdset(" ", curses.color_pair(5))
# Help screen
hbox.bkgd(" ", curses.color_pair(6))
hbox.bkgdset(" ", curses.color_pair(6))
hboxShadow.bkgd(" ", curses.color_pair(7))
hboxShadow.bkgdset(" ", curses.color_pair(7))
# Boxes and borders
hbox.box()
left.box()
rightTitle.border(
" ", " ", curses.ACS_HLINE, " ", curses.ACS_ULCORNER, curses.ACS_URCORNER, curses.ACS_VLINE, curses.ACS_VLINE
)
right.border(
curses.ACS_VLINE,
curses.ACS_VLINE,
curses.ACS_HLINE,
curses.ACS_HLINE,
curses.ACS_LTEE,
curses.ACS_RTEE,
curses.ACS_LLCORNER,
curses.ACS_LRCORNER,
)
# Left side header
stdscr.addstr(leftY - 1, leftX, selectstring, curses.color_pair(3))
# Right side header
stdscr.addstr(rightTitleY - 1, rightTitleX, tablestring, curses.color_pair(3))
# Fieldnames header
# rightTitle.addstr(1, centerX(rightTitle, fieldnames), fieldnames, curses.color_pair(4));
# Status screen default
rightTitlePad.erase()
rightPad.erase()
global rightTableString
global rightTitleString
rightTitlePad.addstr(rightTitleString)
rightPad.addstr(rightTableString)
rightTitlePad.refresh(0, 0, *rightTitlePadDim)
rightPad.refresh(0, 0, *rightPadDim)
if stdscr.getmaxyx()[1] > len(commandsString):
command.addstr(0, 0, commandsString)
else:
command.addstr(0, 0, "Terminal too small. . .")
command.refresh()
stdscr.refresh()
pass
