bascenev1lib.game.onslaught

   1# Released under the MIT License. See LICENSE for details.
   2#
   3"""Provides Onslaught Co-op game."""
   4
   5# Yes this is a long one..
   6# pylint: disable=too-many-lines
   7
   8# ba_meta require api 9
   9# (see https://ballistica.net/wiki/meta-tag-system)
  10
  11from __future__ import annotations
  12
  13import math
  14import random
  15import logging
  16from enum import Enum, unique
  17from dataclasses import dataclass
  18from typing import TYPE_CHECKING, override
  19
  20import bascenev1 as bs
  21
  22from bascenev1lib.actor.popuptext import PopupText
  23from bascenev1lib.actor.bomb import TNTSpawner
  24from bascenev1lib.actor.playerspaz import PlayerSpazHurtMessage
  25from bascenev1lib.actor.scoreboard import Scoreboard
  26from bascenev1lib.actor.controlsguide import ControlsGuide
  27from bascenev1lib.actor.powerupbox import PowerupBox, PowerupBoxFactory
  28from bascenev1lib.actor.spazbot import (
  29    SpazBotDiedMessage,
  30    SpazBotSet,
  31    ChargerBot,
  32    StickyBot,
  33    BomberBot,
  34    BomberBotLite,
  35    BrawlerBot,
  36    BrawlerBotLite,
  37    TriggerBot,
  38    BomberBotStaticLite,
  39    TriggerBotStatic,
  40    BomberBotProStatic,
  41    TriggerBotPro,
  42    ExplodeyBot,
  43    BrawlerBotProShielded,
  44    ChargerBotProShielded,
  45    BomberBotPro,
  46    TriggerBotProShielded,
  47    BrawlerBotPro,
  48    BomberBotProShielded,
  49)
  50
  51if TYPE_CHECKING:
  52    from typing import Any, Sequence
  53    from bascenev1lib.actor.spazbot import SpazBot
  54
  55
  56@dataclass
  57class Wave:
  58    """A wave of enemies."""
  59
  60    entries: list[Spawn | Spacing | Delay | None]
  61    base_angle: float = 0.0
  62
  63
  64@dataclass
  65class Spawn:
  66    """A bot spawn event in a wave."""
  67
  68    bottype: type[SpazBot] | str
  69    point: Point | None = None
  70    spacing: float = 5.0
  71
  72
  73@dataclass
  74class Spacing:
  75    """Empty space in a wave."""
  76
  77    spacing: float = 5.0
  78
  79
  80@dataclass
  81class Delay:
  82    """A delay between events in a wave."""
  83
  84    duration: float
  85
  86
  87class Preset(Enum):
  88    """Game presets we support."""
  89
  90    TRAINING = 'training'
  91    TRAINING_EASY = 'training_easy'
  92    ROOKIE = 'rookie'
  93    ROOKIE_EASY = 'rookie_easy'
  94    PRO = 'pro'
  95    PRO_EASY = 'pro_easy'
  96    UBER = 'uber'
  97    UBER_EASY = 'uber_easy'
  98    ENDLESS = 'endless'
  99    ENDLESS_TOURNAMENT = 'endless_tournament'
 100
 101
 102@unique
 103class Point(Enum):
 104    """Points on the map we can spawn at."""
 105
 106    LEFT_UPPER_MORE = 'bot_spawn_left_upper_more'
 107    LEFT_UPPER = 'bot_spawn_left_upper'
 108    TURRET_TOP_RIGHT = 'bot_spawn_turret_top_right'
 109    RIGHT_UPPER = 'bot_spawn_right_upper'
 110    TURRET_TOP_MIDDLE_LEFT = 'bot_spawn_turret_top_middle_left'
 111    TURRET_TOP_MIDDLE_RIGHT = 'bot_spawn_turret_top_middle_right'
 112    TURRET_TOP_LEFT = 'bot_spawn_turret_top_left'
 113    TOP_RIGHT = 'bot_spawn_top_right'
 114    TOP_LEFT = 'bot_spawn_top_left'
 115    TOP = 'bot_spawn_top'
 116    BOTTOM = 'bot_spawn_bottom'
 117    LEFT = 'bot_spawn_left'
 118    RIGHT = 'bot_spawn_right'
 119    RIGHT_UPPER_MORE = 'bot_spawn_right_upper_more'
 120    RIGHT_LOWER = 'bot_spawn_right_lower'
 121    RIGHT_LOWER_MORE = 'bot_spawn_right_lower_more'
 122    BOTTOM_RIGHT = 'bot_spawn_bottom_right'
 123    BOTTOM_LEFT = 'bot_spawn_bottom_left'
 124    TURRET_BOTTOM_RIGHT = 'bot_spawn_turret_bottom_right'
 125    TURRET_BOTTOM_LEFT = 'bot_spawn_turret_bottom_left'
 126    LEFT_LOWER = 'bot_spawn_left_lower'
 127    LEFT_LOWER_MORE = 'bot_spawn_left_lower_more'
 128    TURRET_TOP_MIDDLE = 'bot_spawn_turret_top_middle'
 129    BOTTOM_HALF_RIGHT = 'bot_spawn_bottom_half_right'
 130    BOTTOM_HALF_LEFT = 'bot_spawn_bottom_half_left'
 131    TOP_HALF_RIGHT = 'bot_spawn_top_half_right'
 132    TOP_HALF_LEFT = 'bot_spawn_top_half_left'
 133
 134
 135class Player(bs.Player['Team']):
 136    """Our player type for this game."""
 137
 138    def __init__(self) -> None:
 139        self.has_been_hurt = False
 140        self.respawn_wave = 0
 141
 142
 143class Team(bs.Team[Player]):
 144    """Our team type for this game."""
 145
 146
 147class OnslaughtGame(bs.CoopGameActivity[Player, Team]):
 148    """Co-op game where players try to survive attacking waves of enemies."""
 149
 150    name = 'Onslaught'
 151    description = 'Defeat all enemies.'
 152
 153    tips: list[str | bs.GameTip] = [
 154        'Hold any button to run.'
 155        '  (Trigger buttons work well if you have them)',
 156        'Try tricking enemies into killing eachother or running off cliffs.',
 157        'Try \'Cooking off\' bombs for a second or two before throwing them.',
 158        'It\'s easier to win with a friend or two helping.',
 159        'If you stay in one place, you\'re toast. Run and dodge to survive..',
 160        'Practice using your momentum to throw bombs more accurately.',
 161        'Your punches do much more damage if you are running or spinning.',
 162    ]
 163
 164    # Show messages when players die since it matters here.
 165    announce_player_deaths = True
 166
 167    def __init__(self, settings: dict):
 168        self._preset = Preset(settings.get('preset', 'training'))
 169        if self._preset in {
 170            Preset.TRAINING,
 171            Preset.TRAINING_EASY,
 172            Preset.PRO,
 173            Preset.PRO_EASY,
 174            Preset.ENDLESS,
 175            Preset.ENDLESS_TOURNAMENT,
 176        }:
 177            settings['map'] = 'Doom Shroom'
 178        else:
 179            settings['map'] = 'Courtyard'
 180
 181        super().__init__(settings)
 182
 183        self._new_wave_sound = bs.getsound('scoreHit01')
 184        self._winsound = bs.getsound('score')
 185        self._cashregistersound = bs.getsound('cashRegister')
 186        self._a_player_has_been_hurt = False
 187        self._player_has_dropped_bomb = False
 188
 189        # FIXME: should use standard map defs.
 190        if settings['map'] == 'Doom Shroom':
 191            self._spawn_center = (0, 3, -5)
 192            self._tntspawnpos = (0.0, 3.0, -5.0)
 193            self._powerup_center = (0, 5, -3.6)
 194            self._powerup_spread = (6.0, 4.0)
 195        elif settings['map'] == 'Courtyard':
 196            self._spawn_center = (0, 3, -2)
 197            self._tntspawnpos = (0.0, 3.0, 2.1)
 198            self._powerup_center = (0, 5, -1.6)
 199            self._powerup_spread = (4.6, 2.7)
 200        else:
 201            raise RuntimeError('Unsupported map: ' + str(settings['map']))
 202        self._scoreboard: Scoreboard | None = None
 203        self._game_over = False
 204        self._wavenum = 0
 205        self._can_end_wave = True
 206        self._score = 0
 207        self._time_bonus = 0
 208        self._spawn_info_text: bs.NodeActor | None = None
 209        self._dingsound = bs.getsound('dingSmall')
 210        self._dingsoundhigh = bs.getsound('dingSmallHigh')
 211        self._have_tnt = False
 212        self._excluded_powerups: list[str] | None = None
 213        self._waves: list[Wave] = []
 214        self._tntspawner: TNTSpawner | None = None
 215        self._bots: SpazBotSet | None = None
 216        self._powerup_drop_timer: bs.Timer | None = None
 217        self._time_bonus_timer: bs.Timer | None = None
 218        self._time_bonus_text: bs.NodeActor | None = None
 219        self._flawless_bonus: int | None = None
 220        self._wave_text: bs.NodeActor | None = None
 221        self._wave_update_timer: bs.Timer | None = None
 222        self._throw_off_kills = 0
 223        self._land_mine_kills = 0
 224        self._tnt_kills = 0
 225
 226    @override
 227    def on_transition_in(self) -> None:
 228        super().on_transition_in()
 229        customdata = bs.getsession().customdata
 230
 231        # Show special landmine tip on rookie preset.
 232        if self._preset in {Preset.ROOKIE, Preset.ROOKIE_EASY}:
 233            # Show once per session only (then we revert to regular tips).
 234            if not customdata.get('_showed_onslaught_landmine_tip', False):
 235                customdata['_showed_onslaught_landmine_tip'] = True
 236                self.tips = [
 237                    bs.GameTip(
 238                        'Land-mines are a good way to stop speedy enemies.',
 239                        icon=bs.gettexture('powerupLandMines'),
 240                        sound=bs.getsound('ding'),
 241                    )
 242                ]
 243
 244        # Show special tnt tip on pro preset.
 245        if self._preset in {Preset.PRO, Preset.PRO_EASY}:
 246            # Show once per session only (then we revert to regular tips).
 247            if not customdata.get('_showed_onslaught_tnt_tip', False):
 248                customdata['_showed_onslaught_tnt_tip'] = True
 249                self.tips = [
 250                    bs.GameTip(
 251                        'Take out a group of enemies by\n'
 252                        'setting off a bomb near a TNT box.',
 253                        icon=bs.gettexture('tnt'),
 254                        sound=bs.getsound('ding'),
 255                    )
 256                ]
 257
 258        # Show special curse tip on uber preset.
 259        if self._preset in {Preset.UBER, Preset.UBER_EASY}:
 260            # Show once per session only (then we revert to regular tips).
 261            if not customdata.get('_showed_onslaught_curse_tip', False):
 262                customdata['_showed_onslaught_curse_tip'] = True
 263                self.tips = [
 264                    bs.GameTip(
 265                        'Curse boxes turn you into a ticking time bomb.\n'
 266                        'The only cure is to quickly grab a health-pack.',
 267                        icon=bs.gettexture('powerupCurse'),
 268                        sound=bs.getsound('ding'),
 269                    )
 270                ]
 271
 272        self._spawn_info_text = bs.NodeActor(
 273            bs.newnode(
 274                'text',
 275                attrs={
 276                    'position': (15, -130),
 277                    'h_attach': 'left',
 278                    'v_attach': 'top',
 279                    'scale': 0.55,
 280                    'color': (0.3, 0.8, 0.3, 1.0),
 281                    'text': '',
 282                },
 283            )
 284        )
 285        bs.setmusic(bs.MusicType.ONSLAUGHT)
 286
 287        self._scoreboard = Scoreboard(
 288            label=bs.Lstr(resource='scoreText'), score_split=0.5
 289        )
 290
 291    @override
 292    def on_begin(self) -> None:
 293        super().on_begin()
 294        player_count = len(self.players)
 295        hard = self._preset not in {
 296            Preset.TRAINING_EASY,
 297            Preset.ROOKIE_EASY,
 298            Preset.PRO_EASY,
 299            Preset.UBER_EASY,
 300        }
 301        if self._preset in {Preset.TRAINING, Preset.TRAINING_EASY}:
 302            ControlsGuide(delay=3.0, lifespan=10.0, bright=True).autoretain()
 303
 304            self._have_tnt = False
 305            self._excluded_powerups = ['curse', 'land_mines']
 306            self._waves = [
 307                Wave(
 308                    base_angle=195,
 309                    entries=[
 310                        Spawn(BomberBotLite, spacing=5),
 311                    ]
 312                    * player_count,
 313                ),
 314                Wave(
 315                    base_angle=130,
 316                    entries=[
 317                        Spawn(BrawlerBotLite, spacing=5),
 318                    ]
 319                    * player_count,
 320                ),
 321                Wave(
 322                    base_angle=195,
 323                    entries=[Spawn(BomberBotLite, spacing=10)]
 324                    * (player_count + 1),
 325                ),
 326                Wave(
 327                    base_angle=130,
 328                    entries=[
 329                        Spawn(BrawlerBotLite, spacing=10),
 330                    ]
 331                    * (player_count + 1),
 332                ),
 333                Wave(
 334                    base_angle=130,
 335                    entries=[
 336                        (
 337                            Spawn(BrawlerBotLite, spacing=5)
 338                            if player_count > 1
 339                            else None
 340                        ),
 341                        Spawn(BrawlerBotLite, spacing=5),
 342                        Spacing(30),
 343                        (
 344                            Spawn(BomberBotLite, spacing=5)
 345                            if player_count > 3
 346                            else None
 347                        ),
 348                        Spawn(BomberBotLite, spacing=5),
 349                        Spacing(30),
 350                        Spawn(BrawlerBotLite, spacing=5),
 351                        (
 352                            Spawn(BrawlerBotLite, spacing=5)
 353                            if player_count > 2
 354                            else None
 355                        ),
 356                    ],
 357                ),
 358                Wave(
 359                    base_angle=195,
 360                    entries=[
 361                        Spawn(TriggerBot, spacing=90),
 362                        (
 363                            Spawn(TriggerBot, spacing=90)
 364                            if player_count > 1
 365                            else None
 366                        ),
 367                    ],
 368                ),
 369            ]
 370
 371        elif self._preset in {Preset.ROOKIE, Preset.ROOKIE_EASY}:
 372            self._have_tnt = False
 373            self._excluded_powerups = ['curse']
 374            self._waves = [
 375                Wave(
 376                    entries=[
 377                        (
 378                            Spawn(ChargerBot, Point.LEFT_UPPER_MORE)
 379                            if player_count > 2
 380                            else None
 381                        ),
 382                        Spawn(ChargerBot, Point.LEFT_UPPER),
 383                    ]
 384                ),
 385                Wave(
 386                    entries=[
 387                        Spawn(BomberBotStaticLite, Point.TURRET_TOP_RIGHT),
 388                        Spawn(BrawlerBotLite, Point.RIGHT_UPPER),
 389                        (
 390                            Spawn(BrawlerBotLite, Point.RIGHT_LOWER)
 391                            if player_count > 1
 392                            else None
 393                        ),
 394                        (
 395                            Spawn(
 396                                BomberBotStaticLite, Point.TURRET_BOTTOM_RIGHT
 397                            )
 398                            if player_count > 2
 399                            else None
 400                        ),
 401                    ]
 402                ),
 403                Wave(
 404                    entries=[
 405                        Spawn(BomberBotStaticLite, Point.TURRET_BOTTOM_LEFT),
 406                        Spawn(TriggerBot, Point.LEFT),
 407                        (
 408                            Spawn(TriggerBot, Point.LEFT_LOWER)
 409                            if player_count > 1
 410                            else None
 411                        ),
 412                        (
 413                            Spawn(TriggerBot, Point.LEFT_UPPER)
 414                            if player_count > 2
 415                            else None
 416                        ),
 417                    ]
 418                ),
 419                Wave(
 420                    entries=[
 421                        Spawn(BrawlerBotLite, Point.TOP_RIGHT),
 422                        (
 423                            Spawn(BrawlerBot, Point.TOP_HALF_RIGHT)
 424                            if player_count > 1
 425                            else None
 426                        ),
 427                        Spawn(BrawlerBotLite, Point.TOP_LEFT),
 428                        (
 429                            Spawn(BrawlerBotLite, Point.TOP_HALF_LEFT)
 430                            if player_count > 2
 431                            else None
 432                        ),
 433                        Spawn(BrawlerBot, Point.TOP),
 434                        Spawn(BomberBotStaticLite, Point.TURRET_TOP_MIDDLE),
 435                    ]
 436                ),
 437                Wave(
 438                    entries=[
 439                        Spawn(TriggerBotStatic, Point.TURRET_BOTTOM_LEFT),
 440                        Spawn(TriggerBotStatic, Point.TURRET_BOTTOM_RIGHT),
 441                        Spawn(TriggerBot, Point.BOTTOM),
 442                        (
 443                            Spawn(TriggerBot, Point.BOTTOM_HALF_RIGHT)
 444                            if player_count > 1
 445                            else None
 446                        ),
 447                        (
 448                            Spawn(TriggerBot, Point.BOTTOM_HALF_LEFT)
 449                            if player_count > 2
 450                            else None
 451                        ),
 452                    ]
 453                ),
 454                Wave(
 455                    entries=[
 456                        Spawn(BomberBotStaticLite, Point.TURRET_TOP_LEFT),
 457                        Spawn(BomberBotStaticLite, Point.TURRET_TOP_RIGHT),
 458                        Spawn(ChargerBot, Point.BOTTOM),
 459                        (
 460                            Spawn(ChargerBot, Point.BOTTOM_HALF_LEFT)
 461                            if player_count > 1
 462                            else None
 463                        ),
 464                        (
 465                            Spawn(ChargerBot, Point.BOTTOM_HALF_RIGHT)
 466                            if player_count > 2
 467                            else None
 468                        ),
 469                    ]
 470                ),
 471            ]
 472
 473        elif self._preset in {Preset.PRO, Preset.PRO_EASY}:
 474            self._excluded_powerups = ['curse']
 475            self._have_tnt = True
 476            self._waves = [
 477                Wave(
 478                    base_angle=-50,
 479                    entries=[
 480                        (
 481                            Spawn(BrawlerBot, spacing=12)
 482                            if player_count > 3
 483                            else None
 484                        ),
 485                        Spawn(BrawlerBot, spacing=12),
 486                        Spawn(BomberBot, spacing=6),
 487                        (
 488                            Spawn(BomberBot, spacing=6)
 489                            if self._preset is Preset.PRO
 490                            else None
 491                        ),
 492                        (
 493                            Spawn(BomberBot, spacing=6)
 494                            if player_count > 1
 495                            else None
 496                        ),
 497                        Spawn(BrawlerBot, spacing=12),
 498                        (
 499                            Spawn(BrawlerBot, spacing=12)
 500                            if player_count > 2
 501                            else None
 502                        ),
 503                    ],
 504                ),
 505                Wave(
 506                    base_angle=180,
 507                    entries=[
 508                        (
 509                            Spawn(BrawlerBot, spacing=6)
 510                            if player_count > 3
 511                            else None
 512                        ),
 513                        (
 514                            Spawn(BrawlerBot, spacing=6)
 515                            if self._preset is Preset.PRO
 516                            else None
 517                        ),
 518                        Spawn(BrawlerBot, spacing=6),
 519                        Spawn(ChargerBot, spacing=45),
 520                        (
 521                            Spawn(ChargerBot, spacing=45)
 522                            if player_count > 1
 523                            else None
 524                        ),
 525                        Spawn(BrawlerBot, spacing=6),
 526                        (
 527                            Spawn(BrawlerBot, spacing=6)
 528                            if self._preset is Preset.PRO
 529                            else None
 530                        ),
 531                        (
 532                            Spawn(BrawlerBot, spacing=6)
 533                            if player_count > 2
 534                            else None
 535                        ),
 536                    ],
 537                ),
 538                Wave(
 539                    base_angle=0,
 540                    entries=[
 541                        Spawn(ChargerBot, spacing=30),
 542                        Spawn(TriggerBot, spacing=30),
 543                        Spawn(TriggerBot, spacing=30),
 544                        (
 545                            Spawn(TriggerBot, spacing=30)
 546                            if self._preset is Preset.PRO
 547                            else None
 548                        ),
 549                        (
 550                            Spawn(TriggerBot, spacing=30)
 551                            if player_count > 1
 552                            else None
 553                        ),
 554                        (
 555                            Spawn(TriggerBot, spacing=30)
 556                            if player_count > 3
 557                            else None
 558                        ),
 559                        Spawn(ChargerBot, spacing=30),
 560                    ],
 561                ),
 562                Wave(
 563                    base_angle=90,
 564                    entries=[
 565                        Spawn(StickyBot, spacing=50),
 566                        (
 567                            Spawn(StickyBot, spacing=50)
 568                            if self._preset is Preset.PRO
 569                            else None
 570                        ),
 571                        Spawn(StickyBot, spacing=50),
 572                        (
 573                            Spawn(StickyBot, spacing=50)
 574                            if player_count > 1
 575                            else None
 576                        ),
 577                        (
 578                            Spawn(StickyBot, spacing=50)
 579                            if player_count > 3
 580                            else None
 581                        ),
 582                    ],
 583                ),
 584                Wave(
 585                    base_angle=0,
 586                    entries=[
 587                        Spawn(TriggerBot, spacing=72),
 588                        Spawn(TriggerBot, spacing=72),
 589                        (
 590                            Spawn(TriggerBot, spacing=72)
 591                            if self._preset is Preset.PRO
 592                            else None
 593                        ),
 594                        Spawn(TriggerBot, spacing=72),
 595                        Spawn(TriggerBot, spacing=72),
 596                        (
 597                            Spawn(TriggerBot, spacing=36)
 598                            if player_count > 2
 599                            else None
 600                        ),
 601                    ],
 602                ),
 603                Wave(
 604                    base_angle=30,
 605                    entries=[
 606                        Spawn(ChargerBotProShielded, spacing=50),
 607                        Spawn(ChargerBotProShielded, spacing=50),
 608                        (
 609                            Spawn(ChargerBotProShielded, spacing=50)
 610                            if self._preset is Preset.PRO
 611                            else None
 612                        ),
 613                        (
 614                            Spawn(ChargerBotProShielded, spacing=50)
 615                            if player_count > 1
 616                            else None
 617                        ),
 618                        (
 619                            Spawn(ChargerBotProShielded, spacing=50)
 620                            if player_count > 2
 621                            else None
 622                        ),
 623                    ],
 624                ),
 625            ]
 626
 627        elif self._preset in {Preset.UBER, Preset.UBER_EASY}:
 628            # Show controls help in demo or arcade modes.
 629            env = bs.app.env
 630            if env.demo or env.arcade:
 631                ControlsGuide(
 632                    delay=3.0, lifespan=10.0, bright=True
 633                ).autoretain()
 634
 635            self._have_tnt = True
 636            self._excluded_powerups = []
 637            self._waves = [
 638                Wave(
 639                    entries=[
 640                        (
 641                            Spawn(
 642                                BomberBotProStatic, Point.TURRET_TOP_MIDDLE_LEFT
 643                            )
 644                            if hard
 645                            else None
 646                        ),
 647                        Spawn(
 648                            BomberBotProStatic, Point.TURRET_TOP_MIDDLE_RIGHT
 649                        ),
 650                        (
 651                            Spawn(BomberBotProStatic, Point.TURRET_TOP_LEFT)
 652                            if player_count > 2
 653                            else None
 654                        ),
 655                        Spawn(ExplodeyBot, Point.TOP_RIGHT),
 656                        Delay(4.0),
 657                        Spawn(ExplodeyBot, Point.TOP_LEFT),
 658                    ]
 659                ),
 660                Wave(
 661                    entries=[
 662                        Spawn(ChargerBot, Point.LEFT),
 663                        Spawn(ChargerBot, Point.RIGHT),
 664                        (
 665                            Spawn(ChargerBot, Point.RIGHT_UPPER_MORE)
 666                            if player_count > 2
 667                            else None
 668                        ),
 669                        Spawn(BomberBotProStatic, Point.TURRET_TOP_LEFT),
 670                        Spawn(BomberBotProStatic, Point.TURRET_TOP_RIGHT),
 671                    ]
 672                ),
 673                Wave(
 674                    entries=[
 675                        Spawn(TriggerBotPro, Point.TOP_RIGHT),
 676                        (
 677                            Spawn(TriggerBotPro, Point.RIGHT_UPPER_MORE)
 678                            if player_count > 1
 679                            else None
 680                        ),
 681                        Spawn(TriggerBotPro, Point.RIGHT_UPPER),
 682                        (
 683                            Spawn(TriggerBotPro, Point.RIGHT_LOWER)
 684                            if hard
 685                            else None
 686                        ),
 687                        (
 688                            Spawn(TriggerBotPro, Point.RIGHT_LOWER_MORE)
 689                            if player_count > 2
 690                            else None
 691                        ),
 692                        Spawn(TriggerBotPro, Point.BOTTOM_RIGHT),
 693                    ]
 694                ),
 695                Wave(
 696                    entries=[
 697                        Spawn(ChargerBotProShielded, Point.BOTTOM_RIGHT),
 698                        (
 699                            Spawn(ChargerBotProShielded, Point.BOTTOM)
 700                            if player_count > 2
 701                            else None
 702                        ),
 703                        Spawn(ChargerBotProShielded, Point.BOTTOM_LEFT),
 704                        (
 705                            Spawn(ChargerBotProShielded, Point.TOP)
 706                            if hard
 707                            else None
 708                        ),
 709                        Spawn(BomberBotProStatic, Point.TURRET_TOP_MIDDLE),
 710                    ]
 711                ),
 712                Wave(
 713                    entries=[
 714                        Spawn(ExplodeyBot, Point.LEFT_UPPER),
 715                        Delay(1.0),
 716                        Spawn(BrawlerBotProShielded, Point.LEFT_LOWER),
 717                        Spawn(BrawlerBotProShielded, Point.LEFT_LOWER_MORE),
 718                        Delay(4.0),
 719                        Spawn(ExplodeyBot, Point.RIGHT_UPPER),
 720                        Delay(1.0),
 721                        Spawn(BrawlerBotProShielded, Point.RIGHT_LOWER),
 722                        Spawn(BrawlerBotProShielded, Point.RIGHT_UPPER_MORE),
 723                        Delay(4.0),
 724                        Spawn(ExplodeyBot, Point.LEFT),
 725                        Delay(5.0),
 726                        Spawn(ExplodeyBot, Point.RIGHT),
 727                    ]
 728                ),
 729                Wave(
 730                    entries=[
 731                        Spawn(BomberBotProStatic, Point.TURRET_TOP_LEFT),
 732                        Spawn(BomberBotProStatic, Point.TURRET_TOP_RIGHT),
 733                        Spawn(BomberBotProStatic, Point.TURRET_BOTTOM_LEFT),
 734                        Spawn(BomberBotProStatic, Point.TURRET_BOTTOM_RIGHT),
 735                        (
 736                            Spawn(
 737                                BomberBotProStatic, Point.TURRET_TOP_MIDDLE_LEFT
 738                            )
 739                            if hard
 740                            else None
 741                        ),
 742                        (
 743                            Spawn(
 744                                BomberBotProStatic,
 745                                Point.TURRET_TOP_MIDDLE_RIGHT,
 746                            )
 747                            if hard
 748                            else None
 749                        ),
 750                    ]
 751                ),
 752            ]
 753
 754        # We generate these on the fly in endless.
 755        elif self._preset in {Preset.ENDLESS, Preset.ENDLESS_TOURNAMENT}:
 756            self._have_tnt = True
 757            self._excluded_powerups = []
 758            self._waves = []
 759
 760        else:
 761            raise RuntimeError(f'Invalid preset: {self._preset}')
 762
 763        # FIXME: Should migrate to use setup_standard_powerup_drops().
 764
 765        # Spit out a few powerups and start dropping more shortly.
 766        self._drop_powerups(
 767            standard_points=True,
 768            poweruptype=(
 769                'curse'
 770                if self._preset in [Preset.UBER, Preset.UBER_EASY]
 771                else (
 772                    'land_mines'
 773                    if self._preset in [Preset.ROOKIE, Preset.ROOKIE_EASY]
 774                    else None
 775                )
 776            ),
 777        )
 778        bs.timer(4.0, self._start_powerup_drops)
 779
 780        # Our TNT spawner (if applicable).
 781        if self._have_tnt:
 782            self._tntspawner = TNTSpawner(position=self._tntspawnpos)
 783
 784        self.setup_low_life_warning_sound()
 785        self._update_scores()
 786        self._bots = SpazBotSet()
 787        bs.timer(4.0, self._start_updating_waves)
 788
 789    def _get_dist_grp_totals(self, grps: list[Any]) -> tuple[int, int]:
 790        totalpts = 0
 791        totaldudes = 0
 792        for grp in grps:
 793            for grpentry in grp:
 794                dudes = grpentry[1]
 795                totalpts += grpentry[0] * dudes
 796                totaldudes += dudes
 797        return totalpts, totaldudes
 798
 799    def _get_distribution(
 800        self,
 801        target_points: int,
 802        min_dudes: int,
 803        max_dudes: int,
 804        group_count: int,
 805        max_level: int,
 806    ) -> list[list[tuple[int, int]]]:
 807        """Calculate a distribution of bad guys given some params."""
 808        # pylint: disable=too-many-positional-arguments
 809        max_iterations = 10 + max_dudes * 2
 810
 811        groups: list[list[tuple[int, int]]] = []
 812        for _g in range(group_count):
 813            groups.append([])
 814        types = [1]
 815        if max_level > 1:
 816            types.append(2)
 817        if max_level > 2:
 818            types.append(3)
 819        if max_level > 3:
 820            types.append(4)
 821        for iteration in range(max_iterations):
 822            diff = self._add_dist_entry_if_possible(
 823                groups, max_dudes, target_points, types
 824            )
 825
 826            total_points, total_dudes = self._get_dist_grp_totals(groups)
 827            full = total_points >= target_points
 828
 829            if full:
 830                # Every so often, delete a random entry just to
 831                # shake up our distribution.
 832                if random.random() < 0.2 and iteration != max_iterations - 1:
 833                    self._delete_random_dist_entry(groups)
 834
 835                # If we don't have enough dudes, kill the group with
 836                # the biggest point value.
 837                elif (
 838                    total_dudes < min_dudes and iteration != max_iterations - 1
 839                ):
 840                    self._delete_biggest_dist_entry(groups)
 841
 842                # If we've got too many dudes, kill the group with the
 843                # smallest point value.
 844                elif (
 845                    total_dudes > max_dudes and iteration != max_iterations - 1
 846                ):
 847                    self._delete_smallest_dist_entry(groups)
 848
 849                # Close enough.. we're done.
 850                else:
 851                    if diff == 0:
 852                        break
 853
 854        return groups
 855
 856    def _add_dist_entry_if_possible(
 857        self,
 858        groups: list[list[tuple[int, int]]],
 859        max_dudes: int,
 860        target_points: int,
 861        types: list[int],
 862    ) -> int:
 863        # See how much we're off our target by.
 864        total_points, total_dudes = self._get_dist_grp_totals(groups)
 865        diff = target_points - total_points
 866        dudes_diff = max_dudes - total_dudes
 867
 868        # Add an entry if one will fit.
 869        value = types[random.randrange(len(types))]
 870        group = groups[random.randrange(len(groups))]
 871        if not group:
 872            max_count = random.randint(1, 6)
 873        else:
 874            max_count = 2 * random.randint(1, 3)
 875        max_count = min(max_count, dudes_diff)
 876        count = min(max_count, diff // value)
 877        if count > 0:
 878            group.append((value, count))
 879            total_points += value * count
 880            total_dudes += count
 881            diff = target_points - total_points
 882        return diff
 883
 884    def _delete_smallest_dist_entry(
 885        self, groups: list[list[tuple[int, int]]]
 886    ) -> None:
 887        smallest_value = 9999
 888        smallest_entry = None
 889        smallest_entry_group = None
 890        for group in groups:
 891            for entry in group:
 892                if entry[0] < smallest_value or smallest_entry is None:
 893                    smallest_value = entry[0]
 894                    smallest_entry = entry
 895                    smallest_entry_group = group
 896        assert smallest_entry is not None
 897        assert smallest_entry_group is not None
 898        smallest_entry_group.remove(smallest_entry)
 899
 900    def _delete_biggest_dist_entry(
 901        self, groups: list[list[tuple[int, int]]]
 902    ) -> None:
 903        biggest_value = 9999
 904        biggest_entry = None
 905        biggest_entry_group = None
 906        for group in groups:
 907            for entry in group:
 908                if entry[0] > biggest_value or biggest_entry is None:
 909                    biggest_value = entry[0]
 910                    biggest_entry = entry
 911                    biggest_entry_group = group
 912        if biggest_entry is not None:
 913            assert biggest_entry_group is not None
 914            biggest_entry_group.remove(biggest_entry)
 915
 916    def _delete_random_dist_entry(
 917        self, groups: list[list[tuple[int, int]]]
 918    ) -> None:
 919        entry_count = 0
 920        for group in groups:
 921            for _ in group:
 922                entry_count += 1
 923        if entry_count > 1:
 924            del_entry = random.randrange(entry_count)
 925            entry_count = 0
 926            for group in groups:
 927                for entry in group:
 928                    if entry_count == del_entry:
 929                        group.remove(entry)
 930                        break
 931                    entry_count += 1
 932
 933    @override
 934    def spawn_player(self, player: Player) -> bs.Actor:
 935        # We keep track of who got hurt each wave for score purposes.
 936        player.has_been_hurt = False
 937        pos = (
 938            self._spawn_center[0] + random.uniform(-1.5, 1.5),
 939            self._spawn_center[1],
 940            self._spawn_center[2] + random.uniform(-1.5, 1.5),
 941        )
 942        spaz = self.spawn_player_spaz(player, position=pos)
 943        if self._preset in {
 944            Preset.TRAINING_EASY,
 945            Preset.ROOKIE_EASY,
 946            Preset.PRO_EASY,
 947            Preset.UBER_EASY,
 948        }:
 949            spaz.impact_scale = 0.25
 950        spaz.add_dropped_bomb_callback(self._handle_player_dropped_bomb)
 951        return spaz
 952
 953    def _handle_player_dropped_bomb(
 954        self, player: bs.Actor, bomb: bs.Actor
 955    ) -> None:
 956        del player, bomb  # Unused.
 957        self._player_has_dropped_bomb = True
 958
 959    def _drop_powerup(self, index: int, poweruptype: str | None = None) -> None:
 960        poweruptype = PowerupBoxFactory.get().get_random_powerup_type(
 961            forcetype=poweruptype, excludetypes=self._excluded_powerups
 962        )
 963        PowerupBox(
 964            position=self.map.powerup_spawn_points[index],
 965            poweruptype=poweruptype,
 966        ).autoretain()
 967
 968    def _start_powerup_drops(self) -> None:
 969        self._powerup_drop_timer = bs.Timer(
 970            3.0, bs.WeakCall(self._drop_powerups), repeat=True
 971        )
 972
 973    def _drop_powerups(
 974        self, standard_points: bool = False, poweruptype: str | None = None
 975    ) -> None:
 976        """Generic powerup drop."""
 977        if standard_points:
 978            points = self.map.powerup_spawn_points
 979            for i in range(len(points)):
 980                bs.timer(
 981                    1.0 + i * 0.5,
 982                    bs.WeakCall(
 983                        self._drop_powerup, i, poweruptype if i == 0 else None
 984                    ),
 985                )
 986        else:
 987            point = (
 988                self._powerup_center[0]
 989                + random.uniform(
 990                    -1.0 * self._powerup_spread[0],
 991                    1.0 * self._powerup_spread[0],
 992                ),
 993                self._powerup_center[1],
 994                self._powerup_center[2]
 995                + random.uniform(
 996                    -self._powerup_spread[1], self._powerup_spread[1]
 997                ),
 998            )
 999
1000            # Drop one random one somewhere.
1001            PowerupBox(
1002                position=point,
1003                poweruptype=PowerupBoxFactory.get().get_random_powerup_type(
1004                    excludetypes=self._excluded_powerups
1005                ),
1006            ).autoretain()
1007
1008    def do_end(self, outcome: str, delay: float = 0.0) -> None:
1009        """End the game with the specified outcome."""
1010        if outcome == 'defeat':
1011            self.fade_to_red()
1012        score: int | None
1013        if self._wavenum >= 2:
1014            score = self._score
1015            fail_message = None
1016        else:
1017            score = None
1018            fail_message = bs.Lstr(resource='reachWave2Text')
1019        self.end(
1020            {
1021                'outcome': outcome,
1022                'score': score,
1023                'fail_message': fail_message,
1024                'playerinfos': self.initialplayerinfos,
1025            },
1026            delay=delay,
1027        )
1028
1029    def _award_completion_achievements(self) -> None:
1030        if self._preset in {Preset.TRAINING, Preset.TRAINING_EASY}:
1031            self._award_achievement('Onslaught Training Victory', sound=False)
1032            if not self._player_has_dropped_bomb:
1033                self._award_achievement('Boxer', sound=False)
1034        elif self._preset in {Preset.ROOKIE, Preset.ROOKIE_EASY}:
1035            self._award_achievement('Rookie Onslaught Victory', sound=False)
1036            if not self._a_player_has_been_hurt:
1037                self._award_achievement('Flawless Victory', sound=False)
1038        elif self._preset in {Preset.PRO, Preset.PRO_EASY}:
1039            self._award_achievement('Pro Onslaught Victory', sound=False)
1040            if not self._player_has_dropped_bomb:
1041                self._award_achievement('Pro Boxer', sound=False)
1042        elif self._preset in {Preset.UBER, Preset.UBER_EASY}:
1043            self._award_achievement('Uber Onslaught Victory', sound=False)
1044
1045    def _update_waves(self) -> None:
1046        # If we have no living bots, go to the next wave.
1047        assert self._bots is not None
1048        if (
1049            self._can_end_wave
1050            and not self._bots.have_living_bots()
1051            and not self._game_over
1052        ):
1053            self._can_end_wave = False
1054            self._time_bonus_timer = None
1055            self._time_bonus_text = None
1056            if self._preset in {Preset.ENDLESS, Preset.ENDLESS_TOURNAMENT}:
1057                won = False
1058            else:
1059                won = self._wavenum == len(self._waves)
1060
1061            base_delay = 4.0 if won else 0.0
1062
1063            # Reward time bonus.
1064            if self._time_bonus > 0:
1065                bs.timer(0, self._cashregistersound.play)
1066                bs.timer(
1067                    base_delay,
1068                    bs.WeakCall(self._award_time_bonus, self._time_bonus),
1069                )
1070                base_delay += 1.0
1071
1072            # Reward flawless bonus.
1073            if self._wavenum > 0:
1074                have_flawless = False
1075                for player in self.players:
1076                    if player.is_alive() and not player.has_been_hurt:
1077                        have_flawless = True
1078                        bs.timer(
1079                            base_delay,
1080                            bs.WeakCall(self._award_flawless_bonus, player),
1081                        )
1082                    player.has_been_hurt = False  # reset
1083                if have_flawless:
1084                    base_delay += 1.0
1085
1086            if won:
1087                self.show_zoom_message(
1088                    bs.Lstr(resource='victoryText'), scale=1.0, duration=4.0
1089                )
1090                self.celebrate(20.0)
1091                self._award_completion_achievements()
1092                bs.timer(base_delay, bs.WeakCall(self._award_completion_bonus))
1093                base_delay += 0.85
1094                self._winsound.play()
1095                bs.cameraflash()
1096                bs.setmusic(bs.MusicType.VICTORY)
1097                self._game_over = True
1098
1099                # Can't just pass delay to do_end because our extra bonuses
1100                # haven't been added yet (once we call do_end the score
1101                # gets locked in).
1102                bs.timer(base_delay, bs.WeakCall(self.do_end, 'victory'))
1103                return
1104
1105            self._wavenum += 1
1106
1107            # Short celebration after waves.
1108            if self._wavenum > 1:
1109                self.celebrate(0.5)
1110            bs.timer(base_delay, bs.WeakCall(self._start_next_wave))
1111
1112    def _award_completion_bonus(self) -> None:
1113        self._cashregistersound.play()
1114        for player in self.players:
1115            try:
1116                if player.is_alive():
1117                    assert self.initialplayerinfos is not None
1118                    self.stats.player_scored(
1119                        player,
1120                        int(100 / len(self.initialplayerinfos)),
1121                        scale=1.4,
1122                        color=(0.6, 0.6, 1.0, 1.0),
1123                        title=bs.Lstr(resource='completionBonusText'),
1124                        screenmessage=False,
1125                    )
1126            except Exception:
1127                logging.exception('error in _award_completion_bonus')
1128
1129    def _award_time_bonus(self, bonus: int) -> None:
1130        self._cashregistersound.play()
1131        PopupText(
1132            bs.Lstr(
1133                value='+${A} ${B}',
1134                subs=[
1135                    ('${A}', str(bonus)),
1136                    ('${B}', bs.Lstr(resource='timeBonusText')),
1137                ],
1138            ),
1139            color=(1, 1, 0.5, 1),
1140            scale=1.0,
1141            position=(0, 3, -1),
1142        ).autoretain()
1143        self._score += self._time_bonus
1144        self._update_scores()
1145
1146    def _award_flawless_bonus(self, player: Player) -> None:
1147        self._cashregistersound.play()
1148        try:
1149            if player.is_alive():
1150                assert self._flawless_bonus is not None
1151                self.stats.player_scored(
1152                    player,
1153                    self._flawless_bonus,
1154                    scale=1.2,
1155                    color=(0.6, 1.0, 0.6, 1.0),
1156                    title=bs.Lstr(resource='flawlessWaveText'),
1157                    screenmessage=False,
1158                )
1159        except Exception:
1160            logging.exception('error in _award_flawless_bonus')
1161
1162    def _start_time_bonus_timer(self) -> None:
1163        self._time_bonus_timer = bs.Timer(
1164            1.0, bs.WeakCall(self._update_time_bonus), repeat=True
1165        )
1166
1167    def _update_player_spawn_info(self) -> None:
1168        # If we have no living players lets just blank this.
1169        assert self._spawn_info_text is not None
1170        assert self._spawn_info_text.node
1171        if not any(player.is_alive() for player in self.teams[0].players):
1172            self._spawn_info_text.node.text = ''
1173        else:
1174            text: str | bs.Lstr = ''
1175            for player in self.players:
1176                if not player.is_alive() and (
1177                    self._preset in [Preset.ENDLESS, Preset.ENDLESS_TOURNAMENT]
1178                    or (player.respawn_wave <= len(self._waves))
1179                ):
1180                    rtxt = bs.Lstr(
1181                        resource='onslaughtRespawnText',
1182                        subs=[
1183                            ('${PLAYER}', player.getname()),
1184                            ('${WAVE}', str(player.respawn_wave)),
1185                        ],
1186                    )
1187                    text = bs.Lstr(
1188                        value='${A}${B}\n',
1189                        subs=[
1190                            ('${A}', text),
1191                            ('${B}', rtxt),
1192                        ],
1193                    )
1194            self._spawn_info_text.node.text = text
1195
1196    def _respawn_players_for_wave(self) -> None:
1197        # Respawn applicable players.
1198        if self._wavenum > 1:
1199            for player in self.players:
1200                if (
1201                    not player.is_alive()
1202                    and player.respawn_wave == self._wavenum
1203                ):
1204                    self.spawn_player(player)
1205        self._update_player_spawn_info()
1206
1207    def _setup_wave_spawns(self, wave: Wave) -> None:
1208        tval = 0.0
1209        dtime = 0.2
1210        if self._wavenum == 1:
1211            spawn_time = 3.973
1212            tval += 0.5
1213        else:
1214            spawn_time = 2.648
1215
1216        bot_angle = wave.base_angle
1217        self._time_bonus = 0
1218        self._flawless_bonus = 0
1219        for info in wave.entries:
1220            if info is None:
1221                continue
1222            if isinstance(info, Delay):
1223                spawn_time += info.duration
1224                continue
1225            if isinstance(info, Spacing):
1226                bot_angle += info.spacing
1227                continue
1228            bot_type_2 = info.bottype
1229            if bot_type_2 is not None:
1230                assert not isinstance(bot_type_2, str)
1231                self._time_bonus += bot_type_2.points_mult * 20
1232                self._flawless_bonus += bot_type_2.points_mult * 5
1233
1234            # If its got a position, use that.
1235            point = info.point
1236            if point is not None:
1237                assert bot_type_2 is not None
1238                spcall = bs.WeakCall(
1239                    self.add_bot_at_point, point, bot_type_2, spawn_time
1240                )
1241                bs.timer(tval, spcall)
1242                tval += dtime
1243            else:
1244                spacing = info.spacing
1245                bot_angle += spacing * 0.5
1246                if bot_type_2 is not None:
1247                    tcall = bs.WeakCall(
1248                        self.add_bot_at_angle, bot_angle, bot_type_2, spawn_time
1249                    )
1250                    bs.timer(tval, tcall)
1251                    tval += dtime
1252                bot_angle += spacing * 0.5
1253
1254        # We can end the wave after all the spawning happens.
1255        bs.timer(
1256            tval + spawn_time - dtime + 0.01,
1257            bs.WeakCall(self._set_can_end_wave),
1258        )
1259
1260    def _start_next_wave(self) -> None:
1261        # This can happen if we beat a wave as we die.
1262        # We don't wanna respawn players and whatnot if this happens.
1263        if self._game_over:
1264            return
1265
1266        self._respawn_players_for_wave()
1267        if self._preset in {Preset.ENDLESS, Preset.ENDLESS_TOURNAMENT}:
1268            wave = self._generate_random_wave()
1269        else:
1270            wave = self._waves[self._wavenum - 1]
1271        self._setup_wave_spawns(wave)
1272        self._update_wave_ui_and_bonuses()
1273        bs.timer(0.4, self._new_wave_sound.play)
1274
1275    def _update_wave_ui_and_bonuses(self) -> None:
1276        self.show_zoom_message(
1277            bs.Lstr(
1278                value='${A} ${B}',
1279                subs=[
1280                    ('${A}', bs.Lstr(resource='waveText')),
1281                    ('${B}', str(self._wavenum)),
1282                ],
1283            ),
1284            scale=1.0,
1285            duration=1.0,
1286            trail=True,
1287        )
1288
1289        # Reset our time bonus.
1290        tbtcolor = (1, 1, 0, 1)
1291        tbttxt = bs.Lstr(
1292            value='${A}: ${B}',
1293            subs=[
1294                ('${A}', bs.Lstr(resource='timeBonusText')),
1295                ('${B}', str(self._time_bonus)),
1296            ],
1297        )
1298        self._time_bonus_text = bs.NodeActor(
1299            bs.newnode(
1300                'text',
1301                attrs={
1302                    'v_attach': 'top',
1303                    'h_attach': 'center',
1304                    'h_align': 'center',
1305                    'vr_depth': -30,
1306                    'color': tbtcolor,
1307                    'shadow': 1.0,
1308                    'flatness': 1.0,
1309                    'position': (0, -60),
1310                    'scale': 0.8,
1311                    'text': tbttxt,
1312                },
1313            )
1314        )
1315
1316        bs.timer(5.0, bs.WeakCall(self._start_time_bonus_timer))
1317        wtcolor = (1, 1, 1, 1)
1318        wttxt = bs.Lstr(
1319            value='${A} ${B}',
1320            subs=[
1321                ('${A}', bs.Lstr(resource='waveText')),
1322                (
1323                    '${B}',
1324                    str(self._wavenum)
1325                    + (
1326                        ''
1327                        if self._preset
1328                        in [Preset.ENDLESS, Preset.ENDLESS_TOURNAMENT]
1329                        else ('/' + str(len(self._waves)))
1330                    ),
1331                ),
1332            ],
1333        )
1334        self._wave_text = bs.NodeActor(
1335            bs.newnode(
1336                'text',
1337                attrs={
1338                    'v_attach': 'top',
1339                    'h_attach': 'center',
1340                    'h_align': 'center',
1341                    'vr_depth': -10,
1342                    'color': wtcolor,
1343                    'shadow': 1.0,
1344                    'flatness': 1.0,
1345                    'position': (0, -40),
1346                    'scale': 1.3,
1347                    'text': wttxt,
1348                },
1349            )
1350        )
1351
1352    def _bot_levels_for_wave(self) -> list[list[type[SpazBot]]]:
1353        level = self._wavenum
1354        bot_types = [
1355            BomberBot,
1356            BrawlerBot,
1357            TriggerBot,
1358            ChargerBot,
1359            BomberBotPro,
1360            BrawlerBotPro,
1361            TriggerBotPro,
1362            BomberBotProShielded,
1363            ExplodeyBot,
1364            ChargerBotProShielded,
1365            StickyBot,
1366            BrawlerBotProShielded,
1367            TriggerBotProShielded,
1368        ]
1369        if level > 5:
1370            bot_types += [
1371                ExplodeyBot,
1372                TriggerBotProShielded,
1373                BrawlerBotProShielded,
1374                ChargerBotProShielded,
1375            ]
1376        if level > 7:
1377            bot_types += [
1378                ExplodeyBot,
1379                TriggerBotProShielded,
1380                BrawlerBotProShielded,
1381                ChargerBotProShielded,
1382            ]
1383        if level > 10:
1384            bot_types += [
1385                TriggerBotProShielded,
1386                TriggerBotProShielded,
1387                TriggerBotProShielded,
1388                TriggerBotProShielded,
1389            ]
1390        if level > 13:
1391            bot_types += [
1392                TriggerBotProShielded,
1393                TriggerBotProShielded,
1394                TriggerBotProShielded,
1395                TriggerBotProShielded,
1396            ]
1397        bot_levels = [
1398            [b for b in bot_types if b.points_mult == 1],
1399            [b for b in bot_types if b.points_mult == 2],
1400            [b for b in bot_types if b.points_mult == 3],
1401            [b for b in bot_types if b.points_mult == 4],
1402        ]
1403
1404        # Make sure all lists have something in them
1405        if not all(bot_levels):
1406            raise RuntimeError('Got empty bot level')
1407        return bot_levels
1408
1409    def _add_entries_for_distribution_group(
1410        self,
1411        group: list[tuple[int, int]],
1412        bot_levels: list[list[type[SpazBot]]],
1413        all_entries: list[Spawn | Spacing | Delay | None],
1414    ) -> None:
1415        entries: list[Spawn | Spacing | Delay | None] = []
1416        for entry in group:
1417            bot_level = bot_levels[entry[0] - 1]
1418            bot_type = bot_level[random.randrange(len(bot_level))]
1419            rval = random.random()
1420            if rval < 0.5:
1421                spacing = 10.0
1422            elif rval < 0.9:
1423                spacing = 20.0
1424            else:
1425                spacing = 40.0
1426            split = random.random() > 0.3
1427            for i in range(entry[1]):
1428                if split and i % 2 == 0:
1429                    entries.insert(0, Spawn(bot_type, spacing=spacing))
1430                else:
1431                    entries.append(Spawn(bot_type, spacing=spacing))
1432        if entries:
1433            all_entries += entries
1434            all_entries.append(Spacing(40.0 if random.random() < 0.5 else 80.0))
1435
1436    def _generate_random_wave(self) -> Wave:
1437        level = self._wavenum
1438        bot_levels = self._bot_levels_for_wave()
1439
1440        target_points = level * 3 - 2
1441        min_dudes = min(1 + level // 3, 10)
1442        max_dudes = min(10, level + 1)
1443        max_level = (
1444            4 if level > 6 else (3 if level > 3 else (2 if level > 2 else 1))
1445        )
1446        group_count = 3
1447        distribution = self._get_distribution(
1448            target_points, min_dudes, max_dudes, group_count, max_level
1449        )
1450        all_entries: list[Spawn | Spacing | Delay | None] = []
1451        for group in distribution:
1452            self._add_entries_for_distribution_group(
1453                group, bot_levels, all_entries
1454            )
1455        angle_rand = random.random()
1456        if angle_rand > 0.75:
1457            base_angle = 130.0
1458        elif angle_rand > 0.5:
1459            base_angle = 210.0
1460        elif angle_rand > 0.25:
1461            base_angle = 20.0
1462        else:
1463            base_angle = -30.0
1464        base_angle += (0.5 - random.random()) * 20.0
1465        wave = Wave(base_angle=base_angle, entries=all_entries)
1466        return wave
1467
1468    def add_bot_at_point(
1469        self, point: Point, spaz_type: type[SpazBot], spawn_time: float = 1.0
1470    ) -> None:
1471        """Add a new bot at a specified named point."""
1472        if self._game_over:
1473            return
1474        assert isinstance(point.value, str)
1475        pointpos = self.map.defs.points[point.value]
1476        assert self._bots is not None
1477        self._bots.spawn_bot(spaz_type, pos=pointpos, spawn_time=spawn_time)
1478
1479    def add_bot_at_angle(
1480        self, angle: float, spaz_type: type[SpazBot], spawn_time: float = 1.0
1481    ) -> None:
1482        """Add a new bot at a specified angle (for circular maps)."""
1483        if self._game_over:
1484            return
1485        angle_radians = angle / 57.2957795
1486        xval = math.sin(angle_radians) * 1.06
1487        zval = math.cos(angle_radians) * 1.06
1488        point = (xval / 0.125, 2.3, (zval / 0.2) - 3.7)
1489        assert self._bots is not None
1490        self._bots.spawn_bot(spaz_type, pos=point, spawn_time=spawn_time)
1491
1492    def _update_time_bonus(self) -> None:
1493        self._time_bonus = int(self._time_bonus * 0.93)
1494        if self._time_bonus > 0 and self._time_bonus_text is not None:
1495            assert self._time_bonus_text.node
1496            self._time_bonus_text.node.text = bs.Lstr(
1497                value='${A}: ${B}',
1498                subs=[
1499                    ('${A}', bs.Lstr(resource='timeBonusText')),
1500                    ('${B}', str(self._time_bonus)),
1501                ],
1502            )
1503        else:
1504            self._time_bonus_text = None
1505
1506    def _start_updating_waves(self) -> None:
1507        self._wave_update_timer = bs.Timer(
1508            2.0, bs.WeakCall(self._update_waves), repeat=True
1509        )
1510
1511    def _update_scores(self) -> None:
1512        score = self._score
1513        if self._preset is Preset.ENDLESS:
1514            if score >= 500:
1515                self._award_achievement('Onslaught Master')
1516            if score >= 1000:
1517                self._award_achievement('Onslaught Wizard')
1518            if score >= 5000:
1519                self._award_achievement('Onslaught God')
1520        assert self._scoreboard is not None
1521        self._scoreboard.set_team_value(self.teams[0], score, max_score=None)
1522
1523    @override
1524    def handlemessage(self, msg: Any) -> Any:
1525        if isinstance(msg, PlayerSpazHurtMessage):
1526            msg.spaz.getplayer(Player, True).has_been_hurt = True
1527            self._a_player_has_been_hurt = True
1528
1529        elif isinstance(msg, bs.PlayerScoredMessage):
1530            self._score += msg.score
1531            self._update_scores()
1532
1533        elif isinstance(msg, bs.PlayerDiedMessage):
1534            super().handlemessage(msg)  # Augment standard behavior.
1535            player = msg.getplayer(Player)
1536            self._a_player_has_been_hurt = True
1537
1538            # Make note with the player when they can respawn:
1539            if self._wavenum < 10:
1540                player.respawn_wave = max(2, self._wavenum + 1)
1541            elif self._wavenum < 15:
1542                player.respawn_wave = max(2, self._wavenum + 2)
1543            else:
1544                player.respawn_wave = max(2, self._wavenum + 3)
1545            bs.timer(0.1, self._update_player_spawn_info)
1546            bs.timer(0.1, self._checkroundover)
1547
1548        elif isinstance(msg, SpazBotDiedMessage):
1549            pts, importance = msg.spazbot.get_death_points(msg.how)
1550            if msg.killerplayer is not None:
1551                self._handle_kill_achievements(msg)
1552                target: Sequence[float] | None
1553                if msg.spazbot.node:
1554                    target = msg.spazbot.node.position
1555                else:
1556                    target = None
1557
1558                killerplayer = msg.killerplayer
1559                self.stats.player_scored(
1560                    killerplayer,
1561                    pts,
1562                    target=target,
1563                    kill=True,
1564                    screenmessage=False,
1565                    importance=importance,
1566                )
1567                dingsound = (
1568                    self._dingsound if importance == 1 else self._dingsoundhigh
1569                )
1570                dingsound.play(volume=0.6)
1571
1572            # Normally we pull scores from the score-set, but if there's
1573            # no player lets be explicit.
1574            else:
1575                self._score += pts
1576            self._update_scores()
1577        else:
1578            super().handlemessage(msg)
1579
1580    def _handle_kill_achievements(self, msg: SpazBotDiedMessage) -> None:
1581        if self._preset in {Preset.TRAINING, Preset.TRAINING_EASY}:
1582            self._handle_training_kill_achievements(msg)
1583        elif self._preset in {Preset.ROOKIE, Preset.ROOKIE_EASY}:
1584            self._handle_rookie_kill_achievements(msg)
1585        elif self._preset in {Preset.PRO, Preset.PRO_EASY}:
1586            self._handle_pro_kill_achievements(msg)
1587        elif self._preset in {Preset.UBER, Preset.UBER_EASY}:
1588            self._handle_uber_kill_achievements(msg)
1589
1590    def _handle_uber_kill_achievements(self, msg: SpazBotDiedMessage) -> None:
1591        # Uber mine achievement:
1592        if msg.spazbot.last_attacked_type == ('explosion', 'land_mine'):
1593            self._land_mine_kills += 1
1594            if self._land_mine_kills >= 6:
1595                self._award_achievement('Gold Miner')
1596
1597        # Uber tnt achievement:
1598        if msg.spazbot.last_attacked_type == ('explosion', 'tnt'):
1599            self._tnt_kills += 1
1600            if self._tnt_kills >= 6:
1601                bs.timer(
1602                    0.5, bs.WeakCall(self._award_achievement, 'TNT Terror')
1603                )
1604
1605    def _handle_pro_kill_achievements(self, msg: SpazBotDiedMessage) -> None:
1606        # TNT achievement:
1607        if msg.spazbot.last_attacked_type == ('explosion', 'tnt'):
1608            self._tnt_kills += 1
1609            if self._tnt_kills >= 3:
1610                bs.timer(
1611                    0.5,
1612                    bs.WeakCall(
1613                        self._award_achievement, 'Boom Goes the Dynamite'
1614                    ),
1615                )
1616
1617    def _handle_rookie_kill_achievements(self, msg: SpazBotDiedMessage) -> None:
1618        # Land-mine achievement:
1619        if msg.spazbot.last_attacked_type == ('explosion', 'land_mine'):
1620            self._land_mine_kills += 1
1621            if self._land_mine_kills >= 3:
1622                self._award_achievement('Mine Games')
1623
1624    def _handle_training_kill_achievements(
1625        self, msg: SpazBotDiedMessage
1626    ) -> None:
1627        # Toss-off-map achievement:
1628        if msg.spazbot.last_attacked_type == ('picked_up', 'default'):
1629            self._throw_off_kills += 1
1630            if self._throw_off_kills >= 3:
1631                self._award_achievement('Off You Go Then')
1632
1633    def _set_can_end_wave(self) -> None:
1634        self._can_end_wave = True
1635
1636    @override
1637    def end_game(self) -> None:
1638        # Tell our bots to celebrate just to rub it in.
1639        assert self._bots is not None
1640        self._bots.final_celebrate()
1641        self._game_over = True
1642        self.do_end('defeat', delay=2.0)
1643        bs.setmusic(None)
1644
1645    def _checkroundover(self) -> None:
1646        """Potentially end the round based on the state of the game."""
1647        if self.has_ended():
1648            return
1649        if not any(player.is_alive() for player in self.teams[0].players):
1650            self.end_game()