bascenev1lib.game.thelaststand

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Defines the last stand minigame."""
  4
  5from __future__ import annotations
  6
  7import random
  8import logging
  9from dataclasses import dataclass
 10from typing import TYPE_CHECKING, override
 11
 12import bascenev1 as bs
 13
 14from bascenev1lib.actor.playerspaz import PlayerSpaz
 15from bascenev1lib.actor.bomb import TNTSpawner
 16from bascenev1lib.actor.scoreboard import Scoreboard
 17from bascenev1lib.actor.powerupbox import PowerupBoxFactory, PowerupBox
 18from bascenev1lib.actor.spazbot import (
 19    SpazBotSet,
 20    SpazBotDiedMessage,
 21    BomberBot,
 22    BomberBotPro,
 23    BomberBotProShielded,
 24    BrawlerBot,
 25    BrawlerBotPro,
 26    BrawlerBotProShielded,
 27    TriggerBot,
 28    TriggerBotPro,
 29    TriggerBotProShielded,
 30    ChargerBot,
 31    StickyBot,
 32    ExplodeyBot,
 33)
 34
 35if TYPE_CHECKING:
 36    from typing import Any, Sequence
 37    from bascenev1lib.actor.spazbot import SpazBot
 38
 39
 40@dataclass
 41class SpawnInfo:
 42    """Spawning info for a particular bot type."""
 43
 44    spawnrate: float
 45    increase: float
 46    dincrease: float
 47
 48
 49class Player(bs.Player['Team']):
 50    """Our player type for this game."""
 51
 52
 53class Team(bs.Team[Player]):
 54    """Our team type for this game."""
 55
 56
 57class TheLastStandGame(bs.CoopGameActivity[Player, Team]):
 58    """Slow motion how-long-can-you-last game."""
 59
 60    name = 'The Last Stand'
 61    description = 'Final glorious epic slow motion battle to the death.'
 62    tips = [
 63        'This level never ends, but a high score here\n'
 64        'will earn you eternal respect throughout the world.'
 65    ]
 66
 67    # Show messages when players die since it matters here.
 68    announce_player_deaths = True
 69
 70    # And of course the most important part.
 71    slow_motion = True
 72
 73    default_music = bs.MusicType.EPIC
 74
 75    def __init__(self, settings: dict):
 76        settings['map'] = 'Rampage'
 77        super().__init__(settings)
 78        self._new_wave_sound = bs.getsound('scoreHit01')
 79        self._winsound = bs.getsound('score')
 80        self._cashregistersound = bs.getsound('cashRegister')
 81        self._spawn_center = (0, 5.5, -4.14)
 82        self._tntspawnpos = (0, 5.5, -6)
 83        self._powerup_center = (0, 7, -4.14)
 84        self._powerup_spread = (7, 2)
 85        self._preset = str(settings.get('preset', 'default'))
 86        self._excludepowerups: list[str] = []
 87        self._scoreboard: Scoreboard | None = None
 88        self._score = 0
 89        self._bots = SpazBotSet()
 90        self._dingsound = bs.getsound('dingSmall')
 91        self._dingsoundhigh = bs.getsound('dingSmallHigh')
 92        self._tntspawner: TNTSpawner | None = None
 93        self._bot_update_interval: float | None = None
 94        self._bot_update_timer: bs.Timer | None = None
 95        self._powerup_drop_timer = None
 96
 97        # For each bot type: [spawnrate, increase, d_increase]
 98        self._bot_spawn_types = {
 99            BomberBot: SpawnInfo(1.00, 0.00, 0.000),
100            BomberBotPro: SpawnInfo(0.00, 0.05, 0.001),
101            BomberBotProShielded: SpawnInfo(0.00, 0.02, 0.002),
102            BrawlerBot: SpawnInfo(1.00, 0.00, 0.000),
103            BrawlerBotPro: SpawnInfo(0.00, 0.05, 0.001),
104            BrawlerBotProShielded: SpawnInfo(0.00, 0.02, 0.002),
105            TriggerBot: SpawnInfo(0.30, 0.00, 0.000),
106            TriggerBotPro: SpawnInfo(0.00, 0.05, 0.001),
107            TriggerBotProShielded: SpawnInfo(0.00, 0.02, 0.002),
108            ChargerBot: SpawnInfo(0.30, 0.05, 0.000),
109            StickyBot: SpawnInfo(0.10, 0.03, 0.001),
110            ExplodeyBot: SpawnInfo(0.05, 0.02, 0.002),
111        }
112
113    @override
114    def on_transition_in(self) -> None:
115        super().on_transition_in()
116        bs.timer(1.3, self._new_wave_sound.play)
117        self._scoreboard = Scoreboard(
118            label=bs.Lstr(resource='scoreText'), score_split=0.5
119        )
120
121    @override
122    def on_begin(self) -> None:
123        super().on_begin()
124
125        # Spit out a few powerups and start dropping more shortly.
126        self._drop_powerups(standard_points=True)
127        bs.timer(2.0, bs.WeakCall(self._start_powerup_drops))
128        bs.timer(0.001, bs.WeakCall(self._start_bot_updates))
129        self.setup_low_life_warning_sound()
130        self._update_scores()
131        self._tntspawner = TNTSpawner(
132            position=self._tntspawnpos, respawn_time=10.0
133        )
134
135    @override
136    def spawn_player(self, player: Player) -> bs.Actor:
137        pos = (
138            self._spawn_center[0] + random.uniform(-1.5, 1.5),
139            self._spawn_center[1],
140            self._spawn_center[2] + random.uniform(-1.5, 1.5),
141        )
142        return self.spawn_player_spaz(player, position=pos)
143
144    def _start_bot_updates(self) -> None:
145        self._bot_update_interval = 3.3 - 0.3 * (len(self.players))
146        self._update_bots()
147        self._update_bots()
148        if len(self.players) > 2:
149            self._update_bots()
150        if len(self.players) > 3:
151            self._update_bots()
152        self._bot_update_timer = bs.Timer(
153            self._bot_update_interval, bs.WeakCall(self._update_bots)
154        )
155
156    def _drop_powerup(self, index: int, poweruptype: str | None = None) -> None:
157        if poweruptype is None:
158            poweruptype = PowerupBoxFactory.get().get_random_powerup_type(
159                excludetypes=self._excludepowerups
160            )
161        PowerupBox(
162            position=self.map.powerup_spawn_points[index],
163            poweruptype=poweruptype,
164        ).autoretain()
165
166    def _start_powerup_drops(self) -> None:
167        self._powerup_drop_timer = bs.Timer(
168            3.0, bs.WeakCall(self._drop_powerups), repeat=True
169        )
170
171    def _drop_powerups(
172        self, standard_points: bool = False, force_first: str | None = None
173    ) -> None:
174        """Generic powerup drop."""
175        from bascenev1lib.actor import powerupbox
176
177        if standard_points:
178            pts = self.map.powerup_spawn_points
179            for i in range(len(pts)):
180                bs.timer(
181                    1.0 + i * 0.5,
182                    bs.WeakCall(
183                        self._drop_powerup, i, force_first if i == 0 else None
184                    ),
185                )
186        else:
187            drop_pt = (
188                self._powerup_center[0]
189                + random.uniform(
190                    -1.0 * self._powerup_spread[0],
191                    1.0 * self._powerup_spread[0],
192                ),
193                self._powerup_center[1],
194                self._powerup_center[2]
195                + random.uniform(
196                    -self._powerup_spread[1], self._powerup_spread[1]
197                ),
198            )
199
200            # Drop one random one somewhere.
201            powerupbox.PowerupBox(
202                position=drop_pt,
203                poweruptype=PowerupBoxFactory.get().get_random_powerup_type(
204                    excludetypes=self._excludepowerups
205                ),
206            ).autoretain()
207
208    def do_end(self, outcome: str) -> None:
209        """End the game."""
210        if outcome == 'defeat':
211            self.fade_to_red()
212        self.end(
213            delay=2.0,
214            results={
215                'outcome': outcome,
216                'score': self._score,
217                'playerinfos': self.initialplayerinfos,
218            },
219        )
220
221    def _update_bots(self) -> None:
222        assert self._bot_update_interval is not None
223        self._bot_update_interval = max(0.5, self._bot_update_interval * 0.98)
224        self._bot_update_timer = bs.Timer(
225            self._bot_update_interval, bs.WeakCall(self._update_bots)
226        )
227        botspawnpts: list[Sequence[float]] = [
228            [-5.0, 5.5, -4.14],
229            [0.0, 5.5, -4.14],
230            [5.0, 5.5, -4.14],
231        ]
232        dists = [0.0, 0.0, 0.0]
233        playerpts: list[Sequence[float]] = []
234        for player in self.players:
235            try:
236                if player.is_alive():
237                    assert isinstance(player.actor, PlayerSpaz)
238                    assert player.actor.node
239                    playerpts.append(player.actor.node.position)
240            except Exception:
241                logging.exception('Error updating bots.')
242        for i in range(3):
243            for playerpt in playerpts:
244                dists[i] += abs(playerpt[0] - botspawnpts[i][0])
245            dists[i] += random.random() * 5.0  # Minor random variation.
246        if dists[0] > dists[1] and dists[0] > dists[2]:
247            spawnpt = botspawnpts[0]
248        elif dists[1] > dists[2]:
249            spawnpt = botspawnpts[1]
250        else:
251            spawnpt = botspawnpts[2]
252
253        spawnpt = (
254            spawnpt[0] + 3.0 * (random.random() - 0.5),
255            spawnpt[1],
256            2.0 * (random.random() - 0.5) + spawnpt[2],
257        )
258
259        # Normalize our bot type total and find a random number within that.
260        total = 0.0
261        for spawninfo in self._bot_spawn_types.values():
262            total += spawninfo.spawnrate
263        randval = random.random() * total
264
265        # Now go back through and see where this value falls.
266        total = 0
267        bottype: type[SpazBot] | None = None
268        for spawntype, spawninfo in self._bot_spawn_types.items():
269            total += spawninfo.spawnrate
270            if randval <= total:
271                bottype = spawntype
272                break
273        spawn_time = 1.0
274        assert bottype is not None
275        self._bots.spawn_bot(bottype, pos=spawnpt, spawn_time=spawn_time)
276
277        # After every spawn we adjust our ratios slightly to get more
278        # difficult.
279        for spawninfo in self._bot_spawn_types.values():
280            spawninfo.spawnrate += spawninfo.increase
281            spawninfo.increase += spawninfo.dincrease
282
283    def _update_scores(self) -> None:
284        score = self._score
285
286        # Achievements apply to the default preset only.
287        if self._preset == 'default':
288            if score >= 250:
289                self._award_achievement('Last Stand Master')
290            if score >= 500:
291                self._award_achievement('Last Stand Wizard')
292            if score >= 1000:
293                self._award_achievement('Last Stand God')
294        assert self._scoreboard is not None
295        self._scoreboard.set_team_value(self.teams[0], score, max_score=None)
296
297    @override
298    def handlemessage(self, msg: Any) -> Any:
299        if isinstance(msg, bs.PlayerDiedMessage):
300            player = msg.getplayer(Player)
301            self.stats.player_was_killed(player)
302            bs.timer(0.1, self._checkroundover)
303
304        elif isinstance(msg, bs.PlayerScoredMessage):
305            self._score += msg.score
306            self._update_scores()
307
308        elif isinstance(msg, SpazBotDiedMessage):
309            pts, importance = msg.spazbot.get_death_points(msg.how)
310            target: Sequence[float] | None
311            if msg.killerplayer:
312                assert msg.spazbot.node
313                target = msg.spazbot.node.position
314                self.stats.player_scored(
315                    msg.killerplayer,
316                    pts,
317                    target=target,
318                    kill=True,
319                    screenmessage=False,
320                    importance=importance,
321                )
322                diesound = (
323                    self._dingsound if importance == 1 else self._dingsoundhigh
324                )
325                diesound.play(volume=0.6)
326
327            # Normally we pull scores from the score-set, but if there's no
328            # player lets be explicit.
329            else:
330                self._score += pts
331            self._update_scores()
332        else:
333            super().handlemessage(msg)
334
335    @override
336    def end_game(self) -> None:
337        # Tell our bots to celebrate just to rub it in.
338        self._bots.final_celebrate()
339        bs.setmusic(None)
340        bs.pushcall(bs.WeakCall(self.do_end, 'defeat'))
341
342    def _checkroundover(self) -> None:
343        """End the round if conditions are met."""
344        if not any(player.is_alive() for player in self.teams[0].players):
345            self.end_game()