5 from plomrogue.parser import ArgError, Parser
6 from plomrogue.commands import cmd_PLAYER_ID, cmd_THING_HEALTH
7 from plomrogue.game import GameBase
8 from plomrogue.mapping import Map, MapGeometryHex, YX
9 from plomrogue.io import PlomSocket
10 from plomrogue.things import ThingBase
17 def y_cut(self, map_lines, center_y, view_height):
18 map_height = len(map_lines)
19 if map_height > view_height and center_y > view_height / 2:
20 if center_y > map_height - view_height / 2:
21 map_lines[:] = map_lines[map_height - view_height:]
23 start = center_y - int(view_height / 2) - 1
24 map_lines[:] = map_lines[start:start + view_height]
26 def x_cut(self, map_lines, center_x, view_width, map_width):
27 if map_width > view_width and center_x > view_width / 2:
28 if center_x > map_width - view_width / 2:
29 cut_start = map_width - view_width
32 cut_start = center_x - int(view_width / 2)
33 cut_end = cut_start + view_width
34 map_lines[:] = [line[cut_start:cut_end] for line in map_lines]
36 def format_to_view(self, map_cells, center, size, indent_first_line):
38 def map_cells_to_lines(map_cells):
41 map_view_chars += ['0']
44 for cell in map_cells:
46 map_view_chars += [cell, ' ']
48 map_view_chars += [cell[0], cell[1]]
51 map_view_chars += ['\n']
54 if y % 2 == int(not indent_first_line):
55 map_view_chars += ['0']
56 if y % 2 == int(not indent_first_line):
57 map_view_chars = map_view_chars[:-1]
58 map_view_chars = map_view_chars[:-1]
59 return ''.join(map_view_chars).split('\n')
61 map_lines = map_cells_to_lines(map_cells)
62 self.y_cut(map_lines, center[1].y, size.y)
63 map_width = self.size.x * 2 + 1
64 self.x_cut(map_lines, center[1].x * 2, size.x, map_width)
68 def cmd_LAST_PLAYER_TASK_RESULT(game, msg):
71 cmd_LAST_PLAYER_TASK_RESULT.argtypes = 'string'
74 def cmd_TURN_FINISHED(game, n):
75 """Do nothing. (This may be extended later.)"""
77 cmd_TURN_FINISHED.argtypes = 'int:nonneg'
80 def cmd_TURN(game, n):
81 """Set game.turn to n, empty game.things."""
84 game.pickable_items[:] = []
85 cmd_TURN.argtypes = 'int:nonneg'
88 def cmd_VISIBLE_MAP(game, offset, size):
89 game.new_map(offset, size)
90 cmd_VISIBLE_MAP.argtypes = 'yx_tuple yx_tuple:pos'
93 def cmd_VISIBLE_MAP_LINE(game, y, terrain_line):
94 game.map_.set_line(y, terrain_line)
95 cmd_VISIBLE_MAP_LINE.argtypes = 'int:nonneg string'
98 def cmd_GAME_STATE_COMPLETE(game):
99 game.tui.to_update['turn'] = True
100 game.tui.to_update['map'] = True
101 game.tui.to_update['inventory'] = True
104 def cmd_THING_TYPE(game, i, type_):
105 t = game.get_thing(i)
107 cmd_THING_TYPE.argtypes = 'int:nonneg string'
110 def cmd_THING_POS(game, i, yx):
111 t = game.get_thing(i)
112 t.position = YX(0,0), yx
113 cmd_THING_POS.argtypes = 'int:nonneg yx_tuple:nonneg'
116 def cmd_PLAYER_INVENTORY(game, ids):
117 game.player_inventory[:] = ids # TODO: test whether valid IDs
118 game.tui.to_update['inventory'] = True
119 cmd_PLAYER_INVENTORY.argtypes = 'seq:int:nonneg'
122 def cmd_PICKABLE_ITEMS(game, ids):
123 game.pickable_items[:] = ids
124 game.tui.to_update['pickable_items'] = True
125 cmd_PICKABLE_ITEMS.argtypes = 'seq:int:nonneg'
128 class Game(GameBase):
130 def __init__(self, *args, **kwargs):
131 super().__init__(*args, **kwargs)
132 self.map_ = ClientMap() # we need an empty default map cause we draw
133 self.offset = YX(0,0) # the map widget even before we get a real one
134 self.player_inventory = []
136 self.pickable_items = []
137 self.parser = Parser(self)
138 self.map_geometry = MapGeometryHex()
139 self.thing_type = ThingBase
140 self.commands = {'LAST_PLAYER_TASK_RESULT': cmd_LAST_PLAYER_TASK_RESULT,
141 'TURN_FINISHED': cmd_TURN_FINISHED,
143 'VISIBLE_MAP_LINE': cmd_VISIBLE_MAP_LINE,
144 'PLAYER_ID': cmd_PLAYER_ID,
145 'PLAYER_INVENTORY': cmd_PLAYER_INVENTORY,
146 'GAME_STATE_COMPLETE': cmd_GAME_STATE_COMPLETE,
147 'VISIBLE_MAP': cmd_VISIBLE_MAP,
148 'PICKABLE_ITEMS': cmd_PICKABLE_ITEMS,
149 'THING_TYPE': cmd_THING_TYPE,
150 'THING_HEALTH': cmd_THING_HEALTH,
151 'THING_POS': cmd_THING_POS}
156 def new_map(self, offset, size):
157 self.map_ = ClientMap(size)
162 return self.get_thing(self.player_id)
164 def get_command(self, command_name):
165 from functools import partial
166 if command_name in self.commands:
167 f = partial(self.commands[command_name], self)
168 if hasattr(self.commands[command_name], 'argtypes'):
169 f.argtypes = self.commands[command_name].argtypes
173 def get_string_options(self, string_option_type):
176 def handle_input(self, msg):
182 command, args = self.parser.parse(msg)
184 self.log('UNHANDLED INPUT: ' + msg)
187 except ArgError as e:
188 self.log('ARGUMENT ERROR: ' + msg + '\n' + str(e))
191 """Prefix msg plus newline to self.log_text."""
192 self.log_text = msg + '\n' + self.log_text
193 self.tui.to_update['log'] = True
195 def symbol_for_type(self, type_):
199 elif type_ == 'monster':
201 elif type_ == 'food':
206 ASCII_printable = ' !"#$%&\'\(\)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX'\
207 'YZ[\\]^_\`abcdefghijklmnopqrstuvwxyz{|}~'
210 def recv_loop(plom_socket, game, q):
211 for msg in plom_socket.recv():
217 def __init__(self, tui, start, size, check_updates=[], visible=True):
218 self.check_updates = check_updates
221 self.win = curses.newwin(1, 1, self.start.y, self.start.x)
222 self.size_def = size # store for re-calling .size on SIGWINCH
224 self.do_update = True
225 self.visible = visible
230 return YX(*self.win.getmaxyx())
233 def size(self, size):
234 """Set window size. Size be y,x tuple. If y or x None, use legal max."""
235 n_lines, n_cols = size
236 getmaxyx = YX(*self.tui.stdscr.getmaxyx())
238 n_lines = getmaxyx.y - self.start.y
240 n_cols = getmaxyx.x - self.start.x
241 self.win.resize(n_lines, n_cols)
244 getmaxyx = YX(*self.win.getmaxyx())
245 return getmaxyx.y * getmaxyx.x
247 def safe_write(self, foo):
249 def to_chars_with_attrs(part):
250 attr = curses.A_NORMAL
252 if not type(part) == str:
253 part_string = part[0]
255 return [(char, attr) for char in part_string]
257 chars_with_attrs = []
258 if type(foo) == str or (len(foo) == 2 and type(foo[1]) == int):
259 chars_with_attrs += to_chars_with_attrs(foo)
262 chars_with_attrs += to_chars_with_attrs(part)
264 if len(chars_with_attrs) < len(self):
265 for char_with_attr in chars_with_attrs:
266 self.win.addstr(char_with_attr[0], char_with_attr[1])
267 else: # workaround to <https://stackoverflow.com/q/7063128>
268 cut = chars_with_attrs[:len(self) - 1]
269 last_char_with_attr = chars_with_attrs[len(self) - 1]
270 self.win.addstr(self.size.y - 1, self.size.x - 2,
271 last_char_with_attr[0], last_char_with_attr[1])
272 self.win.insstr(self.size.y - 1, self.size.x - 2, ' ')
274 for char_with_attr in cut:
275 self.win.addstr(char_with_attr[0], char_with_attr[1])
277 def ensure_freshness(self, do_refresh=False):
281 for key in self.check_updates:
282 if key in self.tui.to_update and self.tui.to_update[key]:
290 for child in self.children:
291 did_refresh = child.ensure_freshness(do_refresh) | did_refresh
295 class EditWidget(Widget):
298 self.safe_write((''.join(self.tui.to_send), curses.color_pair(1)))
301 class TextLinesWidget(Widget):
304 lines = self.get_text_lines()
305 line_width = self.size.x
308 to_pad = line_width - (len(line) % line_width)
309 if to_pad == line_width:
311 to_join += [line + ' '*to_pad]
312 self.safe_write((''.join(to_join), curses.color_pair(3)))
315 class LogWidget(TextLinesWidget):
317 def get_text_lines(self):
318 return self.tui.game.log_text.split('\n')
321 class DescriptorWidget(TextLinesWidget):
323 def get_text_lines(self):
325 pos_i = self.tui.game.map_.\
326 get_position_index(self.tui.examiner_position[1])
327 terrain = self.tui.game.map_.terrain[pos_i]
329 for t in self.tui.game.things_at_pos(self.tui.examiner_position):
334 class PopUpWidget(Widget):
337 self.safe_write(self.tui.popup_text)
339 def reconfigure(self):
340 size = (1, len(self.tui.popup_text))
343 getmaxyx = YX(*self.tui.stdscr.getmaxyx())
344 offset_y = int(getmaxyx.y / 2 - size.y / 2)
345 offset_x = int(getmaxyx.x / 2 - size.x / 2)
346 self.start = YX(offset_y, offset_x)
347 self.win.mvwin(self.start.y, self.start.x)
350 class ItemsSelectorWidget(Widget):
352 def __init__(self, headline, selection, *args, **kwargs):
353 super().__init__(*args, **kwargs)
354 self.headline = headline
355 self.selection = selection
357 def ensure_freshness(self, *args, **kwargs):
358 # We only update pointer on non-empty selection so that the zero-ing
359 # of the selection at TURN_FINISHED etc. before pulling in a new
360 # state does not destroy any memory of previous item pointer positions.
361 if len(self.selection) > 0 and\
362 len(self.selection) < self.tui.item_pointer + 1 and\
363 self.tui.item_pointer > 0:
364 self.tui.item_pointer = max(0, len(self.selection) - 1)
365 self.tui.to_update[self.check_updates[0]] = True
366 super().ensure_freshness(*args, **kwargs)
369 lines = [self.headline]
371 for id_ in self.selection:
372 pointer = '*' if counter == self.tui.item_pointer else ' '
373 t = self.tui.game.get_thing(id_)
374 lines += ['%s %s' % (pointer, t.type_)]
376 line_width = self.size.x
379 to_pad = line_width - (len(line) % line_width)
380 if to_pad == line_width:
382 to_join += [line + ' '*to_pad]
383 self.safe_write((''.join(to_join), curses.color_pair(3)))
386 class MapWidget(Widget):
390 def annotated_terrain():
391 terrain_as_list = list(self.tui.game.map_.terrain[:])
392 for t in self.tui.game.things:
393 if t.id_ in self.tui.game.player_inventory:
395 pos_i = self.tui.game.map_.get_position_index(t.position[1])
396 symbol = self.tui.game.symbol_for_type(t.type_)
397 if terrain_as_list[pos_i][0] in {'f', '@', 'm'}:
398 old_symbol = terrain_as_list[pos_i][0]
399 if old_symbol in {'@', 'm'}:
401 terrain_as_list[pos_i] = (symbol, '+')
403 terrain_as_list[pos_i] = symbol
404 if self.tui.examiner_mode:
405 pos_i = self.tui.game.map_.\
406 get_position_index(self.tui.examiner_position[1])
407 terrain_as_list[pos_i] = (terrain_as_list[pos_i][0], '?')
408 return terrain_as_list
410 def pad_or_cut_x(lines):
411 line_width = self.size.x
412 for y in range(len(lines)):
414 if line_width > len(line):
415 to_pad = line_width - (len(line) % line_width)
416 lines[y] = line + '0' * to_pad
418 lines[y] = line[:line_width]
421 if len(lines) < self.size.y:
422 to_pad = self.size.y - len(lines)
423 lines += to_pad * ['0' * self.size.x]
425 def lines_to_colored_chars(lines):
426 chars_with_attrs = []
427 for c in ''.join(lines):
429 chars_with_attrs += [(c, curses.color_pair(1))]
431 chars_with_attrs += [(c, curses.color_pair(4))]
433 chars_with_attrs += [(c, curses.color_pair(2))]
434 elif c in {'x', 'X', '#'}:
435 chars_with_attrs += [(c, curses.color_pair(3))]
437 chars_with_attrs += [(c, curses.color_pair(5))]
439 chars_with_attrs += [c]
440 return chars_with_attrs
442 if self.tui.game.map_.terrain == '':
445 self.safe_write(''.join(lines))
448 annotated_terrain = annotated_terrain()
449 center = self.tui.game.player.position
450 if self.tui.examiner_mode:
451 center = self.tui.examiner_position
452 indent_first_line = not bool(self.tui.game.offset.y % 2)
453 lines = self.tui.game.map_.\
454 format_to_view(annotated_terrain, center, self.size,
458 self.safe_write(lines_to_colored_chars(lines))
461 class TurnWidget(Widget):
464 self.safe_write((str(self.tui.game.turn), curses.color_pair(2)))
467 class HealthWidget(Widget):
470 if hasattr(self.tui.game.player, 'health'):
471 self.safe_write((str(self.tui.game.player.health),
472 curses.color_pair(2)))
475 class TextLineWidget(Widget):
477 def __init__(self, text_line, *args, **kwargs):
478 self.text_line = text_line
479 super().__init__(*args, **kwargs)
482 self.safe_write(self.text_line)
487 def __init__(self, plom_socket, game, q):
488 self.socket = plom_socket
492 self.parser = Parser(self.game)
494 self.item_pointer = 0
495 self.examiner_position = (YX(0,0), YX(0, 0))
496 self.examiner_mode = False
497 self.popup_text = 'Hi bob'
499 self.draw_popup_if_visible = True
500 curses.wrapper(self.loop)
502 def loop(self, stdscr):
504 def setup_screen(stdscr):
506 self.stdscr.refresh() # will be called by getkey else, clearing screen
507 self.stdscr.timeout(10)
509 def switch_widgets(widget_1, widget_2):
510 widget_1.visible = False
511 widget_2.visible = True
512 trigger = widget_2.check_updates[0]
513 self.to_update[trigger] = True
515 def selectables_menu(key, widget, selectables, f):
517 switch_widgets(widget, map_widget)
519 self.item_pointer += 1
520 elif key == 'k' and self.item_pointer > 0:
521 self.item_pointer -= 1
522 elif not f(key, selectables):
524 trigger = widget.check_updates[0]
525 self.to_update[trigger] = True
527 def pickup_menu(key):
529 def f(key, selectables):
530 if key == 'p' and len(selectables) > 0:
531 id_ = selectables[self.item_pointer]
532 self.socket.send('TASK:PICKUP %s' % id_)
533 self.socket.send('GET_PICKABLE_ITEMS')
538 selectables_menu(key, pickable_items_widget,
539 self.game.pickable_items, f)
541 def inventory_menu(key):
543 def f(key, selectables):
544 if key == 'd' and len(selectables) > 0:
545 id_ = selectables[self.item_pointer]
546 self.socket.send('TASK:DROP %s' % id_)
547 elif key == 'e' and len(selectables) > 0:
548 id_ = selectables[self.item_pointer]
549 self.socket.send('TASK:EAT %s' % id_)
554 selectables_menu(key, inventory_widget,
555 self.game.player_inventory, f)
557 def move_examiner(direction):
558 start_pos = self.examiner_position
559 new_examine_pos = self.game.map_geometry.move(start_pos, direction,
561 if new_examine_pos[0] == (0,0):
562 self.examiner_position = new_examine_pos
563 self.to_update['map'] = True
565 def switch_to_pick_or_drop(target_widget):
566 self.item_pointer = 0
567 switch_widgets(map_widget, target_widget)
568 if self.examiner_mode:
569 self.examiner_mode = False
570 switch_widgets(descriptor_widget, log_widget)
572 def toggle_examiner_mode():
573 if self.examiner_mode:
574 self.examiner_mode = False
575 switch_widgets(descriptor_widget, log_widget)
577 self.examiner_mode = True
578 self.examiner_position = self.game.player.position
579 switch_widgets(log_widget, descriptor_widget)
580 self.to_update['map'] = True
583 if popup_widget.visible:
584 popup_widget.visible = False
585 for w in top_widgets:
586 w.ensure_freshness(True)
588 self.to_update['popup'] = True
589 popup_widget.visible = True
590 popup_widget.reconfigure()
591 self.draw_popup_if_visible = True
593 def try_write_keys():
594 if len(key) == 1 and key in ASCII_printable and \
595 len(self.to_send) < len(edit_line_widget):
596 self.to_send += [key]
597 self.to_update['edit'] = True
598 elif key == 'KEY_BACKSPACE':
599 self.to_send[:] = self.to_send[:-1]
600 self.to_update['edit'] = True
601 elif key == '\n': # Return key
602 self.socket.send(''.join(self.to_send))
604 self.to_update['edit'] = True
606 def try_examiner_keys():
608 move_examiner('UPLEFT')
610 move_examiner('UPRIGHT')
612 move_examiner('LEFT')
614 move_examiner('RIGHT')
616 move_examiner('DOWNLEFT')
618 move_examiner('DOWNRIGHT')
620 def try_player_move_keys():
622 self.socket.send('TASK:MOVE UPLEFT')
624 self.socket.send('TASK:MOVE UPRIGHT')
626 self.socket.send('TASK:MOVE LEFT')
628 self.socket.send('TASK:MOVE RIGHT')
630 self.socket.send('TASK:MOVE DOWNLEFT')
632 self.socket.send('TASK:MOVE DOWNRIGHT')
635 curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_RED)
636 curses.init_pair(2, curses.COLOR_BLACK, curses.COLOR_GREEN)
637 curses.init_pair(3, curses.COLOR_BLACK, curses.COLOR_BLUE)
638 curses.init_pair(4, curses.COLOR_BLACK, curses.COLOR_YELLOW)
639 curses.init_pair(5, curses.COLOR_BLACK, curses.COLOR_WHITE)
641 # Basic curses initialization work.
643 curses.curs_set(False) # hide cursor
646 # With screen initialized, set up widgets with their curses windows.
647 edit_widget = TextLineWidget('SEND:', self, YX(0, 0), YX(1, 20))
648 edit_line_widget = EditWidget(self, YX(0, 6), YX(1, 14), ['edit'])
649 edit_widget.children += [edit_line_widget]
650 turn_widget = TextLineWidget('TURN:', self, YX(2, 0), YX(1, 20))
651 turn_widget.children += [TurnWidget(self, YX(2, 6), YX(1, 14), ['turn'])]
652 health_widget = TextLineWidget('HEALTH:', self, YX(3, 0), YX(1, 20))
653 health_widget.children += [HealthWidget(self, YX(3, 8), YX(1, 12), ['turn'])]
654 log_widget = LogWidget(self, YX(5, 0), YX(None, 20), ['log'])
655 descriptor_widget = DescriptorWidget(self, YX(5, 0), YX(None, 20),
657 map_widget = MapWidget(self, YX(0, 21), YX(None, None), ['map'])
658 inventory_widget = ItemsSelectorWidget('INVENTORY:',
659 self.game.player_inventory,
660 self, YX(0, 21), YX(None, None),
661 ['inventory'], False)
662 pickable_items_widget = ItemsSelectorWidget('PICKABLE:',
663 self.game.pickable_items,
668 top_widgets = [edit_widget, turn_widget, health_widget, log_widget,
669 descriptor_widget, map_widget, inventory_widget,
670 pickable_items_widget]
671 popup_widget = PopUpWidget(self, YX(0, 0), YX(1, 1), visible=False)
673 # Ensure initial window state before loop starts.
674 for w in top_widgets:
675 w.ensure_freshness(True)
676 self.socket.send('GET_GAMESTATE')
681 for w in top_widgets:
682 if w.ensure_freshness():
683 self.draw_popup_if_visible = True
684 if popup_widget.visible and self.draw_popup_if_visible:
685 popup_widget.ensure_freshness(True)
686 self.draw_popup_if_visible = False
687 for k in self.to_update.keys():
688 self.to_update[k] = False
690 # Handle input from server.
693 command = self.queue.get(block=False)
696 self.game.handle_input(command)
698 # Handle keys (and resize event read as key).
700 key = self.stdscr.getkey()
701 if key == 'KEY_RESIZE':
703 setup_screen(curses.initscr())
704 for w in top_widgets:
706 w.ensure_freshness(True)
707 elif key == '\t': # Tabulator key.
708 write_mode = False if write_mode else True
713 elif map_widget.visible:
715 toggle_examiner_mode()
717 self.socket.send('GET_PICKABLE_ITEMS')
718 switch_to_pick_or_drop(pickable_items_widget)
720 switch_to_pick_or_drop(inventory_widget)
721 elif self.examiner_mode:
724 try_player_move_keys()
725 elif pickable_items_widget.visible:
727 elif inventory_widget.visible:
732 # Quit when server recommends it.
733 if self.game.do_quit:
737 s = socket.create_connection(('127.0.0.1', 5000))
738 plom_socket = PlomSocket(s)
741 t = threading.Thread(target=recv_loop, args=(plom_socket, game, q))
743 TUI(plom_socket, game, q)