esper 3.2__tar.gz → 3.3__tar.gz

esper-3.3/.ruff.toml

@@ -0,0 +1,2 @@
+lint.select = ["F", "E", "W", "C90", "B", "A", "C4", "G", "T20", "PT", "SLF", "TCH", "RET", "N", "ARG"]
+lint.ignore = ["E501"]

{esper-3.2 → esper-3.3}/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2023 Benjamin Moran
+Copyright (c) 2024 Benjamin Moran
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{esper-3.2 → esper-3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: esper
-Version: 3.2
+Version: 3.3
 Summary: esper is a lightweight Entity System (ECS) for Python, with a focus on performance
 Author-email: Benjamin Moran <benmoran@protonmail.com>
 Requires-Python: >=3.8
@@ -75,7 +75,7 @@ Design
 * World Context
 
 Esper uses the concept of "World" contexts. When you first `import esper`, a default context is
-active. You create Entities, assign Components, register Processesors, etc., by calling functions
+active. You create Entities, assign Components, register Processors, etc., by calling functions
 on the `esper` module. Entities, Components and Processors can be created, assigned, or deleted
 while your game is running. A simple call to `esper.process()` is all that's needed for each
 iteration of your game loop. Advanced users can switch contexts, which can be useful for

{esper-3.2 → esper-3.3}/README.md

@@ -65,7 +65,7 @@ Design
 * World Context
 
 Esper uses the concept of "World" contexts. When you first `import esper`, a default context is
-active. You create Entities, assign Components, register Processesors, etc., by calling functions
+active. You create Entities, assign Components, register Processors, etc., by calling functions
 on the `esper` module. Entities, Components and Processors can be created, assigned, or deleted
 while your game is running. A simple call to `esper.process()` is all that's needed for each
 iteration of your game loop. Advanced users can switch contexts, which can be useful for

{esper-3.2 → esper-3.3}/RELEASE_NOTES

@@ -1,3 +1,14 @@
+esper 3.3
+=========
+Maintenance release
+
+Changes
+-------
+- Fix unreadable `esper.current_world` property. (#100)
+- Minor typing configuration updates.
+- Remove outdated pyglet example. (Another one already exists).
+
+
 esper 3.2
 =========
 Maintenance release

{esper-3.2 → esper-3.3}/esper/__init__.py

@@ -23,7 +23,7 @@ from weakref import WeakMethod as _WeakMethod
 
 from itertools import count as _count
 
-__version__ = version = '3.2'
+__version__ = version = '3.3'
 
 
 ###################
@@ -131,7 +131,7 @@ class Processor:
 #   ECS functions
 ###################
 
-_current_context: str = "default"
+_current_world: str = "default"
 _entity_count: "_count[int]" = _count(start=1)
 _components: _Dict[_Type[_Any], _Set[_Any]] = {}
 _entities: _Dict[int, _Dict[_Type[_Any], _Any]] = {}
@@ -141,8 +141,16 @@ _get_components_cache: _Dict[_Tuple[_Type[_Any], ...], _List[_Any]] = {}
 _processors: _List[Processor] = []
 process_times: _Dict[str, int] = {}
 event_registry: _Dict[str, _Any] = {}
+current_world: str = "default"
+"""The name of the currently active World context.
 
-# {context_name: (entity_count, components, entities, dead_entities, comp_cache, comps_cache, processors, process_times, event_registry)}
+This attribute can be checked to confirm the name of the
+currently active World context. Modifying this has no effect;
+to switch Worlds, use the :py:func:`~switch_world` function.
+"""
+
+# {context_name: (entity_count, components, entities, dead_entities,
+#                 comp_cache, comps_cache, processors, process_times, event_registry)}
 _context_map: _Dict[str, _Tuple[
     "_count[int]",
     _Dict[_Type[_Any], _Set[_Any]],
@@ -387,9 +395,7 @@ def get_component(component_type: _Type[_C]) -> _List[_Tuple[int, _C]]:
     try:
         return _get_component_cache[component_type]
     except KeyError:
-        return _get_component_cache.setdefault(
-            component_type, list(_get_component(component_type))
-        )
+        return _get_component_cache.setdefault(component_type, list(_get_component(component_type)))
 
 
 @_overload
@@ -404,7 +410,7 @@ def get_components(__c1: _Type[_C], __c2: _Type[_C2], __c3: _Type[_C3]) -> _List
 
 @_overload
 def get_components(__c1: _Type[_C], __c2: _Type[_C2], __c3: _Type[_C3], __c4: _Type[_C4]) -> _List[
-    _Tuple[int, _Tuple[_C, _C2, _C3, _C4]]]:
+                   _Tuple[int, _Tuple[_C, _C2, _C3, _C4]]]:
     ...
 
 
@@ -413,9 +419,7 @@ def get_components(*component_types: _Type[_Any]) -> _Iterable[_Tuple[int, _Tupl
     try:
         return _get_components_cache[component_types]
     except KeyError:
-        return _get_components_cache.setdefault(
-            component_types, list(_get_components(*component_types))
-        )
+        return _get_components_cache.setdefault(component_types, list(_get_components(*component_types)))
 
 
 def try_component(entity: int, component_type: _Type[_C]) -> _Optional[_C]:
@@ -525,7 +529,7 @@ def delete_world(name: str) -> None:
     Raises `PermissionError` if you attempt to delete the currently
     active World context.
     """
-    if _current_context == name:
+    if _current_world == name:
         raise PermissionError("The active World context cannot be deleted.")
 
     del _context_map[name]
@@ -550,7 +554,7 @@ def switch_world(name: str) -> None:
         # Create a new context if the name does not already exist:
         _context_map[name] = (_count(start=1), {}, {}, set(), {}, {}, [], {}, {})
 
-    global _current_context
+    global _current_world
     global _entity_count
     global _components
     global _entities
@@ -560,17 +564,9 @@ def switch_world(name: str) -> None:
     global _processors
     global process_times
     global event_registry
+    global current_world
 
     # switch the references to the objects in the named context_map:
     (_entity_count, _components, _entities, _dead_entities, _get_component_cache,
      _get_components_cache, _processors, process_times, event_registry) = _context_map[name]
-    _current_context = name
-
-
-@property   # type: ignore
-def current_world() -> str:
-    """The currently active World context.
-
-    To switch World contexts, see :py:func:`esper.switch_world`.
-    """
-    return _current_context
+    _current_world = current_world = name

{esper-3.2 → esper-3.3}/examples/pyglet_example.py

@@ -36,7 +36,7 @@ class MovementProcessor:
     def process(self, dt):
         # This will iterate over every Entity that has BOTH of these components:
         for ent, (vel, rend) in esper.get_components(Velocity, Renderable):
-            # Update the Renderable Component's position by it's Velocity:
+            # Update the Renderable Component's position by its Velocity:
             # An example of keeping the sprite inside screen boundaries. Basically,
             # adjust the position back inside screen boundaries if it is outside:
             new_x = max(self.minx, rend.sprite.x + vel.x)

esper-3.2/.ruff.toml

@@ -1,3 +0,0 @@
-select = ["F", "E", "W", "C90", "B", "A", "C4", "G", "T20", "PT", "SLF", "TCH", "RET", "N", "ARG"]
-ignore = ["E501"]
-

esper-3.2/examples/pyglet_example_batch.py

@@ -1,245 +0,0 @@
-import pyglet
-from pyglet.gl import *
-from pyglet.window import key
-
-import esper
-
-
-FPS = 60
-RESOLUTION = 720, 480
-BGCOLOR = (0, 0, 0, 255)
-
-
-##################################
-#  Define some Components:
-##################################
-class Velocity:
-    def __init__(self, x=0.0, y=0.0):
-        self.x = x
-        self.y = y
-
-
-class Renderable:
-    def __init__(self, texture, width, height, posx, posy):
-        self.texture = texture
-        self._x = posx
-        self._y = posy
-        self.w = width
-        self.h = height
-        self.group = TextureBindGroup(texture)
-        self.vertex_list = None
-        self._dirty = True
-
-    @property
-    def x(self):
-        return self._x
-
-    @x.setter
-    def x(self, val):
-        if val != self._x:
-            self._x = val
-            self._dirty = True
-
-    @property
-    def y(self):
-        return self._y
-
-    @y.setter
-    def y(self, val):
-        if val != self._y:
-            self._y = val
-            self._dirty = True
-
-
-################################
-#  Define some Processors:
-################################
-class MovementProcessor:
-    def __init__(self, minx, miny, maxx, maxy):
-        super().__init__()
-        self.minx = minx
-        self.miny = miny
-        self.maxx = maxx
-        self.maxy = maxy
-
-    def process(self):
-        # This will iterate over every Entity that has BOTH of these components:
-        for ent, (vel, rend) in esper.get_components(Velocity, Renderable):
-            # Update the Renderable Component's position by it's Velocity:
-            rend.x += vel.x
-            rend.y += vel.y
-            # An example of keeping the sprite inside screen boundaries. Basically,
-            # adjust the position back inside screen boundaries if it tries to go outside:
-            rend.x = max(self.minx, rend.x)
-            rend.y = max(self.miny, rend.y)
-            rend.x = min(self.maxx - rend.w, rend.x)
-            rend.y = min(self.maxy - rend.h, rend.y)
-
-
-class TextureRenderProcessor():
-    def __init__(self, batch):
-        super().__init__()
-        self.batch = batch
-
-    def process(self):
-        # This will iterate over every Entity that has this Component, and
-        # add the texture associated with the Renderable Component instance
-        # and its vertice_list to the render batch. The batch will then be
-        # drawn by the 'on_draw' event handler of teh main window:
-        for entity, renderable in esper.get_component(Renderable):
-            self.draw_texture(renderable)
-
-    def draw_texture(self, renderable):
-        texture = renderable.texture
-
-        if renderable.vertex_list is None:
-            vertex_format = 'v2i/dynamic'
-            renderable.vertex_list = self.batch.add(4, GL_QUADS,
-                                                    renderable.group,
-                                                    vertex_format, 'c4B',
-                                                    ('t3f', texture.tex_coords))
-
-        if renderable._dirty:
-            x1 = renderable.x - texture.anchor_x
-            y1 = renderable.y - texture.anchor_y
-            x2 = x1 + texture.width
-            y2 = y1 + texture.height
-            renderable.vertex_list.vertices[:] = [x1, y1, x2, y1, x2, y2, x1, y2]
-            renderable.vertex_list.colors[:] = [255, 255, 255, 255] * 4
-            renderable._dirty = False
-
-
-############################################
-#  Some pyglet helper classes and functions:
-############################################
-def texture_from_image(image_name):
-    """Create a pyglet Texture from an image file"""
-    return pyglet.resource.image(image_name).get_texture()
-
-
-# Code below cobbled together from
-# https://pyglet.readthedocs.org/en/latest/programming_guide/graphics.html#hierarchical-state
-# and pyglet.sprite.SpriteGroup
-
-class TextureEnableGroup(pyglet.graphics.Group):
-    def set_state(self):
-        glEnable(GL_TEXTURE_2D)
-
-    def unset_state(self):
-        glDisable(GL_TEXTURE_2D)
-
-
-texture_enable_group = TextureEnableGroup()
-
-
-class TextureBindGroup(pyglet.graphics.Group):
-    def __init__(self, texture):
-        super().__init__(parent=texture_enable_group)
-        assert texture.target == GL_TEXTURE_2D
-        self.texture = texture
-        self.blend_src = GL_SRC_ALPHA
-        self.blend_dest = GL_ONE_MINUS_SRC_ALPHA
-
-    def set_state(self):
-        glBindTexture(GL_TEXTURE_2D, self.texture.id)
-        glPushAttrib(GL_COLOR_BUFFER_BIT)
-        glEnable(GL_BLEND)
-        glBlendFunc(self.blend_src, self.blend_dest)
-
-    def unset_state(self):
-        glPopAttrib()
-        glDisable(self.texture.target)
-
-    def __eq__(self, other):
-        return (other.__class__ is self.__class__ and
-                self.parent is other.parent and
-                self.texture.target == other.texture.target and
-                self.texture.id == other.texture.id and
-                self.blend_src == other.blend_src and
-                self.blend_dest == other.blend_dest)
-
-    def __hash__(self):
-        return hash((id(self.parent),
-                     self.texture.id, self.texture.target,
-                     self.blend_src, self.blend_dest))
-
-
-################################
-#  The main core of the program:
-################################
-def run(args=None):
-    # Initialize the main window stuff
-    window = pyglet.window.Window(width=RESOLUTION[0], height=RESOLUTION[1])
-    window.set_caption("Esper pyglet Example")
-    pyglet.gl.glClearColor(*BGCOLOR)
-    # pyglet graphics batch for efficient rendering
-    renderbatch = pyglet.graphics.Batch()
-
-    # Initialize Esper world, and create a "player" Entity with a few Components.
-    player = esper.create_entity()
-    esper.add_component(player, Velocity(x=0, y=0))
-    redsquare = Renderable(texture=texture_from_image("redsquare.png"),
-                           width=64,
-                           height=64,
-                           posx=100,
-                           posy=100)
-    esper.add_component(player, redsquare)
-
-    # Another motionless Entity:
-    enemy = esper.create_entity()
-    bluesquare = Renderable(texture=texture_from_image("bluesquare.png"),
-                            width=64,
-                            height=64,
-                            posx=400,
-                            posy=250)
-    esper.add_component(enemy, bluesquare)
-
-    # Create some Processor instances, and asign them to be processed.
-    render_processor = TextureRenderProcessor(batch=renderbatch)
-    movement_processor = MovementProcessor(minx=0, maxx=RESOLUTION[0], miny=0,
-                                           maxy=RESOLUTION[1])
-
-    @window.event
-    def on_key_press(symbol, modifiers):
-        if symbol == key.UP:
-            # Here is a way to directly access a specific Entity's Velocity
-            # Component's attribute (y) without making a temporary variable.
-            esper.component_for_entity(player, Velocity).y = 3
-        elif symbol == key.DOWN:
-            # For clarity, here is an alternate way in which a temporary variable
-            # is created and modified. The previous way above is recommended instead.
-            player_velocity_component = esper.component_for_entity(player, Velocity)
-            player_velocity_component.y = -3
-        elif symbol == key.LEFT:
-            esper.component_for_entity(player, Velocity).x = -3
-        elif symbol == key.RIGHT:
-            esper.component_for_entity(player, Velocity).x = 3
-        elif symbol == key.ESCAPE:
-            pyglet.app.exit()
-
-    @window.event
-    def on_key_release(symbol, modifiers):
-        if symbol in (key.UP, key.DOWN):
-            esper.component_for_entity(player, Velocity).y = 0
-        if symbol in (key.LEFT, key.RIGHT):
-            esper.component_for_entity(player, Velocity).x = 0
-
-    @window.event
-    def on_draw():
-        # Clear the window:
-        window.clear()
-        # Draw the batch of Renderables:
-        renderbatch.draw()
-
-    def update(dt):
-        # A single call to esper.process() will update all Processors:
-        render_processor.process()
-        movement_processor.process()
-
-    pyglet.clock.schedule_interval(update, 1.0 / FPS)
-    pyglet.app.run()
-
-
-if __name__ == "__main__":
-    import sys
-    sys.exit(run(sys.argv[1:]) or 0)