Engine.Actor

//=============================================================================
// Actor: The base class of all actors.
// Actor is the base class of all gameplay objects.
// A large number of properties, behaviors and interfaces are implemented in Actor, including:
//
// -	Display
// -	Animation
// -	Physics and world interaction
// -	Making sounds
// -	Networking properties
// -	Actor creation and destruction
// -	Triggering and timers
// -	Actor iterator functions
// -	Message broadcasting
//
// This is a built-in Unreal class and it shouldn't be modified.
//=============================================================================
class Actor extends Object
    abstract
    native
    nativereplication;

// Imported data (during full rebuild).
#exec Texture Import File=Textures\S_Actor.pcx Name=S_Actor Mips=Off MASKED=1

//-----------------------------------------------------------------------------
// Lighting.

// Light modulation.
var(Lighting) enum ELightType
{
    LT_None,
    LT_Steady,
    LT_Pulse,
    LT_Blink,
    LT_Flicker,
    LT_Strobe,
    LT_BackdropLight,
    LT_SubtlePulse,
    LT_TexturePaletteOnce,
    LT_TexturePaletteLoop,
    LT_FadeOut
} LightType;

// Spatial light effect to use.
var(Lighting) enum ELightEffect
{
    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_Negative, // sjs
    LE_Sunlight,
    LE_QuadraticNonIncidence
} LightEffect;

// Lighting info.
var(LightColor) byte
    LightHue,
    LightSaturation;
var(LightColor) float
    LightBrightness;
var(Lighting) float
    LightRadius;
var(Lighting) byte
    LightPeriod,
    LightPhase,
    LightCone;

// Drawing effect.
var(Display) const enum EDrawType
{
    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
} DrawType;

enum EFilterState
{
    FS_Maybe,
    FS_Yes,
    FS_No
};
var const native EFilterState   StaticFilterState;

var(Display) const StaticMesh StaticMesh;       // StaticMesh if DrawType=DT_StaticMesh

// Owner.
var const Actor          Owner;          // Owner actor.
var const Actor          Base;           // Actor we're standing on.

struct ActorRenderDataPtr { var pointer Ptr; };
struct LightRenderDataPtr { var pointer Ptr; };

var const native ActorRenderDataPtr ActorRenderData;
var const native LightRenderDataPtr LightRenderData;
var const native int                RenderRevision;

struct BatchReference
{
    var int BatchIndex,
            ElementIndex;
};

var const native array<BatchReference>  StaticSectionBatches;

var(Display) const name ForcedVisibilityZoneTag; // Makes the visibility code treat the actor as if it was in the zone with the given tag.
var(Display) float          CullDistance;       // 0 == no distance cull, < 0 only drawn at distance > 0 cull at distance

// Lighting.
var(Lighting) bool       bSpecialLit;           // Only affects special-lit surfaces.
var(Lighting) bool       bActorShadows;         // Light casts actor shadows.
var(Lighting) bool       bCorona;              // Light uses Skin as a corona.
var(Lighting) bool       bDirectionalCorona;    // (if bCorona) Make corona bigger if it faces you, and zero and 90 degrees or beyond.
var(Lighting) bool       bAttenByLife;          // sjs - attenuate light by diminishing lifespan
var(Lighting) bool       bLightingVisibility;   // Calculate lighting visibility for this actor with line checks.
var(Display) bool        bUseDynamicLights;
var bool                 bLightChanged;         // Recalculate this light's lighting now.
var bool                 bDramaticLighting;

// Flags.
var           const bool    bStatic;            // Does not move or change over time. Don't let L.D.s change this - screws up net play
var(Advanced)       bool    bHidden;            // Is hidden during gameplay.
var(Advanced) const bool    bNoDelete;          // Cannot be deleted during play.
var           const bool    bDeleteMe;          // About to be deleted.
var transient const bool    bTicked;            // Actor has been updated.
var(Lighting)       bool    bDynamicLight;      // This light is dynamic.
var                 bool    bTimerLoop;         // Timer loops (else is one-shot).
var                 bool    bOnlyOwnerSee;      // Only owner can see this actor.
var(Advanced)       bool    bHighDetail;        // Only show up in high or super high detail mode.
var(Advanced)       bool    bSuperHighDetail;   // Only show up in super high detail mode.
var                 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)
var(Advanced)       bool    bStasis;            // In StandAlone games, turn off if not in a recently rendered zone turned off if  bStasis  and physics = PHYS_None or PHYS_Rotating.
var                 bool    bTrailerAllowRotation; // If PHYS_Trailer and want independent rotation control.
var                 bool    bTrailerSameRotation; // If PHYS_Trailer and true, have same rotation as owner.
var                 bool    bTrailerPrePivot;   // If PHYS_Trailer and true, offset from owner by PrePivot.
var                 bool    bWorldGeometry;     // Collision and Physics treats this actor as world geometry
var(Display)        bool    bAcceptsProjectors; // Projectors can project onto this actor
var                 bool    bOrientOnSlope;     // when landing, orient base on slope of floor
var           const bool    bOnlyAffectPawns;   // Optimisation - only test ovelap against pawns. Used for influences etc.
var(Display)        bool    bDisableSorting;    // Manual override for translucent material sorting.
var(Movement)       bool    bIgnoreEncroachers; // Ignore collisions between movers and this actor

var                 bool    bShowOctreeNodes;
var                 bool    bWasSNFiltered;      // Mainly for debugging - the way this actor was inserted into Octree.
var transient const bool    bShouldStopKarma;    // Internal.
var           const bool    bDetailAttachment;   // If actor is attached to Karma object, only move once a frame regardless of timestep subdivision. Only valid when bCollideActors is false.

// Networking flags
var           const bool    bNetTemporary;              // Tear-off simulation in network play.
var                 bool    bOnlyRelevantToOwner;           // this actor is only relevant to its owner.
var transient const bool    bNetDirty;                  // set when any attribute is assigned a value in unrealscript, reset when the actor is replicated
var                 bool    bAlwaysRelevant;            // Always relevant for network.
var                 bool    bReplicateInstigator;       // Replicate instigator to client (used by bNetTemporary projectiles).
var                 bool    bReplicateMovement;         // if true, replicate movement/location related properties
var                 bool    bSkipActorPropertyReplication; // if true, don't replicate actor class variables for this actor
var                 bool    bUpdateSimulatedPosition;   // if true, update velocity/location after initialization for simulated proxies
var                 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.
var                 bool    bOnlyDirtyReplication;      // if true, only replicate actor if bNetDirty is true - useful if no C++ changed attributes (such as physics)
                                                        // bOnlyDirtyReplication only used with bAlwaysRelevant actors
var                 bool    bReplicateAnimations;       // Should replicate SimAnim
var const           bool    bNetInitialRotation;        // Should replicate initial rotation
var                 bool    bCompressedPosition;        // used by networking code to flag compressed position replication
var                 bool    bAlwaysZeroBoneOffset;      // if true, offset always zero when attached to skeletalmesh
var                 bool    bIgnoreVehicles;            // Ignore collisions between vehicles and this actor (only relevant if bIgnoreEncroachers is false)
var(Display)        bool    bDeferRendering;            // defer rendering if DrawType is DT_Particle or Style is STY_Additive
var                 bool    bBadStateCode;              // used for recovering from illegal state transitions (hack)

// Priority Parameters
// Actor's current physics mode.
var(Movement) const enum EPhysics
{
    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_Hovering,
    PHYS_CinMotion,
} Physics;

// Net variables.
enum ENetRole
{
    ROLE_None,              // No role at all.
    ROLE_DumbProxy,         // Dumb proxy of this actor.
    ROLE_SimulatedProxy,    // Locally simulated proxy of this actor.
    ROLE_AutonomousProxy,   // Locally autonomous proxy of this actor.
    ROLE_Authority,         // Authoritative control over the actor.
};
var ENetRole RemoteRole, Role;
var const transient int     NetTag;
var float NetUpdateTime;    // time of last update
var float NetUpdateFrequency; // How many net updates per seconds.
var float NetPriority; // Higher priorities means update it more frequently.
var Pawn                  Instigator;    // Pawn responsible for damage caused by this actor.
var(Sound) sound          AmbientSound;  // Ambient sound effect.
var const name          AttachmentBone;     // name of bone to which actor is attached (if attached to center of base, =='')

var       const LevelInfo Level;         // Level this actor is on.
var transient const Level   XLevel;         // Level object.
var(Advanced)   float       LifeSpan;       // How old the object lives before dying, 0=forever.

//-----------------------------------------------------------------------------
// Structures.

// Identifies a unique convex volume in the world.
struct PointRegion
{
    var zoneinfo Zone;       // Zone.
    var int      iLeaf;      // Bsp leaf.
    var byte     ZoneNumber; // Zone number.
};

//-----------------------------------------------------------------------------
// Major actor properties.

// Scriptable.
var const PointRegion     Region;        // Region this actor is in.
var             float       TimerRate;      // Timer event, 0=no timer.
var(Display)    Material    OverlayMaterial; // sjs - shader/material effect to use with skin
var(Display) const mesh     Mesh;           // Mesh if DrawType=DT_Mesh.
var transient float     LastRenderTime; // last time this actor was rendered.
var(Events) name            Tag;            // Actor's tag name.
var transient array<int>  Leaves;        // BSP leaves this actor is in.
var(Events) name          Event;         // The event this actor causes.
var Inventory             Inventory;     // Inventory chain.
var     const   float       TimerCounter;   // Counts up until it reaches TimerRate.
var transient MeshInstance MeshInstance;    // Mesh instance.
var(Display) float        LODBias;
var(Object) name InitialState;
var(Object) name Group;

// Internal.
var const array<Actor>    Touching;      // List of touching actors.
var const transient array<pointer>  OctreeNodes;// Array of nodes of the octree Actor is currently in. Internal use only.
var const transient Box   OctreeBox;     // Actor bounding box cached when added to Octree. Internal use only.
var const transient vector OctreeBoxCenter;
var const transient vector OctreeBoxRadii;
var const actor           Deleted;       // Next actor in just-deleted chain.
var const float           LatentFloat;   // Internal latent function use.

// Internal tags.
var const native int CollisionTag;
var const transient int JoinedTag;

// The actor's position and rotation.
var const   PhysicsVolume   PhysicsVolume;  // physics volume this actor is currently in
var(Movement) const vector  Location;       // Actor's location; use Move to set.
var(Movement) const rotator Rotation;       // Rotation.
var(Movement) vector        Velocity;       // Velocity.
var           vector        Acceleration;   // Acceleration.

var const vector CachedLocation;
var const Rotator CachedRotation;
var Matrix CachedLocalToWorld;

// Attachment related variables
var(Movement)   name    AttachTag;
var const array<Actor>  Attached;           // array of actors attached to this actor.
var const vector        RelativeLocation;   // location relative to base/bone (valid if base exists)
var const rotator       RelativeRotation;   // rotation relative to base/bone (valid if base exists)
var const     Matrix    HardRelMatrix;      // Transform of actor in base's ref frame. Doesn't change after SetBase.

// Projectors
struct ProjectorRenderInfoPtr { var pointer Ptr; }; // Hack to to fool C++ header generation...
struct StaticMeshProjectorRenderInfoPtr { var pointer Ptr; };
var const native array<ProjectorRenderInfoPtr> Projectors;// Projected textures on this actor
var const native array<StaticMeshProjectorRenderInfoPtr>    StaticMeshProjectors;

//-----------------------------------------------------------------------------
// Display properties.

var(Display) Material       Texture;            // Sprite texture.if DrawType=DT_Sprite
var StaticMeshInstance      StaticMeshInstance; // Contains per-instance static mesh data, like static lighting data.
var const export model      Brush;              // Brush if DrawType=DT_Brush.
var(Display) const float    DrawScale;          // Scaling factor, 1.0=normal size.
var(Display) const vector   DrawScale3D;        // Scaling vector, (1.0,1.0,1.0)=normal size.
var(Display) vector         PrePivot;           // Offset from box center for drawing.
var(Display) array<Material> Skins;             // Multiple skin support - not replicated.
var         Material        RepSkin;            // replicated skin (sets Skins[0] if not none)
var(Display) byte           AmbientGlow;        // Ambient brightness, or 255=pulsing.
var(Display) byte           MaxLights;          // Limit to hardware lights active on this primitive.
var(Display) enum EUV2Mode
{
    UVM_MacroTexture,
    UVM_LightMap,
    UVM_Skin,
} UV2Mode;
var(Display) ConvexVolume   AntiPortal;         // Convex volume used for DT_AntiPortal

var(Display) Material       UV2Texture;

var(Display) float          ScaleGlow;

var(Collision) enum ESurfaceTypes // !! - must mirror with Texture.uc in order for BSP geom surface's to match
{
    EST_Default,
    EST_Rock,
    EST_Dirt,
    EST_Metal,
    EST_Wood,
    EST_Plant,
    EST_Flesh,
    EST_Ice,
    EST_Snow,
    EST_Water,
    EST_Glass,
    EST_Custom00,
    EST_Custom01,
    EST_Custom02,
    EST_Custom03,
    EST_Custom04,
    EST_Custom05,
    EST_Custom06,
    EST_Custom07,
    EST_Custom08,
    EST_Custom09,
    EST_Custom10,
    EST_Custom11,
    EST_Custom12,
    EST_Custom13,
    EST_Custom14,
    EST_Custom15,
    EST_Custom16,
    EST_Custom17,
    EST_Custom18,
    EST_Custom19,
    EST_Custom20,
    EST_Custom21,
    EST_Custom22,
    EST_Custom23,
    EST_Custom24,
    EST_Custom25,
    EST_Custom26,
    EST_Custom27,
    EST_Custom28,
    EST_Custom29,
    EST_Custom30,
    EST_Custom31,
} SurfaceType;

// Style for rendering sprites, meshes.
var(Display) enum ERenderStyle
{
    STY_None,
    STY_Normal,
    STY_Masked,
    STY_Translucent,
    STY_Modulated,
    STY_Alpha,
    STY_Additive,
    STY_Subtractive,
    STY_Particle,
    STY_AlphaZ,
} Style;

// Display.
var(Display)  bool      bUnlit;                 // Lights don't affect actor.
var(Display)  bool      bShadowCast;            // Casts static shadows.
var(Display)  bool      bStaticLighting;        // Uses raytraced lighting.
var(Display)  bool      bUseLightingFromBase;   // Use Unlit/AmbientGlow from Base

// Advanced.
var           bool      bHurtEntry;             // keep HurtRadius from being reentrant
var(Advanced) bool      bGameRelevant;          // Always relevant for game
var(Advanced) bool      bCollideWhenPlacing;    // This actor collides with the world when placing.
var           bool      bTravel;                // Actor is capable of travelling among servers.
var(Advanced) bool      bMovable;               // Actor can be moved.
var           bool      bDestroyInPainVolume;   // destroy this actor if it enters a pain volume
var           bool      bCanBeDamaged;          // can take damage
var(Advanced) bool      bShouldBaseAtStartup;   // if true, find base for this actor at level startup, if collides with world and PHYS_None or PHYS_Rotating
var           bool      bPendingDelete;         // set when actor is about to be deleted (since endstate and other functions called
                                                // during deletion process before bDeleteMe is set).
var                 bool    bAnimByOwner;       // Animation dictated by owner.
var                 bool    bOwnerNoSee;        // Everything but the owner can see this actor.
var(Advanced)       bool    bCanTeleport;       // This actor can be teleported.
var                 bool    bClientAnim;        // Don't replicate any animations - animation done client-side
var                 bool    bDisturbFluidSurface; // Cause ripples when in contact with FluidSurface.
var                 float    FluidSurfaceShootStrengthMod; // if bDisturbFluidSurface == true, FluidSurface's ShootStrength is multiplied by this before doing the ripples
var           const bool    bAlwaysTick;        // Update even when players-only.
var(Sound) bool             bFullVolume;        // Whether to apply ambient attenuation.
var             bool    bNotifyLocalPlayerTeamReceived; //wants NotifyLocalPlayerTeamReceived()

var(Movement)       bool    bHardAttach;       // Uses 'hard' attachment code. bBlockActor and bBlockPlayer must also be false.
                                                // This actor cannot then move relative to base (setlocation etc.).
                                                // Dont set while currently based on something!
var                 bool    bForceSkelUpdate;   // update skeleton (and attached actor positions) even if not rendered
var     const       bool    bClientAuthoritative; // Remains ROLE_Authority on client (only valid for bStatic or bNoDelete actors)

//-----------------------------------------------------------------------------
// Sound.

// Ambient sound.
var(Sound) byte         SoundVolume;            // Volume of ambient sound.
var(Sound) byte         SoundPitch;             // Sound pitch shift, 64.0=none.

// Sound occlusion
enum ESoundOcclusion
{
    OCCLUSION_Default,
    OCCLUSION_None,
    OCCLUSION_BSP,
    OCCLUSION_StaticMeshes,
};

var(Sound) ESoundOcclusion SoundOcclusion;      // Sound occlusion approach.

// Sound slots for actors.
enum ESoundSlot
{
    SLOT_None,
    SLOT_Misc,
    SLOT_Pain,
    SLOT_Interact,
    SLOT_Ambient,
    SLOT_Talk,
    SLOT_Interface,
};

// Music transitions.
enum EMusicTransition
{
    MTRAN_None,
    MTRAN_Instant,
    MTRAN_Segue,
    MTRAN_Fade,
    MTRAN_FastFade,
    MTRAN_SlowFade,
};

var(Sound) float        SoundRadius;            // Radius of ambient sound.

// Regular sounds.
var(Sound) float TransientSoundVolume;  // default sound volume for regular sounds (can be overridden in playsound)
var(Sound) float TransientSoundRadius;  // default sound radius for regular sounds (can be overridden in playsound)

//-----------------------------------------------------------------------------
// Collision.

// Collision size.
var(Collision) const float CollisionRadius;     // Radius of collision cyllinder.
var(Collision) const float CollisionHeight;     // Half-height cyllinder.

// Collision flags.
var(Collision) const bool bCollideActors;       // Collides with other actors.
var            bool       bCollideWorld;        // Collides with the world.
var(Collision) bool       bBlockActors;         // Blocks other nonplayer actors.
var            bool       bBlockPlayers;        // OBSOLETE - no longer used
var            bool       bBlockProjectiles;    // hack for Paladin shield
var(Collision) bool       bProjTarget;          // Projectiles should potentially target this actor.
var(Collision) bool       bBlockZeroExtentTraces; // block zero extent actors/traces
var(Collision) bool       bBlockNonZeroExtentTraces;    // block non-zero extent actors/traces
var(Collision) bool       bAutoAlignToTerrain;  // Auto-align to terrain in the editor
var(Collision) bool       bUseCylinderCollision;// Force axis aligned cylinder collision (useful for static mesh pickups, etc.)
var(Collision) const bool bBlockKarma;          // Block actors being simulated with Karma.
var            bool       bBlocksTeleport;
var(Display)        bool    bAlwaysFaceCamera;          // actor will be rendered always facing the camera like a sprite
var                 bool    bNetNotify;                 // actor wishes to be notified of replication events
var                 bool    bClientTrigger;             // replicated property used to trigger client side ClientTrigger() event
var            bool       bUseCollisionStaticMesh;
var            bool       bSmoothKarmaStateUpdates;     // When true, karma state updates will be smoothly interpolated

//-----------------------------------------------------------------------------
// Physics.

// Options.
var           bool        bIgnoreOutOfWorld; // Don't destroy if enters zone zero
var(Movement) bool        bBounce;           // Bounces when hits ground fast.
var(Movement) bool        bFixedRotationDir; // Fixed direction of rotation.
var(Movement) bool        bRotateToDesired;  // Rotate to DesiredRotation.
var(Movement) bool        bIgnoreTerminalVelocity;  // If PHYS_Falling, ignore the TerminalVelocity of the PhysicsVolume.
var(Movement) bool        bOrientToVelocity; // Orient in the direction of current velocity.
var           bool        bInterpolating;    // Performing interpolating.
var           const bool  bJustTeleported;   // Used by engine physics - not valid for scripts.

// Physics properties.
var(Movement) float       Mass;             // Mass of this actor.
var(Movement) float       Buoyancy;         // Water buoyancy.
var(Movement) rotator     RotationRate;     // Change in rotation per second.
var(Movement) rotator     DesiredRotation;  // Physics will smoothly rotate actor to this rotation if bRotateToDesired.
var           Actor       PendingTouch;     // Actor touched during move which wants to add an effect after the movement completes
var       const vector    ColLocation;      // Actor's old location one move ago. Only for debugging

var(Events)     Name    ExcludeTag[8];      // sjs - multipurpose exclusion tag for excluding lights, projectors, rendering actors, blocking weather

const MAXSTEPHEIGHT = 35.0; // Maximum step height walkable by pawns
const MINFLOORZ = 0.7; // minimum z value for floor normal (if less, not a walkable floor)
                       // 0.7 ~= 45 degree angle for floor

// ifdef WITH_KARMA

// Used to avoid compression
struct KRBVec
{
    var float   X, Y, Z;
};

struct KRigidBodyState
{
    var KRBVec  Position;
    var Quat    Quaternion;
    var KRBVec  LinVel;
    var KRBVec  AngVel;
};

// Scary internal params used by Karma. BE VERY CAREFUL!!
// NB. These take affect until you quit the game! Make sure you reset them to defaults when leaving mod etc.

struct KSimParams
{
    var float   GammaPerSec; // Relaxation constant. Making it larger pushes things apart harder when they penetrate.
    var float   Epsilon; // Global constraint compliance. Making it larger makes contacts/joints softer.
    var float   PenetrationOffset; // Resting penetration. Making this larger can reduce jiggling.
    var float   PenetrationScale; // Artificially increase penetration - makes contacts 'stiffer'
    var float   ContactSoftness; // Softness of just contact constraints.
    var float   MaxPenetration; // Maximum penetration allowed.
    var float   MaxTimestep; // Maximum timestep ever used to advance rigid body simulation.
};

var(Karma) export editinline KarmaParamsCollision KParams; // Parameters for Karma Collision/Dynamics.
var const native int KStepTag;

var float AccumKarmaAngleError;

// endif

//-----------------------------------------------------------------------------
// Animation replication (can be used to replicate channel 0 anims for dumb proxies)
struct AnimRep
{
    var name AnimSequence;
    var bool bAnimLoop;
    var byte AnimRate;      // note that with compression, max replicated animrate is 4.0
    var byte AnimFrame;
    var byte TweenRate;     // note that with compression, max replicated tweentime is 4 seconds
};
var AnimRep       SimAnim;         // only replicated if bReplicateAnimations is true

//-----------------------------------------------------------------------------
// Forces.

enum EForceType
{
    FT_None,
    FT_DragAlong,
    FT_Constant,
};

var (Force) EForceType  ForceType;
var (Force) float       ForceRadius;
var (Force) float       ForceScale;
var (Force) float       ForceNoise; // sjs - 0.0 - 1.0


//-----------------------------------------------------------------------------
// Networking.

// Symmetric network flags, valid during replication only.
var const bool bNetInitial;       // Initial network update.
var const bool bNetOwner;         // Player owns this actor.
var const bool bNetRelevant;      // Actor is currently relevant. Only valid server side, only when replicating variables.
var const bool bDemoRecording;    // True we are currently demo recording
var const bool bClientDemoRecording;// True we are currently recording a client-side demo
var const bool bRepClientDemo;      // True if remote client is recording demo
var const bool bClientDemoNetFunc;// True if we're client-side demo recording and this call originated from the remote.
var const bool bDemoOwner;          // Demo recording driver owns this actor.
var bool       bNoRepMesh;          // don't replicate mesh
var bool        bNotOnDedServer;    // destroy if on dedicated server and RemoteRole == ROLE_None (emitters, etc.)

var bool        bAlreadyPrecachedMaterials;
var bool        bAlreadyPrecachedMeshes;

//Editing flags
var(Advanced) bool        bHiddenEd;     // Is hidden during editing.
var(Advanced) bool        bHiddenEdGroup;// Is hidden by the group brower.
var(Advanced) bool        bDirectional;  // Actor shows direction arrow during editing.
var const bool            bSelected;     // Selected in UnrealEd.
var(Advanced) bool        bEdShouldSnap; // Snap to grid in editor.
var transient bool        bEdSnap;       // Should snap to grid in UnrealEd.
var transient const bool  bTempEditor;   // Internal UnrealEd.
var bool                  bObsolete;     // actor is obsolete - warn level designers to remove it
var(Collision) 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)
var transient bool        bPathTemp;     // Internal/path building
var bool                  bScriptInitialized; // set to prevent re-initializing of actors spawned during level startup
var(Advanced) bool        bLockLocation; // Prevent the actor from being moved in the editor.

var bool                bTraceWater;    // if true, trace() by this actor returns collisions with water volumes

var class<LocalMessage> MessageClass;

//-----------------------------------------------------------------------------
// Enums.

// Travelling from server to server.
enum ETravelType
{
    TRAVEL_Absolute,    // Absolute URL.
    TRAVEL_Partial,     // Partial (carry name, reset server).
    TRAVEL_Relative,    // Relative URL.
};


// double click move direction.
enum EDoubleClickDir
{
    DCLICK_None,
    DCLICK_Left,
    DCLICK_Right,
    DCLICK_Forward,
    DCLICK_Back,
    DCLICK_Active,
    DCLICK_Done
};

enum eKillZType
{
    KILLZ_None,
    KILLZ_Lava,
    KILLZ_Suicide
};


enum EFlagState
{
    FLAG_Home,
    FLAG_HeldFriendly,
    FLAG_HeldEnemy,
    FLAG_Down,
};

var(Display) float       OverlayTimer;          // sjs - set by server
var(Display) transient float       ClientOverlayTimer;    // sjs - client inital time count
var(Display) transient float       ClientOverlayCounter;  // sjs - current secs left to show overlay effect
var Material HighDetailOverlay; // if high detail mode, use this overlay when no other overlay is active

struct FireProperties
{
    var class<Ammunition> AmmoClass;
    var class<Projectile> ProjectileClass;
    var float WarnTargetPct;
    var float MaxRange;
    var bool bTossed;
    var bool bTrySplash;
    var bool bLeadTarget;
    var bool bInstantHit;
    var bool bInitialized;
};

//-----------------------------------------------------------------------------
// natives.

// Execute a console command in the context of the current level and game engine.
native function string ConsoleCommand( string Command, optional bool bWriteToLog );

// Copy the specified object's properties to the clipboard. The format generated is for pasting into the editor if it's an actor or into the defaultproperties block of a class if it isn't
native function CopyObjectToClipboard(Object Obj);

native function TextToSpeech( string Text, float Volume );

//-----------------------------------------------------------------------------
// Network replication.

replication
{
    // Location
    unreliable if ( (!bSkipActorPropertyReplication || bNetInitial) && bReplicateMovement
                    && (((RemoteRole == ROLE_AutonomousProxy) && bNetInitial)
                        || ((RemoteRole == ROLE_SimulatedProxy) && (bNetInitial || bUpdateSimulatedPosition) && ((Base == None) || Base.bWorldGeometry))
                        || ((RemoteRole == ROLE_DumbProxy) && ((Base == None) || Base.bWorldGeometry))) )
        Location;

    unreliable if ( (!bSkipActorPropertyReplication || bNetInitial) && bReplicateMovement
                    && ((DrawType == DT_Mesh) || (DrawType == DT_StaticMesh))
                    && (((RemoteRole == ROLE_AutonomousProxy) && bNetInitial)
                        || ((RemoteRole == ROLE_SimulatedProxy) && (bNetInitial || bUpdateSimulatedPosition) && ((Base == None) || Base.bWorldGeometry))
                        || ((RemoteRole == ROLE_DumbProxy) && ((Base == None) || Base.bWorldGeometry))) )
        Rotation;

    unreliable if ( (!bSkipActorPropertyReplication || bNetInitial) && bReplicateMovement
                    && RemoteRole<=ROLE_SimulatedProxy )
        Base,bOnlyDrawIfAttached;

    unreliable if( (!bSkipActorPropertyReplication || bNetInitial) && bReplicateMovement
                    && RemoteRole<=ROLE_SimulatedProxy && (Base != None) && !Base.bWorldGeometry)
        RelativeRotation, RelativeLocation, AttachmentBone;

    // Physics
    unreliable if( (!bSkipActorPropertyReplication || bNetInitial) && bReplicateMovement
                    && (((RemoteRole == ROLE_SimulatedProxy) && (bNetInitial || bUpdateSimulatedPosition))
                        || ((RemoteRole == ROLE_DumbProxy) && (Physics == PHYS_Falling))) )
        Velocity;

    unreliable if( (!bSkipActorPropertyReplication || bNetInitial) && bReplicateMovement
                    && (((RemoteRole == ROLE_SimulatedProxy) && bNetInitial)
                        || (RemoteRole == ROLE_DumbProxy)) )
        Physics;

    unreliable if( (!bSkipActorPropertyReplication || bNetInitial) && bReplicateMovement
                    && (RemoteRole <= ROLE_SimulatedProxy) && (Physics == PHYS_Rotating) )
        bFixedRotationDir, bRotateToDesired, RotationRate, DesiredRotation;

    // Ambient sound.
    unreliable if( (!bSkipActorPropertyReplication || bNetInitial) && (Role==ROLE_Authority) && (!bNetOwner || !bClientAnim) )
        AmbientSound;

    unreliable if( (!bSkipActorPropertyReplication || bNetInitial) && (Role==ROLE_Authority) && (!bNetOwner || !bClientAnim)
                    && (AmbientSound!=None) )
        SoundRadius, SoundVolume, SoundPitch;

    // Animation.
    unreliable if( (!bSkipActorPropertyReplication || bNetInitial)
                && (Role==ROLE_Authority) && (DrawType==DT_Mesh) && bReplicateAnimations )
        SimAnim;

    unreliable if ( (!bSkipActorPropertyReplication || bNetInitial) && (Role==ROLE_Authority) )
        bHidden;

    // Properties changed using accessor functions (Owner, rendering, and collision)
    unreliable if ( (!bSkipActorPropertyReplication || bNetInitial) && (Role==ROLE_Authority) && bNetDirty )
        DrawScale, DrawType, bCollideActors,bCollideWorld,bOnlyOwnerSee,Texture,Style, RepSkin, bClientTrigger;

    unreliable if ( (!bSkipActorPropertyReplication || bNetInitial) && (Role==ROLE_Authority) && bNetDirty
                    && (bCollideActors || bCollideWorld) )
        bProjTarget, bBlockActors, CollisionRadius, CollisionHeight, bIgnoreEncroachers;

    // Properties changed only when spawning or in script (relationships, rendering, lighting)
    unreliable if ( (!bSkipActorPropertyReplication || bNetInitial) && (Role==ROLE_Authority) )
        Role,RemoteRole,bNetOwner,LightType,bTearOff;

    unreliable if ( (!bSkipActorPropertyReplication || bNetInitial) && (Role==ROLE_Authority)
                    && bNetDirty && bNetOwner )
        Owner, Inventory;

    unreliable if ( (!bSkipActorPropertyReplication || bNetInitial) && (Role==ROLE_Authority)
                    && bNetDirty && bReplicateInstigator )
        Instigator;

    unreliable if (bNetDirty && Role==ROLE_Authority)
        OverlayMaterial, OverlayTimer;

    // Infrequently changed mesh properties
    unreliable if ( (!bSkipActorPropertyReplication || bNetInitial) && (Role==ROLE_Authority)
                    && bNetDirty && (DrawType == DT_Mesh) )
        AmbientGlow,bUnlit,PrePivot;

    unreliable if ( (!bSkipActorPropertyReplication || bNetInitial) && (Role==ROLE_Authority)
                    && bNetDirty && !bNoRepMesh && (DrawType == DT_Mesh) )
        Mesh;

    unreliable if ( (!bSkipActorPropertyReplication || bNetInitial) && (Role==ROLE_Authority)
                && bNetDirty && (DrawType == DT_StaticMesh) )
        StaticMesh;

    // Infrequently changed lighting properties.
    unreliable if ( (!bSkipActorPropertyReplication || bNetInitial) && (Role==ROLE_Authority)
                    && bNetDirty && (LightType != LT_None) )
        LightEffect, LightBrightness, LightHue, LightSaturation,
        LightRadius, LightPeriod, LightPhase, bSpecialLit;

    // replicated functions
    unreliable if( bDemoRecording )
        DemoPlaySound;
}

//=============================================================================
// Actor error handling.

// Handle an error and kill this one actor.
native(233) final function Error( coerce string S );

// check if class has HideDropDown specifier
native final static function bool ShouldBeHidden();

//=============================================================================
// General functions.

// Latent functions.
native(256) final latent function Sleep( float Seconds );

// Collision.
native(262) final function SetCollision( optional bool NewColActors, optional bool NewBlockActors, optional bool NewBlockPlayers ); // NOTE - bBlockPlayers is obsolete
native(283) final function bool SetCollisionSize( float NewRadius, float NewHeight );
native final function SetDrawScale(float NewScale);
native final function SetDrawScale3D(vector NewScale3D);
native final function SetStaticMesh(StaticMesh NewStaticMesh);
native final function SetDrawType(EDrawType NewDrawType);

// Movement.
native(266) final function bool Move( vector Delta );
native(267) final function bool SetLocation( vector NewLocation );
native(299) final function bool SetRotation( rotator NewRotation );

// SetRelativeRotation() sets the rotation relative to the actor's base
native final function bool SetRelativeRotation( rotator NewRotation );
native final function bool SetRelativeLocation( vector NewLocation );

native(3969) final function bool MoveSmooth( vector Delta );
native(3971) final function AutonomousPhysics(float DeltaSeconds);

// Relations.
native(298) final function SetBase( actor NewBase, optional vector NewFloor );
native(272) final function SetOwner( actor NewOwner );
native final function bool IsJoinedTo( actor Other );

//=============================================================================
// Animation.

native final function string GetMeshName();

// Animation functions.
native(259) final function bool PlayAnim( name Sequence, optional float Rate, optional float TweenTime, optional int Channel );
native(260) final function bool LoopAnim( name Sequence, optional float Rate, optional float TweenTime, optional int Channel );
native(294) final function bool TweenAnim( name Sequence, float Time, optional int Channel );
native(282) final function bool IsAnimating(optional int Channel);
native(261) final latent function FinishAnim(optional int Channel);
native(263) final function bool HasAnim( name Sequence );
native final function StopAnimating( optional bool ClearAllButBase );
native final function FreezeAnimAt( float Time, optional int Channel);
native final function SetAnimFrame( float Time, optional int Channel, optional int UnitFlag );

native final function bool IsTweening(int Channel);
native final function AnimStopLooping(optional int Channel); // jjs

// ifdef WITH_LIPSINC
native final function PlayLIPSincAnim(
    name                LIPSincAnimName,
    optional float      Volume,
    optional float      Radius,
    optional float      Pitch
);

native final function StopLIPSincAnim();

native final function bool HasLIPSincAnim( name LIPSincAnimName );
native final function bool IsPlayingLIPSincAnim();
native final function string CurrentLIPSincAnim();

// LIPSinc Animation notifications.
event LIPSincAnimEnd();
// endif

// Animation notifications.
event AnimEnd( int Channel );
native final function EnableChannelNotify ( int Channel, int Switch );
native final function int GetNotifyChannel();

// Skeletal animation.
simulated native final function LinkSkelAnim( MeshAnimation Anim, optional mesh NewMesh );
simulated native final function LinkMesh( mesh NewMesh, optional bool bKeepAnim );
native final function BoneRefresh();

native final function AnimBlendParams( int Stage, optional float BlendAlpha, optional float InTime, optional float OutTime, optional name BoneName, optional bool bGlobalPose);
native final function AnimBlendToAlpha( int Stage, float TargetAlpha, float TimeInterval );

native final function coords  GetBoneCoords(   name BoneName );
native final function rotator GetBoneRotation( name BoneName, optional int Space );

native final function vector  GetRootLocation();
native final function rotator GetRootRotation();
native final function vector  GetRootLocationDelta();
native final function rotator GetRootRotationDelta();

native final function bool  AttachToBone( actor Attachment, name BoneName );
native final function bool  DetachFromBone( actor Attachment );

native final function LockRootMotion( int Lock );
native final function SetBoneScale( int Slot, optional float BoneScale, optional name BoneName );

native final function SetBoneDirection( name BoneName, rotator BoneTurn, optional vector BoneTrans, optional float Alpha, optional int Space );
native final function SetBoneLocation( name BoneName, optional vector BoneTrans, optional float Alpha );
native final simulated function SetBoneRotation( name BoneName, optional rotator BoneTurn, optional int Space, optional float Alpha );
native final function GetAnimParams( int Channel, out name OutSeqName, out float OutAnimFrame, out float OutAnimRate );
native final function bool AnimIsInGroup( int Channel, name GroupName );
native final function Name GetClosestBone( Vector loc, Vector ray, out float boneDist, optional Name BiasBone, optional float BiasDistance ); // sjs
// gam ---
native final function UpdateURL(string NewOption, string NewValue, bool bSaveDefault);
native final function string GetUrlOption(string Option);
// --- gam

//=========================================================================
// Rendering.

native final function plane GetRenderBoundingSphere();
native final function DrawDebugLine( vector LineStart, vector LineEnd, byte R, byte G, byte B); // SLOW! Use for debugging only!
native final function DrawStayingDebugLine( vector LineStart, vector LineEnd, byte R, byte G, byte B); // SLOW! Use for debugging only!
native final function DrawDebugCircle( vector Base, vector X, vector Y, float Radius, int NumSides, byte R, byte G, byte B); // SLOW! Use for debugging only!
native final function DrawDebugSphere( vector Base, float Radius, int NumDivisions, byte R, byte G, byte B); // SLOW! Use for debugging only!
native final function ClearStayingDebugLines();

//=========================================================================
// Physics.

native final function DebugClock();
native final function DebugUnclock();

// Physics control.
native(301) final latent function FinishInterpolation();
native(3970) final function SetPhysics( EPhysics newPhysics );

native final function OnlyAffectPawns(bool B);

// ifdef WITH_KARMA

// NB. These take affect until you quit the game! Make sure you reset them to defaults when leaving mod etc.
native final function KGetSimParams(out KSimParams SimParams);
native final function KSetSimParams(KSimParams SimParams);

native final function quat KGetRBQuaternion();

native final function KGetRigidBodyState(out KRigidBodyState RBstate);
native final function KDrawRigidBodyState(KRigidBodyState RBState, bool AltColour); // SLOW! Use for debugging only!
native final function vector KRBVecToVector(KRBVec RBvec);
native final function KRBVec KRBVecFromVector(vector v);

native final function KSetMass( float mass );
native final function float KGetMass();

// Set inertia tensor assuming a mass of 1. Scaled by mass internally to calculate actual inertia tensor.
native final function KSetInertiaTensor( vector it1, vector it2 );
native final function KGetInertiaTensor( out vector it1, out vector it2 );

native final function KSetDampingProps( float lindamp, float angdamp );
native final function KGetDampingProps( out float lindamp, out float angdamp );

native final function KSetFriction( float friction );
native final function float KGetFriction();

native final function KSetRestitution( float rest );
native final function float KGetRestitution();

native final function KSetCOMOffset( vector offset );
native final function KGetCOMOffset( out vector offset );
native final function KGetCOMPosition( out vector pos ); // get actual position of actors COM in world space

native final function KSetImpactThreshold( float thresh );
native final function float KGetImpactThreshold();

native final function KWake();
native final function bool KIsAwake();
native final function KAddImpulse( vector Impulse, vector Position, optional name BoneName ); // A position of (0,0,0) applies impulse at COM (ie no angular component)
native final function KAddAngularImpulse( vector AngImpulse );

native final function KSetStayUpright( bool stayUpright, bool allowRotate );
native final function KSetStayUprightParams( float stiffness, float damping );

native final function KSetBlockKarma( bool newBlock );

native final function KSetActorGravScale( float ActorGravScale );
native final function float KGetActorGravScale();

// Disable/Enable Karma contact generation between this actor, and another actor.
// Collision is on by default.
native final function KDisableCollision( actor Other );
native final function KEnableCollision( actor Other );

// Ragdoll-specific functions
native final function KSetSkelVel( vector Velocity, optional vector AngVelocity, optional bool AddToCurrent );
native final function float KGetSkelMass();
native final function KFreezeRagdoll();
native final function KScaleJointLimits(float scale, float stiffness);

// You MUST turn collision off (KSetBlockKarma) before using bone lifters!
native final function KAddBoneLifter( name BoneName, InterpCurve LiftVel, float LateralFriction, InterpCurve Softness );
native final function KRemoveLifterFromBone( name BoneName );
native final function KRemoveAllBoneLifters();

// Used for only allowing a fixed maximum number of ragdolls in action.
native final function KMakeRagdollAvailable();
native final function bool KIsRagdollAvailable();

// event called when Karmic actor hits with impact velocity over KImpactThreshold
event KImpact(actor other, vector pos, vector impactVel, vector impactNorm);

// event called when karma actor's velocity drops below KVelDropBelowThreshold;
event KVelDropBelow();

// event called when a ragdoll convulses (see KarmaParamsSkel)
event KSkelConvulse();

// event called just before sim to allow user to
// NOTE: you should ONLY put numbers into Force and Torque during this event!!!!
event KApplyForce(out vector Force, out vector Torque);

// This is called from inside C++ physKarma at the appropriate time to update state of Karma rigid body.
// If you return true, newState will be set into the rigid body. Return false and it will do nothing.
event bool KUpdateState(out KRigidBodyState newState);

// endif

// Timing
native final function Clock(out float time);
native final function UnClock(out float time);

//=========================================================================
// Music

native final function AllowMusicPlayback( bool Allow );

// used for playing custom music - not cached, and will not be stopped at level transition
// Song parameter must contain extension, but can be relative or absolute directory
// ex: PlayStream("D:\\alongtheway.mp3",false,1,0,0);
native final function int  PlayStream(   string Song, optional bool  UseMusicVolume, optional float Volume, optional float FadeInTime, optional float SeekTime );
native final function      StopStream(   int Handle,  optional float FadeOutTime );
native final function int  SeekStream(   int Handle,           float Seconds     );
native final function bool AdjustVolume( int Handle,           float NewVolume   );
native final function bool PauseStream(  int Handle                              );

// only used for level music - will be stopped when level changes
// Song parameter should not include extension (assumes .ogg)
native final function int PlayMusic( string Song, optional float FadeInTime );

native final function StopMusic( int SongHandle, optional float FadeOutTime );
native final function StopAllMusic( optional float FadeOutTime );


//=========================================================================
// Engine notification functions.

//
// Major notifications.
//
event Destroyed();
event GainedChild( Actor Other );
event LostChild( Actor Other );
event Tick( float DeltaTime );
event PostNetReceive();
event ClientTrigger();      // called on client whenever bClientTrigger changes values

//
// Triggers.
//
event Trigger( Actor Other, Pawn EventInstigator );
event UnTrigger( Actor Other, Pawn EventInstigator );
event BeginEvent();
event EndEvent();

//
// Physics & world interaction.
//

// Since Volumes are static, VolumeTimer can be used to get timer notifications (1sec steps)
// Laurent -- Moved from Volume to Actor.
simulated function TimerPop(VolumeTimer T);

event Timer();
event HitWall( vector HitNormal, actor HitWall );
event Falling();
event Landed( vector HitNormal );
event ZoneChange( ZoneInfo NewZone );
event PhysicsVolumeChange( PhysicsVolume NewVolume );
event Touch( Actor Other );
event PostTouch( Actor Other ); // called for PendingTouch actor after physics completes
event UnTouch( Actor Other );
event Bump( Actor Other );
event BaseChange();
event Attach( Actor Other );
event Detach( Actor Other );
event Actor SpecialHandling(Pawn Other);
event bool EncroachingOn( actor Other );
event EncroachedBy( actor Other );
event RanInto( Actor Other );   // called for encroaching actors which successfully moved the other actor out of the way
event FinishedInterpolation()
{
    bInterpolating = false;
}

event EndedRotation();          // called when rotation completes
event UsedBy( Pawn user ); // called if this Actor was touching a Pawn who pressed Use

simulated event FellOutOfWorld(eKillZType KillType)
{
    SetPhysics(PHYS_None);
    Destroy();
}

//
// Damage and kills.
//
event KilledBy( pawn EventInstigator );
event TakeDamage(int Damage, Pawn EventInstigator, vector HitLocation, vector Momentum, class<DamageType> DamageType);
function bool HealDamage(int Amount, Controller Healer, class<DamageType> DamageType);

//
// Trace a line and see what it collides with first.
// Takes this actor's collision properties into account.
// Returns first hit actor, Level if hit level, or None if hit nothing.
//
native(277) final function Actor Trace
(
    out vector      HitLocation,
    out vector      HitNormal,
    vector          TraceEnd,
    optional vector TraceStart,
    optional bool   bTraceActors,
    optional vector Extent,
    optional out material Material
);

// returns true if did not hit world geometry
native(548) final function bool FastTrace
(
    vector          TraceEnd,
    optional vector TraceStart
);

// Line check just against this actor.
// Returns true if did not hit this actor.
native final function bool TraceThisActor
(
 out vector      HitLocation,
 out vector      HitNormal,
 vector          TraceEnd,
 vector          TraceStart,
 optional vector Extent
);

//
// 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).
// Defaults to spawning at the spawner's location.
//
native(278) final function actor Spawn
(
    class<actor>      SpawnClass,
    optional actor    SpawnOwner,
    optional name     SpawnTag,
    optional vector   SpawnLocation,
    optional rotator  SpawnRotation
);

//
// Destroy this actor. Returns true if destroyed, false if indestructable.
// Destruction is latent. It occurs at the end of the tick.
//
native(279) final function bool Destroy();

// Networking - called on client when actor is torn off (bTearOff==true)
event TornOff();

//=============================================================================
// Timing.

// Causes Timer() events every NewTimerRate seconds.
native(280) final function SetTimer( float NewTimerRate, bool bLoop );

//=============================================================================
// Save Games

/* PreSaveGame() is called right before game is saved.
PostLoadSavedGame() is called right after a saved game is loaded.
*/
event PreSaveGame();
event PostLoadSavedGame();

//=============================================================================
// Sound functions.

/* Play a sound effect.
*/
native(264) final function 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, but don't propagate to a remote owner
 (he is playing the sound clientside)
 */
native simulated final function PlayOwnedSound
(
    sound               Sound,
    optional ESoundSlot Slot,
    optional float      Volume,
    optional bool       bNoOverride,
    optional float      Radius,
    optional float      Pitch,
    optional bool       Attenuate
);

native simulated event DemoPlaySound
(
    sound               Sound,
    optional ESoundSlot Slot,
    optional float      Volume,
    optional bool       bNoOverride,
    optional float      Radius,
    optional float      Pitch,
    optional bool       Attenuate
);

/* Get a sound duration.
*/
native final function float GetSoundDuration( sound Sound );

//=============================================================================
// Force Feedback.
// jdf ---
native(566) final function PlayFeedbackEffect( String EffectName );
native(567) final function StopFeedbackEffect( optional String EffectName ); // Pass no parameter or "" to stop all
native(568) final function ChangeSpringFeedbackEffect( String EffectName, float CenterX, float CenterY ); // 0, 0 is straight up
native(569) final function ChangeBaseParamsFeedbackEffect( String EffectName, optional float DirectionX, optional float DirectionY, optional float Gain ); // Direction range -1.0 to 1.0, Gain range 0.0 to 1.0
native final function bool ForceFeedbackSupported( optional bool Enable );
// --- jdf

//=============================================================================
// AI functions.

/* Inform other creatures that you've made a noise
 they might hear (they are sent a HearNoise message)
 Senders of MakeNoise should have an instigator if they are not pawns.
*/
native(512) final function MakeNoise( float Loudness );

/* PlayerCanSeeMe returns true if any player (server) or the local player (standalone
or client) has a line of sight to actor's location.
*/
native(532) final function bool PlayerCanSeeMe();

native final function vector SuggestFallVelocity(vector Destination, vector Start, float MaxZ, float MaxXYSpeed);

//=============================================================================
// Regular engine functions.

// Teleportation.
event bool PreTeleport( Teleporter InTeleporter );
event PostTeleport( Teleporter OutTeleporter );

// Level state.
event BeginPlay();

native final function ResetStaticFilterState(); // use when change rendering of bStatic actors

//Add PackageName to the packagemap (as if it was in GameEngine's ServerPackages list)
//If omitted, adds this actor's package
//This function is only valid during initialization (between GameInfo::InitGame() and GameInfo::SetInitialState())
//If called outside of that window, or anytime on a client, the function returns without doing anything
native final function AddToPackageMap(optional string PackageName);

//========================================================================
// Disk access.

// Find files.
native(539) final function string GetMapName( string NameEnding, string MapName, int Dir );
native(545) final function GetNextSkin( string Prefix, string CurrentSkin, int Dir, out string SkinName, out string SkinDesc );
native(547) final function string GetURLMap( optional bool bIncludeOptions );
native final function string GetNextInt( string ClassName, int Num );
native final function GetNextIntDesc( string ClassName, int Num, out string Entry, out string Description );

// Much faster versions of GetNextInt & GetNextIntDesc
native static final function GetAllInt( string MetaClass, array<string> Entries );
native static final function GetAllIntDesc( string MetaClass, out array<string> Entry, out array<string> Description );

native final function bool GetCacheEntry( int Num, out string GUID, out string Filename );
native final function bool MoveCacheEntry( string GUID, optional string NewFilename );

//=============================================================================
// Iterator functions.

// Iterator functions for dealing with sets of actors.

/* AllActors() - avoid using AllActors() too often as it iterates through the whole actor list and is therefore slow
*/
native(304) final iterator function AllActors     ( class<actor> BaseClass, out actor Actor, optional name MatchTag );

/* DynamicActors() only iterates through the non-static actors on the list (still relatively slow, bu
 much better than AllActors).  This should be used in most cases and replaces AllActors in most of
 Epic's game code.
*/
native(313) final iterator function DynamicActors     ( class<actor> BaseClass, out actor Actor, optional name MatchTag );

/* ChildActors() returns all actors owned by this actor.  Slow like AllActors()
*/
native(305) final iterator function ChildActors   ( class<actor> BaseClass, out actor Actor );

/* BasedActors() returns all actors based on the current actor (slow, like AllActors)
*/
native(306) final iterator function BasedActors   ( class<actor> BaseClass, out actor Actor );

/* TouchingActors() returns all actors touching the current actor (fast)
*/
native(307) final iterator function TouchingActors( class<actor> BaseClass, out actor Actor );

/* TraceActors() return all actors along a traced line.  Reasonably fast (like any trace)
*/
native(309) final iterator function TraceActors   ( class<actor> BaseClass, out actor Actor, out vector HitLoc, out vector HitNorm, vector End, optional vector Start, optional vector Extent );

/* 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)
*/
native(310) final iterator function RadiusActors  ( class<actor> BaseClass, out actor Actor, float Radius, optional vector Loc );

/* VisibleActors() 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.
Slow like AllActors(). Use VisibleCollidingActors() instead if desired actor types are in the collision hash (bCollideActors is true)
*/
native(311) final iterator function VisibleActors ( class<actor> BaseClass, out actor Actor, optional float Radius, optional vector Loc );

/* VisibleCollidingActors() 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.
Much faster than AllActors() since it uses the collision hash
*/
native(312) final iterator function VisibleCollidingActors ( class<actor> BaseClass, out actor Actor, float Radius, optional vector Loc, optional bool bIgnoreHidden );

/* CollidingActors() returns colliding (bCollideActors==true) actors within a certain radius.
Much faster than AllActors() for reasonably small radii since it uses the collision hash
*/
native(321) final iterator function CollidingActors ( class<actor> BaseClass, out actor Actor, float Radius, optional vector Loc );

//=============================================================================
// Color functions
native(549) static final operator(20) color -     ( color A, color B );
native(550) static final operator(16) color *     ( float A, color B );
native(551) static final operator(20) color +     ( color A, color B );
native(552) static final operator(16) color *     ( color A, float B );

//=============================================================================
// Scripted Actor functions.

event RecoverFromBadStateCode();

/* RenderOverlays()
called by player's hud to request drawing of actor specific overlays onto canvas
*/
function RenderOverlays(Canvas Canvas);

// RenderTexture
event RenderTexture(ScriptedTexture Tex);

//
// Called immediately before gameplay begins.
//
event PreBeginPlay()
{
    // Handle autodestruction if desired.
    if( !bGameRelevant && (Level.NetMode != NM_Client) && !Level.Game.BaseMutator.CheckRelevance(Self) )
        Destroy();
    else if ( (Level.DetailMode == DM_Low) && (CullDistance == Default.CullDistance) )
        CullDistance *= 0.8;
}

//
// Broadcast a localized message to all players.
// Most message deal with 0 to 2 related PRIs.
// The LocalMessage class defines how the PRI's and optional actor are used.
//
event BroadcastLocalizedMessage( class<LocalMessage> MessageClass, optional int Switch, optional PlayerReplicationInfo RelatedPRI_1, optional PlayerReplicationInfo RelatedPRI_2, optional Object OptionalObject )
{
    Level.Game.BroadcastLocalized( self, MessageClass, Switch, RelatedPRI_1, RelatedPRI_2, OptionalObject );
}

// Called immediately after gameplay begins.
//
event PostBeginPlay();

// Called after PostBeginPlay.
//
simulated event SetInitialState()
{
    bScriptInitialized = true;
    if( InitialState!='' )
        GotoState( InitialState );
    else
        GotoState( 'Auto' );
}

// called after PostBeginPlay.  On a net client, PostNetBeginPlay() is spawned after replicated variables have been initialized to
// their replicated values
event PostNetBeginPlay();

simulated function UpdatePrecacheMaterials()
{
    local int i;

    if ( Skins.Length > 0 )
        for ( i=0; i<Skins.Length; i++ )
            if ( Skins[i] != None )
                Level.AddPrecacheMaterial( Skins[i] );
}

simulated function UpdatePrecacheStaticMeshes()
{
    if ( (DrawType == DT_StaticMesh) && !bStatic && !bNoDelete )
        Level.AddPrecacheStaticMesh( StaticMesh );
}

/* OBSOLETE UpdateAnnouncements() - preload all announcer phrases used by this actor */
simulated function UpdateAnnouncements();

simulated function PrecacheAnnouncer(AnnouncerVoice V, bool bRewardSounds);

/* HurtRadius()
 Hurt locally authoritative actors within the radius.
*/
simulated function HurtRadius( float DamageAmount, float DamageRadius, class<DamageType> DamageType, float Momentum, vector HitLocation )
{
    local actor Victims;
    local float damageScale, dist;
    local vector dir;

    if( bHurtEntry )
        return;

    bHurtEntry = true;
    foreach VisibleCollidingActors( class 'Actor', Victims, DamageRadius, HitLocation )
    {
        // don't let blast damage affect fluid - VisibleCollisingActors doesn't really work for them - jag
        if( (Victims != self) && (Victims.Role == ROLE_Authority) && (!Victims.IsA('FluidSurfaceInfo')) )
        {
            dir = Victims.Location - HitLocation;
            dist = FMax(1,VSize(dir));
            dir = dir/dist;
            damageScale = 1 - FMax(0,(dist - Victims.CollisionRadius)/DamageRadius);
            Victims.TakeDamage
            (
                damageScale * DamageAmount,
                Instigator,
                Victims.Location - 0.5 * (Victims.CollisionHeight + Victims.CollisionRadius) * dir,
                (damageScale * Momentum * dir),
                DamageType
            );
            if (Instigator != None && Vehicle(Victims) != None && Vehicle(Victims).Health > 0)
                Vehicle(Victims).DriverRadiusDamage(DamageAmount, DamageRadius, Instigator.Controller, DamageType, Momentum, HitLocation);
        }
    }
    bHurtEntry = false;
}

function bool CheckForErrors()
{
    if ( bObsolete )
        log(self$" is Obsolete");
    return bObsolete;
}

// Called when carried onto a new level, before AcceptInventory.
//
event TravelPreAccept();

// Called when carried into a new level, after AcceptInventory.
//
event TravelPostAccept();

// Called by PlayerController when this actor becomes its ViewTarget.
//
function BecomeViewTarget();

// Called by PlayerController from on its current ViewTarget when its ViewTarget and/or bBehindView change
//
function POVChanged(PlayerController PC, bool bBehindViewChanged);

// Returns the human readable string representation of an object.
//
simulated function String GetHumanReadableName()
{
    return GetItemName(string(class));
}

// Set the display properties of an actor.  By setting them through this function, it allows
// the actor to modify other components (such as a Pawn's weapon) or to adjust the result
// based on other factors (such as a Pawn's other inventory wanting to affect the result)
function SetDisplayProperties(ERenderStyle NewStyle, Material NewTexture, bool bLighting )
{
    Style = NewStyle;
    texture = NewTexture;
    bUnlit = bLighting;
}

function SetDefaultDisplayProperties()
{
    Style = Default.Style;
    texture = Default.Texture;
    bUnlit = Default.bUnlit;
}

// Get localized message string associated with this actor
static function string GetLocalString(
    optional int Switch,
    optional PlayerReplicationInfo RelatedPRI_1,
    optional PlayerReplicationInfo RelatedPRI_2
    )
{
    return "";
}

function MatchStarting(); // called when gameplay actually starts
function SetGRI(GameReplicationInfo GRI);

function String GetDebugName()
{
    return GetItemName(string(self));
}

/* DisplayDebug()
list important actor variable on canvas.  HUD will call DisplayDebug() on the current ViewTarget when
the ShowDebug exec is used
*/
simulated function DisplayDebug(Canvas Canvas, out float YL, out float YPos)
{
    local string T;
    local float XL;
    local int i;
    local Actor A;
    local name anim;
    local float frame,rate;

    Canvas.Style = ERenderStyle.STY_Normal;
    Canvas.StrLen("TEST", XL, YL);
    YPos = YPos + YL;
    Canvas.SetPos(4,YPos);
    Canvas.SetDrawColor(255,0,0);
    T = GetDebugName();
    if ( bDeleteMe )
        T = T$" DELETED (bDeleteMe == true)";

    Canvas.DrawText(T, false);
    YPos += YL;
    Canvas.SetPos(4,YPos);
    Canvas.SetDrawColor(255,255,255);

    if ( Level.NetMode != NM_Standalone )
    {
        // networking attributes
        T = "ROLE ";
        Switch(Role)
        {
            case ROLE_None: T=T$"None"; break;
            case ROLE_DumbProxy: T=T$"DumbProxy"; break;
            case ROLE_SimulatedProxy: T=T$"SimulatedProxy"; break;
            case ROLE_AutonomousProxy: T=T$"AutonomousProxy"; break;
            case ROLE_Authority: T=T$"Authority"; break;
        }
        T = T$" REMOTE ROLE ";
        Switch(RemoteRole)
        {
            case ROLE_None: T=T$"None"; break;
            case ROLE_DumbProxy: T=T$"DumbProxy"; break;
            case ROLE_SimulatedProxy: T=T$"SimulatedProxy"; break;
            case ROLE_AutonomousProxy: T=T$"AutonomousProxy"; break;
            case ROLE_Authority: T=T$"Authority"; break;
        }
        if ( bTearOff )
            T = T$" Tear Off";
        Canvas.DrawText(T, false);
        YPos += YL;
        Canvas.SetPos(4,YPos);
    }
    T = "Physics ";
    Switch(PHYSICS)
    {
        case PHYS_None: T=T$"None"; break;
        case PHYS_Walking: T=T$"Walking"; break;
        case PHYS_Falling: T=T$"Falling"; break;
        case PHYS_Swimming: T=T$"Swimming"; break;
        case PHYS_Flying: T=T$"Flying"; break;
        case PHYS_Rotating: T=T$"Rotating"; break;
        case PHYS_Projectile: T=T$"Projectile"; break;
        case PHYS_Interpolating: T=T$"Interpolating"; break;
        case PHYS_MovingBrush: T=T$"MovingBrush"; break;
        case PHYS_Spider: T=T$"Spider"; break;
        case PHYS_Trailer: T=T$"Trailer"; break;
        case PHYS_Ladder: T=T$"Ladder"; break;
        case PHYS_Karma: T=T$"Karma"; break;
    }
    T = T$" in physicsvolume "$GetItemName(string(PhysicsVolume))$" on base "$GetItemName(string(Base));
    if ( bBounce )
        T = T$" - will bounce";
    Canvas.DrawText(T, false);
    YPos += YL;
    Canvas.SetPos(4,YPos);

    Canvas.DrawText("Location: "$Location$" Rotation "$Rotation, false);
    YPos += YL;
    Canvas.SetPos(4,YPos);
    Canvas.DrawText("Velocity: "$Velocity$" Speed "$VSize(Velocity)$" Speed2D "$VSize(Velocity-Velocity.Z*vect(0,0,1)), false);
    YPos += YL;
    Canvas.SetPos(4,YPos);
    Canvas.DrawText("Acceleration: "$Acceleration, false);
    YPos += YL;
    Canvas.SetPos(4,YPos);

    Canvas.DrawColor.B = 0;
    Canvas.DrawText("Collision Radius "$CollisionRadius$" Height "$CollisionHeight);
    YPos += YL;
    Canvas.SetPos(4,YPos);

    Canvas.DrawText("Collides with Actors "$bCollideActors$", world "$bCollideWorld$", proj. target "$bProjTarget);
    YPos += YL;
    Canvas.SetPos(4,YPos);
    Canvas.DrawText("Blocks Actors "$bBlockActors);
    YPos += YL;
    Canvas.SetPos(4,YPos);

    T = "Touching ";
    ForEach TouchingActors(class'Actor', A)
        T = T$GetItemName(string(A))$" ";
    if ( T == "Touching ")
        T = "Touching nothing";
    Canvas.DrawText(T, false);
    YPos += YL;
    Canvas.SetPos(4,YPos);

    Canvas.DrawColor.R = 0;
    T = "Rendered: ";
    Switch(Style)
    {
        case STY_None: T=T; break;
        case STY_Normal: T=T$"Normal"; break;
        case STY_Masked: T=T$"Masked"; break;
        case STY_Translucent: T=T$"Translucent"; break;
        case STY_Modulated: T=T$"Modulated"; break;
        case STY_Alpha: T=T$"Alpha"; break;
    }

    Switch(DrawType)
    {
        case DT_None: T=T$" None"; break;
        case DT_Sprite: T=T$" Sprite "; break;
        case DT_Mesh: T=T$" Mesh "; break;
        case DT_Brush: T=T$" Brush "; break;
        case DT_RopeSprite: T=T$" RopeSprite "; break;
        case DT_VerticalSprite: T=T$" VerticalSprite "; break;
        case DT_Terraform: T=T$" Terraform "; break;
        case DT_SpriteAnimOnce: T=T$" SpriteAnimOnce "; break;
        case DT_StaticMesh: T=T$" StaticMesh "; break;
    }

    if ( DrawType == DT_Mesh )
    {
        T = T$GetItemName(string(Mesh));
        if ( Skins.length > 0 )
        {
            T = T$" skins: ";
            for ( i=0; i<Skins.length; i++ )
            {
                if ( skins[i] == None )
                    break;
                else
                    T =T$GetItemName(string(skins[i]))$", ";
            }
        }

        Canvas.DrawText(T, false);
        YPos += YL;
        Canvas.SetPos(4,YPos);

        // mesh animation
        GetAnimParams(0,Anim,frame,rate);
        T = "AnimSequence "$Anim$" Frame "$frame$" Rate "$rate;
        if ( bAnimByOwner )
            T= T$" Anim by Owner";
    }
    else if ( (DrawType == DT_Sprite) || (DrawType == DT_SpriteAnimOnce) )
        T = T$Texture;
    else if ( DrawType == DT_Brush )
        T = T$Brush;

    Canvas.DrawText(T, false);
    YPos += YL;
    Canvas.SetPos(4,YPos);

    Canvas.DrawColor.B = 255;
    Canvas.DrawText("Tag: "$Tag$" Event: "$Event$" STATE: "$GetStateName(), false);
    YPos += YL;
    Canvas.SetPos(4,YPos);

    Canvas.DrawText("Instigator "$GetItemName(string(Instigator))$" Owner "$GetItemName(string(Owner)));
    YPos += YL;
    Canvas.SetPos(4,YPos);

    Canvas.DrawText("Timer: "$TimerCounter$" LifeSpan "$LifeSpan$" AmbientSound "$AmbientSound$" volume "$SoundVolume);
    YPos += YL;
    Canvas.SetPos(4,YPos);
}

// NearSpot() returns true is spot is within collision cylinder
simulated final function bool NearSpot(vector Spot)
{
    local vector Dir;

    Dir = Location - Spot;

    if ( abs(Dir.Z) > CollisionHeight )
        return false;

    Dir.Z = 0;
    return ( VSize(Dir) <= CollisionRadius );
}

simulated final function bool TouchingActor(Actor A)
{
    local vector Dir;

    Dir = Location - A.Location;

    if ( abs(Dir.Z) > CollisionHeight + A.CollisionHeight )
        return false;

    Dir.Z = 0;
    return ( VSize(Dir) <= CollisionRadius + A.CollisionRadius );
}

/* StartInterpolation()
when this function is called, the actor will start moving along an interpolation path
beginning at Dest
*/
simulated function StartInterpolation()
{
    GotoState('');
    SetCollision(True,false);
    bCollideWorld = False;
    bInterpolating = true;
    SetPhysics(PHYS_None);
}

/* Reset()
reset actor to initial state - used when restarting level without reloading.
*/
function Reset();

/*
Trigger an event
*/
simulated event TriggerEvent( Name EventName, Actor Other, Pawn EventInstigator )
{
    local Actor A;
    local NavigationPoint N;

    if ( EventName == '' )
        return;

    ForEach DynamicActors( class 'Actor', A, EventName )
        A.Trigger(Other, EventInstigator);

    For ( N=Level.NavigationPointList; N!=None; N=N.NextNavigationPoint )
        if ( N.bStatic && N.Tag == EventName )
            N.Trigger(Other, EventInstigator);
}

/*
Untrigger an event
*/
function UntriggerEvent( Name EventName, Actor Other, Pawn EventInstigator )
{
    local Actor A;
    local NavigationPoint N;

    if ( EventName == '' )
        return;

    ForEach DynamicActors( class 'Actor', A, EventName )
        A.Untrigger(Other, EventInstigator);
    For ( N=Level.NavigationPointList; N!=None; N=N.NextNavigationPoint )
        if ( N.bStatic && N.Tag == EventName )
            N.Untrigger(Other, EventInstigator);
}

function bool IsInVolume(Volume aVolume)
{
    local Volume V;

    ForEach TouchingActors(class'Volume',V)
        if ( V == aVolume )
            return true;
    return false;
}

function bool IsInPain()
{
    local PhysicsVolume V;

    ForEach TouchingActors(class'PhysicsVolume',V)
        if ( V.bPainCausing && (V.DamagePerSec > 0) )
            return true;
    return false;
}

function PlayTeleportEffect(bool bOut, bool bSound);

simulated function bool CanSplash()
{
    return false;
}

function vector GetCollisionExtent()
{
    local vector Extent;

    Extent = CollisionRadius * vect(1,1,0);
    Extent.Z = CollisionHeight;
    return Extent;
}

static function Crash()
{
    assert(false);
}

simulated function SetOverlayMaterial( Material mat, float time, bool bOverride )
{
    if (OverlayMaterial == None || OverlayMaterial == mat || bOverride)
    {
        OverlayMaterial = mat;
        if ( OverlayTimer == time )
            OverlayTimer = time + 0.001;
        else
            OverlayTimer = time;
        ClientOverlayTimer = OverlayTimer;
        ClientOverlayCounter = OverlayTimer;
        NetUpdateTime = Level.TimeSeconds - 1;
    }
}

simulated function bool CheckMaxEffectDistance(PlayerController P, vector SpawnLocation)
{
    return !P.BeyondViewDistance(SpawnLocation,0);
}

simulated function bool EffectIsRelevant(vector SpawnLocation, bool bForceDedicated )
{
    local PlayerController P;
    local bool bResult;

    if ( Level.NetMode == NM_DedicatedServer )
        return bForceDedicated;
    if ( Level.NetMode != NM_Client )
        bResult = true;
    else if ( (Instigator != None) && Instigator.IsHumanControlled() )
        return  true;
    else if ( SpawnLocation == Location )
        bResult = ( Level.TimeSeconds - LastRenderTime < 3 );
    else if ( (Instigator != None) && (Level.TimeSeconds - Instigator.LastRenderTime < 3) )
        bResult = true;
    if ( bResult )
    {
        P = Level.GetLocalPlayerController();

        if ( (P == None) || (P.ViewTarget == None) )
            bResult = false;
        else if ( P.Pawn == Instigator )
            bResult = CheckMaxEffectDistance(P, SpawnLocation);
        else if ( (Vector(P.Rotation) Dot (SpawnLocation - P.ViewTarget.Location)) < 0.0 )
            bResult = (VSize(P.ViewTarget.Location - SpawnLocation) < 1600);
        else
            bResult = CheckMaxEffectDistance(P, SpawnLocation);
    }
    return bResult;
}

function bool SelfTriggered()
{
    return false;
}

function bool TeamLink(int TeamNum)
{
    return false;
}

function SetDelayedDamageInstigatorController(Controller C);

function NotifyLocalPlayerDead(PlayerController PC);

// called only if bNotifyLocalPlayerTeamReceived and is a net client when local playercontroller receives PlayerReplicationInfo.Team
function NotifyLocalPlayerTeamReceived();

//for AI... bots have perfect aim shooting non-pawn stationary targets
function bool IsStationary()
{
    return true;
}

//this actor is based on a pawn and that pawn has just died
function PawnBaseDied();

function bool BlocksShotAt(Actor Other)
{
    return false;
}

defaultproperties
{
     DrawType=DT_Sprite
     bLightingVisibility=Wahr
     bAcceptsProjectors=Wahr
     bReplicateMovement=Wahr
     bDeferRendering=Wahr
     RemoteRole=ROLE_DumbProxy
     Role=ROLE_Authority
     NetUpdateFrequency=100.000000
     NetPriority=1.000000
     LODBias=1.000000
     Texture=Texture'Engine.S_Actor'
     DrawScale=1.000000
     DrawScale3D=(X=1.000000,Y=1.000000,Z=1.000000)
     MaxLights=4
     ScaleGlow=1.000000
     Style=STY_Normal
     bMovable=Wahr
     FluidSurfaceShootStrengthMod=1.000000
     SoundVolume=128
     SoundPitch=64
     SoundRadius=64.000000
     TransientSoundVolume=0.300000
     TransientSoundRadius=300.000000
     CollisionRadius=22.000000
     CollisionHeight=22.000000
     bBlockZeroExtentTraces=Wahr
     bBlockNonZeroExtentTraces=Wahr
     bSmoothKarmaStateUpdates=Wahr
     bJustTeleported=Wahr
     Mass=100.000000
     ForceNoise=0.500000
     MessageClass=Class'Engine.LocalMessage'
}