Quad Clash

    GetBestPlayer() : void = 
        # Retrieve all players currently in the playspace
        AllPlayers := GetPlayspace().GetPlayers()
        
        # Loop through each player to populate the Scores array with their current scores
        for(IDX := 0..Scores.Length-1):
            if (Player := AllPlayers[IDX]):
                # Set the score for each player in the Scores array
                if (set Scores[IDX] = ScoreManager.GetCurrentScore(Player)){}
        
        # Initialize a flag to track whether any scores were swapped during sorting
        var Swapped : logic = false
        
        # Main loop to repeatedly sort scores and update the leaderboard display
        loop:
            Sleep(5.0)  # Runs every 5 seconds to keep it up to date
            set Swapped = false  # Reset Swapped to detect any new swaps in this iteration
            
            # Bubble sort loop to order scores in descending order
            for(IDX := 0..Scores.Length-1):
                # Compare each score with the next; swap if current score is higher
                if(Scores[IDX] > Scores[IDX + 1]):
                    if (NextScore := Scores[IDX + 1], CurrentScore := Scores[IDX]):
                        # Perform the swap of scores in the array
                        if(set Scores[IDX] = NextScore, set Scores[IDX + 1] = CurrentScore):
                            set Swapped = true  # Mark that a swap happened
            
            # Once sorting is complete (no swaps), determine the highest scorer
            if (Swapped = false):
                # Check each player to see who matches the top score (Scores[0])
                for (Player : AllPlayers):
                    if (HighScore := Scores[0], HighScore > 0):
                        # If player's score matches the top score, display them on the DanceMannequin
                        if (ScoreManager.GetCurrentScore(Player) = HighScore):
                            DanceMannequin.ActivateSkinAndEmoteCapture(Player)
                    else:
                        # If no high score is found, set the mannequin to its default appearance
                        DanceMannequin.ActivateDefaultPreset()
                break  # Exit loop after displaying the best player
    

        

This code is a simple function to identify the player with the highest score and display their avatar at the top of the hub. It starts by retrieving all players and assigning each player's score to an index in the Scores[] array. Using a bubble sort, it repeatedly checks and swaps scores until they're sorted in descending order. Once sorted, the top player (Scores[0]) is displayed by the DanceMannequin device. If no high score is found, the default mannequin preset is shown. This loop runs every 5 seconds, making sure it stays up to date.

    TeleportAllToArenas() : void =
        # Get the collection of all teams within the playspace
        TeamCollection := GetPlayspace().GetTeamCollection()
        
        # Loop through two indices representing the two winning and two losing teams
        for (Index := 0..1):
            # Retrieve the team from the WinnerTeams array at the current index
            if (WinnerTeam := WinnerTeams[Index]):
                # Get the agents (members) of the winning team and the designated teleporter
                if (TeamMembers := TeamCollection.GetAgents[WinnerTeam]): 
                    if (WinnerTeleporter := Teleporters[Index + WinnerPlacer + ArenaCycler]):
                        # Teleport each team member to their assigned winner teleporter
                        for (Member : TeamMembers):
                            WinnerTeleporter.Teleport(Member)
        
            # Retrieve the team from the LoserTeams array at the current index
            if (LoserTeam := LoserTeams[Index]): 
                # Get the agents (members) of the losing team and the designated teleporter
                if (TeamMembers := TeamCollection.GetAgents[LoserTeam]): 
                    if (LoserTeleporter := Teleporters[Index + LoserPlacer + ArenaCycler]):
                        # Teleport each team member to their assigned loser teleporter
                        for (Member : TeamMembers):
                            LoserTeleporter.Teleport(Member)
        
        # Increment ArenaCycler by 2 to change the arenas the players are going to play in
        set ArenaCycler += 2
        
        # Reset ArenaCycler and swap positions for winner and loser placers when the limit is reached
        if (ArenaCycler > 6, LoserPlace := LoserPlacer, WinnerPlace := WinnerPlacer):
            set ArenaCycler = 0
            set WinnerPlacer = LoserPlace
            set LoserPlacer = WinnerPlace
            Print("Swapped")

        

This code teleports members of winning and losing teams to designated arena teleporters based on their team status. It cycles through two indices for the teams, retrieves team members, and assigns each to specific teleporters (winner or loser) in sequence. After teleporting, it increments a counter (ArenaCycler) to adjust for the next round (this makes sure the teams play in different arenas every round). Once a threshold is reached, it resets the counter and swaps the positions for the winner and loser teleporters to keep the placements dynamic.