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