omniecs 0.2.0__py3-none-any.whl

omniecs/components.py

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

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/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/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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,11 @@
+omniecs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omniecs/components.py,sha256=JcRU_V0XwMYPDXi_vAZjvliq14O1MdRlhpj_WW-vgeo,121
+omniecs/managers.py,sha256=JHs4eTk9LZSCxsL-Yy40t2Mx9KkFqB8sjpGbYvj04_I,6513
+omniecs/system.py,sha256=jkLAOqnnRyfn87nIUWPDqFdCkBiX5hoZCGgW_xXKUxM,897
+omniecs/types.py,sha256=iESX-i0OAc4W6BuOMJjCOWFA8lX_GyJMu7zCc8vkySQ,597
+omniecs/world.py,sha256=wa81geyiAz0PriaK9ZV0_vp2pYqFeGTfURCTJbTEMcw,5494
+omniecs-0.2.0.dist-info/licenses/LICENSE,sha256=Os0WYgx_nC5tqtt85RnEz52Fk0XCrJZehYTfPQaGSeo,1083
+omniecs-0.2.0.dist-info/METADATA,sha256=OINkOnb3JzKYGCCqPGcqRUtaloiR20OpDgAH4Cs9Rbw,396
+omniecs-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+omniecs-0.2.0.dist-info/top_level.txt,sha256=4-GuB6YmotfbiwLSjAVkDKsmjNvX2QiGt0_PcQt2Rpo,8
+omniecs-0.2.0.dist-info/RECORD,,

omniecs-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

omniecs-0.2.0.dist-info/licenses/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.dist-info/top_level.txt

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