UTMultiTeam.UTMT_TeamHUD

//-----------------------------------------------------------
// Copyright 2007, Infinity Impossible
//-----------------------------------------------------------
class UTMT_TeamHUD extends UTTeamHUD
	abstract;

/**
 * The UIScene scoreboards to use. Index 0 is for a 2-team game, 1 is
 * for a 3-team game, etc, all the way up to however many teams you have.
 */
var array<UTUIScene_Scoreboard> ScoreboardSceneTemplates;


/**
 * Dictate the "pivot point" of the team scores display. The owner's score
 * will be drawn to the left of this X value in the HUD and the other teams
 * will be drawn to the right. Indexing as with the scoreboard templates.
 */
var array<float> ScorePositionModifier;


/**
 * Dictate the spacing left to the left and right of the pivot point before
 * drawing the scores. This actually leaves twice the amount of space than
 * given. For example, a value of 0.01 will add 0.01 to the left and 0.01 to
 * the right. Indexing as with the scoreboard templates.
 */
var array<float> ScorePositionOffset;


var array<float> TeamPulseTime;
var array<int> OldTeamScore;

var class<UTMT_TeamInfo> TeamInfoClass;
var class<LocalMessage> SayMessageClass;
var class<LocalMessage> TeamSayMessageClass;

var localized string TeamHasWonTheMatch;
var localized string TeamYouLose;



simulated function SetUpMultiTeamHUD(int NumTeams)
{
	local int Index;

	Index = NumTeams - 2;

	assert(ScoreboardSceneTemplates.Length > Index);

	ScoreboardSceneTemplate = ScoreboardSceneTemplates[Index];
	TeamPulseTime.Length = NumTeams;
	OldTeamScore.Length = NumTeams;
}


simulated function UpdateTeamPulseTimes()
{
	local int i;
	local int NewScore;

	for(i = 0; i < UTGRI.Teams.Length; ++i)
	{
		NewScore = GetTeamScore(i);

		if( NewScore != OldTeamScore[i] )
			TeamPulseTime[i] = WorldInfo.TimeSeconds;

		OldTeamScore[i] = NewScore;
	}
}


simulated function DrawHUD()
{
	local int TeamIndex;

	TeamIndex = UTPlayerOwner.GetTeamNum();
	if(TeamIndex < UTGRI.Teams.Length)
		GetMultiTeamColor(UTGRI.Teams[TeamIndex], TeamHUDColor, TeamTextColor);
	else
		GetMultiTeamColor(none, TeamHUDColor, TeamTextColor);

	TeamColor.R = TeamHUDColor.R * 256;
	TeamColor.G = TeamHUDColor.G * 256;
	TeamColor.B = TeamHUDColor.B * 256;
	TeamColor.A = TeamHUDColor.A * 256;

	super.DrawHUD();
}


function DrawPostGameHud()
{
	local bool bWinner;
	local UTMT_TeamInfo MultiTeamInfo;
	local string TeamYouHaveLost;

	if (WorldInfo.GRI != None && PlayerOwner.PlayerReplicationInfo != None && !PlayerOwner.PlayerReplicationInfo.bOnlySpectator)
	{
		if ( UTPlayerReplicationInfo(WorldInfo.GRI.Winner) != none )
		{
			bWinner = UTPlayerReplicationInfo(WorldInfo.GRI.Winner) == UTOwnerPRI;
		}
		// automated testing will not have a valid winner
		else if( WorldInfo.GRI.Winner != none )
		{
			bWinner = WorldInfo.GRI.Winner.GetTeamNum() == UTPlayerOwner.GetTeamNum();
		}

		if(WorldInfo.GRI.Winner != None)
			if(WorldInfo.GRI.Winner.GetTeamNum() < UTGRI.Teams.Length)
				MultiTeamInfo = UTMT_TeamInfo( UTGRI.Teams[WorldInfo.GRI.Winner.GetTeamNum()] );

		if(MultiTeamInfo != None)
			TeamYouHaveLost = TeamYouLose@Caps(MultiTeamInfo.GetTeamCaption(false))@TeamHasWonTheMatch;

		DisplayHUDMessage((bWinner ? YouHaveWon : TeamYouHaveLost));
	}

	DisplayConsoleMessages();
}


simulated function DisplayTeamScore()
{
	local float DestScale, W, H, POSX;
	local vector2d Logo;
	local byte TeamIndex;
	local LinearColor TeamLC;
	local color TextC;
	local int NewScore;
	local float PulseTime;
	local int NumTeams;
	local int i;

	UpdateTeamPulseTimes();

	Canvas.DrawColor = WhiteColor;
    W = 214 * ResolutionScale;
    H = 87 * ResolutionScale;

	// Draw the Left Team Indicator
	DestScale = 1.0;
	TeamIndex = UTPlayerOwner.GetTeamNum();
	NumTeams = UTGRI.Teams.Length;
	if ( (TeamIndex == 255) || bIsSplitScreen )
	{
		// spectator
		TeamIndex = 0;
		DestScale = TeamScaleModifier;
	}
	GetMultiTeamColor(UTGRI.Teams[TeamIndex], TeamLC, TextC);
	POSX = Canvas.ClipX * ScorePositionModifier[NumTeams-2] - ScorePositionOffset[NumTeams-2] - W;

	Canvas.SetPos(POSX, 0);
	Canvas.DrawColorizedTile(IconHudTexture, W * DestScale, H * DestScale, 0, 491, 214, 87, TeamLC);

	NewScore = GetTeamScore(TeamIndex);
	PulseTime = TeamPulseTime[TeamIndex];

	if (DestScale < 1.0)
	{
		DrawGlowText(string(NewScore), POSX + 97 * ResolutionScale, -2 * ResolutionScale, 50 * ResolutionScale, PulseTime, true);
	}
	else
	{
		DrawGlowText(string(NewScore), POSX + 124 * ResolutionScale, -2 * ResolutionScale, 60 * ResolutionScale, PulseTime, true);
	}

	Logo.X = POSX + ((TeamIconCenterPoints[0].X) * DestScale * ResolutionScale) + (30 * ResolutionScale);
	Logo.Y = ((TeamIconCenterPoints[0].Y) * DestScale * ResolutionScale) + (27.5 * ResolutionScale);


   	DisplayTeamLogos(TeamIndex,Logo, 1.5);


	// Draw the Right Team Indicators
	POSX = Canvas.ClipX * ScorePositionModifier[NumTeams-2] + ScorePositionOffset[NumTeams-2];

	for(i = 0; i < NumTeams; ++i)
	{
		if (bScoreDebug)
		{
			Canvas.SetPos(0,100 + 20*i);
			Canvas.DrawText("ScoreDebug: "@UTGRI.Teams[i].GetHumanReadableName()@" NewScore="@NewScore@UTGRI@UTGRI.Teams[i]);
		}

		if(i != TeamIndex)
		{
			DestScale = TeamScaleModifier;
			GetMultiTeamColor(UTGRI.Teams[i], TeamLC, TextC);

			NewScore = GetTeamScore(i);
			PulseTime = TeamPulseTime[i];

			Canvas.SetPos(POSX,0);
			Canvas.DrawColorizedTile(IconHudTexture, W * DestScale, H * DestScale, 0, 582, 214, 87, TeamLC);
			Canvas.DrawColor = WhiteColor;
			DrawGlowText(string(NewScore), POSX + 0.66*W, -4 * ResolutionScale, 50 * ResolutionScale, PulseTime, true);

			Logo.X = (POSX + (TeamIconCenterPoints[1].X) * DestScale * ResolutionScale) + (30 * ResolutionScale);
			Logo.Y = ((TeamIconCenterPoints[1].Y) * DestScale * ResolutionScale) + (27.5 * ResolutionScale);
	   		DisplayTeamLogos(TeamIndex,Logo, 1.0);

	   		POSX += W * DestScale;
	   	}
   	}
}


simulated function GetMultiTeamColor(TeamInfo Team, optional out LinearColor ImageColor, optional out color TextColor)
{
	local int TeamIndex;
	local UTMT_TeamInfo MultiTeamInfo;

	if(Team != None)
		TeamIndex = Team.GetTeamNum();
	else
		TeamIndex = 255;

	if(TeamIndex < 255)
	{
		MultiTeamInfo = UTMT_TeamInfo(Team);
		if(MultiTeamInfo != None)
			ImageColor = MultiTeamInfo.GetImageColor();
		else
			WarnInternal("Team is not an instance of UTMT_TeamInfo");

		TextColor = Team.GetTextColor();
	}
	else
	{
		GetTeamColor(TeamIndex, ImageColor, TextColor);
	}
}


/**
 * We preferably gather this information dynamically, but where this is not
 * possible, this is the fallback function.
 */
static simulated function GetTeamColor(int TeamIndex, optional out LinearColor ImageColor, optional out color TextColor)
{
	if(TeamIndex < 255)
	{
        ImageColor = default.TeamInfoClass.static.GetDefaultImageColor(TeamIndex);
        TextColor = default.TeamInfoClass.static.GetDefaultTextColor(TeamIndex);
	}
	else
	{
		super.GetTeamColor(TeamIndex, ImageColor, TextColor);
	}
}


simulated function int GetTeamScore(byte TeamIndex)
{
	assert(UTGRI.Teams.Length > TeamIndex);

	if( (UTGRI != None) && (UTGRI.Teams[TeamIndex] != None) )
	{
		return int(UTGRI.Teams[TeamIndex].Score);
	}
	else
	{
		return 0;
	}
}


/**
 * This function overrides Message to provide teamcolored messages for the green
 * and gold teams' say functions.
 */
function Message( PlayerReplicationInfo PRI, coerce string Msg, name MsgType, optional float LifeTime )
{
	local class<LocalMessage> MsgClass;

	if ( bMessageBeep )
	{
		PlayerOwner.PlayBeepSound();
	}

	MsgClass = SayMessageClass;
	if (MsgType == 'Say' || MsgType == 'TeamSay')
	{
		Msg = PRI.GetPlayerAlias()$": "$Msg;
		if (MsgType == 'TeamSay')
		{
			MsgClass = TeamSayMessageClass;
		}
	}

	AddConsoleMessage(Msg, MsgClass, PRI, LifeTime);
}

defaultproperties
{
   ScorePositionModifier(0)=0.500000
   ScorePositionModifier(1)=0.450000
   ScorePositionModifier(2)=0.392000
   ScorePositionOffset(0)=0.010000
   ScorePositionOffset(1)=0.000000
   ScorePositionOffset(2)=0.000000
   TeamInfoClass=Class'UTMultiTeam.UTMT_TeamInfo'
   SayMessageClass=Class'UTMultiTeam.UTMT_UTSayMsg'
   TeamSayMessageClass=Class'UTGame.UTTeamSayMsg'
   TeamHasWonTheMatch="HAS WON THE MATCH!"
   TeamYouLose="YOU LOSE,"
}