bascenev1lib.actor.spawner

Defines some lovely Actor(s).

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Defines some lovely Actor(s)."""
  4
  5from __future__ import annotations
  6
  7from typing import TYPE_CHECKING
  8
  9import bascenev1 as bs
 10
 11if TYPE_CHECKING:
 12    from typing import Any, Sequence, Callable
 13
 14
 15# FIXME: Should make this an Actor.
 16class Spawner:
 17    """Utility for delayed spawning of objects.
 18
 19    Creates a light flash and sends a Spawner.SpawnMessage to the
 20    current activity after a delay.
 21    """
 22
 23    class SpawnMessage:
 24        """Spawn message sent by a Spawner after its delay has passed."""
 25
 26        spawner: Spawner
 27        """The bascenev1.Spawner we came from."""
 28
 29        data: Any
 30        """The data object passed by the user."""
 31
 32        pt: Sequence[float]
 33        """The spawn position."""
 34
 35        def __init__(
 36            self,
 37            spawner: Spawner,
 38            data: Any,
 39            pt: Sequence[float],
 40        ):
 41            """Instantiate with the given values."""
 42            self.spawner = spawner
 43            self.data = data
 44            self.pt = pt
 45
 46    def __init__(
 47        self,
 48        *,
 49        data: Any = None,
 50        pt: Sequence[float] = (0, 0, 0),
 51        spawn_time: float = 1.0,
 52        send_spawn_message: bool = True,
 53        spawn_callback: Callable[[], Any] | None = None,
 54    ):
 55        """Instantiate a Spawner.
 56
 57        Requires some custom data, a position,
 58        and a spawn-time in seconds.
 59        """
 60        self._spawn_callback = spawn_callback
 61        self._send_spawn_message = send_spawn_message
 62        self._spawner_sound = bs.getsound('swip2')
 63        self._data = data
 64        self._pt = pt
 65        # create a light where the spawn will happen
 66        self._light = bs.newnode(
 67            'light',
 68            attrs={
 69                'position': tuple(pt),
 70                'radius': 0.1,
 71                'color': (1.0, 0.1, 0.1),
 72                'lights_volumes': False,
 73            },
 74        )
 75        scl = float(spawn_time) / 3.75
 76        min_val = 0.4
 77        max_val = 0.7
 78        self._spawner_sound.play(position=self._light.position)
 79        bs.animate(
 80            self._light,
 81            'intensity',
 82            {
 83                0.0: 0.0,
 84                0.25 * scl: max_val,
 85                0.500 * scl: min_val,
 86                0.750 * scl: max_val,
 87                1.000 * scl: min_val,
 88                1.250 * scl: 1.1 * max_val,
 89                1.500 * scl: min_val,
 90                1.750 * scl: 1.2 * max_val,
 91                2.000 * scl: min_val,
 92                2.250 * scl: 1.3 * max_val,
 93                2.500 * scl: min_val,
 94                2.750 * scl: 1.4 * max_val,
 95                3.000 * scl: min_val,
 96                3.250 * scl: 1.5 * max_val,
 97                3.500 * scl: min_val,
 98                3.750 * scl: 2.0,
 99                4.000 * scl: 0.0,
100            },
101        )
102        bs.timer(spawn_time, self._spawn)
103
104    def _spawn(self) -> None:
105        bs.timer(1.0, self._light.delete)
106        if self._spawn_callback is not None:
107            self._spawn_callback()
108        if self._send_spawn_message:
109            # only run if our activity still exists
110            activity = bs.getactivity()
111            if activity is not None:
112                activity.handlemessage(
113                    self.SpawnMessage(self, self._data, self._pt)
114                )
class Spawner:
 17class Spawner:
 18    """Utility for delayed spawning of objects.
 19
 20    Creates a light flash and sends a Spawner.SpawnMessage to the
 21    current activity after a delay.
 22    """
 23
 24    class SpawnMessage:
 25        """Spawn message sent by a Spawner after its delay has passed."""
 26
 27        spawner: Spawner
 28        """The bascenev1.Spawner we came from."""
 29
 30        data: Any
 31        """The data object passed by the user."""
 32
 33        pt: Sequence[float]
 34        """The spawn position."""
 35
 36        def __init__(
 37            self,
 38            spawner: Spawner,
 39            data: Any,
 40            pt: Sequence[float],
 41        ):
 42            """Instantiate with the given values."""
 43            self.spawner = spawner
 44            self.data = data
 45            self.pt = pt
 46
 47    def __init__(
 48        self,
 49        *,
 50        data: Any = None,
 51        pt: Sequence[float] = (0, 0, 0),
 52        spawn_time: float = 1.0,
 53        send_spawn_message: bool = True,
 54        spawn_callback: Callable[[], Any] | None = None,
 55    ):
 56        """Instantiate a Spawner.
 57
 58        Requires some custom data, a position,
 59        and a spawn-time in seconds.
 60        """
 61        self._spawn_callback = spawn_callback
 62        self._send_spawn_message = send_spawn_message
 63        self._spawner_sound = bs.getsound('swip2')
 64        self._data = data
 65        self._pt = pt
 66        # create a light where the spawn will happen
 67        self._light = bs.newnode(
 68            'light',
 69            attrs={
 70                'position': tuple(pt),
 71                'radius': 0.1,
 72                'color': (1.0, 0.1, 0.1),
 73                'lights_volumes': False,
 74            },
 75        )
 76        scl = float(spawn_time) / 3.75
 77        min_val = 0.4
 78        max_val = 0.7
 79        self._spawner_sound.play(position=self._light.position)
 80        bs.animate(
 81            self._light,
 82            'intensity',
 83            {
 84                0.0: 0.0,
 85                0.25 * scl: max_val,
 86                0.500 * scl: min_val,
 87                0.750 * scl: max_val,
 88                1.000 * scl: min_val,
 89                1.250 * scl: 1.1 * max_val,
 90                1.500 * scl: min_val,
 91                1.750 * scl: 1.2 * max_val,
 92                2.000 * scl: min_val,
 93                2.250 * scl: 1.3 * max_val,
 94                2.500 * scl: min_val,
 95                2.750 * scl: 1.4 * max_val,
 96                3.000 * scl: min_val,
 97                3.250 * scl: 1.5 * max_val,
 98                3.500 * scl: min_val,
 99                3.750 * scl: 2.0,
100                4.000 * scl: 0.0,
101            },
102        )
103        bs.timer(spawn_time, self._spawn)
104
105    def _spawn(self) -> None:
106        bs.timer(1.0, self._light.delete)
107        if self._spawn_callback is not None:
108            self._spawn_callback()
109        if self._send_spawn_message:
110            # only run if our activity still exists
111            activity = bs.getactivity()
112            if activity is not None:
113                activity.handlemessage(
114                    self.SpawnMessage(self, self._data, self._pt)
115                )

Utility for delayed spawning of objects.

Creates a light flash and sends a Spawner.SpawnMessage to the current activity after a delay.

Spawner( *, data: Any = None, pt: Sequence[float] = (0, 0, 0), spawn_time: float = 1.0, send_spawn_message: bool = True, spawn_callback: Optional[Callable[[], Any]] = None)
 47    def __init__(
 48        self,
 49        *,
 50        data: Any = None,
 51        pt: Sequence[float] = (0, 0, 0),
 52        spawn_time: float = 1.0,
 53        send_spawn_message: bool = True,
 54        spawn_callback: Callable[[], Any] | None = None,
 55    ):
 56        """Instantiate a Spawner.
 57
 58        Requires some custom data, a position,
 59        and a spawn-time in seconds.
 60        """
 61        self._spawn_callback = spawn_callback
 62        self._send_spawn_message = send_spawn_message
 63        self._spawner_sound = bs.getsound('swip2')
 64        self._data = data
 65        self._pt = pt
 66        # create a light where the spawn will happen
 67        self._light = bs.newnode(
 68            'light',
 69            attrs={
 70                'position': tuple(pt),
 71                'radius': 0.1,
 72                'color': (1.0, 0.1, 0.1),
 73                'lights_volumes': False,
 74            },
 75        )
 76        scl = float(spawn_time) / 3.75
 77        min_val = 0.4
 78        max_val = 0.7
 79        self._spawner_sound.play(position=self._light.position)
 80        bs.animate(
 81            self._light,
 82            'intensity',
 83            {
 84                0.0: 0.0,
 85                0.25 * scl: max_val,
 86                0.500 * scl: min_val,
 87                0.750 * scl: max_val,
 88                1.000 * scl: min_val,
 89                1.250 * scl: 1.1 * max_val,
 90                1.500 * scl: min_val,
 91                1.750 * scl: 1.2 * max_val,
 92                2.000 * scl: min_val,
 93                2.250 * scl: 1.3 * max_val,
 94                2.500 * scl: min_val,
 95                2.750 * scl: 1.4 * max_val,
 96                3.000 * scl: min_val,
 97                3.250 * scl: 1.5 * max_val,
 98                3.500 * scl: min_val,
 99                3.750 * scl: 2.0,
100                4.000 * scl: 0.0,
101            },
102        )
103        bs.timer(spawn_time, self._spawn)

Instantiate a Spawner.

Requires some custom data, a position, and a spawn-time in seconds.

class Spawner.SpawnMessage:
24    class SpawnMessage:
25        """Spawn message sent by a Spawner after its delay has passed."""
26
27        spawner: Spawner
28        """The bascenev1.Spawner we came from."""
29
30        data: Any
31        """The data object passed by the user."""
32
33        pt: Sequence[float]
34        """The spawn position."""
35
36        def __init__(
37            self,
38            spawner: Spawner,
39            data: Any,
40            pt: Sequence[float],
41        ):
42            """Instantiate with the given values."""
43            self.spawner = spawner
44            self.data = data
45            self.pt = pt

Spawn message sent by a Spawner after its delay has passed.

Spawner.SpawnMessage( spawner: Spawner, data: Any, pt: Sequence[float])
36        def __init__(
37            self,
38            spawner: Spawner,
39            data: Any,
40            pt: Sequence[float],
41        ):
42            """Instantiate with the given values."""
43            self.spawner = spawner
44            self.data = data
45            self.pt = pt

Instantiate with the given values.

spawner: Spawner

The bascenev1.Spawner we came from.

data: Any

The data object passed by the user.

pt: Sequence[float]

The spawn position.