Feature/double rainbow

pelita/scripts/pelita_tkviewer.py

@@ -49,6 +49,7 @@ def geometry_string(s):
                                   ' LOGFILE (default \'stderr\')',
                     metavar='LOGFILE', const='-', nargs='?')
 
+
 def main():
     args = parser.parse_args()
     if args.version:

pelita/ui/tk_canvas.py

@@ -38,6 +38,11 @@
 
 _logger = logging.getLogger(__name__)
 
+def col(red, green, blue):
+    """Convert the given colours [0, 255] to HTML hex colours."""
+    return "#%02x%02x%02x" % (red, green, blue)
+
+
 # Design variables
 #
 # The size of the status section on the bottom is generated automatically.
@@ -256,7 +261,7 @@ def screen(self, model_x, model_y):
 
 class TkApplication:
     def __init__(self, window, controller_address=None,
-                 geometry=None, delay=1, stop_after=None, stop_after_kill=False, fullscreen=False):
+                 geometry=None, delay=1, stop_after=None, stop_after_kill=False, fullscreen=False, rainbow=False):
         self.window = window
         self.window.configure(background="white")
 
@@ -281,6 +286,7 @@ def __init__(self, window, controller_address=None,
         self._default_font_size = self._default_font.cget('size')
 
         self._grid_enabled = False
+        self._rainbow = rainbow
 
         self.selected = None
 
@@ -456,6 +462,14 @@ def update(self, game_state=None, redraw=False):
             if self._default_font.cget('size') != self._default_font_size:
                 self._default_font.configure(size=self._default_font_size)
 
+        if self._rainbow:
+            import random
+            r = random.randint(0, 15)
+            g = random.randint(0, 15)
+            b = random.randint(0, 15)
+            self.ui_game_canvas.configure(background=col(r*16, g*16, b*16))
+            redraw = True
+
         self.draw_universe(game_state, redraw=redraw)
 
         eaten_food = []
@@ -1022,14 +1036,20 @@ def draw_maze(self, game_state, redraw):
         # them otherwise
         self.wall_items = []
         num = 0
+        self.t = getattr(self, "t", 0) + 1
+        if self._rainbow:
+            self.t = getattr(self, "t", 0) + 1
         for wall in game_state['walls']:
             model_x, model_y = wall
             wall_neighbors = [(dx, dy)
                               for dx in [-1, 0, 1]
                               for dy in [-1, 0, 1]
                               if (model_x + dx, model_y + dy) in game_state['walls']]
             wall_item = Wall(self.mesh_graph, wall_neighbors=wall_neighbors, position=(model_x, model_y))
-            wall_item.draw(self.ui_game_canvas)
+            if self._rainbow:
+                wall_item.draw(self.ui_game_canvas, self.t)
+            else:
+                wall_item.draw(self.ui_game_canvas)
             self.wall_items.append(wall_item)
             num += 1
 

pelita/ui/tk_sprites.py

@@ -23,6 +23,12 @@
 
 FOOD_WARNING_TIME = 6
 
+
+def col(red, green, blue):
+    """Convert the given colours [0, 255] to HTML hex colours."""
+    return "#%02x%02x%02x" % (red, green, blue)
+
+
 def rotate(arc, rotation):
     """Helper for rotation normalisation."""
     return (arc + rotation) % 360
@@ -259,15 +265,40 @@ def __init__(self, mesh, wall_neighbors=None, **kwargs):
 
 
     def draw(self, canvas, game_state=None):
-        scale = (self.mesh.half_scale_x + self.mesh.half_scale_y) * 0.6
+        scale = (self.mesh.half_scale_x + self.mesh.half_scale_y) * 0.5
+        if game_state:
+            wall_col = col(48, 26, 22)
+
+            import random
+            r = random.randint(0, 15)
+            g = random.randint(0, 15)
+            b = random.randint(0, 15)
+            wall_col = col(r*16, g*16, b*16)
+
+            def rb_col(idx, width, phase=0):
+                import math
+                freq = math.pi * 2 / width
+                r = math.sin(freq * idx + 2 + phase) * 127 + 128
+                g = math.sin(freq * idx + 0 + phase) * 127 + 128
+                b = math.sin(freq * idx + 4 + phase) * 127 + 128
+                return (int(r), int(g), int(b))
+
+            x, y = self.position
+            if x == 0 or y == 0:
+                wall_col = col(*rb_col(x + y, 16, game_state))
+            elif x == self.mesh.mesh_width - 1 or y == self.mesh.mesh_height - 1:
+                wall_col = col(*rb_col(- x - y, 16, game_state))
+        else:
+            wall_col = col(48, 26, 22)
+
         if not ((0, 1) in self.wall_neighbors or
                 (1, 0) in self.wall_neighbors or
                 (0, -1) in self.wall_neighbors or
                 (-1, 0) in self.wall_neighbors):
             # if there is no direct neighbour, we can’t connect.
             # draw only a small dot.
             # TODO add diagonal lines
-            canvas.create_line(self.screen((-0.3, 0)), self.screen((+0.3, 0)), fill=BROWN,
+            canvas.create_line(self.screen((-0.3, 0)), self.screen((+0.3, 0)), fill=wall_col,
                                width=scale, tags=(self.tag, "wall"), capstyle="round")
         else:
             neighbours = [(-1, -1), (0, -1), (1, -1), (1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0)]
@@ -283,7 +314,7 @@ def draw(self, canvas, game_state=None):
                             neighbours[(index - 1) % len(neighbours)] in self.wall_neighbors):
                             pass
                         else:
-                            canvas.create_line(self.screen((0, 0)), self.screen((2*dx, 2*dy)), fill=BROWN,
+                            canvas.create_line(self.screen((0, 0)), self.screen((2*dx, 2*dy)), fill=wall_col,
                                                width=scale, tags=(self.tag, "wall"), capstyle="round")
 
             # if we are drawing a closed square, fill in the internal part

pelita/ui/tk_viewer.py

@@ -95,6 +95,11 @@ def __init__(self, address, controller_address=None, standalone_mode=False,
 
         self._delay = 2
 
+        if os.getenv("PELITA_DOUBLE_RAINBOW", None):
+            self.rainbow = True
+        else:
+            self.rainbow = False
+
     def run(self):
         try:
             self.root = tkinter.Tk()
@@ -122,7 +127,8 @@ def run(self):
                                  delay=self.delay,
                                  stop_after=self.stop_after,
                                  stop_after_kill=self.stop_after_kill,
-                                 fullscreen=self.fullscreen)
+                                 fullscreen=self.fullscreen,
+                                 rainbow=self.rainbow)
         # schedule next read
         self.root.after_idle(self.read_queue)
         try: