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