plomlompom.com Git - plomrogue2/blob - rogue_chat_curses.py

   1 #!/usr/bin/env python3
   2 import curses
   3 import queue
   4 import threading
   5 import time
   6 import sys
   7 from plomrogue.game import GameBase
   8 from plomrogue.parser import Parser
   9 from plomrogue.mapping import YX, MapGeometrySquare, MapGeometryHex
  10 from plomrogue.things import ThingBase
  11 from plomrogue.misc import quote
  12 from plomrogue.errors import BrokenSocketConnection, ArgError
  13
  14 mode_helps = {
  15     'play': {
  16         'short': 'play',
  17         'intro': '',
  18         'long': 'This mode allows you to interact with the map in various ways.'
  19     },
  20     'study': {
  21         'short': 'study',
  22         'intro': '',
  23         'long': 'This mode allows you to study the map and its tiles in detail.  Move the question mark over a tile, and the right half of the screen will show detailed information on it.  Toggle the map view to show or hide different information layers.'},
  24     'edit': {
  25         'short': 'world edit',
  26         'intro': '',
  27         'long': 'This mode allows you to change the game world in various ways.  Individual map tiles can be protected by "protection characters", which you can see by toggling into the protections map view.  You can edit a tile if you set the world edit password that matches its protection character.  The character "." marks the absence of protection:  Such tiles can always be edited.'
  28     },
  29     'name_thing': {
  30         'short': 'name thing',
  31         'intro': '',
  32         'long': 'Give name to/change name of carried thing.'
  33     },
  34     'command_thing': {
  35         'short': 'command',
  36         'intro': '',
  37         'long': 'Enter a command to the thing you carry.  Enter nothing to return to play mode.'
  38     },
  39     'take_thing': {
  40         'short': 'take',
  41         'intro': 'Pick up a thing in reach by entering its index number.  Enter nothing to abort.',
  42         'long': 'You see a list of things which you could pick up.  Enter the target thing\'s index, or, to leave, nothing.'
  43     },
  44     'drop_thing': {
  45         'short': 'drop',
  46         'intro': 'Enter number of direction to which you want to drop thing.',
  47         'long': 'Drop currently carried thing by entering the target direction index.  Enter nothing to return to play mode..'
  48     },
  49     'admin_thing_protect': {
  50         'short': 'change thing protection',
  51         'intro': '@ enter thing protection character:',
  52         'long': 'Change protection character for carried thing.'
  53     },
  54     'enter_face': {
  55         'short': 'edit face',
  56         'intro': '@ enter face line:',
  57         '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..'
  58     },
  59     'enter_design': {
  60         'short': 'edit design',
  61         'intro': '@ enter design:',
  62         'long': 'Enter design for carried thing as ASCII art.'
  63     },
  64     'write': {
  65         'short': 'edit tile',
  66         'intro': '',
  67         '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.'
  68     },
  69     'control_pw_type': {
  70         'short': 'change protection character password',
  71         'intro': '@ enter protection character for which you want to change the password:',
  72         'long': 'This mode is the first of two steps to change the password for a protection character.  First enter the protection character for which you want to change the password.'
  73     },
  74     'control_pw_pw': {
  75         'short': 'change protection character password',
  76         'intro': '',
  77         'long': 'This mode is the second of two steps to change the password for a protection character.  Enter the new password for the protection character you chose.'
  78     },
  79     'control_tile_type': {
  80         'short': 'change tiles protection',
  81         'intro': '@ enter protection character which you want to draw:',
  82         'long': 'This mode is the first of two steps to change tile protection areas on the map.  First enter the tile protection character you want to write.'
  83     },
  84     'control_tile_draw': {
  85         'short': 'change tiles protection',
  86         'intro': '',
  87         'long': 'This mode is the second of two steps to change tile protection areas on the map.  Toggle tile protection drawing on/off and move the ?? cursor around the map to draw the selected protection character.'
  88     },
  89     'annotate': {
  90         'short': 'annotate tile',
  91         'intro': '',
  92         'long': 'This mode allows you to add/edit a comment on the tile you are currently standing on (provided your world editing password authorizes you so).  Hit Return to leave.'
  93     },
  94     'portal': {
  95         'short': 'edit portal',
  96         'intro': '',
  97         'long': 'This mode allows you to imprint/edit/remove a teleportation target on the ground you are currently standing on (provided your world editing password authorizes you so).  Enter or edit a URL to imprint a teleportation target; enter emptiness to remove a pre-existing teleportation target.  Hit Return to leave.'
  98     },
  99     'chat': {
 100         'short': 'chat',
 101         'intro': '',
 102         'long': 'This mode allows you to engage in chit-chat with other users.  Any line you enter into the input prompt that does not start with a "/" will be sent out to nearby players – but barriers and distance will reduce what they can read, so stand close to them to ensure they get your message.  Lines that start with a "/" are used for commands like:\n\n/nick NAME – re-name yourself to NAME'
 103     },
 104     'login': {
 105         'short': 'login',
 106         'intro': '',
 107         'long': 'Enter your player name.'
 108     },
 109     'waiting_for_server': {
 110         'short': 'waiting for server response',
 111         'intro': '@ waiting for server …',
 112         'long': 'Waiting for a server response.'
 113     },
 114     'post_login_wait': {
 115         'short': 'waiting for server response',
 116         'intro': '',
 117         'long': 'Waiting for a server response.'
 118     },
 119     'password': {
 120         'short': 'set world edit password',
 121         'intro': '',
 122         'long': 'This mode allows you to change the password that you send to authorize yourself for editing password-protected elements of the world.  Hit return to confirm and leave.'
 123     },
 124     'admin_enter': {
 125         'short': 'become admin',
 126         'intro': '@ enter admin password:',
 127         'long': 'This mode allows you to become admin if you know an admin password.'
 128     },
 129     'admin': {
 130         'short': 'admin',
 131         'intro': '',
 132         'long': 'This mode allows you access to actions limited to administrators.'
 133     }
 134 }
 135
 136 from ws4py.client import WebSocketBaseClient
 137 class WebSocketClient(WebSocketBaseClient):
 138
 139     def __init__(self, recv_handler, *args, **kwargs):
 140         super().__init__(*args, **kwargs)
 141         self.recv_handler = recv_handler
 142         self.connect()
 143
 144     def received_message(self, message):
 145         if message.is_text:
 146             message = str(message)
 147             self.recv_handler(message)
 148
 149     @property
 150     def plom_closed(self):
 151         return self.client_terminated
 152
 153 from plomrogue.io_tcp import PlomSocket
 154 class PlomSocketClient(PlomSocket):
 155
 156     def __init__(self, recv_handler, url):
 157         import socket
 158         self.recv_handler = recv_handler
 159         host, port = url.split(':')
 160         super().__init__(socket.create_connection((host, port)))
 161
 162     def close(self):
 163         self.socket.close()
 164
 165     def run(self):
 166         import ssl
 167         try:
 168             for msg in self.recv():
 169                 if msg == 'NEED_SSL':
 170                     self.socket = ssl.wrap_socket(self.socket)
 171                     continue
 172                 self.recv_handler(msg)
 173         except BrokenSocketConnection:
 174             pass  # we assume socket will be known as dead by now
 175
 176 def cmd_TURN(game, n):
 177     game.turn_complete = False
 178 cmd_TURN.argtypes = 'int:nonneg'
 179
 180 def cmd_OTHER_WIPE(game):
 181     game.portals_new = {}
 182     game.annotations_new = {}
 183     game.things_new = []
 184 cmd_OTHER_WIPE.argtypes = ''
 185
 186 def cmd_LOGIN_OK(game):
 187     game.tui.switch_mode('post_login_wait')
 188     game.tui.send('GET_GAMESTATE')
 189     game.tui.log_msg('@ welcome!')
 190     game.tui.log_msg('@ hint: see top of terminal for how to get help.')
 191     game.tui.log_msg('@ hint: enter study mode to understand your environment.')
 192 cmd_LOGIN_OK.argtypes = ''
 193
 194 def cmd_ADMIN_OK(game):
 195     game.tui.is_admin = True
 196     game.tui.log_msg('@ you now have admin rights')
 197     game.tui.switch_mode('admin')
 198     game.tui.do_refresh = True
 199 cmd_ADMIN_OK.argtypes = ''
 200
 201 def cmd_REPLY(game, msg):
 202     game.tui.log_msg('#MUSICPLAYER: ' + msg)
 203     game.tui.do_refresh = True
 204 cmd_REPLY.argtypes = 'string'
 205
 206 def cmd_CHAT(game, msg):
 207     game.tui.log_msg('# ' + msg)
 208     game.tui.do_refresh = True
 209 cmd_CHAT.argtypes = 'string'
 210
 211 def cmd_CHATFACE(game, thing_id):
 212     game.tui.draw_face = thing_id
 213     game.tui.do_refresh = True
 214 cmd_CHATFACE.argtypes = 'int:pos'
 215
 216 def cmd_PLAYER_ID(game, player_id):
 217     game.player_id = player_id
 218 cmd_PLAYER_ID.argtypes = 'int:nonneg'
 219
 220 def cmd_PLAYERS_HAT_CHARS(game, hat_chars):
 221     game.players_hat_chars_new = hat_chars
 222 cmd_PLAYERS_HAT_CHARS.argtypes = 'string'
 223
 224 def cmd_THING(game, yx, thing_type, protection, thing_id, portable, commandable):
 225     t = game.get_thing_temp(thing_id)
 226     if not t:
 227         t = ThingBase(game, thing_id)
 228         game.things_new += [t]
 229     t.position = yx
 230     t.type_ = thing_type
 231     t.protection = protection
 232     t.portable = portable
 233     t.commandable = commandable
 234 cmd_THING.argtypes = 'yx_tuple:nonneg string:thing_type char int:nonneg bool bool'
 235
 236 def cmd_THING_NAME(game, thing_id, name):
 237     t = game.get_thing_temp(thing_id)
 238     t.name = name
 239 cmd_THING_NAME.argtypes = 'int:pos string'
 240
 241 def cmd_THING_FACE(game, thing_id, face):
 242     t = game.get_thing_temp(thing_id)
 243     t.face = face
 244 cmd_THING_FACE.argtypes = 'int:pos string'
 245
 246 def cmd_THING_HAT(game, thing_id, hat):
 247     t = game.get_thing_temp(thing_id)
 248     t.hat = hat
 249 cmd_THING_HAT.argtypes = 'int:pos string'
 250
 251 def cmd_THING_DESIGN(game, thing_id, size, design):
 252     t = game.get_thing_temp(thing_id)
 253     t.design = [size, design]
 254 cmd_THING_DESIGN.argtypes = 'int:pos yx_tuple string'
 255
 256 def cmd_THING_CHAR(game, thing_id, c):
 257     t = game.get_thing_temp(thing_id)
 258     t.thing_char = c
 259 cmd_THING_CHAR.argtypes = 'int:pos char'
 260
 261 def cmd_MAP(game, geometry, size, content):
 262     map_geometry_class = globals()['MapGeometry' + geometry]
 263     game.map_geometry_new = map_geometry_class(size)
 264     game.map_content_new = content
 265     if type(game.map_geometry_new) == MapGeometrySquare:
 266         game.tui.movement_keys = {
 267             game.tui.keys['square_move_up']: 'UP',
 268             game.tui.keys['square_move_left']: 'LEFT',
 269             game.tui.keys['square_move_down']: 'DOWN',
 270             game.tui.keys['square_move_right']: 'RIGHT',
 271         }
 272     elif type(game.map_geometry_new) == MapGeometryHex:
 273         game.tui.movement_keys = {
 274             game.tui.keys['hex_move_upleft']: 'UPLEFT',
 275             game.tui.keys['hex_move_upright']: 'UPRIGHT',
 276             game.tui.keys['hex_move_right']: 'RIGHT',
 277             game.tui.keys['hex_move_downright']: 'DOWNRIGHT',
 278             game.tui.keys['hex_move_downleft']: 'DOWNLEFT',
 279             game.tui.keys['hex_move_left']: 'LEFT',
 280         }
 281 cmd_MAP.argtypes = 'string:map_geometry yx_tuple:pos string'
 282
 283 def cmd_FOV(game, content):
 284     game.fov_new = content
 285 cmd_FOV.argtypes = 'string'
 286
 287 def cmd_MAP_CONTROL(game, content):
 288     game.map_control_content_new = content
 289 cmd_MAP_CONTROL.argtypes = 'string'
 290
 291 def cmd_GAME_STATE_COMPLETE(game):
 292     game.tui.do_refresh = True
 293     game.tui.info_cached = None
 294     game.things = game.things_new
 295     game.portals = game.portals_new
 296     game.annotations = game.annotations_new
 297     game.fov = game.fov_new
 298     game.map_geometry = game.map_geometry_new
 299     game.map_content = game.map_content_new
 300     game.map_control_content = game.map_control_content_new
 301     game.player = game.get_thing(game.player_id)
 302     game.players_hat_chars = game.players_hat_chars_new
 303     game.bladder_pressure = game.bladder_pressure_new
 304     game.energy = game.energy_new
 305     game.turn_complete = True
 306     if game.tui.mode.name == 'post_login_wait':
 307         game.tui.switch_mode('play')
 308 cmd_GAME_STATE_COMPLETE.argtypes = ''
 309
 310 def cmd_PORTAL(game, position, msg):
 311     game.portals_new[position] = msg
 312 cmd_PORTAL.argtypes = 'yx_tuple:nonneg string'
 313
 314 def cmd_PLAY_ERROR(game, msg):
 315     game.tui.log_msg('? ' + msg)
 316     game.tui.flash = True
 317     game.tui.do_refresh = True
 318 cmd_PLAY_ERROR.argtypes = 'string'
 319
 320 def cmd_GAME_ERROR(game, msg):
 321     game.tui.log_msg('? game error: ' + msg)
 322     game.tui.do_refresh = True
 323 cmd_GAME_ERROR.argtypes = 'string'
 324
 325 def cmd_ARGUMENT_ERROR(game, msg):
 326     game.tui.log_msg('? syntax error: ' + msg)
 327     game.tui.do_refresh = True
 328 cmd_ARGUMENT_ERROR.argtypes = 'string'
 329
 330 def cmd_ANNOTATION(game, position, msg):
 331     game.annotations_new[position] = msg
 332     if game.tui.mode.shows_info:
 333         game.tui.do_refresh = True
 334 cmd_ANNOTATION.argtypes = 'yx_tuple:nonneg string'
 335
 336 def cmd_TASKS(game, tasks_comma_separated):
 337     game.tasks = tasks_comma_separated.split(',')
 338     game.tui.mode_write.legal = 'WRITE' in game.tasks
 339     game.tui.mode_command_thing.legal = 'COMMAND' in game.tasks
 340     game.tui.mode_take_thing.legal = 'PICK_UP' in game.tasks
 341     game.tui.mode_drop_thing.legal = 'DROP' in game.tasks
 342 cmd_TASKS.argtypes = 'string'
 343
 344 def cmd_THING_TYPE(game, thing_type, symbol_hint):
 345     game.thing_types[thing_type] = symbol_hint
 346 cmd_THING_TYPE.argtypes = 'string char'
 347
 348 def cmd_THING_INSTALLED(game, thing_id):
 349     game.get_thing_temp(thing_id).installed = True
 350 cmd_THING_INSTALLED.argtypes = 'int:pos'
 351
 352 def cmd_THING_CARRYING(game, thing_id, carried_id):
 353     game.get_thing_temp(thing_id).carrying = game.get_thing_temp(carried_id)
 354 cmd_THING_CARRYING.argtypes = 'int:pos int:pos'
 355
 356 def cmd_TERRAIN(game, terrain_char, terrain_desc):
 357     game.terrains[terrain_char] = terrain_desc
 358 cmd_TERRAIN.argtypes = 'char string'
 359
 360 def cmd_PONG(game):
 361     pass
 362 cmd_PONG.argtypes = ''
 363
 364 def cmd_DEFAULT_COLORS(game):
 365     game.tui.set_default_colors()
 366 cmd_DEFAULT_COLORS.argtypes = ''
 367
 368 def cmd_RANDOM_COLORS(game):
 369     game.tui.set_random_colors()
 370 cmd_RANDOM_COLORS.argtypes = ''
 371
 372 def cmd_STATS(game, bladder_pressure, energy):
 373     game.bladder_pressure_new = bladder_pressure
 374     game.energy_new = energy
 375 cmd_STATS.argtypes = 'int:nonneg int'
 376
 377 class Game(GameBase):
 378     turn_complete = False
 379     tasks = {}
 380     thing_types = {}
 381     things_new = []
 382
 383     def __init__(self, *args, **kwargs):
 384         super().__init__(*args, **kwargs)
 385         self.register_command(cmd_LOGIN_OK)
 386         self.register_command(cmd_ADMIN_OK)
 387         self.register_command(cmd_PONG)
 388         self.register_command(cmd_CHAT)
 389         self.register_command(cmd_CHATFACE)
 390         self.register_command(cmd_REPLY)
 391         self.register_command(cmd_PLAYER_ID)
 392         self.register_command(cmd_TURN)
 393         self.register_command(cmd_OTHER_WIPE)
 394         self.register_command(cmd_THING)
 395         self.register_command(cmd_THING_TYPE)
 396         self.register_command(cmd_THING_NAME)
 397         self.register_command(cmd_THING_CHAR)
 398         self.register_command(cmd_THING_FACE)
 399         self.register_command(cmd_THING_HAT)
 400         self.register_command(cmd_THING_DESIGN)
 401         self.register_command(cmd_THING_CARRYING)
 402         self.register_command(cmd_THING_INSTALLED)
 403         self.register_command(cmd_TERRAIN)
 404         self.register_command(cmd_MAP)
 405         self.register_command(cmd_MAP_CONTROL)
 406         self.register_command(cmd_PORTAL)
 407         self.register_command(cmd_ANNOTATION)
 408         self.register_command(cmd_GAME_STATE_COMPLETE)
 409         self.register_command(cmd_PLAYERS_HAT_CHARS)
 410         self.register_command(cmd_ARGUMENT_ERROR)
 411         self.register_command(cmd_GAME_ERROR)
 412         self.register_command(cmd_PLAY_ERROR)
 413         self.register_command(cmd_TASKS)
 414         self.register_command(cmd_FOV)
 415         self.register_command(cmd_DEFAULT_COLORS)
 416         self.register_command(cmd_RANDOM_COLORS)
 417         self.register_command(cmd_STATS)
 418         self.map_content = ''
 419         self.players_hat_chars = ''
 420         self.player_id = -1
 421         self.annotations = {}
 422         self.annotations_new = {}
 423         self.portals = {}
 424         self.portals_new = {}
 425         self.terrains = {}
 426         self.player = None
 427
 428     def get_string_options(self, string_option_type):
 429         if string_option_type == 'map_geometry':
 430             return ['Hex', 'Square']
 431         elif string_option_type == 'thing_type':
 432             return self.thing_types.keys()
 433         return None
 434
 435     def get_command(self, command_name):
 436         from functools import partial
 437         f = partial(self.commands[command_name], self)
 438         f.argtypes = self.commands[command_name].argtypes
 439         return f
 440
 441     def get_thing_temp(self, id_):
 442         for thing in self.things_new:
 443             if id_ == thing.id_:
 444                 return thing
 445         return None
 446
 447 class Mode:
 448
 449     def __init__(self, name, has_input_prompt=False, shows_info=False,
 450                  is_intro=False, is_single_char_entry=False):
 451         self.name = name
 452         self.short_desc = mode_helps[name]['short']
 453         self.available_modes = []
 454         self.available_actions = []
 455         self.has_input_prompt = has_input_prompt
 456         self.shows_info = shows_info
 457         self.is_intro = is_intro
 458         self.help_intro = mode_helps[name]['long']
 459         self.intro_msg = mode_helps[name]['intro']
 460         self.is_single_char_entry = is_single_char_entry
 461         self.legal = True
 462
 463     def iter_available_modes(self, tui):
 464         for mode_name in self.available_modes:
 465             mode = getattr(tui, 'mode_' + mode_name)
 466             if not mode.legal:
 467                 continue
 468             key = tui.keys['switch_to_' + mode.name]
 469             yield mode, key
 470
 471     def list_available_modes(self, tui):
 472         msg = ''
 473         if len(self.available_modes) > 0:
 474             msg = 'Other modes available from here:\n'
 475             for mode, key in self.iter_available_modes(tui):
 476                 msg += '[%s] – %s\n' % (key, mode.short_desc)
 477         return msg
 478
 479     def mode_switch_on_key(self, tui, key_pressed):
 480         for mode, key in self.iter_available_modes(tui):
 481             if key_pressed == key:
 482                 tui.switch_mode(mode.name)
 483                 return True
 484         return False
 485
 486 class TUI:
 487     mode_admin_enter = Mode('admin_enter', has_input_prompt=True)
 488     mode_admin = Mode('admin')
 489     mode_play = Mode('play')
 490     mode_study = Mode('study', shows_info=True)
 491     mode_write = Mode('write', is_single_char_entry=True)
 492     mode_edit = Mode('edit')
 493     mode_control_pw_type = Mode('control_pw_type', has_input_prompt=True)
 494     mode_control_pw_pw = Mode('control_pw_pw', has_input_prompt=True)
 495     mode_control_tile_type = Mode('control_tile_type', has_input_prompt=True)
 496     mode_control_tile_draw = Mode('control_tile_draw')
 497     mode_admin_thing_protect = Mode('admin_thing_protect', has_input_prompt=True)
 498     mode_annotate = Mode('annotate', has_input_prompt=True, shows_info=True)
 499     mode_portal = Mode('portal', has_input_prompt=True, shows_info=True)
 500     mode_chat = Mode('chat', has_input_prompt=True)
 501     mode_waiting_for_server = Mode('waiting_for_server', is_intro=True)
 502     mode_login = Mode('login', has_input_prompt=True, is_intro=True)
 503     mode_post_login_wait = Mode('post_login_wait', is_intro=True)
 504     mode_password = Mode('password', has_input_prompt=True)
 505     mode_name_thing = Mode('name_thing', has_input_prompt=True, shows_info=True)
 506     mode_command_thing = Mode('command_thing', has_input_prompt=True)
 507     mode_take_thing = Mode('take_thing', has_input_prompt=True)
 508     mode_drop_thing = Mode('drop_thing', has_input_prompt=True)
 509     mode_enter_face = Mode('enter_face', has_input_prompt=True)
 510     mode_enter_design = Mode('enter_design', has_input_prompt=True)
 511     is_admin = False
 512     tile_draw = False
 513
 514     def __init__(self, host):
 515         import os
 516         import json
 517         self.mode_play.available_modes = ["chat", "study", "edit", "admin_enter",
 518                                           "command_thing", "take_thing",
 519                                           "drop_thing"]
 520         self.mode_play.available_actions = ["move", "teleport", "door", "consume",
 521                                             "install", "wear", "spin", "dance"]
 522         self.mode_study.available_modes = ["chat", "play", "admin_enter", "edit"]
 523         self.mode_study.available_actions = ["toggle_map_mode", "move_explorer"]
 524         self.mode_admin.available_modes = ["admin_thing_protect", "control_pw_type",
 525                                            "control_tile_type", "chat",
 526                                            "study", "play", "edit"]
 527         self.mode_admin.available_actions = ["move", "toggle_map_mode"]
 528         self.mode_control_tile_draw.available_modes = ["admin_enter"]
 529         self.mode_control_tile_draw.available_actions = ["move_explorer",
 530                                                          "toggle_tile_draw"]
 531         self.mode_edit.available_modes = ["write", "annotate", "portal",
 532                                           "name_thing", "enter_face", "enter_design",
 533                                           "password",
 534                                           "chat", "study", "play", "admin_enter"]
 535         self.mode_edit.available_actions = ["move", "flatten", "install",
 536                                             "toggle_map_mode"]
 537         self.mode = None
 538         self.host = host
 539         self.game = Game()
 540         self.game.tui = self
 541         self.parser = Parser(self.game)
 542         self.log = []
 543         self.do_refresh = True
 544         self.queue = queue.Queue()
 545         self.login_name = None
 546         self.map_mode = 'terrain + things'
 547         self.password = 'foo'
 548         self.switch_mode('waiting_for_server')
 549         self.keys = {
 550             'switch_to_chat': 't',
 551             'switch_to_play': 'p',
 552             'switch_to_password': 'P',
 553             'switch_to_annotate': 'M',
 554             'switch_to_portal': 'T',
 555             'switch_to_study': '?',
 556             'switch_to_edit': 'E',
 557             'switch_to_write': 'm',
 558             'switch_to_name_thing': 'N',
 559             'switch_to_command_thing': 'O',
 560             'switch_to_admin_enter': 'A',
 561             'switch_to_control_pw_type': 'C',
 562             'switch_to_control_tile_type': 'Q',
 563             'switch_to_admin_thing_protect': 'T',
 564             'flatten': 'F',
 565             'switch_to_enter_face': 'f',
 566             'switch_to_enter_design': 'D',
 567             'switch_to_take_thing': 'z',
 568             'switch_to_drop_thing': 'u',
 569             'teleport': 'p',
 570             'consume': 'C',
 571             'door': 'D',
 572             'install': 'I',
 573             'wear': 'W',
 574             'spin': 'S',
 575             'dance': 'T',
 576             'help': 'h',
 577             'toggle_map_mode': 'L',
 578             'toggle_tile_draw': 'm',
 579             'hex_move_upleft': 'w',
 580             'hex_move_upright': 'e',
 581             'hex_move_right': 'd',
 582             'hex_move_downright': 'x',
 583             'hex_move_downleft': 'y',
 584             'hex_move_left': 'a',
 585             'square_move_up': 'w',
 586             'square_move_left': 'a',
 587             'square_move_down': 's',
 588             'square_move_right': 'd',
 589         }
 590         if os.path.isfile('config.json'):
 591             with open('config.json', 'r') as f:
 592                 keys_conf = json.loads(f.read())
 593             for k in keys_conf:
 594                 self.keys[k] = keys_conf[k]
 595         self.show_help = False
 596         self.disconnected = True
 597         self.force_instant_connect = True
 598         self.input_lines = []
 599         self.fov = ''
 600         self.flash = False
 601         self.map_lines = []
 602         self.ascii_draw_stage = 0
 603         self.full_ascii_draw = ''
 604         self.offset = YX(0,0)
 605         curses.wrapper(self.loop)
 606
 607     def connect(self):
 608
 609         def handle_recv(msg):
 610             if msg == 'BYE':
 611                 self.socket.close()
 612             else:
 613                 self.queue.put(msg)
 614
 615         self.log_msg('@ attempting connect')
 616         socket_client_class = PlomSocketClient
 617         if self.host.startswith('ws://') or self.host.startswith('wss://'):
 618             socket_client_class = WebSocketClient
 619         try:
 620             self.socket = socket_client_class(handle_recv, self.host)
 621             self.socket_thread = threading.Thread(target=self.socket.run)
 622             self.socket_thread.start()
 623             self.disconnected = False
 624             self.game.thing_types = {}
 625             self.game.terrains = {}
 626             self.is_admin = False
 627             time.sleep(0.1)  # give potential SSL negotation some time …
 628             self.socket.send('TASKS')
 629             self.socket.send('TERRAINS')
 630             self.socket.send('THING_TYPES')
 631             self.switch_mode('login')
 632         except ConnectionRefusedError:
 633             self.log_msg('@ server connect failure')
 634             self.disconnected = True
 635             self.switch_mode('waiting_for_server')
 636         self.do_refresh = True
 637
 638     def reconnect(self):
 639         self.log_msg('@ attempting reconnect')
 640         self.send('QUIT')
 641         # necessitated by some strange SSL race conditions with ws4py
 642         time.sleep(0.1)  # FIXME find out why exactly necessary
 643         self.switch_mode('waiting_for_server')
 644         self.connect()
 645
 646     def send(self, msg):
 647         try:
 648             if hasattr(self.socket, 'plom_closed') and self.socket.plom_closed:
 649                 raise BrokenSocketConnection
 650             self.socket.send(msg)
 651         except (BrokenPipeError, BrokenSocketConnection):
 652             self.log_msg('@ server disconnected :(')
 653             self.disconnected = True
 654             self.force_instant_connect = True
 655             self.do_refresh = True
 656
 657     def log_msg(self, msg):
 658         self.log += [msg]
 659         if len(self.log) > 100:
 660             self.log = self.log[-100:]
 661
 662     def restore_input_values(self):
 663         if self.mode.name == 'annotate' and self.explorer in self.game.annotations:
 664             self.input_ = self.game.annotations[self.explorer]
 665         elif self.mode.name == 'portal' and self.explorer in self.game.portals:
 666             self.input_ = self.game.portals[self.explorer]
 667         elif self.mode.name == 'password':
 668             self.input_ = self.password
 669         elif self.mode.name == 'name_thing':
 670             if hasattr(self.game.player.carrying, 'name'):
 671                 self.input_ = self.game.player.carrying.name
 672         elif self.mode.name == 'admin_thing_protect':
 673             if hasattr(self.game.player.carrying, 'protection'):
 674                 self.input_ = self.game.player.carrying.protection
 675         elif self.mode.name == 'enter_face':
 676             start = self.ascii_draw_stage * 6
 677             end = (self.ascii_draw_stage + 1) * 6
 678             self.input_ = self.game.player.face[start:end]
 679         elif self.mode.name == 'enter_design':
 680             width = self.game.player.carrying.design[0].x
 681             start = self.ascii_draw_stage * width
 682             end = (self.ascii_draw_stage + 1) * width
 683             self.input_ = self.game.player.carrying.design[1][start:end]
 684
 685     def send_tile_control_command(self):
 686         self.send('SET_TILE_CONTROL %s %s' %
 687                   (self.explorer, quote(self.tile_control_char)))
 688
 689     def toggle_map_mode(self):
 690         if self.map_mode == 'terrain only':
 691             self.map_mode = 'terrain + annotations'
 692         elif self.map_mode == 'terrain + annotations':
 693             self.map_mode = 'terrain + things'
 694         elif self.map_mode == 'terrain + things':
 695             self.map_mode = 'protections'
 696         elif self.map_mode == 'protections':
 697             self.map_mode = 'terrain only'
 698
 699     def switch_mode(self, mode_name):
 700
 701         def fail(msg, return_mode='play'):
 702             self.log_msg('? ' + msg)
 703             self.flash = True
 704             self.switch_mode(return_mode)
 705
 706         if self.mode and self.mode.name == 'control_tile_draw':
 707             self.log_msg('@ finished tile protection drawing.')
 708         self.draw_face = False
 709         self.tile_draw = False
 710         self.ascii_draw_stage = 0
 711         self.full_ascii_draw = ''
 712         if mode_name == 'command_thing' and\
 713            (not self.game.player.carrying or
 714             not self.game.player.carrying.commandable):
 715             return fail('not carrying anything commandable')
 716         if mode_name == 'name_thing' and not self.game.player.carrying:
 717             return fail('not carrying anything to re-name', 'edit')
 718         if mode_name == 'admin_thing_protect' and not self.game.player.carrying:
 719             return fail('not carrying anything to protect')
 720         if mode_name == 'take_thing' and self.game.player.carrying:
 721             return fail('already carrying something')
 722         if mode_name == 'drop_thing' and not self.game.player.carrying:
 723             return fail('not carrying anything droppable')
 724         if mode_name == 'enter_design' and\
 725            (not self.game.player.carrying or
 726             not hasattr(self.game.player.carrying, 'design')):
 727             return fail('not carrying designable to edit', 'edit')
 728         if mode_name == 'admin_enter' and self.is_admin:
 729             mode_name = 'admin'
 730         self.mode = getattr(self, 'mode_' + mode_name)
 731         if self.mode.name in {'control_tile_draw', 'control_tile_type',
 732                               'control_pw_type'}:
 733             self.map_mode = 'protections'
 734         elif self.mode.name != 'edit':
 735             self.map_mode = 'terrain + things'
 736         if self.mode.shows_info or self.mode.name == 'control_tile_draw':
 737             self.explorer = YX(self.game.player.position.y,
 738                                self.game.player.position.x)
 739         if self.mode.is_single_char_entry:
 740             self.show_help = True
 741         if len(self.mode.intro_msg) > 0:
 742             self.log_msg(self.mode.intro_msg)
 743         if self.mode.name == 'login':
 744             if self.login_name:
 745                 self.send('LOGIN ' + quote(self.login_name))
 746             else:
 747                 self.log_msg('@ enter username')
 748         elif self.mode.name == 'take_thing':
 749             self.log_msg('Portable things in reach for pick-up:')
 750             directed_moves = {
 751                 'HERE': YX(0, 0), 'LEFT': YX(0, -1), 'RIGHT': YX(0, 1)
 752             }
 753             if type(self.game.map_geometry) == MapGeometrySquare:
 754                 directed_moves['UP'] = YX(-1, 0)
 755                 directed_moves['DOWN'] = YX(1, 0)
 756             elif type(self.game.map_geometry) == MapGeometryHex:
 757                 if self.game.player.position.y % 2:
 758                     directed_moves['UPLEFT'] = YX(-1, 0)
 759                     directed_moves['UPRIGHT'] = YX(-1, 1)
 760                     directed_moves['DOWNLEFT'] = YX(1, 0)
 761                     directed_moves['DOWNRIGHT'] = YX(1, 1)
 762                 else:
 763                     directed_moves['UPLEFT'] = YX(-1, -1)
 764                     directed_moves['UPRIGHT'] = YX(-1, 0)
 765                     directed_moves['DOWNLEFT'] = YX(1, -1)
 766                     directed_moves['DOWNRIGHT'] = YX(1, 0)
 767             select_range = {}
 768             for direction in directed_moves:
 769                 move = directed_moves[direction]
 770                 select_range[direction] = self.game.player.position + move
 771             self.selectables = []
 772             directions = []
 773             for direction in select_range:
 774                 for t in [t for t in self.game.things
 775                           if t.portable and t.position == select_range[direction]]:
 776                     self.selectables += [t.id_]
 777                     directions += [direction]
 778             if len(self.selectables) == 0:
 779                 return fail('nothing to pick-up')
 780             else:
 781                 for i in range(len(self.selectables)):
 782                     t = self.game.get_thing(self.selectables[i])
 783                     self.log_msg('%s %s: %s' % (i, directions[i],
 784                                                 self.get_thing_info(t)))
 785         elif self.mode.name == 'drop_thing':
 786             self.log_msg('Direction to drop thing to:')
 787             self.selectables =\
 788                 ['HERE'] + list(self.game.tui.movement_keys.values())
 789             for i in range(len(self.selectables)):
 790                 self.log_msg(str(i) + ': ' + self.selectables[i])
 791         elif self.mode.name == 'enter_design':
 792             if self.game.player.carrying.type_ == 'Hat':
 793                 self.log_msg('@ The design you enter must be %s lines of max %s '
 794                              'characters width each'
 795                              % (self.game.player.carrying.design[0].y,
 796                                 self.game.player.carrying.design[0].x))
 797                 self.log_msg('@ Legal characters: ' + self.game.players_hat_chars)
 798                 self.log_msg('@ (Eat cookies to extend the ASCII characters available for drawing.)')
 799             else:
 800                 self.log_msg('@ Width of first line determines maximum width for remaining design')
 801                 self.log_msg('@ Finish design by entering an empty line (multiple space characters do not count as empty)')
 802         elif self.mode.name == 'command_thing':
 803             self.send('TASK:COMMAND ' + quote('HELP'))
 804         elif self.mode.name == 'control_pw_pw':
 805             self.log_msg('@ enter protection password for "%s":' % self.tile_control_char)
 806         elif self.mode.name == 'control_tile_draw':
 807             self.log_msg('@ can draw protection character "%s", turn drawing on/off with [%s], finish with [%s].' % (self.tile_control_char, self.keys['toggle_tile_draw'], self.keys['switch_to_admin_enter']))
 808         self.input_ = ""
 809         self.restore_input_values()
 810
 811     def set_default_colors(self):
 812         if curses.can_change_color():
 813             curses.init_color(7, 1000, 1000, 1000)
 814             curses.init_color(0, 0, 0, 0)
 815         self.do_refresh = True
 816
 817     def set_random_colors(self):
 818
 819         def rand(offset):
 820             import random
 821             return int(offset + random.random()*375)
 822
 823         if curses.can_change_color():
 824             curses.init_color(7, rand(625), rand(625), rand(625))
 825             curses.init_color(0, rand(0), rand(0), rand(0))
 826         self.do_refresh = True
 827
 828     def get_info(self):
 829         if self.info_cached:
 830             return self.info_cached
 831         pos_i = self.explorer.y * self.game.map_geometry.size.x + self.explorer.x
 832         info_to_cache = ''
 833         if len(self.game.fov) > pos_i and self.game.fov[pos_i] != '.':
 834             info_to_cache += 'outside field of view'
 835         else:
 836             for t in self.game.things:
 837                 if t.position == self.explorer:
 838                     info_to_cache += '%s' % self.get_thing_info(t, True)
 839             terrain_char = self.game.map_content[pos_i]
 840             terrain_desc = '?'
 841             if terrain_char in self.game.terrains:
 842                 terrain_desc = self.game.terrains[terrain_char]
 843             info_to_cache += 'TERRAIN: %s (%s' % (terrain_char,
 844                                                        terrain_desc)
 845             protection = self.game.map_control_content[pos_i]
 846             if protection != '.':
 847                 info_to_cache += '/protection:%s' % protection
 848             info_to_cache += ')\n'
 849             if self.explorer in self.game.portals:
 850                 info_to_cache += 'PORTAL: ' +\
 851                     self.game.portals[self.explorer] + '\n'
 852             if self.explorer in self.game.annotations:
 853                 info_to_cache += 'ANNOTATION: ' +\
 854                     self.game.annotations[self.explorer]
 855         self.info_cached = info_to_cache
 856         return self.info_cached
 857
 858     def get_thing_info(self, t, detailed=False):
 859         info = ''
 860         if detailed:
 861             info += '- '
 862         info += self.game.thing_types[t.type_]
 863         if hasattr(t, 'thing_char'):
 864             info += t.thing_char
 865         if hasattr(t, 'name'):
 866             info += ': %s' % t.name
 867         info += ' (%s' % t.type_
 868         if hasattr(t, 'installed'):
 869             info += '/installed'
 870         if t.type_ == 'Bottle':
 871             if t.thing_char == '_':
 872                 info += '/empty'
 873             elif t.thing_char == '~':
 874                 info += '/full'
 875         if detailed:
 876             protection = t.protection
 877             if protection != '.':
 878                 info += '/protection:%s' % protection
 879             info += ')\n'
 880             if hasattr(t, 'hat') or hasattr(t, 'face'):
 881                 info += '----------\n'
 882             if hasattr(t, 'hat'):
 883                 info += '| %s |\n' % t.hat[0:6]
 884                 info += '| %s |\n' % t.hat[6:12]
 885                 info += '| %s |\n' % t.hat[12:18]
 886             if hasattr(t, 'face'):
 887                 info += '| %s |\n' % t.face[0:6]
 888                 info += '| %s |\n' % t.face[6:12]
 889                 info += '| %s |\n' % t.face[12:18]
 890                 info += '----------\n'
 891             if hasattr(t, 'design'):
 892                 line_length = t.design[0].x
 893                 lines = []
 894                 for i in range(t.design[0].y):
 895                     start = i * line_length
 896                     end = (i + 1) * line_length
 897                     lines += [t.design[1][start:end]]
 898                 info += '-' * (line_length + 4) + '\n'
 899                 for line in lines:
 900                     info += '| %s |\n' % line
 901                 info += '-' * (line_length + 4) + '\n'
 902         else:
 903             info += ')'
 904         return info
 905
 906     def loop(self, stdscr):
 907         import datetime
 908
 909         def safe_addstr(y, x, line):
 910             if y < self.size.y - 1 or x + len(line) < self.size.x:
 911                 stdscr.addstr(y, x, line, curses.color_pair(1))
 912             else:  # workaround to <https://stackoverflow.com/q/7063128>
 913                 cut_i = self.size.x - x - 1
 914                 cut = line[:cut_i]
 915                 last_char = line[cut_i]
 916                 stdscr.addstr(y, self.size.x - 2, last_char, curses.color_pair(1))
 917                 stdscr.insstr(y, self.size.x - 2, ' ')
 918                 stdscr.addstr(y, x, cut, curses.color_pair(1))
 919
 920         def handle_input(msg):
 921             command, args = self.parser.parse(msg)
 922             command(*args)
 923
 924         def task_action_on(action):
 925             return action_tasks[action] in self.game.tasks
 926
 927         def msg_into_lines_of_width(msg, width):
 928             chunk = ''
 929             lines = []
 930             x = 0
 931             for i in range(len(msg)):
 932                 if x >= width or msg[i] == "\n":
 933                     lines += [chunk]
 934                     chunk = ''
 935                     x = 0
 936                     if msg[i] == "\n":
 937                         x -= 1
 938                 if msg[i] != "\n":
 939                     chunk += msg[i]
 940                 x += 1
 941             lines += [chunk]
 942             return lines
 943
 944         def reset_screen_size():
 945             self.size = YX(*stdscr.getmaxyx())
 946             self.size = self.size - YX(self.size.y % 4, 0)
 947             self.size = self.size - YX(0, self.size.x % 4)
 948             self.left_window_width = min(52, int(self.size.x / 2))
 949             self.right_window_width = self.size.x - self.left_window_width
 950
 951         def recalc_input_lines():
 952             if not self.mode.has_input_prompt:
 953                 self.input_lines = []
 954             else:
 955                 self.input_lines = msg_into_lines_of_width(input_prompt
 956                                                            + self.input_ + '█',
 957                                                            self.right_window_width)
 958
 959         def move_explorer(direction):
 960             target = self.game.map_geometry.move_yx(self.explorer, direction)
 961             if target:
 962                 self.info_cached = None
 963                 self.explorer = target
 964                 if self.tile_draw:
 965                     self.send_tile_control_command()
 966             else:
 967                 self.flash = True
 968
 969         def draw_history():
 970             lines = []
 971             for line in self.log:
 972                 lines += msg_into_lines_of_width(line, self.right_window_width)
 973             lines.reverse()
 974             height_header = 2
 975             max_y = self.size.y - len(self.input_lines)
 976             for i in range(len(lines)):
 977                 if (i >= max_y - height_header):
 978                     break
 979                 safe_addstr(max_y - i - 1, self.left_window_width, lines[i])
 980
 981         def draw_info():
 982             info = 'MAP VIEW: %s\n%s' % (self.map_mode, self.get_info())
 983             lines = msg_into_lines_of_width(info, self.right_window_width)
 984             height_header = 2
 985             for i in range(len(lines)):
 986                 y = height_header + i
 987                 if y >= self.size.y - len(self.input_lines):
 988                     break
 989                 safe_addstr(y, self.left_window_width, lines[i])
 990
 991         def draw_input():
 992             y = self.size.y - len(self.input_lines)
 993             for i in range(len(self.input_lines)):
 994                 safe_addstr(y, self.left_window_width, self.input_lines[i])
 995                 y += 1
 996
 997         def draw_stats():
 998             stats = 'ENERGY: %s BLADDER: %s' % (self.game.energy,
 999                                                 self.game.bladder_pressure)
1000             safe_addstr(0, self.left_window_width, stats)
1001
1002         def draw_mode():
1003             help = "hit [%s] for help" % self.keys['help']
1004             if self.mode.has_input_prompt:
1005                 help = "enter /help for help"
1006             safe_addstr(1, self.left_window_width,
1007                         'MODE: %s – %s' % (self.mode.short_desc, help))
1008
1009         def draw_map():
1010             if (not self.game.turn_complete) and len(self.map_lines) == 0:
1011                 return
1012             if self.game.turn_complete:
1013                 map_lines_split = []
1014                 for y in range(self.game.map_geometry.size.y):
1015                     start = self.game.map_geometry.size.x * y
1016                     end = start + self.game.map_geometry.size.x
1017                     if self.map_mode == 'protections':
1018                         map_lines_split += [[c + ' ' for c
1019                                              in self.game.map_control_content[start:end]]]
1020                     else:
1021                         map_lines_split += [[c + ' ' for c
1022                                              in self.game.map_content[start:end]]]
1023                 if self.map_mode == 'terrain + annotations':
1024                     for p in self.game.annotations:
1025                         map_lines_split[p.y][p.x] = 'A '
1026                 elif self.map_mode == 'terrain + things':
1027                     for p in self.game.portals.keys():
1028                         original = map_lines_split[p.y][p.x]
1029                         map_lines_split[p.y][p.x] = original[0] + 'P'
1030                     used_positions = []
1031
1032                     def draw_thing(t, used_positions):
1033                         symbol = self.game.thing_types[t.type_]
1034                         meta_char = ' '
1035                         if hasattr(t, 'thing_char'):
1036                             meta_char = t.thing_char
1037                         if t.position in used_positions:
1038                             meta_char = '+'
1039                         if hasattr(t, 'carrying') and t.carrying:
1040                             meta_char = '$'
1041                         map_lines_split[t.position.y][t.position.x] = symbol + meta_char
1042                         used_positions += [t.position]
1043
1044                     for t in [t for t in self.game.things if t.type_ != 'Player']:
1045                         draw_thing(t, used_positions)
1046                     for t in [t for t in self.game.things if t.type_ == 'Player']:
1047                         draw_thing(t, used_positions)
1048                 if self.mode.shows_info or self.mode.name == 'control_tile_draw':
1049                     map_lines_split[self.explorer.y][self.explorer.x] = '??'
1050                 elif self.map_mode != 'terrain + things':
1051                     map_lines_split[self.game.player.position.y]\
1052                         [self.game.player.position.x] = '??'
1053                 self.map_lines = []
1054                 if type(self.game.map_geometry) == MapGeometryHex:
1055                     indent = 0
1056                     for line in map_lines_split:
1057                         self.map_lines += [indent * ' ' + ''.join(line)]
1058                         indent = 0 if indent else 1
1059                 else:
1060                     for line in map_lines_split:
1061                         self.map_lines += [''.join(line)]
1062                 window_center = YX(int(self.size.y / 2),
1063                                    int(self.left_window_width / 2))
1064                 center = self.game.player.position
1065                 if self.mode.shows_info or self.mode.name == 'control_tile_draw':
1066                     center = self.explorer
1067                 center = YX(center.y, center.x * 2)
1068                 self.offset = center - window_center
1069                 if type(self.game.map_geometry) == MapGeometryHex and self.offset.y % 2:
1070                     self.offset += YX(0, 1)
1071             term_y = max(0, -self.offset.y)
1072             term_x = max(0, -self.offset.x)
1073             map_y = max(0, self.offset.y)
1074             map_x = max(0, self.offset.x)
1075             while term_y < self.size.y and map_y < len(self.map_lines):
1076                 to_draw = self.map_lines[map_y][map_x:self.left_window_width + self.offset.x]
1077                 safe_addstr(term_y, term_x, to_draw)
1078                 term_y += 1
1079                 map_y += 1
1080
1081         def draw_face_popup():
1082             t = self.game.get_thing(self.draw_face)
1083             if not t or not hasattr(t, 'face'):
1084                 self.draw_face = False
1085                 return
1086
1087             start_x = self.left_window_width - 10
1088             def draw_body_part(body_part, end_y):
1089                 safe_addstr(end_y - 3, start_x, '----------')
1090                 safe_addstr(end_y - 2, start_x, '| ' + body_part[0:6] + ' |')
1091                 safe_addstr(end_y - 1, start_x, '| ' + body_part[6:12] + ' |')
1092                 safe_addstr(end_y, start_x, '| ' + body_part[12:18] + ' |')
1093
1094             if hasattr(t, 'face'):
1095                 draw_body_part(t.face, self.size.y - 3)
1096             if hasattr(t, 'hat'):
1097                 draw_body_part(t.hat, self.size.y - 6)
1098             safe_addstr(self.size.y - 2, start_x, '----------')
1099             name = t.name[:]
1100             if len(name) > 6:
1101                 name = name[:6] + '…'
1102             safe_addstr(self.size.y - 1, start_x,
1103                         '@%s:%s' % (t.thing_char, name))
1104
1105         def draw_help():
1106             content = "%s help\n\n%s\n\n" % (self.mode.short_desc,
1107                                              self.mode.help_intro)
1108             if len(self.mode.available_actions) > 0:
1109                 content += "Available actions:\n"
1110                 for action in self.mode.available_actions:
1111                     if action in action_tasks:
1112                         if action_tasks[action] not in self.game.tasks:
1113                             continue
1114                     if action == 'move_explorer':
1115                         action = 'move'
1116                     if action == 'move':
1117                         key = ','.join(self.movement_keys)
1118                     else:
1119                         key = self.keys[action]
1120                     content += '[%s] – %s\n' % (key, action_descriptions[action])
1121                 content += '\n'
1122             content += self.mode.list_available_modes(self)
1123             for i in range(self.size.y):
1124                 safe_addstr(i,
1125                             self.left_window_width * (not self.mode.has_input_prompt),
1126                             ' ' * self.left_window_width)
1127             lines = []
1128             for line in content.split('\n'):
1129                 lines += msg_into_lines_of_width(line, self.right_window_width)
1130             for i in range(len(lines)):
1131                 if i >= self.size.y:
1132                     break
1133                 safe_addstr(i,
1134                             self.left_window_width * (not self.mode.has_input_prompt),
1135                             lines[i])
1136
1137         def draw_screen():
1138             stdscr.clear()
1139             stdscr.bkgd(' ', curses.color_pair(1))
1140             recalc_input_lines()
1141             if self.mode.has_input_prompt:
1142                 draw_input()
1143             if self.mode.shows_info:
1144                 draw_info()
1145             else:
1146                 draw_history()
1147             draw_mode()
1148             if not self.mode.is_intro:
1149                 draw_stats()
1150                 draw_map()
1151             if self.show_help:
1152                 draw_help()
1153             if self.draw_face and self.mode.name in {'chat', 'play'}:
1154                 draw_face_popup()
1155
1156         def pick_selectable(task_name):
1157             try:
1158                 i = int(self.input_)
1159                 if i < 0 or i >= len(self.selectables):
1160                     self.log_msg('? invalid index, aborted')
1161                 else:
1162                     self.send('TASK:%s %s' % (task_name, self.selectables[i]))
1163             except ValueError:
1164                 self.log_msg('? invalid index, aborted')
1165             self.input_ = ''
1166             self.switch_mode('play')
1167
1168         def enter_ascii_art(command, height, width,
1169                             with_pw=False, with_size=False):
1170             if with_size and self.ascii_draw_stage == 0:
1171                 width = len(self.input_)
1172                 if width > 36:
1173                     self.log_msg('? input too long, must be max 36; try again')
1174                     # TODO: move max width mechanism server-side
1175                     return
1176                 old_size = self.game.player.carrying.design[0]
1177                 if width != old_size.x:
1178                     # TODO: save remaining design?
1179                     self.game.player.carrying.design[1] = ''
1180                     self.game.player.carrying.design[0] = YX(old_size.y, width)
1181             elif len(self.input_) > width:
1182                 self.log_msg('? input too long, '
1183                              'must be max %s; try again' % width)
1184                 return
1185             self.log_msg('  ' + self.input_)
1186             if with_size and self.input_ in {'', ' '}\
1187                and self.ascii_draw_stage > 0:
1188                 height = self.ascii_draw_stage
1189             else:
1190                 if with_size:
1191                     height = self.ascii_draw_stage + 2
1192                 if len(self.input_) < width:
1193                     self.input_ += ' ' * (width - len(self.input_))
1194                 self.full_ascii_draw += self.input_
1195             if with_size:
1196                 old_size = self.game.player.carrying.design[0]
1197                 self.game.player.carrying.design[0] = YX(height, old_size.x)
1198             self.ascii_draw_stage += 1
1199             if self.ascii_draw_stage < height:
1200                 self.restore_input_values()
1201             else:
1202                 if with_pw and with_size:
1203                     self.send('%s_SIZE %s %s' % (command, YX(height, width),
1204                                                  quote(self.password)))
1205                 if with_pw:
1206                     self.send('%s %s %s' % (command, quote(self.full_ascii_draw),
1207                                             quote(self.password)))
1208                 else:
1209                     self.send('%s %s' % (command, quote(self.full_ascii_draw)))
1210                 self.full_ascii_draw = ""
1211                 self.ascii_draw_stage = 0
1212                 self.input_ = ""
1213                 self.switch_mode('edit')
1214
1215         action_descriptions = {
1216             'move': 'move',
1217             'flatten': 'flatten surroundings',
1218             'teleport': 'teleport',
1219             'take_thing': 'pick up thing',
1220             'drop_thing': 'drop thing',
1221             'toggle_map_mode': 'toggle map view',
1222             'toggle_tile_draw': 'toggle protection character drawing',
1223             'install': '(un-)install',
1224             'wear': '(un-)wear',
1225             'door': 'open/close',
1226             'consume': 'consume',
1227             'spin': 'spin',
1228             'dance': 'dance',
1229         }
1230
1231         action_tasks = {
1232             'flatten': 'FLATTEN_SURROUNDINGS',
1233             'take_thing': 'PICK_UP',
1234             'drop_thing': 'DROP',
1235             'door': 'DOOR',
1236             'install': 'INSTALL',
1237             'wear': 'WEAR',
1238             'move': 'MOVE',
1239             'command': 'COMMAND',
1240             'consume': 'INTOXICATE',
1241             'spin': 'SPIN',
1242             'dance': 'DANCE',
1243         }
1244
1245         curses.curs_set(0)  # hide cursor
1246         curses.start_color()
1247         self.set_default_colors()
1248         curses.init_pair(1, 7, 0)
1249         if not curses.can_change_color():
1250             self.log_msg('@ unfortunately, your terminal does not seem to '
1251                          'support re-definition of colors; you might miss out '
1252                          'on some color effects')
1253         stdscr.timeout(10)
1254         reset_screen_size()
1255         self.explorer = YX(0, 0)
1256         self.input_ = ''
1257         store_widechar = False
1258         input_prompt = '> '
1259         interval = datetime.timedelta(seconds=5)
1260         last_ping = datetime.datetime.now() - interval
1261         while True:
1262             if self.disconnected and self.force_instant_connect:
1263                 self.force_instant_connect = False
1264                 self.connect()
1265             now = datetime.datetime.now()
1266             if now - last_ping > interval:
1267                 if self.disconnected:
1268                     self.connect()
1269                 else:
1270                     self.send('PING')
1271                 last_ping = now
1272             if self.flash:
1273                 curses.flash()
1274                 self.flash = False
1275             if self.do_refresh:
1276                 draw_screen()
1277                 self.do_refresh = False
1278             while True:
1279                 try:
1280                     msg = self.queue.get(block=False)
1281                     handle_input(msg)
1282                 except queue.Empty:
1283                     break
1284             try:
1285                 key = stdscr.getkey()
1286                 self.do_refresh = True
1287             except curses.error:
1288                 continue
1289             keycode = None
1290             if len(key) == 1:
1291                 keycode = ord(key)
1292                 # workaround for <https://stackoverflow.com/a/56390915>
1293                 if store_widechar:
1294                     store_widechar = False
1295                     key = bytes([195, keycode]).decode()
1296                 if keycode == 195:
1297                     store_widechar = True
1298                     continue
1299             self.show_help = False
1300             self.draw_face = False
1301             if key == 'KEY_RESIZE':
1302                 reset_screen_size()
1303             elif self.mode.has_input_prompt and key == 'KEY_BACKSPACE':
1304                 self.input_ = self.input_[:-1]
1305             elif (((not self.mode.is_intro) and keycode == 27)  # Escape
1306                   or (self.mode.has_input_prompt and key == '\n'
1307                       and self.input_ == ''\
1308                       and self.mode.name in {'chat', 'command_thing',
1309                                              'take_thing', 'drop_thing',
1310                                              'admin_enter'})):
1311                 if self.mode.name not in {'chat', 'play', 'study', 'edit'}:
1312                     self.log_msg('@ aborted')
1313                 self.switch_mode('play')
1314             elif self.mode.has_input_prompt and key == '\n' and self.input_ == '/help':
1315                 self.show_help = True
1316                 self.input_ = ""
1317                 self.restore_input_values()
1318             elif self.mode.has_input_prompt and key != '\n':  # Return key
1319                 self.input_ += key
1320                 max_length = self.right_window_width * self.size.y - len(input_prompt) - 1
1321                 if len(self.input_) > max_length:
1322                     self.input_ = self.input_[:max_length]
1323             elif key == self.keys['help'] and not self.mode.is_single_char_entry:
1324                 self.show_help = True
1325             elif self.mode.name == 'login' and key == '\n':
1326                 self.login_name = self.input_
1327                 self.send('LOGIN ' + quote(self.input_))
1328                 self.input_ = ""
1329             elif self.mode.name == 'enter_face' and key == '\n':
1330                 enter_ascii_art('PLAYER_FACE', 3, 6)
1331             elif self.mode.name == 'enter_design' and key == '\n':
1332                 if self.game.player.carrying.type_ == 'Hat':
1333                     enter_ascii_art('THING_DESIGN',
1334                                     self.game.player.carrying.design[0].y,
1335                                     self.game.player.carrying.design[0].x, True)
1336                 else:
1337                     enter_ascii_art('THING_DESIGN',
1338                                     self.game.player.carrying.design[0].y,
1339                                     self.game.player.carrying.design[0].x,
1340                                     True, True)
1341             elif self.mode.name == 'take_thing' and key == '\n':
1342                 pick_selectable('PICK_UP')
1343             elif self.mode.name == 'drop_thing' and key == '\n':
1344                 pick_selectable('DROP')
1345             elif self.mode.name == 'command_thing' and key == '\n':
1346                 self.send('TASK:COMMAND ' + quote(self.input_))
1347                 self.input_ = ""
1348             elif self.mode.name == 'control_pw_pw' and key == '\n':
1349                 if self.input_ == '':
1350                     self.log_msg('@ aborted')
1351                 else:
1352                     self.send('SET_MAP_CONTROL_PASSWORD ' + quote(self.tile_control_char) + ' ' + quote(self.input_))
1353                     self.log_msg('@ sent new password for protection character "%s"' % self.tile_control_char)
1354                 self.switch_mode('admin')
1355             elif self.mode.name == 'password' and key == '\n':
1356                 if self.input_ == '':
1357                     self.input_ = ' '
1358                 self.password = self.input_
1359                 self.switch_mode('edit')
1360             elif self.mode.name == 'admin_enter' and key == '\n':
1361                 self.send('BECOME_ADMIN ' + quote(self.input_))
1362                 self.switch_mode('play')
1363             elif self.mode.name == 'control_pw_type' and key == '\n':
1364                 if len(self.input_) != 1:
1365                     self.log_msg('@ entered non-single-char, therefore aborted')
1366                     self.switch_mode('admin')
1367                 else:
1368                     self.tile_control_char = self.input_
1369                     self.switch_mode('control_pw_pw')
1370             elif self.mode.name == 'admin_thing_protect' and key == '\n':
1371                 if len(self.input_) != 1:
1372                     self.log_msg('@ entered non-single-char, therefore aborted')
1373                 else:
1374                     self.send('THING_PROTECTION %s' % (quote(self.input_)))
1375                     self.log_msg('@ sent new protection character for thing')
1376                 self.switch_mode('admin')
1377             elif self.mode.name == 'control_tile_type' and key == '\n':
1378                 if len(self.input_) != 1:
1379                     self.log_msg('@ entered non-single-char, therefore aborted')
1380                     self.switch_mode('admin')
1381                 else:
1382                     self.tile_control_char = self.input_
1383                     self.switch_mode('control_tile_draw')
1384             elif self.mode.name == 'chat' and key == '\n':
1385                 if self.input_ == '':
1386                     continue
1387                 if self.input_[0] == '/':
1388                     if self.input_.startswith('/nick'):
1389                         tokens = self.input_.split(maxsplit=1)
1390                         if len(tokens) == 2:
1391                             self.send('NICK ' + quote(tokens[1]))
1392                         else:
1393                             self.log_msg('? need login name')
1394                     else:
1395                         self.log_msg('? unknown command')
1396                 else:
1397                     self.send('ALL ' + quote(self.input_))
1398                 self.input_ = ""
1399             elif self.mode.name == 'name_thing' and key == '\n':
1400                 if self.input_ == '':
1401                     self.input_ = ' '
1402                 self.send('THING_NAME %s %s' % (quote(self.input_),
1403                                                 quote(self.password)))
1404                 self.switch_mode('edit')
1405             elif self.mode.name == 'annotate' and key == '\n':
1406                 if self.input_ == '':
1407                     self.input_ = ' '
1408                 self.send('ANNOTATE %s %s %s' % (self.explorer, quote(self.input_),
1409                                                  quote(self.password)))
1410                 self.switch_mode('edit')
1411             elif self.mode.name == 'portal' and key == '\n':
1412                 if self.input_ == '':
1413                     self.input_ = ' '
1414                 self.send('PORTAL %s %s %s' % (self.explorer, quote(self.input_),
1415                                                quote(self.password)))
1416                 self.switch_mode('edit')
1417             elif self.mode.name == 'study':
1418                 if self.mode.mode_switch_on_key(self, key):
1419                     continue
1420                 elif key == self.keys['toggle_map_mode']:
1421                     self.toggle_map_mode()
1422                 elif key in self.movement_keys:
1423                     move_explorer(self.movement_keys[key])
1424             elif self.mode.name == 'play':
1425                 if self.mode.mode_switch_on_key(self, key):
1426                     continue
1427                 elif key == self.keys['door'] and task_action_on('door'):
1428                     self.send('TASK:DOOR')
1429                 elif key == self.keys['consume'] and task_action_on('consume'):
1430                     self.send('TASK:INTOXICATE')
1431                 elif key == self.keys['wear'] and task_action_on('wear'):
1432                     self.send('TASK:WEAR')
1433                 elif key == self.keys['spin'] and task_action_on('spin'):
1434                     self.send('TASK:SPIN')
1435                 elif key == self.keys['dance'] and task_action_on('dance'):
1436                     self.send('TASK:DANCE')
1437                 elif key == self.keys['teleport']:
1438                     if self.game.player.position in self.game.portals:
1439                         self.host = self.game.portals[self.game.player.position]
1440                         self.reconnect()
1441                     else:
1442                         self.flash = True
1443                         self.log_msg('? not standing on portal')
1444                 elif key in self.movement_keys and task_action_on('move'):
1445                     self.send('TASK:MOVE ' + self.movement_keys[key])
1446             elif self.mode.name == 'write':
1447                 self.send('TASK:WRITE %s %s' % (key, quote(self.password)))
1448                 self.switch_mode('edit')
1449             elif self.mode.name == 'control_tile_draw':
1450                 if self.mode.mode_switch_on_key(self, key):
1451                     continue
1452                 elif key in self.movement_keys:
1453                     move_explorer(self.movement_keys[key])
1454                 elif key == self.keys['toggle_tile_draw']:
1455                     self.tile_draw = False if self.tile_draw else True
1456             elif self.mode.name == 'admin':
1457                 if self.mode.mode_switch_on_key(self, key):
1458                     continue
1459                 elif key == self.keys['toggle_map_mode']:
1460                     self.toggle_map_mode()
1461                 elif key in self.movement_keys and task_action_on('move'):
1462                     self.send('TASK:MOVE ' + self.movement_keys[key])
1463             elif self.mode.name == 'edit':
1464                 if self.mode.mode_switch_on_key(self, key):
1465                     continue
1466                 elif key == self.keys['flatten'] and task_action_on('flatten'):
1467                     self.send('TASK:FLATTEN_SURROUNDINGS ' + quote(self.password))
1468                 elif key == self.keys['install'] and task_action_on('install'):
1469                     self.send('TASK:INSTALL %s' % quote(self.password))
1470                 elif key == self.keys['toggle_map_mode']:
1471                     self.toggle_map_mode()
1472                 elif key in self.movement_keys and task_action_on('move'):
1473                     self.send('TASK:MOVE ' + self.movement_keys[key])
1474
1475 if len(sys.argv) != 2:
1476     raise ArgError('wrong number of arguments, need game host')
1477 host = sys.argv[1]
1478 TUI(host)