Chemeric Home

  Reference
Material to look stuff up in.

  UnrealScript
That lovely java cum C++ language

  A Look at Mods
You wanted work in progress - and here it is

  Bots
Custom bots & configurations

  Misc
Stuff we can't place easily :-)

  Contributors
The guys and gals of Chimeric

 

The Actor Class

Written by Valiant - 15 June 1998

Copyright

Unreal™ © 1998 Epic Megagames, Inc. All Rights Reserved.

Version Information

Based upon Unreal Version 1.0. Please send comments to Valiant.

Class Definition

class Actor expands Object
    abstract
    intrinsic;

The base class of all actors.

Imported Data

#exec Texture Import File=Textures\S_Actor.pcx Name=S_Actor Mips=Off Flags=2
Default texture loading.

Class Enums and Related Class Data Members

EDodgeDir
var enum EDodgeDir
{
    DODGE_None,
    DODGE_Left,
    DODGE_Right,
    DODGE_Forward,
    DODGE_Back,
    DODGE_Active,
    DODGE_Done
} DodgeDir;

Enumerators for dodging move direction.

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

Enumerator for types of drawing effects.

EInputAction
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.
};

Enumerator for input system states.

EInputKey
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
};

Enumerator for input keys.

ELightEffect
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;

Enumerator for different spatial light effects to use.

ELightType
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;

Enumerator for different light modulation types.

EMusicTransition
enum EMusicTransition
{
    MTRAN_None,
    MTRAN_Instant,
    MTRAN_Segue,
    MTRAN_Fade,
    MTRAN_FastFade,
    MTRAN_SlowFade,
};

Enumerators for music transitions.

ENetRole
enum ENetRole
{
    ROLE_None,
    ROLE_DumbProxy,
    ROLE_SimulatedProxy,
    ROLE_AutonomousProxy,
    ROLE_Authority,
};

Enumerator for the deferent roles this actor may play in a net based game.

EPhysics
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;

Enumerators for supported physics modes.

ERenderStyle
var(Display) enum ERenderStyle
{
    STY_None,
    STY_Normal,
    STY_Masked,
    STY_Translucent,
    STY_Modulated,
} Style;

Enumerators for different styles of rendering sprites and meshes.

ESoundSlot
enum ESoundSlot
{
    SLOT_None,
    SLOT_Misc,
    SLOT_Pain,
    SLOT_Interact,
    SLOT_Ambient,
    SLOT_Talk,
    SLOT_Interface,
};

Enumerators for different sound slots for actors.

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

Enumerator for travelling from server to server.

Class Data Members

Acceleration
var vector Acceleration;
Actor’s current acceleration.

bAlwaysRelevant
var(Advanced) bool bAlwaysRelevant;
Never destroy based on game.

bAlwaysTick
var Const bool bAlwaysTick;
Update even when players-only.

AmbientGlow
var(Display) byte AmbientGlow;
Ambient brightness, or 255=pulsing.

AmbientSound
var(Sound) sound AmbientSound;
Ambient sound effect.

AnimFrame
var(Display) float AnimFrame;
Current animation frame, 0.0 to 1.0.

AnimLast
var float AnimLast;
Last frame of current animation.

AnimMinRate
var float AnimMinRate;
Minimum rate for velocity-scaled animation.

AnimRate
var(Display) float AnimRate;
Animation rate in frames per second, 0=none, negative=velocity scaled.

AnimSequence
var(Display) name AnimSequence;
Current animation sequence being played.

bActorShadows
var(Lighting) bool bActorShadows;
This light casts actor shadows.

bAnimFinished
var bool bAnimFinished;
Unlooped animation sequence has finished.

bAnimLoop
var bool bAnimLoop;
Whether animation is looping.

bAnimNotify
var bool bAnimNotify;
Whether a notify is applied to the current sequence of animation.

bAssimilated
var transient const bool bAssimilated;
Actor dynamics are assimilated in world geometry.

bBlockActors
var(Collision) bool bBlockActors;
Blocks other nonplayer actors.

bBlockPlayers
var(Collision) bool bBlockPlayers;
Blocks other player actors.

bBounce
var(Movement) bool bBounce;
Actor bounces when it hits ground fast.

bCanTeleport
var(Advanced) bool bCanTeleport;
This actor can be teleported.

bCollideActors
var(Collision) const bool bCollideActors;
Collides with other actors.

bCollideWhenPlacing
var(Advanced) bool bCollideWhenPlacing;
This actor collides with the world when placing.

bCollideWorld
var(Collision) bool bCollideWorld;
Collides with the world.

bCorona
var(Lighting) bool bCorona;
This light uses Skin as a corona.

bDeleteMe
var const bool bDeleteMe;
Actor is about to be deleted.

bDirectional
var(Advanced) bool bDirectional;
Actor shows direction arrow during editing.

bDynamicLight
var bool bDynamicLight;
Temporarily treat this as a dynamic light.

bEdLocked
var bool bEdLocked;
Actor is locked in editor, therefore, no movement or rotation.

bEdShouldSnap
var(Advanced) bool bEdShouldSnap;
Actor should be snapped to grid in UnrealEd.

bEdSnap
var transient bool bEdSnap;
Actor is snapped to grid in UnrealEd.

bFixedRotationDir
var(Movement) bool bFixedRotationDir;
Actor has a fixed direction of rotation.

bForceStasis
var(Advanced) bool bForceStasis;
Actor is forced into stasis when not recently rendered, even if physics not PHYS_None or PHYS_Rotating.

bHidden
var(Advanced) bool bHidden;
Actor is hidden during gameplay.

bHiddenEd
var(Advanced) bool bHiddenEd;
Actor is hidden during editing.

bHighDetail
var(Advanced) bool bHighDetail;
Actor only shows up on high detail mode.

bHighlighted
var const bool bHighlighted;
Actor is highlighted in UnrealEd.

bHurtEntry
var bool bHurtEntry;
keep HurtRadius from being reentrant

bInterpolating
var bool bInterpolating;
Actor is performing an interpolating operation.

bIsItemGoal
var(Advanced) bool bIsItemGoal;
This actor counts in the "item" count.

bIsKillGoal
var(Advanced) bool bIsKillGoal;
This actor counts in the "death" toll.

bIsMover
var Const bool bIsMover;
Is a mover.

bIsPawn
var const bool bIsPawn;
Actor is a pawn.

bIsSecretGoal
var(Advanced) bool bIsSecretGoal;
This actor counts in the "secret" total.

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

bLensFlare
var(Lighting) bool bLensFlare;
Whether or not to use zone lens flare.

bLightChanged
var transient bool bLightChanged;
Recalculate this light’s lighting now.

bMemorized
var const bool bMemorized;
Actor is remembered in UnrealEd.

bMeshCurvy
var(Display) bool bMeshCurvy;
Curvy mesh.

bMeshEnviroMap
var(Display) bool bMeshEnviroMap;
Environment-map the mesh.

bMovable
var(Advanced) bool bMovable;
Actor is capable of travelling among servers.

bNetFeel
var const bool bNetFeel;
Player collides with/feels this actor in network play. . Symmetric network flag, valid during replication only.

bNetHear
var const bool bNetHear;
Player hears this actor in network play. Symmetric network flag, valid during replication only.

bNetInitial
var const bool bNetInitial;
Initial network update flag. Symmetric network flag, valid during replication only.

bNetOptional
var const bool bNetOptional;
Actor should only be replicated if bandwidth available. Symmetric network flag, valid during replication only.

bNetOwner
var const bool bNetOwner;
Player owns this actor. Symmetric network flag, valid during replication only.

bNetSee
var const bool bNetSee;
Player sees it in network play. Symmetric network flag, valid during replication only.

bNoDelete
var(Advanced) const bool bNoDelete;
Actor cannot be deleted during play.

bNoSmooth
var(Display) bool bNoSmooth;
Don't smooth actor's texture.

bOnlyOwnerSee
var(Advanced) bool bOnlyOwnerSee;
Only owner can see this actor.

bParticles
var(Display) bool bParticles;
Mesh is a particle system.

bProjTarget
var(Collision) bool bProjTarget;
Projectiles should potentially target this actor.

bRotateToDesired
var(Movement) bool bRotateToDesired;
Actor rotates to DesiredRotation.

Brush
var const export model Brush;
Brush if DrawType=DT_Brush.

bSelected
var const bool bSelected;
Actor is selected in UnrealEd.

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

bSimulatedPawn
var const bool bSimulatedPawn;
True if this actor is a Pawn and a simulated proxy. Symmetric network flag, valid during replication only.

bSpecialLit
var(Lighting) bool bSpecialLit;
Only affects special-lit surfaces.

bStasis
var(Advanced) bool bStasis;
In standalone games, actor is turned off if not in a recently rendered zone, or the actor is turned off if bCanStasis == True and physics mode is PHYS_None or PHYS_Rotating.

bStatic
var(Advanced) const bool bStatic;
Actor does not move or change over time.

bTempEditor
var transient const bool bTempEditor;
Internal UnrealEd use.

bTicked
var transient const bool bTicked;
Actor has been updated.

bTimerLoop
var bool bTimerLoop;
If True then the actor Timer loops, else it is one-shot.

bTravel
var(Advanced) bool bTravel;
Actor is capable of travelling among servers.

bUnlit
var(Display) bool bUnlit;
Lights don't affect actor.

Buoyancy
var(Movement) float Buoyancy;
Actor’s water buoyancy value.

CollisionHeight
var(Collision) const float CollisionHeight;
Half-height cylinder.

CollisionRadius
var(Collision) const float CollisionRadius;
Radius of collision cyllinder.

ColLocation
var const vector ColLocation;
Actor's old location one move ago.

DesiredRotation
var(Movement) rotator DesiredRotation;
Physics subsystem will rotate pawn to this if bRotateToDesired.

DrawScale
var(Display) float DrawScale;
Scaling factor, 1.0=normal size.

Fatness
var(Display) byte Fatness;
Fatness (mesh distortion).

Group
var(Object) name Group;
???

InitialState
var(Object) name InitialState;
???

LifeSpan
var(Advanced) float LifeSpan;
How long the actor lives before dying, 0=forever. Used for executing timer-related events for the actor.

LightBrightness
var(LightColor) byte LightBrightness;
Light brightness value.

LightCone
var(LightColor) byte LightCone;
Light cone value.

LightHue
var(LightColor) byte LightHue;
Light hue value.

LightPeriod
var(Lighting) byte LightPeriod;
Light period value.

LightPhase
var(Lighting) byte LightPhase;
Light phase value.

LightRadius
var(Lighting) byte LightRadius;
Light radius value.

LightSaturation
var(LightColor) byte LightSaturation;
Light saturation value.

Location
var(Movement) const vector Location;
Actor's location; use Move to set.

Mass
var(Movement) float Mass;
Mass of this actor.

Mesh
var(Display) mesh Mesh;
Mesh if DrawType=DT_Mesh.

NetPriority
var(Networking) float NetPriority;
Higher priorities means update it more frequently.

OldAnimRate
var float OldAnimRate;
Animation rate of previous animation (= AnimRate until animation completes).

OldLocation
var const vector OldLocation;
Actor's old location one tick ago.

Owner
var const Actor Owner;
Owner of this actor.

PhysAlpha
var float PhysAlpha;
Interpolating position, 0.0-1.0.

PhysRate
var float PhysRate;
Interpolation rate per second.

PrePivot
var vector PrePivot;
Offset from box center for drawing.

RemoteRole
var(Networking) ENetRole RemoteRole;
Actor’s role in the current networked game on all other machines other than it’s original machine.

Role
var ENetRole Role;
Actor/s role in the current networked game on it’s original machine.

Rotation
var(Movement) const rotator Rotation;
Actor’s current rotation.

RotationRate
var(Movement) rotator RotationRate;
Change in rotation per second.

ScaleGlow
var(Display) float ScaleGlow;
Multiplies lighting.

SimAnim
var plane SimAnim;
Replicated to simulated proxies.

Skin
var(Display) texture Skin;
Special skin or environment map texture.

SoundPitch
var(Sound) byte SoundPitch;
Ambient sound pitch shift, 64.0=none.

SoundRadius
var(Sound) byte SoundRadius;
Radius of ambient sound.

SoundVolume
var(Sound) byte SoundVolume;
Volume of ambient sound.

Sprite
var(Display) texture Sprite;
Sprite texture if DrawType=DT_Sprite.

Texture
var(Display) texture Texture;
Misc. texture.

TimerCounter
var const float TimerCounter;
Counts up until it reaches TimerRate. Used for executing timer-related events for the actor.

TimerRate
var float TimerRate;
Timer event, 0=no timer. Used for executing timer-related events for the actor.

TransientSoundVolume
var(Sound) float TransientSoundVolume;
Volume of regular (non-ambient) sounds.

TweenRate
var float TweenRate;
Animation tween-into rate.

Velocity
var(Movement) vector Velocity;
Actor’s player’s pulse rate . . . just wanted to see if you were awake. ;-) Actor’s current velocity.

VolumeBrightness
var(Lighting) byte VolumeBrightness;
Light volume brightness value.

VolumeFog
var(Lighting) byte VolumeFog;
Light volume fog value.

VolumeRadius
var(Lighting) byte VolumeRadius;
Light volume radius value.

Scriptable Class Data Members

Base
var const Actor Base;
Moving brush actor we're standing on.

Event
var(Events) name Event;
The event this actor causes.

Instigator
var Pawn Instigator;
Pawn responsible for damage.

Inventory
var Inventory Inventory;
Inventory chain.

LevelInfo
var const LevelInfo Level;
Level this actor is on.

Region
var const PointRegion Region;
Region this actor is in.

Tag
var(Events) name Tag;
Actor's tag name.

Target
var Actor Target;
Actor we're aiming at (other uses as well).

XLevel
var const Level XLevel;
Level object.

Gameplay Scenarios Class Data Members

bDifficulty0
var(Filter) bool bDifficulty0;
Actor appears in difficulty level 0 gameplay scenarios.

bDifficulty1
var(Filter) bool bDifficulty1;
Actor appears in difficulty level 1 gameplay scenarios.

bDifficulty2
var(Filter) bool bDifficulty2;
Actor appears in difficulty level 2 gameplay scenarios.

bDifficulty3
var(Filter) bool bDifficulty3;
Actor appears in difficulty level 3 gameplay scenarios.

bSinglePlayer
var(Filter) bool bSinglePlayer;
Actor appears in single player gameplay scenarios.

bNet
var(Filter) bool bNet;
Actor appears in regular network play gameplay scenarios.

bNetSpecial
var(Filter) bool bNetSpecial;
Actor appears in special network gameplay mode.

OddsOfAppearing
var(Filter) float OddsOfAppearing;
Chance the actor will appear in relevant gameplay modes, values of 0.0 to 1.0, 1.0=always appears.

Internal Use Class Data Members

CollisionTag, ExtraTag, LightingTag, NetTag, OtherTag, SpecialTag
var const transient int CollisionTag;
var const transient int ExtraTag;
var const transient int LightingTag;
var const transient int NetTag;
var const transient int OtherTag;
var const transient int SpecialTag;

All tag variables for internal use. Purposes unknown.

Deleted
var const actor Deleted;
Next actor in just-deleted chain.

LatentActor
var const actor LatentActor;
Internal latent function use.

LatentByte
var const byte LatentByte;
Internal latent function use.

LatentFloat
var const float LatentFloat;
Internal latent function use.

LatentInt
var const int LatentInt;
Internal latent function use.

MiscNumber
var const byte MiscNumber;
Internal use.

StandingCount
var const byte StandingCount;
Count of actors standing on this actor.

Touching[4]
var const actor Touching[4];
List of touching actors.

Class Structure Definitions

PointRegion
struct PointRegion
{
    var zoneinfo Zone; // Zone.
    var int iLeaf; // Bsp leaf.
    var byte ZoneNumber; // Zone number, to be eliminated!!
};

Identifies a unique convex volume in the world.

Class Information for Network Replication

???. I have my guesses about this special piece of code for dealing with networking. I still think it best we wait for Tim Sweeney to enlighten us. If you have some thoughts on this piece of code please email me at Valiant.

replication
{
    // Relationships.
    reliable if( Role==ROLE_Authority )
    Owner, Role, RemoteRole;
    reliable if( Role==ROLE_Authority && bNetOwner )
    bNetOwner, Inventory;
    // Ambient sound.
    reliable if( Role==ROLE_Authority )
    AmbientSound;
    reliable if( Role==ROLE_Authority && AmbientSound!=None )
    SoundRadius, SoundVolume, SoundPitch;
    // Collision.
    reliable if( Role==ROLE_Authority )
    bCollideActors;
    reliable if( Role==ROLE_Authority )
    bCollideWorld;
    reliable if( Role==ROLE_Authority && bCollideActors )
    bBlockActors, bBlockPlayers;
    reliable if( Role==ROLE_Authority && (bCollideActors || bCollideWorld) )
    CollisionRadius, CollisionHeight;
    // Location.
    unreliable if( Role==ROLE_Authority && (bNetInitial || bSimulatedPawn ||
    RemoteRole<ROLE_SimulatedProxy) )
    Location, Rotation;
    unreliable if( Role==ROLE_Authority && (bNetInitial || bSimulatedPawn) &&
    RemoteRole==ROLE_SimulatedProxy )
    Base;
    // Velocity.
    unreliable if( (RemoteRole==ROLE_SimulatedProxy && (bNetInitial || bSimulatedPawn)) || bIsMover     )
    Velocity;
    // Physics.
    unreliable if( RemoteRole==ROLE_SimulatedProxy && bNetInitial )
    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) )
    AnimSequence;
    unreliable if( DrawType==DT_Mesh && (RemoteRole==ROLE_SimulatedProxy) )
    bAnimNotify;
    unreliable if( DrawType==DT_Mesh && (RemoteRole<ROLE_AutonomousProxy) )
    SimAnim, AnimMinRate;
    // Rendering.
    reliable if( Role==ROLE_Authority )
    bHidden, bOnlyOwnerSee;
    unreliable if( Role==ROLE_Authority ) // and see...
    Texture, DrawScale, PrePivot, DrawType, AmbientGlow, Fatness, ScaleGlow, bUnlit, bNoSmooth,
    bShadowCast, bActorShadows;
    unreliable if( Role==ROLE_Authority && DrawType==DT_Sprite && !bHidden &&          (!bOnlyOwnerSee     || bNetOwner) )
    Sprite;
    unreliable if( Role==ROLE_Authority && DrawType==DT_Mesh )
    Mesh, bMeshEnviroMap, bMeshCurvy, Skin;
    unreliable if( Role==ROLE_Authority && DrawType==DT_Brush )
    Brush;
    // Lighting.
    unreliable if( Role==ROLE_Authority )
    LightType;
    unreliable if( Role==ROLE_Authority && LightType!=LT_None )
    LightEffect, LightBrightness, LightHue, LightSaturation,
    LightRadius, LightPeriod, LightPhase, LightCone,
    VolumeBrightness, VolumeRadius,
    bSpecialLit;
    // Messages
    unreliable if( Role < ROLE_Authority )
    BroadcastMessage;
}

Class Intrinsic Operators and Functions

Vector Operators

-
intrinsic(211) static final preoperator vector - ( vector A );
Negation operator

*
intrinsic(212) static final operator(16) vector * ( vector A, float B );
intrinsic(213) static final operator(16) vector * ( float A, vector B );
intrinsic(296) static final operator(16) vector * ( vector A, vector B );

Multiplication operator

/
intrinsic(214) static final operator(16) vector / ( vector A, float B );
Division operator

+
intrinsic(215) static final operator(20) vector + ( vector A, vector B );
Addition operator

-
intrinsic(216) static final operator(20) vector - ( vector A, vector B );
Subtraction operator

<<
intrinsic(275) static final operator(22) vector << ( vector A, rotator B );
Left rotation operator

>>
intrinsic(276) static final operator(22) vector >> ( vector A, rotator B );
Right rotation operator

==
intrinsic(217) static final operator(24) bool == ( vector A, vector B );
Equality operator

!=
intrinsic(218) static final operator(26) bool != ( vector A, vector B );
Inequality operator

Dot
intrinsic(219) static final operator(16) float Dot ( vector A, vector B );
Dot product operator

Cross
intrinsic(220) static final operator(16) vector Cross ( vector A, vector B );
Cross product operator

*=
intrinsic(221) static final operator(34) vector *= ( out vector A, float B );
intrinsic(297) static final operator(34) vector *= ( out vector A, vector B );

Multiplication assignment operator

/=
intrinsic(222) static final operator(34) vector /= ( out vector A, float B );
Division assignment operator

+=
intrinsic(223) static final operator(34) vector += ( out vector A, vector B );
Addition assignment operator

-=
intrinsic(224) static final operator(34) vector -= ( out vector A, vector B );
Subtraction assignment operator

Vector Functions

VSize
intrinsic(225) static final function float VSize ( vector A );
Get the vertical size of a vector.

Normal
intrinsic(226) static final function vector Normal ( vector A );
Get the normal of a vector.

Invert
intrinsic(227) static final function Invert ( out vector X, out vector Y, out vector Z );
Invert a vector.

Vrand
intrinsic(252) static final function vector VRand ( );
???. Please email Valiant if you know what this does.

MirrorVectorByNormal
intrinsic(300) static final function vector MirrorVectorByNormal( vector Vect, vector Normal );
Return the mirror about the given normal of a vector.

Rotator Operators

==
intrinsic(142) static final operator(24) bool == ( rotator A, rotator B );
Equality operator

!=
intrinsic(203) static final operator(26) bool != ( rotator A, rotator B );
Inequality operator

*
intrinsic(287) static final operator(16) rotator * ( rotator A, float B );
intrinsic(288) static final operator(16) rotator * ( float A, rotator B );

Multiplication operator

/
intrinsic(289) static final operator(16) rotator / ( rotator A, float B );
Division operator

*=
intrinsic(290) static final operator(34) rotator *= ( out rotator A, float B );
Multiplication assignment operator

/=
intrinsic(291) static final operator(34) rotator /= ( out rotator A, float B );
Division assignment operator

+
intrinsic(316) static final operator(20) rotator + ( rotator A, rotator B );
Addition operator

-
intrinsic(317) static final operator(20) rotator - ( rotator A, rotator B );
Subtraction operator

+=
intrinsic(318) static final operator(34) rotator += ( out rotator A, rotator B );
Addition assignment operator

-=
intrinsic(319) static final operator(34) rotator -= ( out rotator A, rotator B );
Subtraction assignment operator

Rotator Functions

GetAxes
intrinsic(229) static final function GetAxes ( rotator A, out vector X, out vector Y, out vector Z );
Get X,Y and Z axes values for the given rotator.

GetUnAxes
intrinsic(230) static final function GetUnAxes ( rotator A, out vector X, out vector Y, out vector Z );
???. Email me at Valiant if you know what this does.

RotRand
intrinsic(320) static final function rotator RotRand ( optional bool bRoll );
Return randomized rotator.

Iterator Functions

AllActors
intrinsic(304) final iterator function AllActors(class<actor> BaseClass, out actor Actor, optional name MatchTag);
Iterates through all actors in the level with the specified tag. If you don’t specify a tag, it iterates through all actors in the level. This is pretty slow if you specify a tag, and very slow if you don’t.

BasedActors
intrinsic(306) final iterator function BasedActors(class<actor> BaseClass, out actor Actor);
Iterates through all actors directly based on this actor.

ChildActors
intrinsic(305) final iterator function ChildActors(class<actor> BaseClass, out actor Actor);
Iterates through all actors owned by this actor.

RadiusActors
intrinsic(310) final iterator function RadiusActors(class<actor> BaseClass, out actor Actor, float Radius, optional vector Loc);
Iterates through all actors within a specified radius. This is fast.

TouchingActors
intrinsic(307) final iterator function TouchingActors(class<actor> BaseClass, out actor Actor);
Iterates through all actors touching this actor. This is fast.

TraceActors
intrinsic(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);
Iterates through all actors hit by a trace along a line with an optional collision extent. This is pretty fast.

VisibleActors
intrinsic(311) final iterator function VisibleActors(class<actor> BaseClass, out actor Actor, optional float Radius, optional vector Loc);
Iterates through all actors visible to this actor (using a simple line trace, rather than exact mesh-to-mesh visible). This is very, very slow.

VisibleCollidingActors
intrinsic(312) final iterator function VisibleCollidingActors(class<actor> BaseClass, out actor Actor, optional float Radius, optional vector Loc);
Iterates through all actors visible to this actor which have collision enabled; this is much faster than VisibleActors.

Class Member Functions

AnimEnd
event AnimEnd();
Called when the currently playing or looping animation reaches the end of the sequence.

Attach
event Attach( Actor Other );
Some other actor has set its base to this actor.

BaseChange
event BaseChange();
This actor’s base has changed.

BeginEvent
event BeginEvent();
A simple protocal to indicate that this actor called a Trigger() function that began a complex chain of events. This enables switches to be coordinated with doors intelligently. For example, you press a switch, the door switch moves in, it triggers a door which calls your BeginEvent() then slowly opens, then the door calls your EndEvent(). Nowyou move the button back out to give the user feedback that the button is finished with what it was doing.

BeginPlay
event BeginPlay();
Called when a level is entered for playing.

BroadcastMessage
function BroadcastMessage( coerce string[240] Msg, bool bBeep )
{
    local Pawn P;
    if ( Level.Game.AllowsBroadcast(self, Len(Msg)) )
        for( P=Level.PawnList; P!=None; P=P.nextPawn )
            if( P.bIsPlayer )
                P.ClientMessage( Msg );
}

Broadcast a message to all players.

Bump
event Bump( Actor Other );
This actor has bumped into an impenetrable actor.

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

Destroyed
event Destroyed();
Called immediately when an actor is destroyed.

Detach
event Detach( Actor Other );
Some other actor based on this one is no longer based on this actor.

EncroachedBy
event EncroachedBy( actor Other );
This actor has been successfully encroached by (overlapped by) another actor. This is where players may opt to telefrag themselves or ignore the encroach.

EncroachingOn
event bool EncroachingOn( actor Other );
This actor is now encroaching on (overlapping with) another actor as a result of moving and it may return true to abort the move, or false to continue the move.

EndEvent
event EndEvent();
The event called when BeginEvent() has ended.

EndedRotation
event EndedRotation();
Called when the actor’s current rotation has ended.

Error
intrinsic(233) final function Error( coerce string[255] S );
Handle an error and kill this one actor. Causes a critical error; exits the engine.

Expired
event Expired();
Called immediately before Destroyed() when an actor’s LifeTime has counted downward past zero.

Falling
event Falling();
This actor has transitioned into PHYS_Falling.

FinishAnim
intrinsic(261) final latent function FinishAnim();
Waits for the currently playing or looping animation to reach the end of the sequence.

FinishInterpolation
intrinsic(301) final latent function FinishInterpolation();
Only relevent with the physics mode PHYS_Interpolating. Waits until the next interpolation point is reached.

GainedChild
event GainedChild( Actor Other );
Another actor has done a SetOwner() to this actor.

GetAnimGroup
intrinsic(293) final function name GetAnimGroup( name Sequence );
Returns the group name of the specified animation sequence.

GetMapName
intrinsic(539) final function string[32] GetMapName( string[32] NameEnding, string[32] MapName, int Dir );
Returns the name of the map specified.

GetNextSkin

intrinsic(545) final function string[64] GetNextSkin( string[64] Prefix, string[64] CurrentSkin, int Dir );

Returns the name of the next skin in the current file of skins being accessed.

HitWall

event HitWall( vector HitNormal, actor HitWall );

This actor ran into a wall while moving.

HurtRadius
final function HurtRadius( float DamageAmount, float DamageRadius, name DamageName, 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 )
    {
        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);
        }
    }
    bHurtEntry = false;
}

Hurt actors within the radius.

InterpoloateEnd
event InterpolateEnd( actor Other );
Called when Physics==PHYS_Interpolating and the next interpolation point has been reached.

IsA
intrinsic(303) final function bool IsA( name ClassName );
Return whether this actor belongs in a named class.

IsAnimating
intrinsic(282) final function bool IsAnimating();
Returns whether the actor’s mesh is currently animating.

KilledBy
event KilledBy( pawn EventInstigator );
Called when killed by another actor (killed just means dead, it doesn’t mean destroyed).

KillCredit
event KillCredit( Actor Other );
This actor has successfully killed another actor.

Landed
event Landed( vector HitNormal );
Ouch! That’s gotta hurt! This actor has transitioned out of PHYS_Falling.

LoopAnim
intrinsic(260) final function LoopAnim( name Sequence, optional float Rate, optional float TweenTime, optional float MinRate );
Loops the animation dequence forever. The AnimEnd() is called at the end of the sequence, and FinishAnim() calls return at the end of each iteration of the loop.

LostChild
event LostChild( Actor Other );
An actor owned by this actor has been destroyed or done a SetOwner() to another actor.

MakeNoise
intrinsic(512) final function MakeNoise( float Loudness );
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.

Move
intrinsic(266) final function bool Move( vector Delta );
Moves the actor by the specified displacement vector, handling collision (based on the collision flags), Touch and Bump notifications.

MoveSmooth
intrinsic(3969) final function bool MoveSmooth( vector Delta );
Like move, but smoothly brushes against walls.

PlayAnim
intrinsic(259) final function PlayAnim( name Sequence, optional float Rate, optional float TweenTime );
Plays a named animation sequence in the actor’s Mesh once. The optional Rate scales the animation’s default rate. If a nonzero TweenTime is specified, the animation is first tweened from whatever is currently displayed to the start of the named animation sequence, before the animation sequence plays. When the animation playing completes, it stops and calls your optional AnimEnd() event and causes any latent FinishAnim() calls to return.

PlayerCanSeeMe
intrinsic(532) final function bool PlayerCanSeeMe();
PlayerCanSeeMe returns true if some player has a line of sight to actor's location.

PlaySound
intrinsic(264) final function PlaySound(sound Sound, optional ESoundSlot Slot, optional float Volume, optional bool bNoOverride, optional float Radius, optional float Pitch);
Play a sound effect.

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

PostTeleport
event PostTeleport( Teleporter OutTeleporter );
Called after this actor is teleported by a teleporter.

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

Called immediately before gameplay begins.

PreTeleport
event bool PreTeleport( Teleporter InTeleporter );
Called before this actor is teleported by a teleporter.

SetBase
intrinsic(298) final function SetBase( actor NewBase );
Sets the actor’s Base. A base of None means that the actor moves alone; setting the base to another actor in the world causes this actor to move and rotate along with its base. An example of using a base is standing on a moving platform.

SetCollision
intrinsic(262) final function SetCollision( optional bool NewColActors, optional bool NewBlockActors, optional bool NewBlockPlayers );
Changes the actor’s collision flags.

SetCollisionSize
intrinsic(283) final function bool SetCollisionSize( float NewRadius, float NewHeight );
Changes the actor’s collision size.

SetInitialState
simulated event SetInitialState()
{
    if( InitialState!='' )
        GotoState( InitialState );
    else
        GotoState( 'Auto' );
}

Called after PostBeginPlay.

SetLocation
intrinsic(267) final function bool SetLocation( vector NewLocation );
Teleports the actor to a new location.

SetOwner
intrinsic(272) final function SetOwner( actor NewOwner );
Sets this actor’s owner.

SetPhysics
intrinsic(3970) final function SetPhysics( EPhysics newPhysics );
Sets the actor’s current physics mode.

SetRotation
intrinsic(299) final function bool SetRotation( rotator NewRotation );
Sets the actor’s new rotation.

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

Sleep
intrinsic(256) final latent function Sleep( float Seconds );
Waits for a certain number of seconds to pass, then continues.

Spawn
intrinsic(278) final function actor Spawn(class<actor> SpawnClass, optional actor SpawnOwner, optional name SpawnTag, optional vector SpawnLocation, optional rotator SpawnRotation);
Spawn an actor. Returns an actor of the specified class, not of class Actor (this is hardcoded in the compiler). Returns None if the actor could not be spawned (either the actor wouldn't fit in the specified location, or the actor list is full). Defaults to spawning at the spawner's location.

Spawned
event Spawned();
Called when an actor is spawned during gameplay. Never called if the actor is preexisting when a level is loaded.

SpecialHandling
event Actor SpecialHandling(Pawn Other);
???.

TakeDamage
event TakeDamage( int Damage, Pawn EventInstigator, vector HitLocation, vector Momentum, name DamageType);
A certain amount of damage has been imparted on this actor.

Tick
event Tick( float DeltaTime );
Called each iteration of the game loop; varies depending on frame rate. DeltaTime indicates how much time has passed.

Trigger
event Trigger( Actor Other, Pawn EventInstigator );
Roy Roger’s house. ;-) This actor has been triggered by another actor Other, optionally caused by a pawn EventInstigator.

Timer
event Timer();
If you call SetTimer, this Timer function is called each time the timer has counted down from your time value.

Touch
event Touch( Actor Other );
This actor has begun touching (interpenetrating) another actor. Now, now, I know what you’re thinking, let’s keep it clean.

Trace
intrinsic(277) final function Actor Trace(out vector HitLocation, out vector HitNormal, vector TraceEnd, optional vector TraceStart, optional bool bTraceActors, optional vector Extent);
Traced 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.

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

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

TweenAnim
intrinsic(294) final function TweenAnim( name Sequence, float Time );
Tweens from whatever animation is currently being displayed, to the start of the specified animation sequence, then stops and calls AnimEnd() and releases any latent FinishAnim() calls.

UnTouch
event UnTouch( Actor Other );
This actor has stopped touching (interpenetrating) another actor.

UnTrigger
event UnTrigger( Actor Other, Pawn EventInstigator );
This actor has been untriggered by another actor Other, optionally caused by a pawn EventInstigator.

ZoneChange
event ZoneChange( ZoneInfo NewZone );
This actor has entered a new zone.


Copyright

Unreal™ © 1998 Epic Megagames, Inc. All Rights Reserved.