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