Removed the harvester. Introduced the cleaner (not active yet) spawners use full room capacity now.

CreepClass.js

@@ -1,8 +1,7 @@
 const jobBuilder = require("JobBuilder");
-const jobHarvester = require("JobHarvester");
 const jobMiner = require("JobMiner");
 const jobSupplier = require("JobSupplier");
-const JobUpgrader = require("JobUpgrader");
+const jobUpgrader = require("JobUpgrader");
 
 module.exports = {
 	setup: function () { 
@@ -12,11 +11,10 @@ module.exports = {
 }
 
 const Role = {
-	HARVESTER: 0,
+    BUILDER: 0,
     MINER: 1,
     SUPPLIER: 2,
-    UPGRADER: 3,
+    UPGRADER: 3
-    BUILDER: 4
 }
 
 class _Creep extends Creep {
@@ -24,10 +22,9 @@ class _Creep extends Creep {
         if(!this.memory.job) this.memory.job = { role: Role.HARVESTER };
         switch (this.memory.job.role) {
             case Role.BUILDER: jobBuilder.begin(this); break;
-            case Role.HARVESTER: jobHarvester.begin(this); break;
             case Role.MINER: jobMiner.begin(this); break;
             case Role.SUPPLIER: jobSupplier.begin(this); break;
-            case Role.UPGRADER: JobUpgrader.begin(this); break;
+            case Role.UPGRADER: jobUpgrader.begin(this); break;
         }
 		this.memory.init = true; 
     }
@@ -36,10 +33,9 @@ class _Creep extends Creep {
         if(!this.memory.init) this.begin();
         switch (this.memory.job.role) {
             case Role.BUILDER: jobBuilder.tick(this); break;
-            case Role.HARVESTER: jobHarvester.tick(this); break;
             case Role.MINER: jobMiner.tick(this); break;
             case Role.SUPPLIER: jobSupplier.tick(this); break;
-            case Role.UPGRADER: JobUpgrader.tick(this); break;
+            case Role.UPGRADER: jobUpgrader.tick(this); break;
         }
     }
 }

JobCleaner.js

@@ -0,0 +1,81 @@
+module.exports = {
+    begin(creep){
+        if(!creep.memory.collecting) creep.memory.collecting = false;
+    },
+    
+    tick(creep){
+        if(creep.memory.collecting) {            
+            searchForLooseEnergy(creep);
+            energyFullCheck(creep);
+        }
+        else {
+            DepositEnergy(creep);
+            energyEmptyCheck(creep);
+        }
+    }
+}
+
+function searchForLooseEnergy(creep){
+    if(!creep.memory.target) findLooseEnergyTarget(creep);
+    const target = Game.getObjectById(creep.memory.target);
+    if(!target) creep.memory.target = undefined;
+    if(creep.pos.isNearTo(target)) {
+        if(!target.store) creep.pickup(target);
+        else creep.withdraw(target, RESOURCE_ENERGY);
+    }
+    else creep.moveTo(target);
+}
+
+function energyFullCheck(creep){
+    if(!creep.store.getFreeCapacity(RESOURCE_ENERGY)) {
+        creep.memory.collecting = false;
+        creep.memory.target = undefined; 
+    }
+}
+
+function DepositEnergy(creep){
+    if(!creep.memory.target) findDepositTarget(creep);
+    if(!creep.memory.target) return;
+    const target = Game.getObjectById(creep.memory.target);
+    if(target.store.getFreeCapacity(RESOURCE_ENERGY)==0) { creep.memory.target = undefined; creep.memory.counter++; }   
+    if(creep.pos.isNearTo(target)) creep.transfer(target, RESOURCE_ENERGY);
+    else creep.moveTo(target);
+}
+
+function energyEmptyCheck(creep){
+    if(!creep.store.getUsedCapacity(RESOURCE_ENERGY)) {
+        creep.memory.collecting = true;
+        creep.memory.target = undefined; 
+    }
+}
+
+function findLooseEnergyTarget(creep){
+    var target = creep.pos.findClosestByRange(FIND_DROPPED_RESOURCES, {
+        filter: (r)=>{ 
+            return r.resourceType == RESOURCE_ENERGY && r.amount > creep.store.getFreeCapacity(RESOURCE_ENERGY);
+        }});    
+    if(!target) target = creep.pos.findClosestByRange(FIND_RUINS, {
+        filter: (r)=>{ 
+            return r.store.getUsedCapacity(RESOURCE_ENERGY) > creep.store.getFreeCapacity(RESOURCE_ENERGY);
+        }});    
+    if(!target) target = creep.pos.findClosestByRange(FIND_TOMBSTONES, {
+        filter: (t)=>{ 
+            return t.store.getUsedCapacity(RESOURCE_ENERGY) > creep.store.getFreeCapacity(RESOURCE_ENERGY);
+        }});
+    if(target) creep.memory.target = target.id;
+}
+
+function findDepositTarget(creep) {
+    var target = creep.pos.findClosestByRange(FIND_STRUCTURES, {
+        filter:(s)=> { 
+            return s.structureType == STRUCTURE_CONTAINER 
+            && s.store.getFreeCapacity(RESOURCE_ENERGY) > 1000;
+        }}); 
+    if(!target) target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES, {
+        filter:(s)=> { 
+            return (s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_EXTENSION) 
+            && s.store.getFreeCapacity(RESOURCE_ENERGY) > 0;
+        }}); 
+    if(!target) target = creep.room.storage;
+    if(target) creep.memory.target = target.id;
+}

JobHarvester.js

@@ -1,91 +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%4) {
-        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;
-        case 3: target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES, {filter:(s)=>{return s.hitsMax != s.hits;}}); break;
-    }
-    if(target) return target.id;
-    creep.memory.counter++;
-    return undefined;
-}
-
-function doJob(creep, target){
-    var response;
-    switch (creep.memory.counter%4) {
-        case 0: response = creep.upgradeController(target); break;
-        case 1: response = creep.transfer(target, RESOURCE_ENERGY); break;
-        case 2: response = creep.build(target); break;
-        case 3: response = creep.repair(target); break;
-    }
-    if(response == ERR_FULL) {
-        creep.memory.counter++;
-        creep.memory.target = undefined; 
-    }
-}

JobSupplier.js

@@ -75,7 +75,12 @@ function findTransferTarget(creep) {
     switch (creep.memory.counter%3) {
         case 0: target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES, {
             filter:(s)=> { 
-                return (s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_EXTENSION) 
+                return (s.structureType == STRUCTURE_EXTENSION) 
+                && s.store.getFreeCapacity(RESOURCE_ENERGY) > 0;
+            }}); 
+            if(!target) target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES, {
+                filter:(s)=> { 
+                    return (s.structureType == STRUCTURE_SPAWN) 
                     && s.store.getFreeCapacity(RESOURCE_ENERGY) > 0;
                 }}); 
             break;

RoomClass.js

@@ -26,8 +26,8 @@ function roomLayoutScan(room){
 
 function jobScan(room){
 	if(!room.memory.jobs) room.memory.jobs = [{role:Role.UPGRADER}]
-		.concat(Array(2).fill({role: Role.BUILDER}))
+		.concat(Array(4).fill({role: Role.BUILDER}))
-		.concat(Array(5).fill({role: Role.SUPPLIER}))
+		.concat(Array(2).fill({role: Role.SUPPLIER}))
 		.concat(room.memory.layout.sources.map(s=> {return {role: Role.MINER, source: s}}));	
 }
 

StructureSpawnClass.js

@@ -1,3 +1,5 @@
+const math = require("Math");
+
 module.exports = {
 	setup: function () { StructureSpawn.prototype = _StructureSpawn.prototype; }
 }
@@ -14,7 +16,7 @@ class _StructureSpawn extends StructureSpawn {
 		const job = this.room.memory.vacancies.pop();
 		if(job){
 			const name = getJobName(job.role);
-			const body = getBodyByJob(job.role);
+			const body = getBodyByJob(job.role, this.room.energyAvailable);
 			if(this.createCreep(job, name, body) != OK) this.room.memory.vacancies.push(job);
 		}
     }
@@ -31,19 +33,32 @@ class _StructureSpawn extends StructureSpawn {
 function getJobName(role){
 	switch (role) {
 		case Role.BUILDER: return "Bob";
-		case Role.HARVESTER: return "Harvy";
 		case Role.MINER: return "minny";
 		case Role.SUPPLIER: return "Sully";
 		case Role.UPGRADER: return "Uppa";
 	}
 }
 
-function getBodyByJob(role){
+function getBodyByJob(role, energyAvailability){
+	const body = [];
 	switch (role) { 
-		case Role.BUILDER: 
+		case Role.UPGRADER: body.push(CARRY); body.push(MOVE); energyAvailability -= 100; break;
-		case Role.HARVESTER: return [WORK, CARRY, CARRY, MOVE, MOVE];
+		case Role.MINER: body.push(MOVE); energyAvailability -= 50; break;
-		case Role.UPGRADER: return [WORK, WORK, CARRY, MOVE];
-		case Role.MINER: return [WORK, WORK, MOVE, MOVE];
-		case Role.SUPPLIER: return [CARRY, CARRY, CARRY, MOVE, MOVE, MOVE]
 	}
+	
+	var unitEnergyCost = 0;
+	while(unitEnergyCost <= energyAvailability) {
+		switch (role) {
+			case Role.BUILDER: body.push(WORK); body.push(CARRY); body.push(MOVE); unitEnergyCost = 200;  break;
+			case Role.UPGRADER:
+			case Role.MINER:
+				body.push(WORK);  unitEnergyCost = 100;
+			 	if(role === Role.MINER && body.length > 5) energyAvailability = -1; 
+				break;
+			case Role.SUPPLIER: body.push(CARRY); body.push(MOVE); unitEnergyCost = 100;  break;
+			default: energyAvailability = -1; break;
+		}
+		energyAvailability -= unitEnergyCost;
+	}
+	return body;
 }