--- /dev/null
+#!/usr/bin/env python3
+import curses
+import plom_socket_io
+import socket
+import threading
+
+ASCII_printable = ' !"#$%&\'\(\)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX'\
+ 'YZ[\\]^_\`abcdefghijklmnopqrstuvwxyz{|}~'
+
+
+def recv_loop(server_output):
+ for msg in plom_socket_io.recv(s):
+ while len(server_output) > 0:
+ pass
+ server_output += [msg]
+
+
+class Widget:
+
+ def __init__(self, content, tui, start, size):
+ self.tui = tui
+ self.content = content
+ self.start = start
+ self.win = curses.newwin(1, 1, self.start[0], self.start[1])
+ self.size_def = size # store for re-calling .size on SIGWINCH
+ self.size = size
+ self.update = True
+
+ @property
+ def size(self):
+ return self.win.getmaxyx()
+
+ @size.setter
+ def size(self, size):
+ """Set window size. Size be y,x tuple. If y or x None, use legal max."""
+ n_lines, n_cols = size
+ if n_lines is None:
+ n_lines = self.tui.stdscr.getmaxyx()[0] - self.start[0]
+ if n_cols is None:
+ n_cols = self.tui.stdscr.getmaxyx()[1] - self.start[1]
+ self.win.resize(n_lines, n_cols)
+
+ def __len__(self):
+ return self.win.getmaxyx()[0] * self.win.getmaxyx()[1]
+
+ def safe_write(self, string):
+ if len(string) < len(self):
+ self.win.addstr(0, 0, string)
+ else: # workaround to <https://stackoverflow.com/q/7063128>
+ cut = string[:len(self) - 1]
+ self.win.addch(self.size[0] - 1, self.size[1] - 2,
+ string[len(self) - 1])
+ self.win.insstr(self.size[0] - 1, self.size[1] - 2, " ")
+ self.win.addstr(0, 0, cut)
+
+ def draw(self):
+ if self.content is not None:
+ self.safe_write(''.join(self.content))
+
+ def draw_and_refresh(self):
+ self.win.erase()
+ self.draw()
+ self.win.refresh()
+
+
+class LogWidget(Widget):
+
+ def draw(self):
+ line_width = self.size[1]
+ to_join = []
+ for line in self.content:
+ to_pad = line_width - (len(line) % line_width)
+ if to_pad == line_width:
+ to_pad = 0
+ to_join += [line + ' '*to_pad]
+ self.safe_write(''.join(to_join))
+
+class MapWidget(Widget):
+
+ def draw(self):
+ from datetime import datetime
+ with open('log', 'a') as f:
+ f.write(str(datetime.now()) + ' TRIGGERED ' + str(len(self)) + '\n')
+ self.safe_write('#'*len(self))
+
+
+class TUI:
+
+ def __init__(self, server_output):
+ self.server_output = server_output
+ curses.wrapper(self.loop)
+
+ def setup_screen(self, stdscr):
+ self.stdscr = stdscr
+ self.stdscr.refresh() # will be called by getkey else, clearing screen
+ self.stdscr.timeout(10)
+ self.stdscr.addstr(0, 0, 'SEND:')
+
+ def loop(self, stdscr):
+ self.setup_screen(stdscr)
+ curses.curs_set(False) # hide cursor
+ to_send = []
+ log = []
+ edit_line = Widget(to_send, self, (0, 6), (1, 14))
+ log_display = LogWidget(log, self, (1, 0), (None, 20))
+ map_view = MapWidget(None, self, (0, 20), (None, None))
+ map_view.update = True
+ widgets = [edit_line, log_display, map_view]
+ do_update = True
+ while True:
+ if do_update:
+ for w in widgets:
+ w.draw_and_refresh()
+ do_update = False
+ try:
+ key = self.stdscr.getkey()
+ do_update = True
+ if len(key) == 1 and key in ASCII_printable and \
+ len(to_send) < len(edit_line):
+ to_send += [key]
+ elif key == 'KEY_BACKSPACE':
+ to_send[:] = to_send[:-1]
+ elif key == '\n':
+ plom_socket_io.send(s, ''.join(to_send))
+ to_send[:] = []
+ elif key == 'KEY_RESIZE':
+ curses.endwin()
+ self.setup_screen(curses.initscr())
+ for w in widgets:
+ w.size = w.size_def
+ else:
+ do_update = False
+ except curses.error:
+ pass
+ if len(self.server_output) > 0:
+ log[:0] = [self.server_output[0]]
+ self.server_output[:] = []
+ do_update = True
+
+
+server_output = []
+s = socket.create_connection(('127.0.0.1', 5000))
+t = threading.Thread(target=recv_loop, args=(server_output,))
+t.start()
+TUI(server_output)
--- /dev/null
+#!/usr/bin/env python3
+import urwid
+import plom_socket_io
+import socket
+import threading
+from parser import ArgError, Parser
+import game_common
+
+
+class MapSquare(game_common.Map):
+
+ def list_terrain_to_lines(self, terrain_as_list):
+ terrain = ''.join(terrain_as_list)
+ map_lines = []
+ start_cut = 0
+ while start_cut < len(terrain):
+ limit = start_cut + self.size[1]
+ map_lines += [terrain[start_cut:limit]]
+ start_cut = limit
+ return map_lines
+
+
+class MapHex(game_common.Map):
+
+ def list_terrain_to_lines(self, terrain_as_list):
+ new_terrain_list = [' ']
+ x = 0
+ y = 0
+ for c in terrain_as_list:
+ new_terrain_list += [c, ' ']
+ x += 1
+ if x == self.size[1]:
+ new_terrain_list += ['\n']
+ x = 0
+ y += 1
+ if y % 2 == 0:
+ new_terrain_list += [' ']
+ return ''.join(new_terrain_list).split('\n')
+
+
+map_manager = game_common.MapManager(globals())
+
+
+class World(game_common.World):
+
+ def __init__(self, game, *args, **kwargs):
+ """Extend original with local classes and empty default map.
+
+ We need the empty default map because we draw the map widget
+ on any update, even before we actually receive map data.
+ """
+ super().__init__(*args, **kwargs)
+ self.game = game
+ self.map_ = self.game.map_manager.get_map_class('Hex')()
+
+
+class Game(game_common.CommonCommandsMixin):
+
+ def __init__(self):
+ self.map_manager = map_manager
+ self.world = World(self)
+ self.log_text = ''
+
+ def log(self, msg):
+ """Prefix msg plus newline to self.log_text."""
+ self.log_text = msg + '\n' + self.log_text
+
+ def symbol_for_type(self, type_):
+ symbol = '?'
+ if type_ == 'human':
+ symbol = '@'
+ elif type_ == 'monster':
+ symbol = 'm'
+ return symbol
+
+ def cmd_LAST_PLAYER_TASK_RESULT(self, msg):
+ if msg != "success":
+ self.log_text = msg + '\n' + self.log_text
+ cmd_LAST_PLAYER_TASK_RESULT.argtypes = 'string'
+
+ def cmd_TURN_FINISHED(self, n):
+ """Do nothing. (This may be extended later.)"""
+ pass
+ cmd_TURN_FINISHED.argtypes = 'int:nonneg'
+
+ def cmd_NEW_TURN(self, n):
+ """Set self.turn to n, empty self.things."""
+ self.world.turn = n
+ self.world.things = []
+ cmd_NEW_TURN.argtypes = 'int:nonneg'
+
+ def cmd_VISIBLE_MAP_LINE(self, y, terrain_line):
+ self.world.map_.set_line(y, terrain_line)
+ cmd_VISIBLE_MAP_LINE.argtypes = 'int:nonneg string'
+
+
+class WidgetManager:
+
+ def __init__(self, socket, game):
+ """Set up all urwid widgets we want on the screen."""
+ self.game = game
+ edit_widget = self.EditToSocketWidget(socket, 'SEND: ')
+ self.map_widget = self.MapWidget()
+ self.turn_widget = urwid.Text('')
+ self.log_widget = urwid.Text('')
+ edit_map = urwid.AttrMap(edit_widget, 'foo')
+ turn_map = urwid.AttrMap(self.turn_widget, 'bar')
+ log_map = urwid.AttrMap(self.log_widget, 'baz')
+ widget_pile = urwid.Pile([('pack', edit_map),
+ ('pack', urwid.Divider()),
+ ('pack', turn_map),
+ ('pack', urwid.Divider()),
+ ('pack', log_map),
+ urwid.SolidFill(fill_char=' ')])
+ self.top = urwid.Columns([(20, widget_pile), self.map_widget],
+ dividechars=1)
+ self.palette = [('foo', 'white', 'dark red'),
+ ('bar', 'white', 'dark blue'),
+ ('baz', 'white', 'dark green')]
+
+ def draw_map(self):
+ """Draw map view from .game.map_.terrain, .game.things."""
+ terrain_as_list = list(self.game.world.map_.terrain[:])
+ for t in self.game.world.things:
+ pos_i = self.game.world.map_.get_position_index(t.position)
+ terrain_as_list[pos_i] = self.game.symbol_for_type(t.type_)
+ return self.game.world.map_.list_terrain_to_lines(terrain_as_list)
+ #text = self.game.world.map_.list_terrain_to_lines(terrain_as_list)
+ #new_map_text = []
+ #for char in text:
+ # if char == '.':
+ # new_map_text += [('foo', char)]
+ # elif char in {'x', 'X', '#'}:
+ # new_map_text += [('bar', char)]
+ # elif char in {'@', 'm'}:
+ # new_map_text += [('baz', char)]
+ # else:
+ # new_map_text += [char]
+ #return new_map_text
+
+ def update(self):
+ """Redraw all non-edit widgets."""
+ self.turn_widget.set_text('TURN: ' + str(self.game.world.turn))
+ self.log_widget.set_text(self.game.log_text)
+ self.map_widget.text = self.draw_map()
+ self.map_widget._invalidate()
+
+ class EditToSocketWidget(urwid.Edit):
+ """Extends urwid.Edit with socket to send input on 'enter' to."""
+
+ def __init__(self, socket, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.socket = socket
+
+ def keypress(self, size, key):
+ """Extend super(): on Enter, send .edit_text, and empty it."""
+ if key != 'enter':
+ return super().keypress(size, key)
+ plom_socket_io.send(self.socket, self.edit_text)
+ self.edit_text = ''
+
+ class MapWidget(urwid.Widget):
+ _sizing = frozenset(['box'])
+ text = ['']
+
+ def render(self, size, focus=False):
+ maxcol, maxrow = size
+ content = []
+ for y in range(len(self.text)):
+ if y < maxrow:
+ line = self.text[y]
+ if len(line) < maxcol:
+ line = line + '0' * (maxcol - len(line))
+ else:
+ line = line[:maxcol]
+ content += [line.encode('utf-8')]
+ padding_y = maxrow - len(content)
+ if padding_y > 0:
+ for y in range(padding_y):
+ content += ['0'.encode('utf-8') * maxcol]
+ return urwid.TextCanvas(content)
+
+
+class PlomRogueClient:
+
+ def __init__(self, game, socket):
+ """Build client urwid interface around socket communication.
+
+ Sets up all widgets for writing to the socket and representing data
+ from it. Sending via a WidgetManager.EditToSocket widget is
+ straightforward; polling the socket for input from the server in
+ parallel to the urwid main loop not so much:
+
+ The urwid developers warn against sharing urwid resources among
+ threads, so having a socket polling thread for writing to an urwid
+ widget while other widgets are handled in other threads would be
+ dangerous. Urwid developers recommend using urwid's watch_pipe
+ mechanism instead: using a pipe from non-urwid threads into a single
+ urwid thread. We use self.recv_loop_thread to poll the socket, therein
+ write socket.recv output to an object that is then linked to by
+ self.server_output (which is known to the urwid thread), then use the
+ pipe to urwid to trigger it pulling new data from self.server_output to
+ handle via self.handle_input. (We *could* pipe socket.recv output
+ directly, but then we get complicated buffering situations here as well
+ as in the urwid code that receives the pipe output. It's easier to just
+ tell the urwid code where it finds full new server messages to handle.)
+ """
+ self.game = game
+ self.parser = Parser(self.game)
+ self.socket = socket
+ self.widget_manager = WidgetManager(self.socket, self.game)
+ self.server_output = []
+ self.urwid_loop = urwid.MainLoop(self.widget_manager.top,
+ self.widget_manager.palette)
+ self.urwid_pipe_write_fd = self.urwid_loop.watch_pipe(self.
+ handle_input)
+ self.recv_loop_thread = threading.Thread(target=self.recv_loop)
+
+ def handle_input(self, trigger):
+ """On input from recv_loop thread, parse and enact commands.
+
+ Serves as a receiver to urwid's watch_pipe mechanism, with trigger the
+ data that a pipe defined by watch_pipe delivers. To avoid buffering
+ trouble, we don't care for that data beyond the fact that its receival
+ triggers this function: The sender is to write the data it wants to
+ deliver into the container referenced by self.server_output, and just
+ pipe the trigger to inform us about this.
+
+ If the message delivered is 'BYE', quits Urwid. Otherwise tries to
+ parse it as a command, and enact it. In all cases but the 'BYE', calls
+ self.widget_manager.update.
+ """
+ msg = self.server_output[0]
+ if msg == 'BYE':
+ raise urwid.ExitMainLoop()
+ try:
+ command = self.parser.parse(msg)
+ if command is None:
+ self.game.log('UNHANDLED INPUT: ' + msg)
+ else:
+ command()
+ except ArgError as e:
+ self.game.log('ARGUMENT ERROR: ' + msg + '\n' + str(e))
+ self.widget_manager.update()
+ del self.server_output[0]
+
+ def recv_loop(self):
+ """Loop to receive messages from socket, deliver them to urwid thread.
+
+ Waits for self.server_output to become empty (this signals that the
+ input handler is finished / ready to receive new input), then writes
+ finished message from socket to self.server_output, then sends a single
+ b' ' through self.urwid_pipe_write_fd to trigger the input handler.
+ """
+ import os
+ for msg in plom_socket_io.recv(self.socket):
+ while len(self.server_output) > 0: # Wait until self.server_output
+ pass # is emptied by input handler.
+ self.server_output += [msg]
+ os.write(self.urwid_pipe_write_fd, b' ')
+
+ def run(self):
+ """Run in parallel urwid_loop and recv_loop threads."""
+ self.recv_loop_thread.start()
+ self.urwid_loop.run()
+ self.recv_loop_thread.join()
+
+
+if __name__ == '__main__':
+ game = Game()
+ s = socket.create_connection(('127.0.0.1', 5000))
+ p = PlomRogueClient(game, s)
+ p.run()
+ s.close()
+++ /dev/null
-#!/usr/bin/env python3
-import urwid
-import plom_socket_io
-import socket
-import threading
-from parser import ArgError, Parser
-import game_common
-
-
-class MapSquare(game_common.Map):
-
- def list_terrain_to_lines(self, terrain_as_list):
- terrain = ''.join(terrain_as_list)
- map_lines = []
- start_cut = 0
- while start_cut < len(terrain):
- limit = start_cut + self.size[1]
- map_lines += [terrain[start_cut:limit]]
- start_cut = limit
- return map_lines
-
-
-class MapHex(game_common.Map):
-
- def list_terrain_to_lines(self, terrain_as_list):
- new_terrain_list = [' ']
- x = 0
- y = 0
- for c in terrain_as_list:
- new_terrain_list += [c, ' ']
- x += 1
- if x == self.size[1]:
- new_terrain_list += ['\n']
- x = 0
- y += 1
- if y % 2 == 0:
- new_terrain_list += [' ']
- return ''.join(new_terrain_list).split('\n')
-
-
-map_manager = game_common.MapManager(globals())
-
-
-class World(game_common.World):
-
- def __init__(self, game, *args, **kwargs):
- """Extend original with local classes and empty default map.
-
- We need the empty default map because we draw the map widget
- on any update, even before we actually receive map data.
- """
- super().__init__(*args, **kwargs)
- self.game = game
- self.map_ = self.game.map_manager.get_map_class('Hex')()
-
-
-class Game(game_common.CommonCommandsMixin):
-
- def __init__(self):
- self.map_manager = map_manager
- self.world = World(self)
- self.log_text = ''
-
- def log(self, msg):
- """Prefix msg plus newline to self.log_text."""
- self.log_text = msg + '\n' + self.log_text
-
- def symbol_for_type(self, type_):
- symbol = '?'
- if type_ == 'human':
- symbol = '@'
- elif type_ == 'monster':
- symbol = 'm'
- return symbol
-
- def cmd_LAST_PLAYER_TASK_RESULT(self, msg):
- if msg != "success":
- self.log_text = msg + '\n' + self.log_text
- cmd_LAST_PLAYER_TASK_RESULT.argtypes = 'string'
-
- def cmd_TURN_FINISHED(self, n):
- """Do nothing. (This may be extended later.)"""
- pass
- cmd_TURN_FINISHED.argtypes = 'int:nonneg'
-
- def cmd_NEW_TURN(self, n):
- """Set self.turn to n, empty self.things."""
- self.world.turn = n
- self.world.things = []
- cmd_NEW_TURN.argtypes = 'int:nonneg'
-
- def cmd_VISIBLE_MAP_LINE(self, y, terrain_line):
- self.world.map_.set_line(y, terrain_line)
- cmd_VISIBLE_MAP_LINE.argtypes = 'int:nonneg string'
-
-
-class WidgetManager:
-
- def __init__(self, socket, game):
- """Set up all urwid widgets we want on the screen."""
- self.game = game
- edit_widget = self.EditToSocketWidget(socket, 'SEND: ')
- self.map_widget = self.MapWidget()
- self.turn_widget = urwid.Text('')
- self.log_widget = urwid.Text('')
- edit_map = urwid.AttrMap(edit_widget, 'foo')
- turn_map = urwid.AttrMap(self.turn_widget, 'bar')
- log_map = urwid.AttrMap(self.log_widget, 'baz')
- widget_pile = urwid.Pile([('pack', edit_map),
- ('pack', urwid.Divider()),
- ('pack', turn_map),
- ('pack', urwid.Divider()),
- ('pack', log_map),
- urwid.SolidFill(fill_char=' ')])
- self.top = urwid.Columns([(20, widget_pile), self.map_widget],
- dividechars=1)
- self.palette = [('foo', 'white', 'dark red'),
- ('bar', 'white', 'dark blue'),
- ('baz', 'white', 'dark green')]
-
- def draw_map(self):
- """Draw map view from .game.map_.terrain, .game.things."""
- terrain_as_list = list(self.game.world.map_.terrain[:])
- for t in self.game.world.things:
- pos_i = self.game.world.map_.get_position_index(t.position)
- terrain_as_list[pos_i] = self.game.symbol_for_type(t.type_)
- return self.game.world.map_.list_terrain_to_lines(terrain_as_list)
- #text = self.game.world.map_.list_terrain_to_lines(terrain_as_list)
- #new_map_text = []
- #for char in text:
- # if char == '.':
- # new_map_text += [('foo', char)]
- # elif char in {'x', 'X', '#'}:
- # new_map_text += [('bar', char)]
- # elif char in {'@', 'm'}:
- # new_map_text += [('baz', char)]
- # else:
- # new_map_text += [char]
- #return new_map_text
-
- def update(self):
- """Redraw all non-edit widgets."""
- self.turn_widget.set_text('TURN: ' + str(self.game.world.turn))
- self.log_widget.set_text(self.game.log_text)
- self.map_widget.text = self.draw_map()
- self.map_widget._invalidate()
-
- class EditToSocketWidget(urwid.Edit):
- """Extends urwid.Edit with socket to send input on 'enter' to."""
-
- def __init__(self, socket, *args, **kwargs):
- super().__init__(*args, **kwargs)
- self.socket = socket
-
- def keypress(self, size, key):
- """Extend super(): on Enter, send .edit_text, and empty it."""
- if key != 'enter':
- return super().keypress(size, key)
- plom_socket_io.send(self.socket, self.edit_text)
- self.edit_text = ''
-
- class MapWidget(urwid.Widget):
- _sizing = frozenset(['box'])
- text = ['']
-
- def render(self, size, focus=False):
- maxcol, maxrow = size
- content = []
- for y in range(len(self.text)):
- if y < maxrow:
- line = self.text[y]
- if len(line) < maxcol:
- line = line + '0' * (maxcol - len(line))
- else:
- line = line[:maxcol]
- content += [line.encode('utf-8')]
- padding_y = maxrow - len(content)
- if padding_y > 0:
- for y in range(padding_y):
- content += ['0'.encode('utf-8') * maxcol]
- return urwid.TextCanvas(content)
-
-
-class PlomRogueClient:
-
- def __init__(self, game, socket):
- """Build client urwid interface around socket communication.
-
- Sets up all widgets for writing to the socket and representing data
- from it. Sending via a WidgetManager.EditToSocket widget is
- straightforward; polling the socket for input from the server in
- parallel to the urwid main loop not so much:
-
- The urwid developers warn against sharing urwid resources among
- threads, so having a socket polling thread for writing to an urwid
- widget while other widgets are handled in other threads would be
- dangerous. Urwid developers recommend using urwid's watch_pipe
- mechanism instead: using a pipe from non-urwid threads into a single
- urwid thread. We use self.recv_loop_thread to poll the socket, therein
- write socket.recv output to an object that is then linked to by
- self.server_output (which is known to the urwid thread), then use the
- pipe to urwid to trigger it pulling new data from self.server_output to
- handle via self.handle_input. (We *could* pipe socket.recv output
- directly, but then we get complicated buffering situations here as well
- as in the urwid code that receives the pipe output. It's easier to just
- tell the urwid code where it finds full new server messages to handle.)
- """
- self.game = game
- self.parser = Parser(self.game)
- self.socket = socket
- self.widget_manager = WidgetManager(self.socket, self.game)
- self.server_output = []
- self.urwid_loop = urwid.MainLoop(self.widget_manager.top,
- self.widget_manager.palette)
- self.urwid_pipe_write_fd = self.urwid_loop.watch_pipe(self.
- handle_input)
- self.recv_loop_thread = threading.Thread(target=self.recv_loop)
-
- def handle_input(self, trigger):
- """On input from recv_loop thread, parse and enact commands.
-
- Serves as a receiver to urwid's watch_pipe mechanism, with trigger the
- data that a pipe defined by watch_pipe delivers. To avoid buffering
- trouble, we don't care for that data beyond the fact that its receival
- triggers this function: The sender is to write the data it wants to
- deliver into the container referenced by self.server_output, and just
- pipe the trigger to inform us about this.
-
- If the message delivered is 'BYE', quits Urwid. Otherwise tries to
- parse it as a command, and enact it. In all cases but the 'BYE', calls
- self.widget_manager.update.
- """
- msg = self.server_output[0]
- if msg == 'BYE':
- raise urwid.ExitMainLoop()
- try:
- command = self.parser.parse(msg)
- if command is None:
- self.game.log('UNHANDLED INPUT: ' + msg)
- else:
- command()
- except ArgError as e:
- self.game.log('ARGUMENT ERROR: ' + msg + '\n' + str(e))
- self.widget_manager.update()
- del self.server_output[0]
-
- def recv_loop(self):
- """Loop to receive messages from socket, deliver them to urwid thread.
-
- Waits for self.server_output to become empty (this signals that the
- input handler is finished / ready to receive new input), then writes
- finished message from socket to self.server_output, then sends a single
- b' ' through self.urwid_pipe_write_fd to trigger the input handler.
- """
- import os
- for msg in plom_socket_io.recv(self.socket):
- while len(self.server_output) > 0: # Wait until self.server_output
- pass # is emptied by input handler.
- self.server_output += [msg]
- os.write(self.urwid_pipe_write_fd, b' ')
-
- def run(self):
- """Run in parallel urwid_loop and recv_loop threads."""
- self.recv_loop_thread.start()
- self.urwid_loop.run()
- self.recv_loop_thread.join()
-
-
-if __name__ == '__main__':
- game = Game()
- s = socket.create_connection(('127.0.0.1', 5000))
- p = PlomRogueClient(game, s)
- p.run()
- s.close()
projects / plomrogue2-experiments / commitdiff