home · contact · privacy
Make sign design sizes variable.
[plomrogue2] / rogue_chat_curses.py
index d76c3bebd0b41622a41d3191b8db20836e989f8d..fd28049072a3fc62e9a310872ef242b935f91e68 100755 (executable)
@@ -29,35 +29,40 @@ mode_helps = {
     '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': {
-        '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..'
     },
     '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': 'enter your face',
-        'intro': '@ enter face line (enter nothing to abort):',
+        'short': 'edit face',
+        'intro': '@ enter face line:',
         '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_design': {
+        'short': 'edit design',
+        'intro': '@ enter design:',
+        'long': 'Enter design for carried thing as ASCII art.'
+    },
     '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,20 +174,21 @@ class PlomSocketClient(PlomSocket):
             pass  # we assume socket will be known as dead by now
 
 def cmd_TURN(game, n):
-    game.turn = n
     game.turn_complete = False
 cmd_TURN.argtypes = 'int:nonneg'
 
-def cmd_PSEUDO_FOV_WIPE(game):
+def cmd_OTHER_WIPE(game):
     game.portals_new = {}
     game.annotations_new = {}
     game.things_new = []
-cmd_PSEUDO_FOV_WIPE.argtypes = ''
+cmd_OTHER_WIPE.argtypes = ''
 
 def cmd_LOGIN_OK(game):
     game.tui.switch_mode('post_login_wait')
     game.tui.send('GET_GAMESTATE')
-    game.tui.log_msg('@ welcome')
+    game.tui.log_msg('@ welcome!')
+    game.tui.log_msg('@ hint: see top of terminal for how to get help.')
+    game.tui.log_msg('@ hint: enter study mode to understand your environment.')
 cmd_LOGIN_OK.argtypes = ''
 
 def cmd_ADMIN_OK(game):
@@ -211,6 +217,10 @@ 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_temp(thing_id)
     if not t:
@@ -238,6 +248,11 @@ def cmd_THING_HAT(game, thing_id, hat):
     t.hat = hat
 cmd_THING_HAT.argtypes = 'int:pos string'
 
+def cmd_THING_DESIGN(game, thing_id, size, design):
+    t = game.get_thing_temp(thing_id)
+    t.design = [size, design]
+cmd_THING_DESIGN.argtypes = 'int:pos yx_tuple string'
+
 def cmd_THING_CHAR(game, thing_id, c):
     t = game.get_thing_temp(thing_id)
     t.thing_char = c
@@ -247,14 +262,14 @@ def cmd_MAP(game, geometry, size, content):
     map_geometry_class = globals()['MapGeometry' + geometry]
     game.map_geometry_new = map_geometry_class(size)
     game.map_content_new = content
-    if type(game.map_geometry) == MapGeometrySquare:
+    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',
         }
-    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',
@@ -284,6 +299,9 @@ def cmd_GAME_STATE_COMPLETE(game):
     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.bladder_pressure = game.bladder_pressure_new
+    game.energy = game.energy_new
     game.turn_complete = True
     if game.tui.mode.name == 'post_login_wait':
         game.tui.switch_mode('play')
@@ -332,7 +350,7 @@ def cmd_THING_INSTALLED(game, thing_id):
 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)
+    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):
@@ -351,6 +369,11 @@ def cmd_RANDOM_COLORS(game):
     game.tui.set_random_colors()
 cmd_RANDOM_COLORS.argtypes = ''
 
+def cmd_STATS(game, bladder_pressure, energy):
+    game.bladder_pressure_new = bladder_pressure
+    game.energy_new = energy
+cmd_STATS.argtypes = 'int:nonneg int'
+
 class Game(GameBase):
     turn_complete = False
     tasks = {}
@@ -367,13 +390,14 @@ class Game(GameBase):
         self.register_command(cmd_REPLY)
         self.register_command(cmd_PLAYER_ID)
         self.register_command(cmd_TURN)
-        self.register_command(cmd_PSEUDO_FOV_WIPE)
+        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_DESIGN)
         self.register_command(cmd_THING_CARRYING)
         self.register_command(cmd_THING_INSTALLED)
         self.register_command(cmd_TERRAIN)
@@ -382,6 +406,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)
@@ -389,7 +414,9 @@ class Game(GameBase):
         self.register_command(cmd_FOV)
         self.register_command(cmd_DEFAULT_COLORS)
         self.register_command(cmd_RANDOM_COLORS)
+        self.register_command(cmd_STATS)
         self.map_content = ''
+        self.players_hat_chars = ''
         self.player_id = -1
         self.annotations = {}
         self.annotations_new = {}
@@ -480,6 +507,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_design = Mode('enter_design', has_input_prompt=True)
     is_admin = False
     tile_draw = False
 
@@ -490,18 +518,19 @@ class TUI:
                                           "command_thing", "take_thing",
                                           "drop_thing"]
         self.mode_play.available_actions = ["move", "teleport", "door", "consume",
-                                            "install", "wear", "spin"]
+                                            "install", "wear", "spin", "dance"]
         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",
                                            "control_tile_type", "chat",
                                            "study", "play", "edit"]
-        self.mode_admin.available_actions = ["move"]
+        self.mode_admin.available_actions = ["move", "toggle_map_mode"]
         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", "enter_face", "password",
+                                          "name_thing", "enter_face", "enter_design",
+                                          "password",
                                           "chat", "study", "play", "admin_enter"]
         self.mode_edit.available_actions = ["move", "flatten", "install",
                                             "toggle_map_mode"]
@@ -534,6 +563,7 @@ class TUI:
             'switch_to_admin_thing_protect': 'T',
             'flatten': 'F',
             'switch_to_enter_face': 'f',
+            'switch_to_enter_design': 'D',
             'switch_to_take_thing': 'z',
             'switch_to_drop_thing': 'u',
             'teleport': 'p',
@@ -542,6 +572,7 @@ class TUI:
             'install': 'I',
             'wear': 'W',
             'spin': 'S',
+            'dance': 'T',
             'help': 'h',
             'toggle_map_mode': 'L',
             'toggle_tile_draw': 'm',
@@ -568,6 +599,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)
 
@@ -633,11 +666,20 @@ class TUI:
         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':
-            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 == 'enter_face':
+            start = self.ascii_draw_stage * 6
+            end = (self.ascii_draw_stage + 1) * 6
+            self.input_ = self.game.player.face[start:end]
+        elif self.mode.name == 'enter_design':
+            width = self.game.player.carrying.design[0].x
+            start = self.ascii_draw_stage * width
+            end = (self.ascii_draw_stage + 1) * width
+            self.input_ = self.game.player.carrying.design[1][start:end]
 
     def send_tile_control_command(self):
         self.send('SET_TILE_CONTROL %s %s' %
@@ -668,23 +710,20 @@ class TUI:
            (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', 'edit')
+        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_design' and\
+           (not self.game.player.carrying or
+            not hasattr(self.game.player.carrying, 'design')):
+            return fail('not carrying designable 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 == self.game.player.position
-                      and t.id_ != self.game.player.id_]:
-                thing = t
-                break
-            if not thing:
-                return fail('not standing over thing', 'edit')
-            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'}:
@@ -705,32 +744,58 @@ class TUI:
                 self.log_msg('@ enter username')
         elif self.mode.name == 'take_thing':
             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:
+            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:
-                    select_range += [self.game.player.position + YX(-1, 1),
-                                     self.game.player.position + YX(1, 1)]
+                    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:
-                    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]
+                    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:
                 return fail('nothing to pick-up')
             else:
                 for i in range(len(self.selectables)):
                     t = self.game.get_thing(self.selectables[i])
-                    self.log_msg(str(i) + ': ' + self.get_thing_info(t))
+                    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_design':
+            if self.game.player.carrying.type_ == 'Hat':
+                self.log_msg('@ The design you enter must be %s lines of max %s '
+                             'characters width each'
+                             % (self.game.player.carrying.design[0].y,
+                                self.game.player.carrying.design[0].x))
+                self.log_msg('@ Legal characters: ' + self.game.players_hat_chars)
+                self.log_msg('@ (Eat cookies to extend the ASCII characters available for drawing.)')
+            else:
+                self.log_msg('@ Width of first line determines maximum width for remaining design')
+                self.log_msg('@ Finish design by entering an empty line (multiple space characters do not count as empty)')
         elif self.mode.name == 'command_thing':
             self.send('TASK:COMMAND ' + quote('HELP'))
         elif self.mode.name == 'control_pw_pw':
@@ -765,49 +830,72 @@ class TUI:
         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'
+                    info_to_cache += '%s' % self.get_thing_info(t, True)
             terrain_char = self.game.map_content[pos_i]
             terrain_desc = '?'
             if terrain_char in self.game.terrains:
                 terrain_desc = self.game.terrains[terrain_char]
-            info_to_cache += 'TERRAIN: "%s" / %s\n' % (terrain_char,
+            info_to_cache += 'TERRAIN: %s (%s' % (terrain_char,
                                                        terrain_desc)
             protection = self.game.map_control_content[pos_i]
-            if protection == '.':
-                protection = 'unprotected'
-            info_to_cache += 'PROTECTION: %s\n' % protection
+            if protection != '.':
+                info_to_cache += '/protection:%s' % protection
+            info_to_cache += ')\n'
             if self.explorer in self.game.portals:
                 info_to_cache += 'PORTAL: ' +\
                     self.game.portals[self.explorer] + '\n'
-            else:
-                info_to_cache += 'PORTAL: (none)\n'
             if self.explorer in self.game.annotations:
                 info_to_cache += 'ANNOTATION: ' +\
                     self.game.annotations[self.explorer]
         self.info_cached = info_to_cache
         return self.info_cached
 
-    def get_thing_info(self, t):
-        info = '%s / %s' %\
-            (t.type_, self.game.thing_types[t.type_])
+    def get_thing_info(self, t, detailed=False):
+        info = ''
+        if detailed:
+            info += '- '
+        info += self.game.thing_types[t.type_]
         if hasattr(t, 'thing_char'):
             info += t.thing_char
         if hasattr(t, 'name'):
-            info += ' (%s)' % t.name
+            info += ': %s' % t.name
+        info += ' (%s' % t.type_
         if hasattr(t, 'installed'):
-            info += ' / installed'
+            info += '/installed'
+        if t.type_ == 'Bottle':
+            if t.thing_char == '_':
+                info += '/empty'
+            elif t.thing_char == '~':
+                info += '/full'
+        if detailed:
+            protection = t.protection
+            if protection != '.':
+                info += '/protection:%s' % protection
+            info += ')\n'
+            if hasattr(t, 'hat') or hasattr(t, 'face'):
+                info += '----------\n'
+            if hasattr(t, 'hat'):
+                info += '| %s |\n' % t.hat[0:6]
+                info += '| %s |\n' % t.hat[6:12]
+                info += '| %s |\n' % t.hat[12:18]
+            if hasattr(t, 'face'):
+                info += '| %s |\n' % t.face[0:6]
+                info += '| %s |\n' % t.face[6:12]
+                info += '| %s |\n' % t.face[12:18]
+                info += '----------\n'
+            if hasattr(t, 'design'):
+                line_length = t.design[0].x
+                lines = []
+                for i in range(t.design[0].y):
+                    start = i * line_length
+                    end = (i + 1) * line_length
+                    lines += [t.design[1][start:end]]
+                info += '-' * (line_length + 4) + '\n'
+                for line in lines:
+                    info += '| %s |\n' % line
+                info += '-' * (line_length + 4) + '\n'
+        else:
+            info += ')'
         return info
 
     def loop(self, stdscr):
@@ -858,7 +946,8 @@ class TUI:
             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):
@@ -899,10 +988,10 @@ class TUI:
                 safe_addstr(y, self.window_width, self.input_lines[i])
                 y += 1
 
-        def draw_turn():
-            if not self.game.turn_complete:
-                return
-            safe_addstr(0, self.window_width, 'TURN: ' + str(self.game.turn))
+        def draw_stats():
+            stats = 'ENERGY: %s BLADDER: %s' % (self.game.energy,
+                                                self.game.bladder_pressure)
+            safe_addstr(0, self.window_width, stats)
 
         def draw_mode():
             help = "hit [%s] for help" % self.keys['help']
@@ -990,21 +1079,22 @@ class TUI:
                 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 - 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)
+                draw_body_part(t.face, self.size.y - 3)
             if hasattr(t, 'hat'):
-                draw_body_part(t.hat, self.size.y - 5)
-            safe_addstr(self.size.y - 1, start_x, '|        |')
+                draw_body_part(t.hat, self.size.y - 6)
+            safe_addstr(self.size.y - 2, start_x, '----------')
+            name = t.name[:]
+            if len(name) > 6:
+                name = name[:6] + '…'
+            safe_addstr(self.size.y - 1, start_x,
+                        '@%s:%s' % (t.thing_char, name))
 
         def draw_help():
             content = "%s help\n\n%s\n\n" % (self.mode.short_desc,
@@ -1050,7 +1140,7 @@ class TUI:
                 draw_history()
             draw_mode()
             if not self.mode.is_intro:
-                draw_turn()
+                draw_stats()
                 draw_map()
             if self.show_help:
                 draw_help()
@@ -1069,6 +1159,53 @@ class TUI:
             self.input_ = ''
             self.switch_mode('play')
 
+        def enter_ascii_art(command, height, width,
+                            with_pw=False, with_size=False):
+            if with_size and self.ascii_draw_stage == 0:
+                width = len(self.input_)
+                if width > 36:
+                    self.log_msg('? input too long, must be max 36; try again')
+                    # TODO: move max width mechanism server-side
+                    return
+                old_size = self.game.player.carrying.design[0]
+                if width != old_size.x:
+                    # TODO: save remaining design?
+                    self.game.player.carrying.design[1] = ''
+                    self.game.player.carrying.design[0] = YX(old_size.y, width)
+            elif len(self.input_) > width:
+                self.log_msg('? input too long, '
+                             'must be max %s; try again' % width)
+                return
+            self.log_msg('  ' + self.input_)
+            if with_size and self.input_ in {'', ' '}\
+               and self.ascii_draw_stage > 0:
+                height = self.ascii_draw_stage
+            else:
+                if with_size:
+                    height = self.ascii_draw_stage + 2
+                if len(self.input_) < width:
+                    self.input_ += ' ' * (width - len(self.input_))
+                self.full_ascii_draw += self.input_
+            if with_size:
+                old_size = self.game.player.carrying.design[0]
+                self.game.player.carrying.design[0] = YX(height, old_size.x)
+            self.ascii_draw_stage += 1
+            if self.ascii_draw_stage < height:
+                self.restore_input_values()
+            else:
+                if with_pw and with_size:
+                    self.send('%s_SIZE %s %s' % (command, YX(height, width),
+                                                 quote(self.password)))
+                if with_pw:
+                    self.send('%s %s %s' % (command, quote(self.full_ascii_draw),
+                                            quote(self.password)))
+                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',
@@ -1082,6 +1219,7 @@ class TUI:
             'door': 'open/close',
             'consume': 'consume',
             'spin': 'spin',
+            'dance': 'dance',
         }
 
         action_tasks = {
@@ -1095,6 +1233,7 @@ class TUI:
             'command': 'COMMAND',
             'consume': 'INTOXICATE',
             'spin': 'SPIN',
+            'dance': 'DANCE',
         }
 
         curses.curs_set(False)  # hide cursor
@@ -1105,6 +1244,7 @@ class TUI:
         reset_screen_size()
         self.explorer = YX(0, 0)
         self.input_ = ''
+        store_widechar = False
         input_prompt = '> '
         interval = datetime.timedelta(seconds=5)
         last_ping = datetime.datetime.now() - interval
@@ -1139,6 +1279,13 @@ class TUI:
             keycode = None
             if len(key) == 1:
                 keycode = ord(key)
+                # workaround for <https://stackoverflow.com/a/56390915>
+                if store_widechar:
+                    store_widechar = False
+                    key = bytes([195, keycode]).decode()
+                if keycode == 195:
+                    store_widechar = True
+                    continue
             self.show_help = False
             self.draw_face = False
             if key == 'KEY_RESIZE':
@@ -1170,12 +1317,17 @@ 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')
+                enter_ascii_art('PLAYER_FACE', 3, 6)
+            elif self.mode.name == 'enter_design' and key == '\n':
+                if self.game.player.carrying.type_ == 'Hat':
+                    enter_ascii_art('THING_DESIGN',
+                                    self.game.player.carrying.design[0].y,
+                                    self.game.player.carrying.design[0].x, True)
                 else:
-                    self.send('PLAYER_FACE %s' % quote(self.input_))
-                self.input_ = ""
-                self.switch_mode('edit')
+                    enter_ascii_art('THING_DESIGN',
+                                    self.game.player.carrying.design[0].y,
+                                    self.game.player.carrying.design[0].x,
+                                    True, True)
             elif self.mode.name == 'take_thing' and key == '\n':
                 pick_selectable('PICK_UP')
             elif self.mode.name == 'drop_thing' and key == '\n':
@@ -1209,8 +1361,7 @@ class TUI:
                 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':
@@ -1238,9 +1389,8 @@ class TUI:
             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_ == '':
@@ -1272,6 +1422,8 @@ class TUI:
                     self.send('TASK:WEAR')
                 elif key == self.keys['spin'] and task_action_on('spin'):
                     self.send('TASK:SPIN')
+                elif key == self.keys['dance'] and task_action_on('dance'):
+                    self.send('TASK:DANCE')
                 elif key == self.keys['teleport']:
                     if self.game.player.position in self.game.portals:
                         self.host = self.game.portals[self.game.player.position]
@@ -1294,6 +1446,8 @@ class TUI:
             elif self.mode.name == 'admin':
                 if self.mode.mode_switch_on_key(self, key):
                     continue
+                elif key == self.keys['toggle_map_mode']:
+                    self.toggle_map_mode()
                 elif key in self.movement_keys and task_action_on('move'):
                     self.send('TASK:MOVE ' + self.movement_keys[key])
             elif self.mode.name == 'edit':