home · contact · privacy
88939ba4d9fe026584fbaff0206dcec14e5f4a9d
[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_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
11 import types
12 import queue
13
14
15 class ClientMap(Map):
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 = []
40             if self.start_indented:
41                 map_view_chars += ['0']
42             x = 0
43             y = 0
44             for cell in map_cells:
45                 if type(cell) == str:
46                     map_view_chars += [cell, ' ']
47                 else:
48                     map_view_chars += [cell[0], cell[1]]
49                 x += 1
50                 if x == self.size.x:
51                     map_view_chars += ['\n']
52                     x = 0
53                     y += 1
54                     if y % 2 == int(not self.start_indented):
55                         map_view_chars += ['0']
56             if y % 2 == int(not self.start_indented):
57                 map_view_chars = map_view_chars[:-1]
58             map_view_chars = map_view_chars[:-1]
59             return ''.join(map_view_chars).split('\n')
60
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)
65         return map_lines
66
67
68 def cmd_LAST_PLAYER_TASK_RESULT(game, msg):
69     if msg != "success":
70         game.log(msg)
71 cmd_LAST_PLAYER_TASK_RESULT.argtypes = 'string'
72
73
74 def cmd_TURN_FINISHED(game, n):
75     """Do nothing. (This may be extended later.)"""
76     pass
77 cmd_TURN_FINISHED.argtypes = 'int:nonneg'
78
79
80 def cmd_TURN(game, n):
81     """Set game.turn to n, empty game.things."""
82     game.turn = n
83     game.things = []
84     game.pickable_items[:] = []
85 cmd_TURN.argtypes = 'int:nonneg'
86
87
88 def cmd_VISIBLE_MAP(game, size, indent_first_line):
89     game.new_map(size, indent_first_line)
90 cmd_VISIBLE_MAP.argtypes = 'yx_tuple:pos bool'
91
92
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'
96
97
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
102
103
104 def cmd_THING_TYPE(game, i, type_):
105     t = game.get_thing(i)
106     t.type_ = type_
107 cmd_THING_TYPE.argtypes = 'int:nonneg string'
108
109
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'
114
115
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'
120
121
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'
126
127
128 class Game(GameBase):
129
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 = []
135         self.player_id = 0
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,
142                          'TURN': cmd_TURN,
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}
152         self.log_text = ''
153         self.do_quit = False
154         self.tui = None
155
156     def new_map(self, size, indent_first_line):
157         self.map_ = ClientMap(size, start_indented=indent_first_line)
158
159     @property
160     def player(self):
161         return self.get_thing(self.player_id)
162
163     def get_command(self, command_name):
164         from functools import partial
165         if command_name in self.commands:
166             f = partial(self.commands[command_name], self)
167             if hasattr(self.commands[command_name], 'argtypes'):
168                 f.argtypes = self.commands[command_name].argtypes
169             return f
170         return None
171
172     def get_string_options(self, string_option_type):
173         return None
174
175     def handle_input(self, msg):
176         self.log(msg)
177         if msg == 'BYE':
178             self.do_quit = True
179             return
180         try:
181             command, args = self.parser.parse(msg)
182             if command is None:
183                 self.log('UNHANDLED INPUT: ' + msg)
184             else:
185                 command(*args)
186         except ArgError as e:
187             self.log('ARGUMENT ERROR: ' + msg + '\n' + str(e))
188
189     def log(self, msg):
190         """Prefix msg plus newline to self.log_text."""
191         self.log_text = msg + '\n' + self.log_text
192         self.tui.to_update['log'] = True
193
194     def symbol_for_type(self, type_):
195         symbol = '?'
196         if type_ == 'human':
197             symbol = '@'
198         elif type_ == 'monster':
199             symbol = 'm'
200         elif type_ == 'food':
201             symbol = 'f'
202         return symbol
203
204
205 ASCII_printable = ' !"#$%&\'\(\)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX'\
206                   'YZ[\\]^_\`abcdefghijklmnopqrstuvwxyz{|}~'
207
208
209 def recv_loop(plom_socket, game, q):
210     for msg in plom_socket.recv():
211         q.put(msg)
212
213
214 class Widget:
215
216     def __init__(self, tui, start, size, check_updates=[], visible=True):
217         self.check_updates = check_updates
218         self.tui = tui
219         self.start = start
220         self.win = curses.newwin(1, 1, self.start.y, self.start.x)
221         self.size_def = size  # store for re-calling .size on SIGWINCH
222         self.size = size
223         self.do_update = True
224         self.visible = visible
225         self.children = []
226
227     @property
228     def size(self):
229         return YX(*self.win.getmaxyx())
230
231     @size.setter
232     def size(self, size):
233         """Set window size. Size be y,x tuple. If y or x None, use legal max."""
234         n_lines, n_cols = size
235         getmaxyx = YX(*self.tui.stdscr.getmaxyx())
236         if n_lines is None:
237             n_lines = getmaxyx.y - self.start.y
238         if n_cols is None:
239             n_cols = getmaxyx.x - self.start.x
240         self.win.resize(n_lines, n_cols)
241
242     def __len__(self):
243         getmaxyx = YX(*self.win.getmaxyx())
244         return getmaxyx.y * getmaxyx.x
245
246     def safe_write(self, foo):
247
248         def to_chars_with_attrs(part):
249             attr = curses.A_NORMAL
250             part_string = part
251             if not type(part) == str:
252                 part_string = part[0]
253                 attr = part[1]
254             return [(char, attr) for char in part_string]
255
256         chars_with_attrs = []
257         if type(foo) == str or (len(foo) == 2 and type(foo[1]) == int):
258             chars_with_attrs += to_chars_with_attrs(foo)
259         else:
260             for part in foo:
261                 chars_with_attrs += to_chars_with_attrs(part)
262         self.win.move(0, 0)
263         if len(chars_with_attrs) < len(self):
264             for char_with_attr in chars_with_attrs:
265                 self.win.addstr(char_with_attr[0], char_with_attr[1])
266         else:  # workaround to <https://stackoverflow.com/q/7063128>
267             cut = chars_with_attrs[:len(self) - 1]
268             last_char_with_attr = chars_with_attrs[len(self) - 1]
269             self.win.addstr(self.size.y - 1, self.size.x - 2,
270                             last_char_with_attr[0], last_char_with_attr[1])
271             self.win.insstr(self.size.y - 1, self.size.x - 2, ' ')
272             self.win.move(0, 0)
273             for char_with_attr in cut:
274                 self.win.addstr(char_with_attr[0], char_with_attr[1])
275
276     def ensure_freshness(self, do_refresh=False):
277         did_refresh = False
278         if self.visible:
279             if not do_refresh:
280                 for key in self.check_updates:
281                     if key in self.tui.to_update and self.tui.to_update[key]:
282                         do_refresh = True
283                         break
284             if do_refresh:
285                 self.win.erase()
286                 self.draw()
287                 self.win.refresh()
288                 did_refresh = True
289             for child in self.children:
290                 did_refresh = child.ensure_freshness(do_refresh) | did_refresh
291         return did_refresh
292
293
294 class EditWidget(Widget):
295
296     def draw(self):
297         self.safe_write((''.join(self.tui.to_send), curses.color_pair(1)))
298
299
300 class TextLinesWidget(Widget):
301
302     def draw(self):
303         lines = self.get_text_lines()
304         line_width = self.size.x
305         to_join = []
306         for line in lines:
307             to_pad = line_width - (len(line) % line_width)
308             if to_pad == line_width:
309                 to_pad = 0
310             to_join += [line + ' '*to_pad]
311         self.safe_write((''.join(to_join), curses.color_pair(3)))
312
313
314 class LogWidget(TextLinesWidget):
315
316     def get_text_lines(self):
317         return self.tui.game.log_text.split('\n')
318
319
320 class DescriptorWidget(TextLinesWidget):
321
322     def get_text_lines(self):
323         lines = []
324         pos_i = self.tui.game.map_.\
325                 get_position_index(self.tui.examiner_position[1])
326         terrain = self.tui.game.map_.terrain[pos_i]
327         lines = [terrain]
328         for t in self.tui.game.things_at_pos(self.tui.examiner_position):
329             lines += [t.type_]
330         return lines
331
332
333 class PopUpWidget(Widget):
334
335     def draw(self):
336         self.safe_write(self.tui.popup_text)
337
338     def reconfigure(self):
339         size = (1, len(self.tui.popup_text))
340         self.size = size
341         self.size_def = size
342         getmaxyx = YX(*self.tui.stdscr.getmaxyx())
343         offset_y = int(getmaxyx.y / 2 - size.y / 2)
344         offset_x = int(getmaxyx.x / 2 - size.x / 2)
345         self.start = YX(offset_y, offset_x)
346         self.win.mvwin(self.start.y, self.start.x)
347
348
349 class ItemsSelectorWidget(Widget):
350
351     def __init__(self, headline, selection, *args, **kwargs):
352         super().__init__(*args, **kwargs)
353         self.headline = headline
354         self.selection = selection
355
356     def ensure_freshness(self, *args, **kwargs):
357         # We only update pointer on non-empty selection so that the zero-ing
358         # of the selection at TURN_FINISHED etc. before pulling in a new
359         # state does not destroy any memory of previous item pointer positions.
360         if len(self.selection) > 0 and\
361            len(self.selection) < self.tui.item_pointer + 1 and\
362            self.tui.item_pointer > 0:
363             self.tui.item_pointer = max(0, len(self.selection) - 1)
364             self.tui.to_update[self.check_updates[0]] = True
365         super().ensure_freshness(*args, **kwargs)
366
367     def draw(self):
368         lines = [self.headline]
369         counter = 0
370         for id_ in self.selection:
371             pointer = '*' if counter == self.tui.item_pointer else ' '
372             t = self.tui.game.get_thing(id_)
373             lines += ['%s %s' % (pointer, t.type_)]
374             counter += 1
375         line_width = self.size.x
376         to_join = []
377         for line in lines:
378             to_pad = line_width - (len(line) % line_width)
379             if to_pad == line_width:
380                 to_pad = 0
381             to_join += [line + ' '*to_pad]
382         self.safe_write((''.join(to_join), curses.color_pair(3)))
383
384
385 class MapWidget(Widget):
386
387     def draw(self):
388
389         def annotated_terrain():
390             terrain_as_list = list(self.tui.game.map_.terrain[:])
391             for t in self.tui.game.things:
392                 if t.id_ in self.tui.game.player_inventory:
393                     continue
394                 pos_i = self.tui.game.map_.get_position_index(t.position[1])
395                 symbol = self.tui.game.symbol_for_type(t.type_)
396                 if terrain_as_list[pos_i][0] in {'f', '@', 'm'}:
397                     old_symbol = terrain_as_list[pos_i][0]
398                     if old_symbol in {'@', 'm'}:
399                         symbol = old_symbol
400                     terrain_as_list[pos_i] = (symbol, '+')
401                 else:
402                     terrain_as_list[pos_i] = symbol
403             if self.tui.examiner_mode:
404                 pos_i = self.tui.game.map_.\
405                         get_position_index(self.tui.examiner_position[1])
406                 terrain_as_list[pos_i] = (terrain_as_list[pos_i][0], '?')
407             return terrain_as_list
408
409         def pad_or_cut_x(lines):
410             line_width = self.size.x
411             for y in range(len(lines)):
412                 line = lines[y]
413                 if line_width > len(line):
414                     to_pad = line_width - (len(line) % line_width)
415                     lines[y] = line + '0' * to_pad
416                 else:
417                     lines[y] = line[:line_width]
418
419         def pad_y(lines):
420             if len(lines) < self.size.y:
421                 to_pad = self.size.y - len(lines)
422                 lines += to_pad * ['0' * self.size.x]
423
424         def lines_to_colored_chars(lines):
425             chars_with_attrs = []
426             for c in ''.join(lines):
427                 if c in {'@', 'm'}:
428                     chars_with_attrs += [(c, curses.color_pair(1))]
429                 elif c == 'f':
430                     chars_with_attrs += [(c, curses.color_pair(4))]
431                 elif c == '.':
432                     chars_with_attrs += [(c, curses.color_pair(2))]
433                 elif c in {'x', 'X', '#'}:
434                     chars_with_attrs += [(c, curses.color_pair(3))]
435                 elif c == '?':
436                     chars_with_attrs += [(c, curses.color_pair(5))]
437                 else:
438                     chars_with_attrs += [c]
439             return chars_with_attrs
440
441         if self.tui.game.map_.terrain == '':
442             lines = []
443             pad_y(lines)
444             self.safe_write(''.join(lines))
445             return
446
447         annotated_terrain = annotated_terrain()
448         center = self.tui.game.player.position
449         if self.tui.examiner_mode:
450             center = self.tui.examiner_position
451         lines = self.tui.game.map_.\
452                 format_to_view(annotated_terrain, center, self.size)
453         pad_or_cut_x(lines)
454         pad_y(lines)
455         self.safe_write(lines_to_colored_chars(lines))
456
457
458 class TurnWidget(Widget):
459
460     def draw(self):
461         self.safe_write((str(self.tui.game.turn), curses.color_pair(2)))
462
463
464 class HealthWidget(Widget):
465
466     def draw(self):
467         if hasattr(self.tui.game.player, 'health'):
468             self.safe_write((str(self.tui.game.player.health),
469                              curses.color_pair(2)))
470
471
472 class TextLineWidget(Widget):
473
474     def __init__(self, text_line, *args, **kwargs):
475         self.text_line = text_line
476         super().__init__(*args, **kwargs)
477
478     def draw(self):
479         self.safe_write(self.text_line)
480
481
482 class TUI:
483
484     def __init__(self, plom_socket, game, q):
485         self.socket = plom_socket
486         self.game = game
487         self.game.tui = self
488         self.queue = q
489         self.parser = Parser(self.game)
490         self.to_update = {}
491         self.item_pointer = 0
492         self.examiner_position = (YX(0,0), YX(0, 0))
493         self.examiner_mode = False
494         self.popup_text = 'Hi bob'
495         self.to_send = []
496         self.draw_popup_if_visible = True
497         curses.wrapper(self.loop)
498
499     def loop(self, stdscr):
500
501         def setup_screen(stdscr):
502             self.stdscr = stdscr
503             self.stdscr.refresh()  # will be called by getkey else, clearing screen
504             self.stdscr.timeout(10)
505
506         def switch_widgets(widget_1, widget_2):
507             widget_1.visible = False
508             widget_2.visible = True
509             trigger = widget_2.check_updates[0]
510             self.to_update[trigger] = True
511
512         def selectables_menu(key, widget, selectables, f):
513             if key == 'c':
514                 switch_widgets(widget, map_widget)
515             elif key == 'j':
516                 self.item_pointer += 1
517             elif key == 'k' and self.item_pointer > 0:
518                 self.item_pointer -= 1
519             elif not f(key, selectables):
520                 return
521             trigger = widget.check_updates[0]
522             self.to_update[trigger] = True
523
524         def pickup_menu(key):
525
526             def f(key, selectables):
527                 if key == 'p' and len(selectables) > 0:
528                     id_ = selectables[self.item_pointer]
529                     self.socket.send('TASK:PICKUP %s' % id_)
530                     self.socket.send('GET_PICKABLE_ITEMS')
531                 else:
532                     return False
533                 return True
534
535             selectables_menu(key, pickable_items_widget,
536                              self.game.pickable_items, f)
537
538         def inventory_menu(key):
539
540             def f(key, selectables):
541                 if key == 'd' and len(selectables) > 0:
542                     id_ = selectables[self.item_pointer]
543                     self.socket.send('TASK:DROP %s' % id_)
544                 elif key == 'e' and len(selectables) > 0:
545                     id_ = selectables[self.item_pointer]
546                     self.socket.send('TASK:EAT %s' % id_)
547                 else:
548                     return False
549                 return True
550
551             selectables_menu(key, inventory_widget,
552                              self.game.player_inventory, f)
553
554         def move_examiner(direction):
555             start_pos = self.examiner_position
556             new_examine_pos = self.game.map_geometry.move(start_pos, direction,
557                                                           self.game.map_.size)
558             if new_examine_pos[0] == (0,0):
559                 self.examiner_position = new_examine_pos
560             self.to_update['map'] = True
561
562         def switch_to_pick_or_drop(target_widget):
563             self.item_pointer = 0
564             switch_widgets(map_widget, target_widget)
565             if self.examiner_mode:
566                 self.examiner_mode = False
567                 switch_widgets(descriptor_widget, log_widget)
568
569         def toggle_examiner_mode():
570             if self.examiner_mode:
571                 self.examiner_mode = False
572                 switch_widgets(descriptor_widget, log_widget)
573             else:
574                 self.examiner_mode = True
575                 self.examiner_position = self.game.player.position
576                 switch_widgets(log_widget, descriptor_widget)
577             self.to_update['map'] = True
578
579         def toggle_popup():
580             if popup_widget.visible:
581                 popup_widget.visible = False
582                 for w in top_widgets:
583                     w.ensure_freshness(True)
584             else:
585                 self.to_update['popup'] = True
586                 popup_widget.visible = True
587                 popup_widget.reconfigure()
588                 self.draw_popup_if_visible = True
589
590         def try_write_keys():
591             if len(key) == 1 and key in ASCII_printable and \
592                     len(self.to_send) < len(edit_line_widget):
593                 self.to_send += [key]
594                 self.to_update['edit'] = True
595             elif key == 'KEY_BACKSPACE':
596                 self.to_send[:] = self.to_send[:-1]
597                 self.to_update['edit'] = True
598             elif key == '\n':  # Return key
599                 self.socket.send(''.join(self.to_send))
600                 self.to_send[:] = []
601                 self.to_update['edit'] = True
602
603         def try_examiner_keys():
604             if key == 'w':
605                 move_examiner('UPLEFT')
606             elif key == 'e':
607                 move_examiner('UPRIGHT')
608             elif key == 's':
609                 move_examiner('LEFT')
610             elif key == 'd':
611                 move_examiner('RIGHT')
612             elif key == 'x':
613                 move_examiner('DOWNLEFT')
614             elif key == 'c':
615                 move_examiner('DOWNRIGHT')
616
617         def try_player_move_keys():
618             if key == 'w':
619                 self.socket.send('TASK:MOVE UPLEFT')
620             elif key == 'e':
621                 self.socket.send('TASK:MOVE UPRIGHT')
622             elif key == 's':
623                 self.socket.send('TASK:MOVE LEFT')
624             elif key == 'd':
625                 self.socket.send('TASK:MOVE RIGHT')
626             elif key == 'x':
627                 self.socket.send('TASK:MOVE DOWNLEFT')
628             elif key == 'c':
629                 self.socket.send('TASK:MOVE DOWNRIGHT')
630
631         def init_colors():
632             curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_RED)
633             curses.init_pair(2, curses.COLOR_BLACK, curses.COLOR_GREEN)
634             curses.init_pair(3, curses.COLOR_BLACK, curses.COLOR_BLUE)
635             curses.init_pair(4, curses.COLOR_BLACK, curses.COLOR_YELLOW)
636             curses.init_pair(5, curses.COLOR_BLACK, curses.COLOR_WHITE)
637
638         # Basic curses initialization work.
639         setup_screen(stdscr)
640         curses.curs_set(False)  # hide cursor
641         init_colors()
642
643         # With screen initialized, set up widgets with their curses windows.
644         edit_widget = TextLineWidget('SEND:', self, YX(0, 0), YX(1, 20))
645         edit_line_widget = EditWidget(self, YX(0, 6), YX(1, 14), ['edit'])
646         edit_widget.children += [edit_line_widget]
647         turn_widget = TextLineWidget('TURN:', self, YX(2, 0), YX(1, 20))
648         turn_widget.children += [TurnWidget(self, YX(2, 6), YX(1, 14), ['turn'])]
649         health_widget = TextLineWidget('HEALTH:', self, YX(3, 0), YX(1, 20))
650         health_widget.children += [HealthWidget(self, YX(3, 8), YX(1, 12), ['turn'])]
651         log_widget = LogWidget(self, YX(5, 0), YX(None, 20), ['log'])
652         descriptor_widget = DescriptorWidget(self, YX(5, 0), YX(None, 20),
653                                              ['map'], False)
654         map_widget = MapWidget(self, YX(0, 21), YX(None, None), ['map'])
655         inventory_widget = ItemsSelectorWidget('INVENTORY:',
656                                                self.game.player_inventory,
657                                                self, YX(0, 21), YX(None, None),
658                                                ['inventory'], False)
659         pickable_items_widget = ItemsSelectorWidget('PICKABLE:',
660                                                     self.game.pickable_items,
661                                                     self, YX(0, 21),
662                                                     YX(None, None),
663                                                     ['pickable_items'],
664                                                     False)
665         top_widgets = [edit_widget, turn_widget, health_widget, log_widget,
666                        descriptor_widget, map_widget, inventory_widget,
667                        pickable_items_widget]
668         popup_widget = PopUpWidget(self, YX(0, 0), YX(1, 1), visible=False)
669
670         # Ensure initial window state before loop starts.
671         for w in top_widgets:
672             w.ensure_freshness(True)
673         self.socket.send('GET_GAMESTATE')
674         write_mode = False
675         while True:
676
677             # Draw screen.
678             for w in top_widgets:
679                 if w.ensure_freshness():
680                     self.draw_popup_if_visible = True
681             if popup_widget.visible and self.draw_popup_if_visible:
682                 popup_widget.ensure_freshness(True)
683                 self.draw_popup_if_visible = False
684             for k in self.to_update.keys():
685                 self.to_update[k] = False
686
687             # Handle input from server.
688             while True:
689                 try:
690                     command = self.queue.get(block=False)
691                 except queue.Empty:
692                     break
693                 self.game.handle_input(command)
694
695             # Handle keys (and resize event read as key).
696             try:
697                 key = self.stdscr.getkey()
698                 if key == 'KEY_RESIZE':
699                     curses.endwin()
700                     setup_screen(curses.initscr())
701                     for w in top_widgets:
702                         w.size = w.size_def
703                         w.ensure_freshness(True)
704                 elif key == '\t':  # Tabulator key.
705                     write_mode = False if write_mode else True
706                 elif write_mode:
707                     try_write_keys()
708                 elif key == 't':
709                     toggle_popup()
710                 elif map_widget.visible:
711                     if key == '?':
712                         toggle_examiner_mode()
713                     elif key == 'p':
714                         self.socket.send('GET_PICKABLE_ITEMS')
715                         switch_to_pick_or_drop(pickable_items_widget)
716                     elif key == 'i':
717                         switch_to_pick_or_drop(inventory_widget)
718                     elif self.examiner_mode:
719                         try_examiner_keys()
720                     else:
721                         try_player_move_keys()
722                 elif pickable_items_widget.visible:
723                     pickup_menu(key)
724                 elif inventory_widget.visible:
725                     inventory_menu(key)
726             except curses.error:
727                 pass
728
729             # Quit when server recommends it.
730             if self.game.do_quit:
731                 break
732
733
734 s = socket.create_connection(('127.0.0.1', 5000))
735 plom_socket = PlomSocket(s)
736 game = Game()
737 q = queue.Queue()
738 t = threading.Thread(target=recv_loop, args=(plom_socket, game, q))
739 t.start()
740 TUI(plom_socket, game, q)