U2.PowerSuit

//=============================================================================
// PowerSuit.uc
//=============================================================================

class PowerSuit extends Armor;

#exec OBJ LOAD File=..\System\ParticleRes\Impact_Metal_AR.u //!SBB: Placeholder until we get real powersuit effects
#exec OBJ LOAD FILE=..\Sounds\U2A.uax

var() class<DamageFilter> DamageFilterClass;

var() float MaxPower;						// The Maximum level of the PowerSuit energy holding capacity
var() travel float Power;					// The current energy level of the PowerSuit
var() ParticleGenerator ParticleEffect;		// The effect to spawn when an impact happens
var   travel float DamageResidue;			// Holds the fractional damage not dealt to the player immediately
var bool bProhibitPickups;					// if true powersuit can't be replaced by another one (pickup)
var() Sound	PowerSuitHitSound;

var float PowerSuitHitVolume;

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

event Replication()
{
	Super.Replication();
	DOREP('Power');
}

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

event PreBeginPlay()
{
	local class<PowerSuitPickup> PSPClass;

	Super.PreBeginPlay();
	
	PSPClass = class<PowerSuitPickup>(PickupClass);

	if( PSPClass != None )
	{
		MaxPower = class<PowerSuitPickup>(PickupClass).default.MaxPower;
		Power = class<PowerSuitPickup>(PickupClass).default.Power;
	}
}

//-----------------------------------------------------------------------------
// Now that the player has lost the PowerSuit, reset UnderWaterTime back to default.

event Destroyed()
{
	// if PowerSuit is not held, there will be no owner to reset
	if( Pawn(Owner) != None )
		Pawn(Owner).UnderWaterTime = Pawn(Owner).default.UnderWaterTime;
//	DM( "UnderWaterTime="$Pawn(Owner).UnderWaterTime );

	Super.Destroyed();
}

//-----------------------------------------------------------------------------
// Checks to see if the player already has one of these items in his
// inventory, if he does, the new item is only picked up if it is a better
// PowerSuit (higher MaxPower).

// FYI: False means good to pickup, true means do not pickup

function bool HandlePickupQuery( Pickup item )
{
	//!!mdf-tbd: ClassIsChildOf( class, class'PowerSuit' ) is always going to be true no?
	//if( ClassIsChildOf( item.InventoryType, class'PowerSuit' ) && ClassIsChildOf( class, class'PowerSuit' ) )
	if( ClassIsChildOf( item.InventoryType, class'PowerSuit' ) )
	{
		// NOTE (mb) currently unused. Commented out to remove dependency on jump pack assets
		//if( U2JumpPackPickup(item) != None )
		//	return false;

		if( bProhibitPickups )
			return true;
			
		if( PowerSuitPickup(item).MaxPower > MaxPower )
		{
			Destroy();
			return false;
		}
		
		return true;
	}
	else
	{
		if( Inventory == None )
		{
			return false;
		}
	}
	return Inventory.HandlePickupQuery( item );
}

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

function TransferProperties( Pickup PickedUpItem )
{
	local PowerSuitPickup P;

	P = PowerSuitPickup(PickedUpItem);

	MaxPower    = P.MaxPower;
	Power		= P.Power;
}

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

function TransferPropertiesTo( Pickup PickedUpItem )
{
	local PowerSuitPickup P;

	P = PowerSuitPickup(PickedUpItem);

	P.MaxPower  = MaxPower;
	P.Power		= Power;
}

//-----------------------------------------------------------------------------
// Could be used for HUD indicators.
// I am not real sure if health indicators should be handled here since this is
// the PowerSuit, not the Pawn.
// ARL/SBB: I'm not sure if this will be the place to handle PowerSuit effects, so it's here in case.

function DisplayDamageTaken( int PSDamage, int HealthDamage, vector Location )
{
	local ParticleGenerator Particles;

	// Visual hit effect
	// PWC 2002.08.20 Commenting this out because damage effects should really be displayed by impact handlers.  
	//                The way it is implemented here was also leaving active particle generators unattached to the Pawn
/*	if( PSDamage > 0 && ParticleEffect != None )
	{
		Particles = class'ParticleGenerator'.static.CreateNew( Owner, ParticleEffect, Location );
//		Particles.SetRotation( rotator(Hit.Normal) );
		Particles.Trigger( Owner, Owner.Instigator );
		Particles.ParticleLifeSpan = Particles.GetMaxLifeSpan() + Particles.TimerDuration;
	}
*/
	if( PSDamage > 0 && Pawn(Owner)? && Pawn(Owner).IsRealPlayer() )
	{
		class'UIConsole'.static.SendEvent("ShieldFlash");
		Pawn(Owner).PlaySound( PowerSuitHitSound, SLOT_None, PowerSuitHitVolume );
	}

	// HUD indicators
	/*
	if( HealthDamage > 0 )
	{
	}
	*/
}

/*-----------------------------------------------------------------------------
Determines the amount of damage to be dealt to the PowerSuit, applies that
damage and returns all carryover damage and health damage.

NOTE (mdf): the current design has the current power level of the suit applying
to the *entire* amount of damage that comes in. This means that if you have a
suit at 100%, all damage will go to the power suit (up to the MaxPower for the
suit) whereas if you take the same amount of damage across multiple calls to
this function (possibly in the same tick), less, possibly much less damage will 
go to the suit.

We may not change this design, but if we decide this is confusing / strange, 2
possible solutions:

1: track damage over, say, 0.25 secs and have the suit able to absorb a certain
amount of damage over that time. If that level is exceeeded, the "overflow" goes
to the Pawn.

2: determine a function for applying damage continuously instead of discretely
so that for a call to this function with Damage > 1, the power suit will be
increasingly degraded for each unit of damage.

I haven't nailed this down, but the basic idea is that, if the suit is currently
at Power = X, and N units of damage come in, the damage to the suit is

	X/MaxPower + (X-(X/MaxPower))/MaxPower  + (X-(X-(X/MaxPower))/MaxPower)/MaxPower etc.
	
=

	X/MaxPower + (X-(X/MaxPower))/MaxPower  + (X-(X-(X/MaxPower))/MaxPower)/MaxPower etc.

=

	SUM(1..N) (X - Damage(i-1)) / MaxPower
	
(get out calculus text...)
*/

// DamageType specific ratios:
// 0=all health, 0.25=armor piercing, 0.5=normal armor calculation(default), 1=armor only(emp).

function int ArmorAbsorbDamage( int DamageInt, class<DamageType> DamageType, vector HitLocation )
{
	local float ReturnedDamage;
	local float ReturnedDamageInt;
	local float Pct,D;
	local vector Momentum; // used as stub for DamageFilter.ApplyFilter() momentum parameter

	local float OldPower;
	local int ArmorDamageInt;
	local float ArmorDamage;
	local float OldArmorDamage;
	local float Damage;

	OldPower = Power;
	Damage = DamageInt; //made Damage a float for greater precision
	//PWC 2002.10.22 Some particle effects were coming in with no damage type, so we now check for that
	// and if that's the case give it the default DamageType
	if (DamageType == None) DamageType=class'DamageType';
	// Pre-damage for armor.
	if( DamageType.default.ArmorHealthRatio>0.5 )
	{
		D = Damage * (DamageType.default.ArmorHealthRatio-0.5)*2.0;
		Damage -= D;
		Power -= D;
	}

	// Get damage to EnergyShield
	if( Power>0 )
	{
		Pct = Power / MaxPower;
		Power -= Damage * Pct;
		ReturnedDamage = Damage * (1-Pct);
	}
	else			
	{
		Pct = 0;
		ReturnedDamage = Damage;
	}

	// Post-damage for health.
	if( DamageType.default.ArmorHealthRatio<0.5 )
	{
		D = (Damage * Pct) * (((DamageType.default.ArmorHealthRatio*2.0)*-1.0)+1.0);
		Power += D;
		ReturnedDamage += D;
	}

	ArmorDamage		= OldPower-Power;
	OldArmorDamage	= ArmorDamage;
	//PWC 7/15/2002 Changed DamageFilter to support an optional float damage paramenter
	//              In order to avoid nasty mult/div 100 hack
	ArmorDamageInt	= int (ArmorDamage);
	DamageFilterClass.static.ApplyFilter( ArmorDamageInt, Momentum, DamageType, ArmorDamage );
	Power = OldPower - ArmorDamage;
	if( Power < 0 )
	{
		ReturnedDamage -= (Power * (OldArmorDamage / ArmorDamage)); //leftover health should have the powersuit damagefilter eliminated
		Power = 0;
	}
	
	ReturnedDamageInt = int(ReturnedDamage);
	DamageResidue += ReturnedDamage - ReturnedDamageInt;

	if( DamageResidue > 1 )
	{
		DamageResidue -= 1;
		ReturnedDamage += 1;
	}

	// Display HUD indicators PowerSuit visual hit effect
	DisplayDamageTaken( (int(OldPower) - int(Power)), ReturnedDamage, HitLocation );
	return ReturnedDamage;
}

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

function armor PrioritizeArmor( int Damage, class<DamageType> DamageType, vector HitLocation )
{
	return Self;
}

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

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

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

defaultproperties
{
	DamageFilterClass=Class'U2.DamageFilterPowerSuit'
	ParticleEffect=ParticleSalamander'Impact_Metal_AR.ParticleSalamander0'
	PowerSuitHitSound=Sound'U2A.Suits.PowerSuitHit'
	PowerSuitHitVolume=0.250000
	ItemName="Power Suit"
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}