bascenev1lib.game.easteregghunt

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Provides an easter egg hunt 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.playerspaz import PlayerSpaz
 17from bascenev1lib.actor.spazbot import SpazBotSet, BouncyBot, SpazBotDiedMessage
 18from bascenev1lib.actor.onscreencountdown import OnScreenCountdown
 19from bascenev1lib.actor.scoreboard import Scoreboard
 20from bascenev1lib.actor.respawnicon import RespawnIcon
 21from bascenev1lib.gameutils import SharedObjects
 22
 23if TYPE_CHECKING:
 24    from typing import Any
 25
 26
 27class Player(bs.Player['Team']):
 28    """Our player type for this game."""
 29
 30    def __init__(self) -> None:
 31        self.respawn_timer: bs.Timer | None = None
 32        self.respawn_icon: RespawnIcon | None = None
 33
 34
 35class Team(bs.Team[Player]):
 36    """Our team type for this game."""
 37
 38    def __init__(self) -> None:
 39        self.score = 0
 40
 41
 42# ba_meta export bascenev1.GameActivity
 43class EasterEggHuntGame(bs.TeamGameActivity[Player, Team]):
 44    """A game where score is based on collecting eggs."""
 45
 46    name = 'Easter Egg Hunt'
 47    description = 'Gather eggs!'
 48    available_settings = [
 49        bs.BoolSetting('Pro Mode', default=False),
 50        bs.BoolSetting('Epic Mode', default=False),
 51    ]
 52    scoreconfig = bs.ScoreConfig(label='Score', scoretype=bs.ScoreType.POINTS)
 53
 54    # We're currently hard-coded for one map.
 55    @override
 56    @classmethod
 57    def get_supported_maps(cls, sessiontype: type[bs.Session]) -> list[str]:
 58        return ['Tower D']
 59
 60    # We support teams, free-for-all, and co-op sessions.
 61    @override
 62    @classmethod
 63    def supports_session_type(cls, sessiontype: type[bs.Session]) -> bool:
 64        return (
 65            issubclass(sessiontype, bs.CoopSession)
 66            or issubclass(sessiontype, bs.DualTeamSession)
 67            or issubclass(sessiontype, bs.FreeForAllSession)
 68        )
 69
 70    def __init__(self, settings: dict):
 71        super().__init__(settings)
 72        shared = SharedObjects.get()
 73        self._last_player_death_time = None
 74        self._scoreboard = Scoreboard()
 75        self.egg_mesh = bs.getmesh('egg')
 76        self.egg_tex_1 = bs.gettexture('eggTex1')
 77        self.egg_tex_2 = bs.gettexture('eggTex2')
 78        self.egg_tex_3 = bs.gettexture('eggTex3')
 79        self._collect_sound = bs.getsound('powerup01')
 80        self._pro_mode = settings.get('Pro Mode', False)
 81        self._epic_mode = settings.get('Epic Mode', False)
 82        self._max_eggs = 1.0
 83        self.egg_material = bs.Material()
 84        self.egg_material.add_actions(
 85            conditions=('they_have_material', shared.player_material),
 86            actions=(('call', 'at_connect', self._on_egg_player_collide),),
 87        )
 88        self._eggs: list[Egg] = []
 89        self._update_timer: bs.Timer | None = None
 90        self._countdown: OnScreenCountdown | None = None
 91        self._bots: SpazBotSet | None = None
 92
 93        # Base class overrides
 94        self.slow_motion = self._epic_mode
 95        self.default_music = (
 96            bs.MusicType.EPIC if self._epic_mode else bs.MusicType.FORWARD_MARCH
 97        )
 98
 99    @override
100    def on_team_join(self, team: Team) -> None:
101        if self.has_begun():
102            self._update_scoreboard()
103
104    # Called when our game actually starts.
105    @override
106    def on_begin(self) -> None:
107        from bascenev1lib.maps import TowerD
108
109        # There's a player-wall on the tower-d level to prevent
110        # players from getting up on the stairs.. we wanna kill that.
111        gamemap = self.map
112        assert isinstance(gamemap, TowerD)
113        gamemap.player_wall.delete()
114        super().on_begin()
115        self._update_scoreboard()
116        self._update_timer = bs.Timer(0.25, self._update, repeat=True)
117        self._countdown = OnScreenCountdown(60, endcall=self.end_game)
118        bs.timer(4.0, self._countdown.start)
119        self._bots = SpazBotSet()
120
121        # Spawn evil bunny in co-op only.
122        if isinstance(self.session, bs.CoopSession) and self._pro_mode:
123            self._spawn_evil_bunny()
124
125    # Overriding the default character spawning.
126    @override
127    def spawn_player(self, player: Player) -> bs.Actor:
128        spaz = self.spawn_player_spaz(player)
129        spaz.connect_controls_to_player()
130        return spaz
131
132    def _spawn_evil_bunny(self) -> None:
133        assert self._bots is not None
134        self._bots.spawn_bot(BouncyBot, pos=(6, 4, -7.8), spawn_time=10.0)
135
136    def _on_egg_player_collide(self) -> None:
137        if self.has_ended():
138            return
139        collision = bs.getcollision()
140
141        # Be defensive here; we could be hitting the corpse of a player
142        # who just left/etc.
143        try:
144            egg = collision.sourcenode.getdelegate(Egg, True)
145            player = collision.opposingnode.getdelegate(
146                PlayerSpaz, True
147            ).getplayer(Player, True)
148        except bs.NotFoundError:
149            return
150
151        player.team.score += 1
152
153        # Displays a +1 (and adds to individual player score in
154        # teams mode).
155        self.stats.player_scored(player, 1, screenmessage=False)
156        if self._max_eggs < 5:
157            self._max_eggs += 1.0
158        elif self._max_eggs < 10:
159            self._max_eggs += 0.5
160        elif self._max_eggs < 30:
161            self._max_eggs += 0.3
162        self._update_scoreboard()
163        self._collect_sound.play(0.5, position=egg.node.position)
164
165        # Create a flash.
166        light = bs.newnode(
167            'light',
168            attrs={
169                'position': egg.node.position,
170                'height_attenuated': False,
171                'radius': 0.1,
172                'color': (1, 1, 0),
173            },
174        )
175        bs.animate(light, 'intensity', {0: 0, 0.1: 1.0, 0.2: 0}, loop=False)
176        bs.timer(0.200, light.delete)
177        egg.handlemessage(bs.DieMessage())
178
179    def _update(self) -> None:
180        # Misc. periodic updating.
181        xpos = random.uniform(-7.1, 6.0)
182        ypos = random.uniform(3.5, 3.5)
183        zpos = random.uniform(-8.2, 3.7)
184
185        # Prune dead eggs from our list.
186        self._eggs = [e for e in self._eggs if e]
187
188        # Spawn more eggs if we've got space.
189        if len(self._eggs) < int(self._max_eggs):
190            # Occasionally spawn a land-mine in addition.
191            if self._pro_mode and random.random() < 0.25:
192                mine = Bomb(
193                    position=(xpos, ypos, zpos), bomb_type='land_mine'
194                ).autoretain()
195                mine.arm()
196            else:
197                self._eggs.append(Egg(position=(xpos, ypos, zpos)))
198
199    # Various high-level game events come through this method.
200    @override
201    def handlemessage(self, msg: Any) -> Any:
202        # Respawn dead players.
203        if isinstance(msg, bs.PlayerDiedMessage):
204            # Augment standard behavior.
205            super().handlemessage(msg)
206
207            # Respawn them shortly.
208            player = msg.getplayer(Player)
209            assert self.initialplayerinfos is not None
210            respawn_time = 2.0 + len(self.initialplayerinfos) * 1.0
211            player.respawn_timer = bs.Timer(
212                respawn_time, bs.Call(self.spawn_player_if_exists, player)
213            )
214            player.respawn_icon = RespawnIcon(player, respawn_time)
215
216        # Whenever our evil bunny dies, respawn him and spew some eggs.
217        elif isinstance(msg, SpazBotDiedMessage):
218            self._spawn_evil_bunny()
219            assert msg.spazbot.node
220            pos = msg.spazbot.node.position
221            for _i in range(6):
222                spread = 0.4
223                self._eggs.append(
224                    Egg(
225                        position=(
226                            pos[0] + random.uniform(-spread, spread),
227                            pos[1] + random.uniform(-spread, spread),
228                            pos[2] + random.uniform(-spread, spread),
229                        )
230                    )
231                )
232        else:
233            # Default handler.
234            return super().handlemessage(msg)
235        return None
236
237    def _update_scoreboard(self) -> None:
238        for team in self.teams:
239            self._scoreboard.set_team_value(team, team.score)
240
241    @override
242    def end_game(self) -> None:
243        results = bs.GameResults()
244        for team in self.teams:
245            results.set_team_score(team, team.score)
246        self.end(results)
247
248
249class Egg(bs.Actor):
250    """A lovely egg that can be picked up for points."""
251
252    def __init__(self, position: tuple[float, float, float] = (0.0, 1.0, 0.0)):
253        super().__init__()
254        activity = self.activity
255        assert isinstance(activity, EasterEggHuntGame)
256        shared = SharedObjects.get()
257
258        # Spawn just above the provided point.
259        self._spawn_pos = (position[0], position[1] + 1.0, position[2])
260        ctex = (activity.egg_tex_1, activity.egg_tex_2, activity.egg_tex_3)[
261            random.randrange(3)
262        ]
263        mats = [shared.object_material, activity.egg_material]
264        self.node = bs.newnode(
265            'prop',
266            delegate=self,
267            attrs={
268                'mesh': activity.egg_mesh,
269                'color_texture': ctex,
270                'body': 'capsule',
271                'reflection': 'soft',
272                'mesh_scale': 0.5,
273                'body_scale': 0.6,
274                'density': 4.0,
275                'reflection_scale': [0.15],
276                'shadow_size': 0.6,
277                'position': self._spawn_pos,
278                'materials': mats,
279            },
280        )
281
282    @override
283    def exists(self) -> bool:
284        return bool(self.node)
285
286    @override
287    def handlemessage(self, msg: Any) -> Any:
288        if isinstance(msg, bs.DieMessage):
289            if self.node:
290                self.node.delete()
291        elif isinstance(msg, bs.HitMessage):
292            if self.node:
293                assert msg.force_direction is not None
294                self.node.handlemessage(
295                    'impulse',
296                    msg.pos[0],
297                    msg.pos[1],
298                    msg.pos[2],
299                    msg.velocity[0],
300                    msg.velocity[1],
301                    msg.velocity[2],
302                    1.0 * msg.magnitude,
303                    1.0 * msg.velocity_magnitude,
304                    msg.radius,
305                    0,
306                    msg.force_direction[0],
307                    msg.force_direction[1],
308                    msg.force_direction[2],
309                )
310        else:
311            super().handlemessage(msg)