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