Changeset 13907 for ps

Timestamp:

09/29/13 15:32:52 (11 years ago)

Author:

wraitii

Message:

New version of Aegis. Huge rewrite for WIP naval support (still very, very buggy at this point.) Features a few bugfixes and might be more efficient than the former version.

NEEDS TESTING.

Location:

ps/trunk/binaries/data/mods/public/simulation/ai

Files:

• aegis/aegis.js (modified) (14 diffs)
• aegis/attack_plan.js (modified) (35 diffs)
• aegis/base-manager.js (added)
• aegis/config.js (modified) (3 diffs)
• aegis/data.json (modified) (1 diff)
• aegis/defence.js (modified) (15 diffs)
• aegis/economy.js (deleted)
• aegis/enemy-watcher.js (modified) (1 diff)
• aegis/entitycollection-extend.js (modified) (1 diff)
• aegis/headquarters.js (added)
• aegis/map-module.js (modified) (9 diffs)
• aegis/military.js (deleted)
• aegis/naval-manager.js (added)
• aegis/plan-building.js (deleted)
• aegis/plan-research.js (deleted)
• aegis/plan-training.js (deleted)
• aegis/plan-transport.js (added)
• aegis/queue-manager.js (modified) (9 diffs)
• aegis/queue.js (modified) (7 diffs)
• aegis/queueplan-building.js (added)
• aegis/queueplan-research.js (added)
• aegis/queueplan-training.js (added)
• aegis/worker.js (modified) (29 diffs)
• common-api-v3/base.js (modified) (3 diffs)
• common-api-v3/entity.js (modified) (9 diffs)
• common-api-v3/entitycollection.js (modified) (12 diffs)
• common-api-v3/filters.js (modified) (5 diffs)
• common-api-v3/gamestate.js (modified) (10 diffs)
• common-api-v3/map-module.js (modified) (9 diffs)
• common-api-v3/shared.js (modified) (10 diffs)
• common-api-v3/terrain-analysis.js (modified) (10 diffs)

ps/trunk/binaries/data/mods/public/simulation/ai/aegis/aegis.js

@@ -1 @@
-function QBotAI(settings) {
+// "local" global variables for stuffs that will need a unique ID
+// Note that since order of loading is alphabetic, this means this file must go before any other file using them.
+var uniqueIDBOPlans = 0;    // training/building/research plans
+var uniqueIDBases = 1;  // base manager ID. Starts at one because "0" means "no base" on the map
+var uniqueIDTPlans = 1; // transport plans. starts at 1 because 0 might be used as none.
+
+function AegisBot(settings) {
     BaseAI.call(this, settings);
 
@@ -7 +13 @@
 
     this.playedTurn = 0;
-
-    this.modules = {
-            "economy": new EconomyManager(), 
-            "military": new MilitaryAttackManager()
-    };
+        
+    this.priorities = Config.priorities;
 
     // this.queues can only be modified by the queue manager or things will go awry.
-    this.queues = {
-        house : new Queue(),
-        citizenSoldier : new Queue(),
-        villager : new Queue(),
-        economicBuilding : new Queue(),
-        dropsites : new Queue(),
-        field : new Queue(),
-        militaryBuilding : new Queue(),
-        defenceBuilding : new Queue(),
-        civilCentre: new Queue(),
-        majorTech: new Queue(),
-        minorTech: new Queue()
-    };
-    
-    this.productionQueues = [];
-    
-    this.priorities = Config.priorities;
-    
+    this.queues = {};
+    for (i in this.priorities)
+        this.queues[i] = new Queue();
+
     this.queueManager = new QueueManager(this.queues, this.priorities);
-    
+
+    this.HQ = new HQ();
+
     this.firstTime = true;
 
     this.savedEvents = [];
-    
-    this.waterMap = false;
     
     this.defcon = 5;
@@ -44 +33 @@
 }
 
-QBotAI.prototype = new BaseAI();
-
-// Bit of a hack: I run the pathfinder early, before the map apears, to avoid a sometimes substantial lag right at the start.
-QBotAI.prototype.InitShared = function(gameState, sharedScript) {
+AegisBot.prototype = new BaseAI();
+
+AegisBot.prototype.InitShared = function(gameState, sharedScript) {
+    
+    this.HQ.init(gameState,sharedScript.events,this.queues);
+    debug ("Initialized with the difficulty " + Config.difficulty);
+
     var ents = gameState.getEntities().filter(Filters.byOwner(PlayerID));
     var myKeyEntities = ents.filter(function(ent) {
@@ -64 +56 @@
     }
 
+    this.myIndex = this.accessibility.getAccessValue(myKeyEntities.toEntityArray()[0].position());
+    
     this.pathFinder = new aStarPath(gameState, false, true);
     this.pathsToMe = [];
@@ -83 +77 @@
 
     this.pathInfo.angle += Math.PI/3.0;
-}
-
-//Some modules need the gameState to fully initialise
-QBotAI.prototype.runInit = function(gameState, events){
 
     this.chooseRandomStrategy();
-
-    for (var i in this.modules){
-        if (this.modules[i].init){
-            this.modules[i].init(gameState, events);
-        }
-    }
-    debug ("Inited, diff is " + Config.difficulty);
-    this.timer = new Timer();
-    
-    
-    var ents = gameState.getOwnEntities();
-    var myKeyEntities = gameState.getOwnEntities().filter(function(ent) {
-                                                          return ent.hasClass("CivCentre");
-                                                          });
-    
-    if (myKeyEntities.length == 0){
-        myKeyEntities = gameState.getOwnEntities();
-    }
-    
-    // disband the walls themselves
-    if (gameState.playerData.civ == "iber") {
-        gameState.getOwnEntities().filter(function(ent) { //}){
-                                          if (ent.hasClass("StoneWall") && !ent.hasClass("Tower"))
-                                          ent.destroy();
-                                          });
-    }
-    
-    var filter = Filters.byClass("CivCentre");
-    var enemyKeyEntities = gameState.getEnemyEntities().filter(filter);
-    
-    if (enemyKeyEntities.length == 0){
-        enemyKeyEntities = gameState.getEnemyEntities();
-    }
-    
-    //this.accessibility = new Accessibility(gameState, myKeyEntities.toEntityArray()[0].position());
-    
-    this.myIndex = this.accessibility.getAccessValue(myKeyEntities.toEntityArray()[0].position());
-    
-    if (enemyKeyEntities.length == 0)
-        return;
-        
-    this.templateManager = new TemplateManager(gameState);
-};
-
-QBotAI.prototype.OnUpdate = function(sharedScript) {
+}
+
+AegisBot.prototype.OnUpdate = function(sharedScript) {
     if (this.gameFinished){
         return;
     }
     
-    if (this.events.length > 0){
+    if (this.events.length > 0 && this.turn !== 0){
         this.savedEvents = this.savedEvents.concat(this.events);
     }
     
     
-    
     // Run the update every n turns, offset depending on player ID to balance the load
-    // this also means that init at turn 0 always happen and is never run in parallel to the first played turn so I use an else if.
-    if (this.turn == 0) {
-        
-        //Engine.DumpImage("terrain.png", this.accessibility.map, this.accessibility.width,this.accessibility.height,255)
-        //Engine.DumpImage("Access.png", this.accessibility.passMap, this.accessibility.width,this.accessibility.height,this.accessibility.regionID+1)
-
-        var gameState = sharedScript.gameState[PlayerID];
-        gameState.ai = this;
-        
-        this.runInit(gameState, this.savedEvents);
-        
-        // Delete creation events
-        delete this.savedEvents;
-        this.savedEvents = [];
-    } else if ((this.turn + this.player) % 8 == 5) {
-        
-        Engine.ProfileStart("Aegis bot");
+    if ((this.turn + this.player) % 8 == 5) {
+        
+        Engine.ProfileStart("Aegis bot (player " + this.player +")");
         
         this.playedTurn++;
         
-        var gameState = sharedScript.gameState[PlayerID];
-        gameState.ai = this;
-        
-        if (gameState.getOwnEntities().length === 0){
+        if (this.gameState.getOwnEntities().length === 0){
             Engine.ProfileStop();
             return; // With no entities to control the AI cannot do anything 
@@ -176 +106 @@
         {
             var pos = [this.pathInfo.mkeyPos[0] + 150*Math.cos(this.pathInfo.angle),this.pathInfo.mkeyPos[1] + 150*Math.sin(this.pathInfo.angle)];
-            var path = this.pathFinder.getPath(this.pathInfo.ekeyPos, pos, 6, 5);// uncomment for debug:*/, 300000, gameState);
+            var path = this.pathFinder.getPath(this.pathInfo.ekeyPos, pos, 6, 5);// uncomment for debug:*/, 300000, this.gameState);
             if (path !== undefined && path[1] !== undefined && path[1] == false) {
                 // path is viable and doesn't require boating.
@@ -192 +122 @@
                 {
                     debug ("Assuming this is a water map");
-                    this.waterMap = true;
+                    this.HQ.waterMap = true;
                 }
                 delete this.pathFinder;
@@ -199 +129 @@
         }
         
-        var sfx = "_generic";
-        if (gameState.civ() == "athen")
-            sfx = "_athen"
-
+        var townPhase = this.gameState.townPhase();
+        var cityPhase = this.gameState.cityPhase();
         // try going up phases.
-        if (gameState.canResearch("phase_town" + sfx,true) && gameState.getTimeElapsed() > (Config.Economy.townPhase*1000)
-            && gameState.findResearchers("phase_town" + sfx,true).length != 0 && this.queues.majorTech.totalLength() === 0) {
-            this.queues.majorTech.addItem(new ResearchPlan(gameState, "phase_town" + sfx,true));    // we rush the town phase.
+        // TODO: softcode this.
+        if (this.gameState.canResearch(townPhase,true) && this.gameState.getTimeElapsed() > (Config.Economy.townPhase*1000) && this.gameState.getPopulation() > 40
+            && this.gameState.findResearchers(townPhase,true).length != 0 && this.queues.majorTech.length() === 0
+            && this.gameState.getOwnEntities().filter(Filters.byClass("Village")).length > 5)
+        {
+            this.queueManager.pauseQueue("villager", true);
+            this.queueManager.pauseQueue("citizenSoldier", true);
+            this.queueManager.pauseQueue("house", true);
+            this.queues.majorTech.addItem(new ResearchPlan(this.gameState, townPhase,0,-1,true));   // we rush the town phase.
             debug ("Trying to reach town phase");
-            var nb = gameState.getOwnEntities().filter(Filters.byClass("Village")).length-1;
-            if (nb < 5)
-            {
-                while (nb < 5 && ++nb)
-                    this.queues.house.addItem(new BuildingConstructionPlan(gameState, "structures/{civ}_house"));
-            }
-        } else if (gameState.canResearch("phase_city_generic",true) && gameState.getTimeElapsed() > (Config.Economy.cityPhase*1000)
-                && gameState.getOwnEntitiesByRole("worker").length > 85
-                && gameState.findResearchers("phase_city_generic", true).length != 0 && this.queues.majorTech.totalLength() === 0) {
+        }
+        else if (this.gameState.canResearch(cityPhase,true) && this.gameState.getTimeElapsed() > (Config.Economy.cityPhase*1000)
+                && this.gameState.getOwnEntitiesByRole("worker").length > 85
+                && this.gameState.findResearchers(cityPhase, true).length != 0 && this.queues.majorTech.length() === 0) {
             debug ("Trying to reach city phase");
-            this.queues.majorTech.addItem(new ResearchPlan(gameState, "phase_city_generic"));
+            this.queues.majorTech.addItem(new ResearchPlan(this.gameState, cityPhase));
         }
         // defcon cooldown
-        if (this.defcon < 5 && gameState.timeSinceDefconChange() > 20000)
+        if (this.defcon < 5 && this.gameState.timeSinceDefconChange() > 20000)
         {
             this.defcon++;
             debug ("updefconing to " +this.defcon);
-            if (this.defcon >= 4 && this.modules.military.hasGarrisonedFemales)
-                this.modules.military.ungarrisonAll(gameState);
-        }
-        
-        for (var i in this.modules){
-            this.modules[i].update(gameState, this.queues, this.savedEvents);
-        }
-        
-        this.queueManager.update(gameState);
-        
+            if (this.defcon >= 4 && this.HQ.hasGarrisonedFemales)
+                this.HQ.ungarrisonAll(this.gameState);
+        }
+        
+        this.HQ.update(this.gameState, this.queues, this.savedEvents);
+
+        this.queueManager.update(this.gameState);
+
         /*
          // Use this to debug informations about the metadata.
@@ -240 +167 @@
         {
             // some debug informations about units.
-            var units = gameState.getOwnEntities();
+            var units = this.gameState.getOwnEntities();
             for (var i in units._entities)
             {
@@ -266 +193 @@
             
         //if (this.playedTurn % 5 === 0)
-        //  this.queueManager.printQueues(gameState);
+        //  this.queueManager.printQueues(this.gameState);
         
         // Generate some entropy in the random numbers (against humans) until the engine gets random initialised numbers
@@ -284 +211 @@
 };
 
-QBotAI.prototype.chooseRandomStrategy = function()
+AegisBot.prototype.chooseRandomStrategy = function()
 {
     // deactivated for now.
@@ -293 +220 @@
         this.strategy = "rush";
         // going to rush.
-        this.modules.economy.targetNumWorkers = 0;
+        this.HQ.targetNumWorkers = 0;
         Config.Economy.townPhase = 480;
         Config.Economy.cityPhase = 900;
@@ -303 +230 @@
 // TODO: Remove override when the whole AI state is serialised
 // TODO: this currently is very much equivalent to "rungamestateinit" with a few hacks. Should deserialize/serialize properly someday.
-QBotAI.prototype.Deserialize = function(data, sharedScript)
+AegisBot.prototype.Deserialize = function(data, sharedScript)
 {
     BaseAI.prototype.Deserialize.call(this, data);
@@ -346 +273 @@
 
 // Override the default serializer
-QBotAI.prototype.Serialize = function()
+AegisBot.prototype.Serialize = function()
 {
     //var ret = BaseAI.prototype.Serialize.call(this);

ps/trunk/binaries/data/mods/public/simulation/ai/aegis/attack_plan.js

@@ -7 +7 @@
  */
 
-function CityAttack(gameState, militaryManager, uniqueID, targetEnemy, type , targetFinder) {
+function CityAttack(gameState, HQ, uniqueID, targetEnemy, type , targetFinder) {
     
     //This is the list of IDs of the units in the plan
@@ -331 +331 @@
 // Three returns possible: 1 is "keep going", 0 is "failed plan", 2 is "start"
 // 3 is a special case: no valid path returned. Right now I stop attacking alltogether.
-CityAttack.prototype.updatePreparation = function(gameState, militaryManager,events) {
+CityAttack.prototype.updatePreparation = function(gameState, HQ,events) {
     var self = this;
     
@@ -338 +338 @@
         if (this.target == undefined)
         {
-            var targets = this.targetFinder(gameState, militaryManager);
+            var targets = this.targetFinder(gameState, HQ);
             if (targets.length === 0)
-                targets = this.defaultTargetFinder(gameState, militaryManager);
+                targets = this.defaultTargetFinder(gameState, HQ);
                 
             if (targets.length !== 0) {
@@ -366 +366 @@
         // It will probably carry over a few turns but that's no issue.
         if (this.path === undefined)
-            this.path = this.pathFinder.getPath(this.rallyPoint,this.targetPos, this.pathSampling, this.pathWidth,250);//,gameState);
+            this.path = this.pathFinder.getPath(this.rallyPoint,this.targetPos, this.pathSampling, this.pathWidth,175);//,gameState);
         else if (this.path === "toBeContinued")
             this.path = this.pathFinder.continuePath();//gameState);
@@ -384 +384 @@
             // okay so we need a ship.
             // Basically we'll add it as a new class to train compulsorily, and we'll recompute our path.
-            if (!gameState.ai.waterMap)
+            if (!gameState.ai.HQ.waterMap)
             {
                 debug ("This is actually a water map.");
-                gameState.ai.waterMap = true;
+                gameState.ai.HQ.waterMap = true;
+                return 0;
             }
             debug ("We need a ship.");
-            var stat = { "priority" : 1.1, "minSize" : 2, "targetSize" : 2, "batchSize" : 1, "classes" : ["Warship"],
-                "interests" : [ ["strength",1], ["cost",1] ]  ,"templates" : [] };
-            if (type === "superSized") {
-                this.unitStat["TransportShip"]["minSize"] = 4;
-                this.unitStat["TransportShip"]["targetSize"] = 4;
-            }
-            this.addBuildOrder(gameState, "TransportShip", stat);
             this.needsShip = true;
             this.pathWidth = 3;
@@ -415 +409 @@
                     else
                         this.rallyPoint = this.path[0][0];
+                    if (i >= 1)
+                        this.path.splice(0,i-1);
                     break;
                 }
@@ -474 +470 @@
         // We still have time left to recruit units and do stuffs.
         
-        // TODO: check why this can happen instead of resorting to this "hack".
-        if (this.buildOrder.length === 0 || this.buildOrder[0] === undefined) {
-            debug ("Ending plan: no build orders");
-            return 0;   // will abort the plan, should return something else
-        }
-
-        
         // let's sort by training advancement, ie 'current size / target size'
         // count the number of queued units too.
@@ -486 +475 @@
         this.buildOrder.sort(function (a,b) { //}) {
             var aQueued = gameState.countOwnQueuedEntitiesWithMetadata("special","Plan_"+self.name+"_"+a[4]);
-            aQueued += self.queue.countTotalQueuedUnitsWithMetadata("special","Plan_"+self.name+"_"+a[4]);
-            aQueued += self.queueChamp.countTotalQueuedUnitsWithMetadata("special","Plan_"+self.name+"_"+a[4]);
+            aQueued += self.queue.countQueuedUnitsWithMetadata("special","Plan_"+self.name+"_"+a[4]);
+            aQueued += self.queueChamp.countQueuedUnitsWithMetadata("special","Plan_"+self.name+"_"+a[4]);
             a[0] = (a[2].length + aQueued)/a[3]["targetSize"];
                              
             var bQueued = gameState.countOwnQueuedEntitiesWithMetadata("special","Plan_"+self.name+"_"+b[4]);
-            bQueued += self.queue.countTotalQueuedUnitsWithMetadata("special","Plan_"+self.name+"_"+b[4]);
-            bQueued += self.queueChamp.countTotalQueuedUnitsWithMetadata("special","Plan_"+self.name+"_"+b[4]);
+            bQueued += self.queue.countQueuedUnitsWithMetadata("special","Plan_"+self.name+"_"+b[4]);
+            bQueued += self.queueChamp.countQueuedUnitsWithMetadata("special","Plan_"+self.name+"_"+b[4]);
             b[0] = (b[2].length + bQueued)/b[3]["targetSize"];
                              
@@ -513 +502 @@
         var inTraining = gameState.countOwnQueuedEntitiesWithMetadata("special",specialData);
                 
-        var queued = this.queue.countTotalQueuedUnitsWithMetadata("special",specialData) + this.queueChamp.countTotalQueuedUnitsWithMetadata("special",specialData)
+        var queued = this.queue.countQueuedUnitsWithMetadata("special",specialData) + this.queueChamp.countQueuedUnitsWithMetadata("special",specialData)
         
         if (queued + inTraining + this.buildOrder[0][2].length <= this.buildOrder[0][3]["targetSize"]) {
@@ -522 +511 @@
             
             if (this.buildOrder[0][0] < 1 && queue.length() <= 5) {
-                var template = militaryManager.findBestTrainableUnit(gameState, this.buildOrder[0][1], this.buildOrder[0][3]["interests"] );
+                var template = HQ.findBestTrainableSoldier(gameState, this.buildOrder[0][1], this.buildOrder[0][3]["interests"] );
                 //debug ("tried " + uneval(this.buildOrder[0][1]) +", and " + template);
                 // HACK (TODO replace) : if we have no trainable template... Then we'll simply remove the buildOrder, effectively removing the unit from the plan.
                 if (template === undefined) {
                     // TODO: this is a complete hack.
-                    if (this.needsShip && this.buildOrder[0][4] == "TransportShip") {
-                        Engine.ProfileStop();
-                        Engine.ProfileStop();
-                        return 0;
-                    }
                     delete this.unitStat[this.buildOrder[0][4]];    // deleting the associated unitstat.
                     this.buildOrder.splice(0,1);
@@ -539 +523 @@
                     if (gameState.getTimeElapsed() > 1800000)
                         max *= 2;
-                    if (gameState.getTemplate(template).hasClasses(["CitizenSoldier", "Infantry"]))
-                        queue.addItem( new UnitTrainingPlan(gameState,template, { "role" : "worker", "plan" : this.name, "special" : specialData }, this.buildOrder[0][3]["batchSize"],max ) );
+                    if (gameState.getTemplate(template).hasClass("CitizenSoldier"))
+                        queue.addItem( new TrainingPlan(gameState,template, { "role" : "worker", "plan" : this.name, "special" : specialData, "base" : 1 }, this.buildOrder[0][3]["batchSize"],max ) );
                     else
-                        queue.addItem( new UnitTrainingPlan(gameState,template, { "role" : "attack", "plan" : this.name, "special" : specialData }, this.buildOrder[0][3]["batchSize"],max ) );
+                        queue.addItem( new TrainingPlan(gameState,template, { "role" : "attack", "plan" : this.name, "special" : specialData, "base" : 1 }, this.buildOrder[0][3]["batchSize"],max ) );
                 }
             }
@@ -550 +534 @@
             
             // find our target
-            var targets = this.targetFinder(gameState, militaryManager);
+            var targets = this.targetFinder(gameState, HQ);
             if (targets.length === 0){
-                targets = this.defaultTargetFinder(gameState, militaryManager);
+                targets = this.defaultTargetFinder(gameState, HQ);
             }
             if (targets.length) {
@@ -633 +617 @@
         for (var unitCat in this.unit) {
             this.unit[unitCat].forEach(function (ent) {
-                if (ent.getMetadata(PlayerID, "role") != "defence" && !ent.hasClass("Warship"))
+                if (ent.getMetadata(PlayerID, "role") != "defence")
                 {
                     ent.setMetadata(PlayerID,"role", "attack");
@@ -643 +627 @@
         for (var unitCat in this.unit) {
             this.unit[unitCat].forEach(function (ent) {
-                if (ent.getMetadata(PlayerID, "role") != "worker" && ent.getMetadata(PlayerID, "role") != "defence" && !ent.hasClass("Warship"))
+                if (ent.getMetadata(PlayerID, "role") != "worker" && ent.getMetadata(PlayerID, "role") != "defence")
                     ent.move(self.rallyPoint[0],self.rallyPoint[1]);
             });
@@ -651 +635 @@
 
 // Default target finder aims for conquest critical targets
-CityAttack.prototype.defaultTargetFinder = function(gameState, militaryManager){
+CityAttack.prototype.defaultTargetFinder = function(gameState, HQ){
     var targets = undefined;
     
-    targets = militaryManager.enemyWatchers[this.targetPlayer].getEnemyBuildings(gameState, "CivCentre",true);
+    targets = HQ.enemyWatchers[this.targetPlayer].getEnemyBuildings(gameState, "CivCentre",true);
     if (targets.length == 0) {
-        targets = militaryManager.enemyWatchers[this.targetPlayer].getEnemyBuildings(gameState, "ConquestCritical");
+        targets = HQ.enemyWatchers[this.targetPlayer].getEnemyBuildings(gameState, "ConquestCritical");
     }
     // If there's nothing, attack anything else that's less critical
     if (targets.length == 0) {
-        targets = militaryManager.enemyWatchers[this.targetPlayer].getEnemyBuildings(gameState, "Town",true);
+        targets = HQ.enemyWatchers[this.targetPlayer].getEnemyBuildings(gameState, "Town",true);
     }
     if (targets.length == 0) {
-        targets = militaryManager.enemyWatchers[this.targetPlayer].getEnemyBuildings(gameState, "Village",true);
+        targets = HQ.enemyWatchers[this.targetPlayer].getEnemyBuildings(gameState, "Village",true);
     }
     // no buildings, attack anything conquest critical, even units (it's assuming it won't move).
@@ -673 +657 @@
 
 // tupdate
-CityAttack.prototype.raidingTargetFinder = function(gameState, militaryManager, Target){
+CityAttack.prototype.raidingTargetFinder = function(gameState, HQ, Target){
     var targets = undefined;
     if (Target == "villager")
@@ -694 +678 @@
         return targets;
     } else {
-        return this.defaultTargetFinder(gameState, militaryManager);
+        return this.defaultTargetFinder(gameState, HQ);
     }
 };
@@ -701 +685 @@
 // If we're here, it's because we have in our IDlist enough units.
 // now the IDlist units are treated turn by turn
-CityAttack.prototype.StartAttack = function(gameState, militaryManager){
+CityAttack.prototype.StartAttack = function(gameState, HQ){
     
     // check we have a target and a path.
@@ -712 +696 @@
         
         this.unitCollection.forEach(function(ent) { ent.setMetadata(PlayerID, "subrole", "walking"); ent.setMetadata(PlayerID, "role", "attack") ;});
-
-        this.unitCollectionNoWarship = this.unitCollection.filter(Filters.not(Filters.byClass("Warship")));
-        this.unitCollectionNoWarship.registerUpdates();
-        
-        this.unitCollection.moveIndiv(this.path[0][0][0], this.path[0][0][1]);
+        // optimize our collection now.
+        this.unitCollection.freeze();
+        this.unitCollection.allowQuickIter();
+        
+        this.unitCollection.move(this.path[0][0][0], this.path[0][0][1]);
         this.unitCollection.setStance("aggressive");
         this.unitCollection.filter(Filters.byClass("Siege")).setStance("defensive");
@@ -730 +714 @@
 
 // Runs every turn after the attack is executed
-CityAttack.prototype.update = function(gameState, militaryManager, events){
+CityAttack.prototype.update = function(gameState, HQ, events){
     var self = this;
         
@@ -772 +756 @@
                             attackedNB++;
                         }
-                        //if (militaryManager.enemyWatchers[attacker.owner()]) {
+                        //if (HQ.enemyWatchers[attacker.owner()]) {
                             //toProcess[attacker.id()] = attacker;
-                            //var armyID = militaryManager.enemyWatchers[attacker.owner()].getArmyFromMember(attacker.id());
+                            //var armyID = HQ.enemyWatchers[attacker.owner()].getArmyFromMember(attacker.id());
                             //armyToProcess[armyID[0]] = armyID[1];
                         //}
@@ -852 +836 @@
     if (this.state === "walking"){
         
-        this.position = this.unitCollectionNoWarship.getCentrePosition();
+        this.position = this.unitCollection.getCentrePosition();
 
         // probably not too good.
@@ -881 +865 @@
         
         if (this.lastPosition && SquareVectorDistance(this.position, this.lastPosition) < 20 && this.path.length > 0) {
-            this.unitCollectionNoWarship.moveIndiv(this.path[0][0][0], this.path[0][0][1]);
+            this.unitCollection.moveIndiv(this.path[0][0][0], this.path[0][0][1]);
             // We're stuck, presumably. Check if there are no walls just close to us. If so, we're arrived, and we're gonna tear down some serious stone.
             var walls = gameState.getEnemyEntities().filter(Filters.and(Filters.byOwner(this.targetPlayer), Filters.byClass("StoneWall")));
@@ -903 +887 @@
         
         // check if our land units are close enough from the next waypoint.
-        if (SquareVectorDistance(this.unitCollectionNoWarship.getCentrePosition(), this.targetPos) < 7500 ||
-            SquareVectorDistance(this.unitCollectionNoWarship.getCentrePosition(), this.path[0][0]) < 850) {
+        if (SquareVectorDistance(this.unitCollection.getCentrePosition(), this.targetPos) < 7500 ||
+            SquareVectorDistance(this.unitCollection.getCentrePosition(), this.path[0][0]) < 650) {
             if (this.unitCollection.filter(Filters.byClass("Siege")).length !== 0
-                && SquareVectorDistance(this.unitCollectionNoWarship.getCentrePosition(), this.targetPos) > 7500
-                && SquareVectorDistance(this.unitCollection.filter(Filters.byClass("Siege")).getCentrePosition(), this.path[0][0]) > 850)
+                && SquareVectorDistance(this.unitCollection.getCentrePosition(), this.targetPos) >= 7500
+                && SquareVectorDistance(this.unitCollection.filter(Filters.byClass("Siege")).getCentrePosition(), this.path[0][0]) >= 650)
             {
             } else {
+
+                for (var i = 0; i < this.path.length; ++i)
+                {
+                    debug ("path waypoint " + i + "," + this.path[i][1] + " at " + uneval(this.path[i][0]));
+                }
+                debug ("position is " + this.unitCollection.getCentrePosition());
+
                 // okay so here basically two cases. The first one is "we need a boat at this point".
                 // the second one is "we need to unload at this point". The third is "normal".
@@ -916 +907 @@
                     this.path.shift();
                     if (this.path.length > 0){
-                        this.unitCollectionNoWarship.moveIndiv(this.path[0][0][0], this.path[0][0][1]);
+                        this.unitCollection.move(this.path[0][0][0], this.path[0][0][1]);
                     } else {
                         debug ("Attack Plan " +this.type +" " +this.name +" has arrived to destination.");
@@ -922 +913 @@
                         this.state = "arrived";
                     }
-                } else if (this.path[0][1] === true)
+                } else
                 {
-                    // okay we must load our units.
-                    // check if we have some kind of ships.
-                    var ships = this.unitCollection.filter(Filters.byClass("Warship"));
-                    if (ships.length === 0) {
+                    // TODO: make this require an escort later on.
+                    this.path.shift();
+                    if (this.path.length === 0) {
+                        debug ("Attack Plan " +this.type +" " +this.name +" has arrived to destination.");
+                        // we must assume we've arrived at the end of the trail.
+                        this.state = "arrived";
+                    } else {
+                        /*
+                        var plan = new TransportPlan(gameState, this.unitCollection.toIdArray(), this.path[0][0], false);
+                        this.tpPlanID = plan.ID;
+                        HQ.navalManager.transportPlans.push(plan);
+                        debug ("Transporting over sea");
+                        this.state = "transporting";
+                    */
+                        // TODO: fix this above
+                        //right now we'll abort.
                         Engine.ProfileStop();
-                        return 0; // abort
+                        return 0;
                     }
-                
-                    debug ("switch to boarding");
-                    this.state = "boarding";
-                }
-            }
-        }
-    } else if (this.state === "shipping") {
-        this.position = this.unitCollection.filter(Filters.byClass("Warship")).getCentrePosition();
-        
-        if (!this.lastPosition)
-            this.lastPosition = [0,0];
-
-        if (SquareVectorDistance(this.position, this.lastPosition) < 20 && this.path.length > 0) {
-            this.unitCollection.filter(Filters.byClass("Warship")).move(this.path[0][0][0], this.path[0][0][1]);
-        }
-        if (SquareVectorDistance(this.position, this.path[0][0]) < 1600) {
-            if (this.path[0][1] !== true)
-            {
-                this.path.shift();
-                if (this.path.length > 0){
-                    this.unitCollection.filter(Filters.byClass("Warship")).move(this.path[0][0][0], this.path[0][0][1]);
-                } else {
-                    debug ("Attack Plan " +this.type +" " +this.name +" has arrived to destination, but it's still on the ship…");
-                    Engine.ProfileStop();
-                    return 0; // abort
-                }
-            } else if (this.path[0][1] === true)
-            {
-                debug ("switch to unboarding");
-                // we unload
-                this.state = "unboarding";
-            }
-        }
-    } else if (this.state === "boarding") {
-        this.position = this.unitCollectionNoWarship.getCentrePosition();
-
-        var ships = this.unitCollection.filter(Filters.byClass("Warship"));
-        if (ships.length === 0) {
-            Engine.ProfileStop();
-            return 0; // abort
-        }
-        
-        var globalPos = this.unitCollectionNoWarship.getCentrePosition();
-        var shipPos = ships.getCentrePosition();
-
-        if (globalPos !== undefined && SquareVectorDistance(globalPos,shipPos) > 800)
-        {   // get them closer
-            ships.moveIndiv(globalPos[0],globalPos[1]);
-            this.unitCollectionNoWarship.moveIndiv(shipPos[0],shipPos[1]);
-        } else {
-            // okay try to garrison.
-            var shipsArray = ships.toEntityArray();
-            this.unitCollectionNoWarship.forEach(function (ent) { //}){
-                if (ent.position()) // if we're not garrisoned
-                    for (var shipId = 0; shipId < shipsArray.length; shipId++) {
-                        if (shipsArray[shipId].garrisoned().length < shipsArray[shipId].garrisonMax())
-                        {
-                            ent.garrison(shipsArray[shipId]);
-                            break;
-                        }
-                    }
-            });
-            var garrLength = 0;
-            for (var shipId = 0; shipId < shipsArray.length; shipId++)
-                garrLength += shipsArray[shipId].garrisoned().length;
-            
-            if (garrLength == this.unitCollectionNoWarship.length) {
-                // okay.
-                this.path.shift();
-                if (this.path.length > 0){
-                    ships.move(this.path[0][0][0], this.path[0][0][1]);
-                    debug ("switch to shipping");
-                    this.state = "shipping";
-                } else {
-                    debug ("Attack Plan " +this.type +" " +this.name +" has arrived to destination.");
-                    // we must assume we've arrived at the end of the trail.
-                    this.state = "arrived";
-                }
-            }
-        }
-    } else if (this.state === "unboarding") {
-        
-        var ships = this.unitCollection.filter(Filters.byClass("Warship"));
-        if (ships.length === 0) {
-            Engine.ProfileStop();
-            return 0; // abort
-        }
-
-        this.position = ships.getCentrePosition();
-        
-        // the procedure is pretty simple: we move the ships to the next point and try to unload until all units are over.
-        // TODO: make it better, like avoiding collisions, and so on.
-
-        if (this.path.length > 1)
-            ships.move(this.path[1][0][0], this.path[1][0][1]);
-
-        ships.forEach(function (ship) {
-            ship.unloadAll();
-        });
-        
-        var shipsArray = ships.toEntityArray();
-        var garrLength = 0;
-        for (var shipId = 0; shipId < shipsArray.length; shipId++)
-            garrLength += shipsArray[shipId].garrisoned().length;
-            
-        if (garrLength == 0) {
-            // release the ships
-            
-            ships.forEach(function (ent) {
-                ent.setMetadata(PlayerID, "role",undefined);
-                ent.setMetadata(PlayerID, "subrole",undefined);
-                ent.setMetadata(PlayerID, "plan",undefined);
-            });
-            for (var shipId = 0; shipId < shipsArray.length; shipId++)
-                this.unitCollection.removeEnt(shipsArray[shipId]);
-            
-            this.path.shift();
-            if (this.path.length > 0){
-                this.unitCollection.moveIndiv(this.path[0][0][0], this.path[0][0][1]);
-                debug ("switch to walking");
-                this.state = "walking";
-            } else {
-                debug ("Attack Plan " +this.type +" " +this.name +" has arrived to destination.");
-                // we must assume we've arrived at the end of the trail.
-                this.state = "arrived";
-            }
-        }
-        
+                }
+            }
+        }
+    } else if (this.state === "transporting") {
+        // check that we haven't finished transporting, ie the plan
+        if (!HQ.navalManager.checkActivePlan(this.tpPlanID))
+        {
+            this.state = "walking";
+        }
     }
 
@@ -1095 +979 @@
     
     if (this.state === "") {
-        
         // Units attacked will target their attacker unless they're siege. Then we take another non-siege unit to attack them.
         for (var key in events) {
@@ -1107 +990 @@
                         if (ourUnit.hasClass("Siege"))
                         {
-                            var help = this.unitCollection.filter(Filters.and(Filters.not(Filters.byClass("Siege")),Filters.isIdle()));
-                            if (help.length === 0)
-                                help = this.unitCollection.filter(Filters.not(Filters.byClass("Siege")));
-                            if (help.length > 0)
-                                help.toEntityArray()[0].attack(attacker.id());
-                            if (help.length > 1)
-                                help.toEntityArray()[1].attack(attacker.id());
-
+                            var collec = this.unitCollection.filterNearest(ourUnit.position(), 8).filter(Filters.not(Filters.byClass("Siege"))).toEntityArray();
+                            if (collec.length !== 0)
+                            {
+                                collec[0].attack(attacker.id());
+                                if (collec.length !== 1)
+                                {
+                                    collec[1].attack(attacker.id());
+                                    if (collec.length !== 2)
+                                    {
+                                        collec[2].attack(attacker.id());
+                                    }
+                                }
+                            }
                         } else {
                             ourUnit.attack(attacker.id());
@@ -1123 +1011 @@
         }
         
-        
-        var enemyUnits = gameState.getEnemyEntities().filter(Filters.and(Filters.byOwner(this.targetPlayer), Filters.byClass("Unit")));
-        var enemyStructures = gameState.getEnemyEntities().filter(Filters.and(Filters.byOwner(this.targetPlayer), Filters.byClass("Structure")));
+        var enemyUnits = gameState.getGEC("player-" +this.targetPlayer + "-units");
+        var enemyStructures = gameState.getGEC("player-" +this.targetPlayer + "-structures");
 
         if (this.unitCollUpdateArray === undefined || this.unitCollUpdateArray.length === 0)
         {
-            this.unitCollUpdateArray = this.unitCollection.toEntityArray();
+            this.unitCollUpdateArray = this.unitCollection.toIdArray();
         } else {
+            // some stuffs for locality and speed
+            var territoryMap = Map.createTerritoryMap(gameState);
+            var timeElapsed = gameState.getTimeElapsed();
+            
             // Let's check a few units each time we update. Currently 10
-            for (var check = 0; check < Math.min(this.unitCollUpdateArray.length,10); check++)
+            var lgth = Math.min(this.unitCollUpdateArray.length,10);
+            for (var check = 0; check < lgth; check++)
             {
-                var ent = this.unitCollUpdateArray[0];
-                
-                // if the unit is not in my territory, make it move.
-                var territoryMap = Map.createTerritoryMap(gameState);
+                var ent = gameState.getEntityById(this.unitCollUpdateArray[0]);
+                if (!ent)
+                    continue;
+                var orderData = ent.unitAIOrderData();
+                if (orderData.length !== 0)
+                    orderData = orderData[0];
+                else
+                    orderData = undefined;
+
+                // if the unit is in my territory, make it move.
                 if (territoryMap.point(ent.position()) - 64 === PlayerID)
                     ent.move(this.targetPos[0],this.targetPos[1]);
+                
                 // update it.
                 var needsUpdate = false;
                 if (ent.isIdle())
                     needsUpdate = true;
-                if (ent.hasClass("Siege") && (!ent.unitAIOrderData() || !ent.unitAIOrderData()["target"] || !gameState.getEntityById(ent.unitAIOrderData()["target"]).hasClass("ConquestCritical")) )
+                if (ent.hasClass("Siege") && (!orderData || !orderData["target"] || !gameState.getEntityById(orderData["target"]) || !gameState.getEntityById(orderData["target"]).hasClass("ConquestCritical")) )
                     needsUpdate = true;
-                else if (ent.unitAIOrderData() && ent.unitAIOrderData()["target"] && gameState.getEntityById(ent.unitAIOrderData()["target"]).hasClass("Structure"))
+                else if (!ent.hasClass("Siege") && orderData && orderData["target"] && gameState.getEntityById(orderData["target"]) && gameState.getEntityById(orderData["target"]).hasClass("Structure"))
                     needsUpdate = true; // try to make it attack a unit instead
-                
-                if (gameState.getTimeElapsed() - ent.getMetadata(PlayerID, "lastAttackPlanUpdateTime") < 10000)
+
+                if (timeElapsed - ent.getMetadata(PlayerID, "lastAttackPlanUpdateTime") < 10000)
                     needsUpdate = false;
                 
-                if (needsUpdate || arrivedthisTurn)
+                if (needsUpdate === true || arrivedthisTurn)
                 {
-                    ent.setMetadata(PlayerID, "lastAttackPlanUpdateTime", gameState.getTimeElapsed());
+                    ent.setMetadata(PlayerID, "lastAttackPlanUpdateTime", timeElapsed);
                     var mStruct = enemyStructures.filter(function (enemy) { //}){
                         if (!enemy.position() || (enemy.hasClass("StoneWall") && ent.canAttackClass("StoneWall"))) {
                             return false;
                         }
-                        if (SquareVectorDistance(enemy.position(),ent.position()) > 2000) {
+                        if (SquareVectorDistance(enemy.position(),ent.position()) > 3000) {
                             return false;
                         }
@@ -1165 +1064 @@
                     });
                     var mUnit;
-                    if (ent.hasClass("Cavalry")) {
+                    if (ent.hasClass("Cavalry") && ent.countersClasses(["Support"])) {
                         mUnit = enemyUnits.filter(function (enemy) { //}){
                             if (!enemy.position()) {
@@ -1172 +1071 @@
                             if (!enemy.hasClass("Support"))
                                 return false;
-                            if (SquareVectorDistance(enemy.position(),ent.position()) > 2000) {
+                            if (SquareVectorDistance(enemy.position(),ent.position()) > 10000) {
                                 return false;
                             }
@@ -1178 +1077 @@
                         });
                     }
-                    if (!ent.hasClass("Cavalry") || mUnit.length === 0) {
+                    if (!(ent.hasClass("Cavalry") && ent.countersClasses(["Support"])) || mUnit.length === 0) {
                         mUnit = enemyUnits.filter(function (enemy) { //}){
                             if (!enemy.position()) {
                                 return false;
                             }
-                            if (SquareVectorDistance(enemy.position(),ent.position()) > 2000) {
+                            if (SquareVectorDistance(enemy.position(),ent.position()) > 10000) {
                                 return false;
                             }
@@ -1212 +1111 @@
                             return (valb - vala);
                         });
-                        
+                        // TODO: handle ballistas here
                         if (mStruct.length !== 0) {
                             if (isGate)
@@ -1227 +1126 @@
                         }
                     } else {
-                        if (mUnit.length !== 0 && !isGate) {
+                        if (mUnit.length !== 0) {
                             var rand = Math.floor(Math.random() * mUnit.length*0.99);
                             ent.attack(mUnit[(+rand)].id());
                             //debug ("Units attacking a unit from " +mUnit[+rand].owner() + " , " +mUnit[+rand].templateName());
+                        } else if (SquareVectorDistance(self.targetPos, ent.position()) > 900 ){
+                            //debug ("Units moving to " + uneval(self.targetPos));
+                            ent.move(self.targetPos[0],self.targetPos[1]);
                         } else if (mStruct.length !== 0) {
                             mStruct.sort(function (structa,structb) { //}){
@@ -1257 +1159 @@
                                 //debug ("Units attacking a structure from " +mStruct[+rand].owner() + " , " +mStruct[+rand].templateName());
                             }
-                        } else if (SquareVectorDistance(self.targetPos, ent.position()) > 900 ){
-                            //debug ("Units moving to " + uneval(self.targetPos));
-                            ent.move(self.targetPos[0],self.targetPos[1]);
                         }
                     }
                 }
-                
-                this.unitCollUpdateArray.splice(0,1);
-            }
+            }
+            this.unitCollUpdateArray.splice(0,10);
         }
         // updating targets.
         if (!gameState.getEntityById(this.target.id()))
         {           
-            var targets = this.targetFinder(gameState, militaryManager);
+            var targets = this.targetFinder(gameState, HQ);
             if (targets.length === 0){
-                targets = this.defaultTargetFinder(gameState, militaryManager);
+                targets = this.defaultTargetFinder(gameState, HQ);
             }
             if (targets.length) {

ps/trunk/binaries/data/mods/public/simulation/ai/aegis/config.js

@@ -4 +4 @@
         "fortressLapseTime" : 540, // Time to wait between building 2 fortresses
         "defenceBuildingTime" : 600, // Time to wait before building towers or fortresses
-        "attackPlansStartTime" : 0  // time to wait before attacking. Start as soon as possible (first barracks)
+        "attackPlansStartTime" : 0, // time to wait before attacking. Start as soon as possible (first barracks)
+        "techStartTime" : 120,  // time to wait before teching. Will only start after town phase so it's irrelevant.
+        "popForBarracks1" : 15,
+        "popForBarracks2" : 95,
+        "timeForBlacksmith" : 900,
     },
     "Economy" : {
         "townPhase" : 180,  // time to start trying to reach town phase (might be a while after. Still need the requirements + ress )
-        "cityPhase" : 540,  // time to start trying to reach city phase
-        "farmsteadStartTime" : 400, // Time to wait before building a farmstead.
+        "cityPhase" : 840000,   // time to start trying to reach city phase
+        "popForMarket" : 80,
+        "popForFarmstead" : 45,
         "dockStartTime" : 240,  // Time to wait before building the dock
-        "techStartTime" : 600,  // time to wait before teching.
-        "targetNumBuilders" : 1.5, // Base number of builders per foundation. Later updated, but this remains a multiplier.
-        "femaleRatio" : 0.6 // percent of females among the workforce.
+        "techStartTime" : 0,    // time to wait before teching.
+        "targetNumBuilders" : 1.5, // Base number of builders per foundation.
+        "femaleRatio" : 0.4, // percent of females among the workforce.
+        "initialFields" : 2
     },
     
@@ -50 +56 @@
     // qbot
     "priorities" : {  // Note these are dynamic, you are only setting the initial values
-        "house" : 200,
-        "citizenSoldier" : 70,
-        "villager" : 55,
-        "economicBuilding" : 70,
+        "house" : 350,
+        "villager" : 40,
+        "citizenSoldier" : 60,
+        "ships" : 70,
+        "economicBuilding" : 90,
         "dropsites" : 120,
-        "field" : 1000,
-        "militaryBuilding" : 90,
+        "field" : 500,
+        "militaryBuilding" : 110,
         "defenceBuilding" : 70,
-        "majorTech" : 400,
-        "minorTech" : 40,
-        "civilCentre" : 10000   // will hog all resources
+        "majorTech" : 700,
+        "minorTech" : 50,
+        "civilCentre" : 400
     },
-    "difficulty" : 2,   // for now 2 is "hard", ie default. 1 is normal, 0 is easy. 3 is very hard
+    "difficulty" : 2,   // 0 is sandbox, 1 is easy, 2 is medium, 3 is hard, 4 is very hard.
     "debug" : false
 };
@@ -75 +82 @@
         if (Config.difficulty === 1)
         {
-            Config["Military"] = {
-                "fortressLapseTime" : 900,
-                "defenceBuildingTime" : 720,
-                "attackPlansStartTime" : 1200
-            };
-            Config["Economy"] = {
-                "townPhase" : 360,
-                "cityPhase" : 900,
-                "farmsteadStartTime" : 600,
-                "dockStartTime" : 240,
-                "techStartTime" : 1320,
-                "targetNumBuilders" : 2,
-                "femaleRatio" : 0.5,
-                "targetNumWorkers" : 110    // should not make more than 2 barracks.
-            };
-            Config["Defence"] = {
-                "defenceRatio" : 4.0,
-                "armyCompactSize" : 700,
-                "armyBreakawaySize" : 900
-            };
-        } else if (Config.difficulty === 0)
+            Config.Military.defenceBuildingTime = 1200;
+            Config.Military.attackPlansStartTime = 960;
+            Config.Military.popForBarracks1 = 35;
+            Config.Military.popForBarracks2 = 150;  // shouldn't reach it
+            Config.Military.popForBlacksmith = 150; // shouldn't reach it
+
+            Config.Economy.cityPhase = 1800;
+            Config.Economy.popForMarket = 80;
+            Config.Economy.techStartTime = 600;
+            Config.Economy.femaleRatio = 0.6;
+            Config.Economy.initialFields = 1;
+            // Config.Economy.targetNumWorkers will be set by AI scripts.
+        }
+        else if (Config.difficulty === 0)
         {
-            Config["Military"] = {
-                "fortressLapseTime" : 1000000,  // never
-                "defenceBuildingTime" : 900,
-                "attackPlansStartTime" : 120000 // never
-            };
-            Config["Economy"] = {
-                "townPhase" : 480,
-                "cityPhase" : 1200,
-                "farmsteadStartTime" : 1200,
-                "dockStartTime" : 240,
-                "techStartTime" : 600000,   // never
-                "targetNumBuilders" : 1,
-                "femaleRatio" : 0.0,    // makes us slower, but also less sucky at defending so it's still fun to attack it.
-                "targetNumWorkers" : 70
-            };
-            Config["Defence"] = {
-                "defenceRatio" : 2.0,
-                "armyCompactSize" : 700,
-                "armyBreakawaySize" : 900
-            };
+            Config.Military.defenceBuildingTime = 450;
+            Config.Military.attackPlansStartTime = 9600000; // never
+            Config.Military.popForBarracks1 = 60;
+            Config.Military.popForBarracks2 = 150;  // shouldn't reach it
+            Config.Military.popForBlacksmith = 150; // shouldn't reach it
+
+            Config.Economy.cityPhase = 240000;
+            Config.Economy.popForMarket = 200;
+            Config.Economy.techStartTime = 1800;
+            Config.Economy.femaleRatio = 0.2;
+            Config.Economy.initialFields = 1;
+            // Config.Economy.targetNumWorkers will be set by AI scripts.
         }
     }

ps/trunk/binaries/data/mods/public/simulation/ai/aegis/data.json

@@ -2 +2 @@
   "name": "Aegis Bot",
   "description": "Wraitii's improvement of qBot. It is more reliable and generally a better player. Note that it doesn't support saved games yet, and there may be other bugs. Please report issues to Wildfire Games (see the link in the main menu).",
-  "constructor": "QBotAI",
+  "constructor": "AegisBot",
   "useShared": true
 }

ps/trunk/binaries/data/mods/public/simulation/ai/aegis/defence.js

@@ -49 +49 @@
 
 
-Defence.prototype.update = function(gameState, events, militaryManager){
+Defence.prototype.update = function(gameState, events, HQ){
     
     Engine.ProfileStart("Defence Manager");
@@ -81 +81 @@
 
     // First step: we deal with enemy armies, those are the highest priority.
-    this.defendFromEnemies(gameState, events, militaryManager);
+    this.defendFromEnemies(gameState, events, HQ);
 
     // second step: we loop through messages, and sort things as needed (dangerous buildings, attack by animals, ships, lone units, whatever).
     // TODO : a lot.
-    this.MessageProcess(gameState,events,militaryManager);
-    
-    this.DealWithWantedUnits(gameState,events,militaryManager);
+    this.MessageProcess(gameState,events,HQ);
+    
+    this.DealWithWantedUnits(gameState,events,HQ);
 
     /*
@@ -139 +139 @@
 // Incorporates an entity in an army. If no army fits, it creates a new one around this one.
 // an army is basically an entity collection.
-Defence.prototype.armify = function(gameState, entity, militaryManager, minNBForArmy) {
+Defence.prototype.armify = function(gameState, entity, HQ, minNBForArmy) {
     if (entity.position() === undefined)
         return;
@@ -161 +161 @@
         }
     }
-    if (militaryManager)
+    if (HQ)
     {
         var self = this;
-        var close = militaryManager.enemyWatchers[entity.owner()].enemySoldiers.filter(Filters.byDistance(entity.position(), self.armyCompactSize));
+        var close = HQ.enemyWatchers[entity.owner()].enemySoldiers.filter(Filters.byDistance(entity.position(), self.armyCompactSize));
         if (!minNBForArmy || close.length >= minNBForArmy)
         {
@@ -224 +224 @@
 // This deals with incoming enemy armies, setting the defcon if needed. It will take new soldiers, and assign them to attack
 // TODO: still is still pretty dumb, it could use improvements.
-Defence.prototype.defendFromEnemies = function(gameState, events, militaryManager) {
+Defence.prototype.defendFromEnemies = function(gameState, events, HQ) {
     var self = this;
     
@@ -265 +265 @@
     for (var enemyID in this.enemyArmy)
     {
-        //this.enemyUnits[enemyID] = militaryManager.enemyWatchers[enemyID].getAllEnemySoldiers();
+        //this.enemyUnits[enemyID] = HQ.enemyWatchers[enemyID].getAllEnemySoldiers();
         if (this.enemyUnits[enemyID] === undefined || this.enemyUnits[enemyID].length === 0)
         {
-            this.enemyUnits[enemyID] = militaryManager.enemyWatchers[enemyID].enemySoldiers.toEntityArray();
+            this.enemyUnits[enemyID] = HQ.enemyWatchers[enemyID].enemySoldiers.toEntityArray();
         } else {
             // we have some units still to check in this array. Check 15 (TODO: DIFFLEVEL)
@@ -284 +284 @@
                         var dangerous = this.evaluateEntity(gameState, this.enemyUnits[enemyID][0]);
                         if (dangerous)
-                            this.armify(gameState, this.enemyUnits[enemyID][0], militaryManager,2);
+                            this.armify(gameState, this.enemyUnits[enemyID][0], HQ,2);
                         this.enemyUnits[enemyID].splice(0,1);
                     }
@@ -380 +380 @@
             self.nbDefenders--;
         });
-        militaryManager.ungarrisonAll(gameState);
-        militaryManager.unpauseAllPlans(gameState);
+        HQ.ungarrisonAll(gameState);
+        HQ.unpauseAllPlans(gameState);
         return;
     } else if (this.nbAttackers === 0 && this.nbDefenders !== 0) {
@@ -394 +394 @@
             self.nbDefenders--;
         });
-        militaryManager.ungarrisonAll(gameState);
-        militaryManager.unpauseAllPlans(gameState);
+        HQ.ungarrisonAll(gameState);
+        HQ.unpauseAllPlans(gameState);
         return;
     }
     if ( (this.nbDefenders < 4 && this.nbAttackers >= 5) || this.nbDefenders === 0) {
-        militaryManager.ungarrisonAll(gameState);
+        HQ.ungarrisonAll(gameState);
     }
     
@@ -450 +450 @@
         
     if (gameState.defcon() > 3)
-        militaryManager.unpauseAllPlans(gameState);
+        HQ.unpauseAllPlans(gameState);
     
     if ( (nonDefenders.length + this.nbDefenders > newEnemies.length + this.nbAttackers)
@@ -468 +468 @@
     if (gameState.defcon() < 2 && (this.nbAttackers-this.nbDefenders) > 15)
     {
-        militaryManager.pauseAllPlans(gameState);
+        HQ.pauseAllPlans(gameState);
     } else if (gameState.defcon() < 3 && this.nbDefenders === 0 && newEnemies.length === 0) {
-        militaryManager.ungarrisonAll(gameState);
+        HQ.ungarrisonAll(gameState);
     }*/
     
@@ -550 +550 @@
         defs.forEach(function (defender) { //}){
             if (defender.getMetadata(PlayerID, "plan") != undefined && (gameState.defcon() < 4 || defender.getMetadata(PlayerID,"subrole") == "walking"))
-                militaryManager.pausePlan(gameState, defender.getMetadata(PlayerID, "plan"));
+                HQ.pausePlan(gameState, defender.getMetadata(PlayerID, "plan"));
             //debug ("Against " +enemy.id() + " Assigning " + defender.id());
             if (defender.getMetadata(PlayerID, "role") == "worker" || defender.getMetadata(PlayerID, "role") == "attack")
@@ -606 +606 @@
 // So that a unit that gets attacked will not be completely dumb.
 // warning: huge levels of indentation coming.
-Defence.prototype.MessageProcess = function(gameState,events, militaryManager) {
+Defence.prototype.MessageProcess = function(gameState,events, HQ) {
     var self = this;
     
@@ -678 +678 @@
                                     {
                                         var position = attacker.position();
-                                        var close = militaryManager.enemyWatchers[attacker.owner()].enemySoldiers.filter(Filters.byDistance(position, self.armyCompactSize));
+                                        var close = HQ.enemyWatchers[attacker.owner()].enemySoldiers.filter(Filters.byDistance(position, self.armyCompactSize));
                                         
                                         if (close.length > 2 || ourUnit.hasClass("Support") || attacker.hasClass("Siege"))
@@ -737 +737 @@
 
 // At most, this will put defcon to 4
-Defence.prototype.DealWithWantedUnits = function(gameState, events, militaryManager) {
+Defence.prototype.DealWithWantedUnits = function(gameState, events, HQ) {
     //if (gameState.defcon() < 3)
     //  return;

ps/trunk/binaries/data/mods/public/simulation/ai/aegis/enemy-watcher.js

@@ -13 +13 @@
     var filter = Filters.and(Filters.byClass("Structure"), Filters.byOwner(this.watched));
     this.enemyBuildings = gameState.updatingGlobalCollection("player-" +this.watched + "-structures", filter);
-                             
+
+    filter = Filters.and(Filters.byClass("Unit"), Filters.byOwner(this.watched));
+    this.enemyUnits = gameState.updatingGlobalCollection("player-" +this.watched + "-units", filter);
+
     filter = Filters.and(Filters.byClass("Worker"), Filters.byOwner(this.watched));
     this.enemyCivilians = gameState.updatingGlobalCollection("player-" +this.watched + "-civilians", filter);

ps/trunk/binaries/data/mods/public/simulation/ai/aegis/entitycollection-extend.js

@@ -7 +7 @@
         }
     }
-    return new EntityCollection(gameState.ai, ents);
+    return new EntityCollection(gameState.sharedScript, ents);
 }

ps/trunk/binaries/data/mods/public/simulation/ai/aegis/map-module.js

@@ -1 @@
-const TERRITORY_PLAYER_MASK = 0x3F;
+// other map functions
 
-//TODO: Make this cope with negative cell values
-// This is by default a 16-bit map but can be adapted into 8-bit.
-function Map(gameState, originalMap, actualCopy){
-    // get the map to find out the correct dimensions
-    var gameMap = gameState.getMap();
-    this.width = gameMap.width;
-    this.height = gameMap.height;
-    this.length = gameMap.data.length;
-
-    this.maxVal = 65535;
-    
-    if (originalMap && actualCopy){
-        this.map = new Uint16Array(this.length);
-        for (var i = 0; i < originalMap.length; ++i)
-            this.map[i] = originalMap[i];
-    } else if (originalMap) {
-        this.map = originalMap;
-    } else {
-        this.map = new Uint16Array(this.length);
-    }
-    this.cellSize = gameState.cellSize;
-}
-Map.prototype.setMaxVal = function(val){
-    this.maxVal = val;
-};
-
-Map.prototype.gamePosToMapPos = function(p){
-    return [Math.floor(p[0]/this.cellSize), Math.floor(p[1]/this.cellSize)];
-};
-
-Map.prototype.point = function(p){
-    var q = this.gamePosToMapPos(p);
-    return this.map[q[0] + this.width * q[1]];
-};
-
-// returns an 8-bit map.
-Map.createObstructionMap = function(gameState, template){
+Map.createObstructionMap = function(gameState, accessIndex, template){
     var passabilityMap = gameState.getMap();
-    var territoryMap = gameState.ai.territoryMap; 
+    var territoryMap = gameState.ai.territoryMap;
     
     // default values
@@ -50 +14 @@
     if (template){
         placementType = template.buildPlacementType();
-        buildOwn = template.hasBuildTerritory("own"); 
-        buildAlly = template.hasBuildTerritory("ally"); 
-        buildNeutral = template.hasBuildTerritory("neutral"); 
+        buildOwn = template.hasBuildTerritory("own");
+        buildAlly = template.hasBuildTerritory("ally");
+        buildNeutral = template.hasBuildTerritory("neutral");
         buildEnemy = template.hasBuildTerritory("enemy");
     }
-
+    
     var obstructionMask = gameState.getPassabilityClassMask("foundationObstruction") | gameState.getPassabilityClassMask("building-land");
     
@@ -67 +31 @@
             for (var y = 0; y < passabilityMap.height; ++y)
             {
-                okay = false;
                 var i = x + y*passabilityMap.width;
                 var tilePlayer = (territoryMap.data[i] & TERRITORY_PLAYER_MASK);
+                
+                if (gameState.ai.myIndex !== gameState.ai.accessibility.landPassMap[i])
+                {
+                    obstructionTiles[i] = 0;
+                    continue;
+                }
+                if (gameState.isPlayerEnemy(tilePlayer) && tilePlayer !== 0)
+                {
+                    obstructionTiles[i] = 0;
+                    continue;
+                }
+                if ((passabilityMap.data[i] & (gameState.getPassabilityClassMask("building-shore") | gameState.getPassabilityClassMask("default"))))
+                {
+                    obstructionTiles[i] = 0;
+                    continue;
+                }
 
+                okay = false;
                 var positions = [[0,1], [1,1], [1,0], [1,-1], [0,-1], [-1,-1], [-1,0], [-1,1]];
                 var available = 0;
@@ -79 +59 @@
                     var index3 = x + stuff[0]*3 + (y+stuff[1]*3)*passabilityMap.width;
                     var index4 = x + stuff[0]*4 + (y+stuff[1]*4)*passabilityMap.width;
-                    if ((passabilityMap.data[index] & gameState.getPassabilityClassMask("default")) && gameState.ai.accessibility.getRegionSizei(index) > 500)
-                        if ((passabilityMap.data[index2] & gameState.getPassabilityClassMask("default")) && gameState.ai.accessibility.getRegionSizei(index2) > 500)
-                            if ((passabilityMap.data[index3] & gameState.getPassabilityClassMask("default")) && gameState.ai.accessibility.getRegionSizei(index3) > 500)
-                                if ((passabilityMap.data[index4] & gameState.getPassabilityClassMask("default")) && gameState.ai.accessibility.getRegionSizei(index4) > 500) {
+                    
+                    if ((passabilityMap.data[index] & gameState.getPassabilityClassMask("default")) && gameState.ai.accessibility.getRegionSizei(index,true) > 500)
+                        if ((passabilityMap.data[index2] & gameState.getPassabilityClassMask("default")) && gameState.ai.accessibility.getRegionSizei(index2,true) > 500)
+                            if ((passabilityMap.data[index3] & gameState.getPassabilityClassMask("default")) && gameState.ai.accessibility.getRegionSizei(index3,true) > 500)
+                                if ((passabilityMap.data[index4] & gameState.getPassabilityClassMask("default")) && gameState.ai.accessibility.getRegionSizei(index4,true) > 500) {
                                     if (available < 2)
                                         available++;
@@ -99 +80 @@
                                 okay = false;
                     }
-                if (gameState.ai.myIndex !== gameState.ai.accessibility.passMap[i])
-                    okay = false;
-                if (gameState.isPlayerEnemy(tilePlayer) && tilePlayer !== 0)
-                    okay = false;
-                if ((passabilityMap.data[i] & (gameState.getPassabilityClassMask("building-shore") | gameState.getPassabilityClassMask("default"))))
-                    okay = false;
                 obstructionTiles[i] = okay ? 255 : 0;
             }
@@ -121 +96 @@
                                     (!buildEnemy && gameState.isPlayerEnemy(tilePlayer) && tilePlayer != 0)
                                     );
-            var tileAccessible = (gameState.ai.myIndex === gameState.ai.accessibility.passMap[i]);
+            if (accessIndex)
+                var tileAccessible = (accessIndex === gameState.ai.accessibility.landPassMap[i]);
+            else
+                var tileAccessible = true;
             if (placementType === "shore")
                 tileAccessible = true;
@@ -127 +105 @@
         }
     }
-        
-    var map = new Map(gameState, obstructionTiles);
+    
+    var map = new Map(gameState.sharedScript, obstructionTiles);
     map.setMaxVal(255);
     
@@ -136 +114 @@
         if (minDist !== undefined && category !== undefined){
             gameState.getOwnEntities().forEach(function(ent) {
-                if (ent.buildCategory() === category && ent.position()){
-                    var pos = ent.position();
-                    var x = Math.round(pos[0] / gameState.cellSize);
-                    var z = Math.round(pos[1] / gameState.cellSize);
-                    map.addInfluence(x, z, minDist/gameState.cellSize, -255, 'constant');
-                }
-            });
+                                               if (ent.buildCategory() === category && ent.position()){
+                                               var pos = ent.position();
+                                               var x = Math.round(pos[0] / gameState.cellSize);
+                                               var z = Math.round(pos[1] / gameState.cellSize);
+                                               map.addInfluence(x, z, minDist/gameState.cellSize, -255, 'constant');
+                                               }
+                                               });
         }
     }
-    
     return map;
 };
+
+
 
 Map.createTerritoryMap = function(gameState) {
     var map = gameState.ai.territoryMap;
     
-    var ret = new Map(gameState, map.data);
+    var ret = new Map(gameState.sharedScript, map.data);
     
     ret.getOwner = function(p) {
@@ -162 +141 @@
     return ret;
 };
-
-Map.prototype.addInfluence = function(cx, cy, maxDist, strength, type) {
-    strength = strength ? +strength : +maxDist;
-    type = type ? type : 'linear';
-    
-    var x0 = Math.max(0, cx - maxDist);
-    var y0 = Math.max(0, cy - maxDist);
-    var x1 = Math.min(this.width, cx + maxDist);
-    var y1 = Math.min(this.height, cy + maxDist);
-    var maxDist2 = maxDist * maxDist;
-    
-    var str = 0.0;
-    switch (type){
-    case 'linear':
-        str = +strength / +maxDist;
-        break;
-    case 'quadratic':
-        str = +strength / +maxDist2;
-        break;
-    case 'constant':
-        str = +strength;
-        break;
-    }
-    
-    for ( var y = y0; y < y1; ++y) {
-        for ( var x = x0; x < x1; ++x) {
-            var dx = x - cx;
-            var dy = y - cy;
-            var r2 = dx*dx + dy*dy;
-            if (r2 < maxDist2){
-                var quant = 0;
-                switch (type){
-                case 'linear':
-                    var r = Math.sqrt(r2);
-                    quant = str * (maxDist - r);
-                    break;
-                case 'quadratic':
-                    quant = str * (maxDist2 - r2);
-                    break;
-                case 'constant':
-                    quant = str;
-                    break;
-                }
-                if (this.map[x + y * this.width] + quant < 0)
-                    this.map[x + y * this.width] = 0;
-                else if (this.map[x + y * this.width] + quant > this.maxVal)
-                    this.map[x + y * this.width] = this.maxVal; // avoids overflow.
-                else
-                    this.map[x + y * this.width] += quant;
-            }
-        }
-    }
-};
-
-Map.prototype.multiplyInfluence = function(cx, cy, maxDist, strength, type) {
-    strength = strength ? +strength : +maxDist;
-    type = type ? type : 'constant';
-    
-    var x0 = Math.max(0, cx - maxDist);
-    var y0 = Math.max(0, cy - maxDist);
-    var x1 = Math.min(this.width, cx + maxDist);
-    var y1 = Math.min(this.height, cy + maxDist);
-    var maxDist2 = maxDist * maxDist;
-    
-    var str = 0.0;
-    switch (type){
-        case 'linear':
-            str = strength / maxDist;
-            break;
-        case 'quadratic':
-            str = strength / maxDist2;
-            break;
-        case 'constant':
-            str = strength;
-            break;
-    }
-    
-    for ( var y = y0; y < y1; ++y) {
-        for ( var x = x0; x < x1; ++x) {
-            var dx = x - cx;
-            var dy = y - cy;
-            var r2 = dx*dx + dy*dy;
-            if (r2 < maxDist2){
-                var quant = 0;
-                switch (type){
-                    case 'linear':
-                        var r = Math.sqrt(r2);
-                        quant = str * (maxDist - r);
-                        break;
-                    case 'quadratic':
-                        quant = str * (maxDist2 - r2);
-                        break;
-                    case 'constant':
-                        quant = str;
-                        break;
-                }
-                var machin = this.map[x + y * this.width] * quant;
-                if (machin < 0)
-                    this.map[x + y * this.width] = 0;
-                else if (machin > this.maxVal)
-                    this.map[x + y * this.width] = this.maxVal;
-                else
-                    this.map[x + y * this.width] = machin;
-            }
-        }
-    }
-};
-// doesn't check for overflow.
-Map.prototype.setInfluence = function(cx, cy, maxDist, value) {
-    value = value ? value : 0;
-    
-    var x0 = Math.max(0, cx - maxDist);
-    var y0 = Math.max(0, cy - maxDist);
-    var x1 = Math.min(this.width, cx + maxDist);
-    var y1 = Math.min(this.height, cy + maxDist);
-    var maxDist2 = maxDist * maxDist;
-    
-    for ( var y = y0; y < y1; ++y) {
-        for ( var x = x0; x < x1; ++x) {
-            var dx = x - cx;
-            var dy = y - cy;
-            var r2 = dx*dx + dy*dy;
-            if (r2 < maxDist2){
-                this.map[x + y * this.width] = value;
-            }
-        }
-    }
-};
-
-/**
- * Make each cell's 16-bit/8-bit value at least one greater than each of its
- * neighbours' values. (If the grid is initialised with 0s and 65535s or 255s, the
- * result of each cell is its Manhattan distance to the nearest 0.)
- */
-Map.prototype.expandInfluences = function() {
-    var w = this.width;
-    var h = this.height;
-    var grid = this.map;
-    for ( var y = 0; y < h; ++y) {
-        var min = this.maxVal;
-        for ( var x = 0; x < w; ++x) {
-            var g = grid[x + y * w];
-            if (g > min)
-                grid[x + y * w] = min;
-            else if (g < min)
-                min = g;
-            ++min;
-        }
-
-        for ( var x = w - 2; x >= 0; --x) {
-            var g = grid[x + y * w];
-            if (g > min)
-                grid[x + y * w] = min;
-            else if (g < min)
-                min = g;
-            ++min;
-        }
-    }
-
-    for ( var x = 0; x < w; ++x) {
-        var min = this.maxVal;
-        for ( var y = 0; y < h; ++y) {
-            var g = grid[x + y * w];
-            if (g > min)
-                grid[x + y * w] = min;
-            else if (g < min)
-                min = g;
-            ++min;
-        }
-
-        for ( var y = h - 2; y >= 0; --y) {
-            var g = grid[x + y * w];
-            if (g > min)
-                grid[x + y * w] = min;
-            else if (g < min)
-                min = g;
-            ++min;
-        }
-    }
-};
-
-Map.prototype.findBestTile = function(radius, obstructionTiles){
-    // Find the best non-obstructed tile
-    var bestIdx = 0;
-    var bestVal = -1;
-    for ( var i = 0; i < this.length; ++i) {
-        if (obstructionTiles.map[i] > radius) {
-            var v = this.map[i];
-            if (v > bestVal) {
-                bestVal = v;
-                bestIdx = i;
-            }
-        }
-    }
-    
-    return [bestIdx, bestVal];
-};
-
-// add to current map by the parameter map pixelwise
-Map.prototype.add = function(map){
-    for (var i = 0; i < this.length; ++i) {
-        if (this.map[i] + map.map[i] < 0)
-            this.map[i] = 0;
-        else if (this.map[i] + map.map[i] > this.maxVal)
-            this.map[i] = this.maxVal;
-        else
-            this.map[i] += map.map[i];
-    }
-};
-
-Map.prototype.dumpIm = function(name, threshold){
-    name = name ? name : "default.png";
-    threshold = threshold ? threshold : this.maxVal;
-    Engine.DumpImage(name, this.map, this.width, this.height, threshold);
-};

ps/trunk/binaries/data/mods/public/simulation/ai/aegis/queue-manager.js

@@ -16 +16 @@
 // Particularly noticeable when phasing: the AI often overshoots by a good 200/300 resources before starting.
 //
-// The fact that there is an outqueue is mostly a relic of qBot.
-//
 // This system should be improved. It's probably not flexible enough.
 
@@ -37 +35 @@
 
     this.curItemQueue = [];
-    
 };
 
@@ -50 +47 @@
 };
 
-QueueManager.prototype.futureNeeds = function(gameState, EcoManager) {
+QueueManager.prototype.getTotalAccountedResources = function(gameState) {
+    var resources = new Resources();
+    for (var key in this.queues) {
+        resources.add(this.accounts[key]);
+    }
+    return resources;
+};
+
+QueueManager.prototype.currentNeeds = function(gameState) {
     var needs = new Resources();
-    // get ouy current resources, not removing accounts.
+    // get out current resources, not removing accounts.
     var current = this.getAvailableResources(gameState, true);
     //queueArrays because it's faster.
@@ -59 +64 @@
         var name = this.queueArrays[i][0];
         var queue = this.queueArrays[i][1];
-        for (var j = 0; j < Math.min(2,queue.length()); ++j)
-        {
-            needs.add(queue.queue[j].getCost());
-        }
-    }
-    if (EcoManager === false) {
-        return {
-            "food" : Math.max(needs.food - current.food, 0),
-            "wood" : Math.max(needs.wood - current.wood, 0),
-            "stone" : Math.max(needs.stone - current.stone, 0),
-            "metal" : Math.max(needs.metal - current.metal, 0)
-        };
-    } else {
-        // Return predicted values minus the current stockpiles along with a base rater for all resources
-        return {
-            "food" : (Math.max(needs.food - current.food, 0) + EcoManager.baseNeed["food"])/2,
-            "wood" : (Math.max(needs.wood - current.wood, 0) + EcoManager.baseNeed["wood"])/2,
-            "stone" : (Math.max(needs.stone - current.stone, 0) + EcoManager.baseNeed["stone"])/2,
-            "metal" : (Math.max(needs.metal - current.metal, 0) + EcoManager.baseNeed["metal"])/2
-        };
-    }
-};
+        if (queue.length() > 0 && queue.getNext().isGo(gameState))
+            needs.add(queue.getNext().getCost());
+        else if (queue.length() > 0 && !queue.getNext().isGo(gameState))
+        {
+            var cost = queue.getNext().getCost();
+            cost.multiply(0.5);
+            needs.add(cost);
+        }
+        if (queue.length() > 1 && queue.queue[1].isGo(gameState))
+            needs.add(queue.queue[1].getCost());
+    }
+    return {
+        "food" : Math.max(25 + needs.food - current.food, 0),
+        "wood" : Math.max(needs.wood - current.wood, 0),
+        "stone" : Math.max(needs.stone - current.stone, 0),
+        "metal" : Math.max(needs.metal - current.metal, 0)
+    };
+};
+
+QueueManager.prototype.futureNeeds = function(gameState) {
+    var needs = new Resources();
+    // get out current resources, not removing accounts.
+    var current = this.getAvailableResources(gameState, true);
+    //queueArrays because it's faster.
+    for (var i in this.queueArrays)
+    {
+        var name = this.queueArrays[i][0];
+        var queue = this.queueArrays[i][1];
+        for (var j = 0; j < queue.length(); ++j)
+        {
+            var costs = queue.queue[j].getCost();
+            if (!queue.queue[j].isGo(gameState))
+                costs.multiply(0.5);
+            needs.add(costs);
+        }
+    }
+    return {
+        "food" : Math.max(25 + needs.food - current.food, 10),
+        "wood" : Math.max(needs.wood - current.wood, 10),
+        "stone" : Math.max(needs.stone - current.stone, 0),
+        "metal" : Math.max(needs.metal - current.metal, 0)
+    };
+};
+
+// calculate the gather rates we'd want to be able to use all elements in our queues
+QueueManager.prototype.wantedGatherRates = function(gameState) {
+    var rates = { "food" : 0, "wood" : 0, "stone" : 0, "metal" : 0 };
+    var qTime = gameState.getTimeElapsed();
+    var qCosts = { "food" : 0, "wood" : 0, "stone" : 0, "metal" : 0 };
+
+    var currentRess = this.getAvailableResources(gameState);
+    
+    //queueArrays because it's faster.
+    for (var i in this.queueArrays)
+    {
+        qCosts = { "food" : 0, "wood" : 0, "stone" : 0, "metal" : 0 };
+        qTime = gameState.getTimeElapsed();
+        var name = this.queueArrays[i][0];
+        var queue = this.queueArrays[i][1];
+
+        for (var j = 0; j < queue.length(); ++j)
+        {
+            var elem = queue.queue[j];
+            var cost = elem.getCost();
+            if (qTime < elem.startTime)
+                qTime = elem.startTime;
+            if (!elem.isGo(gameState))
+            {
+                // assume 2 minutes.
+                // TODO work on this.
+                for (type in qCosts)
+                    qCosts[type] += cost[type];
+                qTime += 120000;
+                break;  // disregard other stuffs.
+            }
+            if (!elem.endTime)
+            {
+                // estimate time based on priority + cost + nb
+                // TODO: work on this.
+                for (type in qCosts)
+                    qCosts[type] += (cost[type] + Math.min(cost[type],this.priorities[name]));
+                qTime += 30000;
+            } else {
+                // TODO: work on this.
+                for (type in qCosts)
+                    qCosts[type] += (cost[type] + Math.min(cost[type],this.priorities[name]));
+                // TODO: refine based on % completed.
+                qTime += (elem.endTime-elem.startTime);
+            }
+        }
+        for (j in qCosts)
+        {
+            qCosts[j] -= this.accounts[name][j];
+            var diff = Math.min(qCosts[j], currentRess[j]);
+            qCosts[j] -= diff;
+            currentRess[j] -= diff;
+            rates[j] += qCosts[j]/(qTime/1000);
+        }
+    }
+    return rates;
+};
+
+/*QueueManager.prototype.logNeeds = function(gameState) {
+ if (!this.totor)
+ {
+ this.totor = [];
+ this.currentGathR = [];
+ this.currentGathRWanted = [];
+ this.ressLev = [];
+}
+ 
+    if (gameState.ai.playedTurn % 10 !== 0)
+        return;
+    
+    
+    var array = this.wantedGatherRates(gameState);
+    this.totor.push( array );
+    
+    
+    var currentRates = {};
+    for (var type in array)
+        currentRates[type] = 0;
+    for (i in gameState.ai.HQ.baseManagers)
+    {
+        var base = gameState.ai.HQ.baseManagers[i];
+        for (var type in array)
+        {
+            base.gatherersByType(gameState,type).forEach (function (ent) { //}){
+                                                          var worker = ent.getMetadata(PlayerID, "worker-object");
+                                                          if (worker)
+                                                          currentRates[type] += worker.getGatherRate(gameState);
+                                                          });
+        }
+    }
+    this.currentGathR.push( currentRates );
+    
+    var types = Object.keys(array);
+    
+    types.sort(function(a, b) {
+               var va = (Math.max(0,array[a] - currentRates[a]))/ (currentRates[a]+1);
+               var vb = (Math.max(0,array[b] - currentRates[b]))/ (currentRates[b]+1);
+               if (va === vb)
+               return (array[b]/(currentRates[b]+1)) - (array[a]/(currentRates[a]+1));
+               return vb-va;
+               });
+    this.currentGathRWanted.push( types );
+
+    var rss = gameState.getResources();
+    this.ressLev.push( {"food" : rss["food"],"stone" : rss["stone"],"wood" : rss["wood"],"metal" : rss["metal"]} );
+    
+    if (gameState.getTimeElapsed() > 20*60*1000 && !this.once)
+    {
+        this.once = true;
+        for (j in array)
+        {
+            log (j + ";");
+            for (var i = 0; i < this.totor.length; ++i)
+            {
+                log (this.totor[i][j] + ";");
+            }
+        }
+        log();
+        for (j in array)
+        {
+            log (j + ";");
+            for (var i = 0; i < this.totor.length; ++i)
+            {
+                log (this.currentGathR[i][j] + ";");
+            }
+        }
+        log();
+        for (j in array)
+        {
+            log (j + ";");
+            for (var i = 0; i < this.totor.length; ++i)
+            {
+                log (this.currentGathRWanted[i].indexOf(j) + ";");
+            }
+        }
+        log();
+        for (j in array)
+        {
+            log (j + ";");
+            for (var i = 0; i < this.totor.length; ++i)
+            {
+                log (this.ressLev[i][j] + ";");
+            }
+        }
+    }
+};
+*/
 
 QueueManager.prototype.printQueues = function(gameState){
-    debug("OUTQUEUES");
-    for (var i in this.queues){
-        var qStr = "";
-        var q = this.queues[i];
-        if (q.outQueue.length > 0)
-            debug((i + ":"));
-        for (var j in q.outQueue){
-            qStr = "    " + q.outQueue[j].type + " ";
-            if (q.outQueue[j].number)
-                qStr += "x" + q.outQueue[j].number;
-            debug (qStr);
-        }
-    }
-    
-    debug("INQUEUES");
+    debug("QUEUES");
     for (var i in this.queues){
         var qStr = "";
@@ -116 +276 @@
     }
     debug("Needed Resources:" + uneval(this.futureNeeds(gameState,false)));
+    debug ("Wanted Gather Rates:" + uneval(this.wantedGatherRates(gameState)));
     debug ("Current Resources:" + uneval(gameState.getResources()));
     debug ("Available Resources:" + uneval(this.getAvailableResources(gameState)));
+};
+
+// nice readable HTML version.
+QueueManager.prototype.HTMLprintQueues = function(gameState){
+    if (!Config.debug)
+        return;
+    log("<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"> <html> <head> <title>Aegis Queue Manager</title> <link rel=\"stylesheet\" href=\"table.css\">  </head> <body> <table> <caption>Aegis Build Order</caption> ");
+    for (var i in this.queues){
+        log ("<tr>");
+        
+        var q = this.queues[i];
+        var str = "<th>" + i +"<br>";
+        for each (k in this.accounts[i].types)
+            if(k != "population")
+            {
+                str += this.accounts[i][k] + k.substr(0,1).toUpperCase() ;
+                if (k != "metal") str += " / ";
+            }
+        log(str + "</th>");
+        for (var j in q.queue) {
+            if (q.queue[j].isGo(gameState))
+                log ("<td>");
+            else
+                log ("<td class=\"NotGo\">");
+
+            var qStr = "";
+            qStr += q.queue[j].type;
+            if (q.queue[j].number)
+                qStr += "x" + q.queue[j].number;
+            log (qStr);
+            log ("</td>");
+        }
+        log ("</tr>");
+    }
+    log ("</table>");
+    /*log ("<h3>Accounts</h3>");
+    for (var p in this.accounts)
+    {
+        log("<p>" + p + ": " + uneval(this.accounts[p]) + " </p>");
+    }*/
+    log ("<p>Needed Resources:" + uneval(this.futureNeeds(gameState,false)) + "</p>");
+    log ("<p>Wanted Gather Rate:" + uneval(this.wantedGatherRates(gameState)) + "</p>");
+    log ("<p>Current Resources:" + uneval(gameState.getResources()) + "</p>");
+    log ("<p>Available Resources:" + uneval(this.getAvailableResources(gameState)) + "</p>");
+    log("</body></html>");
 };
 
@@ -137 +343 @@
     
     Engine.ProfileStart("Queue Manager");
-    
-    //if (gameState.ai.playedTurn % 10 === 0)
-    //  this.printQueues(gameState);
-    
-    Engine.ProfileStart("Pick items from queues");
-    
-    // TODO: this only pushes the first object. SHould probably try to push any possible object to maximize productivity. Perhaps a settinh?
-    // looking at queues in decreasing priorities and pushing to the current item queues.
-    for (var i in this.queueArrays)
-    {
-        var name = this.queueArrays[i][0];
-        var queue = this.queueArrays[i][1];
-        if (queue.length() > 0)
-        {
-            var item = queue.getNext();
-            var total = new Resources();
-            total.add(this.accounts[name]);
-            total.subtract(queue.outQueueCost());
-            if (total.canAfford(item.getCost()))
-            {
-                queue.nextToOutQueue();
-            }
-        } else if (queue.totalLength() === 0) {
-            this.accounts[name].reset();
-        }
-    }
-    
+            
+    // Let's assign resources to plans that need'em
     var availableRes = this.getAvailableResources(gameState);
-    // assign some accounts to queues. This is done by priority, and by need.
     for (var ress in availableRes)
     {
@@ -174 +354 @@
             var maxNeed = {};
             // Okay so this is where it gets complicated.
-            // If a queue requires "ress" for the next elements (in the queue or the outqueue)
+            // If a queue requires "ress" for the next elements (in the queue)
             // And the account is not high enough for it.
             // Then we add it to the total priority.
@@ -183 +363 @@
             // uselessly while it awaits for other resources.
             for (var j in this.queues) {
-                var outQueueCost = this.queues[j].outQueueCost();
-                var queueCost = this.queues[j].queueCost();
-                if (this.accounts[j][ress] < queueCost[ress] + outQueueCost[ress])
+                // returns exactly the correct amount, ie 0 if we're not go.
+                var queueCost = this.queues[j].maxAccountWanted(gameState);
+                if (this.queues[j].length() > 0 && this.accounts[j][ress] < queueCost[ress] && !this.queues[j].paused)
                 {
+                    // check that we're not too forward in this resource compared to others.
+                    /*var maxp = this.accounts[j][ress] / (queueCost[ress]+1);
+                    var tooFull = false;
+                    for (tempRess in availableRes)
+                        if (tempRess !== ress && queueCost[tempRess] > 0 && (this.accounts[j][tempRess] / (queueCost[tempRess]+1)) - maxp < -0.2)
+                            tooFull = true;
+                    if (tooFull)
+                        continue;*/
+                    
                     // adding us to the list of queues that need an update.
                     tempPrio[j] = this.priorities[j];
-                    maxNeed[j] = outQueueCost[ress] + this.queues[j].getNext().getCost()[ress];
-                    // if we have enough of that resource for the outqueue and our first resource in the queue, diminish our priority.
-                    if (this.accounts[j][ress] >= outQueueCost[ress] + this.queues[j].getNext().getCost()[ress])
-                    {
+                    maxNeed[j] = queueCost[ress] - this.accounts[j][ress];
+                    // if we have enough of that resource for our first item in the queue, diminish our priority.
+                    if (this.accounts[j][ress] >= this.queues[j].getNext().getCost()[ress])
                         tempPrio[j] /= 2;
-                        if (this.queues[j].length() !== 1)
-                        {
-                            var halfcost = this.queues[j].queue[1].getCost()[ress]*0.8;
-                            maxNeed[j] += halfcost;
-                            if (this.accounts[j][ress] >= outQueueCost[ress] + this.queues[j].getNext().getCost()[ress] + halfcost)
-                                delete tempPrio[j];
-                        }
-                    }
+
                     if (tempPrio[j])
                         totalPriority += tempPrio[j];
+                }
+                else if (this.accounts[j][ress] > queueCost[ress])
+                {
+                    this.accounts[j][ress] = queueCost[ress];
                 }
             }
@@ -210 +395 @@
             for (var j in tempPrio) {
                 // we'll add at much what can be allowed to this queue.
-                var toAdd = Math.floor(tempPrio[j]/totalPriority * availableRes[ress]);
-                // let's check we're not adding too much.
-                var maxAdd = Math.min(maxNeed[j] - this.accounts[j][ress], toAdd);
+                var toAdd = tempPrio[j]/totalPriority * availableRes[ress];
+                var maxAdd = Math.floor(Math.min(maxNeed[j], toAdd));
                 this.accounts[j][ress] += maxAdd;
             }
-        }
-    }
+        }/* else if (ress != "population" && gameState.ai.playedTurn % 5 === 0) {
+            // okay here we haev no resource available. We'll try to shift resources to complete plans if possible.
+            // So basically if 2 queues have resources, and one is higher priority, and it needs resources
+            // We'll shift from the lower priority to the higher if we can complete it.
+            var queues = [];
+            for (var j in this.queues) {
+                if (this.queues[j].length() && this.queues[j].getNext().isGo(gameState) && this.accounts[j][ress] > 0)
+                    queues.push(j);
+            }
+            if (queues.length > 1)
+            {
+                // we'll work from the bottom to the top. ie lowest priority will try to give to highest priority.
+                queues.sort(function (a,b) { return (self.priorities[a] < self.priorities[b]); });
+                var under = 0, over = queues.length - 1;
+                while (under !== over)
+                {
+                    var cost = this.queues[queues[over]].getNext().getCost()[ress];
+                    var totalCost = this.queues[queues[over]].maxAccountWanted(gameState)[ress];
+                    if (this.accounts[queues[over]] >= cost)
+                    {
+                        --over; // check the next one.
+                        continue;
+                    }
+                    // need some discrepancy in priorities
+                    if (this.priorities[queues[under]] < this.priorities[queues[over]] - 20)
+                    {
+                        if (this.accounts[queues[under]] + this.accounts[queues[over]] >= cost)
+                        {
+                            var amnt = cost - this.accounts[queues[over]];
+                            this.accounts[queues[under]] -= amnt;
+                            this.accounts[queues[over]] += amnt;
+                            --over;
+                            debug ("Shifting " + amnt + " from " + queues[under] + " to " +queues[over]);
+                            continue;
+                        } else {
+                            ++under;
+                            continue;
+                        }
+                    } else {
+                        break;
+                    }
+                }
+                // okaaaay.
+            }
+        }*/
+    }
+    
+    Engine.ProfileStart("Pick items from queues");
+
+    //debug ("start");
+    //debug (uneval(this.accounts));
+    // Start the next item in the queue if we can afford it.
+    for (var i in this.queueArrays)
+    {
+        var name = this.queueArrays[i][0];
+        var queue = this.queueArrays[i][1];
+        if (queue.length() > 0 && !queue.paused)
+        {
+            var item = queue.getNext();
+            var total = new Resources();
+            total.add(this.accounts[name]);
+            if (total.canAfford(item.getCost()))
+            {
+                if (item.canStart(gameState))
+                {
+                    this.accounts[name].subtract(item.getCost());
+                    queue.startNext(gameState);
+                }
+            }
+        } else if (queue.length() === 0) {
+            this.accounts[name].reset();
+        }
+    }
+    //debug (uneval(this.accounts));
+    
     Engine.ProfileStop();
-
-    Engine.ProfileStart("Execute items");
-    
-    var units_Techs_passed = 0;
-    // Handle output queues by executing items where possible
-    for (var p in this.queueArrays) {
-        var name = this.queueArrays[p][0];
-        var queue = this.queueArrays[p][1];
-        var next = queue.outQueueNext();
-        if (!next)
-            continue;
-        if (next.category === "building") {
-            if (gameState.buildingsBuilt == 0) {
-                if (next.canExecute(gameState)) {
-                    this.accounts[name].subtract(next.getCost())
-                    //debug ("Starting " + next.type + " substracted " + uneval(next.getCost()))
-                    queue.executeNext(gameState);
-                    gameState.buildingsBuilt += 1;
-                }
-            }
-        } else {
-            if (units_Techs_passed < 2 && queue.outQueueNext().canExecute(gameState)){
-                //debug ("Starting " + next.type + " substracted " + uneval(next.getCost()))
-                this.accounts[name].subtract(next.getCost())
-                queue.executeNext(gameState);
-                units_Techs_passed++;
-            }
-        }
-        if (units_Techs_passed >= 2)
-            continue;
-    }
+    
+    if (gameState.ai.playedTurn % 30 === 0)
+        this.HTMLprintQueues(gameState);
+
     Engine.ProfileStop();
-    Engine.ProfileStop();
-};
+};
+
+QueueManager.prototype.pauseQueue = function(queue, scrapAccounts) {
+    if (this.queues[queue])
+    {
+        this.queues[queue].paused = true;
+        if (scrapAccounts)
+            this.accounts[queue].reset();
+    }
+}
+
+QueueManager.prototype.unpauseQueue = function(queue) {
+    if (this.queues[queue])
+        this.queues[queue].paused = false;
+}
+
+QueueManager.prototype.pauseAll = function(scrapAccounts, but) {
+    for (var p in this.queues)
+        if (p != but)
+        {
+            if (scrapAccounts)
+                this.accounts[p].reset();
+            this.queues[p].paused = true;
+        }
+}
+
+QueueManager.prototype.unpauseAll = function(but) {
+    for (var p in this.queues)
+        if (p != but)
+            this.queues[p].paused = false;
+}
+
 
 QueueManager.prototype.addQueue = function(queueName, priority) {

ps/trunk/binaries/data/mods/public/simulation/ai/aegis/queue.js

@@ -5 +5 @@
 var Queue = function() {
     this.queue = [];
-    this.outQueue = [];
+    this.paused = false;
 };
 
 Queue.prototype.empty = function() {
     this.queue = [];
-    this.outQueue = [];
 };
-
 
 Queue.prototype.addItem = function(plan) {
@@ -34 +32 @@
 };
 
-Queue.prototype.outQueueNext = function(){
-    if (this.outQueue.length > 0) {
-        return this.outQueue[0];
+Queue.prototype.startNext = function(gameState) {
+    if (this.queue.length > 0) {
+        this.queue.shift().start(gameState);
+        return true;
     } else {
-        return null;
+        return false;
     }
 };
 
-Queue.prototype.outQueueCost = function(){
+// returns the maximal account we'll accept for this queue.
+// Currently 100% of the cost of the first element and 80% of that of the second
+Queue.prototype.maxAccountWanted = function(gameState) {
     var cost = new Resources();
-    for (var key in this.outQueue){
-        cost.add(this.outQueue[key].getCost());
+    if (this.queue.length > 0 && this.queue[0].isGo(gameState))
+        cost.add(this.queue[0].getCost());
+    if (this.queue.length > 1 && this.queue[1].isGo(gameState))
+    {
+        var costs = this.queue[1].getCost();
+        costs.multiply(0.8);
+        cost.add(costs);
     }
     return cost;
@@ -56 +62 @@
     }
     return cost;
-};
-
-Queue.prototype.nextToOutQueue = function(){
-    if (this.queue.length > 0){
-        this.outQueue.push(this.queue.shift());
-    }
-};
-
-Queue.prototype.executeNext = function(gameState) {
-    if (this.outQueue.length > 0) {
-        this.outQueue.shift().execute(gameState);
-        return true;
-    } else {
-        return false;
-    }
 };
 
@@ -85 +76 @@
 };
 
-Queue.prototype.countOutQueuedUnits = function(){
-    var count = 0;
-    for (var i in this.outQueue){
-        count += this.outQueue[i].number;
-    }
-    return count;
-};
-
-Queue.prototype.countTotalQueuedUnits = function(){
-    var count = 0;
-    for (var i in this.queue){
-        count += this.queue[i].number;
-    }
-    for (var i in this.outQueue){
-        count += this.outQueue[i].number;
-    }
-    return count;
-};
-Queue.prototype.countTotalQueuedUnitsWithClass = function(classe){
+Queue.prototype.countQueuedUnitsWithClass = function(classe){
     var count = 0;
     for (var i in this.queue){
@@ -109 +82 @@
             count += this.queue[i].number;
     }
-    for (var i in this.outQueue){
-        if (this.outQueue[i].template && this.outQueue[i].template.hasClass(classe))
-            count += this.outQueue[i].number;
-    }
     return count;
 };
-Queue.prototype.countTotalQueuedUnitsWithMetadata = function(data,value){
+Queue.prototype.countQueuedUnitsWithMetadata = function(data,value){
     var count = 0;
     for (var i in this.queue){
@@ -121 +90 @@
             count += this.queue[i].number;
     }
-    for (var i in this.outQueue){
-        if (this.outQueue[i].metadata[data] && this.outQueue[i].metadata[data] == value)
-            count += this.outQueue[i].number;
-    }
     return count;
-};
-
-Queue.prototype.totalLength = function(){
-    return this.queue.length + this.outQueue.length;
-};
-
-Queue.prototype.outQueueLength = function(){
-    return this.outQueue.length;
 };
 
@@ -144 +101 @@
         } 
     }
-    for (var i = 0; i < this.outQueue.length; i++){
-        if (this.outQueue[i].type === t){
-            count += this.outQueue[i].number;
-        } 
-    }
     return count;
 };

ps/trunk/binaries/data/mods/public/simulation/ai/aegis/worker.js

@@ -7 +7 @@
     this.maxApproachTime = 45000;
     this.unsatisfactoryResource = false;    // if true we'll reguarly check if we can't have better now.
-};
-
-Worker.prototype.update = function(gameState) {
-    
+    this.baseID = 0;
+};
+
+Worker.prototype.update = function(baseManager, gameState) {
+    this.baseID = baseManager.ID;
     var subrole = this.ent.getMetadata(PlayerID, "subrole");
 
@@ -20 +21 @@
         this.ent.setMetadata(PlayerID,"fleeing", undefined);
     
+    // Okay so we have a few tasks.
+    // If we're gathering, we'll check that we haven't run idle.
+    // ANd we'll also check that we're gathering a resource we want to gather.
+    
+    // If we're fighting, let's not start gathering, heh?
+    // TODO: remove this when we're hunting?
+    if (this.ent.unitAIState().split(".")[1] === "COMBAT" || this.ent.getMetadata(PlayerID, "role") === "transport")
+    {
+        return;
+    }
+    
     if (subrole === "gatherer") {
-        if (this.ent.unitAIState().split(".")[1] !== "GATHER" && this.ent.unitAIState().split(".")[1] !== "COMBAT" && this.ent.unitAIState().split(".")[1] !== "RETURNRESOURCE"){
-            // TODO: handle combat for hunting animals
-            if (!this.ent.resourceCarrying() || this.ent.resourceCarrying().length === 0 || 
+        if (this.ent.isIdle()) {
+            // if we aren't storing resources or it's the same type as what we're about to gather,
+            // let's just pick a new resource.
+            if (!this.ent.resourceCarrying() || this.ent.resourceCarrying().length === 0 ||
                     this.ent.resourceCarrying()[0].type === this.ent.getMetadata(PlayerID, "gather-type")){
                 Engine.ProfileStart("Start Gathering");
-                this.startGathering(gameState);
+                this.unsatisfactoryResource = false;
+                this.startGathering(baseManager,gameState);
                 Engine.ProfileStop();
+
+                this.startApproachingResourceTime = gameState.getTimeElapsed();
+
             } else {
                 // Should deposit resources
@@ -35 +52 @@
                     // no dropsite, abandon cargo.
                     
-                    // if we have a new order
+                    // if we were ordered to gather something else, try that.
                     if (this.ent.resourceCarrying()[0].type !== this.ent.getMetadata(PlayerID, "gather-type"))
-                        this.startGathering(gameState);
+                        this.startGathering(baseManager,gameState);
                     else {
+                        // okay so we haven't found a proper dropsite for the resource we're supposed to gather
+                        // so let's get idle and the base manager will reassign us, hopefully well.
                         this.ent.setMetadata(PlayerID, "gather-type",undefined);
                         this.ent.setMetadata(PlayerID, "subrole", "idle");
@@ -46 +65 @@
                 Engine.ProfileStop();
             }
-            this.startApproachingResourceTime = gameState.getTimeElapsed();
-            
+            // debug: show the resource we're gathering from
             //Engine.PostCommand({"type": "set-shading-color", "entities": [this.ent.id()], "rgb": [10,0,0]});
         } else if (this.ent.unitAIState().split(".")[1] === "GATHER") {
-            if (this.unsatisfactoryResource && (this.ent.id() + gameState.ai.playedTurn) % 20 === 0)
+            
+            // check for transport.
+            if (gameState.ai.playedTurn % 5 === 0)
+            {
+                if (this.ent.unitAIOrderData().length && this.ent.unitAIState().split(".")[2] === "APPROACHING" && this.ent.unitAIOrderData()[0]["target"])
+                {
+                    var ress = gameState.getEntityById(this.ent.unitAIOrderData()[0]["target"]);
+                    if (ress !== undefined)
+                    {
+                        var index = gameState.ai.accessibility.getAccessValue(ress.position());
+                        var mIndex = gameState.ai.accessibility.getAccessValue(this.ent.position());
+                        if (index !== mIndex && index !== 1)
+                        {
+                            //gameState.ai.HQ.navalManager.askForTransport(this.ent.id(), this.ent.position(), ress.position());
+                        }
+                    }
+                }
+            }
+            
+            /*
+            if (gameState.getTimeElapsed() - this.startApproachingResourceTime > this.maxApproachTime)
+            {
+                if (this.ent.unitAIOrderData().length && this.ent.unitAIState().split(".")[1] === "GATHER"
+                    && this.ent.unitAIOrderData()[0]["target"])
+                {
+                    var ent = gameState.getEntityById(this.ent.unitAIOrderData()[0]["target"]);
+                    debug ("here " + this.startApproachingResourceAmount + "," + ent.resourceSupplyAmount());
+                    if (ent && this.startApproachingResourceAmount == ent.resourceSupplyAmount() && this.startEnt == ent.id()) {
+                        debug (ent.toString() + " is inaccessible");
+                        ent.setMetadata(PlayerID, "inaccessible", true);
+                        this.ent.flee(ent);
+                        this.ent.setMetadata(PlayerID, "subrole", "idle");
+                    }
+                }
+            }*/
+            
+            // we're gathering. Let's check that it's not a resource we'd rather not gather from.
+            if ((this.ent.id() + gameState.ai.playedTurn) % 6 === 0 && this.checkUnsatisfactoryResource(gameState))
             {
                 Engine.ProfileStart("Start Gathering");
-                this.startGathering(gameState);
+                this.startGathering(baseManager,gameState);
                 Engine.ProfileStop();
             }
+            // TODO: reimplement the "reaching time" check.
             /*if (gameState.getTimeElapsed() - this.startApproachingResourceTime > this.maxApproachTime) {
                 if (this.gatheringFrom) {
@@ -68 +124 @@
                     }
                 }
-            }*/
+             }*/
         } else if (this.ent.unitAIState().split(".")[1] === "COMBAT") {
             /*if (gameState.getTimeElapsed() - this.startApproachingResourceTime > this.maxApproachTime) {
@@ -81 +137 @@
                 }
             }*/
-        } else {
-            this.startApproachingResourceTime = gameState.getTimeElapsed();
         }
     } else if(subrole === "builder") {
-        if (this.ent.unitAIState().split(".")[1] !== "REPAIR"){
-            var target = this.ent.getMetadata(PlayerID, "target-foundation");
-            if (target.foundationProgress() === undefined && target.needsRepair() == false)
-                this.ent.setMetadata(PlayerID, "subrole", "idle");
+        
+        // check for transport.
+        if (gameState.ai.playedTurn % 5 === 0)
+        {
+            if (this.ent.unitAIOrderData().length && this.ent.unitAIState().split(".")[2] === "APPROACHING" && this.ent.unitAIOrderData()[0]["target"])
+            {
+                var ress = gameState.getEntityById(this.ent.unitAIOrderData()[0]["target"]);
+                if (ress !== undefined)
+                {
+                    var index = gameState.ai.accessibility.getAccessValue(ress.position());
+                    var mIndex = gameState.ai.accessibility.getAccessValue(this.ent.position());
+                    if (index !== mIndex && index !== 1)
+                    {
+                        //gameState.ai.HQ.navalManager.askForTransport(this.ent.id(), this.ent.position(), ress.position());
+                    }
+                }
+            }
+        }
+
+        
+        if (this.ent.unitAIState().split(".")[1] !== "REPAIR") {
+            var target = gameState.getEntityById(this.ent.getMetadata(PlayerID, "target-foundation"));
+            // okay so apparently we aren't working.
+            // Unless we've been explicitely told to keep our role, make us idle.
+            if (!target || target.foundationProgress() === undefined && target.needsRepair() == false)
+            {
+                if (!this.ent.getMetadata(PlayerID, "keepSubrole"))
+                    this.ent.setMetadata(PlayerID, "subrole", "idle");
+            }
             else
                 this.ent.repair(target);
@@ -94 +173 @@
         this.startApproachingResourceTime = gameState.getTimeElapsed();
         //Engine.PostCommand({"type": "set-shading-color", "entities": [this.ent.id()], "rgb": [0,10,0]});
+        // TODO: we should maybe decide on our own to build other buildings, not rely on the assigntofoundation stuff.
     }  else if(subrole === "hunter") {
-        if (!this.ent.resourceCarrying() || this.ent.resourceCarrying().length === 0){
+        if (this.ent.isIdle()){
             Engine.ProfileStart("Start Hunting");
-            this.startHunting(gameState);
+            this.startHunting(gameState, baseManager);
             Engine.ProfileStop();
         }
-    } else {
-        this.startApproachingResourceTime = gameState.getTimeElapsed();
-    }
-};
-
-Worker.prototype.startGathering = function(gameState){
+    }
+};
+
+// check if our current resource is unsatisfactory
+// this can happen in two ways:
+//      -either we were on an unsatisfactory resource last time we started gathering (this.unsatisfactoryResource)
+//      -Or we auto-moved to a bad resource thanks to the great UnitAI.
+Worker.prototype.checkUnsatisfactoryResource = function(gameState) {
+    if (this.unsatisfactoryResource)
+        return true;
+    if (this.ent.unitAIOrderData().length && this.ent.unitAIState().split(".")[1] === "GATHER" && this.ent.unitAIState().split(".")[2] === "GATHERING" && this.ent.unitAIOrderData()[0]["target"])
+    {
+        var ress = gameState.getEntityById(this.ent.unitAIOrderData()[0]["target"]);
+        if (!ress || !ress.getMetadata(PlayerID,"linked-dropsite") || !ress.getMetadata(PlayerID,"linked-dropsite-nearby") || gameState.ai.accessibility.getAccessValue(ress.position()) === -1)
+            return true;
+    }
+    return false;
+};
+
+Worker.prototype.startGathering = function(baseManager, gameState) {
     var resource = this.ent.getMetadata(PlayerID, "gather-type");
     var ent = this.ent;
+    var self = this;
     
     if (!ent.position()){
@@ -114 +209 @@
     }
     
-    this.unsatisfactoryResource = false;
-
     // TODO: this is not necessarily optimal.
     
@@ -126 +219 @@
     // TODO: this is a huge part of multi-base support. Count only those in the same base as the worker.
     var number = 0;
-    var ourDropsites = gameState.getOwnDropsites(resource);
-    
+    
+    var ourDropsites = EntityCollectionFromIds(gameState,Object.keys(baseManager.dropsites));
     if (ourDropsites.length === 0)
     {
@@ -134 +227 @@
     }
     
+    var maxPerDP = 20;
+    if (resource === "food")
+        maxPerDP = 200;
+    
     ourDropsites.forEach(function (dropsite) {
-        if (dropsite.getMetadata(PlayerID, "linked-resources-" +resource) !== undefined
-            && dropsite.getMetadata(PlayerID, "resource-quantity-" +resource) !== undefined && dropsite.getMetadata(PlayerID, "resource-quantity-" +resource) > 200) {
+        if (baseManager.dropsites[dropsite.id()][resource] && baseManager.dropsites[dropsite.id()][resource][4] > 1000
+            && baseManager.dropsites[dropsite.id()][resource][5].length < maxPerDP)
             number++;
-        }
     });
-    
-    //debug ("Available " +resource + " dropsites: " +ourDropsites.length);
     
     // Allright second step, if there are any such dropsites, we pick the closest.
@@ -148 +242 @@
     {
         ourDropsites.forEach(function (dropsite) { //}){
-            if (dropsite.getMetadata(PlayerID, "resource-quantity-" +resource) == undefined)
-                return;
-            if (dropsite.position() && (dropsite.getMetadata(PlayerID, "resource-quantity-" +resource) > 700 || (number === 1 && dropsite.getMetadata(PlayerID, "resource-quantity-" +resource) > 200) ) ) {
+            if (baseManager.dropsites[dropsite.id()][resource] === undefined)
+                return;
+            if (dropsite.position() && (baseManager.dropsites[dropsite.id()][resource][4] > 1000 || (number === 1 && baseManager.dropsites[dropsite.id()][resource][4] > 200) )
+                && baseManager.dropsites[dropsite.id()][resource][5].length < maxPerDP) {
                 var dist = SquareVectorDistance(ent.position(), dropsite.position());
                 if (dist < minDropsiteDist){
                     minDropsiteDist = dist;
-                    nearestResources = dropsite.getMetadata(PlayerID, "linked-resources-" + resource);
+                    nearestResources = baseManager.dropsites[dropsite.id()][resource][1];
                     nearestDropsite = dropsite;
                 }
@@ -160 +255 @@
         });
     }
-    //debug ("Nearest dropsite: " +nearestDropsite);
-    
-    // Now if we have no dropsites, we repeat the process with resources "far" from dropsites but still linked with them.
-    // I add the "close" value for code sanity.
-    // Again, we choose a dropsite with a lot of resources left, or we pick the only one available (in this case whatever happens).
+    // we've found no fitting dropsites close enough from us.
+    // So'll try with far away.
     if (!nearestResources || nearestResources.length === 0) {
-        //debug ("here(1)");
-        gameState.getOwnDropsites(resource).forEach(function (dropsite){ //}){
-            var quantity = dropsite.getMetadata(PlayerID, "resource-quantity-" +resource)+dropsite.getMetadata(PlayerID, "resource-quantity-far-" +resource);
-            if (dropsite.position() && (quantity) > 700 || number === 1) {
+        ourDropsites.forEach(function (dropsite) { //}){
+            if (baseManager.dropsites[dropsite.id()][resource] === undefined)
+                return;
+            if (dropsite.position() && baseManager.dropsites[dropsite.id()][resource][4] > 400
+                && baseManager.dropsites[dropsite.id()][resource][5].length < maxPerDP) {
                 var dist = SquareVectorDistance(ent.position(), dropsite.position());
                 if (dist < minDropsiteDist){
                     minDropsiteDist = dist;
-                    nearestResources = dropsite.getMetadata(PlayerID, "linked-resources-" + resource);
+                    nearestResources = baseManager.dropsites[dropsite.id()][resource][1];
                     nearestDropsite = dropsite;
                 }
             }
         });
-        this.unsatisfactoryResource = true;
-        //debug ("Nearest dropsite: " +nearestDropsite);
-    }
-    // If we still haven't found any fitting dropsite...
-    // Then we'll just pick any resource, and we'll check for the closest dropsite to that one
+    }
+
     if (!nearestResources || nearestResources.length === 0){
+        if (resource === "food")
+            if (this.buildAnyField(gameState))
+                return;
+
+        if (this.unsatisfactoryResource == true)
+            return; // we were already not satisfied, we're still not, change not.
+
+        if (gameState.ai.HQ.switchWorkerBase(gameState, this.ent, resource))
+            return;
+
         //debug ("No fitting dropsite for " + resource + " found, iterating the map.");
         nearestResources = gameState.getResourceSupplies(resource);
         this.unsatisfactoryResource = true;
+        // TODO: should try setting up dropsites.
+    } else {
+        this.unsatisfactoryResource = false;
     }
     
@@ -194 +297 @@
             if (this.buildAnyField(gameState))
                 return;
+            if (gameState.ai.HQ.switchWorkerBase(gameState, this.ent, resource))
+                return;
             debug("No " + resource + " found! (1)");
         }
         else
+        {
+            if (gameState.ai.HQ.switchWorkerBase(gameState, this.ent, resource))
+                return;
             debug("No " + resource + " found! (1)");
+        }
         return;
     }
@@ -214 +323 @@
     // TODo: add a bonus for resources with a lot of resources left, perhaps, to spread gathering?
     nearestResources.forEach(function(supply) { //}){
-
         // sanity check, perhaps sheep could be garrisoned?
         if (!supply.position()) {
@@ -225 +333 @@
             return;
         }
-                                     
-        if (supply.isFull() === true || (supply.maxGatherers() - supply.resourceSupplyGatherers().length == 0) ||
-            (gameState.turnCache["ressGathererNB"] && gameState.turnCache["ressGathererNB"][supply.id()]
-                && gameState.turnCache["ressGathererNB"][supply.id()] + supply.resourceSupplyGatherers().length >= supply.maxGatherers())) {
-            return;
-        }
+
+        if (supply.isFull() === true
+            || (gameState.turnCache["ressGathererNB"] && gameState.turnCache["ressGathererNB"][supply.id()]
+                && gameState.turnCache["ressGathererNB"][supply.id()] + supply.resourceSupplyGatherers().length >= supply.maxGatherers))
+            return;
+
                              
-        // Don't gather enemy farms
-        if (!supply.isOwn(PlayerID) && supply.owner() !== 0) {
+        // Don't gather enemy farms or farms from another base
+        if ((!supply.isOwn(PlayerID) && supply.owner() !== 0) || (supply.isOwn(PlayerID) && supply.getMetadata(PlayerID,"base") !== self.baseID)) {
             //debug ("enemy");
             return;
@@ -239 +347 @@
         
         // quickscope accessbility check.
-        if (!gameState.ai.accessibility.pathAvailable(gameState, ent.position(), supply.position(), true)) {
+        if (!gameState.ai.accessibility.pathAvailable(gameState, ent.position(), supply.position())) {
             //debug ("nopath");
             return;
@@ -246 +354 @@
         if (supply.footprintRadius() < 1)
         {
-            var fakeMap = new Map(gameState,gameState.getMap().data);
+            var fakeMap = new Map(gameState.sharedScript,gameState.getMap().data);
             var id = fakeMap.gamePosToMapPos(supply.position())[0] + fakeMap.width*fakeMap.gamePosToMapPos(supply.position())[1];
             if ( (gameState.sharedScript.passabilityClasses["pathfinderObstruction"] & gameState.getMap().data[id]) )
@@ -269 +377 @@
         var territoryOwner = Map.createTerritoryMap(gameState).getOwner(supply.position());
         if (territoryOwner != PlayerID && territoryOwner != 0) {
-            dist *= 3.0;
+            dist *= 5.0;
             //return;
-        }
-        
-        // Go for treasure as a priority
-        if (dist < 40000 && supply.resourceSupplyType().generic == "treasure"){
+        } else if (dist < 40000 && supply.resourceSupplyType().generic == "treasure"){
+            // go for treasures if they're not in enemy territory
             dist /= 1000;
         }
@@ -283 +389 @@
         } 
     });
-    
     if (nearestSupply) {
         var pos = nearestSupply.position();
@@ -311 +416 @@
             tried = this.buildAnyField(gameState);
             if (!tried && SquareVectorDistance(pos,this.ent.position()) > 62500) {
+                // TODO: ought to change behavior here.
                 return; // wait. a farm should appear.
             }
         }
         if (!tried) {
-            
             if (!gameState.turnCache["ressGathererNB"])
             {
@@ -325 +430 @@
                 gameState.turnCache["ressGathererNB"][nearestSupply.id()]++;
             
-            this.maxApproachTime = Math.max(25000, VectorDistance(pos,this.ent.position()) * 1000);
+            this.maxApproachTime = Math.max(30000, VectorDistance(pos,this.ent.position()) * 5000);
+            this.startApproachingResourceAmount = ent.resourceSupplyAmount();
+            this.startEnt = ent.id();
             ent.gather(nearestSupply);
             ent.setMetadata(PlayerID, "target-foundation", undefined);
-
-            // check if the resource we've started gathering from is now full, in which case inform the dropsite.
-            if (gameState.turnCache["ressGathererNB"][nearestSupply.id()] + nearestSupply.resourceSupplyGatherers().length >= nearestSupply.maxGatherers()
-                && nearestSupply.getMetadata(PlayerID, "linked-dropsite") != undefined)
-            {
-                var dropsite = gameState.getEntityById(nearestSupply.getMetadata(PlayerID, "linked-dropsite"));
-                if (dropsite == undefined || dropsite.getMetadata(PlayerID, "linked-resources-" + resource) === undefined)
-                    return;
-                if (nearestSupply.getMetadata(PlayerID, "linked-dropsite-nearby") == true) {
-                    dropsite.setMetadata(PlayerID, "resource-quantity-" + resource, +dropsite.getMetadata(PlayerID, "resource-quantity-" + resource) - (+nearestSupply.getMetadata(PlayerID, "dp-update-value")));
-                    dropsite.getMetadata(PlayerID, "linked-resources-" + resource).updateEnt(nearestSupply);
-                    dropsite.getMetadata(PlayerID, "nearby-resources-" + resource).updateEnt(nearestSupply);
-                } else {
-                    dropsite.setMetadata(PlayerID, "resource-quantity-far-" + resource, +dropsite.getMetadata(PlayerID, "resource-quantity-" + resource) - (+nearestSupply.getMetadata(PlayerID, "dp-update-value")));
-                    dropsite.getMetadata(PlayerID, "linked-resources-" + resource).updateEnt(nearestSupply);
-                }
-
-            }
-        
         }
     } else {
@@ -352 +440 @@
             return;
 
-        debug("No " + resource + " found! (2)");
+        if (gameState.ai.HQ.switchWorkerBase(gameState, this.ent, resource))
+            return;
+        
+        if (resource !== "food")
+            debug("No " + resource + " found! (2)");
         // If we had a fitting closest dropsite with a lot of resources, mark it as not good. It means it's probably full. Then retry.
         // it'll be resetted next time it's counted anyway.
@@ -359 +451 @@
             nearestDropsite.setMetadata(PlayerID, "resource-quantity-" +resource, 0);
             nearestDropsite.setMetadata(PlayerID, "resource-quantity-far-" +resource, 0);
-            this.startGathering(gameState);
+            this.startGathering(baseManager, gameState);
         }
     }
@@ -398 +490 @@
 };
 
-Worker.prototype.startHunting = function(gameState){
+Worker.prototype.startHunting = function(gameState, baseManager){
     var ent = this.ent;
     
-    if (!ent.position() || ent.getMetadata(PlayerID, "stoppedHunting"))
+    if (!ent.position() || !baseManager.isHunting)
         return;
     
@@ -439 +531 @@
         
         // quickscope accessbility check
-        if (!gameState.ai.accessibility.pathAvailable(gameState, ent.position(), supply.position(), true))
+        if (!gameState.ai.accessibility.pathAvailable(gameState, ent.position(), supply.position(),false, true))
             return;
         
@@ -465 +557 @@
         if (!nearestDropsite)
         {
-            ent.setMetadata(PlayerID, "stoppedHunting", true);
+            baseManager.isHunting = false;
             ent.setMetadata(PlayerID, "role", undefined);
             debug ("No dropsite for hunting food");
             return;
         }
-        if (minDropsiteDist > 45000) {
-            ent.setMetadata(PlayerID, "stoppedHunting", true);
+        if (minDropsiteDist > 35000) {
+            baseManager.isHunting = false;
             ent.setMetadata(PlayerID, "role", undefined);
         } else {
@@ -478 +570 @@
         }
     } else {
-        ent.setMetadata(PlayerID, "stoppedHunting", true);
+        baseManager.isHunting = false;
         ent.setMetadata(PlayerID, "role", undefined);
         debug("No food found for hunting! (2)");
@@ -496 +588 @@
 };
 
+Worker.prototype.getGatherRate = function(gameState) {
+    if (this.ent.getMetadata(PlayerID,"subrole") !== "gatherer")
+        return 0;
+    var rates = this.ent.resourceGatherRates();
+    
+    if (this.ent.unitAIOrderData().length && this.ent.unitAIState().split(".")[1] === "GATHER" && this.ent.unitAIOrderData()[0]["target"])
+    {
+        var ress = gameState.getEntityById(this.ent.unitAIOrderData()[0]["target"]);
+        if (!ress)
+            return 0;
+        var type = ress.resourceSupplyType();
+        if (type.generic == "treasure")
+            return 1000;
+        var tstring = type.generic + "." + type.specific;
+        //debug (+rates[tstring] + " for " + tstring + " for " + this.ent._templateName);
+        if (rates[tstring])
+            return rates[tstring];
+        return 0;
+    }
+    return 0;
+};
+
 Worker.prototype.buildAnyField = function(gameState){
     var self = this;
     var okay = false;
-    var foundations = gameState.getOwnFoundations();
+    var foundations = gameState.getOwnFoundations().filter(Filters.byMetadata(PlayerID,"base",this.baseID));
     foundations.filterNearest(this.ent.position(), foundations.length);
     foundations.forEach(function (found) {
@@ -508 +622 @@
         }
     });
+    if (!okay)
+    {
+        var foundations = gameState.getOwnFoundations();
+        foundations.filterNearest(this.ent.position(), foundations.length);
+        foundations.forEach(function (found) {
+            if (found._template.BuildRestrictions.Category === "Field" && !okay) {
+                self.ent.repair(found);
+                self.ent.setMetadata(PlayerID,"base", found.getMetadata(PlayerID,"base"));
+                okay = true;
+                return;
+            }
+        });
+    }
     return okay;
 };

ps/trunk/binaries/data/mods/public/simulation/ai/common-api-v3/base.js

@@ -13 +13 @@
 
     this.turn = 0;
+    this.timeElapsed = 0;
 }
 
@@ -36 +37 @@
     this.passabilityClasses = sharedAI.passabilityClasses;
     this.passabilityMap = sharedAI.passabilityMap;
+    this.territoryMap = sharedAI.territoryMap;
+    this.timeElapsed = state.timeElapsed;
 
-    var gameState = sharedAI.gameState[PlayerID];
-    gameState.ai = this;
+    this.gameState = sharedAI.gameState[PlayerID];
+    this.gameState.ai = this;
+    this.sharedScript = sharedAI;
         
-    this.InitShared(gameState, sharedAI);
-    
-    delete gameState.ai;
+    this.InitShared(this.gameState, this.sharedScript);
 }
 
@@ -60 +62 @@
     this.accessibility = sharedAI.accessibility;
     this.terrainAnalyzer = sharedAI.terrainAnalyzer;
-    this.techModifications = sharedAI.techModifications[this._player];
+    this.techModifications = sharedAI._techModifications[this._player];
 
     Engine.ProfileStop();

ps/trunk/binaries/data/mods/public/simulation/ai/common-api-v3/entity.js

@@ -33 +33 @@
         return this._template.Identity.RequiredTechnology;
     },
-
+                           
+    available: function(gameState) {
+        if (!this._template.Identity || !this._template.Identity.RequiredTechnology)
+            return true;
+        return gameState.isResearched(this._template.Identity.RequiredTechnology);
+    },
+                           
+    // specifically
     phase: function() {
         if (!this._template.Identity || !this._template.Identity.RequiredTechnology)
@@ -413 +420 @@
         return (territories && territories.indexOf(territory) != -1);
     },
-    
+
+    hasTerritoryInfluence: function() {
+        return (this._template.TerritoryInfluence !== undefined);
+    },
+
+    territoryInfluenceRadius: function() {
+        if (this._template.TerritoryInfluence !== undefined)
+            return (this._template.TerritoryInfluence.Radius);
+        else
+            return -1;
+    },
+
+    territoryInfluenceWeight: function() {
+        if (this._template.TerritoryInfluence !== undefined)
+            return (this._template.TerritoryInfluence.Weight);
+        else
+            return -1;
+    },
+
     visionRange: function() {
         if (!this._template.Vision)
@@ -428 +453 @@
     _init: function(sharedAI, entity)
     {
-        this._super.call(this, sharedAI.GetTemplate(entity.template), sharedAI.techModifications[entity.owner]);
+        this._super.call(this, sharedAI.GetTemplate(entity.template), sharedAI._techModifications[entity.owner]);
 
         this._ai = sharedAI;
@@ -463 +488 @@
     },
     
-    deleteMetadata: function(player) {
+    deleteAllMetadata: function(player) {
         delete this._ai._entityMetadata[player][this.id()];
+    },
+                   
+    deleteMetadata: function(player, key) {
+        this._ai.deleteMetadata(player, this, key);
     },
 
@@ -501 +530 @@
 
     foundationProgress: function() {
-        if (typeof this._entity.foundationProgress === "undefined")
+        if (this._entity.foundationProgress == undefined)
             return undefined;
         return this._entity.foundationProgress;
@@ -538 +567 @@
         if (this._entity.resourceSupplyGatherers !== undefined)
             return (this.maxGatherers() === this._entity.resourceSupplyGatherers.length);
+
         return undefined;
     },
@@ -548 +578 @@
 
     garrisoned: function() { return new EntityCollection(this._ai, this._entity.garrisoned); },
+    
+    canGarrisonInside: function() { return this._entity.garrisoned.length < this.garrisonMax(); },
 
     // TODO: visibility
@@ -659 +691 @@
     },
 
-    construct: function(template, x, z, angle) {
+    construct: function(template, x, z, angle, metadata) {
         // TODO: verify this unit can construct this, just for internal
         // sanity-checking and error reporting
@@ -672 +704 @@
             "autorepair": false,
             "autocontinue": false,
-            "queued": false
+            "queued": false,
+            "metadata" : metadata   // can be undefined
         });
         return this;

ps/trunk/binaries/data/mods/public/simulation/ai/common-api-v3/entitycollection.js

@@ -4 +4 @@
     this._entities = entities || {};
     this._filters = filters || [];
+    
+    this._quickIter = false;    // will make the entity collection store an array (not associative) of entities used when calling "foreach".
+    // probably should not be usde for very dynamic entity collections.
 
     // Compute length lazily on demand, since it can be
@@ -24 +27 @@
 // If an entitycollection is frozen, it will never automatically add a unit.
 // But can remove one.
+// this makes it easy to create entity collection that will auto-remove dead units
+// but never add new ones.
 EntityCollection.prototype.freeze = function()
 {
@@ -31 +36 @@
 {
     this.frozen = false;
+};
+
+EntityCollection.prototype.allowQuickIter = function()
+{
+    this._quickIter = true;
+    this._entitiesArray = [];
+    for each (var ent in this._entities)
+        this._entitiesArray.push(ent);
 };
 
@@ -43 +56 @@
 EntityCollection.prototype.toEntityArray = function()
 {
+    if (this._quickIter === true)
+        return this._entitiesArray;
     var ret = [];
     for each (var ent in this._entities)
@@ -60 +75 @@
 {
     // Compute the distance of each entity
-    var data = []; // [ [id, ent, distance], ... ]
-    for (var id in this._entities)
-    {
-        var ent = this._entities[id];
-        if (ent.position())
-            data.push([id, ent, VectorDistance(targetPos, ent.position())]);
+    var data = []; // [id, ent, distance]
+    
+    if (this._quickIter === true)
+    {
+        for (var i in this._entitiesArray)
+        {
+            var ent = this._entitiesArray[i];
+            if (ent.position() !== -1)
+                data.push([ent.id(), ent, SquareVectorDistance(targetPos, ent.position())]);
+        }
+    } else {
+        for (var id in this._entities)
+        {
+            var ent = this._entities[id];
+            if (ent.position() !== -1)
+                data.push([id, ent, SquareVectorDistance(targetPos, ent.position())]);
+        }
     }
 
@@ -73 +99 @@
     // Extract the first n
     var ret = {};
-    for each (var val in data.slice(0, n))
-        ret[val[0]] = val[1];
+    var length = Math.min(n, entData.length);
+    for (var i = 0; i < length; ++i)
+        ret[data[i][0]] = data[i][1];
 
     return new EntityCollection(this._ai, ret);
@@ -85 +112 @@
     
     var ret = {};
-    for (var id in this._entities)
-    {
-        var ent = this._entities[id];
-        if (filter.func.call(thisp, ent, id, this))
-            ret[id] = ent;
+    if (this._quickIter === true)
+    {
+        for (var i in this._entitiesArray)
+        {
+            var ent = this._entitiesArray[i];
+            var id = ent.id();
+            if (filter.func.call(thisp, ent, id, this))
+                ret[id] = ent;
+        }
+    } else {
+        for (var id in this._entities)
+        {
+            var ent = this._entities[id];
+            if (filter.func.call(thisp, ent, id, this))
+                ret[id] = ent;
+        }
     }
     
@@ -106 +144 @@
     }
     return new EntityCollection(this._ai, ret);
+};
+
+EntityCollection.prototype.forEach = function(callback)
+{
+    if (this._quickIter === true)
+    {
+        for (var id in this._entitiesArray)
+        {
+            callback(this._entitiesArray[id]);
+        }
+        return this;
+    }
+    for (var id in this._entities)
+    {
+        callback(this._entities[id]);
+    }
+    return this;
 };
 
@@ -131 +186 @@
 };
 
-EntityCollection.prototype.forEach = function(callback, thisp)
-{
-    for (var id in this._entities)
-    {
-        var ent = this._entities[id];
-        callback.call(thisp, ent, id, this);
-    }
-    return this;
-};
-
 EntityCollection.prototype.move = function(x, z, queued)
 {
@@ -242 +287 @@
         if (this.length !== undefined)
             this._length--;
+        if (this._quickIter === true)
+            this._entitiesArray.splice(this._entitiesArray.indexOf(ent),1);
         delete this._entities[ent.id()];
         return true;
@@ -264 +311 @@
             this._length++;
         this._entities[ent.id()] = ent;
+        if (this._quickIter === true)
+            this._entitiesArray.push(ent);
         return true;
     }
@@ -298 +347 @@
 };
 
+EntityCollection.prototype.unregister = function()
+{
+    this._ai.removeUpdatingEntityCollection(this);
+};
+
 EntityCollection.prototype.dynamicProperties = function()
 {

ps/trunk/binaries/data/mods/public/simulation/ai/common-api-v3/filters.js

@@ -42 +42 @@
         "dynamicProperties": ['metadata.' + key]};
     },
+
+    // can be used for stuffs which won't change once entities are created.
+    byStaticMetadata: function(player, key, value){
+        return {"func" : function(ent){
+            return (ent.getMetadata(player, key) == value);
+        },
+            "dynamicProperties": []};
+    },
+    
     byHasMetadata: function(player, key){
         return {"func" : function(ent){
@@ -98 +107 @@
     byCanGarrison: function(){
         return {"func" : function(ent){
-            return ent.garrisonMax();
+            return ent.garrisonMax() > 0;
         },
             "dynamicProperties": []};
@@ -127 +136 @@
             "dynamicProperties": []};
     },
+    
+    isGarrisoned: function(){
+        return {"func" : function(ent){
+            return ent.position() == -1;    // assumes garrisoned
+        },
+            "dynamicProperties": []};
+    },
 
     isSoldier: function(){
@@ -185 +201 @@
     isDropsite: function(resourceType){
         return {"func": function(ent){
-            return (ent.resourceDropsiteTypes() && ent.resourceDropsiteTypes().indexOf(resourceType) !== -1);
+            return (ent.resourceDropsiteTypes() && (resourceType === undefined || ent.resourceDropsiteTypes().indexOf(resourceType) !== -1));
         },
         "dynamicProperties": []};
@@ -204 +220 @@
             
             // And don't go for the bloody fish! TODO: better accessibility checks 
-            if (ent.hasClass("SeaCreature")){
+            if (ent.hasClass("SeaCreature")) {
                 return false;
             }

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

@@ -3 +3 @@
  * higher level than the raw data.
  */
-var GameState = function(SharedScript, state, player) {
+var GameState = function() {
+    this.ai = null; // must be updated by the AIs.
+    this.cellSize = 4; // Size of each map tile
+
+    this.buildingsBuilt = 0;
+    this.turnCache = {};
+};
+
+GameState.prototype.init = function(SharedScript, state, player) {
     this.sharedScript = SharedScript;
     this.EntCollecNames = SharedScript._entityCollectionsName;
     this.EntCollec = SharedScript._entityCollections;
-    this.timeElapsed = state.timeElapsed;
+    this.timeElapsed = SharedScript.timeElapsed;
     this.templates = SharedScript._templates;
     this.techTemplates = SharedScript._techTemplates;
     this.entities = SharedScript.entities;
     this.player = player;
-    this.playerData = state.players[player];
-    this.techModifications = SharedScript.techModifications[player];
-    this.buildingsBuilt = 0;
-    
-    this.ai = null; // must be updated by the AIs.
-    
-    this.cellSize = 4; // Size of each map tile
-    
-    this.turnCache = {};
-};
+    this.playerData = this.sharedScript.playersData[this.player];
+    this.techModifications = SharedScript._techModifications[this.player];
+};
+
 GameState.prototype.update = function(SharedScript, state) {
     this.sharedScript = SharedScript;
     this.EntCollecNames = SharedScript._entityCollectionsName;
     this.EntCollec = SharedScript._entityCollections;
-    this.timeElapsed = state.timeElapsed;
+    this.timeElapsed = SharedScript.timeElapsed;
     this.templates = SharedScript._templates;
     this.techTemplates = SharedScript._techTemplates;
+    this._entities = SharedScript._entities;
     this.entities = SharedScript.entities;
-    this.playerData = state.players[this.player];
-    this.techModifications = SharedScript.techModifications[this.player];
+    this.playerData = SharedScript.playersData[this.player];
+    this.techModifications = SharedScript._techModifications[this.player];
 
     this.buildingsBuilt = 0;
@@ -37 +40 @@
 };
 
-GameState.prototype.updatingCollection = function(id, filter, collection){
+GameState.prototype.updatingCollection = function(id, filter, collection, allowQuick){
     // automatically add the player ID
     id = this.player + "-" + id;
-        
     if (!this.EntCollecNames[id]){
         if (collection !== undefined)
@@ -47 +49 @@
             this.EntCollecNames[id] = this.entities.filter(filter);
         }
+        if (allowQuick)
+            this.EntCollecNames[id].allowQuickIter();
         this.EntCollecNames[id].registerUpdates();
+        //  warn ("New Collection named " +id);
     }
     
@@ -70 +75 @@
 };
 
-GameState.prototype.updatingGlobalCollection = function(id, filter, collection) {
+GameState.prototype.updatingGlobalCollection = function(id, filter, collection, allowQuick) {
     if (!this.EntCollecNames[id]){
         if (collection !== undefined)
@@ -76 +81 @@
         else
             this.EntCollecNames[id] = this.entities.filter(filter);
+        if (allowQuick)
+            this.EntCollecNames[id].allowQuickIter();
         this.EntCollecNames[id].registerUpdates();
+        //warn ("New Global Collection named " +id);
     }
     
@@ -104 +112 @@
         return 1;
     return 0;
+};
+
+GameState.prototype.townPhase = function()
+{
+    if (this.playerData.civ == "athen")
+        return "phase_town_athen";
+    return "phase_town_generic";
+};
+
+GameState.prototype.cityPhase = function()
+{
+    return "phase_city_generic";
 };
 
@@ -229 +249 @@
     return str.replace(/\{civ\}/g, this.playerData.civ);
 };
+
 GameState.prototype.civ = function() {
     return this.playerData.civ;
@@ -350 +371 @@
 };
 
-GameState.prototype.getOwnEntitiesByMetadata = function(key, value){
-    return this.updatingCollection(key + "-" + value, Filters.byMetadata(this.player, key, value),this.getOwnEntities());
+GameState.prototype.getOwnEntitiesByMetadata = function(key, value, maintain){
+    if (maintain === true)
+        return this.updatingCollection(key + "-" + value, Filters.byMetadata(this.player, key, value),this.getOwnEntities());
+    return this.getOwnEntities().filter(Filters.byMetadata(this.player, key, value));
 };
 
 GameState.prototype.getOwnEntitiesByRole = function(role){
-    return this.getOwnEntitiesByMetadata("role", role);
+    return this.getOwnEntitiesByMetadata("role", role, true);
 };
 
 GameState.prototype.getOwnTrainingFacilities = function(){
-    return this.updatingCollection("own-training-facilities", Filters.byTrainingQueue(), this.getOwnEntities());
+    return this.updatingCollection("own-training-facilities", Filters.byTrainingQueue(), this.getOwnEntities(), true);
 };
 
 GameState.prototype.getOwnResearchFacilities = function(){
-    return this.updatingCollection("own-research-facilities", Filters.byResearchAvailable(), this.getOwnEntities());
-};
-
-GameState.prototype.getOwnEntitiesByType = function(type){
+    return this.updatingCollection("own-research-facilities", Filters.byResearchAvailable(), this.getOwnEntities(), true);
+};
+
+GameState.prototype.getOwnEntitiesByType = function(type, maintain){
     var filter = Filters.byType(type);
-    return this.updatingCollection("own-by-type-" + type, filter, this.getOwnEntities());
-};
-
-GameState.prototype.countEntitiesByType = function(type) {
-    return this.getOwnEntitiesByType(type).length;
+    if (maintain === true)
+        return this.updatingCollection("own-by-type-" + type, filter, this.getOwnEntities());
+    return this.getOwnEntities().filter(filter);
+
+};
+
+GameState.prototype.countEntitiesByType = function(type, maintain) {
+    return this.getOwnEntitiesByType(type, maintain).length;
 };
 
 GameState.prototype.countEntitiesAndQueuedByType = function(type) {
-    var count = this.countEntitiesByType(type);
+    var count = this.countEntitiesByType(type, true);
     
     // Count building foundations
-    count += this.countEntitiesByType("foundation|" + type);
-    
-    // Count animal resources
-    count += this.countEntitiesByType("resource|" + type);
-
-    // Count entities in building production queues
-    this.getOwnTrainingFacilities().forEach(function(ent){
-        ent.trainingQueue().forEach(function(item) {
-            if (item.unitTemplate == type){
-                count += item.count;
-            }
+    if (this.getTemplate(type).hasClass("Structure") === true)
+        count += this.countEntitiesByType("foundation|" + type, true);
+    else if (this.getTemplate(type).resourceSupplyType() !== undefined) // animal resources
+        count += this.countEntitiesByType("resource|" + type, true);
+    else
+    {
+        // Count entities in building production queues
+        // TODO: maybe this fails for corrals.
+        this.getOwnTrainingFacilities().forEach(function(ent){
+            ent.trainingQueue().forEach(function(item) {
+                if (item.unitTemplate == type){
+                    count += item.count;
+                }
+            });
         });
-    });
+    }
     
     return count;
@@ -509 +538 @@
 
 GameState.prototype.getOwnDropsites = function(resource){
-    return this.updatingCollection("dropsite-own-" + resource, Filters.isDropsite(resource), this.getOwnEntities());
+    if (resource !== undefined)
+        return this.updatingCollection("dropsite-own-" + resource, Filters.isDropsite(resource), this.getOwnEntities(), true);
+    return this.updatingCollection("dropsite-own", Filters.isDropsite(), this.getOwnEntities(), true);
 };
 
 GameState.prototype.getResourceSupplies = function(resource){
-    return this.updatingGlobalCollection("resource-" + resource, Filters.byResource(resource), this.getEntities());
+    return this.updatingGlobalCollection("resource-" + resource, Filters.byResource(resource), this.getEntities(), true);
 };
 
@@ -590 +621 @@
                 ret.push([techs[1]._templateName, techs[1]] );
         } else {
-            if (this.canResearch(allResearchable[i]) && template._templateName != "phase_town_generic"
-                && template._templateName != "phase_town_athens" && template._templateName != "phase_city_generic")
+            if (this.canResearch(allResearchable[i]) && template._templateName != this.townPhase() && template._templateName != this.cityPhase())
                 ret.push( [allResearchable[i], template] );
         }

ps/trunk/binaries/data/mods/public/simulation/ai/common-api-v3/map-module.js

@@ -2 +2 @@
  * Copied with changes from QuantumState's original for qBot, it's a component for storing 8 bit values.
  */
+
+const TERRITORY_PLAYER_MASK = 0x3F;
 
 function Map(sharedScript, originalMap, actualCopy){
@@ -10 +12 @@
     this.length = gameMap.data.length;
     
+    this.maxVal = 255;
+
     if (originalMap && actualCopy){
         this.map = new Uint8Array(this.length);
@@ -22 +26 @@
 }
 
+Map.prototype.setMaxVal = function(val){
+    this.maxVal = val;
+};
+
 Map.prototype.gamePosToMapPos = function(p){
-    return [Math.round(p[0]/this.cellSize), Math.round(p[1]/this.cellSize)];
+    return [Math.floor(p[0]/this.cellSize), Math.floor(p[1]/this.cellSize)];
 };
 
@@ -44 +52 @@
         case 'linear':
             str = +strength / +maxDist;
-            break;
+        break;
         case 'quadratic':
             str = +strength / +maxDist2;
-            break;
+        break;
         case 'constant':
             str = +strength;
-            break;
+        break;
     }
         
@@ -72 +80 @@
                         break;
                 }
-                if (this.map[x + y * this.width] + quant > 255){
-                    this.map[x + y * this.width] = 255;
-                } else if (this.map[x + y * this.width] + quant < 0){
+                if (this.map[x + y * this.width] + quant < 0)
                     this.map[x + y * this.width] = 0;
-                } else {
+                else if (this.map[x + y * this.width] + quant > this.maxVal)
+                    this.map[x + y * this.width] = this.maxVal; // avoids overflow.
+                else
                     this.map[x + y * this.width] += quant;
-                }
             }
         }
@@ -127 +134 @@
                 }
                 var machin = this.map[x + y * this.width] * quant;
-                if (machin <= 0){
-                    this.map[x + y * this.width] = 0; //set anything which would have gone negative to 0
-                }else{
+                if (machin < 0)
+                    this.map[x + y * this.width] = 0;
+                else if (machin > this.maxVal)
+                    this.map[x + y * this.width] = this.maxVal;
+                else
                     this.map[x + y * this.width] = machin;
-                }
-            }
-        }
-    }
-};
+            }
+        }
+    }
+};
+
+// doesn't check for overflow.
 Map.prototype.setInfluence = function(cx, cy, maxDist, value) {
     value = value ? value : 0;
@@ -179 +189 @@
 };
 /**
- * Make each cell's 8-bit value at least one greater than each of its
- * neighbours' values. Possible assignment of a cap (maximum).
+ * Make each cell's 16-bit/8-bit value at least one greater than each of its
+ * neighbours' values. (If the grid is initialised with 0s and 65535s or 255s, the
+ * result of each cell is its Manhattan distance to the nearest 0.)
  */
 Map.prototype.expandInfluences = function(maximum, map) {
@@ -188 +199 @@
     
     if (maximum == undefined)
-        maximum = 255;
+        maximum = this.maxVal;
     var w = this.width;
     var h = this.height;
@@ -267 +278 @@
 // add to current map by the parameter map pixelwise
 Map.prototype.add = function(map){
-    for (var i = 0; i < this.length; ++i){
-        this.map[i] += +map.map[i];
-    }
-};
+    for (var i = 0; i < this.length; ++i) {
+        if (this.map[i] + map.map[i] < 0)
+            this.map[i] = 0;
+        else if (this.map[i] + map.map[i] > this.maxVal)
+            this.map[i] = this.maxVal;
+        else
+            this.map[i] += map.map[i];
+    }
+};
+
+Map.prototype.dumpIm = function(name, threshold){
+    name = name ? name : "default.png";
+    threshold = threshold ? threshold : this.maxVal;
+    Engine.DumpImage(name, this.map, this.width, this.height, threshold);
+};

ps/trunk/binaries/data/mods/public/simulation/ai/common-api-v3/shared.js

@@ -23 +23 @@
     this._entityCollectionsByDynProp = {};
     this._entityCollectionsUID = 0;
-        
+    
+    // A few notes about these maps. They're updated by checking for "create" and "destroy" events for all resources
+    // TODO: change the map when the resource amounts change for at least stone and metal mines.
+    this.resourceMaps = {}; // Contains maps showing the density of wood, stone and metal
+    this.CCResourceMaps = {}; // Contains maps showing the density of wood, stone and metal, optimized for CC placement.
+    // Resource maps data.
+    // By how much to divide the resource amount for plotting (ie a tree having 200 wood is "4").
+    this.decreaseFactor = {'wood': 50.0, 'stone': 90.0, 'metal': 90.0, 'food': 40.0};
+
     this.turn = 0;
 }
@@ -161 +169 @@
 // this is called right at the end of map generation, before you actually reach the map.
 SharedScript.prototype.initWithState = function(state) {    
-    this.passabilityClasses = state.passabilityClasses;
-    this.passabilityMap = state.passabilityMap;
-    this.territoryMap = state.territoryMap;
-
-    for (var o in state.players)
-        this._techModifications[o] = state.players[o].techModifications;
-    
-    this.techModifications = this._techModifications;
-    
-    this._entities = {};
-    for (var id in state.entities)
-    {
-        this._entities[id] = new Entity(this, state.entities[id]);
-    }
-    // entity collection updated on create/destroy event.
-    this.entities = new EntityCollection(this, this._entities);
-    
-    // create the terrain analyzer
-    this.terrainAnalyzer = new TerrainAnalysis(this, state);
-    this.accessibility = new Accessibility(state, this.terrainAnalyzer);
-    
-    this.gameState = {};
-    for (var i in this._players)
-    {
-        this.gameState[this._players[i]] = new GameState(this,state,this._players[i]);
-    }
-
-};
-
-// General update of the shared script, before each AI's update
-// applies entity deltas, and each gamestate.
-SharedScript.prototype.onUpdate = function(state)
-{
-    this.ApplyEntitiesDelta(state);
-    
-    Engine.ProfileStart("onUpdate");
-    
     this.events = state.events;
     this.passabilityClasses = state.passabilityClasses;
@@ -205 +176 @@
     this.territoryMap = state.territoryMap;
     this.timeElapsed = state.timeElapsed;
-    
+
     for (var o in state.players)
         this._techModifications[o] = state.players[o].techModifications;
+    
+    this._entities = {};
+    this.entities = new EntityCollection(this);
+
+    /* (var id in state.entities)
+    {
+        this._entities[id] = new Entity(this, state.entities[id]);
+    }
+    // entity collection updated on create/destroy event.
+    this.entities = new EntityCollection(this, this._entities);
+    */
+    
+    this.ApplyEntitiesDelta(state);
+
+    // create the terrain analyzer
+    this.terrainAnalyzer = new TerrainAnalysis();
+    this.terrainAnalyzer.init(this, state);
+    this.accessibility = new Accessibility();
+    this.accessibility.init(state, this.terrainAnalyzer);
+    
+    // defined in TerrainAnalysis.js
+    this.updateResourceMaps(this, this.events);
+
+    this.gameState = {};
+    for (var i in this._players)
+    {
+        this.gameState[this._players[i]] = new GameState();
+        this.gameState[this._players[i]].init(this,state,this._players[i]);
+    }
+
+};
+
+// General update of the shared script, before each AI's update
+// applies entity deltas, and each gamestate.
+SharedScript.prototype.onUpdate = function(state)
+{
+    if (this.turn !== 0)
+        this.ApplyEntitiesDelta(state);
+
+    Engine.ProfileStart("onUpdate");
+    
+    this.events = state.events;
+    this.passabilityClasses = state.passabilityClasses;
+    this.passabilityMap = state.passabilityMap;
+    this.players = this._players;
+    this.playersData = state.players;
+    this.territoryMap = state.territoryMap;
+    this.timeElapsed = state.timeElapsed;
+    
+    for (var o in state.players)
+        this._techModifications[o] = state.players[o].techModifications;
 
     for (var i in this.gameState)
         this.gameState[i].update(this,state);
 
+    if (this.turn !== 0)
+        this.updateResourceMaps(this, this.events);
     this.terrainAnalyzer.updateMapWithEvents(this);
     
@@ -224 +248 @@
 {
     Engine.ProfileStart("Shared ApplyEntitiesDelta");
+
+    var foundationFinished = {};
     
     for each (var evt in state.events)
@@ -237 +263 @@
 
             // Update all the entity collections since the create operation affects static properties as well as dynamic
-            for each (var entCollection in this._entityCollections)
-            {
-                entCollection.updateEnt(this._entities[evt.msg.entity]);
-            }
-
+            for (var entCollection in this._entityCollections)
+            {
+                this._entityCollections[entCollection].updateEnt(this._entities[evt.msg.entity]);
+            }
         }
         else if (evt.type == "Destroy")
@@ -253 +278 @@
                 continue;
             
+            if (foundationFinished[evt.msg.entity])
+                evt.msg["SuccessfulFoundation"] = true;
+            
             // The entity was destroyed but its data may still be useful, so
             // remember the entity and this AI's metadata concerning it
@@ -281 +309 @@
             }
         }
+        else if (evt.type == "ConstructionFinished")
+        {
+            // we can rely on this being before the "Destroy" command as this is the order defined by FOundation.js
+            // we'll move metadata.
+            if (!this._entities[evt.msg.entity])
+                continue;
+            var ent = this._entities[evt.msg.entity];
+            var newEnt = this._entities[evt.msg.newentity];
+            if (this._entityMetadata[ent.owner()] && this._entityMetadata[ent.owner()][evt.msg.entity] !== undefined)
+                for (var key in this._entityMetadata[ent.owner()][evt.msg.entity])
+                {
+                    this.setMetadata(ent.owner(), newEnt, key, this._entityMetadata[ent.owner()][evt.msg.entity][key])
+                }
+            foundationFinished[evt.msg.entity] = true;
+        }
+        else if (evt.type == "AIMetadata")
+        {
+            if (!this._entities[evt.msg.id])
+                continue;   // might happen in some rare cases of foundations getting destroyed, perhaps.
+            // Apply metadata (here for buildings for example)
+            for (var key in evt.msg.metadata)
+            {
+                this.setMetadata(evt.msg.owner, this._entities[evt.msg.id], key, evt.msg.metadata[key])
+            }
+        }
     }
     
@@ -286 +339 @@
     {
         var changes = state.entities[id];
-        
+
         for (var prop in changes)
         {
             this._entities[id]._entity[prop] = changes[prop];
+            
             this.updateEntityCollections(prop, this._entities[id]);
         }
@@ -336 +390 @@
     if (this._entityCollectionsByDynProp[property] !== undefined)
     {
-        for each (var entCollection in this._entityCollectionsByDynProp[property])
-        {
-            entCollection.updateEnt(ent);
+        for (var entCollectionid in this._entityCollectionsByDynProp[property])
+        {
+            this._entityCollectionsByDynProp[property][entCollectionid].updateEnt(ent);
         }
     }
@@ -360 +414 @@
         return undefined;
     return metadata[key];
+};
+SharedScript.prototype.deleteMetadata = function(player, ent, key)
+{
+    var metadata = this._entityMetadata[player][ent.id()];
+    
+    if (!metadata || !(key in metadata))
+        return true;
+    metadata[key] = undefined;
+    delete metadata[key];
+    return true;
 };
 

ps/trunk/binaries/data/mods/public/simulation/ai/common-api-v3/terrain-analysis.js

@@ -13 +13 @@
  */
 
-function TerrainAnalysis(sharedScript,rawState){
+function TerrainAnalysis() {
+    this.cellSize = 4;
+}
+
+copyPrototype(TerrainAnalysis, Map);
+
+TerrainAnalysis.prototype.init = function(sharedScript,rawState) {
     var self = this;
-    this.cellSize = 4;
 
     var passabilityMap = rawState.passabilityMap;
-
     this.width = passabilityMap.width;
     this.height = passabilityMap.height;
@@ -99 +103 @@
     this.obstructionMaskWater = null;
     this.obstructionMask = null;
-};
-
-copyPrototype(TerrainAnalysis, Map);
+    delete this.obstructionMaskLand;
+    delete this.obstructionMaskWater;
+    delete this.obstructionMask;
+};
 
 // Returns the (approximately) closest point which is passable by searching in a spiral pattern 
@@ -239 +244 @@
 
  */
-function Accessibility(rawState, terrainAnalyser){
+function Accessibility() {
+    
+}
+
+copyPrototype(Accessibility, TerrainAnalysis);
+
+Accessibility.prototype.init = function(rawState, terrainAnalyser){
     var self = this;
     
     this.Map(rawState, terrainAnalyser.map);
-    this.passMap = new Uint8Array(terrainAnalyser.length);
+    this.landPassMap = new Uint8Array(terrainAnalyser.length);
+    this.navalPassMap = new Uint8Array(terrainAnalyser.length);
 
     this.regionSize = [];
-    this.regionSize.push(0);
+    this.regionType = []; // "inaccessible", "land" or "water";
+    // ID of the region associated with an array of region IDs.
+    this.regionLinks = [];
     
     // initialized to 0, it's more optimized to start at 1 (I'm checking that if it's not 0, then it's already aprt of a region, don't touch);
@@ -252 +266 @@
     // So start at 2.
     this.regionID = 2;
-    for (var i = 0; i < this.passMap.length; ++i) {
-        if (this.passMap[i] === 0 && this.map[i] !== 0) {   // any non-painted, non-inacessible area.
-            this.regionSize.push(0);    // updated
-            this.floodFill(i,this.regionID,false);
-            this.regionID++;
-        } else if (this.passMap[i] === 0) { // any non-painted, inacessible area.
+    
+    for (var i = 0; i < this.landPassMap.length; ++i) {
+        if (this.map[i] !== 0) {    // any non-painted, non-inacessible area.
+            if (this.landPassMap[i] === 0 && this.floodFill(i,this.regionID,false))
+                this.regionType[this.regionID++] = "land";
+            if (this.navalPassMap[i] === 0 && this.floodFill(i,this.regionID,true))
+                this.regionType[this.regionID++] = "water";
+        } else if (this.landPassMap[i] === 0) { // any non-painted, inacessible area.
             this.floodFill(i,1,false);
-        }
-    }
+            this.floodFill(i,1,true);
+        }
+    }
+    
+    // calculating region links. Regions only touching diagonaly are not linked.
+    // since we're checking all of them, we'll check from the top left to the bottom right
+    var w = this.width;
+    for (var x = 0; x < this.width-1; ++x)
+    {
+        for (var y = 0; y < this.height-1; ++y)
+        {
+            // checking right.
+            var thisLID = this.landPassMap[x+y*w];
+            var thisNID = this.navalPassMap[x+y*w];
+            var rightLID = this.landPassMap[x+1+y*w];
+            var rightNID = this.navalPassMap[x+1+y*w];
+            var bottomLID = this.landPassMap[x+y*w+w];
+            var bottomNID = this.navalPassMap[x+y*w+w];
+            if (thisLID > 1)
+            {
+                if (rightNID > 1)
+                    if (this.regionLinks[thisLID].indexOf(rightNID) === -1)
+                        this.regionLinks[thisLID].push(rightNID);
+                if (bottomNID > 1)
+                    if (this.regionLinks[thisLID].indexOf(bottomNID) === -1)
+                        this.regionLinks[thisLID].push(bottomNID);
+            }
+            if (thisNID > 1)
+            {
+                if (rightLID > 1)
+                    if (this.regionLinks[thisNID].indexOf(rightLID) === -1)
+                        this.regionLinks[thisNID].push(rightLID);
+                if (bottomLID > 1)
+                    if (this.regionLinks[thisNID].indexOf(bottomLID) === -1)
+                        this.regionLinks[thisNID].push(bottomLID);
+                if (thisLID > 1)
+                    if (this.regionLinks[thisNID].indexOf(thisLID) === -1)
+                        this.regionLinks[thisNID].push(thisLID);
+            }
+        }
+    }
+    
+    //warn(uneval(this.regionLinks));
+
+    //Engine.DumpImage("LandPassMap.png", this.landPassMap, this.width, this.height, 255);
+    //Engine.DumpImage("NavalPassMap.png", this.navalPassMap, this.width, this.height, 255);
 }
-copyPrototype(Accessibility, TerrainAnalysis);
-
-Accessibility.prototype.getAccessValue = function(position){
+
+Accessibility.prototype.getAccessValue = function(position, onWater) {
     var gamePos = this.gamePosToMapPos(position);
-    return this.passMap[gamePos[0] + this.width*gamePos[1]];
+    if (onWater === true)
+        return this.navalPassMap[gamePos[0] + this.width*gamePos[1]];
+    var ret = this.landPassMap[gamePos[0] + this.width*gamePos[1]];
+    if (ret === 1)
+    {
+        // quick spiral search.
+        var indx = [ [-1,-1],[-1,0],[-1,1],[0,1],[1,1],[1,0],[1,-1],[0,-1]]
+        for (i in indx)
+        {
+            ret = this.landPassMap[gamePos[0]+indx[0] + this.width*(gamePos[1]+indx[0])]
+            if (ret !== undefined && ret !== 1)
+                return ret;
+        }
+    }
+    return ret;
 };
 
@@ -284 +357 @@
 // Hardcore means is also checks for isAccessible at the end (it checks for either water or land though, beware).
 // This is a blind check and not a pathfinder: for all it knows there is a huge block of trees in the middle.
-Accessibility.prototype.pathAvailable = function(gameState, start,end, hardcore){
+Accessibility.prototype.pathAvailable = function(gameState, start, end, onWater, hardcore){
     var pstart = this.gamePosToMapPos(start);
     var istart = pstart[0] + pstart[1]*this.width;
     var pend = this.gamePosToMapPos(end);
     var iend = pend[0] + pend[1]*this.width;
-
-    if (this.passMap[istart] === this.passMap[iend]) {
-        if (hardcore && (this.isAccessible(gameState, end,true) || this.isAccessible(gameState, end,false)))
+    if (onWater)
+    {
+        if (this.navalPassMap[istart] === this.navalPassMap[iend]) {
+            if (hardcore && this.isAccessible(gameState, end,false))
+                return true;
+            else if (hardcore)
+                return false;
             return true;
-        else if (hardcore)
-            return false;
-        return true;
+        }
+    } else {
+        if (this.landPassMap[istart] === this.landPassMap[iend]) {
+            if (hardcore && this.isAccessible(gameState, end,true))
+                return true;
+            else if (hardcore)
+                return false;
+            return true;
+        }
     }
     return false;
 };
-Accessibility.prototype.getRegionSize = function(position){
+
+Accessibility.prototype.getTrajectTo = function(start, end, noBound) {
+    var pstart = this.gamePosToMapPos(start);
+    var istart = pstart[0] + pstart[1]*this.width;
+    var pend = this.gamePosToMapPos(end);
+    var iend = pend[0] + pend[1]*this.width;
+    
+    var onLand = true;
+    if (this.landPassMap[istart] <= 1 && this.navalPassMap[istart] > 1)
+        onLand = false;
+    if (this.landPassMap[istart] <= 1 && this.navalPassMap[istart] <= 1)
+        return false;
+    
+    var endRegion = this.landPassMap[iend];
+    if (endRegion <= 1 && this.navalPassMap[iend] > 1)
+        endRegion = this.navalPassMap[iend];
+    else if (endRegion <= 1)
+        return false;
+    
+    if (onLand)
+        var startRegion = this.landPassMap[istart];
+    else
+        var startRegion = this.navalPassMap[istart];
+
+    return this.getTrajectToIndex(startRegion, endRegion, noBound);
+}
+
+// Return a "path" of accessibility indexes from one point to another, including the start and the end indexes (unless specified otherwise)
+// this can tell you what sea zone you need to have a dock on, for example.
+// assumes a land unit unless start point is over deep water.
+// if the path is more complicated than "land->sea->land" (or "sea->land->sea"), it will run A* to try and figure it out
+// Thus it can handle arbitrarily complicated paths (theoretically).
+Accessibility.prototype.getTrajectToIndex = function(istart, iend, noBound){
+    var startRegion = istart;
+    var currentRegion = istart;
+    
+    var endRegion = iend;
+    
+    // optimizations to avoid needless memory usage
+    // if it's the same, return the path
+    if (startRegion === endRegion)
+        return [startRegion];
+    else if (this.regionLinks[startRegion].indexOf(endRegion) !== -1)
+        return [startRegion, endRegion];
+    else
+    {
+        var rgs = this.regionLinks[startRegion];
+        for (p in rgs)
+        {
+            if (this.regionLinks[rgs[p]].indexOf(endRegion) !== -1)
+                return [startRegion, rgs[p], endRegion];
+        }
+    }
+    // it appears to be difficult.
+    // computing A* over a graph with all nodes equally good (might want to change this sometimes), currently it returns the shortest path switch-wise.
+    this.openList = [];
+    this.parentSquare = new Uint8Array(this.regionSize.length);
+    this.isOpened = new Boolean(this.regionSize.length);
+    this.gCostArray = new Uint8Array(this.regionSize.length);
+
+    this.isOpened[currentRegion] = true;
+    this.openList.push(currentRegion);
+    this.gCostArray[currentRegion] = 0;
+    this.parentSquare[currentRegion] = currentRegion;
+
+    var w = this.width;
+    var h = this.height;
+    
+    //creation of variables used in the loop
+    var found = false;
+
+    // on to A*
+    while (found === false && this.openList.length !== 0) {
+        var currentDist = 300;
+        var ti = 0;
+        for (var i in this.openList)
+        {
+            var sum = this.gCostArray[this.openList[i]];
+            if (sum < currentDist)
+            {
+                ti = i;
+                currentRegion = this.openList[i];
+                currentDist = sum;
+            }
+        }
+        this.openList.splice(ti,1);
+        this.isOpened[currentRegion] = false;
+
+        // special case, might make it faster (usually oceans connect multiple land masses, sometimes all of them)
+        if (this.regionType[currentRegion] == "water" && endLand)
+        {
+            var idx = this.regionLinks[currentRegion].indexOf(endRegion);
+            if (idx !== -1)
+            {
+                this.parentSquare[endRegion] = currentRegion;
+                this.gCostArray[endRegion] = this.gCostArray[currentRegion] + 1;
+                found = true;
+                break;
+            }
+        }
+        for (var i in this.regionLinks[currentRegion])
+        {
+            var region = this.regionLinks[currentRegion][i];
+            if(this.isOpened[region] === undefined)
+            {
+                this.parentSquare[region] = currentRegion;
+                this.gCostArray[region] = this.gCostArray[currentRegion] + 1;
+                this.openList.push(region);
+                this.isOpened[region] = true;
+                if (region === endRegion)
+                {
+                    found = true;
+                    break;
+                }
+            } else {
+                if (this.gCostArray[region] > 1 + this.gCostArray[currentRegion])
+                {
+                    this.parentSquare[region] = currentRegion;
+                    this.gCostArray[region] = 1 + this.gCostArray[currentRegion];
+                }
+            }
+        }
+    }
+    var path = [];
+    if (found) {
+        currentRegion = endRegion;
+        if (!noBound)
+            path.push(currentRegion);
+        while (this.parentSquare[currentRegion] !== startRegion)
+        {
+            currentRegion = this.parentSquare[currentRegion];
+            path.push(currentRegion);
+        }
+        if (!noBound)
+            path.push(startRegion);
+    } else {
+        delete this.parentSquare;
+        delete this.isOpened;
+        delete this.gCostArray;
+        return false;
+    }
+    
+    delete this.parentSquare;
+    delete this.isOpened;
+    delete this.gCostArray;
+    
+    return path;
+};
+
+Accessibility.prototype.getRegionSize = function(position, onWater){
     var pos = this.gamePosToMapPos(position);
     var index = pos[0] + pos[1]*this.width;
-    if (this.regionSize[this.passMap[index]] === undefined)
+    var ID = (onWater === true) ? this.navalPassMap[index] : this.landPassMap[index];
+    if (this.regionSize[ID] === undefined)
         return 0;
-    return this.regionSize[this.passMap[index]];
-};
-Accessibility.prototype.getRegionSizei = function(index) {
-    if (this.regionSize[this.passMap[index]] === undefined)
+    return this.regionSize[ID];
+};
+
+Accessibility.prototype.getRegionSizei = function(index, onWater) {
+    if (this.regionSize[this.landPassMap[index]] === undefined && (!onWater || this.regionSize[this.navalPassMap[index]] === undefined))
         return 0;
-    return this.regionSize[this.passMap[index]];
-};
-
-// Implementation of a fast flood fill. Reasonably good performances. Runs once at startup.
+    if (onWater && this.regionSize[this.navalPassMap[index]] > this.regionSize[this.landPassMap[index]])
+        return this.regionSize[this.navalPassMap[index]];
+    return this.regionSize[this.landPassMap[index]];
+};
+
+// Implementation of a fast flood fill. Reasonably good performances for JS.
 // TODO: take big zones of impassable trees into account?
 Accessibility.prototype.floodFill = function(startIndex, value, onWater)
 {
     this.s = startIndex;
-    if (this.passMap[this.s] !== 0) {
+    if ((!onWater && this.landPassMap[this.s] !== 0) || (onWater && this.navalPassMap[this.s] !== 0) ) {
         return false;   // already painted.
     }
     
     this.floodFor = "land";
-    if (this.map[this.s] === 200 || (this.map[this.s] === 201 && onWater === true))
+    if (this.map[this.s] === 0)
+    {
+        this.landPassMap[this.s] = 1;
+        this.navalPassMap[this.s] = 1;
+        return false;
+    }
+    if (onWater === true)
+    {
+        if (this.map[this.s] !== 200 && this.map[this.s] !== 201)
+        {
+            this.navalPassMap[this.s] = 1;  // impassable for naval
+            return false;   // do nothing
+        }
         this.floodFor = "water";
-    else if (this.map[this.s] === 0)
-        this.floodFor = "impassable";
-
+    } else if (this.map[this.s] === 200) {
+        this.landPassMap[this.s] = 1;   // impassable for land
+        return false;
+    }
+    
+    // here we'll be able to start.
+    for (var i = this.regionSize.length; i <= value; ++i)
+    {
+        this.regionLinks.push([]);
+        this.regionSize.push(0);
+        this.regionType.push("inaccessible");
+    }
     var w = this.width;
     var h = this.height;
@@ -348 +605 @@
             if (index < 0)
                 break;
-            if (this.floodFor === "impassable" && this.map[index] === 0 && this.passMap[index] === 0) {
+            if (this.floodFor === "land" && this.landPassMap[index] === 0 && this.map[index] !== 0 && this.map[index] !== 200) {
                 loop = true;
-            } else if (this.floodFor === "land" && this.passMap[index] === 0 && this.map[index] !== 0 && this.map[index] !== 200) {
-                loop = true;
-            } else if (this.floodFor === "water" && this.passMap[index] === 0 && (this.map[index] === 200 || (this.map[index] === 201 && this.onWater)) ) {
+            } else if (this.floodFor === "water" && this.navalPassMap[index] === 0 && (this.map[index] === 200 || this.map[index] === 201)) {
                 loop = true;
             } else {
@@ -364 +619 @@
         do {
             var index = +newIndex + w*y;
-            if (this.floodFor === "impassable" && this.map[index] === 0 && this.passMap[index] === 0) {
-                this.passMap[index] = value;
+            
+            if (this.floodFor === "land" && this.landPassMap[index] === 0 && this.map[index] !== 0 && this.map[index] !== 200) {
+                this.landPassMap[index] = value;
                 this.regionSize[value]++;
-            } else if (this.floodFor === "land" && this.passMap[index] === 0 && this.map[index] !== 0 && this.map[index] !== 200) {
-                this.passMap[index] = value;
-                this.regionSize[value]++;
-            } else if (this.floodFor === "water" && this.passMap[index] === 0 && (this.map[index] === 200 || (this.map[index] === 201 && this.onWater)) ) {
-                this.passMap[index] = value;
+            } else if (this.floodFor === "water" && this.navalPassMap[index] === 0 && (this.map[index] === 200 || this.map[index] === 201)) {
+                this.navalPassMap[index] = value;
                 this.regionSize[value]++;
             } else {
@@ -379 +632 @@
             if (index%w > 0)
             {
-                if (this.floodFor === "impassable" && this.map[index -1] === 0 && this.passMap[index -1] === 0) {
+                if (this.floodFor === "land" && this.landPassMap[index -1] === 0 && this.map[index -1] !== 0 && this.map[index -1] !== 200) {
                     if(!reachLeft) {
                         IndexArray.push(index -1);
                         reachLeft = true;
                     }
-                } else if (this.floodFor === "land" && this.passMap[index -1] === 0 && this.map[index -1] !== 0 && this.map[index -1] !== 200) {
+                } else if (this.floodFor === "water" && this.navalPassMap[index -1] === 0 && (this.map[index -1] === 200 || this.map[index -1] === 201)) {
                     if(!reachLeft) {
                         IndexArray.push(index -1);
                         reachLeft = true;
                     }
-                } else if (this.floodFor === "water" && this.passMap[index -1] === 0 && (this.map[index -1] === 200 || (this.map[index -1] === 201 && this.onWater)) ) {
-                    if(!reachLeft) {
-                        IndexArray.push(index -1);
-                        reachLeft = true;
-                    }
                 } else if(reachLeft) {
                     reachLeft = false;
@@ -400 +648 @@
             if (index%w < w - 1)
             {
-                if (this.floodFor === "impassable" && this.map[index +1] === 0 && this.passMap[index +1] === 0) {
+                if (this.floodFor === "land" && this.landPassMap[index +1] === 0 && this.map[index +1] !== 0 && this.map[index +1] !== 200) {
                     if(!reachRight) {
                         IndexArray.push(index +1);
                         reachRight = true;
                     }
-                } else if (this.floodFor === "land" && this.passMap[index +1] === 0 && this.map[index +1] !== 0 && this.map[index +1] !== 200) {
+                } else if (this.floodFor === "water" && this.navalPassMap[index +1] === 0 && (this.map[index +1] === 200 || this.map[index +1] === 201)) {
                     if(!reachRight) {
                         IndexArray.push(index +1);
                         reachRight = true;
                     }
-                } else if (this.floodFor === "water" && this.passMap[index +1] === 0 && (this.map[index +1] === 200 || (this.map[index +1] === 201 && this.onWater)) ) {
-                    if(!reachRight) {
-                        IndexArray.push(index +1);
-                        reachRight = true;
-                    }
                 } else if(reachRight) {
                     reachRight = false;
@@ -420 +663 @@
             }
             ++y;
-        } while (index/w < w)   // should actually break
+        } while (index/w < w-1) // should actually break
     }
     return true;
 }
 
-function landSizeCounter(rawState,terrainAnalyzer) {
-    var self = this;
-    
-    this.passMap = terrainAnalyzer.map;
-
-    var map = new Uint8Array(this.passMap.length);
-    this.Map(rawState,map);
-
-    
-    for (var i = 0; i < this.passMap.length; ++i) {
-        if (this.passMap[i] !== 0)
-            this.map[i] = 255;
-        else
-            this.map[i] = 0;
-    }
-    
-    this.expandInfluences();
-}
-copyPrototype(landSizeCounter, TerrainAnalysis);
-
-// Implementation of A* as a flood fill. Possibility of (clever) oversampling
-// for efficiency or for disregarding too small passages.
-// can operate over several turns, though default is only one turn.
-landSizeCounter.prototype.getAccessibleLandSize = function(position, sampling, mode, OnlyBuildable, sizeLimit, iterationLimit)
-{
-    if (sampling === undefined)
-        this.Sampling = 1;
-    else
-        this.Sampling = sampling < 1 ? 1 : sampling;
-    
-    // this checks from the actual starting point. If that is inaccessible (0), it returns undefined;
-    if (position.length !== undefined) {
-        // this is an array
-        if (position[0] < 0 || this.gamePosToMapPos(position)[0] >= this.width || position[1] < 0 || this.gamePosToMapPos(position)[1] >= this.height)
-            return undefined;
-        
-        var s = this.gamePosToMapPos(position);
-        this.s = s[0] + w*s[1];
-        if (this.map[this.s] === 0 || this.map[this.s] === 200 || (OnlyBuildable === true && this.map[this.s] === 201) ) {
-            return undefined;
-        }
-    } else {
-        this.s = position;
-        if (this.map[this.s] === 0 || this.map[this.s] === 200 || (OnlyBuildable === true && this.map[this.s] === 201) ) {
-            return undefined;
-        }
-    }
-        
-    if (mode === undefined)
-        this.mode = "default";
-    else
-        this.mode = mode;
-
-    if (sizeLimit === undefined)
-        this.sizeLimit = 300000;
-    else
-        this.sizeLimit = sizeLimit;
-
-    var w = this.width;
-    var h = this.height;
-    
-    // max map size is 512*512, this is higher.
-    this.iterationLimit = 300000;
-    if (iterationLimit !== undefined)
-        this.iterationLimit = iterationLimit;
-    
-    this.openList = [];
-    this.isOpened = new Boolean(this.map.length);
-    this.gCostArray = new Uint16Array(this.map.length);
-
-    this.currentSquare = this.s;
-    this.isOpened[this.s] = true;
-    this.openList.push(this.s);
-    this.gCostArray[this.s] = 0;
-    
-    this.countedValue = 1;
-    this.countedArray = [this.s];
-    
-    if (OnlyBuildable !== undefined)
-        this.onlyBuildable = OnlyBuildable;
-    else
-        this.onlyBuildable = true;
-    
-    return this.continueLandSizeCalculation();
-}
-landSizeCounter.prototype.continueLandSizeCalculation = function()
-{
-    var w = this.width;
-    var h = this.height;
-    var positions = [[0,1], [0,-1], [1,0], [-1,0], [1,1], [-1,-1], [1,-1], [-1,1]];
-    var cost = [10,10,10,10,15,15,15,15];
-    
-    //creation of variables used in the loop
-    var nouveau = false;
-    var shortcut = false;
-    var Sampling = this.Sampling;
-    var infinity = Math.min();
-    var currentDist = infinity;
-    
-    var iteration = 0;
-    while (this.openList.length !== 0 && iteration < this.iterationLimit && this.countedValue < this.sizeLimit && this.countedArray.length < this.sizeLimit){
-        currentDist = infinity;
-        for (var i in this.openList)
-        {
-            var sum = this.gCostArray[this.openList[i]];
-            if (sum < currentDist)
-            {
-                this.currentSquare = this.openList[i];
-                currentDist = sum;
-            }
-        }
-        this.openList.splice(this.openList.indexOf(this.currentSquare),1);
-
-        shortcut = false;
-        this.isOpened[this.currentSquare] = false;
-        for (var i in positions) {
-            var index = 0 + this.currentSquare + positions[i][0]*Sampling + w*Sampling*positions[i][1];
-            if (this.passMap[index] !== 0 && this.passMap[index] !== 200 && this.map[index] >= Sampling && (!this.onlyBuildable || this.passMap[index] !== 201)) {
-                if(this.isOpened[index] === undefined) {
-                    if (this.mode === "default")
-                        this.countedValue++;
-                    else if (this.mode === "array")
-                        this.countedArray.push(index);
-                    this.gCostArray[index] = this.gCostArray[this.currentSquare] + cost[i] * Sampling;
-                    this.openList.push(index);
-                    this.isOpened[index] = true;
-                }
-            }
-        }
-        iteration++;
-    }
-    
-    if (iteration === this.iterationLimit && this.openList.length !== 0 && this.countedValue !== this.sizeLimit && this.countedArray.length !== this.sizeLimit)
-    {
-        // we've got to assume that we stopped because we reached the upper limit of iterations
-        return "toBeContinued";
-    }
-        
-    delete this.parentSquare;
-    delete this.isOpened;
-    delete this.fCostArray;
-    delete this.gCostArray;
-    
-    if (this.mode === "default")
-        return this.countedValue;
-    else if (this.mode === "array")
-        return this.countedArray;
-    return undefined;
-}
+// TODO: make it regularly update stone+metal mines and their resource levels.
+// creates and maintains a map of unused resource density
+// this also takes dropsites into account.
+// resources that are "part" of a dropsite are not counted.
+SharedScript.prototype.updateResourceMaps = function(sharedScript, events) {
+    
+    for (var resource in this.decreaseFactor){
+        // if there is no resourceMap create one with an influence for everything with that resource
+        if (! this.resourceMaps[resource]){
+            // We're creting them 8-bit. Things could go above 255 if there are really tons of resources
+            // But at that point the precision is not really important anyway. And it saves memory.
+            this.resourceMaps[resource] = new Map(sharedScript, new Uint8Array(sharedScript.passabilityMap.data.length));
+            this.resourceMaps[resource].setMaxVal(255);
+            this.CCResourceMaps[resource] = new Map(sharedScript, new Uint8Array(sharedScript.passabilityMap.data.length));
+            this.CCResourceMaps[resource].setMaxVal(255);
+        }
+    }
+    
+    // Look for destroy events and subtract the entities original influence from the resourceMap
+    // TODO: perhaps do something when dropsites appear/disappear.
+    for (var key in events) {
+        var e = events[key];
+        if (e.type === "Destroy") {
+            if (e.msg.entityObj){
+                var ent = e.msg.entityObj;
+                if (ent && ent.position() && ent.resourceSupplyType() && ent.resourceSupplyType().generic !== "treasure") {
+                    var resource = ent.resourceSupplyType().generic;
+                    var x = Math.floor(ent.position()[0] / 4);
+                    var z = Math.floor(ent.position()[1] / 4);
+                    var strength = Math.floor(ent.resourceSupplyMax()/this.decreaseFactor[resource]);
+                    
+                    if (resource === "wood" || resource === "food")
+                    {
+                        this.resourceMaps[resource].addInfluence(x, z, 2, 5,'constant');
+                        this.resourceMaps[resource].addInfluence(x, z, 9.0, -strength,'constant');
+                        this.CCResourceMaps[resource].addInfluence(x, z, 15, -strength/2.0,'constant');
+                    }
+                    else if (resource === "stone" || resource === "metal")
+                    {
+                        this.resourceMaps[resource].addInfluence(x, z, 8, 50);
+                        this.resourceMaps[resource].addInfluence(x, z, 12.0, -strength/1.5);
+                        this.resourceMaps[resource].addInfluence(x, z, 12.0, -strength/2.0,'constant');
+                        this.CCResourceMaps[resource].addInfluence(x, z, 30, -strength,'constant');
+                    }
+                }
+            }
+        } else if (e.type === "Create") {
+            if (e.msg.entity){
+                var ent = sharedScript._entities[e.msg.entity];
+                if (ent && ent.position() && ent.resourceSupplyType() && ent.resourceSupplyType().generic !== "treasure"){
+                    var resource = ent.resourceSupplyType().generic;
+                    
+                    var x = Math.floor(ent.position()[0] / 4);
+                    var z = Math.floor(ent.position()[1] / 4);
+                    var strength = Math.floor(ent.resourceSupplyMax()/this.decreaseFactor[resource]);
+                    if (resource === "wood" || resource === "food")
+                    {
+                        this.CCResourceMaps[resource].addInfluence(x, z, 15, strength/2.0,'constant');
+                        this.resourceMaps[resource].addInfluence(x, z, 9.0, strength,'constant');
+                        this.resourceMaps[resource].addInfluence(x, z, 2, -5,'constant');
+                    }
+                    else if (resource === "stone" || resource === "metal")
+                    {
+                        this.CCResourceMaps[resource].addInfluence(x, z, 30, strength,'constant');
+                        this.resourceMaps[resource].addInfluence(x, z, 12.0, strength/1.5);
+                        this.resourceMaps[resource].addInfluence(x, z, 12.0, strength/2.0,'constant');
+                        this.resourceMaps[resource].addInfluence(x, z, 8, -50);
+                    }
+                }
+            }
+        }
+    }
+};