Domination again... this time for real

Code_Reference/Domination/CineLobbyController.verse

@@ -0,0 +1,20 @@
+# Copyright Epic Games, Inc. All Rights Reserved.
+
+using { /Fortnite.com/Devices }
+using { /Verse.org/Simulation }
+
+##################################################################
+# Our game features a looping cinematic in the pregame.  This class simply tells that cinematic to stop!
+# The second cleanup cinematic resets all the material parameters
+##################################################################
+cinematic_lobby_controller := class(creative_device):
+
+    @editable
+    CineLobby_Sequence:cinematic_sequence_device := cinematic_sequence_device{}
+    @editable
+    CineLobby_Cleanup_Sequence:cinematic_sequence_device := cinematic_sequence_device{}
+
+
+    OnBegin<override>()<suspends>:void=
+        CineLobby_Sequence.Stop()
+        CineLobby_Cleanup_Sequence.Play()

Code_Reference/Domination/DominationSpawnManager.verse

@@ -0,0 +1,147 @@
+# Copyright Epic Games, Inc. All Rights Reserved.
+
+using { /Fortnite.com/Devices }
+using { /Fortnite.com/Teams }
+using { /Verse.org/Simulation }
+using { /Verse.org/Simulation/Tags }
+
+## This device manages the player spawners
+## An intial set of spawners starts enabled
+## After a short time, the initial spawners are disabled
+## From there, team spawns associated with each capture point are enabled/disabled based off a weighting score
+##     Owning the point adds 1 to the weighting score (or -1 if team 2)
+##     Each ally in the area adds 1 to the weighting score (or -1 if team 2)
+##     If the weighting score is > 0, team 1 can spawn near the point.  
+##     If the weighting score is < 0, team 2 can spawn near the point
+
+##################################################################
+## Event Handler Class - We'll spawn one of these per capture point and bind events through it
+##################################################################
+capture_point_event_handler := class:
+
+    CapturePointIndex:int
+    DominationSpawnManagerRef:domination_spawn_manager
+    TeamCollectionRef:fort_team_collection
+
+    var CaptureWeightOfThisPoint:int = 0
+    var PlayerWeightOfThisPoint:float = 0.0
+    WeightForEachPlayer:float = 0.5
+
+    # If Team 1, we return 1.  If Team 2, we return -1.
+    GetTeamDirectionOfAgent<private>(MyAgent:agent)<transacts>:int=
+        if (FirstTeam := TeamCollectionRef.GetTeams()[0]):
+            if (TeamCollectionRef.IsOnTeam[MyAgent, FirstTeam]):
+                return 1
+        return -1
+    
+    # Set state of capture point
+    OnCaptured(MyAgent:agent):void=
+        set CaptureWeightOfThisPoint = GetTeamDirectionOfAgent(MyAgent)
+        DominationSpawnManagerRef.CalculateWeightForPoint(CapturePointIndex)
+
+    # Shift player weighting of point as players enter or leave
+    PlayerEnteredLargeZone(MyAgent:agent):void=
+        set PlayerWeightOfThisPoint = PlayerWeightOfThisPoint + (GetTeamDirectionOfAgent(MyAgent) * WeightForEachPlayer)
+        DominationSpawnManagerRef.CalculateWeightForPoint(CapturePointIndex)
+    PlayerLeftLargeZone(MyAgent:agent):void=
+        set PlayerWeightOfThisPoint = PlayerWeightOfThisPoint - (GetTeamDirectionOfAgent(MyAgent) * WeightForEachPlayer)
+        DominationSpawnManagerRef.CalculateWeightForPoint(CapturePointIndex)
+    
+
+##################################################################
+## Domination Spawn Manager Class
+##################################################################
+domination_spawn_manager := class(creative_device):
+
+    # Player Spawner Device Groups - Populated by searching for Verse tags
+    var SpawnPointGroupInitial:[]player_spawner_device = array{}
+    var SpawnPointGroupsCapPoint:[][]player_spawner_device = array{array{}, array{}, array{}}
+
+    # Capture Zone
+    @editable  
+    CapturePoints:[]capture_area_device = array{}
+    @editable  
+    LargeZones:[]player_counter_device = array{}
+
+    # Initial Spawners will disable after this many seconds
+    InitialGroupDisableTime:float = 5.0
+
+    # Cap Point Event Handler Class Refs
+    var CapturePointListeners:[]capture_point_event_handler = array{} 
+
+
+    # OnBegin will run when the game starts
+    OnBegin<override>()<suspends>:void=
+        BeginPlayEventSubscriptions()
+        FindAndCacheSpawnDevices()
+        DisableInitialSpawnGroup()
+        
+
+    # Subscribe to events from our attribute triggers
+    BeginPlayEventSubscriptions<private>():void=
+        for (I -> EachCapPoint:CapturePoints):
+            MyHandler := capture_point_event_handler:
+                CapturePointIndex := I
+                DominationSpawnManagerRef := Self
+                TeamCollectionRef := Self.GetPlayspace().GetTeamCollection()
+
+            set CapturePointListeners = CapturePointListeners + array{MyHandler}
+            
+            EachCapPoint.ControlChangeEvent.Subscribe(MyHandler.OnCaptured)
+
+            if (EachLargeZone := LargeZones[I]):
+                EachLargeZone.CountedEvent.Subscribe(MyHandler.PlayerEnteredLargeZone)
+                EachLargeZone.RemovedEvent.Subscribe(MyHandler.PlayerLeftLargeZone)
+
+
+    # Get all our various Player Spawner devices, and store them in the appropriate arrays
+    FindAndCacheSpawnDevices<private>():void=
+        InitialSpawnPoints:[]creative_object_interface = GetCreativeObjectsWithTag(DominationSpawnTags.Tag_SpawnGroup_Initial{})
+        for (FoundDevice : InitialSpawnPoints, DeviceAsSpawner:= player_spawner_device[FoundDevice]):
+            set SpawnPointGroupInitial = SpawnPointGroupInitial + array{DeviceAsSpawner}
+
+        GroupTags:[]tag = array:
+            DominationSpawnTags.Tag_SpawnGroup_GroupA{}
+            DominationSpawnTags.Tag_SpawnGroup_GroupB{}
+            DominationSpawnTags.Tag_SpawnGroup_GroupC{}
+
+        for (I -> GroupTag:GroupTags): 
+            FoundSpawnGroup:[]creative_object_interface := GetCreativeObjectsWithTag(GroupTag)
+            for (FoundDevice : FoundSpawnGroup, DeviceAsSpawner:= player_spawner_device[FoundDevice]):
+                if:
+                    set SpawnPointGroupsCapPoint[I] = SpawnPointGroupsCapPoint[I] + array{DeviceAsSpawner}
+            
+
+    # Turn off initial spawn points     
+    DisableInitialSpawnGroup<private>()<suspends>:void=
+        Sleep(InitialGroupDisableTime)
+        for (SpawnPoint : SpawnPointGroupInitial):
+            SpawnPoint.Disable()
+        
+
+    # Whenever the CapPointCaptureWeight or CapPointPlayerWeight for a point changes, this runs to see who should be allowed to spawn from the associated spawn group
+    CalculateWeightForPoint(PointIndex:int):void=
+        var WeightOfPoint:int = 0
+
+        if:
+            CapPointData := CapturePointListeners[PointIndex]
+            CapPlayerWeightToInt := Floor[CapPointData.PlayerWeightOfThisPoint]
+        then:
+            set WeightOfPoint = CapPointData.CaptureWeightOfThisPoint + CapPlayerWeightToInt
+        
+        for (SpawnDevice:SpawnPointGroupsCapPoint[PointIndex]):
+            var DeviceIsTeam1:logic = false
+            DeviceTags := SpawnDevice.GetTags()
+            if (DeviceTags.Has[DominationSpawnTags.Tag_TeamOwnership_Team1{}]):
+                set DeviceIsTeam1 = true
+            
+            if (DeviceIsTeam1?):
+                if (WeightOfPoint > 0):
+                    SpawnDevice.Enable()
+                else:
+                    SpawnDevice.Disable()
+            else:
+                if (WeightOfPoint < 0):
+                    SpawnDevice.Enable()
+                else:
+                    SpawnDevice.Disable()

Code_Reference/Domination/DominationVOController.verse

@@ -0,0 +1,272 @@
+# Copyright Epic Games, Inc. All Rights Reserved.
+
+using { /Fortnite.com/Devices }
+using { /Fortnite.com/Teams }
+using { /Verse.org/Simulation }
+
+
+##################################################################
+## Event Handler Class - We'll spawn one of these per capture point and bind events through it
+##################################################################
+vo_cappoint_event_handler := class:
+    CapturePointIndex:int
+    VOControlRef:domination_vo_controller
+
+    # Only play losing control audio if the point has been captured.  Otherwise you get 'losing control' vo for neutral points at the start of game.
+    var HasBeenCaptured:logic = false
+
+    OnCaptured(MyAgent:agent):void=
+        VOControlRef.UpdateCapturePointTracking(MyAgent, CapturePointIndex)
+        VOControlRef.QueueVO_PointCapturedOrLost(MyAgent, CapturePointIndex)
+
+        set HasBeenCaptured = true
+
+    OnStartedCapture(MyAgent:agent):void=
+        if (HasBeenCaptured?):
+            VOControlRef.QueueVO_PointCaptureStarted(MyAgent, CapturePointIndex)     
+
+
+##################################################################
+## VO Controller Device Class
+##################################################################   
+
+audioqueue_type := enum:
+    CaptureStarted
+    CaptureOrLost
+    AllPointsCaptured
+
+audioqueue_entry:= struct:
+    InitiatingAgent:agent
+    CapturePointID:int
+    AudioEventType:audioqueue_type
+
+domination_vo_controller := class(creative_device):
+
+    # Capture Zone
+    @editable  
+    CapturePoints:[]capture_area_device = array{}
+
+    # Audio Players
+    @editable
+    VO_PointCaptured:[]audio_player_device = array{}
+    @editable
+    VO_PointLost_A:[]audio_player_device = array{}
+    @editable
+    VO_PointLost_B:[]audio_player_device = array{}
+    @editable
+    VO_PointLost_C:[]audio_player_device = array{}
+
+    @editable
+    VO_PointStartedLosing_A:[]audio_player_device = array{}
+    @editable
+    VO_PointStartedLosing_B:[]audio_player_device = array{}
+    @editable
+    VO_PointStartedLosing_C:[]audio_player_device = array{}
+
+    @editable
+    VO_SelectLoadout:audio_player_device = audio_player_device{}
+
+    @editable
+    FriendlyTeamIsDominating:[]audio_player_device = array{}
+    @editable
+    EnemyTeamIsDominating:[]audio_player_device = array{}
+
+    # Hud Messages
+    @editable
+    HUDMessage_PointCaptured:[]hud_message_device = array{}
+    @editable
+    HUDMessage_PointLost:[]hud_message_device = array{}
+    @editable
+    HUDMessage_LosingPoint:[]hud_message_device = array{}
+
+    # Cycle Audio Clips to avoid repeats
+    var AudioIndex_CapOrLost:int = 0
+    var AudioIndex_Losing:int = 0
+
+    # Domination State
+    var CapturePointOwnership:[]int = array{0,0,0}
+    var AnyTeamIsDominating:logic = false
+
+    # VO Play Cooldown
+    VOCooldownTime:float = 2.0
+    var VOIsOnCooldown:logic = false
+
+    # Audio queue for important messages
+    var AudioToPlayQueue:[]audioqueue_entry = array{}
+
+    # Class Selector Device Ref
+    @editable
+    ClassSelectUI:class_selector_ui_device = class_selector_ui_device{}
+    @editable
+    ClassSelectOpenedRouter:attribute_evaluator_device = attribute_evaluator_device{}
+    var ValidAudioTargets:[]agent = array{}
+    var ValidClassSelectAudioTargets:[]agent = array{}
+
+
+    @editable
+    GameIntroHUDMessage:hud_message_device = hud_message_device{}
+
+
+    # Cache Listener Classes to Prevent GC - In the future you won't need to do this!
+    var CachedListeners:[]vo_cappoint_event_handler = array{} 
+
+
+    OnBegin<override>()<suspends>:void=
+        # Create an event handler class for each capture point, and subscribe
+        for (I->EachCapPoint : CapturePoints):
+            MyHandler := vo_cappoint_event_handler:
+                CapturePointIndex := I
+                VOControlRef := Self
+            EachCapPoint.ControlChangeEvent.Subscribe(MyHandler.OnCaptured)
+            EachCapPoint.ControlChangeStartsEvent.Subscribe(MyHandler.OnStartedCapture)
+            set CachedListeners = CachedListeners + array{MyHandler}
+
+        # Player spawned in world event (we don't play audio until the player has spawned once and heard the intro VO)
+        ClassSelectUI.ClassSelectedEvent.Subscribe(PlayerSpawnedIntoWorld)
+        # Player entered class UI
+        ClassSelectOpenedRouter.PassEvent.Subscribe(ClassSelectUIOpen)
+
+
+    ClassSelectUIOpen <private>(MyAgent:agent):void=
+        if (not ValidClassSelectAudioTargets.Find[MyAgent]):
+            set ValidClassSelectAudioTargets = ValidClassSelectAudioTargets + array{MyAgent}
+            VO_SelectLoadout.Play(MyAgent)
+        
+
+    PlayerSpawnedIntoWorld<private>(MyAgent:agent):void=
+        if (not ValidAudioTargets.Find[MyAgent]):
+            spawn{AddPlayerToValidAudioTargets(MyAgent)}
+
+
+    AddPlayerToValidAudioTargets<private>(MyAgent:agent)<suspends>:void=
+        # After a delay to account for initial class popup, permit audio
+        Sleep(0.5)
+        GameIntroHUDMessage.Show(MyAgent)
+        Sleep(2.0)
+        if (not ValidAudioTargets.Find[MyAgent]):
+            set ValidAudioTargets = ValidAudioTargets + array{MyAgent}
+
+
+    UpdateCapturePointTracking(MyAgent:agent, CapturePointID:int):void=
+        TeamCollection := GetPlayspace().GetTeamCollection()
+        if:
+            Team1 := TeamCollection.GetTeams()[0]
+            TeamCollection.IsOnTeam[MyAgent, Team1]
+            set CapturePointOwnership[CapturePointID]=1
+        else if:
+            set CapturePointOwnership[CapturePointID]=-1
+
+        if (Abs(CapturePointOwnership[0] + CapturePointOwnership[1] + CapturePointOwnership[2]) = 3):
+            set AnyTeamIsDominating = true
+        else:
+            set AnyTeamIsDominating = false
+        
+
+    ##################################################################
+    # Play VO Methods
+    # These should not be used directly. Instead use the Audio Queue
+    ##################################################################
+    PlayVO_PointCapturedOrLost<private>(MyAgent:agent, CapturePointID:int, SkipDominationCheck:logic):void=
+        # Increment VO Index
+        set AudioIndex_CapOrLost = AudioIndex_CapOrLost + 1
+        
+        # For each player in the game, play the appropriate audio & associated HUD message
+        TeamCollection := GetPlayspace().GetTeamCollection()
+        for (EachPlayer : GetPlayspace().GetPlayers()):
+            if (TeamCollection.GetTeamAttitude[MyAgent, EachPlayer] = team_attitude.Friendly):
+                HUDMessageToShow:?hud_message_device = option{ HUDMessage_PointCaptured[CapturePointID] }
+
+                if (AnyTeamIsDominating? and not SkipDominationCheck?):
+                    PlayVOForPlayer(EachPlayer, FriendlyTeamIsDominating, AudioIndex_CapOrLost, HUDMessageToShow)
+                else:
+                    PlayVOForPlayer(EachPlayer, VO_PointCaptured, AudioIndex_CapOrLost, HUDMessageToShow)
+
+            else:
+                HUDMessageToShow:?hud_message_device = option{ HUDMessage_PointLost[CapturePointID] }
+
+                if (AnyTeamIsDominating? and not SkipDominationCheck?):
+                    PlayVOForPlayer(EachPlayer, EnemyTeamIsDominating, AudioIndex_CapOrLost, HUDMessageToShow)
+                else:
+                    VOPointLostArray := array{VO_PointLost_A, VO_PointLost_B, VO_PointLost_C}
+                    if (VOToPlay := VOPointLostArray[CapturePointID]):
+                        PlayVOForPlayer(EachPlayer, VOToPlay, AudioIndex_CapOrLost, HUDMessageToShow)
+    
+
+    PlayPointCaptureStartedVO<private>(MyAgent:agent, CapturePointID:int):void=
+        # Increment VO Index
+        set AudioIndex_Losing = AudioIndex_Losing + 1
+        
+        # For each enemy (we don't tell friendlies capture has tarted), play VO and associated hud message
+        TeamCollection := GetPlayspace().GetTeamCollection()
+        for (EachPlayer : GetPlayspace().GetPlayers()):
+            if (TeamCollection.GetTeamAttitude[MyAgent, EachPlayer] <> team_attitude.Friendly):
+                HUDMessageToShow:?hud_message_device = option{ HUDMessage_LosingPoint[CapturePointID] }
+
+                VOPointLostArray := array{VO_PointStartedLosing_A, VO_PointStartedLosing_B, VO_PointStartedLosing_C}
+                if (VOToPlay := VOPointLostArray[CapturePointID]):
+                    PlayVOForPlayer(EachPlayer, VOToPlay, AudioIndex_Losing, HUDMessageToShow)
+
+
+    PlayVOForPlayer<private>(MyAgent:agent, DeviceList:[]audio_player_device, ClipIndex:int, OptionalHUDMessage:?hud_message_device):void=
+        # Make sure the incoming device list is populated!
+        if (DeviceList.Length = 0):
+            return
+        # Is player a valid audio target?
+        if (not ValidAudioTargets.Find[MyAgent]):
+            return
+
+        if (Device := DeviceList[Mod[ClipIndex, DeviceList.Length]]):
+            Device.Play(MyAgent)
+        if (HUDMessage := OptionalHUDMessage?):
+            HUDMessage.Show(MyAgent)
+
+
+    ##################################################################
+    # Audio Queue Management
+    ##################################################################
+    QueueVO_PointCapturedOrLost(MyAgent:agent, CapturePointID:int):void=
+        if (AnyTeamIsDominating?):
+            EnqueueAudioEntry(MyAgent, CapturePointID, audioqueue_type.AllPointsCaptured)
+        else:
+            EnqueueAudioEntry(MyAgent, CapturePointID, audioqueue_type.CaptureOrLost)
+
+
+    QueueVO_PointCaptureStarted(MyAgent:agent, CapturePointID:int):void=
+        # Only add these to the queue if they're the only audio to play.
+        # They aren't important enough to queue up compared to other audio sources.
+        if (AudioToPlayQueue.Length = 0):
+            EnqueueAudioEntry(MyAgent, CapturePointID, audioqueue_type.CaptureStarted)
+
+
+    EnqueueAudioEntry<private>(MyAgent:agent, CaptureID:int, AudioType:audioqueue_type):void=
+        set AudioToPlayQueue = AudioToPlayQueue + array:
+            audioqueue_entry{InitiatingAgent := MyAgent, CapturePointID := CaptureID, AudioEventType := AudioType}
+
+        spawn { PlayQueuedVO() }
+
+
+    PlayQueuedVO<private>()<suspends>:void =
+        if (VOIsOnCooldown?):
+            return
+
+        set VOIsOnCooldown = true
+
+        loop: 
+            if:
+                NextAudioToPlay := AudioToPlayQueue[0]
+                set AudioToPlayQueue = AudioToPlayQueue.RemoveElement[0]
+            then:
+                case (NextAudioToPlay.AudioEventType):
+                    audioqueue_type.CaptureStarted =>
+                        PlayPointCaptureStartedVO(NextAudioToPlay.InitiatingAgent, NextAudioToPlay.CapturePointID)
+                    audioqueue_type.CaptureOrLost =>
+                        PlayVO_PointCapturedOrLost(NextAudioToPlay.InitiatingAgent, NextAudioToPlay.CapturePointID, true)
+                    audioqueue_type.AllPointsCaptured =>
+                        PlayVO_PointCapturedOrLost(NextAudioToPlay.InitiatingAgent, NextAudioToPlay.CapturePointID, false)
+
+                # Sleep between each play
+                Sleep(VOCooldownTime)
+            else:
+                break
+
+        set VOIsOnCooldown = false

Code_Reference/Domination/SequencerRandomizer.verse

@@ -0,0 +1,51 @@
+# Copyright Epic Games, Inc. All Rights Reserved.
+
+using { /Fortnite.com/Devices }
+using { /Verse.org/Random }
+using { /Verse.org/Simulation }
+
+################################################################################
+## This device references an array of Cinematic Sequence Devices, and plays them randomly with a variable cooldown in between.
+################################################################################
+sequencer_randomization_device := class<concrete>(creative_device):
+
+    # Array of Cinematic Sequence Devices to randomize between
+    @editable   
+    SequencerList : []cinematic_sequence_device = array{}
+
+    # Minimum / Maximum time to wait before triggering another sequence
+    @editable   
+    CooldownMin:float = 120.0
+    @editable   
+    CooldownMax:float = 240.0
+
+    # If we have more than 1 sequence to choose from, should we prevent the same sequence playing two times in a row?
+    @editable   
+    PreventBackToBackRepeats:logic = true 
+
+
+    # OnBegin will run when the game starts
+    OnBegin<override>()<suspends>:void=
+        if (SequencerList.Length > 0):
+            QueueSequence(GetRandomInt(0, SequencerList.Length-1))
+
+
+    # Wait a random amount of time, then play the sequence
+    QueueSequence<private>(Index:int)<suspends>:void=
+        CooldownTime:float = GetRandomFloat(CooldownMin, CooldownMax)
+        Sleep(CooldownTime)
+
+        if (MySequencer := SequencerList[Index]):
+            MySequencer.Play()
+
+        QueueSequence(GetNextIndexToPlay(Index))
+
+    
+    # Decide the next sequence index, either completely random, or excluding the last-played sequence
+    GetNextIndexToPlay<private>(LastIndex:int):int=
+        if (SequencerList.Length > 1 and PreventBackToBackRepeats?):
+            var IndexToReturn:int = LastIndex + GetRandomInt(1, SequencerList.Length-1)
+            if(set IndexToReturn = Mod[IndexToReturn, SequencerList.Length]):
+                return IndexToReturn
+
+        return GetRandomInt(0, SequencerList.Length-1)

Code_Reference/Domination/capturepoint_lighting_control.verse

@@ -0,0 +1,47 @@
+# Copyright Epic Games, Inc. All Rights Reserved.
+
+using { /Fortnite.com/Devices }
+using { /Verse.org/Simulation }
+
+##################################################################
+# We want a bit more control over our capture point lighting than what the default capture device light can do
+# This script plays a cinematic sequence device for each capture point depending on which team owns it
+# Within the sequence, we set our lighting values to desired color & intensity
+##################################################################
+
+capturepoint_lighting_control := class(creative_device):
+
+    @editable
+    CapturePoints:[]capture_area_device = array{}
+    @editable
+    Sequencers_Team1:[]cinematic_sequence_device = array{}
+    @editable
+    Sequencers_Team2:[]cinematic_sequence_device = array{}
+
+    OnBegin<override>()<suspends>:void=
+        for (i -> EachCapPoint : CapturePoints):
+            case (i):
+                0 => EachCapPoint.ControlChangeEvent.Subscribe(CaptureChange_A)
+                1 => EachCapPoint.ControlChangeEvent.Subscribe(CaptureChange_B)
+                2 => EachCapPoint.ControlChangeEvent.Subscribe(CaptureChange_C)
+                _ => 
+
+    CaptureChange_A(MyAgent:agent):void=
+        PointCaptured(MyAgent, 0)
+    CaptureChange_B(MyAgent:agent):void=
+        PointCaptured(MyAgent, 1)
+    CaptureChange_C(MyAgent:agent):void=
+        PointCaptured(MyAgent, 2)
+
+    PointCaptured(MyAgent:agent, CaptureIndex:int):void=
+        TeamCollection := GetPlayspace().GetTeamCollection()
+        if:
+            Team1Sequence := Sequencers_Team1[CaptureIndex]
+            Team2Sequence := Sequencers_Team2[CaptureIndex]
+        then:
+            if (TeamCollection.IsOnTeam[MyAgent, TeamCollection.GetTeams()[0]]):
+                Team1Sequence.Play()
+                Team2Sequence.Stop()
+            else:
+                Team1Sequence.Stop()
+                Team2Sequence.Play()