tinyecs 0.3.5__tar.gz → 0.4.0__tar.gz

{tinyecs-0.3.5/src/tinyecs.egg-info → tinyecs-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinyecs
-Version: 0.3.5
+Version: 0.4.0
 Summary: The teeniest, tiniest ECS system
 Author-email: Michael Lamertz <michael.lamertz@gmail.com>
 License-Expression: MIT

{tinyecs-0.3.5 → tinyecs-0.4.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "tinyecs"
 description = "The teeniest, tiniest ECS system"
-version = "0.3.5"
+version = "0.4.0"
 readme = "README.rst"
 
 authors = [

{tinyecs-0.3.5 → tinyecs-0.4.0}/src/tinyecs/__init__.py

@@ -24,7 +24,7 @@ type DomainID = Hashable
 type Property = Hashable
 type Component = object
 
-type _EntityComponentsBundle = tuple[EntityID, list[Component]]
+type EntityComponentsBundle = tuple[EntityID, list[Component]]
 type _OptionalProperties = Iterable[Property] | None
 type _RunSystemResult = dict[EntityID, Any]
 
@@ -32,7 +32,7 @@ type _RunSystemResult = dict[EntityID, Any]
 # The typehinting system can't work with functions using *args, **kwargs.
 # This solution comes from https://docs.python.org/3/library/typing.html#annotating-callable-objects
 class SystemFunction(Protocol):
-    def __call__(self, dt: float, eid: EntityID, *cids: ComponentID, **kwargs: dict[str, object]) -> Any: ...
+    def __call__(self, eid: EntityID, *cids: ComponentID, **kwargs: dict[str, object]) -> Any: ...
 
 
 eidx = {}  # entity index
@@ -282,16 +282,16 @@ def remove_component(eid: EntityID, *cids: ComponentID) -> None:
                 obj.shutdown_()
 
 
-def add_system(fkt: SystemFunction, *cids: ComponentID) -> None:
+def add_system(fn: SystemFunction, *cids: ComponentID) -> None:
     r"""Add a system for the specifiied cids.
 
-    :param fkt: The system function
+    :param fn: The system function
     :param cids: The component ids that are required for this system
     :return: None
 
     The prototype for the function is::
 
-        fkt(delta_time, eid, *comps)
+        fn(delta_time, eid, *comps)
 
     where delta_time is e.g. the miliseconds from a pygame tick.  eid is the id
     of the entity that matches, and \*comps are all requested components for
@@ -304,13 +304,13 @@ def add_system(fkt: SystemFunction, *cids: ComponentID) -> None:
     """
 
     create_archetype(*cids)
-    sidx[fkt] = cids
+    sidx[fn] = cids
 
 
-def remove_system(fkt: SystemFunction) -> None:
+def remove_system(fn: SystemFunction) -> None:
     """Remove the given function from the registry.
 
-    :param fkt: The system function
+    :param fn: The system function
     :return: None
 
     Remove the match for this function from the registry
@@ -319,11 +319,11 @@ def remove_system(fkt: SystemFunction) -> None:
     """
 
     for domain in didx:
-        remove_system_from_domain(domain, fkt)
+        remove_system_from_domain(domain, fn)
 
     # Ignore unregistered systems, since we're removing anyways
     try:
-        del sidx[fkt]
+        del sidx[fn]
     except KeyError:
         pass
 
@@ -480,7 +480,7 @@ def comp_of_eid(eid: EntityID, cid: ComponentID) -> Component:
     return comps_of_eid(eid, cid)[0]
 
 
-def eid_of_comp(comp: Component) -> set(EntityID):
+def eid_of_comp(comp: Component) -> set[EntityID]:
     """Find the entity id for object comp.
 
     :param comp: The component to find the entity of
@@ -519,63 +519,94 @@ def cid_of_comp(eid: EntityID, comp: Component) -> ComponentID:
     raise UnknownComponentError(f'Component {comp} not found in entity {eid}')
 
 
-def run_system(dt: float,
-               fkt: SystemFunction,
+def _create_call_list(cids: tuple[ComponentID],
+                      has_properties: _OptionalProperties) -> list[tuple[EntityID, Component]]:
+    at = tuple(cids)
+    if at not in archetype:
+        create_archetype(*cids)
+
+    adict = archetype[at]
+    # need to get call_list upfront, since kill_system could modify the dict
+    # Also: not running in the if clause is vastly faster than checking an
+    # empty set.
+    if has_properties:
+        property_filter = set(has_properties)
+        call_list = [(eid, *parms) for eid, parms in adict.items()
+                     if property_filter <= plist[eid]]
+    else:
+        call_list = [(eid, *parms) for eid, parms in adict.items()]
+    return call_list
+
+
+def run_system(fn: SystemFunction,
                *cids: ComponentID,
                has_properties: _OptionalProperties = None,
                **kwargs: dict[str, Any]) -> _RunSystemResult:
     """Run the system for the matching cids.
 
-    :param dt: delta time since the last frame (miliseconds)
-    :param fkt: the actual system function
+    :param fn: the actual system function
     :param cids: the components to run on
     :param has_properties: set of required properties
     :return: A dictionary with entity IDs as key and the function result as value
 
-    The fkt gets the list of all entities that contain the listed
-    components.  The list can further be narrowed down my filtering for given
-    properties.  Then it runs the function for every entity and the requested
-    components, passing dt as heartbeat.
+    For every entity that has all the listed components, ``fn`` is run.  The
+    function prototype of ``fn`` is::
+
+        def callback(eid: EntityID, *comps: Component) -> Any
+
+    The list can further be narrowed down my filtering for given properties.
 
     This function is a direct call.  Alternatively, you can use add_system
     combined with run_all_systems or run_domain below.
     """
 
-    at = tuple(cids)
-    if at not in archetype:
-        create_archetype(*cids)
+    call_list = _create_call_list(cids, has_properties)
+    return {eid: fn(eid, *parms, **kwargs) for eid, *parms in call_list}
 
-    adict = archetype[at]
-    # need to get call_list upfront, since kill_system could modify the dict
-    # Also: not running in the if clause is vastly faster than checking an
-    # empty set.
-    if has_properties:
-        property_filter = set(has_properties)
-        call_list = [(eid, *parms) for eid, parms in adict.items()
-                     if property_filter <= plist[eid]]
-    else:
-        call_list = [(eid, *parms) for eid, parms in adict.items()]
-    return {eid: fkt(dt, eid, *parms, **kwargs) for eid, *parms in call_list}
 
+def run_bulk_system(fn: SystemFunction,
+                    *cids: ComponentID,
+                    has_properties: _OptionalProperties = None,
+                    **kwargs: dict[str, Any]) -> Any:
+    """Run the bulk system for all entities with matching cids.
 
-def run_all_systems(dt: float) -> dict[SystemFunction, _RunSystemResult]:
+    :param fn: the actual system function
+    :param cids: the components to run on
+    :param has_properties: set of required properties
+    :return: A dictionary with entity IDs as key and the function result as value
+
+    The fn is called with a list of entity ID and components tuples of all
+    entities that contain the listed components.  The list can further be
+    narrowed down my filtering for given properties.
+
+    ``fn`` is called given a list of ``(EntityID, (components,...))``. In
+    contrast to ``run_system``, the user is responsible to loop over the list.
+
+    The prototype of ``fn`` is::
+
+        def callback(call_list: list[tuple[EntityID, list[Component]]]) -> Any
+    """
+
+    call_list = _create_call_list(cids, has_properties)
+    return fn(call_list, **kwargs) if call_list else None
+
+
+def run_all_systems(**kwargs) -> dict[SystemFunction, _RunSystemResult]:
     """Run all registered systems.
 
-    :param dt: Delta time
     :return: A dict of function as key, and the result of run_system as value
 
     This calls above run_system for all registered systems with their
     appropriate components.
     """
 
-    return {fkt: run_system(dt, fkt, *comps)
-            for fkt, comps in sidx.items()}
+    return {fn: run_system(fn, *comps, **kwargs)
+            for fn, comps in sidx.items()}
 
 
-def run_domain(dt: float, domain: DomainID) -> dict[SystemFunction, _RunSystemResult]:
+def run_domain(domain: DomainID, **kwargs) -> dict[SystemFunction, _RunSystemResult]:
     """Run all systems within domain.
 
-    :param dt: Delta time
     :return: A dict of function as key, and the result of run_system as value
 
     This is the same as run_all_systems, but limited to a specific domain.
@@ -584,14 +615,14 @@ def run_domain(dt: float, domain: DomainID) -> dict[SystemFunction, _RunSystemRe
     if domain not in didx:
         return {}
 
-    return {fkt: run_system(dt, fkt, *sidx[fkt])
-            for fkt in didx[domain]}
+    return {fn: run_system(fn, *sidx[fn], **kwargs)
+            for fn in didx[domain]}
 
 
 def create_archetype(*cids: ComponentID) -> None:
     """Create an archetype from the provided cids.
 
-    :param cids The list of cids that define the archetype.
+    :param cids: The list of cids that define the archetype.
     :return: None
 
     An archetype is a fixed combination of components.  Each time a component
@@ -669,11 +700,11 @@ def remove_from_archetype(eid: EntityID, cid: ComponentID | None = None) -> None
             del adict[eid]
 
 
-def comps_of_archetype(*cids: ComponentID, has_properties: _OptionalProperties = None) -> list[_EntityComponentsBundle]:
+def comps_of_archetype(*cids: ComponentID, has_properties: _OptionalProperties = None) -> list[EntityComponentsBundle]:
     """Return the given archetype.
 
-    :param cids The cids that define the archetype.
-    :param has_properties Optional set of required properties
+    :param cids: The cids that define the archetype.
+    :param has_properties: Optional set of required properties
     :return: A list of tuples of (eid, components)
     :raises UnknownArchetypeError: If the given archetype doesn't exist.
 

{tinyecs-0.3.5 → tinyecs-0.4.0}/src/tinyecs/compsys.py

@@ -249,12 +249,12 @@ class RSAImage:
         self.update()
 
 
-def dead_system(dt, eid, dead):
+def dead_system(eid, dead, **kwargs):
     """Reap entities marked with a `dead` component."""
     ecs.remove_entity(eid)
 
 
-def deadzone_system(dt, eid, world, position, *, container):
+def deadzone_system(eid, world, position, *, container, **kwargs):
     """Kill entities moving outside defined boundaries
 
     To avoid sprites flying off to infinity, a dead zone can be defined, that
@@ -284,7 +284,7 @@ def deadzone_system(dt, eid, world, position, *, container):
         ecs.remove_entity(eid)
 
 
-def extension_system(dt, eid, extension):
+def extension_system(eid, extension, **kwargs):
     """Add additional components.
 
     Parameters:
@@ -318,29 +318,29 @@ def extension_system(dt, eid, extension):
         ecs.remove_component(eid, 'extension')
 
 
-def force_system(dt, eid, force, momentum):
+def force_system(eid, force, momentum, *, dt, **kwargs):
     """Apply a force to a momentum"""
     momentum += force * dt
 
 
-def lifetime_system(dt, eid, lifetime):
+def lifetime_system(eid, lifetime, **kwargs):
     """Kill an entity after a specified time"""
     if lifetime.cold():
         ecs.remove_entity(eid)
 
 
-def momentum_system(dt, eid, momentum, position):
+def momentum_system(eid, momentum, position, *, dt):
     """Apply momentum to a position (a.k.a. "move")."""
     position += momentum * dt
 
 
-def mouse_system(dt, eid, mouse, position):
+def mouse_system(eid, mouse, position):
     """Place the position of an entity to the mouse cursor."""
     mp = pygame.mouse.get_pos()
     position.xy = Vector2(mp)
 
 
-def scale_system(dt, eid, scale, momentum):
+def scale_system(eid, scale, momentum, *, dt):
     """Apply friction to a momentum.
 
     In contrast to a force, which adds a directional vector to the momentum,
@@ -353,7 +353,7 @@ def scale_system(dt, eid, scale, momentum):
 friction_system = scale_system
 
 
-def sprite_system(dt, eid, sprite, position):
+def sprite_system(eid, sprite, position, **kwargs):
     """Set the rect.center of sprite to position."""
 
     if sprite.rect:
@@ -362,7 +362,7 @@ def sprite_system(dt, eid, sprite, position):
         sprite.rect = sprite.image.get_rect(center=position)
 
 
-def wsad_system(dt, eid, wsad, position):
+def wsad_system(eid, wsad, position, *, dt):
     """An example system to control a playear with the `wsad` keys.
 
     Given the following entity:
@@ -374,7 +374,7 @@ def wsad_system(dt, eid, wsad, position):
 
     running this system will modify the position component of the entity.
 
-        ecs.run_system(dt, 'wsad', 'position', 'player')
+        ecs.run_system('wsad', 'position', 'player', dt=dt)
 
     Parameters
     ----------
@@ -396,4 +396,4 @@ def wsad_system(dt, eid, wsad, position):
     if keys[pygame.K_d]: v.x += 1
 
     # Normalize so diagonals are not faster then axis motion
-    if v: position += v.normalize() * wsad * dt
+    if v: position += v.normalize() * wsad

{tinyecs-0.3.5 → tinyecs-0.4.0}/src/tinyecs/demos/background.py

@@ -6,11 +6,11 @@ from types import SimpleNamespace
 from pygame import Vector2
 
 
-def momentum_system(dt, eid, momentum, position):
+def momentum_system(eid, momentum, position, *, dt):
     position += momentum * dt
 
 
-def border_system(dt, eid, border, position, momentum):
+def border_system(eid, border, position, momentum, **kwargs):
     if position.x < 0:
         position.x = -position.x
         momentum.x = -momentum.x
@@ -25,7 +25,7 @@ def border_system(dt, eid, border, position, momentum):
         momentum.y = -momentum.y
 
 
-def background_system(dt, eid, background, position, surface):
+def background_system(eid, background, position, surface, *, dt):
     def draw_one(angle, offset):
         v0 = Vector2(position)
         v1 = Vector2(2000, 0).rotate(angle)
@@ -81,7 +81,7 @@ def main():
 
         screen.fill('black')
 
-        ecs.run_all_systems(dt)
+        ecs.run_all_systems(dt=dt)
 
         pygame.display.flip()
         clock.tick(FPS)

{tinyecs-0.3.5 → tinyecs-0.4.0}/src/tinyecs/demos/bouncing_sprites.py

@@ -14,7 +14,7 @@ class Sprite(pygame.sprite.Sprite):
         self.rect = self.image.get_rect()
 
 
-def bounding_box_system(dt, eid, world, position, momentum):
+def bounding_box_system(eid, world, position, momentum, **kwargs):
     if position.x < 0:
         position.x = -position.x
         momentum.x = -momentum.x
@@ -95,7 +95,7 @@ def main():
         screen.fill('black')
 
         group.update(dt)
-        ecs.run_all_systems(dt)
+        ecs.run_all_systems(dt=dt)
 
         screen.blit(click, click_rect)
         group.draw(screen)

{tinyecs-0.3.5 → tinyecs-0.4.0}/src/tinyecs/demos/example.py

@@ -25,7 +25,7 @@ class Velocity:
     dy: float
 
 
-def motion_system(dt, eid, position, velocity):
+def motion_system(eid, position, velocity, *, dt):
     # Note that assigning a new Vector to position would not make it back
     # into e.position.  But since we don't change the position instance
     # itself, we're safe.
@@ -33,14 +33,14 @@ def motion_system(dt, eid, position, velocity):
     position.y += velocity.dy * dt
 
 
-def lifetime_system(dt, eid, lifetime):
+def lifetime_system(eid, lifetime, *, dt):
     lifetime.time_left -= 1 * dt
     if lifetime.time_left <= 0:
         print(f'removing entity {eid}')
         ecs.remove_entity(eid)
 
 
-def render_system(dt, eid, printable):
+def render_system(eid, printable):
     # the printable component contains no data at all and can be ignored,
     # but it will still be passed as a parameter.
     name, pos, velocity, lifetime = ecs.comps_of_eid(eid,
@@ -72,7 +72,7 @@ def main():
 
     ecs.run_system(1, render_system, Comps.PRINTABLE)
     for i in range(15):
-        ecs.run_system(1, motion_system, Comps.POSITION, Comps.VELOCITY)
+        ecs.run_system(1, motion_system, Comps.POSITION, Comps.VELOCITY, dt=1)
         ecs.run_system(1, lifetime_system, Comps.LIFETIME)
         ecs.run_system(1, render_system, Comps.PRINTABLE)
 
@@ -105,8 +105,8 @@ def main():
 
     for i in range(15):
         # ecs.run_all_systems(1)
-        ecs.run_domain(1, 'updates')
-        ecs.run_domain(1, 'render')
+        ecs.run_domain('updates', dt=1)
+        ecs.run_domain('render')
 
     print(f'All entities: {ecs.eidx}')
     print(f'All components: {ecs.cidx}')

{tinyecs-0.3.5 → tinyecs-0.4.0}/src/tinyecs/demos/homing-missiles.py

@@ -10,12 +10,12 @@ from pgcooldown import Cooldown
 from pygame import Vector2
 
 
-def dead_sprite_system(dt, eid, dead, sprite):
+def dead_sprite_system(eid, dead, sprite):
     sprite.kill()
     ecs.remove_entity(eid)
 
 
-def lifetime_sprite_system(dt, eid, lifetime, sprite):
+def lifetime_sprite_system(eid, lifetime, sprite):
     if lifetime.hot():
         return
     sprite.kill()
@@ -54,7 +54,7 @@ def create_shard(position, image, *groups):
     ecs.add_component(e, 'lifetime', Cooldown(random() * 0.25))
 
 
-def homing_missile_system(dt, eid, homing_missile, position, momentum):
+def homing_missile_system(eid, homing_missile, position, momentum, *, dt):
     target_pos = ecs.comp_of_eid(homing_missile.target, 'position')
 
     target = target_pos
@@ -88,14 +88,14 @@ def homing_missile_system(dt, eid, homing_missile, position, momentum):
     momentum.rotate_ip(copysign(rotation, delta_phi))
 
 
-def fire_system(dt, eid, fire, position):
+def fire_system(eid, fire, position):
     for i in range(fire.count):
         fire.fkt(pos=position)
 
     ecs.remove_component(eid, 'fire')
 
 
-def bounding_box_system(dt, eid, world, position, momentum):
+def bounding_box_system(eid, world, position, momentum):
     if position.x < 0:
         position.x = -position.x
         momentum.x = -momentum.x
@@ -206,15 +206,15 @@ def main():
 
         screen.fill('black')
 
-        ecs.run_system(dt, ecsc.mouse_system, 'mouse', 'position')
-        ecs.run_system(dt, lifetime_sprite_system, 'lifetime', 'sprite')
-        ecs.run_system(dt, dead_sprite_system, 'dead', 'sprite')
-        ecs.run_system(dt, ecsc.dead_system, 'dead')
-        ecs.run_system(dt, ecsc.momentum_system, 'momentum', 'position')
-        ecs.run_system(dt, ecsc.sprite_system, 'sprite', 'position')
-        ecs.run_system(dt, bounding_box_system, 'world', 'position', 'momentum')
-        ecs.run_system(dt, homing_missile_system, 'homing_missile', 'position', 'momentum')
-        ecs.run_system(dt, fire_system, 'fire', 'position')
+        ecs.run_system(ecsc.mouse_system, 'mouse', 'position')
+        ecs.run_system(lifetime_sprite_system, 'lifetime', 'sprite')
+        ecs.run_system(dead_sprite_system, 'dead', 'sprite')
+        ecs.run_system(ecsc.dead_system, 'dead')
+        ecs.run_system(ecsc.momentum_system, 'momentum', 'position', dt=dt)
+        ecs.run_system(ecsc.sprite_system, 'sprite', 'position')
+        ecs.run_system(bounding_box_system, 'world', 'position', 'momentum')
+        ecs.run_system(homing_missile_system, 'homing_missile', 'position', 'momentum', dt=dt)
+        ecs.run_system(fire_system, 'fire', 'position')
 
         screen.blit(click, click_rect)
         group.draw(screen)

{tinyecs-0.3.5 → tinyecs-0.4.0}/src/tinyecs/demos/marquee.py

@@ -10,7 +10,7 @@ from pgcooldown import Cooldown
 from pygame import Vector2
 
 
-def marquee_system(dt, eid, marquee, border, surface):
+def marquee_system(eid, marquee, border, surface, *, dt):
     def bounce(point, momentum):
         point += momentum * dt
         if point.x < 0:
@@ -80,7 +80,7 @@ def main():
 
         screen.fill(BLACK)
 
-        ecs.run_system(dt, marquee_system, 'marquee', 'border', 'surface')
+        ecs.run_system(marquee_system, 'marquee', 'border', 'surface', dt=dt)
 
         pygame.display.flip()
         clock.tick(FPS)

{tinyecs-0.3.5 → tinyecs-0.4.0}/src/tinyecs/tutorial.py

@@ -173,17 +173,18 @@ will be used.  To run e.g. the `momentum_system`, put the following into the
 game loop:
 
 ``py
-ecs.run_system(dt, momentum_system, 'momentum', 'position')
+ecs.run_system(momentum_system, 'momentum', 'position', dt=deltatime)
 ```
 
 When the game loop passes this call, `run_system` will find all entities that
 have both components `momentum` and `position` and pass these together with
-deltatime `dt` and the entity ID into the `momentum_system` function.
+the entity ID into the `momentum_system` function.  Remember, that kwargs can
+be used to pass additional arguments from the main scope.
 
 Writing the `momentum_system` is easy:
 
 ```py
-def momentum_system(dt, eid, momentum, position):
+def momentum_system(eid, momentum, position, *, dt):
     position += momentum * dt
 ```
 
@@ -199,11 +200,16 @@ passed in after the components.  The following will be explained in the actual
 script later.
 
 ```py
-ecs.run_system(dt, deadzone_system, 'position', deadzone=WORLD)
+ecs.run_system(deadzone_system, 'position', deadzone=WORLD)
 ```
 
 So the system is basically the `update(dt)` function in an OO driven game.
 
+If you prefer to loop over the list of entities yourself, instead of your
+system being called for each entity individually, theren is `run_bulk_system`,
+which gets the same arguments as ``run_system``, but will pass the full list
+to the system.
+
 At this point you might get the feeling, that you will have a very large list
 of systems in a big block in your game loop, and that's exactly right.  You
 either hate that, which is fine, so the option is either to go back to an OO
@@ -216,7 +222,7 @@ There are some alternatives still.
 program and call a single function in your game loop:
 
 ```py
-ecs.run_all_systems(dt)
+ecs.run_all_systems(dt=dt)
 ```
 
 2. To give you a more fine grained control over what systems run together, the
@@ -236,7 +242,7 @@ method of your component.  You still need that block of `run_system` or above
 shortcuts in your game loop though.
 
 ```py
-def call_update_system(dt, eid, component):
+def call_update_system(eid, component, dt=dt):
     component.update(dt)
 ```
 
@@ -359,15 +365,15 @@ completeness:
 # addition.
 WORLD = SCREEN.scale_by(1.25)
 
-def momentum_system(dt, eid, momentum, position):
+def momentum_system(eid, momentum, position, *, dt):
     """Add a delta time scaled momentum to the position."""
     position += momentum * dt
 
-def sprite_position_system(dt, eid, sprite, position):
+def sprite_position_system(eid, sprite, position):
     """Apply the position to the rect of the sprite for the sprite group"""
     sprite.rect.center = position
 
-def deadzone_system(dt, eid, position, *, world):
+def deadzone_system(eid, position, *, world):
     """Kill sprites that move off screen"""
     if world.collidepoint(position):
         return
@@ -391,7 +397,7 @@ to the entity instead of overwriting the component variable.
 
 .. code-block::
 
-  def take_damage_system(dt, eid, health, damage):
+  def take_damage_system(eid, health, damage):
       ecs.add_component(eid, 'health', health - damage)
 
 For semantic reasons, tinyecs also provides `update_component`, but that's
@@ -425,9 +431,9 @@ The lines marked with `>` are additions to the game loop template all above.
 #### Running the systems
 
 ```py
->   ecs.run_system(dt, momentum_system, 'momentum', 'position')
->   ecs.run_system(dt, deadzone_system, 'position', world=WORLD)
->   ecs.run_system(dt, sprite_position_system, 'sprite', 'position')
+>   ecs.run_system(momentum_system, 'momentum', 'position', dt=dt)
+>   ecs.run_system(deadzone_system, 'position', world=WORLD)
+>   ecs.run_system(sprite_position_system, 'sprite', 'position')
 
     screen.fill('black')
 
@@ -494,17 +500,17 @@ def create_box_entity(position, sprite_group):
     ecs.add_component(e, 'sprite', DemoSprite(sprite_group))
 
 
-def momentum_system(dt, eid, momentum, position):
+def momentum_system(eid, momentum, position, *, dt):
     """Add a delta time scaled momentum to the position."""
     position += momentum * dt
 
 
-def sprite_position_system(dt, eid, sprite, position):
+def sprite_position_system(eid, sprite, position):
     """Apply the position to the rect of the sprite for the sprite group"""
     sprite.rect.center = position
 
 
-def deadzone_system(dt, eid, position, *, world):
+def deadzone_system(eid, position, *, world):
     """Kill sprites that move off screen"""
     if world.collidepoint(position):
         return
@@ -533,9 +539,9 @@ while running:
             pos = pygame.mouse.get_pos()
             create_box_entity(pos, group)
 
-    ecs.run_system(dt, momentum_system, 'momentum', 'position')
-    ecs.run_system(dt, deadzone_system, 'position', world=WORLD)
-    ecs.run_system(dt, sprite_position_system, 'sprite', 'position')
+    ecs.run_system(momentum_system, 'momentum', 'position', dt=dt)
+    ecs.run_system(deadzone_system, 'position', world=WORLD)
+    ecs.run_system(sprite_position_system, 'sprite', 'position')
 
     screen.fill('black')
 
@@ -585,12 +591,12 @@ import tinyecs.compsys as ecsc
 
     UNSTABLE!  DON'T RELY ON THIS YET!
 
-`def dead_system(dt, eid, dead)`:
+`def dead_system(eid, dead)`:
     Sometimes it is useful to not remove a sprite immediately from the system.
     Instead, you can add a component tagged e.g. 'dead', and later reap all
     entities marked with that tag.
 
-`def deadzone_system(dt, eid, world, position, *, container)`:
+`def deadzone_system(eid, world, position, *, container)`:
 
     Basically the function created in this tutorial, with one addition.
 
@@ -603,25 +609,25 @@ import tinyecs.compsys as ecsc
 
         ecs.add_component(e, 'world', True)
 
-`def extension_system(dt, eid, extension)`:
+`def extension_system(eid, extension)`:
     Will be removed.  tinyecs installs pgcooldown as a requirement and that
     comes with the `CronD` class which does the same and more.
 
-`def force_system(dt, eid, force, momentum)`:
+`def force_system(eid, force, momentum, *, dt)`:
     Applies (adds) a constant force to a momentum.
 
-`def lifetime_system(dt, eid, lifetime)`:
+`def lifetime_system(eid, lifetime)`:
     Kills the entity once lifetime has run out.  Expects `lifetime` to be an
     instance of `pgcooldown.Cooldown`
 
-`def momentum_system(dt, eid, momentum, position)`:
+`def momentum_system(eid, momentum, position, *, dt)`:
     The same as we wrote in the tutorial above.
 
-`def mouse_system(dt, eid, mouse, position)`:
+`def mouse_system(eid, mouse, position)`:
     Update a position component with the position of the mouse cursor.
 
-`def scale_system(dt, eid, scale, momentum)`:
-`def friction_system(dt, eid, scale, momentum)`:
+`def scale_system(eid, scale, momentum, *, dt)`:
+`def friction_system(eid, scale, momentum, *, dt)`:
     Apply friction to a momentum.
 
     In contrast to a force_system, which adds a directional vector to the
@@ -630,10 +636,10 @@ import tinyecs.compsys as ecsc
 
     `friction_system` is an alias to `scale_system`.
 
-`def sprite_system(dt, eid, sprite, position)`:
+`def sprite_system(eid, sprite, position)`:
     The same as we wrote above, apply the position to `sprite.rect.center`.
 
-`def wsad_system(dt, eid, wsad, position)`:
+`def wsad_system(eid, wsad, position)`:
     An example system to control a playear with the `wsad` keys.
     This was just a proof of concept, but I'm currently using it, so perhaps
     it will stay.
@@ -690,17 +696,17 @@ def create_box_entity(position, sprite_group):
     ecs.add_component(e, 'sprite', DemoSprite(sprite_group))
 
 
-def momentum_system(dt, eid, momentum, position):
+def momentum_system(eid, momentum, position, *, dt):
     """Add a delta time scaled momentum to the position."""
     position += momentum * dt
 
 
-def sprite_position_system(dt, eid, sprite, position):
+def sprite_position_system(eid, sprite, position):
     """Apply the position to the rect of the sprite for the sprite group"""
     sprite.rect.center = position
 
 
-def deadzone_system(dt, eid, position, *, world):
+def deadzone_system(eid, position, *, world):
     """Kill sprites that move off screen"""
     if world.collidepoint(position):
         return
@@ -730,9 +736,9 @@ def main():
                 pos = pygame.mouse.get_pos()
                 create_box_entity(pos, group)
 
-        ecs.run_system(dt, momentum_system, 'momentum', 'position')
-        ecs.run_system(dt, deadzone_system, 'position', world=WORLD)
-        ecs.run_system(dt, sprite_position_system, 'sprite', 'position')
+        ecs.run_system(momentum_system, 'momentum', 'position', dt=dt)
+        ecs.run_system(deadzone_system, 'position', world=WORLD)
+        ecs.run_system(sprite_position_system, 'sprite', 'position')
 
         screen.fill('black')
 

{tinyecs-0.3.5 → tinyecs-0.4.0/src/tinyecs.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinyecs
-Version: 0.3.5
+Version: 0.4.0
 Summary: The teeniest, tiniest ECS system
 Author-email: Michael Lamertz <michael.lamertz@gmail.com>
 License-Expression: MIT

{tinyecs-0.3.5 → tinyecs-0.4.0}/tests/test_tinyecs.py

@@ -28,20 +28,20 @@ class Ping:
     ack: bool = False
 
 
-def wounding_system(dt, eid, health):
+def wounding_system(eid, health, **kwargs):
     health.health -= 100
     return health.health
 
 
-def stats_system(dt, eid, name, health):
-    return f'{dt=}, {eid=}, {name.name=}, {health.health=}'
+def stats_system(eid, name, health, **kwargs):
+    return f'{eid=}, {name.name=}, {health.health=}'
 
 
-def ping_system(dt, eid, ping):
+def ping_system(eid, ping):
     ping.ack = True
 
 
-def move_system(dt, eid, pos, velocity):
+def move_system(eid, pos, velocity, *, dt, **kwargs):
     pos.x += velocity.dx * dt
     pos.y += velocity.dy * dt
     return (pos.x, pos.y)
@@ -161,27 +161,40 @@ def test_comps_of_eid():
 
 def test_run_system():
     e1, e2 = setup()
-    ecs.run_system(1, wounding_system, 'health')
+    ecs.run_system(wounding_system, 'health')
     assert ecs.eidx[e2]['health'].health == 900
     assert ecs.cidx['health'][e2].health == 900
 
     worked = False
 
-    def sys_no_args(dt, eid):
+    def sys_no_args(eid):
         nonlocal worked
         worked = True
 
-    ecs.run_system(0, sys_no_args)
+    ecs.run_system(sys_no_args)
     assert worked
 
 
+def test_run_bulk_system():
+    ecs.reset()
+    for i in range(10):
+        eid = ecs.create_entity()
+        ecs.add_component(eid, 'number', i)
+
+    def bulk_runner(call_list):
+        assert len(call_list) == 10
+        return sum([i for eid, i in call_list])
+
+    assert ecs.run_bulk_system(bulk_runner, 'number') == 45
+
+
 def test_run_all_systems():
     e1, e2 = setup()
     ecs.add_system(move_system, 'pos', 'velocity')
     ecs.add_system(wounding_system, 'health')
     ecs.add_component(e2, 'pos', SimpleNamespace(x=100, y=200))
     ecs.add_component(e2, 'velocity', SimpleNamespace(dx=5, dy=7))
-    res = ecs.run_all_systems(1)
+    res = ecs.run_all_systems(dt=1)
 
     assert ecs.eidx[e2]['pos'] == SimpleNamespace(x=105, y=207)
     assert res[move_system][e2] == (105, 207)
@@ -261,7 +274,7 @@ def test_reset():
 
 
 def test_kill_from_system():
-    def kill_system(dt, eid, kill):
+    def kill_system(eid, kill):
         ecs.remove_entity(eid)
 
     ecs.reset()
@@ -273,7 +286,7 @@ def test_kill_from_system():
             ecs.add_component(e, 'kill', True)
 
     assert len(ecs.eidx) == 10
-    ecs.run_system(1, kill_system, 'kill')
+    ecs.run_system(kill_system, 'kill')
     assert len(ecs.eidx) == 5
 
 
@@ -305,11 +318,11 @@ def test_run_domain():
     e = ecs.create_entity()
     ecs.add_component(e, 'ping', Ping(False))
 
-    res = ecs.run_domain(1, 'infra')
+    res = ecs.run_domain('infra')
     assert ping_system in res
     assert e in res[ping_system]
 
-    res = ecs.run_domain(1, 'non-existent')
+    res = ecs.run_domain('non-existent')
     assert res == {}
 
 
@@ -404,12 +417,12 @@ def test_add_to_archetype():
     # Also tests remove_from_archetype
     setup()
 
-    def test_system(dt, eid, test):
+    def test_system(eid, test):
         pass
 
     e = ecs.create_entity()
     ecs.add_component(e, 'test', True)
-    ecs.run_system(0, test_system, 'test')
+    ecs.run_system(test_system, 'test')
     assert e in ecs.archetype[('test',)]
 
     ecs.remove_component(e, 'test')
@@ -457,10 +470,10 @@ def test_property_get_entities():
 def test_property_run_system():
     setup_property_tests()
 
-    def flag_system(dt, eid, comp1, comp2):
+    def flag_system(eid, comp1, comp2):
         ecs.add_component(eid, 'flag', True)
 
-    ecs.run_system(0, flag_system, 'comp-1', 'comp-2', has_properties={'is-even'})
+    ecs.run_system(flag_system, 'comp-1', 'comp-2', has_properties={'is-even'})
     assert len(ecs.eids_by_cids('flag')) == 5