Ticket #3993: notciv_v3-3.patch

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

@@ -107 +107 @@
     var template = loadTemplate(templateName);
     return GetTemplateDataHelper(template, null, g_AuraData);
 }
+
+/**
+ * Determines and returns the phase of a given technology. Works
+ * recursively through the given tech's pre-requisite and superseded
+ * techs if necessary.
+ * 
+ * @param {string} techName - The Technology's name
+ * @return The name of the phase the technology belongs to, or false if
+ *         the current civ can't research this tech
+ */
+function GetPhaseOfTechnology(techName)
+{
+    let phaseIdx = -1;
+
+    if (depath(techName).slice(0, 5) === "phase")
+    {
+        phaseIdx = g_ParsedData.phaseList.indexOf(g_ParsedData.phases[techName].actualPhase);
+        if (phaseIdx > 0)
+            return g_ParsedData.phaseList[phaseIdx - 1];
+        warn("Unrecognised phase (" + techName + ")");
+        return false;
+    }
+
+    let techReqs = g_ParsedData.techs[techName].reqs;
+    let reqs = [];
+
+    if (g_SelectedCiv in techReqs)
+    {
+        if (techReqs[g_SelectedCiv] === false)
+            return false;
+        reqs = techReqs[g_SelectedCiv];
+    }
+    else if ("generic" in techReqs)
+        reqs = techReqs.generic;
+
+    for (let req of reqs)
+    {
+        if (depath(req).slice(0, 5) === "phase")
+            return req;
+        phaseIdx = Math.max(phaseIdx, g_ParsedData.phaseList.indexOf(GetPhaseOfTechnology(req)));
+    }
+    return g_ParsedData.phaseList[phaseIdx] || false;
+}

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

@@ -188 +188 @@
 
     if (template.requirements !== undefined)
     {
-        for (let op in template.requirements)
-        {
-            let val = template.requirements[op];    
-            let req = calcReqs(op, val);
-
-            switch (op)
-            {
-            case "tech":
-                tech.reqs.generic = req;
-                break;
-
-            case "civ":
-                tech.reqs[req] = [];
-                break;
-
-            case "any":
-                if (req[0].length > 0)
-                    for (let r of req[0])
-                    {
-                        let v = req[0][r];
-                        if (typeof r == "number")
-                            tech.reqs[v] = [];
-                        else
-                            tech.reqs[r] = v;
-                    }
-                if (req[1].length > 0)
-                    tech.reqs.generic = req[1];
-                break;
-
-            case "all":
-                if (!req[0].length)
-                    tech.reqs.generic = req[1];
-                else
-                    for (let r of req[0])
-                        tech.reqs[r] = req[1];
-                break;
-            }
-        }
+        let op = Object.keys(template.requirements)[0];
+        let val = template.requirements[op];
+        tech.reqs = calcReqs(op, val);
     }
 
     if (template.supersedes !== undefined)
     {
         if (tech.reqs.generic !== undefined)
             tech.reqs.generic.push(template.supersedes);
+        else if (!Object.keys(tech.reqs).length)
+            tech.reqs.generic = [template.supersedes];
         else
             for (let ck of Object.keys(tech.reqs))
-                tech.reqs[ck].push(template.supersedes);
+                if (tech.reqs[ck])
+                    tech.reqs[ck].push(template.supersedes);
     }
 
     return tech;
@@ -266 +234 @@
  * Calculate the prerequisite requirements of a technology.
  * Works recursively if needed.
  *
- * @param op The base operation. Can be "civ", "tech", "all" or "any".
- * @param val The value associated with the above operation.
+ * @param {string} operator - The base operation. Can be "civ", "notciv", "tech", "all" or "any".
+ * @param {mixed} value - The value associated with the above operation.
  *
- * @return Sorted requirments.
+ * @return Object containing the requirements, sorted.
  */
-function calcReqs(op, val)
+function calcReqs(operator, value)
 {
-    switch (op)
+    let requirements = {};
+
+    switch (operator)
     {
     case "civ":
-    case "class":
+        requirements[value] = [];
+        break;
+
     case "notciv":
+        requirements[value] = false;
+        break;
+
+    case "class":
     case "number":
-        // nothing needs doing
+        // do nothing
         break;
 
     case "tech":
-        if (depath(val).slice(0,4) === "pair")
-            return loadTechnologyPair(val).techs;
-        return [ val ];
+        if (depath(value).slice(0,4) === "pair")
+            return { "generic": loadTechnologyPair(value).techs };
+        return { "generic": [ value ] };
 
     case "all":
-    case "any":
-        let t = [];
-        let c = [];
-        for (let nv of val)
-        {
-            for (let o in nv)
+    {
+        let civs = [];
+        let techs = [];
+        for (let subvalue of value)
+            for (let newOper in subvalue)
             {
-                let v = nv[o];
-                let r = calcReqs(o, v);
-                switch (o)
+                let newValue = subvalue[newOper];
+                let result = calcReqs(newOper, newValue)
+
+                switch (newOper)
                 {
                 case "civ":
+                    civs.push(Object.keys(result)[0]);
+                    break;
+
                 case "notciv":
-                    c.push(r);
+                    requirements[Object.keys(result)[0]] = false;
                     break;
 
                 case "tech":
-                    t = t.concat(r);
+                    techs = techs.concat(result.generic);
                     break;
 
                 case "any":
-                    c = c.concat(r[0]);
-                    t = t.concat(r[1]);
+                case "all":
+                {
+                    if (result.generic)
+                        techs = techs.concat(result.generic);
+                    else
+                        for (let civ in result)
+                            if (result[civ] === false)
+                                requirements[civ] = false;
+                            else if (newOper === "any")
+                                civs.push(civ);
+                            else
+                                warn("Incomprehensible technology requirements - "+operator +":"+uneval(value));
+                }
+                break;
+
+                }
+            }
+        if (!civs.length && techs.length)
+            requirements.generic = techs;
+        else
+            for (let civ of civs)
+                requirements[civ] = techs;
+    }
+    break;
+
+    case "any":
+    {
+        for (let subvalue of value)
+            for (let newOper in subvalue)
+            {
+                let newValue = subvalue[newOper];
+                let result = calcReqs(newOper, newValue)
+
+                switch (newOper)
+                {
+                case "civ":
+                    requirements[Object.keys(result)[0]] = [];
+                    break;
+
+                case "notciv":
+                    requirements[Object.keys(result)[0]] = false;
+                    break;
+
+                case "tech":
+                    if (!requirements.generic)
+                        requirements.generic = [];
+                    requirements.generic.push(result.generic);
                     break;
 
                 case "all":
-                    for (let ci in r[0])
-                        c[ci] = r[1];
-                    t = t;
+                    for (let civ in result)
+                        requirements[civ] = result[civ];
+                    break;
+
+                case "any":
+                    for (let civ in result)
+                    {
+                        if (!requirements[civ])
+                        {
+                            warn("Possible any/all req operator problem - "+operator +":"+uneval(value));
+                            requirements[civ] = [];
+                        }
+                        for (let val of result[civ])
+                            requirements.generic.push(val);
+                    }
+                    break;
                 }
             }
-        }
-        return [ c, t ];
+    }
+    break;
 
     default:
-        warn("Unknown reqs operator: "+op);
+        warn("Unknown requirement operator: "+operator);
     }
-    return val;
+
+    return requirements;
 }
 
 /**
@@ -364 +402 @@
         let reqPhasePos = phaseList.indexOf(reqPhase);
         let myPhasePos = phaseList.indexOf(myPhase);
 
-        if (phaseList.length === 0)
+        if (!phaseList.length)
             phaseList = [reqPhase, myPhase];
         else if (reqPhasePos < 0 && myPhasePos > -1)
             phaseList.splice(myPhasePos, 0, reqPhase);

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

@@ -188 +188 @@
         let newProdTech = {};
         for (let prod of structInfo.production.technology)
         {
-            let phase = "";
+            let phase = GetPhaseOfTechnology(prod);
 
-            if (depath(prod).slice(0,5) === "phase")
-            {
-                phase = g_ParsedData.phaseList.indexOf(g_ParsedData.phases[prod].actualPhase);
-                if (phase > 0)
-                    phase = g_ParsedData.phaseList[phase - 1];
-            }
-            else if (g_SelectedCiv in g_ParsedData.techs[prod].reqs)
-            {
-                for (let req of g_ParsedData.techs[prod].reqs[g_SelectedCiv])
-                    if (depath(req).slice(0,5) === "phase")
-                        phase = req;
-            }
-            else if ("generic" in g_ParsedData.techs[prod].reqs)
-            {
-                for (let req of g_ParsedData.techs[prod].reqs.generic)
-                    if (depath(req).slice(0,5) === "phase")
-                        phase = req;
-            }
+            if (phase === false)
+                continue;
 
-            if (depath(phase).slice(0,5) !== "phase" ||
-                g_ParsedData.phaseList.indexOf(phase) < structPhaseIdx)
+            if (g_ParsedData.phaseList.indexOf(phase) < structPhaseIdx)
             {
                 if (structInfo.phase !== false)
                     phase = structInfo.phase;
@@ -243 +226 @@
             }
             else if (unit.required !== undefined)
             {
-                if (g_ParsedData.phases[unit.required])
-                    phase = g_ParsedData.phases[unit.required].actualPhase;
-                else if (g_ParsedData.techs[unit.required])
-                {
-                    let reqs = g_ParsedData.techs[unit.required].reqs;
-                    if (reqs[g_SelectedCiv])
-                        phase = reqs[g_SelectedCiv][0];
-                    else if (reqs.generic)
-                        phase = reqs.generic[0];
-                    else
-                        warn("Empty requirements found on technology " + unit.required);
-                }
-                else
-                    warn("Technology " + unit.required + " for " + prod + " not found.");
+                phase = GetPhaseOfTechnology(unit.required);
+                if (phase === false)
+                    continue;
             }
 
             if (depath(phase).slice(0,5) !== "phase" || g_ParsedData.phaseList.indexOf(phase) < structPhaseIdx)