Ticket #4143: petra_lastmanstanding_v1.1.patch

binaries/data/mods/public/simulation/ai/common-api/gamestate.js

@@ -21 +21 @@
     this.playerData = SharedScript.playersData[this.player];
     this.barterPrices = SharedScript.barterPrices;
     this.gameType = SharedScript.gameType;
+    this.alliedVictory = SharedScript.alliedVictory;
+    this.ceasefireActive = SharedScript.ceasefireActive;
 
     // get the list of possible phases for this civ:
     // we assume all of them are researchable from the civil centre
@@ -55 +57 @@
     this.timeElapsed = SharedScript.timeElapsed;
     this.playerData = SharedScript.playersData[this.player];
     this.barterPrices = SharedScript.barterPrices;
+    this.ceasefireActive = SharedScript.ceasefireActive;
 };
 
 m.GameState.prototype.updatingCollection = function(id, filter, collection)
@@ -117 +120 @@
     return this.gameType;
 };
 
+m.GameState.prototype.getAlliedVictory = function()
+{
+    return this.alliedVictory;
+};
+
+m.GameState.prototype.isCeasefireActive = function()
+{
+    return this.ceasefireActive;
+};
+
 m.GameState.prototype.getTemplate = function(type)
 {
     if (this.techTemplates[type] !== undefined)
@@ -291 +304 @@
 m.GameState.prototype.hasAllies = function()
 {
     for (let i in this.playerData.isAlly)
-        if (this.playerData.isAlly[i] && +i !== this.player)
+        if (this.playerData.isAlly[i] && +i !== this.player &&
+            this.sharedScript.playersData[i].state !== "defeated")
             return true;
     return false;
 };
 
+m.GameState.prototype.hasEnemies = function()
+{
+    for (let i in this.playerData.isEnemy)
+        if (this.playerData.isEnemy[i] && +i !== 0 &&
+            this.sharedScript.playersData[i].state !== "defeated")
+            return true;
+    return false;
+};
+
 m.GameState.prototype.isPlayerAlly = function(id)
 {
     return this.playerData.isAlly[id];
@@ -408 +431 @@
     return this.updatingGlobalCollection("" + this.player + "-units", m.Filters.byClass("Unit"), this.getOwnEntities());
 };
 
-m.GameState.prototype.getAllyEntities = function()
+m.GameState.prototype.getAllyEntities = function(allyID)
 {
-    return this.entities.filter(m.Filters.byOwners(this.getAllies()));
+    if (allyID === undefined)
+        return this.entities.filter(m.Filters.byOwners(this.getAllies()));
+
+    return this.updatingGlobalCollection("" + allyID + "-entities", m.Filters.byOwner(allyID));
 };
 
 m.GameState.prototype.getExclusiveAllyEntities = function()

binaries/data/mods/public/simulation/ai/common-api/shared.js

@@ -142 +142 @@
     this.mapSize = state.mapSize;
     this.gameType = state.gameType;
     this.barterPrices = state.barterPrices;
+    this.alliedVictory = state.alliedVictory;
+    this.ceasefireActive = state.ceasefireActive;
 
     this.passabilityMap = state.passabilityMap;
     if (this.mapSize % this.passabilityMap.width !== 0)
@@ -241 +243 @@
     this.playersData = state.players;
     this.timeElapsed = state.timeElapsed;
     this.barterPrices = state.barterPrices;
+    this.ceasefireActive = state.ceasefireActive;
 
     this.passabilityMap = state.passabilityMap;
     this.passabilityMap.cellSize = this.mapSize / this.passabilityMap.width;

binaries/data/mods/public/simulation/ai/petra/chatHelper.js

@@ -130 +130 @@
     });
 };
 
+m.chatNewDiplomacy = function(gameState, player, enemy)
+{
+    let message;
+    if (enemy)
+        message = markForTranslation("%(_player_)s and I are now enemies.");
+    else
+        message = markForTranslation("%(_player_)s and I are now allies.");
+
+    Engine.PostCommand(PlayerID, {
+        "type": "aichat",
+        "message": message,
+        "translateMessage": true,
+        "translateParameters": ["_player_"],
+        "parameters": {"_player_": player}
+    });
+};
+
 return m;
 }(PETRA);

binaries/data/mods/public/simulation/ai/petra/diplomacyManager.js

@@ -13 +13 @@
     this.nextTributeUpdate = -1;
     this.nextTributeRequest = new Map();
     this.nextTributeRequest.set("all", 240);
+    this.allyBetrayLapseTime = -1;
+    this.waitingToBetray = false;
 };
 
 /**
@@ -108 +110 @@
             continue;
         this.Config.personality.cooperative = Math.min(1, this.Config.personality.cooperative + 0.003);
     }
+
+    if (events.DiplomacyChanged.length || events.PlayerDefeated.length || events.CeasefireEnded.length)
+        this.lastManStandingCheck(gameState);
 };
 
+/**
+ * Check if the only remaining players are allies. If so, turn against the strongest first
+ * if the "Last Man Standing" option is enabled
+ */
+m.DiplomacyManager.prototype.lastManStandingCheck = function(gameState)
+{
+    if (gameState.getAlliedVictory() || gameState.isCeasefireActive())
+        return;
 
+    if (gameState.hasEnemies())
+    {
+        this.waitingToBetray = false;
+        return;
+    }
+
+    if (!gameState.hasAllies())
+        return;
+
+    // wait a bit before turning
+    if (!this.waitingToBetray)
+    {
+        this.allyBetrayLapseTime = gameState.ai.elapsedTime + Math.random() * 100 + 10;
+        this.waitingToBetray = true;
+        return;
+    }
+
+    // do not turn against an ally yet if we are not strong enough
+    if (gameState.getOwnUnits().length < 50)
+    {
+        this.allyBetrayLapseTime += 60;
+        return;
+    }
+
+    let allyToTurnAgainst;
+    let allyEntities = 0;
+    let max = 0;
+
+    // count the amount of entities our allies have
+    for (let i = 1; i < gameState.sharedScript.playersData.length; ++i)
+    {
+        if (i === PlayerID || gameState.ai.HQ.attackManager.defeated[i])
+            continue;
+
+        allyEntities = gameState.getAllyEntities(i).length;
+
+        if (allyEntities < max)
+            continue;
+
+        max = allyEntities;
+        allyToTurnAgainst = i;
+    }
+
+    if (allyToTurnAgainst)
+    {
+        Engine.PostCommand(PlayerID, { "type": "diplomacy", "player": allyToTurnAgainst, "to": "enemy" });
+        if (this.Config.debug > 1)
+            API3.warn("player " + allyToTurnAgainst + " is now an enemy");
+        if (this.Config.chat)
+            m.chatNewDiplomacy(gameState, allyToTurnAgainst, true);
+    }
+    this.allyBetrayLapseTime = -1;
+    this.waitingToBetray = false;
+};
+
 m.DiplomacyManager.prototype.update = function(gameState, events)
 {
     this.checkEvents(gameState, events);
@@ -117 +185 @@
 
     if (!gameState.ai.HQ.saveResources && gameState.ai.elapsedTime > this.nextTributeUpdate)
         this.tributes(gameState);
+
+    if (this.waitingToBetray && gameState.ai.elapsedTime > this.allyBetrayLapseTime)
+        this.lastManStandingCheck(gameState);
 };
 
 m.DiplomacyManager.prototype.Serialize = function()
 {
-    return { "nextTributeUpdate": this.nextTributeUpdate, "nextTributeRequest": this.nextTributeRequest };
+    return {
+        "nextTributeUpdate": this.nextTributeUpdate,
+        "nextTributeRequest": this.nextTributeRequest,
+        "allyBetrayLapseTime": this.allyBetrayLapseTime,
+        "waitingToBetray": this.waitingToBetray
+    };
 };
 
 m.DiplomacyManager.prototype.Deserialize = function(data)
 {
-    this.nextTributeUpdate = data.nextTributeUpdate;
-    this.nextTributeRequest = data.nextTributeRequest;
+    for (let key in data)
+        this[key] = data[key];
 };
 
 return m;

binaries/data/mods/public/simulation/ai/petra/headquarters.js

@@ -82 +82 @@
     this.treasures.registerUpdates();
     this.currentPhase = gameState.currentPhase();
     this.decayingStructures = new Set();
+    this.diplomacyManager.lastManStandingCheck(gameState);
 };
 
 /**

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

@@ -20 +20 @@
     "TerritoriesChanged",
     "TerritoryDecayChanged",
     "TributeExchanged",
-    "AttackRequest"
+    "AttackRequest",
+    "CeasefireEnded"
 ];
 
 AIInterface.prototype.Init = function()
@@ -197 +198 @@
     this.events.TerritoriesChanged.push(msg);
 };
 
+AIInterface.prototype.OnCeasefireEnded = function(msg)
+{
+    this.events.CeasefireEnded.push(msg);
+};
+
 /**
  * When a new technology is researched, check which templates it affects,
  * and send the updated values to the AI.

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

@@ -76 +76 @@
     this.alliedVictory = flag;
 };
 
+EndGameManager.prototype.GetAlliedVictory = function()
+{
+    return this.alliedVictory;
+};
+
 EndGameManager.prototype.AlliedVictoryCheck = function()
 {
     if (this.skipAlliedVictoryCheck)

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

@@ -144 +144 @@
         ret.ceasefireTimeRemaining = ret.ceasefireActive ? cmpCeasefireManager.GetCeasefireStartedTime() + cmpCeasefireManager.GetCeasefireTime() - ret.timeElapsed : 0;
     }
 
-    // Add the game type
+    // Add the game type and allied victory
     let cmpEndGameManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_EndGameManager);
     ret.gameType = cmpEndGameManager.GetGameType();
+    ret.alliedVictory = cmpEndGameManager.GetAlliedVictory();
 
     // Add bartering prices
     let cmpBarter = Engine.QueryInterface(SYSTEM_ENTITY, IID_Barter);

binaries/data/mods/public/simulation/components/tests/test_EndGameManager.js

@@ +1 @@
+Engine.LoadComponentScript("interfaces/Player.js");
+Engine.LoadComponentScript("interfaces/EndGameManager.js");
+Engine.LoadComponentScript("Player.js");
+
+Engine.LoadComponentScript("PlayerManager.js");
+Engine.LoadComponentScript("EndGameManager.js");
+Engine.LoadComponentScript("GuiInterface.js");
+
+let cmpEndGameManager = ConstructComponent(SYSTEM_ENTITY, "EndGameManager");
+let playerEnt1 = 1;
+let wonderDuration = 1;
+
+let gameTypeSettings = {};
+gameTypeSettings.wonderDuration = wonderDuration * 60 * 1000;
+
+AddMock(SYSTEM_ENTITY, IID_PlayerManager, {
+    "GetNumPlayers": () => 4
+});
+
+AddMock(SYSTEM_ENTITY, IID_GuiInterface, {
+    "DeleteTimeNotification": () => null,
+    "AddTimeNotification": () => 1
+});
+
+AddMock(playerEnt1, IID_Player, {
+    "GetName": () => "Player 1",
+    "GetState": () => "active",
+});
+
+let cmpPlayerManager = ConstructComponent(SYSTEM_ENTITY, "PlayerManager");
+
+TS_ASSERT_EQUALS(cmpEndGameManager.skipAlliedVictoryCheck, true);
+cmpEndGameManager.SetAlliedVictory(true);
+TS_ASSERT_EQUALS(cmpEndGameManager.GetAlliedVictory(), true);
+cmpEndGameManager.SetGameType("wonder", gameTypeSettings);
+TS_ASSERT_EQUALS(cmpEndGameManager.CheckGameType("regicide"), false);
+TS_ASSERT_EQUALS(cmpEndGameManager.skipAlliedVictoryCheck, false);
+TS_ASSERT(cmpEndGameManager.GetGameType() == "wonder");
+TS_ASSERT_EQUALS(cmpEndGameManager.GetGameTypeSettings().wonderDuration, 60000);
+cmpEndGameManager.AlliedVictoryCheck();

binaries/data/mods/public/simulation/components/tests/test_GuiInterface.js

@@ -47 +47 @@
 });
 
 AddMock(SYSTEM_ENTITY, IID_EndGameManager, {
-    GetGameType: function() { return "conquest"; }
+    GetGameType: function() { return "conquest"; },
+    GetAlliedVictory: function() { return false; }
 });
 
 AddMock(SYSTEM_ENTITY, IID_PlayerManager, {
@@ -331 +332 @@
     circularMap: false,
     timeElapsed: 0,
     gameType: "conquest",
+    alliedVictory: false,
     barterPrices: {buy: {food: 150}, sell: {food: 25}}
 });
 
@@ -450 +452 @@
     circularMap: false,
     timeElapsed: 0,
     gameType: "conquest",
+    alliedVictory: false,
     barterPrices: {buy: {food: 150}, sell: {food: 25}}
 });