2131 lines
77 KiB
Ucode
2131 lines
77 KiB
Ucode
//=============================================================================
|
|
// 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.
|
|
|
|
// if _RO_
|
|
var(Advanced) bool bCanAutoTraceSelect; // This actor can be selected with an autotrace
|
|
var(Advanced) bool bAutoTraceNotify; // When autotraced by a pawn this actor will call the NotifySelected event
|
|
|
|
// 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.
|
|
// if _RO_
|
|
var const float LastReplicateTime; // The last time this actor was replicated.
|
|
// endif _RO_
|
|
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;
|
|
|
|
// if _RO_
|
|
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_Gravel,
|
|
EST_Concrete,
|
|
EST_HollowWood,
|
|
EST_Mud,
|
|
EST_MetalArmor,
|
|
EST_Paper,
|
|
EST_Cloth,
|
|
EST_Rubber,
|
|
EST_Poop,
|
|
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;
|
|
// else UT
|
|
//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;
|
|
// end _RO_
|
|
|
|
|
|
// 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
|
|
|
|
// if _RO_
|
|
var bool bBlockHitPointTraces; // If true will do hit point checks when a hitpoint trace is done
|
|
//
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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
|
|
// if _RO_
|
|
const MAINCOLLISIONINDEX = 0; // Hitpoint index of the main hitpointcollision cylinder
|
|
//
|
|
|
|
// 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
|
|
// if _RO_
|
|
var bool bUseHighDetailOverlayIndex; // Only render the high detail overlay for a specific skin index
|
|
var int HighDetailOverlayIndex; // Which skin index to render the high detail overlay on with bUseHighDetailOverlayIndex is true
|
|
// end _RO_
|
|
|
|
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;
|
|
}
|
|
|
|
static native function UpdateDefaultMesh(Mesh NewMesh);
|
|
static native function UpdateDefaultStaticMesh(StaticMesh NewMesh);
|
|
|
|
//=============================================================================
|
|
// 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
|
|
|
|
// if _RO_
|
|
// Returns the length of time a given animation will take to play at a
|
|
// specific rate
|
|
native final function float GetAnimDuration(name Sequence, optional float Rate);
|
|
// end _RO_
|
|
|
|
// 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();
|
|
|
|
/* begin KFO *================*/
|
|
|
|
/* Returns a list of all events this actor can trigger as well as
|
|
receive. In a basic actor this would simply be the 'Event' and 'Tag' names.
|
|
Objective mode actors override this function because they have more elaborate
|
|
event arrays.*/
|
|
|
|
event GetEvents(out array<name> TriggeredEvents, out array<name> ReceivedEvents)
|
|
{
|
|
if(Event != '')
|
|
{
|
|
TriggeredEvents[TriggeredEvents.length] = Event;
|
|
}
|
|
|
|
ReceivedEvents[ReceivedEvents.length] = Tag;
|
|
}
|
|
|
|
event color GetEventColor()
|
|
{
|
|
return class'Canvas'.static.MakeColor(25,25,255);
|
|
}
|
|
|
|
/* end KFO ===================*/
|
|
|
|
//
|
|
// 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();
|
|
}
|
|
|
|
// if _RO_
|
|
event NotifySelected( Pawn user ); // Notifies this actor that it is selected by a pawn that is looking at it
|
|
// end _RO_
|
|
|
|
//
|
|
// Damage and kills.
|
|
//
|
|
event KilledBy( pawn EventInstigator );
|
|
// if _RO_
|
|
event TakeDamage(int Damage, Pawn EventInstigator, vector HitLocation, vector Momentum, class<DamageType> DamageType, optional int HitIndex);
|
|
// else UT
|
|
// 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
|
|
);
|
|
|
|
native(999) final function Actor HitPointTrace
|
|
(
|
|
out vector HitLocation,
|
|
out vector HitNormal,
|
|
vector TraceEnd,
|
|
out array<int> HitPoints,
|
|
optional vector TraceStart,
|
|
optional vector Extent,
|
|
optional int WhizType,
|
|
optional out material Material
|
|
);
|
|
// WhizType
|
|
// 0 = none
|
|
// 1 = bullet
|
|
// 2 = Tank or Arty shell
|
|
|
|
|
|
// 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;
|
|
|
|
// KF_Begin
|
|
CheckAchievementEvents( EventName, EventInstigator );
|
|
// KF_End
|
|
|
|
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);
|
|
}
|
|
|
|
/** This function was created specifically to check achievement events in a KF level
|
|
* - Greg Felber */
|
|
simulated function CheckAchievementEvents( Name EventName, Pawn EventInstigator )
|
|
{
|
|
local Controller C;
|
|
local PlayerController PC;
|
|
|
|
For ( C=Level.ControllerList; C!=None; C=C.NextController )
|
|
{
|
|
PC = PlayerController(C);
|
|
if ( (PC != None) && ( PC.SteamStatsAndAchievements != none ) )
|
|
{
|
|
PC.SteamStatsAndAchievements.CheckEvents( EventName );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
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);
|
|
}
|
|
|
|
/* Triggered by class KFEventListener - Greg Felber */
|
|
simulated function ReceivedEvent( name EventName );
|
|
|
|
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
|
|
Texture=S_Actor
|
|
DrawScale=+00001.000000
|
|
MaxLights=4
|
|
DrawScale3D=(X=1,Y=1,Z=1)
|
|
SoundRadius=64
|
|
SoundVolume=128
|
|
SoundPitch=64
|
|
ScaleGlow=1.0
|
|
TransientSoundVolume=0.3
|
|
TransientSoundRadius=300.0
|
|
CollisionRadius=+00022.000000
|
|
CollisionHeight=+00022.000000
|
|
bJustTeleported=True
|
|
Mass=+00100.000000
|
|
Role=ROLE_Authority
|
|
RemoteRole=ROLE_DumbProxy
|
|
NetPriority=+00001.000000
|
|
Style=STY_Normal
|
|
bMovable=True
|
|
bHighDetail=False
|
|
bSuperHighDetail=False
|
|
InitialState=None
|
|
NetUpdateFrequency=100
|
|
LODBias=1.0
|
|
MessageClass=class'LocalMessage'
|
|
bHiddenEdGroup=False
|
|
bBlockZeroExtentTraces=true
|
|
bBlockNonZeroExtentTraces=true
|
|
// if _RO_
|
|
bBlockHitPointTraces=true
|
|
// end _RO)
|
|
bReplicateMovement=true
|
|
CullDistance=0.0
|
|
ForceNoise=0.5 // sjs
|
|
bAcceptsProjectors=True
|
|
bLightingVisibility=True
|
|
StaticFilterState=FS_Maybe
|
|
bUseDynamicLights=false
|
|
FluidSurfaceShootStrengthMod=1.f
|
|
bDeferRendering=true
|
|
bSmoothKarmaStateUpdates=True
|
|
}
|