# Porting to api 8 made easier by baport.(https://github.com/bombsquad-community/baport) # snake # Released under the MIT License. See LICENSE for details. # """Snake game by SEBASTIAN2059""" # ba_meta require api 8 # (see https://ballistica.net/wiki/meta-tag-system) from __future__ import annotations from typing import TYPE_CHECKING import babase import bauiv1 as bui import bascenev1 as bs from bascenev1lib.actor.playerspaz import PlayerSpaz from bascenev1lib.actor.scoreboard import Scoreboard from bascenev1lib.actor import bomb as stdbomb if TYPE_CHECKING: from typing import Any, Type, List, Dict, Tuple, Union, Sequence, Optional class ScoreMessage: """It will help us with the scores.""" def __init__(self, player: Player): self.player = player def getplayer(self): return self.player class Player(bs.Player['Team']): """Our player type for this game.""" def __init__(self) -> None: self.mines = [] self.actived = None class Team(bs.Team[Player]): """Our team type for this game.""" def __init__(self) -> None: self.score = 0 lang = bs.app.lang.language if lang == 'Spanish': description = 'Sobrevive a un número determinado de minas para ganar.' join_description = 'Corre y no te dejes matar.' view_description = 'sobrevive ${ARG1} minas' else: description = 'Survive a set number of mines to win.' join_description = "Run and don't get killed." view_description = 'survive ${ARG1} mines' class Custom_Mine(stdbomb.Bomb): """Custom a mine :)""" def __init__(self, position, source_player): stdbomb.Bomb.__init__(self, position=position, bomb_type='land_mine', source_player=source_player) def handlemessage(self, msg: Any) -> Any: if isinstance(msg, bs.HitMessage): return else: super().handlemessage(msg) # ba_meta export bascenev1.GameActivity class SnakeGame(bs.TeamGameActivity[Player, Team]): """A game type based on acquiring kills.""" name = 'Snake' description = description # 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.IntSetting( 'Score to Win', min_value=40, default=80, increment=5, ), 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), ] 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._scoreboard = Scoreboard() self._score_to_win: Optional[int] = None self._dingsound = bs.getsound('dingSmall') self._beep_1_sound = bs.getsound('raceBeep1') self._beep_2_sound = bs.getsound('raceBeep2') self._epic_mode = bool(settings['Epic Mode']) self._kills_to_win_per_player = int( settings['Score to Win']) self._time_limit = float(settings['Time Limit']) self._started = False # 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 join_description def get_instance_description_short(self) -> Union[str, Sequence]: return view_description, self._score_to_win def on_team_join(self, team: Team) -> None: if self.has_begun(): self._update_scoreboard() def on_begin(self) -> None: super().on_begin() self.setup_standard_time_limit(self._time_limit) # self.setup_standard_powerup_drops() # Base kills needed to win on the size of the largest team. self._score_to_win = (self._kills_to_win_per_player * max(1, max(len(t.players) for t in self.teams))) self._update_scoreboard() if self.slow_motion: t_scale = 0.4 light_y = 50 else: t_scale = 1.0 light_y = 150 lstart = 7.1 * t_scale inc = 1.25 * t_scale bs.timer(lstart, self._do_light_1) bs.timer(lstart + inc, self._do_light_2) bs.timer(lstart + 2 * inc, self._do_light_3) bs.timer(lstart + 3 * inc, self._start_race) self._start_lights = [] for i in range(4): lnub = bs.newnode('image', attrs={ 'texture': bs.gettexture('nub'), 'opacity': 1.0, 'absolute_scale': True, 'position': (-75 + i * 50, light_y), 'scale': (50, 50), 'attach': 'center' }) bs.animate( lnub, 'opacity', { 4.0 * t_scale: 0, 5.0 * t_scale: 1.0, 12.0 * t_scale: 1.0, 12.5 * t_scale: 0.0 }) bs.timer(13.0 * t_scale, lnub.delete) self._start_lights.append(lnub) self._start_lights[0].color = (0.2, 0, 0) self._start_lights[1].color = (0.2, 0, 0) self._start_lights[2].color = (0.2, 0.05, 0) self._start_lights[3].color = (0.0, 0.3, 0) def _do_light_1(self) -> None: assert self._start_lights is not None self._start_lights[0].color = (1.0, 0, 0) self._beep_1_sound.play() def _do_light_2(self) -> None: assert self._start_lights is not None self._start_lights[1].color = (1.0, 0, 0) self._beep_1_sound.play() def _do_light_3(self) -> None: assert self._start_lights is not None self._start_lights[2].color = (1.0, 0.3, 0) self._beep_1_sound.play() def _start_race(self) -> None: assert self._start_lights is not None self._start_lights[3].color = (0.0, 1.0, 0) self._beep_2_sound.play() self._started = True for player in self.players: self.generate_mines(player) # overriding the default character spawning.. def spawn_player(self, player: Player) -> bs.Actor: spaz = self.spawn_player_spaz(player) # Let's reconnect this player's controls to this # spaz but *without* the ability to attack or pick stuff up. spaz.connect_controls_to_player(enable_punch=False, enable_bomb=False, enable_pickup=False) # Also lets have them make some noise when they die. spaz.play_big_death_sound = True if self._started: self.generate_mines(player) return spaz def generate_mines(self, player: Player): try: player.actived = bs.Timer(0.5, babase.Call(self.spawn_mine, player), repeat=True) except Exception as e: print('Exception -> ' + str(e)) def spawn_mine(self, player: Player): if player.team.score >= self._score_to_win: return pos = player.actor.node.position # mine = stdbomb.Bomb(position=(pos[0], pos[1] + 2.0, pos[2]), # velocity=(0, 0, 0), # bomb_type='land_mine', # #blast_radius=, # source_player=player.actor.source_player, # owner=player.actor.node).autoretain() mine = Custom_Mine(position=(pos[0], pos[1] + 2.0, pos[2]), source_player=player.actor.source_player) def arm(): mine.arm() bs.timer(0.5, arm) player.mines.append(mine) if len(player.mines) > 15: for m in player.mines: try: m.node.delete() except Exception: pass player.mines.remove(m) break self.handlemessage(ScoreMessage(player)) def handlemessage(self, msg: Any) -> Any: if isinstance(msg, bs.PlayerDiedMessage): # Augment standard behavior. super().handlemessage(msg) player = msg.getplayer(Player) self.respawn_player(player) player.actived = None elif isinstance(msg, ScoreMessage): player = msg.getplayer() player.team.score += 1 self._update_scoreboard() assert self._score_to_win is not None if any(team.score >= self._score_to_win for team in self.teams): self.end_game() # bs.timer(0.5, self.end_game) else: return super().handlemessage(msg) return None def _update_scoreboard(self) -> None: for team in self.teams: self._scoreboard.set_team_value(team, team.score, self._score_to_win) def end_game(self) -> None: results = bs.GameResults() for team in self.teams: results.set_team_score(team, team.score) self.end(results=results)