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                     map_lines_split[p.y][p.x] = 'P '
 678                 used_positions = []
 679                 for t in self.game.things:
 680                     symbol = self.game.thing_types[t.type_]
 681                     meta_char = ' '
 682                     if hasattr(t, 'player_char'):
 683                         meta_char = t.player_char
 684                     if t.position in used_positions:
 685                         meta_char = '+'
 686                     map_lines_split[t.position.y][t.position.x] = symbol + meta_char
 687                     used_positions += [t.position]
 688             if self.mode.shows_info or self.mode.name == 'control_tile_draw':
 689                 map_lines_split[self.explorer.y][self.explorer.x] = '??'
 690             map_lines = []
 691             if type(self.game.map_geometry) == MapGeometryHex:
 692                 indent = 0
 693                 for line in map_lines_split:
 694                     map_lines += [indent*' ' + ''.join(line)]
 695                     indent = 0 if indent else 1
 696             else:
 697                 for line in map_lines_split:
 698                     map_lines += [''.join(line)]
 699             window_center = YX(int(self.size.y / 2),
 700                                int(self.window_width / 2))
 701             player = self.game.get_thing(self.game.player_id)
 702             center = player.position
 703             if self.mode.shows_info:
 704                 center = self.explorer
 705             center = YX(center.y, center.x * 2)
 706             offset = center - window_center
 707             if type(self.game.map_geometry) == MapGeometryHex and offset.y % 2:
 708                 offset += YX(0, 1)
 709             term_y = max(0, -offset.y)
 710             term_x = max(0, -offset.x)
 711             map_y = max(0, offset.y)
 712             map_x = max(0, offset.x)
 713             while (term_y < self.size.y and map_y < self.game.map_geometry.size.y):
 714                 to_draw = map_lines[map_y][map_x:self.window_width + offset.x]
 715                 safe_addstr(term_y, term_x, to_draw)
 716                 term_y += 1
 717                 map_y += 1
 718
 719         def draw_help():
 720             content = "%s help\n\n%s\n\n" % (self.mode.short_desc,
 721                                              self.mode.help_intro)
 722             if self.mode.name == 'play':
 723                 content += "Available actions:\n"
 724                 if 'MOVE' in self.game.tasks:
 725                     content += "[%s] – move player\n" % ','.join(self.movement_keys)
 726                 if 'PICK_UP' in self.game.tasks:
 727                     content += "[%s] – take thing under player\n" % self.keys['take_thing']
 728                 if 'DROP' in self.game.tasks:
 729                     content += "[%s] – drop carried thing\n" % self.keys['drop_thing']
 730                 content += '[%s] – teleport to other space\n' % self.keys['teleport']
 731                 content += '\n'
 732             elif self.mode.name == 'study':
 733                 content += 'Available actions:\n'
 734                 content += '[%s] – move question mark\n' % ','.join(self.movement_keys)
 735                 content += '[%s] – toggle view between terrain, annotations, and password protection areas\n' % self.keys['toggle_map_mode']
 736                 content += '\n'
 737             elif self.mode.name == 'edit':
 738                 content += "Available actions:\n"
 739                 if 'FLATTEN_SURROUNDINGS' in self.game.tasks:
 740                     content += "[%s] – flatten player's surroundings\n" % self.keys['flatten']
 741                 content += '\n'
 742             elif self.mode.name == 'chat':
 743                 content += '/nick NAME – re-name yourself to NAME\n'
 744                 content += '/%s or /play – switch to play mode\n' % self.keys['switch_to_play']
 745                 content += '/%s or /study – switch to study mode\n' % self.keys['switch_to_study']
 746                 content += '/%s or /edit – switch to map edit mode\n' % self.keys['switch_to_edit']
 747                 content += '/%s or /admin – switch to admin mode\n' % self.keys['switch_to_admin_enter']
 748             content += self.mode.list_available_modes(self)
 749             for i in range(self.size.y):
 750                 safe_addstr(i,
 751                             self.window_width * (not self.mode.has_input_prompt),
 752                             ' '*self.window_width)
 753             lines = []
 754             for line in content.split('\n'):
 755                 lines += msg_into_lines_of_width(line, self.window_width)
 756             for i in range(len(lines)):
 757                 if i >= self.size.y:
 758                     break
 759                 safe_addstr(i,
 760                             self.window_width * (not self.mode.has_input_prompt),
 761                             lines[i])
 762
 763         def draw_screen():
 764             stdscr.clear()
 765             if self.mode.has_input_prompt:
 766                 recalc_input_lines()
 767                 draw_input()
 768             if self.mode.shows_info:
 769                 draw_info()
 770             else:
 771                 draw_history()
 772             draw_mode()
 773             if not self.mode.is_intro:
 774                 draw_turn()
 775                 draw_map()
 776             if self.show_help:
 777                 draw_help()
 778
 779         curses.curs_set(False)  # hide cursor
 780         curses.use_default_colors();
 781         stdscr.timeout(10)
 782         reset_screen_size()
 783         self.explorer = YX(0, 0)
 784         self.input_ = ''
 785         input_prompt = '> '
 786         interval = datetime.timedelta(seconds=5)
 787         last_ping = datetime.datetime.now() - interval
 788         while True:
 789             if self.disconnected and self.force_instant_connect:
 790                 self.force_instant_connect = False
 791                 self.connect()
 792             now = datetime.datetime.now()
 793             if now - last_ping > interval:
 794                 if self.disconnected:
 795                     self.connect()
 796                 else:
 797                     self.send('PING')
 798                 last_ping = now
 799             if self.flash:
 800                 curses.flash()
 801                 self.flash = False
 802             if self.do_refresh:
 803                 draw_screen()
 804                 self.do_refresh = False
 805             while True:
 806                 try:
 807                     msg = self.queue.get(block=False)
 808                     handle_input(msg)
 809                 except queue.Empty:
 810                     break
 811             try:
 812                 key = stdscr.getkey()
 813                 self.do_refresh = True
 814             except curses.error:
 815                 continue
 816             self.show_help = False
 817             if key == 'KEY_RESIZE':
 818                 reset_screen_size()
 819             elif self.mode.has_input_prompt and key == 'KEY_BACKSPACE':
 820                 self.input_ = self.input_[:-1]
 821             elif self.mode.has_input_prompt and key == '\n' and self.input_ == '/help':
 822                 self.show_help = True
 823                 self.input_ = ""
 824                 self.restore_input_values()
 825             elif self.mode.has_input_prompt and key != '\n':  # Return key
 826                 self.input_ += key
 827                 max_length = self.window_width * self.size.y - len(input_prompt) - 1
 828                 if len(self.input_) > max_length:
 829                     self.input_ = self.input_[:max_length]
 830             elif key == self.keys['help'] and not self.mode.is_single_char_entry:
 831                 self.show_help = True
 832             elif self.mode.name == 'login' and key == '\n':
 833                 self.login_name = self.input_
 834                 self.send('LOGIN ' + quote(self.input_))
 835                 self.input_ = ""
 836             elif self.mode.name == 'control_pw_pw' and key == '\n':
 837                 if self.input_ == '':
 838                     self.log_msg('@ aborted')
 839                 else:
 840                     self.send('SET_MAP_CONTROL_PASSWORD ' + quote(self.tile_control_char) + ' ' + quote(self.input_))
 841                     self.input_ = ""
 842                 self.switch_mode('admin')
 843             elif self.mode.name == 'password' and key == '\n':
 844                 if self.input_ == '':
 845                     self.input_ = ' '
 846                 self.password = self.input_
 847                 self.input_ = ""
 848                 self.switch_mode('edit')
 849             elif self.mode.name == 'admin_enter' and key == '\n':
 850                 self.send('BECOME_ADMIN ' + quote(self.input_))
 851                 self.input_ = ""
 852                 self.switch_mode('play')
 853             elif self.mode.name == 'chat' and key == '\n':
 854                 if self.input_ == '':
 855                     continue
 856                 if self.input_[0] == '/':  # FIXME fails on empty input
 857                     if self.input_ in {'/' + self.keys['switch_to_play'], '/play'}:
 858                         self.switch_mode('play')
 859                     elif self.input_ in {'/' + self.keys['switch_to_study'], '/study'}:
 860                         self.switch_mode('study')
 861                     elif self.input_ in {'/' + self.keys['switch_to_edit'], '/edit'}:
 862                         self.switch_mode('edit')
 863                     elif self.input_ in {'/' + self.keys['switch_to_admin_enter'], '/admin'}:
 864                         self.switch_mode('admin_enter')
 865                     elif self.input_.startswith('/nick'):
 866                         tokens = self.input_.split(maxsplit=1)
 867                         if len(tokens) == 2:
 868                             self.send('NICK ' + quote(tokens[1]))
 869                         else:
 870                             self.log_msg('? need login name')
 871                     else:
 872                         self.log_msg('? unknown command')
 873                 else:
 874                     self.send('ALL ' + quote(self.input_))
 875                 self.input_ = ""
 876             elif self.mode.name == 'annotate' and key == '\n':
 877                 if self.input_ == '':
 878                     self.input_ = ' '
 879                 self.send('ANNOTATE %s %s %s' % (self.explorer, quote(self.input_),
 880                                                  quote(self.password)))
 881                 self.input_ = ""
 882                 self.switch_mode('edit')
 883             elif self.mode.name == 'portal' and key == '\n':
 884                 if self.input_ == '':
 885                     self.input_ = ' '
 886                 self.send('PORTAL %s %s %s' % (self.explorer, quote(self.input_),
 887                                                quote(self.password)))
 888                 self.input_ = ""
 889                 self.switch_mode('edit')
 890             elif self.mode.name == 'study':
 891                 if self.mode.mode_switch_on_key(self, key):
 892                     continue
 893                 elif key == self.keys['toggle_map_mode']:
 894                     if self.map_mode == 'terrain':
 895                         self.map_mode = 'annotations'
 896                     elif self.map_mode == 'annotations':
 897                         self.map_mode = 'control'
 898                     else:
 899                         self.map_mode = 'terrain'
 900                 elif key in self.movement_keys:
 901                     move_explorer(self.movement_keys[key])
 902             elif self.mode.name == 'play':
 903                 if self.mode.mode_switch_on_key(self, key):
 904                     continue
 905                 elif key == self.keys['take_thing'] and 'PICK_UP' in self.game.tasks:
 906                     self.send('TASK:PICK_UP')
 907                 elif key == self.keys['drop_thing'] and 'DROP' in self.game.tasks:
 908                     self.send('TASK:DROP')
 909                 elif key == self.keys['teleport']:
 910                     player = self.game.get_thing(self.game.player_id)
 911                     if player.position in self.game.portals:
 912                         self.host = self.game.portals[player.position]
 913                         self.reconnect()
 914                     else:
 915                         self.flash = True
 916                         self.log_msg('? not standing on portal')
 917                 elif key in self.movement_keys and 'MOVE' in self.game.tasks:
 918                     self.send('TASK:MOVE ' + self.movement_keys[key])
 919             elif self.mode.name == 'write':
 920                 self.send('TASK:WRITE %s %s' % (key, quote(self.password)))
 921                 self.switch_mode('edit')
 922             elif self.mode.name == 'control_pw_type':
 923                 self.tile_control_char = key
 924                 self.switch_mode('control_pw_pw')
 925             elif self.mode.name == 'control_tile_type':
 926                 self.tile_control_char = key
 927                 self.switch_mode('control_tile_draw')
 928             elif self.mode.name == 'control_tile_draw':
 929                 if self.mode.mode_switch_on_key(self, key):
 930                     continue
 931                 elif key in self.movement_keys:
 932                     move_explorer(self.movement_keys[key])
 933             elif self.mode.name == 'admin':
 934                 if self.mode.mode_switch_on_key(self, key):
 935                     continue
 936             elif self.mode.name == 'edit':
 937                 if self.mode.mode_switch_on_key(self, key):
 938                     continue
 939                 if key == self.keys['flatten'] and\
 940                      'FLATTEN_SURROUNDINGS' in self.game.tasks:
 941                     self.send('TASK:FLATTEN_SURROUNDINGS ' + quote(self.password))
 942                 elif key in self.movement_keys and 'MOVE' in self.game.tasks:
 943                     self.send('TASK:MOVE ' + self.movement_keys[key])
 944
 945 if len(sys.argv) != 2:
 946     raise ArgError('wrong number of arguments, need game host')
 947 host = sys.argv[1]
 948 TUI(host)