From 2ac90c867700e5b6fb1240f14f26c66461c23695 Mon Sep 17 00:00:00 2001 From: Loup-Garou911XD Date: Mon, 15 May 2023 10:58:00 +0000 Subject: [PATCH] [ci] auto-format --- plugins/minigames/arms_race.py | 26 +- plugins/minigames/collector.py | 1049 +++++++++++++------------ plugins/minigames/dodge_the_ball.py | 709 ++++++++--------- plugins/minigames/invisible_one.py | 7 +- plugins/minigames/last_punch_stand.py | 401 +++++----- plugins/minigames/quake.py | 25 +- plugins/minigames/sleep_race.py | 52 +- plugins/minigames/snake.py | 93 ++- plugins/minigames/ufo_fight.py | 51 +- plugins/minigames/yeeting_party.py | 26 +- 10 files changed, 1225 insertions(+), 1214 deletions(-) diff --git a/plugins/minigames/arms_race.py b/plugins/minigames/arms_race.py index 13f32b7..728f7c0 100644 --- a/plugins/minigames/arms_race.py +++ b/plugins/minigames/arms_race.py @@ -1,10 +1,9 @@ -#Ported by: Freaku / @[Just] Freak#4999 +# Ported by: Freaku / @[Just] Freak#4999 -#Join BCS: +# Join BCS: # https://discord.gg/ucyaesh - # ba_meta require api 7 from __future__ import annotations @@ -18,7 +17,6 @@ if TYPE_CHECKING: from typing import Any, Type, List, Dict, Tuple, Union, Sequence, Optional - class State: def __init__(self, bomb=None, grab=False, punch=False, curse=False, required=False, final=False, name=''): self.bomb = bomb @@ -35,8 +33,8 @@ class State: 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) + enable_bomb=self.bomb, + enable_pickup=self.grab) if self.curse: spaz.curse_time = -1 spaz.curse() @@ -48,16 +46,18 @@ class State: 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) ] +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(ba.Player['Team']): """Our player type for this game.""" + def __init__(self): self.state = None diff --git a/plugins/minigames/collector.py b/plugins/minigames/collector.py index 1a22bda..0f9bbc3 100644 --- a/plugins/minigames/collector.py +++ b/plugins/minigames/collector.py @@ -40,603 +40,604 @@ from bastd.actor.scoreboard import Scoreboard from bastd.gameutils import SharedObjects if TYPE_CHECKING: - from typing import Any, Sequence + from typing import Any, Sequence lang = ba.app.lang.language if lang == 'Spanish': - name = 'Coleccionista' - description = ('Elimina a tus oponentes para robar sus cápsulas.\n' - '¡Recolecta y anota en el punto de depósito!') - description_ingame = 'Obtén ${ARG1} cápsulas de tus enemigos.' - description_short = 'colecciona ${ARG1} cápsulas' - tips = [( - '¡Si tu oponente cae fuera del mapa, sus cápsulas desapareceran!\n' - 'No intestes matar a tus enemigos arrojándolos al vacio.'), - 'No te apresures. ¡Puedes perder tus cápsulas rápidamente!', - ('¡No dejes que el jugador con más cápsulas anote!\n' - '¡Intenta atraparlo si puedes!'), - ('¡Las Capsulas de la Suerte te dan 4 cápsulas en lugar de 2' - 'y tienen un 8% de probabilidad de aparecer después de matar'), - ('¡No te quedes en un solo lugar! Muevete más rapido que tu enemigo, ' - '¡con suerte conseguirás algunas cápsulas!'), - ] - capsules_to_win = 'Cápsulas para Ganar' - capsules_death = 'Cápsulas al Morir' - lucky_capsules = 'Cápsulas de la Suerte' - bonus = '¡BONUS!' - full_capacity = '¡Capacidad Completa!' + name = 'Coleccionista' + description = ('Elimina a tus oponentes para robar sus cápsulas.\n' + '¡Recolecta y anota en el punto de depósito!') + description_ingame = 'Obtén ${ARG1} cápsulas de tus enemigos.' + description_short = 'colecciona ${ARG1} cápsulas' + tips = [( + '¡Si tu oponente cae fuera del mapa, sus cápsulas desapareceran!\n' + 'No intestes matar a tus enemigos arrojándolos al vacio.'), + 'No te apresures. ¡Puedes perder tus cápsulas rápidamente!', + ('¡No dejes que el jugador con más cápsulas anote!\n' + '¡Intenta atraparlo si puedes!'), + ('¡Las Capsulas de la Suerte te dan 4 cápsulas en lugar de 2' + 'y tienen un 8% de probabilidad de aparecer después de matar'), + ('¡No te quedes en un solo lugar! Muevete más rapido que tu enemigo, ' + '¡con suerte conseguirás algunas cápsulas!'), + ] + capsules_to_win = 'Cápsulas para Ganar' + capsules_death = 'Cápsulas al Morir' + lucky_capsules = 'Cápsulas de la Suerte' + bonus = '¡BONUS!' + full_capacity = '¡Capacidad Completa!' else: - name = 'Collector' - description = ('Kill your opponents to steal their Capsules.\n' - 'Collect them and score at the Deposit point!') - description_ingame = 'Score ${ARG1} capsules from your enemies.' - description_short = 'collect ${ARG1} capsules' - tips = [( - 'Making you opponent fall down the pit makes his Capsules wasted!\n' - 'Try not to kill enemies by throwing them off the cliff.'), - 'Don\'t be too reckless. You can lose your loot quite quickly!', - ('Don\'t let the leading player score his Capsules ' - 'at the Deposit Point!\nTry to catch him if you can!'), - ('Lucky Capsules give 4 to your inventory and they have 8% chance ' - 'of spawning after kill!'), - ('Don\'t camp in one place! Make your move first, ' - 'so hopefully you get some dough!'), - ] - capsules_to_win = 'Capsules to Win' - capsules_death = 'Capsules on Death' - lucky_capsules = 'Allow Lucky Capsules' - bonus = 'BONUS!' - full_capacity = 'Full Capacity!' + name = 'Collector' + description = ('Kill your opponents to steal their Capsules.\n' + 'Collect them and score at the Deposit point!') + description_ingame = 'Score ${ARG1} capsules from your enemies.' + description_short = 'collect ${ARG1} capsules' + tips = [( + 'Making you opponent fall down the pit makes his Capsules wasted!\n' + 'Try not to kill enemies by throwing them off the cliff.'), + 'Don\'t be too reckless. You can lose your loot quite quickly!', + ('Don\'t let the leading player score his Capsules ' + 'at the Deposit Point!\nTry to catch him if you can!'), + ('Lucky Capsules give 4 to your inventory and they have 8% chance ' + 'of spawning after kill!'), + ('Don\'t camp in one place! Make your move first, ' + 'so hopefully you get some dough!'), + ] + capsules_to_win = 'Capsules to Win' + capsules_death = 'Capsules on Death' + lucky_capsules = 'Allow Lucky Capsules' + bonus = 'BONUS!' + full_capacity = 'Full Capacity!' class FlagState(Enum): - """States our single flag can be in.""" + """States our single flag can be in.""" - NEW = 0 - UNCONTESTED = 1 - CONTESTED = 2 - HELD = 3 + NEW = 0 + UNCONTESTED = 1 + CONTESTED = 2 + HELD = 3 class Player(ba.Player['Team']): - """Our player type for this game.""" + """Our player type for this game.""" - def __init__(self) -> None: - self.time_at_flag = 0 - self.capsules = 0 - self.light = None + def __init__(self) -> None: + self.time_at_flag = 0 + self.capsules = 0 + self.light = None class Team(ba.Team[Player]): - """Our team type for this game.""" + """Our team type for this game.""" - def __init__(self) -> None: - self.score = 0 + def __init__(self) -> None: + self.score = 0 # ba_meta export game class CollectorGame(ba.TeamGameActivity[Player, Team]): - name = name - description = description - tips = tips + name = name + description = description + tips = tips - # Print messages when players die since it matters here. - announce_player_deaths = True + # Print messages when players die since it matters here. + announce_player_deaths = True - @classmethod - def get_available_settings( - cls, sessiontype: type[ba.Session] - ) -> list[ba.Setting]: - settings = [ - ba.IntSetting( - capsules_to_win, - min_value=1, - default=10, - increment=1, - ), - ba.IntSetting( - capsules_death, - min_value=1, - max_value=10, - default=2, - increment=1, - ), - ba.IntChoiceSetting( - 'Time Limit', - choices=[ - ('None', 0), - ('1 Minute', 60), - ('2 Minutes', 120), - ('5 Minutes', 300), - ('10 Minutes', 600), - ('20 Minutes', 1200), - ], - default=0, - ), - ba.FloatChoiceSetting( - 'Respawn Times', - choices=[ - ('Shorter', 0.25), - ('Short', 0.5), - ('Normal', 1.0), - ('Long', 2.0), - ('Longer', 4.0), - ], - default=1.0, - ), - ba.BoolSetting(lucky_capsules, default=True), - ba.BoolSetting('Epic Mode', default=False), - ] - return settings + @classmethod + def get_available_settings( + cls, sessiontype: type[ba.Session] + ) -> list[ba.Setting]: + settings = [ + ba.IntSetting( + capsules_to_win, + min_value=1, + default=10, + increment=1, + ), + ba.IntSetting( + capsules_death, + min_value=1, + max_value=10, + default=2, + increment=1, + ), + ba.IntChoiceSetting( + 'Time Limit', + choices=[ + ('None', 0), + ('1 Minute', 60), + ('2 Minutes', 120), + ('5 Minutes', 300), + ('10 Minutes', 600), + ('20 Minutes', 1200), + ], + default=0, + ), + ba.FloatChoiceSetting( + 'Respawn Times', + choices=[ + ('Shorter', 0.25), + ('Short', 0.5), + ('Normal', 1.0), + ('Long', 2.0), + ('Longer', 4.0), + ], + default=1.0, + ), + ba.BoolSetting(lucky_capsules, default=True), + ba.BoolSetting('Epic Mode', default=False), + ] + return settings - @classmethod - def supports_session_type(cls, sessiontype: type[ba.Session]) -> bool: - return issubclass(sessiontype, ba.DualTeamSession) or issubclass( - sessiontype, ba.FreeForAllSession - ) + @classmethod + def supports_session_type(cls, sessiontype: type[ba.Session]) -> bool: + return issubclass(sessiontype, ba.DualTeamSession) or issubclass( + sessiontype, ba.FreeForAllSession + ) - @classmethod - def get_supported_maps(cls, sessiontype: type[ba.Session]) -> list[str]: - return ba.getmaps('keep_away') + @classmethod + def get_supported_maps(cls, sessiontype: type[ba.Session]) -> list[str]: + return ba.getmaps('keep_away') - def __init__(self, settings: dict): - super().__init__(settings) - shared = SharedObjects.get() - self._scoreboard = Scoreboard() - self._score_to_win: int | None = None - self._swipsound = ba.getsound('swip') - self._lucky_sound = ba.getsound('ding') + def __init__(self, settings: dict): + super().__init__(settings) + shared = SharedObjects.get() + self._scoreboard = Scoreboard() + self._score_to_win: int | None = None + self._swipsound = ba.getsound('swip') + self._lucky_sound = ba.getsound('ding') - self._flag_pos: Sequence[float] | None = None - self._flag_state: FlagState | None = None - self._flag: Flag | None = None - self._flag_light: ba.Node | None = None - self._scoring_team: weakref.ref[Team] | None = None - self._time_limit = float(settings['Time Limit']) - self._epic_mode = bool(settings['Epic Mode']) + self._flag_pos: Sequence[float] | None = None + self._flag_state: FlagState | None = None + self._flag: Flag | None = None + self._flag_light: ba.Node | None = None + self._scoring_team: weakref.ref[Team] | None = None + self._time_limit = float(settings['Time Limit']) + self._epic_mode = bool(settings['Epic Mode']) - self._capsules_to_win = int(settings[capsules_to_win]) - self._capsules_death = int(settings[capsules_death]) - self._lucky_capsules = bool(settings[lucky_capsules]) - self._capsules: list[Any] = [] + self._capsules_to_win = int(settings[capsules_to_win]) + self._capsules_death = int(settings[capsules_death]) + self._lucky_capsules = bool(settings[lucky_capsules]) + self._capsules: list[Any] = [] - self._capsule_model = ba.getmodel('bomb') - self._capsule_tex = ba.gettexture('bombColor') - self._capsule_lucky_tex = ba.gettexture('bombStickyColor') - self._collect_sound = ba.getsound('powerup01') - self._lucky_collect_sound = ba.getsound('cashRegister2') + self._capsule_model = ba.getmodel('bomb') + self._capsule_tex = ba.gettexture('bombColor') + self._capsule_lucky_tex = ba.gettexture('bombStickyColor') + self._collect_sound = ba.getsound('powerup01') + self._lucky_collect_sound = ba.getsound('cashRegister2') - self._capsule_material = ba.Material() - self._capsule_material.add_actions( - conditions=('they_have_material', shared.player_material), - actions=('call', 'at_connect', self._on_capsule_player_collide), - ) + self._capsule_material = ba.Material() + self._capsule_material.add_actions( + conditions=('they_have_material', shared.player_material), + actions=('call', 'at_connect', self._on_capsule_player_collide), + ) - self._flag_region_material = ba.Material() - self._flag_region_material.add_actions( - conditions=('they_have_material', shared.player_material), - actions=( - ('modify_part_collision', 'collide', True), - ('modify_part_collision', 'physical', False), - ( - 'call', - 'at_connect', - ba.Call(self._handle_player_flag_region_collide, True), - ), - ( - 'call', - 'at_disconnect', - ba.Call(self._handle_player_flag_region_collide, False), - ), - ), - ) + self._flag_region_material = ba.Material() + self._flag_region_material.add_actions( + conditions=('they_have_material', shared.player_material), + actions=( + ('modify_part_collision', 'collide', True), + ('modify_part_collision', 'physical', False), + ( + 'call', + 'at_connect', + ba.Call(self._handle_player_flag_region_collide, True), + ), + ( + 'call', + 'at_disconnect', + ba.Call(self._handle_player_flag_region_collide, False), + ), + ), + ) - # Base class overrides. - self.slow_motion = self._epic_mode - self.default_music = ( - ba.MusicType.EPIC if self._epic_mode else ba.MusicType.SCARY - ) + # Base class overrides. + self.slow_motion = self._epic_mode + self.default_music = ( + ba.MusicType.EPIC if self._epic_mode else ba.MusicType.SCARY + ) - def get_instance_description(self) -> str | Sequence: - return description_ingame, self._score_to_win + def get_instance_description(self) -> str | Sequence: + return description_ingame, self._score_to_win - def get_instance_description_short(self) -> str | Sequence: - return description_short, self._score_to_win + def get_instance_description_short(self) -> str | Sequence: + return description_short, self._score_to_win - def create_team(self, sessionteam: ba.SessionTeam) -> Team: - return Team() + def create_team(self, sessionteam: ba.SessionTeam) -> Team: + return Team() - def on_team_join(self, team: Team) -> None: - self._update_scoreboard() + def on_team_join(self, team: Team) -> None: + self._update_scoreboard() - def on_begin(self) -> None: - super().on_begin() - shared = SharedObjects.get() - self.setup_standard_time_limit(self._time_limit) - self.setup_standard_powerup_drops() + def on_begin(self) -> None: + super().on_begin() + shared = SharedObjects.get() + 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._capsules_to_win * max( - 1, max(len(t.players) for t in self.teams) - ) - self._update_scoreboard() + # Base kills needed to win on the size of the largest team. + self._score_to_win = self._capsules_to_win * max( + 1, max(len(t.players) for t in self.teams) + ) + self._update_scoreboard() - if isinstance(self.session, ba.FreeForAllSession): - self._flag_pos = self.map.get_flag_position(random.randint(0, 1)) - else: - self._flag_pos = self.map.get_flag_position(None) + if isinstance(self.session, ba.FreeForAllSession): + self._flag_pos = self.map.get_flag_position(random.randint(0, 1)) + else: + self._flag_pos = self.map.get_flag_position(None) - ba.timer(1.0, self._tick, repeat=True) - self._flag_state = FlagState.NEW - Flag.project_stand(self._flag_pos) - self._flag = Flag( - position=self._flag_pos, touchable=False, color=(1, 1, 1) - ) - self._flag_light = ba.newnode( - 'light', - attrs={ - 'position': self._flag_pos, - 'intensity': 0.2, - 'height_attenuated': False, - 'radius': 0.4, - 'color': (0.2, 0.2, 0.2), - }, - ) - # Flag region. - flagmats = [self._flag_region_material, shared.region_material] - ba.newnode( - 'region', - attrs={ - 'position': self._flag_pos, - 'scale': (1.8, 1.8, 1.8), - 'type': 'sphere', - 'materials': flagmats, - }, - ) - self._update_flag_state() + ba.timer(1.0, self._tick, repeat=True) + self._flag_state = FlagState.NEW + Flag.project_stand(self._flag_pos) + self._flag = Flag( + position=self._flag_pos, touchable=False, color=(1, 1, 1) + ) + self._flag_light = ba.newnode( + 'light', + attrs={ + 'position': self._flag_pos, + 'intensity': 0.2, + 'height_attenuated': False, + 'radius': 0.4, + 'color': (0.2, 0.2, 0.2), + }, + ) + # Flag region. + flagmats = [self._flag_region_material, shared.region_material] + ba.newnode( + 'region', + attrs={ + 'position': self._flag_pos, + 'scale': (1.8, 1.8, 1.8), + 'type': 'sphere', + 'materials': flagmats, + }, + ) + self._update_flag_state() - def _tick(self) -> None: - self._update_flag_state() + def _tick(self) -> None: + self._update_flag_state() - if self._scoring_team is None: - scoring_team = None - else: - scoring_team = self._scoring_team() + if self._scoring_team is None: + scoring_team = None + else: + scoring_team = self._scoring_team() - if not scoring_team: - return + if not scoring_team: + return - if isinstance(self.session, ba.FreeForAllSession): - players = self.players - else: - players = scoring_team.players + if isinstance(self.session, ba.FreeForAllSession): + players = self.players + else: + players = scoring_team.players - for player in players: - if player.time_at_flag > 0: - self.stats.player_scored( - player, 3, screenmessage=False, display=False - ) - if player.capsules > 0: - if self._flag_state != FlagState.HELD: - return - if scoring_team.score >= self._score_to_win: - return + for player in players: + if player.time_at_flag > 0: + self.stats.player_scored( + player, 3, screenmessage=False, display=False + ) + if player.capsules > 0: + if self._flag_state != FlagState.HELD: + return + if scoring_team.score >= self._score_to_win: + return - player.capsules -= 1 - scoring_team.score += 1 - self._handle_capsule_storage(( - self._flag_pos[0], - self._flag_pos[1]+1, - self._flag_pos[2] - ), player) - ba.playsound( - self._collect_sound, - 0.8, - position=self._flag_pos) + player.capsules -= 1 + scoring_team.score += 1 + self._handle_capsule_storage(( + self._flag_pos[0], + self._flag_pos[1]+1, + self._flag_pos[2] + ), player) + ba.playsound( + self._collect_sound, + 0.8, + position=self._flag_pos) - self._update_scoreboard() - if player.capsules > 0: - assert self._flag is not None - self._flag.set_score_text( - str(self._score_to_win - scoring_team.score)) + self._update_scoreboard() + if player.capsules > 0: + assert self._flag is not None + self._flag.set_score_text( + str(self._score_to_win - scoring_team.score)) - # winner - if scoring_team.score >= self._score_to_win: - self.end_game() + # winner + if scoring_team.score >= self._score_to_win: + self.end_game() - def end_game(self) -> None: - results = ba.GameResults() - for team in self.teams: - results.set_team_score(team, team.score) - self.end(results=results, announce_delay=0) + def end_game(self) -> None: + results = ba.GameResults() + for team in self.teams: + results.set_team_score(team, team.score) + self.end(results=results, announce_delay=0) - def _update_flag_state(self) -> None: - holding_teams = set( - player.team for player in self.players if player.time_at_flag - ) - prev_state = self._flag_state - assert self._flag_light - assert self._flag is not None - assert self._flag.node - if len(holding_teams) > 1: - self._flag_state = FlagState.CONTESTED - self._scoring_team = None - self._flag_light.color = (0.6, 0.6, 0.1) - self._flag.node.color = (1.0, 1.0, 0.4) - elif len(holding_teams) == 1: - holding_team = list(holding_teams)[0] - self._flag_state = FlagState.HELD - self._scoring_team = weakref.ref(holding_team) - self._flag_light.color = ba.normalized_color(holding_team.color) - self._flag.node.color = holding_team.color - else: - self._flag_state = FlagState.UNCONTESTED - self._scoring_team = None - self._flag_light.color = (0.2, 0.2, 0.2) - self._flag.node.color = (1, 1, 1) - if self._flag_state != prev_state: - ba.playsound(self._swipsound) + def _update_flag_state(self) -> None: + holding_teams = set( + player.team for player in self.players if player.time_at_flag + ) + prev_state = self._flag_state + assert self._flag_light + assert self._flag is not None + assert self._flag.node + if len(holding_teams) > 1: + self._flag_state = FlagState.CONTESTED + self._scoring_team = None + self._flag_light.color = (0.6, 0.6, 0.1) + self._flag.node.color = (1.0, 1.0, 0.4) + elif len(holding_teams) == 1: + holding_team = list(holding_teams)[0] + self._flag_state = FlagState.HELD + self._scoring_team = weakref.ref(holding_team) + self._flag_light.color = ba.normalized_color(holding_team.color) + self._flag.node.color = holding_team.color + else: + self._flag_state = FlagState.UNCONTESTED + self._scoring_team = None + self._flag_light.color = (0.2, 0.2, 0.2) + self._flag.node.color = (1, 1, 1) + if self._flag_state != prev_state: + ba.playsound(self._swipsound) - def _handle_player_flag_region_collide(self, colliding: bool) -> None: - try: - spaz = ba.getcollision().opposingnode.getdelegate(PlayerSpaz, True) - except ba.NotFoundError: - return + def _handle_player_flag_region_collide(self, colliding: bool) -> None: + try: + spaz = ba.getcollision().opposingnode.getdelegate(PlayerSpaz, True) + except ba.NotFoundError: + return - if not spaz.is_alive(): - return + if not spaz.is_alive(): + return - player = spaz.getplayer(Player, True) + player = spaz.getplayer(Player, True) - # Different parts of us can collide so a single value isn't enough - # also don't count it if we're dead (flying heads shouldn't be able to - # win the game :-) - if colliding and player.is_alive(): - player.time_at_flag += 1 - else: - player.time_at_flag = max(0, player.time_at_flag - 1) + # Different parts of us can collide so a single value isn't enough + # also don't count it if we're dead (flying heads shouldn't be able to + # win the game :-) + if colliding and player.is_alive(): + player.time_at_flag += 1 + else: + player.time_at_flag = max(0, player.time_at_flag - 1) - self._update_flag_state() + self._update_flag_state() - def _update_scoreboard(self) -> None: - for team in self.teams: - self._scoreboard.set_team_value( - team, team.score, self._score_to_win - ) + def _update_scoreboard(self) -> None: + for team in self.teams: + self._scoreboard.set_team_value( + team, team.score, self._score_to_win + ) - def _drop_capsule(self, player: Player) -> None: - pt = player.node.position + def _drop_capsule(self, player: Player) -> None: + pt = player.node.position - # Throw out capsules that the victim has + 2 more to keep the game running - for i in range(player.capsules + self._capsules_death): - # How far from each other these capsules should spawn - w = 0.6 - # How much these capsules should fly after spawning - s = 0.005 - (player.capsules * 0.01) - self._capsules.append( - Capsule( - position=(pt[0] + random.uniform(-w, w), - pt[1] + 0.75 + random.uniform(-w, w), - pt[2]), - velocity=(random.uniform(-s, s), - random.uniform(-s, s), - random.uniform(-s, s)), - lucky=False)) - if random.randint(1, 12) == 1 and self._lucky_capsules: - # How far from each other these capsules should spawn - w = 0.6 - # How much these capsules should fly after spawning - s = 0.005 - self._capsules.append( - Capsule( - position=(pt[0] + random.uniform(-w, w), - pt[1] + 0.75 + random.uniform(-w, w), - pt[2]), - velocity=(random.uniform(-s, s), - random.uniform(-s, s), - random.uniform(-s, s)), - lucky=True)) + # Throw out capsules that the victim has + 2 more to keep the game running + for i in range(player.capsules + self._capsules_death): + # How far from each other these capsules should spawn + w = 0.6 + # How much these capsules should fly after spawning + s = 0.005 - (player.capsules * 0.01) + self._capsules.append( + Capsule( + position=(pt[0] + random.uniform(-w, w), + pt[1] + 0.75 + random.uniform(-w, w), + pt[2]), + velocity=(random.uniform(-s, s), + random.uniform(-s, s), + random.uniform(-s, s)), + lucky=False)) + if random.randint(1, 12) == 1 and self._lucky_capsules: + # How far from each other these capsules should spawn + w = 0.6 + # How much these capsules should fly after spawning + s = 0.005 + self._capsules.append( + Capsule( + position=(pt[0] + random.uniform(-w, w), + pt[1] + 0.75 + random.uniform(-w, w), + pt[2]), + velocity=(random.uniform(-s, s), + random.uniform(-s, s), + random.uniform(-s, s)), + lucky=True)) - def _on_capsule_player_collide(self) -> None: - if self.has_ended(): - return - collision = ba.getcollision() + def _on_capsule_player_collide(self) -> None: + if self.has_ended(): + return + collision = ba.getcollision() - # Be defensive here; we could be hitting the corpse of a player - # who just left/etc. - try: - capsule = collision.sourcenode.getdelegate(Capsule, True) - player = collision.opposingnode.getdelegate( - PlayerSpaz, True - ).getplayer(Player, True) - except ba.NotFoundError: - return + # Be defensive here; we could be hitting the corpse of a player + # who just left/etc. + try: + capsule = collision.sourcenode.getdelegate(Capsule, True) + player = collision.opposingnode.getdelegate( + PlayerSpaz, True + ).getplayer(Player, True) + except ba.NotFoundError: + return - if not player.is_alive(): - return + if not player.is_alive(): + return - if capsule.node.color_texture == self._capsule_lucky_tex: - player.capsules += 4 - PopupText( - bonus, - color=(1, 1, 0), - scale=1.5, - position=capsule.node.position - ).autoretain() - ba.playsound( - self._lucky_collect_sound, - 1.0, - position=capsule.node.position) - ba.emitfx( - position=capsule.node.position, - velocity=(0, 0, 0), - count=int(6.4+random.random()*24), - scale=1.2, - spread=2.0, - chunk_type='spark'); - ba.emitfx( - position=capsule.node.position, - velocity=(0, 0, 0), - count=int(4.0+random.random()*6), - emit_type='tendrils'); - else: - player.capsules += 1 - ba.playsound( - self._collect_sound, - 0.6, - position=capsule.node.position) - # create a flash - light = ba.newnode( - 'light', - attrs={ - 'position': capsule.node.position, - 'height_attenuated': False, - 'radius': 0.1, - 'color': (1, 1, 0)}) + if capsule.node.color_texture == self._capsule_lucky_tex: + player.capsules += 4 + PopupText( + bonus, + color=(1, 1, 0), + scale=1.5, + position=capsule.node.position + ).autoretain() + ba.playsound( + self._lucky_collect_sound, + 1.0, + position=capsule.node.position) + ba.emitfx( + position=capsule.node.position, + velocity=(0, 0, 0), + count=int(6.4+random.random()*24), + scale=1.2, + spread=2.0, + chunk_type='spark') + ba.emitfx( + position=capsule.node.position, + velocity=(0, 0, 0), + count=int(4.0+random.random()*6), + emit_type='tendrils') + else: + player.capsules += 1 + ba.playsound( + self._collect_sound, + 0.6, + position=capsule.node.position) + # create a flash + light = ba.newnode( + 'light', + attrs={ + 'position': capsule.node.position, + 'height_attenuated': False, + 'radius': 0.1, + 'color': (1, 1, 0)}) - # Create a short text informing about your inventory - self._handle_capsule_storage(player.position, player) + # Create a short text informing about your inventory + self._handle_capsule_storage(player.position, player) - ba.animate(light, 'intensity', { - 0: 0, - 0.1: 0.5, - 0.2: 0 - }, loop=False) - ba.timer(0.2, light.delete) - capsule.handlemessage(ba.DieMessage()) + ba.animate(light, 'intensity', { + 0: 0, + 0.1: 0.5, + 0.2: 0 + }, loop=False) + ba.timer(0.2, light.delete) + capsule.handlemessage(ba.DieMessage()) - def _update_player_light(self, player: Player, capsules: int) -> None: - if player.light: - intensity = 0.04 * capsules - ba.animate(player.light, 'intensity', { - 0.0: player.light.intensity, - 0.1: intensity - }) - def newintensity(): - player.light.intensity = intensity - ba.timer(0.1, newintensity) - else: - player.light = ba.newnode( - 'light', - attrs={ - 'height_attenuated': False, - 'radius': 0.2, - 'intensity': 0.0, - 'color': (0.2, 1, 0.2) - }) - player.node.connectattr('position', player.light, 'position') + def _update_player_light(self, player: Player, capsules: int) -> None: + if player.light: + intensity = 0.04 * capsules + ba.animate(player.light, 'intensity', { + 0.0: player.light.intensity, + 0.1: intensity + }) - def _handle_capsule_storage(self, pos: float, player: Player) -> None: - capsules = player.capsules - text = str(capsules) - scale = 1.75 + (0.02 * capsules) - if capsules > 10: - player.capsules = 10 - text = full_capacity - color = (1, 0.85, 0) - elif capsules > 7: - color = (1, 0, 0) - scale = 2.4 - elif capsules > 5: - color = (1, 0.4, 0.4) - scale = 2.1 - elif capsules > 3: - color = (1, 1, 0.4) - scale = 2.0 - else: - color = (1, 1, 1) - scale = 1.9 - PopupText( - text, - color=color, - scale=scale, - position=(pos[0], pos[1]-1, pos[2]) - ).autoretain() - self._update_player_light(player, capsules) + def newintensity(): + player.light.intensity = intensity + ba.timer(0.1, newintensity) + else: + player.light = ba.newnode( + 'light', + attrs={ + 'height_attenuated': False, + 'radius': 0.2, + 'intensity': 0.0, + 'color': (0.2, 1, 0.2) + }) + player.node.connectattr('position', player.light, 'position') - def handlemessage(self, msg: Any) -> Any: - if isinstance(msg, ba.PlayerDiedMessage): - super().handlemessage(msg) # Augment default. - # No longer can count as time_at_flag once dead. - player = msg.getplayer(Player) - player.time_at_flag = 0 - self._update_flag_state() - self._drop_capsule(player) - player.capsules = 0 - self._update_player_light(player, 0) - self.respawn_player(player) - else: - return super().handlemessage(msg) + def _handle_capsule_storage(self, pos: float, player: Player) -> None: + capsules = player.capsules + text = str(capsules) + scale = 1.75 + (0.02 * capsules) + if capsules > 10: + player.capsules = 10 + text = full_capacity + color = (1, 0.85, 0) + elif capsules > 7: + color = (1, 0, 0) + scale = 2.4 + elif capsules > 5: + color = (1, 0.4, 0.4) + scale = 2.1 + elif capsules > 3: + color = (1, 1, 0.4) + scale = 2.0 + else: + color = (1, 1, 1) + scale = 1.9 + PopupText( + text, + color=color, + scale=scale, + position=(pos[0], pos[1]-1, pos[2]) + ).autoretain() + self._update_player_light(player, capsules) + + def handlemessage(self, msg: Any) -> Any: + if isinstance(msg, ba.PlayerDiedMessage): + super().handlemessage(msg) # Augment default. + # No longer can count as time_at_flag once dead. + player = msg.getplayer(Player) + player.time_at_flag = 0 + self._update_flag_state() + self._drop_capsule(player) + player.capsules = 0 + self._update_player_light(player, 0) + self.respawn_player(player) + else: + return super().handlemessage(msg) class Capsule(ba.Actor): - def __init__(self, - position: Sequence[float] = (0.0, 1.0, 0.0), - velocity: Sequence[float] = (0.0, 0.5, 0.0), - lucky: bool = False): - super().__init__() - shared = SharedObjects.get() - activity = self.getactivity() + def __init__(self, + position: Sequence[float] = (0.0, 1.0, 0.0), + velocity: Sequence[float] = (0.0, 0.5, 0.0), + lucky: bool = False): + super().__init__() + shared = SharedObjects.get() + activity = self.getactivity() - # spawn just above the provided point - self._spawn_pos = (position[0], position[1], position[2]) + # spawn just above the provided point + self._spawn_pos = (position[0], position[1], position[2]) - if lucky: - ba.playsound(activity._lucky_sound, 1.0, self._spawn_pos) + if lucky: + ba.playsound(activity._lucky_sound, 1.0, self._spawn_pos) - self.node = ba.newnode( - 'prop', - attrs={ - 'model': activity._capsule_model, - 'color_texture': activity._capsule_lucky_tex if lucky else ( - activity._capsule_tex), - 'body': 'crate' if lucky else 'capsule', - 'reflection': 'powerup' if lucky else 'soft', - 'body_scale': 0.65 if lucky else 0.3, - 'density':6.0 if lucky else 4.0, - 'reflection_scale': [0.15], - 'shadow_size': 0.65 if lucky else 0.6, - 'position': self._spawn_pos, - 'velocity': velocity, - 'materials': [ - shared.object_material, activity._capsule_material] - }, - delegate=self) - ba.animate(self.node, 'model_scale', { - 0.0: 0.0, - 0.1: 0.9 if lucky else 0.6, - 0.16: 0.8 if lucky else 0.5 - }) - self._light_capsule = ba.newnode( - 'light', - attrs={ - 'position': self._spawn_pos, - 'height_attenuated': False, - 'radius': 0.5 if lucky else 0.1, - 'color': (0.2, 0.2, 0) if lucky else (0.2, 1, 0.2) - }) - self.node.connectattr('position', self._light_capsule, 'position') + self.node = ba.newnode( + 'prop', + attrs={ + 'model': activity._capsule_model, + 'color_texture': activity._capsule_lucky_tex if lucky else ( + activity._capsule_tex), + 'body': 'crate' if lucky else 'capsule', + 'reflection': 'powerup' if lucky else 'soft', + 'body_scale': 0.65 if lucky else 0.3, + 'density': 6.0 if lucky else 4.0, + 'reflection_scale': [0.15], + 'shadow_size': 0.65 if lucky else 0.6, + 'position': self._spawn_pos, + 'velocity': velocity, + 'materials': [ + shared.object_material, activity._capsule_material] + }, + delegate=self) + ba.animate(self.node, 'model_scale', { + 0.0: 0.0, + 0.1: 0.9 if lucky else 0.6, + 0.16: 0.8 if lucky else 0.5 + }) + self._light_capsule = ba.newnode( + 'light', + attrs={ + 'position': self._spawn_pos, + 'height_attenuated': False, + 'radius': 0.5 if lucky else 0.1, + 'color': (0.2, 0.2, 0) if lucky else (0.2, 1, 0.2) + }) + self.node.connectattr('position', self._light_capsule, 'position') - def handlemessage(self, msg: Any): - if isinstance(msg, ba.DieMessage): - self.node.delete() - ba.animate(self._light_capsule, 'intensity', { - 0: 1.0, - 0.05: 0.0 - }, loop=False) - ba.timer(0.05, self._light_capsule.delete) - elif isinstance(msg, ba.OutOfBoundsMessage): - self.handlemessage(ba.DieMessage()) - elif isinstance(msg, ba.HitMessage): - self.node.handlemessage( - 'impulse', - msg.pos[0], msg.pos[1], msg.pos[2], - msg.velocity[0]/8, msg.velocity[1]/8, msg.velocity[2]/8, - 1.0*msg.magnitude, 1.0*msg.velocity_magnitude, msg.radius, 0, - msg.force_direction[0], msg.force_direction[1], - msg.force_direction[2]) - else: - return super().handlemessage(msg) + def handlemessage(self, msg: Any): + if isinstance(msg, ba.DieMessage): + self.node.delete() + ba.animate(self._light_capsule, 'intensity', { + 0: 1.0, + 0.05: 0.0 + }, loop=False) + ba.timer(0.05, self._light_capsule.delete) + elif isinstance(msg, ba.OutOfBoundsMessage): + self.handlemessage(ba.DieMessage()) + elif isinstance(msg, ba.HitMessage): + self.node.handlemessage( + 'impulse', + msg.pos[0], msg.pos[1], msg.pos[2], + msg.velocity[0]/8, msg.velocity[1]/8, msg.velocity[2]/8, + 1.0*msg.magnitude, 1.0*msg.velocity_magnitude, msg.radius, 0, + msg.force_direction[0], msg.force_direction[1], + msg.force_direction[2]) + else: + return super().handlemessage(msg) diff --git a/plugins/minigames/dodge_the_ball.py b/plugins/minigames/dodge_the_ball.py index d5b1770..a950131 100644 --- a/plugins/minigames/dodge_the_ball.py +++ b/plugins/minigames/dodge_the_ball.py @@ -11,7 +11,7 @@ from __future__ import annotations from typing import TYPE_CHECKING import ba -from random import choice +from random import choice from enum import Enum from bastd.actor.bomb import Blast from bastd.actor.popuptext import PopupText @@ -39,28 +39,31 @@ class BallType(Enum): # increase the next ball speed but less than MEDIUM. # Ball color is crimson(purple+red = pinky color type). -# this dict decide the ball_type spawning rate like powerup box + +# this dict decide the ball_type spawning rate like powerup box ball_type_dict: dict[BallType, int] = { BallType.EASY: 3, BallType.MEDIUM: 2, BallType.HARD: 1, -}; +} + class Ball(ba.Actor): """ Shooting Ball """ - def __init__(self, - position: Sequence[float], - velocity: Sequence[float], - texture: ba.Texture, - body_scale: float = 1.0, - gravity_scale: float = 1.0, - ) -> NoReturn: - - super().__init__(); - - shared = SharedObjects.get(); - - ball_material = ba.Material(); + + def __init__(self, + position: Sequence[float], + velocity: Sequence[float], + texture: ba.Texture, + body_scale: float = 1.0, + gravity_scale: float = 1.0, + ) -> NoReturn: + + super().__init__() + + shared = SharedObjects.get() + + ball_material = ba.Material() ball_material.add_actions( conditions=( ( @@ -72,8 +75,8 @@ class Ball(ba.Actor): ('they_have_material', shared.object_material), ), actions=('modify_node_collision', 'collide', False), - ); - + ) + self.node = ba.newnode( 'prop', delegate=self, @@ -86,37 +89,37 @@ class Ball(ba.Actor): 'model_scale': body_scale, 'color_texture': texture, 'gravity_scale': gravity_scale, - 'density': 4.0, # increase density of ball so ball collide with player with heavy force. # ammm very bad grammer + 'density': 4.0, # increase density of ball so ball collide with player with heavy force. # ammm very bad grammer 'materials': (ball_material,), - }, - ); - + }, + ) + # die the ball manually incase the ball doesn't fall the outside of the map - ba.timer(2.5, ba.WeakCall(self.handlemessage, ba.DieMessage())); - + ba.timer(2.5, ba.WeakCall(self.handlemessage, ba.DieMessage())) + # i am not handling anything in this ball Class(except for diemessage). # all game things and logics going to be in the box class def handlemessage(self, msg: Any) -> Any: - + if isinstance(msg, ba.DieMessage): - self.node.delete(); + self.node.delete() else: - super().handlemessage(msg); - - + super().handlemessage(msg) + + class Box(ba.Actor): """ A box that spawn midle of map as a decoration perpose """ - - def __init__(self, - position: Sequence[float], - velocity: Sequence[float], - ) -> NoReturn: - - super().__init__(); - shared = SharedObjects.get(); + def __init__(self, + position: Sequence[float], + velocity: Sequence[float], + ) -> NoReturn: + + super().__init__() + + shared = SharedObjects.get() # self.ball_jump = 0.0; - no_hit_material = ba.Material(); + no_hit_material = ba.Material() # we don't need that the box was move and collide with objects. no_hit_material.add_actions( conditions=( @@ -125,7 +128,7 @@ class Box(ba.Actor): ('they_have_material', shared.attack_material), ), actions=('modify_part_collision', 'collide', False), - ); + ) no_hit_material.add_actions( conditions=( @@ -137,8 +140,8 @@ class Box(ba.Actor): ('modify_part_collision', 'collide', False), ('modify_part_collision', 'physical', False), ), - ); - + ) + self.node = ba.newnode( 'prop', delegate=self, @@ -154,26 +157,26 @@ class Box(ba.Actor): 'reflection': 'powerup', 'reflection_scale': [1.0], 'materials': (no_hit_material,), - }, - ); + }, + ) # light self.light = ba.newnode( "light", - owner = self.node, + owner=self.node, attrs={ - 'radius' : 0.2, - 'intensity' : 0.8, - 'color': (0.0, 1.0, 0.0), + 'radius': 0.2, + 'intensity': 0.8, + 'color': (0.0, 1.0, 0.0), } - ); - self.node.connectattr("position", self.light, "position"); - # Drawing circle and circleOutline in radius of 3, - # so player can see that how close he is to the box. - # If player is inside this circle the ball speed will increase. + ) + self.node.connectattr("position", self.light, "position") + # Drawing circle and circleOutline in radius of 3, + # so player can see that how close he is to the box. + # If player is inside this circle the ball speed will increase. circle = ba.newnode( "locator", - owner = self.node, - attrs = { + owner=self.node, + attrs={ 'shape': 'circle', 'color': (1.0, 0.0, 0.0), 'opacity': 0.1, @@ -182,12 +185,12 @@ class Box(ba.Actor): 'additive': True, }, ) - self.node.connectattr("position", circle, "position"); + self.node.connectattr("position", circle, "position") # also adding a outline cause its look nice. circle_outline = ba.newnode( "locator", - owner = self.node, - attrs = { + owner=self.node, + attrs={ 'shape': 'circleOutline', 'color': (1.0, 1.0, 0.0), 'opacity': 0.1, @@ -195,185 +198,185 @@ class Box(ba.Actor): 'draw_beauty': False, 'additive': True, }, - ); - self.node.connectattr("position", circle_outline, "position"); - + ) + self.node.connectattr("position", circle_outline, "position") + # all ball attribute that we need. - self.ball_type: BallType = BallType.EASY; - self.shoot_timer: ba.Timer | None = None; - self.shoot_speed: float = 0.0; + self.ball_type: BallType = BallType.EASY + self.shoot_timer: ba.Timer | None = None + self.shoot_speed: float = 0.0 # this force the shoot if player is inside the red circle. - self.force_shoot_speed: float = 0.0; - self.ball_mag = 3000; - self.ball_gravity: float = 1.0; - self.ball_tex: ba.Texture | None = None; - # only for Hard ball_type - self.player_facing_direction: list[float, float] = [0.0, 0.0]; + self.force_shoot_speed: float = 0.0 + self.ball_mag = 3000 + self.ball_gravity: float = 1.0 + self.ball_tex: ba.Texture | None = None + # only for Hard ball_type + self.player_facing_direction: list[float, float] = [0.0, 0.0] # ball shoot soound. - self.shoot_sound = ba.getsound('laserReverse'); - - # same as "powerupdist" - self.ball_type_dist: list[BallType] = []; + self.shoot_sound = ba.getsound('laserReverse') + + # same as "powerupdist" + self.ball_type_dist: list[BallType] = [] for ball in ball_type_dict: for _ in range(ball_type_dict[ball]): - self.ball_type_dist.append(ball); - + self.ball_type_dist.append(ball) + # Here main logic of game goes here. # like shoot balls, shoot speed, anything we want goes here(except for some thing). def start_shoot(self) -> NoReturn: - + # getting all allive players in a list. - alive_players_list = self.activity.get_alive_players(); - + alive_players_list = self.activity.get_alive_players() + # make sure that list is not Empty. if len(alive_players_list) > 0: - + # choosing a random player from list. - target_player = choice(alive_players_list); - # highlight the target player - self.highlight_target_player(target_player); - + target_player = choice(alive_players_list) + # highlight the target player + self.highlight_target_player(target_player) + # to finding difference between player and box. # we just need to subtract player pos and ball pos. # Same logic as eric applied in Target Practice Gamemode. - difference = ba.Vec3(target_player.position) - ba.Vec3(self.node.position); - + difference = ba.Vec3(target_player.position) - ba.Vec3(self.node.position) + # discard Y position so ball shoot more straight. difference[1] = 0.0 - + # and now, this length method returns distance in float. # we're gonna use this value for calculating player analog stick - distance = difference.length(); - + distance = difference.length() + # shoot a random BallType - self.upgrade_ball_type(choice(self.ball_type_dist)); - + self.upgrade_ball_type(choice(self.ball_type_dist)) + # and check the ball_type and upgrade it gravity_scale, texture, next ball speed. - self.check_ball_type(self.ball_type); - + self.check_ball_type(self.ball_type) + # For HARD ball i am just focusing on player analog stick facing direction. # Not very accurate and that's we need. if self.ball_type == BallType.HARD: - self.calculate_player_analog_stick(target_player, distance); + self.calculate_player_analog_stick(target_player, distance) else: - self.player_facing_direction = [0.0, 0.0]; - - pos = self.node.position; - + self.player_facing_direction = [0.0, 0.0] + + pos = self.node.position + if self.ball_type == BallType.MEDIUM or self.ball_type == BallType.HARD: # Target head by increasing Y pos. # How this work? cause ball gravity_scale is ...... - pos = (pos[0], pos[1]+.25, pos[2]); - + pos = (pos[0], pos[1]+.25, pos[2]) + # ball is generating.. ball = Ball( - position = pos, - velocity = (0.0, 0.0, 0.0), - texture = self.ball_tex, - gravity_scale = self.ball_gravity, - body_scale = 1.0, - ).autoretain(); - + position=pos, + velocity=(0.0, 0.0, 0.0), + texture=self.ball_tex, + gravity_scale=self.ball_gravity, + body_scale=1.0, + ).autoretain() + # shoot Animation and sound. - self.shoot_animation(); - + self.shoot_animation() + # force the shoot speed if player try to go inside the red circle. if self.force_shoot_speed != 0.0: - self.shoot_speed = self.force_shoot_speed; - + self.shoot_speed = self.force_shoot_speed + # push the ball to the player ball.node.handlemessage( - 'impulse', + 'impulse', self.node.position[0], # ball spawn position X self.node.position[1], # Y self.node.position[2], # Z - 0, 0, 0, # velocity x,y,z - self.ball_mag, # magnetude - 0.000, # magnetude velocity + 0, 0, 0, # velocity x,y,z + self.ball_mag, # magnetude + 0.000, # magnetude velocity 0.000, # radius 0.000, # idk - difference[0] + self.player_facing_direction[0], # force direction X - difference[1] , # force direction Y - difference[2] + self.player_facing_direction[1], # force direction Z - ); + difference[0] + self.player_facing_direction[0], # force direction X + difference[1], # force direction Y + difference[2] + self.player_facing_direction[1], # force direction Z + ) # creating our timer and shoot the ball again.(and we create a loop) - self.shoot_timer = ba.Timer(self.shoot_speed, self.start_shoot); - + self.shoot_timer = ba.Timer(self.shoot_speed, self.start_shoot) + def upgrade_ball_type(self, ball_type: BallType) -> NoReturn: - - self.ball_type = ball_type; + + self.ball_type = ball_type def check_ball_type(self, ball_type: BallType) -> NoReturn: - - if ball_type == BallType.EASY: - self.shoot_speed = 0.8; - self.ball_gravity = 1.0; - # next ball shoot speed - self.ball_mag = 3000; - # box light color and ball tex - self.light.color = (1.0, 1.0, 0.0); - self.ball_tex = ba.gettexture('egg4'); - elif ball_type == BallType.MEDIUM: - self.ball_mag = 3000; - # decrease the gravity scale so, ball shoot without falling and straight. - self.ball_gravity = 0.0; - # next ball shoot speed. - self.shoot_speed = 0.4; - # box light color and ball tex. - self.light.color = (1.0, 0.0, 1.0); - self.ball_tex = ba.gettexture('egg3'); - elif ball_type == BallType.HARD: - self.ball_mag = 2500; - self.ball_gravity = 0.0; - # next ball shoot speed. - self.shoot_speed = 0.6; - # box light color and ball tex. - self.light.color = (1.0, 0.2, 1.0); - self.ball_tex = ba.gettexture('egg1'); - + + if ball_type == BallType.EASY: + self.shoot_speed = 0.8 + self.ball_gravity = 1.0 + # next ball shoot speed + self.ball_mag = 3000 + # box light color and ball tex + self.light.color = (1.0, 1.0, 0.0) + self.ball_tex = ba.gettexture('egg4') + elif ball_type == BallType.MEDIUM: + self.ball_mag = 3000 + # decrease the gravity scale so, ball shoot without falling and straight. + self.ball_gravity = 0.0 + # next ball shoot speed. + self.shoot_speed = 0.4 + # box light color and ball tex. + self.light.color = (1.0, 0.0, 1.0) + self.ball_tex = ba.gettexture('egg3') + elif ball_type == BallType.HARD: + self.ball_mag = 2500 + self.ball_gravity = 0.0 + # next ball shoot speed. + self.shoot_speed = 0.6 + # box light color and ball tex. + self.light.color = (1.0, 0.2, 1.0) + self.ball_tex = ba.gettexture('egg1') + def shoot_animation(self) -> NoReturn: - + ba.animate( self.node, - "model_scale",{ + "model_scale", { 0.00: 1.4, 0.05: 1.7, 0.10: 1.4, } - ); + ) # playing shoot sound. - ba.playsound(self.shoot_sound, position = self.node.position); - + ba.playsound(self.shoot_sound, position=self.node.position) + def highlight_target_player(self, player: ba.Player) -> NoReturn: - + # adding light light = ba.newnode( "light", - owner = self.node, + owner=self.node, attrs={ - 'radius':0.0, - 'intensity':1.0, - 'color': (1.0, 0.0, 0.0), + 'radius': 0.0, + 'intensity': 1.0, + 'color': (1.0, 0.0, 0.0), } - ); + ) ba.animate( - light, - "radius",{ - 0.05: 0.02, - 0.10: 0.07, - 0.15: 0.15, - 0.20: 0.13, - 0.25: 0.10, - 0.30: 0.05, - 0.35: 0.02, - 0.40: 0.00, - } - ); + light, + "radius", { + 0.05: 0.02, + 0.10: 0.07, + 0.15: 0.15, + 0.20: 0.13, + 0.25: 0.10, + 0.30: 0.05, + 0.35: 0.02, + 0.40: 0.00, + } + ) # And a circle outline with ugly animation. circle_outline = ba.newnode( "locator", - owner = player.actor.node, + owner=player.actor.node, attrs={ 'shape': 'circleOutline', 'color': (1.0, 0.0, 0.0), @@ -381,82 +384,82 @@ class Box(ba.Actor): 'draw_beauty': False, 'additive': True, }, - ); + ) ba.animate_array( circle_outline, - 'size', + 'size', 1, { - 0.05: [0.5], - 0.10: [0.8], - 0.15: [1.5], - 0.20: [2.0], - 0.25: [1.8], - 0.30: [1.3], - 0.35: [0.6], - 0.40: [0.0], - } - ); - + 0.05: [0.5], + 0.10: [0.8], + 0.15: [1.5], + 0.20: [2.0], + 0.25: [1.8], + 0.30: [1.3], + 0.35: [0.6], + 0.40: [0.0], + } + ) + # coonect it and... - player.actor.node.connectattr("position", light, "position"); - player.actor.node.connectattr("position", circle_outline, "position"); - + player.actor.node.connectattr("position", light, "position") + player.actor.node.connectattr("position", circle_outline, "position") + # immediately delete the node after another player has been targeted. - self.shoot_speed = 0.5 if self.shoot_speed == 0.0 else self.shoot_speed; - ba.timer(self.shoot_speed, light.delete); - ba.timer(self.shoot_speed, circle_outline.delete); - - def calculate_player_analog_stick(self, player:ba.Player, distance: float) -> NoReturn: + self.shoot_speed = 0.5 if self.shoot_speed == 0.0 else self.shoot_speed + ba.timer(self.shoot_speed, light.delete) + ba.timer(self.shoot_speed, circle_outline.delete) + + def calculate_player_analog_stick(self, player: ba.Player, distance: float) -> NoReturn: # at first i was very confused how i can read the player analog stick \ # then i saw TheMikirog#1984 autorun plugin code. # and i got it how analog stick values are works. # just need to store analog stick facing direction and need some calculation according how far player pushed analog stick. # Notice that how vertical direction is inverted, so we need to put a minus infront of veriable.(so ball isn't shoot at wrong direction). - self.player_facing_direction[0] = player.actor.node.move_left_right; - self.player_facing_direction[1] = -player.actor.node.move_up_down; - + self.player_facing_direction[0] = player.actor.node.move_left_right + self.player_facing_direction[1] = -player.actor.node.move_up_down + # if player is too close and the player pushing his analog stick fully the ball shoot's too far away to player. # so, we need to reduce the value of "self.player_facing_direction" to fix this problem. if distance <= 3: - self.player_facing_direction[0] = 0.4 if self.player_facing_direction[0] > 0 else -0.4; - self.player_facing_direction[1] = 0.4 if self.player_facing_direction[0] > 0 else -0.4; + self.player_facing_direction[0] = 0.4 if self.player_facing_direction[0] > 0 else -0.4 + self.player_facing_direction[1] = 0.4 if self.player_facing_direction[0] > 0 else -0.4 # same problem to long distance but in reverse, the ball can't reach to the player, # its because player analog stick value is between 1 and -1, # and this value is low to shoot ball forward to Player if player is too far from the box. # so. let's increase to 1.5 if player pushed analog stick fully. elif distance > 6.5: # So many calculation according to how analog stick pushed by player. - # Horizontal(left-right) calculation + # Horizontal(left-right) calculation if self.player_facing_direction[0] > 0.4: - self.player_facing_direction[0] = 1.5; + self.player_facing_direction[0] = 1.5 elif self.player_facing_direction[0] < -0.4: - self.player_facing_direction[0] = -1.5; + self.player_facing_direction[0] = -1.5 else: if self.player_facing_direction[0] > 0.0: - self.player_facing_direction[0] = 0.2; + self.player_facing_direction[0] = 0.2 elif self.player_facing_direction[0] < 0.0: - self.player_facing_direction[0] = -0.2; + self.player_facing_direction[0] = -0.2 else: - self.player_facing_direction[0] = 0.0; - + self.player_facing_direction[0] = 0.0 + # Vertical(up-down) calculation. if self.player_facing_direction[1] > 0.4: - self.player_facing_direction[1] = 1.5; + self.player_facing_direction[1] = 1.5 elif self.player_facing_direction[1] < -0.4: - self.player_facing_direction[1] = -1.5; + self.player_facing_direction[1] = -1.5 else: if self.player_facing_direction[1] > 0.0: - self.player_facing_direction[1] = 0.2; + self.player_facing_direction[1] = 0.2 elif self.player_facing_direction[1] < 0.0: - self.player_facing_direction[1] = -0.2; + self.player_facing_direction[1] = -0.2 else: - self.player_facing_direction[1] = -0.0; - + self.player_facing_direction[1] = -0.0 + # if we want stop the ball shootes def stop_shoot(self) -> NoReturn: - # Kill the timer. - self.shoot_timer = None; - + # Kill the timer. + self.shoot_timer = None + class Player(ba.Player['Team']): """Our player type for this game.""" @@ -466,192 +469,194 @@ class Team(ba.Team[Player]): """Our team type for this game.""" # almost 80 % for game we done in box class. -# now remain things, like name, seetings, scoring, cooldonw, +# now remain things, like name, seetings, scoring, cooldonw, # and main thing don't allow player to camp inside of box are going in this class. # ba_meta export game + + class DodgeTheBall(ba.TeamGameActivity[Player, Team]): - + # defining name, description and settings.. - name = 'Dodge the ball'; - description = 'Survive from shooting balls'; - + name = 'Dodge the ball' + description = 'Survive from shooting balls' + available_settings = [ ba.IntSetting( 'Cooldown', - min_value = 20, - default = 45, - increment = 5, + min_value=20, + default=45, + increment=5, ), ba.BoolSetting('Epic Mode', default=False) ] # Don't allow joining after we start. - allow_mid_activity_joins = False; - + allow_mid_activity_joins = False + @classmethod def supports_session_type(cls, sessiontype: type[ba.Session]) -> bool: # We support team and ffa sessions. return issubclass(sessiontype, ba.FreeForAllSession) or issubclass( sessiontype, ba.DualTeamSession, - ); - + ) + @classmethod def get_supported_maps(cls, sessiontype: type[ba.Session]) -> list[str]: # This Game mode need a flat and perfect shape map where can player fall outside map. # bombsquad have "Doom Shroom" map. # Not perfect map for this game mode but its fine for this gamemode. # the problem is that Doom Shroom is not a perfect circle and not flat also. - return ['Doom Shroom']; - + return ['Doom Shroom'] + def __init__(self, settings: dict): - super().__init__(settings); - self._epic_mode = bool(settings['Epic Mode']); - self.countdown_time = int(settings['Cooldown']); - - self.check_player_pos_timer: ba.Timer | None = None; - self.shield_drop_timer: ba.Timer | None = None; + super().__init__(settings) + self._epic_mode = bool(settings['Epic Mode']) + self.countdown_time = int(settings['Cooldown']) + + self.check_player_pos_timer: ba.Timer | None = None + self.shield_drop_timer: ba.Timer | None = None # cooldown and Box - self._countdown: OnScreenCountdown | None = None; - self.box: Box | None = None; - + self._countdown: OnScreenCountdown | None = None + self.box: Box | None = None + # this lists for scoring. - self.joined_player_list: list[ba.Player] = []; - self.dead_player_list: list[ba.Player] = []; - + self.joined_player_list: list[ba.Player] = [] + self.dead_player_list: list[ba.Player] = [] + # normally play RUN AWAY music cause is match with our gamemode at.. my point, # but in epic switch to EPIC. - self.slow_motion = self._epic_mode; + self.slow_motion = self._epic_mode self.default_music = ( ba.MusicType.EPIC if self._epic_mode else ba.MusicType.RUN_AWAY - ); - + ) + def get_instance_description(self) -> str | Sequence: - return 'Keep away as possible as you can'; - + return 'Keep away as possible as you can' + # add a tiny text under our game name. def get_instance_description_short(self) -> str | Sequence: - return 'Dodge the shooting balls'; + return 'Dodge the shooting balls' def on_begin(self) -> NoReturn: - super().on_begin(); - + super().on_begin() + # spawn our box at middle of the map self.box = Box( position=(0.5, 2.7, -3.9), velocity=(0.0, 0.0, 0.0), - ).autoretain(); - - # create our cooldown + ).autoretain() + + # create our cooldown self._countdown = OnScreenCountdown( - duration = self.countdown_time, - endcall = self.play_victory_sound_and_end, - ); - + duration=self.countdown_time, + endcall=self.play_victory_sound_and_end, + ) + # and starts the cooldown and shootes. - ba.timer(5.0, self._countdown.start); - ba.timer(5.0, self.box.start_shoot); - + ba.timer(5.0, self._countdown.start) + ba.timer(5.0, self.box.start_shoot) + # start checking all player pos. - ba.timer(5.0, self.check_player_pos); - + ba.timer(5.0, self.check_player_pos) + # drop shield every ten Seconds # need five seconds delay Because shootes start after 5 seconds. - ba.timer(15.0, self.drop_shield); - + ba.timer(15.0, self.drop_shield) + # This function returns all alive players in game. # i thinck you see this function in Box class. def get_alive_players(self) -> Sequence[ba.Player]: - - alive_players = []; - + + alive_players = [] + for team in self.teams: for player in team.players: if player.is_alive(): - alive_players.append(player); - - return alive_players; - + alive_players.append(player) + + return alive_players + # let's disallowed camping inside of box by doing a blast and increasing ball shoot speed. def check_player_pos(self): - + for player in self.get_alive_players(): - - # same logic as applied for the ball - difference = ba.Vec3(player.position) - ba.Vec3(self.box.node.position); - - distance = difference.length(); - - if distance < 3: - self.box.force_shoot_speed = 0.2; - else: - self.box.force_shoot_speed = 0.0; - - if distance < 0.5: - Blast( - position = self.box.node.position, - velocity = self.box.node.velocity, - blast_type = 'normal', - blast_radius = 1.0, - ).autoretain(); - - PopupText( - position = self.box.node.position, - text = 'Keep away from me', - random_offset = 0.0, - scale = 2.0, - color = self.box.light.color, - ).autoretain(); - + + # same logic as applied for the ball + difference = ba.Vec3(player.position) - ba.Vec3(self.box.node.position) + + distance = difference.length() + + if distance < 3: + self.box.force_shoot_speed = 0.2 + else: + self.box.force_shoot_speed = 0.0 + + if distance < 0.5: + Blast( + position=self.box.node.position, + velocity=self.box.node.velocity, + blast_type='normal', + blast_radius=1.0, + ).autoretain() + + PopupText( + position=self.box.node.position, + text='Keep away from me', + random_offset=0.0, + scale=2.0, + color=self.box.light.color, + ).autoretain() + # create our timer and start looping it - self.check_player_pos_timer = ba.Timer(0.1, self.check_player_pos); - + self.check_player_pos_timer = ba.Timer(0.1, self.check_player_pos) + # drop useless shield's too give player temptation. def drop_shield(self) -> NoReturn: - - pos = self.box.node.position; - - PowerupBox( - position = (pos[0] + 4.0, pos[1] + 3.0, pos[2]), - poweruptype = 'shield', - ).autoretain(); - - PowerupBox( - position = (pos[0] - 4.0, pos[1] + 3.0, pos[2]), - poweruptype = 'shield', - ).autoretain(); - - self.shield_drop_timer = ba.Timer(10.0, self.drop_shield); - + + pos = self.box.node.position + + PowerupBox( + position=(pos[0] + 4.0, pos[1] + 3.0, pos[2]), + poweruptype='shield', + ).autoretain() + + PowerupBox( + position=(pos[0] - 4.0, pos[1] + 3.0, pos[2]), + poweruptype='shield', + ).autoretain() + + self.shield_drop_timer = ba.Timer(10.0, self.drop_shield) + # when cooldown time up i don't want that the game end immediately. def play_victory_sound_and_end(self) -> NoReturn: - + # kill timers - self.box.stop_shoot(); + self.box.stop_shoot() self.check_player_pos_timer = None self.shield_drop_timer = None - ba.timer(2.0, self.end_game); - + ba.timer(2.0, self.end_game) + # this function runs when A player spawn in map def spawn_player(self, player: Player) -> NoReturn: - spaz = self.spawn_player_spaz(player); + spaz = self.spawn_player_spaz(player) # reconnect this player's controls. # without bomb, punch and pickup. spaz.connect_controls_to_player( enable_punch=False, enable_bomb=False, enable_pickup=False, - ); - + ) + # storing all players for ScorinG. - self.joined_player_list.append(player); - + self.joined_player_list.append(player) + # Also lets have them make some noise when they die. - spaz.play_big_death_sound = True; - + spaz.play_big_death_sound = True + # very helpful function to check end game when player dead or leav. def _check_end_game(self) -> bool: - + living_team_count = 0 for team in self.teams: for player in team.players: @@ -669,51 +674,51 @@ class DodgeTheBall(ba.TeamGameActivity[Player, Team]): # this function called when player leave. def on_player_leave(self, player: Player) -> NoReturn: # Augment default behavior. - super().on_player_leave(player); + super().on_player_leave(player) # checking end game. - self._check_end_game(); + self._check_end_game() # this gamemode needs to handle only one msg "PlayerDiedMessage". def handlemessage(self, msg: Any) -> Any: - + if isinstance(msg, ba.PlayerDiedMessage): # Augment standard behavior. - super().handlemessage(msg); - + super().handlemessage(msg) + # and storing the dead player records in our dead_player_list. - self.dead_player_list.append(msg.getplayer(Player)); - + self.dead_player_list.append(msg.getplayer(Player)) + # check the end game. - ba.timer(1.0, self._check_end_game); - + ba.timer(1.0, self._check_end_game) + def end_game(self): # kill timers self.box.stop_shoot() self.check_player_pos_timer = None self.shield_drop_timer = None - + # here the player_dead_list and joined_player_list gonna be very helpful. for team in self.teams: for player in team.players: - + # for scoring i am just following the index of the player_dead_list. # for dead list... # 0th index player dead first. # 1st index player dead second. # and so on... - # i think you got it... maybe + # i think you got it... maybe # sometime we also got a empty list # if we got a empty list that means all players are survived or maybe only one player playing and he/she survived. if len(self.dead_player_list) > 0: - + for index, dead_player in enumerate(self.dead_player_list): # if this condition is true we find the dead player \ # and his index with enumerate function. if player == dead_player: # updating with one, because i don't want to give 0 score to first dead player. - index += 1 + index += 1 break # and if this statement is true we just find a survived player. # for survived player i am giving the highest score according to how many players are joined. @@ -722,11 +727,11 @@ class DodgeTheBall(ba.TeamGameActivity[Player, Team]): # for survived player i am giving the highest score according to how many players are joined. else: index = len(self.joined_player_list) - + # and here i am following Table of 10 for scoring. # very lazY. score = int(10 * index) - + self.stats.player_scored(player, score, screenmessage=False) # Ok now calc game results: set a score for each team and then tell \ @@ -738,25 +743,23 @@ class DodgeTheBall(ba.TeamGameActivity[Player, Team]): # just always deal in teams and have all cases covered. # hmmm... some eric comments might be helpful to you. for team in self.teams: - + max_index = 0 for player in team.players: - # for the team, we choose only one player who survived longest. - # same logic.. - if len(self.dead_player_list) > 0: + # for the team, we choose only one player who survived longest. + # same logic.. + if len(self.dead_player_list) > 0: for index, dead_player in enumerate(self.dead_player_list): if player == dead_player: index += 1 break elif index == len(self.dead_player_list) - 1: index = len(self.joined_player_list) - else: + else: index = len(self.joined_player_list) - - max_index = max(max_index, index) + + max_index = max(max_index, index) # set the team score - results.set_team_score(team, int(10 * max_index)) + results.set_team_score(team, int(10 * max_index)) # and end the game self.end(results=results) - - \ No newline at end of file diff --git a/plugins/minigames/invisible_one.py b/plugins/minigames/invisible_one.py index 211a163..3b9bdd8 100644 --- a/plugins/minigames/invisible_one.py +++ b/plugins/minigames/invisible_one.py @@ -225,7 +225,6 @@ class InvicibleOneGame(ba.TeamGameActivity[Player, Team]): scoring_team.time_remaining = max( 0, scoring_team.time_remaining - 1) - self._update_scoreboard() # announce numbers we have sounds for @@ -286,7 +285,8 @@ class InvicibleOneGame(ba.TeamGameActivity[Player, Team]): self._invicible_one_player = player if self._invicible_one_is_lazy: - player.actor.connect_controls_to_player(enable_punch = False, enable_pickup = False, enable_bomb = False) + player.actor.connect_controls_to_player( + enable_punch=False, enable_pickup=False, enable_bomb=False) if player.actor.node.torso_model != None: player.actor.node.color_mask_texture = None player.actor.node.color_texture = None @@ -307,9 +307,8 @@ class InvicibleOneGame(ba.TeamGameActivity[Player, Team]): player.actor.pickup_sounds = invi_sound player.actor.death_sounds = invi_sound player.actor.fall_sounds = invi_sound - - player.actor.node.name = '' + player.actor.node.name = '' def handlemessage(self, msg: Any) -> Any: if isinstance(msg, ba.PlayerDiedMessage): diff --git a/plugins/minigames/last_punch_stand.py b/plugins/minigames/last_punch_stand.py index 878fea9..41fe281 100644 --- a/plugins/minigames/last_punch_stand.py +++ b/plugins/minigames/last_punch_stand.py @@ -1,38 +1,45 @@ # ba_meta require api 7 from typing import Sequence -import ba, _ba, random +import ba +import _ba +import random from bastd.actor.spaz import Spaz from bastd.actor.scoreboard import Scoreboard + class Player(ba.Player['Team']): - """Our player type for this game.""" + """Our player type for this game.""" + class Team(ba.Team[Player]): - """Our team type for this game.""" + """Our team type for this game.""" + + def __init__(self) -> None: + super().__init__() + self.score = 1 - def __init__(self) -> None: - super().__init__() - self.score = 1 class ChooseingSpazHitMessage: - def __init__(self, hitter:Player) -> None: - self.hitter = hitter + def __init__(self, hitter: Player) -> None: + self.hitter = hitter + class ChooseingSpazDieMessage: - def __init__(self, killer:Player) -> None: - self.killer = killer + def __init__(self, killer: Player) -> None: + self.killer = killer + class ChooseingSpaz(Spaz): - def __init__( - self, - pos:Sequence[float], - color: Sequence[float] = (1.0, 1.0, 1.0), - highlight: Sequence[float] = (0.5, 0.5, 0.5), - ): - super().__init__(color, highlight, "Spaz", None, True, True, False, False) - self.last_player_attacked_by = None - self.stand(pos) - self.loc = ba.newnode( + def __init__( + self, + pos: Sequence[float], + color: Sequence[float] = (1.0, 1.0, 1.0), + highlight: Sequence[float] = (0.5, 0.5, 0.5), + ): + super().__init__(color, highlight, "Spaz", None, True, True, False, False) + self.last_player_attacked_by = None + self.stand(pos) + self.loc = ba.newnode( 'locator', attrs={ 'shape': 'circleOutline', @@ -43,221 +50,223 @@ class ChooseingSpaz(Spaz): 'additive': True, }, ) - self.node.connectattr("position", self.loc, "position") - ba.animate_array(self.loc, "size", 1, keys={0:[0.5,], 1:[2,], 1.5:[0.5]}, loop=True) + self.node.connectattr("position", self.loc, "position") + ba.animate_array(self.loc, "size", 1, keys={0: [0.5,], 1: [2,], 1.5: [0.5]}, loop=True) - def handlemessage(self, msg): - if isinstance(msg, ba.FreezeMessage): - return + def handlemessage(self, msg): + if isinstance(msg, ba.FreezeMessage): + return - if isinstance(msg, ba.PowerupMessage): - if not(msg.poweruptype == "health"): - return + if isinstance(msg, ba.PowerupMessage): + if not (msg.poweruptype == "health"): + return - super().handlemessage(msg) + super().handlemessage(msg) - if isinstance(msg, ba.HitMessage): - self.handlemessage(ba.PowerupMessage("health")) + if isinstance(msg, ba.HitMessage): + self.handlemessage(ba.PowerupMessage("health")) - player = msg.get_source_player(Player) - if self.is_alive(): - self.activity.handlemessage(ChooseingSpazHitMessage(player)) - self.last_player_attacked_by = player + player = msg.get_source_player(Player) + if self.is_alive(): + self.activity.handlemessage(ChooseingSpazHitMessage(player)) + self.last_player_attacked_by = player + elif isinstance(msg, ba.DieMessage): + player = self.last_player_attacked_by - elif isinstance(msg, ba.DieMessage): - player = self.last_player_attacked_by + if msg.how.value != ba.DeathType.GENERIC.value: + self._dead = True + self.activity.handlemessage(ChooseingSpazDieMessage(player)) - if msg.how.value != ba.DeathType.GENERIC.value: - self._dead = True - self.activity.handlemessage(ChooseingSpazDieMessage(player)) + self.loc.delete() - self.loc.delete() + def stand(self, pos=(0, 0, 0), angle=0): + self.handlemessage(ba.StandMessage(pos, angle)) + def recolor(self, color, highlight=(1, 1, 1)): + self.node.color = color + self.node.highlight = highlight + self.loc.color = color - def stand(self, pos = (0,0,0), angle = 0): - self.handlemessage(ba.StandMessage(pos,angle)) - - def recolor(self, color, highlight = (1,1,1)): - self.node.color = color - self.node.highlight = highlight - self.loc.color = color - class ChooseBilbord(ba.Actor): - def __init__(self, player:Player, delay = 0.1) -> None: - super().__init__() + def __init__(self, player: Player, delay=0.1) -> None: + super().__init__() - icon = player.get_icon() - self.scale = 100 + icon = player.get_icon() + self.scale = 100 - self.node = ba.newnode( - 'image', - delegate=self, - attrs={ - "position":(60,-125), - 'texture': icon['texture'], - 'tint_texture': icon['tint_texture'], - 'tint_color': icon['tint_color'], - 'tint2_color': icon['tint2_color'], - 'opacity': 1.0, - 'absolute_scale': True, - 'attach': "topLeft" - }, - ) + self.node = ba.newnode( + 'image', + delegate=self, + attrs={ + "position": (60, -125), + 'texture': icon['texture'], + 'tint_texture': icon['tint_texture'], + 'tint_color': icon['tint_color'], + 'tint2_color': icon['tint2_color'], + 'opacity': 1.0, + 'absolute_scale': True, + 'attach': "topLeft" + }, + ) - self.name_node = ba.newnode( - 'text', - owner=self.node, - attrs={ - 'position': (60,-185), - 'text': ba.Lstr(value=player.getname()), - 'color': ba.safecolor(player.team.color), - 'h_align': 'center', - 'v_align': 'center', - 'vr_depth': 410, - 'flatness': 1.0, - 'h_attach': 'left', - 'v_attach': 'top', - 'maxwidth':self.scale - }, - ) - - ba.animate_array(self.node, "scale", keys={0 + delay:[0,0], 0.05 + delay:[self.scale, self.scale]}, size=1) - ba.animate(self.name_node, "scale", {0 + delay:0, 0.07 + delay:1}) + self.name_node = ba.newnode( + 'text', + owner=self.node, + attrs={ + 'position': (60, -185), + 'text': ba.Lstr(value=player.getname()), + 'color': ba.safecolor(player.team.color), + 'h_align': 'center', + 'v_align': 'center', + 'vr_depth': 410, + 'flatness': 1.0, + 'h_attach': 'left', + 'v_attach': 'top', + 'maxwidth': self.scale + }, + ) - def handlemessage(self, msg): - super().handlemessage(msg) - if isinstance(msg, ba.DieMessage): - ba.animate_array(self.node, "scale", keys={0:self.node.scale, 0.05:[0,0]}, size=1) - ba.animate(self.name_node, "scale", {0:self.name_node.scale, 0.07:0}) + ba.animate_array(self.node, "scale", keys={ + 0 + delay: [0, 0], 0.05 + delay: [self.scale, self.scale]}, size=1) + ba.animate(self.name_node, "scale", {0 + delay: 0, 0.07 + delay: 1}) - def __delete(): - self.node.delete() - self.name_node.delete() - - ba.timer(0.2, __delete) + def handlemessage(self, msg): + super().handlemessage(msg) + if isinstance(msg, ba.DieMessage): + ba.animate_array(self.node, "scale", keys={0: self.node.scale, 0.05: [0, 0]}, size=1) + ba.animate(self.name_node, "scale", {0: self.name_node.scale, 0.07: 0}) + + def __delete(): + self.node.delete() + self.name_node.delete() + + ba.timer(0.2, __delete) # ba_meta export game + + class LastPunchStand(ba.TeamGameActivity[Player, Team]): - name = "Last Punch Stand" - description = "Last one punchs the choosing spaz wins" - tips = [ - 'keep punching the choosing spaz to be last punched player at times up!', - 'you can not frezz the choosing spaz', - "evry time you punch the choosing spaz, you will get one point", - ] + name = "Last Punch Stand" + description = "Last one punchs the choosing spaz wins" + tips = [ + 'keep punching the choosing spaz to be last punched player at times up!', + 'you can not frezz the choosing spaz', + "evry time you punch the choosing spaz, you will get one point", + ] - default_music = ba.MusicType.TO_THE_DEATH + default_music = ba.MusicType.TO_THE_DEATH - available_settings = [ - ba.FloatSetting("min time limit (in seconds)", 50.0, min_value=30.0), - ba.FloatSetting("max time limit (in seconds)", 160.0, 60), + available_settings = [ + ba.FloatSetting("min time limit (in seconds)", 50.0, min_value=30.0), + ba.FloatSetting("max time limit (in seconds)", 160.0, 60), - ] + ] - def __init__(self, settings: dict): - super().__init__(settings) - self._min_timelimit = settings["min time limit (in seconds)"] - self._max_timelimit = settings["max time limit (in seconds)"] - if (self._min_timelimit > self._max_timelimit): - self._max_timelimit = self._min_timelimit + def __init__(self, settings: dict): + super().__init__(settings) + self._min_timelimit = settings["min time limit (in seconds)"] + self._max_timelimit = settings["max time limit (in seconds)"] + if (self._min_timelimit > self._max_timelimit): + self._max_timelimit = self._min_timelimit - self._choosing_spaz_defcolor = (0.5,0.5,0.5) - self.choosing_spaz = None - self.choosed_player = None - self.times_uped = False - self.scoreboard = Scoreboard() + self._choosing_spaz_defcolor = (0.5, 0.5, 0.5) + self.choosing_spaz = None + self.choosed_player = None + self.times_uped = False + self.scoreboard = Scoreboard() - def times_up(self): - self.times_uped = True + def times_up(self): + self.times_uped = True - for player in self.players: - if self.choosed_player and (player.team.id != self.choosed_player.team.id): - player.actor._cursed = True - player.actor.curse_explode() + for player in self.players: + if self.choosed_player and (player.team.id != self.choosed_player.team.id): + player.actor._cursed = True + player.actor.curse_explode() - self.end_game() + self.end_game() - def __get_spaz_bot_spawn_point(self): - if len(self.map.tnt_points) > 0: - return self.map.tnt_points[random.randint(0, len(self.map.tnt_points)-1)] - else: - return (0, 6, 0) + def __get_spaz_bot_spawn_point(self): + if len(self.map.tnt_points) > 0: + return self.map.tnt_points[random.randint(0, len(self.map.tnt_points)-1)] + else: + return (0, 6, 0) - def spaw_bot(self): - "spawns a choosing bot" + def spaw_bot(self): + "spawns a choosing bot" - self.choosing_spaz = ChooseingSpaz(self.__get_spaz_bot_spawn_point()) - self.choose_bilbord = None + self.choosing_spaz = ChooseingSpaz(self.__get_spaz_bot_spawn_point()) + self.choose_bilbord = None - def on_begin(self) -> None: - super().on_begin() - time_limit = random.randint(self._min_timelimit, self._max_timelimit) - self.spaw_bot() - ba.timer(time_limit, self.times_up) + def on_begin(self) -> None: + super().on_begin() + time_limit = random.randint(self._min_timelimit, self._max_timelimit) + self.spaw_bot() + ba.timer(time_limit, self.times_up) - self.setup_standard_powerup_drops(False) + self.setup_standard_powerup_drops(False) - def end_game(self) -> None: - results = ba.GameResults() - for team in self.teams: - if self.choosed_player and (team.id == self.choosed_player.team.id): team.score += 100 - results.set_team_score(team, team.score) - self.end(results=results) + def end_game(self) -> None: + results = ba.GameResults() + for team in self.teams: + if self.choosed_player and (team.id == self.choosed_player.team.id): + team.score += 100 + results.set_team_score(team, team.score) + self.end(results=results) - def change_choosed_player(self, hitter:Player): - if hitter: - self.choosing_spaz.recolor(hitter.color, hitter.highlight) - self.choosed_player = hitter - hitter.team.score += 1 - self.choose_bilbord = ChooseBilbord(hitter) - self.hide_score_board() - else: - self.choosing_spaz.recolor(self._choosing_spaz_defcolor) - self.choosed_player = None - self.choose_bilbord = None - self.show_score_board() + def change_choosed_player(self, hitter: Player): + if hitter: + self.choosing_spaz.recolor(hitter.color, hitter.highlight) + self.choosed_player = hitter + hitter.team.score += 1 + self.choose_bilbord = ChooseBilbord(hitter) + self.hide_score_board() + else: + self.choosing_spaz.recolor(self._choosing_spaz_defcolor) + self.choosed_player = None + self.choose_bilbord = None + self.show_score_board() - def show_score_board(self): - self.scoreboard = Scoreboard() - for team in self.teams: - self.scoreboard.set_team_value(team, team.score) - - def hide_score_board(self): - self.scoreboard = None + def show_score_board(self): + self.scoreboard = Scoreboard() + for team in self.teams: + self.scoreboard.set_team_value(team, team.score) - def _watch_dog_(self): - "checks if choosing spaz exists" - #choosing spaz wont respawn if death type if generic - #this becuse we dont want to keep respawn him when he dies because of losing referce - #but sometimes "choosing spaz" dies naturaly and his death type is generic! so it wont respawn back again - #thats why we have this function; to check if spaz exits in the case that he didnt respawned - - if self.choosing_spaz: - if self.choosing_spaz._dead: - self.spaw_bot() - else: - self.spaw_bot() + def hide_score_board(self): + self.scoreboard = None - def handlemessage(self, msg): - super().handlemessage(msg) + def _watch_dog_(self): + "checks if choosing spaz exists" + # choosing spaz wont respawn if death type if generic + # this becuse we dont want to keep respawn him when he dies because of losing referce + # but sometimes "choosing spaz" dies naturaly and his death type is generic! so it wont respawn back again + # thats why we have this function; to check if spaz exits in the case that he didnt respawned - if isinstance(msg, ChooseingSpazHitMessage): - hitter = msg.hitter - if self.choosing_spaz.node and hitter: - self.change_choosed_player(hitter) + if self.choosing_spaz: + if self.choosing_spaz._dead: + self.spaw_bot() + else: + self.spaw_bot() - elif isinstance(msg, ChooseingSpazDieMessage): - self.spaw_bot() - self.change_choosed_player(None) - - elif isinstance(msg, ba.PlayerDiedMessage): - player = msg.getplayer(Player) - if not (self.has_ended() or self.times_uped): - self.respawn_player(player, 0) - - if self.choosed_player and (player.getname(True) == self.choosed_player.getname(True)): - self.change_choosed_player(None) + def handlemessage(self, msg): + super().handlemessage(msg) - self._watch_dog_() \ No newline at end of file + if isinstance(msg, ChooseingSpazHitMessage): + hitter = msg.hitter + if self.choosing_spaz.node and hitter: + self.change_choosed_player(hitter) + + elif isinstance(msg, ChooseingSpazDieMessage): + self.spaw_bot() + self.change_choosed_player(None) + + elif isinstance(msg, ba.PlayerDiedMessage): + player = msg.getplayer(Player) + if not (self.has_ended() or self.times_uped): + self.respawn_player(player, 0) + + if self.choosed_player and (player.getname(True) == self.choosed_player.getname(True)): + self.change_choosed_player(None) + + self._watch_dog_() diff --git a/plugins/minigames/quake.py b/plugins/minigames/quake.py index 58ef3e3..e0bb33b 100644 --- a/plugins/minigames/quake.py +++ b/plugins/minigames/quake.py @@ -6,16 +6,17 @@ from typing import TYPE_CHECKING import random import enum -import ba, _ba +import ba +import _ba from bastd.actor.scoreboard import Scoreboard from bastd.actor.powerupbox import PowerupBox from bastd.gameutils import SharedObjects -#from rocket +# from rocket from bastd.actor.bomb import Blast -#from railgun +# from railgun from bastd.actor.playerspaz import PlayerSpaz from bastd.actor.spaz import Spaz @@ -27,7 +28,7 @@ if TYPE_CHECKING: STORAGE_ATTR_NAME = f'_shared_{__name__}_factory' -#+++++++++++++++++++Rocket++++++++++++++++++++++++ +# +++++++++++++++++++Rocket++++++++++++++++++++++++ class RocketFactory: """Quake Rocket factory""" @@ -182,10 +183,10 @@ class Rocket(ba.Actor): elif isinstance(msg, ba.OutOfBoundsMessage): self.handlemessage(ba.DieMessage()) -#-------------------Rocket-------------------------- +# -------------------Rocket-------------------------- -#++++++++++++++++++Railgun++++++++++++++++++++++++++ +# ++++++++++++++++++Railgun++++++++++++++++++++++++++ class Railgun: """Very dangerous weapon""" @@ -298,7 +299,8 @@ class RailBullet(ba.Actor): elif isinstance(msg, ba.OutOfBoundsMessage): self.handlemessage(ba.DieMessage()) -#------------------Railgun------------------------- +# ------------------Railgun------------------------- + class Player(ba.Player['Team']): """Our player""" @@ -306,6 +308,7 @@ class Player(ba.Player['Team']): class Team(ba.Team[Player]): """Our team""" + def __init__(self) -> None: self.score = 0 @@ -618,10 +621,10 @@ class Obstacle(ba.Actor): 'color_texture': ba.gettexture('bunnyColor'), 'materials': [SharedObjects.get().footing_material] - if mirror else [ - SharedObjects.get().object_material, - SharedObjects.get().footing_material - ] + if mirror else [ + SharedObjects.get().object_material, + SharedObjects.get().footing_material + ] }) def handlemessage(self, msg: Any) -> Any: diff --git a/plugins/minigames/sleep_race.py b/plugins/minigames/sleep_race.py index 6746524..104c98c 100644 --- a/plugins/minigames/sleep_race.py +++ b/plugins/minigames/sleep_race.py @@ -1,7 +1,7 @@ # Released under the MIT License. See LICENSE for details. # y me (: itsre3 # =>2<= -#BCS RULES +# BCS RULES # """Defines Race mini-game.""" @@ -14,7 +14,8 @@ import random from typing import TYPE_CHECKING from dataclasses import dataclass -import ba, _ba +import ba +import _ba from bastd.actor.bomb import Bomb from bastd.actor.playerspaz import PlayerSpaz from bastd.actor.scoreboard import Scoreboard @@ -215,7 +216,7 @@ class SleepRaceGame(ba.TeamGameActivity[Player, Team]): ('modify_part_collision', 'physical', False), ('call', 'at_connect', self._handle_race_point_collide), - )) + )) for rpt in pts: self._regions.append(RaceRegion(rpt, len(self._regions))) @@ -263,7 +264,7 @@ class SleepRaceGame(ba.TeamGameActivity[Player, Team]): translate=('statements', 'Killing ${NAME} for' ' skipping part of the track!'), subs=[('${NAME}', player.getname(full=True))]), - color=(1, 0, 0)) + color=(1, 0, 0)) else: # If this player is in first, note that this is the # front-most race-point. @@ -378,7 +379,7 @@ class SleepRaceGame(ba.TeamGameActivity[Player, Team]): '${TEAM} is disqualified because ${PLAYER} left'), subs=[('${TEAM}', player.team.name), ('${PLAYER}', player.getname(full=True))]), - color=(1, 1, 0)) + color=(1, 1, 0)) player.team.finished = True player.team.time = None player.team.lap = 0 @@ -435,7 +436,6 @@ class SleepRaceGame(ba.TeamGameActivity[Player, Team]): 'text': 'By itsre3' })) - # Throw a timer up on-screen. self._time_text = ba.NodeActor( ba.newnode('text', @@ -543,35 +543,34 @@ class SleepRaceGame(ba.TeamGameActivity[Player, Team]): self._spawn_bomb, repeat=True) - def knock_players(): activity = _ba.get_foreground_host_activity() gnode = ba.getactivity().globalsnode for players in activity.players: - gnode.tint = (0.5,0.5,0.5) + gnode.tint = (0.5, 0.5, 0.5) node = players.actor.node node.handlemessage('knockout', 600.0) self.text_offset = ba.newnode('math', - owner=node, - attrs={'input1': (-0.5, 0.5, 0.25), - 'operation': 'add'}) + owner=node, + attrs={'input1': (-0.5, 0.5, 0.25), + 'operation': 'add'}) node.connectattr( - 'torso_position', - self.text_offset, - 'input2') + 'torso_position', + self.text_offset, + 'input2') self.text = ba.newnode('text', - owner=node, - attrs={ - 'h_align': 'right', - 'color': (1.0, 1.0, 1.0), - 'shadow': 1.0, - 'text': 'z z', - 'scale': 0.01, - 'in_world': True}) + owner=node, + attrs={ + 'h_align': 'right', + 'color': (1.0, 1.0, 1.0), + 'shadow': 1.0, + 'text': 'z z', + 'scale': 0.01, + 'in_world': True}) self.text_offset.connectattr( - 'output', - self.text, - 'position') + 'output', + self.text, + 'position') ba.animate(self.text, 'scale', {0: 0.0, 1.0: 0.01}) ba.timer(2, self.text.delete) @@ -580,9 +579,8 @@ class SleepRaceGame(ba.TeamGameActivity[Player, Team]): self._knockout_timer = ba.Timer(knock_time, knock_players, repeat=True) - - self._race_started = True + self._race_started = True def _update_player_order(self) -> None: diff --git a/plugins/minigames/snake.py b/plugins/minigames/snake.py index 7252bfc..84e912b 100644 --- a/plugins/minigames/snake.py +++ b/plugins/minigames/snake.py @@ -1,4 +1,4 @@ -#snake +# snake # Released under the MIT License. See LICENSE for details. # """Snake game by SEBASTIAN2059""" @@ -18,50 +18,61 @@ from bastd.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): + + def __init__(self, player: Player): self.player = player - + def getplayer(self): return self.player + class Player(ba.Player['Team']): """Our player type for this game.""" + def __init__(self) -> None: - + self.mines = [] self.actived = None + class Team(ba.Team[Player]): """Our team type for this game.""" def __init__(self) -> None: self.score = 0 + lang = ba.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: + + 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, ba.HitMessage): return else: super().handlemessage(msg) # ba_meta export game + + class SnakeGame(ba.TeamGameActivity[Player, Team]): """A game type based on acquiring kills.""" @@ -122,17 +133,17 @@ class SnakeGame(ba.TeamGameActivity[Player, Team]): self._scoreboard = Scoreboard() self._score_to_win: Optional[int] = None self._dingsound = ba.getsound('dingSmall') - + self._beep_1_sound = ba.getsound('raceBeep1') self._beep_2_sound = ba.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 = (ba.MusicType.EPIC if self._epic_mode else @@ -151,14 +162,13 @@ class SnakeGame(ba.TeamGameActivity[Player, Team]): def on_begin(self) -> None: super().on_begin() self.setup_standard_time_limit(self._time_limit) - #self.setup_standard_powerup_drops() + # 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 @@ -220,10 +230,10 @@ class SnakeGame(ba.TeamGameActivity[Player, Team]): ba.playsound(self._beep_2_sound) self._started = True - + for player in self.players: self.generate_mines(player) - + # overriding the default character spawning.. def spawn_player(self, player: Player) -> ba.Actor: spaz = self.spawn_player_spaz(player) @@ -239,33 +249,30 @@ class SnakeGame(ba.TeamGameActivity[Player, Team]): if self._started: self.generate_mines(player) return spaz - - - def generate_mines(self,player: Player): + + def generate_mines(self, player: Player): try: - player.actived = ba.Timer(0.5,ba.Call(self.spawn_mine, player),repeat=True) + player.actived = ba.Timer(0.5, ba.Call(self.spawn_mine, player), repeat=True) except Exception as e: - print('Exception -> '+ str(e)) - - - - def spawn_mine(self,player: Player): + 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() + # 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) - + source_player=player.actor.source_player) + def arm(): mine.arm() - ba.timer(0.5,arm) - + ba.timer(0.5, arm) + player.mines.append(mine) if len(player.mines) > 15: for m in player.mines: @@ -275,9 +282,9 @@ class SnakeGame(ba.TeamGameActivity[Player, Team]): pass player.mines.remove(m) break - + self.handlemessage(ScoreMessage(player)) - + def handlemessage(self, msg: Any) -> Any: if isinstance(msg, ba.PlayerDiedMessage): @@ -286,18 +293,18 @@ class SnakeGame(ba.TeamGameActivity[Player, Team]): 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() #ba.timer(0.5, self.end_game) + self.end_game() # ba.timer(0.5, self.end_game) else: return super().handlemessage(msg) return None diff --git a/plugins/minigames/ufo_fight.py b/plugins/minigames/ufo_fight.py index 29c4571..4823904 100644 --- a/plugins/minigames/ufo_fight.py +++ b/plugins/minigames/ufo_fight.py @@ -15,7 +15,8 @@ from __future__ import annotations import random from typing import TYPE_CHECKING -import ba, _ba +import ba +import _ba from bastd.actor.playerspaz import PlayerSpaz from bastd.actor.spaz import Spaz from bastd.actor.bomb import Blast, Bomb @@ -56,8 +57,6 @@ class RoboBot(StickyBot): highlight = (3, 3, 3) - - class UFO(ba.Actor): """ New AI for Boss @@ -252,8 +251,8 @@ class UFO(ba.Actor): 1.0 + i, lambda: self._bots.spawn_bot( RoboBot, pos=(self.node.position[0], - self.node.position[1] - 1, - self.node.position[2]), spawn_time=0.0 + self.node.position[1] - 1, + self.node.position[2]), spawn_time=0.0 ), ) else: @@ -299,7 +298,6 @@ class UFO(ba.Actor): node.position[2], 0, 5, 0, 3, 10, 0, 0, 0, 5, 0) - except: pass @@ -314,7 +312,6 @@ class UFO(ba.Actor): if not self.node: return None - damage = abs(msg.magnitude) if msg.hit_type == 'explosion': damage /= 20 @@ -326,7 +323,7 @@ class UFO(ba.Actor): self.handlemessage(ba.DieMessage()) def _get_target_player_pt(self) -> tuple[ - ba.Vec3 | None, ba.Vec3 | None]: + ba.Vec3 | None, ba.Vec3 | None]: """Returns the position and velocity of our target. Both values will be None in the case of no target. @@ -519,7 +516,6 @@ class UFO(ba.Actor): {0: self.shield_deco.color, 0.2: (5, 0.2, 0.2)}) self.bot_count = 6 - def update_ai(self) -> None: """Should be called periodically to update the spaz' AI.""" # pylint: disable=too-many-branches @@ -572,9 +568,9 @@ class UFO(ba.Actor): self.to_target.y, self.to_target.z * self.xz_pos)) setattr(self.node, 'extra_acceleration', - (self.to_target.x * self.xz_pos , + (self.to_target.x * self.xz_pos, self.to_target.y * 80 + 70, - self.to_target.z * self.xz_pos)) + self.to_target.z * self.xz_pos)) def on_expire(self) -> None: super().on_expire() @@ -656,7 +652,6 @@ class UFO(ba.Actor): self.xz_pos = 0.01 self.node.reflection_scale = [2] - def unfrozen(): self.frozen = False if self.bot_dur_froze: @@ -666,7 +661,6 @@ class UFO(ba.Actor): self.xz_pos = 1 self.node.reflection_scale = [0.25] - ba.timer(5.0, unfrozen) else: @@ -710,8 +704,8 @@ class UFOSet: + str(self._ufo_bot_lists[self._ufo_bot_update_list]) ) self._bot_update_list = ( - self._ufo_bot_update_list + 1 - ) % self._ufo_bot_list_count + self._ufo_bot_update_list + 1 + ) % self._ufo_bot_list_count # Update our list of player points for the bots to use. player_pts = [] @@ -784,7 +778,7 @@ class UFOSet: """Add a ba.SpazBot instance to the set.""" self._ufo_bot_lists[self._ufo_bot_add_list].append(bot) self._ufo_bot_add_list = ( - self._ufo_bot_add_list + 1) % self._ufo_bot_list_count + self._ufo_bot_add_list + 1) % self._ufo_bot_list_count def have_living_bots(self) -> bool: """Return whether any bots in the set are alive or spawning.""" @@ -859,18 +853,16 @@ class UFOightGame(ba.TeamGameActivity[Player, Team]): self._bots = UFOSet() self._preset = str(settings['preset']) self._credit = ba.newnode('text', - attrs={ - 'v_attach': 'bottom', - 'h_align': 'center', - 'color': (0.4, 0.4, 0.4), - 'flatness': 0.5, - 'shadow': 0.5, - 'position': (0, 20), - 'scale': 0.7, - 'text': 'By Cross Joy' - }) - - + attrs={ + 'v_attach': 'bottom', + 'h_align': 'center', + 'color': (0.4, 0.4, 0.4), + 'flatness': 0.5, + 'shadow': 0.5, + 'position': (0, 20), + 'scale': 0.7, + 'text': 'By Cross Joy' + }) def on_transition_in(self) -> None: super().on_transition_in() @@ -882,8 +874,6 @@ class UFOightGame(ba.TeamGameActivity[Player, Team]): super().on_begin() self.setup_standard_powerup_drops() - - # In pro mode there's no powerups. # Make our on-screen timer and start it roughly when our bots appear. @@ -991,4 +981,3 @@ class MyUFOFightLevel(ba.Plugin): preview_texture_name='footballStadiumPreview', ) ) - diff --git a/plugins/minigames/yeeting_party.py b/plugins/minigames/yeeting_party.py index 8ae6721..a5e79a0 100644 --- a/plugins/minigames/yeeting_party.py +++ b/plugins/minigames/yeeting_party.py @@ -1,4 +1,4 @@ -#Made by your friend: @[Just] Freak#4999 +# Made by your friend: @[Just] Freak#4999 # ba_meta require api 7 from __future__ import annotations @@ -116,34 +116,36 @@ class BoxingGame(ba.TeamGameActivity[Player, Team]): def on_team_join(self, team: Team) -> None: if self.has_begun(): self._update_scoreboard() + def getRandomPowerupPoint(self) -> None: myMap = self.map.getname() if myMap == 'Doom Shroom': while True: - x = random.uniform(-1.0,1.0) - y = random.uniform(-1.0,1.0) - if x*x+y*y < 1.0: break - return ((8.0*x,2.5,-3.5+5.0*y)) + x = random.uniform(-1.0, 1.0) + y = random.uniform(-1.0, 1.0) + if x*x+y*y < 1.0: + break + return ((8.0*x, 2.5, -3.5+5.0*y)) elif myMap == 'Rampage': - x = random.uniform(-6.0,7.0) - y = random.uniform(-6.0,-2.5) + x = random.uniform(-6.0, 7.0) + y = random.uniform(-6.0, -2.5) return ((x, 5.2, y)) else: - x = random.uniform(-5.0,5.0) - y = random.uniform(-6.0,0.0) + x = random.uniform(-5.0, 5.0) + y = random.uniform(-6.0, 0.0) return ((x, 8.0, y)) def on_begin(self) -> None: super().on_begin() - ba.screenmessage("start Yeeting",color = (0.2,1,1)) + ba.screenmessage("start Yeeting", color=(0.2, 1, 1)) self.setup_standard_time_limit(self._time_limit) # 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() - + def spawn_player(self, player: Player) -> ba.Actor: - + spaz = self.spawn_player_spaz(player) # Let's reconnect this player's controls to this