1# Released under the MIT License. See LICENSE for details.
  2#
  3"""DeathMatch game and support classes."""
  4
  5# ba_meta require api 8
  6# (see https://ballistica.net/wiki/meta-tag-system)
  7
  8from __future__ import annotations
  9
 10from typing import TYPE_CHECKING
 11
 12from bascenev1lib.actor.playerspaz import PlayerSpaz
 13from bascenev1lib.actor.scoreboard import Scoreboard
 14import bascenev1 as bs
 15
 16if TYPE_CHECKING:
 17    from typing import Any, Sequence
 18
 19
 20class Player(bs.Player['Team']):
 21    """Our player type for this game."""
 22
 23
 24class Team(bs.Team[Player]):
 25    """Our team type for this game."""
 26
 27    def __init__(self) -> None:
 28        self.score = 0
 29
 30
 31# ba_meta export bascenev1.GameActivity
 32class DeathMatchGame(bs.TeamGameActivity[Player, Team]):
 33    """A game type based on acquiring kills."""
 34
 35    name = 'Death Match'
 36    description = 'Kill a set number of enemies to win.'
 37
 38    # Print messages when players die since it matters here.
 39    announce_player_deaths = True
 40
 41    @classmethod
 42    def get_available_settings(
 43        cls, sessiontype: type[bs.Session]
 44    ) -> list[bs.Setting]:
 45        settings = [
 46            bs.IntSetting(
 47                'Kills to Win Per Player',
 48                min_value=1,
 49                default=5,
 50                increment=1,
 51            ),
 52            bs.IntChoiceSetting(
 53                'Time Limit',
 54                choices=[
 55                    ('None', 0),
 56                    ('1 Minute', 60),
 57                    ('2 Minutes', 120),
 58                    ('5 Minutes', 300),
 59                    ('10 Minutes', 600),
 60                    ('20 Minutes', 1200),
 61                ],
 62                default=0,
 63            ),
 64            bs.FloatChoiceSetting(
 65                'Respawn Times',
 66                choices=[
 67                    ('Shorter', 0.25),
 68                    ('Short', 0.5),
 69                    ('Normal', 1.0),
 70                    ('Long', 2.0),
 71                    ('Longer', 4.0),
 72                ],
 73                default=1.0,
 74            ),
 75            bs.BoolSetting('Epic Mode', default=False),
 76        ]
 77
 78        # In teams mode, a suicide gives a point to the other team, but in
 79        # free-for-all it subtracts from your own score. By default we clamp
 80        # this at zero to benefit new players, but pro players might like to
 81        # be able to go negative. (to avoid a strategy of just
 82        # suiciding until you get a good drop)
 83        if issubclass(sessiontype, bs.FreeForAllSession):
 84            settings.append(
 85                bs.BoolSetting('Allow Negative Scores', default=False)
 86            )
 87
 88        return settings
 89
 90    @classmethod
 91    def supports_session_type(cls, sessiontype: type[bs.Session]) -> bool:
 92        return issubclass(sessiontype, bs.DualTeamSession) or issubclass(
 93            sessiontype, bs.FreeForAllSession
 94        )
 95
 96    @classmethod
 97    def get_supported_maps(cls, sessiontype: type[bs.Session]) -> list[str]:
 98        assert bs.app.classic is not None
 99        return bs.app.classic.getmaps('melee')
100
101    def __init__(self, settings: dict):
102        super().__init__(settings)
103        self._scoreboard = Scoreboard()
104        self._score_to_win: int | None = None
105        self._dingsound = bs.getsound('dingSmall')
106        self._epic_mode = bool(settings['Epic Mode'])
107        self._kills_to_win_per_player = int(settings['Kills to Win Per Player'])
108        self._time_limit = float(settings['Time Limit'])
109        self._allow_negative_scores = bool(
110            settings.get('Allow Negative Scores', False)
111        )
112
113        # Base class overrides.
114        self.slow_motion = self._epic_mode
115        self.default_music = (
116            bs.MusicType.EPIC if self._epic_mode else bs.MusicType.TO_THE_DEATH
117        )
118
119    def get_instance_description(self) -> str | Sequence:
120        return 'Crush ${ARG1} of your enemies.', self._score_to_win
121
122    def get_instance_description_short(self) -> str | Sequence:
123        return 'kill ${ARG1} enemies', self._score_to_win
124
125    def on_team_join(self, team: Team) -> None:
126        if self.has_begun():
127            self._update_scoreboard()
128
129    def on_begin(self) -> None:
130        super().on_begin()
131        self.setup_standard_time_limit(self._time_limit)
132        self.setup_standard_powerup_drops()
133
134        # Base kills needed to win on the size of the largest team.
135        self._score_to_win = self._kills_to_win_per_player * max(
136            1, max((len(t.players) for t in self.teams), default=0)
137        )
138        self._update_scoreboard()
139
140    def handlemessage(self, msg: Any) -> Any:
141        if isinstance(msg, bs.PlayerDiedMessage):
142            # Augment standard behavior.
143            super().handlemessage(msg)
144
145            player = msg.getplayer(Player)
146            self.respawn_player(player)
147
148            killer = msg.getkillerplayer(Player)
149            if killer is None:
150                return None
151
152            # Handle team-kills.
153            if killer.team is player.team:
154                # In free-for-all, killing yourself loses you a point.
155                if isinstance(self.session, bs.FreeForAllSession):
156                    new_score = player.team.score - 1
157                    if not self._allow_negative_scores:
158                        new_score = max(0, new_score)
159                    player.team.score = new_score
160
161                # In teams-mode it gives a point to the other team.
162                else:
163                    self._dingsound.play()
164                    for team in self.teams:
165                        if team is not killer.team:
166                            team.score += 1
167
168            # Killing someone on another team nets a kill.
169            else:
170                killer.team.score += 1
171                self._dingsound.play()
172
173                # In FFA show scores since its hard to find on the scoreboard.
174                if isinstance(killer.actor, PlayerSpaz) and killer.actor:
175                    killer.actor.set_score_text(
176                        str(killer.team.score) + '/' + str(self._score_to_win),
177                        color=killer.team.color,
178                        flash=True,
179                    )
180
181            self._update_scoreboard()
182
183            # If someone has won, set a timer to end shortly.
184            # (allows the dust to clear and draws to occur if deaths are
185            # close enough)
186            assert self._score_to_win is not None
187            if any(team.score >= self._score_to_win for team in self.teams):
188                bs.timer(0.5, self.end_game)
189
190        else:
191            return super().handlemessage(msg)
192        return None
193
194    def _update_scoreboard(self) -> None:
195        for team in self.teams:
196            self._scoreboard.set_team_value(
197                team, team.score, self._score_to_win
198            )
199
200    def end_game(self) -> None:
201        results = bs.GameResults()
202        for team in self.teams:
203            results.set_team_score(team, team.score)
204        self.end(results=results)