2023-10-23 11:15:50 +00:00
|
|
|
from typing import Iterator, Callable
|
|
|
|
from logging import error
|
2023-10-22 17:26:06 +00:00
|
|
|
|
|
|
|
|
|
|
|
class World:
|
2023-10-22 21:11:44 +00:00
|
|
|
"""
|
|
|
|
Un monde contenant des entités et des ressources.
|
|
|
|
"""
|
|
|
|
|
2023-10-22 17:26:06 +00:00
|
|
|
def __init__(self):
|
2023-10-22 21:11:44 +00:00
|
|
|
"""
|
|
|
|
Permet de créer un nouveau monde vide.
|
|
|
|
"""
|
2023-10-22 20:22:17 +00:00
|
|
|
self._to_apply: set[Entity] = set()
|
|
|
|
self._entities: set[Entity] = set()
|
|
|
|
self._mapping: dict[type, set[Entity]] = {}
|
2023-10-22 20:49:58 +00:00
|
|
|
self._to_apply_resources: list[tuple[type, object]] = []
|
|
|
|
self._resources: dict[type, object] = {}
|
2023-10-23 10:14:28 +00:00
|
|
|
|
2023-10-22 20:19:43 +00:00
|
|
|
def create_entity(self, *components):
|
2023-10-22 21:11:44 +00:00
|
|
|
"""
|
|
|
|
Crée une entité avec les composants donnés en paramètres.
|
|
|
|
|
|
|
|
Paramètres:
|
|
|
|
*components: Les composants de l'entité.
|
|
|
|
|
|
|
|
Retourne:
|
|
|
|
L'entité crée.
|
|
|
|
"""
|
2023-10-22 20:19:43 +00:00
|
|
|
return Entity(self, *components)
|
|
|
|
|
2023-10-23 10:14:28 +00:00
|
|
|
def remove_entity(self, entity: "Entity"):
|
2023-10-22 21:11:44 +00:00
|
|
|
"""
|
|
|
|
Supprime une entité du monde.
|
|
|
|
|
|
|
|
Paramètres:
|
|
|
|
entity: L'entité a supprimer.
|
|
|
|
"""
|
2023-10-22 20:19:43 +00:00
|
|
|
entity._deleted = True
|
2023-10-22 20:22:17 +00:00
|
|
|
self._to_apply.add(entity)
|
2023-10-23 10:14:28 +00:00
|
|
|
|
2023-10-22 20:49:58 +00:00
|
|
|
def set(self, *resources):
|
2023-10-22 21:11:44 +00:00
|
|
|
"""
|
|
|
|
Définit les ressources données en paramètres.
|
|
|
|
Si les ressources existent deja, elles seront remplacées.
|
|
|
|
|
|
|
|
Paramètres:
|
|
|
|
*resources: Les ressources a definir.
|
|
|
|
"""
|
2023-10-22 20:49:58 +00:00
|
|
|
for resource in resources:
|
|
|
|
self._to_apply_resources.append((type(resource), resource))
|
2023-10-23 10:14:28 +00:00
|
|
|
|
2023-10-22 20:49:58 +00:00
|
|
|
def remove(self, *resource_types):
|
2023-10-22 21:11:44 +00:00
|
|
|
"""
|
|
|
|
Supprime les ressources données en paramètres.
|
|
|
|
|
|
|
|
Paramètres:
|
|
|
|
*resource_types: Les types des ressources à supprimer.
|
|
|
|
"""
|
2023-10-22 20:49:58 +00:00
|
|
|
for resource_type in resource_types:
|
|
|
|
if resource_type in self._resources:
|
|
|
|
self._to_apply_resources.append((resource_type, None))
|
2023-10-22 17:26:06 +00:00
|
|
|
|
2023-10-22 20:19:43 +00:00
|
|
|
def apply(self):
|
2023-10-22 21:11:44 +00:00
|
|
|
"""
|
|
|
|
Applique les changements réaliser dans le monde.
|
|
|
|
"""
|
2023-10-22 20:22:17 +00:00
|
|
|
for entity in self._to_apply:
|
2023-10-22 20:19:43 +00:00
|
|
|
if entity._deleted:
|
2023-10-22 20:22:17 +00:00
|
|
|
self._entities.remove(entity)
|
2023-10-22 20:19:43 +00:00
|
|
|
for component_type in entity._components:
|
2023-10-22 20:22:17 +00:00
|
|
|
self._mapping[component_type].remove(entity)
|
2023-10-22 20:19:43 +00:00
|
|
|
else:
|
2023-10-22 20:22:17 +00:00
|
|
|
self._entities.add(entity)
|
2023-10-22 20:19:43 +00:00
|
|
|
for component_type, component in entity._to_apply:
|
|
|
|
if component is None:
|
|
|
|
del entity._components[component_type]
|
2023-10-22 20:22:17 +00:00
|
|
|
self._mapping[component_type].remove(entity)
|
2023-10-22 20:19:43 +00:00
|
|
|
else:
|
|
|
|
entity._components[component_type] = component
|
2023-10-22 20:22:17 +00:00
|
|
|
self._mapping.setdefault(component_type, set()).add(entity)
|
2023-10-22 20:19:43 +00:00
|
|
|
entity._to_apply.clear()
|
2023-10-22 20:49:58 +00:00
|
|
|
self._to_apply.clear()
|
|
|
|
for resource_type, resource in self._to_apply_resources:
|
2023-10-23 10:14:28 +00:00
|
|
|
if resource is None:
|
|
|
|
del self._resources[resource_type]
|
|
|
|
else:
|
|
|
|
self._resources[resource_type] = resource
|
2023-10-22 20:49:58 +00:00
|
|
|
self._to_apply_resources.clear()
|
2023-10-23 10:14:28 +00:00
|
|
|
|
|
|
|
def query(self, *needed: type, without: tuple[type] = []) -> Iterator["Entity"]:
|
2023-10-22 21:11:44 +00:00
|
|
|
"""
|
|
|
|
Renvoie les entités qui ont les composants de *needed et sans les composants de *without.
|
2023-10-23 10:14:28 +00:00
|
|
|
|
2023-10-22 21:11:44 +00:00
|
|
|
Paramètres:
|
|
|
|
*needed: Le type de composants que les entités doivent avoir.
|
|
|
|
*without: Les type de composants que les entités ne doivent pas avoir.
|
|
|
|
|
|
|
|
Retourne:
|
|
|
|
Les entités qui ont les composants de *needed et sans les composants de *without.
|
|
|
|
Si *needed est vide, on retourne toutes les entités qui ont les composants de *without.
|
|
|
|
"""
|
2023-10-22 17:26:06 +00:00
|
|
|
if not needed:
|
2023-10-22 20:22:17 +00:00
|
|
|
for entity in self._entities:
|
2023-10-22 20:19:43 +00:00
|
|
|
if all(without_type not in entity for without_type in without):
|
2023-10-22 17:26:06 +00:00
|
|
|
yield entity
|
|
|
|
else:
|
2023-10-22 20:22:17 +00:00
|
|
|
for entity in self._mapping.get(needed[0], set()):
|
2023-10-23 10:14:28 +00:00
|
|
|
if all(
|
|
|
|
entity in self._mapping.get(component_type, set())
|
|
|
|
for component_type in needed[1:]
|
|
|
|
) and all(without_type not in entity for without_type in without):
|
2023-10-22 20:19:43 +00:00
|
|
|
yield entity
|
2023-10-23 10:14:28 +00:00
|
|
|
|
2023-10-22 20:49:58 +00:00
|
|
|
def __getitem__(self, resource_type: type) -> object:
|
2023-10-22 21:11:44 +00:00
|
|
|
"""
|
|
|
|
Renvoie la ressource de type *resource_type.
|
|
|
|
|
|
|
|
Paramètres:
|
|
|
|
resource_type: Le type de ressource à récupérer.
|
|
|
|
|
|
|
|
Retourne:
|
|
|
|
La ressource de type *resource_type.
|
|
|
|
"""
|
2023-10-22 20:49:58 +00:00
|
|
|
return self._resources[resource_type]
|
2023-10-23 10:14:28 +00:00
|
|
|
|
2023-10-22 20:49:58 +00:00
|
|
|
def __contains__(self, resource_type: type) -> bool:
|
2023-10-22 21:11:44 +00:00
|
|
|
"""
|
|
|
|
Renvoie si la ressource de type *resource_type existe.
|
|
|
|
|
|
|
|
Paramètres:
|
|
|
|
resource_type: Le type de ressource à tester.
|
|
|
|
|
|
|
|
Retourne:
|
|
|
|
Si la ressource de type *resource_type existe.
|
|
|
|
"""
|
2023-10-22 20:49:58 +00:00
|
|
|
return resource_type in self._resources
|
2023-10-22 17:26:06 +00:00
|
|
|
|
2023-10-23 10:14:28 +00:00
|
|
|
|
2023-10-22 17:26:06 +00:00
|
|
|
class Entity:
|
2023-10-22 21:11:44 +00:00
|
|
|
"""
|
|
|
|
Une entité du monde.
|
|
|
|
"""
|
2023-10-23 10:14:28 +00:00
|
|
|
|
2023-10-22 20:19:43 +00:00
|
|
|
def __init__(self, world: World, *components):
|
2023-10-22 21:11:44 +00:00
|
|
|
"""
|
|
|
|
Créer une entité avec les composants en paramètres et l'ajoute au monde.
|
|
|
|
|
|
|
|
Paramètres:
|
|
|
|
world: Le monde auquel ajouter l'entité.
|
|
|
|
*components: Les composants de l'entité.
|
|
|
|
"""
|
2023-10-22 20:19:43 +00:00
|
|
|
self._world = world
|
2023-10-23 10:14:28 +00:00
|
|
|
self._to_apply: list[tuple[type, object]] = [
|
|
|
|
(type(component), component) for component in components
|
|
|
|
]
|
2023-10-22 20:19:43 +00:00
|
|
|
self._components: dict[type, object] = {}
|
|
|
|
self._deleted = False
|
2023-10-22 20:22:17 +00:00
|
|
|
self._world._to_apply.add(self)
|
2023-10-23 10:14:28 +00:00
|
|
|
|
2023-10-22 20:19:43 +00:00
|
|
|
def set(self, *components):
|
2023-10-22 21:11:44 +00:00
|
|
|
"""
|
|
|
|
Définit les composants de l'entité donnés en paramètres.
|
|
|
|
|
|
|
|
Paramètres:
|
|
|
|
*components: Les composants a definir.
|
|
|
|
"""
|
2023-10-22 20:19:43 +00:00
|
|
|
for component in components:
|
|
|
|
self._to_apply.append((type(component), component))
|
2023-10-22 20:22:17 +00:00
|
|
|
self._world._to_apply.add(self)
|
2023-10-23 10:14:28 +00:00
|
|
|
|
2023-10-22 20:19:43 +00:00
|
|
|
def remove(self, *component_types: type):
|
2023-10-22 21:11:44 +00:00
|
|
|
"""
|
|
|
|
Supprime les composants de l'entité donnés en paramètres.
|
|
|
|
|
|
|
|
Paramètres:
|
|
|
|
*component_types: Le type des composants à supprimer.
|
|
|
|
"""
|
2023-10-22 20:19:43 +00:00
|
|
|
for component_type in component_types:
|
|
|
|
if component_type in self._components:
|
|
|
|
self._to_apply.append((component_type, None))
|
2023-10-22 20:22:17 +00:00
|
|
|
self._world._to_apply.add(self)
|
2023-10-23 10:14:28 +00:00
|
|
|
|
2023-10-22 20:19:43 +00:00
|
|
|
def __getitem__(self, component_type: type) -> object:
|
2023-10-22 21:11:44 +00:00
|
|
|
"""
|
|
|
|
Renvoie le composant de type *component_type.
|
|
|
|
|
|
|
|
Paramètres:
|
|
|
|
component_type: Le type du composant à récupérer.
|
|
|
|
|
|
|
|
Retourne:
|
|
|
|
Le composant de type *component_type.
|
|
|
|
"""
|
2023-10-22 20:19:43 +00:00
|
|
|
return self._components[component_type]
|
|
|
|
|
|
|
|
def __contains__(self, component_type: type) -> bool:
|
2023-10-22 21:11:44 +00:00
|
|
|
"""
|
|
|
|
Renvoie si le composant de type *component_type existe.
|
|
|
|
|
|
|
|
Paramètres:
|
|
|
|
component_type: Le type du composant à tester.
|
|
|
|
|
|
|
|
Retourne:
|
|
|
|
Si le composant de type *component_type existe.
|
|
|
|
"""
|
2023-10-23 10:14:28 +00:00
|
|
|
return component_type in self._components
|
2023-10-23 11:15:50 +00:00
|
|
|
|
|
|
|
|
|
|
|
class Game:
|
|
|
|
"""
|
|
|
|
Permet de faire une simple boucle de jeu.
|
|
|
|
"""
|
|
|
|
|
|
|
|
def __init__(self):
|
|
|
|
"""
|
|
|
|
Créer une un jeu.
|
|
|
|
"""
|
|
|
|
self._running = False
|
|
|
|
self._startup_tasks: dict[int, list[Callable[[World], None]]] = {}
|
|
|
|
self._update_tasks: dict[int, list[Callable[[World], None]]] = {}
|
|
|
|
self._shutdown_tasks: dict[int, list[Callable[[World], None]]] = {}
|
|
|
|
|
|
|
|
def add_startup_tasks(self, priority: int, *tasks: Callable[[World], None]):
|
|
|
|
"""
|
|
|
|
Ajoute des taches qui s'executeront au démarrage du jeu.
|
|
|
|
|
|
|
|
Paramètres:
|
|
|
|
priority: La priorité de la tache.
|
|
|
|
*tasks: Les taches à ajouter.
|
|
|
|
"""
|
|
|
|
if self._running:
|
|
|
|
raise RuntimeError("Cannot add startup task while the loop is running")
|
|
|
|
self._startup_tasks.setdefault(priority, []).extend(tasks)
|
|
|
|
|
|
|
|
def add_tasks(self, priority: int, *tasks: Callable[[World], None]):
|
|
|
|
"""
|
|
|
|
Ajoute des taches qui s'executeront a chaque mise à jour du jeu.
|
|
|
|
|
|
|
|
Paramètres:
|
|
|
|
priority: La priorité de la tache.
|
|
|
|
*tasks: Les taches à ajouter.
|
|
|
|
"""
|
|
|
|
if self._running:
|
|
|
|
raise RuntimeError("Cannot add task while the loop is running")
|
|
|
|
self._update_tasks.setdefault(priority, []).extend(tasks)
|
|
|
|
|
|
|
|
def add_shutdown_tasks(self, priority: int, *tasks: Callable[[World], None]):
|
|
|
|
"""
|
|
|
|
Ajoute des taches qui s'executeront à la fin de la boucle de jeu.
|
|
|
|
|
|
|
|
Paramètres:
|
|
|
|
priority: La priorité de la tache.
|
|
|
|
*tasks: Les taches à ajouter.
|
|
|
|
"""
|
|
|
|
if self._running:
|
|
|
|
raise RuntimeError("Cannot add shutdown task while the loop is running")
|
|
|
|
self._shutdown_tasks.setdefault(priority, []).extend(tasks)
|
|
|
|
|
|
|
|
def _run_tasks(self, tasks: dict[int, list[Callable[[World], None]]], world: World):
|
|
|
|
"""
|
|
|
|
Execute toutes les taches donnes en paramètres en respectant la priorité.
|
|
|
|
"""
|
|
|
|
priorities = sorted(list(tasks.keys()))
|
|
|
|
for priority in priorities:
|
|
|
|
for task in tasks[priority]:
|
|
|
|
try:
|
|
|
|
task(world)
|
|
|
|
except Exception as e:
|
|
|
|
error(f"Error in task: {e}")
|
|
|
|
|
|
|
|
def run(self) -> World:
|
|
|
|
"""
|
|
|
|
Lance la boucle de jeu.
|
|
|
|
"""
|
|
|
|
if self._running:
|
|
|
|
raise RuntimeError("The loop is already running")
|
|
|
|
self._running = True
|
|
|
|
|
|
|
|
# On initialize le monde
|
|
|
|
world = World()
|
|
|
|
world.set(self)
|
|
|
|
world.apply()
|
|
|
|
self._run_tasks(self._startup_tasks, world)
|
|
|
|
|
|
|
|
while self._running:
|
|
|
|
# On exécute les taches de mise a jour du monde
|
|
|
|
self._run_tasks(self._update_tasks, world)
|
|
|
|
|
|
|
|
# On applique les changements
|
|
|
|
world.apply()
|
|
|
|
|
|
|
|
# On exécute les taches de fin du monde
|
|
|
|
self._run_tasks(self._shutdown_tasks, world)
|
|
|
|
|
|
|
|
# On applique les changements
|
|
|
|
world.apply()
|
|
|
|
|
|
|
|
# On retourne le monde
|
|
|
|
return world
|
|
|
|
|
|
|
|
def stop(self):
|
|
|
|
"""
|
|
|
|
Demande la fin de la boucle de jeu. La boucle s'arretera a la prochaine mise à jour.
|
|
|
|
"""
|
|
|
|
self._running = False
|