Ticket #4142: 4142_petra_regicide_support_v1.7.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();
+    // Holds ids of all ents who are (or can be) guarding and if the ent is currently guarding
+    this.guardEnts = new Map();
+    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)
+    {
+        hero.setStance(hero.hasClass("Soldier") ? "aggressive" : "passive");
+        this.criticalEnts.set(hero.id(), {
+            "garrisonEmergency": false,
+            "stance": hero.hasClass("Soldier") ? "aggressive" : "passive",
+            "healersAssigned": 0,
+            "guards": new Set() // ids of 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
@@ -48 +71 @@
 
     for (let evt of events.Attacked)
     {
+        if (!evt.target || !this.criticalEnts.has(evt.target))
+            continue;
+
         let target = gameState.getEntityById(evt.target);
-        if (!target || !gameState.isEntityOwn(target) || !target.position() ||
-            !target.hasClass("Hero") || target.healthLevel() > 0.7)
+        if (!target.position() || 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 +98 @@
                     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;
+        let entId = evt.entityObj.id();
+        if (this.criticalEnts.has(entId))
+        {
+            for (let guardId of this.criticalEnts.get(entId).guards)
+                this.guardEnts.set(guardId, false);
+
+            this.criticalEnts.delete(entId);
+            continue;
+        }
+
+        if (!this.guardEnts.has(entId))
+            continue;
+
+        for (let data of this.criticalEnts.values())
+            if (data.guards.has(entId))
+            {
+                data.guards.delete(entId);
+                if (evt.entityObj.hasClass("Healer"))
+                    --data.healersAssigned;
+            }
+
+        this.guardEnts.delete(entId);
     }
 
     for (let evt of events.TrainingFinished)
@@ -103 +147 @@
             if (!ent || !ent.isOwn(PlayerID) || ent.getMetadata(PlayerID, "role") !== "regicideHealer")
                 continue;
 
-            this.assignGuardToRegicideHero(gameState, ent);
+            this.assignGuardToCriticalEnt(gameState, ent);
         }
 
     for (let evt of events.Garrison)
     {
-        let ent = gameState.getEntityById(evt.entity);
-        if (!ent || !ent.isOwn(PlayerID) || !ent.hasClass("Hero"))
+        if (!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.heroGuards = [];
+            this.guardEnts.set(guardId, false);
+        }
+        hero.guards.clear();
     }
 
     for (let evt of events.UnGarrison)
     {
-        let ent = gameState.getEntityById(evt.entity);
-        if (!ent || !ent.isOwn(PlayerID))
+        if (!this.guardEnts.has(evt.entity) && !this.criticalEnts.has(evt.entity))
             continue;
 
+        let ent = gameState.getEntityById(evt.entity);
         // 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.get(evt.entity))
         {
-            this.assignGuardToRegicideHero(gameState, ent);
+            this.assignGuardToCriticalEnt(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);
+        // If this is a hero, try to assign ents that should be guarding it, but couldn't previously
+        let criticalEnt = this.criticalEnts.get(ent.id());
+        for (let [id, isGuarding] of this.guardEnts)
+        {
+            if (criticalEnt.guards.size >= this.healersPerCriticalEnt)
+                break;
+
+            if (!isGuarding)
+                this.assignGuardToCriticalEnt(gameState, gameState.getEntityById(id));
+        }
     }
 };
 
@@ -178 +228 @@
         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 (dependent on the defensive trait)
+ * may not be the number of healers actually guarding a hero at any one time.
+ */
+m.GameTypeManager.prototype.trainRegicideHealer = function(gameState, queues, id)
 {
     if (gameState.ai.HQ.saveResources || !gameState.getOwnEntitiesByClass("Temple", true).hasEntities())
         return;
@@ -186 +240 @@
     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;
 };
 
 /**
- * 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)
+ * Only send the guard command if the guard's accessIndex is the same as the critical ent
+ * and the critical ent has a position (i.e. not garrisoned)
  * request a transport if the accessIndex value is different
  */
-m.GameTypeManager.prototype.assignGuardToRegicideHero = function(gameState, ent)
+m.GameTypeManager.prototype.assignGuardToCriticalEnt = function(gameState, guardEnt)
 {
-    let heroEnt = gameState.getOwnEntitiesByClass("Hero", true).toEntityArray()[0];
-    if (!heroEnt || !heroEnt.position() ||
-        !ent.position() || ent.getMetadata(PlayerID, "transport") !== undefined || !ent.canGuard())
+    // Assign to the critical ent with the fewest guards
+    let min = Math.min();
+    let criticalEntId;
+    for (let [id, data] of this.criticalEnts)
+    {
+        if (data.guards.size > min)
+            continue;
+
+        criticalEntId = id;
+        min = data.guards.size;
+    }
+
+    if (guardEnt.getMetadata(PlayerID, "transport") !== undefined || !guardEnt.canGuard())
         return;
 
-    let entAccess = gameState.ai.accessibility.getAccessValue(ent.position());
-    let heroAccess = gameState.ai.accessibility.getAccessValue(heroEnt.position());
+    let criticalEnt = gameState.getEntityById(criticalEntId);
+    if (!criticalEnt || !criticalEnt.position() || !guardEnt.position())
+    {
+        this.guardEnts.set(guardEnt.id(), false);
+        return;
+    }
+
+    let entAccess = gameState.ai.accessibility.getAccessValue(guardEnt.position());
+    let heroAccess = gameState.ai.accessibility.getAccessValue(criticalEnt.position());
     if (entAccess === heroAccess)
     {
-        ent.guard(heroEnt);
-        this.heroGuards.push(ent.id());
+        guardEnt.guard(criticalEnt);
+        this.criticalEnts.get(criticalEntId).guards.add(guardEnt.id());
     }
     else
-        gameState.ai.HQ.navalManager.requireTransport(gameState, ent, entAccess, heroAccess, heroEnt.position());
+        gameState.ai.HQ.navalManager.requireTransport(gameState, guardEnt, entAccess, heroAccess, criticalEnt.position());
+    this.guardEnts.set(guardEnt.id(), entAccess === heroAccess);
 };
 
 m.GameTypeManager.prototype.update = function(gameState, events, queues)
 {
+    // Wait a turn for trigger scripts to spawn any critical ents (i.e. in regicide)
+    if (gameState.ai.playedTurn === 1)
+        this.init(gameState);
+
     this.checkEvents(gameState, events);
 
     if (gameState.getGameType() === "wonder")
@@ -223 +299 @@
         return;
 
     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.guardEnts.size < gameState.getPopulationMax() / 10)
+            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
     };
 };