changes

Empire.js

@@ -39,58 +39,93 @@ module.exports = {
         }
          return 'Spawning initiated'
     },
-    spawnnrworker: function(){
-        for(let myroom of _.filter(Game.rooms, 'controller.my')) {
-            let name = myroom.name
+    spawnnrworker: function(name){
+        if(name==null || name== undefined){
+            for(let myroom of _.filter(Game.rooms, 'controller.my')) {
+                let name = myroom.name
+                require('proc.spawning').spawnnrworker(name)
+            }
+        } else {
             require('proc.spawning').spawnnrworker(name)
         }
          return 'Spawning initiated'
     },
-    spawnworker: function(){
-        for(let myroom of _.filter(Game.rooms, 'controller.my')) {
-            let name = myroom.name
+    spawnworker: function(name){
+        if(name!=null && name!= undefined){
+            for(let myroom of _.filter(Game.rooms, 'controller.my')) {
+                let name = myroom.name
+                require('proc.spawning').spawnworker(name)
+            }
+        } else {
             require('proc.spawning').spawnworker(name)
         }
          return 'Spawning initiated'
     },
-    spawnminer: function(){
-        for(let myroom of _.filter(Game.rooms, 'controller.my')) {
-            let name = myroom.name
+    spawnminer: function(name){
+        if(name!=null && name!= undefined){
+            for(let myroom of _.filter(Game.rooms, 'controller.my')) {
+                let name = myroom.name
+                require('proc.spawning').spawnsourceminer(name)
+            }
+        } else {
             require('proc.spawning').spawnsourceminer(name)
         }
          return 'Spawning initiated'
     },
-    spawnmover: function(){
-        for(let myroom of _.filter(Game.rooms, 'controller.my')) {
-            let name = myroom.name
+    spawnmover: function(name){
+        if(name!=null && name!= undefined){
+            for(let myroom of _.filter(Game.rooms, 'controller.my')) {
+                let name = myroom.name
+                require('proc.spawning').spawnmover(name)
+            }
+        } else {
             require('proc.spawning').spawnmover(name)
         }
          return 'Spawning initiated'
     },
-    spawnclaimer: function(){
-        for(let myroom of _.filter(Game.rooms, 'controller.my')) {
-            let name = myroom.name
+    spawnclaimer: function(name){
+        if(name!=null && name!= undefined){
+            for(let myroom of _.filter(Game.rooms, 'controller.my')) {
+                let name = myroom.name
+                require('proc.spawning').spawnclaimer(name)
+            }
+        } else {
             require('proc.spawning').spawnclaimer(name)
         }
          return 'Spawning initiated'
     },
-    removeConstruction: function(roomname){
-        _.invoke(Game.rooms[roomname].find(FIND_MY_CONSTRUCTION_SITES), 'remove')
+    removeConstruction: function(name){
+        if(name==null || name== undefined){
+            for(let myroom of _.filter(Game.rooms, 'controller.my')) {
+                let name = myroom.name
+                _.invoke(Game.rooms[name].find(FIND_MY_CONSTRUCTION_SITES), 'remove')
+            }
+        } else {
+            _.invoke(Game.rooms[name].find(FIND_MY_CONSTRUCTION_SITES), 'remove')
+        }
     },
     removeAllConstruction: function(){
         _.invoke(_.map(Game.constructionSites, (x)=>x), 'remove')
     },
-    removeWalls: function(roomname){
-        Game.rooms[roomname].find(FIND_STRUCTURES, {filter: s => s.structureType === STRUCTURE_WALL}).forEach(s => s.destroy())
+    removeWalls: function(name){
+        if(name==null || name== undefined){
+            for(let myroom of _.filter(Game.rooms, 'controller.my')) {
+                let name = myroom.name
+                Game.rooms[name].find(FIND_STRUCTURES, {filter: s => s.structureType === STRUCTURE_WALL}).forEach(s => s.destroy())
+            }
+        } else {
+            Game.rooms[name].find(FIND_STRUCTURES, {filter: s => s.structureType === STRUCTURE_WALL}).forEach(s => s.destroy())
+        }
     },
-    removeRoads: function(roomname,hitsleft){
-        Game.rooms[roomname].find(FIND_STRUCTURES, {filter: s => (s.structureType === STRUCTURE_ROAD && s.hits < hitsleft)}).forEach(s => s.destroy())
+    removeRoads: function(name,hitsleft){
+        Game.rooms[name].find(FIND_STRUCTURES, {filter: s => (s.structureType === STRUCTURE_ROAD && s.hits < hitsleft)}).forEach(s => s.destroy())
         return "done"
     },
-    sellEnergy: function(roomname){
+    sellEnergy: function(name){
         let myorders = Game.market.getAllOrders(order=>order.resourceType == RESOURCE_ENERGY && order.type == ORDER_SELL)
     },
     computeSourceAccess: function(){
+        
         for(let myroom of _.filter(Game.rooms, 'controller.my')) {
             let name = myroom.name
             let minablepositions = 0
@@ -129,5 +164,37 @@ module.exports = {
             }
         }
         return accessPoints;
+    },
+    computeSpawnLevels: function(room){
+        myroom=Game.rooms[room]
+        creepcounts=myroom.memory.creepcounts
+        let workerrolename = 'phase' + myroom.memory.phase +'worker'
+        if((myroom.memory.minablepositions >= 3 ||myroom.memory.minablepositions==undefined) && (creepcounts["mover"] == 0 || creepcounts["mover"]==undefined) ){
+            if((((creepcounts[workerrolename]< (myroom.memory.minablepositions + 1) || creepcounts[workerrolename]==undefined)  && myroom.energyAvailable >= myroom.energyCapacityAvailable) ) || ((creepcounts[workerrolename]==0 || creepcounts[workerrolename]==undefined ) && myroom.energyAvailable>100)) {
+                console.log('Spawning worker in '  + room)
+            }
+        } else {                    
+            if((((creepcounts['sourceminer']< myroom.find(FIND_SOURCES).length) || creepcounts['sourceminer']==undefined)  ) || ((creepcounts['sourceminer']==0 || creepcounts['sourceminer']==undefined ) && myroom.energyAvailable>100)) {
+                console.log('Spawning sourceminer in '  + room)
+            }
+            if((((creepcounts[workerrolename]< (myroom.memory.minablepositions+1) || creepcounts[workerrolename]==undefined)  && myroom.energyAvailable >= myroom.energyCapacityAvailable) ) || ((creepcounts[workerrolename]==0 || creepcounts[workerrolename]==undefined ) && myroom.energyAvailable>100)) {
+                console.log('Spawning worker in '  + room)
+            }
+        }
+        if((myroom.storage!=undefined || myroom.terminal!=undefined) && (creepcounts["mover"] < 2 || creepcounts["mover"]==undefined)){
+            console.log("Spawning Mover in " + room)
+        }
+        if(((myroom.storage || myroom.terminal) && myroom.StructureExtractor)  && (creepcounts["mineralmover"] < 1 || creepcounts["mineralmover"]==undefined)){
+            console.log("Spawning MineralMover in " + room)
+        }
+        if((myroom.find(FIND_MY_STRUCTURES, {filter: {structureType: STRUCTURE_EXTRACTOR}}).length > 0)&&(creepcounts["miner"] < myroom.memory.mineralminablepositions || creepcounts["miner"]==undefined)&&(myroom.energyAvailable >= myroom.energyCapacityAvailable)){
+            if(myroom.find(FIND_MINERALS)[0].ticksToRegeneration == undefined || myroom.find(FIND_MINERALS)[0].ticksToRegeneration < 1000 ){
+                console.log("Spawning Miner in "  + room)
+            } else { 
+                if(Game.flags.debug && Game.flags.debug.room == myroom){
+                    console.log("Not spawning miner in " + room + ", waiting for regen")
+                }
+            }
+        }
     }
 };

Room.Phase0.js

@@ -1,7 +1,9 @@
 let Phase0 = {
      run: function(room) {
          require('assignsources').tick(room)
-         creepcounts = _.countBy(Game.rooms[room].find(FIND_MY_CREEPS), c => c.memory.role) 
+         let creepcounts = _.countBy(Game.rooms[room].find(FIND_MY_CREEPS), c => c.memory.role) 
+         if(creepcounts===undefined){creepcounts['phase' + Game.rooms[room].memory.phase +'worker']=0}
+         Game.rooms[room].memory.creepcounts=creepcounts
          let myspawns = Game.rooms[room].find(FIND_MY_SPAWNS)
          let sources = Game.rooms[room].find(FIND_SOURCES )
          if(myspawns.length<1){
@@ -12,7 +14,7 @@ let Phase0 = {
              let newworkerrolename = 'phase' + Game.rooms[room].memory.phase + 'worker'
              for(let mycreep in creeps){
                  creep=creeps[mycreep]
-                 if(creep.memory.role == workerrolename){
+                 if(creep.memory.role != newworkerrolename){
                      creep.memory.role=newworkerrolename
                  }
              }
@@ -24,13 +26,13 @@ let Phase0 = {
          } else {
              let workerrolename = 'phase' + Game.rooms[room].memory.phase +'worker'
              console.log(room)
-             console.log(workerrolename + " : " + creepcounts[workerrolename])
-          if(((creepcounts[workerrolename]< (sources.length * 1) || creepcounts[workerrolename]==undefined) && !myspawns[0].spawning && Game.rooms[room].energyAvailable == Game.rooms[room].energyCapacityAvailable) || (creepcounts[workerrolename] ==0 && Game.rooms[room].energyAvailable==300) ){
+             console.log("room.phase0.js "+workerrolename + " : " + creepcounts[workerrolename])
+          if(( creepcounts[workerrolename] == undefined  ||(creepcounts[workerrolename]< (sources.length * 1) || creepcounts[workerrolename]==undefined) && !myspawns[0].spawning && Game.rooms[room].energyAvailable == Game.rooms[room].energyCapacityAvailable) || (creepcounts[workerrolename] ==0 && Game.rooms[room].energyAvailable==300)  ){
                 if(Game.rooms[room].energyAvailable == Game.rooms[room].energyCapacityAvailable){
                    require('proc.spawning').spawnworker(room)
                  }
              } else {  }
-            if(Game.rooms[room].controller.level>1){
+            if(Game.rooms[room].controller.level>1 && Game.rooms[room].spawn){
             
              Game.rooms[room].memory.phase++
              let creeps=Game.rooms[room].find(FIND_MY_CREEPS)

Room.Phase1.js

@@ -5,11 +5,26 @@ let Phase1 = {
          creepcounts = _.countBy(myroom.find(FIND_MY_CREEPS), c => c.memory.role)
          myroom.memory.creepcounts=creepcounts
          myroom.memory.movercount=creepcounts["mover"]
+         let links=myroom.find(FIND_STRUCTURES, {filter: (s) =>{return ( s.structureType==STRUCTURE_LINK)}})
+         let constructionSites=myroom.find(FIND_CONSTRUCTION_SITES)
+        if(constructionSites.length > 0){
+            if(myroom.memory.currentconstruction!=undefined && myroom.memory.currentconstruction!=null){
+                if(Game.getObjectById(myroom.memory.currentconstruction.id)){
+
+                } else {
+                    myroom.memory.currentconstruction=constructionSites[0]
+                }
+            } else {
+                myroom.memory.currentconstruction=constructionSites[0]
+            }
+        } else {
+            console.log(myroom.name+" No constructions")
+            delete myroom.memory.currentconstruction
+        }
          if(Game.time % 10 === 0){
             //console.log('processing spawn')
 
             let myspawns = myroom.find(FIND_MY_SPAWNS)
-            
             if(myspawns.length>0){
                 let myspawn = myspawns[0]
                 let creepcount = myroom.find(FIND_MY_CREEPS).length
@@ -44,7 +59,7 @@ let Phase1 = {
                         require('proc.spawning').spawnworker(room)
                     }
                 }
-                if((myroom.storage || myroom.terminal) && (creepcounts["mover"] < 2 || creepcounts["mover"]==undefined)){
+                if((myroom.storage!=undefined || myroom.terminal!=undefined) && (creepcounts["mover"] < 2 || creepcounts["mover"]==undefined)){
                     console.log("Spawning Mover in " + room)
                     require('proc.spawning').spawnmover(room)
                 }
@@ -61,6 +76,7 @@ let Phase1 = {
             }
         }
         if(Game.time % 4 === 0){
+            /*
             if(myroom.find(FIND_MY_STRUCTURES, {filter: {structureType: STRUCTURE_TERMINAL}}).length > 0){
                 //console.log("starting market check for room " + room)
                 try{
@@ -105,8 +121,45 @@ let Phase1 = {
                     console.log("Myroom" + myroom)
                     console.log(e)
                 }
+            }*/
+        }
+        /*
+        if(links!=null && links!=undefined){
+            if(links.length>1){
+                console.log('1')
+                let sourcelink=links[0]
+                let destlinks
+                try{
+                    for(let idx in links.length){
+                        link = links[idx]
+                        console.log('2')
+                        console.log(link.id)
+                        console.log(sourcelink.id)
+                        link.store.getUsedCapacity('energy')
+                        sourcelink.store.getUsedCapacity('energy')
+                        if(link.store.getUsedCapacity('energy') > sourcelink.store.getUsedCapacity('energy')){
+                            console.log("2.1")
+                            destlinks += sourcelink
+                            sourcelink=link
+                        } else if (link.store.getUsedCapacity('energy') == sourcelink.store.getUsedCapacity('energy')){
+                            console.log('2.2')
+                        }
+                        idx++
+                    }
+                    for(let destlink in destlinks){
+                        if(destlink != undefined && destlink != null){
+                            if(destlink.store.getUsedCapacity() < destlink.store.getCapacity()){
+                                console.log('3')
+                                sourcelink.transferEnergy(destlink)
+                            }
+                        }
+                    }
+                } catch(e){
+                    console.log(e)
+                }
             }
         }
+        */
         if(myroom.controller.level>2){         }
      }
 };

assignsources.js

@@ -1,6 +1,6 @@
 let assignMiners = {
      tick: function(roomname) {
-        let sources = Game.rooms[roomname].find(FIND_SOURCES );
+        let sources = Game.rooms[roomname].find(FIND_SOURCES);
         for(let source of sources){
                 let allminers = Game.rooms[roomname].find(FIND_MY_CREEPS, {filter: (creep) =>{return ( creep.memory.role=='sourceminer'|| creep.memory.role == ("phase" + Game.rooms[roomname].memory.phase + "worker") )}});
                 //let allstorage = Game.rooms[name].find(FIND_STRUCTURES, {filter: (s) => {return ( s.structureType == STRUCTURE_CONTAINER || s.structureType == STRUCTURE_STORAGE)}})

main.js

@@ -22,7 +22,11 @@ module.exports.loop = function () {
          }
          if(myroom.controller!==undefined){
             myroom.memory.tickssofar++
+            try{
             require('Room.Phase' + myroom.memory.phase).run(name)
+            } catch(e){
+                console.log(myroom.name + ": " + e)
+            }
          }
          
          for(let pos in myroom.memory.maphits){

proc.creepfunctions.js

@@ -0,0 +1,5 @@
+module.exports = {
+    spawnwarrior: function(){
+        
+    }
+}

proc.spawning.js

@@ -31,11 +31,7 @@ let buildparts = {
                         if(!spawn.spawning){
                         let tobuild=[]
                         for(let totry of [
-                            [WORK,WORK,WORK,WORK,WORK,MOVE],
-                            [WORK,WORK,WORK,WORK,MOVE],
-                            [WORK,WORK,WORK,MOVE],
-                            [WORK,WORK,MOVE],
-                            [WORK,MOVE]
+                            [WORK,WORK,WORK,WORK,WORK,MOVE]
                             ]){
                             let ispossible = spawn.canCreateCreep(totry)
                             if(ispossible==OK){
@@ -94,7 +90,11 @@ let buildparts = {
                                 break;
                             }
                         }
-                        let newcreep = spawn.createCreep(tobuild,CreepName,{spawnedat: Game.time,role:"phase" + Game.rooms[roomname].memory.phase +"worker"})
+                        if(tobuild != null && tobuild != undefined){
+                            let newcreep = spawn.createCreep(tobuild,CreepName,{spawnedat: Game.time,role:"phase" + Game.rooms[roomname].memory.phase +"worker"})
+                        } else {
+                            console.log("not enough e in " + roomname + " to spawn")
+                        }
                     }}
 
     },

role.mover.js

@@ -8,6 +8,9 @@ let mover={
         if(creep.memory.working==undefined){
             creep.memory.working=false
         }
+        if(creep.memory.assignedroom==undefined){
+            creep.memory.assignedroom=creep.room.name
+        }
         let lastpos = _.create(RoomPosition.prototype, creep.memory.lastpos)
         if(creep.pos.isEqualTo(lastpos)){
             creep.memory.timeatpos = creep.memory.timeatpos+1
@@ -25,140 +28,108 @@ let mover={
 	        creep.memory.working = true;
 	        creep.say('working');
 	    }
-        if(creep.memory.working){
-            //let terminaltarget = creep.room.terminal
-            let spawntarget = creep.pos.findClosestByPath(FIND_STRUCTURES, {filter: (s) => {return ((([STRUCTURE_SPAWN, STRUCTURE_EXTENSION, STRUCTURE_TOWER, STRUCTURE_LAB].includes(s.structureType)) && s.energy < s.energyCapacity ))}})
-            if(spawntarget){
-                creep.say('ref sp')
-                if(creep.transfer(spawntarget, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
-                    creep.moveTo(spawntarget,{ignoreCreeps:ignorecreeps})
-                }
-            } else {
-                try{
-                    creep.say('finding storage')
-                    let mystorage = creep.pos.findClosestByRange(FIND_STRUCTURES, {filter: (s) => {return ((s.structureType == STRUCTURE_STORAGE) &&  s.store.getFreeCapacity()>0 )   ;}});
-                    creep.say('got storage')
-                    if(creep.transfer(mystorage, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
-                        creep.say('MvStor')
-                        creep.moveTo(mystorage,{ignoreCreeps:ignorecreeps})
-                    } else {
-                        creep.say("Dumped")
-                    }
-                } catch(e){
-                    console.log(e)
-                }
-            }
-            /*else if(terminaltarget != creep.memory.pulledenergyfrom){
-                 if(creep.transfer(terminaltarget,RESOURCE_ENERGY)== ERR_NOT_IN_RANGE ) {
-                    creep.say('Putting Energy')
-                    creep.travelTo(terminaltarget);
-                 }
-            }*/
-        } else if ((creep.ticksToLive < 300 || creep.ticksToLive <= creep.memory.renewto) && (Game.rooms[creep.room.name].find(FIND_MY_SPAWNS, {filter: (r) =>{return ( r.store[RESOURCE_ENERGY]>200)}}))  ) {
-            if(creep.memory.renewto == undefined){
-                creep.memory.renewto = 1200
-            } else {
-                if(creep.ticksToLive >= creep.memory.renewto){
-                    delete creep.memory.renewto
-                }
-            }
-            //console.log(creep.name + ": " + creep.ticksToLive + " " + creep.memory.renewto)
-            creep.say('renewing')
-            let spawn = creep.pos.findClosestByRange(FIND_MY_SPAWNS)
-            if(spawn.renewCreep(creep) == ERR_NOT_IN_RANGE)
-            {
-                creep.moveTo(spawn);
-            }
+        if(creep.room.name != creep.memory.assignedroom){
+            creep.moveTo(Game.rooms[creep.memory.assignedroom].controller)
+            //Game.notify(creep.name + " Not in assigned room")
         } else {
-            if(filllevel < creep.carryCapacity){
-                /*
-                let nearestcontainer = creep.pos.findClosestByRange(FIND_STRUCTURES, {filter: (s) => {return ((s.structureType == STRUCTURE_CONTAINER ) &&  s.store.getUsedCapacity('energy') >= 10)  ;}});
-                if(creep.room.terminal){
-                    let terminal = creep.room.terminal
-                    let terminalenergy= terminal.store.getUsedCapacity('energy')
-                }
-                if(creep.room.storage){
-                    let storage = creep.room.storage
-                    let storageenergy=storage.store.getUsedCapacity('energy')
-                }
-                //console.log("Storage: " + storage.store.getUsedCapacity('energy'))
-                //console.log("Container: " + nearestcontainer.store.getUsedCapacity('energy')
-                try{
-                    if(nearestcontainer == null){
-                        
-                    }else {
-                        storagetarget = nearestcontainer
+            if(creep.memory.working){
+                //let terminaltarget = creep.room.terminal
+                let spawntarget = creep.pos.findClosestByPath(FIND_STRUCTURES, {filter: (s) => {return ((([STRUCTURE_SPAWN, STRUCTURE_EXTENSION, STRUCTURE_TOWER, STRUCTURE_LAB].includes(s.structureType)) && s.energy < s.energyCapacity ))}})
+                if(spawntarget){
+                    creep.say('ref sp')
+                    if(creep.transfer(spawntarget, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
+                        creep.moveTo(spawntarget,{ignoreCreeps:ignorecreeps})
                     }
-                }catch{
-                    if(storageenergy > 0){
-                        storagetarget = storage
-                    } else if ( terminalenergy > 0) { 
-                        storagetarget = terminal
-                    } else {
-                        console.log("we're out of energy!")
-                        storagetarget=storage
+                } else {
+                    try{
+                        creep.say('finding storage')
+                        let mystorage = creep.pos.findClosestByRange(FIND_STRUCTURES, {filter: (s) => {return ((s.structureType == STRUCTURE_STORAGE || s.structureType == STRUCTURE_CONTAINER) &&  s.store.getFreeCapacity()>0 )   ;}});
+                        creep.say('got storage')
+                        if(creep.transfer(mystorage, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
+                            creep.say('MvStor')
+                            creep.moveTo(mystorage,{ignoreCreeps:ignorecreeps})
+                        } else {
+                            creep.say("Dumped")
+                        }
+                    } catch(e){
+                        console.log(e)
+                    }
+                }
+                /*else if(terminaltarget != creep.memory.pulledenergyfrom){
+                    if(creep.transfer(terminaltarget,RESOURCE_ENERGY)== ERR_NOT_IN_RANGE ) {
+                        creep.say('Putting Energy')
+                        creep.travelTo(terminaltarget);
                     }
                 }*/
-                
-                let storagetarget = creep.pos.findClosestByRange(FIND_STRUCTURES, {filter: (s) => {return ((s.structureType == STRUCTURE_CONTAINER) &&  s.store.getUsedCapacity('energy') >= 1000)   ;}});
-                if(storagetarget===undefined||storagetarget==null){
-                    creep.say('finding storage')
-                    storagetarget=creep.pos.findClosestByRange(FIND_STRUCTURES, {filter: (s) => {return ((s.structureType == STRUCTURE_STORAGE) &&  s.store.getUsedCapacity('energy') >= 10)   ;}});
-                    if((storagetarget==undefined ||storagetarget==null) && creep.room.terminal){
-                        storagetarget=creep.room.terminal
+            } else if ((creep.ticksToLive < 300 || creep.ticksToLive <= creep.memory.renewto) && (Game.rooms[creep.room.name].find(FIND_MY_SPAWNS, {filter: (r) =>{return ( r.store[RESOURCE_ENERGY]>200)}}))  ) {
+                if(creep.memory.renewto == undefined){
+                    creep.memory.renewto = 1200
+                } else {
+                    if(creep.ticksToLive >= creep.memory.renewto){
+                        delete creep.memory.renewto
                     }
                 }
-                let droppedenergy = creep.pos.findClosestByRange(FIND_DROPPED_RESOURCES, {filter: (r) =>{return ( r.resourceType==RESOURCE_ENERGY&& r.amount>10)}});
-                let tombstone =  creep.pos.findClosestByRange(FIND_TOMBSTONES, {filter: (r) =>{return ( r.store[RESOURCE_ENERGY]>200)}});
-                let ruins=creep.pos.findClosestByRange(FIND_RUINS, {filter: ruin => ruin.store.getUsedCapacity(RESOURCE_ENERGY) > 0});
-                if((droppedenergy == undefined) && (tombstone==undefined) && (ruins==undefined)){
-                    /*try{
-                //        console.log(storagetarget.store.getUsedCapacity('energy')/storagetarget.store.getCapacity())
-                        if(storagetarget.store.getUsedCapacity('energy')< 1000 && (storagetarget.store.getUsedCapacity('energy')/storagetarget.store.getCapacity() < .5 )){
-                                //console.log("too much crap")
-                                //console.log(storagetarget.store.getUsedCapacity())
-                                //creep.travelTo(storagetarget);
-                        }
-                    } catch(e) {
-                        console.log("oops" + e)
-                    }*/
-//                    creep.say('2')
-                    //creep.say(storagetarget)
-                    if(creep.withdraw(storagetarget,RESOURCE_ENERGY)== ERR_NOT_IN_RANGE) {
-                        creep.say('Getting Energy')
-                        creep.travelTo(storagetarget);
-                    }
-                    //creep.memory.pulledenergyfrom=storagetarget
-                } else {
-                    if(ruins){
-                        if(creep.withdraw(ruins,RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
-                            if(global.verbosity>0){
-                                creep.say("MTRU");
+                //console.log(creep.name + ": " + creep.ticksToLive + " " + creep.memory.renewto)
+                creep.say('renewing')
+                let spawn = creep.pos.findClosestByRange(FIND_MY_SPAWNS)
+                if(creep.store.getUsedCapacity('energy') > 0){
+                    creep.transfer(spawn,RESOURCE_ENERGY)
+                }
+                if(spawn.renewCreep(creep) == ERR_NOT_IN_RANGE)
+                {
+                    creep.moveTo(spawn);
+                }
+            } else {
+                if(filllevel < creep.carryCapacity){
+                    let storagetarget = creep.pos.findClosestByRange(FIND_STRUCTURES, {filter: (s) => {return ((s.structureType == STRUCTURE_CONTAINER) &&  s.store.getUsedCapacity('energy') >= 200)   ;}});
+                    let droppedenergy = creep.pos.findClosestByRange(FIND_DROPPED_RESOURCES, {filter: (r) =>{return ( r.resourceType==RESOURCE_ENERGY&& r.amount>10)}});
+                    let tombstone =  creep.pos.findClosestByRange(FIND_TOMBSTONES, {filter: (r) =>{return ( r.store[RESOURCE_ENERGY]>200)}});
+                    let ruins=creep.pos.findClosestByRange(FIND_RUINS, {filter: ruin => ruin.store.getUsedCapacity(RESOURCE_ENERGY) > 0});
+                    console.log(creep.room.name + " " + creep.name + " " + creep.room.energyAvailable+":"+ creep.room.energyCapacityAvailable )
+                    if(creep.room.energyAvailable < creep.room.energyCapacityAvailable  || ((droppedenergy == undefined) && (tombstone==undefined) && (ruins==undefined))){
+                        
+                        if(storagetarget===undefined||storagetarget==null){
+                            creep.say('finding storage')
+                            storagetarget=creep.pos.findClosestByRange(FIND_STRUCTURES, {filter: (s) => {return ((s.structureType == STRUCTURE_STORAGE) &&  s.store.getUsedCapacity('energy') >= 10)   ;}});
+                            if((storagetarget==undefined ||storagetarget==null) && creep.room.terminal){
+                                storagetarget=creep.room.terminal
                             }
-                            creep.moveTo(ruins,{ignoreCreeps:ignorecreeps})           
                         }
-                    }else if(droppedenergy){
-                        if(creep.pickup(droppedenergy) == ERR_NOT_IN_RANGE) {
-                            if(global.verbosity>0){
-                                creep.say("MTDE");
-                            }
-                            creep.moveTo(droppedenergy,{ignoreCreeps:ignorecreeps})           
+                        if(creep.withdraw(storagetarget,RESOURCE_ENERGY)== ERR_NOT_IN_RANGE) {
+                            creep.say('GEST')
+                            creep.travelTo(storagetarget);
                         }
                     } else {
-                        if(creep.withdraw(tombstone,RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
-                            if(global.verbosity>0){
-                                creep.say("MTTS");
+                        if(ruins){
+                            if(creep.withdraw(ruins,RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
+                                if(global.verbosity>0){
+                                    creep.say("MTRU");
+                                }
+                                creep.moveTo(ruins,{ignoreCreeps:ignorecreeps})           
+                            }
+                        }else if(droppedenergy){
+                            if(creep.pickup(droppedenergy) == ERR_NOT_IN_RANGE) {
+                                if(global.verbosity>0){
+                                    creep.say("MTDE");
+                                }
+                                creep.moveTo(droppedenergy,{ignoreCreeps:ignorecreeps})           
+                            }
+                        } else {
+                            if(creep.withdraw(tombstone,RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
+                                if(global.verbosity>0){
+                                    creep.say("MTTS");
+                                }
+                                creep.moveTo(tombstone.pos,{ignoreCreeps:ignorecreeps})           
                             }
-                            creep.moveTo(tombstone.pos,{ignoreCreeps:ignorecreeps})           
                         }
                     }
-                }
-                if(!storagetarget && (creep.carry > 0)){
-                    creep.memory.working=true
+                    if(!storagetarget && (creep.carry > 0)){
+                        creep.memory.working=true
+                    }
                 }
             }
+            creep.memory.lastpos=creep.pos
         }
-        creep.memory.lastpos=creep.pos
     }
 }
 module.exports = mover;

role.phase0worker.js

@@ -1,6 +1,23 @@
 //'use strict';
 let Phase0Worker = {
      run: function(creep) {
+        let ignorecreeps=true
+        if(creep.memory.lastpos==undefined || creep.memory.timeatpos==undefined){
+            creep.memory.lastpos = creep.pos
+            creep.memory.timeatpos = 0
+        }
+        if(creep.memory.assignedroom==undefined){
+            creep.memory.assignedroom=creep.room.name
+        }
+        let lastpos = _.create(RoomPosition.prototype, creep.memory.lastpos)
+        if(creep.pos.isEqualTo(lastpos)){
+            
+            creep.memory.timeatpos = creep.memory.timeatpos+1
+            if(creep.memory.timeatpos>2){
+                //console.log(creep.name + " " + creep.memory.timeatpos)
+                ignorecreeps=false
+            } else { }
+        } else { creep.memory.timeatpos=0}
         let filllevel = _.sum(creep.carry)
         //creep.say(creep.room.memory.maphits[creep.pos.x + '-' + creep.pos.y].hits)
         if(creep.memory.working && filllevel == 0) {
@@ -30,20 +47,29 @@ let Phase0Worker = {
             }
         } else {
             let droppedenergy = creep.pos.findClosestByRange(FIND_DROPPED_RESOURCES, {filter: {resourceType: RESOURCE_ENERGY}});
-            if(droppedenergy == undefined){
-                if(Game.getObjectById(creep.memory.destsource.id)==undefined){creep.memory.destsource=undefined}
+            let ruins=creep.pos.findClosestByRange(FIND_RUINS, {filter: ruin => ruin.store.getUsedCapacity(RESOURCE_ENERGY) > 0});
+            if(droppedenergy == undefined && ruins==undefined){
+                if((Game.getObjectById(creep.memory.destsource.id)==undefined)){creep.memory.destsource=undefined}
                 let mysource=Game.getObjectById(creep.memory.destsource.id)
                 //mysource=creep.pos.findClosestByRange( FIND_SOURCES )
                 if(creep.harvest(mysource) == ERR_NOT_IN_RANGE){
                     creep.travelTo(mysource);
                 }
             } else {
+                if(droppedenergy){
                 if(creep.pickup(droppedenergy) == ERR_NOT_IN_RANGE) {
                     if(global.verbosity>0){
                         creep.say("MTDE");
                     }
                     creep.travelTo(droppedenergy);
-                }   
+                }   } else {
+                    if(creep.withdraw(ruins,RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
+                        if(global.verbosity>0){
+                            creep.say("MTRU");
+                        }
+                        creep.moveTo(ruins,{ignoreCreeps:ignorecreeps})           
+                    }
+                }
             }
         }
      }

role.phase1worker.js

@@ -21,139 +21,171 @@ let Phase1Worker = {
         
         let road = creep.pos.lookFor(LOOK_STRUCTURES);
         let filllevel = _.sum(creep.carry)
-        if(creep.memory.working && filllevel == 0) {
-            creep.memory.working = false;
-            creep.say('Gathering');
-	    }
-	    if(!creep.memory.working && creep.carry.energy == creep.carryCapacity) {
-	        creep.memory.working = true;
-	        creep.say('working');
-        }
-        
-        
-        if(creep.memory.working){
-            let look=creep.pos.lookFor(LOOK_STRUCTURES)
-            let storagetargets = creep.pos.findClosestByRange(FIND_STRUCTURES, {filter: (s) => {return ((s.structureType == STRUCTURE_STORAGE || s.structureType == STRUCTURE_CONTAINER || s.structureType == STRUCTURE_TERMINAL ) &&  _.sum(s.store) < s.store.getCapacity())  ;}});
-             if(creep.room.memory.NeedsRecharge==1){
-                 if(creep.upgradeController(creep.room.controller) == ERR_NOT_IN_RANGE) {
-	                   creep.say(creep.room.controller.ticksToDowngrade + " of " +  CONTROLLER_DOWNGRADE[creep.room.controller.level] * .2)
-                       creep.moveTo(creep.room.controller)
-                }
-             } else if((creep.pos.findClosestByPath(FIND_STRUCTURES, {filter: (s) => {return ((([STRUCTURE_SPAWN, STRUCTURE_EXTENSION, STRUCTURE_TOWER].includes(s.structureType)) && s.energy < s.energyCapacity))}}))&& (creep.room.memory.movercount<1||creep.room.memory.movercount==undefined)){
-                let spawntarget = creep.pos.findClosestByPath(FIND_STRUCTURES, {filter: (s) => {return (((s.structureType == STRUCTURE_EXTENSION || s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_TOWER) && s.energy < s.energyCapacity))}});
-                if(creep.transfer(spawntarget, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
-                    creep.moveTo(spawntarget,{ignoreCreeps:ignorecreeps})
-                }
-            } else if(creep.pos.findClosestByPath(FIND_STRUCTURES, {filter: (s) => {return ((([STRUCTURE_RAMPART].includes(s.structureType)) && s.hits < 20000))}})){
-                let ramparttarget = creep.pos.findClosestByPath(FIND_STRUCTURES, {filter: (s) => {return (((s.structureType == STRUCTURE_RAMPART) && s.hits < s.hitsMax))}});
-                if(creep.repair(ramparttarget) == ERR_NOT_IN_RANGE) {
-                    creep.moveTo(ramparttarget,{ignoreCreeps:ignorecreeps})
-                }
-            } else if(creep.pos.findClosestByRange(FIND_CONSTRUCTION_SITES)){
-                target = creep.pos.findClosestByRange(FIND_CONSTRUCTION_SITES)
-                if(creep.build(target) == ERR_NOT_IN_RANGE) {
-                    if (road.length > 0) {creep.repair(road);}
-                    creep.moveTo(target,{ignoreCreeps:ignorecreeps})
-                }
-            } else if(storagetargets && creep.room.controller.level*125000> creep.room.storage.store.getUsedCapacity('energy')){
-                 if(creep.transfer(storagetargets, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
-                     if (road.length > 0) {creep.repair(road);}
-                    creep.moveTo(storagetargets,{ignoreCreeps:ignorecreeps})
-                } 
-            }else {
-                if(creep.upgradeController(creep.room.controller) == ERR_NOT_IN_RANGE) {
-	                   creep.say('MTRC')
-                       if (road.length > 0) {creep.repair(road);}
-                       creep.moveTo(Game.rooms[creep.memory.assignedroom].controller,{ignoreCreeps:ignorecreeps})
-                }
+        if(creep.room.name == creep.memory.assignedroom){
+            if(creep.memory.working && filllevel == 0) {
+                creep.memory.working = false;
+                creep.say('Gathering');
             }
-        } else if (creep.pos.findClosestByRange(FIND_MY_SPAWNS) && (creep.ticksToLive < 300 || creep.ticksToLive <= creep.memory.renewto) && (Game.rooms[creep.room.name].find(FIND_MY_SPAWNS, {filter: (r) =>{return ( r.store[RESOURCE_ENERGY]>200)}}))  ) {
-            if(creep.memory.renewto == undefined){
-                creep.memory.renewto = 1200
-            } else {
-                if(creep.ticksToLive >= creep.memory.renewto){
-                    delete creep.memory.renewto
-                }
+            if(!creep.memory.working && creep.carry.energy == creep.carryCapacity) {
+                creep.memory.working = true;
+                creep.say('working');
             }
-            creep.say('renewing')
-            console.log(creep.name + ": " + creep.ticksToLive + " " + creep.memory.renewto)
-            let spawn = creep.pos.findClosestByRange(FIND_MY_SPAWNS)
-            if(spawn != undefined && spawn!= null){
-                if(creep.room.memory.NeedsRecharge==1 && creep.carry.energy>0){
+            if(creep.memory.working){
+                let look=creep.pos.lookFor(LOOK_STRUCTURES)
+                let storagetargets = creep.pos.findClosestByRange(FIND_STRUCTURES, {filter: (s) => {return ((s.structureType == STRUCTURE_STORAGE || s.structureType == STRUCTURE_TERMINAL ) &&  _.sum(s.store) < s.store.getCapacity())  ;}});
+                if(creep.room.memory.NeedsRecharge==1){
                     if(creep.upgradeController(creep.room.controller) == ERR_NOT_IN_RANGE) {
-                            creep.say(creep.room.controller.ticksToDowngrade + " of " +  (CONTROLLER_DOWNGRADE[creep.room.controller.level] * .2))
-                            creep.moveTo(creep.room.controller)
+                        creep.say(creep.room.controller.ticksToDowngrade + " of " +  CONTROLLER_DOWNGRADE[creep.room.controller.level] * .2)
+                        creep.moveTo(creep.room.controller)
+                    }
+                } else if((creep.pos.findClosestByPath(FIND_STRUCTURES, {filter: (s) => {return ((([STRUCTURE_SPAWN, STRUCTURE_EXTENSION, STRUCTURE_TOWER,STRUCTURE_LINK].includes(s.structureType)) && s.energy < s.energyCapacity))}}))&& (creep.room.memory.movercount<1||creep.room.memory.movercount==undefined)){
+                    let spawntarget = creep.pos.findClosestByPath(FIND_STRUCTURES, {filter: (s) => {return (((s.structureType == STRUCTURE_EXTENSION || s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_TOWER) && s.energy < s.energyCapacity))}});
+                    if(creep.transfer(spawntarget, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
+                        creep.moveTo(spawntarget,{ignoreCreeps:ignorecreeps})
+                    }
+                } else if(creep.pos.findClosestByPath(FIND_STRUCTURES, {filter: (s) => {return ((([STRUCTURE_RAMPART].includes(s.structureType)) && s.hits < 20000))}})){
+                    let ramparttarget = creep.pos.findClosestByPath(FIND_STRUCTURES, {filter: (s) => {return (((s.structureType == STRUCTURE_RAMPART) && s.hits < s.hitsMax))}});
+                    if(creep.repair(ramparttarget) == ERR_NOT_IN_RANGE) {
+                        creep.moveTo(ramparttarget,{ignoreCreeps:ignorecreeps})
+                    }
+                } else if(creep.room.memory.currentconstruction){
+                    target = Game.getObjectById(creep.room.memory.currentconstruction.id)
+                    creep.moveTo(target,{ignoreCreeps:ignorecreeps})
+                    if(creep.build(target) == ERR_NOT_IN_RANGE) {
+                        if (road.length > 0) {creep.repair(road);}
+                        creep.moveTo(target,{ignoreCreeps:ignorecreeps})
+                    }
+                } else if(storagetargets && creep.room.storage&& creep.room.controller.level*125000> creep.room.storage.store.getUsedCapacity('energy')){
+                    if(creep.transfer(storagetargets, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
+                        if (road.length > 0) {creep.repair(road);}
+                        creep.moveTo(storagetargets,{ignoreCreeps:ignorecreeps})
+                    } 
+                }else {
+                    if(creep.upgradeController(creep.room.controller) == ERR_NOT_IN_RANGE) {
+                        creep.say('MTRC')
+                        if (road.length > 0) {creep.repair(road);}
+                        creep.moveTo(Game.rooms[creep.memory.assignedroom].controller,{ignoreCreeps:ignorecreeps})
+                    }
+                }
+            } else if (creep.pos.findClosestByRange(FIND_MY_SPAWNS) && (creep.ticksToLive < 300 || creep.ticksToLive <= creep.memory.renewto) && (Game.rooms[creep.room.name].find(FIND_MY_SPAWNS, {filter: (r) =>{return ( r.store[RESOURCE_ENERGY]>200)}}))  ) {
+                if(creep.memory.renewto == undefined){
+                    creep.memory.renewto = 1200
+                } else {
+                    if(creep.ticksToLive >= creep.memory.renewto){
+                        delete creep.memory.renewto
+                    }
+                }
+                creep.say('renewing')
+                console.log(creep.name + ": " + creep.ticksToLive + " " + creep.memory.renewto)
+                let spawn = creep.pos.findClosestByRange(FIND_MY_SPAWNS)
+                if(spawn != undefined && spawn!= null){
+                    if(creep.room.memory.NeedsRecharge==1 && creep.carry.energy>0){
+                        if(creep.upgradeController(creep.room.controller) == ERR_NOT_IN_RANGE) {
+                                creep.say(creep.room.controller.ticksToDowngrade + " of " +  (CONTROLLER_DOWNGRADE[creep.room.controller.level] * .2))
+                                creep.moveTo(creep.room.controller)
+                        }
+                    } else {
+                        creep.transfer(spawn, RESOURCE_ENERGY)
+                        if(spawn.renewCreep(creep) == ERR_NOT_IN_RANGE){
+                            creep.say('MVSP')
+                            creep.moveTo(spawn);
+                        }   
                     }
                 } else {
-                    
-                    if(spawn.renewCreep(creep) == ERR_NOT_IN_RANGE){
-                        creep.say('MVSP')
-                        creep.moveTo(spawn);
-                    }   
+                    creep.memory.renewto=1
                 }
             } else {
-                creep.memory.renewto=1
-            }
-        } else {
-            let droppedenergy = creep.pos.findClosestByRange(FIND_DROPPED_RESOURCES, {filter: (r) =>{return ( r.resourceType==RESOURCE_ENERGY&& r.amount>200)}});
-            let tombstone =  creep.pos.findClosestByRange(FIND_TOMBSTONES, {filter: (r) =>{return ( r.store[RESOURCE_ENERGY]>200)}});
-            //console.log(tombstone)
-            if((droppedenergy == undefined || droppedenergy==null) && (tombstone==undefined || tombstone==null)){
-                creep.say("1")
-                if(Game.getObjectById(creep.memory.destsource.id)==undefined){creep.memory.destsource=undefined}
-                let mysource=Game.getObjectById(creep.memory.destsource.id)
-                try{
-                    //console.log(creep.room.memory.creepcounts)
-                    if((mysource.energy==0 || ((creep.room.memory.creepcounts.sourceminer!=null ||creep.room.memory.creepcounts.sourceminer!=undefined )))){
-                        creep.say("2.1")
-                        //creep.say("No Energy Left to get")
-                        let storagetarget = creep.pos.findClosestByRange(FIND_STRUCTURES, {filter: (s) => {return ((s.structureType == STRUCTURE_CONTAINER) &&  s.store.getUsedCapacity('energy') >= 100)   ;}});
-                        if(storagetarget===undefined || storagetarget==null){
-                            creep.say('2.2')
-                            storagetarget=creep.pos.findClosestByRange(FIND_STRUCTURES, {filter: (s) => {return ((s.structureType == STRUCTURE_STORAGE) &&  s.store.getUsedCapacity('energy') >= creep.room.controller.level * 125000)   ;}});
-                            if((storagetarget===undefined || storagetarget==null) && creep.room.terminal && creep.room.terminal.store.getUsedCapacity('energy') > 100000){
-                                creep.say('2.3')
-                                storagetarget=creep.room.terminal
+                let droppedenergy = creep.pos.findClosestByRange(FIND_DROPPED_RESOURCES, {filter: (r) =>{return ( r.resourceType==RESOURCE_ENERGY&& r.amount>200)}});
+                let tombstone =  creep.pos.findClosestByRange(FIND_TOMBSTONES, {filter: (r) =>{return ( r.store[RESOURCE_ENERGY]>200)}});
+                let ruins=creep.pos.findClosestByRange(FIND_RUINS, {filter: ruin => ruin.store.getUsedCapacity(RESOURCE_ENERGY) > 0});
+                let spawn= creep.pos.findClosestByPath(FIND_STRUCTURES, {filter: (s) => {return ( s.structureType == STRUCTURE_SPAWN)}});
+                //console.log(tombstone)
+                if((droppedenergy == undefined || droppedenergy==null) && (tombstone==undefined || tombstone==null) && (spawn!=undefined || spawn!=null) && (ruins==undefined  || ruins==null)){
+                    creep.say("1")
+                    if(Game.getObjectById(creep.memory.destsource.id)==undefined){creep.memory.destsource=undefined}
+                    let mysource=Game.getObjectById(creep.memory.destsource.id)
+                    try{
+                        //console.log(creep.room.memory.creepcounts)
+                        if((mysource.energy==0 || ((creep.room.memory.creepcounts.sourceminer!=null ||creep.room.memory.creepcounts.sourceminer!=undefined )))){
+                            creep.say("2.1")
+                            //creep.say("No Energy Left to get")
+                            let storagetarget = creep.pos.findClosestByRange(FIND_STRUCTURES, {filter: (s) => {return ((s.structureType == STRUCTURE_CONTAINER || s.structureType == STRUCTURE_LINK) &&  s.store.getUsedCapacity('energy') >= 100)   ;}});
+                            if(storagetarget===undefined || storagetarget==null){
+                                creep.say('2.2')
+                                storagetarget=creep.pos.findClosestByRange(FIND_STRUCTURES, {filter: (s) => {return ((s.structureType == STRUCTURE_STORAGE) &&  s.store.getUsedCapacity('energy') >= creep.room.controller.level * 125000)   ;}});
+                                if((storagetarget===undefined || storagetarget==null) && creep.room.terminal && creep.room.terminal.store.getUsedCapacity('energy') > 100000){
+                                    creep.say('2.3')
+                                    storagetarget=creep.room.terminal
+                                }
                             }
-                        }
-                        //console.log(Game.getObjectById(storagetarget.id))
-                        if((storagetarget != undefined || storagetarget != null) && creep.withdraw(storagetarget,RESOURCE_ENERGY)== ERR_NOT_IN_RANGE) {
-                            creep.say('3')
-                            //creep.say('Getting Energy')
-                            creep.travelTo(storagetarget);
-                        } else {
+                            //console.log(Game.getObjectById(storagetarget.id))
+                            if((storagetarget != undefined || storagetarget != null)){
+                                if( creep.withdraw(storagetarget,RESOURCE_ENERGY)== ERR_NOT_IN_RANGE){
+                                    creep.say('3')
+                                    //creep.say('Getting Energy')
+                                    creep.travelTo(storagetarget);
+                                }
+                            } else {
+                                if(creep.harvest(mysource) == ERR_NOT_IN_RANGE){
+                                    creep.moveTo(mysource,{ignoreCreeps:ignorecreeps})
+                                }
+                                creep.say("NSE-Ming")
+                            }
+                        }else {
                             if(creep.harvest(mysource) == ERR_NOT_IN_RANGE){
                                 creep.moveTo(mysource,{ignoreCreeps:ignorecreeps})
                             }
-                            creep.say("NSE-Ming")
                         }
-                    }else {
-                        if(creep.harvest(mysource) == ERR_NOT_IN_RANGE){
-                            creep.moveTo(mysource,{ignoreCreeps:ignorecreeps})
-                        }
-                    }
-                } catch(e){
-                    console.log(e)
-                }
-            } else {
-                if(droppedenergy){
-                    if(creep.pickup(droppedenergy) == ERR_NOT_IN_RANGE) {
-                        if(global.verbosity>0){
-                            creep.say("MTDE");
-                        }
-                        creep.moveTo(droppedenergy,{ignoreCreeps:ignorecreeps})           
+                    } catch(e){
+                        console.log(e)
                     }
                 } else {
-                    if(creep.withdraw(tombstone,RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
-                        if(global.verbosity>0){
-                            creep.say("MTTS");
+                    if(droppedenergy){
+                        if(creep.pickup(droppedenergy) == ERR_NOT_IN_RANGE) {
+                            if(global.verbosity>0){
+                                creep.say("MTDE");
+                            }
+                            creep.moveTo(droppedenergy,{ignoreCreeps:ignorecreeps})           
                         }
-                        creep.moveTo(tombstone.pos,{ignoreCreeps:ignorecreeps})           
+                    } else if (tombstone) {
+                        if(creep.withdraw(tombstone,RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
+                            if(global.verbosity>0){
+                                creep.say("MTTS");
+                            }
+                            creep.moveTo(tombstone.pos,{ignoreCreeps:ignorecreeps})           
+                        }
+                    } else if (ruins){
+                        if(creep.withdraw(ruins,RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
+                            if(global.verbosity>0){
+                                creep.say("MTTS");
+                            }
+                            creep.moveTo(ruins,{ignoreCreeps:ignorecreeps})           
+                        }
+                    } else if(spawn==null || spawn==undefined){
+                        storagetarget=creep.pos.findClosestByRange(FIND_STRUCTURES, {filter: (s) => {return ((s.structureType == STRUCTURE_STORAGE))   ;}});
+                        if(storagetarget){
+                            if(creep.withdraw(storagetarget,RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
+                                if(global.verbosity>0){
+                                    creep.say("MTTS");
+                                }
+                                creep.moveTo(storagetarget,{ignoreCreeps:ignorecreeps})           
+                            }
+                        } else {
+                            let mysource=Game.getObjectById(creep.memory.destsource.id)
+                            if(creep.harvest(mysource) == ERR_NOT_IN_RANGE){
+                                creep.moveTo(mysource,{ignoreCreeps:ignorecreeps})
+                            }
+                        }
+                        
+                    } else {
+                        creep.say("IDK")
                     }
                 }
             }
+            creep.memory.lastpos=creep.pos
+        } else { 
+            creep.moveTo(Game.rooms[creep.memory.assignedroom].controller)
         }
-        creep.memory.lastpos=creep.pos
-     }
+    }
 };
 module.exports = Phase1Worker;

role.sourceminer.js

@@ -1,5 +1,6 @@
 let rolesourceMiner = {
     run: function(creep) {
+        try{
         //if(Game.getObjectById(creep.memory.destsource.id)==undefined){creep.memory.destsource=undefined}
         let ignorecreeps=true
         //console.log('running sourceminer')
@@ -26,10 +27,58 @@ let rolesourceMiner = {
                 }   
             }
         } else{
-            if(creep.harvest(mysource) == ERR_NOT_IN_RANGE) {
-                creep.travelTo(mysource);
+            try{
+                creep.say('1')
+                let destcontainer=Game.getObjectById(creep.memory.destsource.id).pos.findInRange(FIND_STRUCTURES,1,{filter: (s) => {return (s.structureType == STRUCTURE_CONTAINER && s.store.getFreeCapacity() > 0)  ;}})
+                //console.log(creep.room.name + " " + destcontainer)
+                if(destcontainer != undefined || destcontainer != null){
+                    creep.say('2')
+                    console.log(creep.name + " " + destcontainer[0].id)
+                    creep.travelTo(destcontainer[0])
+                    if(creep.harvest(mysource) == ERR_NOT_IN_RANGE || creep.harvest(mysource)==ERR_NOT_ENOUGH_RESOURCES) {
+                        //let mycontainer = creep.find(FIND_STRUCTURES, {filter: (s) => {return (s.structureType == STRUCTURE_CONTAINER)  ;}});
+                        creep.travelTo(destcontainer[0],{ignoreCreeps:ignorecreeps});
+                    }
+                } else {
+                    creep.say('3')
+                    if(creep.harvest(mysource) == ERR_NOT_IN_RANGE|| creep.harvest(mysource)==ERR_NOT_ENOUGH_RESOURCES) {
+                        //let mycontainer = creep.find(FIND_STRUCTURES, {filter: (s) => {return (s.structureType == STRUCTURE_CONTAINER)  ;}});
+                        creep.travelTo(mysource,{ignoreCreeps:ignorecreeps});
+                    }
+                }
+            } catch(e){
+                console.log(e)
             }
         }
-    }   
+    }   catch(e){
+            console.log(e)
+        }
+    },
+    computeSourceAccessPoints: function(room, source){
+       const roomTerrain = room.getTerrain();
+       var accessPoints = 0;
+       for(var x = -1;x<=1;x++)
+       {
+           for(var y = -1;y<=1;y++)
+           {
+               if(x==0 && y==0){continue;}
+               if(roomTerrain.get(source.pos.x+x,source.pos.y+y)!=1){accessPoints++;}
+           }
+       }
+       return accessPoints;
+   },
+    checkminablepositions: function(name){
+       let x = this.pos.x;
+       let y = this.pos.y;
+       let walkable = this.room.lookForAtArea(
+           LOOK_TERRAIN,
+           y - 1,  // top
+           x - 1,  // left
+           y + 1,  // bottom
+           x + 1,  // right
+           true    // asArray
+       ).filter(o => o[LOOK_TERRAIN] !== 'wall');
+       return walkable.length;
+    }
 };
 module.exports = rolesourceMiner;