Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • scs/cocosy/cooperative-cuisine
1 result
Show changes
Commits on Source (83)
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 1818 additions and 265 deletions
README.md
View file @ 7011f0e6
......@@ -10,7 +10,7 @@ The real-time overcooked simulation for a cognitive cooperative system.
You have two options to install the environment. Either clone it and install it locally or install it in your
site-packages.
You need a Python 3.10 or higher environment. Either conda or PyEnv.
You need a Python 3.10 or newer environment. Either conda or PyEnv.
### Local Editable Installation
......@@ -73,7 +73,8 @@ can be cooked/created.
### Layout Config
You can define the layout of the kitchen via a layout file. The position of counters are based on a grid system, even
when the players do not move grid steps but continuous steps. Each character defines a different type of counter.
when the players do not move grid steps but continuous steps. Each character defines a different type of counter. Which
character is mapped to which counter is defined in the Environment config.
### Environment Config
......
overcooked_simulator/__init__.py
View file @ 7011f0e6
......@@ -5,8 +5,8 @@ This is the documentation of the Overcooked Simulator.
# About the package
The package contains an environment for cooperation between players/agents. A PyGameGUI visualizes the game to
human or visual agents in 2D. A 3D web-enabled version (for example for online studies, currently under development)
can be found [here](https://gitlab.ub.uni-bielefeld.de/scs/cocosy/godot-overcooked-3d-visualization)
human or virtual agents in 2D. A 3D web-enabled version (for example for online studies, currently under development)
can be found [here](https://gitlab.ub.uni-bielefeld.de/scs/cocosy/godot-overcooked-3d-visualization).
# Background / Literature
The overcooked/cooking domain is a well established cooperation domain/task. There exists
......@@ -19,9 +19,23 @@ With this overcooked-simulator, we want to bring both worlds together: the reinf
environment with an appealing visualisation. Enable the potential of developing artificial agents that play with humans
like a "real" cooperative / human partner.
# Installation
You need a Python **3.10** or newer environment.
```bash
pip install overcooked-environment@git+https://gitlab.ub.uni-bielefeld.de/scs/cocosy/overcooked-simulator@main
```
Or clone it and install it as an editable library which allows you to use all the scripts directly.
```bash
git clone https://gitlab.ub.uni-bielefeld.de/scs/cocosy/overcooked-simulator.git
cd overcooked_simulator
pip install -e .
```
# Usage / Examples
Our overcooked simulator is designed for real time interaction but also with reinforcement learning in mind (gymnasium environment).
It focuses on configurability, extensibility and appealing visualization options.
Our overcooked simulator is designed for real time interaction but also for reinforcement
learning (gymnasium environment) with time independent step function calls. It focuses on configurability, extensibility and appealing visualization
options.
## Human Player
Run it via the command line (in your pyenv/conda environment):
......@@ -30,7 +44,7 @@ Run it via the command line (in your pyenv/conda environment):
overcooked-sim --url "localhost" --port 8000
```
_The arguments are the defaults. Therefore, they are optional._
*The arguments shown are the defaults.*
You can also start the **Game Server** and the **PyGame GUI** individually in different terminals.
......@@ -41,12 +55,261 @@ python3 overcooked_simulator/gui_2d_vis/overcooked_gui.py --url "localhost" --po
```
## Connect with agent and receive game state
...
Or you start a game server, create an environment and connect each player/agent via a websocket connection.
To start a game server see above. Your own manager needs to create an environment.
```python
import requests
from overcooked_simulator import ROOT_DIR
from overcooked_simulator.game_server import CreateEnvironmentConfig
from overcooked_simulator.server_results import CreateEnvResult
with open(ROOT_DIR / "game_content" / "item_info.yaml", "r") as file:
item_info = file.read()
with open(ROOT_DIR / "game_content" / "layouts" / "basic.layout", "r") as file:
layout = file.read()
with open(ROOT_DIR / "game_content" / "environment_config.yaml", "r") as file:
environment_config = file.read()
create_env = CreateEnvironmentConfig(
manager_id="SECRETKEY1",
number_players=2,
environment_settings={"all_player_can_pause_game": False},
item_info_config=item_info,
environment_config=environment_config,
layout_config=layout,
).model_dump(mode="json")
env_info = requests.post("http://localhost:8000/manage/create_env", json=create_env)
if env_info.status_code == 403:
raise ValueError(f"Forbidden Request: {env_info.json()['detail']}")
env_info: CreateEnvResult = env_info.json()
```
Connect each player via a websocket (threaded or async).
```python
import json
import dataclasses
from websockets import connect
from overcooked_simulator.overcooked_environment import Action, ActionType, InterActionData
from overcooked_simulator.utils import custom_asdict_factory
p1_websocket = connect("ws://localhost:8000/ws/player/" + env_info["player_info"]["0"]["client_id"])
# set player "0" as ready
p1_websocket.send(json.dumps({"type": "ready", "player_hash": env_info["player_info"]["0"]["player_hash"]}))
assert json.loads(websocket.recv())["status"] == 200, "not accepted player"
# get the state for player "0", call every frame/step
p1_websocket.send(json.dumps({"type": "get_state", "player_hash": env_info["player_info"]["0"]["player_hash"]}))
state = json.loads(websocket.recv())
# send an action for player "0"
# --- movement ---
action = Action(
player="0",
action_type=ActionType.MOVEMENT,
action_data=[0.0, 1.0], # direction (here straight up)
duration=0.5 # seconds
)
# --- pickup/drop off ---
action = Action(
player="0",
action_type=ActionType.PUT,
action_data="pickup",
)
# --- interact ---
action = Action(
player="0",
action_type=ActionType.INTERACT,
action_data=InterActionData.START # InterActionData.STOP when to stop the interaction
)
p1_websocket.send(json.dumps({
"type": "action",
"player_hash": env_info["player_info"]["0"]["player_hash"],
"action": dataclasses.asdict(
action, dict_factory=custom_asdict_factory
),
}))
websocket.recv()
```
Stop the environment if you want the game to end before the time is up.
```python
requests.post(
"http://localhost:8000/manage/stop_env",
json={
"manager_id": "SECRETKEY1",
"env_id": env_info["env_id"],
"reason": "closed environment",
},
)
```
## Direct integration into your code
You can use the `overcooked_simulator.overcooked_environment.Environment` class
and call the `step`, `get_json_state`, and `perform_action` methods directly.
```python
from datetime import timedelta
from overcooked_simulator import ROOT_DIR
from overcooked_simulator.overcooked_environment import Action, Environment
env = Environment(
env_config=ROOT_DIR / "game_content" / "environment_config.yaml",
layout_config=ROOT_DIR / "game_content" / "layouts" / "basic.layout",
item_info=ROOT_DIR / "game_content" / "item_info.yaml"
)
env.add_player("0")
env.add_player("1")
while True:
# adapt this to real time if needed with time.sleep etc.
env.step(timedelta(seconds=0.1))
player_0_state = json.loads(env.get_json_state("0"))
if player_0_state["ended"]:
break
action = ... # See above but use np.array instead of list for the movement direction vector
env.perform_action(action)
```
# JSON State
The JSON Schema for the state of the environment for a player can be generated by running the `state_representation.py`
```bash
python state_representation.py
```
Should look like
```
{'$defs': {'CookingEquipmentState': {'properties': {'content_list': {'items': {'$ref': '#/$defs/ItemState'}, 'title': 'Content List', 'type': 'array'}, 'content_ready': {'anyOf': [{'$ref': '#/$defs/ItemState'}, {'type': 'null'}]}}, 'required': ['content_list', 'content_ready'], 'title': 'CookingEquipmentState', 'type': 'object'}, 'CounterState': {'properties': {'id': {'title': 'Id', 'type': 'string'}, 'category': {'const': 'Counter', 'title': 'Category'}, 'type': {'title': 'Type', 'type': 'string'}, 'pos': {'items': {'type': 'number'}, 'title': 'Pos', 'type': 'array'}, 'occupied_by': {'anyOf': [{'items': {'anyOf': [{'$ref': '#/$defs/ItemState'}, {'$ref': '#/$defs/CookingEquipmentState'}]}, 'type': 'array'}, {'$ref': '#/$defs/ItemState'}, {'$ref': '#/$defs/CookingEquipmentState'}, {'type': 'null'}], 'title': 'Occupied By'}}, 'required': ['id', 'category', 'type', 'pos', 'occupied_by'], 'title': 'CounterState', 'type': 'object'}, 'ItemState': {'properties': {'id': {'title': 'Id', 'type': 'string'}, 'category': {'anyOf': [{'const': 'Item'}, {'const': 'ItemCookingEquipment'}], 'title': 'Category'}, 'type': {'title': 'Type', 'type': 'string'}, 'progress_percentage': {'anyOf': [{'type': 'number'}, {'type': 'integer'}], 'title': 'Progress Percentage'}}, 'required': ['id', 'category', 'type', 'progress_percentage'], 'title': 'ItemState', 'type': 'object'}, 'KitchenInfo': {'properties': {'width': {'title': 'Width', 'type': 'number'}, 'height': {'title': 'Height', 'type': 'number'}}, 'required': ['width', 'height'], 'title': 'KitchenInfo', 'type': 'object'}, 'OrderState': {'properties': {'id': {'title': 'Id', 'type': 'string'}, 'category': {'const': 'Order', 'title': 'Category'}, 'meal': {'title': 'Meal', 'type': 'string'}, 'start_time': {'format': 'date-time', 'title': 'Start Time', 'type': 'string'}, 'max_duration': {'title': 'Max Duration', 'type': 'number'}}, 'required': ['id', 'category', 'meal', 'start_time', 'max_duration'], 'title': 'OrderState', 'type': 'object'}, 'PlayerState': {'properties': {'id': {'title': 'Id', 'type': 'string'}, 'pos': {'items': {'type': 'number'}, 'title': 'Pos', 'type': 'array'}, 'facing_direction': {'items': {'type': 'number'}, 'title': 'Facing Direction', 'type': 'array'}, 'holding': {'anyOf': [{'$ref': '#/$defs/ItemState'}, {'$ref': '#/$defs/CookingEquipmentState'}, {'type': 'null'}], 'title': 'Holding'}, 'current_nearest_counter_pos': {'anyOf': [{'items': {'type': 'number'}, 'type': 'array'}, {'type': 'null'}], 'title': 'Current Nearest Counter Pos'}, 'current_nearest_counter_id': {'anyOf': [{'type': 'string'}, {'type': 'null'}], 'title': 'Current Nearest Counter Id'}}, 'required': ['id', 'pos', 'facing_direction', 'holding', 'current_nearest_counter_pos', 'current_nearest_counter_id'], 'title': 'PlayerState', 'type': 'object'}}, 'properties': {'players': {'items': {'$ref': '#/$defs/PlayerState'}, 'title': 'Players', 'type': 'array'}, 'counters': {'items': {'$ref': '#/$defs/CounterState'}, 'title': 'Counters', 'type': 'array'}, 'kitchen': {'$ref': '#/$defs/KitchenInfo'}, 'score': {'anyOf': [{'type': 'number'}, {'type': 'integer'}], 'title': 'Score'}, 'orders': {'items': {'$ref': '#/$defs/OrderState'}, 'title': 'Orders', 'type': 'array'}, 'ended': {'title': 'Ended', 'type': 'boolean'}, 'env_time': {'format': 'date-time', 'title': 'Env Time', 'type': 'string'}, 'remaining_time': {'title': 'Remaining Time', 'type': 'number'}}, 'required': ['players', 'counters', 'kitchen', 'score', 'orders', 'ended', 'env_time', 'remaining_time'], 'title': 'StateRepresentation', 'type': 'object'}
```
The BaseModel and TypedDicts can be found in `overcooked_simulator.state_representation`. The
`overcooked_simulator.state_representation.StateRepresentation` represents the json state that the `get_json_state`
returns.
## Generate images from JSON states
You might have stored some json states and now you want to visualize them via the
pygame-2d visualization. You can do that by running the `drawing.py` script and referencing a json file.
```bash
python3 overcooked_simulator/gui_2d_vis/drawing.py --state my_state.json
```
- You can specify a different visualization config with `-v` or `--visualization_config`.
- You can specify the name of the output file with `-o` or `--output_file`. The default is `screenshot.jpg`.
# Configuration
The environment configuration is currently done with 3 config files + GUI configuration.
## Item Config
The item config defines which ingredients, cooking equipment and meals can exist and how meals and processed ingredients
can be cooked/created.
For example
CuttingBoard:
type: Equipment
Stove:
type: Equipment
Pot:
type: Equipment
equipment: Stove
Tomato:
type: Ingredient
ChoppedTomato:
type: Ingredient
needs: [ Tomato ]
seconds: 4.0
equipment: CuttingBoard
TomatoSoup:
type: Meal
needs: [ ChoppedTomato, ChoppedTomato, ChoppedTomato ]
seconds: 6.0
equipment: Pot
## Layout Config
You can define the layout of the kitchen via a layout file. The position of counters are based on a grid system, even
when the players do not move grid steps but continuous steps. Each character defines a different type of counter. Which
character is mapped to which counter is defined in the Environment config.
For example
```
#QU#FO#TNLB#
#__________M
#__________K
W__________I
#__A_____A_D
C__________E
C__________G
#__________#
#P#S+#X##S+#
```
## Environment Config
The environment config defines how a level/environment is defined. Here, the available plates, meals, order and player
configuration is done.
For example
```yaml
plates:
clean_plates: 1
dirty_plates: 2
plate_delay: [ 5, 10 ]
# range of seconds until the dirty plate arrives.
game:
time_limit_seconds: 300
meals:
all: true
layout_chars:
_: Free
hash: Counter
A: Agent
P: PlateDispenser
C: CuttingBoard
X: Trashcan
W: ServingWindow
S: Sink
+: SinkAddon
U: Pot # with Stove
T: Tomato
orders:
...
player_config:
radius: 0.4
player_speed_units_per_seconds: 8
interaction_range: 1.6
```
## Direct integration into your code.
Initialize an environment....
## PyGame Visualization Config
**TODO** JSON State description.
Here the visualisation for all objects is defined. Reference the images or define a list of base shapes that represent
the counters, ingredients, meals and players.
# Citation
......@@ -54,14 +317,17 @@ Initialize an environment....
# Structure of the Documentation
The API documentation follows the file and content structure in the repo.
On the left you can find the navigation panel that brings you to the implementation of
- the **counter factory** converts the characters in the layout file to counter instances,
- the **counters**, including the kitchen utility objects like dispenser, cooking counter (stove, deep fryer, oven),
sink, etc.,
- the **game items**, the holdable ingredients, cooking equipment, composed ingredients, and meals,
- in **main**, you find an example how to start a simulation,
- the **game server**, which can manage several running environments and can communicates via FastAPI post requests and
websockets,
- the **orders**, how to sample incoming orders and their attributes,
- the **environment**, handles the incoming actions and provides the state,
- the **player**/agent, that interacts in the environment,
- a **simulation runner**, that calls the step function of the environment for a real-time interaction, and
- type hints are defined in **state representation** for the json state and **server results** for the data returned by
the game server in post requests.
- **util**ity code.
......
overcooked_simulator/__main__.py
View file @ 7011f0e6
......@@ -50,7 +50,7 @@ def main(cli_args=None):
print("Received Keyboard interrupt")
finally:
if game_server is not None and game_server.is_alive():
print("Terminate gparserame server")
print("Terminate game server")
game_server.terminate()
if pygame_gui is not None and pygame_gui.is_alive():
print("Terminate pygame gui")
......
overcooked_simulator/counter_factory.py
View file @ 7011f0e6
"""
The `CounterFactory` initializes the `Counter` classes from the characters in the layout config.
The mapping depends on the definition in the `environment_config.yml` in the `layout_chars` section.
```yaml
layout_chars:
_: Free
hash: Counter
A: Agent
P: PlateDispenser
C: CuttingBoard
X: Trashcan
W: ServingWindow
S: Sink
+: SinkAddon
U: Pot # with Stove
Q: Pan # with Stove
O: Peel # with Oven
F: Basket # with DeepFryer
T: Tomato
N: Onion # oNioN
L: Lettuce
K: Potato # Kartoffel
I: Fish # fIIIsh
D: Dough
E: Cheese # chEEEse
G: Sausage # sausaGe
B: Bun
M: Meat
```
# Code Documentation
"""
import inspect
import sys
from random import Random
from typing import Any, Type, TypeVar
import numpy as np
......@@ -17,7 +51,15 @@ from overcooked_simulator.counters import (
SinkAddon,
Trashcan,
)
from overcooked_simulator.game_items import ItemInfo, ItemType, CookingEquipment, Plate
from overcooked_simulator.effect_manager import EffectManager
from overcooked_simulator.game_items import (
ItemInfo,
ItemType,
CookingEquipment,
Plate,
Item,
)
from overcooked_simulator.hooks import Hooks
from overcooked_simulator.order import OrderAndScoreManager
from overcooked_simulator.utils import get_closest
......@@ -27,12 +69,15 @@ T = TypeVar("T")
def convert_words_to_chars(layout_chars_config: dict[str, str]) -> dict[str, str]:
"""Converts words in a given layout chars configuration dictionary to their corresponding characters.
This is useful for characters that can not be keys in a yaml file. For example, `#` produces a comment.
Therefore, you can specify `hash` as a key (`hash: Counter`). `word_refs` defines the conversions. *Click on `▶ View Source`.*
Args:
layout_chars_config (dict[str, str]): A dictionary containing layout character configurations, where the keys are words
layout_chars_config: A dictionary containing layout character configurations, where the keys are words
representing layout characters and the values are the corresponding character representations.
Returns:
dict[str, str]: A dictionary where the keys are the layout characters and the values are their corresponding words.
A dictionary where the keys are the layout characters and the values are their corresponding words.
"""
word_refs = {
"hash": "#",
......@@ -75,56 +120,71 @@ class CounterFactory:
serving_window_additional_kwargs: dict[str, Any],
plate_config: PlateConfig,
order_and_score: OrderAndScoreManager,
effect_manager_config: dict,
hook: Hooks,
random: Random,
) -> None:
"""Constructor for the `CounterFactory` class. Set up the attributes necessary to instantiate the counters.
Args:
layout_chars_config (dict[str, str]): A dictionary mapping layout characters to their corresponding names.
item_info (dict[str, ItemInfo]): A dictionary containing information about different items.
serving_window_additional_kwargs (dict[str, Any]): Additional keyword arguments for serving window configuration.
plate_config (PlateConfig): The configuration for plate usage.
Returns:
None
Initializes the object with the provided parameters. It performs the following tasks:
- Converts the layout character configuration from words to characters.
- Sets the item information dictionary.
- Sets the additional keyword arguments for serving window configuration.
- Sets the plate configuration.
It also sets the following attributes:
- `no_counter_chars`: A set of characters that represent counters for agents or free spaces.
- `counter_classes`: A dictionary of counter classes imported from the 'overcooked_simulator.counters' module.
- `cooking_counter_equipments`: A dictionary mapping cooking counters to the list of equipment items associated with them.
Args:
layout_chars_config: A dictionary mapping layout characters to their corresponding names.
item_info: A dictionary containing information about different items.
serving_window_additional_kwargs: Additional keyword arguments for serving window configuration.
plate_config: The configuration for plate usage.
"""
self.layout_chars_config = convert_words_to_chars(layout_chars_config)
self.item_info = item_info
self.serving_window_additional_kwargs = serving_window_additional_kwargs
self.plate_config = plate_config
self.order_and_score = order_and_score
self.layout_chars_config: dict[str, str] = convert_words_to_chars(
layout_chars_config
)
"""Layout chars to the counter names."""
self.item_info: dict[str, ItemInfo] = item_info
"""All item infos from the `item_info` config."""
self.serving_window_additional_kwargs: dict[
str, Any
] = serving_window_additional_kwargs
"""The additional keyword arguments for the serving window."""
self.plate_config: PlateConfig = plate_config
"""The plate config from the `environment_config`"""
self.order_and_score: OrderAndScoreManager = order_and_score
"""The order and score manager to pass to `ServingWindow` and the `Tashcan` which can affect the scores."""
self.effect_manager_config = effect_manager_config
"""The effect manager config to setup the effect manager based on the defined effects in the item info."""
self.no_counter_chars = set(
self.no_counter_chars: set[str] = set(
c
for c, name in self.layout_chars_config.items()
if name in ["Agent", "Free"]
)
"""A set of characters that represent counters for agents or free spaces."""
self.counter_classes = dict(
self.counter_classes: dict[str, Type] = dict(
inspect.getmembers(
sys.modules["overcooked_simulator.counters"], inspect.isclass
)
)
"""A dictionary of counter classes imported from the 'overcooked_simulator.counters' module."""
self.cooking_counter_equipments = {
cooking_counter: [
self.cooking_counter_equipments: dict[str, set[str]] = {
cooking_counter: {
equipment
for equipment, e_info in self.item_info.items()
if e_info.equipment and e_info.equipment.name == cooking_counter
]
}
for cooking_counter, info in self.item_info.items()
if info.type == ItemType.Equipment and info.equipment is None
}
"""A dictionary mapping cooking counters to the list of equipment items associated with them."""
self.hook = hook
"""Reference to the hook manager."""
self.random = random
"""Random instance."""
def get_counter_object(self, c: str, pos: npt.NDArray[float]) -> Counter:
"""Create and returns a counter object based on the provided character and position."""
......@@ -137,36 +197,49 @@ class CounterFactory:
if item_info.equipment.name not in self.counter_classes:
return CookingCounter(
name=item_info.equipment.name,
cooking_counter_equipments=self.cooking_counter_equipments,
equipments=self.cooking_counter_equipments[
item_info.equipment.name
],
pos=pos,
occupied_by=CookingEquipment(
name=item_info.name,
item_info=item_info,
transitions=self.filter_item_info(
by_equipment_name=item_info.name
by_equipment_name=item_info.name,
add_effects=True,
),
),
hook=self.hook,
)
elif item_info.type == ItemType.Ingredient:
return Dispenser(pos=pos, dispensing=item_info)
return Dispenser(pos=pos, hook=self.hook, dispensing=item_info)
elif item_info.type == ItemType.Tool:
return Counter(
pos=pos,
hook=self.hook,
occupied_by=Item(name=item_info.name, item_info=item_info),
)
if counter_class is None:
counter_class = self.counter_classes[self.layout_chars_config[c]]
kwargs = {
"pos": pos,
"hook": self.hook,
}
if issubclass(counter_class, (CuttingBoard, Sink)):
kwargs["transitions"] = self.filter_item_info(
by_equipment_name=counter_class.__name__
by_equipment_name=counter_class.__name__,
add_effects=True,
)
elif issubclass(counter_class, PlateDispenser):
kwargs.update(
{
"plate_transitions": self.filter_item_info(
by_item_type=ItemType.Meal
by_item_type=ItemType.Meal, add_effects=True
),
"plate_config": self.plate_config,
"dispensing": self.item_info[Plate.__name__],
"random": self.random,
}
)
elif issubclass(counter_class, ServingWindow):
......@@ -200,21 +273,32 @@ class CounterFactory:
self,
by_item_type: ItemType = None,
by_equipment_name: str = None,
add_effects: bool = False,
) -> dict[str, ItemInfo]:
"""Filter the item info dict by item type or equipment name"""
filtered = {}
if by_item_type is not None:
return {
filtered = {
name: info
for name, info in self.item_info.items()
if info.type == by_item_type
}
if by_equipment_name is not None:
return {
filtered = {
name: info
for name, info in self.item_info.items()
if info.equipment is not None
and info.equipment.name == by_equipment_name
}
if add_effects:
for name, effect in self.filter_item_info(
by_item_type=ItemType.Effect
).items():
for need in effect.needs:
if need in filtered:
filtered.update({name: effect})
if by_item_type or by_equipment_name:
return filtered
return self.item_info
def post_counter_setup(self, counters: list[Counter]):
......@@ -240,11 +324,34 @@ class CounterFactory:
counter: Sink # Pycharm type checker does now work for match statements?
assert len(sink_addons) > 0, "No SinkAddon but normal Sink"
closest_addon = get_closest(pos, sink_addons)
assert 1 - (1 * 0.05) <= np.linalg.norm(
assert 1.0 == np.linalg.norm(
closest_addon.pos - pos
), f"No SinkAddon connected to Sink at pos {pos}"
counter.set_addon(closest_addon)
def setup_effect_manger(self, counters: list[Counter]) -> dict[str, EffectManager]:
effect_manager = {}
for name, effect in self.filter_item_info(by_item_type=ItemType.Effect).items():
assert (
effect.manager in self.effect_manager_config
), f"Manager for effect not found: {name} -> {effect.manager} not in {list(self.effect_manager_config.keys())}"
if effect.manager in effect_manager:
manager = effect_manager[effect.manager]
else:
manager = self.effect_manager_config[effect.manager]["class"](
hook=self.hook,
random=self.random,
**self.effect_manager_config[effect.manager]["kwargs"],
)
manager.set_counters(counters)
effect_manager[effect.manager] = manager
manager.add_effect(effect)
effect.manager = manager
return effect_manager
@staticmethod
def get_counter_of_type(counter_type: Type[T], counters: list[Counter]) -> list[T]:
"""Filter all counters in the environment for a counter type."""
......
overcooked_simulator/counters.py
View file @ 7011f0e6
This diff is collapsed.
overcooked_simulator/effect_manager.py 0 → 100644
View file @ 7011f0e6
from __future__ import annotations
from collections import deque
from datetime import timedelta, datetime
from random import Random
from typing import TYPE_CHECKING, Tuple
from overcooked_simulator.game_items import (
ItemInfo,
Item,
ItemType,
Effect,
CookingEquipment,
)
from overcooked_simulator.hooks import Hooks
from overcooked_simulator.utils import get_touching_counters, find_item_on_counters
if TYPE_CHECKING:
from overcooked_simulator.counters import Counter
class EffectManager:
def __init__(self, hook: Hooks, random: Random) -> None:
self.effects = []
self.counters = []
self.hook = hook
self.new_effects: list[Tuple[Effect, Item | Counter]] = []
self.random = random
def add_effect(self, effect: ItemInfo):
self.effects.append(effect)
def set_counters(self, counters: list[Counter]):
self.counters.extend(counters)
def register_active_effect(self, effect: Effect, target: Item | Counter):
target.active_effects.append(effect)
self.new_effects.append((effect, target))
def progress(self, passed_time: timedelta, now: datetime):
...
def can_start_effect_transition(
self, effect: ItemInfo, target: Item | Counter
) -> bool:
return effect.name not in [e.name for e in target.active_effects]
def remove_active_effect(self, effect: Effect, target: Item | Counter):
...
class FireEffectManager(EffectManager):
# TODO add Random object
def __init__(
self,
spreading_duration: list[float],
fire_burns_ingredients_and_meals: bool,
**kwargs,
):
super().__init__(**kwargs)
self.spreading_duration = spreading_duration
self.fire_burns_ingredients_and_meals = fire_burns_ingredients_and_meals
self.effect_to_timer: dict[str:datetime] = {}
self.next_finished_timer = datetime.max
self.active_effects: list[Tuple[Effect, Item | Counter]] = []
def progress(self, passed_time: timedelta, now: datetime):
if self.new_effects:
for effect, target in self.new_effects:
self.effect_to_timer[effect.uuid] = now + timedelta(
seconds=self.random.uniform(*self.spreading_duration)
)
self.next_finished_timer = min(
self.next_finished_timer, self.effect_to_timer[effect.uuid]
)
self.active_effects.append((effect, target))
self.new_effects = []
if self.next_finished_timer < now:
for effect, target in self.active_effects:
if self.effect_to_timer[effect.uuid] < now:
if isinstance(target, Item):
target = find_item_on_counters(target.uuid, self.counters)
if target:
touching = get_touching_counters(target, self.counters)
for counter in touching:
if counter.occupied_by:
if isinstance(counter.occupied_by, deque):
self.apply_effect(effect, counter.occupied_by[-1])
else:
self.apply_effect(effect, counter.occupied_by)
else:
self.apply_effect(effect, counter)
self.effect_to_timer[effect.uuid] = now + timedelta(
seconds=self.random.uniform(*self.spreading_duration)
)
if self.effect_to_timer:
self.next_finished_timer = min(self.effect_to_timer.values())
else:
self.next_finished_timer = datetime.max
def apply_effect(self, effect: Effect, target: Item | Counter):
if (
isinstance(target, Item)
and target.item_info.type == ItemType.Tool
and effect.name in target.item_info.needs
):
# Tools that reduce fire can not burn
return
if effect.name not in target.active_effects and target.uuid not in [
t.uuid for _, t in self.active_effects
]:
if isinstance(target, CookingEquipment):
if target.content_list:
for content in target.content_list:
self.burn_content(content)
if self.fire_burns_ingredients_and_meals:
self.burn_content(target.content_ready)
elif isinstance(target, Item):
self.burn_content(target)
self.register_active_effect(
Effect(effect.name, item_info=effect.item_info), target
)
def burn_content(self, content: Item):
if self.fire_burns_ingredients_and_meals and content:
if not content.name.startswith("Burnt"):
content.name = "Burnt" + content.name
def remove_active_effect(self, effect: Effect, target: Item | Counter):
if (effect, target) in self.active_effects:
self.active_effects.remove((effect, target))
if effect.uuid in self.effect_to_timer:
del self.effect_to_timer[effect.uuid]
overcooked_simulator/game_content/agents/arch_config.yml 0 → 100644
View file @ 7011f0e6
concurrency: MultiProcessing
communication:
communication_prefs:
- !name:ipaacar_com_service.communications.ipaacar_com.IPAACARInfo
modules:
connection:
module_info: !name:cocosy_agent.modules.connection_module.ConnectionModule
mean_frequency_step: 2 # 2: every 0.5 seconds
working_memory:
module_info: !name:cocosy_agent.modules.working_memory_module.WorkingMemoryModule
subtask_selection:
module_info: !name:cocosy_agent.modules.random_subtask_module.RandomSubtaskModule
action_execution:
module_info: !name:cocosy_agent.modules.action_execution_module.ActionExecutionModule
mean_frequency_step: 10 # 2: every 0.5 seconds
# gui:
# module_info: !name:aaambos.std.guis.pysimplegui.pysimplegui_window.PySimpleGUIWindowModule
# window_title: Counting GUI
# topics_to_show: [["SubtaskDecision", "cocosy_agent.conventions.communication.SubtaskDecision", ["task_type"]], ["ActionControl", "cocosy_agent.conventions.communication.ActionControl", ["action_type"]]]
status_manager:
module_info: !name:aaambos.std.modules.module_status_manager.ModuleStatusManager
gui: false
\ No newline at end of file
overcooked_simulator/game_content/agents/random_agent.py 0 → 100644
View file @ 7011f0e6
import argparse
import asyncio
import dataclasses
import json
import random
import time
from collections import defaultdict
from datetime import datetime, timedelta
import numpy as np
from websockets import connect
from overcooked_simulator.overcooked_environment import (
ActionType,
Action,
InterActionData,
)
from overcooked_simulator.utils import custom_asdict_factory
async def agent():
parser = argparse.ArgumentParser("Random agent")
parser.add_argument("--uri", type=str)
parser.add_argument("--player_id", type=str)
parser.add_argument("--player_hash", type=str)
parser.add_argument("--step_time", type=float, default=0.5)
args = parser.parse_args()
async with connect(args.uri) as websocket:
await websocket.send(
json.dumps({"type": "ready", "player_hash": args.player_hash})
)
await websocket.recv()
ended = False
counters = None
player_info = {}
current_agent_pos = None
interaction_counter = None
last_interacting = False
last_interact_progress = None
threshold = datetime.max
task_type = None
task_args = None
started_interaction = False
still_interacting = False
current_nearest_counter_id = None
while not ended:
time.sleep(args.step_time)
await websocket.send(
json.dumps({"type": "get_state", "player_hash": args.player_hash})
)
state = json.loads(await websocket.recv())
if counters is None:
counters = defaultdict(list)
for counter in state["counters"]:
counters[counter["type"]].append(counter)
for player in state["players"]:
if player["id"] == args.player_id:
player_info = player
current_agent_pos = player["pos"]
if player["current_nearest_counter_id"]:
if (
current_nearest_counter_id
!= player["current_nearest_counter_id"]
):
for counter in state["counters"]:
if (
counter["id"]
== player["current_nearest_counter_id"]
):
interaction_counter = counter
current_nearest_counter_id = player[
"current_nearest_counter_id"
]
break
if last_interacting:
if (
not interaction_counter
or not interaction_counter["occupied_by"]
or isinstance(interaction_counter["occupied_by"], list)
or (
interaction_counter["occupied_by"][
"progress_percentage"
]
== 1.0
)
):
last_interacting = False
last_interact_progress = None
else:
if (
interaction_counter
and interaction_counter["occupied_by"]
and not isinstance(interaction_counter["occupied_by"], list)
):
if (
last_interact_progress
!= interaction_counter["occupied_by"][
"progress_percentage"
]
):
last_interact_progress = interaction_counter[
"occupied_by"
]["progress_percentage"]
last_interacting = True
break
if task_type:
if threshold < datetime.now():
print(
args.player_hash, args.player_id, "---Threshold---Too long---"
)
task_type = None
match task_type:
case "GOTO":
diff = np.array(task_args) - np.array(current_agent_pos)
dist = np.linalg.norm(diff)
if dist > 1.2:
if dist != 0:
await websocket.send(
json.dumps(
{
"type": "action",
"action": dataclasses.asdict(
Action(
args.player_id,
ActionType.MOVEMENT,
(diff / dist).tolist(),
args.step_time + 0.01,
),
dict_factory=custom_asdict_factory,
),
"player_hash": args.player_hash,
}
)
)
await websocket.recv()
else:
task_type = None
task_args = None
case "INTERACT":
if not started_interaction or (
still_interacting and interaction_counter
):
if not started_interaction:
started_interaction = True
still_interacting = True
await websocket.send(
json.dumps(
{
"type": "action",
"action": dataclasses.asdict(
Action(
args.player_id,
ActionType.INTERACT,
InterActionData.START,
),
dict_factory=custom_asdict_factory,
),
"player_hash": args.player_hash,
}
)
)
await websocket.recv()
else:
still_interacting = False
started_interaction = False
task_type = None
task_args = None
case "PUT":
await websocket.send(
json.dumps(
{
"type": "action",
"action": dataclasses.asdict(
Action(
args.player_id,
ActionType.PUT,
"pickup",
),
dict_factory=custom_asdict_factory,
),
"player_hash": args.player_hash,
}
)
)
await websocket.recv()
task_type = None
task_args = None
case None:
...
if not task_type:
task_type = random.choice(["GOTO", "PUT", "INTERACT"])
threshold = datetime.now() + timedelta(seconds=15.0)
if task_type == "GOTO":
counter_type = random.choice(list(counters.keys()))
task_args = random.choice(counters[counter_type])["pos"]
print(args.player_hash, args.player_id, task_type, counter_type)
else:
print(args.player_hash, args.player_id, task_type)
task_args = None
ended = state["ended"]
if __name__ == "__main__":
asyncio.run(agent())
overcooked_simulator/game_content/agents/run_config.yml 0 → 100644
View file @ 7011f0e6
general:
agent_name: cocosy_agent
instance: _dev
local_agent_directories: ~/aaambos_agents
plus:
agent_websocket: ws://localhost:8000:/ws/player/MY_CLIENT_ID
player_hash: abcdefghijklmnopqrstuvwxyz
agent_id: 1
logging:
log_level_command_line: INFO
supervisor:
run_time_manager_class: !name:aaambos.std.supervision.instruction_run_time_manager.instruction_run_time_manager.InstructionRunTimeManager
overcooked_simulator/game_content/environment_config.yaml
View file @ 7011f0e6
......@@ -20,6 +20,7 @@ layout_chars:
_: Free
hash: Counter
A: Agent
pipe: Extinguisher
P: PlateDispenser
C: CuttingBoard
X: Trashcan
......@@ -41,6 +42,7 @@ layout_chars:
B: Bun
M: Meat
orders:
order_gen_class: !!python/name:overcooked_simulator.order.RandomOrderGeneration ''
# the class to that receives the kwargs. Should be a child class of OrderGeneration in order.py
......@@ -83,5 +85,47 @@ orders:
player_config:
radius: 0.4
player_speed_units_per_seconds: 8
player_speed_units_per_seconds: 6
interaction_range: 1.6
effect_manager:
FireManager:
class: !!python/name:overcooked_simulator.effect_manager.FireEffectManager ''
kwargs:
spreading_duration: [ 5, 10 ]
fire_burns_ingredients_and_meals: true
extra_setup_functions:
# json_states:
# func: !!python/name:overcooked_simulator.recording.class_recording_with_hooks ''
# kwargs:
# hooks: [ json_state ]
# log_class: !!python/name:overcooked_simulator.recording.LogRecorder ''
# log_class_kwargs:
# log_path: USER_LOG_DIR/ENV_NAME/json_states.jsonl
actions:
func: !!python/name:overcooked_simulator.recording.class_recording_with_hooks ''
kwargs:
hooks: [ pre_perform_action ]
log_class: !!python/name:overcooked_simulator.recording.LogRecorder ''
log_class_kwargs:
log_path: USER_LOG_DIR/ENV_NAME/LOG_RECORD_NAME.jsonl
random_env_events:
func: !!python/name:overcooked_simulator.recording.class_recording_with_hooks ''
kwargs:
hooks: [ order_duration_sample, plate_out_of_kitchen_time ]
log_class: !!python/name:overcooked_simulator.recording.LogRecorder ''
log_class_kwargs:
log_path: USER_LOG_DIR/ENV_NAME/LOG_RECORD_NAME.jsonl
add_hook_ref: true
env_configs:
func: !!python/name:overcooked_simulator.recording.class_recording_with_hooks ''
kwargs:
hooks: [ env_initialized, item_info_config ]
log_class: !!python/name:overcooked_simulator.recording.LogRecorder ''
log_class_kwargs:
log_path: USER_LOG_DIR/ENV_NAME/LOG_RECORD_NAME.jsonl
add_hook_ref: true
overcooked_simulator/game_content/item_info.yaml
View file @ 7011f0e6
......@@ -176,3 +176,57 @@ Pizza:
needs: [ PizzaBase, ChoppedTomato, GratedCheese, ChoppedSausage ]
seconds: 7.0
equipment: Peel
# --------------------------------------------------------------------------------
BurntCookedPatty:
type: Waste
seconds: 5.0
needs: [ CookedPatty ]
equipment: Pan
BurntChips:
type: Waste
seconds: 5.0
needs: [ Chips ]
equipment: Basket
BurntFriedFish:
type: Waste
seconds: 5.0
needs: [ FriedFish ]
equipment: Basket
BurntTomatoSoup:
type: Waste
needs: [ TomatoSoup ]
seconds: 6.0
equipment: Pot
BurntOnionSoup:
type: Waste
needs: [ OnionSoup ]
seconds: 6.0
equipment: Pot
BurntPizza:
type: Waste
needs: [ Pizza ]
seconds: 7.0
equipment: Peel
# --------------------------------------------------------------------------------
Fire:
type: Effect
seconds: 5.0
needs: [ BurntCookedPatty, BurntChips, BurntFriedFish, BurntTomatoSoup, BurntOnionSoup, BurntPizza ]
manager: FireManager
effect_type: Unusable
# --------------------------------------------------------------------------------
Extinguisher:
type: Tool
seconds: 1.0
needs: [ Fire ]
overcooked_simulator/game_content/item_info_debug.yaml
View file @ 7011f0e6
......@@ -177,3 +177,57 @@ Pizza:
needs: [ PizzaBase, ChoppedTomato, GratedCheese, ChoppedSausage ]
seconds: 0.1
equipment: Peel
# --------------------------------------------------------------------------------
BurntCookedPatty:
type: Waste
seconds: 5.0
needs: [ CookedPatty ]
equipment: Pan
BurntChips:
type: Waste
seconds: 1.0
needs: [ Chips ]
equipment: Basket
BurntFriedFish:
type: Waste
seconds: 5.0
needs: [ FriedFish ]
equipment: Basket
BurntTomatoSoup:
type: Waste
needs: [ TomatoSoup ]
seconds: 6.0
equipment: Pot
BurntOnionSoup:
type: Waste
needs: [ OnionSoup ]
seconds: 6.0
equipment: Pot
BurntPizza:
type: Waste
needs: [ Pizza ]
seconds: 7.0
equipment: Peel
# --------------------------------------------------------------------------------
Fire:
type: Effect
seconds: 1.0
needs: [ BurntCookedPatty, BurntChips, BurntFriedFish, BurntTomatoSoup, BurntOnionSoup, BurntPizza ]
manager: FireManager
effect_type: Unusable
# --------------------------------------------------------------------------------
Extinguisher:
type: Tool
seconds: 0.1
needs: [ Fire ]
\ No newline at end of file
overcooked_simulator/game_content/layouts/basic.layout
View file @ 7011f0e6
#QU#FO#TNLB#
#__________M
#__________K
|__________K
W__________I
#__A_____A_D
C__________E
......
overcooked_simulator/game_content/layouts/empty.layout
View file @ 7011f0e6
______
______
______
______
______
______
_____P
\ No newline at end of file
_______
_______
_______
_______
__A____
_______
_______
______P
\ No newline at end of file
overcooked_simulator/game_content/layouts/large.layout 0 → 100644
View file @ 7011f0e6
#QU#F###O#T#################N###L###B#
#____________________________________#
#____________________________________M
#____________________________________#
#____________________________________#
#____________________________________K
W____________________________________I
#____________________________________#
#____________________________________#
#__A_____A___________________________D
#____________________________________#
#____________________________________#
#____________________________________#
#____________________________________#
#____________________________________#
C____________________________________E
#____________________________________#
#____________________________________#
#____________________________________#
#____________________________________#
C____________________________________G
#____________________________________#
#P#####S+####X#####S+#################
\ No newline at end of file
overcooked_simulator/game_content/layouts/rot_test.layout 0 → 100644
View file @ 7011f0e6
##S+#
S___#
+___S
#___+
#+SP#
\ No newline at end of file
overcooked_simulator/game_items.py
View file @ 7011f0e6
......@@ -26,18 +26,38 @@ import datetime
import logging
import uuid
from enum import Enum
from typing import Optional, TypedDict
from typing import Optional, TypedDict, TYPE_CHECKING
if TYPE_CHECKING:
from overcooked_simulator.effect_manager import EffectManager
log = logging.getLogger(__name__)
"""The logger for this module."""
ITEM_CATEGORY = "Item"
"""The string for the `category` value in the json state representation for all normal items."""
COOKING_EQUIPMENT_ITEM_CATEGORY = "ItemCookingEquipment"
"""The string for the `category` value in the json state representation for all cooking equipments."""
class EffectType(Enum):
Unusable = "Unusable"
class ItemType(Enum):
Ingredient = "Ingredient"
"""All ingredients and process ingredients."""
Meal = "Meal"
"""All combined ingredients that can be served."""
Equipment = "Equipment"
"""All counters and cooking equipments."""
Waste = "Waste"
"""Burnt ingredients and meals."""
Effect = "Effect"
"""Does not change the item but the object attributes, like adding fire."""
Tool = "Tool"
"""Item that remains in hands in extends the interactive abilities of the player."""
@dataclasses.dataclass
......@@ -80,16 +100,24 @@ class ItemInfo:
"""The name of the item, is set automatically by the "group" name of the item."""
seconds: float = dataclasses.field(compare=False, default=0)
"""If progress is needed this argument defines how long it takes to complete the process in seconds."""
# TODO maybe as a lambda/based on Prefix?
needs: list[str] = dataclasses.field(compare=False, default_factory=list)
"""The ingredients/items which are needed to create the item/start the progress."""
equipment: ItemInfo | None = dataclasses.field(compare=False, default=None)
"""On which the item can be created. `null`, `~` (None) converts to Plate."""
manager: str | None | EffectManager = None
"""The manager for the effect."""
effect_type: None | EffectType = None
"""How does the effect effect interaction, combine actions etc."""
recipe: collections.Counter | None = None
"""Internally set in CookingEquipment"""
def __post_init__(self):
self.type = ItemType(self.type)
if self.effect_type:
self.effect_type = EffectType(self.effect_type)
class ActiveTransitionTypedDict(TypedDict):
......@@ -97,7 +125,7 @@ class ActiveTransitionTypedDict(TypedDict):
seconds: int | float
"""The needed seconds to progress for the transition."""
result: str
result: str | Item | Effect
"""The new name of the item after the transition."""
......@@ -105,15 +133,25 @@ class Item:
"""Base class for game items which can be held by a player."""
item_category = ITEM_CATEGORY
"""Class dependent category (is changed for the `CookingEquipment` class). """
def __init__(
self, name: str, item_info: ItemInfo, uid: str = None, *args, **kwargs
):
self.name = self.__class__.__name__ if name is None else name
self.item_info = item_info
self.progress_equipment = None
self.progress_percentage = 0.0
self.uuid = uuid.uuid4().hex if uid is None else uid
self.name: str = self.__class__.__name__ if name is None else name
"""The name of the item, e.g., `Tomato` or `ChoppedTomato`"""
self.item_info: ItemInfo = item_info
"""The information about the item from the `item_info.yml` config."""
self.progress_equipment: str | None = None
"""The equipment with which the item was last progressed."""
self.progress_percentage: float = 0.0
"""The current progress percentage of the item if it is progress-able."""
self.inverse_progress: bool = False
"""Whether the progress will produce waste."""
self.uuid: str = uuid.uuid4().hex if uid is None else uid
"""A unique identifier for the item. Useful for GUIs that handles specific asset instances."""
self.active_effects: list[Effect] = []
"""The effects that affect the item."""
def __repr__(self):
if self.progress_equipment is None:
......@@ -126,12 +164,15 @@ class Item:
@property
def extra_repr(self):
"""Additional string to add to the representation of the item (in __repr__)."""
return ""
def can_combine(self, other) -> bool:
"""Check if the item can be combined with the other. After it returned True the `combine` method is called."""
return False
def combine(self, other) -> Item | None:
"""Combine the item with another item based on possible transitions/needs."""
pass
def progress(self, equipment: str, percent: float):
......@@ -148,26 +189,33 @@ class Item:
)
def reset(self):
"""Reset the progress."""
self.progress_equipment = None
self.progress_percentage = 0.0
self.inverse_progress = False
def to_dict(self) -> dict:
"""For the state representation. Only the relevant attributes are put into the dict."""
return {
"id": self.uuid,
"category": self.item_category,
"type": self.name,
"progress_percentage": self.progress_percentage,
"inverse_progress": self.inverse_progress,
"active_effects": [e.to_dict() for e in self.active_effects],
}
class CookingEquipment(Item):
"""Pot, Pan, ... that can hold items. It holds the progress of the content (e.g., the soup) in itself (
progress_percentage) and not in the items in the content list."""
item_category = "Cooking Equipment"
item_category = COOKING_EQUIPMENT_ITEM_CATEGORY
def __init__(self, transitions: dict[str, ItemInfo], *args, **kwargs):
super().__init__(*args, **kwargs)
self.transitions = transitions
self.transitions: dict[str, ItemInfo] = transitions
"""What is needed to cook a meal / create another ingredient."""
self.active_transition: Optional[ActiveTransitionTypedDict] = None
"""The info how and when to convert the content_list to a new item."""
......@@ -186,9 +234,17 @@ class CookingEquipment(Item):
def can_combine(self, other) -> bool:
# already cooking or nothing to combine
if other is None:
if other is None or (
isinstance(other, CookingEquipment) and not other.content_list
):
return False
if any(
e.item_info.effect_type == EffectType.Unusable for e in other.active_effects
) or any(
e.item_info.effect_type == EffectType.Unusable for e in self.active_effects
):
return False
if isinstance(other, CookingEquipment):
other = other.content_list
else:
......@@ -206,45 +262,82 @@ class CookingEquipment(Item):
self.content_list.extend(other.content_list)
return_value = other
other.reset_content()
other.reset()
elif isinstance(other, list):
self.content_list.extend(other)
else:
self.content_list.append(other)
ingredients = collections.Counter(item.name for item in self.content_list)
for result, transition in self.transitions.items():
if ingredients == transition.recipe:
if transition.seconds == 0:
self.content_ready = Item(name=result, item_info=transition)
else:
self.active_transition = {
"seconds": transition.seconds,
"result": Item(name=result, item_info=transition),
}
break
else:
self.content_ready = None
self.check_active_transition()
return return_value
def can_progress(self) -> bool:
return self.active_transition is not None
"""Check if the cooking equipment can progress items at all."""
return self.active_transition is not None and not any(
e.item_info.effect_type == EffectType.Unusable for e in self.active_effects
)
def progress(self, passed_time: datetime.timedelta, now: datetime.datetime):
percent = passed_time.total_seconds() / self.active_transition["seconds"]
super().progress(equipment=self.name, percent=percent)
if self.progress_percentage == 1.0:
self.content_list = [self.active_transition["result"]]
if isinstance(self.active_transition["result"], Effect):
self.active_transition[
"result"
].item_info.manager.register_active_effect(
self.active_transition["result"], self
)
else:
self.content_list = [self.active_transition["result"]]
self.reset()
self.check_active_transition()
# todo set active transition for fire/burnt?
def check_active_transition(self):
ingredients = collections.Counter(item.name for item in self.content_list)
for result, transition in self.transitions.items():
if transition.type == ItemType.Effect:
if set(ingredients.keys()).issubset(
transition.needs
) and transition.manager.can_start_effect_transition(transition, self):
if transition.seconds == 0:
transition.manager.register_active_effect(
Effect(name=transition.name, item_info=transition), self
)
else:
self.active_transition = {
"seconds": transition.seconds,
"result": Effect(
name=transition.name, item_info=transition
),
}
self.inverse_progress = True
break # ?
else:
if ingredients == transition.recipe:
if transition.seconds == 0:
self.content_ready = Item(name=result, item_info=transition)
else:
self.active_transition = {
"seconds": transition.seconds,
"result": Item(name=result, item_info=transition),
}
self.inverse_progress = transition.type == ItemType.Waste
break
else:
self.content_ready = None
def reset_content(self):
"""Reset the content attributes after the content was picked up from the equipment."""
self.content_list = []
self.content_ready = None
def release(self):
"""Release the content when the player "picks up" the equipment with a plate in the hands"""
content = self.content_list
self.reset_content()
self.reset()
return content
@property
......@@ -256,6 +349,7 @@ class CookingEquipment(Item):
self.active_transition = None
def get_potential_meal(self) -> Item | None:
"""The meal that could be served depends on the attributes `content_ready` and `content_list`"""
if self.content_ready:
return self.content_ready
if len(self.content_list) == 1:
......@@ -281,8 +375,9 @@ class CookingEquipment(Item):
class Plate(CookingEquipment):
"""The plate can have to states: clean and dirty. In the clean state it can hold content/other items."""
def __init__(self, transitions, clean, *args, **kwargs):
self.clean = clean
def __init__(self, transitions: dict[str, ItemInfo], clean: bool, *args, **kwargs):
self.clean: bool = clean
"""If the plate is clean or dirty."""
self.meals = set(transitions.keys())
"""All meals can be hold by a clean plate"""
super().__init__(
......@@ -292,14 +387,12 @@ class Plate(CookingEquipment):
**kwargs,
)
def finished_call(self):
self.clean = True
self.name = self.create_name()
def progress(self, equipment: str, percent: float):
Item.progress(self, equipment, percent)
def create_name(self):
"""The name depends on the clean or dirty state of the plate. Clean plates are `Plate`, otherwise
`DirtyPlate`."""
return "Plate" if self.clean else "DirtyPlate"
def can_combine(self, other):
......@@ -317,3 +410,19 @@ class Plate(CookingEquipment):
elif self.clean:
return True
return False
class Effect:
def __init__(self, name: str, item_info: ItemInfo, uid: str = None):
self.uuid: str = uuid.uuid4().hex if uid is None else uid
self.name = name
self.item_info = item_info
self.progres_percentage = 0.0
def to_dict(self) -> dict:
return {
"id": self.uuid,
"type": self.name,
"progress_percentage": self.progres_percentage,
"inverse_progress": True,
}
overcooked_simulator/game_server.py
View file @ 7011f0e6
......@@ -125,6 +125,7 @@ class EnvironmentHandler:
layout_config=environment_config.layout_config,
item_info=environment_config.item_info_config,
as_files=False,
env_name=env_id,
)
player_info = {}
for player_id in range(environment_config.number_players):
......@@ -219,7 +220,9 @@ class EnvironmentHandler:
self.envs[env_id].last_step_time = time.time_ns()
self.envs[env_id].environment.reset_env_time()
def get_state(self, player_hash: str) -> str: # -> StateRepresentation as json
def get_state(
self, player_hash: str
) -> str | int: # -> StateRepresentation as json
"""Get the current state representation of the environment for a player.
Args:
......@@ -236,6 +239,10 @@ class EnvironmentHandler:
return self.envs[
self.player_data[player_hash].env_id
].environment.get_json_state()
if player_hash not in self.player_data:
return 1
if self.player_data[player_hash].env_id not in self.envs:
return 2
def pause_env(self, manager_id: str, env_id: str, reason: str):
"""Pause the specified environment.
......@@ -250,7 +257,7 @@ class EnvironmentHandler:
manager_id in self.manager_envs
and env_id in self.manager_envs[manager_id]
and self.envs[env_id].status
not in [EnvironmentStatus.STOPPED, Environment.PAUSED]
not in [EnvironmentStatus.STOPPED, EnvironmentStatus.PAUSED]
):
self.envs[env_id].status = EnvironmentStatus.PAUSED
......@@ -266,7 +273,7 @@ class EnvironmentHandler:
manager_id in self.manager_envs
and env_id in self.manager_envs[manager_id]
and self.envs[env_id].status
not in [EnvironmentStatus.STOPPED, Environment.PAUSED]
not in [EnvironmentStatus.STOPPED, EnvironmentStatus.PAUSED]
):
self.envs[env_id].status = EnvironmentStatus.PAUSED
self.envs[env_id].last_step_time = time.time_ns()
......@@ -598,7 +605,17 @@ def manage_websocket_message(message: str, client_id: str) -> PlayerRequestResul
}
case PlayerRequestType.GET_STATE:
return environment_handler.get_state(message_dict["player_hash"])
state = environment_handler.get_state(message_dict["player_hash"])
if isinstance(state, int):
return {
"request_type": message_dict["type"],
"status": 400,
"msg": "env id of player not in running envs"
if state == 2
else "player hash unknown",
"player_hash": None,
}
return state
case PlayerRequestType.ACTION:
assert (
......@@ -655,6 +672,7 @@ class CreateEnvironmentConfig(BaseModel):
item_info_config: str # file content
environment_config: str # file content
layout_config: str # file content
seed: int
class AdditionalPlayer(BaseModel):
......@@ -724,7 +742,10 @@ async def websocket_player_endpoint(websocket: WebSocket, client_id: str):
log.debug(f"Client #{client_id} disconnected")
def main(host: str, port: int, manager_ids: list[str]):
def main(
host: str, port: int, manager_ids: list[str], enable_websocket_logging: bool = False
):
setup_logging(enable_websocket_logging)
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
environment_handler.extend_allowed_manager(manager_ids)
......@@ -745,8 +766,7 @@ if __name__ == "__main__":
disable_websocket_logging_arguments(parser)
add_list_of_manager_ids_arguments(parser)
args = parser.parse_args()
setup_logging(args.enable_websocket_logging)
main(args.url, args.port, args.manager_ids)
main(args.url, args.port, args.manager_ids, args.enable_websocket_logging)
"""
Or in console:
uvicorn overcooked_simulator.fastapi_game_server:app --reload
......
overcooked_simulator/gui_2d_vis/gui_theme.json
View file @ 7011f0e6
......@@ -6,7 +6,7 @@
"disabled_bg": "#25292e",
"selected_bg": "#193754",
"dark_bg": "#15191e",
"normal_text": "#c5cbd8",
"normal_text": "#000000",
"hovered_text": "#FFFFFF",
"selected_text": "#FFFFFF",
"disabled_text": "#6d736f",
......@@ -92,5 +92,70 @@
"normal_border": "#000000",
"normal_text": "#000000"
}
},
"#players": {
"colours": {
"dark_bg": "#fffacd",
"normal_border": "#fffacd"
}
},
"#players_players": {
"colours": {
"dark_bg": "#fffacd"
}
},
"#players_bots": {
"colours": {
"dark_bg": "#fffacd"
}
},
"#number_players_label": {
"colours": {
"dark_bg": "#fffacd",
"normal_text": "#000000"
},
"font": {
"size": 14,
"bold": 1
}
},
"#number_bots_label": {
"colours": {
"dark_bg": "#fffacd",
"normal_text": "#000000"
},
"font": {
"size": 14,
"bold": 1,
"colour": "#000000"
}
},
"#multiple_keysets_button": {
"font": {
"size": 12,
"bold": 1,
"colour": "#000000"
}
},
"#split_players_button": {
"font": {
"size": 12,
"bold": 1,
"colour": "#000000"
}
},
"#controller_button": {
"font": {
"size": 12,
"bold": 1,
"colour": "#000000"
}
},
"#quantity_button": {
"font": {
"size": 24,
"bold": 1,
"colour": "#000000"
}
}
}
\ No newline at end of file