Ticket #4431: petra_ally_requests_v0.2.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

@@ -146 +146 @@
     return str.replace(/\{civ\}/g, this.playerData.civ);
 };
 
+m.GameState.prototype.getPlayerCiv = function(player)
+{
+    if (player === undefined)
+        return this.playerData.civ;
+
+    return this.sharedScript.playersData[player].civ;
+}
+
 m.GameState.prototype.civ = function()
 {
-    return this.playerData.civ;
+    return this.getPlayerCiv();
 };
 
 m.GameState.prototype.currentPhase = function()

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

@@ -1 +1 @@
 var PETRA = function(m)
 {
 
+m.chatNewDiplomacyMessages = {
+    "enemy": [
+        markForTranslation("%(_player_)s and I are now enemies.")
+    ],
+    "ally": [
+        markForTranslation("%(_player_)s and I are now allies.")
+    ],
+    "neutral": [
+        markForTranslation("%(_player_)s and I are now neutral.")
+    ]
+};
+
+m.chatAnswerAllyRequestMessages = {
+    "decline": [
+        markForTranslation("I cannot accept your offer to be allies %(_player_)s.")
+    ],
+    "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 consider 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;
@@ -128 +159 @@
     });
 };
 
-m.chatNewDiplomacy = function(gameState, player, enemy)
+m.chatNewDiplomacy = function(gameState, player, newDiplomaticStance)
 {
-    let message = enemy ?
-        markForTranslation("%(_player_)s and I are now enemies.") :
-        markForTranslation("%(_player_)s and I are now allies.");
-
     Engine.PostCommand(PlayerID, {
         "type": "aichat",
-        "message": message,
+        "message": API3.PickRandom(this.chatNewDiplomacyMessages[newDiplomaticStance]),
         "translateMessage": true,
         "translateParameters": ["_player_"],
-        "parameters": {"_player_": player}
+        "parameters": { "_player_": player }
     });
 };
 
+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
+ * containing 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.
+ * f.e. { "status": 1, "type": "metal", "wanted": 1000 }.
+ * Status is -1 for decline, -2 for decline repeated request, 1 for waiting for tributes.
+ */
 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 === -1 || request.status === -2)
+                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");
+                // if this new ally turns on us later and requests to ally again, we will decline
+                request.status = -2;
+            }
+        }
+
         if (evt.to !== PlayerID || !gameState.isPlayerAlly(evt.from))
             continue;
         let tributes = 0;
@@ -114 +143 @@
 
     if (events.DiplomacyChanged.length || events.PlayerDefeated.length || events.CeasefireEnded.length)
         this.lastManStandingCheck(gameState);
+
+    if (gameState.getAlliedVictory())
+        return;
+
+    for (let evt of events.DiplomacyChanged)
+        if (evt.otherPlayer === PlayerID && !gameState.isPlayerAlly(evt.player))
+            if (gameState.sharedScript.playersData[evt.player].isAlly[PlayerID])
+                this.handleAllyRequest(gameState, evt.player);
+            else if (this.allyRequests.has(evt.player)) // a player that had requested to be allies changed their stance with us
+                this.allyRequests.get(evt.player).status = -2;
 };
 
 /**
@@ -181 +220 @@
     }
 
     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.changePlayerDiplomacy(gameState, playerToTurnAgainst, "enemy");
     this.betrayLapseTime = -1;
     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; be more likely to 
+ * demand a tribute if the requesting player is not as strong as us.
+ */
+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": -1 });
+        response = "decline";
+    }
+    else if (request)
+    {
+        if (request.status === -1)
+            response = "decline";
+        else if (request.status === -2) // we had become allies with this player and the alliance was broken, so decline
+            response = "declineRepeatedOffer";
+        else if (request.wanted > 0) // already sent ally request, and has not yet sent the required tributes
+        {
+            response = "waitingForTribute";
+            requiredTribute = request;
+        }
+    }
+    else if (gameState.getEnemies().length < 3 || gameState.ai.HQ.attackManager.currentEnemyPlayer === player)
+    {
+        response = "decline";
+        this.allyRequests.set(player, { "status": -1 });
+    }
+    else if (gameState.getEntities(player).length < gameState.getOwnEntities().length && Math.random() > 0.6)
+    {
+        // if this player has less entities than us, be less likely to demand a tribute
+        response = "accept";
+        this.changePlayerDiplomacy(gameState, player, "ally");
+        this.allyRequests.set(player, { "status": -2 });
+    }
+    else
+    {
+        response = "acceptWithTribute";
+        requiredTribute = gameState.ai.HQ.pickMostNeededResources(gameState)[0];
+        requiredTribute.wanted = Math.max(1000, gameState.getOwnUnits().length * 10);
+        this.allyRequests.set(player, {
+            "status": 1,
+            "wanted": requiredTribute.wanted,
+            "type": requiredTribute.type,
+        });
+    }
+    m.chatAnswerRequestAlly(gameState, player, response, requiredTribute);
+};
+
+/**
+ * Change our diplomacy stance with a player, and send a chat message
+ */
+m.DiplomacyManager.prototype.changePlayerDiplomacy = function(gameState, player, newDiplomaticStance)
+{
+    Engine.PostCommand(PlayerID, { "type": "diplomacy", "player": player, "to": newDiplomaticStance });
+    if (this.Config.debug > 1)
+        API3.warn("diplomacy stance with player " + player + " is now " + newDiplomaticStance);
+    if (this.Config.chat)
+        m.chatNewDiplomacy(gameState, player, newDiplomaticStance);
+};
+
 m.DiplomacyManager.prototype.update = function(gameState, events)
 {
     this.checkEvents(gameState, events);
@@ -209 +309 @@
         "nextTributeUpdate": this.nextTributeUpdate,
         "nextTributeRequest": this.nextTributeRequest,
         "betrayLapseTime": this.betrayLapseTime,
-        "waitingToBetray": this.waitingToBetray
+        "waitingToBetray": this.waitingToBetray,
+        "allyRequests": this.allyRequests
     };
 };