Legacy:Land Of The Dead/Actor - Unreal Wiki

# Legacy:Land Of The Dead/Actor

### From Unreal Wiki, The Unreal Engine Documentation Site

< Legacy:Land Of The Dead
Land of the Dead :: Object >> Actor

## Constants

MAXSTEPHEIGHT = 35.0
  Maximum step height walkable by Pawns

MINFLOORZ = 0.7
  Minimum Z value for floor normal. Anything that's less, isn't a walkable floor. (0.7 corresponds to about 45 degree angle for floor)

## Properties

vector Acceleration
  Actor's movement acceleration

ActorRenderDataPtr ActorRenderData

array<Actor> Attached
  Array of actors attached to this actor.

name AttachmentBone
  Name of bone to which actor is attached

bool bAlwaysRelevant
  When true, this Actor will be Always relevant for network.

bool bAlwaysTick
  Update even when players-only is turned on.

bool bAlwaysZeroBoneOffset
  If true, offset always zero when attached to skeletalmesh.

bool bAnimByOwner
  Animation dictated by owner.

Actor Base
  Actor we're standing on, or attached to with SetBase

bool bCanBeDamaged
  Can take damage. (this doesn't seem to be used much, a lot of actors implement their own Can Damage functions)

bool bClientAnim
  Don't replicate any animations - animation done client-side.

bool bClientDemoNetFunc
  True if we're client-side demo recording and this call originated from the remote.

bool bClientDemoRecording
  True if we are currently recording a client-side demo.

bool bCompressedPosition
  Used by networking code to flag compressed position replication.

bool bDeleteMe
  This is set true for items that have had Destroy() called, but are not completely destroyed yet.

bool bDemoOwner
  Demo recording driver owns this actor.

bool bDemoRecording
  True we are currently demo recording.

bool bDestroyInPainVolume
  Destroy this actor if it enters a pain volume.

bool bDisturbFluidSurface
  Cause ripples when in contact with FluidSurface.

bool bEdSnap
  Should snap to grid in UnrealEd.

bool bHurtEntry
  This is a hack to keep HurtRadius from being reentrant, Epic probably should've used singular here, but I'm guessing singular didn't exist when they wrote that code.

bool bIgnoreOutOfWorld
  Don't destroy if enters zone zero.

bool bInterpolating
  Performing interpolating.

bool bJustTeleported
  Used by engine physics - not valid for scripts.

bool bLightChanged
  Set by the Editor to determine if this actor's lighting properties have been changed (for Build Changed Lighting)

bool bNetDirty
  Set true when any replicated variable is set in Unrealscript, mostly used in Replication block conditions

bool bNetInitial
  True for the initial network update.

bool bNetInitialRotation
  Should replicate initial rotation.

bool bNetNotify
  The actor wishes to be notified of replication events. The actor gets the simulated function PostNetReceive() called whenever replication occurs, e.g. in Ammunition whenever AmmoAmount gets changed.

bool bNetOwner
  Player owns this actor. (Used mainly in replication blocks)

bool bNetRelevant
  Actor is currently relevant. Only valid server side, only when replicating variables.

bool bNetTemporary
  Tear-off simulation in network play.

bool bNoRepMesh
  Don't replicate mesh.

bool bObsolete
  Actor is obsolete - warn level designers to remove it.

bool bOnlyAffectPawns
  Optimisation - only test ovelap against pawns. Used for influences etc.

bool bOnlyDirtyReplication
  If true, only replicate actor if `bNetDirty` is true - useful if no C++ changed attributes (such as physics)

bool bOnlyDrawIfAttached
  Don't draw this actor if not attached (useful for net clients where attached actors and their bases' replication may not be synched).

bool bOnlyOwnerSee
  Only owner can see this actor.

bool bOnlyRelevantToOwner
  This actor is only relevant to its owner.

bool bOrientOnSlope
  When landing, orient base on slope of floor.

bool bOwnerNoSee
  Everything but the owner can see this actor.

bool bPathTemp
  Internal/path building.

bool bPendingDelete
  Set when actor is about to be deleted (since endstate and other functions called during deletion process before `bDeleteMe` is set).

bool bRepClientDemo
  True if remote client is recording demo.

bool bReplicateAnimations
  Should replicate SimAnim.

bool bReplicateInstigator
  Replicate instigator to client (used by bNetTemporary projectiles).

bool bReplicateMovement
  If true, replicate movement/location related properties.

model Brush
  Brush if `DrawType=DT_Brush`.

bool bScriptInitialized
  Set to prevent re-initializing of actors spawned during level startup

bool bSelected
  Selected in UnrealEd.

bool bShowOctreeNodes

bool bSkipActorPropertyReplication
  If true, don't replicate actor class variables for this actor.

bool bTearOff
  If true, this actor is no longer replicated to new clients, and is "torn off" (becomes a `ROLE_Authority`) on clients to which it was being replicated.

bool bTempEditor

bool bTicked
  Actor has been updated.

bool bTimerLoop
  Timer loops (else is one-shot).

bool bTrailerAllowRotation
  If `PHYS_Trailer` and want independent rotation control.

bool bTrailerPrePivot
  If `PHYS_Trailer` and true, offset from owner by `PrePivot`.

bool bTrailerSameRotation
  If `PHYS_Trailer` and true, have same rotation as owner.

bool bTravel
  Actor is capable of travelling among servers.

bool bUpdateSimulatedPosition
  f true, update velocity/location after initialization for simulated proxies.

bool bWasSNFiltered
  Mainly for debugging - the way this actor was inserted into Octree.

bool bWorldGeometry
  Collision and Physics treats this actor as world geometry.

Matrix CachedLocalToWorld

vector CachedLocation

Rotator CachedRotation

int CollisionTag

vector ColLocation
  Actor's old location one move ago. Only for debugging.

actor Deleted
  Next actor in just-deleted chain.

Matrix HardRelMatrix
  Transform of actor in base's ref frame. Doesn't change after SetBase.

Pawn Instigator
  Pawn responsible for damage caused by this actor.

Inventory Inventory
  Inventory chain.

int JoinedTag

int KStepTag

float LastRenderTime
  Last time this actor was rendered.

float LatentFloat
  Internal latent function use.

array<int> Leaves
  BSP leaves this actor is in.

LevelInfo Level
  Level this actor is on.

LightRenderDataPtr LightRenderData

MeshInstance MeshInstance
  Mesh instance.

class<LocalMessage> MessageClass

array<timerStruct> MultiTimers
  Used internally by the Land of the Dead SetMultiTimer() native function

float NetPriority
  Higher priorities means update it more frequently.

int NetTag

float NetUpdateFrequency
  How many net updates per seconds.

float NetUpdateTime
  Time of last update

Box OctreeBox
  Actor bounding box cached when added to Octree. Internal use only.

vector OctreeBoxCenter

vector OctreeBoxRadii

array<int> OctreeNodes
  Array of nodes of the octree Actor is currently in. Internal use only.

Actor Owner
  Owner actor, usually set in Spawn()

Actor PendingTouch
  Actor touched during move which wants to add an effect after the movement completes.

PhysicsVolume PhysicsVolume
  physics volume this actor is currently in.

array<ProjectorRenderInfoPtr> Projectors
  Projected textures on this actor.

PointRegion Region
  Region this actor is in.

vector RelativeLocation
  Location relative to base/bone (valid if base exists).

rotator RelativeRotation
  Rotation relative to base/bone (valid if base exists)

ENetRole RemoteRole
  Default Replication role

int RenderRevision

Material RepSkin
  Replicated skin, covers all material slots, as far as I can tell

ENetRole Role
  Net Role used in Replication

AnimRep SimAnim
  Only replicated if `bReplicateAnimations` is true

EFilterState StaticFilterState

StaticMeshInstance StaticMeshInstance
  Contains per-instance static mesh data, like static lighting data.

array<StaticMeshProjectorRenderInfoPtr> StaticMeshProjectors

array<BatchReference> StaticSectionBatches

float TimerCounter
  Counts up until it reaches TimerRate.

float TimerRate
  Timer event, 0=no timer.

array<Actor> Touching
  List of touching actors.

Level XLevel
  Level object.

### Actionable

string ActionableMessage
  A message to display to a player when near the object

int iActionablePriority
  Priority if near several Actionable objects

int iActionableRadius
  Radius to be Actionable within

### Advanced

bool bCanTeleport
  This actor can be teleported. This property must be True for Teleporters to notice the actor.

bool bCollideWhenPlacing
  The actor will collide with world geometry when placed.

bool bDirectional
  Whether the editor should display an arrow to show the actor's current rotation. This has no effect in the game.

bool bEdShouldSnap
  Snap to grid in the editor.

bool bGameRelevant
  Mutators will not receive CheckReplacement and AlwaysKeep calls for the actor if this property is True.

bool bHidden
  Specifies, whether the actor is invisible in the game. This property has no effect in the editor.

bool bHiddenEd
  The actor is hidden in the editor. This has no effect in the game.

bool bHiddenEdGroup
  The actor is hidden in the Group Browser. This has no effect in the editor viewports or in the game.

bool bHighDetail
  The actor only shows up in high or super high detail mode.

bool bLockLocation
  Prevent the actor from being moved in the editor.

bool bMovable
  Actor can be moved.

bool bNoDelete
  Specifies, that the actor can't be spawned or destroyed during the game.

bool bShouldBaseAtStartup
  The actor tries to find another actor for its Base at level startup if its Physics property is set to either PHYS_None or PHYS_Rotating.

bool bStasis
  In standalone (i.e. single player, e.g. Instant Action) games this actor should be turned off if it's not in a recently rendered zone. It will only be turned off when its Physics mode is PHYS_None or PHYS_Rotating.

bool bSuperHighDetail
  The actor only shows up in super high detail mode.

float LifeSpan
  Specifies how long the actor will exist. This value is constantly decreased and the actor will be destroyed when it reaches 0. In this case the actor's Expired method is executed. An initial LifeSpan of 0 or explicitely setting the LifeSpan to 0 from UnrealScript disables the actor's "destruction timer". Setting it to a value greater 0 from UnrealScript enables it and the Actor will be destroyed after that time unless LifeSpan is set to 0 again before it expired.

### BreakNetPlay

bool bStatic
  Does not move or change over time. Don't let L.D.s change this - screws up net play.

### Collision

bool bAutoAlignToTerrain
  Auto-align to terrain in the editor.

bool bBlockActors
  Blocks other nonplayer actors.

bool bBlockKarma
  Block actors being simulated with Karma.

bool bBlockNonZeroExtentTraces
  Block non-zero extent actors/traces.

bool bBlockPlayers
  The comment for this says "OBSOLETE - no longer used", but it seems to be quite required if you want something to block player movement. Anyone have ideas?

bool bBlockZeroExtentTraces
  Block zero extent actors/traces, such as normal bullet fire, and any regular Trace() calls

bool bCollideActors
  Collides with other actors.

bool bCollideWorld
  Collides with the world.

bool bPathColliding
  This actor should collide (if `bWorldGeometry && bBlockActors` is true) during path building (ignored if `bStatic` is true, as actor will always collide during path building).

bool bProjTarget
  Projectiles will Explode() when touching an actor with bProjTarget = True

bool bUseCylinderCollision
  Force axis aligned cylinder collision (useful for static mesh pickups, etc.).

float CollisionHeight
  Half-height cyllinder.

float CollisionRadius
  Radius of collision cyllinder.

### Display

byte AmbientGlow
  Ambient brightness, or 255=pulsing.

EricBlade: Pulsing? Anyone ever see that?

ConvexVolume AntiPortal
  Convex volume used for DT_AntiPortal.

bool bAcceptsProjectors
  Projectors can project onto this actor.

bool bDisableSorting
  Manual override for translucent material sorting.

bool bShadowCast
  Used in the editor to determine if this actor should be considered when drawing shadows

bool bStaticLighting
  Uses raytraced lighting.

bool bUnlit
  Lights don't affect actor, it will be displayed at it's full brightness.

bool bUseDynamicLights
  If true, Dynamic lights will shine on this actor

bool bUseLightingFromBase
  Use Unlit/AmbientGlow from Base.

float CullDistance
  0=no distance cull, < 0 only drawn at distance > 0 cull at distance.

float DrawScale
  Scaling factor, 1.0=normal size.

vector DrawScale3D
  Scaling vector, `(1.0,1.0,1.0)`=normal size. Use negative numbers to mirror the actor along the axis that is negative. NOTE: In most actors, DrawScale3D is NOT replicated, so it's pretty much useless in net play!

EDrawType DrawType
  Internal enum representing what type of thing to display here, Mesh, StaticMesh, etc

name ForcedVisibilityZoneTag
  Makes the visibility code treat the actor as if it was in the zone with the given tag.

float LODBias

byte MaxLights
  Limit to hardware lights active on this primitive.

mesh Mesh
  Mesh if `DrawType=DT_Mesh`.

vector PrePivot
  Offset from box center for drawing.

float ScaleGlow
  Similar to AmbientGlow, not quite sure how it differs

array<Material> Skins
  Multiple skin support - not replicated. Overrides the default materials of a mesh or static mesh

StaticMesh StaticMesh
  StaticMesh if `DrawType=DT_StaticMesh`

ERenderStyle Style
  Style for rendering sprites, meshes.

Material Texture
  Sprite texture. If `DrawType=DT_Sprite`

### Events

bool bHasHandlers
  If this is set, TriggerEx() will be called to handle events, to deal with LOTD's custom multi-event system

name Event
  The event this actor causes.

array<EventHandlerMapping> EventBindings
  Used to create a list of Events that this actor will respond to, used in conjunction with bHasHandlers

name Tag
  Actor's tag name.

### Force

float ForceRadius
  Radius that forces are applied to Emitters that have Forces enabled

float ForceScale
  Scale to apply to forces

EForceType ForceType
  Type of force to apply to particles that are force enabled

### Karma

KarmaParamsCollision KParams
  Parameters for Karma Collision/Dynamics.

### LightColor

float LightBrightness
  Brightness of light this actor is to emit

byte LightHue
  Hue for light this actor is to emit

byte LightSaturation
  Saturation for light this actor is to emit

### Lighting

bool bActorShadows
  Light casts actor shadows.

bool bCorona
  Light uses Skin[0] as a corona.

bool bDynamicLight
  This light is dynamic.

bool bLightingVisibility
  Calculate lighting visibility for this actor with line checks.

bool bSpecialLit
  Only affects special-lit surfaces.

byte LightCone
  Used with LT_SpotLight effect to determine the size of the spot cone

ELightEffect LightEffect

byte LightPeriod
  Used with some of the dynamic LightEffects

byte LightPhase
  Used with some of the dynamic LightEffects

float LightRadius
  Radius for lights to affect, note this has nothing to do with Unreal units, or any other known direct measurement.

ELightType LightType

### Movement

name AttachTag
  Attach this actor's movement to the mover with the specified Tag set - note that LOTD suffers from an apparent engine bug that makes this a real bear to get working in netplay.

bool bBounce
  Bounces when hits ground fast.

bool bFixedRotationDir
  Fixed direction of rotation.

bool bHardAttach
  Uses 'hard' attachment code. `bBlockActor` and `bBlockPlayer` must also be false.
  This actor cannot then move relative to base (setlocation etc.).

bool bIgnoreEncroachers
  Ignore collisions between movers and this actor.

bool bRotateToDesired
  Rotate to DesiredRotation.

float Buoyancy
  Water buoyancy.

rotator DesiredRotation
  Physics will smoothly rotate actor to this rotation if `bRotateToDesired`.

vector Location
  Actor's location; use SetLocation() to set.

float Mass
  Mass of this actor.

EPhysics Physics
  The type of Physics in use for this actor

rotator Rotation
  Actor's rotation

rotator RotationRate
  Change in rotation per second.

vector Velocity
  Actor's velocity

### Object

int DebugFlags

name Group
  The Group this actor is in within the Editor

name InitialState
  Initial code state to start in

### Sound

sound AmbientSound
  Ambient sound effect.

bool bFullVolume
  Whether to apply ambient attenuation.

ESoundOcclusion SoundOcclusion
  Sound occlusion approach.

byte SoundPitch
  Sound pitch shift, 64.0=none.

float SoundRadius
  Radius of ambient sound. (It will be audible out to SoundRadius * 100 UU from this actor)

byte SoundVolume
  Volume of ambient sound.

float TransientSoundRadius
  Default sound radius for regular sounds (can be overridden in playsound).

float TransientSoundVolume
  Default sound volume for regular sounds (can be overridden in playsound).

## Enums

### EDetailMode

DM_Low
  Low detail mode
DM_High
  High detail mode
DM_SuperHigh
  Super High detail mode

### EDoubleClickDir

Double click move direction.
Used to remember the dodging state of a player. This will be reset to DCLICK_None when the player lands.
These are not used in LOTD.

DCLICK_None
  No dodging move started.
DCLICK_Active
  In dodging move.
DCLICK_Done
  Dodging move done.
  DCLICK_None
  DCLICK_Left
  DCLICK_Right
  DCLICK_Forward
  DCLICK_Back
  DCLICK_Active
  DCLICK_Done

  ### EDrawType

  The DrawType enumneration sets how the actor displays. Some of these options work with another property to set what is displayed.

  DT_None
    The actor isn't displayed at all. `bHidden` instead in most cases because it will allow the actor to still show up in UnrealEd.
  DT_Sprite
    Display a sprite with the material set in the Texture property.
  DT_Mesh
    Display the mesh set in the Mesh property.
  DT_Brush
    Only for Brush classes.
  DT_RopeSprite
  DT_VerticalSprite
  DT_Terraform
  DT_SpriteAnimOnce
    Like DT_Sprite, but plays an animated texture's animation at a speed that plays the animation exactly once during the LifeSpan of the actor.
  DT_StaticMesh
    Display the static mesh set in the StaticMesh property.
  DT_DrawType
  DT_Particle
    Used by particle effect actors (Emitter, xEmitter, xWeatherEffect) and xProcMeshes.
  DT_AntiPortal
    Used for Antiportals.
  DT_FluidSurface
    Used by FluidSurfaceInfos. See Fluid Surfaces.
    DT_None
    DT_Sprite
    DT_Mesh
    DT_Brush
    DT_RopeSprite
    DT_VerticalSprite
    DT_Terraform
    DT_SpriteAnimOnce
    DT_StaticMesh
    DT_DrawType
    DT_Particle
    DT_AntiPortal
    DT_FluidSurface

    ### EFilterState

    FS_Maybe
    FS_Yes
    FS_No

    ### EForceType

    FT_None
      Actor does not apply forces
    FT_DragAlong
      Actor drags particles with it, if the particle emitter is set to use Forces

    ### eKillZType

    KILLZ_None
      Actor killZ will be killed with no damage type
    KILLZ_Lava
      Actor killZ will be killed with Lava damage type
    KILLZ_Suicide
      Actor KillZ will be killed with Suicide damage type

    ### ELightEffect

    Spatial light effect to use.

    LE_None
    LE_TorchWaver
    LE_FireWaver
    LE_WateryShimmer
    LE_Searchlight
    LE_SlowWave
    LE_FastWave
    LE_CloudCast
    LE_StaticSpot
    LE_Shock
    LE_Disco
    LE_Warp
    LE_Spotlight
    LE_NonIncidence
    LE_Shell
    LE_OmniBumpMap
    LE_Interference
    LE_Cylinder
    LE_Rotor
    LE_Sunlight
    LE_QuadraticNonIncidence

    ### ELightType

    Light modulation.

    LT_None
    LT_Steady
    LT_Pulse
    LT_Blink
    LT_Flicker
    LT_Strobe
    LT_BackdropLight
    LT_SubtlePulse
    LT_TexturePaletteOnce
    LT_TexturePaletteLoop
    LT_FadeOut

    ### EMusicTransition

    Music transitions.

    MTRAN_None
    MTRAN_Instant
    MTRAN_Segue
    MTRAN_Fade
    MTRAN_FastFade
    MTRAN_SlowFade

    ### ENetRole

    Net variables.

    ROLE_None
      This means that none of the actor's attributes will not be replicated at all. Examples for this kind of actors are the GameInfo, Mutators and GameRules as well as some explosion effects and decals in UT. Note that Actor's with this role can still be instantiated on network game clients if spawned from the right function. For example if an Actor with `ROLE_None` is instantiated from a `simulated event PostBeginPlay()` function it will be created on both the server and the client as this function is invoked on both. However the server-side Actor and the client-side Actor are two completely independant entities. This means that destroying the actor on the server will not destroy the actor on the client (and vice-versa).
    ROLE_DumbProxy
      The actor is replicated, but can't execute any functions on the remote side. It will update when variables are replicated to it but will not attempt to interpolate.
    ROLE_SimulatedProxy
      The actor is replicated and may execute simulated functions and simulated state code on the remote side. Often this kind of actor simulates its behavior based on initially replicated properties without (much) further "help" from the server.
    ROLE_AutonomousProxy
      Autonomous proxies come with some more magic built-in. They are basically simulated proxies, but may execute simulated and non-simulated functions on the client owning/controlling this actor (only on that client!).
      In UT only PlayerPawns are autonomous proxies, in UT2003 only PlayerControllers are. Every other client sees them as a regular simulated proxy. Player-controlled actors, such as the guided redeemer missile (GuidedWarshell in UT or RedeemerWarhead in UT2003) are autonomous proxies on the controlling player's client, too.
    ROLE_Authority
      All functions can be executed. This role is only allowed on the machine the actor was spawned on. All actors on the server or in standalone games have `Role== ROLE_Authority`. Never manually set the `RemoteRole` on the authorative version of an actor or the `Role` on a replicated version of the actor to this value.
      ROLE_None
      ROLE_DumbProxy
      ROLE_SimulatedProxy
      ROLE_AutonomousProxy
      ROLE_Authority

      ### EPhysics

      Actor's PhysicsType is set in the Physics property. Use the `SetPhysics() method to change.`

      PHYS_CinMotion
        (new in UT2003)
      PHYS_Falling
        Automatically applies the gravity of the current zone. Pawn-set acceleration in the Z direction is ignored.
      PHYS_Flying
        The Pawn or Actor can move independantly from gravity. Velocity on the Z axis is ignored.
      PHYS_Hovering
        This is is a fun Physics type. When you an actors physics to `PHYS_Hovering`, it, er, hovers a few UU off the ground. If you do this to an xPawn, for example, it will act kind of like a hovercraft. Friction is reduced (so you slide around, and slide down ramps), and if you go at speed up an incline you can do some massive jumps.
      PHYS_Interpolating
        Used in conjunction with `bInterpolating` in Actor. Seems to also use the `PhysRate` and `PhysAlpha` parameters. Seems to be a leftover from the pre-Matinee days.
      PHYS_Karma
        Signals an Actor is to be effected by the Karma engine.
      PHYS_KarmaRagDoll
        This is used for dead pawns.
      PHYS_Ladder
        Applies to an Actor when they are climbing a ladder.
      PHYS_MovingBrush
        Used for Movers
      PHYS_None
        No native physics code is applied.
      PHYS_Projectile
        Uses velocities on all 3 axes but DOES NOT use the current Zone's ZoneGravity and ZoneFluidFriction members to adjust velocity. This means that actors with a velocity are not affected by gravity or friction. Actors with this physics setting do not have any freedom of movement.
      PHYS_Rolling
        (removed in UT2003)
      PHYS_RootMotion
        (new in UT2003)
      PHYS_Rotating
        Only rotation changes. Location doesn't change. If `bRotateToDesired` is false, then the Actor rotates according to `RotationRate`. If `bRotateToDesired` is true, then the Actor rotates to the rotation specified by `DesiredRotation` at the speed specified by `RotationRate`.
      PHYS_Spider
        Similar to `PHYS_Walking` except it applies to an Actor against any surface, not just a "ground" surface. An Actor in `PHYS_Spider` will move against a horizontal or vertical surface just like in `PHYS_Walking`. When the end of the surface is reached the Pawn will be set to `PHYS_Falling`. `PHYS_Spider` only works on one plane, it will not allow a Pawn to move across perpendicular walls.
      PHYS_Swimming
        Similar to `PHYS_Flying`, but also take the zone's FluidFriction into account.
      PHYS_Trailer
        Used to set an Actor to follow its Owner. An Actor set this way has no physics of its own, (*including collision) and simply follow their Owner around. NOTE: There are two settings in the Actor class which can specify the actions of a `PHYS_Trailer`. First is `bTrailerPrePivot`, which, when set to True, causes the Actor in `PHYS_Trailer` to be positioned away from its Owner by the vector value set in `PrePivot`. If not set or left at 0, the Actor in `PHYS_Trailer` will have the same location as its Owner. Secondly, there is `bTrailerSameRotation`, which causes the Actor in `PHYS_Trailer` to have the same Rotation as its Owner no matter where it is.
      PHYS_Walking
        Native physics code for Pawn class only. Applies all the things that make a pawn move around on the ground. Must have a Base set, without a Base to walk on, this turns to `PHYS_Falling`.
        PHYS_None
        PHYS_Walking
        PHYS_Falling
        PHYS_Swimming
        PHYS_Flying
        PHYS_Rotating
        PHYS_Projectile
        PHYS_Interpolating
        PHYS_MovingBrush
        PHYS_Spider
        PHYS_Trailer
        PHYS_Ladder
        PHYS_RootMotion
        PHYS_Karma
        PHYS_KarmaRagDoll
        PHYS_Pawn

        ### ERenderStyle

        Style for rendering sprites, meshes.

        STY_None
        STY_Normal
        STY_Masked
        STY_Translucent
        STY_Modulated
        STY_Alpha
        STY_Additive
        STY_Subtractive
        STY_Particle
        STY_AlphaZ

        ### ESoundOcclusion

        Sound occlusion

        OCCLUSION_Default
        OCCLUSION_None
          Objects between this Actor and Player do not affect sound
        OCCLUSION_BSP
          BSP between this Actor and Player affects sounds
        OCCLUSION_StaticMeshes
          StaticMeshes between Actor and Player affects sounds

        ### ESoundSlot

        SLOT_None
          Generic sound slot, any sound played in this slot should play, even if sound is already playing. All other slots are one sound at a time.
        SLOT_Misc
          Misc. sounds
        SLOT_Pain
          Pain sounds
        SLOT_Interact
          Interaction with the world sounds
        SLOT_Ambient
          Ambient Noise
        SLOT_Talk
          Talking
        SLOT_Interface
          User Interface sounds

        ### ETravelType

        Travelling from server to server.

        TRAVEL_Absolute
          Travel to absolute URL
        TRAVEL_Partial
          Partial travel (carry name, reset server) ?
        TRAVEL_Relative
          Relative URL

        ## Structures

        ### ActorRenderDataPtr

        int Ptr

        ### AnimRep

        Animation replication (can be used to replicate channel 0 anims for dumb proxies)

        byte AnimFrame
        byte AnimRate
          note that with compression, max replicated animrate is 4.0
        name AnimSequence
        bool bAnimLoop
        byte TweenRate
          note that with compression, max replicated tweentime is 4 seconds

        ### BatchReference

        int BatchIndex
        int ElementIndex

        ### EventHandlerMapping

        #### Actor

        Name EventName
        Name HandledBy

        ### KRBVec

        float X
        float Y
        float Z

        ### KRigidBodyState

        KRBVec AngVel
        KRBVec LinVel
        KRBVec Position
        Quat Quaternion

        ### LightRenderDataPtr

        int Ptr

        ### PointRegion

        Identifies a unique convex volume in the world.

        int iLeaf
          Bsp leaf.
        zoneinfo Zone
          Zone
        byte ZoneNumber
          Zone Number.

        ### ProjectorRenderInfoPtr

        Hack to to fool C++ header generation...

        int Ptr

        ### StaticMeshProjectorRenderInfoPtr

        int Ptr

        ### timerStruct

        byte bLooping
        int slotID
        float TimerCounter
        float TimerRate

        ## Functions

        AllActors(class<actor> BaseClass, out actor Actor, optional name MatchTag )
          Avoid using `AllActors()` too often as it iterates through the whole actor list and is therefore slow.
        AnimBlendParams(int Stage, optional float BlendAlpha, optional float InTime, optional float OutTime, optional name BoneName, optional bool bGlobalPose )
        AnimBlendToAlpha(int Stage, float TargetAlpha, float TimeInterval )
        bool AnimIsInGroup(int Channel, name GroupName )
        bool AttachToBone(actor Attachment, name BoneName )
          Attach the specified Attachment actor to the specified BoneName bone of this Actor
        AutonomousPhysics(float DeltaSeconds )
        BasedActors(class<actor> BaseClass, out actor Actor )
          Returns all actors based on the current actor (slow, like AllActors)
        BecomeViewTarget( )
          Called by PlayerController when this actor becomes its ViewTarget.
        BoneRefresh( )
          You want to call this when bringing a Skeletal actor into the world to avoid it going into it's refpose for no obvious reason.
        bool CanSplash( )
        ChildActors(class<actor> BaseClass, out actor Actor )
          ChildActors() returns all actors owned by this actor. Slow like AllActors()
        Clock(out float time )
          This is called at the beginning of a section of code to be timed. The variable time does not need to be initialized. Call Unclock() with the same variable you passed to Clock() to get the timer results
        CollidingActors(class<actor> BaseClass, out actor Actor, float Radius, optional vector Loc )
          CollidingActors() returns colliding (`bCollideActors==true`) actors within a certain radius.
        string ConsoleCommand(string Command )
          Execute a console command in the context of the current level and game engine.
        CopyMaterialsToSkins( )
          Native function unique to LOTD, copies the default Materials into the Skins[] override array
        DebugClock( )
        DebugUnclock( )
        bool Destroy( )
          Destroy this actor. Returns true if destroyed, false if indestructable.
        bool DetachFromBone(actor Attachment )
          Remove the specified Actor, from whatever it is attached to. It is presumed that it would be attached to THIS actor, but that is apparently not a requirement.
        DisplayDebug(Canvas Canvas, out float YL, out float YPos )
          List important actor variable on canvas. HUD will call DisplayDebug() on the current ViewTarget when the ShowDebug exec is used.
        DoActionableAction(Controller InstigatingController )
          Called whenever a player presses the Action button within this actor's ActionableRadius
        DrawDebugLine(vector LineStart, vector LineEnd, byte R, byte G, byte B )
          SLOW! Use for debugging only!
        DynamicActors(class<actor> BaseClass, out actor Actor, optional name MatchTag )
          DynamicActors() only iterates through the non-static actors on the list (still relatively slow, but much better than AllActors). This should be used in most cases and replaces AllActors in many situations
        bool EffectIsRelevant(vector SpawnLocation, bool bForceDedicated )
          This should be called by effects to see if they should play. The original game doesn't use it much at all, but you probably should.
        EnableChannelNotify(int Channel, int Switch )
        Error(coerce string S )
          Handle an error and kill this one actor.
        bool FastTrace(vector TraceEnd, optional vector TraceStart )
          Similar to trace, this one returns true if it hits the world geometry, false if it is not long enough. It will pass right through anything that is not set as world geometry.
        FilterStateDirty( )
        FinishAnim(optional int Channel )
          Latent function that will return when all Animation (or within the specified Channel) is completed
        FinishInterpolation( )
        bool ForceFeedbackSupported(optional bool Enable )
          Without parameters this will return the state of Force Feedback support, with a True parameter, it will enable Force Feedback
        FreezeAnimAt(float Time, optional int Channel )
          Hold an animation on the specified channel at the specified time frame.
        string GetActionableMessage(Controller InstigatingController )
          Called in any object when a Player is within it's ActionableRadius to determine what to print on the Player's screen to notify them that they can use the object for something
        int GetActionablePriority(Controller InstigatingController )
          Called in any object when a Player is within it's ActionableRadius to determine what Actor's GetActionableMessage and DoActionableAction functions should be called by the player, if there are multiple Actionable items involved. Set to -1 to make this Actor non actionable
        GetAnimParams(int Channel, out name OutSeqName, out float OutAnimFrame, out float OutAnimRate )
          Returns information about the currently playing Animation
        coords GetBoneCoords(name BoneName )
          Returns the coords of the BoneName bone.
        rotator GetBoneRotation(name BoneName, optional int Space )
          Returns the rotation of the BoneName bone
        bool GetCacheEntry(int Num, out string GUID, out string Filename )
          Give this a number, and it will return you the GUID and Filename of that entry in the Cache. It may be possible to build some kind of Cache manager thing, but I have no idea why.
        vector GetCollisionExtent( )
          This returns a collision Extent that could be used with Trace, that will give you the size of this actor as the extent, based on CollisionRadius and CollisionHeight
        String GetDebugName( )
        String GetHumanReadableName( )
          Returns the human readable string representation of an object.
        String GetItemName(string FullName )
        string GetLocalString(optional int Switch, optional PlayerReplicationInfo RelatedPRI_1, optional PlayerReplicationInfo RelatedPRI_2 )
          Get localized message string associated with this actor.
        string GetMapName(string NameEnding, string MapName, int Dir )
        string GetMeshName( )
        string GetNextInt(string ClassName, int Num )
        GetNextIntDesc(string ClassName, int Num, out string Entry, out string Description )
          Read from the INT files available
        GetNextSkin(string Prefix, string CurrentSkin, int Dir, out string SkinName, out string SkinDesc )
        int GetNotifyChannel( )
        plane GetRenderBoundingSphere( )
        vector GetRootLocation( )
        vector GetRootLocationDelta( )
        rotator GetRootRotation( )
        rotator GetRootRotationDelta( )
        float GetSoundDuration(sound Sound )
          Returns the duration in seconds of a sound
        string GetURLMap( )
        bool HasAnim(name Sequence )
          Returns true if this actor has an animation with the named Sequence
        HurtRadius(float DamageAmount, float DamageRadius, class<DamageType> DamageType, float Momentum, vector HitLocation )
          Hurt locally authoritative actors within the radius.
        bool IsAnimating(optional int Channel )
          returns true if the specified channel is playing an animation
        bool IsInPain( )
          Return True if this actor is inside a Pain volume
        bool IsInVolume(Volume aVolume )
          Returns true if the actor is in the specified volume
        bool IsTweening(int Channel )
          Presumably returns True if the Actor is Tweening on the particular animation channel
        KAddBoneLifter(name BoneName, InterpCurve LiftVel, float LateralFriction, InterpCurve Softness )
          Note you MUST turn collision off (`KSetBlockKarma`) before using bone lifters.
        KAddImpulse(vector Impulse, vector Position, optional name BoneName )
          A position of (0,0,0) applies impulse at COM (ie no angular component).
        KDisableCollision(actor Other )
          Turn off Karma collision for this actor to the specified other actor
        KDrawRigidBodyState(KRigidBodyState RBState, bool AltColour )
          SLOW! Use for debugging only!
        KEnableCollision(actor Other )
          Turns on Karma collision for this actor to the specified other actor
        KFreezeRagdoll( )
          Halt a Karma Ragdoll
        float KGetActorGravScale( )
          Returns the KParams.KGravScale
        KGetCOMOffset(out vector offset )
          Get the offset of actor's Center of Mass
        KGetCOMPosition(out vector pos )
          Get actual position of actors Center of Mass in world space
        KGetDampingProps(out float lindamp, out float angdamp )
          Return the Linear damping and Angular damping
        float KGetFriction( )
          Return the Karma Friction
        float KGetImpactThreshold( )
          Return Karma ImpactThreshold
        KGetInertiaTensor(out vector it1, out vector it2 )
          Return Karma Inertia Tensor
        float KGetMass( )
          Return Karma Mass
        quat KGetRBQuaternion( )
        float KGetRestitution( )
          Return Karma Restitution (bounciness)
        KGetRigidBodyState(out KRigidBodyState RBstate )
          Return Karma Rigid Body State
        float KGetSkelMass( )
          Return Karma SKeletal Mass (where is this set?)
        bool KIsAwake( )
          Returns true if we are currently simulating
        bool KIsRagdollAvailable( )
          Returns true if there is a ragdoll available (what are these conditions?)
        KMakeRagdollAvailable( )
          Make a Ragdoll available (explain?)
        KRBVec KRBVecFromVector(vector v )
        vector KRBVecToVector(KRBVec RBvec )
        KRemoveAllBoneLifters( )
        KRemoveLifterFromBone(name BoneName )
        KSetActorGravScale(float ActorGravScale )
          Set Karma Gravity Scale
        KSetBlockKarma(bool newBlock )
          Set to Block karma objects
        KSetCOMOffset(vector offset )
          Set offset of Center of Mass
        KSetDampingProps(float lindamp, float angdamp )
          Set Linear and Angular karma damping
        KSetFriction(float friction )
          Set Karma Friction
        KSetImpactThreshold(float thresh )
          Set Karma ImpactThreshold
        KSetInertiaTensor(vector it1, vector it2 )
          set Karma Inertia Tensor
        KSetMass(float mass )
          Set Karma Mass
        KSetRestitution(float rest )
          Set Karma Restitution (bounciness)
        KSetSkelVel(vector Velocity, optional vector AngVelocity, optional bool AddToCurrent )
          Set Karma SKeletalVelocity
        KSetStayUpright(bool stayUpright, bool allowRotate )
          Set Karma StayUpright properties
        KSetStayUprightParams(float stiffness, float damping )
        KWake( )
          Start Karma simulating
        LinkMesh(mesh NewMesh, optional bool bKeepAnim )
          Link to a new Mesh, optionally keeping the existing Animations or using the new Mesh's animations
        LinkSkelAnim(MeshAnimation Anim, optional mesh NewMesh )
          Link new Animations, optionally replacing the Mesh (LOTD implements multiple Animation packages per Mesh, there are better functions for dealing with this
        LockRootMotion(int Lock )
        LoopAnim(name Sequence, optional float Rate, optional float TweenTime, optional int Channel )
        MakeNoise(float Loudness )
          Inform other creatures that you've made a noise they might hear (they are sent a HearNoise message). (Loudness seems to be 1.0 in most places, is that the max?)
        MatchStarting( )
          Called when gameplay actually starts.
        bool Move(vector Delta )
          Move this actor, and everything attached to it, by Delta vector.
        bool MoveCacheEntry(string GUID, optional string NewFilename )
          Cache management function
        bool MoveSmooth(vector Delta )
          Like Move(), but will attempt to continue moving by sliding along a wall or up a slight incline/stairs, etc
        bool NearSpot(vector Spot )
          NearSpot() returns true is spot is within collision cylinder.
        Notify( )
        OnlyAffectPawns(bool B )
        PlayAnim(name Sequence, optional float Rate, optional float TweenTime, optional int Channel )
        bool PlayerCanSeeMe( )
          PlayerCanSeeMe returns true if any player (server) or the local player (standalone or client) has a line of sight to actor's location. Note that if you want to use this with an actor that is normally bHidden, you will need to set bHidden=False, and set DrawType=DT_NONE.
        PlayFeedbackEffect(String EffectName )
          Play a Force Feedback effect
        int PlayMusic(string Song, float FadeInTime )
          Only used for level music - will be stopped when level changes
        PlayOwnedSound(sound Sound, optional ESoundSlot Slot, optional float Volume, optional bool bNoOverride, optional float Radius, optional float Pitch, optional bool Attenuate )
          Play a sound effect, but don't propagate to a remote owner (he is playing the sound clientside)
        PlaySound(sound Sound, optional ESoundSlot Slot, optional float Volume, optional bool bNoOverride, optional float Radius, optional float Pitch, optional bool Attenuate )
          Play a sound effect.
        PlayTeleportEffect(bool bOut, bool bSound )
          Called when this actor passes through a Teleporter
        RadiusActors(class<actor> BaseClass, out actor Actor, float Radius, optional vector Loc )
          RadiusActors() returns all actors within a give radius. Slow like AllActors(). Use CollidingActors() or VisibleCollidingActors() instead if desired actor types are visible (not bHidden) and in the collision hash (`bCollideActors` is true)
        RenderOverlays(Canvas Canvas )
          Called by player's hud to request drawing of actor specific overlays onto canvas
        ReplaceText(out string Text, string Replace, string With )
          Replace string Replace with string With, in string Text, returning result in passed string Text
        Reset( )
          Reset actor to initial state - used when restarting level without reloading.
        SetAnimFrame(float Time, optional int Channel, optional int UnitFlag )
          Move to a specific frame of animation, on a specific channel. If UnitFlag == 0 (default), then Time refers to a percentage of time (0.0 to 1.0). If UnitFlag == 1, then Time refers to a specific Frame number.
        SetBase(actor NewBase, optional vector NewFloor )
          Set the actor's Base (for attached movement). NewFloor is only valid for Pawns, and is used to set the Floor that they would be walking on if they were PHYS_Walking or PHYS_Spidering.
        SetBoneDirection(name BoneName, rotator BoneTurn, optional vector BoneTrans, optional float Alpha, optional int Space )
        SetBoneLocation(name BoneName, optional vector BoneTrans, optional float Alpha )
        SetBoneRotation(name BoneName, optional rotator BoneTurn, optional int Space, optional float Alpha )
        SetBoneScale(int Slot, optional float BoneScale, optional name BoneName )
          Adjust the size of a particular bone. This is used to implement destructable limbs and the Big Head mutator.
        SetCollision(optional bool NewColActors, optional bool NewBlockActors, optional bool NewBlockPlayers )
          Adjust collision paramters
        bool SetCollisionSize(float NewRadius, float NewHeight )
          Adjust actor's collisionradius and height
        SetDefaultDisplayProperties( )
          Reset this actor's Style, bUnlit, and Texture settings to the actor's default.
        SetDisplayProperties(ERenderStyle NewStyle, Material NewTexture, bool bLighting )
          Set the display properties of an actor.
        SetDrawScale(float NewScale )
          Adjust the DrawScale of the Actor, 1.0 = normal
        SetDrawScale3D(vector NewScale3D )
          Adjust the DrawScale3D, (1.0,1.0,1.0) = normal, use negative numbers to mirror
        SetDrawType(EDrawType NewDrawType )
          Change the actor's DrawType
        SetGRI(GameReplicationInfo GRI )
        bool SetLocation(vector NewLocation )
          This function sets the location of the actor it is called on. It will not work on actors with `PHYS_Karma` or `PHYS_KarmaRagdoll`. If the actor cannot occupy the new location because it is colliding with an actor that can block it, it will be placed at the nearest valid location. Note that because Terrain has no "volume" and is just a bent up sheet, the actor may not be moved in this manner when it penetrates terrain.
        SetMultiTimer(int slotID, float NewTimerRate, bool bLoop )
          Native function apparently specific to LOTD, specifies that this actor's MultiTimer(slotID) function will be called. Very similar to Timer, but easy to use for multiple things in one actor.
        SetOwner(actor NewOwner )
          Set this Actor's Owner property
        SetPhysics(EPhysics newPhysics )
          Changes this Actor's physics type, takes effect on the NEXT tick.
        bool SetRelativeLocation(vector NewLocation )
          Sets the location relative to this actor's base
        bool SetRelativeRotation(rotator NewRotation )
          Sets the rotation relative to the actor's base.
        bool SetRotation(rotator NewRotation )
          This function sets the rotation of the actor it is called on. It will not work on actors with `PHYS_Karma` or `PHYS_KarmaRagdoll`.
        SetStaticMesh(StaticMesh NewStaticMesh )
          Set a new StaticMesh to replace this actor's original setting.
        SetTimer(float NewTimerRate, bool bLoop )
          Causes `Timer()` events every `NewTimerRate` seconds. If `bLoop` is true, causes `Timer()` events every `NewTimerRate` seconds. Otherwise, causes `Timer()` to be called once in `NewTimerRate` seconds. `SetTimer(0.0, False);` stops the timer.
        bool ShouldBeHidden( )
          Check if class has HideDropDown specifier
        Sleep(float Seconds )
          Waits for the specified amount of time before returning.
        actor Spawn(class<actor> SpawnClass, optional actor SpawnOwner, optional name SpawnTag, optional vector SpawnLocation, optional rotator SpawnRotation )
          Spawn an actor. Returns an actor of the specified class, not of class Actor (this is hardcoded in the compiler).
          Returns None if the actor could not be spawned (either the actor wouldn't fit in the specified location, or the actor list is full).
        StartInterpolation( )
          When this function is called, the actor will start moving along an interpolation path beginning at Dest
        StopAllMusic(float FadeOutTime )
          Fade all music out
        StopAnimating(optional bool ClearAllButBase )
          Halt animation playing for this actor
        StopFeedbackEffect(optional String EffectName )
          Pass no parameter or "" to stop all.
        StopMusic(int SongHandle, float FadeOutTime )
          Stop a particular songhandle (returned by PlayMusic)
        vector SuggestFallVelocity(vector Destination, vector Start, float MaxZ, float MaxXYSpeed )
        bool TouchingActor(Actor A )
          Returns true if Actor A is touching this Actor
        TouchingActors(class<actor> BaseClass, out actor Actor )
          Returns all actors touching the current actor (fast).
        Actor Trace(out vector HitLocation, out vector HitNormal, vector TraceEnd, optional vector TraceStart, optional bool bTraceActors, optional vector Extent, optional out material Material )
          This traces a path to find what it collides with first. The line will be traced starting at `TraceStart` and ending at `TraceEnd`.
          If `bTraceActors` is true, actors will be considered for the tracing, otherwise only pieces of the world (terrain, staticmeshactors, BSP) will be considered for collision.
          When the trace hits something, `HitLocation` and `HitNormal` will be set to contain the location and normal of the impact. If specified, the material of the surface hit can also be returned. If an `Extent` is specified, you can have the trace have "width." It will have a box of the size specified as a vector (corner to corner) as the "thickness" of the trace.
          Note that traces are not very fast, so should be avoided or kept to a minimum where possible.
        TraceActors(class<actor> BaseClass, out actor Actor, out vector HitLoc, out vector HitNorm, vector End, optional vector Start, optional vector Extent )
          Return all actors along a traced line. Reasonably fast (like any trace)
        TweenAnim(name Sequence, float Time, optional int Channel )
        UnClock(out float time )
          This is called at the end of a section of code to be timed passing in the same time variable supplied to Clock.
        UntriggerEvent(Name EventName, Actor Other, Pawn EventInstigator )
        UpdatePrecacheMaterials( )
          Used to add new materials to the Precache specified in Level. Not quite sure why we'd want to do this after the game starts, as that's when the Precaching happens.
        UpdatePrecacheStaticMeshes( )
          See UpdatePrecacheMaterials
        VisibleActors(class<actor> BaseClass, out actor Actor, optional float Radius, optional vector Loc )
          Returns all visible (not `bHidden`) actors within a radius for which a trace from `Loc` (which defaults to caller's `Location`) to that actor's `Location` does not hit the world.
        VisibleCollidingActors(class<actor> BaseClass, out actor Actor, float Radius, optional vector Loc, optional bool bIgnoreHidden )
          Returns all colliding (`bCollideActors==true`) actors within a certain radius for which a trace from `Loc` (which defaults to caller's Location) to that actor's Location does not hit the world.
        WaitForNotification(optional float TimeoutInSeconds )
          Latent function returns after specified time, or when a Notify() is called

        ## Events

        AnimEnd(int Channel )
          Notification that the current animation has ended. Allows an object to wait for animation completion before proceeding with other activities.
        Attach(Actor Other )
          Called when this actor is attached to actor Other
        BaseChange( )
          Called when this actor's Base is changed
        BeginEvent( )
        BeginPlay( )
          Called at the beginning of play
        BroadcastLocalizedMessage(class<LocalMessage> MessageClass, optional int Switch, optional PlayerReplicationInfo RelatedPRI_1, optional PlayerReplicationInfo RelatedPRI_2, optional Object OptionalObject )
          Broadcast a localized message to all players.
          Most message deal with 0 to 2 related PRIs.
        Bump(Actor Other )
          Called when actor Other bumps this actor
        DemoPlaySound(sound Sound, optional ESoundSlot Slot, optional float Volume, optional bool bNoOverride, optional float Radius, optional float Pitch, optional bool Attenuate )
        Destroyed( )
          Called after this actor's Destroy() function is called
        Detach(Actor Other )
          Called when this actor is detached from Other
        EncroachedBy(actor Other )
          Called when Other is encroaching our collision zone
        bool EncroachingOn(actor Other )
          Called when we are encoraching on Other's collision zone
        EndedRotation( )
          Called when rotation completes
        EndEvent( )
        Falling( )
          Called when we are falling. Ahhh!!!!!
        FellOutOfWorld(eKillZType KillType )
          Sets physics to none and destroys the actor.
        FinishedInterpolation( )
          The implementation in actor only sets `bInterpolating` to false.
        GainedChild(Actor Other )
          Called when a child actor is spawned
        HitWall(vector HitNormal, actor HitWall )
          Called when this actor hits a wall
        KApplyForce(out vector Force, out vector Torque )
          Event called just before sim to allow user to apply Karma forces
        KilledBy(pawn EventInstigator )
          Called when this Actor is killed (only appears to be useful for pawns..)
        KImpact(actor other, vector pos, vector impactVel, vector impactNorm )
          Event called when Karmic actor hits with impact velocity over `KImpactThreshold`.
        KSkelConvulse( )
          Event called when a ragdoll convulses (see KarmaParamsSkel)
        bool KUpdateState(out KRigidBodyState newState )
          This is called from inside C++ physKarma at the appropriate time to update state of Karma rigid body.
        KVelDropBelow( )
          Event called when karma actor's velocity drops below `KVelDropBelowThreshold`
        Landed(vector HitNormal )
          Called when we hit the ground
        LostChild(Actor Other )
          Called when another actor with this actor as its owner is destroyed.
        MultiTimer(int slotID )
          Called as a result of the SetMultiTimer() function
        PhysicsVolumeChange(PhysicsVolume NewVolume )
          Called when this actor enters a new Physics Volume
        PostBeginPlay( )
          Called immediately after gameplay begins.
        PostLinearLoad( )
        PostLoad( )
          Called when a saved game is loaded, to allow actors to fix up anything they might need.
        PostNetBeginPlay( )
          Called after PostBeginPlay. On a net client, PostNetBeginPlay() is called after replicated variables have been initialized to their replicated values
        PostNetReceive( )
          If `bNetNotify` is True, this event is called when the actor receives an update to any variable through replication.
        PostTeleport(Teleporter OutTeleporter )
          function called after this Actor has passed through a Teleporter
        PostTouch(Actor Other )
          Called for PendingTouch actor after physics completes
        PreBeginPlay( )
          Called immediately before gameplay begins.
        bool PreTeleport(Teleporter InTeleporter )
          function called before this Actor is going to pass through a Teleporter
        RenderTexture(ScriptedTexture Tex )
        SetInitialState( )
          Called after PostBeginPlay.
        Actor SpecialHandling(Pawn Other )
        TakeDamage(int Damage, Pawn EventInstigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
          Called by anything that wishes to cause this actor Damage
        Tick(float DeltaTime )
        Timer( )
          Called from setting the SetTimer() function
        TornOff( )
          Networking - called on client when actor is torn off (`bTearOff==true`)
        Touch(Actor Other )
          Called when we are touching Actor Other
        TravelPostAccept( )
          Called when carried into a new level, after AcceptInventory.
        TravelPreAccept( )
          Called when carried onto a new level, before AcceptInventory.
        Trigger(Actor Other, Pawn EventInstigator )
          Called when this Actor's "Tag" event is triggered
        TriggerEvent(Name eventName, Actor sender, Pawn instigator )
          Call this to trigger an event
        TriggerEx(Actor sender, Pawn instigator, Name handler )
          Called when an Event that this actor handles is called, if bHasHandlers is set
        UnTouch(Actor Other )
          Called when this actor is no logner touching Other
        UnTrigger(Actor Other, Pawn EventInstigator )
        UsedBy(Pawn user )
          Called if this Actor was touching a Pawn who pressed Use (not used in LOTD in favor of the Actionable system)
        ZoneChange(ZoneInfo NewZone )
          Called when this actor changes zones

##### Views

- Legacy
- Discussion
- Current revision

##### Search