U2.PowerUp

//=============================================================================
// PowerUp.uc
//=============================================================================

class PowerUp extends U2Inventory
	abstract;

var() int       EnergyUnits;      // A pickup or station's number of EnergyUnits
var() int       HealthUnits;      // A pickup or station's number of HealthUnits
var() int       TransferRate;     // The rate at which the units are passed to the PowerSuit or Player
							      // in terms of x units per second.
var() bool      bIsStation;       // True if object is a station
var() string    Description;	  // Popup description of this PowerUp
var   float     LastTransferTime; // Saves the time of the last Unit transfer
var   PowerSuit TargetPowerSuit;  // The PowerSuit that is being manipulated
var   Pawn      PowerUpOwner;     // The owner of the PowerSuit

//-----------------------------------------------------------------------------
// The following functions are explained in PowerStation

function ActivateStation( Pawn P );
function StopStation();
function DeactivateStation();
function MakeStationEmpty();
function OnUse( Actor Other );
function OnUnuse( Actor Other );
function bool IsUsable( Actor Other );
function string GetDescription();

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

event PreBeginPlay()
{
	Super.PreBeginPlay();
	
	if( Pawn(Owner) != None )
	{
		PowerUpOwner = Pawn(Owner);
		TargetPowerSuit = PowerSuit(class'UtilGame'.static.GetInventoryItem( PowerUpOwner, class'PowerSuit' ));
	}
	LastTransferTime = Level.TimeSeconds;
}

//-----------------------------------------------------------------------------
// Checks to see if the player already has one of these items in his
// inventory. If he does, he receives an error message.

// FYI: False means good to pickup, true means do not pickup
/*
function bool HandlePickupQuery( Pickup item )
{
	local bool bTransferred;

	// This will take care of those powerups that are not the same as this class, but
	// are still powerups and therefore can have their charges added to this item's charges.
	if( item.InventoryType == class || ClassIsChildOf(item.InventoryType, class'PowerUp') ) 
	{
		bTransferred = AddUnits( PowerUpPickup(item) );
		if( bTransferred )
		{
			DM( "  *** One of these is in inventory, AddUnits, do not pick up -> " $ item );
			return false;
		}
		else
			DM( "  *** Not transferring " $ item );
		return true;
	}

	if( Inventory == None )
	{
		return false;
	}
	return Inventory.HandlePickupQuery( item );
}
*/
//-----------------------------------------------------------------------------
// Transfer units from a newly picked up PowerUp to a PowerUp currently held.

function TransferProperties( Pickup PickedUpItem )
{
	local PowerUpPickup P;

	P = PowerUpPickup(PickedUpItem);

	bIsStation   = P.bIsStation;
	TransferRate = P.TransferRate;
	EnergyUnits  = P.EnergyUnits;
	HealthUnits  = P.HealthUnits;
	Description  = P.Description;	
}

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

function GiveTo( pawn Other, optional bool bDontTryToSwitch )
{
	local PowerUp	Inv;

	Inv = PowerUp(Other.FindInventoryType( Class ));
	if( Inv != None )
	{
		Inv.AddUnits( Self );
		Destroy();
	}
	else
	{
		super.GiveTo( Other, bDontTryToSwitch );
	}
}

//-----------------------------------------------------------------------------
// Transfer units from a newly picked up PowerUp to a PowerUp currently held.
// PUI = PickedUpItem, shortened here to keep the line length readable.

function bool AddUnits( PowerUp PUI )
{
	local PowerSuit PS;
	local bool      bTransferred;
	local Pawn		P;

	P = Pawn(Owner);

	if( P != None && PUI != None )
	{
		bTransferred = false;

		PS = PowerSuit(class'UtilGame'.static.GetInventoryItem( P, class'PowerSuit' ));
		// Must have a PowerSuit in order to pickup energy
		if( PS != None && PUI.EnergyUnits > 0 )
		{
			EnergyUnits += PUI.EnergyUnits;
			bTransferred = true;
		}

		if( PUI.HealthUnits > 0 )
		{
			HealthUnits += PUI.HealthUnits;
			bTransferred = true;
		}
	}

	return bTransferred;
}

//-----------------------------------------------------------------------------
// Determines the amount of units to be transfered during this cycle

function int CalcPowerUp( int CalcUnits, float CurrentTime )
{
	local int ToTransfer;

	if( TransferRate == 0 )
	{
		//transfer all
		ToTransfer = CalcUnits;
	}
	else
	{
//DM( "@@@ " $ TransferRate $ " * " $ CurrentTime $ " - " $ LastTransferTime );
		if( LastTransferTime != 0 )
		{
			ToTransfer = TransferRate * (CurrentTime - LastTransferTime);
//DM( "@@@ ToTransfer = " $ ToTransfer );
			if( ToTransfer > CalcUnits )
			{
				ToTransfer = CalcUnits;
			}
		}
		else
			ToTransfer = 0;
	}
	return ToTransfer;
}

//-----------------------------------------------------------------------------
// Transfers the determined amount of units

function int TransferPowerUp( int ToTransfer, int MaxUnits, int TargetsCurrentUnits, float CurrentTime )
{
	// Catches the case where the pawn has more health than his default health
	if( ToTransfer > 0 && TargetsCurrentUnits < MaxUnits )
	{
		ToTransfer = Min( ToTransfer, MaxUnits - TargetsCurrentUnits );
		LastTransferTime = CurrentTime;
	}
	else
	{
		if( TargetsCurrentUnits >= MaxUnits )
		{
			//DM( "*** MAX hit" );
			// The Max of this unit type has been hit, the powerup needs to be destroyed.
			return -1;
		}
		ToTransfer = 0;
	}
	return ToTransfer;
}

//-----------------------------------------------------------------------------
// Manages the dispersal of powerup units

function TickPowerUp( out int UnitsAvailable, int MaxUnits, out int TargetsCurrentUnits )
{
	local int ToTransfer;

	// Calculate
//DM( "@@@ " $ Self $ ".TickPowerUp.LastTransferTime = " $ LastTransferTime );
	ToTransfer = CalcPowerUp( UnitsAvailable, Level.TimeSeconds );
	// Do Transfer
	ToTransfer = TransferPowerUp( ToTransfer, MaxUnits, TargetsCurrentUnits, Level.TimeSeconds );
	// If max health has been reached
	if( ToTransfer == -1 )
		UnitsAvailable = 0;
	else
	{
		TargetsCurrentUnits += ToTransfer;
		// Cleanup
		UnitsAvailable -= ToTransfer;
	}
//DM( "@@@ " $ Self $ ".UnitsAvailable = " $ UnitsAvailable $ " Health = " $ TargetsCurrentUnits );
	if( UnitsAvailable <= 0 )
	{
		if( bIsStation )
		{
			MakeStationEmpty();
		}
		else  // Is a pickup
		{
			Destroy();
		}
	}
}

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

function CheckStopStation( int MaxUnits, int TargetsCurrentUnits )
{
	if( bIsStation && TargetsCurrentUnits == MaxUnits )
		StopStation();
}

//-----------------------------------------------------------------------------
// Manages the dispersal of powerup units

simulated event Tick(float DeltaTime)
{
	local int ToTransfer;
	local int MaxPower;
	local int Power;

	Super.Tick( DeltaTime );

	if( PowerUpOwner != None )
	{
//DM( "@@@ " $ Self $ ".Tick.LastTransferTime = "	$ LastTransferTime );
		if( PowerUpOwner.Health > 0 )
		{
			if( TargetPowerSuit == None )
			{
				// Player does not have a PowerSuit, but it is a Health PowerUp
				if( HealthUnits > 0 )
				{
					TickPowerUp( HealthUnits, PowerUpOwner.default.Health, PowerUpOwner.Health );
					if( PowerUpOwner != None )
						CheckStopStation( PowerUpOwner.default.Health, PowerUpOwner.Health );
				}
				else
					// Exception, should only happen if player has no PowerSuit and pickup is not for Health
					return;
			}	
			else
			{
				if( EnergyUnits > 0 )
				{
					MaxPower = int(TargetPowerSuit.MaxPower);
					Power = int(TargetPowerSuit.Power);
					TickPowerUp( EnergyUnits, MaxPower, Power );
					if( TargetPowerSuit != None )
					{
						TargetPowerSuit.Power = float(Power);
						CheckStopStation( MaxPower, Power );
					}
				}
				if( HealthUnits > 0 )
				{
					TickPowerUp( HealthUnits, PowerUpOwner.default.Health, PowerUpOwner.Health );
					if( PowerUpOwner != None )
						CheckStopStation( PowerUpOwner.default.Health, PowerUpOwner.Health );
				}
			}
		}
	}
}

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

defaultproperties
{
	bMergesCopies=true
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}