U2.PowerStation

//=============================================================================
// PowerStation.uc
//=============================================================================

class PowerStation extends PowerUp;

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

enum EStationTypes
{
	ST_Energy,
	ST_Health
};

var() bool	  bLimited;					// If Limited, the station deactivates when units are consumed,
										// else stops working when  units are consumed, but will recharge
										// them over time.
var() float   RechargeRate;				// If !bLimited, rate at which units are recharged.
var() Texture StationActiveTexture;		// Station is active useable
var() Texture StationInactiveTexture;	// Station is not useable
var() Texture StationInUseTexture;		// Station is being used
var() Sound   StationStartUsingSound;   // Pawn starts using the station
var() Sound   StationStopUsingSound;	// Pawn stops using the station
var() Sound   StationInUseSound;		// Station is being used by the pawn
var() Sound   StationErrorSound;		// Station cannot be used or stops
var() bool    bSwapTextures;
var   float   DelayTime;
var   float   LastRechargeTime;
var	  int     StartingEnergyUnits;
var   int     StartingHealthUnits;
var   PowerStationCollisionProxy TouchingCollisionProxy;
var   float   TouchingHeight, TouchingRadius;
/* Not used yet
var   float   UseHeight, UseRadius;
var   float   UseXOffset, UseYOffset, UseZOffset;
var   CollisionProxy UseCollisionProxy;
*/
var   bool    bIsUsable; //!!SBB (mdf) remove?

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

event PreBeginPlay()
{
	Super.PreBeginPlay();

	if( !bLimited )
	{
		StartingHealthUnits = HealthUnits;
		StartingEnergyUnits = EnergyUnits;
	}
	TouchingCollisionProxy = Spawn( class'PowerStationCollisionProxy' );
	TouchingCollisionProxy.CP_SetCollision( true, false, false );
	TouchingCollisionProxy.CP_SetLocation( Location );
	TouchingCollisionProxy.CP_SetCollisionSize( TouchingRadius, TouchingHeight );
	TouchingCollisionProxy.CP_SetTouchTarget( Self );
	TouchingCollisionProxy.SetBase( Self );
	/* Not used yet
	UseCollisionProxy = Spawn( class'CollisionProxy' );
	UseCollisionProxy.CP_SetCollision( true, false, false );
	UseCollisionProxy.CP_SetLocation( Location + vect(1,0,0)*UseXOffset + vect(0,1,0)*UseYOffset + vect(0,0,1)*UseZOffset );
	UseCollisionProxy.CP_SetCollisionSize( UseRadius, UseHeight );
	UseCollisionProxy.CP_SetTouchTarget( Self );
	UseCollisionProxy.SetBase( Self );
	*/
}

//-----------------------------------------------------------------------------
// Activates when the pawn 'uses' a station

simulated function OnUse( Actor Other );
//-----------------------------------------------------------------------------
// Pawn stops using station

simulated function OnUnuse( Actor Other );

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

//!!SBB (mdf) remove?
simulated function bool IsUsable( Actor Other )
{ 
	return false;
}

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

simulated function string GetDescription()
{
	return Description;
}

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

simulated function ClearProperties()
{
	AmbientSound = None;
	TargetPowerSuit = None;
	PowerUpOwner = None;
}

//-----------------------------------------------------------------------------
// This function occurs when a station is either empty, the pawn's units are
// full or potentially if the station is damaged (no determination on this yet).

simulated function StationError()
{
	PlaySound( StationErrorSound, SLOT_None );
	ClearProperties();
	LastRechargeTime = Level.TimeSeconds;
//DM( "%%% " $ Self $ ".PowerStation.StationError() LastRechargeTime = " $ LastRechargeTime );
}

//-----------------------------------------------------------------------------
// Turn station off and set texture back to active

simulated function SetStationActiveOff()
{
	if( bSwapTextures )
		Skins[0] = StationActiveTexture;
	ClearProperties();
	LastRechargeTime = Level.TimeSeconds;
//DM( "%%% " $ Self $ ".PowerStation.SetStationActiveOff() LastRechargeTime = " $ LastRechargeTime );
}

//-----------------------------------------------------------------------------
// Play in use sound, set ambient sound, change skin to in use and set the
// transfer time for the powerup calculation code.

simulated function SetStationInUse()
{
	PlaySound( StationStartUsingSound, SLOT_None );
	AmbientSound = StationInUseSound;
	if( bSwapTextures )
		Skins[0] = StationInUseTexture;
	LastTransferTime = Level.TimeSeconds;
}

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

simulated function MakeStationEmpty()
{
	if( bSwapTextures )
		Skins[0] = StationInactiveTexture;
	StationError();
}

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

simulated function StopStation()
{
	SetStationActiveOff();
	StationError();
}

//-----------------------------------------------------------------------------
// Set up station for use

simulated function ActivateStation( Pawn P )
{
	TargetPowerSuit = PowerSuit(class'UtilGame'.static.GetInventoryItem( P, class'PowerSuit' ));
	PowerUpOwner = P;

	if( TargetPowerSuit == None )
	{
		// Pawn does not have a PowerSuit, but it is a Health Station
		if( HealthUnits > 0 && P.Health < P.default.Health )
		{
			SetStationInUse();
		}
		else // Container is full
		{
			StationError();
		}
	}
	else
	{
		if(		HealthUnits > 0 && P.Health < P.default.Health 
			||	EnergyUnits > 0 && TargetPowerSuit.Power < TargetPowerSuit.MaxPower )
		{
			SetStationInUse();
		}
		else // Container is full
		{
			StationError();
		}
	}
}

//-----------------------------------------------------------------------------
// Resets a stations sounds and textures

simulated function DeactivateStation()
{
	if( TargetPowerSuit == None )
	{
		if( PowerUpOwner != None )
		{
			// Pawn does not have a PowerSuit, but it is a Health Station
			//DM( "*** PowerUpOwner=" $ PowerUpOwner );
			if( HealthUnits > 0 && PowerUpOwner.Health < PowerUpOwner.default.Health )
			{
				SetStationActiveOff();
				PlaySound( StationStopUsingSound, SLOT_None );
			}
		}
	}
	else
	{
		if(		HealthUnits > 0 && PowerUpOwner.Health < PowerUpOwner.default.Health 
			||	EnergyUnits > 0 && TargetPowerSuit.Power < TargetPowerSuit.MaxPower )
		{
			SetStationActiveOff();
			PlaySound( StationStopUsingSound, SLOT_None );
		}
	}
}

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

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

	if( RechargeRate == 0 )
	{
		//recharge all
		ToTransfer = CalcUnits;
	}
	else
	{
//DM( "%%% " $ RechargeRate $ " * " $ CurrentTime $ " - " $ LastRechargeTime );
		if( LastRechargeTime != 0 )
		{
			ToTransfer = RechargeRate * (CurrentTime - LastRechargeTime);
//DM( "%%% " $ Self $ ".ToTransfer = " $ ToTransfer );
			if( ToTransfer > CalcUnits )
			{
				ToTransfer = CalcUnits;
			}
		}
		else
			ToTransfer = 0;
	}

	return ToTransfer;
}

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

event Touch( Actor Other );

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

event UnTouch( Actor Other );

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

function CleanupCollisionProxy( CollisionProxy CP )
{
	if( CP != None )
	{
		CP.Destroy();
		CP = None;
	}
}

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

event Destroyed()
{
	CleanupCollisionProxy( TouchingCollisionProxy );
	Super.Destroyed();
}

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

simulated event Tick(float DeltaTime)
{
	local float NewRechargeTime;

	Super.Tick( DeltaTime );

	if( !bLimited )
	{
		if( StartingEnergyUnits > 0 )
		{
			if( EnergyUnits < StartingEnergyUnits && PowerUpOwner == None )
			{
				NewRechargeTime = Level.TimeSeconds;
				if( NewRechargeTime - LastRechargeTime >= DelayTime )
				{
//DM( "### " $ Self $ " " $ StartingEnergyUnits $ " - " $ EnergyUnits $ " = " $ StartingEnergyUnits - EnergyUnits );
					EnergyUnits += CalcRecharge( StartingEnergyUnits - EnergyUnits, NewRechargeTime );
//DM( "### " $ Self $ ".EnergyUnits = " $ EnergyUnits );
					LastRechargeTime = NewRechargeTime;
				}
			}
		}
		else if( StartingHealthUnits > 0 )
		{
			if( HealthUnits < StartingHealthUnits && PowerUpOwner == None )
			{
				NewRechargeTime = Level.TimeSeconds;
				if( NewRechargeTime - LastRechargeTime >= DelayTime )
				{
//DM( "### " $ Self $ " " $ StartingHealthUnits $ " - " $ HealthUnits $ " = " $ StartingHealthUnits - HealthUnits );
					HealthUnits += CalcRecharge( StartingHealthUnits - HealthUnits, NewRechargeTime );
//DM( "### " $ Self $ ".HealthUnits = " $ HealthUnits );
					LastRechargeTime = NewRechargeTime;
				}
			}
		}
	}
}

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

defaultproperties
{
	bLimited=true
	RechargeRate=2.000000
	DelayTime=1.000000
	TouchingHeight=20.000000
	TouchingRadius=10.000000
	bHidden=false
	bOnlyOwnerSee=false
	bAlwaysRelevant=true
	RemoteRole=ROLE_DumbProxy
	bMustFace=false
	bTravel=false
	bCollideWorld=true
	bCanMantle=false
	bFixedRotationDir=true
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}