U2XMP.weaponTurretMounted

//=============================================================================
// $Workfile: weaponTurretMounted.uc $
// Created By: Sam Brown
// Created On: 1/14/00
// $Author: Ascheidecker $
// $Date: 11/28/02 10:11p $
// $Revision: 24 $
//=============================================================================
class weaponTurretMounted extends U2Weapon;

var bool     bLeftBarrel;
var	vector   LeftBarrel, RightBarrel;
var rotator  LeftBarrelRot, RightBarrelRot, FireRotation;
var int		 TracerCount;
var bool	 bAmbientFireSound;
var() int	 DrawTracerFrequency;		// Draw a tracer every this number of rounds, if 0 tracer will not be drawn.
var vector	 FireStartLocation;
var() float	 FireTimeMax, FireTimeMin;	// Used for varying FireTime based on difficulty

var float TryToHitInstantBaseOddsMin;
var float TryToHitInstantBaseOddsMax;
var float TryToHitProjectileBaseOddsMin;
var float TryToHitProjectileBaseOddsMax;

var float TryToHitInstantBaseDistance;
var float TryToHitInstantMinMissDistance;
var float TryToHitInstantMaxHitDistance;

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

function ProcessTraceHitEx( vector HitDirection, CheckResult Hit, float EffectiveDamage )
{
	//ARL compute damage vs. position of hit on collision cylinder -- kill randomness
	EffectiveDamage = 9 + Rand( 6 );
	if( FRand() < 0.2 )
	{
		HitDirection *= 2.5;
	}
	Super.ProcessTraceHitEx( HitDirection, Hit, EffectiveDamage );
}

// doesn't use ammo.  never plays reload.
simulated function int GetFireAmmoUsed() { return 0; }
simulated function int GetAltFireAmmoUsed() { return 0; }

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

simulated function PlayAnimEx( name Sequence )
{
	local int i;

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

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

function float GetFireTime()
{
	local float Val;

	Val = (1.0 - Level.Game.GetNormalizedDifficulty())*(FireTimeMax - FireTimeMin) + FireTimeMin;
	//DM( "*** " $ Self $ " FireTime = " $ Val );

	return Val;
}

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

simulated function PlayFiring()
{
	PlayAnimEx( 'Fire' );
}

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

function AuthorityFire()
{
	if( bInstantHit )
	{
		TraceFire( TraceSpreadFire );
	}
	else if( ProjectileClass? )
	{
		ProjectileFire( ProjectileClass );
	}
}

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

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

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

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

simulated function Fire()
{
	// if not overheated
	//if( U2Ammo(AmmoType)? && !U2Ammo(AmmoType).ReloadRequired( GetFireAmmoUsed() ) )
	//{
		if (Role == ROLE_Authority)
			AuthorityFire();
		EverywhereFire();
	//}
}

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

simulated function ClearTracers()
{
	local int i;

	for (i=0;i<DecoEffects.Length;i++)
		if( DecoEffects[i].Effect? )
			PulseLineGenerator(DecoEffects[i].Effect).ParticleDestroy();
}

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

simulated state Idle // override Weapon.Idle.Begin
{
Begin:
	if( bInstantHit && DrawTracerFrequency > 0 )
		ClearTracers();
}

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

simulated state Firing
{
ignores Fire, AltFire;
	
	// This BeginState can go away if the turrets eventually get agentized, but since they
	// don't really animate, I'm not sure it's necessary.
	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()
	{
		AmbientSound = default.AmbientSound;
	}

Begin:
	//incoming animation set by EverywhereFire(). We wait for it to finish
	FireTime = GetFireTime();
//DM( "*** " $ Self $ ".stateFiring, FireTime = " $ FireTime );	
	Sleep( FireTime );
//DM( "*** Done sleeping" );
	if (bRepeatFire)
	{
//DM( "*** Going to Global.Fire()" );
		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
		//else, if we're done firing, and want to stop
	}

	GotoState('Idle');
}

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

function vector GetFireOffset()
{
	if( bLeftBarrel )
		return LeftBarrel;
	else
		return RightBarrel;
}

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

function rotator GetFireRotation()
{
	if( bLeftBarrel )
		return LeftBarrelRot;
	else
		return RightBarrelRot;
}

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

function SetFireStartLocations()
{
	FireStartLocation = GetFireOffset();
	FireRotation = GetFireRotation();
	
	bLeftBarrel = !bLeftBarrel;
	
	//DM( "*** LeftBarrel = " $ LeftBarrel $ " RightBarrel = " $ RightBarrel );
}

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

simulated function ClientTraceImpact( CheckResult Hit )
{
	UpdateTracer(Hit);
}

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

simulated function UpdateTracer( CheckResult Hit )
{
	local PulseLineGenerator Tracer;

	if( DrawTracerFrequency == 0 )
		return;

	Tracer = PulseLineGenerator(DecoEffects[0].Effect);
	if (!Tracer) return;

	if( TracerCount == DrawTracerFrequency )
	{
		Tracer.SetDrawType(DT_Custom);
		TracerCount = 0;
	}
	else
	{
		Tracer.SetDrawType(DT_None);
		TracerCount++;
	}

	if (Tracer.Connections.length!=1)
		Tracer.Connections.length = 1;

	Tracer.Connections[0].Start = FireStartLocation;
	Tracer.Connections[0].End = Hit.Location;
}

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

function MaybeAdjustTargetLocation( 
	Actor TargetActor, 
	float TargetDistance,
	float SpreadDegrees,
	float TryToHitBaseOddsMin, 
	float TryToHitBaseOddsMax, 
	float TryToHitBaseDistance, 
	float TryToHitMinMissDistance, 
	float TryToHitMaxHitDistance,
	out vector TargetLocation )
{
	local vector MissVector;
	local float MissDistance;
	local int PitchError;
	
	if( class'UtilGame'.static.TryToHit(
			Owner,
			TargetActor, 
			TargetDistance, 
			SpreadDegrees,
			0.0, //LastPainAnimTime,
			0.0, //MaxAffectedByHitTime,
			0.0, //LastAcquireTime,
			0.0, //MaxAffectedByAcquisitionTime,
			TryToHitBaseOddsMin, 
			TryToHitBaseOddsMax, 
			TryToHitBaseDistance, 
			TryToHitMinMissDistance, 
			TryToHitMaxHitDistance ) )
	{
		return;
	}
	
	MissVector = class'UtilGame'.static.GetMissVector(
		Owner,
		TargetActor,
		0.0, //LastPainAnimTime,
		0.0, //MaxAffectedByHitTime,
		0.0, //MaxHitMissMultiplier,
		0.0, //MinHitPitchError,
		0.0, //MaxHitPitchError,
		0.0, //LastAcquireTime,
		0.0, //MaxAffectedByAcquisitionTime,
		0.0, //MaxAcquireMissMultiplier,
		0.0, //MinAcquirePitchError,
		0.0, //MaxAcquirePitchError,
		false, // bTargetBlocked,
		PitchError );
		
	MissDistance = TargetActor.CollisionRadius + FRand() * TargetActor.CollisionRadius + 4.0;
	if( SpreadDegrees > 0.0 )
		MissDistance += TargetDistance * sin( 0.5*DegreesToRadians*SpreadDegrees );
	
	TargetLocation += MissVector * MissDistance;
	TargetLocation.Z += TargetActor.CollisionHeight - 2*FRand() * TargetActor.CollisionHeight;
}

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

function TraceFire( float Accuracy )
{
	local vector End, X, Y, Z;
	local CheckResult Hit;
	local Actor TargetActor;
	local vector TargetVector;
	local float TargetDistance;
	local Material.CheckResult MaterialHit;
		
	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;

	SetFireStartLocations();
	
	TargetActor = Pawn(Owner).Controller.ControllerEnemy;
	if( TargetActor == None )
		return;
	TargetVector = TargetActor.Location - FireStartLocation;
	TargetDistance = VSize( TargetVector );
	
	Pawn(Owner).MakeNoise( Pawn(Owner).SoundDampening );
	
	GetAxes( rotator(TargetVector), X, Y, Z );
	End = TargetActor.Location; // perfect aim

	MaybeAdjustTargetLocation( 
		TargetActor, 
		TargetDistance,
		TraceSpreadFire,
		TryToHitInstantBaseOddsMin, 
		TryToHitInstantBaseOddsMax, 
		TryToHitInstantBaseDistance, 
		TryToHitInstantMinMissDistance, 
		TryToHitInstantMaxHitDistance,
		End );

	// increase length of trace in case we are missing the target
	End = End + TraceRange * Normal( End - FireStartLocation );
	SingleLineCheck( Hit, Pawn(Owner), End, FireStartLocation, TRACE_ProjTargets ); //ARL don't use TRACE_AllEverything, or triggers will be hit
	
	#debugbegin
	/*
	if( Hit.Actor == TargetActor )
		AddLine( FireStartLocation, End, ColorGreen() );
	else
		AddLine( FireStartLocation, End, ColorRed() );
	*/
	#debugend
	
	DispatchWeaponNotifies( Hit );
	
	if( Hit.Actor? )
	{
		assert( Hit.Actor? );
		assert( Role == ROLE_Authority );
		ProcessTraceHitEx( X, Hit, Damage );

		ImpactHandlerClass.static.TraceImpact( self, MaterialHit );
		ClientTraceImpact( Hit );
	}
}

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

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

	SetFireStartLocations();
	AdjustedAim = rotator(Pawn(Owner).Controller.ControllerEnemy.Location - FireStartLocation );
	
	//AddArrow( FireStartLocation, FireStartLocation + vector(FireRotation)*vect(10000,10000,10000), ColorGreen() );

	//	if( FastTrace( FireStartLocation, FireStartLocation + vector(FireRotation)*vect(10000,10000,10000) ) )
	//	{
		// NOTE (mdf): in some cases this can fail (Pawn too close to geometry for example)
		return Spawn( ProjClass, Self, , FireStartLocation, AdjustedAim );
	//	}
	//	else
	//		DM( "*** FastTrace true" );
}

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

defaultproperties
{
	bLeftBarrel=true
	TryToHitInstantBaseOddsMin=0.125000
	TryToHitInstantBaseOddsMax=0.625000
	TryToHitInstantBaseDistance=1024.000000
	TryToHitInstantMinMissDistance=256.000000
	TryToHitInstantMaxHitDistance=9999999.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'
     TargetableTypes(0)='Pawn'
	bDisableTick=true
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}