Ticket #4431: petra_ally_requests_v0.3.patch

binaries/data/mods/public/gui/session/messages.js

@@ -185 +185 @@
         g_IsObserver,
 
     "/msg": (senderID, addresseeGUID) =>
-        addresseeGUID == Engine.GetPlayerGUID()
+        addresseeGUID == (Engine.GetPlayerGUID() || "local")
 };
 
 /**

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

@@ -13 +13 @@
     ]
 };
 
+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)
 {
     let message;
@@ -151 +173 @@
     });
 };
 
+m.chatAnswerRequestAlly = function(gameState, player, response, requiredTribute)
+{
+    Engine.PostCommand(PlayerID, {
+        "type": "aichat",
+        "message": "/msg " + gameState.sharedScript.playersData[player].name + " " +
+            API3.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();
 };
 
 /**
@@ -86 +96 @@
     // 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")
+                continue;
+
+            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 +148 @@
 
     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 +240 @@
     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)
+    {
+        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.getEnemies().length < 2 + gameState.getExclusiveMutualAllies().length ||
+        gameState.ai.HQ.attackManager.currentEnemyPlayer === player)
+    {
+        response = "decline";
+        this.allyRequests.set(player, { "status": "declinedRequest" });
+    }
+    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 });
@@ -204 +314 @@
 
     if (this.waitingToBetray && gameState.ai.elapsedTime > this.betrayLapseTime)
         this.lastManStandingCheck(gameState);
+
+    for (let [player, data] of this.allyRequests.entries())
+    {
+        if (data.status !== "declinedRequest" && data.status !== "allianceBroken" &&
+            data.warnTime && gameState.ai.elapsedTime > data.warnTime)
+        {
+            if (data.sentWarning)
+            {
+                data.status = "declinedRequest";
+                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.Serialize = function()
@@ -212 +344 @@
         "nextTributeUpdate": this.nextTributeUpdate,
         "nextTributeRequest": this.nextTributeRequest,
         "betrayLapseTime": this.betrayLapseTime,
-        "waitingToBetray": this.waitingToBetray
+        "waitingToBetray": this.waitingToBetray,
+        "allyRequests": this.allyRequests
     };
 };