Ticket #3213: unitTrainingUnits.patch

gui/structree/draw.js

@@ -102 +102 @@
             hideRemaining("phase["+i+"]_struct["+s+"]_row[", r, "]");
             ++s;
         }
+        
+        for (let unit of g_CivData[g_SelectedCiv].trainList[pha])
+        {
+            let thisEle = Engine.GetGUIObjectByName("phase["+i+"]_struct["+s+"]");
+            if (thisEle === undefined)
+            {
+                error("\""+g_SelectedCiv+"\" has more structures + units in phase "+pha+" than can be supported by the current GUI layout");
+                break;
+            }
+
+            let c = 0;
+            let rowCounts = [];
+            unit = g_ParsedData.units[unit];
+            Engine.GetGUIObjectByName("phase["+i+"]_struct["+s+"]_icon").sprite = "stretched:session/portraits/"+unit.icon;
+            Engine.GetGUIObjectByName("phase["+i+"]_struct["+s+"]_icon").tooltip = assembleTooltip(unit);
+            Engine.GetGUIObjectByName("phase["+i+"]_struct["+s+"]_name").caption = translate(unit.name.specific);
+            thisEle.hidden = false;
+            
+            
+            for (let r in g_DrawLimits[pha].prodQuant)
+            {
+                let p = 0;
+                r = +r; // force int
+                let prod_pha = phaseList[phaseList.indexOf(pha) + r];
+                if (unit.trainer[prod_pha])
+                {
+                    for (let prod of unit.trainer[prod_pha])
+                    {
+                        prod = g_ParsedData.units[prod];
+                        if (!drawProdIcon(i, s, r, p, prod, "Blue"))
+                            break;
+                        p++;
+                    }
+                }
+                rowCounts[r] = p;
+                if (p>c)
+                    c = p;
+                hideRemaining("phase["+i+"]_struct["+s+"]_row["+r+"]_prod[", p, "]");
+            }
+
+            
+            let size = thisEle.size;
+            size.left = y;
+            size.right = size.left + ((c*24 < defWidth)?defWidth:c*24)+4;
+            y = size.right + defMargin;
+            thisEle.size = size;
+
+            let eleWidth = size.right - size.left;
+            let r;
+            for (r in rowCounts)
+            {
+                let wid = rowCounts[r] * 24 - 4;
+                let phaEle = Engine.GetGUIObjectByName("phase["+i+"]_struct["+s+"]_row["+r+"]");
+                size = phaEle.size;
+                size.left = (eleWidth - wid)/2;
+                phaEle.size = size;
+            }
+            ++r;
+            hideRemaining("phase["+i+"]_struct["+s+"]_row[", r, "]");
+            ++s;
+        }
+        
         hideRemaining("phase["+i+"]_struct[", s, "]");
         ++i;
     }

gui/structree/load.js

@@ -54 +54 @@
 
     unit.gather = getGatherRates(templateName);
 
+    if (template.ProductionQueue)
+    {
+        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) < 0)
+                g_Lists.units.push(build);
+        }
+    }
+
     if (template.Heal)
         unit.healer = {
             "Range": +template.Heal.Range || 0,

gui/structree/rows.xml

@@ -3 +3 @@
 <object name="phase_rows">
     <repeat count="4" var="k">
         <object name="phase[k]">
-            <repeat count="11" var="s">
+            <repeat count="12" var="s">
                 <object type="image" style="StructBox" name="phase[k]_struct[s]">
                     <object type="text" style="StructNameSpecific" name="phase[k]_struct[s]_name"/>
                     <object type="image" style="StructIcon" name="phase[k]_struct[s]_icon"

gui/structree/structree.js

@@ -236 +236 @@
             "units": newProdUnits
         };
     }
+    
+    // Group training lists of units by phase
+    for (let unitCode of g_Lists.units)
+    {
+        let unitInfo = g_ParsedData.units[unitCode];
+
+        if (!unitInfo || !unitInfo.trainer)
+            continue;
+
+        // Determine phase for units
+        let newTrainees = {};
+        for (let prod of unitInfo.trainer)
+        {
+            if (!(prod in g_ParsedData.units))
+            {
+                error(prod+" doesn't exist! ("+structCode+")");
+                continue;
+            }
+            let unit = g_ParsedData.units[prod];
+            let phase = "";
+
+            if (unit.phase !== false)
+                phase = unit.phase;
+            else if (unit.required !== undefined)
+            {
+                if (unit.required in g_ParsedData.phases)
+                    phase = g_ParsedData.phases[unit.required].actualPhase;
+                else
+                {
+                    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 (unitInfo.phase !== false)
+                phase = unitInfo.phase;
+            else
+                phase = g_ParsedData.phaseList[0];
+
+            if (!(phase in newTrainees))
+                newTrainees[phase] = [];
+
+            newTrainees[phase].push(prod);
+        }
+
+        g_ParsedData.units[unitCode].trainer = newTrainees;
+    }
 
     // Determine the buildList for the civ (grouped by phase)
     var buildList = {};
+    var trainerList = {};
     for (let pha of g_ParsedData.phaseList)
+    {
         buildList[pha] = [];
+        trainerList[pha] = [];
+    }
     for (let structCode of g_Lists.structures)
     {
         if (!g_ParsedData.structures[structCode].phase || startStructs.indexOf(structCode) > -1)
@@ -249 +302 @@
         let myPhase = g_ParsedData.structures[structCode].phase;
         buildList[myPhase].push(structCode);
     }
+    for (let unitCode of g_Lists.units)
+    {
+        if (!g_ParsedData.units[unitCode] || !g_ParsedData.units[unitCode].trainer)
+            continue;
+        
+        let myPhase = g_ParsedData.units[unitCode].phase;
+        if (g_ParsedData.phaseList.indexOf(myPhase) === -1)
+            myPhase = g_ParsedData.phases[myPhase].actualPhase;
+        
+        trainerList[myPhase].push(unitCode);
+    }
 
     g_CivData[g_SelectedCiv].buildList = buildList;
+    g_CivData[g_SelectedCiv].trainList = trainerList;
 
     // Draw tree
     draw();