'long': 'Give name to/change name of thing here.'
},
'command_thing': {
- 'short': 'command thing',
+ 'short': 'command',
'intro': '',
'long': 'Enter a command to the thing you carry. Enter nothing to return to play mode.'
},
'take_thing': {
- 'short': 'take thing',
- 'intro': '',
+ 'short': 'take',
+ 'intro': 'Pick up a thing in reach by entering its index number. Enter nothing to abort.',
'long': 'You see a list of things which you could pick up. Enter the target thing\'s index, or, to leave, nothing.'
},
+ 'drop_thing': {
+ 'short': 'drop',
+ 'intro': 'Enter number of direction to which you want to drop thing.',
+ 'long': 'Drop currently carried thing by entering the target direction index. Enter nothing to return to play mode..'
+ },
'admin_thing_protect': {
'short': 'change thing protection',
'intro': '@ enter thing protection character:',
'long': 'Change protection character for thing here.'
},
+ 'enter_face': {
+ 'short': 'edit face',
+ 'intro': '@ enter face line (enter nothing to abort):',
+ '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..'
+ },
+ 'enter_hat': {
+ 'short': 'edit hat',
+ 'intro': '@ enter hat line (enter nothing to abort):',
+ '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.'
+ },
'write': {
- 'short': 'change terrain',
+ 'short': 'edit tile',
'intro': '',
'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.'
},
'chat': {
'short': 'chat',
'intro': '',
- '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:'
+ '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'
},
'login': {
'short': 'login',
pass # we assume socket will be known as dead by now
def cmd_TURN(game, n):
- game.annotations = {}
game.turn = n
- game.things = []
- game.portals = {}
game.turn_complete = False
- game.fov = ''
cmd_TURN.argtypes = 'int:nonneg'
+def cmd_OTHER_WIPE(game):
+ game.portals_new = {}
+ game.annotations_new = {}
+ game.things_new = []
+cmd_OTHER_WIPE.argtypes = ''
+
def cmd_LOGIN_OK(game):
game.tui.switch_mode('post_login_wait')
game.tui.send('GET_GAMESTATE')
game.tui.do_refresh = True
cmd_CHAT.argtypes = 'string'
+def cmd_CHATFACE(game, thing_id):
+ game.tui.draw_face = thing_id
+ game.tui.do_refresh = True
+cmd_CHATFACE.argtypes = 'int:pos'
+
def cmd_PLAYER_ID(game, player_id):
game.player_id = player_id
cmd_PLAYER_ID.argtypes = 'int:nonneg'
-def cmd_THING(game, yx, thing_type, protection, thing_id):
- t = game.get_thing(thing_id)
+def cmd_PLAYERS_HAT_CHARS(game, hat_chars):
+ game.players_hat_chars_new = hat_chars
+cmd_PLAYERS_HAT_CHARS.argtypes = 'string'
+
+def cmd_THING(game, yx, thing_type, protection, thing_id, portable, commandable):
+ t = game.get_thing_temp(thing_id)
if not t:
t = ThingBase(game, thing_id)
- game.things += [t]
+ game.things_new += [t]
t.position = yx
t.type_ = thing_type
t.protection = protection
-cmd_THING.argtypes = 'yx_tuple:nonneg string:thing_type char int:nonneg'
+ t.portable = portable
+ t.commandable = commandable
+cmd_THING.argtypes = 'yx_tuple:nonneg string:thing_type char int:nonneg bool bool'
def cmd_THING_NAME(game, thing_id, name):
- t = game.get_thing(thing_id)
- if t:
- t.name = name
-cmd_THING_NAME.argtypes = 'int:nonneg string'
+ t = game.get_thing_temp(thing_id)
+ t.name = name
+cmd_THING_NAME.argtypes = 'int:pos string'
+
+def cmd_THING_FACE(game, thing_id, face):
+ t = game.get_thing_temp(thing_id)
+ t.face = face
+cmd_THING_FACE.argtypes = 'int:pos string'
+
+def cmd_THING_HAT(game, thing_id, hat):
+ t = game.get_thing_temp(thing_id)
+ t.hat = hat
+cmd_THING_HAT.argtypes = 'int:pos string'
def cmd_THING_CHAR(game, thing_id, c):
- t = game.get_thing(thing_id)
- if t:
- t.thing_char = c
-cmd_THING_CHAR.argtypes = 'int:nonneg char'
+ t = game.get_thing_temp(thing_id)
+ t.thing_char = c
+cmd_THING_CHAR.argtypes = 'int:pos char'
def cmd_MAP(game, geometry, size, content):
map_geometry_class = globals()['MapGeometry' + geometry]
- game.map_geometry = map_geometry_class(size)
- game.map_content = content
+ game.map_geometry_new = map_geometry_class(size)
+ game.map_content_new = content
if type(game.map_geometry) == MapGeometrySquare:
game.tui.movement_keys = {
game.tui.keys['square_move_up']: 'UP',
cmd_MAP.argtypes = 'string:map_geometry yx_tuple:pos string'
def cmd_FOV(game, content):
- game.fov = content
+ game.fov_new = content
cmd_FOV.argtypes = 'string'
def cmd_MAP_CONTROL(game, content):
- game.map_control_content = content
+ game.map_control_content_new = content
cmd_MAP_CONTROL.argtypes = 'string'
def cmd_GAME_STATE_COMPLETE(game):
- if game.tui.mode.name == 'post_login_wait':
- game.tui.switch_mode('play')
- game.turn_complete = True
game.tui.do_refresh = True
game.tui.info_cached = None
+ game.things = game.things_new
+ game.portals = game.portals_new
+ game.annotations = game.annotations_new
+ game.fov = game.fov_new
+ game.map_geometry = game.map_geometry_new
+ game.map_content = game.map_content_new
+ game.map_control_content = game.map_control_content_new
+ game.player = game.get_thing(game.player_id)
+ game.players_hat_chars = game.players_hat_chars_new
+ game.turn_complete = True
+ if game.tui.mode.name == 'post_login_wait':
+ game.tui.switch_mode('play')
cmd_GAME_STATE_COMPLETE.argtypes = ''
def cmd_PORTAL(game, position, msg):
- game.portals[position] = msg
+ game.portals_new[position] = msg
cmd_PORTAL.argtypes = 'yx_tuple:nonneg string'
def cmd_PLAY_ERROR(game, msg):
cmd_ARGUMENT_ERROR.argtypes = 'string'
def cmd_ANNOTATION(game, position, msg):
- game.annotations[position] = msg
+ game.annotations_new[position] = msg
if game.tui.mode.shows_info:
game.tui.do_refresh = True
cmd_ANNOTATION.argtypes = 'yx_tuple:nonneg string'
game.tui.mode_write.legal = 'WRITE' in game.tasks
game.tui.mode_command_thing.legal = 'COMMAND' in game.tasks
game.tui.mode_take_thing.legal = 'PICK_UP' in game.tasks
+ game.tui.mode_drop_thing.legal = 'DROP' in game.tasks
cmd_TASKS.argtypes = 'string'
def cmd_THING_TYPE(game, thing_type, symbol_hint):
game.thing_types[thing_type] = symbol_hint
cmd_THING_TYPE.argtypes = 'string char'
+def cmd_THING_INSTALLED(game, thing_id):
+ game.get_thing_temp(thing_id).installed = True
+cmd_THING_INSTALLED.argtypes = 'int:pos'
+
+def cmd_THING_CARRYING(game, thing_id, carried_id):
+ game.get_thing_temp(thing_id).carrying = game.get_thing(carried_id)
+cmd_THING_CARRYING.argtypes = 'int:pos int:pos'
+
def cmd_TERRAIN(game, terrain_char, terrain_desc):
game.terrains[terrain_char] = terrain_desc
cmd_TERRAIN.argtypes = 'char string'
turn_complete = False
tasks = {}
thing_types = {}
+ things_new = []
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.register_command(cmd_ADMIN_OK)
self.register_command(cmd_PONG)
self.register_command(cmd_CHAT)
+ self.register_command(cmd_CHATFACE)
self.register_command(cmd_REPLY)
self.register_command(cmd_PLAYER_ID)
self.register_command(cmd_TURN)
+ self.register_command(cmd_OTHER_WIPE)
self.register_command(cmd_THING)
self.register_command(cmd_THING_TYPE)
self.register_command(cmd_THING_NAME)
self.register_command(cmd_THING_CHAR)
+ self.register_command(cmd_THING_FACE)
+ self.register_command(cmd_THING_HAT)
+ self.register_command(cmd_THING_CARRYING)
+ self.register_command(cmd_THING_INSTALLED)
self.register_command(cmd_TERRAIN)
self.register_command(cmd_MAP)
self.register_command(cmd_MAP_CONTROL)
self.register_command(cmd_PORTAL)
self.register_command(cmd_ANNOTATION)
self.register_command(cmd_GAME_STATE_COMPLETE)
+ self.register_command(cmd_PLAYERS_HAT_CHARS)
self.register_command(cmd_ARGUMENT_ERROR)
self.register_command(cmd_GAME_ERROR)
self.register_command(cmd_PLAY_ERROR)
self.register_command(cmd_DEFAULT_COLORS)
self.register_command(cmd_RANDOM_COLORS)
self.map_content = ''
+ self.players_hat_chars = ''
self.player_id = -1
self.annotations = {}
+ self.annotations_new = {}
self.portals = {}
+ self.portals_new = {}
self.terrains = {}
+ self.player = None
def get_string_options(self, string_option_type):
if string_option_type == 'map_geometry':
f.argtypes = self.commands[command_name].argtypes
return f
+ def get_thing_temp(self, id_):
+ for thing in self.things_new:
+ if id_ == thing.id_:
+ return thing
+ return None
+
class Mode:
def __init__(self, name, has_input_prompt=False, shows_info=False,
mode_name_thing = Mode('name_thing', has_input_prompt=True, shows_info=True)
mode_command_thing = Mode('command_thing', has_input_prompt=True)
mode_take_thing = Mode('take_thing', has_input_prompt=True)
+ mode_drop_thing = Mode('drop_thing', has_input_prompt=True)
+ mode_enter_face = Mode('enter_face', has_input_prompt=True)
+ mode_enter_hat = Mode('enter_hat', has_input_prompt=True)
is_admin = False
tile_draw = False
import os
import json
self.mode_play.available_modes = ["chat", "study", "edit", "admin_enter",
- "command_thing", "take_thing"]
- self.mode_play.available_actions = ["move", "drop_thing",
- "teleport", "door", "consume"]
+ "command_thing", "take_thing",
+ "drop_thing"]
+ self.mode_play.available_actions = ["move", "teleport", "door", "consume",
+ "install", "wear", "spin"]
self.mode_study.available_modes = ["chat", "play", "admin_enter", "edit"]
self.mode_study.available_actions = ["toggle_map_mode", "move_explorer"]
self.mode_admin.available_modes = ["admin_thing_protect", "control_pw_type",
self.mode_control_tile_draw.available_modes = ["admin_enter"]
self.mode_control_tile_draw.available_actions = ["move_explorer",
"toggle_tile_draw"]
- self.mode_edit.available_modes = ["write", "annotate", "portal", "name_thing",
- "password", "chat", "study", "play",
- "admin_enter"]
- self.mode_edit.available_actions = ["move", "flatten", "toggle_map_mode"]
+ self.mode_edit.available_modes = ["write", "annotate", "portal",
+ "name_thing", "enter_face", "enter_hat", "password",
+ "chat", "study", "play", "admin_enter"]
+ self.mode_edit.available_actions = ["move", "flatten", "install",
+ "toggle_map_mode"]
self.mode = None
self.host = host
self.game = Game()
'switch_to_control_tile_type': 'Q',
'switch_to_admin_thing_protect': 'T',
'flatten': 'F',
+ 'switch_to_enter_face': 'f',
+ 'switch_to_enter_hat': 'H',
'switch_to_take_thing': 'z',
- 'drop_thing': 'u',
+ 'switch_to_drop_thing': 'u',
'teleport': 'p',
'consume': 'C',
'door': 'D',
+ 'install': 'I',
+ 'wear': 'W',
+ 'spin': 'S',
'help': 'h',
'toggle_map_mode': 'L',
'toggle_tile_draw': 'm',
self.fov = ''
self.flash = False
self.map_lines = []
+ self.ascii_draw_stage = 0
+ self.full_ascii_draw = ''
self.offset = YX(0,0)
curses.wrapper(self.loop)
elif self.mode.name == 'admin_thing_protect':
if hasattr(self.thing_selected, 'protection'):
self.input_ = self.thing_selected.protection
+ elif self.mode.name in {'enter_face', 'enter_hat'}:
+ start = self.ascii_draw_stage * 6
+ end = (self.ascii_draw_stage + 1) * 6
+ if self.mode.name == 'enter_face':
+ self.input_ = self.game.player.face[start:end]
+ elif self.mode.name == 'enter_hat':
+ self.input_ = self.game.player.hat[start:end]
def send_tile_control_command(self):
self.send('SET_TILE_CONTROL %s %s' %
self.map_mode = 'terrain only'
def switch_mode(self, mode_name):
+
+ def fail(msg, return_mode='play'):
+ self.log_msg('? ' + msg)
+ self.flash = True
+ self.switch_mode(return_mode)
+
if self.mode and self.mode.name == 'control_tile_draw':
self.log_msg('@ finished tile protection drawing.')
+ self.draw_face = False
self.tile_draw = False
+ if mode_name == 'command_thing' and\
+ (not self.game.player.carrying or
+ not self.game.player.carrying.commandable):
+ return fail('not carrying anything commandable')
+ if mode_name == 'take_thing' and self.game.player.carrying:
+ return fail('already carrying something')
+ if mode_name == 'drop_thing' and not self.game.player.carrying:
+ return fail('not carrying anything droppable')
+ if mode_name == 'enter_hat' and not hasattr(self.game.player, 'hat'):
+ return fail('not wearing hat to edit', 'edit')
if mode_name == 'admin_enter' and self.is_admin:
mode_name = 'admin'
elif mode_name in {'name_thing', 'admin_thing_protect'}:
- player = self.game.get_thing(self.game.player_id)
thing = None
- for t in [t for t in self.game.things if t.position == player.position
- and t.id_ != player.id_]:
+ for t in [t for t in self.game.things
+ if t.position == self.game.player.position
+ and t.id_ != self.game.player.id_]:
thing = t
break
if not thing:
- self.flash = True
- self.log_msg('? not standing over thing')
- return
+ return fail('not standing over thing', 'edit')
else:
self.thing_selected = thing
self.mode = getattr(self, 'mode_' + mode_name)
elif self.mode.name != 'edit':
self.map_mode = 'terrain + things'
if self.mode.shows_info or self.mode.name == 'control_tile_draw':
- player = self.game.get_thing(self.game.player_id)
- self.explorer = YX(player.position.y, player.position.x)
+ self.explorer = YX(self.game.player.position.y,
+ self.game.player.position.x)
if self.mode.is_single_char_entry:
self.show_help = True
if len(self.mode.intro_msg) > 0:
else:
self.log_msg('@ enter username')
elif self.mode.name == 'take_thing':
- self.log_msg('selectable things:')
- player = self.game.get_thing(self.game.player_id)
- self.selectables = [t for t in self.game.things
- if t != player and t.type_ != 'Player'
- and t.position == player.position]
+ self.log_msg('Portable things in reach for pick-up:')
+ select_range = [self.game.player.position,
+ self.game.player.position + YX(0,-1),
+ self.game.player.position + YX(0, 1),
+ self.game.player.position + YX(-1, 0),
+ self.game.player.position + YX(1, 0)]
+ if type(self.game.map_geometry) == MapGeometryHex:
+ if self.game.player.position.y % 2:
+ select_range += [self.game.player.position + YX(-1, 1),
+ self.game.player.position + YX(1, 1)]
+ else:
+ select_range += [self.game.player.position + YX(-1, -1),
+ self.game.player.position + YX(1, -1)]
+ self.selectables = [t.id_ for t in self.game.things
+ if t.portable and t.position in select_range]
if len(self.selectables) == 0:
- self.log_msg('none')
+ return fail('nothing to pick-up')
else:
for i in range(len(self.selectables)):
- t = self.selectables[i]
+ t = self.game.get_thing(self.selectables[i])
self.log_msg(str(i) + ': ' + self.get_thing_info(t))
+ elif self.mode.name == 'drop_thing':
+ self.log_msg('Direction to drop thing to:')
+ self.selectables =\
+ ['HERE'] + list(self.game.tui.movement_keys.values())
+ for i in range(len(self.selectables)):
+ self.log_msg(str(i) + ': ' + self.selectables[i])
+ elif self.mode.name == 'enter_hat':
+ self.log_msg('legal characters: ' + self.game.players_hat_chars)
elif self.mode.name == 'command_thing':
self.send('TASK:COMMAND ' + quote('HELP'))
elif self.mode.name == 'control_pw_pw':
if len(self.game.fov) > pos_i and self.game.fov[pos_i] != '.':
info_to_cache += 'outside field of view'
else:
+ for t in self.game.things:
+ if t.position == self.explorer:
+ info_to_cache += 'THING: %s' % self.get_thing_info(t)
+ protection = t.protection
+ if protection == '.':
+ protection = 'none'
+ info_to_cache += ' / protection: %s\n' % protection
+ if hasattr(t, 'hat'):
+ info_to_cache += t.hat[0:6] + '\n'
+ info_to_cache += t.hat[6:12] + '\n'
+ info_to_cache += t.hat[12:18] + '\n'
+ if hasattr(t, 'face'):
+ info_to_cache += t.face[0:6] + '\n'
+ info_to_cache += t.face[6:12] + '\n'
+ info_to_cache += t.face[12:18] + '\n'
terrain_char = self.game.map_content[pos_i]
terrain_desc = '?'
if terrain_char in self.game.terrains:
if protection == '.':
protection = 'unprotected'
info_to_cache += 'PROTECTION: %s\n' % protection
- for t in self.game.things:
- if t.position == self.explorer:
- info_to_cache += 'THING: %s' % self.get_thing_info(t)
- protection = t.protection
- if protection == '.':
- protection = 'none'
- info_to_cache += ' / protection: %s\n' % protection
if self.explorer in self.game.portals:
info_to_cache += 'PORTAL: ' +\
self.game.portals[self.explorer] + '\n'
info += t.thing_char
if hasattr(t, 'name'):
info += ' (%s)' % t.name
+ if hasattr(t, 'installed'):
+ info += ' / installed'
return info
def loop(self, stdscr):
'MODE: %s – %s' % (self.mode.short_desc, help))
def draw_map():
- if not self.game.turn_complete and len(self.map_lines) == 0:
+ if (not self.game.turn_complete) and len(self.map_lines) == 0:
return
if self.game.turn_complete:
map_lines_split = []
meta_char = t.thing_char
if t.position in used_positions:
meta_char = '+'
+ if hasattr(t, 'carrying') and t.carrying:
+ meta_char = '$'
map_lines_split[t.position.y][t.position.x] = symbol + meta_char
used_positions += [t.position]
draw_thing(t, used_positions)
for t in [t for t in self.game.things if t.type_ == 'Player']:
draw_thing(t, used_positions)
- player = self.game.get_thing(self.game.player_id)
if self.mode.shows_info or self.mode.name == 'control_tile_draw':
map_lines_split[self.explorer.y][self.explorer.x] = '??'
elif self.map_mode != 'terrain + things':
- map_lines_split[player.position.y][player.position.x] = '??'
+ map_lines_split[self.game.player.position.y]\
+ [self.game.player.position.x] = '??'
self.map_lines = []
if type(self.game.map_geometry) == MapGeometryHex:
indent = 0
self.map_lines += [''.join(line)]
window_center = YX(int(self.size.y / 2),
int(self.window_width / 2))
- center = player.position
+ center = self.game.player.position
if self.mode.shows_info or self.mode.name == 'control_tile_draw':
center = self.explorer
center = YX(center.y, center.x * 2)
term_x = max(0, -self.offset.x)
map_y = max(0, self.offset.y)
map_x = max(0, self.offset.x)
- while (term_y < self.size.y and map_y < self.game.map_geometry.size.y):
+ while term_y < self.size.y and map_y < len(self.map_lines):
to_draw = self.map_lines[map_y][map_x:self.window_width + self.offset.x]
safe_addstr(term_y, term_x, to_draw)
term_y += 1
map_y += 1
+ def draw_face_popup():
+ t = self.game.get_thing(self.draw_face)
+ if not t or not hasattr(t, 'face'):
+ self.draw_face = False
+ return
+
+ start_x = self.window_width - 10
+ t_char = ' '
+ if hasattr(t, 'thing_char'):
+ t_char = t.thing_char
+ def draw_body_part(body_part, end_y):
+ safe_addstr(end_y - 4, start_x, ' _[ @' + t_char + ' ]_ ')
+ safe_addstr(end_y - 3, start_x, '| |')
+ safe_addstr(end_y - 2, start_x, '| ' + body_part[0:6] + ' |')
+ safe_addstr(end_y - 1, start_x, '| ' + body_part[6:12] + ' |')
+ safe_addstr(end_y, start_x, '| ' + body_part[12:18] + ' |')
+
+ if hasattr(t, 'face'):
+ draw_body_part(t.face, self.size.y - 2)
+ if hasattr(t, 'hat'):
+ draw_body_part(t.hat, self.size.y - 5)
+ safe_addstr(self.size.y - 1, start_x, '| |')
+
def draw_help():
content = "%s help\n\n%s\n\n" % (self.mode.short_desc,
self.mode.help_intro)
key = self.keys[action]
content += '[%s] – %s\n' % (key, action_descriptions[action])
content += '\n'
- if self.mode.name == 'chat':
- content += '/nick NAME – re-name yourself to NAME\n'
- content += '/%s or /play – switch to play mode\n' % self.keys['switch_to_play']
- content += '/%s or /study – switch to study mode\n' % self.keys['switch_to_study']
- content += '/%s or /edit – switch to world edit mode\n' % self.keys['switch_to_edit']
- content += '/%s or /admin – switch to admin mode\n' % self.keys['switch_to_admin_enter']
content += self.mode.list_available_modes(self)
for i in range(self.size.y):
safe_addstr(i,
draw_map()
if self.show_help:
draw_help()
+ if self.draw_face and self.mode.name in {'chat', 'play'}:
+ draw_face_popup()
+
+ def pick_selectable(task_name):
+ try:
+ i = int(self.input_)
+ if i < 0 or i >= len(self.selectables):
+ self.log_msg('? invalid index, aborted')
+ else:
+ self.send('TASK:%s %s' % (task_name, self.selectables[i]))
+ except ValueError:
+ self.log_msg('? invalid index, aborted')
+ self.input_ = ''
+ self.switch_mode('play')
+
+ def enter_ascii_art(command):
+ if len(self.input_) != 6:
+ self.log_msg('? wrong input length, try again')
+ return
+ self.log_msg(' ' + self.input_)
+ self.full_ascii_draw += self.input_
+ self.ascii_draw_stage += 1
+ if self.ascii_draw_stage < 3:
+ self.restore_input_values()
+ else:
+ self.send('%s %s' % (command, quote(self.full_ascii_draw)))
+ self.full_ascii_draw = ""
+ self.ascii_draw_stage = 0
+ self.input_ = ""
+ self.switch_mode('edit')
action_descriptions = {
'move': 'move',
'drop_thing': 'drop thing',
'toggle_map_mode': 'toggle map view',
'toggle_tile_draw': 'toggle protection character drawing',
+ 'install': '(un-)install',
+ 'wear': '(un-)wear',
'door': 'open/close',
'consume': 'consume',
+ 'spin': 'spin',
}
action_tasks = {
'take_thing': 'PICK_UP',
'drop_thing': 'DROP',
'door': 'DOOR',
+ 'install': 'INSTALL',
+ 'wear': 'WEAR',
'move': 'MOVE',
'command': 'COMMAND',
'consume': 'INTOXICATE',
+ 'spin': 'SPIN',
}
curses.curs_set(False) # hide cursor
self.do_refresh = True
except curses.error:
continue
+ keycode = None
+ if len(key) == 1:
+ keycode = ord(key)
self.show_help = False
+ self.draw_face = False
if key == 'KEY_RESIZE':
reset_screen_size()
elif self.mode.has_input_prompt and key == 'KEY_BACKSPACE':
self.input_ = self.input_[:-1]
+ elif (((not self.mode.is_intro) and keycode == 27) # Escape
+ or (self.mode.has_input_prompt and key == '\n'
+ and self.input_ == ''\
+ and self.mode.name in {'chat', 'command_thing',
+ 'take_thing', 'drop_thing',
+ 'admin_enter'})):
+ if self.mode.name not in {'chat', 'play', 'study', 'edit'}:
+ self.log_msg('@ aborted')
+ self.switch_mode('play')
elif self.mode.has_input_prompt and key == '\n' and self.input_ == '/help':
self.show_help = True
self.input_ = ""
self.login_name = self.input_
self.send('LOGIN ' + quote(self.input_))
self.input_ = ""
+ elif self.mode.name == 'enter_face' and key == '\n':
+ enter_ascii_art('PLAYER_FACE')
+ elif self.mode.name == 'enter_hat' and key == '\n':
+ enter_ascii_art('PLAYER_HAT')
elif self.mode.name == 'take_thing' and key == '\n':
- if self.input_ == '':
- self.log_msg('@ aborted')
- else:
- try:
- i = int(self.input_)
- if i < 0 or i >= len(self.selectables):
- self.log_msg('? invalid index, aborted')
- else:
- self.send('TASK:PICK_UP %s' % self.selectables[i].id_)
- except ValueError:
- self.log_msg('? invalid index, aborted')
- self.input_ = ''
- self.switch_mode('play')
+ pick_selectable('PICK_UP')
+ elif self.mode.name == 'drop_thing' and key == '\n':
+ pick_selectable('DROP')
elif self.mode.name == 'command_thing' and key == '\n':
- if self.input_ == '':
- self.log_msg('@ aborted')
- self.switch_mode('play')
- elif task_action_on('command'):
- self.send('TASK:COMMAND ' + quote(self.input_))
- self.input_ = ""
+ self.send('TASK:COMMAND ' + quote(self.input_))
+ self.input_ = ""
elif self.mode.name == 'control_pw_pw' and key == '\n':
if self.input_ == '':
self.log_msg('@ aborted')
elif self.mode.name == 'chat' and key == '\n':
if self.input_ == '':
continue
- if self.input_[0] == '/': # FIXME fails on empty input
- if self.input_ in {'/' + self.keys['switch_to_play'], '/play'}:
- self.switch_mode('play')
- elif self.input_ in {'/' + self.keys['switch_to_study'], '/study'}:
- self.switch_mode('study')
- elif self.input_ in {'/' + self.keys['switch_to_edit'], '/edit'}:
- self.switch_mode('edit')
- elif self.input_ in {'/' + self.keys['switch_to_admin_enter'], '/admin'}:
- self.switch_mode('admin_enter')
- elif self.input_.startswith('/nick'):
+ if self.input_[0] == '/':
+ if self.input_.startswith('/nick'):
tokens = self.input_.split(maxsplit=1)
if len(tokens) == 2:
self.send('NICK ' + quote(tokens[1]))
elif self.mode.name == 'play':
if self.mode.mode_switch_on_key(self, key):
continue
- elif key == self.keys['drop_thing'] and task_action_on('drop_thing'):
- self.send('TASK:DROP')
elif key == self.keys['door'] and task_action_on('door'):
self.send('TASK:DOOR')
elif key == self.keys['consume'] and task_action_on('consume'):
self.send('TASK:INTOXICATE')
+ elif key == self.keys['wear'] and task_action_on('wear'):
+ self.send('TASK:WEAR')
+ elif key == self.keys['spin'] and task_action_on('spin'):
+ self.send('TASK:SPIN')
elif key == self.keys['teleport']:
- player = self.game.get_thing(self.game.player_id)
- if player.position in self.game.portals:
- self.host = self.game.portals[player.position]
+ if self.game.player.position in self.game.portals:
+ self.host = self.game.portals[self.game.player.position]
self.reconnect()
else:
self.flash = True
continue
elif key == self.keys['flatten'] and task_action_on('flatten'):
self.send('TASK:FLATTEN_SURROUNDINGS ' + quote(self.password))
+ elif key == self.keys['install'] and task_action_on('install'):
+ self.send('TASK:INSTALL %s' % quote(self.password))
elif key == self.keys['toggle_map_mode']:
self.toggle_map_mode()
elif key in self.movement_keys and task_action_on('move'):
projects / plomrogue2 / blobdiff