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
  13
  14 mode_helps = {
  15     'play': {
  16         'short': 'play',
  17         'long': 'This mode allows you to interact with the map.'
  18     },
  19     'study': {
  20         'short': 'study',
  21         '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.'},
  22     'edit': {
  23         'short': 'map edit',
  24         'long': 'This mode allows you to change the map in various ways.'
  25     },
  26     'write': {
  27         'short': 'terrain write',
  28         'long': 'This mode allows you to change the map tile you currently stand on (if your map editing password authorizes you so).  Just enter any printable ASCII character to imprint it on the ground below you.'
  29     },
  30     'control_pw_type': {
  31         'short': 'change tiles control password',
  32         'long': 'This mode is the first of two steps to change the password for a tile control character.  First enter the tile control character for which you want to change the password!'
  33     },
  34     'control_pw_pw': {
  35         'short': 'change tiles control password',
  36         'long': 'This mode is the second of two steps to change the password for a tile control character.  Enter the new password for the tile control character you chose.'
  37     },
  38     'control_tile_type': {
  39         'short': 'change tiles control',
  40         'long': 'This mode is the first of two steps to change tile control areas on the map.  First enter the tile control character you want to write.'
  41     },
  42     'control_tile_draw': {
  43         'short': 'change tiles control',
  44         'long': 'This mode is the second of two steps to change tile control areas on the map.  Move cursor around the map to draw selected tile control character'
  45     },
  46     'annotate': {
  47         'short': 'annotate tile',
  48         'long': 'This mode allows you to add/edit a comment on the tile you are currently standing on (provided your map editing password authorizes you so).  Hit Return to leave.'
  49     },
  50     'portal': {
  51         'short': 'edit portal',
  52         'long': 'This mode allows you to imprint/edit/remove a teleportation target on the ground you are currently standing on (provided your map 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.'
  53     },
  54     'chat': {
  55         'short': 'chat',
  56         '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:'
  57     },
  58     'login': {
  59         'short': 'login',
  60         'long': 'Pick your player name.'
  61     },
  62     'waiting_for_server': {
  63         'short': 'waiting for server response',
  64         'long': 'Waiting for a server response.'
  65     },
  66     'post_login_wait': {
  67         'short': 'waiting for server response',
  68         'long': 'Waiting for a server response.'
  69     },
  70     'password': {
  71         'short': 'map edit password',
  72         'long': 'This mode allows you to change the password that you send to authorize yourself for editing password-protected map tiles.  Hit return to confirm and leave.'
  73     },
  74     'admin_enter': {
  75         'short': 'become admin',
  76         'long': 'This mode allows you to become admin if you know an admin password.'
  77     },
  78     'admin': {
  79         'short': 'admin',
  80         'long': 'This mode allows you access to actions limited to administrators.'
  81     }
  82 }
  83
  84 from ws4py.client import WebSocketBaseClient
  85 class WebSocketClient(WebSocketBaseClient):
  86
  87     def __init__(self, recv_handler, *args, **kwargs):
  88         super().__init__(*args, **kwargs)
  89         self.recv_handler = recv_handler
  90         self.connect()
  91
  92     def received_message(self, message):
  93         if message.is_text:
  94             message = str(message)
  95             self.recv_handler(message)
  96
  97     @property
  98     def plom_closed(self):
  99         return self.client_terminated
 100
 101 from plomrogue.io_tcp import PlomSocket
 102 class PlomSocketClient(PlomSocket):
 103
 104     def __init__(self, recv_handler, url):
 105         import socket
 106         self.recv_handler = recv_handler
 107         host, port = url.split(':')
 108         super().__init__(socket.create_connection((host, port)))
 109
 110     def close(self):
 111         self.socket.close()
 112
 113     def run(self):
 114         import ssl
 115         try:
 116             for msg in self.recv():
 117                 if msg == 'NEED_SSL':
 118                     self.socket = ssl.wrap_socket(self.socket)
 119                     continue
 120                 self.recv_handler(msg)
 121         except BrokenSocketConnection:
 122             pass  # we assume socket will be known as dead by now
 123
 124 def cmd_TURN(game, n):
 125     game.info_db = {}
 126     game.info_hints = []
 127     game.turn = n
 128     game.things = []
 129     game.portals = {}
 130     game.turn_complete = False
 131 cmd_TURN.argtypes = 'int:nonneg'
 132
 133 def cmd_LOGIN_OK(game):
 134     game.tui.switch_mode('post_login_wait')
 135     game.tui.send('GET_GAMESTATE')
 136     game.tui.log_msg('@ welcome')
 137 cmd_LOGIN_OK.argtypes = ''
 138
 139 def cmd_ADMIN_OK(game):
 140     game.tui.is_admin = True
 141     game.tui.log_msg('@ you now have admin rights')
 142     game.tui.switch_mode('admin')
 143     game.tui.do_refresh = True
 144 cmd_ADMIN_OK.argtypes = ''
 145
 146 def cmd_CHAT(game, msg):
 147     game.tui.log_msg('# ' + msg)
 148     game.tui.do_refresh = True
 149 cmd_CHAT.argtypes = 'string'
 150
 151 def cmd_PLAYER_ID(game, player_id):
 152     game.player_id = player_id
 153 cmd_PLAYER_ID.argtypes = 'int:nonneg'
 154
 155 def cmd_THING(game, yx, thing_type, thing_id):
 156     t = game.get_thing(thing_id)
 157     if not t:
 158         t = ThingBase(game, thing_id)
 159         game.things += [t]
 160     t.position = yx
 161     t.type_ = thing_type
 162 cmd_THING.argtypes = 'yx_tuple:nonneg string:thing_type int:nonneg'
 163
 164 def cmd_THING_NAME(game, thing_id, name):
 165     t = game.get_thing(thing_id)
 166     if t:
 167         t.name = name
 168 cmd_THING_NAME.argtypes = 'int:nonneg string'
 169
 170 def cmd_THING_CHAR(game, thing_id, c):
 171     t = game.get_thing(thing_id)
 172     if t:
 173         t.player_char = c
 174 cmd_THING_CHAR.argtypes = 'int:nonneg char'
 175
 176 def cmd_MAP(game, geometry, size, content):
 177     map_geometry_class = globals()['MapGeometry' + geometry]
 178     game.map_geometry = map_geometry_class(size)
 179     game.map_content = content
 180     if type(game.map_geometry) == MapGeometrySquare:
 181         game.tui.movement_keys = {
 182             game.tui.keys['square_move_up']: 'UP',
 183             game.tui.keys['square_move_left']: 'LEFT',
 184             game.tui.keys['square_move_down']: 'DOWN',
 185             game.tui.keys['square_move_right']: 'RIGHT',
 186         }
 187     elif type(game.map_geometry) == MapGeometryHex:
 188         game.tui.movement_keys = {
 189             game.tui.keys['hex_move_upleft']: 'UPLEFT',
 190             game.tui.keys['hex_move_upright']: 'UPRIGHT',
 191             game.tui.keys['hex_move_right']: 'RIGHT',
 192             game.tui.keys['hex_move_downright']: 'DOWNRIGHT',
 193             game.tui.keys['hex_move_downleft']: 'DOWNLEFT',
 194             game.tui.keys['hex_move_left']: 'LEFT',
 195         }
 196 cmd_MAP.argtypes = 'string:map_geometry yx_tuple:pos string'
 197
 198 def cmd_FOV(game, content):
 199     game.fov = content
 200 cmd_FOV.argtypes = 'string'
 201
 202 def cmd_MAP_CONTROL(game, content):
 203     game.map_control_content = content
 204 cmd_MAP_CONTROL.argtypes = 'string'
 205
 206 def cmd_GAME_STATE_COMPLETE(game):
 207     if game.tui.mode.name == 'post_login_wait':
 208         game.tui.switch_mode('play')
 209     if game.tui.mode.shows_info:
 210         game.tui.query_info()
 211     game.turn_complete = True
 212     game.tui.do_refresh = True
 213 cmd_GAME_STATE_COMPLETE.argtypes = ''
 214
 215 def cmd_PORTAL(game, position, msg):
 216     game.portals[position] = msg
 217 cmd_PORTAL.argtypes = 'yx_tuple:nonneg string'
 218
 219 def cmd_PLAY_ERROR(game, msg):
 220     game.tui.log_msg('? ' + msg)
 221     game.tui.flash = True
 222     game.tui.do_refresh = True
 223 cmd_PLAY_ERROR.argtypes = 'string'
 224
 225 def cmd_GAME_ERROR(game, msg):
 226     game.tui.log_msg('? game error: ' + msg)
 227     game.tui.do_refresh = True
 228 cmd_GAME_ERROR.argtypes = 'string'
 229
 230 def cmd_ARGUMENT_ERROR(game, msg):
 231     game.tui.log_msg('? syntax error: ' + msg)
 232     game.tui.do_refresh = True
 233 cmd_ARGUMENT_ERROR.argtypes = 'string'
 234
 235 def cmd_ANNOTATION_HINT(game, position):
 236     game.info_hints += [position]
 237 cmd_ANNOTATION_HINT.argtypes = 'yx_tuple:nonneg'
 238
 239 def cmd_ANNOTATION(game, position, msg):
 240     game.info_db[position] = msg
 241     game.tui.restore_input_values()
 242     if game.tui.mode.shows_info:
 243         game.tui.do_refresh = True
 244 cmd_ANNOTATION.argtypes = 'yx_tuple:nonneg string'
 245
 246 def cmd_TASKS(game, tasks_comma_separated):
 247     game.tasks = tasks_comma_separated.split(',')
 248     game.tui.mode_write.legal = 'WRITE' in game.tasks
 249 cmd_TASKS.argtypes = 'string'
 250
 251 def cmd_THING_TYPE(game, thing_type, symbol_hint):
 252     game.thing_types[thing_type] = symbol_hint
 253 cmd_THING_TYPE.argtypes = 'string char'
 254
 255 def cmd_TERRAIN(game, terrain_char, terrain_desc):
 256     game.terrains[terrain_char] = terrain_desc
 257 cmd_TERRAIN.argtypes = 'char string'
 258
 259 def cmd_PONG(game):
 260     pass
 261 cmd_PONG.argtypes = ''
 262
 263 class Game(GameBase):
 264     turn_complete = False
 265     tasks = {}
 266     thing_types = {}
 267
 268     def __init__(self, *args, **kwargs):
 269         super().__init__(*args, **kwargs)
 270         self.register_command(cmd_LOGIN_OK)
 271         self.register_command(cmd_ADMIN_OK)
 272         self.register_command(cmd_PONG)
 273         self.register_command(cmd_CHAT)
 274         self.register_command(cmd_PLAYER_ID)
 275         self.register_command(cmd_TURN)
 276         self.register_command(cmd_THING)
 277         self.register_command(cmd_THING_TYPE)
 278         self.register_command(cmd_THING_NAME)
 279         self.register_command(cmd_THING_CHAR)
 280         self.register_command(cmd_TERRAIN)
 281         self.register_command(cmd_MAP)
 282         self.register_command(cmd_MAP_CONTROL)
 283         self.register_command(cmd_PORTAL)
 284         self.register_command(cmd_ANNOTATION)
 285         self.register_command(cmd_ANNOTATION_HINT)
 286         self.register_command(cmd_GAME_STATE_COMPLETE)
 287         self.register_command(cmd_ARGUMENT_ERROR)
 288         self.register_command(cmd_GAME_ERROR)
 289         self.register_command(cmd_PLAY_ERROR)
 290         self.register_command(cmd_TASKS)
 291         self.register_command(cmd_FOV)
 292         self.map_content = ''
 293         self.player_id = -1
 294         self.info_db = {}
 295         self.info_hints = []
 296         self.portals = {}
 297         self.terrains = {}
 298
 299     def get_string_options(self, string_option_type):
 300         if string_option_type == 'map_geometry':
 301             return ['Hex', 'Square']
 302         elif string_option_type == 'thing_type':
 303             return self.thing_types.keys()
 304         return None
 305
 306     def get_command(self, command_name):
 307         from functools import partial
 308         f = partial(self.commands[command_name], self)
 309         f.argtypes = self.commands[command_name].argtypes
 310         return f
 311
 312 class Mode:
 313
 314     def __init__(self, name, has_input_prompt=False, shows_info=False,
 315                  is_intro=False, is_single_char_entry=False):
 316         self.name = name
 317         self.short_desc = mode_helps[name]['short']
 318         self.available_modes = []
 319         self.has_input_prompt = has_input_prompt
 320         self.shows_info = shows_info
 321         self.is_intro = is_intro
 322         self.help_intro = mode_helps[name]['long']
 323         self.is_single_char_entry = is_single_char_entry
 324         self.legal = True
 325
 326     def iter_available_modes(self, tui):
 327         for mode_name in self.available_modes:
 328             mode = getattr(tui, 'mode_' + mode_name)
 329             if not mode.legal:
 330                 continue
 331             key = tui.keys['switch_to_' + mode.name]
 332             yield mode, key
 333
 334     def list_available_modes(self, tui):
 335         msg = ''
 336         if len(self.available_modes) > 0:
 337             msg = 'Other modes available from here:\n'
 338             for mode, key in self.iter_available_modes(tui):
 339                 msg += '[%s] – %s\n' % (key, mode.short_desc)
 340         return msg
 341
 342     def mode_switch_on_key(self, tui, key_pressed):
 343         for mode, key in self.iter_available_modes(tui):
 344             if key_pressed == key:
 345                 tui.switch_mode(mode.name)
 346                 return True
 347         return False
 348
 349 class TUI:
 350     mode_admin_enter = Mode('admin_enter', has_input_prompt=True)
 351     mode_admin = Mode('admin')
 352     mode_play = Mode('play')
 353     mode_study = Mode('study', shows_info=True)
 354     mode_write = Mode('write', is_single_char_entry=True)
 355     mode_edit = Mode('edit')
 356     mode_control_pw_type = Mode('control_pw_type', is_single_char_entry=True)
 357     mode_control_pw_pw = Mode('control_pw_pw', has_input_prompt=True)
 358     mode_control_tile_type = Mode('control_tile_type', is_single_char_entry=True)
 359     mode_control_tile_draw = Mode('control_tile_draw')
 360     mode_annotate = Mode('annotate', has_input_prompt=True, shows_info=True)
 361     mode_portal = Mode('portal', has_input_prompt=True, shows_info=True)
 362     mode_chat = Mode('chat', has_input_prompt=True)
 363     mode_waiting_for_server = Mode('waiting_for_server', is_intro=True)
 364     mode_login = Mode('login', has_input_prompt=True, is_intro=True)
 365     mode_post_login_wait = Mode('post_login_wait', is_intro=True)
 366     mode_password = Mode('password', has_input_prompt=True)
 367     is_admin = False
 368
 369     def __init__(self, host):
 370         import os
 371         import json
 372         self.mode_play.available_modes = ["chat", "study", "edit", "admin_enter"]
 373         self.mode_study.available_modes = ["chat", "play", "admin_enter", "edit"]
 374         self.mode_admin.available_modes = ["control_pw_type",
 375                                            "control_tile_type", "chat",
 376                                            "study", "play", "edit"]
 377         self.mode_control_tile_draw.available_modes = ["admin"]
 378         self.mode_edit.available_modes = ["write", "annotate", "portal",
 379                                           "password", "chat", "study", "play",
 380                                           "admin_enter"]
 381         self.host = host
 382         self.game = Game()
 383         self.game.tui = self
 384         self.parser = Parser(self.game)
 385         self.log = []
 386         self.do_refresh = True
 387         self.queue = queue.Queue()
 388         self.login_name = None
 389         self.map_mode = 'terrain'
 390         self.password = 'foo'
 391         self.switch_mode('waiting_for_server')
 392         self.keys = {
 393             'switch_to_chat': 't',
 394             'switch_to_play': 'p',
 395             'switch_to_password': 'P',
 396             'switch_to_annotate': 'M',
 397             'switch_to_portal': 'T',
 398             'switch_to_study': '?',
 399             'switch_to_edit': 'E',
 400             'switch_to_write': 'm',
 401             'switch_to_admin_enter': 'A',
 402             'switch_to_control_pw_type': 'C',
 403             'switch_to_control_tile_type': 'Q',
 404             'flatten': 'F',
 405             'take_thing': 'z',
 406             'drop_thing': 'u',
 407             'teleport': 'p',
 408             'help': 'h',
 409             'toggle_map_mode': 'M',
 410             'hex_move_upleft': 'w',
 411             'hex_move_upright': 'e',
 412             'hex_move_right': 'd',
 413             'hex_move_downright': 'x',
 414             'hex_move_downleft': 'y',
 415             'hex_move_left': 'a',
 416             'square_move_up': 'w',
 417             'square_move_left': 'a',
 418             'square_move_down': 's',
 419             'square_move_right': 'd',
 420         }
 421         if os.path.isfile('config.json'):
 422             with open('config.json', 'r') as f:
 423                 keys_conf = json.loads(f.read())
 424             for k in keys_conf:
 425                 self.keys[k] = keys_conf[k]
 426         self.show_help = False
 427         self.disconnected = True
 428         self.force_instant_connect = True
 429         self.input_lines = []
 430         self.fov = ''
 431         self.flash = False
 432         curses.wrapper(self.loop)
 433
 434     def connect(self):
 435
 436         def handle_recv(msg):
 437             if msg == 'BYE':
 438                 self.socket.close()
 439             else:
 440                 self.queue.put(msg)
 441
 442         self.log_msg('@ attempting connect')
 443         socket_client_class = PlomSocketClient
 444         if self.host.startswith('ws://') or self.host.startswith('wss://'):
 445             socket_client_class = WebSocketClient
 446         try:
 447             self.socket = socket_client_class(handle_recv, self.host)
 448             self.socket_thread = threading.Thread(target=self.socket.run)
 449             self.socket_thread.start()
 450             self.disconnected = False
 451             self.game.thing_types = {}
 452             self.game.terrains = {}
 453             self.socket.send('TASKS')
 454             self.socket.send('TERRAINS')
 455             self.socket.send('THING_TYPES')
 456             self.switch_mode('login')
 457         except ConnectionRefusedError:
 458             self.log_msg('@ server connect failure')
 459             self.disconnected = True
 460             self.switch_mode('waiting_for_server')
 461         self.do_refresh = True
 462
 463     def reconnect(self):
 464         self.log_msg('@ attempting reconnect')
 465         self.send('QUIT')
 466         time.sleep(0.1)  # FIXME necessitated by some some strange SSL race
 467                          # conditions with ws4py, find out what exactly
 468         self.switch_mode('waiting_for_server')
 469         self.connect()
 470
 471     def send(self, msg):
 472         try:
 473             if hasattr(self.socket, 'plom_closed') and self.socket.plom_closed:
 474                 raise BrokenSocketConnection
 475             self.socket.send(msg)
 476         except (BrokenPipeError, BrokenSocketConnection):
 477             self.log_msg('@ server disconnected :(')
 478             self.disconnected = True
 479             self.force_instant_connect = True
 480             self.do_refresh = True
 481
 482     def log_msg(self, msg):
 483         self.log += [msg]
 484         if len(self.log) > 100:
 485             self.log = self.log[-100:]
 486
 487     def query_info(self):
 488         self.send('GET_ANNOTATION ' + str(self.explorer))
 489
 490     def restore_input_values(self):
 491         if self.mode.name == 'annotate' and self.explorer in self.game.info_db:
 492             info = self.game.info_db[self.explorer]
 493             if info != '(none)':
 494                 self.input_ = info
 495         elif self.mode.name == 'portal' and self.explorer in self.game.portals:
 496             self.input_ = self.game.portals[self.explorer]
 497         elif self.mode.name == 'password':
 498             self.input_ = self.password
 499
 500     def send_tile_control_command(self):
 501         self.send('SET_TILE_CONTROL %s %s' %
 502                   (self.explorer, quote(self.tile_control_char)))
 503
 504     def switch_mode(self, mode_name):
 505         self.map_mode = 'terrain'
 506         if mode_name == 'admin_enter' and self.is_admin:
 507             mode_name = 'admin'
 508         self.mode = getattr(self, 'mode_' + mode_name)
 509         if self.mode.shows_info or self.mode.name == 'control_tile_draw':
 510             player = self.game.get_thing(self.game.player_id)
 511             self.explorer = YX(player.position.y, player.position.x)
 512             if self.mode.shows_info:
 513                 self.query_info()
 514             elif self.mode.name == 'control_tile_draw':
 515                 self.send_tile_control_command()
 516                 self.map_mode = 'control'
 517         if self.mode.is_single_char_entry:
 518             self.show_help = True
 519         if self.mode.name == 'waiting_for_server':
 520             self.log_msg('@ waiting for server …')
 521         elif self.mode.name == 'login':
 522             if self.login_name:
 523                 self.send('LOGIN ' + quote(self.login_name))
 524             else:
 525                 self.log_msg('@ enter username')
 526         elif self.mode.name == 'admin_enter':
 527             self.log_msg('@ enter admin password:')
 528         elif self.mode.name == 'control_pw_pw':
 529             self.log_msg('@ enter tile control password for "%s":' % self.tile_control_char)
 530         self.restore_input_values()
 531
 532     def loop(self, stdscr):
 533         import datetime
 534
 535         def safe_addstr(y, x, line):
 536             if y < self.size.y - 1 or x + len(line) < self.size.x:
 537                 stdscr.addstr(y, x, line)
 538             else:  # workaround to <https://stackoverflow.com/q/7063128>
 539                 cut_i = self.size.x - x - 1
 540                 cut = line[:cut_i]
 541                 last_char = line[cut_i]
 542                 stdscr.addstr(y, self.size.x - 2, last_char)
 543                 stdscr.insstr(y, self.size.x - 2, ' ')
 544                 stdscr.addstr(y, x, cut)
 545
 546         def handle_input(msg):
 547             command, args = self.parser.parse(msg)
 548             command(*args)
 549
 550         def msg_into_lines_of_width(msg, width):
 551             chunk = ''
 552             lines = []
 553             x = 0
 554             for i in range(len(msg)):
 555                 if x >= width or msg[i] == "\n":
 556                     lines += [chunk]
 557                     chunk = ''
 558                     x = 0
 559                     if msg[i] == "\n":
 560                         x -= 1
 561                 if msg[i] != "\n":
 562                     chunk += msg[i]
 563                 x += 1
 564             lines += [chunk]
 565             return lines
 566
 567         def reset_screen_size():
 568             self.size = YX(*stdscr.getmaxyx())
 569             self.size = self.size - YX(self.size.y % 4, 0)
 570             self.size = self.size - YX(0, self.size.x % 4)
 571             self.window_width = int(self.size.x / 2)
 572
 573         def recalc_input_lines():
 574             if not self.mode.has_input_prompt:
 575                 self.input_lines = []
 576             else:
 577                 self.input_lines = msg_into_lines_of_width(input_prompt + self.input_,
 578                                                            self.window_width)
 579
 580         def move_explorer(direction):
 581             target = self.game.map_geometry.move_yx(self.explorer, direction)
 582             if target:
 583                 self.explorer = target
 584                 if self.mode.shows_info:
 585                     self.query_info()
 586                 elif self.mode.name == 'control_tile_draw':
 587                     self.send_tile_control_command()
 588             else:
 589                 self.flash = True
 590
 591         def draw_history():
 592             lines = []
 593             for line in self.log:
 594                 lines += msg_into_lines_of_width(line, self.window_width)
 595             lines.reverse()
 596             height_header = 2
 597             max_y = self.size.y - len(self.input_lines)
 598             for i in range(len(lines)):
 599                 if (i >= max_y - height_header):
 600                     break
 601                 safe_addstr(max_y - i - 1, self.window_width, lines[i])
 602
 603         def draw_info():
 604             if not self.game.turn_complete:
 605                 return
 606             pos_i = self.explorer.y * self.game.map_geometry.size.x + self.explorer.x
 607             info = 'outside field of view'
 608             if self.game.fov[pos_i] == '.':
 609                 terrain_char = self.game.map_content[pos_i]
 610                 terrain_desc = '?'
 611                 if terrain_char in self.game.terrains:
 612                     terrain_desc = self.game.terrains[terrain_char]
 613                 info = 'TERRAIN: "%s" / %s\n' % (terrain_char, terrain_desc)
 614                 protection = self.game.map_control_content[pos_i]
 615                 if protection == '.':
 616                     protection = 'unprotected'
 617                 info = 'PROTECTION: %s\n' % protection
 618                 for t in self.game.things:
 619                     if t.position == self.explorer:
 620                         info += 'THING: %s / %s' % (t.type_,
 621                                                     self.game.thing_types[t.type_])
 622                         if hasattr(t, 'player_char'):
 623                             info += t.player_char
 624                         if hasattr(t, 'name'):
 625                             info += ' (%s)' % t.name
 626                         info += '\n'
 627                 if self.explorer in self.game.portals:
 628                     info += 'PORTAL: ' + self.game.portals[self.explorer] + '\n'
 629                 else:
 630                     info += 'PORTAL: (none)\n'
 631                 if self.explorer in self.game.info_db:
 632                     info += 'ANNOTATION: ' + self.game.info_db[self.explorer]
 633                 else:
 634                     info += 'ANNOTATION: waiting …'
 635             lines = msg_into_lines_of_width(info, self.window_width)
 636             height_header = 2
 637             for i in range(len(lines)):
 638                 y = height_header + i
 639                 if y >= self.size.y - len(self.input_lines):
 640                     break
 641                 safe_addstr(y, self.window_width, lines[i])
 642
 643         def draw_input():
 644             y = self.size.y - len(self.input_lines)
 645             for i in range(len(self.input_lines)):
 646                 safe_addstr(y, self.window_width, self.input_lines[i])
 647                 y += 1
 648
 649         def draw_turn():
 650             if not self.game.turn_complete:
 651                 return
 652             safe_addstr(0, self.window_width, 'TURN: ' + str(self.game.turn))
 653
 654         def draw_mode():
 655             help = "hit [%s] for help" % self.keys['help']
 656             if self.mode.has_input_prompt:
 657                 help = "enter /help for help"
 658             safe_addstr(1, self.window_width,
 659                         'MODE: %s – %s' % (self.mode.short_desc, help))
 660
 661         def draw_map():
 662             if not self.game.turn_complete:
 663                 return
 664             map_lines_split = []
 665             map_content = self.game.map_content
 666             if self.map_mode == 'control':
 667                 map_content = self.game.map_control_content
 668             for y in range(self.game.map_geometry.size.y):
 669                 start = self.game.map_geometry.size.x * y
 670                 end = start + self.game.map_geometry.size.x
 671                 map_lines_split += [[c + ' ' for c in map_content[start:end]]]
 672             if self.map_mode == 'annotations':
 673                 for p in self.game.info_hints:
 674                     map_lines_split[p.y][p.x] = 'A '
 675             elif self.map_mode == 'terrain':
 676                 for p in self.game.portals.keys():
 677                     original = map_lines_split[p.y][p.x]
 678                     map_lines_split[p.y][p.x] = original[0] + 'P'
 679                 used_positions = []
 680                 for t in self.game.things:
 681                     symbol = self.game.thing_types[t.type_]
 682                     meta_char = ' '
 683                     if hasattr(t, 'player_char'):
 684                         meta_char = t.player_char
 685                     if t.position in used_positions:
 686                         meta_char = '+'
 687                     map_lines_split[t.position.y][t.position.x] = symbol + meta_char
 688                     used_positions += [t.position]
 689             if self.mode.shows_info or self.mode.name == 'control_tile_draw':
 690                 map_lines_split[self.explorer.y][self.explorer.x] = '??'
 691             map_lines = []
 692             if type(self.game.map_geometry) == MapGeometryHex:
 693                 indent = 0
 694                 for line in map_lines_split:
 695                     map_lines += [indent*' ' + ''.join(line)]
 696                     indent = 0 if indent else 1
 697             else:
 698                 for line in map_lines_split:
 699                     map_lines += [''.join(line)]
 700             window_center = YX(int(self.size.y / 2),
 701                                int(self.window_width / 2))
 702             player = self.game.get_thing(self.game.player_id)
 703             center = player.position
 704             if self.mode.shows_info:
 705                 center = self.explorer
 706             center = YX(center.y, center.x * 2)
 707             offset = center - window_center
 708             if type(self.game.map_geometry) == MapGeometryHex and offset.y % 2:
 709                 offset += YX(0, 1)
 710             term_y = max(0, -offset.y)
 711             term_x = max(0, -offset.x)
 712             map_y = max(0, offset.y)
 713             map_x = max(0, offset.x)
 714             while (term_y < self.size.y and map_y < self.game.map_geometry.size.y):
 715                 to_draw = map_lines[map_y][map_x:self.window_width + offset.x]
 716                 safe_addstr(term_y, term_x, to_draw)
 717                 term_y += 1
 718                 map_y += 1
 719
 720         def draw_help():
 721             content = "%s help\n\n%s\n\n" % (self.mode.short_desc,
 722                                              self.mode.help_intro)
 723             if self.mode.name == 'play':
 724                 content += "Available actions:\n"
 725                 if 'MOVE' in self.game.tasks:
 726                     content += "[%s] – move player\n" % ','.join(self.movement_keys)
 727                 if 'PICK_UP' in self.game.tasks:
 728                     content += "[%s] – pick up thing\n" % self.keys['take_thing']
 729                 if 'DROP' in self.game.tasks:
 730                     content += "[%s] – drop picked up thing\n" % self.keys['drop_thing']
 731                 content += '[%s] – teleport to other space\n' % self.keys['teleport']
 732                 content += '\n'
 733             elif self.mode.name == 'study':
 734                 content += 'Available actions:\n'
 735                 content += '[%s] – move question mark\n' % ','.join(self.movement_keys)
 736                 content += '[%s] – toggle view between terrain, annotations, and password protection areas\n' % self.keys['toggle_map_mode']
 737                 content += '\n'
 738             elif self.mode.name == 'edit':
 739                 content += "Available actions:\n"
 740                 if 'FLATTEN_SURROUNDINGS' in self.game.tasks:
 741                     content += "[%s] – flatten player's surroundings\n" % self.keys['flatten']
 742                 content += '\n'
 743             elif self.mode.name == 'chat':
 744                 content += '/nick NAME – re-name yourself to NAME\n'
 745                 content += '/%s or /play – switch to play mode\n' % self.keys['switch_to_play']
 746                 content += '/%s or /study – switch to study mode\n' % self.keys['switch_to_study']
 747                 content += '/%s or /edit – switch to map edit mode\n' % self.keys['switch_to_edit']
 748                 content += '/%s or /admin – switch to admin mode\n' % self.keys['switch_to_admin_enter']
 749             content += self.mode.list_available_modes(self)
 750             for i in range(self.size.y):
 751                 safe_addstr(i,
 752                             self.window_width * (not self.mode.has_input_prompt),
 753                             ' '*self.window_width)
 754             lines = []
 755             for line in content.split('\n'):
 756                 lines += msg_into_lines_of_width(line, self.window_width)
 757             for i in range(len(lines)):
 758                 if i >= self.size.y:
 759                     break
 760                 safe_addstr(i,
 761                             self.window_width * (not self.mode.has_input_prompt),
 762                             lines[i])
 763
 764         def draw_screen():
 765             stdscr.clear()
 766             if self.mode.has_input_prompt:
 767                 recalc_input_lines()
 768                 draw_input()
 769             if self.mode.shows_info:
 770                 draw_info()
 771             else:
 772                 draw_history()
 773             draw_mode()
 774             if not self.mode.is_intro:
 775                 draw_turn()
 776                 draw_map()
 777             if self.show_help:
 778                 draw_help()
 779
 780         curses.curs_set(False)  # hide cursor
 781         curses.use_default_colors();
 782         stdscr.timeout(10)
 783         reset_screen_size()
 784         self.explorer = YX(0, 0)
 785         self.input_ = ''
 786         input_prompt = '> '
 787         interval = datetime.timedelta(seconds=5)
 788         last_ping = datetime.datetime.now() - interval
 789         while True:
 790             if self.disconnected and self.force_instant_connect:
 791                 self.force_instant_connect = False
 792                 self.connect()
 793             now = datetime.datetime.now()
 794             if now - last_ping > interval:
 795                 if self.disconnected:
 796                     self.connect()
 797                 else:
 798                     self.send('PING')
 799                 last_ping = now
 800             if self.flash:
 801                 curses.flash()
 802                 self.flash = False
 803             if self.do_refresh:
 804                 draw_screen()
 805                 self.do_refresh = False
 806             while True:
 807                 try:
 808                     msg = self.queue.get(block=False)
 809                     handle_input(msg)
 810                 except queue.Empty:
 811                     break
 812             try:
 813                 key = stdscr.getkey()
 814                 self.do_refresh = True
 815             except curses.error:
 816                 continue
 817             self.show_help = False
 818             if key == 'KEY_RESIZE':
 819                 reset_screen_size()
 820             elif self.mode.has_input_prompt and key == 'KEY_BACKSPACE':
 821                 self.input_ = self.input_[:-1]
 822             elif self.mode.has_input_prompt and key == '\n' and self.input_ == '/help':
 823                 self.show_help = True
 824                 self.input_ = ""
 825                 self.restore_input_values()
 826             elif self.mode.has_input_prompt and key != '\n':  # Return key
 827                 self.input_ += key
 828                 max_length = self.window_width * self.size.y - len(input_prompt) - 1
 829                 if len(self.input_) > max_length:
 830                     self.input_ = self.input_[:max_length]
 831             elif key == self.keys['help'] and not self.mode.is_single_char_entry:
 832                 self.show_help = True
 833             elif self.mode.name == 'login' and key == '\n':
 834                 self.login_name = self.input_
 835                 self.send('LOGIN ' + quote(self.input_))
 836                 self.input_ = ""
 837             elif self.mode.name == 'control_pw_pw' and key == '\n':
 838                 if self.input_ == '':
 839                     self.log_msg('@ aborted')
 840                 else:
 841                     self.send('SET_MAP_CONTROL_PASSWORD ' + quote(self.tile_control_char) + ' ' + quote(self.input_))
 842                     self.input_ = ""
 843                 self.switch_mode('admin')
 844             elif self.mode.name == 'password' and key == '\n':
 845                 if self.input_ == '':
 846                     self.input_ = ' '
 847                 self.password = self.input_
 848                 self.input_ = ""
 849                 self.switch_mode('edit')
 850             elif self.mode.name == 'admin_enter' and key == '\n':
 851                 self.send('BECOME_ADMIN ' + quote(self.input_))
 852                 self.input_ = ""
 853                 self.switch_mode('play')
 854             elif self.mode.name == 'chat' and key == '\n':
 855                 if self.input_ == '':
 856                     continue
 857                 if self.input_[0] == '/':  # FIXME fails on empty input
 858                     if self.input_ in {'/' + self.keys['switch_to_play'], '/play'}:
 859                         self.switch_mode('play')
 860                     elif self.input_ in {'/' + self.keys['switch_to_study'], '/study'}:
 861                         self.switch_mode('study')
 862                     elif self.input_ in {'/' + self.keys['switch_to_edit'], '/edit'}:
 863                         self.switch_mode('edit')
 864                     elif self.input_ in {'/' + self.keys['switch_to_admin_enter'], '/admin'}:
 865                         self.switch_mode('admin_enter')
 866                     elif self.input_.startswith('/nick'):
 867                         tokens = self.input_.split(maxsplit=1)
 868                         if len(tokens) == 2:
 869                             self.send('NICK ' + quote(tokens[1]))
 870                         else:
 871                             self.log_msg('? need login name')
 872                     else:
 873                         self.log_msg('? unknown command')
 874                 else:
 875                     self.send('ALL ' + quote(self.input_))
 876                 self.input_ = ""
 877             elif self.mode.name == 'annotate' and key == '\n':
 878                 if self.input_ == '':
 879                     self.input_ = ' '
 880                 self.send('ANNOTATE %s %s %s' % (self.explorer, quote(self.input_),
 881                                                  quote(self.password)))
 882                 self.input_ = ""
 883                 self.switch_mode('edit')
 884             elif self.mode.name == 'portal' and key == '\n':
 885                 if self.input_ == '':
 886                     self.input_ = ' '
 887                 self.send('PORTAL %s %s %s' % (self.explorer, quote(self.input_),
 888                                                quote(self.password)))
 889                 self.input_ = ""
 890                 self.switch_mode('edit')
 891             elif self.mode.name == 'study':
 892                 if self.mode.mode_switch_on_key(self, key):
 893                     continue
 894                 elif key == self.keys['toggle_map_mode']:
 895                     if self.map_mode == 'terrain':
 896                         self.map_mode = 'annotations'
 897                     elif self.map_mode == 'annotations':
 898                         self.map_mode = 'control'
 899                     else:
 900                         self.map_mode = 'terrain'
 901                 elif key in self.movement_keys:
 902                     move_explorer(self.movement_keys[key])
 903             elif self.mode.name == 'play':
 904                 if self.mode.mode_switch_on_key(self, key):
 905                     continue
 906                 elif key == self.keys['take_thing'] and 'PICK_UP' in self.game.tasks:
 907                     self.send('TASK:PICK_UP')
 908                 elif key == self.keys['drop_thing'] and 'DROP' in self.game.tasks:
 909                     self.send('TASK:DROP')
 910                 elif key == self.keys['teleport']:
 911                     player = self.game.get_thing(self.game.player_id)
 912                     if player.position in self.game.portals:
 913                         self.host = self.game.portals[player.position]
 914                         self.reconnect()
 915                     else:
 916                         self.flash = True
 917                         self.log_msg('? not standing on portal')
 918                 elif key in self.movement_keys and 'MOVE' in self.game.tasks:
 919                     self.send('TASK:MOVE ' + self.movement_keys[key])
 920             elif self.mode.name == 'write':
 921                 self.send('TASK:WRITE %s %s' % (key, quote(self.password)))
 922                 self.switch_mode('edit')
 923             elif self.mode.name == 'control_pw_type':
 924                 self.tile_control_char = key
 925                 self.switch_mode('control_pw_pw')
 926             elif self.mode.name == 'control_tile_type':
 927                 self.tile_control_char = key
 928                 self.switch_mode('control_tile_draw')
 929             elif self.mode.name == 'control_tile_draw':
 930                 if self.mode.mode_switch_on_key(self, key):
 931                     continue
 932                 elif key in self.movement_keys:
 933                     move_explorer(self.movement_keys[key])
 934             elif self.mode.name == 'admin':
 935                 if self.mode.mode_switch_on_key(self, key):
 936                     continue
 937             elif self.mode.name == 'edit':
 938                 if self.mode.mode_switch_on_key(self, key):
 939                     continue
 940                 if key == self.keys['flatten'] and\
 941                      'FLATTEN_SURROUNDINGS' in self.game.tasks:
 942                     self.send('TASK:FLATTEN_SURROUNDINGS ' + quote(self.password))
 943                 elif key in self.movement_keys and 'MOVE' in self.game.tasks:
 944                     self.send('TASK:MOVE ' + self.movement_keys[key])
 945
 946 if len(sys.argv) != 2:
 947     raise ArgError('wrong number of arguments, need game host')
 948 host = sys.argv[1]
 949 TUI(host)