bascenev1lib.game.meteorshower

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Defines a bomb-dodging 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.bomb import Bomb
 14from bascenev1lib.actor.onscreentimer import OnScreenTimer
 15import bascenev1 as bs
 16
 17if TYPE_CHECKING:
 18    from typing import Any, Sequence
 19
 20
 21class Player(bs.Player['Team']):
 22    """Our player type for this game."""
 23
 24    def __init__(self) -> None:
 25        super().__init__()
 26        self.death_time: float | None = None
 27
 28
 29class Team(bs.Team[Player]):
 30    """Our team type for this game."""
 31
 32
 33# ba_meta export bascenev1.GameActivity
 34class MeteorShowerGame(bs.TeamGameActivity[Player, Team]):
 35    """Minigame involving dodging falling bombs."""
 36
 37    name = 'Meteor Shower'
 38    description = 'Dodge the falling bombs.'
 39    available_settings = [bs.BoolSetting('Epic Mode', default=False)]
 40    scoreconfig = bs.ScoreConfig(
 41        label='Survived', scoretype=bs.ScoreType.MILLISECONDS, version='B'
 42    )
 43
 44    # Print messages when players die (since its meaningful in this game).
 45    announce_player_deaths = True
 46
 47    # Don't allow joining after we start
 48    # (would enable leave/rejoin tomfoolery).
 49    allow_mid_activity_joins = False
 50
 51    # We're currently hard-coded for one map.
 52    @classmethod
 53    def get_supported_maps(cls, sessiontype: type[bs.Session]) -> list[str]:
 54        return ['Rampage']
 55
 56    # We support teams, free-for-all, and co-op sessions.
 57    @classmethod
 58    def supports_session_type(cls, sessiontype: type[bs.Session]) -> bool:
 59        return (
 60            issubclass(sessiontype, bs.DualTeamSession)
 61            or issubclass(sessiontype, bs.FreeForAllSession)
 62            or issubclass(sessiontype, bs.CoopSession)
 63        )
 64
 65    def __init__(self, settings: dict):
 66        super().__init__(settings)
 67
 68        self._epic_mode = settings.get('Epic Mode', False)
 69        self._last_player_death_time: float | None = None
 70        self._meteor_time = 2.0
 71        self._timer: OnScreenTimer | None = None
 72
 73        # Some base class overrides:
 74        self.default_music = (
 75            bs.MusicType.EPIC if self._epic_mode else bs.MusicType.SURVIVAL
 76        )
 77        if self._epic_mode:
 78            self.slow_motion = True
 79
 80    def on_begin(self) -> None:
 81        super().on_begin()
 82
 83        # Drop a wave every few seconds.. and every so often drop the time
 84        # between waves ..lets have things increase faster if we have fewer
 85        # players.
 86        delay = 5.0 if len(self.players) > 2 else 2.5
 87        if self._epic_mode:
 88            delay *= 0.25
 89        bs.timer(delay, self._decrement_meteor_time, repeat=True)
 90
 91        # Kick off the first wave in a few seconds.
 92        delay = 3.0
 93        if self._epic_mode:
 94            delay *= 0.25
 95        bs.timer(delay, self._set_meteor_timer)
 96
 97        self._timer = OnScreenTimer()
 98        self._timer.start()
 99
100        # Check for immediate end (if we've only got 1 player, etc).
101        bs.timer(5.0, self._check_end_game)
102
103    def on_player_leave(self, player: Player) -> None:
104        # Augment default behavior.
105        super().on_player_leave(player)
106
107        # A departing player may trigger game-over.
108        self._check_end_game()
109
110    # overriding the default character spawning..
111    def spawn_player(self, player: Player) -> bs.Actor:
112        spaz = self.spawn_player_spaz(player)
113
114        # Let's reconnect this player's controls to this
115        # spaz but *without* the ability to attack or pick stuff up.
116        spaz.connect_controls_to_player(
117            enable_punch=False, enable_bomb=False, enable_pickup=False
118        )
119
120        # Also lets have them make some noise when they die.
121        spaz.play_big_death_sound = True
122        return spaz
123
124    # Various high-level game events come through this method.
125    def handlemessage(self, msg: Any) -> Any:
126        if isinstance(msg, bs.PlayerDiedMessage):
127            # Augment standard behavior.
128            super().handlemessage(msg)
129
130            curtime = bs.time()
131
132            # Record the player's moment of death.
133            # assert isinstance(msg.spaz.player
134            msg.getplayer(Player).death_time = curtime
135
136            # In co-op mode, end the game the instant everyone dies
137            # (more accurate looking).
138            # In teams/ffa, allow a one-second fudge-factor so we can
139            # get more draws if players die basically at the same time.
140            if isinstance(self.session, bs.CoopSession):
141                # Teams will still show up if we check now.. check in
142                # the next cycle.
143                bs.pushcall(self._check_end_game)
144
145                # Also record this for a final setting of the clock.
146                self._last_player_death_time = curtime
147            else:
148                bs.timer(1.0, self._check_end_game)
149
150        else:
151            # Default handler:
152            return super().handlemessage(msg)
153        return None
154
155    def _check_end_game(self) -> None:
156        living_team_count = 0
157        for team in self.teams:
158            for player in team.players:
159                if player.is_alive():
160                    living_team_count += 1
161                    break
162
163        # In co-op, we go till everyone is dead.. otherwise we go
164        # until one team remains.
165        if isinstance(self.session, bs.CoopSession):
166            if living_team_count <= 0:
167                self.end_game()
168        else:
169            if living_team_count <= 1:
170                self.end_game()
171
172    def _set_meteor_timer(self) -> None:
173        bs.timer(
174            (1.0 + 0.2 * random.random()) * self._meteor_time,
175            self._drop_bomb_cluster,
176        )
177
178    def _drop_bomb_cluster(self) -> None:
179        # Random note: code like this is a handy way to plot out extents
180        # and debug things.
181        loc_test = False
182        if loc_test:
183            bs.newnode('locator', attrs={'position': (8, 6, -5.5)})
184            bs.newnode('locator', attrs={'position': (8, 6, -2.3)})
185            bs.newnode('locator', attrs={'position': (-7.3, 6, -5.5)})
186            bs.newnode('locator', attrs={'position': (-7.3, 6, -2.3)})
187
188        # Drop several bombs in series.
189        delay = 0.0
190        for _i in range(random.randrange(1, 3)):
191            # Drop them somewhere within our bounds with velocity pointing
192            # toward the opposite side.
193            pos = (
194                -7.3 + 15.3 * random.random(),
195                11,
196                -5.57 + 2.1 * random.random(),
197            )
198            dropdir = -1.0 if pos[0] > 0 else 1.0
199            vel = (
200                (-5.0 + random.random() * 30.0) * dropdir,
201                random.uniform(-3.066, -4.12),
202                0,
203            )
204            bs.timer(delay, bs.Call(self._drop_bomb, pos, vel))
205            delay += 0.1
206        self._set_meteor_timer()
207
208    def _drop_bomb(
209        self, position: Sequence[float], velocity: Sequence[float]
210    ) -> None:
211        Bomb(position=position, velocity=velocity).autoretain()
212
213    def _decrement_meteor_time(self) -> None:
214        self._meteor_time = max(0.01, self._meteor_time * 0.9)
215
216    def end_game(self) -> None:
217        cur_time = bs.time()
218        assert self._timer is not None
219        start_time = self._timer.getstarttime()
220
221        # Mark death-time as now for any still-living players
222        # and award players points for how long they lasted.
223        # (these per-player scores are only meaningful in team-games)
224        for team in self.teams:
225            for player in team.players:
226                survived = False
227
228                # Throw an extra fudge factor in so teams that
229                # didn't die come out ahead of teams that did.
230                if player.death_time is None:
231                    survived = True
232                    player.death_time = cur_time + 1
233
234                # Award a per-player score depending on how many seconds
235                # they lasted (per-player scores only affect teams mode;
236                # everywhere else just looks at the per-team score).
237                score = int(player.death_time - self._timer.getstarttime())
238                if survived:
239                    score += 50  # A bit extra for survivors.
240                self.stats.player_scored(player, score, screenmessage=False)
241
242        # Stop updating our time text, and set the final time to match
243        # exactly when our last guy died.
244        self._timer.stop(endtime=self._last_player_death_time)
245
246        # Ok now calc game results: set a score for each team and then tell
247        # the game to end.
248        results = bs.GameResults()
249
250        # Remember that 'free-for-all' mode is simply a special form
251        # of 'teams' mode where each player gets their own team, so we can
252        # just always deal in teams and have all cases covered.
253        for team in self.teams:
254            # Set the team score to the max time survived by any player on
255            # that team.
256            longest_life = 0.0
257            for player in team.players:
258                assert player.death_time is not None
259                longest_life = max(longest_life, player.death_time - start_time)
260
261            # Submit the score value in milliseconds.
262            results.set_team_score(team, int(1000.0 * longest_life))
263
264        self.end(results=results)