bastd.game.targetpractice

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