import socket
import threading
from plomrogue.parser import ArgError, Parser
-from plomrogue.commands import cmd_MAP, cmd_THING_TYPE, cmd_THING_POS
+from plomrogue.commands import cmd_MAP, cmd_THING_POS, cmd_PLAYER_ID
from plomrogue.game import Game, WorldBase
from plomrogue.mapping import MapBase
from plomrogue.io import PlomSocket
"""
super().__init__(*args, **kwargs)
self.map_ = Map()
- self.player_position = (0, 0)
+ self.player_inventory = []
+ self.player_id = 0
+ self.pickable_items = []
def new_map(self, yx):
self.map_ = Map(yx)
+ @property
+ def player(self):
+ return self.get_thing(self.player_id)
+
-def cmd_LAST_PLAYER_TASK_RESULT(self, msg):
+def cmd_LAST_PLAYER_TASK_RESULT(game, msg):
if msg != "success":
- self.log(msg)
+ game.log(msg)
cmd_LAST_PLAYER_TASK_RESULT.argtypes = 'string'
-def cmd_TURN_FINISHED(self, n):
+def cmd_TURN_FINISHED(game, n):
"""Do nothing. (This may be extended later.)"""
pass
cmd_TURN_FINISHED.argtypes = 'int:nonneg'
-def cmd_TURN(self, n):
- """Set self.turn to n, empty self.things."""
- self.world.turn = n
- self.world.things = []
- self.to_update['turn'] = False
- self.to_update['map'] = False
+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.to_update['turn'] = False
+ game.to_update['map'] = False
cmd_TURN.argtypes = 'int:nonneg'
-def cmd_VISIBLE_MAP_LINE(self, y, terrain_line):
- self.world.map_.set_line(y, terrain_line)
+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_PLAYER_POS(self, yx):
- self.world.player_position = yx
-cmd_PLAYER_POS.argtypes = 'yx_tuple:pos'
+def cmd_GAME_STATE_COMPLETE(game):
+ game.to_update['turn'] = True
+ game.to_update['map'] = 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_GAME_STATE_COMPLETE(self):
- self.to_update['turn'] = True
- self.to_update['map'] = True
+def cmd_PLAYER_INVENTORY(game, ids):
+ game.world.player_inventory = ids # TODO: test whether valid IDs
+cmd_PLAYER_INVENTORY.argtypes = 'seq:int:nonneg'
+
+def cmd_PICKABLE_ITEMS(game, ids):
+ game.world.pickable_items = ids
+ game.to_update['map'] = True
+cmd_PICKABLE_ITEMS.argtypes = 'seq:int:nonneg'
class Game:
'TURN_FINISHED': cmd_TURN_FINISHED,
'TURN': cmd_TURN,
'VISIBLE_MAP_LINE': cmd_VISIBLE_MAP_LINE,
- 'PLAYER_POS': cmd_PLAYER_POS,
+ 'PLAYER_ID': cmd_PLAYER_ID,
+ 'PLAYER_INVENTORY': cmd_PLAYER_INVENTORY,
'GAME_STATE_COMPLETE': cmd_GAME_STATE_COMPLETE,
'MAP': cmd_MAP,
+ 'PICKABLE_ITEMS': cmd_PICKABLE_ITEMS,
'THING_TYPE': cmd_THING_TYPE,
'THING_POS': cmd_THING_POS}
self.log_text = ''
'turn': True,
}
self.do_quit = False
+ self.to_update_lock = False
def get_command(self, command_name):
from functools import partial
return None
def handle_input(self, msg):
+ self.log(msg)
if msg == 'BYE':
self.do_quit = True
return
symbol = '@'
elif type_ == 'monster':
symbol = 'm'
+ elif type_ == 'item':
+ symbol = 'i'
return symbol
self.size_def = size # store for re-calling .size on SIGWINCH
self.size = size
self.do_update = True
+ self.visible = True
@property
def size(self):
self.win.addstr(char_with_attr[0], char_with_attr[1])
def ensure_freshness(self, do_refresh=False):
+ if not self.visible:
+ return
if not do_refresh:
for key in self.check_game:
- if self.tui.game.to_update[key]:
+ if key in self.tui.game.to_update and self.tui.game.to_update[key]:
do_refresh = True
break
if not do_refresh:
for key in self.check_tui:
- if self.tui.to_update[key]:
+ if key in self.tui.to_update and self.tui.to_update[key]:
do_refresh = True
break
if do_refresh:
self.safe_write((''.join(to_join), curses.color_pair(3)))
+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
+ offset_y = int((self.tui.stdscr.getmaxyx()[0] / 2) - (size[0] / 2))
+ offset_x = int((self.tui.stdscr.getmaxyx()[1] / 2) - (size[1] / 2))
+ self.start = (offset_y, offset_x)
+ self.win.mvwin(self.start[0], self.start[1])
+ self.ensure_freshness(True)
+
+
+
class MapWidget(Widget):
def draw(self):
+ if self.tui.view == 'map':
+ self.draw_map()
+ elif self.tui.view == 'inventory':
+ self.draw_item_selector('INVENTORY:',
+ self.tui.game.world.player_inventory)
+ elif self.tui.view == 'pickable_items':
+ self.draw_item_selector('PICKABLE:',
+ self.tui.game.world.pickable_items)
+
+ def draw_item_selector(self, title, selection):
+ lines = [title]
+ counter = 0
+ for id_ in selection:
+ pointer = '*' if counter == self.tui.item_pointer else ' '
+ t = self.tui.game.world.get_thing(id_)
+ lines += ['%s %s' % (pointer, t.type_)]
+ counter += 1
+ line_width = self.size[1]
+ to_join = []
+ for line in lines:
+ to_pad = line_width - (len(line) % line_width)
+ if to_pad == line_width:
+ to_pad = 0
+ to_join += [line + ' '*to_pad]
+ self.safe_write((''.join(to_join), curses.color_pair(3)))
+
+ def draw_map(self):
def terrain_with_objects():
terrain_as_list = list(self.tui.game.world.map_.terrain[:])
for t in self.tui.game.world.things:
pos_i = self.tui.game.world.map_.get_position_index(t.position)
- terrain_as_list[pos_i] = self.tui.game.symbol_for_type(t.type_)
+ symbol = self.tui.game.symbol_for_type(t.type_)
+ if symbol in {'i'} and terrain_as_list[pos_i] in {'@', 'm'}:
+ continue
+ terrain_as_list[pos_i] = symbol
return ''.join(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':
+ chars_with_attrs += [(c, curses.color_pair(4))]
elif c == '.':
chars_with_attrs += [(c, curses.color_pair(2))]
elif c in {'x', 'X', '#'}:
return
terrain_with_objects = terrain_with_objects()
- center = self.tui.game.world.player_position
+ center = self.tui.game.world.player.position
lines = self.tui.game.world.map_.format_to_view(terrain_with_objects,
center, self.size)
pad_or_cut_x(lines)
self.game = game
self.parser = Parser(self.game)
self.to_update = {'edit': False}
+ self.item_pointer = 0
curses.wrapper(self.loop)
+ def draw_screen(self):
+ self.stdscr.addstr(0, 0, 'SEND:')
+ self.stdscr.addstr(2, 0, 'TURN:')
+
def setup_screen(self, stdscr):
self.stdscr = stdscr
self.stdscr.refresh() # will be called by getkey else, clearing screen
self.stdscr.timeout(10)
- self.stdscr.addstr(0, 0, 'SEND:')
- self.stdscr.addstr(2, 0, 'TURN:')
+ self.draw_screen()
def loop(self, stdscr):
self.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 = []
self.edit = EditWidget(self, (0, 6), (1, 14), check_tui = ['edit'])
self.turn = TurnWidget(self, (2, 6), (1, 14), ['turn'])
self.log = LogWidget(self, (4, 0), (None, 20), ['log'])
self.map_ = MapWidget(self, (0, 21), (None, None), ['map'])
- widgets = (self.edit, self.turn, self.log, self.map_)
- map_mode = False
+ self.popup = PopUpWidget(self, (0, 0), (1, 1), ['popup'])
+ self.popup.visible = False
+ self.popup_text = 'Hi bob'
+ widgets = (self.edit, self.turn, self.log, self.map_, self.popup)
+ write_mode = True
+ self.view = 'map'
while True:
for w in widgets:
w.ensure_freshness()
w.size = w.size_def
w.ensure_freshness(True)
elif key == '\t': # Tabulator key.
- map_mode = False if map_mode else True
- elif map_mode:
+ 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(self.edit):
+ 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
+ elif self.view == 'map':
if key == 'w':
self.socket.send('TASK:MOVE UPLEFT')
elif key == 'e':
self.socket.send('TASK:MOVE DOWNLEFT')
elif key == 'c':
self.socket.send('TASK:MOVE DOWNRIGHT')
- else:
- if len(key) == 1 and key in ASCII_printable and \
- len(self.to_send) < len(self.edit):
- 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
+ elif key == 't':
+ if not self.popup.visible:
+ self.to_update['popup'] = True
+ self.popup.visible = True
+ self.popup.reconfigure()
+ else:
+ self.popup.visible = False
+ self.stdscr.erase() # we'll call refresh here so
+ self.stdscr.refresh() # getkey doesn't, erasing screen
+ self.draw_screen()
+ for w in widgets:
+ w.ensure_freshness(True)
+ elif key == 'p':
+ self.socket.send('GET_PICKABLE_ITEMS')
+ self.item_pointer = 0
+ self.view = 'pickable_items'
+ elif key == 'i':
+ self.item_pointer = 0
+ self.view = 'inventory'
+ self.game.to_update['map'] = True
+ elif self.view == 'pickable_items':
+ if key == 'c':
+ self.view = 'map'
+ elif key == 'j' and \
+ len(self.game.world.pickable_items) > \
+ self.item_pointer + 1:
+ self.item_pointer += 1
+ elif key == 'k' and self.item_pointer > 0:
+ self.item_pointer -= 1
+ elif key == 'p' and \
+ len(self.game.world.pickable_items) > 0:
+ id_ = self.game.world.pickable_items[self.item_pointer]
+ self.socket.send('TASK:PICKUP %s' % id_)
+ self.view = 'map'
+ else:
+ continue
+ self.game.to_update['map'] = True
+ elif self.view == 'inventory':
+ if key == 'c':
+ self.view = 'map'
+ elif key == 'j' and \
+ len(self.game.world.player_inventory) > \
+ self.item_pointer + 1:
+ self.item_pointer += 1
+ elif key == 'k' and self.item_pointer > 0:
+ self.item_pointer -= 1
+ elif key == 'd' and \
+ len(self.game.world.player_inventory) > 0:
+ id_ = self.game.world.player_inventory[self.item_pointer]
+ self.socket.send('TASK:DROP %s' % id_)
+ if self.item_pointer > 0:
+ self.item_pointer -= 1
+ else:
+ continue
+ self.game.to_update['map'] = True
except curses.error:
pass
if self.game.do_quit:
projects / plomrogue2-experiments / blobdiff