Actor.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Stats/Stats.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectBaseUtility.h"
#include "UObject/Object.h"
#include "InputCoreTypes.h"
#include "Templates/Requires.h"
#include "Templates/SubclassOf.h"
#include "Engine/EngineTypes.h"
#include "Engine/EngineBaseTypes.h"
#include "PropertyPairsMap.h"
#include "Components/ChildActorComponent.h"
#include "RenderCommandFence.h"
#include "Net/Core/Misc/NetSubObjectRegistry.h"
#include "Engine/ReplicatedState.h"
 
#include <atomic>
 
#if WITH_EDITOR
#include "Folder.h"
#endif
 
#include "WorldPartition/WorldPartitionActorDescType.h"
 
#include "Actor.generated.h"
 
class AActor;
class AController;
class APawn;
class APlayerController;
class UActorChannel;
class UChildActorComponent;
class UNetDriver;
class UPrimitiveComponent;
struct FAttachedActorInfo;
struct FNetViewer;
struct FNetworkObjectInfo;
class FActorTransactionAnnotation;
class FComponentInstanceDataCache;
struct FWorldRenameFromRootContext;
class UDEPRECATED_DataLayer;
class UDataLayerAsset;
class UExternalDataLayerAsset;
class UDataLayerInstance;
class AWorldDataLayers;
class IWorldPartitionCell;
struct FActorReplicationParams;
struct FStopReplicatingActorParams;
class UActorFolder;
struct FActorDataLayer;
struct FHitResult;
 
namespace UE::Net
{
    class FTearOffSetter;
    struct FReplicationSystemUtil;
}
 
// By default, debug and development builds (even cooked) will keep actor labels. Manually define this if you want to make a local build
// that keep actor labels for Test or Shipping builds.
#ifndef ACTOR_HAS_LABELS
#define ACTOR_HAS_LABELS (UE_BUILD_DEBUG || UE_BUILD_DEVELOPMENT || WITH_PROFILEGPU)
#endif
 
UENUM(BlueprintType)
enum class EActorUpdateOverlapsMethod : uint8
{
    // Use the default value specified by the native class or config value.
    UseConfigDefault,
    // Always update overlap state on initialization.
    AlwaysUpdate,
    // Only update if root component has Movable mobility.
    OnlyUpdateMovable,
    // Never update overlap state on initialization.
    NeverUpdate
};
 
UENUM(BlueprintType)
enum class ESpawnActorScaleMethod : uint8
{
    OverrideRootScale                       UMETA(DisplayName = "Override Root Component Scale"),
    MultiplyWithRoot                        UMETA(DisplayName = "Multiply Scale With Root Component Scale"),
    SelectDefaultAtRuntime                  UMETA(Hidden),
};
 
UENUM()
enum class ELevelInstanceType : uint8
{
    None,
    LevelInstance,
    LevelInstanceEdit,
    LevelInstancePropertyOverride
};
 
UENUM()
enum class ELevelInstanceFlags : uint8
{
    None = 0,
    IsInEditHierarchy = 1,
    HasPropertyOverrides = 2,
    HasEditablePropertyOverrides = 4 
};
 
ENUM_CLASS_FLAGS(ELevelInstanceFlags)
 
#if WITH_EDITORONLY_DATA
UENUM()
enum class UE_DEPRECATED(5.0, "EActorGridPlacement is deprecated.") EActorGridPlacement : uint8
{
    // Actor uses its bounds to determine in which runtime cells it's going to be placed.
    Bounds,
    // Actor uses its location to determine in which runtime cells it's going to be placed.
    Location,
    // Actor is always loaded (not placed in the grid), also affects editor.
    AlwaysLoaded,
    None UMETA(Hidden)
};
#endif
 
struct FActorLastRenderTime
{
    UE_DEPRECATED(5.6, "Use GetLastRenderTime/SetLastRenderTime instead.")
    std::atomic<float> LastRenderTime;
 
    void SetLastRenderTime(float InLastRenderTime)
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        LastRenderTime.store(InLastRenderTime, std::memory_order_relaxed);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    float GetLastRenderTime() const
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return LastRenderTime.load(std::memory_order_relaxed);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    std::atomic_int32_t NumAlwaysVisibleComponents = 0;
 
private:
    static void Set(AActor* InActor, float LastRenderTime);
    static FActorLastRenderTime* GetPtr(AActor* InActor);
 
    friend class UPrimitiveComponent;
    friend struct FPrimitiveSceneInfoAdapter;
};
 
ENGINE_API DECLARE_LOG_CATEGORY_EXTERN(LogActor, Log, All);
 
// Delegate signatures
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_FiveParams( FTakeAnyDamageSignature, AActor, OnTakeAnyDamage, AActor*, DamagedActor, float, Damage, const class UDamageType*, DamageType, class AController*, InstigatedBy, AActor*, DamageCauser );
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_NineParams( FTakePointDamageSignature, AActor, OnTakePointDamage, AActor*, DamagedActor, float, Damage, class AController*, InstigatedBy, FVector, HitLocation, class UPrimitiveComponent*, FHitComponent, FName, BoneName, FVector, ShotFromDirection, const class UDamageType*, DamageType, AActor*, DamageCauser );
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_SevenParams( FTakeRadialDamageSignature, AActor, OnTakeRadialDamage, AActor*, DamagedActor, float, Damage, const class UDamageType*, DamageType, FVector, Origin, const FHitResult&, HitInfo, class AController*, InstigatedBy, AActor*, DamageCauser );
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams( FActorBeginOverlapSignature, AActor, OnActorBeginOverlap, AActor*, OverlappedActor, AActor*, OtherActor );
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams( FActorEndOverlapSignature, AActor, OnActorEndOverlap, AActor*, OverlappedActor, AActor*, OtherActor );
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_FourParams( FActorHitSignature, AActor, OnActorHit, AActor*, SelfActor, AActor*, OtherActor, FVector, NormalImpulse, const FHitResult&, Hit );
 
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_OneParam( FActorBeginCursorOverSignature, AActor, OnBeginCursorOver, AActor*, TouchedActor );
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_OneParam( FActorEndCursorOverSignature, AActor, OnEndCursorOver, AActor*, TouchedActor );
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams( FActorOnClickedSignature, AActor, OnClicked, AActor*, TouchedActor , FKey, ButtonPressed );
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams( FActorOnReleasedSignature, AActor, OnReleased, AActor*, TouchedActor , FKey, ButtonReleased );
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams( FActorOnInputTouchBeginSignature, AActor, OnInputTouchBegin, ETouchIndex::Type, FingerIndex, AActor*, TouchedActor );
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams( FActorOnInputTouchEndSignature, AActor, OnInputTouchEnd, ETouchIndex::Type, FingerIndex, AActor*, TouchedActor );
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams( FActorBeginTouchOverSignature, AActor, OnInputTouchEnter, ETouchIndex::Type, FingerIndex, AActor*, TouchedActor );
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams( FActorEndTouchOverSignature, AActor, OnInputTouchLeave, ETouchIndex::Type, FingerIndex, AActor*, TouchedActor );
 
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_OneParam(FActorDestroyedSignature, AActor, OnDestroyed, AActor*, DestroyedActor );
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams(FActorEndPlaySignature, AActor, OnEndPlay, AActor*, Actor , EEndPlayReason::Type, EndPlayReason);
 
DECLARE_DELEGATE_SixParams(FMakeNoiseDelegate, AActor*, float /*Loudness*/, class APawn*, const FVector&, float /*MaxRange*/, FName /*Tag*/);
 
#if WITH_EDITOR
DECLARE_EVENT_TwoParams(AActor, FActorOnPackagingModeChanged, AActor*, bool /* bExternal */);
 
using FReplacementComponentMap = TMap<UObject*, UObject*>;
DECLARE_MULTICAST_DELEGATE_OneParam(FActorOnComponentsReplaced, const FReplacementComponentMap&);
#endif
 
#if !UE_BUILD_SHIPPING
DECLARE_DELEGATE_RetVal_ThreeParams(bool, FOnProcessEvent, AActor*, UFunction*, void*);
#endif
 
template<class T, uint32 NumElements = NumInlinedActorComponents>
class TInlineComponentArray : public TArray<T, TInlineAllocator<NumElements>>
{
    typedef TArray<T, TInlineAllocator<NumElements>> Super;
 
public:
    TInlineComponentArray() : Super() { }
    TInlineComponentArray(const AActor* Actor, bool bIncludeFromChildActors = false);
};
 
template<class T, uint32 NumElements>
struct TIsContiguousContainer<TInlineComponentArray<T, NumElements>>
{
    enum { Value = true };
};
 
UCLASS(BlueprintType, Blueprintable, config=Engine, meta=(ShortTooltip="An Actor is an object that can be placed or spawned in the world."), MinimalAPI)
class AActor : public UObject
{
    GENERATED_BODY()
 
public:
    ENGINE_API AActor();
 
    ENGINE_API AActor(const FObjectInitializer& ObjectInitializer);
 
private:
    ENGINE_API void InitializeDefaults();
 
public:
    ENGINE_API virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
 
    ENGINE_API virtual void GetReplicatedCustomConditionState(FCustomPropertyConditionState& OutActiveState) const override;
 
    UPROPERTY(EditDefaultsOnly, Category=Tick)
    struct FActorTickFunction PrimaryActorTick;
 
    UPROPERTY()
    uint8 bNetTemporary:1;
 
    uint8 bNetStartup:1;
 
    UPROPERTY(Category=Replication, EditDefaultsOnly, BlueprintReadOnly)
    uint8 bOnlyRelevantToOwner:1;
 
    UPROPERTY(Category=Replication, EditDefaultsOnly, BlueprintReadWrite)
    uint8 bAlwaysRelevant:1;    
 
    UFUNCTION()
    ENGINE_API virtual void OnRep_ReplicateMovement();
 
#if WITH_EDITOR
    virtual bool ShouldDuplicateInPIE() const { return !bIgnoreInPIE; }
#endif
 
private:
    UPROPERTY(ReplicatedUsing=OnRep_ReplicateMovement, Category=Replication, EditDefaultsOnly)
    uint8 bReplicateMovement:1;    
 
    UPROPERTY(EditDefaultsOnly, Category = Replication, AdvancedDisplay)
    uint8 bCallPreReplication:1;
 
    UPROPERTY(EditDefaultsOnly, Category = Replication, AdvancedDisplay)
    uint8 bCallPreReplicationForReplay:1;
 
    UPROPERTY(Interp, EditAnywhere, Category=Rendering, BlueprintReadOnly, Replicated, meta=(AllowPrivateAccess="true", DisplayName="Actor Hidden In Game", SequencerTrackClass="/Script/MovieSceneTracks.MovieSceneVisibilityTrack"))
    uint8 bHidden:1;
 
    UPROPERTY(Replicated)
    uint8 bTearOff:1;
 
    friend class UE::Net::FTearOffSetter;
 
    UPROPERTY()
    uint8 bForceNetAddressable:1;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(Transient, NonTransactional)
    ELevelInstanceType LevelInstanceType;
 
    UPROPERTY(Transient, NonTransactional)
    ELevelInstanceFlags LevelInstanceFlags;
 
    friend struct FSetActorIsInLevelInstance;
    friend struct FAddActorLevelInstanceFlags;
    friend struct FRemoveActorLevelInstanceFlags;
 
public:
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = LevelInstance, meta = (Tooltip = "If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances."))
    uint8 bIsMainWorldOnly : 1;
 
    UPROPERTY(Transient)
    uint8 bIgnoreInPIE : 1;
 
private:
#endif
 
    ENGINE_API bool ShouldCallPreReplication() const;
 
    ENGINE_API bool ShouldCallPreReplicationForReplay() const;
 
public:
    ENGINE_API void SetCallPreReplication(bool bCall);
 
    ENGINE_API void SetCallPreReplicationForReplay(bool bCall);
 
    bool GetTearOff() const
    {
        return bTearOff;
    }
 
#if WITH_EDITOR
    UE_DEPRECATED(5.4, "Call IsInEditLevelInstanceHierarchy/IsInEditLevelInstance instead.")
    virtual bool IsInEditingLevelInstance() const
    {
        return IsInEditLevelInstance();
    }
 
    bool IsInAnyEditLevelInstance() const
    {
        return IsInEditLevelInstance() || IsInPropertyOverrideLevelInstance();
    }
 
    bool IsInEditLevelInstance() const
    {
        return LevelInstanceType == ELevelInstanceType::LevelInstanceEdit;
    }
 
    bool IsInPropertyOverrideLevelInstance() const
    {
        return LevelInstanceType == ELevelInstanceType::LevelInstancePropertyOverride;
    }
 
    bool IsInEditLevelInstanceHierarchy() const
    {
        return EnumHasAnyFlags(LevelInstanceFlags, ELevelInstanceFlags::IsInEditHierarchy);
    }
 
    bool HasLevelInstancePropertyOverrides() const
    {
        return EnumHasAnyFlags(LevelInstanceFlags, ELevelInstanceFlags::HasPropertyOverrides);
    }
 
    bool HasEditableLevelLevelInstancePropertyOverrides() const
    {
        return EnumHasAnyFlags(LevelInstanceFlags, ELevelInstanceFlags::HasEditablePropertyOverrides);
    }
 
    bool IsInLevelInstance() const
    {
        return LevelInstanceType != ELevelInstanceType::None;
    }
#endif
 
    UFUNCTION(BlueprintCallable, Category=Networking)
    ENGINE_API virtual void TearOff();
 
    UPROPERTY(Transient)
    uint8 bExchangedRoles:1;
 
    UPROPERTY(Category=Replication, EditAnywhere)
    uint8 bNetLoadOnClient:1;
 
    UPROPERTY(Category=Replication, EditDefaultsOnly, BlueprintReadWrite)
    uint8 bNetUseOwnerRelevancy:1;
 
    UPROPERTY()
    uint8 bRelevantForNetworkReplays:1;
 
    UPROPERTY(EditAnywhere, Category=Collision, AdvancedDisplay)
    uint8 bRelevantForLevelBounds:1;
 
    UPROPERTY(Category=Replication, EditDefaultsOnly, AdvancedDisplay)
    uint8 bReplayRewindable:1;
 
    UPROPERTY(EditDefaultsOnly, Category=Tick)
    uint8 bAllowTickBeforeBeginPlay:1;
 
private:
    UPROPERTY(BlueprintSetter=SetAutoDestroyWhenFinished, Category=Actor)
    uint8 bAutoDestroyWhenFinished:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, SaveGame, Replicated, Category=Actor, meta=(AllowPrivateAccess="true"))
    uint8 bCanBeDamaged:1;
 
public:
    UPROPERTY(EditDefaultsOnly, Category=Input)
    uint8 bBlockInput:1;
 
    UPROPERTY()
    uint8 bCollideWhenPlacing:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Actor, AdvancedDisplay)
    uint8 bFindCameraComponentWhenViewTarget:1;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Collision)
    uint8 bGenerateOverlapEventsDuringLevelStreaming:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category=Actor)
    uint8 bIgnoresOriginShifting:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=HLOD, meta=(DisplayName="Include Actor in HLOD"))
    uint8 bEnableAutoLODGeneration:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category=Cooking)
    uint8 bIsEditorOnlyActor:1;
 
    uint8 bActorSeamlessTraveled:1;
 
    ENGINE_API virtual bool HasNetOwner() const;
 
    ENGINE_API virtual bool HasLocalNetOwner() const;
 
    bool GetAutoDestroyWhenFinished() const { return bAutoDestroyWhenFinished; }
 
    UFUNCTION(BlueprintSetter)
    ENGINE_API void SetAutoDestroyWhenFinished(bool bVal);
 
protected:
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category=Replication)
    uint8 bReplicates:1;
 
    void SetRemoteRoleForBackwardsCompat(const ENetRole InRemoteRole) { RemoteRole = InRemoteRole; }
 
    UFUNCTION()
    ENGINE_API virtual void OnRep_Owner();
 
    UPROPERTY(Category=Actor, EditAnywhere, AdvancedDisplay)
    uint8 bCanBeInCluster:1;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(Category = Actor, EditAnywhere, AdvancedDisplay)
    uint8 bMigratingAsset : 1;
#endif
 
    UPROPERTY()
    uint8 bAllowReceiveTickEventOnDedicatedServer:1;
 
    uint8 bNetCheckedInitialPhysicsState : 1;
 
    UPROPERTY(Config, EditDefaultsOnly, BlueprintReadOnly, Category=Replication, AdvancedDisplay)
    uint8 bReplicateUsingRegisteredSubObjectList : 1;
 
private:
    friend class FActorDeferredScriptManager;
 
    uint8 bHasFinishedSpawning:1;
 
    uint8 bActorInitialized:1;
 
    uint8 bActorBeginningPlayFromLevelStreaming:1;
 
    uint8 bTickFunctionsRegistered:1;
 
    uint8 bHasDeferredComponentRegistration:1;
 
    uint8 bRunningUserConstructionScript:1;
 
    uint8 bHasPreRegisteredAllComponents : 1;
 
    uint8 bHasRegisteredAllComponents:1;
 
    UPROPERTY()
    uint8 bActorEnableCollision:1;
 
    UPROPERTY(Transient, DuplicateTransient)
    uint8 bActorIsBeingDestroyed:1;
 
    uint8 bActorWantsDestroyDuringBeginPlay : 1;
 
    enum class EActorBeginPlayState : uint8
    {
        HasNotBegunPlay,
        BeginningPlay,
        HasBegunPlay,
    };
 
    EActorBeginPlayState ActorHasBegunPlay:2;
 
    uint8 bActorIsBeingConstructed : 1;
 
    uint8 bActorIsPendingPostNetInit : 1;   
 
    static ENGINE_API uint32 BeginPlayCallDepth;
 
protected:
        
    UPROPERTY(EditAnywhere, Category=Physics)
    uint8 bAsyncPhysicsTickEnabled : 1;
    
    UPROPERTY(Category=Collision, EditAnywhere)
    EActorUpdateOverlapsMethod UpdateOverlapsMethodDuringLevelStreaming;
 
public:
 
    ENGINE_API EActorUpdateOverlapsMethod GetUpdateOverlapsMethodDuringLevelStreaming() const;
 
private:
 
    UPROPERTY(Config, Category = Collision, VisibleAnywhere)
    EActorUpdateOverlapsMethod DefaultUpdateOverlapsMethodDuringLevelStreaming;
 
    ENGINE_API void UpdateInitialOverlaps(bool bFromLevelStreaming);
    
    UPROPERTY(Replicated, Transient, VisibleInstanceOnly, Category=Networking)
    TEnumAsByte<enum ENetRole> RemoteRole;
 
public:
    UFUNCTION(BlueprintCallable, BlueprintAuthorityOnly, Category=Networking)
    ENGINE_API void SetReplicates(bool bInReplicates);
 
    UFUNCTION(BlueprintCallable, Category=Networking)
    ENGINE_API virtual void SetReplicateMovement(bool bInReplicateMovement);
 
    ENGINE_API void SetAutonomousProxy(const bool bInAutonomousProxy, const bool bAllowForcePropertyCompare=true);
    
    ENGINE_API void CopyRemoteRoleFrom(const AActor* CopyFromActor);
 
    UFUNCTION(BlueprintCallable, Category=Networking)
    ENetRole GetLocalRole() const { return Role; }
 
    UFUNCTION(BlueprintCallable, Category=Networking)
    ENetRole GetRemoteRole() const;
 
    ENGINE_API void SetNetAddressable();
 
public:
    uint8 ActorCategory = 0;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Actor)
    float InitialLifeSpan;
 
    UPROPERTY(BlueprintReadWrite, AdvancedDisplay, Category=Actor)
    float CustomTimeDilation;
    
private:
    UPROPERTY()
    int32 RayTracingGroupId;
 
protected:
#if WITH_EDITORONLY_DATA
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    UPROPERTY()
    EActorGridPlacement GridPlacement_DEPRECATED;
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category=WorldPartition)
    FName RuntimeGrid;
#endif
 
    UPROPERTY(Transient, ReplicatedUsing=OnRep_AttachmentReplication)
    struct FRepAttachment AttachmentReplication;
 
private:
    UPROPERTY(EditDefaultsOnly, ReplicatedUsing=OnRep_ReplicatedMovement, Category=Replication, AdvancedDisplay)
    struct FRepMovement ReplicatedMovement;
 
public:
    UPROPERTY(ReplicatedUsing=OnRep_Owner)
    TObjectPtr<AActor> Owner;
 
#if WITH_EDITOR
    TWeakObjectPtr<AActor> IntermediateOwner = nullptr;
#endif
 
protected:
    UPROPERTY()
    FName NetDriverName;
 
public:
    const struct FRepAttachment& GetAttachmentReplication() const { return AttachmentReplication; }
 
    UFUNCTION()
    ENGINE_API virtual void OnRep_AttachmentReplication();
 
private:
    UPROPERTY(Replicated, VisibleInstanceOnly, Category=Networking)
    TEnumAsByte<enum ENetRole> Role;
 
public:
    UPROPERTY(BlueprintReadOnly, EditDefaultsOnly, Category=Replication)
    TEnumAsByte<enum ENetDormancy> NetDormancy;
 
    UE_DEPRECATED(5.3, "Replication pausing is deprecated.")
    ENGINE_API virtual bool IsReplicationPausedForConnection(const FNetViewer& ConnectionOwnerNetViewer);
 
    UE_DEPRECATED(5.3, "Replication pausing is deprecated.")
    ENGINE_API virtual void OnReplicationPausedChanged(bool bIsReplicationPaused);
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Actor)
    ESpawnActorCollisionHandlingMethod SpawnCollisionHandlingMethod;
 
    UPROPERTY(EditAnywhere, Category=Input)
    TEnumAsByte<EAutoReceiveInput::Type> AutoReceiveInput;
 
    UPROPERTY(EditAnywhere, Category=Input)
    int32 InputPriority;
    
    float CreationTime;
 
    UPROPERTY(DuplicateTransient)
    TObjectPtr<class UInputComponent> InputComponent;
 
    UPROPERTY(Transient)
    int32 NetTag;
 
    UE_DEPRECATED(5.5, "Public access to NetCullDistanceSquared has been deprecated. Use SetNetCullDistanceSquared() and GetNetCullDistanceSquared() instead.")
    UPROPERTY(Category=Replication, EditDefaultsOnly, BlueprintReadWrite, meta=(AllowPrivateAccess=true), BlueprintGetter=GetNetCullDistanceSquared, BlueprintSetter=SetNetCullDistanceSquared)
    float NetCullDistanceSquared;
 
    UE_DEPRECATED(5.5, "Public access to NetUpdateFrequency has been deprecated. Use SetNetUpdateFrequency() and GetNetUpdateFrequency() instead.")
    UPROPERTY(Category=Replication, EditDefaultsOnly, BlueprintReadWrite, meta=(AllowPrivateAccess=true), BlueprintGetter=GetNetUpdateFrequency, BlueprintSetter=SetNetUpdateFrequency)
    float NetUpdateFrequency;
 
    UE_DEPRECATED(5.5, "Public access MinNetUpdateFrequency has been deprecated. Use SetMinNetUpdateFrequency() and GetMinNetUpdateFrequency() instead.")
    UPROPERTY(Category=Replication, EditDefaultsOnly, BlueprintReadWrite, meta=(AllowPrivateAccess=true), BlueprintGetter=GetMinNetUpdateFrequency, BlueprintSetter=SetMinNetUpdateFrequency)
    float MinNetUpdateFrequency;
 
    UPROPERTY(Category=Replication, EditDefaultsOnly, BlueprintReadWrite)
    float NetPriority;
 
private:
    UPROPERTY(EditDefaultsOnly, Category = Replication)
    EPhysicsReplicationMode PhysicsReplicationMode;
    
public:
    UFUNCTION(BlueprintCallable, Category = Replication)
    ENGINE_API void SetPhysicsReplicationMode(const EPhysicsReplicationMode ReplicationMode);
 
    UFUNCTION(BlueprintCallable, Category = Replication)
    ENGINE_API EPhysicsReplicationMode GetPhysicsReplicationMode();
 
    UFUNCTION(BlueprintCallable, Category = Replication)
    ENGINE_API void RegisterAsFocalPointInPhysicsReplicationLOD() const;
 
    UFUNCTION(BlueprintCallable, Category = Replication)
    ENGINE_API void UnregisterAsFocalPointInPhysicsReplicationLOD() const;
 
    UFUNCTION(BlueprintCallable, Category = Physics)
    ENGINE_API bool CanTriggerResimulation() const;
 
    UFUNCTION(BlueprintCallable, Category = Physics)
    ENGINE_API float GetResimulationThreshold() const;
 
private:
    FActorLastRenderTime LastRenderTime;
 
    friend struct FActorLastRenderTime;
 
public:
    ENGINE_API void SetNetDriverName(FName NewNetDriverName);
 
    FName GetNetDriverName() const { return NetDriverName; }
 
    bool IsUsingRegisteredSubObjectList() const { return bReplicateUsingRegisteredSubObjectList; }
 
    ENGINE_API virtual bool ReplicateSubobjects(class UActorChannel *Channel, class FOutBunch *Bunch, FReplicationFlags *RepFlags);
 
    ENGINE_API virtual void OnSubobjectCreatedFromReplication(UObject *NewSubobject);
 
    ENGINE_API virtual void OnSubobjectDestroyFromReplication(UObject *Subobject);
 
    ENGINE_API virtual void PreReplication(IRepChangedPropertyTracker & ChangedPropertyTracker);
 
    ENGINE_API virtual void PreReplicationForReplay(IRepChangedPropertyTracker & ChangedPropertyTracker);
 
    ENGINE_API virtual void RewindForReplay();
 
    ENGINE_API void CallPreReplication(UNetDriver* NetDriver);  
 
private:
    UPROPERTY(BlueprintReadWrite, ReplicatedUsing=OnRep_Instigator, meta=(ExposeOnSpawn=true, AllowPrivateAccess=true), Category=Actor)
    TObjectPtr<class APawn> Instigator;
 
public:
    UFUNCTION()
    ENGINE_API virtual void OnRep_Instigator();
 
    UPROPERTY(Transient)
    TArray<TObjectPtr<AActor>> Children;
 
protected:
    UPROPERTY(BlueprintGetter=K2_GetRootComponent, Category="Transformation")
    TObjectPtr<USceneComponent> RootComponent;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, BlueprintReadOnly, AdvancedDisplay, Category=Actor)
    FVector PivotOffset;
#endif
 
    FTimerHandle TimerHandle_LifeSpanExpired;
 
public:
#if WITH_EDITOR
    ENGINE_API class UHLODLayer* GetHLODLayer() const;
 
    ENGINE_API void SetHLODLayer(class UHLODLayer* InHLODLayer);
 
    static const FName GetHLODLayerPropertyName() { return GET_MEMBER_NAME_CHECKED(AActor, HLODLayer); }
#endif
 
    UFUNCTION(BlueprintCallable, Category = RayTracing)
    ENGINE_API void SetRayTracingGroupId(int32 InRaytracingGroupId);
    
    UFUNCTION(BlueprintCallable, Category = RayTracing)
    ENGINE_API int32 GetRayTracingGroupId() const;
 
private:
    UPROPERTY(EditAnywhere, Category = HLOD, meta = (DisplayName = "HLOD Layer"))
    TObjectPtr<class UHLODLayer> HLODLayer;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(Transient)
    TArray<TObjectPtr<UObject>> ObjectsDetachedFromExternalPackage;
#endif
 
public:
    inline bool AllowReceiveTickEventOnDedicatedServer() const { return bAllowReceiveTickEventOnDedicatedServer; }
 
    inline bool IsRunningUserConstructionScript() const { return bRunningUserConstructionScript; }
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Actor)
    TArray< FName > Layers;
 
private:
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TWeakObjectPtr<AActor> ParentComponentActor_DEPRECATED; 
#endif
 
    UPROPERTY()
    TWeakObjectPtr<UChildActorComponent> ParentComponent;   
 
#if WITH_EDITORONLY_DATA
protected:
    UPROPERTY(BluePrintReadOnly, AdvancedDisplay, Category=Actor, NonPIEDuplicateTransient, TextExportTransient, NonTransactional)
    FGuid ActorGuid;
 
    UPROPERTY(BluePrintReadOnly, AdvancedDisplay, Category=Actor, Transient, NonPIEDuplicateTransient, TextExportTransient, NonTransactional)
    FGuid ActorInstanceGuid;
 
    UPROPERTY(BluePrintReadOnly, AdvancedDisplay, Category=Actor, TextExportTransient, NonTransactional)
    FGuid ContentBundleGuid;
 
    UPROPERTY(VisibleAnywhere, AdvancedDisplay, Category = DataLayers)
    TArray<FActorDataLayer> DataLayers;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = DataLayers, meta=(DisableLevelInstancePropertyOverride))
    TArray<TSoftObjectPtr<UDataLayerAsset>> DataLayerAssets;
 
    TArray<TSoftObjectPtr<UDataLayerAsset>> PreEditChangeDataLayers;
 
    UPROPERTY(VisibleAnywhere, AdvancedDisplay, Category = DataLayers, TextExportTransient)
    TObjectPtr<const UExternalDataLayerAsset> ExternalDataLayerAsset;
 
public:
    uint32 CopyPasteId;
 
    UPROPERTY(Transient)
    TObjectPtr<AActor> GroupActor;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Rendering, meta=(DisplayName="Editor Billboard Scale"))
    float SpriteScale;
 
    UPROPERTY(Transient)
    uint64 HiddenEditorViews;
#endif // WITH_EDITORONLY_DATA
 
#if WITH_EDITOR
    ENGINE_API void SetPackageExternal(bool bExternal, bool bShouldDirty = true, UPackage* ActorExternalPackage = nullptr);
 
    virtual bool ShouldLevelKeepRefIfExternal() const { return false; }
 
    ENGINE_API bool IsMainWorldOnly() const;
 
    FActorOnPackagingModeChanged OnPackagingModeChanged;
 
    virtual FName GetRuntimeGrid() const { return RuntimeGrid; }
 
    void SetRuntimeGrid(FName InRuntimeGrid) { RuntimeGrid = InRuntimeGrid; }
 
    static const FName GetRuntimeGridPropertyName() { return GET_MEMBER_NAME_CHECKED(AActor, RuntimeGrid); }
 
    inline const FGuid& GetActorGuid() const { return ActorGuid; }
 
    inline const FGuid& GetActorInstanceGuid() const { return ActorInstanceGuid.IsValid() ? ActorInstanceGuid : ActorGuid; }
 
    inline const FGuid& GetContentBundleGuid() const { return ContentBundleGuid; }
 
    ENGINE_API virtual bool IsLockLocation() const;
 
    void SetLockLocation(bool bInLockLocation) { bLockLocation = bInLockLocation; }
 
    ENGINE_API virtual void OnPlayFromHere();
 
    bool CanPlayFromHere() const { return bCanPlayFromHere; }
 
    ENGINE_API virtual TUniquePtr<class FWorldPartitionActorDesc> CreateClassActorDesc() const;
 
public:
    ENGINE_API TUniquePtr<class FWorldPartitionActorDesc> CreateActorDesc() const;
 
    ENGINE_API virtual void GetActorDescProperties(FPropertyPairsMap& PropertyPairsMap) const;
 
    static ENGINE_API TUniquePtr<class FWorldPartitionActorDesc> StaticCreateClassActorDesc(const TSubclassOf<AActor>& ActorClass);
 
    virtual void OnLoadedActorAddedToLevel() {}
 
    virtual void OnLoadedActorRemovedFromLevel() {}
#endif // WITH_EDITOR
 
private:
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FString ActorLabel;
#endif
 
#if !WITH_EDITORONLY_DATA && ACTOR_HAS_LABELS
    FString ActorLabel;
#endif
 
public:
    FString GetActorNameOrLabel() const
    {
#if WITH_EDITORONLY_DATA || ACTOR_HAS_LABELS
        if (!ActorLabel.IsEmpty())
        {
            return ActorLabel;
        }
#endif
        return GetName();
    }
 
    FStringView GetActorLabelView() const
    {
#if WITH_EDITORONLY_DATA || ACTOR_HAS_LABELS
        return ActorLabel;
#else
        return FStringView();
#endif
    }
 
#if WITH_EDITORONLY_DATA
private:
    UPROPERTY()
    FName FolderPath;
 
    UPROPERTY(TextExportTransient)
    FGuid FolderGuid;
 
public:
    UPROPERTY()
    uint8 bHiddenEd:1;
 
    UPROPERTY(Transient)
    uint8 bIsEditorPreviewActor:1;
 
    UPROPERTY(Transient)
    uint8 bHiddenEdLayer:1;
 
    UPROPERTY(Transient)
    uint8 bHiddenEdLevel:1;
 
    uint8 bRunConstructionScriptOnDrag:1;
 
    uint8 bDefaultOutlinerExpansionState : 1;
 
protected:
    UPROPERTY()
    uint8 bLockLocation:1;
 
    UPROPERTY()
    uint8 bActorLabelEditable:1; 
 
    UPROPERTY()
    uint8 bEditable:1;
 
    UPROPERTY()
    uint8 bListedInSceneOutliner:1;
 
    UPROPERTY(EditDefaultsOnly, AdvancedDisplay, Category=Cooking, meta=(DisplayName="Generate Optimized Blueprint Component Data"))
    uint8 bOptimizeBPComponentData:1;
 
    UPROPERTY()
    uint8 bCanPlayFromHere : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category=WorldPartition)
    uint8 bIsSpatiallyLoaded : 1;
 
private:
    UPROPERTY(Transient)
    uint8 bHiddenEdTemporary:1;
 
    UPROPERTY(Transient)
    uint8 bForceExternalActorLevelReferenceForPIE : 1;
#endif // WITH_EDITORONLY_DATA
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category=Actor)
    TArray<FName> Tags;
 
 
    //~==============================================================================================
    // Delegates
    
    UPROPERTY(BlueprintAssignable, Category="Game|Damage")
    FTakeAnyDamageSignature OnTakeAnyDamage;
 
    UPROPERTY(BlueprintAssignable, Category="Game|Damage")
    FTakePointDamageSignature OnTakePointDamage;
 
    UPROPERTY(BlueprintAssignable, Category="Game|Damage")
    FTakeRadialDamageSignature OnTakeRadialDamage;
    
    UPROPERTY(BlueprintAssignable, Category="Collision")
    FActorBeginOverlapSignature OnActorBeginOverlap;
 
    UPROPERTY(BlueprintAssignable, Category="Collision")
    FActorEndOverlapSignature OnActorEndOverlap;
 
    UPROPERTY(BlueprintAssignable, Category="Input|Mouse Input")
    FActorBeginCursorOverSignature OnBeginCursorOver;
 
    UPROPERTY(BlueprintAssignable, Category="Input|Mouse Input")
    FActorEndCursorOverSignature OnEndCursorOver;
 
    UPROPERTY(BlueprintAssignable, Category="Input|Mouse Input")
    FActorOnClickedSignature OnClicked;
 
    UPROPERTY(BlueprintAssignable, Category="Input|Mouse Input")
    FActorOnReleasedSignature OnReleased;
 
    UPROPERTY(BlueprintAssignable, Category="Input|Touch Input")
    FActorOnInputTouchBeginSignature OnInputTouchBegin;
        
    UPROPERTY(BlueprintAssignable, Category="Input|Touch Input")
    FActorOnInputTouchEndSignature OnInputTouchEnd;
 
    UPROPERTY(BlueprintAssignable, Category="Input|Touch Input")
    FActorBeginTouchOverSignature OnInputTouchEnter;
 
    UPROPERTY(BlueprintAssignable, Category="Input|Touch Input")
    FActorEndTouchOverSignature OnInputTouchLeave;
 
    UPROPERTY(BlueprintAssignable, Category="Collision")
    FActorHitSignature OnActorHit;
 
    UFUNCTION(BlueprintCallable, Category="Input")
    ENGINE_API virtual void EnableInput(class APlayerController* PlayerController);
 
    UFUNCTION(BlueprintCallable, Category="Input")
    ENGINE_API virtual void CreateInputComponent(TSubclassOf<UInputComponent> InputComponentToCreate);
 
    UFUNCTION(BlueprintCallable, Category="Input")
    ENGINE_API virtual void DisableInput(class APlayerController* PlayerController);
 
    UFUNCTION(BlueprintCallable, meta=(BlueprintInternalUseOnly="true", HideSelfPin="true", HidePin="InputAxisName"))
    ENGINE_API float GetInputAxisValue(const FName InputAxisName) const;
 
    UFUNCTION(BlueprintCallable, meta=(BlueprintInternalUseOnly="true", HideSelfPin="true", HidePin="InputAxisKey"))
    ENGINE_API float GetInputAxisKeyValue(const FKey InputAxisKey) const;
 
    UFUNCTION(BlueprintCallable, meta=(BlueprintInternalUseOnly="true", HideSelfPin="true", HidePin="InputAxisKey"))
    ENGINE_API FVector GetInputVectorAxisValue(const FKey InputAxisKey) const;
 
    UFUNCTION(BlueprintCallable, meta=(BlueprintProtected = "true"), Category="Game")
    ENGINE_API APawn* GetInstigator() const;
 
    template <class T>
    T* GetInstigator() const
    {
        return Cast<T>(GetInstigator());
    }
 
    UFUNCTION(BlueprintCallable, meta=(BlueprintProtected = "true"), Category="Game")
    ENGINE_API AController* GetInstigatorController() const;
 
    template<class T>
    T* GetInstigatorController() const
    {
        return Cast<T>(GetInstigatorController());
    }
 
    //~=============================================================================
    // DataLayers functions.
#if WITH_EDITOR
protected:
    UE_DEPRECATED(5.4, "Use ActorTypeSupportsDataLayer instead.")
    virtual bool IsDataLayerTypeSupported(TSubclassOf<UDataLayerInstance> DataLayerType) const final { return false; }
private:
    virtual bool ActorTypeIsMainWorldOnly() const { return false; }
    ENGINE_API TArray<const UDataLayerAsset*> ResolveDataLayerAssets(const TArray<TSoftObjectPtr<UDataLayerAsset>>& InDataLayerAssets) const;
public:
    ENGINE_API bool AddDataLayer(const UDataLayerInstance* DataLayerInstance);
    ENGINE_API bool RemoveDataLayer(const UDataLayerInstance* DataLayerInstance);
    ENGINE_API bool CanAddDataLayer(const UDataLayerInstance* InDataLayerInstance, FText* OutReason = nullptr) const;
 
    ENGINE_API TArray<const UDataLayerInstance*> RemoveAllDataLayers();
    ENGINE_API bool SupportsDataLayerType(TSubclassOf<UDataLayerInstance> DataLayerType) const;
    
    ENGINE_API TArray<const UDataLayerInstance*> GetDataLayerInstancesForLevel() const;
    ENGINE_API TArray<FName> GetDataLayerInstanceNames() const;
    ENGINE_API bool IsPropertyChangedAffectingDataLayers(FPropertyChangedEvent& PropertyChangedEvent) const;
    ENGINE_API void FixupDataLayers(bool bRevertChangesOnLockedDataLayer = false);
    static const FName GetDataLayerAssetsPropertyName() { return GET_MEMBER_NAME_CHECKED(AActor, DataLayerAssets); }
    static const FName GetDataLayerPropertyName() { return GET_MEMBER_NAME_CHECKED(AActor, DataLayers); }
 
    ENGINE_API TArray<const UDataLayerAsset*> GetDataLayerAssets(bool bIncludeExternalDataLayerAsset = true) const;
    ENGINE_API bool HasExternalContent() const;
 
    virtual bool ActorTypeSupportsDataLayer() const { return true; }
    virtual bool ActorTypeSupportsExternalDataLayer() const { return true; }
 
    //~ Begin Deprecated
 
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
 
    UE_DEPRECATED(5.1, "Convert DataLayer using UDataLayerToAssetCommandlet and use AddDataLayer(UDataLayerInstance*)")
    ENGINE_API bool AddDataLayer(const UDEPRECATED_DataLayer* DataLayer);
 
    UE_DEPRECATED(5.1, "Convert DataLayer using UDataLayerToAssetCommandlet and use RemoveDataLayer(UDataLayerInstance*)")
    ENGINE_API bool RemoveDataLayer(const UDEPRECATED_DataLayer* DataLayer);
 
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    UE_DEPRECATED(5.3, "Use AActor::SupportsDataLayerType(TSubclassOf<UDataLayerInstance>) instead.")
    ENGINE_API bool SupportsDataLayer() const;
 
    UE_DEPRECATED(5.3, "Use UDataLayerInstance::AddActor(AActor*) instead.")
    bool AddDataLayer(const UDataLayerAsset* DataLayerAsset) { return false; }
 
    UE_DEPRECATED(5.3, "Use UDataLayerInstance::RemoveDataLayer(AActor*) instead.")
    bool RemoveDataLayer(const UDataLayerAsset* DataLayerAsset) { return false; }
 
    UE_DEPRECATED(5.1, "Convert DataLayer using UDataLayerToAssetCommandlet and use AddDataLayer(UDataLayerAsset*)")
    ENGINE_API bool AddDataLayer(const FActorDataLayer& ActorDataLayer);
 
    UE_DEPRECATED(5.1, "Convert DataLayer using UDataLayerToAssetCommandlet and use RemoveDataLayer(UDataLayerAsset*)")
    ENGINE_API bool RemoveDataLayer(const FActorDataLayer& ActorDataLayer);
 
    UE_DEPRECATED(5.1, "Convert DataLayer using UDataLayerToAssetCommandlet and use ContainsDataLayer(const UDataLayerAsset*)")
    ENGINE_API bool ContainsDataLayer(const FActorDataLayer& ActorDataLayer) const;
 
    UE_DEPRECATED(5.1, "Convert DataLayer using UDataLayerToAssetCommandlet and use GetDataLayerAssets() instead")
    TArray<FActorDataLayer> const& GetActorDataLayers() const { return DataLayers; }
 
    UE_DEPRECATED(5.1, "Use GetDataLayerInstances() with no parameters instead")
    TArray<const UDataLayerInstance*> GetDataLayerInstances(const AWorldDataLayers* WorldDataLayers) const { return TArray<const UDataLayerInstance*>(); }
 
    UE_DEPRECATED(5.1, "Use HasDataLayers() instead")
    bool HasValidDataLayers() const { return HasDataLayers(); }
 
    //~ End Deprecated
#endif
 
    ENGINE_API TArray<const UDataLayerInstance*> GetDataLayerInstances() const;
 
    ENGINE_API bool ContainsDataLayer(const UDataLayerAsset* DataLayerAsset) const;
    ENGINE_API bool ContainsDataLayer(const UDataLayerInstance* DataLayerInstance) const;
    ENGINE_API bool HasDataLayers() const;
    ENGINE_API bool HasContentBundle() const;
    ENGINE_API const UExternalDataLayerAsset* GetExternalDataLayerAsset() const;
 
private:
    ENGINE_API TArray<const UDataLayerInstance*> GetDataLayerInstancesInternal(bool bUseLevelContext, bool bIncludeParentDataLayers = true) const;
    ENGINE_API const IWorldPartitionCell* GetWorldPartitionRuntimeCell() const;
 
    virtual bool SupportsIncrementalPreRegisterComponents() const
    {
        return true;
    }
 
    virtual bool SupportsIncrementalPreUnregisterComponents() const
    {
        return true;
    }
 
    ENGINE_API void IncrementalPreRegisterComponents();
 
    bool HasPreRegisteredAllComponents() const { return bHasPreRegisteredAllComponents; }
 
    ENGINE_API void IncrementalPreUnregisterComponents();
 
    //~=============================================================================
    // General functions.
public:
    UFUNCTION(BlueprintCallable, meta=(DisplayName = "Get Actor Transform", ScriptName = "GetActorTransform"), Category="Transformation")
    const FTransform& GetTransform() const
    {
        return ActorToWorld();
    }
 
    inline const FTransform& ActorToWorld() const
    {
        return (RootComponent ? RootComponent->GetComponentTransform() : FTransform::Identity);
    }
 
    UFUNCTION(BlueprintCallable, meta=(DisplayName = "Get Actor Location", ScriptName = "GetActorLocation", Keywords="position"), Category="Transformation")
    FVector K2_GetActorLocation() const;
 
    UFUNCTION(BlueprintCallable, meta=(DisplayName = "Set Actor Location", ScriptName = "SetActorLocation", Keywords="position"), Category="Transformation")
    ENGINE_API bool K2_SetActorLocation(FVector NewLocation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
 
    UFUNCTION(BlueprintCallable, meta=(DisplayName = "Get Actor Rotation", ScriptName = "GetActorRotation"), Category="Transformation")
    FRotator K2_GetActorRotation() const;
 
    UFUNCTION(BlueprintCallable, Category = "Transformation")
    FVector GetActorForwardVector() const;
 
    UFUNCTION(BlueprintCallable, Category = "Transformation")
    FVector GetActorUpVector() const;
 
    UFUNCTION(BlueprintCallable, Category = "Transformation")
    FVector GetActorRightVector() const;
 
    UFUNCTION(BlueprintCallable, Category="Collision", meta=(DisplayName = "Get Actor Bounds"))
    ENGINE_API virtual void GetActorBounds(bool bOnlyCollidingComponents, FVector& Origin, FVector& BoxExtent, bool bIncludeFromChildActors = false) const;
 
    UFUNCTION(BlueprintGetter)
    USceneComponent* K2_GetRootComponent() const;
 
    UFUNCTION(BlueprintCallable, Category="Transformation")
    ENGINE_API virtual FVector GetVelocity() const;
 
    ENGINE_API bool SetActorLocation(const FVector& NewLocation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, meta=(DisplayName = "Set Actor Rotation", ScriptName = "SetActorRotation"), Category="Transformation")
    ENGINE_API bool K2_SetActorRotation(FRotator NewRotation, bool bTeleportPhysics);
    
    ENGINE_API bool SetActorRotation(FRotator NewRotation, ETeleportType Teleport = ETeleportType::None);
    ENGINE_API bool SetActorRotation(const FQuat& NewRotation, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Set Actor Location And Rotation", ScriptName="SetActorLocationAndRotation"))
    ENGINE_API bool K2_SetActorLocationAndRotation(FVector NewLocation, FRotator NewRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    
    ENGINE_API bool SetActorLocationAndRotation(FVector NewLocation, FRotator NewRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
    ENGINE_API bool SetActorLocationAndRotation(FVector NewLocation, const FQuat& NewRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation")
    ENGINE_API void SetActorScale3D(FVector NewScale3D);
 
    UFUNCTION(BlueprintCallable, Category="Transformation")
    ENGINE_API FVector GetActorScale3D() const;
 
    UFUNCTION(BlueprintCallable, Category = "Transformation")
    ENGINE_API float GetDistanceTo(const AActor* OtherActor) const;
 
    UFUNCTION(BlueprintCallable, Category = "Transformation")
    ENGINE_API float GetSquaredDistanceTo(const AActor* OtherActor) const;
 
    UFUNCTION(BlueprintCallable, Category = "Transformation")
    ENGINE_API float GetHorizontalDistanceTo(const AActor* OtherActor) const;
 
    UFUNCTION(BlueprintCallable, Category = "Transformation")
    ENGINE_API float GetSquaredHorizontalDistanceTo(const AActor* OtherActor) const;
 
    UFUNCTION(BlueprintCallable, Category = "Transformation")
    ENGINE_API float GetVerticalDistanceTo(const AActor* OtherActor) const;
 
    UFUNCTION(BlueprintCallable, Category = "Transformation")
    ENGINE_API float GetDotProductTo(const AActor* OtherActor) const;
 
    UFUNCTION(BlueprintCallable, Category = "Transformation")
    ENGINE_API float GetHorizontalDotProductTo(const AActor* OtherActor) const;
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Add Actor World Offset", ScriptName="AddActorWorldOffset", Keywords="location position"))
    ENGINE_API void K2_AddActorWorldOffset(FVector DeltaLocation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void AddActorWorldOffset(FVector DeltaLocation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Add Actor World Rotation", ScriptName="AddActorWorldRotation", AdvancedDisplay="bSweep,SweepHitResult,bTeleport"))
    ENGINE_API void K2_AddActorWorldRotation(FRotator DeltaRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void AddActorWorldRotation(FRotator DeltaRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
    ENGINE_API void AddActorWorldRotation(const FQuat& DeltaRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Add Actor World Transform", ScriptName="AddActorWorldTransform"))
    ENGINE_API void K2_AddActorWorldTransform(const FTransform& DeltaTransform, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void AddActorWorldTransform(const FTransform& DeltaTransform, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category = "Transformation", meta = (DisplayName = "Add Actor World Transform Keep Scale", ScriptName = "AddActorWorldTransformKeepScale"))
    ENGINE_API void K2_AddActorWorldTransformKeepScale(const FTransform& DeltaTransform, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void AddActorWorldTransformKeepScale(const FTransform& DeltaTransform, bool bSweep = false, FHitResult* OutSweepHitResult = nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Set Actor Transform", ScriptName="SetActorTransform"))
    ENGINE_API bool K2_SetActorTransform(const FTransform& NewTransform, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API bool SetActorTransform(const FTransform& NewTransform, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Add Actor Local Offset", ScriptName="AddActorLocalOffset", Keywords="location position"))
    ENGINE_API void K2_AddActorLocalOffset(FVector DeltaLocation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void AddActorLocalOffset(FVector DeltaLocation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Add Actor Local Rotation", ScriptName="AddActorLocalRotation", AdvancedDisplay="bSweep,SweepHitResult,bTeleport"))
    ENGINE_API void K2_AddActorLocalRotation(FRotator DeltaRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void AddActorLocalRotation(FRotator DeltaRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
    ENGINE_API void AddActorLocalRotation(const FQuat& DeltaRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Add Actor Local Transform", ScriptName="AddActorLocalTransform"))
    ENGINE_API void K2_AddActorLocalTransform(const FTransform& NewTransform, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void AddActorLocalTransform(const FTransform& NewTransform, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Set Actor Relative Location", ScriptName="SetActorRelativeLocation"))
    ENGINE_API void K2_SetActorRelativeLocation(FVector NewRelativeLocation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void SetActorRelativeLocation(FVector NewRelativeLocation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Set Actor Relative Rotation", ScriptName="SetActorRelativeRotation", AdvancedDisplay="bSweep,SweepHitResult,bTeleport"))
    ENGINE_API void K2_SetActorRelativeRotation(FRotator NewRelativeRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void SetActorRelativeRotation(FRotator NewRelativeRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
    ENGINE_API void SetActorRelativeRotation(const FQuat& NewRelativeRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Set Actor Relative Transform", ScriptName="SetActorRelativeTransform"))
    ENGINE_API void K2_SetActorRelativeTransform(const FTransform& NewRelativeTransform, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void SetActorRelativeTransform(const FTransform& NewRelativeTransform, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation")
    ENGINE_API void SetActorRelativeScale3D(FVector NewRelativeScale);
 
    UFUNCTION(BlueprintCallable, Category="Transformation")
    ENGINE_API FVector GetActorRelativeScale3D() const;
 
    ENGINE_API void MarkNeedsRecomputeBoundsOnceForGame();
 
    UFUNCTION(BlueprintCallable, Category="Rendering", meta=( DisplayName = "Set Actor Hidden In Game", Keywords = "Visible Hidden Show Hide" ))
    ENGINE_API virtual void SetActorHiddenInGame(bool bNewHidden);
 
    UFUNCTION(BlueprintCallable, Category="Collision")
    ENGINE_API void SetActorEnableCollision(bool bNewActorEnableCollision);
 
    UFUNCTION(BlueprintPure, Category="Collision")
    bool GetActorEnableCollision() const;
 
    UFUNCTION(BlueprintCallable, Category="Actor", meta=(Keywords = "Delete", DisplayName = "Destroy Actor", ScriptName = "DestroyActor"))
    ENGINE_API virtual void K2_DestroyActor();
 
    UFUNCTION(BlueprintCallable, Category="Networking")
    bool HasAuthority() const;
 
    UFUNCTION(BlueprintCallable, meta=(ScriptNoExport, BlueprintInternalUseOnly = "true", DefaultToSelf="ComponentTemplateContext", InternalUseParam="ComponentTemplateContext,bDeferredFinish"))
    ENGINE_API UActorComponent* AddComponent(FName TemplateName, bool bManualAttachment, const FTransform& RelativeTransform, const UObject* ComponentTemplateContext, bool bDeferredFinish = false);
 
    UFUNCTION(BlueprintCallable, meta=(ScriptNoExport, BlueprintInternalUseOnly = "true", InternalUseParam="bDeferredFinish"))
    ENGINE_API UActorComponent* AddComponentByClass(UPARAM(meta = (AllowAbstract = "false")) TSubclassOf<UActorComponent> Class, bool bManualAttachment, const FTransform& RelativeTransform, bool bDeferredFinish);
 
    UFUNCTION(BlueprintCallable, meta=(BlueprintInternalUseOnly="true"))
    ENGINE_API void FinishAddComponent(UActorComponent* Component, bool bManualAttachment, const FTransform& RelativeTransform);
 
    UE_DEPRECATED(4.17, "Use AttachToComponent() instead.")
    UFUNCTION(BlueprintCallable, meta = (DisplayName = "AttachRootComponentTo (Deprecated)", ScriptNoExport, AttachLocationType = "KeepRelativeOffset"), Category = "Transformation")
    ENGINE_API void K2_AttachRootComponentTo(USceneComponent* InParent, FName InSocketName = NAME_None, EAttachLocation::Type AttachLocationType = EAttachLocation::KeepRelativeOffset, bool bWeldSimulatedBodies = true);
 
    UFUNCTION(BlueprintCallable, meta = (DisplayName = "Attach Actor To Component", ScriptName = "AttachToComponent", bWeldSimulatedBodies = true), Category = "Transformation")
    ENGINE_API bool K2_AttachToComponent(USceneComponent* Parent, FName SocketName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule, bool bWeldSimulatedBodies);
 
    ENGINE_API bool AttachToComponent(USceneComponent* Parent, const FAttachmentTransformRules& AttachmentRules, FName SocketName = NAME_None);
 
    UE_DEPRECATED(4.17, "Use AttachToActor() instead.")
    UFUNCTION(BlueprintCallable, meta = (DisplayName = "AttachRootComponentToActor (Deprecated)", ScriptNoExport, AttachLocationType = "KeepRelativeOffset"), Category = "Transformation")
    ENGINE_API void K2_AttachRootComponentToActor(AActor* InParentActor, FName InSocketName = NAME_None, EAttachLocation::Type AttachLocationType = EAttachLocation::KeepRelativeOffset, bool bWeldSimulatedBodies = true);
 
    ENGINE_API bool AttachToActor(AActor* ParentActor, const FAttachmentTransformRules& AttachmentRules, FName SocketName = NAME_None);
 
    UFUNCTION(BlueprintCallable, meta = (DisplayName = "Attach Actor To Actor", ScriptName = "AttachToActor", bWeldSimulatedBodies=true), Category = "Transformation")
    ENGINE_API bool K2_AttachToActor(AActor* ParentActor, FName SocketName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule, bool bWeldSimulatedBodies);
 
    UE_DEPRECATED(4.17, "Use DetachFromActor() instead")
    UFUNCTION(BlueprintCallable, meta=(DisplayName = "DetachActorFromActor (Deprecated)", ScriptNoExport), Category="Transformation")
    ENGINE_API void DetachRootComponentFromParent(bool bMaintainWorldPosition = true);
 
    UFUNCTION(BlueprintCallable, meta=(DisplayName = "Detach From Actor", ScriptName = "DetachFromActor"), Category="Transformation")
    ENGINE_API void K2_DetachFromActor(EDetachmentRule LocationRule = EDetachmentRule::KeepRelative, EDetachmentRule RotationRule = EDetachmentRule::KeepRelative, EDetachmentRule ScaleRule = EDetachmentRule::KeepRelative);
 
    ENGINE_API void DetachFromActor(const FDetachmentTransformRules& DetachmentRules);
 
    ENGINE_API void DetachAllSceneComponents(class USceneComponent* InParentComponent, const FDetachmentTransformRules& DetachmentRules);
 
    UFUNCTION(BlueprintCallable, Category="Actor")
    ENGINE_API bool ActorHasTag(FName Tag) const;
 
 
    //~==============================================================================
    // Misc Blueprint support
 
    UFUNCTION(BlueprintCallable, Category="Actor")
    ENGINE_API float GetActorTimeDilation() const;
 
    ENGINE_API float GetActorTimeDilation(const UWorld& ActorWorld) const;
 
    UFUNCTION(BlueprintCallable, Category="Actor|Tick", meta=(Keywords = "dependency"))
    ENGINE_API virtual void AddTickPrerequisiteActor(AActor* PrerequisiteActor);
 
    UFUNCTION(BlueprintCallable, Category="Actor|Tick", meta=(Keywords = "dependency"))
    ENGINE_API virtual void AddTickPrerequisiteComponent(UActorComponent* PrerequisiteComponent);
 
    UFUNCTION(BlueprintCallable, Category="Actor|Tick", meta=(Keywords = "dependency"))
    ENGINE_API virtual void RemoveTickPrerequisiteActor(AActor* PrerequisiteActor);
 
    UFUNCTION(BlueprintCallable, Category="Actor|Tick", meta=(Keywords = "dependency"))
    ENGINE_API virtual void RemoveTickPrerequisiteComponent(UActorComponent* PrerequisiteComponent);
    
    UFUNCTION(BlueprintCallable, Category="Actor|Tick")
    ENGINE_API bool GetTickableWhenPaused();
 
    UFUNCTION(BlueprintCallable, Category="Actor|Tick")
    ENGINE_API void SetTickableWhenPaused(bool bTickableWhenPaused);
 
    UFUNCTION(BlueprintPure, Category=Actor)
    ENGINE_API float GetGameTimeSinceCreation() const;
 
protected:
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName = "BeginPlay"))
    ENGINE_API void ReceiveBeginPlay();
 
    ENGINE_API virtual void BeginPlay();
 
    UFUNCTION(BlueprintImplementableEvent, meta=(Keywords = "delete", DisplayName = "End Play"))
    ENGINE_API void ReceiveEndPlay(EEndPlayReason::Type EndPlayReason);
 
    ENGINE_API virtual void EndPlay(const EEndPlayReason::Type EndPlayReason);
 
public:
    ENGINE_API void DispatchBeginPlay(bool bFromLevelStreaming = false);
 
    bool IsActorInitialized() const { return bActorInitialized; }
 
    bool IsActorBeginningPlay() const { return ActorHasBegunPlay == EActorBeginPlayState::BeginningPlay; }
 
    bool HasActorBegunPlay() const { return ActorHasBegunPlay == EActorBeginPlayState::HasBegunPlay; }
 
    bool IsActorBeginningPlayFromLevelStreaming() const { return bActorBeginningPlayFromLevelStreaming; }
 
    UFUNCTION(BlueprintCallable, Category="Game")
    bool IsActorBeingDestroyed() const 
    {
        return bActorIsBeingDestroyed;
    }
 
    bool HasActorRegisteredAllComponents() const { return bHasRegisteredAllComponents; }
 
    void SetHasActorRegisteredAllComponents() { bHasRegisteredAllComponents = true; }
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintAuthorityOnly, meta=(DisplayName = "AnyDamage"), Category="Game|Damage")
    ENGINE_API void ReceiveAnyDamage(float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, AActor* DamageCauser);
    
    UFUNCTION(BlueprintImplementableEvent, BlueprintAuthorityOnly, meta=(DisplayName = "RadialDamage"), Category="Game|Damage")
    ENGINE_API void ReceiveRadialDamage(float DamageReceived, const class UDamageType* DamageType, FVector Origin, const struct FHitResult& HitInfo, class AController* InstigatedBy, AActor* DamageCauser);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintAuthorityOnly, meta=(DisplayName = "PointDamage"), Category="Game|Damage")
    ENGINE_API void ReceivePointDamage(float Damage, const class UDamageType* DamageType, FVector HitLocation, FVector HitNormal, class UPrimitiveComponent* HitComponent, FName BoneName, FVector ShotFromDirection, class AController* InstigatedBy, AActor* DamageCauser, const FHitResult& HitInfo);
 
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName = "Tick"))
    ENGINE_API void ReceiveTick(float DeltaSeconds);
 
    UFUNCTION(BlueprintImplementableEvent, meta = (DisplayName = "Async Physics Tick"))
    ENGINE_API void ReceiveAsyncPhysicsTick(float DeltaSeconds, float SimSeconds);
 
    ENGINE_API virtual void NotifyActorBeginOverlap(AActor* OtherActor);
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName = "ActorBeginOverlap"), Category="Collision")
    ENGINE_API void ReceiveActorBeginOverlap(AActor* OtherActor);
 
    ENGINE_API virtual void NotifyActorEndOverlap(AActor* OtherActor);
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName = "ActorEndOverlap"), Category="Collision")
    ENGINE_API void ReceiveActorEndOverlap(AActor* OtherActor);
 
    ENGINE_API virtual void NotifyActorBeginCursorOver();
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName = "ActorBeginCursorOver"), Category="Mouse Input")
    ENGINE_API void ReceiveActorBeginCursorOver();
 
    ENGINE_API virtual void NotifyActorEndCursorOver();
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName = "ActorEndCursorOver"), Category="Mouse Input")
    ENGINE_API void ReceiveActorEndCursorOver();
 
    ENGINE_API virtual void NotifyActorOnClicked(FKey ButtonPressed = EKeys::LeftMouseButton);
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName = "ActorOnClicked"), Category="Mouse Input")
    ENGINE_API void ReceiveActorOnClicked(FKey ButtonPressed = EKeys::LeftMouseButton);
 
    ENGINE_API virtual void NotifyActorOnReleased(FKey ButtonReleased = EKeys::LeftMouseButton);
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName = "ActorOnReleased"), Category="Mouse Input")
    ENGINE_API void ReceiveActorOnReleased(FKey ButtonReleased = EKeys::LeftMouseButton);
 
    ENGINE_API virtual void NotifyActorOnInputTouchBegin(const ETouchIndex::Type FingerIndex);
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName = "BeginInputTouch"), Category="Touch Input")
    ENGINE_API void ReceiveActorOnInputTouchBegin(const ETouchIndex::Type FingerIndex);
 
    ENGINE_API virtual void NotifyActorOnInputTouchEnd(const ETouchIndex::Type FingerIndex);
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName = "EndInputTouch"), Category="Touch Input")
    ENGINE_API void ReceiveActorOnInputTouchEnd(const ETouchIndex::Type FingerIndex);
 
    ENGINE_API virtual void NotifyActorOnInputTouchEnter(const ETouchIndex::Type FingerIndex);
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName = "TouchEnter"), Category="Touch Input")
    ENGINE_API void ReceiveActorOnInputTouchEnter(const ETouchIndex::Type FingerIndex);
 
    ENGINE_API virtual void NotifyActorOnInputTouchLeave(const ETouchIndex::Type FingerIndex);
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName = "TouchLeave"), Category="Touch Input")
    ENGINE_API void ReceiveActorOnInputTouchLeave(const ETouchIndex::Type FingerIndex);
 
    UFUNCTION(BlueprintCallable, Category="Collision", meta=(UnsafeDuringActorConstruction="true", DeterminesOutputType="ClassFilter",  DynamicOutputParam="OverlappingActors"))
    ENGINE_API void GetOverlappingActors(TArray<AActor*>& OverlappingActors, TSubclassOf<AActor> ClassFilter=nullptr) const;
 
    ENGINE_API void GetOverlappingActors(TSet<AActor*>& OverlappingActors, TSubclassOf<AActor> ClassFilter=nullptr) const;
 
    UFUNCTION(BlueprintCallable, Category="Collision", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API void GetOverlappingComponents(TArray<UPrimitiveComponent*>& OverlappingComponents) const;
 
    ENGINE_API void GetOverlappingComponents(TSet<UPrimitiveComponent*>& OverlappingComponents) const;
 
    ENGINE_API virtual void NotifyHit(class UPrimitiveComponent* MyComp, AActor* Other, class UPrimitiveComponent* OtherComp, bool bSelfMoved, FVector HitLocation, FVector HitNormal, FVector NormalImpulse, const FHitResult& Hit);
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName = "Hit"), Category="Collision")
    ENGINE_API void ReceiveHit(class UPrimitiveComponent* MyComp, AActor* Other, class UPrimitiveComponent* OtherComp, bool bSelfMoved, FVector HitLocation, FVector HitNormal, FVector NormalImpulse, const FHitResult& Hit);
 
    UFUNCTION(BlueprintCallable, Category="Actor", meta=(Keywords = "delete destroy"))
    ENGINE_API virtual void SetLifeSpan( float InLifespan );
 
    UFUNCTION(BlueprintCallable, Category="Actor", meta=(Keywords = "delete destroy"))
    ENGINE_API virtual float GetLifeSpan() const;
 
    UFUNCTION(BlueprintImplementableEvent, meta=(BlueprintInternalUseOnly = "true", DisplayName = "Construction Script"))
    ENGINE_API void UserConstructionScript();
 
    ENGINE_API bool Destroy(bool bNetForce = false, bool bShouldModifyLevel = true );
 
    UFUNCTION(BlueprintImplementableEvent, meta = (Keywords = "delete", DisplayName = "Destroyed"))
    ENGINE_API void ReceiveDestroyed();
 
    UPROPERTY(BlueprintAssignable, Category="Game")
    FActorDestroyedSignature OnDestroyed;
 
    UPROPERTY(BlueprintAssignable, Category="Game")
    FActorEndPlaySignature OnEndPlay;
    
    //~ Begin UObject Interface
    ENGINE_API virtual bool CheckDefaultSubobjectsInternal() const override;
    ENGINE_API virtual void PostInitProperties() override;
    ENGINE_API virtual void ProcessEvent( UFunction* Function, void* Parameters ) override;
    ENGINE_API virtual int32 GetFunctionCallspace( UFunction* Function, FFrame* Stack ) override;
    ENGINE_API virtual bool CallRemoteFunction( UFunction* Function, void* Parameters, FOutParmRec* OutParms, FFrame* Stack ) override;
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    ENGINE_API virtual void PostLoad() override;
    ENGINE_API virtual void PostLoadSubobjects( FObjectInstancingGraph* OuterInstanceGraph ) override;
#if UE_WITH_REMOTE_OBJECT_HANDLE
    ENGINE_API virtual void PostMigrate(const struct FUObjectMigrationContext& MigrationContext) override;
    ENGINE_API virtual bool IsMigrationRoot() const override;
#endif
    ENGINE_API virtual void BeginDestroy() override;
#if !UE_STRIP_DEPRECATED_PROPERTIES
    ENGINE_API virtual bool IsReadyForFinishDestroy() override;
#endif
    ENGINE_API virtual bool Rename( const TCHAR* NewName=nullptr, UObject* NewOuter=nullptr, ERenameFlags Flags=REN_None ) override;
    ENGINE_API virtual void PostRename( UObject* OldOuter, const FName OldName ) override;
    ENGINE_API virtual bool CanBeInCluster() const override;
    static ENGINE_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
    ENGINE_API virtual bool IsEditorOnly() const override;
    virtual bool IsEditorOnlyLoadedInPIE() const { return false; }
    virtual bool IsRuntimeOnly() const { return false; }
    ENGINE_API virtual bool IsAsset() const override;
 
    ENGINE_API virtual void PreSaveRoot(FObjectPreSaveRootContext ObjectSaveContext) override;
    ENGINE_API virtual void PostSaveRoot(FObjectPostSaveRootContext ObjectSaveContext) override;
    ENGINE_API virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
 
    ENGINE_API bool IsMainPackageActor() const;
 
    static ENGINE_API AActor* FindActorInPackage(UPackage* InPackage, bool bEvenIfPendingKill = true);
 
#if WITH_EDITOR
    ENGINE_API virtual bool Modify(bool bAlwaysMarkDirty = true) override;
    ENGINE_API virtual void GetAssetRegistryTags(FAssetRegistryTagsContext Context) const override;
    UE_DEPRECATED(5.4, "Implement the version that takes FAssetRegistryTagsContext instead.")
    ENGINE_API virtual void GetAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) const override;
    ENGINE_API virtual bool NeedsLoadForTargetPlatform(const ITargetPlatform* TargetPlatform) const;
    ENGINE_API virtual void PreEditChange(FProperty* PropertyThatWillChange) override;
    ENGINE_API virtual bool CanEditChange(const FProperty* InProperty) const;
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    ENGINE_API virtual void PreEditUndo() override;
    ENGINE_API virtual void PostEditUndo() override;
    ENGINE_API virtual void PostEditImport() override;
    ENGINE_API virtual void PostTransacted(const FTransactionObjectEvent& TransactionEvent) override;
    ENGINE_API virtual bool IsSelectedInEditor() const override;
 
    struct UE_DEPRECATED(5.6, "Use PreDuplicateFromRoot instead.") FDuplicationSeedInterface
    {
    public:
        FDuplicationSeedInterface(TMap<UObject*, UObject*>& InDuplicationSeed) {}
 
        ENGINE_API void AddEntry(UObject* Source, UObject* Dest) {}
    };
 
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    UE_DEPRECATED(5.6, "Use PreDuplicateFromRoot instead.")
    virtual void PopulatePIEDuplicationSeed(FDuplicationSeedInterface& DupSeed) {}
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    virtual bool IsDefaultPreviewEnabled() const
    {
        return true;
    }
 
    virtual bool IsUserManaged() const { return true; }
 
    ENGINE_API virtual bool CanDeleteSelectedActor(FText& OutReason) const;
 
    ENGINE_API virtual bool CanReplaceSelectedActor(FText& OutReason) const;
 
    ENGINE_API virtual bool SupportsExternalPackaging() const;
#endif
 
#if WITH_EDITOR
    TSharedPtr<FActorTransactionAnnotation> CurrentTransactionAnnotation;
 
    ENGINE_API virtual TSharedPtr<ITransactionObjectAnnotation> FactoryTransactionAnnotation(const ETransactionAnnotationCreationMode InCreationMode) const override;
    ENGINE_API virtual void PostEditUndo(TSharedPtr<ITransactionObjectAnnotation> TransactionAnnotation) override;
 
    ENGINE_API bool ReregisterComponentsWhenModified() const;
 
    ENGINE_API virtual void PostEditMove(bool bFinished);
#endif // WITH_EDITOR
    //~ End UObject Interface
 
#if WITH_EDITOR
    virtual void PreRenameFromRoot(const FWorldRenameFromRootContext& RenameContext) {}
    virtual void PostRenameFromRoot(const FWorldRenameFromRootContext& RenameContext) {}
#endif
    virtual void PreDuplicateFromRoot(FObjectDuplicationParameters& DupParams) {}
    ENGINE_API virtual void PreSaveFromRoot(FObjectPreSaveRootContext ObjectSaveContext);
    ENGINE_API virtual void PostSaveFromRoot(FObjectPostSaveRootContext ObjectSaveContext);
 
#if WITH_EDITOR
    ENGINE_API virtual bool CanEditChangeComponent(const UActorComponent* Component, const FProperty* InProperty) const;
#endif
 
    //~=============================================================================
    // Property Replication
 
    ENGINE_API virtual void GatherCurrentMovement();
 
    inline bool IsOwnedBy( const AActor* TestOwner ) const
    {
        for( const AActor* Arg=this; Arg; Arg=Arg->Owner )
        {
            if( Arg == TestOwner )
                return true;
        }
        return false;
    }
 
    inline USceneComponent* GetRootComponent() const { return RootComponent; }
 
    virtual USceneComponent* GetDefaultAttachComponent() const { return GetRootComponent(); }
 
    ENGINE_API bool SetRootComponent(USceneComponent* NewRootComponent);
 
    inline const FTransform& GetActorTransform() const
    {
        return TemplateGetActorTransform(ToRawPtr(RootComponent));
    }
 
    inline FVector GetActorLocation() const
    {
        return TemplateGetActorLocation(ToRawPtr(RootComponent));
    }
 
    inline FRotator GetActorRotation() const
    {
        return TemplateGetActorRotation(ToRawPtr(RootComponent));
    }
 
    inline FVector GetActorScale() const
    {
        return TemplateGetActorScale(ToRawPtr(RootComponent));
    }
 
    inline FQuat GetActorQuat() const
    {
        return TemplateGetActorQuat(ToRawPtr(RootComponent));
    }
 
#if WITH_EDITOR
    inline void SetPivotOffset(const FVector& InPivotOffset)
    {
        PivotOffset = InPivotOffset;
    }
 
    inline FVector GetPivotOffset() const
    {
        return PivotOffset;
    }
 
    ENGINE_API virtual void GetStreamingBounds(FBox& OutRuntimeBounds, FBox& OutEditorBounds) const;
 
    UE_DEPRECATED(5.5, "Use the override that takes both Runtime and Editor boxes")
    ENGINE_API FBox GetStreamingBounds() const;
#endif
 
 
    //~=============================================================================
    // Relations
 
    ENGINE_API virtual void ApplyWorldOffset(const FVector& InOffset, bool bWorldShift);
 
    virtual bool IsLevelBoundsRelevant() const { return bRelevantForLevelBounds; }
 
    ENGINE_API virtual bool IsHLODRelevant() const;
 
    ENGINE_API virtual bool HasHLODRelevantComponents() const;
 
    ENGINE_API virtual TArray<UActorComponent*> GetHLODRelevantComponents() const;
 
    ENGINE_API void SetLODParent(class UPrimitiveComponent* InLODParent, float InParentDrawDistance);
 
#if WITH_EDITOR
    static ENGINE_API bool bUsePercentageBasedScaling;
 
    ENGINE_API virtual void EditorApplyTranslation(const FVector& DeltaTranslation, bool bAltDown, bool bShiftDown, bool bCtrlDown);
 
    ENGINE_API virtual void EditorApplyRotation(const FRotator& DeltaRotation, bool bAltDown, bool bShiftDown, bool bCtrlDown);
 
    ENGINE_API virtual void EditorApplyScale(const FVector& DeltaScale, const FVector* PivotLocation, bool bAltDown, bool bShiftDown, bool bCtrlDown);
 
    ENGINE_API virtual void EditorApplyMirror(const FVector& MirrorScale, const FVector& PivotLocation);    
 
    ENGINE_API virtual void EditorGetUnderlyingActors(TSet<AActor*>& OutUnderlyingActors) const;
 
    UFUNCTION(BlueprintCallable, Category = "Editor Scripting | Actor Editing")
    bool IsHiddenEdAtStartup() const
    {
        return bHiddenEd;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Editor Scripting | Actor Editing")
    ENGINE_API virtual bool IsHiddenEd() const;
 
    UFUNCTION(BlueprintCallable, Category="Editor Scripting | Actor Editing")
    ENGINE_API virtual void SetIsTemporarilyHiddenInEditor( bool bIsHidden );
 
    ENGINE_API virtual bool SetIsHiddenEdLayer(bool bIsHiddenEdLayer);
 
    ENGINE_API virtual bool SupportsLayers() const;
 
    ENGINE_API bool IsForceExternalActorLevelReferenceForPIE() const;
 
    void SetForceExternalActorLevelReferenceForPIE(bool bValue)
    {
        if (IsPackageExternal())
        {
            bForceExternalActorLevelReferenceForPIE = bValue;
        }
    }
 
    ENGINE_API bool GetIsSpatiallyLoaded() const;
    
    void SetIsSpatiallyLoaded(bool bInIsSpatiallyLoaded)
    {
        if (bIsSpatiallyLoaded != bInIsSpatiallyLoaded)
        {
            check(CanChangeIsSpatiallyLoadedFlag());
            bIsSpatiallyLoaded = bInIsSpatiallyLoaded;
        }
    }
 
    ENGINE_API virtual bool CanChangeIsSpatiallyLoadedFlag() const;
 
    static const FName GetIsSpatiallyLoadedPropertyName() { return GET_MEMBER_NAME_CHECKED(AActor, bIsSpatiallyLoaded); }
 
    UFUNCTION(BlueprintCallable, Category = "Editor Scripting | Actor Editing")
    ENGINE_API bool IsTemporarilyHiddenInEditor(bool bIncludeParent = false) const;
 
    UFUNCTION(BlueprintCallable, Category = "Editor Scripting | Actor Editing")
    ENGINE_API bool IsEditable() const;
 
    UFUNCTION(BlueprintCallable, Category = "Editor Scripting | Actor Editing")
    ENGINE_API virtual bool IsSelectable() const;
 
    ENGINE_API virtual bool IsListedInSceneOutliner() const;
 
    ENGINE_API virtual bool EditorCanAttachTo(const AActor* InParent, FText& OutReason) const;
 
    ENGINE_API virtual bool EditorCanAttachFrom(const AActor* InChild, FText& OutReason) const;
 
    virtual bool EditorCanDetachFrom(const AActor* InParent, FText& OutReason) const { return true; }
 
    ENGINE_API virtual AActor* GetSceneOutlinerParent() const;
 
    UE_DEPRECATED(5.6, "Please use GetSceneOutlinerItemPackage or GetSceneOutlinerTopParentPackage instead.")
    ENGINE_API virtual UPackage* GetSceneOutlinerPackage() const;
 
    ENGINE_API virtual UPackage* GetSceneOutlinerItemPackage() const;
 
    ENGINE_API virtual UPackage* GetSceneOutlinerTopParentPackage() const;
 
    virtual bool ShouldExport() { return true; }
 
    UE_DEPRECATED(5.2, "Use the override that takes a StringView instead")
    virtual bool ShouldImport(FString* ActorPropString, bool IsMovingLevel) { return ActorPropString ? ShouldImport(FStringView(*ActorPropString), IsMovingLevel) : ShouldImport(FStringView(), IsMovingLevel); }
 
    virtual bool ShouldImport(FStringView ActorPropString, bool IsMovingLevel) { return true; }
 
    UE_DEPRECATED(5.4, "Please use UI Commands and process your custom actors as necessary by extending the level editor modules' global command list.")
    virtual void EditorKeyPressed(FKey Key, EInputEvent Event) {}
 
    ENGINE_API virtual void EditorReplacedActor(AActor* OldActor);
 
    ENGINE_API virtual void CheckForErrors();
 
    ENGINE_API virtual void CheckForDeprecated();
 
    UFUNCTION(BlueprintCallable, Category = "Editor Scripting | Actor Editing", meta = (KeyWords = "Display Name"))
    ENGINE_API virtual FString GetDefaultActorLabel() const;
 
    UFUNCTION(BlueprintCallable, Category = "Editor Scripting | Actor Editing", meta = (KeyWords = "Display Name"))
    ENGINE_API const FString& GetActorLabel(bool bCreateIfNone = true) const;
 
    UFUNCTION(BlueprintCallable, Category = "Editor Scripting | Actor Editing", meta = (KeyWords = "Display Name"))
    ENGINE_API void SetActorLabel( const FString& NewActorLabel, bool bMarkDirty = true );
 
    ENGINE_API void ClearActorLabel();
 
    void SetInitialActorLabel(FStringView InitialLabel);
 
    ENGINE_API virtual bool IsActorLabelEditable() const;
 
    UFUNCTION(BlueprintCallable, Category = "Editor Scripting | Actor Editing")
    ENGINE_API FName GetFolderPath() const;
 
    /*
     * Returns actor folder guid. If level is not using actor folder objects, returns an invalid guid. 
     * @param bDirectAccess If true, returns the raw value without testing if level uses Actor Folders.
     */
    ENGINE_API FGuid GetFolderGuid(bool bDirectAccess = false) const;
 
    ENGINE_API FFolder::FRootObject GetFolderRootObject() const;
    
    ENGINE_API void FixupActorFolder();
 
    ENGINE_API bool CreateOrUpdateActorFolder();
 
    ENGINE_API FFolder GetFolder() const;
 
    UFUNCTION(BlueprintCallable, Category = "Editor Scripting | Actor Editing")
    ENGINE_API void SetFolderPath(const FName& NewFolderPath);
 
    ENGINE_API void SetFolderPath_Recursively(const FName& NewFolderPath);
 
    ENGINE_API virtual bool GetReferencedContentObjects( TArray<UObject*>& Objects ) const;
 
    ENGINE_API virtual bool GetSoftReferencedContentObjects(TArray<FSoftObjectPath>& SoftObjects) const;
 
    virtual bool OpenAssetEditor() { return false; }
 
    ENGINE_API const int32 GetNumUncachedStaticLightingInteractions() const;
 
    virtual FName GetCustomIconName() const { return NAME_None; }
 
    inline bool ShouldCookOptimizedBPComponentData() const
    {
        return bOptimizeBPComponentData;
    }
 
    UE_DEPRECATED(5.7, "SetBrowseToAssetOverride is deprecated as it was unreliable. Register a callback with UBrowseToAssetOverrideSubsystem instead, and store the override as a property on your actor.")
    ENGINE_API void SetBrowseToAssetOverride(const FString& PackageName);
    UE_DEPRECATED(5.7, "GetBrowseToAssetOverride is deprecated. Use UBrowseToAssetOverrideSubsystem::GetBrowseToAssetOverride instead.")
    ENGINE_API const FString& GetBrowseToAssetOverride() const;
#endif      // WITH_EDITOR
 
    ENGINE_API virtual float GetNetPriority(const FVector& ViewPos, const FVector& ViewDir, class AActor* Viewer, AActor* ViewTarget, UActorChannel* InChannel, float Time, bool bLowBandwidth);
 
    ENGINE_API virtual float GetReplayPriority(const FVector& ViewPos, const FVector& ViewDir, class AActor* Viewer, AActor* ViewTarget, UActorChannel* const InChannel, float Time);
 
    ENGINE_API virtual bool GetNetDormancy(const FVector& ViewPos, const FVector& ViewDir, class AActor* Viewer, AActor* ViewTarget, UActorChannel* InChannel, float Time, bool bLowBandwidth);
 
    virtual void OnActorChannelOpen(class FInBunch& InBunch, class UNetConnection* Connection) {};
 
    virtual bool UseShortConnectTimeout() const { return false; }
 
    virtual void OnSerializeNewActor(class FOutBunch& OutBunch) {};
 
    virtual void OnNetCleanup(class UNetConnection* Connection) {};
 
    ENGINE_API void ExchangeNetRoles(bool bRemoteOwner);
 
    ENGINE_API void SwapRoles();
 
    ENGINE_API void RegisterAllActorTickFunctions(bool bRegister, bool bDoComponents);
 
    UFUNCTION(BlueprintCallable, Category="Actor|Tick")
    ENGINE_API virtual void SetActorTickEnabled(bool bEnabled);
 
    UFUNCTION(BlueprintCallable, Category="Actor|Tick")
    ENGINE_API bool IsActorTickEnabled() const;
 
    UFUNCTION(BlueprintCallable, Category="Actor|Tick")
    ENGINE_API void SetActorTickInterval(float TickInterval);
 
    UFUNCTION(BlueprintCallable, Category="Actor|Tick")
    ENGINE_API float GetActorTickInterval() const;
 
    ENGINE_API virtual void TickActor( float DeltaTime, enum ELevelTick TickType, FActorTickFunction& ThisTickFunction );
 
    virtual void AsyncPhysicsTickActor(float DeltaTime, float SimTime) { ReceiveAsyncPhysicsTick(DeltaTime, SimTime); }
 
    ENGINE_API virtual void PostActorCreated();
 
    ENGINE_API virtual void LifeSpanExpired();
 
    ENGINE_API virtual void PreNetReceive() override;
    
    ENGINE_API virtual void PostNetReceive() override;
 
    ENGINE_API virtual void PostNetReceiveRole();
 
    ENGINE_API virtual bool IsNameStableForNetworking() const override;
 
    ENGINE_API virtual bool IsSupportedForNetworking() const override;
 
    ENGINE_API virtual void PostNetInit();
 
    UFUNCTION()
    ENGINE_API virtual void OnRep_ReplicatedMovement();
 
    ENGINE_API virtual void PostNetReceiveLocationAndRotation();
 
    ENGINE_API virtual void PostNetReceiveVelocity(const FVector& NewVelocity);
 
    ENGINE_API virtual void PostNetReceivePhysicState();
 
    void SetFakeNetPhysicsState(bool bShouldSleep);
 
protected:
    ENGINE_API void SyncReplicatedPhysicsSimulation();
 
public:
    UFUNCTION(BlueprintCallable, Category=Actor)
    ENGINE_API virtual void SetOwner( AActor* NewOwner );
 
    UFUNCTION(BlueprintCallable, Category=Actor)
    AActor* GetOwner() const;
 
    template< class T >
    T* GetOwner() const
    {
        return Cast<T>(GetOwner());
    }
 
    ENGINE_API virtual bool CheckStillInWorld();
 
#if WITH_EDITOR
    ENGINE_API virtual EDataValidationResult IsDataValid(class FDataValidationContext& Context) const override;
#endif // WITH_EDITOR
 
 
    //~=============================================================================
    // Actor overlap tracking
    
    ENGINE_API void ClearComponentOverlaps();
 
    ENGINE_API void UpdateOverlaps(bool bDoNotifies=true);
    
    UFUNCTION(BlueprintCallable, Category="Collision", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API bool IsOverlappingActor(const AActor* Other) const;
 
    ENGINE_API bool IsRootComponentStatic() const;
 
    ENGINE_API bool IsRootComponentStationary() const;
 
    ENGINE_API bool IsRootComponentMovable() const;
 
    ENGINE_API virtual APhysicsVolume* GetPhysicsVolume() const;
 
    //~=============================================================================
    // Actor ticking
 
    inline bool CanEverTick() const { return PrimaryActorTick.bCanEverTick; }
 
    ENGINE_API virtual void Tick( float DeltaSeconds );
 
    ENGINE_API virtual bool ShouldTickIfViewportsOnly() const;
 
 
    //~=============================================================================
    // Actor relevancy determination
 
protected:
    ENGINE_API bool IsWithinNetRelevancyDistance(const FVector& SrcLocation) const;
    
public: 
    ENGINE_API virtual bool IsNetRelevantFor(const AActor* RealViewer, const AActor* ViewTarget, const FVector& SrcLocation) const;
 
    ENGINE_API virtual bool IsReplayRelevantFor(const AActor* RealViewer, const AActor* ViewTarget, const FVector& SrcLocation, const float CullDistanceSquared) const;
 
    ENGINE_API virtual bool IsRelevancyOwnerFor(const AActor* ReplicatedActor, const AActor* ActorOwner, const AActor* ConnectionActor) const;
 
    ENGINE_API void PostSpawnInitialize(FTransform const& SpawnTransform, AActor* InOwner, APawn* InInstigator, bool bRemoteOwned, bool bNoFail, bool bDeferConstruction, ESpawnActorScaleMethod TransformScaleMethod = ESpawnActorScaleMethod::MultiplyWithRoot);
 
    ENGINE_API void FinishSpawning(const FTransform& Transform, bool bIsDefaultTransform = false, const FComponentInstanceDataCache* InstanceDataCache = nullptr, ESpawnActorScaleMethod TransformScaleMethod = ESpawnActorScaleMethod::OverrideRootScale);
 
    ENGINE_API void PostActorConstruction();
 
public:
    ENGINE_API virtual void PreInitializeComponents();
 
    ENGINE_API virtual void PostInitializeComponents();
 
 
    ENGINE_API virtual void DispatchPhysicsCollisionHit(const struct FRigidBodyCollisionInfo& MyInfo, const struct FRigidBodyCollisionInfo& OtherInfo, const FCollisionImpactData& RigidCollisionData);
    
    virtual const AActor* GetNetOwner() const;
 
    ENGINE_API virtual class UPlayer* GetNetOwningPlayer();
 
    ENGINE_API virtual class UPlayer* GetNetOwningPlayerAnyRole();
 
    ENGINE_API virtual class UNetConnection* GetNetConnection() const;
 
    ENGINE_API virtual bool DestroyNetworkActorHandled();
 
    ENetMode GetNetMode() const;
 
    bool IsNetMode(ENetMode Mode) const;
 
    ENGINE_API class UNetDriver* GetNetDriver() const;
 
    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, Category = "Networking")
    ENGINE_API void SetNetDormancy(ENetDormancy NewDormancy);
 
    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, Category="Networking")
    ENGINE_API void FlushNetDormancy();
 
    ENGINE_API void ForcePropertyCompare();
 
    UFUNCTION(BlueprintCallable, Category="Actor")
    ENGINE_API bool IsChildActor() const;
 
    ENGINE_API virtual bool IsSelectionParentOfAttachedActors() const;
 
    ENGINE_API virtual bool IsSelectionChild() const;
 
    ENGINE_API virtual AActor* GetSelectionParent() const;
 
    ENGINE_API virtual AActor* GetRootSelectionParent() const;
 
    ENGINE_API virtual bool SupportsSubRootSelection() const;
 
    ENGINE_API bool IsActorOrSelectionParentSelected() const;
 
    ENGINE_API virtual void PushSelectionToProxies();
 
#if WITH_EDITOR
    ENGINE_API virtual void PushLevelInstanceEditingStateToProxies(bool bInEditingState);
#endif
 
    UFUNCTION(BlueprintCallable, Category="Actor")
    ENGINE_API void GetAllChildActors(TArray<AActor*>& ChildActors, bool bIncludeDescendants = true) const;
 
    UFUNCTION(BlueprintCallable, Category="Actor")
    ENGINE_API UChildActorComponent* GetParentComponent() const;
 
    UFUNCTION(BlueprintCallable, Category="Actor")
    ENGINE_API AActor* GetParentActor() const;
 
    ENGINE_API virtual void RegisterAllComponents();
 
    ENGINE_API virtual void PreRegisterAllComponents();
 
    ENGINE_API virtual void PostRegisterAllComponents();
 
    inline bool HasDeferredComponentRegistration() const { return bHasDeferredComponentRegistration; }
 
    ENGINE_API bool HasValidRootComponent() const;
 
    ENGINE_API virtual void UnregisterAllComponents(bool bForReregister = false);
 
    ENGINE_API virtual void PostUnregisterAllComponents();
 
    ENGINE_API virtual void ReregisterAllComponents();
 
    ENGINE_API void HandleRegisterComponentWithWorld(UActorComponent* Component);
 
    ENGINE_API bool IncrementalRegisterComponents(int32 NumComponentsToRegister, FRegisterComponentContext* Context = nullptr);
 
    ENGINE_API void MarkComponentsRenderStateDirty();
 
    ENGINE_API void UpdateComponentTransforms();
 
    ENGINE_API void UpdateComponentVisibility();
 
    ENGINE_API void InitializeComponents();
 
    ENGINE_API void UninitializeComponents();
 
    ENGINE_API void DrawDebugComponents(FColor const& BaseColor=FColor::White) const;
 
    
    UE_DEPRECATED(5.3, "Use MarkComponentsAsGarbage instead.")
    virtual void MarkComponentsAsPendingKill() { MarkComponentsAsGarbage(); }
 
    ENGINE_API virtual void MarkComponentsAsGarbage(bool bModify = true);
    
    inline bool IsPendingKillPending() const
    {
        return bActorIsBeingDestroyed || !IsValidChecked(this);
    }
 
    void InvalidateLightingCache()
    {
        if (GIsEditor && !GIsDemoMode)
        {
            InvalidateLightingCacheDetailed(false);
        }
    }
 
    ENGINE_API virtual void InvalidateLightingCacheDetailed(bool bTranslationOnly);
 
    ENGINE_API virtual bool TeleportTo( const FVector& DestLocation, const FRotator& DestRotation, bool bIsATest=false, bool bNoCheck=false );
 
    UFUNCTION(BlueprintCallable, meta=( DisplayName="Teleport", ScriptName="Teleport", Keywords = "Move Position" ), Category="Transformation")
    ENGINE_API bool K2_TeleportTo( FVector DestLocation, FRotator DestRotation );
 
    virtual void TeleportSucceeded(bool bIsATest) {}
 
    ENGINE_API bool ActorLineTraceSingle(struct FHitResult& OutHit, const FVector& Start, const FVector& End, ECollisionChannel TraceChannel, const struct FCollisionQueryParams& Params) const;
 
    ENGINE_API float ActorGetDistanceToCollision(const FVector& Point, ECollisionChannel TraceChannel, FVector& ClosestPointOnCollision, UPrimitiveComponent** OutPrimitiveComponent = nullptr) const;
 
    ENGINE_API bool IsInLevel(const class ULevel *TestLevel) const;
 
    UFUNCTION(BlueprintCallable, Category=Level)
    ENGINE_API ULevel* GetLevel() const;
 
    UFUNCTION(BlueprintCallable, Category=Level)
    ENGINE_API FTransform GetLevelTransform() const;
 
    ENGINE_API virtual void ClearCrossLevelReferences();
    
    ENGINE_API void RouteEndPlay(const EEndPlayReason::Type EndPlayReason);
 
    ENGINE_API virtual bool IsBasedOnActor(const AActor* Other) const;
    
    ENGINE_API virtual bool IsAttachedTo( const AActor* Other ) const;
 
    ENGINE_API FVector GetPlacementExtent() const;
 
 
    //~=============================================================================
    // Blueprint
 
#if WITH_EDITOR
    ENGINE_API void SeedAllRandomStreams();
#endif // WITH_EDITOR
 
    ENGINE_API void ResetPropertiesForConstruction();
 
    ENGINE_API bool HasNonTrivialUserConstructionScript() const;
 
#if WITH_EDITOR
    ENGINE_API virtual void RerunConstructionScripts();
#endif
 
    ENGINE_API void DebugShowComponentHierarchy( const TCHAR* Info, bool bShowPosition  = true);
    
    ENGINE_API void DebugShowOneComponentHierarchy( USceneComponent* SceneComp, int32& NestLevel, bool bShowPosition );
 
    ENGINE_API bool ExecuteConstruction(const FTransform& Transform, const struct FRotationConversionCache* TransformRotationCache, const class FComponentInstanceDataCache* InstanceDataCache, bool bIsDefaultTransform = false, ESpawnActorScaleMethod TransformScaleMethod = ESpawnActorScaleMethod::OverrideRootScale);
 
    virtual void OnConstruction(const FTransform& Transform) {}
 
    ENGINE_API void FinishAndRegisterComponent(UActorComponent* Component);
 
    ENGINE_API UActorComponent* CreateComponentFromTemplate(UActorComponent* Template, const FName InName = NAME_None );
    ENGINE_API UActorComponent* CreateComponentFromTemplateData(const struct FBlueprintCookedComponentInstancingData* TemplateData, const FName InName = NAME_None);
 
    ENGINE_API void DestroyConstructedComponents();
 
    ENGINE_API virtual void RegisterReplicationFragments(UE::Net::FFragmentRegistrationContext& Context, UE::Net::EFragmentRegistrationFlags RegistrationFlags) override;
 
    struct FFillReplicationParamsContext
    {
    };
    ENGINE_API virtual void FillReplicationParams(const FFillReplicationParamsContext& Context, FActorReplicationParams& OutParams);
 
protected:
 
    struct FOnReplicationStartedParams
    {
    };
    ENGINE_API virtual void OnReplicationStartedForIris(const FOnReplicationStartedParams&);
 
    struct FOnStopReplicationParams
    {
        const FStopReplicatingActorParams& StopReplicatingParams;
    };
    ENGINE_API virtual void OnStopReplicationForIris(const FOnStopReplicationParams&);
 
    UE_DEPRECATED(5.7, "This is being deprecated as part of iris beta. Use OnReplicationStartedForIris or FillReplicationParams overrides instead.")
    ENGINE_API virtual void BeginReplication();
 
    UE_DEPRECATED(5.7, "This is being deprecated as part of iris beta. Override OnStopReplicationForIris instead.")
    ENGINE_API virtual void EndReplication(EEndPlayReason::Type EndPlayReason);
 
    UE_DEPRECATED(5.7, "This is being deprecated as part of iris beta. Do not call directly override FillReplicationParams instead to provide custom parameters.")
    ENGINE_API void BeginReplication(const FActorReplicationParams& Params);
 
    ENGINE_API void UpdateOwningNetConnection();
 
    friend struct UE::Net::FReplicationSystemUtil;
 
 
    ENGINE_API void UpdateReplicatePhysicsCondition();
    
protected:
    ENGINE_API virtual void RegisterActorTickFunctions(bool bRegister);
 
    ENGINE_API void ProcessUserConstructionScript();
 
    ENGINE_API bool CheckActorComponents() const;
 
    ENGINE_API void PostCreateBlueprintComponent(UActorComponent* NewActorComp);
 
public:
    ENGINE_API void CheckComponentInstanceName(const FName InName);
 
    UFUNCTION(BlueprintPure, Category = "Actor")
    ENGINE_API AActor* GetAttachParentActor() const;
 
    UFUNCTION(BlueprintPure, Category = "Actor")
    ENGINE_API FName GetAttachParentSocketName() const;
 
    ENGINE_API void ForEachAttachedActors(TFunctionRef<bool(class AActor*)> Functor) const;
    
    UFUNCTION(BlueprintPure, Category = "Actor")
    ENGINE_API void GetAttachedActors(TArray<AActor*>& OutActors, bool bResetArray = true, bool bRecursivelyIncludeAttachedActors = false) const;
 
    UFUNCTION(BlueprintCallable, Category="Actor|Tick", meta=(Keywords = "dependency"))
    ENGINE_API void SetTickGroup(ETickingGroup NewTickGroup);
 
    ENGINE_API virtual void Destroyed();
 
    ENGINE_API void DispatchBlockingHit(UPrimitiveComponent* MyComp, UPrimitiveComponent* OtherComp, bool bSelfMoved, FHitResult const& Hit);
 
    ENGINE_API virtual void FellOutOfWorld(const class UDamageType& dmgType);
 
    ENGINE_API virtual void OutsideWorldBounds();
 
    ENGINE_API virtual FBox GetComponentsBoundingBox(bool bNonColliding = false, bool bIncludeFromChildActors = false) const;
 
    ENGINE_API virtual FBox CalculateComponentsBoundingBoxInLocalSpace(bool bNonColliding = false, bool bIncludeFromChildActors = false) const;
 
    ENGINE_API virtual void GetComponentsBoundingCylinder(float& CollisionRadius, float& CollisionHalfHeight, bool bNonColliding = false, bool bIncludeFromChildActors = false) const;
 
    ENGINE_API virtual void GetSimpleCollisionCylinder(float& CollisionRadius, float& CollisionHalfHeight) const;
 
    float GetSimpleCollisionRadius() const;
 
    float GetSimpleCollisionHalfHeight() const;
 
    FVector GetSimpleCollisionCylinderExtent() const;
 
    ENGINE_API virtual bool IsRootComponentCollisionRegistered() const;
 
    ENGINE_API virtual void TornOff();
 
 
    //~=============================================================================
    // Collision/Physics functions.
 
    ENGINE_API virtual ECollisionResponse GetComponentsCollisionResponseToChannel(ECollisionChannel Channel) const;
 
    ENGINE_API void DisableComponentsSimulatePhysics();
 
    ENGINE_API class AWorldSettings* GetWorldSettings() const;
 
    ENGINE_API virtual bool CanBeBaseForCharacter(class APawn* Pawn) const;
 
    ENGINE_API virtual float TakeDamage(float DamageAmount, struct FDamageEvent const& DamageEvent, class AController* EventInstigator, AActor* DamageCauser);
 
protected:
    ENGINE_API virtual float InternalTakeRadialDamage(float Damage, struct FRadialDamageEvent const& RadialDamageEvent, class AController* EventInstigator, AActor* DamageCauser);
    ENGINE_API virtual float InternalTakePointDamage(float Damage, struct FPointDamageEvent const& PointDamageEvent, class AController* EventInstigator, AActor* DamageCauser);
 
public:
    ENGINE_API virtual void BecomeViewTarget( class APlayerController* PC );
 
    ENGINE_API virtual void EndViewTarget( class APlayerController* PC );
 
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName="OnBecomeViewTarget", ScriptName="OnBecomeViewTarget", Keywords="Activate Camera"), Category=Actor)
    ENGINE_API void K2_OnBecomeViewTarget( class APlayerController* PC );
 
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName="OnEndViewTarget", ScriptName="OnEndViewTarget", Keywords="Deactivate Camera"), Category=Actor)
    ENGINE_API void K2_OnEndViewTarget( class APlayerController* PC );
 
    ENGINE_API virtual void CalcCamera(float DeltaTime, struct FMinimalViewInfo& OutResult);
 
    ENGINE_API virtual bool HasActiveCameraComponent(bool bForceFindCamera = false) const;
 
    ENGINE_API virtual bool HasActivePawnControlCameraComponent() const;
 
    ENGINE_API virtual FString GetHumanReadableName() const;
 
    ENGINE_API virtual void Reset();
 
    UFUNCTION(BlueprintImplementableEvent, Category=Actor, meta=(DisplayName="OnReset", ScriptName="OnReset"))
    ENGINE_API void K2_OnReset();
 
    UFUNCTION(Category="Rendering", BlueprintCallable, meta=(DisplayName="Was Actor Recently Rendered", Keywords="scene visible"))
    ENGINE_API bool WasRecentlyRendered(float Tolerance = 0.2f) const;
 
    ENGINE_API virtual float GetLastRenderTime() const;
 
    ENGINE_API virtual void ForceNetRelevant();
 
    UFUNCTION( BlueprintCallable, Category="Networking")
    ENGINE_API virtual void ForceNetUpdate();
 
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    ENGINE_API virtual void PrestreamTextures( float Seconds, bool bEnableStreaming, int32 CinematicTextureGroups = 0 );
 
    UFUNCTION(BlueprintCallable, Category = Actor)
    ENGINE_API virtual void GetActorEyesViewPoint( FVector& OutLocation, FRotator& OutRotation ) const;
 
    ENGINE_API virtual FVector GetTargetLocation(AActor* RequestedBy = nullptr) const;
 
    ENGINE_API virtual void PostRenderFor(class APlayerController* PC, class UCanvas* Canvas, FVector CameraPosition, FVector CameraDir);
 
    ENGINE_API bool IsInPersistentLevel(bool bIncludeLevelStreamingPersistent = false) const;
 
    ENGINE_API virtual UWorld* GetWorld() const override final;
 
    ENGINE_API class FTimerManager& GetWorldTimerManager() const;
 
    ENGINE_API class UGameInstance* GetGameInstance() const;
    
    template< class T >
    T* GetGameInstance() const 
    { 
        return Cast<T>(GetGameInstance()); 
    }
 
    ENGINE_API bool IsNetStartupActor() const;
 
    ENGINE_API virtual UActorComponent* FindComponentByClass(const TSubclassOf<UActorComponent> ComponentClass) const;
    
    UFUNCTION(BlueprintCallable, Category = "Actor", meta = (ComponentClass = "/Script/Engine.ActorComponent"), meta = (DeterminesOutputType = "ComponentClass"))
    ENGINE_API UActorComponent* GetComponentByClass(TSubclassOf<UActorComponent> ComponentClass) const;
 
    template<class T>
    T* GetComponentByClass() const
    {
        return FindComponentByClass<T>();
    }
 
    UFUNCTION(BlueprintCallable, Category = "Actor", meta = (ComponentClass = "/Script/Engine.ActorComponent", DisplayName = "Get Components By Class", ScriptName = "GetComponentsByClass", DeterminesOutputType = "ComponentClass"))
    ENGINE_API TArray<UActorComponent*> K2_GetComponentsByClass(TSubclassOf<UActorComponent> ComponentClass) const;
 
    UFUNCTION(BlueprintCallable, Category = "Actor", meta = (ComponentClass = "/Script/Engine.ActorComponent"), meta = (DeterminesOutputType = "ComponentClass"))
    ENGINE_API UActorComponent* FindComponentByTag(TSubclassOf<UActorComponent> ComponentClass, FName Tag) const;
 
    UFUNCTION(BlueprintCallable, Category = "Actor", meta = (ComponentClass = "/Script/Engine.ActorComponent"), meta = (DeterminesOutputType = "ComponentClass"))
    ENGINE_API TArray<UActorComponent*> GetComponentsByTag(TSubclassOf<UActorComponent> ComponentClass, FName Tag) const;
 
    ENGINE_API virtual UActorComponent* FindComponentByInterface(const TSubclassOf<UInterface> Interface) const;
    
    UFUNCTION(BlueprintCallable, Category = "Actor")
    ENGINE_API TArray<UActorComponent*> GetComponentsByInterface(TSubclassOf<UInterface> Interface) const;
 
    template<class T>
    T* FindComponentByClass() const
    {
        static_assert(TPointerIsConvertibleFromTo<T, const UActorComponent>::Value, "'T' template parameter to FindComponentByClass must be derived from UActorComponent");
 
        return (T*)FindComponentByClass(T::StaticClass());
    }
    
    template<class T>
    T* FindComponentByTag(const FName& Tag) const
    {
        static_assert(TPointerIsConvertibleFromTo<T, const UActorComponent>::Value, "'T' template parameter to FindComponentByTag must be derived from UActorComponent");
 
        return (T*)FindComponentByTag(T::StaticClass(), Tag);
    }
 
    template<class T UE_REQUIRES(TPointerIsConvertibleFromTo<T, UInterface>::Value)>
    UE_DEPRECATED(5.5, "This version incorrectly casts to the UInterface type used for reflection. Use FindComponentByInterface<IMyInterface>() instead")
    T* FindComponentByInterface() const
    {
        return (T*)FindComponentByInterface(T::StaticClass());
    }
 
    template<class T UE_REQUIRES(TIsIInterface<T>::Value)>
    T* FindComponentByInterface() const
    {
        return Cast<T>(FindComponentByInterface(T::UClassType::StaticClass()));
    }
 
private:
 
    template<class ComponentType, bool bClassIsActorComponent, bool bIncludeFromChildActors, typename Func>
    void ForEachComponent_Internal(TSubclassOf<UActorComponent> InComponentClass, Func InFunc) const
    {
        if (const UClass* ComponentClass = InComponentClass)
        {
            check(bClassIsActorComponent == false || ComponentClass == UActorComponent::StaticClass());
            check(ComponentClass->IsChildOf(ComponentType::StaticClass()));
 
            // static check, so that the most common case (bIncludeFromChildActors) doesn't need to allocate an additional array : 
            if (bIncludeFromChildActors)
            {
                TArray<AActor*, TInlineAllocator<NumInlinedActorComponents>> ChildActors;
                for (UActorComponent* OwnedComponent : OwnedComponents)
                {
                    if (OwnedComponent)
                    {
                        if (bClassIsActorComponent || OwnedComponent->IsA(ComponentClass))
                        {
                            InFunc(static_cast<ComponentType *>(OwnedComponent));
                        }
                        if (UChildActorComponent* ChildActorComponent = Cast<UChildActorComponent>(OwnedComponent))
                        {
                            if (AActor* ChildActor = ChildActorComponent->GetChildActor())
                            {
                                ChildActors.Add(ChildActor);
                            }
                        }
                    }
                }
 
                for (AActor* ChildActor : ChildActors)
                {
                    ChildActor->ForEachComponent_Internal<ComponentType, bClassIsActorComponent, bIncludeFromChildActors>(InComponentClass, InFunc);
                }
            }
            else
            {
                for (UActorComponent* OwnedComponent : OwnedComponents)
                {
                    if (OwnedComponent)
                    {
                        if (bClassIsActorComponent || OwnedComponent->IsA(ComponentClass))
                        {
                            InFunc(static_cast<ComponentType *>(OwnedComponent));
                        }
                    }
                }
            }
        }
    }
 
    template<class ComponentType, typename Func>
    void ForEachComponent_Internal(TSubclassOf<UActorComponent> ComponentClass, bool bIncludeFromChildActors, Func InFunc) const
    {
        static_assert(TPointerIsConvertibleFromTo<ComponentType, const UActorComponent>::Value, "'ComponentType' template parameter to ForEachComponent must be derived from UActorComponent");
        if (ComponentClass == UActorComponent::StaticClass())
        {
            if (bIncludeFromChildActors)
            {
                ForEachComponent_Internal<ComponentType, true /*bClassIsActorComponent*/, true /*bIncludeFromChildActors*/>(ComponentClass, InFunc);
            }
            else
            {
                ForEachComponent_Internal<ComponentType, true /*bClassIsActorComponent*/, false /*bIncludeFromChildActors*/>(ComponentClass, InFunc);
            }
        }
        else
        {
            if (bIncludeFromChildActors)
            {
                ForEachComponent_Internal<ComponentType, false /*bClassIsActorComponent*/, true /*bIncludeFromChildActors*/>(ComponentClass, InFunc);
            }
            else
            {
                ForEachComponent_Internal<ComponentType, false /*bClassIsActorComponent*/, false /*bIncludeFromChildActors*/>(ComponentClass, InFunc);
            }
        }
    }
 
public:
 
    template<class ComponentType, typename Func>
    void ForEachComponent(bool bIncludeFromChildActors, Func InFunc) const
    {       
        ForEachComponent_Internal<ComponentType>(ComponentType::StaticClass(), bIncludeFromChildActors, InFunc);
    }
 
    template<typename Func>
    void ForEachComponent(bool bIncludeFromChildActors, Func InFunc) const
    {
        ForEachComponent_Internal<UActorComponent>(UActorComponent::StaticClass(), bIncludeFromChildActors, InFunc);
    }
 
    template<class AllocatorType, class ComponentType>
    void GetComponents(TSubclassOf<UActorComponent> ComponentClass, TArray<ComponentType*, AllocatorType>& OutComponents, bool bIncludeFromChildActors = false) const
    {
        OutComponents.Reset();
        ForEachComponent_Internal<ComponentType>(ComponentClass, bIncludeFromChildActors, [&](ComponentType* InComp)
        {
            OutComponents.Add(InComp);
        });
    }
 
    template<class ComponentType, class AllocatorType>
    void GetComponents(TArray<ComponentType, AllocatorType>& OutComponents, bool bIncludeFromChildActors = false) const
    {
        typedef TPointedToType<ComponentType> T;
 
        OutComponents.Reset();
        ForEachComponent_Internal<T>(T::StaticClass(), bIncludeFromChildActors, [&](T* InComp)
        {
            OutComponents.Add(InComp);
        });
    }
 
    template<class T, class AllocatorType>
    void GetComponents(TArray<T*, AllocatorType>& OutComponents, bool bIncludeFromChildActors = false) const
    {
        // We should consider removing this function.  It's not really hurting anything by existing but the one above it was added so that
        // we weren't assuming T*, preventing TObjectPtrs from working for this function.  The only downside is all the people who force the
        // template argument with GetComponents's code suddenly not compiling with no clear error message.
 
        OutComponents.Reset();
        ForEachComponent_Internal<T>(T::StaticClass(), bIncludeFromChildActors, [&](T* InComp)
        {
            OutComponents.Add(InComp);
        });
    }
 
    template<class T, class AllocatorType>
    void GetComponents(TArray<TObjectPtr<T>, AllocatorType>& OutComponents, bool bIncludeFromChildActors = false) const
    {
        OutComponents.Reset();
        ForEachComponent_Internal<T>(T::StaticClass(), bIncludeFromChildActors, [&](T* InComp)
            {
                OutComponents.Add(InComp);
            });
    }
 
    template<class AllocatorType>
    void GetComponents(TArray<UActorComponent*, AllocatorType>& OutComponents, bool bIncludeFromChildActors = false) const
    {
        OutComponents.Reset();
        ForEachComponent_Internal<UActorComponent>(UActorComponent::StaticClass(), bIncludeFromChildActors, [&](UActorComponent* InComp)
        {
            OutComponents.Add(InComp);
        });
    }
 
    const TSet<UActorComponent*>& GetComponents() const
    {
        return ObjectPtrDecay(OwnedComponents);
    }
 
    ENGINE_API void AddOwnedComponent(UActorComponent* Component);
 
    ENGINE_API void RemoveOwnedComponent(UActorComponent* Component);
 
#if DO_CHECK || USING_CODE_ANALYSIS
    ENGINE_API bool OwnsComponent(UActorComponent* Component) const;
#endif
 
    ENGINE_API void ResetOwnedComponents();
 
    ENGINE_API void UpdateReplicatedComponent(UActorComponent* Component);
 
    ENGINE_API void UpdateAllReplicatedComponents();
 
    ENGINE_API virtual ELifetimeCondition AllowActorComponentToReplicate(const UActorComponent* ComponentToReplicate) const;
 
    ENGINE_API void SetReplicatedComponentNetCondition(const UActorComponent* ReplicatedComponent, ELifetimeCondition NetCondition);
 
    inline bool GetIsReplicated() const
    {
        return bReplicates;
    }
 
    const TArray<UActorComponent*>& GetReplicatedComponents() const
    { 
        return ReplicatedComponents; 
    }
 
    ENGINE_API void AddReplicatedSubObject(UObject* SubObject, ELifetimeCondition NetCondition = COND_None);
 
    ENGINE_API void RemoveReplicatedSubObject(UObject* SubObject);
 
    ENGINE_API void DestroyReplicatedSubObjectOnRemotePeers(UObject* SubObject);
 
    ENGINE_API void DestroyReplicatedSubObjectOnRemotePeers(UActorComponent* OwnerComponent, UObject* SubObject);
 
    ENGINE_API void TearOffReplicatedSubObjectOnRemotePeers(UObject* SubObject);
 
    ENGINE_API void TearOffReplicatedSubObjectOnRemotePeers(UActorComponent* OwnerComponent, UObject* SubObject);
 
    ENGINE_API void AddActorComponentReplicatedSubObject(UActorComponent* OwnerComponent, UObject* SubObject, ELifetimeCondition NetCondition = COND_None);
 
    ENGINE_API void RemoveActorComponentReplicatedSubObject(UActorComponent* OwnerComponent, UObject* SubObject);
 
    ENGINE_API bool IsReplicatedSubObjectRegistered(const UObject* SubObject) const;
 
    ENGINE_API bool IsReplicatedActorComponentRegistered(const UActorComponent* ReplicatedComponent) const;
 
    ENGINE_API bool IsActorComponentReplicatedSubObjectRegistered(const UActorComponent* OwnerComponent, const UObject* SubObject) const;
 
 
    static ENGINE_API void GetActorClassDefaultComponents(const TSubclassOf<AActor>& InActorClass, const TSubclassOf<UActorComponent>& InComponentClass, TArray<const UActorComponent*>& OutComponents);
 
    static ENGINE_API const UActorComponent* GetActorClassDefaultComponent(const TSubclassOf<AActor>& InActorClass, const TSubclassOf<UActorComponent>& InComponentClass);
 
    static ENGINE_API const UActorComponent* GetActorClassDefaultComponentByName(const TSubclassOf<AActor>& InActorClass, const TSubclassOf<UActorComponent>& InComponentClass, FName InComponentName);
 
    static ENGINE_API void ForEachComponentOfActorClassDefault(const TSubclassOf<AActor>& InActorClass, const TSubclassOf<UActorComponent>& InComponentClass, TFunctionRef<bool(const UActorComponent*)> InFunc);
 
    template <typename TComponentClass = UActorComponent, typename = typename TEnableIf<TIsDerivedFrom<TComponentClass, UActorComponent>::IsDerived>::Type>
    static void GetActorClassDefaultComponents(const TSubclassOf<AActor>& InActorClass, TArray<const TComponentClass*>& OutComponents)
    {
        ForEachComponentOfActorClassDefault(InActorClass, TComponentClass::StaticClass(), [&](const UActorComponent* TemplateComponent)
        {
            OutComponents.Add(CastChecked<TComponentClass>(TemplateComponent));
            return true;
        });
    }
 
    template <typename TComponentClass = UActorComponent, typename = typename TEnableIf<TIsDerivedFrom<TComponentClass, UActorComponent>::IsDerived>::Type>
    static const TComponentClass* GetActorClassDefaultComponent(const TSubclassOf<AActor>& InActorClass)
    {
        return Cast<TComponentClass>(GetActorClassDefaultComponent(InActorClass, TComponentClass::StaticClass()));
    }
 
    template <typename TComponentClass = UActorComponent, typename = typename TEnableIf<TIsDerivedFrom<TComponentClass, UActorComponent>::IsDerived>::Type>
    static const TComponentClass* GetActorClassDefaultComponentByName(const TSubclassOf<AActor>& InActorClass, FName InComponentName)
    {
        return Cast<TComponentClass>(GetActorClassDefaultComponentByName(InActorClass, TComponentClass::StaticClass(), InComponentName));
    }
 
    template <typename TComponentClass = UActorComponent, typename = typename TEnableIf<TIsDerivedFrom<TComponentClass, UActorComponent>::IsDerived>::Type>
    static void ForEachComponentOfActorClassDefault(const TSubclassOf<AActor>& InActorClass, TFunctionRef<bool(const TComponentClass*)> InFunc)
    {
        ForEachComponentOfActorClassDefault(InActorClass, TComponentClass::StaticClass(), [&](const UActorComponent* TemplateComponent)
        {
            return InFunc(CastChecked<TComponentClass>(TemplateComponent));
        });
    }
 
private:
    UE::Net::FSubObjectRegistry ReplicatedSubObjects;
    friend class UE::Net::FSubObjectRegistryGetter;
 
    TArray<UE::Net::FReplicatedComponentInfo> ReplicatedComponentsInfo;
 
    ENGINE_API bool RemoveReplicatedSubObjectFromList(UObject* SubObject);
 
    ENGINE_API bool RemoveActorComponentReplicatedSubObjectFromList(UActorComponent* OwnerComponent, UObject* SubObject);
 
    ENGINE_API void AddComponentForReplication(UActorComponent* Component);
 
    ENGINE_API void RemoveReplicatedComponent(UActorComponent* Component);
 
    ENGINE_API void BuildReplicatedComponentsInfo();
 
protected:
    TArray<UActorComponent*> ReplicatedComponents;
 
private:
    TSet<TObjectPtr<UActorComponent>> OwnedComponents;
 
#if WITH_EDITOR
    TMultiMap<FName, FObjectProperty*> NativeConstructedComponentToPropertyMap;
#endif
 
    UPROPERTY(Instanced)
    TArray<TObjectPtr<UActorComponent>> InstanceComponents;
 
public:
    UPROPERTY(TextExportTransient, NonTransactional)
    TArray<TObjectPtr<UActorComponent>> BlueprintCreatedComponents;
 
    ENGINE_API void AddInstanceComponent(UActorComponent* Component);
 
    ENGINE_API void RemoveInstanceComponent(UActorComponent* Component);
 
    ENGINE_API void ClearInstanceComponents(bool bDestroyComponents);
 
    ENGINE_API const TArray<UActorComponent*>& GetInstanceComponents() const;
 
#if WITH_EDITOR
    FActorOnComponentsReplaced OnComponentsReplaced;
#endif
 
    //~=============================================================================
    // Navigation/AI related functions
    
    UFUNCTION(BlueprintCallable, BlueprintAuthorityOnly, Category="AI", meta=(BlueprintProtected = "true"))
    ENGINE_API void MakeNoise(float Loudness=1.f, APawn* NoiseInstigator=nullptr, FVector NoiseLocation=FVector::ZeroVector, float MaxRange = 0.f, FName Tag = NAME_None);
 
    static ENGINE_API void MakeNoiseImpl(AActor* NoiseMaker, float Loudness, APawn* NoiseInstigator, const FVector& NoiseLocation, float MaxRange, FName Tag);
 
    static ENGINE_API void SetMakeNoiseDelegate(const FMakeNoiseDelegate& NewDelegate);
 
    virtual bool IsComponentRelevantForNavigation(UActorComponent* Component) const { return true; }
 
private:
    static ENGINE_API FMakeNoiseDelegate MakeNoiseDelegate;
 
 
public:
    //~=============================================================================
    // Debugging functions
 
    ENGINE_API virtual void DisplayDebug(class UCanvas* Canvas, const class FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos);
 
    static FString GetDebugName(const AActor* Actor) { return Actor ? Actor->GetName() : TEXT("NULL"); }
 
#if !UE_BUILD_SHIPPING
    static ENGINE_API FOnProcessEvent ProcessEventDelegate;
#endif
 
#if !UE_STRIP_DEPRECATED_PROPERTIES
    UE_DEPRECATED(5.1, "AActor::DetachFence has been deprecated. If you are relying on it for render thread synchronization in a subclass of actor, add your own fence to that class instead.")
    FRenderCommandFence DetachFence;
#endif
 
private:
    ENGINE_API void InternalDispatchBlockingHit(UPrimitiveComponent* MyComp, UPrimitiveComponent* OtherComp, bool bSelfMoved, FHitResult const& Hit);
 
    ENGINE_API ENetMode InternalGetNetMode() const;
 
    ENGINE_API bool InternalPostEditUndo();
 
    friend struct FMarkActorIsBeingDestroyed;
    friend struct FActorParentComponentSetter;
    friend struct FSetActorWantsDestroyDuringBeginPlay;
    friend struct FActorPreRegistrationAccessor;
#if WITH_EDITOR
    ENGINE_API bool IsActorFolderValid() const;
    ENGINE_API void SetFolderPathInternal(const FName& InNewFolderPath, bool bInBroadcastChange = true);
    ENGINE_API void SetFolderGuidInternal(const FGuid& InFolderGuid, bool bInBroadcastChange = true);
    ENGINE_API UActorFolder* GetActorFolder(bool bSkipDeleted = true) const;
 
    friend struct FSetActorHiddenInSceneOutliner;
    friend struct FSetActorGuid;
    friend struct FSetActorReplicates;
    friend struct FSetActorInstanceGuid;
    friend struct FSetActorContentBundleGuid;
    friend struct FAssignActorDataLayer;
    friend struct FSetActorSelectable;
    friend struct FSetActorFolderPath;
#endif
 
    // Static helpers for accessing functions on SceneComponent.
    // These are templates for no other reason than to delay compilation until USceneComponent is defined.
 
    template<class T>
    static inline const FTransform& TemplateGetActorTransform(const T* RootComponent)
    {
        return (RootComponent != nullptr) ? RootComponent->GetComponentTransform() : FTransform::Identity;
    }
 
    template<class T>
    static inline FVector TemplateGetActorLocation(const T* RootComponent)
    {
        return (RootComponent != nullptr) ? RootComponent->GetComponentLocation() : FVector::ZeroVector;
    }
 
    template<class T>
    static inline FRotator TemplateGetActorRotation(const T* RootComponent)
    {
        return (RootComponent != nullptr) ? RootComponent->GetComponentRotation() : FRotator::ZeroRotator;
    }
 
    template<class T>
    static inline FVector TemplateGetActorScale(const T* RootComponent)
    {
        return (RootComponent != nullptr) ? RootComponent->GetComponentScale() : FVector(1.f,1.f,1.f);
    }
 
    template<class T>
    static inline FQuat TemplateGetActorQuat(const T* RootComponent)
    {
        return (RootComponent != nullptr) ? RootComponent->GetComponentQuat() : FQuat(ForceInit);
    }
 
    template<class T>
    static inline FVector TemplateGetActorForwardVector(const T* RootComponent)
    {
        return (RootComponent != nullptr) ? RootComponent->GetForwardVector() : FVector::ForwardVector;
    }
 
    template<class T>
    static inline FVector TemplateGetActorUpVector(const T* RootComponent)
    {
        return (RootComponent != nullptr) ? RootComponent->GetUpVector() : FVector::UpVector;
    }
 
    template<class T>
    static inline FVector TemplateGetActorRightVector(const T* RootComponent)
    {
        return (RootComponent != nullptr) ? RootComponent->GetRightVector() : FVector::RightVector;
    }
    
    //~ Begin Methods for Replicated Members.
public:
 
    static const FName GetHiddenPropertyName()
    {
        return GET_MEMBER_NAME_CHECKED(AActor, bHidden);
    }
 
    bool IsHidden() const
    {
        return bHidden;
    }
 
    ENGINE_API void SetHidden(const bool bInHidden);
 
    static const FName GetReplicateMovementPropertyName()
    {
        return GET_MEMBER_NAME_CHECKED(AActor, bReplicateMovement);
    }
 
    bool IsReplicatingMovement() const
    {
        return bReplicateMovement;
    }
 
    ENGINE_API void SetReplicatingMovement(bool bInReplicateMovement);
 
    static const FName GetCanBeDamagedPropertyName()
    {
        return GET_MEMBER_NAME_CHECKED(AActor, bCanBeDamaged);
    }
 
    bool CanBeDamaged() const
    {
        return bCanBeDamaged;
    }
 
    ENGINE_API void SetCanBeDamaged(bool bInCanBeDamaged);
 
    static const FName GetRolePropertyName()
    {
        return GET_MEMBER_NAME_CHECKED(AActor, Role);
    }
 
    ENGINE_API void SetRole(ENetRole InRole);
    
    const FRepMovement& GetReplicatedMovement() const
    {
        return ReplicatedMovement;
    }
 
    ENGINE_API FRepMovement& GetReplicatedMovement_Mutable();
 
    ENGINE_API void SetReplicatedMovement(const FRepMovement& InReplicatedMovement);
 
    UFUNCTION(BlueprintSetter)
    ENGINE_API void SetNetUpdateFrequency(float Frequency);
 
    UFUNCTION(BlueprintGetter)
    ENGINE_API float GetNetUpdateFrequency() const;
 
    UFUNCTION(BlueprintSetter)
    ENGINE_API void SetMinNetUpdateFrequency(float MinFrequency);
 
    UFUNCTION(BlueprintGetter)
    ENGINE_API float GetMinNetUpdateFrequency() const;
 
    UFUNCTION(BlueprintSetter)
    ENGINE_API void SetNetCullDistanceSquared(float DistanceSq);
 
    UFUNCTION(BlueprintGetter)
    ENGINE_API float GetNetCullDistanceSquared() const;
 
    static const FName GetInstigatorPropertyName()
    {
        return GET_MEMBER_NAME_CHECKED(AActor, Instigator);
    }
 
    ENGINE_API void SetInstigator(APawn* InInstigator);
 
    void SetActorIsPendingPostNetInit(bool bInIsPendingPostNetInit)
    {
        bActorIsPendingPostNetInit = bInIsPendingPostNetInit;
    }
    
    //~ End Methods for Replicated Members.
};
 
struct FMarkActorIsBeingDestroyed
{
private:
    FMarkActorIsBeingDestroyed(AActor* InActor)
    {
        InActor->bActorIsBeingDestroyed = true;
    }
 
    friend UWorld;
};
 
struct FSetActorWantsDestroyDuringBeginPlay
{
private:
    FSetActorWantsDestroyDuringBeginPlay(AActor* InActor)
    {
        ensure(InActor->IsActorBeginningPlay()); // Doesn't make sense to call this under any other circumstances
        InActor->bActorWantsDestroyDuringBeginPlay = true;
    }
 
    friend UWorld;
};
 
 
inline void FActorLastRenderTime::Set(AActor* InActor, float LastRenderTime)
{
    InActor->LastRenderTime.SetLastRenderTime(LastRenderTime);
}
 
inline FActorLastRenderTime* FActorLastRenderTime::GetPtr(AActor* InActor)
{
    return (InActor ? &InActor->LastRenderTime : nullptr);
}
 
struct FActorPreRegistrationAccessor
{
private:
    static void IncrementalPreRegisterComponents(AActor* InActor)
    {
        InActor->IncrementalPreRegisterComponents();
    }
 
    static bool HasPreRegisteredAllComponents(const AActor* InActor)
    {
        return InActor->HasPreRegisteredAllComponents();
    }
 
    static void IncrementalPreUnregisterComponents(AActor* InActor)
    {
        InActor->IncrementalPreUnregisterComponents();
    }
    friend class ULevel;
};
 
#if WITH_EDITOR
struct FSetActorHiddenInSceneOutliner
{
private:
    FSetActorHiddenInSceneOutliner(AActor* InActor, bool bHidden = true)
    {
        InActor->bListedInSceneOutliner = !bHidden;
    }
 
    friend UWorld;
    friend class FFoliageHelper;
    friend class ULevelInstanceSubsystem;
    friend class UExternalDataLayerInstance;
    friend class FModelingToolsSetActorHiddenInSceneOutliner;
};
 
struct FSetActorGuid
{
private:
    FSetActorGuid(AActor* InActor, const FGuid& InActorGuid)
    {
        InActor->ActorGuid = InActorGuid;
    }
    friend class UWorld;
    friend class UEngine;
    friend class UExternalActorsCommandlet;
    friend class UWorldPartitionConvertCommandlet;
};
 
struct FSetActorReplicates
{
private:
    FSetActorReplicates(AActor* InActor, bool bInReplicates)
    {
        if (InActor->bReplicates != bInReplicates)
        {
            check(!InActor->bActorInitialized);
            InActor->bReplicates = bInReplicates;
            InActor->RemoteRole = (bInReplicates ? ROLE_SimulatedProxy : ROLE_None);
        }
    }
    friend class FWorldPartitionLevelHelper;
};
 
struct FSetActorInstanceGuid
{
private:
    FSetActorInstanceGuid(AActor* InActor, const FGuid& InActorInstanceGuid)
    {
        InActor->ActorInstanceGuid = InActorInstanceGuid;
        if (InActorInstanceGuid == InActor->ActorGuid)
        {
            InActor->ActorInstanceGuid.Invalidate();
        }
    }
    friend class UEngine;
    friend class ULevelStreamingLevelInstance;
    friend class FWorldPartitionLevelHelper;
    friend class FReplaceActorHelperSetActorInstanceGuid;
};
 
struct FSetActorFolderPath
{
private:
    FSetActorFolderPath(AActor* InActor, const FName InFolderPath, bool bInBroadcastChange = true)
    {
        InActor->SetFolderPathInternal(InFolderPath, bInBroadcastChange);
    }
    friend class UWorldPartitionRuntimeCell;
};
 
struct FSetActorContentBundleGuid
{
private:
    FSetActorContentBundleGuid(AActor* InActor, const FGuid& InContentBundleGuid)
    {
        InActor->ContentBundleGuid = InContentBundleGuid;
    }
    friend class FContentBundleEditor;
    friend class FExternalDataLayerHelper;
    friend class UGameFeatureActionConvertContentBundleWorldPartitionBuilder;
};
 
struct FAssignActorDataLayer
{
private:
    ENGINE_API static bool AddDataLayerAsset(AActor* InActor, const UDataLayerAsset* InDataLayerAsset);
    ENGINE_API static bool RemoveDataLayerAsset(AActor* InActor, const UDataLayerAsset* InDataLayerAsset);
 
    friend class UEngine;
    friend class FContentBundleEditor;
    friend class UDataLayerInstanceWithAsset;
    friend class UDataLayerInstancePrivate;
    friend class UExternalDataLayerInstance;
    friend class ULevelInstanceSubsystem;
    friend class FExternalDataLayerHelper;
    friend class UActorPartitionSubsystem;
};
 
struct FSetActorIsInLevelInstance
{
private:
    FSetActorIsInLevelInstance(AActor* InActor, ELevelInstanceType InLevelInstanceType)
    {
        InActor->LevelInstanceType = InLevelInstanceType;
    }
 
    friend class ULevelStreamingLevelInstance;
    friend class ULevelStreamingLevelInstanceEditor;
    friend class ULevelStreamingLevelInstanceEditorPropertyOverride;
};
 
struct FAddActorLevelInstanceFlags
{
private:
    FAddActorLevelInstanceFlags(AActor* InActor, ELevelInstanceFlags InFlagsToAdd)
    {
        EnumAddFlags(InActor->LevelInstanceFlags, InFlagsToAdd);
    }
 
    friend class ULevelStreamingLevelInstance;
    friend class ULevelStreamingLevelInstanceEditor;
    friend class ULevelStreamingLevelInstanceEditorPropertyOverride;
};
 
struct FRemoveActorLevelInstanceFlags
{
private:
    FRemoveActorLevelInstanceFlags(AActor* InActor, ELevelInstanceFlags InFlagsToRemove)
    {
        EnumRemoveFlags(InActor->LevelInstanceFlags, InFlagsToRemove);
    }
 
    friend class ULevelStreamingLevelInstance;
    friend class ULevelStreamingLevelInstanceEditor;
    friend class ULevelStreamingLevelInstanceEditorPropertyOverride;
};
#endif
 
template <typename ExecuteTickLambda>
void FActorComponentTickFunction::ExecuteTickHelper(UActorComponent* Target, bool bTickInEditor, float DeltaTime, ELevelTick TickType, const ExecuteTickLambda& ExecuteTickFunc)
{
    if (IsValid(Target))
    {
        FScopeCycleCounterUObject ComponentScope(Target);
        FScopeCycleCounterUObject AdditionalScope(Target->AdditionalStatObject());
 
        if (Target->bRegistered)
        {
            AActor* MyOwner = Target->GetOwner();
            if (TickType != LEVELTICK_ViewportsOnly || bTickInEditor ||
                (MyOwner && MyOwner->ShouldTickIfViewportsOnly()))
            {
                const float TimeDilation = (MyOwner ? MyOwner->CustomTimeDilation : 1.f);
                ExecuteTickFunc(DeltaTime * TimeDilation);
            }
        }
    }
}
 
template<class T, uint32 NumElements>
TInlineComponentArray<T, NumElements>::TInlineComponentArray(const AActor* Actor, bool bIncludeFromChildActors) 
    : Super()
{
    if (Actor)
    {
        Actor->GetComponents(*this, bIncludeFromChildActors);
    }
};
 
// Inlines
 
inline FVector AActor::K2_GetActorLocation() const
{
    return GetActorLocation();
}
 
inline FRotator AActor::K2_GetActorRotation() const
{
    return GetActorRotation();
}
 
inline USceneComponent* AActor::K2_GetRootComponent() const
{
    return GetRootComponent();
}
 
inline FVector AActor::GetActorForwardVector() const
{
    return TemplateGetActorForwardVector(ToRawPtr(RootComponent));
}
 
inline FVector AActor::GetActorUpVector() const
{
    return TemplateGetActorUpVector(ToRawPtr(RootComponent));
}
 
inline FVector AActor::GetActorRightVector() const
{
    return TemplateGetActorRightVector(ToRawPtr(RootComponent));
}
 
 
inline float AActor::GetSimpleCollisionRadius() const
{
    float Radius, HalfHeight;
    GetSimpleCollisionCylinder(Radius, HalfHeight);
    return Radius;
}
 
inline float AActor::GetSimpleCollisionHalfHeight() const
{
    float Radius, HalfHeight;
    GetSimpleCollisionCylinder(Radius, HalfHeight);
    return HalfHeight;
}
 
inline FVector AActor::GetSimpleCollisionCylinderExtent() const
{
    float Radius, HalfHeight;
    GetSimpleCollisionCylinder(Radius, HalfHeight);
    return FVector(Radius, Radius, HalfHeight);
}
 
inline bool AActor::GetActorEnableCollision() const
{
    return bActorEnableCollision;
}
 
inline bool AActor::HasAuthority() const
{
    return (GetLocalRole() == ROLE_Authority);
}
 
inline AActor* AActor::GetOwner() const
{ 
    return Owner; 
}
 
inline const AActor* AActor::GetNetOwner() const
{
    // NetOwner is the Actor Owner unless otherwise overridden (see PlayerController/Pawn/Beacon)
    // Used in ServerReplicateActors
    return Owner;
}
 
inline ENetRole AActor::GetRemoteRole() const
{
    return RemoteRole;
}
 
inline ENetMode AActor::GetNetMode() const
{
    // IsRunningDedicatedServer() is a compile-time check in optimized non-editor builds.
    if (IsRunningDedicatedServer() && (NetDriverName == NAME_None || NetDriverName == NAME_GameNetDriver))
    {
        // Only normal net driver actors can have this optimization
        return NM_DedicatedServer;
    }
 
    return InternalGetNetMode();
}
 
inline bool AActor::IsNetMode(ENetMode Mode) const
{
#if UE_EDITOR
    // Editor builds are special because of PIE, which can run a dedicated server without the app running with -server.
    return GetNetMode() == Mode;
#else
    // IsRunningDedicatedServer() is a compile-time check in optimized non-editor builds.
    if (Mode == NM_DedicatedServer)
    {
        return IsRunningDedicatedServer();
    }
    else if (NetDriverName == NAME_None || NetDriverName == NAME_GameNetDriver)
    {
        // Only normal net driver actors can have this optimization
        return !IsRunningDedicatedServer() && (InternalGetNetMode() == Mode);
    }
    else
    {
        return (InternalGetNetMode() == Mode);
    }
#endif
}
 
#if WITH_EDITOR
extern ENGINE_API TFunction<bool(const AActor*)> GIsActorSelectedInEditor;
#endif
 
DEFINE_ACTORDESC_TYPE(AActor, FWorldPartitionActorDesc);
 
// Macro to hide common Transform functions in native code for classes where they don't make sense.
// Note that this doesn't prevent access through function calls from parent classes (ie an AActor*), but
// does prevent use in the class that hides them and any derived child classes.
 
#define HIDE_ACTOR_TRANSFORM_FUNCTIONS() private: \
    FTransform GetTransform() const { return Super::GetTransform(); } \
    FTransform GetActorTransform() const { return Super::GetActorTransform(); } \
    FVector GetActorLocation() const { return Super::GetActorLocation(); } \
    FRotator GetActorRotation() const { return Super::GetActorRotation(); } \
    FQuat GetActorQuat() const { return Super::GetActorQuat(); } \
    FVector GetActorScale() const { return Super::GetActorScale(); } \
    bool SetActorTransform(const FTransform& NewTransform, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None) { return Super::SetActorTransform(NewTransform, bSweep, OutSweepHitResult, Teleport); } \
    bool SetActorLocation(const FVector& NewLocation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None) { return Super::SetActorLocation(NewLocation, bSweep, OutSweepHitResult, Teleport); } \
    bool SetActorRotation(FRotator NewRotation, ETeleportType Teleport = ETeleportType::None) { return Super::SetActorRotation(NewRotation, Teleport); } \
    bool SetActorRotation(const FQuat& NewRotation, ETeleportType Teleport = ETeleportType::None) { return Super::SetActorRotation(NewRotation, Teleport); } \
    bool SetActorLocationAndRotation(FVector NewLocation, FRotator NewRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None) { return Super::SetActorLocationAndRotation(NewLocation, NewRotation, bSweep, OutSweepHitResult, Teleport); } \
    bool SetActorLocationAndRotation(FVector NewLocation, const FQuat& NewRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None) { return Super::SetActorLocationAndRotation(NewLocation, NewRotation, bSweep, OutSweepHitResult, Teleport); } \
    virtual bool TeleportTo( const FVector& DestLocation, const FRotator& DestRotation, bool bIsATest, bool bNoCheck ) override { return Super::TeleportTo(DestLocation, DestRotation, bIsATest, bNoCheck); } \
    virtual FVector GetVelocity() const override { return Super::GetVelocity(); } \
    float GetHorizontalDistanceTo(AActor* OtherActor)  { return Super::GetHorizontalDistanceTo(OtherActor); } \
    float GetVerticalDistanceTo(AActor* OtherActor)  { return Super::GetVerticalDistanceTo(OtherActor); } \
    float GetDotProductTo(AActor* OtherActor) { return Super::GetDotProductTo(OtherActor); } \
    float GetHorizontalDotProductTo(AActor* OtherActor) { return Super::GetHorizontalDotProductTo(OtherActor); } \
    float GetDistanceTo(AActor* OtherActor) { return Super::GetDistanceTo(OtherActor); } \
    float GetSquaredDistanceTo(const AActor* OtherActor) { return Super::GetSquaredDistanceTo(OtherActor); } \
    FVector GetActorForwardVector() const { return Super::GetActorForwardVector(); } \
    FVector GetActorUpVector() const { return Super::GetActorUpVector(); } \
    FVector GetActorRightVector() const { return Super::GetActorRightVector(); } \
    void GetActorBounds(bool bOnlyCollidingComponents, FVector& Origin, FVector& BoxExtent, bool bIncludeFromChildActors = false) const { return Super::GetActorBounds(bOnlyCollidingComponents, Origin, BoxExtent, bIncludeFromChildActors); } \
    void SetActorScale3D(FVector NewScale3D) { Super::SetActorScale3D(NewScale3D); } \
    FVector GetActorScale3D() const { return Super::GetActorScale3D(); } \
    void SetActorRelativeScale3D(FVector NewRelativeScale) { Super::SetActorRelativeScale3D(NewRelativeScale); } \
    FVector GetActorRelativeScale3D() const { return Super::GetActorRelativeScale3D(); } \
    FTransform ActorToWorld() const { return Super::ActorToWorld(); } \
    void AddActorWorldOffset(FVector DeltaLocation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None) { Super::AddActorWorldOffset(DeltaLocation, bSweep, OutSweepHitResult, Teleport); } \
    void AddActorWorldRotation(FRotator DeltaRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None) { Super::AddActorWorldRotation(DeltaRotation, bSweep, OutSweepHitResult, Teleport); } \
    void AddActorWorldRotation(const FQuat& DeltaRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None) { Super::AddActorWorldRotation(DeltaRotation, bSweep, OutSweepHitResult, Teleport); } \
    void AddActorWorldTransform(const FTransform& DeltaTransform, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None) { Super::AddActorWorldTransform(DeltaTransform, bSweep, OutSweepHitResult, Teleport); } \
    void AddActorLocalOffset(FVector DeltaLocation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None) { Super::AddActorLocalOffset(DeltaLocation, bSweep, OutSweepHitResult, Teleport); } \
    void AddActorLocalRotation(FRotator DeltaRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None) { Super::AddActorLocalRotation(DeltaRotation, bSweep, OutSweepHitResult, Teleport); } \
    void AddActorLocalRotation(const FQuat& DeltaRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None) { Super::AddActorLocalRotation(DeltaRotation, bSweep, OutSweepHitResult, Teleport); } \
    void AddActorLocalTransform(const FTransform& NewTransform, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None) { Super::AddActorLocalTransform(NewTransform, bSweep, OutSweepHitResult, Teleport); } \
    void SetActorRelativeLocation(FVector NewRelativeLocation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None) { Super::SetActorRelativeLocation(NewRelativeLocation, bSweep, OutSweepHitResult, Teleport); } \
    void SetActorRelativeRotation(FRotator NewRelativeRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None) { Super::SetActorRelativeRotation(NewRelativeRotation, bSweep, OutSweepHitResult, Teleport); } \
    void SetActorRelativeRotation(const FQuat& NewRelativeRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None) { Super::SetActorRelativeRotation(NewRelativeRotation, bSweep, OutSweepHitResult, Teleport); } \
    void SetActorRelativeTransform(const FTransform& NewRelativeTransform, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None) { Super::SetActorRelativeTransform(NewRelativeTransform, bSweep, OutSweepHitResult, Teleport); }