fixed wrong vacancy generation bug.

Removed automatic path placement.
Started command section.

.sync

@@ -1,2 +0,0 @@
-1650024834746
-5ce5d401e947ee7ab16cc8db

Commands.js

@@ -0,0 +1,61 @@
+
+
+module.exports = {
+    setup(){
+        global.fullReset = fullReset;
+        global.resetRooms = resetRooms;
+        global.resetStructures = resetStructures;
+        global.resetCreeps = resetCreeps;
+        global.resetConstruction = resetConstruction;
+
+        global.buildRoads = buildRoads;
+    }
+}
+
+function fullReset(){
+    resetRooms();
+    resetCreeps();
+    resetStructures();
+    resetConstruction();
+    global.started = false;
+    global.compiled = false;
+    return "OK";
+}
+
+function resetRooms(){
+    Object.values(Game.rooms).forEach(room => room.memory = {});
+    return "OK";
+}
+
+function resetStructures(){
+    Object.values(Game.structures).forEach(structure => structure.memory = {});
+    return "OK";
+}
+
+function resetCreeps(){
+    Object.values(Game.creeps).forEach(creep => creep.suicide());
+    return "OK";
+}
+
+function resetConstruction(){
+    Object.values(Game.rooms).forEach(room=>room.find(FIND_CONSTRUCTION_SITES).forEach(cs=>cs.remove()));
+    return "OK";
+}
+
+function buildRoads(){
+    Object.values(Game.rooms).forEach(room=>
+    {
+        room.memory.layout.sources.forEach(
+            sId => {
+                const source = Game.getObjectById(sId);
+                var roads = [];
+                roads = roads.concat(source.pos.findPathTo(room.controller));
+                roads.pop();
+                roads = roads.concat(source.pos.findPathTo(room.find(FIND_MY_STRUCTURES, { filter:{ structureType:STRUCTURE_SPAWN }})[0]));
+                roads.pop();
+                roads.forEach(tile => room.createConstructionSite(tile.x, tile.y, STRUCTURE_ROAD));
+            }
+        );
+    });
+    return "OK";
+}

CreepClass.js

@@ -0,0 +1,36 @@
+const jobHarvester = require("JobHarvester");
+const jobMiner = require("JobMiner");
+
+module.exports = {
+	setup: function () { 
+		Creep.prototype = _Creep.prototype;
+		global.Role = Role;
+	}
+}
+
+const Role = {
+	HARVESTER: 0,
+    MINER: 1,
+    SUPPLIER: 2,
+    UPGRADER: 3,
+    BUILDER: 4
+}
+
+class _Creep extends Creep {
+	begin(){
+        if(!this.memory.job) this.memory.job = { role: Role.HARVESTER };
+        switch (this.memory.job.role) {
+            case Role.HARVESTER: jobHarvester.begin(this); break;
+            case Role.MINER: jobMiner.begin(this); break;
+        }
+		this.memory.init = true; 
+    }
+    
+    tick(){
+        if(!this.memory.init) this.begin();
+        switch (this.memory.job.role) {
+            case Role.HARVESTER: jobHarvester.tick(this); break;
+            case Role.MINER: jobMiner.tick(this); break;
+        }
+    }
+}

GLOBAL_VARIABLES.js

@@ -1,15 +0,0 @@
-module.exports = {
-    
-    // JOBS
-
-    JOB_HARVESTER: 0,
-    JOB_MINER: 1,
-    JOB_SUPPLIER: 2,
-    JOB_BUILDER:3,
-    JOB_UPGRADER: 4,
-    JOB_DEFENDER: 5,
-    JOB_RESERVER: 6,
-    JOB_RESERVED_HARVESTER: 7
-    
-    // OTHER
-};

JobBuilder.js

@@ -0,0 +1,8 @@
+module.exports = {
+    begin(creep){
+    },
+    
+    tick(creep){
+
+    }
+}

JobHarvester.js

@@ -0,0 +1,89 @@
+module.exports = {
+    begin(creep){
+        if(!creep.memory.harvesting) creep.memory.harvesting = false;
+        if(!creep.memory.counter) creep.memory.counter = 0;
+    },
+    
+    tick(creep){
+        if(creep.memory.harvesting) {            
+            pickUpEnergy(creep);
+            onEnergyFullTurnToJobMode(creep);
+        }
+        else {
+            performJobs(creep);
+            onOutOfEnergyTurnHarvestingMode(creep);
+        }
+    }
+}
+
+function pickUpEnergy(creep){
+    if(!creep.memory.target) {
+        const target = creep.pos.findClosestByRange(FIND_DROPPED_RESOURCES, {filter: {resourceType: RESOURCE_ENERGY}});
+        if(target) creep.memory.target = target.id;
+    }
+    const resource = Game.getObjectById(creep.memory.target);
+    if(!resource) creep.memory.target = undefined;
+    if(creep.pos.isNearTo(resource)) creep.pickup(resource);
+    else creep.moveTo(resource);
+}
+
+function harvestSource(creep){
+    if(!creep.memory.target) creep.memory.target = getSourceIdFromRoomTable(creep);
+    var source = Game.getObjectById(creep.memory.target);
+    if(creep.pos.isNearTo(source)) creep.harvest(source);
+    else creep.moveTo(source);
+}
+
+function onEnergyFullTurnToJobMode(creep){
+    if(!creep.store.getFreeCapacity(RESOURCE_ENERGY)) {
+        creep.memory.harvesting = false;
+        creep.memory.target = undefined; 
+    }
+}
+
+function performJobs(creep){
+    if(!creep.memory.target) creep.memory.target = getJobTarget(creep); 
+    var target = Game.getObjectById(creep.memory.target);          
+    if(creep.pos.isNearTo(target)) doJob(creep, target);
+    else creep.moveTo(target);
+}
+
+function onOutOfEnergyTurnHarvestingMode(creep){
+    if(!creep.store.getUsedCapacity(RESOURCE_ENERGY)) {
+        creep.memory.harvesting = true;
+        creep.memory.target = undefined; 
+        creep.memory.counter += 1;
+    }
+}
+
+function getSourceIdFromRoomTable(creep) {
+    const sourceTable = creep.room.memory.layout.sources; 
+    const sourceIterator = creep.memory.counter%creep.room.memory.layout.sources.length;
+    const sourceId = sourceTable[sourceIterator];
+    return sourceId;
+}
+
+function getJobTarget(creep) {
+    var target;
+    switch (creep.memory.counter%3) {
+        case 0: target = creep.room.controller; break;
+        case 1: target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES, {filter:{structureType:STRUCTURE_SPAWN}}); break;
+        case 2: target = creep.pos.findClosestByRange(FIND_MY_CONSTRUCTION_SITES); break;
+    }
+    if(target) return target.id;
+    creep.memory.counter++;
+    return undefined;
+}
+
+function doJob(creep, target){
+    var response;
+    switch (creep.memory.counter%3) {
+        case 0: response = creep.upgradeController(target); break;
+        case 1: response = creep.transfer(target, RESOURCE_ENERGY); break;
+        case 2: response = creep.build(target); break;
+    }
+    if(response == ERR_FULL) {
+        creep.memory.counter++;
+        creep.memory.target = undefined; 
+    }
+}

JobMiner.js

@@ -0,0 +1,18 @@
+module.exports = {
+    begin(creep){},
+    
+    tick(creep){
+        const source = Game.getObjectById(creep.memory.job.source);
+        if(creep.memory.aboveContainer) creep.harvest(source);
+        if(!creep.pos.isNearTo(source)) { creep.moveTo(source); return; }
+        if(creep.memory.container) {
+            const container = Game.getObjectById(creep.memory.container);
+            if(container.pos.x === creep.pos.x, container.pos.y === creep.pos.y) creep.memory.aboveContainer = true; 
+            else creep.moveTo(container);
+        } else{
+            const container = source.pos.findInRange(FIND_STRUCTURES, 1, {filter:{structureType:STRUCTURE_CONTAINER}})[0];            
+            if(container) creep.memory.container = container.id;
+            else creep.harvest(source);
+        }
+    }
+}

JobSupplier.js

@@ -0,0 +1,8 @@
+module.exports = {
+    begin(creep){
+    },
+    
+    tick(creep){
+
+    }
+}

JobUpgrader.js

@@ -0,0 +1,8 @@
+module.exports = {
+    begin(creep){
+    },
+    
+    tick(creep){
+
+    }
+}

Math.js

@@ -0,0 +1,7 @@
+module.exports = {
+    clamp: function(v, min, max){
+        if(v<min) v = min;
+        else if (max < v) v = max;
+        return v;
+    } 
+}

RoomClass.js

@@ -0,0 +1,44 @@
+module.exports = {
+	setup: function () { Room.prototype = _Room.prototype; }
+}
+
+class _Room extends Room {
+	begin(){
+		roomScan(this);
+		jobScan(this);
+		vacancyScan(this);
+		this.memory.init = true;	
+    }
+    
+    tick(){
+		if(!this.memory.init) this.begin(); 
+		if(Game.time%100 === 1) vacancyScan(this);
+    }
+}   
+
+function roomScan(room){
+	room.memory.layout = {
+		sources: room.find(FIND_SOURCES).map(s=>s.id)
+	};
+}
+
+function jobScan(room){
+	if(!room.memory.jobs) room.memory.jobs = Array(10).fill({role: Role.HARVESTER})
+		.concat(room.memory.layout.sources.map(s=> {return {role: Role.MINER, source: s}}));	
+}
+
+function vacancyScan(room){
+	const activeJobs = room.find(FIND_MY_CREEPS).map(creep=>creep.memory.job);
+	console.log(activeJobs.toString());
+	console.log(room.memory.jobs.toString());
+	const jobs = room.memory.jobs.filter((j)=>{
+		const index = activeJobs.findIndex(aj=> _.isEqual(aj,j));
+		if(index < 0) return true;
+		activeJobs.splice(index,1);
+		return false;
+	});
+	console.log(jobs.toString());
+
+	room.memory.vacancies = jobs;
+}
+

Structure.js

@@ -0,0 +1,21 @@
+const spawnClass = require("StructureSpawnClass");
+
+module.exports = {
+	setup() {
+		spawnClass.setup();
+	},
+
+	begin(structure){
+		switch (structure.structureType) {
+			case STRUCTURE_SPAWN: structure.begin(); break;
+			default: break;
+		}
+	},
+
+	tick(structure){
+		switch (structure.structureType) {
+			case STRUCTURE_SPAWN: structure.tick(); break;
+			default: break;
+		}
+	}
+}

StructureSpawnClass.js

@@ -0,0 +1,43 @@
+module.exports = {
+	setup: function () { StructureSpawn.prototype = _StructureSpawn.prototype; }
+}
+
+class _StructureSpawn extends StructureSpawn {	
+	begin(){
+		if (!this.memory.creepCounter) this.memory.creepCounter = 0;
+		this.memory.init = true;
+    }
+    
+    tick(){
+		if(!this.memory.init) this.begin();
+		if(this.store.getUsedCapacity(RESOURCE_ENERGY) < 300) return; 
+		const job = this.room.memory.vacancies.pop();
+		if(job){
+			const name = getJobName(job.role);
+			const body = getBodyByJob(job.role);
+			if(this.createCreep(job, name, body) != OK) this.room.memory.vacancies.push(job);
+		}
+    }
+
+	createCreep(job, name, body) {
+		const response = this.spawnCreep(body, name + ": " + this.memory.creepCounter, {
+			memory: { job: job }
+		});
+		if (response == OK) this.memory.creepCounter++;
+		return response;
+	}
+}
+
+function getJobName(role){
+	switch (role) {
+		case Role.HARVESTER: return "Harvy";
+		case Role.MINER: return "minny";
+	}
+}
+
+function getBodyByJob(role){
+	switch (role) {
+		case Role.HARVESTER: return [WORK, CARRY, MOVE, MOVE];
+		case Role.MINER: return [WORK, WORK, MOVE];
+	}
+}

ai_main.js

@@ -1,65 +0,0 @@
-
-/*  ###########################
-    # Cross room managment AI #
-    ########################### */
-
-var GLOBAL = require("GLOBAL_VARIABLES");
-
-module.exports = {
-    run_front: function()
-    {
-        if(Memory.AImain == null) Memory.AImain = {};
-        if(Memory.AImain.MainHub == null) Memory.AImain.MainHub = "insert name"
-        for(var n_flag in Game.flags){
-            var flag = Game.flags[n_flag];
-            if(flag.color == COLOR_YELLOW){
-                if(flag.room != undefined && flag.room.find(FIND_MY_CREEPS).length != flag.room.find(FIND_CREEPS).length){
-                    Game.spawns[Memory.AImain.MainHub].spawnCreep([TOUGH, TOUGH, TOUGH, TOUGH, TOUGH, TOUGH, TOUGH, ATTACK, ATTACK, ATTACK, MOVE], 
-                    "Defender", { memory: { role:GLOBAL.JOB_DEFENDER , flag: flag.name }});
-                    break;
-                }
-                if(flag.room == undefined ||  flag.room.controller.reservation == undefined || (
-                    flag.room.controller.reservation.username == "DouweRavers" && flag.room.controller.reservation.ticksToEnd < 3500))
-                {
-                    if(Memory.AImain.MainHub != "insert name") Game.spawns[Memory.AImain.MainHub].spawnCreep([MOVE, CLAIM, CLAIM], "columbus", { memory: { role:GLOBAL.JOB_RESERVER, target: flag.name, home: Memory.AImain.MainHub}});
-                }
-                if(flag.room != undefined && flag.room.controller.reservation != undefined && flag.room.controller.reservation.username == "DouweRavers")
-                {
-                    var containers = flag.room.find(FIND_STRUCTURES, { filter:(s) => ( s.structureType == STRUCTURE_CONTAINER )});
-                    if(containers.length > 0){
-                        var has_miner = false;
-                        console.log("test");
-                        var creeps = flag.room.find(FIND_CREEPS);
-                        for(var cp in creeps){
-                            console.log(creeps[cp]);
-                            var creep = creeps[cp];
-                            if(creep.memory.role == GLOBAL.JOB_MINER){
-                                has_miner = true;
-                            }
-                        }
-                        if(!has_miner) {
-                            console.log("needs new miner")
-                            Game.spawns[Memory.AImain.MainHub].spawnCreep([ WORK, WORK, WORK, WORK, WORK, MOVE ], "ForeignMiner", { memory: { role:GLOBAL.JOB_MINER, container_id: containers[0].id}});
-                        }
-                    }
-                    var harvs = flag.room.find(FIND_MY_CREEPS).length;
-                    var source_id = flag.room.find(FIND_SOURCES)[0].id;
-                    if(harvs < 4){
-                        var spawn = Game.spawns[Memory.AImain.MainHub];
-                        var body = [];
-                        for(let i=0;i<Math.floor(spawn.room.energyAvailable/200);i++){
-                            body.push(WORK);
-                            body.push(CARRY);
-                            body.push(MOVE);
-                        }
-                        var name = "ForeignHarvy"+spawn.memory.creep_iterate;
-                        spawn.spawnCreep( body, name, { memory: 
-                                {role: GLOBAL.JOB_RESERVED_HARVESTER, source_id: source_id}});    
-                        
-                    }
-                }
-            }
-        }
-    },
-    run_back: function(){}
-};

controller_creeps.js

@@ -1,41 +0,0 @@
-
-/*  #######################################
-    # Controls the jobs of all the creeps #
-    #######################################*/
-
-var GLOBAL = require("GLOBAL_VARIABLES");
-
-var job_harvester = require("job_harvester");
-var job_miner = require("job_miner");
-var job_supplier = require("job_supplier");
-var job_builder = require("job_builder");
-var job_upgrader = require("job_upgrader");
-var job_defender = require("job_defender");
-var job_reserver = require("job_reserver");
-var job_reserved_harvester = require("job_reserved_harvester");
-
-module.exports = {
-    run: function(){
-        for(var cr in Game.creeps){
-            cr = Game.creeps[cr];
-            switch(cr.memory.role){
-                case GLOBAL.JOB_HARVESTER: job_harvester.do(cr);
-                    break;
-                case GLOBAL.JOB_MINER: job_miner.do(cr);
-                    break;
-                case GLOBAL.JOB_SUPPLIER: job_supplier.do(cr);
-                    break;
-                case GLOBAL.JOB_BUILDER: job_builder.do(cr);
-                    break;
-                case GLOBAL.JOB_UPGRADER: job_upgrader.do(cr);
-                    break;
-                case GLOBAL.JOB_DEFENDER: job_defender.do(cr);
-                    break;
-                case GLOBAL.JOB_RESERVER: job_reserver.do(cr);
-                    break;
-                case GLOBAL.JOB_RESERVED_HARVESTER: job_reserved_harvester.do(cr);
-                    break;
-            }
-        }
-    }
-};

controller_spawns.js

@@ -1,171 +0,0 @@
-
-/*  #####################################
-    # Controls the way creeps are spawn #
-    #####################################*/
-
-var GLOBAL = require("GLOBAL_VARIABLES");
-
-module.exports = {
-    run: function(){
-        for(var sp in Game.spawns){
-            sp = Game.spawns[sp]
-            // values
-            var creep_count = 0
-            for(var cr in Game.creeps){
-                if(Game.creeps[cr].room.name == sp.room.name) creep_count += 1;
-            }
-            var source_count = 0;
-            if(sp.memory.sources_ids != undefined) source_count = sp.memory.sources_ids.length;
-
-            
-            // Memory setup
-            if(sp.memory.creep_iterate == undefined) sp.memory.creep_iterate = 0;
-
-            if(sp.memory.sources_ids == undefined){
-                sp.memory.sources_ids = [];
-                var sources = sp.room.find(FIND_SOURCES);
-                for(var source in sources){
-                    source = sources[source];
-                    sp.memory.sources_ids.push(source.id);
-                }
-                source_count = sp.memory.sources_ids.length;
-            }
-
-            if(sp.memory.containers_ids == undefined || sp.memory.containers_ids.length != source_count){
-                sp.memory.containers_ids = [];
-                var containers = sp.room.find(FIND_STRUCTURES, { filter:{ structureType: STRUCTURE_CONTAINER }});
-                if(containers.length > 0){
-                    for(let i=0;i<containers.length;i+=1){
-                        sp.memory.containers_ids.push(containers[i].id);
-                    }
-                }
-            }
-
-            // Different spawning configurations
-           
-            // Add improved versions at top of if-else statement
-            if(sp.memory.containers_ids.length >= source_count && sp.room.energyCapacityAvailable >= 550 && creep_count > source_count ){ // Miner method: Miners fille containers rest picks up from them
-                // Check current creep_jobs
-                var jobs = { miner: 0, supplier: 0, builder: 0, upgrader: 0, defender: 0};
-                var container_id = sp.memory.containers_ids[0];
-                for(var creep in Game.creeps){
-                    var creep = Game.creeps[creep];
-                    if(creep.room.name != sp.room.name) continue;
-                    switch (creep.memory.role) {
-                        case GLOBAL.JOB_MINER:
-                            jobs.miner += 1;    
-                            for(let i=0;i<sp.memory.containers_ids.length;i++){
-                                if(creep.memory.container_id != sp.memory.containers_ids[i]) container_id = sp.memory.containers_ids[i]; 
-                            }
-                            break;
-                        case GLOBAL.JOB_SUPPLIER:
-                            jobs.supplier += creep.body.length;
-                            break;
-                        case GLOBAL.JOB_BUILDER:
-                            jobs.builder += creep.body.length;
-                            break;
-                        case GLOBAL.JOB_UPGRADER:
-                            jobs.upgrader += creep.body.length;
-                            break;
-                        case GLOBAL.JOB_DEFENDER:
-                            jobs.defender += 1;
-                            break;
-                        default:
-                            break;
-                    }
-                }
-                if(jobs.miner < source_count){
-                    if(sp.room.energyAvailable >= 550) create_miner(sp, container_id);
-                }
-                else if(jobs.supplier < source_count * 15 && sp.room.energyAvailable >= 300 && jobs.miner > 0) create_supplier(sp);
-                else if(jobs.builder < source_count * 5 && sp.room.energyAvailable >= 300 && jobs.miner > 0) create_builder(sp);
-                else if(jobs.upgrader < source_count * 5 && sp.room.energyAvailable >= 300 && jobs.miner > 0) create_upgrader(sp);
-                else if(jobs.defender < 0 && sp.room.energyAvailable >= sp.room.energyCapacityAvailable*0.8 && jobs.miner > 0) create_defender(sp);
-            } else { // Harvesting method: everybody mines own sources
-                if (sp.room.find(FIND_MY_CREEPS).length < source_count * 5 && sp.room.energyAvailable >= 300){
-                    var source_id = sp.memory.sources_ids[sp.memory.creep_iterate % source_count];
-                    create_harvester(sp, source_id);
-                }
-            }
-        }
-    }
-};
-
-
-function create_harvester(sp, source_id){
-    var body = [];
-    for(let i=0;i<Math.floor(sp.room.energyAvailable/200);i++){
-        body.push(WORK);
-        body.push(CARRY);
-        body.push(MOVE);
-    }
-    var name = "Harvy"+sp.memory.creep_iterate;
-    sp.spawnCreep( body, name, { memory: 
-            {role: GLOBAL.JOB_HARVESTER, source_id: source_id}});
-    sp.memory.creep_iterate += 1;
-}
-
-function create_miner(sp, container_id){
-    var body = [ WORK, WORK, WORK, WORK, WORK, MOVE ]; // (creep)5*work(2energy/tick)=10energy/tick -> (source)3000energy/300tick=10energy/tick
-    var name = "Mindy"+sp.memory.creep_iterate;
-    sp.spawnCreep( body, name, { memory: 
-        {role: GLOBAL.JOB_MINER, container_id: container_id}});
-    sp.memory.creep_iterate += 1;
-}
-
-function create_supplier(sp){
-    var body = [WORK];
-
-    for(let i=0;i<Math.floor(sp.room.energyAvailable/100)-1 && i < 8;i++){ // as big as possible
-        body.push(CARRY);
-        body.push(MOVE);
-    }
-    var name = "Suppry"+sp.memory.creep_iterate;
-    sp.spawnCreep( body, name, { memory: 
-        {role: GLOBAL.JOB_SUPPLIER}});
-    sp.memory.creep_iterate += 1; 
-}
-
-function create_builder(sp){
-    var body = [];
-
-    for(let i=0;i<Math.floor(sp.room.energyAvailable/200);i++){ // as big as possible
-        body.push(CARRY);
-        body.push(MOVE);
-        body.push(WORK);
-    }
-    var name = "Bobby"+sp.memory.creep_iterate;
-    sp.spawnCreep( body, name, { memory: 
-        {role: GLOBAL.JOB_BUILDER}});
-    sp.memory.creep_iterate += 1; 
-}
-
-function create_upgrader(sp){
-    var body = [];
-
-    for(let i=0;i<Math.floor(sp.room.energyAvailable/300);i++){ // as big as possible
-        body.push(CARRY);
-        body.push(MOVE);
-        body.push(WORK);
-        body.push(WORK);
-    }
-    var name = "Undy"+sp.memory.creep_iterate;
-    sp.spawnCreep( body, name, { memory: 
-        {role: GLOBAL.JOB_UPGRADER}});
-    sp.memory.creep_iterate += 1; 
-}
-
-function create_defender(sp){
-    var body = [];
-
-    for(let i=0;i<Math.floor(sp.room.energyAvailable/150);i++){ // as big as possible
-        body.push(TOUGH);
-        body.push(TOUGH);
-        body.push(ATTACK);
-        body.push(MOVE);
-    }
-    var name = "Destroyer CODE"+sp.memory.creep_iterate;
-    sp.spawnCreep( body, name, { memory: 
-        {role: GLOBAL.JOB_DEFENDER}});
-    sp.memory.creep_iterate += 1; 
-}

controller_towers.js

@@ -1,37 +0,0 @@
-module.exports = {
-    
-    run: function(){
-        for(var spawn in Game.spawns){
-            var room = Game.spawns[spawn].room;
-            var towers = room.find(FIND_MY_STRUCTURES,
-                {filter: (s)=>(s.structureType == STRUCTURE_TOWER)});
-            for(var tower in towers){
-                tower = towers[tower];
-                var enemy = tower.pos.findClosestByRange(FIND_HOSTILE_CREEPS);
-                if(enemy != null) tower.attack(enemy);
-                else {
-                    var healt_creep = false;
-                    for(var creep in Game.creeps){
-                        creep = Game.creeps[creep];
-                        if(creep.hits < creep.hitsMax) {
-                            tower.heal(creep);
-                            healt_creep = true;
-                        }
-                    }
-                    if(!healt_creep && 500 < tower.energy){
-                         var structure = tower.pos.findClosestByPath(FIND_STRUCTURES, 
-                           {filter: (s)=>( (s.structureType != STRUCTURE_RAMPART && s.structureType != STRUCTURE_WALL && s.hits < s.hitsMax )
-                                || ( s.structureType == STRUCTURE_RAMPART && s.hits < 10000 ))});
-                        if(structure == null) structure = tower.pos.findClosestByRange(FIND_STRUCTURES, 
-                           {filter: (s)=>((s.structureType == STRUCTURE_RAMPART) && s.hits < 1000)});
-                        if(structure == null) structure = tower.pos.findClosestByRange(FIND_STRUCTURES, 
-                           {filter: (s)=>((s.structureType == STRUCTURE_WALL) && s.hits < 1000)});
-                        tower.repair(structure);
-                    }
-                   
-                }
-            }
-        }
-    }
-
-};

job_builder.js

@@ -1,57 +0,0 @@
-
-/*  #######################################################
-    # Deliver energy to spawns, controller and extencions #
-    ####################################################### */
-
-module.exports = {
-    do: function(creep){
-        //creep.memory.target = null;
-
-        // Memory creation
-        if(creep.memory.restock == undefined) creep.memory.restock = true;
-        if(creep.memory.target == undefined) creep.memory.target = null;
-        
-        // Job implementation
-        if(creep.memory.restock){
-            if(creep.memory.target == null){
-                if(creep.room.storage != null && 1000 < creep.room.storage.store.getUsedCapacity(RESOURCE_ENERGY)) creep.memory.target = creep.room.storage.id;
-                else {
-                    var container = creep.pos.findClosestByPath(FIND_STRUCTURES, 
-                        {filter: (s)=>(s.structureType == STRUCTURE_CONTAINER
-                        && 0 < s.store.getUsedCapacity(RESOURCE_ENERGY))});
-                    if(container != null) creep.memory.target = container.id;
-                }
-            }
-            var target = Game.getObjectById(creep.memory.target);
-            if(creep.withdraw(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
-            if(target != null && target.store.getUsedCapacity(RESOURCE_ENERGY) < creep.store.getFreeCapacity(RESOURCE_ENERGY)*0.4) creep.memory.target = null;
-            if(creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0){
-                creep.memory.restock = false;
-                creep.memory.target = null;
-            }
-        } else {
-            if(creep.memory.target == null){ // aquire target
-                // constuction
-                var structure = creep.pos.findClosestByRange(FIND_MY_CONSTRUCTION_SITES);
-                
-                // ramparts
-                if(structure == null){
-                    var ramparts = creep.room.find(FIND_STRUCTURES, 
-                        {filter: (s)=>((s.structureType == STRUCTURE_RAMPART || s.structureType == STRUCTURE_WALL) && s.hits < s.hitsMax)});
-                    for(var ramp in ramparts){
-                        ramp = ramparts[ramp];
-                        if(structure == null || structure.hits > ramp.hits) structure = ramp;
-                    }
-                }
-                creep.memory.target = structure.id;
-            }
-            var target = Game.getObjectById(creep.memory.target);
-            if(target == null || target.hits == target.hitsMax) creep.memory.target = null;
-            if(creep.build(target) == ERR_NOT_IN_RANGE || creep.repair(target) == ERR_NOT_IN_RANGE) creep.moveTo(target);
-            if(creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0){
-                creep.memory.restock = true;
-                creep.memory.target = null;
-            }
-        }
-    }
-};

job_defender.js

@@ -1,22 +0,0 @@
-
-/*  #######################################################
-    # Deliver energy to spawns, controller and extencions #
-    ####################################################### */
-
-module.exports = {
-    do: function(creep){
-        if(creep.memory.flag != undefined && Game.flags[creep.memory.flag].room.name != creep.room.name) creep.moveTo(Game.flags[creep.memory.flag]); 
-        if(creep.memory.target == undefined) creep.memory.target = null;
-        if(creep.memory.target == null){
-            var enemy = creep.pos.findClosestByPath(FIND_HOSTILE_CREEPS);
-            if(enemy != null) creep.memory.target = enemy.id;
-        }
-        var enemy = Game.getObjectById(creep.memory.target);
-        if(enemy != null){
-            creep.say("ATTACK");
-            if(creep.attack(enemy) == ERR_NOT_IN_RANGE) creep.moveTo(enemy);
-        } else {
-            creep.memory.target = null;
-        }
-    }
-};

job_harvester.js

@@ -1,92 +0,0 @@
-
-/*  ###########################################
-    # Mine energy and do all fundamental jobs #
-    ###########################################*/
-
-module.exports = {
-    do: function(creep){
-        //memory setup
-        if(creep.memory.harvesting == undefined) creep.memory.harvesting = true;
-        if(creep.memory.counter == undefined) creep.memory.counter = 0;
-        if(creep.memory.target == undefined) creep.memory.target = null;
-
-        if (creep.memory.harvesting){
-            var source = Game.getObjectById(creep.memory.source_id);
-            var result = creep.harvest(source);
-            if (result == ERR_NOT_IN_RANGE){
-                creep.moveTo(source);    
-            }
-            if (result == ERR_NOT_ENOUGH_RESOURCES || creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0){
-                creep.memory.harvesting = false;
-                creep.memory.target = null;
-            }
-        } else {
-            if(creep.memory.target == null){
-                switch(creep.memory.counter%10){
-                    case 0: // upgrading
-                        creep.memory.target = creep.room.controller.id;
-                        break;
-                    case 1: // suppling
-                    case 2:
-                    case 3:
-                    case 4:
-                        creep.memory.target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES,{
-                            filter:(s) => ( s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_EXTENSION ) && s.store.getFreeCapacity(RESOURCE_ENERGY) > 0});
-                        if(creep.memory.target != null) creep.memory.target = creep.memory.target.id;
-                        else creep.memory.counter += 1;
-                        break;
-                    case 5:
-                    case 6:
-                    case 7:
-                    case 8:
-                        creep.memory.target = creep.pos.findClosestByRange(FIND_CONSTRUCTION_SITES);
-                        if(creep.memory.target != null) creep.memory.target = creep.memory.target.id;
-                        else creep.memory.counter += 1;
-                        break;
-                    case 9: // repairing (no walls or ramparts)
-                        creep.memory.target = creep.pos.findClosestByRange(FIND_STRUCTURES,{
-                            filter:(s) => ( s.structureType != STRUCTURE_WALL && s.structureType != STRUCTURE_RAMPART) && s.hits < s.hitsMax});
-                        if(creep.memory.target != null) creep.memory.target = creep.memory.target.id;
-                        else creep.memory.counter += 1;
-                        break;
-                }
-            }
-            
-            var target = Game.getObjectById(creep.memory.target);
-            var response = OK;
-            switch(creep.memory.counter%10){
-                case 0:
-                    response = creep.transfer(target, RESOURCE_ENERGY);
-                    break;
-                case 1:
-                case 2:
-                case 3:
-                case 4:
-                    response = creep.transfer(target, RESOURCE_ENERGY);
-                    if(target != null && target.store.getFreeCapacity(RESOURCE_ENERGY) == 0) creep.memory.target = null;
-                    break;
-                case 5:
-                case 6:
-                case 7:
-                case 8:
-                    response = creep.build(target);
-                    if(target != null && target.progress == target.progressTotal) creep.memory.target = null;
-                    break;
-                case 9:
-                    response = creep.repair(target);
-                    if(target != null && target.hits == target.hitsMax) creep.memory.target = null;
-                    break;
-            }
-            if(response == ERR_NOT_IN_RANGE){
-                creep.moveTo(target);
-            } else if(response == ERR_FULL || response == ERR_INVALID_TARGET){
-                creep.memory.target = null;
-            }
-            if (creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0){
-                creep.memory.harvesting = true;
-                creep.memory.target = null;
-                creep.memory.counter += 1;
-            }
-        }
-    }
-};

job_miner.js

@@ -1,16 +0,0 @@
-
-/*  ########################################
-    # Mine energy and drop it in container #
-    ########################################*/
-
-module.exports = {
-    do: function(creep){
-        var container = Game.getObjectById(creep.memory.container_id);
-        if(container != null && creep.pos.isEqualTo(container.pos)){
-            if(creep.memory.source_id == undefined) creep.memory.source_id = creep.pos.findClosestByPath(FIND_SOURCES).id;
-            creep.harvest(Game.getObjectById(creep.memory.source_id));
-        } else {
-            creep.moveTo(Game.getObjectById(creep.memory.container_id));
-        }
-    }
-};

job_reserved_harvester.js

@@ -1,93 +0,0 @@
-
-/*  ###########################################
-    # Mine energy and do all fundamental jobs #
-    ###########################################*/
-
-module.exports = {
-    do: function(creep){
-        creep.memory.home = "Central"
-        //memory setup
-        if(creep.memory.harvesting == undefined) creep.memory.harvesting = true;
-        if(creep.memory.counter == undefined) creep.memory.counter = 0;
-        if(creep.memory.target == undefined) creep.memory.target = null;
-
-        if (creep.memory.harvesting){
-            var source = Game.getObjectById(creep.memory.source_id);
-            if(source != undefined && creep.room.name == source.room.name){
-                var container = creep.pos.findClosestByPath(FIND_STRUCTURES, { filter:(s) => ( s.structureType == STRUCTURE_CONTAINER && s.store.getUsedCapacity(RESOURCE_ENERGY) > creep.store.getFreeCapacity(RESOURCE_ENERGY))});
-                if(container == null) {
-                    var source = Game.getObjectById(creep.memory.source_id);
-                    result = creep.harvest(source);
-                    if (result == ERR_NOT_IN_RANGE){
-                        creep.moveTo(source);    
-                    }
-                } else {
-                    var result = creep.withdraw(container, RESOURCE_ENERGY);
-                    if (result == ERR_NOT_IN_RANGE){
-                        creep.moveTo(container);
-                    }
-                }
-                if (creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0){
-                    creep.memory.harvesting = false;
-                    creep.memory.target = null;
-                }
-            } else {
-                creep.moveTo(source);
-            }
-        } else {
-            if(creep.memory.target == null){
-                switch(creep.memory.counter%3){
-                    case 0: // building
-                        creep.memory.target = creep.pos.findClosestByRange(FIND_CONSTRUCTION_SITES);
-                        if(creep.memory.target != null) creep.memory.target = creep.memory.target.id;
-                        else creep.memory.counter += 1;
-                        break;
-                    case 1: // repairing (no walls or ramparts)
-                        creep.memory.target = creep.pos.findClosestByRange(FIND_STRUCTURES,{
-                            filter:(s) => ( s.structureType != STRUCTURE_WALL && s.structureType != STRUCTURE_RAMPART) && s.hits < s.hitsMax-creep.store.getUsedCapacity(RESOURCE_ENERGY)*3/4});
-                        if(creep.memory.target != null) creep.memory.target = creep.memory.target.id;
-                        else creep.memory.counter += 1;
-                        break;
-                    case 2:
-                        var home = Game.spawns[creep.memory.home];
-                        if(creep.room.name == home.room.name){
-                            creep.memory.target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES,{
-                            filter:(s) => ( s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_EXTENSION || s.structureType == STRUCTURE_STORAGE ) && s.store.getFreeCapacity(RESOURCE_ENERGY) > 0});
-                            if(creep.memory.target != null) creep.memory.target = creep.memory.target.id;
-                            else creep.memory.counter += 1;
-                        } else {
-                            creep.moveTo(home);
-                        }
-                        break;
-                }
-            }
-            
-            var target = Game.getObjectById(creep.memory.target);
-            var response = OK;
-            switch(creep.memory.counter%3){
-                case 0: // building
-                    response = creep.build(target);
-                    if(target != null && target.progress == target.progressTotal) creep.memory.target = null;
-                    break;
-                case 1:
-                    response = creep.repair(target);
-                    if(target != null && target.hits == target.hitsMax) creep.memory.target = null;
-                    break;
-                case 2:
-                    response = creep.transfer(target, RESOURCE_ENERGY);
-                    if(target != null && target.store.getFreeCapacity(RESOURCE_ENERGY) == 0) creep.memory.target = null;
-                    break;
-            }
-            if(response == ERR_NOT_IN_RANGE){
-                creep.moveTo(target);
-            } else if(response == ERR_FULL || response == ERR_INVALID_TARGET){
-                creep.memory.target = null;
-            }
-            if (creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0){
-                creep.memory.harvesting = true;
-                creep.memory.target = null;
-                creep.memory.counter += 1;
-            }
-        }
-    }
-};

job_reserver.js

@@ -1,16 +0,0 @@
-
-/*  ###########################################
-    # Go to a controller and reserve the room #
-    ###########################################*/
-
-module.exports = {
-    do: function(creep){
-        if(Game.flags[creep.memory.target].room != undefined && Game.flags[creep.memory.target].room == creep.room){
-            if(creep.reserveController(creep.room.controller) == ERR_NOT_IN_RANGE){
-                creep.moveTo(creep.room.controller);
-            }
-        } else {
-            creep.moveTo(Game.flags[creep.memory.target]);
-        }
-    }
-};

job_supplier.js

@@ -1,54 +0,0 @@
-
-/*  #######################################################
-    # Deliver energy to spawns, controller and extencions #
-    ####################################################### */
-
-module.exports = {
-    do: function(creep){
-        // Memory creation
-        if(creep.memory.restock == undefined) creep.memory.restock = true;
-        if(creep.memory.target == undefined) creep.memory.target = null;
-        // Job implementation
-        if(creep.memory.restock){
-            if(creep.memory.target == null){ // aquire target
-                var containers = creep.room.find(FIND_STRUCTURES, 
-                    {filter: (s)=>(s.structureType == STRUCTURE_CONTAINER
-                        && s.store.getUsedCapacity(RESOURCE_ENERGY) >= creep.store.getFreeCapacity(RESOURCE_ENERGY)/2)});
-                var container = containers[0];
-                for(var c in containers){
-                    c = containers[c];
-                    if(c.store.getUsedCapacity(RESOURCE_ENERGY) > container.store.getUsedCapacity(RESOURCE_ENERGY)) container = c;
-                }
-                if(container != null) creep.memory.target = container.id;
-                else creep.memory.target = creep.room.storage.id;
-            }
-            var target = Game.getObjectById(creep.memory.target);
-            if(creep.withdraw(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
-            if(target != null && target.store.getUsedCapacity(RESOURCE_ENERGY) < creep.store.getFreeCapacity(RESOURCE_ENERGY)*0.4) creep.memory.target = null;
-            if(creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0){
-                creep.memory.restock = false;
-                creep.memory.target = null;
-            }
-        } else {
-            if(creep.memory.target == null){ // aquire target
-                var structure = creep.pos.findClosestByPath(FIND_MY_STRUCTURES, 
-                    {filter: (s)=>(s.structureType == STRUCTURE_TOWER && s.store.getUsedCapacity(RESOURCE_ENERGY) < 900)});
-                if(structure == null) structure = creep.pos.findClosestByPath(FIND_MY_STRUCTURES, 
-                    {filter: (s)=>(( s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_EXTENSION) 
-                        && s.store.getFreeCapacity(RESOURCE_ENERGY) > s.store.getCapacity(RESOURCE_ENERGY)*0.1)});
-                if(structure == null) structure = creep.pos.findClosestByPath(FIND_MY_STRUCTURES, 
-                    {filter: (s)=>(( s.id == "5f3e44e1014017c66fc5df10") && s.store.getFreeCapacity() > 100)});
-                if(structure == null) structure = creep.room.storage;
-                if(structure == null) return;
-                creep.memory.target = structure.id;
-            }
-            var target = Game.getObjectById(creep.memory.target);
-            if(creep.transfer(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
-            if(target != null && target.store.getFreeCapacity(RESOURCE_ENERGY) == 0) creep.memory.target = null;
-            if(creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0){
-                creep.memory.restock = true;
-                creep.memory.target = null;
-            }
-        }
-    }
-};

job_upgrader.js

@@ -1,43 +0,0 @@
-
-/*  #######################################################
-    # Deliver energy to spawns, controller and extencions #
-    ####################################################### */
-
-module.exports = {
-    do: function(creep){
-        // Memory creation
-        if(creep.memory.restock == undefined) creep.memory.restock = true;
-        if(creep.memory.target == undefined) creep.memory.target = null;
-        
-        // Job implementation
-        if(creep.memory.restock){
-            if(creep.memory.target == null){
-                if(creep.room.storage != null && 1000 < creep.room.storage.store.getUsedCapacity(RESOURCE_ENERGY)) creep.memory.target = creep.room.storage.id;
-                else {
-                    var container = creep.pos.findClosestByPath(FIND_STRUCTURES, 
-                        {filter: (s)=>(s.structureType == STRUCTURE_CONTAINER
-                        && 0 < s.store.getUsedCapacity(RESOURCE_ENERGY))});
-                    if(container != null) creep.memory.target = container.id;
-                }
-            }
-            var target = Game.getObjectById(creep.memory.target);
-            if(creep.withdraw(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
-            if(target != null && target.store.getUsedCapacity(RESOURCE_ENERGY) < creep.store.getFreeCapacity(RESOURCE_ENERGY)*0.4) creep.memory.target = null;
-            if(creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0){
-                creep.memory.restock = false;
-                creep.memory.target = null;
-            }
-        } else {
-            if(creep.memory.target == null){ // aquire target
-                var structure = structure = creep.room.controller;
-                creep.memory.target = structure.id;
-            }
-            var target = Game.getObjectById(creep.memory.target);
-            if(creep.transfer(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
-            if(creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0){
-                creep.memory.restock = true;
-                creep.memory.target = null;
-            }
-        }
-    }
-};

main.js

@@ -1,26 +1,44 @@
-
-var controller_spawns = require("controller_spawns");
-var controller_creeps = require("controller_creeps");
-var controller_towers = require("controller_towers");
-var ai_main = require("ai_main");
+const Commands = require("Commands");
+const CreepClass = require("CreepClass");
+const RoomClass = require("RoomClass");
+const Structure = require("Structure");
 
 module.exports.loop = function () {
-    ai_main.run_front();
-    controller_creeps.run();
-    controller_towers.run();
-    controller_spawns.run();
-    if (Game.time % 60 == 30) clear_dead_creeps_from_memory();
-    ai_main.run_back();
+    if(!global.compiled) onRecompile();
+    else if (!global.started) onRestart();
+    else onTick(); 
 }
 
-/*
-    GLOBAL FUNCTIONS
-*/
+function onRecompile(){
+    setupClasses();
+    console.log("Script recompiled...");
+    global.compiled = true;
+}
+
+function onRestart(){
+    Object.values(Game.rooms).forEach(room => room.begin());
+    Object.values(Game.creeps).forEach(creep => creep.begin());
+    Object.values(Game.structures).forEach(structure => Structure.begin(structure));
+    global.started = true;
+}
+
+function onTick(){
+    Object.values(Game.rooms).forEach(room => room.tick());
+    Object.values(Game.creeps).forEach(creep => creep.tick());
+    Object.values(Game.structures).forEach(structure => Structure.tick(structure));
+    if(!(Game.time % 100)) cleanUp();
+}
+
+
+function setupClasses(){
+    Commands.setup(); 
+    CreepClass.setup();
+    RoomClass.setup();
+    Structure.setup();
+}
+
+function cleanUp(){
+    Object.keys(Memory.rooms).forEach(roomName => { if(!Game.rooms[roomName]) Memory.rooms[roomName] = undefined; });
+    Object.keys(Memory.creeps).forEach(creepName => { if(!Game.creeps[creepName])  Memory.creeps[creepName] = undefined; });
+}
 
-function clear_dead_creeps_from_memory() {
-    for (var cr in Memory.creeps) {
-        if (Game.creeps[cr] == null) {
-            delete (Memory.creeps[cr]);
-        }
-    }
-}