import socket
import threading
from plomrogue.parser import ArgError, Parser
-from plomrogue.commands import cmd_MAP, cmd_THING_POS, cmd_PLAYER_ID
+from plomrogue.commands import (cmd_MAP, cmd_THING_POS, cmd_PLAYER_ID,
+ cmd_THING_HEALTH)
from plomrogue.game import Game, WorldBase
-from plomrogue.mapping import MapBase
+from plomrogue.mapping import MapHex
from plomrogue.io import PlomSocket
from plomrogue.things import ThingBase
import types
import queue
-class Map(MapBase):
+class ClientMap(MapHex):
def y_cut(self, map_lines, center_y, view_height):
map_height = len(map_lines)
on any update, even before we actually receive map data.
"""
super().__init__(*args, **kwargs)
- self.map_ = Map()
+ self.map_ = ClientMap()
self.player_inventory = []
self.player_id = 0
self.pickable_items = []
def new_map(self, yx):
- self.map_ = Map(yx)
+ self.map_ = ClientMap(yx)
@property
def player(self):
game.log(msg)
cmd_LAST_PLAYER_TASK_RESULT.argtypes = 'string'
+
def cmd_TURN_FINISHED(game, n):
"""Do nothing. (This may be extended later.)"""
pass
cmd_TURN_FINISHED.argtypes = 'int:nonneg'
+
def cmd_TURN(game, n):
"""Set game.turn to n, empty game.things."""
game.world.turn = n
game.world.things = []
- game.world.pickable_items = []
+ game.world.pickable_items[:] = []
cmd_TURN.argtypes = 'int:nonneg'
+
def cmd_VISIBLE_MAP_LINE(game, y, terrain_line):
game.world.map_.set_line(y, terrain_line)
cmd_VISIBLE_MAP_LINE.argtypes = 'int:nonneg string'
+
def cmd_GAME_STATE_COMPLETE(game):
game.tui.to_update['turn'] = True
game.tui.to_update['map'] = True
game.tui.to_update['inventory'] = True
+
def cmd_THING_TYPE(game, i, type_):
t = game.world.get_thing(i)
t.type_ = type_
cmd_THING_TYPE.argtypes = 'int:nonneg string'
+
def cmd_PLAYER_INVENTORY(game, ids):
- game.world.player_inventory = ids # TODO: test whether valid IDs
+ game.world.player_inventory[:] = ids # TODO: test whether valid IDs
+ game.tui.to_update['inventory'] = True
cmd_PLAYER_INVENTORY.argtypes = 'seq:int:nonneg'
+
def cmd_PICKABLE_ITEMS(game, ids):
- game.world.pickable_items = ids
+ game.world.pickable_items[:] = ids
game.tui.to_update['pickable_items'] = True
cmd_PICKABLE_ITEMS.argtypes = 'seq:int:nonneg'
'MAP': cmd_MAP,
'PICKABLE_ITEMS': cmd_PICKABLE_ITEMS,
'THING_TYPE': cmd_THING_TYPE,
+ 'THING_HEALTH': cmd_THING_HEALTH,
'THING_POS': cmd_THING_POS}
self.log_text = ''
self.do_quit = False
symbol = '@'
elif type_ == 'monster':
symbol = 'm'
- elif type_ == 'item':
- symbol = 'i'
+ elif type_ == 'food':
+ symbol = 'f'
return symbol
self.safe_write((''.join(self.tui.to_send), curses.color_pair(1)))
-class LogWidget(Widget):
+class TextLinesWidget(Widget):
def draw(self):
+ lines = self.get_text_lines()
line_width = self.size[1]
- log_lines = self.tui.game.log_text.split('\n')
to_join = []
- for line in log_lines:
+ for line in lines:
to_pad = line_width - (len(line) % line_width)
if to_pad == line_width:
to_pad = 0
self.safe_write((''.join(to_join), curses.color_pair(3)))
+class LogWidget(TextLinesWidget):
+
+ def get_text_lines(self):
+ return self.tui.game.log_text.split('\n')
+
+
+class DescriptorWidget(TextLinesWidget):
+
+ def get_text_lines(self):
+ lines = []
+ pos_i = self.tui.game.world.map_.\
+ get_position_index(self.tui.examiner_position)
+ terrain = self.tui.game.world.map_.terrain[pos_i]
+ lines = [terrain]
+ for t in self.tui.game.world.things_at_pos(self.tui.examiner_position):
+ lines += [t.type_]
+ return lines
+
+
class PopUpWidget(Widget):
def draw(self):
self.safe_write(self.tui.popup_text)
def reconfigure(self):
- self.visible = True
size = (1, len(self.tui.popup_text))
self.size = size
self.size_def = size
class ItemsSelectorWidget(Widget):
- def draw_item_selector(self, title, selection):
- lines = [title]
+ def __init__(self, headline, selection, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.headline = headline
+ self.selection = selection
+
+ def ensure_freshness(self, *args, **kwargs):
+ # We only update pointer on non-empty selection so that the zero-ing
+ # of the selection at TURN_FINISHED etc. before pulling in a new
+ # state does not destroy any memory of previous item pointer positions.
+ if len(self.selection) > 0 and\
+ len(self.selection) < self.tui.item_pointer + 1 and\
+ self.tui.item_pointer > 0:
+ self.tui.item_pointer = max(0, len(self.selection) - 1)
+ self.tui.to_update[self.check_updates[0]] = True
+ super().ensure_freshness(*args, **kwargs)
+
+ def draw(self):
+ lines = [self.headline]
counter = 0
- for id_ in selection:
+ for id_ in self.selection:
pointer = '*' if counter == self.tui.item_pointer else ' '
t = self.tui.game.world.get_thing(id_)
lines += ['%s %s' % (pointer, t.type_)]
self.safe_write((''.join(to_join), curses.color_pair(3)))
-class InventoryWidget(ItemsSelectorWidget):
-
- def draw(self):
- self.draw_item_selector('INVENTORY:',
- self.tui.game.world.player_inventory)
-
-class PickableItemsWidget(ItemsSelectorWidget):
-
- def draw(self):
- self.draw_item_selector('PICKABLE:',
- self.tui.game.world.pickable_items)
-
-
class MapWidget(Widget):
def draw(self):
for t in self.tui.game.world.things:
pos_i = self.tui.game.world.map_.get_position_index(t.position)
symbol = self.tui.game.symbol_for_type(t.type_)
- if terrain_as_list[pos_i][0] in {'i', '@', 'm'}:
+ if terrain_as_list[pos_i][0] in {'f', '@', 'm'}:
old_symbol = terrain_as_list[pos_i][0]
if old_symbol in {'@', 'm'}:
symbol = old_symbol
terrain_as_list[pos_i] = (symbol, '+')
else:
terrain_as_list[pos_i] = symbol
+ if self.tui.examiner_mode:
+ pos_i = self.tui.game.world.map_.\
+ get_position_index(self.tui.examiner_position)
+ terrain_as_list[pos_i] = (terrain_as_list[pos_i][0], '?')
return terrain_as_list
def pad_or_cut_x(lines):
for c in ''.join(lines):
if c in {'@', 'm'}:
chars_with_attrs += [(c, curses.color_pair(1))]
- elif c == 'i':
+ elif c == 'f':
chars_with_attrs += [(c, curses.color_pair(4))]
elif c == '.':
chars_with_attrs += [(c, curses.color_pair(2))]
elif c in {'x', 'X', '#'}:
chars_with_attrs += [(c, curses.color_pair(3))]
+ elif c == '?':
+ chars_with_attrs += [(c, curses.color_pair(5))]
else:
chars_with_attrs += [c]
return chars_with_attrs
annotated_terrain = annotated_terrain()
center = self.tui.game.world.player.position
+ if self.tui.examiner_mode:
+ center = self.tui.examiner_position
lines = self.tui.game.world.map_.format_to_view(annotated_terrain,
center, self.size)
pad_or_cut_x(lines)
self.safe_write((str(self.tui.game.world.turn), curses.color_pair(2)))
+class HealthWidget(Widget):
+
+ def draw(self):
+ if hasattr(self.tui.game.world.player, 'health'):
+ self.safe_write((str(self.tui.game.world.player.health),
+ curses.color_pair(2)))
+
+
class TextLineWidget(Widget):
def __init__(self, text_line, *args, **kwargs):
self.parser = Parser(self.game)
self.to_update = {}
self.item_pointer = 0
+ self.examiner_position = (0, 0)
+ self.examiner_mode = False
+ self.popup_text = 'Hi bob'
+ self.to_send = []
+ self.draw_popup_if_visible = True
curses.wrapper(self.loop)
def loop(self, stdscr):
trigger = widget_2.check_updates[0]
self.to_update[trigger] = True
- def pick_or_drop_menu(action_key, widget, selectables, task,
- bonus_command=None):
- if len(selectables) < self.item_pointer + 1 and\
- self.item_pointer > 0:
- self.item_pointer = len(selectables) - 1
+ def selectables_menu(key, widget, selectables, f):
if key == 'c':
switch_widgets(widget, map_widget)
elif key == 'j':
self.item_pointer += 1
elif key == 'k' and self.item_pointer > 0:
self.item_pointer -= 1
- elif key == action_key and len(selectables) > 0:
- id_ = selectables[self.item_pointer]
- self.socket.send('TASK:%s %s' % (task, id_))
- if bonus_command:
- self.socket.send(bonus_command)
- if self.item_pointer > 0:
- self.item_pointer -= 1
- else:
+ elif not f(key, selectables):
return
trigger = widget.check_updates[0]
self.to_update[trigger] = True
+ def pickup_menu(key):
+
+ def f(key, selectables):
+ if key == 'p' and len(selectables) > 0:
+ id_ = selectables[self.item_pointer]
+ self.socket.send('TASK:PICKUP %s' % id_)
+ self.socket.send('GET_PICKABLE_ITEMS')
+ else:
+ return False
+ return True
+
+ selectables_menu(key, pickable_items_widget,
+ self.game.world.pickable_items, f)
+
+ def inventory_menu(key):
+
+ def f(key, selectables):
+ if key == 'd' and len(selectables) > 0:
+ id_ = selectables[self.item_pointer]
+ self.socket.send('TASK:DROP %s' % id_)
+ elif key == 'e' and len(selectables) > 0:
+ id_ = selectables[self.item_pointer]
+ self.socket.send('TASK:EAT %s' % id_)
+ else:
+ return False
+ return True
+
+ selectables_menu(key, inventory_widget,
+ self.game.world.player_inventory, f)
+
+ def move_examiner(direction):
+ start_pos = self.examiner_position
+ new_examine_pos = self.game.world.map_.move(start_pos, direction)
+ if new_examine_pos:
+ self.examiner_position = new_examine_pos
+ self.to_update['map'] = True
+
+ def switch_to_pick_or_drop(target_widget):
+ self.item_pointer = 0
+ switch_widgets(map_widget, target_widget)
+ if self.examiner_mode:
+ self.examiner_mode = False
+ switch_widgets(descriptor_widget, log_widget)
+
+ def toggle_examiner_mode():
+ if self.examiner_mode:
+ self.examiner_mode = False
+ switch_widgets(descriptor_widget, log_widget)
+ else:
+ self.examiner_mode = True
+ self.examiner_position = self.game.world.player.position
+ switch_widgets(log_widget, descriptor_widget)
+ self.to_update['map'] = True
+
+ def toggle_popup():
+ if popup_widget.visible:
+ popup_widget.visible = False
+ for w in top_widgets:
+ w.ensure_freshness(True)
+ else:
+ self.to_update['popup'] = True
+ popup_widget.visible = True
+ popup_widget.reconfigure()
+ self.draw_popup_if_visible = True
+
+ def try_write_keys():
+ if len(key) == 1 and key in ASCII_printable and \
+ len(self.to_send) < len(edit_line_widget):
+ self.to_send += [key]
+ self.to_update['edit'] = True
+ elif key == 'KEY_BACKSPACE':
+ self.to_send[:] = self.to_send[:-1]
+ self.to_update['edit'] = True
+ elif key == '\n': # Return key
+ self.socket.send(''.join(self.to_send))
+ self.to_send[:] = []
+ self.to_update['edit'] = True
+
+ def try_examiner_keys():
+ if key == 'w':
+ move_examiner('UPLEFT')
+ elif key == 'e':
+ move_examiner('UPRIGHT')
+ elif key == 's':
+ move_examiner('LEFT')
+ elif key == 'd':
+ move_examiner('RIGHT')
+ elif key == 'x':
+ move_examiner('DOWNLEFT')
+ elif key == 'c':
+ move_examiner('DOWNRIGHT')
+
+ def try_player_move_keys():
+ if key == 'w':
+ self.socket.send('TASK:MOVE UPLEFT')
+ elif key == 'e':
+ self.socket.send('TASK:MOVE UPRIGHT')
+ elif key == 's':
+ self.socket.send('TASK:MOVE LEFT')
+ elif key == 'd':
+ self.socket.send('TASK:MOVE RIGHT')
+ elif key == 'x':
+ self.socket.send('TASK:MOVE DOWNLEFT')
+ elif key == 'c':
+ self.socket.send('TASK:MOVE DOWNRIGHT')
+
+ def init_colors():
+ curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_RED)
+ curses.init_pair(2, curses.COLOR_BLACK, curses.COLOR_GREEN)
+ curses.init_pair(3, curses.COLOR_BLACK, curses.COLOR_BLUE)
+ curses.init_pair(4, curses.COLOR_BLACK, curses.COLOR_YELLOW)
+ curses.init_pair(5, curses.COLOR_BLACK, curses.COLOR_WHITE)
+
+ # Basic curses initialization work.
setup_screen(stdscr)
- curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_RED)
- curses.init_pair(2, curses.COLOR_BLACK, curses.COLOR_GREEN)
- curses.init_pair(3, curses.COLOR_BLACK, curses.COLOR_BLUE)
- curses.init_pair(4, curses.COLOR_BLACK, curses.COLOR_YELLOW)
curses.curs_set(False) # hide cursor
- self.to_send = []
+ init_colors()
+
+ # With screen initialized, set up widgets with their curses windows.
edit_widget = TextLineWidget('SEND:', self, (0, 0), (1, 20))
edit_line_widget = EditWidget(self, (0, 6), (1, 14), ['edit'])
edit_widget.children += [edit_line_widget]
turn_widget = TextLineWidget('TURN:', self, (2, 0), (1, 20))
turn_widget.children += [TurnWidget(self, (2, 6), (1, 14), ['turn'])]
- log_widget = LogWidget(self, (4, 0), (None, 20), ['log'])
+ health_widget = TextLineWidget('HEALTH:', self, (3, 0), (1, 20))
+ health_widget.children += [HealthWidget(self, (3, 8), (1, 12), ['turn'])]
+ log_widget = LogWidget(self, (5, 0), (None, 20), ['log'])
+ descriptor_widget = DescriptorWidget(self, (5, 0), (None, 20),
+ ['map'], False)
map_widget = MapWidget(self, (0, 21), (None, None), ['map'])
- inventory_widget = InventoryWidget(self, (0, 21), (None, None),
- ['inventory'], False)
- pickable_items_widget = PickableItemsWidget(self, (0, 21), (None, None),
- ['pickable_items'], False)
- top_widgets = [edit_widget, turn_widget, log_widget, map_widget,
- inventory_widget, pickable_items_widget]
+ inventory_widget = ItemsSelectorWidget('INVENTORY:',
+ self.game.world.player_inventory,
+ self, (0, 21), (None,
+ None), ['inventory'],
+ False)
+ pickable_items_widget = ItemsSelectorWidget('PICKABLE:',
+ self.game.world.pickable_items,
+ self, (0, 21),
+ (None, None),
+ ['pickable_items'],
+ False)
+ top_widgets = [edit_widget, turn_widget, health_widget, log_widget,
+ descriptor_widget, map_widget, inventory_widget,
+ pickable_items_widget]
popup_widget = PopUpWidget(self, (0, 0), (1, 1), visible=False)
- self.popup_text = 'Hi bob'
- write_mode = True
+
+ # Ensure initial window state before loop starts.
for w in top_widgets:
w.ensure_freshness(True)
- draw_popup_if_visible = True
+ self.socket.send('GET_GAMESTATE')
+ write_mode = False
while True:
+
+ # Draw screen.
for w in top_widgets:
- did_refresh = w.ensure_freshness()
- draw_popup_if_visible = did_refresh | draw_popup_if_visible
- if popup_widget.visible and draw_popup_if_visible:
+ if w.ensure_freshness():
+ self.draw_popup_if_visible = True
+ if popup_widget.visible and self.draw_popup_if_visible:
popup_widget.ensure_freshness(True)
- draw_popup_if_visible = False
+ self.draw_popup_if_visible = False
for k in self.to_update.keys():
self.to_update[k] = False
+
+ # Handle input from server.
while True:
try:
command = self.queue.get(block=False)
except queue.Empty:
break
self.game.handle_input(command)
+
+ # Handle keys (and resize event read as key).
try:
key = self.stdscr.getkey()
if key == 'KEY_RESIZE':
elif key == '\t': # Tabulator key.
write_mode = False if write_mode else True
elif write_mode:
- if len(key) == 1 and key in ASCII_printable and \
- len(self.to_send) < len(edit_line_widget):
- self.to_send += [key]
- self.to_update['edit'] = True
- elif key == 'KEY_BACKSPACE':
- self.to_send[:] = self.to_send[:-1]
- self.to_update['edit'] = True
- elif key == '\n': # Return key
- self.socket.send(''.join(self.to_send))
- self.to_send[:] = []
- self.to_update['edit'] = True
+ try_write_keys()
elif key == 't':
- if not popup_widget.visible:
- self.to_update['popup'] = True
- popup_widget.visible = True
- popup_widget.reconfigure()
- draw_popup_if_visible = True
- else:
- popup_widget.visible = False
- for w in top_widgets:
- w.ensure_freshness(True)
+ toggle_popup()
elif map_widget.visible:
- if key == 'w':
- self.socket.send('TASK:MOVE UPLEFT')
- elif key == 'e':
- self.socket.send('TASK:MOVE UPRIGHT')
- if key == 's':
- self.socket.send('TASK:MOVE LEFT')
- elif key == 'd':
- self.socket.send('TASK:MOVE RIGHT')
- if key == 'x':
- self.socket.send('TASK:MOVE DOWNLEFT')
- elif key == 'c':
- self.socket.send('TASK:MOVE DOWNRIGHT')
+ if key == '?':
+ toggle_examiner_mode()
elif key == 'p':
self.socket.send('GET_PICKABLE_ITEMS')
- self.item_pointer = 0
- switch_widgets(map_widget, pickable_items_widget)
+ switch_to_pick_or_drop(pickable_items_widget)
elif key == 'i':
- self.item_pointer = 0
- switch_widgets(map_widget, inventory_widget)
+ switch_to_pick_or_drop(inventory_widget)
+ elif self.examiner_mode:
+ try_examiner_keys()
+ else:
+ try_player_move_keys()
elif pickable_items_widget.visible:
- pick_or_drop_menu('p', pickable_items_widget,
- self.game.world.pickable_items,
- 'PICKUP', 'GET_PICKABLE_ITEMS')
+ pickup_menu(key)
elif inventory_widget.visible:
- pick_or_drop_menu('d', inventory_widget,
- self.game.world.player_inventory,
- 'DROP')
+ inventory_menu(key)
except curses.error:
pass
+
+ # Quit when server recommends it.
if self.game.do_quit:
break
projects / plomrogue2-experiments / blobdiff