def test_key_input(self): """ Check that keyboard input works. """ def internal_checks(screen): # Inject a letter and check it is picked up self._inject_key(screen, ord("a")) ch = screen.get_event() self.assertEqual(ch.key_code, ord("a")) self.assertIsNone(screen.get_event()) # Inject a letter and check it is picked up self._inject_key(screen, Screen.KEY_BACK_TAB) ch = screen.get_event() self.assertEqual(ch.key_code, Screen.KEY_BACK_TAB) self.assertIsNone(screen.get_event()) # Check that get_key also works. self._inject_key(screen, ord("b")) ch = screen.get_key() self.assertEqual(ch, ord("b")) self.assertIsNone(screen.get_key()) # Check that unicode input also works self._inject_key(screen, ord(u"├")) ch = screen.get_event() self.assertEqual(ch.key_code, ord(u"├")) self.assertIsNone(screen.get_event()) Screen.wrapper(internal_checks, height=15, unicode_aware=True)
def test_play(self): """ Check that we can play a basic Effect in a Scene. """ def internal_checks(screen): # Since the Screen draws things, there's not too much we can do # to genuinely verify this without verifying all Scene and Effect # function too. Just play a dummy Effect for now. test_effect = MockEffect() screen.play([Scene([test_effect], 0)]) self.assertTrue(test_effect.stop_called) self.assertTrue(test_effect.reset_called) # Now check that the desired duration is used. test_effect = MockEffect(count=6) screen.play([Scene([test_effect], 15)]) self.assertFalse(test_effect.stop_called) self.assertTrue(test_effect.reset_called) # Now check that delete_count works. test_effect = MockEffect(count=6) test_effect2 = MockEffect(delete_count=3) scene = Scene([test_effect, test_effect2], 15) self.assertEqual(len(scene.effects), 2) screen.play([scene]) self.assertEqual(len(scene.effects), 1) self.assertEqual(scene.effects[0], test_effect) Screen.wrapper(internal_checks, height=15)
def test_last_pos(self): """ Check that screen drawing is efficient and unaffected by draw. """ def internal_checks(screen): # Should start with no known location. screen.reset() self.assertEqual(screen._cur_x, None) self.assertEqual(screen._cur_y, None) # Drawing should not affect latest update. This was previously # bugged - hence this test case! screen.move(0, 0) screen.draw(10, 10) self.assertEqual(screen._cur_x, None) self.assertEqual(screen._cur_y, None) # Printing should not affect latest update. screen.print_at("Hi", 12, 12) self.assertEqual(screen._cur_x, None) self.assertEqual(screen._cur_y, None) # Refresh should update the last drawn character. screen.refresh() self.assertEqual(screen._cur_x, 14) self.assertEqual(screen._cur_y, 12) Screen.wrapper( internal_checks, height=15, unicode_aware=False)
def test_limits(self): """ Check that get_from and print_at limit checking works. """ def internal_checks(screen): # Check we have some canvas dimensions self.assertEqual(screen.dimensions[1], screen.width) self.assertEqual(screen.dimensions[0], screen.height) # Basic limit checking self.assertIsNone(screen.get_from(-1, -1)) self.assertIsNone(screen.get_from(screen.width, screen.height)) # Printing off-screen should not fail, but do nothing. screen.print_at("hello", 0, -1) screen.print_at("hello", 0, screen.height) # Printing across screen edge should crop. screen.print_at("12345", -1, 0) char, fg, _, bg = screen.get_from(0, 0) self.assertEqual(char, ord("2")) self.assertEqual(fg, Screen.COLOUR_WHITE) self.assertEqual(bg, Screen.COLOUR_BLACK) Screen.wrapper( check_screen_and_canvas, height=15, arguments=[internal_checks])
def test_polygons(self): """ Check that filled polygons work as expected. """ def internal_checks(screen): screen.fill_polygon([[(0, 0), (10, 0), (0, 10), (10, 10)]]) screen.fill_polygon([[(20, 0), (30, 0), (30, 10), (25, 5), (20, 10)]]) screen.fill_polygon([[(40, 0), (45, 5), (50, 0), (50, 10), (40, 10)]]) screen.fill_polygon([[(60, 0), (70, 0), (70, 10), (60, 10)], [(63, 2), (67, 2), (67, 8), (63, 8)]]) self.maxDiff = None self.assert_canvas_equals( screen, "Y########7 ########## . . ########## \n" + " Y######7 ########## #. .# ########## \n" + " Y####7 ########## ##. .## ### ### \n" + " Y##7 ########## ###. .### ### ### \n" + " Y7 ########## ####..#### ### ### \n" + " .. ####7Y#### ########## ### ### \n" + " .##. ###7 Y### ########## ### ### \n" + " .####. ##7 Y## ########## ### ### \n" + " .######. #7 Y# ########## ########## \n" + ".########. 7 Y ########## ########## \n") Screen.wrapper( check_screen_and_canvas, height=10, unicode_aware=False, arguments=[internal_checks])
def test_palette(self): """ Check that we have a valid colour palette. """ def internal_checks(screen): # Check basic length self.assertGreater(screen.colours, 0) self.assertEqual(len(screen.palette), 256 * 3) # Should always have fundamental console colours for i, c in enumerate((0, 0, 0)): self.assertEqual(screen.palette[i], c) for i, c in enumerate((128, 0, 0)): self.assertEqual(screen.palette[i+3], c) for i, c in enumerate((0, 128, 0)): self.assertEqual(screen.palette[i+6], c) for i, c in enumerate((128, 128, 0)): self.assertEqual(screen.palette[i+9], c) for i, c in enumerate((0, 0, 128)): self.assertEqual(screen.palette[i+12], c) for i, c in enumerate((128, 0, 128)): self.assertEqual(screen.palette[i+15], c) for i, c in enumerate((0, 128, 128)): self.assertEqual(screen.palette[i+18], c) for i, c in enumerate((192, 192, 192)): self.assertEqual(screen.palette[i+21], c) Screen.wrapper(internal_checks, height=15)
def test_text_effects(self): """ Check effects can be played. """ # Skip for non-Windows if the terminal definition is incomplete. # This typically means we're running inside a non-standard termina;. # For example, thi happens when embedded in PyCharm. if sys.platform != "win32": curses.initscr() if curses.tigetstr("ri") is None: self.skipTest("No valid terminal definition") # A lot of effects are just about the visual output working when played # so check that playing a load of text effects doesn't crash. # # It's really not a great test, but it's important to show Effects are # dynamically compatible with Screen.play(). def internal_checks(screen): screen.play([ Scene([ MockEffect(count=5), Print(screen, FigletText("hello"), 2), Cycle(screen, FigletText("world"), 6), BannerText(screen, FigletText("world"), 10, 3), Mirage(screen, FigletText("huh?"), 14, 2)], 0)]) Screen.wrapper(internal_checks, height=25)
def test_origin(self): """ Check that Canvas origin is correct. """ def internal_checks(screen): canvas = Canvas(screen, 5, 5, 1, 2) self.assertEqual(canvas.origin, (1, 2)) Screen.wrapper(internal_checks, height=15)
def test_title(self): """ Check that we can change the screen title. """ def internal_checks(screen): # It's not possible to read values back, so just check code doesn't # crash. screen.set_title("Asciimatics test") Screen.wrapper(internal_checks, height=15)
def test_centre(self): """ Check that centre works as expected. """ def internal_checks(screen): screen.centre("1234", 0) char, fg, _, bg = screen.get_from((screen.width - 4) // 2, 0) self.assertEqual(char, ord("1")) self.assertEqual(fg, Screen.COLOUR_WHITE) self.assertEqual(bg, Screen.COLOUR_BLACK) Screen.wrapper(internal_checks, height=15)
def test_draw(self): """ Check that line drawing works as expected. """ def internal_checks(screen): # Draw thick and thin lines for line_type in (True, False): # Draw in opposite directions for start in range(0, 11, 10): screen.print_at(str(start), 11, 2) # Horizontal line screen.move(start, 0) screen.draw(10 - start, 0, thin=line_type) res = screen.get_from(1, 0) self.assertEqual(res[0], ord("^" if line_type else "#")) # Check clearing works too screen.draw(start, 0, char=" ", thin=line_type) res = screen.get_from(1, 0) self.assertEqual(res[0], ord(" ")) # Vertical line screen.move(0, start) screen.draw(0, 10 - start, thin=line_type) res = screen.get_from(0, 1) self.assertEqual(res[0], ord("|" if line_type else "#")) # Check clearing works too screen.draw(0, start, char=" ", thin=line_type) res = screen.get_from(0, 1) self.assertEqual(res[0], ord(" ")) # Diagonal line screen.move(0, start) screen.draw(10, 10 - start, thin=line_type) res = screen.get_from(1, 9 if start else 1) if line_type: self.assertEqual(res[0], ord("'" if start else "\\")) else: self.assertEqual(res[0], ord("7" if start else "Y")) # Check clearing works too screen.move(0, start) screen.draw(10, 10 - start, char=" ", thin=line_type) res = screen.get_from(1, 9 if start else 1) self.assertEqual(res[0], ord(" ")) Screen.wrapper( check_screen_and_canvas, height=15, unicode_aware=False, arguments=[internal_checks])
def test_next_scene(self): """ Check that we can play multiple Scenes. """ def internal_checks(screen): # First check that we can move between screens. test_effect1 = MockEffect(stop=False) test_effect2 = MockEffect(count=5) screen.play([ Scene([test_effect1], 5), Scene([test_effect2], 0)]) self.assertTrue(test_effect1.update_called) self.assertTrue(test_effect2.update_called) # Now check that we can start at the second scene. test_effect1 = MockEffect(stop=False) scene1 = Scene([test_effect1], 5, name="1") test_effect2 = MockEffect(count=3) scene2 = Scene([test_effect2], 0, name="2") screen.play([scene1, scene2], start_scene=scene2) self.assertFalse(test_effect1.update_called) self.assertTrue(test_effect2.update_called) # Now check that we can move to named scenes. test_effect1 = MockEffect(stop=False, next_scene="B") test_effect2 = MockEffect(count=5) screen.play([ Scene([test_effect1], 15, name="A"), Scene([test_effect2], 0, name="B")]) self.assertTrue(test_effect1.update_called) self.assertTrue(test_effect2.update_called) # Now check that bad names cause an exception. with self.assertRaises(RuntimeError): test_effect1 = MockEffect(stop=False, next_scene="C") test_effect2 = MockEffect(count=5) screen.play([ Scene([test_effect1], 15, name="A"), Scene([test_effect2], 0, name="B")]) self.assertTrue(test_effect1.update_called) self.assertFalse(test_effect2.update_called) # Now check that play stops at the end when repeat=False test_effect1 = MockEffect(stop=False) scene1 = Scene([test_effect1], 5, name="1") screen.play([scene1], repeat=False) self.assertTrue(test_effect1.update_called) Screen.wrapper(internal_checks, height=15)
def test_refresh(self): """ Check that refresh works. """ def internal_checks(screen): # Not much we can do here as refresh will draw to a screen we can't # query. Check that we don't hit an Exception on refresh(). screen.print_at("Hello world!", 0, 0, colour=Screen.COLOUR_CYAN, attr=Screen.A_BOLD, bg=Screen.COLOUR_BLUE) screen.refresh() Screen.wrapper( check_screen_and_canvas, height=15, arguments=[internal_checks])
def display(self): while True: try: # save the console so if the program encounters # a problem/exception we may be able to restore the console self._save_window() Screen.wrapper(self._start_app, catch_interrupt=False, arguments=[self.last_scene]) break except ResizeScreenError as e: self.last_scene = e.scene except Exception as e: print('Unhandled exception: ' + str(e)) self._restore_window() raise e
def test_visible(self): """ Check that is_visible works as expected. """ def internal_checks(screen): # Check some points that must always be visible self.assertTrue(screen.is_visible(0, 0)) self.assertTrue(screen.is_visible( screen.width - 1, screen.height - 1)) # Check some points that cannot be visible self.assertFalse(screen.is_visible(-1, -1)) self.assertFalse(screen.is_visible( screen.width, screen.height)) Screen.wrapper( check_screen_and_canvas, height=15, arguments=[internal_checks])
def test_scroll(self): """ Check that scrolling works as expected. """ def internal_checks(screen): # New screen is not scrolled. self.assertEqual(screen.start_line, 0) # Scroll and check it has moved screen.scroll() self.assertEqual(screen.start_line, 1) # Scroll to specific location and check it has moved screen.scroll_to(0) self.assertEqual(screen.start_line, 0) Screen.wrapper(internal_checks, height=15)
def test_unhandled_events(self): """ Check that default handling of events works as documented. """ def internal_checks(screen): # Check for exit for char in ("X", "x", "Q", "q"): with self.assertRaises(StopApplication): event = KeyboardEvent(ord(char)) screen._unhandled_event_default(event) for char in (" ", "\n"): with self.assertRaises(NextScene): event = KeyboardEvent(ord(char)) screen._unhandled_event_default(event) Screen.wrapper(internal_checks, height=15)
def test_wrapper_return(self): """ Check that you get the result back from the wrapped function. """ def internal_checks(_): return True self.assertTrue(Screen.wrapper(internal_checks))
def test_signal(self): """ Check that signals are restored after using _CursesScreen """ if sys.platform == "win32": self.skipTest("Windows does not have signals.") def dummy_signal_handler(): """Dummy previous signal handler.""" pass outer_state = _SignalState() self.assertNotEqual(signal.getsignal(signal.SIGWINCH), dummy_signal_handler) outer_state.set(signal.SIGWINCH, dummy_signal_handler) self.assertEqual(signal.getsignal(signal.SIGWINCH), dummy_signal_handler) Screen.wrapper(self.signal_check) self.assertEqual(signal.getsignal(signal.SIGWINCH), dummy_signal_handler) outer_state.restore() self.assertNotEqual(signal.getsignal(signal.SIGWINCH), dummy_signal_handler)
def test_uni_image_files(self): """ Check that the unicode ColourImageFile rendering works. """ # Skip for non-Windows if the terminal definition is incomplete. # This typically means we're running inside a non-standard terminal. # For example, this happens when embedded in PyCharm. if sys.platform != "win32": curses.initscr() if curses.tigetstr("ri") is None: self.skipTest("No valid terminal definition") def internal_checks(screen): # Check the original FG only rendering renderer = ColourImageFile( screen, os.path.join(os.path.dirname(__file__), "globe.gif"), height=10, uni=True, dither=True) # Check renderer got all images from the file. count = 0 for image in renderer.images: count += 1 self.assertIsNotNone(image) self.assertIsNotNone(len(image) <= renderer.max_height) self.assertEqual(count, 11) # Check an image looks plausible image = next(renderer.images) self.assertEqual( image, ['.', '.....▄▄▄▄▄▄▄▄▄▄......', '...▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄...', '.▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄..', '.▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄.', '▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄.', '▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄.', '.▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄.', '.▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄..', '...▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄...', '.....▄▄▄▄▄▄▄▄▄▄▄.....']) Screen.wrapper(internal_checks, height=15)
def test_putch_and_getch(self): """ Check deprecated features still work. """ def internal_checks(screen): for x in range(screen.width): for y in range(15): char = randint(0, 255) fg = randint(0, Screen.COLOUR_WHITE) bg = randint(0, Screen.COLOUR_WHITE) attr = randint(0, Screen.A_UNDERLINE) screen.putch(chr(char), x, y, fg, attr, bg) char2, fg2, attr2, bg2 = screen.getch(x, y) self.assertEqual(char, char2) self.assertEqual(fg, fg2) self.assertEqual(attr, attr2) self.assertEqual(bg, bg2) Screen.wrapper(internal_checks, height=15)
def test_highlight(self): """ Check that highlight works as expected. """ def internal_checks(screen): for x in range(screen.width): for y in range(15): char = randint(0, 255) fg = randint(Screen.COLOUR_RED, Screen.COLOUR_WHITE) bg = randint(Screen.COLOUR_RED, Screen.COLOUR_WHITE) attr = randint(0, Screen.A_UNDERLINE) screen.print_at(chr(char), x, y, fg, attr, bg) # Check BG highlight first. screen.highlight(-1, -1, screen.width + 2, screen.height + 2, bg=0) for x in range(screen.width): for y in range(15): _, fg2, _, bg2 = screen.get_from(x, y) self.assertEqual(bg2, 0) self.assertNotEqual(fg2, 0) # Now check FG highlighting. screen.highlight(-1, -1, screen.width + 2, screen.height + 2, fg=0) for x in range(screen.width): for y in range(15): _, fg2, _, bg2 = screen.get_from(x, y) self.assertEqual(bg2, 0) self.assertEqual(fg2, 0) # Now check blending. screen.print_at("*" * screen.width, 0, 0, Screen.COLOUR_CYAN, Screen.A_NORMAL, Screen.COLOUR_YELLOW) screen.highlight(0, 0, screen.width, 1, fg=0, bg=0, blend=50) for x in range(screen.width): _, fg2, _, bg2 = screen.get_from(x, 0) self.assertEqual(bg2, 0) self.assertEqual(fg2, 0) Screen.wrapper( check_screen_and_canvas, height=15, arguments=[internal_checks])
def test_paint(self): """ Check that paint with colour map works. """ def internal_checks(screen): # Put a simple colour map to screen. screen.paint( "Text", 0, 0, colour_map=((1, 0, 4), (2, 0, 3), (3, 0, 2), (4, 0, 1))) # Check it is rendered as expected. char, fg, _, bg = screen.get_from(0, 0) self.assertEqual(fg, 1) self.assertEqual(bg, 4) char, fg, _, bg = screen.get_from(3, 0) self.assertEqual(fg, 4) self.assertEqual(bg, 1) Screen.wrapper( check_screen_and_canvas, height=15, arguments=[internal_checks])
def test_print_and_get(self): """ Check that basic print_at and get_from work as expected. """ def internal_checks(screen): for x in range(screen.width): for y in range(15): char = randint(0, 255) fg = randint(0, Screen.COLOUR_WHITE) bg = randint(0, Screen.COLOUR_WHITE) attr = randint(0, Screen.A_UNDERLINE) screen.print_at(chr(char), x, y, fg, attr, bg) char2, fg2, attr2, bg2 = screen.get_from(x, y) self.assertEqual(char, char2) self.assertEqual(fg, fg2) self.assertEqual(attr, attr2) self.assertEqual(bg, bg2) Screen.wrapper( check_screen_and_canvas, height=15, arguments=[internal_checks])
def test_scroll_redraw(self): """ Check that scrolling works with screen locations. """ def internal_checks(screen): # New screen is not scrolled. self.assertEqual(screen.start_line, 0) # Scroll and check it has not moved screen.print_at("Hello", 0, 1) for i, c in enumerate("Hello"): self.assertEqual(screen.get_from(i, 1)[0], ord(c)) screen.scroll() for i, c in enumerate("Hello"): self.assertEqual(screen.get_from(i, 1)[0], ord(c)) screen.refresh() for i, c in enumerate("Hello"): self.assertEqual(screen.get_from(i, 1)[0], ord(c)) Screen.wrapper(internal_checks)
def test_windows_input(self): """ Check that extended keyboard input works on Windows. """ def internal_checks(screen): if sys.platform != "win32": self.skipTest("Only valid for Windows platforms") # Test no mapping by default self._inject_key(screen, Screen.KEY_NUMPAD0) self.assertIsNone(screen.get_event()) # Test switching on mapping picks up keys screen.map_all_keys(True) self._inject_key(screen, Screen.KEY_NUMPAD0) ch = screen.get_key() self.assertEqual(ch, Screen.KEY_NUMPAD0) self.assertIsNone(screen.get_key()) Screen.wrapper(internal_checks, height=15)
def test_wrapper(self): """ Check that you can create a blank Screen. """ def internal_checks(screen): # Check screen basically exists self.assertIsNotNone(screen) self.assertGreater(screen.width, 0) self.assertGreater(screen.height, 0) self.assertGreater(screen.colours, 0) # Check that the Screen is cleared ready for use. for x in range(screen.width): for y in range(screen.height): char, fg, attr, bg = screen.get_from(x, y) self.assertEqual(char, ord(" ")) self.assertEqual(fg, Screen.COLOUR_WHITE) self.assertEqual(attr, 0) self.assertEqual(bg, Screen.COLOUR_BLACK) Screen.wrapper(internal_checks)
def test_catch_exceptions(self): """ Check that we can catch exceptions (e.g. for ctrl-c). """ def internal_checks(screen): # Not much we can do here as refresh will draw to a screen we can't # query. Check that we don't hit an Exception on refresh(). if sys.platform == "win32": # Strictly speaking, this doesn't test catching ctrl-c as # it isn't possible to trigger the control handler (even if # we don't catch interrupts). Still a good basic check for # input, though. event = win32console.PyINPUT_RECORDType(win32console.KEY_EVENT) event.Char = u"\03" event.KeyDown = 1 event.RepeatCount = 1 event.ControlKeyState = win32con.LEFT_CTRL_PRESSED event.VirtualKeyCode = 67 event.VirtualScanCode = 46 screen._stdin.WriteConsoleInput([event]) event.KeyDown = 0 screen._stdin.WriteConsoleInput([event]) ch = screen.get_event() self.assertEqual(ch.key_code, 3) self.assertIsNone(screen.get_event()) else: # Check Ctrl-c (and no other input) os.kill(os.getpid(), signal.SIGINT) ch = screen.get_event() self.assertEqual(ch.key_code, 3) self.assertIsNone(screen.get_event()) # Check Ctrl-z (and no other input) os.kill(os.getpid(), signal.SIGTSTP) ch = screen.get_event() self.assertEqual(ch.key_code, 26) self.assertIsNone(screen.get_event()) Screen.wrapper(internal_checks, height=15, catch_interrupt=True)
def test_mouse_input(self): """ Check that mouse input works. """ def internal_checks(screen): # Inject a mouse move and check it is picked up self._inject_mouse(screen, 1, 2, 0) ev = screen.get_event() self.assertEqual(ev.x, 1) self.assertEqual(ev.y, 2) self.assertEqual(ev.buttons, 0) self.assertIsNone(screen.get_event()) # Check left click self._inject_mouse(screen, 2, 3, MouseEvent.LEFT_CLICK) ev = screen.get_event() self.assertEqual(ev.x, 2) self.assertEqual(ev.y, 3) self.assertEqual(ev.buttons, MouseEvent.LEFT_CLICK) self.assertIsNone(screen.get_event()) # Check right click self._inject_mouse(screen, 0, 0, MouseEvent.RIGHT_CLICK) ev = screen.get_event() self.assertEqual(ev.x, 0) self.assertEqual(ev.y, 0) self.assertEqual(ev.buttons, MouseEvent.RIGHT_CLICK) self.assertIsNone(screen.get_event()) # Check double click self._inject_mouse(screen, 0, 0, MouseEvent.DOUBLE_CLICK) ev = screen.get_event() self.assertEqual(ev.x, 0) self.assertEqual(ev.y, 0) self.assertEqual(ev.buttons, MouseEvent.DOUBLE_CLICK) self.assertIsNone(screen.get_event()) Screen.wrapper(internal_checks, height=15)
def test_forced_update(self): """ Check that forcing an update works as expected. """ def internal_checks(screen): # First check that Effects are always drawn at Scene start test_effect = MockEffect(count=101, stop_frame=101, frame_rate=100) screen.set_scenes([Scene([test_effect], 0)]) screen.draw_next_frame() self.assertTrue(test_effect.update_called) # Now check that the Screen honours the long frame rate... test_effect.update_called = False for _ in range(90): screen.draw_next_frame() self.assertFalse(test_effect.update_called) # Now check that the forced update works as expected. screen.force_update() screen.draw_next_frame() self.assertTrue(test_effect.update_called) Screen.wrapper(internal_checks, height=15)
def run_demo(): Screen.wrapper(asciimatics_demo)
from views.parameterizer.detail import Detail as Parameterizer from views.reserve.detail import Detail as Reserve from views.datatrust.detail import Detail as Datatrust from views.listing.detail import Detail as Listing last_scene = None def app(screen, scene): scenes = [ Scene([Dashboard(screen)], -1, name=S['DASHBOARD']), Scene([EtherToken(screen)], -1, name=S['ETHER_TOKEN']), Scene([MarketToken(screen)], -1, name=S['MARKET_TOKEN']), Scene([Voting(screen)], -1, name=S['VOTING']), Scene([Parameterizer(screen)], -1, name=S['PARAMETERIZER']), Scene([Reserve(screen)], -1, name=S['RESERVE']), Scene([Datatrust(screen)], -1, name=S['DATATRUST']), Scene([Listing(screen)], -1, name=S['LISTING']), ] screen.play(scenes, stop_on_resize=True, start_scene=scene, allow_int=True) if __name__ == '__main__': while True: try: Screen.wrapper(app, catch_interrupt=True, arguments=[last_scene]) sys.exit(0) except ResizeScreenError as e: last_scene = e.scene
def run_day10_animate(): Screen.wrapper(day10_animation)
self._instructions.delete_count = 1 else: # we have to create a new effect since the last one have been removed by the screen self._instructions = self._create_instructions_effect() self.add_effect(self._instructions) def _create_instructions_effect(self): x = int(self._screen.width * (config.instructions['position']['x'] / 100)) y = int(self._screen.height * (config.instructions['position']['y'] / 100)) return Print(self._screen, SpeechBubble(config.instructions['text'], uni=True), y, x) def pomodoro(screen: Screen) -> None: screen.play([PomodoroController(screen)], stop_on_resize=True) if __name__ == "__main__": timer = Timer(config.time['pomodoro']['m'], None) # This is the start of the Screen # Is called every time the screen is resized, so from here on everything must be stateless while True: try: Screen.wrapper(pomodoro, catch_interrupt=True) sys.exit(0) except ResizeScreenError: pass
def test_colour_image_file(self): """ Check that the ColourImageFile renderer works. """ # Skip for non-Windows if the terminal definition is incomplete. # This typically means we're running inside a non-standard terminal. # For example, this happens when embedded in PyCharm. if sys.platform != "win32": curses.initscr() if curses.tigetstr("ri") is None: self.skipTest("No valid terminal definition") def internal_checks(screen): # Check the original FG only rendering renderer = ColourImageFile(screen, os.path.join(os.path.dirname(__file__), "globe.gif"), height=10) # Check renderer got all images from the file. count = 0 for image in renderer.images: count += 1 self.assertIsNotNone(image) self.assertIsNotNone(len(image) <= renderer.max_height) self.assertEqual(count, 11) # Check an image looks plausible image = next(renderer.images) self.assertEqual(image, [ '', ' ##### ', ' ############# ', ' ################# ', ' ###################', '####################', '####################', ' ###################', ' ################## ', ' ############### ', ' ########### ' ]) # Also check the BG rendering renderer2 = ColourImageFile(screen, os.path.join(os.path.dirname(__file__), "globe.gif"), fill_background=True, height=10) # Check BG rendering doesn't change the text output. image2 = next(renderer2.images) self.assertEqual(image, image2) # Check BG rendering gives same colours for FG and BG as original # rendering for a, b in zip(renderer.rendered_text[1], renderer2.rendered_text[1]): for attr1, attr2 in zip(a, b): if attr1[0] is None: self.assertEqual(0, attr2[0]) self.assertEqual(0, attr2[2]) else: self.assertEqual(attr1[0], attr2[0]) self.assertEqual(attr2[0], attr2[2]) Screen.wrapper(internal_checks, height=15)
def start(): Screen.wrapper(demo)
#Cycle let cycle the color of the text we are passing it Cycle( screen, FigletText("Rensykes", font='big'), #you can use other Figlet int(screen.height / 2 - 8)), Cycle(screen, FigletText("Learn asciimatics!", font='small'), int(screen.height / 2 + 3)), Stars(screen, 500) #draw a certain ammpunt of stars ] screen.play([Scene(effects, 500)]) #renderize the scene with the effects ev = screen.get_key() #use it to get the key pressed if ev in (ord('Q'), ord('q')): return screen.refresh() def demo_helloWorld(screen): while True: screen.print_at('Hello world!', randint(0, screen.width), randint(0, screen.height), colour=randint(0, screen.colours - 1), bg=randint(0, screen.colours - 1)) ev = screen.get_key() if ev in (ord('Q'), ord('q')): return screen.refresh() Screen.wrapper(demo_helloWorld)
def main(): # parse args parser = argparse.ArgumentParser(description='Ping things') parser.add_argument('--range', type=str, help='network range, eg: 192.168.0.0/24', required=False, default='192.168.0.0/24') parser.add_argument('--time_out', type=int, help='time out for ping, in whole seconds', required=False, default=1) parser.add_argument( '--view', type=str, help='Columns to show', required=False, default= "flag,ip,ping,mean,best,worst,sd,up-time,last-outage,name,services,mac,manufacturer" ) parser.add_argument('--bw', help='Black/white mode (colour blind safe).', required=False, action='store_true', default=False) args = parser.parse_args() # configure app according to args ip_range = ipaddress.IPv4Network(args.range) time_out = args.time_out current_view = [c.strip() for c in args.view.split(",")] ping_stats = {} # PING_COL_SIZE = int(math.log10(int(time_out * 1000000))) + 1 def ping_thing(screen): unexplored_addresses = [ str(ip) for ip in ipaddress.IPv4Network(ip_range) ] range_len = len(unexplored_addresses) re_ping_freq = 2 last_refresh: int = 0 num_scans = 1 last_refresh_time = time.time() rescan_chunk_size = int(2 * (math.log2(len(unexplored_addresses) + 1) + 1)) refresh = True # grow the services col to fit col_sum = sum([c.width for c in col_config.values()]) if col_sum < screen.width and 'services' in col_config: col_config['services'].width += (screen.width - col_sum) while True: turbo_scan = num_scans < (range_len / rescan_chunk_size) # handle rescan if (time.time() - last_refresh_time) >= re_ping_freq: # explore known addresses and a few others (but not the whole network). effective_chunk_size = rescan_chunk_size * 2 if turbo_scan else rescan_chunk_size recheck_pos = (num_scans * effective_chunk_size ) % len(unexplored_addresses) to_check = [k for k in ping_stats.keys() ] + unexplored_addresses[recheck_pos:recheck_pos + effective_chunk_size] last_refresh_time = time.time() # do scans res = scan(to_check, time_out=1) new_ips = update_ping_stats(ping_stats, res) num_scans += 1 # port scan up to one new address # if not new_ips: un_scanned_ips = [ k for k in ping_stats.keys() if k not in port_scan_res ] if len(un_scanned_ips) > 0: ip = un_scanned_ips[0] port_scan_res[ip] = quick_port_scan(ip) # flag screen refresh refresh = True # get mac, scanning 2 at at time un_scanned_ips = [ k for k in ping_stats.keys() if k not in mac_scan_res ] for q in range(0, min(len(un_scanned_ips), 2)): ip = un_scanned_ips[q] mac_scan_res[ip] = mac_scan(ip) # has the effective second changed? if int(time.time()) != last_refresh: refresh = True last_refresh = int(time.time()) if refresh: # heading screen.print_at(f'PING THING (press q to exit)'.center( screen.width), 0, 0, colour=COLOUR_MAGENTA, bg=COLOUR_YELLOW) # col headings heading = "".join([ f'{col_config[h].heading}'.ljust(col_config[h].width) for h in current_view ]) heading = heading.ljust(screen.width) screen.print_at(heading, 0, 1, colour=COLOUR_YELLOW, bg=COLOUR_MAGENTA, attr=A_NORMAL) # list scan results for i in range(screen.height - 2): if i < len(ping_stats): print_row(i, ping_stats, current_view, screen) else: screen.print_at(" ...", 0, i + 2) # show info bar at bottom screen.print_at( f" ping unit=ms scans={num_scans}, network={ip_range}," f" explore={rescan_chunk_size}, time_out={time_out}". ljust(screen.width), 0, screen.height - 1, colour=COLOUR_WHITE, bg=COLOUR_BLUE, attr=A_NORMAL) refresh = False # handle UI ev = screen.get_key() if ev in (ord('Q'), ord('q')): return screen.refresh() Screen.wrapper(ping_thing)
self.state[2] += -0.2 def stop(self): self.state = [0, 0, 0] def update(self): self.car.move(self.state) return self.state def ui(screen): key = 0 ctl = Controller() while True: # catch keyboard event event = screen.get_event() if isinstance(event, KeyboardEvent): key = event.key_code if key == ord('q'): break if key in ctl.events: ctl.events[key]() # refresh the screen screen.clear() screen.print_at(str(ctl.update()), 0, 0) screen.refresh() time.sleep(0.1) Screen.wrapper(ui)
def show_title_screen(self): cls() Screen.wrapper(self.title_screen_graphics) self.title_screen_select()
@property def frame_update_count(self): # Only redraw if required - as determined by the update logic. return self._next_update @property def stop_frame(self): # No specific end point for this Effect. Carry on running forever. return 0 def reset(self): # Nothing special to do. Just need this to satisfy the ABC. pass def demo(screen, scene): screen.play([Scene([Map(screen)], -1)], stop_on_resize=True, start_scene=scene) if __name__ == "__main__": last_scene = None while True: try: Screen.wrapper(demo, catch_interrupt=False, arguments=[last_scene]) sys.exit(0) except ResizeScreenError as e: last_scene = e.scene
elif c in (ord("1"), ord("2")): self._state.mode = c - ord("0") elif c in (ord("m"), ord("M")): self._state.show_mini_map = not self._state.show_mini_map if self._state.show_mini_map: self.add_effect(self._mini_map) else: self.remove_effect(self._mini_map) elif c in (ord("h"), ord("H")): self.add_effect(PopUpDialog(self._screen, HELP, ["OK"])) else: # Not a recognised key - pass on to other handlers. return event else: # Ignore other types of events. return event def demo(screen, game_state): screen.play([GameController(screen, game_state)], stop_on_resize=True) if __name__ == "__main__": game_state = GameState() while True: try: Screen.wrapper(demo, catch_interrupt=False, arguments=[game_state]) sys.exit(0) except ResizeScreenError: pass
from functools import partial import dino_api from asciimatics.screen import Screen def main(screen): dino_api.play_game(partial(dummy_play, screen)) def dummy_play(screen, distance: int, size: int, speed: int) -> str: action = 'up' if distance - speed < 102 else '' screen.print_at('Distance: {:3d}'.format(distance), 0, 0, bg=1 if action else 0) screen.print_at('Size: {:3d}'.format(size), 0, 1) screen.print_at('Speed: {:3d}'.format(speed), 0, 2) screen.refresh() return action if __name__ == '__main__': Screen.wrapper(main)
.format(self.fps_rate, monitor.width, monitor.height, monitor.X, monitor.Y), shell=True, stdout=subprocess.DEVNULL, preexec_fn=os.setsid) self.emulating_monitor = monitor self.update_status() def exit(self, *args): print('Finishing...') if self.emulating_proccess is not None: self.emulating_proccess.terminate() subprocess.run(['reset']) sys.exit(0) if __name__ == '__main__': # Parse arguments parser = argparse.ArgumentParser( description='Helps stream desktop in Discord through virtual cams') parser.add_argument('--fps', dest='fps_rate', default="60", help="Sets FPS rate (default is 60)") args = parser.parse_args() # Probing v4l2loopback subprocess.run( 'sudo modprobe v4l2loopback video_nr=4 \'card_label=VirtualScreen\'', shell=True) Screen.wrapper(Main, arguments=(args, ))
def main(): Screen.wrapper(run)
elif inp == ord('d'): got_key = True cpu.inQ.put(4) next_pos[0] += 1 #Handle output if got_key: outp = cpu.outQ.get() if outp == 0: screen.print_at('█', next_pos[0], next_pos[1], 1) next_pos = [i for i in cur_pos] elif outp == 1: screen.print_at('.', cur_pos[0], cur_pos[1], 7) screen.print_at('D', next_pos[0], next_pos[1], 3) cur_pos = [i for i in next_pos] stepcount += 1 elif outp == 2: screen.print_at('.', cur_pos[0], cur_pos[1], 7) screen.print_at('X', next_pos[0], next_pos[1], 2) stepcount += 1 cur_pos = [i for i in next_pos] if cur_pos[0] != start_pos[0] and cur_pos[1] != start_pos[1]: screen.print_at('o', start_pos[0], start_pos[1], 3) screen.refresh() Screen.wrapper(robo) print(stepcount)
def show_clock(): try: Screen.wrapper(demo) sys.exit(0) except ResizeScreenError: pass
session.headers.update(headers) #block count r = requests.get("https://blockchain.info/q/getblockcount") #print("Block Count: ", r.content.decode("utf-8")) blockCount = r.content.decode("utf-8") # global variable for displaying #get Bitcoin info at the beginning threading.Thread(target=updateBitcoin).start() #parallel processes #threading.Thread(target=transactions).start() threading.Thread(target=footprintCalculator).start() ##screen management Screen.wrapper(on_screen_ready) midd = mido.MidiFile('the-miners2.midi') midd.play() for msgg in midd.play(): port.send(msgg) if msgg.type == 'note_on': #MINE! threading.Thread(target=mine).start() #print(msg) MIDImsg = '{}'.format(msgg) #add a counter notes per second to check this works
def welcome(screen): scenes = [] greenfire = GreenFire(screen.height + 10, screen.width, '*' * screen.width, 0.6, 60, screen.colours, bg=screen.colours >= 256) blackwater = FigletText('BLACKWATER', font='banner3') effects = [ Print(screen, greenfire, 0, speed=1, transparent=False), Print(screen, blackwater, screen.height - 18, speed=1, colour=Screen.COLOUR_BLACK, transparent=True) ] scenes.append(Scene(effects, 100)) screen.play(scenes) if __name__ == '__main__': while True: Screen.wrapper(welcome)
def wrapper(cls, func, watch=False): if watch and os.isatty(sys.stdout.fileno()): Screen.wrapper(func, height=1000, catch_interrupt=True) else: func(display)
return c #Returns total number of bugs in all levels def bugcount(): c = 0 for r in curstate.values(): for n in r: if n == '#': c += 1 return c def printlevel(r): print(curstate[r][:5]) print(curstate[r][5:10]) print(curstate[r][10:15]) print(curstate[r][15:20]) print(curstate[r][20:25]) file = open('Aoc_24.txt', 'r') curstate[0] = '' for line in file: curstate[0] += line.strip() file.close() #for i in range(200): # updstate() Screen.wrapper(bugs) print(bugcount())
def visual(self): qValues, scores, rewards = game.agentSolve(True) actions = [] gs2 = None s2 = 0 gs1 = game.gameState s1 = 0 def test(screen): #START: ASK FOR FOUR MOVES nonlocal gs2 gs = game.gameState h = 3 screen.print_at('CLICK FOUR VALID MOVES', 3, 2) for i in range(10): screen.print_at('+---+---+---+---+---+---+---+---+---+---+', 3, h, colour=Screen.COLOUR_WHITE) h += 1 screen.print_at('| | | | | | | | | | |', 3, h, colour=Screen.COLOUR_WHITE) h += 1 for i in range(0, 10): for j in range(0, 10): if gs.playerLoc[0] == j and gs.playerLoc[1] == i: screen.print_at(str('P'), 4 + 4*i, 4 + 2*j, colour=Screen.COLOUR_WHITE, bg=Screen.COLOUR_RED) elif gs.board[j][i]: screen.print_at(str(gs.board[j][i]), 4 + 4*i, 4 + 2*j, colour=Screen.COLOUR_WHITE, bg=Screen.COLOUR_BLACK) elif gs.double[0] == j and gs.double[1] == i: screen.print_at(str('2'), 4 + 4*i, 4 + 2*j, colour=Screen.COLOUR_YELLOW) screen.print_at('+---+---+---+---+---+---+---+---+---+---+', 3, h, colour=Screen.COLOUR_WHITE) screen.print_at('HOLDING: ' + str(gs.holding) + " ", 3, h + 1) screen.refresh() while (len(actions) < 4): click = screen.get_event() if isinstance(click, MouseEvent) and click.buttons and MouseEvent.LEFT_CLICK != 0: click.y = click.y - 4 click.y = math.floor(float(click.y) / 2) click.x = click.x - 4 click.x = math.floor(float(click.x) / 4) actions.append((click.y, click.x)) elif isinstance(click, MouseEvent): click.y = click.y - 4 click.y = math.floor(float(click.y) / 2) click.x = click.x - 4 click.x = math.floor(float(click.x) / 4) screen.print_at('MOUSEPOS: ' + '(' + str(click.y) + ' ' + str(click.x) + ')' + " ", 3, h + 2) s = '' for action in actions: s += str(action) + " " screen.print_at(s, 3, h + 3) screen.refresh() time.sleep(1) nonlocal s2 gs2 = game.gameState for action in actions: h = 3 screen.print_at('TAKING YOUR ACTIONS ', 3, 2) for i in range(10): screen.print_at('+---+---+---+---+---+---+---+---+---+---+',3, h, colour=Screen.COLOUR_WHITE) h += 1 screen.print_at('| | | | | | | | | | |', 3, h, colour=Screen.COLOUR_WHITE) h += 1 for i in range(0, 10): for j in range(0, 10): if gs2.playerLoc[0] == j and gs2.playerLoc[1] == i: screen.print_at(str('P'), 4 + 4*i, 4 + 2*j, colour=Screen.COLOUR_WHITE, bg=Screen.COLOUR_RED) elif gs2.board[j][i]: screen.print_at(str(gs2.board[j][i]), 4 + 4*i, 4 + 2*j, colour=Screen.COLOUR_WHITE, bg=Screen.COLOUR_BLACK) elif gs2.double[0] == j and gs2.double[1] == i: screen.print_at(str('2'), 4 + 4*i, 4 + 2*j, colour=Screen.COLOUR_YELLOW) screen.print_at('+---+---+---+---+---+---+---+---+---+---+', 3, h, colour=Screen.COLOUR_WHITE) screen.print_at('HOLDING: ' + str(gs2.holding) + " ", 3, h + 1) screen.print_at('SCORE: ' + format(s2, '.2f') + " ", 3, h + 2) if gs2 == game.gameState: screen.print_at('START ', 3, h + 3, bg=Screen.COLOUR_RED) else: screen.print_at(' ', 3, h + 3) nxt = gs2.getSuccessor(action) gs2 = nxt[0] s2 += nxt[1] screen.refresh() time.sleep(3) nonlocal gs1 nonlocal s1 count = 0 while gs1.getLegalActions() and count < 4: h = 3 screen.print_at('TAKING OPTIMAL ACTIONS FOR FOUR STEPS ', 3, 2) for i in range(10): screen.print_at('+---+---+---+---+---+---+---+---+---+---+',3, h, colour=Screen.COLOUR_WHITE) h += 1 screen.print_at('| | | | | | | | | | |', 3, h, colour=Screen.COLOUR_WHITE) h += 1 for i in range(0, 10): for j in range(0, 10): if gs1.playerLoc[0] == j and gs1.playerLoc[1] == i: screen.print_at(str('P'), 4 + 4*i, 4 + 2*j, colour=Screen.COLOUR_WHITE, bg=Screen.COLOUR_RED) elif gs1.board[j][i]: screen.print_at(str(gs1.board[j][i]), 4 + 4*i, 4 + 2*j, colour=Screen.COLOUR_WHITE, bg=Screen.COLOUR_BLACK) elif gs1.double[0] == j and gs1.double[1] == i: screen.print_at(str('2'), 4 + 4*i, 4 + 2*j, colour=Screen.COLOUR_YELLOW) screen.print_at('+---+---+---+---+---+---+---+---+---+---+', 3, h, colour=Screen.COLOUR_WHITE) screen.print_at('HOLDING: ' + str(gs1.holding) + " ", 3, h + 1) screen.print_at('SCORE: ' + format(s1, '.2f') + " ", 3, h + 2) if gs1 == game.gameState: screen.print_at('START ', 3, h + 3, bg=Screen.COLOUR_RED) else: screen.print_at(' ', 3, h + 3) moves = gs1.getLegalActions() bact = max(moves, key = lambda x: qValues[(gs1, x)]) nxt = gs1.getSuccessor(bact) gs1 = nxt[0] s1 += nxt[1] screen.refresh() count += 1 time.sleep(3) Screen.wrapper(test) def visualGame(screen): #VISUAL COMPARISON def compareLeaves(gs1, gs2): start1 = gs1 start2 = gs2 score1 = s1 score2 = s2 while True: h = 3 screen.print_at('OPTIMAL LEAF', 3, 2) for i in range(10): screen.print_at('+---+---+---+---+---+---+---+---+---+---+', 3, h, colour=Screen.COLOUR_WHITE) h += 1 screen.print_at('| | | | | | | | | | |', 3, h, colour=Screen.COLOUR_WHITE) h += 1 for i in range(0, 10): for j in range(0, 10): if gs1.playerLoc[0] == j and gs1.playerLoc[1] == i: screen.print_at(str('P'), 4 + 4*i, 4 + 2*j, colour=Screen.COLOUR_WHITE, bg=Screen.COLOUR_RED) elif gs1.board[j][i]: screen.print_at(str(gs1.board[j][i]), 4 + 4*i, 4 + 2*j, colour=Screen.COLOUR_WHITE, bg=Screen.COLOUR_BLACK) elif gs1.double[0] == j and gs1.double[1] == i: screen.print_at(str('2'), 4 + 4*i, 4 + 2*j, colour=Screen.COLOUR_YELLOW) screen.print_at('+---+---+---+---+---+---+---+---+---+---+', 3, h, colour=Screen.COLOUR_WHITE) screen.print_at('HOLDING: ' + str(gs1.holding) + " ", 3, h + 1) screen.print_at('SCORE: ' + format(score1, '.2f'), 3, h + 2) if gs1 == start1: screen.print_at('START', 3, h + 3, bg=Screen.COLOUR_RED) elif not gs1.getLegalActions(): screen.print_at('END ', 3, h + 3, bg=Screen.COLOUR_RED) else: screen.print_at(' ', 3, h + 3) actions = [action for action in gs1.getLegalActions()] if actions: bact = max(actions, key = lambda x: qValues[(gs1, x)]) nxt = gs1.getSuccessor(bact) gs1 = nxt[0] score1 += nxt[1] else: gs1 = start1 score1 = s1 h = 3 screen.print_at("YOUR LEAF", 50, 2) for i in range(10): screen.print_at('+---+---+---+---+---+---+---+---+---+---+', 50, h, colour=Screen.COLOUR_WHITE) h += 1 screen.print_at('| | | | | | | | | | |', 50, h, colour=Screen.COLOUR_WHITE) h += 1 for i in range(0, 10): for j in range(0, 10): if gs2.playerLoc[0] == j and gs2.playerLoc[1] == i: screen.print_at(str('P'), 51 + 4*i, 4 + 2*j, colour=Screen.COLOUR_WHITE, bg=Screen.COLOUR_RED) elif gs2.board[j][i]: screen.print_at(str(gs2.board[j][i]), 51 + 4*i, 4 + 2*j, colour=Screen.COLOUR_WHITE, bg=Screen.COLOUR_BLACK) elif gs2.double[0] == j and gs2.double[1] == i: screen.print_at(str('2'), 51 + 4*i, 4 + 2*j, colour=Screen.COLOUR_YELLOW) screen.print_at('+---+---+---+---+---+---+---+---+---+---+', 50, h, colour=Screen.COLOUR_WHITE) screen.print_at('HOLDING: ' + str(gs2.holding) + " ", 50, h + 1) screen.print_at('SCORE: ' + format(score2, '.2f'), 50, h + 2) if gs2 == start2: screen.print_at('START', 50, h + 3, bg=Screen.COLOUR_RED) elif not gs2.getLegalActions(): screen.print_at('END ', 50, h + 3, bg=Screen.COLOUR_RED) else: screen.print_at(' ', 50, h + 3) actions = [action for action in gs2.getLegalActions()] if actions: bact = max(actions, key = lambda x: qValues[(gs2, x)]) nxt = gs2.getSuccessor(bact) gs2 = nxt[0] score2 += nxt[1] else: gs2 = start2 score2 = s2 screen.refresh() time.sleep(3) compareLeaves(gs1, gs2) Screen.wrapper(visualGame)
for i, row in enumerate(board): screen.print_at( ''.join([f"{'■' if alive else ' ': ^2}" for alive in row]), 0, i) screen.refresh() def draw(screen): board = init_board(64, 64) while True: sleep(0.05) show_board(board, screen) board = evolve_board(board) # Key event = screen.get_event() if isinstance(event, KeyboardEvent): if event.key_code in (ord('Q'), ord('q')): return elif isinstance(event, MouseEvent): if event.buttons & MouseEvent.LEFT_CLICK != 0: y = event.y x = event.x // 2 if y in range(board.shape[0]) and x in range(board.shape[1]): board[y, x] = 1 if __name__ == "__main__": Screen.wrapper(draw)
# takes a converter function to map between keys and # their frontend-specific representation. this will # make loading generic while still retaining compatibility # with various frontends. final_keymap = build_hexkey_mapping() while True: ev = screen.get_key() if ev in (ord('H'), ord('h')): return if ev == ord('p'): paused = not paused if not paused: if ev in final_keymap: vm.press(final_keymap[ev]) for i in range(vm.ticks_per_frame): vm.tick() if ev in final_keymap: vm.release(final_keymap[ev]) render_method(screen, vm) screen.refresh() Screen.wrapper(run_emu)
FigletText("ASCIIMATICS", font='big'), screen.height // 2 - 8, stop_frame=100), Cycle(screen, FigletText("ROCKS!", font='big'), screen.height // 2 + 3, stop_frame=100), Stars(screen, (screen.width + screen.height) // 2, stop_frame=100), DropScreen(screen, 100, start_frame=100) ] scenes.append(Scene(effects, 200)) effects = [ Print(screen, SpeechBubble("Press 'X' to exit."), screen.height // 2 - 1, attr=Screen.A_BOLD) ] scenes.append(Scene(effects, -1)) screen.play(scenes, stop_on_resize=True) if __name__ == "__main__": while True: try: Screen.wrapper(_credits) sys.exit(0) except ResizeScreenError: pass
from asciimatics.screen import Screen import time def beamtest(screen): counter = 0 for y in range(50): for x in range(50): cpu = INTCODE_T.Intcomp_T(1, 'cpu', 4096) cpu.loadfile('TRACTORBEAM') cpu.start() cpu.inQ.put(x) cpu.inQ.put(y) r = cpu.outQ.get() if r == 0: screen.print_at('.', x, y, 7) else: screen.print_at('#', x, y, 4) counter += 1 time.sleep(0.02) screen.refresh() screen.print_at(str(counter), 0, 52, 7) screen.refresh() while True: k = screen.get_key() if k == ord('q'): break Screen.wrapper(beamtest)
module_file_array.add(line[:-1]) cleanRedis() TABLES_TITLES["running"] = format_string([([ " Action", "Queue name", "PID", "#", "S Time", "R Time", "Processed element", "CPU %", "Mem %", "Avg CPU%" ], 0)], TABLES_PADDING["running"])[0][0] TABLES_TITLES["idle"] = format_string( [([" Action", "Queue", "PID", "Idle Time", "Last paste hash"], 0)], TABLES_PADDING["idle"])[0][0] TABLES_TITLES["notRunning"] = format_string( [([" Action", "Queue", "State"], 0)], TABLES_PADDING["notRunning"])[0][0] TABLES_TITLES["logs"] = format_string( [(["Time", "Module", "PID", "Info"], 0)], TABLES_PADDING["logs"])[0][0] try: input("Press < ENTER > to launch the manager...") except SyntaxError: pass last_scene = None while True: try: Screen.wrapper(demo) sys.exit(0) except ResizeScreenError as e: pass except StopApplication: sys.exit(0)
from game.director import Director from game.input_service import Input_Service from game.output_service import Output_Service from asciimatics.screen import Screen from game.menu import Menu def main(screen, player: str): input_service = Input_Service(screen) output_service = Output_Service(screen) director = Director(input_service, output_service, player) results = director.start_game() return results menu = Menu() play_game = menu.main_menu() while play_game: results = Screen.wrapper(main, arguments=[menu.player]) menu.game_over(results) play_game = menu.main_menu()
screen.clear() game.context.update(game, screen) screen.refresh() def app(screen): game = init(screen) while (game.running): # Grab Keyboard state game.key_state = screen.get_key() start_time = time.clock() # Update Every entity loop(game, screen) game.tick += 1 # How long did it take to calculate everything we needed to this game loop? delta_t = time.clock() - start_time if (delta_t < game.SPF): # Sleep for the rest of the tick/loop time.sleep(abs(delta_t)) else: # We are taking longer that SPF seconds to calculate a game loop/tick logging.debug("Game is lagging by: {} seconds".format(delta_t)) if __name__ == "__main__": print("> Starting {}".format(GAME_TITLE)) Screen.wrapper(app)
screen.print_at("><>", self.position_x, self.position_y, colour=2, bg=0) class Bubble: position_x = 0 position_y = 0 speed = 0 def __init__(self, position_x, position_y, speed): self.position_x = position_x self.position_y = position_y self.speed = speed def update(self, entities, addEntity): self.position_y += -randint(0, self.speed) return [] def render(self, screen): screen.print_at("O", self.position_x, self.position_y, colour=4, bg=0) Screen.wrapper(game)