Merge remote-tracking branch 'origin/34-can-put-tomatos-on-returned-plate'...

Merge remote-tracking branch 'origin/34-can-put-tomatos-on-returned-plate' into 34-can-put-tomatos-on-returned-plate

# Conflicts:
#	overcooked_simulator/pygame_gui/pygame_gui.py

overcooked_simulator/counters.py

 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 if TYPE_CHECKING:
     from overcooked_simulator.overcooked_environment import GameScore
-from typing import Optional
 
 import numpy as np
+import numpy.typing as npt
 
 from overcooked_simulator.game_items import (
     CuttableItem,
@@ -20,8 +20,8 @@ from overcooked_simulator.game_items import (
 class Counter:
     """Simple class for a counter at a specified position (center of counter). Can hold things on top."""
 
-    def __init__(self, pos: np.ndarray):
-        self.pos: np.ndarray = pos
+    def __init__(self, pos: npt.NDArray[float]):
+        self.pos: npt.NDArray[float] = pos
         self.occupied_by: Optional[HoldableItem] = None
 
     def pick_up(self):
@@ -35,7 +35,7 @@ class Counter:
         self.occupied_by = None
         return give_player
 
-    def can_drop_off(self, item: HoldableItem):
+    def can_drop_off(self, item: HoldableItem) -> bool:
         """Checks whether an item by the player can be dropped of. More relevant for example with
         ingredient dispensers, which should always be occupied and cannot take an item.
 
@@ -47,19 +47,20 @@ class Counter:
         """
         return self.occupied_by is None or self.occupied_by.can_combine(item)
 
-    def drop_off(self, item: HoldableItem):
+    def drop_off(self, item: HoldableItem) -> HoldableItem | None:
         """Takes the thing dropped of by the player.
 
         Args:
             item: The item to be placed on the counter.
 
-        Returns: TODO Return information, wether the score is affected (Serving Window?)
+        Returns: TODO Return information, whether the score is affected (Serving Window?)
 
         """
         if self.occupied_by is None:
             self.occupied_by = item
         elif self.occupied_by.can_combine(item):
             self.occupied_by.combine(item)
+        return None
 
     def interact_start(self):
         """Starts an interaction by the player. Nothing happens for the standard counter."""
@@ -105,19 +106,21 @@ class CuttingBoard(Counter):
 
 
 class ServingWindow(Counter):
-    def __init__(self, pos, gamescore: GameScore):
-        self.game_score = gamescore
+    def __init__(self, pos, game_score: GameScore):
+        self.game_score = game_score
         super().__init__(pos)
 
-    def drop_off(self, item):
+    def drop_off(self, item) -> HoldableItem | None:
         reward = 5
+        # TODO define rewards
         self.game_score.increment_score(reward)
+        return None
 
     def can_score(self, item):
         if isinstance(item, Plate) and isinstance(item.holds, ProgressibleItem):
             return item.holds.finished
 
-    def can_drop_off(self, item: HoldableItem):
+    def can_drop_off(self, item: HoldableItem) -> bool:
         return self.can_score(item)
 
     def pick_up(self):
@@ -130,7 +133,7 @@ class ServingWindow(Counter):
 class PlateReturn(Counter):
     def __init__(self, pos):
         super().__init__(pos)
-        self.occupied_by = Plate()
+        self.occupied_by = [Plate()]
 
     def pick_up(self):
         """Gets called upon a player performing the pickup action. Gives back a plate (possibly with ingredient.
@@ -138,20 +141,28 @@ class PlateReturn(Counter):
         Returns: A plate possibly with an ingredient on it.
 
         """
-        give_player = self.occupied_by
-        self.occupied_by = Plate()
+        give_player = self.occupied_by.pop()
+        if not self.occupied_by:
+            self.occupied_by.append(Plate())
         return give_player
 
-    def drop_off(self, item: HoldableItem):
+    def drop_off(self, item: HoldableItem) -> HoldableItem | None:
         """Takes the ingredient dropped of by the player.
 
         Args:
             item: The ingredient to be placed on the counter.
         """
-        if item is Plate() and self.occupied_by is Plate():
-            self.occupied_by = None
-
-    def can_drop_off(self, item: HoldableItem):
+        if isinstance(item, Plate):
+            if self.occupied_by[-1].holds:
+                return item
+            self.occupied_by.append(item)
+            return None
+        if self.occupied_by[-1].can_combine(item):
+            self.occupied_by[-1].combine(item)
+            return None
+        return item
+
+    def can_drop_off(self, item: HoldableItem) -> bool:
         """Checks whether an ingredient by the player can be dropped of.
 
         Args:
@@ -162,8 +173,8 @@ class PlateReturn(Counter):
         """
         # possibility to drop off empty plate on empty plate return
         return (
-                isinstance(self.occupied_by, Plate) and isinstance(item, Plate)
-        ) or self.occupied_by.can_combine(item)
+            isinstance(self.occupied_by[-1], Plate) and isinstance(item, Plate)
+        ) or self.occupied_by[-1].can_combine(item)
 
     def __repr__(self):
         return "PlateReturn"
@@ -176,10 +187,10 @@ class TomatoDispenser(Counter):
     def pick_up(self):
         return Tomato()
 
-    def drop_off(self, item: HoldableItem):
-        return 0
+    def drop_off(self, item: HoldableItem) -> HoldableItem | None:
+        return None
 
-    def can_drop_off(self, item: HoldableItem):
+    def can_drop_off(self, item: HoldableItem) -> bool:
         return False
 
     def __repr__(self):
@@ -190,12 +201,13 @@ class Trash(Counter):
     def pick_up(self):
         pass
 
-    def drop_off(self, item: HoldableItem):
+    def drop_off(self, item: HoldableItem) -> HoldableItem | None:
         if isinstance(item, Plate):
             item.holds = None
-        return -1
+            return item
+        return None
 
-    def can_drop_off(self, item: HoldableItem):
+    def can_drop_off(self, item: HoldableItem) -> bool:
         return True
 
     def __repr__(self):

overcooked_simulator/game_items.py

 class HoldableItem:
     """Base class for game items which can be held by a player."""
 
-    pass
-
     def can_combine(self, other):
         return False
 
@@ -11,9 +9,9 @@ class HoldableItem:
 
 
 class Plate(HoldableItem):
-    def __init__(self):
+    def __init__(self, holds: HoldableItem = None):
         self.clean = True
-        self.holds = None
+        self.holds = holds
 
         super().__init__()
 

overcooked_simulator/main.py

@@ -5,7 +5,6 @@ import numpy as np
 import pygame
 
 from overcooked_simulator import ROOT_DIR
-from overcooked_simulator.game_items import Tomato, Plate
 from overcooked_simulator.player import Player
 from overcooked_simulator.pygame_gui.pygame_gui import PyGameGUI
 from overcooked_simulator.simulation_runner import Simulator
@@ -15,8 +14,8 @@ def main():
     simulator = Simulator(Path(ROOT_DIR, "layouts", "basic.layout"), 600)
     player_one_name = "p1"
     player_two_name = "p2"
-    simulator.register_player(Player(player_one_name, np.array([200, 200])))
-    simulator.register_player(Player(player_two_name, np.array([100, 200])))
+    simulator.register_player(Player(player_one_name, np.array([200.0, 200.0])))
+    simulator.register_player(Player(player_two_name, np.array([100.0, 200.0])))
 
     # TODO maybe read the player names and keyboard keys from config file?
     keys1 = [

overcooked_simulator/overcooked_environment.py

@@ -6,6 +6,8 @@ if TYPE_CHECKING:
     from overcooked_simulator.player import Player
 from pathlib import Path
 import numpy as np
+import numpy.typing as npt
+
 from scipy.spatial import distance_matrix
 from overcooked_simulator.counters import (
     Counter,
@@ -55,7 +57,7 @@ class Environment:
 
     def __init__(self, layout_path):
         self.players: dict[str, Player] = {}
-        self.counter_side_length: float = 40
+        self.counter_side_length: int = 40
         self.layout_path: Path = layout_path
 
         self.game_score = GameScore()
@@ -132,7 +134,7 @@ class Environment:
                     elif action.action == "keyup":
                         player.perform_interact_hold_stop(counter)
 
-    def get_closest_counter(self, point: np.ndarray):
+    def get_closest_counter(self, point: npt.NDArray):
         """Determines the closest counter for a given 2d-coordinate point in the env.
 
         Args:
@@ -161,7 +163,7 @@ class Environment:
         facing_counter = self.get_closest_counter(facing_point)
         return facing_counter
 
-    def perform_movement(self, player: Player, move_vector: np.array):
+    def perform_movement(self, player: Player, move_vector: npt.NDArray[int]):
         """Moves a player in the direction specified in the action.action. If the player collides with a
         counter or other player through this movement, then they are not moved.
         (The extended code with the two ifs is for sliding movement at the counters, which feels a bit smoother.
@@ -170,6 +172,8 @@ class Environment:
 
         The movement action is a unit 2d vector.
 
+        Detects collisions with other players and pushes them out of the way.
+
         Args:
             player: The player to move.
             move_vector: The movement vector which is a unit-2d-vector of the movement direction
@@ -179,6 +183,18 @@ class Environment:
         step = move_vector * player.move_dist
         player.move(step)
         if self.detect_collision(player):
+            collided_players = self.get_collided_players(player)
+            for collided_player in collided_players:
+                pushing_vector = collided_player.pos - player.pos
+                if np.linalg.norm(pushing_vector) != 0:
+                    pushing_vector = pushing_vector / np.linalg.norm(pushing_vector)
+
+                old_pos_other = collided_player.pos.copy()
+                collided_player.move(pushing_vector * (collided_player.move_dist / 2))
+                if self.detect_collision_counters(
+                        collided_player
+                ) or self.detect_collision_world_bounds(player):
+                    collided_player.move_abs(old_pos_other)
             player.move_abs(old_pos)
 
             old_pos = player.pos.copy()
@@ -210,11 +226,29 @@ class Environment:
         Returns: True if the player is intersecting with any object in the environment.
         """
         return (
-                self.detect_player_collision(player)
+                len(self.get_collided_players(player)) != 0
                 or self.detect_collision_counters(player)
                 or self.detect_collision_world_bounds(player)
         )
 
+    def get_collided_players(self, player: Player) -> list[Player]:
+        """Detects collisions between the queried player and other players. Returns the list of the collided players.
+        A player is modelled as a circle. Collision is detected if the distance between the players is smaller
+        than the sum of the radius's.
+
+        Args:
+            player: The player to check collisions with other players for.
+
+        Returns: The list of other players the player collides with.
+
+        """
+        other_players = filter(lambda p: p.name != player.name, self.players.values())
+
+        def collide(p):
+            return np.linalg.norm(player.pos - p.pos) <= (player.radius + p.radius)
+
+        return list(filter(collide, other_players))
+
     def detect_player_collision(self, player: Player):
         """Detects collisions between the queried player and other players.
         A player is modelled as a circle. Collision is detected if the distance between the players is smaller

overcooked_simulator/player.py

 from typing import Optional
 
 import numpy as np
+import numpy.typing as npt
 
-from overcooked_simulator.counters import Counter, Trash
-from overcooked_simulator.game_items import HoldableItem, Plate
+from overcooked_simulator.counters import Counter
+from overcooked_simulator.game_items import HoldableItem
 
 
 class Player:
@@ -13,17 +14,17 @@ class Player:
 
     """
 
-    def __init__(self, name: str, pos: np.ndarray):
+    def __init__(self, name: str, pos: npt.NDArray[float]):
         self.name: str = name
-        self.pos: np.ndarray = np.array(pos, dtype=float)
+        self.pos: npt.NDArray[float] = np.array(pos, dtype=float)
         self.holding: Optional[HoldableItem] = None
 
         self.radius: int = 18
         self.move_dist: int = 5
         self.interaction_range: int = 60
-        self.facing_direction: np.ndarray = np.array([0, 1])
+        self.facing_direction: npt.NDArray[float] = np.array([0, 1])
 
-    def move(self, movement: np.ndarray):
+    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.
 
@@ -34,7 +35,7 @@ class Player:
         if np.linalg.norm(movement) != 0:
             self.turn(movement)
 
-    def move_abs(self, new_pos: np.ndarray):
+    def move_abs(self, new_pos: npt.NDArray[float]):
         """Overwrites the player location by the new_pos 2d-vector. Absolute movement.
         Mostly needed for resetting the player after a collision.
 
@@ -43,7 +44,7 @@ class Player:
         """
         self.pos = new_pos
 
-    def turn(self, direction: np.ndarray):
+    def turn(self, direction: npt.NDArray[float]):
         """Turns the player in the given direction. Overwrites the facing_direction by a given 2d-vector.
         facing_direction is normalized to length 1.
 
@@ -54,7 +55,7 @@ class Player:
             self.facing_direction = direction / np.linalg.norm(direction)
 
     def can_reach(self, counter: Counter):
-        """Checks wether the player can reach the counter in question. Simple check if the distance is not larger
+        """Checks whether the player can reach the counter in question. Simple check if the distance is not larger
         than the player interaction range.
 
         Args:
@@ -77,11 +78,7 @@ class Player:
             self.holding = counter.pick_up()
 
         elif counter.can_drop_off(self.holding):
-            if isinstance(counter, Trash) and isinstance(self.holding, Plate):
-                self.holding.holds = None
-            else:
-                counter.drop_off(self.holding)
-                self.holding = None
+            self.holding = counter.drop_off(self.holding)
 
         elif self.holding.can_combine(counter.occupied_by):
             returned_by_counter = counter.pick_up()

overcooked_simulator/pygame_gui/pygame_gui.py

@@ -12,7 +12,7 @@ from overcooked_simulator.counters import (
     PlateReturn,
     ServingWindow,
 )
-from overcooked_simulator.game_items import ProgressibleItem, Plate
+from overcooked_simulator.game_items import ProgressibleItem, Plate, HoldableItem
 from overcooked_simulator.game_items import Tomato
 from overcooked_simulator.overcooked_environment import Action
 from overcooked_simulator.simulation_runner import Simulator
@@ -20,7 +20,7 @@ from overcooked_simulator.simulation_runner import Simulator
 WHITE = (255, 255, 255)
 GREY = (190, 190, 190)
 BLACK = (0, 0, 0)
-COUNTERCOLOR = (240, 240, 240)
+COUNTER_COLOR = (240, 240, 240)
 LIGHTGREY = (220, 220, 220)
 GREEN = (0, 255, 0)
 RED = (255, 0, 0)
@@ -33,6 +33,7 @@ PLATE_RETURN_COLOR = (170, 170, 240)
 BOARD_COLOR = (239, 193, 151)
 
 
+<<<<<<< HEAD
 def angle_between_vectors_old(v1, v2):
     if np.linalg.norm(v1) != 0:
         v1 = v1 / np.linalg.norm(v1)
@@ -53,6 +54,9 @@ def angle_between_vectors(v1, v2):
 
 
 class PlayerKeyset:
+=======
+class PlayerKeySet:
+>>>>>>> origin/34-can-put-tomatos-on-returned-plate
     """Set of keyboard keys for controlling a player.
     First four keys are for movement. Order: Down, Up, Left, Right.
     5th key is for interacting with counters.
@@ -61,7 +65,7 @@ class PlayerKeyset:
     """
 
     def __init__(self, player_name: str, keys: list[pygame.key]):
-        """Creates a player keyset which contains information about which keyboard keys control the player.
+        """Creates a player key set which contains information about which keyboard keys control the player.
         Movement keys in the following order: Down, Up, Left, Right
 
         Args:
@@ -79,7 +83,7 @@ class PlayerKeyset:
 
 
 class PyGameGUI:
-    """Visualisation of the overcooked environmnent and reading keyboard inputs using pygame."""
+    """Visualisation of the overcooked environment and reading keyboard inputs using pygame."""
 
     def __init__(
             self,
@@ -87,6 +91,7 @@ class PyGameGUI:
             player_names: list[str],
             player_keys: list[pygame.key],
     ):
+        self.screen = None
         self.FPS = 60
         self.simulator = simulator
         self.counter_size = self.simulator.env.counter_side_length
@@ -99,10 +104,10 @@ class PyGameGUI:
         self.player_keys = player_keys
         assert len(self.player_names) == len(
             self.player_keys
-        ), "Number of players and keysets should match."
+        ), "Number of players and key sets should match."
 
-        self.player_keysets: list[PlayerKeyset] = [
-            PlayerKeyset(player_name, keys)
+        self.player_key_sets: list[PlayerKeySet] = [
+            PlayerKeySet(player_name, keys)
             for player_name, keys in zip(self.player_names, self.player_keys)
         ]
 
@@ -121,13 +126,13 @@ class PyGameGUI:
         an action is sent in this function.
         """
         keys = pygame.key.get_pressed()
-        for player_idx, keyset in enumerate(self.player_keysets):
-            relevant_keys = [keys[k] for k in keyset.player_keys]
+        for player_idx, key_set in enumerate(self.player_key_sets):
+            relevant_keys = [keys[k] for k in key_set.player_keys]
             if any(relevant_keys[:-2]):
                 move_vec = np.zeros(2)
                 for idx, pressed in enumerate(relevant_keys[:-2]):
                     if pressed:
-                        move_vec += keyset.move_vectors[idx]
+                        move_vec += key_set.move_vectors[idx]
                 if np.linalg.norm(move_vec) != 0:
                     move_vec = move_vec / np.linalg.norm(move_vec)
 
@@ -142,17 +147,17 @@ class PyGameGUI:
         Args:
             event: Pygame event for extracting the key action.
         """
-        for keyset in self.player_keysets:
-            if event.key == keyset.pickup_key and event.type == pygame.KEYDOWN:
-                action = Action(keyset.name, "pickup", "pickup")
+        for key_set in self.player_key_sets:
+            if event.key == key_set.pickup_key and event.type == pygame.KEYDOWN:
+                action = Action(key_set.name, "pickup", "pickup")
                 self.send_action(action)
 
-            if event.key == keyset.interact_key:
+            if event.key == key_set.interact_key:
                 if event.type == pygame.KEYDOWN:
-                    action = Action(keyset.name, "interact", "keydown")
+                    action = Action(key_set.name, "interact", "keydown")
                     self.send_action(action)
                 elif event.type == pygame.KEYUP:
-                    action = Action(keyset.name, "interact", "keyup")
+                    action = Action(key_set.name, "interact", "keyup")
                     self.send_action(action)
 
     def draw_background(self):
@@ -164,7 +169,7 @@ class PyGameGUI:
                 pygame.draw.rect(self.screen, BACKGROUND_LINES_COLOR, rect, 1)
 
     def draw_players(self, state):
-        """Visualizes the players as circles with a triangle for the facing diretion.
+        """Visualizes the players as circles with a triangle for the facing direction.
         If the player holds something in their hands, it is displayed
 
         Args:
@@ -212,7 +217,7 @@ class PyGameGUI:
                 holding_item_pos = player.pos + (20 * player.facing_direction)
                 self.draw_item(holding_item_pos, player.holding)
 
-    def draw_item(self, pos, item):
+    def draw_item(self, pos, item: HoldableItem):
         """Visualisation of an item at the specified position. On a counter or in the hands of the player."""
         if isinstance(item, Tomato):
             if item.finished:
@@ -229,7 +234,7 @@ class PyGameGUI:
 
         if isinstance(item, Plate):
             image = pygame.image.load(
-                "overcooked_simulator/pygame_gui/images/plate.png"
+                self.images_path / "plate.png"
             ).convert_alpha()  # or .convert_alpha()
             rect = image.get_rect()
             rect.center = pos
@@ -266,7 +271,7 @@ class PyGameGUI:
             self.counter_size,
             self.counter_size,
         )
-        pygame.draw.rect(self.screen, COUNTERCOLOR, counter_rect_outline)
+        pygame.draw.rect(self.screen, COUNTER_COLOR, counter_rect_outline)
 
         if isinstance(counter, CuttingBoard):
             board_size = 30
@@ -320,7 +325,13 @@ class PyGameGUI:
             pygame.draw.rect(self.screen, YELLOW, board_rect)
 
         if counter.occupied_by is not None:
-            self.draw_item(counter.pos, counter.occupied_by)
+            if isinstance(counter.occupied_by, list):
+                for i, o in enumerate(counter.occupied_by):
+                    self.draw_item(
+                        np.abs([counter.pos[0], counter.pos[1] - (i * 3)]), o
+                    )
+            else:
+                self.draw_item(counter.pos, counter.occupied_by)
 
     def draw_counters(self, state):
         """Visualizes the counters in the environment.
@@ -346,7 +357,7 @@ class PyGameGUI:
         pygame.display.flip()
 
     def start_pygame(self):
-        """Starts pygame and the gui loop. Each frame the gamestate is visualized and keyboard inputs are read."""
+        """Starts pygame and the gui loop. Each frame the game state is visualized and keyboard inputs are read."""
         pygame.init()
         pygame.font.init()
 

overcooked_simulator/simulation_runner.py

@@ -6,23 +6,24 @@ from overcooked_simulator.player import Player
 
 
 class Simulator(Thread):
-    """Simulator main class which runs manages the environment and player inputs and gamestate outputs.
+    """Simulator main class which runs manages the environment and player inputs and game state outputs.
 
     Main Simulator class which runs the game environment. Players can be registered in the game.
     The simulator is run as its own thread.
 
     Typical usage example:
-
-      sim = Simulator()
-      sim.register_player(Player("p1", [x,y]))
-      sim.start()
+    ```python
+    sim = Simulator()
+    sim.register_player(Player("p1", [x,y]))
+    sim.start()
+    ```
     """
 
     def __init__(self, env_layout_path, frequency: int):
         self.finished: bool = False
 
         self.step_frequency: int = frequency
-        self.prefered_sleeptime_ns: float = 1e9 / self.step_frequency
+        self.preferred_sleep_time_ns: float = 1e9 / self.step_frequency
         self.env: Environment = Environment(env_layout_path)
 
         super().__init__()
@@ -40,19 +41,19 @@ class Simulator(Thread):
         self.env.perform_action(action)
 
     def get_state(self):
-        """Get the current gamestate as python objects.
+        """Get the current game state as python objects.
 
         Returns:
-            The current state of the game. Currently as dict with lists of environment objects.
+            The current state of the game. Currently, as dict with lists of environment objects.
         """
 
         return self.env.get_state()
 
     def get_state_json(self):
-        """Get the current gamestate in json-like dict.
+        """Get the current game state in json-like dict.
 
         Returns:
-            The gamestate encoded in a json style nested dict.
+            The gamest ate encoded in a json style nested dict.
         """
 
         return self.env.get_state_json()
@@ -86,7 +87,7 @@ class Simulator(Thread):
             self.step()
             step_duration = time.time_ns() - step_start
 
-            time_to_sleep_ns = self.prefered_sleeptime_ns - (
+            time_to_sleep_ns = self.preferred_sleep_time_ns - (
                 step_duration + overslept_in_ns
             )
 

tests/test_start.py

@@ -36,7 +36,7 @@ def test_player_registration():
     assert len(sim.env.players) == 2, "Wrong number of players"
 
     p3 = Player("player2", np.array([100, 100]))
-    sim.register_player(p2)  # same player name
+    sim.register_player(p3)  # same player name
     assert len(sim.env.players) == 2, "Wrong number of players"
 
     sim.start()