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]
 44    ) -> list[ba.Setting]:
 45        settings = [
 46            ba.IntSetting(
 47                'Kills to Win Per Player',
 48                min_value=1,
 49                default=5,
 50                increment=1,
 51            ),
 52            ba.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            ba.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            ba.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, ba.FreeForAllSession):
 84            settings.append(
 85                ba.BoolSetting('Allow Negative Scores', default=False)
 86            )
 87
 88        return settings
 89
 90    @classmethod
 91    def supports_session_type(cls, sessiontype: type[ba.Session]) -> bool:
 92        return issubclass(sessiontype, ba.DualTeamSession) or issubclass(
 93            sessiontype, ba.FreeForAllSession
 94        )
 95
 96    @classmethod
 97    def get_supported_maps(cls, sessiontype: type[ba.Session]) -> list[str]:
 98        return ba.getmaps('melee')
 99
100    def __init__(self, settings: dict):
101        super().__init__(settings)
102        self._scoreboard = Scoreboard()
103        self._score_to_win: int | None = None
104        self._dingsound = ba.getsound('dingSmall')
105        self._epic_mode = bool(settings['Epic Mode'])
106        self._kills_to_win_per_player = int(settings['Kills to Win Per Player'])
107        self._time_limit = float(settings['Time Limit'])
108        self._allow_negative_scores = bool(
109            settings.get('Allow Negative Scores', False)
110        )
111
112        # Base class overrides.
113        self.slow_motion = self._epic_mode
114        self.default_music = (
115            ba.MusicType.EPIC if self._epic_mode else ba.MusicType.TO_THE_DEATH
116        )
117
118    def get_instance_description(self) -> str | Sequence:
119        return 'Crush ${ARG1} of your enemies.', self._score_to_win
120
121    def get_instance_description_short(self) -> str | Sequence:
122        return 'kill ${ARG1} enemies', self._score_to_win
123
124    def on_team_join(self, team: Team) -> None:
125        if self.has_begun():
126            self._update_scoreboard()
127
128    def on_begin(self) -> None:
129        super().on_begin()
130        self.setup_standard_time_limit(self._time_limit)
131        self.setup_standard_powerup_drops()
132
133        # Base kills needed to win on the size of the largest team.
134        self._score_to_win = self._kills_to_win_per_player * max(
135            1, max(len(t.players) for t in self.teams)
136        )
137        self._update_scoreboard()
138
139    def handlemessage(self, msg: Any) -> Any:
140
141        if isinstance(msg, ba.PlayerDiedMessage):
142
143            # Augment standard behavior.
144            super().handlemessage(msg)
145
146            player = msg.getplayer(Player)
147            self.respawn_player(player)
148
149            killer = msg.getkillerplayer(Player)
150            if killer is None:
151                return None
152
153            # Handle team-kills.
154            if killer.team is player.team:
155
156                # In free-for-all, killing yourself loses you a point.
157                if isinstance(self.session, ba.FreeForAllSession):
158                    new_score = player.team.score - 1
159                    if not self._allow_negative_scores:
160                        new_score = max(0, new_score)
161                    player.team.score = new_score
162
163                # In teams-mode it gives a point to the other team.
164                else:
165                    ba.playsound(self._dingsound)
166                    for team in self.teams:
167                        if team is not killer.team:
168                            team.score += 1
169
170            # Killing someone on another team nets a kill.
171            else:
172                killer.team.score += 1
173                ba.playsound(self._dingsound)
174
175                # In FFA show scores since its hard to find on the scoreboard.
176                if isinstance(killer.actor, PlayerSpaz) and killer.actor:
177                    killer.actor.set_score_text(
178                        str(killer.team.score) + '/' + str(self._score_to_win),
179                        color=killer.team.color,
180                        flash=True,
181                    )
182
183            self._update_scoreboard()
184
185            # If someone has won, set a timer to end shortly.
186            # (allows the dust to clear and draws to occur if deaths are
187            # close enough)
188            assert self._score_to_win is not None
189            if any(team.score >= self._score_to_win for team in self.teams):
190                ba.timer(0.5, self.end_game)
191
192        else:
193            return super().handlemessage(msg)
194        return None
195
196    def _update_scoreboard(self) -> None:
197        for team in self.teams:
198            self._scoreboard.set_team_value(
199                team, team.score, self._score_to_win
200            )
201
202    def end_game(self) -> None:
203        results = ba.GameResults()
204        for team in self.teams:
205            results.set_team_score(team, team.score)
206        self.end(results=results)