Ticket #4142: 4142_petra_regicide_support_v1.5.patch

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

@@ -745 +745 @@
     garrisoned: function() { return this._entity.garrisoned; },
     canGarrisonInside: function() { return this._entity.garrisoned.length < this.garrisonMax(); },
 
+    "canGuard": function() { return this.get("UnitAI/CanGuard") === "true"; },
+
     move: function(x, z, queued = false) {
         Engine.PostCommand(PlayerID,{"type": "walk", "entities": [this.id()], "x": x, "z": z, "queued": queued });
         return this;
@@ -929 +931 @@
             if (item.progress < percentToStopAt)
                 Engine.PostCommand(PlayerID,{ "type": "stop-production", "entity": this.id(), "id": item.id });
         return this;
+    },
+
+    "guard": function(target, queued = false) {
+        Engine.PostCommand(PlayerID, { "type": "guard", "entities": [this.id()], "target": target.id(), "queued": queued });
+        return this;
+    },
+
+    "removeGuard": function() {
+        Engine.PostCommand(PlayerID, { "type": "remove-guard", "entities": [this.id()] });
+        return this;
     }
 });
 

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

@@ -3 +3 @@
 
 /**
  * Handle events that are important to specific gameTypes
+ * In regicide, train and manage healer guards for the hero
  * TODO: Handle when there is more than one hero in regicide
  * TODO: Assign military units to guard the hero in regicide
  */
 
-m.GameTypeManager = function()
+m.GameTypeManager = function(Config)
 {
+    this.Config = Config;
     this.heroGarrisonEmergency = false;
+    this.healersAssignedToHero = 0; // Accounts for healers being trained as well
+    this.heroGuards = []; // Holds ents currently guarding the hero
 };
 
 /**
@@ -80 +84 @@
         }
     }
 
-    if (!this.heroGarrisonEmergency)
-        return;
+    // check if new healers/guards need to be assigned to the hero
+    for (let evt of events.Destroy)
+    {
+        if (!evt.entityObj || evt.entityObj.owner() !== PlayerID ||
+            this.heroGuards.indexOf(evt.entityObj.id()) === -1)
+            continue;
 
+        this.heroGuards.splice(this.heroGuards.indexOf(evt.entityObj.id()), 1);
+        if (evt.entityObj.hasClass("Healer"))
+            --this.healersAssignedToHero;
+    }
+
+    for (let evt of events.TrainingFinished)
+        for (let entId of evt.entities)
+        {
+            let ent = gameState.getEntityById(entId);
+            if (!ent || !ent.isOwn(PlayerID) || ent.getMetadata(PlayerID, "role") !== "regicideHealer")
+                continue;
+
+            this.assignGuardToRegicideHero(gameState, ent);
+        }
+
     for (let evt of events.Garrison)
-        if (gameState.getEntityById(evt.entity).hasClass("Hero"))
+    {
+        let ent = gameState.getEntityById(evt.entity);
+        if (!ent || !ent.isOwn(PlayerID) || !ent.hasClass("Hero"))
+            continue;
+
+        if (this.heroGarrisonEmergency)
             this.heroGarrisonEmergency = false;
+
+        if (!gameState.getEntityById(evt.holder).hasClass("Ship"))
+            continue;
+
+        // If the hero is garrisoned on a ship, remove its guards
+        for (let guardId of this.heroGuards)
+            gameState.getEntityById(guardId).removeGuard();
+
+        this.heroGuards = [];
+    }
+
+    for (let evt of events.UnGarrison)
+    {
+        let ent = gameState.getEntityById(evt.entity);
+        if (!ent || !ent.isOwn(PlayerID))
+            continue;
+
+        // If this ent travelled to a hero's accessValue, try again to assign as a guard
+        if (ent.getMetadata(PlayerID, "role") === "regicideHealer" &&
+            this.heroGuards.indexOf(evt.entity) === -1)
+        {
+            this.assignGuardToRegicideHero(gameState, ent);
+            continue;
+        }
+
+        if (!ent.hasClass("Hero"))
+            continue;
+
+        // If this is the hero, try to assign ents that should be guarding it, but couldn't previously
+        let regicideHealers = gameState.getOwnUnits().filter(API3.Filters.byMetadata(PlayerID, "role", "regicideHealer"));
+        for (let healer of regicideHealers.values())
+        {
+            if (this.heroGuards.indexOf(healer.id()) !== -1)
+                continue;
+
+            this.assignGuardToRegicideHero(gameState, healer);
+        }
+    }
 };
 
 m.GameTypeManager.prototype.buildWonder = function(gameState, queues)
@@ -116 +182 @@
         heroEnt.move(basePos.anchor.position()[0], basePos.anchor.position()[1]);
 };
 
+m.GameTypeManager.prototype.trainRegicideHealer = function(gameState, queues)
+{
+    if (gameState.ai.HQ.saveResources || !gameState.getOwnEntitiesByClass("Temple", true).hasEntities())
+        return;
+
+    let template = gameState.applyCiv("units/{civ}_support_healer_b");
+
+    queues.villager.addPlan(new m.TrainingPlan(gameState, template, { "role": "regicideHealer", "base": 0 }, 1, 1));
+    ++this.healersAssignedToHero;
+};
+
+/**
+ * Only send the guard command if the guard's accessIndex is the same as the hero
+ * and the hero has a position (i.e. not garrisoned)
+ * request a transport if the accessIndex value is different
+ */
+m.GameTypeManager.prototype.assignGuardToRegicideHero = function(gameState, ent)
+{
+    let heroEnt = gameState.getOwnEntitiesByClass("Hero", true).toEntityArray()[0];
+    if (!heroEnt || !heroEnt.position() || !ent.position() || !ent.canGuard())
+        return;
+
+    let entAccess = gameState.ai.accessibility.getAccessValue(ent.position());
+    let heroAccess = gameState.ai.accessibility.getAccessValue(heroEnt.position());
+    if (entAccess && entAccess === heroAccess)
+    {
+        ent.guard(heroEnt);
+        this.heroGuards.push(ent.id());
+        return;
+    }
+    gameState.ai.HQ.navalManager.requireTransport(gameState, ent, entAccess, heroAccess, heroEnt.position());
+};
+
 m.GameTypeManager.prototype.update = function(gameState, events, queues)
 {
     this.checkEvents(gameState, events);
@@ -122 +221 @@
 
     if (gameState.getGameType() === "wonder")
         this.buildWonder(gameState, queues);
-    else if (gameState.getGameType() === "regicide" && gameState.ai.playedTurn % 50 === 0)
+
+    if (gameState.getGameType() !== "regicide")
+        return;
+
+    if (gameState.ai.playedTurn % 50 === 0)
     {
         let heroEnt = gameState.getOwnEntitiesByClass("Hero", true).toEntityArray()[0];
         if (heroEnt && heroEnt.healthLevel() > 0.7)
             heroEnt.setStance("aggressive");
     }
+
+    if (this.healersAssignedToHero < 2 + Math.round(this.Config.personality.defensive * 2))
+        this.trainRegicideHealer(gameState, queues);
 };
 
 m.GameTypeManager.prototype.Serialize = function()
 {
-    return { "heroGarrisonEmergency": this.heroGarrisonEmergency };
+    return {
+        "heroGarrisonEmergency": this.heroGarrisonEmergency,
+        "healersAssignedToHero": this.healersAssignedToHero,
+        "heroGuards": this.heroGuards
+    };
 };
 
 m.GameTypeManager.prototype.Deserialize = function(data)

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

@@ -215 +215 @@
 {
     ent.stopMoving();
     this.leaveGarrison(ent);
-    let holderId = ent.getMetadata(PlayerId, "garrisonHolder");
+    let holderId = ent.getMetadata(PlayerID, "garrisonHolder");
     if (!holderId || !this.holders.has(holderId))
         return;
     let list = this.holders.get(holderId);

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

@@ -51 +51 @@
     this.researchManager = new m.ResearchManager(this.Config);
     this.diplomacyManager = new m.DiplomacyManager(this.Config);
     this.garrisonManager = new m.GarrisonManager();
-    this.gameTypeManager = new m.GameTypeManager();
+    this.gameTypeManager = new m.GameTypeManager(this.Config);
 };
 
 /** More initialisation for stuff that needs the gameState */
@@ -1268 +1268 @@
         gameState.getOwnEntitiesByClass("Temple", true).hasEntities() ||
         !gameState.getOwnEntitiesByClass("BarterMarket", true).hasEntities())
         return;
-    if (gameState.currentPhase() < 3)
+    // Try to build a temple earlier if in regicide to recruit healer guards
+    if (gameState.currentPhase() < 3 && gameState.getGameType() !== "regicide")
     {
         if (gameState.currentPhase() < 2 || this.econState !== "cityPhasing")
             return;
@@ -2279 +2280 @@
     this.garrisonManager = new m.GarrisonManager();
     this.garrisonManager.Deserialize(data.garrisonManager);
 
-    this.gameTypeManager = new m.GameTypeManager();
+    this.gameTypeManager = new m.GameTypeManager(this.Config);
     this.gameTypeManager.Deserialize(data.gameTypeManager);
 };