Ticket #1432: one_hero_2012_10_02_v4.diff

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

@@ -1470 +1470 @@
 
 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});
+    }
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 // Called by GUI when user clicks training button
-function addTrainingToQueue(selection, trainEntType)
+function addTrainingToQueue(selection, trainEntType)
 {
-    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)
         {
@@ -1493 +1545 @@
                 }
             }
             // If we're already creating a batch of this unit (in the same building(s)), then just extend it
+
             if (sameEnts && batchTrainingType == trainEntType)
             {
-                batchTrainingCount += batchIncrementSize;
+                if (canBeTrainedCount !== undefined && canBeTrainedCount > batchTrainingCount * appropriateBuildings.length)
+                    batchTrainingCount += batchIncrementSize;
+                batchTrainingEntityAllowedCount = canBeTrainedCount;
                 return;
             }
             // Otherwise start a new one
@@ -1508 +1563 @@
         inputState = INPUT_BATCHTRAINING;
         batchTrainingEntities = selection;
         batchTrainingType = trainEntType;
+
         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});
     }
 }
 
@@ -1525 +1585 @@
 
 // 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()
 {
+
+
+
+
     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 = batchTrainingEntityAllowedCount % nextBatchTrainingCount;
+    }
+    return [buildingsCountToTrainFullBatch, nextBatchTrainingCount, remainderToTrain];
 }
 
 // Called by GUI when user clicks production queue item

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

@@ -150 +150 @@
  * @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, items, callback)
 {
     usedPanels[guiName] = 1;
 
@@ -347 +347 @@
             case GATE:
                 var tooltip = item.tooltip;
                 if (item.template)
-                {
+                {
                     var template = GetTemplateData(item.template);
-                    tooltip += "\n" + getEntityCostTooltip(template);
-
-                    var affordableMask = getGUIObjectByName("unitGateUnaffordable["+i+"]");
+                    tooltip += "\n" + getEntityCostTooltip(template);
+
+                    var affordableMask = getGUIObjectByName("unitGateUnaffordable["+i+"]");
                     affordableMask.hidden = true;
-
-                    var neededResources = Engine.GuiInterfaceCall("GetNeededResources", template.cost);
-                    if (neededResources)
-                    {
-                        affordableMask.hidden = false;
-                        tooltip += getNeededResourcesTooltip(neededResources);
-                    }
-                }
+
+                    var neededResources = Engine.GuiInterfaceCall("GetNeededResources", template.cost);
+                    if (neededResources)
+                    {
+                        affordableMask.hidden = false;
+                        tooltip += getNeededResourcesTooltip(neededResources);
+                    }
+                }
                 break;
 
             case STANCE:
@@ -374 +374 @@
                 if (template.tooltip)
                     tooltip += "\n[font=\"serif-13\"]" + template.tooltip + "[/font]";
 
-                var [batchSize, batchIncrement] = getTrainingBatchStatus(unitEntState.id, entType);
-                var trainNum = batchSize ? batchSize+batchIncrement : batchIncrement;
+                var [b);
+                var t;
 
                 tooltip += "\n" + getEntityCostTooltip(template);
 
@@ -388 +388 @@
                 if (template.speed)
                     tooltip += "\n" + getEntitySpeed(template);
 
-                tooltip += "\n\n[font=\"serif-bold-13\"]Shift-click[/font][font=\"serif-13\"] to train " + trainNum + ".[/font]";
-
+                if (totalBatchTrainingCount > 0)
+                {
+                    var fullBatchesString = buildingsCountToTrainFullBatch * fullBatchSize > 0 ? buildingsCountToTrainFullBatch + "*" + fullBatchSize : "";
+                    var remainderBatchString = remainderBatch > 0 ? remainderBatch : "";
+                    var batchDetailsString = buildingsCountToTrainFullBatch > 1 || (buildingsCountToTrainFullBatch == 1 && remainderBatch > 0) ?
+                        " (" + [fullBatchesString, remainderBatchString].filter(function(string) { return string != "" }).join(" + ") + ")" :
+                        "";
+                    tooltip += "\n\n[font=\"serif-bold-13\"]Shift-click[/font][font=\"serif-13\"] to train "
+                        + totalBatchTrainingCount + batchDetailsString + ".[/font]";
+                }
                 break;
                 
             case RESEARCH:
@@ -444 +452 @@
         // Button
         var button = getGUIObjectByName("unit"+guiName+"Button["+i+"]");
         var button1 = getGUIObjectByName("unit"+guiName+"Button["+(i+rowLength)+"]");
-        var affordableMask = getGUIObjectByName("unit"+guiName+"Unaffordable["+i+"]");
-        var affordableMask1 = getGUIObjectByName("unit"+guiName+"Unaffordable["+(i+rowLength)+"]");
+        var affordableMask = getGUIObjectByName("unit"+guiName+"Unaffordable["+i+"]");
+        var affordableMask1 = getGUIObjectByName("unit"+guiName+"Unaffordable["+(i+rowLength)+"]");
         var icon = getGUIObjectByName("unit"+guiName+"Icon["+i+"]");
         var selection = getGUIObjectByName("unit"+guiName+"Selection["+i+"]");
         var pair = getGUIObjectByName("unit"+guiName+"Pair["+i+"]");
@@ -540 +548 @@
         {
             icon.sprite = "stretched:session/icons/" + item.icon;
         }
+
+
+
+
+
+
+
+
+
+
+
+
+
         else if (guiName == GATE)
         {
             var gateIcon;
@@ -583 +604 @@
             
             if (guiName == RESEARCH)
             {
-                // Check resource requirements for first button
-                affordableMask.hidden = true;
-                var neededResources = Engine.GuiInterfaceCall("GetNeededResources", template.cost);
-                if (neededResources)
-                {
-                    if (button.enabled !== false)
-                    {
-                        button.enabled = false;
-                        affordableMask.hidden = false;
-                    }
-                    button.tooltip += getNeededResourcesTooltip(neededResources);
-                }
-
+                // Check resource requirements for first button
+                affordableMask.hidden = true;
+                var neededResources = Engine.GuiInterfaceCall("GetNeededResources", template.cost);
+                if (neededResources)
+                {
+                    if (button.enabled !== false)
+                    {
+                        button.enabled = false;
+                        affordableMask.hidden = false;
+                    }
+                    button.tooltip += getNeededResourcesTooltip(neededResources);
+                }
+
                 if (item.pair)
                 {
                     grayscale = "";
                     button1.enabled = true;
-
-                    if (!Engine.GuiInterfaceCall("CheckTechnologyRequirements", entType1))
+
+                    if (!Engine.GuiInterfaceCall("CheckTechnologyRequirements", entType1))
                     {
                         button1.enabled = false;
                         button1.tooltip += "\n" + GetTechnologyData(entType1).requirementsTooltip;
                         grayscale = "grayscale:";
                     }
                     icon1.sprite = "stretched:" + grayscale + "session/portraits/" +template1.icon;
-
-                    // Check resource requirements for second button
-                    affordableMask1.hidden = true;
-                    neededResources = Engine.GuiInterfaceCall("GetNeededResources", template.cost);
-                    if (neededResources)
-                    {
-                        if (button1.enabled !== false)
-                        {
-                            button1.enabled = false;
-                            affordableMask1.hidden = false;
-                        }
-                        button1.tooltip += getNeededResourcesTooltip(neededResources);
-                    }
+
+                    // Check resource requirements for second button
+                    affordableMask1.hidden = true;
+                    neededResources = Engine.GuiInterfaceCall("GetNeededResources", template.cost);
+                    if (neededResources)
+                    {
+                        if (button1.enabled !== false)
+                        {
+                            button1.enabled = false;
+                            affordableMask1.hidden = false;
+                        }
+                        button1.tooltip += getNeededResourcesTooltip(neededResources);
+                    }
                 }
                 else
                 {
                     pair.hidden = true;
                     button1.hidden = true;
-                    affordableMask1.hidden = true;
-                }
-            }
-            else if (guiName == CONSTRUCTION || guiName == TRAINING)
-            {
-                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;
+                    affordableMask1.hidden = true;
+                }
+            }
+            else if (guiName == CONSTRUCTION || guiName == TRAINING)
+            {
+                affordableMask.hidden = true;
+                var totalCosts = {};
+                var trainNum = 1;
+                if (Engine.HotkeyIsPressed("session.batchtrain") && guiName == TRAINING)
+                {
+                    var [b);
+                    trainNum = b;
                 }
-
-                // Walls have no cost defined.
+
+                // Walls have no cost defined.
                 if (template.cost !== undefined)
                     for (var r in template.cost)
                         totalCosts[r] = Math.floor(template.cost[r] * trainNum);
-
-                var neededResources = Engine.GuiInterfaceCall("GetNeededResources", totalCosts);
-                if (neededResources)
+
+                var neededResources = Engine.GuiInterfaceCall("GetNeededResources", totalCosts);
+                if (neededResources)
                 {
-                    var totalCost = 0;
-                    if (button.enabled !== false)
+                    var totalCost = 0;
+                    if (button.enabled !== false)
                     {
                         for each (var resource in neededResources)
                             totalCost += resource;
-
-                        button.enabled = false;
-                        affordableMask.hidden = false;
-                        var alpha = 75 + totalCost/6;
-                        alpha = alpha > 150 ? 150 : alpha;
-                        affordableMask.sprite = "colour: 255 0 0 " + (alpha);
-                    }
-                    button.tooltip += getNeededResourcesTooltip(neededResources);
-                }
+
+                        button.enabled = false;
+                        affordableMask.hidden = false;
+                        var alpha = 75 + totalCost/6;
+                        alpha = alpha > 150 ? 150 : alpha;
+                        affordableMask.sprite = "colour: 255 0 0 " + (alpha);
+                    }
+                    button.tooltip += getNeededResourcesTooltip(neededResources);
+                }
             }
         }
         else
@@ -767 +788 @@
 }
 
 // Sets up "unit barter panel" - special case for setupUnitPanel
-function setupUnitBarterPanel(unitEntState)
+function setupUnitBarterPanel(unitEntState)
 {
     // Amount of player's resource to exchange
     var amountToSell = BARTER_RESOURCE_AMOUNT_TO_SELL;
@@ -862 +883 @@
     var player = Engine.GetPlayerID();
     if (entState.player == player || g_DevSettings.controlAll)
     {
+
+
+
+
+
         if (selection.length > 1)
-            setupUnitPanel(SELECTION, usedPanels, entState, g_Selection.groups.getTemplateNames(),
+            setupUnitPanel(SELECTION, usedPanels, entState, g_Selection.groups.getTemplateNames(),
                 function (entType) { changePrimarySelectionGroup(entType); } );
 
         var commands = getEntityCommandsList(entState);
         if (commands.length)
-            setupUnitPanel(COMMAND, usedPanels, entState, commands,
+            setupUnitPanel(COMMAND, usedPanels, entState, commands,
                 function (item) { performCommand(entState.id, item.name); } );
 
         if (entState.garrisonHolder)
@@ -881 +907 @@
                     groups.add(state.garrisonHolder.entities)
             }
 
-            setupUnitPanel(GARRISON, usedPanels, entState, groups.getTemplateNames(),
+            setupUnitPanel(GARRISON, usedPanels, entState, 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, formations,
                 function (item) { performFormation(entState.id, item); } );
         }
 
@@ -897 +923 @@
         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, stances,
                 function (item) { performStance(entState.id, item); } );
         }
 
@@ -905 +931 @@
         if (entState.barterMarket)
         {
             usedPanels["Barter"] = 1;
-            setupUnitBarterPanel(entState);
+            setupUnitBarterPanel(entState);
         }
 
         var buildableEnts = [];
@@ -929 +955 @@
 
         // The first selected entity's type has priority.
         if (entState.buildEntities)
-            setupUnitPanel(CONSTRUCTION, usedPanels, entState, buildableEnts, startBuildingPlacement);
+            setupUnitPanel(CONSTRUCTION, usedPanels, entState, buildableEnts, startBuildingPlacement);
         else if (entState.production && entState.production.entities)
-            setupUnitPanel(TRAINING, usedPanels, entState, trainableEnts,
-                function (trainEntType) { addTrainingToQueue(selection, trainEntType); } );
+            setupUnitPanel(TRAINING, usedPanels, entState, trainableEnts,
+                function (trainEntType) { addTrainingToQueue(selection, trainEntType); } );
         else if (entState.trader)
             setupUnitTradingPanel(usedPanels, entState, selection);
         else if (!entState.foundation && entState.gate || hasClass(entState, "LongWall"))
@@ -994 +1020 @@
                 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); } );
         }
 
         // Show technologies if the active panel has at most one row of icons.
@@ -1007 +1033 @@
         }
 
         if (entState.production && entState.production.queue.length)
-            setupUnitPanel(QUEUE, usedPanels, entState, entState.production.queue,
+            setupUnitPanel(QUEUE, usedPanels, entState, 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()
+    getLimits: function()
     {
-        return this.playerData.buildLimits;
+        return this.playerData.Limits;
     },
     
     /**
      * Returns player build counts
      * an object where each key is a category corresponding to the current building count for the player.
      */
-    getBuildCounts: function()
+    getCounts: function()
     {
-        return this.playerData.buildCounts;
+        return this.playerData.Counts;
     },
     
     /**
      * 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)
+    isLimitReached: function(category)
     {
-        if (this.playerData.buildLimits[category] === undefined || this.playerData.buildCounts[category] === undefined)
+        if (this.playerData.Counts[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.Limits[category].LimitPerCivCentre !== undefined)
+            return (this.playerData.Limits[category].LimitPerCivCentre);
         else
-            return (this.playerData.buildCounts[category] >= this.playerData.buildLimits[category]);
+            return (this.playerData.Limits[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.getLimits = function() {
+    return this.playerData.Limits;
 };
 
-GameState.prototype.getBuildCounts = function() {
-    return this.playerData.buildCounts;
+GameState.prototype.getCounts = function() {
+    return this.playerData.Counts;
 };
 
 // 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.isLimitReached = function(category) {
+    if(this.playerData.Counts[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.Limits[category].LimitsPerCivCentre != undefined)
+        return (this.playerData.Limits[category].LimitPerCivCentre);
     else
-        return (this.playerData.buildCounts[category] >= this.playerData.buildLimits[category]);
+        return (this.playerData.Limits[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.getLimits()["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.getLimits()["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()
+    getLimits: function()
     {
-        return this.playerData.buildLimits;
+        return this.playerData.Limits;
     },
     
     /**
-     * Returns player build counts
-     * an object where each key is a category corresponding to the current building count for the player.
+     * Returns player  counts
+     * an object where each key is a category corresponding to the current  count for the player.
      */
-    getBuildCounts: function()
+    getCounts: function()
     {
-        return this.playerData.buildCounts;
+        return this.playerData.Counts;
     },
     
     /**
-     * Checks if the player's build limit has been reached for the given category.
+     * Checks if the player's  limit has been reached for the given category.
      * The category comes from the entity tenplate, specifically the BuildRestrictions component.
      */
-    isBuildLimitReached: function(category)
+    isLimitReached: function(category)
     {
-        if (this.playerData.buildLimits[category] === undefined || this.playerData.buildCounts[category] === undefined)
+        if (this.playerData.Counts[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.Limits[category].LimitPerCivCentre !== undefined)
+            return (this.playerData.Limits[category].LimitPerCivCentre);
         else
-            return (this.playerData.buildCounts[category] >= this.playerData.buildLimits[category]);
+            return (this.playerData.Limits[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 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

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 cmpPlayerLimits);
         var cmpPlayer = Engine.QueryInterface(playerEnt, IID_Player);
         
         // Work out what phase we are in
@@ -84 +84 @@
             "phase": phase,
             "isAlly": allies,
             "isEnemy": enemies,
-            "buildLimits": cmpPlayerBuildLimits.GetLimits(),
-            "buildCounts": cmpPlayerBuildLimits.GetCounts(),
+            "Limits.GetLimits(),
+            "Limits.GetCounts(),
             "techModifications": cmpTechnologyManager.GetTechModifications()
         };
         ret.players.push(playerData);
@@ -380 +380 @@
             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 = {};
@@ -449 +456 @@
         ret.icon = template.Identity.Icon;
         ret.tooltip =  template.Identity.Tooltip;
         ret.requiredTechnology = template.Identity.RequiredTechnology;
+
     }
 
     if (template.UnitMotion)

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

@@ -358 +358 @@
 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--;   
-
+            this.conquestCriticalEntitiesCount--;
         var cost = Engine.QueryInterface(msg.entity, IID_Cost);
         if (cost)
         {
@@ -382 +378 @@
             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;
 
+
+
+
+
+
+
+
+
             this.queue.push({
                 "id": this.nextID++,
                 "player": cmpPlayer.GetPlayerID(),
@@ -307 +315 @@
         
         var cmpPlayer = QueryPlayerIDInterface(item.player, IID_Player);
 
+
+
+
+
+
+
+
+
+
+
+
+
+
         // 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 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

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 @@
+

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

@@ +1 @@
+
+

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/Foundation.js");
 Engine.LoadComponentScript("interfaces/GarrisonHolder.js");
 Engine.LoadComponentScript("interfaces/Gate.js");
@@ -67 +67 @@
     IsEnemy: function() { return true; },
 });
 
-AddMock(100, IID_BuildLimits, {
+AddMock(100, IID_Limits, {
     GetLimits: function() { return {"Foo": 10}; },
     GetCounts: function() { return {"Foo": 5}; },
 });
@@ -118 +118 @@
     IsEnemy: function() { return false; },
 });
 
-AddMock(101, IID_BuildLimits, {
+AddMock(101, IID_Limits, {
     GetLimits: function() { return {"Bar": 20}; },
     GetCounts: function() { return {"Bar": 0}; },
 });
@@ -171 +171 @@
             phase: "",
             isAlly: [false, false, false],
             isEnemy: [true, true, true],
-            buildLimits: {"Foo": 10},
-            buildCounts: {"Foo": 5},
+            Limits: {"Foo": 10},
+            Counts: {"Foo": 5},
             techModifications: {},
         },
         {
@@ -189 +189 @@
             phase: "village",
             isAlly: [true, true, true],
             isEnemy: [false, false, false],
-            buildLimits: {"Bar": 20},
-            buildCounts: {"Bar": 0},
+            Limits: {"Bar": 20},
+            Counts: {"Bar": 0},
             techModifications: {},
         }
     ],
@@ -214 +214 @@
             phase: "",
             isAlly: [false, false, false],
             isEnemy: [true, true, true],
-            buildLimits: {"Foo": 10},
-            buildCounts: {"Foo": 5},
+            Limits: {"Foo": 10},
+            Counts: {"Foo": 5},
             techModifications: {},
             statistics: {
                 unitsTrained: 10,
@@ -248 +248 @@
             phase: "village",
             isAlly: [true, true, true],
             isEnemy: [false, false, false],
-            buildLimits: {"Bar": 20},
-            buildCounts: {"Bar": 0},
+            Limits: {"Bar": 20},
+            Counts: {"Bar": 0},
             techModifications: {},
             statistics: {
                 unitsTrained: 10,

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

@@ -146 +146 @@
 
     case "train":
         var entities = FilterEntityList(cmd.entities, player, controlAllUnits);
+
+
+
+
+
+
+
+
         // Verify that the building(s) can be controlled by the player
         if (entities.length > 0)
         {
             for each (var ent in entities)
             {
+
+
+
+
+
+
+
+
+
+
+
+
+
                 var cmpTechnologyManager = QueryOwnerInterface(ent, IID_TechnologyManager);
                 // TODO: Enable this check once the AI gets technology support
                 if (cmpTechnologyManager.CanProduce(cmd.template) || true)
@@ -545 +566 @@
         return false;
     }
     
-    // Check build limits
-    var cmpBuildLimits = QueryPlayerIDInterface(player, IID_BuildLimits);
-    if (!cmpBuildLimits || !cmpBuildLimits.AllowedToBuild(cmpBuildRestrictions.GetCategory()))
+    // Check  limits
+    var cmpLimits);
+    if (!cmpLimits.AllowedToBuild(cmpBuildRestrictions.GetCategory()))
     {
         if (g_DebugCommands)
   ��     {

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

@@ +1 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

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

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

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

@@ -63 +63 @@
       <death>actor/human/death/death.xml</death>
     </SoundGroups>
   </Sound>
+
+
+
   <UnitMotion>
     <WalkSpeed>9.0</WalkSpeed>
     <Run>

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

@@ -70 +70 @@
   <Stamina>
     <Max>2500</Max>
   </Stamina>
+
+
+
   <UnitMotion>
     <WalkSpeed>11.0</WalkSpeed>
     <Run>

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

@@ -70 +70 @@
       </Texture>
     </Overlay>
   </Selectable>
+
+
+
   <UnitMotion>
     <WalkSpeed>11.0</WalkSpeed>
     <Run>

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

@@ -60 +60 @@
       </Texture>
     </Overlay>
   </Selectable>
+
+
+
   <UnitMotion>
     <WalkSpeed>11.5</WalkSpeed>
     <Run>

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

@@ -68 +68 @@
   <Stamina>
     <Max>1500</Max>
   </Stamina>
+
+
+
   <UnitMotion>
     <WalkSpeed>8.5</WalkSpeed>
     <Run>

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

@@ -62 +62 @@
       </Texture>
     </Overlay>
   </Selectable>
+
+
+
 </Entity>

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

@@ -66 +66 @@
       </Texture>
     </Overlay>
   </Selectable>
+
+
+
 </Entity>

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

@@ -51 +51 @@
       </Texture>
     </Overlay>
   </Selectable>
+
+
+
   <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>
+
+
+
   <UnitMotion>
     <WalkSpeed>8.0</WalkSpeed>
     <Run>