Engine.Actor

//=============================================================================
// Actor: The base class of all actors.
// 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 Flags=2

// DEUS_EX STM
enum EAIEventState
{
    EAISTATE_Begin,
    EAISTATE_End,
    EAISTATE_Pulse,
    EAISTATE_ChangeBest
};
enum EAIEventType
{
    EAITYPE_Visual,
    EAITYPE_Audio,
    EAITYPE_Olifactory
};
struct XAIParams
{
    var actor BestActor;
    var float Score;
    var float Visibility;
    var float Volume;
    var float Smell;
};

// DEUS_EX AJY 
enum EBarkModes 
{
    BM_Idle,
    BM_CriticalDamage,
    BM_AreaSecure,
    BM_TargetAcquired,
    BM_TargetLost,
    BM_GoingForAlarm,
    BM_OutOfAmmo,
    BM_Scanning,
    BM_Futz,
    BM_OnFire,
    BM_TearGas,
    BM_Gore,
    BM_Surprise,
    BM_PreAttackSearching,
    BM_PreAttackSighting,
    BM_PostAttackSearching,
    BM_SearchGiveUp,
    BM_AllianceHostile,
    BM_AllianceFriendly
};

// Flags.
var(Advanced) const bool  bStatic;       // Does not move or change over time.
var(Advanced) bool        bHidden;       // Is hidden during gameplay.
var(Advanced) const bool  bNoDelete;     // Cannot be deleted during play.
var bool                  bAnimFinished; // Unlooped animation sequence has finished.
var bool                  bAnimLoop;     // Whether animation is looping.
var bool                  bAnimNotify;   // Whether a notify is applied to the current sequence.
var bool                  bAnimByOwner;  // Animation dictated by owner.
var const bool            bDeleteMe;     // About to be deleted.
var transient const bool  bAssimilated;  // Actor dynamics are assimilated in world geometry.
var transient const bool  bTicked;       // Actor has been updated.
var transient bool        bLightChanged; // Recalculate this light's lighting now.
var bool                  bDynamicLight; // Temporarily treat this as a dynamic light.
var bool                  bTimerLoop;    // Timer loops (else is one-shot).

// Other flags.
var(Advanced) bool        bCanTeleport;  // This actor can be teleported.
var(Advanced) bool        bIsSecretGoal; // This actor counts in the "secret" total.
var(Advanced) bool        bIsKillGoal;   // This actor counts in the "death" toll.
var(Advanced) bool        bIsItemGoal;   // This actor counts in the "item" count.
var(Advanced) bool        bCollideWhenPlacing; // This actor collides with the world when placing.
var(Advanced) bool        bTravel;       // Actor is capable of travelling among servers.
var(Advanced) bool        bMovable;      // Actor is capable of travelling among servers.
var(Advanced) bool        bHighDetail;   // Only show up on high-detail.
var(Advanced) bool        bStasis;       // In StandAlone games, turn off if not in a recently rendered zone turned off if  bCanStasis  and physics = PHYS_None or PHYS_Rotating.
var(Advanced) bool        bForceStasis;  // Force stasis when not recently rendered, even if physics not none or rotating.
var const     bool        bIsPawn;       // True only for pawns.
var(Advanced) const bool  bNetTemporary; // Tear-off simulation in network play.
var(Advanced) const bool  bNetOptional;  // Actor should only be replicated if bandwidth available.
var           bool        bReplicateInstigator; // Replicate instigator to client (used by bNetTemporary projectiles).
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        bClientAnim;
var           bool        bSimFall;         // dumb proxy should simulate fall

// DEUS_EX STM - added new flags
var(Advanced) bool        bBlockSight;   // True if pawns can't see through this actor.
var(Advanced) bool        bDetectable;   // True if this actor can be detected (by sight, sound, etc).
var(Advanced) bool        bTransient;    // True if this actor should be destroyed when it goes into stasis
var           bool        bIgnore;       // True if this actor should be generally ignored; compliance is voluntary

// 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_Rolling,
    PHYS_Interpolating,
    PHYS_MovingBrush,
    PHYS_Spider,
    PHYS_Trailer
} 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 Role;
var(Networking) ENetRole RemoteRole;

// DEUS_EX STM - added for stasis
var float LastRenderTime;
var float DistanceFromPlayer;

// Owner.
var         const Actor   Owner;         // Owner actor.
var(Object) name InitialState;
var(Object) name Group;

// Execution and timer variables.
var float                 TimerRate;     // Timer event, 0=no timer.
var const float           TimerCounter;  // Counts up until it reaches TimerRate.
var(Advanced) float       LifeSpan;      // How old the object lives before dying, 0=forever.

// Animation variables.
var(Display) name         AnimSequence;  // Animation sequence we're playing.
var(Display) float        AnimFrame;     // Current animation frame, 0.0 to 1.0.
var(Display) float        AnimRate;      // Animation rate in frames per second, 0=none, negative=velocity scaled.
var          float        TweenRate;     // Tween-into rate.

var(Display) float        LODBias;

// Blending animation variables - DEUS_EX CNN
var name    BlendAnimSequence[4];
var float   BlendAnimFrame[4];
var float   BlendAnimRate[4];
var float   BlendTweenRate[4];

//-----------------------------------------------------------------------------
// 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 LevelInfo Level;         // Level this actor is on.
var transient const Level XLevel;        // Level object.
var(Events) name          Tag;           // Actor's tag name.
var(Events) name          Event;         // The event this actor causes.
var Actor                 Target;        // Actor we're aiming at (other uses as well).
var Pawn                  Instigator;    // Pawn responsible for damage.
var travel Inventory      Inventory;     // Inventory chain.  (DEUS_EX STM - added "travel")
var const Actor           Base;          // Moving brush actor we're standing on.
var const PointRegion     Region;        // Region this actor is in.
var(Movement)   name      AttachTag;

// Internal.
var const byte            StandingCount; // Count of actors standing on this actor.
var const byte            MiscNumber;    // Internal use.
var const byte            LatentByte;    // Internal latent function use.
var const int             LatentInt;     // Internal latent function use.
var const float           LatentFloat;   // Internal latent function use.
var const actor           LatentActor;   // Internal latent function use.
var const actor           Touching[4];   // List of touching actors.
var const actor           Deleted;       // Next actor in just-deleted chain.

// Internal tags.
var const transient int CollisionTag, LightingTag, NetTag, OtherTag, ExtraTag, SpecialTag;

// The actor's position and rotation.
var(Movement) const vector Location;     // Actor's location; use Move to set.
var(Movement) const rotator Rotation;    // Rotation.
var       const vector    OldLocation;   // Actor's old location one tick ago.
var       const vector    ColLocation;   // Actor's old location one move ago.
var(Movement) vector      Velocity;      // Velocity.
var       vector          Acceleration;  // Acceleration.

//Editing flags
var(Advanced) bool        bHiddenEd;     // Is hidden during editing.
var(Advanced) bool        bDirectional;  // Actor shows direction arrow during editing.
var const bool            bSelected;     // Selected in UnrealEd.
var const bool            bMemorized;    // Remembered in UnrealEd.
var const bool            bHighlighted;  // Highlighted in UnrealEd.
var bool                  bEdLocked;     // Locked in editor (no movement or rotation).
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.

// What kind of gameplay scenarios to appear in.
var(Filter) bool          bDifficulty0;  // Appear in difficulty 0.
var(Filter) bool          bDifficulty1;  // Appear in difficulty 1.
var(Filter) bool          bDifficulty2;  // Appear in difficulty 2.
var(Filter) bool          bDifficulty3;  // Appear in difficulty 3.
var(Filter) bool          bSinglePlayer; // Appear in single player.
var(Filter) bool          bNet;          // Appear in regular network play.
var(Filter) bool          bNetSpecial;   // Appear in special network play mode.
var(Filter) float         OddsOfAppearing; // 0-1 - chance actor will appear in relevant game modes.

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

// Drawing effect.
var(Display) enum EDrawType
{
    DT_None,
    DT_Sprite,
    DT_Mesh,
    DT_Brush,
    DT_RopeSprite,
    DT_VerticalSprite,
    DT_Terraform,
    DT_SpriteAnimOnce,
} DrawType;

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

// Other display properties.
var(Display) texture    Sprite;          // Sprite texture if DrawType=DT_Sprite.
var(Display) texture    Texture;         // Misc texture.
var(Display) texture    Skin;            // Special skin or enviro map texture.
var(Display) mesh       Mesh;            // Mesh if DrawType=DT_Mesh.
var const export model  Brush;           // Brush if DrawType=DT_Brush.
var(Display) float      DrawScale;       // Scaling factor, 1.0=normal size.
var          vector     PrePivot;        // Offset from box center for drawing.
var(Display) float      ScaleGlow;       // Multiplies lighting.
var(Display) byte       AmbientGlow;     // Ambient brightness, or 255=pulsing.
var(Display) byte       Fatness;         // Fatness (mesh distortion).

// Display.
var(Display)  bool      bUnlit;          // Lights don't affect actor.
var(Display)  bool      bNoSmooth;       // Don't smooth actor's texture.
var(Display)  bool      bParticles;      // Mesh is a particle system.
var(Display)  bool      bRandomFrame;    // Particles use a random texture from among the default texture and the multiskins textures
var(Display)  bool      bMeshEnviroMap;  // Environment-map the mesh.
var(Display)  bool      bMeshCurvy;      // Curvy mesh.
var(Display)  float     VisibilityRadius;// Actor is drawn if viewer is within its visibility
var(Display)  float     VisibilityHeight;// cylinder.  Zero=infinite visibility.

// Not yet implemented.
var(Display) bool       bShadowCast;     // Casts shadows.

// Advanced.
var(Advanced) bool      bOwnerNoSee;     // Everything but the owner can see this actor.
var(Advanced) bool      bOnlyOwnerSee;   // Only owner can see this actor.
var Const     bool      bIsMover;        // Is a mover.
var(Advanced) bool      bAlwaysRelevant; // Always relevant for network.
var Const     bool      bAlwaysTick;     // Update even when players-only.
var           bool      bHurtEntry;      // keep HurtRadius from being reentrant
var(Advanced) bool      bGameRelevant;   // Always relevant for game
var           bool      bCarriedItem;    // being carried, and not responsible for displaying self, so don't replicated location and rotation
var           bool      bForcePhysicsUpdate; // force a physics update for simulated pawns


// Multiple skin support.
var(Display) texture MultiSkins[8];

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

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

// Regular sounds.
var(Sound) float TransientSoundVolume;
var(Sound) float TransientSoundRadius;

// 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,
};

//-----------------------------------------------------------------------------
// 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(Collision) bool       bCollideWorld;    // Collides with the world.
var(Collision) bool       bBlockActors;     // Blocks other nonplayer actors.
var(Collision) bool       bBlockPlayers;    // Blocks other player actors.
var(Collision) bool       bProjTarget;      // Projectiles should potentially target this actor.

//-----------------------------------------------------------------------------
// 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
} 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_Unused
} LightEffect;

// Lighting info.
var(LightColor) byte
    LightBrightness,
    LightHue,
    LightSaturation;

// Light properties.
var(Lighting) byte
    LightRadius,
    LightPeriod,
    LightPhase,
    LightCone,
    VolumeBrightness,
    VolumeRadius,
    VolumeFog;

// 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       bLensFlare;     // Whether to use zone lens flare.

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

// Options.
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           bool        bInterpolating;    // Performing interpolating.
var           const bool  bJustTeleported;   // Used by engine physics - not valid for scripts.

// Dodge move direction.
var enum EDodgeDir
{
    DODGE_None,
    DODGE_Left,
    DODGE_Right,
    DODGE_Forward,
    DODGE_Back,
    DODGE_Active,
    DODGE_Done
} DodgeDir;

// 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 rotate pawn to this if bRotateToDesired.
var           float       PhysAlpha;       // Interpolating position, 0.0-1.0.
var           float       PhysRate;        // Interpolation rate per second.
var           Actor       PendingTouch;     // Actor touched during move which wants to add an effect after the movement completes 
//-----------------------------------------------------------------------------
// Animation.

// Animation control.
var          float        AnimLast;        // Last frame.
var          float        AnimMinRate;     // Minimum rate for velocity-scaled animation.
var          float        OldAnimRate;     // Animation rate of previous animation (= AnimRate until animation completes).
var          plane        SimAnim;         // replicated to simulated proxies.

// Blending Animation control - DEUS_EX CNN
var          float        BlendAnimLast[4];        // Last frame.
var          float        BlendAnimMinRate[4];     // Minimum rate for velocity-scaled animation.
var          float        OldBlendAnimRate[4];     // Animation rate of previous animation (= AnimRate until animation completes).
var          plane        SimBlendAnim[4];         // replicated to simulated proxies.

// Conversation Related Variables - DEUS_EX AJY
var(Conversation) String BindName;                  // Used to bind conversations
var(Conversation) String BarkBindName;              // Used to bind Barks!
var(Conversation) localized String FamiliarName;    // For display in Conversations
var(Conversation) localized String UnfamiliarName;  // For display in Conversations
var transient Object     ConListItems;              // List of ConListItems for this Actor
var travel   float       LastConEndTime;            // Time when last conversation ended
var(Conversation) float  ConStartInterval;          // Amount of time required between two convos.

// Additional variables for AI - DEUS_EX STM
var          float        VisUpdateTime;
var          float        CurrentVisibility;
var          float        LastVisibility;

var(Smell)   class<SmellNode> SmellClass;
var          SmellNode        LastSmellNode;

var(Advanced) bool            bOwned;
// End additional variables - DEUS_EX STM

// DEUS_EX AMSD Added to make vision aug run faster.  If true, the vision aug needs to check this object more closely.
// Used for heat sources as well as things that blind.
var bool bVisionImportant;

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

// Network control.
var(Networking) float NetPriority; // Higher priorities means update it more frequently.
var(Networking) float NetUpdateFrequency; // How many seconds between net updates.
var(Networking) float RelevantRadius; //Radius in which things are always relevant.

// 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 bNetSee;           // Player sees it in network play.
var const bool bNetHear;          // Player hears it in network play.
var const bool bNetFeel;          // Player collides with/feels it in network play.
var const bool bSimulatedPawn;    // True if Pawn and simulated proxy.
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 bClientDemoNetFunc;// True if we're client-side demo recording and this call originated from the remote.


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

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

// Input system states.
enum EInputAction
{
    IST_None,    // Not performing special input processing.
    IST_Press,   // Handling a keypress or button press.
    IST_Hold,    // Handling holding a key or button.
    IST_Release, // Handling a key or button release.
    IST_Axis,    // Handling analog axis movement.
};

// Input keys.
enum EInputKey
{
/*00*/  IK_None         ,IK_LeftMouse   ,IK_RightMouse  ,IK_Cancel      ,
/*04*/  IK_MiddleMouse  ,IK_Unknown05   ,IK_Unknown06   ,IK_Unknown07   ,
/*08*/  IK_Backspace    ,IK_Tab         ,IK_Unknown0A   ,IK_Unknown0B   ,
/*0C*/  IK_Unknown0C    ,IK_Enter       ,IK_Unknown0E   ,IK_Unknown0F   ,
/*10*/  IK_Shift        ,IK_Ctrl        ,IK_Alt         ,IK_Pause       ,
/*14*/  IK_CapsLock     ,IK_Unknown15   ,IK_Unknown16   ,IK_Unknown17   ,
/*18*/  IK_Unknown18    ,IK_Unknown19   ,IK_Unknown1A   ,IK_Escape      ,
/*1C*/  IK_Unknown1C    ,IK_Unknown1D   ,IK_Unknown1E   ,IK_Unknown1F   ,
/*20*/  IK_Space        ,IK_PageUp      ,IK_PageDown    ,IK_End         ,
/*24*/  IK_Home         ,IK_Left        ,IK_Up          ,IK_Right       ,
/*28*/  IK_Down         ,IK_Select      ,IK_Print       ,IK_Execute     ,
/*2C*/  IK_PrintScrn    ,IK_Insert      ,IK_Delete      ,IK_Help        ,
/*30*/  IK_0            ,IK_1           ,IK_2           ,IK_3           ,
/*34*/  IK_4            ,IK_5           ,IK_6           ,IK_7           ,
/*38*/  IK_8            ,IK_9           ,IK_Unknown3A   ,IK_Unknown3B   ,
/*3C*/  IK_Unknown3C    ,IK_Unknown3D   ,IK_Unknown3E   ,IK_Unknown3F   ,
/*40*/  IK_Unknown40    ,IK_A           ,IK_B           ,IK_C           ,
/*44*/  IK_D            ,IK_E           ,IK_F           ,IK_G           ,
/*48*/  IK_H            ,IK_I           ,IK_J           ,IK_K           ,
/*4C*/  IK_L            ,IK_M           ,IK_N           ,IK_O           ,
/*50*/  IK_P            ,IK_Q           ,IK_R           ,IK_S           ,
/*54*/  IK_T            ,IK_U           ,IK_V           ,IK_W           ,
/*58*/  IK_X            ,IK_Y           ,IK_Z           ,IK_Unknown5B   ,
/*5C*/  IK_Unknown5C    ,IK_Unknown5D   ,IK_Unknown5E   ,IK_Unknown5F   ,
/*60*/  IK_NumPad0      ,IK_NumPad1     ,IK_NumPad2     ,IK_NumPad3     ,
/*64*/  IK_NumPad4      ,IK_NumPad5     ,IK_NumPad6     ,IK_NumPad7     ,
/*68*/  IK_NumPad8      ,IK_NumPad9     ,IK_GreyStar    ,IK_GreyPlus    ,
/*6C*/  IK_Separator    ,IK_GreyMinus   ,IK_NumPadPeriod,IK_GreySlash   ,
/*70*/  IK_F1           ,IK_F2          ,IK_F3          ,IK_F4          ,
/*74*/  IK_F5           ,IK_F6          ,IK_F7          ,IK_F8          ,
/*78*/  IK_F9           ,IK_F10         ,IK_F11         ,IK_F12         ,
/*7C*/  IK_F13          ,IK_F14         ,IK_F15         ,IK_F16         ,
/*80*/  IK_F17          ,IK_F18         ,IK_F19         ,IK_F20         ,
/*84*/  IK_F21          ,IK_F22         ,IK_F23         ,IK_F24         ,
/*88*/  IK_Unknown88    ,IK_Unknown89   ,IK_Unknown8A   ,IK_Unknown8B   ,
/*8C*/  IK_Unknown8C    ,IK_Unknown8D   ,IK_Unknown8E   ,IK_Unknown8F   ,
/*90*/  IK_NumLock      ,IK_ScrollLock  ,IK_Unknown92   ,IK_Unknown93   ,
/*94*/  IK_Unknown94    ,IK_Unknown95   ,IK_Unknown96   ,IK_Unknown97   ,
/*98*/  IK_Unknown98    ,IK_Unknown99   ,IK_Unknown9A   ,IK_Unknown9B   ,
/*9C*/  IK_Unknown9C    ,IK_Unknown9D   ,IK_Unknown9E   ,IK_Unknown9F   ,
/*A0*/  IK_LShift       ,IK_RShift      ,IK_LControl    ,IK_RControl    ,
/*A4*/  IK_UnknownA4    ,IK_UnknownA5   ,IK_UnknownA6   ,IK_UnknownA7   ,
/*A8*/  IK_UnknownA8    ,IK_UnknownA9   ,IK_UnknownAA   ,IK_UnknownAB   ,
/*AC*/  IK_UnknownAC    ,IK_UnknownAD   ,IK_UnknownAE   ,IK_UnknownAF   ,
/*B0*/  IK_UnknownB0    ,IK_UnknownB1   ,IK_UnknownB2   ,IK_UnknownB3   ,
/*B4*/  IK_UnknownB4    ,IK_UnknownB5   ,IK_UnknownB6   ,IK_UnknownB7   ,
/*B8*/  IK_UnknownB8    ,IK_UnknownB9   ,IK_Semicolon   ,IK_Equals      ,
/*BC*/  IK_Comma        ,IK_Minus       ,IK_Period      ,IK_Slash       ,
/*C0*/  IK_Tilde        ,IK_UnknownC1   ,IK_UnknownC2   ,IK_UnknownC3   ,
/*C4*/  IK_UnknownC4    ,IK_UnknownC5   ,IK_UnknownC6   ,IK_UnknownC7   ,
/*C8*/  IK_Joy1         ,IK_Joy2        ,IK_Joy3        ,IK_Joy4        ,
/*CC*/  IK_Joy5         ,IK_Joy6        ,IK_Joy7        ,IK_Joy8        ,
/*D0*/  IK_Joy9         ,IK_Joy10       ,IK_Joy11       ,IK_Joy12       ,
/*D4*/  IK_Joy13        ,IK_Joy14       ,IK_Joy15       ,IK_Joy16       ,
/*D8*/  IK_UnknownD8    ,IK_UnknownD9   ,IK_UnknownDA   ,IK_LeftBracket ,
/*DC*/  IK_Backslash    ,IK_RightBracket,IK_SingleQuote ,IK_UnknownDF   ,
/*E0*/  IK_JoyX         ,IK_JoyY        ,IK_JoyZ        ,IK_JoyR        ,
/*E4*/  IK_MouseX       ,IK_MouseY      ,IK_MouseZ      ,IK_MouseW      ,
/*E8*/  IK_JoyU         ,IK_JoyV        ,IK_UnknownEA   ,IK_UnknownEB   ,
/*EC*/  IK_MouseWheelUp ,IK_MouseWheelDown,IK_Unknown10E,UK_Unknown10F  ,
/*F0*/  IK_JoyPovUp     ,IK_JoyPovDown  ,IK_JoyPovLeft  ,IK_JoyPovRight ,
/*F4*/  IK_UnknownF4    ,IK_UnknownF5   ,IK_Attn        ,IK_CrSel       ,
/*F8*/  IK_ExSel        ,IK_ErEof       ,IK_Play        ,IK_Zoom        ,
/*FC*/  IK_NoName       ,IK_PA1         ,IK_OEMClear
};

var(Display) class<RenderIterator> RenderIteratorClass; // class to instantiate as the actor's RenderInterface
var transient RenderIterator RenderInterface;       // abstract iterator initialized in the Rendering engine

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

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


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

replication
{
    // Relationships.
    unreliable if( Role==ROLE_Authority )
        Owner, Role, RemoteRole;
    unreliable if( bNetOwner && Role==ROLE_Authority )
        bNetOwner, Inventory;
    unreliable if( bReplicateInstigator && (RemoteRole>=ROLE_SimulatedProxy) && (Role==ROLE_Authority) )
        Instigator;

    // Ambient sound.
    unreliable if( (Role==ROLE_Authority) && (!bNetOwner || !bClientAnim) )
        AmbientSound;
    unreliable if( AmbientSound!=None && Role==ROLE_Authority  && (!bNetOwner || !bClientAnim) )
        SoundRadius, SoundVolume, SoundPitch;
    unreliable if( bDemoRecording )
        DemoPlaySound;

    // Collision.
    unreliable if( Role==ROLE_Authority )
        bCollideActors, bCollideWorld;
    unreliable if( (bCollideActors || bCollideWorld) && Role==ROLE_Authority )
        bProjTarget, bBlockActors, bBlockPlayers, CollisionRadius, CollisionHeight;

    // Location.
    unreliable if( !bCarriedItem && (bNetInitial || bSimulatedPawn || RemoteRole<ROLE_SimulatedProxy) && Role==ROLE_Authority )
        Location;
    unreliable if( !bCarriedItem && (DrawType==DT_Mesh || DrawType==DT_Brush) && (bNetInitial || bSimulatedPawn || RemoteRole<ROLE_SimulatedProxy) && Role==ROLE_Authority )
        Rotation;
    unreliable if( RemoteRole==ROLE_SimulatedProxy )
        Base;

   // Events
   unreliable if( Role==ROLE_authority)
      Event, Tag;

    // Velocity.
    unreliable if( bSimFall || ((RemoteRole==ROLE_SimulatedProxy && (bNetInitial || bSimulatedPawn)) || bIsMover) )
        Velocity;

    // Physics.
    unreliable if( bSimFall || (RemoteRole==ROLE_SimulatedProxy && bNetInitial && !bSimulatedPawn) )
        Physics, Acceleration, bBounce;
    unreliable if( RemoteRole==ROLE_SimulatedProxy && Physics==PHYS_Rotating && bNetInitial )
        bFixedRotationDir, bRotateToDesired, RotationRate, DesiredRotation;

    // Animation. 
    unreliable if( DrawType==DT_Mesh && ((RemoteRole<=ROLE_SimulatedProxy && (!bNetOwner || !bClientAnim)) || bDemoRecording) )
        AnimSequence, BlendAnimSequence;                        // blended anims added - DEUS_EX CNN
    unreliable if( DrawType==DT_Mesh && (RemoteRole==ROLE_SimulatedProxy))
        bAnimNotify;
    unreliable if( DrawType==DT_Mesh && (RemoteRole<ROLE_SimulatedProxy))
        SimAnim, AnimMinRate, SimBlendAnim, BlendAnimMinRate;   // blended anims added - DEUS_EX CNN


    // Rendering.
    unreliable if( Role==ROLE_Authority )
        bHidden, bOnlyOwnerSee;
    unreliable if( Role==ROLE_Authority )
        Texture, DrawScale, PrePivot, DrawType, AmbientGlow, Fatness, ScaleGlow, bUnlit, Style;
    unreliable if( DrawType==DT_Sprite && !bHidden && (!bOnlyOwnerSee || bNetOwner) && Role==ROLE_Authority)
        Sprite;
    unreliable if( DrawType==DT_Mesh && Role==ROLE_Authority )
        Mesh, bMeshEnviroMap, Skin, MultiSkins;
    unreliable if( DrawType==DT_Brush && Role==ROLE_Authority )
        Brush;

    // Lighting.
    unreliable if( Role==ROLE_Authority )
        LightType;
    unreliable if( LightType!=LT_None && Role==ROLE_Authority )
        LightEffect, LightBrightness, LightHue, LightSaturation,
        LightRadius, LightPeriod, LightPhase,
        VolumeBrightness, VolumeRadius,
        bSpecialLit;

    // Messages
    reliable if( Role<ROLE_Authority )
        BroadcastMessage, BroadcastLocalizedMessage;
}

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

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

//=============================================================================
// 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 );
native(283) final function bool SetCollisionSize( float NewRadius, float NewHeight );

// 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 );
native(3969) final function bool MoveSmooth( vector Delta );
native(3971) final function AutonomousPhysics(float DeltaSeconds);

// Relations.
native(298) final function SetBase( actor NewBase );
native(272) final function SetOwner( actor NewOwner );

// AI Functions added DEUS_EX STM
native(700) final function float AIGetLightLevel( vector Location );
native(701) final function float AIVisibility(optional bool bIncludeVelocity);
native(710) final function AISetEventCallback(name eventName, name callback,
                                              optional name scoreCallback,
                                              optional bool bCheckVisibility,
                                              optional bool bCheckDir,
                                              optional bool bCheckCylinder,
                                              optional bool bCheckLOS);
native(711) final function AIClearEventCallback(name eventName);
native(713) final function AISendEvent(name eventName, EAIEventType eventType,
                                       optional float Value, optional float Radius);
native(714) final function AIStartEvent(name eventName, EAIEventType eventType,
                                        optional float Value, optional float Radius);
native(715) final function AIEndEvent(name eventName, EAIEventType eventType);
native(716) final function AIClearEvent(name eventName);
native(717) final function rotator RandomBiasedRotation(int centralYaw, float yawDistribution,
                                                        int centralPitch, float pitchDistribution);
native(718) final function bool IsOverlapping(actor checkActor);
native(720) final function PlayerPawn GetPlayerPawn();
native(721) final function bool InStasis();
native(722) final function float ParabolicTrace(out      vector finalLocation,
                                                optional vector startVelocity,
                                                optional vector startLocation,
                                                optional bool   bCheckActors,
                                                optional vector cylinder,
                                                optional float  maxTime,
                                                optional float  elasticity,
                                                optional bool   bBounce,
                                                optional float  landingSpeed,
                                                optional float  granularity);
native(723) final function float LastRendered();
native(724) final function bool GetBoundingBox(out vector MinVect, out vector MaxVect,
                                               optional bool bExact,
                                               optional vector testLocation,
                                               optional rotator testRotation);
// End of AI functions DEUS_EX STM

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

// Animation functions.
native(259) final function PlayAnim( name Sequence, optional float Rate, optional float TweenTime );
native(260) final function LoopAnim( name Sequence, optional float Rate, optional float TweenTime, optional float MinRate );
native(294) final function TweenAnim( name Sequence, float Time );
native(282) final function bool IsAnimating();
native(293) final function name GetAnimGroup( name Sequence );
native(261) final latent function FinishAnim();
native(263) final function bool HasAnim( name Sequence );

// Blending animation function - DEUS_EX CNN
native(1010) final function PlayBlendAnim( name Sequence, optional float Rate, optional float TweenTime, optional int BlendSlot );
native(1012) final function TweenBlendAnim( name Sequence, float Time, optional int BlendSlot );

// Gets any numbered texture from a mesh - DEUS_EX CNN
native(1013) final function Texture GetMeshTexture( optional int texnum );

// Animation notifications.
event AnimEnd();

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

// Physics control.
native(301) final latent function FinishInterpolation();
// DEUS_EX STM - added optional param to SetPhysics()
//native(3970) final function SetPhysics( EPhysics newPhysics );
native(3970) final function SetPhysics( EPhysics newPhysics, optional Actor newFloor );

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

//
// Major notifications.
//
event Spawned();
event Destroyed();
event Expired();
event GainedChild( Actor Other );
event LostChild( Actor Other );
event Tick( float DeltaTime );

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

//
// Physics & world interaction.
//
event Timer();
event HitWall( vector HitNormal, actor HitWall );
event Falling();
event Landed( vector HitNormal );
event ZoneChange( ZoneInfo NewZone );
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 KillCredit( Actor Other );
event Actor SpecialHandling(Pawn Other);
event bool EncroachingOn( actor Other );
event EncroachedBy( actor Other );
event InterpolateEnd( actor Other );
event EndedRotation();

// DEUS_EX STM -- added
event BumpWall( vector HitLocation, vector HitNormal );
event SupportActor( actor StandingActor )
{
    StandingActor.SetBase( self );
}

event FellOutOfWorld()
{
    SetPhysics(PHYS_None);
    Destroy();
}   

//
// Damage and kills.
//
event KilledBy( pawn EventInstigator );
event TakeDamage( int Damage, Pawn EventInstigator, vector HitLocation, vector Momentum, name 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
);

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

//
// 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();

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

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

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

// Play a sound effect.
// DEUS_EX - CNN
// changed to return the channel ID of the sound so you can call StopSound later
native(264) final function int PlaySound
(
    sound               Sound,
    optional ESoundSlot Slot,
    optional float      Volume,
    optional bool       bNoOverride,
    optional float      Radius,
    optional float      Pitch
);

// 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
);

// DEUS_EX CNN - Stop a sound given the sound's ID
native(265) final function StopSound(int Id);

// DEUS_EX CNN - Set the sound system volumes without waiting for a tick event
native(268) final function SetInstantSoundVolume(byte newSoundVolume);
native(269) final function SetInstantSpeechVolume(byte newSpeechVolume);
native(270) final function SetInstantMusicVolume(byte newMusicVolume);

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

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

//=============================================================================
// 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 some player has a line of sight to 
// actor's location.
//
native(532) final function bool PlayerCanSeeMe();

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

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

// Level state.
event BeginPlay();

//========================================================================
// 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();
native final function string GetNextInt( string ClassName, int Num );
native final function GetNextIntDesc( string ClassName, int Num, out string Entry, out string Description );

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

// Iterator functions for dealing with sets of actors.
native(304) final iterator function AllActors     ( class<actor> BaseClass, out actor Actor, optional name MatchTag );
native(305) final iterator function ChildActors   ( class<actor> BaseClass, out actor Actor );
native(306) final iterator function BasedActors   ( class<actor> BaseClass, out actor Actor );
native(307) final iterator function TouchingActors( class<actor> BaseClass, out actor Actor );
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 );
native(310) final iterator function RadiusActors  ( class<actor> BaseClass, out actor Actor, float Radius, optional vector Loc );
native(311) final iterator function VisibleActors ( class<actor> BaseClass, out actor Actor, optional float Radius, optional vector Loc );
native(312) final iterator function VisibleCollidingActors ( class<actor> BaseClass, out actor Actor, optional float Radius, optional vector Loc, optional bool bIgnoreHidden );

// added by DEUS_EX CNN
native(1000) final iterator function TraceTexture (class<actor> BaseClass, out actor Actor, out name texName, out name texGroup, out int flags, out vector HitLoc, out vector HitNorm, vector End, optional vector Start, optional vector Extent);

// added by DEUS_EX STM
native(1002) final iterator function CycleActors (class<actor> BaseClass, out actor Actor, out int Index );
native(1003) final iterator function TraceVisibleActors(class<actor> BaseClass, out actor Actor, out vector HitLoc, out vector HitNorm, vector End, optional vector Start, optional vector Extent );

//=============================================================================
// Color operators
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.

// draw on canvas before flash and fog are applied (used for drawing weapons)
event RenderOverlays( canvas Canvas );

//
// Called immediately before gameplay begins.
//
event PreBeginPlay()
{
    // fake shrink to fix faked collision with floor problems - DEUS_EX CNN
    if ((IsA('Decoration') || IsA('Inventory')) && (CollisionHeight > 0.75))
        SetCollisionSize(CollisionRadius, CollisionHeight - 0.75);
    else if (IsA('Pawn'))
    {
        if (CollisionHeight > 9)
            SetCollisionSize(CollisionRadius, CollisionHeight - 4.5);
        else
            SetCollisionSize(CollisionRadius, CollisionHeight*0.5);
    }

    // Handle autodestruction if desired.
    if( !bGameRelevant && (Level.NetMode != NM_Client) && !Level.Game.IsRelevant(Self) )
        Destroy();
}

//
// Broadcast a message to all players.
//
event BroadcastMessage( coerce string Msg, optional bool bBeep, optional name Type )
{
    local Pawn P;

    if (Type == '')
        Type = 'Event';

//	if ( Level.Game.AllowsBroadcast(self, Len(Msg)) )
        for( P=Level.PawnList; P!=None; P=P.nextPawn )
            if( P.bIsPlayer || P.IsA('MessagingSpectator') )
                P.ClientMessage( Msg, Type, bBeep );
}

//
// 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> Message, optional int Switch, optional PlayerReplicationInfo RelatedPRI_1, optional PlayerReplicationInfo RelatedPRI_2, optional Object OptionalObject )
{
    local Pawn P;

    for ( P=Level.PawnList; P != None; P=P.nextPawn )
        if ( P.bIsPlayer || P.IsA('MessagingSpectator') )
            P.ReceiveLocalizedMessage( Message, Switch, RelatedPRI_1, RelatedPRI_2, OptionalObject );
}

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

//
// DEUS_EX AJY
//
// Called immediately after Initial State, and always
// called when loading a map *AND* when loading savegame
//
event PostPostBeginPlay();

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

// MBCODE: Stub for PostNetBeginPlay
simulated event PostNetBeginPlay();

//
// Hurt actors within the radius.
//
final function HurtRadius( float DamageAmount, float DamageRadius, name DamageName, float Momentum, vector HitLocation, optional bool bIgnoreLOS )
{
    local actor Victims;
    local float damageScale, dist;
    local vector dir;

    // DEUS_EX CNN
    local Mover M;              
    
    if( bHurtEntry )
        return;

    bHurtEntry = true;
   if (!bIgnoreLOS)
   {
      foreach VisibleCollidingActors( class 'Actor', Victims, DamageRadius, HitLocation )
      {
         if( Victims != self )
         {
            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),
               DamageName
               );
         } 
      }
   }
   else
   {
      foreach RadiusActors(class 'Actor', Victims, DamageRadius, HitLocation )
      {
         if( Victims != self )
         {
            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),
               DamageName
               );
         } 
      }
   }

    //
    // DEUS_EX - CNN - damage the movers, also
    //
    foreach RadiusActors(class 'Mover', M, DamageRadius, HitLocation)
    {
        if( M != self )
        {
            dir = M.Location - HitLocation;
            dist = FMax(1,VSize(dir));
            dir = dir/dist; 
            damageScale = 1 - FMax(0,(dist - M.CollisionRadius)/DamageRadius);
            M.TakeDamage
            (
                damageScale * DamageAmount,
                Instigator, 
                M.Location - 0.5 * (M.CollisionHeight + M.CollisionRadius) * dir,
                (damageScale * Momentum * dir),
                DamageName
            );
        } 
    }

    bHurtEntry = false;
}

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

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

//
// DEUS_EX CNN
// Frob() - called to frob an object
// the subclass is responsible for implementing this
//
function Frob(Actor Frobber, Inventory frobWith)
{
}

// DEUS_EX CNN
function StopBlendAnims()
{
    local int i;

    for (i=0; i<ArrayCount(BlendAnimSequence); i++)
        BlendAnimSequence[i] = '';
}

//
// Called when a scripted texture needs rendering
//
event RenderTexture(ScriptedTexture Tex);

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

//
// Returns the string representation of the name of an object without the package
// prefixes.
//
function String GetItemName( string FullName )
{
    local int pos;

    pos = InStr(FullName, ".");
    While ( pos != -1 )
    {
        FullName = Right(FullName, Len(FullName) - pos - 1);
        pos = InStr(FullName, ".");
    }

    return FullName;
}

//
// Returns the human readable string representation of an object.
//

function String GetHumanName()
{
    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, texture NewTexture, bool bLighting, bool bEnviroMap )
{
    Style = NewStyle;
    texture = NewTexture;
    bUnlit = bLighting;
    bMeshEnviromap = bEnviromap;
}

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

// ----------------------------------------------------------------------
// EndConversation()
//
// Save the time this conversation ended
//
// DEUS_EX AJY
// ----------------------------------------------------------------------

function EndConversation()
{
    LastConEndTime = Level.TimeSeconds;
}

defaultproperties
{
     bMovable=True
     bDetectable=True
     Role=ROLE_Authority
     RemoteRole=ROLE_DumbProxy
     LastRenderTime=-10.000000
     LODBias=1.000000
     bDifficulty0=True
     bDifficulty1=True
     bDifficulty2=True
     bDifficulty3=True
     bSinglePlayer=True
     bNet=True
     bNetSpecial=True
     OddsOfAppearing=1.000000
     DrawType=DT_Sprite
     Style=STY_Normal
     Texture=Texture'Engine.S_Actor'
     DrawScale=1.000000
     ScaleGlow=1.000000
     Fatness=128
     SoundRadius=32
     SoundVolume=128
     SoundPitch=64
     TransientSoundVolume=1.000000
     CollisionRadius=22.000000
     CollisionHeight=22.000000
     bJustTeleported=True
     Mass=100.000000
     ConStartInterval=5.000000
     NetPriority=1.000000
     NetUpdateFrequency=100.000000
}