Ticket #3993: notciv_v5-1.patch

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

@@ -50 +50 @@
 {
     return MatchesClassList(classes, modification.affects);
 }
+
+
+/**
+ * Fetch the civ-specific technology requirements of a technology
+ *
+ * @param {object} techReqs - The technology requirements, derived from
+ *                            InterpretTechRequirements
+ * @param {string} civ - The civ
+ *
+ * @return An object containing the requirements specific to this civ
+ *         for this technology or false if the civ cannot research this
+ *         technology
+ */
+function GetCivSpecificReqsOfTech(techReqs, civ)
+{
+    if (civ in techReqs)
+    {
+        if (techReqs[civ] === false)
+            return false;
+        return techReqs[civ] || {};
+    }
+
+    if (techReqs.generic)
+        return techReqs.generic || {};
+
+    return !Object.keys(techReqs).length;
+}
+
+/**
+ * Derives the technology requirements from a given technology template.
+ * Takes into account the `supersedes` attribute.
+ * 
+ * @param {object} template - The template object. Loading of the template must have already occured.
+ * 
+ * @return Derived technology requirements. See `InterpretTechRequirements` for object's syntax.
+ */
+function DeriveTechnologyRequirements(template)
+{
+    let requirements = {}
+
+    if (template.requirements)
+    {
+        let op = Object.keys(template.requirements)[0];
+        let val = template.requirements[op];
+        requirements = InterpretTechRequirements(op, val);
+    }
+
+    if (template.supersedes)
+    {
+        if (requirements.generic)
+        {
+            if (!requirements.generic.techs)
+                requirements.generic.techs = [];
+            requirements.generic.techs.push(template.supersedes);
+        }
+        else if (!Object.keys(requirements).length)
+            requirements.generic = { "techs": [template.supersedes] };
+        else
+            for (let ck in requirements)
+                if (requirements[ck])
+                {
+                    if (!requirements[ck].techs)
+                        requirements[ck].techs = [];
+                    requirements[ck].techs.push(template.supersedes);
+                }
+    }
+
+    return requirements;
+}
+
+/**
+ * Interprets the prerequisite requirements of a technology.
+ *
+ * Takes the initial { key: value } from the short-form requirements object in entity templates,
+ * and parses it into an object that can be more easily checked by simulation and gui.
+ *
+ * Works recursively if needed.
+ * 
+ * The returned object is in the form:
+ * ```
+ *  {
+ *      "civA": {
+ *          "techs": ["tech1"]
+ *      },
+ *      "civB": {
+ *          "entities": [{
+ *              "class": "human",
+ *              "number": 2,
+ *              "variant": "count"
+ *          }]
+ *      },
+ *      "civC": false,
+ *      "generic": {
+ *          "techs": ["tech2"]
+ *      }
+ *  }
+ * ```
+ * (Or, to translate:
+ * - `civA` needs `tech1`
+ * - `civB` needs 2 entities with the `human` class
+ * - `civC` cannot research this tech at all
+ * - and everyone else needs `tech2`)
+ *
+ * @param {string} operator - The base operation. Can be "civ", "notciv", "tech", "entity", "all" or "any".
+ * @param {mixed} value - The value associated with the above operation.
+ *
+ * @return Object containing the requirements, sorted.
+ */
+function InterpretTechRequirements(operator, value)
+{
+    let requirements = {};
+
+    switch (operator)
+    {
+    case "civ":
+        requirements[value] = {};
+        break;
+
+    case "notciv":
+        requirements[value] = false;
+        requirements.generic = {};
+        break;
+
+    case "class":
+    case "number":
+    case "numberOfTypes":
+        // do nothing
+        break;
+
+    case "entity":
+        requirements.generic = { "entities": [{
+            "class": value.class,
+            "number": value.number || value.numberOfTypes,
+            "check": value.number ? "count" : "variants"
+        }]};
+        break;
+
+    case "tech":
+        requirements.generic = { "techs": [value] };
+        break;
+
+    case "all":
+    {
+        let civs = [];
+        let techs = [];
+        let entities = [];
+        for (let subvalue of value)
+            for (let newOper in subvalue)
+            {
+                let newValue = subvalue[newOper];
+                let result = InterpretTechRequirements(newOper, newValue)
+
+                switch (newOper)
+                {
+                case "civ":
+                    civs.push(Object.keys(result)[0]);
+                    break;
+
+                case "notciv":
+                    for (let civ in result)
+                        requirements[civ] = result[civ];
+                    break;
+
+                case "tech":
+                    techs = techs.concat(result.generic.techs);
+                    break;
+
+                case "entity":
+                    entities = entities.concat(result.generic.entities);
+                    break;
+
+                case "any":
+                case "all":
+                {
+                    for (let civ in result)
+                        if (result[civ] === false)
+                            requirements[civ] = false;
+                        else if (newOper === "any")
+                            civs.push(civ);
+                }
+                break;
+
+                }
+            }
+        if (!civs.length && (techs.length || entities.length))
+        {
+            requirements.generic = {};
+            if (techs.length)
+                requirements.generic.techs = techs;
+            if (entities.length)
+                requirements.generic.entities = entities;
+        }
+        else
+            for (let civ of civs)
+            {
+                requirements[civ] = {};
+                if (techs.length)
+                    requirements[civ].techs = techs;
+                if (entities.length)
+                    requirements[civ].entities = entities;
+            }
+    }
+    break;
+
+    case "any":
+    {
+        for (let subvalue of value)
+            for (let newOper in subvalue)
+            {
+                let newValue = subvalue[newOper];
+                let result = InterpretTechRequirements(newOper, newValue)
+
+                switch (newOper)
+                {
+                case "civ":
+                case "notciv":
+                    for (let civ in result)
+                        requirements[civ] = result[civ];
+                    break;
+
+                case "tech":
+                    if (!requirements.generic)
+                        requirements.generic = { "techs": [] };
+                    requirements.generic.techs.push(result.generic.techs);
+                    break;
+
+                case "entity":
+                    if (!requirements.generic)
+                        requirements.generic = { "entities": [] };
+                    requirements.generic.entities.push(result.generic.entities);
+                    break;
+
+                case "all":
+                    for (let civ in result)
+                    {
+                        requirements[civ] = {};
+                        if (result[civ].techs)
+                            requirements[civ].techs = result[civ].techs;
+                        if (result[civ].entities)
+                            requirements[civ].entities = result[civ].entities;
+                    }
+                    break;
+
+                case "any":
+                    for (let civ in result)
+                    {
+                        if (!requirements[civ])
+                        {
+                            warn("Possible any/all req operator problem - "+operator +":"+uneval(value));
+                            requirements[civ] = {};
+                        }
+                        if (result[civ].techs)
+                            for (let val of result[civ].techs)
+                                requirements.generic.techs.push(val);
+                        if (result[civ].entities)
+                            for (let val of result[civ].entities)
+                                requirements.generic.entities.push(val);
+                    }
+                    break;
+                }
+            }
+    }
+    break;
+
+    default:
+        warn("Unknown requirement operator: "+operator);
+    }
+
+    return requirements;
+}

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

@@ -371 +371 @@
     ret.tooltip = template.tooltip;
     ret.requirementsTooltip = template.requirementsTooltip || "";
 
-    if (template.requirements && template.requirements.class)
-        ret.classRequirements = {
-            "class": template.requirements.class,
-            "number": template.requirements.number
-        };
+    ret.reqs = DeriveTechnologyRequirements(template);
 
     ret.description = template.description;
 

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

@@ -34 +34 @@
     }
     return result;
 }
+
+/**
+ * Removes prefixing path from a path or filename, leaving just the file's name (with extension)
+ * 
+ * ie. a/b/c/file.ext -> file.ext
+ */
+function depath(path)
+{
+    return path.slice(path.lastIndexOf("/") + 1);
+}

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

@@ -731 +731 @@
         setPanelObjectPosition(pair, data.i, data.rowLength);
 
         // Handle one or two techs
+        let player = data.unitEntState.player;
         for (let i in techs)
         {
             let tech = techs[i];
@@ -743 +744 @@
 
             let neededResources = Engine.GuiInterfaceCall("GetNeededResources", {
                 "cost": template.cost,
-                "player": data.unitEntState.player
+                "player": player
             });
 
             let requirementsPassed = Engine.GuiInterfaceCall("CheckTechnologyRequirements", {
                 "tech": tech,
-                "player": data.unitEntState.player
+                "player": player
             });
 
             let button = Engine.GetGUIObjectByName("unitResearchButton[" + position + "]");
@@ -763 +764 @@
             if (!requirementsPassed)
             {
                 let tip = template.requirementsTooltip;
-                if (template.classRequirements)
+                let reqs = GetCivSpecificReqsOfTech(template.reqs, GetSimState().players[player].civ);
+                if (reqs.entities)
                 {
-                    let player = data.unitEntState.player;
-                    let current = GetSimState().players[player].classCounts[template.classRequirements.class] || 0;
-                    let remaining = template.classRequirements.number - current;
-                    tip += " " + sprintf(translatePlural("Remaining: %(number)s to build.", "Remaining: %(number)s to build.", remaining), {
-                        "number": remaining
+                    let entityCounts = [];
+                    for (let entity of reqs.entities)
+                    {
+                        let current = 0;
+                        switch (entity.check)
+                        {
+                        case "count":
+                            current = GetSimState().players[player].classCounts[entity.class] || 0;
+                            break;
+
+                        case "variants":
+                            current = GetSimState().players[player].typeCountsByClass[entity.class] ? Object.keys(GetSimState().players[player].typeCountsByClass[entity.class]).length : 0;
+                            break;
+                        }
+
+                        let remaining = entity.number - current;
+                        if (remaining < 1)
+                            continue;
+
+                        entityCounts.push(sprintf(translatePlural("%(number)s entity of class %(class)s", "%(number)s entities of class %(class)s", remaining), {
+                            "number": remaining,
+                            "class": entity.class
+                        }));
+                    }
+                    tip += " " + sprintf(translate("Remaining: %(entityCounts)s"), {
+                        "entityCounts": entityCounts.join(translate(", "))
                     });
                 }
                 tooltips.push(tip);

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

@@ -92 +92 @@
     return val._string.split(" ");
 }
 
-function depath(path)
-{
-    return path.slice(path.lastIndexOf("/") + 1);
-}
-
 /**
  * This is needed because getEntityCostTooltip in tooltip.js needs to get
  * the template data of the different wallSet pieces. In the session this
@@ -107 +102 @@
     var template = loadTemplate(templateName);
     return GetTemplateDataHelper(template, null, g_AuraData);
 }
+
+/**
+ * Determines and returns the phase in which a given technology can be
+ * first researched. 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(GetActualPhase(techName));
+        if (phaseIdx > 0)
+            return g_ParsedData.phaseList[phaseIdx - 1];
+    }
+
+    let techReqs = GetCivSpecificReqsOfTech(g_ParsedData.techs[techName].reqs, g_SelectedCiv);
+    if (!techReqs)
+        return false;
+
+    for (let req of techReqs.techs)
+    {
+        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;
+}
+
+function GetActualPhase(phaseName)
+{
+    if (g_ParsedData.phases[phaseName])
+        return g_ParsedData.phases[phaseName].actualPhase;
+
+    warn("Unrecognised phase (" + techName + ")");
+    return g_ParsedData.phaseList[0];
+}
+
+function GetPhaseOfTemplate(template)
+{
+    if (!template.requiredTechnology)
+        return g_ParsedData.phaseList[0];
+
+    if (depath(template.requiredTechnology).slice(0, 5) == "phase")
+        return GetActualPhase(template.requiredTechnology);
+
+    return GetPhaseOfTechnology(template.requiredTechnology);
+}

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

@@ -39 +39 @@
 {
     if (!Engine.TemplateExists(templateName))
         return null;
-    var template = loadTemplate(templateName);
-
-    var unit = GetTemplateDataHelper(template, null, g_AuraData);
-    unit.phase = false;
-
-    if (unit.requiredTechnology)
-    {
-        if (depath(unit.requiredTechnology).slice(0, 5) == "phase")
-            unit.phase = unit.requiredTechnology;
-        else if (unit.requiredTechnology.length)
-            unit.required = unit.requiredTechnology;
-    }
+    let template = loadTemplate(templateName);
+    let unit = GetTemplateDataHelper(template, null, g_AuraData);
 
     unit.gather = getGatherRates(templateName);
 
@@ -93 +83 @@
 
 function loadStructure(templateName)
 {
-    var template = loadTemplate(templateName);
-    var structure = GetTemplateDataHelper(template, null, g_AuraData);
-    structure.phase = false;
-
-    if (structure.requiredTechnology)
-    {
-        if (depath(structure.requiredTechnology).slice(0, 5) == "phase")
-            structure.phase = structure.requiredTechnology;
-        else if (structure.requiredTechnology.length)
-            structure.required = structure.requiredTechnology;
-    }
+    let template = loadTemplate(templateName);
+    let structure = GetTemplateDataHelper(template, null, g_AuraData);
 
     structure.production = {
         "technology": [],
@@ -179 +160 @@
 
 function loadTechnology(techName)
 {
-    var template = loadTechData(techName);
-    var tech = GetTechnologyDataHelper(template, g_SelectedCiv);
-    tech.reqs = {};
+    let template = loadTechData(techName);
+    let tech = GetTechnologyDataHelper(template, g_SelectedCiv);
 
     if (template.pair !== undefined)
         tech.pair = template.pair;
 
-    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;
-            }
-        }
-    }
-
-    if (template.supersedes !== undefined)
-    {
-        if (tech.reqs.generic !== undefined)
-            tech.reqs.generic.push(template.supersedes);
-        else
-            for (let ck of Object.keys(tech.reqs))
-                tech.reqs[ck].push(template.supersedes);
-    }
-
     return tech;
 }
 
@@ -258 +187 @@
 
     return {
         "techs": [ pairInfo.top, pairInfo.bottom ],
-        "req": pairInfo.supersedes || ""
+        "reqs": DeriveTechnologyRequirements(pairInfo)
     };
 }
 
 /**
- * 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.
- *
- * @return Sorted requirments.
- */
-function calcReqs(op, val)
-{
-    switch (op)
-    {
-    case "civ":
-    case "class":
-    case "notciv":
-    case "number":
-        // nothing needs doing
-        break;
-
-    case "tech":
-        if (depath(val).slice(0,4) === "pair")
-            return loadTechnologyPair(val).techs;
-        return [ val ];
-
-    case "all":
-    case "any":
-        let t = [];
-        let c = [];
-        for (let nv of val)
-        {
-            for (let o in nv)
-            {
-                let v = nv[o];
-                let r = calcReqs(o, v);
-                switch (o)
-                {
-                case "civ":
-                case "notciv":
-                    c.push(r);
-                    break;
-
-                case "tech":
-                    t = t.concat(r);
-                    break;
-
-                case "any":
-                    c = c.concat(r[0]);
-                    t = t.concat(r[1]);
-                    break;
-
-                case "all":
-                    for (let ci in r[0])
-                        c[ci] = r[1];
-                    t = t;
-                }
-            }
-        }
-        return [ c, t ];
-
-    default:
-        warn("Unknown reqs operator: "+op);
-    }
-    return val;
-}
-
-/**
  * Unravel phases
  *
  * @param techs The current available store of techs
@@ -343 +206 @@
     {
         let techdata = techs[techcode];
 
-        if (!("generic" in techdata.reqs) || techdata.reqs.generic.length < 2)
+        if (!techdata.reqs.generic || !techdata.reqs.generic.techs || techdata.reqs.generic.techs.length < 2)
             continue;
 
-        let reqTech = techs[techcode].reqs.generic[1];
+        let reqTech = techs[techcode].reqs.generic.techs[1];
 
         // Tech that can't be researched anywhere
         if (!(reqTech in techs))
@@ -355 +218 @@
         if (!("generic" in techs[reqTech].reqs))
             continue;
 
-        let reqPhase = techs[reqTech].reqs.generic[0];
-        let myPhase = techs[techcode].reqs.generic[0];
+        let reqPhase = techs[reqTech].reqs.generic.techs[0];
+        let myPhase = techs[techcode].reqs.generic.techs[0];
 
         if (reqPhase == myPhase || depath(reqPhase).slice(0,5) !== "phase" || depath(myPhase).slice(0,5) !== "phase")
             continue;
@@ -364 +227 @@
         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

@@ -62 +62 @@
     };
 
     // get initial units
-    var startStructs = [];
     for (let entity of g_CivData[civCode].StartEntities)
     {
         if (entity.Template.slice(0, 5) == "units")
             g_Lists.units.push(entity.Template);
         else if (entity.Template.slice(0, 6) == "struct")
-        {
             g_Lists.structures.push(entity.Template);
-            startStructs.push(entity.Template);
-        }
     }
 
     // Load units and structures
@@ -115 +111 @@
             else
             {
                 let newTech = loadTechnology(techcode);
-                if (pair.req !== "")
+                for (let civ in pair.reqs)
                 {
-                    if ("generic" in newTech.reqs)
-                        newTech.reqs.generic.concat(techPairs[pair.req].techs);
-                    else
+                    if (!newTech.reqs[civ])
+                        newTech.reqs[civ] = {};
+                    else if (newTech.reqs[civ] === false)
+                        continue;
+
+                    if (pair.reqs[civ] === false)
                     {
-                        for (let civkey of Object.keys(newTech.reqs))
-                            newTech.reqs[civkey].concat(techPairs[pair.req].techs);
+                        newTech.reqs[civ] = false;
+                        continue;
                     }
+
+                    for (let type in pair.reqs[civ])
+                        if (pair.reqs[civ][type])
+                            newTech.reqs[civ][type].concat(pair.reqs[civ][type])
                 }
                 g_ParsedData.techs[techcode] = newTech;
             }
@@ -169 +172 @@
     for (let structCode of g_Lists.structures)
     {
         let structInfo = g_ParsedData.structures[structCode];
+        structInfo.phase = GetPhaseOfTemplate(structInfo);
         let structPhaseIdx = g_ParsedData.phaseList.indexOf(structInfo.phase);
 
         // If this building is shared with another civ,
@@ -180 +184 @@
         for (let prod of structInfo.production.technology)
             if (prod in techPairs)
                 structInfo.production.technology.splice(
-                    structInfo.production.technology.indexOf(prod), 1,
-                    techPairs[prod].techs[0], techPairs[prod].techs[1]
+                    structInfo.production.technology.indexOf(prod),
+                    1, ...techPairs[prod].techs
                 );
 
         // Sort techs by phase
         let newProdTech = {};
         for (let prod of structInfo.production.technology)
         {
-            let phase = "";
-
-            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;
-            }
+            let phase = GetPhaseOfTechnology(prod);
+            if (phase === false)
+                continue;
 
-            if (depath(phase).slice(0,5) !== "phase" ||
-                g_ParsedData.phaseList.indexOf(phase) < structPhaseIdx)
-            {
-                if (structInfo.phase !== false)
-                    phase = structInfo.phase;
-                else
-                    phase = g_ParsedData.phaseList[0];
-            }
+            if (g_ParsedData.phaseList.indexOf(phase) < structPhaseIdx)
+                phase = structInfo.phase;
 
             if (!(phase in newProdTech))
                 newProdTech[phase] = [];
@@ -224 +205 @@
             newProdTech[phase].push(prod);
         }
 
-        // Determine phase for units
+        // Sort units by phase
         let newProdUnits = {};
         for (let prod of structInfo.production.units)
         {
             if (!g_ParsedData.units[prod])
                 continue;
 
-            let unit = g_ParsedData.units[prod];
-            let phase = "";
-
-            if (unit.phase !== false)
-            {
-                if (g_ParsedData.phaseList.indexOf(unit.phase) < 0)
-                    phase = g_ParsedData.phases[unit.phase].actualPhase;
-                else
-                    phase = unit.phase;
-            }
-            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.");
-            }
+            let phase = GetPhaseOfTemplate(g_ParsedData.units[prod]);
+            if (phase === false)
+                continue;
 
-            if (depath(phase).slice(0,5) !== "phase" || g_ParsedData.phaseList.indexOf(phase) < structPhaseIdx)
-                if (structInfo.phase !== false)
-                    phase = structInfo.phase;
-                else
-                    phase = g_ParsedData.phaseList[0];
+            if (g_ParsedData.phaseList.indexOf(phase) < structPhaseIdx)
+                phase = structInfo.phase;
 
             if (!(phase in newProdUnits))
                 newProdUnits[phase] = [];
@@ -278 +232 @@
     }
 
     // Determine the buildList for the civ (grouped by phase)
-    var buildList = {};
-    var trainerList = [];
+    let buildList = {};
+    let trainerList = [];
     for (let pha of g_ParsedData.phaseList)
         buildList[pha] = [];
     for (let structCode of g_Lists.structures)
     {
-        if (!g_ParsedData.structures[structCode].phase || startStructs.indexOf(structCode) > -1)
-            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);
+        let phase = g_ParsedData.structures[structCode].phase;
+        buildList[phase].push(structCode);
     }
     for (let unitCode of g_Lists.units)
         if (g_ParsedData.units[unitCode] && g_ParsedData.units[unitCode].production)

binaries/data/mods/public/simulation/ai/common-api/gamestate.js

@@ -199 +199 @@
 
     if (noRequirementCheck === true)
         return true;
-    
-    // not already researched, check if we can.
-    // basically a copy of the function in technologyManager since we can't use it.
-    // Checks the requirements for a technology to see if it can be researched at the current time
-        
-    // The technology which this technology supersedes is required
-    if (template.supersedes() && !this.playerData.researchedTechs[template.supersedes()])
-        return false;
 
     // if this is a pair, we must check that the pair tech is not being researched
     if (template.pair())
@@ -222 +214 @@
 };
 
 /**
- * Private function for checking a set of requirements is met
- * basically copies TechnologyManager
+ * Private function for checking a set of requirements is met.
+ * Basically copies TechnologyManager, but compares against
+ * variables only available within the AI
  */
 m.GameState.prototype.checkTechRequirements = function(reqs)
 {
-    // If there are no requirements then all requirements are met
+    reqs = GetCivSpecificReqsOfTech(reqs, this.playerData.civ);
+
     if (!reqs)
-        return true;
-    
-    if (reqs.all)
-        return reqs.all.every(r => this.checkTechRequirements(r));
-    if (reqs.any)
-        return reqs.any.some(r => this.checkTechRequirements(r));
-    if (reqs.civ)
-        return this.playerData.civ == reqs.civ;
-    if (reqs.notciv)
-        return this.playerData.civ != reqs.notciv;
-    if (reqs.tech)
-        return this.playerData.researchedTechs[reqs.tech] !== undefined && this.playerData.researchedTechs[reqs.tech];
-    if (reqs.class && reqs.numberOfTypes)
-        return this.playerData.typeCountsByClass[reqs.class] && 
-            Object.keys(this.playerData.typeCountsByClass[reqs.class]).length >= reqs.numberOfTypes;
-    if (reqs.class && reqs.number)
-        return this.playerData.classCounts[reqs.class] &&
-            this.playerData.classCounts[reqs.class] >= reqs.number;
-    
-    // The technologies requirements are not a recognised format
-    error("Bad requirements " + uneval(reqs));
-    return false;
+        return false;
+
+    if (reqs.techs)
+        for (let prerequisite of reqs.techs)
+            if (!this.playerData.researchedTechs[prerequisite])
+                return false;
+
+    if (reqs.entities)
+        for (let entity of reqs.entities)
+        {
+            switch (entity.check)
+            {
+            case "count":
+                if (!this.playerData.classCounts[entity.class] || this.playerData.classCounts[entity.class] < entity.number)
+                    return false;
+                break;
+
+            case "variants":
+                if (!this.playerData.typeCountsByClass[entity.class] || Object.keys(this.playerData.typeCountsByClass[entity.class]).length < entity.number)
+                    return false;
+                break;
+            }
+        }
+
+    return true;
 };
 
 m.GameState.prototype.getMap = function()

binaries/data/mods/public/simulation/ai/common-api/technology.js

@@ -99 +99 @@
 
 m.Technology.prototype.requirements = function()
 {
-    if (!this._template.requirements)
-        return undefined;
-    return this._template.requirements;
+    return DeriveTechnologyRequirements(this._template);
 };
 
 m.Technology.prototype.autoResearch = function()

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

@@ -168 +168 @@
 
     // Remove any technologies that can't be researched by this civ
     techs = techs.filter(tech => {
-        let reqs = cmpTechnologyManager.GetTechnologyTemplate(tech).requirements || null;
+        let reqs = DeriveTechnologyRequirements(cmpTechnologyManager.GetTechnologyTemplate(tech));
         return cmpTechnologyManager.CheckTechnologyRequirements(reqs, true);
     });
 

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

@@ -97 +97 @@
 // Checks the requirements for a technology to see if it can be researched at the current time
 TechnologyManager.prototype.CanResearch = function(tech)
 {
-    var template = this.GetTechnologyTemplate(tech);
+    let template = this.GetTechnologyTemplate(tech);
+
     if (!template)
     {
         warn("Technology \"" + tech + "\" does not exist");
         return false;
     }
 
-    // The technology which this technology supersedes is required
-    if (template.supersedes && !this.IsTechnologyResearched(template.supersedes))
-        return false;
-
     if (template.top && this.IsInProgress(template.top) ||
         template.bottom && this.IsInProgress(template.bottom))
         return false;
@@ -121 +118 @@
     if (this.IsTechnologyResearched(tech))
         return false;
 
-    return this.CheckTechnologyRequirements(template.requirements || null);
+    return this.CheckTechnologyRequirements(DeriveTechnologyRequirements(template));
 };
 
 /**
  * Private function for checking a set of requirements is met
- * @param reqs Object of technology requirements as given by the technology template
- * @param civonly A boolean set to true if only the civ requirement is checked
+ * @param {object} reqs - Technology requirements as derived from the technology template by globalscripts
+ * @param {boolean} civonly - True if only the civ requirement is to be checked
  *
- * @return true if the requirements are checked
- * false otherwise
+ * @return true if the requirements pass, false otherwise
  */
-TechnologyManager.prototype.CheckTechnologyRequirements = function(reqs, civonly)
+TechnologyManager.prototype.CheckTechnologyRequirements = function(reqs, civonly = false)
 {
-    // If there are no requirements then all requirements are met
+    let cmpPlayer = Engine.QueryInterface(this.entity, IID_Player);
+    reqs = GetCivSpecificReqsOfTech(reqs, cmpPlayer.GetCiv());
+
     if (!reqs)
-        return true;
+        return false;
 
-    if (reqs.all)
-        return reqs.all.every(r => this.CheckTechnologyRequirements(r, civonly));
-    if (reqs.any)
-        return reqs.any.some(r => this.CheckTechnologyRequirements(r, civonly));
-    if (reqs.civ)
-    {
-        let cmpPlayer = Engine.QueryInterface(this.entity, IID_Player);
-        return cmpPlayer && cmpPlayer.GetCiv() == reqs.civ;
-    }
-    if (reqs.notciv)
-    {
-        let cmpPlayer = Engine.QueryInterface(this.entity, IID_Player);
-        return cmpPlayer && cmpPlayer.GetCiv() != reqs.notciv;
-    }
     if (civonly)
         return true;
-    if (reqs.tech)
-        return this.IsTechnologyResearched(reqs.tech);
-    if (reqs.class && reqs.numberOfTypes)
-        return this.typeCountsByClass[reqs.class] &&
-            Object.keys(this.typeCountsByClass[reqs.class]).length >= reqs.numberOfTypes;
-    if (reqs.class && reqs.number)
-        return this.classCounts[reqs.class] &&
-            this.classCounts[reqs.class] >= reqs.number;
-    // The technologies requirements are not a recognised format
-    error("Bad requirements " + uneval(reqs));
-    return false;
-};
+
+    if (reqs.techs)
+        for (let prerequisite of reqs.techs)
+            if (!this.IsTechnologyResearched(prerequisite))
+                return false;
+
+    if (reqs.entities)
+        for (let entity of reqs.entities)
+        {
+            switch (entity.check)
+            {
+            case "count":
+                if (!this.classCounts[entity.class] || this.classCounts[entity.class] < entity.number)
+                    return false;
+                break;
+
+            case "variants":
+                if (!this.typeCountsByClass[entity.class] || Object.keys(this.typeCountsByClass[entity.class]).length < entity.number)
+                    return false;
+                break;
+            }
+        }
+
+    return true;
+}
 
 TechnologyManager.prototype.OnGlobalOwnershipChanged = function(msg)
 {

binaries/data/mods/public/simulation/data/technologies/phase_city.json

@@ -6 +6 @@
     },
     "description": "Advances from a bustling town to a veritable metropolis, full of the wonders of modern technology.",
     "cost": { "food": 0, "wood": 0, "stone": 750, "metal": 750 },
-    "requirements": { "all": [{ "class": "Town", "number": 4 }, { "notciv": "athen" }] },
+    "requirements": { "all": [{ "entity": { "class": "Town", "number": 4 } }, { "notciv": "athen" }] },
     "requirementsTooltip": "Requires 4 new Town Phase structures (except Walls and Civic Centers).",
     "supersedes": "phase_town",
     "icon": "city_phase.png",

binaries/data/mods/public/simulation/data/technologies/phase_city_athen.json

@@ -5 +5 @@
     },
     "description": "Advances from a bustling town to a veritable metropolis, full of the wonders of modern technology. This is the Athenian city phase, where metal gathering rates are boosted because of the 'Silver Owls' bonus.",
     "cost": { "food": 0, "wood": 0, "stone": 750, "metal": 750 },
-    "requirements": { "all": [{ "class": "Town", "number": 4 }, { "civ": "athen" }] },
+    "requirements": { "all": [{ "entity": { "class": "Town", "number": 4 } }, { "civ": "athen" }] },
     "requirementsTooltip": "Requires 4 new Town Phase structures (except Walls and Civic Centers).",
     "supersedes": "phase_town_athen",
     "replaces": ["phase_city"],

binaries/data/mods/public/simulation/data/technologies/phase_town.json

@@ -6 +6 @@
     },
     "description": "Advances from a small village to a bustling town, ready to expand rapidly.",
     "cost": { "food": 500, "wood": 500, "stone": 0, "metal": 0 },
-    "requirements": { "all": [{ "class": "Village", "number": 5 }, { "notciv": "athen" }] },
+    "requirements": { "all": [{ "entity": { "class": "Village", "number": 5 } }, { "notciv": "athen" }] },
     "requirementsTooltip": "Requires 5 Village Phase structures (except Palisades and Farm Fields).",
     "supersedes": "phase_village",
     "icon": "town_phase.png",

binaries/data/mods/public/simulation/data/technologies/phase_town_athen.json

@@ -5 +5 @@
     },
     "description": "Advances from a small village to a bustling town, ready to expand rapidly. This is the Athenian town phase, where metal gathering rates are boosted because of the 'Silver Owls' bonus.",
     "cost": { "food": 500, "wood": 500, "stone": 0, "metal": 0 },
-    "requirements": { "all": [{ "class": "Village", "number": 5 }, { "civ": "athen" }] },
+    "requirements": { "all": [{ "entity": { "class": "Village", "number": 5 } }, { "civ": "athen" }] },
     "requirementsTooltip": "Requires 5 Village Phase structures (except Palisades and Farm Fields).",
     "supersedes": "phase_village",
     "replaces": ["phase_town"],

binaries/data/mods/public/simulation/data/technologies/unlock_shared_dropsites.json

@@ -2 +2 @@
     "genericName": "Diaspora",
     "description": "The extension of trade leads to the permanent establishment of storekeepers and their families in foreign countries, allowing them to exploit the wealth of these countries.",
     "cost": { "food": 200, "wood": 200, "stone": 100, "metal": 100 },
-    "requirements": { "class": "Trader", "number": 3 },
+    "requirements": { "entity": { "class": "Trader", "number": 3 } },
     "requirementsTooltip": "Requires 3 Traders",
     "supersedes": "unlock_shared_los",
     "icon": "diaspora.png",