prop hunt and stronghold .verse files added

Code_Reference/PropHunt/txt/base_team.txt

@@ -0,0 +1,81 @@
+using { /Fortnite.com/Characters }
+using { /Fortnite.com/Devices }
+using { /Fortnite.com/UI }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /UnrealEngine.com/Temporary/SpatialMath }
+using { /UnrealEngine.com/Temporary/UI }
+using { /Verse.org/Colors }
+using { /Verse.org/Simulation }
+
+log_team := class(log_channel){}
+
+# This class defines the devices needed for the different teams in the experience.
+# This class is abstract so it cannot be used on its own. It has to be inherited by another class.
+base_team := class<abstract>:
+    Logger:log = log{Channel:=log_team}
+
+    @editable # Used to set a player to the team.
+    ClassSelector:class_and_team_selector_device = class_and_team_selector_device{}
+  
+    @editable # Used to award score to agents on the team.
+    ScoreManager:score_manager_device = score_manager_device{}
+    
+    @editable # Used to display the team assignment title.
+    TeamTitle:hud_message_device = hud_message_device{}
+    
+    @editable # Used to display the team assignment description.
+    TeamDescription:hud_message_device = hud_message_device{}
+    
+    @editable # Used to subscribe to team member (prop team) or enemy (hunter team) eliminated events.
+    TeamManager:team_settings_and_inventory_device = team_settings_and_inventory_device{}
+
+    # This is an array of agents on the team.
+    var TeamAgents<private>:[]agent = array{}
+
+    # This event is signaled when the TeamAgents array becomes empty (signaling the end of the round).
+    TeamEmptyEvent:event() = event(){}
+
+    # Returns the current TeamAgents array.
+    # This is required because the TeamAgents array is private, so other classes cannot access it directly.
+    GetAgents()<decides><transacts>:[]agent =
+        TeamAgents
+
+    # Return the size of the TeamAgents array
+    # This requires a function because the TeamAgents array is private, so other classes cannot access it directly.
+    Count()<transacts>:int = 
+        TeamAgents.Length
+
+    # Returns an index in the TeamAgents array of an agent, fails otherwise.
+    FindOnTeam(Agent:agent)<decides><transacts>: int =
+        Index := TeamAgents.Find[Agent] 
+        
+    # Set the agent to the team and notify the player. 
+    InitializeAgent(Agent:agent):void =
+        AddAgentToTeam(Agent)
+        ClassSelector.ChangeTeamAndClass(Agent)
+        DisplayTeamInformation(Agent)
+  
+    # Add an agent to TeamAgents.
+    AddAgentToTeam(AgentToAdd:agent):void =
+        if (not FindOnTeam[AgentToAdd]):
+            Logger.Print("Adding agent to team.")
+            set TeamAgents += array{AgentToAdd}
+
+    # Activates hud message devices to show the player what team they are on
+    DisplayTeamInformation(Agent:agent):void =
+        TeamTitle.Show(Agent)
+        TeamDescription.Show(Agent)
+
+    # When an agent leaves the match, remove them from the TeamAgents array and check for the end of the round. 
+    EliminateAgent(Agent:agent)<suspends>:void =
+        Sleep(0.0) # Delaying 1 game tick to ensure the player is respawned before proceeding.
+        RemoveAgentFromTeam(Agent)
+
+    # Remove an agent from TeamAgents.
+    # If the agent removed was the last, signal TeamEmptyEvent.
+    RemoveAgentFromTeam(AgentToRemove:agent):void =
+        set TeamAgents = TeamAgents.RemoveAllElements(AgentToRemove)
+        Logger.Print("{Count()} agent(s) on team remaining.")
+        if (Count() < 1):
+            Logger.Print("No agents on team remaining. Ending the round.")
+            TeamEmptyEvent.Signal()

Code_Reference/PropHunt/txt/billboard_cinematic_flythrough.txt

@@ -0,0 +1,187 @@
+using { /Fortnite.com/Characters }
+using { /Fortnite.com/Devices }
+using { /Fortnite.com/FortPlayerUtilities }
+using { /Fortnite.com/UI }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /UnrealEngine.com/Temporary/SpatialMath}
+using { /UnrealEngine.com/Temporary/UI }
+using { /Verse.org/Simulation }
+using { /Verse.org/Simulation/Tags } 
+
+# Gameplay tag for objects that should be displayed or hidden during cinematic
+cinematic_objects := class(tag):
+
+# Script that sets the player into a cinematic mode so its not in the cinematic, and then resets them when the cinematic is done
+billboard_cinematic := class<concrete>:
+
+    # A reference to the device that contains the level sequence to be played
+    @editable
+    CinematicSequence:cinematic_sequence_device := cinematic_sequence_device{}
+
+    # A reference to the device that will hide the HUD
+    @editable
+    HUDController:hud_controller_device := hud_controller_device{}
+
+    # Should the Skip Intro button be visible during the cinematic
+    @editable
+    ShowUI:logic := true
+
+    # Should Devices and Billboards be visible during the cinematic
+    @editable
+    ShowCreativeObjects:logic := true
+
+    # Should play the cinematic at the beginning of game
+    @editable
+    PlayAtStart:logic = true
+
+    # Reference to the Radio that plays music
+    @editable
+    Music:radio_device := radio_device{}
+
+    # Signaled when the cinematic has completed.
+    CinematicCompleted<public>:event() = event(){}
+
+    # Runs at the beginning of the script.
+    EnterCinematicModeForAll<public>(InPlayers:[]player):void=
+        HUDController.Enable()
+
+        if (ShowCreativeObjects?):
+            ShowObjectsInCinematic()
+        else:
+            HideObjectsInCinematic()
+
+        for:
+            Player : InPlayers
+            not Player.IsSpectator[]
+        do:
+            spawn{EnterCinematicMode(Player)}
+        
+        Music.Play()
+
+    # Sets players to visible, re-enables their movement, and removes the skip button.
+    EndCinematicModeForAll<public>(InPlayers:[]player):void=
+        Music.Stop()
+        for:
+            Player : InPlayers
+            not Player.IsSpectator[]
+        do:
+            EndCinematicMode(Player)
+
+        HUDController.Disable()
+        HideObjectsInCinematic()
+
+    # UI to show during the cinematic
+    CinematicUI<private>:cinematic_ui = cinematic_ui{}
+
+    # Handler for player choosing to skip cinematic
+    HandleSkipIntroInteraction<private>(WidgetMessage:widget_message):void=
+        EndCinematicMode(WidgetMessage.Player)
+
+    # Sets players to invisible, removes their movement, optionally gives them a skip button, then waits for the cinematic to end before signaling that it has completed.
+    EnterCinematicMode<private>(Player:player)<suspends>:void=
+        HidePlayer(Player)
+
+        if:
+            ShowUI?
+            PlayerUI := GetPlayerUI[Player]
+        then:
+            Listenable := CinematicUI.Show(Player, PlayerUI)
+            Listenable.Subscribe(HandleSkipIntroInteraction)
+
+        CinematicSequence.Play(Player)
+        
+        CinematicSequence.StoppedEvent.Await()
+        CinematicCompleted.Signal()
+
+    # Stop cinematic for player
+    EndCinematicMode<private>(Player:player):void=
+        CinematicSequence.Stop(Player)
+        ShowPlayer(Player)
+        CinematicUI.Hide(Player)
+
+    # Make player invisible and unmoveable
+    HidePlayer<private>(Player:player):void=
+        if (FortCharacter := Player.GetFortCharacter[]):
+            CinematicStasis := stasis_args{AllowTurning := false, AllowFalling := false, AllowEmotes := false}
+
+            FortCharacter.PutInStasis(CinematicStasis)
+            FortCharacter.Hide()
+
+    # Make player visible and moveable
+    ShowPlayer<private>(Player:player):void=
+        if (FortCharacter := Player.GetFortCharacter[]):
+            FortCharacter.ReleaseFromStasis()
+            FortCharacter.Show()
+
+    # Find all objects tagged and make them visible
+    ShowObjectsInCinematic<private>():void=
+        ObjectsToShow := GetCreativeObjectsWithTag(cinematic_objects{})
+
+        for (Object : ObjectsToShow):
+            if (Billboard := billboard_device[Object]):
+                Billboard.ShowText()
+            else if (Device := creative_device[Object]):
+                Device.Show()
+            else if (Radio := radio_device[Object]):
+                Radio.Show()
+            else if (AudioPlayer := audio_player_device[Object]):
+                AudioPlayer.Show()
+
+    # Find all objects tagged and make them invisible
+    HideObjectsInCinematic<private>():void=
+        ObjectsToHide := GetCreativeObjectsWithTag(cinematic_objects{})
+
+        for (Object : ObjectsToHide):
+            if (Billboard := billboard_device[Object]):
+                Billboard.HideText()
+            else if (Device := creative_device[Object]):
+                Device.Hide()
+            else if (Radio := radio_device[Object]):
+                Radio.Hide()
+            else if (AudioPlayer := audio_player_device[Object]):
+                AudioPlayer.Hide()
+
+# Class in charge of UI for cinematic
+cinematic_ui := class:
+
+    # Create a canvas widget that displays a skip button for the cinematic
+    CreateUI():tuple(canvas, listenable(widget_message))=
+        SkipButton:button_regular = button_regular{DefaultText := SkipCinematicText}
+        SkipButton.SetEnabled(true)
+
+        UICanvas:canvas = canvas:
+            Slots := array:
+                canvas_slot:
+                    Anchors := anchors{Minimum := vector2{X := 0.9, Y := 0.9}, Maximum := vector2{X := 0.9, Y := 0.9}}
+                    Offsets := margin{Top := 0.0, Left := 0.0, Right := 0.0, Bottom := 0.0}
+                    Alignment := vector2{X := 1.0, Y := 1.0}
+                    SizeToContent := true
+                    Widget := SkipButton
+
+        return (UICanvas, SkipButton.OnClick())
+
+    # Shows the UI for the player and returns the listenable for the button
+    Show(Player:player, PlayerUI:player_ui):listenable(widget_message)=
+        UIResult := CreateUI()
+        UICanvas := UIResult(0)
+        Listenable := UIResult(1)
+
+        PlayerUISlot := player_ui_slot{ZOrder := 0, InputMode := ui_input_mode.All}
+        PlayerUI.AddWidget(UICanvas, PlayerUISlot)
+        if (set UIPerPlayer[Player] = option{UICanvas}):
+        
+        return Listenable
+
+    # Hides the UI for the player
+    Hide(Player:player):void=
+        if:
+            PlayerUI := GetPlayerUI[Player]
+            CustomUI := UIPerPlayer[Player]?
+        then:
+            PlayerUI.RemoveWidget(CustomUI)
+            if (set UIPerPlayer[Player] = false):
+
+    # A localizable message to display as text in the UI
+    SkipCinematicText<localizes><private>:message = "Skip Intro"
+
+    var UIPerPlayer<private>:[player]?canvas = map{}

Code_Reference/PropHunt/txt/heartbeat.txt

@@ -0,0 +1,121 @@
+using { /Fortnite.com/Characters }
+using { /Fortnite.com/Devices }
+using { /Fortnite.com/UI }
+using { /UnrealEngine.com/Temporary/SpatialMath }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /UnrealEngine.com/Temporary/UI }
+using { /Verse.org/Colors }
+using { /Verse.org/Simulation }
+
+log_heart_beat := class(log_channel){}
+
+# These messages are used to notify a prop agent with a message (or to hide it) when they need to move to avoid their heart beat from becoming visible.
+HeartBeatWarningMessage<localizes>(Time:int):message = "Heart Beat in {Time} Seconds. Move!"
+HeartBeatWarningClear<localizes>:message = ""
+
+# This class exposed the editable properties for the heartbeat to the prop_hunt device.
+heart_beat := class<concrete>():
+    Logger:log = log{Channel:=log_heart_beat}
+
+    @editable # The number of seconds before a prop agent must move before the heart beat reveals their position.
+    MoveTime:float = 15.0
+
+    @editable # The seconds remaining before the heart beat warning appears. Shouldn't be > than HeartBeatTimer.
+    WarningTime:float = 5.0
+
+    @editable # An array of heart beat VFX devices. There is one per player.
+    AgentVFX:[]heartbeat_vfx = array{}
+    
+    @editable # The audio player device used to play the heart beat sound effects (SFX).
+    SFXPlayer:radio_device = radio_device{}
+
+    # This map associates a UI for displaying the heart beat warning to each prop agent. 
+    var WarningUI:[agent]heartbeat_warning_ui = map{}
+
+    # Keeps track of how many players have an active heartbeat so we can manage the SFX device.
+    var NumberOfHeartBeats:int = 0
+
+    # Sets up heart beat UI for the agent.
+    SetUpUI(PropAgent:agent):void =
+        if:
+            not WarningUI[PropAgent]
+            AsPlayer := player[PropAgent]
+            PlayerUI := GetPlayerUI[AsPlayer]
+        then:
+            UIData:heartbeat_warning_ui = heartbeat_warning_ui{}
+            UIData.CreateCanvas()
+            PlayerUI.AddWidget(UIData.Canvas, player_ui_slot{ZOrder := 1})
+            if (set WarningUI[PropAgent] = UIData) {}
+
+    # Activates the heartbeat VFX and SFX for the specified player.
+    Enable(PropAgent:agent, HeartBeatVFXData:heartbeat_vfx):void =
+        if:
+            # Get the character, which is used to find the prop agent's position in the scene. 
+            Character := PropAgent.GetFortCharacter[]
+        then:
+            # Set the heart beat VFX's position to the prop agent's position.
+            HeartBeatVFXData.Activate(Character.GetTransform())
+            # Increment the heartbeat count, and if this is the first heartbeat playing, we need to play the audio to get it started.
+            set NumberOfHeartBeats += 1
+            if (NumberOfHeartBeats = 1) then SFXPlayer.Play()
+            # Register the prop agent to the audio player device so the heart beat audio will play from that position.
+            SFXPlayer.Register(PropAgent)
+        else:
+            Logger.Print("Character, Index, or HeartBeatVFXData not found. Cannot start the heartbeat")
+
+    # Clears the heartbeat VFX and SFX for the specified prop agent.
+    Disable(PropAgent:agent, HeartBeatVFXData:heartbeat_vfx):void =
+        Logger.Print("Disabling heart beat.")
+        # Deactivate the VFX visuals.
+        HeartBeatVFXData.Deactivate()
+        # Unregister the prop agent from the audio player device, causing the heart beat audio to stop.
+        SFXPlayer.Unregister(PropAgent)
+        # Decrement the heartbeat counter. This counter should never drop below 0.
+        set NumberOfHeartBeats -= 1
+        if (NumberOfHeartBeats < 0) then set NumberOfHeartBeats = 0
+
+    # Clears all heartbeat VFX and SFX for all prop agents.
+    DisableAll():void =
+        Logger.Print("Disabling all heart beats.")
+        # Iterate through all VFX and move them to 0,0,0.
+        for (HeartBeatVFXDevice : AgentVFX):
+            HeartBeatVFXDevice.Deactivate()
+        # Unregister all players from the heart beat audio.
+        SFXPlayer.UnregisterAll()
+        # Reinitialize the heartbeat counter to 0
+        set NumberOfHeartBeats = 0
+
+# The heartbeat_warning_ui class contains a struct of data to track the UI canvas and text_block per player as well as the function to create a new heartbeat warning UI canvas.
+heartbeat_warning_ui := class:
+    var Canvas:canvas = canvas{}
+    var Text:text_block = text_block{}
+
+    # Creates the UI canvas for the warning message.
+    CreateCanvas():void =
+        set Text = text_block{DefaultTextColor := NamedColors.White, DefaultShadowColor := NamedColors.Black}
+        set Canvas = canvas:
+            Slots := array:
+                canvas_slot:
+                    Anchors := anchors{Minimum := vector2{X := 0.5, Y := 0.75}, Maximum := vector2{X := 0.5, Y := 0.75}}
+                    Offsets := margin{Top := 0.0, Left := 0.0, Right := 0.0, Bottom := 0.0}
+                    Alignment := vector2{X := 0.5, Y := 1.0}
+                    SizeToContent := true
+                    Widget := Text
+
+# The heartbeat_vfx class contains a struct of data to track the VFX's root and vfx_spawner_device objects per player as well as the functions to set the VFX to a position or reset it.
+heartbeat_vfx := class<concrete>:
+    @editable # The VFX device for each heart beat.
+    VFXDevice:vfx_spawner_device = vfx_spawner_device{}
+
+    # This offset is used to position the heartbeat above a prop agent's head.
+    HeartBeatVFXOffset:vector3 = vector3{X := 0.0, Y := 0.0, Z := 110.0}
+
+    # Sets the position of the heart beat VFX then enables the VFX.
+    Activate(Transform:transform):void =
+        VFXPosition := Transform.Translation + HeartBeatVFXOffset
+        if (VFXDevice.TeleportTo[VFXPosition, Transform.Rotation]):
+            VFXDevice.Enable()
+    
+    # Disables the VFX, hiding the heart beat visuals.
+    Deactivate():void =
+        VFXDevice.Disable()

Code_Reference/PropHunt/txt/hunter_team.txt

@@ -0,0 +1,28 @@
+using { /Fortnite.com/Devices }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /Verse.org/Simulation }
+
+# Inheriting from the base_team class, The hunter_team class contains the device definitions and functions related to the hunter team and its agents. 
+hunter_team := class<concrete>(base_team):
+    @editable # One hunter agent is created each round for each n players. Example: HunterTeamPerNumberOfPlayers = 5.0 is 1 per 5 players. If players = 6, 2 hunter agents are created.
+    HunterAgentPerNumberOfPlayers:float = 5.0 # Minimum 1.1 is enforced to ensure at least 1 prop agent is created.
+
+    @editable # The number of seconds before the hunter agents are spawned, giving the prop agents a head start to hide.
+    SpawnDelay:float = 15.0
+
+    @editable # The maximum base points a hunter agent gets for eliminating a prop agent. These points are divided by the number of prop agents remaining.
+    MaxEliminationScore:int = 5000
+
+    @editable # The timer device used to give props a grace period to hide.
+    WaitTimer:timer_device = timer_device{}
+
+    # Set the agent to a hunter agent. 
+    InitializeAgent<override>(NewHunterAgent:agent):void =
+        Logger.Print("Setting a new hunter agent.")
+        (super:)InitializeAgent(NewHunterAgent)
+
+    # When a hunter agent leaves the match, remove them from the HunterAgents array and check for the end of the round. 
+    # Notice that we're overriding this function because we don't need to pass extra data here like we do for prop team.
+    EliminateAgent<override>(HunterAgent:agent)<suspends>:void =
+        Logger.Print("Hunter agent eliminated.")
+        (super:)EliminateAgent(HunterAgent)

Code_Reference/PropHunt/txt/prop_hunt.txt

@@ -0,0 +1,189 @@
+using { /Fortnite.com/Devices }
+using { /Fortnite.com/UI }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /UnrealEngine.com/Temporary/SpatialMath }
+using { /UnrealEngine.com/Temporary/UI }
+using { /Verse.org/Colors }
+using { /Verse.org/Random }
+using { /Verse.org/Simulation }
+
+log_prop_hunt_device := class(log_channel){}
+
+# This class contains the logic for starting and ending a round. It also handles events for players joining and leaving when a round is in progress.
+prop_hunt := class(creative_device):
+    Logger:log = log{Channel:=log_prop_hunt_device}
+
+    @editable # An instance of the prop_team class, used to manage the Prop team.
+    PropTeam:prop_team = prop_team{}
+
+    @editable # An instance of the hunter_team class, used to manage the Hunter team.
+    HunterTeam:hunter_team = hunter_team{}
+
+    @editable # The round manager device is used to end the round when the last prop agent is eliminated.
+    RoundSettings:round_settings_device = round_settings_device{}
+
+    @editable # The teleporter in the lobby area. This device is enabled and disabled to allow props and hunters out of the pre-game lobby.
+    LobbyTeleporter:teleporter_device = teleporter_device{}
+
+    @editable # The waiting for more players device. This device checks if there are enough players to start the round.
+    WaitingForMorePlayers:waiting_for_more_players = waiting_for_more_players{}
+
+    @editable # This hud controller is used when a round is waiting to start.
+    # Set Priority to "Highest" for this device and have a second HUD controller set to < "Highest" to use during the round.
+    HUDControllerWaiting:hud_controller_device = hud_controller_device{}
+
+    @editable # The round timer device. This device keeps track of the time left in the round and is started within StartTheHunt().
+    RoundTimer:round_timer = round_timer{}
+
+    @editable # The device that controls the game music. 
+    GameMusic:radio_device = radio_device{}
+
+    @editable # Message for when the hunter agents are set loose in the game.
+    StartTheHuntMessage:hud_message_device = hud_message_device{}
+
+    @editable # The Verse class that controls the opening cinematic.
+    Cinematic:billboard_cinematic = billboard_cinematic{}
+
+    # When the device is started in a running game, initialize subscriptions and launch the team setup. This runs at the start of every round.
+    OnBegin<override>()<suspends>:void =
+        Sleep(1.0)
+        Logger.Print("Round loaded.")
+
+        # Play cinematic at beginning if user has it enabled
+        if (Cinematic.PlayAtStart?):
+            Cinematic.EnterCinematicModeForAll(GetPlayspace().GetPlayers())
+            Cinematic.CinematicCompleted.Await()
+            Cinematic.EndCinematicModeForAll(GetPlayspace().GetPlayers())
+            Logger.Print("Cinematic Completed.")
+        else:
+            Logger.Print("Cinematic Skipped.")
+
+        GameMusic.Play()
+        SetUpTeams()
+        race: # When there are no more prop or hunter agents (whichever happens first), or the round timer finishes, the round ends
+            PropTeam.TeamEmptyEvent.Await()
+            HunterTeam.TeamEmptyEvent.Await()
+            RoundTimer.AwaitEnd()
+        Logger.Print("Round ending.")
+        EndRound()
+
+    # When a round is started, subscribe to team devices, randomly pick the hunter agents, enable the hunter timer, set the prop agents, and teleport them into the game area.
+    SetUpTeams()<suspends>:void =
+        Logger.Print("Setting up teams.")
+
+        # Subscribe to the prop team score timer, set the score award, and subscribe to the prop team's eliminated event.
+        PropTeam.ScoreManager.SetScoreAward(PropTeam.ScorePerSecond)
+        PropTeam.TeamManager.TeamMemberEliminatedEvent.Subscribe(OnPropEliminated) # Occurs when a prop agent is eliminated.
+
+        # Subscribe to the hunter team's wait timer and set the duration. Also subscribe to the hunter team's elimination event.
+        HunterTeam.WaitTimer.SuccessEvent.Subscribe(HuntersGo)
+        HunterTeam.WaitTimer.SetMaxDuration(HunterTeam.SpawnDelay)
+        HunterTeam.TeamManager.EnemyEliminatedEvent.Subscribe(OnHunterEliminated) # Occurs when a hunter agent eliminates a prop agent.
+
+        # Initialize the starting hunter and prop agents arrays. Get the players and find the number of players in the server.
+        var StartingHunterAgents:[]agent = array{}
+        var StartingPropAgents:[]agent = array{}
+        var Players:[]player = GetPlayspace().GetPlayers()
+
+        # Enable the HUD appropriate for waiting for players. 
+        HUDControllerWaiting.Enable()
+
+        # Check if there are enough players to start the round.
+        set Players = WaitingForMorePlayers.WaitForMinimumNumberOfPlayers(Players)
+        Logger.Print("Round started.")
+
+        # Disable the waiting HUD to use the next highest priority HUD. 
+        HUDControllerWaiting.Disable()
+
+        # Now that the round has started, we need to handle players being added or removed from the match. Subscribe to those events.
+        GetPlayspace().PlayerAddedEvent().Subscribe(OnPlayerAdded)
+        GetPlayspace().PlayerRemovedEvent().Subscribe(OnPlayerRemoved)
+
+        # Calculate the number of starting hunter agents for the game based on the player count and the number of hunter agents per number of players.
+        NumberOfPlayers:float = 1.0 * Players.Length # Converts Players.Length to a float so it can be used in the next Ceil function.
+        if (NumberOfStartingHunters:int = Ceil[NumberOfPlayers / Max(1.1, HunterTeam.HunterAgentPerNumberOfPlayers)]):
+            # Shuffle the players and then slice the array to get the starting hunter agents. The remaining players are the starting prop agents. 
+            var RandomizedPlayers:[]agent = Shuffle(Players)
+            if (set StartingHunterAgents = RandomizedPlayers.Slice[0,NumberOfStartingHunters]) {}
+            if (set StartingPropAgents = RandomizedPlayers.Slice[NumberOfStartingHunters,RandomizedPlayers.Length]) {}
+
+            # Iterate through the starting hunter agents and assign them to the hunter team. Then start the hunter wait timer.
+            Logger.Print("Setting {StartingHunterAgents.Length} hunter agent(s).")
+            for (StartingHunterAgent : StartingHunterAgents):
+                HunterTeam.InitializeAgent(StartingHunterAgent)
+            HunterTeam.WaitTimer.Start()
+
+            # Iterate through the starting prop agents and assign them to the prop team. Teleport them into the play area.
+            Logger.Print("Setting {StartingPropAgents.Length} prop agent(s).")
+            LobbyTeleporter.Enable()
+            for (StartingPropAgent : StartingPropAgents):
+                PropTeam.InitializeAgent(StartingPropAgent)
+                PropTeam.HeartBeat.SetUpUI(StartingPropAgent)
+                LobbyTeleporter.Activate(StartingPropAgent)
+            LobbyTeleporter.Disable()
+            # Set the props remaining tracker's Target and Value to the current number of props.
+            # In the future, we'll only update Value as props are eliminated.
+            PropTeam.PropsRemainingTracker.SetTarget(PropTeam.Count())
+            PropTeam.UpdatePropsRemainingTracker()
+
+    # When the hunter timer finishes, spawn the function that unleashes the hunter agents into the game and begins the round.
+    # HunterInstigator is needed for the event subscription but not used.
+    HuntersGo(HunterInstigator:?agent):void =
+        spawn{ StartTheHunt() }
+
+    # Enable the lobby teleporter, teleport all the hunter agents to the game area and then run the prop game loop for each prop agent.
+    StartTheHunt()<suspends>:void =
+        Logger.Print("Teleporting hunter agent(s).")
+        LobbyTeleporter.Enable()
+        Sleep(0.5) # Delaying half a second to give the teleporter time to enable.
+        for (HunterAgent : HunterTeam.GetAgents[]):
+            LobbyTeleporter.Activate(HunterAgent)
+            StartTheHuntMessage.Show(HunterAgent)
+        Logger.Print("Starting prop(s) game logic.")
+        for (PropAgent : PropTeam.GetAgents[]):
+            spawn {PropTeam.RunPropGameLoop(PropAgent)}
+            StartTheHuntMessage.Show(PropAgent)
+
+        # Signal that the round has started to start the round and scoring timers.
+        RoundTimer.Start()
+        PropTeam.ScoreTimer.Start()
+
+    # When a player joins the match mid-round, make them a hunter if the round has started.
+    OnPlayerAdded(Player:player):void =
+        Logger.Print("A player joined the game.")
+        if (PropTeam.Count() > 0): # if there are any prop agents, the round has started.
+            HunterTeam.InitializeAgent(Player)
+
+    # When a hunter agent eliminates a prop agent, award score. The score is divided by the number of prop agents remaining.
+    OnHunterEliminated(HunterAgent:agent):void =
+        Logger.Print("Hunter agent eliminated a prop agent.")
+        PropTeamSize := PropTeam.Count()
+        if (EliminationAward := Floor(HunterTeam.MaxEliminationScore / PropTeamSize)):
+            Logger.Print("Awarding {EliminationAward} points.")
+            HunterTeam.ScoreManager.SetScoreAward(EliminationAward)
+            HunterTeam.ScoreManager.Activate(HunterAgent)
+
+    # When a prop agent is eliminated, remove the prop from the prop team, check for round end, and set them as a hunter.
+    OnPropEliminated(PropAgent:agent):void =
+        Logger.Print("Prop agent eliminated.")
+        spawn{ PropTeam.EliminateAgent(PropAgent) }
+        HunterTeam.InitializeAgent(PropAgent)
+  
+    # When a player leaves the match, check which team they were on and then check for round end.
+    OnPlayerRemoved(Player:player):void =
+        Logger.Print("A player left the game.")
+        if (PropTeam.FindOnTeam[Player]):
+            Logger.Print("Player was a Prop.")
+            spawn{ PropTeam.EliminateAgent(Player) }
+        if (HunterTeam.FindOnTeam[Player]):
+            Logger.Print("Player was a Hunter.")
+            spawn{ HunterTeam.EliminateAgent(Player) }
+
+    # Cleans up the heart beat VFX and then ends the round.
+    EndRound():void=
+        PropTeam.HeartBeat.DisableAll()
+        # Get any player to pass to EndRound
+        Players:[]player = GetPlayspace().GetPlayers()
+        if (RoundEndInstigator := Players[0]):
+            Logger.Print("Round ended.")
+            RoundSettings.EndRound(RoundEndInstigator)

Code_Reference/PropHunt/txt/prop_team.txt

@@ -0,0 +1,147 @@
+using { /Fortnite.com/Characters }
+using { /Fortnite.com/Devices }
+using { /Fortnite.com/UI }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /UnrealEngine.com/Temporary/SpatialMath }
+using { /UnrealEngine.com/Temporary/UI }
+using { /Verse.org/Colors }
+using { /Verse.org/Simulation }
+
+# This message is used to print the number of props remaining to all players during a round.
+PropAgentsRemainingMessage<localizes>(Count:int):message = "{Count} Prop(s) Remaining"
+
+# Inheriting from the base_team class, the prop_team class contains the device definitions and functions related to the prop team and its agents.
+# Notably, a prop agent's heart beat behavior can be found in this class.
+prop_team := class<concrete>(base_team):
+    @editable # The score a prop agent receives per second.
+    ScorePerSecond:int = 10
+
+    @editable # The minimum distance a prop agent must move to reset the heart beat timer.
+    MinimumMoveDistance:float = 100.0
+
+    @editable # The timer device used to award score to a prop.
+    ScoreTimer:timer_device = timer_device{}
+
+    @editable # This tracker device is used to display the props remaining to the screen.
+    PropsRemainingTracker:tracker_device = tracker_device{}
+    
+    @editable # Get the properties from the heart_beat class.
+    HeartBeat:heart_beat = heart_beat{}
+
+    # Set the agent to a prop agent and assign heart beat warning UI. 
+    InitializeAgent<override>(NewPropAgent:agent):void =
+        Logger.Print("Setting a new prop agent.")
+        (super:)InitializeAgent(NewPropAgent)
+
+    # When a prop agent is eliminated or leaves the match, remove them from the PropAgents array and check for the end of the round.
+    # Note that this isn't overridding because we're passing all players to the function to update the props remaining message.
+    EliminateAgent<override>(PropAgent:agent)<suspends>:void =
+        Logger.Print("Prop agent eliminated.")
+        (super:)EliminateAgent(PropAgent)
+        # Update the props remaining number.
+        UpdatePropsRemainingTracker()
+
+    # Updates the value of the tracker device showing the number of props remaining.
+    UpdatePropsRemainingTracker():void =
+        PropsRemainingTracker.SetValue(Count())
+
+    # If the prop agent stops moving then race to see if the prop agent moves beyond the MinimumMoveDistance, the heart beat timer completes, or the prop agent is eliminated.
+    RunPropGameLoop(PropAgent:agent)<suspends>:void =
+        Logger.Print("Starting prop agent game loop.")
+        # Loop forever through the prop behavior and scoring until the prop agent is eliminated or the player leaves the session.
+        race: 
+            PropAgent.AwaitNoLongerAProp()
+            loop:
+                # Wait until the prop agent moves less than the minimum distance, then advance.
+                PropAgent.AwaitStopMoving(MinimumMoveDistance) 
+                # Until the prop agent moves beyond the minimum distance, countdown to the heart beat and then play the heart beat indefinitely.
+                race: 
+                    PropAgent.AwaitStartMoving(MinimumMoveDistance)
+                    block:
+                        CountdownTimer(PropAgent)
+                        PropAgent.StartHeartbeat()
+                Sleep(0.0) # Once the race completes (the prop agent moves), start the loop again.
+            loop:
+                # Every second, award the prop agent points.
+                Sleep(1.0)
+                ScoreManager.Activate(PropAgent)
+
+
+    # Loop until the prop agent is no longer a part of the PropAgents array. Removal happens if the prop agent is eliminated and turned into a hunter or if the player leaves the session.
+    (PropAgent:agent).AwaitNoLongerAProp()<suspends>:void =
+        loop:
+            if (not FindOnTeam[PropAgent]):
+                Logger.Print("Cancelling prop agent behavior.")
+                break
+            Sleep(0.0) # Advance to the next game tick.
+
+    # Loops until the agent moves less than the MinimumDistance.
+    (PropAgent:agent).AwaitStopMoving(MinimumDistance:float)<suspends>:void =
+        Logger.Print("Checking if the agent has moved less than the minimum distance.")
+        # Get the initial position of the agent from the agent's character in the scene.
+        if (Tracked := PropAgent.GetFortCharacter[]):
+            var StartPosition:vector3 = Tracked.GetTransform().Translation
+            loop:
+                Sleep(0.0) # Get the position of the agent in the next game tick.
+                NewPosition := Tracked.GetTransform().Translation
+                # If the distance of the new position from the starting position is less than MinimumDistance, the agent has not moved and we break the loop.
+                if (Distance(StartPosition, NewPosition) < MinimumDistance):
+                    Logger.Print("Agent has moved less than the minimum distance.")
+                    break
+                # Otherwise, we reset StartPosition to make sure the player moves from the new position.
+                else: 
+                    set StartPosition = NewPosition
+
+    # Loops until the agent moves more than the MinimumDistance.
+    (PropAgent:agent).AwaitStartMoving(MinimumDistance:float)<suspends>:void =
+        Logger.Print("Checking if the agent moves further than the minimum distance.")
+        # Get the initial position of the agent from the agent's character in the scene.
+        if (Tracked := PropAgent.GetFortCharacter[]):
+            StartPosition:vector3 = Tracked.GetTransform().Translation
+            loop:
+                Sleep(0.0) # Get the position of the agent in the next game tick.
+                NewPosition := Tracked.GetTransform().Translation
+                # If the distance of the new position from the starting position is greater than or equal to MinimumDistance, the agent has moved and we break the loop.
+                if (Distance(StartPosition, NewPosition) >= MinimumDistance):
+                    Logger.Print("Agent has moved more than or equal to the minimum distance.")
+                    break
+
+    # Delays until HeartBeatWarningTime should start. Then counts down by HeartBeatWarningTime and sets the countdown text. Clears the text when deferred.
+    CountdownTimer(PropAgent:agent)<suspends>:void =
+        Logger.Print("Starting heart beat countdown.")
+        if (UIData := HeartBeat.WarningUI[PropAgent]):
+            Sleep(HeartBeat.MoveTime - HeartBeat.WarningTime) # Sleep for the amount of time before the warning appears.
+            Logger.Print("Starting heart beat warning.")
+            var WarningTimeRemaining:int = 0
+            if (set WarningTimeRemaining = Ceil[HeartBeat.WarningTime]) {}
+            # A defer happens when the function completes or if it is cancelled, such as if it loses a race.
+            # So in this case, the warning text is cleared when the countdown finishes or if the prop agent moves before the countdown finishes.
+            defer:
+                UIData.Text.SetText(HeartBeatWarningClear)
+            # Set the warning text to the time remaining, wait a second, and then decrement the time remaining. If the countdown completes, break the loop.
+            loop:
+                Logger.Print("Heart beat in {WarningTimeRemaining} seconds.")
+                UIData.Text.SetText(HeartBeatWarningMessage(WarningTimeRemaining))
+                Sleep(1.0)
+                set WarningTimeRemaining -= 1
+                if (WarningTimeRemaining <= 0):
+                    break
+        else:
+            Logger.Print("UIData not found.")
+              
+    # Turns on the heart beat VFX and SFX. Waits infinitely until deferred then disables the heart beat VFX and SFX.
+    (PropAgent:agent).StartHeartbeat()<suspends>:void =
+        Logger.Print("Spawning heart beat.")
+        # Save the heartbeat data so we can pass it in the defer later, after the PropAgent is destroyed or leaves the game.
+        var HeartBeatVFXData:heartbeat_vfx = heartbeat_vfx{}
+        if:
+            # Get the index of the prop agent in the PropAgents array to then access the corresponding heart beat VFX actor.
+            Index := FindOnTeam[PropAgent]
+            set HeartBeatVFXData = HeartBeat.AgentVFX[Index]
+        then:
+            HeartBeat.Enable(PropAgent, HeartBeatVFXData)
+        # When this function is cancelled by the prop agent moving, being eliminated, or the player leaving the session, disable the heartbeat.
+        defer:
+            HeartBeat.Disable(PropAgent, HeartBeatVFXData)
+        Sleep(Inf) # Do not stop sleeping until the race completes.
+

Code_Reference/PropHunt/txt/round_timer.txt

@@ -0,0 +1,158 @@
+using { /Fortnite.com/Devices }
+using { /Fortnite.com/UI }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /UnrealEngine.com/Temporary/SpatialMath }
+using { /UnrealEngine.com/Temporary/UI }
+using { /Verse.org/Colors }
+using { /Verse.org/Simulation }
+
+log_round_timer_device := class(log_channel){}
+
+# An int that allows values between the ranges specified. This type is required by player_ui_slot.ZOrder.
+round_int_clamped := type{_X:int where 0 <= _X, _X <= 2147483647}
+
+# This message is used to print the time remaining before a round ends.
+TimeRemainingMessage<localizes>(Minutes:string, Seconds:string):message = "{Minutes}:{Seconds}"
+
+<#
+This class contains all the logic for managing the round time and displaying the time to the screen.
+You can use this device with a round_settings_device to actually end the round.
+This device manages time without the use of a timer.
+To use this class:
+    1) Add the file to your project.
+    2) Compile Verse Code from the Verse menu on the toolbar.
+    3) Drag the device into your island from your island's Content/Creative Devices folder in the Content Browser.
+    4) Include the waiting_for_more_players class in another Verse script with:
+        @editable
+        RoundTimer:round_timer = round_timer{}
+    5) Compile Verse Code from the Verse menu on the toolbar.
+    6) Connect the device you made in step 3 to the Verse device.
+    7) Start the round timer with the following Verse:
+        RoundTimer.Start()
+    8) Restart or Stop the timer with the equivalent functions.
+    9) Wait for the timer to start with:
+        RoundTimer.AwaitStart()
+    10) Wait for the timer to complete with:
+        RoundTimer.AwaitEnd()
+        Call the EndRound function on a round_settings_device to actually end the game round.
+#>
+round_timer := class(creative_device):
+    Logger:log = log{Channel:=log_round_timer_device}
+
+    @editable # The time, in minutes, a round lasts.
+    RoundTimeInMinutes:float = 5.0
+
+    @editable # The horizontal and vertical position of the timer UI on screen. X 0-1 is left-right and Y 0-1 is top-bottom.
+    UIPosition:vector2 = vector2{X:= 0.98, Y:=0.13}
+
+    @editable # The horizontal and vertical position of the timer UI on screen. X 0-1 is left-right and Y 0-1 is top-bottom.
+    UIAlignment:vector2 = vector2{X := 1.0, Y := 0.0}
+
+    @editable # The ZOrder of the UI compared to other UI elements.
+    UIZOrder:round_int_clamped = 4
+
+    # Signaled when the round has been started.
+    RoundStarted:event() = event(){}
+
+    # Signaled when the round is about to be ended.
+    RoundEndedEvent:event() = event(){}
+
+    # This map associates a text box for displaying the time to each player.  
+    var TimeRemainingTextBlocks:[player]text_block = map{}
+
+    # The time remaining before the round completes, as an integer.
+    var TimeRemainingInSeconds:int = 0
+
+    # Waits until the round timer is started.
+    AwaitStart()<suspends>:void =
+        RoundStarted.Await()
+        Logger.Print("Round timer started.")
+    
+    # Used to start the round timer.
+    Start():void = 
+        Logger.Print("Starting the round timer.")
+        RoundStarted.Signal()
+        set TimeRemainingInSeconds = GetRoundTimeInSeconds()
+        spawn{ Running() }
+
+    # Restarts the timer to RoundTime
+    Restart():void = 
+        Logger.Print("Restarting the round timer.")
+        set TimeRemainingInSeconds = GetRoundTimeInSeconds()
+
+    # Runs the timer logic.
+    Running()<suspends>:void =
+        Logger.Print("Round timer running.")
+        loop:
+            UpdateTimeUI()
+            Sleep(1.0)
+            # Decrement TimeRemaining by 1 second then check if the time has run out. If so, end the round.
+            set TimeRemainingInSeconds -= 1
+            if (TimeRemainingInSeconds < 0):
+                Stop()
+                break
+            
+    # Stops the timer and ends the round.
+    Stop():void = 
+        Logger.Print("Ending the round timer.")
+        # We get a player from the players remaining in the scene to end the round.
+        Players:[]player = GetPlayspace().GetPlayers()
+        if (Instigator := Players[0]):
+            RoundEndedEvent.Signal()
+
+    # Waits until the round timer is just about to end.
+    AwaitEnd()<suspends>:void =
+        RoundEndedEvent.Await()
+        Logger.Print("Round timer ended.")
+
+    # Accepts a time value in minutes and returns the value in seconds.
+    GetRoundTimeInSeconds():int =
+        var InSeconds:int = 0
+        if (set InSeconds = Round[RoundTimeInMinutes * 60.0]) {}
+        InSeconds
+
+    # When the timer completes, update the time remaining and check if time has expired.
+    UpdateTimeUI():void =
+        # Set Minutes to TimeRemainingInSeconds/60 without the remainder.
+        var Minutes:int = 0
+        if (set Minutes = Floor(TimeRemainingInSeconds / 60)) {}
+        # Set Seconds to the remainder of TimeRemainingInSeconds/60.
+        var Seconds:int = 0
+        if (set Seconds = Mod[TimeRemainingInSeconds, 60]) {}
+        # Convert Minutes and Seconds to strings.
+        MinutesAsString := string("{Minutes}")
+        # If Seconds < 10, then we need to add a 0 in front of the value so it displays as :0# instead of :#
+        SecondsAsString := if (Seconds < 10) then Join(array{string("{0}"),string("{Seconds}")},string()) else string("{Seconds}")
+
+        # Iterate through all players, check if they have a TimeRemainingTextBlock, if not, give them one. Then update the text.
+        Players:[]player = GetPlayspace().GetPlayers()
+        for (Player : Players):
+            var TextBlock:text_block = text_block{}
+            if (set TextBlock = TimeRemainingTextBlocks[Player]):
+            else:
+                Logger.Print("Creating new round time text block.")
+                set TextBlock = SetUpTimeRemainingUI(Player)
+            TextBlock.SetText(TimeRemainingMessage(MinutesAsString, SecondsAsString))
+
+    # Accepts a player and then adds a round time ui canvas to their screen and stores their TimeRemainingTextBlock for updating later.
+    SetUpTimeRemainingUI(Player:player):text_block =
+        Logger.Print("Adding round timer UI to a player.")
+        # This is the text_block that prints the time remaining text to the screen.
+        TextBlock:text_block = text_block:
+            DefaultTextColor := NamedColors.White
+            DefaultShadowColor := NamedColors.Black
+        if (PlayerUI := GetPlayerUI[Player]):
+            if (set TimeRemainingTextBlocks[Player] = TextBlock) {}
+            # This is the canvas that holds and positions the text_block on the screen.
+            Canvas := canvas:
+                Slots := array:
+                    canvas_slot:
+                        Anchors := anchors{Minimum := UIPosition, Maximum := UIPosition}
+                        Offsets := margin{Top := 0.0, Left := 0.0, Right := 0.0, Bottom := 0.0}
+                        Alignment := UIAlignment
+                        SizeToContent := true
+                        Widget := TextBlock
+            # The canvas is assigned to the player.
+            PlayerUI.AddWidget(Canvas, player_ui_slot{ZOrder := UIZOrder})
+        # The text_block is returned so it can be saved to the map and updated later as time ticks down.
+        return TextBlock

Code_Reference/PropHunt/txt/waiting_for_more_players.txt

@@ -0,0 +1,131 @@
+
+using { /Fortnite.com/Devices }
+using { /Fortnite.com/UI }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /UnrealEngine.com/Temporary/SpatialMath }
+using { /UnrealEngine.com/Temporary/UI }
+using { /Verse.org/Colors }
+using { /Verse.org/Simulation }
+
+log_waiting_for_more_players_device := class(log_channel){}
+
+# An int that allows values between the ranges specified. This type is required by player_ui_slot.ZOrder.
+waiting_int_clamped := type{_X:int where 0 <= _X, _X <= 2147483647}
+
+# This message is used to print the number of players needed before a round can begin.
+WaitingForMorePlayersMessage<localizes>(Count:int):message = "Waiting for {Count} more Player(s)"
+
+# This class is for showing how many players are needed to start the round.
+waiting_for_more_players_ui := class:
+    var Canvas:canvas
+    var TextBlock:text_block
+
+<# 
+This class contains all the logic for setting a minimum number of players and checking if there are enough to start the round.
+To use this class:
+    1) Add the file to your project.
+    2) Compile Verse Code from the Verse menu on the toolbar.
+    3) Drag the device into your island from your island's Content/Creative Devices folder in the Content Browser.
+    4) Connect a Timer device to this device's "WaitingForMorePlayersTimer" property.
+    5) Include the waiting_for_more_players class in another Verse script with:
+        @editable
+        WaitingForMorePlayers:waiting_for_more_players = waiting_for_more_players{}
+    6) Compile Verse Code from the Verse menu on the toolbar.
+    7) Connect the device you made in step 3 to the Verse device and property you exposed in step 6.
+    8) Await the CheckForMinimumNumberOfPlayers functions by passing it a player. For example:
+        Players = GetPlayspace().GetPlayers()
+        CheckForMinimumNumberOfPlayers(Players)
+    9) On IslandSettings, Set the Game Start Countdown to 0.0.
+#>
+waiting_for_more_players := class(creative_device):
+    Logger:log = log{Channel:=log_waiting_for_more_players_device}
+
+    @editable # The minimum number of players needed in the match for a round to start.
+    MinimumNumberOfPlayers:int = 2
+
+    @editable # The horizontal and vertical position of the timer UI on screen. X 0-1 is left-right and Y 0-1 is top-bottom.
+    UIPosition:vector2 = vector2{X:= 0.5, Y:=0.4}
+
+    @editable # The horizontal and vertical position of the timer UI on screen. X 0-1 is left-right and Y 0-1 is top-bottom.
+    UIAlignment:vector2 = vector2{X := 0.5, Y := 0.5}
+
+    @editable # The ZOrder of the UI compared to other UI elements.
+    UIZOrder:waiting_int_clamped = 3
+
+    @editable # This timer is used to countdown to round start after waiting for players to join the match.
+    WaitingForMorePlayersTimer:timer_device = timer_device{}
+
+    # This map associates a UI canvas for displaying the number of players needed to start a round to each player. 
+    var WaitingForMorePlayersUI:[player]?waiting_for_more_players_ui = map{}
+
+    # Check if there are enough players to start the round. If not, wait until number of players >= MinimumNumberOfPlayers.
+    WaitForMinimumNumberOfPlayers(Players:[]player)<suspends>:[]player =
+        Logger.Print("Waiting if there are enough players for the round to start.")
+        # Creating a new variable so I can modify it as more players join. Initializing it with an array of players passed to the function.
+        var PlayersWaiting:[]player = Players
+        # If the number of players is less than the minimum needed to start the round...
+        if (PlayersWaiting.Length < MinimumNumberOfPlayers):
+            loop: # Loop until the number of players is greater than or equal to the minimum needed.
+                Logger.Print("{PlayersWaiting.Length}/{MinimumNumberOfPlayers} players needed for the round to start.")
+                # Update the waiting for more players UI.
+                DisplayWaitingForMorePlayers(PlayersWaiting)
+                Sleep(2.0) # Wait to see if more players join the match then check if there are enough players to start the round.
+                set PlayersWaiting = GetPlayspace().GetPlayers()
+                if (PlayersWaiting.Length >= MinimumNumberOfPlayers):
+                    # If there are now enough players, clear the waiting for more players UI, 
+                    Logger.Print("{PlayersWaiting.Length}/{MinimumNumberOfPlayers} players in round, preparing for round start.")
+                    ClearWaitingForMorePlayers()
+                    # Then break out of the loop.
+                    break
+        # start the round start countdown, and wait until the countdown completes. 
+        WaitingForMorePlayersTimer.Start()
+        WaitingForMorePlayersTimer.SuccessEvent.Await()
+        Logger.Print("Starting round.")
+        # Return the list of players in the session.
+        return PlayersWaiting
+
+    # Displays a "Waiting for more players" UI message for each player if they don't already have one. Updates the player counter for all players.
+    DisplayWaitingForMorePlayers(Players:[]player):void =
+        PlayersNeededCount := MinimumNumberOfPlayers - Players.Length
+        Logger.Print("{Players.Length} players in round, waiting for {PlayersNeededCount} more player(s) to join.")
+        for (Player: Players):
+            # If the player has a WaitingForMorePlayersUI, get the TextBlock and refresh the text so it shows the correct number of players needed to start the round.
+            if (UIData := WaitingForMorePlayersUI[Player]?):
+                UIData.TextBlock.SetText(WaitingForMorePlayersMessage(PlayersNeededCount))
+            # Else create a WaitingForMorePlayersUI for the player.
+            else:
+                SetUpWaitingForMorePlayersUI(Player, PlayersNeededCount)
+    
+    # Accepts a player and player_ui and adds a waiting for more players ui canvas to their screen.
+    SetUpWaitingForMorePlayersUI(Player:player, PlayersNeededCount:int):void =
+        Logger.Print("Creating 'waiting for more players' UI.")
+        if (PlayerUI := GetPlayerUI[Player]):
+            # This is the text_block that prints the waiting for more players text to the screen.
+            TextBlock:text_block = text_block:
+                DefaultText := WaitingForMorePlayersMessage(PlayersNeededCount)
+                DefaultTextColor := NamedColors.White
+                DefaultShadowColor := NamedColors.Black
+            # This is the canvas that holds and positions the text_block on the screen.
+            Canvas := canvas:
+                Slots := array:
+                    canvas_slot:
+                        Anchors := anchors{Minimum := UIPosition, Maximum := UIPosition}
+                        Offsets := margin{Top := 0.0, Left := 0.0, Right := 0.0, Bottom := 0.0}
+                        Alignment := UIAlignment
+                        SizeToContent := true
+                        Widget := TextBlock
+            # The canvas is assigned to the player.
+            PlayerUI.AddWidget(Canvas, player_ui_slot{ZOrder := UIZOrder})
+            # The text_block is saved to the map so we can update the text later as more players join the game.
+            if (set WaitingForMorePlayersUI[Player] = option{ waiting_for_more_players_ui{Canvas := Canvas, TextBlock := TextBlock} }) {}
+
+    # Removes the "Waiting for more players" UI message for each player who has one.
+    ClearWaitingForMorePlayers():void =
+        Logger.Print("Clearing 'waiting for more players' UI.")
+        for (Player -> UIData : WaitingForMorePlayersUI):
+            if:
+                PlayerUI := GetPlayerUI[Player]
+                Canvas := UIData?.Canvas
+                set WaitingForMorePlayersUI[Player] = false
+            then:
+                PlayerUI.RemoveWidget(Canvas)

Code_Reference/PropHunt/verse/base_team.verse

@@ -0,0 +1,81 @@
+using { /Fortnite.com/Characters }
+using { /Fortnite.com/Devices }
+using { /Fortnite.com/UI }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /UnrealEngine.com/Temporary/SpatialMath }
+using { /UnrealEngine.com/Temporary/UI }
+using { /Verse.org/Colors }
+using { /Verse.org/Simulation }
+
+log_team := class(log_channel){}
+
+# This class defines the devices needed for the different teams in the experience.
+# This class is abstract so it cannot be used on its own. It has to be inherited by another class.
+base_team := class<abstract>:
+    Logger:log = log{Channel:=log_team}
+
+    @editable # Used to set a player to the team.
+    ClassSelector:class_and_team_selector_device = class_and_team_selector_device{}
+  
+    @editable # Used to award score to agents on the team.
+    ScoreManager:score_manager_device = score_manager_device{}
+    
+    @editable # Used to display the team assignment title.
+    TeamTitle:hud_message_device = hud_message_device{}
+    
+    @editable # Used to display the team assignment description.
+    TeamDescription:hud_message_device = hud_message_device{}
+    
+    @editable # Used to subscribe to team member (prop team) or enemy (hunter team) eliminated events.
+    TeamManager:team_settings_and_inventory_device = team_settings_and_inventory_device{}
+
+    # This is an array of agents on the team.
+    var TeamAgents<private>:[]agent = array{}
+
+    # This event is signaled when the TeamAgents array becomes empty (signaling the end of the round).
+    TeamEmptyEvent:event() = event(){}
+
+    # Returns the current TeamAgents array.
+    # This is required because the TeamAgents array is private, so other classes cannot access it directly.
+    GetAgents()<decides><transacts>:[]agent =
+        TeamAgents
+
+    # Return the size of the TeamAgents array
+    # This requires a function because the TeamAgents array is private, so other classes cannot access it directly.
+    Count()<transacts>:int = 
+        TeamAgents.Length
+
+    # Returns an index in the TeamAgents array of an agent, fails otherwise.
+    FindOnTeam(Agent:agent)<decides><transacts>: int =
+        Index := TeamAgents.Find[Agent] 
+        
+    # Set the agent to the team and notify the player. 
+    InitializeAgent(Agent:agent):void =
+        AddAgentToTeam(Agent)
+        ClassSelector.ChangeTeamAndClass(Agent)
+        DisplayTeamInformation(Agent)
+  
+    # Add an agent to TeamAgents.
+    AddAgentToTeam(AgentToAdd:agent):void =
+        if (not FindOnTeam[AgentToAdd]):
+            Logger.Print("Adding agent to team.")
+            set TeamAgents += array{AgentToAdd}
+
+    # Activates hud message devices to show the player what team they are on
+    DisplayTeamInformation(Agent:agent):void =
+        TeamTitle.Show(Agent)
+        TeamDescription.Show(Agent)
+
+    # When an agent leaves the match, remove them from the TeamAgents array and check for the end of the round. 
+    EliminateAgent(Agent:agent)<suspends>:void =
+        Sleep(0.0) # Delaying 1 game tick to ensure the player is respawned before proceeding.
+        RemoveAgentFromTeam(Agent)
+
+    # Remove an agent from TeamAgents.
+    # If the agent removed was the last, signal TeamEmptyEvent.
+    RemoveAgentFromTeam(AgentToRemove:agent):void =
+        set TeamAgents = TeamAgents.RemoveAllElements(AgentToRemove)
+        Logger.Print("{Count()} agent(s) on team remaining.")
+        if (Count() < 1):
+            Logger.Print("No agents on team remaining. Ending the round.")
+            TeamEmptyEvent.Signal()

Code_Reference/PropHunt/verse/billboard_cinematic_flythrough.verse

@@ -0,0 +1,187 @@
+using { /Fortnite.com/Characters }
+using { /Fortnite.com/Devices }
+using { /Fortnite.com/FortPlayerUtilities }
+using { /Fortnite.com/UI }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /UnrealEngine.com/Temporary/SpatialMath}
+using { /UnrealEngine.com/Temporary/UI }
+using { /Verse.org/Simulation }
+using { /Verse.org/Simulation/Tags } 
+
+# Gameplay tag for objects that should be displayed or hidden during cinematic
+cinematic_objects := class(tag):
+
+# Script that sets the player into a cinematic mode so its not in the cinematic, and then resets them when the cinematic is done
+billboard_cinematic := class<concrete>:
+
+    # A reference to the device that contains the level sequence to be played
+    @editable
+    CinematicSequence:cinematic_sequence_device := cinematic_sequence_device{}
+
+    # A reference to the device that will hide the HUD
+    @editable
+    HUDController:hud_controller_device := hud_controller_device{}
+
+    # Should the Skip Intro button be visible during the cinematic
+    @editable
+    ShowUI:logic := true
+
+    # Should Devices and Billboards be visible during the cinematic
+    @editable
+    ShowCreativeObjects:logic := true
+
+    # Should play the cinematic at the beginning of game
+    @editable
+    PlayAtStart:logic = true
+
+    # Reference to the Radio that plays music
+    @editable
+    Music:radio_device := radio_device{}
+
+    # Signaled when the cinematic has completed.
+    CinematicCompleted<public>:event() = event(){}
+
+    # Runs at the beginning of the script.
+    EnterCinematicModeForAll<public>(InPlayers:[]player):void=
+        HUDController.Enable()
+
+        if (ShowCreativeObjects?):
+            ShowObjectsInCinematic()
+        else:
+            HideObjectsInCinematic()
+
+        for:
+            Player : InPlayers
+            not Player.IsSpectator[]
+        do:
+            spawn{EnterCinematicMode(Player)}
+        
+        Music.Play()
+
+    # Sets players to visible, re-enables their movement, and removes the skip button.
+    EndCinematicModeForAll<public>(InPlayers:[]player):void=
+        Music.Stop()
+        for:
+            Player : InPlayers
+            not Player.IsSpectator[]
+        do:
+            EndCinematicMode(Player)
+
+        HUDController.Disable()
+        HideObjectsInCinematic()
+
+    # UI to show during the cinematic
+    CinematicUI<private>:cinematic_ui = cinematic_ui{}
+
+    # Handler for player choosing to skip cinematic
+    HandleSkipIntroInteraction<private>(WidgetMessage:widget_message):void=
+        EndCinematicMode(WidgetMessage.Player)
+
+    # Sets players to invisible, removes their movement, optionally gives them a skip button, then waits for the cinematic to end before signaling that it has completed.
+    EnterCinematicMode<private>(Player:player)<suspends>:void=
+        HidePlayer(Player)
+
+        if:
+            ShowUI?
+            PlayerUI := GetPlayerUI[Player]
+        then:
+            Listenable := CinematicUI.Show(Player, PlayerUI)
+            Listenable.Subscribe(HandleSkipIntroInteraction)
+
+        CinematicSequence.Play(Player)
+        
+        CinematicSequence.StoppedEvent.Await()
+        CinematicCompleted.Signal()
+
+    # Stop cinematic for player
+    EndCinematicMode<private>(Player:player):void=
+        CinematicSequence.Stop(Player)
+        ShowPlayer(Player)
+        CinematicUI.Hide(Player)
+
+    # Make player invisible and unmoveable
+    HidePlayer<private>(Player:player):void=
+        if (FortCharacter := Player.GetFortCharacter[]):
+            CinematicStasis := stasis_args{AllowTurning := false, AllowFalling := false, AllowEmotes := false}
+
+            FortCharacter.PutInStasis(CinematicStasis)
+            FortCharacter.Hide()
+
+    # Make player visible and moveable
+    ShowPlayer<private>(Player:player):void=
+        if (FortCharacter := Player.GetFortCharacter[]):
+            FortCharacter.ReleaseFromStasis()
+            FortCharacter.Show()
+
+    # Find all objects tagged and make them visible
+    ShowObjectsInCinematic<private>():void=
+        ObjectsToShow := GetCreativeObjectsWithTag(cinematic_objects{})
+
+        for (Object : ObjectsToShow):
+            if (Billboard := billboard_device[Object]):
+                Billboard.ShowText()
+            else if (Device := creative_device[Object]):
+                Device.Show()
+            else if (Radio := radio_device[Object]):
+                Radio.Show()
+            else if (AudioPlayer := audio_player_device[Object]):
+                AudioPlayer.Show()
+
+    # Find all objects tagged and make them invisible
+    HideObjectsInCinematic<private>():void=
+        ObjectsToHide := GetCreativeObjectsWithTag(cinematic_objects{})
+
+        for (Object : ObjectsToHide):
+            if (Billboard := billboard_device[Object]):
+                Billboard.HideText()
+            else if (Device := creative_device[Object]):
+                Device.Hide()
+            else if (Radio := radio_device[Object]):
+                Radio.Hide()
+            else if (AudioPlayer := audio_player_device[Object]):
+                AudioPlayer.Hide()
+
+# Class in charge of UI for cinematic
+cinematic_ui := class:
+
+    # Create a canvas widget that displays a skip button for the cinematic
+    CreateUI():tuple(canvas, listenable(widget_message))=
+        SkipButton:button_regular = button_regular{DefaultText := SkipCinematicText}
+        SkipButton.SetEnabled(true)
+
+        UICanvas:canvas = canvas:
+            Slots := array:
+                canvas_slot:
+                    Anchors := anchors{Minimum := vector2{X := 0.9, Y := 0.9}, Maximum := vector2{X := 0.9, Y := 0.9}}
+                    Offsets := margin{Top := 0.0, Left := 0.0, Right := 0.0, Bottom := 0.0}
+                    Alignment := vector2{X := 1.0, Y := 1.0}
+                    SizeToContent := true
+                    Widget := SkipButton
+
+        return (UICanvas, SkipButton.OnClick())
+
+    # Shows the UI for the player and returns the listenable for the button
+    Show(Player:player, PlayerUI:player_ui):listenable(widget_message)=
+        UIResult := CreateUI()
+        UICanvas := UIResult(0)
+        Listenable := UIResult(1)
+
+        PlayerUISlot := player_ui_slot{ZOrder := 0, InputMode := ui_input_mode.All}
+        PlayerUI.AddWidget(UICanvas, PlayerUISlot)
+        if (set UIPerPlayer[Player] = option{UICanvas}):
+        
+        return Listenable
+
+    # Hides the UI for the player
+    Hide(Player:player):void=
+        if:
+            PlayerUI := GetPlayerUI[Player]
+            CustomUI := UIPerPlayer[Player]?
+        then:
+            PlayerUI.RemoveWidget(CustomUI)
+            if (set UIPerPlayer[Player] = false):
+
+    # A localizable message to display as text in the UI
+    SkipCinematicText<localizes><private>:message = "Skip Intro"
+
+    var UIPerPlayer<private>:[player]?canvas = map{}

Code_Reference/PropHunt/verse/heartbeat.verse

@@ -0,0 +1,121 @@
+using { /Fortnite.com/Characters }
+using { /Fortnite.com/Devices }
+using { /Fortnite.com/UI }
+using { /UnrealEngine.com/Temporary/SpatialMath }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /UnrealEngine.com/Temporary/UI }
+using { /Verse.org/Colors }
+using { /Verse.org/Simulation }
+
+log_heart_beat := class(log_channel){}
+
+# These messages are used to notify a prop agent with a message (or to hide it) when they need to move to avoid their heart beat from becoming visible.
+HeartBeatWarningMessage<localizes>(Time:int):message = "Heart Beat in {Time} Seconds. Move!"
+HeartBeatWarningClear<localizes>:message = ""
+
+# This class exposed the editable properties for the heartbeat to the prop_hunt device.
+heart_beat := class<concrete>():
+    Logger:log = log{Channel:=log_heart_beat}
+
+    @editable # The number of seconds before a prop agent must move before the heart beat reveals their position.
+    MoveTime:float = 15.0
+
+    @editable # The seconds remaining before the heart beat warning appears. Shouldn't be > than HeartBeatTimer.
+    WarningTime:float = 5.0
+
+    @editable # An array of heart beat VFX devices. There is one per player.
+    AgentVFX:[]heartbeat_vfx = array{}
+    
+    @editable # The audio player device used to play the heart beat sound effects (SFX).
+    SFXPlayer:radio_device = radio_device{}
+
+    # This map associates a UI for displaying the heart beat warning to each prop agent. 
+    var WarningUI:[agent]heartbeat_warning_ui = map{}
+
+    # Keeps track of how many players have an active heartbeat so we can manage the SFX device.
+    var NumberOfHeartBeats:int = 0
+
+    # Sets up heart beat UI for the agent.
+    SetUpUI(PropAgent:agent):void =
+        if:
+            not WarningUI[PropAgent]
+            AsPlayer := player[PropAgent]
+            PlayerUI := GetPlayerUI[AsPlayer]
+        then:
+            UIData:heartbeat_warning_ui = heartbeat_warning_ui{}
+            UIData.CreateCanvas()
+            PlayerUI.AddWidget(UIData.Canvas, player_ui_slot{ZOrder := 1})
+            if (set WarningUI[PropAgent] = UIData) {}
+
+    # Activates the heartbeat VFX and SFX for the specified player.
+    Enable(PropAgent:agent, HeartBeatVFXData:heartbeat_vfx):void =
+        if:
+            # Get the character, which is used to find the prop agent's position in the scene. 
+            Character := PropAgent.GetFortCharacter[]
+        then:
+            # Set the heart beat VFX's position to the prop agent's position.
+            HeartBeatVFXData.Activate(Character.GetTransform())
+            # Increment the heartbeat count, and if this is the first heartbeat playing, we need to play the audio to get it started.
+            set NumberOfHeartBeats += 1
+            if (NumberOfHeartBeats = 1) then SFXPlayer.Play()
+            # Register the prop agent to the audio player device so the heart beat audio will play from that position.
+            SFXPlayer.Register(PropAgent)
+        else:
+            Logger.Print("Character, Index, or HeartBeatVFXData not found. Cannot start the heartbeat")
+
+    # Clears the heartbeat VFX and SFX for the specified prop agent.
+    Disable(PropAgent:agent, HeartBeatVFXData:heartbeat_vfx):void =
+        Logger.Print("Disabling heart beat.")
+        # Deactivate the VFX visuals.
+        HeartBeatVFXData.Deactivate()
+        # Unregister the prop agent from the audio player device, causing the heart beat audio to stop.
+        SFXPlayer.Unregister(PropAgent)
+        # Decrement the heartbeat counter. This counter should never drop below 0.
+        set NumberOfHeartBeats -= 1
+        if (NumberOfHeartBeats < 0) then set NumberOfHeartBeats = 0
+
+    # Clears all heartbeat VFX and SFX for all prop agents.
+    DisableAll():void =
+        Logger.Print("Disabling all heart beats.")
+        # Iterate through all VFX and move them to 0,0,0.
+        for (HeartBeatVFXDevice : AgentVFX):
+            HeartBeatVFXDevice.Deactivate()
+        # Unregister all players from the heart beat audio.
+        SFXPlayer.UnregisterAll()
+        # Reinitialize the heartbeat counter to 0
+        set NumberOfHeartBeats = 0
+
+# The heartbeat_warning_ui class contains a struct of data to track the UI canvas and text_block per player as well as the function to create a new heartbeat warning UI canvas.
+heartbeat_warning_ui := class:
+    var Canvas:canvas = canvas{}
+    var Text:text_block = text_block{}
+
+    # Creates the UI canvas for the warning message.
+    CreateCanvas():void =
+        set Text = text_block{DefaultTextColor := NamedColors.White, DefaultShadowColor := NamedColors.Black}
+        set Canvas = canvas:
+            Slots := array:
+                canvas_slot:
+                    Anchors := anchors{Minimum := vector2{X := 0.5, Y := 0.75}, Maximum := vector2{X := 0.5, Y := 0.75}}
+                    Offsets := margin{Top := 0.0, Left := 0.0, Right := 0.0, Bottom := 0.0}
+                    Alignment := vector2{X := 0.5, Y := 1.0}
+                    SizeToContent := true
+                    Widget := Text
+
+# The heartbeat_vfx class contains a struct of data to track the VFX's root and vfx_spawner_device objects per player as well as the functions to set the VFX to a position or reset it.
+heartbeat_vfx := class<concrete>:
+    @editable # The VFX device for each heart beat.
+    VFXDevice:vfx_spawner_device = vfx_spawner_device{}
+
+    # This offset is used to position the heartbeat above a prop agent's head.
+    HeartBeatVFXOffset:vector3 = vector3{X := 0.0, Y := 0.0, Z := 110.0}
+
+    # Sets the position of the heart beat VFX then enables the VFX.
+    Activate(Transform:transform):void =
+        VFXPosition := Transform.Translation + HeartBeatVFXOffset
+        if (VFXDevice.TeleportTo[VFXPosition, Transform.Rotation]):
+            VFXDevice.Enable()
+    
+    # Disables the VFX, hiding the heart beat visuals.
+    Deactivate():void =
+        VFXDevice.Disable()

Code_Reference/PropHunt/verse/hunter_team.verse

@@ -0,0 +1,28 @@
+using { /Fortnite.com/Devices }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /Verse.org/Simulation }
+
+# Inheriting from the base_team class, The hunter_team class contains the device definitions and functions related to the hunter team and its agents. 
+hunter_team := class<concrete>(base_team):
+    @editable # One hunter agent is created each round for each n players. Example: HunterTeamPerNumberOfPlayers = 5.0 is 1 per 5 players. If players = 6, 2 hunter agents are created.
+    HunterAgentPerNumberOfPlayers:float = 5.0 # Minimum 1.1 is enforced to ensure at least 1 prop agent is created.
+
+    @editable # The number of seconds before the hunter agents are spawned, giving the prop agents a head start to hide.
+    SpawnDelay:float = 15.0
+
+    @editable # The maximum base points a hunter agent gets for eliminating a prop agent. These points are divided by the number of prop agents remaining.
+    MaxEliminationScore:int = 5000
+
+    @editable # The timer device used to give props a grace period to hide.
+    WaitTimer:timer_device = timer_device{}
+
+    # Set the agent to a hunter agent. 
+    InitializeAgent<override>(NewHunterAgent:agent):void =
+        Logger.Print("Setting a new hunter agent.")
+        (super:)InitializeAgent(NewHunterAgent)
+
+    # When a hunter agent leaves the match, remove them from the HunterAgents array and check for the end of the round. 
+    # Notice that we're overriding this function because we don't need to pass extra data here like we do for prop team.
+    EliminateAgent<override>(HunterAgent:agent)<suspends>:void =
+        Logger.Print("Hunter agent eliminated.")
+        (super:)EliminateAgent(HunterAgent)

Code_Reference/PropHunt/verse/prop_hunt.verse

@@ -0,0 +1,189 @@
+using { /Fortnite.com/Devices }
+using { /Fortnite.com/UI }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /UnrealEngine.com/Temporary/SpatialMath }
+using { /UnrealEngine.com/Temporary/UI }
+using { /Verse.org/Colors }
+using { /Verse.org/Random }
+using { /Verse.org/Simulation }
+
+log_prop_hunt_device := class(log_channel){}
+
+# This class contains the logic for starting and ending a round. It also handles events for players joining and leaving when a round is in progress.
+prop_hunt := class(creative_device):
+    Logger:log = log{Channel:=log_prop_hunt_device}
+
+    @editable # An instance of the prop_team class, used to manage the Prop team.
+    PropTeam:prop_team = prop_team{}
+
+    @editable # An instance of the hunter_team class, used to manage the Hunter team.
+    HunterTeam:hunter_team = hunter_team{}
+
+    @editable # The round manager device is used to end the round when the last prop agent is eliminated.
+    RoundSettings:round_settings_device = round_settings_device{}
+
+    @editable # The teleporter in the lobby area. This device is enabled and disabled to allow props and hunters out of the pre-game lobby.
+    LobbyTeleporter:teleporter_device = teleporter_device{}
+
+    @editable # The waiting for more players device. This device checks if there are enough players to start the round.
+    WaitingForMorePlayers:waiting_for_more_players = waiting_for_more_players{}
+
+    @editable # This hud controller is used when a round is waiting to start.
+    # Set Priority to "Highest" for this device and have a second HUD controller set to < "Highest" to use during the round.
+    HUDControllerWaiting:hud_controller_device = hud_controller_device{}
+
+    @editable # The round timer device. This device keeps track of the time left in the round and is started within StartTheHunt().
+    RoundTimer:round_timer = round_timer{}
+
+    @editable # The device that controls the game music. 
+    GameMusic:radio_device = radio_device{}
+
+    @editable # Message for when the hunter agents are set loose in the game.
+    StartTheHuntMessage:hud_message_device = hud_message_device{}
+
+    @editable # The Verse class that controls the opening cinematic.
+    Cinematic:billboard_cinematic = billboard_cinematic{}
+
+    # When the device is started in a running game, initialize subscriptions and launch the team setup. This runs at the start of every round.
+    OnBegin<override>()<suspends>:void =
+        Sleep(1.0)
+        Logger.Print("Round loaded.")
+
+        # Play cinematic at beginning if user has it enabled
+        if (Cinematic.PlayAtStart?):
+            Cinematic.EnterCinematicModeForAll(GetPlayspace().GetPlayers())
+            Cinematic.CinematicCompleted.Await()
+            Cinematic.EndCinematicModeForAll(GetPlayspace().GetPlayers())
+            Logger.Print("Cinematic Completed.")
+        else:
+            Logger.Print("Cinematic Skipped.")
+
+        GameMusic.Play()
+        SetUpTeams()
+        race: # When there are no more prop or hunter agents (whichever happens first), or the round timer finishes, the round ends
+            PropTeam.TeamEmptyEvent.Await()
+            HunterTeam.TeamEmptyEvent.Await()
+            RoundTimer.AwaitEnd()
+        Logger.Print("Round ending.")
+        EndRound()
+
+    # When a round is started, subscribe to team devices, randomly pick the hunter agents, enable the hunter timer, set the prop agents, and teleport them into the game area.
+    SetUpTeams()<suspends>:void =
+        Logger.Print("Setting up teams.")
+
+        # Subscribe to the prop team score timer, set the score award, and subscribe to the prop team's eliminated event.
+        PropTeam.ScoreManager.SetScoreAward(PropTeam.ScorePerSecond)
+        PropTeam.TeamManager.TeamMemberEliminatedEvent.Subscribe(OnPropEliminated) # Occurs when a prop agent is eliminated.
+
+        # Subscribe to the hunter team's wait timer and set the duration. Also subscribe to the hunter team's elimination event.
+        HunterTeam.WaitTimer.SuccessEvent.Subscribe(HuntersGo)
+        HunterTeam.WaitTimer.SetMaxDuration(HunterTeam.SpawnDelay)
+        HunterTeam.TeamManager.EnemyEliminatedEvent.Subscribe(OnHunterEliminated) # Occurs when a hunter agent eliminates a prop agent.
+
+        # Initialize the starting hunter and prop agents arrays. Get the players and find the number of players in the server.
+        var StartingHunterAgents:[]agent = array{}
+        var StartingPropAgents:[]agent = array{}
+        var Players:[]player = GetPlayspace().GetPlayers()
+
+        # Enable the HUD appropriate for waiting for players. 
+        HUDControllerWaiting.Enable()
+
+        # Check if there are enough players to start the round.
+        set Players = WaitingForMorePlayers.WaitForMinimumNumberOfPlayers(Players)
+        Logger.Print("Round started.")
+
+        # Disable the waiting HUD to use the next highest priority HUD. 
+        HUDControllerWaiting.Disable()
+
+        # Now that the round has started, we need to handle players being added or removed from the match. Subscribe to those events.
+        GetPlayspace().PlayerAddedEvent().Subscribe(OnPlayerAdded)
+        GetPlayspace().PlayerRemovedEvent().Subscribe(OnPlayerRemoved)
+
+        # Calculate the number of starting hunter agents for the game based on the player count and the number of hunter agents per number of players.
+        NumberOfPlayers:float = 1.0 * Players.Length # Converts Players.Length to a float so it can be used in the next Ceil function.
+        if (NumberOfStartingHunters:int = Ceil[NumberOfPlayers / Max(1.1, HunterTeam.HunterAgentPerNumberOfPlayers)]):
+            # Shuffle the players and then slice the array to get the starting hunter agents. The remaining players are the starting prop agents. 
+            var RandomizedPlayers:[]agent = Shuffle(Players)
+            if (set StartingHunterAgents = RandomizedPlayers.Slice[0,NumberOfStartingHunters]) {}
+            if (set StartingPropAgents = RandomizedPlayers.Slice[NumberOfStartingHunters,RandomizedPlayers.Length]) {}
+
+            # Iterate through the starting hunter agents and assign them to the hunter team. Then start the hunter wait timer.
+            Logger.Print("Setting {StartingHunterAgents.Length} hunter agent(s).")
+            for (StartingHunterAgent : StartingHunterAgents):
+                HunterTeam.InitializeAgent(StartingHunterAgent)
+            HunterTeam.WaitTimer.Start()
+
+            # Iterate through the starting prop agents and assign them to the prop team. Teleport them into the play area.
+            Logger.Print("Setting {StartingPropAgents.Length} prop agent(s).")
+            LobbyTeleporter.Enable()
+            for (StartingPropAgent : StartingPropAgents):
+                PropTeam.InitializeAgent(StartingPropAgent)
+                PropTeam.HeartBeat.SetUpUI(StartingPropAgent)
+                LobbyTeleporter.Activate(StartingPropAgent)
+            LobbyTeleporter.Disable()
+            # Set the props remaining tracker's Target and Value to the current number of props.
+            # In the future, we'll only update Value as props are eliminated.
+            PropTeam.PropsRemainingTracker.SetTarget(PropTeam.Count())
+            PropTeam.UpdatePropsRemainingTracker()
+
+    # When the hunter timer finishes, spawn the function that unleashes the hunter agents into the game and begins the round.
+    # HunterInstigator is needed for the event subscription but not used.
+    HuntersGo(HunterInstigator:?agent):void =
+        spawn{ StartTheHunt() }
+
+    # Enable the lobby teleporter, teleport all the hunter agents to the game area and then run the prop game loop for each prop agent.
+    StartTheHunt()<suspends>:void =
+        Logger.Print("Teleporting hunter agent(s).")
+        LobbyTeleporter.Enable()
+        Sleep(0.5) # Delaying half a second to give the teleporter time to enable.
+        for (HunterAgent : HunterTeam.GetAgents[]):
+            LobbyTeleporter.Activate(HunterAgent)
+            StartTheHuntMessage.Show(HunterAgent)
+        Logger.Print("Starting prop(s) game logic.")
+        for (PropAgent : PropTeam.GetAgents[]):
+            spawn {PropTeam.RunPropGameLoop(PropAgent)}
+            StartTheHuntMessage.Show(PropAgent)
+
+        # Signal that the round has started to start the round and scoring timers.
+        RoundTimer.Start()
+        PropTeam.ScoreTimer.Start()
+
+    # When a player joins the match mid-round, make them a hunter if the round has started.
+    OnPlayerAdded(Player:player):void =
+        Logger.Print("A player joined the game.")
+        if (PropTeam.Count() > 0): # if there are any prop agents, the round has started.
+            HunterTeam.InitializeAgent(Player)
+
+    # When a hunter agent eliminates a prop agent, award score. The score is divided by the number of prop agents remaining.
+    OnHunterEliminated(HunterAgent:agent):void =
+        Logger.Print("Hunter agent eliminated a prop agent.")
+        PropTeamSize := PropTeam.Count()
+        if (EliminationAward := Floor(HunterTeam.MaxEliminationScore / PropTeamSize)):
+            Logger.Print("Awarding {EliminationAward} points.")
+            HunterTeam.ScoreManager.SetScoreAward(EliminationAward)
+            HunterTeam.ScoreManager.Activate(HunterAgent)
+
+    # When a prop agent is eliminated, remove the prop from the prop team, check for round end, and set them as a hunter.
+    OnPropEliminated(PropAgent:agent):void =
+        Logger.Print("Prop agent eliminated.")
+        spawn{ PropTeam.EliminateAgent(PropAgent) }
+        HunterTeam.InitializeAgent(PropAgent)
+  
+    # When a player leaves the match, check which team they were on and then check for round end.
+    OnPlayerRemoved(Player:player):void =
+        Logger.Print("A player left the game.")
+        if (PropTeam.FindOnTeam[Player]):
+            Logger.Print("Player was a Prop.")
+            spawn{ PropTeam.EliminateAgent(Player) }
+        if (HunterTeam.FindOnTeam[Player]):
+            Logger.Print("Player was a Hunter.")
+            spawn{ HunterTeam.EliminateAgent(Player) }
+
+    # Cleans up the heart beat VFX and then ends the round.
+    EndRound():void=
+        PropTeam.HeartBeat.DisableAll()
+        # Get any player to pass to EndRound
+        Players:[]player = GetPlayspace().GetPlayers()
+        if (RoundEndInstigator := Players[0]):
+            Logger.Print("Round ended.")
+            RoundSettings.EndRound(RoundEndInstigator)

Code_Reference/PropHunt/verse/prop_team.verse

@@ -0,0 +1,147 @@
+using { /Fortnite.com/Characters }
+using { /Fortnite.com/Devices }
+using { /Fortnite.com/UI }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /UnrealEngine.com/Temporary/SpatialMath }
+using { /UnrealEngine.com/Temporary/UI }
+using { /Verse.org/Colors }
+using { /Verse.org/Simulation }
+
+# This message is used to print the number of props remaining to all players during a round.
+PropAgentsRemainingMessage<localizes>(Count:int):message = "{Count} Prop(s) Remaining"
+
+# Inheriting from the base_team class, the prop_team class contains the device definitions and functions related to the prop team and its agents.
+# Notably, a prop agent's heart beat behavior can be found in this class.
+prop_team := class<concrete>(base_team):
+    @editable # The score a prop agent receives per second.
+    ScorePerSecond:int = 10
+
+    @editable # The minimum distance a prop agent must move to reset the heart beat timer.
+    MinimumMoveDistance:float = 100.0
+
+    @editable # The timer device used to award score to a prop.
+    ScoreTimer:timer_device = timer_device{}
+
+    @editable # This tracker device is used to display the props remaining to the screen.
+    PropsRemainingTracker:tracker_device = tracker_device{}
+    
+    @editable # Get the properties from the heart_beat class.
+    HeartBeat:heart_beat = heart_beat{}
+
+    # Set the agent to a prop agent and assign heart beat warning UI. 
+    InitializeAgent<override>(NewPropAgent:agent):void =
+        Logger.Print("Setting a new prop agent.")
+        (super:)InitializeAgent(NewPropAgent)
+
+    # When a prop agent is eliminated or leaves the match, remove them from the PropAgents array and check for the end of the round.
+    # Note that this isn't overridding because we're passing all players to the function to update the props remaining message.
+    EliminateAgent<override>(PropAgent:agent)<suspends>:void =
+        Logger.Print("Prop agent eliminated.")
+        (super:)EliminateAgent(PropAgent)
+        # Update the props remaining number.
+        UpdatePropsRemainingTracker()
+
+    # Updates the value of the tracker device showing the number of props remaining.
+    UpdatePropsRemainingTracker():void =
+        PropsRemainingTracker.SetValue(Count())
+
+    # If the prop agent stops moving then race to see if the prop agent moves beyond the MinimumMoveDistance, the heart beat timer completes, or the prop agent is eliminated.
+    RunPropGameLoop(PropAgent:agent)<suspends>:void =
+        Logger.Print("Starting prop agent game loop.")
+        # Loop forever through the prop behavior and scoring until the prop agent is eliminated or the player leaves the session.
+        race: 
+            PropAgent.AwaitNoLongerAProp()
+            loop:
+                # Wait until the prop agent moves less than the minimum distance, then advance.
+                PropAgent.AwaitStopMoving(MinimumMoveDistance) 
+                # Until the prop agent moves beyond the minimum distance, countdown to the heart beat and then play the heart beat indefinitely.
+                race: 
+                    PropAgent.AwaitStartMoving(MinimumMoveDistance)
+                    block:
+                        CountdownTimer(PropAgent)
+                        PropAgent.StartHeartbeat()
+                Sleep(0.0) # Once the race completes (the prop agent moves), start the loop again.
+            loop:
+                # Every second, award the prop agent points.
+                Sleep(1.0)
+                ScoreManager.Activate(PropAgent)
+
+
+    # Loop until the prop agent is no longer a part of the PropAgents array. Removal happens if the prop agent is eliminated and turned into a hunter or if the player leaves the session.
+    (PropAgent:agent).AwaitNoLongerAProp()<suspends>:void =
+        loop:
+            if (not FindOnTeam[PropAgent]):
+                Logger.Print("Cancelling prop agent behavior.")
+                break
+            Sleep(0.0) # Advance to the next game tick.
+
+    # Loops until the agent moves less than the MinimumDistance.
+    (PropAgent:agent).AwaitStopMoving(MinimumDistance:float)<suspends>:void =
+        Logger.Print("Checking if the agent has moved less than the minimum distance.")
+        # Get the initial position of the agent from the agent's character in the scene.
+        if (Tracked := PropAgent.GetFortCharacter[]):
+            var StartPosition:vector3 = Tracked.GetTransform().Translation
+            loop:
+                Sleep(0.0) # Get the position of the agent in the next game tick.
+                NewPosition := Tracked.GetTransform().Translation
+                # If the distance of the new position from the starting position is less than MinimumDistance, the agent has not moved and we break the loop.
+                if (Distance(StartPosition, NewPosition) < MinimumDistance):
+                    Logger.Print("Agent has moved less than the minimum distance.")
+                    break
+                # Otherwise, we reset StartPosition to make sure the player moves from the new position.
+                else: 
+                    set StartPosition = NewPosition
+
+    # Loops until the agent moves more than the MinimumDistance.
+    (PropAgent:agent).AwaitStartMoving(MinimumDistance:float)<suspends>:void =
+        Logger.Print("Checking if the agent moves further than the minimum distance.")
+        # Get the initial position of the agent from the agent's character in the scene.
+        if (Tracked := PropAgent.GetFortCharacter[]):
+            StartPosition:vector3 = Tracked.GetTransform().Translation
+            loop:
+                Sleep(0.0) # Get the position of the agent in the next game tick.
+                NewPosition := Tracked.GetTransform().Translation
+                # If the distance of the new position from the starting position is greater than or equal to MinimumDistance, the agent has moved and we break the loop.
+                if (Distance(StartPosition, NewPosition) >= MinimumDistance):
+                    Logger.Print("Agent has moved more than or equal to the minimum distance.")
+                    break
+
+    # Delays until HeartBeatWarningTime should start. Then counts down by HeartBeatWarningTime and sets the countdown text. Clears the text when deferred.
+    CountdownTimer(PropAgent:agent)<suspends>:void =
+        Logger.Print("Starting heart beat countdown.")
+        if (UIData := HeartBeat.WarningUI[PropAgent]):
+            Sleep(HeartBeat.MoveTime - HeartBeat.WarningTime) # Sleep for the amount of time before the warning appears.
+            Logger.Print("Starting heart beat warning.")
+            var WarningTimeRemaining:int = 0
+            if (set WarningTimeRemaining = Ceil[HeartBeat.WarningTime]) {}
+            # A defer happens when the function completes or if it is cancelled, such as if it loses a race.
+            # So in this case, the warning text is cleared when the countdown finishes or if the prop agent moves before the countdown finishes.
+            defer:
+                UIData.Text.SetText(HeartBeatWarningClear)
+            # Set the warning text to the time remaining, wait a second, and then decrement the time remaining. If the countdown completes, break the loop.
+            loop:
+                Logger.Print("Heart beat in {WarningTimeRemaining} seconds.")
+                UIData.Text.SetText(HeartBeatWarningMessage(WarningTimeRemaining))
+                Sleep(1.0)
+                set WarningTimeRemaining -= 1
+                if (WarningTimeRemaining <= 0):
+                    break
+        else:
+            Logger.Print("UIData not found.")
+              
+    # Turns on the heart beat VFX and SFX. Waits infinitely until deferred then disables the heart beat VFX and SFX.
+    (PropAgent:agent).StartHeartbeat()<suspends>:void =
+        Logger.Print("Spawning heart beat.")
+        # Save the heartbeat data so we can pass it in the defer later, after the PropAgent is destroyed or leaves the game.
+        var HeartBeatVFXData:heartbeat_vfx = heartbeat_vfx{}
+        if:
+            # Get the index of the prop agent in the PropAgents array to then access the corresponding heart beat VFX actor.
+            Index := FindOnTeam[PropAgent]
+            set HeartBeatVFXData = HeartBeat.AgentVFX[Index]
+        then:
+            HeartBeat.Enable(PropAgent, HeartBeatVFXData)
+        # When this function is cancelled by the prop agent moving, being eliminated, or the player leaving the session, disable the heartbeat.
+        defer:
+            HeartBeat.Disable(PropAgent, HeartBeatVFXData)
+        Sleep(Inf) # Do not stop sleeping until the race completes.
+

Code_Reference/PropHunt/verse/round_timer.verse

@@ -0,0 +1,158 @@
+using { /Fortnite.com/Devices }
+using { /Fortnite.com/UI }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /UnrealEngine.com/Temporary/SpatialMath }
+using { /UnrealEngine.com/Temporary/UI }
+using { /Verse.org/Colors }
+using { /Verse.org/Simulation }
+
+log_round_timer_device := class(log_channel){}
+
+# An int that allows values between the ranges specified. This type is required by player_ui_slot.ZOrder.
+round_int_clamped := type{_X:int where 0 <= _X, _X <= 2147483647}
+
+# This message is used to print the time remaining before a round ends.
+TimeRemainingMessage<localizes>(Minutes:string, Seconds:string):message = "{Minutes}:{Seconds}"
+
+<#
+This class contains all the logic for managing the round time and displaying the time to the screen.
+You can use this device with a round_settings_device to actually end the round.
+This device manages time without the use of a timer.
+To use this class:
+    1) Add the file to your project.
+    2) Compile Verse Code from the Verse menu on the toolbar.
+    3) Drag the device into your island from your island's Content/Creative Devices folder in the Content Browser.
+    4) Include the waiting_for_more_players class in another Verse script with:
+        @editable
+        RoundTimer:round_timer = round_timer{}
+    5) Compile Verse Code from the Verse menu on the toolbar.
+    6) Connect the device you made in step 3 to the Verse device.
+    7) Start the round timer with the following Verse:
+        RoundTimer.Start()
+    8) Restart or Stop the timer with the equivalent functions.
+    9) Wait for the timer to start with:
+        RoundTimer.AwaitStart()
+    10) Wait for the timer to complete with:
+        RoundTimer.AwaitEnd()
+        Call the EndRound function on a round_settings_device to actually end the game round.
+#>
+round_timer := class(creative_device):
+    Logger:log = log{Channel:=log_round_timer_device}
+
+    @editable # The time, in minutes, a round lasts.
+    RoundTimeInMinutes:float = 5.0
+
+    @editable # The horizontal and vertical position of the timer UI on screen. X 0-1 is left-right and Y 0-1 is top-bottom.
+    UIPosition:vector2 = vector2{X:= 0.98, Y:=0.13}
+
+    @editable # The horizontal and vertical position of the timer UI on screen. X 0-1 is left-right and Y 0-1 is top-bottom.
+    UIAlignment:vector2 = vector2{X := 1.0, Y := 0.0}
+
+    @editable # The ZOrder of the UI compared to other UI elements.
+    UIZOrder:round_int_clamped = 4
+
+    # Signaled when the round has been started.
+    RoundStarted:event() = event(){}
+
+    # Signaled when the round is about to be ended.
+    RoundEndedEvent:event() = event(){}
+
+    # This map associates a text box for displaying the time to each player.  
+    var TimeRemainingTextBlocks:[player]text_block = map{}
+
+    # The time remaining before the round completes, as an integer.
+    var TimeRemainingInSeconds:int = 0
+
+    # Waits until the round timer is started.
+    AwaitStart()<suspends>:void =
+        RoundStarted.Await()
+        Logger.Print("Round timer started.")
+    
+    # Used to start the round timer.
+    Start():void = 
+        Logger.Print("Starting the round timer.")
+        RoundStarted.Signal()
+        set TimeRemainingInSeconds = GetRoundTimeInSeconds()
+        spawn{ Running() }
+
+    # Restarts the timer to RoundTime
+    Restart():void = 
+        Logger.Print("Restarting the round timer.")
+        set TimeRemainingInSeconds = GetRoundTimeInSeconds()
+
+    # Runs the timer logic.
+    Running()<suspends>:void =
+        Logger.Print("Round timer running.")
+        loop:
+            UpdateTimeUI()
+            Sleep(1.0)
+            # Decrement TimeRemaining by 1 second then check if the time has run out. If so, end the round.
+            set TimeRemainingInSeconds -= 1
+            if (TimeRemainingInSeconds < 0):
+                Stop()
+                break
+            
+    # Stops the timer and ends the round.
+    Stop():void = 
+        Logger.Print("Ending the round timer.")
+        # We get a player from the players remaining in the scene to end the round.
+        Players:[]player = GetPlayspace().GetPlayers()
+        if (Instigator := Players[0]):
+            RoundEndedEvent.Signal()
+
+    # Waits until the round timer is just about to end.
+    AwaitEnd()<suspends>:void =
+        RoundEndedEvent.Await()
+        Logger.Print("Round timer ended.")
+
+    # Accepts a time value in minutes and returns the value in seconds.
+    GetRoundTimeInSeconds():int =
+        var InSeconds:int = 0
+        if (set InSeconds = Round[RoundTimeInMinutes * 60.0]) {}
+        InSeconds
+
+    # When the timer completes, update the time remaining and check if time has expired.
+    UpdateTimeUI():void =
+        # Set Minutes to TimeRemainingInSeconds/60 without the remainder.
+        var Minutes:int = 0
+        if (set Minutes = Floor(TimeRemainingInSeconds / 60)) {}
+        # Set Seconds to the remainder of TimeRemainingInSeconds/60.
+        var Seconds:int = 0
+        if (set Seconds = Mod[TimeRemainingInSeconds, 60]) {}
+        # Convert Minutes and Seconds to strings.
+        MinutesAsString := string("{Minutes}")
+        # If Seconds < 10, then we need to add a 0 in front of the value so it displays as :0# instead of :#
+        SecondsAsString := if (Seconds < 10) then Join(array{string("{0}"),string("{Seconds}")},string()) else string("{Seconds}")
+
+        # Iterate through all players, check if they have a TimeRemainingTextBlock, if not, give them one. Then update the text.
+        Players:[]player = GetPlayspace().GetPlayers()
+        for (Player : Players):
+            var TextBlock:text_block = text_block{}
+            if (set TextBlock = TimeRemainingTextBlocks[Player]):
+            else:
+                Logger.Print("Creating new round time text block.")
+                set TextBlock = SetUpTimeRemainingUI(Player)
+            TextBlock.SetText(TimeRemainingMessage(MinutesAsString, SecondsAsString))
+
+    # Accepts a player and then adds a round time ui canvas to their screen and stores their TimeRemainingTextBlock for updating later.
+    SetUpTimeRemainingUI(Player:player):text_block =
+        Logger.Print("Adding round timer UI to a player.")
+        # This is the text_block that prints the time remaining text to the screen.
+        TextBlock:text_block = text_block:
+            DefaultTextColor := NamedColors.White
+            DefaultShadowColor := NamedColors.Black
+        if (PlayerUI := GetPlayerUI[Player]):
+            if (set TimeRemainingTextBlocks[Player] = TextBlock) {}
+            # This is the canvas that holds and positions the text_block on the screen.
+            Canvas := canvas:
+                Slots := array:
+                    canvas_slot:
+                        Anchors := anchors{Minimum := UIPosition, Maximum := UIPosition}
+                        Offsets := margin{Top := 0.0, Left := 0.0, Right := 0.0, Bottom := 0.0}
+                        Alignment := UIAlignment
+                        SizeToContent := true
+                        Widget := TextBlock
+            # The canvas is assigned to the player.
+            PlayerUI.AddWidget(Canvas, player_ui_slot{ZOrder := UIZOrder})
+        # The text_block is returned so it can be saved to the map and updated later as time ticks down.
+        return TextBlock

Code_Reference/PropHunt/verse/waiting_for_more_players.verse

@@ -0,0 +1,131 @@
+
+using { /Fortnite.com/Devices }
+using { /Fortnite.com/UI }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /UnrealEngine.com/Temporary/SpatialMath }
+using { /UnrealEngine.com/Temporary/UI }
+using { /Verse.org/Colors }
+using { /Verse.org/Simulation }
+
+log_waiting_for_more_players_device := class(log_channel){}
+
+# An int that allows values between the ranges specified. This type is required by player_ui_slot.ZOrder.
+waiting_int_clamped := type{_X:int where 0 <= _X, _X <= 2147483647}
+
+# This message is used to print the number of players needed before a round can begin.
+WaitingForMorePlayersMessage<localizes>(Count:int):message = "Waiting for {Count} more Player(s)"
+
+# This class is for showing how many players are needed to start the round.
+waiting_for_more_players_ui := class:
+    var Canvas:canvas
+    var TextBlock:text_block
+
+<# 
+This class contains all the logic for setting a minimum number of players and checking if there are enough to start the round.
+To use this class:
+    1) Add the file to your project.
+    2) Compile Verse Code from the Verse menu on the toolbar.
+    3) Drag the device into your island from your island's Content/Creative Devices folder in the Content Browser.
+    4) Connect a Timer device to this device's "WaitingForMorePlayersTimer" property.
+    5) Include the waiting_for_more_players class in another Verse script with:
+        @editable
+        WaitingForMorePlayers:waiting_for_more_players = waiting_for_more_players{}
+    6) Compile Verse Code from the Verse menu on the toolbar.
+    7) Connect the device you made in step 3 to the Verse device and property you exposed in step 6.
+    8) Await the CheckForMinimumNumberOfPlayers functions by passing it a player. For example:
+        Players = GetPlayspace().GetPlayers()
+        CheckForMinimumNumberOfPlayers(Players)
+    9) On IslandSettings, Set the Game Start Countdown to 0.0.
+#>
+waiting_for_more_players := class(creative_device):
+    Logger:log = log{Channel:=log_waiting_for_more_players_device}
+
+    @editable # The minimum number of players needed in the match for a round to start.
+    MinimumNumberOfPlayers:int = 2
+
+    @editable # The horizontal and vertical position of the timer UI on screen. X 0-1 is left-right and Y 0-1 is top-bottom.
+    UIPosition:vector2 = vector2{X:= 0.5, Y:=0.4}
+
+    @editable # The horizontal and vertical position of the timer UI on screen. X 0-1 is left-right and Y 0-1 is top-bottom.
+    UIAlignment:vector2 = vector2{X := 0.5, Y := 0.5}
+
+    @editable # The ZOrder of the UI compared to other UI elements.
+    UIZOrder:waiting_int_clamped = 3
+
+    @editable # This timer is used to countdown to round start after waiting for players to join the match.
+    WaitingForMorePlayersTimer:timer_device = timer_device{}
+
+    # This map associates a UI canvas for displaying the number of players needed to start a round to each player. 
+    var WaitingForMorePlayersUI:[player]?waiting_for_more_players_ui = map{}
+
+    # Check if there are enough players to start the round. If not, wait until number of players >= MinimumNumberOfPlayers.
+    WaitForMinimumNumberOfPlayers(Players:[]player)<suspends>:[]player =
+        Logger.Print("Waiting if there are enough players for the round to start.")
+        # Creating a new variable so I can modify it as more players join. Initializing it with an array of players passed to the function.
+        var PlayersWaiting:[]player = Players
+        # If the number of players is less than the minimum needed to start the round...
+        if (PlayersWaiting.Length < MinimumNumberOfPlayers):
+            loop: # Loop until the number of players is greater than or equal to the minimum needed.
+                Logger.Print("{PlayersWaiting.Length}/{MinimumNumberOfPlayers} players needed for the round to start.")
+                # Update the waiting for more players UI.
+                DisplayWaitingForMorePlayers(PlayersWaiting)
+                Sleep(2.0) # Wait to see if more players join the match then check if there are enough players to start the round.
+                set PlayersWaiting = GetPlayspace().GetPlayers()
+                if (PlayersWaiting.Length >= MinimumNumberOfPlayers):
+                    # If there are now enough players, clear the waiting for more players UI, 
+                    Logger.Print("{PlayersWaiting.Length}/{MinimumNumberOfPlayers} players in round, preparing for round start.")
+                    ClearWaitingForMorePlayers()
+                    # Then break out of the loop.
+                    break
+        # start the round start countdown, and wait until the countdown completes. 
+        WaitingForMorePlayersTimer.Start()
+        WaitingForMorePlayersTimer.SuccessEvent.Await()
+        Logger.Print("Starting round.")
+        # Return the list of players in the session.
+        return PlayersWaiting
+
+    # Displays a "Waiting for more players" UI message for each player if they don't already have one. Updates the player counter for all players.
+    DisplayWaitingForMorePlayers(Players:[]player):void =
+        PlayersNeededCount := MinimumNumberOfPlayers - Players.Length
+        Logger.Print("{Players.Length} players in round, waiting for {PlayersNeededCount} more player(s) to join.")
+        for (Player: Players):
+            # If the player has a WaitingForMorePlayersUI, get the TextBlock and refresh the text so it shows the correct number of players needed to start the round.
+            if (UIData := WaitingForMorePlayersUI[Player]?):
+                UIData.TextBlock.SetText(WaitingForMorePlayersMessage(PlayersNeededCount))
+            # Else create a WaitingForMorePlayersUI for the player.
+            else:
+                SetUpWaitingForMorePlayersUI(Player, PlayersNeededCount)
+    
+    # Accepts a player and player_ui and adds a waiting for more players ui canvas to their screen.
+    SetUpWaitingForMorePlayersUI(Player:player, PlayersNeededCount:int):void =
+        Logger.Print("Creating 'waiting for more players' UI.")
+        if (PlayerUI := GetPlayerUI[Player]):
+            # This is the text_block that prints the waiting for more players text to the screen.
+            TextBlock:text_block = text_block:
+                DefaultText := WaitingForMorePlayersMessage(PlayersNeededCount)
+                DefaultTextColor := NamedColors.White
+                DefaultShadowColor := NamedColors.Black
+            # This is the canvas that holds and positions the text_block on the screen.
+            Canvas := canvas:
+                Slots := array:
+                    canvas_slot:
+                        Anchors := anchors{Minimum := UIPosition, Maximum := UIPosition}
+                        Offsets := margin{Top := 0.0, Left := 0.0, Right := 0.0, Bottom := 0.0}
+                        Alignment := UIAlignment
+                        SizeToContent := true
+                        Widget := TextBlock
+            # The canvas is assigned to the player.
+            PlayerUI.AddWidget(Canvas, player_ui_slot{ZOrder := UIZOrder})
+            # The text_block is saved to the map so we can update the text later as more players join the game.
+            if (set WaitingForMorePlayersUI[Player] = option{ waiting_for_more_players_ui{Canvas := Canvas, TextBlock := TextBlock} }) {}
+
+    # Removes the "Waiting for more players" UI message for each player who has one.
+    ClearWaitingForMorePlayers():void =
+        Logger.Print("Clearing 'waiting for more players' UI.")
+        for (Player -> UIData : WaitingForMorePlayersUI):
+            if:
+                PlayerUI := GetPlayerUI[Player]
+                Canvas := UIData?.Canvas
+                set WaitingForMorePlayersUI[Player] = false
+            then:
+                PlayerUI.RemoveWidget(Canvas)

Code_Reference/Stronghold/verse/stronghold_alert_manager.verse

@@ -0,0 +1,87 @@
+using { /Verse.org/Simulation }
+using { /Verse.org/Simulation/Tags }
+using { /Verse.org/Colors }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /Fortnite.com/Devices }
+
+
+# Script that handles music and turn on lights when guards are alerted
+stronghold_alert_manager := class(creative_device):
+    
+    # Reference to the Game Manager to monitor perception events
+    @editable
+    StrongholdGameManager:stronghold_game_manager := stronghold_game_manager{}
+
+    # Reference to Radio that plays combat music
+    @editable
+    RadioCombat:radio_device := radio_device{}
+
+    # Reference to Radio that plays alerted music
+    @editable
+    RadioAlerted:radio_device := radio_device{}
+
+    # VFX to play when alarm/flare is shot
+    @editable
+    FlareAlarmVFXCreator:vfx_creator_device := vfx_creator_device{}
+    
+    # Lights to turn on when alerted
+    @editable
+    CustomizableLightDevicesAlerted: []customizable_light_device = array{}
+
+    # Lights to turn on during combat
+    @editable
+    CustomizableLightDevicesCombat: []customizable_light_device = array{}
+    
+    # Change the camp to alerted when player is lost / killed
+    WaitForAlerted()<suspends>:void=
+        # do not go back to alerted after fallback
+        if (StrongholdGameManager.FallbackTriggered?):
+            Sleep(Inf)
+        StrongholdGameManager.GuardsUnawareEvent.Await()
+        Sleep(3.0)
+        SetAlertedMood()
+
+    # Change the camp to combat when player is spotted
+    WaitForCombat()<suspends>:void=
+        race:
+            StrongholdGameManager.PlayerDetectedEvent.Await()
+            StrongholdGameManager.FallbackEvent.Await()
+        Sleep(2.0)
+        SetCombatMood()
+
+    # Runs when the device is started in a running game
+    OnBegin<override>()<suspends>:void=
+        MonitorStrongholdAlertStatus()
+
+    # Main Loop checking if stronghold is in combat or alerted
+    MonitorStrongholdAlertStatus()<suspends>:void=
+        loop:
+            WaitForCombat()
+            WaitForAlerted()
+    
+    # Sets Base to Combat by toggling lights red and playing high intensity music
+    SetCombatMood():void=
+        # Loop through Combat Lights and turn them on
+        for(LightsToTurnOn: CustomizableLightDevicesCombat):
+            LightsToTurnOn.TurnOn()
+        # Loop through Alert Lights and turn them off
+        for(LightsToTurnOff: CustomizableLightDevicesAlerted):
+            LightsToTurnOff.TurnOff()
+        # Turn on combat audio and turn off alerted audio
+        RadioCombat.Play()
+        RadioAlerted.Stop()
+        FlareAlarmVFXCreator.Toggle()
+        Log("Alert manager - Combat Lights & Music On")
+
+    # Sets Base to Alerted by toggling lights yellow and playing  tense music
+    SetAlertedMood():void=
+        for(LightsToTurnOn: CustomizableLightDevicesAlerted):
+            LightsToTurnOn.TurnOn()
+        for(LightsToTurnOff: CustomizableLightDevicesCombat):
+            LightsToTurnOff.TurnOff()
+        RadioCombat.Stop()
+        RadioAlerted.Play()
+        Log("Alert manager - Alert Lights & Music On")
+
+   
+          

Code_Reference/Stronghold/verse/stronghold_bark_manager.verse

@@ -0,0 +1,247 @@
+using { /Fortnite.com/Devices }
+using { /Fortnite.com/Game }
+using { /Fortnite.com/Characters }
+using { /Verse.org/Random }
+using { /Verse.org/Simulation }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /UnrealEngine.com/Temporary/SpatialMath }
+
+# Audio bark that can be played on a NPC
+audio_npc_bark := class<concrete>:
+
+    # Audio device to play barks
+    @editable
+    BarkDevice:audio_player_device := audio_player_device{}
+
+    # Option to allow NPCs to repeat the bark
+    @editable
+    CanRepeat:logic = true
+
+    # Delay between the event and the beginning of the bark
+    @editable
+    Delay:float = 0.0
+
+    # Delay before repeating this bark
+    @editable
+    Cooldown:float = 5.0
+
+    # Bark name for logging
+    @editable
+    BarkID:string = "Missing ID"
+
+    # Is the cooldown timer elapsed
+    var<private> IsInCooldown:logic = false
+
+    # Event to stop the bark
+    StopBarkEvent<private>:event() = event(){}
+
+    PlayBark(Agent:agent)<suspends>:void=
+        var IsPlaying:logic = false;
+        defer:
+            if (IsPlaying?):
+                set IsPlaying = false
+                set IsInCooldown = false
+                BarkDevice.Stop(Agent)
+                Log("Bark manager - PlayBark - {BarkID} - Stopped")
+        race:
+            block:
+                StopBarkEvent.Await()
+                return
+            block:
+                AwaitAgentDown(Agent)
+                return
+            block:
+                if (Delay > 0.0):
+                    Sleep(Delay)
+                if (IsInCooldown?):
+                    return
+                BarkDevice.Play(Agent)
+                set IsPlaying = true
+                set IsInCooldown = true
+                Sleep(2.0)
+                set IsPlaying = false
+                Log("Bark manager - PlayBark - {BarkID} - Success")
+
+        if (CanRepeat?):
+            Sleep(Cooldown)
+            set IsInCooldown = false
+
+    StopBark():void=
+        StopBarkEvent.Signal()
+
+    AwaitAgentDown<private>(Agent:agent)<suspends>:void=
+        if (Character := Agent.GetFortCharacter[]):
+            loop:
+                if (Character.GetHealth() <= 0.0):
+                    return
+                Character.DamagedEvent().Await()
+    
+# Script that handles barks from guards                
+stronghold_bark_manager := class(creative_device):
+    
+    # Reference to the Game Manager to monitor perception events
+    @editable
+    StrongholdGameManager:stronghold_game_manager := stronghold_game_manager{}
+
+    # Audio Player Devices
+    @editable
+    BarkNPCDown:audio_npc_bark = audio_npc_bark{BarkID := "Man Down", Delay := 0.3}
+
+    @editable
+    BarkFallback:audio_npc_bark = audio_npc_bark{BarkID := "Fallback", CanRepeat := false, Delay := 3.0}
+    
+    @editable
+    BarkNeedBackup:audio_npc_bark = audio_npc_bark{BarkID := "Need Backup", CanRepeat := false, Delay := 2.0}
+
+    @editable
+    BarkGoToLeash:audio_npc_bark = audio_npc_bark{BarkID := "Reinforcements En Route", CanRepeat := false, Delay := 4.0}
+
+    @editable
+    BarkDamageTaken:audio_npc_bark = audio_npc_bark{BarkID := "Took Damage", Delay := 0.2}
+
+    @editable
+    BarkDamagePlayer:audio_npc_bark = audio_npc_bark{BarkID := "Hit Player", Delay := 0.2}
+
+    @editable
+    BarkEliminatedPlayer:audio_npc_bark = audio_npc_bark{BarkID := "Eliminated Player", Delay := 0.3}
+
+    @editable
+    BarkPlayerSpotted:audio_npc_bark = audio_npc_bark{BarkID := "Spotted Player", CanRepeat := false}
+
+    @editable
+    BarkPlayerLost:audio_npc_bark = audio_npc_bark{BarkID := "Lost Player", Cooldown := 10.0}
+
+    @editable
+    BarkGuardSuspicious:audio_npc_bark = audio_npc_bark{BarkID := "Suspicious", Cooldown := 10.0}
+
+    @editable
+    BarkGuardUnaware:audio_npc_bark = audio_npc_bark{BarkID := "Unaware", Cooldown := 10.0}
+
+    # Variable to store if guards were looking for targets
+    var<private> HasLostTarget:logic := false
+
+    # Runs when the device is started in a running game
+    OnBegin<override>()<suspends>:void=
+        ConfigureBarks()
+
+        sync:
+            AwaitReinforcements()
+            AwaitFallback()
+            PlayAwarenessBarks()
+
+    PlayBark(Bark:audio_npc_bark, Guard:agent):void=
+        spawn {Bark.PlayBark(Guard)}
+
+    # Play a bark when reinforcement is called
+    AwaitReinforcements<private>()<suspends>:void=
+        AlertedGuard := StrongholdGameManager.ReinforcementsCalledEvent.Await()
+        PlayBark(BarkNeedBackup, AlertedGuard)
+
+    # Play a bark when guards regroup in the stronghold
+    AwaitFallback<private>()<suspends>:void=
+        StrongholdGameManager.FallbackEvent.Await()
+        if:
+            Guard := StrongholdGameManager.AlertedGuards[0]
+        then:
+            PlayBark(BarkFallback, Guard)
+
+    PlayAwarenessBarks<private>()<suspends>:void=
+        loop:
+            race:
+                PlayGuardsSuspiciousBark()
+                PlayPlayerSpottedBark()
+                PlayPlayerLostBark()
+                PlayGuardsUnawareBark()
+
+    PlayPlayerSpottedBark<private>()<suspends>:void=
+        Guard:=StrongholdGameManager.PlayerDetectedEvent.Await();
+        set HasLostTarget = false
+        PlayBark(BarkPlayerSpotted, Guard)
+
+    PlayPlayerLostBark<private>()<suspends>:void=
+        Guard:=StrongholdGameManager.PlayerLostEvent.Await();
+        set HasLostTarget = true
+        PlayBark(BarkPlayerLost, Guard)
+
+    PlayGuardsSuspiciousBark<private>()<suspends>:void=
+        Guard:=StrongholdGameManager.GuardsSuspiciousEvent.Await();
+        PlayBark(BarkGuardSuspicious, Guard)
+
+    PlayGuardsUnawareBark<private>()<suspends>:void=
+        Guard:=StrongholdGameManager.GuardsUnawareEvent.Await();
+        if (HasLostTarget?):
+            set HasLostTarget = false
+            if (not StrongholdGameManager.FallbackTriggered?):
+                PlayBark(BarkGuardUnaware, Guard)
+
+    SubscribeToGuardSpawnerEvents(GuardSpawnerDevice:guard_spawner_device):void = 
+        GuardSpawnerDevice.DamagedEvent.Subscribe(OnGuardDamaged)
+        GuardSpawnerDevice.EliminatedEvent.Subscribe(OnGuardEliminated)
+        GuardSpawnerDevice.EliminatingEvent.Subscribe(OnPlayerEliminated)
+            
+    # Configure all barks
+    ConfigureBarks():void=
+        
+        # Subscribe To Player Damage Event
+        AllPlayers := GetPlayspace().GetPlayers()
+        for (StrongholdPlayer : AllPlayers, StrongholdPC := StrongholdPlayer.GetFortCharacter[]):
+            StrongholdPC.DamagedEvent().Subscribe(OnPlayerDamaged)
+        
+        # Run through guards spawner list from stronghold manager and subscribe to all key events
+        for (GuardSpawner : StrongholdGameManager.GuardsInitialSpawners):
+            SubscribeToGuardSpawnerEvents(GuardSpawner)
+        for (GuardSpawner : StrongholdGameManager.GuardsReinforcementSpawners):
+            SubscribeToGuardSpawnerEvents(GuardSpawner)
+
+        # Have a separate case for when the reinforcements spawn
+        if:
+            FirstReinforcementSpawner := StrongholdGameManager.GuardsReinforcementSpawners[0]
+        then:
+            FirstReinforcementSpawner.SpawnedEvent.Subscribe(HandleReinforcementSpawned)
+        
+    # Guard is down, try to play a bark on the closest alerted guard
+    OnGuardEliminated(InteractionResult:device_ai_interaction_result):void=
+        if (EliminatedGuard := InteractionResult.Target?):
+
+            # Find closest alive guard to play this bark
+            var ClosestGuard:?agent = false
+            if:
+                set ClosestGuard = option{StrongholdGameManager.AlertedGuards[0]}
+                EliminatedGuardCharacter := EliminatedGuard.GetFortCharacter[]
+            then:
+                for (AlertedGuard : StrongholdGameManager.AlertedGuards, AlertedGuardCharacter := AlertedGuard.GetFortCharacter[]):
+                    if:
+                        not ClosestGuard? = AlertedGuard
+                        ClosestGuardCharacter := ClosestGuard?.GetFortCharacter[]
+                        DistanceSquaredToAlertedGuard := DistanceSquared(AlertedGuardCharacter.GetTransform().Translation, EliminatedGuardCharacter.GetTransform().Translation)
+                        DistanceSquaredToClosestGuard := DistanceSquared(ClosestGuardCharacter.GetTransform().Translation, EliminatedGuardCharacter.GetTransform().Translation)
+                        DistanceSquaredToAlertedGuard < DistanceSquaredToClosestGuard
+                    then:
+                        set ClosestGuard = option{AlertedGuard}
+
+            if (Guard := ClosestGuard?):
+                spawn {BarkNPCDown.PlayBark(Guard)}
+    
+    # Guard is hit, try to play a bark if the guard is not down              
+    OnGuardDamaged(InteractionResult:device_ai_interaction_result):void=
+        if (Guard := InteractionResult.Target?):
+            spawn {BarkDamageTaken.PlayBark(Guard)}
+
+    # Player is hit, try to play a bark on the guard that damaged the player   
+    OnPlayerDamaged(DamageResult:damage_result):void=
+        if:
+            fort_character[DamageResult.Target].GetHealth() > 0.0
+            Guard := DamageResult.Instigator?.GetInstigatorAgent[]
+        then:
+            spawn {BarkDamagePlayer.PlayBark(Guard)}
+
+    # Player is down, try to play a bark on the guard that eliminated the player   
+    OnPlayerEliminated(InteractionResult:device_ai_interaction_result):void=
+        if (Guard := InteractionResult.Source?):
+            spawn {BarkEliminatedPlayer.PlayBark(Guard)}
+
+    HandleReinforcementSpawned(Guard:agent):void=
+        spawn {BarkGoToLeash.PlayBark(Guard)}
+
+
+    

Code_Reference/Stronghold/verse/stronghold_billboard_cinematic.verse

@@ -0,0 +1,149 @@
+using { /Fortnite.com/Devices }
+using { /Fortnite.com/Characters }
+using { /Fortnite.com/FortPlayerUtilities }
+using { /Fortnite.com/UI }
+using { /Verse.org/Simulation }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /UnrealEngine.com/Temporary/SpatialMath}
+using { /UnrealEngine.com/Temporary/UI }
+
+# Script that sets the player into a cinematic mode so its not in the cinematic, and then resets them when the cinematic is done
+stronghold_billboard_cinematic := class(creative_device):
+
+    # A reference to the device that contains the level sequence to be played
+    @editable
+    CinematicSequenceDeviceToPlay:cinematic_sequence_device := cinematic_sequence_device{}
+
+    # A reference to the device that will hide the HUD
+    @editable
+    HudController:hud_controller_device := hud_controller_device{}
+
+    # Should the Skip Intro button be visible during the cinematic
+    @editable
+    ShowSkipIntroButton:logic := true
+
+    # Should Devices and Billboards be visible during the cinematic
+    @editable
+    ShowDevices:logic := true
+
+    # References to the billboard that will be visible during the cinematic
+    @editable
+    BillboardsToShow:[]billboard_device := array{}
+
+    # References to the devices that will be hidden after the cinematic
+    @editable
+    DevicesToHide:[]creative_device := array{}
+    @editable
+    RadiosToHide:[]radio_device := array{}
+    @editable
+    AudioPlayersToHide:[]audio_player_device := array{}
+
+    # Reference to Radio that plays music
+    @editable
+    Music:radio_device := radio_device{}
+
+    # Reference to the Game Manager to start gameplay after the cinematic
+    @editable
+    StrongholdGameManager:stronghold_game_manager := stronghold_game_manager{}
+
+    # A localizable message to display as text in the UI
+    SkipCinematicText<localizes> : message = "Skip intro"
+
+    var SkipButtonPerPlayer : [player]?canvas = map{}
+
+    # Runs at the beginning of the script.
+    OnBegin<override>()<suspends>:void=
+
+        # Handles when the cinematic sequence device finishes playing
+        CinematicSequenceDeviceToPlay.StoppedEvent.Subscribe(HandleCinematicEnd)
+
+        # Sets the player to invisible and removes their movement
+        CinematicStasis := stasis_args{AllowTurning := false, AllowFalling := false, AllowEmotes := false}
+
+        for (StrongholdPlayer : GetPlayspace().GetPlayers(), not StrongholdPlayer.IsSpectator[], PlayerCharacter:= StrongholdPlayer.GetFortCharacter[], PlayerUI := GetPlayerUI[StrongholdPlayer]):
+            PlayerCharacter.PutInStasis(CinematicStasis)
+            PlayerCharacter.Hide()
+
+            if (ShowSkipIntroButton?):
+                SkipButton := CreateSkipButton(PlayerUI)
+                option { set SkipButtonPerPlayer[StrongholdPlayer] = option{SkipButton} }
+
+        HudController.Enable()
+
+        if (ShowDevices?):
+            ShowBillboardsAndDevices()
+        else:
+            HideBillboardsAndDevices()
+
+        CinematicSequenceDeviceToPlay.Play()
+        Music.Play()
+        Log("Cinematic Mode Engaged - Players should be frozen and invisible")
+
+    # Sets the player back to visible and free to move
+    HandleCinematicEnd():void=
+
+        Music.Stop()
+
+        for (StrongholdPlayer : GetPlayspace().GetPlayers(), not StrongholdPlayer.IsSpectator[], PlayerCharacter:= StrongholdPlayer.GetFortCharacter[], PlayerUI := GetPlayerUI[StrongholdPlayer]):
+            PlayerCharacter.ReleaseFromStasis()
+            PlayerCharacter.Show()
+
+            if (SkipButtonUI := SkipButtonPerPlayer[StrongholdPlayer]?):
+                PlayerUI.RemoveWidget(SkipButtonUI)
+                option { set SkipButtonPerPlayer[StrongholdPlayer] = false }
+
+        HudController.Disable()
+
+        HideBillboardsAndDevices()
+
+        Log("Cinematic Mode Disengaged - Players should be free to move and visible.")
+
+        spawn{ StrongholdGameManager.StartGameplay() }
+
+    HandleSkipIntroInteraction(Message : widget_message) : void =
+
+        CinematicSequenceDeviceToPlay.Stop(Message.Player)
+
+    # A canvas widget that displays a Skip Button 
+    CreateSkipButton(PlayerUI:player_ui):canvas=
+
+        SkipButton :button_regular = button_regular{DefaultText := SkipCinematicText}
+        SkipButton.OnClick().Subscribe(HandleSkipIntroInteraction)
+        SkipButton.SetEnabled(true)
+
+        SkipButtonCanvas : canvas = canvas:
+            Slots := array:
+                canvas_slot:
+                    Anchors := anchors{Minimum := vector2{X := 0.9, Y := 0.9}, Maximum := vector2{X := 0.9, Y := 0.9}}
+                    Offsets := margin{Top := 0.0, Left := 0.0, Right := 0.0, Bottom := 0.0}
+                    Alignment := vector2{X := 1.0, Y := 1.0}
+                    SizeToContent := true
+                    Widget := SkipButton
+
+        PlayerUISlot:=player_ui_slot{ZOrder:=0, InputMode:=ui_input_mode.All}
+        PlayerUI.AddWidget(SkipButtonCanvas, PlayerUISlot)
+
+        return SkipButtonCanvas
+
+
+    ShowBillboardsAndDevices():void=
+        for (Billboard : BillboardsToShow):
+            Billboard.ShowText()
+            Show()
+        for (Device : DevicesToHide):
+            Device.Show()
+        for (Radio : RadiosToHide):
+            Radio.Show()
+        for (AudioPlayer : AudioPlayersToHide):
+            AudioPlayer.Show()
+
+    HideBillboardsAndDevices():void=
+        for (Billboard : BillboardsToShow):
+            Billboard.HideText()
+        Hide()
+        for (Device : DevicesToHide):
+            Device.Hide()
+        for (Radio : RadiosToHide):
+            Radio.Hide()
+        for (AudioPlayer : AudioPlayersToHide):
+            AudioPlayer.Hide()

Code_Reference/Stronghold/verse/stronghold_game_manager.verse

@@ -0,0 +1,359 @@
+using { /Fortnite.com/AI }
+using { /Fortnite.com/Characters }
+using { /Fortnite.com/Devices }
+using { /Fortnite.com/FortPlayerUtilities }
+using { /Fortnite.com/Game }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /UnrealEngine.com/Temporary/SpatialMath }
+using { /Verse.org/Simulation }
+using { /Verse.org/Verse }
+
+
+# The Stronghold is a game mode in which the goal is for players to eliminate all hostile enemies at a heavily guarded Stronghold
+# The Stronghold Game Manager Verse device is used to manage, monitor, and control the AIs at the Stronghold
+stronghold_game_manager := class(creative_device):
+    
+    # Device reference to guard spawner device to keep track of for eliminations
+    @editable
+    GuardsInitialSpawners:[]guard_spawner_device := array{}
+
+    # Device reference to guard spawner device to keep track of for eliminations for multiplayer scaling
+    @editable
+    GuardsInitialSpawnersAdditional:[]guard_spawner_device := array{}
+
+    # Device reference to reinforcement guard spawner device to trigger when one of the Stronghold guards is alerted
+    @editable
+    GuardsReinforcementSpawners:[]guard_spawner_device := array{}
+
+    # Device reference to reinforcement guard spawner device to trigger when one of the Stronghold guards is alerted for multiplayer scaling
+    @editable
+    GuardsReinforcementSpawnersAdditional:[]guard_spawner_device := array{}
+
+    # Device reference to display and track objectives
+    @editable
+    ObjectiveTracker:tracker_device := tracker_device{}
+
+    # Device reference to display reinforcement in-game message
+    @editable
+    MessageDeviceReinforcement:hud_message_device := hud_message_device{}
+
+    # Device reference to display fallback in-game message
+    @editable
+    MessageDeviceFallback:hud_message_device := hud_message_device{}
+
+    # Device reference to end the game with a victory if the players completed the Stronghold without being detected
+    @editable
+    EndGameVictoryDeviceUndetected:end_game_device := end_game_device{}
+
+    # Device reference to end the game with a victory if the players completed the Stronghold while being detected
+    @editable
+    EndGameVictoryDeviceDetected:end_game_device := end_game_device{}
+
+    # Device reference to end the game with a fail if the players ran out of retries
+    @editable
+    EndGameFailDevice:end_game_device := end_game_device{}
+
+    # Adjustable number of player lives
+    @editable
+    var PlayerRetries:int = 2
+
+    # Device to reference Stronghold leash position
+    @editable
+    ReinforcementLeashReference:stronghold_leash_position := stronghold_leash_position{}
+
+    # Device to reference Fallback leash position
+    @editable
+    FallbackLeashReference:stronghold_leash_position := stronghold_leash_position{}
+
+    # Leashes that must be disabled after fallback
+    @editable
+    LeashesToDisableForFallback:[]stronghold_leash_position := array{}
+
+    # Device for the explosion
+    @editable
+    ExplosiveDevice:explosive_device := explosive_device{}
+
+    # Guards perception is monitored by this script, the other scripts can subscribe to those events
+
+    # Event broadcasted when a guard call for reinforcement
+    ReinforcementsCalledEvent:event(agent) = event(agent){}
+
+    # Event broadcasted when guards defend the center of the Stronghold
+    FallbackEvent:event() = event(){}
+
+    # Event broadcasted when a guard becomes suspicious
+    GuardsSuspiciousEvent:event(agent) = event(agent){}
+
+    # Event broadcasted when all guards become unaware
+    GuardsUnawareEvent:event(agent) = event(agent){}
+
+    # Event broadcasted when a player is detected
+    PlayerDetectedEvent:event(agent) = event(agent){}
+
+    # Event broadcasted when all guards have lost their target
+    PlayerLostEvent:event(agent) = event(agent){}
+
+    # Lists of guards in a specific alert state to monitor perception changes
+
+    # Variable to store reinforcement guards
+    var<private> NumGuardsSpawned:int := 0
+
+    # Variable to store all Stronghold guards
+    var<private> StrongholdGuards:[]agent := array{}
+
+    # Variable to store reinforcement guards
+    var<private> ReinforcementGuards:[]agent := array{}
+
+    # List of guards currently suspicious
+    var<private> SuspiciousGuards : []agent = array{}
+
+    # List of guards currently alerted
+    var<private> AlertedGuards : []agent = array{}
+
+    # List of guards currently investigating
+    var<private> InvestigatingGuards : []agent = array{}
+
+    # Initial guard spawners, will include additional spawners with multiplayer session
+    var<private> GuardsInitialSpawnersInternal:[]guard_spawner_device = array{}
+
+    # Reinforcement guard spawners, will include additional spawners with multiplayer session
+    var<private> GuardsReinforcementSpawnersInternal:[]guard_spawner_device = array{}
+
+    # Gameplay logic variables
+
+    # Variable to track the number of eliminations from all Stronghold guard spawners
+    var<private> GuardsEliminated:int := 0
+
+    # Variable to track if the reinforcement were called or not
+    var<private> ReinforcementTriggered:logic := false
+
+    # Variable to track if the fallback was triggered
+    var<private> FallbackTriggered:logic := false
+
+    # Variable to store the first player agent that gets detected by the guards
+    var<private> DetectedPlayer:?player := false
+    
+
+    # Runs when the device is started in a running game.
+    OnBegin<override>()<suspends>:void=
+        Log("Stronghold verse manager is starting")
+
+        # Check active player for difficulty scaling
+        var NumberOfActivePlayers:int = 0
+        for (StrongholdPlayer : GetPlayspace().GetPlayers(), not StrongholdPlayer.IsSpectator[], StrongholdPC := StrongholdPlayer.GetFortCharacter[]):
+            set NumberOfActivePlayers += 1
+            # Subscribing to player elimination event
+            StrongholdPC.EliminatedEvent().Subscribe(OnPlayerEliminated)
+
+        Log("Game manager - Total player number is {NumberOfActivePlayers}")
+
+        set GuardsInitialSpawnersInternal = GuardsInitialSpawners
+        set GuardsReinforcementSpawnersInternal = GuardsReinforcementSpawners
+
+        # Add additional Guard Spawner when there is more than 2 players
+        if (NumberOfActivePlayers > 2):
+            set GuardsInitialSpawnersInternal += GuardsInitialSpawnersAdditional
+            set GuardsReinforcementSpawnersInternal += GuardsReinforcementSpawnersAdditional
+            
+        var NumInitialGuards:int = 0
+        for (GuardSpawner : GuardsInitialSpawnersInternal):
+            GuardSpawner.Enable()
+            SubscribeToGuardSpawnerEvents(GuardSpawner);
+            set NumInitialGuards += GuardSpawner.GetSpawnLimit()
+
+        ObjectiveTracker.SetTarget(NumInitialGuards)
+        
+        for (GuardReinforcementSpawner : GuardsReinforcementSpawnersInternal):
+            SubscribeToGuardSpawnerEvents(GuardReinforcementSpawner);
+
+            # Subscribing to reinforcement spawned event
+            GuardReinforcementSpawner.SpawnedEvent.Subscribe(OnReinforcementSpawned)
+            GuardReinforcementSpawner.AlertedEvent.Subscribe(OnReinforcementAlerted)
+            GuardReinforcementSpawner.UnawareEvent.Subscribe(OnReinforcementUnaware)
+
+    SubscribeToGuardSpawnerEvents(SpawnerDevice:guard_spawner_device):void = 
+        SpawnerDevice.SpawnedEvent.Subscribe(OnGuardSpawned)
+        SpawnerDevice.EliminatedEvent.Subscribe(OnGuardEliminated)
+        SpawnerDevice.SuspiciousEvent.Subscribe(OnGuardSuspicious)
+        SpawnerDevice.AlertedEvent.Subscribe(OnGuardAlerted)
+        SpawnerDevice.TargetLostEvent.Subscribe(OnGuardLostTarget)
+        SpawnerDevice.UnawareEvent.Subscribe(OnGuardUnaware)
+        
+    # Start tracking eliminated guards and trigger the explosion  
+    StartGameplay()<suspends>:void = 
+        ObjectiveTracker.AssignToAll()
+        Sleep(3.0)
+        if (FirstPlayer:=GetPlayspace().GetPlayers()[0]):
+            ExplosiveDevice.Explode(FirstPlayer)
+
+    # Runs when guard spawner receives an alerted event and considers only the first alert event
+    OnGuardAlerted(InteractionResult:device_ai_interaction_result):void=
+        if:
+            not ReinforcementTriggered?
+            set DetectedPlayer = option{player[InteractionResult.Target?]}
+            Guard:=InteractionResult.Source?
+        then:
+            Log("Game manager - Stronghold is alerted. Incoming reinforcement")
+
+            var NumGuards:int = ObjectiveTracker.GetTarget()
+
+            # Enabling the reinforcement guard spawner device ensures that we spawn the amount of guards configured in the guard spawner device.
+            for (GuardReinforcementSpawner : GuardsReinforcementSpawnersInternal):
+                GuardReinforcementSpawner.Enable()
+                set NumGuards += GuardReinforcementSpawner.GetSpawnLimit()
+    
+            ObjectiveTracker.SetTarget(NumGuards)
+
+            # Displaying in-game message for detection and incoming reinforcement
+            MessageDeviceReinforcement.Show()
+            set ReinforcementTriggered = true
+            # Signal Reinforcement event
+            ReinforcementsCalledEvent.Signal(Guard)
+       
+        # Add the guard to the list of alerted guards if it hasn't been previously added
+        if(Guard:=InteractionResult.Source?):
+            if (not AlertedGuards.Find[Guard]):
+                set AlertedGuards += array{Guard}
+
+            option {set SuspiciousGuards = SuspiciousGuards.RemoveFirstElement[Guard]}
+            option {set InvestigatingGuards = InvestigatingGuards.RemoveFirstElement[Guard]}
+        
+            # Broadcast the Player Detected Event when one guard is alerted
+            if (AlertedGuards.Length = 1):
+                PlayerDetectedEvent.Signal(Guard)
+
+    # Runs when reinforcement guard spawner receives an alerted event
+    OnReinforcementAlerted(InteractionResult:device_ai_interaction_result):void=      
+        if:
+            not FallbackTriggered?
+            Guard:=InteractionResult.Source?
+        then:
+            # Clear leash for reinforcement on alerted so they attack their target
+            ReinforcementLeashReference.ClearLeashOnGuard(Guard)
+            Log("Game manager - Reinforcement is alerted. Clear Leash.")
+
+    # Runs when reinforcement guard spawner receives an unaware event
+    OnReinforcementUnaware(Guard:agent):void=    
+        if (not FallbackTriggered?):
+            # Set back the leash
+            Log("Game manager - Reinforcement is unaware. Reset leash.")
+            ReinforcementLeashReference.ApplyLeashOnGuard(Guard)
+
+    # Runs when guard spawner receives an unaware event
+    OnGuardSuspicious(Guard:agent):void=
+        if (not SuspiciousGuards.Find[Guard]):
+            set SuspiciousGuards += array{Guard}
+
+            # Broadcast the Suspicious Event when one guard is suspicious
+            if:
+                SuspiciousGuards.Length = 1
+                AlertedGuards.Length = 0
+                InvestigatingGuards.Length = 0
+            then:
+                GuardsSuspiciousEvent.Signal(Guard)
+
+    # Runs when guard spawner receives an unaware event
+    OnGuardUnaware(Guard:agent):void=
+        option {set AlertedGuards = AlertedGuards.RemoveFirstElement[Guard]}
+        option {set SuspiciousGuards = SuspiciousGuards.RemoveFirstElement[Guard]}
+        option {set InvestigatingGuards = InvestigatingGuards.RemoveFirstElement[Guard]}
+
+        # Broadcast the Unaware Event when no guard is suspicious, alerted or investigating
+        if:
+            SuspiciousGuards.Length = 0
+            AlertedGuards.Length = 0
+            InvestigatingGuards.Length = 0
+        then:
+            GuardsUnawareEvent.Signal(Guard)  
+
+    # When a guard loses track of the player, remove it from the alerted guards list, when all guards have lost player, signal the event
+    OnGuardLostTarget(InteractionResult:device_ai_interaction_result):void=
+        if (Guard := InteractionResult.Source?):
+            if (not InvestigatingGuards.Find[Guard]):
+                set InvestigatingGuards += array{Guard}
+
+            # Broadcast the Player Lost Event when no guard is alerted                
+            if (set AlertedGuards = AlertedGuards.RemoveFirstElement[Guard]):
+                if (AlertedGuards.Length = 0):
+                    PlayerLostEvent.Signal(Guard)
+
+
+    # Runs when a reinforcement guard is spawned. Each reinforcement guard is forced to attack the player that alerted the Stronghold
+    OnReinforcementSpawned(Guard:agent):void=
+        set ReinforcementGuards += array{Guard}
+        ReinforcementLeashReference.ApplyLeashOnGuard(Guard)
+
+        # Assigns the player that alerted the Stronghold guards as the target
+        if (Target := DetectedPlayer?):
+            for (GuardReinforcementSpawner : GuardsReinforcementSpawnersInternal):
+                GuardReinforcementSpawner.ForceAttackTarget(Target, ?ForgetTime:=30.0)
+            Log("Game manager - ForceAttackTarget given to reinforcement guard")
+
+    
+    # Runs when any guard from the Stronghold is spawned
+    OnGuardSpawned(Guard:agent):void=
+        set StrongholdGuards += array{Guard}
+        set NumGuardsSpawned += 1
+    
+    # Runs when initial or reinforcement spawners receive an elimination
+    OnGuardEliminated(InteractionResult:device_ai_interaction_result):void=
+        set GuardsEliminated += 1
+        Log("Game manager - Stronghold guard eliminated count = {GuardsEliminated} / {NumGuardsSpawned}")
+
+        if (EliminatedAgent := InteractionResult.Target?):
+            # Remove eliminated guard from the alerted guards list
+            option {set AlertedGuards = AlertedGuards.RemoveFirstElement[EliminatedAgent]}
+            option {set SuspiciousGuards = SuspiciousGuards.RemoveFirstElement[EliminatedAgent]}
+            option {set InvestigatingGuards = InvestigatingGuards.RemoveFirstElement[EliminatedAgent]}
+            option {set StrongholdGuards = StrongholdGuards.RemoveFirstElement[EliminatedAgent]}
+        else:
+            Log("Game manager - No interaction target for elimination", ?Level:=log_level.Error)
+
+        if (EliminationAgent := InteractionResult.Source?):
+            OnGuardEliminatedByPlayer(EliminationAgent)
+        else:
+            Log("Game manager - No interaction source for elimination.", ?Level:=log_level.Error)
+
+    OnGuardEliminatedByPlayer(EliminationPlayer:agent):void=
+
+        # Increasing progress value for tracker device for each elimination
+        ObjectiveTracker.Increment(EliminationPlayer)
+
+        if (ReinforcementTriggered?):
+
+            if (NumGuardsSpawned - GuardsEliminated = 3):
+                StartFallback()
+                
+            # Ends the game mode if all guards were eliminated without the reinforcements
+            if (GuardsEliminated >= NumGuardsSpawned):
+                EndGameVictoryDeviceDetected.Activate(EliminationPlayer)
+                Log("Game manager - Completed Stronghold detected")
+        else:
+            # Ends the game mode if all guards were eliminated with the reinforcements
+            if (GuardsEliminated >= NumGuardsSpawned):
+                EndGameVictoryDeviceUndetected.Activate(EliminationPlayer)
+                Log("Game manager - Completed Stronghold undetected")
+
+    # Assigns a new fallback leash when a few alerted guards are remaining to defend the center of the Stronghold
+    StartFallback():void=
+        # Displaying in-game message for guards retreating inside the Stronghold building
+        MessageDeviceFallback.Show()
+        set FallbackTriggered = true
+
+        for (LeashDevice : LeashesToDisableForFallback):  
+            LeashDevice.DisableLeashAndPatrolPaths()
+
+        FallbackLeashPosition := FallbackLeashReference.GetTransform().Translation
+        FallbackEvent.Signal()
+        for (Guard : StrongholdGuards):  
+            FallbackLeashReference.ApplyLeashOnGuard(Guard)
+        Log("Game manager - Fallback leash is assigned")
+    
+        
+    # Runs when a player elimination event is received
+    OnPlayerEliminated(EliminationResult:elimination_result):void=
+        set PlayerRetries -= 1
+        if (PlayerRetries = 0, Agent := EliminationResult.EliminatedCharacter.GetAgent[]):
+            EndGameFailDevice.Activate(Agent)
+            Log("Game manager - Player was eliminated")
+

Code_Reference/Stronghold/verse/stronghold_intro_explosion.verse

@@ -0,0 +1,108 @@
+using { /Fortnite.com/AI }
+using { /Fortnite.com/Characters }
+using { /Fortnite.com/Devices }
+using { /Verse.org/Random }
+using { /Verse.org/Simulation }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /UnrealEngine.com/Temporary/SpatialMath }
+
+# Script that handles the explosion sequence
+stronghold_intro_explosion := class(creative_device):
+
+    @editable
+    StrongholdGameManager:stronghold_game_manager := stronghold_game_manager{}
+
+    # Device for guard spawner who goes to investigate the explosion outside of the base
+    @editable
+    GuardsInvestigateSpawner:guard_spawner_device := guard_spawner_device{}
+
+    # Device for the explosion
+    @editable
+    ExplosiveDevice:explosive_device := explosive_device{}
+
+    # Device for the fire volume around the vehicle
+    @editable
+    FireVolumeAroundVehicle:fire_volume_device := fire_volume_device{}
+
+    # Device for the damage volume around the vehicle
+    @editable
+    DamageVolumeAroundVehicle:damage_volume_device := damage_volume_device{}
+    
+    # Device for the vehicle explosion
+    @editable
+    VehicleSpawnerIntroExplosion:vehicle_spawner_big_rig_device := vehicle_spawner_big_rig_device{}
+
+    # Bark to play when the investigation start
+    @editable
+    AudioPlayerInvestigateBark:audio_player_device := audio_player_device{}
+
+    # A reference to the device that contains the level sequence to be played
+    @editable
+    CinematicSequenceDeviceToPlay:cinematic_sequence_device := cinematic_sequence_device{}
+
+    StartDamageVolume<private>()<suspends>:void=
+
+        VehicleSpawnerIntroExplosion.VehicleSpawnedEvent.Await()
+        Log("Intro Sequence - Enable Damage Volume")
+        DamageVolumeAroundVehicle.Enable()
+        ExplosiveDevice.ExplodedEvent.Await()
+        Log("Intro Sequence - Start post-explosion")
+        DamageVolumeAroundVehicle.Disable()
+        FireVolumeAroundVehicle.Ignite()
+        CinematicSequenceDeviceToPlay.Play()
+        Log("Intro Sequence - Damage Volume Disabled")
+
+    # Runs when the device is started in a running game
+    OnBegin<override>()<suspends>:void=
+
+        spawn{ StartDamageVolume() }
+
+        Log("Intro Sequence - Waiting for Guard to Spawn")
+        GuardToGoInvestigate:=GuardsInvestigateSpawner.SpawnedEvent.Await()
+
+        race:
+            # stop the intro if guard is alerted
+            block:
+                GuardsInvestigateSpawner.AlertedEvent.Await()
+                Log("Intro Sequence - Guard Alerted")
+                return
+
+            # stop the intro if guard is eliminated
+            block:
+                GuardsInvestigateSpawner.EliminatedEvent.Await()
+                Log("Intro Sequence - Guard Eliminated")
+                return
+
+            block:
+
+                if:
+                    Navigatable:=GuardToGoInvestigate.GetFortCharacter[].GetNavigatable[]
+                    FocusInterface:=GuardToGoInvestigate.GetFortCharacter[].GetFocusInterface[]
+                then:
+                    Log("Intro Sequence - Guard Spawned - Waiting for explosion")
+                    race:
+                        ExplosiveDevice.ExplodedEvent.Await()
+                        Navigatable.Wait()
+
+                    Navigatable.Wait(?Duration:=3.0)
+                    AudioPlayerInvestigateBark.Play(GuardToGoInvestigate)
+
+                    Log("Intro Sequence - Investigate Bark Played - Setting NavTarget")
+                    Navigatable.Wait(?Duration:=2.0)
+                    Log("Intro Sequence - Walking to Explosion")
+                    InvestigatePosition:= MakeNavigationTarget(Self.GetTransform().Translation)
+                    Navigatable.NavigateTo(InvestigatePosition,?AllowPartialPath:=true, ?ReachRadius:=100.0)
+
+                    race:
+                        Sleep(6.0)
+                        loop:
+                            RandomOffset := vector3{ X:=GetRandomFloat(-1000.0, 1000.0), Y:=GetRandomFloat(-1000.0, 1000.0), Z:=GetRandomFloat(50.0, 200.0)}
+                            race:
+                                FocusInterface.MaintainFocus(Self.GetTransform().Translation + RandomOffset)
+                                Sleep(GetRandomFloat(0.5, 1.5))
+
+                else:
+                    Log("Intro Sequence - No navigation interface", ?Level:=log_level.Error)
+
+
+    

Code_Reference/Stronghold/verse/stronghold_leash_position.verse

@@ -0,0 +1,85 @@
+using { /Fortnite.com/AI }
+using { /Fortnite.com/Characters }
+using { /Fortnite.com/Devices }
+using { /UnrealEngine.com/Temporary/Diagnostics }
+using { /UnrealEngine.com/Temporary/SpatialMath }
+using { /Verse.org/Colors }
+using { /Verse.org/Random }
+using { /Verse.org/Simulation }
+
+# Defines a leash volume that can be assigned to guards
+stronghold_leash_position := class(creative_device):
+
+    # Leash is applied by default to all guards spawned by those devices
+    @editable
+    GuardsSpawners:[]guard_spawner_device := array{}
+
+    # Guards on those patrol paths can go outside the leash (only one device per path)
+    @editable
+    PatrolPaths:[]ai_patrol_path_device := array{}
+
+    # Set the leash inner radius. This value must be in centimeters. 
+    # This defines the volume that must be reached when this leash is assigned to guards
+    @editable 
+    LeashInnerRadius<private>:float = 2300.0
+
+    # Set the leash outer radius. This value must be in centimeters
+    # This defines the volume in which guards must stay in when this leash is assigned
+    @editable
+    LeashOuterRadius<private>:float = 2400.0
+
+    # List of guards currently assigned to this leash
+    var<private> Guards : []agent = array{}
+
+    OnBegin<override>()<suspends>:void=
+        DebugDraw : debug_draw = debug_draw{}
+        DebugDraw.DrawCylinder(GetTransform().Translation, GetTransform().Translation + vector3{X:=0.0, Y:=0.0, Z:=500.0}, ?NumSegments:=64, ?Radius:= LeashInnerRadius, ?Color:=NamedColors.LightGreen, ?DrawDurationPolicy:=debug_draw_duration_policy.Persistent, ?Thickness:= 3.0)
+        DebugDraw.DrawCylinder(GetTransform().Translation, GetTransform().Translation + vector3{X:=0.0, Y:=0.0, Z:=500.0}, ?NumSegments:=64, ?Radius:= LeashOuterRadius, ?Color:=NamedColors.Orange, ?DrawDurationPolicy:=debug_draw_duration_policy.Persistent, ?Thickness:= 3.0)
+
+        for (GuardSpawner : GuardsSpawners):
+            GuardSpawner.SpawnedEvent.Subscribe(ApplyLeashOnGuard)
+
+        for (PatrolPath : PatrolPaths):
+            PatrolPath.PatrolPathStartedEvent.Subscribe(PatrolPathStarted)
+            PatrolPath.PatrolPathStoppedEvent.Subscribe(PatrolPathStopped)
+
+    ApplyLeashOnGuard(Guard:agent):void=
+        Log("Leash position - Applying leash {LeashInnerRadius} / {LeashOuterRadius} on guard")
+        if (Leashable:=Guard.GetFortCharacter[].GetFortLeashable[]):
+            Leashable.SetLeashPosition(GetTransform().Translation, LeashInnerRadius, LeashOuterRadius)
+    
+            set Guards += array{Guard}
+
+    ClearLeashOnGuard(Guard:agent):void=
+        Log("Leash position - Clearing leash {LeashInnerRadius} / {LeashOuterRadius} on guard")
+        if (Leashable:=Guard.GetFortCharacter[].GetFortLeashable[]):
+            Leashable.ClearLeash()
+        
+        option {set Guards = Guards.RemoveFirstElement[Guard]}
+
+    DisableLeashAndPatrolPaths():void=
+        Log("Leash position - Disabling leash {LeashInnerRadius} / {LeashOuterRadius}")
+        for (Guard : Guards):
+            if (Leashable:=Guard.GetFortCharacter[].GetFortLeashable[]):
+                Leashable.ClearLeash()
+
+        for (PatrolPath : PatrolPaths):
+            PatrolPath.Disable()
+        
+        set Guards = array{}
+
+    PatrolPathStarted(Guard:agent):void=
+        if:
+            Guards.Find[Guard]
+            Leashable:=Guard.GetFortCharacter[].GetFortLeashable[]
+        then:
+            Log("Leash position - Patrol started - Clearing leash {LeashInnerRadius} / {LeashOuterRadius} on guard")
+            Leashable.ClearLeash()
+
+    PatrolPathStopped(Guard:agent):void=
+        if:
+            Guards.Find[Guard]
+            Leashable:=Guard.GetFortCharacter[].GetFortLeashable[]
+        then:
+            Log("Leash position - Patrol stopped - Setting leash {LeashInnerRadius} / {LeashOuterRadius} on guard")
+            Leashable.SetLeashPosition(GetTransform().Translation, LeashInnerRadius, LeashOuterRadius)

Code_Reference/Stronghold/verse/stronghold_log.verse

@@ -0,0 +1,12 @@
+using { /UnrealEngine.com/Temporary/Diagnostics }
+
+# Logger for the Stronghold experience. This log channel prints the Stronghold game's progression to the output log of UEFN.
+
+stronghold_log_channel := class(log_channel){}
+
+Log<internal>(Text:string, ?Level:log_level=log_level.Debug):void=
+
+    Logger:log = log{Channel:=stronghold_log_channel}
+    Logger.Print(Text, ?Level:=Level)
+
+