omniecs 0.2.0__tar.gz

omniecs-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Legus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

omniecs-0.2.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: omniecs
+Version: 0.2.0
+Summary: A lightweight, modular, and extensible Entity-Component-System framework.
+Author-email: Matheus Brenner Lehmann <legus.codes@gmail.com>
+License: MIT
+Requires-Python: >=3.9
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Dynamic: license-file

omniecs-0.2.0/README.md

@@ -0,0 +1,2 @@
+# OmniECS
+OmniECS is a lightweight, modular, and extensible Entity-Component-System framework implemented in Python for game development, designed to separate logic, data, and rendering.

omniecs-0.2.0/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["setuptools>=61.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "omniecs"
+version = "0.2.0"
+description = "A lightweight, modular, and extensible Entity-Component-System framework."
+authors = [{ name = "Matheus Brenner Lehmann", email = "legus.codes@gmail.com" }]
+license = { text = "MIT" }
+requires-python = ">=3.9"
+dependencies = []
+
+[project.optional-dependencies]
+test = ["pytest>=7.0", "pytest-cov"]

omniecs-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

omniecs-0.2.0/src/omniecs/components.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+
+from omniecs.types import Component
+
+
+@dataclass
+class Spawned(Component): ...

omniecs-0.2.0/src/omniecs/managers.py

@@ -0,0 +1,187 @@
+from collections import defaultdict
+from itertools import chain, count
+from typing import Iterable
+
+from omniecs.system import System
+from omniecs.types import R, Component, Cs, DrawCommand, EntityId, Event, ExecutionStage, Resource
+
+
+class EntityManager:
+
+    def __init__(self):
+        self._next_entity_id = count()
+        self._entities: set[EntityId] = set()
+
+    def create(self) -> EntityId:
+        entity_id = EntityId(next(self._next_entity_id))
+        self._entities.add(entity_id)
+        return entity_id
+    
+    def destroy(self, entity_id: EntityId) -> None:
+        self._entities.discard(entity_id)
+
+    def exists(self, entity_id: EntityId) -> bool:
+        return entity_id in self._entities
+
+
+class ComponentStorage[C: Component]:
+
+    def __init__(self):
+        self._components: dict[EntityId, C] = {}
+
+    def add(self, entity_id: EntityId, component: C) -> None:
+        self._components[entity_id] = component
+
+    def remove(self, entity_id: EntityId) -> None:
+        self._components.pop(entity_id, None)
+
+    def get(self, entity_id: EntityId) -> C | None:
+        return self._components.get(entity_id, None)
+
+    def has(self, entity_id: EntityId) -> bool:
+        return entity_id in self._components
+
+    def entities(self) -> set[EntityId]:
+        return set(self._components.keys())
+
+
+class ComponentManager:
+
+    def __init__(self):
+        self._component_storage: dict[type[Component], ComponentStorage[Component]] = defaultdict(ComponentStorage)
+        self._temporary_components: set[type[Component]] = set()
+
+    def add(self, entity_id: EntityId, component: Component) -> None:
+        self._component_storage[type(component)].add(entity_id, component)
+
+    def remove(self, entity_id: EntityId, component_type: type[Component]) -> None:
+        self._component_storage.get(component_type, ComponentStorage()).remove(entity_id)
+
+    def remove_all(self, component_type: type[Component]) -> None:
+        self._component_storage.pop(component_type, None)
+
+    def destroy(self, entity_id: EntityId) -> None:
+        for storage in self._component_storage.values():
+            storage.remove(entity_id)
+
+    def has(self, entity_id: EntityId, component_type: type[Component]) -> bool:
+        return component_type in self._component_storage and self._component_storage[component_type].has(entity_id)
+    
+    def get(self, entity_id: EntityId, component_type: type[Component]) -> Component | None:
+        return self._component_storage[component_type].get(entity_id)
+
+    def query_entities(self,
+                       all_of: tuple[type[Component], ...] = (),
+                       any_of: tuple[type[Component], ...] = (),
+                       none_of: tuple[type[Component], ...] = ()
+     ) -> set[EntityId]:
+        if len(self._component_storage) == 0:
+            return set()
+
+        entities = set.union(*(storage.entities() for storage in self._component_storage.values()))
+
+        if all_of:
+            for component in all_of:
+                entities.intersection_update(self._component_storage[component].entities())
+            if not entities:
+                return entities
+
+        if any_of:
+            candidates = set.union(*(self._component_storage[c].entities() for c in any_of))
+            entities.intersection_update(candidates)
+            if not entities:
+                return entities
+
+        if none_of:
+            candidates = set.union(*(self._component_storage[c].entities() for c in none_of))
+            entities.difference_update(candidates)
+
+        return entities
+
+    def query(self,
+              *component_types: *Cs,
+              all_of: tuple[type[Component], ...] = (),
+              any_of: tuple[type[Component], ...] = (),
+              none_of: tuple[type[Component], ...] = ()
+     ) -> Iterable[tuple[EntityId, tuple[*Cs]]]:
+        entities = self.query_entities(all_of + component_types, any_of, none_of)
+
+        for entity in entities:
+            components = tuple(self._component_storage[c].get(entity) for c in component_types)
+            yield entity, components
+
+    def register_temporary_component(self, component_type: type[Component]) -> None:
+        self._temporary_components.add(component_type)
+
+    def get_temporary_components(self) -> set[type[Component]]:
+        return self._temporary_components
+
+
+class SystemManager:
+
+    def __init__(self):
+        self._systems: dict[ExecutionStage, list[System]] = defaultdict(list)
+   
+    @property
+    def all_systems(self) -> Iterable[System]:
+        return chain(*self._systems.values())
+
+    def add(self, system: System, stage: ExecutionStage) -> None:
+        if any(isinstance(s, type(system)) for s in self.all_systems):
+            raise ValueError(f'System {type(system).__name__} already registered')
+        self._systems[stage].append(system)
+
+    def remove(self, system_type: type[System]) -> None:
+        for stage, systems in self._systems.items():
+            self._systems[stage] = [system for system in systems if not isinstance(system, system_type)]
+
+    def execute(self, delta_time: float) -> None:
+        for stage in ExecutionStage:
+            for system in self._systems[stage]:
+                system.execute(delta_time)
+
+
+class ResourceManager:
+
+    def __init__(self):
+        self._resources: dict[type[Resource], Resource] = {}
+   
+    def set(self, resource: Resource) -> None:
+        self._resources[type(resource)] = resource
+
+    def get(self, resource_type: type[R]) -> R | None:
+        return self._resources.get(resource_type, None)
+
+    def remove(self, resource_type: type[Resource]) -> None:
+        self._resources.pop(resource_type, None)
+
+
+class EventManager:
+
+    def __init__(self):
+        self._events: list[Event] = []
+
+    def push(self, event: Event) -> None:
+        self._events.append(event)
+
+    def get(self) -> list[Event]:
+        return self._events
+    
+    def clear(self) -> None:
+        self._events.clear()
+
+
+
+class RenderManager:
+
+    def __init__(self):
+        self._queue: list[DrawCommand] = []
+
+    def push(self, command: DrawCommand) -> None:
+        self._queue.append(command)
+
+    def get(self) -> list[DrawCommand]:
+        return sorted(self._queue, key=lambda c: (c.global_layer, c.local_layer))
+    
+    def clear(self) -> None:
+        self._queue.clear()

omniecs-0.2.0/src/omniecs/system.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from omniecs.world import World
+
+
+class System:
+
+    def __init__(self):
+        self.world: World | None = None
+
+    def register(self, world: World) -> None:
+        self.world = world
+        self.on_register()
+
+    def on_register(self) -> None: ...
+
+    def execute(self, delta_time: float) -> None: ...
+        
+
+class ClearEventSystem(System):
+
+    def execute(self, _: float) -> None:
+        self.world.clear_events()
+
+        
+class ClearRenderQueueSystem(System):
+
+    def execute(self, _: float) -> None:
+        self.world.clear_draw_commands()
+
+
+class ClearTemporaryComponentSystem(System):
+
+    def execute(self, _: float) -> None:
+        for component_type in self.world.get_temporary_components():
+            self.world.remove_all(component_type)

omniecs-0.2.0/src/omniecs/types.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Iterable, Protocol, TypeVar, TypeVarTuple
+
+
+@dataclass(slots=True, frozen=True)
+class EntityId:
+    value: int
+
+
+class Component: ...
+
+
+class Bundle(Protocol):
+    def components(self) -> Iterable[Component]: ...
+
+    
+class ExecutionStage(Enum):
+    reset = 0
+    update = 1
+    cleanup = 2
+
+
+class Resource: ...
+
+
+class Event: ...
+
+
+@dataclass(kw_only=True)
+class DrawCommand:
+    global_layer: int
+    local_layer: int = 0
+
+
+R = TypeVar("R", bound=Resource)
+Cs = TypeVarTuple("Cs")

omniecs-0.2.0/src/omniecs/world.py

@@ -0,0 +1,141 @@
+from typing import Iterable
+
+from omniecs.components import Spawned
+from omniecs.managers import ComponentManager, EntityManager, EventManager, RenderManager, ResourceManager, SystemManager
+from omniecs.system import ClearEventSystem, ClearRenderQueueSystem, ClearTemporaryComponentSystem, System
+from omniecs.types import R, Component, Cs, DrawCommand, EntityId, Event, ExecutionStage, Resource
+
+
+class World:
+
+    def __init__(self,
+                 entity_manager: EntityManager,
+                 component_manager: ComponentManager,
+                 system_manager: SystemManager,
+                 resource_manager: ResourceManager,
+                 event_manager: EventManager,
+                 render_manager: RenderManager):
+        self._entities = entity_manager
+        self._components = component_manager
+        self._systems = system_manager
+        self._resources = resource_manager
+        self._events = event_manager
+        self._render = render_manager
+        self._running = True
+
+    def quit(self) -> None:
+        self._running = False
+
+    @property
+    def is_running(self) -> bool:
+        return self._running
+
+    def spawn(self, *components: Component) -> EntityId:
+        entity_id = self._entities.create()
+        for component in components:
+            self.add_component(entity_id, component)
+        self.add_component(entity_id, Spawned())
+        return entity_id
+
+    def destroy(self, entity_id: EntityId) -> None:
+        self._components.destroy(entity_id)
+        self._entities.destroy(entity_id)
+
+    def exists(self, entity_id: EntityId) -> bool:
+        return self._entities.exists(entity_id)
+
+    def add_component(self, entity_id: EntityId, component: Component) -> None:
+        self._components.add(entity_id, component)
+
+    def add_components(self, entity_id: EntityId, components: list[Component]) -> None:
+        for component in components:
+            self.add_component(entity_id, component)
+
+    def remove_component(self, entity_id: EntityId, component_type: type[Component]) -> None:
+        self._components.remove(entity_id, component_type)
+
+    def get_component(self, entity_id: EntityId, component_type: type[Component]) -> Component | None:
+        return self._components.get(entity_id, component_type)
+
+    def remove_all(self, component_type: type[Component]) -> None:
+        self._components.remove_all(component_type)
+
+    def query_entities(self,
+                       all_of: tuple[type[Component], ...] = (),
+                       any_of: tuple[type[Component], ...] = (),
+                       none_of: tuple[type[Component], ...] = ()
+     ) -> set[EntityId]:
+        return self._components.query_entities(all_of, any_of, none_of)
+
+
+    def query(self,
+              *component_types: *Cs,
+              all_of: tuple[type[Component], ...] = (),
+              any_of: tuple[type[Component], ...] = (),
+              none_of: tuple[type[Component], ...] = ()
+     ) -> Iterable[tuple[EntityId, tuple[*Cs]]]:
+        yield from self._components.query(*component_types, all_of=all_of, any_of=any_of, none_of=none_of)
+
+    def register_temporary_component(self, component_type: type[Component]) -> None:
+        self._components.register_temporary_component(component_type)
+
+    def get_temporary_components(self) -> set[type[Component]]:
+        return self._components.get_temporary_components()
+    
+    def register_system(self, system: System, stage: ExecutionStage=ExecutionStage.update) -> None:
+        system.register(self)
+        self._systems.add(system, stage)
+    
+    def unregister_system(self, system_type: type[System]) -> None:
+        self._systems.remove(system_type)
+
+    def execute(self, delta_time: float = 0) -> None:
+        self._systems.execute(delta_time)
+
+    def set_resource(self, resource: Resource) -> None:
+        self._resources.set(resource)
+
+    def get_resource(self, resource: type[R]) -> R:
+        return self._resources.get(resource)
+
+    def push_event(self, event: Event) -> None:
+        self._events.push(event)
+
+    def get_events(self) -> list[Event]:
+        return self._events.get()
+    
+    def clear_events(self) -> None:
+        self._events.clear()
+
+    def add_draw_command(self, draw_command: DrawCommand) -> None:
+        self._render.push(draw_command)
+
+    def get_draw_commands(self ) -> list[DrawCommand]:
+        return self._render.get()
+    
+    def clear_draw_commands(self) -> None:
+        self._render.clear()
+
+
+class WorldFactory:
+
+    @staticmethod
+    def create_world() -> World:
+        world = WorldFactory.create_empty_world()        
+        world.register_system(ClearRenderQueueSystem(), ExecutionStage.reset)
+        world.register_system(ClearEventSystem(), ExecutionStage.cleanup)
+        world.register_system(ClearTemporaryComponentSystem(), ExecutionStage.cleanup)
+        world.register_temporary_component(Spawned)
+        
+        return world
+
+    @staticmethod
+    def create_empty_world() -> World:
+        entity_manager = EntityManager()
+        component_manager = ComponentManager()
+        system_manager = SystemManager()
+        resource_manager = ResourceManager()
+        event_manager = EventManager()
+        render_manager = RenderManager()
+
+        return World(entity_manager, component_manager, system_manager, resource_manager, event_manager, render_manager)

omniecs-0.2.0/src/omniecs.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: omniecs
+Version: 0.2.0
+Summary: A lightweight, modular, and extensible Entity-Component-System framework.
+Author-email: Matheus Brenner Lehmann <legus.codes@gmail.com>
+License: MIT
+Requires-Python: >=3.9
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Dynamic: license-file

omniecs-0.2.0/src/omniecs.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+README.md
+pyproject.toml
+src/omniecs/__init__.py
+src/omniecs/components.py
+src/omniecs/managers.py
+src/omniecs/system.py
+src/omniecs/types.py
+src/omniecs/world.py
+src/omniecs.egg-info/PKG-INFO
+src/omniecs.egg-info/SOURCES.txt
+src/omniecs.egg-info/dependency_links.txt
+src/omniecs.egg-info/requires.txt
+src/omniecs.egg-info/top_level.txt
+tests/test_component_manager.py
+tests/test_entity_manager.py
+tests/test_event_manager.py
+tests/test_render_manager.py
+tests/test_resource_manager.py
+tests/test_system.py
+tests/test_system_manager.py
+tests/test_world.py

omniecs-0.2.0/src/omniecs.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

omniecs-0.2.0/src/omniecs.egg-info/requires.txt

@@ -0,0 +1,4 @@
+
+[test]
+pytest>=7.0
+pytest-cov

omniecs-0.2.0/src/omniecs.egg-info/top_level.txt

@@ -0,0 +1 @@
+omniecs

omniecs-0.2.0/tests/test_component_manager.py

@@ -0,0 +1,189 @@
+from omniecs.managers import ComponentManager, ComponentStorage
+from omniecs.types import Component, EntityId
+
+
+class MockComponent(Component): ...
+
+class MockComponentA(Component): ...
+class MockComponentB(Component): ...
+class MockComponentC(Component): ...
+class MockComponentD(Component): ...
+class MockComponentE(Component): ...
+
+
+def test_add_component_storage():
+    component_storage = ComponentStorage[MockComponent]()
+    entity_id = EntityId(1)
+    component = MockComponent()
+    component_storage.add(entity_id, component)
+
+    assert component_storage.has(entity_id)
+    assert component_storage.get(entity_id) == component
+
+def test_remove_component_storage():
+    component_storage = ComponentStorage[MockComponent]()
+    entity_id = EntityId(1)
+    component = MockComponent()
+    component_storage.add(entity_id, component)
+    component_storage.remove(entity_id)
+
+    assert not component_storage.has(entity_id)
+    assert component_storage.get(entity_id) is None
+
+def test_remove_non_existing_entity():
+    component_storage = ComponentStorage[MockComponent]()
+    entity_id = EntityId(1)
+    component_storage.remove(entity_id)
+
+    assert not component_storage.has(entity_id)
+    assert component_storage.get(entity_id) is None
+
+def test_component_storage_entities():
+    component_storage = ComponentStorage[MockComponent]()
+    entity_ids = set([EntityId(1), EntityId(2), EntityId(3), EntityId(4)])
+    component = MockComponent()
+    for entity_id in entity_ids:
+        component_storage.add(entity_id, component)
+
+    assert component_storage.entities() == entity_ids
+
+def test_add_component_manager():
+    component_manager = ComponentManager()
+    entity_id = EntityId(1)
+    component_manager.add(entity_id, MockComponentA())
+
+    assert component_manager.has(entity_id, MockComponentA)
+
+def test_add_multiple_components_component_manager():
+    component_manager = ComponentManager()
+    entity_id = EntityId(1)
+    component_manager.add(entity_id, MockComponentA())
+    component_manager.add(entity_id, MockComponentB())
+    component_manager.add(entity_id, MockComponentC())
+    component_manager.add(entity_id, MockComponentD())
+
+    assert component_manager.has(entity_id, MockComponentA)
+    assert component_manager.has(entity_id, MockComponentB)
+    assert component_manager.has(entity_id, MockComponentC)
+    assert component_manager.has(entity_id, MockComponentD)
+
+def test_remove_component_manager():
+    component_manager = ComponentManager()
+    entity_id = EntityId(1)
+    component_manager.add(entity_id, MockComponentA())
+    component_manager.remove(entity_id, MockComponentA)
+
+    assert not component_manager.has(entity_id, MockComponentA)
+
+def test_destroy_component_manager():
+    component_manager = ComponentManager()
+    entity_id = EntityId(1)
+    component_manager.add(entity_id, MockComponentA())
+    component_manager.add(entity_id, MockComponentB())
+    component_manager.add(entity_id, MockComponentC())
+    component_manager.add(entity_id, MockComponentD())
+    component_manager.destroy(entity_id)
+
+    assert not component_manager.has(entity_id, MockComponentA)
+    assert not component_manager.has(entity_id, MockComponentB)
+    assert not component_manager.has(entity_id, MockComponentC)
+    assert not component_manager.has(entity_id, MockComponentD)
+
+def test_query_all_of_entities_component_manager():
+    component_manager = ComponentManager()
+    entity_id1 = EntityId(1)
+    entity_id2 = EntityId(2)
+    entity_id3 = EntityId(3)
+    entity_id4 = EntityId(4)
+    entity_id5 = EntityId(5)
+    component_manager.add(entity_id1, MockComponentA())
+    component_manager.add(entity_id2, MockComponentB())
+    component_manager.add(entity_id3, MockComponentC())
+    component_manager.add(entity_id4, MockComponentD())
+    component_manager.add(entity_id5, MockComponentE())
+    component_manager.add(entity_id2, MockComponentE())
+    
+    entities = component_manager.query_entities(all_of=(MockComponentB, MockComponentE))
+    assert entities == set([entity_id2])
+
+def test_query_any_of_entities_component_manager():
+    component_manager = ComponentManager()
+    entity_id1 = EntityId(1)
+    entity_id2 = EntityId(2)
+    entity_id3 = EntityId(3)
+    entity_id4 = EntityId(4)
+    entity_id5 = EntityId(5)
+    component_manager.add(entity_id1, MockComponentA())
+    component_manager.add(entity_id2, MockComponentB())
+    component_manager.add(entity_id3, MockComponentC())
+    component_manager.add(entity_id4, MockComponentD())
+    component_manager.add(entity_id5, MockComponentE())
+    component_manager.add(entity_id3, MockComponentA())
+    
+    entities = component_manager.query_entities(any_of=(MockComponentA, MockComponentD))
+    assert entities == set([entity_id1, entity_id3, entity_id4])
+
+def test_query_none_of_entities_component_manager():
+    component_manager = ComponentManager()
+    entity_id1 = EntityId(1)
+    entity_id2 = EntityId(2)
+    entity_id3 = EntityId(3)
+    entity_id4 = EntityId(4)
+    entity_id5 = EntityId(5)
+    component_manager.add(entity_id1, MockComponentA())
+    component_manager.add(entity_id2, MockComponentB())
+    component_manager.add(entity_id3, MockComponentC())
+    component_manager.add(entity_id4, MockComponentD())
+    component_manager.add(entity_id5, MockComponentE())
+    component_manager.add(entity_id1, MockComponentB())
+    
+    entities = component_manager.query_entities(none_of=(MockComponentB, MockComponentC))
+    assert entities == set([entity_id4, entity_id5])
+
+def test_query_entities_component_manager():
+    component_manager = ComponentManager()
+    entity_id1 = EntityId(1)
+    entity_id2 = EntityId(2)
+    entity_id3 = EntityId(3)
+    entity_id4 = EntityId(4)
+    entity_id5 = EntityId(5)
+    component_manager.add(entity_id1, MockComponentA())
+    component_manager.add(entity_id1, MockComponentB())
+    component_manager.add(entity_id1, MockComponentC())
+    component_manager.add(entity_id2, MockComponentB())
+    component_manager.add(entity_id2, MockComponentD())
+    component_manager.add(entity_id3, MockComponentC())
+    component_manager.add(entity_id3, MockComponentE())
+    component_manager.add(entity_id4, MockComponentB())
+    component_manager.add(entity_id4, MockComponentE())
+    component_manager.add(entity_id5, MockComponentA())
+    component_manager.add(entity_id5, MockComponentE())
+    
+    entities = component_manager.query_entities(all_of=(MockComponentB,), any_of=(MockComponentA, MockComponentD), none_of=(MockComponentE,))
+    assert entities == set([entity_id1, entity_id2])
+
+def test_query_component_manager():
+    component_manager = ComponentManager()
+    entity_id1 = EntityId(1)
+    entity_id2 = EntityId(2)
+    entity_id3 = EntityId(3)
+    entity_id4 = EntityId(4)
+    entity_id5 = EntityId(5)
+    component = MockComponentC()
+    component_manager.add(entity_id1, MockComponentA())
+    component_manager.add(entity_id1, MockComponentB())
+    component_manager.add(entity_id1, component)
+    component_manager.add(entity_id2, MockComponentB())
+    component_manager.add(entity_id2, MockComponentD())
+    component_manager.add(entity_id3, MockComponentC())
+    component_manager.add(entity_id3, MockComponentE())
+    component_manager.add(entity_id4, MockComponentB())
+    component_manager.add(entity_id4, MockComponentE())
+    component_manager.add(entity_id5, MockComponentA())
+    component_manager.add(entity_id5, MockComponentE())
+    
+    entities = list(component_manager.query(MockComponentC, all_of=(MockComponentB,), any_of=(MockComponentA, MockComponentD), none_of=(MockComponentE,)))
+    assert len(entities) == 1
+    entity, (queried_component,) = entities[0]
+    assert entity == entity_id1
+    assert queried_component == component

omniecs-0.2.0/tests/test_entity_manager.py

@@ -0,0 +1,30 @@
+from omniecs.managers import EntityManager
+from omniecs.types import EntityId
+
+
+def test_create_entity():
+    entity_manager = EntityManager()
+    entity = entity_manager.create()
+    assert entity_manager.exists(entity)
+    assert isinstance(entity, EntityId)
+
+
+def test_create_multiple_entities():
+    entity_manager = EntityManager()
+    entity1 = entity_manager.create()
+    entity2 = entity_manager.create()
+    assert entity1 != entity2
+
+
+def test_destroy_entity():
+    entity_manager = EntityManager()
+    entity = entity_manager.create()
+    entity_manager.destroy(entity)
+    assert not entity_manager.exists(entity)
+
+
+def test_destroy_non_existing_entity():
+    entity_manager = EntityManager()
+    entity = entity_manager.create()
+    entity_manager.destroy(EntityId(12))
+    assert entity_manager.exists(entity)

omniecs-0.2.0/tests/test_event_manager.py

@@ -0,0 +1,27 @@
+from omniecs.managers import EventManager
+from omniecs.types import Event
+
+
+def test_create_event():
+    event_manager = EventManager()
+    event_manager.push(Event())
+    assert len(event_manager._events) == 1
+
+    
+def test_get_events():
+    event_manager = EventManager()
+    event_manager.push(Event())
+    event_manager.push(Event())
+    event_manager.push(Event())
+    events = event_manager.get()
+    assert len(events) == 3
+    assert len(event_manager._events) == 3
+
+    
+def test_clear_events():
+    event_manager = EventManager()
+    event_manager.push(Event())
+    event_manager.push(Event())
+    event_manager.push(Event())
+    event_manager.clear()
+    assert len(event_manager._events) == 0

omniecs-0.2.0/tests/test_render_manager.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+
+from omniecs.managers import RenderManager
+from omniecs.types import DrawCommand
+
+
+
+@dataclass(kw_only=True)
+class MockDrawCommand(DrawCommand):
+    text: str
+
+
+def test_create_command():
+    render_manager = RenderManager()
+    render_manager.push(MockDrawCommand(global_layer=1, text=''))
+    assert len(render_manager._queue) == 1
+
+    
+def test_get_commands():
+    render_manager = RenderManager()
+    render_manager.push(MockDrawCommand(global_layer=3, text='third'))
+    render_manager.push(MockDrawCommand(global_layer=1, text='first'))
+    render_manager.push(MockDrawCommand(global_layer=2, text='second'))
+    commands = render_manager.get()
+    assert len(commands) == 3
+    assert commands[0].text == 'first'
+    assert commands[1].text == 'second'
+    assert commands[2].text == 'third'
+    assert len(render_manager._queue) == 3
+
+    
+def test_clear_commands():
+    render_manager = RenderManager()
+    render_manager.push(MockDrawCommand(global_layer=3, text='third'))
+    render_manager.push(MockDrawCommand(global_layer=1, text='first'))
+    render_manager.push(MockDrawCommand(global_layer=2, text='second'))
+    render_manager.clear()
+    assert len(render_manager._queue) == 0

omniecs-0.2.0/tests/test_resource_manager.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass
+
+from omniecs.managers import ResourceManager
+from omniecs.types import Resource
+
+
+class ResourceA(Resource): ...
+
+
+@dataclass
+class ResourceB(Resource):
+    value: str
+
+
+def test_set_resource():
+    resource_manager = ResourceManager()
+    resource_manager.set(ResourceA())
+    resource = resource_manager.get(ResourceA)
+    assert isinstance(resource, ResourceA)
+
+
+def test_overwrite_resource():
+    resource_manager = ResourceManager()
+    resource_manager.set(ResourceB('old'))
+    resource_manager.set(ResourceB('new'))
+    resource = resource_manager.get(ResourceB)
+    assert resource.value == 'new'
+
+
+def test_remove_resource():
+    resource_manager = ResourceManager()
+    resource_manager.set(ResourceA())
+    resource_manager.remove(ResourceA)
+    resource = resource_manager.get(ResourceA)
+    assert resource is None

omniecs-0.2.0/tests/test_system.py

@@ -0,0 +1,62 @@
+from dataclasses import dataclass
+from omniecs.system import ClearEventSystem, ClearRenderQueueSystem, ClearTemporaryComponentSystem, System
+from omniecs.types import Component, DrawCommand, Event
+from omniecs.world import WorldFactory
+
+
+class MockEvent(Event): ...
+class MockTemporaryComponent(Component): ...
+class MockDrawCommand(DrawCommand): ...
+
+class MockSystem(System):
+    def on_register(self):
+        self.world.register_temporary_component(MockTemporaryComponent)
+
+
+def test_system_on_register_temporary_component():
+    world = WorldFactory.create_world()
+    world.register_system(MockSystem())
+
+    world.spawn(MockTemporaryComponent())
+    world.spawn(MockTemporaryComponent())
+    world.spawn(MockTemporaryComponent())
+    assert len(list(world.query_entities(all_of=(MockTemporaryComponent,)))) == 3
+
+    world.execute(0)
+    assert len(list(world.query_entities(all_of=(MockTemporaryComponent,)))) == 0
+
+
+def test_clear_event_system():
+    world = WorldFactory.create_world()
+    assert any(isinstance(system, ClearEventSystem) for system in world._systems.all_systems)
+
+    world.push_event(MockEvent())
+    assert len(world.get_events()) == 1
+
+    world.execute(0)
+    assert len(world.get_events()) == 0
+
+
+def test_clear_render_queue_system():
+    world = WorldFactory.create_world()
+    assert any(isinstance(system, ClearRenderQueueSystem) for system in world._systems.all_systems)
+
+    world.add_draw_command(MockDrawCommand(global_layer=3))
+    assert len(world.get_draw_commands()) == 1
+
+    world.execute(0)
+    assert len(world.get_draw_commands()) == 0
+
+
+def test_clear_temporary_component_system():
+    world = WorldFactory.create_world()
+    assert any(isinstance(system, ClearTemporaryComponentSystem) for system in world._systems.all_systems)
+
+    world.spawn(MockTemporaryComponent())
+    world.spawn(MockTemporaryComponent())
+    world.spawn(MockTemporaryComponent())
+    world.register_temporary_component(MockTemporaryComponent)
+    assert len(list(world.query_entities(all_of=(MockTemporaryComponent,)))) == 3
+
+    world.execute(0)
+    assert len(list(world.query_entities(all_of=(MockTemporaryComponent,)))) == 0

omniecs-0.2.0/tests/test_system_manager.py

@@ -0,0 +1,61 @@
+import pytest
+from dataclasses import dataclass
+
+from omniecs.managers import SystemManager
+from omniecs.system import System
+from omniecs.types import ExecutionStage
+
+
+@dataclass
+class SystemA(System): 
+    executed: bool = False
+
+    def execute(self, delta_time):
+        self.executed = True
+
+@dataclass
+class SystemB(System):
+    executed: bool = False
+
+    def execute(self, delta_time):
+        self.executed = True
+
+@dataclass
+class SystemC(System):
+    executed: bool = False
+
+    def execute(self, delta_time):
+        self.executed = True
+
+
+@pytest.mark.parametrize('stage', [ExecutionStage.reset, ExecutionStage.update, ExecutionStage.cleanup])
+def test_add_system_frame_start(stage: ExecutionStage):
+    system_manager = SystemManager()
+    system_manager.add(SystemA(), stage)
+    system_manager.add(SystemB(), stage)
+    system_manager.add(SystemC(), stage)
+    assert len(system_manager._systems[stage]) == 3
+
+def test_add_system_of_same_type():
+    system_manager = SystemManager()
+    system_manager.add(SystemA(), ExecutionStage.update)
+    with pytest.raises(ValueError) as exception:
+        system_manager.add(SystemA(), ExecutionStage.cleanup)
+
+def test_execute_systems():
+    system_manager = SystemManager()
+    system_manager.add(SystemA(), ExecutionStage.reset)
+    system_manager.add(SystemB(), ExecutionStage.update)
+    system_manager.add(SystemC(), ExecutionStage.cleanup)
+    system_manager.execute(0)
+    for system in system_manager.all_systems:
+        assert system.executed
+
+def test_remove_system():
+    system_manager = SystemManager()
+    system_manager.add(SystemA(), ExecutionStage.reset)
+    system_manager.add(SystemB(), ExecutionStage.update)
+    system_manager.add(SystemC(), ExecutionStage.cleanup)
+    system_manager.remove(SystemA)
+    system_manager.remove(SystemB)
+    assert len(list(system_manager.all_systems)) == 1

omniecs-0.2.0/tests/test_world.py

@@ -0,0 +1,136 @@
+from omniecs.managers import ComponentManager, EntityManager, EventManager, RenderManager, ResourceManager, SystemManager
+from omniecs.system import System
+from omniecs.types import Component, DrawCommand, Event, Resource
+from omniecs.world import WorldFactory
+
+
+class MockComponentA(Component): ...
+class MockComponentB(Component): ...
+class MockComponentC(Component): ...
+
+class MockSystem(System):
+    executed: bool = False
+    def execute(self, delta_time: float) -> None:
+        self.executed = True
+
+class MockResource(Resource): ...
+
+class MockEvent(Event): ...
+
+class MockDrawCommand(DrawCommand): ...
+
+def test_world_has_all_managers():
+    world = WorldFactory.create_world()
+    assert isinstance(world._entities, EntityManager)
+    assert isinstance(world._components, ComponentManager)
+    assert isinstance(world._systems, SystemManager)
+    assert len(list(world._systems.all_systems)) == 3
+    assert isinstance(world._resources, ResourceManager)
+    assert isinstance(world._events, EventManager)
+    assert isinstance(world._render, RenderManager)
+
+def test_spawn_entity():
+    world = WorldFactory.create_world()
+    componentA = MockComponentA()
+    componentB = MockComponentB()
+    entity_id = world.spawn(componentA, componentB)
+
+    entities = list(world.query(MockComponentA, MockComponentB))
+    assert len(entities) == 1
+    entity, (compA, compB) = entities[0]
+    assert entity == entity_id
+    assert compA == componentA
+    assert compB == componentB
+
+def test_destroy_entity():
+    world = WorldFactory.create_world()
+    componentA = MockComponentA()
+    componentB = MockComponentB()
+    entity_id = world.spawn(componentA, componentB)
+    world.destroy(entity_id)
+
+    assert world.query_entities(any_of=(MockComponentA, MockComponentB)) == set()
+
+def test_add_component():
+    world = WorldFactory.create_world()
+    componentC = MockComponentC()
+    entity_id = world.spawn(MockComponentA(), MockComponentB())
+    world.add_component(entity_id, componentC)
+
+    entities = list(world.query(MockComponentC))
+    assert len(entities) == 1
+    entity, (compC,) = entities[0]
+    assert entity == entity_id
+    assert compC == componentC
+
+def test_remove_component():
+    world = WorldFactory.create_world()
+    entity_id = world.spawn(MockComponentA(), MockComponentB())
+    world.remove_component(entity_id, MockComponentA)
+
+    assert world.query_entities(all_of=(MockComponentA,)) == set()
+
+def test_register_temporary_component():
+    world = WorldFactory.create_world()
+    world.register_temporary_component(MockComponentA)
+    world.spawn(MockComponentA())
+    world.spawn(MockComponentA())
+    world.spawn(MockComponentA())
+    world.execute(0)
+
+    assert world.query_entities(all_of=(MockComponentA,)) == set()
+
+def test_execute_system():
+    world = WorldFactory.create_world()
+    system = MockSystem()
+    world.register_system(system)
+    assert not system.executed
+
+    world.execute(0)
+    assert system.executed
+
+def test_execute_unregistered_system():
+    world = WorldFactory.create_world()
+    system = MockSystem()
+    world.register_system(system)
+    assert not system.executed
+
+    world.unregister_system(MockSystem)
+    world.execute(0)
+    assert not system.executed
+
+def test_set_resource():
+    world = WorldFactory.create_world()
+    resource = MockResource()
+    world.set_resource(resource)
+
+    assert world.get_resource(MockResource) == resource
+
+def test_overwrite_resource():
+    world = WorldFactory.create_world()
+    resource = MockResource()
+    world.set_resource(MockResource())
+    world.set_resource(resource)
+
+    assert world.get_resource(MockResource) == resource
+
+def test_push_events():
+    world = WorldFactory.create_world()
+    event = MockEvent()
+    world.push_event(event)
+    world.push_event(event)
+    world.push_event(event)
+
+    assert world.get_events() == [event, event, event]
+    assert world.get_events() == [event, event, event]
+
+def test_add_draw_commands():
+    world = WorldFactory.create_world()
+    draw_command = MockDrawCommand(global_layer=1)
+    world.add_draw_command(draw_command)
+    world.add_draw_command(draw_command)
+    world.add_draw_command(draw_command)
+
+    assert world.get_draw_commands() == [draw_command, draw_command, draw_command]
+    assert world.get_draw_commands() == [draw_command, draw_command, draw_command]
+