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