You dont need them anymore, I found a better way to set and get team:
using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /Verse.org/Random }
using { /Fortnite.com/Characters }
using { /Fortnite.com/Game }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /UnrealEngine.com/Temporary/SpatialMath}
using { /Fortnite.com/FortPlayerUtilities }
using { config }
team_manager := class(creative_device):
@editable RoundManager<private>:round_manager = round_manager{}
@editable TrackerSaveTeam:tracker_device = tracker_device{}
@editable SpectateSwitch:switch_device = switch_device{}
@editable CheckSpectateStateTrigger:trigger_device = trigger_device{}
@editable NewPlayerSwitch:switch_device = switch_device{}
@editable NoClass<private>:class_and_team_selector_device = class_and_team_selector_device{}
Logger<private>:log = log{Channel:=log_device}
# If 1 team remains, set this to the team number of the winners
var WinningTeam<public>:?int = false
var PlayingAgents:[]agent = array{}
var SpectateMap:[agent]logic = map{}
OnBegin<override>()<suspends>:void={
SubscribeAll()
for(Agent:GetAllAgents()):
if(FC := Agent.GetFortCharacter[]):
FC.EliminatedEvent().Subscribe(OnPlayerEliminated)
}
# Get team number of agent
GetTeam<public>(Agent:agent)<transacts>:int={
TeamCollection := Self.GetPlayspace().GetTeamCollection()
if(AgentTeam := TeamCollection.GetTeam[Agent]):
for(I -> Team:TeamCollection.GetTeams()):
if(AgentTeam = Team):
return I+1
return -1
}
# Set team for an agent
SetTeam<public>(Agent:agent,TeamNumber:int):void={
TeamCollection := Self.GetPlayspace().GetTeamCollection()
if(Team := TeamCollection.GetTeams()[TeamNumber-1]):
if(TeamCollection.AddToTeam[Agent, Team]){}
TrackerSaveTeam.SetValue(Agent,TeamNumber)
}
#Heal agent for Amount
HealAgent<public>(Agent:agent, Amount:float):void={
if(FortCharacter := Agent.GetFortCharacter[]):
HP := FortCharacter.GetHealth()
Shield := FortCharacter.GetShield()
HPMissing := FortCharacter.GetMaxHealth() - HP
FortCharacter.SetHealth(Clamp(HP + Amount,0.0,FortCharacter.GetMaxHealth()))
FortCharacter.SetShield(Clamp(Shield + Clamp(Amount - HPMissing,0.0,Amount),0.0,FortCharacter.GetMaxShield()))
}
# Get all Agents in the Experience, spectators too
GetAllAgents<public>()<transacts>:[]agent={
return Self.GetPlayspace().GetPlayers()
}
# Gets all active agents in these teams: Teams
GetAllActiveAgents<public>()<transacts>:[]agent={
ActiveAgents := for:
Agent:GetAllAgents()
FortCharacter := Agent.GetFortCharacter[]
FortCharacter.IsActive[]
do:
Agent
return ActiveAgents
}
GetFightingAgents<public>()<transacts>:[]agent={
Agents := for:
Agent:GetAllAgents()
FortCharacter := Agent.GetFortCharacter[]
FortCharacter.IsActive[]
#not EliminatedMap[Agent]?
do:
Agent
return Agents
}
# Returns an array with all the teams that are still alive
GetFightingTeams<public>()<transacts>:[]int={
# Put the teamsize for each team in a map from TeamNumber => TeamSize
var ActiveTeams:[]int = array{}
for:
Agent:GetFightingAgents()
FortCharacter := Agent.GetFortCharacter[]
FortCharacter.IsActive[]
do:
TeamNumber := GetTeam(Agent)
set ActiveTeams += array{TeamNumber}
return SortArray(RemoveDuplicates(ActiveTeams))
}
# Get a random Agent that has not been eliminated
GetRandomActiveAgent<public>()<decides><transacts>:agent={
ActiveAgents := GetAllActiveAgents()
Index := GetRandomInt(0,ActiveAgents.Length - 1)
return ActiveAgents[Index]
}
# Get a random Agent
GetRandomAgent<public>()<decides><transacts>:agent={
Agents := GetAllAgents()
Index := GetRandomInt(0,Agents.Length - 1)
return Agents[Index]
}
# Get a list of Agents that are on this team
GetAgentsInTeam<public>(Team:int)<transacts>:[]agent={
Agents := for:
Agent:GetAllAgents()
GetTeam(Agent) = Team
do:
Agent
return Agents
}
CheckLMS<private>()<suspends>:void={
Sleep(0.0)
LMS()
}
# Set member variable WinningTeam to winner. Use in main.verse to end the round
LMS<public>()<transacts>:?int={
# On LMS, set WinningTeam value
set WinningTeam = false
PlayingTeams := RemoveFromArray(GetFightingTeams(), SpectateTeam)
if(PlayingTeams.Length = 1):
set WinningTeam = option{PlayingTeams[0]}
else if(PlayingTeams.Length < 1):
if(RandomAgent := GetRandomAgent[]):
set WinningTeam = option{GetTeam(RandomAgent)}
return WinningTeam
}
# Completes on LMS, returns the Last Standing Team
AwaitLMS<public>()<suspends>:int={
set WinningTeam = false
spawn {CheckLMS()}
loop:
if(TeamNumber := WinningTeam?):
return TeamNumber
Sleep(0.01)
}
AwaitMaxPlayersLoaded()<suspends>:void={
loop:
Sleep(0.5)
if(PlayingAgents.Length >= MaxPlayerCount):
break
}
# Returns an array with all the teams that are still alive
GetActiveTeams<public>()<transacts>:[]int={
# Put the teamsize for each team in a map from TeamNumber => TeamSize
var ActiveTeams:[]int = array{}
for:
Agent:GetAllAgents()
FortCharacter := Agent.GetFortCharacter[]
FortCharacter.IsActive[]
do:
TeamNumber := GetTeam(Agent)
set ActiveTeams += array{TeamNumber}
return SortArray(RemoveDuplicates(ActiveTeams))
}
# TODO, update function when persistance is out
# Subscribe all devices
SubscribeAll<private>():void={
NewPlayerSwitch.TurnedOnEvent.Subscribe(OnPlayerAdded)
Self.GetPlayspace().PlayerRemovedEvent().Subscribe(OnPlayerRemoved)
SpectateSwitch.TurnedOnEvent.Subscribe(SpectateButtonTurnedOn)
SpectateSwitch.TurnedOffEvent.Subscribe(SpectateButtonTurnedOff)
}
SpectateButtonTurnedOn(Agent:agent):void={
if(set SpectateMap[Agent] = true){}
}
SpectateButtonTurnOn(MaybeAgent:?agent):void={
if(Agent := MaybeAgent?):
if(set SpectateMap[Agent] = true){}
}
SpectateButtonTurnedOff(Agent:agent):void={
if(set SpectateMap[Agent] = false){}
}
# Handle player joining the island
OnPlayerAdded<private>(Agent:agent):void={
SpectateSwitch.ClearPersistenceData(Agent)
TrackerSaveTeam.ClearPersistence(Agent)
if(FC := Agent.GetFortCharacter[]):
FC.EliminatedEvent().Subscribe(OnPlayerEliminated)
}
# Handle player leaving the island
OnPlayerRemoved<private>(Agent:agent):void={
if(Temp := PlayingAgents.RemoveFirstElement[Agent]){set PlayingAgents = Temp}
# Check if only 1 team remains on remove
spawn {CheckLMS()}
}
# Check LMS on Eliminated
OnPlayerEliminated<private>(Result:elimination_result):void={
Print("Player eliminated in team manager")
spawn {CheckLMS()}
}
RespawnAgents<public>()<suspends>:void={
for(Agent:GetAllAgents()):
#if(GetTeam(Agent) <> SpectateTeam and EliminatedMap[Agent]?):
if(GetTeam(Agent) <> SpectateTeam and not Agent.GetFortCharacter[].IsActive[]):
spawn{RespawnAgent(Agent)}
}
RespawnAgent<public>(Agent:agent)<suspends>:void={
if(FortCharacter := Agent.GetFortCharacter[]):
if(not FortCharacter.IsActive[]):
Agent.Respawn(FortCharacter.GetTransform().Translation,FortCharacter.GetViewRotation())
Sleep(0.0)
NoClass.ChangeClass(Agent)
}