AActor

class Engine Blueprint Since 1.0

Inherits: UObjectBase › UObjectBaseUtility › UObject › AActor

#include "GameFramework/Actor.h"

Access: public Specifiers: UCLASS

Description

The base class for all actors that can be placed or spawned in the world. AActor provides transform, component attachment, lifecycle events (BeginPlay, Tick, EndPlay), replication, and overlap/hit events. Every object you see or interact with in a level descends from AActor.

Caveats & Gotchas

• Actors must be spawned with `UWorld::SpawnActor<T>()`, not `NewObject<T>()`.
• Component initialization order: constructor → InitializeComponent → BeginPlay. Do not rely on component state in the constructor.
• NetMode checks (`HasAuthority()`, `IsLocallyControlled()`) are critical for multiplayer correctness.
• Calling `Destroy()` does not immediately remove the actor — it defers removal to end-of-frame.

Signature

class AActor : public UObject

Examples

Minimal AActor subclass C++

UCLASS()
class MYGAME_API AMyActor : public AActor
{
    GENERATED_BODY()

public:
    AMyActor();

protected:
    virtual void BeginPlay() override;
    virtual void Tick(float DeltaTime) override;

private:
    UPROPERTY(VisibleAnywhere)
    UStaticMeshComponent* Mesh;
};

AMyActor::AMyActor()
{
    PrimaryActorTick.bCanEverTick = true;
    Mesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Mesh"));
    RootComponent = Mesh;
}

Spawning an actor C++

FActorSpawnParameters Params;
Params.Owner = this;
AMyActor* Spawned = GetWorld()->SpawnActor<AMyActor>(
    AMyActor::StaticClass(),
    FVector(0, 0, 100),
    FRotator::ZeroRotator,
    Params
);

Functions (444)

Lifecycle 51 Transform 58 Components 57 Collision 29 Damage 6 Input 22 Networking 111 Rendering 18 Audio 1 Navigation 1 Tags 1 Utility 72 Actor 1 AI 1 Tick 11 Transformation 4

Lifecycle

51 ▼

Access	Type	Name	Description
protected	function	AActor::BeginPlay	Called when the actor is fully initialized and play begins in the world.
public	function	AActor::CanEverTick	Returns true if this actor's primary tick function is allowed to tick.
public	function	AActor::Destroy	Marks this actor for destruction at the end of the current tick.
protected	function	AActor::EndPlay	Called when this actor's lifespan ends.
public	function	AActor::GetGameTimeSinceCreation	Returns the number of game-time seconds elapsed since this actor was created, equivalent to UGameplayStatics::GetGameTimeSinceCreation minus the actor's creation time.
public	function	AActor::GetLifeSpan	Returns the remaining lifespan of this actor in seconds.
public	function	AActor::K2_DestroyActor	Destroys this actor at the end of the current frame, releasing it from the world.
public	function	AActor::ReceiveTick	The Blueprint implementable version of Tick, called every frame when ticking is enabled.
public	function	AActor::SetLifeSpan	Schedules this actor to be automatically destroyed after the given number of seconds.
public	function	AActor::TakeDamage	Entry point for applying damage to this actor.
public	function	AActor::Tick	Called every frame if `PrimaryActorTick.
public	function	AActor::AllowReceiveTickEventOnDedicatedServer	Returns whether the Blueprint ReceiveTick event is allowed to fire on dedicated servers.
public	function	AActor::Destroyed	Called when this actor is explicitly destroyed during gameplay or in the editor.
public	function	AActor::FellOutOfWorld	Called when the actor falls below the world's KillZ threshold or exits the hard world bounds.
public	function	AActor::FinishSpawning	Completes the deferred spawning process by running construction scripts and finalizing the actor's state.
public	function	AActor::GetAutoDestroyWhenFinished	Returns whether this actor will automatically destroy itself when all its relevant components report that they are finished and no timelines or timers are in flight.
public	function	AActor::HasActorBegunPlay	Returns true once BeginPlay has fully completed on this actor and EndPlay has not yet been called.
public	function	AActor::InitializeComponents	Iterates over all components and calls InitializeComponent on each one.
public	function	AActor::IsActorBeginningPlay	Returns true while this actor is in the middle of its BeginPlay dispatch — after DispatchBeginPlay() has started but before it completes.
public	function	AActor::IsActorBeingDestroyed	Returns true if this actor is currently in the process of being destroyed.
public	function	AActor::IsActorInitialized	Returns true after the actor has completed its initialization phase (PostInitializeComponents and PreInitializeComponents have completed).
public	function	AActor::IsPendingKillPending	Returns true if this actor has begun the destruction process or has already been destroyed.
public	function	AActor::K2_OnReset	Blueprint-implementable event fired when this actor is reset to its initial state, such as when restarting a level without reloading.
public	function	AActor::LifeSpanExpired	Called when the actor's lifespan timer fires (set via SetLifeSpan).
public	function	AActor::OnConstruction	Called when an instance of this class is placed in the editor or spawned at runtime, after native components are created but before BeginPlay.
public	function	AActor::PostActorCreated	Called after an actor is spawned into the world (via UWorld::SpawnActor), both in the editor and during gameplay.
public	function	AActor::PostInitializeComponents	Called after all components have been initialized during gameplay or editor previews.
public	function	AActor::ReceiveDestroyed	Blueprint event called when this actor has been explicitly destroyed via Destroy().
public	function	AActor::Reset	Resets the actor to its initial state.
public	function	AActor::SetAutoDestroyWhenFinished	Sets whether this actor should automatically destroy itself when all its components are done and no timers or timelines remain active.
public	function	AActor::UninitializeComponents	Iterates over all components and calls UninitializeComponent on each one.
public	function	AActor::UserConstructionScript	The Blueprint Construction Script entry point, called each time the actor is placed or modified in the editor and when it is spawned at runtime.
public	function	AActor::AsyncPhysicsTickActor	C++ virtual called each physics sub-step when async physics ticking is enabled.
public	function	AActor::DispatchBeginPlay	Engine-internal function that orchestrates the full BeginPlay call chain in the correct order — initializing components, calling PreInitializeComponents, PostInitializeComponents, then BeginPlay on the actor and all its components.
public	function	AActor::ExecuteConstruction	Runs the actor's construction scripts, including OnConstruction and the Blueprint Construction Script.
public	function	AActor::IsActorBeginningPlayFromLevelStreaming	Returns true when BeginPlay is being dispatched as a result of level streaming (including initial level load).
public	function	AActor::IsRunningUserConstructionScript	Returns true while the Blueprint User Construction Script (UCS) is executing on this actor.
public	function	AActor::MarkComponentsAsGarbage	Marks all components as garbage so the GC can collect them when the actor is destroyed.
public	function	AActor::OutsideWorldBounds	Called by the engine when this actor is detected outside the hard limit on world bounds.
public	function	AActor::PostActorConstruction	Called after the actor has run its construction script.
public	function	AActor::PostRegisterAllComponents	Called after all components have been registered with the world.
public	function	AActor::PostSpawnInitialize	Called immediately after the actor is spawned in the world.
public	function	AActor::PreInitializeComponents	Called immediately before InitializeComponent() is invoked on each of the actor's components, and only during gameplay (not in the editor).
public	function	AActor::PreRegisterAllComponents	Called before any component in the actor is registered with the world.
public	function	AActor::ReceiveAsyncPhysicsTick	Blueprint implementable event called every physics sub-step when async physics ticking is enabled on this actor.
public	function	AActor::RegisterAllActorTickFunctions	Registers or unregisters all tick functions for this actor and optionally its components with the world's tick task manager.
public	function	AActor::RegisterAllComponents	Registers all components that belong to this actor with the world.
public	function	AActor::ResetPropertiesForConstruction	Resets private actor properties to their defaults and re-seeds all FRandomStream members, so they will replay their random sequence from the beginning on the next construction.
public	function	AActor::RouteEndPlay	Non-virtual engine function that evaluates which portions of the EndPlay process to dispatch for this actor, then calls EndPlay on the actor and all its components in the correct order.
public	function	AActor::ShouldTickIfViewportsOnly	Returns whether this actor should tick in editor viewports (TickType == LEVELTICK_ViewportsOnly).
public	function	AActor::TickActor	The internal dispatcher called by the PrimaryActorTick function each frame.

Transform

58 ▼

Access	Type	Name	Description
public	function	AActor::GetActorLocation	Returns the current world-space location of the actor's root component.
public	function	AActor::GetActorRelativeScale3D	Returns the actor's RootComponent scale relative to its parent actor.
public	function	AActor::GetActorScale	Returns the world-space scale of the actor's RootComponent as an FVector.
public	function	AActor::GetActorScale3D	Returns the actor's world-space scale as an FVector with X, Y, and Z scale factors.
public	function	AActor::GetActorTransform	Returns the full world-space transform (location, rotation, scale) of the actor's root component as an FTransform.
public	function	AActor::GetAttachParentActor	Walks up the scene attachment chain from RootComponent and returns the first actor it belongs to that is different from this actor.
public	function	AActor::GetHorizontalDistanceTo	Returns the 2D (horizontal) distance between this actor and OtherActor, ignoring Z height.
public	function	AActor::GetSquaredDistanceTo	Returns the squared 3D distance between this actor and OtherActor.
public	function	AActor::GetTransform	Returns the actor-to-world transform of the RootComponent.
public	function	AActor::GetVelocity	Returns the velocity of the actor in cm/s.
public	function	AActor::K2_AddActorLocalOffset	Adds a delta to the actor's location in its own local space.
public	function	AActor::K2_AddActorLocalRotation	Adds a delta rotation in the actor's local reference frame.
public	function	AActor::K2_AddActorWorldOffset	Adds a delta to the actor's world-space location.
public	function	AActor::K2_AddActorWorldRotation	Adds a delta rotation to the actor's current world-space rotation.
public	function	AActor::K2_GetActorLocation	Returns the world-space location of the actor's RootComponent.
public	function	AActor::K2_GetActorRotation	Returns the world-space rotation of the actor's RootComponent as an FRotator.
public	function	AActor::K2_SetActorLocation	Moves the actor to the specified world-space location.
public	function	AActor::K2_SetActorLocationAndRotation	Moves and rotates the actor to the specified world-space location and rotation in a single call.
public	function	AActor::K2_SetActorRelativeLocation	Sets the actor's RootComponent to the given location relative to its parent actor.
public	function	AActor::K2_SetActorRelativeRotation	Sets the actor's RootComponent to the given rotation relative to its parent actor.
public	function	AActor::K2_SetActorRotation	Sets the actor's world-space rotation instantly.
public	function	AActor::K2_SetActorTransform	Sets the actor's world-space transform (location, rotation, and scale) in one call.
public	function	AActor::K2_TeleportTo	Moves this actor to the specified location and rotation, attempting to avoid overlapping geometry by nudging slightly out of walls.
public	function	AActor::SetActorLocation	Sets the world-space location of the actor.
public	function	AActor::SetActorLocationAndRotation	Sets the actor's world location and rotation in a single call, which is more efficient than calling SetActorLocation and SetActorRotation separately because it only triggers one transform update.
public	function	AActor::SetActorRelativeLocation	Sets the location of this actor's root component relative to its parent component in the attachment hierarchy.
public	function	AActor::SetActorRelativeRotation	Sets the rotation of this actor's root component relative to its parent in the attachment hierarchy.
public	function	AActor::SetActorRelativeScale3D	Sets the actor's RootComponent scale relative to its parent.
public	function	AActor::SetActorRelativeTransform	Sets the full transform (location, rotation, and scale) of this actor's root component relative to its parent in the attachment hierarchy.
public	function	AActor::SetActorScale3D	Sets the world-space scale of the actor's root component.
public	function	AActor::ActorToWorld	Returns the local-to-world transform of the actor's RootComponent.
public	function	AActor::AddActorLocalOffset	Moves the actor by a delta offset expressed in the actor's local space.
public	function	AActor::AddActorLocalRotation	Adds a delta rotation to this actor in its own local reference frame.
public	function	AActor::AddActorWorldTransform	Applies a delta transform to this actor in world space, combining the delta rotation and location with the current transform.
public	function	AActor::AddActorWorldTransformKeepScale	Applies a delta transform to this actor in world space while preserving the actor's existing scale.
public	function	AActor::AttachToActor	Attaches this actor's RootComponent to the RootComponent of another actor.
public	function	AActor::AttachToComponent	Attaches this actor's RootComponent to a specific SceneComponent, with full control over how the existing transform is preserved or reset.
public	function	AActor::DetachFromActor	Detaches this actor's RootComponent from its current parent, releasing the attachment.
public	function	AActor::DetachRootComponentFromParent deprecated	Deprecated function that detaches this actor's root component from its parent.
public	function	AActor::GetActorQuat	Returns the rotation of the actor's RootComponent as a quaternion.
public	function	AActor::GetAttachParentSocketName	Walks up the attachment chain from RootComponent and returns the socket name on the parent actor's component to which this actor is attached.
public	function	AActor::GetDotProductTo	Returns the dot product between this actor's forward vector and the normalized direction to OtherActor.
public	function	AActor::GetHorizontalDotProductTo	Returns the dot product between this actor's forward vector and the horizontal (XY-plane) direction to OtherActor.
public	function	AActor::GetSquaredHorizontalDistanceTo	Returns the squared 2D (horizontal) distance between this actor and OtherActor, ignoring Z.
public	function	AActor::GetVerticalDistanceTo	Returns the absolute vertical (Z-axis only) distance between this actor and OtherActor, ignoring XY.
public	function	AActor::K2_AddActorLocalTransform	Adds a delta transform to the actor in its local reference frame, affecting location, rotation, and scale together.
public	function	AActor::K2_AddActorWorldTransform	Adds a delta transform to the actor in world space.
public	function	AActor::K2_AddActorWorldTransformKeepScale	Adds a delta transform to the actor in world space while preserving the actor's current scale.
public	function	AActor::K2_AttachRootComponentTo deprecated	Deprecated Blueprint-facing wrapper that attaches this actor's root component to a given scene component.
public	function	AActor::K2_AttachRootComponentToActor deprecated	Deprecated Blueprint-facing wrapper that attaches this actor's root component to another actor's root component.
public	function	AActor::K2_AttachToActor	Attaches this actor's root component to the root component of another actor.
public	function	AActor::K2_AttachToComponent	Attaches this actor's root component to a given scene component, with fine-grained control over how transform rules are applied.
public	function	AActor::K2_DetachFromActor	Detaches this actor's root component from whatever scene component it is currently attached to.
public	function	AActor::K2_SetActorRelativeTransform	Sets the actor's full transform (location, rotation, and scale) relative to its parent in one call.
public	function	AActor::TeleportSucceeded	Called from TeleportTo() after a teleport completes successfully.
public	function	AActor::TeleportTo	Moves this actor to a destination location and rotation, attempting to push it clear of overlapping geometry if it does not fit exactly at the target point.
public	function	AActor::ApplyWorldOffset	Shifts the actor's location and all relevant internal data structures by the given offset vector.
public	function	AActor::GetLevelTransform	Returns the transform of the ULevel this actor belongs to.

Components

57 ▼

Access	Type	Name	Description
public	function	AActor::FindComponentByClass	Searches the actor's owned components and returns the first one that is an instance of the given class.
public	function	AActor::GetComponents	Fills OutComponents with all owned components of type T (or all components when called with a UActorComponent* array).
public	function	AActor::GetRootComponent	Returns the actor's root scene component, or null if none has been set.
public	function	AActor::IsRootComponentMovable	Returns true if the actor's root component has a mobility of EComponentMobility::Movable — the actor can be moved at runtime.
public	function	AActor::K2_GetComponentsByClass	Returns all components on this actor that are of or derive from ComponentClass.
public	function	AActor::K2_GetRootComponent	Returns the actor's root scene component.
public	function	AActor::AddComponent	Blueprint-internal function that instantiates a component from a named template and optionally attaches it.
public	function	AActor::AddComponentByClass	Blueprint-internal function that creates a component from a class reference rather than a named template, powering the 'Add Component by Class' Blueprint node.
public	function	AActor::AddInstanceComponent	Adds a component to the actor's InstanceComponents array, which tracks components added at runtime rather than defined in the class defaults.
public	function	AActor::ClearInstanceComponents	Clears the InstanceComponents array, optionally destroying every component in it.
public	function	AActor::DetachAllSceneComponents	Detaches all SceneComponents in this Actor that are attached to the supplied parent SceneComponent.
public	function	AActor::FindComponentByInterface	Searches the actor's owned components and returns the first one that implements the specified UInterface.
public	function	AActor::FindComponentByTag	Searches the actor's component list and returns the first component that is of type ComponentClass and has the specified tag.
public	function	AActor::ForEachAttachedActors	Calls a functor for each actor directly attached to any component of this actor.
public	function	AActor::ForEachComponent	Iterates every owned component of the given type (or all UActorComponent instances when no type parameter is specified) and invokes the provided callable on each.
public	function	AActor::GetAllChildActors	Fills an array with all actors spawned by `UChildActorComponent` instances on this actor.
public	function	AActor::GetAttachedActors	Populates OutActors with all actors that are directly attached to any component on this actor via scene attachment.
public	function	AActor::GetComponentsByClass	Returns all components of the given class attached to this actor.
public	function	AActor::GetComponentsByInterface	Returns all components on this actor that implement the specified UInterface.
public	function	AActor::GetComponentsByTag	Returns all components on this actor that are of type ComponentClass and have the specified tag.
public	function	AActor::GetDefaultAttachComponent	Returns the component that child actors and components should attach to by default.
public	function	AActor::GetInstanceComponents	Returns a read-only reference to the array of components that have been added to this actor instance at runtime via AddInstanceComponent.
public	function	AActor::GetParentActor	Returns the actor that owns the UChildActorComponent which created this actor, or nullptr if this actor was not spawned as a child actor.
public	function	AActor::GetParentComponent	Returns the UChildActorComponent that created this actor, or nullptr if this actor was not spawned by a child actor component.
public	function	AActor::HasActiveCameraComponent	Returns true if this actor owns at least one active UCameraComponent.
public	function	AActor::HasActivePawnControlCameraComponent	Returns true if this actor owns an active camera component that is set to use pawn control rotation (bUsePawnControlRotation=true), indicating an HMD-locked or controller-yawed camera setup.
public	function	AActor::HasValidRootComponent	Returns true if this actor has a root component that is fully registered with the world.
public	function	AActor::IsAttachedTo	Walks up the component attachment chain to determine whether this actor is attached (directly or transitively) to the given actor.
public	function	AActor::IsChildActor	Returns true if this actor was spawned and is owned by a `UChildActorComponent`.
public	function	AActor::IsRootComponentStatic	Returns true if the actor's root component has a mobility of EComponentMobility::Static.
public	function	AActor::IsRootComponentStationary	Returns true if the actor's root component has a mobility of EComponentMobility::Stationary — cannot move, but can change lighting state at runtime.
public	function	AActor::RemoveInstanceComponent	Removes a component from the actor's InstanceComponents array.
public	function	AActor::SetRootComponent	Promotes the given component to be this actor's root component.
public	function	AActor::AddOwnedComponent	Inserts a component into the actor's OwnedComponents set, making it visible to GetComponents and other component-iteration APIs.
public	function	AActor::CheckComponentInstanceName	Checks for and resolves any name collisions before a new Blueprint-created component is instanced, renaming any existing component that conflicts with the given name.
public	function	AActor::CreateComponentFromTemplate	Instantiates a new component by duplicating a template object, used during Blueprint construction script execution to stamp out component instances.
public	function	AActor::CreateComponentFromTemplateData	Creates a component instance from pre-cooked serialized data, allowing Blueprint component construction to bypass the more expensive template duplication path used in the editor.
public	function	AActor::DestroyConstructedComponents	Destroys all components that were created by the construction script (Blueprint or C++ OnConstruction), preparing the actor for a full re-run of its construction scripts.
public	function	AActor::FinishAddComponent	Completes the registration of a component that was created with bDeferredFinish=true.
public	function	AActor::FinishAndRegisterComponent	Completes component setup by adding it to the actor's serialized components array and registering it with the world.
public	function	AActor::ForEachComponentOfActorClassDefault	Iterates every CDO component of the given type on an actor class (including Blueprint-added ones) and calls InFunc for each.
public	function	AActor::GetActorClassDefaultComponent	Returns the first CDO component of a given type from the actor class, including Blueprint-added components.
public	function	AActor::GetActorClassDefaultComponentByName	Returns the CDO component with the given object name and type from the actor class, including Blueprint-added components.
public	function	AActor::GetActorClassDefaultComponents	Returns all components of a given type on an actor class's CDO, including Blueprint-added components that are invisible to `GetComponents()` when called on CDO instances directly.
public	function	AActor::HandleRegisterComponentWithWorld	Finalizes component initialization after it has registered with the world, wiring up tick functions and dispatching BeginPlay if the actor has already begun play.
public	function	AActor::HasActorRegisteredAllComponents	Returns whether this actor has fully registered all of its components — i.
public	function	AActor::HasDeferredComponentRegistration	Returns true if RegisterAllComponents() was deferred at spawn time because the Blueprint SCS had not yet executed to establish the root component.
public	function	AActor::IncrementalRegisterComponents	Registers a limited number of this actor's components per call, spreading the work across multiple frames.
public	function	AActor::OwnsComponent	Returns true if the component is present in this actor's OwnedComponents set.
public	function	AActor::PostUnregisterAllComponents	Called after all currently registered components have been unregistered.
public	function	AActor::RemoveOwnedComponent	Removes a component from the actor's OwnedComponents set.
public	function	AActor::ReregisterAllComponents	Unregisters then re-registers all components on this actor.
public	function	AActor::ResetOwnedComponents	Clears and rebuilds the OwnedComponents set by walking the actor's full component hierarchy.
public	function	AActor::SetHasActorRegisteredAllComponents	Sets the internal bHasRegisteredAllComponents flag to true.
public	function	AActor::FindComponentByInterface (IInterface template overload)	The `TIsIInterface`-constrained template overload of `FindComponentByInterface`, introduced in UE 5.
public	function	AActor::UnregisterAllComponents	Unregisters all currently registered components from the world.
public	function	AActor::UpdateComponentTransforms	Propagates the actor's current world transform to all attached scene components, updating their cached transforms without re-registering them.

Collision

29 ▼

Access	Type	Name	Description
public	function	AActor::GetActorBounds	Computes an axis-aligned bounding box (AABB) for this actor and outputs it as a center origin and half-extents.
public	function	AActor::GetActorEnableCollision	Returns whether collision is currently enabled for the whole actor.
public	function	AActor::IsOverlappingActor	Returns true if any component of this actor overlaps any component of the given actor.
public	function	AActor::NotifyActorBeginOverlap	Called when any component of this actor begins overlapping any component of another actor.
public	function	AActor::NotifyActorEndOverlap	Called when all overlapping component pairs between this actor and another actor have separated.
public	function	AActor::ReceiveActorBeginOverlap	Blueprint event fired when this actor begins overlapping another actor.
public	function	AActor::ReceiveActorEndOverlap	Blueprint event fired when this actor stops overlapping another actor.
public	function	AActor::ReceiveHit	Blueprint event fired when this actor blocks or is blocked by another actor's movement.
public	function	AActor::ActorGetDistanceToCollision	Returns the distance from a world-space point to the nearest collision surface on this actor.
public	function	AActor::ActorLineTraceSingle	Traces a ray against only the components of this specific actor and returns the first blocking hit.
public	function	AActor::AddActorLocalTransform	Applies a delta transform (offset + rotation + scale) to this actor in its local reference frame.
public	function	AActor::DisableComponentsSimulatePhysics	Calls SetSimulatePhysics(false) on every primitive component owned by this actor, stopping all physics simulation in one call.
public	function	AActor::GetComponentsBoundingCylinder	Computes the axis-aligned bounding cylinder that encloses all registered colliding components (or all components when bNonColliding is true).
public	function	AActor::GetComponentsCollisionResponseToChannel	Returns the most restrictive collision response across all components for the given channel.
public	function	AActor::GetOverlappingActors	Populates an array with all actors currently overlapping any component of this actor.
public	function	AActor::GetOverlappingComponents	Populates an output array with all UPrimitiveComponents from other actors that are currently overlapping any component of this actor.
public	function	AActor::GetSimpleCollisionCylinder	Returns an axis-aligned cylinder approximating this actor's simple collision, used for broad checks like AI pathfinding proximity tests.
public	function	AActor::GetSimpleCollisionCylinderExtent	Returns the simple collision cylinder as an FVector(Radius, Radius, HalfHeight), convenient for axis-aligned extent comparisons and box overlap approximations.
public	function	AActor::GetSimpleCollisionHalfHeight	Returns just the half-height component of GetSimpleCollisionCylinder().
public	function	AActor::GetSimpleCollisionRadius	Returns just the radius component of GetSimpleCollisionCylinder().
public	function	AActor::IsRootComponentCollisionRegistered	Returns true when the actor's root component is registered with the world and has collision enabled.
public	function	AActor::NotifyHit	Called when this actor bumps into a blocking object or is bumped into.
public	function	AActor::SetActorEnableCollision	Enables or disables collision for the entire actor by toggling all of its collision components at once.
public	function	AActor::UpdateOverlaps	Queries the world and refreshes the overlap state for all of this actor's components.
public	function	AActor::CanBeBaseForCharacter	Returns whether the given pawn is allowed to walk on (be based on) this actor.
public	function	AActor::ClearComponentOverlaps	Dispatches EndOverlap for all active overlaps on all of this actor's primitive components.
public	function	AActor::DispatchBlockingHit	Calls ReceiveHit on this actor and fires the OnComponentHit delegate on the blocking component.
public	function	AActor::DispatchPhysicsCollisionHit	Called by the physics engine when two rigid bodies collide.
public	function	AActor::GetUpdateOverlapsMethodDuringLevelStreaming	Returns the resolved method this actor uses to update overlaps when loaded via level streaming.

Damage

6 ▼

Access	Type	Name	Description
public	function	AActor::CanBeDamaged	Returns whether this actor can receive damage.
protected	function	AActor::ReceiveAnyDamage	Blueprint implementable event called on the server whenever this actor takes any damage.
public	function	AActor::SetCanBeDamaged	Sets whether this actor can receive damage.
protected	function	AActor::ReceivePointDamage	Blueprint implementable event called on the server when this actor takes point damage from a hit-scan or projectile hit.
protected	function	AActor::ReceiveRadialDamage	Blueprint implementable event called on the server when this actor takes radial (AoE) damage.
public	function	AActor::GetCanBeDamagedPropertyName	Returns the FName of the `bCanBeDamaged` UPROPERTY, allowing subsystems to reference the property by name without hard-coding the string.

Input

22 ▼

Access	Type	Name	Description
public	function	AActor::DisableInput	Removes this actor from the input stack of the specified PlayerController, stopping it from receiving input events.
public	function	AActor::EnableInput	Pushes this actor onto the input stack of the given PlayerController so it can receive and respond to input events.
public	function	AActor::GetInputAxisKeyValue	Returns the current float value of a specific input key axis, bypassing axis name mappings and querying the raw key state directly.
public	function	AActor::GetInputAxisValue	Returns the current float value of a named input axis, provided this actor has input enabled.
public	function	AActor::GetInputVectorAxisValue	Returns the current value of a vector-type input axis key as an FVector.
public	function	AActor::NotifyActorBeginCursorOver	Called by the engine when the mouse cursor first moves over this actor while click-events are enabled on the player controller.
public	function	AActor::NotifyActorEndCursorOver	Called when the mouse cursor leaves this actor after having entered it while click-events are enabled.
public	function	AActor::NotifyActorOnClicked	Called when the player clicks on this actor while click-events are enabled.
public	function	AActor::NotifyActorOnInputTouchBegin	Called when this actor is touched by a finger when click events are enabled in the PlayerController.
public	function	AActor::NotifyActorOnInputTouchEnd	Called when a finger is lifted off this actor when click events are enabled in the PlayerController.
public	function	AActor::NotifyActorOnInputTouchEnter	Called when a touch finger moves onto this actor while touch-events are enabled, analogous to NotifyActorBeginCursorOver but for touchscreen input.
public	function	AActor::NotifyActorOnInputTouchLeave	Called when a touch finger moves off this actor while touch-events are enabled.
public	function	AActor::NotifyActorOnReleased	Called when the mouse button is released over this actor after a click, while click-events are enabled.
public	function	AActor::ReceiveActorBeginCursorOver	Blueprint implementable event called when the mouse cursor moves over this actor, provided mouse-over events are enabled on the player controller.
public	function	AActor::ReceiveActorEndCursorOver	Blueprint implementable event called when the mouse cursor moves off this actor, provided mouse-over events are enabled on the player controller.
public	function	AActor::ReceiveActorOnClicked	Blueprint implementable event called when the mouse clicks this actor while click events are enabled on the player controller.
public	function	AActor::ReceiveActorOnInputTouchBegin	Blueprint implementable event called when a touch input begins on this actor.
public	function	AActor::ReceiveActorOnInputTouchEnd	Blueprint implementable event called when a touch input ends over this actor.
public	function	AActor::ReceiveActorOnInputTouchEnter	Blueprint implementable event called when an active touch point moves onto this actor's area.
public	function	AActor::ReceiveActorOnInputTouchLeave	Blueprint implementable event called when an active touch point moves off this actor's area.
public	function	AActor::ReceiveActorOnReleased	Blueprint implementable event called when a mouse button is released over this actor while click events are enabled on the player controller.
public	function	AActor::CreateInputComponent	Creates the actor's InputComponent using the provided class.

Networking

111 ▼

Access	Type	Name	Description
public	function	AActor::AddActorComponentReplicatedSubObject	Registers a UObject as a replicated sub-object owned by a specific actor component, so its UPROPERTY fields replicate along with that component's replication lifecycle.
public	function	AActor::AddReplicatedSubObject	Registers a UObject as a replicated sub-object of this actor so its UPROPERTY fields are automatically replicated.
public	function	AActor::AllowActorComponentToReplicate	Override to control whether a component that wants to replicate is actually allowed to, and to which connections.
public	function	AActor::CallPreReplication	Called by the networking system to invoke PreReplication on this actor and all of its replicated components.
public	function	AActor::CallRemoteFunction	Sends an RPC function call across the network via the actor's NetDriver.
public	function	AActor::CanTriggerResimulation	Returns whether this actor is allowed to trigger a physics resimulation when Physics Prediction is enabled.
public	function	AActor::CopyRemoteRoleFrom	Copies the RemoteRole from another actor and registers this actor with the net driver if the copied role makes it a networked actor.
public	function	AActor::DestroyNetworkActorHandled	Called by DestroyActor() to give actors a chance to opt out of immediate destruction, allowing the network layer to perform cleanup first.
public	function	AActor::DestroyReplicatedSubObjectOnRemotePeers	Stops replicating a sub-object and instructs actor channels to delete its replica on all connected clients the next time the actor replicates.
public	function	AActor::ExchangeNetRoles	Swaps the Role and RemoteRole of this actor when called on a client to establish correct local authority perspective.
public	function	AActor::FillReplicationParams	Called by the Iris replication system immediately before an actor begins replicating to allow custom replication parameters to be injected.
public	function	AActor::FlushNetDormancy	Forces a dormant actor to send a replication update to clients without permanently waking it.
public	function	AActor::ForceNetRelevant	Forces this actor to be considered net-relevant even if it would otherwise be culled by distance or dormancy rules.
public	function	AActor::ForceNetUpdate	Forces this actor to be considered dirty for replication and sent to clients on the next network tick, bypassing its normal NetUpdateFrequency schedule.
public	function	AActor::ForcePropertyCompare	Forces all replicated properties on this actor to do a full comparison against their shadow state for one frame, rather than relying on the shared dirty-tracking state.
public	function	AActor::GatherCurrentMovement	Fills the `ReplicatedMovement` struct with the actor's current location, rotation, velocity, and angular velocity so that data can be sent to clients.
public	function	AActor::GetAttachmentReplication	Returns a const reference to the `FRepAttachment` struct that the engine fills in when this actor's root component is attached to another actor, used to replicate attachment state to clients.
public	function	AActor::GetFunctionCallspace	Returns a bitmask indicating where a given UFUNCTION should execute — locally, on the server, on clients, or some combination.
public	function	AActor::GetIsReplicated	Returns whether replication is currently enabled for this actor.
public	function	AActor::GetLifetimeReplicatedProps	Override this in any actor subclass that has UPROPERTY members marked with Replicated or ReplicatedUsing to register those properties with the replication system.
public	function	AActor::GetLocalRole	Returns the net role of this actor on the current machine — `ROLE_Authority` on the server, `ROLE_SimulatedProxy` or `ROLE_AutonomousProxy` on clients.
public	function	AActor::GetMinNetUpdateFrequency	Returns the minimum rate (updates per second) this actor will be considered for replication, even when its replicated properties are not changing.
public	function	AActor::GetNetConnection	Returns the owning net connection for this actor, used to determine which client connection owns and controls it.
public	function	AActor::GetNetCullDistanceSquared	Returns the squared net cull distance for this actor.
public	function	AActor::GetNetDormancy	Determines whether this actor should be dormant for a specific net connection.
public	function	AActor::GetNetDriver	Returns the UNetDriver this actor is bound to, or nullptr if the actor has no net driver association.
public	function	AActor::GetNetDriverName	Returns the name of the net driver associated with this actor.
public	function	AActor::GetNetMode	Returns the current network mode (dedicated server, listen server, client, or standalone).
public	function	AActor::GetNetOwner	Returns the actor responsible for network replication decisions.
public	function	AActor::GetNetOwningPlayer	Returns the owning UPlayer for this actor, but only when the actor's role is ROLE_Authority.
public	function	AActor::GetNetOwningPlayerAnyRole	Returns the owning UPlayer for this actor regardless of its current net role.
public	function	AActor::GetNetPriority	Returns the replication priority for this actor on a given connection.
public	function	AActor::GetNetUpdateFrequency	Returns the current rate (updates per second) at which this actor is considered for replication.
public	function	AActor::GetOwner	Returns the actor that owns this actor, or nullptr if there is no owner.
public	function	AActor::GetPhysicsReplicationMode	Returns the current physics replication mode set on this actor.
public	function	AActor::GetRemoteRole	Returns the net role this actor has on the remote machine.
public	function	AActor::GetReplayPriority	Returns the priority for replicating this actor into a replay recording.
public	function	AActor::GetReplicatedComponents	Returns a const reference to the cached array of components that have replication enabled on this actor.
public	function	AActor::GetReplicatedCustomConditionState	Called once when this actor begins replicating to initialize the active state of properties registered with `COND_Custom`.
public	function	AActor::GetReplicatedMovement	Returns a const reference to the actor's replicated movement struct, which holds the location, rotation, linear velocity, and angular velocity as received from the server.
public	function	AActor::GetReplicatedMovement_Mutable	Returns a mutable reference to the actor's replicated movement struct, intended for cases where the struct must be modified in place — primarily by the engine's replication machinery.
public	function	AActor::GetReplicateMovementPropertyName	Returns the FName of the bReplicateMovement property on AActor, intended for use in lifetime property registration without requiring direct access to the private member.
public	function	AActor::GetResimulationThreshold	Returns the positional error threshold in centimeters beyond which this actor should force a physics resimulation when the Network Physics Prediction system is active.
public	function	AActor::GetRolePropertyName	Returns the FName of the `Role` UPROPERTY (the actor's local net role), allowing reflection-based systems to reference the property without hard-coded strings.
public	function	AActor::GetTearOff	Returns whether this actor has been torn off — that is, no longer receiving replication updates from the server and now running as a local authority copy on the client.
public	function	AActor::HasAuthority	Returns true if this actor has network authority — i.
public	function	AActor::HasLocalNetOwner	Returns true if this actor's owner chain leads to a locally controlled player controller on the current machine.
public	function	AActor::HasNetOwner	Returns true if this actor has an owner chain that leads to an actor capable of net ownership, typically an APlayerController.
public	function	AActor::IsActorComponentReplicatedSubObjectRegistered	Returns true if the given object is currently registered as a replicated sub-object of the specified actor component.
public	function	AActor::IsNameStableForNetworking	Returns true if this actor's path name is stable enough to be used as a net reference across server and client.
public	function	AActor::IsNetMode	Returns true if the current network mode matches Mode.
public	function	AActor::IsNetRelevantFor	Determines whether this actor is network-relevant for a given client connection.
public	function	AActor::IsNetStartupActor	Returns true if this is a replicated actor that was placed in the level map at design time (a 'net startup actor'), as opposed to one dynamically spawned at runtime.
public	function	AActor::IsRelevancyOwnerFor	Determines whether this actor should be considered the relevancy owner for a given replicated actor on a given connection.
public	function	AActor::IsReplayRelevantFor	Determines whether this actor should be recorded into a replay for a given viewer.
public	function	AActor::IsReplicatedActorComponentRegistered	Returns true if the given component is currently registered in the actor's replicated component list and is being replicated.
public	function	AActor::IsReplicatedSubObjectRegistered	Returns true if the given object is currently registered as a replicated sub-object directly on this actor (not via a component).
public	function	AActor::IsReplicatingMovement	Returns the current value of `bReplicateMovement`, indicating whether the engine's built-in movement replication is enabled for this actor.
public	function	AActor::IsSupportedForNetworking	Returns true if this actor can be referenced across a network connection.
public	function	AActor::IsUsingRegisteredSubObjectList	Returns true if this actor replicates its subobjects and ActorComponents via the registered subobject list rather than via the virtual ReplicateSubobjects() method.
public	function	AActor::OnActorChannelOpen	Called on the client when the actor's net channel is first opened.
public	function	AActor::OnNetCleanup	Called when the net connection associated with this actor is being closed or destroyed.
public	function	AActor::OnRep_AttachmentReplication	RepNotify called on clients when the `AttachmentReplication` property changes, causing the engine to apply the new attachment transform and socket on the client.
public	function	AActor::OnRep_Instigator	Called on clients when the Instigator property is replicated.
public	function	AActor::OnRep_ReplicatedMovement	Called on clients when the ReplicatedMovement struct is replicated.
public	function	AActor::OnRep_ReplicateMovement	RepNotify callback invoked on clients whenever the `bReplicateMovement` property changes, used to start or stop physics/movement replication.
public	function	AActor::OnSerializeNewActor	Called on the server immediately before a new actor is serialized and sent to a connecting client.
public	function	AActor::OnSubobjectCreatedFromReplication	Called on the client actor when the replication system dynamically creates a new subobject that was spawned on the server.
public	function	AActor::OnSubobjectDestroyFromReplication	Called on the client actor just before the replication system destroys a subobject that no longer exists on the server.
public	function	AActor::PostNetInit	Called on the client immediately after an actor is spawned via replication and all initial replicated properties have been received.
public	function	AActor::PostNetReceive	Called immediately after replicated properties have been applied to this actor on the client.
public	function	AActor::PostNetReceiveLocationAndRotation	Called after the actor receives replicated location and rotation from the network via ReplicatedMovement.
public	function	AActor::PostNetReceivePhysicState	Called on simulated proxies when physics state (location, rotation, velocity, and angular velocity) is received from ReplicatedMovement.
public	function	AActor::PostNetReceiveRole	Called immediately after the actor's Role is received from the server.
public	function	AActor::PostNetReceiveVelocity	Called on simulated proxies when a new velocity is received from the ReplicatedMovement struct.
public	function	AActor::PreNetReceive	Called immediately before replicated properties are applied to this actor on the client.
public	function	AActor::PreReplication	Called on the server (and autonomous proxy during client replays) immediately before replication occurs.
public	function	AActor::PreReplicationForReplay	Called before replication when recording a client replay, including for simulated proxies.
public	function	AActor::RegisterAsFocalPointInPhysicsReplicationLOD	Registers this actor's root component physics object as a focal point in the Physics Replication LOD system, causing the engine to allocate higher-fidelity physics replication budget around this actor.
public	function	AActor::RegisterReplicationFragments	Called by the Iris replication system to let the actor register its replication fragments.
public	function	AActor::RemoveActorComponentReplicatedSubObject	Unregisters a UObject that was previously registered as a replicated sub-object of a specific component, stopping its replication.
public	function	AActor::RemoveReplicatedSubObject	Unregisters a UObject from this actor's replicated sub-object list, stopping future property replication.
public	function	AActor::ReplicateSubobjects	Override to manually replicate subobjects (UObjects owned by this actor) on the actor channel.
public	function	AActor::RewindForReplay	Called on the actor before replay checkpoint data is applied, giving it a chance to reset any transient state that checkpoint data does not cover.
public	function	AActor::SetActorIsPendingPostNetInit	Sets the internal flag that tracks whether this actor is still pending its `PostNetInit` phase after initial network replication.
public	function	AActor::SetAutonomousProxy	Changes the actor's local network role to AutonomousProxy (client-driven) or SimulatedProxy (server-driven).
public	function	AActor::SetCallPreReplication	Controls whether `PreReplication()` is invoked on this actor before each replication attempt.
public	function	AActor::SetCallPreReplicationForReplay	Controls whether `PreReplicationForReplay()` is called before each replay replication pass.
public	function	AActor::SetFakeNetPhysicsState	Forces the physics body of this actor into a fake network-replicated sleep or wake state, used exclusively with EPhysicsReplicationMode::PredictiveInterpolation.
public	function	AActor::SetMinNetUpdateFrequency	Sets the rate the engine throttles down to when this actor's replicated properties have not changed recently.
public	function	AActor::SetNetAddressable	Marks this actor as net-addressable by its full path name so that clients can reference it by name even though it was spawned dynamically after map load.
public	function	AActor::SetNetCullDistanceSquared	Sets the squared net cull distance for this actor.
public	function	AActor::SetNetDormancy	Sets the network dormancy state of this actor.
public	function	AActor::SetNetDriverName	Associates this actor with a specific net driver by name, moving it out of its current driver's network actor list and into the new driver's list.
public	function	AActor::SetNetUpdateFrequency	Sets how many times per second this actor is considered for replication.
public	function	AActor::SetOwner	Sets the owner of this actor, which primarily affects network relevancy and RPC routing.
public	function	AActor::SetPhysicsReplicationMode	Sets the physics replication mode for this actor, controlling how physics state is synchronized from server to clients.
public	function	AActor::SetReplicatedComponentNetCondition	Changes the network lifetime condition of an already-registered replicated component at runtime, after BeginPlay.
public	function	AActor::SetReplicatedMovement	Replaces the actor's ReplicatedMovement struct wholesale.
public	function	AActor::SetReplicateMovement	Controls whether this actor's movement (location, rotation, velocity) is replicated from server to clients.
public	function	AActor::SetReplicates	Enables or disables replication for this actor at runtime.
public	function	AActor::SetReplicatingMovement	Sets whether this actor's movement (location, rotation, velocity) is replicated to clients.
public	function	AActor::SetRole	Directly sets the actor's net role without triggering any side effects.
public	function	AActor::SwapRoles	Swaps the values of Role and RemoteRole on this actor.
public	function	AActor::TearOff	Server-side call that stops replication for this actor and promotes all existing client copies to local authority (`ROLE_Authority`).
public	function	AActor::TearOffReplicatedSubObjectOnRemotePeers	Stops replicating a sub-object and releases the network engine's reference to the client replica, leaving the client-side object alive but no longer updated.
public	function	AActor::TornOff	Called on the client when this actor is torn off from replication (bTearOff == true), meaning the server will no longer replicate it.
public	function	AActor::UnregisterAsFocalPointInPhysicsReplicationLOD	Removes this actor's root component physics object from the Physics Replication LOD focal point list, reverting it to standard LOD priority.
public	function	AActor::UpdateAllReplicatedComponents	Rebuilds the actor's ReplicatedComponents cache from scratch so it exactly matches all currently-owned components whose IsReplicated() returns true.
public	function	AActor::UpdateReplicatedComponent	Refreshes the actor's internal ReplicatedComponents cache for a single component after its replication state changes.
public	function	AActor::UseShortConnectTimeout	Tells the net driver whether the owning connection should switch from the initial long connect timeout to the shorter gameplay timeout value.

Rendering

18 ▼

Access	Type	Name	Description
public	function	AActor::SetActorHiddenInGame	Hides or shows the actor and all of its components in the game world.
public	function	AActor::GetLastRenderTime	Returns the most recent game time (in seconds) at which any of this actor's components were rendered.
public	function	AActor::IsHidden	Returns the raw value of the bHidden flag.
public	function	AActor::MarkComponentsRenderStateDirty	Flags all components' render state as dirty, causing them to be re-submitted to the render thread on the next frame.
public	function	AActor::SetHidden	Sets the bHidden flag directly without triggering virtual behavior or component notifications.
public	function	AActor::UpdateComponentVisibility	Propagates the actor's current hidden/visible state to all attached components, ensuring their render visibility matches the actor-level flag.
public	function	AActor::WasRecentlyRendered	Returns true if any of this actor's primitive components have been rendered within the last Tolerance seconds of game time.
public	function	AActor::GetHiddenPropertyName	Returns the FName of the bHidden property.
public	function	AActor::GetHLODRelevantComponents	Returns the list of components from this actor that should contribute geometry to the actor's Hierarchical LOD proxy mesh during a HLOD build.
public	function	AActor::GetRayTracingGroupId	Returns the ray tracing group ID assigned to this actor.
public	function	AActor::HasHLODRelevantComponents	Returns whether this actor contains any components that should be included when building its Hierarchical LOD proxy mesh.
public	function	AActor::InvalidateLightingCache	Invalidates the cached static lighting for this actor using default options.
public	function	AActor::InvalidateLightingCacheDetailed	Invalidates all static lighting data produced by the last lighting build for this actor, with control over whether to do a full invalidation or a translation-only pass.
public	function	AActor::IsHLODRelevant	Returns whether this actor should contribute geometry to Hierarchical Level of Detail (HLOD) mesh generation.
public	function	AActor::PostRenderFor	Hook for actors to render HUD overlays for themselves, called from AHUD::DrawActorOverlays().
public	function	AActor::PrestreamTextures	Forces all mesh components on this actor to prestream their textures at full resolution for the specified duration.
public	function	AActor::SetLODParent	Assigns an HLOD proxy component as the LOD parent for all of this actor's primitive components, hiding them when the proxy is shown at distance.
public	function	AActor::SetRayTracingGroupId	Assigns a ray tracing group ID to this actor.

Audio

1 ▼

Access	Type	Name	Description
public	function	AActor::SetMakeNoiseDelegate	Replaces the global delegate that handles `MakeNoise` calls, allowing custom AI hearing logic to intercept or replace the default noise propagation.

Navigation

1 ▼

Access	Type	Name	Description
public	function	AActor::IsComponentRelevantForNavigation	Override to control whether a specific owned component contributes geometry to the navigation mesh.

Access	Type	Name	Description
public	function	AActor::ActorHasTag	Returns true if this actor's `Tags` array contains the specified name.

Access	Type	Name	Description
public	function	AActor::GetDebugName	Returns the actor's name as a string, or the literal string "NULL" if the pointer is null.
public	function	AActor::GetGameInstance	Returns the UGameInstance that ultimately owns this actor's world.
public	function	AActor::GetHumanReadableName	Returns a human-readable string name for this actor, suitable for display in debug output and logs.
public	function	AActor::GetWorld	Returns the UWorld that contains this actor.
public	function	AActor::GetWorldTimerManager	Returns a reference to the world's FTimerManager, which is used to set, clear, and query timers.
public	function	AActor::IsOwnedBy	Walks the Owner chain of this actor and returns true if TestOwner appears anywhere in it.
public	function	AActor::BecomeViewTarget	Called when a PlayerController sets this actor as its view target.
public	function	AActor::CalculateComponentsBoundingBoxInLocalSpace	Calculates the actor-local-space bounding box of all components by recalculating component local bounds each time.
public	function	AActor::CheckStillInWorld	Checks whether the actor is still within valid world bounds, including the KillZ plane and world boundary volumes, and handles the situation if not.
public	function	AActor::DebugShowComponentHierarchy	Prints the full scene component attachment hierarchy of this actor to the log, optionally showing each component's world-space position.
public	function	AActor::DrawDebugComponents	Renders debug visualizations for the component tree of this actor in the world for one frame.
public	function	AActor::EndViewTarget	Called when a PlayerController stops using this actor as its view target.
public	function	AActor::GetActorEyesViewPoint	Returns the world-space location and rotation representing this actor's eye position and view direction.
public	function	AActor::GetActorNameOrLabel	Returns the actor's editor label if one has been set, otherwise falls back to the actor's internal object name.
public	function	AActor::GetActorTimeDilation	Returns the current time dilation factor applied to this actor, combining world and actor-level dilation.
public	function	AActor::GetComponentsBoundingBox	Returns the world-space axis-aligned bounding box enclosing all registered components on this actor.
public	function	AActor::GetInstigator	Returns the pawn responsible for spawning or triggering this actor, or nullptr if none was set.
public	function	AActor::GetInstigatorController	Returns the controller of this actor's instigator pawn, or nullptr if there is no instigator or the instigator has no controller.
public	function	AActor::GetLevel	Returns the ULevel that contains this actor.
public	function	AActor::GetPhysicsVolume	Returns the APhysicsVolume that is currently affecting this actor.
public	function	AActor::GetTargetLocation	Returns the optimal location to fire weapons at or aim towards this actor.
public	function	AActor::GetWorldSettings	Returns the AWorldSettings actor for the world this actor is in.
public	function	AActor::IsBasedOnActor	Iterates up the movement base chain to determine whether this actor is based on (standing on or riding) the given actor.
public	function	AActor::IsEditorOnly	Returns true if this actor should exist only in editor builds and be stripped from cooked/packaged games.
public	function	AActor::IsInLevel	Returns true if this actor is contained in the specified ULevel.
public	function	AActor::IsInPersistentLevel	Returns whether this actor resides in the persistent level rather than a streaming sublevel.
public	function	AActor::IsMainPackageActor	Returns true if this actor is the primary actor of its containing package (i.
public	function	AActor::K2_OnBecomeViewTarget	Blueprint event fired when a PlayerController sets this actor as its view target.
public	function	AActor::K2_OnEndViewTarget	Blueprint event fired when a PlayerController stops using this actor as its view target.
public	function	AActor::SetInstigator	Sets the instigating pawn responsible for spawning or triggering this actor.
public	function	AActor::AddReferencedObjects	Static GC hook that lets actors report object references held in non-UPROPERTY storage, ensuring the garbage collector does not prematurely collect those objects.
public	function	AActor::CalcCamera	Calculates the camera view point for this actor when it is the active view target.
public	function	AActor::CanBeInCluster	Returns whether this actor is eligible to be grouped into a GC cluster, which improves Garbage Collection performance by treating a set of objects as a single unit.
public	function	AActor::CheckDefaultSubobjectsInternal	Internal integrity check that verifies all default subobjects (components created in the constructor) are properly registered.
public	function	AActor::ClearCrossLevelReferences	Clears any references this actor holds to objects in other levels.
public	function	AActor::ContainsDataLayer	Returns true if this actor belongs to the specified data layer asset.
public	function	AActor::DebugShowOneComponentHierarchy	Prints the hierarchy of a single scene component and its children to the log.
public	function	AActor::DisplayDebug	Called by the HUD to draw debug information for this actor on-screen when the `showdebug` console command is active.
public	function	AActor::FindActorInPackage	Static helper that searches a UPackage and returns the first AActor it finds.
public	function	AActor::GetActorLabelView	Returns a non-owning view into the actor's editor label string without allocating.
public	function	AActor::GetDataLayerInstances	Returns all UDataLayerInstance objects this actor belongs to, resolving both the actor's DataLayerAssets list and any inherited parent data layers.
public	function	AActor::GetExternalDataLayerAsset	Returns the External Data Layer asset associated with this actor's Content Bundle, if any.
public	function	AActor::GetInstigatorPropertyName	Returns the FName of the `Instigator` UPROPERTY, allowing reflection-based systems to reference the property without hard-coding the string.
public	function	AActor::GetPlacementExtent	Returns the bounding extent used when placing this actor in the editor, primarily to offset the actor from a hit surface so it doesn't clip into geometry.
public	function	AActor::GetRootSelectionParent	Returns the topmost actor in the editor selection hierarchy, traversing up through GetSelectionParent() until the root is found.
public	function	AActor::GetSelectionParent	Returns the immediate parent actor in the editor selection hierarchy.
public	function	AActor::HasContentBundle	Returns true if this actor is associated with a World Partition Content Bundle.
public	function	AActor::HasDataLayers	Returns true if this actor belongs to at least one data layer.
public	function	AActor::HasNonTrivialUserConstructionScript	Returns true if this actor's class has a non-trivial Blueprint User Construction Script — i.
public	function	AActor::IsActorOrSelectionParentSelected	Returns true if this actor or any of its selection parents are currently selected in the editor.
public	function	AActor::IsAsset	Returns whether this actor should be treated as a standalone asset (e.
public	function	AActor::IsEditorOnlyLoadedInPIE	Returns whether this actor, despite being editor-only, should still be loaded and present during Play-In-Editor sessions.
public	function	AActor::IsLevelBoundsRelevant	Returns whether this actor should be included when calculating the level's bounding box.
public	function	AActor::IsMigrationRoot	Returns true if this actor is the root object of a Remote Object Handle migration operation — meaning the engine will migrate this actor (and its subobjects) as a unit when transferring between server processes.
public	function	AActor::IsRuntimeOnly	Returns whether this actor should only exist at runtime and be excluded from editor-world operations such as level saving and cooking preparation.
public	function	AActor::IsSelectionChild	Returns whether this actor is part of another actor's selection group in the editor.
public	function	AActor::IsSelectionParentOfAttachedActors	Returns whether this actor acts as a selection parent for its attached actors in the editor.
public	function	AActor::MakeNoiseImpl	Default static implementation called by the MakeNoise delegate.
public	function	AActor::MarkNeedsRecomputeBoundsOnceForGame	Marks all SceneComponents on this actor that have bComputeBoundsOnceForGame set as needing their cached bounds recomputed the next time UpdateBounds is called.
public	function	AActor::PostLoadSubobjects	Called after all subobjects have been serialized and their references fixedup during asset load.
public	function	AActor::PostMigrate	Called after this actor has been migrated between server instances or processes via the UE Remote Object Handle system.
public	function	AActor::PostRename	Called by the engine immediately after an actor (or its outer) is renamed.
public	function	AActor::PostSaveFromRoot	Called on non-root actors after the package containing the root actor has finished saving.
public	function	AActor::PostSaveRoot	Called after the root object of a package has been saved.
public	function	AActor::PreDuplicateFromRoot	Called on the source actor before it and its sub-objects are duplicated (e.
public	function	AActor::PreSave	Called on every UObject in a package just before it is serialized to disk or cooked.
public	function	AActor::PreSaveFromRoot	Called on non-root actors in the same package before the root actor's package is saved.
public	function	AActor::PreSaveRoot	Called before the root object of a package is saved.
public	function	AActor::ProcessEvent	Low-level UObject event dispatch entry point, overridden in AActor to intercept and redirect UFUNCTION calls — particularly for routing Blueprint events and remote-function calls through the actor's replication layer.
public	function	AActor::PushSelectionToProxies	Propagates the current editor selection state down to all primitive scene proxies owned by this actor, causing the viewport to render the selection highlight correctly.
public	function	AActor::Rename	Renames this actor within the object system, optionally re-outering it to a different level or package.
public	function	AActor::SupportsSubRootSelection	Returns true if this actor can be individually selected as a sub-selection within its root selection parent's group.

Access	Type	Name	Description
public	function	AActor::GetComponentByClass	Returns the first component of the given class attached to this actor, or null if none is found.

Access	Type	Name	Description
public	function	AActor::MakeNoise	Dispatches a noise event that can be picked up by `UPawnSensingComponent` instances.

Access	Type	Name	Description
public	function	AActor::GetActorTickInterval	Returns the current minimum tick interval (in seconds) of this actor's primary tick function.
public	function	AActor::GetTickableWhenPaused	Returns whether this actor's primary tick function is set to tick even when the game is paused.
public	function	AActor::IsActorTickEnabled	Returns true if this actor's primary tick function is currently enabled.
public	function	AActor::SetActorTickEnabled	Enables or disables this actor's primary tick function at runtime.
public	function	AActor::SetActorTickInterval	Sets the minimum time between consecutive ticks for this actor's primary tick function.
public	function	AActor::SetTickableWhenPaused	Controls whether this actor's primary tick function fires while the game is paused.
public	function	AActor::AddTickPrerequisiteActor	Forces this actor's tick to run after the specified actor's tick has completed.
public	function	AActor::AddTickPrerequisiteComponent	Forces this actor's tick to run after the specified component's tick has completed.
public	function	AActor::RemoveTickPrerequisiteActor	Removes a previously added actor tick prerequisite so this actor can tick freely again relative to that actor.
public	function	AActor::RemoveTickPrerequisiteComponent	Removes a previously added component tick prerequisite from this actor's primary tick function.
public	function	AActor::SetTickGroup	Assigns this actor's primary tick function to a specific tick group, controlling when in the frame it runs relative to physics and other systems.

Access	Type	Name	Description
public	function	AActor::GetActorForwardVector	Returns the unit forward vector (local +X axis) of this actor in world space, derived from the RootComponent's world rotation.
public	function	AActor::GetActorRightVector	Returns the unit right vector (local +Y axis) of this actor in world space, derived from the RootComponent's world rotation.
public	function	AActor::GetActorUpVector	Returns the unit up vector (local +Z axis) of this actor in world space, derived from the RootComponent's world rotation.
public	function	AActor::GetDistanceTo	Returns the world-space distance in centimetres between this actor's origin and OtherActor's origin.

Properties

Access	Type	Name	Description
public	property	AActor::AutoReceiveInput	Specifies which player's input this actor will automatically receive when the game starts, without requiring explicit EnableInput() calls.
public	property	AActor::BlueprintCreatedComponents	Stores the actor components that were created by Blueprint construction scripts and serialised on a per-instance basis.
public	property	AActor::Children	Array of all actors whose Owner is this actor.
public	property	AActor::CustomTimeDilation	A per-actor time multiplier applied on top of the global WorldSettings TimeDilation.
public	property	AActor::InitialLifeSpan	How many seconds this actor lives before being automatically destroyed.
public	property	AActor::InputComponent	The UInputComponent that handles input bindings for this actor when input is enabled.
public	property	AActor::InputPriority	The priority of this actor's input component in the player controller's input stack.
public	property	AActor::Layers	The editor layer names this actor belongs to.
public	property	AActor::NetDormancy	Controls whether and how this actor is allowed to enter a dormant state where it is removed from the replication list without being destroyed on clients.
public	property	AActor::NetPriority	A weight used to prioritise this actor for replication when bandwidth is limited or the replication list is saturated.
public	property	AActor::NetTag	Internal bookkeeping integer used by UNetDriver to track actor channel state.
public	property	AActor::OnActorBeginOverlap	Multicast delegate fired when another actor begins overlapping this actor.
public	property	AActor::OnActorEndOverlap	Multicast delegate fired when another actor stops overlapping this actor.
public	property	AActor::OnActorHit	Multicast delegate fired when this actor hits (or is hit by) a solid blocking surface.
public	property	AActor::OnBeginCursorOver	Delegate fired when the mouse cursor moves over this actor while mouse-over events are enabled in the PlayerController.
public	property	AActor::OnClicked	Multicast delegate fired when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
public	property	AActor::OnDestroyed	Delegate broadcast when this actor has been explicitly destroyed via Destroy().
public	property	AActor::OnEndCursorOver	Delegate fired when the mouse cursor moves off this actor while mouse-over events are enabled in the PlayerController.
public	property	AActor::OnEndPlay	Delegate broadcast whenever this actor's play session ends for any reason — explicit destruction, level unload, game end, or streaming out.
public	property	AActor::OnInputTouchBegin	Delegate fired when a touch input begins over this actor while touch events are enabled in the player controller.
public	property	AActor::OnInputTouchEnd	Delegate fired when a touch input that began over this actor is released, while touch events are enabled in the player controller.
public	property	AActor::OnInputTouchEnter	Delegate fired when a finger moves onto this actor's touch area while a touch is already active and touch over events are enabled in the player controller.
public	property	AActor::OnInputTouchLeave	Delegate fired when a moving finger leaves this actor's touch area while a touch is active and touch over events are enabled in the player controller.
public	property	AActor::OnReleased	Multicast delegate fired when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
public	property	AActor::OnTakeAnyDamage	Delegate broadcast whenever this actor takes any form of damage (point, radial, or generic).
public	property	AActor::OnTakePointDamage	Delegate broadcast when this actor takes point damage — typically a hit-scan or projectile that supplies a precise impact location, bone name, and shot direction.
public	property	AActor::OnTakeRadialDamage	Delegate broadcast when this actor takes radial (area-of-effect) damage, providing the explosion origin and a hit result for the closest impacted primitive.
public	property	AActor::Owner	The owning actor of this actor.
public	property	AActor::PrimaryActorTick	The primary tick function for this actor.
public	property	AActor::SpawnCollisionHandlingMethod	Controls how spawning this actor is handled when it would collide with an existing object.
public	property	AActor::Tags	An array of FName tags attached to this actor for grouping and querying purposes.

Events & Delegates

event OnActorBeginOverlap event OnActorEndOverlap event OnActorHit

Version History

Introduced in: 1.0

Version	Status	Notes
5.6	stable	—
5.5	stable	—

Feedback

Was this helpful?