Ticket #2160: Regicide_v1.6.patch

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

@@ -498 +498 @@
         "ExploreMap": "exploreMap",
         "DisableTreasures": "disableTreasures",
         "LockTeams": "lockTeams",
-        "LastManStanding" : "lastManStanding",
+        "LastManStanding": "lastManStanding",
+        "RegicideEarlyAttack": "regicideEarlyAttack",
         "CheatsEnabled": "enableCheats"
     };
 
@@ -1183 +1184 @@
     {
         delete g_GameAttributes.settings.WonderDuration;
         delete g_GameAttributes.settings.LastManStanding;
+        delete g_GameAttributes.settings.RegicideEarlyAttack;
     }
 
     if (mapSettings.PlayerData)
@@ -1380 +1382 @@
     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 =
@@ -1386 +1389 @@
         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;
 
@@ -1403 +1409 @@
 
     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;

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

@@ -335 +335 @@
                     </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"/>
@@ -345 +355 @@
                     </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>
@@ -355 +365 @@
                     </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>
@@ -440 +450 @@
                     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"
                 >

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

@@ -992 +992 @@
             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))
@@ -1003 +1011 @@
         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:";

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

@@ -45 +45 @@
 
     // 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) =>
@@ -51 +54 @@
             getSpawnPreference(entity2) - getSpawnPreference(entity1));
 
         this.regicideHeroes[playerID] = this.SpawnRegicideHero(playerID, heroTemplates[playersCivs[playerID]], spawnPoints);
+
+        if (this.regicideEarlyAttack)
+            continue;
+
+        let cmpAttack = Engine.QueryInterface(this.regicideHeroes[playerID], IID_Attack);
+        if (cmpAttack)
+            cmpAttack.SetEnabled(false);
+
+        let cmpAuras = Engine.QueryInterface(this.regicideHeroes[playerID], IID_Auras);
+        if (cmpAuras)
+            cmpAuras.SetEnabled(false);
+
+        let cmpProductionQueue = Engine.QueryInterface(this.regicideHeroes[playerID], IID_ProductionQueue);
+        if (cmpProductionQueue)
+            cmpProductionQueue.SetEnabled(false);
     }
 };
 
@@ -98 +116 @@
     return undefined;
 };
 
+Trigger.prototype.CheckRegicideCityPhase = function(data)
+{
+    if (data.tech.indexOf("phase_city") == -1 || this.regicideEarlyAttack)
+        return;
+
+    let cmpAttack = Engine.QueryInterface(this.regicideHeroes[data.player], IID_Attack);
+    if (cmpAttack)
+        cmpAttack.SetEnabled(true);
+
+    let cmpAuras = Engine.QueryInterface(this.regicideHeroes[data.player], IID_Auras);
+    if (cmpAuras)
+        cmpAuras.SetEnabled(true);
+    
+    let cmpProductionQueue = Engine.QueryInterface(this.regicideHeroes[data.player], IID_ProductionQueue);
+    if (cmpProductionQueue)
+        cmpProductionQueue.SetEnabled(true);
+};
+
 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

@@ -202 +202 @@
 
 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]);
@@ -231 +242 @@
 
 Attack.prototype.CanAttack = function(target)
 {
+    if (!this.enabled)
+        return false;
+
     let cmpFormation = Engine.QueryInterface(target, IID_Formation);
     if (cmpFormation)
         return true;

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

@@ -8 +8 @@
 
 Auras.prototype.Init = function()
 {
+    this.enabled = true;
     let cmpDataTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_DataTemplateManager);
     this.auras = {};
     this.affectedPlayers = {};
@@ -22 +23 @@
     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)
 {
@@ -109 +121 @@
 
 Auras.prototype.CanApply = function(name)
 {
+    if (!this.enabled)
+        return false;
     if (!this.auras[name].requiredTechnology)
         return true;
     let cmpTechnologyManager = QueryOwnerInterface(this.entity, IID_TechnologyManager);

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

@@ -304 +304 @@
         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);
@@ -387 +387 @@
         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

@@ -275 +275 @@
         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": [] });
@@ -348 +348 @@
         cmpProductionQueue.UnpauseProduction();
 
     var cmpAura = Engine.QueryInterface(entity, IID_Auras);
-    if (cmpAura && cmpAura.HasGarrisonAura())
+    if (cmpAura && cmpAura.HasGarrisonAura() && cmpAura.GetEnabled())
         cmpAura.RemoveGarrisonBonus(this.entity);
 
 

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

@@ -757 +757 @@
     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")
@@ -1961 +1974 @@
     "GetNeededResources": 1,
     "GetNotifications": 1,
     "GetTimeNotifications": 1,
+    "GetProductionQueueEnabled": 1,
 
     "GetAvailableFormations": 1,
     "GetFormationRequirements": 1,

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

@@ -42 +42 @@
 
 ProductionQueue.prototype.Init = function()
 {
+    this.enabled = true;
     this.nextID = 1;
 
     this.queue = [];
@@ -78 +79 @@
     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;
@@ -260 +271 @@
     // 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)

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

@@ -73 +73 @@
 auras.OnRangeUpdate({"tag": 1, "added": [30], "removed": []});
 
 TS_ASSERT_EQUALS(ApplyValueModificationsToEntity("Component/Value", 1, targetEnt), 2);
+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: function(id) { return playerEntity; },
+    GetCheatTimeMultiplier: function() { return 20; },
+});
+
+AddMock(SYSTEM_ENTITY, IID_TemplateManager, {
+    GetTemplate: function(trainTemplate) { return 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);