changes

Empire.js

@@ -39,51 +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
-            require('proc.spawning').spawnminer(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'
     },
-    spawnclaimer: 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(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
@@ -122,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

@@ -1,58 +1,166 @@
 let Phase1 = {
      run: function(room) {
+        let myroom=Game.rooms[room]
          require('assignsources').tick(room)
+         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 = Game.rooms[room].find(FIND_MY_SPAWNS)
+
+            let myspawns = myroom.find(FIND_MY_SPAWNS)
             if(myspawns.length>0){
                 let myspawn = myspawns[0]
-                let creepcount = Game.rooms[room].find(FIND_MY_CREEPS).length
-                creepcounts = _.countBy(Game.rooms[room].find(FIND_MY_CREEPS), c => c.memory.role)
-                Game.rooms[room].memory.movercount=creepcounts["mover"]
-                let workerrolename = 'phase' + Game.rooms[room].memory.phase +'worker'
-                let sources = Game.rooms[room].find(FIND_SOURCES )
-                if(Game.rooms[room].controller.ticksToDowngrade < CONTROLLER_DOWNGRADE[Game.rooms[room].controller.level] * .2 ){
-                    Game.rooms[room].memory.NeedsRecharge=1
-                    console.log(room + " needs Recharge " + Game.rooms[room].memory.NeedsRecharge)
+                let creepcount = myroom.find(FIND_MY_CREEPS).length
+                
+                let workerrolename = 'phase' + myroom.memory.phase +'worker'
+                let sources = myroom.find(FIND_SOURCES )
+                if(myroom.controller.ticksToDowngrade < CONTROLLER_DOWNGRADE[myroom.controller.level] * .2 ){
+                    myroom.memory.NeedsRecharge=1
+                    console.log(room + " needs Recharge " + myroom.memory.NeedsRecharge)
                 }
-                if(Game.rooms[room].controller.ticksToDowngrade > CONTROLLER_DOWNGRADE[Game.rooms[room].controller.level]*.8){
-                     Game.rooms[room].memory.NeedsRecharge=0
+                if(myroom.controller.ticksToDowngrade > CONTROLLER_DOWNGRADE[myroom.controller.level]*.8){
+                     myroom.memory.NeedsRecharge=0
                 }
-                if(Game.flags.debug && Game.flags.debug.room == Game.rooms[room]){
+                if(Game.flags.debug && Game.flags.debug.room == myroom){
                     console.log(room)
                     console.log(workerrolename)
                     console.log(creepcounts[workerrolename])
-                    console.log(Game.rooms[room].energyAvailable + " of " + Game.rooms[room].energyCapacityAvailable)
+                    console.log(myroom.energyAvailable + " of " + myroom.energyCapacityAvailable)
                 }
-                if(Game.rooms[room].memory.minablepositions >= 3 ||Game.rooms[room].memory.minablepositions==undefined ){
-                    if((((creepcounts[workerrolename]< (Game.rooms[room].memory.minablepositions + 1) || creepcounts[workerrolename]==undefined)  && Game.rooms[room].energyAvailable >= Game.rooms[room].energyCapacityAvailable) ) || ((creepcounts[workerrolename]==0 || creepcounts[workerrolename]==undefined ) && Game.rooms[room].energyAvailable>100)) {
+                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)
                         require('proc.spawning').spawnworker(room)
                     }
-                } else {
-                    if((((creepcounts['sourceminer']< Game.rooms[room].memory.minablepositions) || creepcounts['sourceminer']==undefined)  && Game.rooms[room].energyAvailable >= Game.rooms[room].energyCapacityAvailable) || ((creepcounts['sourceminer']==0 || creepcounts['sourceminer']==undefined ) && Game.rooms[room].energyAvailable>100)) {
+                } 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)
                         require('proc.spawning').spawnsourceminer(room)
                     }
-                    if((((creepcounts[workerrolename]< (Game.rooms[room].memory.minablepositions+1) || creepcounts[workerrolename]==undefined)  && Game.rooms[room].energyAvailable >= Game.rooms[room].energyCapacityAvailable) ) || ((creepcounts[workerrolename]==0 || creepcounts[workerrolename]==undefined ) && Game.rooms[room].energyAvailable>100)) {
+                    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)
                         require('proc.spawning').spawnworker(room)
                     }
                 }
-                if((Game.rooms[room].storage || Game.rooms[room].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)
                 }
-                if((Game.rooms[room].find(FIND_MY_STRUCTURES, {filter: {structureType: STRUCTURE_EXTRACTOR}}).length > 0)&&(creepcounts["miner"] < Game.rooms[room].memory.mineralminablepositions || creepcounts["miner"]==undefined)&&(Game.rooms[room].energyAvailable >= Game.rooms[room].energyCapacityAvailable)){
-                    if(Game.rooms[room].find(FIND_MINERALS)[0].ticksToRegeneration == undefined || Game.rooms[room].find(FIND_MINERALS)[0].ticksToRegeneration < 1000 ){
+                if(((myroom.storage || myroom.terminal) && myroom.StructureExtractor)  && (creepcounts["mineralmover"] < 1 || creepcounts["mineralmover"]==undefined)){
+                    console.log("Spawning MineralMover in " + room)
+                    require('proc.spawning').spawnmineralmover(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)
                         require('proc.spawning').spawnminer(room)
-                    } else { if(Game.flags.debug && Game.flags.debug.room == Game.rooms[room]){console.log("Not spawning miner in " + room + ", waiting for regen")}}
+                    } else { if(Game.flags.debug && Game.flags.debug.room == myroom){console.log("Not spawning miner in " + room + ", waiting for regen")}}
                 }
-                //require('proc.market').sellEnergy(room)
             }
         }
-        if(Game.rooms[room].controller.level>2){         }
+        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{
+                    if(myroom.terminal){
+                        ///console.log("1")
+                        if(myroom.terminal.store.getUsedCapacity() == 0) {
+                            //console.log("terminal is empty")
+                        }else{
+                            if(myroom.terminal.store.getUsedCapacity('energy') > 100000){
+                                console.log("Starting market loop for "+ myroom)
+                                for(mat in myroom.terminal.store){
+                                    let availtosell=0
+                                    //console.log(mat)
+                                    if(mat == 'energy'){
+                                        try{
+                                            availtosell = myroom.terminal.store.getUsedCapacity(mat) - 200000
+                                        } catch {
+                                            //console.log("error getting energy")
+                                            availtosell=0
+                                        }
+                                    } else {
+                                        try{
+                                            //console.log("2")
+                                            availtosell = myroom.terminal.store.getUsedCapacity(mat)
+                                        } catch {
+                                            //console.log("Couldn't get available " + mat)
+                                            availtosell=0
+                                        }
+                                    }
+                                    if(availtosell){
+                                        //console.log(availtosell)
+                                        if(availtosell > 20000){
+                                            //console.log("processing market")
+                                            require('proc.market').sellEnergy(room,mat)  
+                                        }
+                                    }
+                                }    
+                            }
+                        }   
+                    }
+                }catch(e){
+                    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){         }
      }
 };
 module.exports = Phase1;

RoomInit.js

@@ -21,6 +21,7 @@ let initroom = {
         Game.rooms[name].memory.mineralminablepositions = mineralminablepositions
         let minablepositions = 0
         let srcs = Game.rooms[name].find(FIND_SOURCES);
+        Game.rooms[name].memory.sourcecount=srcs.length
         for(let i = 0;i<srcs.length;i++)
         {
             minablepositions = minablepositions + this.computeSourceAccessPoints(Game.rooms[name],srcs[i])

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)}})

flag.claim.js

@@ -21,7 +21,7 @@ let claim = {
         if(!Game.flags.claim.room.controller.my){
             //console.log('not my controller')
         }
-        console.log("CreepCount:"+creepcount+"| Lifetime:" + avglife + "|Request Time:" + Game.flags.claim.memory.requesttime )
+        console.log("Room: " + Game.flags.claim.room  + "CreepCount:"+creepcount+"| Lifetime:" + avglife + "|Request Time:" + Game.flags.claim.memory.requesttime )
      }
      
      }

main.js

@@ -5,6 +5,7 @@ global.verbosity=0
 module.exports.loop = function () {
     console.log("----Start loop for "+ Game.time + '----')
     let decrementcounter = Game.time % 30
+    ///for (let key of require('Empire')) global[key] = require('Empire')[key]
     try{
     for(let name in Game.rooms){
         let myroom=Game.rooms[name]
@@ -21,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.market.js

@@ -7,18 +7,18 @@
  * mod.thing == 'a thing'; // true
  */
 let gomarket={
-    sellEnergy: function(myroom) {
+    sellEnergy: function(myroom,mat) {
         try{
-        let availtosell= Game.rooms[myroom].terminal.store[RESOURCE_ENERGY]
-        
-        if(availtosell>5000){
-            console.log(myroom + ":" + availtosell)
+        let availtosell= Game.rooms[myroom].terminal.store.getUsedCapacity(mat)
+        if(availtosell>0){
+            console.log(myroom + ":" + mat +":" + availtosell)
             //console.log(JSON.stringify(Game.market.orders))
           // if(Game.market.orders.length > 9){
-                let myorders = Game.market.getAllOrders(order=>order.resourceType == RESOURCE_ENERGY && order.type == ORDER_BUY)
+                let myorders = Game.market.getAllOrders(order=>order.resourceType == mat && order.type == ORDER_BUY)
+                //console.log("Open orders: " + myorders.length)
                 //console.log(myorders.length)
                 for(let i=0; i<myorders.length; i++){
-                     let recheckavailtosell= Game.rooms[myroom].terminal.store[RESOURCE_ENERGY]
+                     let recheckavailtosell= Game.rooms[myroom].terminal.store.getUsedCapacity(mat)
                      if(recheckavailtosell<1000){
                          console.log("too little to mess with")
                      } else {
@@ -30,9 +30,21 @@ let gomarket={
                         } else {
                             amttosell=myorders[i].amount
                         }
-                        console.log( myroom + " trying to sell " + amttosell + " Energy on order size of " + myorders[i].amount + " with " + recheckavailtosell + " left")
+                        console.log( myroom + " trying to sell " + amttosell + " " + mat + " on order size of " + myorders[i].amount + " with " + recheckavailtosell + " left and " + myorders.length + " orders open")
                         let mydeal = Game.market.deal(myorders[i].id, amttosell, myroom);
-                        console.log(mydeal)
+                        if(mydeal == 0){
+                            console.log("Order Created")
+                        } else if(mydeal==-6){
+                            console.log("not enouhg resources")
+                        } else if(mydeal == -8){
+                            console.log("too many orders")
+                        } else if (mydeal == -10){
+                            console.log("Invalid arguments")
+                        } else if (mydeal==-11){
+                            console.log("terminal cooling down")
+                        } else {
+                            console.log(mydeal)
+                        }
                      //} else { 
                     //     console.log("Too expensive")
                      //}

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")
+                        }
                     }}
 
     },
@@ -124,6 +124,33 @@ let buildparts = {
                         let newcreep = spawn.createCreep(tobuild,CreepName,{spawnedat: Game.time,role:"mover"})
                     }}
 
+    },
+    spawnmineralmover: function(roomname) {
+        let myspawns=Game.rooms[roomname].find(FIND_MY_SPAWNS)
+        Game.rooms[roomname].memory.CreepNum++
+        let CreepName =  'MineralMover_' + roomname + "_" + (Game.rooms[roomname].memory.CreepNum)
+                            for(let spawn of myspawns){
+                        if(!spawn.spawning){
+                        for(let totry of [
+                             [MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY],//MOVE*6,WORK*5,CARRY*7
+                             [MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY],// all * 5
+                             [MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY],//move*5, work*4, carry*5
+                             [MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY],//move*4,work*4,carry*4
+                             [MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY],//move*4, work*3, carry*4
+                             [MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY], //move*3,work*2, carry*3
+                             [MOVE,CARRY,CARRY,MOVE,CARRY,CARRY], //move*2, work*2, carry*2
+                             [MOVE,CARRY,CARRY,MOVE,CARRY],//move*2, work*1, carry*2
+                             [MOVE,CARRY,CARRY]
+                            ]){
+                            let ispossible = spawn.canCreateCreep(totry)
+                            if(ispossible==OK){
+                                tobuild=totry
+                                break;
+                            }
+                        }
+                        let newcreep = spawn.createCreep(tobuild,CreepName,{spawnedat: Game.time,role:"mineralmover"})
+                    }}
+
     },
     spawnnrworker: function(roomname) {
         console.log('1')

role.miner.js

@@ -32,7 +32,7 @@ let roleMiner = {
              creep.moveTo(spawn);
          }
      } else {
-         let storagetargets = creep.pos.findClosestByRange(FIND_STRUCTURES, {filter: (s) => {return ((s.structureType == STRUCTURE_STORAGE || s.structureType == STRUCTURE_CONTAINER || s.structureType == STRUCTURE_TERMINAL || s.structureType == STRUCTURE_FACTORY ) &&  _.sum(s.store) < s.storeCapacity)  ;}});
+         let storagetargets = creep.pos.findClosestByRange(FIND_STRUCTURES, {filter: (s) => {return ((s.structureType == STRUCTURE_TERMINAL || s.structureType == STRUCTURE_FACTORY ) &&  _.sum(s.store) < s.storeCapacity)  ;}});
          if(storagetargets){
             if(this.transferAll(creep,storagetargets) == ERR_NOT_IN_RANGE) {
                creep.moveTo(storagetargets,{ignoreCreeps:ignorecreeps})

role.mineralmover.js

@@ -0,0 +1,132 @@
+let mover={
+    run: function(creep) {
+        //creep.say("Moving Minerals")
+        let ignorecreeps=true
+        if(creep.memory.lastpos==undefined || creep.memory.timeatpos==undefined){
+            creep.memory.lastpos = creep.pos
+            creep.memory.timeatpos = 0
+        }
+        if(creep.memory.working==undefined){
+            creep.memory.working=false
+        }
+        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)
+        if(creep.memory.working && filllevel == 0) {
+            creep.memory.working = false;
+            creep.say('Gathering');
+	    }
+	    if(!creep.memory.working && filllevel == creep.carryCapacity) {
+	        creep.memory.working = true;
+	        creep.say('working');
+	    }
+        if(creep.memory.working){
+            let terminaltarget = creep.room.terminal
+            if(creep.room.terminal){
+                if(terminaltarget.store.getUsedCapacity()<200000){
+                    if(this.transferAll(creep,terminaltarget) == ERR_NOT_IN_RANGE) {
+                        creep.moveTo(terminaltarget,{ignoreCreeps:ignorecreeps})
+                    } 
+                }
+            }
+        } 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);
+            }
+        } 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
+                    }
+                }catch{
+                    if(storageenergy > 0){
+                        storagetarget = storage
+                    } else if ( terminalenergy > 0) { 
+                        storagetarget = terminal
+                    } else {
+                        console.log("we're out of energy!")
+                        storagetarget=storage
+                    }
+                }*/
+                let storagetarget = creep.pos.findClosestByRange(FIND_STRUCTURES, {filter: (s) => {return ((s.structureType == STRUCTURE_STORAGE || s.structureType == STRUCTURE_CONTAINER ) &&  (s.store.getUsedCapacity() > s.store.getUsedCapacity('energy') || s.store.getUsedCapacity('energy') > 200000))  ;}});
+                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)}});
+                if((droppedenergy == undefined) && (tombstone==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)
+                    }
+                    try{
+                        for(mat in storagetarget.store){
+                            if(mat=='energy' && storagetarget.store.getUsedCapacity('energy') > 200000){
+                                if(creep.withdraw(storagetarget,mat)== ERR_NOT_IN_RANGE) {
+                                    creep.say('Getting ' + mat )
+                                    creep.travelTo(storagetarget);
+                                }
+                            } else {
+                                if(creep.withdraw(storagetarget,mat)== ERR_NOT_IN_RANGE) {
+                                    creep.say('Getting ' + mat )
+                                    creep.travelTo(storagetarget);
+                                }
+                            }
+                        }
+                    } catch (e){
+                        //console.log(e)
+                    }
+                } 
+                if(!storagetarget && (creep.carry > 0)){
+                    creep.memory.working=true
+                }
+            }
+        }
+        creep.memory.lastpos=creep.pos
+    },
+    transferAll: function(creep,targetStorage){
+        let result = 0;
+        for(mat in creep.store)
+        {
+           let tempResult = creep.transfer(targetStorage,mat);
+           if(tempResult !== ERR_INVALID_ARGS) {result = tempResult;}
+        }
+        return result;
+     }
+}
+module.exports = mover;

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,62 +28,108 @@ let mover={
 	        creep.memory.working = true;
 	        creep.say('working');
 	    }
-        if(creep.memory.working){
-            let terminaltarget = creep.room.terminal
-            if(creep.pos.findClosestByPath(FIND_STRUCTURES, {filter: (s) => {return ((([STRUCTURE_SPAWN, STRUCTURE_EXTENSION, STRUCTURE_TOWER, STRUCTURE_LAB].includes(s.structureType)) && s.energy < s.energyCapacity))}})){
-                let spawntarget = creep.pos.findClosestByPath(FIND_STRUCTURES, {filter: (s) => {return (((s.structureType == STRUCTURE_EXTENSION || s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_TOWER|| s.structureType == STRUCTURE_LAB) && s.energy < s.energyCapacity))}});
-                if(creep.transfer(spawntarget, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
-                    creep.moveTo(spawntarget,{ignoreCreeps:ignorecreeps})
-                }
-            }else 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]>1)}}))  ) {
-            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 storagetarget = creep.pos.findClosestByRange(FIND_STRUCTURES, {filter: (s) => {return ((s.structureType == STRUCTURE_STORAGE || s.structureType == STRUCTURE_CONTAINER) &&  _.sum(s.store) >= 500)  ;}});
-                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)}});
-                if((droppedenergy == undefined) && (tombstone==undefined)){
-                    if(creep.withdraw(storagetarget,RESOURCE_ENERGY)== ERR_NOT_IN_RANGE) {
-                        creep.say('Getting Energy')
-                        creep.travelTo(storagetarget);
+            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 {
-                    if(droppedenergy){
-                        if(creep.pickup(droppedenergy) == ERR_NOT_IN_RANGE) {
-                            if(global.verbosity>0){
-                                creep.say("MTDE");
+                    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);
+                    }
+                }*/
+            } 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(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(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
+                    }
                 }
             }
+            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,104 +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.storeCapacity)  ;}});
-             if(creep.room.memory.NeedsRecharge==1){
-                 if(creep.upgradeController(creep.room.controller) == ERR_NOT_IN_RANGE) {
-	                   creep.say('!MTRC!')
-	                   creep.say(creep.room.controller.ticksToDowngrade)
-                       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);}
+        if(creep.room.name == creep.memory.assignedroom){
+            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_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,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(storagetargets){
-                 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
+                    }
                 }
-            }
-        } 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]>1)}}))  ) {
-            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(creep.room.memory.NeedsRecharge==1 && creep.carry.energy>0){
-                if(creep.upgradeController(creep.room.controller) == ERR_NOT_IN_RANGE) {
-                      creep.say('!MTRC!')
-                      creep.say(creep.room.controller.ticksToDowngrade)
-                      creep.moveTo(creep.room.controller)
-               }
-            } else {
-               if(spawn.renewCreep(creep) == ERR_NOT_IN_RANGE){
-                    creep.moveTo(spawn);
-                }   
-            }
-        } 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(tombstones)
-            if((droppedenergy == undefined) && (tombstone==undefined)){
-                if(Game.getObjectById(creep.memory.destsource.id)==undefined){creep.memory.destsource=undefined}
-                let mysource=Game.getObjectById(creep.memory.destsource.id)
-                if(creep.harvest(mysource) == ERR_NOT_IN_RANGE){
-                    creep.moveTo(mysource,{ignoreCreeps:ignorecreeps})
-                }
-            } else {
-                if(droppedenergy){
-                    if(creep.pickup(droppedenergy) == ERR_NOT_IN_RANGE) {
-                        if(global.verbosity>0){
-                            creep.say("MTDE");
+                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)
                         }
-                        creep.moveTo(droppedenergy,{ignoreCreeps:ignorecreeps})           
+                    } else {
+                        creep.transfer(spawn, RESOURCE_ENERGY)
+                        if(spawn.renewCreep(creep) == ERR_NOT_IN_RANGE){
+                            creep.say('MVSP')
+                            creep.moveTo(spawn);
+                        }   
                     }
                 } else {
-                    if(creep.withdraw(tombstone,RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
-                        if(global.verbosity>0){
-                            creep.say("MTTS");
+                    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)}});
+                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)){
+                                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.moveTo(tombstone.pos,{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})           
+                        }
+                    } 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,12 +1,84 @@
 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')
         let mysource=Game.getObjectById(creep.memory.destsource.id)
-        if(creep.harvest(mysource) == ERR_NOT_IN_RANGE) {
-            creep.travelTo(mysource);
+        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
+                }
+            }
+            creep.say('renewing')
+            console.log(creep.name + ": " + creep.ticksToLive + " " + creep.memory.renewto)
+            let spawn = creep.pos.findClosestByRange(FIND_MY_SPAWNS)
+            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 {
+               if(spawn.renewCreep(creep) == ERR_NOT_IN_RANGE){
+                    creep.moveTo(spawn);
+                }   
+            }
+        } else{
+            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;