Request to move certain epic_internal functions into Public APIs

General Feedback & Requests
, ,
1

There are several epic_internal APIs (some of which have existed since UEFN launch) that haven’t found their way into any public modules yet, most of which could find good use in creators’ hands. Well aware they are internal for a reason (ie. they’re being worked on), but I’m writing this feature request just in case they’ve been forgotten about :slight_smile:

  • Zipline device (which released two years ago)'s API is entirely epic_internal
    zipline_device<epic_internal> := class<concrete><final>(creative_device_base):
        # Signaled when an `agent` attaches to the zipline.
        # Sends `agent` that attached.
        AttachEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` detaches from the zipline.
        # Sends `agent` that detached.
        DetachEvent<public>:listenable(agent) = external {}

        # Returns true if `Agent`is currently attached to this zipline.
        IsAttached<public>(Agent:agent)<transacts><decides>:void = external {}
  • All the Patchwork device classes have members, yet they’re all epic_internal. This could help set up rhythm-based experiences without the hassle of going through Sequencers.
    Patchwork<public> := module:
                    ...
        # Apply a distortion effect to Patchwork audio inputs.
        distortion_effect_device<public> := class<concrete><final>(patchwork_device):
            var Mix<epic_internal>:float = external {}

            var Tame<epic_internal>:float = external {}

            var Shatter<epic_internal>:float = external {}

            var Drive<epic_internal>:float = external {}

            var Style<epic_internal>:int = external {}
  • Several functions on the base class for vehicle spawners are epic_internal. Yes, there is a GetPassengers function that’s public, but that only returns an array. You can’t know for sure who’s a driver or a passenger unless all seats are occupied.
    # Base class for various specialized vehicle spawners which allow specific vehicle types to be spawned and configured with specialized options.
    vehicle_spawner_device<public> := class<abstract><epic_internal>(creative_device_base):
                   ...
        # Applies off-road tires to the vehicle if applicable.
        ApplyOffRoadTires<epic_internal>():void = external {}

        # Reverts to road tires on the vehicle if applicable.
        RemoveTireMods<epic_internal>():void = external {}

        # Pops all of the tires on the vehicle, if applicable.
        PopAllTires<epic_internal>():void = external {}

        # Repairs all of the tires on the vehicle, if applicable.
        RepairAllTires<epic_internal>():void = external {}

        # Sets the amount of fuel(or energy) in the vehicle as a percentage between `0.0` and `100.0`.
        SetFuelRemaining<epic_internal>(Amount:float):void = external {}

        # Gets the amount of fuel(or energy) in the vehicle as a percentage between `0.0` and `100.0`.
        GetFuelRemaining<epic_internal>()<transacts>:float = external {}

        # Checks to see if a vehicle is currently spawned from this device.
        HasVehicle<epic_internal>()<transacts><decides>:void = external {}

        # Succeeds if `agent` is the driver of the vehicle.
        IsDriver<epic_internal>(Agent:agent)<transacts><decides>:void = external {}

        # Succeeds if `agent` is the passenger of the vehicle.
        IsPassenger<epic_internal>(Agent:agent)<transacts><decides>:void = external {}

        # Restores the vehicle to full health.
        RepairVehicle<epic_internal>():void = external {}

        # Sets the vehicle's current health to the supplied amount.
        # Health will be clamped between `1.0` and *Max Health*.
        SetVehicleHealth<epic_internal>(Amount:float):void = external {}

        # Returns the vehicle's current health.
        # Returns 0.0 if the vehicle does not exist.
        GetVehicleHealth<epic_internal>()<transacts>:float = external {}

        # Sets the vehicle's maximum health to the supplied value.
        # Health will be clamped between `1.0` and `9,999.0`.
        SetVehicleMaxHealth<epic_internal>(Amount:float):void = external {}

        # Returns the vehicle's maximum health.
        GetVehicleMaxHealth<epic_internal>(Amount:float):void = external {}

        # Returns the `agent` who is currently driving the vehicle.
        GetDriver<epic_internal>()<transacts><decides>:agent = external {}

Some Ballistic functions that should be part of existing playspace/player APIs

  • At the minute, Playspace PlayerAdded events fire off before the player has actually loaded into the game. There is no way to check if the player’s actually loaded in without silly workarounds. Ballistic appears to have solved this.
    # Module import path: /Fortnite.com/FeralCorgi/PlayerLoadingStatusBridge
    PlayerLoadingStatusBridge<epic_internal> := module:
                      ...
        IsPlayerLoading<native><epic_internal>(Playspace:fort_playspace, Player:player)<transacts><decides>:void
                       ...
        AwaitPlayerReadyForGameplay<native><epic_internal>(Player:player)<suspends>:void
  • Being able to check if code is running in an Edit Session would be useful for showing or hiding content used for testing.
  • Can’t end the game without hooking into a Device. A Verse function would be plenty useful.
  • Getting the current round number is impossible without setting up Rounds * Round Manager devices or other weird workarounds.
  • Getting the amount of Rounds is also impossible without hardcoding a value for it (which you then might forget to update if changing the number of rounds).
  • Checking if a player is in a Public or Private session is also impossible. Use cases for this include: reminding players they could look for Fill lobbies if they switch to Public mm, disable progression in competitive maps to avoid boosting, allowing players to AFK in Private lobbies where they wouldn’t ruin the experience for randoms, etc.
    # Module import path: /Fortnite.com/FeralCorgi/SessionAttributesBridge
    SessionAttributesBridge<epic_internal> := module:
                          ...
        IsVKEdit<native><epic_internal>(Playspace:fort_playspace)<transacts><decides>:void
                          ...
        EndMatch<native><epic_internal>(Playspace:fort_playspace)<transacts><decides>:void

        GetMinigameRound<native><epic_internal>(Playspace:fort_playspace)<transacts>:int

        GetTotalMinigameRounds<native><epic_internal>(Playspace:fort_playspace)<transacts>:int
  • It is currently impossible to get a player’s outfit icon outside of one or two mvvm viewmodels used in the HUD Controller Device. Use cases: leaderboards, other UIs that could display player outfit alongside player name.
FeralCorgi<public> := module:
          ...
    player_display_info<native><epic_internal> := struct:
        Image<native>:texture

        LargeImage<native>:texture

        SmallImage<native>:texture

    player_display_info_manager<native><epic_internal> := class:
        GetDisplayInfo<native><epic_internal>(InAgent:agent)<reads>:player_display_info
  • Character DBNO events without having to set up a Down But Not Out Device
# Module import path: /Fortnite.com/Characters
Characters<public> := module:
    # Main API implemented by Fortnite characters.
    fort_character<native><public> := ...
...

        # Signaled when this `fort_character` changes 'Down But Not Out' (DBNO) state.
        # Sends `tuple` payload:
        #  - 0: the `fort_character` that changed DBNO state.
        #  - 1: the `fort_character` that instigated the DBNO state change.
        #  - 2: `true` if the character is DBNO. `false` if the character is not DBNO.
        DownButNotOutEvent<epic_internal>():listenable(tuple(fort_character, ?fort_character, logic))
  • We currently have little to no control over Spectating. These functions exist under FortPlayerUtilities, however they are not public.
# Module import path: /Fortnite.com/FortPlayerUtilities
FortPlayerUtilities<public> := module:
            ...

    # Sets `InAgent` to spectate `ParticipantToSpectate`.
    # Fails if:
    #  * `ParticipantToSpectate` is already eliminated.
    #  * `ParticipantToSpectate` is the same as `InAgent`.
    (InAgent:agent).SpectateParticipant<native><epic_internal>(ParticipantToSpectate:agent)<transacts><decides>:void

    # Sets `InAgent` to spectate the `agent` that eliminated them.
    # Fails if the eliminating `player` has also been eliminated.
    (InAgent:agent).SpectateEliminator<native><epic_internal>()<transacts><decides>:void
  • The shieldable interface has internal members for Overshield (from Zero Build)
    shieldable<native><public> := interface<epic_internal>:
           ...


        # Returns the overshield state of the object. This value will be between 0.0 and `MaxOvershield`
        GetOvershield<epic_internal>()<transacts>:float

        # Sets the overshield state of the object.
        #  * Overshield state will be clamped between 0.0 and `MaxOvershield`.
        SetOvershield<epic_internal>(Overshield:float)<transacts>:void

        # Returns the maximum overshield state of the object. This value will be between 0.0 and Inf.
        GetMaxOvershield<epic_internal>()<transacts>:float

        # Sets the maximum overshield state of the object.
        #  * MaxOvershield will be clamped between 0.0 and Inf.
        #  * Current overshield state will be scaled up or down based on the scale difference between the old and new MaxOvershield state.
        SetMaxOvershield<epic_internal>(MaxOvershield:float)<transacts>:void

        # Signaled when the overshield is damaged.
        DamagedOvershieldEvent<epic_internal>():listenable(damage_result)

        # Signaled when the oversshield is healed.
        HealedOvershieldEvent<epic_internal>():listenable(healing_result)

These are just from the Fortnite digest & there are plenty more.

2

VerseWorldPartition please? :slightly_smiling_face:

using {/UnrealEngine.com/Temporary/SpatialMath}
using {/Verse.org/Assets}
VerseWorldPartition<public> := module:
    data_layer_asset<native><epic_internal> := class<concrete><computes><final><epic_internal>(asset):


    world_partition_streaming_runtime_state<native><epic_internal> := enum:
        Unloaded
        Loaded
        Activated
        
    world_partition_helper<native><epic_internal> := class<concrete>:
        SetDataLayerRuntimeState<native><public>(DataLayerAsset:data_layer_asset, State:world_partition_streaming_runtime_state, IsRecursive:logic)<transacts>:logic

        GetDataLayerEffectiveRuntimeState<native><public>(DataLayerAsset:data_layer_asset)<transacts>:world_partition_streaming_runtime_state

        AddStreamingSourceProvider<native><public>(UpdateStreamingSourceCallback:type {_(:world_partition_streaming_source):void})<transacts>:cancelable

        AddStreamingSource<native><public>(StreamingSource:world_partition_streaming_source)<transacts>:cancelable

        IsStreamingCompleted<native><public>(Sources:?[]world_partition_streaming_source)<transacts>:logic

        IsStreamingCompleted<native><public>(Sources:[]world_partition_streaming_query_source, QueryState:world_partition_streaming_runtime_state)<transacts>:logic

    GetWorldPartitionHelper<native><epic_internal>()<transacts>:?world_partition_helper
2 Likes
3

YES YES YES YES YES YES YES YES YES

4

+1, I personally of all these API’s would mostly like the SessionAttributesBridge, especially since Skill Based Matchmaking is set to come next Quarter, I would really believe a way to differentiate Public/Private/Custom Matchmade games would be important