Ticket #4143: petra_lastmanstanding_v1.3_rebased.patch

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

@@ -19 +19 @@
     this.entities = SharedScript.entities;
     this.player = player;
     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
     this.phases = [ { name: "phase_village" }, { name: "phase_town" }, { name: "phase_city" } ];
     let cctemplate = this.getTemplate(this.applyCiv("structures/{civ}_civil_centre"));
@@ -53 +55 @@
 m.GameState.prototype.update = function(SharedScript)
 {
     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)
 {
     let gid = this.player + "-" + id;   // automatically add the player ID
@@ -115 +118 @@
 m.GameState.prototype.getGameType = function()
 {
     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)
         return new m.Technology(this.techTemplates, type);
 
@@ -289 +302 @@
 };
 
 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.hasNeutrals = function()
+{
+    for (let i in this.playerData.isNeutral)
+        if (this.playerData.isNeutral[i] &&
+            this.sharedScript.playersData[i].state !== "defeated")
+            return true;
+    return false;
+};
+
+m.GameState.prototype.isPlayerNeutral = function(id)
+{
+    return this.playerData.isNeutral[id];
+};
+
 m.GameState.prototype.isPlayerAlly = function(id)
 {
     return this.playerData.isAlly[id];
 };
 
@@ -381 +418 @@
         return this.entities._entities.get(+id);
 
     return undefined;
 };
 
-m.GameState.prototype.getEntities = function()
+m.GameState.prototype.getEntities = function(id)
 {
-    return this.entities;
+    if (id === undefined)
+        return this.entities;
+
+    return this.updatingGlobalCollection("" + id + "-entities", m.Filters.byOwner(id));
 };
 
 m.GameState.prototype.getStructures = function()
 {
     return this.updatingGlobalCollection("structures", m.Filters.byClass("Structure"), this.entities);

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

@@ -140 +140 @@
     this.timeElapsed = state.timeElapsed;
     this.circularMap = state.circularMap;
     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)
          error("AI shared component inconsistent sizes: map=" + this.mapSize + " while passability=" + this.passabilityMap.width);
     this.passabilityMap.cellSize = this.mapSize / this.passabilityMap.width;
@@ -239 +241 @@
     this.events = state.events;
     this.passabilityClasses = state.passabilityClasses;
     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;
     this.territoryMap = state.territoryMap;
     this.territoryMap.cellSize = this.mapSize / this.territoryMap.width;

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

@@ -128 +128 @@
         "translateParameters": ["phase"],
         "parameters": { "phase": phase }
     });
 };
 
+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

@@ -11 +11 @@
 {
     this.Config = Config;
     this.nextTributeUpdate = -1;
     this.nextTributeRequest = new Map();
     this.nextTributeRequest.set("all", 240);
+    this.betrayLapseTime = -1;
+    this.waitingToBetray = false;
 };
 
 /**
  * Check if any allied needs help (tribute) and sent it if we have enough resource
  * or ask for a tribute if we are in need and one ally can help
@@ -106 +108 @@
         let attacker = gameState.getEntityById(evt.attacker);
         if (!attacker || attacker.owner() === PlayerID || !gameState.isPlayerAlly(attacker.owner()))
             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 the diplomacy at the start of the game
+ */
+m.DiplomacyManager.prototype.diplomacyCheck = function(gameState)
+{
+    if (!gameState.getAlliedVictory() && !gameState.isCeasefireActive())
+        this.lastManStandingCheck(gameState);
 };
 
+/**
+ * If the "Last Man Standing" option is enabled, check if the only remaining players are allies or neutral.
+ * If so, turn against the strongest first, but be more likely to first turn against neutral players, if there are any.
+ */
+m.DiplomacyManager.prototype.lastManStandingCheck = function(gameState)
+{
+    if (gameState.getAlliedVictory() || gameState.isCeasefireActive())
+        return;
+
+    if (gameState.hasEnemies())
+    {
+        this.waitingToBetray = false;
+        return;
+    }
+
+    if (!gameState.hasAllies() && !gameState.hasNeutrals())
+        return;
+
+    // wait a bit before turning
+    if (!this.waitingToBetray)
+    {
+        this.betrayLapseTime = gameState.ai.elapsedTime + Math.random() * 100 + 10;
+        this.waitingToBetray = true;
+        return;
+    }
+
+    // do not turn against a player yet if we are not strong enough
+    if (gameState.getOwnUnits().length < 50)
+    {
+        this.betrayLapseTime += 60;
+        return;
+    }
+
+    let playerToTurnAgainst;
+    let turnFactor = 0;
+    let max = 0;
+
+    // count the amount of entities remaining players have
+    for (let i = 1; i < gameState.sharedScript.playersData.length; ++i)
+    {
+        if (i === PlayerID || gameState.ai.HQ.attackManager.defeated[i])
+            continue;
+
+        turnFactor = gameState.getEntities(i).length;
+
+        if (gameState.isPlayerNeutral(i)) // be more inclined to turn against neutral players
+            turnFactor += 150;
+
+        if (turnFactor < max)
+            continue;
+
+        max = turnFactor;
+        playerToTurnAgainst = i;
+    }
+
+    if (playerToTurnAgainst)
+    {
+        Engine.PostCommand(PlayerID, { "type": "diplomacy", "player": playerToTurnAgainst, "to": "enemy" });
+        if (this.Config.debug > 1)
+            API3.warn("player " + playerToTurnAgainst + " is now an enemy");
+        if (this.Config.chat)
+            m.chatNewDiplomacy(gameState, playerToTurnAgainst, true);
+    }
+    this.betrayLapseTime = -1;
+    this.waitingToBetray = false;
+};
 
 m.DiplomacyManager.prototype.update = function(gameState, events)
 {
     this.checkEvents(gameState, events);
 
     if (!gameState.ai.HQ.saveResources && gameState.ai.elapsedTime > this.nextTributeUpdate)
         this.tributes(gameState);
+
+    if (this.waitingToBetray && gameState.ai.elapsedTime > this.betrayLapseTime)
+        this.lastManStandingCheck(gameState);
 };
 
 m.DiplomacyManager.prototype.Serialize = function()
 {
-    return { "nextTributeUpdate": this.nextTributeUpdate, "nextTributeRequest": this.nextTributeRequest };
+    return {
+        "nextTributeUpdate": this.nextTributeUpdate,
+        "nextTributeRequest": this.nextTributeRequest,
+        "betrayLapseTime": this.betrayLapseTime,
+        "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;
 }(PETRA);

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

@@ -52 +52 @@
     }
 
     // configure our first base strategy
     if (this.baseManagers.length > 1)
         this.configFirstBase(gameState);
+    this.diplomacyManager.diplomacyCheck(gameState);
 };
 
 /**
  * Assign the starting entities to the different bases
  */

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

@@ -18 +18 @@
     "Garrison",
     "UnGarrison",
     "TerritoriesChanged",
     "TerritoryDecayChanged",
     "TributeExchanged",
-    "AttackRequest"
+    "AttackRequest",
+    "CeasefireEnded"
 ];
 
 AIInterface.prototype.Init = function()
 {
     this.events = {};
@@ -195 +196 @@
 AIInterface.prototype.OnTerritoriesChanged = function(msg)
 {
     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.
  * this relies on the fact that any "value" in a technology can only ever change
  * one template value, and that the naming is the same (with / in place of .)

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

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

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

@@ -142 +142 @@
     {
         ret.ceasefireActive = cmpCeasefireManager.IsCeasefireActive();
         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);
     ret.barterPrices = cmpBarter.GetPrices();
 

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

@@ -20 +20 @@
     "GetState": () => "active",
 });
 
 TS_ASSERT_EQUALS(cmpEndGameManager.skipAlliedVictoryCheck, true);
 cmpEndGameManager.SetAlliedVictory(true);
-TS_ASSERT_EQUALS(cmpEndGameManager.alliedVictory, true);
+TS_ASSERT_EQUALS(cmpEndGameManager.GetAlliedVictory(), true);
 cmpEndGameManager.SetGameType("wonder", { "wonderDuration": wonderDuration });
 TS_ASSERT_EQUALS(cmpEndGameManager.CheckGameType("regicide"), false);
 TS_ASSERT_EQUALS(cmpEndGameManager.skipAlliedVictoryCheck, false);
 TS_ASSERT(cmpEndGameManager.GetGameType() == "wonder");
 TS_ASSERT_EQUALS(cmpEndGameManager.GetGameTypeSettings().wonderDuration, wonderDuration);

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

@@ -45 +45 @@
         };
     }
 });
 
 AddMock(SYSTEM_ENTITY, IID_EndGameManager, {
-    GetGameType: function() { return "conquest"; }
+    GetGameType: function() { return "conquest"; },
+    GetAlliedVictory: function() { return false; }
 });
 
 AddMock(SYSTEM_ENTITY, IID_PlayerManager, {
     GetNumPlayers: function() { return 2; },
     GetPlayerByID: function(id) { TS_ASSERT(id === 0 || id === 1); return 100+id; },
@@ -329 +330 @@
         }
     ],
     circularMap: false,
     timeElapsed: 0,
     gameType: "conquest",
+    alliedVictory: false,
     barterPrices: {buy: {food: 150}, sell: {food: 25}}
 });
 
 TS_ASSERT_UNEVAL_EQUALS(cmp.GetExtendedSimulationState(), {
     players: [
@@ -448 +450 @@
         }
     ],
     circularMap: false,
     timeElapsed: 0,
     gameType: "conquest",
+    alliedVictory: false,
     barterPrices: {buy: {food: 150}, sell: {food: 25}}
 });
 
 
 AddMock(10, IID_Builder, {