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 8
   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        max_iterations = 10 + max_dudes * 2
 809
 810        groups: list[list[tuple[int, int]]] = []
 811        for _g in range(group_count):
 812            groups.append([])
 813        types = [1]
 814        if max_level > 1:
 815            types.append(2)
 816        if max_level > 2:
 817            types.append(3)
 818        if max_level > 3:
 819            types.append(4)
 820        for iteration in range(max_iterations):
 821            diff = self._add_dist_entry_if_possible(
 822                groups, max_dudes, target_points, types
 823            )
 824
 825            total_points, total_dudes = self._get_dist_grp_totals(groups)
 826            full = total_points >= target_points
 827
 828            if full:
 829                # Every so often, delete a random entry just to
 830                # shake up our distribution.
 831                if random.random() < 0.2 and iteration != max_iterations - 1:
 832                    self._delete_random_dist_entry(groups)
 833
 834                # If we don't have enough dudes, kill the group with
 835                # the biggest point value.
 836                elif (
 837                    total_dudes < min_dudes and iteration != max_iterations - 1
 838                ):
 839                    self._delete_biggest_dist_entry(groups)
 840
 841                # If we've got too many dudes, kill the group with the
 842                # smallest point value.
 843                elif (
 844                    total_dudes > max_dudes and iteration != max_iterations - 1
 845                ):
 846                    self._delete_smallest_dist_entry(groups)
 847
 848                # Close enough.. we're done.
 849                else:
 850                    if diff == 0:
 851                        break
 852
 853        return groups
 854
 855    def _add_dist_entry_if_possible(
 856        self,
 857        groups: list[list[tuple[int, int]]],
 858        max_dudes: int,
 859        target_points: int,
 860        types: list[int],
 861    ) -> int:
 862        # See how much we're off our target by.
 863        total_points, total_dudes = self._get_dist_grp_totals(groups)
 864        diff = target_points - total_points
 865        dudes_diff = max_dudes - total_dudes
 866
 867        # Add an entry if one will fit.
 868        value = types[random.randrange(len(types))]
 869        group = groups[random.randrange(len(groups))]
 870        if not group:
 871            max_count = random.randint(1, 6)
 872        else:
 873            max_count = 2 * random.randint(1, 3)
 874        max_count = min(max_count, dudes_diff)
 875        count = min(max_count, diff // value)
 876        if count > 0:
 877            group.append((value, count))
 878            total_points += value * count
 879            total_dudes += count
 880            diff = target_points - total_points
 881        return diff
 882
 883    def _delete_smallest_dist_entry(
 884        self, groups: list[list[tuple[int, int]]]
 885    ) -> None:
 886        smallest_value = 9999
 887        smallest_entry = None
 888        smallest_entry_group = None
 889        for group in groups:
 890            for entry in group:
 891                if entry[0] < smallest_value or smallest_entry is None:
 892                    smallest_value = entry[0]
 893                    smallest_entry = entry
 894                    smallest_entry_group = group
 895        assert smallest_entry is not None
 896        assert smallest_entry_group is not None
 897        smallest_entry_group.remove(smallest_entry)
 898
 899    def _delete_biggest_dist_entry(
 900        self, groups: list[list[tuple[int, int]]]
 901    ) -> None:
 902        biggest_value = 9999
 903        biggest_entry = None
 904        biggest_entry_group = None
 905        for group in groups:
 906            for entry in group:
 907                if entry[0] > biggest_value or biggest_entry is None:
 908                    biggest_value = entry[0]
 909                    biggest_entry = entry
 910                    biggest_entry_group = group
 911        if biggest_entry is not None:
 912            assert biggest_entry_group is not None
 913            biggest_entry_group.remove(biggest_entry)
 914
 915    def _delete_random_dist_entry(
 916        self, groups: list[list[tuple[int, int]]]
 917    ) -> None:
 918        entry_count = 0
 919        for group in groups:
 920            for _ in group:
 921                entry_count += 1
 922        if entry_count > 1:
 923            del_entry = random.randrange(entry_count)
 924            entry_count = 0
 925            for group in groups:
 926                for entry in group:
 927                    if entry_count == del_entry:
 928                        group.remove(entry)
 929                        break
 930                    entry_count += 1
 931
 932    @override
 933    def spawn_player(self, player: Player) -> bs.Actor:
 934        # We keep track of who got hurt each wave for score purposes.
 935        player.has_been_hurt = False
 936        pos = (
 937            self._spawn_center[0] + random.uniform(-1.5, 1.5),
 938            self._spawn_center[1],
 939            self._spawn_center[2] + random.uniform(-1.5, 1.5),
 940        )
 941        spaz = self.spawn_player_spaz(player, position=pos)
 942        if self._preset in {
 943            Preset.TRAINING_EASY,
 944            Preset.ROOKIE_EASY,
 945            Preset.PRO_EASY,
 946            Preset.UBER_EASY,
 947        }:
 948            spaz.impact_scale = 0.25
 949        spaz.add_dropped_bomb_callback(self._handle_player_dropped_bomb)
 950        return spaz
 951
 952    def _handle_player_dropped_bomb(
 953        self, player: bs.Actor, bomb: bs.Actor
 954    ) -> None:
 955        del player, bomb  # Unused.
 956        self._player_has_dropped_bomb = True
 957
 958    def _drop_powerup(self, index: int, poweruptype: str | None = None) -> None:
 959        poweruptype = PowerupBoxFactory.get().get_random_powerup_type(
 960            forcetype=poweruptype, excludetypes=self._excluded_powerups
 961        )
 962        PowerupBox(
 963            position=self.map.powerup_spawn_points[index],
 964            poweruptype=poweruptype,
 965        ).autoretain()
 966
 967    def _start_powerup_drops(self) -> None:
 968        self._powerup_drop_timer = bs.Timer(
 969            3.0, bs.WeakCall(self._drop_powerups), repeat=True
 970        )
 971
 972    def _drop_powerups(
 973        self, standard_points: bool = False, poweruptype: str | None = None
 974    ) -> None:
 975        """Generic powerup drop."""
 976        if standard_points:
 977            points = self.map.powerup_spawn_points
 978            for i in range(len(points)):
 979                bs.timer(
 980                    1.0 + i * 0.5,
 981                    bs.WeakCall(
 982                        self._drop_powerup, i, poweruptype if i == 0 else None
 983                    ),
 984                )
 985        else:
 986            point = (
 987                self._powerup_center[0]
 988                + random.uniform(
 989                    -1.0 * self._powerup_spread[0],
 990                    1.0 * self._powerup_spread[0],
 991                ),
 992                self._powerup_center[1],
 993                self._powerup_center[2]
 994                + random.uniform(
 995                    -self._powerup_spread[1], self._powerup_spread[1]
 996                ),
 997            )
 998
 999            # Drop one random one somewhere.
1000            PowerupBox(
1001                position=point,
1002                poweruptype=PowerupBoxFactory.get().get_random_powerup_type(
1003                    excludetypes=self._excluded_powerups
1004                ),
1005            ).autoretain()
1006
1007    def do_end(self, outcome: str, delay: float = 0.0) -> None:
1008        """End the game with the specified outcome."""
1009        if outcome == 'defeat':
1010            self.fade_to_red()
1011        score: int | None
1012        if self._wavenum >= 2:
1013            score = self._score
1014            fail_message = None
1015        else:
1016            score = None
1017            fail_message = bs.Lstr(resource='reachWave2Text')
1018        self.end(
1019            {
1020                'outcome': outcome,
1021                'score': score,
1022                'fail_message': fail_message,
1023                'playerinfos': self.initialplayerinfos,
1024            },
1025            delay=delay,
1026        )
1027
1028    def _award_completion_achievements(self) -> None:
1029        if self._preset in {Preset.TRAINING, Preset.TRAINING_EASY}:
1030            self._award_achievement('Onslaught Training Victory', sound=False)
1031            if not self._player_has_dropped_bomb:
1032                self._award_achievement('Boxer', sound=False)
1033        elif self._preset in {Preset.ROOKIE, Preset.ROOKIE_EASY}:
1034            self._award_achievement('Rookie Onslaught Victory', sound=False)
1035            if not self._a_player_has_been_hurt:
1036                self._award_achievement('Flawless Victory', sound=False)
1037        elif self._preset in {Preset.PRO, Preset.PRO_EASY}:
1038            self._award_achievement('Pro Onslaught Victory', sound=False)
1039            if not self._player_has_dropped_bomb:
1040                self._award_achievement('Pro Boxer', sound=False)
1041        elif self._preset in {Preset.UBER, Preset.UBER_EASY}:
1042            self._award_achievement('Uber Onslaught Victory', sound=False)
1043
1044    def _update_waves(self) -> None:
1045        # If we have no living bots, go to the next wave.
1046        assert self._bots is not None
1047        if (
1048            self._can_end_wave
1049            and not self._bots.have_living_bots()
1050            and not self._game_over
1051        ):
1052            self._can_end_wave = False
1053            self._time_bonus_timer = None
1054            self._time_bonus_text = None
1055            if self._preset in {Preset.ENDLESS, Preset.ENDLESS_TOURNAMENT}:
1056                won = False
1057            else:
1058                won = self._wavenum == len(self._waves)
1059
1060            base_delay = 4.0 if won else 0.0
1061
1062            # Reward time bonus.
1063            if self._time_bonus > 0:
1064                bs.timer(0, self._cashregistersound.play)
1065                bs.timer(
1066                    base_delay,
1067                    bs.WeakCall(self._award_time_bonus, self._time_bonus),
1068                )
1069                base_delay += 1.0
1070
1071            # Reward flawless bonus.
1072            if self._wavenum > 0:
1073                have_flawless = False
1074                for player in self.players:
1075                    if player.is_alive() and not player.has_been_hurt:
1076                        have_flawless = True
1077                        bs.timer(
1078                            base_delay,
1079                            bs.WeakCall(self._award_flawless_bonus, player),
1080                        )
1081                    player.has_been_hurt = False  # reset
1082                if have_flawless:
1083                    base_delay += 1.0
1084
1085            if won:
1086                self.show_zoom_message(
1087                    bs.Lstr(resource='victoryText'), scale=1.0, duration=4.0
1088                )
1089                self.celebrate(20.0)
1090                self._award_completion_achievements()
1091                bs.timer(base_delay, bs.WeakCall(self._award_completion_bonus))
1092                base_delay += 0.85
1093                self._winsound.play()
1094                bs.cameraflash()
1095                bs.setmusic(bs.MusicType.VICTORY)
1096                self._game_over = True
1097
1098                # Can't just pass delay to do_end because our extra bonuses
1099                # haven't been added yet (once we call do_end the score
1100                # gets locked in).
1101                bs.timer(base_delay, bs.WeakCall(self.do_end, 'victory'))
1102                return
1103
1104            self._wavenum += 1
1105
1106            # Short celebration after waves.
1107            if self._wavenum > 1:
1108                self.celebrate(0.5)
1109            bs.timer(base_delay, bs.WeakCall(self._start_next_wave))
1110
1111    def _award_completion_bonus(self) -> None:
1112        self._cashregistersound.play()
1113        for player in self.players:
1114            try:
1115                if player.is_alive():
1116                    assert self.initialplayerinfos is not None
1117                    self.stats.player_scored(
1118                        player,
1119                        int(100 / len(self.initialplayerinfos)),
1120                        scale=1.4,
1121                        color=(0.6, 0.6, 1.0, 1.0),
1122                        title=bs.Lstr(resource='completionBonusText'),
1123                        screenmessage=False,
1124                    )
1125            except Exception:
1126                logging.exception('error in _award_completion_bonus')
1127
1128    def _award_time_bonus(self, bonus: int) -> None:
1129        self._cashregistersound.play()
1130        PopupText(
1131            bs.Lstr(
1132                value='+${A} ${B}',
1133                subs=[
1134                    ('${A}', str(bonus)),
1135                    ('${B}', bs.Lstr(resource='timeBonusText')),
1136                ],
1137            ),
1138            color=(1, 1, 0.5, 1),
1139            scale=1.0,
1140            position=(0, 3, -1),
1141        ).autoretain()
1142        self._score += self._time_bonus
1143        self._update_scores()
1144
1145    def _award_flawless_bonus(self, player: Player) -> None:
1146        self._cashregistersound.play()
1147        try:
1148            if player.is_alive():
1149                assert self._flawless_bonus is not None
1150                self.stats.player_scored(
1151                    player,
1152                    self._flawless_bonus,
1153                    scale=1.2,
1154                    color=(0.6, 1.0, 0.6, 1.0),
1155                    title=bs.Lstr(resource='flawlessWaveText'),
1156                    screenmessage=False,
1157                )
1158        except Exception:
1159            logging.exception('error in _award_flawless_bonus')
1160
1161    def _start_time_bonus_timer(self) -> None:
1162        self._time_bonus_timer = bs.Timer(
1163            1.0, bs.WeakCall(self._update_time_bonus), repeat=True
1164        )
1165
1166    def _update_player_spawn_info(self) -> None:
1167        # If we have no living players lets just blank this.
1168        assert self._spawn_info_text is not None
1169        assert self._spawn_info_text.node
1170        if not any(player.is_alive() for player in self.teams[0].players):
1171            self._spawn_info_text.node.text = ''
1172        else:
1173            text: str | bs.Lstr = ''
1174            for player in self.players:
1175                if not player.is_alive() and (
1176                    self._preset in [Preset.ENDLESS, Preset.ENDLESS_TOURNAMENT]
1177                    or (player.respawn_wave <= len(self._waves))
1178                ):
1179                    rtxt = bs.Lstr(
1180                        resource='onslaughtRespawnText',
1181                        subs=[
1182                            ('${PLAYER}', player.getname()),
1183                            ('${WAVE}', str(player.respawn_wave)),
1184                        ],
1185                    )
1186                    text = bs.Lstr(
1187                        value='${A}${B}\n',
1188                        subs=[
1189                            ('${A}', text),
1190                            ('${B}', rtxt),
1191                        ],
1192                    )
1193            self._spawn_info_text.node.text = text
1194
1195    def _respawn_players_for_wave(self) -> None:
1196        # Respawn applicable players.
1197        if self._wavenum > 1 and not self.is_waiting_for_continue():
1198            for player in self.players:
1199                if (
1200                    not player.is_alive()
1201                    and player.respawn_wave == self._wavenum
1202                ):
1203                    self.spawn_player(player)
1204        self._update_player_spawn_info()
1205
1206    def _setup_wave_spawns(self, wave: Wave) -> None:
1207        tval = 0.0
1208        dtime = 0.2
1209        if self._wavenum == 1:
1210            spawn_time = 3.973
1211            tval += 0.5
1212        else:
1213            spawn_time = 2.648
1214
1215        bot_angle = wave.base_angle
1216        self._time_bonus = 0
1217        self._flawless_bonus = 0
1218        for info in wave.entries:
1219            if info is None:
1220                continue
1221            if isinstance(info, Delay):
1222                spawn_time += info.duration
1223                continue
1224            if isinstance(info, Spacing):
1225                bot_angle += info.spacing
1226                continue
1227            bot_type_2 = info.bottype
1228            if bot_type_2 is not None:
1229                assert not isinstance(bot_type_2, str)
1230                self._time_bonus += bot_type_2.points_mult * 20
1231                self._flawless_bonus += bot_type_2.points_mult * 5
1232
1233            # If its got a position, use that.
1234            point = info.point
1235            if point is not None:
1236                assert bot_type_2 is not None
1237                spcall = bs.WeakCall(
1238                    self.add_bot_at_point, point, bot_type_2, spawn_time
1239                )
1240                bs.timer(tval, spcall)
1241                tval += dtime
1242            else:
1243                spacing = info.spacing
1244                bot_angle += spacing * 0.5
1245                if bot_type_2 is not None:
1246                    tcall = bs.WeakCall(
1247                        self.add_bot_at_angle, bot_angle, bot_type_2, spawn_time
1248                    )
1249                    bs.timer(tval, tcall)
1250                    tval += dtime
1251                bot_angle += spacing * 0.5
1252
1253        # We can end the wave after all the spawning happens.
1254        bs.timer(
1255            tval + spawn_time - dtime + 0.01,
1256            bs.WeakCall(self._set_can_end_wave),
1257        )
1258
1259    def _start_next_wave(self) -> None:
1260        # This can happen if we beat a wave as we die.
1261        # We don't wanna respawn players and whatnot if this happens.
1262        if self._game_over:
1263            return
1264
1265        self._respawn_players_for_wave()
1266        if self._preset in {Preset.ENDLESS, Preset.ENDLESS_TOURNAMENT}:
1267            wave = self._generate_random_wave()
1268        else:
1269            wave = self._waves[self._wavenum - 1]
1270        self._setup_wave_spawns(wave)
1271        self._update_wave_ui_and_bonuses()
1272        bs.timer(0.4, self._new_wave_sound.play)
1273
1274    def _update_wave_ui_and_bonuses(self) -> None:
1275        self.show_zoom_message(
1276            bs.Lstr(
1277                value='${A} ${B}',
1278                subs=[
1279                    ('${A}', bs.Lstr(resource='waveText')),
1280                    ('${B}', str(self._wavenum)),
1281                ],
1282            ),
1283            scale=1.0,
1284            duration=1.0,
1285            trail=True,
1286        )
1287
1288        # Reset our time bonus.
1289        tbtcolor = (1, 1, 0, 1)
1290        tbttxt = bs.Lstr(
1291            value='${A}: ${B}',
1292            subs=[
1293                ('${A}', bs.Lstr(resource='timeBonusText')),
1294                ('${B}', str(self._time_bonus)),
1295            ],
1296        )
1297        self._time_bonus_text = bs.NodeActor(
1298            bs.newnode(
1299                'text',
1300                attrs={
1301                    'v_attach': 'top',
1302                    'h_attach': 'center',
1303                    'h_align': 'center',
1304                    'vr_depth': -30,
1305                    'color': tbtcolor,
1306                    'shadow': 1.0,
1307                    'flatness': 1.0,
1308                    'position': (0, -60),
1309                    'scale': 0.8,
1310                    'text': tbttxt,
1311                },
1312            )
1313        )
1314
1315        bs.timer(5.0, bs.WeakCall(self._start_time_bonus_timer))
1316        wtcolor = (1, 1, 1, 1)
1317        wttxt = bs.Lstr(
1318            value='${A} ${B}',
1319            subs=[
1320                ('${A}', bs.Lstr(resource='waveText')),
1321                (
1322                    '${B}',
1323                    str(self._wavenum)
1324                    + (
1325                        ''
1326                        if self._preset
1327                        in [Preset.ENDLESS, Preset.ENDLESS_TOURNAMENT]
1328                        else ('/' + str(len(self._waves)))
1329                    ),
1330                ),
1331            ],
1332        )
1333        self._wave_text = bs.NodeActor(
1334            bs.newnode(
1335                'text',
1336                attrs={
1337                    'v_attach': 'top',
1338                    'h_attach': 'center',
1339                    'h_align': 'center',
1340                    'vr_depth': -10,
1341                    'color': wtcolor,
1342                    'shadow': 1.0,
1343                    'flatness': 1.0,
1344                    'position': (0, -40),
1345                    'scale': 1.3,
1346                    'text': wttxt,
1347                },
1348            )
1349        )
1350
1351    def _bot_levels_for_wave(self) -> list[list[type[SpazBot]]]:
1352        level = self._wavenum
1353        bot_types = [
1354            BomberBot,
1355            BrawlerBot,
1356            TriggerBot,
1357            ChargerBot,
1358            BomberBotPro,
1359            BrawlerBotPro,
1360            TriggerBotPro,
1361            BomberBotProShielded,
1362            ExplodeyBot,
1363            ChargerBotProShielded,
1364            StickyBot,
1365            BrawlerBotProShielded,
1366            TriggerBotProShielded,
1367        ]
1368        if level > 5:
1369            bot_types += [
1370                ExplodeyBot,
1371                TriggerBotProShielded,
1372                BrawlerBotProShielded,
1373                ChargerBotProShielded,
1374            ]
1375        if level > 7:
1376            bot_types += [
1377                ExplodeyBot,
1378                TriggerBotProShielded,
1379                BrawlerBotProShielded,
1380                ChargerBotProShielded,
1381            ]
1382        if level > 10:
1383            bot_types += [
1384                TriggerBotProShielded,
1385                TriggerBotProShielded,
1386                TriggerBotProShielded,
1387                TriggerBotProShielded,
1388            ]
1389        if level > 13:
1390            bot_types += [
1391                TriggerBotProShielded,
1392                TriggerBotProShielded,
1393                TriggerBotProShielded,
1394                TriggerBotProShielded,
1395            ]
1396        bot_levels = [
1397            [b for b in bot_types if b.points_mult == 1],
1398            [b for b in bot_types if b.points_mult == 2],
1399            [b for b in bot_types if b.points_mult == 3],
1400            [b for b in bot_types if b.points_mult == 4],
1401        ]
1402
1403        # Make sure all lists have something in them
1404        if not all(bot_levels):
1405            raise RuntimeError('Got empty bot level')
1406        return bot_levels
1407
1408    def _add_entries_for_distribution_group(
1409        self,
1410        group: list[tuple[int, int]],
1411        bot_levels: list[list[type[SpazBot]]],
1412        all_entries: list[Spawn | Spacing | Delay | None],
1413    ) -> None:
1414        entries: list[Spawn | Spacing | Delay | None] = []
1415        for entry in group:
1416            bot_level = bot_levels[entry[0] - 1]
1417            bot_type = bot_level[random.randrange(len(bot_level))]
1418            rval = random.random()
1419            if rval < 0.5:
1420                spacing = 10.0
1421            elif rval < 0.9:
1422                spacing = 20.0
1423            else:
1424                spacing = 40.0
1425            split = random.random() > 0.3
1426            for i in range(entry[1]):
1427                if split and i % 2 == 0:
1428                    entries.insert(0, Spawn(bot_type, spacing=spacing))
1429                else:
1430                    entries.append(Spawn(bot_type, spacing=spacing))
1431        if entries:
1432            all_entries += entries
1433            all_entries.append(Spacing(40.0 if random.random() < 0.5 else 80.0))
1434
1435    def _generate_random_wave(self) -> Wave:
1436        level = self._wavenum
1437        bot_levels = self._bot_levels_for_wave()
1438
1439        target_points = level * 3 - 2
1440        min_dudes = min(1 + level // 3, 10)
1441        max_dudes = min(10, level + 1)
1442        max_level = (
1443            4 if level > 6 else (3 if level > 3 else (2 if level > 2 else 1))
1444        )
1445        group_count = 3
1446        distribution = self._get_distribution(
1447            target_points, min_dudes, max_dudes, group_count, max_level
1448        )
1449        all_entries: list[Spawn | Spacing | Delay | None] = []
1450        for group in distribution:
1451            self._add_entries_for_distribution_group(
1452                group, bot_levels, all_entries
1453            )
1454        angle_rand = random.random()
1455        if angle_rand > 0.75:
1456            base_angle = 130.0
1457        elif angle_rand > 0.5:
1458            base_angle = 210.0
1459        elif angle_rand > 0.25:
1460            base_angle = 20.0
1461        else:
1462            base_angle = -30.0
1463        base_angle += (0.5 - random.random()) * 20.0
1464        wave = Wave(base_angle=base_angle, entries=all_entries)
1465        return wave
1466
1467    def add_bot_at_point(
1468        self, point: Point, spaz_type: type[SpazBot], spawn_time: float = 1.0
1469    ) -> None:
1470        """Add a new bot at a specified named point."""
1471        if self._game_over:
1472            return
1473        assert isinstance(point.value, str)
1474        pointpos = self.map.defs.points[point.value]
1475        assert self._bots is not None
1476        self._bots.spawn_bot(spaz_type, pos=pointpos, spawn_time=spawn_time)
1477
1478    def add_bot_at_angle(
1479        self, angle: float, spaz_type: type[SpazBot], spawn_time: float = 1.0
1480    ) -> None:
1481        """Add a new bot at a specified angle (for circular maps)."""
1482        if self._game_over:
1483            return
1484        angle_radians = angle / 57.2957795
1485        xval = math.sin(angle_radians) * 1.06
1486        zval = math.cos(angle_radians) * 1.06
1487        point = (xval / 0.125, 2.3, (zval / 0.2) - 3.7)
1488        assert self._bots is not None
1489        self._bots.spawn_bot(spaz_type, pos=point, spawn_time=spawn_time)
1490
1491    def _update_time_bonus(self) -> None:
1492        self._time_bonus = int(self._time_bonus * 0.93)
1493        if self._time_bonus > 0 and self._time_bonus_text is not None:
1494            assert self._time_bonus_text.node
1495            self._time_bonus_text.node.text = bs.Lstr(
1496                value='${A}: ${B}',
1497                subs=[
1498                    ('${A}', bs.Lstr(resource='timeBonusText')),
1499                    ('${B}', str(self._time_bonus)),
1500                ],
1501            )
1502        else:
1503            self._time_bonus_text = None
1504
1505    def _start_updating_waves(self) -> None:
1506        self._wave_update_timer = bs.Timer(
1507            2.0, bs.WeakCall(self._update_waves), repeat=True
1508        )
1509
1510    def _update_scores(self) -> None:
1511        score = self._score
1512        if self._preset is Preset.ENDLESS:
1513            if score >= 500:
1514                self._award_achievement('Onslaught Master')
1515            if score >= 1000:
1516                self._award_achievement('Onslaught Wizard')
1517            if score >= 5000:
1518                self._award_achievement('Onslaught God')
1519        assert self._scoreboard is not None
1520        self._scoreboard.set_team_value(self.teams[0], score, max_score=None)
1521
1522    @override
1523    def handlemessage(self, msg: Any) -> Any:
1524        if isinstance(msg, PlayerSpazHurtMessage):
1525            msg.spaz.getplayer(Player, True).has_been_hurt = True
1526            self._a_player_has_been_hurt = True
1527
1528        elif isinstance(msg, bs.PlayerScoredMessage):
1529            self._score += msg.score
1530            self._update_scores()
1531
1532        elif isinstance(msg, bs.PlayerDiedMessage):
1533            super().handlemessage(msg)  # Augment standard behavior.
1534            player = msg.getplayer(Player)
1535            self._a_player_has_been_hurt = True
1536
1537            # Make note with the player when they can respawn:
1538            if self._wavenum < 10:
1539                player.respawn_wave = max(2, self._wavenum + 1)
1540            elif self._wavenum < 15:
1541                player.respawn_wave = max(2, self._wavenum + 2)
1542            else:
1543                player.respawn_wave = max(2, self._wavenum + 3)
1544            bs.timer(0.1, self._update_player_spawn_info)
1545            bs.timer(0.1, self._checkroundover)
1546
1547        elif isinstance(msg, SpazBotDiedMessage):
1548            pts, importance = msg.spazbot.get_death_points(msg.how)
1549            if msg.killerplayer is not None:
1550                self._handle_kill_achievements(msg)
1551                target: Sequence[float] | None
1552                if msg.spazbot.node:
1553                    target = msg.spazbot.node.position
1554                else:
1555                    target = None
1556
1557                killerplayer = msg.killerplayer
1558                self.stats.player_scored(
1559                    killerplayer,
1560                    pts,
1561                    target=target,
1562                    kill=True,
1563                    screenmessage=False,
1564                    importance=importance,
1565                )
1566                dingsound = (
1567                    self._dingsound if importance == 1 else self._dingsoundhigh
1568                )
1569                dingsound.play(volume=0.6)
1570
1571            # Normally we pull scores from the score-set, but if there's
1572            # no player lets be explicit.
1573            else:
1574                self._score += pts
1575            self._update_scores()
1576        else:
1577            super().handlemessage(msg)
1578
1579    def _handle_kill_achievements(self, msg: SpazBotDiedMessage) -> None:
1580        if self._preset in {Preset.TRAINING, Preset.TRAINING_EASY}:
1581            self._handle_training_kill_achievements(msg)
1582        elif self._preset in {Preset.ROOKIE, Preset.ROOKIE_EASY}:
1583            self._handle_rookie_kill_achievements(msg)
1584        elif self._preset in {Preset.PRO, Preset.PRO_EASY}:
1585            self._handle_pro_kill_achievements(msg)
1586        elif self._preset in {Preset.UBER, Preset.UBER_EASY}:
1587            self._handle_uber_kill_achievements(msg)
1588
1589    def _handle_uber_kill_achievements(self, msg: SpazBotDiedMessage) -> None:
1590        # Uber mine achievement:
1591        if msg.spazbot.last_attacked_type == ('explosion', 'land_mine'):
1592            self._land_mine_kills += 1
1593            if self._land_mine_kills >= 6:
1594                self._award_achievement('Gold Miner')
1595
1596        # Uber tnt achievement:
1597        if msg.spazbot.last_attacked_type == ('explosion', 'tnt'):
1598            self._tnt_kills += 1
1599            if self._tnt_kills >= 6:
1600                bs.timer(
1601                    0.5, bs.WeakCall(self._award_achievement, 'TNT Terror')
1602                )
1603
1604    def _handle_pro_kill_achievements(self, msg: SpazBotDiedMessage) -> None:
1605        # TNT achievement:
1606        if msg.spazbot.last_attacked_type == ('explosion', 'tnt'):
1607            self._tnt_kills += 1
1608            if self._tnt_kills >= 3:
1609                bs.timer(
1610                    0.5,
1611                    bs.WeakCall(
1612                        self._award_achievement, 'Boom Goes the Dynamite'
1613                    ),
1614                )
1615
1616    def _handle_rookie_kill_achievements(self, msg: SpazBotDiedMessage) -> None:
1617        # Land-mine achievement:
1618        if msg.spazbot.last_attacked_type == ('explosion', 'land_mine'):
1619            self._land_mine_kills += 1
1620            if self._land_mine_kills >= 3:
1621                self._award_achievement('Mine Games')
1622
1623    def _handle_training_kill_achievements(
1624        self, msg: SpazBotDiedMessage
1625    ) -> None:
1626        # Toss-off-map achievement:
1627        if msg.spazbot.last_attacked_type == ('picked_up', 'default'):
1628            self._throw_off_kills += 1
1629            if self._throw_off_kills >= 3:
1630                self._award_achievement('Off You Go Then')
1631
1632    def _set_can_end_wave(self) -> None:
1633        self._can_end_wave = True
1634
1635    @override
1636    def end_game(self) -> None:
1637        # Tell our bots to celebrate just to rub it in.
1638        assert self._bots is not None
1639        self._bots.final_celebrate()
1640        self._game_over = True
1641        self.do_end('defeat', delay=2.0)
1642        bs.setmusic(None)
1643
1644    @override
1645    def on_continue(self) -> None:
1646        for player in self.players:
1647            if not player.is_alive():
1648                self.spawn_player(player)
1649
1650    def _checkroundover(self) -> None:
1651        """Potentially end the round based on the state of the game."""
1652        if self.has_ended():
1653            return
1654        if not any(player.is_alive() for player in self.teams[0].players):
1655            # Allow continuing after wave 1.
1656            if self._wavenum > 1:
1657                self.continue_or_end_game()
1658            else:
1659                self.end_game()