U2.U2Weapon

//=============================================================================
// U2Weapon.uc
// Created By: Mike Lambert
// Created On: 6/14/01
// $Author: Mfox $
// $Date: 1/29/03 1:50p $
// $Revision: 157 $
//=============================================================================
class U2Weapon extends Weapon
	native
	abstract;

/*
Current States: (they should be self-explanatory)
Active
DownWeapon
Firing
AltFiring
Idle
Reloading

==OVERVIEW==

How the weapon works:

Reloading/Unloading:

Unload() and Reload() functions hide the different anims from the programmer. 
Reload() can be called whenever a reload is desired, either when the weapon 
currently has a partial clip, or it's empty. It takes care of playing OutOfAmmo 
if necessary, and sends it to the Reloading state to handle the animations during 
that time. Unload() is used to make the weapon behave as an unloaded gun, 
and is called after the current clip is emptied. To handle this unloaded 'state' 
without a real state, there are various properties such as: 
AmbientAnim, DownAnim, SelectAnim, which are set differently in Reload() and Unload(). 
All weapon logic can now be the same, and the code should just play the appropriate 
animation variable, ensuring that unloaded and loaded states are never confused.

Selecting/PutDown:

No more PlayPostSelect. Most of the logic here has still been inherited from the Weapon code.

Fire/AltFire:

Every weapon gets its Fire called, which calls AuthorityFire if we are on the server, 
and then proceeds to ALWAYS call EverywhereFire, to handle effects. In order 
to properly send the weapon back to the idle state, the Firing/AltFiring states 
are used. These states are able to handle both auto-firing weapons and 
single-shot weapons, and will do the appropriate logic for each. 
EverywhereFire is equivalent to the old ClientFire, 
and AuthorityFire is very similar to old Fire.
Fire is now just a dispatch mechanism for all fire events.
	This is not done in PlayerController any longer.

FireSound/AltFireSound, when used for single-shot weapons, plays once for 
each shot. When used in continous (bRapidFire/bRapidAltFire) weapons, 
it will be put in the AmbientSound.
Shot Effects:

They've now been moved into a base class, where you specify the appropriate 
type of effect in the def.props. The effect is appropriately triggered with 
each Fire/AltFire, and it supports different effects for both Fire and AltFire 
using the PGenClass and PGenEffect two-element arrays. Any triggerable actor 
should be put there, and it will be triggered with each Fire/AltFire. 
Fire corresponds to the first element, and AltFire corresponds to the second 
element of those arrays. In addition, if one needs to modify the spawn offsets 
(currently a hack while we wait to become 100%-golem-ized), there is 
FlashOffsetFP and FlashOffsetTP arrays for use. The FlameThrower currently 
does not use this interface because it wants to be the odd one out where it 
does not use a triggerable interface, and so it does the effects manuallly 
in its concrete subclass.


===ANIMATION, SOUNDS, AND SETUP===

Sequences Needed:
	Ambient, AmbientUnloaded,
	Down, DownUnloaded, Select, SelectUnloaded
	Fire,Fire1,Fire2,Fire3,etc, FireLastRound, FireEnd
	AltFire,AltFire2,AltFire3,AltFire3,etc, AltFireLastRound, AltFireEnd
	OutOfAmmo, Reload, 
	Idle,Idle2,Idle3,etc


All Weapons Need:
	Ambient/AmbientUnloaded: regular swaying of the weapon
	Down/DownUnloaded: bring down the weapon, in order to switch to another weapon
	Select/SelectUnloaded: bring up the weapon, in order to use it
	Reload: reloads a new clip into the weapon from an unloaded frame
	OutOfAmmo: drop the current partial clip in preparation for a reload
Firing animation stuff: (each of the below applies equally-well to AltFire animations)
	Set the names of the various fire animations in the FireAnims dynamic array.
	If the weapon has a wind-down animation, it needs to be called FireEnd, and bNeedsWindDown should be set
	If the weapon has an animation for when it fires the last shot of the round/clip, it needs to be called FireLastRound.
		This should bring the weapon into an unloaded frame in preparation for Reload
Idle animation stuff:
	Set the names of the various idle animations in the IdleAnims dynamic array.

Variables to set:
	If one has a special animation for FireLastRound
		bHasFireLastRound/bHasAltFireLastRound should be set
		FireLastRound/AltFireLastRound should be the appropriate animation name for the wind-down
		FireEndSound/AltFireSound are the sound to be played as the weapon shoots its last shot
	If one has a wind-down stage:
		bNeedsWindDown/bAltNeedsWindDown should be set
		FireEndSound/AltFireSound are the sound to be played as the weapon winds down
		FireEnd/AltFireEnd should be the appropriate animation name for the wind-down
	If one wants a held-down fire key to repeat the fire loop, for stuff like the pistol/CAR:
		bRepeatFire/bAltRepeatFire must be set
	If the FireSound/FireAltSound is an ambient sound to be played for the life of the weapon's firing
		(from entering the firing state, to leaving it)
		bAmbientFireSound/bAmbientAltFireSound should be set

	For TraceHit Weapons:
		Damage, MomentumTransfer, TraceRange, TraceSpreadFire, TraceSpreadAltFire
		bInstantHit should be set
	For Projectile Weapons:
		ProjectileClass/AltProjectileClass
	MyDamageType is the type of damage
	
	ShellClass/AltShellClass
	WeaponAnimationType
	ImpactHandlerClass
	Shaking Weapons:
		ShakeMag/AltShakeMag, ShakeTime/AltShakeTime, ShakeVert/AltShakeVert
	Kicking Weapons:
		WeaponKickDirection/AltWeaponKickDirection, WeaponKickDuration/AltWeaponKickDuration, WeaponKickRecoveryDuration/AltWeaponKickRecoveryDuration
	Targetting Weapons with the HUD:
		TargetableTypes is an array of the classes which can be targetted by the weapon
	bRapidFire/bAltRapidFire helps the Pawn know what kind of animations it needs to play on it's end

AI Vars: (MikeF may be able to fill this section in more)
	bWarnTarget/bAltWarnTarget
	bRecommendSplashDamage/bRecommendAltSplashDamage
	RefireRate/AltRefireRate

	Aiming: see AdjustAim comments. Note that TraceSpreadFire/AltFire reflects the spread of the weapon due to its
	firing characteristics (in degrees around the selected aim direction). This affects PCs and NPCs equally and
	does not affect the actual aiming of weapon (PCs do their own aiming generally and for NPCs, their accuracy is
	determined by the game's difficulty and various ohter factors such as whether the enemy was recently acquired
	or is falling etc.

Sounds:
	FireSound, AltFireSound, CockingSound (for reload/unload), SelectSound, FireEndSound, AltFireEndSound (described above)

Note: The use of PlaySound in here is intended. Since it is always called 
from simulated functions, it will never be replicated to anyone when called on the server.
Thus, one must ensure that the logic below occurs on all clients which should hear the sound.


Limitations:
The U2Weapon only offers one type of ammo, and one type of reload.
It cannot do different fire and altfire reloads.
It cannot do simultaneous Fire/AltFire combinations



===RENDERING AND DAMAGE===

first-person:
	NM_Standalone:	the player
	NM_Listen:		the player
	NM_Dedicated:	none
	NM_Client:		the player
third-person when drawn:
	NM_Standalone:	visible pawns
	NM_Listen:		visible pawns
	NM_Dedicated:	none
	NM_Client:		visible pawns
third-person when not drawn:
	NM_Standalone:	non-visible pawns
	NM_Listen:		non-visible pawns
	NM_Dedicated:	all pawns
	NM_Client:		non-visible pawns (for brief periods of relevancy)

Weapon Drawing:
RenderOverlays()

Weapon Moving:
first-person:					moved in RenderOverlays
third-person when drawn:		moved when drawn (done natively)
third-person when not drawn:	moved in Tick ... a rough estimate

ParticleSystem Drawing:
SpecialDraw()

ParticleSystem Moving:
first-person:					moved in SpecialDraw (called from native code)
third-person when drawn:		moved in SpecialDraw (called from native code)
third-person when not drawn:	moved in Tick ... a rough estimate

ParticeSystem Locations:
				(if visible)=>	visual	damage	<=(if on role_authority)
first-person:					head	head
third-person when drawn:		hand	hand
third-person when not drawn:	----	head

*/

#exec OBJ LOAD FILE=..\Sounds\U2WeaponsA.uax

// animation support
var(Firing) float	FireTime,
					AltFireTime,
					FireLastDownTime,
					AltFireLastDownTime,
					FireLastReloadTime,
					AltFireLastReloadTime,
					ReloadTime,
					ReloadUnloadedTime,
					SelectTime,
					DownTime;

// flashskin support
var() Material FlashSkin; //the skin to show when we just fired, and want to make the gun appear brighter from the flash
var() Material FlashSkinTP;
var float FireSkinTime; //Time we set the fireskin, so we can turn it off in the next tick (using a timer caused it to be turned off before we even saw it ;)
var() sound FireEndSound, AltFireEndSound; //coincides with FireEnd (the post shot die-down) or FireLastRound (the last shot) animations
var() sound FireLastRoundSound, AltFireLastRoundSound;
var() sound ReloadUnloadedSound;
var() array<sound> GunButtSounds;

var() range FirePitch, AltFirePitch;

var float ProjectileSpeed, AltProjectileSpeed; // used for aiming particle-based "projectile" weapons

var mesh FirstPersonMesh;

// decorative effects
// Fix ARL: Add support for multiple detail levels.
var() array< struct native DecoEffect
{
	var() name			AnimSequence;		// name of the associated animation that this effect should be triggered on
	var() class<Actor>	DecoClass;			// name of the class to spawn
	var() ParticleGenerator	Particles;		// name of the package.object to load the particle system from (optional)
	var() string		MountNode;			// name of the bone to attach to (can be left blank for attaching relative to the weapon's origin)
	var() vector		MountOffset;		// translation offset from mount location
	var() rotator		MountRot;			// rotation offset from mount orientation
	var() vector		ThirdPersonOffset;	// translation offset from weapon hand location in 3rd person (since those use staticmeshes, not golem meshes)
	var() bool			GameplayRelevant;	// effect has an effect on gameplay, such as damaging particles (will be placed at head offset)
	var() bool			bTriggerUpdateOnly;	// only update location when triggered (for effects that need to be left behind)
	var() bool			bWorldFOV;			// draw in world fov (as opposed to weapon fov)
	var() bool			bRequiresWorldZBuffer;// if false and in a 1st-person weapon, draws after the z-buffer has been cleared and the weapon has been drawn. otherwise, draws into the world zbuffer
	var() bool			AutoAim;			// aim particle as though it was a projectile spawned via ProjectileFire.
	var() int			AIAim;				// if set, auto-aim effect for NPCs (value should be set to the speed of the projectile we're aiming -- for leading).
	var() float			PushBack;			// push the effect back up to this number of units if we're too close to anything (not evaluated for TriggerUpdateOnly effects).
	var   Actor			Effect;				// instance of above described effect
} > DecoEffects;

var name LastTriggeredAnim;

var bool bLockLocation;		//DEBUG: set to stop weapon from updating it's location

//DEBUG: For temporarily tweaking weapon offsets.
var bool bAdjustWeaponXY;
var bool bAdjustWeaponZ;
var bool bAdjustWeaponPitchYaw;
var bool bAdjustWeaponRoll;
var int MagicKey;
var float fAdjustWeaponRate;
var vector LocationOffset;
var rotator RotationOffset;
var vector TraceFireStartLocation;
var vector ProjectileFireStartLocation;
var() vector FirstPersonOffset;

var() bool bRepeatFire, bRepeatAltFire; //should we go directly into playing the next animation after playing this one?
var() bool bAmbientFireSound, bAmbientAltFireSound; //should the FireSound/AltFireSound be played as an ambient sound?

var config bool UseGlowingCrosshairs;	// Allow user to disable for performance.
var bool bCrosshairGlows; //crosshair should glow when it is over a targetable actor
var bool bGlowing; //whether the crosshair is currently glowing
var Controller.EAttitude GlowingAttitude; //attitude towards targetable actor (enemy/neutral/friend)

var() protected LicenseePawn.EWeaponAnimationType WeaponAnimationType;	// usual intended animation type for weapon (shoulder, small etc.)

var() class<ImpactHandler> ImpactHandlerClass;			//

var() float Damage,AltDamage;							// used for instant hit weapons
var() float MomentumTransfer;							// used for instant hit weapons
var() float TraceRange;									// range used within TraceFire()
var() float TraceSpreadFire, TraceSpreadAltFire;		// spread (degrees) used with TraceFire() for PCs and NPCs

// weapon shake (extension of ShakeMag, ShakeTime, ShakeVert implemented in Weapon.uc)
var(WeaponShake) float	AltShakeMag;					//
var(WeaponShake) float	AltShakeTime;					//

// shell ejection
var() class<U2ShellCase>	ShellClass;					//
var() class<U2ShellCase>	AltShellClass;				//
var() vector				ShellOffset;				//

// weapon dropped -- bounce handling
var() sound BounceSound;
var() float BounceDamping;

// misc. weapon effects
var float LastWaterRingTime;

var bool bFiring;										// firing state (used to differentiate Fire()/AltFire() handling)
var bool bAltFiring;
var bool bLastRound;

// Crosshair stuff.
var() array<name> TargetableTypes;							// Types of classes we can target.
var() string CrosshairFilename;
var() string CrosshairName;
var ComponentHandle Crosshair;

// optimization support.
var float LastFullUpdateTime;

var bool  bDisableTick;		// performance testing: disable weapon tick overhead temporarily
var bool  bDisableFiring;	// performance testing: disable weapon firing overhead temporarily

//-----------------------------------------------------------------------------
// U2 Weapon AI properties
//-----------------------------------------------------------------------------

const MaxRapidFireRate		=   0.50;		// firing rates <= this are considered rapid fire
const MinSlowFireRate		=   0.51;		// firing rates >= this are considered slow fire

// special weapon rating values
const RatingFireNow			= 100.000;		// weapon wants Pawn to fire it immediately (i.e. even if no target)
const RatingHighest			=  90.000;		// weapon thinks it would be highly effective if used now
const RatingDefault			=   0.000;		// default
const RatingLow				=  -5.000;		// weapon is a poor choice but could be used if nothing better
const RatingIneffective		= -10.000;		// weapon will have no effect on target in current situation
const RatingDangerous		= -20.000;		// using weapon now will likely hurt/kill owner
const RatingNoAmmo  		= -30.000;		// not enough ammo to fire/altfire
const RatingCantFire		= -40.000;		// can't actually fire weapon currently (not ready etc.)
const RatingDisabled		= -50.000;		// weapon is disabled (alt and primary fire)
const RatingNone			= -99.999;		// no rating (e.g. no weapon)

const RangeUnlimited		= 32767.0;		// no limit to effective range of weapon (limit to reasonable size for levels)

// AI !!mdf-tbd: generalize
var() bool bAimFire;						// whether primary fire requires owner aiming (usually true)
var() bool bAimAltFire;						// whether alt fire requires owner aiming (usually true)
var() bool bFireEnabledForOwner;			// supports disabling fire for specific weapons for specific NPCs
var() bool bAltFireEnabledForOwner;			// supports disabling altfire for specific weapons for specific NPCs

//NOTE: AIRating still used to specify the "global" rating for a weapon vs other weapons and should be set
//to Max( AIRatingFire, AIRatingAltFire );
//!!mdf-tbd: turn all of these into config vars for tweaking purposes
var() float RangeMinFire;					// min range to target for firing weapon (-1 = range not considered)
var() float RangeIdealFire;					// ideal range to target for firing weapon (-1 = range not considered)
var() float RangeMaxFire;					// max range to target for firing weapon (-1 = range not considered)
var() float RangeLimitFire;					// absolute limit of range to target for firing weapon (default is use RangeMaxFire as limit)
var() float RatingInsideMinFire;			// rating for firing weapon inside min range
var() float RatingRangeMinFire;				// rating for firing weapon at min range
var() float RatingRangeIdealFire;			// rating for firing weapon at ideal range
var() float RatingRangeMaxFire;				// rating for firing weapon at max range
var() float RatingRangeLimitFire;			// rating for firing weapon at limit of range
var() float AIRatingFire;					// default rating for firing weapon (used when range not considered or no target)
											
var() float RangeMinAltFire;				// min range to target for alt-firing weapon (-1 = range not considered)  
var() float RangeIdealAltFire;				// ideal range to target for alt-firing weapon (-1 = range not considered)
var() float RangeMaxAltFire;				// max range to target for alt-firing weapon (-1 = range not considered)  
var() float RangeLimitAltFire;				// absolute limit of range to target for alt-firing weapon (default is use RangeMaxAltFire as limit)
var() float RatingInsideMinAltFire;			// rating for alt-firing weapon inside min range
var() float RatingRangeMinAltFire;			// rating for alt-firing weapon at min range                             
var() float RatingRangeIdealAltFire;		// rating for alt-firing weapon at ideal range                           
var() float RatingRangeMaxAltFire;			// rating for alt-firing weapon at max range                             
var() float RatingRangeLimitAltFire;		// rating for alt-firing weapon at limit of range
var() float AIRatingAltFire;				// default rating for alt-firing weapon (used when range not considered or no target

var	  float UpdateRangeGravityZ;			// for weapons using tossed projectiles, last Z gravity used to update ranges
var   Ammunition UpdateRangeAmmoType;		// for weapons using tossed projectiles (in case ammo type can vary)

var U2PlayerController U2PCOwner;			// set in XXXBeginPlay to avoid need to cast owner all over the place

replication
{
	// we use unreliable here to avoid network overflow from reliable functions
	//   the order and guarantee of the function is not as important,
	//   and packetloss causing ClientTraceImpact to fail is an acceptable tradeoff
	unreliable toall if( Role == ROLE_Authority )
		ClientTraceImpact;
}


//DEBUG: For temporarily tweaking weapon offsets.
exec function AdjustWeaponXY()			{ bAdjustWeaponXY		=true; StartAdjust(); }
exec function AdjustWeaponZ()			{ bAdjustWeaponZ		=true; StartAdjust(); }
exec function AdjustWeaponPitchYaw()	{ bAdjustWeaponPitchYaw	=true; StartAdjust(); }
exec function AdjustWeaponRoll()		{ bAdjustWeaponRoll		=true; StartAdjust(); }
exec function AdjustWeaponRate(float f)	{ fAdjustWeaponRate = f; }
exec function StopAdjust()
{
	bAdjustWeaponXY=false;
	bAdjustWeaponZ=false;
	bAdjustWeaponPitchYaw=false;
	bAdjustWeaponRoll=false;

	if(MagicKey!=0)
		class'UIConsole'.static.RemoveKeyEventListener( MagicKey );
	MagicKey=0;
}
function StartAdjust()
{
	MagicKey = class'UIConsole'.static.AddKeyEventListener( self, "MouseMove" );
}
exec function AdjustWeaponLog()
{
	DM	(	"X="$-LocationOffset.Y
		@	"Y="$LocationOffset.Z
		@	"Z="$LocationOffset.X
		@	"Pitch="$RotationOffset.Pitch	* 360.0 / 65536.0
		@	"Yaw="$RotationOffset.Yaw		* 360.0 / 65536.0
		@	"Roll="$RotationOffset.Roll		* 360.0 / 65536.0
		);
}
function bool MouseMove( Console.EInputKey Key, Console.EInputAction Action, float Delta )
{
	if( Action == IST_Axis )
	{
		switch( Key )
		{
		case IK_MouseX:
			if(bAdjustWeaponXY)
				LocationOffset.Y += fAdjustWeaponRate * Delta;
			if(bAdjustWeaponPitchYaw)
				RotationOffset.Yaw += fAdjustWeaponRate * Delta * 182.0;
			if(bAdjustWeaponRoll)
				RotationOffset.Roll += fAdjustWeaponRate * Delta * 182.0;
			ThirdPersonRelativeLocation = LocationOffset;
			return true;
		case IK_MouseY:
			if(bAdjustWeaponXY)
				LocationOffset.Z += fAdjustWeaponRate * Delta;
			if(bAdjustWeaponZ)
				LocationOffset.X += fAdjustWeaponRate * Delta;
			if(bAdjustWeaponPitchYaw)
				RotationOffset.Pitch += fAdjustWeaponRate * Delta * 182.0;
			ThirdPersonRelativeLocation = LocationOffset;
			return true;
		}
	}
	return false;
}


//Dummy overrides to ensure no logic from parent classes comes through
simulated function Finish()
{}
simulated function ClientFinish()
{}
simulated event AnimEnd( int Channel )
{}

//-----------------------------------------------------------------------------
// Aiming
//-----------------------------------------------------------------------------

function bool AdjustTraceAim( float projSpeed, vector projStart, float FireSpread, bool bLeadTarget, bool bWarnTarget, bool bTossed, bool bTrySplash )
{
	return Pawn(Owner).AdjustAim( None, projSpeed, projStart, FireSpread, false, false, false, false );
}

function bool AdjustProjectileAim( bool bAltFire, class<Projectile> ProjectileClass, vector projStart, float FireSpread, bool bLeadTarget, bool bWarnTarget, bool bTossed, bool bTrySplash )
{
	return Pawn(Owner).AdjustAim( ProjectileClass, GetProjSpeed( bAltFire ), projStart, FireSpread, bLeadTarget, bWarnTarget, bTossed, bTrySplash );
}

function bool AdjustAim( bool bAltFire, bool bInstant, float FireSpread, class<projectile> ProjClass, bool bWarnTarget, bool bTrySplash )
{
	local bool bResult;
	
	// test for situation which doesn't require aiming (e.g. takkra alt fire)	
	if( !bAltFire && !bAimFire )
		bResult = true;
	else if( bAltFire && !bAimAltFire )
		bResult = true;
	else if( bInstant )
		bResult = AdjustTraceAim( 1000000, TraceFireStartLocation, FireSpread, false, false, false, false );
	else
		bResult = AdjustProjectileAim( bAltFire, ProjClass, ProjectileFireStartLocation, FireSpread, true, bWarnTarget, ProjClass? && (ProjClass.default.Physics == PHYS_Falling), bTrySplash );
	return bResult;	
}

/*-----------------------------------------------------------------------------
Most weapons use the default PreSetAimingParameters behavior (when owner begins 
firing the weapon, set fire start location, then set owner's aiming rotation 
for use when the weapon is actually fired. If false is returned, abort firing 
the weapon. 

The DP alt-fire fires its projectile when the owner *stops* alt-firing and in
this case the weapon is aimed just prior to spawning the projectile (at that
point it is too late to abort firing the weapon).
*/

function bool PreSetAimingParameters( bool bAltFire, bool bInstant, float FireSpread, class<projectile> ProjClass, bool bWarnTarget, bool bTrySplash )
{
	local bool bResult;
	SetFireStartLocations();
	bResult = AdjustAim( bAltFire, bInstant, FireSpread, ProjClass, bWarnTarget, bTrySplash );
	return bResult;
}

function PostSetAimingParameters( bool bAltFire, bool bInstant, float FireSpread, class<projectile> ProjClass, bool bWarnTarget, bool bTrySplash )
{
	// override to have this function do anything useful
}

//-----------------------------------------------------------------------------
// AI Interface
//-----------------------------------------------------------------------------

/*-----------------------------------------------------------------------------
NOTES:

U2 NPCs can be set up to not use fire/altfire on a per-NPC basis (e.g. to
force an NPC to use a particular weapon in a specific manner).
*/

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

function final DMW( coerce string Msg )
{
	if( false )
		DMTN( Msg );
}

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

function UpdateRanges( float Speed, float DamageRadius, out float RangeIdeal, out float RangeMax, out float RangeLimit )
{
	local float MaxRange;

	// do the calculation using the current gravity 
	MaxRange = class'UtilGame'.static.GetMaxRange( Owner, class'Projectile', Speed );

	RangeLimit	= MaxRange + DamageRadius;
	RangeIdeal	= 0.30*MaxRange;	// seems about right for grenades -- maybe not for all tossed projectiles?
	RangeMax	= 0.75*MaxRange;	// seems about right for grenades -- maybe not for all tossed projectiles?

	//DMTNS( "ProjectileClass: " $ ProjectileClass );
	//DMTNS( "Speed:           " $ Speed );
	//DMTNS( "DamageRadius:    " $ DamageRadius );	
	//DMTNS( "MaxRange:        " $ MaxRange );
	//DMTNS( "RangeMax:        " $ RangeMax );
	//DMTNS( "RangeLimit:      " $ RangeLimit );
}

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

function UpdatePriRanges()
{
	if( ProjectileClass? && ProjectileClass.default.Physics == PHYS_Falling	)
		UpdateRanges( GetProjSpeed( false ), ProjectileClass.default.DamageRadius, RangeIdealFire, RangeMaxFire, RangeLimitFire );
}

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

function UpdateAltRanges()
{
	if( AltProjectileClass? && AltProjectileClass.default.Physics == PHYS_Falling	)
		UpdateRanges( GetProjSpeed( true ), AltProjectileClass.default.DamageRadius, RangeIdealAltFire, RangeMaxAltFire, RangeLimitAltFire );
}

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

function bool HasEnoughModeAmmo( int AmmoUsed, int NumUses )
{
	return( !AmmoType || AmmoUsed <= 0 || AmmoType.AmmoAmount/AmmoUsed >= NumUses );
}

/*-----------------------------------------------------------------------------
Has enough fire or alt-fire ammo to fire the weapon at least the given number 
of times.

!!mdf-tbd: probably need properties to indicate whether each mode of fire can
actually be used to attack (e.g. don't want to return true for alt-fire of
sniper rifle...)

!!mdf-tbd: possible optimization -- this is potentially getting called very
frequently. Could add bEnoughFireAmmo and bEnoughAltFireAmmo and just track 
these whenever ammo amount changes (this will happen a lot less frequently).
*/

function bool HasEnoughAmmo( int MinUses )
{
	return( HasEnoughModeAmmo( GetFireAmmoUsed(), MinUses ) || 
			HasEnoughModeAmmo( GetAltFireAmmoUsed(), MinUses ) );
}

//-----------------------------------------------------------------------------
// Primary and Alt firing modes are both enabled and both were given about the
// same rating. Select one or the other.

function byte SelectFiringMode( Actor Target )
{
	// !!mdf-tbd: add a property for this
	return byte(FRand() < 0.5); // 50/50 fire/altfire for now
}

/*-----------------------------------------------------------------------------
Can be used in subclasses to modify weapon's fire/altfire ratings prior to 
call(s) to GetModeRating for each mode and to optionally prevent GetModeRating
form being called for either or both modes.

NOTE: If a rating of RatingDisabled is passed in, subclasses should NOT modify
that rating since this means that weapon use for this mode (primary/alt) is
disabled (e.g. because bots don't know how to use that mode or because the
weapon itself isn't yet functional).

Subclasses can clear bGetFireRating and/or bGetAltFireRating to disable the
call to GetModeRating for the primary and/or alt fire modes respectively.
*/

function PreModifyRatings( Actor Target, float DistanceToEnemy, 
						   out float PriFireRating, out float AltFireRating, 
						   out byte bGetFireRating, out byte bGetAltFireRating )
{}

/*-----------------------------------------------------------------------------
Can be used in subclasses to modify weapon's fire/altfire ratings after call(s)
to GetModeRating for each mode.

NOTE: If a rating of RatingDisabled is passed in, subclasses should NOT modify
that rating since this means that weapon use for this mode (primary/alt) is
disabled (e.g. because bots don't know how to use that mode or because the
weapon itself isn't yet functional).
*/

function PostModifyRatings( Actor Target, float DistanceToEnemy, out float PriFireRating, out float AltFireRating )
{}

//-----------------------------------------------------------------------------
// Returns default Fire/AltFire rating. Subclasses can hook into this? 
// !!mdf-tbd: add other hooks as needed as more specific weapon rating added.

function float DefaultRating( Actor Target, bool bUseAltMode )
{
	if( bUseAltMode )
		return AIRatingAltFire;
	else
		return AIRatingFire;
}

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

function float NoEnemyRating( bool bUseAltMode )
{
	return DefaultRating( None, bUseAltMode );
}

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

function float NotUsingRangeRating( Actor Target, bool bUseAltMode )
{
	return DefaultRating( Target, bUseAltMode );
}

/*-----------------------------------------------------------------------------
!!mdf-tbd: encourage bot to position himself in anticipation of switching to some 
weapon which is effective at that location (distance, snipe point etc.) while 
using best weapon for current distance i.e. 1) what is my best weapon for my 
current position 2) what is my best weapon overall if I can get into a good 
situation in which to use it (e.g. if many targets in one area, back off, 
fire singularity cannon from distance, avoid that area for a while; have 
shotgun -- fire current weapon while closing then blow target away from close 
range with shotgun (note have to factor in time to switch into decision to 
switch

should also add code to take reloading into account...

bots should reload appropriately (i.e. if Skill > x, don't wait until
out of ammo)

!!mdf-tbd: properties should replace magic #'s here (InsideMinRangeAIRating etc. --
e.g. with some weapons, firing weapon at target inside min range could be 100% fatal
to npc

!!mdf-tbd: simply usess a location-to-location dist -- take CC sizes into account?

tbd: check target visibility?

!!mdf-tbd: what if outside max range but rapidly closing on target?

!!mdf-tbd: how to generalize increasing rating with owner's skill?

!!mdf-tbd: support non linear scaling, e.g. exponential falloffs?

*/

// !!mdf-tbi: expose this and associated code so that any NPC can determine the effectiveness of an attack
// based on distance to target even if they don't use actual weapons.
function float GetModeRating(
	Actor Target, 
	float DistanceToEnemy, 
	float RangeMin, 
	float RangeIdeal, 
	float RangeMax, 
	float RangeLimit, 
	float RatingInsideMin,
	float RatingRangeMin, 
	float RatingRangeIdeal, 
	float RatingRangeMax,
	float RatingRangeLimit,
	float RatingBase,
	bool bUseAltMode )
{
	local float ReturnedRating;
	local float DistancePastMax, ScaleFactor;

	//#debug DMW( "GetModeRating -- RangeMin: " $ RangeMin $ " RangeMax: " $ RangeMax $ " DistanceToEnemy: " $ DistanceToEnemy );

	if( !Target )
	{
		// no target -- default to "raw" rating
		//#debug DMW( "no target" );
		ReturnedRating = NoEnemyRating( bUseAltMode );
	}
	else if( RatingBase == RatingDisabled )
	{
		// weapon is disabled in this mode
		return RatingDisabled;
	}
	else if( RangeMin == -1 || RangeMax == -1 )
	{
		// weapon not affected by range -- default to "raw" rating
		//#debug DMW( "not affected by range" );
		ReturnedRating = NotUsingRangeRating( Target, bUseAltMode );
	}
	else if( DistanceToEnemy < RangeMin )
	{
		// 0..Min --> RatingIneffective
		//#debug DMW( "in 0..min" );
		ReturnedRating = RatingInsideMin;
	}
	else if( DistanceToEnemy < RangeIdeal )
	{
		// Min..Ideal --> RatingRangeMin..RatingRangeIdeal
		//#debug DMW( "in min..ideal" );
	   	ReturnedRating = (RatingRangeIdeal-RatingRangeMin)*(DistanceToEnemy-RangeMin)/(RangeIdeal-RangeMin) + RatingRangeMin;
	}
	else if( DistanceToEnemy < RangeMax )
	{
		// Ideal..Max --> RatingRangeIdeal to RatingRangeMax
		//#debug DMW( "in ideal..max: " );
	 	ReturnedRating = ( (RatingRangeIdeal-RatingRangeMax)*(RangeMax-DistanceToEnemy)/(RangeMax-RangeIdeal) + RatingRangeMax );
	}
	else if( DistanceToEnemy < RangeLimit )
	{
		// Max..Limit --> RatingRangeMax..RatingRangeLimit (fall off with square of distance past max?)
		//#debug DMW( "in max..limit " );

		DistancePastMax = (DistanceToEnemy - RangeMax)*0.10; // don't fall off too quickly (!!mdf-tbd: expose this?)
		ScaleFactor = FMax( 0.0, (RangeLimit-(DistanceToEnemy+DistancePastMax*DistancePastMax))/(RangeLimit-RangeMax) );
	 	ReturnedRating = ( (RatingRangeMax-RatingRangeLimit)*ScaleFactor + RatingRangeLimit );
	}
	else
	{
		// > Limit --> RatingIneffective (outside of range limit for weapon)
		//#debug DMW( "in limit.." );
	 	ReturnedRating = RatingIneffective;
	}

	return ReturnedRating;
}

//-----------------------------------------------------------------------------
// Use the CC to CC distance, not the location to location distance.

function float GetWeaponDistanceToEnemy( Actor Target )
{
	if( !Target )
		return -1.0;
	else
		return class'Util'.static.GetDistanceBetweenActors( Owner, Target );
}

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

function float GetWeaponRating( Actor Target, out byte bUseAltMode, bool bSupportsFire, bool bSupportsAltFire )
{
	local float ReturnedRating;
	local float DistanceToEnemy;
	local float PriFireRating, AltFireRating;
	local byte bGetFireRating, bGetAltFireRating;
	local float RandomizeRange;
	
	if( bSupportsFire )
	{
		PriFireRating = RatingNone;
		bGetFireRating = 1;
	}
	else
	{
		PriFireRating = RatingDisabled;
		bGetFireRating = 0;
	}

	if( bSupportsAltFire )
	{
		AltFireRating = RatingNone;
		bGetAltFireRating = 1;
	}
	else
	{
		AltFireRating = RatingDisabled;
		bGetAltFireRating = 0;
	}

	DistanceToEnemy = GetWeaponDistanceToEnemy( Target );

	//DMTNS( "GetWeaponRating -- DistanceToEnemy: " $ DistanceToEnemy );
	//DMTNS( "AmmoType: " $ AmmoType );
	//DMTNS( "ProjectileClass: " $ ProjectileClass );
	
	// if gravity changed (or first time through) redo ranges for tossed projectiles
	if( PhysicsVolume.Gravity.Z != UpdateRangeGravityZ || AmmoType != UpdateRangeAmmoType )
	{
		UpdatePriRanges();
		UpdateAltRanges();
		UpdateRangeGravityZ = PhysicsVolume.Gravity.Z;
		UpdateRangeAmmoType = AmmoType;
	}

	// give weapon a chance to muck with ratings
	PreModifyRatings( Target, DistanceToEnemy, PriFireRating, AltFireRating, bGetFireRating, bGetAltFireRating );

	if( bGetFireRating == 1 )
	{
		// get fire	rating
		PriFireRating = GetModeRating( 
							Target, DistanceToEnemy, 
							RangeMinFire, RangeIdealFire, RangeMaxFire, RangeLimitFire,
							RatingInsideMinFire, RatingRangeMinFire, RatingRangeIdealFire, RatingRangeMaxFire, RatingRangeLimitFire, 
							AIRatingFire, false );
	}

	if( bGetAltFireRating == 1 )
	{
		// get altfire rating
		AltFireRating = GetModeRating( 
							Target, DistanceToEnemy, 
							RangeMinAltFire, RangeIdealAltFire, RangeMaxAltFire, RangeLimitAltFire,
							RatingInsideMinAltFire, RatingRangeMinAltFire, RatingRangeIdealAltFire, RatingRangeMaxAltFire, RatingRangeLimitAltFire, 
							AIRatingAltFire, true );
	}

	// now that the pri/alt ratings are known give subclasses a chance to filter pri/alt fire
	PostModifyRatings( Target, DistanceToEnemy, PriFireRating, AltFireRating );

	// !!mdf-tbd: treat fairly close results as being the same so one of fire/altfire doesn't dominate?
	//#debug DMW( "GetWeaponRating -- Comparing PriFireRating " $ PriFireRating $ " with AltFireRating " $ AltFireRating );

	ReturnedRating = FMax( PriFireRating, AltFireRating );

	//DM( "GetWeaponRating -- Comparing PriFireRating " $ PriFireRating $ " with AltFireRating " $ AltFireRating );
	bUseAltMode = 0;
	if( AltFireRating > PriFireRating )
	{
		//DM( "using alt fire" );
		bUseAltMode = 1; // use alt fire
	}
	else if( AltFireRating ~= PriFireRating )
	{
		//DM( "calling SelectFiringMode" );
		bUseAltMode = SelectFiringMode( Target );
	}

	// randomize "normal" ratings somewhat (more for lower skill NPCs)
	if( ReturnedRating >= -1.0 && ReturnedRating <= 1.0 )
	{
		// skill=0.0 --> range of +/- 0.2, skill=1.0 --> range of +/- 0.1
		RandomizeRange = (1.0 - Instigator.Controller.GetSkill()) * 0.1 + 0.1;
		//DMTNS( "RandomizeRange: " $ RandomizeRange );
		//DMTNS( "Rating before randomizing: " $ ReturnedRating );
		ReturnedRating += ( RandomizeRange - (2 * FRand() * RandomizeRange) );
		//DMTNS( "Rating after randomizing: " $ ReturnedRating );
	}
	
	//#debug DMW( "  GetWeaponRating -- ReturnedRating " $ ReturnedRating );
	return ReturnedRating;
}

/*-----------------------------------------------------------------------------
NOTE: basically treats alt and primary fire as 2 different weapons, evaluates
each then returns the higher rating and sets bUseAltMode accordingly.

NOTE: Its possible for this function to be called on a weapon belonging to a 
(human) player. This happens when an NPC wants to determine the relative
strength of a potential target which happens to be a human player.

!!mdf-support weapon suggesting firing duration and firing style (e.g. sweep
vs aim, aim for head etc.)?
*/

function float RateSelf( Actor Target, out byte bUseAltMode )
{
	local float ReturnedRating;
	local bool bSupportsFire, bSupportsAltFire;
	local bool bHasEnoughAmmo, bHasEnoughAltAmmo;

	//#debug DMW( "RateSelf for Owner=" $ Owner $ " Target=" $ Target );

	// clear in case caller passed this in set
	bUseAltMode	= 0;

	// make sure Owner's Controller set
	if( Instigator.Controller? )
	{
		bHasEnoughAmmo = HasEnoughModeAmmo( GetFireAmmoUsed(), 1 );
		bHasEnoughAltAmmo = HasEnoughModeAmmo( GetAltFireAmmoUsed(), 1 );

		if( bHasEnoughAmmo || bHasEnoughAltAmmo )
		{
			// has enough ammo to fire the weapon in at least 1 mode
			bSupportsFire = (bHasEnoughAmmo && bFireEnabledForOwner);
			bSupportsAltFire = (bHasEnoughAltAmmo && bAltFireEnabledForOwner);
		
			if(	bSupportsFire || bSupportsAltFire )
			{	
				ReturnedRating = GetWeaponRating( Target, bUseAltMode, bSupportsFire, bSupportsAltFire );
			}
			else		
			{
				//#debug DMW( "weapon fire/altfire disabled!" );
				ReturnedRating = RatingDisabled;
			}
		}
		else
		{
			//#debug DMW( "not enough fire/altfire ammo!" );
			ReturnedRating = RatingNoAmmo;
		}
	}
	else
	{
		//#debug DMW( "Controller not set!" );
		ReturnedRating = RatingCantFire;
	}

	//#debug DMW( "  RateSelf -- ReturnedRating " $ ReturnedRating );
	return ReturnedRating;
}

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

function float SuggestAttackStyleNoEnemy( bool bUseAltMode )
{
	return U2NPCController.StyleNeutral;
}

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

function float SuggestAttackStyleNoRange( bool bUseAltMode )
{
	// generally back off?
	return U2NPCController.StyleBackOff;
}

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

function float SuggestAttackStyleMode( Actor Target, float RangeMin, float RangeIdeal, float RangeMax, bool bUseAltMode )
{
	local float DistanceToEnemy;
	local float ReturnedStyle;

	DistanceToEnemy = GetWeaponDistanceToEnemy( Target );

	if( !Target )
	{
		// no Target
		ReturnedStyle = SuggestAttackStyleNoEnemy( bUseAltMode );
	}
	else if( RangeMin == -1 || RangeMax == -1 )
	{
		// not affected by range
		ReturnedStyle = SuggestAttackStyleNoRange( bUseAltMode );
	}
	else if( DistanceToEnemy > RangeMax )
	{
		// > max -- strongly encourage bot to close to ideal range
		ReturnedStyle = U2NPCController.StyleClose;
	}
	else if( DistanceToEnemy > RangeIdeal )
	{
		// in ideal..max -- encourage bot to close in somewhat
		ReturnedStyle = 0.8*(DistanceToEnemy-RangeIdeal)/(RangeMax-RangeIdeal);
	}
	else if( DistanceToEnemy > RangeMin )
	{
		// in Min..ideal -- encourage bot to back off somewhat
		ReturnedStyle = -0.8*(RangeIdeal-DistanceToEnemy)/RangeIdeal;
	}
	else if( DistanceToEnemy < RangeMin )
	{
		// in 0..ideal -- strongly encourage bot to back off
		ReturnedStyle = U2NPCController.StyleBackOff;
	}
	else
	{
		// at ideal
		ReturnedStyle = U2NPCController.StyleNeutral;
	}

	//#debug DMW( "SuggestAttackStyleMode: " $ ReturnedStyle );
	return ReturnedStyle;
}

/*-----------------------------------------------------------------------------
Tell NPC to close/back off depending on distance to target vs weapon's ideal
and max range. !!mdf-tbd: this results in modifying bot's aggression which 
isn't exactly what we want (even a very aggressive/timid bots should try
to use the weapon correctly, no)?

Default implementation tries to encourage NPCs to maintain the weapon's 
ideal distance, subclasses can modify this -- e.g. if alt firing GL run!

!!mdf-tbd: for speed, much can be pre-calculated

NOTE: AI code multiplies return value by 2. See also SuggestDefenseStyle. 
Both of these functions are only used to modify the NPC's aggression in 
the TacticalMove state.

!!mdf-tbd: shouldn't weapon also affect bot's style -- e.g. if NPC has a
bunch of weapons, should try to get at optimum distance for best one?
Might be hard to get this to work well, especially in tight levels.

!!mdf-tbd: bUseAltMode is currently always 0. But, I don't think we want
to pass in the alt mode since in some (many?) cases RateSelf will be 
rapidly flipping between suggesting that the NPC use the alt of pri version 
of the weapon with the result that SuggestAttackStyle could end up returning
contradictory values. It seems that the intended mode which will be used
is less important than trying to get the NPC into the ideal range for the
weapon as a whole (or even, for the best weapon in the NPC's
inventory as a whole), no? This should just go off of the Weapon's Fire
and AltFire ratings, ideal distances for those ratings and the distance
to the target.

But, I can also imagine situations in which the weapon needs to tell the
NPC how to use it for a specific mode.
*/

function float SuggestAttackStyle( Actor Target )
{
	local float ReturnedStyle;
	local bool bSupportsFire, bSupportsAltFire;

/* OLD crapola -- see above comment
	if( bUseAltMode == 0 )
		ReturnedStyle = SuggestAttackStyleMode( Target, RangeMinFire, RangeIdealFire, RangeMaxFire, false );
    else
		ReturnedStyle = SuggestAttackStyleMode( Target, RangeMinFire, RangeIdealAltFire, RangeMaxAltFire, true );
*/

	// check whether each mode is enabled/has enough ammo
	if( CanFire() )
	{
		bSupportsFire = ( HasEnoughModeAmmo( GetFireAmmoUsed(), 1 ) && bFireEnabledForOwner );
		bSupportsAltFire = ( HasEnoughModeAmmo( GetAltFireAmmoUsed(), 1 ) && bAltFireEnabledForOwner );
		
		if(	bSupportsFire && bSupportsAltFire )
		{
			// both supported -- pick the mode with the best rating and try to get the NPC to that mode's ideal distance
			if( AIRatingFire >= AIRatingAltFire )
				ReturnedStyle = SuggestAttackStyleMode( Target, RangeMinFire, RangeIdealFire, RangeMaxFire, false );
			else
				ReturnedStyle = SuggestAttackStyleMode( Target, RangeMinAltFire, RangeIdealAltFire, RangeMaxAltFire, true );
		}
		else if( bSupportsFire )
		{
			// only primary supported
			ReturnedStyle = SuggestAttackStyleMode( Target, RangeMinFire, RangeIdealFire, RangeMaxFire, false );
		}
		else if( bSupportsAltFire )
		{
			// only alt supported
			ReturnedStyle = SuggestAttackStyleMode( Target, RangeMinAltFire, RangeIdealAltFire, RangeMaxAltFire, true );
		}
		else
		{
			// neither supported -- run away!
			ReturnedStyle = U2NPCController.StyleRunaway;
		}
	}
	else
	{
		// reloading etc.
		ReturnedStyle = U2NPCController.StyleRunaway;
	}

	//#debug DMW( "SuggestAttackStyle: " $ ReturnedStyle );
	return ReturnedStyle;
}

/*-----------------------------------------------------------------------------
Used for recommending whether NPC should close or back-off based on current
Target's weapon. Note: this isn't the inverse of SuggestAttackStyle. e.g. if an
NPC is standing at the perfect distance for an Target with a flamethrower, the
Target's weapon is telling him to stay put while the NPC should back off. This 
is tricky because if both of them have flamethrowers, then the more each backs
off, the more the flamethrower will tell them to close. For now I'll try using
some -ve value for situation where Target weapon is a weapon that is only
effective at close distances.

float RangeDefensiveFire
float RangeDefensiveAltFire
float RatingRangeDefensiveFire
float RatingRangeDefensiveAltFire
*/

function float SuggestDefenseStyle( Actor Target )
{
/*
	!!mdf-tbi:
	local float ReturnedStyle;
	local float ReturnedStyleFire;
	local float ReturnedStyleAltFire;

	// we don't know which mode the Target will use so assume the worst
	ReturnedStyleFire = SuggestAttackStyleMode( Other, RangeMinFire, RangeIdealFire, RangeMaxFire, false );
	ReturnedStyleAltFire = SuggestAttackStyleMode( Other, RangeMinFire, RangeIdealFire, RangeMaxFire, false );

	// !!mdf-tbd: seems to make sense for now:
	#debug DMW( "SuggestDefenseStyle: " $ ReturnedStyle );
	return ReturnedStyle( Other, bUseAltMode ;
*/

	return U2NPCController.StyleNeutral;
}

//-----------------------------------------------------------------------------
// Overridden to implement U2-specific behavior. For example, the engine
// version mucks with the weapon's rating so that NPC's will tend to stick
// with the same weapon even if that weapon is out of ammo or has been given a
// rating which says it is useless in the current situation. It also seems that
// the decision to stick with the current weapon shouldn't be made based on
// ratings -- NPCs (like players) should occasionally stick with the same
// weapon even if a much better one is available (so the way in which this is
// implemented in Weapon doesn't make much sense).

simulated function Weapon RecommendWeapon( Actor Target, out float Rating, out byte bUseAltMode )
{
	local Weapon RecommendedWeapon;
	local Weapon OtherRecommendedWeapon;
	local float OtherRating;
	local byte bOtherUseAltMode;

	bUseAltMode = 0;
	if( PlayerController(Instigator.Controller)? )
	{
		// player's configuration determines rating
		Rating = SwitchPriority();
	}
	else
	{
		// weapon rates itself
		Rating = RateSelf( Target, bUseAltMode );

		// !!mdf-tbr:
		// engine code -- if this weapon is current one and the pawn has a target and the weapon has ammo
		// boost its rating somewhat so it will tend to be kept -- this seems like a bad way to do this
		/*
		if( (Self == Instigator.Weapon) && Target != None &&
			((AmmoType == None) || (AmmoType.AmmoAmount > 0)) )
				Rating += 0.21; // tend to stick with same weapon
		*/
	}

	RecommendedWeapon = Self;
	if( Inventory? )
	{
		// get recommended weapon in rest of inventory chain
		OtherRecommendedWeapon = Inventory.RecommendWeapon( Target, OtherRating, bOtherUseAltMode );
		if( OtherRecommendedWeapon? && OtherRating > Rating )
		{
			// some other weapon rated higher
			RecommendedWeapon = OtherRecommendedWeapon;
			Rating = OtherRating;
			bUseAltMode = bOtherUseAltMode;
		}
	}

	return RecommendedWeapon;
}

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

simulated function LicenseePawn.EWeaponAnimationType GetWeaponAnimationType()
{
	return WeaponAnimationType;
}

// CDH... weapon state notification to pawn
// TEMPORARY ARPROACH, this should switch to a general purpose call to the
// to the pawn and/or animation controller, and let them deal with the specifics.
simulated function PawnAgentEvent(name InEventName)
{
	local vector Dummy;
	
	if( InEventName == 'Ambient' && LicenseePawn(Owner)? )
	{
		if (LicenseePawn(Owner).GetAlert() || Owner.IsRealPlayer())
			InEventName = 'AmbientAlert';
		else if (Instigator != None && Instigator.Controller != None && Instigator.Controller.GetAimingLocation( Dummy ))
			InEventName = 'Ambient';
		else
			InEventName = 'AmbientLowered';
	}
	if (Pawn(Owner)?)
	{
		Pawn(Owner).MeshAgentSetInputCurValue('WeaponState', InEventName);
		Pawn(Owner).MeshAgentSetInputCurValue('WeaponID', StringToName(ItemID));
	}
}
// ...CDH

/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
//Pickup

function Refresh()
{
	local U2NPCController NPC;
	local int i;

	NPC = U2NPCController(Instigator.Controller);
	if( NPC? )
	{
		bFireEnabledForOwner = NPC.SupportsWeaponFire( Self );
		bAltFireEnabledForOwner = NPC.SupportsWeaponAltFire( Self );
	}
	else
	{
		bFireEnabledForOwner = true;
		bAltFireEnabledForOwner = true;
	}

	//the decos could have retained bad memory, so make sure we reset them
	for(i=0;i<DecoEffects.length;i++)
		DestructDeco(i);
}


function GiveTo( Pawn Other, optional bool bDontTryToSwitch )
{
	local Controller C;

	////////////
	//!!mdf-tbd: 
	// Idiot check for owner already having the weapon or a super-class of the
	// weapon -- this totally borks using either weapon?
	local Inventory Inv;
	
	for( Inv=Other.Inventory; Inv!=None; Inv=Inv.Inventory )
	{
		if( Inv.IsA( Class.Name ) || ClassIsChildOf( Class, Inv.Class ) )
			DMT( "Warning (ASSERT): tried to give " $ Self $ " to " $ Other $ " where " $ Other $ " already has a " $ Inv $ "!" );
	}
	//!!mdf-tbd:
	///////////
	
	super.GiveTo( Other, bDontTryToSwitch );
	U2PCOwner = U2PlayerController(Instigator.Controller);
	FireAdjust = 1.0;
	

	Refresh();

	if( Level.Game.bTeamGame || Level.Game.NumBots > 4 )
		return;

	//MWP (mdf) -- probably don't want to do this in singleplayer (NPCs hearing player
	//pick up stuff makes sense for multiplayer but not for singleplayer and adds overhead).
	//NOTE: NumBots isn't affected by # NPCs in a level afaik -- a possible approach
	//which would fix similar code might be to generalize this.
	// let high skill bots hear pickup if close enough
	for( C = Level.ControllerList; C?; C = C.NextController )
	{
		if( AIController(C)? && C.Pawn? && VSize( C.Pawn.Location - Pawn(Owner).Location ) < 1000 )
		{
			AIController(C).HearPickup( Pawn(Owner) );
			return;
		}
	}
}


function bool HandlePickupQuery( Pickup Item )
{
	local int OldAmmo, NewAmmo;
	local Pawn P;
	local bool bAmmo,bMoreAmmo;

	if( Item.InventoryType == Class )
	{
		if( WeaponPickup(Item).bWeaponStay && ( !Item.Inventory || Item.Inventory.bTossedOut ) )
		{
			U2Ammo(AmmoType).AddMinAmmo( Weapon(Item.Inventory).PickupAmmoCount ); //NEW
			return true;
		}
		P = Pawn(Owner);
		if( AmmoType? )
		{
			OldAmmo = AmmoType.AmmoAmount;
			if( Item.Inventory? )
				NewAmmo = Weapon(Item.Inventory).PickupAmmoCount;
			else
				NewAmmo = class<Weapon>(Item.InventoryType).default.PickupAmmoCount;
			bAmmo = AmmoType.AddAmmo( default.PickupAmmoCount );
			bMoreAmmo = Item.MaybeAddMoreAmmo(Self,P);
			if( (bAmmo || bMoreAmmo) && OldAmmo == 0 && P.Weapon.Class != Item.Class ) //ARL && !P.bNeverSwitchOnPickup ) //NEW
			{
				ClientWeaponSet( true );
			}
		}
		Item.AnnouncePickup( Pawn(Owner) );
		return true;
	}

	if( !Inventory )
		return false;

	return Inventory.HandlePickupQuery(Item);
}

simulated function ClientWeaponSet(bool bOptionalSet)
{
	Super.ClientWeaponSet(bOptionalSet);
	U2PCOwner = U2PlayerController(Instigator.Controller);	
	if( U2PCOwner != None ) U2PCOwner.HighlightPendingWeapon( U2PCOwner.Pawn );
}

function bool ShouldSwitchWeapon( Weapon CurrentWeapon, bool bOptionalSet )
{
	local float CurrentSwitchPriority, PendingSwitchPriority;
	local bool bShouldSwitch;

	if( Instigator.IsHumanControlled() && U2GameInfo(Level.Game).bForcedWeaponSwitch && U2XMPItem(Self) == None )
	{
		bShouldSwitch = true;
	}
	else
	{
		PendingSwitchPriority = SwitchPriority();
		if( PendingSwitchPriority > RatingIneffective )
		{
			// pending weapon has at least some potential
			CurrentSwitchPriority = CurrentWeapon.SwitchPriority();
			if( PendingSwitchPriority > CurrentSwitchPriority ) 
			{
				// pending weapon is better than current one
				if( !bOptionalSet ||
					!AIController(Instigator.Controller) ||
					AIController(Instigator.Controller).AllowPickupWeaponSwitch( Self, CurrentSwitchPriority, PendingSwitchPriority ) )
				{
					bShouldSwitch = true;
				}
			}
		}
	}
	
	return bShouldSwitch;
}

/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
//Dropping

function DropFrom(vector StartLocation)
{
	//note: this function is only called on the server, so thet client doesn't see the unsetting of the crosshair
	//  so the ClearWeaponEffects() is also directly handled by PlayerController's ThrowWeapon, since
	//  there's no easy way to make it work nicely without just pasting code in there
	
	ClearWeaponEffects();

	PickupAmmoCount = U2Ammo(AmmoType).ClipRoundsRemaining;
	AmmoType.AmmoAmount -= U2Ammo(AmmoType).ClipRoundsRemaining;

	U2PCOwner = None;
	Super.DropFrom(StartLocation);
}

/*
simulated event Landed( vector HitNormal )
{
	local rotator newRot;

	newRot = Rotation;
	newRot.Pitch = 16384;
	SetRotation( newRot );
}
*/

simulated function SwitchAway()
{
	Instigator.Controller.SwitchToBestWeapon();
}

function GiveAmmo( Pawn Other )
{
	Super.GiveAmmo(Other);
	if (U2Ammo(AmmoType)?)
		U2Ammo(AmmoType).Reload();
}

simulated function int GetClipAmount()
{
	if( U2Ammo(AmmoType)? )
		return U2Ammo(AmmoType).ClipRoundsRemaining;
	else
		return 0;
}

simulated function int GetClipSize()
{
	if( U2Ammo(AmmoType)? )
		return U2Ammo(AmmoType).ClipSize;
	else
		return 0;
}

/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
//Reloading

//this is called to reload the gun, and can be called at any point in time
//it will correctly deal with reloading from the loaded and unloaded states
simulated function Reload()
{
	//mjl-tbd: ensure reloading works on third-person clients, so the sound can be heard
	if ( !IsInState('Reloading') && HasAmmo() && U2Ammo(AmmoType).CanReload() )
	{
		//Pawn(Owner).Controller.StopFiring();
		//Pawn(Owner).PlaySound( CockingSound, SLOT_Misc );
		if (!U2Ammo(AmmoType).ReloadRequired(1)) //if we are not completely out of ammo, then drop our current clip
		{
			//OutOfAmmo
		}

		//go to the state for the duration of the reload
		GotoState('Reloading');
	}
}

simulated state Reloading
{
ignores Fire,AltFire,Reload;

	function bool CanFire() { return false; }

	simulated event BeginState()
	{
	}
	simulated event EndState()
	{
	}

Begin:
	if( U2PCOwner? )
		class'UIConsole'.static.SendEvent("WeaponFlash");
	PawnAgentEvent('Reload');
	if( !bLastRound )
		PlayAnimEx('Reload');
	else
	{
		PlayAnimEx('ReloadUnloaded');
		if( default.ReloadUnloadedTime!=0.0 )
			ReloadTime=default.ReloadUnloadedTime;
	}
	Sleep(ReloadTime);
	ReloadTime=default.ReloadTime;
	bLastRound=false;
	U2Ammo(AmmoType).Reload();
	GotoState('Idle');
}


/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
//Fire/AltFire


simulated function NotifyPlaySoundSlot( string Slot )
{
	switch(Slot)
	{
	case "Fire":				if(!bAmbientFireSound)		Pawn(Owner).PlaySound(FireSound,SLOT_Weapon,,,,GetRand(FirePitch));				return;
	case "AltFire":				if(!bAmbientAltFireSound)	Pawn(Owner).PlaySound(AltFireSound,SLOT_Weapon,,,,GetRand(AltFirePitch));			return;
	case "FireEnd":				if(FireEndSound?)			Pawn(Owner).PlaySound(FireEndSound,SLOT_Weapon,,,,GetRand(FirePitch));			return;
	case "AltFireEnd":			if(AltFireEndSound?)		Pawn(Owner).PlaySound(AltFireEndSound,SLOT_Weapon,,,,GetRand(AltFirePitch));		return;
	case "FireLastRound":		if(FireLastRoundSound?)		Pawn(Owner).PlaySound(FireLastRoundSound,SLOT_Weapon,,,,GetRand(FirePitch));		return;
	case "AltFireLastRound":	if(AltFireLastRoundSound?)	Pawn(Owner).PlaySound(AltFireLastRoundSound,SLOT_Weapon,,,,GetRand(AltFirePitch));return;
	case "ReloadUnloaded":		if(ReloadUnloadedSound?)	Pawn(Owner).PlaySound(ReloadUnloadedSound,SLOT_Weapon,,,128);						return;
	case "Reload":											Pawn(Owner).PlaySound(CockingSound,SLOT_Weapon,,,128);							return;
//	case "Select":				PlaySound(SelectSound);		return;
	};
}

simulated function PlayFiring()
{
	bLastRound = U2Ammo(AmmoType)? && U2Ammo(AmmoType).ReloadRequired(1);

	if( !bLastRound )
	{
		PlayAnimEx('Fire');
		FireTime = default.FireTime;
	}
	else if( HasAmmo() )
	{
		PlayAnimEx('FireLastReload');
		FireTime = default.FireTime;
		ReloadTime = default.FireLastReloadTime - default.FireTime;
	}
	else
	{
		PlayAnimEx('FireLastDown');
		FireTime = default.FireLastDownTime - default.DownTime;
	}

	PawnAgentEvent('Fire');
}

simulated function PlayAltFiring()
{
	bLastRound = U2Ammo(AmmoType)? && U2Ammo(AmmoType).ReloadRequired(1);

	if( !bLastRound )
	{
		PlayAnimEx('AltFire');
		AltFireTime = default.AltFireTime;
	}
	else if( HasAmmo() )
	{
		PlayAnimEx('AltFireLastReload');
		AltFireTime = default.AltFireTime;
		ReloadTime = default.AltFireLastReloadTime - default.AltFireTime;
	}
	else
	{
		PlayAnimEx('AltFireLastDown');
		AltFireTime = default.AltFireLastDownTime - default.DownTime;
	}

	PawnAgentEvent('AltFire');
}

simulated state Firing
{
ignores Fire, AltFire;
	simulated function Reload(){}

	simulated event BeginState()
	{
		if (bAmbientFireSound) //if we are a rapid-fire weapon, then make our FireSound be the ambient sound
			AmbientSound = FireSound;
	}
	simulated event EndState()
	{
		bFiring = false;
		if (bAmbientFireSound)
			AmbientSound = default.AmbientSound;
	}

Begin:
	//incoming animation set by EverywhereFire(). We wait for it to finish

	Sleep(FireTime);

	if (bRepeatFire)
	{
		if ( Pawn(Owner).PressingFire() )
		{
			Global.Fire();
			//if it's going to fire, code execution will jump to the Begin label
			//if it's going to reload/changeweapon, code execution will jump to some other state
			//assert(false);	//whoops, apparently this assumption is invalid!!
		}
		//else, if we're done firing, and want to stop (which may be the case even if we're still holding fire -- like if you ran out of ammo)

		//maybe wind-down our weapon...
		PlayAnimEx('FireEnd');
	}

	if( U2Ammo(AmmoType)? && U2Ammo(AmmoType).ReloadRequired( GetFireAmmoUsed() ) )
	{
		if( HasAmmo() )
			Global.Reload();	// Global since Reload is locally disabled.
		else if( HasAnyAmmo() )
			ChangeAmmoType();
		else
			SwitchAway();
	}

	GotoState('Idle');
}

simulated state AltFiring
{
ignores Fire, AltFire;
	simulated function Reload(){}

	simulated event BeginState()
	{
		if (bAmbientAltFireSound) //if we are a rapid-fire weapon, then make our AltFireSound be the ambient sound
			AmbientSound = AltFireSound;
	}
	simulated event EndState()
	{
		bAltFiring = false;
		if (bAmbientAltFireSound)
			AmbientSound = default.AmbientSound;
	}
	
Begin:
	//incoming animation set by EverywhereAltFire(). We wait for it to finish

	Sleep(AltFireTime);

	if (bRepeatAltFire)
	{
		if ( Pawn(Owner).PressingAltFire() )
		{
			Global.AltFire();
			//if it's going to fire, code execution will jump to the Begin label
			//if it's going to reload/changeweapon, code execution will jump to some other state
			//assert(false);	//whoops, apparently this assumption is invalid!!
		}
		//else, if we're done firing, and want to stop (which may be the case even if we're still holding fire -- like if you ran out of ammo)

		//maybe wind-down our weapon...
		PlayAnimEx('AltFireEnd');
	}

	if( U2Ammo(AmmoType)? && U2Ammo(AmmoType).ReloadRequired( GetAltFireAmmoUsed() ) )
	{
		if( HasAmmo() )
			Global.Reload();	// Global since Reload is locally disabled.
		else if( HasAnyAmmo() )
			ChangeAmmoType();
		else
			SwitchAway();
	}

	GotoState('Idle');
}

simulated function Fire()
{
	//ensures that we can control who can fire and who cannot, based upon the function. bPlayerCanFire is now useful. :)
	if( !Pawn(Owner).PressingFire() )
		return;

	if( bDisableFiring )
		return;

	bFiring = true;
	bAltFiring = false;
	if( U2Ammo(AmmoType)? && !U2Ammo(AmmoType).ReloadRequired( GetFireAmmoUsed() ) )
	{
		// firing of the weapon can be aborted by the aiming code (e.g. due to obstacles)
 		if( PreSetAimingParameters( false, bInstantHit, TraceSpreadFire, ProjectileClass, bWarnTarget, bRecommendSplashDamage ) )
		{
			if (Role == ROLE_Authority)
				AuthorityFire();
			EverywhereFire();
		}
	}
	else if ( HasAmmo() )
		Reload();
	else if( HasAnyAmmo() )
		ChangeAmmoType();
	else
		SwitchAway();
}

simulated function AltFire()
{
	//ensures that we can control who can fire and who cannot, based upon the function. bCanAltFire is now useful. :)
	if( !Pawn(Owner).PressingAltFire() )
		return;

	if( bDisableFiring )
		return;

	bFiring = false;
	bAltFiring = true;
	if( U2Ammo(AmmoType)? && !U2Ammo(AmmoType).ReloadRequired( GetAltFireAmmoUsed() ) )
	{
		// firing of the weapon can be aborted by the aiming code (e.g. due to obstacles)		
		if( PreSetAimingParameters( true, bAltInstantHit, TraceSpreadAltFire, AltProjectileClass, bAltWarnTarget, bRecommendAltSplashDamage ) )
		{
			if (Role == ROLE_Authority)
				AuthorityAltFire();
			EverywhereAltFire();
		}
	}
	else if ( HasAmmo() )
		Reload();
	else if( HasAnyAmmo() )
		ChangeAmmoType();
	else
		SwitchAway();
}

function AuthorityFire()
{
	if( !IsInState('Firing') )
		U2Pawn(Owner).CurrentStatus.NumFires = (U2Pawn(Owner).CurrentStatus.NumFires+1) % 4;

	//guaranteed by ReloadRequired in Fire
	//NOTE (mdf): AmmoType can be None for some weapons (e.g. Takkra)?
	if( AmmoType? )
		AmmoType.UseAmmo( GetFireAmmoUsed() );

	bPointing = true;
/* SERVOTBD
	if( bRapidFire || FiringSpeed > 0 )
		Pawn(Owner).PlayRecoil( FiringSpeed );
*/
	// does nothing for most weapons unless shot fired when owner stops firing
	PostSetAimingParameters( false, bInstantHit, TraceSpreadFire, ProjectileClass, bWarnTarget, bRecommendSplashDamage );
	
	if( bInstantHit )
	{
		TraceFire( TraceSpreadFire );
	}
	else if( ProjectileClass? )
	{
		ProjectileFire( ProjectileClass );
	}
}

function AuthorityAltFire()
{
	if( !IsInState('AltFiring') )
		U2Pawn(Owner).CurrentStatus.NumAltFires = (U2Pawn(Owner).CurrentStatus.NumAltFires+1) % 4;

	//guaranteed by ReloadRequired in Fire
	//NOTE (mdf): AmmoType can be None for some weapons (e.g. Takkra)?
	if( AmmoType? )
		AmmoType.UseAmmo( GetAltFireAmmoUsed() );

	bPointing = true;
/* SERVOTBD
	if( bRapidAltFire || FiringSpeed > 0 )
		Pawn(Owner).PlayRecoil( FiringSpeed );
*/
	// does nothing for most weapons unless shot fired when owner stops firing
	PostSetAimingParameters( true, bAltInstantHit, TraceSpreadAltFire, AltProjectileClass, bAltWarnTarget, bRecommendAltSplashDamage );
	
	if( bAltInstantHit )
	{
		TraceFire( TraceSpreadAltFire );
	}
	else if( AltProjectileClass? )
	{
		ProjectileFire( AltProjectileClass );
	}
}

simulated function EverywhereFire()
{
	local PlayerController P;
	
	GotoState( 'Firing' );

	if( Level.NetMode != NM_DedicatedServer )
	{
		SetFireSkin();

		if( ShellClass? )
			EjectShell( ShellClass );

		if( Pawn(Owner)? )
			P = PlayerController(Pawn(Owner).Controller);
		if( P? )
		{
			if( InstFlash != 0.0 )
				P.ClientInstantFlash( InstFlash, InstFog );
			if( ShakeMag>0 && ShakeTime>0 )
				P.ShakeView( ShakeMag, ShakeTime );
		}
	}
	if( Affector? )
		Affector.FireEffect();
	PlayFiring();
}

simulated function EverywhereAltFire()
{
	local PlayerController P;
	GotoState( 'AltFiring' );

	if( Level.NetMode != NM_DedicatedServer )
	{
		SetFireSkin();

		if( AltShellClass? )
			EjectShell( AltShellClass );

		if ( Pawn(Owner)? )
			P = PlayerController(Pawn(Owner).Controller);
		if( P? )
		{
			if( InstFlash != 0.0 )
				P.ClientInstantFlash( InstFlash, InstFog );
			if( ShakeMag>0 && ShakeTime>0 )
				P.ShakeView( AltShakeMag, AltShakeTime );
		}
	}
	if( Affector? )
		Affector.FireEffect();
	PlayAltFiring();
}

simulated function int GetFireAmmoUsed() { return 1; }
simulated function int GetAltFireAmmoUsed() { return 1; }

/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
//Actual Projectile/Trace Fires

simulated function vector CalcDrawOffset()
{
	local vector WeaponKickOffset; //ARL collapse WeaponKickOffset into U2Pawn.CalcDrawOffset

	if( U2PlayerController(Pawn(Owner).Controller)? )
	{
		WeaponKickOffset = U2PlayerController(Pawn(Owner).Controller).WeaponKickOffset;
	}

	return Pawn(Owner).CalcDrawOffset( Self ) + WeaponKickOffset;
}


simulated function vector CalcFireOffset( vector X, vector Y, vector Z )
{
	local vector DrawOffset;

	DrawOffset.Z = Pawn(Owner).BaseEyeHeight;

	return DrawOffset + FireOffset.X * X + FireOffset.Y * Y + FireOffset.Z * Z;
}


simulated function vector CalcShellOffset( vector X, vector Y, vector Z )
{
	local vector DrawOffset;

	DrawOffset.Z = Pawn(Owner).BaseEyeHeight;

	return DrawOffset + ShellOffset.X * X + ShellOffset.Y * Y + ShellOffset.Z * Z;
}


simulated function EjectShell( class<U2ShellCase> ShellClass )
{
	local vector X, Y, Z;
	local U2ShellCase S;

	GetAxes( Pawn(Owner).GetViewRotation(), X, Y, Z );
	S = Spawn( ShellClass, Pawn(Owner), '', Pawn(Owner).Location + CalcShellOffset( X, Y, Z ) );
	if( S? )
	{
		S.Eject( ( (FRand()*0.1+0.2)*X + (FRand()*0.2+0.4)*Y + (FRand()*0.2+0.4) * Z ) * 160 );
	}
}

function MeleeAttack()
{
	TraceFire( 0.0 );
}


function AdjustTraceFireHit( out CheckResult Hit );			// allow subclasses to modify TraceFire()


//-----------------------------------------------------------------------------
// Sets Trace/ProjectileFireStartLocations for next shot. NOTE: sets both since
// some weapons (e.g. LR) do both a trace and projectile fire.

function SetFireStartLocations()
{
	local bool bFirstPerson;
	
	bFirstPerson = ( U2PCOwner? && Viewport(U2PCOwner.Player)? && U2PCOwner.ViewingSelf() && !U2PCOwner.ThirdPerson() );
	
	// trace from weapon's fireoffset (relative to Pawn) for projectile weapons
	if( bFirstPerson )
	{
		// Fix ARL: Adjust for weapon bone attachments!!
		// trace from eyes for hitscan weapons (for players in 1st person only?)
		TraceFireStartLocation = Pawn(Owner).Location;
		TraceFireStartLocation.Z += Pawn(Owner).BaseEyeHeight;
		
		ProjectileFireStartLocation = class'UtilGame'.static.GetRotatedFireStart( Pawn(Owner), Owner.Location, Pawn(Owner).GetViewRotation(), FireOffset + FirstPersonOffset );
	}
	else
	{
		ProjectileFireStartLocation = class'UtilGame'.static.GetRotatedFireStart( Pawn(Owner), Owner.Location, Pawn(Owner).GetViewRotation(), FireOffset );
		TraceFireStartLocation = ProjectileFireStartLocation;
	}
}


function TraceFire( float TraceSpread )
{
	local vector End, SpreadVector;
	local CheckResult Hit;
	local Material.CheckResult MaterialHit;
	local float TraceDamage;

	Pawn(Owner).MakeNoise( Pawn(Owner).SoundDampening );

	AdjustedAim = Pawn(Owner).GetAimRotation();
	SpreadVector = vector(AdjustedAim + rotator(class'Util'.static.RandomSpreadVector( TraceSpread )));
	End = TraceFireStartLocation + TraceRange * SpreadVector;

	SingleLineCheck( Hit, Pawn(Owner), End, TraceFireStartLocation, TRACE_ProjTargets ); //ARL don't use TRACE_AllEverything, or triggers will be hit

	MaterialHit.Next = Hit.Next;
	MaterialHit.Actor = Hit.Actor;
	MaterialHit.Location = Hit.Location;
	MaterialHit.Normal = Hit.Normal;
	MaterialHit.Primitive = Hit.Primitive;
	MaterialHit.Time = Hit.Time;
	MaterialHit.Item = Hit.Item;
	MaterialHit.Material = Hit.Material;

	DispatchWeaponNotifies( Hit );

/*
	if( Owner.IsRealPlayer() )
		AddArrow( TraceFireStartLocation, End, ColorBlue() );
	else
		AddArrow( TraceFireStartLocation, End, ColorGreen() );
*/

// Fix ARL: FindWaterSurface no longer exists.  Improve water-hit handling -- replace with TRACE_Zone in SingleLineCheck()?
/*
	FindWaterSurface( SurfaceLocation, TraceFireStartLocation + ( 32 * vector( AdjustedAim ) ), HitLocation );
	if( Pawn(Owner).PhysicsVolume.bWaterVolume )
	{
		HandleWaterShot( HitLocation, TraceFireStartLocation, SurfaceLocation );
	}
	if( SurfaceLocation != vect(0,0,0) )
	{
		Spawn( class'U2Splash',,, SurfaceLocation, -1 * rotator( HitLocation - TraceFireStartLocation ) );

		HandleWaterShot( HitLocation, SurfaceLocation, HitLocation );

		if( ( Level.TimeSeconds - LastWaterRingTime ) > 0.35 )
		{
			Ring = Spawn( class'U2WaterRing', , , SurfaceLocation, rot(16384,0,0) );
			Ring.SetDrawScale(0.25);
			LastWaterRingTime = Level.TimeSeconds;
		}
	}
*/

	if( Hit.Actor? )
	{
		assert( Role == ROLE_Authority );

		if( bFiring )
			TraceDamage = Damage;
		else if( bAltFiring )
			TraceDamage = AltDamage;
		else
			warn("TraceFire called without bFiring or bAltFiring set!");

		ProcessTraceHitEx( SpreadVector, Hit, TraceDamage );
//NEW
		if( ImpactHandlerClass? ) //!!ARL (mdf) causing warnings for LR primary fire?
			ImpactHandlerClass.static.TraceImpact( self, MaterialHit );		//HACK: FCheckResult apparently doesn't "replicate" properly... even in StandAlone mode.  WTF?!?
		ClientTraceImpact( Hit );
/*OLD: ClientTraceImpact will need to be updated to properly account for new Hit.Material var, etc.
		ClientTraceImpact( Hit.Location + Hit.Normal, rotator(Hit.Normal), class'Material'.static.GetHitTextureType( MaterialHit ) );
//DM( Self$".ClientTraceImpact() SERVER "$Self@vector(Pawn(Owner).ViewRotation)@Hit.Actor@Hit.Item@Hit.Location+Hit.Normal@Hit.Normal );
*/
	}
	else TraceFireFailed( End );
}

function TraceFireFailed( vector EndPoint );

function DispatchWeaponNotifies( out CheckResult Hit )
{
	local array<Actor> NotifyProjectiles;
	local int i;

	NotifyProjectiles = Level.GetList('TraceFireNotify');
	for(i=0;i<NotifyProjectiles.length;i++)
		U2Projectile(NotifyProjectiles[i]).AdjustTraceFireHit(Hit);
}

function ProcessTraceHitEx( vector HitDirection, CheckResult Hit, float EffectiveDamage )
{
	Hit.Actor.TakeDamage( EffectiveDamage, Pawn(Owner), Hit.Location, MomentumTransfer * HitDirection, MyDamageType );
}

//mjl-tbd: optimize this function ... pass the impacteffect class directly instead of ints and vectors and rotators?
//NEW
simulated function ClientTraceImpact( CheckResult Hit )
{
	//ImpactHandlerClass.static.TraceImpact( self, Hit );
}
/*OLD
simulated function ClientTraceImpact( vector HitLocation, rotator HitNormal, Material.ETextureType MaterialType )
{
	local CheckResult Hit;
	Hit.Location = HitLocation;
	Hit.Normal = vector(HitNormal);
//DM( Self$".ClientTraceImpact() CLIENT "$Self@vector(Pawn(Owner).GetViewRotation())@Hit.Actor@Hit.Item@Hit.Location@Hit.Normal );
	ImpactHandlerClass.static.TraceImpact( self, Hit, MaterialType );
}
*/

function Projectile ProjectileFire( class<projectile> ProjClass )
{
	local Projectile SpawnedProjectile;
	
	Pawn(Owner).MakeNoise( Pawn(Owner).SoundDampening );

	AdjustedAim = Pawn(Owner).GetAimRotation();
	SpawnedProjectile = Spawn( ProjClass, Self, , ProjectileFireStartLocation, AdjustedAim ); // NOTE (mdf): can fail, e.g. if Pawn too close to geometry
	
	return SpawnedProjectile;
	
	/* debug stuff
	local Projectile SpawnedProjectile;

	DM( "ProjectileFire: " $ Pawn(Owner) );
	DM( "  GetViewRotation: " $ Pawn(Owner).GetViewRotation().Yaw $ " " $ Pawn(Owner).GetViewRotation().Pitch $ " " $ Pawn(Owner).GetViewRotation().Roll );

	SpawnedProjectile = Spawn( ProjClass, Self,, ProjectileFireStartLocation, AdjustedAim );

	AddArrow( Owner.Location, Owner.Location + 128.0*vector(Pawn(Owner).GetViewRotation()), ColorMagenta() );
	AddActor( Owner, ColorCyan() );
	AddArrow( Owner.Location, ProjectileFireStartLocation, ColorRed() );
	AddArrow( ProjectileFireStartLocation, ProjectileFireStartLocation + vector(AdjustedAim)*128.0, ColorGreen() );

	// bots were aiming into the ground because of borked EyeHeight
	if( SpawnedProjectile == None )
	{
		DMTNS( "ProjectileFire failed to spawn a " $ ProjClass $ " at " $ ProjectileFireStartLocation $ " rotation: " $ AdjustedAim );
	}

	return SpawnedProjectile;
	*/
}



/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
//Idle

simulated state Idle // override Weapon.Idle.Begin
{
	simulated event AnimEnd( int Channel )
	{
	}
	
	simulated function bool PutDown()
	{
		if (Global.PutDown())
		{
			GotoState('DownWeapon');
			return true;
		}
		return false;
	}

Begin:
	if( Pawn(Owner)? )
	{
		PawnAgentEvent('Ambient');
		if (Pawn(Owner).PressingFire() && bRepeatFire)
			Fire();
		else if (Pawn(Owner).PressingAltFire() && bRepeatAltFire)
			AltFire();
		else if ( bChangeWeapon )
			GotoState('DownWeapon');
	}
	bPointing = false;
}


/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
//Select/PutDown

simulated function float SwitchPriority() 
{
	local byte bTempUseAltMode;
	local float Priority;

	if( !Pawn(Owner).IsHumanControlled() && Pawn(Owner).Health > 0 )
	{
		Priority = RateSelf( Instigator.Controller.ControllerEnemy, bTempUseAltMode );
	}
	else if ( !HasAnyAmmo() )
	{
		if( Pawn(Owner).Weapon == self )
			Priority = -0.5;
		else
			Priority = -1;
	}
	else
	{
		Priority = AutoSwitchPriority;
	}

	return Priority;
}

//
// Change weapon to that specificed by F matching inventory weapon's Inventory Group.
simulated function Weapon WeaponChange( byte F, Weapon aChoice )
{
	local U2Weapon CurrentChoice;
	local U2Weapon CurrentWeapon;

	CurrentChoice = U2Weapon(aChoice);
	CurrentWeapon = U2Weapon(Pawn(Owner).PendingWeapon);	// allow fast cycling

	if( CurrentWeapon == None )
		CurrentWeapon = U2Weapon(Pawn(Owner).Weapon);

	if ( HasAnyAmmo() || SnipingWeapon() )
	{
		if( InventoryGroup == F )
		{
			// no current choice, we're the best so far.
			if( !CurrentChoice && Self != CurrentWeapon )
				CurrentChoice = Self;

			// if current weapon isn't in this group, pick one with lowest position in group
			else if( !CurrentWeapon || CurrentWeapon.InventoryGroup != F )
			{
				if( /*Self.*/LessThan(CurrentChoice))
					CurrentChoice = Self;
			}
			// current weapon is in current group, pick next weapon after it
			else if ( !CurrentChoice || CurrentChoice.LessThan(CurrentWeapon) )
			{
				if ( /*Self.*/LessThan(CurrentChoice) ||				// Self		Choice	Weapon
					 /*Self.*/GreaterThan(CurrentWeapon) )				// Choice	Weapon	Self
					CurrentChoice = Self;
			}

			else if ( CurrentWeapon.LessThan(Self) &&					// Weapon	Self	Choice
					  /*Self.*/LessThan(CurrentChoice) )
				CurrentChoice = Self;
		}
	}

	if( Inventory? )
		return Inventory.WeaponChange( F, CurrentChoice );
	else
		return CurrentChoice;
}


// Compare our group and position within the group to another weapon
simulated function bool LessThan( Weapon Other )
{
	if( Other == None ) //!!ARL (mdf) this is happening when switching from DP to an XMP item for example
		return false;

	if( InventoryGroup < Other.InventoryGroup )
		return true;
	else if( InventoryGroup == Other.InventoryGroup )
	{
		if( GroupOffset < Other.GroupOffset )
			return true;
		// weapons with same tray/priority sort alphabetically
		// tbd - might not be the same as comparing their strings but should be consistent
		else if( GroupOffset == Other.GroupOffset )
			if( ItemName < Other.ItemName )
				return true;
	}
	return false;
}

simulated function bool GreaterThan( Weapon Other )
{
	if ( InventoryGroup > Other.InventoryGroup )
		return true;
	else if ( InventoryGroup == Other.InventoryGroup )
	{
		if( GroupOffset > Other.GroupOffset )
			return true;
		// weapons with same tray/priority sort alphabetically
		// tbd - might not be the same as comparing their strings but should be consistent
		else if( GroupOffset == Other.GroupOffset )
			if( ItemName > Other.ItemName )
				return true;
	}
	return false;
}

// Find the previous weapon (using the Inventory group and the position within the group (GroupOffset)
simulated function Weapon PrevWeapon(Weapon aChoice, Weapon aWeapon)
{
	local U2Weapon CurrentChoice;
	local U2Weapon CurrentWeapon;

	CurrentChoice = U2Weapon(aChoice);
	CurrentWeapon = U2Weapon(aWeapon);

	if ( HasAnyAmmo() || SnipingWeapon() )
	{
		if ( !CurrentChoice )
		{
			if ( CurrentWeapon != self )
				CurrentChoice = self;
		}
		else if ( /*Self.*/LessThan(CurrentWeapon) )
		{
			if ( CurrentChoice.LessThan(Self) ||					// Choice	Self	Weapon	
				 CurrentChoice.GreaterThan(CurrentWeapon) )			// Self		Weapon	Choice
				CurrentChoice = self;
		}
		else if ( CurrentWeapon.LessThan(CurrentChoice) &&			// Weapon	Choice	Self
				  CurrentChoice.LessThan(Self) )
			CurrentChoice = self;
	}
	if ( !Inventory )
		return CurrentChoice;
	else
		return Inventory.PrevWeapon(CurrentChoice,CurrentWeapon);
}

// Find the next weapon (using the Inventory group and the position within the group (GroupOffset)
simulated function Weapon NextWeapon(Weapon aChoice, Weapon aWeapon)
{
	local U2Weapon CurrentChoice;
	local U2Weapon CurrentWeapon;

	CurrentChoice = U2Weapon(aChoice);
	CurrentWeapon = U2Weapon(aWeapon);

	if ( HasAnyAmmo() || SnipingWeapon() )
	{
		if ( !CurrentChoice )
		{
			if ( CurrentWeapon != self )
				CurrentChoice = self;
		}
		else if ( CurrentChoice.LessThan(CurrentWeapon) )
		{
			if ( /*Self.*/LessThan(CurrentChoice) ||					// Self		Choice	Weapon
				 /*Self.*/GreaterThan(CurrentWeapon) )					// Choice	Weapon	Self
				CurrentChoice = self;
		}
		else if ( CurrentWeapon.LessThan(Self) &&					// Weapon	Self	Choice
				  /*Self.*/LessThan(CurrentChoice) )
			CurrentChoice = self;
	}
	if ( !Inventory )
		return CurrentChoice;
	else
		return Inventory.NextWeapon(CurrentChoice,CurrentWeapon);
}



simulated state DownWeapon
{
ignores Fire, AltFire;
	function bool CanFire() { return false; }
	simulated function bool PutDown() { return true; }	//just keep putting it down

	simulated event BeginState()
	{
		bChangeWeapon = false;
		ClearWeaponEffects();
		U2PCOwner = U2PlayerController(Instigator.Controller);
	}
	simulated event EndState()
	{}
	simulated event AnimEnd( int Channel )
	{}
	
Begin:
	PawnAgentEvent('Deactivate');
	if( !bLastRound )
		PlayAnimEx('DownAnim');
	MeshAgentSetInputCurValueEx('Active','False');
	Sleep(DownTime);
	Pawn(Owner).ChangedWeapon();
	GotoState('');
}


//to get rid of the cruft from the Active state...

simulated state Active
{
ignores Fire, AltFire;
	
	simulated function bool PutDown()
	{
		if ( bWeaponUp || (AnimFrame < 0.75) )
			GotoState('DownWeapon');
		else
			bChangeWeapon = true;
		return True;
	}
	
	simulated event AnimEnd( int Channel )
	{
	}
	simulated event EndState()
	{
	}
	simulated event BeginState()
	{
	}

Begin:
	MaybePixieReload();
	Sleep(SelectTime);
	if( bChangeWeapon )
		GotoState('DownWeapon');
	bWeaponUp = true;

	// this should never happen since you cannot select weapons with no ammo, and if you had ammo, then it got pixie loaded.
	// (but... the sniper rifle can be selected without ammo, and you might pick up ammo while bringing it up -- in which case we might as well auto-reload still)
	if( HasAmmo() && U2Ammo(AmmoType)? && U2Ammo(AmmoType).ReloadRequired( GetFireAmmoUsed() ) && U2Ammo(AmmoType).ReloadRequired( GetAltFireAmmoUsed() ))
		Reload();

	//if none of the above checks worked, then go idle
	GotoState('Idle');
}

// We no longer have Unloaded anim support, so just magically reload weapons on selection if you picked up some since you ran out.
function MaybePixieReload()
{
	if( HasAmmo() && U2Ammo(AmmoType)? && U2Ammo(AmmoType).ReloadRequired(GetFireAmmoUsed()) && U2Ammo(AmmoType).ReloadRequired(GetAltFireAmmoUsed()) )
		U2Ammo(AmmoType).Reload();
}

simulated function PlaySelect()
{
	bForceFire = false;
	bForceAltFire = false;
	PawnAgentEvent('Activate');
	PlayAnimEx('SelectAnim');
	MeshAgentSetInputCurValueEx('Active','True');

//DMT( Owner @ Pawn(Owner).Controller @ self @ "WEAPON SELECT SOUND" );
	if( Pawn(Owner).IsHumanControlled() )
		Owner.PlayOwnedSound( SelectSound, SLOT_Misc, 1.0 );
}

simulated function PlayPostSelect()
{}


/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
//Special Effects

function HandleWaterShot( vector HitLocation, vector Start, vector End )
{
/*!!arl -- Mike's BubbleSpawner lacks the "Start" property that Jess's U2BubbleSpawner had... replace both with a ParticleGenerator?
	local BubbleSpawner BubbleTrailer;

	BubbleTrailer = Spawn( class'BubbleSpawner', , , Start, rotator( HitLocation - Start ) );
	BubbleTrailer.Start = Start;
	BubbleTrailer.End = End;
	BubbleTrailer.Bubbles();
*/
}


/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
//Decorative Effects


simulated event PostBeginPlay()
{
	FirstPersonMesh = Mesh;
	Super.PostBeginPlay();
}

simulated event Destroyed()
{
	local int i;

	for (i=0;i<DecoEffects.Length;i++)
		DestructDeco( i );

	ClearWeaponEffects();
//	if( ImpactHandlerClass != None )
//		ImpactHandlerClass.static.Cleanup( self );
	Super.Destroyed();
}

simulated function DestructDeco( int i )
{
	local ParticleGenerator P;

	if( !DecoEffects[i].Effect )
		return;

	P = ParticleGenerator(DecoEffects[i].Effect);

	if (P?)
	{
		P.bManualTick = false;
		P.ParticleDestroy();
	}
	else if (DecoEffects[i].Effect?)
		DecoEffects[i].Effect.Destroy();

	DecoEffects[i].Effect = None;
}

simulated function ConstructDeco( int i )
{
	local ParticleGenerator P;
	//local mesh FirstPersonMesh;

	if( Level.NetMode == NM_DedicatedServer && !DecoEffects[i].GameplayRelevant )
		return;
/*
	if (MeshGetNodeNamed(DecoEffects[i].MountNode)==0)
		warn("Firstperson attachment node not found! : "$Mesh$"."$DecoEffects[i].MountNode);

	FirstPersonMesh = Mesh;
	Mesh = ThirdPersonMesh;
	if (MeshGetNodeNamed(DecoEffects[i].MountNode)==0)
		warn("Thirdperson attachment node not found! : "$Mesh$"."$DecoEffects[i].MountNode);
	Mesh = FirstPersonMesh;
*/
	if (DecoEffects[i].Particles?)
	{
		P = class'ParticleGenerator'.static.CreateNew( self, DecoEffects[i].Particles );
		DecoEffects[i].Effect = P;
		P.bManualTick = true;
		//mjl-tbd: handle double-particle-systems if we decide it's needed...
	}
	else
	{
		DecoEffects[i].Effect = Spawn( DecoEffects[i].DecoClass );
	}

	if (DecoEffects[i].Effect?)
	{
//		DecoEffects[i].Effect.MountParentActor	= self;
		DecoEffects[i].Effect.MountParentTag	= Tag;
		DecoEffects[i].Effect.MountParentNode	= DecoEffects[i].MountNode;
		DecoEffects[i].Effect.MountOrgLocation	= DecoEffects[i].MountOffset;
		DecoEffects[i].Effect.MountOrgRotation	= DecoEffects[i].MountRot;
		DecoEffects[i].Effect.MountOldLocation	= DecoEffects[i].Effect.Location;
		DecoEffects[i].Effect.MountOldRotation	= DecoEffects[i].Effect.Rotation;
		DecoEffects[i].Effect.Instigator = Pawn(Owner);
		DecoEffects[i].Effect.bRenderLater = true;
		DecoEffects[i].Effect.bRequiresWorldZBuffer = DecoEffects[i].bRequiresWorldZBuffer;
	}
}

// Fix ARL: Also call UnTrigger when finished to support TriggerControl effects.
simulated function PlayAnimEx( name Sequence )
{
	local int i;

	LastTriggeredAnim = Sequence;
	switch(LastTriggeredAnim)
	{
	case 'FireLastDown':		LastTriggeredAnim='Fire';		break;
	case 'FireLastReload':		LastTriggeredAnim='Fire';		break;
	case 'AltFireLastDown':		LastTriggeredAnim='AltFire';	break;
	case 'AltFireLastReload':	LastTriggeredAnim='AltFire';	break;
	}

	for (i=0;i<DecoEffects.Length;i++)
		if (DecoEffects[i].AnimSequence==LastTriggeredAnim)
		{
			if( !DecoEffects[i].Effect )
				ConstructDeco(i);
			if( DecoEffects[i].Effect? )
				DecoEffects[i].Effect.Trigger( self, Instigator );
		}

	//DMN("MeshAgentCallAction:"@Sequence@MeshAgentCallAction(Sequence));
	MeshAgentCallActionEx(Sequence);
}

simulated function MeshAgentCallActionEx( name Sequence )
{
	local mesh OldMesh;
	local bool bFirstPerson;
	bFirstPerson = U2PCOwner? && Viewport(U2PCOwner.Player)? && U2PCOwner.ViewingSelf() && !U2PCOwner.ThirdPerson();
	OldMesh = Mesh;
	if (!bFirstPerson)
		Mesh = ThirdPersonMesh;
	MeshAgentCallAction(Sequence);
	Mesh = OldMesh;
}

simulated function MeshAgentSetInputCurValueEx( name Input, name Value )
{
	local mesh OldMesh;
	local bool bFirstPerson;
	if( !Mesh )
		return;
	bFirstPerson = U2PCOwner? && Viewport(U2PCOwner.Player)? && U2PCOwner.ViewingSelf() && !U2PCOwner.ThirdPerson();
	OldMesh = Mesh;
	if (!bFirstPerson)
		Mesh = ThirdPersonMesh;
	MeshAgentSetInputCurValue(Input,Value);
	Mesh = OldMesh;
}

//make our skin show the flash of the shot
simulated function SetFireSkin()
{
	local bool bFirstPerson;

	if( FlashSkin? )
	{
		bFirstPerson = true;
		if( FlashSkinTP? )
			bFirstPerson = U2PCOwner? && Viewport(U2PCOwner.Player)? && U2PCOwner.ViewingSelf() && !U2PCOwner.ThirdPerson();
		if( bFirstPerson )
			MeshSetStaticMeshAttachmentSkinsAll(FlashSkin);
		else
			MeshSetStaticMeshAttachmentSkinsAll(FlashSkinTP);
	}

//	AmbientGlow = 40;	//does not look good on flamethrower: make this a per weapon variable?
	FireSkinTime = Level.TimeSeconds;
}

//note: this is copied into the native code instead of called for performance reasons (see AU2Weapon.cpp)
simulated function UnsetFireSkin()
{
	if( FlashSkin? )
		MeshSetStaticMeshAttachmentSkinsAll(None);

//	AmbientGlow = 0;
}

/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
//DecoEffects

/*
mjl-tbd: implement newer, better system for weapons drawing, as described below...
dependant upon the new renderer, so this is not currently possible
as bad as it sounds, this has been thoroughly discussed,
	so there are probably going to be 'issues' with any simpler implementation

issues:
particlesystems always need to be ticked
	particlesystems need to be ticked in the correct place,
		if their weapon is renderered (1st or 3rd)
	therefore, particlesystem ticks need to be done after render
	doing it in the old SpecialDraw was not good, 
		since then it required SpecialDraw to be called.
		and we had to make up for it with tick ticking,
			which got ugly very very quickly, due to the off-by-one errors

Tick		Render
allactors	allactors	portalfilter	renderactors
trigger() ^	AL	BL		AL	BL			AR	WR	BT	BR
  		  \---------------------------------/	 \==/
  												  |
  												  |
  												  foreach B list
  												  tick()
  												  if ShouldRender
  												  	render()
When ticking in the B list, it should use DeltaTime,
	so DeltaTime needs to be stored in the LevelInfo for global access

All B actors (particlesystems) are ticked each tick,
	using either the accurate render location,
	or the semi-accurate calculated location
All DecoEffects are put into the B list,
	render order hopefully doesn't matter for them

Weapon rendering could be moved to the very front of the list,
	necessary such that the z-buffer is not cleared before the 
	B-list is rendered, which needs occlusion

Two possibilities:
Weapon Rendering, Idea One:
	Turn off Z-reads
	Turn on Z-writes
	Each DecoEffect defines it's own Z-properties,
		since muzzle flashes should always be drawn
		and flame effects should not
Weapon Rendering, Idea Two:
	Move it to the PreRender
	Clear the Z-buffer
	Turn on the stencil buffer
	Turn on Z-writes and reads,
		since there it is not rendering sorted polygons
	Use the stencil to write '0' into the Z-buffer
	Now nothing can be drawn over the weapon
	So BSP walls, etc will be drawn underneath, as intended
	Each DecoEffect can optionally choose to do Z[stencil?]-reads or not
		useful for effects which need to be drawn over the weapon

Since I don't understand Idea One anymore, I'm going to suggest Idea Two. :)
*/

/* == NEW APPROACH = 01.09.2002 ==
make a bRequiresWorldZBuffer
should this all move to native code?

//UpdateWeaponPosition Timer
	* Sometimes tick A-List weapons.

//mjl-tbd:
//Not Actor-list Tick, as we need the PlayerCalcView information
	Tick 1st person weapon.

	A-List Render (includes all 3rd person weapons - includes ticking of weapons if visible)

//Generate B list during UnLevTic level tick
//ensure DecoEffects are not in the A-List. They are bHidden, so that works okay?
//SpecialDraw..if no viewport, draw all. if viewport, draw only if bRequiresWorldZBuffer

//tick all actors here
	B-List Tick (dependant upon weapon render/tick in A-List)
//render clipped ones here: if viewactor does not own this, draw it. if viewactor owns this, only if bRequiresWorldZBuffer
	B-List Render

//DrawWeapon
	Clear Z buffer
	Render 1st person weapon
//DrawDecos..only draw if !bRequiresWorldZBuffer
	Render DecoEffects

	B-List is all DecoEffects that need to interact with the world.
		for other weapons, ALL effects
		for our weapon, just world-interacting effects
	A-List is everything else except first person weapon and remaining DecoEffects.

*/

/*ARL(moved to C++ | way too slow)
simulated event Tick( float DeltaSeconds )
{
	local bool bFullUpdate;	//optimization
	local bool bFirstPerson;

	//!!mdf-tmp: disable weapon overhead temporarily
	if( bDisableTick )
		return;

	//Super.Tick(DeltaSeconds);
	if( Level.TimeSeconds - FireSkinTime > 0.2 )
		UnsetFireSkin();
	
	if( !Owner || !Owner.bStasis )
	{
//		HideFirstPersonEffects();
//		UpdateEffectsFOV();
		HideFirstPersonEffects_and_UpdateEffectsFOV();

		bFullUpdate = U2PCOwner? || (Owner? && Owner.DrawType == DT_Mesh && (Level.TimeSeconds - Owner.LastRenderTime) < 0.25) || (Level.TimeSeconds - LastFullUpdateTime) > 1.0;
//		bFullUpdate = true;
		if( bFullUpdate )
		{
			LastFullUpdateTime = Level.TimeSeconds;
			MoveWeapon();
		}

		MoveDecos(DeltaSeconds,bFullUpdate);
	}

	// Set correct mesh.
	bFirstPerson = U2PCOwner? && Viewport(U2PCOwner.Player)? && U2PCOwner.ViewingSelf() && !U2PCOwner.ThirdPerson();
	if (bFirstPerson)
		Mesh = FirstPersonMesh;
	else
		Mesh = ThirdPersonMesh;

}

simulated function HideFirstPersonEffects_and_UpdateEffectsFOV()
{
	local int i;
	local bool bFirstPerson;

	bFirstPerson = U2PCOwner? && Viewport(U2PCOwner.Player)? && U2PCOwner.ViewingSelf() && !U2PCOwner.ThirdPerson();

	for(i=0;i<DecoEffects.length;i++)
	{
		if( DecoEffects[i].Effect? )
		{
			DecoEffects[i].Effect.bHidden = bFirstPerson && !DecoEffects[i].Effect.bRequiresWorldZBuffer;

			if( bFirstPerson && !DecoEffects[i].bWorldFOV )
				DecoEffects[i].Effect.FOV=FOV;
			else
				DecoEffects[i].Effect.FOV=0;
		}
	}
}

simulated function HideFirstPersonEffects()
{
	local int i;
	local bool bFirstPerson;

	bFirstPerson = U2PCOwner? && Viewport(U2PCOwner.Player)? && U2PCOwner.ViewingSelf() && !U2PCOwner.ThirdPerson();

	for(i=0;i<DecoEffects.length;i++)
		if( DecoEffects[i].Effect? )
			DecoEffects[i].Effect.bHidden = bFirstPerson && !DecoEffects[i].Effect.bRequiresWorldZBuffer;
}

simulated function UpdateEffectsFOV()
{
	local int i;
	local bool bFirstPerson;

	bFirstPerson = U2PCOwner? && Viewport(U2PCOwner.Player)? && U2PCOwner.ViewingSelf() && !U2PCOwner.ThirdPerson();

	for(i=0;i<DecoEffects.length;i++)
	{
		if( DecoEffects[i].Effect? )
		{
			if( bFirstPerson && !DecoEffects[i].bWorldFOV )
				DecoEffects[i].Effect.FOV=FOV;
			else
				DecoEffects[i].Effect.FOV=0;
		}
	}
}

simulated function MoveWeapon()
{
	local vector NextLocation;
	local rotator NextRotation;

	local bool bFirstPerson;

	if(bLockLocation)
		return;

	// Fix ARL: If we don't have an Owner, why do we even exist?
	if( !Pawn(Owner) )
		return;

	bFirstPerson = U2PCOwner? && Viewport(U2PCOwner.Player)? && U2PCOwner.ViewingSelf() && !U2PCOwner.ThirdPerson();

	if( bFirstPerson )
	{
		NextLocation = Pawn(Owner).Location + Pawn(Owner).CalcDrawOffset(Self);
		NextRotation = Pawn(Owner).GetViewRotation();
		if( U2PCOwner.LeanOffset != vect(0,0,0) )
		{
			NextLocation += U2PCOwner.LeanOffset;
			NextRotation.Pitch -= VSize(U2PCOwner.LeanOffset)/48.0*8192;
		}

		SetRotation( NextRotation + RotationOffset );

		if( Location!=vect(0,0,0) )
			NextLocation += LocationOffset >> (Rotation - RotationOffset);
		SetLocation( NextLocation );
	}
	else
	{
		MountParentActor	= Owner;
		MountParentTag		= Owner.Tag;
		MountParentNode		= MeshGetNodeWeapon();
		MountOrgLocation	= vect(0,0,0);
		MountOrgRotation	= rot(0,0,0);
		MountOldLocation	= Location;
		MountOldRotation	= Rotation;
		
		// Fix ARL: Node isn't set yet?  Need to force this or something.
		if( MountParentNode=="" )
			MountParentNode="handpointr02";

		UpdateMountPhysics();

		MountParentActor	= None;
	}
}

simulated function MoveDecos( float DeltaSeconds, bool bFullUpdate )
{
	local int i;
	local ParticleGenerator P;

	local float OldAnimFrame;

	local bool bFirstPerson;

	bFirstPerson = U2PCOwner? && Viewport(U2PCOwner.Player)? && U2PCOwner.ViewingSelf() && !U2PCOwner.ThirdPerson();

	// choose correct mesh for updating attachments.
	if( bFirstPerson )
		Mesh = FirstPersonMesh;
	else
		Mesh = ThirdPersonMesh;

	for(i=0;i<DecoEffects.length;i++)
	{
		if( DecoEffects[i].Effect? )
		{
			// update attachment location for all effects except those that are bTriggerUpdateOnly (only update those the first tick after the animation has been played).
			if( DecoEffects[i].bTriggerUpdateOnly )
			{
				if( LastTriggeredAnim==DecoEffects[i].AnimSequence )
				{
					OldAnimFrame = AnimFrame;
					AnimFrame = 0.0;
					DecoEffects[i].Effect.MountParentActor = self;
					DecoEffects[i].Effect.UpdateMountPhysics();
					DecoEffects[i].Effect.MountParentActor = none;
					AnimFrame = OldAnimFrame;
				}
			}
			else if( bFullUpdate )
			{
				DecoEffects[i].Effect.MountParentActor = self;
				DecoEffects[i].Effect.UpdateMountPhysics();
				DecoEffects[i].Effect.MountParentActor = none;
			}

			// Auto-aim for NPCs.
			if( bFullUpdate )
			{
				if( DecoEffects[i].AIAim>0 && !U2PCOwner && Pawn(Owner)? )
					DecoEffects[i].Effect.SetRotation( Pawn(Owner).AdjustAim( None, DecoEffects[i].AIAim, DecoEffects[i].Effect.Location, 0, true, false, false, false) );
			}

			// manually tick particle systems (after their location has been updated so particles get spawned at the correct location).
			P = ParticleGenerator(DecoEffects[i].Effect);
			if( P? )
				P.ManualTick( DeltaSeconds );
			//{
			//	// don't tick particlesystems full time if they aren't world z buffer (if they don't exist in the world). gives better visuals at high deltatimes
			//	if( !DecoEffects[i].bRequiresWorldZBuffer )
			//		//Fix ARL: Replace this with a 'PrimeTime' variable set either by the LD on the particlesystem, or in the DecoEffects, or as a constant, here
			//		P.ManualTick( FMin(0.02 + FRand()*0.02, DeltaSeconds) );
			//	else
			//		P.ManualTick( DeltaSeconds );
			//}
		}
	}

	LastTriggeredAnim = '';
}
*/

simulated event RenderOverlays( canvas Canvas )
{
	//log("RenderOverlays");
	if( !Pawn(Owner) )
		return;

	if( U2PCOwner? && U2PCOwner.ViewingSelf() && !U2PCOwner.ThirdPerson() )
	{
		if( U2PCOwner.HandlingCrosshair() )
		{
			if( (~Crosshair))	UnSetCrosshair();
		}
		else if( !IsInState( 'DownWeapon' ) ) //MJL push SetCrosshair() into PlayPostSelect() override
		{
			if(!(~Crosshair))	SetCrosshair();
			if( (~Crosshair))	UpdateCrosshair( Canvas );
		}

		// Zoomed in.
		if( U2PCOwner.DesiredFOV != U2PCOwner.DefaultFOV )
			return;

		// 3rd person.
		if( U2PCOwner.ViewTarget != Pawn(Owner) || U2PCOwner.bBehindView )
			return;

		// invisibility cheat
		if( Pawn(Owner).bHidden )
			return;

		DrawWeapon( Canvas );
		DrawDecos( Canvas );
	}
	else
	{
		if( (~Crosshair))	UnsetCrosshair();
	}
}

simulated function DrawWeapon( canvas Canvas )
{
	Canvas.DrawActor(self, false, true, ActorFOV);
}

simulated function DrawDecos( canvas Canvas )
{
	local int i;
	for(i=0;i<DecoEffects.length;i++)
		if( DecoEffects[i].Effect? && DecoEffects[i].Effect.bHidden )
			Canvas.DrawActor( DecoEffects[i].Effect, false, false, DecoEffects[i].Effect.ActorFOV );
}

/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
//Crosshair/HUD

//if we used to be owned by a pawn who had a viewport, and now we aren't...
//   then clear the weapon effects. This is the BEST way I can think of to do this
simulated function PostRecvOwner()
{
	Super.PostRecvOwner();
	if( !Pawn(Owner) )
	{
		ClearWeaponEffects();
		GotoState( '' );
	}
	if( Instigator? )
		U2PCOwner = U2PlayerController(Instigator.Controller);
}

simulated function ClearWeaponEffects()		// interface function -- override as necessary in weapon subclasses (may be called repeatedly)
{
	UnSetCrosshair();
}

simulated function UIConsole GetConsole()
{
	local UIConsole C;
	local PlayerController PC;

	PC = PlayerController(Instigator.Controller);
	if( PC? )
		C = UIConsole(PC.Player.Console);

	return C;
}

simulated function SetCrosshair()
{
	if( CrosshairName!="" )
	{
		Crosshair = class'UIConsole'.static.LoadComponent( CrosshairFilename, CrosshairName );
		class'UIConsole'.static.SetOwner( Crosshair, Self );
		class'UIConsole'.static.AddComponent(Crosshair);
	}
}

simulated function UnSetCrosshair()
{
	if( ~Crosshair )
		Crosshair = class'UIConsole'.static.DestroyComponent(Crosshair);
}

simulated function UpdateCrosshair( Canvas Canvas )
{
	if( bCrosshairGlows && GetConsole()? )
		HandleCrosshairGlow( Canvas );
}
simulated function HandleCrosshairGlow( Canvas Canvas )
{
	local Actor A;
	local vector ScreenLoc;
	local int i;
	local byte bHitTarget;
	local vector ViewLoc;
	local rotator ViewRot;
	local string Event;

	ViewLoc = Owner.Location;
	ViewLoc.Z += Pawn(Owner).BaseEyeHeight;
	ViewRot = Pawn(Owner).GetViewRotation();

	A = FindTraceTarget( ViewLoc, ViewRot );
	HandleTargetDetails( A, Canvas, ViewLoc, ViewRot );
	
	if( !bGlowing && A? && IsTargetable(A) )
	{
		bGlowing=true;
		if (U2PCOwner?)
			U2PCOwner.SendEvent("Glow");
/*OLD
		GlowingAttitude = GetAttitudeTo(A);
		if( GlowingAttitude == ATTITUDE_Enemy )		Event = "GlowEnemy";
		else										Event = "Glow";
//		!!!ARL (mdf) tbd show friends (as opposed to neutral)?
//		if( GlowingAttitude == ATTITUDE_Friend )	Event = "GlowFriend";
//		else										Event = "Glow";
		if( U2PCOwner? ) U2PCOwner.SendEvent(Event);
*/
	}
	else if( bGlowing && ( !A || !IsTargetable(A) ) )
	{
		bGlowing=false;
		if (U2PCOwner?)
			U2PCOwner.SendEvent("UnGlow");
/*OLD
		if( GlowingAttitude != ATTITUDE_Neutral )	Event = "UnGlowEnemy";
		else										Event = "UnGlow";
		if( U2PCOwner? ) U2PCOwner.SendEvent(Event);
*/
	}
}

simulated function Controller.EAttitude GetAttitudeTo( Actor A )
{
	local pawn OwnerPawn,TargetPawn;
	local controller TargetController;

	OwnerPawn = Pawn(Owner);
	TargetPawn = Pawn(A);
	if( !OwnerPawn || !TargetPawn || OwnerPawn.bHidden )
		return ATTITUDE_Neutral;

	TargetController = TargetPawn.Controller;
	if( !TargetController )
		return ATTITUDE_Neutral;

	return TargetController.GetAttitudeTo(OwnerPawn);
}

simulated function HandleTargetDetails( Actor A, Canvas Canvas, vector ViewLoc, rotator ViewRot );

function bool IsTargetable( Actor A )
{
	local int i;

	if( A==Owner )
		return false;
	if( A.bHidden )
		return false;
	if( A.Physics == PHYS_None ) // don't target carcasses & such?
		return false;
		
	for( i=0; i<TargetableTypes.Length; i++ )
		if( A.IsA( TargetableTypes[i] ) )
			return true;

	return false;
}

//------------------------------------------------------------------------------
// Returns the target that is in the player's FOV as defined by MaxAngleInDegrees
// that is also the closest to the center of view.
//------------------------------------------------------------------------------
// Loc:					Point of origin.
// ViewRot:				Direction of view.
// MaxAngleInDegrees:	Field of view.
//------------------------------------------------------------------------------
// REQUIRE: MaxAngleInDegrees < 90
//------------------------------------------------------------------------------
function Actor FindBestTarget( vector Loc, rotator ViewRot, float MaxAngleInDegrees )
{
	local float		BestRatio;		//best found ratio
	local Actor		BestTarget;		//best target discovered so far
	local vector	ViewVec;		//vector showing LOS Loc/ViewRot
	local Actor		IterA;			//iterator tmp var
	local vector	DirVec;			//direction vector from Loc to current potential target
	local float		DistRatio;		//dot product of the view direction with one-over the offset to the actor
	local float		FOVCos;			//Cos of MaxAngleInDegrees

	// First try a direct trace to the first targetable actor.
	BestTarget = FindTraceTarget( Loc, ViewRot );
	if( !BestTarget || !IsTargetable( BestTarget ) )
	{
		BestTarget = None;

		FOVCos = class'Util'.static.Cos( MaxAngleInDegrees * DegreesToRadians );

		ViewVec = vector(ViewRot);

		foreach DynamicActors( class'Actor', IterA )
		{
			if( IsTargetable(IterA) )
			{
				DistRatio = ((IterA.Location - Loc) dot ViewVec) / VSizeSq(IterA.Location - Loc);
				if( DistRatio > 0 && class'UtilGame'.static.ActorCanSeeActor( Owner, IterA, FOVCos ) )
				{
					if( !BestTarget || DistRatio > BestRatio )
					{
						BestTarget = IterA;
						BestRatio = DistRatio;
					}
				}
			}
		}
    }

	return BestTarget;
}

function Actor FindTraceTarget( vector Loc, rotator ViewRot )
{
	local vector	Ignored;		//dummy arg

	// optimization
	if( !UseGlowingCrosshairs )
		return None;

	//return class'Util'.static.TraceRecursive( Self, Ignored, Ignored, Loc, true,, vector(ViewRot) );
	//!!ARL (mdf) above call is causing between 0.0 (look at floor) to 2.8ms (mm_waterfront) -- cap at 4K?
	return class'Util'.static.TraceRecursive( Self, Ignored, Ignored, Loc, true,, vector(ViewRot), 4096.0 );
}

static function bool AddAmmo( Pawn Other, string AmmoClassString, int AddAmmoAmount, optional bool bMaximizeClipAmount )
{
	local Ammunition Ammo;
	local class<Ammunition> AddAmmoClass;
	local bool bResult;

	bResult = false;

	AddAmmoClass = class<Ammunition>(DynamicLoadObject( AmmoClassString, class'Class' ));
	if( AddAmmoClass? )
	{
		Ammo = Ammunition(Other.FindInventoryType( AddAmmoClass ));
		if( Ammo? )
		{
			AddAmmoAmount = Max( AddAmmoAmount, -Ammo.AmmoAmount );

			Ammo.AddAmmo( AddAmmoAmount );
			bResult = true;
		}
		else
		{
			Ammo = Other.Spawn( AddAmmoClass );		// Create ammo type required
			if( Ammo? )
			{
				AddAmmoAmount = Max( AddAmmoAmount, 0 );
				Other.AddInventory( Ammo );			// and add to player's inventory

				Ammo.AmmoAmount = AddAmmoAmount;
				Ammo.GotoState( '' );
				bResult = true;
			}
		}
		
		if( U2Ammo(Ammo)? && bMaximizeClipAmount )
			U2Ammo(Ammo).MaximizeClipAmount();
	}

	return bResult;
}

function sound GetGunButtSound()
{
	return GunButtSounds[ Rand( GunButtSounds.Length ) ];
}

simulated function NotifyCutsceneBegin();	// override for special handling of cutscene starting.

defaultproperties
{
	FireTime=0.500000
	AltFireTime=0.500000
	FireLastDownTime=1.000000
	AltFireLastDownTime=1.000000
	FireLastReloadTime=1.000000
	AltFireLastReloadTime=1.000000
	ReloadTime=0.500000
	SelectTime=0.600000
	DownTime=0.533000
	FireSkinTime=1000000000.000000
     GunButtSounds(0)=Sound'U2WeaponsA.GunButt.GunButt01'
     GunButtSounds(1)=Sound'U2WeaponsA.GunButt.GunButt02'
     GunButtSounds(2)=Sound'U2WeaponsA.GunButt.GunButt03'
     GunButtSounds(3)=Sound'U2WeaponsA.GunButt.GunButt04'
	FirePitch=(A=1.000000,B=1.000000)
	AltFirePitch=(A=1.000000,B=1.000000)
	fAdjustWeaponRate=0.400000
	bRepeatFire=true
	bRepeatAltFire=true
	UseGlowingCrosshairs=true
	WeaponAnimationType=AT_NoWeapon
	TraceRange=10000.000000
	AltShakeMag=5.000000
	AltShakeTime=0.200000
	BounceDamping=0.450000
     TargetableTypes(0)='Pawn'
	CrosshairFilename="Crosshairs"
	CrosshairName="Pistol_Cross"
	bAimFire=true
	bAimAltFire=true
	bFireEnabledForOwner=true
	bAltFireEnabledForOwner=true
	RangeMinFire=-1.000000
	RangeIdealFire=-1.000000
	RangeMaxFire=-1.000000
	RangeLimitFire=-1.000000
	RatingInsideMinFire=-10.000000
	RatingRangeMinFire=-1.000000
	RatingRangeIdealFire=-1.000000
	RatingRangeMaxFire=-1.000000
	RatingRangeLimitFire=-1.000000
	AIRatingFire=-99.999001
	RangeMinAltFire=-1.000000
	RangeIdealAltFire=-1.000000
	RangeMaxAltFire=-1.000000
	RangeLimitAltFire=-1.000000
	RatingInsideMinAltFire=-10.000000
	RatingRangeMinAltFire=-1.000000
	RatingRangeIdealAltFire=-1.000000
	RatingRangeMaxAltFire=-1.000000
	RatingRangeLimitAltFire=-1.000000
	AIRatingAltFire=-99.999001
	ShakeMag=5.000000
	ShakeTime=0.200000
	AIRating=-99.999001
	AlignMeshTraceOffset1=(X=10.000000,Y=-5.000000,Z=-12.000000)
	AlignMeshTraceOffset2=(X=10.000000,Y=5.000000,Z=-12.000000)
	AlignMeshTraceOffset3=(X=-12.000000,Z=-12.000000)
	ActorFOV=60.000000
	bNoSmooth=false
	bAutoEnableAgent=true
	SoundRadius=800.000000
	TransientSoundRadius=800.000000
	CollisionRadius=0.000000
	CollisionHeight=0.000000
	bBounce=true
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}