#!/usr/bin/env python3
import curses
-import queue
-import threading
-import time
import sys
from plomrogue.game import GameBase
from plomrogue.parser import Parser
from plomrogue.mapping import YX, MapGeometrySquare, MapGeometryHex
from plomrogue.things import ThingBase
from plomrogue.misc import quote
-from plomrogue.errors import BrokenSocketConnection
+from plomrogue.errors import ArgError
+from plomrogue_client.socket import ClientSocket
+from plomrogue_client.tui import msg_into_lines_of_width, TUI
+
+
mode_helps = {
'play': {
'short': 'play',
- 'long': 'This mode allows you to interact with the map.'
+ 'intro': '',
+ 'long': 'This mode allows you to interact with the map in various ways.'
},
'study': {
'short': 'study',
- 'long': 'This mode allows you to study the map and its tiles in detail. Move the question mark over a tile, and the right half of the screen will show detailed information on it.'},
+ 'intro': '',
+ 'long': 'This mode allows you to study the map and its tiles in detail. Move the question mark over a tile, and the right half of the screen will show detailed information on it. Toggle the map view to show or hide different information layers.'},
'edit': {
- 'short': 'map edit',
- 'long': 'This mode allows you to change the map in various ways.'
+ 'short': 'world edit',
+ 'intro': '',
+ 'long': 'This mode allows you to change the game world in various ways. Individual map tiles can be protected by "protection characters", which you can see by toggling into the protections map view. You can edit a tile if you set the world edit password that matches its protection character. The character "." marks the absence of protection: Such tiles can always be edited.'
+ },
+ 'name_thing': {
+ 'short': 'name thing',
+ 'intro': '',
+ 'long': 'Give name to/change name of carried thing.'
+ },
+ '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',
+ 'intro': 'Pick up a thing in reach by entering its index number. Enter nothing to abort.',
+ 'long': 'You see a list of things which you could pick up. Enter the target thing\'s index, or, to leave, nothing.'
+ },
+ 'drop_thing': {
+ 'short': 'drop',
+ 'intro': 'Enter number of direction to which you want to drop thing.',
+ 'long': 'Drop currently carried thing by entering the target direction index. Enter nothing to return to play mode..'
+ },
+ 'admin_thing_protect': {
+ 'short': 'change thing protection',
+ 'intro': '@ enter thing protection character:',
+ 'long': 'Change protection character for carried thing.'
+ },
+ 'enter_face': {
+ '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': 'terrain write',
- 'long': 'This mode allows you to change the map tile you currently stand on (if your map editing password authorizes you so). Just enter any printable ASCII character to imprint it on the ground below you.'
+ '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.'
},
'control_pw_type': {
- 'short': 'change tiles control password',
- 'long': 'This mode is the first of two steps to change the password for a tile control character. First enter the tile control character for which you want to change the password.'
+ 'short': 'change protection character password',
+ 'intro': '@ enter protection character for which you want to change the password:',
+ 'long': 'This mode is the first of two steps to change the password for a protection character. First enter the protection character for which you want to change the password.'
},
'control_pw_pw': {
- 'short': 'change tiles control password',
- 'long': 'This mode is the second of two steps to change the password for a tile control character. Enter the new password for the tile control character you chose.'
+ 'short': 'change protection character password',
+ 'intro': '',
+ 'long': 'This mode is the second of two steps to change the password for a protection character. Enter the new password for the protection character you chose.'
},
'control_tile_type': {
- 'short': 'change tiles control',
- 'long': 'This mode is the first of two steps to change tile control areas on the map. First enter the tile control character you want to write.'
+ 'short': 'change tiles protection',
+ 'intro': '@ enter protection character which you want to draw:',
+ 'long': 'This mode is the first of two steps to change tile protection areas on the map. First enter the tile protection character you want to write.'
},
'control_tile_draw': {
- 'short': 'change tiles control',
- 'long': 'This mode is the second of two steps to change tile control areas on the map. Toggle tile control drawing on, then move cursor around the map to draw selected tile control character.'
+ 'short': 'change tiles protection',
+ 'intro': '',
+ 'long': 'This mode is the second of two steps to change tile protection areas on the map. Toggle tile protection drawing on/off and move the ?? cursor around the map to draw the selected protection character.'
},
'annotate': {
'short': 'annotate tile',
- 'long': 'This mode allows you to add/edit a comment on the tile you are currently standing on (provided your map editing password authorizes you so). Hit Return to leave.'
+ 'intro': '',
+ 'long': 'This mode allows you to add/edit a comment on the tile you are currently standing on (provided your world editing password authorizes you so). Hit Return to leave.'
},
'portal': {
'short': 'edit portal',
- 'long': 'This mode allows you to imprint/edit/remove a teleportation target on the ground you are currently standing on (provided your map editing password authorizes you so). Enter or edit a URL to imprint a teleportation target; enter emptiness to remove a pre-existing teleportation target. Hit Return to leave.'
+ 'intro': '',
+ 'long': 'This mode allows you to imprint/edit/remove a teleportation target on the ground you are currently standing on (provided your world editing password authorizes you so). Enter or edit a URL to imprint a teleportation target; enter emptiness to remove a pre-existing teleportation target. Hit Return to leave.'
},
'chat': {
'short': 'chat',
- 'long': 'This mode allows you to engage in chit-chat with other users. Any line you enter into the input prompt that does not start with a "/" will be sent out to nearby players – but barriers and distance will reduce what they can read, so stand close to them to ensure they get your message. Lines that start with a "/" are used for commands like:'
+ 'intro': '',
+ 'long': 'This mode allows you to engage in chit-chat with other users. Any line you enter into the input prompt that does not start with a "/" will be sent out to nearby players – but barriers and distance will reduce what they can read, so stand close to them to ensure they get your message. Lines that start with a "/" are used for commands like:\n\n/nick NAME – re-name yourself to NAME'
},
'login': {
'short': 'login',
- 'long': 'Pick your player name.'
+ 'intro': '',
+ 'long': 'Enter your player name.'
},
'waiting_for_server': {
'short': 'waiting for server response',
+ 'intro': '@ waiting for server …',
'long': 'Waiting for a server response.'
},
'post_login_wait': {
'short': 'waiting for server response',
+ 'intro': '',
'long': 'Waiting for a server response.'
},
'password': {
- 'short': 'map edit password',
- 'long': 'This mode allows you to change the password that you send to authorize yourself for editing password-protected map tiles. Hit return to confirm and leave.'
+ 'short': 'set world edit password',
+ 'intro': '',
+ 'long': 'This mode allows you to change the password that you send to authorize yourself for editing password-protected elements of the world. Hit return to confirm and leave.'
},
'admin_enter': {
'short': 'become admin',
+ 'intro': '@ enter admin password:',
'long': 'This mode allows you to become admin if you know an admin password.'
},
'admin': {
'short': 'admin',
+ 'intro': '',
'long': 'This mode allows you access to actions limited to administrators.'
}
}
-from ws4py.client import WebSocketBaseClient
-class WebSocketClient(WebSocketBaseClient):
-
- def __init__(self, recv_handler, *args, **kwargs):
- super().__init__(*args, **kwargs)
- self.recv_handler = recv_handler
- self.connect()
-
- def received_message(self, message):
- if message.is_text:
- message = str(message)
- self.recv_handler(message)
-
- @property
- def plom_closed(self):
- return self.client_terminated
-
-from plomrogue.io_tcp import PlomSocket
-class PlomSocketClient(PlomSocket):
-
- def __init__(self, recv_handler, url):
- import socket
- self.recv_handler = recv_handler
- host, port = url.split(':')
- super().__init__(socket.create_connection((host, port)))
-
- def close(self):
- self.socket.close()
-
- def run(self):
- import ssl
- try:
- for msg in self.recv():
- if msg == 'NEED_SSL':
- self.socket = ssl.wrap_socket(self.socket)
- continue
- self.recv_handler(msg)
- except BrokenSocketConnection:
- pass # we assume socket will be known as dead by now
-
def cmd_TURN(game, n):
- game.info_db = {}
- game.info_hints = []
- game.turn = n
- game.things = []
- game.portals = {}
game.turn_complete = False
cmd_TURN.argtypes = 'int:nonneg'
+def cmd_OTHER_WIPE(game):
+ game.portals_new = {}
+ game.annotations_new = {}
+ game.things_new = []
+cmd_OTHER_WIPE.argtypes = ''
+
def cmd_LOGIN_OK(game):
game.tui.switch_mode('post_login_wait')
game.tui.send('GET_GAMESTATE')
- game.tui.log_msg('@ welcome')
+ game.tui.log_msg('@ welcome!')
cmd_LOGIN_OK.argtypes = ''
def cmd_ADMIN_OK(game):
game.tui.do_refresh = True
cmd_ADMIN_OK.argtypes = ''
+def cmd_REPLY(game, msg):
+ game.tui.log_msg('#MUSICPLAYER: ' + msg)
+ game.tui.do_refresh = True
+cmd_REPLY.argtypes = 'string'
+
def cmd_CHAT(game, msg):
game.tui.log_msg('# ' + 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_THING(game, yx, thing_type, thing_id):
- t = game.get_thing(thing_id)
+def cmd_PLAYERS_HAT_CHARS(game, hat_chars):
+ game.players_hat_chars_new = hat_chars
+cmd_PLAYERS_HAT_CHARS.argtypes = 'string'
+
+def cmd_THING(game, yx, thing_type, protection, thing_id, portable, commandable):
+ t = game.get_thing_temp(thing_id)
if not t:
t = ThingBase(game, thing_id)
- game.things += [t]
+ game.things_new += [t]
t.position = yx
t.type_ = thing_type
-cmd_THING.argtypes = 'yx_tuple:nonneg string:thing_type int:nonneg'
+ t.protection = protection
+ t.portable = portable
+ t.commandable = commandable
+cmd_THING.argtypes = 'yx_tuple:nonneg string:thing_type char int:nonneg bool bool'
def cmd_THING_NAME(game, thing_id, name):
- t = game.get_thing(thing_id)
- if t:
- t.name = name
-cmd_THING_NAME.argtypes = 'int:nonneg string'
+ t = game.get_thing_temp(thing_id)
+ t.name = name
+cmd_THING_NAME.argtypes = 'int:pos string'
+
+def cmd_THING_FACE(game, thing_id, face):
+ t = game.get_thing_temp(thing_id)
+ t.face = face
+cmd_THING_FACE.argtypes = 'int:pos string'
+
+def cmd_THING_HAT(game, thing_id, hat):
+ t = game.get_thing_temp(thing_id)
+ t.hat = hat
+cmd_THING_HAT.argtypes = 'int:pos string'
+
+def cmd_THING_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(thing_id)
- if t:
- t.player_char = c
-cmd_THING_CHAR.argtypes = 'int:nonneg char'
+ t = game.get_thing_temp(thing_id)
+ t.thing_char = c
+cmd_THING_CHAR.argtypes = 'int:pos char'
def cmd_MAP(game, geometry, size, content):
map_geometry_class = globals()['MapGeometry' + geometry]
- game.map_geometry = map_geometry_class(size)
- game.map_content = content
- 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',
}
- 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',
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):
+ 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.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')
- if game.tui.mode.shows_info:
- game.tui.query_info()
- game.turn_complete = True
- game.tui.do_refresh = True
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):
game.tui.do_refresh = True
cmd_ARGUMENT_ERROR.argtypes = 'string'
-def cmd_ANNOTATION_HINT(game, position):
- game.info_hints += [position]
-cmd_ANNOTATION_HINT.argtypes = 'yx_tuple:nonneg'
-
def cmd_ANNOTATION(game, position, msg):
- game.info_db[position] = msg
- game.tui.restore_input_values()
+ game.annotations_new[position] = msg
if game.tui.mode.shows_info:
game.tui.do_refresh = True
cmd_ANNOTATION.argtypes = 'yx_tuple:nonneg string'
def cmd_TASKS(game, tasks_comma_separated):
game.tasks = tasks_comma_separated.split(',')
game.tui.mode_write.legal = 'WRITE' in game.tasks
+ game.tui.mode_command_thing.legal = 'COMMAND' in game.tasks
+ game.tui.mode_take_thing.legal = 'PICK_UP' in game.tasks
+ game.tui.mode_drop_thing.legal = 'DROP' in game.tasks
cmd_TASKS.argtypes = 'string'
def cmd_THING_TYPE(game, thing_type, symbol_hint):
game.thing_types[thing_type] = symbol_hint
cmd_THING_TYPE.argtypes = 'string char'
+def cmd_THING_INSTALLED(game, thing_id):
+ game.get_thing_temp(thing_id).installed = True
+cmd_THING_INSTALLED.argtypes = 'int:pos'
+
+def cmd_THING_CARRYING(game, thing_id, carried_id):
+ game.get_thing_temp(thing_id).carrying = game.get_thing_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
cmd_TERRAIN.argtypes = 'char string'
pass
cmd_PONG.argtypes = ''
+def cmd_DEFAULT_COLORS(game):
+ game.tui.set_default_colors()
+cmd_DEFAULT_COLORS.argtypes = ''
+
+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 = {}
thing_types = {}
+ things_new = []
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.register_command(cmd_ADMIN_OK)
self.register_command(cmd_PONG)
self.register_command(cmd_CHAT)
+ self.register_command(cmd_CHATFACE)
+ self.register_command(cmd_REPLY)
self.register_command(cmd_PLAYER_ID)
self.register_command(cmd_TURN)
+ self.register_command(cmd_OTHER_WIPE)
self.register_command(cmd_THING)
self.register_command(cmd_THING_TYPE)
self.register_command(cmd_THING_NAME)
self.register_command(cmd_THING_CHAR)
+ self.register_command(cmd_THING_FACE)
+ self.register_command(cmd_THING_HAT)
+ self.register_command(cmd_THING_DESIGN)
+ self.register_command(cmd_THING_CARRYING)
+ self.register_command(cmd_THING_INSTALLED)
self.register_command(cmd_TERRAIN)
self.register_command(cmd_MAP)
self.register_command(cmd_MAP_CONTROL)
self.register_command(cmd_PORTAL)
self.register_command(cmd_ANNOTATION)
- self.register_command(cmd_ANNOTATION_HINT)
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_TASKS)
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.info_db = {}
- self.info_hints = []
+ self.annotations = {}
+ self.annotations_new = {}
self.portals = {}
+ self.portals_new = {}
self.terrains = {}
+ self.player = None
def get_string_options(self, string_option_type):
if string_option_type == 'map_geometry':
f.argtypes = self.commands[command_name].argtypes
return f
+ def get_thing_temp(self, id_):
+ for thing in self.things_new:
+ if id_ == thing.id_:
+ return thing
+ return None
+
class Mode:
def __init__(self, name, has_input_prompt=False, shows_info=False,
self.name = name
self.short_desc = mode_helps[name]['short']
self.available_modes = []
+ self.available_actions = []
self.has_input_prompt = has_input_prompt
self.shows_info = shows_info
self.is_intro = is_intro
self.help_intro = mode_helps[name]['long']
+ self.intro_msg = mode_helps[name]['intro']
self.is_single_char_entry = is_single_char_entry
self.legal = True
return True
return False
-class TUI:
+class RogueChatTUI(TUI):
mode_admin_enter = Mode('admin_enter', has_input_prompt=True)
mode_admin = Mode('admin')
mode_play = Mode('play')
mode_control_pw_pw = Mode('control_pw_pw', has_input_prompt=True)
mode_control_tile_type = Mode('control_tile_type', has_input_prompt=True)
mode_control_tile_draw = Mode('control_tile_draw')
+ mode_admin_thing_protect = Mode('admin_thing_protect', has_input_prompt=True)
mode_annotate = Mode('annotate', has_input_prompt=True, shows_info=True)
mode_portal = Mode('portal', has_input_prompt=True, shows_info=True)
mode_chat = Mode('chat', has_input_prompt=True)
mode_login = Mode('login', has_input_prompt=True, is_intro=True)
mode_post_login_wait = Mode('post_login_wait', is_intro=True)
mode_password = Mode('password', 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_design = Mode('enter_design', has_input_prompt=True)
is_admin = False
tile_draw = False
- def __init__(self, host):
+ def __init__(self, host, *args, **kwargs):
import os
import json
- self.mode_play.available_modes = ["chat", "study", "edit", "admin_enter"]
+ self.mode_play.available_modes = ["chat", "study", "edit", "admin_enter",
+ "command_thing", "take_thing",
+ "drop_thing"]
+ self.mode_play.available_actions = ["move", "teleport", "door", "consume",
+ "install", "wear", "spin", "dance"]
self.mode_study.available_modes = ["chat", "play", "admin_enter", "edit"]
- self.mode_admin.available_modes = ["control_pw_type",
+ 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", "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",
- "password", "chat", "study", "play",
- "admin_enter"]
- self.host = host
+ "name_thing", "enter_face", "enter_design",
+ "password",
+ "chat", "study", "play", "admin_enter"]
+ self.mode_edit.available_actions = ["move", "flatten", "install",
+ "toggle_map_mode"]
+ self.mode = None
+ self.socket = ClientSocket(host, self.socket_log)
self.game = Game()
self.game.tui = self
self.parser = Parser(self.game)
- self.log = []
self.do_refresh = True
- self.queue = queue.Queue()
self.login_name = None
self.map_mode = 'terrain + things'
self.password = 'foo'
- self.switch_mode('waiting_for_server')
self.keys = {
'switch_to_chat': 't',
'switch_to_play': 'p',
'switch_to_study': '?',
'switch_to_edit': 'E',
'switch_to_write': 'm',
+ 'switch_to_name_thing': 'N',
+ 'switch_to_command_thing': 'O',
'switch_to_admin_enter': 'A',
'switch_to_control_pw_type': 'C',
'switch_to_control_tile_type': 'Q',
+ 'switch_to_admin_thing_protect': 'T',
'flatten': 'F',
- 'take_thing': 'z',
- 'drop_thing': 'u',
+ 'switch_to_enter_face': 'f',
+ 'switch_to_enter_design': 'D',
+ 'switch_to_take_thing': 'z',
+ 'switch_to_drop_thing': 'u',
'teleport': 'p',
+ 'consume': 'C',
+ 'door': 'D',
+ 'install': 'I',
+ 'wear': 'W',
+ 'spin': 'S',
+ 'dance': 'T',
'help': 'h',
- 'toggle_map_mode': 'M',
+ 'toggle_map_mode': 'L',
'toggle_tile_draw': 'm',
'hex_move_upleft': 'w',
'hex_move_upright': 'e',
for k in keys_conf:
self.keys[k] = keys_conf[k]
self.show_help = False
- self.disconnected = True
- self.force_instant_connect = True
self.input_lines = []
self.fov = ''
self.flash = False
- curses.wrapper(self.loop)
-
- def connect(self):
-
- def handle_recv(msg):
- if msg == 'BYE':
- self.socket.close()
- else:
- self.queue.put(msg)
+ self.map_lines = []
+ self.ascii_draw_stage = 0
+ self.full_ascii_draw = ''
+ self.offset = YX(0,0)
+ self.explorer = YX(0, 0)
+ self.input_ = ''
+ self.store_widechar = False
+ self.input_prompt = '> '
+ self.action_descriptions = {
+ 'move': 'move',
+ 'flatten': 'flatten surroundings',
+ 'teleport': 'teleport',
+ 'take_thing': 'pick up thing',
+ 'drop_thing': 'drop thing',
+ 'toggle_map_mode': 'toggle map view',
+ 'toggle_tile_draw': 'toggle protection character drawing',
+ 'install': '(un-)install',
+ 'wear': '(un-)wear',
+ 'door': 'open/close',
+ 'consume': 'consume',
+ 'spin': 'spin',
+ 'dance': 'dance',
+ }
+ self.action_tasks = {
+ 'flatten': 'FLATTEN_SURROUNDINGS',
+ 'take_thing': 'PICK_UP',
+ 'drop_thing': 'DROP',
+ 'door': 'DOOR',
+ 'install': 'INSTALL',
+ 'wear': 'WEAR',
+ 'move': 'MOVE',
+ 'command': 'COMMAND',
+ 'consume': 'INTOXICATE',
+ 'spin': 'SPIN',
+ 'dance': 'DANCE',
+ }
+ super().__init__(*args, **kwargs)
- self.log_msg('@ attempting connect')
- socket_client_class = PlomSocketClient
- if self.host.startswith('ws://') or self.host.startswith('wss://'):
- socket_client_class = WebSocketClient
- try:
- self.socket = socket_client_class(handle_recv, self.host)
- self.socket_thread = threading.Thread(target=self.socket.run)
- self.socket_thread.start()
- self.disconnected = False
- self.game.thing_types = {}
- self.game.terrains = {}
- self.socket.send('TASKS')
- self.socket.send('TERRAINS')
- self.socket.send('THING_TYPES')
- self.switch_mode('login')
- except ConnectionRefusedError:
- self.log_msg('@ server connect failure')
- self.disconnected = True
- self.switch_mode('waiting_for_server')
- self.do_refresh = True
+ def update_on_connect(self):
+ self.socket.send('TASKS')
+ self.socket.send('TERRAINS')
+ self.socket.send('THING_TYPES')
+ self.switch_mode('login')
def reconnect(self):
- self.log_msg('@ attempting reconnect')
- self.send('QUIT')
- time.sleep(0.1) # FIXME necessitated by some some strange SSL race
- # conditions with ws4py, find out what exactly
+ import time
+ self.log('@ attempting reconnect')
+ self.socket.send('QUIT')
+ # necessitated by some strange SSL race conditions with ws4py
+ time.sleep(0.1) # FIXME find out why exactly necessary
self.switch_mode('waiting_for_server')
- self.connect()
+ self.socket.connect()
+ self.update_on_connect()
def send(self, msg):
- try:
- if hasattr(self.socket, 'plom_closed') and self.socket.plom_closed:
- raise BrokenSocketConnection
- self.socket.send(msg)
- except (BrokenPipeError, BrokenSocketConnection):
- self.log_msg('@ server disconnected :(')
- self.disconnected = True
- self.force_instant_connect = True
+ self.socket.send(msg)
+ if self.socket.disconnected:
self.do_refresh = True
- def log_msg(self, msg):
- self.log += [msg]
- if len(self.log) > 100:
- self.log = self.log[-100:]
+ def socket_log(self, msg):
+ self.log('@ ' + msg)
- def query_info(self):
- self.send('GET_ANNOTATION ' + str(self.explorer))
+ def log_msg(self, msg):
+ super().log(msg)
+ #self.log += [msg]
+ if len(self._log) > 100:
+ self.log = self._log[-100:]
def restore_input_values(self):
- if self.mode.name == 'annotate' and self.explorer in self.game.info_db:
- info = self.game.info_db[self.explorer]
- if info != '(none)':
- self.input_ = info
+ if self.mode.name == 'annotate' and self.explorer in self.game.annotations:
+ self.input_ = self.game.annotations[self.explorer]
elif self.mode.name == 'portal' and self.explorer in self.game.portals:
self.input_ = self.game.portals[self.explorer]
elif self.mode.name == 'password':
self.input_ = self.password
+ elif self.mode.name == 'name_thing':
+ if hasattr(self.game.player.carrying, 'name'):
+ self.input_ = self.game.player.carrying.name
+ elif self.mode.name == 'admin_thing_protect':
+ 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' %
(self.explorer, quote(self.tile_control_char)))
+ def toggle_map_mode(self):
+ if self.map_mode == 'terrain only':
+ self.map_mode = 'terrain + annotations'
+ elif self.map_mode == 'terrain + annotations':
+ self.map_mode = 'terrain + things'
+ elif self.map_mode == 'terrain + things':
+ self.map_mode = 'protections'
+ elif self.map_mode == 'protections':
+ self.map_mode = 'terrain only'
+
def switch_mode(self, mode_name):
- self.map_mode = 'terrain + things'
+
+ def fail(msg, return_mode='play'):
+ self.log('? ' + msg)
+ self.flash = True
+ self.switch_mode(return_mode)
+
+ if self.mode and self.mode.name == 'control_tile_draw':
+ self.log('@ finished tile protection drawing.')
+ self.draw_face = False
self.tile_draw = False
+ self.ascii_draw_stage = 0
+ self.full_ascii_draw = ''
+ 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', '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'
self.mode = getattr(self, 'mode_' + mode_name)
+ if self.mode.name in {'control_tile_draw', 'control_tile_type',
+ 'control_pw_type'}:
+ self.map_mode = 'protections'
+ 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)
- if self.mode.shows_info:
- self.query_info()
+ 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 self.mode.name == 'waiting_for_server':
- self.log_msg('@ waiting for server …')
- elif self.mode.name == 'login':
+ if len(self.mode.intro_msg) > 0:
+ self.log(self.mode.intro_msg)
+ if self.mode.name == 'login':
if self.login_name:
self.send('LOGIN ' + quote(self.login_name))
else:
- self.log_msg('@ enter username')
- elif self.mode.name == 'admin_enter':
- self.log_msg('@ enter admin password:')
- elif self.mode.name == 'control_pw_type':
- self.log_msg('@ enter tile control character for which you want to change the password:')
- elif self.mode.name == 'control_tile_type':
- self.log_msg('@ enter tile control character which you want to draw:')
+ self.log('@ enter username')
+ elif self.mode.name == 'take_thing':
+ self.log('Portable things in reach for pick-up:')
+ 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:
+ 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('%s %s: %s' % (i, directions[i],
+ self.get_thing_info(t)))
+ elif self.mode.name == 'drop_thing':
+ self.log('Direction to drop thing to:')
+ self.selectables =\
+ ['HERE'] + list(self.game.tui.movement_keys.values())
+ for i in range(len(self.selectables)):
+ self.log(str(i) + ': ' + self.selectables[i])
+ elif self.mode.name == 'enter_design':
+ if self.game.player.carrying.type_ == 'Hat':
+ self.log('@ 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('@ Legal characters: ' + self.game.players_hat_chars)
+ self.log('@ (Eat cookies to extend the ASCII characters available for drawing.)')
+ else:
+ self.log('@ Width of first line determines maximum width for remaining design')
+ self.log('@ 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':
- self.log_msg('@ enter tile control password for "%s":' % self.tile_control_char)
+ self.log('@ enter protection password for "%s":' % self.tile_control_char)
elif self.mode.name == 'control_tile_draw':
- self.log_msg('@ can draw tile control character "%s", turn drawing on/off with [%s], finish with [%s].' % (self.tile_control_char, self.keys['toggle_tile_draw'], self.keys['switch_to_admin_enter']))
+ self.log('@ can draw protection character "%s", turn drawing on/off with [%s], finish with [%s].' % (self.tile_control_char, self.keys['toggle_tile_draw'], self.keys['switch_to_admin_enter']))
self.input_ = ""
self.restore_input_values()
- def loop(self, stdscr):
- import datetime
+ def set_default_colors(self):
+ if curses.can_change_color():
+ curses.init_color(7, 1000, 1000, 1000)
+ curses.init_color(0, 0, 0, 0)
+ self.do_refresh = True
+
+ def set_random_colors(self):
- def safe_addstr(y, x, line):
- if y < self.size.y - 1 or x + len(line) < self.size.x:
- stdscr.addstr(y, x, line)
- else: # workaround to <https://stackoverflow.com/q/7063128>
- cut_i = self.size.x - x - 1
- cut = line[:cut_i]
- last_char = line[cut_i]
- stdscr.addstr(y, self.size.x - 2, last_char)
- stdscr.insstr(y, self.size.x - 2, ' ')
- stdscr.addstr(y, x, cut)
+ def rand(offset):
+ import random
+ return int(offset + random.random()*375)
+
+ if curses.can_change_color():
+ curses.init_color(7, rand(625), rand(625), rand(625))
+ curses.init_color(0, rand(0), rand(0), rand(0))
+ self.do_refresh = True
+
+ def get_info(self):
+ if self.info_cached:
+ return self.info_cached
+ pos_i = self.explorer.y * self.game.map_geometry.size.x + self.explorer.x
+ info_to_cache = ''
+ 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 += '%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' % (terrain_char,
+ terrain_desc)
+ protection = self.game.map_control_content[pos_i]
+ 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'
+ 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, 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.type_
+ if hasattr(t, '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 reset_size(self):
+ super().reset_size()
+ self.left_window_width = min(52, int(self.size.x / 2))
+ self.right_window_width = self.size.x - self.left_window_width
+
+ def addstr(self, y, x, line, ignore=None):
+ super().addstr(y, x, line, curses.color_pair(1))
+
+ def init_loop(self):
+ self.switch_mode('waiting_for_server')
+ curses.start_color()
+ self.set_default_colors()
+ curses.init_pair(1, 7, 0)
+ if not curses.can_change_color():
+ self.log('@ unfortunately, your terminal does not seem to '
+ 'support re-definition of colors; you might miss out '
+ 'on some color effects')
+ super().init_loop()
+
+ def loop(self):
def handle_input(msg):
command, args = self.parser.parse(msg)
command(*args)
- def msg_into_lines_of_width(msg, width):
- chunk = ''
- lines = []
- x = 0
- for i in range(len(msg)):
- if x >= width or msg[i] == "\n":
- lines += [chunk]
- chunk = ''
- x = 0
- if msg[i] == "\n":
- x -= 1
- if msg[i] != "\n":
- chunk += msg[i]
- x += 1
- lines += [chunk]
- return lines
-
- def reset_screen_size():
- self.size = YX(*stdscr.getmaxyx())
- self.size = self.size - YX(self.size.y % 4, 0)
- self.size = self.size - YX(0, self.size.x % 4)
- self.window_width = int(self.size.x / 2)
+ def task_action_on(action):
+ return self.action_tasks[action] in self.game.tasks
def recalc_input_lines():
if not self.mode.has_input_prompt:
self.input_lines = []
else:
- self.input_lines = msg_into_lines_of_width(input_prompt + self.input_,
- self.window_width)
+ self.input_lines = msg_into_lines_of_width(self.input_prompt
+ + self.input_ + '█',
+ self.right_window_width)
def move_explorer(direction):
target = self.game.map_geometry.move_yx(self.explorer, direction)
if target:
+ self.info_cached = None
self.explorer = target
- if self.mode.shows_info:
- self.query_info()
if self.tile_draw:
self.send_tile_control_command()
else:
def draw_history():
lines = []
- for line in self.log:
- lines += msg_into_lines_of_width(line, self.window_width)
+ for line in self._log:
+ lines += msg_into_lines_of_width(line, self.right_window_width)
lines.reverse()
height_header = 2
max_y = self.size.y - len(self.input_lines)
for i in range(len(lines)):
if (i >= max_y - height_header):
break
- safe_addstr(max_y - i - 1, self.window_width, lines[i])
+ self.addstr(max_y - i - 1, self.left_window_width, lines[i])
def draw_info():
- if not self.game.turn_complete:
- return
- pos_i = self.explorer.y * self.game.map_geometry.size.x + self.explorer.x
- info = 'MAP VIEW: %s\n' % self.map_mode
- if self.game.fov[pos_i] != '.':
- info += 'outside field of view'
- else:
- 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 += 'TERRAIN: "%s" / %s\n' % (terrain_char, terrain_desc)
- protection = self.game.map_control_content[pos_i]
- if protection == '.':
- protection = 'unprotected'
- info += 'PROTECTION: %s\n' % protection
- for t in self.game.things:
- if t.position == self.explorer:
- info += 'THING: %s / %s' % (t.type_,
- self.game.thing_types[t.type_])
- if hasattr(t, 'player_char'):
- info += t.player_char
- if hasattr(t, 'name'):
- info += ' (%s)' % t.name
- info += '\n'
- if self.explorer in self.game.portals:
- info += 'PORTAL: ' + self.game.portals[self.explorer] + '\n'
- else:
- info += 'PORTAL: (none)\n'
- if self.explorer in self.game.info_db:
- info += 'ANNOTATION: ' + self.game.info_db[self.explorer]
- else:
- info += 'ANNOTATION: waiting …'
- lines = msg_into_lines_of_width(info, self.window_width)
+ info = 'MAP VIEW: %s\n%s' % (self.map_mode, self.get_info())
+ lines = msg_into_lines_of_width(info, self.right_window_width)
height_header = 2
for i in range(len(lines)):
y = height_header + i
if y >= self.size.y - len(self.input_lines):
break
- safe_addstr(y, self.window_width, lines[i])
+ self.addstr(y, self.left_window_width, lines[i])
def draw_input():
y = self.size.y - len(self.input_lines)
for i in range(len(self.input_lines)):
- safe_addstr(y, self.window_width, self.input_lines[i])
+ self.addstr(y, self.left_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)
+ self.addstr(0, self.left_window_width, stats)
def draw_mode():
help = "hit [%s] for help" % self.keys['help']
if self.mode.has_input_prompt:
help = "enter /help for help"
- safe_addstr(1, self.window_width,
+ self.addstr(1, self.left_window_width,
'MODE: %s – %s' % (self.mode.short_desc, help))
def draw_map():
- if not self.game.turn_complete:
+ if (not self.game.turn_complete) and len(self.map_lines) == 0:
return
- map_lines_split = []
- for y in range(self.game.map_geometry.size.y):
- start = self.game.map_geometry.size.x * y
- end = start + self.game.map_geometry.size.x
- if self.mode.name in {'edit', 'write', 'control_tile_draw',
- 'control_tile_type'}:
- line = []
- for i in range(start, end):
- line += [self.game.map_content[i]
- + self.game.map_control_content[i]]
- map_lines_split += [line]
+ if self.game.turn_complete:
+ map_lines_split = []
+ for y in range(self.game.map_geometry.size.y):
+ start = self.game.map_geometry.size.x * y
+ end = start + self.game.map_geometry.size.x
+ if self.map_mode == 'protections':
+ map_lines_split += [[c + ' ' for c
+ in self.game.map_control_content[start:end]]]
+ else:
+ map_lines_split += [[c + ' ' for c
+ in self.game.map_content[start:end]]]
+ if self.map_mode == 'terrain + annotations':
+ for p in self.game.annotations:
+ map_lines_split[p.y][p.x] = 'A '
+ elif self.map_mode == 'terrain + things':
+ for p in self.game.portals.keys():
+ original = map_lines_split[p.y][p.x]
+ map_lines_split[p.y][p.x] = original[0] + 'P'
+ used_positions = []
+
+ def draw_thing(t, used_positions):
+ symbol = self.game.thing_types[t.type_]
+ meta_char = ' '
+ if hasattr(t, 'thing_char'):
+ meta_char = t.thing_char
+ if t.position in used_positions:
+ meta_char = '+'
+ if hasattr(t, 'carrying') and t.carrying:
+ meta_char = '$'
+ map_lines_split[t.position.y][t.position.x] = symbol + meta_char
+ used_positions += [t.position]
+
+ for t in [t for t in self.game.things if t.type_ != 'Player']:
+ draw_thing(t, used_positions)
+ for t in [t for t in self.game.things if t.type_ == 'Player']:
+ draw_thing(t, used_positions)
+ 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[self.game.player.position.y]\
+ [self.game.player.position.x] = '??'
+ self.map_lines = []
+ if type(self.game.map_geometry) == MapGeometryHex:
+ indent = 0
+ for line in map_lines_split:
+ self.map_lines += [indent * ' ' + ''.join(line)]
+ indent = 0 if indent else 1
else:
- map_lines_split += [[c + ' ' for c
- in self.game.map_content[start:end]]]
- if self.map_mode == 'terrain + annotations':
- for p in self.game.info_hints:
- map_lines_split[p.y][p.x] = 'A '
- elif self.map_mode == 'terrain + things':
- for p in self.game.portals.keys():
- original = map_lines_split[p.y][p.x]
- map_lines_split[p.y][p.x] = original[0] + 'P'
- used_positions = []
- for t in self.game.things:
- symbol = self.game.thing_types[t.type_]
- meta_char = ' '
- if hasattr(t, 'player_char'):
- meta_char = t.player_char
- if t.position in used_positions:
- meta_char = '+'
- map_lines_split[t.position.y][t.position.x] = symbol + meta_char
- used_positions += [t.position]
- if self.mode.shows_info or self.mode.name == 'control_tile_draw':
- map_lines_split[self.explorer.y][self.explorer.x] = '??'
- map_lines = []
- if type(self.game.map_geometry) == MapGeometryHex:
- indent = 0
- for line in map_lines_split:
- map_lines += [indent*' ' + ''.join(line)]
- indent = 0 if indent else 1
- else:
- for line in map_lines_split:
- map_lines += [''.join(line)]
- window_center = YX(int(self.size.y / 2),
- int(self.window_width / 2))
- player = self.game.get_thing(self.game.player_id)
- center = player.position
- if self.mode.shows_info:
- center = self.explorer
- center = YX(center.y, center.x * 2)
- offset = center - window_center
- if type(self.game.map_geometry) == MapGeometryHex and offset.y % 2:
- offset += YX(0, 1)
- term_y = max(0, -offset.y)
- term_x = max(0, -offset.x)
- map_y = max(0, offset.y)
- map_x = max(0, offset.x)
- while (term_y < self.size.y and map_y < self.game.map_geometry.size.y):
- to_draw = map_lines[map_y][map_x:self.window_width + offset.x]
- safe_addstr(term_y, term_x, to_draw)
+ for line in map_lines_split:
+ self.map_lines += [''.join(line)]
+ window_center = YX(int(self.size.y / 2),
+ int(self.left_window_width / 2))
+ 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)
+ self.offset = center - window_center
+ if type(self.game.map_geometry) == MapGeometryHex and self.offset.y % 2:
+ self.offset += YX(0, 1)
+ term_y = max(0, -self.offset.y)
+ 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 < len(self.map_lines):
+ to_draw = self.map_lines[map_y][map_x:self.left_window_width + self.offset.x]
+ self.addstr(term_y, term_x, to_draw)
term_y += 1
map_y += 1
+ def draw_names():
+ players = [t for t in self.game.things if t.type_ == 'Player']
+ players.sort(key=lambda t: len(t.name))
+ players.reverse()
+ shrink_offset = max(0, (self.size.y - self.left_window_width // 2) // 2)
+ y = 0
+ for t in players:
+ offset_y = y - shrink_offset
+ max_len = max(5, (self.left_window_width // 2) - (offset_y * 2) - 8)
+ name = t.name[:]
+ if len(name) > max_len:
+ name = name[:max_len - 1] + '…'
+ self.addstr(y, 0, '@%s:%s' % (t.thing_char, name))
+ y += 1
+ if y >= self.size.y:
+ break
+
+ 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.left_window_width - 10
+ def draw_body_part(body_part, end_y):
+ self.addstr(end_y - 3, start_x, '----------')
+ self.addstr(end_y - 2, start_x, '| ' + body_part[0:6] + ' |')
+ self.addstr(end_y - 1, start_x, '| ' + body_part[6:12] + ' |')
+ self.addstr(end_y, start_x, '| ' + body_part[12:18] + ' |')
+
+ if hasattr(t, 'face'):
+ draw_body_part(t.face, self.size.y - 3)
+ if hasattr(t, 'hat'):
+ draw_body_part(t.hat, self.size.y - 6)
+ self.addstr(self.size.y - 2, start_x, '----------')
+ name = t.name[:]
+ if len(name) > 7:
+ name = name[:6 - 1] + '…'
+ self.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,
self.mode.help_intro)
- if self.mode.name == 'play':
- content += "Available actions:\n"
- if 'MOVE' in self.game.tasks:
- content += "[%s] – move player\n" % ','.join(self.movement_keys)
- if 'PICK_UP' in self.game.tasks:
- content += "[%s] – pick up thing\n" % self.keys['take_thing']
- if 'DROP' in self.game.tasks:
- content += "[%s] – drop picked-up thing\n" % self.keys['drop_thing']
- content += '[%s] – teleport to other space\n' % self.keys['teleport']
- content += '\n'
- elif self.mode.name == 'study':
- content += 'Available actions:\n'
- content += '[%s] – move question mark\n' % ','.join(self.movement_keys)
- content += '[%s] – toggle view between anything, terrain, and annotations\n' % self.keys['toggle_map_mode']
- content += '\n'
- elif self.mode.name == 'edit':
+ if len(self.mode.available_actions) > 0:
content += "Available actions:\n"
- if 'FLATTEN_SURROUNDINGS' in self.game.tasks:
- content += "[%s] – flatten player's surroundings\n" % self.keys['flatten']
- content += '\n'
- elif self.mode.name == 'control_tile_draw':
- content += "Available actions:\n"
- content += "[%s] – toggle tile control drawing\n" % self.keys['toggle_tile_draw']
+ for action in self.mode.available_actions:
+ if action in self.action_tasks:
+ if self.action_tasks[action] not in self.game.tasks:
+ continue
+ if action == 'move_explorer':
+ action = 'move'
+ if action == 'move':
+ key = ','.join(self.movement_keys)
+ else:
+ key = self.keys[action]
+ content += '[%s] – %s\n' % (key, self.action_descriptions[action])
content += '\n'
- elif self.mode.name == 'chat':
- content += '/nick NAME – re-name yourself to NAME\n'
- content += '/%s or /play – switch to play mode\n' % self.keys['switch_to_play']
- content += '/%s or /study – switch to study mode\n' % self.keys['switch_to_study']
- content += '/%s or /edit – switch to map edit mode\n' % self.keys['switch_to_edit']
- content += '/%s or /admin – switch to admin mode\n' % self.keys['switch_to_admin_enter']
content += self.mode.list_available_modes(self)
for i in range(self.size.y):
- safe_addstr(i,
- self.window_width * (not self.mode.has_input_prompt),
- ' '*self.window_width)
+ self.addstr(i,
+ self.left_window_width * (not self.mode.has_input_prompt),
+ ' ' * self.left_window_width)
lines = []
for line in content.split('\n'):
- lines += msg_into_lines_of_width(line, self.window_width)
+ lines += msg_into_lines_of_width(line, self.right_window_width)
for i in range(len(lines)):
if i >= self.size.y:
break
- safe_addstr(i,
- self.window_width * (not self.mode.has_input_prompt),
+ self.addstr(i,
+ self.left_window_width * (not self.mode.has_input_prompt),
lines[i])
def draw_screen():
- stdscr.clear()
+ self.stdscr.clear()
+ self.stdscr.bkgd(' ', curses.color_pair(1))
+ recalc_input_lines()
if self.mode.has_input_prompt:
- recalc_input_lines()
draw_input()
if self.mode.shows_info:
draw_info()
draw_history()
draw_mode()
if not self.mode.is_intro:
- draw_turn()
+ draw_stats()
draw_map()
if self.show_help:
draw_help()
+ if self.mode.name in {'chat', 'play'}:
+ draw_names()
+ if self.draw_face:
+ draw_face_popup()
- curses.curs_set(False) # hide cursor
- curses.use_default_colors();
- stdscr.timeout(10)
- reset_screen_size()
- self.explorer = YX(0, 0)
- self.input_ = ''
- input_prompt = '> '
- interval = datetime.timedelta(seconds=5)
- last_ping = datetime.datetime.now() - interval
- while True:
- if self.disconnected and self.force_instant_connect:
- self.force_instant_connect = False
- self.connect()
- now = datetime.datetime.now()
- if now - last_ping > interval:
- if self.disconnected:
- self.connect()
- else:
- self.send('PING')
- last_ping = now
- if self.flash:
- curses.flash()
- self.flash = False
- if self.do_refresh:
- draw_screen()
- self.do_refresh = False
- while True:
- try:
- msg = self.queue.get(block=False)
- handle_input(msg)
- except queue.Empty:
- break
+ def pick_selectable(task_name):
try:
- key = stdscr.getkey()
- self.do_refresh = True
- except curses.error:
- continue
- self.show_help = 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_ == '/help':
- self.show_help = True
- self.input_ = ""
- self.restore_input_values()
- elif self.mode.has_input_prompt and key != '\n': # Return key
- self.input_ += key
- max_length = self.window_width * self.size.y - len(input_prompt) - 1
- if len(self.input_) > max_length:
- self.input_ = self.input_[:max_length]
- elif key == self.keys['help'] and not self.mode.is_single_char_entry:
- self.show_help = True
- elif self.mode.name == 'login' and key == '\n':
- self.login_name = self.input_
- self.send('LOGIN ' + quote(self.input_))
- self.input_ = ""
- elif self.mode.name == 'control_pw_pw' and key == '\n':
- if self.input_ == '':
- self.log_msg('@ aborted')
- else:
- self.send('SET_MAP_CONTROL_PASSWORD ' + quote(self.tile_control_char) + ' ' + quote(self.input_))
- self.switch_mode('admin')
- elif self.mode.name == 'password' and key == '\n':
- if self.input_ == '':
- self.input_ = ' '
- self.password = self.input_
- self.switch_mode('edit')
- elif self.mode.name == 'admin_enter' and key == '\n':
- self.send('BECOME_ADMIN ' + quote(self.input_))
- self.switch_mode('play')
- elif self.mode.name == 'control_pw_type' and key == '\n':
- if len(self.input_) != 1:
- self.log_msg('@ entered non-single-char, therefore aborted')
- self.switch_mode('admin')
- else:
- self.tile_control_char = self.input_
- self.switch_mode('control_pw_pw')
- elif self.mode.name == 'control_tile_type' and key == '\n':
- if len(self.input_) != 1:
- self.log_msg('@ entered non-single-char, therefore aborted')
- self.switch_mode('admin')
+ i = int(self.input_)
+ if i < 0 or i >= len(self.selectables):
+ self.log('? invalid index, aborted')
else:
- self.tile_control_char = self.input_
- self.switch_mode('control_tile_draw')
- elif self.mode.name == 'chat' and key == '\n':
- if self.input_ == '':
- continue
- if self.input_[0] == '/': # FIXME fails on empty input
- if self.input_ in {'/' + self.keys['switch_to_play'], '/play'}:
- self.switch_mode('play')
- elif self.input_ in {'/' + self.keys['switch_to_study'], '/study'}:
- self.switch_mode('study')
- elif self.input_ in {'/' + self.keys['switch_to_edit'], '/edit'}:
- self.switch_mode('edit')
- elif self.input_ in {'/' + self.keys['switch_to_admin_enter'], '/admin'}:
- self.switch_mode('admin_enter')
- elif self.input_.startswith('/nick'):
- tokens = self.input_.split(maxsplit=1)
- if len(tokens) == 2:
- self.send('NICK ' + quote(tokens[1]))
- else:
- self.log_msg('? need login name')
- else:
- self.log_msg('? unknown command')
+ self.send('TASK:%s %s' % (task_name, self.selectables[i]))
+ except ValueError:
+ self.log('? invalid index, aborted')
+ 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('? 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('? input too long, '
+ 'must be max %s; try again' % width)
+ return
+ self.log(' ' + 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('ALL ' + quote(self.input_))
+ self.send('%s %s' % (command, quote(self.full_ascii_draw)))
+ self.full_ascii_draw = ""
+ self.ascii_draw_stage = 0
self.input_ = ""
- elif self.mode.name == 'annotate' and key == '\n':
- if self.input_ == '':
- self.input_ = ' '
- self.send('ANNOTATE %s %s %s' % (self.explorer, quote(self.input_),
- quote(self.password)))
self.switch_mode('edit')
- elif self.mode.name == 'portal' and key == '\n':
- if self.input_ == '':
- self.input_ = ' '
- self.send('PORTAL %s %s %s' % (self.explorer, quote(self.input_),
- quote(self.password)))
- self.switch_mode('edit')
- elif self.mode.name == 'study':
- if self.mode.mode_switch_on_key(self, key):
- continue
- elif key == self.keys['toggle_map_mode']:
- if self.map_mode == 'terrain only':
- self.map_mode = 'terrain + annotations'
- elif self.map_mode == 'terrain + annotations':
- self.map_mode = 'terrain + things'
- else:
- self.map_mode = 'terrain only'
- elif key in self.movement_keys:
- move_explorer(self.movement_keys[key])
- elif self.mode.name == 'play':
- if self.mode.mode_switch_on_key(self, key):
- continue
- elif key == self.keys['take_thing'] and 'PICK_UP' in self.game.tasks:
- self.send('TASK:PICK_UP')
- elif key == self.keys['drop_thing'] and 'DROP' in self.game.tasks:
- self.send('TASK:DROP')
- 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]
- self.reconnect()
+
+ prev_disconnected = self.socket.disconnected
+ self.socket.keep_connection_alive()
+ if prev_disconnected and not self.socket.disconnected:
+ self.update_on_connect()
+ if self.flash:
+ curses.flash()
+ self.flash = False
+ if self.do_refresh:
+ draw_screen()
+ self.do_refresh = False
+ for msg in self.socket.get_message():
+ handle_input(msg)
+ try:
+ key = self.stdscr.getkey()
+ self.do_refresh = True
+ except curses.error:
+ return
+ keycode = None
+ if len(key) == 1:
+ keycode = ord(key)
+ # workaround for <https://stackoverflow.com/a/56390915>
+ if self.store_widechar:
+ self.store_widechar = False
+ key = bytes([195, keycode]).decode()
+ if keycode == 195:
+ self.store_widechar = True
+ return
+ self.show_help = False
+ self.draw_face = False
+ if key == 'KEY_RESIZE':
+ self.reset_size()
+ elif self.mode.has_input_prompt and key == 'KEY_BACKSPACE':
+ self.input_ = self.input_[:-1]
+ elif (((not self.mode.is_intro) and keycode == 27) # Escape
+ or (self.mode.has_input_prompt and key == '\n'
+ and self.input_ == ''\
+ and self.mode.name in {'chat', 'command_thing',
+ 'take_thing', 'drop_thing',
+ 'admin_enter'})):
+ if self.mode.name not in {'chat', 'play', 'study', 'edit'}:
+ self.log('@ aborted')
+ self.switch_mode('play')
+ elif self.mode.has_input_prompt and key == '\n' and self.input_ == '/help':
+ self.show_help = True
+ self.input_ = ""
+ self.restore_input_values()
+ elif self.mode.has_input_prompt and key != '\n': # Return key
+ self.input_ += key
+ max_length = self.right_window_width * self.size.y - len(self.input_prompt) - 1
+ if len(self.input_) > max_length:
+ self.input_ = self.input_[:max_length]
+ elif key == self.keys['help'] and not self.mode.is_single_char_entry:
+ self.show_help = True
+ elif self.mode.name == 'login' and key == '\n':
+ 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', 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:
+ 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':
+ pick_selectable('DROP')
+ elif self.mode.name == 'command_thing' and key == '\n':
+ self.send('TASK:COMMAND ' + quote(self.input_))
+ self.input_ = ""
+ elif self.mode.name == 'control_pw_pw' and key == '\n':
+ if self.input_ == '':
+ self.log('@ aborted')
+ else:
+ self.send('SET_MAP_CONTROL_PASSWORD ' + quote(self.tile_control_char) + ' ' + quote(self.input_))
+ self.log('@ sent new password for protection character "%s"' % self.tile_control_char)
+ self.switch_mode('admin')
+ elif self.mode.name == 'password' and key == '\n':
+ if self.input_ == '':
+ self.input_ = ' '
+ self.password = self.input_
+ self.switch_mode('edit')
+ elif self.mode.name == 'admin_enter' and key == '\n':
+ self.send('BECOME_ADMIN ' + quote(self.input_))
+ self.switch_mode('play')
+ elif self.mode.name == 'control_pw_type' and key == '\n':
+ if len(self.input_) != 1:
+ self.log('@ entered non-single-char, therefore aborted')
+ self.switch_mode('admin')
+ else:
+ self.tile_control_char = self.input_
+ self.switch_mode('control_pw_pw')
+ elif self.mode.name == 'admin_thing_protect' and key == '\n':
+ if len(self.input_) != 1:
+ self.log('@ entered non-single-char, therefore aborted')
+ else:
+ self.send('THING_PROTECTION %s' % (quote(self.input_)))
+ self.log('@ sent new protection character for thing')
+ self.switch_mode('admin')
+ elif self.mode.name == 'control_tile_type' and key == '\n':
+ if len(self.input_) != 1:
+ self.log('@ entered non-single-char, therefore aborted')
+ self.switch_mode('admin')
+ else:
+ self.tile_control_char = self.input_
+ self.switch_mode('control_tile_draw')
+ elif self.mode.name == 'chat' and key == '\n':
+ if self.input_ == '':
+ return
+ if self.input_[0] == '/':
+ if self.input_.startswith('/nick'):
+ tokens = self.input_.split(maxsplit=1)
+ if len(tokens) == 2:
+ self.send('NICK ' + quote(tokens[1]))
else:
- self.flash = True
- self.log_msg('? not standing on portal')
- elif key in self.movement_keys and 'MOVE' in self.game.tasks:
- self.send('TASK:MOVE ' + self.movement_keys[key])
- elif self.mode.name == 'write':
- self.send('TASK:WRITE %s %s' % (key, quote(self.password)))
- self.switch_mode('edit')
- elif self.mode.name == 'control_tile_draw':
- if self.mode.mode_switch_on_key(self, key):
- continue
- elif key in self.movement_keys:
- move_explorer(self.movement_keys[key])
- elif key == self.keys['toggle_tile_draw']:
- self.tile_draw = False if self.tile_draw else True
- elif self.mode.name == 'admin':
- if self.mode.mode_switch_on_key(self, key):
- continue
- elif self.mode.name == 'edit':
- if self.mode.mode_switch_on_key(self, key):
- continue
- if key == self.keys['flatten'] and\
- 'FLATTEN_SURROUNDINGS' in self.game.tasks:
- self.send('TASK:FLATTEN_SURROUNDINGS ' + quote(self.password))
- elif key in self.movement_keys and 'MOVE' in self.game.tasks:
- self.send('TASK:MOVE ' + self.movement_keys[key])
+ self.log('? need login name')
+ else:
+ self.log('? unknown command')
+ else:
+ self.send('ALL ' + quote(self.input_))
+ self.input_ = ""
+ elif self.mode.name == 'name_thing' and key == '\n':
+ if self.input_ == '':
+ self.input_ = ' '
+ 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.input_ = ' '
+ self.send('ANNOTATE %s %s %s' % (self.explorer, quote(self.input_),
+ quote(self.password)))
+ self.switch_mode('edit')
+ elif self.mode.name == 'portal' and key == '\n':
+ if self.input_ == '':
+ self.input_ = ' '
+ self.send('PORTAL %s %s %s' % (self.explorer, quote(self.input_),
+ quote(self.password)))
+ self.switch_mode('edit')
+ elif self.mode.name == 'study':
+ if self.mode.mode_switch_on_key(self, key):
+ return
+ elif key == self.keys['toggle_map_mode']:
+ self.toggle_map_mode()
+ elif key in self.movement_keys:
+ move_explorer(self.movement_keys[key])
+ elif self.mode.name == 'play':
+ if self.mode.mode_switch_on_key(self, key):
+ return
+ elif key == self.keys['door'] and task_action_on('door'):
+ self.send('TASK:DOOR')
+ elif key == self.keys['consume'] and task_action_on('consume'):
+ self.send('TASK:INTOXICATE')
+ elif key == self.keys['wear'] and task_action_on('wear'):
+ self.send('TASK:WEAR')
+ elif key == self.keys['spin'] and task_action_on('spin'):
+ self.send('TASK:SPIN')
+ elif key == self.keys['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.socket.host = self.game.portals[self.game.player.position]
+ self.reconnect()
+ else:
+ self.flash = True
+ self.log('? not standing on portal')
+ elif key in self.movement_keys and task_action_on('move'):
+ self.send('TASK:MOVE ' + self.movement_keys[key])
+ elif self.mode.name == 'write':
+ self.send('TASK:WRITE %s %s' % (key, quote(self.password)))
+ self.switch_mode('edit')
+ elif self.mode.name == 'control_tile_draw':
+ if self.mode.mode_switch_on_key(self, key):
+ return
+ elif key in self.movement_keys:
+ move_explorer(self.movement_keys[key])
+ elif key == self.keys['toggle_tile_draw']:
+ self.tile_draw = False if self.tile_draw else True
+ elif self.mode.name == 'admin':
+ if self.mode.mode_switch_on_key(self, key):
+ return
+ 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':
+ if self.mode.mode_switch_on_key(self, key):
+ return
+ 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'):
+ self.send('TASK:MOVE ' + self.movement_keys[key])
if len(sys.argv) != 2:
raise ArgError('wrong number of arguments, need game host')
host = sys.argv[1]
-TUI(host)
+RogueChatTUI(host)
projects / plomrogue2 / blobdiff