unreal.Actor

class unreal.Actor(outer=None, name='None')

Bases: unreal.Object

Actor is the base class for an Object that can be placed or spawned in a level. Actors may contain a collection of ActorComponents, which can be used to control how actors move, how they are rendered, etc. The other main function of an Actor is the replication of properties and function calls across the network during play.

Actor initialization has multiple steps, here’s the order of important virtual functions that get called: - UObject::PostLoad: For actors statically placed in a level, the normal UObject PostLoad gets called both in the editor and during gameplay.

This is not called for newly spawned actors.
  • UActorComponent::OnComponentCreated: When an actor is spawned in the editor or during gameplay, this gets called for any native components.
    For blueprint-created components, this gets called during construction for that component. This is not called for components loaded from a level.
  • AActor::PreRegisterAllComponents: For statically placed actors and spawned actors that have native root components, this gets called now.
    For blueprint actors without a native root component, these registration functions get called later during construction.
  • UActorComponent::RegisterComponent: All components are registered in editor and at runtime, this creates their physical/visual representation.
    These calls may be distributed over multiple frames, but are always after PreRegisterAllComponents. This may also get called later on after an UnregisterComponent call removes it from the world.
  • AActor::PostRegisterAllComponents: Called for all actors both in the editor and in gameplay, this is the last function that is called in all cases.
  • AActor::PostActorCreated: When an actor is created in the editor or during gameplay, this gets called right before construction.
    This is not called for components loaded from a level.
  • AActor::UserConstructionScript: Called for blueprints that implement a construction script.
  • AActor::OnConstruction: Called at the end of ExecuteConstruction, which calls the blueprint construction script.
    This is called after all blueprint-created components are fully created and registered. This is only called during gameplay for spawned actors, and may get rerun in the editor when changing blueprints.
  • AActor::PreInitializeComponents: Called before InitializeComponent is called on the actor’s components.
    This is only called during gameplay and in certain editor preview windows.
  • UActorComponent::Activate: This will be called only if the component has bAutoActivate set.
    It will also got called later on if a component is manually activated.
  • UActorComponent::InitializeComponent: This will be called only if the component has bWantsInitializeComponentSet.
    This only happens once per gameplay session.
  • AActor::PostInitializeComponents: Called after the actor’s components have been initialized, only during gameplay and some editor previews.
  • AActor::BeginPlay: Called when the level starts ticking, only during actual gameplay.
    This normally happens right after PostInitializeComponents but can be delayed for networked or child actors.

https://docs.unrealengine.com/latest/INT/Programming/UnrealArchitecture/Actors/: https://docs.unrealengine.com/en-us/Programming/UnrealArchitecture/Actors/ActorLifecycle: UActorComponent:

C++ Source:

  • Module: Engine
  • File: Actor.h

Editor Properties: (see get_editor_property/set_editor_property)

  • allow_tick_before_begin_play (bool): [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event. Normally we don’t tick actors until after BeginPlay; this setting allows this behavior to be overridden. This Actor must be able to tick for this setting to be relevant.
  • always_relevant (bool): [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
  • auto_destroy_when_finished (bool): [Read-Write] If true then destroy self when “finished”, meaning all relevant components report that they are done and no timelines or timers are in flight.
  • auto_receive_input (AutoReceiveInput): [Read-Write] Automatically registers this actor to receive input from a player.
  • block_input (bool): [Read-Write] If true, all input on the stack below this actor will not be considered
  • can_be_damaged (bool): [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called. https://www.unrealengine.com/blog/damage-in-ue4: TakeDamage(), ReceiveDamage():
  • can_be_in_cluster (bool): [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
  • custom_time_dilation (float): [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor’s tick.
  • enable_auto_lod_generation (bool): [Read-Write] If true, and if World setting has bEnableHierarchicalLOD equal to true, then it will generate LODActor from groups of clustered Actor
  • find_camera_component_when_view_target (bool): [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
  • generate_overlap_events_during_level_streaming (bool): [Read-Write] If true, this actor will generate overlap events when spawned as part of level streaming. You might enable this is in the case where a streaming level loads around an actor and you want overlaps to trigger.
  • hidden (bool): [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game. SetActorHiddenInGame():
  • ignores_origin_shifting (bool): [Read-Write] Whether this actor should not be affected by world origin shifting.
  • initial_life_span (float): [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
  • input_priority (int32): [Read-Write] The priority of this input component when pushed in to the stack.
  • instigator (Pawn): [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
  • is_editor_only_actor (bool): [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
  • min_net_update_frequency (float): [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
  • net_cull_distance_squared (float): [Read-Write] Square of the max distance from the client’s viewpoint that this actor is relevant and will be replicated.
  • net_dormancy (NetDormancy): [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
  • net_load_on_client (bool): [Read-Write] This actor will be loaded on network clients during map load
  • net_priority (float): [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
  • net_update_frequency (float): [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
  • net_use_owner_relevancy (bool): [Read-Write] If actor has valid Owner, call Owner’s IsNetRelevantFor and GetNetPriority
  • on_actor_begin_overlap (ActorBeginOverlapSignature): [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger. For events when objects have a blocking collision, for example a player hitting a wall, see ‘Hit’ events. Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.:
  • on_actor_end_overlap (ActorEndOverlapSignature): [Read-Write] Called when another actor stops overlapping this actor. Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.:
  • on_actor_hit (ActorHitSignature): [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with ‘sweep’ enabled, or physics simulation. For events when objects overlap (e.g. walking into a trigger) see the ‘Overlap’ event. For collisions during physics simulation to generate hit events, ‘Simulation Generates Hit Events’ must be enabled.:
  • on_begin_cursor_over (ActorBeginCursorOverSignature): [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
  • on_clicked (ActorOnClickedSignature): [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
  • on_destroyed (ActorDestroyedSignature): [Read-Write] Event triggered when the actor has been explicitly destroyed.
  • on_end_cursor_over (ActorEndCursorOverSignature): [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
  • on_end_play (ActorEndPlaySignature): [Read-Write] Event triggered when the actor is being deleted or removed from a level.
  • on_input_touch_begin (ActorOnInputTouchBeginSignature): [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
  • on_input_touch_end (ActorOnInputTouchEndSignature): [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
  • on_input_touch_enter (ActorBeginTouchOverSignature): [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
  • on_input_touch_leave (ActorEndTouchOverSignature): [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
  • on_released (ActorOnReleasedSignature): [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
  • on_take_any_damage (TakeAnyDamageSignature): [Read-Write] Called when the actor is damaged in any way.
  • on_take_point_damage (TakePointDamageSignature): [Read-Write] Called when the actor is damaged by point damage.
  • on_take_radial_damage (TakeRadialDamageSignature): [Read-Write] Called when the actor is damaged by radial damage.
  • only_relevant_to_owner (bool): [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
  • optimize_bp_component_data (bool): [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
  • pivot_offset (Vector): [Read-Write] Local space pivot offset for the actor, only used in the editor
  • primary_actor_tick (ActorTickFunction): [Read-Write] Primary Actor tick function, which calls TickActor(). Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies. https://docs.unrealengine.com/latest/INT/API/Runtime/Engine/Engine/FTickFunction/: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent():
  • relevant_for_level_bounds (bool): [Read-Write] If true, this actor’s component’s bounds will be included in the level’s bounding box unless the Actor’s class has overridden IsLevelBoundsRelevant
  • replay_rewindable (bool): [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed. Otherwise, RewindForReplay will be called if we detect the actor needs to be reset. Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
  • replicate_movement (bool): [Read-Write] If true, replicate movement/location related properties. Actor must also be set to replicate. SetReplicates(): https://docs.unrealengine.com/latest/INT/Gameplay/Networking/Replication/:
  • replicated_movement (RepMovement): [Read-Write] Used for replication of our RootComponent’s position and velocity
  • replicates (bool): [Read-Write] If true, this actor will replicate to remote machines SetReplicates():
  • root_component (SceneComponent): [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
  • spawn_collision_handling_method (SpawnActorCollisionHandlingMethod): [Read-Write] Controls how to handle spawning this actor in a situation where it’s colliding with something else. “Default” means AlwaysSpawn here.
  • sprite_scale (float): [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
  • tags (Array(Name)): [Read-Write] Array of tags that can be used for grouping and categorizing.
actor_has_tag(tag) → bool

See if this actor’s Tags array contains the supplied name tag

Parameters:tag (Name) –
Returns:
Return type:bool
add_actor_local_offset(delta_location, sweep, teleport) → HitResult

Adds a delta to the location of this component in its local reference frame.

Parameters:
  • delta_location (Vector) –
  • sweep (bool) – Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
  • teleport (bool) – Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume.
Returns:

sweep_hit_result (HitResult):

Return type:

HitResult

add_actor_local_rotation(delta_rotation, sweep, teleport) → HitResult

Adds a delta to the rotation of this component in its local reference frame

Parameters:
  • delta_rotation (Rotator) – The change in rotation in local space.
  • sweep (bool) – Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
  • teleport (bool) – Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume.
Returns:

sweep_hit_result (HitResult):

Return type:

HitResult

add_actor_local_transform(new_transform, sweep, teleport) → HitResult

Adds a delta to the transform of this component in its local reference frame

Parameters:
  • new_transform (Transform) – The change in transform in local space.
  • sweep (bool) – Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
  • teleport (bool) – Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume.
Returns:

sweep_hit_result (HitResult):

Return type:

HitResult

add_actor_world_offset(delta_location, sweep, teleport) → HitResult

Adds a delta to the location of this actor in world space.

Parameters:
  • delta_location (Vector) – The change in location.
  • sweep (bool) – Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
  • teleport (bool) – Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume.
Returns:

sweep_hit_result (HitResult): The hit result from the move if swept.

Return type:

HitResult

add_actor_world_rotation(delta_rotation, sweep, teleport) → HitResult

Adds a delta to the rotation of this actor in world space.

Parameters:
  • delta_rotation (Rotator) – The change in rotation.
  • sweep (bool) – Whether to sweep to the target rotation (not currently supported for rotation).
  • teleport (bool) – Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume.
Returns:

sweep_hit_result (HitResult): The hit result from the move if swept.

Return type:

HitResult

add_actor_world_transform(delta_transform, sweep, teleport) → HitResult

Adds a delta to the transform of this actor in world space. Scale is unchanged.

Parameters:
Returns:

sweep_hit_result (HitResult):

Return type:

HitResult

add_tick_prerequisite_actor(prerequisite_actor) → None

Make this actor tick after PrerequisiteActor. This only applies to this actor’s tick function; dependencies for owned components must be set up separately if desired.

Parameters:prerequisite_actor (Actor) –
add_tick_prerequisite_component(prerequisite_component) → None

Make this actor tick after PrerequisiteComponent. This only applies to this actor’s tick function; dependencies for owned components must be set up separately if desired.

Parameters:prerequisite_component (ActorComponent) –
always_relevant

(bool) – [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).

attach_to_actor(parent_actor, socket_name, location_rule, rotation_rule, scale_rule, weld_simulated_bodies) → None

Attaches the RootComponent of this Actor to the supplied component, optionally at a named socket. It is not valid to call this on components that are not Registered.

Parameters:
  • parent_actor (Actor) – Actor to attach this actor’s RootComponent to
  • socket_name (Name) – Socket name to attach to, if any
  • location_rule (AttachmentRule) – How to handle translation when attaching.
  • rotation_rule (AttachmentRule) – How to handle rotation when attaching.
  • scale_rule (AttachmentRule) – How to handle scale when attaching.
  • weld_simulated_bodies (bool) – Whether to weld together simulated physics bodies.
attach_to_component(parent, socket_name, location_rule, rotation_rule, scale_rule, weld_simulated_bodies) → None

Attaches the RootComponent of this Actor to the supplied component, optionally at a named socket. It is not valid to call this on components that are not Registered.

Parameters:
  • parent (SceneComponent) – Parent to attach to.
  • socket_name (Name) – Optional socket to attach to on the parent.
  • location_rule (AttachmentRule) – How to handle translation when attaching.
  • rotation_rule (AttachmentRule) – How to handle rotation when attaching.
  • scale_rule (AttachmentRule) – How to handle scale when attaching.
  • weld_simulated_bodies (bool) – Whether to weld together simulated physics bodies.
auto_destroy_when_finished

(bool) – [Read-Write] If true then destroy self when “finished”, meaning all relevant components report that they are done and no timelines or timers are in flight.

can_be_damaged

(bool) – [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called. https://www.unrealengine.com/blog/damage-in-ue4: TakeDamage(), ReceiveDamage():

custom_time_dilation

(float) – [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor’s tick.

destroy_actor() → None

Destroy the actor

destroy_component(component) → None

K2 Destroy Component deprecated: Use Component.DestroyComponent instead

Parameters:component (ActorComponent) –
detach_from_actor(location_rule=DetachmentRule.KEEP_RELATIVE, rotation_rule=DetachmentRule.KEEP_RELATIVE, scale_rule=DetachmentRule.KEEP_RELATIVE) → None

Detaches the RootComponent of this Actor from any SceneComponent it is currently attached to.

Parameters:
  • location_rule (DetachmentRule) – How to handle translation when detaching.
  • rotation_rule (DetachmentRule) – How to handle rotation when detaching.
  • scale_rule (DetachmentRule) – How to handle scale when detaching.
disable_input(player_controller) → None

Removes this actor from the stack of input being handled by a PlayerController.

Parameters:player_controller (PlayerController) – The PlayerController whose input events we no longer want to receive. If null, this actor will stop receiving input from all PlayerControllers.
enable_auto_lod_generation

(bool) – [Read-Write] If true, and if World setting has bEnableHierarchicalLOD equal to true, then it will generate LODActor from groups of clustered Actor

enable_input(player_controller) → None

Pushes this actor on to the stack of input being handled by a PlayerController.

Parameters:player_controller (PlayerController) – The PlayerController whose input events we want to receive.
find_camera_component_when_view_target

(bool) – [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.

flush_net_dormancy() → None

Forces dormant actor to replicate but doesn’t change NetDormancy state (i.e., they will go dormant again if left dormant)

force_net_update() → None

Force actor to be updated to clients/demo net drivers

generate_overlap_events_during_level_streaming

(bool) – [Read-Write] If true, this actor will generate overlap events when spawned as part of level streaming. You might enable this is in the case where a streaming level loads around an actor and you want overlaps to trigger.

get_actor_bounds(only_colliding_components) -> (origin=Vector, box_extent=Vector)

Returns the bounding box of all components that make up this Actor (excluding ChildActorComponents).

Parameters:only_colliding_components (bool) – If true, will only return the bounding box for components with collision enabled.
Returns:origin (Vector): Set to the center of the actor in world space

box_extent (Vector): Set to half the actor’s size in 3d space

Return type:tuple
get_actor_enable_collision() → bool

Get current state of collision for the whole actor

Returns:
Return type:bool
get_actor_eyes_view_point() -> (out_location=Vector, out_rotation=Rotator)

Returns the point of view of the actor. Note that this doesn’t mean the camera, but the ‘eyes’ of the actor. For example, for a Pawn, this would define the eye height location, and view rotation (which is different from the pawn rotation which has a zeroed pitch component). A camera first person view will typically use this view point. Most traces (weapon, AI) will be done from this view point.

Returns:out_location (Vector): location of view point

out_rotation (Rotator): view rotation of actor.

Return type:tuple
get_actor_forward_vector() → Vector

Get the forward (X) vector (length 1.0) from this Actor, in world space.

Returns:
Return type:Vector
get_actor_label() → str

Returns this actor’s current label. Actor labels are only available in development builds.

Returns:
Return type:str
get_actor_location() → Vector

Returns the location of the RootComponent of this Actor

Returns:
Return type:Vector
get_actor_relative_scale3d() → Vector

Return the actor’s relative scale 3d

Returns:
Return type:Vector
get_actor_right_vector() → Vector

Get the right (Y) vector (length 1.0) from this Actor, in world space.

Returns:
Return type:Vector
get_actor_rotation() → Rotator

Returns rotation of the RootComponent of this Actor.

Returns:
Return type:Rotator
get_actor_scale3d() → Vector

Returns the Actor’s world-space scale.

Returns:
Return type:Vector
get_actor_tick_interval() → float

Returns the tick interval of this actor’s primary tick function

Returns:
Return type:float
get_actor_time_dilation() → float

Get ActorTimeDilation - this can be used for input control or speed control for slomo. We don’t want to scale input globally because input can be used for UI, which do not care for TimeDilation.

Returns:
Return type:float
get_actor_transform() → Transform

Get the actor-to-world transform.

Returns:The transform that transforms from actor space to world space.
Return type:Transform
get_actor_up_vector() → Vector

Get the up (Z) vector (length 1.0) from this Actor, in world space.

Returns:
Return type:Vector
get_all_child_actors(include_descendants=True) -> Array(Actor)

Returns a list of all actors spawned by our Child Actor Components, including children of children. This does not return the contents of the Children array

Parameters:include_descendants (bool) –
Returns:child_actors (Array(Actor)):
Return type:Array(Actor)
get_attach_parent_actor() → Actor

Walk up the attachment chain from RootComponent until we encounter a different actor, and return it. If we are not attached to a component in a different actor, returns nullptr

Returns:
Return type:Actor
get_attach_parent_socket_name() → Name

Walk up the attachment chain from RootComponent until we encounter a different actor, and return the socket name in the component. If we are not attached to a component in a different actor, returns NAME_None

Returns:
Return type:Name
get_attached_actors() -> Array(Actor)

Find all Actors which are attached directly to a component in this actor

Returns:out_actors (Array(Actor)):
Return type:Array(Actor)
get_component_by_class(component_class) → ActorComponent

Searches components array and returns first encountered component of the specified class

Parameters:component_class (type(Class)) –
Returns:
Return type:ActorComponent
get_components_by_class(component_class) -> Array(ActorComponent)

Gets all the components that inherit from the given class. Currently returns an array of UActorComponent which must be cast to the correct type.

Parameters:component_class (type(Class)) –
Returns:
Return type:Array(ActorComponent)
get_components_by_tag(component_class, tag) -> Array(ActorComponent)

Gets all the components that inherit from the given class with a given tag.

Parameters:
Returns:

Return type:

Array(ActorComponent)

get_distance_to(other_actor) → float

Returns the distance from this Actor to OtherActor.

Parameters:other_actor (Actor) –
Returns:
Return type:float
get_dot_product_to(other_actor) → float

Returns the dot product from this Actor to OtherActor. Returns -2.0 on failure. Returns 0.0 for coincidental actors.

Parameters:other_actor (Actor) –
Returns:
Return type:float
get_folder_path() → Name

Returns this actor’s folder path. Actor folder paths are only available in development builds.

Returns:
Return type:Name
get_game_time_since_creation() → float

The number of seconds (in game time) since this Actor was created, relative to Get Game Time In Seconds.

Returns:
Return type:float
get_horizontal_distance_to(other_actor) → float

Returns the distance from this Actor to OtherActor, ignoring Z.

Parameters:other_actor (Actor) –
Returns:
Return type:float
get_horizontal_dot_product_to(other_actor) → float

Returns the dot product from this Actor to OtherActor, ignoring Z. Returns -2.0 on failure. Returns 0.0 for coincidental actors.

Parameters:other_actor (Actor) –
Returns:
Return type:float
get_instigator() → Pawn

Returns the instigator for this actor, or nullptr if there is none.

Returns:
Return type:Pawn
get_instigator_controller() → Controller

Returns the instigator’s controller for this actor, or nullptr if there is none.

Returns:
Return type:Controller
get_life_span() → float

Get the remaining lifespan of this actor. If zero is returned the actor lives forever.

Returns:
Return type:float
get_local_role() → NetRole

Returns how much control the local machine has over this actor.

Returns:
Return type:NetRole
get_overlapping_actors(class_filter=None) -> Array(Actor)

Returns list of actors this actor is overlapping (any component overlapping any component). Does not return itself.

Parameters:class_filter (type(Class)) – [optional] If set, only returns actors of this class or subclasses
Returns:overlapping_actors (Array(Actor)): [out] Returned list of overlapping actors
Return type:Array(Actor)
get_overlapping_components() -> Array(PrimitiveComponent)

Returns list of components this actor is overlapping.

Returns:overlapping_components (Array(PrimitiveComponent)):
Return type:Array(PrimitiveComponent)
get_owner() → Actor

Get the owner of this Actor, used primarily for network replication.

Returns:
Return type:Actor
get_parent_actor() → Actor

If this Actor was created by a Child Actor Component returns the Actor that owns that Child Actor Component

Returns:
Return type:Actor
get_parent_component() → ChildActorComponent

If this Actor was created by a Child Actor Component returns that Child Actor Component

Returns:
Return type:ChildActorComponent
get_remote_role() → NetRole

Returns how much control the remote machine has over this actor.

Returns:
Return type:NetRole
get_squared_distance_to(other_actor) → float

Returns the squared distance from this Actor to OtherActor.

Parameters:other_actor (Actor) –
Returns:
Return type:float
get_tickable_when_paused() → bool

Gets whether this actor can tick when paused.

Returns:
Return type:bool
get_touching_actors(class_filter=None)

deprecated: ‘get_touching_actors’ was renamed to ‘get_overlapping_actors’.

get_touching_components()

deprecated: ‘get_touching_components’ was renamed to ‘get_overlapping_components’.

get_velocity() → Vector

Returns velocity (in cm/s (Unreal Units/second) of the rootcomponent if it is either using physics or has an associated MovementComponent

Returns:
Return type:Vector
get_vertical_distance_to(other_actor) → float

Returns the distance from this Actor to OtherActor, ignoring XY.

Parameters:other_actor (Actor) –
Returns:
Return type:float
has_authority() → bool

Returns whether this actor has network authority

Returns:
Return type:bool
has_tag(tag)

deprecated: ‘has_tag’ was renamed to ‘actor_has_tag’.

hidden

(bool) – [Read-Only] Allows us to only see this Actor in the Editor, and not in the actual game. SetActorHiddenInGame():

initial_life_span

(float) – [Read-Only] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.

instigator

(Pawn) – [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.

is_actor_being_destroyed() → bool

Returns true if this actor is currently being destroyed, some gameplay events may be unsafe

Returns:
Return type:bool
is_actor_tick_enabled() → bool

Returns whether this actor has tick enabled or not

Returns:
Return type:bool
is_child_actor() → bool

Returns whether this Actor was spawned by a child actor component

Returns:
Return type:bool
is_editable() → bool

Returns true if this actor is allowed to be displayed, selected and manipulated by the editor.

Returns:
Return type:bool
is_hidden_ed() → bool

Returns true if this actor is hidden in the editor viewports, also checking temporary flags.

Returns:
Return type:bool
is_hidden_ed_at_startup() → bool

Returns true if the actor is hidden upon editor startup/by default, false if it is not

Returns:
Return type:bool
is_overlapping_actor(other) → bool

Check whether any component of this Actor is overlapping any component of another Actor.

Parameters:other (Actor) – The other Actor to test against
Returns:Whether any component of this Actor is overlapping any component of another Actor.
Return type:bool
is_selectable() → bool

Returns true if this actor can EVER be selected in a level in the editor. Can be overridden by specific actors to make them unselectable.

Returns:
Return type:bool
is_temporarily_hidden_in_editor(include_parent=False) → bool

Returns whether or not this actor was explicitly hidden in the editor for the duration of the current editor session

Parameters:include_parent (bool) – Whether to recurse up child actor hierarchy or not
Returns:
Return type:bool
life_span

deprecated – ‘life_span’ was renamed to ‘initial_life_span’.

make_mid_for_material(parent) → MaterialInstanceDynamic

Make MIDFor Material deprecated: Use PrimitiveComponent.CreateAndSetMaterialInstanceDynamic instead.

Parameters:parent (MaterialInterface) –
Returns:
Return type:MaterialInstanceDynamic
make_noise(loudness=1.000000, noise_instigator=None, noise_location=[0.000000, 0.000000, 0.000000], max_range=0.000000, tag="None") → None

Trigger a noise caused by a given Pawn, at a given location. Note that the NoiseInstigator Pawn MUST have a PawnNoiseEmitterComponent for the noise to be detected by a PawnSensingComponent. Senders of MakeNoise should have an Instigator if they are not pawns, or pass a NoiseInstigator.

Parameters:
  • loudness (float) – The relative loudness of this noise. Usual range is 0 (no noise) to 1 (full volume). If MaxRange is used, this scales the max range, otherwise it affects the hearing range specified by the sensor.
  • noise_instigator (Pawn) – Pawn responsible for this noise. Uses the actor’s Instigator if NoiseInstigator is null
  • noise_location (Vector) – Position of noise source. If zero vector, use the actor’s location.
  • max_range (float) – Max range at which the sound may be heard. A value of 0 indicates no max range (though perception may have its own range). Loudness scales the range. (Note: not supported for legacy PawnSensingComponent, only for AIPerception)
  • tag (Name) – Identifier for the noise.
min_net_update_frequency

(float) – [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently

net_cull_distance_squared

(float) – [Read-Only] Square of the max distance from the client’s viewpoint that this actor is relevant and will be replicated.

net_dormancy

(NetDormancy) – [Read-Only] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.

net_priority

(float) – [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate

net_update_frequency

(float) – [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime

net_use_owner_relevancy

(bool) – [Read-Write] If actor has valid Owner, call Owner’s IsNetRelevantFor and GetNetPriority

on_actor_begin_overlap

(ActorBeginOverlapSignature) – [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger. For events when objects have a blocking collision, for example a player hitting a wall, see ‘Hit’ events. Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.:

on_actor_end_overlap

(ActorEndOverlapSignature) – [Read-Write] Called when another actor stops overlapping this actor. Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.:

on_actor_hit

(ActorHitSignature) – [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with ‘sweep’ enabled, or physics simulation. For events when objects overlap (e.g. walking into a trigger) see the ‘Overlap’ event. For collisions during physics simulation to generate hit events, ‘Simulation Generates Hit Events’ must be enabled.:

on_actor_touch

deprecated – ‘on_actor_touch’ was renamed to ‘on_actor_begin_overlap’.

on_actor_un_touch

deprecated – ‘on_actor_un_touch’ was renamed to ‘on_actor_end_overlap’.

on_become_view_target(pc) → None

Event called when this Actor becomes the view target for the given PlayerController.

Parameters:pc (PlayerController) –
on_begin_cursor_over

(ActorBeginCursorOverSignature) – [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.

on_clicked

(ActorOnClickedSignature) – [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.

on_destroyed

(ActorDestroyedSignature) – [Read-Write] Event triggered when the actor has been explicitly destroyed.

on_end_cursor_over

(ActorEndCursorOverSignature) – [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.

on_end_play

(ActorEndPlaySignature) – [Read-Write] Event triggered when the actor is being deleted or removed from a level.

on_end_view_target(pc) → None

Event called when this Actor is no longer the view target for the given PlayerController.

Parameters:pc (PlayerController) –
on_input_touch_begin

(ActorOnInputTouchBeginSignature) – [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.

on_input_touch_end

(ActorOnInputTouchEndSignature) – [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.

on_input_touch_enter

(ActorBeginTouchOverSignature) – [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.

on_input_touch_leave

(ActorEndTouchOverSignature) – [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.

on_released

(ActorOnReleasedSignature) – [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.

on_reset() → None

Event called when this Actor is reset to its initial state - used when restarting level without reloading.

on_take_any_damage

(TakeAnyDamageSignature) – [Read-Write] Called when the actor is damaged in any way.

on_take_point_damage

(TakePointDamageSignature) – [Read-Write] Called when the actor is damaged by point damage.

on_take_radial_damage

(TakeRadialDamageSignature) – [Read-Write] Called when the actor is damaged by radial damage.

only_relevant_to_owner

(bool) – [Read-Only] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.

pivot_offset

(Vector) – [Read-Only] Local space pivot offset for the actor, only used in the editor

prestream_textures(seconds, enable_streaming, cinematic_texture_groups=0) → None

Calls PrestreamTextures() for all the actor’s meshcomponents.

Parameters:
  • seconds (float) – Number of seconds to force all mip-levels to be resident
  • enable_streaming (bool) – Whether to start (true) or stop (false) streaming
  • cinematic_texture_groups (int32) – Bitfield indicating which texture groups that use extra high-resolution mips
receive_actor_begin_cursor_over() → None

Event when this actor has the mouse moved over it with the clickable interface.

receive_actor_begin_overlap(other_actor) → None

Event when this actor overlaps another actor, for example a player walking into a trigger. For events when objects have a blocking collision, for example a player hitting a wall, see ‘Hit’ events. Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.:

Parameters:other_actor (Actor) –
receive_actor_end_cursor_over() → None

Event when this actor has the mouse moved off of it with the clickable interface.

receive_actor_end_overlap(other_actor) → None

Event when an actor no longer overlaps another actor, and they have separated. Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.:

Parameters:other_actor (Actor) –
receive_actor_on_clicked(button_pressed) → None

Event when this actor is clicked by the mouse when using the clickable interface.

Parameters:button_pressed (Key) –
receive_actor_on_input_touch_begin(finger_index) → None

Event when this actor is touched when click events are enabled.

Parameters:finger_index (TouchIndex) –
receive_actor_on_input_touch_end(finger_index) → None

Event when this actor is under the finger when untouched when click events are enabled.

Parameters:finger_index (TouchIndex) –
receive_actor_on_input_touch_enter(finger_index) → None

Event when this actor has a finger moved over it with the clickable interface.

Parameters:finger_index (TouchIndex) –
receive_actor_on_input_touch_leave(finger_index) → None

Event when this actor has a finger moved off of it with the clickable interface.

Parameters:finger_index (TouchIndex) –
receive_actor_on_released(button_released) → None

Event when this actor is under the mouse when left mouse button is released while using the clickable interface.

Parameters:button_released (Key) –
receive_actor_touch(other_actor)

deprecated: ‘receive_actor_touch’ was renamed to ‘receive_actor_begin_overlap’.

receive_actor_untouch(other_actor)

deprecated: ‘receive_actor_untouch’ was renamed to ‘receive_actor_end_overlap’.

receive_any_damage(damage, damage_type, instigated_by, damage_causer) → None

Event when this actor takes ANY damage

Parameters:
receive_begin_play() → None

Event when play begins for this actor.

receive_destroyed() → None

Called when the actor has been explicitly destroyed.

receive_end_play(end_play_reason) → None

Event to notify blueprints this actor is being deleted or removed from a level.

Parameters:end_play_reason (EndPlayReason) –
receive_hit(my_comp, other, other_comp, self_moved, hit_location, hit_normal, normal_impulse, hit) → None

Event when this actor bumps into a blocking object, or blocks another actor that bumps into it. This could happen due to things like Character movement, using Set Location with ‘sweep’ enabled, or physics simulation. For events when objects overlap (e.g. walking into a trigger) see the ‘Overlap’ event. For collisions during physics simulation to generate hit events, ‘Simulation Generates Hit Events’ must be enabled.: When receiving a hit from another object’s movement (bSelfMoved is false), the directions of ‘Hit.Normal’ and ‘Hit.ImpactNormal’ will be adjusted to indicate force from the other object against this object.: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.:

Parameters:
receive_point_damage(damage, damage_type, hit_location, hit_normal, hit_component, bone_name, shot_from_direction, instigated_by, damage_causer, hit_info) → None

Event when this actor takes POINT damage

Parameters:
receive_radial_damage(damage_received, damage_type, origin, hit_info, instigated_by, damage_causer) → None

Event when this actor takes RADIAL damage

Parameters:
receive_tick(delta_seconds) → None

Event called every frame, if ticking is enabled

Parameters:delta_seconds (float) –
remove_tick_prerequisite_actor(prerequisite_actor) → None

Remove tick dependency on PrerequisiteActor.

Parameters:prerequisite_actor (Actor) –
remove_tick_prerequisite_component(prerequisite_component) → None

Remove tick dependency on PrerequisiteComponent.

Parameters:prerequisite_component (ActorComponent) –
replicates

(bool) – [Read-Only] If true, this actor will replicate to remote machines SetReplicates():

root_component

(SceneComponent) – [Read-Only] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow

set_actor_enable_collision(new_actor_enable_collision) → None

Allows enabling/disabling collision for the whole actor

Parameters:new_actor_enable_collision (bool) –
set_actor_hidden(new_hidden)

deprecated: ‘set_actor_hidden’ was renamed to ‘set_actor_hidden_in_game’.

set_actor_hidden_in_game(new_hidden) → None

Sets the actor to be hidden in the game

Parameters:new_hidden (bool) – Whether or not to hide the actor and all its components
set_actor_label(new_actor_label, mark_dirty=True) → None

Assigns a new label to this actor. Actor labels are only available in development builds.

Parameters:
  • new_actor_label (str) – The new label string to assign to the actor. If empty, the actor will have a default label.
  • mark_dirty (bool) – If true the actor’s package will be marked dirty for saving. Otherwise it will not be. You should pass false for this parameter if dirtying is not allowed (like during loads)
set_actor_location(new_location, sweep, teleport) → HitResult or None

Move the Actor to the specified location.

Parameters:
  • new_location (Vector) – The new location to move the Actor to.
  • sweep (bool) – Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
  • teleport (bool) – Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume.
Returns:

Whether the location was successfully set (if not swept), or whether movement occurred at all (if swept).

sweep_hit_result (HitResult): The hit result from the move if swept.

Return type:

HitResult or None

set_actor_location_and_rotation(new_location, new_rotation, sweep, teleport) → HitResult or None

Move the actor instantly to the specified location and rotation.

Parameters:
  • new_location (Vector) – The new location to teleport the Actor to.
  • new_rotation (Rotator) – The new rotation for the Actor.
  • sweep (bool) – Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
  • teleport (bool) – Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume.
Returns:

Whether the rotation was successfully set.

sweep_hit_result (HitResult): The hit result from the move if swept.

Return type:

HitResult or None

set_actor_relative_location(new_relative_location, sweep, teleport) → HitResult

Set the actor’s RootComponent to the specified relative location.

Parameters:
  • new_relative_location (Vector) – New relative location of the actor’s root component
  • sweep (bool) – Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
  • teleport (bool) – Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume.
Returns:

sweep_hit_result (HitResult):

Return type:

HitResult

set_actor_relative_rotation(new_relative_rotation, sweep, teleport) → HitResult

Set the actor’s RootComponent to the specified relative rotation

Parameters:
  • new_relative_rotation (Rotator) – New relative rotation of the actor’s root component
  • sweep (bool) – Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
  • teleport (bool) – Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume.
Returns:

sweep_hit_result (HitResult):

Return type:

HitResult

set_actor_relative_scale3d(new_relative_scale) → None

Set the actor’s RootComponent to the specified relative scale 3d

Parameters:new_relative_scale (Vector) – New scale to set the actor’s RootComponent to
set_actor_relative_transform(new_relative_transform, sweep, teleport) → HitResult

Set the actor’s RootComponent to the specified relative transform

Parameters:
  • new_relative_transform (Transform) – New relative transform of the actor’s root component
  • sweep (bool) – Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
  • teleport (bool) – Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume.
Returns:

sweep_hit_result (HitResult):

Return type:

HitResult

set_actor_rotation(new_rotation, teleport_physics) → bool

Set the Actor’s rotation instantly to the specified rotation.

Parameters:
  • new_rotation (Rotator) – The new rotation for the Actor.
  • teleport_physics (bool) – Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts).
Returns:

Whether the rotation was successfully set.

Return type:

bool

set_actor_scale3d(new_scale3d) → None

Set the Actor’s world-space scale.

Parameters:new_scale3d (Vector) –
set_actor_tick_enabled(enabled) → None

Set this actor’s tick functions to be enabled or disabled. Only has an effect if the function is registered This only modifies the tick function on actor itself

Parameters:enabled (bool) – Whether it should be enabled or not
set_actor_tick_interval(tick_interval) → None

Sets the tick interval of this actor’s primary tick function. Will not enable a disabled tick function. Takes effect on next tick.

Parameters:tick_interval (float) – The rate at which this actor should be ticking
set_actor_transform(new_transform, sweep, teleport) → HitResult or None

Set the Actors transform to the specified one.

Parameters:
  • new_transform (Transform) – The new transform.
  • sweep (bool) – Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
  • teleport (bool) – Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume.
Returns:

sweep_hit_result (HitResult):

Return type:

HitResult or None

set_folder_path(new_folder_path) → None

Assigns a new folder to this actor. Actor folder paths are only available in development builds.

Parameters:new_folder_path (Name) – The new folder to assign to the actor.
set_is_temporarily_hidden_in_editor(is_hidden) → None

Explicitly sets whether or not this actor is hidden in the editor for the duration of the current editor session

Parameters:is_hidden (bool) – True if the actor is hidden
set_life_span(lifespan) → None

Set the lifespan of this actor. When it expires the object will be destroyed. If requested lifespan is 0, the timer is cleared and the actor will not be destroyed.

Parameters:lifespan (float) –
set_net_dormancy(new_dormancy) → None

Puts actor in dormant networking state

Parameters:new_dormancy (NetDormancy) –
set_owner(new_owner) → None

Set the owner of this Actor, used primarily for network replication.

Parameters:new_owner (Actor) – The Actor whom takes over ownership of this Actor
set_replicate_movement(replicate_movement) → None

Set whether this actor’s movement replicates to network clients.

Parameters:replicate_movement (bool) – Whether this Actor’s movement replicates to clients.
set_replicates(replicates) → None

Set whether this actor replicates to network clients. When this actor is spawned on the server it will be sent to clients as well. Properties flagged for replication will update on clients if they change on the server. Internally changes the RemoteRole property and handles the cases where the actor needs to be added to the network actor list. https://docs.unrealengine.com/latest/INT/Gameplay/Networking/Replication/:

Parameters:replicates (bool) – Whether this Actor replicates to network clients.
set_tick_enabled(enabled)

deprecated: ‘set_tick_enabled’ was renamed to ‘set_actor_tick_enabled’.

set_tick_group(new_tick_group) → None

Sets the ticking group for this actor.

Parameters:new_tick_group (TickingGroup) – the new value to assign
set_tick_prerequisite(prerequisite_actor)

deprecated: ‘set_tick_prerequisite’ was renamed to ‘add_tick_prerequisite_actor’.

set_tickable_when_paused(tickable_when_paused) → None

Sets whether this actor can tick when paused.

Parameters:tickable_when_paused (bool) –
spawn_collision_handling_method

(SpawnActorCollisionHandlingMethod) – [Read-Write] Controls how to handle spawning this actor in a situation where it’s colliding with something else. “Default” means AlwaysSpawn here.

sprite_scale

(float) – [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).

tags

(Array(Name)) – [Read-Write] Array of tags that can be used for grouping and categorizing.

tear_off() → None

Networking - Server - TearOff this actor to stop replication to clients. Will set bTearOff to true.

teleport(dest_location, dest_rotation) → bool

Teleport this actor to a new location. If the actor doesn’t fit exactly at the location specified, tries to slightly move it out of walls and such.

Parameters:
  • dest_location (Vector) – The target destination point
  • dest_rotation (Rotator) – The target rotation at the destination
Returns:

true if the actor has been successfully moved, or false if it couldn’t fit.

Return type:

bool

was_recently_rendered(tolerance=0.200000) → bool

Returns true if this actor has been rendered “recently”, with a tolerance in seconds to define what “recent” means. e.g.: If a tolerance of 0.1 is used, this function will return true only if the actor was rendered in the last 0.1 seconds of game time.

Parameters:tolerance (float) – How many seconds ago the actor last render time can be and still count as having been “recently” rendered.
Returns:Whether this actor was recently rendered.
Return type:bool