From: Christian Heller Date: Wed, 23 Jan 2019 23:39:34 +0000 (+0100) Subject: Add start of ncurses client. X-Git-Url: https://plomlompom.com/repos/%7B%7Bdb.prefix%7D%7D/conditions?a=commitdiff_plain;h=ff3a55c51e49f1b356f8eb056609e17b845ebb77;p=plomrogue2-experiments Add start of ncurses client. --- diff --git a/client-curses.py b/client-curses.py new file mode 100755 index 0000000..5312e3e --- /dev/null +++ b/client-curses.py @@ -0,0 +1,145 @@ +#!/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 + 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) diff --git a/client-urwid.py b/client-urwid.py new file mode 100755 index 0000000..6e22d00 --- /dev/null +++ b/client-urwid.py @@ -0,0 +1,274 @@ +#!/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() diff --git a/client.py b/client.py deleted file mode 100755 index 6e22d00..0000000 --- a/client.py +++ /dev/null @@ -1,274 +0,0 @@ -#!/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()