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