U2.U2JumpPack

//=============================================================================
// U2JumpPack.uc
//=============================================================================
class U2JumpPack extends PowerSuit;

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

var() float		Thrust;
var() float		DrainRate;			// DrainAmount per DrainRate in seconds
var() int		DrainAmount;
var() Sound		ThrustSound;
var() float		MaxJumpEnergy;		// JumpEnergy cap
var() float		JumpEnergy;			// Current JumpEnergy
var() float		RechargeRate;		// RechargeAmount per RechargeRate in seconds
var() float		RechargeAmount;		
var   bool		bThrusting;
var   PowerSuit	TargetPowerSuit;
var   float		LastDrainTime;
var   float		LastRechargeTime;

//-----------------------------------------------------------------------------
// Gets the current PowerSuit and records a time to reference the initial
// transfer from.

event PreBeginPlay()
{
	//MWP (mdf) -- owner is none when starting a dm game and game hasn't started yet 
	// (waiting for player to hit fire) so PowerSuit pbly never assigned in dm currently?
	//temp check just to get rid of warning -- need to fix time at which inventory is
	//assigned
	if( Owner == None )
		return;

	TargetPowerSuit = PowerSuit(class'UtilGame'.static.GetInventoryItem( Pawn(Owner), class'PowerSuit' ));
	// Prime vars
	JumpEnergy = MaxJumpEnergy;	
	LastDrainTime = Level.TimeSeconds;
	LastRechargeTime = Level.TimeSeconds;
}

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

function TransferProperties( Pickup PickedUpItem )
{
	local U2JumpPackPickup P;

	P = U2JumpPackPickup(PickedUpItem);

	Thrust         = P.Thrust;
	DrainRate      = P.DrainRate;
	DrainAmount    = P.DrainAmount;
	MaxJumpEnergy  = P.MaxJumpEnergy;
	RechargeRate   = P.RechargeRate;
	RechargeAmount = P.RechargeAmount;
}

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

exec function JumpPackThrust()
{
	bThrusting = true;
}

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

exec function UnJumpPackThrust()
{
	bThrusting = false;
}

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

function float CalcEnergyDrain( float CurrentDrainTime )
{
	local float ToDrain;

	// DrainAmount should only be set to 0 for testing
	if( DrainAmount == 0 )
	{
		// If DrainRate is 0, don't drain anything
		ToDrain = DrainAmount;
	}
	else
	{
		// If the timeperiod since the last Drain is greater than or equal to the specified
		// DrainRate, Then
		if( (CurrentDrainTime - LastDrainTime) >= DrainRate )
		{
			// Set Drain to the specified DrainAmount
			ToDrain = DrainAmount;
			// If the amount to Drain is greater than the amount of JumpEnergy left before
			// empty, Then
			if( ToDrain > JumpEnergy )
			{
				// Only Drain the remaining amount of JumpEnergy
				ToDrain = JumpEnergy;
			}
		}
	}
	return ToDrain;
}

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

function float CalcEnergyRecharge( float CurrentRechargeTime )
{
	local float ToRecharge;

	if( RechargeAmount == 0 )
	{
		// If RechargeRate is 0, recharge it all
		ToRecharge = MaxJumpEnergy - JumpEnergy;
	}
	else
	{
		// If the timeperiod since the last Recharge is greater than or equal to the specified
		// RechargeRate, Then
		if( (CurrentRechargeTime - LastRechargeTime) >= RechargeRate )
		{
			// Set Recharge to the specified RechargeAmount
			ToRecharge = RechargeAmount;
			// If the amount to Recharge is greater than the amount of JumpEnergy needed to reach
			// max, Then
			if( ToRecharge > MaxJumpEnergy - JumpEnergy )
			{
				// Only recharge that little bit left to reach max
				ToRecharge = MaxJumpEnergy - JumpEnergy;
			}
		}
	}
	return ToRecharge;
}

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

function float ApplyDrain( float ToDrain, float CurrentDrainTime )
{
	// This catches the unlikely case where the amount to drain is less than 0
	if( ToDrain > 0 )
	{
		JumpEnergy -= ToDrain;
		LastDrainTime = CurrentDrainTime;
	}
	else
	{
		// In which case, the amount to drain is set to 0
		ToDrain = 0;
	}
	if( JumpEnergy <= 0 )
		bThrusting = false;

	return ToDrain;
}

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

function float ApplyRecharge( float ToRecharge, float CurrentRechargeTime )
{
	// This catches the unlikely case where the amount to recharge is less than 0
	if( ToRecharge > 0 )
	{
		JumpEnergy += ToRecharge;
		LastRechargeTime = CurrentRechargeTime;
	}
	else
	{
		// In which case, the amount to recharge is set to 0
		ToRecharge = 0;
	}
	return ToRecharge;
}

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

simulated event Tick(float DeltaTime)
{
	local float ToDrain;
	local float ToRecharge;

	Super.Tick( DeltaTime );

	if( TargetPowerSuit == None )
	{
		// Exception, should only happen if player has no PowerSuit
		return;
	}
	
	// If there is JumpEnergy and the player is Thrusting, Then
	if( JumpEnergy > 0 && bThrusting )
	{
		// Calculate Drain
		ToDrain = CalcEnergyDrain( Level.TimeSeconds );
		// Apply Drain
		ToDrain = ApplyDrain( ToDrain, Level.TimeSeconds );
		// Perform Thrust
		Owner.SetPhysics( PHYS_Falling );
		//==================== For taking Owner.Mass into account =============
		// the 0.001 is to convert the mass to a reasonable number, 1- inverts it
//		Owner.Velocity.Z += (Thrust * DeltaTime)*(1-(Owner.Mass*0.001));
		Owner.Velocity.Z += (Thrust * DeltaTime);
		Owner.AmbientSound = ThrustSound;
	}

	// If the player is not Thrusting, Then
	if( !bThrusting )
	{
		// The thrust sound should not be playing
		Owner.AmbientSound = None;
		// Caclulate Recharge
		ToRecharge = CalcEnergyRecharge( Level.TimeSeconds );
		// Apply Recharge
		ToRecharge = ApplyRecharge( ToRecharge, Level.TimeSeconds );
	}
}

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

defaultproperties
{
	ThrustSound=Sound'U2A.Suits.JumpPackThrust'
	ItemName="Jump Pack"
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}