# Released under the MIT License. See LICENSE for details.
#
"""Provides Onslaught Co-op game."""
# Yes this is a long one..
# pylint: disable=too-many-lines
# ba_meta require api 9
# (see https://ballistica.net/wiki/meta-tag-system)
from __future__ import annotations
import math
import random
import logging
from enum import Enum, unique
from dataclasses import dataclass
from typing import TYPE_CHECKING, override
import bascenev1 as bs
from bascenev1lib.actor.popuptext import PopupText
from bascenev1lib.actor.bomb import TNTSpawner
from bascenev1lib.actor.playerspaz import PlayerSpazHurtMessage
from bascenev1lib.actor.scoreboard import Scoreboard
from bascenev1lib.actor.controlsguide import ControlsGuide
from bascenev1lib.actor.powerupbox import PowerupBox, PowerupBoxFactory
from bascenev1lib.actor.spazbot import (
SpazBotDiedMessage,
SpazBotSet,
ChargerBot,
StickyBot,
BomberBot,
BomberBotLite,
BrawlerBot,
BrawlerBotLite,
TriggerBot,
BomberBotStaticLite,
TriggerBotStatic,
BomberBotProStatic,
TriggerBotPro,
ExplodeyBot,
BrawlerBotProShielded,
ChargerBotProShielded,
BomberBotPro,
TriggerBotProShielded,
BrawlerBotPro,
BomberBotProShielded,
)
if TYPE_CHECKING:
from typing import Any, Sequence
from bascenev1lib.actor.spazbot import SpazBot
[docs]
@dataclass
class Wave:
"""A wave of enemies."""
entries: list[Spawn | Spacing | Delay | None]
base_angle: float = 0.0
[docs]
@dataclass
class Spawn:
"""A bot spawn event in a wave."""
bottype: type[SpazBot] | str
point: Point | None = None
spacing: float = 5.0
[docs]
@dataclass
class Spacing:
"""Empty space in a wave."""
spacing: float = 5.0
[docs]
@dataclass
class Delay:
"""A delay between events in a wave."""
duration: float
[docs]
class Preset(Enum):
"""Game presets we support."""
TRAINING = 'training'
TRAINING_EASY = 'training_easy'
ROOKIE = 'rookie'
ROOKIE_EASY = 'rookie_easy'
PRO = 'pro'
PRO_EASY = 'pro_easy'
UBER = 'uber'
UBER_EASY = 'uber_easy'
ENDLESS = 'endless'
ENDLESS_TOURNAMENT = 'endless_tournament'
[docs]
@unique
class Point(Enum):
"""Points on the map we can spawn at."""
LEFT_UPPER_MORE = 'bot_spawn_left_upper_more'
LEFT_UPPER = 'bot_spawn_left_upper'
TURRET_TOP_RIGHT = 'bot_spawn_turret_top_right'
RIGHT_UPPER = 'bot_spawn_right_upper'
TURRET_TOP_MIDDLE_LEFT = 'bot_spawn_turret_top_middle_left'
TURRET_TOP_MIDDLE_RIGHT = 'bot_spawn_turret_top_middle_right'
TURRET_TOP_LEFT = 'bot_spawn_turret_top_left'
TOP_RIGHT = 'bot_spawn_top_right'
TOP_LEFT = 'bot_spawn_top_left'
TOP = 'bot_spawn_top'
BOTTOM = 'bot_spawn_bottom'
LEFT = 'bot_spawn_left'
RIGHT = 'bot_spawn_right'
RIGHT_UPPER_MORE = 'bot_spawn_right_upper_more'
RIGHT_LOWER = 'bot_spawn_right_lower'
RIGHT_LOWER_MORE = 'bot_spawn_right_lower_more'
BOTTOM_RIGHT = 'bot_spawn_bottom_right'
BOTTOM_LEFT = 'bot_spawn_bottom_left'
TURRET_BOTTOM_RIGHT = 'bot_spawn_turret_bottom_right'
TURRET_BOTTOM_LEFT = 'bot_spawn_turret_bottom_left'
LEFT_LOWER = 'bot_spawn_left_lower'
LEFT_LOWER_MORE = 'bot_spawn_left_lower_more'
TURRET_TOP_MIDDLE = 'bot_spawn_turret_top_middle'
BOTTOM_HALF_RIGHT = 'bot_spawn_bottom_half_right'
BOTTOM_HALF_LEFT = 'bot_spawn_bottom_half_left'
TOP_HALF_RIGHT = 'bot_spawn_top_half_right'
TOP_HALF_LEFT = 'bot_spawn_top_half_left'
[docs]
class Player(bs.Player['Team']):
"""Our player type for this game."""
def __init__(self) -> None:
self.has_been_hurt = False
self.respawn_wave = 0
[docs]
class Team(bs.Team[Player]):
"""Our team type for this game."""
[docs]
class OnslaughtGame(bs.CoopGameActivity[Player, Team]):
"""Co-op game where players try to survive attacking waves of enemies."""
name = 'Onslaught'
description = 'Defeat all enemies.'
tips: list[str | bs.GameTip] = [
'Hold any button to run.'
' (Trigger buttons work well if you have them)',
'Try tricking enemies into killing eachother or running off cliffs.',
'Try \'Cooking off\' bombs for a second or two before throwing them.',
'It\'s easier to win with a friend or two helping.',
'If you stay in one place, you\'re toast. Run and dodge to survive..',
'Practice using your momentum to throw bombs more accurately.',
'Your punches do much more damage if you are running or spinning.',
]
# Show messages when players die since it matters here.
announce_player_deaths = True
def __init__(self, settings: dict):
self._preset = Preset(settings.get('preset', 'training'))
if self._preset in {
Preset.TRAINING,
Preset.TRAINING_EASY,
Preset.PRO,
Preset.PRO_EASY,
Preset.ENDLESS,
Preset.ENDLESS_TOURNAMENT,
}:
settings['map'] = 'Doom Shroom'
else:
settings['map'] = 'Courtyard'
super().__init__(settings)
self._new_wave_sound = bs.getsound('scoreHit01')
self._winsound = bs.getsound('score')
self._cashregistersound = bs.getsound('cashRegister')
self._a_player_has_been_hurt = False
self._player_has_dropped_bomb = False
# FIXME: should use standard map defs.
if settings['map'] == 'Doom Shroom':
self._spawn_center = (0, 3, -5)
self._tntspawnpos = (0.0, 3.0, -5.0)
self._powerup_center = (0, 5, -3.6)
self._powerup_spread = (6.0, 4.0)
elif settings['map'] == 'Courtyard':
self._spawn_center = (0, 3, -2)
self._tntspawnpos = (0.0, 3.0, 2.1)
self._powerup_center = (0, 5, -1.6)
self._powerup_spread = (4.6, 2.7)
else:
raise RuntimeError('Unsupported map: ' + str(settings['map']))
self._scoreboard: Scoreboard | None = None
self._game_over = False
self._wavenum = 0
self._can_end_wave = True
self._score = 0
self._time_bonus = 0
self._spawn_info_text: bs.NodeActor | None = None
self._dingsound = bs.getsound('dingSmall')
self._dingsoundhigh = bs.getsound('dingSmallHigh')
self._have_tnt = False
self._excluded_powerups: list[str] | None = None
self._waves: list[Wave] = []
self._tntspawner: TNTSpawner | None = None
self._bots: SpazBotSet | None = None
self._powerup_drop_timer: bs.Timer | None = None
self._time_bonus_timer: bs.Timer | None = None
self._time_bonus_text: bs.NodeActor | None = None
self._flawless_bonus: int | None = None
self._wave_text: bs.NodeActor | None = None
self._wave_update_timer: bs.Timer | None = None
self._throw_off_kills = 0
self._land_mine_kills = 0
self._tnt_kills = 0
[docs]
@override
def on_transition_in(self) -> None:
super().on_transition_in()
customdata = bs.getsession().customdata
# Show special landmine tip on rookie preset.
if self._preset in {Preset.ROOKIE, Preset.ROOKIE_EASY}:
# Show once per session only (then we revert to regular tips).
if not customdata.get('_showed_onslaught_landmine_tip', False):
customdata['_showed_onslaught_landmine_tip'] = True
self.tips = [
bs.GameTip(
'Land-mines are a good way to stop speedy enemies.',
icon=bs.gettexture('powerupLandMines'),
sound=bs.getsound('ding'),
)
]
# Show special tnt tip on pro preset.
if self._preset in {Preset.PRO, Preset.PRO_EASY}:
# Show once per session only (then we revert to regular tips).
if not customdata.get('_showed_onslaught_tnt_tip', False):
customdata['_showed_onslaught_tnt_tip'] = True
self.tips = [
bs.GameTip(
'Take out a group of enemies by\n'
'setting off a bomb near a TNT box.',
icon=bs.gettexture('tnt'),
sound=bs.getsound('ding'),
)
]
# Show special curse tip on uber preset.
if self._preset in {Preset.UBER, Preset.UBER_EASY}:
# Show once per session only (then we revert to regular tips).
if not customdata.get('_showed_onslaught_curse_tip', False):
customdata['_showed_onslaught_curse_tip'] = True
self.tips = [
bs.GameTip(
'Curse boxes turn you into a ticking time bomb.\n'
'The only cure is to quickly grab a health-pack.',
icon=bs.gettexture('powerupCurse'),
sound=bs.getsound('ding'),
)
]
self._spawn_info_text = bs.NodeActor(
bs.newnode(
'text',
attrs={
'position': (15, -130),
'h_attach': 'left',
'v_attach': 'top',
'scale': 0.55,
'color': (0.3, 0.8, 0.3, 1.0),
'text': '',
},
)
)
bs.setmusic(bs.MusicType.ONSLAUGHT)
self._scoreboard = Scoreboard(
label=bs.Lstr(resource='scoreText'), score_split=0.5
)
[docs]
@override
def on_begin(self) -> None:
super().on_begin()
player_count = len(self.players)
hard = self._preset not in {
Preset.TRAINING_EASY,
Preset.ROOKIE_EASY,
Preset.PRO_EASY,
Preset.UBER_EASY,
}
if self._preset in {Preset.TRAINING, Preset.TRAINING_EASY}:
ControlsGuide(delay=3.0, lifespan=10.0, bright=True).autoretain()
self._have_tnt = False
self._excluded_powerups = ['curse', 'land_mines']
self._waves = [
Wave(
base_angle=195,
entries=[
Spawn(BomberBotLite, spacing=5),
]
* player_count,
),
Wave(
base_angle=130,
entries=[
Spawn(BrawlerBotLite, spacing=5),
]
* player_count,
),
Wave(
base_angle=195,
entries=[Spawn(BomberBotLite, spacing=10)]
* (player_count + 1),
),
Wave(
base_angle=130,
entries=[
Spawn(BrawlerBotLite, spacing=10),
]
* (player_count + 1),
),
Wave(
base_angle=130,
entries=[
(
Spawn(BrawlerBotLite, spacing=5)
if player_count > 1
else None
),
Spawn(BrawlerBotLite, spacing=5),
Spacing(30),
(
Spawn(BomberBotLite, spacing=5)
if player_count > 3
else None
),
Spawn(BomberBotLite, spacing=5),
Spacing(30),
Spawn(BrawlerBotLite, spacing=5),
(
Spawn(BrawlerBotLite, spacing=5)
if player_count > 2
else None
),
],
),
Wave(
base_angle=195,
entries=[
Spawn(TriggerBot, spacing=90),
(
Spawn(TriggerBot, spacing=90)
if player_count > 1
else None
),
],
),
]
elif self._preset in {Preset.ROOKIE, Preset.ROOKIE_EASY}:
self._have_tnt = False
self._excluded_powerups = ['curse']
self._waves = [
Wave(
entries=[
(
Spawn(ChargerBot, Point.LEFT_UPPER_MORE)
if player_count > 2
else None
),
Spawn(ChargerBot, Point.LEFT_UPPER),
]
),
Wave(
entries=[
Spawn(BomberBotStaticLite, Point.TURRET_TOP_RIGHT),
Spawn(BrawlerBotLite, Point.RIGHT_UPPER),
(
Spawn(BrawlerBotLite, Point.RIGHT_LOWER)
if player_count > 1
else None
),
(
Spawn(
BomberBotStaticLite, Point.TURRET_BOTTOM_RIGHT
)
if player_count > 2
else None
),
]
),
Wave(
entries=[
Spawn(BomberBotStaticLite, Point.TURRET_BOTTOM_LEFT),
Spawn(TriggerBot, Point.LEFT),
(
Spawn(TriggerBot, Point.LEFT_LOWER)
if player_count > 1
else None
),
(
Spawn(TriggerBot, Point.LEFT_UPPER)
if player_count > 2
else None
),
]
),
Wave(
entries=[
Spawn(BrawlerBotLite, Point.TOP_RIGHT),
(
Spawn(BrawlerBot, Point.TOP_HALF_RIGHT)
if player_count > 1
else None
),
Spawn(BrawlerBotLite, Point.TOP_LEFT),
(
Spawn(BrawlerBotLite, Point.TOP_HALF_LEFT)
if player_count > 2
else None
),
Spawn(BrawlerBot, Point.TOP),
Spawn(BomberBotStaticLite, Point.TURRET_TOP_MIDDLE),
]
),
Wave(
entries=[
Spawn(TriggerBotStatic, Point.TURRET_BOTTOM_LEFT),
Spawn(TriggerBotStatic, Point.TURRET_BOTTOM_RIGHT),
Spawn(TriggerBot, Point.BOTTOM),
(
Spawn(TriggerBot, Point.BOTTOM_HALF_RIGHT)
if player_count > 1
else None
),
(
Spawn(TriggerBot, Point.BOTTOM_HALF_LEFT)
if player_count > 2
else None
),
]
),
Wave(
entries=[
Spawn(BomberBotStaticLite, Point.TURRET_TOP_LEFT),
Spawn(BomberBotStaticLite, Point.TURRET_TOP_RIGHT),
Spawn(ChargerBot, Point.BOTTOM),
(
Spawn(ChargerBot, Point.BOTTOM_HALF_LEFT)
if player_count > 1
else None
),
(
Spawn(ChargerBot, Point.BOTTOM_HALF_RIGHT)
if player_count > 2
else None
),
]
),
]
elif self._preset in {Preset.PRO, Preset.PRO_EASY}:
self._excluded_powerups = ['curse']
self._have_tnt = True
self._waves = [
Wave(
base_angle=-50,
entries=[
(
Spawn(BrawlerBot, spacing=12)
if player_count > 3
else None
),
Spawn(BrawlerBot, spacing=12),
Spawn(BomberBot, spacing=6),
(
Spawn(BomberBot, spacing=6)
if self._preset is Preset.PRO
else None
),
(
Spawn(BomberBot, spacing=6)
if player_count > 1
else None
),
Spawn(BrawlerBot, spacing=12),
(
Spawn(BrawlerBot, spacing=12)
if player_count > 2
else None
),
],
),
Wave(
base_angle=180,
entries=[
(
Spawn(BrawlerBot, spacing=6)
if player_count > 3
else None
),
(
Spawn(BrawlerBot, spacing=6)
if self._preset is Preset.PRO
else None
),
Spawn(BrawlerBot, spacing=6),
Spawn(ChargerBot, spacing=45),
(
Spawn(ChargerBot, spacing=45)
if player_count > 1
else None
),
Spawn(BrawlerBot, spacing=6),
(
Spawn(BrawlerBot, spacing=6)
if self._preset is Preset.PRO
else None
),
(
Spawn(BrawlerBot, spacing=6)
if player_count > 2
else None
),
],
),
Wave(
base_angle=0,
entries=[
Spawn(ChargerBot, spacing=30),
Spawn(TriggerBot, spacing=30),
Spawn(TriggerBot, spacing=30),
(
Spawn(TriggerBot, spacing=30)
if self._preset is Preset.PRO
else None
),
(
Spawn(TriggerBot, spacing=30)
if player_count > 1
else None
),
(
Spawn(TriggerBot, spacing=30)
if player_count > 3
else None
),
Spawn(ChargerBot, spacing=30),
],
),
Wave(
base_angle=90,
entries=[
Spawn(StickyBot, spacing=50),
(
Spawn(StickyBot, spacing=50)
if self._preset is Preset.PRO
else None
),
Spawn(StickyBot, spacing=50),
(
Spawn(StickyBot, spacing=50)
if player_count > 1
else None
),
(
Spawn(StickyBot, spacing=50)
if player_count > 3
else None
),
],
),
Wave(
base_angle=0,
entries=[
Spawn(TriggerBot, spacing=72),
Spawn(TriggerBot, spacing=72),
(
Spawn(TriggerBot, spacing=72)
if self._preset is Preset.PRO
else None
),
Spawn(TriggerBot, spacing=72),
Spawn(TriggerBot, spacing=72),
(
Spawn(TriggerBot, spacing=36)
if player_count > 2
else None
),
],
),
Wave(
base_angle=30,
entries=[
Spawn(ChargerBotProShielded, spacing=50),
Spawn(ChargerBotProShielded, spacing=50),
(
Spawn(ChargerBotProShielded, spacing=50)
if self._preset is Preset.PRO
else None
),
(
Spawn(ChargerBotProShielded, spacing=50)
if player_count > 1
else None
),
(
Spawn(ChargerBotProShielded, spacing=50)
if player_count > 2
else None
),
],
),
]
elif self._preset in {Preset.UBER, Preset.UBER_EASY}:
# Show controls help in demo or arcade modes.
env = bs.app.env
if env.demo or env.arcade:
ControlsGuide(
delay=3.0, lifespan=10.0, bright=True
).autoretain()
self._have_tnt = True
self._excluded_powerups = []
self._waves = [
Wave(
entries=[
(
Spawn(
BomberBotProStatic, Point.TURRET_TOP_MIDDLE_LEFT
)
if hard
else None
),
Spawn(
BomberBotProStatic, Point.TURRET_TOP_MIDDLE_RIGHT
),
(
Spawn(BomberBotProStatic, Point.TURRET_TOP_LEFT)
if player_count > 2
else None
),
Spawn(ExplodeyBot, Point.TOP_RIGHT),
Delay(4.0),
Spawn(ExplodeyBot, Point.TOP_LEFT),
]
),
Wave(
entries=[
Spawn(ChargerBot, Point.LEFT),
Spawn(ChargerBot, Point.RIGHT),
(
Spawn(ChargerBot, Point.RIGHT_UPPER_MORE)
if player_count > 2
else None
),
Spawn(BomberBotProStatic, Point.TURRET_TOP_LEFT),
Spawn(BomberBotProStatic, Point.TURRET_TOP_RIGHT),
]
),
Wave(
entries=[
Spawn(TriggerBotPro, Point.TOP_RIGHT),
(
Spawn(TriggerBotPro, Point.RIGHT_UPPER_MORE)
if player_count > 1
else None
),
Spawn(TriggerBotPro, Point.RIGHT_UPPER),
(
Spawn(TriggerBotPro, Point.RIGHT_LOWER)
if hard
else None
),
(
Spawn(TriggerBotPro, Point.RIGHT_LOWER_MORE)
if player_count > 2
else None
),
Spawn(TriggerBotPro, Point.BOTTOM_RIGHT),
]
),
Wave(
entries=[
Spawn(ChargerBotProShielded, Point.BOTTOM_RIGHT),
(
Spawn(ChargerBotProShielded, Point.BOTTOM)
if player_count > 2
else None
),
Spawn(ChargerBotProShielded, Point.BOTTOM_LEFT),
(
Spawn(ChargerBotProShielded, Point.TOP)
if hard
else None
),
Spawn(BomberBotProStatic, Point.TURRET_TOP_MIDDLE),
]
),
Wave(
entries=[
Spawn(ExplodeyBot, Point.LEFT_UPPER),
Delay(1.0),
Spawn(BrawlerBotProShielded, Point.LEFT_LOWER),
Spawn(BrawlerBotProShielded, Point.LEFT_LOWER_MORE),
Delay(4.0),
Spawn(ExplodeyBot, Point.RIGHT_UPPER),
Delay(1.0),
Spawn(BrawlerBotProShielded, Point.RIGHT_LOWER),
Spawn(BrawlerBotProShielded, Point.RIGHT_UPPER_MORE),
Delay(4.0),
Spawn(ExplodeyBot, Point.LEFT),
Delay(5.0),
Spawn(ExplodeyBot, Point.RIGHT),
]
),
Wave(
entries=[
Spawn(BomberBotProStatic, Point.TURRET_TOP_LEFT),
Spawn(BomberBotProStatic, Point.TURRET_TOP_RIGHT),
Spawn(BomberBotProStatic, Point.TURRET_BOTTOM_LEFT),
Spawn(BomberBotProStatic, Point.TURRET_BOTTOM_RIGHT),
(
Spawn(
BomberBotProStatic, Point.TURRET_TOP_MIDDLE_LEFT
)
if hard
else None
),
(
Spawn(
BomberBotProStatic,
Point.TURRET_TOP_MIDDLE_RIGHT,
)
if hard
else None
),
]
),
]
# We generate these on the fly in endless.
elif self._preset in {Preset.ENDLESS, Preset.ENDLESS_TOURNAMENT}:
self._have_tnt = True
self._excluded_powerups = []
self._waves = []
else:
raise RuntimeError(f'Invalid preset: {self._preset}')
# FIXME: Should migrate to use setup_standard_powerup_drops().
# Spit out a few powerups and start dropping more shortly.
self._drop_powerups(
standard_points=True,
poweruptype=(
'curse'
if self._preset in [Preset.UBER, Preset.UBER_EASY]
else (
'land_mines'
if self._preset in [Preset.ROOKIE, Preset.ROOKIE_EASY]
else None
)
),
)
bs.timer(4.0, self._start_powerup_drops)
# Our TNT spawner (if applicable).
if self._have_tnt:
self._tntspawner = TNTSpawner(position=self._tntspawnpos)
self.setup_low_life_warning_sound()
self._update_scores()
self._bots = SpazBotSet()
bs.timer(4.0, self._start_updating_waves)
def _get_dist_grp_totals(self, grps: list[Any]) -> tuple[int, int]:
totalpts = 0
totaldudes = 0
for grp in grps:
for grpentry in grp:
dudes = grpentry[1]
totalpts += grpentry[0] * dudes
totaldudes += dudes
return totalpts, totaldudes
def _get_distribution(
self,
target_points: int,
min_dudes: int,
max_dudes: int,
group_count: int,
max_level: int,
) -> list[list[tuple[int, int]]]:
"""Calculate a distribution of bad guys given some params."""
# pylint: disable=too-many-positional-arguments
max_iterations = 10 + max_dudes * 2
groups: list[list[tuple[int, int]]] = []
for _g in range(group_count):
groups.append([])
types = [1]
if max_level > 1:
types.append(2)
if max_level > 2:
types.append(3)
if max_level > 3:
types.append(4)
for iteration in range(max_iterations):
diff = self._add_dist_entry_if_possible(
groups, max_dudes, target_points, types
)
total_points, total_dudes = self._get_dist_grp_totals(groups)
full = total_points >= target_points
if full:
# Every so often, delete a random entry just to
# shake up our distribution.
if random.random() < 0.2 and iteration != max_iterations - 1:
self._delete_random_dist_entry(groups)
# If we don't have enough dudes, kill the group with
# the biggest point value.
elif (
total_dudes < min_dudes and iteration != max_iterations - 1
):
self._delete_biggest_dist_entry(groups)
# If we've got too many dudes, kill the group with the
# smallest point value.
elif (
total_dudes > max_dudes and iteration != max_iterations - 1
):
self._delete_smallest_dist_entry(groups)
# Close enough.. we're done.
else:
if diff == 0:
break
return groups
def _add_dist_entry_if_possible(
self,
groups: list[list[tuple[int, int]]],
max_dudes: int,
target_points: int,
types: list[int],
) -> int:
# See how much we're off our target by.
total_points, total_dudes = self._get_dist_grp_totals(groups)
diff = target_points - total_points
dudes_diff = max_dudes - total_dudes
# Add an entry if one will fit.
value = types[random.randrange(len(types))]
group = groups[random.randrange(len(groups))]
if not group:
max_count = random.randint(1, 6)
else:
max_count = 2 * random.randint(1, 3)
max_count = min(max_count, dudes_diff)
count = min(max_count, diff // value)
if count > 0:
group.append((value, count))
total_points += value * count
total_dudes += count
diff = target_points - total_points
return diff
def _delete_smallest_dist_entry(
self, groups: list[list[tuple[int, int]]]
) -> None:
smallest_value = 9999
smallest_entry = None
smallest_entry_group = None
for group in groups:
for entry in group:
if entry[0] < smallest_value or smallest_entry is None:
smallest_value = entry[0]
smallest_entry = entry
smallest_entry_group = group
assert smallest_entry is not None
assert smallest_entry_group is not None
smallest_entry_group.remove(smallest_entry)
def _delete_biggest_dist_entry(
self, groups: list[list[tuple[int, int]]]
) -> None:
biggest_value = 9999
biggest_entry = None
biggest_entry_group = None
for group in groups:
for entry in group:
if entry[0] > biggest_value or biggest_entry is None:
biggest_value = entry[0]
biggest_entry = entry
biggest_entry_group = group
if biggest_entry is not None:
assert biggest_entry_group is not None
biggest_entry_group.remove(biggest_entry)
def _delete_random_dist_entry(
self, groups: list[list[tuple[int, int]]]
) -> None:
entry_count = 0
for group in groups:
for _ in group:
entry_count += 1
if entry_count > 1:
del_entry = random.randrange(entry_count)
entry_count = 0
for group in groups:
for entry in group:
if entry_count == del_entry:
group.remove(entry)
break
entry_count += 1
[docs]
@override
def spawn_player(self, player: Player) -> bs.Actor:
# We keep track of who got hurt each wave for score purposes.
player.has_been_hurt = False
pos = (
self._spawn_center[0] + random.uniform(-1.5, 1.5),
self._spawn_center[1],
self._spawn_center[2] + random.uniform(-1.5, 1.5),
)
spaz = self.spawn_player_spaz(player, position=pos)
if self._preset in {
Preset.TRAINING_EASY,
Preset.ROOKIE_EASY,
Preset.PRO_EASY,
Preset.UBER_EASY,
}:
spaz.impact_scale = 0.25
spaz.add_dropped_bomb_callback(self._handle_player_dropped_bomb)
return spaz
def _handle_player_dropped_bomb(
self, player: bs.Actor, bomb: bs.Actor
) -> None:
del player, bomb # Unused.
self._player_has_dropped_bomb = True
def _drop_powerup(self, index: int, poweruptype: str | None = None) -> None:
poweruptype = PowerupBoxFactory.get().get_random_powerup_type(
forcetype=poweruptype, excludetypes=self._excluded_powerups
)
PowerupBox(
position=self.map.powerup_spawn_points[index],
poweruptype=poweruptype,
).autoretain()
def _start_powerup_drops(self) -> None:
self._powerup_drop_timer = bs.Timer(
3.0, bs.WeakCall(self._drop_powerups), repeat=True
)
def _drop_powerups(
self, standard_points: bool = False, poweruptype: str | None = None
) -> None:
"""Generic powerup drop."""
if standard_points:
points = self.map.powerup_spawn_points
for i in range(len(points)):
bs.timer(
1.0 + i * 0.5,
bs.WeakCall(
self._drop_powerup, i, poweruptype if i == 0 else None
),
)
else:
point = (
self._powerup_center[0]
+ random.uniform(
-1.0 * self._powerup_spread[0],
1.0 * self._powerup_spread[0],
),
self._powerup_center[1],
self._powerup_center[2]
+ random.uniform(
-self._powerup_spread[1], self._powerup_spread[1]
),
)
# Drop one random one somewhere.
PowerupBox(
position=point,
poweruptype=PowerupBoxFactory.get().get_random_powerup_type(
excludetypes=self._excluded_powerups
),
).autoretain()
[docs]
def do_end(self, outcome: str, delay: float = 0.0) -> None:
"""End the game with the specified outcome."""
if outcome == 'defeat':
self.fade_to_red()
score: int | None
if self._wavenum >= 2:
score = self._score
fail_message = None
else:
score = None
fail_message = bs.Lstr(resource='reachWave2Text')
self.end(
{
'outcome': outcome,
'score': score,
'fail_message': fail_message,
'playerinfos': self.initialplayerinfos,
},
delay=delay,
)
def _award_completion_achievements(self) -> None:
if self._preset in {Preset.TRAINING, Preset.TRAINING_EASY}:
self._award_achievement('Onslaught Training Victory', sound=False)
if not self._player_has_dropped_bomb:
self._award_achievement('Boxer', sound=False)
elif self._preset in {Preset.ROOKIE, Preset.ROOKIE_EASY}:
self._award_achievement('Rookie Onslaught Victory', sound=False)
if not self._a_player_has_been_hurt:
self._award_achievement('Flawless Victory', sound=False)
elif self._preset in {Preset.PRO, Preset.PRO_EASY}:
self._award_achievement('Pro Onslaught Victory', sound=False)
if not self._player_has_dropped_bomb:
self._award_achievement('Pro Boxer', sound=False)
elif self._preset in {Preset.UBER, Preset.UBER_EASY}:
self._award_achievement('Uber Onslaught Victory', sound=False)
def _update_waves(self) -> None:
# If we have no living bots, go to the next wave.
assert self._bots is not None
if (
self._can_end_wave
and not self._bots.have_living_bots()
and not self._game_over
):
self._can_end_wave = False
self._time_bonus_timer = None
self._time_bonus_text = None
if self._preset in {Preset.ENDLESS, Preset.ENDLESS_TOURNAMENT}:
won = False
else:
won = self._wavenum == len(self._waves)
base_delay = 4.0 if won else 0.0
# Reward time bonus.
if self._time_bonus > 0:
bs.timer(0, self._cashregistersound.play)
bs.timer(
base_delay,
bs.WeakCall(self._award_time_bonus, self._time_bonus),
)
base_delay += 1.0
# Reward flawless bonus.
if self._wavenum > 0:
have_flawless = False
for player in self.players:
if player.is_alive() and not player.has_been_hurt:
have_flawless = True
bs.timer(
base_delay,
bs.WeakCall(self._award_flawless_bonus, player),
)
player.has_been_hurt = False # reset
if have_flawless:
base_delay += 1.0
if won:
self.show_zoom_message(
bs.Lstr(resource='victoryText'), scale=1.0, duration=4.0
)
self.celebrate(20.0)
self._award_completion_achievements()
bs.timer(base_delay, bs.WeakCall(self._award_completion_bonus))
base_delay += 0.85
self._winsound.play()
bs.cameraflash()
bs.setmusic(bs.MusicType.VICTORY)
self._game_over = True
# Can't just pass delay to do_end because our extra bonuses
# haven't been added yet (once we call do_end the score
# gets locked in).
bs.timer(base_delay, bs.WeakCall(self.do_end, 'victory'))
return
self._wavenum += 1
# Short celebration after waves.
if self._wavenum > 1:
self.celebrate(0.5)
bs.timer(base_delay, bs.WeakCall(self._start_next_wave))
def _award_completion_bonus(self) -> None:
self._cashregistersound.play()
for player in self.players:
try:
if player.is_alive():
assert self.initialplayerinfos is not None
self.stats.player_scored(
player,
int(100 / len(self.initialplayerinfos)),
scale=1.4,
color=(0.6, 0.6, 1.0, 1.0),
title=bs.Lstr(resource='completionBonusText'),
screenmessage=False,
)
except Exception:
logging.exception('error in _award_completion_bonus')
def _award_time_bonus(self, bonus: int) -> None:
self._cashregistersound.play()
PopupText(
bs.Lstr(
value='+${A} ${B}',
subs=[
('${A}', str(bonus)),
('${B}', bs.Lstr(resource='timeBonusText')),
],
),
color=(1, 1, 0.5, 1),
scale=1.0,
position=(0, 3, -1),
).autoretain()
self._score += self._time_bonus
self._update_scores()
def _award_flawless_bonus(self, player: Player) -> None:
self._cashregistersound.play()
try:
if player.is_alive():
assert self._flawless_bonus is not None
self.stats.player_scored(
player,
self._flawless_bonus,
scale=1.2,
color=(0.6, 1.0, 0.6, 1.0),
title=bs.Lstr(resource='flawlessWaveText'),
screenmessage=False,
)
except Exception:
logging.exception('error in _award_flawless_bonus')
def _start_time_bonus_timer(self) -> None:
self._time_bonus_timer = bs.Timer(
1.0, bs.WeakCall(self._update_time_bonus), repeat=True
)
def _update_player_spawn_info(self) -> None:
# If we have no living players lets just blank this.
assert self._spawn_info_text is not None
assert self._spawn_info_text.node
if not any(player.is_alive() for player in self.teams[0].players):
self._spawn_info_text.node.text = ''
else:
text: str | bs.Lstr = ''
for player in self.players:
if not player.is_alive() and (
self._preset in [Preset.ENDLESS, Preset.ENDLESS_TOURNAMENT]
or (player.respawn_wave <= len(self._waves))
):
rtxt = bs.Lstr(
resource='onslaughtRespawnText',
subs=[
('${PLAYER}', player.getname()),
('${WAVE}', str(player.respawn_wave)),
],
)
text = bs.Lstr(
value='${A}${B}\n',
subs=[
('${A}', text),
('${B}', rtxt),
],
)
self._spawn_info_text.node.text = text
def _respawn_players_for_wave(self) -> None:
# Respawn applicable players.
if self._wavenum > 1:
for player in self.players:
if (
not player.is_alive()
and player.respawn_wave == self._wavenum
):
self.spawn_player(player)
self._update_player_spawn_info()
def _setup_wave_spawns(self, wave: Wave) -> None:
tval = 0.0
dtime = 0.2
if self._wavenum == 1:
spawn_time = 3.973
tval += 0.5
else:
spawn_time = 2.648
bot_angle = wave.base_angle
self._time_bonus = 0
self._flawless_bonus = 0
for info in wave.entries:
if info is None:
continue
if isinstance(info, Delay):
spawn_time += info.duration
continue
if isinstance(info, Spacing):
bot_angle += info.spacing
continue
bot_type_2 = info.bottype
if bot_type_2 is not None:
assert not isinstance(bot_type_2, str)
self._time_bonus += bot_type_2.points_mult * 20
self._flawless_bonus += bot_type_2.points_mult * 5
# If its got a position, use that.
point = info.point
if point is not None:
assert bot_type_2 is not None
spcall = bs.WeakCall(
self.add_bot_at_point, point, bot_type_2, spawn_time
)
bs.timer(tval, spcall)
tval += dtime
else:
spacing = info.spacing
bot_angle += spacing * 0.5
if bot_type_2 is not None:
tcall = bs.WeakCall(
self.add_bot_at_angle, bot_angle, bot_type_2, spawn_time
)
bs.timer(tval, tcall)
tval += dtime
bot_angle += spacing * 0.5
# We can end the wave after all the spawning happens.
bs.timer(
tval + spawn_time - dtime + 0.01,
bs.WeakCall(self._set_can_end_wave),
)
def _start_next_wave(self) -> None:
# This can happen if we beat a wave as we die.
# We don't wanna respawn players and whatnot if this happens.
if self._game_over:
return
self._respawn_players_for_wave()
if self._preset in {Preset.ENDLESS, Preset.ENDLESS_TOURNAMENT}:
wave = self._generate_random_wave()
else:
wave = self._waves[self._wavenum - 1]
self._setup_wave_spawns(wave)
self._update_wave_ui_and_bonuses()
bs.timer(0.4, self._new_wave_sound.play)
def _update_wave_ui_and_bonuses(self) -> None:
self.show_zoom_message(
bs.Lstr(
value='${A} ${B}',
subs=[
('${A}', bs.Lstr(resource='waveText')),
('${B}', str(self._wavenum)),
],
),
scale=1.0,
duration=1.0,
trail=True,
)
# Reset our time bonus.
tbtcolor = (1, 1, 0, 1)
tbttxt = bs.Lstr(
value='${A}: ${B}',
subs=[
('${A}', bs.Lstr(resource='timeBonusText')),
('${B}', str(self._time_bonus)),
],
)
self._time_bonus_text = bs.NodeActor(
bs.newnode(
'text',
attrs={
'v_attach': 'top',
'h_attach': 'center',
'h_align': 'center',
'vr_depth': -30,
'color': tbtcolor,
'shadow': 1.0,
'flatness': 1.0,
'position': (0, -60),
'scale': 0.8,
'text': tbttxt,
},
)
)
bs.timer(5.0, bs.WeakCall(self._start_time_bonus_timer))
wtcolor = (1, 1, 1, 1)
wttxt = bs.Lstr(
value='${A} ${B}',
subs=[
('${A}', bs.Lstr(resource='waveText')),
(
'${B}',
str(self._wavenum)
+ (
''
if self._preset
in [Preset.ENDLESS, Preset.ENDLESS_TOURNAMENT]
else ('/' + str(len(self._waves)))
),
),
],
)
self._wave_text = bs.NodeActor(
bs.newnode(
'text',
attrs={
'v_attach': 'top',
'h_attach': 'center',
'h_align': 'center',
'vr_depth': -10,
'color': wtcolor,
'shadow': 1.0,
'flatness': 1.0,
'position': (0, -40),
'scale': 1.3,
'text': wttxt,
},
)
)
def _bot_levels_for_wave(self) -> list[list[type[SpazBot]]]:
level = self._wavenum
bot_types = [
BomberBot,
BrawlerBot,
TriggerBot,
ChargerBot,
BomberBotPro,
BrawlerBotPro,
TriggerBotPro,
BomberBotProShielded,
ExplodeyBot,
ChargerBotProShielded,
StickyBot,
BrawlerBotProShielded,
TriggerBotProShielded,
]
if level > 5:
bot_types += [
ExplodeyBot,
TriggerBotProShielded,
BrawlerBotProShielded,
ChargerBotProShielded,
]
if level > 7:
bot_types += [
ExplodeyBot,
TriggerBotProShielded,
BrawlerBotProShielded,
ChargerBotProShielded,
]
if level > 10:
bot_types += [
TriggerBotProShielded,
TriggerBotProShielded,
TriggerBotProShielded,
TriggerBotProShielded,
]
if level > 13:
bot_types += [
TriggerBotProShielded,
TriggerBotProShielded,
TriggerBotProShielded,
TriggerBotProShielded,
]
bot_levels = [
[b for b in bot_types if b.points_mult == 1],
[b for b in bot_types if b.points_mult == 2],
[b for b in bot_types if b.points_mult == 3],
[b for b in bot_types if b.points_mult == 4],
]
# Make sure all lists have something in them
if not all(bot_levels):
raise RuntimeError('Got empty bot level')
return bot_levels
def _add_entries_for_distribution_group(
self,
group: list[tuple[int, int]],
bot_levels: list[list[type[SpazBot]]],
all_entries: list[Spawn | Spacing | Delay | None],
) -> None:
entries: list[Spawn | Spacing | Delay | None] = []
for entry in group:
bot_level = bot_levels[entry[0] - 1]
bot_type = bot_level[random.randrange(len(bot_level))]
rval = random.random()
if rval < 0.5:
spacing = 10.0
elif rval < 0.9:
spacing = 20.0
else:
spacing = 40.0
split = random.random() > 0.3
for i in range(entry[1]):
if split and i % 2 == 0:
entries.insert(0, Spawn(bot_type, spacing=spacing))
else:
entries.append(Spawn(bot_type, spacing=spacing))
if entries:
all_entries += entries
all_entries.append(Spacing(40.0 if random.random() < 0.5 else 80.0))
def _generate_random_wave(self) -> Wave:
level = self._wavenum
bot_levels = self._bot_levels_for_wave()
target_points = level * 3 - 2
min_dudes = min(1 + level // 3, 10)
max_dudes = min(10, level + 1)
max_level = (
4 if level > 6 else (3 if level > 3 else (2 if level > 2 else 1))
)
group_count = 3
distribution = self._get_distribution(
target_points, min_dudes, max_dudes, group_count, max_level
)
all_entries: list[Spawn | Spacing | Delay | None] = []
for group in distribution:
self._add_entries_for_distribution_group(
group, bot_levels, all_entries
)
angle_rand = random.random()
if angle_rand > 0.75:
base_angle = 130.0
elif angle_rand > 0.5:
base_angle = 210.0
elif angle_rand > 0.25:
base_angle = 20.0
else:
base_angle = -30.0
base_angle += (0.5 - random.random()) * 20.0
wave = Wave(base_angle=base_angle, entries=all_entries)
return wave
[docs]
def add_bot_at_point(
self, point: Point, spaz_type: type[SpazBot], spawn_time: float = 1.0
) -> None:
"""Add a new bot at a specified named point."""
if self._game_over:
return
assert isinstance(point.value, str)
pointpos = self.map.defs.points[point.value]
assert self._bots is not None
self._bots.spawn_bot(spaz_type, pos=pointpos, spawn_time=spawn_time)
[docs]
def add_bot_at_angle(
self, angle: float, spaz_type: type[SpazBot], spawn_time: float = 1.0
) -> None:
"""Add a new bot at a specified angle (for circular maps)."""
if self._game_over:
return
angle_radians = angle / 57.2957795
xval = math.sin(angle_radians) * 1.06
zval = math.cos(angle_radians) * 1.06
point = (xval / 0.125, 2.3, (zval / 0.2) - 3.7)
assert self._bots is not None
self._bots.spawn_bot(spaz_type, pos=point, spawn_time=spawn_time)
def _update_time_bonus(self) -> None:
self._time_bonus = int(self._time_bonus * 0.93)
if self._time_bonus > 0 and self._time_bonus_text is not None:
assert self._time_bonus_text.node
self._time_bonus_text.node.text = bs.Lstr(
value='${A}: ${B}',
subs=[
('${A}', bs.Lstr(resource='timeBonusText')),
('${B}', str(self._time_bonus)),
],
)
else:
self._time_bonus_text = None
def _start_updating_waves(self) -> None:
self._wave_update_timer = bs.Timer(
2.0, bs.WeakCall(self._update_waves), repeat=True
)
def _update_scores(self) -> None:
score = self._score
if self._preset is Preset.ENDLESS:
if score >= 500:
self._award_achievement('Onslaught Master')
if score >= 1000:
self._award_achievement('Onslaught Wizard')
if score >= 5000:
self._award_achievement('Onslaught God')
assert self._scoreboard is not None
self._scoreboard.set_team_value(self.teams[0], score, max_score=None)
[docs]
@override
def handlemessage(self, msg: Any) -> Any:
if isinstance(msg, PlayerSpazHurtMessage):
msg.spaz.getplayer(Player, True).has_been_hurt = True
self._a_player_has_been_hurt = True
elif isinstance(msg, bs.PlayerScoredMessage):
self._score += msg.score
self._update_scores()
elif isinstance(msg, bs.PlayerDiedMessage):
super().handlemessage(msg) # Augment standard behavior.
player = msg.getplayer(Player)
self._a_player_has_been_hurt = True
# Make note with the player when they can respawn:
if self._wavenum < 10:
player.respawn_wave = max(2, self._wavenum + 1)
elif self._wavenum < 15:
player.respawn_wave = max(2, self._wavenum + 2)
else:
player.respawn_wave = max(2, self._wavenum + 3)
bs.timer(0.1, self._update_player_spawn_info)
bs.timer(0.1, self._checkroundover)
elif isinstance(msg, SpazBotDiedMessage):
pts, importance = msg.spazbot.get_death_points(msg.how)
if msg.killerplayer is not None:
self._handle_kill_achievements(msg)
target: Sequence[float] | None
if msg.spazbot.node:
target = msg.spazbot.node.position
else:
target = None
killerplayer = msg.killerplayer
self.stats.player_scored(
killerplayer,
pts,
target=target,
kill=True,
screenmessage=False,
importance=importance,
)
dingsound = (
self._dingsound if importance == 1 else self._dingsoundhigh
)
dingsound.play(volume=0.6)
# Normally we pull scores from the score-set, but if there's
# no player lets be explicit.
else:
self._score += pts
self._update_scores()
else:
super().handlemessage(msg)
def _handle_kill_achievements(self, msg: SpazBotDiedMessage) -> None:
if self._preset in {Preset.TRAINING, Preset.TRAINING_EASY}:
self._handle_training_kill_achievements(msg)
elif self._preset in {Preset.ROOKIE, Preset.ROOKIE_EASY}:
self._handle_rookie_kill_achievements(msg)
elif self._preset in {Preset.PRO, Preset.PRO_EASY}:
self._handle_pro_kill_achievements(msg)
elif self._preset in {Preset.UBER, Preset.UBER_EASY}:
self._handle_uber_kill_achievements(msg)
def _handle_uber_kill_achievements(self, msg: SpazBotDiedMessage) -> None:
# Uber mine achievement:
if msg.spazbot.last_attacked_type == ('explosion', 'land_mine'):
self._land_mine_kills += 1
if self._land_mine_kills >= 6:
self._award_achievement('Gold Miner')
# Uber tnt achievement:
if msg.spazbot.last_attacked_type == ('explosion', 'tnt'):
self._tnt_kills += 1
if self._tnt_kills >= 6:
bs.timer(
0.5, bs.WeakCall(self._award_achievement, 'TNT Terror')
)
def _handle_pro_kill_achievements(self, msg: SpazBotDiedMessage) -> None:
# TNT achievement:
if msg.spazbot.last_attacked_type == ('explosion', 'tnt'):
self._tnt_kills += 1
if self._tnt_kills >= 3:
bs.timer(
0.5,
bs.WeakCall(
self._award_achievement, 'Boom Goes the Dynamite'
),
)
def _handle_rookie_kill_achievements(self, msg: SpazBotDiedMessage) -> None:
# Land-mine achievement:
if msg.spazbot.last_attacked_type == ('explosion', 'land_mine'):
self._land_mine_kills += 1
if self._land_mine_kills >= 3:
self._award_achievement('Mine Games')
def _handle_training_kill_achievements(
self, msg: SpazBotDiedMessage
) -> None:
# Toss-off-map achievement:
if msg.spazbot.last_attacked_type == ('picked_up', 'default'):
self._throw_off_kills += 1
if self._throw_off_kills >= 3:
self._award_achievement('Off You Go Then')
def _set_can_end_wave(self) -> None:
self._can_end_wave = True
[docs]
@override
def end_game(self) -> None:
# Tell our bots to celebrate just to rub it in.
assert self._bots is not None
self._bots.final_celebrate()
self._game_over = True
self.do_end('defeat', delay=2.0)
bs.setmusic(None)
def _checkroundover(self) -> None:
"""Potentially end the round based on the state of the game."""
if self.has_ended():
return
if not any(player.is_alive() for player in self.teams[0].players):
self.end_game()