old source files of 2018-2020.

.sync

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

Commands.js

@@ -1,61 +0,0 @@
-
-
-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

@@ -1,36 +0,0 @@
-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

@@ -0,0 +1,15 @@
+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

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

JobHarvester.js

@@ -1,89 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

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

JobUpgrader.js

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

Math.js

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

RoomClass.js

@@ -1,44 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -0,0 +1,65 @@
+
+/*  ###########################
+    # 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

@@ -0,0 +1,41 @@
+
+/*  #######################################
+    # 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

@@ -0,0 +1,171 @@
+
+/*  #####################################
+    # 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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,57 @@
+
+/*  #######################################################
+    # 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

@@ -0,0 +1,22 @@
+
+/*  #######################################################
+    # 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

@@ -0,0 +1,92 @@
+
+/*  ###########################################
+    # 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

@@ -0,0 +1,16 @@
+
+/*  ########################################
+    # 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

@@ -0,0 +1,93 @@
+
+/*  ###########################################
+    # 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

@@ -0,0 +1,16 @@
+
+/*  ###########################################
+    # 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

@@ -0,0 +1,54 @@
+
+/*  #######################################################
+    # 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

@@ -0,0 +1,43 @@
+
+/*  #######################################################
+    # 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,44 +1,26 @@
-const Commands = require("Commands");
+
-const CreepClass = require("CreepClass");
+var controller_spawns = require("controller_spawns");
-const RoomClass = require("RoomClass");
+var controller_creeps = require("controller_creeps");
-const Structure = require("Structure");
+var controller_towers = require("controller_towers");
+var ai_main = require("ai_main");
 
 module.exports.loop = function () {
-    if(!global.compiled) onRecompile();
+    ai_main.run_front();
-    else if (!global.started) onRestart();
+    controller_creeps.run();
-    else onTick(); 
+    controller_towers.run();
+    controller_spawns.run();
+    if (Game.time % 60 == 30) clear_dead_creeps_from_memory();
+    ai_main.run_back();
 }
 
-function onRecompile(){
+/*
-    setupClasses();
+    GLOBAL FUNCTIONS
-    console.log("Script recompiled...");
+*/
-    global.compiled = true;
+
+function clear_dead_creeps_from_memory() {
+    for (var cr in Memory.creeps) {
+        if (Game.creeps[cr] == null) {
+            delete (Memory.creeps[cr]);
+        }
+    }
 }
-
-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; });
-}
-