X-Git-Url: https://plomlompom.com/repos/berlin_corona.txt?a=blobdiff_plain;f=client.py;h=45ef9f859ecf88e14b14cb8dafd81eed138d1917;hb=2966f4632c6c80b5a1a279a908831150092ad09f;hp=9092fe644bcd9618bb6b97e3e9f380a54dff972e;hpb=c54df60b10ad8eec9eb216b3ffc6c6692c3975cb;p=plomrogue2-experiments diff --git a/client.py b/client.py index 9092fe6..45ef9f8 100755 --- a/client.py +++ b/client.py @@ -6,7 +6,11 @@ import socket import threading -class UrwidSetup(): +class ArgumentError(Exception): + pass + + +class UrwidSetup: def __init__(self, socket): """Build client urwid interface around socket communication. @@ -23,17 +27,16 @@ class UrwidSetup(): 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 the urwid thread), and then use the + 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.InputHandler. (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 much easier to - just tell the urwid code where it finds a full new server message to - handle.) + 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.socket = socket self.main_loop = urwid.MainLoop(self.setup_widgets()) - self.server_output = [''] + self.server_output = [] input_handler = getattr(self.InputHandler(self.reply_widget, self.map_widget, self.server_output), @@ -45,19 +48,19 @@ class UrwidSetup(): """Return container widget with all widgets we want on our screen. Sets up an urwid.Pile inside a returned urwid.Filler; top to bottom: - - an EditToSocket widget, prefixing self.socket input with 'SEND: ' - - self.reply_widget, a urwid.Text widget printing self.socket replies + - an EditToSocketWidget, prefixing self.socket input with 'SEND: ' - a 50-col wide urwid.Padding container for self.map_widget, which is to print clipped map representations + - self.reply_widget, a urwid.Text widget printing self.socket replies """ - edit_widget = self.EditToSocket(self.socket, 'SEND: ') + edit_widget = self.EditToSocketWidget(self.socket, 'SEND: ') self.reply_widget = urwid.Text('') - self.map_widget = urwid.Text('', wrap='clip') + self.map_widget = self.MapWidget('', wrap='clip') map_box = urwid.Padding(self.map_widget, width=50) - widget_pile = urwid.Pile([edit_widget, self.reply_widget, map_box]) - return urwid.Filler(widget_pile) + widget_pile = urwid.Pile([edit_widget, map_box, self.reply_widget]) + return urwid.Filler(widget_pile, valign='top') - class EditToSocket(urwid.Edit): + class EditToSocketWidget(urwid.Edit): """Extends urwid.Edit with socket to send input on 'enter' to.""" def __init__(self, socket, *args, **kwargs): @@ -71,6 +74,42 @@ class UrwidSetup(): plom_socket_io.send(self.socket, self.edit_text) self.edit_text = '' + class MapWidget(urwid.Text): + """Stores/updates/draws game map.""" + terrain_map = ' ' * 25 + position = (0, 0) + + def draw_map(self): + """Draw map view from .terrain_map, .position.""" + whole_map = [] + for c in self.terrain_map: + whole_map += [c] + pos_i = self.position[0] * (5 + 1) + self.position[1] + whole_map[pos_i] = '@' + self.set_text(''.join(whole_map)) + + def update_terrain(self, terrain_map): + """Update self.terrain_map.""" + self.terrain_map = terrain_map + self.draw_map() + + def update_position(self, position_string): + """Update self.position.""" + + def get_axis_position_from_argument(axis, token): + if len(token) < 3 or token[:2] != axis + ':' or \ + not token[2:].isdigit(): + raise ArgumentError('Bad arg for ' + axis + ' position.') + return int(token[2:]) + + tokens = position_string.split(',') + if len(tokens) != 2: + raise ArgumentError('wrong number of ","-separated arguments') + y = get_axis_position_from_argument('y', tokens[0]) + x = get_axis_position_from_argument('x', tokens[1]) + self.position = (y, x) + self.draw_map() + class InputHandler: """Delivers data from other thread to widget via message_container. @@ -97,29 +136,47 @@ class UrwidSetup(): self.message_container, and just pipe the trigger to inform us about this. - If the message delivered is 'BYE', quits Urbit. + If the message delivered is 'BYE', quits Urwid. """ - if self.message_container[0] == 'BYE': + + def mapdraw_command(prefix, func): + n = len(prefix) + if len(msg) > n and msg[:n] == prefix: + m = getattr(self.widget2, func) + m(msg[n:]) + return True + return False + + msg = self.message_container[0] + if msg == 'BYE': raise urwid.ExitMainLoop() return - self.widget1.set_text('SERVER: ' + self.message_container[0]) - self.widget2.set_text('loremipsumdolorsitamet ' - 'loremipsumdolorsitamet' - 'loremipsumdolorsitamet ' - 'loremipsumdolorsitamet\n' - 'loremipsumdolorsitamet ' - 'loremipsumdolorsitamet') + found_command = False + try: + found_command = ( + mapdraw_command('TERRAIN\n', 'update_terrain') or + mapdraw_command('POSITION ', 'update_position')) + except ArgumentError as e: + self.widget1.set_text('BAD ARGUMENT: ' + msg + '\n' + + str(e)) + else: + if not found_command: + self.widget1.set_text('UNKNOWN COMMAND: ' + msg) + del self.message_container[0] def recv_loop(self): """Loop to receive messages from socket and deliver them to urwid. - Writes finished messages from the socket to self.server_output[0], - then sends a single b' ' through self.urwid_pipe_write_fd to trigger - the urwid code to read from it. + 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): - self.server_output[0] = msg + while len(self.server_output) > 0: + pass + self.server_output += [msg] os.write(self.urwid_pipe_write_fd, b' ') def run(self):