Ticket #1432: one_hero_2012_10_27.diff

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

@@ -1467 +1467 @@
 var batchTrainingEntities;
 var batchTrainingType;
 var batchTrainingCount;
+var batchTrainingEntityAllowedCount;
 const batchIncrementSize = 5;
 
 function flushTrainingBatch()
 {
-    Engine.PostNetworkCommand({"type": "train", "entities": batchTrainingEntities, "template": batchTrainingType, "count": batchTrainingCount});
+    var appropriateBuildings = getBuidlingsWhichCanTrainEntity(batchTrainingEntities, batchTrainingType);
+    // If training limits don't allow us to train batchTrainingCount in each appropriate building
+    if (batchTrainingEntityAllowedCount !== undefined && batchTrainingEntityAllowedCount < batchTrainingCount * appropriateBuildings.length)
+    {
+        // Train as many full batches as we can
+        var buildingsCountToTrainFullBatch = Math.floor(batchTrainingEntityAllowedCount / batchTrainingCount);
+        var buildingsToTrainFullBatch = appropriateBuildings.slice(0, buildingsCountToTrainFullBatch);
+        Engine.PostNetworkCommand({"type": "train", "entities": buildingsToTrainFullBatch, "template": batchTrainingType, "count": batchTrainingCount});
+
+        // Train remainer in one more building
+        var remainderToTrain = batchTrainingEntityAllowedCount % batchTrainingCount;
+        Engine.PostNetworkCommand({"type": "train", "entities": [ appropriateBuildings[buildingsCountToTrainFullBatch] ], "template": batchTrainingType, "count": remainderToTrain});
+    }
+    else
+    {
+        Engine.PostNetworkCommand({"type": "train", "entities": appropriateBuildings, "template": batchTrainingType, "count": batchTrainingCount});
+    }
 }
 
+function getBuidlingsWhichCanTrainEntity(entitiesToCheck, trainEntType)
+{
+    return entitiesToCheck.filter(function(entity) {
+        var state = GetEntityState(entity);
+        var canTrain = state && state.production && state.production.entities.length && state.production.entities.indexOf(trainEntType) != -1;
+        return canTrain;
+    });
+}
+
+function getEntityLimitAndCount(playerState, entType)
+{
+    var template = GetTemplateData(entType);
+    var trainingCategory = null;
+    if (template.trainingRestrictions)
+        trainingCategory = template.trainingRestrictions.category;
+    var trainEntLimit = undefined;
+    var trainEntCount = undefined;
+    var canBeTrainedCount = undefined;
+    if (trainingCategory && playerState.entityLimits[trainingCategory])
+    {
+        trainEntLimit = playerState.entityLimits[trainingCategory];
+        trainEntCount = playerState.entityCounts[trainingCategory];
+        canBeTrainedCount = trainEntLimit - trainEntCount;
+    }
+    return [trainEntLimit, trainEntCount, canBeTrainedCount];
+}
+
 // Called by GUI when user clicks training button
-function addTrainingToQueue(selection, trainEntType)
+function addTrainingToQueue(selection, trainEntType, playerState)
 {
-    if (Engine.HotkeyIsPressed("session.batchtrain"))
+    // Create list of buildings which can train trainEntType
+    var appropriateBuildings = getBuidlingsWhichCanTrainEntity(selection, trainEntType);
+
+    // Check trainEntType entity limit and count
+    var [trainEntLimit, trainEntCount, canBeTrainedCount] = getEntityLimitAndCount(playerState, trainEntType)
+
+    // Batch training possible if we can train at least 2 units
+    var batchTrainingPossible = canBeTrainedCount !== undefined && canBeTrainedCount > 1;
+
+    if (Engine.HotkeyIsPressed("session.batchtrain") && batchTrainingPossible)
     {
         if (inputState == INPUT_BATCHTRAINING)
         {
@@ -1494 +1547 @@
                 }
             }
             // If we're already creating a batch of this unit (in the same building(s)), then just extend it
+            // (if training limits allow)
             if (sameEnts && batchTrainingType == trainEntType)
             {
-                batchTrainingCount += batchIncrementSize;
+                if (canBeTrainedCount !== undefined && canBeTrainedCount > batchTrainingCount * appropriateBuildings.length)
+                    batchTrainingCount += batchIncrementSize;
+                batchTrainingEntityAllowedCount = canBeTrainedCount;
                 return;
             }
             // Otherwise start a new one
@@ -1509 +1565 @@
         inputState = INPUT_BATCHTRAINING;
         batchTrainingEntities = selection;
         batchTrainingType = trainEntType;
+        batchTrainingEntityAllowedCount = canBeTrainedCount;
         batchTrainingCount = batchIncrementSize;
     }
     else
     {
-        // Non-batched - just create a single entity
-        Engine.PostNetworkCommand({"type": "train", "template": trainEntType, "count": 1, "entities": selection});
+        // Non-batched - just create a single entity in each building
+        // (but no more than entity limit allows)
+        var buildingsForTraining = appropriateBuildings;
+        if (trainEntLimit)
+            buildingsForTraining = buildingsForTraining.slice(0, canBeTrainedCount);
+        Engine.PostNetworkCommand({"type": "train", "template": trainEntType, "count": 1, "entities": buildingsForTraining});
     }
 }
 
@@ -1526 +1587 @@
 
 // Returns the number of units that will be present in a batch if the user clicks
 // the training button with shift down
-function getTrainingBatchStatus(entity, trainEntType)
+function getTrainingBatchStatus(playerState, entity, trainEntType, selection)
 {
+    var apporpriateBuildings = [entity];
+    if (selection && selection.indexOf(entity) != -1)
+        appropriateBuildings = getBuidlingsWhichCanTrainEntity(selection, trainEntType);
+    var nextBatchTrainingCount = 0;
     if (inputState == INPUT_BATCHTRAINING && batchTrainingEntities.indexOf(entity) != -1 && batchTrainingType == trainEntType)
-        return [batchTrainingCount, batchIncrementSize];
+    {
+        nextBatchTrainingCount = batchTrainingCount;
+        var canBeTrainedCount = batchTrainingEntityAllowedCount;
+    }
     else
-        return [0, batchIncrementSize];
+    {
+        var [trainEntLimit, trainEntCount, canBeTrainedCount] = getEntityLimitAndCount(playerState, trainEntType);
+        var batchSize = Math.min(canBeTrainedCount, batchIncrementSize);
+    }
+    // We need to calculate count after the next increment if it's possible
+    if (canBeTrainedCount == undefined || canBeTrainedCount > nextBatchTrainingCount * appropriateBuildings.length)
+        nextBatchTrainingCount += batchIncrementSize;
+    // If training limits don't allow us to train batchTrainingCount in each appropriate building
+    // train as many full batches as we can and remainer in one more building.
+    var buildingsCountToTrainFullBatch = appropriateBuildings.length;
+    var remainderToTrain = 0;
+    if (canBeTrainedCount !== undefined && canBeTrainedCount < nextBatchTrainingCount * appropriateBuildings.length)
+    {
+        buildingsCountToTrainFullBatch = Math.floor(canBeTrainedCount / nextBatchTrainingCount);
+        remainderToTrain = canBeTrainedCount % nextBatchTrainingCount;
+    }
+    return [buildingsCountToTrainFullBatch, nextBatchTrainingCount, remainderToTrain];
 }
 
 // Called by GUI when user clicks production queue item

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

@@ -139 +139 @@
 }
 
 /**
+ * Format entity count/limit message for the tooltip
+ */
+function formatLimitString(trainEntLimit, trainEntCount)
+{
+    if (trainEntLimit == undefined)
+        return "";
+    var text = "\n\nCurrent count: " + trainEntCount + ", limit: " + trainEntLimit + ".";
+    if (trainEntCount >= trainEntLimit)
+        text = "[color=\"red\"]" + text + "[/color]";
+    return text;
+}
+
+/**
+ * Format batch training string for the tooltip
+ * Examples:
+ * buildingsCountToTrainFullBatch = 1, fullBatchSize = 5, remainderBatch = 0:
+ * "Shift-click to train 5"
+ * buildingsCountToTrainFullBatch = 2, fullBatchSize = 5, remainderBatch = 0:
+ * "Shift-click to train 10 (2*5)"
+ * buildingsCountToTrainFullBatch = 1, fullBatchSize = 15, remainderBatch = 12:
+ * "Shift-click to train 27 (15 + 12)"
+ */
+function formatBatchTrainingString(buildingsCountToTrainFullBatch, fullBatchSize, remainderBatch)
+{
+    var totalBatchTrainingCount = buildingsCountToTrainFullBatch * fullBatchSize + remainderBatch;
+    // Don't show the batch training tooltip if either units of this type can't be trained at all
+    // or only one unit can be trained
+    if (totalBatchTrainingCount < 2)
+        return "";
+    var batchTrainingString = "";
+    var fullBatchesString = "";
+    if (buildingsCountToTrainFullBatch > 0)
+    {
+        if (buildingsCountToTrainFullBatch > 1)
+            fullBatchesString += buildingsCountToTrainFullBatch + "*";
+        fullBatchesString += fullBatchSize;
+    }
+    var remainderBatchString = remainderBatch > 0 ? remainderBatch : "";
+    var batchDetailsString = buildingsCountToTrainFullBatch > 1 || (buildingsCountToTrainFullBatch == 1 && remainderBatch > 0) ?
+        " (" + [fullBatchesString, remainderBatchString].filter(function(string) { return string != "" }).join(" + ") + ")" :
+        "";
+    return "\n\n[font=\"serif-bold-13\"]Shift-click[/font][font=\"serif-13\"] to train "
+        + totalBatchTrainingCount + batchDetailsString + ".[/font]";
+}
+
+/**
  * Helper function for updateUnitCommands; sets up "unit panels" (i.e. panels with rows of icons) for the currently selected
  * unit.
  * 
@@ -150 +196 @@
  * @param items Panel-specific data to construct the icons with.
  * @param callback Callback function to argument to execute when an item's icon gets clicked. Takes a single 'item' argument.
  */
-function setupUnitPanel(guiName, usedPanels, unitEntState, items, callback)
+function setupUnitPanel(guiName, usedPanels, unitEntState, playerState, items, callback)
 {
     usedPanels[guiName] = 1;
 
@@ -374 +420 @@
                 if (template.tooltip)
                     tooltip += "\n[font=\"serif-13\"]" + template.tooltip + "[/font]";
 
-                var [batchSize, batchIncrement] = getTrainingBatchStatus(unitEntState.id, entType);
-                var trainNum = batchSize ? batchSize+batchIncrement : batchIncrement;
-
                 tooltip += "\n" + getEntityCostTooltip(template);
 
                 if (template.health)
@@ -388 +431 @@
                 if (template.speed)
                     tooltip += "\n" + getEntitySpeed(template);
 
-                tooltip += "\n\n[font=\"serif-bold-13\"]Shift-click[/font][font=\"serif-13\"] to train " + trainNum + ".[/font]";
+                var [trainEntLimit, trainEntCount, canBeTrainedCount] = getEntityLimitAndCount(playerState, entType)
+                tooltip += formatLimitString(trainEntLimit, trainEntCount);
 
+                var [buildingsCountToTrainFullBatch, fullBatchSize, remainderBatch] = getTrainingBatchStatus(playerState, unitEntState.id, entType, selection);
+                tooltip += formatBatchTrainingString(buildingsCountToTrainFullBatch, fullBatchSize, remainderBatch);
                 break;
                 
             case RESEARCH:
@@ -627 +673 @@
                     pair.hidden = true;
                     button1.hidden = true;
                     affordableMask1.hidden = true;
-                }
+                }
             }
             else if (guiName == CONSTRUCTION || guiName == TRAINING)
             {
+                if (guiName == TRAINING)
+                {
+                    var trainingCategory = null;
+                    if (template.trainingRestrictions)
+                        trainingCategory = template.trainingRestrictions.category;
+                    var grayscale = "";
+                    if (trainingCategory && playerState.entityLimits[trainingCategory] && playerState.entityCounts[trainingCategory] >= playerState.entityLimits[trainingCategory])
+                        grayscale = "grayscale:";
+                    icon.sprite = "stretched:" + grayscale + "session/portraits/" + template.icon;
+                }
+
                 affordableMask.hidden = true;
                 var totalCosts = {};
                 var trainNum = 1;
                 if (Engine.HotkeyIsPressed("session.batchtrain") && guiName == TRAINING)
                 {
-                    var [batchSize, batchIncrement] = getTrainingBatchStatus(unitEntState.id, entType);
-                    trainNum = batchSize + batchIncrement;
+                    var [buildingsCountToTrainFullBatch, fullBatchSize, remainderBatch] = getTrainingBatchStatus(playerState, unitEntState.id, entType, selection);
+                    trainNum = buildingsCountToTrainFullBatch * fullBatchSize + remainderBatch;
                 }
 
                 // Walls have no cost defined.
@@ -767 +824 @@
 }
 
 // Sets up "unit barter panel" - special case for setupUnitPanel
-function setupUnitBarterPanel(unitEntState)
+function setupUnitBarterPanel(unitEntState, playerState)
 {
     // Amount of player's resource to exchange
     var amountToSell = BARTER_RESOURCE_AMOUNT_TO_SELL;
@@ -862 +919 @@
     var player = Engine.GetPlayerID();
     if (entState.player == player || g_DevSettings.controlAll)
     {
+        // Get player state to check some constraints
+        // e.g. presence of a hero or build limits
+        var simState = Engine.GuiInterfaceCall("GetSimulationState");
+        var playerState = simState.players[player];
+
         if (selection.length > 1)
-            setupUnitPanel(SELECTION, usedPanels, entState, g_Selection.groups.getTemplateNames(),
+            setupUnitPanel(SELECTION, usedPanels, entState, playerState, g_Selection.groups.getTemplateNames(),
                 function (entType) { changePrimarySelectionGroup(entType); } );
 
         var commands = getEntityCommandsList(entState);
         if (commands.length)
-            setupUnitPanel(COMMAND, usedPanels, entState, commands,
+            setupUnitPanel(COMMAND, usedPanels, entState, playerState, commands,
                 function (item) { performCommand(entState.id, item.name); } );
 
         if (entState.garrisonHolder)
@@ -881 +943 @@
                     groups.add(state.garrisonHolder.entities)
             }
 
-            setupUnitPanel(GARRISON, usedPanels, entState, groups.getTemplateNames(),
+            setupUnitPanel(GARRISON, usedPanels, entState, playerState, groups.getTemplateNames(),
                 function (item) { unloadTemplate(item); } );
         }
 
         var formations = Engine.GuiInterfaceCall("GetAvailableFormations");
         if (hasClass(entState, "Unit") && !hasClass(entState, "Animal") && !entState.garrisonHolder && formations.length)
         {
-            setupUnitPanel(FORMATION, usedPanels, entState, formations,
+            setupUnitPanel(FORMATION, usedPanels, entState, playerState, formations,
                 function (item) { performFormation(entState.id, item); } );
         }
 
@@ -897 +959 @@
         var stances = ["violent", "aggressive", "passive", "defensive", "standground"];
         if (hasClass(entState, "Unit") && !hasClass(entState, "Animal") && stances.length)
         {
-            setupUnitPanel(STANCE, usedPanels, entState, stances,
+            setupUnitPanel(STANCE, usedPanels, entState, playerState, stances,
                 function (item) { performStance(entState.id, item); } );
         }
 
@@ -905 +967 @@
         if (entState.barterMarket)
         {
             usedPanels["Barter"] = 1;
-            setupUnitBarterPanel(entState);
+            setupUnitBarterPanel(entState, playerState);
         }
 
         var buildableEnts = [];
@@ -929 +991 @@
 
         // The first selected entity's type has priority.
         if (entState.buildEntities)
-            setupUnitPanel(CONSTRUCTION, usedPanels, entState, buildableEnts, startBuildingPlacement);
+            setupUnitPanel(CONSTRUCTION, usedPanels, entState, playerState, buildableEnts, startBuildingPlacement);
         else if (entState.production && entState.production.entities)
-            setupUnitPanel(TRAINING, usedPanels, entState, trainableEnts,
-                function (trainEntType) { addTrainingToQueue(selection, trainEntType); } );
+            setupUnitPanel(TRAINING, usedPanels, entState, playerState, trainableEnts,
+                function (trainEntType) { addTrainingToQueue(selection, trainEntType, playerState); } );
         else if (entState.trader)
             setupUnitTradingPanel(usedPanels, entState, selection);
         else if (!entState.foundation && entState.gate || hasClass(entState, "LongWall"))
@@ -994 +1056 @@
                 setupUnitPanel(CONSTRUCTION, usedPanels, entState, buildableEnts, startBuildingPlacement);
             else if (trainableEnts.length)
                 setupUnitPanel(TRAINING, usedPanels, entState, trainableEnts,
-                    function (trainEntType) { addTrainingToQueue(selection, trainEntType); } );
+                    function (trainEntType) { addTrainingToQueue(selection, trainEntType, playerState); } );
         }
 
         // Show technologies if the active panel has at most one row of icons.
@@ -1007 +1069 @@
         }
 
         if (entState.production && entState.production.queue.length)
-            setupUnitPanel(QUEUE, usedPanels, entState, entState.production.queue,
+            setupUnitPanel(QUEUE, usedPanels, entState, playerState, entState.production.queue,
                 function (item) { removeFromProductionQueue(entState.id, item.id); } );
         
         supplementalDetailsPanel.hidden = false;

binaries/data/mods/public/simulation/ai/jubot/gamestate.js

@@ -416 +416 @@
      * Returns player build limits
      * an object where each key is a category corresponding to a build limit for the player.
      */
-    getBuildLimits: function()
+    getEntityLimits: function()
     {
-        return this.playerData.buildLimits;
+        return this.playerData.entityLimits;
     },
     
     /**
      * Returns player build counts
      * an object where each key is a category corresponding to the current building count for the player.
      */
-    getBuildCounts: function()
+    getEntityCounts: function()
     {
-        return this.playerData.buildCounts;
+        return this.playerData.entityCounts;
     },
     
     /**
      * Checks if the player's build limit has been reached for the given category.
      * The category comes from the entity tenplate, specifically the BuildRestrictions component.
      */
-    isBuildLimitReached: function(category)
+    isEntityLimitReached: function(category)
     {
-        if (this.playerData.buildLimits[category] === undefined || this.playerData.buildCounts[category] === undefined)
+        if (this.playerData.entityLimits[category] === undefined || this.playerData.entityCounts[category] === undefined)
             return false;
         
         // There's a special case of build limits per civ centre, so check that first
-        if (this.playerData.buildLimits[category].LimitPerCivCentre !== undefined)
-            return (this.playerData.buildCounts[category] >= this.playerData.buildCounts["CivilCentre"]*this.playerData.buildLimits[category].LimitPerCivCentre);
+        if (this.playerData.entityLimits[category].LimitPerCivCentre !== undefined)
+            return (this.playerData.entityCounts[category] >= this.playerData.entityCounts["CivilCentre"]*this.playerData.entityLimits[category].LimitPerCivCentre);
         else
-            return (this.playerData.buildCounts[category] >= this.playerData.buildLimits[category]);
+            return (this.playerData.entityCounts[category] >= this.playerData.entityLimits[category]);
     },
 });

binaries/data/mods/public/simulation/ai/qbot/gamestate.js

@@ -303 +303 @@
     return this.updatingCollection("resource-" + resource, Filters.byResource(resource), this.getEntities());
 };
 
-GameState.prototype.getBuildLimits = function() {
-    return this.playerData.buildLimits;
+GameState.prototype.getEntityLimits = function() {
+    return this.playerData.entityLimits;
 };
 
-GameState.prototype.getBuildCounts = function() {
-    return this.playerData.buildCounts;
+GameState.prototype.getEntityCounts = function() {
+    return this.playerData.entityCounts;
 };
 
 // Checks whether the maximum number of buildings have been cnstructed for a certain catergory
-GameState.prototype.isBuildLimitReached = function(category) {
-    if(this.playerData.buildLimits[category] === undefined || this.playerData.buildCounts[category] === undefined)
+GameState.prototype.isEntityLimitReached = function(category) {
+    if(this.playerData.entityLimits[category] === undefined || this.playerData.entityCounts[category] === undefined)
         return false;
-    if(this.playerData.buildLimits[category].LimitsPerCivCentre != undefined)
-        return (this.playerData.buildCounts[category] >= this.playerData.buildCounts["CivilCentre"]*this.playerData.buildLimits[category].LimitPerCivCentre);
+    if(this.playerData.entityLimits[category].LimitsPerCivCentre != undefined)
+        return (this.playerData.entityCounts[category] >= this.playerData.entityCounts["CivilCentre"]*this.playerData.entityLimits[category].LimitPerCivCentre);
     else
-        return (this.playerData.buildCounts[category] >= this.playerData.buildLimits[category]);
+        return (this.playerData.entityCounts[category] >= this.playerData.entityLimits[category]);
 };

binaries/data/mods/public/simulation/ai/qbot/military.js

@@ -324 +324 @@
 // Adds towers to the defenceBuilding queue
 MilitaryAttackManager.prototype.buildDefences = function(gameState, queues){ 
     if (gameState.countEntitiesAndQueuedByType(gameState.applyCiv('structures/{civ}_defense_tower'))
-            + queues.defenceBuilding.totalLength() < gameState.getBuildLimits()["DefenseTower"]) {
+            + queues.defenceBuilding.totalLength() < gameState.getEntityLimits()["DefenseTower"]) {
         
         
         gameState.getOwnEntities().forEach(function(dropsiteEnt) {
@@ -343 +343 @@
         numFortresses += gameState.countEntitiesAndQueuedByType(gameState.applyCiv(this.bFort[i]));
     }
     
-    if (numFortresses + queues.defenceBuilding.totalLength() < gameState.getBuildLimits()["Fortress"]) {
+    if (numFortresses + queues.defenceBuilding.totalLength() < gameState.getEntityLimits()["Fortress"]) {
         if (gameState.countEntitiesByType(gameState.applyCiv("units/{civ}_support_female_citizen")) > gameState.ai.modules["economy"].targetNumWorkers * 0.5){
             if (gameState.getTimeElapsed() > 350 * 1000 * numFortresses){
                 if (gameState.ai.pathsToMe && gameState.ai.pathsToMe.length > 0){

binaries/data/mods/public/simulation/ai/testbot/gamestate.js

@@ -269 +269 @@
      * Returns player build limits
      * an object where each key is a category corresponding to a build limit for the player.
      */
-    getBuildLimits: function()
+    getEntityLimits: function()
     {
-        return this.playerData.buildLimits;
+        return this.playerData.entityLimits;
     },
     
     /**
-     * Returns player build counts
-     * an object where each key is a category corresponding to the current building count for the player.
+     * Returns player entity counts
+     * an object where each key is a category corresponding to the current entity count for the player.
      */
-    getBuildCounts: function()
+    getEntityCounts: function()
     {
-        return this.playerData.buildCounts;
+        return this.playerData.entityCounts;
     },
     
     /**
-     * Checks if the player's build limit has been reached for the given category.
+     * Checks if the player's entity limit has been reached for the given category.
      * The category comes from the entity tenplate, specifically the BuildRestrictions component.
      */
-    isBuildLimitReached: function(category)
+    isEntityLimitReached: function(category)
     {
-        if (this.playerData.buildLimits[category] === undefined || this.playerData.buildCounts[category] === undefined)
+        if (this.playerData.entityLimits[category] === undefined || this.playerData.entityCounts[category] === undefined)
             return false;
         
         // There's a special case of build limits per civ centre, so check that first
-        if (this.playerData.buildLimits[category].LimitPerCivCentre !== undefined)
-            return (this.playerData.buildCounts[category] >= this.playerData.buildCounts["CivilCentre"]*this.playerData.buildLimits[category].LimitPerCivCentre);
+        if (this.playerData.entityLimits[category].LimitPerCivCentre !== undefined)
+            return (this.playerData.entityCounts[category] >= this.playerData.entityCounts["CivilCentre"]*this.playerData.entityLimits[category].LimitPerCivCentre);
         else
-            return (this.playerData.buildCounts[category] >= this.playerData.buildLimits[category]);
+            return (this.playerData.entityCounts[category] >= this.playerData.entityLimits[category]);
     },
 });

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

@@ -1 @@
-function BuildLimits() {}
-
-BuildLimits.prototype.Schema =
-    "<a:help>Specifies per category limits on number of buildings that can be constructed for each player.</a:help>" +
-    "<a:example>" +
-        "<Limits>" +
-          "<CivilCentre/>" +
-          "<DefenseTower>25</DefenseTower>" +
-          "<Fortress>10</Fortress>" +
-          "<Special>" +
-            "<LimitPerCivCentre>1</LimitPerCivCentre>" +
-          "</Special>" +
-        "</Limits>" +
-    "</a:example>" +
-    "<element name='LimitMultiplier'>" +
-        "<ref name='positiveDecimal'/>" +
-    "</element>" +
-    "<element name='Limits'>" +
-        "<zeroOrMore>" +
-            "<element a:help='Specifies a category of building on which to apply this limit. See BuildRestrictions for list of categories.'>" +
-                "<anyName />" +
-                "<choice>" +
-                    "<text />" +
-                    "<element name='LimitPerCivCentre' a:help='Specifies that this limit is per number of civil centres.'>" +
-                        "<data type='nonNegativeInteger'/>" +
-                    "</element>" +
-                "</choice>" +
-            "</element>" +
-        "</zeroOrMore>" +
-    "</element>";
-
-/*
- *  TODO: Use an inheriting player_{civ}.xml template for civ-specific limits
- */
-
-BuildLimits.prototype.Init = function()
-{
-    this.limit = {};
-    this.count = {};
-    for (var category in this.template.Limits)
-    {
-        this.limit[category] = this.template.Limits[category];
-        this.count[category] = 0;
-    }
-};
-
-BuildLimits.prototype.IncrementCount = function(category)
-{
-    if (this.count[category] !== undefined)
-    {
-        this.count[category]++;
-    }
-};
-
-BuildLimits.prototype.DecrementCount = function(category)
-{
-    if (this.count[category] !== undefined)
-    {
-        this.count[category]--;
-    }
-};
-
-BuildLimits.prototype.GetLimits = function()
-{
-    return this.limit;
-};
-
-BuildLimits.prototype.GetCounts = function()
-{
-    return this.count;
-};
-
-BuildLimits.prototype.AllowedToBuild = function(category)
-{
-    // TODO: The UI should reflect this before the user tries to place the building,
-    //          since the limits are independent of placement location
-
-    // Allow unspecified categories and those with no limit
-    if (this.count[category] === undefined || this.limit[category] === undefined)
-    {
-        return true;
-    }
-    
-    // Rather than complicating the schema unecessarily, just handle special cases here
-    if (this.limit[category].LimitPerCivCentre !== undefined)
-    {
-        if (this.count[category] >= this.count["CivilCentre"] * this.limit[category].LimitPerCivCentre)
-        {
-            var cmpPlayer = Engine.QueryInterface(this.entity, IID_Player); 
-            var notification = {"player": cmpPlayer.GetPlayerID(), "message": category+" build limit of "+this.limit[category].LimitPerCivCentre+" per civil centre reached"};
-            var cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
-            cmpGUIInterface.PushNotification(notification);
-            
-            return false;
-        }
-    }
-    else if (this.count[category] >= this.limit[category])
-    {
-        var cmpPlayer = Engine.QueryInterface(this.entity, IID_Player);
-        var notification = {"player": cmpPlayer.GetPlayerID(), "message": category+" build limit of "+this.limit[category]+ " reached"};
-        var cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
-        cmpGUIInterface.PushNotification(notification);
-        
-        return false;
-    }
-    
-    return true;
-};
-
-BuildLimits.prototype.OnGlobalOwnershipChanged = function(msg)
-{
-    // This automatically updates build counts
-    var cmpBuildRestrictions = Engine.QueryInterface(msg.entity, IID_BuildRestrictions);
-    if (cmpBuildRestrictions)
-    {
-        var playerID = (Engine.QueryInterface(this.entity, IID_Player)).GetPlayerID();
-        if (msg.from == playerID)
-        {
-            this.DecrementCount(cmpBuildRestrictions.GetCategory());
-        }
-        if (msg.to == playerID)
-        {
-            this.IncrementCount(cmpBuildRestrictions.GetCategory());
-        }
-    }
-};
-
-Engine.RegisterComponentType(IID_BuildLimits, "BuildLimits", BuildLimits);

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

@@ +1 @@
+function EntityLimits() {}
+
+EntityLimits.prototype.Schema =
+    "<a:help>Specifies per category limits on number of entities (buildings or units) that can be created for each player.</a:help>" +
+    "<a:example>" +
+        "<Limits>" +
+          "<CivilCentre/>" +
+          "<DefenseTower>25</DefenseTower>" +
+          "<Fortress>10</Fortress>" +
+          "<Hero>1</Hero>" +
+          "<Special>" +
+            "<LimitPerCivCentre>1</LimitPerCivCentre>" +
+          "</Special>" +
+        "</Limits>" +
+    "</a:example>" +
+    "<element name='LimitMultiplier'>" +
+        "<ref name='positiveDecimal'/>" +
+    "</element>" +
+    "<element name='Limits'>" +
+        "<zeroOrMore>" +
+            "<element a:help='Specifies a category of building/unit on which to apply this limit. See BuildRestrictions/TrainingRestrictions for list of categories.'>" +
+                "<anyName />" +
+                "<choice>" +
+                    "<text />" +
+                    "<element name='LimitPerCivCentre' a:help='Specifies that this limit is per number of civil centres.'>" +
+                        "<data type='nonNegativeInteger'/>" +
+                    "</element>" +
+                "</choice>" +
+            "</element>" +
+        "</zeroOrMore>" +
+    "</element>";
+
+/*
+ *  TODO: Use an inheriting player_{civ}.xml template for civ-specific limits
+ */
+
+const TRAINING = "training";
+const BUILD = "build";
+
+EntityLimits.prototype.Init = function()
+{
+    this.limit = {};
+    this.count = {};
+    for (var category in this.template.Limits)
+    {
+        this.limit[category] = this.template.Limits[category];
+        this.count[category] = 0;
+    }
+};
+
+EntityLimits.prototype.IncreaseCount = function(category, value)
+{
+    if (this.count[category] !== undefined)
+    {
+        this.count[category] += value;
+    }
+};
+
+EntityLimits.prototype.DecreaseCount = function(category, value)
+{
+    if (this.count[category] !== undefined)
+    {
+        this.count[category] -= value;
+    }
+};
+
+EntityLimits.prototype.IncrementCount = function(category)
+{
+    this.IncreaseCount(category, 1);
+};
+
+EntityLimits.prototype.DecrementCount = function(category)
+{
+    this.DecreaseCount(category, 1);
+};
+
+EntityLimits.prototype.GetLimits = function()
+{
+    return this.limit;
+};
+
+EntityLimits.prototype.GetCounts = function()
+{
+    return this.count;
+};
+
+EntityLimits.prototype.AllowedToCreate = function(limitType, category, count)
+{
+    // TODO: The UI should reflect this before the user tries to place the building,
+    //          since the limits are independent of placement location
+
+    // Allow unspecified categories and those with no limit
+    if (this.count[category] === undefined || this.limit[category] === undefined)
+    {
+        return true;
+    }
+    
+    // Rather than complicating the schema unecessarily, just handle special cases here
+    if (this.limit[category].LimitPerCivCentre !== undefined)
+    {
+        if (this.count[category] >= this.count["CivilCentre"] * this.limit[category].LimitPerCivCentre)
+        {
+            var cmpPlayer = Engine.QueryInterface(this.entity, IID_Player); 
+            var notification = {"player": cmpPlayer.GetPlayerID(), "message": category+" "+limitType+" limit of "+this.limit[category].LimitPerCivCentre+" per civil centre reached"};
+            var cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
+            cmpGUIInterface.PushNotification(notification);
+            
+            return false;
+        }
+    }
+    else if (this.count[category] + count > this.limit[category])
+    {
+        var cmpPlayer = Engine.QueryInterface(this.entity, IID_Player);
+        var notification = {"player": cmpPlayer.GetPlayerID(), "message": category+" "+limitType+" limit of "+this.limit[category]+ " reached"};
+        var cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
+        cmpGUIInterface.PushNotification(notification);
+        
+        return false;
+    }
+    
+    return true;
+}
+
+EntityLimits.prototype.AllowedToBuild = function(category)
+{
+    // TODO: The UI should reflect this before the user tries to place the building,
+    //          since the limits are independent of placement location
+
+    return this.AllowedToCreate(BUILD, category, 1);
+};
+
+EntityLimits.prototype.AllowedToTrain = function(category, count)
+{
+    return this.AllowedToCreate(TRAINING, category, count);
+};
+
+EntityLimits.prototype.OnGlobalOwnershipChanged = function(msg)
+{
+    // This automatically updates entity counts
+    var category = null;
+    var cmpBuildRestrictions = Engine.QueryInterface(msg.entity, IID_BuildRestrictions);
+    if (cmpBuildRestrictions)
+        category = cmpBuildRestrictions.GetCategory();
+    var cmpTrainingRestrictions = Engine.QueryInterface(msg.entity, IID_TrainingRestrictions);
+    if (cmpTrainingRestrictions)
+        category = cmpTrainingRestrictions.GetCategory();
+    if (category)
+    {
+        var playerID = (Engine.QueryInterface(this.entity, IID_Player)).GetPlayerID();
+        if (msg.from == playerID)
+        {
+            this.DecrementCount(category);
+        }
+        if (msg.to == playerID)
+        {
+            this.IncrementCount(category);
+        }
+    }
+};
+
+Engine.RegisterComponentType(IID_EntityLimits, "EntityLimits", EntityLimits);

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

@@ -49 +49 @@
     for (var i = 0; i < n; ++i)
     {
         var playerEnt = cmpPlayerMan.GetPlayerByID(i);
-        var cmpPlayerBuildLimits = Engine.QueryInterface(playerEnt, IID_BuildLimits);
+        var cmpPlayerEntityLimits = Engine.QueryInterface(playerEnt, IID_EntityLimits);
         var cmpPlayer = Engine.QueryInterface(playerEnt, IID_Player);
         
         // Work out what phase we are in
@@ -88 +88 @@
             "isAlly": allies,
             "isNeutral": neutrals,
             "isEnemy": enemies,
-            "buildLimits": cmpPlayerBuildLimits.GetLimits(),
-            "buildCounts": cmpPlayerBuildLimits.GetCounts(),
+            "entityLimits": cmpPlayerEntityLimits.GetLimits(),
+            "entityCounts": cmpPlayerEntityLimits.GetCounts(),
             "techModifications": cmpTechnologyManager.GetTechModifications()
         };
         ret.players.push(playerData);
@@ -384 +384 @@
             if (template.BuildRestrictions.Distance.MaxDistance) ret.buildRestrictions.distance.max = +template.BuildRestrictions.Distance.MaxDistance;
         }
     }
-    
+
+    if (template.TrainingRestrictions)
+    {
+        ret.trainingRestrictions = {
+            "category": template.TrainingRestrictions.Category,
+        };
+    }
+
     if (template.Cost)
     {
         ret.cost = {};
@@ -453 +460 @@
         ret.icon = template.Identity.Icon;
         ret.tooltip =  template.Identity.Tooltip;
         ret.requiredTechnology = template.Identity.RequiredTechnology;
+        ret.identityClassesString = GetTemplateIdentityClassesString(template);
     }
 
     if (template.UnitMotion)

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

@@ -417 +417 @@
 Player.prototype.OnGlobalOwnershipChanged = function(msg)
 {
     var isConquestCritical = false;
-
     // Load class list only if we're going to need it
     if (msg.from == this.playerID || msg.to == this.playerID)
     {
         var cmpIdentity = Engine.QueryInterface(msg.entity, IID_Identity);
         if (cmpIdentity)
         {
-            var classes = cmpIdentity.GetClassesList();
-            isConquestCritical = classes.indexOf("ConquestCritical") != -1;
+            isConquestCritical = cmpIdentity.HasClass("ConquestCritical");
         }
     }
-    
     if (msg.from == this.playerID)
     {
         if (isConquestCritical)
             this.conquestCriticalEntitiesCount--;
-
         var cost = Engine.QueryInterface(msg.entity, IID_Cost);
         if (cost)
         {
@@ -441 +437 @@
             this.popBonuses -= cost.GetPopBonus();
         }
     }
-    
     if (msg.to == this.playerID)
     {
         if (isConquestCritical)
             this.conquestCriticalEntitiesCount++;
-            
         var cost = Engine.QueryInterface(msg.entity, IID_Cost);
         if (cost)
         {

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

@@ -212 +212 @@
             if (!cmpPlayer.TrySubtractResources(totalCosts))
                 return;
 
+            // Update entity count in the EntityLimits component
+            if (template.TrainingRestrictions)
+            {
+                var unitCategory = template.TrainingRestrictions.Category;
+                var cmpPlayerEntityLimits = QueryOwnerInterface(this.entity, IID_EntityLimits);
+                cmpPlayerEntityLimits.IncreaseCount(unitCategory, count);
+            }
+
             this.queue.push({
                 "id": this.nextID++,
                 "player": cmpPlayer.GetPlayerID(),
@@ -307 +315 @@
         
         var cmpPlayer = QueryPlayerIDInterface(item.player, IID_Player);
 
+        // Update entity count in the EntityLimits component
+        if (item.unitTemplate)
+        {
+            var cmpTempMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
+            var template = cmpTempMan.GetTemplate(item.unitTemplate);
+            if (template.TrainingRestrictions)
+            {
+                var unitCategory = template.TrainingRestrictions.Category;
+                var cmpPlayerEntityLimits = QueryOwnerInterface(this.entity, IID_EntityLimits);
+                cmpPlayerEntityLimits.DecreaseCount(unitCategory, item.count);
+            }
+        }
+
         // Refund the resource cost for this batch
         var totalCosts = {};
         var cmpStatisticsTracker = QueryOwnerInterface(this.entity, IID_StatisticsTracker);
@@ -422 +443 @@
         //  so only create them once and use as needed
         for (var i = 0; i < count; ++i)
         {
-            this.entityCache.push(Engine.AddEntity(templateName));
+            var ent = Engine.AddEntity(templateName);
+            this.entityCache.push(ent);
+
+            // Decrement entity count in the EntityLimits component
+            // since it will be increased by EntityLimits.OnGlobalOwnershipChanged function,
+            // i.e. we replace a 'trained' entity to an 'alive' one
+            var cmpTrainingRestrictions = Engine.QueryInterface(ent, IID_TrainingRestrictions);
+            if (cmpTrainingRestrictions)
+            {
+                var unitCategory = cmpTrainingRestrictions.GetCategory();
+                var cmpPlayerEntityLimits = QueryOwnerInterface(this.entity, IID_EntityLimits);
+                cmpPlayerEntityLimits.DecrementCount(unitCategory);
+            }
         }
     }
 

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

@@ +1 @@
+function TrainingRestrictions() {}
+
+TrainingRestrictions.prototype.Schema =
+    "<a:help>Specifies unit training restrictions, currently only unit category.</a:help>" +
+    "<a:example>" +
+        "<TrainingRestrictions>" +
+            "<Category>Hero</Category>" +
+        "</TrainingRestrictions>" +
+    "</a:example>" +
+    "<element name='Category' a:help='Specifies the category of this unit, for satisfying special constraints.'>" +
+        "<choice>" +
+            "<value>Hero</value>" +
+            "<value>FemaleCitizen</value>" +
+        "</choice>" +
+    "</element>";
+
+TrainingRestrictions.prototype.GetCategory = function()
+{
+    return this.template.Category;
+};
+
+Engine.RegisterComponentType(IID_TrainingRestrictions, "TrainingRestrictions", TrainingRestrictions);

binaries/data/mods/public/simulation/components/interfaces/BuildLimits.js

@@ -1 @@
-Engine.RegisterInterface("BuildLimits");
- No newline at end of file

binaries/data/mods/public/simulation/components/interfaces/EntityLimits.js

@@ +1 @@
+Engine.RegisterInterface("EntityLimits");

binaries/data/mods/public/simulation/components/interfaces/TrainingRestrictions.js

@@ +1 @@
+Engine.RegisterInterface("TrainingRestrictions");
+

binaries/data/mods/public/simulation/components/tests/test_GuiInterface.js

@@ -1 +1 @@
 Engine.LoadComponentScript("interfaces/Attack.js");
 Engine.LoadComponentScript("interfaces/Barter.js");
 Engine.LoadComponentScript("interfaces/Builder.js");
-Engine.LoadComponentScript("interfaces/BuildLimits.js");
 Engine.LoadComponentScript("interfaces/DamageReceiver.js");
+Engine.LoadComponentScript("interfaces/EntityLimits.js");
 Engine.LoadComponentScript("interfaces/Foundation.js");
 Engine.LoadComponentScript("interfaces/GarrisonHolder.js");
 Engine.LoadComponentScript("interfaces/Gate.js");
@@ -69 +69 @@
     IsEnemy: function() { return true; },
 });
 
-AddMock(100, IID_BuildLimits, {
+AddMock(100, IID_EntityLimits, {
     GetLimits: function() { return {"Foo": 10}; },
     GetCounts: function() { return {"Foo": 5}; },
 });
@@ -122 +122 @@
     IsEnemy: function() { return false; },
 });
 
-AddMock(101, IID_BuildLimits, {
+AddMock(101, IID_EntityLimits, {
     GetLimits: function() { return {"Bar": 20}; },
     GetCounts: function() { return {"Bar": 0}; },
 });
@@ -177 +177 @@
             isAlly: [false, false, false],
             isNeutral: [false, false, false],
             isEnemy: [true, true, true],
-            buildLimits: {"Foo": 10},
-            buildCounts: {"Foo": 5},
+            entityLimits: {"Foo": 10},
+            entityCounts: {"Foo": 5},
             techModifications: {},
         },
         {
@@ -197 +197 @@
             isAlly: [true, true, true],
             isNeutral: [false, false, false],
             isEnemy: [false, false, false],
-            buildLimits: {"Bar": 20},
-            buildCounts: {"Bar": 0},
+            entityLimits: {"Bar": 20},
+            entityCounts: {"Bar": 0},
             techModifications: {},
         }
     ],
@@ -224 +224 @@
             isAlly: [false, false, false],
             isNeutral: [false, false, false],
             isEnemy: [true, true, true],
-            buildLimits: {"Foo": 10},
-            buildCounts: {"Foo": 5},
+            entityLimits: {"Foo": 10},
+            entityCounts: {"Foo": 5},
             techModifications: {},
             statistics: {
                 unitsTrained: 10,
@@ -260 +260 @@
             isAlly: [true, true, true],
             isNeutral: [false, false, false],
             isEnemy: [false, false, false],
-            buildLimits: {"Bar": 20},
-            buildCounts: {"Bar": 0},
+            entityLimits: {"Bar": 20},
+            entityCounts: {"Bar": 0},
             techModifications: {},
             statistics: {
                 unitsTrained: 10,

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

@@ -1 @@
-{   
-    "genericName": "Future Alpha",
-    "description": "Temporarily Disable Heroes",
-    "cost": {"food": 0, "wood": 100, "stone": 0, "metal": 0},
-    "requirements": {"tech": "phase_city"},
-    "requirementsTooltip": "Unlocked in City Phase.",
-    "icon": "arrow.png",
-    "researchTime": 20,
-    "tooltip": "Need build limits before renabling this."
-}

binaries/data/mods/public/simulation/helpers/Commands.js

@@ -169 +169 @@
 
     case "train":
         var entities = FilterEntityList(cmd.entities, player, controlAllUnits);
+        
+        // Check entity limits
+        var cmpTempMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
+        var template = cmpTempMan.GetTemplate(cmd.template);
+        var unitCategory = null;
+        if (template.TrainingRestrictions)
+            unitCategory = template.TrainingRestrictions.Category;
+
         // Verify that the building(s) can be controlled by the player
         if (entities.length > 0)
         {
             for each (var ent in entities)
             {
+                if (unitCategory)
+                {
+                    var cmpPlayerEntityLimits = QueryOwnerInterface(ent, IID_EntityLimits);
+                    if (!cmpPlayerEntityLimits.AllowedToTrain(unitCategory, cmd.count))
+                    {
+                        if (g_DebugCommands)
+                        {
+                            warn(unitCategory + " train limit is reached: " + uneval(cmd));
+                        }
+                        continue;
+                    }
+                }
+
                 var cmpTechnologyManager = QueryOwnerInterface(ent, IID_TechnologyManager);
                 // TODO: Enable this check once the AI gets technology support
                 if (cmpTechnologyManager.CanProduce(cmd.template) || true)
@@ -568 +589 @@
         return false;
     }
     
-    // Check build limits
-    var cmpBuildLimits = QueryPlayerIDInterface(player, IID_BuildLimits);
-    if (!cmpBuildLimits || !cmpBuildLimits.AllowedToBuild(cmpBuildRestrictions.GetCategory()))
+    // Check entity limits
+    var cmpEntityLimits = QueryPlayerIDInterface(player, IID_EntityLimits);
+    if (!cmpEntityLimits || !cmpEntityLimits.AllowedToBuild(cmpBuildRestrictions.GetCategory()))
     {
         if (g_DebugCommands)
         {

binaries/data/mods/public/simulation/helpers/Templates.js

@@ +1 @@
+/**
+ * Return template.Identity.Classes._string if exists
+ */
+function GetTemplateIdentityClassesString(template)
+{
+    var identityClassesString = undefined;
+    if (template.Identity && template.Identity.Classes && "_string" in template.Identity.Classes)
+        identityClassesString = template.Identity.Classes._string;
+    return identityClassesString;
+}
+
+/**
+ * Check whether template.Identity.Classes contains specified class
+ */
+function TemplateHasIdentityClass(template, className)
+{
+    var identityClassesString = GetTemplateIdentityClassesString(template);
+    var hasClass = identityClassesString && identityClassesString.indexOf(className) != -1;
+    return hasClass;
+}
+
+Engine.RegisterGlobal("GetTemplateIdentityClassesString", GetTemplateIdentityClassesString);
+Engine.RegisterGlobal("TemplateHasIdentityClass", TemplateHasIdentityClass);
+

binaries/data/mods/public/simulation/templates/special/player.xml

@@ -1 +1 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity>
-  <BuildLimits>
+  <EntityLimits>
     <LimitMultiplier>1.0</LimitMultiplier>
     <Limits>
       <CivilCentre/>
       <DefenseTower>25</DefenseTower>
       <Fortress>10</Fortress>
+      <FemaleCitizen>32</FemaleCitizen>
+      <Hero>1</Hero>
     </Limits>
-  </BuildLimits>
+  </EntityLimits>
   <Player/>
   <StatisticsTracker/>
   <TechnologyManager/>

binaries/data/mods/public/simulation/templates/template_unit_hero.xml

@@ -36 +36 @@
   <Identity>
     <GenericName>Hero</GenericName>
     <Classes datatype="tokens">Hero Organic</Classes>
-    <RequiredTechnology>no_heroes</RequiredTechnology>
   </Identity>
   <Loot>
     <xp>400</xp>
@@ -63 +62 @@
       <death>actor/human/death/death.xml</death>
     </SoundGroups>
   </Sound>
+  <TrainingRestrictions>
+    <Category>Hero</Category>
+  </TrainingRestrictions>
   <UnitMotion>
     <WalkSpeed>9.0</WalkSpeed>
     <Run>

binaries/data/mods/public/simulation/templates/template_unit_hero_cavalry.xml

@@ -40 +40 @@
   <Identity>
     <GenericName>Hero Cavalry</GenericName>
     <Classes datatype="tokens">Hero Cavalry</Classes>
-    <RequiredTechnology>no_heroes</RequiredTechnology>
   </Identity>
   <Loot>
     <xp>500</xp>
@@ -70 +69 @@
   <Stamina>
     <Max>2500</Max>
   </Stamina>
+  <TrainingRestrictions>
+    <Category>Hero</Category>
+  </TrainingRestrictions>
   <UnitMotion>
     <WalkSpeed>11.0</WalkSpeed>
     <Run>

binaries/data/mods/public/simulation/templates/template_unit_hero_cavalry_archer.xml

@@ -49 +49 @@
     <GenericName>Hero Cavalry Archer</GenericName>
     <Tooltip>Hero Aura: n/a.
 Ranged attack 2x vs. spearmen. Ranged attack 1.5x vs. Swordsmen.</Tooltip>
-    <RequiredTechnology>no_heroes</RequiredTechnology>
   </Identity>
   <Loot>
     <xp>450</xp>
@@ -70 +69 @@
       </Texture>
     </Overlay>
   </Selectable>
+  <TrainingRestrictions>
+    <Category>Hero</Category>
+  </TrainingRestrictions>
   <UnitMotion>
     <WalkSpeed>11.0</WalkSpeed>
     <Run>

binaries/data/mods/public/simulation/templates/template_unit_hero_cavalry_javelinist.xml

@@ -39 +39 @@
   <Identity>
     <Classes datatype="tokens">Hero</Classes>
     <GenericName>Hero Cavalry Skirmisher</GenericName>
-    <RequiredTechnology>no_heroes</RequiredTechnology>
   </Identity>
   <Loot>
     <xp>450</xp>
@@ -60 +59 @@
       </Texture>
     </Overlay>
   </Selectable>
+  <TrainingRestrictions>
+    <Category>Hero</Category>
+  </TrainingRestrictions>
   <UnitMotion>
     <WalkSpeed>11.5</WalkSpeed>
     <Run>

binaries/data/mods/public/simulation/templates/template_unit_hero_infantry.xml

@@ -38 +38 @@
   <Identity>
     <Classes datatype="tokens">Hero Infantry</Classes>
     <GenericName>Hero</GenericName>
-    <RequiredTechnology>no_heroes</RequiredTechnology>
   </Identity>
   <Loot>
     <xp>400</xp>
@@ -68 +67 @@
   <Stamina>
     <Max>1500</Max>
   </Stamina>
+  <TrainingRestrictions>
+    <Category>Hero</Category>
+  </TrainingRestrictions>
   <UnitMotion>
     <WalkSpeed>8.5</WalkSpeed>
     <Run>

binaries/data/mods/public/simulation/templates/template_unit_hero_infantry_archer.xml

@@ -41 +41 @@
     <Classes datatype="tokens">Hero</Classes>
     <Tooltip>Hero Archer.
 Counters Swordsmen and Cavalry Spearmen. Countered by Skirmishers and other Cavalry types.</Tooltip>
-    <RequiredTechnology>no_heroes</RequiredTechnology>
   </Identity>
   <Loot>
     <xp>350</xp>
@@ -62 +61 @@
       </Texture>
     </Overlay>
   </Selectable>
+  <TrainingRestrictions>
+    <Category>Hero</Category>
+  </TrainingRestrictions>
 </Entity>

binaries/data/mods/public/simulation/templates/template_unit_hero_infantry_javelinist.xml

@@ -45 +45 @@
   <Identity>
     <Classes datatype="tokens">Hero</Classes>
     <GenericName>Hero Skirmisher</GenericName>
-    <RequiredTechnology>no_heroes</RequiredTechnology>
   </Identity>
   <Loot>
     <xp>350</xp>
@@ -66 +65 @@
       </Texture>
     </Overlay>
   </Selectable>
+  <TrainingRestrictions>
+    <Category>Hero</Category>
+  </TrainingRestrictions>
 </Entity>

binaries/data/mods/public/simulation/templates/template_unit_hero_ranged.xml

@@ -51 +51 @@
       </Texture>
     </Overlay>
   </Selectable>
+  <TrainingRestrictions>
+    <Category>Hero</Category>
+  </TrainingRestrictions>
   <UnitMotion>
     <WalkSpeed>8.5</WalkSpeed>
     <Run>

binaries/data/mods/public/simulation/templates/template_unit_support_female_citizen.xml

@@ -99 +99 @@
   <Stamina>
     <Max>500</Max>
   </Stamina>
+  <TrainingRestrictions>
+    <Category>FemaleCitizen</Category>
+  </TrainingRestrictions>
   <UnitMotion>
     <WalkSpeed>8.0</WalkSpeed>
     <Run>