Ticket #2130: endgame.diff

binaries/data/mods/public/simulation/components/EndGameManager.js

@@ -19 +19 @@
     // Allied victory means allied players can win if victory conditions are met for each of them
     // Would be false for a "last man standing" game (when diplomacy is fully implemented)
     this.alliedVictory = true;
+    this.activePlayers = [];
 };
 
 EndGameManager.prototype.SetGameType = function(newGameType)
@@ -31 +32 @@
     this.alliedVictory = flag;
 };
 
-/**
- * Begin checking the end-game conditions.
- * Must be called once, after calling SetGameType.
- */
-EndGameManager.prototype.Start = function()
+EndGameManager.prototype.OnUpdate = function()
 {
-    if (this.gameType != "endless")
+    if (this.gameType == "endless")
+        return;
+    // initialise the activePlayers array on the start of the game 
+    if (!this.activePlayers.length)
     {
-        var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
-        this.timer = cmpTimer.SetTimeout(this.entity, IID_EndGameManager, "ProgressTimeout", g_ProgressInterval, {});
+        this.UpdatePlayerStates();
+        return;
     }
-};
 
-EndGameManager.prototype.OnDestroy = function()
-{
-    if (this.timer)
-    {
-        var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
-        cmpTimer.CancelTimer(this.timer);
-    }
-};
+    if (!this.activePlayers.every(function(v){return v.GetConquestCriticalEntitiesCount()}))
+        this.UpdatePlayerStates();
+}
 
-EndGameManager.prototype.ProgressTimeout = function(data)
+EndGameManager.prototype.UpdatePlayerStates = function()
 {
-    this.UpdatePlayerStates();
-    
-    // Repeat the timer
-    var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
-    this.timer = cmpTimer.SetTimeout(this.entity, IID_EndGameManager, "ProgressTimeout", g_ProgressInterval, data);
-};
+    if (this.gameType == "endless")
+        return;
 
-EndGameManager.prototype.UpdatePlayerStates = function()
-{
     var cmpPlayerManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
-    switch (this.gameType)
+    var numPlayers = cmpPlayerManager.GetNumPlayers();
+    this.activePlayers = [];
+
+    // get all the active players (or won). Defeat players without the needed entities
+    for (var i = 1; i < numPlayers; ++i)
     {
-    case "conquest":
+        var playerEntity = cmpPlayerManager.GetPlayerByID(i);
+        var cmpPlayer = Engine.QueryInterface(playerEntity, IID_Player);
+        if (cmpPlayer.GetState() == "defeated")
+            continue;
+        if (cmpPlayer.GetConquestCriticalEntitiesCount())
+            this.activePlayers.push(cmpPlayer);
+        else
+            Engine.PostMessage(playerEntity, MT_PlayerDefeated);
+    }
 
-        // Ignore gaia
-        var numPlayers = cmpPlayerManager.GetNumPlayers() - 1;
-        var cmpPlayers = new Array(numPlayers);
-        
-        // If a player is currently active but has no suitable units left,
-        // mark that player as defeated
-        for (var i = 0; i < numPlayers; i++)
-        {
-            var playerEntityId = cmpPlayerManager.GetPlayerByID(i+1);
-            cmpPlayers[i] = Engine.QueryInterface(playerEntityId, IID_Player);
-            if (cmpPlayers[i].GetState() == "active")
-            {
-                if (cmpPlayers[i].GetConquestCriticalEntitiesCount() == 0)
-                {   // Defeated - notify AIs by sending playerId
-                    Engine.PostMessage(playerEntityId, MT_PlayerDefeated, { "playerId": i } );
-                }
-            }
-        }
+    if (!this.alliedVictory && this.activePlayers.length > 1)
+        return;
 
-        var onlyAlliesLeft = true;
-        var allies = [];
-        for (var i = 0; i < numPlayers && onlyAlliesLeft; i++)
-        {
-            if (cmpPlayers[i].GetState() == "active")
-            {   //Active player
-                for (var j = 0; j < numPlayers && onlyAlliesLeft; j++)
-                {
-                    if (cmpPlayers[j].GetState() == "active"
-                        && (cmpPlayers[i].IsEnemy(j+1) || cmpPlayers[j].IsEnemy(i+1)
-                            || cmpPlayers[i].IsNeutral(j+1) || cmpPlayers[j].IsNeutral(i+1)))
-                    {   // Only need to find an active non-allied player
-                        onlyAlliesLeft = false;
-                    }
-                }
-                
-                if (onlyAlliesLeft)
-                    allies.push(i);
-            }
-        }
+    for each (var cmpPlayer in this.activePlayers)
+    {
+        if (!this.activePlayers.every(function(v){return cmpPlayer == v || cmpPlayer.IsMutualAlly(v.GetPlayerID())}))
+            return;
+    }
 
-        // If only allies left and allied victory set (or only one player left)
-        if (onlyAlliesLeft && (this.alliedVictory || allies.length == 1))
-        {
-            for each (var p in allies)
-            {
-                cmpPlayers[p].SetState("won");
-            }
-
-            // Reveal the map to all players
-            var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
-            cmpRangeManager.SetLosRevealAll(-1, true);
-        }
-
-        break;
-
-    default:
-        error("Invalid game type "+this.gameType);
-        break;
-    }
+    var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+    cmpRangeManager.SetLosRevealAll(-1, true);
+    for each (var cmpPlayer in this.activePlayers)
+        cmpPlayer.SetState("won");
 };
 
 Engine.RegisterComponentType(IID_EndGameManager, "EndGameManager", EndGameManager);

binaries/data/mods/public/simulation/helpers/Setup.js

@@ -41 +41 @@
     {
         cmpEndGameManager.SetGameType(settings.GameType);
     }
-    cmpEndGameManager.Start();
 }
 
 Engine.RegisterGlobal("LoadMapSettings", LoadMapSettings);