bascenev1lib.game.targetpractice

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Implements Target Practice 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.scoreboard import Scoreboard
 16from bascenev1lib.actor.onscreencountdown import OnScreenCountdown
 17from bascenev1lib.actor.bomb import Bomb
 18from bascenev1lib.actor.popuptext import PopupText
 19
 20if TYPE_CHECKING:
 21    from typing import Any, Sequence
 22
 23    from bascenev1lib.actor.bomb import Blast
 24
 25
 26class Player(bs.Player['Team']):
 27    """Our player type for this game."""
 28
 29    def __init__(self) -> None:
 30        self.streak = 0
 31
 32
 33class Team(bs.Team[Player]):
 34    """Our team type for this game."""
 35
 36    def __init__(self) -> None:
 37        self.score = 0
 38
 39
 40# ba_meta export bascenev1.GameActivity
 41class TargetPracticeGame(bs.TeamGameActivity[Player, Team]):
 42    """Game where players try to hit targets with bombs."""
 43
 44    name = 'Target Practice'
 45    description = 'Bomb as many targets as you can.'
 46    available_settings = [
 47        bs.IntSetting('Target Count', min_value=1, default=3),
 48        bs.BoolSetting('Enable Impact Bombs', default=True),
 49        bs.BoolSetting('Enable Triple Bombs', default=True),
 50    ]
 51    default_music = bs.MusicType.FORWARD_MARCH
 52
 53    @override
 54    @classmethod
 55    def get_supported_maps(cls, sessiontype: type[bs.Session]) -> list[str]:
 56        return ['Doom Shroom']
 57
 58    @override
 59    @classmethod
 60    def supports_session_type(cls, sessiontype: type[bs.Session]) -> bool:
 61        # We support any teams or versus sessions.
 62        return issubclass(sessiontype, bs.CoopSession) or issubclass(
 63            sessiontype, bs.MultiTeamSession
 64        )
 65
 66    def __init__(self, settings: dict):
 67        super().__init__(settings)
 68        self._scoreboard = Scoreboard()
 69        self._targets: list[Target] = []
 70        self._update_timer: bs.Timer | None = None
 71        self._countdown: OnScreenCountdown | None = None
 72        self._target_count = int(settings['Target Count'])
 73        self._enable_impact_bombs = bool(settings['Enable Impact Bombs'])
 74        self._enable_triple_bombs = bool(settings['Enable Triple Bombs'])
 75
 76    @override
 77    def on_team_join(self, team: Team) -> None:
 78        if self.has_begun():
 79            self.update_scoreboard()
 80
 81    @override
 82    def on_begin(self) -> None:
 83        super().on_begin()
 84        self.update_scoreboard()
 85
 86        # Number of targets is based on player count.
 87        for i in range(self._target_count):
 88            bs.timer(5.0 + i * 1.0, self._spawn_target)
 89
 90        self._update_timer = bs.Timer(1.0, self._update, repeat=True)
 91        self._countdown = OnScreenCountdown(60, endcall=self.end_game)
 92        bs.timer(4.0, self._countdown.start)
 93
 94    @override
 95    def spawn_player(self, player: Player) -> bs.Actor:
 96        spawn_center = (0, 3, -5)
 97        pos = (
 98            spawn_center[0] + random.uniform(-1.5, 1.5),
 99            spawn_center[1],
100            spawn_center[2] + random.uniform(-1.5, 1.5),
101        )
102
103        # Reset their streak.
104        player.streak = 0
105        spaz = self.spawn_player_spaz(player, position=pos)
106
107        # Give players permanent triple impact bombs and wire them up
108        # to tell us when they drop a bomb.
109        if self._enable_impact_bombs:
110            spaz.bomb_type = 'impact'
111        if self._enable_triple_bombs:
112            spaz.set_bomb_count(3)
113        spaz.add_dropped_bomb_callback(self._on_spaz_dropped_bomb)
114        return spaz
115
116    def _spawn_target(self) -> None:
117        # Generate a few random points; we'll use whichever one is farthest
118        # from our existing targets (don't want overlapping targets).
119        points = []
120
121        for _i in range(4):
122            # Calc a random point within a circle.
123            while True:
124                xpos = random.uniform(-1.0, 1.0)
125                ypos = random.uniform(-1.0, 1.0)
126                if xpos * xpos + ypos * ypos < 1.0:
127                    break
128            points.append(bs.Vec3(8.0 * xpos, 2.2, -3.5 + 5.0 * ypos))
129
130        def get_min_dist_from_target(pnt: bs.Vec3) -> float:
131            return min((t.get_dist_from_point(pnt) for t in self._targets))
132
133        # If we have existing targets, use the point with the highest
134        # min-distance-from-targets.
135        if self._targets:
136            point = max(points, key=get_min_dist_from_target)
137        else:
138            point = points[0]
139
140        self._targets.append(Target(position=point))
141
142    def _on_spaz_dropped_bomb(self, spaz: bs.Actor, bomb: bs.Actor) -> None:
143        del spaz  # Unused.
144
145        # Wire up this bomb to inform us when it blows up.
146        assert isinstance(bomb, Bomb)
147        bomb.add_explode_callback(self._on_bomb_exploded)
148
149    def _on_bomb_exploded(self, bomb: Bomb, blast: Blast) -> None:
150        assert blast.node
151        pos = blast.node.position
152
153        # Debugging: throw a locator down where we landed.
154        # bs.newnode('locator', attrs={'position':blast.node.position})
155
156        # Feed the explosion point to all our targets and get points in return.
157        # Note: we operate on a copy of self._targets since the list may change
158        # under us if we hit stuff (don't wanna get points for new targets).
159        player = bomb.get_source_player(Player)
160        if not player:
161            # It's possible the player left after throwing the bomb.
162            return
163
164        bullseye = any(
165            target.do_hit_at_position(pos, player)
166            for target in list(self._targets)
167        )
168        if bullseye:
169            player.streak += 1
170        else:
171            player.streak = 0
172
173    def _update(self) -> None:
174        """Misc. periodic updating."""
175        # Clear out targets that have died.
176        self._targets = [t for t in self._targets if t]
177
178    @override
179    def handlemessage(self, msg: Any) -> Any:
180        # When players die, respawn them.
181        if isinstance(msg, bs.PlayerDiedMessage):
182            super().handlemessage(msg)  # Do standard stuff.
183            player = msg.getplayer(Player)
184            assert player is not None
185            self.respawn_player(player)  # Kick off a respawn.
186        elif isinstance(msg, Target.TargetHitMessage):
187            # A target is telling us it was hit and will die soon..
188            # ..so make another one.
189            self._spawn_target()
190        else:
191            super().handlemessage(msg)
192
193    def update_scoreboard(self) -> None:
194        """Update the game scoreboard with current team values."""
195        for team in self.teams:
196            self._scoreboard.set_team_value(team, team.score)
197
198    @override
199    def end_game(self) -> None:
200        results = bs.GameResults()
201        for team in self.teams:
202            results.set_team_score(team, team.score)
203        self.end(results)
204
205
206class Target(bs.Actor):
207    """A target practice target."""
208
209    class TargetHitMessage:
210        """Inform an object a target was hit."""
211
212    def __init__(self, position: Sequence[float]):
213        self._r1 = 0.45
214        self._r2 = 1.1
215        self._r3 = 2.0
216        self._rfudge = 0.15
217        super().__init__()
218        self._position = bs.Vec3(position)
219        self._hit = False
220
221        # It can be handy to test with this on to make sure the projection
222        # isn't too far off from the actual object.
223        show_in_space = False
224        loc1 = bs.newnode(
225            'locator',
226            attrs={
227                'shape': 'circle',
228                'position': position,
229                'color': (0, 1, 0),
230                'opacity': 0.5,
231                'draw_beauty': show_in_space,
232                'additive': True,
233            },
234        )
235        loc2 = bs.newnode(
236            'locator',
237            attrs={
238                'shape': 'circleOutline',
239                'position': position,
240                'color': (0, 1, 0),
241                'opacity': 0.3,
242                'draw_beauty': False,
243                'additive': True,
244            },
245        )
246        loc3 = bs.newnode(
247            'locator',
248            attrs={
249                'shape': 'circleOutline',
250                'position': position,
251                'color': (0, 1, 0),
252                'opacity': 0.1,
253                'draw_beauty': False,
254                'additive': True,
255            },
256        )
257        self._nodes = [loc1, loc2, loc3]
258        bs.animate_array(loc1, 'size', 1, {0: [0.0], 0.2: [self._r1 * 2.0]})
259        bs.animate_array(loc2, 'size', 1, {0.05: [0.0], 0.25: [self._r2 * 2.0]})
260        bs.animate_array(loc3, 'size', 1, {0.1: [0.0], 0.3: [self._r3 * 2.0]})
261        bs.getsound('laserReverse').play()
262
263    @override
264    def exists(self) -> bool:
265        return bool(self._nodes)
266
267    @override
268    def handlemessage(self, msg: Any) -> Any:
269        if isinstance(msg, bs.DieMessage):
270            for node in self._nodes:
271                node.delete()
272            self._nodes = []
273        else:
274            super().handlemessage(msg)
275
276    def get_dist_from_point(self, pos: bs.Vec3) -> float:
277        """Given a point, returns distance squared from it."""
278        return (pos - self._position).length()
279
280    def do_hit_at_position(self, pos: Sequence[float], player: Player) -> bool:
281        """Handle a bomb hit at the given position."""
282        # pylint: disable=too-many-statements
283        activity = self.activity
284
285        # Ignore hits if the game is over or if we've already been hit
286        if activity.has_ended() or self._hit or not self._nodes:
287            return False
288
289        diff = bs.Vec3(pos) - self._position
290
291        # Disregard Y difference. Our target point probably isn't exactly
292        # on the ground anyway.
293        diff[1] = 0.0
294        dist = diff.length()
295
296        bullseye = False
297        if dist <= self._r3 + self._rfudge:
298            # Inform our activity that we were hit
299            self._hit = True
300            activity.handlemessage(self.TargetHitMessage())
301            keys: dict[float, Sequence[float]] = {
302                0.0: (1.0, 0.0, 0.0),
303                0.049: (1.0, 0.0, 0.0),
304                0.05: (1.0, 1.0, 1.0),
305                0.1: (0.0, 1.0, 0.0),
306            }
307            cdull = (0.3, 0.3, 0.3)
308            popupcolor: Sequence[float]
309            if dist <= self._r1 + self._rfudge:
310                bullseye = True
311                self._nodes[1].color = cdull
312                self._nodes[2].color = cdull
313                bs.animate_array(self._nodes[0], 'color', 3, keys, loop=True)
314                popupscale = 1.8
315                popupcolor = (1, 1, 0, 1)
316                streak = player.streak
317                points = 10 + min(20, streak * 2)
318                bs.getsound('bellHigh').play()
319                if streak > 0:
320                    bs.getsound(
321                        'orchestraHit4'
322                        if streak > 3
323                        else (
324                            'orchestraHit3'
325                            if streak > 2
326                            else (
327                                'orchestraHit2'
328                                if streak > 1
329                                else 'orchestraHit'
330                            )
331                        )
332                    ).play()
333            elif dist <= self._r2 + self._rfudge:
334                self._nodes[0].color = cdull
335                self._nodes[2].color = cdull
336                bs.animate_array(self._nodes[1], 'color', 3, keys, loop=True)
337                popupscale = 1.25
338                popupcolor = (1, 0.5, 0.2, 1)
339                points = 4
340                bs.getsound('bellMed').play()
341            else:
342                self._nodes[0].color = cdull
343                self._nodes[1].color = cdull
344                bs.animate_array(self._nodes[2], 'color', 3, keys, loop=True)
345                popupscale = 1.0
346                popupcolor = (0.8, 0.3, 0.3, 1)
347                points = 2
348                bs.getsound('bellLow').play()
349
350            # Award points/etc.. (technically should probably leave this up
351            # to the activity).
352            popupstr = '+' + str(points)
353
354            # If there's more than 1 player in the game, include their
355            # names and colors so they know who got the hit.
356            if len(activity.players) > 1:
357                popupcolor = bs.safecolor(player.color, target_intensity=0.75)
358                popupstr += ' ' + player.getname()
359            PopupText(
360                popupstr,
361                position=self._position,
362                color=popupcolor,
363                scale=popupscale,
364            ).autoretain()
365
366            # Give this player's team points and update the score-board.
367            player.team.score += points
368            assert isinstance(activity, TargetPracticeGame)
369            activity.update_scoreboard()
370
371            # Also give this individual player points
372            # (only applies in teams mode).
373            assert activity.stats is not None
374            activity.stats.player_scored(
375                player, points, showpoints=False, screenmessage=False
376            )
377
378            bs.animate_array(
379                self._nodes[0],
380                'size',
381                1,
382                {0.8: self._nodes[0].size, 1.0: [0.0]},
383            )
384            bs.animate_array(
385                self._nodes[1],
386                'size',
387                1,
388                {0.85: self._nodes[1].size, 1.05: [0.0]},
389            )
390            bs.animate_array(
391                self._nodes[2],
392                'size',
393                1,
394                {0.9: self._nodes[2].size, 1.1: [0.0]},
395            )
396            bs.timer(1.1, bs.Call(self.handlemessage, bs.DieMessage()))
397
398        return bullseye