diff --git a/plugins/minigames/arms_race.py b/plugins/minigames/arms_race.py index 6f7351b..7710c2a 100644 --- a/plugins/minigames/arms_race.py +++ b/plugins/minigames/arms_race.py @@ -1,9 +1,10 @@ -# Ported by: Freaku / @[Just] Freak#4999 +# Ported by your friend: Freaku -# Join BCS: +#Join BCS: # https://discord.gg/ucyaesh + # ba_meta require api 8 from __future__ import annotations @@ -11,7 +12,6 @@ from __future__ import annotations from typing import TYPE_CHECKING import babase -import bauiv1 as bui import bascenev1 as bs from bascenev1lib.actor.playerspaz import PlayerSpaz @@ -19,6 +19,7 @@ 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 +36,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,18 +49,16 @@ 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(bs.Player['Team']): """Our player type for this game.""" - def __init__(self): self.state = None @@ -193,4 +192,4 @@ class ArmsRaceGame(bs.TeamGameActivity[Player, Team]): results = bs.GameResults() for team in self.teams: results.set_team_score(team, team.score) - self.end(results=results) + self.end(results=results) \ No newline at end of file diff --git a/plugins/minigames/frozen_one.py b/plugins/minigames/frozen_one.py new file mode 100644 index 0000000..7bfbe65 --- /dev/null +++ b/plugins/minigames/frozen_one.py @@ -0,0 +1,18 @@ +# Ported by your friend: Freaku + + +import babase +import bascenev1 as bs +from bascenev1lib.game.chosenone import Player, ChosenOneGame + + +# ba_meta require api 8 +# ba_meta export bascenev1.GameActivity +class FrozenOneGame(ChosenOneGame): + name = 'Frozen One' + + def _set_chosen_one_player(self, player: Player) -> None: + super()._set_chosen_one_player(player) + if hasattr(player, 'actor'): + player.actor.frozen = True + player.actor.node.frozen = 1 \ No newline at end of file diff --git a/plugins/minigames/icy_emits.py b/plugins/minigames/icy_emits.py new file mode 100644 index 0000000..50a883c --- /dev/null +++ b/plugins/minigames/icy_emits.py @@ -0,0 +1,46 @@ +# Made by your friend: Freaku + + +import babase +import bascenev1 as bs, random +from bascenev1lib.actor.bomb import Bomb +from bascenev1lib.game.meteorshower import Player, MeteorShowerGame + + +# ba_meta require api 8 +# ba_meta export bascenev1.GameActivity +class IcyEmitsGame(MeteorShowerGame): + name = 'Icy Emits' + + @classmethod + def get_supported_maps(cls, sessiontype): + return ['Lake Frigid','Hockey Stadium'] + + def _drop_bomb_cluster(self) -> None: + delay = 0.0 + for _i in range(random.randrange(1, 3)): + # Drop them somewhere within our bounds with velocity pointing + # toward the opposite side. + pos = (-7.3 + 15.3 * random.random(), 5.3, + -5.5 + 2.1 * random.random()) + dropdir = (-1.0 if pos[0] > 0 else 1.0) + vel = (0,10,0) + bs.timer(delay, babase.Call(self._drop_bomb, pos, vel)) + delay += 0.1 + self._set_meteor_timer() + + def _drop_bomb(self, position, velocity): + random_xpositions = [-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9,10] + random_zpositions = [-5,-4.5,-4,-3.5,-3,-2.5,-2,-1.5,-1,-0.5,0,0.5,1,1.5,2,2.5,3,3.5,4,4.5,5] + bomb_position = (random.choice(random_xpositions), 0.2,random.choice(random_zpositions)) + Bomb(position=bomb_position, velocity=velocity, bomb_type = 'ice').autoretain() + + + + +# ba_meta export plugin +class byFreaku(babase.Plugin): + def __init__(self): + ## Campaign support ## + randomPic = ['lakeFrigidPreview','hockeyStadiumPreview'] + babase.app.classic.add_coop_practice_level(bs.Level(name='Icy Emits', displayname='${GAME}', gametype=IcyEmitsGame, settings={}, preview_texture_name=random.choice(randomPic))) \ No newline at end of file diff --git a/plugins/minigames/memory_game.py b/plugins/minigames/memory_game.py index c5c0204..a433eec 100644 --- a/plugins/minigames/memory_game.py +++ b/plugins/minigames/memory_game.py @@ -2,7 +2,7 @@ from __future__ import annotations ## Original creator: byANG3L ## -## Made by: Freaku / @[Just] Freak#4999 ## +## Made by: Freaku ## ## From: BSWorld Modpack (https://youtu.be/1TN56NLlShE) ## @@ -12,77 +12,70 @@ from __future__ import annotations # (& some improvements) + + + + # incase someone is wondering how is map floating. Check out # def spawnAllMap(self) -# ba_meta require api 7 + +# ba_meta require api 8 from typing import TYPE_CHECKING, overload -import _ba -import ba -import random -from bastd.gameutils import SharedObjects +import _babase, babase, random +import bascenev1 as bs +from bascenev1lib.gameutils import SharedObjects if TYPE_CHECKING: from typing import Any, Sequence, Optional, List, Dict, Type, Union, Any, Literal -class OnTimer(ba.Actor): - """Timer which counts but doesn't show on-screen""" + +class OnTimer(bs.Actor): + """Timer which counts but doesn't show on-screen""" def __init__(self) -> None: super().__init__() - self._starttime_ms: Optional[int] = None - self.node = ba.newnode('text', attrs={'v_attach': 'top', 'h_attach': 'center', 'h_align': 'center', 'color': ( - 1, 1, 0.5, 1), 'flatness': 0.5, 'shadow': 0.5, 'position': (0, -70), 'scale': 0, 'text': ''}) - self.inputnode = ba.newnode('timedisplay', attrs={ - 'timemin': 0, 'showsubseconds': True}) + self._starttime_ms: int | None = None + self.node = bs.newnode('text', attrs={ 'v_attach': 'top', 'h_attach': 'center', 'h_align': 'center', 'color': (1, 1, 0.5, 1), 'flatness': 0.5, 'shadow': 0.5, 'position': (0, -70), 'scale': 0, 'text': ''}) + self.inputnode = bs.newnode( + 'timedisplay', attrs={'timemin': 0, 'showsubseconds': True} + ) self.inputnode.connectattr('output', self.node, 'text') def start(self) -> None: - tval = ba.time(timeformat=ba.TimeFormat.MILLISECONDS) + """Start the timer.""" + tval = int(bs.time() * 1000.0) assert isinstance(tval, int) self._starttime_ms = tval self.inputnode.time1 = self._starttime_ms - ba.getactivity().globalsnode.connectattr('time', self.inputnode, 'time2') + bs.getactivity().globalsnode.connectattr( + 'time', self.inputnode, 'time2' + ) def has_started(self) -> bool: + """Return whether this timer has started yet.""" return self._starttime_ms is not None - def stop(self, - endtime: Union[int, float] = None, - timeformat: ba.TimeFormat = ba.TimeFormat.SECONDS) -> None: + def stop(self, endtime: int | float | None = None) -> None: + """End the timer. + + If 'endtime' is not None, it is used when calculating + the final display time; otherwise the current time is used. + """ if endtime is None: - endtime = ba.time(timeformat=ba.TimeFormat.MILLISECONDS) - timeformat = ba.TimeFormat.MILLISECONDS + endtime = bs.time() + if self._starttime_ms is None: - print('Warning: OnTimer.stop() called without start() first') + logging.warning( + 'OnScreenTimer.stop() called without first calling start()' + ) else: - endtime_ms: int - if timeformat is ba.TimeFormat.SECONDS: - endtime_ms = int(endtime * 1000) - elif timeformat is ba.TimeFormat.MILLISECONDS: - assert isinstance(endtime, int) - endtime_ms = endtime - else: - raise ValueError(f'invalid timeformat: {timeformat}') - + endtime_ms = int(endtime * 1000) self.inputnode.timemax = endtime_ms - self._starttime_ms - # Overloads so type checker knows our exact return type based in args. - @overload - def getstarttime(self, timeformat: Literal[ba.TimeFormat.SECONDS] = ba.TimeFormat.SECONDS) -> float: - ... - - @overload - def getstarttime(self, - timeformat: Literal[ba.TimeFormat.MILLISECONDS]) -> int: - ... - - def getstarttime( - self, - timeformat: ba.TimeFormat = ba.TimeFormat.SECONDS - ) -> Union[int, float]: - """Return the sim-time when start() was called. + def getstarttime(self) -> float: + """Return the scene-time when start() was called. Time will be returned in seconds if timeformat is SECONDS or milliseconds if it is MILLISECONDS. @@ -90,15 +83,11 @@ class OnTimer(ba.Actor): val_ms: Any if self._starttime_ms is None: print('WARNING: getstarttime() called on un-started timer') - val_ms = ba.time(timeformat=ba.TimeFormat.MILLISECONDS) + val_ms = int(bs.time() * 1000.0) else: val_ms = self._starttime_ms assert isinstance(val_ms, int) - if timeformat is ba.TimeFormat.SECONDS: - return 0.001 * val_ms - if timeformat is ba.TimeFormat.MILLISECONDS: - return val_ms - raise ValueError(f'invalid timeformat: {timeformat}') + return 0.001 * val_ms @property def starttime(self) -> float: @@ -107,12 +96,14 @@ class OnTimer(ba.Actor): def handlemessage(self, msg: Any) -> Any: # if we're asked to die, just kill our node/timer - if isinstance(msg, ba.DieMessage): + if isinstance(msg, bs.DieMessage): if self.node: self.node.delete() -class Player(ba.Player['Team']): + + +class Player(bs.Player['Team']): """Our player type for this game.""" def __init__(self) -> None: @@ -120,33 +111,32 @@ class Player(ba.Player['Team']): self.death_time: Optional[float] = None -class Team(ba.Team[Player]): +class Team(bs.Team[Player]): """Our team type for this game.""" -# ba_meta export game -class MGgame(ba.TeamGameActivity[Player, Team]): +# ba_meta export bascenev1.GameActivity +class MGgame(bs.TeamGameActivity[Player, Team]): name = 'Memory Game' description = 'Memories tiles and survive till the end!' - available_settings = [ba.BoolSetting( - 'Epic Mode', default=False), ba.BoolSetting('Enable Bottom Credits', True)] - scoreconfig = ba.ScoreConfig(label='Survived', scoretype=ba.ScoreType.MILLISECONDS, version='B') + available_settings = [bs.BoolSetting('Epic Mode', default=False), bs.BoolSetting('Enable Bottom Credits', True)] + scoreconfig = bs.ScoreConfig(label='Survived', scoretype=bs.ScoreType.MILLISECONDS, version='B') # Print messages when players die (since its meaningful in this game). announce_player_deaths = True # we're currently hard-coded for one map.. @classmethod - def get_supported_maps(cls, sessiontype: Type[ba.Session]) -> List[str]: + def get_supported_maps(cls, sessiontype: Type[bs.Session]) -> List[str]: return ['Sky Tiles'] # We support teams, free-for-all, and co-op sessions. @classmethod - def supports_session_type(cls, sessiontype: Type[ba.Session]) -> bool: - return (issubclass(sessiontype, ba.DualTeamSession) - or issubclass(sessiontype, ba.FreeForAllSession) - or issubclass(sessiontype, ba.CoopSession)) + def supports_session_type(cls, sessiontype: Type[bs.Session]) -> bool: + return (issubclass(sessiontype, bs.DualTeamSession) + or issubclass(sessiontype, bs.FreeForAllSession) + or issubclass(sessiontype, babase.CoopSession)) def __init__(self, settings: dict): super().__init__(settings) @@ -157,14 +147,14 @@ class MGgame(ba.TeamGameActivity[Player, Team]): self.credit_text = bool(settings['Enable Bottom Credits']) # Some base class overrides: - self.default_music = (ba.MusicType.EPIC - if self._epic_mode else ba.MusicType.SURVIVAL) + self.default_music = (bs.MusicType.EPIC + if self._epic_mode else bs.MusicType.SURVIVAL) if self._epic_mode: self.slow_motion = True shared = SharedObjects.get() - self._collide_with_player = ba.Material() + self._collide_with_player=bs.Material() self._collide_with_player.add_actions(actions=(('modify_part_collision', 'collide', True))) - self.dont_collide = ba.Material() + self.dont_collide=bs.Material() self.dont_collide.add_actions(actions=(('modify_part_collision', 'collide', False))) self._levelStage = 0 @@ -172,100 +162,101 @@ class MGgame(ba.TeamGameActivity[Player, Team]): self._lastPlayerDeathTime = None self._spawnCenter = (-3.17358, 2.75764, -2.99124) - self._mapFGPModel = ba.getmodel('buttonSquareOpaque') - self._mapFGPDefaultTex = ba.gettexture('achievementOffYouGo') + self._mapFGPModel = bs.getmesh('buttonSquareOpaque') + self._mapFGPDefaultTex = bs.gettexture('achievementOffYouGo') - self._mapFGCurseTex = ba.gettexture('powerupCurse') - self._mapFGHealthTex = ba.gettexture('powerupHealth') - self._mapFGIceTex = ba.gettexture('powerupIceBombs') - self._mapFGImpactTex = ba.gettexture('powerupImpactBombs') - self._mapFGMinesTex = ba.gettexture('powerupLandMines') - self._mapFGPunchTex = ba.gettexture('powerupPunch') - self._mapFGShieldTex = ba.gettexture('powerupShield') - self._mapFGStickyTex = ba.gettexture('powerupStickyBombs') + self._mapFGCurseTex = bs.gettexture('powerupCurse') + self._mapFGHealthTex = bs.gettexture('powerupHealth') + self._mapFGIceTex = bs.gettexture('powerupIceBombs') + self._mapFGImpactTex = bs.gettexture('powerupImpactBombs') + self._mapFGMinesTex = bs.gettexture('powerupLandMines') + self._mapFGPunchTex = bs.gettexture('powerupPunch') + self._mapFGShieldTex = bs.gettexture('powerupShield') + self._mapFGStickyTex = bs.gettexture('powerupStickyBombs') - self._mapFGSpaz = ba.gettexture('neoSpazIcon') - self._mapFGZoe = ba.gettexture('zoeIcon') - self._mapFGSnake = ba.gettexture('ninjaIcon') - self._mapFGKronk = ba.gettexture('kronkIcon') - self._mapFGMel = ba.gettexture('melIcon') - self._mapFGJack = ba.gettexture('jackIcon') - self._mapFGSanta = ba.gettexture('santaIcon') - self._mapFGFrosty = ba.gettexture('frostyIcon') - self._mapFGBones = ba.gettexture('bonesIcon') - self._mapFGBernard = ba.gettexture('bearIcon') - self._mapFGPascal = ba.gettexture('penguinIcon') - self._mapFGAli = ba.gettexture('aliIcon') - self._mapFGRobot = ba.gettexture('cyborgIcon') - self._mapFGAgent = ba.gettexture('agentIcon') - self._mapFGGrumbledorf = ba.gettexture('wizardIcon') - self._mapFGPixel = ba.gettexture('pixieIcon') + self._mapFGSpaz = bs.gettexture('neoSpazIcon') + self._mapFGZoe = bs.gettexture('zoeIcon') + self._mapFGSnake = bs.gettexture('ninjaIcon') + self._mapFGKronk= bs.gettexture('kronkIcon') + self._mapFGMel = bs.gettexture('melIcon') + self._mapFGJack = bs.gettexture('jackIcon') + self._mapFGSanta = bs.gettexture('santaIcon') + self._mapFGFrosty = bs.gettexture('frostyIcon') + self._mapFGBones = bs.gettexture('bonesIcon') + self._mapFGBernard = bs.gettexture('bearIcon') + self._mapFGPascal = bs.gettexture('penguinIcon') + self._mapFGAli = bs.gettexture('aliIcon') + self._mapFGRobot = bs.gettexture('cyborgIcon') + self._mapFGAgent = bs.gettexture('agentIcon') + self._mapFGGrumbledorf = bs.gettexture('wizardIcon') + self._mapFGPixel = bs.gettexture('pixieIcon') - self._imageTextDefault = ba.gettexture('bg') - self._circleTex = ba.gettexture('circleShadow') + self._imageTextDefault = bs.gettexture('bg') + self._circleTex = bs.gettexture('circleShadow') - self._image = ba.newnode('image', - attrs={'texture': self._imageTextDefault, - 'position': (0, -100), - 'scale': (100, 100), - 'opacity': 0.0, - 'attach': 'topCenter'}) + self._image = bs.newnode('image', + attrs={'texture': self._imageTextDefault, + 'position':(0,-100), + 'scale':(100,100), + 'opacity': 0.0, + 'attach':'topCenter'}) - self._textCounter = ba.newnode('text', - attrs={'text': '10', - 'position': (0, -100), - 'scale': 2.3, - 'shadow': 1.0, - 'flatness': 1.0, - 'opacity': 0.0, - 'v_attach': 'top', - 'h_attach': 'center', - 'h_align': 'center', - 'v_align': 'center'}) + self._textCounter = bs.newnode('text', + attrs={'text': '10', + 'position': (0, -100), + 'scale': 2.3, + 'shadow': 1.0, + 'flatness': 1.0, + 'opacity': 0.0, + 'v_attach': 'top', + 'h_attach': 'center', + 'h_align': 'center', + 'v_align': 'center'}) - self._textLevel = ba.newnode('text', - attrs={'text': 'Level ' + str(self._levelStage), - 'position': (0, -28), - 'scale': 1.3, - 'shadow': 1.0, - 'flatness': 1.0, - 'color': (1.0, 0.0, 1.0), - 'opacity': 0.0, - 'v_attach': 'top', - 'h_attach': 'center', - 'h_align': 'center', - 'v_align': 'center'}) + self._textLevel = bs.newnode('text', + attrs={'text': 'Level ' + str(self._levelStage), + 'position': (0, -28), + 'scale': 1.3, + 'shadow': 1.0, + 'flatness': 1.0, + 'color': (1.0, 0.0, 1.0), + 'opacity': 0.0, + 'v_attach': 'top', + 'h_attach': 'center', + 'h_align': 'center', + 'v_align': 'center'}) + + self._imageCircle = bs.newnode('image', + attrs={'texture': self._circleTex, + 'position': (75, -75), + 'scale': (20,20), + 'color': (0.2, 0.2, 0.2), + 'opacity': 0.0, + 'attach': 'topCenter'}) + self._imageCircle2 = bs.newnode('image', + attrs={'texture': self._circleTex, + 'position': (75, -100), + 'scale': (20,20), + 'color': (0.2, 0.2, 0.2), + 'opacity': 0.0, + 'attach': 'topCenter'}) + self._imageCircle3 = bs.newnode('image', + attrs={'texture': self._circleTex, + 'position': (75, -125), + 'scale': (20,20), + 'color': (0.2, 0.2, 0.2), + 'opacity': 0.0, + 'attach': 'topCenter'}) - self._imageCircle = ba.newnode('image', - attrs={'texture': self._circleTex, - 'position': (75, -75), - 'scale': (20, 20), - 'color': (0.2, 0.2, 0.2), - 'opacity': 0.0, - 'attach': 'topCenter'}) - self._imageCircle2 = ba.newnode('image', - attrs={'texture': self._circleTex, - 'position': (75, -100), - 'scale': (20, 20), - 'color': (0.2, 0.2, 0.2), - 'opacity': 0.0, - 'attach': 'topCenter'}) - self._imageCircle3 = ba.newnode('image', - attrs={'texture': self._circleTex, - 'position': (75, -125), - 'scale': (20, 20), - 'color': (0.2, 0.2, 0.2), - 'opacity': 0.0, - 'attach': 'topCenter'}) def on_transition_in(self) -> None: super().on_transition_in() - self._bellLow = ba.getsound('bellLow') - self._bellMed = ba.getsound('bellMed') - self._bellHigh = ba.getsound('bellHigh') - self._tickSound = ba.getsound('tick') - self._tickFinal = ba.getsound('powerup01') - self._scoreSound = ba.getsound('score') + self._bellLow = bs.getsound('bellLow') + self._bellMed = bs.getsound('bellMed') + self._bellHigh = bs.getsound('bellHigh') + self._tickSound = bs.getsound('tick') + self._tickFinal = bs.getsound('powerup01') + self._scoreSound = bs.getsound('score') self._image.opacity = 1 self._textCounter.opacity = 1 @@ -282,8 +273,8 @@ class MGgame(ba.TeamGameActivity[Player, Team]): if self._levelStage == 1: timeStart = 6 - ba.timer(timeStart, self._randomPlatform) - ba.timer(timeStart, self.startCounter) + bs.timer(timeStart, self._randomPlatform) + bs.timer(timeStart, self.startCounter) def on_begin(self) -> None: super().on_begin() @@ -308,26 +299,25 @@ class MGgame(ba.TeamGameActivity[Player, Team]): self.coldel15 = True self.coldel16 = True if self.credit_text: - t = ba.newnode('text', - attrs={'text': "Made by Freaku\nOriginally for 1.4: byANG3L", # Disable 'Enable Bottom Credits' when making playlist, No need to edit this lovely... - 'scale': 0.7, - 'position': (0, 0), - 'shadow': 0.5, - 'flatness': 1.2, - 'color': (1, 1, 1), - 'h_align': 'center', - 'v_attach': 'bottom'}) - self.spawnAllMap() - self.flashHide() + t = bs.newnode('text', + attrs={ 'text':"Made by Freaku\nOriginally for 1.4: byANG3L", ## Disable 'Enable Bottom Credits' when making playlist, No need to edit this lovely... + 'scale':0.7, + 'position':(0,0), + 'shadow':0.5, + 'flatness':1.2, + 'color':(1, 1, 1), + 'h_align':'center', + 'v_attach':'bottom'}) + self.spawnAllMap() + self.flashHide() # Check for immediate end (if we've only got 1 player, etc). - ba.timer(5, self._check_end_game) - self._dingSound = ba.getsound('dingSmall') - self._dingSoundHigh = ba.getsound('dingSmallHigh') + bs.timer(5, self._check_end_game) + self._dingSound = bs.getsound('dingSmall') + self._dingSoundHigh = bs.getsound('dingSmallHigh') def startCounter(self): self._textCounter.text = '10' - def count9(): def count8(): def count7(): @@ -339,45 +329,45 @@ class MGgame(ba.TeamGameActivity[Player, Team]): def count1(): def countFinal(): self._textCounter.text = '' - ba.playsound(self._tickFinal) + self._tickFinal.play() self._stop() self._textCounter.text = '1' - ba.playsound(self._tickSound) - ba.timer(1, countFinal) + self._tickSound.play() + bs.timer(1, countFinal) self._textCounter.text = '2' - ba.playsound(self._tickSound) - ba.timer(1, count1) + self._tickSound.play() + bs.timer(1, count1) self._textCounter.text = '3' - ba.playsound(self._tickSound) - ba.timer(1, count2) + self._tickSound.play() + bs.timer(1, count2) self._textCounter.text = '4' - ba.playsound(self._tickSound) - ba.timer(1, count3) + self._tickSound.play() + bs.timer(1, count3) self._textCounter.text = '5' - ba.playsound(self._tickSound) - ba.timer(1, count4) + self._tickSound.play() + bs.timer(1, count4) self._textCounter.text = '6' - ba.playsound(self._tickSound) - ba.timer(1, count5) + self._tickSound.play() + bs.timer(1, count5) self._textCounter.text = '7' - ba.playsound(self._tickSound) - ba.timer(1, count6) + self._tickSound.play() + bs.timer(1, count6) self._textCounter.text = '8' - ba.playsound(self._tickSound) - ba.timer(1, count7) + self._tickSound.play() + bs.timer(1, count7) self._textCounter.text = '9' - ba.playsound(self._tickSound) - ba.timer(1, count8) - ba.timer(1, count9) + self._tickSound.play() + bs.timer(1, count8) + bs.timer(1, count9) def on_player_join(self, player: Player) -> None: # Don't allow joining after we start # (would enable leave/rejoin tomfoolery). if self.has_begun(): - ba.screenmessage( - ba.Lstr(resource='playerDelayedJoinText', + bs.broadcastmessage( + babase.Lstr(resource='playerDelayedJoinText', subs=[('${PLAYER}', player.getname(full=True))]), - color=(0, 1, 0), transient=True, clients=[player.sessionplayer.inputdevice.client_id]) + color=(0, 1, 0),transient=True,clients=[player.sessionplayer.inputdevice.client_id]) # For score purposes, mark them as having died right as the # game started. assert self._timer is not None @@ -393,184 +383,182 @@ class MGgame(ba.TeamGameActivity[Player, Team]): self._check_end_game() # overriding the default character spawning.. - def spawn_player(self, player: Player) -> ba.Actor: + def spawn_player(self, player: Player) -> bs.Actor: spaz = self.spawn_player_spaz(player) - pos = (self._spawnCenter[0] + random.uniform(-1.5, 2.5), - self._spawnCenter[1], self._spawnCenter[2] + random.uniform(-2.5, 1.5)) + pos = (self._spawnCenter[0] + random.uniform(-1.5, 2.5), self._spawnCenter[1], self._spawnCenter[2] + random.uniform(-2.5, 1.5)) spaz.connect_controls_to_player(enable_punch=False, enable_bomb=False, enable_pickup=False) - spaz.handlemessage(ba.StandMessage(pos)) + spaz.handlemessage(bs.StandMessage(pos)) return spaz def _randomSelect(self): if self._levelStage == 1: self._textureSelected = random.choice([self._mapFGMinesTex, - self._mapFGStickyTex]) + self._mapFGStickyTex]) self._image.texture = self._textureSelected elif self._levelStage == 2: self._textureSelected = random.choice([self._mapFGIceTex, - self._mapFGShieldTex]) + self._mapFGShieldTex]) self._image.texture = self._textureSelected - elif self._levelStage in [3, 4, 5]: + elif self._levelStage in [3,4,5]: self._textureSelected = random.choice([self._mapFGStickyTex, - self._mapFGIceTex, - self._mapFGImpactTex, - self._mapFGMinesTex]) + self._mapFGIceTex, + self._mapFGImpactTex, + self._mapFGMinesTex]) self._image.texture = self._textureSelected - elif self._levelStage in [6, 7, 8, 9]: + elif self._levelStage in [6,7,8,9]: self._textureSelected = random.choice([self._mapFGCurseTex, - self._mapFGHealthTex, - self._mapFGIceTex, - self._mapFGImpactTex, - self._mapFGMinesTex, - self._mapFGPunchTex, - self._mapFGShieldTex]) + self._mapFGHealthTex, + self._mapFGIceTex, + self._mapFGImpactTex, + self._mapFGMinesTex, + self._mapFGPunchTex, + self._mapFGShieldTex]) self._image.texture = self._textureSelected elif self._levelStage >= 10: self._textureSelected = random.choice([self._mapFGSpaz, - self._mapFGZoe, - self._mapFGSnake, - self._mapFGKronk, - self._mapFGMel, - self._mapFGJack, - self._mapFGSanta, - self._mapFGFrosty, - self._mapFGBones, - self._mapFGBernard, - self._mapFGPascal, - self._mapFGAli, - self._mapFGRobot, - self._mapFGAgent, - self._mapFGGrumbledorf, - self._mapFGPixel]) + self._mapFGZoe, + self._mapFGSnake, + self._mapFGKronk, + self._mapFGMel, + self._mapFGJack, + self._mapFGSanta, + self._mapFGFrosty, + self._mapFGBones, + self._mapFGBernard, + self._mapFGPascal, + self._mapFGAli, + self._mapFGRobot, + self._mapFGAgent, + self._mapFGGrumbledorf, + self._mapFGPixel]) self._image.texture = self._textureSelected return self._textureSelected def _stop(self): self._textureSelected = self._randomSelect() - def circle(): def circle2(): def circle3(): self._imageCircle3.color = (0.0, 1.0, 0.0) self._imageCircle3.opacity = 1.0 - ba.playsound(self._bellHigh) - ba.timer(0.2, self._doDelete) + self._bellHigh.play() + bs.timer(0.2, self._doDelete) self._imageCircle2.color = (1.0, 1.0, 0.0) self._imageCircle2.opacity = 1.0 - ba.playsound(self._bellMed) - ba.timer(1, circle3) + self._bellMed.play() + bs.timer(1, circle3) self._imageCircle.color = (1.0, 0.0, 0.0) self._imageCircle.opacity = 1.0 - ba.playsound(self._bellLow) - ba.timer(1, circle2) - ba.timer(1, circle) + self._bellLow.play() + bs.timer(1, circle2) + bs.timer(1, circle) def _randomPlatform(self): if self._levelStage == 1: - randomTexture = [self._mapFGMinesTex, - self._mapFGMinesTex, - self._mapFGMinesTex, - self._mapFGMinesTex, - self._mapFGMinesTex, - self._mapFGMinesTex, - self._mapFGMinesTex, - self._mapFGMinesTex, - self._mapFGStickyTex, - self._mapFGStickyTex, - self._mapFGStickyTex, - self._mapFGStickyTex, - self._mapFGStickyTex, - self._mapFGStickyTex, - self._mapFGStickyTex, - self._mapFGStickyTex] + randomTexture=[self._mapFGMinesTex, + self._mapFGMinesTex, + self._mapFGMinesTex, + self._mapFGMinesTex, + self._mapFGMinesTex, + self._mapFGMinesTex, + self._mapFGMinesTex, + self._mapFGMinesTex, + self._mapFGStickyTex, + self._mapFGStickyTex, + self._mapFGStickyTex, + self._mapFGStickyTex, + self._mapFGStickyTex, + self._mapFGStickyTex, + self._mapFGStickyTex, + self._mapFGStickyTex] elif self._levelStage == 2: - randomTexture = [self._mapFGIceTex, - self._mapFGIceTex, - self._mapFGIceTex, - self._mapFGIceTex, - self._mapFGIceTex, - self._mapFGIceTex, - self._mapFGIceTex, - self._mapFGIceTex, - self._mapFGShieldTex, - self._mapFGShieldTex, - self._mapFGShieldTex, - self._mapFGShieldTex, - self._mapFGShieldTex, - self._mapFGShieldTex, - self._mapFGShieldTex, - self._mapFGShieldTex] - elif self._levelStage in [3, 4, 5]: - randomTexture = [self._mapFGStickyTex, - self._mapFGStickyTex, - self._mapFGStickyTex, - self._mapFGStickyTex, - self._mapFGIceTex, - self._mapFGIceTex, - self._mapFGIceTex, - self._mapFGIceTex, - self._mapFGImpactTex, - self._mapFGImpactTex, - self._mapFGImpactTex, - self._mapFGImpactTex, - self._mapFGMinesTex, - self._mapFGMinesTex, - self._mapFGMinesTex, - self._mapFGMinesTex] - elif self._levelStage in [6, 7, 8, 9]: - randomTexture = [self._mapFGHealthTex, - self._mapFGShieldTex, - self._mapFGCurseTex, - self._mapFGCurseTex, - self._mapFGHealthTex, - self._mapFGHealthTex, - self._mapFGIceTex, - self._mapFGIceTex, - self._mapFGImpactTex, - self._mapFGImpactTex, - self._mapFGMinesTex, - self._mapFGMinesTex, - self._mapFGPunchTex, - self._mapFGPunchTex, - self._mapFGShieldTex, - self._mapFGShieldTex] + randomTexture=[self._mapFGIceTex, + self._mapFGIceTex, + self._mapFGIceTex, + self._mapFGIceTex, + self._mapFGIceTex, + self._mapFGIceTex, + self._mapFGIceTex, + self._mapFGIceTex, + self._mapFGShieldTex, + self._mapFGShieldTex, + self._mapFGShieldTex, + self._mapFGShieldTex, + self._mapFGShieldTex, + self._mapFGShieldTex, + self._mapFGShieldTex, + self._mapFGShieldTex] + elif self._levelStage in [3,4,5]: + randomTexture=[self._mapFGStickyTex, + self._mapFGStickyTex, + self._mapFGStickyTex, + self._mapFGStickyTex, + self._mapFGIceTex, + self._mapFGIceTex, + self._mapFGIceTex, + self._mapFGIceTex, + self._mapFGImpactTex, + self._mapFGImpactTex, + self._mapFGImpactTex, + self._mapFGImpactTex, + self._mapFGMinesTex, + self._mapFGMinesTex, + self._mapFGMinesTex, + self._mapFGMinesTex] + elif self._levelStage in [6,7,8,9]: + randomTexture=[self._mapFGHealthTex, + self._mapFGShieldTex, + self._mapFGCurseTex, + self._mapFGCurseTex, + self._mapFGHealthTex, + self._mapFGHealthTex, + self._mapFGIceTex, + self._mapFGIceTex, + self._mapFGImpactTex, + self._mapFGImpactTex, + self._mapFGMinesTex, + self._mapFGMinesTex, + self._mapFGPunchTex, + self._mapFGPunchTex, + self._mapFGShieldTex, + self._mapFGShieldTex] elif self._levelStage >= 10: - randomTexture = [self._mapFGSpaz, - self._mapFGZoe, - self._mapFGSnake, - self._mapFGKronk, - self._mapFGMel, - self._mapFGJack, - self._mapFGSanta, - self._mapFGFrosty, - self._mapFGBones, - self._mapFGBernard, - self._mapFGPascal, - self._mapFGAli, - self._mapFGRobot, - self._mapFGAgent, - self._mapFGGrumbledorf, - self._mapFGPixel] + randomTexture=[self._mapFGSpaz, + self._mapFGZoe, + self._mapFGSnake, + self._mapFGKronk, + self._mapFGMel, + self._mapFGJack, + self._mapFGSanta, + self._mapFGFrosty, + self._mapFGBones, + self._mapFGBernard, + self._mapFGPascal, + self._mapFGAli, + self._mapFGRobot, + self._mapFGAgent, + self._mapFGGrumbledorf, + self._mapFGPixel] (self.mapFGPTex, self.mapFGP2Tex, self.mapFGP3Tex, self.mapFGP4Tex, - self.mapFGP5Tex, self.mapFGP6Tex, - self.mapFGP7Tex, self.mapFGP8Tex, - self.mapFGP9Tex, self.mapFGP10Tex, - self.mapFGP11Tex, self.mapFGP12Tex, - self.mapFGP13Tex, self.mapFGP14Tex, - self.mapFGP15Tex, self.mapFGP16Tex) = ( - random.sample(randomTexture, 16)) + self.mapFGP5Tex, self.mapFGP6Tex, + self.mapFGP7Tex, self.mapFGP8Tex, + self.mapFGP9Tex,self.mapFGP10Tex, + self.mapFGP11Tex, self.mapFGP12Tex, + self.mapFGP13Tex, self.mapFGP14Tex, + self.mapFGP15Tex, self.mapFGP16Tex) = ( + random.sample(randomTexture, 16)) self._mixPlatform() def _mixPlatform(self): - ba.timer(1, self.flashShow) - ba.timer(3, self.flashHide) - ba.timer(4, self.flashShow) - ba.timer(6, self.flashHide) - ba.timer(7, self.flashShow) - ba.timer(9, self.flashHide) - ba.timer(13.2, self.flashShow) + bs.timer(1, self.flashShow) + bs.timer(3, self.flashHide) + bs.timer(4, self.flashShow) + bs.timer(6, self.flashHide) + bs.timer(7, self.flashShow) + bs.timer(9, self.flashHide) + bs.timer(13.2, self.flashShow) def flashHide(self): self.mapFGP.color_texture = self._mapFGPDefaultTex @@ -674,14 +662,14 @@ class MGgame(ba.TeamGameActivity[Player, Team]): self.mapFGP16col.delete() self.coldel16 = True - ba.timer(3.3, self._platformTexDefault) + bs.timer(3.3, self._platformTexDefault) def spawnAllMap(self): """ # Here's how it works: # First, create prop with a gravity scale of 0 - # Then use a in-game model which will suit it (For this one I didn't chose box, since it will look kinda weird) Right? - # Instead I used a 2d model (which is nothing but a button in menu) + # Then use a in-game mesh which will suit it (For this one I didn't chose box, since it will look kinda weird) Right? + # Instead I used a 2d mesh (which is nothing but a button in menu) # This prop SHOULD NOT collide with anything, since it has gravity_scale of 0 if it'll get weight it will fall down :(( # These are where we change those color-textures and is seen in-game @@ -696,131 +684,115 @@ class MGgame(ba.TeamGameActivity[Player, Team]): """ shared = SharedObjects.get() if self.coldel: - self.mapFGP = ba.newnode('prop', - attrs={'body': 'puck', 'position': (3, 2, -9), 'model': self._mapFGPModel, 'model_scale': 3.8, 'body_scale': 3.8, 'shadow_size': 0.5, 'gravity_scale': 0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) + self.mapFGP = bs.newnode('prop', + attrs={'body': 'puck', 'position': (4.5,2,-9), 'mesh': self._mapFGPModel, 'mesh_scale': 3.73, 'body_scale': 3.73, 'shadow_size': 0.5, 'gravity_scale':0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) self.mapFGPTex = None - self.mapFGPcol = ba.newnode('region', attrs={'position': (3, 2, -9), 'scale': ( - 3.5, 0.1, 3.5), 'type': 'box', 'materials': (self._collide_with_player, shared.footing_material)}) + self.mapFGPcol = bs.newnode('region',attrs={'position': (4.5,2,-9),'scale': (3.5,0.1,3.5),'type': 'box','materials': (self._collide_with_player, shared.footing_material)}) self.coldel = False if self.coldel2: - self.mapFGP2 = ba.newnode('prop', - attrs={'body': 'puck', 'position': (3, 2, -6), 'model': self._mapFGPModel, 'model_scale': 3.8, 'body_scale': 3.8, 'shadow_size': 0.5, 'gravity_scale': 0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) + self.mapFGP2 = bs.newnode('prop', + attrs={'body': 'puck', 'position': (4.5,2,-6), 'mesh': self._mapFGPModel, 'mesh_scale': 3.73, 'body_scale': 3.73, 'shadow_size': 0.5, 'gravity_scale':0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) self.mapFGP2Tex = None - self.mapFGP2col = ba.newnode('region', attrs={'position': (3, 2, -6), 'scale': ( - 3.5, 0.1, 3.5), 'type': 'box', 'materials': (self._collide_with_player, shared.footing_material)}) + self.mapFGP2col = bs.newnode('region',attrs={'position': (4.5,2,-6),'scale': (3.5,0.1,3.5),'type': 'box','materials': (self._collide_with_player, shared.footing_material)}) self.coldel2 = False if self.coldel3: - self.mapFGP3 = ba.newnode('prop', - attrs={'body': 'puck', 'position': (3, 2, -3), 'model': self._mapFGPModel, 'model_scale': 3.8, 'body_scale': 3.8, 'shadow_size': 0.5, 'gravity_scale': 0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) + self.mapFGP3 = bs.newnode('prop', + attrs={'body': 'puck', 'position': (4.5,2,-3), 'mesh': self._mapFGPModel, 'mesh_scale': 3.73, 'body_scale': 3.73, 'shadow_size': 0.5, 'gravity_scale':0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) self.mapFGP3Tex = None - self.mapFGP3col = ba.newnode('region', attrs={'position': (3, 2, -3), 'scale': ( - 3.5, 0.1, 3.5), 'type': 'box', 'materials': (self._collide_with_player, shared.footing_material)}) + self.mapFGP3col = bs.newnode('region',attrs={'position': (4.5,2,-3),'scale': (3.5,0.1,3.5),'type': 'box','materials': (self._collide_with_player, shared.footing_material)}) self.coldel3 = False if self.coldel4: - self.mapFGP4 = ba.newnode('prop', - attrs={'body': 'puck', 'position': (3, 2, 0), 'model': self._mapFGPModel, 'model_scale': 3.8, 'body_scale': 3.8, 'shadow_size': 0.5, 'gravity_scale': 0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) + self.mapFGP4 = bs.newnode('prop', + attrs={'body': 'puck', 'position': (4.5,2,0), 'mesh': self._mapFGPModel, 'mesh_scale': 3.73, 'body_scale': 3.73, 'shadow_size': 0.5, 'gravity_scale':0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) self.mapFGP4Tex = None - self.mapFGP4col = ba.newnode('region', attrs={'position': (3, 2, 0), 'scale': ( - 3.5, 0.1, 3.5), 'type': 'box', 'materials': (self._collide_with_player, shared.footing_material)}) + self.mapFGP4col = bs.newnode('region',attrs={'position': (4.5,2,0),'scale': (3.5,0.1,3.5),'type': 'box','materials': (self._collide_with_player, shared.footing_material)}) self.coldel4 = False if self.coldel5: - self.mapFGP5 = ba.newnode('prop', - attrs={'body': 'puck', 'position': (0, 2, -9), 'model': self._mapFGPModel, 'model_scale': 3.8, 'body_scale': 3.8, 'shadow_size': 0.5, 'gravity_scale': 0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) + self.mapFGP5 = bs.newnode('prop', + attrs={'body': 'puck', 'position': (1.5,2,-9), 'mesh': self._mapFGPModel, 'mesh_scale': 3.73, 'body_scale': 3.73, 'shadow_size': 0.5, 'gravity_scale':0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) self.mapFGP5Tex = None - self.mapFGP5col = ba.newnode('region', attrs={'position': (0, 2, -9), 'scale': ( - 3.5, 0.1, 3.5), 'type': 'box', 'materials': (self._collide_with_player, shared.footing_material)}) + self.mapFGP5col = bs.newnode('region',attrs={'position': (1.5,2,-9),'scale': (3.5,0.1,3.5),'type': 'box','materials': (self._collide_with_player, shared.footing_material)}) self.coldel5 = False if self.coldel6: - self.mapFGP6 = ba.newnode('prop', - attrs={'body': 'puck', 'position': (0, 2, -6), 'model': self._mapFGPModel, 'model_scale': 3.8, 'body_scale': 3.8, 'shadow_size': 0.5, 'gravity_scale': 0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) + self.mapFGP6 = bs.newnode('prop', + attrs={'body': 'puck', 'position': (1.5,2,-6), 'mesh': self._mapFGPModel, 'mesh_scale': 3.73, 'body_scale': 3.73, 'shadow_size': 0.5, 'gravity_scale':0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) self.mapFGP6Tex = None - self.mapFGP6col = ba.newnode('region', attrs={'position': (0, 2, -6), 'scale': ( - 3.5, 0.1, 3.5), 'type': 'box', 'materials': (self._collide_with_player, shared.footing_material)}) + self.mapFGP6col = bs.newnode('region',attrs={'position': (1.5,2,-6),'scale': (3.5,0.1,3.5),'type': 'box','materials': (self._collide_with_player, shared.footing_material)}) self.coldel6 = False if self.coldel7: - self.mapFGP7 = ba.newnode('prop', - attrs={'body': 'puck', 'position': (0, 2, -3), 'model': self._mapFGPModel, 'model_scale': 3.8, 'body_scale': 3.8, 'shadow_size': 0.5, 'gravity_scale': 0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) + self.mapFGP7 = bs.newnode('prop', + attrs={'body': 'puck', 'position': (1.5,2,-3), 'mesh': self._mapFGPModel, 'mesh_scale': 3.73, 'body_scale': 3.73, 'shadow_size': 0.5, 'gravity_scale':0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) self.mapFGP7Tex = None - self.mapFGP7col = ba.newnode('region', attrs={'position': (0, 2, -3), 'scale': ( - 3.5, 0.1, 3.5), 'type': 'box', 'materials': (self._collide_with_player, shared.footing_material)}) + self.mapFGP7col = bs.newnode('region',attrs={'position': (1.5,2,-3),'scale': (3.5,0.1,3.5),'type': 'box','materials': (self._collide_with_player, shared.footing_material)}) self.coldel7 = False if self.coldel8: - self.mapFGP8 = ba.newnode('prop', - attrs={'body': 'puck', 'position': (0, 2, 0), 'model': self._mapFGPModel, 'model_scale': 3.8, 'body_scale': 3.8, 'shadow_size': 0.5, 'gravity_scale': 0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) + self.mapFGP8 = bs.newnode('prop', + attrs={'body': 'puck', 'position': (1.5,2,0), 'mesh': self._mapFGPModel, 'mesh_scale': 3.73, 'body_scale': 3.73, 'shadow_size': 0.5, 'gravity_scale':0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) self.mapFGP8Tex = None - self.mapFGP8col = ba.newnode('region', attrs={'position': (0, 2, 0), 'scale': ( - 3.5, 0.1, 3.5), 'type': 'box', 'materials': (self._collide_with_player, shared.footing_material)}) + self.mapFGP8col = bs.newnode('region',attrs={'position': (1.5,2,0),'scale': (3.5,0.1,3.5),'type': 'box','materials': (self._collide_with_player, shared.footing_material)}) self.coldel8 = False if self.coldel9: - self.mapFGP9 = ba.newnode('prop', - attrs={'body': 'puck', 'position': (-3, 2, -9), 'model': self._mapFGPModel, 'model_scale': 3.8, 'body_scale': 3.8, 'shadow_size': 0.5, 'gravity_scale': 0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) + self.mapFGP9 = bs.newnode('prop', + attrs={'body': 'puck', 'position': (-1.5,2,-9), 'mesh': self._mapFGPModel, 'mesh_scale': 3.73, 'body_scale': 3.73, 'shadow_size': 0.5, 'gravity_scale':0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) self.mapFGP9Tex = None - self.mapFGP9col = ba.newnode('region', attrs={'position': (-3, 2, -9), 'scale': ( - 3.5, 0.1, 3.5), 'type': 'box', 'materials': (self._collide_with_player, shared.footing_material)}) + self.mapFGP9col = bs.newnode('region',attrs={'position': (-1.5,2,-9),'scale': (3.5,0.1,3.5),'type': 'box','materials': (self._collide_with_player, shared.footing_material)}) self.coldel9 = False if self.coldel10: - self.mapFGP10 = ba.newnode('prop', - attrs={'body': 'puck', 'position': (-3, 2, -6), 'model': self._mapFGPModel, 'model_scale': 3.8, 'body_scale': 3.8, 'shadow_size': 0.5, 'gravity_scale': 0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) + self.mapFGP10 = bs.newnode('prop', + attrs={'body': 'puck', 'position': (-1.5,2,-6), 'mesh': self._mapFGPModel, 'mesh_scale': 3.73, 'body_scale': 3.73, 'shadow_size': 0.5, 'gravity_scale':0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) self.mapFGP10Tex = None - self.mapFGP10col = ba.newnode('region', attrs={'position': (-3, 2, -6), 'scale': ( - 3.5, 0.1, 3.5), 'type': 'box', 'materials': (self._collide_with_player, shared.footing_material)}) + self.mapFGP10col = bs.newnode('region',attrs={'position': (-1.5,2,-6),'scale': (3.5,0.1,3.5),'type': 'box','materials': (self._collide_with_player, shared.footing_material)}) self.coldel10 = False if self.coldel11: - self.mapFGP11 = ba.newnode('prop', - attrs={'body': 'puck', 'position': (-3, 2, -3), 'model': self._mapFGPModel, 'model_scale': 3.8, 'body_scale': 3.8, 'shadow_size': 0.5, 'gravity_scale': 0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) + self.mapFGP11 = bs.newnode('prop', + attrs={'body': 'puck', 'position': (-1.5,2,-3), 'mesh': self._mapFGPModel, 'mesh_scale': 3.73, 'body_scale': 3.73, 'shadow_size': 0.5, 'gravity_scale':0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) self.mapFGP11Tex = None - self.mapFGP11col = ba.newnode('region', attrs={'position': (-3, 2, -3), 'scale': ( - 3.5, 0.1, 3.5), 'type': 'box', 'materials': (self._collide_with_player, shared.footing_material)}) + self.mapFGP11col = bs.newnode('region',attrs={'position': (-1.5,2,-3),'scale': (3.5,0.1,3.5),'type': 'box','materials': (self._collide_with_player, shared.footing_material)}) self.coldel11 = False if self.coldel12: - self.mapFGP12 = ba.newnode('prop', - attrs={'body': 'puck', 'position': (-3, 2, 0), 'model': self._mapFGPModel, 'model_scale': 3.8, 'body_scale': 3.8, 'shadow_size': 0.5, 'gravity_scale': 0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) + self.mapFGP12 = bs.newnode('prop', + attrs={'body': 'puck', 'position': (-1.5,2,0), 'mesh': self._mapFGPModel, 'mesh_scale': 3.73, 'body_scale': 3.73, 'shadow_size': 0.5, 'gravity_scale':0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) self.mapFGP12Tex = None - self.mapFGP12col = ba.newnode('region', attrs={'position': (-3, 2, 0), 'scale': ( - 3.5, 0.1, 3.5), 'type': 'box', 'materials': (self._collide_with_player, shared.footing_material)}) + self.mapFGP12col = bs.newnode('region',attrs={'position': (-1.5,2,0),'scale': (3.5,0.1,3.5),'type': 'box','materials': (self._collide_with_player, shared.footing_material)}) self.coldel12 = False if self.coldel13: - self.mapFGP13 = ba.newnode('prop', - attrs={'body': 'puck', 'position': (-6, 2, -9), 'model': self._mapFGPModel, 'model_scale': 3.8, 'body_scale': 3.8, 'shadow_size': 0.5, 'gravity_scale': 0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) + self.mapFGP13 = bs.newnode('prop', + attrs={'body': 'puck', 'position': (-4.5,2,-9), 'mesh': self._mapFGPModel, 'mesh_scale': 3.73, 'body_scale': 3.73, 'shadow_size': 0.5, 'gravity_scale':0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) self.mapFGP13Tex = None - self.mapFGP13col = ba.newnode('region', attrs={'position': (-6, 2, -9), 'scale': ( - 3.5, 0.1, 3.5), 'type': 'box', 'materials': (self._collide_with_player, shared.footing_material)}) + self.mapFGP13col = bs.newnode('region',attrs={'position': (-4.5,2,-9),'scale': (3.5,0.1,3.5),'type': 'box','materials': (self._collide_with_player, shared.footing_material)}) self.coldel13 = False if self.coldel14: - self.mapFGP14 = ba.newnode('prop', - attrs={'body': 'puck', 'position': (-6, 2, -6), 'model': self._mapFGPModel, 'model_scale': 3.8, 'body_scale': 3.8, 'shadow_size': 0.5, 'gravity_scale': 0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) + self.mapFGP14 = bs.newnode('prop', + attrs={'body': 'puck', 'position': (-4.5,2,-6), 'mesh': self._mapFGPModel, 'mesh_scale': 3.73, 'body_scale': 3.73, 'shadow_size': 0.5, 'gravity_scale':0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) self.mapFGP14Tex = None - self.mapFGP14col = ba.newnode('region', attrs={'position': (-6, 2, -6), 'scale': ( - 3.5, 0.1, 3.5), 'type': 'box', 'materials': (self._collide_with_player, shared.footing_material)}) + self.mapFGP14col = bs.newnode('region',attrs={'position': (-4.5,2,-6),'scale': (3.5,0.1,3.5),'type': 'box','materials': (self._collide_with_player, shared.footing_material)}) self.coldel14 = False if self.coldel15: - self.mapFGP15 = ba.newnode('prop', - attrs={'body': 'puck', 'position': (-6, 2, -3), 'model': self._mapFGPModel, 'model_scale': 3.8, 'body_scale': 3.8, 'shadow_size': 0.5, 'gravity_scale': 0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) + self.mapFGP15 = bs.newnode('prop', + attrs={'body': 'puck', 'position': (-4.5,2,-3), 'mesh': self._mapFGPModel, 'mesh_scale': 3.73, 'body_scale': 3.73, 'shadow_size': 0.5, 'gravity_scale':0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) self.mapFGP15Tex = None - self.mapFGP15col = ba.newnode('region', attrs={'position': (-6, 2, -3), 'scale': ( - 3.5, 0.1, 3.5), 'type': 'box', 'materials': (self._collide_with_player, shared.footing_material)}) + self.mapFGP15col = bs.newnode('region',attrs={'position': (-4.5,2,-3),'scale': (3.5,0.1,3.5),'type': 'box','materials': (self._collide_with_player, shared.footing_material)}) self.coldel15 = False if self.coldel16: - self.mapFGP16 = ba.newnode('prop', - attrs={'body': 'puck', 'position': (-6, 2, 0), 'model': self._mapFGPModel, 'model_scale': 3.8, 'body_scale': 3.8, 'shadow_size': 0.5, 'gravity_scale': 0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) + self.mapFGP16 = bs.newnode('prop', + attrs={'body': 'puck', 'position': (-4.5,2,0), 'mesh': self._mapFGPModel, 'mesh_scale': 3.73, 'body_scale': 3.73, 'shadow_size': 0.5, 'gravity_scale':0.0, 'color_texture': self._mapFGPDefaultTex, 'reflection': 'soft', 'reflection_scale': [1.0], 'is_area_of_interest': True, 'materials': [self.dont_collide]}) self.mapFGP16Tex = None - self.mapFGP16col = ba.newnode('region', attrs={'position': (-6, 2, 0), 'scale': ( - 3.5, 0.1, 3.5), 'type': 'box', 'materials': (self._collide_with_player, shared.footing_material)}) + self.mapFGP16col = bs.newnode('region',attrs={'position': (-4.5,2,0),'scale': (3.5,0.1,3.5),'type': 'box','materials': (self._collide_with_player, shared.footing_material)}) self.coldel16 = False def _platformTexDefault(self): @@ -843,27 +815,27 @@ class MGgame(ba.TeamGameActivity[Player, Team]): timeStart = 6 else: timeStart = 2 - ba.playsound(self._scoreSound) - activity = _ba.get_foreground_host_activity() + self._scoreSound.play() + activity = bs.get_foreground_host_activity() for i in activity.players: try: - i.actor.node.handlemessage(ba.CelebrateMessage(2.0)) + i.actor.node.handlemessage(bs.CelebrateMessage(2.0)) except: pass - ba.timer(timeStart, self._randomPlatform) - ba.timer(timeStart, self.startCounter) + bs.timer(timeStart, self._randomPlatform) + bs.timer(timeStart, self.startCounter) self.spawnAllMap() self.flashHide() # Various high-level game events come through this method. def handlemessage(self, msg: Any) -> Any: - if isinstance(msg, ba.PlayerDiedMessage): + if isinstance(msg, bs.PlayerDiedMessage): # Augment standard behavior. super().handlemessage(msg) - curtime = ba.time() + curtime = bs.time() # Record the player's moment of death. # assert isinstance(msg.spaz.player @@ -873,15 +845,15 @@ class MGgame(ba.TeamGameActivity[Player, Team]): # (more accurate looking). # In teams/ffa, allow a one-second fudge-factor so we can # get more draws if players die basically at the same time. - if isinstance(self.session, ba.CoopSession): + if isinstance(self.session, bs.CoopSession): # Teams will still show up if we check now.. check in # the next cycle. - ba.pushcall(self._check_end_game) + babase.pushcall(self._check_end_game) # Also record this for a final setting of the clock. self._last_player_death_time = curtime else: - ba.timer(1.0, self._check_end_game) + bs.timer(1.0, self._check_end_game) else: # Default handler: return super().handlemessage(msg) @@ -897,15 +869,16 @@ class MGgame(ba.TeamGameActivity[Player, Team]): # In co-op, we go till everyone is dead.. otherwise we go # until one team remains. - if isinstance(self.session, ba.CoopSession): + if isinstance(self.session, bs.CoopSession): if living_team_count <= 0: self.end_game() else: if living_team_count <= 1: self.end_game() + def end_game(self) -> None: - cur_time = ba.time() + cur_time = bs.time() assert self._timer is not None start_time = self._timer.getstarttime() @@ -936,7 +909,7 @@ class MGgame(ba.TeamGameActivity[Player, Team]): # Ok now calc game results: set a score for each team and then tell # the game to end. - results = ba.GameResults() + results = bs.GameResults() # Remember that 'free-for-all' mode is simply a special form # of 'teams' mode where each player gets their own team, so we can @@ -956,16 +929,20 @@ class MGgame(ba.TeamGameActivity[Player, Team]): self.end(results=results) + + + + + + + class MGdefs(): points = {} boxes = {} - boxes['area_of_interest_bounds'] = ( - 0.3544110667, 4.493562578, -2.518391331) + (0.0, 0.0, 0.0) + (16.64754831, 8.06138989, 18.5029888) - boxes['map_bounds'] = (0.2608783669, 4.899663734, -3.543675157) + \ - (0.0, 0.0, 0.0) + (29.23565494, 14.19991443, 29.92689344) + boxes['area_of_interest_bounds'] = (0.3544110667, 4.493562578, -2.518391331) + (0.0, 0.0, 0.0) + (16.64754831, 8.06138989, 18.5029888) + boxes['map_bounds'] = (0.2608783669, 4.899663734, -3.543675157) + (0.0, 0.0, 0.0) + (29.23565494, 14.19991443, 29.92689344) - -class MGmap(ba.Map): +class MGmap(bs.Map): defs = MGdefs() name = 'Sky Tiles' @@ -981,23 +958,23 @@ class MGmap(ba.Map): @classmethod def on_preload(cls) -> Any: data: Dict[str, Any] = { - 'bgtex': ba.gettexture('menuBG'), - 'bgmodel': ba.getmodel('thePadBG') + 'bgtex': bs.gettexture('menuBG'), + 'bgmesh': bs.getmesh('thePadBG') } return data def __init__(self) -> None: super().__init__() shared = SharedObjects.get() - self.node = ba.newnode( + self.node = bs.newnode( 'terrain', attrs={ - 'model': self.preloaddata['bgmodel'], + 'mesh': self.preloaddata['bgmesh'], 'lighting': False, 'background': True, 'color_texture': self.preloaddata['bgtex'] }) - gnode = ba.getactivity().globalsnode + gnode = bs.getactivity().globalsnode gnode.tint = (1.3, 1.2, 1.0) gnode.ambient_color = (1.3, 1.2, 1.0) gnode.vignette_outer = (0.57, 0.57, 0.57) @@ -1006,12 +983,16 @@ class MGmap(ba.Map): gnode.vr_near_clip = 0.5 -ba._map.register_map(MGmap) + + + +bs._map.register_map(MGmap) + + # ba_meta export plugin -class byFreaku(ba.Plugin): +class byFreaku(babase.Plugin): def __init__(self): ## Campaign support ## - ba.app.add_coop_practice_level(ba.Level(name='Memory Game', displayname='${GAME}', gametype=MGgame, settings={ - }, preview_texture_name='achievementOffYouGo')) + babase.app.classic.add_coop_practice_level(bs.Level(name='Memory Game', displayname='${GAME}', gametype=MGgame, settings={}, preview_texture_name='achievementOffYouGo')) \ No newline at end of file diff --git a/plugins/minigames/musical_flags.py b/plugins/minigames/musical_flags.py index fbe9d2e..41828b3 100644 --- a/plugins/minigames/musical_flags.py +++ b/plugins/minigames/musical_flags.py @@ -1,100 +1,99 @@ -# Made by MattZ45986 on GitHub -# Ported by: Freaku / @[Just] Freak#4999 +## Made by MattZ45986 on GitHub +## Ported by your friend: Freaku -# Bug Fixes & Improvements as well... +#Bug Fixes & Improvements as well... -# Join BCS: +#Join BCS: # https://discord.gg/ucyaesh + + from __future__ import annotations from typing import TYPE_CHECKING -import _ba -import ba -import random -import math -from bastd.actor.flag import Flag, FlagPickedUpMessage -from bastd.actor.playerspaz import PlayerSpaz +import _babase, random, math +import bascenev1 as bs +from bascenev1lib.actor.flag import Flag,FlagPickedUpMessage +from bascenev1lib.actor.playerspaz import PlayerSpaz if TYPE_CHECKING: from typing import Any, Type, List, Dict, Tuple, Union, Sequence, Optional -class Player(ba.Player['Team']): + +class Player(bs.Player['Team']): def __init__(self) -> None: self.done: bool = False self.survived: bool = True - -class Team(ba.Team[Player]): +class Team(bs.Team[Player]): def __init__(self) -> None: self.score = 0 -# ba_meta require api 7 -# ba_meta export game -class MFGame(ba.TeamGameActivity[Player, Team]): +# ba_meta require api 8 +# ba_meta export bascenev1.GameActivity +class MFGame(bs.TeamGameActivity[Player, Team]): name = 'Musical Flags' description = "Don't be the one stuck without a flag!" @classmethod def get_available_settings( - cls, sessiontype: Type[ba.Session]) -> List[ba.Setting]: + cls, sessiontype: Type[bs.Session]) -> List[babase.Setting]: settings = [ - ba.IntChoiceSetting( - 'Time Limit', - choices=[ - ('None', 0), - ('1 Minute', 60), - ('2 Minutes', 120), - ('5 Minutes', 300), - ('10 Minutes', 600), - ('20 Minutes', 1200), - ], - default=0, + bs.IntSetting( + 'Max Round Time', + min_value=15, + default=25, + increment=5, ), - ba.BoolSetting('Epic Mode', default=False), - ba.BoolSetting('Enable Running', default=True), - ba.BoolSetting('Enable Punching', default=False), - ba.BoolSetting('Enable Bottom Credit', True) + bs.BoolSetting('Epic Mode', default=False), + bs.BoolSetting('Enable Running', default=True), + bs.BoolSetting('Enable Punching', default=False), + bs.BoolSetting('Enable Bottom Credit', True) ] return settings @classmethod - def supports_session_type(cls, sessiontype: Type[ba.Session]) -> bool: - return (issubclass(sessiontype, ba.DualTeamSession) - or issubclass(sessiontype, ba.FreeForAllSession)) + def supports_session_type(cls, sessiontype: Type[bs.Session]) -> bool: + return (issubclass(sessiontype, bs.DualTeamSession) + or issubclass(sessiontype, bs.FreeForAllSession)) @classmethod - def get_supported_maps(cls, sessiontype: Type[ba.Session]) -> List[str]: + def get_supported_maps(cls, sessiontype: Type[bs.Session]) -> List[str]: return ['Doom Shroom'] def __init__(self, settings: dict): super().__init__(settings) self.nodes = [] - self._dingsound = ba.getsound('dingSmall') + self._dingsound = bs.getsound('dingSmall') self._epic_mode = bool(settings['Epic Mode']) self.credit_text = bool(settings['Enable Bottom Credit']) - self._time_limit = float(settings['Time Limit']) self.is_punch = bool(settings['Enable Punching']) self.is_run = bool(settings['Enable Running']) - self._textRound = ba.newnode('text', - attrs={'text': '', - 'position': (0, -38), - 'scale': 1, - 'shadow': 1.0, - 'flatness': 1.0, - 'color': (1.0, 0.0, 1.0), - 'opacity': 1, - 'v_attach': 'top', - 'h_attach': 'center', - 'h_align': 'center', - 'v_align': 'center'}) + self._textRound = bs.newnode('text', + attrs={'text': '', + 'position': (0, -38), + 'scale': 1, + 'shadow': 1.0, + 'flatness': 1.0, + 'color': (1.0, 0.0, 1.0), + 'opacity': 1, + 'v_attach': 'top', + 'h_attach': 'center', + 'h_align': 'center', + 'v_align': 'center'}) + self.round_time = int(settings['Max Round Time']) + self.reset_round_time = int(settings['Max Round Time']) + self.should_die_occur = True + self.round_time_textnode = bs.newnode('text', + attrs={ + 'text': "",'flatness':1.0,'h_align':'center','h_attach':'center','v_attach':'top','v_align':'center','position':(0,-15),'scale':0.9,'color':(1,0.7,0.9)}) self.slow_motion = self._epic_mode # A cool music, matching our gamemode theme - self.default_music = ba.MusicType.FLAG_CATCHER + self.default_music = bs.MusicType.FLAG_CATCHER def get_instance_description(self) -> Union[str, Sequence]: return 'Catch Flag for yourself' @@ -104,10 +103,10 @@ class MFGame(ba.TeamGameActivity[Player, Team]): def on_player_join(self, player: Player) -> None: if self.has_begun(): - ba.screenmessage( - ba.Lstr(resource='playerDelayedJoinText', + bs.broadcastmessage( + bs.Lstr(resource='playerDelayedJoinText', subs=[('${PLAYER}', player.getname(full=True))]), - color=(0, 1, 0), transient=True) + color=(0, 1, 0),transient=True) player.survived = False return self.spawn_player(player) @@ -115,7 +114,7 @@ class MFGame(ba.TeamGameActivity[Player, Team]): def on_player_leave(self, player: Player) -> None: super().on_player_leave(player) # A departing player may trigger game-over. - self.checkEnd() + bs.timer(0, self.checkEnd) def on_begin(self) -> None: super().on_begin() @@ -124,74 +123,97 @@ class MFGame(ba.TeamGameActivity[Player, Team]): self.nodes = [] self.flags = [] self.spawned = [] - self.setup_standard_time_limit(self._time_limit) if self.credit_text: - t = ba.newnode('text', - attrs={'text': "Ported by Freaku\nMade by MattZ45986", # Disable 'Enable Bottom Credits' when making playlist, No need to edit this lovely... - 'scale': 0.7, - 'position': (0, 0), - 'shadow': 0.5, - 'flatness': 1.2, - 'color': (1, 1, 1), - 'h_align': 'center', - 'v_attach': 'bottom'}) + t = bs.newnode('text', + attrs={ 'text':"Ported by Freaku\nMade by MattZ45986", ## Disable 'Enable Bottom Credits' when making playlist, No need to edit this lovely... + 'scale':0.7, + 'position':(0,0), + 'shadow':0.5, + 'flatness':1.2, + 'color':(1, 1, 1), + 'h_align':'center', + 'v_attach':'bottom'}) self.makeRound() self._textRound.text = 'Round ' + str(self.roundNum) - ba.timer(5, self.checkEnd) + bs.timer(3, self.checkEnd) + self.keepcalling = bs.timer(1, self._timeround, True) + + def _timeround(self): + if self.round_time == 0 and self.should_die_occur: + self.should_die_occur = False + self.round_time_textnode.opacity = 0 + bs.broadcastmessage('Proceeding Round...') + for player in self.spawned: + if not player.done: + try: + player.survived = False + player.actor.handlemessage(bs.StandMessage((0,3,-2))) + bs.timer(0.5,bs.Call(player.actor.handlemessage, bs.FreezeMessage())) + bs.timer(1.5,bs.Call(player.actor.handlemessage, bs.FreezeMessage())) + bs.timer(2.5,bs.Call(player.actor.handlemessage, bs.FreezeMessage())) + bs.timer(3,bs.Call(player.actor.handlemessage, bs.ShouldShatterMessage())) + except: pass + bs.timer(3.5,self.killRound) + bs.timer(3.55,self.makeRound) + self.round_time_textnode.opacity = 0 + self.round_time = self.reset_round_time + else: + self.round_time_textnode.text = "Time: " + str(self.round_time) + self.round_time -= 1 def makeRound(self): for player in self.players: - if player.survived: - player.team.score += 1 + if player.survived: player.team.score += 1 self.roundNum += 1 self._textRound.text = 'Round ' + str(self.roundNum) self.flags = [] self.spawned = [] - angle = random.randint(0, 359) - c = 0 + self.should_die_occur = True + self.round_time = self.reset_round_time + self.round_time_textnode.opacity = 1 + angle = random.randint(0,359) + c=0 for player in self.players: - if player.survived: - c += 1 + if player.survived: c+=1 spacing = 10 for player in self.players: player.done = False if player.survived: if not player.is_alive(): - self.spawn_player(player, (.5, 5, -4)) + self.spawn_player(player,(.5,5,-4)) self.spawned.append(player) - try: - spacing = 360 // (c) - except: - self.checkEnd() - colors = [(1, 0, 0), (0, 1, 0), (0, 0, 1), (1, 1, 0), (1, 0, 1), (0, 1, 1), (0, 0, 0), - (0.5, 0.8, 0), (0, 0.8, 0.5), (0.8, 0.25, 0.7), (0, 0.27, 0.55), (2, 2, 0.6), (0.4, 3, 0.85)] + try: spacing = 360 // (c) + except: self.checkEnd() + colors = [(1,0,0),(0,1,0),(0,0,1),(1,1,0),(1,0,1),(0,1,1),(0,0,0),(0.5,0.8,0),(0,0.8,0.5),(0.8,0.25,0.7),(0,0.27,0.55),(2,2,0.6),(0.4,3,0.85)] + + # Add support for more than 13 players + if c > 12: + for i in range(c-12): + colors.append((random.uniform(0.1, 1), random.uniform(0.1, 1), random.uniform(0.1, 1))) + # Smart Mathematics: # All Flags spawn same distance from the players for i in range(c-1): angle += spacing angle %= 360 - x = 6 * math.sin(math.degrees(angle)) - z = 6 * math.cos(math.degrees(angle)) - flag = Flag(position=(x+.5, 5, z-4), color=colors[i]).autoretain() + x=6 * math.sin(math.degrees(angle)) + z=6 * math.cos(math.degrees(angle)) + flag = Flag(position=(x+.5,5,z-4), color=colors[i]).autoretain() self.flags.append(flag) def killRound(self): self.numPickedUp = 0 for player in self.players: - if player.is_alive(): - player.actor.handlemessage(ba.DieMessage()) - for flag in self.flags: - flag.node.delete() - for light in self.nodes: - light.delete() + if player.is_alive(): player.actor.handlemessage(bs.DieMessage()) + for flag in self.flags: flag.node.delete() + for light in self.nodes: light.delete() - def spawn_player(self, player: Player, pos: tuple = (0, 0, 0)) -> ba.Actor: + def spawn_player(self, player: Player, pos: tuple = (0,0,0)) -> bs.Actor: spaz = self.spawn_player_spaz(player) - if pos == (0, 0, 0): - pos = (-.5+random.random()*2, 3+random.random()*2, -5+random.random()*2) - spaz.connect_controls_to_player(enable_punch=self.is_punch, - enable_bomb=False, enable_run=self.is_run) - spaz.handlemessage(ba.StandMessage(pos)) + if pos == (0,0,0): + pos = (-.5+random.random()*2,3+random.random()*2,-5+random.random()*2) + spaz.connect_controls_to_player(enable_punch=self.is_punch, enable_bomb=False, enable_run=self.is_run) + spaz.handlemessage(bs.StandMessage(pos)) return spaz def check_respawn(self, player): @@ -200,36 +222,37 @@ class MFGame(ba.TeamGameActivity[Player, Team]): def handlemessage(self, msg: Any) -> Any: - if isinstance(msg, ba.PlayerDiedMessage): + if isinstance(msg, bs.PlayerDiedMessage): super().handlemessage(msg) player = msg.getplayer(Player) - ba.timer(0.1, ba.Call(self.check_respawn, player)) - ba.timer(0.5, self.checkEnd) + bs.timer(0.1, bs.Call(self.check_respawn, player)) + bs.timer(0.5, self.checkEnd) elif isinstance(msg, FlagPickedUpMessage): self.numPickedUp += 1 msg.node.getdelegate(PlayerSpaz, True).getplayer(Player, True).done = True - l = ba.newnode('light', - owner=None, - attrs={'color': msg.node.color, - 'position': (msg.node.position_center), - 'intensity': 1}) + l = bs.newnode('light', + owner=None, + attrs={'color':msg.node.color, + 'position':(msg.node.position_center), + 'intensity':1}) self.nodes.append(l) - msg.flag.handlemessage(ba.DieMessage()) - msg.node.handlemessage(ba.DieMessage()) + msg.flag.handlemessage(bs.DieMessage()) + msg.node.handlemessage(bs.DieMessage()) msg.node.delete() if self.numPickedUp == len(self.flags): + self.round_time_textnode.opacity = 0 + self.round_time = self.reset_round_time for player in self.spawned: if not player.done: try: player.survived = False - ba.screenmessage("No Flag? "+player.getname()) - player.actor.handlemessage(ba.StandMessage((0, 3, -2))) - ba.timer(0.5, ba.Call(player.actor.handlemessage, ba.FreezeMessage())) - ba.timer(3, ba.Call(player.actor.handlemessage, ba.ShouldShatterMessage())) - except: - pass - ba.timer(3.5, self.killRound) - ba.timer(3.55, self.makeRound) + bs.broadcastmessage("No Flag? "+player.getname()) + player.actor.handlemessage(bs.StandMessage((0,3,-2))) + bs.timer(0.5,bs.Call(player.actor.handlemessage, bs.FreezeMessage())) + bs.timer(3,bs.Call(player.actor.handlemessage, bs.ShouldShatterMessage())) + except: pass + bs.timer(3.5,self.killRound) + bs.timer(3.55,self.makeRound) else: return super().handlemessage(msg) return None @@ -238,15 +261,15 @@ class MFGame(ba.TeamGameActivity[Player, Team]): i = 0 for player in self.players: if player.survived: - i += 1 + i+=1 if i <= 1: for player in self.players: if player.survived: player.team.score += 10 - ba.timer(2.5, self.end_game) + bs.timer(2.5, self.end_game) def end_game(self) -> None: - results = ba.GameResults() + results = bs.GameResults() for team in self.teams: results.set_team_score(team, team.score) - self.end(results=results) + self.end(results=results) \ No newline at end of file diff --git a/plugins/minigames/volleyball.py b/plugins/minigames/volleyball.py index d4aeacc..b255950 100644 --- a/plugins/minigames/volleyball.py +++ b/plugins/minigames/volleyball.py @@ -1,16 +1,22 @@ # Volley Ball (final) -# Made by your friend: Freaku / @[Just] Freak#4999 +# Made by your friend: Freaku + + # Join BCS: # https://discord.gg/ucyaesh + + # My GitHub: # https://github.com/Freaku17/BombSquad-Mods-byFreaku + + # CHANGELOG: """ ## 2021 @@ -28,30 +34,37 @@ ## 2022 - Code cleanup -- No longer requires a plugin - More accurate Goal positions """ -# ba_meta require api 7 + + + + + + + + +# ba_meta require api 8 from __future__ import annotations from typing import TYPE_CHECKING -import _ba -import ba -import random -from bastd.actor.playerspaz import PlayerSpaz -from bastd.actor.scoreboard import Scoreboard -from bastd.actor.powerupbox import PowerupBoxFactory -from bastd.actor.bomb import BombFactory -from bastd.gameutils import SharedObjects +import babase, random +import bascenev1 as bs +from bascenev1lib.actor.playerspaz import PlayerSpaz +from bascenev1lib.actor.scoreboard import Scoreboard +from bascenev1lib.actor.powerupbox import PowerupBoxFactory +from bascenev1lib.actor.bomb import BombFactory +from bascenev1lib.gameutils import SharedObjects if TYPE_CHECKING: from typing import Any, Sequence, Dict, Type, List, Optional, Union + class PuckDiedMessage: """Inform something that a puck has died.""" @@ -59,7 +72,7 @@ class PuckDiedMessage: self.puck = puck -class Puck(ba.Actor): +class Puck(bs.Actor): def __init__(self, position: Sequence[float] = (0.0, 1.0, 0.0)): super().__init__() shared = SharedObjects.get() @@ -72,30 +85,31 @@ class Puck(ba.Actor): assert activity is not None assert isinstance(activity, VolleyBallGame) pmats = [shared.object_material, activity.puck_material] - self.node = ba.newnode('prop', + self.node = bs.newnode('prop', delegate=self, attrs={ - 'model': activity.puck_model, + 'mesh': activity.puck_mesh, 'color_texture': activity.puck_tex, 'body': 'sphere', 'reflection': 'soft', 'reflection_scale': [0.2], 'shadow_size': 0.6, - 'model_scale': 0.4, + 'mesh_scale': 0.4, 'body_scale': 1.07, 'is_area_of_interest': True, 'position': self._spawn_pos, 'materials': pmats }) - + # Since it rolls on spawn, lets make gravity # to 0, and when another node (bomb/spaz) # touches it. It'll act back as our normie puck! - ba.animate(self.node, 'gravity_scale', {0: -0.1, 0.2: 1}, False) + bs.animate(self.node, 'gravity_scale', {0:-0.1, 0.2:1}, False) # When other node touches, it realises its new gravity_scale + def handlemessage(self, msg: Any) -> Any: - if isinstance(msg, ba.DieMessage): + if isinstance(msg, bs.DieMessage): assert self.node self.node.delete() activity = self._activity() @@ -103,11 +117,11 @@ class Puck(ba.Actor): activity.handlemessage(PuckDiedMessage(self)) # If we go out of bounds, move back to where we started. - elif isinstance(msg, ba.OutOfBoundsMessage): + elif isinstance(msg, bs.OutOfBoundsMessage): assert self.node self.node.position = self._spawn_pos - elif isinstance(msg, ba.HitMessage): + elif isinstance(msg, bs.HitMessage): assert self.node assert msg.force_direction is not None self.node.handlemessage( @@ -128,29 +142,28 @@ class Puck(ba.Actor): super().handlemessage(msg) -class Player(ba.Player['Team']): +class Player(bs.Player['Team']): """Our player type for this game.""" -class Team(ba.Team[Player]): +class Team(bs.Team[Player]): """Our team type for this game.""" - def __init__(self) -> None: self.score = 0 -# ba_meta export game -class VolleyBallGame(ba.TeamGameActivity[Player, Team]): +# ba_meta export bascenev1.GameActivity +class VolleyBallGame(bs.TeamGameActivity[Player, Team]): name = 'Volley Ball' description = 'Score some goals.\nby \ue048Freaku' available_settings = [ - ba.IntSetting( + bs.IntSetting( 'Score to Win', min_value=1, default=1, increment=1, ), - ba.IntChoiceSetting( + bs.IntChoiceSetting( 'Time Limit', choices=[ ('None', 0), @@ -162,7 +175,7 @@ class VolleyBallGame(ba.TeamGameActivity[Player, Team]): ], default=0, ), - ba.FloatChoiceSetting( + bs.FloatChoiceSetting( 'Respawn Times', choices=[ ('Shorter', 0.25), @@ -173,36 +186,36 @@ class VolleyBallGame(ba.TeamGameActivity[Player, Team]): ], default=1.0, ), - ba.BoolSetting('Epic Mode', True), - ba.BoolSetting('Night Mode', False), - ba.BoolSetting('Icy Floor', True), - ba.BoolSetting('Disable Punch', False), - ba.BoolSetting('Disable Bombs', False), - ba.BoolSetting('Enable Bottom Credits', True), + bs.BoolSetting('Epic Mode', True), + bs.BoolSetting('Night Mode', False), + bs.BoolSetting('Icy Floor', True), + bs.BoolSetting('Disable Punch', False), + bs.BoolSetting('Disable Bombs', False), + bs.BoolSetting('Enable Bottom Credits', True), ] - default_music = ba.MusicType.HOCKEY + default_music = bs.MusicType.HOCKEY @classmethod - def supports_session_type(cls, sessiontype: Type[ba.Session]) -> bool: - return issubclass(sessiontype, ba.DualTeamSession) + def supports_session_type(cls, sessiontype: Type[bs.Session]) -> bool: + return issubclass(sessiontype, bs.DualTeamSession) @classmethod - def get_supported_maps(cls, sessiontype: Type[ba.Session]) -> List[str]: + def get_supported_maps(cls, sessiontype: Type[bs.Session]) -> List[str]: return ['Open Field', 'Closed Arena'] def __init__(self, settings: dict): super().__init__(settings) shared = SharedObjects.get() self._scoreboard = Scoreboard() - self._cheer_sound = ba.getsound('cheer') - self._chant_sound = ba.getsound('crowdChant') - self._foghorn_sound = ba.getsound('foghorn') - self._swipsound = ba.getsound('swip') - self._whistle_sound = ba.getsound('refWhistle') - self.puck_model = ba.getmodel('shield') - self.puck_tex = ba.gettexture('gameCircleIcon') - self._puck_sound = ba.getsound('metalHit') - self.puck_material = ba.Material() + self._cheer_sound = bs.getsound('cheer') + self._chant_sound = bs.getsound('crowdChant') + self._foghorn_sound = bs.getsound('foghorn') + self._swipsound = bs.getsound('swip') + self._whistle_sound = bs.getsound('refWhistle') + self.puck_mesh = bs.getmesh('shield') + self.puck_tex = bs.gettexture('gameCircleIcon') + self._puck_sound = bs.getsound('metalHit') + self.puck_material = bs.Material() self.puck_material.add_actions(actions=(('modify_part_collision', 'friction', 0.5))) self.puck_material.add_actions(conditions=('they_have_material', @@ -233,21 +246,22 @@ class VolleyBallGame(ba.TeamGameActivity[Player, Team]): conditions=('they_have_material', PowerupBoxFactory.get().powerup_material), actions=(('modify_part_collision', 'physical', False), - ('message', 'their_node', 'at_connect', ba.DieMessage()))) - self._score_region_material = ba.Material() + ('message', 'their_node', 'at_connect', bs.DieMessage()))) + self._score_region_material = bs.Material() self._score_region_material.add_actions( conditions=('they_have_material', self.puck_material), actions=(('modify_part_collision', 'collide', True), ('modify_part_collision', 'physical', False), ('call', 'at_connect', self._handle_score))) - - self._wall_material = ba.Material() - self._fake_wall_material = ba.Material() + + + self._wall_material=bs.Material() + self._fake_wall_material=bs.Material() self._wall_material.add_actions( - + actions=( ('modify_part_collision', 'friction', 100000), - )) + )) self._wall_material.add_actions( conditions=('they_have_material', shared.pickup_material), actions=( @@ -256,13 +270,13 @@ class VolleyBallGame(ba.TeamGameActivity[Player, Team]): self._wall_material.add_actions( conditions=(('we_are_younger_than', 100), - 'and', - ('they_have_material', shared.object_material)), + 'and', + ('they_have_material',shared.object_material)), actions=( ('modify_part_collision', 'collide', False), )) self._wall_material.add_actions( - conditions=('they_have_material', shared.footing_material), + conditions=('they_have_material',shared.footing_material), actions=( ('modify_part_collision', 'friction', 9999.5), )) @@ -271,24 +285,25 @@ class VolleyBallGame(ba.TeamGameActivity[Player, Team]): actions=( ('modify_part_collision', 'collide', False), ('modify_part_collision', 'physical', False) - + )) self._fake_wall_material.add_actions( conditions=('they_have_material', shared.player_material), actions=( ('modify_part_collision', 'collide', True), ('modify_part_collision', 'physical', True) - + )) - self.blocks = [] + self.blocks=[] - self._net_wall_material = ba.Material() + + self._net_wall_material=bs.Material() self._net_wall_material.add_actions( conditions=('they_have_material', shared.player_material), actions=( ('modify_part_collision', 'collide', True), ('modify_part_collision', 'physical', True) - + )) self._net_wall_material.add_actions( @@ -306,10 +321,11 @@ class VolleyBallGame(ba.TeamGameActivity[Player, Team]): actions=( ('modify_part_collision', 'collide', True), )) - self.net_blocc = [] + self.net_blocc=[] + self._puck_spawn_pos: Optional[Sequence[float]] = None - self._score_regions: Optional[List[ba.NodeActor]] = None + self._score_regions: Optional[List[bs.NodeActor]] = None self._puck: Optional[Puck] = None self._score_to_win = int(settings['Score to Win']) self._punchie_ = bool(settings['Disable Punch']) @@ -321,8 +337,8 @@ class VolleyBallGame(ba.TeamGameActivity[Player, Team]): self._epic_mode = bool(settings['Epic Mode']) # Base class overrides. self.slow_motion = self._epic_mode - self.default_music = (ba.MusicType.EPIC if self._epic_mode else - ba.MusicType.TO_THE_DEATH) + self.default_music = (bs.MusicType.EPIC if self._epic_mode else + bs.MusicType.TO_THE_DEATH) def get_instance_description(self) -> Union[str, Sequence]: if self._score_to_win == 1: @@ -339,60 +355,58 @@ class VolleyBallGame(ba.TeamGameActivity[Player, Team]): self.setup_standard_time_limit(self._time_limit) if self._night_mode: - ba.getactivity().globalsnode.tint = (0.5, 0.7, 1) + bs.getactivity().globalsnode.tint = (0.5, 0.7, 1) self._puck_spawn_pos = self.map.get_flag_position(None) self._spawn_puck() # Set up the two score regions. self._score_regions = [] self._score_regions.append( - ba.NodeActor( - ba.newnode('region', + bs.NodeActor( + bs.newnode('region', attrs={ - 'position': (5.7, 0, -0.065), + 'position':(5.7, 0, -0.065), 'scale': (10.7, 0.001, 8), 'type': 'box', 'materials': [self._score_region_material] }))) self._score_regions.append( - ba.NodeActor( - ba.newnode('region', + bs.NodeActor( + bs.newnode('region', attrs={ - 'position': (-5.7, 0, -0.065), + 'position':(-5.7, 0, -0.065), 'scale': (10.7, 0.001, 8), 'type': 'box', 'materials': [self._score_region_material] }))) self._update_scoreboard() - ba.playsound(self._chant_sound) + self._chant_sound.play() if self.credit_text: - t = ba.newnode('text', - attrs={'text': "Created by Freaku\nVolleyBall", # Disable 'Enable Bottom Credits' when making playlist, No need to edit this lovely... - 'scale': 0.7, - 'position': (0, 0), - 'shadow': 0.5, - 'flatness': 1.2, - 'color': (1, 1, 1), - 'h_align': 'center', - 'v_attach': 'bottom'}) + t = bs.newnode('text', + attrs={ 'text':"Created by Freaku\nVolleyBall", ## Disable 'Enable Bottom Credits' when making playlist, No need to edit this lovely... + 'scale':0.7, + 'position':(0,0), + 'shadow':0.5, + 'flatness':1.2, + 'color':(1, 1, 1), + 'h_align':'center', + 'v_attach':'bottom'}) shared = SharedObjects.get() - self.blocks.append(ba.NodeActor(ba.newnode('region', attrs={'position': (0, 2.4, 0), 'scale': ( - 0.8, 6, 20), 'type': 'box', 'materials': (self._fake_wall_material, )}))) - - self.net_blocc.append(ba.NodeActor(ba.newnode('region', attrs={'position': (0, 0, 0), 'scale': ( - 0.6, 2.4, 20), 'type': 'box', 'materials': (self._net_wall_material, )}))) + self.blocks.append(bs.NodeActor(bs.newnode('region',attrs={'position': (0,2.4,0),'scale': (0.8,6,20),'type': 'box','materials': (self._fake_wall_material, )}))) + + self.net_blocc.append(bs.NodeActor(bs.newnode('region',attrs={'position': (0,0,0),'scale': (0.6,2.4,20),'type': 'box','materials': (self._net_wall_material, )}))) def on_team_join(self, team: Team) -> None: self._update_scoreboard() def _handle_puck_player_collide(self) -> None: - collision = ba.getcollision() + collision = bs.getcollision() try: puck = collision.sourcenode.getdelegate(Puck, True) player = collision.opposingnode.getdelegate(PlayerSpaz, True).getplayer( Player, True) - except ba.NotFoundError: + except bs.NotFoundError: return puck.last_players_to_touch[player.team.id] = player @@ -409,7 +423,7 @@ class VolleyBallGame(ba.TeamGameActivity[Player, Team]): if self._puck.scored: return - region = ba.getcollision().sourcenode + region = bs.getcollision().sourcenode index = 0 for index in range(len(self._score_regions)): if region == self._score_regions[index].node: @@ -420,18 +434,21 @@ class VolleyBallGame(ba.TeamGameActivity[Player, Team]): scoring_team = team team.score += 1 - # Change puck Spawn - if team.id == 0: # left side scored - self._puck_spawn_pos = (5, 0.42, 0) - elif team.id == 1: # right side scored - self._puck_spawn_pos = (-5, 0.42, 0) - else: # normally shouldn't occur - self._puck_spawn_pos = (0, 0.42, 0) - # Easy pizzy + + # Change puck Spawn + if team.id == 0: # left side scored + self._puck_spawn_pos= (5, 0.42, 0) + elif team.id == 1: # right side scored + self._puck_spawn_pos= (-5, 0.42, 0) + else: # normally shouldn't occur + self._puck_spawn_pos= (0, 0.42, 0) + # Easy pizzy + + for player in team.players: if player.actor: - player.actor.handlemessage(ba.CelebrateMessage(2.0)) + player.actor.handlemessage(bs.CelebrateMessage(2.0)) # If we've got the player from the scoring team that last # touched us, give them points. @@ -446,28 +463,28 @@ class VolleyBallGame(ba.TeamGameActivity[Player, Team]): if team.score >= self._score_to_win: self.end_game() - ba.playsound(self._foghorn_sound) - ba.playsound(self._cheer_sound) + self._foghorn_sound.play() + self._cheer_sound.play() self._puck.scored = True # Kill the puck (it'll respawn itself shortly). - ba.emitfx(position=ba.getcollision().position, count=int( - 6.0 + 7.0 * 12), scale=3, spread=0.5, chunk_type='spark') - ba.timer(0.7, self._kill_puck) + bs.emitfx(position= bs.getcollision().position, count=int(6.0 + 7.0 * 12), scale=3, spread=0.5, chunk_type='spark') + bs.timer(0.7, self._kill_puck) - ba.cameraflash(duration=7.0) + + bs.cameraflash(duration=7.0) self._update_scoreboard() def end_game(self) -> None: - results = ba.GameResults() + results = bs.GameResults() for team in self.teams: results.set_team_score(team, team.score) self.end(results=results) def on_transition_in(self) -> None: super().on_transition_in() - activity = ba.getactivity() + activity = bs.getactivity() if self._icy_flooor: activity.map.is_hockey = True @@ -477,7 +494,7 @@ class VolleyBallGame(ba.TeamGameActivity[Player, Team]): self._scoreboard.set_team_value(team, team.score, winscore) # overriding the default character spawning.. - def spawn_player(self, player: Player) -> ba.Actor: + def spawn_player(self, player: Player) -> bs.Actor: spaz = self.spawn_player_spaz(player) if self._bombies_: @@ -485,6 +502,7 @@ class VolleyBallGame(ba.TeamGameActivity[Player, Team]): spaz.bomb_count = 0 # Imagine not being able to swipe those colorful buttons ;( + if self._punchie_: spaz.connect_controls_to_player(enable_punch=False) @@ -493,7 +511,7 @@ class VolleyBallGame(ba.TeamGameActivity[Player, Team]): def handlemessage(self, msg: Any) -> Any: # Respawn dead players if they're still in the game. - if isinstance(msg, ba.PlayerDiedMessage): + if isinstance(msg, bs.PlayerDiedMessage): # Augment standard behavior... super().handlemessage(msg) self.respawn_player(msg.getplayer(Player)) @@ -501,44 +519,62 @@ class VolleyBallGame(ba.TeamGameActivity[Player, Team]): # Respawn dead pucks. elif isinstance(msg, PuckDiedMessage): if not self.has_ended(): - ba.timer(2.2, self._spawn_puck) + bs.timer(2.2, self._spawn_puck) else: super().handlemessage(msg) def _flash_puck_spawn(self) -> None: # Effect >>>>>> Flashly - ba.emitfx(position=self._puck_spawn_pos, count=int( - 6.0 + 7.0 * 12), scale=1.7, spread=0.4, chunk_type='spark') + bs.emitfx(position= self._puck_spawn_pos, count=int(6.0 + 7.0 * 12), scale=1.7, spread=0.4, chunk_type='spark') def _spawn_puck(self) -> None: - ba.playsound(self._swipsound) - ba.playsound(self._whistle_sound) + self._swipsound.play() + self._whistle_sound.play() self._flash_puck_spawn() assert self._puck_spawn_pos is not None self._puck = Puck(position=self._puck_spawn_pos) + + + + + + + + + + + + + + + + + + + + + class Pointzz: points, boxes = {}, {} points['spawn1'] = (-8.03866, 0.02275, 0.0) + (0.5, 0.05, 4.0) points['spawn2'] = (8.82311, 0.01092, 0.0) + (0.5, 0.05, 4.0) - boxes['area_of_interest_bounds'] = (0.0, 1.18575, 0.43262) + \ - (0, 0, 0) + (29.81803, 11.57249, 18.89134) + boxes['area_of_interest_bounds'] = (0.0, 1.18575, 0.43262) + (0, 0, 0) + (29.81803, 11.57249, 18.89134) boxes['map_bounds'] = (0.0, 1.185751251, 0.4326226188) + (0.0, 0.0, 0.0) + ( - 42.09506485, 22.81173179, 29.76723155) - + 42.09506485, 22.81173179, 29.76723155) class PointzzforH: points, boxes = {}, {} - boxes['area_of_interest_bounds'] = (0.0, 0.7956858119, 0.0) + \ - (0.0, 0.0, 0.0) + (30.80223883, 0.5961646365, 13.88431707) + boxes['area_of_interest_bounds'] = (0.0, 0.7956858119, 0.0) + (0.0, 0.0, 0.0) + (30.80223883, 0.5961646365, 13.88431707) boxes['map_bounds'] = (0.0, 0.7956858119, -0.4689020853) + (0.0, 0.0, 0.0) + ( - 35.16182389, 12.18696164, 21.52869693) + 35.16182389, 12.18696164, 21.52869693) points['spawn1'] = (-6.835352227, 0.02305323209, 0.0) + (1.0, 1.0, 3.0) points['spawn2'] = (6.857415055, 0.03938567998, 0.0) + (1.0, 1.0, 3.0) -class VolleyBallMap(ba.Map): + +class VolleyBallMap(bs.Map): defs = Pointzz() name = "Open Field" @@ -553,72 +589,72 @@ class VolleyBallMap(ba.Map): @classmethod def on_preload(cls) -> Any: data: Dict[str, Any] = { - 'model': ba.getmodel('footballStadium'), - 'vr_fill_model': ba.getmodel('footballStadiumVRFill'), - 'collide_model': ba.getcollidemodel('footballStadiumCollide'), - 'tex': ba.gettexture('footballStadium') + 'mesh': bs.getmesh('footballStadium'), + 'vr_fill_mesh': bs.getmesh('footballStadiumVRFill'), + 'collision_mesh': bs.getcollisionmesh('footballStadiumCollide'), + 'tex': bs.gettexture('footballStadium') } return data - + def __init__(self): super().__init__() shared = SharedObjects.get() x = -5 - while x < 5: - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (0, 0, x), - 'color': (1, 1, 0), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (0, .25, x), - 'color': (1, 1, 0), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (0, .5, x), - 'color': (1, 1, 0), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (0, .75, x), - 'color': (1, 1, 0), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (0, 1, x), - 'color': (1, 1, 0), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) + while x<5: + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(0,0,x), + 'color':(1,1,0),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(0,.25,x), + 'color':(1,1,0),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(0,.5,x), + 'color':(1,1,0),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(0,.75,x), + 'color':(1,1,0),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(0,1,x), + 'color':(1,1,0),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) x = x + 0.5 y = -1 - while y > -11: - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (y, 0.01, 4), - 'color': (0, 0, 1), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (y, 0.01, -4), - 'color': (0, 0, 1), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (-y, 0.01, 4), - 'color': (1, 0, 0), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (-y, 0.01, -4), - 'color': (1, 0, 0), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - y -= 1 + while y>-11: + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(y,0.01,4), + 'color':(0,0,1),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(y,0.01,-4), + 'color':(0,0,1),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(-y,0.01,4), + 'color':(1,0,0),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(-y,0.01,-4), + 'color':(1,0,0),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + y-=1 z = 0 - while z < 5: - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (11, 0.01, z), - 'color': (1, 0, 0), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (11, 0.01, -z), - 'color': (1, 0, 0), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (-11, 0.01, z), - 'color': (0, 0, 1), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (-11, 0.01, -z), - 'color': (0, 0, 1), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - z += 1 + while z<5: + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(11,0.01,z), + 'color':(1,0,0),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(11,0.01,-z), + 'color':(1,0,0),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(-11,0.01,z), + 'color':(0,0,1),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(-11,0.01,-z), + 'color':(0,0,1),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + z+=1 - self.node = ba.newnode( + self.node = bs.newnode( 'terrain', delegate=self, attrs={ - 'model': self.preloaddata['model'], - 'collide_model': self.preloaddata['collide_model'], + 'mesh': self.preloaddata['mesh'], + 'collision_mesh': self.preloaddata['collision_mesh'], 'color_texture': self.preloaddata['tex'], 'materials': [shared.footing_material] }) - ba.newnode('terrain', + bs.newnode('terrain', attrs={ - 'model': self.preloaddata['vr_fill_model'], + 'mesh': self.preloaddata['vr_fill_mesh'], 'lighting': False, 'vr_only': True, 'background': True, 'color_texture': self.preloaddata['tex'] }) - gnode = ba.getactivity().globalsnode + gnode = bs.getactivity().globalsnode gnode.tint = (1.3, 1.2, 1.0) gnode.ambient_color = (1.3, 1.2, 1.0) gnode.vignette_outer = (0.57, 0.57, 0.57) @@ -627,7 +663,8 @@ class VolleyBallMap(ba.Map): gnode.vr_near_clip = 0.5 -class VolleyBallMapH(ba.Map): + +class VolleyBallMapH(bs.Map): defs = PointzzforH() name = 'Closed Arena' @@ -642,13 +679,13 @@ class VolleyBallMapH(ba.Map): @classmethod def on_preload(cls) -> Any: data: Dict[str, Any] = { - 'models': (ba.getmodel('hockeyStadiumOuter'), - ba.getmodel('hockeyStadiumInner')), - 'vr_fill_model': ba.getmodel('footballStadiumVRFill'), - 'collide_model': ba.getcollidemodel('hockeyStadiumCollide'), - 'tex': ba.gettexture('hockeyStadium'), + 'meshs': (bs.getmesh('hockeyStadiumOuter'), + bs.getmesh('hockeyStadiumInner')), + 'vr_fill_mesh': bs.getmesh('footballStadiumVRFill'), + 'collision_mesh': bs.getcollisionmesh('hockeyStadiumCollide'), + 'tex': bs.gettexture('hockeyStadium'), } - mat = ba.Material() + mat = bs.Material() mat.add_actions(actions=('modify_part_collision', 'friction', 0.01)) data['ice_material'] = mat return data @@ -657,84 +694,83 @@ class VolleyBallMapH(ba.Map): super().__init__() shared = SharedObjects.get() x = -5 - while x < 5: - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (0, 0, x), - 'color': (1, 1, 0), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (0, .25, x), - 'color': (1, 1, 0), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (0, .5, x), - 'color': (1, 1, 0), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (0, .75, x), - 'color': (1, 1, 0), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (0, 1, x), - 'color': (1, 1, 0), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) + while x<5: + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(0,0,x), + 'color':(1,1,0),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(0,.25,x), + 'color':(1,1,0),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(0,.5,x), + 'color':(1,1,0),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(0,.75,x), + 'color':(1,1,0),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(0,1,x), + 'color':(1,1,0),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) x = x + 0.5 y = -1 - while y > -11: - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (y, 0.01, 4), - 'color': (0, 0, 1), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (y, 0.01, -4), - 'color': (0, 0, 1), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (-y, 0.01, 4), - 'color': (1, 0, 0), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (-y, 0.01, -4), - 'color': (1, 0, 0), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - y -= 1 + while y>-11: + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(y,0.01,4), + 'color':(0,0,1),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(y,0.01,-4), + 'color':(0,0,1),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(-y,0.01,4), + 'color':(1,0,0),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(-y,0.01,-4), + 'color':(1,0,0),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + y-=1 z = 0 - while z < 5: - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (11, 0.01, z), - 'color': (1, 0, 0), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (11, 0.01, -z), - 'color': (1, 0, 0), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (-11, 0.01, z), - 'color': (0, 0, 1), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - self.zone = ba.newnode('locator', attrs={'shape': 'circle', 'position': (-11, 0.01, -z), - 'color': (0, 0, 1), 'opacity': 1, 'draw_beauty': True, 'additive': False, 'size': [0.40]}) - z += 1 + while z<5: + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(11,0.01,z), + 'color':(1,0,0),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(11,0.01,-z), + 'color':(1,0,0),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(-11,0.01,z), + 'color':(0,0,1),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + self.zone = bs.newnode('locator',attrs={'shape':'circle','position':(-11,0.01,-z), + 'color':(0,0,1),'opacity':1,'draw_beauty':True,'additive':False,'size':[0.40]}) + z+=1 - self.node = ba.newnode('terrain', + self.node = bs.newnode('terrain', delegate=self, attrs={ - 'model': + 'mesh': None, - 'collide_model': - # we dont want Goalposts... - ba.getcollidemodel('footballStadiumCollide'), + 'collision_mesh': + bs.getcollisionmesh('footballStadiumCollide'), # we dont want Goalposts... 'color_texture': self.preloaddata['tex'], 'materials': [ shared.footing_material] }) - ba.newnode('terrain', + bs.newnode('terrain', attrs={ - 'model': self.preloaddata['vr_fill_model'], + 'mesh': self.preloaddata['vr_fill_mesh'], 'vr_only': True, 'lighting': False, 'background': True, }) mats = [shared.footing_material] - self.floor = ba.newnode('terrain', + self.floor = bs.newnode('terrain', attrs={ - 'model': self.preloaddata['models'][1], + 'mesh': self.preloaddata['meshs'][1], 'color_texture': self.preloaddata['tex'], 'opacity': 0.92, 'opacity_in_low_or_medium_quality': 1.0, 'materials': mats, - 'color': (0.4, 0.9, 0) + 'color': (0.4,0.9,0) }) - self.background = ba.newnode( + self.background = bs.newnode( 'terrain', attrs={ - 'model': ba.getmodel('natureBackground'), + 'mesh': bs.getmesh('natureBackground'), 'lighting': False, 'background': True, - 'color': (0.5, 0.30, 0.4) + 'color': (0.5,0.30,0.4) }) - gnode = ba.getactivity().globalsnode + gnode = bs.getactivity().globalsnode gnode.floor_reflection = True gnode.debris_friction = 0.3 gnode.debris_kill_height = -0.3 @@ -747,5 +783,19 @@ class VolleyBallMapH(ba.Map): #self.is_hockey = True -ba._map.register_map(VolleyBallMap) -ba._map.register_map(VolleyBallMapH) + + +bs._map.register_map(VolleyBallMap) +bs._map.register_map(VolleyBallMapH) + + +# ba_meta export plugin +class byFreaku(babase.Plugin): + def __init__(self): + # Reason of plugin: + # To register maps. + # + # Then why not include function here? + # On server upon first launch, plugins are not activated, + # (same can be case for user if disabled auto-enable plugins) + pass \ No newline at end of file