U2XMP.Replicator

//=============================================================================
// $Workfile: Replicator.uc $
// Created By: Mark Poesch
// Created On: 6/22/2001
// $Author: Mfox $
// $Date: 1/29/03 4:25p $
// $Revision: 13 $
//=============================================================================
class Replicator extends Actor
	placeable;

//#exec OBJ LOAD File=..\StaticMeshes\XMPM.usx
//#exec OBJ LOAD File=..\Textures\XMPT.utx
#exec OBJ LOAD File=..\Sounds\U2XMPA.uax

var() int    TeamNumber;			//
var() string TeamRaceClass;			// Marine, MercJap, MercFem
var() int    EnergyLevel;			// base rate at which energy can be  spent to produce an item (units / second)
var() int    ItemLimit;				// max number of items that can be built concurrently
var() struct S_ItemList				// knowledge base for the Replicator
{
	var() int    ResearchTime;		// time to take before Item is available (seconds), typically 60 to 600
	var() string ItemName;			// Weapons(?), Ammo(?), EnergyRelay, ForceFieldGenerator, Sensor, Camera, Turret, SecurityBot
	var() int    EnergyCost;		// quantity of energy required to produce this item
	var() int    ItemsQueued;		// item count to build
	var() int	 BuildPriority;		// the priority level for the production of this item
	var bool     bBuild;			// when true, Replicator is working on this Item
	var float    EnergySpent;		// accumulates energy spent on Item
	var bool     bAvailable;		// set true when research is completed
									// Level of energy focused on production of this Item
} ItemList[32];
var() bool  bAutoConfigure;			// set false as soon as the player adjusts the replicator
var() float ResearchDelay;			//
var() float MinAutoAdjustmentDelay;	//
var() float MaxAutoAdjustmentDelay;	//
var() float ReplicationDelay;		//
var() int   Health;					// replicators can not be destroyed, but they stop functioning when Health < default.Health
var() int   RepairRate;				// 
var() float PriorityMax;			// max priority level available
var() localized string Description;	// 
var bool    bEnabled;				// set true when match starts, set false when Replicator Health is below normal
var float   ResearchStartTime;		//
var float   NextResearchTime;		//
var float   NextAdjustmentTime;		//
var float   NextReplicationTime;	//
var bool    bAccessed;				// true when one of the team members is accessing the Replicator
var float   MinOperationalHealth;	//

var sound AccessingSound;			//
var sound RepairingSound;			//
var sound AccessDeniedSound;		//
var sound AccessCompleteSound;		//
var sound RegisterArtifactSound;	//
var sound ResearchCompleteSound;	//
var sound ProductionInitiatedSound; //
var sound ProductionCompleteSound;	//

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

event PostBeginPlay()
{
	super.PostBeginPlay();

	assert( TeamNumber  >= 0 && TeamNumber < U2TeamGame(Level.Game).NumTeams ); // level-designers MUST set the Team

	bEnabled = false;
	bAutoConfigure = false;
}

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

function MatchStarting() //not implemented: reimplement with invokation from U2XMPGameInfo or PostBeginPlay for SP games
{
	local U2XMPGame XMP;

	XMP = U2XMPGame(Level.Game);
	if( XMP != None )
	{
		if( XMP.EnergyLevel > 0 )
			EnergyLevel = XMP.EnergyLevel;

		if( XMP.ItemLimit > 0 )
			ItemLimit = XMP.ItemLimit;
	}

	bEnabled = true;

	ResearchStartTime = Level.TimeSeconds;

	NextResearchTime = Level.TimeSeconds;

	bAutoConfigure = true;
	ResetAdjustmentTime();

	NextReplicationTime = Level.TimeSeconds;
}

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

function ResetAdjustmentTime()
{
	NextAdjustmentTime = Level.TimeSeconds + RandRange( MinAutoAdjustmentDelay, MaxAutoAdjustmentDelay );
}

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

function bool IsUsable( optional Actor Other )
{
	// 2003.01.29 (mdf) fix for adding timers (etc.) to invalid (e.g. deleted) actors
	if( bDeleteMe )
		return false;

	assert( Controller(Other) != None );
	return U2PlayerXMP(Controller(Other).Pawn) != None && U2PlayerXMP(Controller(Other).Pawn).CanAccessReplicator( TeamNumber );
}

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

function string GetDescription()
{
	return Description $ TeamNumber; //localize
}

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

function OnUse( Actor Other )
{
	// allow user to register their artifact (if it hasn't been registered)
	assert( Controller(Other) != None );
	if( U2PlayerXMP(Controller(Other).Pawn) != None && U2PlayerXMP(Controller(Other).Pawn).HasUnregisteredArtfiact( TeamNumber ) )
	{
		PlaySound( RegisterArtifactSound, SLOT_None );
		U2PlayerXMP(Controller(Other).Pawn).RegisterArtifact( TeamNumber );
		return;
	}

	// if replicator is in use, abort and play sound
	if( bAccessed )
	{
		PlaySound( AccessDeniedSound, SLOT_None );
		return;
	}

	// access replicator -- heal the replicator if it's damaged, otherwise, initiate control dialog
	bAccessed = true;
	if( Health < default.Health )
	{
		PlaySound( RepairingSound, SLOT_None );
	}
	else
	{
		PlaySound( AccessingSound, SLOT_None );

		AdjustProductionAvailability(); //TBI initiate dialog 
	}
}

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

function OnUnuse( Actor Other )
{
	if( bAccessed )
	{
		bAccessed = false;
		PlaySound( AccessCompleteSound, SLOT_None );
	}
}

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

function SetNewPriority( string ItemName, int NewPriority )
{
	local int i;

	for( i=0; i<ArrayCount(ItemList); i++ )
	{
		if( ItemList[i].ItemName == ItemName )
		{
			ItemList[i].BuildPriority = NewPriority;
			break;
		}
	}
}

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

function SetNewQueue( string ItemName, int ModifyBy )
{
	local int i;

	for( i=0; i<ArrayCount(ItemList); i++ )
	{
		if( ItemList[i].ItemName == ItemName )
		{
			ItemList[i].ItemsQueued += ModifyBy;
			// Play ProductionInitiatedSound
			break;
		}
	}
}

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

function int GetRelayEnergy()
{
	local int RelayEnergy;
	local int	i;
	local EnergyRelay ER;

	foreach allactors(class'EnergyRelay',ER)
	{
		if( ER.TeamNumber == TeamNumber )
		{
			RelayEnergy += ER.GetEnergy();
		}
	}

	return RelayEnergy;
}

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

function int GetItemCount()
{
	local int i;
	local int Items;

	for( i = 0; i < ArrayCount(ItemList); i++ )
	{
		if( ItemList[i].bBuild && ItemList[i].ItemsQueued > 0 )
		{
			Items++;
		}
	}

	return Items;
}

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

function float CalcExtraEnergy( float BuildPriority )
{
	local float		ModifiedExtraEnergy;
	local float		TotalPriority;
	local float		ItemCount;
	local int		i;

	for( i=0; i< ArrayCount(ItemList); i++ )
	{
		if( ItemList[i].bBuild && ItemList[i].ItemsQueued > 0 )
		{
			TotalPriority += ItemList[i].BuildPriority;
		}
	}
	ItemCount = GetItemCount();
	ModifiedExtraEnergy = (((ItemCount * PriorityMax) / TotalPriority) * GetRelayEnergy()) / ItemCount;
	return (BuildPriority / PriorityMax) * ModifiedExtraEnergy;
}

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

function UpdateResearchStatus()
{
	local float PctCompleted;
	local int i;

	for( i = 0; i < ArrayCount(ItemList); i++ )
	{
		PctCompleted = PctResearchCompleted( i );
		if( ItemList[i].ItemName != "" && !ItemList[i].bAvailable && PctCompleted >= 100 )
		{
//DM( "    " $ Self $ " " $ ItemList[i].ItemName $ " available for construction!" );
			ItemList[i].bAvailable = true;
			PlaySound( ResearchCompleteSound, SLOT_None );
//DM( "    " $ Self $ " " $ " Setting " $ ItemList[i].ItemName $ " bAvailable = " $ ItemList[i].bAvailable );
		}
//		else if( ItemList[i].ItemName != "" && !ItemList[i].bAvailable )
//			DM( "*** " $ ItemList[i].ItemName $ " PctCompleted = " $ PctCompleted );
	}
}

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

function float PctResearchCompleted( int Index )
{
	local float ResearchTime;

	ResearchTime = Level.TimeSeconds - ResearchStartTime;

	return (ResearchTime / ItemList[Index].ResearchTime) * 100;
}

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

function AdjustProductionAvailability()
{
	local int i;

	for( i = 0; i < ArrayCount(ItemList); i++ )
	{
		if( ItemList[i].bAvailable && !ItemList[i].bBuild && ItemList[i].ItemsQueued > 0 )
		{
//DM(  Self $ " Constructing "$ ItemList[i].ItemName );
			ItemList[i].bBuild = true;
		}
	}
}

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

function bool Replicate( string ItemName )
{
	local bool bValid;
	local int	i;
	local ReplicatorSpawnPoint RSP;

	foreach allactors(class'ReplicatorSpawnPoint',RSP)
	{
		bValid = RSP.IsAvailable( TeamNumber, ItemName );
		if( bValid )
		{
			RSP.SpawnActor( ItemName );
			DM( "$$$ " $ Self $ " Construction of "$ ItemName $" complete at " $ RSP $ "!" );
			PlaySound( ProductionCompleteSound, SLOT_None );
			return bValid;
		}
	}

//	if( !bValid )
//		DM( "!!! " $ Self $ " Construction failed, no spawn points available for " $ ItemName $ "." );
	
	return bValid;
}

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

function UpdateReplication( float DeltaTime )
{
	local float AvailableEnergy;
	local int i;
	local int ItemCount;
	local bool bReplicated;

	// compute energy available for each Item in production
	ItemCount = GetItemCount();
//DM( "@@@ " $ Self $ " ItemCount = " $ ItemCount );
	AvailableEnergy = EnergyLevel * DeltaTime;
	if( ItemCount > 0 )
	{
		AvailableEnergy /= ItemCount;
	}
//DM( "*** AvailableEnergy for " $ Self $ " = " $ AvailableEnergy );
	for( i = 0; i < ArrayCount(ItemList); i++ )
	{
		// check if this item is ready to be replicated
		if( ItemList[i].bBuild && ItemList[i].ItemsQueued > 0 )
		{
			if( ItemList[i].EnergySpent >= ItemList[i].EnergyCost )
			{
				bReplicated = Replicate( ItemList[i].ItemName );
				if( bReplicated )
				{
					ItemList[i].ItemsQueued--;
					ItemList[i].EnergySpent = 0;				
				}
//DM( "*** " $ Self $ " " $ ItemList[i].ItemsQueued $ " " $ ItemList[i].ItemName $ " queued for construction." );
				if( ItemList[i].ItemsQueued == 0 )
					ItemList[i].bBuild = false;
//DM( "*** " $ ItemList[i].ItemName $ " has finished being replicated." );
			}
			else // apply energy
			{
				ItemList[i].EnergySpent += AvailableEnergy + CalcExtraEnergy( ItemList[i].BuildPriority );
//DM( "*** " $ Self $ " EnergySpent on " $ ItemList[i].ItemName $ " = " $ ItemList[i].EnergySpent );
DM( "*** " $ Self $ " Contributing " $ AvailableEnergy $ " Energy + " $ CalcExtraEnergy( ItemList[i].BuildPriority ) $ " (@BuildPriority=" $ ItemList[i].BuildPriority $ ") Extra Energy to " $ ItemList[i].ItemName $ ", " $ ItemList[i].EnergyCost - ItemList[i].EnergySpent $ " Energy needed to finish construction." );
			}
		}
	}
}

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

event Tick( float DeltaTime )
{
	if( Health < default.Health )
	{
		if( bAccessed )
		{
			Health += RepairRate * DeltaTime;
			if( Health >= default.Health )
			{
				bEnabled = true;

				Health = default.Health;

				OnUnuse( self ); // stop healing
			}
		}
	}
	else if( bEnabled )
	{
		if( Level.TimeSeconds > NextResearchTime )
		{
			UpdateResearchStatus();
			NextResearchTime = Level.TimeSeconds + ResearchDelay;
		}

		if( bAutoConfigure && Level.TimeSeconds > NextAdjustmentTime )
		{
			AdjustProductionAvailability();
			ResetAdjustmentTime();
		}

		if( Level.TimeSeconds > NextReplicationTime )
		{
			UpdateReplication( ReplicationDelay );
			NextReplicationTime = Level.TimeSeconds + ReplicationDelay;
		}
	}
}

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

function TakeDamage( int Damage, Pawn instigatedBy, vector hitlocation, vector momentum, class<DamageType> damageType)
{

	if( Health > Damage )
		Health -= Damage;
	else
		Health = 0;

	if( bEnabled && Health < MinOperationalHealth )
	{
		U2GameInfo(Level.Game).ScoreReplicatorShutdown( instigatedBy );
		bEnabled = false;
	}
}

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

defaultproperties
{
	TeamNumber=255
	EnergyLevel=10000
	ItemLimit=4
	ItemList(0)=(ResearchTime=5,ItemName="U2XMP.EnergyRelayPickup",EnergyCost=1500,ItemsQueued=2,BuildPriority=1)
	ItemList(1)=(ResearchTime=60,ItemName="U2XMP.FieldGeneratorPickup",EnergyCost=5000,ItemsQueued=2,BuildPriority=1)
	ItemList(2)=(ResearchTime=90,ItemName="U2XMP.ProximitySensorPickup",EnergyCost=4000,ItemsQueued=2,BuildPriority=1)
	ItemList(3)=(ResearchTime=120,ItemName="U2XMP.AutoTurretPickup",EnergyCost=4500,ItemsQueued=2,BuildPriority=1)
	ItemList(4)=(ResearchTime=130,ItemName="U2XMP.CameraPickup",EnergyCost=3500,BuildPriority=1)
	ItemList(5)=(ResearchTime=180,ItemName="U2XMP.SecurityBotPickup",EnergyCost=3500,BuildPriority=1)
	ItemList(6)=(ItemName="U2XMP.AmmoPackLightPickup",EnergyCost=2500,ItemsQueued=2,BuildPriority=1)
	ItemList(7)=(ItemName="U2XMP.AmmoPackMediumPickup",EnergyCost=2500,ItemsQueued=2,BuildPriority=1)
	ItemList(8)=(ItemName="U2XMP.AmmoPackHeavyPickup",EnergyCost=2500,ItemsQueued=2,BuildPriority=1)
	bAutoConfigure=true
	ResearchDelay=5.000000
	MinAutoAdjustmentDelay=20.000000
	MaxAutoAdjustmentDelay=60.000000
	ReplicationDelay=1.000000
	Health=1000
	RepairRate=100
	PriorityMax=5.000000
	Description="Replicator for Team "
	MinOperationalHealth=500.000000
	AccessingSound=Sound'U2XMPA.Replicator.ReplicatorAccessing'
	RepairingSound=Sound'U2XMPA.Replicator.ReplicatorRepairing'
	AccessDeniedSound=Sound'U2XMPA.Replicator.ReplicatorAccessDenied'
	AccessCompleteSound=Sound'U2XMPA.Replicator.ReplicatorAccessComplete'
	RegisterArtifactSound=Sound'U2XMPA.Replicator.ReplicatorRegisterArtifact'
	ResearchCompleteSound=Sound'U2XMPA.Replicator.ReplicatorResearchComplete'
	ProductionInitiatedSound=Sound'U2XMPA.Replicator.ReplicatorProductionInitiated'
	ProductionCompleteSound=Sound'U2XMPA.Replicator.ReplicatorProductionComplete'
	DrawType=DT_None
	CollisionRadius=50.000000
	CollisionHeight=60.000000
	bCollideActors=true
	bBlockActors=true
	bBlockPlayers=true
	bProjTarget=true
	bNoStaticMeshCollide=true
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}