Ticket #2160: regicide_early_attack_v2.patch

binaries/data/mods/public/gui/gamesetup/gamesetup.js

@@ -496 +496 @@
     let options = {
         "RevealMap": "revealMap",
         "ExploreMap": "exploreMap",
         "DisableTreasures": "disableTreasures",
         "LockTeams": "lockTeams",
-        "LastManStanding" : "lastManStanding",
+        "LastManStanding": "lastManStanding",
+        "RegicideEarlyAttack": "regicideEarlyAttack",
         "CheatsEnabled": "enableCheats"
     };
 
     Object.keys(options).forEach(attribute => {
         Engine.GetGUIObjectByName(options[attribute]).onPress = function() {
@@ -1181 +1182 @@
 
     if (g_GameAttributes.mapType == "scenario")
     {
         delete g_GameAttributes.settings.WonderDuration;
         delete g_GameAttributes.settings.LastManStanding;
+        delete g_GameAttributes.settings.RegicideEarlyAttack;
     }
 
     if (mapSettings.PlayerData)
         sanitizePlayerData(mapSettings.PlayerData);
 
@@ -1378 +1380 @@
     setGUIBoolean("disableTreasures", "disableTreasuresText", !!mapSettings.DisableTreasures);
     setGUIBoolean("exploreMap", "exploreMapText", !!mapSettings.ExploreMap);
     setGUIBoolean("revealMap", "revealMapText", !!mapSettings.RevealMap);
     setGUIBoolean("lockTeams", "lockTeamsText", !!mapSettings.LockTeams);
     setGUIBoolean("lastManStanding", "lastManStandingText", !!mapSettings.LastManStanding);
+    setGUIBoolean("regicideEarlyAttack", "regicideEarlyAttackText", !!mapSettings.RegicideEarlyAttack);
     setGUIBoolean("enableRating", "enableRatingText", !!mapSettings.RatingEnabled);
 
     Engine.GetGUIObjectByName("optionWonderDuration").hidden =
         g_GameAttributes.settings.GameType &&
         g_GameAttributes.settings.GameType != "wonder";
     Engine.GetGUIObjectByName("optionLastManStanding").hidden = mapSettings.LockTeams;
+    Engine.GetGUIObjectByName("optionRegicideEarlyAttack").hidden =
+        g_GameAttributes.settings.GameType &&
+        g_GameAttributes.settings.GameType != "regicide";
 
     Engine.GetGUIObjectByName("cheatWarningText").hidden = !g_IsNetworked || !mapSettings.CheatsEnabled;
 
     Engine.GetGUIObjectByName("enableCheats").enabled = !mapSettings.RatingEnabled;
     Engine.GetGUIObjectByName("lockTeams").enabled = !mapSettings.RatingEnabled;
@@ -1401 +1407 @@
 
     let notScenario = g_GameAttributes.mapType != "scenario" && g_IsController ;
 
     for (let ctrl of ["victoryCondition", "wonderDuration", "populationCap",
                       "startingResources", "ceasefire", "revealMap",
-                      "exploreMap", "disableTreasures", "lockTeams", "lastManStanding"])
+                      "exploreMap", "disableTreasures", "lockTeams",
+                      "lastManStanding", "regicideEarlyAttack"])
         hideControl(ctrl, ctrl + "Text", notScenario);
 
     Engine.GetGUIObjectByName("civResetButton").hidden = !notScenario;
     Engine.GetGUIObjectByName("teamResetButton").hidden = !notScenario;
 

binaries/data/mods/public/gui/gamesetup/gamesetup.xml

@@ -333 +333 @@
                     <object name="wonderDuration" size="40%+10 0 100% 28" type="dropdown" style="ModernDropDown" hidden="true" tooltip_style="onscreenToolTip">
                         <translatableAttribute id="tooltip">Number of minutes that the player has to keep the wonder in order to win.</translatableAttribute>
                     </object>
                 </object>
 
-                <object name="optionPopulationCap" size="14 98 94% 126">
+                <object name="optionRegicideEarlyAttack" size="14 98 94% 126">
+                    <object size="0 0 40% 28" type="text" style="ModernRightLabelText">
+                        <translatableAttribute id="caption">Early Hero Attack:</translatableAttribute>
+                    </object>
+                    <object name="regicideEarlyAttackText" size="40% 0 100% 28" type="text" style="ModernLeftLabelText"/>
+                    <object name="regicideEarlyAttack" size="40%+10 5 40%+30 100%-5" type="checkbox" style="ModernTickBox" hidden="true" tooltip_style="onscreenToolTip">
+                        <translatableAttribute id="tooltip">Toggle whether heroes can attack from the start of the game, or from City Phase.</translatableAttribute>
+                    </object>
+                </object>
+
+                <object name="optionPopulationCap" size="14 128 94% 156">
                     <object size="0 0 40% 28" type="text" style="ModernRightLabelText">
                         <translatableAttribute id="caption">Population Cap:</translatableAttribute>
                     </object>
                     <object name="populationCapText" size="40% 0 100% 100%" type="text" style="ModernLeftLabelText"/>
                     <object name="populationCap" size="40%+10 0 100% 28" type="dropdown" style="ModernDropDown" hidden="true" tooltip_style="onscreenToolTip">
                         <translatableAttribute id="tooltip">Select population cap.</translatableAttribute>
                     </object>
                 </object>
 
-                <object name="optionStartingResources" size="14 128 94% 156">
+                <object name="optionStartingResources" size="14 158 94% 186">
                     <object size="0 0 40% 28" type="text" style="ModernRightLabelText">
                         <translatableAttribute id="caption">Starting Resources:</translatableAttribute>
                     </object>
                     <object name="startingResourcesText" size="40% 0 100% 100%" type="text" style="ModernLeftLabelText"/>
                     <object name="startingResources" size="40%+10 0 100% 28" type="dropdown" style="ModernDropDown" hidden="true" tooltip_style="onscreenToolTip">
                         <translatableAttribute id="tooltip">Select the game's starting resources.</translatableAttribute>
                     </object>
                 </object>
 
-                <object name="optionCeasefire" size="14 158 94% 186">
+                <object name="optionCeasefire" size="14 188 94% 216">
                     <object size="0 0 40% 28" type="text" style="ModernRightLabelText">
                         <translatableAttribute id="caption">Ceasefire:</translatableAttribute>
                     </object>
                     <object name="ceasefireText" size="40% 0 100% 100%" type="text" style="ModernLeftLabelText"/>
                     <object name="ceasefire" size="40%+10 0 100% 28" type="dropdown" style="ModernDropDown" hidden="true" tooltip_style="onscreenToolTip">
@@ -438 +448 @@
                 <!-- Hide More Options Button -->
                 <object
                     name="hideMoreOptions"
                     type="button"
                     style="StoneButton"
-                    size="50%-70 428 50%+70 456"
+                    size="50%-70 458 50%+70 486"
                     tooltip_style="onscreenToolTip"
                     hotkey="cancel"
                 >
                     <translatableAttribute id="caption">OK</translatableAttribute>
                     <translatableAttribute id="tooltip">Close more game options window</translatableAttribute>

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

@@ -990 +990 @@
         tooltips.push(
             "[color=\"" + g_HotkeyColor + "\"]" +
             formatBatchTrainingString(buildingsCountToTrainFullBatch, fullBatchSize, remainderBatch) +
             "[/color]");
 
+        let productionQueueEnabled = Engine.GuiInterfaceCall("GetProductionQueueEnabled", {
+            "player": data.unitEntState.player,
+            "ents": data.selection
+        });
+
+        if (!productionQueueEnabled)
+            tooltips.push(sprintf(translate("The Production Queue is disabled for this entity")));
+
         if (!technologyEnabled)
             tooltips.push(sprintf(translate("Requires %(technology)s"), {
                 "technology": getEntityNames(GetTechnologyData(template.requiredTechnology))
             }));
 
@@ -1001 +1009 @@
             tooltips.push(getNeededResourcesTooltip(neededResources));
 
         data.button.tooltip = tooltips.filter(tip => tip).join("\n");
 
         let modifier = "";
-        if (!technologyEnabled || limits.canBeAddedCount == 0)
+        if (!technologyEnabled || limits.canBeAddedCount == 0 || !productionQueueEnabled)
         {
             data.button.enabled = false;
             modifier = "color:0 0 0 127:grayscale:";
         }
         else if (neededResources)

binaries/data/mods/public/maps/scripts/Regicide.js

@@ -47 +47 @@
         return 0;
     };
 
     // Attempt to spawn one hero per player
     let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+    let cmpEndGameManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_EndGameManager);
+    this.regicideEarlyAttack = cmpEndGameManager.GetGameTypeSettings().regicideEarlyAttack;
+
     for (let playerID = 1; playerID < TriggerHelper.GetNumberOfPlayers(); ++playerID)
     {
         let spawnPoints = cmpRangeManager.GetEntitiesByPlayer(playerID).sort((entity1, entity2) =>
             getSpawnPreference(entity2) - getSpawnPreference(entity1));
 
         this.regicideHeroes[playerID] = this.SpawnRegicideHero(playerID, heroTemplates[playersCivs[playerID]], spawnPoints);
+
+        if (!this.regicideEarlyAttack)
+            this.SetRegicideEarlyAttack(this.regicideHeroes[playerID], false);
     }
 };
 
 /**
  * Spawn a random hero at one of the given locations (which are checked in order).
@@ -100 +106 @@
 
     error("Couldn't spawn hero for player " + playerID);
     return undefined;
 };
 
+Trigger.prototype.CheckRegicideCityPhase = function(data)
+{
+    if (data.tech.indexOf("phase_city") == -1 || this.regicideEarlyAttack)
+        return;
+
+    this.SetRegicideEarlyAttack(this.regicideHeroes[data.player], true);
+};
+
+Trigger.prototype.SetRegicideEarlyAttack(hero, enabled)
+{
+    let cmpAttack = Engine.QueryInterface(heor, IID_Attack);
+    if (cmpAttack)
+        cmpAttack.SetEnabled(enabled);
+
+    let cmpAuras = Engine.QueryInterface(hero, IID_Auras);
+    if (cmpAuras)
+        cmpAuras.SetEnabled(enabled);
+
+    let cmpProductionQueue = Engine.QueryInterface(hero, IID_ProductionQueue);
+    if (cmpProductionQueue)
+        cmpProductionQueue.SetEnabled(enabled);
+};
+
 let cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
 cmpTrigger.regicideHeroes = [];
+cmpTrigger.regicideEarlyAttack = false;
 cmpTrigger.DoAfterDelay(0, "InitRegicideGame", {});
 cmpTrigger.RegisterTrigger("OnOwnershipChanged", "CheckRegicideDefeat", { "enabled": true });
+cmpTrigger.RegisterTrigger("OnResearchFinished", "CheckRegicideCityPhase", { "enabled": true });

binaries/data/mods/public/simulation/components/Attack.js

@@ -200 +200 @@
         "</element>" +
     "</optional>";
 
 Attack.prototype.Init = function()
 {
+    this.enabled = true;
 };
 
 Attack.prototype.Serialize = null; // we have no dynamic state to save
 
+Attack.prototype.GetEnabled = function()
+{
+    return this.enabled;
+};
+
+Attack.prototype.SetEnabled = function(enabled)
+{
+    this.enabled = enabled;
+};
+
 Attack.prototype.GetAttackTypes = function()
 {
     return ["Melee", "Ranged", "Capture"].filter(type => !!this.template[type]);
 };
 
@@ -229 +240 @@
     return [];
 };
 
 Attack.prototype.CanAttack = function(target)
 {
+    if (!this.enabled)
+        return false;
+
     let cmpFormation = Engine.QueryInterface(target, IID_Formation);
     if (cmpFormation)
         return true;
 
     let cmpThisPosition = Engine.QueryInterface(this.entity, IID_Position);
@@ -339 +353 @@
     // check if the target is capturable
     let captureIndex = types.indexOf("Capture");
     if (captureIndex != -1)
     {
         let cmpCapturable = QueryMiragedInterface(target, IID_Capturable);
-
         let cmpPlayer = QueryOwnerInterface(this.entity);
+
         if (allowCapture && cmpPlayer && cmpCapturable && cmpCapturable.CanCapture(cmpPlayer.GetPlayerID()))
             return "Capture";
+
         // not captureable, so remove this attack
         types.splice(captureIndex, 1);
     }
 
     let isPreferred = className => attack.GetPreferredClasses(className).some(isTargetClass);

binaries/data/mods/public/simulation/components/Auras.js

@@ -6 +6 @@
     "</attribute>" +
     "<text a:help='A whitespace-separated list of aura files, placed under simulation/data/auras/'/>";
 
 Auras.prototype.Init = function()
 {
+    this.enabled = true;
     let cmpDataTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_DataTemplateManager);
     this.auras = {};
     this.affectedPlayers = {};
     let auraNames = this.GetAuraNames();
     for (let name of auraNames)
@@ -20 +21 @@
     // In case of autogarrisoning, this component can be called before ownership is set.
     // So it needs to be completely initialised from the start.
     this.Clean();
 };
 
+Auras.prototype.GetEnabled = function()
+{
+    return this.enabled;
+};
+
+Auras.prototype.SetEnabled = function(enabled)
+{
+    this.enabled = enabled;
+    this.Clean();
+};
+
 // We can modify identifier if we want stackable auras in some case.
 Auras.prototype.GetModifierIdentifier = function(name)
 {
     if (this.auras[name].stackable)
         return name + this.entity;
@@ -107 +119 @@
     }
 };
 
 Auras.prototype.CanApply = function(name)
 {
+    if (!this.enabled)
+        return false;
     if (!this.auras[name].requiredTechnology)
         return true;
     let cmpTechnologyManager = QueryOwnerInterface(this.entity, IID_TechnologyManager);
     if (!cmpTechnologyManager)
         return false;

binaries/data/mods/public/simulation/components/Formation.js

@@ -302 +302 @@
         var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
         cmpUnitAI.SetFormationController(this.entity);
         cmpUnitAI.SetLastFormationTemplate(templateName);
 
         var cmpAuras = Engine.QueryInterface(ent, IID_Auras);
-        if (cmpAuras && cmpAuras.HasFormationAura())
+        if (cmpAuras && cmpAuras.HasFormationAura() && cmpAuras.GetEnabled())
         {
             this.formationMembersWithAura.push(ent);
             cmpAuras.ApplyFormationBonus(ents);
         }
     }
@@ -385 +385 @@
     {
         var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
         cmpUnitAI.SetFormationController(this.entity);
         
         var cmpAuras = Engine.QueryInterface(ent, IID_Auras);
-        if (cmpAuras && cmpAuras.HasFormationAura())
+        if (cmpAuras && cmpAuras.HasFormationAura() && cmpAuras.GetEnabled())
         {
             this.formationMembersWithAura.push(ent);
             cmpAuras.ApplyFormationBonus(ents);
         }
     }

binaries/data/mods/public/simulation/components/GarrisonHolder.js

@@ -273 +273 @@
     var cmpProductionQueue = Engine.QueryInterface(entity, IID_ProductionQueue);
     if (cmpProductionQueue)
         cmpProductionQueue.PauseProduction();
 
     var cmpAura = Engine.QueryInterface(entity, IID_Auras);
-    if (cmpAura && cmpAura.HasGarrisonAura())
+    if (cmpAura && cmpAura.HasGarrisonAura() && cmpAura.GetEnabled())
         cmpAura.ApplyGarrisonBonus(this.entity);
 
     Engine.PostMessage(this.entity, MT_GarrisonedUnitsChanged, { "added" : [entity], "removed": [] });
 
     var cmpUnitAI = Engine.QueryInterface(entity, IID_UnitAI);
@@ -346 +346 @@
     var cmpProductionQueue = Engine.QueryInterface(entity, IID_ProductionQueue);
     if (cmpProductionQueue)
         cmpProductionQueue.UnpauseProduction();
 
     var cmpAura = Engine.QueryInterface(entity, IID_Auras);
-    if (cmpAura && cmpAura.HasGarrisonAura())
+    if (cmpAura && cmpAura.HasGarrisonAura() && cmpAura.GetEnabled())
         cmpAura.RemoveGarrisonBonus(this.entity);
 
 
     cmpNewPosition.JumpTo(pos.x, pos.z);
     cmpNewPosition.SetHeightOffset(0);

binaries/data/mods/public/simulation/components/GuiInterface.js

@@ -755 +755 @@
     let time = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer).GetTime();
     // filter on players and time, since the delete timer might be executed with a delay
     return this.timeNotifications.filter(n => n.players.indexOf(player) != -1 && n.endTime > time);
 };
 
+GuiInterface.prototype.GetProductionQueueEnabled = function(player, data)
+{
+    for (let ent of data.ents)
+    {
+        let cmpProductionQueue = Engine.QueryInterface(ent, IID_ProductionQueue);
+        if (!cmpProductionQueue)
+            continue;
+        else
+            return cmpProductionQueue.GetEnabled();
+    }
+    return false;
+};
+
 GuiInterface.prototype.PushNotification = function(notification)
 {
     if (!notification.type || notification.type == "text")
         this.AddTimeNotification(notification);
     else
@@ -1959 +1972 @@
     "GetBattleState": 1,
     "GetIncomingAttacks": 1,
     "GetNeededResources": 1,
     "GetNotifications": 1,
     "GetTimeNotifications": 1,
+    "GetProductionQueueEnabled": 1,
 
     "GetAvailableFormations": 1,
     "GetFormationRequirements": 1,
     "CanMoveEntsIntoFormation": 1,
     "IsFormationSelected": 1,

binaries/data/mods/public/simulation/components/ProductionQueue.js

@@ -40 +40 @@
         "</interleave>" +
     "</element>";
 
 ProductionQueue.prototype.Init = function()
 {
+    this.enabled = true;
     this.nextID = 1;
 
     this.queue = [];
     // Queue items are:
     //   {
@@ -76 +77 @@
     this.spawnNotified = false;
     
     this.alertRaiser = undefined;
 };
 
+ProductionQueue.prototype.GetEnabled = function()
+{
+    return this.enabled;
+};
+
+ProductionQueue.prototype.SetEnabled = function(enabled)
+{
+    this.enabled = enabled;
+};
+
 ProductionQueue.prototype.PutUnderAlert = function(raiser)
 {
     this.alertRaiser = raiser;
 };
 
@@ -258 +269 @@
 ProductionQueue.prototype.AddBatch = function(templateName, type, count, metadata)
 {
     // TODO: there should probably be a limit on the number of queued batches
     // TODO: there should be a way for the GUI to determine whether it's going
     // to be possible to add a batch (based on resource costs and length limits)
+    if (!this.enabled)
+        return;
     var cmpPlayer = QueryOwnerInterface(this.entity);
 
     if (this.queue.length < MAX_QUEUE_SIZE)
     {
         
@@ -656 +669 @@
             "entities": createdEnts,
             "owner": cmpOwnership.GetOwner(),
             "metadata": metadata,
         });
         
-        if(this.alertRaiser && spawnedEnts.length > 0)
+        if (this.alertRaiser && spawnedEnts.length > 0)
         {
             var cmpAlertRaiser = Engine.QueryInterface(this.alertRaiser, IID_AlertRaiser);
-            if(cmpAlertRaiser)
+            if (cmpAlertRaiser)
                 cmpAlertRaiser.UpdateUnits(spawnedEnts);
         }
     }
     
     return createdEnts.length;

binaries/data/mods/public/simulation/components/tests/test_Attack.js

@@ +1 @@
+Engine.LoadHelperScript("Player.js");
+Engine.LoadHelperScript("ValueModification.js");
+Engine.LoadComponentScript("interfaces/Auras.js");
+Engine.LoadComponentScript("interfaces/AuraManager.js");
+Engine.LoadComponentScript("interfaces/Capturable.js");
+Engine.LoadComponentScript("interfaces/TechnologyManager.js");
+Engine.LoadComponentScript("interfaces/Formation.js");
+Engine.LoadComponentScript("Formation.js");
+Engine.LoadComponentScript("interfaces/Attack.js");
+Engine.LoadComponentScript("Attack.js");
+
+function TS_ASSERT_EQUAL_OBJECTS(obj1, obj2)
+{
+    TS_ASSERT_EQUALS(typeof obj1, typeof obj2);
+
+    if (typeof obj1 == "object")
+    {
+        TS_ASSERT_EQUALS(Object.keys(obj1).toString(), Object.keys(obj2).toString());
+
+        for (let prop in obj1)
+            TS_ASSERT_EQUAL_OBJECTS(obj1[prop], obj2[prop]);
+    }
+    else
+        TS_ASSERT_EQUALS(obj1, obj2);
+}
+
+// Initialize player
+{
+    let playerEnt1 = 5;
+
+    AddMock(SYSTEM_ENTITY, IID_PlayerManager, {
+        "GetPlayerByID": () => playerEnt1
+    });
+
+    AddMock(playerEnt1, IID_Player, {
+        "GetPlayerID": () => 1
+    });
+}
+
+// Create attacker
+let entityID = 903;
+let attacker = ++entityID;
+
+AddMock(attacker, IID_Position, {
+    "IsInWorld": () => true,
+    "GetHeightOffset": () => 5
+});
+
+AddMock(attacker, IID_Ownership, {
+    "GetOwner": owner => 1
+});
+
+let cmpAttack = ConstructComponent(attacker, "Attack", {
+    "Melee" : {
+        "Hack": 11,
+        "Pierce": 5,
+        "Crush": 0,
+        "MinRange": 3,
+        "MaxRange": 5,
+        "PreferredClasses": {
+            "_string": "Female"
+        },
+        "RestrictedClasses": {
+            "_string": "Elephant Archer"
+        }
+    },
+    "Ranged" : {
+        "Hack": 0,
+        "Pierce": 10,
+        "Crush": 0,
+        "MinRange": 10,
+        "MaxRange": 80,
+        "PrepareTime": 300,
+        "RepeatTime": 500,
+        "PreferredClasses": {
+            "_string": "Archer"
+        },
+        "RestrictedClasses": {
+            "_string": "Elephant"
+        }
+    },
+    "Capture" : {
+        "Value": 8,
+        "MaxRange": 10,
+    },
+    "Slaughter": {}
+});
+
+TS_ASSERT_EQUAL_OBJECTS(cmpAttack.GetAttackTypes(), ["Melee", "Ranged", "Capture"]);
+TS_ASSERT_EQUAL_OBJECTS(cmpAttack.GetPreferredClasses("Melee"), ["Female"]);
+TS_ASSERT_EQUAL_OBJECTS(cmpAttack.GetRestrictedClasses("Melee"), ["Elephant", "Archer"]);
+TS_ASSERT_EQUAL_OBJECTS(cmpAttack.GetFullAttackRange(), { "min": 0, "max": 80 });
+TS_ASSERT_EQUAL_OBJECTS(cmpAttack.GetAttackStrengths("Capture"), { "value": 8 });
+
+TS_ASSERT_EQUAL_OBJECTS(cmpAttack.GetAttackStrengths("Ranged"), {
+    "hack": 0,
+    "pierce": 10,
+    "crush": 0,
+});
+
+TS_ASSERT_EQUAL_OBJECTS(cmpAttack.GetTimers("Ranged"), {
+    "prepare": 300,
+    "repeat": 500,
+    "recharge": 200
+});
+
+TS_ASSERT_EQUAL_OBJECTS(cmpAttack.GetTimers("Capture"), {
+    "prepare": 0,
+    "repeat": 1000,
+    "recharge": 1000
+});
+
+// Create elephant to ensure CanAttack takes restricted classes into account and rejects
+{
+    let innocentElephant = ++entityID;
+
+    AddMock(innocentElephant, IID_Identity, {
+        "GetClassesList": () => ["Elephant"]
+    });
+
+    AddMock(innocentElephant, IID_Position, {
+        "IsInWorld": () => true,
+        "GetHeightOffset": () => 8
+    });
+
+    TS_ASSERT_EQUALS(cmpAttack.CanAttack(innocentElephant), false);
+
+    cmpAttack.SetEnabled(true);
+    TS_ASSERT_EQUALS(cmpAttack.CanAttack(innocentElephant), false);
+}
+
+// Create woman to test SetEnabled, GetEnabled, CanAttack and GetBestAttackAgainst
+{
+    let helplessWoman = ++entityID;
+
+    AddMock(helplessWoman, IID_Identity, {
+        "GetClassesList": () => ["Female"]
+    });
+
+    AddMock(helplessWoman, IID_Position, {
+        "IsInWorld": () => true,
+        "GetHeightOffset": () => 2
+    });
+
+    TS_ASSERT_EQUALS(cmpAttack.GetEnabled(helplessWoman), true);
+    TS_ASSERT_EQUALS(cmpAttack.CanAttack(helplessWoman), true);
+    TS_ASSERT_EQUALS(cmpAttack.GetBestAttackAgainst(helplessWoman), "Melee");
+
+    for (let value of [true, false, true])
+    {
+        cmpAttack.SetEnabled(value);
+        TS_ASSERT_EQUALS(cmpAttack.GetEnabled(helplessWoman), value);
+        TS_ASSERT_EQUALS(cmpAttack.CanAttack(helplessWoman), value);
+    }
+}
+
+// Create archer to test CanAttack and GetBestAttackAgainst
+{
+    let archer = ++entityID;
+
+    AddMock(archer, IID_Identity, {
+        "GetClassesList": () => ["Archer"]
+    });
+
+    AddMock(archer, IID_Position, {
+        "IsInWorld": () => true,
+        "GetHeightOffset": () => 4
+    });
+
+    TS_ASSERT_EQUALS(cmpAttack.CanAttack(archer), true);
+    TS_ASSERT_EQUALS(cmpAttack.GetBestAttackAgainst(archer), "Ranged");
+}
+
+// Create building to test CanAttack and GetBestAttackAgainst with capturing
+{
+    let darkFortress = ++entityID;
+
+    AddMock(darkFortress, IID_Identity, {
+        "GetClassesList": () => ["Structure"]
+    });
+
+    AddMock(darkFortress, IID_Position, {
+        "IsInWorld": () => true,
+        "GetHeightOffset": () => 4
+    });
+
+    AddMock(darkFortress, IID_Capturable, {
+        "CanCapture": playerID => {
+            TS_ASSERT_EQUALS(playerID, 1);
+            return true;
+        }
+    });
+
+    TS_ASSERT_EQUALS(cmpAttack.CanAttack(darkFortress), true);
+    TS_ASSERT_EQUALS(cmpAttack.GetBestAttackAgainst(darkFortress, true), "Capture");
+}
+
+// Slaughter sheep
+{
+    let sheep = ++entityID;
+
+    AddMock(sheep, IID_Identity, {
+        "GetClassesList": () => ["Domestic"]
+    });
+
+    AddMock(sheep, IID_Position, {
+        "IsInWorld": () => true,
+        "GetHeightOffset": () => 2
+    });
+
+    TS_ASSERT_EQUALS(cmpAttack.CanAttack(sheep), true);
+    TS_ASSERT_EQUALS(cmpAttack.GetBestAttackAgainst(sheep, true), "Slaughter");
+}

binaries/data/mods/public/simulation/components/tests/test_Auras.js

@@ -21 +21 @@
     },
     EnableActiveQuery: function(id) { },
     ResetActiveQuery: function(id) { if (mode == 0) return []; else return [enemy]; },
     DisableActiveQuery: function(id) { },
     GetEntityFlagMask: function(identifier) { },
+    "DestroyActiveQuery": () => {}
 });
 
 AddMock(SYSTEM_ENTITY, IID_DataTemplateManager, {
     GetAuraTemplate: function(name) {
         if (name == "test1")
@@ -71 +72 @@
 
 // send the rangeManager message
 auras.OnRangeUpdate({"tag": 1, "added": [30], "removed": []});
 
 TS_ASSERT_EQUALS(ApplyValueModificationsToEntity("Component/Value", 1, targetEnt), 2);
+TS_ASSERT_EQUALS(auras.GetEnabled(), true);
+
+auras.SetEnabled(false)
+TS_ASSERT_EQUALS(auras.GetEnabled(), false);
+
+auras.SetEnabled(true)
+TS_ASSERT_EQUALS(auras.GetEnabled(), true);

binaries/data/mods/public/simulation/components/tests/test_GarrisonHolder.js

@@ +1 @@
+Engine.LoadHelperScript("Player.js");
+Engine.LoadComponentScript("interfaces/GarrisonHolder.js");
+Engine.LoadComponentScript("interfaces/Health.js");
+Engine.LoadComponentScript("GarrisonHolder.js");
+Engine.LoadComponentScript("Identity.js");
+
+let garrisonEnt = 15;
+let unitEnt = 33;
+let entHP = 1000;
+
+AddMock(garrisonEnt, IID_Health, {
+    "GetHitpoints": () => entHP,
+    "Decrease": hp => {
+        entHP = Math.max(entHP - hp, 0);
+    },
+});
+
+let cmpGarrisonHolder = ConstructComponent(garrisonEnt, "GarrisonHolder", {
+    "LoadingRange": "2.0",
+    "Max": "20",
+    "List": "Support"
+});
+
+TS_ASSERT_EQUALS(cmpGarrisonHolder.GetGarrisonedEntitiesCount(), 0);
+TS_ASSERT_EQUALS(cmpGarrisonHolder.entities.length, 0);
+TS_ASSERT_EQUALS(cmpGarrisonHolder.visibleGarrisonPoints.length, 0);
+TS_ASSERT_EQUALS(+cmpGarrisonHolder.template.Max, 20);
+TS_ASSERT_EQUALS(cmpGarrisonHolder.GetLoadingRange().max, 2.0);

binaries/data/mods/public/simulation/components/tests/test_ProductionQueue.js

@@ +1 @@
+Engine.LoadHelperScript("Player.js");
+Engine.LoadHelperScript("ValueModification.js");
+Engine.LoadComponentScript("interfaces/ProductionQueue.js");
+Engine.LoadComponentScript("interfaces/TechnologyManager.js");
+Engine.LoadComponentScript("interfaces/Player.js");
+Engine.LoadComponentScript("ProductionQueue.js");
+Engine.LoadComponentScript("TechnologyManager.js");
+Engine.LoadComponentScript("Player.js");
+
+let playerEntity = 1;
+let productionEnt = 31;
+let trainTemplate = "units/athen_infantry_spearman_b";
+
+AddMock(SYSTEM_ENTITY, IID_PlayerManager, {
+    "GetPlayerByID": id => playerEntity,
+    "GetCheatTimeMultiplier": () => 20,
+});
+
+AddMock(SYSTEM_ENTITY, IID_TemplateManager, {
+    "GetTemplate": trainTemplate => trainTemplate,
+});
+
+let cmpProductionQueue = ConstructComponent(productionEnt, "ProductionQueue", {
+    "BatchTimeModifier": "0.7",
+    "Entities": "units/athen_infantry_spearman_b"
+});
+
+TS_ASSERT_EQUALS(cmpProductionQueue.GetEnabled(), true);
+
+cmpProductionQueue.SetEnabled(false);
+TS_ASSERT_EQUALS(cmpProductionQueue.GetEnabled(), false);
+
+cmpProductionQueue.SetEnabled(true);
+TS_ASSERT_EQUALS(cmpProductionQueue.GetEnabled(), true);
+
+cmpProductionQueue.PutUnderAlert(productionEnt);
+TS_ASSERT_EQUALS(cmpProductionQueue.alertRaiser, productionEnt);
+
+cmpProductionQueue.ResetAlert();
+TS_ASSERT_EQUALS(cmpProductionQueue.alertRaiser, undefined);
+TS_ASSERT_EQUALS(cmpProductionQueue.GetQueue().length, 0);