Ticket #3993: notciv_v6-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 array 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 ? [] : false;
+}
+
+/**
+ * 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)
+            for (let k in requirements.generic)
+            {
+                if (!requirements.generic[k].techs)
+                    requirements.generic[k].techs = [[]];
+                for (let t in requirements.generic[k].techs)
+                    requirements.generic[k].techs[t].push(template.supersedes);
+            }
+        else if (!Object.keys(requirements).length)
+            requirements.generic = [{ "techs": [[template.supersedes]] }];
+        else
+            for (let civ in requirements)
+                if (requirements[civ])
+                    for (let k in requirements[civ])
+                    {
+                        if (!requirements[civ][k].techs)
+                            requirements[civ][k].techs = [[]];
+                        for (let t in requirements[civ][k].techs)
+                            requirements[civ][k].techs[t].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", "tech2"]] }
+ *      ],
+ *      "civB": [
+ *          { "entities": [[{
+ *              "class": "human",
+ *              "number": 2,
+ *              "variant": "count"
+ *          }]] }
+ *      ],
+ *      "civC": false,
+ *      "generic": [
+ *          { "techs": [["tech3"], ["tech4"]] }
+ *      ]
+ *  }
+ * ```
+ * (Or, to translate:
+ * - `civA` needs both `tech1` and `tech2`
+ * - `civB` needs 2 entities with the `human` class
+ * - `civC` cannot research this tech at all
+ * - and everyone else needs either `tech2` or `tech3`)
+ *
+ * @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 = {};
+    const subReqTypes = ["techs", "entities"];
+
+    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 subReqs = [{}];
+        for (let subvalue of value)
+            for (let newOper in subvalue)
+            {
+                let newValue = subvalue[newOper];
+                let result = InterpretTechRequirements(newOper, newValue)
+
+                let subtype = subReqTypes.length;
+                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":
+                    --subtype;
+                case "entity":
+                    subtype = subReqTypes[--subtype];
+                    for (let sr in subReqs)
+                    {
+                        if (!subReqs[sr][subtype])
+                            subReqs[sr][subtype] = [[]];
+                        for (let e in subReqs[sr][subtype])
+                            subReqs[sr][subtype][e] = subReqs[sr][subtype][e].concat(result.generic[0][subtype][0]);
+                    }
+                    break;
+
+                case "any":
+                {
+                    for (let civ in result)
+                        if (civ === "generic")
+                        {
+                            let newReqs = [];
+                            for (let sr in subReqs)
+                                for (let type of subReqTypes)
+                                    for (let option of result.generic)
+                                        if (option[type])
+                                            for (let t in option[type])
+                                                if (!subReqs[sr][type] || !subReqs[sr][type].length)
+                                                    newReqs.push(option);
+                                                else
+                                                    for (let k in subReqs[sr][type])
+                                                    {
+                                                        if (!newReqs[sr])
+                                                            newReqs[sr] = {};
+                                                        if (!newReqs[sr][type])
+                                                            newReqs[sr][type] = [];
+                                                        newReqs[sr][type].push(subReqs[sr][type][k].concat(option[type][t]));
+                                                    }
+                            if (newReqs.length)
+                                subReqs = newReqs;
+                        }
+                        else if (result[civ] === false)
+                            requirements[civ] = false;
+                        else
+                            civs.push(civ);
+                }
+                break
+
+                case "all":
+                {
+                    for (let civ in result)
+                    {
+                        if (civ === "generic" && result.generic[0])
+                        {
+                            for (let sr in subReqs)
+                                for (let type of subReqTypes)
+                                    if (result.generic[0][type])
+                                    {
+                                        if (!subReqs[sr][type])
+                                            subReqs[sr][type] = [];
+                                        if (subReqs[sr][type].length)
+                                            for (let k in result.generic[0][type])
+                                                result.generic[0][type][k] = subReqs[sr][type][0].concat(result.generic[0][type][k]);
+                                        subReqs[sr][type] = result.generic[0][type];
+                                    }
+                        }
+                        else if (result[civ] === false)
+                        {
+                            requirements[civ] = false;
+                            requirements.generic = [];
+                        }
+                        else if (civ !== "generic")
+                            civs.push(civ);
+                    }
+                }
+                break;
+
+                }
+            }
+
+        if (!Object.keys(subReqs[0]).length)
+            subReqs = [];
+
+        if (!civs.length && subReqs.length)
+            requirements.generic = subReqs;
+        else
+            for (let civ of civs)
+                requirements[civ] = subReqs;
+    }
+    break;
+
+    case "any":
+    {
+        for (let subvalue of value)
+            for (let newOper in subvalue)
+            {
+                let newValue = subvalue[newOper];
+                let result = InterpretTechRequirements(newOper, newValue)
+
+                let subtype = subReqTypes.length;
+                switch (newOper)
+                {
+                case "civ":
+                case "notciv":
+                    for (let civ in result)
+                        requirements[civ] = result[civ];
+                    break;
+
+                case "tech":
+                    --subtype;
+                case "entity":
+                {
+                    subtype = subReqTypes[--subtype];
+
+                    if (!requirements.generic)
+                        requirements.generic = [];
+                    let newReq = {};
+                    newReq[subtype] = [result.generic[0][subtype][0]];
+                    requirements.generic.push(newReq);
+                }
+                break;
+
+                case "all":
+                    for (let civ in result)
+                    {
+                        requirements[civ] = [{}];
+                        for (let type of subReqTypes)
+                            if (result[civ][0][type])
+                                requirements[civ][0][type] = result[civ][0][type];
+                    }
+                    break;
+
+                case "any":
+                    for (let civ in result)
+                    {
+                        if (!requirements[civ])
+                            requirements[civ] = [];
+                        for (let opt of result[civ])
+                            requirements[civ].push(opt);
+                    }
+                    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);
+                for (let req of reqs)
                 {
-                    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
+                    if (!req.entities)
+                        continue;
+
+                    let entityCounts = [];
+                    for (let option of req.entities)
+                        for (let entity of option)
+                        {
+                            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 option in techReqs)
+        if (techReqs[option].techs)
+            for (let techs in techReqs[option].techs)
+                for (let req of techReqs[option].techs[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[0].techs || techdata.reqs.generic[0].techs[0].length < 2)
             continue;
 
-        let reqTech = techs[techcode].reqs.generic[1];
+        let reqTech = techs[techcode].reqs.generic[0].techs[0][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[0].techs[0][0];
+        let myPhase = techs[techcode].reqs.generic[0].techs[0][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 false;
+
+    if (civonly || !reqs.length)
         return true;
 
-    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)
+    return reqs.some(req => {
+        return Object.keys(req).every(type => {
+            switch (type)
+            {
+            case "techs":
+                return req[type].some(tech => tech.every(this.IsTechnologyResearched, this));
+
+            case "entities":
+                return req[type].some(entity => entity.every(this.DoesEntitySpecPass, this));
+            }
+            return false;
+        });
+    });
+}
+
+TechnologyManager.prototype.DoesEntitySpecPass = function(entity)
+{
+    switch (entity.check)
     {
-        let cmpPlayer = Engine.QueryInterface(this.entity, IID_Player);
-        return cmpPlayer && cmpPlayer.GetCiv() != reqs.notciv;
+    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;
     }
-    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;
+    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",