U2.U2Pawn

//=============================================================================
// U2Pawn.uc
// Created By: Mike Fox
// Created On: 8/01/00
// $Author: Mfox $
// $Date: 3/12/03 12:52p $
// $Revision: 219 $
//=============================================================================
// Interface class for U2 Pawns.
//=============================================================================

class U2Pawn extends LicenseePawn
	config(User)
	abstract;

#exec OBJ LOAD File=..\System\ParticleRes\onfire_fx.u
#exec OBJ LOAD File=..\System\ParticleRes\EMP_Hit_FX.u
#exec OBJ LOAD File=..\System\ParticleRes\Toxic_Hit_FX.u
#exec OBJ LOAD File=..\System\ParticleRes\blood.u
#exec OBJ LOAD File=..\System\ParticleRes\corpse_disappear_FX.u

const MaxTossedItems				= 12;

const DyingPlacedState				= 'DyingPlaced';
const MissionFailedState			= 'MissionFailed';

const CleanupCarcassTimerName		= 'CleanupCarcassTimer';

// error/special textures
const TexExternalPathError			= Texture'JLSSBlue';
const TexInternalPathError			= Texture'JLSSGreen';
const TexMinZError					= Texture'JLSSCyan';
const TexMoveError					= Texture'JLSSMagenta';
const TexScriptLoadError			= Texture'JLSSWhite';
const TexScriptRunError				= Texture'JLSSRed';
const TexOtherError					= Texture'JLSSYellow';
const TexDormant					= Texture'JLSSGrey';

const MaxWalkingAnims				= 8;
const MaxCollectMomentumTime		= 0.25;

enum EErrorType 
{
	ET_ExternalPath,
	ET_InternalPath,
	ET_MinZ,
	ET_Move,
	ET_ScriptLoad,
	ET_ScriptRun,
	ET_Other,
};

struct WalkingAnimInfoT
{
	var float MinSpeed;
	var AnimationControllerInterf.EWalkingAnimType WalkingAnimType;
};

struct MomentumTransferT
{
	var float MomentumTransfer;
	var float Time;
	var int NumHits;	 //mdf-tbr: debug
};

//-----------------------------------------------------------------------------
// Asset components

// main animation classes
var(Pawn) class<AnimationControllerInterf>	AnimationControllerClass;	// type of animation controller class to instantiate
var(Pawn) class<AssetsHelperGeneric>			AssetsHelperClass;		// assets (sounds, effects) class
var(Pawn) class<DamageFilter>	DamageFilterClass;
var(Pawn) array<string> DefaultInventory;
var(Pawn) string DefaultWeapon;
var(Pawn) float TimeBeforeCarcassDestroyed;								// only used if bQuickCarcassCleanup=false, set to 0.0 for carcass to be permanent
var(Pawn) float CarcassPrePivotZ;										// extra PrePivot Z amount for shared animation situations
var(AI) bool bSentient;
var bool bTestAnimHandler;
var bool bServoEnabled;

var float HeadTrackTimer;
var Actor HeadTrackActor;
var float MaxHeadTrackPlayerDistance;		// NPCs won't head track if further away than this from player
var float MaxHeadTrackDistance;				// max distance within which NPCs look for pawns to look at
var bool bHeadTrackingEnabled;
var bool bWeaponAimingEnabled;

// Animations
var AnimationControllerInterf AnimationController;	// animation controller 

// Sounds
var SoundTable SoundTable;
var(Pawn) string VoicePackage;						// pawn-specific voice package
var(Pawn) name VoiceListTag;						// tag of placed voice package list
var(Pawn) class<VoiceList> VoiceListClass;			// default class of voice package list
var(Pawn) float MinTimeBetweenHitSounds;			// don't play hit sounds any closer together than this
var(Sound) name SoundSlotTimerListTag;				// tag of the sound slot timer list placed in the level
var SoundSlotTimerListImpl SoundSlotTimers;			// actual sound slot timer list
var(Pawn) bool bUsesFlavorText;						// set to true for NPCs with recognizable dialog (vocals)
var float FriendDeadSoundDelay;						// time to wait before mourning the death of a teammate
var bool bNoFlavorTextTeamCheck;					// uses flavor text regardless if there is not teammate nearby
var bool bUseSoundSlotTimers;						// set to true for NPCs to use SoundSlotTimer list to clamp sounds
var SoundSlotInterf.ESoundTableSlot RandomAttackSoundSlot;	// usually STS_Attack, but can be, say, STS_Acquire if sounds are the same
var SoundSlotInterf.ESoundTableSlot RandomIdleSoundSlot;	// usually STS_Idle, but can be, say, STS_Misc if sounds are the same
var float MinTimeBetweenRandomSounds;						// usually 0.0, if > 0.0 prevents multiple NPCs from talking over each other
var float MinRandomSoundTime, MaxRandomSoundTime;

var EPhysics MovementPhysics;

var float CrouchingMoveSpeed;
var float ProneMoveSpeed;
var	float StandingMoveSpeed;
var float SetMoveSpeedFudge;						// for fixing existing move speeds if groundspeed changes

var globalconfig float DodgeXYVelocityScale;
var globalconfig float DodgeJumpZScale;
var float MinJumpAnimSpeed;
var float MinLandAnimSpeed;

var float FallTimer;

var WalkingAnimInfoT WalkingAnims[ MaxWalkingAnims ]; // list of walking move speeds and associated animation types
var int NumWalkingAnims;

var(Pawn) string TossedItems[ MaxTossedItems ]; // things that are spawned and tossed by the Pawn upon death

var float RemainingPowerSuitEnergy;		// Tracks how much energy was remaining in the powersuit when this pawn was killed
var DroppedEnergyPickup DroppedEnergy;
var bool bRagdollDeath;

// knockdowns
var bool	bCanKnockDown;					// Pawn can be knocked down by damage/momentun
var float	MinKnockDownMomentumThreshold;	// momentum >= this will knock NPC down
var float	MinTimeBetweenKnockDowns;
var float	LastKnockDownTime;
var float	LastMomentumTransferTime;
var array<MomentumTransferT> CollectedMomentumTransfer;
var int CurrentMomentumTransferSlot;
var float TotalRecentMomentumTransfer;
#debugbegin
var int TotalRecentHits;
#debugend

// panic
var float StopPanicTime;
var float MinPanicTime;
var(AI) bool bCanPanic;
var class<DamageType> PanicDamageType;
var Sound CurPanicSound;
var float PanicSoundPauseSeconds;
var Pawn PanicDamageInstigator;

var float MaxAliveAddedVelocity; // cap AddVelocity velocity when alive
var float MaxDeadAddedVelocity;	// cap AddVelocity velocity when dead
var FlameDamager FDamager;
var U2UseManager UseManager;
var array<U2UseManagerPlayer> AlternateUseManagers;
var array<actor> UsableActors;		// list of all usable actors in the level (minus XMP components)

// texture-specific sounds caching
var int NumTextureSounds;
var int TextureSoundIndices[ 4 ];
var class<TextureHelperGeneric> LastSoundClass;
var Material.ETextureType LastTextureType;

var(Pawn) localized string Description; // for displaying text different from the speaker string

var(Pawn) byte LowGoreMeshGoreLevel;
var(Pawn) Mesh LowGoreMesh;

var float TimeSinceBeginState;					// used with some states to track how long NPC in that state

// sinking carcasses
var(Pawn) bool bQuickCarcassCleanup;			// if true, carcass will be cleaned up quickly, otherwise see TimeBeforeCarcassDestroyed
var float TotalCarcassSinkDistance;				// cumulative distance the carcass has sunk
var bool bSinkCarcass;							// if set, carcass will sink
var bool bShrinkCarcass;						// if set, carcass will shrink
var float CarcassSinkRatePerSec;				// computed speed of sinking
var float CarcassSinkRatePerSecMin;				// computed speed of sinking (min)
var float CarcassSinkRatePerSecMax;				// computed speed of sinking (max)
var float CarcassSinkRatePerSecInc;				// computed speed of sinking (rate of increase)
var float CarcassShrinkRateX, CarcassShrinkRateY, CarcassShrinkRateZ;
var ParticleRadiator CarcassFadeTemplate;			// special effect to hide carcasses disappearing
var ParticleRadiator CarcassFadeEffect;

//-----------------------------------------------------------------------------
// AI

var(AI) string				CommandFileName; 								// file to use with event controller if given/applicable
var(AI) string				CommandStartLabel;								// optional label to start at instead of top of script
var(AI) bool				bInfiniteAmmo;									// if true NPC never runs out of ammo (all non-bots?)
var(AI) bool				bReloadsEnabled;								// if false NPC never reloads weapon
var(AI) bool				bFrozen;										// set to true to have NPC frozen on startup (can't move/shoot/turn)
var(AI) bool				bStationary;									// set to true to have NPC stationary on startup (can't move but can shoot/turn)
var(AI) float				DeadBuoyancy;									// how much buoyancy NPC should have when dead (default = 0 ==> sinks like pig iron)
var globalconfig bool		bDisableErrorColors;							// if true, colors not changed on NPC pathing error etc.
var globalconfig bool		bDisableErrorMessages;							// if true, no error messages on NPC pathing error etc.

var float DrowningDamageAmount;

/*
mjl-tbd: can we do this through golem now? no other U2 code currently uses these vars
Set/GetMultiSkin handle this stuff now ... cdh handles this?
we should have the current 'skin' settings specified in the playerreplicationinfo
	as simple strings, to be loaded dynamically on the fly via golem
offer a fallback, either to default male, or a random normal skin?
also must handle sounds/grunts ... works independantly of the model choice?
what is the plan for voicepacks? are we using them at all?

var int			FaceSkin;
var int			FixedSkin;
var int			TeamSkin1;
var int			TeamSkin2;
var int			MultiLevel;
var string		DefaultSkinName;
*/

var string		DefaultPackage;

// Body parts and other death related stuff
//!!MB-uw: var class<UTHeads> HeadClass; 
//!!MB-uw: var class<UTMasterCreatureChunk> MasterReplacement;

// HUD status 
var texture StatusDoll, StatusBelt;

// allowed voices
var string VoicePackMetaClass;
var string VoiceType;

// used to save off LD-set (initial) value so can be restored without using default and spamming the LD-set value
var int InitialHealth;
var float InitialSightRadius;
var float InitialHearingThreshold;
var float InitialAlertness;

//!!cdh (mdf) tbr: used for NPCs which do not have _NW death anims (also maybe 
//_NW can go away and maybe we could have NPCs sometimes hold onto their 
//weapons after dying & turn these into pickups once the lie still?
var LicenseePawn.EWeaponAnimationType DeathWAT;

//-----------------------------------------------------------------------------
//Networking

var bool bReceivedInitialStatus, bReceivedInitialWeapon; //whether or not the client has received it's first variable yet ... see below

var struct SCurrentStatus {
	var int<0,3> NumFires; //set in U2PlayerController.Fire
	var int<0,3> NumAltFires; //set in U2PlayerController.AltFire
	var bool bFiring; //set in U2PlayerNetTestController.ServerMoveEx
	var bool bAltFiring; //set in U2PlayerNetTestController.ServerMoveEx
//	var bool bReloading;
//	var bool bDuck; //taken from coll. cyl?
//	var bool bCrawl; //taken from coll. cyl?
//	var bool bWalk; //taken from speed?
//	var bool bMantling; //uhoh :)
//	var bool bJumping;
	var int<0,65535,32> Yaw; //set in U2PlayerNetTestController.ServerMoveEx
	var int<0,65535,64> Pitch; //set in U2PlayerNetTestController.ServerMoveEx
} CurrentStatus, OldStatus;

var Weapon OldWeapon;

var array<U2Inventory> AdditionalDamageFilters;
var array<U2Inventory> WeaponDamageItems;

var bool bOverridesDamageEffect;
var float DamageEffectOffsetMultiplier;		// increase / decrease from default if mesh close to / far from collision cylinder
// if you add new damage effects, please update StopDamageEffects() down below
var ParticleRadiator FlameEffect;
var ParticleRadiator EMPEffect;
var ParticleRadiator ToxicEffect;
var ParticleGenerator ParticleHitEffect; // pawn-specific hit effect (Drakk metal, green blood, etc.)

var float DamageIndicatorAngle;

// gibs
var(Pawn) class<GibSet> GibSetClass;		// class for gliblety bits
var ParticleRadiator GibbedEffect;			// blood effect when gibbed
var(Pawn) float LoopDeathAnimRate;			// if > 0.0, placed carcassees will loop specified animation (AnimSequence) at this rate

// navigation error debug properties
var bool bCauseMoveTargetNavError;
var bool bCauseScriptedNavError;

struct SInitialAgentInput
{
	var name InputName;
	var name InputValue;
};
var array<SInitialAgentInput> InitialAgentInputs;

//-----------------------------------------------------------------------------
//mjl-tbd: do clientside interpolation of the viewrotation....

event Replication()
{
	Super.Replication();
	if( !bNetOwner && Controller != None )
		DOREP('CurrentStatus');
}

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

simulated function PreRecvCurrentStatus()
{
	OldStatus = CurrentStatus;
}

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

simulated function PostRecvCurrentStatus()
{
	//if this pawn is not 'our' pawn, it does not have a controller replicated to us
	//set local pawn's rotation if not the owner?
	SetRotation(rot(1,0,0) * CurrentStatus.Pitch + rot(0,1,0) * CurrentStatus.Yaw);

	// if this is the first replication for this pawn, and we aren't currently firing, 
	//    ignore the NumFires distinction, since it will usually be different from the default '0'
	if( !bReceivedInitialStatus )
	{
		bReceivedInitialStatus = true;
		if( Weapon != None )
		{
			if( CurrentStatus.bFiring )
				Weapon.Fire();
			else if( CurrentStatus.bAltFiring )
				Weapon.AltFire();
		}
		return;
	}

	if( Weapon != None )
	{
		if( OldStatus.NumFires != CurrentStatus.NumFires )
			Weapon.Fire();
		else if( OldStatus.NumAltFires != CurrentStatus.NumAltFires )
			Weapon.AltFire();
	}
}

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

simulated function PreRecvWeapon()
{
	OldWeapon = Weapon;
}

//-----------------------------------------------------------------------------
//weapon is only replicated for pawns we don't own

simulated function PostRecvWeapon()
{
	if( Weapon != OldWeapon && Weapon != None && !bReceivedInitialWeapon )
		Weapon.PlaySelect();
	bReceivedInitialWeapon = true;
}

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

event TravelPreAccept()
{
	Super.TravelPreAccept();
	// when traveling, the current weapon sometimes gets taken out of the idle state
	// preventing weapon switching until the current weapon is fired.
	if( Weapon != None )
		Weapon.GotoState( 'Idle' );
}

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

event Tick( float DeltaTime )
{
	Super.Tick( DeltaTime );

	//DMTNS( "Tick -- bStasis: " $ bStasis $ " bServoEnabled: " $ bServoEnabled $ " AnimationController: " $ AnimationController );
	//DMTNS( "Tick - LRT: " $ LastRenderTime $ " DT: " $ DeltaTime $ " LTS: " $ Level.TimeSeconds $ " Diff: " $ (Level.TimeSeconds - LastRenderTime) );
	if( bServoEnabled && AnimationController != None && !bStasis && DrawType == DT_Mesh )
	{
		//DMTNS( "  calling ExternalTick -- bStasis: " $ bStasis );
		AnimationController.ExternalTick( DeltaTime );
	}

	if( Level.NetMode != NM_Standalone  && Level.NetMode != NM_Client && Controller != None )
	{
		//for dead pawns and clients, this is useless code

		//mjl-tbd: reloading
		CurrentStatus.Pitch = Controller.Rotation.Pitch;
		CurrentStatus.Yaw   = Controller.Rotation.Yaw;
		CurrentStatus.bFiring    = (Controller.bFire    != 0);
		CurrentStatus.bAltFiring = (Controller.bAltFire != 0);
	}
}

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

function bool GetInfiniteAmmo()
{
	return bInfiniteAmmo;
}

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

function bool GetReloadsEnabled()
{
	return bReloadsEnabled;
}

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

simulated function PressedFire()
{
	Weapon.Fire();
}

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

simulated function PressedAltFire()
{
	Weapon.AltFire();
}

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

simulated function bool PressingFire()
{
	if( Controller != None )
		return Controller.bFire != 0;
	else
		return CurrentStatus.bFiring;
}

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

simulated function bool PressingAltFire()
{
	if( Controller != None )
		return Controller.bAltFire != 0;
	else
		return CurrentStatus.bAltFiring;
}

//-----------------------------------------------------------------------------
// ERROR HANDLING
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Note: if current skin isn't the default one, won't override this with a 
// subsequent non-default skin.

function SpamTextures( Texture Tex )
{
	local int ii;

	if( Skins.Length == 0 )
		Skins.Length = 6; // should be close enough

	if( Tex == None )
	{
		// restore regular skins
		for( ii=0; ii<Skins.Length; ii++ )
			Skins[ii] = default.Skins[ii];
		Texture = default.Texture;
	}
	else if( Texture == default.Texture )
	{
		// set to given skin
		for( ii=0; ii<Skins.Length; ii++ )
			Skins[ii] = Tex;
		Texture = Tex;
	}
}

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

function MakeErrorObvious( EErrorType ErrorType )
{
	local Texture Tex;

	if( !bDisableErrorColors )
	{
		switch( ErrorType )
		{
		case ET_ExternalPath:
			Tex = TexExternalPathError;
			break;
		case ET_InternalPath:
			Tex = TexInternalPathError;
			break;
		case ET_MinZ:
			Tex = TexMinZError;
			break;
		case ET_Move:
			Tex = TexMoveError;
			break;
		case ET_ScriptLoad:
			Tex = TexScriptLoadError;
			break;
		case ET_ScriptRun:
			Tex = TexScriptRunError;
			break;
		default:
			Tex = TexOtherError;
			break;
		}
	
		SpamTextures( Tex );
	}
}

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

function FixSkins()
{
	SpamTextures( None );
}

//-----------------------------------------------------------------------------
// !!mdf-localize:

function ErrorGeneral( EErrorType ErrorType, coerce string Msg )
{
	if( !bDisableErrorMessages )
	{
		switch( ErrorType )
		{
		case ET_ExternalPath:
			Msg = "External AI Pathing Error: " $ Msg;
			break;
		case ET_InternalPath:
			Msg = "Internal AI Pathing Error: " $ Msg;
			break;
		case ET_MinZ:
			Msg = "AI MinZ Error: " $ Msg;
			break;
		case ET_Move:
			Msg = "AI Movement Error: " $ Msg;
			break;
		case ET_ScriptLoad:
			Msg = "Script Load Error: " $ Msg;
			break;
		case ET_ScriptRun:
			Msg = "Script Run Error: " $ Msg;
			break;
		default:
			Msg = "Other AI Error: " $ Msg;
			break;
		}
	
		// just spit to log (as a warning) and console for now
		//AddActor( Self, ColorRed() );
		DMTN( "(" $ Controller $ ") Warning: " $ Msg );
	}

	MakeErrorObvious( ErrorType );
}

//-----------------------------------------------------------------------------
// debug

//tbd #debugbegin
function DMAI ( coerce string Msg )	{ if( U2NPCController(Controller) != None ) U2NPCController(Controller).DMAI( Msg ); }
function DMAIA( coerce string Msg ) { if( U2NPCController(Controller) != None ) U2NPCController(Controller).DMAIA( Msg ); }
function DMAIE( coerce string Msg ) { if( U2NPCController(Controller) != None ) U2NPCController(Controller).DMAIE( Msg ); }
function DMAIL( coerce string Msg ) { if( U2NPCController(Controller) != None ) U2NPCController(Controller).DMAIL( Msg ); }
function DMAIM( coerce string Msg ) { if( U2NPCController(Controller) != None ) U2NPCController(Controller).DMAIM( Msg ); }
//tbd #debugend

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

simulated function SetPlayerModel( string S )
{
	Mesh = LegendMesh(DynamicLoadObject( S, class'Class' ));
}

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

simulated function string GetPlayerModel()
{ 
	return string(Mesh); 
}

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

function ParticleGenerator GetDamageEffect( float Damage, vector HitLocation ) // override to create more sophisticated hit effects
{
	return ParticleHitEffect;
}

//-----------------------------------------------------------------------------
// PowerSuit Accessors (!!SBB (mdf): potential performance issues -- these are 
// called a lot and go through the entire inventory each time -- might want to 
// store a reference to the powersuit).

simulated function float GetPowerSuit()
{
	local PowerSuit CurrentPS;

	CurrentPS = PowerSuit(class'UtilGame'.static.GetInventoryItem( Self, class'PowerSuit' ));

	if( CurrentPS != None )
		return CurrentPS.Power;
	else
		return -1.0;  // Happens if Pawn has no PowerSuit
}

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

simulated function float GetPowerSuitMax()
{
	local PowerSuit CurrentPS;

	CurrentPS = PowerSuit(class'UtilGame'.static.GetInventoryItem( Self, class'PowerSuit' ));

	if( CurrentPS != None )
		return CurrentPS.MaxPower;
	else
		return -1.0;  // shouldn't happen (mdf): why not -- what if NPC doesn't have a powersuit?
}

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

simulated function float GetPowerSuitPct()
{
	local float Power;
	local float MaxPower;

	MaxPower = GetPowerSuitMax();
	Power = GetPowerSuit();

	if ( Power >= 0 && MaxPower > 0 )
		return Power / MaxPower;
	else
		return -1.0;
}

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

simulated function int GetPowerSuitResurrections()
{
	local PowerSuitPhoenix CurrentPS;

	CurrentPS = PowerSuitPhoenix(class'UtilGame'.static.GetInventoryItem( Self, class'PowerSuitPhoenix' ));
	if( CurrentPS != None )
		return CurrentPS.GetNumResurrections();
	else
		return -1;
}

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

simulated function string GetPowerSuitResurrectionsString()
{
	local PowerSuitPhoenix CurrentPS;

	CurrentPS = PowerSuitPhoenix(class'UtilGame'.static.GetInventoryItem( Self, class'PowerSuitPhoenix' ));
	if( CurrentPS != None )
		return CurrentPS.GetResurrectionsString();
	else
		return "";
}

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

function bool PreventDeath( int Damage, Pawn Instigator, class<DamageType> DamageType, vector HitLocation )
{
	local PowerSuit CurrentPS;

	CurrentPS = PowerSuit(class'UtilGame'.static.GetInventoryItem( Self, class'PowerSuit' ));
	
	return ( CurrentPS != None && CurrentPS.PreventDeath( Damage, Instigator, DamageType, HitLocation ) );
}

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

simulated function float GetJumpPack()
{
	local U2JumpPack CurrentJP;

	CurrentJP = U2JumpPack(class'UtilGame'.static.GetInventoryItem( Self, class'U2JumpPack' ));

	if( CurrentJP != None )
		return CurrentJP.JumpEnergy;
	else
		return -1.0;  // shouldn't happen (mdf): why not -- what if NPC doesn't have a jumppack?
}

//-----------------------------------------------------------------------------
// NEW
//-----------------------------------------------------------------------------

// Generic sound notification passed in by Golem
simulated function NotifySound( string SoundTableSlot )
{
	local SoundSlotInterf.ESoundTableSlot SlotIndex;
	
	if( SoundTable.StringToSlot( SoundTableSlot, SlotIndex ) )
		SoundTable.PlaySlotSound( Self, SlotIndex );
	else
		Warn( "NotifySound unable to find sound table slot:" @ SoundTableSlot @ "for pawn:" @ Self @ "using voice package:" @ VoicePackage );
}

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

function PlayTakeHitSound( int Damage, class<DamageType> DamageType, int Mult )
{
	if( (IsRealPlayer() || Controller.AllowHitSounds()) && (Level.TimeSeconds - LastPainSound) > MinTimeBetweenHitSounds ) 
	{
		LastPainSound = Level.TimeSeconds;

		AssetsHelperClass.static.HandleTakeHitSound( Self, Damage, DamageType );
	}
}

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

function PlayMovementSound()
{
    if( !PhysicsVolume.bWaterVolume && (Physics == PHYS_Walking || Physics == PHYS_Ladder) )
    {
		if( IsProne() )
			AssetsHelperClass.static.HandleProneMovingOnTexture( Self );
		else if( !PhysicsVolume.bWaterVolume && (Physics == PHYS_Walking || Physics == PHYS_Ladder) )
			AssetsHelperClass.static.HandleMovingOnTexture( Self );
	}
}

//-----------------------------------------------------------------------------
// Can be used with some movement animations to tell us to turn a movement
// sound on/off.

function NotifySetMovementSound( bool bEnable )
{
	if( bEnable )
		AmbientSound = default.AmbientSound;
	else
		AmbientSound = None;
}

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

function NotifyFallingFar( bool bEnable )
{
	if( bEnable )
		AssetsHelperClass.static.HandleFallingSound( Self );
	else
		AssetsHelperClass.static.StopFallingSound( Self );
}

//-----------------------------------------------------------------------------
// Dialog
//-----------------------------------------------------------------------------

function string GetDescription()
{
	return Description;
}

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

event DialogBegin( Actor Other )
{
	if( Controller != None )
		Controller.DialogBegin( Other );
}

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

event DialogEnd()
{
	if( Controller != None )
		Controller.DialogEnd();
}

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

function DialogPause()
{
	if( Controller != None )
		Controller.DialogPause();
}

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

function DialogUnPause()
{
	if( Controller != None )
		Controller.DialogUnPause();
}

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

function DialogSetFocus( Actor FocusActor )
{
	if( Controller != None )
		Controller.DialogSetFocus( FocusActor );
}

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

function DialogSetEndingFocus( Actor FocusActor )
{
	if( Controller != None )
		Controller.DialogSetEndingFocus( FocusActor );
}

//-----------------------------------------------------------------------------
// Misc
//-----------------------------------------------------------------------------

simulated function PossessedBy( Controller C )
{
	super.PossessedBy( C );

	// we do this in here, instead of PostBeginPlay, because we need a Controller,
	//   so that it correctly replicates ClientWeaponSet to the client, and we see the weapon
	//   AssignDefaultInventory() is also called from AddDefaultInventory() for Bots and Players.
	if( !C.bIsPlayer && Level.Netmode != NM_Client )
	{
		AssignDefaultInventory();
	 	SetDefaultWeapon();
	 	
		class'U2GameInfo'.static.ScaleMovementSpeeds( Self );
	}

//	if( bFrozen )
//		C.SetFrozen( true );
}

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

function Died( Controller Killer, class<DamageType> DamageType, vector HitLocation, vector Momentum )
{
	local int ii;
	local class<Actor> TossedClass;
	local Actor TossedActor;
	local vector X,Y,Z;	

	// spawn tossed items
	for( ii=0; ii<MaxTossedItems; ii++ )
	{
		if( TossedItems[ ii ] != "" )
		{
			TossedClass = class<Actor>(DynamicLoadObject( TossedItems[ ii ], class'Class' ));

			if( TossedClass != None )			
			{
				GetAxes( Rotation, X, Y, Z );
				TossedActor = Spawn( TossedClass,,, Location + EyeHeight*vect(0,0,1) + 2.0*CollisionRadius*X, Rotation );

				if( TossedActor == None )
					DMN( "Warning (1): couldn't toss " $ TossedItems[ ii ] );

				/* !!mdf-tbd:
				Speed = VSize(Other.Velocity);
				if( Speed != 0 )
					TossedItem.Velocity = Normal(Other.Velocity/speed + 0.5 * VRand()) * (speed + 280);
				else 
					TossedItem.Velocity = vect(0,0,0);
				*/
			}
			else
			{
				DMN( "Warning (2): couldn't toss " $ TossedItems[ ii ] );
			}
		}
	}

	Super.Died( Killer, DamageType, HitLocation, Momentum );
}

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

function SetNumWalkingAnims()
{
	// set default.NumWalkingAnims -- some Pawns may have none
	NumWalkingAnims = 0;
	while( NumWalkingAnims < MaxWalkingAnims && WalkingAnims[ NumWalkingAnims ].WalkingAnimType != WAT_None )
		NumWalkingAnims++;
}

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

function SetupAnimationComponents()
{
	if( Health > 0 )
	{
		// animation controller
		if( AnimationControllerClass != None )
		{
			SetNumWalkingAnims();

			AnimationController = new(Self) AnimationControllerClass;
			if( AnimationController == None )
				assert( false );
			AnimationController.Initialize();
		}
	}
}

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

function SetupSoundComponents()
{
	if( Health > 0 )
	{
		if( VoicePackage == "" )
			VoicePackage = class'VoiceList'.static.GetVoicePackage( Self );
		if( SoundTable == None )
			SoundTable = class'SoundTable'.static.GetInstance( Self, VoicePackage );
		if( SoundSlotTimers == None )
			SoundSlotTimers = U2GameInfo(Level.Game).GetSoundSlotTimerList( SoundSlotTimerListTag );
		if( VoicePackage != "" && SoundTable == None )
			assert( false );
		
		// enable idle sound timer but only if NPC has idle sounds
		if( SoundTable != None && (SoundTable.GetNumSounds( RandomIdleSoundSlot ) > 0 || SoundTable.GetNumSounds( RandomAttackSoundSlot ) > 0) )
			U2NPCController(Controller).SetRandomSoundTimer();
	}
}

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

function SetupComponents()
{
	SetupAnimationComponents();
	SetupSoundComponents();
}

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

function MaybeScaleSettings();

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

function NotifyGoreDetailChanged( byte GameGoreDetailLevel )
{
	local byte SwapGoreLevel;
	local Mesh SwapGoreMesh;

	if( LowGoreMeshGoreLevel <= GameGoreDetailLevel &&
		(GoreLevel > GameGoreDetailLevel || LowGoreMeshGoreLevel > GoreLevel) )
	{
		if( DrawType == DT_Mesh && LowGoreMesh != None )
		{
			SwapGoreMesh = Mesh;
			Mesh = LowGoreMesh;
			LowGoreMesh = SwapGoreMesh;

			SwapGoreLevel = GoreLevel;
			GoreLevel = LowGoreMeshGoreLevel;
			LowGoreMeshGoreLevel = SwapGoreLevel;
		}
	}
}

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

simulated event PreBeginPlay()
{
	local Actor A;

	if( GoreLevel > GetGoreDetailLevel() )
		NotifyGoreDetailChanged( GetGoreDetailLevel() );

	Super.PreBeginPlay();
	if( bDeleteMe )			// for actors that were destroyed in Actor.PreBeginPlay
		return;

	// NPCs which default to PHYS_Swimming won't drown (can't use bCanSwim -- this
	// only means that PC/NPC can go into water). For NPCs which don't default to
	// PHYS_Swimming but shouldn't drown (diver, sprout) directly set their
	// UnderWaterTime to -1.0
	if( MovementPhysics == PHYS_Swimming )
		UnderWaterTime = -1.0;

	InitialHealth			= Health;
	InitialSightRadius		= SightRadius;
	InitialHearingThreshold	= HearingThreshold;
	InitialAlertness		= Alertness;

	// cache usable actors in level
	foreach DynamicActors( class'Actor', A )
	{
		if( A.IsA( 'DialogProxy' ) )
		{
			UsableActors[UsableActors.Length] = A;
		}
		else if( Trigger(A) != None  && Trigger(A).TriggerType == TT_Use )
		{
			UsableActors[UsableActors.Length] = A;
		}
	}
}

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

simulated event PostBeginPlay()
{
	local int i;

	if( Level.bStartup && Health <= 0 )
	{
		GotoState( DyingPlacedState );
	}
	else
	{
		Super.PostBeginPlay();

		SetupComponents();

		for (i=0; i<InitialAgentInputs.Length; i++)
			MeshAgentSetInputCurValue(InitialAgentInputs[i].InputName, InitialAgentInputs[i].InputValue);
	}
}

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

simulated event Destroyed()
{
	Level.AddMeshListEntry( Self );
	
	if( bRagdollDeath )
	{
		Level.Game.DecActiveRagDollDeaths();
		bRagdollDeath = false;
	}

	// make sure components cleaned up first
	if( AnimationController != None )
	{
		AnimationController.Cleanup();
		AnimationController.Delete();
		AnimationController=None;
	}

	if( UseManager != None )
	{	
		UseManager.Cleanup();
		UseManager = None;
	}

	Super.Destroyed();
}

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

simulated function SetHealth( float NewVal )
{
	InitialHealth = NewVal;
	Super.SetHealth( NewVal );
}

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

function RestoreSightRadius()
{
	SightRadius = InitialSightRadius;
}

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

function PreSetMovement()
{
	bCanJump = ( JumpZ > 0.0 );
}

//-----------------------------------------------------------------------------
// If the Pawn isn't falling (in which case we leave it falling), set its 
// physics to its MovementPhysics. If in a water volume use PHYS_Swimming if
// MovementPhyscss are PHYS_Walking.
//
// !!mdf-tbd: no -- if falling and in a water volume and bCanSwim, set physics
// to PHYS_Swimming and if fallling and bCanFly, set physics to PHYS_Flying?

function SetMovementPhysics( optional bool bInitializing )
{
	//DMTNS( "SetMovementPhysics (" $ bInitializing $ ")" );
	//DMTNS( "PhysicsVolume.bWaterVolume: " $ PhysicsVolume.bWaterVolume );
	//DMTNS( "Controller.PhysicsVolume.bWaterVolume: " $ Controller.PhysicsVolume.bWaterVolume );
	if( PhysicsVolume.bWaterVolume )
	{
		//DM( "water volume" );
		if( bCanSwim )
			SetPhysics( PHYS_Swimming );
		else if( MovementPhysics != PHYS_None )
			SetPhysics( PHYS_Falling ); // float?
	}
	else if( Physics == PHYS_Falling )
	{
		//DM( "falling" );
		if( bCanFly )
			SetPhysics( PHYS_Flying );
	}
	else
	{
		//DM( "not water volume and not falling" );
		
		if( bInitializing && MovementPhysics == PHYS_Walking )
			SetPhysics( PHYS_Falling );
		else
			SetPhysics( MovementPhysics ); 
	}
}

//-----------------------------------------------------------------------------
// Checks whether currently playing a special jump animation that shouldn't be
// interrupted, e.g. landing or taking hits.

function bool JumpInProgress()
{
	return( AnimationControllerClass != None && AnimationController.SpecialJumpAnim() );
}

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

function LandedOnTexture( float ImpactSpeed )
{
	AssetsHelperClass.static.HandleLandedOnTexture( Self, ImpactSpeed );
}

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

event LandedEx( CheckResult Hit )
{
	if( Mass > 2 )
		LandedOnTexture( Velocity.Z );

	if( bUpdateEyeHeight )
		SetEyeHeight( 0.7*default.BaseEyeHeight );
		
	Super.LandedEx( Hit );
}

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

event FellOutOfWorld()
{
	if( U2NPCController(Controller) != None )
		U2NPCController(Controller).FellOutOfWorld();
	else
		Super.FellOutOfWorld();
}

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

function DropEnergy()
{
	if( DroppedEnergy == None )
	{
		if( RemainingPowerSuitEnergy >= 0 )
		{
			// NOTE: even if the killed pawn's powersuit has 0 energy left, we 
			// want to leave something behind.
			DroppedEnergy = Spawn( class'DroppedEnergyPickup', , , Location );
			DroppedEnergy.Initialize( Self, RemainingPowerSuitEnergy );
			DroppedEnergy.SetBase( Self );
		}
	}
}

//-----------------------------------------------------------------------------
// Skin Stuff
//-----------------------------------------------------------------------------

//NEW MJL: see above comment at beginning of file
/*OLD
static function GetMultiSkin( Actor SkinActor, out string SkinName, out string FaceName )
{
	local string ShortSkinName, FullSkinName, ShortFaceName, FullFaceName;

	FullSkinName  = String(SkinActor.skins[default.FixedSkin]);
	ShortSkinName = SkinActor.GetItemName(FullSkinName);

	FullFaceName = String(SkinActor.skins[default.FaceSkin]);
	ShortFaceName = SkinActor.GetItemName(FullFaceName);

	SkinName = Left(FullSkinName, Len(FullSkinName) - Len(ShortSkinName)) $ Left(ShortSkinName, 4);
	FaceName = Left(FullFaceName, Len(FullFaceName) - Len(ShortFaceName)) $Mid(ShortFaceName, 5);
}

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

static function SetMultiSkin(Actor SkinActor, string SkinName, string FaceName, byte TeamNum)
{
	local string MeshName, FacePackage, SkinItem, FaceItem, SkinPackage;

//!!cdh -- overhaul: SkinName designates a specific Golem entity to use as the mesh/skin/etc. for this Actor

	MeshName = SkinActor.GetItemName(string(SkinActor.Mesh));

	SkinItem = SkinActor.GetItemName(SkinName);
	FaceItem = SkinActor.GetItemName(FaceName);
	FacePackage = Left(FaceName, Len(FaceName) - Len(FaceItem));
	SkinPackage = Left(SkinName, Len(SkinName) - Len(SkinItem));

	if(SkinPackage == "")
	{
		SkinPackage=default.DefaultPackage;
		SkinName=SkinPackage$SkinName;
	}
	if(FacePackage == "")
	{
		FacePackage=default.DefaultPackage;
		FaceName=FacePackage$FaceName;
	}

	// Set the talktexture
	if( Pawn(SkinActor) != None && (Pawn(SkinActor).Controller != None)
		&& (Pawn(SkinActor).PlayerReplicationInfo != None) )
	{
		if(FaceName != "")
			Pawn(SkinActor).PlayerReplicationInfo.TalkTexture = Texture(DynamicLoadObject(FacePackage$SkinItem$"5"$FaceItem, class'Texture'));
		else
			Pawn(SkinActor).PlayerReplicationInfo.TalkTexture = None;
	}
}
*/

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

function LaunchOffPawnDamage( Pawn Stompee )
{
	local int Damage;

	//!!mdf-tbd: abort damage if stomper doesn't weigh much more than stompee?
	// (although, ideally I'd prefer to stop some NPCs from stepping onto others at all -- see StepHeight)?
	//if( Mass <= 5 )
	//if( Mass - Stompee.Mass <= 5 ) // this means that same class NPCs won't ever damage each other via stomping
	//	return;

	Damage = 0.1 * (1-Velocity.Z/400) * Mass/Stompee.Mass;
	if( Damage <= 0.1*Stompee.Mass )
		return;

	//Damage = (1-Velocity.Z/400) * Mass/Stompee.Mass;
	//Damage = 0.1 * (1-Velocity.Z/400) * Mass/Stompee.Mass;
	/*
	DM( "LaunchOffPawnDamage - Damage: " $ Damage $ 
		" Velocity.Z: " $ Velocity.Z $ 
		" Mass: " $ Mass $ 
		" Stompee.Mass: " $ Stompee.Mass );
	*/
	
	//!!mdf-tbd: eliminated momentum xfer for getting stomped on -- IMO momentum xfer for this doesn't make sense
	Stompee.TakeDamage( Damage, Self, Location, vect(0,0,0), class'DamageTypeStomped' );
}

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

event BreathTimer()
{
	if( Level.NetMode == NM_Standalone )	//!!mwp change condition to a check for the power suit? (pending design)
	{
		// single-player pawns never drown
		return;
	}

	super.BreathTimer();
}

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

function TakeDrowningDamage()	
{	
	if( !InGodMode() )
	{
		//DMTN( "TakeDrowningDamage: " $ DrowningDamageAmount );
		TakeDamage( DrowningDamageAmount, None, Location + CollisionHeight * vect(0,0,0.5)+ 0.7 * CollisionRadius * vector(Controller.Rotation), vect(0,0,0), class'DamageTypeDrowned' ); 
	}
}

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

static function bool IsPanicDamageType( class<DamageType> DamageType )
{
	return( ClassIsChildOf( DamageType, class'DamageTypeThermal' ) ||
			ClassIsChildOf( DamageType, class'DamageTypeLeechGun' ) ||
			ClassIsChildOf( DamageType, class'DamageTypeBiologicalGas' ) );
}

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

function eventTakeDamage( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	local vector HitDir;

	//PWC7/10/2002 Removed any damage filtering from Pawn and put it into powersuit and U2GameInfo so that filtering for pawn and armor are completely separate
	// Account for pawns catching on fire!!
	if( ClassIsChildOf( DamageType, class'DamageTypeThermal' ) && (DamageType != class'DamageTypeThermalFlaming') )
	{	
		DoDamageEffect (Damage, DamageType, FlameEffect, ParticleRadiator'onfire_fx.ParticleRadiator0');
		//PWC 8/13/2002 Put in a helper to cause continuous damage when on fire
		if (!FDamager || FDamager.bDeleteme)
			FDamager = spawn (class'FlameDamager');
		FDamager.BeginDamaging(Self, Damage, Instigator, HitLocation, Momentum, class'DamageTypeThermalFlaming', FlameEffect.TimerDuration + FlameEffect.RampDownTime);
	}
			
	else if( ClassIsChildOf( DamageType, class'DamageTypeEMP' ) )
	{
		DoDamageEffect (Damage, DamageType, EMPEffect, ParticleRadiator'EMP_Hit_FX.ParticleRadiator0', 3);
	}

	else if( ClassIsChildOf( DamageType, class'DamageTypeBiologicalGas' ) )
	{
		DoDamageEffect (Damage, DamageType, ToxicEffect, ParticleRadiator'Toxic_Hit_FX.ParticleRadiator0');
	}
	// put NPCs into panic state for some damage types
	if( !IsPlayer() && bCanPanic &&	IsPanicDamageType( DamageType ) && U2NPCController(Controller).CanPanic( Instigator, HitLocation, Damage, DamageType, Momentum ) )
	{
		StopPanicTime = Level.TimeSeconds + MinPanicTime;
		PanicDamageType = DamageType;
		PanicDamageInstigator = Instigator;
		Controller.HandlePanic();
	} 
	
	// !!mdf-tbd: have DamageFilter handle effect to indicate damage filtered?
	// pass it along
	Super.TakeDamage( Damage, Instigator, HitLocation, Momentum, DamageType );

	if( Damage > 0 && Level.NetMode != NM_DedicatedServer )
	{
		// Engine DamageTypes: Crushed, Gibbed, Suicided, Fell do not implement effects
		if( class<DamageTypeImpl>(DamageType) != None )
			class<DamageTypeImpl>(DamageType).static.HandleDamageEffect( Self, Damage, HitLocation );

		if( IsRealPlayer() )
		{
			class'UIConsole'.static.SendEvent("HealthFlash");

			// Calculate hit angle.
			if(Momentum?)	HitDir = normal(-Momentum);
			else			HitDir = normal(HitLocation - Location);
			if(!HitDir)		HitDir = VRand();
			HitDir = HitDir << Rotation;	// transform to playerspace.
			DamageIndicatorAngle = atan2( HitDir.y, HitDir.x );
			DamageIndicatorAngle *= 180.0 / PI;
			DamageIndicatorAngle -= 90.0;
			class'UIConsole'.static.SendEvent("PainFlash");
		}
	}
	
	if( Health <= 0 )
	{
		// mdf-tbd: was originally in PlayDeathHit
		if( PhysicsVolume.bDestructive )
			PhysicsVolume.PlayExitSplash( Self );
	}
}

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

function float GetDamageIndicatorAngleA(){ return DamageIndicatorAngle + 21.9; }
function float GetDamageIndicatorAngleB(){ return DamageIndicatorAngle - 21.9; }

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

function TakeDamageHandlePhysics( Pawn InstigatedBy, out vector Momentum )
{
	if( !IsFrozen() )
		Super.TakeDamageHandlePhysics( InstigatedBy, Momentum );
}

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

function TakeDamage( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	//DMTNS( "U2Pawn.TakeDamage - Damage:" $ Damage $ " DamageType: " $ DamageType);
	// level transition hack
	if( Controller != None && Controller.IsInState( U2PlayerController.LevelTransitionState ) )
		return;
		
	if( IsRealPlayer() )
	{
		//DMTNS( "Calling eventTakeDamage for (real) player" );

		// pass it along
		eventTakeDamage( Damage, Instigator, HitLocation, Momentum, DamageType );
	}
	else if( Controller != None )
	{
		//DMTNS( "Calling eventTakeDamage for non-player" );

		// NPCs under script control might filter out damage (!!mdf-tbd). If this is 
		// the case, the Controller will eat the call to TakeDamage, otherwise the
		// script controller will bounce the damage back to this class' eventTakeDamage
		// which can call the Super.
		//DMTNS( "Calling Controller.TakeDamage: " $ Damage );
		Controller.TakeDamage( Damage, Instigator, HitLocation, Momentum, DamageType );
	}
}

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

function JumpOutOfWater(vector jumpDir)
{
	BeginFalling();
	Velocity = jumpDir * WaterSpeed;
	Acceleration = jumpDir * AccelRate;
	Velocity.Z = 380; //set here so physics uses this for remainder of tick
	bUpAndOut = true;
}

//-----------------------------------------------------------------------------
// ANIMATIONS
//-----------------------------------------------------------------------------

function DoDamageEffect(int Damage, class<DamageType> DamageType, out ParticleRadiator DamageEffect, ParticleRadiator EffectType, optional float MaxScale)
{
	local float DamagePct;
	local float DamageFloat;
	local vector Momentum;
	local int DamageTemp;
	local PowerSuit CurrentPS;

	if (!MaxScale) MaxScale=10;
	if( DamageEffect!=None && DamageEffect.bDeleteMe )
		DamageEffect=None;

	if( DamageEffect==None )
	{
		DamageEffect = ParticleRadiator(class'ParticleGenerator'.static.CreateNew( Self, EffectType, Location ));
		DamageEffect.Volume *= FClamp( CollisionHeight * CollisionRadius * CollisionRadius / /*54x28x28*/42336.0, 0.0, MaxScale );	// scale to CC size based on normal pawn dimensions.
		DamageEffect.TimerDuration=0;
	}
	DamageFloat=Damage;
	//if powersuit active use the powersuit damagefilter
	CurrentPS = PowerSuit(class'UtilGame'.static.GetInventoryItem( Self, class'PowerSuit' ));
	if( CurrentPS == None ) 
	{
		DamageFilterClass.static.ApplyFilter( DamageTemp, Momentum, DamageType, DamageFloat );
	}
	else 
	{
		CurrentPS.DamageFilterClass.static.ApplyFilter( DamageTemp, Momentum, DamageType, DamageFloat );
	}

		if (Damage!=0)
		{
			DamagePct=(DamageFloat)/Damage;
		} else DamagePct=0;
		if (DamagePct==0) DamagePct=0.1;
		DamageEffect.SetBase( Self );
		DamageEffect.MeshOwner = Self;
		if (DamageType.default.EffectDurationCumulative == true) 
		{
			if (DamageEffect.bOn==False) DamageEffect.TimerDuration=0;
			DamageEffect.TimerDuration += (DamageType.default.EffectDuration * DamagePct); 
			if ( ClassIsChildOf( DamageType, class'DamageTypeThermal' ) ) { if ( DamageEffect.TimerDuration > 4 ) DamageEffect.TimerDuration=4; }
			DamageEffect.ParticleLifeSpan= (DamageEffect.TimerDuration + DamageEffect.RampUpTime + DamageEffect.RampDownTime + DamageEffect.GetMaxLifeSpan()); //NEW
		}
		else 
		{
			if (DamageEffect.TimerDuration < (DamageType.default.EffectDuration * DamagePct))
			{
				DamageEffect.TimerDuration = DamageType.default.EffectDuration * DamagePct;
			} 
			DamageEffect.ParticleLifeSpan = DamageEffect.RampUpTime + DamageEffect.TimerDuration + DamageEffect.RampDownTime + DamageEffect.GetMaxLifeSpan();
		}
		DamageEffect.Trigger( Self, Self );//NEW
}

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

function float PlayDodge( eDoubleClickDir DoubleClickMove )
{
	return AnimationController.SpecialAnimationDodge( DoubleClickMove );
}

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

function PlayDying( class<DamageType> DamageType, vector HitLocation, Pawn InstigatedBy, vector Momentum )
{
	if( AnimationController != None )
		AnimationController.SpecialAnimationDeath( DamageType, HitLocation, InstigatedBy, Momentum );
	AssetsHelperClass.static.HandleDyingSound( Self );
}

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

function AddVelocity( vector NewVelocity )
{
	local float VelocitySize;
	
	if ( bIgnoreImpactForces )
		return;
		
	if( NewVelocity == vect(0,0,0) )
		return;
		
	Super.AddVelocity( NewVelocity );
	
	VelocitySize = VSize( Velocity );
	if( Health > 0 && VelocitySize > MaxAliveAddedVelocity )
		Velocity = MaxAliveAddedVelocity * Normal( Velocity );
	else if( Health < 0 && VelocitySize > MaxDeadAddedVelocity )
		Velocity = MaxDeadAddedVelocity * Normal( Velocity );
}

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

function bool HandleKnockdown( Pawn Instigator, vector HitLocation, float Damage, class<DamageType> DamageType, vector Momentum )
{
	local int i;
	local float MomentumTransferThisCall;
#debugbegin
	local int ActiveEntries;
#debugend

	if( !bCanKnockDown )
		return false;

	if( !U2NPCController(Controller).CanKnockdown( Instigator, HitLocation, Damage, DamageType, Momentum ) )
		return false;
		
	MomentumTransferThisCall = VSize( Momentum );
	
	if( !bIgnoreImpactForces && Health > 0 && MomentumTransferThisCall > 0.0 )
	{
		// Mainly because of the way the shotgun works, momentum is tracked over X
		// secs -- if the total momentum transfer across any X-second period ever 
		// exceeds the threshold, the NPC will be knocked down. As the collected MT 
		// becomes "older" than X secs, that MT is removed from the collection.
		// The CollectedMomentumTransfer array should never grow that large afaik
		// so I'm not bothering to try to keep it sorted for fast removals.
		
		if( Level.TimeSeconds > LastMomentumTransferTime )
		{
			// new tick -- remove any entries which are older than MaxCollectMomentumTime
			for( i=0; i<CollectedMomentumTransfer.Length; i++ )
			{
				if( CollectedMomentumTransfer[ i ].MomentumTransfer > 0.0 && (Level.TimeSeconds - CollectedMomentumTransfer[ i ].Time) > MaxCollectMomentumTime )
				{
					TotalRecentMomentumTransfer -= CollectedMomentumTransfer[ i ].MomentumTransfer;
					CollectedMomentumTransfer[ i ].MomentumTransfer = 0.0;
					
					#debugbegin
					TotalRecentHits -= CollectedMomentumTransfer[ i ].NumHits;
					CollectedMomentumTransfer[ i ].NumHits = 0;
					#debugend					
				}
			}
			
			// find a free slot for this tick
			CurrentMomentumTransferSlot = -1;
			for( i=0; i<CollectedMomentumTransfer.Length; i++ )
			{
				if( CollectedMomentumTransfer[ i ].MomentumTransfer == 0.0 )
				{
					CurrentMomentumTransferSlot = i;
					break;
				}
			}
			
			if(	CurrentMomentumTransferSlot == -1 )
			{
				CollectedMomentumTransfer.Length = CollectedMomentumTransfer.Length + 1;
				CurrentMomentumTransferSlot = CollectedMomentumTransfer.Length - 1;
			}
			
			LastMomentumTransferTime = Level.TimeSeconds;
			CollectedMomentumTransfer[ CurrentMomentumTransferSlot ].Time = LastMomentumTransferTime;
		}
		
		CollectedMomentumTransfer[ CurrentMomentumTransferSlot ].MomentumTransfer += MomentumTransferThisCall;
		TotalRecentMomentumTransfer += MomentumTransferThisCall;
		
		//DMTNS( "U2Pawn.HandleTakeHit  Damage: " $ Damage $ " Momentum: " $ VSize(Momentum) $ " MT this tick: " $ MomentumTransferThisCall $ " MT threshold: " $ MinKnockDownMomentumThreshold );
		//DMTNS( "" );
		
#debugbegin
		CollectedMomentumTransfer[ i ].NumHits++;
		TotalRecentHits++;
		
		ActiveEntries = 0;
		for( i=0; i<CollectedMomentumTransfer.Length; i++ )
		{
			if( CollectedMomentumTransfer[ i ].MomentumTransfer > 0.0 )
				ActiveEntries++;
		}
		
		//DMTNS( TotalRecentHits $ ": MomentumTransferThisCall: " $ MomentumTransferThisCall $ " TotalRecentMomentumTransfer: " $ TotalRecentMomentumTransfer $ " (" $ ActiveEntries $ ")" );
#debugend

		if( TotalRecentMomentumTransfer >= MinKnockDownMomentumThreshold )
		{
			if( (Level.TimeSeconds - LastKnockDownTime) > MinTimeBetweenKnockDowns )
			{
				// CDH TEMP... short-term hack for knockdown direction, shouldn't be necessary if/when ragdoll gets used
				if ((vector(Rotation) dot Normal(Momentum)) > 0.0)
					MeshAgentSetInputCurValue('KnockdownDir', 'Forward');
				else
					MeshAgentSetInputCurValue('KnockdownDir', 'Backward');
				// ...CDH

				//DMTNS( "    =====> KnockDown!" );
				Controller.HandleKnockDown();
				LastKnockDownTime = Level.TimeSeconds;
			}	
			else
			{
				//DMTNS( "    already handling previous knockdown" );
			}
			
			return true; // started or already handling a knockdown
		}
	}
	
	return false; // no knockdown
}

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

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

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

function HandleTakeHit( Pawn Instigator, vector HitLocation, float Damage, class<DamageType> DamageType, vector Momentum )
{
	Super.HandleTakeHit( Instigator, HitLocation, Damage, DamageType, Momentum );
	
	if( AnimationController != None )
	{
		AnimationController.SpecialAnimationTakeHit( HitLocation, Damage, DamageType, Instigator, Momentum );
	}
			
	if( Instigator != Self && 
		SameTeam( Instigator ) &&
		!IsPanicDamageType( DamageType ) && // let panic state manage friendly fire (and panic) sounds
		U2NPCController(Controller) != None &&
		U2NPCController(Controller).CanPanic( Instigator, HitLocation, Damage, DamageType, Momentum ) )
	{
		AssetsHelperClass.static.HandleFriendlyFire( U2Pawn(Instigator), Self );
	}
}	

//-----------------------------------------------------------------------------
// Karma impact callback

event KImpact(actor other, vector pos, vector impactVel, vector impactNorm)
{
	local ParticleGenerator EffectClass;
	local ParticleSalamander Particles;
	local vector SpawnLocation;
	local vector EffectVector;
	local rotator EffectRotation;
	local vector DirectionVector;
	
	//DMTNS("IMPACT "$VSize(impactVel));

	/*
		High-impact blood splatter
	*/
	if ((GetGoreDetailLevel() >= 1) && (VSize(impactVel) > 1000.0))
	{
		if (bOverridesDamageEffect)
			EffectClass = ParticleHitEffect;//GetDamageEffect( Damage, HitLocation );
		else
			EffectClass = class'DamageTypePhysical'.default.ParticleEffect;

		if (EffectClass?)
		{
			EffectVector = -impactNorm;//impactVel;
			DirectionVector = Normal(EffectVector);
			EffectRotation = rotator(DirectionVector);
			SpawnLocation = pos + impactNorm*8.0;
			
			Particles = ParticleSalamander(class'ParticleGenerator'.static.CreateNew( self, EffectClass, SpawnLocation ));
			Particles.SetRotation( EffectRotation );
			Particles.Trigger( self, Instigator );
			Particles.ParticleLifeSpan = Particles.GetMaxLifeSpan() + Particles.TimerDuration;
		}
	}
}

//-----------------------------------------------------------------------------
//SERVOTBD: how to handle the rest of these with servo approach?

//-----------------------------------------------------------------------------
// Play specified animation with specified rate (optional).

exec function Gesture( name Sequence, optional float Rate )
{
	if( Rate ~= 0.0 )
		Rate = 1.0;

	// CDH FIXME - Use taunts for now (tbd - Add another agent action for this?)
	AnimationController.SpecialAnimationVictoryDance();
}

//-----------------------------------------------------------------------------
// Play some random taunt animation.

exec function PlayTaunt()
{
	AnimationController.SpecialAnimationTaunt();
}

//-----------------------------------------------------------------------------
// backwards compatibility

function ServerTaunt( name Sequence )
{
	Gesture( Sequence, 1.0 );
}

//-----------------------------------------------------------------------------
// backwards compatibility

exec function Taunt( name Sequence )
{
	Gesture( Sequence, 1.0 );
}

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

function PlayVictoryDance()
{
	PlayTaunt();
}

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

function PlayWaving()
{
	AnimationController.SpecialAnimationWave();
}

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

function HandleRandomAttackSound()
{
	AssetsHelperClass.static.HandleRandomAttackSound( Self, RandomAttackSoundSlot );
}

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

function HandleRandomIdleSound()
{
	AssetsHelperClass.static.HandleRandomIdleSound( Self, RandomIdleSoundSlot );
}

//-----------------------------------------------------------------------------
// !!mdf-tbd: hooking into a servo approach to know when to play jump sound
// would clean code up substantially (would only need to worry about calling 
// this in a single place).

function HandleJumpSound()
{
	if( !bMantling ) // don't spam mantle sound
		AssetsHelperClass.static.HandleJumpSound( Self );
}

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

function Dodge( eDoubleClickDir DoubleClickMove, bool bJumpDodge )
{
	local vector X,Y,Z;

	//!!mdf-tbd:
	StopMovement( true, false );

	PlayDodge( DoubleClickMove );

	if( bJumpDodge )
	{
		GetAxes( Rotation,X,Y,Z );
		if( DoubleClickMove == DCLICK_Forward )
			Velocity = DodgeXYVelocityScale*default.GroundSpeed*X + (Velocity dot Y)*Y;
		else if( DoubleClickMove == DCLICK_Back )
			Velocity = -DodgeXYVelocityScale*default.GroundSpeed*X + (Velocity dot Y)*Y; 
		else if( DoubleClickMove == DCLICK_Left )
			Velocity = DodgeXYVelocityScale*default.GroundSpeed*Y + (Velocity dot X)*X; 
		else if( DoubleClickMove == DCLICK_Right )
			Velocity = -DodgeXYVelocityScale*default.GroundSpeed*Y + (Velocity dot X)*X; 

		Velocity.Z = default.JumpZ * DodgeJumpZScale;
	
		Controller.StartFalling(); //!!mdf-tbd: tell controller we started falling
		SetPhysics( PHYS_Falling );
	}

	HandleJumpSound();
}

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

function MantlingBegin()
{
	//disable for now -- animation is wrong, lasts too long, and isn't really needed?
	//AnimationController.SpecialAnimationMantle();
}

//-----------------------------------------------------------------------------
// Functions for controlling animations for scripting / testing:
//-----------------------------------------------------------------------------

function bool LookupLoopAnim( name LookupName, optional float Rate, optional float TweenTime, optional int LockVal )
{
	return AnimationController.SpecialAnimationLoop( LookupName, Rate, TweenTime, LockVal );
}

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

function bool LookupPlayAnim( name LookupName, optional float Rate, optional float TweenTime, optional int LockVal )
{
	return AnimationController.SpecialAnimationPlay( LookupName, Rate, TweenTime, LockVal );
}

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

function bool LookupTweenAnim( name LookupName, optional float TweenTime, optional int LockVal )
{
	return AnimationController.SpecialAnimationTween( LookupName, TweenTime, LockVal );
}

//-----------------------------------------------------------------------------
// AI stuff -- this is a bit of a mess currently -- I still haven't figured out
// the best way to organize things...
//-----------------------------------------------------------------------------

function AssignDefaultInventory()
{
	local int i;

	for( i = 0; i < DefaultInventory.Length; i++ )
	{
		if( DefaultInventory[i] != "" )
		{
			if( class'UtilGame'.static.GiveInventoryString( Self, DefaultInventory[i] ) == None )
			{
				ErrorGeneral( ET_Other, "Couldn't give inventory: " $ DefaultInventory[i] );
			}
		}
	}
}

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

function SetDefaultWeapon()
{
	if( (DefaultWeapon != "") && (class'UtilGame'.static.SetCurrentWeaponString( Self, DefaultWeapon ) == None) )
	{
		ErrorGeneral( ET_Other, "Couldn't assign default weapon: " $ DefaultWeapon );

		if( Weapon != None )
			Weapon.BringUp();
	}
}

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

function bool GiveTossedItem( string ItemStr )
{
	local int ii;

	// shove into next free slot
	ii=0;
	while( TossedItems[ii] == "" && ii < MaxTossedItems )
		ii++;

	if( ii < MaxTossedItems )
		TossedItems[ ii ] = ItemStr;

	return ( ii < MaxTossedItems );
}

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

function bool RemoveTossedItem( string ItemStr )
{
	local int ii;

	// find specified item
	ii=0;
	while( !(TossedItems[ii] ~= ItemStr) && ii < MaxTossedItems )
		ii++;

	if( ii < MaxTossedItems )
		TossedItems[ ii ] = "";

	return ( ii < MaxTossedItems );
}

//-----------------------------------------------------------------------------
// Interfaces for artifact modification of incoming/outgoing damage
//-----------------------------------------------------------------------------

function AddWeaponDamageItem( U2Inventory Inv )
{
	WeaponDamageItems[WeaponDamageItems.Length] = Inv;
}

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

function RemoveWeaponDamageItem( U2Inventory Inv )
{
	local int i;

	for( i = 0; i < WeaponDamageItems.Length; i++ )
    {
		if( WeaponDamageItems[i] == Inv )
			WeaponDamageItems.Remove(i,1);
	}
}

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

function AddAdditionalDamageFilter( U2Inventory Inv )
{
	AdditionalDamageFilters[ AdditionalDamageFilters.Length ] = Inv;
}

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

function RemoveAdditionalDamageFilter( U2Inventory Inv )
{
	local int i;

	for( i = 0; i < AdditionalDamageFilters.Length; i++ )
    {
		if( AdditionalDamageFilters[ i ] == Inv )
			AdditionalDamageFilters.Remove(i,1);
	}
}

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

function float AdjustWeaponDamage( float Damage )
{
	local int i;

	//DMTNS( "*** AdjustWeaponDamage IN: " $ Damage );
    // traverse Instigator.WeaponDamageItems and call AdjustDamage()
    for( i = 0; i < WeaponDamageItems.Length; i++ )
    {
		WeaponDamageItems[i].AdjustDamage( Damage );
		//DMTNS( "*** after " $ WeaponDamageItems[i] $ ".AdjustDamage: " $ Damage );
    }
	//DMTNS( "*** AdjustWeaponDamage OUT: " $ Damage );
	return Damage;
}

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

function float ApplyAdditionalDamageFilters( float Damage )
{
	local int i;

	for( i = 0; i < AdditionalDamageFilters.Length; i++ )
		AdditionalDamageFilters[i].AdjustDamage( Damage );
//DM( "*** ApplyAdditionalDamageFilters returning " $ Damage );
	return Damage;
}

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

function int AdjustFinalDamage( int Damage )
{
	return Damage;
}

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

function bool IsSentient()
{
	return Controller != None && bSentient;
}

/*-----------------------------------------------------------------------------
Contains static functions for code that would otherwise be duplicated in U2 PC
and NPC classes.
-----------------------------------------------------------------------------*/

function LicenseePawn.EWeaponAnimationType GetWeaponAnimationTypeW( Weapon Weap )
{
	local LicenseePawn.EWeaponAnimationType ReturnedWAT;

	ReturnedWAT = AT_NoWeapon;
	if( U2Weapon(Weap) != None )
	{
		ReturnedWAT = U2Weapon(Weap).GetWeaponAnimationType();
	}
	else if( Weap != None )
	{
		// support for non-U2 weapons
		if( Weap.Mass > 20 )
			ReturnedWAT = AT_Large;
		else
			ReturnedWAT = AT_Small;
	}

	if( bLargeAnims )
	{
		// remap weapon type for big NPCs (these don't have animations for all weapon types)
		if( Health > 0 )
		{
			//2002.12.08 (mdf) heavies should use AT_Shoulder for RL so they don't use repeat fire?
			//if( ReturnedWAT != AT_Flamethrower )
			if( ReturnedWAT != AT_Shoulder && ReturnedWAT != AT_Flamethrower )
				ReturnedWAT = AT_Large;
		}
		else
		{
			ReturnedWAT = DeathWAT;
		}
	}

	return ReturnedWAT;
}

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

function StopDamageEffects()
{
	if( FlameEffect != None && !FlameEffect.bDeleteMe && FlameEffect.bOn ) { FlameEffect.ParticleDestroy(); FlameEffect = None; }
	if( EMPEffect   != None && !EMPEffect.bDeleteMe   && EMPEffect.bOn   ) { EMPEffect.ParticleDestroy();   EMPEffect   = None; }
	if( ToxicEffect != None && !ToxicEffect.bDeleteMe && ToxicEffect.bOn ) { ToxicEffect.ParticleDestroy(); ToxicEffect = None; }
}

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

function bool HasGibs() { return (GibSetClass!=None); }

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

function bool ShouldGib( class<DamageType> DamageType, optional float Damage )
{
	if( GibSetClass.default.GoreLevel > GetGoreDetailLevel() )
	{
		//DMTNS("ShouldGib -- Gore setting too low");
		return false; // gore setting not appropriate
	}

	return Super.ShouldGib( DamageType, Damage );
}

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

function DoGibs()
{
	if( GibSetClass != None )
		GibSetClass.static.CreateChunks(Self);
}

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

function DoGibbedEffect()
{
	if( GibSetClass == None || GibSetClass.default.GibbedEffectType == None )
		return;

	if( GibbedEffect!=None && GibbedEffect.bDeleteMe )
		GibbedEffect=None;

	if( GibbedEffect==None )
	{
		GibbedEffect = ParticleRadiator(class'ParticleGenerator'.static.CreateNew( Self, GibSetClass.default.GibbedEffectType ));
		GibbedEffect.Volume *= FClamp( CollisionHeight * CollisionRadius * CollisionRadius / /*54x28x28*/42336.0, 0.0, 10.0 );	// scale to CC size based on normal pawn dimensions.
		GibbedEffect.Volume *= GibSetClass.default.GibbedEffectVolumeMultiplier;
	}

	GibbedEffect.MeshOwner = GibbedEffect;
	GibbedEffect.Mesh = Mesh;
	GibbedEffect.Trigger( Self, Self );
	GibbedEffect.ParticleDestroy();
}

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

function ChunkUp()
{
	DoGibbedEffect();			// blood radiator effect
	DoGibs();					// chunks and sound

	// are any of these no longer needed since the pawn will be destroyed in the super?	
	StopSoundSlot( SLOT_Talk );
	if( FDamager != None )
		FDamager.StopDamaging();
	StopDamageEffects();
	
	Super.ChunkUp();
}

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

function DumpAgentAnimInfo()
{
	local int ii;
	local array<string> AgentInfoStrings;
	
	DMTNS( "DumpAgentAnimInfo:" );
	GetAgentAnimInfo( AgentInfoStrings );
	for( ii=0; ii<AgentInfoStrings.Length; ii++ )
		DMTNS( "  " $ AgentInfoStrings[ ii ] );
}

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

function DumpAgentInputInfo()
{
	local int ii;
	local array<string> AgentInfoStrings;
	
	DMTNS( "DumpAgentInputInfo:" );
	GetAgentInputInfo( AgentInfoStrings );
	for( ii=0; ii<AgentInfoStrings.Length; ii++ )
		DMTNS( "  " $ AgentInfoStrings[ ii ] );
}

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

function DumpAgentInfo()
{
	DumpAgentAnimInfo();
	DumpAgentInputInfo();
}

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

function NotifyRagdollCollisionChange();
function NotifyRagdollDeathEnded();

//-----------------------------------------------------------------------------
// STATE CODE
//-----------------------------------------------------------------------------

exec function TestMissionFailed( name ViewTargetTag )
{
	local U2PlayerController PC;
	local Pawn P, ViewTarget;

	PC = U2PlayerController(Level.PlayerControllerList);
	assert( PC != None ); // must be able to find the player

	ViewTarget = self;
	if( ViewTargetTag != '' )
	{
		foreach AllActors( class'Pawn', P, ViewTargetTag )
		{
			ViewTarget = P;
		}
	}
	
	DM( "Look at " $ ViewTarget );
	PC.HandleMissionFailed( ViewTarget );
}

function HandleMissionFailed()
{
	GotoState( MissionFailedState );
}

state @ MissionFailedState 
{
	ignores Bump, HitWall, HeadVolumeChange, PhysicsVolumeChange, BeginFalling, BreathTimer;

	function PlayWeaponSwitch(Weapon NewWeapon) {}
	function PlayTakeHit(vector HitLoc, int Damage, class<DamageType> damageType) {}

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

	event LandedEx( CheckResult Hit )
	{
		local rotator finalRot;

		finalRot = Rotation;
		finalRot.Roll = 0;
		finalRot.Pitch = 0;
		setRotation(finalRot);
		SetPhysics(PHYS_None);
		SetCollision(true, false, false);
		if ( !IsAnimating(0) )
			LieStill();
	}

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

	singular event BaseChange()
	{
		// do nothing
	}

	function TakeDamage( int Damage, Pawn instigatedBy, vector hitlocation, vector momentum, class<DamageType> damageType)
	{
		// do nothing
	}

	event BeginState()
	{
		SetPhysics( PHYS_Falling );

		// stop run/turn animations -- return to neutral stance
		MeshAgentSetInputCurValue('Direction', 'None');
		MeshAgentSetInputCurValue('Turning', 'None');
		MeshAgentSetInputLock('Direction', true);
		MeshAgentSetInputLock('Turning', true);

		//!!MWP (mdf) can't this happen if player died / gibbed sometime before mission failed?
 		//assert( U2PlayerController(Controller) != None );
	}
}

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

state @ DyingState
{
	ignores Bump, HitWall, HeadVolumeChange, PhysicsVolumeChange, BeginFalling, BreathTimer;

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

	event LandedEx( CheckResult Hit )
	{
		Super.LandedEx( Hit );
		CleanupShadows();
	}

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

	function CleanupShadows()
	{
		if( Level.NetMode != NM_DedicatedServer )
		{
			if( ShadowA != None )
			{
				ShadowA.Destroy();
				ShadowA = None;
			}
			if( ShadowB != None )
			{
				ShadowB.Destroy();
				ShadowB = None;
			}

			//CDH-uw: if ( UTBloodPool2(Shadow) == None )
			//CDH-uw:	Shadow = Spawn(class'UTBloodPool2',,,Location, rotator(HitNormal));
		}
	}

	//-------------------------------------------------------------------------
	// U2 version
	
	function ReduceCylinder()
	{
		local float OldHeight, OldRadius;
		local vector OldLocation;
		local float HeightChange;
		local bool bResult;

		SetCollision( true, false, false );
		
		// in case size wasn't at default upon death:
		class'Util'.static.AdjustCollisionSize( Self, default.CollisionRadius, default.CollisionHeight );

		OldHeight = CollisionHeight;
		OldRadius = CollisionRadius;
		OldLocation = Location;

		//AddActor( Self );
		//DMTNS( "ReduceCylinder BEGIN  CollisionRadius: " $ CollisionRadius $ " CollisionHeight: " $ CollisionHeight $ " PrePivot.Z: " $ PrePivot.Z );
		//DMTNS( "  Physics: " $ EnumStr( enum'EPhysics', Physics ) );
		//DMTNS( "  Velocity: " $ Velocity );
		
		SetCollisionSize( CarcassCollisionRadius, CarcassCollisionHeight );
		//DMTNS( "  Trying CollisionRadius: " $ CollisionRadius $ " CollisionHeight: " $ CollisionHeight );
		//AddCylinder( OldLocation - vect(0,0,1)*HeightChange, CollisionRadius, CollisionHeight, ColorGreen() );
		
		HeightChange = OldHeight - CarcassCollisionHeight;
		
		//!!mdf-tbd: crouching NPCs still pop up by 4 units compared to standing ones
		//DMTNS( "  New CollisionRadius: " $ CollisionRadius $ " CollisionHeight: " $ CollisionHeight );
		PrePivot.Z = default.PrePivot.Z + HeightChange;
		//DMTNS( "  New PrePivot.Z: " $ PrePivot.Z );

		bResult = SetLocation( OldLocation - vect(0,0,1)*HeightChange );
		if( !bResult )
		{
			SetCollisionSize( CarcassCollisionRadius*0.75, CarcassCollisionHeight );
			//DMTNS( GetContext(0) $ "  Trying CollisionRadius: " $ CollisionRadius $ " CollisionHeight: " $ CollisionHeight );
			//AddCylinder( OldLocation - vect(0,0,1)*HeightChange, CollisionRadius, CollisionHeight, ColorYellow() );
			bResult = SetLocation( OldLocation - vect(0,0,1)*HeightChange);
		}
		if( !bResult )
		{
			SetCollisionSize( OldRadius, CollisionHeight );
			//DMTNS( GetContext(0) $ "  Trying CollisionRadius: " $ CollisionRadius $ " CollisionHeight: " $ CollisionHeight );
			//AddCylinder( OldLocation - vect(0,0,1)*HeightChange, CollisionRadius, CollisionHeight, ColorYellow() );
			bResult = SetLocation( OldLocation - vect(0,0,1)*HeightChange);
		}
		if( !bResult )
		{
			SetCollisionSize( CollisionRadius, OldHeight );
			//DMTNS( GetContext(0) $ "  Trying CollisionRadius: " $ CollisionRadius $ " CollisionHeight: " $ CollisionHeight );
			//AddCylinder( OldLocation - PrePivot, CollisionRadius, CollisionHeight, ColorRed() );
			SetCollision( false, false, false );
			PrePivot = default.PrePivot;
			bResult = SetLocation( OldLocation );
		}
		if( !bResult )
		{
			//DMTNS( GetContext(0) $ "  Trying to gib" );
			TryToGib( class'Crushed' );
		}

		PrePivot.Z += CarcassPrePivotZ;
		
		//DMTNS( "ReduceCylinder END  CollisionRadius: " $ CollisionRadius $ " CollisionHeight: " $ CollisionHeight $ " PrePivot.Z: " $ PrePivot.Z );
		
		bReducedCylinder = true;
		DropEnergy();
	}

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

	function NotifyRagdollCollisionChange()
	{
		//DMTNS( "NotifyRagdollCollisionChange" );
		SetCollision( true, false, false );
		SetCollisionSize( CarcassCollisionRadius, CarcassCollisionHeight );
		bReducedCylinder = true;
		DropEnergy();
	}
	
	//-------------------------------------------------------------------------

	event Tick( float DeltaSeconds )
	{
		local float AmountToSink;
		local vector NewDrawScale3D;
		
		Global.Tick( DeltaSeconds );

		if( bSinkCarcass )
		{
			AmountToSink = DeltaSeconds*CarcassSinkRatePerSec;
			
			// NOTE: increasing the prepivot.Z causes       Meshes to rise
			//       increasing the prepivot.Z causes StaticMeshes to sink
			if( DrawType == DT_StaticMesh )
				PrePivot.Z += AmountToSink;
			else
				PrePivot.Z -= AmountToSink;

			ClearRenderData();
		
			TotalCarcassSinkDistance += AmountToSink;
			
			if( TotalCarcassSinkDistance > 4*CollisionHeight )
				bShrinkCarcass = true;
			
			if( TotalCarcassSinkDistance > 6*CollisionHeight )
			{
				bSinkCarcass = false;

				if( CarcassFadeEffect != None )
				{
					CarcassFadeEffect.ParticleDestroy();
					CarcassFadeEffect = None;
				}
			}
				
			if( CarcassSinkRatePerSec <= CarcassSinkRatePerSecMax )
			{
				CarcassSinkRatePerSec += DeltaSeconds*CarcassSinkRatePerSecInc;
				CarcassSinkRatePerSec = FMin( CarcassSinkRatePerSec, CarcassSinkRatePerSecMax );
			}

		}
		
		if( bShrinkCarcass )
		{
			if( DrawScale3D.X <= 0.01 )
			{
				Destroy();
			}
			else
			{
				NewDrawScale3D = DrawScale3D;
				NewDrawScale3D.X -= DeltaSeconds * CarcassShrinkRateX;
				NewDrawScale3D.Y -= DeltaSeconds * CarcassShrinkRateY;
				NewDrawScale3D.Z -= DeltaSeconds * CarcassShrinkRateZ;
				SetDrawScale3D( NewDrawScale3D );
			}
		}
		
		// can go away if we fix based actors not getting updated
		if( DroppedEnergy != None )
			DroppedEnergy.SetLocation( Location );
	}
	
	//-------------------------------------------------------------------------

	function CleanupCarcass()
	{
		RemoveTimer( CleanupCarcassTimerName );
		
		// start shrinking carcass (in tick)
		//bShrinkCarcass = true;
		
		// start sinking carcass (in tick)
		bSinkCarcass = true;
		SetPhysics( Phys_None );
		SetCollision( false, false, false );
		bCollideWorld = false;

		// play carcass disappearing effect
		CarcassFadeEffect = ParticleRadiator(class'ParticleGenerator'.static.CreateNew( Self, CarcassFadeTemplate ));
		CarcassFadeEffect.MeshOwner = Self;
		CarcassFadeEffect.Trigger( Self, Self );
	}

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

	function CleanupCarcassTimer()
	{
		CleanupCarcass();
	}

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

	function HandleCarcassCleanup()
	{
		local float CleanupDelay;
		
		if( bQuickCarcassCleanup && !bSinkCarcass )
		{			
			//2003.01.31 (mdf) quickly start cleaning up carcass for performance reasons
			if( DroppedEnergy == None )
				CleanupDelay = 2.0;
			else
				CleanupDelay = 5.0;
				
			AddTimer( CleanupCarcassTimerName, CleanupDelay );
		}
	}
	
	//-------------------------------------------------------------------------

	function NotifyRagdollDeathEnded()
	{
		//DMTNS( "NotifyRagdollDeathEnded" );
		SetPhysics( PHYS_None );
		CleanupShadows();
		
		HandleCarcassCleanup();
	}

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

	function LieStill()
	{
		Super.LieStill();
		
		if( bDeleteMe )
			return;

		HandleCarcassCleanup();
	}

	//-------------------------------------------------------------------------
	
	function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
	{
		Super.Trigger( Other, EventInstigator, EventName );
		if( TimeRemaining( CleanupCarcassTimerName ) > 0.0 && EventName == DroppedEnergyPickup.DroppedEnergyDestroyedEvent )
		{
			if( TimeRemaining( CleanupCarcassTimerName ) < 2.0 )
				CleanupCarcass();
			else
				AddTimer( CleanupCarcassTimerName, 2.0 );
		}
	}
	
	//-------------------------------------------------------------------------
	
	function LandThump()
	{
		// animation notify - play sound if actually landed, and animation also shows it
		if( Physics == PHYS_None )
		{			
			bThumped = true;
			AssetsHelperClass.static.HandleLandedOnTexture( Self, Velocity.Z );
		}
	}

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

	function ChunkUp()
	{
		Global.ChunkUp();
		if( DroppedEnergy != None )
			DroppedEnergy.Destroy();
	}

	//-------------------------------------------------------------------------
	//2003.02.03 (mdf) carcass performance fixes

	event Timer()
	{
		// just use standard cleanup method
		CleanupCarcass();
	}

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

	event BeginState()
	{
		//2003.02.03 (mdf) carcass performance fixes
		//local U2Pawn U2P, BestPawn;
		//local float BestDeathTime;

		// make sure stance doesn't change after dying?
		SetStance( GetStance() );
		
		Super.BeginState();		

		//2003.02.03 (mdf) carcass performance fixes
		if( !bQuickCarcassCleanup )
		{
			if( TimeBeforeCarcassDestroyed > 0.0 )
				SetTimer( TimeBeforeCarcassDestroyed, false );
			else
				SetTimer( 0.0, false );
		}

		CarcassSinkRatePerSec = CarcassSinkRatePerSecMin;
		
		//2003.02.03 (mdf) carcass performance fixes
		/*
		Region.Zone.NumCarcasses++;
		BestDeathTime = Level.TimeSeconds;
		if( Region.Zone.MaxCarcasses > 0 && Region.Zone.NumCarcasses > Region.Zone.MaxCarcasses )
		{
			foreach DynamicActors( class'U2Pawn', U2P )
			{
				if( U2P.GetStateName() == DyingState &&
					U2P.TimeSinceBeginState < BestDeathTime &&
					U2P.CarcassSinkRatePerSec <= 0.0 )
				{
					BestDeathTime = U2P.TimeSinceBeginState;
					BestPawn = U2P;
				}
			}
		}
		
		if( BestPawn != None )
			BestPawn.MaybeSinkCarcass( RandRange( Region.Zone.BaseCarcassSinkRatePerSecMin, Region.Zone.BaseCarcassSinkRatePerSecMax ) );
		*/
		
		Buoyancy = DeadBuoyancy;
		bIgnoreImpactForces = true;

		if( UseManager != None )
			UseManager.SetEnabled( Self, false );
	}

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

	event EndState()
	{
		Region.Zone.NumCarcasses--;
	}

} // DyingState

/*-----------------------------------------------------------------------------
Used for dead pawns placed in levels.
*/

state @ DyingPlacedState extends @ DyingState
{
	ignores Bump, HitWall, HeadVolumeChange, PhysicsVolumeChange, BeginFalling, BreathTimer;
	
	//-------------------------------------------------------------------------

	event LandedEx( CheckResult Hit );
	event Timer();
	event AnimEnd( int Channel );
	function LandThump();
	function LieStill();
	function DropEnergy();
	singular event BaseChange();
	simulated event SetInitialState();

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

	event BeginState()
	{
		// don't call super
		SetCollision( true, false, false );
		SetPhysics( PHYS_None );
		bServoEnabled = false;
		AnimRate = 0.0;
		Buoyancy = DeadBuoyancy;
		bAutoEnableAgent = false;
		bIgnoreImpactForces = true;
		if( CollisionHeight == default.CollisionHeight && CollisionRadius == default.CollisionRadius && !bReducedCylinder )
			ReduceCylinder();

		if( LoopDeathAnimRate > 0.0 )
			LoopAnim( AnimSequence, LoopDeathAnimRate );
		else
			AnimRate = 0.0;
	}
} // DyingPlacedState

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

defaultproperties
{
	AnimationControllerClass=Class'U2.AnimationControllerBase'
	AssetsHelperClass=Class'U2.AssetsHelperGeneric'
	DamageFilterClass=Class'U2.DamageFilterDefault'
	TimeBeforeCarcassDestroyed=30.000000
	bServoEnabled=true
	MaxHeadTrackPlayerDistance=2048.000000
	MaxHeadTrackDistance=1024.000000
	MinTimeBetweenHitSounds=0.500000
	FriendDeadSoundDelay=1.250000
	RandomAttackSoundSlot=STS_Attack
	RandomIdleSoundSlot=STS_Idle
	MinRandomSoundTime=1.000000
	MaxRandomSoundTime=8.000000
	MovementPhysics=PHYS_Walking
	CrouchingMoveSpeed=0.300000
	ProneMoveSpeed=0.300000
	StandingMoveSpeed=1.000000
	SetMoveSpeedFudge=1.000000
	DodgeXYVelocityScale=2.000000
	DodgeJumpZScale=0.600000
	MinJumpAnimSpeed=100.000000
	MinLandAnimSpeed=-100.000000
	WalkingAnims(0)=(WalkingAnimType=WAT_WalkFast)
	WalkingAnims(1)=(MinSpeed=0.450000,WalkingAnimType=WAT_RunFast)
	MinTimeBetweenKnockDowns=0.500000
	MinPanicTime=0.500000
	bCanPanic=true
	PanicSoundPauseSeconds=1.500000
	MaxAliveAddedVelocity=1024.000000
	MaxDeadAddedVelocity=2048.000000
	bQuickCarcassCleanup=true
	CarcassSinkRatePerSecMin=1.000000
	CarcassSinkRatePerSecMax=160.000000
	CarcassSinkRatePerSecInc=100.000000
	CarcassShrinkRateX=5.000000
	CarcassShrinkRateY=5.000000
	CarcassShrinkRateZ=5.000000
	CarcassFadeTemplate=ParticleRadiator'corpse_disappear_FX.ParticleRadiator1'
	bInfiniteAmmo=true
	bReloadsEnabled=true
	bDisableErrorColors=true
	bDisableErrorMessages=true
	DrowningDamageAmount=20.000000
	DeathWAT=AT_NoWeapon
	DamageEffectOffsetMultiplier=0.500000
	GibSetClass=Class'U2.GibSetGeneric'
	bCanWalk=true
	bCanSwim=true
	GibForSureHealth=-250.000000
	GibMaybeHealth=-100.000000
	GibMaybeOdds=0.500000
	ControllerClass=None
	LightBrightness=70
	LightHue=40
	LightSaturation=128
	LightRadius=6
	Physics=PHYS_Falling
	bStasis=false
	bIgnoreSingularityDamage=false
	bIgnoreSingularityForces=false
	AmbientGlow=17
	bAutoEnableAgent=true
	bDisturbFluidSurface=true
	SoundRadius=100.000000
	TransientSoundRadius=1500.000000
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleSideBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleSideBars"
}