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