Ticket #4431: petra_ally_requests_v0.1.patch

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

@@ -175 +175 @@
         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.civ = function()
+m.GameState.prototype.civ = function(player)
 {
-    return this.playerData.civ;
+    if (player === undefined)
+        return this.playerData.civ;
+
+    return this.sharedScript.playersData[player].civ;
 };
 
 m.GameState.prototype.currentPhase = function()

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

@@ -128 +128 @@
     });
 };
 
-m.chatNewDiplomacy = function(gameState, player, enemy)
+m.chatNewDiplomacy = function(gameState, player, newStance)
 {
-    let message = enemy ?
-        markForTranslation("%(_player_)s and I are now enemies.") :
-        markForTranslation("%(_player_)s and I are now allies.");
+    let message;
+    if (newStance === "enemy")
+        message = markForTranslation("%(_player_)s and I are now enemies.");
+    else if (newStance === "ally")
+        message = markForTranslation("%(_player_)s and I are now allies.");
+    else if (newStance === "neutral")
+        message = markForTranslation("%(_player_)s and I are now neutral.");
 
     Engine.PostCommand(PlayerID, {
         "type": "aichat",
@@ -143 +147 @@
     });
 };
 
+m.chatAnswerRequestAlly = function(gameState, player, response, requiredTribute)
+{
+    let message;
+    if (response === 0)
+        message = markForTranslation("I cannot accept your offer to be allies %(_player_)s.");
+    else if (response === 1)
+        message = markForTranslation("%(_player_)s, our previous alliance did not work out, so I must decline your offer.");
+    else if (response === 2)
+        message = markForTranslation("I will accept your offer to become allies %(_player_)s. We will both benefit from this alliance");
+    else if (response === 3)
+    {
+        let proba = Math.random();
+        if (proba < 0.5)
+            message = markForTranslation("I will ally with you %(_player_)s, but only if you send me a tribute of %(_amount_)s %(_resource_)s.");
+        else
+            message = markForTranslation("%(_player_)s, you must send me a tribute of %(_amount_)s %(_resource_)s for me to consider an alliance");
+    }
+    else if (response === 4)
+        message = markForTranslation("%(_player_)s, my offer still stands. I will ally with you if you send me a tribute of %(_amount_)s %(_resource_)s.");
+
+    let chat = {
+        "type": "aichat",
+        "message": "/msg " + gameState.sharedScript.playersData[player].name + " " + message,
+        "translateMessage": true,
+        "translateParameters": ["_player_"],
+        "parameters": {"_player_": player}
+    };
+    if (response >= 3)
+    {
+        chat.translateParameters.push("_amount_");
+        chat.translateParameters.push("_resource_");
+        chat.parameters._amount_ = requiredTribute.wanted;
+        chat.parameters._resource_ = requiredTribute.type;
+    }
+    Engine.PostCommand(PlayerID, chat);
+};
+
 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
  */
 
 m.DiplomacyManager = function(Config)
@@ -15 +17 @@
     this.nextTributeRequest.set("all", 240);
     this.betrayLapseTime = -1;
     this.waitingToBetray = false;
+    this.allyRequests = new Map();
+    this.allyLapseTime = -1;
 };
 
 /**
@@ -86 +90 @@
     // 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 newAllyData = this.allyRequests.get(evt.from);
+            if (newAllyData === -1 || newAllyData === -2)
+                continue;
+
+            newAllyData.wanted -= evt.amounts[newAllyData.type];
+
+            if (newAllyData.wanted <= 0)
+            {
+                if (this.Config.debug > 1)
+                    API3.warn("Player " + uneval(evt.from) + " has sent all requested tributes");
+                if (gameState.sharedScript.playersData[evt.from].isAlly[PlayerID])
+                {
+                    this.changePlayerDiplomacy(gameState, evt.from, "ally");
+                    // if this new ally turns on us later and requests to ally again, we will decline
+                    this.allyRequests.set(evt.from, -2);
+                }
+                else
+                    this.allyRequests.set(evt.from, -1);
+                this.allyLapseTime = gameState.ai.elapsedTime + 120;
+            }
+        }
+
         if (evt.to !== PlayerID || !gameState.isPlayerAlly(evt.from))
             continue;
         let tributes = 0;
@@ -114 +142 @@
 
     if (events.DiplomacyChanged.length || events.PlayerDefeated.length || events.CeasefireEnded.length)
         this.lastManStandingCheck(gameState);
+
+    for (let evt of events.DiplomacyChanged)
+        if (evt.otherPlayer === PlayerID && !gameState.isPlayerAlly(evt.player) &&
+            gameState.sharedScript.playersData[evt.player].isAlly[PlayerID])
+            this.handleAllyRequest(gameState, evt.player);
 };
 
 /**
@@ -181 +214 @@
     }
 
     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, or if we recently became allies with another player
+ * Overall, be reluctant to become allies with any one player, but accept if the player has more entites than us
+ * Demand a tribute if the requesting player is not as strong as us.
+ */
+m.DiplomacyManager.prototype.handleAllyRequest = function(gameState, player)
+{
+    // 0 for decline, 1 for decline (already tried being allies), 2 for accept, 3 for demand tribute, 4 for waiting for required tributes
+    let response = 0;
+    let requiredTribute;
+    let newAllyData = this.allyRequests.get(player);
+
+    // for any given ally request be likely to permanently decline
+    if (gameState.ai.elapsedTime < this.allyLapseTime || newAllyData === undefined &&
+        gameState.civ() !== gameState.civ(player) && Math.random() > 0.4)
+    {
+        this.allyRequests.set(player, -1);
+        response = 0;
+    }
+    else if (newAllyData !== undefined)
+    {
+        if (newAllyData === -1)
+            response = 0;
+        else if (newAllyData === -2) // we had become allies with this player and the alliance was broken, so decline
+            response = 1;
+        else if (newAllyData !== -1 && newAllyData !== -2 &&
+            newAllyData.wanted >= 0) // already sent ally request, and has not yet sent the required tributes
+        {
+            response = 4;
+            requiredTribute = newAllyData;
+        }
+    }
+    else if (gameState.getEnemies().length < 3 || gameState.ai.HQ.attackManager.currentEnemyPlayer === player)
+        response = 0;
+    else if (gameState.getEntities(player).length < gameState.getOwnEntities().length)
+    {
+        response = 3;
+        requiredTribute = gameState.ai.HQ.pickMostNeededResources(gameState)[0];
+        requiredTribute.wanted = Math.max(1000, gameState.getOwnUnits().length * 10);
+        this.allyRequests.set(player, requiredTribute);
+    }
+    else // a stronger player wants to ally with us
+    {
+        response = 2;
+        this.changePlayerDiplomacy(gameState, player, "ally");
+        this.allyRequests.set(player, -2);
+        this.allyLapseTime = gameState.ai.elapsedTime + 120;
+    }
+    m.chatAnswerRequestAlly(gameState, player, response, requiredTribute);
+};
+
+/**
+ * Change the diplomacy stance with a player, and send a chat message
+ */
+m.DiplomacyManager.prototype.changePlayerDiplomacy = function(gameState, player, newStance)
+{
+    Engine.PostCommand(PlayerID, { "type": "diplomacy", "player": player, "to": newStance });
+    if (this.Config.debug > 1)
+        API3.warn("diplomacy stance with player " + player + " is now " + newStance);
+    if (this.Config.chat)
+        m.chatNewDiplomacy(gameState, player, newStance);
+};
+
 m.DiplomacyManager.prototype.update = function(gameState, events)
 {
     this.checkEvents(gameState, events);
@@ -209 +299 @@
         "nextTributeUpdate": this.nextTributeUpdate,
         "nextTributeRequest": this.nextTributeRequest,
         "betrayLapseTime": this.betrayLapseTime,
-        "waitingToBetray": this.waitingToBetray
+        "waitingToBetray": this.waitingToBetray,
+        "allyRequests": this.allyRequests,
+        "allyLapseTime": this.allyLapseTime
     };
 };