Rename & update arms_race.py to 1.7.37+ (API 9)

• Fixed a warning error getting on curse_time being less than zero.

Gamemodes/arms_race.py

@@ -0,0 +1,191 @@
+# ba_meta require api 9
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import babase
+import bascenev1 as bs
+
+if TYPE_CHECKING:
+    from typing import Any, Type, List, Union, Sequence
+
+
+class State:
+    def __init__(self, bomb=None, grab=False, punch=False, curse=False, required=False, final=False, name=''):
+        self.bomb = bomb
+        self.grab = grab
+        self.punch = punch
+        self.pickup = False
+        self.curse = curse
+        self.required = required or final
+        self.final = final
+        self.name = name
+        self.next = None
+        self.index = None
+
+    def apply(self, spaz):
+        spaz.disconnect_controls_from_player()
+        spaz.connect_controls_to_player(enable_punch=self.punch,
+                                        enable_bomb=self.bomb,
+                                        enable_pickup=self.grab)
+        if self.curse:
+            try:
+                spaz.curse_time = -1
+                spaz.curse()
+            except:
+                pass
+        if self.bomb:
+            spaz.bomb_type = self.bomb
+        spaz.set_score_text(self.name)
+
+    def get_setting(self):
+        return (self.name)
+
+
+states = [State(bomb='normal', name='Basic Bombs'),
+          State(bomb='ice', name='Frozen Bombs'),
+          State(bomb='sticky', name='Sticky Bombs'),
+          State(bomb='impact', name='Impact Bombs'),
+          State(grab=True, name='Grabbing only'),
+          State(punch=True, name='Punching only'),
+          State(curse=True, name='Cursed', final=True)]
+
+
+class Player(bs.Player['Team']):
+    """Our player type for this game."""
+
+    def __init__(self):
+        self.state = None
+
+
+class Team(bs.Team[Player]):
+    """Our team type for this game."""
+
+    def __init__(self) -> None:
+        self.score = 0
+
+
+# ba_meta export bascenev1.GameActivity
+class ArmsRaceGame(bs.TeamGameActivity[Player, Team]):
+    """A game type based on acquiring kills."""
+
+    name = 'Arms Race'
+    description = 'Upgrade your weapon by eliminating enemies.\nWin the match by being the first player\nto get a kill while cursed.'
+
+    # Print messages when players die since it matters here.
+    announce_player_deaths = True
+
+    @classmethod
+    def get_available_settings(
+            cls, sessiontype: Type[bs.Session]) -> List[babase.Setting]:
+        settings = [
+            bs.IntChoiceSetting(
+                'Time Limit',
+                choices=[
+                    ('None', 0),
+                    ('1 Minute', 60),
+                    ('2 Minutes', 120),
+                    ('5 Minutes', 300),
+                    ('10 Minutes', 600),
+                    ('20 Minutes', 1200),
+                ],
+                default=0,
+            ),
+            bs.FloatChoiceSetting(
+                'Respawn Times',
+                choices=[
+                    ('Shorter', 0.25),
+                    ('Short', 0.5),
+                    ('Normal', 1.0),
+                    ('Long', 2.0),
+                    ('Longer', 4.0),
+                ],
+                default=1.0,
+            ),
+            bs.BoolSetting('Epic Mode', default=False)]
+        for state in states:
+            if not state.required:
+                settings.append(bs.BoolSetting(state.get_setting(), default=True))
+
+        return settings
+
+    @classmethod
+    def supports_session_type(cls, sessiontype: Type[bs.Session]) -> bool:
+        return (issubclass(sessiontype, bs.DualTeamSession)
+                or issubclass(sessiontype, bs.FreeForAllSession))
+
+    @classmethod
+    def get_supported_maps(cls, sessiontype: Type[bs.Session]) -> List[str]:
+        return bs.app.classic.getmaps('melee')
+
+    def __init__(self, settings: dict):
+        super().__init__(settings)
+        self.states = [s for s in states if settings.get(s.name, True)]
+        for i, state in enumerate(self.states):
+            if i < len(self.states) and not state.final:
+                state.next = self.states[i + 1]
+            state.index = i
+        self._dingsound = bs.getsound('dingSmall')
+        self._epic_mode = bool(settings['Epic Mode'])
+        self._time_limit = float(settings['Time Limit'])
+
+        # Base class overrides.
+        self.slow_motion = self._epic_mode
+        self.default_music = (bs.MusicType.EPIC if self._epic_mode else
+                              bs.MusicType.TO_THE_DEATH)
+
+    def get_instance_description(self) -> Union[str, Sequence]:
+        return 'Upgrade your weapon by eliminating enemies.'
+
+    def get_instance_description_short(self) -> Union[str, Sequence]:
+        return 'kill ${ARG1} enemies', len(self.states)
+
+    def on_begin(self) -> None:
+        super().on_begin()
+        self.setup_standard_time_limit(self._time_limit)
+        # self.setup_standard_powerup_drops()
+
+    def on_player_join(self, player):
+        if player.state is None:
+            player.state = self.states[0]
+        self.spawn_player(player)
+
+    # overriding the default character spawning..
+    def spawn_player(self, player):
+        if player.state is None:
+            player.state = self.states[0]
+        super().spawn_player(player)
+        player.state.apply(player.actor)
+
+    def isValidKill(self, m):
+        if m.getkillerplayer(Player) is None:
+            return False
+
+        if m.getkillerplayer(Player).team is m.getplayer(Player).team:
+            return False
+
+        return True
+
+    def handlemessage(self, msg: Any) -> Any:
+
+        if isinstance(msg, bs.PlayerDiedMessage):
+            if self.isValidKill(msg):
+                self.stats.player_scored(msg.getkillerplayer(Player), 10, kill=True)
+                if not msg.getkillerplayer(Player).state.final:
+                    msg.getkillerplayer(Player).state = msg.getkillerplayer(Player).state.next
+                    msg.getkillerplayer(Player).state.apply(msg.getkillerplayer(Player).actor)
+                else:
+                    msg.getkillerplayer(Player).team.score += 1
+                    self.end_game()
+            self.respawn_player(msg.getplayer(Player))
+
+        else:
+            return super().handlemessage(msg)
+        return None
+
+    def end_game(self) -> None:
+        results = bs.GameResults()
+        for team in self.teams:
+            results.set_team_score(team, team.score)
+        self.end(results=results)