U2.U2Projectile

//=============================================================================
// U2Projectile.uc
// $Author: Ascheidecker $
// $Date: 11/28/02 10:11p $
// $Revision: 32 $
//=============================================================================
class U2Projectile extends Projectile
	abstract;

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

var() float BounceDamping;
var() float SplashDrawScale;
var() class<ImpactHandler> ImpactHandlerClass;
var() class<Actor> ExplosionEffect;
var() sound ExplosionSound;
var() float BounceSoundRadius;
var() ParticleSalamander ParticleEffect, WaterParticleEffect, MoveParticleEffect;
var() float Health; // if non-0 projectile can take damage and get destroyed

//viewshake
var() float ShakeRadius, ShakeMagnitude, ShakeDuration;

var float FirstTick;
var float StopNormalZ;

var float LifeSpanOnBounce;

var ParticleSalamander HitSal, MoveSal;
var bool bGotVelocity;
var bool bExplodeImpactSound; // whether to play impact sound when exploding (e.g. false for grenades)

var() bool bNoFalloff;	// Falloff parm for HurtRadius.

simulated event PostBeginPlay()
{
	Super.PostBeginPlay();

	SpawnEffect();
	
	// testing -- draw flight path
	//AddTimer( 'DrawSelf', 0.05, true );
}

function SetLifespanOnBounce( float DesiredLifeSpan )
{
	LifeSpanOnBounce = DesiredLifeSpan;
	LifeSpan = 0.0;
}

simulated function ParticleSalamander SpawnEffect()
{
	if( ShouldSpawnEffect() )
	{
		MoveSal = ParticleSalamander( class'ParticleGenerator'.static.CreateNew( Self, MoveParticleEffect, Location ) );
		MoveSal.SetRotation( Rotation );
		MoveSal.SetBase( Self );
	}
	return MoveSal;
}

simulated function bool ShouldSpawnEffect()
{
	return (
			( bGotVelocity || (Level.NetMode != NM_DedicatedServer && Level.NetMode != NM_Client) ) 
		&&	( MoveParticleEffect != None )
			);
}

simulated function PostRecvVelocity()
{
	Super.PostRecvVelocity();
	bGotVelocity = true;
	SpawnEffect();
}

simulated event PreBeginPlay()
{
	Super.PreBeginPlay();

	Velocity = vector(Rotation) * Speed;

	if( PhysicsVolume.bWaterVolume ) //ARL improved water impact handling (see ZoneChange() below)
	{
		Velocity = 0.6 * Velocity;
	}

	ResetLifeSeconds();

	//!!ARL tbd
	if( SpawnSound != None )
		PlaySound( SpawnSound );
}


simulated function ResetLifeSeconds()
{
	FirstTick = Level.TimeSeconds;
}


simulated function float GetLifeSeconds()
{
	return Level.TimeSeconds - FirstTick;
}


simulated event PhysicsVolumeChange( PhysicsVolume NewVolume )
{
	local U2WaterRing Ring;
	local U2BubbleTrail Trail;

	if( NewVolume.bWaterVolume )
	{
		// slow down the projectile
		Velocity = 0.6 * Velocity;

		// make a splash and water ring
		Spawn( class'U2Splash',,, Location );
		// attach bubble trail
		Trail = Spawn( class'U2BubbleTrail',,, Location );
		Trail.SetRotation( Rotation );
		Trail.SetBase( Self );
		// don't draw explosions under water
		ExplosionDecal = None;
	}
}


function AdjustTraceFireHit( out CheckResult Hit );


// function not simulated because we don't want client-side explosions 
//   when a projectile hits an actor, because it can be different from the server
function ProcessTouch( Actor Other, vector HitLocation )
{
	local CheckResult Hit;
	if( Other != Instigator || RicochetCount > 0 )
	{
		Hit.Actor = Other;
		Hit.Location = HitLocation;
//		Hit.Normal = Normal( HitLocation - Other.Location );
		Hit.Normal = -Velocity;
		if( VSize2D(Hit.Location - Other.Location)<(Other.CollisionRadius-1) )	// if we hit the top/bottom
		{
			Hit.Normal.X = 0;
			Hit.Normal.Y = 0;
		}
		else																	// otherwise we hit the side
		{
			Hit.Normal.Z = 0;
		}
		Hit.Normal = Normal( Hit.Normal );

		if( bBounce && Pawn(Other)==None )
		{
			HitWallEx( Hit );
		}
		else
		{
			if( Role==ROLE_Authority )
				TryExplodeEx( Hit );
		}
	}
}


simulated event LandedEx( CheckResult Hit )
{
	if( bBounce )
	{
		// do nothing
		
		// 2002.11.21 (mdf) NPC support
		if( LifeSpanOnBounce > 0.0 )
		{
			Lifespan = LifeSpanOnBounce;
			LifeSpanOnBounce = 0.0;
		}
	}
	else
	{
		HitWallEx( Hit );
	}
}


simulated event HitWallEx( CheckResult Hit )
{
	local Sound BounceSound;
	local float BounceSpeed;
	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;
		
	if( bBounce )
	{
		// 2002.11.21 (mdf) NPC support
		if( LifeSpanOnBounce > 0.0 )
		{
			Lifespan = LifeSpanOnBounce;
			LifeSpanOnBounce = 0.0;
		}
		
		BounceSpeed = VSize(Velocity);
		if( Level.NetMode != NM_DedicatedServer && ImpactHandlerClass != None )
		{
			BounceSound = ImpactHandlerClass.static.DetermineImpactSound( U2Pawn(Instigator), MaterialHit, true );
			PlaySound( BounceSound, SLOT_Misc, FMin( 800.0, 800.0 * BounceSpeed/256.0), false, BounceSoundRadius );
		}

		Velocity = BounceDamping * ( ( Velocity dot Hit.Normal ) * Hit.Normal * (-2.0) + Velocity );   // Reflect off Wall w/damping
		RandSpin( 100000 );
		
		//DMTNS( "BounceSpeed: " $ BounceSpeed $ " Z: " $ Hit.Normal.Z ); 
		if( BounceSpeed < 16 && Hit.Normal.Z > StopNormalZ ) 
		{
			SetPhysics( PHYS_None );
			Velocity = Vect(0,0,0);
			//why are we passing to LandedEx, if LandedEx is explicitly designed to do nothing?
			LandedEx( Hit );
		}
	}
	else
	{
		TryExplodeEx( Hit );
	}
}


function TakeDamage( int Damage, Pawn InstigatedBy, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	if( default.Health > 0 )
	{
		Health -= Damage;
		if( Health <= 0 )
			Destroy();
	}
}


simulated event Destroyed()
{
	if( MoveSal!=None )
	{
		MoveSal.ParticleDestroy();
		MoveSal.SetPhysics(PHYS_None);
		MoveSal.LightType = LT_None;
		MoveSal = None;
	}

	//explode handles the case of ensuring it doesn't explode twice
	Explode( Location, vect(0,0,1) );
	Super.Destroyed();
}


simulated function Explode( vector HitLocation, vector HitNormal )
{
	local CheckResult Hit;

	Hit.Location = HitLocation;
	Hit.Normal = HitNormal;
	TryExplodeEx( Hit );
}


simulated function TryExplodeEx( CheckResult Hit )
{
	if( bExploded )
		return;
		
	bExploded = true;
	
	ExplodeEx( Hit );
}


simulated function ExplodeEx( CheckResult Hit )
{
	local Actor Explosion;
	local Projector Decal;
	local ParticleGenerator Particles;
	local Material.CheckResult MaterialHit;
	
	if( Role == ROLE_Authority )
	{
		MakeNoise( 1.0 );

		if( Damage > 0 && DamageRadius > 0 )
		{
			HurtRadius( Damage, DamageRadius, MyDamageType, MomentumTransfer, Hit.Location, bNoFalloff );
			class'DestroyOnDamage'.static.Notify(XLevel,Hit.Location,DamageRadius,MyDamageType);
		}
		else if ( Hit.Actor != None )
		{
			Hit.Actor.TakeDamage( Damage, Instigator, Hit.Location, MomentumTransfer * Normal(Velocity), MyDamageType );
		}
	}

	if( Level.NetMode != NM_DedicatedServer )
	{
		if( ExplosionSound != None )
		{
			PlaySound( ExplosionSound, SLOT_Interact );
		}

		if( ExplosionEffect != None )
		{
			Explosion = Spawn( ExplosionEffect, self, , Location + ExploWallOut * Hit.Normal, rotator(Hit.Normal) );
			Explosion.RemoteRole = ROLE_None;
		}

		if( ExplosionDecal != None )
		{
			Decal = Spawn( ExplosionDecal, self,, Location, rotator(-Hit.Normal));
			Decal.RemoteRole = ROLE_None;
		}

		if( WaterParticleEffect != None && PhysicsVolume.bWaterVolume )
		{
			Particles = class'ParticleGenerator'.static.CreateNew( self, WaterParticleEffect, Hit.Location );
			Particles.SetRotation( rotator(Hit.Normal) );
			Particles.Trigger( self, Instigator );
			Particles.ParticleLifeSpan = Particles.GetMaxLifeSpan() + Particles.TimerDuration + Particles.RampUpTime + Particles.RampDownTime;
		}
		else if( ParticleEffect != None )
		{
			Particles = class'ParticleGenerator'.static.CreateNew( self, ParticleEffect, Hit.Location );
			Particles.SetRotation( rotator(Hit.Normal) );
			Particles.Trigger( self, Instigator );
			Particles.ParticleLifeSpan = Particles.GetMaxLifeSpan() + Particles.TimerDuration + Particles.RampUpTime + Particles.RampDownTime;
		}
		
		class'UtilGame'.static.MakeShake( Self, Hit.Location, ShakeRadius, ShakeMagnitude, ShakeDuration );
	}
	if( ImpactHandlerClass != None )
	{
		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;

		// allow the impact handler to reuse the projectile or destroy it, as required
		ImpactHandlerClass.static.ProjectileImpact( self, MaterialHit, bExplodeImpactSound );
	}
	else
	{
		Destroy();
	}
}

/* testing -- draw flight path
function DrawSelf()
{
	AddCylinder( Location, 1, 1, ColorMagenta() );
}
*/

defaultproperties
{
	SplashDrawScale=0.200000
	StopNormalZ=0.500000
	bExplodeImpactSound=true
	bNetTemporary=false
	TransientSoundRadius=500.000000
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}