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
17 'long': 'This mode allows you to interact with the map.'
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.'},
24 'long': 'This mode allows you to change the map in various ways.'
27 'short': 'terrain write',
28 'long': 'This mode allows you to change the map tile you currently stand on (if your map editing password authorizes you so). Just enter any printable ASCII character to imprint it on the ground below you.'
31 'short': 'change tiles control password',
32 'long': 'This mode is the first of two steps to change the password for a tile control character. First enter the tile control character for which you want to change the password.'
35 'short': 'change tiles control password',
36 'long': 'This mode is the second of two steps to change the password for a tile control character. Enter the new password for the tile control character you chose.'
38 'control_tile_type': {
39 'short': 'change tiles control',
40 'long': 'This mode is the first of two steps to change tile control areas on the map. First enter the tile control character you want to write.'
42 'control_tile_draw': {
43 'short': 'change tiles control',
44 'long': 'This mode is the second of two steps to change tile control areas on the map. Toggle tile control drawing on, then move cursor around the map to draw selected tile control character.'
47 'short': 'annotate tile',
48 'long': 'This mode allows you to add/edit a comment on the tile you are currently standing on (provided your map editing password authorizes you so). Hit Return to leave.'
51 'short': 'edit portal',
52 'long': 'This mode allows you to imprint/edit/remove a teleportation target on the ground you are currently standing on (provided your map editing password authorizes you so). Enter or edit a URL to imprint a teleportation target; enter emptiness to remove a pre-existing teleportation target. Hit Return to leave.'
56 'long': 'This mode allows you to engage in chit-chat with other users. Any line you enter into the input prompt that does not start with a "/" will be sent out to nearby players – but barriers and distance will reduce what they can read, so stand close to them to ensure they get your message. Lines that start with a "/" are used for commands like:'
60 'long': 'Pick your player name.'
62 'waiting_for_server': {
63 'short': 'waiting for server response',
64 'long': 'Waiting for a server response.'
67 'short': 'waiting for server response',
68 'long': 'Waiting for a server response.'
71 'short': 'map edit password',
72 'long': 'This mode allows you to change the password that you send to authorize yourself for editing password-protected map tiles. Hit return to confirm and leave.'
75 'short': 'become admin',
76 'long': 'This mode allows you to become admin if you know an admin password.'
80 'long': 'This mode allows you access to actions limited to administrators.'
84 from ws4py.client import WebSocketBaseClient
85 class WebSocketClient(WebSocketBaseClient):
87 def __init__(self, recv_handler, *args, **kwargs):
88 super().__init__(*args, **kwargs)
89 self.recv_handler = recv_handler
92 def received_message(self, message):
94 message = str(message)
95 self.recv_handler(message)
98 def plom_closed(self):
99 return self.client_terminated
101 from plomrogue.io_tcp import PlomSocket
102 class PlomSocketClient(PlomSocket):
104 def __init__(self, recv_handler, url):
106 self.recv_handler = recv_handler
107 host, port = url.split(':')
108 super().__init__(socket.create_connection((host, port)))
116 for msg in self.recv():
117 if msg == 'NEED_SSL':
118 self.socket = ssl.wrap_socket(self.socket)
120 self.recv_handler(msg)
121 except BrokenSocketConnection:
122 pass # we assume socket will be known as dead by now
124 def cmd_TURN(game, n):
130 game.turn_complete = False
131 cmd_TURN.argtypes = 'int:nonneg'
133 def cmd_LOGIN_OK(game):
134 game.tui.switch_mode('post_login_wait')
135 game.tui.send('GET_GAMESTATE')
136 game.tui.log_msg('@ welcome')
137 cmd_LOGIN_OK.argtypes = ''
139 def cmd_ADMIN_OK(game):
140 game.tui.is_admin = True
141 game.tui.log_msg('@ you now have admin rights')
142 game.tui.switch_mode('admin')
143 game.tui.do_refresh = True
144 cmd_ADMIN_OK.argtypes = ''
146 def cmd_CHAT(game, msg):
147 game.tui.log_msg('# ' + msg)
148 game.tui.do_refresh = True
149 cmd_CHAT.argtypes = 'string'
151 def cmd_PLAYER_ID(game, player_id):
152 game.player_id = player_id
153 cmd_PLAYER_ID.argtypes = 'int:nonneg'
155 def cmd_THING(game, yx, thing_type, thing_id):
156 t = game.get_thing(thing_id)
158 t = ThingBase(game, thing_id)
162 cmd_THING.argtypes = 'yx_tuple:nonneg string:thing_type int:nonneg'
164 def cmd_THING_NAME(game, thing_id, name):
165 t = game.get_thing(thing_id)
168 cmd_THING_NAME.argtypes = 'int:nonneg string'
170 def cmd_THING_CHAR(game, thing_id, c):
171 t = game.get_thing(thing_id)
174 cmd_THING_CHAR.argtypes = 'int:nonneg char'
176 def cmd_MAP(game, geometry, size, content):
177 map_geometry_class = globals()['MapGeometry' + geometry]
178 game.map_geometry = map_geometry_class(size)
179 game.map_content = content
180 if type(game.map_geometry) == MapGeometrySquare:
181 game.tui.movement_keys = {
182 game.tui.keys['square_move_up']: 'UP',
183 game.tui.keys['square_move_left']: 'LEFT',
184 game.tui.keys['square_move_down']: 'DOWN',
185 game.tui.keys['square_move_right']: 'RIGHT',
187 elif type(game.map_geometry) == MapGeometryHex:
188 game.tui.movement_keys = {
189 game.tui.keys['hex_move_upleft']: 'UPLEFT',
190 game.tui.keys['hex_move_upright']: 'UPRIGHT',
191 game.tui.keys['hex_move_right']: 'RIGHT',
192 game.tui.keys['hex_move_downright']: 'DOWNRIGHT',
193 game.tui.keys['hex_move_downleft']: 'DOWNLEFT',
194 game.tui.keys['hex_move_left']: 'LEFT',
196 cmd_MAP.argtypes = 'string:map_geometry yx_tuple:pos string'
198 def cmd_FOV(game, content):
200 cmd_FOV.argtypes = 'string'
202 def cmd_MAP_CONTROL(game, content):
203 game.map_control_content = content
204 cmd_MAP_CONTROL.argtypes = 'string'
206 def cmd_GAME_STATE_COMPLETE(game):
207 if game.tui.mode.name == 'post_login_wait':
208 game.tui.switch_mode('play')
209 if game.tui.mode.shows_info:
210 game.tui.query_info()
211 game.turn_complete = True
212 game.tui.do_refresh = True
213 cmd_GAME_STATE_COMPLETE.argtypes = ''
215 def cmd_PORTAL(game, position, msg):
216 game.portals[position] = msg
217 cmd_PORTAL.argtypes = 'yx_tuple:nonneg string'
219 def cmd_PLAY_ERROR(game, msg):
220 game.tui.log_msg('? ' + msg)
221 game.tui.flash = True
222 game.tui.do_refresh = True
223 cmd_PLAY_ERROR.argtypes = 'string'
225 def cmd_GAME_ERROR(game, msg):
226 game.tui.log_msg('? game error: ' + msg)
227 game.tui.do_refresh = True
228 cmd_GAME_ERROR.argtypes = 'string'
230 def cmd_ARGUMENT_ERROR(game, msg):
231 game.tui.log_msg('? syntax error: ' + msg)
232 game.tui.do_refresh = True
233 cmd_ARGUMENT_ERROR.argtypes = 'string'
235 def cmd_ANNOTATION_HINT(game, position):
236 game.info_hints += [position]
237 cmd_ANNOTATION_HINT.argtypes = 'yx_tuple:nonneg'
239 def cmd_ANNOTATION(game, position, msg):
240 game.info_db[position] = msg
241 game.tui.restore_input_values()
242 if game.tui.mode.shows_info:
243 game.tui.do_refresh = True
244 cmd_ANNOTATION.argtypes = 'yx_tuple:nonneg string'
246 def cmd_TASKS(game, tasks_comma_separated):
247 game.tasks = tasks_comma_separated.split(',')
248 game.tui.mode_write.legal = 'WRITE' in game.tasks
249 cmd_TASKS.argtypes = 'string'
251 def cmd_THING_TYPE(game, thing_type, symbol_hint):
252 game.thing_types[thing_type] = symbol_hint
253 cmd_THING_TYPE.argtypes = 'string char'
255 def cmd_TERRAIN(game, terrain_char, terrain_desc):
256 game.terrains[terrain_char] = terrain_desc
257 cmd_TERRAIN.argtypes = 'char string'
261 cmd_PONG.argtypes = ''
263 class Game(GameBase):
264 turn_complete = False
268 def __init__(self, *args, **kwargs):
269 super().__init__(*args, **kwargs)
270 self.register_command(cmd_LOGIN_OK)
271 self.register_command(cmd_ADMIN_OK)
272 self.register_command(cmd_PONG)
273 self.register_command(cmd_CHAT)
274 self.register_command(cmd_PLAYER_ID)
275 self.register_command(cmd_TURN)
276 self.register_command(cmd_THING)
277 self.register_command(cmd_THING_TYPE)
278 self.register_command(cmd_THING_NAME)
279 self.register_command(cmd_THING_CHAR)
280 self.register_command(cmd_TERRAIN)
281 self.register_command(cmd_MAP)
282 self.register_command(cmd_MAP_CONTROL)
283 self.register_command(cmd_PORTAL)
284 self.register_command(cmd_ANNOTATION)
285 self.register_command(cmd_ANNOTATION_HINT)
286 self.register_command(cmd_GAME_STATE_COMPLETE)
287 self.register_command(cmd_ARGUMENT_ERROR)
288 self.register_command(cmd_GAME_ERROR)
289 self.register_command(cmd_PLAY_ERROR)
290 self.register_command(cmd_TASKS)
291 self.register_command(cmd_FOV)
292 self.map_content = ''
299 def get_string_options(self, string_option_type):
300 if string_option_type == 'map_geometry':
301 return ['Hex', 'Square']
302 elif string_option_type == 'thing_type':
303 return self.thing_types.keys()
306 def get_command(self, command_name):
307 from functools import partial
308 f = partial(self.commands[command_name], self)
309 f.argtypes = self.commands[command_name].argtypes
314 def __init__(self, name, has_input_prompt=False, shows_info=False,
315 is_intro=False, is_single_char_entry=False):
317 self.short_desc = mode_helps[name]['short']
318 self.available_modes = []
319 self.has_input_prompt = has_input_prompt
320 self.shows_info = shows_info
321 self.is_intro = is_intro
322 self.help_intro = mode_helps[name]['long']
323 self.is_single_char_entry = is_single_char_entry
326 def iter_available_modes(self, tui):
327 for mode_name in self.available_modes:
328 mode = getattr(tui, 'mode_' + mode_name)
331 key = tui.keys['switch_to_' + mode.name]
334 def list_available_modes(self, tui):
336 if len(self.available_modes) > 0:
337 msg = 'Other modes available from here:\n'
338 for mode, key in self.iter_available_modes(tui):
339 msg += '[%s] – %s\n' % (key, mode.short_desc)
342 def mode_switch_on_key(self, tui, key_pressed):
343 for mode, key in self.iter_available_modes(tui):
344 if key_pressed == key:
345 tui.switch_mode(mode.name)
350 mode_admin_enter = Mode('admin_enter', has_input_prompt=True)
351 mode_admin = Mode('admin')
352 mode_play = Mode('play')
353 mode_study = Mode('study', shows_info=True)
354 mode_write = Mode('write', is_single_char_entry=True)
355 mode_edit = Mode('edit')
356 mode_control_pw_type = Mode('control_pw_type', has_input_prompt=True)
357 mode_control_pw_pw = Mode('control_pw_pw', has_input_prompt=True)
358 mode_control_tile_type = Mode('control_tile_type', has_input_prompt=True)
359 mode_control_tile_draw = Mode('control_tile_draw')
360 mode_annotate = Mode('annotate', has_input_prompt=True, shows_info=True)
361 mode_portal = Mode('portal', has_input_prompt=True, shows_info=True)
362 mode_chat = Mode('chat', has_input_prompt=True)
363 mode_waiting_for_server = Mode('waiting_for_server', is_intro=True)
364 mode_login = Mode('login', has_input_prompt=True, is_intro=True)
365 mode_post_login_wait = Mode('post_login_wait', is_intro=True)
366 mode_password = Mode('password', has_input_prompt=True)
370 def __init__(self, host):
373 self.mode_play.available_modes = ["chat", "study", "edit", "admin_enter"]
374 self.mode_study.available_modes = ["chat", "play", "admin_enter", "edit"]
375 self.mode_admin.available_modes = ["control_pw_type",
376 "control_tile_type", "chat",
377 "study", "play", "edit"]
378 self.mode_control_tile_draw.available_modes = ["admin_enter"]
379 self.mode_edit.available_modes = ["write", "annotate", "portal",
380 "password", "chat", "study", "play",
385 self.parser = Parser(self.game)
387 self.do_refresh = True
388 self.queue = queue.Queue()
389 self.login_name = None
390 self.map_mode = 'all'
391 self.password = 'foo'
392 self.switch_mode('waiting_for_server')
394 'switch_to_chat': 't',
395 'switch_to_play': 'p',
396 'switch_to_password': 'P',
397 'switch_to_annotate': 'M',
398 'switch_to_portal': 'T',
399 'switch_to_study': '?',
400 'switch_to_edit': 'E',
401 'switch_to_write': 'm',
402 'switch_to_admin_enter': 'A',
403 'switch_to_control_pw_type': 'C',
404 'switch_to_control_tile_type': 'Q',
410 'toggle_map_mode': 'M',
411 'toggle_tile_draw': 'm',
412 'hex_move_upleft': 'w',
413 'hex_move_upright': 'e',
414 'hex_move_right': 'd',
415 'hex_move_downright': 'x',
416 'hex_move_downleft': 'y',
417 'hex_move_left': 'a',
418 'square_move_up': 'w',
419 'square_move_left': 'a',
420 'square_move_down': 's',
421 'square_move_right': 'd',
423 if os.path.isfile('config.json'):
424 with open('config.json', 'r') as f:
425 keys_conf = json.loads(f.read())
427 self.keys[k] = keys_conf[k]
428 self.show_help = False
429 self.disconnected = True
430 self.force_instant_connect = True
431 self.input_lines = []
434 curses.wrapper(self.loop)
438 def handle_recv(msg):
444 self.log_msg('@ attempting connect')
445 socket_client_class = PlomSocketClient
446 if self.host.startswith('ws://') or self.host.startswith('wss://'):
447 socket_client_class = WebSocketClient
449 self.socket = socket_client_class(handle_recv, self.host)
450 self.socket_thread = threading.Thread(target=self.socket.run)
451 self.socket_thread.start()
452 self.disconnected = False
453 self.game.thing_types = {}
454 self.game.terrains = {}
455 self.socket.send('TASKS')
456 self.socket.send('TERRAINS')
457 self.socket.send('THING_TYPES')
458 self.switch_mode('login')
459 except ConnectionRefusedError:
460 self.log_msg('@ server connect failure')
461 self.disconnected = True
462 self.switch_mode('waiting_for_server')
463 self.do_refresh = True
466 self.log_msg('@ attempting reconnect')
468 time.sleep(0.1) # FIXME necessitated by some some strange SSL race
469 # conditions with ws4py, find out what exactly
470 self.switch_mode('waiting_for_server')
475 if hasattr(self.socket, 'plom_closed') and self.socket.plom_closed:
476 raise BrokenSocketConnection
477 self.socket.send(msg)
478 except (BrokenPipeError, BrokenSocketConnection):
479 self.log_msg('@ server disconnected :(')
480 self.disconnected = True
481 self.force_instant_connect = True
482 self.do_refresh = True
484 def log_msg(self, msg):
486 if len(self.log) > 100:
487 self.log = self.log[-100:]
489 def query_info(self):
490 self.send('GET_ANNOTATION ' + str(self.explorer))
492 def restore_input_values(self):
493 if self.mode.name == 'annotate' and self.explorer in self.game.info_db:
494 info = self.game.info_db[self.explorer]
497 elif self.mode.name == 'portal' and self.explorer in self.game.portals:
498 self.input_ = self.game.portals[self.explorer]
499 elif self.mode.name == 'password':
500 self.input_ = self.password
502 def send_tile_control_command(self):
503 self.send('SET_TILE_CONTROL %s %s' %
504 (self.explorer, quote(self.tile_control_char)))
506 def switch_mode(self, mode_name):
507 self.map_mode = 'all'
508 self.tile_draw = False
509 if mode_name == 'admin_enter' and self.is_admin:
511 self.mode = getattr(self, 'mode_' + mode_name)
512 if self.mode.shows_info or self.mode.name == 'control_tile_draw':
513 player = self.game.get_thing(self.game.player_id)
514 self.explorer = YX(player.position.y, player.position.x)
515 if self.mode.shows_info:
517 if self.mode.is_single_char_entry:
518 self.show_help = True
519 if self.mode.name == 'waiting_for_server':
520 self.log_msg('@ waiting for server …')
521 elif self.mode.name == 'login':
523 self.send('LOGIN ' + quote(self.login_name))
525 self.log_msg('@ enter username')
526 elif self.mode.name == 'admin_enter':
527 self.log_msg('@ enter admin password:')
528 elif self.mode.name == 'control_pw_type':
529 self.log_msg('@ enter tile control character for which you want to change the password:')
530 elif self.mode.name == 'control_tile_type':
531 self.log_msg('@ enter tile control character which you want to draw:')
532 elif self.mode.name == 'control_pw_pw':
533 self.log_msg('@ enter tile control password for "%s":' % self.tile_control_char)
534 elif self.mode.name == 'control_tile_draw':
535 self.log_msg('@ can draw tile control 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']))
536 self.restore_input_values()
538 def loop(self, stdscr):
541 def safe_addstr(y, x, line):
542 if y < self.size.y - 1 or x + len(line) < self.size.x:
543 stdscr.addstr(y, x, line)
544 else: # workaround to <https://stackoverflow.com/q/7063128>
545 cut_i = self.size.x - x - 1
547 last_char = line[cut_i]
548 stdscr.addstr(y, self.size.x - 2, last_char)
549 stdscr.insstr(y, self.size.x - 2, ' ')
550 stdscr.addstr(y, x, cut)
552 def handle_input(msg):
553 command, args = self.parser.parse(msg)
556 def msg_into_lines_of_width(msg, width):
560 for i in range(len(msg)):
561 if x >= width or msg[i] == "\n":
573 def reset_screen_size():
574 self.size = YX(*stdscr.getmaxyx())
575 self.size = self.size - YX(self.size.y % 4, 0)
576 self.size = self.size - YX(0, self.size.x % 4)
577 self.window_width = int(self.size.x / 2)
579 def recalc_input_lines():
580 if not self.mode.has_input_prompt:
581 self.input_lines = []
583 self.input_lines = msg_into_lines_of_width(input_prompt + self.input_,
586 def move_explorer(direction):
587 target = self.game.map_geometry.move_yx(self.explorer, direction)
589 self.explorer = target
590 if self.mode.shows_info:
593 self.send_tile_control_command()
599 for line in self.log:
600 lines += msg_into_lines_of_width(line, self.window_width)
603 max_y = self.size.y - len(self.input_lines)
604 for i in range(len(lines)):
605 if (i >= max_y - height_header):
607 safe_addstr(max_y - i - 1, self.window_width, lines[i])
610 if not self.game.turn_complete:
612 pos_i = self.explorer.y * self.game.map_geometry.size.x + self.explorer.x
613 info = 'outside field of view'
614 if self.game.fov[pos_i] == '.':
615 terrain_char = self.game.map_content[pos_i]
617 if terrain_char in self.game.terrains:
618 terrain_desc = self.game.terrains[terrain_char]
619 info = 'TERRAIN: "%s" / %s\n' % (terrain_char, terrain_desc)
620 protection = self.game.map_control_content[pos_i]
621 if protection == '.':
622 protection = 'unprotected'
623 info = 'PROTECTION: %s\n' % protection
624 for t in self.game.things:
625 if t.position == self.explorer:
626 info += 'THING: %s / %s' % (t.type_,
627 self.game.thing_types[t.type_])
628 if hasattr(t, 'player_char'):
629 info += t.player_char
630 if hasattr(t, 'name'):
631 info += ' (%s)' % t.name
633 if self.explorer in self.game.portals:
634 info += 'PORTAL: ' + self.game.portals[self.explorer] + '\n'
636 info += 'PORTAL: (none)\n'
637 if self.explorer in self.game.info_db:
638 info += 'ANNOTATION: ' + self.game.info_db[self.explorer]
640 info += 'ANNOTATION: waiting …'
641 lines = msg_into_lines_of_width(info, self.window_width)
643 for i in range(len(lines)):
644 y = height_header + i
645 if y >= self.size.y - len(self.input_lines):
647 safe_addstr(y, self.window_width, lines[i])
650 y = self.size.y - len(self.input_lines)
651 for i in range(len(self.input_lines)):
652 safe_addstr(y, self.window_width, self.input_lines[i])
656 if not self.game.turn_complete:
658 safe_addstr(0, self.window_width, 'TURN: ' + str(self.game.turn))
661 help = "hit [%s] for help" % self.keys['help']
662 if self.mode.has_input_prompt:
663 help = "enter /help for help"
664 safe_addstr(1, self.window_width,
665 'MODE: %s – %s' % (self.mode.short_desc, help))
668 if not self.game.turn_complete:
671 for y in range(self.game.map_geometry.size.y):
672 start = self.game.map_geometry.size.x * y
673 end = start + self.game.map_geometry.size.x
674 if self.mode.name in {'edit', 'write', 'control_tile_draw',
675 'control_tile_type'}:
677 for i in range(start, end):
678 line += [self.game.map_content[i]
679 + self.game.map_control_content[i]]
680 map_lines_split += [line]
682 map_lines_split += [[c + ' ' for c
683 in self.game.map_content[start:end]]]
684 if self.map_mode == 'annotations':
685 for p in self.game.info_hints:
686 map_lines_split[p.y][p.x] = 'A '
687 elif self.map_mode == 'all':
688 for p in self.game.portals.keys():
689 original = map_lines_split[p.y][p.x]
690 map_lines_split[p.y][p.x] = original[0] + 'P'
692 for t in self.game.things:
693 symbol = self.game.thing_types[t.type_]
695 if hasattr(t, 'player_char'):
696 meta_char = t.player_char
697 if t.position in used_positions:
699 map_lines_split[t.position.y][t.position.x] = symbol + meta_char
700 used_positions += [t.position]
701 if self.mode.shows_info or self.mode.name == 'control_tile_draw':
702 map_lines_split[self.explorer.y][self.explorer.x] = '??'
704 if type(self.game.map_geometry) == MapGeometryHex:
706 for line in map_lines_split:
707 map_lines += [indent*' ' + ''.join(line)]
708 indent = 0 if indent else 1
710 for line in map_lines_split:
711 map_lines += [''.join(line)]
712 window_center = YX(int(self.size.y / 2),
713 int(self.window_width / 2))
714 player = self.game.get_thing(self.game.player_id)
715 center = player.position
716 if self.mode.shows_info:
717 center = self.explorer
718 center = YX(center.y, center.x * 2)
719 offset = center - window_center
720 if type(self.game.map_geometry) == MapGeometryHex and offset.y % 2:
722 term_y = max(0, -offset.y)
723 term_x = max(0, -offset.x)
724 map_y = max(0, offset.y)
725 map_x = max(0, offset.x)
726 while (term_y < self.size.y and map_y < self.game.map_geometry.size.y):
727 to_draw = map_lines[map_y][map_x:self.window_width + offset.x]
728 safe_addstr(term_y, term_x, to_draw)
733 content = "%s help\n\n%s\n\n" % (self.mode.short_desc,
734 self.mode.help_intro)
735 if self.mode.name == 'play':
736 content += "Available actions:\n"
737 if 'MOVE' in self.game.tasks:
738 content += "[%s] – move player\n" % ','.join(self.movement_keys)
739 if 'PICK_UP' in self.game.tasks:
740 content += "[%s] – pick up thing\n" % self.keys['take_thing']
741 if 'DROP' in self.game.tasks:
742 content += "[%s] – drop picked up thing\n" % self.keys['drop_thing']
743 content += '[%s] – teleport to other space\n' % self.keys['teleport']
745 elif self.mode.name == 'study':
746 content += 'Available actions:\n'
747 content += '[%s] – move question mark\n' % ','.join(self.movement_keys)
748 content += '[%s] – toggle view between anything, terrain, and annotations\n' % self.keys['toggle_map_mode']
750 elif self.mode.name == 'edit':
751 content += "Available actions:\n"
752 if 'FLATTEN_SURROUNDINGS' in self.game.tasks:
753 content += "[%s] – flatten player's surroundings\n" % self.keys['flatten']
755 elif self.mode.name == 'control_tile_draw':
756 content += "Available actions:\n"
757 content += "[%s] – toggle tile control drawing\n" % self.keys['toggle_tile_draw']
759 elif self.mode.name == 'chat':
760 content += '/nick NAME – re-name yourself to NAME\n'
761 content += '/%s or /play – switch to play mode\n' % self.keys['switch_to_play']
762 content += '/%s or /study – switch to study mode\n' % self.keys['switch_to_study']
763 content += '/%s or /edit – switch to map edit mode\n' % self.keys['switch_to_edit']
764 content += '/%s or /admin – switch to admin mode\n' % self.keys['switch_to_admin_enter']
765 content += self.mode.list_available_modes(self)
766 for i in range(self.size.y):
768 self.window_width * (not self.mode.has_input_prompt),
769 ' '*self.window_width)
771 for line in content.split('\n'):
772 lines += msg_into_lines_of_width(line, self.window_width)
773 for i in range(len(lines)):
777 self.window_width * (not self.mode.has_input_prompt),
782 if self.mode.has_input_prompt:
785 if self.mode.shows_info:
790 if not self.mode.is_intro:
796 curses.curs_set(False) # hide cursor
797 curses.use_default_colors();
800 self.explorer = YX(0, 0)
803 interval = datetime.timedelta(seconds=5)
804 last_ping = datetime.datetime.now() - interval
806 if self.disconnected and self.force_instant_connect:
807 self.force_instant_connect = False
809 now = datetime.datetime.now()
810 if now - last_ping > interval:
811 if self.disconnected:
821 self.do_refresh = False
824 msg = self.queue.get(block=False)
829 key = stdscr.getkey()
830 self.do_refresh = True
833 self.show_help = False
834 if key == 'KEY_RESIZE':
836 elif self.mode.has_input_prompt and key == 'KEY_BACKSPACE':
837 self.input_ = self.input_[:-1]
838 elif self.mode.has_input_prompt and key == '\n' and self.input_ == '/help':
839 self.show_help = True
841 self.restore_input_values()
842 elif self.mode.has_input_prompt and key != '\n': # Return key
844 max_length = self.window_width * self.size.y - len(input_prompt) - 1
845 if len(self.input_) > max_length:
846 self.input_ = self.input_[:max_length]
847 elif key == self.keys['help'] and not self.mode.is_single_char_entry:
848 self.show_help = True
849 elif self.mode.name == 'login' and key == '\n':
850 self.login_name = self.input_
851 self.send('LOGIN ' + quote(self.input_))
853 elif self.mode.name == 'control_pw_pw' and key == '\n':
854 if self.input_ == '':
855 self.log_msg('@ aborted')
857 self.send('SET_MAP_CONTROL_PASSWORD ' + quote(self.tile_control_char) + ' ' + quote(self.input_))
859 self.switch_mode('admin')
860 elif self.mode.name == 'password' and key == '\n':
861 if self.input_ == '':
863 self.password = self.input_
865 self.switch_mode('edit')
866 elif self.mode.name == 'admin_enter' and key == '\n':
867 self.send('BECOME_ADMIN ' + quote(self.input_))
869 self.switch_mode('play')
870 elif self.mode.name == 'control_pw_type' and key == '\n':
871 if len(self.input_) != 1:
872 self.log_msg('@ entered non-single-char, therefore aborted')
873 self.switch_mode('admin')
876 self.tile_control_char = self.input_
878 self.switch_mode('control_pw_pw')
879 elif self.mode.name == 'control_tile_type' and key == '\n':
880 if len(self.input_) != 1:
881 self.log_msg('@ entered non-single-char, therefore aborted')
882 self.switch_mode('admin')
885 self.tile_control_char = self.input_
887 self.switch_mode('control_tile_draw')
888 elif self.mode.name == 'chat' and key == '\n':
889 if self.input_ == '':
891 if self.input_[0] == '/': # FIXME fails on empty input
892 if self.input_ in {'/' + self.keys['switch_to_play'], '/play'}:
893 self.switch_mode('play')
894 elif self.input_ in {'/' + self.keys['switch_to_study'], '/study'}:
895 self.switch_mode('study')
896 elif self.input_ in {'/' + self.keys['switch_to_edit'], '/edit'}:
897 self.switch_mode('edit')
898 elif self.input_ in {'/' + self.keys['switch_to_admin_enter'], '/admin'}:
899 self.switch_mode('admin_enter')
900 elif self.input_.startswith('/nick'):
901 tokens = self.input_.split(maxsplit=1)
903 self.send('NICK ' + quote(tokens[1]))
905 self.log_msg('? need login name')
907 self.log_msg('? unknown command')
909 self.send('ALL ' + quote(self.input_))
911 elif self.mode.name == 'annotate' and key == '\n':
912 if self.input_ == '':
914 self.send('ANNOTATE %s %s %s' % (self.explorer, quote(self.input_),
915 quote(self.password)))
917 self.switch_mode('edit')
918 elif self.mode.name == 'portal' and key == '\n':
919 if self.input_ == '':
921 self.send('PORTAL %s %s %s' % (self.explorer, quote(self.input_),
922 quote(self.password)))
924 self.switch_mode('edit')
925 elif self.mode.name == 'study':
926 if self.mode.mode_switch_on_key(self, key):
928 elif key == self.keys['toggle_map_mode']:
929 if self.map_mode == 'terrain':
930 self.map_mode = 'annotations'
931 elif self.map_mode == 'annotations':
932 self.map_mode = 'all'
934 self.map_mode = 'terrain'
935 elif key in self.movement_keys:
936 move_explorer(self.movement_keys[key])
937 elif self.mode.name == 'play':
938 if self.mode.mode_switch_on_key(self, key):
940 elif key == self.keys['take_thing'] and 'PICK_UP' in self.game.tasks:
941 self.send('TASK:PICK_UP')
942 elif key == self.keys['drop_thing'] and 'DROP' in self.game.tasks:
943 self.send('TASK:DROP')
944 elif key == self.keys['teleport']:
945 player = self.game.get_thing(self.game.player_id)
946 if player.position in self.game.portals:
947 self.host = self.game.portals[player.position]
951 self.log_msg('? not standing on portal')
952 elif key in self.movement_keys and 'MOVE' in self.game.tasks:
953 self.send('TASK:MOVE ' + self.movement_keys[key])
954 elif self.mode.name == 'write':
955 self.send('TASK:WRITE %s %s' % (key, quote(self.password)))
956 self.switch_mode('edit')
957 elif self.mode.name == 'control_tile_draw':
958 if self.mode.mode_switch_on_key(self, key):
960 elif key in self.movement_keys:
961 move_explorer(self.movement_keys[key])
962 elif key == self.keys['toggle_tile_draw']:
963 self.tile_draw = False if self.tile_draw else True
964 elif self.mode.name == 'admin':
965 if self.mode.mode_switch_on_key(self, key):
967 elif self.mode.name == 'edit':
968 if self.mode.mode_switch_on_key(self, key):
970 if key == self.keys['flatten'] and\
971 'FLATTEN_SURROUNDINGS' in self.game.tasks:
972 self.send('TASK:FLATTEN_SURROUNDINGS ' + quote(self.password))
973 elif key in self.movement_keys and 'MOVE' in self.game.tasks:
974 self.send('TASK:MOVE ' + self.movement_keys[key])
976 if len(sys.argv) != 2:
977 raise ArgError('wrong number of arguments, need game host')