bastd.game.ninjafight

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Provides Ninja Fight mini-game."""
  4
  5# ba_meta require api 7
  6# (see https://ballistica.net/wiki/meta-tag-system)
  7
  8from __future__ import annotations
  9
 10import random
 11from typing import TYPE_CHECKING
 12
 13import ba
 14from bastd.actor.spazbot import SpazBotSet, ChargerBot, SpazBotDiedMessage
 15from bastd.actor.onscreentimer import OnScreenTimer
 16
 17if TYPE_CHECKING:
 18    from typing import Any
 19
 20
 21class Player(ba.Player['Team']):
 22    """Our player type for this game."""
 23
 24
 25class Team(ba.Team[Player]):
 26    """Our team type for this game."""
 27
 28
 29# ba_meta export game
 30class NinjaFightGame(ba.TeamGameActivity[Player, Team]):
 31    """
 32    A co-op game where you try to defeat a group
 33    of Ninjas as fast as possible
 34    """
 35
 36    name = 'Ninja Fight'
 37    description = 'How fast can you defeat the ninjas?'
 38    scoreconfig = ba.ScoreConfig(label='Time',
 39                                 scoretype=ba.ScoreType.MILLISECONDS,
 40                                 lower_is_better=True)
 41    default_music = ba.MusicType.TO_THE_DEATH
 42
 43    @classmethod
 44    def get_supported_maps(cls, sessiontype: type[ba.Session]) -> list[str]:
 45        # For now we're hard-coding spawn positions and whatnot
 46        # so we need to be sure to specify that we only support
 47        # a specific map.
 48        return ['Courtyard']
 49
 50    @classmethod
 51    def supports_session_type(cls, sessiontype: type[ba.Session]) -> bool:
 52        # We currently support Co-Op only.
 53        return issubclass(sessiontype, ba.CoopSession)
 54
 55    # In the constructor we should load any media we need/etc.
 56    # ...but not actually create anything yet.
 57    def __init__(self, settings: dict):
 58        super().__init__(settings)
 59        self._winsound = ba.getsound('score')
 60        self._won = False
 61        self._timer: OnScreenTimer | None = None
 62        self._bots = SpazBotSet()
 63        self._preset = str(settings['preset'])
 64
 65    # Called when our game actually begins.
 66    def on_begin(self) -> None:
 67        super().on_begin()
 68        is_pro = self._preset == 'pro'
 69
 70        # In pro mode there's no powerups.
 71        if not is_pro:
 72            self.setup_standard_powerup_drops()
 73
 74        # Make our on-screen timer and start it roughly when our bots appear.
 75        self._timer = OnScreenTimer()
 76        ba.timer(4.0, self._timer.start)
 77
 78        # Spawn some baddies.
 79        ba.timer(
 80            1.0, lambda: self._bots.spawn_bot(
 81                ChargerBot, pos=(3, 3, -2), spawn_time=3.0))
 82        ba.timer(
 83            2.0, lambda: self._bots.spawn_bot(
 84                ChargerBot, pos=(-3, 3, -2), spawn_time=3.0))
 85        ba.timer(
 86            3.0, lambda: self._bots.spawn_bot(
 87                ChargerBot, pos=(5, 3, -2), spawn_time=3.0))
 88        ba.timer(
 89            4.0, lambda: self._bots.spawn_bot(
 90                ChargerBot, pos=(-5, 3, -2), spawn_time=3.0))
 91
 92        # Add some extras for multiplayer or pro mode.
 93        assert self.initialplayerinfos is not None
 94        if len(self.initialplayerinfos) > 2 or is_pro:
 95            ba.timer(
 96                5.0, lambda: self._bots.spawn_bot(
 97                    ChargerBot, pos=(0, 3, -5), spawn_time=3.0))
 98        if len(self.initialplayerinfos) > 3 or is_pro:
 99            ba.timer(
100                6.0, lambda: self._bots.spawn_bot(
101                    ChargerBot, pos=(0, 3, 1), spawn_time=3.0))
102
103    # Called for each spawning player.
104    def spawn_player(self, player: Player) -> ba.Actor:
105
106        # Let's spawn close to the center.
107        spawn_center = (0, 3, -2)
108        pos = (spawn_center[0] + random.uniform(-1.5, 1.5), spawn_center[1],
109               spawn_center[2] + random.uniform(-1.5, 1.5))
110        return self.spawn_player_spaz(player, position=pos)
111
112    def _check_if_won(self) -> None:
113        # Simply end the game if there's no living bots.
114        # FIXME: Should also make sure all bots have been spawned;
115        #  if spawning is spread out enough that we're able to kill
116        #  all living bots before the next spawns, it would incorrectly
117        #  count as a win.
118        if not self._bots.have_living_bots():
119            self._won = True
120            self.end_game()
121
122    # Called for miscellaneous messages.
123    def handlemessage(self, msg: Any) -> Any:
124
125        # A player has died.
126        if isinstance(msg, ba.PlayerDiedMessage):
127            super().handlemessage(msg)  # Augment standard behavior.
128            self.respawn_player(msg.getplayer(Player))
129
130        # A spaz-bot has died.
131        elif isinstance(msg, SpazBotDiedMessage):
132            # Unfortunately the bot-set will always tell us there are living
133            # bots if we ask here (the currently-dying bot isn't officially
134            # marked dead yet) ..so lets push a call into the event loop to
135            # check once this guy has finished dying.
136            ba.pushcall(self._check_if_won)
137
138        # Let the base class handle anything we don't.
139        else:
140            return super().handlemessage(msg)
141        return None
142
143    # When this is called, we should fill out results and end the game
144    # *regardless* of whether is has been won. (this may be called due
145    # to a tournament ending or other external reason).
146    def end_game(self) -> None:
147
148        # Stop our on-screen timer so players can see what they got.
149        assert self._timer is not None
150        self._timer.stop()
151
152        results = ba.GameResults()
153
154        # If we won, set our score to the elapsed time in milliseconds.
155        # (there should just be 1 team here since this is co-op).
156        # ..if we didn't win, leave scores as default (None) which means
157        # we lost.
158        if self._won:
159            elapsed_time_ms = int((ba.time() - self._timer.starttime) * 1000.0)
160            ba.cameraflash()
161            ba.playsound(self._winsound)
162            for team in self.teams:
163                for player in team.players:
164                    if player.actor:
165                        player.actor.handlemessage(ba.CelebrateMessage())
166                results.set_team_score(team, elapsed_time_ms)
167
168        # Ends the activity.
169        self.end(results)