U2.U2TeamGame

//=============================================================================
// U2TeamGame.uc
// $Author: Mfox $
// $Date: 9/13/02 11:02a $
// $Revision: 12 $
//=============================================================================
class U2TeamGame extends U2DeathMatch
	config;


var localized string StartupMessage;			//
var localized string StartupTeamMessage;		//
var localized string StartupTeamTralier;		// terminator for StartupTeamMessage
var localized string TeamChangeMessage;			//
var localized string TeamColor[MaxTeams];		// Red, Blue, Green, Gold

var globalconfig bool bBalanceTeams;			// bots should move to balance teams when players are added in AddToTeam()
var globalconfig bool bPlayersBalanceTeams;		// force players to join the smallest team when changing teams
var() config int NumTeams;						// number of teams used by game type
var() config int MaxTeamSize;					// max number of playes per team for gamet pe
var() config bool bNoTeamChanges;				//
var() float Score_TeamKill;						//

var bool bSpawnInTeamArea;						//
var config bool bScoreTeamKills;				//
var int MaxAllowedTeams;						// maximum number of teams for this game type (limited to 2 in CTF)
var	protected U2TeamInfo Teams[MaxTeams];		//
var bool bBalancing;							// flag to signal that balancing teams is in progress
//!!mdf-obsolete? var int	NumSupportingPlayer;					// number of Bots supporting players -- //MDF this is never decremented!
var int	NextBotTeam;							//
var U2TeamInfo BestTeam;						// used in EndGame logic to determine the camera information


event PreBeginPlay()
{
	local int i;

	super.PreBeginPlay(); // init GameReplicationInfo in GameInfo.uc PreBeginPlay()

	for( i = 0; i < NumTeams; i++ )
	{
		Teams[i] = Spawn( class'U2TeamInfo' );
		Teams[i].TeamIndex = i;
		Teams[i].TeamName = TeamColor[i];
		Teams[i].Size = 0;
		Teams[i].Score = 0;
		U2GameReplicationInfo(GameReplicationInfo).SetTeam( i, Teams[i] );
DM( self @ i @ Teams[i] );
	}
}


function int GetTeamNumber()
{
	return CurrentID % NumTeams; // force each Bot to a unique team up to the NumTeams limit
}


function TeamInfo GetTeam( int InTeamNumber )
{
	if( InTeamNumber < 0 || InTeamNumber >= NumTeams )
		return None;

	return Teams[ InTeamNumber ];
}


function bool ValidTeam( int InTeamNumber )
{
	return InTeamNumber >= 0 && InTeamNumber < NumTeams;
}


event InitGame( string Options, out string Error )
{
	Super.InitGame( Options, Error );

	NumTeams = Min( NumTeams, Min( MaxAllowedTeams, MaxTeams ) );
}


function float RatePlayerStart( NavigationPoint N, byte Team, Controller Player )
{
	if( bSpawnInTeamArea && ( PlayerStart(N) == None || PlayerStart(N).TeamNumber != Team ) )
		return 0;

	return Super.RatePlayerStart( N, Team, Player );
}


function InitBot( U2NPCController NewBot )
{
	local int DesiredTeam, i, MinSize;

	if( bBalanceTeams )
	{
		MinSize = Teams[0].Size;
		DesiredTeam = 0;
		for( i = 1; i < NumTeams; i++ )
		{
			if( Teams[i].Size < MinSize )
			{
				MinSize = Teams[i].Size;
				DesiredTeam = i;
			}
		}
	}
	else
	{
		DesiredTeam = NewBot.PlayerReplicationInfo.Team.TeamIndex;
	}

	NewBot.PlayerReplicationInfo.Team = None;
	if( DesiredTeam == 255 || !ChangeTeam( NewBot, DesiredTeam ) )
	{
		ChangeTeam( NewBot, NextBotTeam );
		NextBotTeam++;
		if( NextBotTeam >= NumTeams )
			NextBotTeam = 0;
	}

	//!!mdf-tbd: SetBotOrders( NewBot );

	Super.InitBot( NewBot );
}


function PlayStartupMessage( PlayerController NewPlayer )
{
	local int i;

	NewPlayer.ClearProgressMessages();

	NewPlayer.SetProgressMessage( i++, GameName, GetWhiteColor() );
	if( bRequireReady && Level.NetMode != NM_Standalone )
		NewPlayer.SetProgressMessage( i++, TourneyMessage, GetWhiteColor() );
	else
		NewPlayer.SetProgressMessage( i++, StartupMessage, GetWhiteColor() );

	if( GoalScore > 0 )
		NewPlayer.SetProgressMessage( i++, GoalScore@GameGoal, GetWhiteColor() );

/* Fix ARL: Replace with cool UI stuff.
	if( NewPlayer.PlayerReplicationInfo.Team.TeamIndex < MaxTeams )
	{
		NewPlayer.SetProgressColor( NewPlayer.PlayerReplicationInfo.Team.TeamColor, i );
		NewPlayer.SetProgressMessage( i++, StartupTeamMessage @ NewPlayer.PlayerReplicationInfo.Team.TeamName $ StartupTeamTralier, GetWhiteColor() );
		NewPlayer.SetProgressMessage( i++, TeamChangeMessage, GetWhiteColor() );
	}
*/

	if( Level.NetMode == NM_Standalone )
		NewPlayer.SetProgressMessage( i++, SingleWaitingMessage, GetWhiteColor() );
}


function bool ChangeTeam( Controller Other, int InTeamNumber )
{
	local int i;
	local Controller C;
	local TeamInfo SmallestTeam, NewTeam;

	// if leaving the team, do it now!
	if( InTeamNumber == 255 )
	{
		Other.PlayerReplicationInfo.Team = None;
/*ARL
		if( StatLog != None )
			StatLog.LogTeamChange( Other );
*/
		return true;
	}

	// find a team with space remaining
	for( i = 0; i < NumTeams; i++ )
	{
		if( SmallestTeam == None || SmallestTeam.Size > Teams[i].Size )
		{
			SmallestTeam = Teams[i];
		}
	}
	assert( SmallestTeam != None );
	if( SmallestTeam.Size >= MaxTeamSize )
	{
		return false;
	}

	// get the player's team request -- revert to SmallestTeam if team is full or unavailable
	NewTeam = GetTeam( InTeamNumber );
	if( NewTeam == None || NewTeam.Size > MaxTeamSize )
	{
		NewTeam = SmallestTeam;
	}

	// ignore the player's request if the server is balancing teams
	if( bPlayersBalanceTeams && Level.NetMode != NM_Standalone )
	{
		for( C=Level.ControllerList; C!=None; C=C.NextController )
			if( U2NPCController(C)!=None )
				break;
		
		Other.PlayerReplicationInfo.Team = None;

		// join bot's team, because he will leave
		if( NumBots == 1 && C != None && C.PlayerReplicationInfo != None && C.PlayerReplicationInfo.Team.Size == SmallestTeam.Size )
		{					
			NewTeam = C.PlayerReplicationInfo.Team;
		}
		else if( NewTeam.Size > SmallestTeam.Size )
		{	
			NewTeam = SmallestTeam;
		}
	}

	if( Other.PlayerReplicationInfo.Team != None && ( Other.PlayerReplicationInfo.Team == NewTeam || bNoTeamChanges ) )
	{
		return false;
	}

	if( Other.PlayerReplicationInfo.Team != None )
	{
		//!!mdf-tbd: ClearOrders( Other.Pawn );
		Other.PlayerReplicationInfo.Team.RemoveFromTeam( Other );
	}

	NewTeam.AddToTeam( Other );

	if( !bGameEnded && bBalanceTeams )
		BalanceTeams();

	return true;
}


function Logout( Controller Exiting )
{
	super.Logout( Exiting );

	if( Exiting.IsA('PlayerController') && PlayerController(Exiting).bOnlySpectator )
		return;

	//!!mdf-tbd: ClearOrders( Exiting.Pawn );
	Exiting.PlayerReplicationInfo.Team.RemoveFromTeam( Exiting );
	
	if( !bGameEnded && bBalanceTeams )
		BalanceTeams();
}


function BalanceTeams()
{
	local int big, small, i, bigsize, smallsize;
	local Controller C, A;
	local U2NPCController B;

	if( bBalancing || NumBots == 0 )
		return;

	big = 0;
	small = 0;
	bigsize = Teams[0].Size;
	smallsize = Teams[0].Size;
	for( i = 1; i < NumTeams; i++ )
	{
		if( Teams[i].Size > bigsize )
		{
			big = i;
			bigsize = Teams[i].Size;
		}
		else if( Teams[i].Size < smallsize )
		{
			small = i;
			smallsize = Teams[i].Size;
		}
	}
	
	bBalancing = true;
	while( bigsize - smallsize > 1 )
	{
		for( C=Level.ControllerList; C!=None; C=C.NextController )
		{
			if( C.bIsPlayer && C.PlayerReplicationInfo.Team == Teams[ big ] && U2NPCController(C) != None )
			{
				B = U2NPCController(C);
				break;
			}
		}
		if( B != None )
		{
			B.Pawn.Health = 0;
			B.Pawn.Died( None, class'Suicided', B.Pawn.Location, vect(0,0,0) );
			bigsize--;
			smallsize++;
			ChangeTeam( B, small );
		}
		else
		{
			break;
		}
	}
	bBalancing = false;

	// re-assign orders to follower bots with no leaders
	// !!mdf-tbd: just send an event to the GameAIController and let it handle this
	for( C=Level.ControllerList; C!=None; C=C.NextController )
	{
		if( C.bIsPlayer && U2NPCController(C)!=None && U2BotReplicationInfo(C.PlayerReplicationInfo).RealOrders == U2NPCController.OrdersFollow )
		{
			A = Controller(U2NPCController(C).GetOrdersObject());
			if( A == None || A.bDeleteMe || !A.IsPlayer() || !A.Pawn.SameTeam( C.Pawn ) )
			{
					U2NPCController(C).SetOrders();
					//!!mdf-tbd: SetBotOrders( U2NPCController(C) );
			}
		}
	}
}


function bool CanSpectate( PlayerController Viewer, Actor ViewTarget )
{
	if( Controller(ViewTarget) != None )
		return false;

	if( Viewer.PlayerReplicationInfo.bIsSpectator && Viewer.PlayerReplicationInfo.Team == None )
		return true;

	return Pawn(ViewTarget) != None
		&& Pawn(ViewTarget).IsPlayerPawn() 
		&& Pawn(ViewTarget).PlayerReplicationInfo.Team == Viewer.PlayerReplicationInfo.Team;
}


function int ReduceFriendlyDamage( int Damage, Pawn Injured, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	if( U2NPCController(Injured.Controller)!=None )
		U2NPCController(Injured.Controller).YellAt( Instigator );
		
	return Super.ReduceFriendlyDamage( Damage, Injured, Instigator, HitLocation, Momentum, DamageType );
}

/*!!mdf-tbd
function int ReduceDamage( int Damage, Pawn Injured, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	if( U2NPCController(Injured.Controller)!=None )
		AssessBotDamage( Injured, Instigator );
	return Super.ReduceDamage( Damage, Injured, Instigator, HitLocation, Momentum, DamageType );
}
*/

function ScoreKill( Controller Killer, Controller Other )
{
	if( bScoreTeamKills && FriendlyDamageScale > 0 )
	{
		if( Killer == Other || Killer != None )
		{
			if( Other.PlayerReplicationInfo != None )
				Other.PlayerReplicationInfo.Team.Score += Score_Suicide;
		}
		else if( !Killer.Pawn.SameTeam( Other.Pawn ) )
		{
			if( Killer.PlayerReplicationInfo != None )
				Killer.PlayerReplicationInfo.Team.Score += Score_EnemyKill;
		}
		else
		{
			if( Killer.PlayerReplicationInfo != None )
			{
				Killer.PlayerReplicationInfo.Team.Score += Score_TeamKill;
				Killer.PlayerReplicationInfo.Score += Score_TeamKill;
			}
		}
	}

	super.ScoreKill( Killer, Other );
}


function bool IsTied()
{
	local int i;

	BestTeam = GetBestTeam();
	for( i = 0; i < NumTeams; i++ )
	{
		if( Teams[i] != BestTeam && Teams[i].Score == BestTeam.Score )
		{
//ARL			BroadcastLocalizedMessage( DMMessageClass, 0 );
			return true;
		}
	}
	return false;

}


function bool GoalLimitMet()
{
	BestTeam = GetBestTeam();

	return GoalScore > 0 && BestTeam.Score >= GoalScore;
}


function U2TeamInfo GetBestTeam()
{
	local U2TeamInfo ThisBestTeam;
	local int i;
	
	for( i = 0; i < NumTeams; i++ )
	{
		if( ThisBestTeam == None || ThisBestTeam.Score < Teams[i].Score )
			ThisBestTeam = Teams[i];
	}
	return ThisBestTeam;
}


function actor GetWinnder()
{
	return BestTeam;
}


function bool IsWinner( Controller Player )
{
	return Player.PlayerReplicationInfo.Team == BestTeam;
}


function SetEndGameCameras()
{
	BestTeam = GetBestTeam();
	Super.SetEndGameCameras();
}


function LogGameParameters()
{
	Super.LogGameParameters();

	StatLog.LogEventString( StatLog.GetTimeStamp()$Chr(9)$"game"$Chr(9)$"GoalScore"$Chr(9)$GoalScore );
	StatLog.LogEventString( StatLog.GetTimeStamp()$Chr(9)$"game"$Chr(9)$"FriendlyDamageScale"$Chr(9)$FriendlyDamageScale );
}


function string GetRules()
{
	local string ResultSet;

	ResultSet = Super.GetRules();
	ResultSet = ResultSet$"\\numteams\\"$NumTeams;
	ResultSet = ResultSet$"\\balanceteams\\"$bBalanceTeams;
	ResultSet = ResultSet$"\\playersbalanceteams\\"$bPlayersBalanceTeams;
	ResultSet = ResultSet$"\\friendlydamagescale\\"$int(FriendlyDamageScale*100)$"%";

	return ResultSet;
}

//-----------------------------------------------------------------------------
// AI
//-----------------------------------------------------------------------------

function GameEvent( name EventName, Actor Instigator, optional Actor OtherActor, optional name OtherInfo )
{
	local int ii;

	// pass event on to controllers for all teams so these can react accordingly
	for( ii=0; ii<GameAIControllers.Length; ii++ )
		GameAIControllers[ii].GameEvent( EventName, Instigator, OtherActor, OtherInfo );
}

defaultproperties
{
	StartupMessage="Work with your teammates against the other teams."
	StartupTeamMessage="You are on"
	StartupTeamTralier="."
	TeamChangeMessage="Use Options->Player Setup to change teams."
	TeamColor(0)="Red"
	TeamColor(1)="Blue"
	TeamColor(2)="Green"
	TeamColor(3)="Gold"
	bBalanceTeams=true
	NumTeams=2
	MaxTeamSize=16
	Score_TeamKill=-1.000000
	bSpawnInTeamArea=true
	bScoreTeamKills=true
	MaxAllowedTeams=4
	MultiplayerPlayerWait=17
	bCanChangeSkin=false
	bTeamGame=true
	BeaconName="TDM"
	GameName="Team Deathmatch Game"
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}