Ticket #3747: 3747_promotionModifier.patch

binaries/data/mods/public/globalscripts/Technologies.js

@@ -53 +53 @@
 }
 
 /**
+ * Derives modifications (to be applied to entities) from a given technology
+ * 
+ * @param techTemplate The technology template to derive the modifications from.
+ * @return Object containing the relevant modifications.
+ */
+function DeriveModificationsFromTech(techTemplate)
+{
+    if (!techTemplate.modifications)
+        return {};
+
+    let techMods = {};
+    let techAffects = [];
+    if (techTemplate.affects && techTemplate.affects.length > 0)
+        for (let affected of techTemplate.affects)
+            techAffects.push(affected.split(/\s+/));
+    else
+        techAffects.push([]);
+
+    for (let mod of techTemplate.modifications)
+    {
+        let affects = techAffects.slice();
+        if (mod.affects)
+        {
+            let specAffects = mod.affects.split(/\s+/);
+            for (let a in affects)
+                affects[a] = affects[a].concat(specAffects);
+        }
+
+        let newModifier = {
+            "affects": affects
+        };
+        for (let idx in mod)
+            if (idx !== "value" && idx !== "affects")
+                newModifier[idx] = mod[idx];
+
+        if (!techMods[mod.value])
+            techMods[mod.value] = [];
+        techMods[mod.value].push(newModifier);
+    }
+    return techMods;
+}
+
+/**
  * Returns whether the given modification applies to the entity containing the given class list
  */
 function DoesModificationApply(modification, classes)

binaries/data/mods/public/globalscripts/Templates.js

@@ -78 +78 @@
     var func;
     if (player)
         func = ApplyValueModificationsToTemplate;
+    else if (g_Modifiers)
+        func = function(property, val, c, template) {
+            return GetTechModifiedProperty(g_Modifiers, template, property, val);
+        }
     else
         func = function(a, val, c, d) { return val; }
 

binaries/data/mods/public/gui/structree/load.js

@@ -35 +35 @@
     return rates;
 }
 
+function preloadUnit(templateName)
+{
+    if (!Engine.TemplateExists(templateName))
+        return;
+    let template = loadTemplate(templateName);
+
+    if (template.Builder && template.Builder.Entities._string)
+        for (let build of template.Builder.Entities._string.split(" "))
+        {
+            build = build.replace("{civ}", g_SelectedCiv);
+            if (g_Lists.structures.indexOf(build) < 0)
+                g_Lists.structures.push(build);
+        }
+
+    if (template.ProductionQueue)
+        for (let build of template.ProductionQueue.Entities._string.split(" "))
+        {
+            build = build.replace("{civ}", g_SelectedCiv);
+            if (g_Lists.units.indexOf(build) === -1)
+                g_Lists.units.push(build);
+        }
+
+    if (template.Identity.Rank)
+    {
+        let promotionTech = template.Identity.Rank.toLowerCase() + "_unit_bonus";
+        if (g_Lists.modifiers.indexOf(promotionTech) < 0)
+            g_Lists.modifiers.push(promotionTech);
+
+        // recurse through promotions to get all techs
+        if (template.Promotion)
+            preloadUnit(template.Promotion.Entity);
+    }
+}
+
 function loadUnit(templateName)
 {
     if (!Engine.TemplateExists(templateName))
@@ -58 +92 @@
     {
         unit.trainer = [];
         for (let build of template.ProductionQueue.Entities._string.split(" "))
-        {
-            build = build.replace("{civ}", g_SelectedCiv);
-            unit.trainer.push(build);
-            if (g_Lists.units.indexOf(build) === -1)
-                g_Lists.units.push(build);
-        }
+            unit.trainer.push(build.replace("{civ}", g_SelectedCiv));
     }
 
     if (template.Heal)
@@ -84 +113 @@
     return unit;
 }
 
+function preloadStructure(templateName)
+{
+    let template = loadTemplate(templateName);
+
+    if (template.ProductionQueue && template.ProductionQueue.Entities && template.ProductionQueue.Entities._string)
+        for (let build of template.ProductionQueue.Entities._string.split(" "))
+        {
+            build = build.replace("{civ}", g_SelectedCiv);
+            if (g_Lists.units.indexOf(build) < 0)
+                g_Lists.units.push(build);
+        }
+}
+
 function loadStructure(templateName)
 {
     var template = loadTemplate(templateName);
@@ -109 +151 @@
             {
                 build = build.replace("{civ}", g_SelectedCiv);
                 structure.production.units.push(build);
-                if (g_Lists.units.indexOf(build) < 0)
-                    g_Lists.units.push(build);
             }
 
         if (template.ProductionQueue.Technologies && template.ProductionQueue.Technologies._string)
@@ -242 +282 @@
     return phase;
 }
 
+function loadModifierTech(modCode)
+{
+    if (!Engine.FileExists("simulation/data/technologies/"+modCode+".json"))
+        return {};
+    return loadTechData(modCode);
+}
+
 function loadTechnologyPair(pairCode)
 {
     var pairInfo = loadTechData(pairCode);

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

@@ -6 +6 @@
 };
 var g_Lists = {};
 var g_CivData = {};
+var g_Modifiers = {};
 var g_SelectedCiv = "";
 var g_CallbackSet = false;
 
@@ -58 +59 @@
     g_Lists.units = [];
     g_Lists.structures = [];
     g_Lists.techs = [];
+    g_Lists.modifiers = [];
+    g_Modifiers = {};
 
     // get initial units
-    var startStructs = [];
+    let startStructs = [];
     for (let entity of g_CivData[civCode].StartEntities)
     {
         if (entity.Template.slice(0, 5) == "units")
@@ -72 +75 @@
         }
     }
 
-    // Load units and structures
-    var unitCount = 0;
+    // Compile lists of units and structures belonging to this civ
+    let unitCount = 0;
     do
     {
         for (let u of g_Lists.units)
-            if (!g_ParsedData.units[u])
-                g_ParsedData.units[u] = loadUnit(u);
+            preloadUnit(u);
 
         unitCount = g_Lists.units.length;
 
         for (let s of g_Lists.structures)
-            if (!g_ParsedData.structures[s])
-                g_ParsedData.structures[s] = loadStructure(s);
+            preloadStructure(s);
 
     } while (unitCount < g_Lists.units.length);
 
+
+    // Load modifiers
+    for (let modCode of g_Lists.modifiers)
+    {
+        let modTech = loadModifierTech(modCode);
+        let derivedModifiers = DeriveModificationsFromTech(modTech);
+
+        for (let modPath in derivedModifiers)
+        {
+            if (!g_Modifiers[modPath])
+                g_Modifiers[modPath] = [];
+            g_Modifiers[modPath] = g_Modifiers[modPath].concat(derivedModifiers[modPath]);
+        }
+    }
+
+    // Properly load units and structures, now we have modifiers
+    for (let u of g_Lists.units)
+        if (!g_ParsedData.units[u])
+            g_ParsedData.units[u] = loadUnit(u);
+
+    for (let s of g_Lists.structures)
+        if (!g_ParsedData.structures[s])
+            g_ParsedData.structures[s] = loadStructure(s);
+
     // Load technologies
-    var techPairs = {};
+    let techPairs = {};
     for (let techcode of g_Lists.techs)
     {
         let realcode = depath(techcode);

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

@@ -284 +284 @@
     // store the modifications in an easy to access structure
     if (template.modifications)
     {
-        var affects = [];
-        if (template.affects && template.affects.length > 0)
+        let derivedModifiers = DeriveModificationsFromTech(template);
+        for (let modifierPath in derivedModifiers)
         {
-            for (let affect of template.affects)
-            {
-                // Put the list of classes into an array for convenient access
-                affects.push(affect.split(/\s+/));
-            }
-        }
-        else
-        {
-            affects.push([]);
-        }
-
-        // We add an item to this.modifications for every modification in the template.modifications array
-        for (var i in template.modifications)
-        {
-            var modification = template.modifications[i];
-            if (!this.modifications[modification.value])
-                this.modifications[modification.value] = [];
-            
-            var modAffects = affects.slice();
-            if (modification.affects)
-            {
-                var extraAffects = modification.affects.split(/\s+/);
-                for (var a in modAffects)
-                    modAffects[a] = modAffects[a].concat(extraAffects);
-            }
-
-            var mod = {"affects": modAffects};
-
-            // copy the modification data into our new data structure
-            for (var j in modification)
-                if (j !== "value" && j !== "affects")
-                    mod[j] = modification[j];
+            if (!this.modifications[modifierPath])
+                this.modifications[modifierPath] = [];
+            this.modifications[modifierPath] = this.modifications[modifierPath].concat(derivedModifiers[modifierPath]);
 
-            this.modifications[modification.value].push(mod);
-            var component = modification.value.split("/")[0];
+            let component = modifierPath.split("/")[0];
             if (!modifiedComponents[component])
                 modifiedComponents[component] = [];
-            modifiedComponents[component].push(modification.value);
-            this.modificationCache[modification.value] = {};
+            modifiedComponents[component].push(modifierPath);
+            this.modificationCache[modifierPath] = {};
         }
     }