1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Defines a capture-the-flag game."""
  4
  5# ba_meta require api 7
  6# (see https://ballistica.net/wiki/meta-tag-system)
  7
  8from __future__ import annotations
  9
 10from typing import TYPE_CHECKING
 11
 12import ba
 13from bastd.actor.playerspaz import PlayerSpaz
 14from bastd.actor.scoreboard import Scoreboard
 15from bastd.actor.flag import (
 16    FlagFactory,
 17    Flag,
 18    FlagPickedUpMessage,
 19    FlagDroppedMessage,
 20    FlagDiedMessage,
 21)
 22
 23if TYPE_CHECKING:
 24    from typing import Any, Sequence
 25
 26
 27class CTFFlag(Flag):
 28    """Special flag type for CTF games."""
 29
 30    activity: CaptureTheFlagGame
 31
 32    def __init__(self, team: Team):
 33        assert team.flagmaterial is not None
 34        super().__init__(
 35            materials=[team.flagmaterial],
 36            position=team.base_pos,
 37            color=team.color,
 38        )
 39        self._team = team
 40        self.held_count = 0
 41        self.counter = ba.newnode(
 42            'text',
 43            owner=self.node,
 44            attrs={'in_world': True, 'scale': 0.02, 'h_align': 'center'},
 45        )
 46        self.reset_return_times()
 47        self.last_player_to_hold: Player | None = None
 48        self.time_out_respawn_time: int | None = None
 49        self.touch_return_time: float | None = None
 50
 51    def reset_return_times(self) -> None:
 52        """Clear flag related times in the activity."""
 53        self.time_out_respawn_time = int(self.activity.flag_idle_return_time)
 54        self.touch_return_time = float(self.activity.flag_touch_return_time)
 55
 56    @property
 57    def team(self) -> Team:
 58        """The flag's team."""
 59        return self._team
 60
 61
 62class Player(ba.Player['Team']):
 63    """Our player type for this game."""
 64
 65    def __init__(self) -> None:
 66        self.touching_own_flag = 0
 67
 68
 69class Team(ba.Team[Player]):
 70    """Our team type for this game."""
 71
 72    def __init__(
 73        self,
 74        base_pos: Sequence[float],
 75        base_region_material: ba.Material,
 76        base_region: ba.Node,
 77        spaz_material_no_flag_physical: ba.Material,
 78        spaz_material_no_flag_collide: ba.Material,
 79        flagmaterial: ba.Material,
 80    ):
 81        self.base_pos = base_pos
 82        self.base_region_material = base_region_material
 83        self.base_region = base_region
 84        self.spaz_material_no_flag_physical = spaz_material_no_flag_physical
 85        self.spaz_material_no_flag_collide = spaz_material_no_flag_collide
 86        self.flagmaterial = flagmaterial
 87        self.score = 0
 88        self.flag_return_touches = 0
 89        self.home_flag_at_base = True
 90        self.touch_return_timer: ba.Timer | None = None
 91        self.enemy_flag_at_base = False
 92        self.flag: CTFFlag | None = None
 93        self.last_flag_leave_time: float | None = None
 94        self.touch_return_timer_ticking: ba.NodeActor | None = None
 95
 96
 97# ba_meta export game
 98class CaptureTheFlagGame(ba.TeamGameActivity[Player, Team]):
 99    """Game of stealing other team's flag and returning it to your base."""
100
101    name = 'Capture the Flag'
102    description = 'Return the enemy flag to score.'
103    available_settings = [
104        ba.IntSetting('Score to Win', min_value=1, default=3),
105        ba.IntSetting(
106            'Flag Touch Return Time',
107            min_value=0,
108            default=0,
109            increment=1,
110        ),
111        ba.IntSetting(
112            'Flag Idle Return Time',
113            min_value=5,
114            default=30,
115            increment=5,
116        ),
117        ba.IntChoiceSetting(
118            'Time Limit',
119            choices=[
120                ('None', 0),
121                ('1 Minute', 60),
122                ('2 Minutes', 120),
123                ('5 Minutes', 300),
124                ('10 Minutes', 600),
125                ('20 Minutes', 1200),
126            ],
127            default=0,
128        ),
129        ba.FloatChoiceSetting(
130            'Respawn Times',
131            choices=[
132                ('Shorter', 0.25),
133                ('Short', 0.5),
134                ('Normal', 1.0),
135                ('Long', 2.0),
136                ('Longer', 4.0),
137            ],
138            default=1.0,
139        ),
140        ba.BoolSetting('Epic Mode', default=False),
141    ]
142
143    @classmethod
144    def supports_session_type(cls, sessiontype: type[ba.Session]) -> bool:
145        return issubclass(sessiontype, ba.DualTeamSession)
146
147    @classmethod
148    def get_supported_maps(cls, sessiontype: type[ba.Session]) -> list[str]:
149        return ba.getmaps('team_flag')
150
151    def __init__(self, settings: dict):
152        super().__init__(settings)
153        self._scoreboard = Scoreboard()
154        self._alarmsound = ba.getsound('alarm')
155        self._ticking_sound = ba.getsound('ticking')
156        self._score_sound = ba.getsound('score')
157        self._swipsound = ba.getsound('swip')
158        self._last_score_time = 0
159        self._all_bases_material = ba.Material()
160        self._last_home_flag_notice_print_time = 0.0
161        self._score_to_win = int(settings['Score to Win'])
162        self._epic_mode = bool(settings['Epic Mode'])
163        self._time_limit = float(settings['Time Limit'])
164
165        self.flag_touch_return_time = float(settings['Flag Touch Return Time'])
166        self.flag_idle_return_time = float(settings['Flag Idle Return Time'])
167
168        # Base class overrides.
169        self.slow_motion = self._epic_mode
170        self.default_music = (
171            ba.MusicType.EPIC if self._epic_mode else ba.MusicType.FLAG_CATCHER
172        )
173
174    def get_instance_description(self) -> str | Sequence:
175        if self._score_to_win == 1:
176            return 'Steal the enemy flag.'
177        return 'Steal the enemy flag ${ARG1} times.', self._score_to_win
178
179    def get_instance_description_short(self) -> str | Sequence:
180        if self._score_to_win == 1:
181            return 'return 1 flag'
182        return 'return ${ARG1} flags', self._score_to_win
183
184    def create_team(self, sessionteam: ba.SessionTeam) -> Team:
185
186        # Create our team instance and its initial values.
187
188        base_pos = self.map.get_flag_position(sessionteam.id)
189        Flag.project_stand(base_pos)
190
191        ba.newnode(
192            'light',
193            attrs={
194                'position': base_pos,
195                'intensity': 0.6,
196                'height_attenuated': False,
197                'volume_intensity_scale': 0.1,
198                'radius': 0.1,
199                'color': sessionteam.color,
200            },
201        )
202
203        base_region_mat = ba.Material()
204        pos = base_pos
205        base_region = ba.newnode(
206            'region',
207            attrs={
208                'position': (pos[0], pos[1] + 0.75, pos[2]),
209                'scale': (0.5, 0.5, 0.5),
210                'type': 'sphere',
211                'materials': [base_region_mat, self._all_bases_material],
212            },
213        )
214
215        spaz_mat_no_flag_physical = ba.Material()
216        spaz_mat_no_flag_collide = ba.Material()
217        flagmat = ba.Material()
218
219        team = Team(
220            base_pos=base_pos,
221            base_region_material=base_region_mat,
222            base_region=base_region,
223            spaz_material_no_flag_physical=spaz_mat_no_flag_physical,
224            spaz_material_no_flag_collide=spaz_mat_no_flag_collide,
225            flagmaterial=flagmat,
226        )
227
228        # Some parts of our spazzes don't collide physically with our
229        # flags but generate callbacks.
230        spaz_mat_no_flag_physical.add_actions(
231            conditions=('they_have_material', flagmat),
232            actions=(
233                ('modify_part_collision', 'physical', False),
234                (
235                    'call',
236                    'at_connect',
237                    lambda: self._handle_touching_own_flag(team, True),
238                ),
239                (
240                    'call',
241                    'at_disconnect',
242                    lambda: self._handle_touching_own_flag(team, False),
243                ),
244            ),
245        )
246
247        # Other parts of our spazzes don't collide with our flags at all.
248        spaz_mat_no_flag_collide.add_actions(
249            conditions=('they_have_material', flagmat),
250            actions=('modify_part_collision', 'collide', False),
251        )
252
253        # We wanna know when *any* flag enters/leaves our base.
254        base_region_mat.add_actions(
255            conditions=('they_have_material', FlagFactory.get().flagmaterial),
256            actions=(
257                ('modify_part_collision', 'collide', True),
258                ('modify_part_collision', 'physical', False),
259                (
260                    'call',
261                    'at_connect',
262                    lambda: self._handle_flag_entered_base(team),
263                ),
264                (
265                    'call',
266                    'at_disconnect',
267                    lambda: self._handle_flag_left_base(team),
268                ),
269            ),
270        )
271
272        return team
273
274    def on_team_join(self, team: Team) -> None:
275        # Can't do this in create_team because the team's color/etc. have
276        # not been wired up yet at that point.
277        self._spawn_flag_for_team(team)
278        self._update_scoreboard()
279
280    def on_begin(self) -> None:
281        super().on_begin()
282        self.setup_standard_time_limit(self._time_limit)
283        self.setup_standard_powerup_drops()
284        ba.timer(1.0, call=self._tick, repeat=True)
285
286    def _spawn_flag_for_team(self, team: Team) -> None:
287        team.flag = CTFFlag(team)
288        team.flag_return_touches = 0
289        self._flash_base(team, length=1.0)
290        assert team.flag.node
291        ba.playsound(self._swipsound, position=team.flag.node.position)
292
293    def _handle_flag_entered_base(self, team: Team) -> None:
294        try:
295            flag = ba.getcollision().opposingnode.getdelegate(CTFFlag, True)
296        except ba.NotFoundError:
297            # Don't think this should logically ever happen.
298            print('Error getting CTFFlag in entering-base callback.')
299            return
300
301        if flag.team is team:
302            team.home_flag_at_base = True
303
304            # If the enemy flag is already here, score!
305            if team.enemy_flag_at_base:
306                # And show team name which scored (but actually we could
307                # show here player who returned enemy flag).
308                self.show_zoom_message(
309                    ba.Lstr(
310                        resource='nameScoresText', subs=[('${NAME}', team.name)]
311                    ),
312                    color=team.color,
313                )
314                self._score(team)
315        else:
316            team.enemy_flag_at_base = True
317            if team.home_flag_at_base:
318                # Award points to whoever was carrying the enemy flag.
319                player = flag.last_player_to_hold
320                if player and player.team is team:
321                    assert self.stats
322                    self.stats.player_scored(player, 50, big_message=True)
323
324                # Update score and reset flags.
325                self._score(team)
326
327            # If the home-team flag isn't here, print a message to that effect.
328            else:
329                # Don't want slo-mo affecting this
330                curtime = ba.time(ba.TimeType.BASE)
331                if curtime - self._last_home_flag_notice_print_time > 5.0:
332                    self._last_home_flag_notice_print_time = curtime
333                    bpos = team.base_pos
334                    tval = ba.Lstr(resource='ownFlagAtYourBaseWarning')
335                    tnode = ba.newnode(
336                        'text',
337                        attrs={
338                            'text': tval,
339                            'in_world': True,
340                            'scale': 0.013,
341                            'color': (1, 1, 0, 1),
342                            'h_align': 'center',
343                            'position': (bpos[0], bpos[1] + 3.2, bpos[2]),
344                        },
345                    )
346                    ba.timer(5.1, tnode.delete)
347                    ba.animate(
348                        tnode, 'scale', {0.0: 0, 0.2: 0.013, 4.8: 0.013, 5.0: 0}
349                    )
350
351    def _tick(self) -> None:
352        # If either flag is away from base and not being held, tick down its
353        # respawn timer.
354        for team in self.teams:
355            flag = team.flag
356            assert flag is not None
357
358            if not team.home_flag_at_base and flag.held_count == 0:
359                time_out_counting_down = True
360                if flag.time_out_respawn_time is None:
361                    flag.reset_return_times()
362                assert flag.time_out_respawn_time is not None
363                flag.time_out_respawn_time -= 1
364                if flag.time_out_respawn_time <= 0:
365                    flag.handlemessage(ba.DieMessage())
366            else:
367                time_out_counting_down = False
368
369            if flag.node and flag.counter:
370                pos = flag.node.position
371                flag.counter.position = (pos[0], pos[1] + 1.3, pos[2])
372
373                # If there's no self-touches on this flag, set its text
374                # to show its auto-return counter.  (if there's self-touches
375                # its showing that time).
376                if team.flag_return_touches == 0:
377                    flag.counter.text = (
378                        str(flag.time_out_respawn_time)
379                        if (
380                            time_out_counting_down
381                            and flag.time_out_respawn_time is not None
382                            and flag.time_out_respawn_time <= 10
383                        )
384                        else ''
385                    )
386                    flag.counter.color = (1, 1, 1, 0.5)
387                    flag.counter.scale = 0.014
388
389    def _score(self, team: Team) -> None:
390        team.score += 1
391        ba.playsound(self._score_sound)
392        self._flash_base(team)
393        self._update_scoreboard()
394
395        # Have teammates celebrate.
396        for player in team.players:
397            if player.actor:
398                player.actor.handlemessage(ba.CelebrateMessage(2.0))
399
400        # Reset all flags/state.
401        for reset_team in self.teams:
402            if not reset_team.home_flag_at_base:
403                assert reset_team.flag is not None
404                reset_team.flag.handlemessage(ba.DieMessage())
405            reset_team.enemy_flag_at_base = False
406        if team.score >= self._score_to_win:
407            self.end_game()
408
409    def end_game(self) -> None:
410        results = ba.GameResults()
411        for team in self.teams:
412            results.set_team_score(team, team.score)
413        self.end(results=results, announce_delay=0.8)
414
415    def _handle_flag_left_base(self, team: Team) -> None:
416        cur_time = ba.time()
417        try:
418            flag = ba.getcollision().opposingnode.getdelegate(CTFFlag, True)
419        except ba.NotFoundError:
420            # This can happen if the flag stops touching us due to being
421            # deleted; that's ok.
422            return
423
424        if flag.team is team:
425
426            # Check times here to prevent too much flashing.
427            if (
428                team.last_flag_leave_time is None
429                or cur_time - team.last_flag_leave_time > 3.0
430            ):
431                ba.playsound(self._alarmsound, position=team.base_pos)
432                self._flash_base(team)
433            team.last_flag_leave_time = cur_time
434            team.home_flag_at_base = False
435        else:
436            team.enemy_flag_at_base = False
437
438    def _touch_return_update(self, team: Team) -> None:
439        # Count down only while its away from base and not being held.
440        assert team.flag is not None
441        if team.home_flag_at_base or team.flag.held_count > 0:
442            team.touch_return_timer_ticking = None
443            return  # No need to return when its at home.
444        if team.touch_return_timer_ticking is None:
445            team.touch_return_timer_ticking = ba.NodeActor(
446                ba.newnode(
447                    'sound',
448                    attrs={
449                        'sound': self._ticking_sound,
450                        'positional': False,
451                        'loop': True,
452                    },
453                )
454            )
455        flag = team.flag
456        if flag.touch_return_time is not None:
457            flag.touch_return_time -= 0.1
458            if flag.counter:
459                flag.counter.text = f'{flag.touch_return_time:.1f}'
460                flag.counter.color = (1, 1, 0, 1)
461                flag.counter.scale = 0.02
462
463            if flag.touch_return_time <= 0.0:
464                self._award_players_touching_own_flag(team)
465                flag.handlemessage(ba.DieMessage())
466
467    def _award_players_touching_own_flag(self, team: Team) -> None:
468        for player in team.players:
469            if player.touching_own_flag > 0:
470                return_score = 10 + 5 * int(self.flag_touch_return_time)
471                self.stats.player_scored(
472                    player, return_score, screenmessage=False
473                )
474
475    def _handle_touching_own_flag(self, team: Team, connecting: bool) -> None:
476        """Called when a player touches or stops touching their own team flag.
477
478        We keep track of when each player is touching their own flag so we
479        can award points when returned.
480        """
481        player: Player | None
482        try:
483            spaz = ba.getcollision().sourcenode.getdelegate(PlayerSpaz, True)
484        except ba.NotFoundError:
485            return
486
487        if not spaz.is_alive():
488            return
489
490        player = spaz.getplayer(Player, True)
491
492        if player:
493            player.touching_own_flag += 1 if connecting else -1
494
495        # If return-time is zero, just kill it immediately.. otherwise keep
496        # track of touches and count down.
497        if float(self.flag_touch_return_time) <= 0.0:
498            assert team.flag is not None
499            if (
500                connecting
501                and not team.home_flag_at_base
502                and team.flag.held_count == 0
503            ):
504                self._award_players_touching_own_flag(team)
505                ba.getcollision().opposingnode.handlemessage(ba.DieMessage())
506
507        # Takes a non-zero amount of time to return.
508        else:
509            if connecting:
510                team.flag_return_touches += 1
511                if team.flag_return_touches == 1:
512                    team.touch_return_timer = ba.Timer(
513                        0.1,
514                        call=ba.Call(self._touch_return_update, team),
515                        repeat=True,
516                    )
517                    team.touch_return_timer_ticking = None
518            else:
519                team.flag_return_touches -= 1
520                if team.flag_return_touches == 0:
521                    team.touch_return_timer = None
522                    team.touch_return_timer_ticking = None
523            if team.flag_return_touches < 0:
524                ba.print_error('CTF flag_return_touches < 0')
525
526    def _flash_base(self, team: Team, length: float = 2.0) -> None:
527        light = ba.newnode(
528            'light',
529            attrs={
530                'position': team.base_pos,
531                'height_attenuated': False,
532                'radius': 0.3,
533                'color': team.color,
534            },
535        )
536        ba.animate(light, 'intensity', {0.0: 0, 0.25: 2.0, 0.5: 0}, loop=True)
537        ba.timer(length, light.delete)
538
539    def spawn_player_spaz(
540        self,
541        player: Player,
542        position: Sequence[float] | None = None,
543        angle: float | None = None,
544    ) -> PlayerSpaz:
545        """Intercept new spazzes and add our team material for them."""
546        spaz = super().spawn_player_spaz(player, position, angle)
547        player = spaz.getplayer(Player, True)
548        team: Team = player.team
549        player.touching_own_flag = 0
550        no_physical_mats: list[ba.Material] = [
551            team.spaz_material_no_flag_physical
552        ]
553        no_collide_mats: list[ba.Material] = [
554            team.spaz_material_no_flag_collide
555        ]
556
557        # Our normal parts should still collide; just not physically
558        # (so we can calc restores).
559        assert spaz.node
560        spaz.node.materials = list(spaz.node.materials) + no_physical_mats
561        spaz.node.roller_materials = (
562            list(spaz.node.roller_materials) + no_physical_mats
563        )
564
565        # Pickups and punches shouldn't hit at all though.
566        spaz.node.punch_materials = (
567            list(spaz.node.punch_materials) + no_collide_mats
568        )
569        spaz.node.pickup_materials = (
570            list(spaz.node.pickup_materials) + no_collide_mats
571        )
572        spaz.node.extras_material = (
573            list(spaz.node.extras_material) + no_collide_mats
574        )
575        return spaz
576
577    def _update_scoreboard(self) -> None:
578        for team in self.teams:
579            self._scoreboard.set_team_value(
580                team, team.score, self._score_to_win
581            )
582
583    def handlemessage(self, msg: Any) -> Any:
584
585        if isinstance(msg, ba.PlayerDiedMessage):
586            super().handlemessage(msg)  # Augment standard behavior.
587            self.respawn_player(msg.getplayer(Player))
588
589        elif isinstance(msg, FlagDiedMessage):
590            assert isinstance(msg.flag, CTFFlag)
591            ba.timer(0.1, ba.Call(self._spawn_flag_for_team, msg.flag.team))
592
593        elif isinstance(msg, FlagPickedUpMessage):
594
595            # Store the last player to hold the flag for scoring purposes.
596            assert isinstance(msg.flag, CTFFlag)
597            try:
598                msg.flag.last_player_to_hold = msg.node.getdelegate(
599                    PlayerSpaz, True
600                ).getplayer(Player, True)
601            except ba.NotFoundError:
602                pass
603
604            msg.flag.held_count += 1
605            msg.flag.reset_return_times()
606
607        elif isinstance(msg, FlagDroppedMessage):
608            # Store the last player to hold the flag for scoring purposes.
609            assert isinstance(msg.flag, CTFFlag)
610            msg.flag.held_count -= 1
611
612        else:
613            super().handlemessage(msg)