1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Defines assault minigame."""
  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.playerspaz import PlayerSpaz
 15from bastd.actor.flag import Flag
 16from bastd.actor.scoreboard import Scoreboard
 17from bastd.gameutils import SharedObjects
 18
 19if TYPE_CHECKING:
 20    from typing import Any, Sequence
 21
 22
 23class Player(ba.Player['Team']):
 24    """Our player type for this game."""
 25
 26
 27class Team(ba.Team[Player]):
 28    """Our team type for this game."""
 29
 30    def __init__(self, base_pos: Sequence[float], flag: Flag) -> None:
 31        self.base_pos = base_pos
 32        self.flag = flag
 33        self.score = 0
 34
 35
 36# ba_meta export game
 37class AssaultGame(ba.TeamGameActivity[Player, Team]):
 38    """Game where you score by touching the other team's flag."""
 39
 40    name = 'Assault'
 41    description = 'Reach the enemy flag to score.'
 42    available_settings = [
 43        ba.IntSetting(
 44            'Score to Win',
 45            min_value=1,
 46            default=3,
 47        ),
 48        ba.IntChoiceSetting(
 49            'Time Limit',
 50            choices=[
 51                ('None', 0),
 52                ('1 Minute', 60),
 53                ('2 Minutes', 120),
 54                ('5 Minutes', 300),
 55                ('10 Minutes', 600),
 56                ('20 Minutes', 1200),
 57            ],
 58            default=0,
 59        ),
 60        ba.FloatChoiceSetting(
 61            'Respawn Times',
 62            choices=[
 63                ('Shorter', 0.25),
 64                ('Short', 0.5),
 65                ('Normal', 1.0),
 66                ('Long', 2.0),
 67                ('Longer', 4.0),
 68            ],
 69            default=1.0,
 70        ),
 71        ba.BoolSetting('Epic Mode', default=False),
 72    ]
 73
 74    @classmethod
 75    def supports_session_type(cls, sessiontype: type[ba.Session]) -> bool:
 76        return issubclass(sessiontype, ba.DualTeamSession)
 77
 78    @classmethod
 79    def get_supported_maps(cls, sessiontype: type[ba.Session]) -> list[str]:
 80        return ba.getmaps('team_flag')
 81
 82    def __init__(self, settings: dict):
 83        super().__init__(settings)
 84        self._scoreboard = Scoreboard()
 85        self._last_score_time = 0.0
 86        self._score_sound = ba.getsound('score')
 87        self._base_region_materials: dict[int, ba.Material] = {}
 88        self._epic_mode = bool(settings['Epic Mode'])
 89        self._score_to_win = int(settings['Score to Win'])
 90        self._time_limit = float(settings['Time Limit'])
 91
 92        # Base class overrides
 93        self.slow_motion = self._epic_mode
 94        self.default_music = (ba.MusicType.EPIC if self._epic_mode else
 95                              ba.MusicType.FORWARD_MARCH)
 96
 97    def get_instance_description(self) -> str | Sequence:
 98        if self._score_to_win == 1:
 99            return 'Touch the enemy flag.'
100        return 'Touch the enemy flag ${ARG1} times.', self._score_to_win
101
102    def get_instance_description_short(self) -> str | Sequence:
103        if self._score_to_win == 1:
104            return 'touch 1 flag'
105        return 'touch ${ARG1} flags', self._score_to_win
106
107    def create_team(self, sessionteam: ba.SessionTeam) -> Team:
108        shared = SharedObjects.get()
109        base_pos = self.map.get_flag_position(sessionteam.id)
110        ba.newnode('light',
111                   attrs={
112                       'position': base_pos,
113                       'intensity': 0.6,
114                       'height_attenuated': False,
115                       'volume_intensity_scale': 0.1,
116                       'radius': 0.1,
117                       'color': sessionteam.color
118                   })
119        Flag.project_stand(base_pos)
120        flag = Flag(touchable=False,
121                    position=base_pos,
122                    color=sessionteam.color)
123        team = Team(base_pos=base_pos, flag=flag)
124
125        mat = self._base_region_materials[sessionteam.id] = ba.Material()
126        mat.add_actions(
127            conditions=('they_have_material', shared.player_material),
128            actions=(
129                ('modify_part_collision', 'collide', True),
130                ('modify_part_collision', 'physical', False),
131                ('call', 'at_connect', ba.Call(self._handle_base_collide,
132                                               team)),
133            ),
134        )
135
136        ba.newnode(
137            'region',
138            owner=flag.node,
139            attrs={
140                'position': (base_pos[0], base_pos[1] + 0.75, base_pos[2]),
141                'scale': (0.5, 0.5, 0.5),
142                'type': 'sphere',
143                'materials': [self._base_region_materials[sessionteam.id]]
144            })
145
146        return team
147
148    def on_team_join(self, team: Team) -> None:
149        # Can't do this in create_team because the team's color/etc. have
150        # not been wired up yet at that point.
151        self._update_scoreboard()
152
153    def on_begin(self) -> None:
154        super().on_begin()
155        self.setup_standard_time_limit(self._time_limit)
156        self.setup_standard_powerup_drops()
157
158    def handlemessage(self, msg: Any) -> Any:
159        if isinstance(msg, ba.PlayerDiedMessage):
160            super().handlemessage(msg)  # Augment standard.
161            self.respawn_player(msg.getplayer(Player))
162        else:
163            super().handlemessage(msg)
164
165    def _flash_base(self, team: Team, length: float = 2.0) -> None:
166        light = ba.newnode('light',
167                           attrs={
168                               'position': team.base_pos,
169                               'height_attenuated': False,
170                               'radius': 0.3,
171                               'color': team.color
172                           })
173        ba.animate(light, 'intensity', {0: 0, 0.25: 2.0, 0.5: 0}, loop=True)
174        ba.timer(length, light.delete)
175
176    def _handle_base_collide(self, team: Team) -> None:
177        try:
178            spaz = ba.getcollision().opposingnode.getdelegate(PlayerSpaz, True)
179        except ba.NotFoundError:
180            return
181
182        if not spaz.is_alive():
183            return
184
185        try:
186            player = spaz.getplayer(Player, True)
187        except ba.NotFoundError:
188            return
189
190        # If its another team's player, they scored.
191        player_team = player.team
192        if player_team is not team:
193
194            # Prevent multiple simultaneous scores.
195            if ba.time() != self._last_score_time:
196                self._last_score_time = ba.time()
197                self.stats.player_scored(player, 50, big_message=True)
198                ba.playsound(self._score_sound)
199                self._flash_base(team)
200
201                # Move all players on the scoring team back to their start
202                # and add flashes of light so its noticeable.
203                for player in player_team.players:
204                    if player.is_alive():
205                        pos = player.node.position
206                        light = ba.newnode('light',
207                                           attrs={
208                                               'position': pos,
209                                               'color': player_team.color,
210                                               'height_attenuated': False,
211                                               'radius': 0.4
212                                           })
213                        ba.timer(0.5, light.delete)
214                        ba.animate(light, 'intensity', {
215                            0: 0,
216                            0.1: 1.0,
217                            0.5: 0
218                        })
219
220                        new_pos = (self.map.get_start_position(player_team.id))
221                        light = ba.newnode('light',
222                                           attrs={
223                                               'position': new_pos,
224                                               'color': player_team.color,
225                                               'radius': 0.4,
226                                               'height_attenuated': False
227                                           })
228                        ba.timer(0.5, light.delete)
229                        ba.animate(light, 'intensity', {
230                            0: 0,
231                            0.1: 1.0,
232                            0.5: 0
233                        })
234                        if player.actor:
235                            player.actor.handlemessage(
236                                ba.StandMessage(new_pos,
237                                                random.uniform(0, 360)))
238
239                # Have teammates celebrate.
240                for player in player_team.players:
241                    if player.actor:
242                        player.actor.handlemessage(ba.CelebrateMessage(2.0))
243
244                player_team.score += 1
245                self._update_scoreboard()
246                if player_team.score >= self._score_to_win:
247                    self.end_game()
248
249    def end_game(self) -> None:
250        results = ba.GameResults()
251        for team in self.teams:
252            results.set_team_score(team, team.score)
253        self.end(results=results)
254
255    def _update_scoreboard(self) -> None:
256        for team in self.teams:
257            self._scoreboard.set_team_value(team, team.score,
258                                            self._score_to_win)