home · contact · privacy
Use dedicated MapWidget in client.
[plomrogue2-experiments] / client.py
index 9d0da0d534399be8f546258d8976036ac53c9eb6..6e22d0006f4d911d06c1373faf968a836b17a206 100755 (executable)
--- a/client.py
+++ b/client.py
@@ -7,10 +7,6 @@ from parser import ArgError, Parser
 import game_common
 
 
-def get_map_class(geometry):
-    return globals()['Map' + geometry]
-
-
 class MapSquare(game_common.Map):
 
     def list_terrain_to_lines(self, terrain_as_list):
@@ -18,16 +14,16 @@ class MapSquare(game_common.Map):
         map_lines = []
         start_cut = 0
         while start_cut < len(terrain):
-            limit = start_cut + self.game.world.map_.size[1]
+            limit = start_cut + self.size[1]
             map_lines += [terrain[start_cut:limit]]
             start_cut = limit
-        return "\n".join(map_lines)
+        return map_lines
 
 
 class MapHex(game_common.Map):
 
     def list_terrain_to_lines(self, terrain_as_list):
-        new_terrain_list = []
+        new_terrain_list = [' ']
         x = 0
         y = 0
         for c in terrain_as_list:
@@ -37,27 +33,33 @@ class MapHex(game_common.Map):
                 new_terrain_list += ['\n']
                 x = 0
                 y += 1
-                if y % 2 != 0:
+                if y % 2 == 0:
                     new_terrain_list += [' ']
-        return ''.join(new_terrain_list)
+        return ''.join(new_terrain_list).split('\n')
+
+
+map_manager = game_common.MapManager(globals())
 
 
 class World(game_common.World):
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, game, *args, **kwargs):
         """Extend original with local classes and empty default map.
 
         We need the empty default map because we draw the map widget
         on any update, even before we actually receive map data.
         """
         super().__init__(*args, **kwargs)
-        self.get_map_class = get_map_class
-        self.map_ = self.get_map_class('Hex')()
+        self.game = game
+        self.map_ = self.game.map_manager.get_map_class('Hex')()
 
 
 class Game(game_common.CommonCommandsMixin):
-    world = World()
-    log_text = ''
+
+    def __init__(self):
+        self.map_manager = map_manager
+        self.world = World(self)
+        self.log_text = ''
 
     def log(self, msg):
         """Prefix msg plus newline to self.log_text."""
@@ -98,13 +100,23 @@ class WidgetManager:
         """Set up all urwid widgets we want on the screen."""
         self.game = game
         edit_widget = self.EditToSocketWidget(socket, 'SEND: ')
-        self.map_widget = urwid.Text('', wrap='clip')
+        self.map_widget = self.MapWidget()
         self.turn_widget = urwid.Text('')
         self.log_widget = urwid.Text('')
-        map_box = urwid.Padding(self.map_widget, width=50)
-        widget_pile = urwid.Pile([edit_widget, map_box, self.turn_widget,
-                                  self.log_widget])
-        self.top = urwid.Filler(widget_pile, valign='top')
+        edit_map = urwid.AttrMap(edit_widget, 'foo')
+        turn_map = urwid.AttrMap(self.turn_widget, 'bar')
+        log_map = urwid.AttrMap(self.log_widget, 'baz')
+        widget_pile = urwid.Pile([('pack', edit_map),
+                                  ('pack', urwid.Divider()),
+                                  ('pack', turn_map),
+                                  ('pack', urwid.Divider()),
+                                  ('pack', log_map),
+                                  urwid.SolidFill(fill_char=' ')])
+        self.top = urwid.Columns([(20, widget_pile), self.map_widget],
+                                       dividechars=1)
+        self.palette = [('foo', 'white', 'dark red'),
+                        ('bar', 'white', 'dark blue'),
+                        ('baz', 'white', 'dark green')]
 
     def draw_map(self):
         """Draw map view from .game.map_.terrain, .game.things."""
@@ -113,12 +125,25 @@ class WidgetManager:
             pos_i = self.game.world.map_.get_position_index(t.position)
             terrain_as_list[pos_i] = self.game.symbol_for_type(t.type_)
         return self.game.world.map_.list_terrain_to_lines(terrain_as_list)
+        #text = self.game.world.map_.list_terrain_to_lines(terrain_as_list)
+        #new_map_text = []
+        #for char in text:
+        #    if char == '.':
+        #        new_map_text += [('foo', char)]
+        #    elif char in {'x', 'X', '#'}:
+        #        new_map_text += [('bar', char)]
+        #    elif char in {'@', 'm'}:
+        #        new_map_text += [('baz', char)]
+        #    else:
+        #        new_map_text += [char]
+        #return new_map_text
 
     def update(self):
         """Redraw all non-edit widgets."""
         self.turn_widget.set_text('TURN: ' + str(self.game.world.turn))
         self.log_widget.set_text(self.game.log_text)
-        self.map_widget.set_text(self.draw_map())
+        self.map_widget.text = self.draw_map()
+        self.map_widget._invalidate()
 
     class EditToSocketWidget(urwid.Edit):
         """Extends urwid.Edit with socket to send input on 'enter' to."""
@@ -134,6 +159,27 @@ class WidgetManager:
             plom_socket_io.send(self.socket, self.edit_text)
             self.edit_text = ''
 
+    class MapWidget(urwid.Widget):
+        _sizing = frozenset(['box'])
+        text = ['']
+
+        def render(self, size, focus=False):
+            maxcol, maxrow = size
+            content = []
+            for y in range(len(self.text)):
+                if y < maxrow:
+                    line = self.text[y]
+                    if len(line) < maxcol:
+                        line = line + '0' * (maxcol - len(line))
+                    else:
+                        line = line[:maxcol]
+                    content += [line.encode('utf-8')]
+            padding_y = maxrow - len(content)
+            if padding_y > 0:
+                for y in range(padding_y):
+                    content += ['0'.encode('utf-8') * maxcol]
+            return urwid.TextCanvas(content)
+
 
 class PlomRogueClient:
 
@@ -164,7 +210,8 @@ class PlomRogueClient:
         self.socket = socket
         self.widget_manager = WidgetManager(self.socket, self.game)
         self.server_output = []
-        self.urwid_loop = urwid.MainLoop(self.widget_manager.top)
+        self.urwid_loop = urwid.MainLoop(self.widget_manager.top,
+                                         self.widget_manager.palette)
         self.urwid_pipe_write_fd = self.urwid_loop.watch_pipe(self.
                                                               handle_input)
         self.recv_loop_thread = threading.Thread(target=self.recv_loop)