1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Implements football games (both co-op and teams varieties)."""
  4
  5# ba_meta require api 7
  6# (see https://ballistica.net/wiki/meta-tag-system)
  7
  8from __future__ import annotations
  9
 10import random
 11from typing import TYPE_CHECKING
 12import math
 13
 14import ba
 15from bastd.actor.bomb import TNTSpawner
 16from bastd.actor.playerspaz import PlayerSpaz
 17from bastd.actor.scoreboard import Scoreboard
 18from bastd.actor.respawnicon import RespawnIcon
 19from bastd.actor.powerupbox import PowerupBoxFactory, PowerupBox
 20from bastd.actor.flag import (
 21    FlagFactory,
 22    Flag,
 23    FlagPickedUpMessage,
 24    FlagDroppedMessage,
 25    FlagDiedMessage,
 26)
 27from bastd.actor.spazbot import (
 28    SpazBotDiedMessage,
 29    SpazBotPunchedMessage,
 30    SpazBotSet,
 31    BrawlerBotLite,
 32    BrawlerBot,
 33    BomberBotLite,
 34    BomberBot,
 35    TriggerBot,
 36    ChargerBot,
 37    TriggerBotPro,
 38    BrawlerBotPro,
 39    StickyBot,
 40    ExplodeyBot,
 41)
 42
 43if TYPE_CHECKING:
 44    from typing import Any, Sequence
 45    from bastd.actor.spaz import Spaz
 46    from bastd.actor.spazbot import SpazBot
 47
 48
 49class FootballFlag(Flag):
 50    """Custom flag class for football games."""
 51
 52    def __init__(self, position: Sequence[float]):
 53        super().__init__(
 54            position=position, dropped_timeout=20, color=(1.0, 1.0, 0.3)
 55        )
 56        assert self.node
 57        self.last_holding_player: ba.Player | None = None
 58        self.node.is_area_of_interest = True
 59        self.respawn_timer: ba.Timer | None = None
 60        self.scored = False
 61        self.held_count = 0
 62        self.light = ba.newnode(
 63            'light',
 64            owner=self.node,
 65            attrs={
 66                'intensity': 0.25,
 67                'height_attenuated': False,
 68                'radius': 0.2,
 69                'color': (0.9, 0.7, 0.0),
 70            },
 71        )
 72        self.node.connectattr('position', self.light, 'position')
 73
 74
 75class Player(ba.Player['Team']):
 76    """Our player type for this game."""
 77
 78    def __init__(self) -> None:
 79        self.respawn_timer: ba.Timer | None = None
 80        self.respawn_icon: RespawnIcon | None = None
 81
 82
 83class Team(ba.Team[Player]):
 84    """Our team type for this game."""
 85
 86    def __init__(self) -> None:
 87        self.score = 0
 88
 89
 90# ba_meta export game
 91class FootballTeamGame(ba.TeamGameActivity[Player, Team]):
 92    """Football game for teams mode."""
 93
 94    name = 'Football'
 95    description = 'Get the flag to the enemy end zone.'
 96    available_settings = [
 97        ba.IntSetting(
 98            'Score to Win',
 99            min_value=7,
100            default=21,
101            increment=7,
102        ),
103        ba.IntChoiceSetting(
104            'Time Limit',
105            choices=[
106                ('None', 0),
107                ('1 Minute', 60),
108                ('2 Minutes', 120),
109                ('5 Minutes', 300),
110                ('10 Minutes', 600),
111                ('20 Minutes', 1200),
112            ],
113            default=0,
114        ),
115        ba.FloatChoiceSetting(
116            'Respawn Times',
117            choices=[
118                ('Shorter', 0.25),
119                ('Short', 0.5),
120                ('Normal', 1.0),
121                ('Long', 2.0),
122                ('Longer', 4.0),
123            ],
124            default=1.0,
125        ),
126        ba.BoolSetting('Epic Mode', default=False),
127    ]
128
129    @classmethod
130    def supports_session_type(cls, sessiontype: type[ba.Session]) -> bool:
131        # We only support two-team play.
132        return issubclass(sessiontype, ba.DualTeamSession)
133
134    @classmethod
135    def get_supported_maps(cls, sessiontype: type[ba.Session]) -> list[str]:
136        return ba.getmaps('football')
137
138    def __init__(self, settings: dict):
139        super().__init__(settings)
140        self._scoreboard: Scoreboard | None = Scoreboard()
141
142        # Load some media we need.
143        self._cheer_sound = ba.getsound('cheer')
144        self._chant_sound = ba.getsound('crowdChant')
145        self._score_sound = ba.getsound('score')
146        self._swipsound = ba.getsound('swip')
147        self._whistle_sound = ba.getsound('refWhistle')
148        self._score_region_material = ba.Material()
149        self._score_region_material.add_actions(
150            conditions=('they_have_material', FlagFactory.get().flagmaterial),
151            actions=(
152                ('modify_part_collision', 'collide', True),
153                ('modify_part_collision', 'physical', False),
154                ('call', 'at_connect', self._handle_score),
155            ),
156        )
157        self._flag_spawn_pos: Sequence[float] | None = None
158        self._score_regions: list[ba.NodeActor] = []
159        self._flag: FootballFlag | None = None
160        self._flag_respawn_timer: ba.Timer | None = None
161        self._flag_respawn_light: ba.NodeActor | None = None
162        self._score_to_win = int(settings['Score to Win'])
163        self._time_limit = float(settings['Time Limit'])
164        self._epic_mode = bool(settings['Epic Mode'])
165        self.slow_motion = self._epic_mode
166        self.default_music = (
167            ba.MusicType.EPIC if self._epic_mode else ba.MusicType.FOOTBALL
168        )
169
170    def get_instance_description(self) -> str | Sequence:
171        touchdowns = self._score_to_win / 7
172
173        # NOTE: if use just touchdowns = self._score_to_win // 7
174        # and we will need to score, for example, 27 points,
175        # we will be required to score 3 (not 4) goals ..
176        touchdowns = math.ceil(touchdowns)
177        if touchdowns > 1:
178            return 'Score ${ARG1} touchdowns.', touchdowns
179        return 'Score a touchdown.'
180
181    def get_instance_description_short(self) -> str | Sequence:
182        touchdowns = self._score_to_win / 7
183        touchdowns = math.ceil(touchdowns)
184        if touchdowns > 1:
185            return 'score ${ARG1} touchdowns', touchdowns
186        return 'score a touchdown'
187
188    def on_begin(self) -> None:
189        super().on_begin()
190        self.setup_standard_time_limit(self._time_limit)
191        self.setup_standard_powerup_drops()
192        self._flag_spawn_pos = self.map.get_flag_position(None)
193        self._spawn_flag()
194        defs = self.map.defs
195        self._score_regions.append(
196            ba.NodeActor(
197                ba.newnode(
198                    'region',
199                    attrs={
200                        'position': defs.boxes['goal1'][0:3],
201                        'scale': defs.boxes['goal1'][6:9],
202                        'type': 'box',
203                        'materials': (self._score_region_material,),
204                    },
205                )
206            )
207        )
208        self._score_regions.append(
209            ba.NodeActor(
210                ba.newnode(
211                    'region',
212                    attrs={
213                        'position': defs.boxes['goal2'][0:3],
214                        'scale': defs.boxes['goal2'][6:9],
215                        'type': 'box',
216                        'materials': (self._score_region_material,),
217                    },
218                )
219            )
220        )
221        self._update_scoreboard()
222        ba.playsound(self._chant_sound)
223
224    def on_team_join(self, team: Team) -> None:
225        self._update_scoreboard()
226
227    def _kill_flag(self) -> None:
228        self._flag = None
229
230    def _handle_score(self) -> None:
231        """A point has been scored."""
232
233        # Our flag might stick around for a second or two
234        # make sure it doesn't score again.
235        assert self._flag is not None
236        if self._flag.scored:
237            return
238        region = ba.getcollision().sourcenode
239        i = None
240        for i, score_region in enumerate(self._score_regions):
241            if region == score_region.node:
242                break
243        for team in self.teams:
244            if team.id == i:
245                team.score += 7
246
247                # Tell all players to celebrate.
248                for player in team.players:
249                    if player.actor:
250                        player.actor.handlemessage(ba.CelebrateMessage(2.0))
251
252                # If someone on this team was last to touch it,
253                # give them points.
254                assert self._flag is not None
255                if (
256                    self._flag.last_holding_player
257                    and team == self._flag.last_holding_player.team
258                ):
259                    self.stats.player_scored(
260                        self._flag.last_holding_player, 50, big_message=True
261                    )
262                # End the game if we won.
263                if team.score >= self._score_to_win:
264                    self.end_game()
265        ba.playsound(self._score_sound)
266        ba.playsound(self._cheer_sound)
267        assert self._flag
268        self._flag.scored = True
269
270        # Kill the flag (it'll respawn shortly).
271        ba.timer(1.0, self._kill_flag)
272        light = ba.newnode(
273            'light',
274            attrs={
275                'position': ba.getcollision().position,
276                'height_attenuated': False,
277                'color': (1, 0, 0),
278            },
279        )
280        ba.animate(light, 'intensity', {0.0: 0, 0.5: 1, 1.0: 0}, loop=True)
281        ba.timer(1.0, light.delete)
282        ba.cameraflash(duration=10.0)
283        self._update_scoreboard()
284
285    def end_game(self) -> None:
286        results = ba.GameResults()
287        for team in self.teams:
288            results.set_team_score(team, team.score)
289        self.end(results=results, announce_delay=0.8)
290
291    def _update_scoreboard(self) -> None:
292        assert self._scoreboard is not None
293        for team in self.teams:
294            self._scoreboard.set_team_value(
295                team, team.score, self._score_to_win
296            )
297
298    def handlemessage(self, msg: Any) -> Any:
299        if isinstance(msg, FlagPickedUpMessage):
300            assert isinstance(msg.flag, FootballFlag)
301            try:
302                msg.flag.last_holding_player = msg.node.getdelegate(
303                    PlayerSpaz, True
304                ).getplayer(Player, True)
305            except ba.NotFoundError:
306                pass
307            msg.flag.held_count += 1
308
309        elif isinstance(msg, FlagDroppedMessage):
310            assert isinstance(msg.flag, FootballFlag)
311            msg.flag.held_count -= 1
312
313        # Respawn dead players if they're still in the game.
314        elif isinstance(msg, ba.PlayerDiedMessage):
315            # Augment standard behavior.
316            super().handlemessage(msg)
317            self.respawn_player(msg.getplayer(Player))
318
319        # Respawn dead flags.
320        elif isinstance(msg, FlagDiedMessage):
321            if not self.has_ended():
322                self._flag_respawn_timer = ba.Timer(3.0, self._spawn_flag)
323                self._flag_respawn_light = ba.NodeActor(
324                    ba.newnode(
325                        'light',
326                        attrs={
327                            'position': self._flag_spawn_pos,
328                            'height_attenuated': False,
329                            'radius': 0.15,
330                            'color': (1.0, 1.0, 0.3),
331                        },
332                    )
333                )
334                assert self._flag_respawn_light.node
335                ba.animate(
336                    self._flag_respawn_light.node,
337                    'intensity',
338                    {0.0: 0, 0.25: 0.15, 0.5: 0},
339                    loop=True,
340                )
341                ba.timer(3.0, self._flag_respawn_light.node.delete)
342
343        else:
344            # Augment standard behavior.
345            super().handlemessage(msg)
346
347    def _flash_flag_spawn(self) -> None:
348        light = ba.newnode(
349            'light',
350            attrs={
351                'position': self._flag_spawn_pos,
352                'height_attenuated': False,
353                'color': (1, 1, 0),
354            },
355        )
356        ba.animate(light, 'intensity', {0: 0, 0.25: 0.25, 0.5: 0}, loop=True)
357        ba.timer(1.0, light.delete)
358
359    def _spawn_flag(self) -> None:
360        ba.playsound(self._swipsound)
361        ba.playsound(self._whistle_sound)
362        self._flash_flag_spawn()
363        assert self._flag_spawn_pos is not None
364        self._flag = FootballFlag(position=self._flag_spawn_pos)
365
366
367class FootballCoopGame(ba.CoopGameActivity[Player, Team]):
368    """Co-op variant of football."""
369
370    name = 'Football'
371    tips = ['Use the pick-up button to grab the flag < ${PICKUP} >']
372    scoreconfig = ba.ScoreConfig(
373        scoretype=ba.ScoreType.MILLISECONDS, version='B'
374    )
375
376    default_music = ba.MusicType.FOOTBALL
377
378    # FIXME: Need to update co-op games to use getscoreconfig.
379    def get_score_type(self) -> str:
380        return 'time'
381
382    def get_instance_description(self) -> str | Sequence:
383        touchdowns = self._score_to_win / 7
384        touchdowns = math.ceil(touchdowns)
385        if touchdowns > 1:
386            return 'Score ${ARG1} touchdowns.', touchdowns
387        return 'Score a touchdown.'
388
389    def get_instance_description_short(self) -> str | Sequence:
390        touchdowns = self._score_to_win / 7
391        touchdowns = math.ceil(touchdowns)
392        if touchdowns > 1:
393            return 'score ${ARG1} touchdowns', touchdowns
394        return 'score a touchdown'
395
396    def __init__(self, settings: dict):
397        settings['map'] = 'Football Stadium'
398        super().__init__(settings)
399        self._preset = settings.get('preset', 'rookie')
400
401        # Load some media we need.
402        self._cheer_sound = ba.getsound('cheer')
403        self._boo_sound = ba.getsound('boo')
404        self._chant_sound = ba.getsound('crowdChant')
405        self._score_sound = ba.getsound('score')
406        self._swipsound = ba.getsound('swip')
407        self._whistle_sound = ba.getsound('refWhistle')
408        self._score_to_win = 21
409        self._score_region_material = ba.Material()
410        self._score_region_material.add_actions(
411            conditions=('they_have_material', FlagFactory.get().flagmaterial),
412            actions=(
413                ('modify_part_collision', 'collide', True),
414                ('modify_part_collision', 'physical', False),
415                ('call', 'at_connect', self._handle_score),
416            ),
417        )
418        self._powerup_center = (0, 2, 0)
419        self._powerup_spread = (10, 5.5)
420        self._player_has_dropped_bomb = False
421        self._player_has_punched = False
422        self._scoreboard: Scoreboard | None = None
423        self._flag_spawn_pos: Sequence[float] | None = None
424        self._score_regions: list[ba.NodeActor] = []
425        self._exclude_powerups: list[str] = []
426        self._have_tnt = False
427        self._bot_types_initial: list[type[SpazBot]] | None = None
428        self._bot_types_7: list[type[SpazBot]] | None = None
429        self._bot_types_14: list[type[SpazBot]] | None = None
430        self._bot_team: Team | None = None
431        self._starttime_ms: int | None = None
432        self._time_text: ba.NodeActor | None = None
433        self._time_text_input: ba.NodeActor | None = None
434        self._tntspawner: TNTSpawner | None = None
435        self._bots = SpazBotSet()
436        self._bot_spawn_timer: ba.Timer | None = None
437        self._powerup_drop_timer: ba.Timer | None = None
438        self._scoring_team: Team | None = None
439        self._final_time_ms: int | None = None
440        self._time_text_timer: ba.Timer | None = None
441        self._flag_respawn_light: ba.Actor | None = None
442        self._flag: FootballFlag | None = None
443
444    def on_transition_in(self) -> None:
445        super().on_transition_in()
446        self._scoreboard = Scoreboard()
447        self._flag_spawn_pos = self.map.get_flag_position(None)
448        self._spawn_flag()
449
450        # Set up the two score regions.
451        defs = self.map.defs
452        self._score_regions.append(
453            ba.NodeActor(
454                ba.newnode(
455                    'region',
456                    attrs={
457                        'position': defs.boxes['goal1'][0:3],
458                        'scale': defs.boxes['goal1'][6:9],
459                        'type': 'box',
460                        'materials': [self._score_region_material],
461                    },
462                )
463            )
464        )
465        self._score_regions.append(
466            ba.NodeActor(
467                ba.newnode(
468                    'region',
469                    attrs={
470                        'position': defs.boxes['goal2'][0:3],
471                        'scale': defs.boxes['goal2'][6:9],
472                        'type': 'box',
473                        'materials': [self._score_region_material],
474                    },
475                )
476            )
477        )
478        ba.playsound(self._chant_sound)
479
480    def on_begin(self) -> None:
481        # FIXME: Split this up a bit.
482        # pylint: disable=too-many-statements
483        from bastd.actor import controlsguide
484
485        super().on_begin()
486
487        # Show controls help in kiosk mode.
488        if ba.app.demo_mode or ba.app.arcade_mode:
489            controlsguide.ControlsGuide(
490                delay=3.0, lifespan=10.0, bright=True
491            ).autoretain()
492        assert self.initialplayerinfos is not None
493        abot: type[SpazBot]
494        bbot: type[SpazBot]
495        cbot: type[SpazBot]
496        if self._preset in ['rookie', 'rookie_easy']:
497            self._exclude_powerups = ['curse']
498            self._have_tnt = False
499            abot = (
500                BrawlerBotLite if self._preset == 'rookie_easy' else BrawlerBot
501            )
502            self._bot_types_initial = [abot] * len(self.initialplayerinfos)
503            bbot = BomberBotLite if self._preset == 'rookie_easy' else BomberBot
504            self._bot_types_7 = [bbot] * (
505                1 if len(self.initialplayerinfos) < 3 else 2
506            )
507            cbot = BomberBot if self._preset == 'rookie_easy' else TriggerBot
508            self._bot_types_14 = [cbot] * (
509                1 if len(self.initialplayerinfos) < 3 else 2
510            )
511        elif self._preset == 'tournament':
512            self._exclude_powerups = []
513            self._have_tnt = True
514            self._bot_types_initial = [BrawlerBot] * (
515                1 if len(self.initialplayerinfos) < 2 else 2
516            )
517            self._bot_types_7 = [TriggerBot] * (
518                1 if len(self.initialplayerinfos) < 3 else 2
519            )
520            self._bot_types_14 = [ChargerBot] * (
521                1 if len(self.initialplayerinfos) < 4 else 2
522            )
523        elif self._preset in ['pro', 'pro_easy', 'tournament_pro']:
524            self._exclude_powerups = ['curse']
525            self._have_tnt = True
526            self._bot_types_initial = [ChargerBot] * len(
527                self.initialplayerinfos
528            )
529            abot = BrawlerBot if self._preset == 'pro' else BrawlerBotLite
530            typed_bot_list: list[type[SpazBot]] = []
531            self._bot_types_7 = (
532                typed_bot_list
533                + [abot]
534                + [BomberBot] * (1 if len(self.initialplayerinfos) < 3 else 2)
535            )
536            bbot = TriggerBotPro if self._preset == 'pro' else TriggerBot
537            self._bot_types_14 = [bbot] * (
538                1 if len(self.initialplayerinfos) < 3 else 2
539            )
540        elif self._preset in ['uber', 'uber_easy']:
541            self._exclude_powerups = []
542            self._have_tnt = True
543            abot = BrawlerBotPro if self._preset == 'uber' else BrawlerBot
544            bbot = TriggerBotPro if self._preset == 'uber' else TriggerBot
545            typed_bot_list_2: list[type[SpazBot]] = []
546            self._bot_types_initial = (
547                typed_bot_list_2
548                + [StickyBot]
549                + [abot] * len(self.initialplayerinfos)
550            )
551            self._bot_types_7 = [bbot] * (
552                1 if len(self.initialplayerinfos) < 3 else 2
553            )
554            self._bot_types_14 = [ExplodeyBot] * (
555                1 if len(self.initialplayerinfos) < 3 else 2
556            )
557        else:
558            raise Exception()
559
560        self.setup_low_life_warning_sound()
561
562        self._drop_powerups(standard_points=True)
563        ba.timer(4.0, self._start_powerup_drops)
564
565        # Make a bogus team for our bots.
566        bad_team_name = self.get_team_display_string('Bad Guys')
567        self._bot_team = Team()
568        self._bot_team.manual_init(
569            team_id=1, name=bad_team_name, color=(0.5, 0.4, 0.4)
570        )
571
572        for team in [self.teams[0], self._bot_team]:
573            team.score = 0
574
575        self.update_scores()
576
577        # Time display.
578        starttime_ms = ba.time(timeformat=ba.TimeFormat.MILLISECONDS)
579        assert isinstance(starttime_ms, int)
580        self._starttime_ms = starttime_ms
581        self._time_text = ba.NodeActor(
582            ba.newnode(
583                'text',
584                attrs={
585                    'v_attach': 'top',
586                    'h_attach': 'center',
587                    'h_align': 'center',
588                    'color': (1, 1, 0.5, 1),
589                    'flatness': 0.5,
590                    'shadow': 0.5,
591                    'position': (0, -50),
592                    'scale': 1.3,
593                    'text': '',
594                },
595            )
596        )
597        self._time_text_input = ba.NodeActor(
598            ba.newnode('timedisplay', attrs={'showsubseconds': True})
599        )
600        self.globalsnode.connectattr(
601            'time', self._time_text_input.node, 'time2'
602        )
603        assert self._time_text_input.node
604        assert self._time_text.node
605        self._time_text_input.node.connectattr(
606            'output', self._time_text.node, 'text'
607        )
608
609        # Our TNT spawner (if applicable).
610        if self._have_tnt:
611            self._tntspawner = TNTSpawner(position=(0, 1, -1))
612
613        self._bots = SpazBotSet()
614        self._bot_spawn_timer = ba.Timer(1.0, self._update_bots, repeat=True)
615
616        for bottype in self._bot_types_initial:
617            self._spawn_bot(bottype)
618
619    def _on_bot_spawn(self, spaz: SpazBot) -> None:
620        # We want to move to the left by default.
621        spaz.target_point_default = ba.Vec3(0, 0, 0)
622
623    def _spawn_bot(
624        self, spaz_type: type[SpazBot], immediate: bool = False
625    ) -> None:
626        assert self._bot_team is not None
627        pos = self.map.get_start_position(self._bot_team.id)
628        self._bots.spawn_bot(
629            spaz_type,
630            pos=pos,
631            spawn_time=0.001 if immediate else 3.0,
632            on_spawn_call=self._on_bot_spawn,
633        )
634
635    def _update_bots(self) -> None:
636        bots = self._bots.get_living_bots()
637        for bot in bots:
638            bot.target_flag = None
639
640        # If we're waiting on a continue, stop here so they don't keep scoring.
641        if self.is_waiting_for_continue():
642            self._bots.stop_moving()
643            return
644
645        # If we've got a flag and no player are holding it, find the closest
646        # bot to it, and make them the designated flag-bearer.
647        assert self._flag is not None
648        if self._flag.node:
649            for player in self.players:
650                if player.actor:
651                    assert isinstance(player.actor, PlayerSpaz)
652                    if (
653                        player.actor.is_alive()
654                        and player.actor.node.hold_node == self._flag.node
655                    ):
656                        return
657
658            flagpos = ba.Vec3(self._flag.node.position)
659            closest_bot: SpazBot | None = None
660            closest_dist = 0.0  # Always gets assigned first time through.
661            for bot in bots:
662                # If a bot is picked up, he should forget about the flag.
663                if bot.held_count > 0:
664                    continue
665                assert bot.node
666                botpos = ba.Vec3(bot.node.position)
667                botdist = (botpos - flagpos).length()
668                if closest_bot is None or botdist < closest_dist:
669                    closest_bot = bot
670                    closest_dist = botdist
671            if closest_bot is not None:
672                closest_bot.target_flag = self._flag
673
674    def _drop_powerup(self, index: int, poweruptype: str | None = None) -> None:
675        if poweruptype is None:
676            poweruptype = PowerupBoxFactory.get().get_random_powerup_type(
677                excludetypes=self._exclude_powerups
678            )
679        PowerupBox(
680            position=self.map.powerup_spawn_points[index],
681            poweruptype=poweruptype,
682        ).autoretain()
683
684    def _start_powerup_drops(self) -> None:
685        self._powerup_drop_timer = ba.Timer(
686            3.0, self._drop_powerups, repeat=True
687        )
688
689    def _drop_powerups(
690        self, standard_points: bool = False, poweruptype: str | None = None
691    ) -> None:
692        """Generic powerup drop."""
693        if standard_points:
694            spawnpoints = self.map.powerup_spawn_points
695            for i, _point in enumerate(spawnpoints):
696                ba.timer(
697                    1.0 + i * 0.5, ba.Call(self._drop_powerup, i, poweruptype)
698                )
699        else:
700            point = (
701                self._powerup_center[0]
702                + random.uniform(
703                    -1.0 * self._powerup_spread[0],
704                    1.0 * self._powerup_spread[0],
705                ),
706                self._powerup_center[1],
707                self._powerup_center[2]
708                + random.uniform(
709                    -self._powerup_spread[1], self._powerup_spread[1]
710                ),
711            )
712
713            # Drop one random one somewhere.
714            PowerupBox(
715                position=point,
716                poweruptype=PowerupBoxFactory.get().get_random_powerup_type(
717                    excludetypes=self._exclude_powerups
718                ),
719            ).autoretain()
720
721    def _kill_flag(self) -> None:
722        try:
723            assert self._flag is not None
724            self._flag.handlemessage(ba.DieMessage())
725        except Exception:
726            ba.print_exception('Error in _kill_flag.')
727
728    def _handle_score(self) -> None:
729        """a point has been scored"""
730        # FIXME tidy this up
731        # pylint: disable=too-many-branches
732
733        # Our flag might stick around for a second or two;
734        # we don't want it to be able to score again.
735        assert self._flag is not None
736        if self._flag.scored:
737            return
738
739        # See which score region it was.
740        region = ba.getcollision().sourcenode
741        i = None
742        for i, score_region in enumerate(self._score_regions):
743            if region == score_region.node:
744                break
745
746        for team in [self.teams[0], self._bot_team]:
747            assert team is not None
748            if team.id == i:
749                team.score += 7
750
751                # Tell all players (or bots) to celebrate.
752                if i == 0:
753                    for player in team.players:
754                        if player.actor:
755                            player.actor.handlemessage(ba.CelebrateMessage(2.0))
756                else:
757                    self._bots.celebrate(2.0)
758
759        # If the good guys scored, add more enemies.
760        if i == 0:
761            if self.teams[0].score == 7:
762                assert self._bot_types_7 is not None
763                for bottype in self._bot_types_7:
764                    self._spawn_bot(bottype)
765            elif self.teams[0].score == 14:
766                assert self._bot_types_14 is not None
767                for bottype in self._bot_types_14:
768                    self._spawn_bot(bottype)
769
770        ba.playsound(self._score_sound)
771        if i == 0:
772            ba.playsound(self._cheer_sound)
773        else:
774            ba.playsound(self._boo_sound)
775
776        # Kill the flag (it'll respawn shortly).
777        self._flag.scored = True
778
779        ba.timer(0.2, self._kill_flag)
780
781        self.update_scores()
782        light = ba.newnode(
783            'light',
784            attrs={
785                'position': ba.getcollision().position,
786                'height_attenuated': False,
787                'color': (1, 0, 0),
788            },
789        )
790        ba.animate(light, 'intensity', {0: 0, 0.5: 1, 1.0: 0}, loop=True)
791        ba.timer(1.0, light.delete)
792        if i == 0:
793            ba.cameraflash(duration=10.0)
794
795    def end_game(self) -> None:
796        ba.setmusic(None)
797        self._bots.final_celebrate()
798        ba.timer(0.001, ba.Call(self.do_end, 'defeat'))
799
800    def on_continue(self) -> None:
801        # Subtract one touchdown from the bots and get them moving again.
802        assert self._bot_team is not None
803        self._bot_team.score -= 7
804        self._bots.start_moving()
805        self.update_scores()
806
807    def update_scores(self) -> None:
808        """update scoreboard and check for winners"""
809        # FIXME: tidy this up
810        # pylint: disable=too-many-nested-blocks
811        have_scoring_team = False
812        win_score = self._score_to_win
813        for team in [self.teams[0], self._bot_team]:
814            assert team is not None
815            assert self._scoreboard is not None
816            self._scoreboard.set_team_value(team, team.score, win_score)
817            if team.score >= win_score:
818                if not have_scoring_team:
819                    self._scoring_team = team
820                    if team is self._bot_team:
821                        self.continue_or_end_game()
822                    else:
823                        ba.setmusic(ba.MusicType.VICTORY)
824
825                        # Completion achievements.
826                        assert self._bot_team is not None
827                        if self._preset in ['rookie', 'rookie_easy']:
828                            self._award_achievement(
829                                'Rookie Football Victory', sound=False
830                            )
831                            if self._bot_team.score == 0:
832                                self._award_achievement(
833                                    'Rookie Football Shutout', sound=False
834                                )
835                        elif self._preset in ['pro', 'pro_easy']:
836                            self._award_achievement(
837                                'Pro Football Victory', sound=False
838                            )
839                            if self._bot_team.score == 0:
840                                self._award_achievement(
841                                    'Pro Football Shutout', sound=False
842                                )
843                        elif self._preset in ['uber', 'uber_easy']:
844                            self._award_achievement(
845                                'Uber Football Victory', sound=False
846                            )
847                            if self._bot_team.score == 0:
848                                self._award_achievement(
849                                    'Uber Football Shutout', sound=False
850                                )
851                            if (
852                                not self._player_has_dropped_bomb
853                                and not self._player_has_punched
854                            ):
855                                self._award_achievement(
856                                    'Got the Moves', sound=False
857                                )
858                        self._bots.stop_moving()
859                        self.show_zoom_message(
860                            ba.Lstr(resource='victoryText'),
861                            scale=1.0,
862                            duration=4.0,
863                        )
864                        self.celebrate(10.0)
865                        assert self._starttime_ms is not None
866                        self._final_time_ms = int(
867                            ba.time(timeformat=ba.TimeFormat.MILLISECONDS)
868                            - self._starttime_ms
869                        )
870                        self._time_text_timer = None
871                        assert (
872                            self._time_text_input is not None
873                            and self._time_text_input.node
874                        )
875                        self._time_text_input.node.timemax = self._final_time_ms
876
877                        # FIXME: Does this still need to be deferred?
878                        ba.pushcall(ba.Call(self.do_end, 'victory'))
879
880    def do_end(self, outcome: str) -> None:
881        """End the game with the specified outcome."""
882        if outcome == 'defeat':
883            self.fade_to_red()
884        assert self._final_time_ms is not None
885        scoreval = (
886            None if outcome == 'defeat' else int(self._final_time_ms // 10)
887        )
888        self.end(
889            delay=3.0,
890            results={
891                'outcome': outcome,
892                'score': scoreval,
893                'score_order': 'decreasing',
894                'playerinfos': self.initialplayerinfos,
895            },
896        )
897
898    def handlemessage(self, msg: Any) -> Any:
899        """handle high-level game messages"""
900        if isinstance(msg, ba.PlayerDiedMessage):
901            # Augment standard behavior.
902            super().handlemessage(msg)
903
904            # Respawn them shortly.
905            player = msg.getplayer(Player)
906            assert self.initialplayerinfos is not None
907            respawn_time = 2.0 + len(self.initialplayerinfos) * 1.0
908            player.respawn_timer = ba.Timer(
909                respawn_time, ba.Call(self.spawn_player_if_exists, player)
910            )
911            player.respawn_icon = RespawnIcon(player, respawn_time)
912
913        elif isinstance(msg, SpazBotDiedMessage):
914
915            # Every time a bad guy dies, spawn a new one.
916            ba.timer(3.0, ba.Call(self._spawn_bot, (type(msg.spazbot))))
917
918        elif isinstance(msg, SpazBotPunchedMessage):
919            if self._preset in ['rookie', 'rookie_easy']:
920                if msg.damage >= 500:
921                    self._award_achievement('Super Punch')
922            elif self._preset in ['pro', 'pro_easy']:
923                if msg.damage >= 1000:
924                    self._award_achievement('Super Mega Punch')
925
926        # Respawn dead flags.
927        elif isinstance(msg, FlagDiedMessage):
928            assert isinstance(msg.flag, FootballFlag)
929            msg.flag.respawn_timer = ba.Timer(3.0, self._spawn_flag)
930            self._flag_respawn_light = ba.NodeActor(
931                ba.newnode(
932                    'light',
933                    attrs={
934                        'position': self._flag_spawn_pos,
935                        'height_attenuated': False,
936                        'radius': 0.15,
937                        'color': (1.0, 1.0, 0.3),
938                    },
939                )
940            )
941            assert self._flag_respawn_light.node
942            ba.animate(
943                self._flag_respawn_light.node,
944                'intensity',
945                {0: 0, 0.25: 0.15, 0.5: 0},
946                loop=True,
947            )
948            ba.timer(3.0, self._flag_respawn_light.node.delete)
949        else:
950            return super().handlemessage(msg)
951        return None
952
953    def _handle_player_dropped_bomb(self, player: Spaz, bomb: ba.Actor) -> None:
954        del player, bomb  # Unused.
955        self._player_has_dropped_bomb = True
956
957    def _handle_player_punched(self, player: Spaz) -> None:
958        del player  # Unused.
959        self._player_has_punched = True
960
961    def spawn_player(self, player: Player) -> ba.Actor:
962        spaz = self.spawn_player_spaz(
963            player, position=self.map.get_start_position(player.team.id)
964        )
965        if self._preset in ['rookie_easy', 'pro_easy', 'uber_easy']:
966            spaz.impact_scale = 0.25
967        spaz.add_dropped_bomb_callback(self._handle_player_dropped_bomb)
968        spaz.punch_callback = self._handle_player_punched
969        return spaz
970
971    def _flash_flag_spawn(self) -> None:
972        light = ba.newnode(
973            'light',
974            attrs={
975                'position': self._flag_spawn_pos,
976                'height_attenuated': False,
977                'color': (1, 1, 0),
978            },
979        )
980        ba.animate(light, 'intensity', {0: 0, 0.25: 0.25, 0.5: 0}, loop=True)
981        ba.timer(1.0, light.delete)
982
983    def _spawn_flag(self) -> None:
984        ba.playsound(self._swipsound)
985        ba.playsound(self._whistle_sound)
986        self._flash_flag_spawn()
987        assert self._flag_spawn_pos is not None
988        self._flag = FootballFlag(position=self._flag_spawn_pos)