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)
