Merge pull request #934 from otizonaizit/overlays

Add `paint_background` method to `Bot` object to paint cells in the maze with user-defined colors and show it in TK viewer in debug mode

Author: otizonaizit

pelita/game.py

@@ -445,6 +445,15 @@ def setup_game(team_specs, *, layout_dict, max_rounds=300, rng=None,
         #: Messages the bots say. Keeps only the recent one at the respective bot’s index.
         say=[""] * 4,
 
+        #: List of 4 lists to store the cell overlays for each bot
+        # Items of each list are dictionaries in the form:
+        # { 'pos' : (x, y), 'color' : "#AABBCC', ... }
+        # where (x, y) are coordinates on the maze and color is HTML-encoded
+        # At the moment only property 'color' is used by the TK-viewer,
+        # but more can be added without modifying the network protocol or
+        # this list
+        overlays=[[], [], [], []],
+
         ### Internal
         #: Internal team representation
         teams=[None] * 2,
@@ -865,6 +874,14 @@ def play_turn(game_state, raise_bot_exceptions=False):
     else:
         game_state['say'][game_state['turn']] = ""
 
+    # reset the overlays so that they are painted new at every turn
+    game_state['overlays'] = [[], [], [], []]
+
+    if position_dict.get('overlay'):
+        game_state['overlays'][game_state['turn']] = position_dict['overlay']
+    else:
+        game_state['overlays'][game_state['turn']] = []
+
     # If the returned move looks okay, we add it to the list of requested moves
     old_position = game_state['bots'][turn]
     game_state['requested_moves'][turn] = {

pelita/team.py

@@ -122,6 +122,36 @@ def sanitize_say(string):
     return ''.join(sane)
 
 
+def convert_overlay_to_json(overlay):
+    """Convert the overlay dictionary to a list of dictionaries for JSON compatibility
+
+    Parameters
+    ----------
+    overlay : dict
+        A dictionary { pos : props } where pos are coordinates in the maze, like
+        for example ( 10, 12) and props is a dictionary of properties, for example:
+
+           {
+            'color' : '#AABBCC',
+            'text'  : 'special text',
+            ...
+           }
+
+    Returns
+    -------
+    A list of dictionaries in the form
+        [ { 'pos' : pos0, 'color' : '#AABBCC', 'text' : 'special text'},
+          { 'pos' : pos1, 'color' : '#BBCCDD', 'text' : 'other text'},
+          ...
+        ]
+
+    Note
+    ----
+    The conversion is necessary because JSON does not support dictionaries
+    with tuples/lists as keys.
+    """
+    return [dict(pos=pos, **props) for pos, props in overlay.items()]
+
 class Team:
     """
     Wraps a move function and forwards it the `set_initial`
@@ -255,6 +285,7 @@ def get_move(self, game_state):
         move = self.apply_move_fn(self._team_move, team[me._bot_turn], self._state)
         if "error" not in move:
             move["say"] = me._say
+            move["overlay"] = convert_overlay_to_json(me._overlay)
         return move
 
     @staticmethod
@@ -649,6 +680,7 @@ def __init__(self, *, bot_index,
                           bot_turn=None):
         self._bots = None
         self._say = None
+        self._overlay = {}
 
         #: The previous positions of this bot including the current one.
         self.track = []
@@ -728,6 +760,59 @@ def say(self, text):
         # sanitize text so that funny users can't break the GUI
         self._say = sanitize_say(str(text))
 
+    def paint_background(self, pos, color='#96FF96'):
+        """ Color background of cell at position pos in the maze with the specified color
+
+        Parameters
+        ----------
+        pos : 2-tuple
+
+            where pos = (x, y) are the coordinates of the cell in the maze that you want
+            to set the background of, and "color" is a string representing an
+            HTML-encoded color for that cell.
+
+            For example:
+            >>> bot.paint_background((10, 10))
+
+            To paint the cell at (10, 10) with the default light yellow background, or:
+
+            >>> bot.paint_background((10, 10), color="#FFFFA8")
+
+            To paint it instead with a light green background
+
+        Note
+        ----
+        Painting the background only works with viewers that support it, like the built-in
+        Tk-viewer in debug mode.
+        """
+
+        width, height = self.shape
+        # first verify that position is list/tuple of length two
+        try:
+            x, y = pos
+            x = int(x)
+            y = int(y)
+        except (TypeError, ValueError):
+            msg = f'Position "{pos}" is not a valid coordinate (x, y).'
+            raise ValueError(msg)
+
+        # check: coordinates fit in the maze
+        if x < 0 or x >= width or y < 0 or y >= height:
+            # just ignore this coordinate
+            return
+
+        # check: color is a string that can be interpreted as a 6 digit hexadecimal number
+        if (not color.startswith('#')) or len(color) != 7:
+            msg = f'Background color "{color}"  is not a valid color.'
+            raise ValueError(msg)
+        try:
+            int(color[1:], base=16)
+        except (TypeError, ValueError):
+            msg = f'Background color "{color}"  is not a valid color.'
+            raise ValueError(msg)
+
+        self._overlay.setdefault((x, y), {}).update({'color' : color})
+
     # def get_direction(self, position):
         # """ Return the direction needed to get to the given position.
 

pelita/ui/tk_canvas.py

@@ -483,7 +483,7 @@ def update(self, game_state=None, redraw=False):
             self.draw_end_of_game(None)
 
     def draw_universe(self, game_state, redraw):
-        self.draw_overlay(game_state.get('overlays', []))
+        self.draw_overlays(game_state.get('overlays', []))
         self.draw_grid(redraw=redraw)
         self.draw_selected(game_state)
         self.draw_line_of_sight(game_state)
@@ -563,25 +563,25 @@ def draw_line(x0, y0, x1, y1):
         y_pos = self.mesh_graph.mesh_to_screen_y(0, -0.7)
         self.ui_game_canvas.create_text(x_pos, y_pos, text="y", **label_style)
 
-    def draw_overlay(self, overlays):
-        """ Draws a light grid on the background.
+    def draw_overlays(self, overlays):
+        """ Draws overlays on top of cells at given coordinates.
         """
-        self.ui_game_canvas.delete("overlay")
+        self.ui_game_canvas.delete("overlays")
         if not self._grid_enabled:
             return
 
-        def draw_box(pos, fill_col):
+        def draw_color_box(pos, fill_col):
             ul = self.mesh_graph.mesh_to_screen(pos, (-1, -1))
             lr = self.mesh_graph.mesh_to_screen(pos, (1, 1))
+            self.ui_game_canvas.create_rectangle(*ul, *lr, width=0, fill=fill_col, tags=("overlays",))
 
-            self.ui_game_canvas.create_rectangle(*ul, *lr, width=0, fill=fill_col, tags=("overlay",))
-
-        for overlay in overlays:
-            if fill_col := overlay.get("fill"):
-                for pos in overlay.get("pos", []):
-                    draw_box(pos, fill_col)
+        for bot_overlays in overlays:
+            for prop in bot_overlays:
+                # paint background if color is specified in the bot overlay
+                if 'color' in prop:
+                    draw_color_box(prop['pos'], prop['color'])
 
-        self.ui_game_canvas.tag_lower("overlay")
+        self.ui_game_canvas.tag_lower("overlays")
         self.ui_game_canvas.tag_raise("wall")
 
     def draw_line_of_sight(self, game_state):

test/test_network.py

@@ -123,7 +123,8 @@ def stopping(bot, state):
         '__uuid__': _uuid,
         '__return__': {
             "move": [1, 1],
-            "say": None
+            "say": None,
+            "overlay" : [],
         }
     }
 

test/test_team.py

@@ -6,7 +6,7 @@
 from pelita.gamestate_filters import manhattan_dist
 from pelita.layout import initial_positions, parse_layout
 from pelita.maze_generator import generate_maze
-
+from pelita.exceptions import PelitaBotError
 
 def stopping(bot, state):
     return bot.position
@@ -767,3 +767,149 @@ def speaking_team(bot, state):
     # check that we finished without problem
     assert state['round'] == 1
     assert state['turn'] == 3
+
+
+def test_valid_paint_background():
+    test_layout = """
+        ##################
+        #.#... .##.     y#
+        # # #  .  .### #x#
+        # ####.   .      #
+        #      .   .#### #
+        #a# ###.  .  # # #
+        #b     .##. ...#.#
+        ##################
+    """
+    overlay = [
+               ((0,0) , "#AABBCC"),
+               ((1,1) , "#BBCCDD"),
+               ((100, 200) , "#DDCCAA"), # silently ignore coords out of the maze
+               ]
+
+    parsed = parse_layout(test_layout)
+
+    def overlay_team(bot, state):
+        for pos, color in overlay:
+            bot.paint_background(pos, color=color)
+        return bot.position
+
+    state = setup_game([overlay_team, overlay_team], max_rounds=2, layout_dict=parsed, raise_bot_exceptions=True)
+
+    overlay_in_maze = [{'pos':(0,0), 'color':"#AABBCC"}, {'pos':(1,1), 'color':"#BBCCDD"}]
+    for idx in range(4):
+        state = play_turn(state)
+        gs_overlay = state['overlays'][idx]
+        assert gs_overlay == overlay_in_maze
+
+
+@pytest.mark.parametrize('pos, color, match', [
+    ((0,1,2), '#AABBCC', 'Position.+(0, 1, 2).+not a valid'), # position has too many values
+    ('#AABBCC', (0, 1), 'Position.+#AABBCC.+not a valid'), # swapped arguments
+    ((1, 2), 'white', 'Background color "white".+'), # color is not HTML encoded
+    ((1, 2),'#AABBCCDDEE', 'Background color.+AABBCCDDEE.+'), # color uses alpha channel
+    ((1, 2),'#GGGGGG', 'Background color.+GGGGGG.+'), # color out of range
+    ])
+def test_paint_background_exceptions(pos, color, match):
+    test_layout = """
+        ##################
+        #.#... .##.     y#
+        # # #  .  .### #x#
+        # ####.   .      #
+        #      .   .#### #
+        #a# ###.  .  # # #
+        #b     .##. ...#.#
+        ##################
+    """
+    parsed = parse_layout(test_layout)
+
+    def overlay_team(bot, state):
+        bot.paint_background(pos, color)
+        return bot.position
+
+    state = setup_game([overlay_team, overlay_team], max_rounds=2, layout_dict=parsed, raise_bot_exceptions=True)
+    with pytest.raises(PelitaBotError, match=match):
+        state = play_turn(state, raise_bot_exceptions=True)
+
+
+def test_paint_background_doesnt_overwrite():
+    # check that we do override color for a coordinate if already set and
+    # that we don't touch other properties that may be defined on that coordinate
+    test_layout = """
+        ##################
+        #.#... .##.     y#
+        # # #  .  .### #x#
+        # ####.   .      #
+        #      .   .#### #
+        #a# ###.  .  # # #
+        #b     .##. ...#.#
+        ##################
+    """
+    parsed = parse_layout(test_layout)
+
+    pos = (0, 1)
+    color = '#FFFFFF'
+    def overlay_team(bot, state):
+        bot.paint_background(pos, '#AABBCC')
+        bot._overlay[pos].update({'text' : 'something'})
+        bot.paint_background(pos, color)
+        return bot.position
+
+    state = setup_game([overlay_team, overlay_team], max_rounds=2, layout_dict=parsed, raise_bot_exceptions=True)
+
+    for idx in range(4):
+        state = play_turn(state)
+        gs_overlay = state['overlays'][idx]
+        assert gs_overlay == [{'pos':(0,1), 'color':'#FFFFFF', 'text':'something'}]
+
+
+def test_paint_background_different_bots():
+    test_layout = """
+        ##################
+        #.#... .##.     y#
+        # # #  .  .### #x#
+        # ####.   .      #
+        #      .   .#### #
+        #a# ###.  .  # # #
+        #b     .##. ...#.#
+        ##################
+    """
+    parsed = parse_layout(test_layout)
+
+    # blue team
+    pos0 = (0, 0)
+    color0 = '#FFFFF0'
+    pos2 = (0, 2)
+    color2 = '#FFFFF2'
+    def overlay_team_blue(bot, state):
+        if bot.turn == 0:
+            bot.paint_background(pos0, color0)
+        else:
+            bot.paint_background(pos2, color2)
+        return bot.position
+
+    # red team
+    pos1 = (0, 1)
+    color1 = '#FFFFF1'
+    pos3 = (0, 3)
+    color3 = '#FFFFF3'
+    def overlay_team_red(bot, state):
+        if bot.turn == 0:
+            bot.paint_background(pos1, color1)
+        else:
+            bot.paint_background(pos3, color3)
+        return bot.position
+
+    state = setup_game([overlay_team_blue, overlay_team_red], max_rounds=2, layout_dict=parsed, raise_bot_exceptions=True)
+
+    pos_color = [(pos0, color0), (pos1, color1), (pos2, color2), (pos3, color3)]
+    for idx in range(4):
+        pos, color = pos_color[idx]
+        state = play_turn(state)
+        gs_overlay = state['overlays'][idx]
+        rest_left = state['overlays'][:idx]
+        rest_right = state['overlays'][idx+1:]
+        assert gs_overlay == [{'pos' : pos, 'color': color}]
+        # verify that the overlays get overriden at every turn
+        for overlay in rest_left+rest_right:
+            assert overlay == []
+