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