Adds support for multi-sprite Goals and BeeBots

- all Components now take a list of sprites/images rather than a single
  sprite/image.
  sprites in future scenarios.
- this is backwards compatiable with all 1.X scenarios
- update test cases to use lists for Component sprites
- Add complete method to Goal that completes goal
  - so that it can handle the sprite change
  - rework has_been_met to is_complete, as complete() is
    a better method name than met() for this method.
  - update test cases due to Goal changes and update comments

Author: alien-gamma

src/BeeBot.py

@@ -24,7 +24,7 @@ class BeeBot(Component):
     def __init__(self, scenario):
         """Create a BeeBot."""
         # Read the sprite and assume it is the "NORTH" sprite.
-        self.original_sprite = scenario.get_beebot_sprite()
+        self.original_sprite_list = scenario.get_beebot_sprite()
 
         # The amount the BeeBot moves.
         self.step = scenario.get_board_step()
@@ -33,15 +33,12 @@ def __init__(self, scenario):
         self.start_logical_position = Point(
             scenario.get_beebot_start_position())
 
-        # Call the superclass constructor
-        super().__init__(self.original_sprite,
+        # Call the superclass constructor.
+        # Use copy() here to copy the objects not just the reference.
+        super().__init__(self.original_sprite_list.copy(),
                          self.start_logical_position.copy(),
                          self.step)
 
-        # Read the sprite and assume it is the "NORTH" sprite.
-        self.original_sprite = scenario.get_beebot_sprite()
-        self.sprite = self.original_sprite
-
         # Which way is the BeeBot facing.
         self.start_heading = scenario.get_beebot_heading()
         self.heading = self.start_heading
@@ -63,6 +60,24 @@ def __init__(self, scenario):
 
         self.running = False
 
+    def increment_sprite(self):
+        """
+        Increment the sprite to display for this BeeBot.
+
+        Also ensures the visual Heading of the sprite is consistent before and
+        after this method is called.
+        """
+        super().increment_sprite()
+        # The new sprite will be facing Heading.NORTH regardless of
+        # self.heading, so fix that.
+        if self.heading == Heading.EAST:
+            self.sprite = self.rotate(self.sprite, 270)
+        elif self.heading == Heading.WEST:
+            self.sprite = self.rotate(self.sprite, 90)
+        elif self.heading == Heading.SOUTH:
+            self.sprite = self.rotate(self.sprite, 180)
+
+
     def move(self, event):
         """Move the BeeBot."""
         if event.type == CustomEvent.MOVE_BEEBOT_UP:
@@ -208,7 +223,8 @@ def reset_position(self):
         self.screen_location = self.start_logical_position.scale(self.step)
 
         # Reset BeeBot sprite
-        self.sprite = self.original_sprite
+        self._sprite_list = self.original_sprite_list.copy()
+        self._sprite_list_index = 0
 
         # From the original sprite, rotate to the start_heading
         if self.start_heading == Heading.EAST:

src/Component.py

@@ -12,12 +12,15 @@ class Component(pygame.sprite.Sprite):
     """This class defines an individual Component."""
 
     def __init__(self,
-                 sprite,  # The image to display (can be None)
+                 sprite_list,  # The list of sprites to display.
                  start_logical_position,  # The starting point of the Component
                  step):  # The 'size' of the Component
         """Create a Component."""
-        # The sprite to display on screen for this Component
-        self.sprite = sprite
+        # The sprite(s) to display on screen for this Component.
+        self._sprite_list = sprite_list
+
+        # Which sprite in self._sprite_list to display.
+        self._sprite_list_index = 0
 
         # The position of the Component in terms of squares on the screen
         self.logical_position = start_logical_position.copy()
@@ -28,12 +31,42 @@ def __init__(self,
         # calling superclass constructor
         pygame.sprite.Sprite.__init__(self)
 
+    @property
+    def sprite(self):
+        """A "public" getter for the current sprite."""
+        return self._sprite_list[self._sprite_list_index]
+
+    @sprite.setter
+    def sprite(self, new_sprite):
+        """
+        A "public" getter for the current sprite.
+
+        This method is needed for Components that rotate, like the BeeBot.
+        """
+        self._sprite_list[self._sprite_list_index] = new_sprite
+
+    @property
+    def sprite_list(self):
+        """A "public" getter for self._sprite_list."""
+        return self._sprite_list
+
+    @property
+    def sprite_list_index(self):
+        """A "public" getter for self._sprite_list_index."""
+        return self._sprite_list_index
+
+    def increment_sprite(self):
+        """Increment the sprite to display for this Component."""
+        if self._sprite_list_index < len(self._sprite_list) - 1:
+            self._sprite_list_index = self._sprite_list_index + 1
+
     def display(self, screen):
         """Draw the Component object on screen, if it has a sprite."""
         if self.sprite is not None:
             screen.blit(self.sprite, self.screen_location)
 
     def is_equal_to(self, other_component):
         """Compare this Component for equality with other_component."""
-        return (self.sprite == other_component.sprite and
+        return (self.sprite_list == other_component.sprite_list and
+                self.sprite_list_index == other_component.sprite_list_index and
                 self.screen_location.is_equal_to(other_component.screen_location))

src/GameWindow.py

@@ -599,13 +599,17 @@ def check_for_goal_collisions(self):
         if self.board.goal_group.is_ordered:
             goal = self.board.goal_group.get_current_goal()
             if self.robot.logical_position.is_equal_to(goal.logical_position):
-                goal.has_been_met = True
+                goal.complete()
+                if goal.should_increment_beebot_sprite:
+                    self.robot.increment_sprite()
                 self.board.goal_group.increment_pointer()
 
         else:
             for goal in self.board.goal_group.components:
                 if self.robot.logical_position.is_equal_to(goal.logical_position):
-                    goal.has_been_met = True
+                    goal.complete()
+                    if goal.should_increment_beebot_sprite:
+                        self.robot.increment_sprite()
 
         if self.board.goal_group.have_all_goals_been_met():
             # clear any remaining events
@@ -730,7 +734,7 @@ def handle_button_press(self, button):
             self.store_movement('Backward')
 
         if button.text == 'Reset':
-            # Reset the BeeBots position and the met status of the goals
+            # Reset the BeeBots position and the completed status of the Goals.
             self.robot.reset_position()
             self.board.goal_group.reset_all_goals()
 
@@ -760,7 +764,7 @@ def handle_key_press(self, event):
         if event.key == pygame.K_RIGHT:
             self.store_movement('Right')
         # if the event is the space bar,
-        # reset the BeeBot's position and clears any met goals.
+        # reset the BeeBot's position and clears any completed Goals.
         # it doesn't clear the memory!
         if event.key == pygame.K_SPACE:
             self.robot.reset_position()

src/Goal.py

@@ -6,20 +6,40 @@ class Goal(Component):
     """This class defines an individual Goal."""
 
     def __init__(self,
-                 sprite,  # The image to display (can be None)
+                 sprite_list,  # The list of sprites to display.
                  start_logical_position,  # The positon of the Goal
-                 step):  # Should be the same as the BeeBot step
+                 step,  # Should be the same as the BeeBot step
+                 should_increment_beebot_sprite=False):
         """Create a Goal."""
         # Call superclass constructor
-        super().__init__(sprite, start_logical_position, step)
+        super().__init__(sprite_list, start_logical_position, step)
 
-        # True if Goal has been met
-        self.has_been_met = False
+        # True if Goal is currently completed.
+        self._is_complete = False
+        # A marker to indicate that the BeeBot sprite should be incremented
+        # after the completion of this Goal.
+        self.should_increment_beebot_sprite = should_increment_beebot_sprite
+
+    @property
+    def is_complete(self):
+        """A "public" getter for the self._is_complete."""
+        return self._is_complete
+
+    def complete(self):
+        """Mark this Goal as complete and increment the sprite if possible."""
+        self._is_complete = True
+        if self._sprite_list_index < len(self._sprite_list) - 1:
+            self.increment_sprite()
+
+    def reset(self):
+        """Reset this Goal."""
+        self._is_complete = False
+        self._sprite_list_index = 0
 
     def is_equal_to(self, other_component):
         """Compare this Goal for equality with other_goal."""
         if not isinstance(other_component, Goal):
             # A Goal can obviously never be equal to a non Goal
             return False
-        return (self.has_been_met == other_component.has_been_met and
+        return (self.is_complete == other_component.is_complete and
                 super().is_equal_to(other_component))

src/GoalGroup.py

@@ -37,14 +37,14 @@ def increment_pointer(self):
     def have_all_goals_been_met(self):
         """True iff all the Goal objects in the GoalGroup have been met."""
         for goal in self.components:
-            if not goal.has_been_met:
+            if not goal.is_complete:
                 return False
         return True
 
     def reset_all_goals(self):
         """Set all Goals to not been met."""
         for goal in self.components:
-            goal.has_been_met = False
+            goal.reset()
         # if Goals are ordered, move ptr back to start of GoalGroup
         if self.is_ordered:
             self._goal_ptr = 0