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