Add psychedelics, move random colouring from drunkenness to tripping.

[plomrogue2] / rogue_chat_curses.py

diff --git a/rogue_chat_curses.py b/rogue_chat_curses.py
index bc3c40d8839bd953e8d4e7ba36db3291a8df79dc..ff559246fe1cbdf22aec2879a41ecf3b7ab3777a 100755 (executable)
--- a/rogue_chat_curses.py
+++ b/rogue_chat_curses.py
@@ -29,25 +29,40 @@ mode_helps = {
     'name_thing': {
         'short': 'name thing',
         'intro': '',
     'name_thing': {
         'short': 'name thing',
         'intro': '',

-        'long': 'Give name to/change name of thing here.'
+        'long': 'Give name to/change name of carried thing.'

     },
     'command_thing': {
     },
     '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': {
         '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.'
     },
         '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:',
     'admin_thing_protect': {
         'short': 'change thing protection',
         'intro': '@ enter thing protection character:',

-        'long': 'Change protection character for thing here.'
+        'long': 'Change protection character for carried thing.'
+    },
+    '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': {
     },
     '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.'
     },
         '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.'
     },


@@ -159,14 +174,16 @@ class PlomSocketClient(PlomSocket):
             pass  # we assume socket will be known as dead by now
 
 def cmd_TURN(game, n):
             pass  # we assume socket will be known as dead by now
 
 def cmd_TURN(game, n):

-    game.annotations = {}

     game.turn = n
     game.turn = n

-    game.things = []
-    game.portals = {}

     game.turn_complete = False
     game.turn_complete = False

-    game.fov = ''

 cmd_TURN.argtypes = 'int:nonneg'
 
 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')
 def cmd_LOGIN_OK(game):
     game.tui.switch_mode('post_login_wait')
     game.tui.send('GET_GAMESTATE')


@@ -190,45 +207,63 @@ def cmd_CHAT(game, msg):
     game.tui.do_refresh = True
 cmd_CHAT.argtypes = 'string'
 
     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_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, portable):
-    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)
     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
     t.portable = portable
     t.position = yx
     t.type_ = thing_type
     t.protection = protection
     t.portable = portable

-cmd_THING.argtypes = 'yx_tuple:nonneg string:thing_type char int:nonneg bool'
+    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):
 
 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):
 
 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]
 
 def cmd_MAP(game, geometry, size, content):
     map_geometry_class = globals()['MapGeometry' + geometry]

-    game.map_geometry = map_geometry_class(size)
-    game.map_content = content
-    if type(game.map_geometry) == MapGeometrySquare:
+    game.map_geometry_new = map_geometry_class(size)
+    game.map_content_new = content
+    if type(game.map_geometry_new) == MapGeometrySquare:

         game.tui.movement_keys = {
             game.tui.keys['square_move_up']: 'UP',
             game.tui.keys['square_move_left']: 'LEFT',
             game.tui.keys['square_move_down']: 'DOWN',
             game.tui.keys['square_move_right']: 'RIGHT',
         }
         game.tui.movement_keys = {
             game.tui.keys['square_move_up']: 'UP',
             game.tui.keys['square_move_left']: 'LEFT',
             game.tui.keys['square_move_down']: 'DOWN',
             game.tui.keys['square_move_right']: 'RIGHT',
         }

-    elif type(game.map_geometry) == MapGeometryHex:
+    elif type(game.map_geometry_new) == MapGeometryHex:

         game.tui.movement_keys = {
             game.tui.keys['hex_move_upleft']: 'UPLEFT',
             game.tui.keys['hex_move_upright']: 'UPRIGHT',
         game.tui.movement_keys = {
             game.tui.keys['hex_move_upleft']: 'UPLEFT',
             game.tui.keys['hex_move_upright']: 'UPRIGHT',


@@ -240,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):
 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):
 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):
 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.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):
 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_PORTAL.argtypes = 'yx_tuple:nonneg string'
 
 def cmd_PLAY_ERROR(game, msg):


@@ -276,7 +320,7 @@ def cmd_ARGUMENT_ERROR(game, msg):
 cmd_ARGUMENT_ERROR.argtypes = 'string'
 
 def cmd_ANNOTATION(game, position, 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'
     if game.tui.mode.shows_info:
         game.tui.do_refresh = True
 cmd_ANNOTATION.argtypes = 'yx_tuple:nonneg string'


@@ -286,6 +330,7 @@ def cmd_TASKS(game, tasks_comma_separated):
     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_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):
 cmd_TASKS.argtypes = 'string'
 
 def cmd_THING_TYPE(game, thing_type, symbol_hint):


@@ -293,12 +338,12 @@ def cmd_THING_TYPE(game, thing_type, symbol_hint):
 cmd_THING_TYPE.argtypes = 'string char'
 
 def cmd_THING_INSTALLED(game, thing_id):
 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'
 
 cmd_THING_INSTALLED.argtypes = 'int:pos'
 

-def cmd_THING_CARRYING(game, thing_id):
-    game.get_thing(thing_id).carrying = True
-cmd_THING_CARRYING.argtypes = 'int:pos'
+def cmd_THING_CARRYING(game, thing_id, carried_id):
+    game.get_thing_temp(thing_id).carrying = game.get_thing_temp(carried_id)
+cmd_THING_CARRYING.argtypes = 'int:pos int:pos'

 
 def cmd_TERRAIN(game, terrain_char, terrain_desc):
     game.terrains[terrain_char] = terrain_desc
 
 def cmd_TERRAIN(game, terrain_char, terrain_desc):
     game.terrains[terrain_char] = terrain_desc


@@ -320,6 +365,7 @@ class Game(GameBase):
     turn_complete = False
     tasks = {}
     thing_types = {}
     turn_complete = False
     tasks = {}
     thing_types = {}

+    things_new = []

 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)


@@ -327,13 +373,17 @@ class Game(GameBase):
         self.register_command(cmd_ADMIN_OK)
         self.register_command(cmd_PONG)
         self.register_command(cmd_CHAT)
         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_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)
         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_THING_CARRYING)
         self.register_command(cmd_THING_INSTALLED)
         self.register_command(cmd_TERRAIN)


@@ -342,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_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_ARGUMENT_ERROR)
         self.register_command(cmd_GAME_ERROR)
         self.register_command(cmd_PLAY_ERROR)


@@ -350,10 +401,14 @@ class Game(GameBase):
         self.register_command(cmd_DEFAULT_COLORS)
         self.register_command(cmd_RANDOM_COLORS)
         self.map_content = ''
         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.player_id = -1
         self.annotations = {}

+        self.annotations_new = {}

         self.portals = {}
         self.portals = {}

+        self.portals_new = {}

         self.terrains = {}
         self.terrains = {}

+        self.player = None

 
     def get_string_options(self, string_option_type):
         if string_option_type == 'map_geometry':
 
     def get_string_options(self, string_option_type):
         if string_option_type == 'map_geometry':


@@ -368,6 +423,12 @@ class Game(GameBase):
         f.argtypes = self.commands[command_name].argtypes
         return f
 
         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,
 class Mode:
 
     def __init__(self, name, has_input_prompt=False, shows_info=False,


@@ -429,6 +490,9 @@ class TUI:
     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_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
 
     is_admin = False
     tile_draw = False
 


@@ -436,10 +500,10 @@ class TUI:
         import os
         import json
         self.mode_play.available_modes = ["chat", "study", "edit", "admin_enter",
         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",
-                                            "install"]
+                                          "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_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",


@@ -449,10 +513,12 @@ 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_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()
         self.mode = None
         self.host = host
         self.game = Game()


@@ -481,12 +547,16 @@ class TUI:
             'switch_to_control_tile_type': 'Q',
             'switch_to_admin_thing_protect': 'T',
             'flatten': 'F',
             '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',
             'switch_to_take_thing': 'z',

-            'drop_thing': 'u',
+            'switch_to_drop_thing': 'u',

             'teleport': 'p',
             'consume': 'C',
             'door': 'D',
             'install': 'I',
             'teleport': 'p',
             'consume': 'C',
             'door': 'D',
             'install': 'I',

+            'wear': 'W',
+            'spin': 'S',

             'help': 'h',
             'toggle_map_mode': 'L',
             'toggle_tile_draw': 'm',
             'help': 'h',
             'toggle_map_mode': 'L',
             'toggle_tile_draw': 'm',


@@ -513,6 +583,8 @@ class TUI:
         self.fov = ''
         self.flash = False
         self.map_lines = []
         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)
 
         self.offset = YX(0,0)
         curses.wrapper(self.loop)
 


@@ -578,11 +650,18 @@ class TUI:
         elif self.mode.name == 'password':
             self.input_ = self.password
         elif self.mode.name == 'name_thing':
         elif self.mode.name == 'password':
             self.input_ = self.password
         elif self.mode.name == 'name_thing':

-            if hasattr(self.thing_selected, 'name'):
-                self.input_ = self.thing_selected.name
+            if hasattr(self.game.player.carrying, 'name'):
+                self.input_ = self.game.player.carrying.name

         elif self.mode.name == 'admin_thing_protect':
         elif self.mode.name == 'admin_thing_protect':

-            if hasattr(self.thing_selected, 'protection'):
-                self.input_ = self.thing_selected.protection
+            if hasattr(self.game.player.carrying, 'protection'):
+                self.input_ = self.game.player.carrying.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' %
 
     def send_tile_control_command(self):
         self.send('SET_TILE_CONTROL %s %s' %


@@ -599,24 +678,32 @@ class TUI:
             self.map_mode = 'terrain only'
 
     def switch_mode(self, mode_name):
             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.')
         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
         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 == 'name_thing' and not self.game.player.carrying:
+            return fail('not carrying anything to re-name')
+        if mode_name == 'admin_thing_protect' and not self.game.player.carrying:
+            return fail('not carrying anything to protect')
+        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'
         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_]:
-                thing = t
-                break
-            if not thing:
-                self.flash = True
-                self.log_msg('? not standing over thing')
-                return
-            else:
-                self.thing_selected = thing

         self.mode = getattr(self, 'mode_' + mode_name)
         if self.mode.name in {'control_tile_draw', 'control_tile_type',
                               'control_pw_type'}:
         self.mode = getattr(self, 'mode_' + mode_name)
         if self.mode.name in {'control_tile_draw', 'control_tile_type',
                               'control_pw_type'}:


@@ -624,8 +711,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':
         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:
         if self.mode.is_single_char_entry:
             self.show_help = True
         if len(self.mode.intro_msg) > 0:


@@ -637,27 +724,49 @@ class TUI:
                 self.log_msg('@ enter username')
         elif self.mode.name == 'take_thing':
             self.log_msg('Portable things in reach for pick-up:')
                 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)]
-            if type(self.game.map_geometry) == MapGeometryHex:
-                if player.position.y % 2:
-                    select_range += [player.position + YX(-1, 1),
-                                     player.position + YX(1, 1)]
+            directed_moves = {
+                'HERE': YX(0, 0), 'LEFT': YX(0, -1), 'RIGHT': YX(0, 1)
+            }
+            if type(self.game.map_geometry) == MapGeometrySquare:
+                directed_moves['UP'] = YX(-1, 0)
+                directed_moves['DOWN'] = YX(1, 0)
+            elif type(self.game.map_geometry) == MapGeometryHex:
+                if self.game.player.position.y % 2:
+                    directed_moves['UPLEFT'] = YX(-1, 0)
+                    directed_moves['UPRIGHT'] = YX(-1, 1)
+                    directed_moves['DOWNLEFT'] = YX(1, 0)
+                    directed_moves['DOWNRIGHT'] = YX(1, 1)

                 else:
                 else:

-                    select_range += [player.position + YX(-1, -1),
-                                     player.position + YX(1, -1)]
-            self.selectables = [t for t in self.game.things
-                                if t.portable and t.position in select_range]
+                    directed_moves['UPLEFT'] = YX(-1, -1)
+                    directed_moves['UPRIGHT'] = YX(-1, 0)
+                    directed_moves['DOWNLEFT'] = YX(1, -1)
+                    directed_moves['DOWNRIGHT'] = YX(1, 0)
+            select_range = {}
+            for direction in directed_moves:
+                move = directed_moves[direction]
+                select_range[direction] = self.game.player.position + move
+            self.selectables = []
+            directions = []
+            for direction in select_range:
+                for t in [t for t in self.game.things
+                          if t.portable and t.position == select_range[direction]]:
+                    self.selectables += [t.id_]
+                    directions += [direction]

             if len(self.selectables) == 0:
             if len(self.selectables) == 0:

-                self.log_msg('none')
+                return fail('nothing to pick-up')

             else:
                 for i in range(len(self.selectables)):
             else:
                 for i in range(len(self.selectables)):

-                    t = self.selectables[i]
-                    self.log_msg(str(i) + ': ' + self.get_thing_info(t))
+                    t = self.game.get_thing(self.selectables[i])
+                    self.log_msg('%s %s: %s' % (i, directions[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':
         elif self.mode.name == 'command_thing':
             self.send('TASK:COMMAND ' + quote('HELP'))
         elif self.mode.name == 'control_pw_pw':


@@ -690,6 +799,21 @@ class TUI:
         if len(self.game.fov) > pos_i and self.game.fov[pos_i] != '.':
             info_to_cache += 'outside field of view'
         else:
         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:
             terrain_char = self.game.map_content[pos_i]
             terrain_desc = '?'
             if terrain_char in self.game.terrains:


@@ -700,13 +824,6 @@ class TUI:
             if protection == '.':
                 protection = 'unprotected'
             info_to_cache += 'PROTECTION: %s\n' % protection
             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'
             if self.explorer in self.game.portals:
                 info_to_cache += 'PORTAL: ' +\
                     self.game.portals[self.explorer] + '\n'


@@ -777,7 +894,8 @@ class TUI:
             if not self.mode.has_input_prompt:
                 self.input_lines = []
             else:
             if not self.mode.has_input_prompt:
                 self.input_lines = []
             else:

-                self.input_lines = msg_into_lines_of_width(input_prompt + self.input_,
+                self.input_lines = msg_into_lines_of_width(input_prompt
+                                                           + self.input_ + '█',

                                                            self.window_width)
 
         def move_explorer(direction):
                                                            self.window_width)
 
         def move_explorer(direction):


@@ -831,7 +949,7 @@ class TUI:
                         'MODE: %s – %s' % (self.mode.short_desc, help))
 
         def draw_map():
                         '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 = []
                 return
             if self.game.turn_complete:
                 map_lines_split = []


@@ -869,11 +987,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)
                         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':
                 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 = []
                 if type(self.game.map_geometry) == MapGeometryHex:
                     indent = 0


@@ -885,7 +1003,7 @@ class TUI:
                         self.map_lines += [''.join(line)]
                 window_center = YX(int(self.size.y / 2),
                                    int(self.window_width / 2))
                         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)
                 if self.mode.shows_info or self.mode.name == 'control_tile_draw':
                     center = self.explorer
                 center = YX(center.y, center.x * 2)


@@ -896,12 +1014,35 @@ class TUI:
             term_x = max(0, -self.offset.x)
             map_y = max(0, self.offset.y)
             map_x = max(0, self.offset.x)
             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
 
                 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)
         def draw_help():
             content = "%s help\n\n%s\n\n" % (self.mode.short_desc,
                                              self.mode.help_intro)


@@ -950,6 +1091,36 @@ class TUI:
                 draw_map()
             if self.show_help:
                 draw_help()
                 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, must be 6; 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',
 
         action_descriptions = {
             'move': 'move',


@@ -959,9 +1130,11 @@ class TUI:
             'drop_thing': 'drop thing',
             'toggle_map_mode': 'toggle map view',
             'toggle_tile_draw': 'toggle protection character drawing',
             'drop_thing': 'drop thing',
             'toggle_map_mode': 'toggle map view',
             'toggle_tile_draw': 'toggle protection character drawing',

-            'install': 'install',
+            'install': '(un-)install',
+            'wear': '(un-)wear',

             'door': 'open/close',
             'consume': 'consume',
             'door': 'open/close',
             'consume': 'consume',

+            'spin': 'spin',

         }
 
         action_tasks = {
         }
 
         action_tasks = {


@@ -970,9 +1143,11 @@ class TUI:
             'drop_thing': 'DROP',
             'door': 'DOOR',
             'install': 'INSTALL',
             'drop_thing': 'DROP',
             'door': 'DOOR',
             'install': 'INSTALL',

+            'wear': 'WEAR',

             'move': 'MOVE',
             'command': 'COMMAND',
             'consume': 'INTOXICATE',
             'move': 'MOVE',
             'command': 'COMMAND',
             'consume': 'INTOXICATE',

+            'spin': 'SPIN',

         }
 
         curses.curs_set(False)  # hide cursor
         }
 
         curses.curs_set(False)  # hide cursor


@@ -1014,15 +1189,22 @@ class TUI:
                 self.do_refresh = True
             except curses.error:
                 continue
                 self.do_refresh = True
             except curses.error:
                 continue

+            keycode = None
+            if len(key) == 1:
+                keycode = ord(key)

             self.show_help = False
             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]
             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',
-                                        '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':
                     self.log_msg('@ aborted')
                 self.switch_mode('play')
             elif self.mode.has_input_prompt and key == '\n' and self.input_ == '/help':


@@ -1040,21 +1222,17 @@ class TUI:
                 self.login_name = self.input_
                 self.send('LOGIN ' + quote(self.input_))
                 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':
             elif self.mode.name == 'take_thing' and key == '\n':

-                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':
             elif self.mode.name == 'command_thing' and key == '\n':

-                if 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 == 'control_pw_pw' and key == '\n':
                 if self.input_ == '':
                     self.log_msg('@ aborted')


@@ -1081,8 +1259,7 @@ class TUI:
                 if len(self.input_) != 1:
                     self.log_msg('@ entered non-single-char, therefore aborted')
                 else:
                 if len(self.input_) != 1:
                     self.log_msg('@ entered non-single-char, therefore aborted')
                 else:

-                    self.send('THING_PROTECTION %s %s' % (self.thing_selected.id_,
-                                                          quote(self.input_)))
+                    self.send('THING_PROTECTION %s' % (quote(self.input_)))

                     self.log_msg('@ sent new protection character for thing')
                 self.switch_mode('admin')
             elif self.mode.name == 'control_tile_type' and key == '\n':
                     self.log_msg('@ sent new protection character for thing')
                 self.switch_mode('admin')
             elif self.mode.name == 'control_tile_type' and key == '\n':


@@ -1110,9 +1287,8 @@ class TUI:
             elif self.mode.name == 'name_thing' and key == '\n':
                 if self.input_ == '':
                     self.input_ = ' '
             elif self.mode.name == 'name_thing' and key == '\n':
                 if self.input_ == '':
                     self.input_ = ' '

-                self.send('THING_NAME %s %s %s' % (self.thing_selected.id_,
-                                                   quote(self.input_),
-                                                   quote(self.password)))
+                self.send('THING_NAME %s %s' % (quote(self.input_),
+                                                quote(self.password)))

                 self.switch_mode('edit')
             elif self.mode.name == 'annotate' and key == '\n':
                 if self.input_ == '':
                 self.switch_mode('edit')
             elif self.mode.name == 'annotate' and key == '\n':
                 if self.input_ == '':


@@ -1136,18 +1312,17 @@ class TUI:
             elif self.mode.name == 'play':
                 if self.mode.mode_switch_on_key(self, key):
                     continue
             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['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['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']:
                 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
                         self.reconnect()
                     else:
                         self.flash = True


@@ -1174,6 +1349,8 @@ class TUI:
                     continue
                 elif key == self.keys['flatten'] and task_action_on('flatten'):
                     self.send('TASK:FLATTEN_SURROUNDINGS ' + quote(self.password))
                     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'):
                 elif key == self.keys['toggle_map_mode']:
                     self.toggle_map_mode()
                 elif key in self.movement_keys and task_action_on('move'):