More

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "githubPullRequests.ignoredPullRequestBranches": [
+        "main"
+    ]
+}

plugins/minigames.json

@@ -1079,6 +1079,76 @@
       "versions": {
         "1.0.0": null
       }
+    },
+    "ba_dark_fileds": {
+      "description": "Get to the other side and watch your step",
+      "external_url": "",
+      "authors": [
+        {
+          "name": "Froshlee24",
+          "email": "",
+          "discord": "froshlee24"
+        }
+      ],
+      "versions": {
+        "1.0.0": null
+      }
+    },
+    "onslaught_football": {
+      "description": "Onslaught but in football map",
+      "external_url": "",
+      "authors": [
+        {
+          "name": "",
+          "email": "",
+          "discord": ""
+        }
+      ],
+      "versions": {
+        "1.0.0": null
+      }
+    },
+    "lame_fight": {
+      "description": "Save World With Super Powers",
+      "external_url": "",
+      "authors": [
+        {
+          "name": "",
+          "email": "",
+          "discord": ""
+        }
+      ],
+      "versions": {
+        "1.0.0": null
+      }
+    },
+    "infinite_ninjas": {
+      "description": "How long can you survive from Ninjas??",
+      "external_url": "",
+      "authors": [
+        {
+          "name": "",
+          "email": "",
+          "discord": ""
+        }
+      ],
+      "versions": {
+        "1.0.0": null
+      }
+    },
+    "gravity_falls": {
+      "description": "Trip to the moon",
+      "external_url": "",
+      "authors": [
+        {
+          "name": "",
+          "email": "",
+          "discord": ""
+        }
+      ],
+      "versions": {
+        "1.0.0": null
+      }
     }
   }
 }

plugins/minigames/ba_dark_fields.py

@@ -0,0 +1,291 @@
+# Ported to api 8 by brostos using baport.(https://github.com/bombsquad-community/baport)
+"""Dark fields mini-game."""
+
+# Minigame by Froshlee24
+# ba_meta require api 8
+# (see https://ballistica.net/wiki/meta-tag-system)
+
+from __future__ import annotations
+import random
+from typing import TYPE_CHECKING
+
+import _babase
+import babase
+import bauiv1 as bui
+import bascenev1 as bs
+from bascenev1lib.actor import bomb
+from bascenev1._music import setmusic
+from bascenev1lib.actor.scoreboard import Scoreboard
+from bascenev1._gameutils import animate_array
+from bascenev1lib.gameutils import SharedObjects
+from bascenev1lib.actor.playerspaz import PlayerSpaz
+
+if TYPE_CHECKING:
+    from typing import Any, Sequence, Optional, List, Dict, Type, Type
+
+class Player(bs.Player['Team']):
+    """Our player type for this game."""
+
+
+class Team(bs.Team[Player]):
+    """Our team type for this game."""
+
+    def __init__(self) -> None:
+        self.score = 0
+
+# ba_meta export bascenev1.GameActivity
+class DarkFieldsGame(bs.TeamGameActivity[Player, Team]):
+
+    name = 'Dark Fields'
+    description = 'Get to the other side.'
+    available_settings = [
+        bs.IntSetting('Score to Win',
+            min_value=1,
+            default=3,
+        ),
+        bs.IntChoiceSetting('Time Limit',
+            choices=[
+                ('None', 0),
+                ('1 Minute', 60),
+                ('2 Minutes', 120),
+                ('5 Minutes', 300),
+                ('10 Minutes', 600),
+                ('20 Minutes', 1200),
+            ],
+            default=0,
+        ),
+        bs.FloatChoiceSetting('Respawn Times',
+            choices=[
+                ('Shorter', 0.25),
+                ('Short', 0.5),
+                ('Normal', 1.0),
+                ('Long', 2.0),
+                ('Longer', 4.0),
+            ],
+            default=1.0,
+        ),
+        bs.BoolSetting('Epic Mode', default=False),
+        bs.BoolSetting('Players as center of interest', default=True),
+    ]
+
+    @classmethod
+    def get_supported_maps(cls, sessiontype: Type[bs.Session]) -> List[str]:
+        return bs.app.classic.getmaps('football')
+
+    @classmethod
+    def supports_session_type(cls, sessiontype: Type[bs.Session]) -> bool:
+        return (issubclass(sessiontype, bs.DualTeamSession)
+                or issubclass(sessiontype, bs.FreeForAllSession))
+
+    def __init__(self, settings: dict):
+        super().__init__(settings)
+        self._epic_mode = bool(settings['Epic Mode'])
+        self._center_of_interest = bool(settings['Players as center of interest'])
+        self._score_to_win_per_player = int(settings['Score to Win'])
+        self._time_limit = float(settings['Time Limit'])
+
+        self._scoreboard = Scoreboard()
+
+        shared = SharedObjects.get()
+
+        self._scoreRegionMaterial = bs.Material()
+        self._scoreRegionMaterial.add_actions(
+            conditions=("they_have_material",shared.player_material),
+            actions=(("modify_part_collision","collide",True),
+                     ("modify_part_collision","physical",False),
+                     ("call","at_connect", self._onPlayerScores)))
+
+        self.slow_motion = self._epic_mode
+        self.default_music = (bs.MusicType.EPIC if self._epic_mode else None)
+
+    
+    def on_transition_in(self) -> None:
+        super().on_transition_in()
+        gnode = bs.getactivity().globalsnode
+        gnode.tint = (0.5,0.5,0.5)
+
+        a = bs.newnode('locator',attrs={'shape':'box','position':(12.2,0,.1087926362),
+            'color':(5,0,0),'opacity':1,'draw_beauty':True,'additive':False,'size':[2.5,0.1,12.8]})
+			
+        b = bs.newnode('locator',attrs={'shape':'box','position':(-12.1,0,.1087926362),
+            'color':(0,0,5),'opacity':1,'draw_beauty':True,'additive':False,'size':[2.5,0.1,12.8]})
+    
+    def on_begin(self) -> None:
+        # self._has_begun = False
+        super().on_begin()
+
+        self.setup_standard_time_limit(self._time_limit)
+        self._score_to_win = (self._score_to_win_per_player *
+                              max(1, max(len(t.players) for t in self.teams)))
+        self._update_scoreboard()
+
+        self.isUpdatingMines = False
+        self._scoreSound = bs.getsound('dingSmall')
+
+        for p in self.players:
+            if p.actor is not None:
+                try:
+                    p.actor.disconnect_controls_from_player()
+                except Exception:
+                    print('Can\'t connect to player')
+
+        self._scoreRegions = []
+        defs = bs.getactivity().map.defs
+        self._scoreRegions.append(bs.NodeActor(bs.newnode('region',
+                                 attrs={'position':defs.boxes['goal1'][0:3],
+                                        'scale':defs.boxes['goal1'][6:9],
+                                        'type': 'box',
+                                        'materials':(self._scoreRegionMaterial,)})))
+        self.mines = []
+        self.spawnMines()
+        bs.timer(0.8 if self.slow_motion else 1.7,self.start)
+
+    def start(self):
+        # self._has_begun = True
+        self._show_info()
+        bs.timer(random.randrange(3,7),self.doRandomLighting)
+        if not self._epic_mode:
+            setmusic(bs.MusicType.SCARY)
+        animate_array(bs.getactivity().globalsnode,'tint',3,{0:(0.5,0.5,0.5),2:(0.2,0.2,0.2)})
+
+        for p in self.players:
+            self.doPlayer(p)
+
+    def spawn_player(self, player):
+        if not self.has_begun():
+            return
+        else:
+            self.doPlayer(player)
+
+    def doPlayer(self,player):
+        pos = (-12.4,1,random.randrange(-5,5))
+        player = self.spawn_player_spaz(player,pos)
+        player.connect_controls_to_player(enable_punch=False,enable_bomb=False)
+        player.node.is_area_of_interest = self._center_of_interest
+
+    def _show_info(self) -> None:
+        if self.has_begun():
+            super()._show_info()
+
+    def on_team_join(self, team: Team) -> None:
+        if self.has_begun():
+            self._update_scoreboard()
+
+    def _update_scoreboard(self) -> None:
+        for team in self.teams:
+            self._scoreboard.set_team_value(team, team.score, self._score_to_win)
+
+    def doRandomLighting(self):
+        bs.timer(random.randrange(3,7),self.doRandomLighting)
+        if self.isUpdatingMines: return
+
+        delay = 0
+        for mine in self.mines:
+            if mine.node.exists():
+                pos = mine.node.position
+                bs.timer(delay,babase.Call(self.do_light,pos))
+                delay += 0.005 if self._epic_mode else 0.01
+
+    def do_light(self,pos):
+        light = bs.newnode('light',attrs={
+                   'position': pos,
+                   'volume_intensity_scale': 1.0,
+                   'radius':0.1,
+                   'color': (1,0,0)
+                })
+        bs.animate(light, 'intensity', { 0: 2.0, 3.0: 0.0})
+        bs.timer(3.0, light.delete)
+
+    def spawnMines(self):
+        delay = 0
+        h_range = [10,8,6,4,2,0,-2,-4,-6,-8,-10]
+        for h in h_range:
+            for i in range(random.randint(3,4)):
+                x = h+random.random()
+                y = random.randrange(-5,6)+(random.random())
+                pos = (x,1,y)
+                bs.timer(delay,babase.Call(self.doMine,pos))
+                delay += 0.015 if self._epic_mode else 0.04
+        bs.timer(5.0,self.stopUpdateMines)
+
+    def stopUpdateMines(self):
+        self.isUpdatingMines = False
+
+    def updateMines(self):
+        if self.isUpdatingMines: return
+        self.isUpdatingMines = True
+        for m in self.mines:
+            m.node.delete()
+        self.mines = []
+        self.spawnMines()
+        
+        	
+    def doMine(self,pos):
+        b = bomb.Bomb(position=pos,bomb_type='land_mine').autoretain()
+        b.add_explode_callback(self._on_bomb_exploded)
+        b.arm()
+        self.mines.append(b)
+
+    def _on_bomb_exploded(self, bomb: Bomb, blast: Blast) -> None:
+        assert blast.node
+        p = blast.node.position
+        pos = (p[0],p[1]+1,p[2])
+        bs.timer(0.5,babase.Call(self.doMine,pos))
+
+    def _onPlayerScores(self):
+        player: Optional[Player]
+        try:
+            spaz = bs.getcollision().opposingnode.getdelegate(PlayerSpaz, True)
+        except bs.NotFoundError:
+            return
+        
+        if not spaz.is_alive():
+            return
+
+        try:
+            player = spaz.getplayer(Player, True)
+        except bs.NotFoundError:
+            return
+        
+        if player.exists() and player.is_alive():
+            player.team.score += 1
+            self._scoreSound.play() 
+            pos = player.actor.node.position
+
+            animate_array(bs.getactivity().globalsnode,'tint',3,{0:(0.5,0.5,0.5),2.8:(0.2,0.2,0.2)})
+            self._update_scoreboard()
+
+            light = bs.newnode('light',
+                           attrs={
+                               'position': pos,
+                               'radius': 0.5,
+                               'color': (1, 0, 0)
+                           })
+            bs.animate(light, 'intensity', {0.0: 0, 0.1: 1, 0.5: 0}, loop=False)
+            bs.timer(1.0, light.delete)
+
+            player.actor.handlemessage(bs.DieMessage( how=bs.DeathType.REACHED_GOAL))
+            self.updateMines()
+
+            if any(team.score >= self._score_to_win for team in self.teams):
+                bs.timer(0.5, self.end_game)
+
+    def handlemessage(self, msg: Any) -> Any:
+
+        if isinstance(msg, bs.PlayerDiedMessage):
+
+            # Augment standard behavior.
+            super().handlemessage(msg)
+
+            player = msg.getplayer(Player)
+            self.respawn_player(player)
+
+        else:
+            return super().handlemessage(msg)
+        return None
+
+    def end_game(self) -> None:
+        results = bs.GameResults()
+        for team in self.teams:
+            results.set_team_score(team, team.score)
+        self.end(results=results)

plugins/minigames/gravity_falls.py

@@ -0,0 +1,34 @@
+# Ported to api 8 by brostos using baport.(https://github.com/bombsquad-community/baport)
+## Made by MattZ45986 on GitHub
+## Ported by: Freaku / @[Just] Freak#4999
+
+
+import babase
+import bauiv1 as bui
+import bascenev1 as bs
+from bascenev1lib.game.elimination import EliminationGame
+
+
+
+# ba_meta require api 8
+# ba_meta export bascenev1.GameActivity
+class GFGame(EliminationGame):
+    name = 'Gravity Falls'
+
+    def spawn_player(self, player):
+        actor = self.spawn_player_spaz(player, (0,5,0))
+        if not self._solo_mode:
+            bs.timer(0.3, babase.Call(self._print_lives, player))
+
+        # If we have any icons, update their state.
+        for icon in player.icons:
+            icon.handle_player_spawned()
+        bs.timer(1,babase.Call(self.raise_player, player))
+        return actor
+
+    def raise_player(self, player):
+        if player.is_alive():
+            try:
+                player.actor.node.handlemessage("impulse",player.actor.node.position[0],player.actor.node.position[1]+.5,player.actor.node.position[2],0,5,0, 3,10,0,0, 0,5,0)
+            except: pass
+            bs.timer(0.05,babase.Call(self.raise_player,player))

plugins/minigames/infinite_ninjas.py

@@ -0,0 +1,134 @@
+# Ported to api 8 by brostos using baport.(https://github.com/bombsquad-community/baport)
+# ba_meta require api 8
+
+#Copy pasted from ExplodoRun by Blitz,just edited Bots and map 😝
+
+
+from __future__ import annotations
+
+import random
+from typing import TYPE_CHECKING
+
+import babase
+import bauiv1 as bui
+import bascenev1 as bs
+from bascenev1lib.actor.spazbot import SpazBotSet, ChargerBot, SpazBotDiedMessage
+from bascenev1lib.actor.onscreentimer import OnScreenTimer
+
+if TYPE_CHECKING:
+    from typing import Any, Type, Dict, List, Optional
+
+## MoreMinigames.py support ##
+def ba_get_api_version():
+    return 6
+
+def ba_get_levels():
+    return [babase._level.Level(
+            'Infinite Ninjas',gametype=InfiniteNinjasGame,
+            settings={},
+            preview_texture_name = 'footballStadiumPreview'),
+            babase._level.Level(
+            'Epic Infinite Ninjas',gametype=InfiniteNinjasGame,
+            settings={'Epic Mode':True},
+            preview_texture_name = 'footballStadiumPreview')]
+## MoreMinigames.py support ##
+
+class Player(bs.Player['Team']):
+    """Our player type for this game."""
+
+
+class Team(bs.Team[Player]):
+    """Our team type for this game."""
+
+# ba_meta export bascenev1.GameActivity
+class InfiniteNinjasGame(bs.TeamGameActivity[Player, Team]):
+    name = "Infinite Ninjas"
+    description = "How long can you survive from Ninjas??"
+    available_settings = [bs.BoolSetting('Epic Mode', default=False)]
+    scoreconfig = bs.ScoreConfig(label='Time',
+                                 scoretype=bs.ScoreType.MILLISECONDS,
+                                 lower_is_better=False)
+    default_music = bs.MusicType.TO_THE_DEATH
+    
+    def __init__(self, settings:dict):
+        settings['map'] = "Football Stadium"
+        self._epic_mode = settings.get('Epic Mode', False)
+        if self._epic_mode:
+            self.slow_motion = True
+        super().__init__(settings)
+        self._timer: Optional[OnScreenTimer] = None
+        self._winsound = bs.getsound('score')
+        self._won = False
+        self._bots = SpazBotSet()
+        self.wave = 1
+    
+    def on_begin(self) -> None:
+        super().on_begin()
+        
+        self._timer = OnScreenTimer()
+        bs.timer(2.5, self._timer.start)
+        
+        #Bots Hehe
+        bs.timer(2.5,self.street)
+
+    def street(self):
+        for a in range(self.wave):
+            p1 = random.choice([-5,-2.5,0,2.5,5])
+            p3 = random.choice([-4.5,-4.14,-5,-3])
+            time = random.choice([1,1.5,2.5,2])
+            self._bots.spawn_bot(ChargerBot, pos=(p1,0.4,p3),spawn_time = time)
+        self.wave += 1
+        
+    def botrespawn(self):
+        if not self._bots.have_living_bots():
+            self.street()
+    def handlemessage(self, msg: Any) -> Any:
+
+        # A player has died.
+        if isinstance(msg, bs.PlayerDiedMessage):
+            super().handlemessage(msg)  # Augment standard behavior.
+            self._won = True
+            self.end_game()
+        
+        # A spaz-bot has died.
+        elif isinstance(msg, SpazBotDiedMessage):
+            # Unfortunately the bot-set will always tell us there are living
+            # bots if we ask here (the currently-dying bot isn't officially
+            # marked dead yet) ..so lets push a call into the event loop to
+            # check once this guy has finished dying.
+            babase.pushcall(self.botrespawn)
+
+        # Let the base class handle anything we don't.
+        else:
+            return super().handlemessage(msg)
+        return None
+
+    # When this is called, we should fill out results and end the game
+    # *regardless* of whether is has been won. (this may be called due
+    # to a tournament ending or other external reason).
+    def end_game(self) -> None:
+
+        # Stop our on-screen timer so players can see what they got.
+        assert self._timer is not None
+        self._timer.stop()
+
+        results = bs.GameResults()
+
+        # If we won, set our score to the elapsed time in milliseconds.
+        # (there should just be 1 team here since this is co-op).
+        # ..if we didn't win, leave scores as default (None) which means
+        # we lost.
+        if self._won:
+            elapsed_time_ms = int((bs.time() - self._timer.starttime) * 1000.0)
+            bs.cameraflash()
+            self._winsound.play()
+            for team in self.teams:
+                for player in team.players:
+                    if player.actor:
+                        player.actor.handlemessage(bs.CelebrateMessage())
+                results.set_team_score(team, elapsed_time_ms)
+
+        # Ends the activity.
+        self.end(results)
+    
+    

plugins/minigames/lame_fight.py

@@ -0,0 +1,158 @@
+# Ported to api 8 by brostos using baport.(https://github.com/bombsquad-community/baport)
+
+# ba_meta require api 8
+# (see https://ballistica.net/wiki/meta-tag-system)
+
+from __future__ import annotations
+
+import random
+from typing import TYPE_CHECKING
+
+import babase
+import bauiv1 as bui
+import bascenev1 as bs
+from bascenev1lib.actor.spazbot import SpazBotSet, ChargerBot, BrawlerBotProShielded, TriggerBotProShielded, ExplodeyBot, BomberBotProShielded, SpazBotDiedMessage
+from bascenev1lib.actor.onscreentimer import OnScreenTimer
+
+if TYPE_CHECKING:
+    from typing import Any, Type, Dict, List, Optional
+
+def ba_get_api_version():
+    return 6
+
+def ba_get_levels():
+	return [babase._level.Level(
+            'Lame Fight',
+			gametype=LameFightGame,
+			settings={},
+			preview_texture_name='courtyardPreview')]
+
+class Player(bs.Player['Team']):
+    """Our player type for this game."""
+
+
+class Team(bs.Team[Player]):
+    """Our team type for this game."""
+
+# ba_meta export bascenev1.GameActivity
+class LameFightGame(bs.TeamGameActivity[Player, Team]):
+    name = "Lame Fight"
+    description = "Save World With Super Powers"
+    slow_motion = True
+    scoreconfig = bs.ScoreConfig(label='Time',
+                                 scoretype=bs.ScoreType.MILLISECONDS,
+                                 lower_is_better=True)
+    default_music = bs.MusicType.TO_THE_DEATH
+    
+    def __init__(self, settings:dict):
+        settings['map'] = "Courtyard"
+        super().__init__(settings)
+        self._timer: Optional[OnScreenTimer] = None
+        self._winsound = bs.getsound('score')
+        self._won = False
+        self._bots = SpazBotSet()
+    
+    def on_begin(self) -> None:
+        super().on_begin()
+        
+        self._timer = OnScreenTimer()
+        bs.timer(4.0, self._timer.start)
+        
+        #Bots Hehe
+        bs.timer(1.0, lambda: self._bots.spawn_bot(ChargerBot, pos=(3,3,-2),spawn_time = 3.0))
+        bs.timer(1.0, lambda: self._bots.spawn_bot(ChargerBot, pos=(-3,3,-2),spawn_time = 3.0))
+        bs.timer(1.0, lambda: self._bots.spawn_bot(ChargerBot, pos=(5,3,-2),spawn_time = 3.0))
+        bs.timer(1.0, lambda: self._bots.spawn_bot(ChargerBot, pos=(-5,3,-2),spawn_time = 3.0))
+        bs.timer(1.0, lambda: self._bots.spawn_bot(ChargerBot, pos=(0,3,1),spawn_time = 3.0))
+        bs.timer(1.0, lambda: self._bots.spawn_bot(ChargerBot, pos=(0,3,-5),spawn_time = 3.0))
+        bs.timer(9.0, lambda: self._bots.spawn_bot(BomberBotProShielded, pos=(-7,5,-7.5),spawn_time = 3.0))
+        bs.timer(9.0, lambda: self._bots.spawn_bot(BomberBotProShielded, pos=(7,5,-7.5),spawn_time = 3.0))
+        bs.timer(9.0, lambda: self._bots.spawn_bot(BomberBotProShielded, pos=(7,5,1.5),spawn_time = 3.0))
+        bs.timer(9.0, lambda: self._bots.spawn_bot(BomberBotProShielded, pos=(-7,5,1.5),spawn_time = 3.0))
+        bs.timer(12.0, lambda: self._bots.spawn_bot(TriggerBotProShielded, pos=(-1,7,-8),spawn_time = 3.0))
+        bs.timer(12.0, lambda: self._bots.spawn_bot(TriggerBotProShielded, pos=(1,7,-8),spawn_time = 3.0))
+        bs.timer(15.0, lambda: self._bots.spawn_bot(ExplodeyBot, pos=(0,3,-5),spawn_time = 3.0))
+        bs.timer(20.0, lambda: self._bots.spawn_bot(ExplodeyBot, pos=(0,3,1),spawn_time = 3.0))
+        bs.timer(20.0, lambda: self._bots.spawn_bot(ExplodeyBot, pos=(-5,3,-2),spawn_time = 3.0))
+        bs.timer(20.0, lambda: self._bots.spawn_bot(ExplodeyBot, pos=(5,3,-2),spawn_time = 3.0))
+        bs.timer(30,self.street)
+
+    def street(self):
+        bs.broadcastmessage("Lame Guys Are Here!",color = (1,0,0))
+        for a in range(-1,2):
+            for b in range(-3,0):
+                self._bots.spawn_bot(BrawlerBotProShielded, pos=(a,3,b),spawn_time = 3.0)
+        
+    def spawn_player(self, player: Player) -> bs.Actor:
+        spawn_center = (0, 3, -2)
+        pos = (spawn_center[0] + random.uniform(-1.5, 1.5), spawn_center[1],
+               spawn_center[2] + random.uniform(-1.5, 1.5))
+        spaz = self.spawn_player_spaz(player,position = pos)
+        p = ["Bigger Blast","Stronger Punch","Shield","Speed"]
+        Power = random.choice(p)
+        spaz.bomb_type = random.choice(["normal","sticky","ice","impact","normal","ice","sticky"])
+        bs.broadcastmessage(f"Now You Have {Power}")
+        if Power == p[0]:
+            spaz.bomb_count = 3
+            spaz.blast_radius = 2.5
+        if Power == p[1]:
+            spaz._punch_cooldown = 350
+            spaz._punch_power_scale = 2.0
+        if Power == p[2]:
+            spaz.equip_shields()
+        if Power == p[3]:
+            spaz.node.hockey = True
+        return spaz
+    def _check_if_won(self) -> None:
+        if not self._bots.have_living_bots():
+            self._won = True
+            self.end_game()
+    def handlemessage(self, msg: Any) -> Any:
+
+        # A player has died.
+        if isinstance(msg, bs.PlayerDiedMessage):
+            super().handlemessage(msg)  # Augment standard behavior.
+            self.respawn_player(msg.getplayer(Player))
+
+        # A spaz-bot has died.
+        elif isinstance(msg, SpazBotDiedMessage):
+            # Unfortunately the bot-set will always tell us there are living
+            # bots if we ask here (the currently-dying bot isn't officially
+            # marked dead yet) ..so lets push a call into the event loop to
+            # check once this guy has finished dying.
+            babase.pushcall(self._check_if_won)
+
+        # Let the base class handle anything we don't.
+        else:
+            return super().handlemessage(msg)
+        return None
+
+    # When this is called, we should fill out results and end the game
+    # *regardless* of whether is has been won. (this may be called due
+    # to a tournament ending or other external reason).
+    def end_game(self) -> None:
+
+        # Stop our on-screen timer so players can see what they got.
+        assert self._timer is not None
+        self._timer.stop()
+
+        results = bs.GameResults()
+
+        # If we won, set our score to the elapsed time in milliseconds.
+        # (there should just be 1 team here since this is co-op).
+        # ..if we didn't win, leave scores as default (None) which means
+        # we lost.
+        if self._won:
+            elapsed_time_ms = int((bs.time() - self._timer.starttime) * 1000.0)
+            bs.cameraflash()
+            self._winsound.play()
+            for team in self.teams:
+                for player in team.players:
+                    if player.actor:
+                        player.actor.handlemessage(bs.CelebrateMessage())
+                results.set_team_score(team, elapsed_time_ms)
+
+        # Ends the activity.
+        self.end(results)
+    
+