Engine.Pawn

//=============================================================================
// Pawn, the base class of all actors that can be controlled by players or AI.
//
// Pawns are the physical representations of players and creatures in a level.  
// Pawns have a mesh, collision, and physics.  Pawns can take damage, make sounds, 
// and hold weapons and other inventory.  In short, they are responsible for all 
// physical interaction between the player or AI and the world.
//
// This is a built-in Unreal class and it shouldn't be modified.
//=============================================================================
class Pawn extends Actor 
	abstract
	native
	placeable
	nativereplication;

#exec Texture Import File=Textures\Pawn.pcx Name=S_Pawn Mips=Off MASKED=1

//NEW
const DyingState					= 'Dying';
const ObservedDeathEvent			= 'ObservedDeath';

// convention: lower values for humanoid creatures
const Team_Invalid					=  -1; // not set
const Team_MinValid					=   0; // should match next value

// player and player teammates
const Team_Player					=   0;

// main characters: will all attack each other (and players) by default any NPCs on TEAM_Ambient with bAmbientCreature = false
const Team_Marine					=   1;
const Team_MercJap					=   2;
const Team_MercMek					=   3;
const Team_MercFem					=   4;
const Team_Skaarj 					=  20;
const Team_Izarian					=  21;
const Team_Shian					=  41;
const Team_Drakk					=  42;
const Team_Araknid					=  43;
const Team_Strider					=  44;
const Team_Kai						=  48;
const Team_Tosc						=  58;

const Team_Spore					=  67; // spores will attack all other non-ambient NPCs

// potentially aggressive NPCs: will attack anything <= Team_AggresiveMax if aggresive
const Team_Ambient					=  85; 

const Team_None						= 100; // will attack/be attacked by all non-ambient NPCs (teams ignored)
const Team_TeamOutcast				= 101; // will be attack/be attacked by NPCs from original team
const Team_ClassOutcast				= 102; // will be attack/be attacked by NPCs of same class (e.g. injured fish).

const Team_MaxValid					= 102; // should match previous value
//OLD

//NEW (mdf) - fix (Acceleration dot X can exceed 0.000023 or more when strafing)
const SwimForwardThreshold = 0.001;
//OLD

//NEW (mdf) support prefering certain types of navigation points

/*
NOTE: be aware that pathing costs are calculated using ints (max of 
0xFFFFFFFF) so you can get overflows if enough large numbers go into its
calculation. The cost of a path is given by its length + the cost associated
with its endpoint. The cost of the endpoint is either its ExtraCost (e.g. if
the LD put it in lava) OR the cost returned by calling the endpoint's
SpecialCost event if it has bSpecialCost set PLUS the sum of the NPCosts
in the SpecialNavigationList for each entry that the endpoint doesn't match
(class doesn't match/isn't a child of the given NPClass). Values along the 
lines of 50000 or so should be plenty to encourage an NPC to use matching 
navigation points as this should outweigh the distance cost.
*/

struct native TSpecialNavigationEntry
{
	var class<NavigationPoint> NPClass;	// class of navigation point to favor
	var int NPCost;						// cost to boost non-matching navigation points by
};
//OLD

//-----------------------------------------------------------------------------
// Pawn variables.

var Controller Controller;

// Physics related flags.
var bool		bJustLanded;		// used by eyeheight adjustment
var bool		bUpAndOut;			// used by swimming 
var bool		bIsWalking;			// currently walking (can't jump, affects animations)
var bool		bSilentCrouch;		//NEW (mdf) true for NPCs which need to crouch to navigate but don't have crouch animations and don't slow down (!!mdf -- ideally fix the problem at the source)
var bool		bWarping;			// Set when travelling through warpzone (so shouldn't telefrag)
/*OLD (mdf)
var bool		bWantsToCrouch;		// if true crouched (physics will automatically reduce collision height to CrouchHeight)
var const bool	bIsCrouched;		// set by physics to specify that pawn is currently crouched
var const bool	bTryToUncrouch;		// when auto-crouch during movement, continually try to uncrouch (NPCs only)
*/
var bool		bCanCrouch;			//NEW (mdf) if true, this pawn is capable of crouch walking/crouching
var bool		bCanCrawl;			//NEW (mdf) if true, this pawn is capable of crawling/going prone
//OLD (mdf) var() bool		bCanCrouch;			// if true, this pawn is capable of crouching
var bool		bCrawler;			// crawling - pitch and roll based on surface pawn is on
var const bool	bReducedSpeed;		// used by movement natives
var	bool		bCanJump;			// movement capabilities - used by AI
var	bool 		bCanWalk;
var	bool		bCanSwim;
var	bool		bCanFly;
var	bool		bCanOpenDoors;		//NEW (mdf) moved here from Controller
var	bool		bCanDoSpecial;		//NEW (mdf) moved Controller //Com: must be true for NPCs to be able to teleport...
var	bool		bCanClimbLadders;
var	bool		bCanStrafe;
var	bool		bAvoidLedges;		// don't get too close to ledges
var	bool		bStopAtLedges;		// if bAvoidLedges and bStopAtLedges, Pawn doesn't try to walk along the edge at all
//NEW (mdf)
var bool		bBlockAdjustJump;	// set to tell controller not to modify velocity of next jump/fall	
var bool		bCanAdjustJump;		// set to tell controller never to modify velocity of a jump/fall (we don't want most singleplayer NPCs jumping to their next destination when they start to fall)
/*OLD
var	bool		bNoJumpAdjust;		// set to tell controller not to modify velocity of a jump/fall	
*/
var	bool		bCountJumps;		// if true, inventory wants message whenever this pawn jumps
var const bool	bSimulateGravity;	// simulate gravity for this pawn on network clients when predicting position (true if pawn is walking or falling)
var	bool		bUpdateEyeheight;	// if true, UpdateEyeheight will get called every tick
//NEW (mdf) moved to Actor and renamed to bIgnoreImpactForces
/*OLD
var() bool		bIgnoreForces;		// if true, not affected by external forces
*/
var const bool	bNoVelocityUpdate;	// used by C++ physics
//NEW (mdf)
var	bool		bCanWalkOffLedges;	// if false, PC/NPC can't walk off ledges when walking (moving at walking speed / bIsWalking=true)
/*OLD
var	bool		bCanWalkOffLedges;	// Can still fall off ledges, even when walking (for Player Controlled pawns)
*/
var bool		bSteadyFiring;		// used for third person weapon anims/effects

//NEW (mdf) Epic removed these in the 777 -> 829 timeframe but we're still using them
var	bool		bIsTurning;			// updated when turning in place (for animation)
var	bool		bTurningLeft;		// updated when turning in place (for animation)
var float		MinIsTurningRate;	// threshold used with rate of change of yaw to determine whether to set bIsTurning
//OLD

var bool		bIgnoreExtraCosts;	// if true, NPCs ignore extra costs given to paths due to force fields etc. (won't prefer to avoid these)

// used by dead pawns (for bodies landing and changing collision box)
var		bool	bThumped;		
var		bool	bInvulnerableBody;

// AI related flags
var		bool	bIsFemale;
var		bool	bAutoActivate;			// if true, automatically activate Powerups which have their bAutoActivate==true
var		bool	bCanPickupInventory;	// if true, will pickup inventory when touching pickup actors   
var		bool	bCanDiscardInventory;	//NEW (mib) if true, will drop inventory when killed
var		bool	bUpdatingDisplay;		// to avoid infinite recursion through inventory setdisplay
var		bool	bAmbientCreature;		// AIs will ignore me
var(AI) bool	bLOSHearing;			// can hear sounds from line-of-sight sources (which are close enough to hear)
										// bLOSHearing=true is like UT/Unreal hearing
var(AI) bool	bSameZoneHearing;		// can hear any sound in same zone (if close enough to hear)
var(AI) bool	bAdjacentZoneHearing;	// can hear any sound in adjacent zone (if close enough to hear)
var(AI) bool	bMuffledHearing;		// can hear sounds through walls (but muffled - sound distance increased to double plus 4x the distance through walls
var(AI) bool	bAroundCornerHearing;	// Hear sounds around one corner (slightly more expensive, and bLOSHearing must also be true)
//NEW (mdf)
/*OLD
var(AI) bool	bDontPossess;			// if true, Pawn won't be possessed at game start
*/
var		byte	FlashCount;				// used for third person weapon anims/effects

// AI basics.
var 	byte	Visibility;				//How visible is the pawn? 0=invisible, 128=normal, 255=highly visible //NEW (mdf) NOTE: scales seeing Pawn's SightRadius by 1/128 * Visibility
var		float	DesiredSpeed;
var		float	MaxDesiredSpeed;
//NEW (mdf) not used with U2
/*OLD
var(AI) name	AIScriptTag;			// tag of AIScript which should be associated with this pawn
*/
var(AI) float	HearingThreshold;		// max distance at which a makenoise(1.0) loudness sound can be heard
var(AI)	float	Alertness;				// -1 to 1 ->Used within specific states for varying reaction to stimuli 
var(AI) bool	bSightRadiusLoseEnemy;  // if true, NPC will lose enemy which is outside of SightRadius (usually only for fog zones)
var(AI)	float	SightRadius;			// Maximum seeing distance.
var(AI)	float	SightRadiusFriend;		//NEW (mdf) Maximum seeing distance for seeing friendly NPCs.
var(AI)	float	SightRadiusFriendAlert;	//NEW (mdf) Maximum seeing distance for seeing alert friendly NPCs (and possibly inheriting their Enemy/alertness).
var(AI)	float	SeenRadius;				//NEW (mdf) Maximum distance at which Pawn will be seen by others.
var(AI)	float	SeenRadiusNoFOV;		//NEW (mdf) Maximum distance at which Pawn will be seen by others without checking others' FOV
var float MaxStepHeight;				//NEW (mdf) step height changes. Never change for NPCs!
//NEW (mdf)
/*
If SeeOtherOdds > 0.0, the line of sight checks don't use the NPC's 
PeripheralVision. The odds determine whether a LOS check is done and
the check is only done from the NPC's eye height to the center of the
target (e.g. enemy) and to the top of the target (eye height or 85% of
collision height used).
*/
//OLD

var(AI)	float	PeripheralVision;	// Cosine of limits of peripheral vision. //NEW (mdf) //NOTE: see above comments!
var(AI) float	SeeOtherOdds;		//NEW (mdf) see above comments
var const float	AvgPhysicsTime;		// Physics updating time monitoring (for AI monitoring reaching destinations)
var float LeapOdds;					// odds NPC will leap if enemy within MinLeapRange..MaxLeapRange
var float LeapMinRange;				// min range for EnemyInLeapRange events (distance between actors)
var float LeapMaxRange;				// max range for EnemyInLeapRange events (distance between actors)
var float MeleeOdds;				// odds NPC will melee if enemy within MeleeRange
var float MeleeRange;				// max range for melee attack (distance between collision cylinders)
var NavigationPoint Anchor;			// current nearest path;
//NEW (mdf) serpentine support
var	const float	DestinationOffset;				// used to vary destination over NavigationPoints
var	const float	NextPathRadius;					// radius of next path in route
var	const vector SerpentineDir;					// serpentine direction
var	const float	SerpentineDist;
var	const float	SerpentineTime;					// how long to stay straight before strafing again
var const float YawRateMultiplier;
var const int PreviousDesiredRotationYaw;		// tracks DesiredRotation.Yaw in physicsRotation in order to scale rotation rate to delta Yaw.
var(Movement) bool	bSmoothTurns;				// if true, turns are smoothed (anticipates destination and moves within reachspec) -- *must* be used with serpentine tactical moves but unless we have problems, probably no reason to turn this off
var(Movement) bool bResortToBasicTacticalMoves; // if true, NPC will resort to basic tactical moves when serpentine requested but not moving along a reachspec (from or to a non-navigation point actor)
var(Movement) int RotationRateYawEnemy;			// yaw rotation rate to use with an enemy (during combat) defaults to RotationRate*X if not set
var(Movement) int RotationRateYawEnemySeen;		// yaw rotation rate to use with an enemy (during combat) defaults to RotationRate*X if not set
var(Movement) bool bScaleRotationRates;			// if true non-enemy rotation rates scaled around a 45 degree yaw difference
var(Movement) bool bScaleRotationRatesEnemy;	// if true enemy rotation rates scaled around a 45 degree yaw difference
var(Movement) ETacticalMoveType TacticalMoveType; // types of tactical moves this NPC does
//OLD
var bool bSpecialNavigation;		//NEW (mdf) if not set, SpecialNavigationList is ignored during pathing
var array<TSpecialNavigationEntry> SpecialNavigationList; //NEW (mdf) if bSpecialNavigation set, used during path building to boost cost of NavigationPoint classes which aren't in the list
var array<Actor> DeathObservers;	//NEW (mdf) list of actors who want to be notified when this Pawn dies

//NEW (mdf)
var private byte Stance;			// current stance
var private byte DesiredStance;		// desired stance -- engine will continually try to switch to desired stance if different from stance
var private byte NavigationStance;	// if not ST_None, stance requested by physics in order to navigate under in tight areas (takes precendence over DesiredStance)
//OLD
var const float	UncrouchTime;		// when auto-crouch during movement, continually try to uncrouch once this decrements to zero

// Movement.
var float   GroundSpeed;    // The maximum ground speed.
var float   WaterSpeed;     // The maximum swimming speed.
var float   AirSpeed;		// The maximum flying speed.
var float	LadderSpeed;	// Ladder climbing speed
var float	AccelRate;		// max acceleration rate
var float	JumpZ;      	// vertical acceleration w/ jump
var float   AirControl;		// amount of AirControl available to the pawn
var float	WalkingPct;		// pct. of running speed that walking speed is
var float	MaxFallSpeed;	// max speed pawn can land without taking damage (also limits what paths AI can use)
var float	MaxJumpDownDistance;		//NEW (mdf) NPC will try to avoid jumping down more than this distance (collapse with MaxFallSpeed?)
var float	MaxJumpUpDistance;			//NEW (mdf) NPC will try to avoid jumping up more than this distance
var float	MaxJumpDistance;			//NEW (mdf) NPC will try to avoid jumping more than this distance
var float	CrouchCostMultiplier;		//NEW (mdf) cost (length) of paths which require crouching scaled by this ( x 1/WalkingPct )
var float	DoorCostMultiplier;			//NEW (mdf) cost (length) of paths through doors scaled by this
var float	FlyCostMultiplier;			//NEW (mdf) cost (length) of paths which require flying scaled by this
var float	JumpCostMultiplier;			//NEW (mdf) cost (length) of paths which require jumping scaled by this
var float	LadderCostMultiplier;		//NEW (mdf) cost (length) of ladder paths scaled by this
var float	SwimCostMultiplier;			//NEW (mdf) cost (length) of paths which require swimming scaled by this

// Player info.
var	string			OwnerName;		// Name of owning player (for save games, coop)
var travel Weapon	Weapon;			// The pawn's current weapon.
var Weapon			PendingWeapon;	// Will become weapon once current weapon is put down
var travel Powerups	SelectedItem;	// currently selected inventory item
var float      		BaseEyeHeight; 	// Base eye height above collision center.
var float			CrouchEyeHeight;//NEW (mdf) set on startup
var float			ProneEyeHeight;	//NEW (mdf) set on startup
var float        	EyeHeight;     	// Current eye height, adjusted for bobbing and stairs.
var	const vector	Floor;			// Normal of floor pawn is standing on (only used by PHYS_Spider and PHYS_Walking)
var float			SplashTime;		// time of last splash
//NEW (mdf) prone support and allow editing crouch sizes
var(Pawn) float		CrouchHeight;	// CollisionHeight when crouching
var(Pawn) float		CrouchRadius;	// CollisionRadius when crouching
var(Pawn) float		ProneHeight;	// CollisionHeight when prone
var(Pawn) float		ProneRadius;	// CollisionRadius when prone
/*OLD 
var float			CrouchHeight;	// CollisionHeight when crouching
var float			CrouchRadius;	// CollisionRadius when crouching
*/
//var	array<TReachInfo> CollisionSizes;	//NEW (mdf) !!mdf-tbd: list of sizes NPC can "assume", e.g. via crouching, going prone, turning into a particle system etc.
var float			OldZ;			// Old Z Location - used for eyeheight smoothing
var PhysicsVolume	HeadVolume;		// physics volume of head
//NEW (mjl)
var() travel int<0,255> Health;		// Health: 100 = normal maximum
/*OLD
var travel int      Health;         // Health: 100 = normal maximum
*/
//NEW (mib)
var() bool			bAlwaysGib;		// turn on gibbing for this pawn (if allowed by the game's current gore level setting)
var() bool			bNeverGib;		// turn off gibbing for this pawn
var() bool			bGibOnInvalidDeathLanding; // gib if landed on a bBlockNavigation actor
var float			GibForSureHealth; // will always gib when health is lower
var float			GibMaybeHealth;	// if health < this when taking damage, NPC gibs depending on GibMaybeOdds
var float			GibMaybeOdds;	// odds to gib at GibMaybeHealth
//OLD

var	float			BreathTime;		// used for getting BreathTimer() messages (for no air, etc.)
var float			UnderWaterTime; // how much time pawn can go without air (in seconds)
//NEW
var	float			LastPainAnimTime;// last time pawn played a pain animation (updated in PlayTakeHit())
/*OLD
var	float			LastPainTime;	// last time pawn played a takehit animation (updated in PlayHit())
*/
var class<DamageType> ReducedDamageType; // which damagetype this creature is protected from (used by AI)

// Sound and noise management
// remember location and position of last noises propagated
var const 	vector 		noise1spot;
var const 	float 		noise1time;
var const	pawn		noise1other;
var const	float		noise1loudness;
var const 	vector 		noise2spot;
var const 	float 		noise2time;
var const	pawn		noise2other;
var const	float		noise2loudness;
var			float		LastPainSound;

// Common sounds
var	sound	HitSound[4];
var	sound	Land;
var	sound	Die;
var sound	BodyLandedSound;

var float SoundDampening;
var float DamageScaling;

var localized  string MenuName; // Name used for this pawn type in menus (e.g. player selection) 

// shadow decal
var Projector	ShadowA,		// Shadow for static lights.
				ShadowB;		// Shadow for dynamic lights (weapon effects).

// shadow overrides
var(Shadows) bool		bForceStaticShadow;
var(Shadows) bool		bForceDynamicShadow;
var(Shadows) bool		bForceLightSourcedShadows;
var(Shadows) bool		bForceDirectionalShadows;
var(Shadows) bool		bForceFullPolyShadows;
var(Shadows) bool		bForceBlobShadows;
var(Shadows) bool		bForceShadowBlur;
var(Shadows) bool		bForceShadowUnBlur;
var(Shadows) vector		ShadowLightDirection;
var(Shadows) float		ShadowLightDistance;
var(Shadows) float		ShadowBoundScale;	// Adjust this for large creatures if shadow extends beyond render area.
var(Shadows) int		ShadowResolution;
var(Shadows) float		ShadowTraceDistance;
var(Shadows) float		ShadowCullDistance;
var(Shadows) float		ShadowInterpolateRate;

// blood effect
var class<Effects> BloodEffect;
var class<Effects> LowDetailBlood;
var class<Effects> LowGoreBlood;

var(AI) class<AIController> ControllerClass;	//NEW (mdf) default class to use when pawn is controlled by AI (can be modified by an AIScript)
//OLD (mdf) var class<AIController> ControllerClass;	// default class to use when pawn is controlled by AI (can be modified by an AIScript)

var() float CarcassCollisionRadius;		//NEW (mdf) collision radius of dead body lying on the ground (defaults to 0.xx*standing collision height if not set)
var() float CarcassCollisionHeight;		//NEW (mdf) collision height of dead body lying on the ground (defaults to 0.xx*standing collision radius if not set)
var(Collision) bool bReducedCylinder;	//NEW (mdf) set once ReduceCylinder called -- LDs can set to not have this change, e.g. for placed carcasses
//OLD var bool bReducedCylinder;	//mdf-tbd: set once ReduceCylinder called

var PlayerReplicationInfo PlayerReplicationInfo;

var LadderVolume OnLadder;		// ladder currently being climbed

var name LandMovementState;		// PlayerControllerState to use when moving on land or air
var name WaterMovementState;	// PlayerControllerState to use when moving in water

// Animation status
var name AnimStatus;
var name AnimAction;			// use for replicating anims 

// Animation updating by physics FIXME - this should be handled as an animation object
// Note that animation channels 2 through 11 are used for animation updating
var vector TakeHitLocation;		// location of last hit (for playing hit/death anims)
var class<DamageType> HitDamageType;	// damage type of last hit (for playing hit/death anims)
var vector TearOffMomentum;		// momentum to apply when torn off (bTearOff == true)
var bool bPhysicsAnimUpdate;	
var bool bWasCrouched;
var bool bWasWalking;
var bool bWasFalling;
var bool bWasOnGround;
var bool bInitializeAnimation;
var bool bPlayedDeath;
var EPhysics OldPhysics;
var float OldRotYaw;			// used for determining if pawn is turning
var vector OldAcceleration;
var name MovementAnims[4];		// Forward, Left, Back, Right
var name TurnLeftAnim;
var name TurnRightAnim;			// turning anims when standing in place (scaled by turn speed)
var float MovementAnimRate[4];	// anim rate scaling for each direction (rate will be blended)
var(Display) float BlendChangeTime;	//NEW (mdf) time to blend between animations
//OLD (mdf) var(AnimTweaks) float BlendChangeTime;	// time to blend between animations
var float MovementBlendStartTime;	// used for delaying the start of run blending

var Actor ControlledActor;		// Actor being controlled by Pawn e.g. KVehicle, WeaponTurret

//NEW (mdf)
var(AI) int TeamNumber;						// Team # -- not used if PlayerReplicationInfo is set
var(AI) bool bFriendlyToPlayerTeam;  		// set to make NPCs not attack player and player teammates
var	bool bIsRealPlayer;						// is a real player
var protected bool bAlert;					// set when Pawn is tense/alert
//tbd:var(AI) EReaction ReactionToPlayer;	// determines how creature will react on seeing player (if in human form)
var const Pawn nextPawn;					// chained PawnList
//OLD

var bool bFallingHitWallNotifications;		//NEW (mib) turns on hit wall events for leaping / flying creatures

replication
{
	// replicated functions sent to server by owning client
	reliable if( Role<ROLE_Authority )
		ServerChangedWeapon;
}

event Replication()
{
	Super.Replication();
	DOREP('PlayerReplicationInfo');
	DOREP('Controller');
	if( bNetOwner )
	{
		DOREP('Health');
		DOREP('SelectedItem');
		DOREP('GroundSpeed');
		DOREP('WaterSpeed');
		DOREP('AirSpeed');
		DOREP('AccelRate');
		DOREP('JumpZ');
		DOREP('AirControl');
	}
	else
	{
//NEW
		DOREP('Weapon');
		//mjl-tbd: only replicate EyeHeight if we are viewing or recording via them. ??
		//DOREP('EyeHeight');
		//viewrotation handled in U2Pawn as CurrentStatus
/*OLD
		DOREP('bSteadyFiring');
*/
	}
	DOREP('HitDamageType');
	DOREP('TakeHitLocation');
	DOREP('AnimStatus');
	DOREP('AnimAction');
	DOREP('bSimulateGravity');
	//OLD (mdf) DOREP('bIsCrouched');
	DOREP('bIsWalking');
	if ( bTearOff )
	{
		DOREP('TearOffMomentum');
	}
	DOREP('Stance'); //NEW (mdf)
	DOREP('DesiredStance'); //NEW (mdf)
}

//NEW (mdf)
native final function AddPawn();
native final function RemovePawn();

// Returns team id from PlayerReplicationInfo if set, TeamNumber otherwise.
native final function int GetTeam();

// Returns true if Other on same team. Uses PRI.TeamInfo if set, TeamNumber 
// otherwise. If bIgnoreAmbientClasses is false (default), ambients 
// (Team_Ambient) will only be considered to be on the same team if they have 
// the same class. Usually bIgnoreAmbientClasses=false in script code where
// SameTeam is used to determine whether NPCs should react to each other
// whereas bIgnoreAmbientClasses=true for the engine code which determines
// whether NPCs should attack each other. Also returns true if either Pawn
// is on the player team and the other pawn has bFriendlyToPlayerTeam=true.
native final function bool SameTeam( Pawn Other, optional bool bIgnoreAmbientClasses, optional bool bIgnoreFriendlyToPlayerTeam );
//OLD

//NEW MJL
simulated function PostRecvOwner()
{
	if( PlayerController(Owner) != None )
	{
		PlayerController(Owner).Possess( Self );
	}
	else
	{
		if( Controller != None && Controller.Pawn == Self )
		{
			PlayerController(Controller).UnPossess();
		}
	}
}
//OLD

/* Reset() 
reset actor to initial state - used when restarting level without reloading.
*/
function Reset()
{
	if ( (Controller == None) || Controller.bIsPlayer )
		Destroy();
	else
		Super.Reset();
}

function String GetHumanReadableName()
{
	if ( PlayerReplicationInfo != None )
		return PlayerReplicationInfo.PlayerName;
	return MenuName;
}

/* PossessedBy()
 Pawn is possessed by Controller
*/
simulated //NEW MJL
function PossessedBy(Controller C)
{
//NEW MJL
	local ENetRole NewRole;
//OLD
	Controller = C;
	NetPriority = 3;
	if ( C.PlayerReplicationInfo != None )
	{
		PlayerReplicationInfo = C.PlayerReplicationInfo;
		OwnerName = PlayerReplicationInfo.PlayerName;
	}
//NEW MJL
	if ( C.IsA('PlayerController') )
		BecomeViewTarget();

	if( C.IsA('PlayerController') )
	{
		if( Role == ROLE_Authority )
			NewRole = C.RemoteRole;
		else
			NewRole = C.Role;
	}
	else
		NewRole = Default.RemoteRole;

	if( Role == ROLE_Authority )
		RemoteRole = NewRole;
	else
		Role = NewRole;
/*OLD
	if ( C.IsA('PlayerController') )
	{
		if ( Level.NetMode != NM_Standalone )
			RemoteRole = ROLE_AutonomousProxy;
		BecomeViewTarget();
	}
	else
		RemoteRole = Default.RemoteRole;
*/
	SetOwner(Controller);	// for network replication
	
	Eyeheight = BaseEyeHeight;

//NEW
/*OLD (mdf) not used for U2
	ChangeAnimation();
*/
}

function UnPossessed()
{	
	PlayerReplicationInfo = None;
	SetOwner(None);
	Controller = None;
}

/* PointOfView()
called by controller when possessing this pawn
false = 1st person, true = 3rd person
*/
simulated function bool PointOfView()
{
	return false;
}

function BecomeViewTarget()
{
	bUpdateEyeHeight = true;
}

function DropToGround()
{
	bCollideWorld = True;
	bInterpolating = false;
	if ( Health > 0 )
	{
		SetCollision(true,true,true);
		SetPhysics(PHYS_Falling);
		AmbientSound = None;
		if ( IsHumanControlled() )
			Controller.GotoState(LandMovementState);
	}
}

//NEW (mdf)
function SetWalking( bool bNewIsWalking )
{
	bIsWalking = bNewIsWalking;

	if( bIsRealPlayer )
	{	
		if( bIsWalking )
			DesiredSpeed = WalkingPct;
		else
			DesiredSpeed = default.DesiredSpeed;
	}
}	
/*OLD
function SetWalking(bool bNewIsWalking)
{
	if ( bNewIsWalking != bIsWalking )
	{
		bIsWalking = bNewIsWalking;
		ChangeAnimation();
	}
}
*/

function bool CanSplash()
{
	if ( (Level.TimeSeconds - SplashTime > 0.25)
		&& ((Physics == PHYS_Falling) || (Physics == PHYS_Flying))
		&& (Abs(Velocity.Z) > 100) )
	{
		SplashTime = Level.TimeSeconds;
		return true;
	}
	return false;
}

//NEW (mdf) ladder grabbing changes sent to me by Steve 02/07/02
function bool CanGrabLadder()
{
	return ( bCanClimbLadders 
			&& (Controller != None)
			&& (Physics != PHYS_Ladder)
			&& (Physics != PHYS_Flying) //NEW (mdf) don't bork flying/ghosted player
//			&& ((Physics != Phys_Falling) || (abs(Velocity.Z) <= JumpZ)) );
			&& ((Physics != Phys_Falling) || (abs(Velocity.Z) <= 1.5*JumpZ)) ); // make it a bit easier to grab ladders?
}
//OLD


//NEW (mdf) Ladder fixes from SteveP to me 02/18/02
event EndClimbLadder()
{
	if( Controller != None )
		Controller.EndClimbLadder();
		
	if( Physics == PHYS_Ladder )
	{
		if( PhysicsVolume.bWaterVolume )
			SetPhysics( PHYS_Swimming );
		else
			SetPhysics( PHYS_Falling );
	}
}
function ClimbLadder( LadderVolume L )
{
	OnLadder = L;
	SetRotation(OnLadder.WallDir);
	SetPhysics(PHYS_Ladder);
	if ( IsHumanControlled() )
		Controller.GotoState( PlayerController.PlayerClimbingState ); //NEW (mdf)
		//OLDController.GotoState( 'PlayerClimbing' );
}
/*OLD
function ClimbLadder(LadderVolume L)
{
	OnLadder = L;

	SetPhysics(PHYS_Ladder);
	if ( IsHumanControlled() )
		Controller.GotoState( PlayerController.PlayerClimbingState );//NEW (mdf)
		//OLDController.GotoState('PlayerClimbing');
}
*/

/* DisplayDebug()
list important actor variable on canvas.  Also show the pawn's controller and weapon info
*/
simulated function DisplayDebug(Canvas Canvas, out float YL, out float YPos)
{
	local string T;
	Super.DisplayDebug(Canvas, YL, YPos);

	Canvas.SetDrawColor(255,255,255);

	Canvas.DrawText("Animation Action "$AnimAction$" Status "$AnimStatus);
	YPos += YL;
	Canvas.SetPos(4,YPos);

//NEW (mdf)
	T = "Floor " $ Floor $ " DesiredSpeed " $ DesiredSpeed $ " Stance " $ Stance $ " Try to uncrouch " $ UncrouchTime;
/*OLD
	T = "Floor "$Floor$" DesiredSpeed "$DesiredSpeed$" Crouched "$bIsCrouched$" Try to uncrouch "$UncrouchTime;
*/	
	if ( (OnLadder != None) || (Physics == PHYS_Ladder) )
		T=T$" on ladder "$OnLadder;
	Canvas.DrawText(T);
	YPos += YL;
	Canvas.SetPos(4,YPos);
	Canvas.DrawText("EyeHeight "$Eyeheight$" BaseEyeHeight "$BaseEyeHeight$" Physics Anim "$bPhysicsAnimUpdate);
	YPos += YL;
	Canvas.SetPos(4,YPos);
	Canvas.SetDrawColor(255,0,0);

	if ( Controller == None )
	{
		Canvas.DrawText("NO CONTROLLER");
		YPos += YL;
		Canvas.SetPos(4,YPos);
	}
	else
		Controller.DisplayDebug(Canvas,YL,YPos);

	Canvas.SetDrawColor(0,255,0);

	if ( Weapon == None )
	{
		Canvas.DrawText("NO WEAPON");
		YPos += YL;
		Canvas.SetPos(4,YPos);
	}
	else
		Weapon.DisplayDebug(Canvas,YL,YPos);
}
		 		
//
// Compute offset for drawing an inventory item.
//
simulated event vector CalcDrawOffset(inventory Inv)
{
	local vector DrawOffset;

//NEW
	DrawOffset = ( Inv.PlayerViewOffset >> GetViewRotation() );
/*OLD
	DrawOffset = ((0.9/Controller.FOVAngle * 100 * Inv.PlayerViewOffset) >> GetViewRotation() );
*/
//NEW MJL: pushes the weapon back an equivalent amount to what is done in U2PlayerController's CalcFirstPersonView
//	DrawOffset -= vector(GetViewRotation())*CollisionRadius;
//OLD

	if ( Controller == None )
		return (Inv.PlayerViewOffset >> Rotation) + BaseEyeHeight * vect(0,0,1);

	DrawOffset = ((0.9/Controller.FOVAngle * 100 * Inv.PlayerViewOffset) >> GetViewRotation() );
//NEW MJL: give everyone the correct baseeyeheight, for use by U2Weapon
	if ( Controller == None || PlayerController(Controller) == None || Viewport(PlayerController(Controller).Player) == None )
/*OLD
	if ( (Level.NetMode == NM_DedicatedServer) 
		|| ((Level.NetMode == NM_ListenServer) && (RemoteRole == ROLE_AutonomousProxy)) )
*/
		DrawOffset.Z += BaseEyeHeight;
	else
	{	
		DrawOffset.Z += EyeHeight;
		DrawOffset += Controller.WeaponBob(Inv.BobDamping);
	}
	return DrawOffset;
}
	
//***************************************
// Interface to Pawn's Controller

// return true if controlled by a Player (AI or human)
simulated function bool IsPlayerPawn()
{
	return ( (Controller != None) && Controller.bIsPlayer );
}

// return true if controlled by a real live human
simulated function bool IsHumanControlled()
{
	return ( PlayerController(Controller) != None );
}

// return true if controlled by local (not network) player
simulated function bool IsLocallyControlled()
{
	if ( Level.NetMode == NM_Standalone )
		return true;
	if ( Controller == None )
		return false;
	if ( PlayerController(Controller) == None )
		return true;

	return ( Viewport(PlayerController(Controller).Player) != None );
}

simulated function rotator GetViewRotation()
{
	if ( Controller == None )
		return Rotation;
	else
		return Controller.Rotation;
}

simulated function SetViewRotation(rotator NewRotation )
{
	if ( Controller != None )
		Controller.SetRotation(NewRotation);
}

final function bool InGodMode()
{
	return ( (Controller != None) && Controller.bGodMode );
}

//NEW (mdf) navigation changes
/*OLD
function bool NearMoveTarget()
{
	if ( (Controller == None) || (Controller.MoveTarget == None) )
		return false;

	return NearSpot(Controller.MoveTarget.Location);
}
*/

//NEW MJL
function bool PressingFire()
{
	return Controller != None && Controller.PressingFire(); 
}
/*OLD
simulated final function bool PressingFire()
{
	return ( (Controller != None) && (Controller.bFire != 0) );
}
*/

//NEW MJL
function bool PressingAltFire()
{
	return Controller != None && Controller.PressingAltFire(); 
}
/*OLD
simulated final function bool PressingAltFire()
{
	return ( (Controller != None) && (Controller.bAltFire != 0) );
}
*/

function Actor GetMoveTarget()
{	
	if ( Controller == None )
		return None;

	return Controller.MoveTarget;
}

function SetMoveTarget(Actor NewTarget )
{
	if ( Controller != None )
		Controller.MoveTarget = NewTarget;
}

function bool LineOfSightTo(actor Other)
{
	return ( (Controller != None) && Controller.LineOfSightTo(Other) );
} 

/* CHANGENOTE: Changes in this function related to the Weapon code updates
*/
//NEW (mdf)
simulated final function bool AdjustAim( class<Projectile> ProjectileClass, float ProjSpeed, vector ProjStart, float WeaponFireSpread, bool bLeadTarget, bool bWarnTarget, bool bTossed, bool bTrySplash )
{
	if( Controller == None )
		return true;

	return Controller.AdjustAim( ProjectileClass, ProjSpeed, ProjStart, WeaponFireSpread, bLeadTarget, bWarnTarget, bTossed, bTrySplash );
}

/* If no controller, returns pawn's Rotation, otherwise returns controller's
Rotation (NPC) AimRotation (player). Native so that native code (e.g. deco
effects) can access this also. */
native final function rotator GetAimRotation();

/*OLD
simulated final function rotator AdjustAim(Ammunition FiredAmmunition, vector projStart, int aimerror)
{
	if ( Controller == None )
		return Rotation;

	return Controller.AdjustAim(FiredAmmunition, projStart, aimerror);
}
*/
//OLD

/* CHANGENOTE: Changes in this function related to the Weapon code updates
*/
function Actor ShootSpecial(Actor A)
{
//NEW (mdf)
	if ( !bCanDoSpecial || (Weapon == None) )
/*OLD
	if ( !Controller.bCanDoSpecial || (Weapon == None) )
*/
		return None;

	//NEW (mdf) renamed to emphasize that weapon not necessarily involved
	Controller.FireAt(A); //OLD Controller.FireWeaponAt(A);
	Controller.bFire = 0;
	return A;
}

function HandlePickup(Pickup pick)
{
	MakeNoise(0.2);
	if ( Controller != None )
		Controller.HandlePickup(pick);
}

event ReceiveLocalizedMessage( class<LocalMessage> Message, optional int Switch, optional PlayerReplicationInfo RelatedPRI_1, optional PlayerReplicationInfo RelatedPRI_2, optional Object OptionalObject )
{
	if ( PlayerController(Controller) != None )
		PlayerController(Controller).ReceiveLocalizedMessage( Message, Switch, RelatedPRI_1, RelatedPRI_2, OptionalObject );
}

event ClientMessage( coerce string S, optional Name Type )
{
	if ( PlayerController(Controller) != None )
		PlayerController(Controller).ClientMessage( S, Type );
}

//NEW (mdf)
function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
/*OLD
function Trigger( Actor Other, Pawn EventInstigator )
*/
{
	if ( Controller != None )
//NEW (mdf)
		Controller.Trigger( Other, EventInstigator, EventName );
/*OLD		
		Controller.Trigger(Other, EventInstigator);
*/
}

//***************************************

function bool CanTrigger(Trigger T)
{
	return true;
}

function GiveWeapon(string aClassName )
{
	local class<Weapon> WeaponClass;
	local Weapon NewWeapon;

	WeaponClass = class<Weapon>(DynamicLoadObject(aClassName, class'Class'));

	if( FindInventoryType(WeaponClass) != None )
		return;
	newWeapon = Spawn(WeaponClass);
	if( newWeapon != None )
		newWeapon.GiveTo(self);
}

function SetDisplayProperties(ERenderStyle NewStyle, Material NewTexture, bool bLighting )
{
	Style = NewStyle;
	Texture = NewTexture;
	bUnlit = bLighting;
	if ( Weapon != None )
		Weapon.SetDisplayProperties(Style, Texture, bUnlit);

	if ( !bUpdatingDisplay && (Inventory != None) )
	{
		bUpdatingDisplay = true;
		Inventory.SetOwnerDisplay();
	}
	bUpdatingDisplay = false;
}

function SetDefaultDisplayProperties()
{
	Style = Default.Style;
	texture = Default.Texture;
	bUnlit = Default.bUnlit;
	if ( Weapon != None )
		Weapon.SetDefaultDisplayProperties();

	if ( !bUpdatingDisplay && (Inventory != None) )
	{
		bUpdatingDisplay = true;
		Inventory.SetOwnerDisplay();
	}
	bUpdatingDisplay = false;
}

//NEW (mdf) not implemented
/*OLD
event FinishedInterpolation(InterpolationPoint Other)
{
	DropToGround();
}
*/

function JumpOutOfWater(vector jumpDir)
{
	//NEW (mdf) falling cleanup
	BeginFalling();
	/*OLD
	//Falling
	*/
	Velocity = jumpDir * WaterSpeed;
	Acceleration = jumpDir * AccelRate;
	velocity.Z = FMax(380,JumpZ); //set here so physics uses this for remainder of tick
	bUpAndOut = true;
}

//NEW (mdf)
function HandleFellOutOfWorld()
{
	Health = -1;
	SetPhysics( PHYS_None );
	Weapon = None;
	Died( None, class'Gibbed', Location, vect(0,0,0) );
}
//OLD

event FellOutOfWorld()
{
	if ( Role < ROLE_Authority )
		return;

//NEW (mdf)
	HandleFellOutOfWorld();		
/*OLD	
	Health = -1;
	SetPhysics(PHYS_None);
	Weapon = None;

	Died( None, class'Gibbed', Location, vect(0,0,0) );
*/
}

//NEW (mdf)
final function bool IsStanding()	{ return ( Stance == ST_Standing ); }
final function bool IsCrouching()	{ return ( Stance == ST_Crouching ); }
final function bool IsProne()		{ return ( Stance == ST_Prone ); }

function SetStance( byte NewStance )
{
	//DMTNS( "SetStance DesiredStance " $ DesiredStance $ " --> " $ NewStance );
	DesiredStance = NewStance;
}

// for use in situations where collision size is adjusted manually
function ForceStance( byte NewStance )
{
	Stance = NewStance;
	DesiredStance = NewStance;
}
	
final function final byte GetStance()
{
	return Stance;
}

final function final byte GetDesiredStance()
{
	return DesiredStance;
}

// Stub events called when physics actually allows stance to change.
// Use these for changing the animation (if script controlled).
event NotifyStanceChange( byte NewStance, float HeightAdjust )
{
	//DMTNS( "NotifyStanceChange  NewStance: " $ NewStance $ " HeightAdjust: " $ HeightAdjust );
	
	if( NewStance == ST_Standing )
		RestoreEyeHeight();
	else if( NewStance == ST_Crouching )
		AdjustEyeHeight( CrouchEyeHeight );
	else
		AdjustEyeHeight( ProneEyeHeight );

	if( Controller != None )	
		Controller.NotifyStanceChange( NewStance, HeightAdjust );	
}

/* ShouldCrouch()
Controller is requesting that pawn crouch
*/
/*OLD (mdf)
function ShouldCrouch(bool Crouch)
{
	bWantsToCrouch = Crouch;
}

// Stub events called when physics actually allows crouch to begin or end
// use these for changing the animation (if script controlled)
event EndCrouch(float HeightAdjust)
{
	EyeHeight += HeightAdjust;
	OldZ += HeightAdjust;
	BaseEyeHeight = Default.BaseEyeHeight;
}

event StartCrouch(float HeightAdjust)
{
	EyeHeight += HeightAdjust;
	OldZ -= HeightAdjust;
	BaseEyeHeight = 0.8 * CrouchHeight;
}
*/

function RestartPlayer();
function AddVelocity( vector NewVelocity)
{

//NEW (mdf) moved to Actor and renamed to bIgnoreImpactForces
	if( bIgnoreImpactForces )
/*OLD	
	if ( bIgnoreForces )
*/
		return;
		
//NEW (mdf) optimization?
	if( NewVelocity == vect(0,0,0) )
		return;
//OLD
	if( (Physics == PHYS_Walking) || (((Physics == PHYS_Ladder) || (Physics == PHYS_Spider)) && (NewVelocity.Z > Default.JumpZ)) )
		SetPhysics( PHYS_Falling );
	
	//!!mdf-tbd: do we need / want this any more?		
	//if ( (Velocity.Z > 380) && (NewVelocity.Z > 0) )
	//	NewVelocity.Z *= 0.5;

	//AddArrow( Location, Location + NewVelocity, ColorOrange() );
			
	Velocity += NewVelocity;
}

function KilledBy( pawn EventInstigator )
{
	local Controller Killer;

	Health = 0;
	if ( EventInstigator != None )
		Killer = EventInstigator.Controller;
	Died( Killer, class'Suicided', Location, vect(0,0,0) );
}

//NEW-COM (mdf) NOTE: not used for U2
function TakeFallingDamage()
{
	local float Shake;

	if (Velocity.Z < -0.5 * MaxFallSpeed)
	{
		MakeNoise(FMin(2.0,-0.5 * Velocity.Z/(FMax(JumpZ, 150.0))));
		if (Velocity.Z < -1 * MaxFallSpeed)
		{
			if ( Role == ROLE_Authority )
				//NEW (mdf) fix (causes warnings in GameInfo Killed function
				TakeDamage(-100 * (Velocity.Z + MaxFallSpeed)/MaxFallSpeed, Self, Location, vect(0,0,0), class'Fell');
				/*OLD
				TakeDamage(-100 * (Velocity.Z + MaxFallSpeed)/MaxFallSpeed, None, Location, vect(0,0,0), class'Fell');
				*/
		}
		if ( Controller != None )
		{
			Shake = FMin(1, -1 * Velocity.Z/MaxFallSpeed);
			Controller.ShakeView(Shake);	//NEW
//OLD		Controller.ShakeView(0.175 + 0.1 * Shake, 850 * Shake, Shake * vect(0,0,1.5), 120000, vect(0,0,10), 1);

		}
	}
}

function ClientReStart()
{
//NEW (mdf)
	StopMovement( true, true );
	RestoreEyeHeight();
/*OLD
	Velocity = vect(0,0,0);
	Acceleration = vect(0,0,0);
	BaseEyeHeight = Default.BaseEyeHeight;
	EyeHeight = BaseEyeHeight;
	PlayWaiting();
*/
}

function ClientSetLocation( vector NewLocation, rotator NewRotation )
{
	if ( Controller != None )
		Controller.ClientSetLocation(NewLocation, NewRotation);
}

function ClientSetRotation( rotator NewRotation )
{
	if ( Controller != None )
		Controller.ClientSetRotation(NewRotation);
}

simulated function FaceRotation( rotator NewRotation, float DeltaTime )
{
	if ( Physics == PHYS_Ladder )
//NEW (mdf) //UDN Bugfix02 (I think WallDir is what we want -- Rotation of LadderVolume isn't relevant currently)
		SetRotation(OnLadder.Walldir); 
/*OLD
		SetRotation(OnLadder.Rotation);
*/
	else
	{
		if ( (Physics == PHYS_Walking) || (Physics == PHYS_Falling) )
			NewRotation.Pitch = 0;
		SetRotation(NewRotation);
	}
}

function ClientDying(class<DamageType> DamageType, vector HitLocation, Pawn InstigatedBy, vector Momentum)
{
	if ( Controller != None )
		Controller.ClientDying(DamageType, HitLocation, InstigatedBy, Momentum);
}

//=============================================================================
// Inventory related functions.

// toss out the weapon currently held
function TossWeapon(vector TossVel)
{
	local vector X,Y,Z;

	Weapon.velocity = TossVel;
	GetAxes(Rotation,X,Y,Z);
//NEW
	Weapon.DropFrom(Location + EyePosition() + 2.0 * CollisionRadius * X );
/*OLD
	Weapon.DropFrom(Location + 0.8 * CollisionRadius * X + - 0.5 * CollisionRadius * Y); 
*/
}	

// The player/bot wants to select next item
exec function NextItem()
{
	local Inventory Inv;

	if (SelectedItem==None) {
		SelectedItem = Inventory.SelectNext();
		Return;
	}
	if (SelectedItem.Inventory!=None)
		SelectedItem = SelectedItem.Inventory.SelectNext(); 
	else
		SelectedItem = Inventory.SelectNext();

	if ( SelectedItem == None )
		SelectedItem = Inventory.SelectNext();
}

// FindInventoryType()
// returns the inventory item of the requested class
// if it exists in this pawn's inventory 

function Inventory FindInventoryType( class DesiredClass )
{
	local Inventory Inv;

	for( Inv=Inventory; Inv!=None; Inv=Inv.Inventory )   
		if ( Inv.class == DesiredClass )
			return Inv;
	return None;
} 

// Add Item to this pawn's inventory. 
// Returns true if successfully added, false if not.
function bool AddInventory( inventory NewItem )
{
	// Skip if already in the inventory.
	local inventory Inv;
	local actor Last;

	Last = self;
	
	// The item should not have been destroyed if we get here.
	if (NewItem ==None )
		log("tried to add none inventory to "$self);

	for( Inv=Inventory; Inv!=None; Inv=Inv.Inventory )
	{
		if( Inv == NewItem )
			return false;
		Last = Inv;
	}

	// Add to back of inventory chain (so minimizes net replication effect).
	NewItem.SetOwner(Self);
	NewItem.Inventory = None;
	Last.Inventory = NewItem;

	if ( Controller != None )
		Controller.NotifyAddInventory(NewItem);

//NEW
	//note: also called in the PostRecvOwner of Inventory on the client, so that inventory received by the pawn go through this interface
	NewItem.NotifyAddInventory( Self );
//OLD

	return true;
}

// Remove Item from this pawn's inventory, if it exists.
function DeleteInventory( inventory Item )
{
	// If this item is in our inventory chain, unlink it.
	local actor Link;

//NEW
	Item.NotifyDeleteInventory( Self );
//OLD
	if ( Item == Weapon )
		Weapon = None;
	if ( Item == SelectedItem )
		SelectedItem = None;
	for( Link = Self; Link!=None; Link=Link.Inventory )
	{
		if( Link.Inventory == Item )
		{
			Link.Inventory = Item.Inventory;
			break;
		}
	}
	Item.SetOwner(None);

//NEW
	if( Controller != None )
		Controller.NotifyRemoveInventory(Item);
//OLD
}

// Just changed to pendingWeapon
function ChangedWeapon()
{
	local Weapon OldWeapon;

	OldWeapon = Weapon;

	if (Weapon == PendingWeapon)
	{
		if ( Weapon == None )
		{
			Controller.SwitchToBestWeapon();
			return;
		}
//NEW
		Weapon.BringUp();
/*OLD
		else if ( Weapon.IsInState('DownWeapon') ) 
			Weapon.GotoState('Idle');
*/
		PendingWeapon = None;
		ServerChangedWeapon(OldWeapon, Weapon);
		return;
	}
	if ( PendingWeapon == None )
		PendingWeapon = Weapon;
		
	Weapon = PendingWeapon;
	if ( (Weapon != None) && (Level.NetMode == NM_Client) )
		Weapon.BringUp();
	PendingWeapon = None;
	Weapon.Instigator = self;
	ServerChangedWeapon(OldWeapon, Weapon);
	if ( Controller != None )
		Controller.ChangedWeapon();
}

function name GetWeaponBoneFor(Inventory I)
{
	return 'righthand';
}

function ServerChangedWeapon(Weapon OldWeapon, Weapon W)
{
	if ( OldWeapon != None )
	{
		OldWeapon.SetDefaultDisplayProperties();
/*OLD //NEW MJL: we don't use Erik's attachment stuff
		OldWeapon.DetachFromPawn(self);		
*/
	}
	Weapon = W;
	if ( Weapon == None )
		return;

/*OLD //NEW MJL: we don't use Erik's attachment stuff
	if ( Weapon != None )
	{
		//log("ServerChangedWeapon: Attaching Weapon to actor bone.");
		Weapon.AttachToPawn(self);
	}

	Weapon.SetRelativeLocation(Weapon.Default.RelativeLocation);
	Weapon.SetRelativeRotation(Weapon.Default.RelativeRotation);
*/

	//NEW (mdf) !!MJL/!!ARL this is happening in dm-deck16iii test vs 3 bots
	if( Inventory == None ) 
		return;
	//OLD

	if ( OldWeapon == Weapon )
	{
		if ( Weapon.IsInState('DownWeapon') ) 
			Weapon.BringUp();
		Inventory.OwnerEvent('ChangedWeapon'); // tell inventory that weapon changed (in case any effect was being applied)
		return;
	}
	else if ( Level.Game != None )
//NEW (mdf)
		MakeNoise( Level.Game.GetNormalizedDifficulty() );
/*OLD	
		MakeNoise(0.1 * Level.Game.Difficulty);	
*/
	Inventory.OwnerEvent('ChangedWeapon'); // tell inventory that weapon changed (in case any effect was being applied)

//NEW (mdf) not used for U2
/*OLD
	PlayWeaponSwitch(W);
*/
	Weapon.BringUp();
}

//==============
// Encroachment
event bool EncroachingOn( actor Other )
{
	//DMTNS( "EncroachingOn " $ Other );
	
	if ( (Other.Brush != None) || (Brush(Other) != None) )
		return true;
		
	if ( ((Controller == None) || !Controller.bIsPlayer || bWarping) && (Pawn(Other) != None) )
		return true;
		
	return false;
}

//NEW (mdf) tbd: don't let Pawns gib each other (do we ever need this?)
/*OLD
event EncroachedBy( actor Other )
{
	if ( Pawn(Other) != None )
		gibbedBy(Other);
}
*/

function gibbedBy(actor Other)
{
//NEW (mdf) go through TakeDamage
	TakeDamage( 10000, Pawn(Other), Other.Location, vect(0,0,0), class'Gibbed' );
/*OLD
	local Controller Killer;

	if ( Role < ROLE_Authority )
		return;
	if ( Pawn(Other) != None )
		Killer = Pawn(Other).Controller;
	Died(Killer, class'Gibbed', Location, vect(0,0,0));
*/	
}

//NEW (mdf) factor out damage handling (so we can override this)
function LaunchOffPawnDamage( Pawn Stompee )
{
	Stompee.TakeDamage( (1-Velocity.Z/400) * Mass/Stompee.Mass, Self, Location,0.5 * Velocity , class'Crushed' );
}
//OLD

//Base change - if new base is pawn or decoration, damage based on relative mass and old velocity
// Also, non-players will jump off pawns immediately
//NEW (mdf) don't jump as far if base pawn is small but don't exceed old limits?
function LaunchPawn( Actor Stompee )
{
	//NEW (mib) jump pawn in opposite direction than the stompee is headed
	local vector LaunchVector; 

	//DMT( "LaunchPawn " $ Self $ " jumping off of Stompee: " $ Stompee $ " Base: " $ Base $ " Velocity: " $ Velocity );
	//AddArrow( Location, Location + Velocity, ColorGreen() );

	// if base isn't moving use VRand like before?
	if( VSize2D( Stompee.Velocity ) ~= 0.0 )
		LaunchVector = VRand();
	else
		LaunchVector = (-Normal(Stompee.Velocity) + RandomSpreadVector(180.0) );
		
	Velocity += (FMin( 100 + CollisionRadius, 10*FMin( CollisionRadius, Base.CollisionRadius ) )) * LaunchVector;
	/*OLD
	Velocity += (FMin( 100 + CollisionRadius, 10*FMin( CollisionRadius, Base.CollisionRadius ) )) * VRand();
	*/
	Velocity.Z = FClamp( 10*FMin( CollisionHeight, Base.CollisionHeight ), 50.0, 200 + CollisionHeight );

	// make sure velocity stays reasonable (in case NPC "stuck" on pawn base)
	if( VSize(Velocity) > 500 )
		Velocity = 500*Normal( Velocity );

	//DMT( Self $ "  almost final velocity: " $ Velocity );

	/*
	Velocity += (800 + CollisionRadius) * VRand();
	Velocity.Z = 200 + CollisionHeight;
	*/	
	
	SetPhysics( PHYS_Falling );
	bBlockAdjustJump = true;
	Controller.SetFall();
	
	//DMT( Self $ "         final velocity: " $ Velocity );
	//AddArrow( Location, Location + Velocity, ColorRed() );
}

/*OLD
function JumpOffPawn()
{
	Velocity += (100 + CollisionRadius) * VRand();
	Velocity.Z = 200 + CollisionHeight;
	SetPhysics(PHYS_Falling);
	bBlockAdjustJump = true;
	Controller.SetFall();
}
*/

singular event BaseChange()
{
	local float decorMass;

	if ( bInterpolating )
		return;
	if ( (base == None) && (Physics == PHYS_None) )
		SetPhysics(PHYS_Falling);
//NEW (mdf) factor out damage handling (so we can override this)
	if( Base != None && Base.bLaunchPawns )
	{
		if( Pawn(Base) != None )
			LaunchOffPawnDamage( Pawn(Base) );
		if( Base != None ) //NOTE: Base could be destroyed in LaunchOffPawnDamage
			LaunchPawn( Base );
/*OLD
		Base.TakeDamage( (1-Velocity.Z/400)* Mass/Base.Mass, Self,Location,0.5 * Velocity , class'Crushed');
		JumpOffPawn();
*/
	}
	else if ( (Decoration(Base) != None) && (Velocity.Z < -400) )
	{
		decorMass = FMax(Decoration(Base).Mass, 1);
		Base.TakeDamage((-2* Mass/decorMass * Velocity.Z/400), Self, Location, 0.5 * Velocity, class'Crushed');
	}
}

//NEW (mdf) 2002.12.02 changes from SteveP to reduce "shake" on stairs
event /*probe*/ UpdateEyeHeight( float DeltaTime )
{
	local float smooth, MaxEyeHeight;
	local float OldEyeHeight;
	local Actor HitActor;
	local vector HitLocation,HitNormal;

	if( Controller == None )
	{
		EyeHeight = 0;
		return;
	}
	
	if( bTearOff )
	{
		EyeHeight = 0;
		bUpdateEyeHeight = false;
		return;
	}
	
	HitActor = Trace( HitLocation, HitNormal, Location + (CollisionHeight + MAXSTEPHEIGHT + 14) * vect(0,0,1), Location + CollisionHeight * vect(0,0,1), true );
	if( HitActor == None )
		MaxEyeHeight = CollisionHeight + MAXSTEPHEIGHT;
	else
		MaxEyeHeight = HitLocation.Z - Location.Z - 14;

	// smooth up/down stairs
	smooth = FMin( 1.0, 10.0 * DeltaTime/Level.TimeDilation );
	if( Controller.WantsSmoothedView() )
	{
		OldEyeHeight = EyeHeight;
		EyeHeight = FClamp( (EyeHeight - Location.Z + OldZ) * (1 - smooth) + BaseEyeHeight * smooth,
							-0.5 * CollisionHeight, 
							MaxEyeheight );
	}
	else
	{
		bJustLanded = false;
		EyeHeight = FMin( EyeHeight * ( 1 - smooth) + BaseEyeHeight * smooth, MaxEyeHeight );
	}
	
	Controller.AdjustView(DeltaTime);
}

/*OLD
event UpdateEyeHeight( float DeltaTime )
{
	local float smooth;
	local float OldEyeHeight;

	if (Controller == None )
	{
		EyeHeight = 0;
		return;
	}

	// smooth up/down stairs
	smooth = FMin(1.0, 10.0 * DeltaTime/Level.TimeDilation);
	if( Controller.WantsSmoothedView() )
	{
		OldEyeHeight = EyeHeight;
		EyeHeight = FClamp((EyeHeight - Location.Z + OldZ) * (1 - smooth) + BaseEyeHeight * smooth,
							-0.5 * CollisionHeight,
							CollisionHeight + FClamp((OldZ - Location.Z), 0.0, MAXSTEPHEIGHT));
	}
	else
	{
		bJustLanded = false;
		EyeHeight = EyeHeight * ( 1 - smooth) + BaseEyeHeight * smooth;
	}
	Controller.AdjustView(DeltaTime);
}
*/

/* EyePosition()
Called by PlayerController to determine camera position in first person view.  Returns
the offset from the Pawn's location at which to place the camera
*/
function vector EyePosition()
{
	return EyeHeight * vect(0,0,1);
}

//=============================================================================

simulated event Destroyed()
{
	local Inventory Inv,Next;

	RemovePawn(); // NEW (mdf)
	
	ClearReferencesTo(); //NEW (mdf) in case Pawn doesn't go through NotifyKilled etc.
	
	if( ShadowA != None )
	{
		ShadowA.Destroy();
		ShadowA = None;
	}
	if( ShadowB != None )
	{
		ShadowB.Destroy();
		ShadowB = None;
	}

	if ( Controller != None )
		Controller.PawnDied();
	if ( Role < ROLE_Authority )
		return;

	Inv = Inventory;
	while ( Inv != None )
	{
		Next = Inv.Inventory;
		Inv.Destroy();
		Inv = Next;
	}	
	Weapon = None;
	Inventory = None;
	Super.Destroyed();
}

//=============================================================================
//
// Called immediately before gameplay begins.
//
simulated //NEW
event PreBeginPlay()
{
	Super.PreBeginPlay();

//NEW (mdf)
	CrouchEyeHeight = default.BaseEyeHeight - (default.CollisionHeight - default.CrouchHeight);
	ProneEyeHeight = 0.5*default.ProneHeight;
	AddPawn();
//OLD
	
	Instigator = self;
	DesiredRotation = Rotation;
	if ( bDeleteMe )
		return;

//NEW (MJL)
	/* This following bit is not done clientside... the actor is ROLE_SimulatedProxy 
       at the moment, so PreSetMovement will not run. So we override PostRecvRole, and 
       also call PreSetMovement when the new ROLE_AutonomousProxy role arrives */
	PreSetMovement();
//NEW (mdf)
	MaybeScaleSettings();
/*OLD
	if ( DrawScale != Default.Drawscale )
	{
		SetCollisionSize(CollisionRadius*DrawScale/Default.DrawScale, CollisionHeight*DrawScale/Default.DrawScale);
		Health = Health * DrawScale/Default.DrawScale;
	}
*/

//NEW (mdf) maybe add a bEyesAboveCC flag to override this?
	if( BaseEyeHeight <= 0 || BaseEyeHeight > CollisionHeight )
		BaseEyeHeight = 0.8 * default.CollisionHeight;
/*OLD
	if ( BaseEyeHeight == 0 )
		BaseEyeHeight = 0.8 * CollisionHeight;
*/
	EyeHeight = BaseEyeHeight;

//NEW (mdf)
	if( MenuName == "" )
		MenuName = string(Name);
/*OLD
	if ( menuname == "" )
		menuname = GetItemName(string(class));
*/

//NEW (mdf)
     if( CarcassCollisionRadius <= 0.0 )
		CarcassCollisionRadius = 0.90 * default.CollisionHeight;
     if( CarcassCollisionHeight <= 0.0 )
		CarcassCollisionHeight = 0.50 * default.CollisionRadius;
//OLD

//NEW (mdf) serpentine support
	SetEnemyRotationRates();
//OLD
}

event PostBeginPlay()
{
	local AIScript A;


	Super.PostBeginPlay();
	SplashTime = 0;
	EyeHeight = BaseEyeHeight;
	OldRotYaw = Rotation.Yaw;

	// automatically add controller to pawns which were placed in level
	// NOTE: pawns spawned during gameplay are not automatically possessed by a controller
//NEW (mdf)
	if( (Level.bStartup || (ControllerClass != None && ControllerClass.default.bShouldPossess)) && Health > 0 )
/*OLD
	if ( Level.bStartup && (Health > 0) && !bDontPossess )
*/
	{
//NEW (mdf) 
/*OLD 
		// check if I have an AI Script
		if ( (AIScriptTag != 'None') && (AIScriptTag != '') )
		{
			ForEach AllActors(class'AIScript',A,AIScriptTag)
				break;
			// let the AIScript spawn and init my controller
			if ( A != None )
			{
				A.SpawnControllerFor(self);
				if ( Controller != None )
					return;
			}
		}
*/		
		if ( (ControllerClass != None) && (Controller == None) )
			Controller = spawn(ControllerClass);
		if ( Controller != None )
			Controller.Possess(self);
	}

	ResetShadows();
}

//
// ResetShadows
//

simulated function ResetShadows()
{
	local bool bStaticShadows;
	local bool bDynamicShadows;

	if(ShadowA?){ ShadowA.Destroy(); ShadowA=None; }
	if(ShadowB?){ ShadowB.Destroy(); ShadowB=None; }

	if(bActorShadows && !bDeleteMe)
	{
		bStaticShadows = (GetClient().MaxShadowsStatic > 0) || bForceStaticShadow;
		bDynamicShadows = (GetClient().MaxShadowsDynamic > 0) || bForceDynamicShadow;

		if(bStaticShadows)
		{
			ShadowA = Spawn(class'ShadowProjector',Self,,Location,Rotation);
			ShadowProjector(ShadowA).bAlwaysAllocate = bForceStaticShadow;
			ShadowProjector(ShadowA).bStaticLights = GetClient().LightSourceShadows;
			if(bForceLightSourcedShadows)	ShadowProjector(ShadowA).bStaticLights = true;
			if(bForceDirectionalShadows)	ShadowProjector(ShadowA).bStaticLights = false;
			InitShadow(ShadowProjector(ShadowA));
		}
/*		if(bDynamicShadows)
		{
			ShadowB = Spawn(class'ShadowProjector',Self,,Location,Rotation);
			ShadowProjector(ShadowB).bDynamicLights = true;
			ShadowProjector(ShadowB).InterpolateRate = 99999;
			ShadowProjector(ShadowB).bAlwaysAllocate = bForceDynamicShadow;
			InitShadow(ShadowProjector(ShadowB));
		}
*/	}
}

//
// InitShadow
//

simulated function InitShadow(ShadowProjector Shadow)
{
	Shadow.ShadowActor = Self;
	Shadow.LightDirection = ShadowLightDirection;
	Shadow.LightDistance = ShadowLightDistance;
	Shadow.BoundScale = ShadowBoundScale;
	Shadow.ShadowResolution = GetClient().ShadowResolution;
	Shadow.MaxTraceDistance = GetClient().ShadowTraceDistance;
	Shadow.VisibilityRadius = GetClient().ShadowCullDistance;
	Shadow.bForceBlobShadow = bForceBlobShadows;
	Shadow.bForceFullPolyShadow = bForceFullPolyShadows;
	Shadow.bBlobShadow = GetClient().BlobShadows;
	Shadow.bBlurShadow = GetClient().BlurShadows;

	if(bForceShadowBlur)			Shadow.bBlurShadow = true;
	if(bForceShadowUnBlur)			Shadow.bBlurShadow = false;
	if(ShadowResolution?)			Shadow.ShadowResolution = ShadowResolution;
	if(ShadowTraceDistance?)		Shadow.MaxTraceDistance = ShadowTraceDistance;
	if(ShadowCullDistance?)			Shadow.VisibilityRadius = ShadowCullDistance;
	if(ShadowInterpolateRate?)		Shadow.InterpolateRate = ShadowInterpolateRate;

	Shadow.InitShadow();
}

// called after PostBeginPlay on net client
//NEW MJL
//once we receive our new role, call PreSetMovement, and it should run if needed
simulated function PostRecvRole()
{
	PreSetMovement();
}

simulated function PostRecvPlayerReplicationInfo()
{
	if ( (PlayerReplicationInfo != None) 
		&& (PlayerReplicationInfo.Owner == None) )
		PlayerReplicationInfo.SetOwner(Controller);
}

/*OLD
simulated event PostNetBeginPlay()
{
	if ( Role == ROLE_Authority )
		return;
	if ( Controller != None )
	{
		Controller.Pawn = self;
		bUpdateEyeHeight = true;
	} 

	if ( (PlayerReplicationInfo != None) 
		&& (PlayerReplicationInfo.Owner == None) )
		PlayerReplicationInfo.SetOwner(Controller);
	PlayWaiting();
}
*/
	
/* PreSetMovement()
default for walking creature.  Re-implement in subclass
for swimming/flying capability
*/
function PreSetMovement()
{
	if (JumpZ > 0)
		bCanJump = true;
	bCanWalk = true;
	bCanSwim = false;
	bCanFly = false;
}

simulated function SetMesh()
{
	mesh = default.mesh;
}

//NEW (mdf) 
function CheckStanceStatus();
function SetMovementPhysics( optional bool bInitializing );
/*OLD
function SetMovementPhysics();
*/
function Gasp();

// NEW (mdf) TakeDamage overhaul
function PlayDying( class<DamageType> DamageType, vector HitLocation, Pawn InstigatedBy, vector Momentum );
function PlayTakeHit( vector HitLocation, int Damage, class<DamageType> DamageType );
function PlayTakeHitSound( int Damage, class<DamageType> DamageType, int Mult );

// was PlayHit -- renamed to HandleTakeHit since this really just plays sounds then calls 
// NotifyTakeHit on Controller which may or may not call PlayTakeHit on the Pawn
function HandleTakeHit( Pawn Instigator, vector HitLocation, float Damage, class<DamageType> DamageType, vector Momentum )
{
	//NOTE: UW829 code wasn't adding velocity if Pawn is dead -- why not?
	
  	AddVelocity( Momentum ); 

	if( Health > 0 )
	{
		if( Damage > 0 || Momentum != vect(0,0,0) ) //!!mdf-tbd
			PlayTakeHitSound( Damage, DamageType, 1 );
			
		if( Controller != None )
			Controller.NotifyTakeHit( Instigator, HitLocation, Damage, DamageType, Momentum );
	}
}

function TakeDamageHandlePhysics( Pawn Instigator, out vector Momentum )
{
	if( Physics == PHYS_None )
		SetMovementPhysics();

	// tend to launch NPC if walking !!mdf-tbd: do even if falling?
	if( Physics == PHYS_Walking || Physics == PHYS_Falling )
		Momentum.Z = FMax( Momentum.Z, 0.4 * VSize( Momentum ) );

	if( Instigator == Self )
		Momentum *= 0.6;
	
	//DMTNS( "TakeDamageHandlePhysics Momentum: " $ VSize( Momentum ) $ " --> " $ VSize( Momentum/Mass ) $ " (Mass=" $ Mass $ ")" );
	
	Momentum = Momentum/Mass;
	
}

function bool PreventDeath( int Damage, Pawn Instigator, class<DamageType> DamageType, vector HitLocation )
{
	return false;
}

function TakeDamage( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	local int ActualDamage;
	local bool bAlreadyDead;
	local Controller Killer;

	if ( Role < ROLE_Authority )
	{
		log( Self $ " client damage type " $ DamageType $ " by " $ Instigator );
		return;
	}

	bAlreadyDead = (Health <= 0);

	//DMTNS( "Pawn.TakeDamage - Damage: " $ Damage $ " Momentum: " $ VSize(Momentum) $ " Type: " $ DamageType $ " Instigator: " $ Instigator $ " new Health: " $ Health $ " Controller: " $ Controller );
	
	TakeDamageHandlePhysics( Instigator, Momentum );

	ActualDamage = Level.Game.ReduceDamage( Damage, Self, Instigator, HitLocation, Momentum, DamageType );

	Health -= ActualDamage;
	if( HitLocation == vect(0,0,0) )
		HitLocation = Location;

	//DMTNS( "Pawn.TakeDamage - ActualDamage: " $ ActualDamage $ " final Momentum: " $ VSize(Momentum) );

	if( bAlreadyDead )
	{
		//!!mdf-tbd: this seems to happen from time to time, e.g. with light araknids. Unless we want to
		// track down the cause of this (in theory a Pawn with Health <= 0 should go to a dying state
		// where it overrides TakeDamage so we shouldn't end up here) we should just disable this warning.
		Warn( Self $ " took regular damage " $ damagetype $ " from " $ Instigator $ " while already dead" );
		if( TryToGib( class'Gibbed', Damage ) )
		{
			return;
		}
	}

	HandleTakeHit( Instigator, HitLocation, ActualDamage, DamageType, Momentum );

	if( Health <= 0 && !PreventDeath( Damage, Instigator, DamageType, HitLocation ) )
	{
		// pawn died
		if( Instigator != None )
			Killer = Instigator.Controller; //FIXME what if killer died before killing you
			
		Died( Killer, DamageType, HitLocation, Momentum );
		
		if( bPhysicsAnimUpdate )
			TearOffMomentum = Momentum;
	}

	MakeNoise( 1.0 );
}
/*OLD
function TakeDamage( int Damage, Pawn instigatedBy, Vector hitlocation, vector momentum, class<DamageType> damageType)
{
	local int actualDamage;
	local bool bAlreadyDead;
	local Controller Killer;

	if ( Role < ROLE_Authority )
	{
		log(self$" client damage type "$damageType$" by "$instigatedBy);
		return;
	}

	bAlreadyDead = (Health <= 0);

	if (Physics == PHYS_None)
		SetMovementPhysics();
	if (Physics == PHYS_Walking)
		momentum.Z = FMax(momentum.Z, 0.4 * VSize(momentum));
	if ( instigatedBy == self )
		momentum *= 0.6;

	momentum = momentum/Mass;

	actualDamage = Level.Game.ReduceDamage(Damage, self, instigatedBy, HitLocation, Momentum, DamageType);

	Health -= actualDamage;
	if ( HitLocation == vect(0,0,0) )
		HitLocation = Location;

	if ( bAlreadyDead )
	{
		Warn(self$" took regular damage "$damagetype$" from "$instigatedby$" while already dead at "$Level.TimeSeconds);
		ChunkUp();
		return;
	}

	PlayHit(actualDamage, hitLocation, damageType, Momentum);

	if ( Health <= 0 )
	{
		// pawn died
		if ( instigatedBy != None )
			Killer = instigatedBy.Controller; //FIXME what if killer died before killing you
		if ( bPhysicsAnimUpdate )
			TearOffMomentum = momentum;
		Died(Killer, damageType, HitLocation);
	}
	MakeNoise(1.0); 
}
*/

//NEW (mdf) factored out and added DeathObservers support
function bool HasDeathObserver( Actor Observer )
{
	local int ii;
	
	for( ii=0; ii<DeathObservers.Length; ii++ )
	{
		if( DeathObservers[ ii ] == Observer )
			return true;
	}
	
	return false;
}

function AddDeathObserver( Actor Observer )
{
	if( !HasDeathObserver( Observer ) )
		DeathObservers[ DeathObservers.Length ]	= Observer;
}

function RemoveDeathObserver( Actor Observer )
{
	local int ii;
	
	for( ii=0; ii<DeathObservers.Length; ii++ )
	{
		if( DeathObservers[ ii ] == Observer )
			DeathObservers.Remove( ii, 1 );
	}
}

function TriggerDeathEvent( Actor Other, Pawn EventInstigator )
{
	local int ii;
	local Actor Observer;
	
	if( Event != '' )
	{
		TriggerEvent( Event, Other, EventInstigator );
		Event = '';
	}
	for( ii=0; ii<DeathObservers.Length; ii++ )
	{
		Observer = DeathObservers[ ii ];
		if( Observer != None && !Observer.bDeleteMe )
			Observer.Trigger( Other, EventInstigator, ObservedDeathEvent );
	}
	
	DeathObservers.Length = 0;
}

function KillSelf()
{
	TriggerDeathEvent( Self, None );
	Destroy();
}
//OLD

//NEW (mdf) various
function Died( Controller Killer, class<DamageType> DamageType, vector HitLocation, vector Momentum )
{
	local Pawn KillerPawn;
	
	if ( bDeleteMe )
		return; //already destroyed
	
	// mutator hook to prevent deaths
	// WARNING - don't prevent bot suicides - they suicide when really needed
	if ( Level.Game.PreventDeath(self, Killer, damageType, HitLocation) )
	{
		Health = Max( Health, 1 ); //mutator should set this higher
		return;
	}
	Health = Min(0, Health);
	Level.Game.Killed(Killer, Controller, self, damageType);

	if ( Killer != None )
		KillerPawn = Killer.Pawn;

	TriggerDeathEvent( Self, KillerPawn );

	Velocity.Z *= 1.3;
	
	if ( IsHumanControlled() )
		PlayerController(Controller).ForceDeathUpdate();
		
	if( !TryToGib( DamageType ) )
	{
		PlayDying(DamageType, HitLocation, KillerPawn, Momentum);
		if ( !Level.Game.bGameEnded )
		{
			if ( RemoteRole == ROLE_AutonomousProxy )
			{
				ClientDying(DamageType, HitLocation, KillerPawn, Momentum);
			}
			else
			{
				GotoState( DyingState );
			}
		}
	}
}
/*OLD
function Died(Controller Killer, class<DamageType> damageType, vector HitLocation)
{
	if ( bDeleteMe )
		return; //already destroyed

	// mutator hook to prevent deaths
	// WARNING - don't prevent bot suicides - they suicide when really needed
	if ( Level.Game.PreventDeath(self, Killer, damageType, HitLocation) )
	{
		Health = max(Health, 1); //mutator should set this higher
		return;
	}
	Health = Min(0, Health);
	Level.Game.Killed(Killer, Controller, self, damageType);

	if ( Killer != None )
		TriggerEvent(Event, self, Killer.Pawn);
	else
		TriggerEvent(Event, self, None);

	Velocity.Z *= 1.3;
	if ( IsHumanControlled() )
		PlayerController(Controller).ForceDeathUpdate();
	if ( (DamageType != None) && (DamageType.default.GibModifier >= 100) )
	{
		ChunkUp();
	}
	else
	{
		PlayDying(DamageType, HitLocation);
		if ( Level.Game.bGameEnded )
			return;
		if ( !bPhysicsAnimUpdate && (RemoteRole == ROLE_AutonomousProxy) )
			ClientDying(DamageType, HitLocation);
	}
}
*/

//NEW (mdf)
function bool HasGibs() { return false; }

function bool TryToGib( class<DamageType> DamageType, optional float Damage )
{
	if( ShouldGib( DamageType, Damage ) )
	{
		ChunkUp();
		return true;
	}
	else return false;
}

function bool ShouldGib( class<DamageType> DamageType, optional float Damage )
{
	local float Odds, PctGibHealth;

	//DMTNS( "ShouldGib Health: " $ Health $ " GibMaybeHealth: " $ GibMaybeHealth $ " GibForSureHealth: " $ GibForSureHealth $ " DamageType: " $ DamageType $ " GoreDetailLevel: " $ GetGoreDetailLevel() );

	if( bDeleteMe )
	{
		//DMTNS("ShouldGib -- bDeleteMe is already true");
		return false; // already destroyed / gibbed?
	}

	if( bAlwaysGib )
	{
		//DMTNS("ShouldGib -- bAlwaysGib set to true");
		return true; // always gibs (even if no gibset)
	}

	if( bNeverGib )
	{
		//DMTNS("ShouldGib -- bNeverGib set to true");
		return false; // edited to not gib
	}

	if( !HasGibs() )
	{
		//DMTNS("ShouldGib -- no gib set");
		return false; // no gibs
	}

	if( DamageType != None && DamageType.default.GibModifier == 0 )
	{
		//DMTNS("ShouldGib -- GibModifier says never gib");
		return false; // modifier says never gib
	}

	if( DamageType != None && DamageType.default.GibModifier >= 100 )
	{
		//DMTNS("ShouldGib -- GibModifier says always gib");
		return true; // modifier says always gib
	}

	if( Health <= GibForSureHealth )
	{
		//DMTNS("ShouldGib -- Health is below gib for sure health");
		return true; // pawn always gibs below this health
	}
	
	if( Health > GibMaybeHealth )
	{
		//DMTNS("ShouldGib -- Health is above gib maybe health");
		return false; // health not long enough
	}

	// denominator should never be zero (will have returned earlier)
	PctGibHealth = (Health - GibMaybeHealth) / (GibForSureHealth - GibMaybeHealth);
	Odds = GibMaybeOdds + PctGibHealth * (1.0 - GibMaybeOdds);
	if( FRand() < Odds )
	{
		//DMTNS("ShouldGib -- random chance at maybe gibbing: Health/GibHealthMaybe/ForSure" @ Health @ "/" @ GibMaybeHealth @ "/" @ GibForSureHealth @ "GibMaybeOdds/FinalOdds:" @ GibMaybeOdds @ "/" @ Odds);
		return true;
	}
}
/*OLD
function bool Gibbed(class<DamageType> damageType)
{
	if ( damageType.default.GibModifier == 0 )
		return false; 
	if ( damageType.default.GibModifier >= 100 )
		return true;	
	if ( (Health <= -80) || ((Health < -40) && (FRand() < 0.6)) )
		return true;
	return false;
}
*/

//NEW (mdf) moved here from Actor and renamed from Falling()
event /*probe*/ BeginFalling()
/*OLD
//function Falling()
*/
{
	//SetPhysics(PHYS_Falling); //Note - physics changes type to PHYS_Falling by default
	if ( Controller != None )
		Controller.SetFall();
}

event /*probe*/ HitWall(vector HitNormal, actor Wall);

//NEW (mdf) U2 approach
event LandedEx( CheckResult Hit )
{
	Super.LandedEx( Hit );

	if( Health > 0 && Controller != None )
	{
		//if( !bIsRealPlayer )
		//	DMTNS( "LandedEx: " $ Hit.Actor $ " Hit.Actor.bBlockNavigation: " $ Hit.Actor.bBlockNavigation $ " Base: " $ Base $ " Velocity: " $ Velocity );
			
		if( Hit.Actor != None && Hit.Actor.bBlockNavigation )
			Controller.NotifyInvalidLanding( Hit );
		else
			Controller.NotifyValidLanding( Hit );
	}
	else if( Health <= 0 && Hit.Actor != None && Hit.Actor.bBlockNavigation && bGibOnInvalidDeathLanding )
	{
		// gib NPC if it died on an invalid surface
		TakeDamage( 9999, None, Location, vect(0,0,0), class'DamageTypeImpact' );
	}
}
/*OLD
event Landed(vector HitNormal)
{
	TakeFallingDamage();

	if ( Health > 0 )
		PlayLanded(Velocity.Z);
	if (Velocity.Z < -1.4 * JumpZ)
		MakeNoise(-0.5 * Velocity.Z/(FMax(JumpZ, 150.0)));
	bJustLanded = true;
}
*/

event /*probe*/ HeadVolumeChange(PhysicsVolume newHeadVolume)
{
	if ( (Level.NetMode == NM_Client) || (Controller == None) )
		return;
	if ( HeadVolume.bWaterVolume )
	{
		if (!newHeadVolume.bWaterVolume)
		{
			if ( Controller.bIsPlayer && (BreathTime > 0) && (BreathTime < 8) )
				Gasp();
			BreathTime = -1.0;
//NEW SBB
			if( IsPlayerPawn() )
				AmbientSound = None;
//OLD
		}
	}
	else if ( newHeadVolume.bWaterVolume )
	{
		BreathTime = UnderWaterTime;
//NEW SBB
		if( IsPlayerPawn() )
			AmbientSound = Sound(DynamicLoadObject( newHeadVolume.UnderwaterSoundStr, class'Sound' ) );
//OLD
	}
}

function bool TouchingWaterVolume()
{
	local PhysicsVolume V;

	ForEach TouchingActors(class'PhysicsVolume',V)
		if ( V.bWaterVolume )
			return true;
			
	return false;
}

//Pain timer just expired.
//Check what zone I'm in (and which parts are)
//based on that cause damage, and reset BreathTime

function bool IsInPain()
{
	local PhysicsVolume V;

	ForEach TouchingActors(class'PhysicsVolume',V)
		if ( V.bPainCausing && (V.DamageType != ReducedDamageType) 
			&& (V.DamagePerSec > 0) )
			return true;
	return false;
}
	
event BreathTimer()
{
	if ( (Health < 0) || (Level.NetMode == NM_Client) )
		return;
	TakeDrowningDamage();
	if ( Health > 0 )
		BreathTime = 2.0;
}

function TakeDrowningDamage();		

function bool CheckWaterJump(out vector WallNormal)
{
	local actor HitActor;
	local vector HitLocation, HitNormal, checkpoint, start, checkNorm, Extent;

	checkpoint = vector(Rotation);
	checkpoint.Z = 0.0;
	checkNorm = Normal(checkpoint);
	checkPoint = Location + CollisionRadius * checkNorm;
	Extent = CollisionRadius * vect(1,1,0);
	Extent.Z = CollisionHeight;
	HitActor = Trace(HitLocation, HitNormal, checkpoint, Location, true, Extent);
	if ( (HitActor != None) && (Pawn(HitActor) == None) )
	{
		WallNormal = -1 * HitNormal;
		start = Location;
//NEW (mdf) step height changes
		start.Z += 1.1 * MaxStepHeight;
/*OLD		
		start.Z += 1.1 * MAXSTEPHEIGHT;
*/
		checkPoint = start + 2 * CollisionRadius * checkNorm;
		HitActor = Trace(HitLocation, HitNormal, checkpoint, start, true);
		if (HitActor == None)
			return true;
	}

	return false;
}

//NEW (mdf) factored out "can jump" code and call HandleJumpSound
function bool CanJump()
{
	return ( IsStanding() && (Physics == PHYS_Walking || Physics == PHYS_Ladder || Physics == PHYS_Spider) );
}

function bool CanCrouch()
{
	return( Physics == PHYS_Walking || Physics == PHYS_Falling );
}

function HandleJumpSound();
function float PlayDodge( eDoubleClickDir DoubleClickMove );
//OLD

//Player Jumped
//NEW (mdf) factored out "can jump" code
function bool DoJump( bool bUpdating )
{
	if( !CanJump() )
		return false;
/*OLD
function DoJump( bool bUpdating )
{
	if ( !bIsCrouched && !bWantsToCrouch && ((Physics == PHYS_Walking) || (Physics == PHYS_Ladder) || (Physics == PHYS_Spider)) )
	{
*/
		if ( Role == ROLE_Authority )
		{
			if( Level.Game != None )
//NEW (mdf)			
				MakeNoise( Level.Game.GetNormalizedDifficulty() );
/*OLD				
				MakeNoise(0.1 * Level.Game.Difficulty);
*/
			if ( bCountJumps && (Inventory != None) )
				Inventory.OwnerEvent('Jumped');
		}
		if ( Physics == PHYS_Spider )
			Velocity = JumpZ * Floor;
//NEW (mdf)
		else if ( Physics == PHYS_Ladder )
		{
			Velocity.Z = 0.5*default.JumpZ; // restrict jumpz somewhat on ladders
		}
//OLD
		else if ( bIsWalking )
			Velocity.Z = Default.JumpZ;
		else
	 		Velocity.Z = JumpZ;
		if ( (Base != None) && !Base.bWorldGeometry )
			Velocity.Z += Base.Velocity.Z; 
		SetPhysics(PHYS_Falling);
//NEW (mdf) factored out "can jump" code and call HandleJumpSound
	HandleJumpSound();
	return true;
/*OLD
	}
*/
}

/*OLD (mdf) not used for U2
function PlayHit(float Damage, vector HitLocation, class<DamageType> damageType, vector Momentum)
{
	local vector BloodOffset, Mo;
	local class<Effects> DesiredEffect;

	if ( (Damage <= 0) && !Controller.bGodMode )
		return;
	if (Damage > 1) //spawn some blood
	{
		DesiredEffect = DamageType.static.GetPawnDamageEffect(HitLocation, Damage, Momentum, self, (Level.bDropDetail || !Level.bHighDetailMode));

		if ( DesiredEffect != None )
		{
			BloodOffset = 0.2 * CollisionRadius * Normal(HitLocation - Location);
			BloodOffset.Z = BloodOffset.Z * 0.5;

			Mo = Momentum;
			if ( Mo.Z > 0 )
				Mo.Z *= 0.5;

			spawn(DesiredEffect,self,,HitLocation + BloodOffset, rotator(Mo));
		}
	}
	if ( Health <= 0 )
	{
		if ( PhysicsVolume.bDestructive && (PhysicsVolume.ExitActor != None) )
			Spawn(PhysicsVolume.ExitActor);
		return;
	}
	if ( Level.TimeSeconds - LastPainTime > 0.1 )
	{
		PlayTakeHit(HitLocation,Damage,damageType);
		LastPainTime = Level.TimeSeconds;
	}
}
*/

/* 
Pawn was killed - detach any controller, and die
*/

// blow up into little pieces (implemented in subclass)		
simulated function ChunkUp()
{
	if ( Controller != None )
	{
		if ( Controller.bIsPlayer )
			Controller.PawnDied();
		else
			Controller.Destroy();
	}
	destroy();
}

//NEW (mdf)
state @ DyingState
{
	ignores Bump, HitWall, HeadVolumeChange, PhysicsVolumeChange, BeginFalling, BreathTimer;

	function PlayWeaponSwitch(Weapon NewWeapon) {}
	function PlayTakeHit(vector HitLoc, int Damage, class<DamageType> damageType) {}
/*OLD
State Dying
{
	//ignores Trigger, Bump, HitWall, HeadVolumeChange, PhysicsVolumeChange, Falling, BreathTimer;
	event ChangeAnimation() {}
	event StopPlayFiring() {}
	function PlayFiring(float Rate, name FiringMode) {}
	function PlayWeaponSwitch(Weapon NewWeapon) {}
	function PlayTakeHit(vector HitLoc, int Damage, class<DamageType> damageType) {}
	simulated function PlayNextAnimation() {}
*/

	function Died(Controller Killer, class<DamageType> damageType, vector HitLocation, vector Momentum)
	{
	}

	//NEW (mib) MinZ (modified version of UT2107 KillZ)
	event FellOutOfWorld()
	{
		Destroy();
	}
	//OLD

	event Timer()
	{
		if ( !PlayerCanSeeMe() )
			Destroy();
		else
			SetTimer(2.0, false);	
	}

	event Landed(vector HitNormal)
	{
		local rotator finalRot;
		local float OldHeight;

		if( Velocity.Z < -500 )
		{
//NEW (mdf)
		   	TakeDamage( (1-Velocity.Z/30),Instigator,Location,vect(0,0,0) , class'DamageTypeImpact' );
/*OLD
			TakeDamage( (1-Velocity.Z/30),Instigator,Location,vect(0,0,0) , class'Crushed' );
*/
		}
		finalRot = Rotation;
		finalRot.Roll = 0;
		finalRot.Pitch = 0;
		setRotation(finalRot);
		SetPhysics(PHYS_None);
		SetCollision(true, false, false);
		if ( !IsAnimating(0) )
			LieStill();
	}

	// prone body should have low height, wider radius
	function ReduceCylinder()
	{
		local float OldHeight, OldRadius;
		local vector OldLocation;

		SetCollision(True,False,False);
		OldHeight = CollisionHeight;
		OldRadius = CollisionRadius;
		SetCollisionSize( CarcassCollisionRadius, CarcassCollisionHeight );
		PrePivot = vect(0,0,1) * (OldHeight - CollisionHeight); // FIXME - changing prepivot isn't safe w/ static meshes
		OldLocation = Location;

		if ( !SetLocation(OldLocation - PrePivot) )
		{
			SetCollisionSize(OldRadius, CollisionHeight);
			if ( !SetLocation(OldLocation - PrePivot) )
			{
				SetCollisionSize(CollisionRadius, OldHeight);
				SetCollision(false, false, false);
//NEW (mdf)
				PrePivot = default.PrePivot;
/*OLD
				PrePivot = vect(0,0,0);
*/
				if ( !SetLocation(OldLocation) )
					TryToGib( class'Crushed' );
			}
		}

		// why? this causes mesh to pop up by 3 units???
		//NEW (mdf) //OLD PrePivot = PrePivot + vect(0,0,3);
		bReducedCylinder = true; //NEW (mdf)
	}

	function LandThump()
	{
		// animation notify - play sound if actually landed, and animation also shows it
		if ( Physics == PHYS_None)
		{
			bThumped = true;
			PlaySound(BodyLandedSound,, 1.0);
		}
	}

	event AnimEnd(int Channel)
	{ 
		if ( Channel != 0 )
			return;
		if ( Physics == PHYS_None )
			LieStill();
		else if ( PhysicsVolume.bWaterVolume )
		{
			bThumped = true;
			LieStill();
		}
	}

	function LieStill()
	{
		if ( !bThumped )
			LandThump();

//NEW (mdf)
		if( !bReducedCylinder )
			ReduceCylinder();
/*OLD			
		if ( CollisionHeight != CarcassCollisionHeight )
			ReduceCylinder();
*/			
	}

	singular event BaseChange()
	{
 		if( base == None )
 		{
			SetPhysics(PHYS_Falling);
		}
		else if ( Pawn(base) != None )
		{
			// don't let corpse ride around on someone's head
			TryToGib( class'Gibbed' );
		}
	}

	function TakeDamage( int Damage, Pawn instigatedBy, Vector hitlocation, 
							Vector momentum, class<DamageType> damageType)
	{
//NEW (mdf)		
		if( !bIgnoreImpactForces )
//OLD		
		SetPhysics(PHYS_Falling);
		
		if ( (Physics == PHYS_None) && (Momentum.Z < 0) )
			Momentum.Z *= -1;
//NEW (mdf)		
		if( !bIgnoreImpactForces )
//OLD		
		Velocity += 3 * momentum/(Mass + 200);
		
		if ( bInvulnerableBody )
			return;
//NEW (mdf)			
		if( DamageType != None )
//OLD	
		Damage *= DamageType.Default.GibModifier;
		Health -=Damage;
		TryToGib( damageType, Damage );
	}

	event BeginState()
	{
		if ( bTearOff && (Level.NetMode == NM_DedicatedServer) )
			LifeSpan = 1.0;
		else
			SetTimer(18.0, false);
		SetPhysics(PHYS_Falling);
		bInvulnerableBody = true;
		if ( Controller != None )
		{
//NEW (mdf) -- PawnDied should be called for non players too -- and let PawnDied decided whether to destroy the Controller
			// Not calling this also means that the Pawn isn't correctly unpossessed?
			Controller.PawnDied();
/*OLD
			if ( Controller.bIsPlayer )
				Controller.PawnDied();
			else
				Controller.Destroy();
*/
		}
	}

Begin:
	Sleep(0.2);
	bInvulnerableBody = false;
}

//=============================================================================
// Animation interface for controllers

/* SetAnimStatus()
Called by controller to set animation status (e.g. relaxed, alert, combat, etc.
*/
//NEW
/*OLD
simulated function SetAnimStatus(name NewStatus)
{
	if ( NewStatus != AnimStatus )
	{
		// anim status change
		AnimStatus = NewStatus;
		ChangeAnimation();
	}
}
*/

/* PlayXXX() function called by controller to play transient animation actions 
*/
//NEW
/*OLD
simulated event PlayDying(class<DamageType> DamageType, vector HitLoc)
{
	GotoState('Dying');
	if ( bPhysicsAnimUpdate )
	{
		bReplicateMovement = false;
		bTearOff = true;
		Velocity += TearOffMomentum;
		SetPhysics(PHYS_Falling);
	}
	bPlayedDeath = true;
}

simulated function PlayFiring(float Rate, name FiringMode);
function PlayWeaponSwitch(Weapon NewWeapon);
simulated event StopPlayFiring()
{
	bSteadyFiring = false;
}

function PlayTakeHit(vector HitLoc, int Damage, class<DamageType> damageType)
{
	if ( Level.TimeSeconds - LastPainSound < 0.25 )
		return;

	if (HitSound[0] == None)return;
	LastPainSound = Level.TimeSeconds;
	if (FRand() < 0.5)
		PlaySound(HitSound[0], SLOT_Pain);
	else
		PlaySound(HitSound[1], SLOT_Pain);
}

//=============================================================================
// Pawn internal animation functions

simulated event ChangeAnimation()
{
	if ( (Controller != None) && Controller.bControlAnimations )
		return;
	// player animation - set up new idle and moving animations
	PlayWaiting();
	PlayMoving();
}
*/

//NEW
/*OLD (mdf) not used for U2
simulated event AnimEnd(int Channel)
{
	if ( Channel == 0 )
		PlayWaiting();
}
*/

// Animation group checks (usually implemented in subclass)

//NEW (mdf)
function bool JumpInProgress()
{
	return false;
}
/*OLD
function bool CannotJumpNow()
{
	return false;
}
*/

//NEW
/*OLD
simulated event PlayJump();
simulated event PlayFalling();
simulated function PlayMoving();
simulated function PlayWaiting();

function PlayLanded(float impactVel)
{
	local float landVol;

	//default - do nothing (keep playing existing animation)
	landVol = impactVel/JumpZ;
	landVol = 0.005 * Mass * landVol * landVol;
	PlaySound(Land, SLOT_Interact, FMin(20, landVol));
	if ( !bPhysicsAnimUpdate )
		PlayLandingAnimation(impactvel);
}

simulated event PlayLandingAnimation(float ImpactVel);
*/

//NEW (mdf)
//-----------------------------------------------------------------------------
// ADDITIONAL INTERFACE FUNCTIONS 
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Pawn became invisible or Controllers should otherwise forget about the Pawn.

function ClearReferencesTo()
{
	local Controller C;

	for( C=Level.ControllerList; C!=None; C=C.NextController )
		C.ClearReferencesTo( Self );
}

//-----------------------------------------------------------------------------

static function bool ValidPawn( Pawn P )
{
	return ( P != None && !P.bDeleteMe && P.Health > 0 && !P.bHidden );
}

//-----------------------------------------------------------------------------

function bool IsPlayer()		{ return Controller != None && Controller.bIsPlayer; }
function bool IsRealPlayer()	{ return Controller != None && PlayerController(Controller) != None; }
function bool IsNPC()			{ return Controller != None && AIController(Controller) != None; }

//-----------------------------------------------------------------------------

function SetTeam( int _TeamNumber )
{
	TeamNumber = _TeamNumber;
}

//-----------------------------------------------------------------------------

function MaybeScaleSettings()
{
	if ( DrawScale != Default.Drawscale )
	{
		SetCollisionSize(CollisionRadius*DrawScale/Default.DrawScale, CollisionHeight*DrawScale/Default.DrawScale);
		Health = Health * DrawScale/Default.DrawScale;
	}
}

/*-----------------------------------------------------------------------------
Master function for mucking with a Pawn's EyeHeight/BaseEyeHeight. Ideally
all eyeheight modifications should pass through this function.

Doesn't generally set EyeHeight if Pawn has bUpdateEyeHeight=true since this
means that the Pawn is being used as the view target for a (real) player and
UpdateEyeHeight will take care of smoothly matching the Pawn's EyeHeight to 
the new BaseEyeHeight.

HeightChange used to adjust EyeHeight when Pawn's collision height changes
(e.g. when crouching) so that the eye height doesn't "jump" for players.
For NPCs which aren't being used as a view target, we don't need to worry 
about this and the EyeHeight will simply get set to the new base eye height.
*/

function AdjustEyeHeight( float NewEyeHeight, optional float HeightChange )
{
	//DMTNS( "AdjustEyeHeight called: " $ NewEyeHeight $ " HeightChange: " $ HeightChange );
	BaseEyeHeight = NewEyeHeight;
	OldZ -= HeightChange;
	if( !bUpdateEyeHeight )
		EyeHeight = BaseEyeHeight;
//? why change base eye height?	BaseEyeHeight = NewBaseEyeHeight;
}

//-----------------------------------------------------------------------------

function SetEyeHeight( float NewEyeHeight )
{
	//DMTNS( "SetEyeHeight called: " $ NewEyeHeight );
	EyeHeight = NewEyeHeight;
	OldZ = Location.Z;
}

//-----------------------------------------------------------------------------

function SetBaseEyeHeight( float NewEyeHeight )
{
	//DMTNS( "SetBaseEyeHeight called: " $ NewEyeHeight );
	BaseEyeHeight = NewEyeHeight;
	if( !bUpdateEyeheight )
		EyeHeight = BaseEyeHeight;
		
	// otherwise UpdateEyeHeight smoothing "overshoots" and actually gives us a very large eyeheight
	OldZ = Location.Z;
}

//-----------------------------------------------------------------------------

function RestoreEyeHeight( optional bool bSnap )
{
	//DMTNS( "RestoreEyeHeight BEGIN BaseEyeHeight: " $ default.BaseEyeHeight $ "  EyeHeight: " $ EyeHeight );
	BaseEyeHeight = default.BaseEyeHeight;
	if( bSnap || !bUpdateEyeHeight )
		EyeHeight = BaseEyeHeight;
	//DMTNS( "RestoreEyeHeight END BaseEyeHeight: " $ default.BaseEyeHeight $ "  EyeHeight: " $ EyeHeight );
}

//-----------------------------------------------------------------------------

function bool IsSentient()
{
	return true;
}

//-----------------------------------------------------------------------------
// true if NPC doesn't use ammo when firing weapon (never runs out).

function bool GetInfiniteAmmo()
{
	return false;
}

//-----------------------------------------------------------------------------

function SetEnemyRotationRates()
{
	if( default.RotationRateYawEnemy == 0 )
		RotationRateYawEnemy = 1.2*default.RotationRate.Yaw;
	else
		RotationRateYawEnemy = default.RotationRateYawEnemy;
		
	if( default.RotationRateYawEnemySeen == 0 )
		RotationRateYawEnemySeen = 2.0*default.RotationRate.Yaw;
	else
		RotationRateYawEnemySeen = default.RotationRateYawEnemySeen;
}

//-----------------------------------------------------------------------------

function EnableRotation( bool bVal )
{
	if( bVal )
	{
		RotationRate = default.RotationRate;
		SetEnemyRotationRates();
	}
	else
	{
		RotationRate = rot(0,0,0);
		RotationRateYawEnemy = 0;
		RotationRateYawEnemySeen = 0;
	}
}

//-----------------------------------------------------------------------------
// true if frozen (can't move and can't shoot etc.)

function bool IsFrozen()		
{ 
	return ( Controller != None && Controller.IsFrozen() );
}

//-----------------------------------------------------------------------------
// true if movement disabled

function bool IsStationary()	
{ 
	return ( Controller != None && Controller.IsStationary() );
}	

//-----------------------------------------------------------------------------
// true if can't move (turrets, frozen/stationary NPCs, controller-less NPCs)

function bool IsMobile()
{ 
	return ( Controller != None && Controller.IsMobile() );
}

//-----------------------------------------------------------------------------

function SetSightRadius( float NewSightRadius )
{
	SightRadius = NewSightRadius;
}

//-----------------------------------------------------------------------------

function RestoreSightRadius()
{
	SightRadius = default.SightRadius;
}
//OLD

defaultproperties
{
	bCanOpenDoors=true
	bCanDoSpecial=true
	bCanWalkOffLedges=true
	MinIsTurningRate=1000.000000
	bCanDiscardInventory=true
	bLOSHearing=true
	Visibility=128
	DesiredSpeed=1.000000
	MaxDesiredSpeed=1.500000
	HearingThreshold=2800.000000
	SightRadius=5000.000000
	SeenRadius=9999999.000000
	MaxStepHeight=35.000000
	AvgPhysicsTime=0.100000
	YawRateMultiplier=1.000000
	PreviousDesiredRotationYaw=9999999
	bSmoothTurns=true
	bResortToBasicTacticalMoves=true
	bSpecialNavigation=true
	Stance=1
	DesiredStance=1
	AccelRate=2048.000000
	AirControl=0.050000
	MaxFallSpeed=1200.000000
	MaxJumpDownDistance=340282346638528860000000000000000000000.000000
	MaxJumpDistance=340282346638528860000000000000000000000.000000
	CrouchCostMultiplier=1.500000
	DoorCostMultiplier=1.200000
	FlyCostMultiplier=1.000000
	JumpCostMultiplier=3.000000
	LadderCostMultiplier=1.200000
	SwimCostMultiplier=2.000000
	BaseEyeHeight=64.000000
	EyeHeight=54.000000
	CrouchHeight=40.000000
	CrouchRadius=34.000000
	ProneHeight=12.000000
	ProneRadius=48.000000
	Health=100
	GibForSureHealth=-9999.000000
	GibMaybeHealth=-9999.000000
	noise1time=-10.000000
	noise2time=-10.000000
	SoundDampening=1.000000
	DamageScaling=1.000000
	ShadowLightDirection=(X=1.000000,Z=2.000000)
	ShadowLightDistance=512.000000
	ShadowBoundScale=35.000000
	ControllerClass=Class'Engine.AIController'
	CarcassCollisionRadius=-1.000000
	CarcassCollisionHeight=-1.000000
	LandMovementState='PlayerWalking'
	WaterMovementState='PlayerSwimming'
	MovementAnimRate(0)=1.000000
	MovementAnimRate(1)=1.000000
	MovementAnimRate(2)=1.000000
	MovementAnimRate(3)=1.000000
	BlendChangeTime=0.250000
	TeamNumber=-1
	DrawType=DT_Mesh
	bCanTeleport=true
	bOwnerNoSee=true
	bStasis=true
	bAcceptsProjectors=true
	bLaunchPawns=true
	bUpdateSimulatedPosition=true
	RemoteRole=ROLE_SimulatedProxy
	Texture=Texture'Engine.S_Pawn'
	TerrainZOffset=5.000000
	bTravel=true
	SoundRadius=9.000000
	SoundVolume=240
	TransientSoundVolume=2.000000
	CollisionRadius=34.000000
	CollisionHeight=78.000000
	bCollideActors=true
	bCollideWorld=true
	bBlockActors=true
	bBlockPlayers=true
	bProjTarget=true
	bBlockStepping=true
	bRotateToDesired=true
	RotationRate=(Pitch=4096,Yaw=50000,Roll=3072)
	NetPriority=2.000000
	bDirectional=true
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleSideBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleSideBars"
}