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