Ticket #3993: notciv_v4.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;
+}
+
+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.
+ *
+ * @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;
+        break;
+
+    case "class":
+    case "number":
+        // do nothing
+        break;
+
+    case "entity":
+        requirements.generic = { "entities": [{
+            "class": value.class,
+            "number": value.number || value.numberOfTypes,
+            "check": value.number ? "count" : "variants"
+        }]};
+        break;
+
+    case "tech":
+        if (depath(value).slice(0,4) === "pair")
+            return { "generic": loadTechnologyPair(value).techs };
+        return { "generic": { "techs": [value] } };
+
+    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":
+                    requirements[Object.keys(result)[0]] = false;
+                    break;
+
+                case "tech":
+                    techs = techs.concat(result.generic.techs);
+                    break;
+
+                case "entity":
+                    entities = entities.concat(result.generic.entities);
+                    break;
+
+                case "any":
+                case "all":
+                {
+                    if (result.generic)
+                        techs = techs.concat(result.generic);
+                    else
+                        for (let civ in result)
+                            if (result[civ] === false)
+                                requirements[civ] = false;
+                            else if (newOper === "any")
+                                civs.push(civ);
+                            else
+                                warn("Incomprehensible technology requirements - "+operator +":"+uneval(value));
+                }
+                break;
+
+                }
+            }
+        if (!civs.length && (techs.length || 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":
+                    requirements[Object.keys(result)[0]] = {};
+                    break;
+
+                case "notciv":
+                    requirements[Object.keys(result)[0]] = false;
+                    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].techs = result[civ].techs;
+                    }
+                    break;
+
+                case "any":
+                    for (let civ in result)
+                    {
+                        if (!requirements[civ])
+                        {
+                            warn("Possible any/all req operator problem - "+operator +":"+uneval(value));
+                            requirements[civ] = {};
+                        }
+                        for (let val of result[civ])
+                            requirements.generic.techs.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;
 }
+
+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 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 reqs = GetCivSpecificReqsOfTech(template.reqs, GetSimState().players[player].civ);
+                if (reqs.entities)
+                    for (let entity of reqs.entities)
+                        if (entity.check == "count")
+                        {
+                            let current = GetSimState().players[player].classCounts[entity.class] || 0;
+                            let remaining = entity.number - current;
+                            tip += " " + sprintf(translatePlural("Remaining: %(number)s to build.", "Remaining: %(number)s to build.", remaining), {
+                                "number": remaining
+                            });
+                        }
                 tooltips.push(tip);
             }
             tooltips.push(getNeededResourcesTooltip(neededResources));

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 of a given technology. Works
+ * recursively through the given tech's pre-requisite and superseded
+ * techs if necessary.
+ * 
+ * @param {string} techName - The Technology's name
+ * @return The name of the phase the technology belongs to, or false if
+ *         the current civ can't research this tech
+ */
+function GetPhaseOfTechnology(techName)
+{
+    let phaseIdx = -1;
+
+    if (depath(techName).slice(0, 5) === "phase")
+    {
+        phaseIdx = g_ParsedData.phaseList.indexOf(g_ParsedData.phases[techName].actualPhase);
+        if (phaseIdx > 0)
+            return g_ParsedData.phaseList[phaseIdx - 1];
+        warn("Unrecognised phase (" + techName + ")");
+        return false;
+    }
+
+    let techReqs = 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;
+}

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

@@ -179 +179 @@
 
 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;
 }
 
@@ -263 +211 @@
 }
 
 /**
- * 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 +225 @@
     {
         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 +237 @@
         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 +246 @@
         let reqPhasePos = phaseList.indexOf(reqPhase);
         let myPhasePos = phaseList.indexOf(myPhase);
 
-        if (phaseList.length === 0)
+        if (!phaseList.length)
             phaseList = [reqPhase, myPhase];
         else if (reqPhasePos < 0 && myPhasePos > -1)
             phaseList.splice(myPhasePos, 0, reqPhase);

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

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

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",