Ticket #4431: petra_ally_requests_v0.4.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/common-api/gamestate.js

@@ -384 +384 @@
     return ret;
 };
 
+m.GameState.prototype.getExclusiveMutualAllies = function()
+{   // Player is not included
+    let ret = [];
+    for (let i in this.playerData.isAlly)
+        if (this.playerData.isAlly[i] &&
+            this.sharedScript.playersData[i].isAlly[this.player] && +i !== 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, {
         "type": "aichat",
-        "message": "/allies " + pickRandom(this.launchAttackMessages[type === "HugeAttack" ? type : "other"]),
+        "message": "/allies " + pickRandom(this.launchAttackMessages[type === "HugeAttack" ? "hugeAttack" : "other"]),
         "translateMessage": true,
         "translateParameters": ["_player_"],
         "parameters": { "_player_": player }
@@ -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();
 };
 
+m.DiplomacyManager.prototype.init = function(gameState)
+{
+    for (let ally of gameState.getExclusiveMutualAllies())
+        this.allyRequests.set(ally, { "status": "accepted" });
+};
+
 /**
  * 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 +102 @@
     // 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 +154 @@
 
     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 +246 @@
     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.getExclusiveMutualAllies().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 +307 @@
         m.chatNewDiplomacy(gameState, player, newDiplomaticStance);
 };
 
+m.DiplomacyManager.prototype.allyRequestsTributesCheck = 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 +338 @@
 
     if (this.waitingToBetray && gameState.ai.elapsedTime > this.betrayLapseTime)
         this.lastManStandingCheck(gameState);
+
+    this.allyRequestsTributesCheck(gameState);
 };
 
 m.DiplomacyManager.prototype.Serialize = function()
@@ -212 +348 @@
         "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);