UTDom.xDoubleDom

/**
 * Base class of Double Domination Gametypes.
 * Based of the UT2004 xGame.xDoubleDom gametype. Added support for 4 team play.
 * 
 * Writen by Brian 'Snake' Alexander. Copyright(c) 2007-2010 All Rights Reserved.
 */
class xDoubleDom extends UTDomGame
   abstract;
`include(UTDom.uci)

/** Should not be used. If False and playing on a map with no TeamPlayerStart actors (e.g. most DOM maps) players will not beable to spawn.
 * True=players can spawn at any playerstarts, False=players spawn in marked team playerstarts. */
var() config bool bNoTeamPlayerStart;
/** When true, in 3 team games, the duration both points must be controlled to score is only 85% of TimeToScore.
 *  In 4 team games, the duration both points must be controlled to score is only 75% of TimeToScore. No change for 2 team games */
var() config bool bUseAltMultiTeamTimeToScore;
/** duration both points must be controlled for to score a point. */
var() config int TimeToScore;
/** duration both points are disabled for after a point is scored. */
var() config int TimeDisabled;
var const int MaxTimeToScore, MaxTimeDisabled;
/** Internal flags so Announcements do not keep repeating. */
var transient bool bPlayedDisabledMsg, bPlayedTeamDominating;
/** tracks the count down until a point is scored. */
var transient int ScoreCountDown; 
/** count down until points are re-enabled after a point is scored. */
var transient int DisabledCountDown; 
var class<UTLocalMessage> CountdownAnnouncerMessageClass;

event InitGame(string Options, out string ErrorMessage)
{
   local string InOpt;

   Super.InitGame(Options, ErrorMessage);

   InOpt = ParseOption( Options, "TimeToScore");
   if (InOpt != "")
   {
      TimeToScore = Clamp(GetIntOption(Options, "TimeToScore", TimeToScore),1,MaxTimeToScore);
      ScoreCountDown = TimeToScore;
   }

   InOpt = ParseOption( Options, "TimeDisabled");
   if (InOpt != "")
   {
      TimeDisabled = Clamp(GetIntOption(Options, "TimeDisabled", TimeDisabled),1,MaxTimeDisabled);
   }

   if ( !WorldInfo.IsConsoleBuild() )
   {
      InOpt = ParseOption(Options, "bNoTeamPlayerStart");
      if (InOpt != "")
      {
         bNoTeamPlayerStart = bool(InOpt);
         if ( !bNoTeamPlayerStart )
         {
            bSpawnInTeamArea = True;
         }
      }

      InOpt = ParseOption(Options, "bUseAltMultiTeamTimeToScore");
      if (InOpt != "")
      {
         bUseAltMultiTeamTimeToScore = bool(InOpt);
      }

      if ( bUseAltMultiTeamTimeToScore && NumTeams > 3)
      {
         if (NumTeams == 3)
         {
            TimeToScore = TimeToScore * 0.85;
         }
         else if (NumTeams == 4)
         {
            TimeToScore = TimeToScore * 0.75;
         }
         ScoreCountDown = TimeToScore;
      }
   }
}

function SetupControlPointClass()
{
   local int i, n;
   local byte outFound;
   local ControlPointFactory FactoryPointA, FactoryPointB;

   // if using maplist, use the 1st two ControlPoint entries for that map.
   if (bUseMapList)
   {
      if (IsMapOnMapList(outFound))
      {
         if (outFound >= 0)
         {
            n = CPF.Length;
            for (i=0; i< n; i++)
            {
               if (IsControlPointOnMapList(CPF[i], outFound))
               {
                  if ( FactoryPointA == none )
                     FactoryPointA = CPF[i];
                  else if ( FactoryPointB == none )
                     FactoryPointB = CPF[i];
               }
            }
         }
      }
   }

   // Search for any pre-defined ControlPointFactory.ControlPointClass that matches
   // ControlPointType[0] or ControlPointType[1]
   if (FactoryPointA == none || FactoryPointB == none)
   {
      for (i=0; i< CPF.Length; i++)
      {
         if (FactoryPointA == none && CPF[i].ControlPointClass == ControlPointType[0])
            FactoryPointA = CPF[i];
         else if (FactoryPointB == none && CPF[i].ControlPointClass == ControlPointType[1])
            FactoryPointB = CPF[i];
      }
   }

   // if have not found both xDomPointA and xDomPointB by now, then just use the 1st two
   // ControlPointFactory's of the map and use them.
   if (FactoryPointA == none || FactoryPointB == none)
   {
      for (i=0; i< CPF.Length; i++)
      {
         if (FactoryPointA == none)
            FactoryPointA = CPF[i];
         else if (FactoryPointB == none)
            FactoryPointB = CPF[i];
      }
   }

   // Setup xDomPointA
   if (FactoryPointA != none)
      FactoryPointA.ControlPointClass = ControlPointType[0];

   // Setup xDomPointB
   if (FactoryPointB != none)
      FactoryPointB.ControlPointClass = ControlPointType[1];

   // Remove unused factories
   n = CPF.Length;
   for (i=0; i<n; i++)
   {
      if (CPF.Length == 2)
      {
         break;
      }
      else if ((FactoryPointA == CPF[i] && CPF[i].ControlPointClass == ControlPointType[0])
       || (FactoryPointB == CPF[i] && CPF[i].ControlPointClass == ControlPointType[1]))
      {
         `Log(" Found ControlPointFactory CPF["$i$"]="$CPF[i].Name,bDebug,'SetupControlPointClass');
      }
      else if (CPF.Length > 2)
      {
         CPF[i].ControlPointClass = none;
         CPF.Remove(i,1);
      }
   }
}

/**
 * locates and then sets up all the right type of xDomPoint for each ControlPointFactory
 * It is very important that the xDomPointA is Registered first! This is so that
 * CDomPoints[0] = A and CDomPoints[1] = B
 */
function FindAllxDomPoints()
{
   local ControlPoint xCP[2];
   local int i;

   for (i=0; i<CPF.Length; i++)
   {
      if ( CPF[i].myControlPoint != none )
      {
         if (CPF[i].myControlPoint.IsA('xDomPointA'))
            xCP[0] = CPF[i].myControlPoint;
         else if (CPF[i].myControlPoint.IsA('xDomPointB'))
            xCP[1] = CPF[i].myControlPoint;
      }

      if (xCP[0] != none && xCP[1] != none)
      {
         break;
      }
   }

   for (i=0; i<2; i++)
   {
      RegisterControlPoint(xCP[i]);
   }
}

function WriteStartUpLogMessage()
{
   super.WriteStartUpLogMessage();
   LogInternal("[  TimeToScore="$TimeToScore);
   LogInternal("[  TimeDisabled="$TimeDisabled);
   LogInternal("[  bNoTeamPlayerStart="$string(bNoTeamPlayerStart));
   LogInternal("[  bUseAltMultiTeamTimeToScore="$string(bUseAltMultiTeamTimeToScore));
   LogInternal("============================================================================");
}

function bool RegisterControlPoint(ControlPoint CP)
{
   local bool bResult;

   bResult = super.RegisterControlPoint(CP);
   if (bResult)
   {
      if (xDomPoint(CDomPoints[CDomPoints.length-1]) != none)
      {
         xDomPoint(CDomPoints[CDomPoints.length-1]).ResetCount = ResetCount;
         return true;
      }
   }
   return bResult;
}

function PostBeginPlay()
{
   Super.PostBeginPlay();
   `Warn(" ######   ERROR: Not enough xDomPoint's   ###### ",(CDomPoints[0] == None || CDomPoints[1] == none ));
}

State MatchInProgress
{
   event Timer()
   {
      local int i;

      super.Timer();
      if (bGameEnded || CDomPoints[0] == none || CDomPoints[1] == none)
      {
         return;
      }

      // both points currently disabled?
      if (DisabledCountDown > 0)
      {
         // Play the "New Round In" announcement
         if ( !bPlayedDisabledMsg && DisabledCountDown < 7 )
         {
            BroadcastLocalizedMessage(CountdownAnnouncerMessageClass, 22);
            bPlayedDisabledMsg = True;
         }

         DisabledCountDown--;
         if (DisabledCountDown == 0)
         {
            CDomPoints[0].ResetPoint(true);
            CDomPoints[1].ResetPoint(true);
            bPlayedDisabledMsg = False;
         }
         else if (DisabledCountDown < 4) // Play the Count down announcements
         {
            BroadcastLocalizedMessage(CountdownAnnouncerMessageClass, DisabledCountDown);
         }
      }

      // nothing more to do unless the same team controls both points
      if ( (CDomPoints[0].ControllingTeam == None) || (CDomPoints[0].ControllingTeam != CDomPoints[1].ControllingTeam) )
      {
         ScoreCountDown = TimeToScore;
         bPlayedTeamDominating = False;
         return;
      }

      if (ScoreCountDown > 0)
      {
         // Play the "x Team is Dominating" announcement
         if ( !bPlayedTeamDominating )
         {
            if (CDomPoints[0].ControllingTeam.TeamIndex == 0)
               BroadcastLocalizedMessage(CountdownAnnouncerMessageClass, 18);
            else if (CDomPoints[0].ControllingTeam.TeamIndex == 1)
               BroadcastLocalizedMessage(CountdownAnnouncerMessageClass, 19);

            PlayMusicEvent(CDomPoints[0].ControllingTeam.TeamIndex, 2);
            bPlayedTeamDominating = True;
         }
         else if (ScoreCountDown < 8) // Play the Count down announcements
         {
            BroadcastLocalizedMessage(CountdownAnnouncerMessageClass, ScoreCountDown);
         }

         // decrement the time remaining until a point is scored
         ScoreCountDown--;
         return;
      }

      // controlling team has scored!
      AnnounceScore(CDomPoints[0].ControllingTeam.TeamIndex);
      CDomPoints[0].ControllingTeam.Score += 1.0;
      CDomPoints[0].ControllingTeam.bForceNetUpdate = True;
      // play the scored music
      BroadcastLocalizedMessage(CountdownAnnouncerMessageClass, 30);
      PlayMusicEvent(CDomPoints[0].ControllingTeam.TeamIndex, 1);
      // Award points to the players
      for (i=0; i < 2; i++)
      {
         if (CDomPoints[i].HolderPRI != none)
         {
            CDomPoints[i].HolderPRI.Score += 5.0;
            CDomPoints[i].HolderPRI.bForceNetUpdate = true;
            // check if the game is over because either team has achieved the goal limit
            CheckScore(CDomPoints[i].HolderPRI);
         }
      }

      // check if the game is over because either team has achieved the goal limit
      if ( bOverTime )
         EndGame(none,"timelimit");

      if ( !bGameEnded )
      {
         bPlayedTeamDominating = False;
         // reset count
         ScoreCountDown = TimeToScore;
         // make all control points be untouchable for a short period
         DisabledCountDown = TimeDisabled;
         // reset both domination points and disable them
         CDomPoints[0].ResetPoint(false);
         CDomPoints[1].ResetPoint(false);
      }
   }
}

function ScoreTeam(int i, float c);

/**
 * Plays music events for all players
 * 
 * @param TeamID   The TeamIndex who triggered this
 * @param MusicType   Which set of music to play
 */
function PlayMusicEvent(int TeamID, int MusicType)
{
   local PlayerController PC;
   local int x,z;

   if (MusicType == 1)
   {
      x = 14; //score increase lead
      z = 13; //score behind
   }
   else if (MusicType == 2)
   {
      x = 7; //took flag
      z = 4; //enemy took flag (from base)
   }

   ForEach LocalPlayerControllers(class'PlayerController', PC)
   {
      if (PC.PlayerReplicationInfo != none && UTPlayerController(PC) != none)
      {
         if (PC.PlayerReplicationInfo.GetTeamNum() == TeamID)
            UTPlayerController(PC).ClientMusicEvent(x);
         else if (PC.PlayerReplicationInfo.GetTeamNum() != TeamID)
            UTPlayerController(PC).ClientMusicEvent(z);
      }
   }
}

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

   if ( (UTPlayerController(Other) == None) || (Other.PlayerReplicationInfo.GetTeamNum() == 255) )
      return;

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

   // find a suitable teammate
   ForEach LocalPlayerControllers(class'PlayerController', PC)
   {
      Player = UTPlayerController(PC);
      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 (CDomPoints[0].ControllingPawn == Other)
   {
      CDomPoints[0].ControllingPawn = Pick;
      CDomPoints[0].UpdateStatus();
   }

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

/**
 * play 'averted' or 'last second save' announcement if within one second of a score 
 */
function ResetCount()
{
   local int i;

   if ( ScoreCountDown < TimeToScore )
   {
      if (TimeToScore - ScoreCountDown > (TimeToScore/2))
      {
         if (TimeToScore - ScoreCountDown >= (TimeToScore-1))
         {
            i = rand(2);
            if (i == 2)
               BroadcastLocalizedMessage(CountdownAnnouncerMessageClass, 20);
            else
               BroadcastLocalizedMessage(CountdownAnnouncerMessageClass, 21);
         }
      }
   }

   bPlayedTeamDominating = False;
   bPlayedDisabledMsg = False;
   ScoreCountDown = TimeToScore;
}

/**
 * Announce score for only red and blue teams 
 */
function AnnounceScore(int ScoringTeam)
{
   local UTPlayerController PC;

   if ( TeamScoreMessageClass == None || ScoringTeam > 1 )
      return;

   foreach WorldInfo.AllControllers(class'UTPlayerController', PC)
   {
      PC.ReceiveLocalizedMessage(TeamScoreMessageClass, ScoringTeam);
   }
}

/**
 * In DOM, critical players are anyone within 1024 units of the dom point
 * who have los to it.
 */
function bool CriticalPlayer(Controller Other)
{
   if ( (vsize(Other.Pawn.Location - CDomPoints[0].HomeBase.Location) <=1024) ||
      (vsize(Other.Pawn.Location - CDomPoints[1].HomeBase.Location) <=1024) )
      return true;
}

function ShowPathTo(PlayerController P, int TeamNum)
{
   if (CDomPoints[TeamNum].HomeBase != None && P.FindPathToward(CDomPoints[TeamNum].HomeBase, false) != None)
      Spawn(class'UTWillowWhisp', P,, P.Pawn.Location);
}

event Destroyed()
{
   local int i;

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

function Actor GetAutoObjectiveFor(UTPlayerController PC)
{
   if ( vsize(PC.Location - CDomPoints[0].HomeBase.Location) < vsize(PC.Location - CDomPoints[1].HomeBase.Location) )
      return CDomPoints[1].HomeBase;
   else if ( vsize(PC.Location - CDomPoints[0].HomeBase.Location) > vsize(PC.Location - CDomPoints[1].HomeBase.Location) )
      return CDomPoints[0].HomeBase;
}

DefaultProperties
{
   bExportMenuData=False
   bUnlimitedTranslocator=False
   bUseHoverboard=False
   bSpawnInTeamArea=False
   bNoTeamPlayerStart=True
   bDDOMGame=True
`if(`isdefined(PLATFORM_PS3))
   GameName="Double Domination"
   Description="Battle for control over 2 ControlPoints: A,B Your team must hold both ControlPoints for 10 seconds to score."
`else
   bUseAltMultiTeamTimeToScore=True
`endif
   GoalScore=3
   ScoreCountDown=10
   TimeToScore=10
   TimeDisabled=10
   MaxTimeToScore=30
   MaxTimeDisabled=30
   TimeLimit=20
   MaxControlPoints=2
   MaxControlPointsAllowed=2
   CountdownAnnouncerMessageClass=class'UTDom.xDomTimerMessage'
   HUDType=class'UTDom.xDOMHUD'
   MultiTeamAIType(0)=class'UTDom.xDOMTeamAI'
   MultiTeamAIType(1)=class'UTDom.xDOMTeamAI'
   MultiTeamAIType(2)=class'UTDom.xDOMTeamAI'
   MultiTeamAIType(3)=class'UTDom.xDOMTeamAI'
   ControlPointType[0]=class'UTDom.xDomPointA'
   ControlPointType[1]=class'UTDom.xDomPointB'
}