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