Ticket #1089: qbot_full_serialize.patch

binaries/data/mods/public/simulation/ai/common-api-v2/base.js

@@ -4 +4 @@
         return;
 
     // Make some properties non-enumerable, so they won't be serialised
-    Object.defineProperty(this, "_player", {value: settings.player, enumerable: false});
-    Object.defineProperty(this, "_templates", {value: settings.templates, enumerable: false});
-    Object.defineProperty(this, "_derivedTemplates", {value: {}, enumerable: false});
+    // Object.defineProperty(this, "_player", {value: settings.player, enumerable: false});
+    // Object.defineProperty(this, "_templates", {value: settings.templates, enumerable: false});
+    // Object.defineProperty(this, "_derivedTemplates", {value: {}, enumerable: false});
+    this._player = settings.player;
+    this._templates = settings.templates;
+    this._derivedTemplates = {};
 
     this._entityMetadata = {};
 
@@ -17 +20 @@
     this.turn = 0;
 }
 
-//Return a simple object (using no classes etc) that will be serialized
-//into saved games
-BaseAI.prototype.Serialize = function()
-{
-    var rawEntities = {};
-    
-    for (var id in this._entities)
-    {
-        rawEntities[id] = this._entities[id]._entity;
-    }
-    
-    return {
-        _rawEntities: rawEntities,
-        _entityMetadata: this._entityMetadata,
-    };
-
-    // TODO: ought to get the AI script subclass to serialize its own state
-};
-
-//Called after the constructor when loading a saved game, with 'data' being
-//whatever Serialize() returned
-BaseAI.prototype.Deserialize = function(data)
-{
-    var rawEntities = data._rawEntities;
-    this._entityMetadata = data._entityMetadata;
-    this._entities = {}
-    
-    for (var id in rawEntities)
-    {
-        this._entities[id] = new Entity(this, rawEntities[id]);
-    }
-
-    // TODO: ought to get the AI script subclass to deserialize its own state
-};
-
 // Components that will be disabled in foundation entity templates.
 // (This is a bit yucky and fragile since it's the inverse of
 // CCmpTemplateManager::CopyFoundationSubset and only includes components
@@ -306 +274 @@
         return undefined;
     return metadata[key];
 }
+
+Engine.RegisterSerializablePrototype("BaseAI", BaseAI.prototype);

binaries/data/mods/public/simulation/ai/common-api-v2/entity.js

@@ -452 +452 @@
     },
 });
 
+Engine.RegisterSerializablePrototype("Entity", Entity.prototype);
+Engine.RegisterSerializablePrototype("EntityTemplate", EntityTemplate.prototype);
+

binaries/data/mods/public/simulation/ai/common-api-v2/entitycollection.js

@@ -8 +8 @@
     // Compute length lazily on demand, since it can be
     // expensive for large collections
     this._length = undefined;
-    Object.defineProperty(this, "length", {
-        get: function () {
-            if (this._length === undefined)
-            {
-                this._length = 0;
-                for (var id in entities)
-                    ++this._length;
-            }
-            return this._length;
-        }
-    });
 }
 
+// Add custom getter on the prototype so the serializer doesn't lose it
+// TODO: why don't we just use .getLength() instead of hiding this?
+Object.defineProperty(EntityCollection.prototype, "length", {
+    get: function () {
+        if (this._length === undefined)
+        {
+            this._length = 0;
+            for (var id in this._entities)
+                ++this._length;
+        }
+        return this._length;
+    }
+});
+
 EntityCollection.prototype.toIdArray = function()
 {
     var ret = [];
@@ -67 +70 @@
     return new EntityCollection(this._ai, ret);
 };
 
-EntityCollection.prototype.filter = function(filter, thisp)
+EntityCollection.prototype.filter = function(filter)
 {
-    if (typeof(filter) == "function")
-        filter = {"func": filter, "dynamicProperties": []};
-    
     var ret = {};
     for (var id in this._entities)
     {
         var ent = this._entities[id];
-        if (filter.func.call(thisp, ent, id, this))
+        if (filter.test(ent))
             ret[id] = ent;
     }
     
@@ -160 +160 @@
     var passesFilters = true;
     for each (var filter in this._filters)
     {
-        passesFilters = passesFilters && filter.func(ent);
+        passesFilters = passesFilters && filter.test(ent);
     }
 
     if (passesFilters)
@@ -198 +198 @@
 {
     return this._UID;
 };
+
+Engine.RegisterSerializablePrototype("EntityCollection", EntityCollection.prototype);

binaries/data/mods/public/simulation/ai/common-api-v2/filters.js

@@ -1 @@
-var Filters = {
-    byType: function(type){
-        return {"func" : function(ent){
-            return ent.templateName() === type;
-        },
-        "dynamicProperties": []};
-    },
+// TODO: Some of these can use inheritance
+
+function FilterByType(type)
+{
+    this.type = type;
+    this.dynamicProperties = [];
+}
+FilterByType.prototype.test = function(ent)
+{
+    return ent.templateName() === this.type;
+};
+Engine.RegisterSerializablePrototype("FilterByType", FilterByType.prototype);
+
+function FilterByClass(cls)
+{
+    this.cls = cls;
+    this.dynamicProperties = [];
+}
+FilterByClass.prototype.test = function(ent)
+{
+    return ent.hasClass(this.cls);
+};
+Engine.RegisterSerializablePrototype("FilterByClass", FilterByClass.prototype);
+
+function FilterByClassesAnd(clsList)
+{
+    this.clsList = clsList;
+    this.dynamicProperties = [];
+}
+FilterByClassesAnd.prototype.test = function(ent)
+{
+    var ret = true;
+    for (var i in this.clsList){
+        ret = ret && ent.hasClass(this.clsList[i]);
+    }
+    return ret;
+};
+Engine.RegisterSerializablePrototype("FilterByClassesAnd", FilterByClassesAnd.prototype);
+
+function FilterByClassesOr(clsList)
+{
+    this.clsList = clsList;
+    this.dynamicProperties = [];
+}
+FilterByClassesOr.prototype.test = function(ent)
+{
+    var ret = false;
+    for (var i in this.clsList){
+        ret = ret || ent.hasClass(this.clsList[i]);
+    }
+    return ret;
+};
+Engine.RegisterSerializablePrototype("FilterByClassesOr", FilterByClassesOr.prototype);
+
+function FilterByMetadata(key, value)
+{
+    this.key = key;
+    this.value = value;
+    this.dynamicProperties = "metadata." + key;
+}
+FilterByMetadata.prototype.test = function(ent)
+{
+    return (ent.getMetadata(this.key) == this.value);
+};
+Engine.RegisterSerializablePrototype("FilterByMetadata", FilterByMetadata.prototype);
+
+function FilterAnd(filter1, filter2)
+{
+    this.filter1 = filter1;
+    this.filter2 = filter2;
+    this.dynamicProperties = filter1.dynamicProperties.concat(filter2.dynamicProperties);
+}
+FilterAnd.prototype.test = function(ent)
+{
+    return this.filter1.test(ent) && this.filter2.test(ent);
+};
+Engine.RegisterSerializablePrototype("FilterAnd", FilterAnd.prototype);
+
+function FilterOr(filter1, filter2)
+{
+    this.filter1 = filter1;
+    this.filter2 = filter2;
+    this.dynamicProperties = filter1.dynamicProperties.concat(filter2.dynamicProperties);
+}
+FilterOr.prototype.test = function(ent)
+{
+    return this.filter1.test(ent) || this.filter2.test(ent);
+};
+Engine.RegisterSerializablePrototype("FilterOr", FilterOr.prototype);
+
+function FilterNot(filter)
+{
+    this.filter = filter;
+    this.dynamicProperties = filter.dynamicProperties;
+}
+FilterNot.prototype.test = function(ent)
+{
+    return !this.filter.test(ent);
+};
+Engine.RegisterSerializablePrototype("FilterNot", FilterNot.prototype);
+
+function FilterByOwner(owner)
+{
+    this.owner = owner;
+    this.dynamicProperties = ["owner"];
+}
+FilterByOwner.prototype.test = function(ent)
+{
+    return (ent.owner() === this.owner);
+};
+Engine.RegisterSerializablePrototype("FilterByOwner", FilterByOwner.prototype);
     
-    byClass: function(cls){
-        return {"func" : function(ent){
-            return ent.hasClass(cls);
-        },
-        "dynamicProperties": []};
-    },
+function FilterByNotOwner(owner)
+{
+    this.owner = owner;
+    this.dynamicProperties = ["owner"];
+}
+FilterByNotOwner.prototype.test = function(ent)
+{
+    return (ent.owner() !== this.owner);
+};
+Engine.RegisterSerializablePrototype("FilterByNotOwner", FilterByNotOwner.prototype);
     
-    byClassesAnd: function(clsList){
-        return {"func" : function(ent){
-            var ret = true;
-            for (var i in clsList){
-                ret = ret && ent.hasClass(clsList[i]);
-            }
-            return ret;
-        }, 
-        "dynamicProperties": []};
-    },
-    
-    byClassesOr: function(clsList){
-        return {"func" : function(ent){
-            var ret = false;
-            for (var i in clsList){
-                ret = ret || ent.hasClass(clsList[i]);
-            }
-            return ret;
-        }, 
-        "dynamicProperties": []};
-    },
+function FilterByOwners(owners)
+{
+    this.owners = owners;
+    this.dynamicProperties = ["owner"];
+}
+FilterByOwners.prototype.test = function(ent)
+{
+    for (var i in this.owners){
+        if (ent.owner() == +this.owners[i]){
+            return true;
+        }
+    }
+    return false;
+};
+Engine.RegisterSerializablePrototype("FilterByOwners", FilterByOwners.prototype);
 
-    byMetadata: function(key, value){
-        return {"func" : function(ent){
-            return (ent.getMetadata(key) == value);
-        }, 
-        "dynamicProperties": ['metadata.' + key]};
-    },
+function FilterByTrainingQueue()
+{
+    this.dynamicProperties = ["trainingQueue"];
+}
+FilterByTrainingQueue.prototype.test = function(ent)
+{
+    return ent.trainingQueue();
+};
+Engine.RegisterSerializablePrototype("FilterByTrainingQueue", FilterByTrainingQueue.prototype);
+
+function FilterIsSoldier()
+{
+    this.dynamicProperties = [];
+}
+FilterIsSoldier.prototype.test = function(ent)
+{
+    var filter = new FilterByClassesOr(["CitizenSoldier", "Super"]);
+    return filter.test(ent);
+};
+Engine.RegisterSerializablePrototype("FilterIsSoldier", FilterIsSoldier.prototype);
+
+function FilterIsIdle()
+{
+    this.dynamicProperties = ["idle"];
+}
+FilterIsIdle.prototype.test = function(ent)
+{
+    return ent.isIdle();
+};
+Engine.RegisterSerializablePrototype("FilterIsIdle", FilterIsIdle.prototype);
+
+function FilterIsFoundation()
+{
+    this.dynamicProperties = [];
+}
+FilterIsFoundation.prototype.test = function(ent)
+{
+    return ent.foundationProgress() !== undefined;
+};
+Engine.RegisterSerializablePrototype("FilterIsFoundation", FilterIsFoundation.prototype);
+
+function FilterByDistance(startPoint, dist)
+{
+    this.startPoint = startPoint;
+    this.dist = dist;
+    this.dynamicProperties = ["position"];
+}
+FilterByDistance.prototype.test = function(ent)
+{
+    if (ent.position() === undefined)
+        return false;
+    else
+        return (SquareVectorDistance(this.startPoint, ent.position()) < this.dist*this.dist);
+};
+Engine.RegisterSerializablePrototype("FilterByDistance", FilterByDistance.prototype);
+
+// Distance filter with no auto updating, use with care 
+function FilterByStaticDistance(startPoint, dist)
+{
+    this.startPoint = startPoint;
+    this.dist = dist;
+    this.dynamicProperties = [];
+}
+FilterByStaticDistance.prototype.test = function(ent)
+{
+    if (!ent.position())
+        return false;
+    else
+        return (SquareVectorDistance(this.startPoint, ent.position()) < this.dist*this.dist);
+};
+Engine.RegisterSerializablePrototype("FilterByStaticDistance", FilterByStaticDistance.prototype);
+
+function FilterIsDropsite(resourceType)
+{
+    this.resourceType = resourceType;
+    this.dynamicProperties = [];
+}
+FilterIsDropsite.prototype.test = function(ent)
+{
+    return (ent.resourceDropsiteTypes() && ent.resourceDropsiteTypes().indexOf(this.resourceType) !== -1);
+}
+Engine.RegisterSerializablePrototype("FilterIsDropsite", FilterIsDropsite.prototype);
+
+function FilterByResource(resourceType)
+{
+    this.resourceType = resourceType;
+    this.dynamicProperties = [/*"resourceSupplyAmount", */"owner", "metadata.inaccessible", "metadata.full"];
+}
+FilterByResource.prototype.test = function(ent)
+{
+    var type = ent.resourceSupplyType();
+    if (!type)
+        return false;
+    var amount = ent.resourceSupplyMax();
+    if (!amount)
+        return false;
     
-    and: function(filter1, filter2){
-        return {"func": function(ent){
-            return filter1.func(ent) && filter2.func(ent);
-        }, 
-        "dynamicProperties": filter1.dynamicProperties.concat(filter2.dynamicProperties)};
-    },
+    // Skip targets that are too hard to hunt
+    if (ent.isUnhuntable())
+        return false;
     
-    or: function(filter1, filter2){
-        return {"func" : function(ent){
-            return filter1.func(ent) || filter2.func(ent);
-        }, 
-        "dynamicProperties": filter1.dynamicProperties.concat(filter2.dynamicProperties)};
-    },
+    // And don't go for the bloody fish! TODO: better accessibility checks 
+    if (ent.hasClass("SeaCreature"))
+        return false;
     
-    not: function(filter){
-        return {"func": function(ent){
-            return !filter.func(ent);
-        },
-        "dynamicProperties": filter.dynamicProperties};
-    },
+    // Don't go for floating treasures since we won't be able to reach them and it kills the pathfinder.
+    if (ent.templateName() == "other/special_treasure_shipwreck_debris" || 
+            ent.templateName() == "other/special_treasure_shipwreck" )
+        return false;
     
-    byOwner: function(owner){
-        return {"func" : function(ent){
-            return (ent.owner() === owner);
-        }, 
-        "dynamicProperties": ['owner']};
-    },
+    // Don't gather enemy farms
+    if (!ent.isOwn() && ent.owner() !== 0)
+        return false;
     
-    byNotOwner: function(owner){
-        return {"func" : function(ent){
-            return (ent.owner() !== owner);
-        }, 
-        "dynamicProperties": ['owner']};
-    },
+    if (ent.getMetadata("inaccessible") === true)
+        return false;
     
-    byOwners: function(owners){
-        return {"func" : function(ent){
-            for (var i in owners){
-                if (ent.owner() == +owners[i]){
-                    return true;
-                }
-            }
-            return false;
-        }, 
-        "dynamicProperties": ['owner']};
-    },
+    // too many workers trying to gather from this resource
+    if (ent.getMetadata("full") === true)
+        return false;
     
-    byTrainingQueue: function(){
-        return {"func" : function(ent){
-            return ent.trainingQueue();
-        }, 
-        "dynamicProperties": ['trainingQueue']};
-    },
-    
-    isSoldier: function(){
-        return {"func" : function(ent){
-            return Filters.byClassesOr(["CitizenSoldier", "Super"])(ent);
-        }, 
-        "dynamicProperties": []};
-    },
-    
-    isIdle: function(){
-        return {"func" : function(ent){
-            return ent.isIdle();
-        }, 
-        "dynamicProperties": ['idle']};
-    },
-    
-    isFoundation: function(){
-        return {"func": function(ent){
-            return ent.foundationProgress() !== undefined;
-        },
-        "dynamicProperties": []};
-    },
-    
-    byDistance: function(startPoint, dist){
-        return {"func": function(ent){
-            if (ent.position() === undefined){
-                return false;
-            }else{
-                return (SquareVectorDistance(startPoint, ent.position()) < dist*dist);
-            }
-        },
-        "dynamicProperties": ['position']};
-    },
-    
-    // Distance filter with no auto updating, use with care 
-    byStaticDistance: function(startPoint, dist){
-        return {"func": function(ent){
-            if (!ent.position()){
-                return false;
-            }else{
-                return (SquareVectorDistance(startPoint, ent.position()) < dist*dist);
-            }
-        },
-        "dynamicProperties": []};
-    },
-    
-    isDropsite: function(resourceType){
-        return {"func": function(ent){
-            return (ent.resourceDropsiteTypes() && ent.resourceDropsiteTypes().indexOf(resourceType) !== -1);
-        },
-        "dynamicProperties": []};
-    },
-    
-    byResource: function(resourceType){
-        return {"func" : function(ent){
-            var type = ent.resourceSupplyType();
-            if (!type)
-                return false;
-            var amount = ent.resourceSupplyMax();
-            if (!amount)
-                return false;
-            
-            // Skip targets that are too hard to hunt
-            if (ent.isUnhuntable())
-                return false;
-            
-            // And don't go for the bloody fish! TODO: better accessibility checks 
-            if (ent.hasClass("SeaCreature")){
-                return false;
-            }
-            
-            // Don't go for floating treasures since we won't be able to reach them and it kills the pathfinder.
-            if (ent.templateName() == "other/special_treasure_shipwreck_debris" || 
-                    ent.templateName() == "other/special_treasure_shipwreck" ){
-                return false;
-            }
-            
-            // Don't gather enemy farms
-            if (!ent.isOwn() && ent.owner() !== 0){
-                return false;
-            }
-            
-            if (ent.getMetadata("inaccessible") === true){
-                return false;
-            }
-            
-            // too many workers trying to gather from this resource
-            if (ent.getMetadata("full") === true){
-                return false;
-            }
-            
-            if (type.generic == "treasure"){
-                return (resourceType == type.specific);
-            } else {
-                return (resourceType == type.generic);
-            }
-        },
-        "dynamicProperties": [/*"resourceSupplyAmount", */"owner", "metadata.inaccessible", "metadata.full"]};
-    }
+    if (type.generic == "treasure")
+        return (this.resourceType == type.specific);
+    else
+        return (this.resourceType == type.generic);
 };
+Engine.RegisterSerializablePrototype("FilterByResource", FilterByResource.prototype);

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

@@ -38 +38 @@
     var targets = militaryManager.getEnemyBuildings(gameState,"ConquestCritical");
     // If there are no critical structures, attack anything else that's critical
     if (targets.length == 0) {
-        targets = gameState.entities.filter(function(ent) {
-            return (gameState.isEntityEnemy(ent) && ent.hasClass("ConquestCritical") && ent.owner() !== 0 && ent.position());
-        });
+        targets = gameState.entities.filter(new FilterEnemyConquestCritical(gameState));
     }
     // If there's nothing, attack anything else that's less critical
     if (targets.length == 0) {
@@ -203 +201 @@
     this.previousHealth = totalHealth;
 };
 
+Engine.RegisterSerializablePrototype("AttackMoveToCC", AttackMoveToCC.prototype);

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

@@ +1 @@
+// Default target finder aims for conquest critical targets
+function DefaultTargetFinder()
+{
+}
+DefaultTargetFinder.prototype.findTargets = function(gameState, militaryManager)
+{
+    // Find the critical enemy buildings we could attack
+    var targets = militaryManager.getEnemyBuildings(gameState,"ConquestCritical");
+    // If there are no critical structures, attack anything else that's critical
+    if (targets.length == 0) {
+        targets = gameState.entities.filter(new FilterEnemyConquestCritical(gameState));
+    }
+    // If there's nothing, attack anything else that's less critical
+    if (targets.length == 0) {
+        targets = militaryManager.getEnemyBuildings(gameState,"Town");
+    }
+    if (targets.length == 0) {
+        targets = militaryManager.getEnemyBuildings(gameState,"Village");
+    }
+    return targets;
+};
+
 function AttackMoveToLocation(gameState, militaryManager, minAttackSize, maxAttackSize, targetFinder){
     this.minAttackSize = minAttackSize || Config.attack.minAttackSize;
     this.maxAttackSize = maxAttackSize || Config.attack.maxAttackSize;
@@ -6 +28 @@
     this.previousTime = 0;
     this.state = "unexecuted";
     
-    this.targetFinder = targetFinder || this.defaultTargetFinder;
+    this.targetFinder = targetFinder || new DefaultTargetFinder();
     
     this.healthRecord = [];
 };
@@ -29 +51 @@
             || availableCount >= this.maxAttackSize);
 };
 
-// Default target finder aims for conquest critical targets
-AttackMoveToLocation.prototype.defaultTargetFinder = function(gameState, militaryManager){
-    // Find the critical enemy buildings we could attack
-    var targets = militaryManager.getEnemyBuildings(gameState,"ConquestCritical");
-    // If there are no critical structures, attack anything else that's critical
-    if (targets.length == 0) {
-        targets = gameState.entities.filter(function(ent) {
-            return (gameState.isEntityEnemy(ent) && ent.hasClass("ConquestCritical") && ent.owner() !== 0 && ent.position());
-        });
-    }
-    // If there's nothing, attack anything else that's less critical
-    if (targets.length == 0) {
-        targets = militaryManager.getEnemyBuildings(gameState,"Town");
-    }
-    if (targets.length == 0) {
-        targets = militaryManager.getEnemyBuildings(gameState,"Village");
-    }
-    return targets;
-};
-
 // Executes the attack plan, after this is executed the update function will be run every turn
 AttackMoveToLocation.prototype.execute = function(gameState, militaryManager){
     var availableCount = militaryManager.countAvailableUnits();
@@ -57 +59 @@
     
     var pending = EntityCollectionFromIds(gameState, this.idList);
     
-    var targets = this.targetFinder(gameState, militaryManager);
+    var targets = this.targetFinder.findTargets(gameState, militaryManager);
     
     if (targets.length === 0){
-        targets = this.defaultTargetFinder(gameState, militaryManager);
+        targets = new DefaultTargetFinder().findTargets(gameState, militaryManager);
     }
     
     // If we have a target, move to it
@@ -236 +238 @@
     this.previousHealth = totalHealth;
 };
 
+Engine.RegisterSerializablePrototype("AttackMoveToLocation", AttackMoveToLocation.prototype);
+Engine.RegisterSerializablePrototype("DefaultTargetFinder", DefaultTargetFinder.prototype);

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

@@ -1 @@
-var baseConfig = {
+var Config = {
     "attack" : {
         "minAttackSize" : 20, // attackMoveToLocation
         "maxAttackSize" : 60, // attackMoveToLocation
@@ -55 +55 @@
     
     "debug" : false
 };
-
-var Config = {
-        "debug": false
-};
-
-Config.__proto__ = baseConfig;
- No newline at end of file

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

@@ -41 +41 @@
     if (numAttackers * this.DEFENCE_RATIO <= numAssignedDefenders){
         militaryManager.unassignUnits(unassignedDefenders);
         
-        var CCs = gameState.getOwnEntities().filter(Filters.byClass("CivCentre"));
+        var CCs = gameState.getOwnEntities().filter(new FilterByClass("CivCentre"));
         
         for (var i in unassignedDefenders){
             var pos = this.defenders[unassignedDefenders[i]].position();
@@ -62 +62 @@
     // Check to see if we need to recruit more defenders
     if (numAttackers * this.DEFENCE_RATIO > numDefenders){
         var numNeeded = Math.ceil(numAttackers * this.DEFENCE_RATIO - numDefenders);
-        var numIdleAvailable = militaryManager.countAvailableUnits(Filters.isIdle());
+        var numIdleAvailable = militaryManager.countAvailableUnits(new FilterIsIdle());
         
         if (numIdleAvailable > numNeeded){
-            var newUnits = militaryManager.getAvailableUnits(numNeeded, Filters.isIdle());
+            var newUnits = militaryManager.getAvailableUnits(numNeeded, new FilterIsIdle());
             for (var i in newUnits){
                 var ent = gameState.getEntityById(newUnits[i]);
             }
@@ -142 +142 @@
 // Returns an entity collection of key buildings which should be defended.
 // Currently just returns civ centres
 Defence.prototype.getKeyBuildings = function(gameState){
-    return gameState.getOwnEntities().filter(Filters.byClass("CivCentre"));
+    return gameState.getOwnEntities().filter(new FilterByClass("CivCentre"));
 };
 
 /*
@@ -276 +276 @@
         }
     }
 };
+
+Engine.RegisterSerializablePrototype("Defence", Defence.prototype);

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

@@ -43 +43 @@
     var numGatherers = {};
     for ( var type in this.gatherWeights){
         numGatherers[type] = gameState.updatingCollection("workers-gathering-" + type, 
-                Filters.byMetadata("gather-type", type), gameState.getOwnEntitiesByRole("worker")).length; 
+                new FilterByMetadata("gather-type", type), gameState.getOwnEntitiesByRole("worker")).length; 
     }
 
     var types = Object.keys(this.gatherWeights);
@@ -111 +111 @@
     var self = this;
 
     // Search for idle workers, and tell them to gather resources based on demand
-    var filter = Filters.or(Filters.isIdle(), Filters.byMetadata("subrole", "idle"));
+    var filter = new FilterOr(new FilterIsIdle(), new FilterByMetadata("subrole", "idle"));
     var idleWorkers = gameState.updatingCollection("idle-workers", filter, gameState.getOwnEntitiesByRole("worker"));
     
     if (idleWorkers.length) {
@@ -133 +133 @@
 
 EconomyManager.prototype.workersBySubrole = function(gameState, subrole) {
     var workers = gameState.getOwnEntitiesByRole("worker");
-    return gameState.updatingCollection("subrole-" + subrole, Filters.byMetadata("subrole", subrole), workers);
+    return gameState.updatingCollection("subrole-" + subrole, new FilterByMetadata("subrole", subrole), workers);
 };
 
 EconomyManager.prototype.assignToFoundations = function(gameState) {
@@ -163 +163 @@
 
     var target = foundations.toEntityArray()[0];
 
-    var nonBuilderWorkers = workers.filter(function(ent) {
-        // check position so garrisoned units aren't tasked
-        return (ent.getMetadata("subrole") !== "builder" && ent.position() !== undefined);
-    });
+    var nonBuilderWorkers = workers.filter(new FilterNonBuilders());
 
     var nearestNonBuilders = nonBuilderWorkers.filterNearest(target.position(), extraNeeded);
 
@@ -184 +181 @@
     
     var numFood = 0;
     
-    gameState.updatingCollection("active-dropsite-food", Filters.byMetadata("active-dropsite-food", true), 
+    gameState.updatingCollection("active-dropsite-food", new FilterByMetadata("active-dropsite-food", true), 
             gameState.getOwnDropsites("food")).forEach(function (dropsite){
         numFood += dropsite.getMetadata("nearby-resources-food").length;
     });
@@ -339 +336 @@
         
         gameState.getOwnDropsites(resource).forEach(function(ent) {
             if (ent.getMetadata("nearby-resources-" + resource) === undefined){
-                var filterPos = Filters.byStaticDistance(ent.position(), radius);
+                var filterPos = new FilterByStaticDistance(ent.position(), radius);
                 
                 var collection = gameState.getResourceSupplies(resource).filter(filterPos);
                 collection.registerUpdates();
@@ -411 +408 @@
                 if (this.checkResourceConcentrations(gameState, resource) < this.dropsiteNumbers[resource]){
                     var spot = this.getBestResourceBuildSpot(gameState, resource);
                     
-                    var myCivCentres = gameState.getOwnEntities().filter(function(ent) {
-                        if (!ent.hasClass("CivCentre") || ent.position() === undefined){
-                            return false;
-                        } 
-                        var dx = (spot[0]-ent.position()[0]);
-                        var dy = (spot[1]-ent.position()[1]);
-                        var dist2 = dx*dx + dy*dy;
-                        return (ent.hasClass("CivCentre") && dist2 < 180*180);
-                    });
+                    var myCivCentres = gameState.getOwnEntities().filter(new FilterNearbyCivCenters(spot));
                     
                     if (myCivCentres.length === 0){
                         queues.economicBuilding.addItem(new BuildingConstructionPlan(gameState, "structures/{civ}_civil_centre", spot));
@@ -521 +510 @@
     });
     
     // Gatherer count updates for non-workers
-    var filter = Filters.and(Filters.not(Filters.byMetadata("worker-object", undefined)), 
-                             Filters.not(Filters.byMetadata("role", "worker")));
+    var filter = new FilterAnd(new FilterNot(new FilterByMetadata("worker-object", undefined)), 
+                             new FilterNot(new FilterByMetadata("role", "worker")));
     gameState.updatingCollection("reassigned-workers", filter, gameState.getOwnEntities()).forEach(function(ent){
         ent.getMetadata("worker-object").updateGathererCounts(gameState);
     });
@@ -541 +530 @@
 
     Engine.ProfileStop();
 };
+
+Engine.RegisterSerializablePrototype("EconomyManager", EconomyManager.prototype);

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

@@ +1 @@
+function FilterEnemyConquestCritical(gameState)
+{
+    this.gameState = gameState;
+    this.dynamicProperties = [];
+}
+FilterEnemyConquestCritical.prototype.test = function(ent)
+{
+    return (this.gameState.isEntityEnemy(ent) && ent.hasClass("ConquestCritical") && ent.owner() !== 0 && ent.position());
+};
+Engine.RegisterSerializablePrototype("FilterEnemyConquestCritical", FilterEnemyConquestCritical.prototype);
+
+function FilterNonBuilders()
+{
+    this.dynamicProperties = [];
+}
+FilterNonBuilders.prototype.test = function(ent)
+{
+    // check position so garrisoned units aren't tasked
+    return (ent.getMetadata("subrole") !== "builder" && ent.position() !== undefined);
+};
+Engine.RegisterSerializablePrototype("FilterNonBuilders", FilterNonBuilders.prototype);
+
+function FilterNearbyCivCenters(spot)
+{
+    this.spot = spot;
+    this.dynamicProperties = [];
+}
+FilterNearbyCivCenters.prototype.test = function(ent)
+{
+    if (!ent.hasClass("CivCentre") || ent.position() === undefined)
+        return false;
+
+    var dx = (this.spot[0]-ent.position()[0]);
+    var dy = (this.spot[1]-ent.position()[1]);
+    var dist2 = dx*dx + dy*dy;
+    return (ent.hasClass("CivCentre") && dist2 < 180*180);
+};
+Engine.RegisterSerializablePrototype("FilterNearbyCivCenters", FilterNearbyCivCenters.prototype);
+
+function FilterAvailableTrainers(template)
+{
+    this.template = template;
+    this.dynamicProperties = [];
+}
+FilterAvailableTrainers.prototype.test = function(ent)
+{
+    var maxQueueLength = 2; // avoid tying up resources in giant training queues
+    var trainable = ent.trainableEntities();
+    if (!trainable || trainable.indexOf(this.template) == -1)
+        return false;
+
+    var queue = ent.trainingQueue();
+    if (queue)
+        if (queue.length >= maxQueueLength)
+            return false;
+
+    return true;
+};
+Engine.RegisterSerializablePrototype("FilterAvailableTrainers", FilterAvailableTrainers.prototype);
+
+function FilterAvailableBuilders(template)
+{
+    this.template = template;
+    this.dynamicProperties = [];
+}
+FilterAvailableBuilders.prototype.test = function(ent)
+{
+    var buildable = ent.buildableEntities();
+    if (!buildable || buildable.indexOf(this.template) == -1)
+        return false;
+
+    return true;
+};
+Engine.RegisterSerializablePrototype("FilterAvailableBuilders", FilterAvailableBuilders.prototype);
+
+function FilterEnemyStructuresByClass(gameState, cls)
+{
+    this.gameState = gameState;
+    this.cls = cls;
+    this.dynamicProperties = [];
+}
+FilterEnemyStructuresByClass.prototype.test = function(ent)
+{
+    return (this.gameState.isEntityEnemy(ent) && ent.hasClass("Structure") && ent.hasClass(this.cls) && ent.owner() !== 0  && ent.position());
+};
+Engine.RegisterSerializablePrototype("FilterEnemyStructuresByClass", FilterEnemyStructuresByClass.prototype);
+

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

@@ -133 +133 @@
 
 GameState.prototype.getOwnEntities = function() {
     if (!this.store.ownEntities){
-        this.store.ownEntities = this.getEntities().filter(Filters.byOwner(this.player));
+        this.store.ownEntities = this.getEntities().filter(new FilterByOwner(this.player));
         this.store.ownEntities.registerUpdates();
     }
     
@@ -155 +155 @@
         }
     }
     if (diplomacyChange || !this.store.enemyEntities){
-        var filter = Filters.byOwners(enemies);
+        var filter = new FilterByOwners(enemies);
         this.store.enemyEntities = this.getEntities().filter(filter);
         this.store.enemyEntities.registerUpdates();
         this.store.enemies = enemies;
@@ -179 +179 @@
 
 GameState.prototype.getOwnEntitiesByMetadata = function(key, value){
     if (!this.store[key + "-" + value]){
-        var filter = Filters.byMetadata(key, value);
+        var filter = new FilterByMetadata(key, value);
         this.store[key + "-" + value] = this.getOwnEntities().filter(filter);
         this.store[key + "-" + value].registerUpdates();
     }
@@ -193 +193 @@
 
 // TODO: fix this so it picks up not in use training stuff
 GameState.prototype.getOwnTrainingFacilities = function(){
-    return this.updatingCollection("own-training-facilities", Filters.byTrainingQueue(), this.getOwnEntities());
+    return this.updatingCollection("own-training-facilities", new FilterByTrainingQueue(), this.getOwnEntities());
 };
 
 GameState.prototype.getOwnEntitiesByType = function(type){
-    var filter = Filters.byType(type);
-    return this.updatingCollection("own-by-type-" + type, filter, this.getOwnEntities());
+    return this.updatingCollection("own-by-type-" + type, new FilterByType(type), this.getOwnEntities());
 };
 
 GameState.prototype.countEntitiesByType = function(type) {
@@ -259 +258 @@
  * already too busy.
  */
 GameState.prototype.findTrainers = function(template) {
-    var maxQueueLength = 2; // avoid tying up resources in giant training queues
-    
-    return this.getOwnTrainingFacilities().filter(function(ent) {
-
-        var trainable = ent.trainableEntities();
-        if (!trainable || trainable.indexOf(template) == -1)
-            return false;
-
-        var queue = ent.trainingQueue();
-        if (queue) {
-            if (queue.length >= maxQueueLength)
-                return false;
-        }
-
-        return true;
-    });
+    return this.getOwnTrainingFacilities().filter(new FilterAvailableTrainers(template));
 };
 
 /**
  * Find units that are capable of constructing the given building type.
  */
 GameState.prototype.findBuilders = function(template) {
-    return this.getOwnEntities().filter(function(ent) {
-
-        var buildable = ent.buildableEntities();
-        if (!buildable || buildable.indexOf(template) == -1)
-            return false;
-
-        return true;
-    });
+    return this.getOwnEntities().filter(new FilterAvailableBuilders(template));
 };
 
 GameState.prototype.getOwnFoundations = function() {
-    return this.updatingCollection("ownFoundations", Filters.isFoundation(), this.getOwnEntities());
+    return this.updatingCollection("ownFoundations", new FilterIsFoundation(), this.getOwnEntities());
 };
 
 GameState.prototype.getOwnDropsites = function(resource){
-    return this.updatingCollection("dropsite-own-" + resource, Filters.isDropsite(resource), this.getOwnEntities());
+    return this.updatingCollection("dropsite-own-" + resource, new FilterIsDropsite(resource), this.getOwnEntities());
 };
 
 GameState.prototype.getResourceSupplies = function(resource){
-    return this.updatingCollection("resource-" + resource, Filters.byResource(resource), this.getEntities());
+    return this.updatingCollection("resource-" + resource, new FilterByResource(resource), this.getEntities());
 };
 
 GameState.prototype.getEntityLimits = function() {
@@ -321 +298 @@
     else
         return (this.playerData.entityCounts[category] >= this.playerData.entityLimits[category]);
 };
+
+Engine.RegisterSerializablePrototype("GameState", GameState.prototype);

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

@@ -27 +27 @@
 
     Engine.ProfileStop();
 };
+
+Engine.RegisterSerializablePrototype("HousingManager", HousingManager.prototype);

binaries/data/mods/public/simulation/ai/qbot/map-module.js

@@ -261 +261 @@
     threshold = threshold ? threshold : 256;
     Engine.DumpImage(name, this.map, this.width, this.height, threshold);
 };
+
+Engine.RegisterSerializablePrototype("Map", Map.prototype);

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

@@ -8 +8 @@
 
 var MilitaryAttackManager = function() {
     // these use the structure soldiers[unitId] = true|false to register the units
-    this.attackManagers = [AttackMoveToLocation];
+    this.attackManagers = ["AttackMoveToLocation"];
     this.availableAttacks = [];
     this.currentAttacks = [];
     
@@ -49 +49 @@
         this.bFort[i] = gameState.applyCiv(this.bFort[i]);
     }
     
-    this.getEconomicTargets = function(gameState, militaryManager){
-        return militaryManager.getEnemyBuildings(gameState, "Economic");
-    };
+    // this.getEconomicTargets = function(gameState, militaryManager){
+        // return militaryManager.getEnemyBuildings(gameState, "Economic");
+    // };
     // TODO: figure out how to make this generic
     for (var i in this.attackManagers){
-        this.availableAttacks[i] = new this.attackManagers[i](gameState, this);
+        this.availableAttacks[i] = new global[this.attackManagers[i]](gameState, this);
     }
     
     var enemies = gameState.getEnemyEntities();
-    var filter = Filters.byClassesOr(["CitizenSoldier", "Champion", "Hero", "Siege"]);
+    var filter = new FilterByClassesOr(["CitizenSoldier", "Champion", "Hero", "Siege"]);
     this.enemySoldiers = enemies.filter(filter); // TODO: cope with diplomacy changes
     this.enemySoldiers.registerUpdates();
 };
@@ -141 +141 @@
 };
 
 // return count of enemy buildings for a given building class
-MilitaryAttackManager.prototype.getEnemyBuildings = function(gameState,cls) {
-    var targets = gameState.entities.filter(function(ent) {
-            return (gameState.isEntityEnemy(ent) && ent.hasClass("Structure") && ent.hasClass(cls) && ent.owner() !== 0  && ent.position());
-        });
+MilitaryAttackManager.prototype.getEnemyBuildings = function(gameState, cls) {
+    var targets = gameState.entities.filter(new FilterEnemyStructuresByClass(gameState, cls));
     return targets;
 };
 
@@ -435 +433 @@
             this.currentAttacks.push(this.availableAttacks[i]);
             //debug("Attacking!");
         }
-        this.availableAttacks.splice(i, 1, new this.attackManagers[i](gameState, this));
+        this.availableAttacks.splice(i, 1, new global[this.attackManagers[i]](gameState, this));
     }
     Engine.ProfileStop();
     
@@ -457 +455 @@
     
     Engine.ProfileStop();
 };
+
+Engine.RegisterSerializablePrototype("MilitaryAttackManager", MilitaryAttackManager.prototype);

binaries/data/mods/public/simulation/ai/qbot/plan-building.js

@@ -122 +122 @@
         "angle" : angle
     };
 };
+
+Engine.RegisterSerializablePrototype("BuildingConstructionPlan", BuildingConstructionPlan.prototype);

binaries/data/mods/public/simulation/ai/qbot/plan-training.js

@@ -53 +53 @@
 
 UnitTrainingPlan.prototype.addItem = function(){
     this.number += 1;
-};
- No newline at end of file
+};
+
+Engine.RegisterSerializablePrototype("UnitTrainingPlan", UnitTrainingPlan.prototype);

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

@@ -50 +50 @@
         
         this.firstTime = false;
         
-        var myKeyEntities = gameState.getOwnEntities().filter(function(ent) {
-            return ent.hasClass("CivCentre");
-        });
+        var myKeyEntities = gameState.getOwnEntities().filter(new FilterByClass("CivCentre"));
         
         if (myKeyEntities.length == 0){
             myKeyEntities = gameState.getOwnEntities();
         }
         
         
-        var filter = Filters.byClass("CivCentre");
+        var filter = new FilterByClass("CivCentre");
         var enemyKeyEntities = gameState.getEnemyEntities().filter(filter);
         
         if (enemyKeyEntities.length == 0){
@@ -146 +144 @@
     Engine.ProfileStop();
 };
 
-// TODO: Remove override when the whole AI state is serialised
-QBotAI.prototype.Deserialize = function(data)
-{
-    BaseAI.prototype.Deserialize.call(this, data);
-};
-
-// Override the default serializer
-QBotAI.prototype.Serialize = function()
-{
-    var ret = BaseAI.prototype.Serialize.call(this);
-    ret._entityMetadata = {};
-    return ret;
-};
-
 function debug(output){
     if (Config.debug){
         if (typeof output === "string"){
@@ -178 +162 @@
         descendant.prototype[m] = parent.prototype[m];
     }
 }
+
+Engine.RegisterSerializablePrototype("QBotAI", QBotAI.prototype);

binaries/data/mods/public/simulation/ai/qbot/queue-manager.js

@@ -199 +199 @@
     
     for (var i in this.priorities){
         if (!(this.priorities[i] > 0)){
+            warn("QueueManager received bad priorities, please report this error: " + uneval(this.priorities));
             this.priorities[i] = 1;  // TODO: make the Queue Manager not die when priorities are zero.
-            warn("QueueManager received bad priorities, please report this error: " + uneval(this.priorities));
         }
     }
     
@@ -300 +300 @@
     Engine.ProfileStop();
     Engine.ProfileStop();
 };
+
+Engine.RegisterSerializablePrototype("QueueManager", QueueManager.prototype);

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

@@ -111 +111 @@
         } 
     }
     return count;
-};
- No newline at end of file
+};
+
+Engine.RegisterSerializablePrototype("Queue", Queue.prototype);

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

@@ -64 +64 @@
     sum += this.population * 50; // based on typical unit costs
     return sum;
 };
+
+Engine.RegisterSerializablePrototype("Resources", Resources.prototype);

binaries/data/mods/public/simulation/ai/qbot/terrain-analysis.js

@@ -347 +347 @@
         newStack = [];
     }
     return count;
-};
- No newline at end of file
+};
+
+Engine.RegisterSerializablePrototype("TerrainAnalysis", TerrainAnalysis.prototype);
+Engine.RegisterSerializablePrototype("PathFinder", PathFinder.prototype);
+Engine.RegisterSerializablePrototype("Accessibility", Accessibility.prototype);

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

@@ -9 +9 @@
 
 
 //-EmjeR-// Timer class //
-var Timer = function() {
-    ///Private array.
-    var alarmList = [];
+var Timer = function() 
+{
+    this.alarmList = [];
+}
+
+///Private methods
+Timer.prototype.num_alarms = function()
+{
+    return this.alarmList.length;
+};
+
+Timer.prototype.get_alarm = function(id)
+{
+    return this.alarmList[id];
+};
     
-    ///Private methods
-    function num_alarms() {
-        return alarmList.length;
-    };
+Timer.prototype.add_alarm = function(index, alarm)
+{
+    this.alarmList[index] = alarm;
+};
     
-    function get_alarm(id) {
-        return alarmList[id];
-    };
+Timer.prototype.delete_alarm = function(id)
+{
+    // Set the array element to undefined
+    delete this.alarmList[id];
+};
     
-    function add_alarm(index, alarm) {
-        alarmList[index] = alarm;
-    };
+///Privileged methods
+// Add an new alarm to the list
+Timer.prototype.setTimer = function(gameState, interval, delay, repeat)
+{
+    delay = delay || 0;
+    repeat = repeat || -1;
     
-    function delete_alarm(id) {
-        // Set the array element to undefined
-        delete alarmList[id];
-    };
+    var index = this.num_alarms();
     
-    ///Privileged methods
-    // Add an new alarm to the list
-    this.setTimer = function(gameState, interval, delay, repeat) {
-        delay = delay || 0;
-        repeat = repeat || -1;
-        
-        var index = num_alarms();
-        
-        //Add a new alarm to the list
-        add_alarm(index, new alarm(gameState, index, interval, delay, repeat));
-        return index;
-    };
+    //Add a new alarm to the list
+    this.add_alarm(index, new Alarm(gameState, index, interval, delay, repeat));
+    return index;
+};
     
+// Check if a alarm has reached its interval.
+Timer.prototype.checkTimer = function(gameState,id)
+{
+    var alarm = this.get_alarm(id);
+    if (alarm === undefined)
+        return false;
+    if (!alarm.active)
+        return false;
+    var time = gameState.getTimeElapsed();
+    var alarmState = false;
     
-    // Check if a alarm has reached its interval.
-    this.checkTimer = function(gameState,id) {
-        var alarm = get_alarm(id);
-        if (alarm === undefined)
-            return false;
-        if (!alarm.active)
-            return false;
-        var time = gameState.getTimeElapsed();
-        var alarmState = false;
-        
-        // If repeat forever (repeat is -1). Or if the alarm has rung less times than repeat.
-        if (alarm.repeat < 0 || alarm.counter < alarm.repeat) {
-            var time_diffrence = time - alarm.start_time - alarm.delay - alarm.interval * alarm.counter;
-            if (time_diffrence > alarm.interval) {
-                alarmState = true;
-                alarm.counter++;
-            }
+    // If repeat forever (repeat is -1). Or if the alarm has rung less times than repeat.
+    if (alarm.repeat < 0 || alarm.counter < alarm.repeat) {
+        var time_diffrence = time - alarm.start_time - alarm.delay - alarm.interval * alarm.counter;
+        if (time_diffrence > alarm.interval) {
+            alarmState = true;
+            alarm.counter++;
         }
-        
-        // Check if the alarm has rung 'alarm.repeat' times if so, delete the alarm.
-        if (alarm.counter >= alarm.repeat && alarm.repeat != -1) {
-            this.clearTimer(id);
-        }
-        
-        return alarmState;
-    };
+    }
     
-    // Remove an alarm from the list.
-    this.clearTimer = function(id) {
-        delete_alarm(id);
-    };
+    // Check if the alarm has rung 'alarm.repeat' times if so, delete the alarm.
+    if (alarm.counter >= alarm.repeat && alarm.repeat != -1) {
+        this.clearTimer(id);
+    }
     
-    // Activate a deactivated alarm.
-    this.activateTimer = function(id) {
-        var alarm = get_alarm(id);
-        alarm.active = true;
-    };
+    return alarmState;
+};
     
-    // Deactivate an active alarm but don't delete it.
-    this.deactivateTimer = function(id) {
-        var alarm = get_alarm(id);
-        alarm.active = false;
-    };
+// Remove an alarm from the list.
+Timer.prototype.clearTimer = function(id)
+{
+    this.delete_alarm(id);
 };
+    
+// Activate a deactivated alarm.
+Timer.prototype.activateTimer = function(id)
+{
+    var alarm = this.get_alarm(id);
+    alarm.active = true;
+};
+    
+// Deactivate an active alarm but don't delete it.
+Timer.prototype.deactivateTimer = function(id) {
+    var alarm = this.get_alarm(id);
+    alarm.active = false;
+};
 
-
 //-EmjeR-// Alarm class //
-function alarm(gameState, id, interval, delay, repeat) {
+function Alarm(gameState, id, interval, delay, repeat)
+{
     this.id = id;
     this.interval = interval;
     this.delay = delay;
@@ -102 +109 @@
     this.active = true;
     this.counter = 0;
 };
+
+Engine.RegisterSerializablePrototype("Timer", Timer.prototype);
+Engine.RegisterSerializablePrototype("Alarm", Alarm.prototype);

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

@@ -33 +33 @@
     var targets = militaryManager.getEnemyBuildings(gameState,"ConquestCritical");
     // If there are no critical structures, attack anything else that's critical
     if (targets.length == 0) {
-        targets = gameState.entities.filter(function(ent) {
-            return (gameState.isEntityEnemy(ent) && ent.hasClass("ConquestCritical") && ent.owner() !== 0);
-        });
+        targets = gameState.entities.filter(new FilterEnemyConquestCritical(gameState));
     }
     // If there's nothing, attack anything else that's less critical
     if (targets.length == 0) {
@@ -82 +80 @@
     for (var i in removeList){
         this.idList.splice(this.idList.indexOf(removeList[i]),1);
     }
-};
- No newline at end of file
+};
+
+Engine.RegisterSerializablePrototype("WalkToCC", WalkToCC.prototype);

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

@@ -128 +128 @@
     var nearestResources = undefined;
     var nearestDropsite = undefined;
     
-    gameState.updatingCollection("active-dropsite-" + resource, Filters.byMetadata("active-dropsite-" + resource, true), 
+    gameState.updatingCollection("active-dropsite-" + resource, new FilterByMetadata("active-dropsite-" + resource, true), 
             gameState.getOwnDropsites(resource)).forEach(function (dropsite){
         if (dropsite.position()){
             var dist = VectorDistance(ent.position(), dropsite.position());
@@ -248 +248 @@
     }else{
         return type.generic;
     }
-};
- No newline at end of file
+};
+
+Engine.RegisterSerializablePrototype("Worker", Worker.prototype);