Ticket #4431: petra_ally_requests_v0.5.patch

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

@@ -384 +384 @@
     return ret;
 };
 
+m.GameState.prototype.getMutualAllies = function()
+{
+    let ret = [];
+    for (let i in this.playerData.isMutualAlly)
+        if (this.playerData.isMutualAlly[i] &&
+            this.sharedScript.playersData[i].isMutualAlly[this.player])
+            ret.push(+i);
+    return ret;
+};
+
 m.GameState.prototype.isEntityAlly = function(ent)
 {
     if (!ent)

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

@@ -63 +63 @@
     ]
 };
 
+m.chatAnswerAllyRequestMessages = {
+    "decline": [
+        markForTranslation("I cannot accept your offer to be allies %(_player_)s.")
+    ],
+    "declineSuggestNeutral": [
+        markForTranslation("I will not ally with you %(_player_)s, but I will consider a neutrality pact.")
+    ],
+    "declineRepeatedOffer": [
+        markForTranslation("%(_player_)s, our previous alliance did not work out, so I must decline your offer.")
+    ],
+    "accept": [
+        markForTranslation("I will accept your offer to become allies %(_player_)s. We will both benefit from this alliance.")
+    ],
+    "acceptWithTribute": [
+        markForTranslation("I will ally with you %(_player_)s, but only if you send me a tribute of %(_amount_)s %(_resource_)s."),
+        markForTranslation("%(_player_)s, you must send me a tribute of %(_amount_)s %(_resource_)s for me to accept an alliance.")
+    ],
+    "waitingForTribute": [
+        markForTranslation("%(_player_)s, my offer still stands. I will ally with you if you send me a tribute of %(_amount_)s %(_resource_)s.")
+    ]
+};
+
 m.chatLaunchAttack = function(gameState, player, type)
 {
     Engine.PostCommand(PlayerID, {
@@ -140 +162 @@
     });
 };
 
+m.chatAnswerRequestAlly = function(gameState, player, response, requiredTribute)
+{
+    Engine.PostCommand(PlayerID, {
+        "type": "aichat",
+        "message": "/msg " + gameState.sharedScript.playersData[player].name + " " +
+            pickRandom(this.chatAnswerAllyRequestMessages[response]),
+        "translateMessage": true,
+        "translateParameters": requiredTribute ? ["_amount_", "_resource_", "_player_"] : ["_player_"],
+        "parameters": requiredTribute ?
+            { "_amount_": requiredTribute.wanted, "_resource_": requiredTribute.type, "_player_": player } :
+            { "_player_": player }
+    });
+};
+
 return m;
 }(PETRA);

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

@@ -5 +5 @@
  * Manage the diplomacy:
  *     update our cooperative trait
  *     sent tribute to allies
+ *     decide which player to turn against in "Last Man Standing" mode
+ *     respond to diplomacy requests
  */
 
+/**
+ * If a player sends us an ally request, an Object in this.allyRequests will be created
+ * that includes the request status, and the amount and type of the resource tribute (if any)
+ * that they must send in order for us to accept their request.
+ * In addition, a message will be sent if the player has not sent us a tribute within a minute.
+ * If two minutes pass without a tribute, we will decline their request.
+ */
 m.DiplomacyManager = function(Config)
 {
     this.Config = Config;
@@ -15 +24 @@
     this.nextTributeRequest.set("all", 240);
     this.betrayLapseTime = -1;
     this.waitingToBetray = false;
+    this.allyRequests = new Map();
 };
 
 /**
+ * If there are any players that are allied with us but we are not allied with them,
+ * treat this situation like an ally request.
+ */
+m.DiplomacyManager.prototype.init = function(gameState)
+{
+    for (let i = 1; i < gameState.sharedScript.playersData.length; ++i)
+    {
+        if (i === PlayerID)
+            continue;
+
+        if (gameState.isPlayerMutualAlly(i))
+            this.allyRequests.set(i, { "status": "accepted" });
+        else if (gameState.sharedScript.playersData[i].isAlly[PlayerID] && !gameState.isPlayerAlly(i))
+            this.handleAllyRequest(gameState, i);
+    }
+};
+
+/**
  * 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
  */
@@ -86 +114 @@
     // or if our allies attack enemies inside our territory
     for (let evt of events.TributeExchanged)
     {
+        if (evt.to === PlayerID && !gameState.isPlayerAlly(evt.from) && this.allyRequests.has(evt.from))
+        {
+            let request = this.allyRequests.get(evt.from);
+            if (request.status === "waitingForTribute")
+            {
+                request.wanted -= evt.amounts[request.type];
+
+                if (request.wanted <= 0)
+                {
+                    if (this.Config.debug > 1)
+                        API3.warn("Player " + uneval(evt.from) + " has sent the required tribute amount");
+
+                    this.changePlayerDiplomacy(gameState, evt.from, "ally");
+                    request.status = "accepted";
+                }
+                else
+                {
+                    // Reset the warning sent to the player that reminds them to speed up the tributes
+                    request.warnTime = gameState.ai.elapsedTime + 60;
+                    request.sentWarning = false;
+                }
+            }
+        }
+
         if (evt.to !== PlayerID || !gameState.isPlayerAlly(evt.from))
             continue;
         let tributes = 0;
@@ -114 +166 @@
 
     if (events.DiplomacyChanged.length || events.PlayerDefeated.length || events.CeasefireEnded.length)
         this.lastManStandingCheck(gameState);
+
+    for (let evt of events.DiplomacyChanged)
+    {
+        if (evt.otherPlayer !== PlayerID)
+            continue;
+
+        if (this.allyRequests.has(evt.player) && !gameState.sharedScript.playersData[evt.player].isAlly[PlayerID])
+        {
+            // a player that had requested to be allies changed their stance with us
+            let request = this.allyRequests.get(evt.player);
+            if (request.status === "accepted")
+                request.status = "allianceBroken";
+            else if (request.status !== "allianceBroken")
+                request.status = "declinedRequest";
+        }
+        else if (gameState.sharedScript.playersData[evt.player].isAlly[PlayerID] && gameState.isPlayerEnemy(evt.player))
+            m.chatAnswerRequestAlly(gameState, evt.player, "declineSuggestNeutral");
+        else if (gameState.sharedScript.playersData[evt.player].isAlly[PlayerID] && gameState.isPlayerNeutral(evt.player))
+            this.handleAllyRequest(gameState, evt.player);
+    }
 };
 
 /**
@@ -186 +258 @@
     this.waitingToBetray = false;
 };
 
+/**
+ * Do not become allies with a player if the game would be over.
+ * Overall, be reluctant to become allies with any one player.
+ */
+m.DiplomacyManager.prototype.handleAllyRequest = function(gameState, player)
+{
+    let response;
+    let requiredTribute;
+    let request = this.allyRequests.get(player);
+
+    // For any given ally request be likely to permanently decline
+    if (!request && gameState.getPlayerCiv() !== gameState.getPlayerCiv(player) && Math.random() > 0.4 ||
+        gameState.getEnemies().length < gameState.getMutualAllies().length ||
+        gameState.ai.HQ.attackManager.currentEnemyPlayer === player)
+    {
+        this.allyRequests.set(player, { "status": "declinedRequest" });
+        response = "decline";
+    }
+    else if (request)
+    {
+        if (request.status === "declinedRequest")
+            response = "decline";
+        else if (request.status === "allianceBroken") // Previous alliance was broken, so decline
+            response = "declineRepeatedOffer";
+        else if (request.status === "waitingForTribute")
+        {
+            response = "waitingForTribute";
+            requiredTribute = request;
+        }
+    }
+    else if (gameState.getEntities(player).length < gameState.getOwnEntities().length && Math.random() > 0.6)
+    {
+        response = "accept";
+        this.changePlayerDiplomacy(gameState, player, "ally");
+        this.allyRequests.set(player, { "status": "accepted" });
+    }
+    else
+    {
+        response = "acceptWithTribute";
+        requiredTribute = gameState.ai.HQ.pickMostNeededResources(gameState)[0];
+        requiredTribute.wanted = Math.max(1000, gameState.getOwnUnits().length * 10);
+        this.allyRequests.set(player, {
+            "status": "waitingForTribute",
+            "wanted": requiredTribute.wanted,
+            "type": requiredTribute.type,
+            "warnTime": gameState.ai.elapsedTime + 60,
+            "sentWarning": false
+        });
+    }
+    m.chatAnswerRequestAlly(gameState, player, response, requiredTribute);
+};
+
 m.DiplomacyManager.prototype.changePlayerDiplomacy = function(gameState, player, newDiplomaticStance)
 {
     Engine.PostCommand(PlayerID, { "type": "diplomacy", "player": player, "to": newDiplomaticStance });
@@ -195 +319 @@
         m.chatNewDiplomacy(gameState, player, newDiplomaticStance);
 };
 
+m.DiplomacyManager.prototype.checkRequestedTributes = function(gameState)
+{
+    for (let [player, data] of this.allyRequests.entries())
+        if (data.status === "waitingForTribute" && gameState.ai.elapsedTime > data.warnTime)
+        {
+            if (data.sentWarning)
+            {
+                this.allyRequests.delete(player);
+                m.chatAnswerRequestAlly(gameState, player, "decline");
+            }
+            else
+            {
+                data.sentWarning = true;
+                data.warnTime = gameState.ai.elapsedTime + 60;
+                m.chatAnswerRequestAlly(gameState, player, "waitingForTribute", {
+                    "wanted": data.wanted,
+                    "type": data.type
+                });
+            }
+        }
+};
+
 m.DiplomacyManager.prototype.update = function(gameState, events)
 {
     this.checkEvents(gameState, events);
@@ -204 +350 @@
 
     if (this.waitingToBetray && gameState.ai.elapsedTime > this.betrayLapseTime)
         this.lastManStandingCheck(gameState);
+
+    this.checkRequestedTributes(gameState);
 };
 
 m.DiplomacyManager.prototype.Serialize = function()
@@ -212 +360 @@
         "nextTributeUpdate": this.nextTributeUpdate,
         "nextTributeRequest": this.nextTributeRequest,
         "betrayLapseTime": this.betrayLapseTime,
-        "waitingToBetray": this.waitingToBetray
+        "waitingToBetray": this.waitingToBetray,
+        "allyRequests": this.allyRequests
     };
 };
 

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

@@ -13 +13 @@
     this.attackManager.init(gameState);
     this.navalManager.init(gameState);
     this.tradeManager.init(gameState);
+    this.diplomacyManager.init(gameState);
 
     // Make a list of buildable structures from the config file
     this.structureAnalysis(gameState);