bascenev1lib.actor.flag

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Implements a flag used for marking bases, capture-the-flag games, etc."""
  4
  5from __future__ import annotations
  6
  7from dataclasses import dataclass
  8from typing import TYPE_CHECKING, override
  9
 10import bascenev1 as bs
 11
 12from bascenev1lib.gameutils import SharedObjects
 13
 14if TYPE_CHECKING:
 15    from typing import Any, Sequence
 16
 17
 18class FlagFactory:
 19    """Wraps up media and other resources used by `Flag`s.
 20
 21    A single instance of this is shared between all flags
 22    and can be retrieved via FlagFactory.get().
 23    """
 24
 25    flagmaterial: bs.Material
 26    """The bs.Material applied to all `Flag`s."""
 27
 28    impact_sound: bs.Sound
 29    """The bs.Sound used when a `Flag` hits the ground."""
 30
 31    skid_sound: bs.Sound
 32    """The bs.Sound used when a `Flag` skids along the ground."""
 33
 34    no_hit_material: bs.Material
 35    """A bs.Material that prevents contact with most objects;
 36       applied to 'non-touchable' flags."""
 37
 38    flag_texture: bs.Texture
 39    """The bs.Texture for flags."""
 40
 41    _STORENAME = bs.storagename()
 42
 43    def __init__(self) -> None:
 44        """Instantiate a `FlagFactory`.
 45
 46        You shouldn't need to do this; call FlagFactory.get() to
 47        get a shared instance.
 48        """
 49        shared = SharedObjects.get()
 50        self.flagmaterial = bs.Material()
 51        self.flagmaterial.add_actions(
 52            conditions=(
 53                ('we_are_younger_than', 100),
 54                'and',
 55                ('they_have_material', shared.object_material),
 56            ),
 57            actions=('modify_node_collision', 'collide', False),
 58        )
 59
 60        self.flagmaterial.add_actions(
 61            conditions=(
 62                'they_have_material',
 63                shared.footing_material,
 64            ),
 65            actions=(
 66                ('message', 'our_node', 'at_connect', 'footing', 1),
 67                ('message', 'our_node', 'at_disconnect', 'footing', -1),
 68            ),
 69        )
 70
 71        self.impact_sound = bs.getsound('metalHit')
 72        self.skid_sound = bs.getsound('metalSkid')
 73        self.flagmaterial.add_actions(
 74            conditions=(
 75                'they_have_material',
 76                shared.footing_material,
 77            ),
 78            actions=(
 79                ('impact_sound', self.impact_sound, 2, 5),
 80                ('skid_sound', self.skid_sound, 2, 5),
 81            ),
 82        )
 83
 84        self.no_hit_material = bs.Material()
 85        self.no_hit_material.add_actions(
 86            conditions=(
 87                ('they_have_material', shared.pickup_material),
 88                'or',
 89                ('they_have_material', shared.attack_material),
 90            ),
 91            actions=('modify_part_collision', 'collide', False),
 92        )
 93
 94        # We also don't want anything moving it.
 95        self.no_hit_material.add_actions(
 96            conditions=(
 97                ('they_have_material', shared.object_material),
 98                'or',
 99                ('they_dont_have_material', shared.footing_material),
100            ),
101            actions=(
102                ('modify_part_collision', 'collide', False),
103                ('modify_part_collision', 'physical', False),
104            ),
105        )
106
107        self.flag_texture = bs.gettexture('flagColor')
108
109    @classmethod
110    def get(cls) -> FlagFactory:
111        """Get/create a shared `FlagFactory` instance."""
112        activity = bs.getactivity()
113        factory = activity.customdata.get(cls._STORENAME)
114        if factory is None:
115            factory = FlagFactory()
116            activity.customdata[cls._STORENAME] = factory
117        assert isinstance(factory, FlagFactory)
118        return factory
119
120
121@dataclass
122class FlagPickedUpMessage:
123    """A message saying a `Flag` has been picked up."""
124
125    flag: Flag
126    """The `Flag` that has been picked up."""
127
128    node: bs.Node
129    """The bs.Node doing the picking up."""
130
131
132@dataclass
133class FlagDiedMessage:
134    """A message saying a `Flag` has died."""
135
136    flag: Flag
137    """The `Flag` that died."""
138
139    self_kill: bool = False
140    """If the `Flag` killed itself or not."""
141
142
143@dataclass
144class FlagDroppedMessage:
145    """A message saying a `Flag` has been dropped."""
146
147    flag: Flag
148    """The `Flag` that was dropped."""
149
150    node: bs.Node
151    """The bs.Node that was holding it."""
152
153
154class Flag(bs.Actor):
155    """A flag; used in games such as capture-the-flag or king-of-the-hill.
156
157    Can be stationary or carry-able by players.
158    """
159
160    def __init__(
161        self,
162        *,
163        position: Sequence[float] = (0.0, 1.0, 0.0),
164        color: Sequence[float] = (1.0, 1.0, 1.0),
165        materials: Sequence[bs.Material] | None = None,
166        touchable: bool = True,
167        dropped_timeout: int | None = None,
168    ):
169        """Instantiate a flag.
170
171        If 'touchable' is False, the flag will only touch terrain;
172        useful for things like king-of-the-hill where players should
173        not be moving the flag around.
174
175        'materials can be a list of extra `bs.Material`s to apply to the flag.
176
177        If 'dropped_timeout' is provided (in seconds), the flag will die
178        after remaining untouched for that long once it has been moved
179        from its initial position.
180        """
181
182        super().__init__()
183
184        self._initial_position: Sequence[float] | None = None
185        self._has_moved = False
186        shared = SharedObjects.get()
187        factory = FlagFactory.get()
188
189        if materials is None:
190            materials = []
191        elif not isinstance(materials, list):
192            # In case they passed a tuple or whatnot.
193            materials = list(materials)
194        if not touchable:
195            materials = [factory.no_hit_material] + materials
196
197        finalmaterials = [
198            shared.object_material,
199            factory.flagmaterial,
200        ] + materials
201        self.node = bs.newnode(
202            'flag',
203            attrs={
204                'position': (position[0], position[1] + 0.75, position[2]),
205                'color_texture': factory.flag_texture,
206                'color': color,
207                'materials': finalmaterials,
208            },
209            delegate=self,
210        )
211
212        if dropped_timeout is not None:
213            dropped_timeout = int(dropped_timeout)
214        self._dropped_timeout = dropped_timeout
215        self._counter: bs.Node | None
216        if self._dropped_timeout is not None:
217            self._count = self._dropped_timeout
218            self._tick_timer = bs.Timer(
219                1.0, call=bs.WeakCall(self._tick), repeat=True
220            )
221            self._counter = bs.newnode(
222                'text',
223                owner=self.node,
224                attrs={
225                    'in_world': True,
226                    'color': (1, 1, 1, 0.7),
227                    'scale': 0.015,
228                    'shadow': 0.5,
229                    'flatness': 1.0,
230                    'h_align': 'center',
231                },
232            )
233        else:
234            self._counter = None
235
236        self._held_count = 0
237        self._score_text: bs.Node | None = None
238        self._score_text_hide_timer: bs.Timer | None = None
239
240    def _tick(self) -> None:
241        if self.node:
242            # Grab our initial position after one tick (in case we fall).
243            if self._initial_position is None:
244                self._initial_position = self.node.position
245
246                # Keep track of when we first move; we don't count down
247                # until then.
248            if not self._has_moved:
249                nodepos = self.node.position
250                if (
251                    max(
252                        abs(nodepos[i] - self._initial_position[i])
253                        for i in list(range(3))
254                    )
255                    > 1.0
256                ):
257                    self._has_moved = True
258
259            if self._held_count > 0 or not self._has_moved:
260                assert self._dropped_timeout is not None
261                assert self._counter
262                self._count = self._dropped_timeout
263                self._counter.text = ''
264            else:
265                self._count -= 1
266                if self._count <= 10:
267                    nodepos = self.node.position
268                    assert self._counter
269                    self._counter.position = (
270                        nodepos[0],
271                        nodepos[1] + 1.3,
272                        nodepos[2],
273                    )
274                    self._counter.text = str(self._count)
275                    if self._count < 1:
276                        self.handlemessage(
277                            bs.DieMessage(how=bs.DeathType.LEFT_GAME)
278                        )
279                else:
280                    assert self._counter
281                    self._counter.text = ''
282
283    def _hide_score_text(self) -> None:
284        assert self._score_text is not None
285        assert isinstance(self._score_text.scale, float)
286        bs.animate(
287            self._score_text, 'scale', {0: self._score_text.scale, 0.2: 0}
288        )
289
290    def set_score_text(self, text: str) -> None:
291        """Show a message over the flag; handy for scores."""
292        if not self.node:
293            return
294        if not self._score_text:
295            start_scale = 0.0
296            math = bs.newnode(
297                'math',
298                owner=self.node,
299                attrs={'input1': (0, 1.4, 0), 'operation': 'add'},
300            )
301            self.node.connectattr('position', math, 'input2')
302            self._score_text = bs.newnode(
303                'text',
304                owner=self.node,
305                attrs={
306                    'text': text,
307                    'in_world': True,
308                    'scale': 0.02,
309                    'shadow': 0.5,
310                    'flatness': 1.0,
311                    'h_align': 'center',
312                },
313            )
314            math.connectattr('output', self._score_text, 'position')
315        else:
316            assert isinstance(self._score_text.scale, float)
317            start_scale = self._score_text.scale
318            self._score_text.text = text
319        self._score_text.color = bs.safecolor(self.node.color)
320        bs.animate(self._score_text, 'scale', {0: start_scale, 0.2: 0.02})
321        self._score_text_hide_timer = bs.Timer(
322            1.0, bs.WeakCall(self._hide_score_text)
323        )
324
325    @override
326    def handlemessage(self, msg: Any) -> Any:
327        assert not self.expired
328        if isinstance(msg, bs.DieMessage):
329            if self.node:
330                self.node.delete()
331                if not msg.immediate:
332                    self.activity.handlemessage(
333                        FlagDiedMessage(
334                            self, (msg.how is bs.DeathType.LEFT_GAME)
335                        )
336                    )
337        elif isinstance(msg, bs.HitMessage):
338            assert self.node
339            assert msg.force_direction is not None
340            self.node.handlemessage(
341                'impulse',
342                msg.pos[0],
343                msg.pos[1],
344                msg.pos[2],
345                msg.velocity[0],
346                msg.velocity[1],
347                msg.velocity[2],
348                msg.magnitude,
349                msg.velocity_magnitude,
350                msg.radius,
351                0,
352                msg.force_direction[0],
353                msg.force_direction[1],
354                msg.force_direction[2],
355            )
356        elif isinstance(msg, bs.PickedUpMessage):
357            self._held_count += 1
358            if self._held_count == 1 and self._counter is not None:
359                self._counter.text = ''
360            self.activity.handlemessage(FlagPickedUpMessage(self, msg.node))
361        elif isinstance(msg, bs.DroppedMessage):
362            self._held_count -= 1
363            if self._held_count < 0:
364                print('Flag held count < 0.')
365                self._held_count = 0
366            self.activity.handlemessage(FlagDroppedMessage(self, msg.node))
367        else:
368            super().handlemessage(msg)
369
370    @staticmethod
371    def project_stand(pos: Sequence[float]) -> None:
372        """Project a flag-stand onto the ground at the given position.
373
374        Useful for games such as capture-the-flag to show where a
375        movable flag originated from.
376        """
377        assert len(pos) == 3
378        bs.emitfx(position=pos, emit_type='flag_stand')