Round Gameplay Interface for Scene Graph

Module — 2 files

These files compile together (same module folder).

file_1.verse

using. /Fortnite.com/Game
using. /Verse.org/Concurrency
using. /Verse.org/SceneGraph
using. /Verse.org/Simulation

fort_round_simulate_interface<public> := interface {

    var<private> FortRoundManagerSubscriptions<private> : []cancelable = array{}

    var<private> _CancelFortRoundGameplayEvent<private> : ?event() = false
    var<private> _FortRoundGameplayHandlerTask<private> : ?task(void) = false

    var<private> IsFortRoundSimulating<public><final> : logic = false
    var<private> _FortRoundStartEvent<private> : ?event() = false
    var<private> _FortRoundEndEvent<private> : ?event() = false

    IsFortRoundGameplayActive<public><final>()<computes><decides><reads>:void = _FortRoundGameplayHandlerTask?

    <#  Start listening to Fort Round Events. Calling this before OnAddedToScene will silently fail.
        If Fort Round is already running, will trigger the FortRoundSimulate callbacks immediately. #>
    StartFortRoundGameplay<public><final>():void = {
        SelfComponent := if (_SelfComponent := component[Self]). _SelfComponent else. return
        if (not SelfComponent.IsInScene[]). return
        if (IsFortRoundSimulating?). OnFortRoundStartInternal()
        if (IsFortRoundGameplayActive[]). return
        if (FortRoundManager := SelfComponent.Entity.GetFortRoundManager[]) {
            InitializeEventsInternal()

            # Keeping the Round Subscriptions cached so they do not get garbage collected 
            set FortRoundManagerSubscriptions = array{
                FortRoundManager.SubscribeRoundStarted(OnFortRoundStartInternal)
                FortRoundManager.SubscribeRoundEnded(OnFortRoundEndInternal)
            }

            # Keeping the Task cached so it does not get garbage collected
            FortRoundGameplayHandlerTask := spawn { FortRoundGameplayHandler() }
            set _FortRoundGameplayHandlerTask = option{FortRoundGameplayHandlerTask}
        }
    }

    <#  Cancel the running FortRoundSimulate tasks, and stops listening for future Fort Round Events.
        Can be used during OnEndSimulation to stop the Fort Round Behavior when the component is removed from scene. #>
    StopFortRoundGameplay<public><final>():void = {
        for (FortRoundManagerSubscription : FortRoundManagerSubscriptions) {
            FortRoundManagerSubscription.Cancel()
        }
        set FortRoundManagerSubscriptions = array{}

        set _FortRoundGameplayHandlerTask = false
        OnFortRoundEndInternal()
        if (CancelFortRoundGameplayEvent := _CancelFortRoundGameplayEvent?). CancelFortRoundGameplayEvent.Signal()
    }

    <#  Need to construct the events outside interface construction due to a bug
        where events created at interface initialization are acting as global #>
    InitializeEventsInternal<private>()<transacts>:void = {
        if (not _CancelFortRoundGameplayEvent?). set _CancelFortRoundGameplayEvent = option{event(){}}
        if (not _FortRoundStartEvent?). set _FortRoundStartEvent = option{event(){}}
        if (not _FortRoundEndEvent?). set _FortRoundEndEvent = option{event(){}}
    }

    OnFortRoundStartInternal<private>():void = {
        if (IsFortRoundSimulating?). return
        set IsFortRoundSimulating = true
        if (FortRoundStartEvent := _FortRoundStartEvent?). FortRoundStartEvent.Signal()
    }
    OnFortRoundEndInternal<private>():void = {
        if (not IsFortRoundSimulating?). return
        set IsFortRoundSimulating = false
        if (FortRoundEndEvent := _FortRoundEndEvent?). FortRoundEndEvent.Signal()
    }

    FortRoundGameplayHandler<private>()<suspends>:void = {
        race {
            if (CancelFortRoundGameplayEvent := _CancelFortRoundGameplayEvent?). CancelFortRoundGameplayEvent.Await()
            FortRoundLifetimeHandler()
        }
    }

    FortRoundLifetimeHandler<private>()<suspends>:void = {
        loop {
            if (FortRoundStartEvent := _FortRoundStartEvent?). FortRoundStartEvent.Await()
            race {
                if (FortRoundEndEvent := _FortRoundEndEvent?). FortRoundEndEvent.Await() else. Sleep(Inf)
                (OnFortRoundBeginSimulation(); OnFortRoundSimulate(); Sleep(Inf))
            }
            OnFortRoundEndSimulation()
        }
    }

    AwaitFortRoundStart<public><final>()<suspends>:void = {
        if (IsFortRoundSimulating?). return 
        InitializeEventsInternal()
        if (FortRoundStartEvent := _FortRoundStartEvent?). FortRoundStartEvent.Await()
    }

    AwaitFortRoundEnd<public><final>()<suspends>:void = {
        InitializeEventsInternal()
        if (FortRoundEndEvent := _FortRoundEndEvent?). FortRoundEndEvent.Await()
    }

    OnFortRoundBeginSimulation<public>():void = {}

    OnFortRoundSimulate<public>()<suspends>:void = {}

    OnFortRoundEndSimulation<public>():void = {}
}

file_2.verse

using. /Verse.org/SceneGraph
using. /Verse.org/Simulation

fort_round_example_component<public> := class<final_super>(component, fort_round_simulate_interface) {
    
    OnAddedToScene<override>():void = {
        <#  Start the Fortnite Round Gameplay Behavior on the interface. This is required to initialize and use any of the provided
            functionality. Fortnite Round Lifecycle Methods and Events will never run if you have not started. Calling this while the
            entity is not currently on the scene will silently fail. (You can check the state with `IsFortRoundGameplayActive[]`) #>
        StartFortRoundGameplay()
    }

    OnEndSimulation<override>():void = {
        <#  Stop the Fortnite Round Gameplay Behavior on the interface. If a Fortnite Round is currently running, the
            round logic will be cancelled, properly cycling the lifetime methods #>
        StopFortRoundGameplay()
    }

    # Examples using awaitable methods and querying the current interface and Fortnite Round states
    OnSimulate<override>()<suspends>:void = {
        # Checks if a Fortnite Round is currently running or not.
        if (IsFortRoundSimulating?). Print("Fortnite Round is currently running!")
        else. Print("Fortnite Round is not running.")

        # Checks if the Fortnite Round Gameplay Behavior interface is currently active or not
        if (IsFortRoundGameplayActive[]). Print("Fortnite Round Gameplay Behavior is enabled!")
        else. Print("Fortnite Round Gameplay Behavior is not enabled.")

        # Wait until a Fortnite Round starts. If a fortnite round is already running, will return immediately.
        AwaitFortRoundStart()
        Print("This Will print only after the Fortnite Round has started!")

        # Wait until a Fortnite Round ends.
        AwaitFortRoundEnd()
        Print("This Will print only after the Fortnite Round has ended!")
    }

    # This runs when the fortnite round start. It is guaranted to run before starting `OnFortRoundSimulate`
    OnFortRoundBeginSimulation<override>():void = {
        Print("Fortnite Round Started, running Initialization Code...")
        # Initialize needed devices, subscriptions, variables and so on
    }

    <#  This runs when a Fortnite Round is active. Will be automatically cancelled when a Fortnite
        Round ends, or if the Round Gameplay Behavior is stopped by `StopFortRoundGameplay()` #>
    OnFortRoundSimulate<override>()<suspends>:void = {
        Print("Fortnite Round Initialization Finished!, running Gameplay Loop code...")
        defer {
            Print("Fortnite Round Ended, round simulation was stopped.")
        }

        # Run your fortnite round gameplay logic here

        var SecondsElapsed : int = 0
        loop {
            Sleep(1.0)
            set SecondsElapsed += 1
            Print("Fortnite Round is running for {SecondsElapsed} seconds!")
        }
    }

    # This runs when a Fortnite Round ends, or if the Round Gameplay Behavior is stopped by `StopFortRoundGameplay()`
    OnFortRoundEndSimulation<override>():void = {
        Print("Fortnite Round Ended, running Clean Up code...")
        # Clean up subscriptions, reset variables, save players data and states as needed.
    }
}

Copy-paste each file above is always free.

Round Gameplay Interface for Scene Graph

Comments