Ticket #3401: structreePhasePairFix.patch

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

@@ -70 +70 @@
                 {
                     for (let prod of stru.production.technology[prod_pha])
                     {
-                        prod = (prod.slice(0,5) == "phase") ? g_ParsedData.phases[prod] : g_ParsedData.techs[prod];
+                        prod = (depath(prod).slice(0,5) == "phase") ? g_ParsedData.phases[prod] : g_ParsedData.techs[prod];
                         if (!drawProdIcon(i, s, r, p, prod))
                             break;
                         p++;

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

@@ -46 +46 @@
 
     if (unit.requiredTechnology)
     {
-        if (unit.requiredTechnology.slice(0, 5) == "phase")
+        if (depath(unit.requiredTechnology).slice(0, 5) == "phase")
             unit.phase = unit.requiredTechnology;
         else if (unit.requiredTechnology.length)
             unit.required = unit.requiredTechnology;
@@ -80 +80 @@
 
     if (structure.requiredTechnology)
     {
-        if (structure.requiredTechnology.slice(0, 5) == "phase")
+        if (depath(structure.requiredTechnology).slice(0, 5) == "phase")
             structure.phase = structure.requiredTechnology;
         else if (structure.requiredTechnology.length)
             structure.required = structure.requiredTechnology;

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

@@ -12 +12 @@
 /**
  * Initialize the dropdown containing all the available civs
  */
-function init(data)
+function init(data = {})
 {
     g_CivData = loadCivData(true);
 
@@ -94 +94 @@
     {
         let realcode = depath(techcode);
 
-        if (realcode.slice(0,4) == "pair")
+        if (realcode.slice(0,4) == "pair" || realcode.indexOf("_pair") > -1)
             techPairs[techcode] = loadTechnologyPair(techcode);
         else if (realcode.slice(0,5) == "phase")
             g_ParsedData.phases[techcode] = loadPhase(techcode);
@@ -108 +108 @@
         let pair = techPairs[paircode];
         for (let techcode of pair.techs)
         {
-            let newTech = loadTechnology(techcode);
-
-            if (pair.req !== "")
+            if (depath(techcode).slice(0, 5) === "phase")
+                g_ParsedData.phases[techcode] = loadPhase(techcode);
+            else
             {
-                if ("generic" in newTech.reqs)
-                    newTech.reqs.generic.concat(techPairs[pair.req].techs);
-                else
-                    for (let civkey of Object.keys(newTech.reqs))
-                        newTech.reqs[civkey].concat(techPairs[pair.req].techs);
+                let newTech = loadTechnology(techcode);
+                if (pair.req !== "")
+                {
+                    if ("generic" in newTech.reqs)
+                        newTech.reqs.generic.concat(techPairs[pair.req].techs);
+                    else
+                        for (let civkey of Object.keys(newTech.reqs))
+                            newTech.reqs[civkey].concat(techPairs[pair.req].techs);
+                }
+                g_ParsedData.techs[techcode] = newTech;
             }
-            g_ParsedData.techs[techcode] = newTech;
         }
     }
 
     // Establish phase order
     g_ParsedData.phaseList = unravelPhases(g_ParsedData.techs);
     for (let phasecode of g_ParsedData.phaseList)
+    {
+        let phaseInfo = loadTechData(phasecode);
         g_ParsedData.phases[phasecode] = loadPhase(phasecode);
 
+        if ("requirements" in phaseInfo)
+            for (let op in phaseInfo.requirements)
+            {
+                let val = phaseInfo.requirements[op];
+                if (op == "any")
+                    for (let v of val)
+                    {
+                        let k = Object.keys(v);
+                        k = k[0];
+                        v = v[k];
+                        if (k == "tech")
+                            if (v in g_ParsedData.phases)
+                                g_ParsedData.phases[v].actualPhase = phasecode;
+                            else if (v in techPairs)
+                                for (let t of techPairs[v].techs)
+                                    g_ParsedData.phases[t].actualPhase = phasecode;
+                    }
+            }
+    }
+
     // Group production lists of structures by phase
     for (let structCode of g_Lists.structures)
     {
@@ -151 +177 @@
         {
             let phase = "";
 
-            if (prod.slice(0,5) === "phase")
+            if (depath(prod).slice(0,5) === "phase")
             {
                 phase = g_ParsedData.phaseList.indexOf(g_ParsedData.phases[prod].actualPhase);
                 if (phase > 0)
@@ -193 +219 @@
             let phase = "";
 
             if (unit.phase !== false)
-                phase = unit.phase;
+                if (g_ParsedData.phaseList.indexOf(unit.phase) < 0)
+                    phase = g_ParsedData.phases[unit.phase].actualPhase;
+                else
+                    phase = unit.phase;
             else if (unit.required !== undefined)
             {
-                let reqs = g_ParsedData.techs[unit.required].reqs;
-                if (g_SelectedCiv in reqs)
-                    phase = reqs[g_SelectedCiv][0];
+                if (unit.required in g_ParsedData.phases)
+                    phase = g_ParsedData.phases[unit.required].actualPhase;
                 else
-                    phase = reqs.generic[0];
+                {
+                    let reqs = g_ParsedData.techs[unit.required].reqs;
+                    if (g_SelectedCiv in reqs)
+                        phase = reqs[g_SelectedCiv][0];
+                    else
+                        phase = reqs.generic[0];
+                }
             }
             else if (structInfo.phase !== false)
                 phase = structInfo.phase;
@@ -229 +263 @@
             g_ParsedData.structures[structCode].phase = g_ParsedData.phaseList[0];
 
         let myPhase = g_ParsedData.structures[structCode].phase;
+        if (g_ParsedData.phaseList.indexOf(myPhase) === -1)
+            myPhase = g_ParsedData.phases[myPhase].actualPhase;
+        
         buildList[myPhase].push(structCode);
     }