home · contact · privacy
0e2ceddec7375e2a27d1a1cf05b0bb5afa965144
[plomrogue2-experiments] / new / example_client.py
1 #!/usr/bin/env python3
2 import curses
3 import socket
4 import threading
5 from plomrogue.parser import ArgError, Parser
6 from plomrogue.commands import cmd_MAP, cmd_THING_POS, cmd_PLAYER_ID
7 from plomrogue.game import Game, WorldBase
8 from plomrogue.mapping import MapHex
9 from plomrogue.io import PlomSocket
10 from plomrogue.things import ThingBase
11 import types
12 import queue
13
14
15 class ClientMap(MapHex):
16
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:]
22             else:
23                 start = center_y - int(view_height / 2) - 1
24                 map_lines[:] = map_lines[start:start + view_height]
25
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
30                 cut_end = None
31             else:
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]
35
36     def format_to_view(self, map_cells, center, size):
37
38         def map_cells_to_lines(map_cells):
39             map_view_chars = ['0']
40             x = 0
41             y = 0
42             for cell in map_cells:
43                 if type(cell) == str:
44                     map_view_chars += [cell, ' ']
45                 else:
46                     map_view_chars += [cell[0], cell[1]]
47                 x += 1
48                 if x == self.size[1]:
49                     map_view_chars += ['\n']
50                     x = 0
51                     y += 1
52                     if y % 2 == 0:
53                         map_view_chars += ['0']
54             if y % 2 == 0:
55                 map_view_chars = map_view_chars[:-1]
56             map_view_chars = map_view_chars[:-1]
57             return ''.join(map_view_chars).split('\n')
58
59         map_lines = map_cells_to_lines(map_cells)
60         self.y_cut(map_lines, center[0], size[0])
61         map_width = self.size[1] * 2 + 1
62         self.x_cut(map_lines, center[1] * 2, size[1], map_width)
63         return map_lines
64
65
66 class World(WorldBase):
67
68     def __init__(self, *args, **kwargs):
69         """Extend original with local classes and empty default map.
70
71         We need the empty default map because we draw the map widget
72         on any update, even before we actually receive map data.
73         """
74         super().__init__(*args, **kwargs)
75         self.map_ = ClientMap()
76         self.player_inventory = []
77         self.player_id = 0
78         self.pickable_items = []
79
80     def new_map(self, yx):
81         self.map_ = ClientMap(yx)
82
83     @property
84     def player(self):
85         return self.get_thing(self.player_id)
86
87
88 def cmd_LAST_PLAYER_TASK_RESULT(game, msg):
89     if msg != "success":
90         game.log(msg)
91 cmd_LAST_PLAYER_TASK_RESULT.argtypes = 'string'
92
93 def cmd_TURN_FINISHED(game, n):
94     """Do nothing. (This may be extended later.)"""
95     pass
96 cmd_TURN_FINISHED.argtypes = 'int:nonneg'
97
98 def cmd_TURN(game, n):
99     """Set game.turn to n, empty game.things."""
100     game.world.turn = n
101     game.world.things = []
102     game.world.pickable_items = []
103 cmd_TURN.argtypes = 'int:nonneg'
104
105 def cmd_VISIBLE_MAP_LINE(game, y, terrain_line):
106     game.world.map_.set_line(y, terrain_line)
107 cmd_VISIBLE_MAP_LINE.argtypes = 'int:nonneg string'
108
109 def cmd_GAME_STATE_COMPLETE(game):
110     game.tui.to_update['turn'] = True
111     game.tui.to_update['map'] = True
112     game.tui.to_update['inventory'] = True
113
114 def cmd_THING_TYPE(game, i, type_):
115     t = game.world.get_thing(i)
116     t.type_ = type_
117 cmd_THING_TYPE.argtypes = 'int:nonneg string'
118
119 def cmd_PLAYER_INVENTORY(game, ids):
120     game.world.player_inventory = ids  # TODO: test whether valid IDs
121 cmd_PLAYER_INVENTORY.argtypes = 'seq:int:nonneg'
122
123 def cmd_PICKABLE_ITEMS(game, ids):
124     game.world.pickable_items = ids
125     game.tui.to_update['pickable_items'] = True
126 cmd_PICKABLE_ITEMS.argtypes = 'seq:int:nonneg'
127
128
129 class Game:
130
131     def __init__(self):
132         self.parser = Parser(self)
133         self.world = World(self)
134         self.thing_type = ThingBase
135         self.commands = {'LAST_PLAYER_TASK_RESULT': cmd_LAST_PLAYER_TASK_RESULT,
136                          'TURN_FINISHED': cmd_TURN_FINISHED,
137                          'TURN': cmd_TURN,
138                          'VISIBLE_MAP_LINE': cmd_VISIBLE_MAP_LINE,
139                          'PLAYER_ID': cmd_PLAYER_ID,
140                          'PLAYER_INVENTORY': cmd_PLAYER_INVENTORY,
141                          'GAME_STATE_COMPLETE': cmd_GAME_STATE_COMPLETE,
142                          'MAP': cmd_MAP,
143                          'PICKABLE_ITEMS': cmd_PICKABLE_ITEMS,
144                          'THING_TYPE': cmd_THING_TYPE,
145                          'THING_POS': cmd_THING_POS}
146         self.log_text = ''
147         self.do_quit = False
148         self.tui = None
149
150     def get_command(self, command_name):
151         from functools import partial
152         if command_name in self.commands:
153             f = partial(self.commands[command_name], self)
154             if hasattr(self.commands[command_name], 'argtypes'):
155                 f.argtypes = self.commands[command_name].argtypes
156             return f
157         return None
158
159     def get_string_options(self, string_option_type):
160         return None
161
162     def handle_input(self, msg):
163         self.log(msg)
164         if msg == 'BYE':
165             self.do_quit = True
166             return
167         try:
168             command, args = self.parser.parse(msg)
169             if command is None:
170                 self.log('UNHANDLED INPUT: ' + msg)
171             else:
172                 command(*args)
173         except ArgError as e:
174             self.log('ARGUMENT ERROR: ' + msg + '\n' + str(e))
175
176     def log(self, msg):
177         """Prefix msg plus newline to self.log_text."""
178         self.log_text = msg + '\n' + self.log_text
179         self.tui.to_update['log'] = True
180
181     def symbol_for_type(self, type_):
182         symbol = '?'
183         if type_ == 'human':
184             symbol = '@'
185         elif type_ == 'monster':
186             symbol = 'm'
187         elif type_ == 'item':
188             symbol = 'i'
189         return symbol
190
191
192 ASCII_printable = ' !"#$%&\'\(\)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX'\
193                   'YZ[\\]^_\`abcdefghijklmnopqrstuvwxyz{|}~'
194
195
196 def recv_loop(plom_socket, game, q):
197     for msg in plom_socket.recv():
198         q.put(msg)
199
200
201 class Widget:
202
203     def __init__(self, tui, start, size, check_updates=[], visible=True):
204         self.check_updates = check_updates
205         self.tui = tui
206         self.start = start
207         self.win = curses.newwin(1, 1, self.start[0], self.start[1])
208         self.size_def = size  # store for re-calling .size on SIGWINCH
209         self.size = size
210         self.do_update = True
211         self.visible = visible
212         self.children = []
213
214     @property
215     def size(self):
216         return self.win.getmaxyx()
217
218     @size.setter
219     def size(self, size):
220         """Set window size. Size be y,x tuple. If y or x None, use legal max."""
221         n_lines, n_cols = size
222         if n_lines is None:
223             n_lines = self.tui.stdscr.getmaxyx()[0] - self.start[0]
224         if n_cols is None:
225             n_cols = self.tui.stdscr.getmaxyx()[1] - self.start[1]
226         self.win.resize(n_lines, n_cols)
227
228     def __len__(self):
229         return self.win.getmaxyx()[0] * self.win.getmaxyx()[1]
230
231     def safe_write(self, foo):
232
233         def to_chars_with_attrs(part):
234             attr = curses.A_NORMAL
235             part_string = part
236             if not type(part) == str:
237                 part_string = part[0]
238                 attr = part[1]
239             return [(char, attr) for char in part_string]
240
241         chars_with_attrs = []
242         if type(foo) == str or (len(foo) == 2 and type(foo[1]) == int):
243             chars_with_attrs += to_chars_with_attrs(foo)
244         else:
245             for part in foo:
246                 chars_with_attrs += to_chars_with_attrs(part)
247         self.win.move(0, 0)
248         if len(chars_with_attrs) < len(self):
249             for char_with_attr in chars_with_attrs:
250                 self.win.addstr(char_with_attr[0], char_with_attr[1])
251         else:  # workaround to <https://stackoverflow.com/q/7063128>
252             cut = chars_with_attrs[:len(self) - 1]
253             last_char_with_attr = chars_with_attrs[len(self) - 1]
254             self.win.addstr(self.size[0] - 1, self.size[1] - 2,
255                             last_char_with_attr[0], last_char_with_attr[1])
256             self.win.insstr(self.size[0] - 1, self.size[1] - 2, ' ')
257             self.win.move(0, 0)
258             for char_with_attr in cut:
259                 self.win.addstr(char_with_attr[0], char_with_attr[1])
260
261     def ensure_freshness(self, do_refresh=False):
262         did_refresh = False
263         if self.visible:
264             if not do_refresh:
265                 for key in self.check_updates:
266                     if key in self.tui.to_update and self.tui.to_update[key]:
267                         do_refresh = True
268                         break
269             if do_refresh:
270                 self.win.erase()
271                 self.draw()
272                 self.win.refresh()
273                 did_refresh = True
274             for child in self.children:
275                 did_refresh = child.ensure_freshness(do_refresh) | did_refresh
276         return did_refresh
277
278
279 class EditWidget(Widget):
280
281     def draw(self):
282         self.safe_write((''.join(self.tui.to_send), curses.color_pair(1)))
283
284
285 class TextLinesWidget(Widget):
286
287     def draw(self):
288         lines = self.get_text_lines()
289         line_width = self.size[1]
290         to_join = []
291         for line in lines:
292             to_pad = line_width - (len(line) % line_width)
293             if to_pad == line_width:
294                 to_pad = 0
295             to_join += [line + ' '*to_pad]
296         self.safe_write((''.join(to_join), curses.color_pair(3)))
297
298
299 class LogWidget(TextLinesWidget):
300
301     def get_text_lines(self):
302         return self.tui.game.log_text.split('\n')
303
304
305 class DescriptorWidget(TextLinesWidget):
306
307     def get_text_lines(self):
308         lines = []
309         pos_i = self.tui.game.world.map_.\
310                 get_position_index(self.tui.examiner_position)
311         terrain = self.tui.game.world.map_.terrain[pos_i]
312         lines = [terrain]
313         for t in self.tui.game.world.things:
314             if t.position == self.tui.examiner_position:
315                 lines += [t.type_]
316         return lines
317
318
319 class PopUpWidget(Widget):
320
321     def draw(self):
322         self.safe_write(self.tui.popup_text)
323
324     def reconfigure(self):
325         self.visible = True
326         size = (1, len(self.tui.popup_text))
327         self.size = size
328         self.size_def = size
329         offset_y = int((self.tui.stdscr.getmaxyx()[0] / 2) - (size[0] / 2))
330         offset_x = int((self.tui.stdscr.getmaxyx()[1] / 2) - (size[1] / 2))
331         self.start = (offset_y, offset_x)
332         self.win.mvwin(self.start[0], self.start[1])
333
334
335 class ItemsSelectorWidget(Widget):
336
337     def draw_item_selector(self, title, selection):
338         lines = [title]
339         counter = 0
340         for id_ in selection:
341             pointer = '*' if counter == self.tui.item_pointer else ' '
342             t = self.tui.game.world.get_thing(id_)
343             lines += ['%s %s' % (pointer, t.type_)]
344             counter += 1
345         line_width = self.size[1]
346         to_join = []
347         for line in lines:
348             to_pad = line_width - (len(line) % line_width)
349             if to_pad == line_width:
350                 to_pad = 0
351             to_join += [line + ' '*to_pad]
352         self.safe_write((''.join(to_join), curses.color_pair(3)))
353
354
355 class InventoryWidget(ItemsSelectorWidget):
356
357     def draw(self):
358         self.draw_item_selector('INVENTORY:',
359                                 self.tui.game.world.player_inventory)
360
361 class PickableItemsWidget(ItemsSelectorWidget):
362
363     def draw(self):
364         self.draw_item_selector('PICKABLE:',
365                                 self.tui.game.world.pickable_items)
366
367
368 class MapWidget(Widget):
369
370     def __init__(self, *args, **kwargs):
371         super().__init__(*args, **kwargs)
372         self.examine_mode = False
373
374     def draw(self):
375
376         def annotated_terrain():
377             terrain_as_list = list(self.tui.game.world.map_.terrain[:])
378             for t in self.tui.game.world.things:
379                 pos_i = self.tui.game.world.map_.get_position_index(t.position)
380                 symbol = self.tui.game.symbol_for_type(t.type_)
381                 if terrain_as_list[pos_i][0] in {'i', '@', 'm'}:
382                     old_symbol = terrain_as_list[pos_i][0]
383                     if old_symbol in {'@', 'm'}:
384                         symbol = old_symbol
385                     terrain_as_list[pos_i] = (symbol, '+')
386                 else:
387                     terrain_as_list[pos_i] = symbol
388             if self.examine_mode:
389                 pos_i = self.tui.game.world.map_.\
390                         get_position_index(self.tui.examiner_position)
391                 terrain_as_list[pos_i] = (terrain_as_list[pos_i][0], '?')
392             return terrain_as_list
393
394         def pad_or_cut_x(lines):
395             line_width = self.size[1]
396             for y in range(len(lines)):
397                 line = lines[y]
398                 if line_width > len(line):
399                     to_pad = line_width - (len(line) % line_width)
400                     lines[y] = line + '0' * to_pad
401                 else:
402                     lines[y] = line[:line_width]
403
404         def pad_y(lines):
405             if len(lines) < self.size[0]:
406                 to_pad = self.size[0] - len(lines)
407                 lines += to_pad * ['0' * self.size[1]]
408
409         def lines_to_colored_chars(lines):
410             chars_with_attrs = []
411             for c in ''.join(lines):
412                 if c in {'@', 'm'}:
413                     chars_with_attrs += [(c, curses.color_pair(1))]
414                 elif c == 'i':
415                     chars_with_attrs += [(c, curses.color_pair(4))]
416                 elif c == '.':
417                     chars_with_attrs += [(c, curses.color_pair(2))]
418                 elif c in {'x', 'X', '#'}:
419                     chars_with_attrs += [(c, curses.color_pair(3))]
420                 else:
421                     chars_with_attrs += [c]
422             return chars_with_attrs
423
424         if self.tui.game.world.map_.terrain == '':
425             lines = []
426             pad_y(lines)
427             self.safe_write(''.join(lines))
428             return
429
430         annotated_terrain = annotated_terrain()
431         center = self.tui.game.world.player.position
432         if self.examine_mode:
433             center = self.tui.examiner_position
434         lines = self.tui.game.world.map_.format_to_view(annotated_terrain,
435                                                         center, self.size)
436         pad_or_cut_x(lines)
437         pad_y(lines)
438         self.safe_write(lines_to_colored_chars(lines))
439
440
441 class TurnWidget(Widget):
442
443     def draw(self):
444         self.safe_write((str(self.tui.game.world.turn), curses.color_pair(2)))
445
446
447 class TextLineWidget(Widget):
448
449     def __init__(self, text_line, *args, **kwargs):
450         self.text_line = text_line
451         super().__init__(*args, **kwargs)
452
453     def draw(self):
454         self.safe_write(self.text_line)
455
456
457 class TUI:
458
459     def __init__(self, plom_socket, game, q):
460         self.socket = plom_socket
461         self.game = game
462         self.game.tui = self
463         self.queue = q
464         self.parser = Parser(self.game)
465         self.to_update = {}
466         self.item_pointer = 0
467         self.examiner_position = (0, 0)
468         curses.wrapper(self.loop)
469
470     def loop(self, stdscr):
471
472         def setup_screen(stdscr):
473             self.stdscr = stdscr
474             self.stdscr.refresh()  # will be called by getkey else, clearing screen
475             self.stdscr.timeout(10)
476
477         def switch_widgets(widget_1, widget_2):
478             widget_1.visible = False
479             widget_2.visible = True
480             trigger = widget_2.check_updates[0]
481             self.to_update[trigger] = True
482
483         def pick_or_drop_menu(action_key, widget, selectables, task,
484                               bonus_command=None):
485             if len(selectables) < self.item_pointer + 1 and\
486                self.item_pointer > 0:
487                 self.item_pointer = len(selectables) - 1
488             if key == 'c':
489                 switch_widgets(widget, map_widget)
490                 map_widget.examine_mode = False
491             elif key == 'j':
492                 self.item_pointer += 1
493             elif key == 'k' and self.item_pointer > 0:
494                 self.item_pointer -= 1
495             elif key == action_key and len(selectables) > 0:
496                 id_ = selectables[self.item_pointer]
497                 self.socket.send('TASK:%s %s' % (task, id_))
498                 if bonus_command:
499                     self.socket.send(bonus_command)
500                 if self.item_pointer > 0:
501                     self.item_pointer -= 1
502             else:
503                 return
504             trigger = widget.check_updates[0]
505             self.to_update[trigger] = True
506
507         def move_examiner(direction):
508             start_pos = self.examiner_position
509             new_examine_pos = self.game.world.map_.move(start_pos, direction)
510             if new_examine_pos:
511                 self.examiner_position = new_examine_pos
512             self.to_update['map'] = True
513             self.to_update['descriptor'] = True
514
515         setup_screen(stdscr)
516         curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_RED)
517         curses.init_pair(2, curses.COLOR_BLACK, curses.COLOR_GREEN)
518         curses.init_pair(3, curses.COLOR_BLACK, curses.COLOR_BLUE)
519         curses.init_pair(4, curses.COLOR_BLACK, curses.COLOR_YELLOW)
520         curses.curs_set(False)  # hide cursor
521         self.to_send = []
522         edit_widget = TextLineWidget('SEND:', self, (0, 0), (1, 20))
523         edit_line_widget = EditWidget(self, (0, 6), (1, 14), ['edit'])
524         edit_widget.children += [edit_line_widget]
525         turn_widget = TextLineWidget('TURN:', self, (2, 0), (1, 20))
526         turn_widget.children += [TurnWidget(self, (2, 6), (1, 14), ['turn'])]
527         log_widget = LogWidget(self, (4, 0), (None, 20), ['log'])
528         descriptor_widget = DescriptorWidget(self, (4, 0), (None, 20),
529                                              ['descriptor'], False)
530         map_widget = MapWidget(self, (0, 21), (None, None), ['map'])
531         inventory_widget = InventoryWidget(self, (0, 21), (None, None),
532                                            ['inventory'], False)
533         pickable_items_widget = PickableItemsWidget(self, (0, 21), (None, None),
534                                                     ['pickable_items'], False)
535         top_widgets = [edit_widget, turn_widget, log_widget,
536                        descriptor_widget, map_widget, inventory_widget,
537                        pickable_items_widget]
538         popup_widget = PopUpWidget(self, (0, 0), (1, 1), visible=False)
539         self.popup_text = 'Hi bob'
540         write_mode = True
541         for w in top_widgets:
542             w.ensure_freshness(True)
543         draw_popup_if_visible = True
544         while True:
545             for w in top_widgets:
546                 did_refresh = w.ensure_freshness()
547                 draw_popup_if_visible = did_refresh | draw_popup_if_visible
548             if popup_widget.visible and draw_popup_if_visible:
549                 popup_widget.ensure_freshness(True)
550                 draw_popup_if_visible = False
551             for k in self.to_update.keys():
552                 self.to_update[k] = False
553             while True:
554                 try:
555                     command = self.queue.get(block=False)
556                 except queue.Empty:
557                     break
558                 self.game.handle_input(command)
559             try:
560                 key = self.stdscr.getkey()
561                 if key == 'KEY_RESIZE':
562                     curses.endwin()
563                     setup_screen(curses.initscr())
564                     for w in top_widgets:
565                         w.size = w.size_def
566                         w.ensure_freshness(True)
567                 elif key == '\t':  # Tabulator key.
568                     write_mode = False if write_mode else True
569                 elif write_mode:
570                     if len(key) == 1 and key in ASCII_printable and \
571                             len(self.to_send) < len(edit_line_widget):
572                         self.to_send += [key]
573                         self.to_update['edit'] = True
574                     elif key == 'KEY_BACKSPACE':
575                         self.to_send[:] = self.to_send[:-1]
576                         self.to_update['edit'] = True
577                     elif key == '\n':  # Return key
578                         self.socket.send(''.join(self.to_send))
579                         self.to_send[:] = []
580                         self.to_update['edit'] = True
581                 elif key == 't':
582                     if not popup_widget.visible:
583                         self.to_update['popup'] = True
584                         popup_widget.visible = True
585                         popup_widget.reconfigure()
586                         draw_popup_if_visible = True
587                     else:
588                         popup_widget.visible = False
589                         for w in top_widgets:
590                             w.ensure_freshness(True)
591                 elif map_widget.visible:
592                     if key == '?':
593                         map_widget.examine_mode = not map_widget.examine_mode
594                         if map_widget.examine_mode:
595                             self.examiner_position = self.game.world.\
596                                                      player.position
597                             switch_widgets(log_widget, descriptor_widget)
598                         else:
599                             switch_widgets(descriptor_widget, log_widget)
600                         self.to_update['map'] = True
601                     elif key == 'p':
602                         self.socket.send('GET_PICKABLE_ITEMS')
603                         self.item_pointer = 0
604                         switch_widgets(map_widget, pickable_items_widget)
605                     elif key == 'i':
606                         self.item_pointer = 0
607                         switch_widgets(map_widget, inventory_widget)
608                     elif map_widget.examine_mode:
609                         if key == 'w':
610                             move_examiner('UPLEFT')
611                         elif key == 'e':
612                             move_examiner('UPRIGHT')
613                         elif key == 's':
614                             move_examiner('LEFT')
615                         elif key == 'd':
616                             move_examiner('RIGHT')
617                         elif key == 'x':
618                             move_examiner('DOWNLEFT')
619                         elif key == 'c':
620                             move_examiner('DOWNRIGHT')
621                     elif key == 'w':
622                         self.socket.send('TASK:MOVE UPLEFT')
623                     elif key == 'e':
624                         self.socket.send('TASK:MOVE UPRIGHT')
625                     elif key == 's':
626                         self.socket.send('TASK:MOVE LEFT')
627                     elif key == 'd':
628                         self.socket.send('TASK:MOVE RIGHT')
629                     elif key == 'x':
630                         self.socket.send('TASK:MOVE DOWNLEFT')
631                     elif key == 'c':
632                         self.socket.send('TASK:MOVE DOWNRIGHT')
633                 elif pickable_items_widget.visible:
634                     pick_or_drop_menu('p', pickable_items_widget,
635                                       self.game.world.pickable_items,
636                                       'PICKUP', 'GET_PICKABLE_ITEMS')
637                 elif inventory_widget.visible:
638                     pick_or_drop_menu('d', inventory_widget,
639                                       self.game.world.player_inventory,
640                                       'DROP')
641             except curses.error:
642                 pass
643             if self.game.do_quit:
644                 break
645
646
647 s = socket.create_connection(('127.0.0.1', 5000))
648 plom_socket = PlomSocket(s)
649 game = Game()
650 q = queue.Queue()
651 t = threading.Thread(target=recv_loop, args=(plom_socket, game, q))
652 t.start()
653 TUI(plom_socket, game, q)