plomlompom.com Git - plomrogue2-experiments/blob - 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, indent_first_line):
  37
  38         def map_cells_to_lines(map_cells):
  39             map_view_chars = []
  40             if indent_first_line:
  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 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')
  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, offset, size):
  89     game.new_map(offset, size)
  90 cmd_VISIBLE_MAP.argtypes = 'yx_tuple yx_tuple:pos'
  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, offset, size):
 157         self.map_ = ClientMap(size)
 158         self.offset = offset
 159
 160     @property
 161     def player(self):
 162         return self.get_thing(self.player_id)
 163
 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
 170             return f
 171         return None
 172
 173     def get_string_options(self, string_option_type):
 174         return None
 175
 176     def handle_input(self, msg):
 177         self.log(msg)
 178         if msg == 'BYE':
 179             self.do_quit = True
 180             return
 181         try:
 182             command, args = self.parser.parse(msg)
 183             if command is None:
 184                 self.log('UNHANDLED INPUT: ' + msg)
 185             else:
 186                 command(*args)
 187         except ArgError as e:
 188             self.log('ARGUMENT ERROR: ' + msg + '\n' + str(e))
 189
 190     def log(self, msg):
 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
 194
 195     def symbol_for_type(self, type_):
 196         symbol = '?'
 197         if type_ == 'human':
 198             symbol = '@'
 199         elif type_ == 'monster':
 200             symbol = 'm'
 201         elif type_ == 'food':
 202             symbol = 'f'
 203         return symbol
 204
 205
 206 ASCII_printable = ' !"#$%&\'\(\)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX'\
 207                   'YZ[\\]^_\`abcdefghijklmnopqrstuvwxyz{|}~'
 208
 209
 210 def recv_loop(plom_socket, game, q):
 211     for msg in plom_socket.recv():
 212         q.put(msg)
 213
 214
 215 class Widget:
 216
 217     def __init__(self, tui, start, size, check_updates=[], visible=True):
 218         self.check_updates = check_updates
 219         self.tui = tui
 220         self.start = start
 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
 223         self.size = size
 224         self.do_update = True
 225         self.visible = visible
 226         self.children = []
 227
 228     @property
 229     def size(self):
 230         return YX(*self.win.getmaxyx())
 231
 232     @size.setter
 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())
 237         if n_lines is None:
 238             n_lines = getmaxyx.y - self.start.y
 239         if n_cols is None:
 240             n_cols = getmaxyx.x - self.start.x
 241         self.win.resize(n_lines, n_cols)
 242
 243     def __len__(self):
 244         getmaxyx = YX(*self.win.getmaxyx())
 245         return getmaxyx.y * getmaxyx.x
 246
 247     def safe_write(self, foo):
 248
 249         def to_chars_with_attrs(part):
 250             attr = curses.A_NORMAL
 251             part_string = part
 252             if not type(part) == str:
 253                 part_string = part[0]
 254                 attr = part[1]
 255             return [(char, attr) for char in part_string]
 256
 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)
 260         else:
 261             for part in foo:
 262                 chars_with_attrs += to_chars_with_attrs(part)
 263         self.win.move(0, 0)
 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, ' ')
 273             self.win.move(0, 0)
 274             for char_with_attr in cut:
 275                 self.win.addstr(char_with_attr[0], char_with_attr[1])
 276
 277     def ensure_freshness(self, do_refresh=False):
 278         did_refresh = False
 279         if self.visible:
 280             if not do_refresh:
 281                 for key in self.check_updates:
 282                     if key in self.tui.to_update and self.tui.to_update[key]:
 283                         do_refresh = True
 284                         break
 285             if do_refresh:
 286                 self.win.erase()
 287                 self.draw()
 288                 self.win.refresh()
 289                 did_refresh = True
 290             for child in self.children:
 291                 did_refresh = child.ensure_freshness(do_refresh) | did_refresh
 292         return did_refresh
 293
 294
 295 class EditWidget(Widget):
 296
 297     def draw(self):
 298         self.safe_write((''.join(self.tui.to_send), curses.color_pair(1)))
 299
 300
 301 class TextLinesWidget(Widget):
 302
 303     def draw(self):
 304         lines = self.get_text_lines()
 305         line_width = self.size.x
 306         to_join = []
 307         for line in lines:
 308             to_pad = line_width - (len(line) % line_width)
 309             if to_pad == line_width:
 310                 to_pad = 0
 311             to_join += [line + ' '*to_pad]
 312         self.safe_write((''.join(to_join), curses.color_pair(3)))
 313
 314
 315 class LogWidget(TextLinesWidget):
 316
 317     def get_text_lines(self):
 318         return self.tui.game.log_text.split('\n')
 319
 320
 321 class DescriptorWidget(TextLinesWidget):
 322
 323     def get_text_lines(self):
 324         lines = []
 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]
 328         lines = [terrain]
 329         for t in self.tui.game.things_at_pos(self.tui.examiner_position):
 330             lines += [t.type_]
 331         return lines
 332
 333
 334 class PopUpWidget(Widget):
 335
 336     def draw(self):
 337         self.safe_write(self.tui.popup_text)
 338
 339     def reconfigure(self):
 340         size = (1, len(self.tui.popup_text))
 341         self.size = size
 342         self.size_def = size
 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)
 348
 349
 350 class ItemsSelectorWidget(Widget):
 351
 352     def __init__(self, headline, selection, *args, **kwargs):
 353         super().__init__(*args, **kwargs)
 354         self.headline = headline
 355         self.selection = selection
 356
 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)
 367
 368     def draw(self):
 369         lines = [self.headline]
 370         counter = 0
 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_)]
 375             counter += 1
 376         line_width = self.size.x
 377         to_join = []
 378         for line in lines:
 379             to_pad = line_width - (len(line) % line_width)
 380             if to_pad == line_width:
 381                 to_pad = 0
 382             to_join += [line + ' '*to_pad]
 383         self.safe_write((''.join(to_join), curses.color_pair(3)))
 384
 385
 386 class MapWidget(Widget):
 387
 388     def draw(self):
 389
 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:
 394                     continue
 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'}:
 400                         symbol = old_symbol
 401                     terrain_as_list[pos_i] = (symbol, '+')
 402                 else:
 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
 409
 410         def pad_or_cut_x(lines):
 411             line_width = self.size.x
 412             for y in range(len(lines)):
 413                 line = lines[y]
 414                 if line_width > len(line):
 415                     to_pad = line_width - (len(line) % line_width)
 416                     lines[y] = line + '0' * to_pad
 417                 else:
 418                     lines[y] = line[:line_width]
 419
 420         def pad_y(lines):
 421             if len(lines) < self.size.y:
 422                 to_pad = self.size.y - len(lines)
 423                 lines += to_pad * ['0' * self.size.x]
 424
 425         def lines_to_colored_chars(lines):
 426             chars_with_attrs = []
 427             for c in ''.join(lines):
 428                 if c in {'@', 'm'}:
 429                     chars_with_attrs += [(c, curses.color_pair(1))]
 430                 elif c == 'f':
 431                     chars_with_attrs += [(c, curses.color_pair(4))]
 432                 elif c == '.':
 433                     chars_with_attrs += [(c, curses.color_pair(2))]
 434                 elif c in {'x', 'X', '#'}:
 435                     chars_with_attrs += [(c, curses.color_pair(3))]
 436                 elif c == '?':
 437                     chars_with_attrs += [(c, curses.color_pair(5))]
 438                 else:
 439                     chars_with_attrs += [c]
 440             return chars_with_attrs
 441
 442         if self.tui.game.map_.terrain == '':
 443             lines = []
 444             pad_y(lines)
 445             self.safe_write(''.join(lines))
 446             return
 447
 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,
 455                                indent_first_line)
 456         pad_or_cut_x(lines)
 457         pad_y(lines)
 458         self.safe_write(lines_to_colored_chars(lines))
 459
 460
 461 class TurnWidget(Widget):
 462
 463     def draw(self):
 464         self.safe_write((str(self.tui.game.turn), curses.color_pair(2)))
 465
 466
 467 class HealthWidget(Widget):
 468
 469     def draw(self):
 470         if hasattr(self.tui.game.player, 'health'):
 471             self.safe_write((str(self.tui.game.player.health),
 472                              curses.color_pair(2)))
 473
 474
 475 class TextLineWidget(Widget):
 476
 477     def __init__(self, text_line, *args, **kwargs):
 478         self.text_line = text_line
 479         super().__init__(*args, **kwargs)
 480
 481     def draw(self):
 482         self.safe_write(self.text_line)
 483
 484
 485 class TUI:
 486
 487     def __init__(self, plom_socket, game, q):
 488         self.socket = plom_socket
 489         self.game = game
 490         self.game.tui = self
 491         self.queue = q
 492         self.parser = Parser(self.game)
 493         self.to_update = {}
 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'
 498         self.to_send = []
 499         self.draw_popup_if_visible = True
 500         curses.wrapper(self.loop)
 501
 502     def loop(self, stdscr):
 503
 504         def setup_screen(stdscr):
 505             self.stdscr = stdscr
 506             self.stdscr.refresh()  # will be called by getkey else, clearing screen
 507             self.stdscr.timeout(10)
 508
 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
 514
 515         def selectables_menu(key, widget, selectables, f):
 516             if key == 'c':
 517                 switch_widgets(widget, map_widget)
 518             elif key == 'j':
 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):
 523                 return
 524             trigger = widget.check_updates[0]
 525             self.to_update[trigger] = True
 526
 527         def pickup_menu(key):
 528
 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')
 534                 else:
 535                     return False
 536                 return True
 537
 538             selectables_menu(key, pickable_items_widget,
 539                              self.game.pickable_items, f)
 540
 541         def inventory_menu(key):
 542
 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_)
 550                 else:
 551                     return False
 552                 return True
 553
 554             selectables_menu(key, inventory_widget,
 555                              self.game.player_inventory, f)
 556
 557         def move_examiner(direction):
 558             start_pos = self.examiner_position
 559             new_examine_pos = self.game.map_geometry.move(start_pos, direction,
 560                                                           self.game.map_.size)
 561             if new_examine_pos[0] == (0,0):
 562                 self.examiner_position = new_examine_pos
 563             self.to_update['map'] = True
 564
 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)
 571
 572         def toggle_examiner_mode():
 573             if self.examiner_mode:
 574                 self.examiner_mode = False
 575                 switch_widgets(descriptor_widget, log_widget)
 576             else:
 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
 581
 582         def toggle_popup():
 583             if popup_widget.visible:
 584                 popup_widget.visible = False
 585                 for w in top_widgets:
 586                     w.ensure_freshness(True)
 587             else:
 588                 self.to_update['popup'] = True
 589                 popup_widget.visible = True
 590                 popup_widget.reconfigure()
 591                 self.draw_popup_if_visible = True
 592
 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))
 603                 self.to_send[:] = []
 604                 self.to_update['edit'] = True
 605
 606         def try_examiner_keys():
 607             if key == 'w':
 608                 move_examiner('UPLEFT')
 609             elif key == 'e':
 610                 move_examiner('UPRIGHT')
 611             elif key == 's':
 612                 move_examiner('LEFT')
 613             elif key == 'd':
 614                 move_examiner('RIGHT')
 615             elif key == 'x':
 616                 move_examiner('DOWNLEFT')
 617             elif key == 'c':
 618                 move_examiner('DOWNRIGHT')
 619
 620         def try_player_move_keys():
 621             if 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
 634         def init_colors():
 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)
 640
 641         # Basic curses initialization work.
 642         setup_screen(stdscr)
 643         curses.curs_set(False)  # hide cursor
 644         init_colors()
 645
 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),
 656                                              ['map'], False)
 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,
 664                                                     self, YX(0, 21),
 665                                                     YX(None, None),
 666                                                     ['pickable_items'],
 667                                                     False)
 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)
 672
 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')
 677         write_mode = False
 678         while True:
 679
 680             # Draw screen.
 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
 689
 690             # Handle input from server.
 691             while True:
 692                 try:
 693                     command = self.queue.get(block=False)
 694                 except queue.Empty:
 695                     break
 696                 self.game.handle_input(command)
 697
 698             # Handle keys (and resize event read as key).
 699             try:
 700                 key = self.stdscr.getkey()
 701                 if key == 'KEY_RESIZE':
 702                     curses.endwin()
 703                     setup_screen(curses.initscr())
 704                     for w in top_widgets:
 705                         w.size = w.size_def
 706                         w.ensure_freshness(True)
 707                 elif key == '\t':  # Tabulator key.
 708                     write_mode = False if write_mode else True
 709                 elif write_mode:
 710                     try_write_keys()
 711                 elif key == 't':
 712                     toggle_popup()
 713                 elif map_widget.visible:
 714                     if key == '?':
 715                         toggle_examiner_mode()
 716                     elif key == 'p':
 717                         self.socket.send('GET_PICKABLE_ITEMS')
 718                         switch_to_pick_or_drop(pickable_items_widget)
 719                     elif key == 'i':
 720                         switch_to_pick_or_drop(inventory_widget)
 721                     elif self.examiner_mode:
 722                         try_examiner_keys()
 723                     else:
 724                         try_player_move_keys()
 725                 elif pickable_items_widget.visible:
 726                     pickup_menu(key)
 727                 elif inventory_widget.visible:
 728                     inventory_menu(key)
 729             except curses.error:
 730                 pass
 731
 732             # Quit when server recommends it.
 733             if self.game.do_quit:
 734                 break
 735
 736
 737 s = socket.create_connection(('127.0.0.1', 5000))
 738 plom_socket = PlomSocket(s)
 739 game = Game()
 740 q = queue.Queue()
 741 t = threading.Thread(target=recv_loop, args=(plom_socket, game, q))
 742 t.start()
 743 TUI(plom_socket, game, q)