home · contact · privacy
Turn players into non-light-blockers.
[plomrogue2] / rogue_chat_curses.py
index 657523fbcf3257aca52daaa749a8ad880ed8906f..8f4f7da96e41f5221880fd6d24036430bdfdf832 100755 (executable)
@@ -32,17 +32,17 @@ mode_helps = {
         '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',
+        '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 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..'
     },
@@ -52,12 +52,17 @@ mode_helps = {
         'long': 'Change protection character for thing here.'
     },
     'enter_face': {
-        'short': 'enter your 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.'
     },
@@ -169,14 +174,16 @@ class PlomSocketClient(PlomSocket):
             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')
@@ -200,15 +207,24 @@ def cmd_CHAT(game, msg):
     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_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(thing_id)
+    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
@@ -217,29 +233,29 @@ def cmd_THING(game, yx, thing_type, protection, thing_id, portable, 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)
+    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(thing_id)
+    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(thing_id)
+    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)
+    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',
@@ -259,23 +275,32 @@ def cmd_MAP(game, geometry, size, content):
 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):
@@ -295,7 +320,7 @@ def cmd_ARGUMENT_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'
@@ -313,11 +338,11 @@ def cmd_THING_TYPE(game, thing_type, symbol_hint):
 cmd_THING_TYPE.argtypes = 'string char'
 
 def cmd_THING_INSTALLED(game, thing_id):
-    game.get_thing(thing_id).installed = True
+    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(thing_id).carrying = game.get_thing(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):
@@ -340,6 +365,7 @@ class Game(GameBase):
     turn_complete = False
     tasks = {}
     thing_types = {}
+    things_new = []
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -347,9 +373,11 @@ class Game(GameBase):
         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)
@@ -364,6 +392,7 @@ class Game(GameBase):
         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)
@@ -372,10 +401,14 @@ class Game(GameBase):
         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':
@@ -390,6 +423,12 @@ class Game(GameBase):
         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,
@@ -453,6 +492,7 @@ class TUI:
     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
 
@@ -463,7 +503,7 @@ class TUI:
                                           "command_thing", "take_thing",
                                           "drop_thing"]
         self.mode_play.available_actions = ["move", "teleport", "door", "consume",
-                                            "install", "wear"]
+                                            "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",
@@ -473,10 +513,11 @@ class TUI:
         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", "enter_face"]
-        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()
@@ -506,6 +547,7 @@ class TUI:
             'switch_to_admin_thing_protect': 'T',
             'flatten': 'F',
             'switch_to_enter_face': 'f',
+            'switch_to_enter_hat': 'H',
             'switch_to_take_thing': 'z',
             'switch_to_drop_thing': 'u',
             'teleport': 'p',
@@ -513,6 +555,7 @@ class TUI:
             'door': 'D',
             'install': 'I',
             'wear': 'W',
+            'spin': 'S',
             'help': 'h',
             'toggle_map_mode': 'L',
             'toggle_tile_draw': 'm',
@@ -539,6 +582,8 @@ class TUI:
         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)
 
@@ -609,6 +654,13 @@ class TUI:
         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' %
@@ -625,28 +677,37 @@ class TUI:
             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
-        player = self.game.get_thing(self.game.player_id)
         if mode_name == 'command_thing' and\
-           (not hasattr(player, 'carrying') or not player.carrying.commandable):
-            self.log_msg('? not carrying anything commandable')
-            self.flash = True
-            self.switch_mode('play')
-            return
+           (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'}:
             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)
@@ -656,8 +717,8 @@ class TUI:
         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:
@@ -669,26 +730,22 @@ class TUI:
                 self.log_msg('@ enter username')
         elif self.mode.name == 'take_thing':
             self.log_msg('Portable things in reach for pick-up:')
-            player = self.game.get_thing(self.game.player_id)
-            select_range = [player.position,
-                            player.position + YX(0,-1),
-                            player.position + YX(0, 1),
-                            player.position + YX(-1, 0),
-                            player.position + YX(1, 0)]
+            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 player.position.y % 2:
-                    select_range += [player.position + YX(-1, 1),
-                                     player.position + YX(1, 1)]
+                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 += [player.position + YX(-1, -1),
-                                     player.position + YX(1, -1)]
+                    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')
-                self.flash = True
-                self.switch_mode('play')
-                return
+                return fail('nothing to pick-up')
             else:
                 for i in range(len(self.selectables)):
                     t = self.game.get_thing(self.selectables[i])
@@ -699,6 +756,8 @@ class TUI:
                 ['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':
@@ -880,7 +939,7 @@ class TUI:
                         '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 = []
@@ -918,11 +977,11 @@ class TUI:
                         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
@@ -934,7 +993,7 @@ class TUI:
                         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)
@@ -951,6 +1010,29 @@ class TUI:
                 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)
@@ -999,6 +1081,8 @@ class TUI:
                 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:
@@ -1012,6 +1096,22 @@ class TUI:
             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',
             'flatten': 'flatten surroundings',
@@ -1024,6 +1124,7 @@ class TUI:
             'wear': '(un-)wear',
             'door': 'open/close',
             'consume': 'consume',
+            'spin': 'spin',
         }
 
         action_tasks = {
@@ -1036,6 +1137,7 @@ class TUI:
             'move': 'MOVE',
             'command': 'COMMAND',
             'consume': 'INTOXICATE',
+            'spin': 'SPIN',
         }
 
         curses.curs_set(False)  # hide cursor
@@ -1077,15 +1179,22 @@ class TUI:
                 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 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 != 'chat':
+            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':
@@ -1104,12 +1213,9 @@ class TUI:
                 self.send('LOGIN ' + quote(self.input_))
                 self.input_ = ""
             elif self.mode.name == 'enter_face' and key == '\n':
-                if len(self.input_) != 18:
-                    self.log_msg('? wrong input length, aborting')
-                else:
-                    self.send('PLAYER_FACE %s' % quote(self.input_))
-                self.input_ = ""
-                self.switch_mode('edit')
+                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':
                 pick_selectable('PICK_UP')
             elif self.mode.name == 'drop_thing' and key == '\n':
@@ -1202,14 +1308,13 @@ class TUI:
                     self.send('TASK:DOOR')
                 elif key == self.keys['consume'] and task_action_on('consume'):
                     self.send('TASK:INTOXICATE')
-                elif key == self.keys['install'] and task_action_on('install'):
-                    self.send('TASK:INSTALL')
                 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
@@ -1236,6 +1341,8 @@ class TUI:
                     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'):