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