Ticket #4142: 4142_petra_regicide_support_v1.6.patch

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

@@ -677 +677 @@
     if (ent.getMetadata(PlayerID, "plan") !== undefined && ent.getMetadata(PlayerID, "plan") !== -1 ||
         ent.getMetadata(PlayerID, "transport") !== undefined || ent.getMetadata(PlayerID, "transporter") !== undefined)
         return false;
-    // TODO if more than one hero in regicide, prevent only the "right one" from being affected
-    if (gameState.getGameType() === "regicide" && ent.hasClass("Hero") && (this.overseas || ent.healthLevel() < 0.8))
+    if (gameState.ai.HQ.gameTypeManager.criticalEnts.has(ent.id()) && (this.overseas || ent.healthLevel() < 0.8))
         return false;
     return true;
 };

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

@@ -388 +388 @@
             return;
         if (ent.getMetadata(PlayerID, "transport") !== undefined || ent.getMetadata(PlayerID, "transporter") !== undefined)
             return;
-        if (gameState.getGameType() === "regicide" && ent.hasClass("Hero"))
+        if (gameState.ai.HQ.gameTypeManager.criticalEnts.has(ent.id()))
             return;
         if (ent.getMetadata(PlayerID, "plan") !== undefined && ent.getMetadata(PlayerID, "plan") !== -1)
         {

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

@@ -4 +4 @@
 /**
  * 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
+ * TODO: Assign guards to the wonder in a wonder game
  */
 
 m.GameTypeManager = function(Config)
 {
     this.Config = Config;
-    this.heroGarrisonEmergency = false;
-    this.healersAssignedToHero = 0; // Accounts for healers being trained as well
-    this.heroGuards = []; // Holds id of ents currently guarding the hero
+    this.criticalEnts = new Map();
+    this.guardEnts = new Map(); // Holds guard ids and if the ent is currently guarding
+    this.healersPerCriticalEnt = 2 + Math.round(this.Config.personality.defensive * 2);
 };
 
 /**
+ * Cache the ids of any inital gameType-critical entities
+ * In regicide, these are the inital heroes that the player starts with.
+ */
+m.GameTypeManager.prototype.init = function(gameState)
+{
+    if (gameState.getGameType() !== "regicide")
+        return;
+
+    let heroEnts = gameState.getOwnEntitiesByClass("Hero", true).toEntityArray();
+    for (let hero of heroEnts)
+        this.criticalEnts.set(hero.id(), {
+            "garrisonEmergency": false,
+            "stance": hero.hasClass("Soldier") ? "aggressive" : "passive",
+            "healersAssigned": 0,
+            "guards": [] // ents who are currently guarding this hero
+        });
+};
+
+/**
  * In regicide mode, if the hero has less than 70% health, try to garrison it in a healing structure
  * If it is less than 40%, try to garrison in the closest possible structure
  * If the hero cannot garrison, retreat it to the closest base
@@ -50 +69 @@
     {
         let target = gameState.getEntityById(evt.target);
         if (!target || !gameState.isEntityOwn(target) || !target.position() ||
-            !target.hasClass("Hero") || target.healthLevel() > 0.7)
+            !this.criticalEnts.has(evt.target) || target.healthLevel() > 0.7)
             continue;
 
         let plan = target.getMetadata(PlayerID, "plan");
+        let hero = this.criticalEnts.get(evt.target);
         if (plan !== -2 && plan !== -3)
         {
             target.stopMoving();
@@ -72 +92 @@
                     army.removeOwn(gameState, target.id());
             }
 
-            this.heroGarrisonEmergency = target.healthLevel() < 0.4;
-            this.pickHeroRetreatLocation(gameState, target, this.heroGarrisonEmergency);
+            hero.garrisonEmergency = target.healthLevel() < 0.4;
+            this.pickHeroRetreatLocation(gameState, target, hero.garrisonEmergency);
         }
-        else if (target.healthLevel() < 0.4 && !this.heroGarrisonEmergency)
+        else if (target.healthLevel() < 0.4 && !hero.garrisonEmergency)
         {
             // the hero is severely wounded, try to retreat/garrison quicker
             gameState.ai.HQ.garrisonManager.cancelGarrison(target);
             this.pickHeroRetreatLocation(gameState, target, true);
-            this.heroGarrisonEmergency = true;
+            hero.garrisonEmergency = true;
         }
     }
 
-    // check if new healers/guards need to be assigned to the hero
+    // check if new healers/guards need to be assigned to an ent
     for (let evt of events.Destroy)
     {
-        if (!evt.entityObj || evt.entityObj.owner() !== PlayerID ||
-            this.heroGuards.indexOf(evt.entityObj.id()) === -1)
+        if (!evt.entityObj || evt.entityObj.owner() !== PlayerID)
             continue;
 
-        this.heroGuards.splice(this.heroGuards.indexOf(evt.entityObj.id()), 1);
-        if (evt.entityObj.hasClass("Healer"))
-            --this.healersAssignedToHero;
+        for (let data of this.criticalEnts.values())
+            if (data.guards.indexOf(evt.entityObj.id()) !== -1)
+            {
+                let index = data.guards.indexOf(evt.entityObj.id());
+                data.guards.splice(index, 1);
+                this.guardEnts.delete(evt.entityObj.id());
+
+                if (evt.entityObj.hasClass("Healer"))
+                    --data.healersAssigned;
+            }
     }
 
     for (let evt of events.TrainingFinished)
@@ -109 +135 @@
     for (let evt of events.Garrison)
     {
         let ent = gameState.getEntityById(evt.entity);
-        if (!ent || !ent.isOwn(PlayerID) || !ent.hasClass("Hero"))
+        if (!ent || !ent.isOwn(PlayerID) || !this.criticalEnts.has(evt.entity))
             continue;
 
-        if (this.heroGarrisonEmergency)
-            this.heroGarrisonEmergency = false;
+        let hero = this.criticalEnts.get(evt.entity);
+        if (hero.garrisonEmergency)
+            hero.garrisonEmergency = 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)
+        for (let guardId of hero.guards)
+        {
             gameState.getEntityById(guardId).removeGuard();
+            this.guardEnts.delete(guardId);
+        }
 
-        this.heroGuards = [];
+        hero.guards = [];
     }
 
     for (let evt of events.UnGarrison)
@@ -132 +162 @@
             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)
+        if (ent.getMetadata(PlayerID, "role") === "regicideHealer" && this.guardEnts.has(evt.entity))
         {
             this.assignGuardToRegicideHero(gameState, ent);
             continue;
         }
 
-        if (!ent.hasClass("Hero"))
+        if (!this.criticalEnts.has(evt.entity))
             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)
-                this.assignGuardToRegicideHero(gameState, healer);
+        let criticalEnt = this.criticalEnts.get(ent.id());
+        for (let [id, isGuarding] of this.guardEnts)
+        {
+            if (criticalEnt.guards.length >= this.healersPerCriticalEnt)
+                break;
+
+            if (!isGuarding)
+                this.assignGuardToRegicideHero(gameState, gameState.getEntityById(id));
+        }
     }
 };
 
@@ -178 +212 @@
         heroEnt.move(basePos.anchor.position()[0], basePos.anchor.position()[1]);
 };
 
-m.GameTypeManager.prototype.trainRegicideHealer = function(gameState, queues)
+/**
+ * The number of healers trained per regicide hero (dependant on the defensive trait)
+ * may not be the number of healers actually guarding a hero.
+ */
+m.GameTypeManager.prototype.trainRegicideHealer = function(gameState, queues, id)
 {
     if (gameState.ai.HQ.saveResources || !gameState.getOwnEntitiesByClass("Temple", true).hasEntities())
         return;
@@ -186 +224 @@
     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;
+    ++this.criticalEnts.get(id).healersAssigned;
 };
 
 /**
@@ -196 +234 @@
  */
 m.GameTypeManager.prototype.assignGuardToRegicideHero = function(gameState, ent)
 {
-    let heroEnt = gameState.getOwnEntitiesByClass("Hero", true).toEntityArray()[0];
+    // Assign to the ent with the fewest guards
+    let min = Math.min();
+    let entId;
+    for (let [id, data] of this.criticalEnts)
+    {
+        if (data.guards.length < min)
+        {
+            entId = id;
+            min = data.guards.length;
+        }
+    }
+
+    let heroEnt = gameState.getEntityById(entId);
     if (!heroEnt || !heroEnt.position() ||
         !ent.position() || ent.getMetadata(PlayerID, "transport") !== undefined || !ent.canGuard())
         return;
@@ -206 +256 @@
     if (entAccess === heroAccess)
     {
         ent.guard(heroEnt);
-        this.heroGuards.push(ent.id());
+        this.criticalEnts.get(entId).guards.push(ent.id());
     }
     else
         gameState.ai.HQ.navalManager.requireTransport(gameState, ent, entAccess, heroAccess, heroEnt.position());
+    this.guardEnts.set(ent.id(), entAccess === heroAccess);
 };
 
 m.GameTypeManager.prototype.update = function(gameState, events, queues)
 {
+    // Wait a turn for trigger scripts to spawn any important ents (i.e. in regicide)
+    if (gameState.ai.playedTurn === 1)
+        this.init(gameState);
+
     this.checkEvents(gameState, events);
 
     if (gameState.getGameType() === "wonder")
@@ -224 +279 @@
 
     if (gameState.ai.playedTurn % 50 === 0)
     {
-        let heroEnt = gameState.getOwnEntitiesByClass("Hero", true).toEntityArray()[0];
-        if (heroEnt && heroEnt.healthLevel() > 0.7)
-            heroEnt.setStance("aggressive");
+        for (let [id, data] of this.criticalEnts)
+        {
+            let ent = gameState.getEntityById(id);
+            if (ent && ent.healthLevel() > 0.7 && ent.hasClass("Soldier") &&
+                data.stance !== "aggressive")
+                ent.setStance("aggressive");
+        }
     }
 
-    if (this.healersAssignedToHero < 2 + Math.round(this.Config.personality.defensive * 2))
-        this.trainRegicideHealer(gameState, queues);
+    for (let [id, data] of this.criticalEnts)
+        if (data.healersAssigned < this.healersPerCriticalEnt)
+            this.trainRegicideHealer(gameState, queues, id);
 };
 
 m.GameTypeManager.prototype.Serialize = function()
 {
     return {
-        "heroGarrisonEmergency": this.heroGarrisonEmergency,
-        "healersAssignedToHero": this.healersAssignedToHero,
-        "heroGuards": this.heroGuards
+        "criticalEnts": this.criticalEnts,
+        "guardEnts": this.guardEnts,
+        "healersPerCriticalEnt": this.healersPerCriticalEnt
     };
 };