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