X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=rogue_chat_curses.py;h=b4ac8e50302dbabc4ff94bbd676a5d635790740a;hb=38a55f96dcd90f0f434b2fbcdc8a3dc943d737ed;hp=b7590381055dc93123178b82bf80811e0844e019;hpb=b42a49ec09d08e8f37ea52ad6b74fb10c5c5b01d;p=plomrogue2 diff --git a/rogue_chat_curses.py b/rogue_chat_curses.py index b759038..b4ac8e5 100755 --- a/rogue_chat_curses.py +++ b/rogue_chat_curses.py @@ -1,15 +1,15 @@ #!/usr/bin/env python3 import curses -import queue -import threading -import time import sys from plomrogue.game import GameBase from plomrogue.parser import Parser from plomrogue.mapping import YX, MapGeometrySquare, MapGeometryHex from plomrogue.things import ThingBase from plomrogue.misc import quote -from plomrogue.errors import BrokenSocketConnection, ArgError +from plomrogue.errors import ArgError +from plomrogue_client.socket import ClientSocket + + mode_helps = { 'play': { @@ -29,25 +29,40 @@ mode_helps = { 'name_thing': { 'short': 'name thing', 'intro': '', - 'long': 'Give name to/change name of thing here.' + 'long': 'Give name to/change name of carried thing.' }, 'command_thing': { - 'short': 'command thing', + 'short': 'command', 'intro': '', 'long': 'Enter a command to the thing you carry. Enter nothing to return to play mode.' }, 'take_thing': { - 'short': 'take thing', + 'short': 'take', 'intro': 'Pick up a thing in reach by entering its index number. Enter nothing to abort.', 'long': 'You see a list of things which you could pick up. Enter the target thing\'s index, or, to leave, nothing.' }, + 'drop_thing': { + 'short': 'drop', + 'intro': 'Enter number of direction to which you want to drop thing.', + 'long': 'Drop currently carried thing by entering the target direction index. Enter nothing to return to play mode..' + }, 'admin_thing_protect': { 'short': 'change thing protection', 'intro': '@ enter thing protection character:', - 'long': 'Change protection character for thing here.' + 'long': 'Change protection character for carried thing.' + }, + 'enter_face': { + 'short': 'edit face', + 'intro': '@ enter face line:', + 'long': 'Draw your face as ASCII art. The string you enter must be 18 characters long, and will be divided on display into 3 lines of 6 characters each, from top to bottom..' + }, + 'enter_design': { + 'short': 'edit design', + 'intro': '@ enter design:', + 'long': 'Enter design for carried thing as ASCII art.' }, 'write': { - 'short': 'change terrain', + 'short': 'edit tile', 'intro': '', 'long': 'This mode allows you to change the map tile you currently stand on (if your world editing password authorizes you so). Just enter any printable ASCII character to imprint it on the ground below you.' }, @@ -118,59 +133,20 @@ mode_helps = { } } -from ws4py.client import WebSocketBaseClient -class WebSocketClient(WebSocketBaseClient): - - def __init__(self, recv_handler, *args, **kwargs): - super().__init__(*args, **kwargs) - self.recv_handler = recv_handler - self.connect() - - def received_message(self, message): - if message.is_text: - message = str(message) - self.recv_handler(message) - - @property - def plom_closed(self): - return self.client_terminated - -from plomrogue.io_tcp import PlomSocket -class PlomSocketClient(PlomSocket): - - def __init__(self, recv_handler, url): - import socket - self.recv_handler = recv_handler - host, port = url.split(':') - super().__init__(socket.create_connection((host, port))) - - def close(self): - self.socket.close() - - def run(self): - import ssl - try: - for msg in self.recv(): - if msg == 'NEED_SSL': - self.socket = ssl.wrap_socket(self.socket) - continue - self.recv_handler(msg) - except BrokenSocketConnection: - pass # we assume socket will be known as dead by now - def cmd_TURN(game, n): - game.annotations = {} - game.turn = n - game.things = [] - game.portals = {} game.turn_complete = False - game.fov = '' cmd_TURN.argtypes = 'int:nonneg' +def cmd_OTHER_WIPE(game): + game.portals_new = {} + game.annotations_new = {} + game.things_new = [] +cmd_OTHER_WIPE.argtypes = '' + def cmd_LOGIN_OK(game): game.tui.switch_mode('post_login_wait') game.tui.send('GET_GAMESTATE') - game.tui.log_msg('@ welcome') + game.tui.log_msg('@ welcome!') cmd_LOGIN_OK.argtypes = '' def cmd_ADMIN_OK(game): @@ -190,44 +166,68 @@ def cmd_CHAT(game, msg): game.tui.do_refresh = True cmd_CHAT.argtypes = 'string' +def cmd_CHATFACE(game, thing_id): + game.tui.draw_face = thing_id + game.tui.do_refresh = True +cmd_CHATFACE.argtypes = 'int:pos' + def cmd_PLAYER_ID(game, player_id): game.player_id = player_id cmd_PLAYER_ID.argtypes = 'int:nonneg' -def cmd_THING(game, yx, thing_type, protection, thing_id): - t = game.get_thing(thing_id) +def cmd_PLAYERS_HAT_CHARS(game, hat_chars): + game.players_hat_chars_new = hat_chars +cmd_PLAYERS_HAT_CHARS.argtypes = 'string' + +def cmd_THING(game, yx, thing_type, protection, thing_id, portable, commandable): + t = game.get_thing_temp(thing_id) if not t: t = ThingBase(game, thing_id) - game.things += [t] + game.things_new += [t] t.position = yx t.type_ = thing_type t.protection = protection -cmd_THING.argtypes = 'yx_tuple:nonneg string:thing_type char int:nonneg' + t.portable = portable + t.commandable = commandable +cmd_THING.argtypes = 'yx_tuple:nonneg string:thing_type char int:nonneg bool bool' def cmd_THING_NAME(game, thing_id, name): - t = game.get_thing(thing_id) - if t: - t.name = name -cmd_THING_NAME.argtypes = 'int:nonneg string' + t = game.get_thing_temp(thing_id) + t.name = name +cmd_THING_NAME.argtypes = 'int:pos string' + +def cmd_THING_FACE(game, thing_id, face): + t = game.get_thing_temp(thing_id) + t.face = face +cmd_THING_FACE.argtypes = 'int:pos string' + +def cmd_THING_HAT(game, thing_id, hat): + t = game.get_thing_temp(thing_id) + t.hat = hat +cmd_THING_HAT.argtypes = 'int:pos string' + +def cmd_THING_DESIGN(game, thing_id, size, design): + t = game.get_thing_temp(thing_id) + t.design = [size, design] +cmd_THING_DESIGN.argtypes = 'int:pos yx_tuple string' def cmd_THING_CHAR(game, thing_id, c): - t = game.get_thing(thing_id) - if t: - t.thing_char = c -cmd_THING_CHAR.argtypes = 'int:nonneg char' + t = game.get_thing_temp(thing_id) + t.thing_char = c +cmd_THING_CHAR.argtypes = 'int:pos char' def cmd_MAP(game, geometry, size, content): map_geometry_class = globals()['MapGeometry' + geometry] - game.map_geometry = map_geometry_class(size) - game.map_content = content - if type(game.map_geometry) == MapGeometrySquare: + game.map_geometry_new = map_geometry_class(size) + game.map_content_new = content + if type(game.map_geometry_new) == MapGeometrySquare: game.tui.movement_keys = { game.tui.keys['square_move_up']: 'UP', game.tui.keys['square_move_left']: 'LEFT', game.tui.keys['square_move_down']: 'DOWN', game.tui.keys['square_move_right']: 'RIGHT', } - elif type(game.map_geometry) == MapGeometryHex: + elif type(game.map_geometry_new) == MapGeometryHex: game.tui.movement_keys = { game.tui.keys['hex_move_upleft']: 'UPLEFT', game.tui.keys['hex_move_upright']: 'UPRIGHT', @@ -239,23 +239,34 @@ def cmd_MAP(game, geometry, size, content): cmd_MAP.argtypes = 'string:map_geometry yx_tuple:pos string' def cmd_FOV(game, content): - game.fov = content + game.fov_new = content cmd_FOV.argtypes = 'string' def cmd_MAP_CONTROL(game, content): - game.map_control_content = content + game.map_control_content_new = content cmd_MAP_CONTROL.argtypes = 'string' def cmd_GAME_STATE_COMPLETE(game): - if game.tui.mode.name == 'post_login_wait': - game.tui.switch_mode('play') - game.turn_complete = True game.tui.do_refresh = True game.tui.info_cached = None + game.things = game.things_new + game.portals = game.portals_new + game.annotations = game.annotations_new + game.fov = game.fov_new + game.map_geometry = game.map_geometry_new + game.map_content = game.map_content_new + game.map_control_content = game.map_control_content_new + game.player = game.get_thing(game.player_id) + game.players_hat_chars = game.players_hat_chars_new + game.bladder_pressure = game.bladder_pressure_new + game.energy = game.energy_new + game.turn_complete = True + if game.tui.mode.name == 'post_login_wait': + game.tui.switch_mode('play') cmd_GAME_STATE_COMPLETE.argtypes = '' def cmd_PORTAL(game, position, msg): - game.portals[position] = msg + game.portals_new[position] = msg cmd_PORTAL.argtypes = 'yx_tuple:nonneg string' def cmd_PLAY_ERROR(game, msg): @@ -275,7 +286,7 @@ def cmd_ARGUMENT_ERROR(game, msg): cmd_ARGUMENT_ERROR.argtypes = 'string' def cmd_ANNOTATION(game, position, msg): - game.annotations[position] = msg + game.annotations_new[position] = msg if game.tui.mode.shows_info: game.tui.do_refresh = True cmd_ANNOTATION.argtypes = 'yx_tuple:nonneg string' @@ -285,12 +296,21 @@ def cmd_TASKS(game, tasks_comma_separated): game.tui.mode_write.legal = 'WRITE' in game.tasks game.tui.mode_command_thing.legal = 'COMMAND' in game.tasks game.tui.mode_take_thing.legal = 'PICK_UP' in game.tasks + game.tui.mode_drop_thing.legal = 'DROP' in game.tasks cmd_TASKS.argtypes = 'string' def cmd_THING_TYPE(game, thing_type, symbol_hint): game.thing_types[thing_type] = symbol_hint cmd_THING_TYPE.argtypes = 'string char' +def cmd_THING_INSTALLED(game, thing_id): + game.get_thing_temp(thing_id).installed = True +cmd_THING_INSTALLED.argtypes = 'int:pos' + +def cmd_THING_CARRYING(game, thing_id, carried_id): + game.get_thing_temp(thing_id).carrying = game.get_thing_temp(carried_id) +cmd_THING_CARRYING.argtypes = 'int:pos int:pos' + def cmd_TERRAIN(game, terrain_char, terrain_desc): game.terrains[terrain_char] = terrain_desc cmd_TERRAIN.argtypes = 'char string' @@ -307,10 +327,16 @@ def cmd_RANDOM_COLORS(game): game.tui.set_random_colors() cmd_RANDOM_COLORS.argtypes = '' +def cmd_STATS(game, bladder_pressure, energy): + game.bladder_pressure_new = bladder_pressure + game.energy_new = energy +cmd_STATS.argtypes = 'int:nonneg int' + class Game(GameBase): turn_complete = False tasks = {} thing_types = {} + things_new = [] def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) @@ -318,19 +344,27 @@ class Game(GameBase): self.register_command(cmd_ADMIN_OK) self.register_command(cmd_PONG) self.register_command(cmd_CHAT) + self.register_command(cmd_CHATFACE) self.register_command(cmd_REPLY) self.register_command(cmd_PLAYER_ID) self.register_command(cmd_TURN) + self.register_command(cmd_OTHER_WIPE) self.register_command(cmd_THING) self.register_command(cmd_THING_TYPE) self.register_command(cmd_THING_NAME) self.register_command(cmd_THING_CHAR) + self.register_command(cmd_THING_FACE) + self.register_command(cmd_THING_HAT) + self.register_command(cmd_THING_DESIGN) + self.register_command(cmd_THING_CARRYING) + self.register_command(cmd_THING_INSTALLED) self.register_command(cmd_TERRAIN) self.register_command(cmd_MAP) self.register_command(cmd_MAP_CONTROL) self.register_command(cmd_PORTAL) self.register_command(cmd_ANNOTATION) self.register_command(cmd_GAME_STATE_COMPLETE) + self.register_command(cmd_PLAYERS_HAT_CHARS) self.register_command(cmd_ARGUMENT_ERROR) self.register_command(cmd_GAME_ERROR) self.register_command(cmd_PLAY_ERROR) @@ -338,11 +372,16 @@ class Game(GameBase): self.register_command(cmd_FOV) self.register_command(cmd_DEFAULT_COLORS) self.register_command(cmd_RANDOM_COLORS) + self.register_command(cmd_STATS) self.map_content = '' + self.players_hat_chars = '' self.player_id = -1 self.annotations = {} + self.annotations_new = {} self.portals = {} + self.portals_new = {} self.terrains = {} + self.player = None def get_string_options(self, string_option_type): if string_option_type == 'map_geometry': @@ -357,6 +396,12 @@ class Game(GameBase): f.argtypes = self.commands[command_name].argtypes return f + def get_thing_temp(self, id_): + for thing in self.things_new: + if id_ == thing.id_: + return thing + return None + class Mode: def __init__(self, name, has_input_prompt=False, shows_info=False, @@ -418,6 +463,9 @@ class TUI: mode_name_thing = Mode('name_thing', has_input_prompt=True, shows_info=True) mode_command_thing = Mode('command_thing', has_input_prompt=True) mode_take_thing = Mode('take_thing', has_input_prompt=True) + mode_drop_thing = Mode('drop_thing', has_input_prompt=True) + mode_enter_face = Mode('enter_face', has_input_prompt=True) + mode_enter_design = Mode('enter_design', has_input_prompt=True) is_admin = False tile_draw = False @@ -425,30 +473,32 @@ class TUI: import os import json self.mode_play.available_modes = ["chat", "study", "edit", "admin_enter", - "command_thing", "take_thing"] - self.mode_play.available_actions = ["move", "drop_thing", - "teleport", "door", "consume"] + "command_thing", "take_thing", + "drop_thing"] + self.mode_play.available_actions = ["move", "teleport", "door", "consume", + "install", "wear", "spin", "dance"] self.mode_study.available_modes = ["chat", "play", "admin_enter", "edit"] self.mode_study.available_actions = ["toggle_map_mode", "move_explorer"] self.mode_admin.available_modes = ["admin_thing_protect", "control_pw_type", "control_tile_type", "chat", "study", "play", "edit"] - self.mode_admin.available_actions = ["move"] + self.mode_admin.available_actions = ["move", "toggle_map_mode"] self.mode_control_tile_draw.available_modes = ["admin_enter"] self.mode_control_tile_draw.available_actions = ["move_explorer", "toggle_tile_draw"] - self.mode_edit.available_modes = ["write", "annotate", "portal", "name_thing", - "password", "chat", "study", "play", - "admin_enter"] - self.mode_edit.available_actions = ["move", "flatten", "toggle_map_mode"] + self.mode_edit.available_modes = ["write", "annotate", "portal", + "name_thing", "enter_face", "enter_design", + "password", + "chat", "study", "play", "admin_enter"] + self.mode_edit.available_actions = ["move", "flatten", "install", + "toggle_map_mode"] self.mode = None - self.host = host + self.socket = ClientSocket(host, self.socket_log) self.game = Game() self.game.tui = self self.parser = Parser(self.game) self.log = [] self.do_refresh = True - self.queue = queue.Queue() self.login_name = None self.map_mode = 'terrain + things' self.password = 'foo' @@ -469,11 +519,17 @@ class TUI: 'switch_to_control_tile_type': 'Q', 'switch_to_admin_thing_protect': 'T', 'flatten': 'F', + 'switch_to_enter_face': 'f', + 'switch_to_enter_design': 'D', 'switch_to_take_thing': 'z', - 'drop_thing': 'u', + 'switch_to_drop_thing': 'u', 'teleport': 'p', 'consume': 'C', 'door': 'D', + 'install': 'I', + 'wear': 'W', + 'spin': 'S', + 'dance': 'T', 'help': 'h', 'toggle_map_mode': 'L', 'toggle_tile_draw': 'm', @@ -494,64 +550,39 @@ class TUI: for k in keys_conf: self.keys[k] = keys_conf[k] self.show_help = False - self.disconnected = True - self.force_instant_connect = True self.input_lines = [] self.fov = '' self.flash = False self.map_lines = [] + self.ascii_draw_stage = 0 + self.full_ascii_draw = '' self.offset = YX(0,0) curses.wrapper(self.loop) - def connect(self): - - def handle_recv(msg): - if msg == 'BYE': - self.socket.close() - else: - self.queue.put(msg) - - self.log_msg('@ attempting connect') - socket_client_class = PlomSocketClient - if self.host.startswith('ws://') or self.host.startswith('wss://'): - socket_client_class = WebSocketClient - try: - self.socket = socket_client_class(handle_recv, self.host) - self.socket_thread = threading.Thread(target=self.socket.run) - self.socket_thread.start() - self.disconnected = False - self.game.thing_types = {} - self.game.terrains = {} - time.sleep(0.1) # give potential SSL negotation some time … - self.socket.send('TASKS') - self.socket.send('TERRAINS') - self.socket.send('THING_TYPES') - self.switch_mode('login') - except ConnectionRefusedError: - self.log_msg('@ server connect failure') - self.disconnected = True - self.switch_mode('waiting_for_server') - self.do_refresh = True + def update_on_connect(self): + self.socket.send('TASKS') + self.socket.send('TERRAINS') + self.socket.send('THING_TYPES') + self.switch_mode('login') def reconnect(self): + import time self.log_msg('@ attempting reconnect') - self.send('QUIT') + self.socket.send('QUIT') # necessitated by some strange SSL race conditions with ws4py time.sleep(0.1) # FIXME find out why exactly necessary self.switch_mode('waiting_for_server') - self.connect() + self.socket.connect() + self.update_on_connect() def send(self, msg): - try: - if hasattr(self.socket, 'plom_closed') and self.socket.plom_closed: - raise BrokenSocketConnection - self.socket.send(msg) - except (BrokenPipeError, BrokenSocketConnection): - self.log_msg('@ server disconnected :(') - self.disconnected = True - self.force_instant_connect = True + self.socket.send(msg) + if self.socket.disconnected: self.do_refresh = True + def socket_log(self, msg): + self.log_msg('@ ' + msg) + def log_msg(self, msg): self.log += [msg] if len(self.log) > 100: @@ -565,11 +596,20 @@ class TUI: elif self.mode.name == 'password': self.input_ = self.password elif self.mode.name == 'name_thing': - if hasattr(self.thing_selected, 'name'): - self.input_ = self.thing_selected.name + if hasattr(self.game.player.carrying, 'name'): + self.input_ = self.game.player.carrying.name elif self.mode.name == 'admin_thing_protect': - if hasattr(self.thing_selected, 'protection'): - self.input_ = self.thing_selected.protection + if hasattr(self.game.player.carrying, 'protection'): + self.input_ = self.game.player.carrying.protection + elif self.mode.name == 'enter_face': + start = self.ascii_draw_stage * 6 + end = (self.ascii_draw_stage + 1) * 6 + self.input_ = self.game.player.face[start:end] + elif self.mode.name == 'enter_design': + width = self.game.player.carrying.design[0].x + start = self.ascii_draw_stage * width + end = (self.ascii_draw_stage + 1) * width + self.input_ = self.game.player.carrying.design[1][start:end] def send_tile_control_command(self): self.send('SET_TILE_CONTROL %s %s' % @@ -586,24 +626,36 @@ class TUI: self.map_mode = 'terrain only' def switch_mode(self, mode_name): + + def fail(msg, return_mode='play'): + self.log_msg('? ' + msg) + self.flash = True + self.switch_mode(return_mode) + if self.mode and self.mode.name == 'control_tile_draw': self.log_msg('@ finished tile protection drawing.') + self.draw_face = False self.tile_draw = False + self.ascii_draw_stage = 0 + self.full_ascii_draw = '' + if mode_name == 'command_thing' and\ + (not self.game.player.carrying or + not self.game.player.carrying.commandable): + return fail('not carrying anything commandable') + if mode_name == 'name_thing' and not self.game.player.carrying: + return fail('not carrying anything to re-name', 'edit') + if mode_name == 'admin_thing_protect' and not self.game.player.carrying: + return fail('not carrying anything to protect') + if mode_name == 'take_thing' and self.game.player.carrying: + return fail('already carrying something') + if mode_name == 'drop_thing' and not self.game.player.carrying: + return fail('not carrying anything droppable') + if mode_name == 'enter_design' and\ + (not self.game.player.carrying or + not hasattr(self.game.player.carrying, 'design')): + return fail('not carrying designable to edit', 'edit') if mode_name == 'admin_enter' and self.is_admin: mode_name = 'admin' - elif mode_name in {'name_thing', 'admin_thing_protect'}: - player = self.game.get_thing(self.game.player_id) - thing = None - for t in [t for t in self.game.things if t.position == player.position - and t.id_ != player.id_]: - thing = t - break - if not thing: - self.flash = True - self.log_msg('? not standing over thing') - return - else: - self.thing_selected = thing self.mode = getattr(self, 'mode_' + mode_name) if self.mode.name in {'control_tile_draw', 'control_tile_type', 'control_pw_type'}: @@ -611,8 +663,8 @@ class TUI: elif self.mode.name != 'edit': self.map_mode = 'terrain + things' if self.mode.shows_info or self.mode.name == 'control_tile_draw': - player = self.game.get_thing(self.game.player_id) - self.explorer = YX(player.position.y, player.position.x) + self.explorer = YX(self.game.player.position.y, + self.game.player.position.x) if self.mode.is_single_char_entry: self.show_help = True if len(self.mode.intro_msg) > 0: @@ -623,29 +675,59 @@ class TUI: else: self.log_msg('@ enter username') elif self.mode.name == 'take_thing': - self.log_msg('Things in reach for pick-up:') - player = self.game.get_thing(self.game.player_id) - select_range = [player.position, - player.position + YX(0,-1), - player.position + YX(0, 1), - player.position + YX(-1, 0), - player.position + YX(1, 0)] - if type(self.game.map_geometry) == MapGeometryHex: - if player.position.y % 2: - select_range += [player.position + YX(-1, 1), - player.position + YX(1, 1)] + self.log_msg('Portable things in reach for pick-up:') + directed_moves = { + 'HERE': YX(0, 0), 'LEFT': YX(0, -1), 'RIGHT': YX(0, 1) + } + if type(self.game.map_geometry) == MapGeometrySquare: + directed_moves['UP'] = YX(-1, 0) + directed_moves['DOWN'] = YX(1, 0) + elif type(self.game.map_geometry) == MapGeometryHex: + if self.game.player.position.y % 2: + directed_moves['UPLEFT'] = YX(-1, 0) + directed_moves['UPRIGHT'] = YX(-1, 1) + directed_moves['DOWNLEFT'] = YX(1, 0) + directed_moves['DOWNRIGHT'] = YX(1, 1) else: - select_range += [player.position + YX(-1, -1), - player.position + YX(1, -1)] - self.selectables = [t for t in self.game.things - if t != player and t.type_ != 'Player' - and t.position in select_range] + directed_moves['UPLEFT'] = YX(-1, -1) + directed_moves['UPRIGHT'] = YX(-1, 0) + directed_moves['DOWNLEFT'] = YX(1, -1) + directed_moves['DOWNRIGHT'] = YX(1, 0) + select_range = {} + for direction in directed_moves: + move = directed_moves[direction] + select_range[direction] = self.game.player.position + move + self.selectables = [] + directions = [] + for direction in select_range: + for t in [t for t in self.game.things + if t.portable and t.position == select_range[direction]]: + self.selectables += [t.id_] + directions += [direction] if len(self.selectables) == 0: - self.log_msg('none') + return fail('nothing to pick-up') else: for i in range(len(self.selectables)): - t = self.selectables[i] - self.log_msg(str(i) + ': ' + self.get_thing_info(t)) + t = self.game.get_thing(self.selectables[i]) + self.log_msg('%s %s: %s' % (i, directions[i], + self.get_thing_info(t))) + elif self.mode.name == 'drop_thing': + self.log_msg('Direction to drop thing to:') + self.selectables =\ + ['HERE'] + list(self.game.tui.movement_keys.values()) + for i in range(len(self.selectables)): + self.log_msg(str(i) + ': ' + self.selectables[i]) + elif self.mode.name == 'enter_design': + if self.game.player.carrying.type_ == 'Hat': + self.log_msg('@ The design you enter must be %s lines of max %s ' + 'characters width each' + % (self.game.player.carrying.design[0].y, + self.game.player.carrying.design[0].x)) + self.log_msg('@ Legal characters: ' + self.game.players_hat_chars) + self.log_msg('@ (Eat cookies to extend the ASCII characters available for drawing.)') + else: + self.log_msg('@ Width of first line determines maximum width for remaining design') + self.log_msg('@ Finish design by entering an empty line (multiple space characters do not count as empty)') elif self.mode.name == 'command_thing': self.send('TASK:COMMAND ' + quote('HELP')) elif self.mode.name == 'control_pw_pw': @@ -656,8 +738,9 @@ class TUI: self.restore_input_values() def set_default_colors(self): - curses.init_color(1, 1000, 1000, 1000) - curses.init_color(2, 0, 0, 0) + if curses.can_change_color(): + curses.init_color(7, 1000, 1000, 1000) + curses.init_color(0, 0, 0, 0) self.do_refresh = True def set_random_colors(self): @@ -666,8 +749,9 @@ class TUI: import random return int(offset + random.random()*375) - curses.init_color(1, rand(625), rand(625), rand(625)) - curses.init_color(2, rand(0), rand(0), rand(0)) + if curses.can_change_color(): + curses.init_color(7, rand(625), rand(625), rand(625)) + curses.init_color(0, rand(0), rand(0), rand(0)) self.do_refresh = True def get_info(self): @@ -678,45 +762,77 @@ class TUI: if len(self.game.fov) > pos_i and self.game.fov[pos_i] != '.': info_to_cache += 'outside field of view' else: + for t in self.game.things: + if t.position == self.explorer: + info_to_cache += '%s' % self.get_thing_info(t, True) terrain_char = self.game.map_content[pos_i] terrain_desc = '?' if terrain_char in self.game.terrains: terrain_desc = self.game.terrains[terrain_char] - info_to_cache += 'TERRAIN: "%s" / %s\n' % (terrain_char, + info_to_cache += 'TERRAIN: %s (%s' % (terrain_char, terrain_desc) protection = self.game.map_control_content[pos_i] - if protection == '.': - protection = 'unprotected' - info_to_cache += 'PROTECTION: %s\n' % protection - for t in self.game.things: - if t.position == self.explorer: - info_to_cache += 'THING: %s' % self.get_thing_info(t) - protection = t.protection - if protection == '.': - protection = 'none' - info_to_cache += ' / protection: %s\n' % protection + if protection != '.': + info_to_cache += '/protection:%s' % protection + info_to_cache += ')\n' if self.explorer in self.game.portals: info_to_cache += 'PORTAL: ' +\ self.game.portals[self.explorer] + '\n' - else: - info_to_cache += 'PORTAL: (none)\n' if self.explorer in self.game.annotations: info_to_cache += 'ANNOTATION: ' +\ self.game.annotations[self.explorer] self.info_cached = info_to_cache return self.info_cached - def get_thing_info(self, t): - info = '%s / %s' %\ - (t.type_, self.game.thing_types[t.type_]) + def get_thing_info(self, t, detailed=False): + info = '' + if detailed: + info += '- ' + info += self.game.thing_types[t.type_] if hasattr(t, 'thing_char'): info += t.thing_char if hasattr(t, 'name'): - info += ' (%s)' % t.name + info += ': %s' % t.name + info += ' (%s' % t.type_ + if hasattr(t, 'installed'): + info += '/installed' + if t.type_ == 'Bottle': + if t.thing_char == '_': + info += '/empty' + elif t.thing_char == '~': + info += '/full' + if detailed: + protection = t.protection + if protection != '.': + info += '/protection:%s' % protection + info += ')\n' + if hasattr(t, 'hat') or hasattr(t, 'face'): + info += '----------\n' + if hasattr(t, 'hat'): + info += '| %s |\n' % t.hat[0:6] + info += '| %s |\n' % t.hat[6:12] + info += '| %s |\n' % t.hat[12:18] + if hasattr(t, 'face'): + info += '| %s |\n' % t.face[0:6] + info += '| %s |\n' % t.face[6:12] + info += '| %s |\n' % t.face[12:18] + info += '----------\n' + if hasattr(t, 'design'): + line_length = t.design[0].x + lines = [] + for i in range(t.design[0].y): + start = i * line_length + end = (i + 1) * line_length + lines += [t.design[1][start:end]] + info += '-' * (line_length + 4) + '\n' + for line in lines: + info += '| %s |\n' % line + info += '-' * (line_length + 4) + '\n' + else: + info += ')' return info def loop(self, stdscr): - import datetime def safe_addstr(y, x, line): if y < self.size.y - 1 or x + len(line) < self.size.x: @@ -757,14 +873,16 @@ class TUI: self.size = YX(*stdscr.getmaxyx()) self.size = self.size - YX(self.size.y % 4, 0) self.size = self.size - YX(0, self.size.x % 4) - self.window_width = int(self.size.x / 2) + self.left_window_width = min(52, int(self.size.x / 2)) + self.right_window_width = self.size.x - self.left_window_width def recalc_input_lines(): if not self.mode.has_input_prompt: self.input_lines = [] else: - self.input_lines = msg_into_lines_of_width(input_prompt + self.input_, - self.window_width) + self.input_lines = msg_into_lines_of_width(input_prompt + + self.input_ + '█', + self.right_window_width) def move_explorer(direction): target = self.game.map_geometry.move_yx(self.explorer, direction) @@ -779,45 +897,45 @@ class TUI: def draw_history(): lines = [] for line in self.log: - lines += msg_into_lines_of_width(line, self.window_width) + lines += msg_into_lines_of_width(line, self.right_window_width) lines.reverse() height_header = 2 max_y = self.size.y - len(self.input_lines) for i in range(len(lines)): if (i >= max_y - height_header): break - safe_addstr(max_y - i - 1, self.window_width, lines[i]) + safe_addstr(max_y - i - 1, self.left_window_width, lines[i]) def draw_info(): info = 'MAP VIEW: %s\n%s' % (self.map_mode, self.get_info()) - lines = msg_into_lines_of_width(info, self.window_width) + lines = msg_into_lines_of_width(info, self.right_window_width) height_header = 2 for i in range(len(lines)): y = height_header + i if y >= self.size.y - len(self.input_lines): break - safe_addstr(y, self.window_width, lines[i]) + safe_addstr(y, self.left_window_width, lines[i]) def draw_input(): y = self.size.y - len(self.input_lines) for i in range(len(self.input_lines)): - safe_addstr(y, self.window_width, self.input_lines[i]) + safe_addstr(y, self.left_window_width, self.input_lines[i]) y += 1 - def draw_turn(): - if not self.game.turn_complete: - return - safe_addstr(0, self.window_width, 'TURN: ' + str(self.game.turn)) + def draw_stats(): + stats = 'ENERGY: %s BLADDER: %s' % (self.game.energy, + self.game.bladder_pressure) + safe_addstr(0, self.left_window_width, stats) def draw_mode(): help = "hit [%s] for help" % self.keys['help'] if self.mode.has_input_prompt: help = "enter /help for help" - safe_addstr(1, self.window_width, + safe_addstr(1, self.left_window_width, 'MODE: %s – %s' % (self.mode.short_desc, help)) def draw_map(): - if not self.game.turn_complete and len(self.map_lines) == 0: + if (not self.game.turn_complete) and len(self.map_lines) == 0: return if self.game.turn_complete: map_lines_split = [] @@ -846,6 +964,8 @@ class TUI: meta_char = t.thing_char if t.position in used_positions: meta_char = '+' + if hasattr(t, 'carrying') and t.carrying: + meta_char = '$' map_lines_split[t.position.y][t.position.x] = symbol + meta_char used_positions += [t.position] @@ -853,11 +973,11 @@ class TUI: draw_thing(t, used_positions) for t in [t for t in self.game.things if t.type_ == 'Player']: draw_thing(t, used_positions) - player = self.game.get_thing(self.game.player_id) if self.mode.shows_info or self.mode.name == 'control_tile_draw': map_lines_split[self.explorer.y][self.explorer.x] = '??' elif self.map_mode != 'terrain + things': - map_lines_split[player.position.y][player.position.x] = '??' + map_lines_split[self.game.player.position.y]\ + [self.game.player.position.x] = '??' self.map_lines = [] if type(self.game.map_geometry) == MapGeometryHex: indent = 0 @@ -868,8 +988,8 @@ class TUI: for line in map_lines_split: self.map_lines += [''.join(line)] window_center = YX(int(self.size.y / 2), - int(self.window_width / 2)) - center = player.position + int(self.left_window_width / 2)) + center = self.game.player.position if self.mode.shows_info or self.mode.name == 'control_tile_draw': center = self.explorer center = YX(center.y, center.x * 2) @@ -880,12 +1000,53 @@ class TUI: term_x = max(0, -self.offset.x) map_y = max(0, self.offset.y) map_x = max(0, self.offset.x) - while (term_y < self.size.y and map_y < self.game.map_geometry.size.y): - to_draw = self.map_lines[map_y][map_x:self.window_width + self.offset.x] + while term_y < self.size.y and map_y < len(self.map_lines): + to_draw = self.map_lines[map_y][map_x:self.left_window_width + self.offset.x] safe_addstr(term_y, term_x, to_draw) term_y += 1 map_y += 1 + def draw_names(): + players = [t for t in self.game.things if t.type_ == 'Player'] + players.sort(key=lambda t: len(t.name)) + players.reverse() + shrink_offset = max(0, (self.size.y - self.left_window_width // 2) // 2) + y = 0 + for t in players: + offset_y = y - shrink_offset + max_len = max(5, (self.left_window_width // 2) - (offset_y * 2) - 8) + name = t.name[:] + if len(name) > max_len: + name = name[:max_len - 1] + '…' + safe_addstr(y, 0, '@%s:%s' % (t.thing_char, name)) + y += 1 + if y >= self.size.y: + break + + def draw_face_popup(): + t = self.game.get_thing(self.draw_face) + if not t or not hasattr(t, 'face'): + self.draw_face = False + return + + start_x = self.left_window_width - 10 + def draw_body_part(body_part, end_y): + safe_addstr(end_y - 3, start_x, '----------') + safe_addstr(end_y - 2, start_x, '| ' + body_part[0:6] + ' |') + safe_addstr(end_y - 1, start_x, '| ' + body_part[6:12] + ' |') + safe_addstr(end_y, start_x, '| ' + body_part[12:18] + ' |') + + if hasattr(t, 'face'): + draw_body_part(t.face, self.size.y - 3) + if hasattr(t, 'hat'): + draw_body_part(t.hat, self.size.y - 6) + safe_addstr(self.size.y - 2, start_x, '----------') + name = t.name[:] + if len(name) > 7: + name = name[:6 - 1] + '…' + safe_addstr(self.size.y - 1, start_x, + '@%s:%s' % (t.thing_char, name)) + def draw_help(): content = "%s help\n\n%s\n\n" % (self.mode.short_desc, self.mode.help_intro) @@ -906,16 +1067,16 @@ class TUI: content += self.mode.list_available_modes(self) for i in range(self.size.y): safe_addstr(i, - self.window_width * (not self.mode.has_input_prompt), - ' ' * self.window_width) + self.left_window_width * (not self.mode.has_input_prompt), + ' ' * self.left_window_width) lines = [] for line in content.split('\n'): - lines += msg_into_lines_of_width(line, self.window_width) + lines += msg_into_lines_of_width(line, self.right_window_width) for i in range(len(lines)): if i >= self.size.y: break safe_addstr(i, - self.window_width * (not self.mode.has_input_prompt), + self.left_window_width * (not self.mode.has_input_prompt), lines[i]) def draw_screen(): @@ -930,10 +1091,73 @@ class TUI: draw_history() draw_mode() if not self.mode.is_intro: - draw_turn() + draw_stats() draw_map() if self.show_help: draw_help() + if self.mode.name in {'chat', 'play'}: + draw_names() + if self.draw_face: + draw_face_popup() + + def pick_selectable(task_name): + try: + i = int(self.input_) + if i < 0 or i >= len(self.selectables): + self.log_msg('? invalid index, aborted') + else: + self.send('TASK:%s %s' % (task_name, self.selectables[i])) + except ValueError: + self.log_msg('? invalid index, aborted') + self.input_ = '' + self.switch_mode('play') + + def enter_ascii_art(command, height, width, + with_pw=False, with_size=False): + if with_size and self.ascii_draw_stage == 0: + width = len(self.input_) + if width > 36: + self.log_msg('? input too long, must be max 36; try again') + # TODO: move max width mechanism server-side + return + old_size = self.game.player.carrying.design[0] + if width != old_size.x: + # TODO: save remaining design? + self.game.player.carrying.design[1] = '' + self.game.player.carrying.design[0] = YX(old_size.y, width) + elif len(self.input_) > width: + self.log_msg('? input too long, ' + 'must be max %s; try again' % width) + return + self.log_msg(' ' + self.input_) + if with_size and self.input_ in {'', ' '}\ + and self.ascii_draw_stage > 0: + height = self.ascii_draw_stage + else: + if with_size: + height = self.ascii_draw_stage + 2 + if len(self.input_) < width: + self.input_ += ' ' * (width - len(self.input_)) + self.full_ascii_draw += self.input_ + if with_size: + old_size = self.game.player.carrying.design[0] + self.game.player.carrying.design[0] = YX(height, old_size.x) + self.ascii_draw_stage += 1 + if self.ascii_draw_stage < height: + self.restore_input_values() + else: + if with_pw and with_size: + self.send('%s_SIZE %s %s' % (command, YX(height, width), + quote(self.password))) + if with_pw: + self.send('%s %s %s' % (command, quote(self.full_ascii_draw), + quote(self.password))) + else: + self.send('%s %s' % (command, quote(self.full_ascii_draw))) + self.full_ascii_draw = "" + self.ascii_draw_stage = 0 + self.input_ = "" + self.switch_mode('edit') action_descriptions = { 'move': 'move', @@ -943,8 +1167,12 @@ class TUI: 'drop_thing': 'drop thing', 'toggle_map_mode': 'toggle map view', 'toggle_tile_draw': 'toggle protection character drawing', + 'install': '(un-)install', + 'wear': '(un-)wear', 'door': 'open/close', 'consume': 'consume', + 'spin': 'spin', + 'dance': 'dance', } action_tasks = { @@ -952,59 +1180,70 @@ class TUI: 'take_thing': 'PICK_UP', 'drop_thing': 'DROP', 'door': 'DOOR', + 'install': 'INSTALL', + 'wear': 'WEAR', 'move': 'MOVE', 'command': 'COMMAND', 'consume': 'INTOXICATE', + 'spin': 'SPIN', + 'dance': 'DANCE', } - curses.curs_set(False) # hide cursor + curses.curs_set(0) # hide cursor curses.start_color() self.set_default_colors() - curses.init_pair(1, 1, 2) + curses.init_pair(1, 7, 0) + if not curses.can_change_color(): + self.log_msg('@ unfortunately, your terminal does not seem to ' + 'support re-definition of colors; you might miss out ' + 'on some color effects') stdscr.timeout(10) reset_screen_size() self.explorer = YX(0, 0) self.input_ = '' + store_widechar = False input_prompt = '> ' - interval = datetime.timedelta(seconds=5) - last_ping = datetime.datetime.now() - interval while True: - if self.disconnected and self.force_instant_connect: - self.force_instant_connect = False - self.connect() - now = datetime.datetime.now() - if now - last_ping > interval: - if self.disconnected: - self.connect() - else: - self.send('PING') - last_ping = now + prev_disconnected = self.socket.disconnected + self.socket.keep_connection_alive() + if prev_disconnected and not self.socket.disconnected: + self.update_on_connect() if self.flash: curses.flash() self.flash = False if self.do_refresh: draw_screen() self.do_refresh = False - while True: - try: - msg = self.queue.get(block=False) - handle_input(msg) - except queue.Empty: - break + for msg in self.socket.get_message(): + handle_input(msg) try: key = stdscr.getkey() self.do_refresh = True except curses.error: continue + keycode = None + if len(key) == 1: + keycode = ord(key) + # workaround for + if store_widechar: + store_widechar = False + key = bytes([195, keycode]).decode() + if keycode == 195: + store_widechar = True + continue self.show_help = False + self.draw_face = False if key == 'KEY_RESIZE': reset_screen_size() elif self.mode.has_input_prompt and key == 'KEY_BACKSPACE': self.input_ = self.input_[:-1] - elif self.mode.has_input_prompt and key == '\n' and self.input_ == ''\ - and self.mode.name in {'chat', 'command_thing', 'take_thing', - 'admin_enter'}: - if self.mode.name != 'chat': + elif (((not self.mode.is_intro) and keycode == 27) # Escape + or (self.mode.has_input_prompt and key == '\n' + and self.input_ == ''\ + and self.mode.name in {'chat', 'command_thing', + 'take_thing', 'drop_thing', + 'admin_enter'})): + if self.mode.name not in {'chat', 'play', 'study', 'edit'}: self.log_msg('@ aborted') self.switch_mode('play') elif self.mode.has_input_prompt and key == '\n' and self.input_ == '/help': @@ -1013,7 +1252,7 @@ class TUI: self.restore_input_values() elif self.mode.has_input_prompt and key != '\n': # Return key self.input_ += key - max_length = self.window_width * self.size.y - len(input_prompt) - 1 + max_length = self.right_window_width * self.size.y - len(input_prompt) - 1 if len(self.input_) > max_length: self.input_ = self.input_[:max_length] elif key == self.keys['help'] and not self.mode.is_single_char_entry: @@ -1022,21 +1261,25 @@ class TUI: self.login_name = self.input_ self.send('LOGIN ' + quote(self.input_)) self.input_ = "" + elif self.mode.name == 'enter_face' and key == '\n': + enter_ascii_art('PLAYER_FACE', 3, 6) + elif self.mode.name == 'enter_design' and key == '\n': + if self.game.player.carrying.type_ == 'Hat': + enter_ascii_art('THING_DESIGN', + self.game.player.carrying.design[0].y, + self.game.player.carrying.design[0].x, True) + else: + enter_ascii_art('THING_DESIGN', + self.game.player.carrying.design[0].y, + self.game.player.carrying.design[0].x, + True, True) elif self.mode.name == 'take_thing' and key == '\n': - try: - i = int(self.input_) - if i < 0 or i >= len(self.selectables): - self.log_msg('? invalid index, aborted') - else: - self.send('TASK:PICK_UP %s' % self.selectables[i].id_) - except ValueError: - self.log_msg('? invalid index, aborted') - self.input_ = '' - self.switch_mode('play') + pick_selectable('PICK_UP') + elif self.mode.name == 'drop_thing' and key == '\n': + pick_selectable('DROP') elif self.mode.name == 'command_thing' and key == '\n': - if task_action_on('command'): - self.send('TASK:COMMAND ' + quote(self.input_)) - self.input_ = "" + self.send('TASK:COMMAND ' + quote(self.input_)) + self.input_ = "" elif self.mode.name == 'control_pw_pw' and key == '\n': if self.input_ == '': self.log_msg('@ aborted') @@ -1063,8 +1306,7 @@ class TUI: if len(self.input_) != 1: self.log_msg('@ entered non-single-char, therefore aborted') else: - self.send('THING_PROTECTION %s %s' % (self.thing_selected.id_, - quote(self.input_))) + self.send('THING_PROTECTION %s' % (quote(self.input_))) self.log_msg('@ sent new protection character for thing') self.switch_mode('admin') elif self.mode.name == 'control_tile_type' and key == '\n': @@ -1092,9 +1334,8 @@ class TUI: elif self.mode.name == 'name_thing' and key == '\n': if self.input_ == '': self.input_ = ' ' - self.send('THING_NAME %s %s %s' % (self.thing_selected.id_, - quote(self.input_), - quote(self.password))) + self.send('THING_NAME %s %s' % (quote(self.input_), + quote(self.password))) self.switch_mode('edit') elif self.mode.name == 'annotate' and key == '\n': if self.input_ == '': @@ -1118,16 +1359,19 @@ class TUI: elif self.mode.name == 'play': if self.mode.mode_switch_on_key(self, key): continue - elif key == self.keys['drop_thing'] and task_action_on('drop_thing'): - self.send('TASK:DROP') elif key == self.keys['door'] and task_action_on('door'): self.send('TASK:DOOR') elif key == self.keys['consume'] and task_action_on('consume'): self.send('TASK:INTOXICATE') + elif key == self.keys['wear'] and task_action_on('wear'): + self.send('TASK:WEAR') + elif key == self.keys['spin'] and task_action_on('spin'): + self.send('TASK:SPIN') + elif key == self.keys['dance'] and task_action_on('dance'): + self.send('TASK:DANCE') elif key == self.keys['teleport']: - player = self.game.get_thing(self.game.player_id) - if player.position in self.game.portals: - self.host = self.game.portals[player.position] + if self.game.player.position in self.game.portals: + self.socket.host = self.game.portals[self.game.player.position] self.reconnect() else: self.flash = True @@ -1147,6 +1391,8 @@ class TUI: elif self.mode.name == 'admin': if self.mode.mode_switch_on_key(self, key): continue + elif key == self.keys['toggle_map_mode']: + self.toggle_map_mode() elif key in self.movement_keys and task_action_on('move'): self.send('TASK:MOVE ' + self.movement_keys[key]) elif self.mode.name == 'edit': @@ -1154,6 +1400,8 @@ class TUI: continue elif key == self.keys['flatten'] and task_action_on('flatten'): self.send('TASK:FLATTEN_SURROUNDINGS ' + quote(self.password)) + elif key == self.keys['install'] and task_action_on('install'): + self.send('TASK:INSTALL %s' % quote(self.password)) elif key == self.keys['toggle_map_mode']: self.toggle_map_mode() elif key in self.movement_keys and task_action_on('move'):