team_settings_and_inventory_device: Run Your Own Team Rules

Overview

The team_settings_and_inventory_device represents the configuration for ONE team (the Team Setting Value you pick in its Details panel). Think of it as the team's brain: it fires events when that team scores an elimination, loses a member, spawns a member, or runs out of respawns — and it exposes methods to query membership (IsOnTeam, GetTeamMembers), force a respawn (RespawnAtPlayerSpawner), shuffle temporary team membership, and end the round with that team as the winner (EndRound).

Reach for it when you want behavior beyond the global island settings: a king-of-the-hill team that wins instantly when an event triggers, a survival mode where the round ends the moment a team is out of respawns, or a special spawn pipeline that drops a player at the best available spawner. You typically place one device per team and give each its own @editable reference.

API Reference

team_settings_and_inventory_device

Provides team and inventory configurations that go beyond the choices the My Island settings provide. Can also be used to customize individual devices and create variations in team setup.

Full public surface, resolved verbatim from the live Epic digest (Fortnite.digest.verse).

team_settings_and_inventory_device<public> := class<concrete><final>(creative_device_base):

Events (subscribe a handler to react):

Methods (call these to make the device act):

Walkthrough

Let's build a last-team-standing round controller. We have two of these devices, one configured for Team 1 and one for Team 2. The rules:

• When a team runs out of respawns, the OTHER team wins the round.
• Every time a team member spawns, we announce how many members that team has left.
• When a team member is eliminated, we re-spawn the eliminating enemy... wait — we keep it simple: we just count and announce.

team_round_controller := class(creative_device):

    # One device per team, configured in the Details panel.
    @editable
    Team1Settings : team_settings_and_inventory_device = team_settings_and_inventory_device{}

    @editable
    Team2Settings : team_settings_and_inventory_device = team_settings_and_inventory_device{}

    # Localized text helper — message params need a localized value, not a raw string.
    Announce<localizes>(S : string) : message = "{S}"

    OnBegin<override>()<suspends>:void =
        # If Team 1 runs out of respawns, Team 2 wins the round.
        Team1Settings.TeamOutOfRespawnsEvent.Subscribe(OnTeam1Wiped)
        Team2Settings.TeamOutOfRespawnsEvent.Subscribe(OnTeam2Wiped)

        # Announce roster size whenever a member spawns.
        Team1Settings.TeamMemberSpawnedEvent.Subscribe(OnTeam1Spawned)
        Team2Settings.TeamMemberSpawnedEvent.Subscribe(OnTeam2Spawned)

    OnTeam1Wiped():void =
        # Team 1 has no respawns left, so Team 2 wins.
        Print("Team 1 wiped out — Team 2 wins!")
        Team2Settings.EndRound()

    OnTeam2Wiped():void =
        Print("Team 2 wiped out — Team 1 wins!")
        Team1Settings.EndRound()

    OnTeam1Spawned(Agent : agent):void =
        Members := Team1Settings.GetTeamMembers()
        Print("Team 1 now has {Members.Length} members")

    OnTeam2Spawned(Agent : agent):void =
        Members := Team2Settings.GetTeamMembers()
        Print("Team 2 now has {Members.Length} members")

Line by line:

• team_round_controller := class(creative_device): — our Verse device. Only a class deriving from creative_device can hold @editable references to placed devices.
• The two @editable fields are the two team devices we placed in the level. We assign each one in the Details panel after compiling.
• Announce<localizes>(S : string) : message — a localized-text helper. Any device method that wants a message needs one of these, not a plain string. (We don't pass messages in this example, but it's the pattern you'll reuse for HUD devices.)
• OnBegin<override>()<suspends>:void = — runs when the game starts. All event subscriptions happen here.
• TeamOutOfRespawnsEvent.Subscribe(...) — this event is listenable(tuple()), so its handler takes NO parameters. When a team is wiped, we call EndRound() on the OTHER team's device to award them the win.
• TeamMemberSpawnedEvent.Subscribe(...) — a listenable(agent) event, so the handler receives an agent. Inside we call GetTeamMembers() (which <reads> and returns []agent) and print the live roster size.
• EndRound() ends the current round and makes the device's team the winner — exactly the win condition we want.

Common patterns

React to enemy eliminations and check membership

EnemyEliminatedEvent fires when a member of this team eliminates an enemy, handing you the eliminator agent. We verify they really are on the team with the <decides> method IsOnTeam.

team_score_tracker := class(creative_device):

    @editable
    BlueTeam : team_settings_and_inventory_device = team_settings_and_inventory_device{}

    OnBegin<override>()<suspends>:void =
        BlueTeam.EnemyEliminatedEvent.Subscribe(OnEnemyDown)

    OnEnemyDown(Eliminator : agent):void =
        # IsOnTeam <decides> — use it inside an if to confirm membership.
        if (BlueTeam.IsOnTeam[Eliminator]):
            Print("A confirmed Blue Team member got a kill!")
        else:
            Print("Eliminator was not on Blue Team.")

Custom respawn at the best player spawner

When a team member is eliminated, force them back into play using RespawnAtPlayerSpawner. The event gives an agent; we narrow it to a player before calling the method.

team_respawner := class(creative_device):

    @editable
    RedTeam : team_settings_and_inventory_device = team_settings_and_inventory_device{}

    OnBegin<override>()<suspends>:void =
        RedTeam.TeamMemberEliminatedEvent.Subscribe(OnMemberDown)

    OnMemberDown(Agent : agent):void =
        # RespawnAtPlayerSpawner takes a player, so narrow the agent.
        if (P := player[Agent]):
            RedTeam.RespawnAtPlayerSpawner(P)
            Print("Respawned a fallen Red Team member.")

Return temporary members to their original teams

If you've been moving players onto a temporary team (e.g. a brief minigame squad), RemoveTemporaryMembersFromTeam sends them all back at once.

temp_team_reset := class(creative_device):

    @editable
    EventTeam : team_settings_and_inventory_device = team_settings_and_inventory_device{}

    @editable
    ResetButton : button_device = button_device{}

    OnBegin<override>()<suspends>:void =
        ResetButton.InteractedWithEvent.Subscribe(OnReset)

    OnReset(Agent : agent):void =
        # Send a single agent back to their original team...
        EventTeam.RemoveTemporaryMemberFromTeam(Agent)
        # ...or send everyone on this temporary team back at once.
        EventTeam.RemoveTemporaryMembersFromTeam()
        Print("Temporary members returned to their original teams.")

Gotchas

• TeamOutOfRespawnsEvent is listenable(tuple()) — its handler takes NO arguments (OnTeam1Wiped():void). Don't try to declare an agent parameter or it won't subscribe.
• IsOnTeam is <decides>, not a bool-returner. Call it inside an if (Device.IsOnTeam[Agent]): with square brackets. There's no true/false value to compare.
• RespawnAtPlayerSpawner needs a player, not an agent. The events hand you agent values; narrow with if (P := player[Agent]): before calling. The same method has an overload that accepts a []player_spawner_device if you want to restrict which spawners are eligible.
• One device = one team. Each placed device targets the Team Setting Value in its Details panel. Calling EndRound() makes THAT device's team win — so to make the surviving team win when another is wiped, call EndRound() on the survivor's device, not the wiped one.
• GetTeamMembers() reflects live state. It returns the current []agent; a member who just got eliminated may already be gone, so read it at the right moment (e.g. on a spawn event).
• Message params want localized text. Any method or device that takes a message needs a <localizes> helper like Announce above — there is no StringToMessage and a raw string won't compile.