Make events actually work. Spawners remove dead things. (#177)

* Have spawners clean up when sprites are removed.

* Make it actually work.

Author: robbrit

engine/builtin.py

@@ -10,8 +10,10 @@
     List,
 )
 
-from engine import scripts
-from engine.model import game_sprite
+from engine import (
+    events,
+    scripts,
+)
 
 logger = logging.Logger("engine.builtin")
 
@@ -54,7 +56,7 @@ class Spawner(scripts.SavesAPI, scripts.Script):
     spawn_script: Callable[[None], scripts.Script]
     spawn_script_kwargs: Dict[str, Any]
     num_spawns: int
-    spawns: List[game_sprite.GameSprite]
+    spawns: List[scripts.Entity]
     last_spawn: float
     spawn_rate_per_sec: float
     spawn_cooldown_secs: float
@@ -103,6 +105,11 @@ def on_start(self, owner: scripts.ScriptOwner):
         """Triggered the first time this spawn is created."""
         self._state["location"] = owner.location
 
+    def set_api(self, api: scripts.GameAPI) -> None:
+        """Sets the API for this spawner."""
+        scripts.SavesAPI.set_api(self, api)
+        api.register_handler(events.SPRITE_REMOVED, self._cleanup_removed_sprite)
+
     def _can_spawn(self, now: float) -> bool:
         return (
             len(self.spawns) < self.num_spawns
@@ -130,3 +137,10 @@ def _spawn(self):
             script=self.spawn_script(**self.spawn_script_kwargs),
         )
         self.spawns.append(sprite)
+
+    def _cleanup_removed_sprite(
+        self,
+        _event_name: str,
+        event: events.SpriteRemoved,
+    ) -> None:
+        self.spawns = [spawn for spawn in self.spawns if spawn.name != event.name]

engine/core.py

@@ -139,13 +139,13 @@ def create_sprite(
         name: str,
         start_location: Tuple[int, int],
         script: Optional[scripts.Script],
-    ) -> None:
+    ) -> scripts.Entity:
         """Creates a sprite."""
         if self.world is None:
             raise GameNotInitializedError()
 
         _spec = self._spec.sprites[spec_name]
-        self.world.create_sprite(_spec, name, start_location, script)
+        return self.world.create_sprite(_spec, name, start_location, script)
 
     def get_key_points(self, name: Optional[str] = None) -> Iterable[scripts.KeyPoint]:
         """Queries for key points in the current region."""
@@ -169,6 +169,26 @@ def play_sound(self, name: str) -> None:
         """Plays a sound."""
         self._sounds[name].play()
 
+    def register_handler(self, event_name: str, handler: scripts.EventHandler) -> None:
+        """Registers an event handler for a custom event."""
+        self._events.register_handler(event_name, handler)
+
+    def unregister_handler(
+        self,
+        event_name: str,
+        handler: scripts.EventHandler,
+    ) -> None:
+        """Unregisters an event handler."""
+        self._events.unregister_handler(event_name, handler)
+
+    def fire_event(self, event_name: str, data: Any) -> None:
+        """Fires an event."""
+        self._events.fire_event(event_name, data)
+
+    def clear_events(self) -> None:
+        """Clears all events."""
+        self._events.clear_events()
+
     @property
     def player_data(self) -> Dict[str, Any]:
         """Gets the player's data."""

engine/event_manager.py

@@ -14,6 +14,10 @@ class EventManager:
     _handlers: Dict[str, List[scripts.EventHandler]]
 
     def __init__(self):
+        self.clear_events()
+
+    def clear_events(self) -> None:
+        """Unregisters all events in the manager."""
         self._handlers = collections.defaultdict(list)
 
     def register_handler(self, event_name: str, handler: scripts.EventHandler) -> None:

engine/model/game_sprite.py

@@ -107,7 +107,7 @@ class GameSprite(arcade.Sprite):
     This includes support for animations, facing directions, etc.
     """
 
-    name: str
+    _name: str
 
     _spec: Optional[spec.GameSpriteSpec]
     animations: Optional[Animations] = None
@@ -137,7 +137,7 @@ def __init__(
             image_width=width,
             image_height=height,
         )
-        self.name = name
+        self._name = name
         self.set_facing(x=1.0, y=1.0)
         self._spec = sprite_spec
         self.script = script
@@ -190,6 +190,11 @@ def _get_direction(self) -> str:
 
         return "right" if self.facing_x > 0 else "left"
 
+    @property
+    def name(self) -> str:
+        """Gets the name of this sprite."""
+        return self._name
+
     @property
     def location(self) -> Tuple[float, float]:
         """Gets the location of this sprite.

engine/model/world.py

@@ -72,6 +72,13 @@ class WorldState:
     region_states: Dict[str, RegionState]
 
 
+class _Core(scripts.GameAPI):
+    """Extended API for interacting with the core."""
+
+    def clear_events(self) -> None:
+        """Clears all events in the event handler."""
+
+
 class World:
     """
     This class represents the world. It manages maintenance of the state of the world.
@@ -83,7 +90,7 @@ class World:
     # - Make as much as possible private; things outside this class are starting to poke
     #   into it which adds extra coupling.
 
-    api: scripts.GameAPI
+    _core: _Core
 
     _player_sprite: player_sprite.PlayerSprite
 
@@ -119,18 +126,16 @@ class World:
 
     def __init__(
         self,
-        api: scripts.GameAPI,
+        core: _Core,
         game_spec: spec.GameSpec,
         initial_player_data: Dict[str, Any],
     ):
-        self.api = api
+        self._core = core
         self._spec = game_spec
         self.sec_passed = 0.0
 
-        api.register_handler(events.SPRITE_REMOVED, self._queue_sprite_removal)
-
         self._player_sprite = player_sprite.PlayerSprite(
-            api=api,
+            api=core,
             sprite_spec=game_spec.player_spec,
             initial_data=initial_player_data,
         )
@@ -177,6 +182,9 @@ def load_region(self, region_name: str, start_location: str) -> None:
         is_first_load = region_name not in self.regions_loaded
         self.regions_loaded.add(region_name)
 
+        self._core.clear_events()
+        self._core.register_handler(events.SPRITE_REMOVED, self._queue_sprite_removal)
+
         self._build_scene(tilemap)
         self._load_scripted_objects(tilemap, region_state, is_first_load)
 
@@ -299,7 +307,7 @@ def create_sprite(
         name: str,
         start_location: Tuple[float, float],
         script: Optional[scripts.Script],
-    ) -> arcade.Sprite:
+    ) -> game_sprite.GameSprite:
         """Adds a sprite to the model."""
         return self._create_sprite(
             sprite_spec,
@@ -344,7 +352,7 @@ def _create_sprite(
         if is_first_load:
             script.on_start(sprite)
 
-        script.set_api(self.api)
+        script.set_api(self._core)
         script.set_owner(sprite)
 
         return sprite
@@ -380,7 +388,7 @@ def _script_from_tiled_object(
             return self._load_script(properties)
         except NoScript:
             return scripts.ObjectScript(
-                self.api,
+                self._core,
                 on_activate=properties.get("on_activate"),
                 on_activate_args=scripts.extract_script_args(
                     "on_activate_",
@@ -406,7 +414,7 @@ def _load_script(self, properties: Dict[str, Any]) -> scripts.Script:
         cls = scripts.load_script_class(properties["script"])
         args = scripts.extract_script_args("script_", properties)
         obj = cls(**args)
-        obj.set_api(self.api)
+        obj.set_api(self._core)
         return obj
 
     def on_update(self, delta_time: float) -> None:
@@ -505,7 +513,7 @@ def _objs_in_front_of_player(self) -> Iterable[game_sprite.GameSprite]:
     def activate(self) -> None:
         """Activates whatever is in front of the player."""
         if self._spec.world.activate_sound:
-            self.api.play_sound(self._spec.world.activate_sound)
+            self._core.play_sound(self._spec.world.activate_sound)
 
         self._player_sprite.on_activate()
         for obj in self._objs_in_front_of_player():
@@ -517,7 +525,7 @@ def hit(self) -> None:
         """Hit whatever is in front of the player."""
 
         if self._spec.world.hit_sound:
-            self.api.play_sound(self._spec.world.hit_sound)
+            self._core.play_sound(self._spec.world.hit_sound)
 
         for obj in self._objs_in_front_of_player():
             if obj.script is None:

engine/scripts.py

@@ -37,6 +37,18 @@ class KeyPoint:
     properties: Dict[str, Any]
 
 
+class Entity(Protocol):
+    """Defines something in the game: a player, a monster, etc."""
+
+    @property
+    def name(self) -> str:
+        """Gets the name of this entity."""
+
+
+class Player(Protocol):
+    """Represents the player to scripts."""
+
+
 # A type that receives events when they are triggered.
 # Note that while this uses `Any`, all custom events defined by the engine use proper
 # types and any events defined by games are encouraged to do so as well. An event
@@ -62,7 +74,7 @@ def create_sprite(
         name: str,
         start_location: Tuple[float, float],
         script: "Optional[Script]",
-    ) -> None:
+    ) -> Entity:
         """Creates a sprite."""
 
     def get_key_points(self, name: Optional[str] = None) -> Iterable[KeyPoint]:
@@ -149,14 +161,6 @@ def custom_animation(self, value: Optional[str]) -> None:
         """Sets the custom animation of the script owner."""
 
 
-class Entity(Protocol):
-    """Defines something in the game: a player, a monster, etc."""
-
-
-class Player(Protocol):
-    """Represents the player to scripts."""
-
-
 class Script:
     """Base class for all scripts."""
 

pylint.toml

@@ -372,7 +372,7 @@ disable = [
     "suppressed-message", "useless-suppression", "deprecated-pragma",
     "use-symbolic-message-instead", "missing-module-docstring", "unspecified-encoding",
     "too-many-instance-attributes", "too-many-branches", "too-few-public-methods",
-    "too-many-locals", "too-many-arguments"
+    "too-many-locals", "too-many-arguments", "too-many-public-methods",
 ]
 
 # Enable the message, report, category or checker with the given id(s). You can