Merge branch '53-mark-counter-to-interact-with' into 'main'

Resolve "Mark counter to interact with"

Closes #53

See merge request scs/cocosy/overcooked-simulator!21

overcooked_simulator/game_content/player_config.yaml

 radius: 0.4
 move_dist: 5
-interaction_range: 1.5
\ No newline at end of file
+interaction_range: 1.6
\ No newline at end of file

overcooked_simulator/overcooked_environment.py

@@ -225,6 +225,7 @@ class Environment:
         counter_distances = distance_matrix(
             [point], [counter.pos for counter in self.counters]
         )[0]
+
         closest_counter_idx = np.argmin(counter_distances)
         return self.counters[closest_counter_idx]
 
@@ -239,12 +240,7 @@ class Environment:
         Returns:
 
         """
-        facing_point = player.pos + (
-            player.facing_direction
-            * player.interaction_range
-            * self.counter_side_length
-        )
-        facing_counter = self.get_closest_counter(facing_point)
+        facing_counter = self.get_closest_counter(player.facing_point)
         return facing_counter
 
     def perform_movement(self, player: Player, move_vector: np.array):
@@ -301,6 +297,12 @@ class Environment:
                 if self.detect_collision(player):
                     player.move_abs(old_pos)
 
+        if self.counters:
+            closest_counter = self.get_facing_counter(player)
+            player.current_nearest_counter = (
+                closest_counter if player.can_reach(closest_counter) else None
+            )
+
     def detect_collision(self, player: Player):
         """Detect collisions between the player and other players or counters.
 
@@ -408,6 +410,7 @@ class Environment:
                 del self.free_positions[free_idx]
             else:
                 log.debug("No free positions left in kitchens")
+            player.update_facing_point()
 
     def detect_collision_world_bounds(self, player: Player):
         """Checks for detections of the player and the world bounds.

overcooked_simulator/player.py

@@ -50,6 +50,9 @@ class Player:
             Counter
         ] = None  # needed to stop progress when moved away
 
+        self.current_nearest_counter: Optional[Counter] = None
+        self.facing_point: npt.NDArray[float] = np.zeros(2, float)
+
     def move(self, movement: npt.NDArray[float]):
         """Moves the player position by the given movement vector.
         A unit direction vector multiplied by move_dist is added to the player position.
@@ -79,6 +82,12 @@ class Player:
         """
         if np.linalg.norm(direction) != 0:
             self.facing_direction = direction / np.linalg.norm(direction)
+        self.update_facing_point()
+
+    def update_facing_point(self):
+        self.facing_point = self.pos + (
+            self.facing_direction * self.radius * self.grid_size * 0.5
+        )
 
     def can_reach(self, counter: Counter):
         """Checks whether the player can reach the counter in question. Simple check if the distance is not larger
@@ -90,7 +99,7 @@ class Player:
         Returns: True if the counter is in range of the player, False if not.
 
         """
-        return np.linalg.norm(counter.pos - self.pos) <= (
+        return np.linalg.norm(counter.pos - self.facing_point) <= (
             self.interaction_range * self.grid_size
         )
 

overcooked_simulator/pygame_gui/pygame_gui.py

@@ -11,6 +11,7 @@ import yaml
 from scipy.spatial import KDTree
 
 from overcooked_simulator import ROOT_DIR
+from overcooked_simulator.counters import Counter
 from overcooked_simulator.game_items import (
     ProgressibleItem,
     Item,
@@ -25,6 +26,7 @@ from overcooked_simulator.simulation_runner import Simulator
 
 USE_PLAYER_COOK_SPRITES = True
 SHOW_INTERACTION_RANGE = False
+SHOW_COUNTER_CENTERS = False
 
 
 def create_polygon(n, length):
@@ -257,13 +259,32 @@ class PyGameGUI:
 
             if SHOW_INTERACTION_RANGE:
                 pygame.draw.circle(
-                    self.screen, BLUE, player.pos, player.interaction_range, width=1
+                    self.screen,
+                    BLUE,
+                    player.facing_point,
+                    player.interaction_range * self.counter_size,
+                    width=1,
                 )
+                pygame.draw.circle(self.screen, colors["red1"], player.facing_point, 4)
 
             if player.holding is not None:
                 holding_item_pos = player.pos + (20 * player.facing_direction)
                 self.draw_item(holding_item_pos, player.holding)
 
+            if player.current_nearest_counter:
+                counter: Counter = player.current_nearest_counter
+                pygame.draw.rect(
+                    self.screen,
+                    colors[self.player_colors[p_idx]],
+                    rect=pygame.Rect(
+                        counter.pos[0] - (self.counter_size // 2),
+                        counter.pos[1] - (self.counter_size // 2),
+                        self.counter_size,
+                        self.counter_size,
+                    ),
+                    width=2,
+                )
+
     def draw_thing(
         self, pos: npt.NDArray[float], parts: list[dict[str]], scale: float = 1.0
     ):
@@ -394,6 +415,8 @@ class PyGameGUI:
         """
         for counter in state["counters"]:
             self.draw_counter(counter)
+            if SHOW_COUNTER_CENTERS:
+                pygame.draw.circle(self.screen, colors["green1"], counter.pos, 3)
 
     def draw(self, state):
         """Main visualization function.