Onslaught.ONSPlayerReplicationInfo

class ONSPlayerReplicationInfo extends xPlayerReplicationInfo
	config(user);

var ONSPowerCore StartCore; //always try to spawn player here. None means auto-select, value ignored if TemporaryStartCore != None
var ONSPowerCore TemporaryStartCore; //next time player respawns try to put him here (then this value is cleared)

enum EMapPreference
{
	MAP_Never,
	MAP_WhenBodyStill,
	MAP_Immediately
};

var globalconfig EMapPreference ShowMapOnDeath;
var bool bPendingMapDisplay;
var globalconfig string LinkDesignerClass;	//class of Link Designer menu
var Material TransMaterials[2];
var float PendingHealBonus; //node healing score bonus that hasn't yet been added to Score

replication
{
	reliable if (bNetDirty && Role == ROLE_Authority)
		StartCore;
	reliable if (Role < ROLE_Authority)
		SetStartCore, ServerSendPowerLinks, ServerReceivePowerLink, ServerRemovePowerLink, ServerClearPowerLinks, ServerSendSetupNames,
		ServerSetPowerLinkSetup, ServerSavePowerLinkSetup, ServerDeletePowerLinkSetup, RequestLinkDesigner, TeleportTo;
	reliable if (Role == ROLE_Authority)
		ClientPrepareToReceivePowerLinks, ClientReceivePowerLink, ClientRemovePowerLink, ClientReceiveSetupName,
		ClientReceiveCurrentSetup, ClientShowMap;
}

//these are set by the link designer
delegate OnReceiveLink( ONSPowerCore A, ONSPowerCore B );
delegate OnRemoveLink( ONSPowerCore A, ONSPowerCore B );
delegate ResetLinks();
delegate ProcessSetupName(string SetupName);
delegate RemoveSetupName(string SetupName);
delegate SetCurrentSetup(string SetupName);
delegate UpdateGUIMapLists(); //listen/standalone servers only

function SetStartCore(ONSPowerCore Core, bool bTemporary)
{
	if ( Core == None || ONSOnslaughtGame(Level.Game).ValidSpawnPoint(Core, Team.TeamIndex))
	{
		if (bTemporary)
			TemporaryStartCore = Core;
		else
			StartCore = Core;
	}
}

// returns the powecore/node the player is currently standing on or in the node teleport trigger radius of,
// if that core/node is currently constructed for the same team as the player
simulated function ONSPowerCore GetCurrentNode()
{
	local ONSPowerCore Core;
	local ONSPCTeleportTrigger T;

	if (Controller(Owner).Pawn != None)
	{
		if (Controller(Owner).Pawn.Base != None)
		{
			Core = ONSPowerCore(Controller(Owner).Pawn.Base);
			if (Core == None)
				Core = ONSPowerCore(Controller(Owner).Pawn.Base.Owner);
		}

		if (Core == None)
			foreach Controller(Owner).Pawn.TouchingActors(class'ONSPCTeleportTrigger', T)
			{
				Core = ONSPowerCore(T.Owner);
				if (Core != None)
					break;
			}
	}

	if (Core != None && Core.CoreStage == 0 && Core.DefenderTeamIndex == Team.TeamIndex)
		return Core;

	return None;
}

function TeleportTo(ONSPowerCore Core)
{
	local ONSPowerCore OldStartCore;
	local ONSPowerCore OwnerBase;

	OwnerBase = GetCurrentNode();
	if (OwnerBase != None && ONSOnslaughtGame(Level.Game).ValidSpawnPoint(Core, Team.TeamIndex))
	{
		OldStartCore = StartCore;
		StartCore = Core;
		if (!DoTeleport() && !DoTeleport()) //two tries
		{
			//FIXME error localmessage here!
		}
		StartCore = OldStartCore;
	}
}

function bool DoTeleport()
{
	local NavigationPoint NewStart;
	local vector PrevLocation;

	PrevLocation = Controller(Owner).Pawn.Location;
	NewStart = Level.Game.FindPlayerStart(Controller(Owner));
	if (NewStart != None && Controller(Owner).Pawn.SetLocation(NewStart.Location))
	{
		Controller(Owner).ClientSetRotation(NewStart.Rotation);
		if (xPawn(Controller(Owner).Pawn) != None)
			xPawn(Controller(Owner).Pawn).DoTranslocateOut(PrevLocation);
		Controller(Owner).Pawn.SetOverlayMaterial(TransMaterials[Team.TeamIndex], 1.0, false);
		Controller(Owner).Pawn.PlayTeleportEffect(false, false);
		return true;
	}

	return false;
}

function OwnerDied()
{
	if (PlayerController(Owner) != None )
		ClientShowMap();
}

simulated function ClientShowMap()
{
	if (ShowMapOnDeath > MAP_Never)
	{
		bPendingMapDisplay = true;
		SetTimer(0.75, true);
	}
}

simulated event Timer()
{
	local PlayerController PC;

	if (bPendingMapDisplay)
	{
		PC = Level.GetLocalPlayerController();
		if (PC != None && !PC.bDemoOwner && PC.Player != None && GUIController(PC.Player.GUIController) != None && !GUIController(PC.Player.GUIController).bActive)
		{
			if (PC.Pawn != None && PC.Pawn.Health > 0) //never automatically pop up map while player is playing!
			{
				bPendingMapDisplay = false;
				SetTimer(0, false);
			}
			else if (ShowMapOnDeath == MAP_Immediately || PC.ViewTarget == None || PC.ViewTarget == PC || VSize(PC.ViewTarget.Velocity) < 100)
			{
				PC.bMenuBeforeRespawn = false;
				bPendingMapDisplay = false;
				SetTimer(0, false);
				PC.ShowMidGameMenu(false);
			}
			else
				PC.bMenuBeforeRespawn = true;
		}
		else
		{
			bPendingMapDisplay = False;
			SetTimer(0, false);
		}
	}

	Super.Timer();
}

simulated function ClientPrepareToReceivePowerLinks()
{
	ResetLinks();
}

function ServerSendPowerLinks()
{
	local int i;
	local ONSOnslaughtGame Game;

	Game = ONSOnslaughtGame(Level.Game);
	for ( i = 0; i < Game.PowerLinks.Length; i++ )
		ClientReceivePowerLink(Game.PowerLinks[i].Nodes[0].Node, Game.PowerLinks[i].Nodes[1].Node);
}

simulated function ClientReceivePowerLink(ONSPowerCore From, ONSPowerCore To)
{
//	log(Name@"ClientReceivePowerLink A:"$From.Name@"B:"$To.Name);
	OnReceiveLink(From,To);
}

simulated function ClientRemovePowerLink(ONSPowerCore From, ONSPowerCore To)
{
	OnRemoveLink(From,To);
}

function ServerReceivePowerLink(ONSPowerCore From, ONSPowerCore To)
{
	local int i;
	local GameReplicationInfo GRI;

	if (PlayerController(Owner) == None || (Owner != Level.GetLocalPlayerController() && !bAdmin) || From == To)
		return;

	if ( ONSOnslaughtGame(Level.Game).AddLink(From,To) )
	{
		ONSOnslaughtGame(Level.Game).UpdateLinks();
		GRI = Level.Game.GameReplicationInfo;
		for ( i = 0; i < GRI.PRIArray.Length; i++ )
		{
			if ( PlayerController(GRI.PRIArray[i].Owner) == None ||
				 ONSPlayerReplicationInfo(GRI.PRIArray[i]) == None )
				continue;

			ONSPlayerReplicationInfo(GRI.PRIArray[i]).ClientReceivePowerLink(From,To);
		}
	}

}

function ServerRemovePowerLink(ONSPowerCore From, ONSPowerCore To)
{
	local int i;
	local GameReplicationInfo GRI;

	if (PlayerController(Owner) == None || (Owner != Level.GetLocalPlayerController() && !bAdmin) || From == To)
		return;

	if ( ONSOnslaughtGame(Level.Game).RemoveLink(From,To) )
	{
		ONSOnslaughtGame(Level.Game).UpdateLinks();
		GRI = Level.Game.GameReplicationInfo;
		for ( i = 0; i < GRI.PRIArray.Length; i++ )
		{
			if ( PlayerController(GRI.PRIArray[i].Owner) == None ||
				 ONSPlayerReplicationInfo(GRI.PRIArray[i]) == None )
				continue;

			ONSPlayerReplicationInfo(GRI.PRIArray[i]).ClientRemovePowerLink(From,To);
		}
	}
}

function ServerClearPowerLinks()
{
	local int i;
	local ONSOnslaughtGame Game;

	Game = ONSOnslaughtGame(Level.Game);

	while (Game.PowerLinks.length > 0)
		ServerRemovePowerLink(Game.PowerLinks[i].Nodes[0].Node, Game.PowerLinks[i].Nodes[1].Node);
}

function ServerSendSetupNames()
{
	local int x;

	for (x = 0; x < ONSOnslaughtGame(Level.Game).OfficialPowerLinkSetups.length && x < 1000; x++)
		ClientReceiveSetupName(ONSOnslaughtGame(Level.Game).OfficialPowerLinkSetups[x].SetupName);

	for (x = 0; x < ONSOnslaughtGame(Level.Game).CustomPowerLinkSetups.length && x < 1000; x++)
		ClientReceiveSetupName(string(ONSOnslaughtGame(Level.Game).CustomPowerLinkSetups[x].Name));

	ClientReceiveSetupName("");		//Indicate end of setup names

	ClientReceiveCurrentSetup(ONSOnslaughtGame(Level.Game).CurrentSetupName);
}

simulated function ClientReceiveSetupName(string SetupName)
{
	ProcessSetupName(SetupName);
}

simulated function ClientReceiveCurrentSetup(string SetupName)
{
	SetCurrentSetup(SetupName);
}

function ServerSetPowerLinkSetup(string SetupName)
{
	if (PlayerController(Owner) == None || (Owner != Level.GetLocalPlayerController() && !bAdmin))
		return;

	ONSOnslaughtGame(Level.Game).SetPowerLinkSetup(SetupName, PlayerController(Owner));
}

function ServerSavePowerLinkSetup(string SetupName)
{
	local array<ONSPowerCore> Traveled;

	if (PlayerController(Owner) == None || (Owner != Level.GetLocalPlayerController() && !bAdmin))
		return;

	if ( !ONSOnslaughtGame(Level.Game).ExistsLinkPathTo( ONSOnslaughtGame(Level.Game).PowerCores[ONSOnslaughtGame(Level.Game).FinalCore[0]],
							     ONSOnslaughtGame(Level.Game).PowerCores[ONSOnslaughtGame(Level.Game).FinalCore[1]],
							     Traveled ) )
	{
		PlayerController(Owner).ReceiveLocalizedMessage(class'ONSLinkDesignMessage', 7);
		return;
	}

	if (ONSOnslaughtGame(Level.Game).SavePowerLinkSetup(SetupName, PlayerController(Owner)))
	{
		ClientReceiveSetupName(SetupName);
		UpdateGUIMapLists();
	}
}

function ServerDeletePowerLinkSetup(string SetupName)
{
	if (PlayerController(Owner) == None || (Owner != Level.GetLocalPlayerController() && !bAdmin))
		return;

	if (ONSOnslaughtGame(Level.Game).DeletePowerLinkSetup(SetupName, PlayerController(Owner)))
	{
		ClientRemoveSetupName(SetupName);
		UpdateGUIMapLists();
	}
}

simulated function ClientRemoveSetupName(string SetupName)
{
	RemoveSetupName(SetupName);
}

function RequestLinkDesigner()
{
	if (PlayerController(Owner) != None && (Owner == Level.GetLocalPlayerController() || bAdmin))
		PlayerController(Owner).ClientOpenMenu(LinkDesignerClass);
}

//scoring bonus for healing powernodes
//we wait until the healing bonus >= 1 point before adding to score to minimize ScoreEvent() calls
function AddHealBonus(float Bonus)
{
	PendingHealBonus += Bonus;
	if (PendingHealBonus >= 1.f)
	{
		Level.Game.ScoreObjective(self, PendingHealBonus);
		Level.Game.ScoreEvent(self, PendingHealBonus, "heal_powernode");
		PendingHealBonus = 0;
	}
}

function Reset()
{
	HasFlag = None;
	NumLives = 0;
	bOutOfLives = false;
}

defaultproperties
{
     ShowMapOnDeath=MAP_WhenBodyStill
     LinkDesignerClass="GUI2K4.UT2K4OnslaughtPowerLinkDesigner"
     TransMaterials(0)=Shader'XGameShaders.PlayerShaders.PlayerTransRed'
     TransMaterials(1)=Shader'XGameShaders.PlayerShaders.PlayerTrans'
}