1. Epic GamesDeveloper
  3. UGameplayStatics

UGameplayStatics

Static class with useful gameplay utility functions that can be called from both Blueprint and C++

API > API/Runtime > API/Runtime/Engine

Static class with useful gameplay utility functions that can be called from both Blueprint and C++

   
Name UGameplayStatics
Type class
Header File /Engine/Source/Runtime/Engine/Classes/Kismet/GameplayStatics.h
Include Path #include "Kismet/GameplayStatics.h"

Syntax

UCLASS (MinimalAPI)  
class UGameplayStatics : public UBlueprintFunctionLibrary

Inheritance Hierarchy

Constructors

Name Remarks Include Path Unreal Specifiers

UGameplayStatics ( const FObjectInitializer& ObjectInitializer
)

   Kismet/GameplayStatics.h  

Structs

Name Remarks
FSuggestProjectileVelocityParameters Struct of parameters passed to SuggestProjectileVelocity function.

Functions

Public

Static

Name Remarks Include Path Unreal Specifiers

static void ActivateReverbEffect ( const UObject* WorldContextObject,
UReverbEffect* ReverbEffect,
FName TagName,
float Priority,
float Volume,
float FadeTime
)

 Activates a Reverb Effect without the need for an Audio Volume Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject", AdvancedDisplay="2")

static void AnnounceAccessibleString ( const FString& AnnouncementString
)

 If accessibility is enabled, have the platform announce a string to the player. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Accessibility"

static float ApplyDamage ( AActor* DamagedActor,
float BaseDamage,
AController* EventInstigator,
AActor* DamageCauser,
TSubclassOf< class UDamageType > DamageTypeClass
)

 Hurts the specified actor with generic damage. Kismet/GameplayStatics.h
  • BlueprintCallable
  • BlueprintAuthorityOnly
  • Category="Game|Damage"

static float ApplyPointDamage ( AActor* DamagedActor,
float BaseDamage,
const FVector& HitFromDirection,
const FHitResult& HitInfo,
AController* EventInstigator,
AActor* DamageCauser,
TSubclassOf< class UDamageType > DamageTypeClass
)

 Hurts the specified actor with the specified impact. Kismet/GameplayStatics.h
  • BlueprintCallable
  • BlueprintAuthorityOnly
  • Category="Game|Damage"

static bool ApplyRadialDamage ( const UObject* WorldContextObject,
float BaseDamage,
const FVector& Origin,
float DamageRadius,
TSubclassOf< class UDamageType > DamageTypeClass,
const TArray< AActor* >& IgnoreActors,
AActor* DamageCauser,
AController* InstigatedByController,
bool bDoFullDamage,
ECollisionChannel DamagePreventionChannel
)

 Hurt locally authoritative actors within the radius. Kismet/GameplayStatics.h
  • BlueprintCallable
  • BlueprintAuthorityOnly
  • Category="Game|Damage"
  • Meta=(WorldContext="WorldContextObject", AutoCreateRefTerm="IgnoreActors")

static bool ApplyRadialDamageWithFalloff ( const UObject* WorldContextObject,
float BaseDamage,
float MinimumDamage,
const FVector& Origin,
float DamageInnerRadius,
float DamageOuterRadius,
float DamageFalloff,
TSubclassOf< class UDamageType > DamageTypeClass,
const TArray< AActor* >& IgnoreActors,
AActor* DamageCauser,
AController* InstigatedByController,
ECollisionChannel DamagePreventionChannel
)

 Hurt locally authoritative actors within the radius. Kismet/GameplayStatics.h
  • BlueprintCallable
  • BlueprintAuthorityOnly
  • Category="Game|Damage"
  • Meta=(WorldContext="WorldContextObject", AutoCreateRefTerm="IgnoreActors")

static bool AreAnyListenersWithinRange ( const UObject* WorldContextObject,
const FVector& Location,
float MaximumRange
)

 Determines if any audio listeners are within range of the specified location Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject")

static bool AreSubtitlesEnabled()

 Returns whether or not subtitles are currently enabled. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Audio|Subtitles"

static void AsyncLoadGameFromSlot ( const FString& SlotName,
const int32 UserIndex,
FAsyncLoadGameFromSlotDelegate LoadedDelegate
)

 Schedule an async load of a specific slot. Kismet/GameplayStatics.h  

static void AsyncSaveGameToSlot ( USaveGame* SaveGameObject,
const FString& SlotName,
const int32 UserIndex,
FAsyncSaveGameToSlotDelegate SavedDelegate
)

 Schedule an async save to a specific slot. Kismet/GameplayStatics.h  

static AActor * BeginDeferredActorSpawnFromClass ( const UObject* WorldContextObject,
TSubclassOf< AActor > ActorClass,
const FTransform& SpawnTransform,
ESpawnActorCollisionHandlingMethod CollisionHandlingOverride,
AActor* Owner,
ESpawnActorScaleMethod TransformScaleMethod
)

 Spawns an instance of an actor class, but does not automatically run its construction script. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Spawning"
  • Meta=(WorldContext="WorldContextObject", UnsafeDuringActorConstruction="true", BlueprintInternalUseOnly="true")

static AActor * BeginSpawningActorFromBlueprint ( const UObject* WorldContextObject,
const UBlueprint* Blueprint,
const FTransform& SpawnTransform,
bool bNoCollisionFail
)

 Spawns an instance of a blueprint, but does not automatically run its construction script. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Spawning"
  • Meta=(WorldContext="WorldContextObject", UnsafeDuringActorConstruction="true", BlueprintInternalUseOnly="true", DeprecatedFunction="Note", DeprecationMessage="Use BeginSpawningActorFromClass")

static bool Blueprint_PredictProjectilePath_Advanced ( const UObject* WorldContextObject,
const FPredictProjectilePathParams& PredictParams,
FPredictProjectilePathResult& PredictResult
)

 Predict the arc of a virtual projectile affected by gravity with collision checks along the arc. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Game"
  • DisplayName="Predict Projectile Path (Advanced)"
  • Meta=(WorldContext="WorldContextObject")

static bool Blueprint_PredictProjectilePath_ByObjectType ( const UObject* WorldContextObject,
FHitResult& OutHit,
TArray< FVector >& OutPathPositions,
FVector& OutLastTraceDestination,
FVector StartPos,
FVector LaunchVelocity,
bool bTracePath,
float ProjectileRadius,
const TArray< TEnumAsByte< EObjectTypeQuery > >& ObjectTypes,
bool bTraceComplex,
const TArray< AActor* >& ActorsToIgnore,
EDrawDebugTrace::Type DrawDebugType,
float DrawDebugTime,
float SimFrequency,
float MaxSimTime,
float OverrideGravityZ
)

 Predict the arc of a virtual projectile affected by gravity with collision checks along the arc. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Game"
  • DisplayName="Predict Projectile Path By ObjectType"
  • Meta=(WorldContext="WorldContextObject", AutoCreateRefTerm="ActorsToIgnore", AdvancedDisplay="DrawDebugTime, DrawDebugType, SimFrequency, MaxSimTime, OverrideGravityZ", bTracePath=true)

static bool Blueprint_PredictProjectilePath_ByTraceChannel ( const UObject* WorldContextObject,
FHitResult& OutHit,
TArray< FVector >& OutPathPositions,
FVector& OutLastTraceDestination,
FVector StartPos,
FVector LaunchVelocity,
bool bTracePath,
float ProjectileRadius,
TEnumAsByte< ECollisionChannel > TraceChannel,
bool bTraceComplex,
const TArray< AActor* >& ActorsToIgnore,
EDrawDebugTrace::Type DrawDebugType,
float DrawDebugTime,
float SimFrequency,
float MaxSimTime,
float OverrideGravityZ
)

 Predict the arc of a virtual projectile affected by gravity with collision checks along the arc. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Game"
  • DisplayName="Predict Projectile Path By TraceChannel"
  • Meta=(WorldContext="WorldContextObject", AutoCreateRefTerm="ActorsToIgnore", AdvancedDisplay="DrawDebugTime, DrawDebugType, SimFrequency, MaxSimTime, OverrideGravityZ", TraceChannel=ECC_WorldDynamic, bTracePath=true)

static bool BlueprintSuggestProjectileVelocity ( const UObject* WorldContextObject,
FVector& TossVelocity,
FVector StartLocation,
FVector EndLocation,
float LaunchSpeed,
float OverrideGravityZ,
ESuggestProjVelocityTraceOption::Type TraceOption,
float CollisionRadius,
bool bFavorHighArc,
bool bDrawDebug,
bool bAcceptClosestOnNoSolutions
)

 Calculates an launch velocity for a projectile to hit a specified point. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Game"
  • DisplayName="Suggest Projectile Velocity"
  • Meta=(WorldContext="WorldContextObject")

static void BreakHitResult ( const FHitResult& Hit,
bool& bBlockingHit,
bool& bInitialOverlap,
float& Time,
float& Distance,
FVector& Location,
FVector& ImpactPoint,
FVector& Normal,
FVector& ImpactNormal,
UPhysicalMaterial*& PhysMat,
AActor*& HitActor,
UPrimitiveComponent*& HitComponent,
FName& HitBoneName,
FName& BoneName,
int32& HitItem,
int32& ElementIndex,
int32& FaceIndex,
FVector& TraceStart,
FVector& TraceEnd
)

 Extracts data from a HitResult. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Collision"
  • Meta=(NativeBreakFunc, AdvancedDisplay="3")

static void CalculateViewProjectionMatricesFromMinimalView ( const FMinimalViewInfo& MinimalViewInfo,
const TOptional< FMatrix >& CustomProjectionMatrix,
FMatrix& OutViewMatrix,
FMatrix& OutProjectionMatrix,
FMatrix& OutViewProjectionMatrix
)

 Calculate view-projection matrices from a specified MinimalViewInfo and optional custom projection matrix Kismet/GameplayStatics.h  

static void CalculateViewProjectionMatricesFromViewTarget ( AActor* InViewTarget,
FMatrix& OutViewMatrix,
FMatrix& OutProjectionMatrix,
FMatrix& OutViewProjectionMatrix
)

 Calculate view-projection matrices from a specified view target Kismet/GameplayStatics.h  

static void CancelAsyncLoading()

 Cancels all currently queued streaming packages Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Game"

static void ClearSoundMixClassOverride ( const UObject* WorldContextObject,
USoundMix* InSoundMixModifier,
USoundClass* InSoundClass,
float FadeOutTime
)

 Clears any existing override of the Sound Class Adjuster in the given Sound Mix Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject")

static void ClearSoundMixModifiers ( const UObject* WorldContextObject
)

 Clear all sound mix modifiers from the audio system Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject")

static APlayerController * CreatePlayer ( const UObject* WorldContextObject,
int32 ControllerId,
bool bSpawnPlayerController
)

 Create a new local player for this game, for cases like local multiplayer. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Game"
  • Meta=(DisplayName="Create Local Player", WorldContext="WorldContextObject", AdvancedDisplay="2", UnsafeDuringActorConstruction="true")

static APlayerController * CreatePlayerFromPlatformUser ( const UObject* WorldContextObject,
FPlatformUserId UserId,
bool bSpawnPlayerController
)

 Create a new local player for this game, for cases like local multiplayer. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Game"
  • Meta=(AutoCreateRefTerm="UserId", DisplayName="Create Local Player For Platform User", WorldContext="WorldContextObject", AdvancedDisplay="2", UnsafeDuringActorConstruction="true")

static USaveGame * CreateSaveGameObject ( TSubclassOf< USaveGame > SaveGameClass
)

 Create a new, empty SaveGame object to set data on and then pass to SaveGameToSlot. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="SaveGame"
  • Meta=(DeterminesOutputType="SaveGameClass")

static UAudioComponent * CreateSound2D ( const UObject* WorldContextObject,
USoundBase* Sound,
float VolumeMultiplier,
float PitchMultiplier,
float StartTime,
USoundConcurrency* ConcurrencySettings,
bool bPersistAcrossLevelTransition,
bool bAutoDestroy
)

 This function allows users to create Audio Components in advance of playback with settings specifically for non-spatialized, non-distance-attenuated sounds. Kismet/GameplayStatics.h
  • BlueprintCallable
  • BlueprintCosmetic
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject", AdvancedDisplay="2", UnsafeDuringActorConstruction="true", Keywords="play")

static void DeactivateReverbEffect ( const UObject* WorldContextObject,
FName TagName
)

 Deactivates a Reverb Effect that was applied outside of an Audio Volume Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject")

static bool DeleteGameInSlot ( const FString& SlotName,
const int32 UserIndex
)

 Delete a save game in a particular slot. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="SaveGame"

static bool DeprojectSceneCaptureComponentToWorld ( USceneCaptureComponent2D* SceneCaptureComponent2D,
const FVector2D& TargetUV,
FVector& WorldPosition,
FVector& WorldDirection
)

 Transforms the given 2D UV coordinate into a 3D world-space point and direction. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Camera"
  • Meta=(Keywords="unproject")

static bool DeprojectSceneCaptureToWorld ( ASceneCapture2D const* SceneCapture2D,
const FVector2D& TargetUV,
FVector& WorldPosition,
FVector& WorldDirection
)

 Transforms the given 2D UV coordinate into a 3D world-space point and direction. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Camera"
  • Meta=(Keywords="unproject")

static bool DeprojectScreenToWorld ( APlayerController const* Player,
const FVector2D& ScreenPosition,
FVector& WorldPosition,
FVector& WorldDirection
)

 Transforms the given 2D screen space coordinate into a 3D world-space point and direction. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Camera"
  • Meta=(Keywords="unproject")

static bool DoesSaveGameExist ( const FString& SlotName,
const int32 UserIndex
)

 See if a save game exists with the specified name. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="SaveGame"

static void EnableLiveStreaming ( bool Enable
)

 Toggle live DVR streaming. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Game"
  • Meta=(Enable="true")

static bool FindCollisionUV ( const FHitResult& Hit,
int32 UVChannel,
FVector2D& UV
)

 Try and find the UV for a collision impact. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Collision"

static AActor * FindNearestActor ( FVector Origin,
const TArray< AActor* >& ActorsToCheck,
float& Distance
)

 Returns an Actor nearest to Origin from ActorsToCheck array. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Actor"

static AActor * FinishSpawningActor ( AActor* Actor,
const FTransform& SpawnTransform,
ESpawnActorScaleMethod TransformScaleMethod
)

 'Finish' spawning an actor. This will run the construction script. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Spawning"
  • Meta=(UnsafeDuringActorConstruction="true", BlueprintInternalUseOnly="true")

static void FlushLevelStreaming ( const UObject* WorldContextObject
)

 Flushes level streaming in blocking fashion and returns when all sub-levels are loaded / visible / hidden Kismet/GameplayStatics.h
  • BlueprintCallable
  • Meta=(WorldContext="WorldContextObject")
  • Category="Game"

static void GetAccurateRealTime ( int32& Seconds,
double& PartialSeconds
)

 Returns time in seconds since the application was started. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Utilities|Time"

static FName GetActiveSpatialPluginName ( const UObject* WorldContextObject
)

 Get currently active Audio Spatialization Plugin name Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject")

static FVector GetActorArrayAverageLocation ( const TArray< AActor* >& Actors
)

 Find the average location (centroid) of an array of Actors Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Transformation"

static void GetActorArrayBounds ( const TArray< AActor* >& Actors,
bool bOnlyCollidingComponents,
FVector& Center,
FVector& BoxExtent
)

 Bind the bounds of an array of Actors Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Collision"

static AActor * GetActorOfClass ( const UObject* WorldContextObject,
TSubclassOf< AActor > ActorClass
)

 Find the first Actor in the world of the specified class. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Actor"
  • Meta=(WorldContext="WorldContextObject", DeterminesOutputType="ActorClass")

static void GetAllActorsOfClass ( const UObject* WorldContextObject,
TSubclassOf< AActor > ActorClass,
TArray< AActor* >& OutActors
)

 Find all Actors in the world of the specified class. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Actor"
  • Meta=(WorldContext="WorldContextObject", DeterminesOutputType="ActorClass", DynamicOutputParam="OutActors")

static void GetAllActorsOfClassWithTag ( const UObject* WorldContextObject,
TSubclassOf< AActor > ActorClass,
FName Tag,
TArray< AActor* >& OutActors
)

 Find all Actors in the world of the specified class with the specified tag. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Actor"
  • Meta=(WorldContext="WorldContextObject", DeterminesOutputType="ActorClass", DynamicOutputParam="OutActors")

static void GetAllActorsWithInterface ( const UObject* WorldContextObject,
TSubclassOf< UInterface > Interface,
TArray< AActor* >& OutActors
)

 Find all Actors in the world with the specified interface. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Actor"
  • Meta=(WorldContext="WorldContextObject", DeterminesOutputType="Interface", DynamicOutputParam="OutActors")

static void GetAllActorsWithTag ( const UObject* WorldContextObject,
FName Tag,
TArray< AActor* >& OutActors
)

 Find all Actors in the world with the specified tag. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Actor"
  • Meta=(WorldContext="WorldContextObject")

static double GetAudioTimeSeconds ( const UObject* WorldContextObject
)

 Returns time in seconds since world was brought up for play, IS stopped when game pauses, NOT dilated/clamped. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Utilities|Time"
  • Meta=(WorldContext="WorldContextObject")

static TArray< FName > GetAvailableSpatialPluginNames ( const UObject* WorldContextObject
)

 Get list of available Audio Spatialization Plugin names Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject")

static bool GetClosestListenerLocation ( const UObject* WorldContextObject,
const FVector& Location,
float MaximumRange,
const bool bAllowAttenuationOverride,
FVector& ListenerPosition
)

 Finds and returns the position of the closest listener to the specified location Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject")

static FString GetCurrentLevelName ( const UObject* WorldContextObject,
bool bRemovePrefixString
)

 Get the name of the currently-open level. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Meta=(WorldContext="WorldContextObject", AdvancedDisplay="1")
  • Category="Game"

static UReverbEffect * GetCurrentReverbEffect ( const UObject* WorldContextObject
)

 Returns the highest priority reverb settings currently active from any source (Audio Volumes or manual settings). Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject")

static bool GetEnableWorldRendering ( const UObject* WorldContextObject
)

 Returns the world rendering state Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Rendering"
  • Meta=(WorldContext="WorldContextObject")

static UGameInstance * GetGameInstance ( const UObject* WorldContextObject
)

 Returns the game instance object Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game"
  • Meta=(WorldContext="WorldContextObject")

static AGameModeBase * GetGameMode ( const UObject* WorldContextObject
)

 Returns the current GameModeBase or Null if it can't be retrieved, such as on the client Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game"
  • Meta=(WorldContext="WorldContextObject")

static AGameStateBase * GetGameState ( const UObject* WorldContextObject
)

 Returns the current GameStateBase or Null if it can't be retrieved Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game"
  • Meta=(WorldContext="WorldContextObject")

static float GetGlobalTimeDilation ( const UObject* WorldContextObject
)

 Gets the current global time dilation. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Utilities|Time"
  • Meta=(WorldContext="WorldContextObject")

static int32 GetIntOption ( const FString& Options,
const FString& Key,
int32 DefaultValue
)

 Find an option in the options string and return it as an integer. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game Options"
  • Meta=(BlueprintThreadSafe)

static void GetKeyValue ( const FString& Pair,
FString& Key,
FString& Value
)

 Break up a key=value pair into its key and value. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game Options"
  • Meta=(BlueprintThreadSafe)

static int32 GetMaxAudioChannelCount ( const UObject* WorldContextObject
)

 Retrieves the max voice count currently used by the audio engine. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject")

static int32 GetNumLocalPlayerControllers ( const UObject* WorldContextObject
)

 Returns the number of fully initialized local players, this will be 0 on dedicated servers. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game"
  • Meta=(WorldContext="WorldContextObject", UnsafeDuringActorConstruction="true")

static int32 GetNumPlayerControllers ( const UObject* WorldContextObject
)

 Returns the total number of available player controllers, including remote players when called on a server. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game"
  • Meta=(WorldContext="WorldContextObject", UnsafeDuringActorConstruction="true")

static int32 GetNumPlayerStates ( const UObject* WorldContextObject
)

 Returns the number of active player states, there is one player state for every connected player even if they are a remote client. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game"
  • Meta=(WorldContext="WorldContextObject", UnsafeDuringActorConstruction="true")

static UClass * GetObjectClass ( const UObject* Object
)

 Returns the class of a passed in Object, will always be valid if Object is not NULL Kismet/GameplayStatics.h
  • BlueprintPure
  • Meta=(DisplayName="Get Class", DeterminesOutputType="Object")
  • Category="Utilities"
Returns the string name of the current platform, to perform different behavior based on platform. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game"

static APlayerCameraManager * GetPlayerCameraManager ( const UObject* WorldContextObject,
int32 PlayerIndex
)

 Returns the camera manager for the Player Controller at the specified player index. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game"
  • Meta=(WorldContext="WorldContextObject", UnsafeDuringActorConstruction="true")

static ACharacter * GetPlayerCharacter ( const UObject* WorldContextObject,
int32 PlayerIndex
)

 Returns the pawn for the player controller at the specified player index, will return null if the pawn is not a character. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game"
  • Meta=(WorldContext="WorldContextObject", UnsafeDuringActorConstruction="true")

static APlayerController * GetPlayerController ( const UObject* WorldContextObject,
int32 PlayerIndex
)

 Returns the player controller found while iterating through the local and available remote player controllers. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game"
  • Meta=(WorldContext="WorldContextObject", UnsafeDuringActorConstruction="true")

static APlayerController * GetPlayerControllerFromID ( const UObject* WorldContextObject,
int32 ControllerID
)

 Returns the player controller with the specified physical controller ID. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game"
  • Meta=(DisplayName="Get Local Player Controller From ID", WorldContext="WorldContextObject", UnsafeDuringActorConstruction="true")

static APlayerController * GetPlayerControllerFromPlatformUser ( const UObject* WorldContextObject,
FPlatformUserId UserId
)

 Returns the player controller with the specified physical controller ID. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game"
  • Meta=(DisplayName="Get Local Player Controller From Platform User", WorldContext="WorldContextObject", UnsafeDuringActorConstruction="true")

static int32 GetPlayerControllerID ( APlayerController* Player
)

 Gets what physical controller ID a player is using. This only works for local player controllers. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game"
  • Meta=(DisplayName="Get Local Player Controller ID", UnsafeDuringActorConstruction="true")

static APawn * GetPlayerPawn ( const UObject* WorldContextObject,
int32 PlayerIndex
)

 Returns the pawn for the player controller at the specified player index. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game"
  • Meta=(WorldContext="WorldContextObject", UnsafeDuringActorConstruction="true")

static APlayerState * GetPlayerState ( const UObject* WorldContextObject,
int32 PlayerStateIndex
)

 Returns the player state at the given index in the game state's PlayerArray. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game"
  • Meta=(WorldContext="WorldContextObject", UnsafeDuringActorConstruction="true")

static APlayerState * GetPlayerStateFromUniqueNetId ( const UObject* WorldContextObject,
const FUniqueNetIdRepl& UniqueId
)

 Returns the player state that matches the passed in online id, or null for an invalid one. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game"
  • Meta=(WorldContext="WorldContextObject", UnsafeDuringActorConstruction="true")

static double GetRealTimeSeconds ( const UObject* WorldContextObject
)

 Returns time in seconds since world was brought up for play, does NOT stop when game pauses, NOT dilated/clamped Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Utilities|Time"
  • Meta=(WorldContext="WorldContextObject")

static ULevelStreaming * GetStreamingLevel ( const UObject* WorldContextObject,
FName PackageName
)

 Returns level streaming object with specified level package name Kismet/GameplayStatics.h
  • BlueprintPure
  • Meta=(WorldContext="WorldContextObject")
  • Category="Game"
Returns the EPhysicalSurface type of the given Hit. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Collision"

static double GetTimeSeconds ( const UObject* WorldContextObject
)

 Returns time in seconds since world was brought up for play, adjusted by time dilation and IS stopped when game pauses Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Utilities|Time"
  • Meta=(WorldContext="WorldContextObject")

static double GetUnpausedTimeSeconds ( const UObject* WorldContextObject
)

 Returns time in seconds since world was brought up for play, adjusted by time dilation and IS NOT stopped when game pauses Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Utilities|Time"
  • Meta=(WorldContext="WorldContextObject")

static EMouseCaptureMode GetViewportMouseCaptureMode ( const UObject* WorldContextObject
)

 Returns the current viewport mouse capture mode Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Viewport"
  • Meta=(WorldContext="WorldContextObject")

static void GetViewProjectionMatrix ( FMinimalViewInfo DesiredView,
FMatrix& ViewMatrix,
FMatrix& ProjectionMatrix,
FMatrix& ViewProjectionMatrix
)

 Returns the View Matrix, Projection Matrix and the View x Projection Matrix for a given view Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Camera"

static double GetWorldDeltaSeconds ( const UObject* WorldContextObject
)

 Returns the frame delta time in seconds, adjusted by time dilation. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Utilities|Time"
  • Meta=(WorldContext="WorldContextObject")

static FIntVector GetWorldOriginLocation ( const UObject* WorldContextObject
)

 Returns world origin current location. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game"
  • Meta=(WorldContext="WorldContextObject")

static bool GrabOption ( FString& Options,
FString& ResultString
)

   Kismet/GameplayStatics.h  

static int32 GrassOverlappingSphereCount ( const UObject* WorldContextObject,
const UStaticMesh* StaticMesh,
FVector CenterPosition,
float Radius
)

 Counts how many grass foliage instances overlap a given sphere. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Foliage"
  • Meta=(WorldContext="WorldContextObject", UnsafeDuringActorConstruction="true")

static bool HasLaunchOption ( const FString& OptionToCheck
)

 Checks the commandline to see if the desired option was specified on the commandline (e.g. -demobuild) Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Utilities"

static bool HasOption ( FString Options,
const FString& InKey
)

 Returns whether a key exists in an options string. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game Options"
  • Meta=(BlueprintThreadSafe)

static UParticleSystemComponent * InternalSpawnEmitterAtLocation ( UWorld* World,
UParticleSystem* EmitterTemplate,
FVector Location,
FRotator Rotation,
FVector Scale,
bool bAutoDestroy,
EPSCPoolMethod PoolingMethod,
bool bAutoActivate
)

   Kismet/GameplayStatics.h  

static bool IsAnyLocalPlayerCameraWithinRange ( const UObject* WorldContextObject,
const FVector& Location,
float MaximumRange
)

 Determines if any local player controller's camera is within range of the specified location. Kismet/GameplayStatics.h
  • BlueprintPure
  • BlueprintCosmetic
  • Category="Game"
  • Meta=(WorldContext="WorldContextObject")

static bool IsGamePaused ( const UObject* WorldContextObject
)

 Returns the game's paused state Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game"
  • Meta=(WorldContext="WorldContextObject")

static bool IsProjectileTrajectoryBlocked ( const UWorld* World,
FVector StartLocation,
FVector& ProjectileVelocity,
float TargetDeltaXY,
float GravityZ,
float CollisionRadius,
ESuggestProjVelocityTraceOption::Type TraceOption,
const FCollisionResponseParams& ResponseParam,
const TArray< AActor* >& ActorsToIgnore,
bool bDrawDebug
)

 Stepwise trace along the path of a given velocity Kismet/GameplayStatics.h  

static bool IsSplitscreenForceDisabled ( const UObject* WorldContextObject
)

 Returns the split screen state Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Viewport"
  • Meta=(WorldContext="WorldContextObject")

static bool LoadDataFromSlot ( TArray< uint8 >& OutSaveData,
const FString& SlotName,
const int32 UserIndex
)

 Load contents from a slot/file into a buffer of save data. Kismet/GameplayStatics.h  

static USaveGame * LoadGameFromMemory ( const TArray< uint8 >& InSaveData
)

 Tries to load a SaveGame object from a given array of bytes. Kismet/GameplayStatics.h  

static USaveGame * LoadGameFromSlot ( const FString& SlotName,
const int32 UserIndex
)

 Load the contents from a given slot. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="SaveGame"

static void LoadStreamLevel ( const UObject* WorldContextObject,
FName LevelName,
bool bMakeVisibleAfterLoad,
bool bShouldBlockOnLoad,
FLatentActionInfo LatentInfo
)

 Stream the level (by Name); Calling again before it finishes has no effect Kismet/GameplayStatics.h
  • BlueprintCallable
  • Meta=(WorldContext="WorldContextObject", Latent="", LatentInfo="LatentInfo", DisplayName="Load Stream Level (by Name)")
  • Category="Game"

static void LoadStreamLevelBySoftObjectPtr ( const UObject* WorldContextObject,
const TSoftObjectPtr< UWorld > Level,
bool bMakeVisibleAfterLoad,
bool bShouldBlockOnLoad,
FLatentActionInfo LatentInfo
)

 Stream the level (by Object Reference); Calling again before it finishes has no effect Kismet/GameplayStatics.h
  • BlueprintCallable
  • Meta=(WorldContext="WorldContextObject", Latent="", LatentInfo="LatentInfo", DisplayName="Load Stream Level (by Object Reference)")
  • Category="Game"

static FHitResult MakeHitResult ( bool bBlockingHit,
bool bInitialOverlap,
float Time,
float Distance,
FVector Location,
FVector ImpactPoint,
FVector Normal,
FVector ImpactNormal,
UPhysicalMaterial* PhysMat,
AActor* HitActor,
UPrimitiveComponent* HitComponent,
FName HitBoneName,
FName BoneName,
int32 HitItem,
int32 ElementIndex,
int32 FaceIndex,
FVector TraceStart,
FVector TraceEnd
)

 Create a HitResult struct Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Collision"
  • Meta=(NativeMakeFunc, AdvancedDisplay="2", Normal="0,0,1", ImpactNormal="0,0,1")

static bool ObjectIsA ( const UObject* Object,
TSubclassOf< UObject > ObjectClass
)

 Returns whether or not the object passed in is of (or inherits from) the class type. Kismet/GameplayStatics.h
  • BlueprintPure
  • Meta=(DisplayName="IsA")
  • Category="Utilities"

static void OpenLevel ( const UObject* WorldContextObject,
FName LevelName,
bool bAbsolute,
FString Options
)

 Travel to another level Kismet/GameplayStatics.h
  • BlueprintCallable
  • Meta=(WorldContext="WorldContextObject", AdvancedDisplay="2", DisplayName="Open Level (by Name)")
  • Category="Game"

static void OpenLevelBySoftObjectPtr ( const UObject* WorldContextObject,
const TSoftObjectPtr< UWorld > Level,
bool bAbsolute,
FString Options
)

 Travel to another level Kismet/GameplayStatics.h
  • BlueprintCallable
  • Meta=(WorldContext="WorldContextObject", AdvancedDisplay="2", DisplayName="Open Level (by Object Reference)")
  • Category="Game"

static FString ParseOption ( FString Options,
const FString& Key
)

 Find an option in the options string and return it. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game Options"
  • Meta=(BlueprintThreadSafe)

static void PlayDialogue2D ( const UObject* WorldContextObject,
UDialogueWave* Dialogue,
const FDialogueContext& Context,
float VolumeMultiplier,
float PitchMultiplier,
float StartTime
)

 Plays a dialogue directly with no attenuation, perfect for UI. Kismet/GameplayStatics.h
  • BlueprintCallable
  • BlueprintCosmetic
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject", AdvancedDisplay="3", UnsafeDuringActorConstruction="true")

static void PlayDialogueAtLocation ( const UObject* WorldContextObject,
UDialogueWave* Dialogue,
const FDialogueContext& Context,
FVector Location,
FRotator Rotation,
float VolumeMultiplier,
float PitchMultiplier,
float StartTime,
USoundAttenuation* AttenuationSettings
)

 Plays a dialogue at the given location. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject", AdvancedDisplay="4", UnsafeDuringActorConstruction="true")

static void PlayDialogueAtLocation ( const UObject* WorldContextObject,
UDialogueWave* Dialogue,
const FDialogueContext& Context,
FVector Location,
float VolumeMultiplier,
float PitchMultiplier,
float StartTime,
USoundAttenuation* AttenuationSettings
)

   Kismet/GameplayStatics.h  

static void PlaySound2D ( const UObject* WorldContextObject,
USoundBase* Sound,
float VolumeMultiplier,
float PitchMultiplier,
float StartTime,
USoundConcurrency* ConcurrencySettings,
const AActor* OwningActor,
bool bIsUISound
)

 Plays a sound directly with no attenuation, perfect for UI sounds. Kismet/GameplayStatics.h
  • BlueprintCallable
  • BlueprintCosmetic
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject", AdvancedDisplay="2", UnsafeDuringActorConstruction="true")

static void PlaySoundAtLocation ( const UObject* WorldContextObject,
USoundBase* Sound,
FVector Location,
float VolumeMultiplier,
float PitchMultiplier,
float StartTime,
USoundAttenuation* AttenuationSettings,
USoundConcurrency* ConcurrencySettings,
const UInitialActiveSoundParams* InitialParams
)

   Kismet/GameplayStatics.h  

static void PlaySoundAtLocation ( const UObject* WorldContextObject,
USoundBase* Sound,
FVector Location,
FRotator Rotation,
float VolumeMultiplier,
float PitchMultiplier,
float StartTime,
USoundAttenuation* AttenuationSettings,
USoundConcurrency* ConcurrencySettings,
const AActor* OwningActor,
const UInitialActiveSoundParams* InitialParams
)

 Plays a sound at the given location. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject", AdvancedDisplay="3", UnsafeDuringActorConstruction="true", Keywords="play")

static void PlayWorldCameraShake ( const UObject* WorldContextObject,
TSubclassOf< class UCameraShakeBase > Shake,
FVector Epicenter,
float InnerRadius,
float OuterRadius,
float Falloff,
bool bOrientShakeTowardsEpicenter
)

 Plays an in-world camera shake that affects all nearby local players, with distance-based attenuation. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Camera"
  • Meta=(WorldContext="WorldContextObject", UnsafeDuringActorConstruction="true")

static void PopSoundMixModifier ( const UObject* WorldContextObject,
USoundMix* InSoundMixModifier
)

 Pop a sound mix modifier from the audio system Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject")

static bool PredictProjectilePath ( const UObject* WorldContextObject,
const FPredictProjectilePathParams& PredictParams,
FPredictProjectilePathResult& PredictResult
)

 Predict the arc of a virtual projectile affected by gravity with collision checks along the arc. Kismet/GameplayStatics.h  

static void PrimeAllSoundsInSoundClass ( USoundClass* InSoundClass
)

 Primes the sound waves in the given USoundClass, caching the first chunk of streamed audio. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"

static void PrimeSound ( USoundBase* InSound
)

 Primes the sound, caching the first chunk of streamed audio. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"

static bool ProjectWorldToScreen ( APlayerController const* Player,
const FVector& WorldPosition,
FVector2D& ScreenPosition,
bool bPlayerViewportRelative
)

 Transforms the given 3D world-space point into a its 2D screen space coordinate. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Camera"

static void PushSoundMixModifier ( const UObject* WorldContextObject,
USoundMix* InSoundMixModifier
)

 Push a sound mix modifier onto the audio system Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject")

static FVector RebaseLocalOriginOntoZero ( UObject* WorldContextObject,
FVector WorldLocation
)

 Returns origin based position for local world location. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game"
  • Meta=(WorldContext="WorldContextObject")

static FVector RebaseZeroOriginOntoLocal ( UObject* WorldContextObject,
FVector WorldLocation
)

 Returns local location for origin based position. Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Game"
  • Meta=(WorldContext="WorldContextObject")

static void RemovePlayer ( APlayerController* Player,
bool bDestroyPawn
)

 Removes a local player from this game. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Game"
  • Meta=(DisplayName="Remove Local Player", UnsafeDuringActorConstruction="true")

static bool SaveDataToSlot ( const TArray< uint8 >& InSaveData,
const FString& SlotName,
const int32 UserIndex
)

 Save the contents of the buffer to a platform-specific save slot/file Kismet/GameplayStatics.h  

static bool SaveGameToMemory ( USaveGame* SaveGameObject,
TArray< uint8 >& OutSaveData
)

 Serialize our USaveGame object into a given array of bytes Kismet/GameplayStatics.h  

static bool SaveGameToSlot ( USaveGame* SaveGameObject,
const FString& SlotName,
const int32 UserIndex
)

 Save the contents of the SaveGameObject to a platform-specific save slot/file. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="SaveGame"

static bool SetActiveSpatialPluginByName ( const UObject* WorldContextObject,
FName InPluginName
)

 Get list of available Audio Spatialization Plugins Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject")

static void SetBaseSoundMix ( const UObject* WorldContextObject,
USoundMix* InSoundMix
)

 Audio Functions ------------------------- Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject")

static void SetEnableWorldRendering ( const UObject* WorldContextObject,
bool bEnable
)

 Enabled rendering of the world Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Rendering"
  • Meta=(WorldContext="WorldContextObject")

static void SetForceDisableSplitscreen ( const UObject* WorldContextObject,
bool bDisable
)

 Enables split screen Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Viewport"
  • Meta=(WorldContext="WorldContextObject")

static bool SetGamePaused ( const UObject* WorldContextObject,
bool bPaused
)

 Sets the game's paused state Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Game"
  • Meta=(WorldContext="WorldContextObject")

static void SetGlobalListenerFocusParameters ( const UObject* WorldContextObject,
float FocusAzimuthScale,
float NonFocusAzimuthScale,
float FocusDistanceScale,
float NonFocusDistanceScale,
float FocusVolumeScale,
float NonFocusVolumeScale,
float FocusPriorityScale,
float NonFocusPriorityScale
)

 Sets the global listener focus parameters, which will scale focus behavior of sounds based on their focus azimuth settings in their attenuation settings. Kismet/GameplayStatics.h
  • BlueprintCallable
  • BlueprintCosmetic
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject")

static void SetGlobalPitchModulation ( const UObject* WorldContextObject,
float PitchModulation,
float TimeSec
)

 Sets a global pitch modulation scalar that will apply to all non-UI sounds Kismet/GameplayStatics.h
  • BlueprintCallable
  • BlueprintCosmetic
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject")

static void SetGlobalTimeDilation ( const UObject* WorldContextObject,
float TimeDilation
)

 Sets the global time dilation. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Utilities|Time"
  • Meta=(WorldContext="WorldContextObject")

static void SetMaxAudioChannelsScaled ( const UObject* WorldContextObject,
float MaxChannelCountScale
)

 Sets the max number of voices (also known as "channels") dynamically by percentage. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject")

static void SetPlayerControllerID ( APlayerController* Player,
int32 ControllerId
)

 Sets what physical controller ID a player should be using. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Game"
  • Meta=(DisplayName="Set Local Player Controller ID", UnsafeDuringActorConstruction="true")

static void SetPlayerPlatformUserId ( APlayerController* PlayerController,
FPlatformUserId UserId
)

 Sets what platform user id a player should be using. This only works for local player controllers. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Game"
  • Meta=(DisplayName="Set Local Player Controller Platform User Id", UnsafeDuringActorConstruction="true")

static void SetSoundClassDistanceScale ( const UObject* WorldContextObject,
USoundClass* SoundClass,
float DistanceAttenuationScale,
float TimeSec
)

 Linearly interpolates the attenuation distance scale value from it's current attenuation distance override value (1.0f it not overridden) to its new attenuation distance override, over the given amount of time Kismet/GameplayStatics.h
  • BlueprintCallable
  • BlueprintCosmetic
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject")

static void SetSoundMixClassOverride ( const UObject* WorldContextObject,
USoundMix* InSoundMixModifier,
USoundClass* InSoundClass,
float Volume,
float Pitch,
float FadeInTime,
bool bApplyToChildren
)

 Overrides the sound class adjuster in the given sound mix. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject")

static void SetSubtitlesEnabled ( bool bEnabled
)

 Will set subtitles to be enabled or disabled. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio|Subtitles"

static void SetViewportMouseCaptureMode ( const UObject* WorldContextObject,
const EMouseCaptureMode MouseCaptureMode
)

 Sets the current viewport mouse capture mode Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Viewport"
  • Meta=(WorldContext="WorldContextObject")

static void SetWorldOriginLocation ( const UObject* WorldContextObject,
FIntVector NewLocation
)

 Requests a new location for a world origin. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Game"
  • Meta=(WorldContext="WorldContextObject")

static UDecalComponent * SpawnDecalAtLocation ( const UObject* WorldContextObject,
UMaterialInterface* DecalMaterial,
FVector DecalSize,
FVector Location,
FRotator Rotation,
float LifeSpan
)

 Spawns a decal at the given location and rotation, fire and forget. Does not replicate. Kismet/GameplayStatics.h
  • BlueprintCallable
  • BlueprintCosmetic
  • Category="Rendering|Decal"
  • Meta=(WorldContext="WorldContextObject", UnsafeDuringActorConstruction="true")

static UDecalComponent * SpawnDecalAttached ( UMaterialInterface* DecalMaterial,
FVector DecalSize,
USceneComponent* AttachToComponent,
FName AttachPointName,
FVector Location,
FRotator Rotation,
EAttachLocation::Type LocationType,
float LifeSpan
)

 Spawns a decal attached to and following the specified component. Does not replicate. Kismet/GameplayStatics.h
  • BlueprintCallable
  • BlueprintCosmetic
  • Category="Rendering|Decal"
  • Meta=(UnsafeDuringActorConstruction="true")

static UAudioComponent * SpawnDialogue2D ( const UObject* WorldContextObject,
UDialogueWave* Dialogue,
const FDialogueContext& Context,
float VolumeMultiplier,
float PitchMultiplier,
float StartTime,
bool bAutoDestroy
)

 Spawns a DialogueWave, a special type of Asset that requires Context data in order to resolve a specific SoundBase, which is then passed on to the new Audio Component. Kismet/GameplayStatics.h
  • BlueprintCallable
  • BlueprintCosmetic
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject", AdvancedDisplay="3", UnsafeDuringActorConstruction="true", Keywords="play")

static UAudioComponent * SpawnDialogueAtLocation ( const UObject* WorldContextObject,
UDialogueWave* Dialogue,
const FDialogueContext& Context,
FVector Location,
FRotator Rotation,
float VolumeMultiplier,
float PitchMultiplier,
float StartTime,
USoundAttenuation* AttenuationSettings,
bool bAutoDestroy
)

 Spawns a DialogueWave, a special type of Asset that requires Context data in order to resolve a specific SoundBase, which is then passed on to the new Audio Component. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject", AdvancedDisplay="4", UnsafeDuringActorConstruction="true", Keywords="play")

static UAudioComponent * SpawnDialogueAttached ( UDialogueWave* Dialogue,
const FDialogueContext& Context,
USceneComponent* AttachToComponent,
FName AttachPointName,
FVector Location,
FRotator Rotation,
EAttachLocation::Type LocationType,
bool bStopWhenAttachedToDestroyed,
float VolumeMultiplier,
float PitchMultiplier,
float StartTime,
USoundAttenuation* AttenuationSettings,
bool bAutoDestroy
)

 Spawns a DialogueWave, a special type of Asset that requires Context data in order to resolve a specific SoundBase, which is then passed on to the new Audio Component. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(AdvancedDisplay="2", UnsafeDuringActorConstruction="true", Keywords="play")

static UAudioComponent * SpawnDialogueAttached ( UDialogueWave* Dialogue,
const FDialogueContext& Context,
USceneComponent* AttachToComponent,
FName AttachPointName,
FVector Location,
EAttachLocation::Type LocationType,
bool bStopWhenAttachedToDestroyed,
float VolumeMultiplier,
float PitchMultiplier,
float StartTime,
USoundAttenuation* AttenuationSettings,
bool bAutoDestroy
)

   Kismet/GameplayStatics.h  

static UParticleSystemComponent * SpawnEmitterAtLocation ( const UObject* WorldContextObject,
UParticleSystem* EmitterTemplate,
FVector Location,
FRotator Rotation,
FVector Scale,
bool bAutoDestroy,
EPSCPoolMethod PoolingMethod,
bool bAutoActivateSystem
)

 Plays the specified effect at the given location and rotation, fire and forget. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Effects"
  • Meta=(Keywords="particle system", WorldContext="WorldContextObject", UnsafeDuringActorConstruction="true")

static UParticleSystemComponent * SpawnEmitterAtLocation ( const UObject* WorldContextObject,
UParticleSystem* EmitterTemplate,
FVector Location,
FRotator Rotation,
bool bAutoDestroy,
EPSCPoolMethod PoolingMethod,
bool bAutoActivateSystem
)

 Backwards compatible version of SpawnEmitterAttached for C++ without Scale. Kismet/GameplayStatics.h  

static UParticleSystemComponent * SpawnEmitterAtLocation ( UWorld* World,
UParticleSystem* EmitterTemplate,
const FTransform& SpawnTransform,
bool bAutoDestroy,
EPSCPoolMethod PoolingMethod,
bool bAutoActivate
)

 Plays the specified effect at the given location and rotation, fire and forget. Kismet/GameplayStatics.h  

static UParticleSystemComponent * SpawnEmitterAttached ( UParticleSystem* EmitterTemplate,
USceneComponent* AttachToComponent,
FName AttachPointName,
FVector Location,
FRotator Rotation,
FVector Scale,
EAttachLocation::Type LocationType,
bool bAutoDestroy,
EPSCPoolMethod PoolingMethod,
bool bAutoActivate
)

 Plays the specified effect attached to and following the specified component. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Effects"
  • Meta=(Keywords="particle system", UnsafeDuringActorConstruction="true")

static UParticleSystemComponent * SpawnEmitterAttached ( UParticleSystem* EmitterTemplate,
USceneComponent* AttachToComponent,
FName AttachPointName,
FVector Location,
FRotator Rotation,
EAttachLocation::Type LocationType,
bool bAutoDestroy,
EPSCPoolMethod PoolingMethod,
bool bAutoActivate
)

 Backwards compatible version of SpawnEmitterAttached for C++ without Scale. Kismet/GameplayStatics.h  

static UForceFeedbackComponent * SpawnForceFeedbackAtLocation ( const UObject* WorldContextObject,
UForceFeedbackEffect* ForceFeedbackEffect,
FVector Location,
FRotator Rotation,
bool bLooping,
float IntensityMultiplier,
float StartTime,
UForceFeedbackAttenuation* AttenuationSettings,
bool bAutoDestroy
)

 Plays a force feedback effect at the given location. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="ForceFeedback"
  • Meta=(WorldContext="WorldContextObject", AdvancedDisplay="3", UnsafeDuringActorConstruction="true", Keywords="play")

static UForceFeedbackComponent * SpawnForceFeedbackAttached ( UForceFeedbackEffect* ForceFeedbackEffect,
USceneComponent* AttachToComponent,
FName AttachPointName,
FVector Location,
FRotator Rotation,
EAttachLocation::Type LocationType,
bool bStopWhenAttachedToDestroyed,
bool bLooping,
float IntensityMultiplier,
float StartTime,
UForceFeedbackAttenuation* AttenuationSettings,
bool bAutoDestroy
)

 Plays a force feedback effect attached to and following the specified component. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="ForceFeedback"
  • Meta=(AdvancedDisplay="2", UnsafeDuringActorConstruction="true", Keywords="play")

static UObject * SpawnObject ( TSubclassOf< UObject > ObjectClass,
UObject* Outer
)

 Create Object Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Spawning"
  • Meta=(BlueprintInternalUseOnly="true", DefaultToSelf="Outer")

static UAudioComponent * SpawnSound2D ( const UObject* WorldContextObject,
USoundBase* Sound,
float VolumeMultiplier,
float PitchMultiplier,
float StartTime,
USoundConcurrency* ConcurrencySettings,
bool bPersistAcrossLevelTransition,
bool bAutoDestroy
)

 This function allows users to create Audio Components with settings specifically for non-spatialized, non-distance-attenuated sounds. Kismet/GameplayStatics.h
  • BlueprintCallable
  • BlueprintCosmetic
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject", AdvancedDisplay="2", UnsafeDuringActorConstruction="true", Keywords="play")

static UAudioComponent * SpawnSoundAtLocation ( const UObject* WorldContextObject,
USoundBase* Sound,
FVector Location,
FRotator Rotation,
float VolumeMultiplier,
float PitchMultiplier,
float StartTime,
USoundAttenuation* AttenuationSettings,
USoundConcurrency* ConcurrencySettings,
bool bAutoDestroy
)

 Spawns a sound at the given location. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(WorldContext="WorldContextObject", AdvancedDisplay="3", UnsafeDuringActorConstruction="true", Keywords="play")

static UAudioComponent * SpawnSoundAttached ( USoundBase* Sound,
USceneComponent* AttachToComponent,
FName AttachPointName,
FVector Location,
FRotator Rotation,
EAttachLocation::Type LocationType,
bool bStopWhenAttachedToDestroyed,
float VolumeMultiplier,
float PitchMultiplier,
float StartTime,
USoundAttenuation* AttenuationSettings,
USoundConcurrency* ConcurrencySettings,
bool bAutoDestroy
)

 This function allows users to create and play Audio Components attached to a specific Scene Component. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"
  • Meta=(AdvancedDisplay="2", UnsafeDuringActorConstruction="true", Keywords="play")

static UAudioComponent * SpawnSoundAttached ( USoundBase* Sound,
USceneComponent* AttachToComponent,
FName AttachPointName,
FVector Location,
EAttachLocation::Type LocationType,
bool bStopWhenAttachedToDestroyed,
float VolumeMultiplier,
float PitchMultiplier,
float StartTime,
USoundAttenuation* AttenuationSettings,
USoundConcurrency* ConcurrencySettings,
bool bAutoDestroy
)

   Kismet/GameplayStatics.h  

static FMemoryReader StripSaveGameHeader ( const TArray< uint8 >& SaveData
)

 Takes the provided buffer and consumes it, parsing past the internal header data, returning a MemoryReader that has: 1) been set up with all the related header information, and 2) offset to where tagged USaveGame object serialization begins. NOTE: that the returned object has a reference to the supplied data - scope them accordingly. Kismet/GameplayStatics.h  

static bool SuggestProjectileVelocity ( const UObject* WorldContextObject,
FVector& TossVelocity,
FVector StartLocation,
FVector EndLocation,
float TossSpeed,
bool bHighArc,
float CollisionRadius,
float OverrideGravityZ,
ESuggestProjVelocityTraceOption::Type TraceOption,
FCollisionResponseParams& ResponseParam,
TArray< AActor* > ActorsToIgnore,
bool bDrawDebug,
bool bAcceptClosestOnNoSolutions
)

   Kismet/GameplayStatics.h  

static bool SuggestProjectileVelocity ( const FSuggestProjectileVelocityParameters& ProjectileParams,
FVector& OutTossVelocity
)

 Native version, has more options than the Blueprint version. Kismet/GameplayStatics.h  

static bool SuggestProjectileVelocity_CustomArc ( const UObject* WorldContextObject,
FVector& OutLaunchVelocity,
FVector StartPos,
FVector EndPos,
float OverrideGravityZ,
float ArcParam
)

 Returns the launch velocity needed for a projectile at rest at StartPos to land on EndPos. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Game"
  • DisplayName="Suggest Projectile Velocity Custom Arc"
  • Meta=(WorldContext="WorldContextObject", AdvancedDisplay="OverrideGravityZ, ArcParam")

static bool SuggestProjectileVelocity_MovingTarget ( const UObject* WorldContextObject,
FVector& OutLaunchVelocity,
FVector ProjectileStartLocation,
AActor* TargetActor,
FVector TargetLocationOffset,
double GravityZOverride,
double TimeToTarget,
EDrawDebugTrace::Type DrawDebugType,
float DrawDebugTime,
FLinearColor DrawDebugColor
)

 Returns a launch velocity need for a projectile to hit the TargetActor in TimeToTarget seconds based on the TargetActor's current velocity. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Game"
  • DisplayName="Suggest Projectile Velocity Moving Target"
  • Meta=(WorldContext="WorldContextObject", AdvancedDisplay="DrawDebugType, DrawDebugTime, DrawDebugColor")

static FVector TransformWorldToFirstPerson ( const FMinimalViewInfo& ViewInfo,
const FVector& WorldPosition,
bool bIgnoreFirstPersonScale
)

 Transforms a world space location into "first person space". Kismet/GameplayStatics.h
  • BlueprintPure
  • Category="Camera"

static void UnloadStreamLevel ( const UObject* WorldContextObject,
FName LevelName,
FLatentActionInfo LatentInfo,
bool bShouldBlockOnUnload
)

 Unload a streamed in level (by Name) Kismet/GameplayStatics.h
  • BlueprintCallable
  • Meta=(WorldContext="WorldContextObject", Latent="", LatentInfo="LatentInfo", DisplayName="Unload Stream Level (by Name)")
  • Category="Game"

static void UnloadStreamLevelBySoftObjectPtr ( const UObject* WorldContextObject,
const TSoftObjectPtr< UWorld > Level,
FLatentActionInfo LatentInfo,
bool bShouldBlockOnUnload
)

 Unload a streamed in level (by Object Reference) Kismet/GameplayStatics.h
  • BlueprintCallable
  • Meta=(WorldContext="WorldContextObject", Latent="", LatentInfo="LatentInfo", DisplayName="Unload Stream Level (by Object Reference)")
  • Category="Game"

static void UnRetainAllSoundsInSoundClass ( USoundClass* InSoundClass
)

 Iterate through all sound waves and releases handles to retained chunks. Kismet/GameplayStatics.h
  • BlueprintCallable
  • Category="Audio"

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page