Tutorial: Creating a new & fresh gamesys

Flux on 16/9/2009 at 20:31

This is seriously exciting, good job guys:thumb:

Now the obvious question, can you make a custom volume, more obviously water volume?

So, let me get this straight, you're copy pasting the existing code, then obsolete >edit script, right?

So does this mean, you can copy paste "code" from unreal engine itself? (that's why I get excited about water volumes, because they are right there in ue2.

ascottk on 16/9/2009 at 20:48

Quote Posted by Flux

The physics volume in unreal refers to Karma physics not Havok, but we could take a gander at games that do use unreal + havok if there is one.

Judith on 16/9/2009 at 20:57

And the hierarchy structure is a bit different too, not to mention the differences between UnrealScript and Flesh-specific language. Anyway the hierarchy in UT2004 looks like this:
Actor->Brush->Volume->PhysicsVolume->WaterVolume

I'm no programmer so here are the UT2004 definitions for each if it helps:

Code:

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

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

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

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

// Spatial light effect to use.
var(Lighting) enum ELightEffect
{
LE_None,
LE_TorchWaver,
LE_FireWaver,
LE_WateryShimmer,
LE_Searchlight,
LE_SlowWave,
LE_FastWave,
LE_CloudCast,
LE_StaticSpot,
LE_Shock,
LE_Disco,
LE_Warp,
LE_Spotlight,
LE_NonIncidence,
LE_Shell,
LE_OmniBumpMap,
LE_Interference,
LE_Cylinder,
LE_Rotor,
LE_Negative, // sjs
LE_Sunlight,
LE_QuadraticNonIncidence
} LightEffect;

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

// Drawing effect.
var(Display) const enum EDrawType
{
DT_None,
DT_Sprite,
DT_Mesh,
DT_Brush,
DT_RopeSprite,
DT_VerticalSprite,
DT_Terraform,
DT_SpriteAnimOnce,
DT_StaticMesh,
DT_DrawType,
DT_Particle,
DT_AntiPortal,
DT_FluidSurface
} DrawType;

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

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

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

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

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

struct BatchReference
{
var int BatchIndex,
ElementIndex;
};

var const native array<BatchReference> StaticSectionBatches;

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

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

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

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

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

// Priority Parameters
// Actor's current physics mode.
var(Movement) const enum EPhysics
{
PHYS_None,
PHYS_Walking,
PHYS_Falling,
PHYS_Swimming,
PHYS_Flying,
PHYS_Rotating,
PHYS_Projectile,
PHYS_Interpolating,
PHYS_MovingBrush,
PHYS_Spider,
PHYS_Trailer,
PHYS_Ladder,
PHYS_RootMotion,
PHYS_Karma,
PHYS_KarmaRagDoll,
PHYS_Hovering,
PHYS_CinMotion,
} Physics;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

var(Display) Material UV2Texture;

var(Display) float ScaleGlow;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ifdef WITH_KARMA

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

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

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

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

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

var float AccumKarmaAngleError;

// endif

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

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

enum EForceType
{
FT_None,
FT_DragAlong,
FT_Constant,
};

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

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

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

var bool bAlreadyPrecachedMaterials;
var bool bAlreadyPrecachedMeshes;

//Editing flags
var(Advanced) bool bHiddenEd; // Is hidden during editing.
var(Advanced) bool bHiddenEdGroup;// Is hidden by the group brower.
var(Advanced) bool bDirectional; // Actor shows direction arrow during editing.
var const bool bSelected; // Selected in UnrealEd.
var(Advanced) bool bEdShouldSnap; // Snap to grid in editor.
var transient bool bEdSnap; // Should snap to grid in UnrealEd.
var transient const bool bTempEditor; // Internal UnrealEd.
var bool bObsolete; // actor is obsolete - warn level designers to remove it
var(Collision) bool bPathColliding;// this actor should collide (if bWorldGeometry && bBlockActors is true) during path building (ignored if bStatic is true, as actor will always collide during path building)
var transient bool bPathTemp; // Internal/path building
var bool bScriptInitialized; // set to prevent re-initializing of actors spawned during level startup
var(Advanced) bool bLockLocation; // Prevent the actor from being moved in the editor.

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

var class<LocalMessage> MessageClass;

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

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

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

enum eKillZType
{
KILLZ_None,
KILLZ_Lava,
KILLZ_Suicide
};

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

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

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

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

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

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

native function TextToSpeech( string Text, float Volume );

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

native final function string GetMeshName();

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

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

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

native final function StopLIPSincAnim();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

native final function OnlyAffectPawns(bool B);

// ifdef WITH_KARMA

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

native final function quat KGetRBQuaternion();

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

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

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

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

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

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

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

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

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

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

native final function KSetBlockKarma( bool newBlock );

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

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

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

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

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

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

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

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

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

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

// endif

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

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

native final function AllowMusicPlayback( bool Allow );

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

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

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

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

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

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

//
// Physics & world interaction.
//

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* play a sound effect, but don't propagate to a remote owner
(he is playing the sound clientside)
*/
native simulated final function PlayOwnedSound
(
sound Sound,
optional ESoundSlot Slot,
optional float Volume,
optional bool bNoOverride,
optional float Radius,
optional float Pitch,
optional bool Attenuate
);

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

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

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

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

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

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

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

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

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

// Level state.
event BeginPlay();

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

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

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

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

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

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

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

// Iterator functions for dealing with sets of actors.

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

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

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

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

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

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

/* RadiusActors() returns all actors within a give radius. Slow like AllActors(). Use CollidingActors() or VisibleCollidingActors() instead if desired actor types are visible
(not bHidden) and in the collision hash (bCollideActors is true)
*/
native(310) final iterator function RadiusActors ( class<actor> BaseClass, out actor Actor, float Radius, optional vector Loc );

/* VisibleActors() returns all visible (not bHidden) actors within a radius
for which a trace from Loc (which defaults to caller's Location) to that actor's Location does not hit the world.
Slow like AllActors(). Use VisibleCollidingActors() instead if desired actor types are in the collision hash (bCollideActors is true)
*/
native(311) final iterator function VisibleActors ( class<actor> BaseClass, out actor Actor, optional float Radius, optional vector Loc );

/* VisibleCollidingActors() returns all colliding (bCollideActors==true) actors within a certain radius
for which a trace from Loc (which defaults to caller's Location) to that actor's Location does not hit the world.
Much faster than AllActors() since it uses the collision hash
*/
native(312) final iterator function VisibleCollidingActors ( class<actor> BaseClass, out actor Actor, float Radius, optional vector Loc, optional bool bIgnoreHidden );

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

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

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

event RecoverFromBadStateCode();

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

// RenderTexture
event RenderTexture(ScriptedTexture Tex);

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

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

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

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

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

simulated function UpdatePrecacheMaterials()
{
local int i;

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

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 == None )
break;
else
T =T$GetItemName(string(skins))$", ";
}
}

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

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

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

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

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

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

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

Dir = Location - Spot;

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

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

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

Dir = Location - A.Location;

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

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

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

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

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

if ( EventName == '' )
return;

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

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

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

if ( EventName == '' )
return;

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

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

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

function bool IsInPain()
{
local PhysicsVolume V;

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

function PlayTeleportEffect(bool bOut, bool bSound);

simulated function bool CanSplash()
{
return false;
}

function vector GetCollisionExtent()
{
local vector Extent;

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

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

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

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

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

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

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

function bool SelfTriggered()
{
return false;
}

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

function SetDelayedDamageInstigatorController(Controller C);

function NotifyLocalPlayerDead(PlayerController PC);

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

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

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

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

Code:
//=============================================================================
// The brush class.
// This is a built-in Unreal class and it shouldn't be modified.
//=============================================================================
class Brush extends Actor
native;

//-----------------------------------------------------------------------------
// Variables.

// CSG operation performed in editor.
var() enum ECsgOper
{
CSG_Active, // Active brush.
CSG_Add, // Add to world.
CSG_Subtract, // Subtract from world.
CSG_Intersect, // Form from intersection with world.
CSG_Deintersect, // Form from negative intersection with world.
} CsgOper;

// Outdated.
var const object UnusedLightMesh;
var vector PostPivot;

// Scaling.
// Outdated : these are only here to allow the "ucc mapconvert" commandlet to work.
// They are NOT used by the engine/editor for anything else.
var scale MainScale;
var scale PostScale;
var scale TempScale;

// Information.
var() color BrushColor;
var() int PolyFlags;
var() bool bColored;

Code:
//=============================================================================
// Volume: a bounding volume
// touch() and untouch() notifications to the volume as actors enter or leave it
// enteredvolume() and leftvolume() notifications when center of actor enters the volume
// pawns with bIsPlayer==true cause playerenteredvolume notifications instead of actorenteredvolume()
// This is a built-in Unreal class and it shouldn't be modified.
//=============================================================================
class Volume extends Brush
native;

var Actor AssociatedActor; // this actor gets touch() and untouch notifications as the volume is entered or left
var() name AssociatedActorTag; // Used by L.D. to specify tag of associated actor
var() int LocationPriority;
var() localized string LocationName;
var() edfindable decorationlist DecoList; // A list of decorations to be spawned inside the volume when the level starts

native function bool Encompasses(Actor Other); // returns true if center of actor is within volume

function PostBeginPlay()
{
Super.PostBeginPlay();

if ( AssociatedActorTag != '' )
ForEach AllActors(class'Actor',AssociatedActor, AssociatedActorTag)
break;
if ( AssociatedActor != None )
{
GotoState('AssociatedTouch');
InitialState = GetStateName();
}
}

function DisplayDebug(Canvas Canvas, out float YL, out float YPos)
{
Super.DisplayDebug(Canvas,YL,YPos);
Canvas.DrawText("AssociatedActor "$AssociatedActor, false);
YPos += YL;
Canvas.SetPos(4,YPos);
}

State AssociatedTouch
{
event touch( Actor Other )
{
AssociatedActor.touch(Other);
}

event untouch( Actor Other )
{
AssociatedActor.untouch(Other);
}

function BeginState()
{
local Actor A;

ForEach TouchingActors(class'Actor', A)
Touch(A);
}
}

Code:
//=============================================================================
// PhysicsVolume: a bounding volume which affects actor physics
// Each Actor is affected at any time by one PhysicsVolume
// This is a built-in Unreal class and it shouldn't be modified.
//=============================================================================
class PhysicsVolume extends Volume
native
nativereplication;

var() vector ZoneVelocity;
var() vector Gravity;

var vector BACKUP_Gravity;

var() float GroundFriction;
var() float TerminalVelocity;
var() float DamagePerSec;
var() class<DamageType> DamageType;
var() int Priority; // determines which PhysicsVolume takes precedence if they overlap
var() sound EntrySound; //only if waterzone
var() sound ExitSound; // only if waterzone
var() editinline I3DL2Listener VolumeEffect;
var() class<actor> EntryActor; // e.g. a splash (only if water zone)
var() class<actor> ExitActor; // e.g. a splash (only if water zone)
var() class<actor> PawnEntryActor; // when pawn center enters volume

var() float FluidFriction;
var() vector ViewFlash, ViewFog;

var() bool bPainCausing; // Zone causes pain.
var bool BACKUP_bPainCausing;
var() bool bDestructive; // Destroys most actors which enter it.
var() bool bNoInventory;
var() bool bMoveProjectiles;// this velocity zone should impart velocity to projectiles and effects
var() bool bBounceVelocity; // this velocity zone should bounce actors that land in it
var() bool bNeutralZone; // Players can't take damage in this zone.
var() bool bWaterVolume;
var() bool bNoDecals;
var() bool bDamagesVehicles;

// Distance Fog
var(VolumeFog) bool bDistanceFog; // There is distance fog in this physicsvolume.
var(VolumeFog) color DistanceFogColor;
var(VolumeFog) float DistanceFogStart;
var(VolumeFog) float DistanceFogEnd;

// Karma
var(Karma) float KExtraLinearDamping; // Extra damping applied to Karma actors in this volume.
var(Karma) float KExtraAngularDamping;
var(Karma) float KBuoyancy; // How buoyant Karma things are in this volume (if bWaterVolume true). Multiplied by Actors KarmaParams->KBuoyancy.

var Info PainTimer;
var PhysicsVolume NextPhysicsVolume;

replication
{
// Things the server should send to the client.
reliable if( bNetDirty && (Role==ROLE_Authority) )
Gravity;
}

simulated function PreBeginPlay()
{
if ( Base == None )
{
RemoteRole = ROLE_None;
bAlwaysRelevant = false; // true by default to put it in the networked list of static actors, turn back on if change gravity or base
}
super.PreBeginPlay();
}

simulated function PostBeginPlay()
{
super.PostBeginPlay();

BACKUP_Gravity = Gravity;
BACKUP_bPainCausing = bPainCausing;
if( VolumeEffect == None && bWaterVolume )
VolumeEffect = new(Level.xLevel) class'EFFECT_WaterVolume';
}

/* Reset()
reset actor to initial state - used when restarting level without reloading.
*/
function Reset()
{
Gravity = BACKUP_Gravity;
bPainCausing = BACKUP_bPainCausing;
NetUpdateTime = Level.TimeSeconds - 1;
}

/* Called when an actor in this PhysicsVolume changes its physics mode
*/
event PhysicsChangedFor(Actor Other);

event ActorEnteredVolume(Actor Other);
event ActorLeavingVolume(Actor Other);

simulated event PawnEnteredVolume(Pawn Other)
{
local vector HitLocation,HitNormal;
local Actor SpawnedEntryActor;

if ( bWaterVolume && (Level.TimeSeconds - Other.SplashTime > 0.3) && (PawnEntryActor != None) && !Level.bDropDetail && (Level.DetailMode != DM_Low) && EffectIsRelevant(Other.Location,false) )
{
if ( !TraceThisActor(HitLocation, HitNormal, Other.Location - Other.CollisionHeight*vect(0,0,1), Other.Location + Other.CollisionHeight*vect(0,0,1)) )
{
SpawnedEntryActor = Spawn(PawnEntryActor,Other,,HitLocation,rot(16384,0,0));
}
}

if ( (Role == ROLE_Authority) && Other.IsPlayerPawn() )
TriggerEvent(Event,self, Other);
}

event PawnLeavingVolume(Pawn Other)
{
if ( Other.IsPlayerPawn() )
UntriggerEvent(Event,self, Other);
}

function PlayerPawnDiedInVolume(Pawn Other)
{
UntriggerEvent(Event,self, Other);
}

singular event BaseChange()
{
if ( Base != None )
{
bAlwaysRelevant = true;
RemoteRole = ROLE_DumbProxy;
}
}

/*
TimerPop
damage touched actors if pain causing.
since PhysicsVolume is static, this function is actually called by a volumetimer
*/
function TimerPop(VolumeTimer T)
{
local actor A;
local bool bFound;

if ( T == PainTimer )
{
if ( !bPainCausing )
{
PainTimer.Destroy();
return;
}
ForEach TouchingActors(class'Actor', A)
if ( A.bCanBeDamaged && !A.bStatic )
{
CausePainTo(A);
bFound = true;
}

if ( !bFound )
PainTimer.Destroy();
}
}

function Trigger( actor Other, pawn EventInstigator )
{
local Pawn P;

// turn zone damage on and off
if (DamagePerSec != 0)
{
bPainCausing = !bPainCausing;
if ( bPainCausing )
{
if ( PainTimer == None )
PainTimer = spawn(class'VolumeTimer', self);
ForEach TouchingActors(class'Pawn', P)
CausePainTo(P);
}
}
}

simulated event touch(Actor Other)
{
local Pawn P;
local bool bFoundPawn;

Super.Touch(Other);
if ( Other == None )
return;
if ( (Other.Role == ROLE_Authority) || Other.bNetTemporary )
{
if ( bNoInventory && (Pickup(Other) != None) && (Other.Owner == None) )
{
Other.LifeSpan = 1.5;
return;
}
if ( bMoveProjectiles && (ZoneVelocity != vect(0,0,0)) )
{
if ( Other.Physics == PHYS_Projectile )
Other.Velocity += ZoneVelocity;
else if ( (Other.Base == None) && Other.IsA('Emitter') && (Other.Physics == PHYS_None) )
{
Other.SetPhysics(PHYS_Projectile);
Other.Velocity += ZoneVelocity;
}
}
if ( bPainCausing )
{
if ( Other.bDestroyInPainVolume )
{
Other.Destroy();
return;
}
if ( Other.bCanBeDamaged && !Other.bStatic )
{
CausePainTo(Other);
if ( Other == None )
return;
if ( Role == ROLE_Authority )
{
if ( PainTimer == None )
PainTimer = Spawn(class'VolumeTimer', self);
else if ( Pawn(Other) != None )
{
ForEach TouchingActors(class'Pawn', P)
if ( (P != Other) && P.bCanBeDamaged )
{
bFoundPawn = true;
break;
}
if ( !bFoundPawn )
PainTimer.SetTimer(1.0,true);
}
}
}
}
}
if ( bWaterVolume && Other.CanSplash() )
PlayEntrySplash(Other);
}

simulated function PlayEntrySplash(Actor Other)
{
local vector StartLoc, Vel2D;

if( EntrySound != None )
{
Other.PlaySound(EntrySound, SLOT_Interact, Other.TransientSoundVolume);
if ( Other.Instigator != None )
MakeNoise(1);
}
if( (EntryActor != None) && (Level.NetMode != NM_DedicatedServer) )
{
StartLoc = Other.Location - Other.CollisionHeight*vect(0,0,0.8);
if ( Other.CollisionRadius > 0 )
{
Vel2D = Other.Velocity;
Vel2D.Z = 0;
if ( VSize(Vel2D) > 100 )
StartLoc = StartLoc + Normal(Vel2D) * CollisionRadius;
}
Spawn(EntryActor,,,StartLoc,rot(16384,0,0));
}
}

simulated event untouch(Actor Other)
{
if ( bWaterVolume && Other.CanSplash() )
PlayExitSplash(Other);
}

simulated function PlayExitSplash(Actor Other)
{
if( ExitSound != None )
Other.PlaySound(ExitSound, SLOT_Interact, Other.TransientSoundVolume);
if( (ExitActor != None) && (Level.NetMode != NM_DedicatedServer) )
Spawn(ExitActor,,,Other.Location - Other.CollisionHeight*vect(0,0,0.8),rot(16384,0,0));
}

function CausePainTo(Actor Other)
{
local float depth;
local Pawn P;

// FIXMEZONE figure out depth of actor, and base pain on that!!!
depth = 1;
P = Pawn(Other);

if ( DamagePerSec > 0 )
{
if ( Region.Zone.bSoftKillZ && (Other.Physics != PHYS_Walking) )
return;
Other.TakeDamage(int(DamagePerSec * depth), None, Location, vect(0,0,0), DamageType);
if ( (P != None) && (P.Controller != None) )
P.Controller.PawnIsInPain(self);
}
else
{
if ( (P != None) && (P.Health < P.HealthMax) )
P.Health = Min(P.HealthMax, P.Health - depth * DamagePerSec);
}
}

Code:
class WaterVolume extends PhysicsVolume;

var string EntrySoundName, ExitSoundName, EntryActorName, PawnEntryActorName;

function PostBeginPlay()
{
Super.PostBeginPlay();

if ( (EntrySound == None) && (EntrySoundName != "") )
EntrySound = Sound(DynamicLoadObject(EntrySoundName,class'Sound'));
if ( (ExitSound == None) && (ExitSoundName != "") )
ExitSound = Sound(DynamicLoadObject(ExitSoundName,class'Sound'));
if ( (EntryActor == None) && (EntryActorName != "") )
EntryActor = class<Actor>(DynamicLoadObject(EntryActorName,class'Class'));
if ( (PawnEntryActor == None) && (PawnEntryActorName != "") )
PawnEntryActor = class<Actor>(DynamicLoadObject(PawnEntryActorName,class'Class'));
}

New Horizon on 16/9/2009 at 22:08
Some seriously great work here guys! Congrats. :)

ascottk on 17/9/2009 at 02:02
Quote Posted by Judith
In theory I just built a new volume definition, but how would I put it in here:

Adding a new item here didn't help:
Code:

enum EVolumeType
{
VOLUME_BASIC,
VOLUME_PHYSICS,
VOLUME_LADDER,
VOLUME_AI,
VOLUME_TAG,
VOLUME_AMBIENT_LIGHT,
VOLUME_SHALLOW_WATER,
VOLUME_DEATH_WATER,
VOLUME_FOG,
};

I haven't found anything in the resource hacker either.

Edit: it might be my bad for e.g. DeathWaterVolume extends Volume, not PhysicsVolume in T3.

I added a T3WaterVolume archetype (generic archetype that just acts like a regular volume) that shows up in the editor:
(http://img42.imageshack.us/i/t3watervolumeadd.jpg/)
Inline Image:
http://img42.imageshack.us/img42/9314/t3watervolumeadd.th.jpg
(http://img6.imageshack.us/i/t3watervolumeactorbrows.jpg/)
Inline Image:
http://img6.imageshack.us/img6/7655/t3watervolumeactorbrows.th.jpg
You need to add that archetype instead of just the definition or it won't show up:
Code:
//=============================================================================
// Volume: a bounding volume
// touch() and untouch() notifications to the volume as actors enter or leave it
// enteredvolume() and leftvolume() notifications when center of actor enters the volume
// pawns with bIsPlayer==true cause playerenteredvolume notifications instead of actorenteredvolume()
// This is a built-in Unreal class and it shouldn't be modified.
//=============================================================================
class Volume extends Brush
native;

var() localized string LocationName;

var inherited(173) vector RenderColor;
var inherited(174) string RenderName;

enum EVolumeType
{
VOLUME_BASIC,
VOLUME_PHYSICS,
VOLUME_LADDER,
VOLUME_ROPE,
VOLUME_AI,
VOLUME_TAG,
VOLUME_AMBIENT_LIGHT,
VOLUME_T3WATER,
VOLUME_SHALLOW_WATER,
VOLUME_DEATH_WATER
};

For the T3WaterVolume
Code:
class T3WaterVolume extends PhysicsVolume;

The rope doesn't show up because I don't have an archetype. <strike>I don't get the T3ContextVolumes though . . .</strike> (AIContextVolume.uc under AICore)

Another thing to look at is having a water zone?

New Horizon on 17/9/2009 at 03:12
Fascinating. :) Would be nice to see real water in T3. Best of luck.

Judith on 17/9/2009 at 08:52
Well, I'm not holding my breath yet :) Somehow, things like having a screen tinted or changing the fog appearance (color, start, end, etc.) until now couldn't be changed by volume properties, even if some of those functions seem to be there. Heck, you had the fog and gravity settings in PhysicsVolume all along. But they don't work.

Still, aforementioned settings can be changed by triggerscripts. Now, the question is, can we look into the triggerscript code and apply it to volumes or brushes? Or maybe we can use those UT2004 UnrealScript class definitions in to see which functions are responsible for simulating water environment and try to "translate" it into "FleshScript" language? This might be a naive approach but I'm no coder so basically I'm just wild guessing ;)

New Horizon on 17/9/2009 at 13:53
Quote Posted by Judith
Well, I'm not holding my breath yet :) Somehow, things like having a screen tinted or changing the fog appearance (color, start, end, etc.) until now couldn't be changed by volume properties, even if some of those functions seem to be there. Heck, you had the fog and gravity settings in PhysicsVolume all along. But they don't work.

Still, aforementioned settings can be changed by triggerscripts. Now, the question is, can we look into the triggerscript code and apply it to volumes or brushes? Or maybe we can use those UT2004 UnrealScript class definitions in to see which functions are responsible for simulating water environment and try to "translate" it into "FleshScript" language? This might be a naive approach but I'm no coder so basically I'm just wild guessing ;)

Fingers crossed. Would make for some great T3 Fm's if this works.

ascottk on 17/9/2009 at 16:25
Has anyone looked at the havok sdk?

(http://software.intel.com/sites/havok/)

It's free & it doesn't seem like they send you an email for confirmation or anything. Just fill it out, download, and look . . .

ascottk on 18/9/2009 at 19:01
I was wondering how to add/change properties to a class through the console:

(http://www.ttlg.com/forums/showthread.php?p=1231161#post1231161)

In the console:
Code:
Set Class/ClassvisibleName=Brush bBlocksCamera False
(Just an experiment)

So it changes bBlocksCamera to False for the Brush archetype.

This'll be useful if you had a .bat file in the system directory you can share with other t3edders. Instead of distributing gamesys files you can distribute .bat files the end user can execute through the console:
Quote:
EXEC MyCustomGamesys.bat

Which could include:
Code:
CLASS NEW PARENT=PhysicsVolume PACKAGE=MyGreatGamesys NAME=T3WaterVolume
Set Class/ClassvisibleName=T3WaterVolume LocationName InWater
CREATELINK SOURCE=T3WaterVolume DEST=Garrett TYPE=Association

& by that example you can create links too :thumb: I don't know if you can add triggerscripts to an archetype through the console though.

Would it be worth it to have a utility to create .bat files?

(Rough sketch using SharpDevelop):
(http://img185.imageshack.us/i/t3classcreator.jpg/)
Inline Image:
http://img185.imageshack.us/img185/9986/t3classcreator.th.jpg

I'd imagine having a list of properties and link types you can choose instead of typing them in & if I find a way to add triggerscripts then it's possible to parse the script folder for a list.