1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Hockey game and support classes."""
  4
  5# ba_meta require api 7
  6# (see https://ballistica.net/wiki/meta-tag-system)
  7
  8from __future__ import annotations
  9
 10from typing import TYPE_CHECKING
 11
 12import ba
 13from bastd.actor.playerspaz import PlayerSpaz
 14from bastd.actor.scoreboard import Scoreboard
 15from bastd.actor.powerupbox import PowerupBoxFactory
 16from bastd.gameutils import SharedObjects
 17
 18if TYPE_CHECKING:
 19    from typing import Any, Sequence
 20
 21
 22class PuckDiedMessage:
 23    """Inform something that a puck has died."""
 24
 25    def __init__(self, puck: Puck):
 26        self.puck = puck
 27
 28
 29class Puck(ba.Actor):
 30    """A lovely giant hockey puck."""
 31
 32    def __init__(self, position: Sequence[float] = (0.0, 1.0, 0.0)):
 33        super().__init__()
 34        shared = SharedObjects.get()
 35        activity = self.getactivity()
 36
 37        # Spawn just above the provided point.
 38        self._spawn_pos = (position[0], position[1] + 1.0, position[2])
 39        self.last_players_to_touch: dict[int, Player] = {}
 40        self.scored = False
 41        assert activity is not None
 42        assert isinstance(activity, HockeyGame)
 43        pmats = [shared.object_material, activity.puck_material]
 44        self.node = ba.newnode('prop',
 45                               delegate=self,
 46                               attrs={
 47                                   'model': activity.puck_model,
 48                                   'color_texture': activity.puck_tex,
 49                                   'body': 'puck',
 50                                   'reflection': 'soft',
 51                                   'reflection_scale': [0.2],
 52                                   'shadow_size': 1.0,
 53                                   'is_area_of_interest': True,
 54                                   'position': self._spawn_pos,
 55                                   'materials': pmats
 56                               })
 57        ba.animate(self.node, 'model_scale', {0: 0, 0.2: 1.3, 0.26: 1})
 58
 59    def handlemessage(self, msg: Any) -> Any:
 60        if isinstance(msg, ba.DieMessage):
 61            assert self.node
 62            self.node.delete()
 63            activity = self._activity()
 64            if activity and not msg.immediate:
 65                activity.handlemessage(PuckDiedMessage(self))
 66
 67        # If we go out of bounds, move back to where we started.
 68        elif isinstance(msg, ba.OutOfBoundsMessage):
 69            assert self.node
 70            self.node.position = self._spawn_pos
 71
 72        elif isinstance(msg, ba.HitMessage):
 73            assert self.node
 74            assert msg.force_direction is not None
 75            self.node.handlemessage(
 76                'impulse', msg.pos[0], msg.pos[1], msg.pos[2], msg.velocity[0],
 77                msg.velocity[1], msg.velocity[2], 1.0 * msg.magnitude,
 78                1.0 * msg.velocity_magnitude, msg.radius, 0,
 79                msg.force_direction[0], msg.force_direction[1],
 80                msg.force_direction[2])
 81
 82            # If this hit came from a player, log them as the last to touch us.
 83            s_player = msg.get_source_player(Player)
 84            if s_player is not None:
 85                activity = self._activity()
 86                if activity:
 87                    if s_player in activity.players:
 88                        self.last_players_to_touch[s_player.team.id] = s_player
 89        else:
 90            super().handlemessage(msg)
 91
 92
 93class Player(ba.Player['Team']):
 94    """Our player type for this game."""
 95
 96
 97class Team(ba.Team[Player]):
 98    """Our team type for this game."""
 99
100    def __init__(self) -> None:
101        self.score = 0
102
103
104# ba_meta export game
105class HockeyGame(ba.TeamGameActivity[Player, Team]):
106    """Ice hockey game."""
107
108    name = 'Hockey'
109    description = 'Score some goals.'
110    available_settings = [
111        ba.IntSetting(
112            'Score to Win',
113            min_value=1,
114            default=1,
115            increment=1,
116        ),
117        ba.IntChoiceSetting(
118            'Time Limit',
119            choices=[
120                ('None', 0),
121                ('1 Minute', 60),
122                ('2 Minutes', 120),
123                ('5 Minutes', 300),
124                ('10 Minutes', 600),
125                ('20 Minutes', 1200),
126            ],
127            default=0,
128        ),
129        ba.FloatChoiceSetting(
130            'Respawn Times',
131            choices=[
132                ('Shorter', 0.25),
133                ('Short', 0.5),
134                ('Normal', 1.0),
135                ('Long', 2.0),
136                ('Longer', 4.0),
137            ],
138            default=1.0,
139        ),
140    ]
141    default_music = ba.MusicType.HOCKEY
142
143    @classmethod
144    def supports_session_type(cls, sessiontype: type[ba.Session]) -> bool:
145        return issubclass(sessiontype, ba.DualTeamSession)
146
147    @classmethod
148    def get_supported_maps(cls, sessiontype: type[ba.Session]) -> list[str]:
149        return ba.getmaps('hockey')
150
151    def __init__(self, settings: dict):
152        super().__init__(settings)
153        shared = SharedObjects.get()
154        self._scoreboard = Scoreboard()
155        self._cheer_sound = ba.getsound('cheer')
156        self._chant_sound = ba.getsound('crowdChant')
157        self._foghorn_sound = ba.getsound('foghorn')
158        self._swipsound = ba.getsound('swip')
159        self._whistle_sound = ba.getsound('refWhistle')
160        self.puck_model = ba.getmodel('puck')
161        self.puck_tex = ba.gettexture('puckColor')
162        self._puck_sound = ba.getsound('metalHit')
163        self.puck_material = ba.Material()
164        self.puck_material.add_actions(actions=(('modify_part_collision',
165                                                 'friction', 0.5)))
166        self.puck_material.add_actions(conditions=('they_have_material',
167                                                   shared.pickup_material),
168                                       actions=('modify_part_collision',
169                                                'collide', False))
170        self.puck_material.add_actions(
171            conditions=(
172                ('we_are_younger_than', 100),
173                'and',
174                ('they_have_material', shared.object_material),
175            ),
176            actions=('modify_node_collision', 'collide', False),
177        )
178        self.puck_material.add_actions(conditions=('they_have_material',
179                                                   shared.footing_material),
180                                       actions=('impact_sound',
181                                                self._puck_sound, 0.2, 5))
182
183        # Keep track of which player last touched the puck
184        self.puck_material.add_actions(
185            conditions=('they_have_material', shared.player_material),
186            actions=(('call', 'at_connect',
187                      self._handle_puck_player_collide), ))
188
189        # We want the puck to kill powerups; not get stopped by them
190        self.puck_material.add_actions(
191            conditions=('they_have_material',
192                        PowerupBoxFactory.get().powerup_material),
193            actions=(('modify_part_collision', 'physical', False),
194                     ('message', 'their_node', 'at_connect', ba.DieMessage())))
195        self._score_region_material = ba.Material()
196        self._score_region_material.add_actions(
197            conditions=('they_have_material', self.puck_material),
198            actions=(('modify_part_collision', 'collide',
199                      True), ('modify_part_collision', 'physical', False),
200                     ('call', 'at_connect', self._handle_score)))
201        self._puck_spawn_pos: Sequence[float] | None = None
202        self._score_regions: list[ba.NodeActor] | None = None
203        self._puck: Puck | None = None
204        self._score_to_win = int(settings['Score to Win'])
205        self._time_limit = float(settings['Time Limit'])
206
207    def get_instance_description(self) -> str | Sequence:
208        if self._score_to_win == 1:
209            return 'Score a goal.'
210        return 'Score ${ARG1} goals.', self._score_to_win
211
212    def get_instance_description_short(self) -> str | Sequence:
213        if self._score_to_win == 1:
214            return 'score a goal'
215        return 'score ${ARG1} goals', self._score_to_win
216
217    def on_begin(self) -> None:
218        super().on_begin()
219
220        self.setup_standard_time_limit(self._time_limit)
221        self.setup_standard_powerup_drops()
222        self._puck_spawn_pos = self.map.get_flag_position(None)
223        self._spawn_puck()
224
225        # Set up the two score regions.
226        defs = self.map.defs
227        self._score_regions = []
228        self._score_regions.append(
229            ba.NodeActor(
230                ba.newnode('region',
231                           attrs={
232                               'position': defs.boxes['goal1'][0:3],
233                               'scale': defs.boxes['goal1'][6:9],
234                               'type': 'box',
235                               'materials': [self._score_region_material]
236                           })))
237        self._score_regions.append(
238            ba.NodeActor(
239                ba.newnode('region',
240                           attrs={
241                               'position': defs.boxes['goal2'][0:3],
242                               'scale': defs.boxes['goal2'][6:9],
243                               'type': 'box',
244                               'materials': [self._score_region_material]
245                           })))
246        self._update_scoreboard()
247        ba.playsound(self._chant_sound)
248
249    def on_team_join(self, team: Team) -> None:
250        self._update_scoreboard()
251
252    def _handle_puck_player_collide(self) -> None:
253        collision = ba.getcollision()
254        try:
255            puck = collision.sourcenode.getdelegate(Puck, True)
256            player = collision.opposingnode.getdelegate(PlayerSpaz,
257                                                        True).getplayer(
258                                                            Player, True)
259        except ba.NotFoundError:
260            return
261
262        puck.last_players_to_touch[player.team.id] = player
263
264    def _kill_puck(self) -> None:
265        self._puck = None
266
267    def _handle_score(self) -> None:
268        """A point has been scored."""
269
270        assert self._puck is not None
271        assert self._score_regions is not None
272
273        # Our puck might stick around for a second or two
274        # we don't want it to be able to score again.
275        if self._puck.scored:
276            return
277
278        region = ba.getcollision().sourcenode
279        index = 0
280        for index, score_region in enumerate(self._score_regions):
281            if region == score_region.node:
282                break
283
284        for team in self.teams:
285            if team.id == index:
286                scoring_team = team
287                team.score += 1
288
289                # Tell all players to celebrate.
290                for player in team.players:
291                    if player.actor:
292                        player.actor.handlemessage(ba.CelebrateMessage(2.0))
293
294                # If we've got the player from the scoring team that last
295                # touched us, give them points.
296                if (scoring_team.id in self._puck.last_players_to_touch
297                        and self._puck.last_players_to_touch[scoring_team.id]):
298                    self.stats.player_scored(
299                        self._puck.last_players_to_touch[scoring_team.id],
300                        100,
301                        big_message=True)
302
303                # End game if we won.
304                if team.score >= self._score_to_win:
305                    self.end_game()
306
307        ba.playsound(self._foghorn_sound)
308        ba.playsound(self._cheer_sound)
309
310        self._puck.scored = True
311
312        # Kill the puck (it'll respawn itself shortly).
313        ba.timer(1.0, self._kill_puck)
314
315        light = ba.newnode('light',
316                           attrs={
317                               'position': ba.getcollision().position,
318                               'height_attenuated': False,
319                               'color': (1, 0, 0)
320                           })
321        ba.animate(light, 'intensity', {0: 0, 0.5: 1, 1.0: 0}, loop=True)
322        ba.timer(1.0, light.delete)
323
324        ba.cameraflash(duration=10.0)
325        self._update_scoreboard()
326
327    def end_game(self) -> None:
328        results = ba.GameResults()
329        for team in self.teams:
330            results.set_team_score(team, team.score)
331        self.end(results=results)
332
333    def _update_scoreboard(self) -> None:
334        winscore = self._score_to_win
335        for team in self.teams:
336            self._scoreboard.set_team_value(team, team.score, winscore)
337
338    def handlemessage(self, msg: Any) -> Any:
339
340        # Respawn dead players if they're still in the game.
341        if isinstance(msg, ba.PlayerDiedMessage):
342            # Augment standard behavior...
343            super().handlemessage(msg)
344            self.respawn_player(msg.getplayer(Player))
345
346        # Respawn dead pucks.
347        elif isinstance(msg, PuckDiedMessage):
348            if not self.has_ended():
349                ba.timer(3.0, self._spawn_puck)
350        else:
351            super().handlemessage(msg)
352
353    def _flash_puck_spawn(self) -> None:
354        light = ba.newnode('light',
355                           attrs={
356                               'position': self._puck_spawn_pos,
357                               'height_attenuated': False,
358                               'color': (1, 0, 0)
359                           })
360        ba.animate(light, 'intensity', {0.0: 0, 0.25: 1, 0.5: 0}, loop=True)
361        ba.timer(1.0, light.delete)
362
363    def _spawn_puck(self) -> None:
364        ba.playsound(self._swipsound)
365        ba.playsound(self._whistle_sound)
366        self._flash_puck_spawn()
367        assert self._puck_spawn_pos is not None
368        self._puck = Puck(position=self._puck_spawn_pos)