XGame.xDoubleDom

//=============================================================================
// xDoubleDom
//=============================================================================
class xDoubleDom extends TeamGame
	config;

// todo: doesn't handle the case where controllingpawn leaves the game or is killed (when it awards score, could be dangling...)
var() config int TimeToScore;               // duration both points must be controlled for to score a point

// TODO (rjp) update this class to use new time tracking vars that were merged from Onslaught/Assault/BombingRun
var() config int TimeDisabled;              // duration both points are disabled for after a point is scored

var   xDomPoint xDomPoints[2];              // the two domination points in the level
var   int ScoreCountDown;                   // count down until a point is scored
var   transient int DisabledCountDown;      // count down until points are re-enabled after a point is scored
var() Sound ControlSounds[2];               // OBSOLETE control sounds
var() Sound ScoreSounds[2];                 // OBSOLETE score sounds
var() Sound AvertedSounds[4];               // OBSOLETE score averted sounds
var() name ControlSoundNames[2];               // control sounds
var() name ScoreSoundNames[2];                 // score sounds
var() name AvertedSoundNames[4];               // score averted sounds
var sound NewRoundSound;  // OBSOLETE

// mc - localized PlayInfo descriptions & extra info
const DDPROPNUM = 2;
var localized string DDomPropsDisplayText[DDPROPNUM];
var localized string DDomPropDescText[DDPROPNUM];

static function PrecacheGameTextures(LevelInfo myLevel)
{
	class'xTeamGame'.static.PrecacheGameTextures(myLevel);

	myLevel.AddPrecacheMaterial(Material'XGameTextures.DOMpointGREY');
	myLevel.AddPrecacheMaterial(Material'XGameTextures.DOMpointLINESg');
	myLevel.AddPrecacheMaterial(Material'XGameTextures.DOMPointABg');
	myLevel.AddPrecacheMaterial(Material'XGameTextures.DOMPointABr');
	myLevel.AddPrecacheMaterial(Material'XGameTextures.DOMpointLINESr');
	myLevel.AddPrecacheMaterial(Material'XGameTextures.DOMpointRED');
	myLevel.AddPrecacheMaterial(Material'XGameTextures.RedScreenA');
	myLevel.AddPrecacheMaterial(Material'XGameTextures.DOMPointABb');
	myLevel.AddPrecacheMaterial(Material'XGameTextures.DOMpointLINESb');
	myLevel.AddPrecacheMaterial(Material'XGameTextures.DOMpointBLUE');
	myLevel.AddPrecacheMaterial(Material'XEffects.RedMarker_T');
	myLevel.AddPrecacheMaterial(Material'XEffects.BlueMarker_T');
}

static function PrecacheGameAnnouncements(AnnouncerVoice V, bool bRewardSounds)
{
	Super.PrecacheGameAnnouncements(V,bRewardSounds);
	if ( !bRewardSounds )
	{
		V.PrecacheSound(Default.ControlSoundNames[0]);
		V.PrecacheSound(Default.ControlSoundNames[1]);
		V.PrecacheSound(Default.ScoreSoundNames[0]);
		V.PrecacheSound(Default.ScoreSoundNames[1]);
		V.PrecacheSound(Default.AvertedSoundNames[1]);
		V.PrecacheSound(Default.AvertedSoundNames[3]);
		V.PrecacheSound('NewRoundIn');
	}
}

/* OBSOLETE UpdateAnnouncements() - preload all announcer phrases used by this actor */
simulated function UpdateAnnouncements() {}

// FIXME DDOM- 16 is alpha secure, 17 is bravo secure

function int GetStatus(PlayerController Sender, Bot B)
{
	local name BotOrders;

	BotOrders = B.GetOrders();
	if ( B.Pawn == None )
	{
		if ( (BotOrders == 'DEFEND') && (B.Squad.Size == 1) )
			return 0;
	}
	else if ( (B.Enemy == None) && (B.Squad.SquadObjective != None) && (B.Squad.SquadObjective.DefenderTeamIndex == B.Squad.Team.TeamIndex)
				&& B.LineOfSightTo(B.Squad.SquadObjective) )
	{
		if ( DominationPoint(B.Squad.SquadObjective).PrimaryTeam == 0 )
			return 16;
		else
			return 17;
	}
	else
		return super.GetStatus(Sender, B);

}
static function int OrderToIndex(int Order)
{
	if(Order == 0)
		return 12;

	if(Order == 2)
		return 13;

	return Order;
}

static function PrecacheGameStaticMeshes(LevelInfo myLevel)
{
	class'xDeathMatch'.static.PrecacheGameStaticMeshes(myLevel);

	myLevel.AddPrecacheStaticMesh(StaticMesh'XGame_rc.DomRing');
	myLevel.AddPrecacheStaticMesh(StaticMesh'XGame_rc.DomAMesh');
	myLevel.AddPrecacheStaticMesh(StaticMesh'XGame_rc.DomBMesh');
}

function PostBeginPlay()
{
	local NavigationPoint N;
	local int i;

	Super.PostBeginPlay();

    // find the first two domination points in the level
	i = 0;
	for(N = Level.NavigationPointList; N != None; N = N.NextNavigationPoint)
	{
		if (N.IsA('xDomPoint'))
		{
			xDomPoints[i] = xDomPoint(N);
			xDomPoints[i].ResetCount = ResetCount;
			i++;
			if (i == 2) break;
		}
	}

    if (i != 2)
    {
        // there were not enough domination points in the level!
		log("xDoubleDom: Level has wrong number of Domination Points!",'Error');
	}
}

State MatchInProgress
{
	function Timer()
	{
		local Controller TeamMate;
		local int i;

		Super.Timer();

		if (bGameEnded || xDomPoints[0] == None || xDomPoints[1] == None)
			return;

		// are both points currently disabled?
		if (DisabledCountDown > 0)
		{
			DisabledCountDown--;
            if ( DisabledCountDown == 7 )
            {
                for ( TeamMate = Level.ControllerList; TeamMate != None; TeamMate = TeamMate.NextController )
                    if ( PlayerController(TeamMate) != None )
						PlayerController(TeamMate).PlayStatusAnnouncement('NewRoundIn',1,true);
			}
	        else if ( (DisabledCountDown > 0) && (DisabledCountDown < 6) )
				BroadcastLocalizedMessage(class'TimerMessage', DisabledCountDown);

			if (DisabledCountDown == 0)
			{
				xDomPoints[0].ResetPoint(true);
				xDomPoints[1].ResetPoint(true);
			}

		}

        // nothing more to do unless the same team controls both points
        if ( (xDomPoints[0].ControllingTeam != xDomPoints[1].ControllingTeam) || (xDomPoints[0].ControllingTeam == None) )
            return;

		if (ScoreCountDown == TimeToScore)
		{
		    for (TeamMate = Level.ControllerList; TeamMate != None; TeamMate = TeamMate.NextController)
            {
			    if (TeamMate.IsA('PlayerController'))
				    PlayerController(TeamMate).PlayStatusAnnouncement(ControlSoundNames[xDomPoints[0].ControllingTeam.TeamIndex],1,true);
        	}
		}

		if (ScoreCountDown > 0 && ScoreCountDown < 9)
		    BroadcastLocalizedMessage(class'TimerMessage', ScoreCountDown );

		if (ScoreCountDown > 0)
        {
            // decrement the time remaining until a point is scored
	        ScoreCountDown--;
            return;
        }

		for (TeamMate = Level.ControllerList; TeamMate != None; TeamMate = TeamMate.NextController)
        {
			if (TeamMate.IsA('PlayerController'))
			{
				PlayerController(TeamMate).PlayStatusAnnouncement(ScoreSoundNames[xDomPoints[0].ControllingTeam.TeamIndex],1,true);
				PlayerController(TeamMate).ClientPlaySound(class'CTFMessage'.Default.Riffs[Rand(3)]);
			}
        }

		// controlling team has scored!
        xDomPoints[0].ControllingTeam.Score += 1.0;
		xDomPoints[0].ControllingTeam.NetUpdateTime = Level.TimeSeconds - 1;

		TeamScoreEvent(xDomPoints[0].ControllingTeam.TeamIndex,1,"dom_teamscore");
        // award scoring players some Adrenaline and increase their score
		if ( (xDomPoints[0].ControllingPawn != None) && (xDomPoints[0].ControllingPawn.Controller != None) )
        {
            xDomPoints[0].ControllingPawn.Controller.PlayerReplicationInfo.Score += 5.0;
			xDomPoints[0].ControllingPawn.Controller.PlayerReplicationInfo.NetUpdateTime = Level.TimeSeconds - 1;
		    xDomPoints[0].ControllingPawn.Controller.AwardAdrenaline(ADR_Goal);
			ScoreEvent(xDomPoints[0].ControllingPawn.Controller.PlayerReplicationInfo,5,"dom_score");
        }

		if ( (xDomPoints[1].ControllingPawn != None) && (xDomPoints[1].ControllingPawn.Controller != None) )
        {
            xDomPoints[1].ControllingPawn.Controller.PlayerReplicationInfo.Score += 5.0;
			xDomPoints[1].ControllingPawn.Controller.PlayerReplicationInfo.NetUpdateTime = Level.TimeSeconds - 1;
		    xDomPoints[1].ControllingPawn.Controller.AwardAdrenaline(ADR_Goal);
			ScoreEvent(xDomPoints[1].ControllingPawn.Controller.PlayerReplicationInfo,5,"dom_score");

        }

		// reset count
        ScoreCountDown = TimeToScore;

		// make all control points be untouchable for a short period
		DisabledCountDown = TimeDisabled;

		// reset both domination points and disable them
		xDomPoints[0].ResetPoint(false);
		xDomPoints[1].ResetPoint(false);

        // check if the game is over because either team has achieved the goal limit
        if ( GoalScore > 0 )
        {
		    for (i = 0; i < 2; i++ )
            {
			    if ( Teams[i].Score >= GoalScore )
                {
				    EndGame(None,"teamscorelimit");
                }
            }
        }
    }
}

function ClearControl(Controller Other)
{
    local Controller P;
	local PlayerController Player;
    local Pawn Pick;

	if ( (PlayerController(Other) == None) || (Other.PlayerReplicationInfo.Team.TeamIndex == 255) )
		return;

	if ( (xDomPoints[0].ControllingPawn != Other) && (xDomPoints[1].ControllingPawn != Other) )
        return;

    // find a suitable teammate
	for( P=Level.ControllerList; P!=None; P=P.nextController )
	{
		Player = PlayerController(P);

		if ( (Player != None) && (Player != Other) && (Player.PlayerReplicationInfo.Team == Other.PlayerReplicationInfo.Team) )
		{
			Pick = Player.Pawn;
            break;
		}
	}

    // update both control points with the new controlling pawn, since the other one is leaving (if no other suitable
    // teammate was found, then the point will return to neutral)
    if (xDomPoints[0].ControllingPawn == Other)
	{
		xDomPoints[0].ControllingPawn = Pick;
		xDomPoints[0].UpdateStatus();
	}

	if (xDomPoints[1].ControllingPawn == Other)
	{
		xDomPoints[1].ControllingPawn = Pick;
		xDomPoints[1].UpdateStatus();
	}
}

function Logout( Controller Exiting )
{
    ClearControl(Exiting);
    Super.Logout(Exiting);
}

function ResetCount()
{
    local name Aversion;
	local Controller TeamMate;

    if ( ScoreCountDown < TimeToScore )
    {
        Aversion = AvertedSoundNames[1];
        if (TimeToScore - ScoreCountDown > (TimeToScore/2))
        {
            if (TimeToScore - ScoreCountDown >= (TimeToScore-1))
            {
                // within one second of a score
                Aversion = AvertedSoundNames[3];
            }
            else
            {
                // halfway to a score
                Aversion = AvertedSoundNames[2];
            }
        }
        else if ( TimeToScore - ScoreCountDown < 2 )
        {
			for (TeamMate = Level.ControllerList; TeamMate != None; TeamMate = TeamMate.NextController)
			{
				if (TeamMate.IsA('PlayerController'))
					PlayerController(TeamMate).PlayAnnouncement(Sound'GameSounds.DDAverted',2,true);
			}
		    ScoreCountDown = TimeToScore;
			return;
		}

        for (TeamMate = Level.ControllerList; TeamMate != None; TeamMate = TeamMate.NextController)
        {
			if (TeamMate.IsA('PlayerController'))
                PlayerController(TeamMate).PlayStatusAnnouncement(Aversion,2,true);
        }
    }

    ScoreCountDown = TimeToScore;
}

function bool CriticalPlayer(Controller Other)
{
	// In DOM, critical players are anyone within 1024 units of the dom point
	// who have los to it.

	if ( (vsize(Other.Pawn.Location - xDomPoints[0].Location) <=1024) ||
	     (vsize(Other.Pawn.Location - xDomPoints[1].Location) <=1024) )
		return true;

	return Super.CriticalPlayer(Other);
}

function Killed( Controller Killer, Controller Killed, Pawn KilledPawn, class<DamageType> damageType )
{
	if ( (Killer != None) && Killer.bIsPlayer && Killed.bIsPlayer &&
         (Killer.PlayerReplicationInfo.Team != Killed.PlayerReplicationInfo.Team)
         && (xPawn(Killer.Pawn) != None) && (DisabledCountDown > 0))
    {
        Killer.AwardAdrenaline(ADR_MinorBonus);
    }

	Super.Killed(Killer, Killed, KilledPawn, damageType);
}

function GetServerDetails(out ServerResponseLine ServerState)
{
	Super.GetServerDetails(ServerState);
	AddServerDetail( ServerState, "TimeToScore", TimeToScore );
	AddServerDetail( ServerState, "TimeDisabled", TimeDisabled );
}

static function FillPlayInfo(PlayInfo PlayInfo)
{
	local int i;

	Super.FillPlayInfo(PlayInfo);  // Always begin with calling parent

	PlayInfo.AddSetting("Game", "TimeToScore",  default.DDomPropsDisplayText[i++], 40, 1, "Text", "3;0:60",,,True);
	PlayInfo.AddSetting("Game", "TimeDisabled", default.DDomPropsDisplayText[i++], 40, 1, "Text", "3;0:60",,,True);
}

static event string GetDescriptionText(string PropName)
{
	switch (PropName)
	{
		case "TimeToScore":	return default.DDomPropDescText[0];
		case "TImeDisabled": return default.DDomPropDescText[1];
	}

	return Super.GetDescriptionText(PropName);
}

function actor FindSpecGoalFor(PlayerReplicationInfo PRI, int TeamIndex)
{
	local XPlayer PC;
    local xDomLetter Dom[2],d;

    PC = XPlayer(PRI.Owner);
    if (PC==None)
    	return none;

	foreach AllActors(class'xDomLetter',d)
    	if (xDomA(d)!=None)
        	Dom[0]=d;
        else
        	Dom[1]=d;

    if ( vsize(PC.Location - Dom[0].Location) < vsize(PC.Location - Dom[1].Location) )
    	return Dom[1];
    else
    	return Dom[0];

    return none;

}

event SetGrammar()
{
	LoadSRGrammar("DOM");
}

event Destroyed()
{
	local int i;

	for ( i = 0; i < 2; i++ )
	{
		if ( xDomPoints[i] != None )
			xDomPoints[i].ResetCount = None;
	}
	Super.Destroyed();
}

defaultproperties
{
	HUDType="XInterface.HudCDoubleDomination"
    MapListType="XInterface.MapListDoubleDomination"
    GameName="Double Domination"
	GoalScore=3
    ScoreCountDown=10
    TimeToScore=10
    TimeDisabled=10
    MapPrefix="DOM"
    BeaconName="DOM"
    bScoreTeamKills=false
	bSpawnInTeamArea=true
    bTeamScoreRounds=false
    ADR_Kill=2.0
	DefaultEnemyRosterClass="xGame.xTeamRoster"
	 bMustHaveMultiplePlayers=false

    // sounds for this game type
	ControlSoundNames(0)=Red_Team_Dominating'
    ControlSoundNames(1)=Blue_Team_Dominating'
    ScoreSoundNames(0)=Red_Team_Scores'
    ScoreSoundNames(1)=Blue_Team_Scores'
    AvertedSoundNames(1)=Narrowly_Averted
    AvertedSoundNames(2)=Narrowly_Averted
    AvertedSoundNames(3)=Last_Second_Save
    DeathMessageClass=class'XGame.xDeathMessage'

    TeamAIType(0)=class'UnrealGame.DOMTeamAI'
    TeamAIType(1)=class'UnrealGame.DOMTeamAI'

    ScreenShotName="UT2004Thumbnails.DOMShots"
    DecoTextName="XGame.DoubleDom"

    Acronym="DOM2"
	OtherMesgGroup="DoubleDom"

    DDomPropsDisplayText(0)="Time To Score"
    DDomPropsDisplayText(1)="Time Disabled"

    DDomPropDescText(0)="Specifies how long domination points must be held to score a point."
    DDomPropDescText(1)="Specifies how long domination points are disabled after a point is scored."

    Description="Your team scores by capturing and holding both Control Points for ten seconds.  Control Points are captured by touching them.  After scoring, the Control Points reset to neutral."
}