UTDom.UTDomGame

/**
 * Base class for all Domination type games.
 * 
 * Writen by Brian 'Snake' Alexander aka 'Wr@ith' ( sw_snakepliskin at hotmail.com )
 * Copyright(c) 2007-2010 All Rights Reserved.
 */
class UTDomGame extends UTMT_TeamGame
   config(Dom)
   abstract;
`include(UTDom.uci)

var const string  DOMVer;
/** Maximum number of Teams ever allowed. */
const MaxTeamsAllowed = 4;
/** Maximum number of ControlPoints ever allowed (MaxControlPoints is clamped to this in initgame(). */
var const byte MaxControlPointsAllowed;
/** TRUE=use only the control points that are named for the specified map in the maplist.
@note when playing DDOM there must only be 2 entries in the ControlPoints list. Any more or less, will make it not work for playing DDOM */
var() config bool bUseMapList;
/** Admin config setting to use the Translocator or not. */
var() config bool bUseTranslocator;
/** Makes the Translocator to be Unlimited. */
var() config bool bUnlimitedTranslocator;
/** Use the Hoverboard instead of the Translocator. Overrides any enabled Translocator setting. */
var() config bool bUseHoverboard;
/** Makes all Vehicle neutral, does not lock then for a team. */
var() config bool bUnlockedVehicles;
/** Allows players to capture control points when in a vehicle */
var() config bool bVehiclesCanCapturePoints;
/** admin config Number of Teams to use. The Value is duplicated to NumTeams parameter. hack needed for the WebAdmin settings because the NumTeams is not config. */
var() config byte NumOfTeams;
/** Maximum number of ControlPoints allowed by this server. (Does not add any ControlPoints to a map) if MaxControlPoints value is greater then the # of ControlPoints in the map, no change. */
var() config byte MaxControlPoints;
/** class of the 'unlimited' use type of translocator */
var() class<Inventory> UnlimitedTranslocatorClass;
/** The domination points in the level that are being used in play */
var array<ControlPoint> CDomPoints;
/** cached array of the ControlPointFactory in the map */
var array<ControlPointFactory> CPF;
/** Controls what class type of DominationObjective will be spawned by the maps DominationFactory actors */
var class<ControlPoint> ControlPointType[2];
struct EMapList
{
   /** The full map name without the file extension (i.e. DOM-MyMapName  do NOT USE: DOM-MyMapName.ut3 ) */
   var() string MapName;
   /** Allows for multiple configurations per map. ONLY one entry per map should be enabled! */
   var() bool bEnabled;
   /** List of Control Points found in the MapName map to use in game play.  All other Control Points will be removed from play. */
   var() array<string> ControlPoints;
};
/** If bUseMapList=TRUE the game will check if the current map is on this list and bEnabled=TRUE for that map, then only allow ControlPoints that ObjectiveName||PointNames~= the ControlPoints entrys. All other ControlPoints not on this list will be disabled and removed from play. */
var() config array<EMapList> MapList;
/** Display a menu for the player to select the team they want to join at login */
var() config bool bShowPickTeamAtLogin;

/**   -----   Internal Game Flags   -----   */
var const bool bDDOMGame;
/** cached # of the CDomPoints.Length */
var transient int iCP;
/** This is so that we can keep a value out of a static event */
var config transient string CurrentMapName;
/** GetMatchSettings Kismet events */
var array<SequenceObject> GMSEvents;
var UTUIScene MidGameMenuTemplates[3];

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

   NumOfTeams = Clamp(GetIntOption( Options, "NumOfTeams", NumOfTeams ), MinTeams, MaxTeams);
   NumTeams = NumOfTeams;

   if ( !WorldInfo.IsConsoleBuild() )
   {
      if (NumOfTeams == 4)
      {
         MidGameMenuTemplate=UTUIScene_MidGameMenu'UI_UT3Dom.Menus.DomMidGameMenu';
      }
      else if (NumOfTeams == 3)
      {
         MidGameMenuTemplate=UTUIScene_MidGameMenu'UI_UT3Dom.Menus.DomMidGameMenu3';
      }
      else
      {
         MidGameMenuTemplate=UTUIScene_MidGameMenu'UI_UT3Dom.Menus.DomMidGameMenu2';
      }
   }

   super.InitGame(Options, ErrorMessage);

   InOpt = ParseOption(Options, "bUseMapList");
   if (InOpt != "")
   {
      bUseMapList = bool(InOpt);
   }
   InOpt = ParseOption(Options, "bUseTranslocator");
   if (InOpt != "")
   {
      bUseTranslocator = bool(InOpt);
   }
   InOpt = ParseOption(Options, "bUnlimitedTranslocator");
   if (InOpt != "")
   {
      bUnlimitedTranslocator = bool(InOpt);
   }
   InOpt = ParseOption(Options, "bUseHoverboard");
   if (InOpt != "")
   {
      bUseHoverboard = bool(InOpt);
   }
   InOpt = ParseOption(Options, "bUnlockedVehicles");
   if (InOpt != "")
   {
      bUnlockedVehicles = bool(InOpt);
   }
   InOpt = ParseOption(Options, "bVehiclesCanCapturePoints");
   if (InOpt != "")
   {
      bVehiclesCanCapturePoints = bool(InOpt);
   }
   InOpt = ParseOption(Options, "bShowPickTeamAtLogin");
   if (InOpt != "")
   {
      bShowPickTeamAtLogin = bool(InOpt);
   }
   // The MaxControlPoints is not used when playing DoubleDom games. Two ControlPoints are required, no more, no less.
   if ( !bDDOMGame )
   {
      MaxControlPoints = Clamp(GetIntOption(Options, "MaxControlPoints", MaxControlPoints),1,MaxControlPointsAllowed);
   }

   WriteStartUpLogMessage();
   FindControlPointFactory();
   `Warn(" ######   Level doesn't have any ControlPointFactory!   ###### ",(CPF.Length == 0));
}

/**
 * This is a work around the bug in WorldInfo.GetMapName(bIncludePrefix) not returning the Map
 * Prefix along with the map name.  Instead it returns the Friendly Map name and we dont want that.
 */
static event class<GameInfo> SetGameType(string MapName, string Options)
{
   default.CurrentMapName = MapName;
   return super.SetGameType(MapName,Options);
}

/**
 * replicate bPickTeamAtLogin to clients
 */
function InitGameReplicationInfo()
{
   Super.InitGameReplicationInfo();

   if (WorldInfo.GRI != None && DomGameReplicationInfo(WorldInfo.GRI) != none)
      DomGameReplicationInfo(WorldInfo.GRI).bPickTeamAtLogin = bShowPickTeamAtLogin;
}

/**
 * Returns whether a mutator should be allowed with this gametype
 */
static function bool AllowMutator( string MutatorClassName )
{
   if (MutatorClassName ~= "UTGame.UTMutator_NoOrbs")
   {
      // No Orbs mutator only for Warfare
      return False;
   }
   return Super.AllowMutator(MutatorClassName);
}

/**
 * Finds all the ControlPointFactory actors in the map
 */
function FindControlPointFactory()
{
   local ControlPointFactory O;

   foreach AllActors(class'ControlPointFactory', O)
   {
      if (O != None)
         CPF.AddItem(O);
   }
   global.SetupControlPointClass();
}

/**
 * Logic to correctly setup the ControlPointFactory actors
 */
function SetupControlPointClass()
{
   local int i, z;
   local byte outFound;

   // check to see if there is a MapList entry
   if (bUseMapList)
   {
      if (IsMapOnMapList(outFound))
      {
         if (outFound >= 0)
         {
            z = CPF.Length;
            for (i=0; i< z; i++)
            {
               if (IsControlPointOnMapList(CPF[i], outFound))
                  CPF[i].ControlPointClass = ControlPointType[0];
               else
               {
                  CPF[i].ControlPointClass = None;
                  CPF.Remove(i,1);
               }
            }
            return;
         }
      }
   }

   // remove any extra factory otherwise setup the factory to use the correct ControlPointClass
   z = CPF.Length;
   for (i=0; i<z; i++)
   {
      if (CPF.Length > MaxControlPoints && CPF[i].ControlPointClass != ControlPointType[0])
          CPF.Remove(i,1);
      else
         CPF[i].ControlPointClass = ControlPointType[0];
   }
}

function WriteStartUpLogMessage()
{
   LogInternal("============================================================================");
   LogInternal("[           INITIALIZING a UT3Domination game ...");
   LogInternal("[  Version="$DOMVer);
   `if(`isdefined(DEBUG))
      `Log("[  --> DEBUG=TRUE <--");
   `endif
`if(`isdefined(PLATFORM_PS3))
   LogInternal("[  --> PS3 BUILD=TRUE <--");
`endif
   LogInternal("[  GameClass="$string(Default.class));
   LogInternal("[  Settings:");
   LogInternal("[    MaxControlPoints="$string(MaxControlPoints));
   LogInternal("[    NumTeams/MaxTeams="$string(NumTeams)$"/"$string(MaxTeams));
   LogInternal("[    bUseTranslocator="$string(bUseTranslocator)$", bUnlimitedTranslocator="$string(bUnlimitedTranslocator)$", bUseHoverboard="$string(bUseHoverboard));
   LogInternal("[    bUnlockedVehicles="$string(bUnlockedVehicles)$", bVehiclesCanCapturePoints="$string(bVehiclesCanCapturePoints));
   LogInternal("[    bUseMapList="$string(bUseMapList)$", bShowPickTeamAtLogin="$string(bShowPickTeamAtLogin));
   if ( bUseMapList )
      LogInternal("[    CurrentMapName="$CurrentMapName);
   LogInternal("============================================================================");
   CrashIfPS3Build();
}

/**
 * If this is the PS3 build of UTDom.u and its being played on the PC
 * then write to the log and crash the game!
 */
function CrashIfPS3Build()
{
`if(`isdefined(PLATFORM_PS3))

   if ( !WorldInfo.IsConsoleBuild() )
   {
      LogInternal("============================================================================");
      LogInternal("[  ==> WorldInfo.IsConsoleBuild() = TRUE <==");
      LogInternal("[  THIS BUILD OF UTDom.u IS FOR THE PS3 ONLY!");
      LogInternal("[  NOT FOR USE ON THE PC");
      LogInternal("============================================================================");
      LogInternal("[  ==> WorldInfo.IsConsoleBuild() = TRUE <==");
      LogInternal("[  THIS BUILD OF UTDom.u IS FOR THE PS3 ONLY!");
      LogInternal("[  NOT FOR USE ON THE PC");
      LogInternal("============================================================================");
      LogInternal("[  ==> WorldInfo.IsConsoleBuild() = TRUE <==");
      LogInternal("[  THIS BUILD OF UTDom.u IS FOR THE PS3 ONLY!");
      LogInternal("[  NOT FOR USE ON THE PC");
      LogInternal("============================================================================");
      LogInternal("   THE GAME WILL NOW SHUT DOWN...");
      ConsoleCommand("QUIT");
   }
`endif
}

/**
 * Checks if bUseMapList=TRUE and the current map is on the MapList and bEnabled=TRUE,
 * Then if the ControlPoint being validated is on the list, allow it. if not on the list or
 * the number of ControlPoints already in use = MaxControlPoints, then disable it.
 * 
 * @param CP   The ControlPoint in question
 * @return     true if we keep the control point
 */
function bool ValidateControlPoint(ControlPoint CP)
{
   if (CP == None || (CDomPoints.Length >= MaxControlPoints))
   {
      if (CP != None)
         CP.DisableThisPoint();

      return False;
   }

   return True;
}

/**
 * @deprecated As of version 1.8 Use IsMapOnMapList() and IsControlPointOnMapList() instead of this.
 *
 * Looks up the current map on the MapList. function will return true if
 * the current map is on the MapList and that entry has bEnabled=TRUE.
 * bFound will return a value of 1 (bool) if "CP" is found in the
 * ControlPoints array.
 */
function bool IsOnMapList(UTGameObjective CP, out byte bFound)
{
   local int i, n;
   local bool bHasMapEntry;

   bFound = 0;
   for (i=0; i < MapList.Length; i++)
   {
      if (MapList[i].bEnabled && (MapList[i].MapName != "" && CurrentMapName != "") && (MapList[i].MapName ~= CurrentMapName))
      {
         bHasMapEntry = True;
         // This map was found in the list, check if the control points is on the list
         for (n=0; n < MapList[i].ControlPoints.Length; n++)
         {
            if (MapList[i].ControlPoints[n] != ""
            && (MapList[i].ControlPoints[n] ~= CP.GetHumanReadableName()
             || MapList[i].ControlPoints[n] ~= CP.ObjectiveName))
            {
               bFound = 1;
               break;
            }
         }
         break;
      }
   }
   return bHasMapEntry;
}

/**
 * Checks the MapList if the map being played is on the list.
 * 
 * @param ListIndex  (out) the index of the entry if found
 * @return           true if entry is found
 */
function bool IsMapOnMapList(out byte ListIndex)
{
   local int i;

   ListIndex = -1;
   for (i=0; i < MapList.Length; i++)
   {
      if (MapList[i].bEnabled && (MapList[i].MapName != "" && CurrentMapName != "") && (MapList[i].MapName ~= CurrentMapName))
      {
         ListIndex = i;
         return True;
      }
   }
   return False;
}

/**
 * Checks the CP aginst the MapList[].ControlPoints array.
 * MapList uses the ListIndex as the index location.
 * 
 * @return  If was found in the map list
 */
function bool IsControlPointOnMapList(UTGameObjective CP, byte ListIndex)
{
   local int n;

   for (n=0; n < MapList[ListIndex].ControlPoints.Length; n++)
   {
      if (MapList[ListIndex].ControlPoints[n] != "")
      {
         if (ControlPointFactory(CP) != none && MapList[ListIndex].ControlPoints[n] ~= ControlPointFactory(CP).PointName)
            return True;

         if (MapList[ListIndex].ControlPoints[n] ~= CP.GetHumanReadableName() || MapList[ListIndex].ControlPoints[n] ~= CP.ObjectiveName)
            return True;
      }
   }

   return False;
}

/**
 * Add the Control Point to the CDomPoints array.
 * 
 * @param CP   The Control Point to add to the CDomPoints array.
 * @return     Will return FALSE if it was not added to the array sucessfuly.
 */
function bool RegisterControlPoint(ControlPoint CP)
{
   local int i, Len;

   if ( !ValidateControlPoint(CP) )
      return False;

   // see if the ControlPoint is already in the array
   Len = CDomPoints.Length;
   for (i=0; i<Len; i++ )
   {
      if ( CDomPoints[i] == CP )
         return False;
   }

   // didn't find it - add this one
   CDomPoints.AddItem(CP);
   return True;
}

/**
 * Similar to FindControlPointFactory()
 * In xDomGame based games, Finds all the ControlPointFactory actors in the map
 */
function FindAllxDomPoints();

/**
 * This is to correct the MultiTeamAIType array. Apparently the PS3 doesnt like it, if this is not done.
 */
function PreBeginPlay()
{
   MultiTeamAIType.Length = MaxTeams;
   super.PreBeginPlay();
}

/**
 * Setup the translocator/hoverboard, then setup the control points, finaly any GetMatchSettings kismet events
 */
function PostBeginPlay()
{
   local int i;
   local Sequence GameSequence;

   if ( !bAllowTranslocator || !bUseTranslocator )
      TranslocatorClass = None;
   else if ( bUseTranslocator )
   {
      bAllowTranslocator = True;
      if (bUnlimitedTranslocator && UnlimitedTranslocatorClass != None)
         TranslocatorClass = UnlimitedTranslocatorClass;
   }

   if ( bUseHoverboard )
   {
      bAllowTranslocator = False;
      bAllowHoverboard = bUseHoverboard;
   }

   // Find all the ControlPoints
   if ( bDDOMGame )
      FindAllxDomPoints();
   else
   {
      for (i=0; i < CPF.Length; i++)
      {
         if ((CDomPoints.Length < MaxControlPoints) && CPF[i].myControlPoint != None)
            RegisterControlPoint(CPF[i].myControlPoint);
      }
   }

   super.PostBeginPlay();
   CurrentMapName = "";
   iCP = CDomPoints.Length;
   `Warn(" ######   Level doesn't have any ControlPoint's!   ###### ",(iCP == 0));

   // find and activate any Kismet GetMatchSettings events for the map
   GameSequence = WorldInfo.GetGameSequence();
   if (GameSequence != None)
   {
      GameSequence.FindSeqObjectsByClass(class'DOMSeqEvent_GetMatchSettings', true, GMSEvents);
      if (GMSEvents.Length > 0)
      {
         for (i = 0; i < GMSEvents.length; i++)
         {
            if (DOMSeqEvent_GetMatchSettings(GMSEvents[i]) != None)
               DOMSeqEvent_GetMatchSettings(GMSEvents[i]).CheckActivate(self, None);
         }
      }
   }
}

/**
 * Logic that handles the scoring during game play
 */
state MatchInProgress
{
   event Timer()
   {
      local int i;
      local float c;

      Super.Timer();
      if ( !bDDOMGame && !bGameEnded )
      {
         c = 0.2;
         if (TimeLimit > 0)
         {
            if (GameReplicationInfo.RemainingTime < 0.25 * TimeLimit)
            {
               if (GameReplicationInfo.RemainingTime < 0.1 * TimeLimit)
                  c = 0.8;
               else
                  c = 0.4;
            }
         }

         if ( !bPlayersMustBeReady || (CountDown <= 0) )
         {
            for (i=0; i < CDomPoints.Length; i++)
            {
               ScoreTeam(i, c);
            }

            if (GoalScore > 0)
            {
               for (i=0; i < GameReplicationInfo.Teams.Length; i++)
               {
                  if (GameReplicationInfo.Teams[i] != None && GameReplicationInfo.Teams[i].Score >= GoalScore)
                     EndGame(None, "teamscorelimit");
               }
            }
         }
      }
   }
}

/**
 * Award points to the ControllingTeam and to the players
 * 
 * @param i    TeamIndex of the ControllingTeam to award points to
 * @param c    The amount of points being awarded
 */
function ScoreTeam(int i, float c)
{
   if ( (CDomPoints[i] != None && CDomPoints[i].ControllingTeam != None) && CDomPoints[i].bScoreReady )
   {
      CDomPoints[i].ControllingTeam.Score += c;
      CDomPoints[i].ControllingTeam.bForceNetUpdate = True;
      if (CDomPoints[i].HolderPRI != None)
      {
         CDomPoints[i].HolderPRI.Score += c;
         CDomPoints[i].HolderPRI.bForceNetUpdate = True;
         CheckScore(CDomPoints[i].HolderPRI);
      }
   }
}

/**
 * Play DominatingVictory if winning team won by 35% or more
 */
function bool DominatingVictory()
{
   local int WinningTeam, i;
   local float best, ScorePercent;

   WinningTeam = GetHighestScoringTeamIndex();
   ScorePercent = MultiTeams[WinningTeam].Score * 0.35;
   for (i=0; i < MultiTeams.Length; i++)
   {
      if (i != WinningTeam && MultiTeams[i].Score >= best)
         best = MultiTeams[i].Score;
   }

   best += ScorePercent;
   return (best <= MultiTeams[WinningTeam].Score);
}

function PlayRegularEndOfMatchMessage()
{
   local UTPlayerController PC;
   local int WinningTeam;

   WinningTeam = GetHighestScoringTeamIndex();
   ForEach WorldInfo.AllControllers(class'UTPlayerController', PC)
   {
      if (PC.PlayerReplicationInfo.GetTeamNum() == WinningTeam)
         PC.ClientPlayAnnouncement(VictoryMessageClass, 2); //A_StatusAnnouncer_YouHaveWonTheMatch
      else
         PC.ClientPlayAnnouncement(VictoryMessageClass, 3); // A_StatusAnnouncer_YouHaveLostTheMatch
   }
}

/** 
 * Reset() - reset actor to initial state - used when restarting level without reloading. 
 */
function Reset()
{
   local int i;
   local UTPlayerReplicationInfo PRI;

   Super.Reset();
   for (i=0; i < iCP; i++)
   {
      CDomPoints[i].ResetPoint(bDDOMGame);
   }

   // reset per-life PRI properties
   for (i = 0; i < GameReplicationInfo.PRIArray.length; i++)
   {
      PRI = UTPlayerReplicationInfo(GameReplicationInfo.PRIArray[i]);
      if (PRI != None)
      {
         PRI.Spree = 0;
         PRI.ResetHero();
         PRI.bHasBeenHero = false;
      }
   }

   for (i = 0; i < ArrayCount(Teams); i++)
   {
      Teams[i].AI.SetObjectiveLists();
   }
}

/**
 * ActivateVehicleFactory()
 * Called by UTVehicleFactory in its PostBeginPlay()
 * If bUnlockedVehicles=True then unlock all vehicles
 */
function ActivateVehicleFactory(UTVehicleFactory VF)
{
   if ( bUnlockedVehicles )
      VF.bStartNeutral = True;

   if ( VF.bStartNeutral )
      VF.Activate(255);
   else
      super.ActivateVehicleFactory(VF);
}

/**
 * called in DominationObjective to safely get the current value of bVehiclesCanCapturePoints
 * 
 * @return  the value of bVehiclesCanCapturePoints
 */
function bool CanVehiclesCanCapturePoints()
{
   return bVehiclesCanCapturePoints;
}

function UTGameObjective ClosestObjectiveTo(Actor A)
{
   local float Distance, BestDistance;
   local UTGameObjective Best;
   local int i;

   for ( i=0; i<iCP; i++ )
   {
      Distance = VSize(A.Location - CDomPoints[i].HomeBase.Location);
      if ( (Best == None) || (Distance < BestDistance) )
      {
         BestDistance = Distance;
         Best = CDomPoints[i].HomeBase;
      }
   }
   return Best;
}

function ShowPathTo(PlayerController P, int TeamNum)
{
   local UTGameObjective Best;
   local int i;

   Best = None;
   for ( i=0; i<iCP; i++ )
   {
      if (CDomPoints[i].BetterObjectiveThan(Best, TeamNum, P.PlayerReplicationInfo.GetTeamNum()))
         Best = CDomPoints[i].HomeBase;
   }

   if (Best != None && P.FindPathToward(Best, False) != None)
      Spawn(class'UTWillowWhisp', P,, P.Pawn.Location);
}

function SetEndGameFocus(PlayerReplicationInfo Winner)
{
   local Controller C;
   local PlayerReplicationInfo HighestScorer;
   local UTPawn P;
   local byte WinnerIndex;
   local int i, NumOfPawns, BestNumOfPawns;
   local array<ControlPoint> WinnerTeamCP;
   local ControlPoint best;

   if (Winner != None && Winner.Team != None)
      WinnerIndex = Winner.Team.TeamIndex;
   else
      WinnerIndex = GetHighestScoringTeamIndex();

   // make a list of all the control points owned by the winning team.
   for ( i=0; i < CDomPoints.Length; i++ )
   {
      if ((CDomPoints[i].ControllingTeam != None) && (CDomPoints[i].ControllingTeam.TeamIndex == WinnerIndex))
         WinnerTeamCP.AddItem(CDomPoints[i]);
   }
   // Get the winning teams Highest Scoring player
   foreach WorldInfo.AllControllers(class'Controller', C)
   {
      if (C != None && C.PlayerReplicationInfo != None)
      {
         if ( C.bIsPlayer && !C.PlayerReplicationInfo.bOutOfLives && (C.PlayerReplicationInfo.GetTeamNum() == WinnerIndex)
            && ((HighestScorer == None) || (C.PlayerReplicationInfo.Score >= HighestScorer.Score)) )
         {
            HighestScorer = C.PlayerReplicationInfo;
         }
      }
   }
   // Find a ControlPoint that is the wining teams, that also has the most players around it.
   // It looks better when players are near it.
   if (WinnerTeamCP.Length > 0)
   {
      for ( i=0; i < WinnerTeamCP.Length; i++ )
      {
         NumOfPawns = 0;
         foreach WorldInfo.AllPawns(class'UTPawn', P, WinnerTeamCP[i].Location, 512)
         {
            if (P.Controller != None && P.Controller.PlayerReplicationInfo != None)
            {
               // Total up the pawn count
               NumOfPawns++;
               // if the highest scoring player on the winning team is near a control point, focus on that player.
               if ((HighestScorer != None) && (P.Controller.PlayerReplicationInfo == HighestScorer))
               {
                  EndGameFocus = WinnerTeamCP[i];
                  break;
               }
            }
         }

         if ( EndGameFocus != None )
            break;
         else if (best == None || (best != None && NumOfPawns > BestNumOfPawns))
         {
            BestNumOfPawns = NumOfPawns;
            best = WinnerTeamCP[i];
         }
      }

      if (EndGameFocus == None)
      {
         if (best != None)
            EndGameFocus = best;
         else
         {
            i = Rand(WinnerTeamCP.Length);
            EndGameFocus = WinnerTeamCP[i];
         }
      }
   }

   if ( EndGameFocus != None )
      EndGameFocus.bAlwaysRelevant = True;

   foreach WorldInfo.AllControllers(class'Controller', C)
   {
      C.GameHasEnded(EndGameFocus, (C.PlayerReplicationInfo != None) && (C.PlayerReplicationInfo.Team == GameReplicationInfo.Winner) );
   }
}

/**
 * Called when a Controller is logout from the game or changes teams.
 * If there is atleast one teammate left on the team, then the team will continue to be in controll of 
 * the leaving Controllers ControlPoints.If there is no other teammates left on the team after the 
 * player changes teams/logout, then any ControlPoints controlled by the Controller is set back to Neutral.
 * 
 * @param   Other The Controller who is changing teams or is logout
 */
function ClearControl(Controller Other)
{
   local Controller P;
   local array<Controller> Pick;
   local int Num, i;
   local UTPlayerReplicationInfo PickPRI;

   // find a teammate
   if ( Other == None || !Other.bIsPlayer || Other.PlayerReplicationInfo.Team == None || Other.PlayerReplicationInfo.GetTeamNum() > 3 )
      return;

   foreach WorldInfo.AllControllers(class'Controller', P)
   {
      if ((P != None && P.PlayerReplicationInfo.Team != None) && P.bIsPlayer && (P != Other)
         && (P.PlayerReplicationInfo.GetTeamNum() == Other.PlayerReplicationInfo.GetTeamNum())
         && (P.PlayerReplicationInfo != Other.PlayerReplicationInfo))
      {
         Pick.AddItem(P);
      }
   }

   if (Pick.Length > 0)
   {
      Num = Rand(Pick.Length);
      if (Pick[Num].PlayerReplicationInfo != None)
      {
         PickPRI = UTPlayerReplicationInfo(Pick[Num].PlayerReplicationInfo);
         for ( i=0; i<CDomPoints.Length; i++ )
         {
            if (CDomPoints[i].HolderPRI == UTPlayerReplicationInfo(Other.PlayerReplicationInfo))
            {
               if (Pick[Num].Pawn != None)
                  CDomPoints[i].ControllingPawn = Pick[Num].Pawn;

               CDomPoints[i].HolderPRI = PickPRI;
               CDomPoints[i].UpdateStatus();
            }
         }
         return;
      }
   }

   // No teammate found, so reset the point
   PickPRI = None;
   for ( i=0; i<CDomPoints.Length; i++ )
   {
      if (CDomPoints[i].HolderPRI == UTPlayerReplicationInfo(Other.PlayerReplicationInfo))
         CDomPoints[i].ResetPoint(False);
   }
}

/**
 * Return a saved team number if player has one
 */
function byte PickTeam(byte num, Controller C)
{
   if ( bShowPickTeamAtLogin 
      && ( C != none
      && C.PlayerReplicationInfo != none 
      && DomPRI(C.PlayerReplicationInfo) != none 
      && !DomPRI(C.PlayerReplicationInfo).bTeamPickerMenuDone ) 
      && ( DomPlayerController(C) != none 
      && DomPlayerController(C).HasSavedTeam() ) )
   {
      return DomPlayerController(C).GetSavedTeamID(GameReplicationInfo.Teams.Length);
   }
      
   return super.PickTeam(num,C);
}

/**
 * ChangeTeam()
 * verify whether controller Other is allowed to change team, and if so change his team by calling SetTeam().
 * @param Other:  the controller which wants to change teams
 * @param num:  the teamindex of the desired team.  If 255, pick the smallest team.
 * @param bNewTeam:  if true, broadcast team change notification
 */
function bool ChangeTeam(Controller Other, int num, bool bNewTeam)
{
   local UTTeamInfo NewTeam, PendingTeam;
   local UniqueNetId ZeroNetId;
   local int i;

   // no team changes after initial change if single player campaign
   if ( (SinglePlayerMissionID != -1) && (Other.PlayerReplicationInfo.Team != None) )
      return false;

   // check if only allow team changes before match starts
   if ( bMustJoinBeforeStart && GameReplicationInfo.bMatchHasBegun )
      return false;

   // don't add spectators to teams
   if ( Other.IsA('PlayerController') && Other.PlayerReplicationInfo.bOnlySpectator )
   {
      Other.PlayerReplicationInfo.Team = None;
      return true;
   }

   // Give mutators a chance to block team changes
   if (BaseMutator != none && !BaseMutator.AllowChangeTeam(Other, num, bNewTeam))
      return False;

   //workaround for friend following
   if (CurrentFriendId != ZeroNetId)
   {
      NewTeam = (num < 255) ? MultiTeams[PickFriendTeam(num, Other, CurrentFriendId)] : None;
   }
   else
   {
      NewTeam = (num < 255) ? MultiTeams[PickTeam(num,Other)] : none;
   }

   // check if already on this team
   if ( Other.PlayerReplicationInfo.Team == NewTeam )
   {
      // may have returned current team if not allowed to switch
      // if not allowed to switch, set up or complete proposed swap
      if((num < NumTeams)
         && (num != NewTeam.TeamIndex)
         && !bPlayersVsBots
         && (PlayerController(Other) != none)
         && (UTTeamInfo(Other.PlayerReplicationInfo.Team) != none) )
      {
         // This is to allow team changes when using the Team Picker and playing offline
         if ((WorldInfo.NetMode == NM_Standalone) 
            && !bPlayersVsBots
            && (PlayerController(Other) != none)
            && (Other.PlayerReplicationInfo.Team != none) )
         {
            i = num;
            num = Other.PlayerReplicationInfo.Team.TeamIndex + 1;
            if (num >= GameReplicationInfo.Teams.Length)
               num = 0;

            if (MultiTeams[num] != none)
            {
               NewTeam = MultiTeams[num];
               SetTeam(Other, NewTeam, bNewTeam);
               return true;
            }
            num = i;
         }
         // check if swap request is pending
         if ( PendingTeamSwap != None )
         {
            if ( PendingTeamSwap.bDeleteMe || (WorldInfo.TimeSeconds - SwapRequestTime > 8.0) )
            {
               PendingTeamSwap = None;
            }
            else if ( PendingTeamSwap.PlayerReplicationInfo.Team.TeamIndex == num )
            {
               // do the swap!
               PendingTeam = UTTeamInfo(PendingTeamSwap.PlayerReplicationInfo.Team);
               if (PendingTeam != None )
               {
                  SetTeam(PendingTeamSwap, UTTeamInfo(Other.PlayerReplicationInfo.Team), true);
                  if ( PendingTeamSwap.Pawn != None )
                     PendingTeamSwap.Pawn.PlayerChangedTeam();
                  PendingTeamSwap = None;
                  SetTeam(Other, PendingTeam, bNewTeam);
                  return true;
               }
            }
         }
         // set pending swap request
         PendingTeamSwap = PlayerController(Other);
         SwapRequestTime = WorldInfo.TimeSeconds;

         // broadcast swap request
         BroadcastLocalizedMessage(class'UTTeamGameMessage', 0, PendingTeamSwap.PlayerReplicationInfo);
      }
      return false;
   }
   // set the new team for Other
   SetTeam(Other, NewTeam, bNewTeam);
   return true;
}

/**
 * Logic to display the UI_UT3Dom.DomTeamConfig scene if bShowPickTeamAtLogin is true
 */
event PostLogin( playercontroller NewPlayer )
{
   local UTGameReplicationInfo GRI;
   local DomPlayerController PC;

   Super.PostLogin(NewPlayer);

   if ( !WorldInfo.IsConsoleBuild() )
   {
      PC = DomPlayerController(NewPlayer);
      if (PC != None)
      {
         GRI = UTGameReplicationInfo(GameReplicationInfo);
         if ( GRI != none && PC.PlayerReplicationInfo != none && DomPRI(PC.PlayerReplicationInfo) != none && !PC.PlayerReplicationInfo.bBot &&
            ( bShowPickTeamAtLogin && !DomPRI(PC.PlayerReplicationInfo).bTeamPickerMenuDone ) && !GRI.bStoryMode && !GRI.bMatchHasBegun && (NetWait - PendingMatchElapsedTime > 5) )
         {
            DomPRI(PC.PlayerReplicationInfo).ShowMidGameMenu(true);
         }
      }
   }
}

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

/**
 * Used to update any changes in game settings that need to be published to
 * players that are searching for games
 */
function UpdateGameSettings()
{
   super.UpdateGameSettings();

   // Set CONTEXT_GAME_MODE to CONTEXT_GAME_MODE_CUSTOM
   if (GameSettings != None && GameInterface != None)
   {
      GameSettings.SetStringSettingValue(class'UTGameSearchCommon'.const.CONTEXT_GAME_MODE,class'UTGameSearchCommon'.const.CONTEXT_GAME_MODE_CUSTOM, False);
      GameInterface.UpdateOnlineGame(GameSettings);
   }
}

/**
 * There is no achivements that should be awarded. Do nothing here. 
 */
function CheckTeamBasedAchievements();

DefaultProperties
{
   DOMVer="5.0 Build:10.12.14"  /* Build: YY.MM.DD */
   bExportMenuData=False
   bUseMapList=True
   bAllowTranslocator=True
   bUseTranslocator=True
   bUnlockedVehicles=True
   bVehiclesCanCapturePoints=True
   bTeamGame=True
   bNoTeamChangePenalty=True
   bScoreDeaths=False
   bScoreTeamKills=False
   bSpawnInTeamArea=False
   bScoreVictimsTarget=True
   bWeaponStay=True
   bLoggingGame=True
   bDDOMGame=False
   GoalScore=100
   TimeLimit=0
   MinTeams=2
   NumTeams=2
   NumOfTeams=2
   MaxControlPoints=32
   MaxControlPointsAllowed=32
   TranslocatorClass=class'UTDom.DOMWeap_Translocator_Content'
   UnlimitedTranslocatorClass=class'UTDom.DOMWeap_UnlimitedTranslocator_Content'
   DeathMessageClass=class'UTGame.UTTeamDeathMessage'
   HUDType=class'UTDom.DOMHUD'
   BotClass=class'UTBot'
   DefaultPawnClass=class'UTDom.DOMPawn'
   PlayerControllerClass=class'DomPlayerController'
   PlayerReplicationInfoClass=class'UTDom.DomPRI'
   GameReplicationInfoClass=Class'UTDom.DomGameReplicationInfo'
   CharacterTeamMaterialTransformerClass=class'UTDom.DOM_MT_CharacterTeamMaterialTransformer'
   VehicleTeamMaterialTransformerClass=class'UTDom.DOM_MT_VehicleTeamMaterialTransformer_Content'
`if(`isdefined(PLATFORM_PS3))
   MaxTeams=2
   GameName="Domination"
   Description="Fight for possession of ControlPoints by touching it and your score increases until taken by another team."
   MidGameMenuTemplate=UTUIScene_MidGameMenu'UI_InGameHud.Menus.MidGameMenu'
   MidGameMenuTemplates(0)=UTUIScene_MidGameMenu'UI_InGameHud.Menus.MidGameMenu'
   MidgameScorePanelTag=TDMPanel
   MidGameScorePanelTags(0)=TDMPanel
   bShowPickTeamAtLogin=False
`else
   bShowPickTeamAtLogin=True
   MaxTeams=4
   MidGameMenuTemplate=UTUIScene_MidGameMenu'UI_UT3Dom.Menus.DomMidGameMenu'
   MidGameMenuTemplates(0)=UTUIScene_MidGameMenu'UI_UT3Dom.Menus.DomMidGameMenu2'
   MidGameMenuTemplates(1)=UTUIScene_MidGameMenu'UI_UT3Dom.Menus.DomMidGameMenu3'
   MidGameMenuTemplates(2)=UTUIScene_MidGameMenu'UI_UT3Dom.Menus.DomMidGameMenu'
   MidGameScorePanelTag=DOMPanel
   MidGameScorePanelTags(0)=DOMPanel
   MidGameScorePanelTags(1)=DOMPanel
   MidGameScorePanelTags(2)=DOMPanel
`endif
   MultiTeamAIType(0)=class'UTDom.DOMTeamAI'
   MultiTeamAIType(1)=class'UTDom.DOMTeamAI'
   MultiTeamAIType(2)=class'UTDom.DOMTeamAI'
   MultiTeamAIType(3)=class'UTDom.DOMTeamAI'
   DefaultMutators(0)="UTDom.DOM_MT_UTMutator_WeaponReplacer"
   NonScoringDamageClasses(0)=None
   NonScoringDamageClasses(1)=None
   ControlPointType[0]=class'UTDom.ControlPoint'
   DefaultMapPrefixes(0)=(Prefix="DOM",GameType="UTDom.Domination",AdditionalGameTypes=("UTDom.DoubleDom"))
   DefaultMapPrefixes(1)=(Prefix="CDOM",GameType="UTDom.Domination",AdditionalGameTypes=("UTDom.DoubleDom"))
   DefaultMapPrefixes(2)=(Prefix="DDOM",GameType="UTDom.DoubleDom",AdditionalGameTypes=("UTDom.Domination"))
   DefaultMapPrefixes(3)=(Prefix="VDOM",GameType="UTDom.Domination",AdditionalGameTypes=("UTDom.DoubleDom"))
   MapPrefixes(0)="DOM"
   MapPrefixes(1)="CDOM"
   MapPrefixes(2)="DDOM"
   MapPrefixes(3)="VDOM"
}