paradizelost/screeps
1
0
Fork 0
mirror of https://github.com/paradizelost/screeps.git synced 2024-11-25 02:14:44 -06:00
Code Issues Projects Releases Wiki Activity

Rewrite Catchup

Browse Source
This commit is contained in:
paradizelost 2017-06-06 13:17:26 -05:00 committed by GitHub
parent 2f45d9b69e
commit 2199b449bb
23 changed files with 858 additions and 248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
Empire.js Normal file
View File

@ -0,0 +1,70 @@
let buildparts=require('bodypartbuilder')
module.exports = {
get getcounts(){
let output=''
for(let myroom of _.filter(Game.rooms, 'controller.my')) {
let name = myroom.name
//let{builder,miner,hauler,hauler2,towerrecharger,repairbot,upgrader,warrior,claimer,nrbuilder,nrminer}=_.groupBy(Game.rooms[name].creeps, 'memory.role')
let allcreeps = _.filter(Game.rooms[name].find(FIND_MY_CREEPS));
let allbuilders = _.filter(allcreeps,(creep) => (creep.memory.role=='builder'))
let allminers = _.filter(allcreeps,(creep) => (creep.memory.role=='miner'))
let allminer2s = _.filter(allcreeps,(creep) => (creep.memory.role=='miner2'))
let allhaulers = _.filter(allcreeps,(creep) => (creep.memory.role=='hauler'))
let allhauler2s = _.filter(allcreeps,(creep) => (creep.memory.role=='hauler2'))
let alltowerrechargers = _.filter(allcreeps,(creep) => (creep.memory.role=='towerrecharger'))
let allrepairbots = _.filter(allcreeps,(creep) => (creep.memory.role=='repairbot'))
let allupgraders = _.filter(allcreeps,(creep) => (creep.memory.role=='upgrader'))
let allwarriors = _.filter(allcreeps,(creep) => (creep.memory.role=='warrior'))
let allclaimers = _.filter(allcreeps,(creep) => (creep.memory.role=='claimer'))
let allnrbuilders = _.filter(allcreeps,(creep) => (creep.memory.role=='nrbuilder'))
let allnrminers = _.filter(allcreeps,(creep) => (creep.memory.role=='nrminer'))
output +=(
name + ': ' +
allcreeps.length + ' total creeps ' + ' '
+ allbuilders.length + ' Builders of ' + Game.rooms[name].memory.maxbuilders + " "
+ allminers.length + ' Miners of ' + Game.rooms[name].memory.maxminers + " "
+ allminer2s.length + ' Miner2s of ' + Game.rooms[name].memory.maxminer2s + " "
+ allhaulers.length + ' Haulers of ' + Game.rooms[name].memory.maxhaulers + " "
+ allhauler2s.length + ' Hauler2s of ' + Game.rooms[name].memory.maxhauler2s + " "
+ alltowerrechargers.length + ' Rechargers of ' + Game.rooms[name].memory.maxtowerrechargers + " "
+ allrepairbots.length + ' Repairbots of ' + Game.rooms[name].memory.maxrepairbots + " "
+ allupgraders.length + ' Upgraders of ' + Game.rooms[name].memory.maxupgraders + " "
+ allwarriors.length + ' Warriors of ' + Game.rooms[name].memory.maxwarriors + " "
+ allclaimers.length + ' Claimers of ' + Game.rooms[name].memory.maxclaimers + " "
+ allnrbuilders.length + ' nrbuilders of ' + Game.rooms[name].memory.maxnrbuilders + " "
+ allnrminers.length + ' nrminers of ' + Game.rooms[name].memory.maxnrminers + " "
+ '\n'
)
}
return output
},
decrease: function(role,roomname){
let rolename = 'max' + role + 's'
let currentmax = Game.rooms[roomname].memory[rolename]
Game.rooms[roomname].memory[rolename]--
let newmax = Game.rooms[roomname].memory[rolename]
return 'Old Max:'+currentmax+' New Max:'+newmax
},
increase: function(role,roomname){
let rolename = 'max' + role + 's'
let currentmax = Game.rooms[roomname].memory[rolename]
Game.rooms[roomname].memory[rolename]++
let newmax = Game.rooms[roomname].memory[rolename]
return 'Old Max:'+currentmax+' New Max:'+newmax
},
kill: function(creepname){
let me= Game.creeps[creepname].suicide()
return me
},
spawn: function(roomname,role){
buildparts.tick(roomname,role)
return 'Spawning initiated'
},
removeConstruction: function(roomname){
_.invoke(Game.rooms[roomname].find(FIND_MY_CONSTRUCTION_SITES), 'remove')
},
removeWalls: function(roomname){
Game.rooms[roomname].find(FIND_STRUCTURES, {filter: s => s.structureType === STRUCTURE_WALL}).forEach(s => s.destroy())
}
};

26
MinedMineralProc.js Normal file
View File

@ -0,0 +1,26 @@
let runSources = {
tick: function(roomname) {
let sources = Game.rooms[roomname].find(
FIND_DROPPED_RESOURCES, {
filter: (mineral) => (mineral.resourceType == RESOURCE_ZYNTHIUM || mineral.resourceType == RESOURCE_OXYGEN || mineral.resourceType == RESOURCE_LEMERGIUM)
});
for(let source of sources){
try{
console.log(source)
let allhaulers = _.filter(Game.rooms[roomname].find(FIND_MY_CREEPS), (creep) => creep.memory.role=='hauler3' );
let unassignedhauler3s = _.filter(allhaulers, (creep) => (creep.memory.destsource == undefined && creep.memory.role=='hauler3'));
let assignedhauler3s = _.filter(allhaulers, (creep) => (creep.memory.destsource != undefined && creep.memory.role=='hauler3'));
let myhauler3s = _.filter(allhaulers, (creep) => (creep.memory.destsource != undefined && creep.memory.destsource.id==source.id && creep.memory.role=='hauler3'));
let sourcecount = sources.length
let persrc = allhaulers.length / sourcecount
console.log('My Assigned Hauler3s: ' +myhauler3s.length + ' Max per source:' + persrc + ' Total Hauler3s:' + allhaulers.length + ' Total Sources:' + sourcecount + ' Unassigned Hauler3s:' + unassignedhauler3s.length)
if(unassignedhauler3s.length > 0){
if(myhauler3s.length < persrc){
unassignedhauler3s[0].memory.destsource = source
} else {}
}
} catch(e){console.log(e)}
}
}
};
module.exports = runSources;

4
NOTES.js
View File

@ -1,3 +1,7 @@
if(containers.count==0 && structure_extensions.count==0 && storage.count==0 && miners.count==0){spawn harvester} else { spawn miners and haulers}
_.forEach(Game.creeps, creep => creep.suicide())
_.forEach(Game.rooms[roomname].constructionSites, cs=>cs.remove())
serializePos: function(pos) { serializePos: function(pos) {
return pos.x + '_' + pos.y + '_' + pos.roomName; return pos.x + '_' + pos.y + '_' + pos.roomName;
}, },

290
bodypartbuilder.js
View File

@ -1,18 +1,71 @@
let buildparts = { let buildparts = {
tick: function(roomname,role) { tick: function(roomname,role) {
console.log(Game.rooms[roomname].memory.tickssincespawn)
console.log(roomname + ":" + role) console.log(roomname + ":" + role)
let energyready = Game.rooms[roomname].energyAvailable let energyready = Game.rooms[roomname].energyAvailable
let energymax = Game.rooms[roomname].energyCapacityAvailable let energymax = Game.rooms[roomname].energyCapacityAvailable
if(energyready==energymax){
Game.rooms[roomname].memory.tickssincespawn=0
let tobuild=[] let tobuild=[]
let myspawns=Game.rooms[roomname].find(FIND_MY_SPAWNS)
Game.rooms[roomname].memory.CreepNum++
let CreepName = role + "_" + roomname + "_" + (Game.rooms[roomname].memory.CreepNum)
switch(role){ switch(role){
case 'builder': case 'builder':
let myspawns=Game.rooms[roomname].find(FIND_MY_SPAWNS)
for(let spawn of myspawns){ for(let spawn of myspawns){
if(!spawn.spawning){
for(let totry of [ for(let totry of [
[MOVE,MOVE,MOVE,MOVE,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,CARRY,CARRY,CARRY,WORK], [MOVE,MOVE,MOVE,MOVE,WORK,WORK,WORK,WORK,CARRY,CARRY,CARRY,CARRY],
[MOVE,MOVE,MOVE,MOVE,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,CARRY,CARRY,CARRY,MOVE], [MOVE,MOVE,MOVE,WORK,WORK,WORK,CARRY,CARRY,CARRY],
[MOVE,MOVE,CARRY] [MOVE,MOVE,WORK,WORK,CARRY,CARRY],
[MOVE,WORK,CARRY]
]){
let ispossible = spawn.canCreateCreep(totry)
if(ispossible==OK){
tobuild=totry
break;
}
}
console.log(tobuild)
let newcreep = spawn.createCreep(tobuild,CreepName,{role:role})
console.log('Spawning new ' + role + ': ' + newcreep );
}
}
break;
case 'nrbuilder':
for(let spawn of myspawns){
if(!spawn.spawning){
for(let totry of [
[MOVE,MOVE,WORK,WORK,CARRY,CARRY],
[MOVE,WORK,CARRY]
]){
let ispossible = spawn.canCreateCreep(totry)
if(ispossible==OK){
tobuild=totry
break;
}
}
console.log(tobuild)
let newcreep = spawn.createCreep(tobuild,CreepName,{role:role})
console.log('Spawning new ' + role + ': ' + newcreep );
}
}
break;
case 'hauler':
for(let spawn of myspawns){
if(!spawn.spawning){
for(let totry of [
[CARRY,CARRY,CARRY,CARRY,CARRY,CARRY,MOVE,MOVE,MOVE,MOVE],
[CARRY,CARRY,CARRY,CARRY,CARRY,MOVE,MOVE,MOVE],
[CARRY,CARRY,CARRY,CARRY,MOVE,MOVE],
[CARRY,CARRY,MOVE,MOVE],
[CARRY,MOVE]
]){ ]){
let ispossible = spawn.canCreateCreep(totry) let ispossible = spawn.canCreateCreep(totry)
if(ispossible==OK){ if(ispossible==OK){
@ -21,15 +74,232 @@ let buildparts = {
} }
} }
console.log(tobuild) console.log(tobuild)
let newcreep = spawn.createCreep(tobuild,CreepName,{role:role})
console.log('Spawning new ' + role + ': ' + newcreep );
}
} }
break; break;
case 'hauler': case 'hauler3':
console.log('2')
break for(let spawn of myspawns){
if(!spawn.spawning){
for(let totry of [
[CARRY,CARRY,CARRY,CARRY,CARRY,CARRY,MOVE,MOVE,MOVE,MOVE],
[CARRY,CARRY,CARRY,CARRY,CARRY,MOVE,MOVE,MOVE],
[CARRY,CARRY,CARRY,CARRY,MOVE,MOVE],
[CARRY,CARRY,MOVE,MOVE],
[CARRY,MOVE]
]){
let ispossible = spawn.canCreateCreep(totry)
if(ispossible==OK){
tobuild=totry
break;
}
}
console.log(tobuild)
let newcreep = spawn.createCreep(tobuild,CreepName,{role:role})
console.log('Spawning new ' + role + ': ' + newcreep );
}
}
break;
case 'miner':
for(let spawn of myspawns){
if(!spawn.spawning){
for(let totry of [
[WORK,WORK,WORK,WORK,WORK,MOVE],
[WORK,WORK,WORK,WORK,MOVE],
[WORK,WORK,WORK,MOVE],
[WORK,WORK,MOVE],
[WORK,MOVE]
]){
let ispossible = spawn.canCreateCreep(totry)
if(ispossible==OK){
tobuild=totry
break;
}
}
console.log(tobuild)
let newcreep = spawn.createCreep(tobuild,CreepName,{role:role})
console.log('Spawning new ' + role + ': ' + newcreep );
}}
break;
case 'miner2':
for(let spawn of myspawns){
if(!spawn.spawning){
for(let totry of [
[WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,MOVE,MOVE],
[WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,MOVE,MOVE],
[WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,MOVE,MOVE],
[WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,MOVE,MOVE],
[WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,MOVE,MOVE],
[WORK,WORK,WORK,WORK,WORK,WORK,WORK,MOVE,MOVE],
[WORK,WORK,WORK,WORK,WORK,WORK,MOVE,MOVE],
[WORK,WORK,WORK,WORK,WORK,MOVE],
[WORK,WORK,WORK,WORK,MOVE],
[WORK,WORK,WORK,MOVE],
[WORK,WORK,MOVE],
[WORK,MOVE]
]){
let ispossible = spawn.canCreateCreep(totry)
if(ispossible==OK){
tobuild=totry
break;
}
}
console.log(tobuild)
let newcreep = spawn.createCreep(tobuild,CreepName,{role:role})
console.log('Spawning new ' + role + ': ' + newcreep );
}}
break;
case 'nrminer':
for(let spawn of myspawns){
if(!spawn.spawning){
for(let totry of [
[WORK,WORK,WORK,WORK,WORK,MOVE],
[WORK,WORK,WORK,WORK,MOVE],
[WORK,WORK,WORK,MOVE],
[WORK,WORK,MOVE],
[WORK,MOVE]
]){
let ispossible = spawn.canCreateCreep(totry)
if(ispossible==OK){
tobuild=totry
break;
}
}
console.log(tobuild)
let newcreep = spawn.createCreep(tobuild,CreepName,{role:role})
console.log('Spawning new ' + role + ': ' + newcreep );
}}
break;
case 'hauler2':
for(let spawn of myspawns){
if(!spawn.spawning){
for(let totry of [[CARRY,CARRY,CARRY,CARRY,CARRY,CARRY,MOVE,MOVE,MOVE,MOVE],
[CARRY,CARRY,CARRY,CARRY,CARRY,MOVE,MOVE,MOVE],
[CARRY,CARRY,CARRY,CARRY,MOVE,MOVE],
[CARRY,CARRY,MOVE,MOVE],
[CARRY,MOVE]
]){
let ispossible = spawn.canCreateCreep(totry)
if(ispossible==OK){
tobuild=totry
break;
}
}
console.log(tobuild)
let newcreep = spawn.createCreep(tobuild,CreepName,{role:role})
console.log('Spawning new ' + role + ': ' + newcreep );
}}
break;
case 'towerrecharger':
for(let spawn of myspawns){
if(!spawn.spawning){
for(let totry of [[CARRY,CARRY,CARRY,MOVE,MOVE]]){
let ispossible = spawn.canCreateCreep(totry)
if(ispossible==OK){
tobuild=totry
break;
}
}
console.log(tobuild)
let newcreep = spawn.createCreep(tobuild,CreepName,{role:role})
console.log('Spawning new ' + role + ': ' + newcreep );
}}
break;
case 'repairbot':
for(let spawn of myspawns){
if(!spawn.spawning){
for(let totry of [
[MOVE,MOVE,MOVE,WORK,WORK,WORK,WORK,WORK,CARRY,CARRY,CARRY],//RCL3
[WORK,CARRY,MOVE]
]){
let ispossible = spawn.canCreateCreep(totry)
if(ispossible==OK){
tobuild=totry
break;
}
}
console.log(tobuild)
let newcreep = spawn.createCreep(tobuild,CreepName,{role:role})
console.log('Spawning new ' + role + ': ' + newcreep );
}}
break;
case 'upgrader':
for(let spawn of myspawns){
if(!spawn.spawning){
for(let totry of [
[WORK,WORK,WORK,WORK,WORK,WORK,WORK,WORK,CARRY,CARRY,CARRY,CARRY,CARRY,CARRY,MOVE,MOVE,MOVE,MOVE],
[WORK,WORK,WORK,WORK,WORK,WORK,WORK,CARRY,CARRY,CARRY,CARRY,CARRY,CARRY,MOVE,MOVE,MOVE,MOVE],
[WORK,WORK,WORK,WORK,WORK,WORK,CARRY,CARRY,CARRY,CARRY,CARRY,CARRY,MOVE,MOVE,MOVE,MOVE],
[WORK,WORK,WORK,WORK,WORK,CARRY,CARRY,CARRY,CARRY,CARRY,CARRY,MOVE,MOVE,MOVE,MOVE],
[WORK,WORK,WORK,WORK,CARRY,CARRY,CARRY,CARRY,CARRY,CARRY,MOVE,MOVE,MOVE,MOVE],
[WORK,WORK,WORK,WORK,CARRY,CARRY,CARRY,CARRY,MOVE,MOVE,MOVE,MOVE],
[WORK,WORK,WORK,CARRY,CARRY,CARRY,MOVE,MOVE,MOVE,MOVE],
[MOVE,MOVE,WORK,WORK,WORK,CARRY,CARRY,CARRY],
[MOVE,MOVE,WORK,WORK,CARRY,CARRY],
[MOVE,WORK,CARRY]
]){
let ispossible = spawn.canCreateCreep(totry)
if(ispossible==OK){
tobuild=totry
break;
}
}
console.log(tobuild)
let newcreep = spawn.createCreep(tobuild,CreepName,{role:role})
console.log('Spawning new ' + role + ': ' + newcreep );
}}
break;
case 'warrior':
for(let spawn of myspawns){
if(!spawn.spawning){
for(let totry of [
[ATTACK,ATTACK,RANGED_ATTACK,RANGED_ATTACK,MOVE,MOVE],
[ATTACK,ATTACK,RANGED_ATTACK,MOVE]
]){
let ispossible = spawn.canCreateCreep(totry)
if(ispossible==OK){
tobuild=totry
break;
}
}
console.log(tobuild)
let newcreep = spawn.createCreep(tobuild,CreepName,{role:role})
console.log('Spawning new ' + role + ': ' + newcreep );
}}
break;
case 'claimer':
for(let spawn of myspawns){
if(!spawn.spawning){
for(let totry of [
[CLAIM,CLAIM,CLAIM,CLAIM,CLAIM,MOVE,MOVE],
[CLAIM,MOVE]
]){
let ispossible = spawn.canCreateCreep(totry)
if(ispossible==OK){
tobuild=totry
break;
}
}
console.log(tobuild)
let newcreep = spawn.createCreep(tobuild,CreepName,{role:role})
console.log('Spawning new ' + role + ': ' + newcreep );
}}
break;
default: default:
console.log('3') console.log('no match')
} }
}
} }
}; };

93
main.js
View File

@ -1,5 +1,7 @@
'use strict'; 'use strict';
global.Empire = require("Empire")
let roleBuilder=require('role.builder'); let roleBuilder=require('role.builder');
let roleClaimer=require('role.claimer');
let roleMiner=require('role.miner'); let roleMiner=require('role.miner');
let roleHauler=require('role.hauler') let roleHauler=require('role.hauler')
let roleHauler2=require('role.hauler2') let roleHauler2=require('role.hauler2')
@ -9,7 +11,14 @@ let runSources=require('sourceprocessing')
let roleRepairbot=require('role.repairbot') let roleRepairbot=require('role.repairbot')
let runTower = require('tower'); let runTower = require('tower');
let assignMiners=require('sproc') let assignMiners=require('sproc')
let buildparts=require('bodypartbuilder') let roleWarrior=require('role.warrior')
let rolenrBuilder=require('role.nrbuilder')
let rolenrMiner=require('role.nrminer')
let processSpawns=require('spawnprocessing')
let minerals=require('mineralprocessing')
let roleMiner2=require('role.miner2')
let roleHauler3=require('role.mineralhauler')
let minedproc = require('MinedMineralProc')
module.exports.loop = function () { module.exports.loop = function () {
console.log('---START---') console.log('---START---')
for(let name in Memory.creeps) { for(let name in Memory.creeps) {
@ -18,30 +27,22 @@ module.exports.loop = function () {
console.log('Clearing non-existing creep memory:', name); console.log('Clearing non-existing creep memory:', name);
} }
} }
for(let myroom of _.filter(Game.rooms, 'controller.my')) { for(let myroom of _.filter(Game.rooms, 'controller.my')) {
let name = myroom.name let name = myroom.name
console.log(name)
buildparts.tick(name,'builder')
console.log('---'+name+'---') console.log('---'+name+'---')
runTower.tick(name); runTower.tick(name);
assignMiners.tick(name) assignMiners.tick(name)
runSources.tick(name) runSources.tick(name)
minedproc.tick(name)
try{ try{
let roomenergy = Game.rooms[name].energyAvailable let roomenergy = Game.rooms[name].energyAvailable
let allstorage = Game.rooms[name].find(FIND_STRUCTURES, {filter: (s) => {return ( s.structureType == STRUCTURE_CONTAINER || s.structureType == STRUCTURE_STORAGE)}}) let allstorage = Game.rooms[name].find(FIND_STRUCTURES, {filter: (s) => {return ( s.structureType == STRUCTURE_CONTAINER || s.structureType == STRUCTURE_STORAGE)}})
let usedstorage = 0 let usedstorage = 0
let mycapacity=0 let mycapacity=0
for(let i=0; i < allstorage.length;i++){ for(let i of allstorage){
usedstorage+=_.sum(allstorage[i].store) usedstorage+=_.sum(i.store)
mycapacity+=allstorage[i].storeCapacity mycapacity+=i.storeCapacity
} }
let allcontainers = Game.rooms[name].find(FIND_STRUCTURES, {filter: (s) => {return ( s.structureType == STRUCTURE_CONTAINER)}}) let allcontainers = Game.rooms[name].find(FIND_STRUCTURES, {filter: (s) => {return ( s.structureType == STRUCTURE_CONTAINER)}})
let containerusedstorage = 0 let containerusedstorage = 0
let containercapacity=0 let containercapacity=0
@ -49,27 +50,26 @@ module.exports.loop = function () {
containerusedstorage+=_.sum(allcontainers[i].store) containerusedstorage+=_.sum(allcontainers[i].store)
containercapacity+=allcontainers[i].storeCapacity containercapacity+=allcontainers[i].storeCapacity
} }
/**
var allstoragecontainers = Game.rooms[name].find(FIND_STRUCTURES, {filter: (s) => {return ( s.structureType == STRUCTURE_STORAGE)}})
var storagecontainerusedstorage = 0
var storagecontainercapacity=0
for(var i=0; i < allcontainers.length;i++){
storagecontainerusedstorage+=_.sum(allstoragecontainers[i].store)
storagecontainercapacity+=allstoragecontainers[i].storeCapacity
}
if()
console.log(storagecontainerusedstorage + ':' + storagecontainercapacity)
**/
Game.rooms[name].memory.storagepercent = usedstorage/mycapacity Game.rooms[name].memory.storagepercent = usedstorage/mycapacity
Game.rooms[name].memory.containerstoragepercent = containerusedstorage/containercapacity Game.rooms[name].memory.containerstoragepercent = containerusedstorage/containercapacity
if(!(Game.rooms[name].memory.containerstoragepercent >-.1)){Game.rooms[name].memory.containerstoragepercent=0}
console.log('-------') console.log('-------')
console.log('Room "'+name+'" has '+roomenergy+' energy : Using ' + usedstorage + ' of ' + mycapacity + ', ' + Game.rooms[name].memory.storagepercent * 100 + '% Storage, ' + containerusedstorage + ' of ' + containercapacity + ':' + Game.rooms[name].memory.containerstoragepercent *100+ '% in containers') console.log('Room "'+name+'" has '+roomenergy+' energy : Using ' + usedstorage + ' of ' + mycapacity + ', ' + Game.rooms[name].memory.storagepercent * 100 + '% Storage, ' + containerusedstorage + ' of ' + containercapacity + ':' + Game.rooms[name].memory.containerstoragepercent *100+ '% in containers')
} catch(e){} } catch(e){}
if(Game.rooms[name].memory.maxbuilders == undefined){ Game.rooms[name].memory.maxbuilders =0 } if(Game.rooms[name].memory.CreepNum == undefined){Game.rooms[name].memory.CreepNum=0}
if(Game.rooms[name].memory.maxupgraders == undefined){ Game.rooms[name].memory.maxupgraders = 0 } if(Game.rooms[name].memory.minbuildpct == undefined){Game.rooms[name].memory.minbuildpct=.5}
if(Game.rooms[name].memory.maxminers == undefined){ Game.rooms[name].memory.maxminers = 0 } if(Game.rooms[name].memory.minupgradepct == undefined){Game.rooms[name].memory.minupgradepct=.5}
if(Game.rooms[name].memory.maxhaulers == undefined){ Game.rooms[name].memory.maxhaulers = 0 } if(Game.rooms[name].memory.minrepairpct == undefined){Game.rooms[name].memory.minrepairpct=.5}
if(Game.rooms[name].memory.maxhauler2s == undefined){ Game.rooms[name].memory.maxhauler2s = 0 } if(Game.rooms[name].memory.maxbuilders == undefined){ Game.rooms[name].memory.maxbuilders =1 }
if(Game.rooms[name].memory.maxnrbuilders == undefined){ Game.rooms[name].memory.maxnrbuilders =0 }
if(Game.rooms[name].memory.maxclaimers == undefined){ Game.rooms[name].memory.maxclaimers =0 }
if(Game.rooms[name].memory.maxupgraders == undefined){ Game.rooms[name].memory.maxupgraders = 2 }
if(Game.rooms[name].memory.maxminers == undefined){ Game.rooms[name].memory.maxminers = 2 }
if(Game.rooms[name].memory.maxminer2s == undefined){ Game.rooms[name].memory.maxminer2s = 0 }
if(Game.rooms[name].memory.maxnrminers == undefined){ Game.rooms[name].memory.maxnrminers = 0 }
if(Game.rooms[name].memory.maxhaulers == undefined){ Game.rooms[name].memory.maxhaulers = 2 }
if(Game.rooms[name].memory.maxhauler2s == undefined){ Game.rooms[name].memory.maxhauler2s = 1 }
if(Game.rooms[name].memory.maxhauler3s == undefined){ Game.rooms[name].memory.maxhauler3s = 0 }
if(Game.rooms[name].memory.maxwarriors == undefined){ Game.rooms[name].memory.maxwarriors = 0 } if(Game.rooms[name].memory.maxwarriors == undefined){ Game.rooms[name].memory.maxwarriors = 0 }
if(Game.rooms[name].memory.maxtowerrechargers == undefined){ Game.rooms[name].memory.maxtowerrechargers = 0 } if(Game.rooms[name].memory.maxtowerrechargers == undefined){ Game.rooms[name].memory.maxtowerrechargers = 0 }
if(Game.rooms[name].memory.maxharvesters == undefined){ Game.rooms[name].memory.maxharvesters = 0 } if(Game.rooms[name].memory.maxharvesters == undefined){ Game.rooms[name].memory.maxharvesters = 0 }
@ -82,27 +82,33 @@ module.exports.loop = function () {
if(Game.rooms[name].memory.hauler2parky==undefined){Game.rooms[name].memory.hauler2parky=24} if(Game.rooms[name].memory.hauler2parky==undefined){Game.rooms[name].memory.hauler2parky=24}
if(Game.rooms[name].memory.upgraderparkx==undefined){Game.rooms[name].memory.upgraderparkx=24} if(Game.rooms[name].memory.upgraderparkx==undefined){Game.rooms[name].memory.upgraderparkx=24}
if(Game.rooms[name].memory.upgraderparky==undefined){Game.rooms[name].memory.upgraderparky=24} if(Game.rooms[name].memory.upgraderparky==undefined){Game.rooms[name].memory.upgraderparky=24}
if(Game.rooms[name].memory.warriorparkx==undefined){Game.rooms[name].memory.warriorparkx=15}
roleBuilder.spawn(name) if(Game.rooms[name].memory.warriorparky==undefined){Game.rooms[name].memory.warriorparky=34}
roleMiner.spawn(name) processSpawns.tick(name)
roleHauler.spawn(name) minerals.tick(name)
roleHauler2.spawn(name) }
roleUpgrader.spawn(name) let mycreeps = Game.creeps
roleTowerrecharger.spawn(name)
roleRepairbot.spawn(name)
let mycreeps = Game.rooms[name].find(FIND_MY_CREEPS)
for(let mycreep in mycreeps){ for(let mycreep in mycreeps){
try{ try{
let creep = mycreeps[mycreep] let creep = mycreeps[mycreep]
if(creep.memory.role == 'miner'){ if(creep.memory.role == 'miner'){
roleMiner.run(creep) roleMiner.run(creep)
} }
if(creep.memory.role=='miner2'){
roleMiner2.run(creep)
}
if(creep.memory.role == 'claimer'){
roleClaimer.run(creep)
}
if(creep.memory.role == 'hauler'){ if(creep.memory.role == 'hauler'){
roleHauler.run(creep) roleHauler.run(creep)
} }
if(creep.memory.role == 'hauler2'){ if(creep.memory.role == 'hauler2'){
roleHauler2.run(creep) roleHauler2.run(creep)
} }
if(creep.memory.role == 'hauler3'){
roleHauler3.run(creep)
}
if(creep.memory.role == 'builder'){ if(creep.memory.role == 'builder'){
roleBuilder.run(creep) roleBuilder.run(creep)
} }
@ -115,12 +121,19 @@ module.exports.loop = function () {
if(creep.memory.role == 'repairbot'){ if(creep.memory.role == 'repairbot'){
roleRepairbot.run(creep) roleRepairbot.run(creep)
} }
if(creep.memory.role=='warrior'){
roleWarrior.run(creep)
}
if(creep.memory.role=='nrbuilder'){
rolenrBuilder.run(creep)
}
if(creep.memory.role=='nrminer'){
rolenrMiner.run(creep)
}
} catch (e) { } catch (e) {
//console.log(e.toString) //console.log(e.toString)
} }
} }
}
console.log('----END---') console.log('----END---')
} }

22
mineralprocessing.js Normal file
View File

@ -0,0 +1,22 @@
let assignMiner2s = {
tick: function(roomname) {
let sources = Game.rooms[roomname].find(FIND_MINERALS);
for(let source of sources){
let allminers = _.filter(Game.rooms[roomname].find(FIND_MY_CREEPS), (creep) => creep.memory.role=='miner2' );
let unassignedminers = _.filter(allminers, (creep) => (creep.memory.destsource == undefined && creep.memory.role=='miner2'));
let assignedminers = _.filter(allminers, (creep) => (creep.memory.destsource != undefined && creep.memory.role=='miner2'));
let myminers = _.filter(allminers, (creep) => (creep.memory.destsource != undefined && creep.memory.destsource.id==source.id && creep.memory.role=='miner'));
let sourcecount = sources.length
let persrc = allminers.length / sourcecount
console.log('My Assigned miner2s: ' +myminers.length + ' Max per source:' + persrc + ' Total Miner2s:' + allminers.length + ' Total Sources:' + sourcecount + ' Unassigned Miners:' + unassignedminers.length)
if(unassignedminers.length > 0){
if(myminers.length >= persrc){
//break;
} else {
unassignedminers[0].memory.destsource = source
}
}
}
}
};
module.exports = assignMiner2s;

38
role.builder.js
View File

@ -1,3 +1,4 @@
let buildparts=require('bodypartbuilder')
let roleBuilder = { let roleBuilder = {
run: function(creep) { run: function(creep) {
if(creep.memory.originroom === undefined){ if(creep.memory.originroom === undefined){
@ -13,35 +14,39 @@ let roleBuilder = {
} }
if(creep.memory.building) { if(creep.memory.building) {
if(creep.memory.buildsite==undefined|| Game.getObjectById(creep.memory.buildsite.id) == undefined){ if(creep.memory.buildsite==undefined|| Game.getObjectById(creep.memory.buildsite.id) == undefined){
creep.memory.buildsite = Game.rooms[creep.memory.originroom].find(FIND_CONSTRUCTION_SITES)[0]; creep.memory.buildsite = Game.rooms[creep.memory.originroom].find(FIND_CONSTRUCTION_SITES)[0];
} }
let target = Game.getObjectById(creep.memory.buildsite.id) let target = Game.getObjectById(creep.memory.buildsite.id)
//Check next room as well
if(target) { if(target) {
if(Game.rooms[creep.memory.originroom].memory.containerstoragepercent > -.5 ){
if(creep.room.memory.containerstoragepercent > creep.room.memory.minbuildpct || creep.room.memory.containerstoragepercent === undefined ){
if(creep.build(target) == ERR_NOT_IN_RANGE) { if(creep.build(target) == ERR_NOT_IN_RANGE) {
creep.moveTo(target); creep.moveTo(target);
if(creep.fatigue<1){ if(creep.fatigue<1){
creep.say("MTCS"); creep.say("MTCS");
} else { creep.say("Tired")} } else { creep.say("Tired")}
} }
} }else {
creep.say(creep.room.memory.containerstoragepercent + ' parking1')
creep.moveTo(creep.room.memory.builderparkx,creep.room.memory.builderparky,creep.room.roomName)
}
} else { } else {
creep.say('parking') creep.say('parking2')
creep.moveTo(Game.rooms[creep.memory.originroom].memory.builderparkx,Game.rooms[creep.memory.originroom].memory.builderparky,creep.memory.originroom) creep.moveTo(creep.room.memory.builderparkx,creep.room.memory.builderparky,creep.room.roomName)
} }
} }
else { else {
let containers =Game.rooms[creep.memory.originroom].find(FIND_STRUCTURES, { let containers =Game.rooms[creep.memory.originroom].find(FIND_STRUCTURES, {
filter: (structure) => {return ((structure.structureType == STRUCTURE_CONTAINER|| structure.structureType == STRUCTURE_STORAGE) && structure.store[RESOURCE_ENERGY] > 0) ;}}); filter: (structure) => {return ((structure.structureType == STRUCTURE_CONTAINER||structure.structureType == STRUCTURE_TERMINAL || structure.structureType == STRUCTURE_STORAGE) && structure.store[RESOURCE_ENERGY] > 0) ;}});
let allcontainers = creep.room.find(FIND_STRUCTURES, { let allcontainers = creep.room.find(FIND_STRUCTURES, {
filter: (structure) => { filter: (structure) => {
return (structure.structureType == STRUCTURE_CONTAINER ) ; return (structure.structureType == STRUCTURE_CONTAINER || structure.structureType == STRUCTURE_STORAGE ) ;
}}); }});
let sources = Game.rooms[creep.memory.originroom].find(FIND_SOURCES); let droppedenergy = creep.pos.findClosestByRange(FIND_DROPPED_RESOURCES, {filter: {resourceType: RESOURCE_ENERGY}});
let droppedenergy = creep.pos.findClosestByRange(FIND_DROPPED_ENERGY ); //find(FIND_DROPPED_RESOURCES, {filter: r => r.resourceType === RESOURCE_ENERGY}) is another option
if(containers==0){ if(allcontainers.length==0){
if(creep.pickup(droppedenergy) == ERR_NOT_IN_RANGE) { if(creep.pickup(droppedenergy) == ERR_NOT_IN_RANGE) {
creep.say("MTDE"); creep.say("MTDE");
creep.moveTo(droppedenergy); creep.moveTo(droppedenergy);
@ -54,19 +59,6 @@ let roleBuilder = {
} }
} }
},
spawn: function(roomname){
let myspawns=Game.rooms[roomname].find(FIND_MY_SPAWNS)
let myroom = Game.rooms[roomname]
for(let spawn of myspawns){
let myrole='builder';
let myroles = _.filter(Game.creeps, (creep) => { return ((creep.memory.role == myrole) && (creep.memory.originroom == roomname))});
console.log(myrole + 's: ' + myroles.length + ' Needed: ' + Game.rooms[roomname].memory['max'+myrole+'s']);
if(myroles.length < Game.rooms[roomname].memory['max'+myrole+'s']) {
let newName = spawn.createCreep([MOVE,WORK,CARRY], undefined, {role: myrole});
console.log('Spawning new ' + myrole + ': ' + newName);
}
}
} }
}; };
module.exports = roleBuilder; module.exports = roleBuilder;

21
role.claimer.js Normal file
View File

@ -0,0 +1,21 @@
let roleClaimer = {
run: function(creep) {
if(creep.memory.originroom === undefined){
creep.memory.originroom = creep.room.name
}
//let mycontroller= creep.room.find(STRUCTURE_CONTROLLER)
if(!creep.room.controller.my){
creep.say('claiming')
if(creep.claimController(creep.room.controller) == ERR_NOT_IN_RANGE) {
creep.moveTo(creep.room.controller);
}
} else if(Game.flags.claim){
creep.say('claim')
creep.moveTo(Game.flags.claim)
} else{
creep.say('parking')
creep.moveTo(creep.room.memory.claimerparkx,creep.room.memory.claimerparky,creep.room)
}
}
};
module.exports = roleClaimer;

68
role.hauler.js
View File

@ -1,45 +1,43 @@
let buildparts=require('bodypartbuilder')
let roleHauler = { let roleHauler = {
run: function(creep) { run: function(creep) {
let spawntargets = creep.pos.findClosestByPath(FIND_STRUCTURES, {
filter: (structure) => {
return (((structure.structureType == STRUCTURE_EXTENSION || structure.structureType == STRUCTURE_SPAWN) && structure.energy < structure.energyCapacity))
}
});
let containertargets = creep.pos.findClosestByRange(FIND_STRUCTURES, {
filter: (structure) => {
return ((structure.structureType == STRUCTURE_CONTAINER ) && _.sum(structure.store) < structure.storeCapacity) ;
}
});
let storagetargets = creep.pos.findClosestByRange(FIND_STRUCTURES, {
filter: (structure) => {
return ((structure.structureType == STRUCTURE_STORAGE || structure.structureType == STRUCTURE_TERMINAL ) && _.sum(structure.store) < structure.storeCapacity) ;
}
});
if(creep.memory.originroom === undefined){ if(creep.memory.originroom === undefined){
creep.memory.originroom = creep.room.name creep.memory.originroom = creep.room.name
} }
if(creep.memory.hauling == undefined){creep.memory.hauling=false} if(creep.memory.hauling == undefined){creep.memory.hauling=false}
if(creep.memory.hauling && creep.carry.energy == 0) { if(creep.memory.hauling && _.sum(creep.carry) == 0) {
creep.memory.destsource=undefined creep.memory.destsource=undefined
creep.memory.hauling = false; creep.memory.hauling = false;
creep.say('gathering'); creep.say('gathering');
} }
if(!creep.memory.hauling && creep.carry.energy == creep.carryCapacity) { if(!creep.memory.hauling && _.sum(creep.carry) == creep.carryCapacity) {
creep.memory.hauling = true; creep.memory.hauling = true;
creep.say('hauling'); creep.say('hauling');
} }
let sources = creep.pos.findClosestByRange(FIND_DROPPED_ENERGY ); let sources = creep.pos.findClosestByRange(FIND_DROPPED_RESOURCES, {filter: {resourceType: RESOURCE_ENERGY}} || STRUCTURE_TERMINAL );
if(creep.memory.hauling==false){ if(creep.memory.hauling==false){
if(Game.getObjectById(creep.memory.destsource.id)==undefined){creep.memory.destsource=undefined} if(Game.getObjectById(creep.memory.destsource.id)==undefined){creep.memory.destsource=undefined}
let mysource=Game.getObjectById(creep.memory.destsource.id) let mysource=Game.getObjectById(creep.memory.destsource.id)
if(creep.pickup(mysource) == ERR_NOT_IN_RANGE && creep.carryCapacity > _.sum(creep.carry)) {
if(creep.pickup(mysource) == ERR_NOT_IN_RANGE && creep.carryCapacity > creep.carry.energy) {
creep.moveTo(mysource); creep.moveTo(mysource);
} }
} else { } else {
if(sources != undefined ) if(sources != undefined ) {
{ let spawntargets = creep.pos.findClosestByPath(FIND_STRUCTURES, {
filter: (structure) => {
return ((structure.structureType == STRUCTURE_EXTENSION || structure.structureType == STRUCTURE_SPAWN) && structure.energy < structure.energyCapacity)
}
});
let containertargets = creep.pos.findClosestByRange(FIND_STRUCTURES, {
filter: (structure) => {
return ((structure.structureType == STRUCTURE_CONTAINER ) && _.sum(structure.store) < structure.storeCapacity) ;
}
});
let storagetargets = creep.pos.findClosestByRange(FIND_STRUCTURES, {
filter: (structure) => {
return ((structure.structureType == STRUCTURE_STORAGE ) && _.sum(structure.store) < structure.storeCapacity) ;
}
});
if(spawntargets) { if(spawntargets) {
if(creep.transfer(spawntargets, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) { if(creep.transfer(spawntargets, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
creep.moveTo(spawntargets); creep.moveTo(spawntargets);
@ -48,26 +46,18 @@ let roleHauler = {
if(creep.transfer(containertargets, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) { if(creep.transfer(containertargets, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
creep.moveTo(containertargets); creep.moveTo(containertargets);
} }
} else { } else {
if(creep.transfer(storagetargets, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) { if(creep.transfer(storagetargets, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
creep.moveTo(storagetargets); creep.moveTo(storagetargets);
} }
}
}
if(creep.carry.RESOURCE_ZYNTHIUM > 0){
if(creep.transfer(storagetargets, RESOURCE_ZYNTHIUM) == ERR_NOT_IN_RANGE) {
creep.moveTo(storagetargets);
} }
} }
} }
},
spawn: function(roomname){
let myspawns=Game.rooms[roomname].find(FIND_MY_SPAWNS)
let myroom = Game.rooms[roomname]
for(let spawn of myspawns){
let myrole='hauler';
let myroles = _.filter(Game.creeps, (creep) => creep.memory.role == myrole && creep.memory.originroom == roomname);
console.log(myrole + 's: ' + myroles.length + ' Needed: ' + Game.rooms[roomname].memory['max'+myrole+'s']);
if(myroles.length < Game.rooms[roomname].memory['max'+myrole+'s']) {
let newName = spawn.createCreep([CARRY,CARRY,CARRY,CARRY,CARRY,CARRY,MOVE,MOVE,MOVE,MOVE], undefined, {role: myrole});
console.log('Spawning new ' + myrole + ': ' + newName);
}
}
} }
}; };
module.exports = roleHauler; module.exports = roleHauler;

20
role.hauler2.js
View File

@ -1,6 +1,5 @@
let buildparts=require('bodypartbuilder')
let roleHauler2 = { let roleHauler2 = {
/** @param {Creep} creep **/
run: function(creep) { run: function(creep) {
if(creep.memory.originroom === undefined){ if(creep.memory.originroom === undefined){
creep.memory.originroom = creep.room.name creep.memory.originroom = creep.room.name
@ -28,7 +27,7 @@
} else { } else {
let spawntarget = creep.pos.findClosestByRange(FIND_STRUCTURES, { let spawntarget = creep.pos.findClosestByRange(FIND_STRUCTURES, {
filter: (structure) => { filter: (structure) => {
return ((structure.structureType == STRUCTURE_EXTENSION || structure.structureType == STRUCTURE_SPAWN) &&structure.energy < structure.energyCapacity) return ((structure.structureType == STRUCTURE_EXTENSION || structure.structureType == STRUCTURE_SPAWN) && structure.energy < structure.energyCapacity)
} }
}); });
if(spawntarget != undefined) { if(spawntarget != undefined) {
@ -41,19 +40,6 @@
creep.moveTo(creep.room.memory.hauler2parkx,creep.room.memory.hauler2parky,creep.room.roomName) creep.moveTo(creep.room.memory.hauler2parkx,creep.room.memory.hauler2parky,creep.room.roomName)
} }
} }
}, }
spawn: function(roomname){
let myspawns=Game.rooms[roomname].find(FIND_MY_SPAWNS)
let myroom = Game.rooms[roomname]
for(let spawn of myspawns){
let myrole='hauler2';
let myroles = _.filter(Game.creeps, (creep) => creep.memory.role == myrole && creep.memory.originroom == roomname);
console.log(myrole + 's: ' + myroles.length + ' Needed: ' + Game.rooms[roomname].memory['max'+myrole+'s']);
if(myroles.length < Game.rooms[roomname].memory['max'+myrole+'s']) {
let newName = spawn.createCreep([CARRY,CARRY,CARRY,MOVE,MOVE], undefined, {role: myrole});
console.log('Spawning new ' + myrole + ': ' + newName);
}
}
}
}; };
module.exports = roleHauler2; module.exports = roleHauler2;

14
role.miner.js
View File

@ -1,3 +1,4 @@
let buildparts=require('bodypartbuilder')
let roleMiner = { let roleMiner = {
run: function(creep) { run: function(creep) {
if(creep.memory.originroom === undefined){ if(creep.memory.originroom === undefined){
@ -8,19 +9,6 @@ let roleMiner = {
if(creep.harvest(mysource) == ERR_NOT_IN_RANGE) { if(creep.harvest(mysource) == ERR_NOT_IN_RANGE) {
creep.moveTo(mysource); creep.moveTo(mysource);
} }
},
spawn: function(roomname){
let myspawns=Game.rooms[roomname].find(FIND_MY_SPAWNS)
let myroom = Game.rooms[roomname]
for(let spawn of myspawns){
let myrole='miner';
let myroles = _.filter(Game.creeps, (creep) => creep.memory.role == myrole && creep.memory.originroom == roomname);
console.log(myrole + 's: ' + myroles.length + ' Needed: ' + Game.rooms[roomname].memory['max'+myrole+'s']);
if(myroles.length < Game.rooms[roomname].memory['max'+myrole+'s']) {
let newName = spawn.createCreep([WORK,WORK,WORK,WORK,WORK,MOVE], undefined, {role: myrole});
console.log('Spawning new ' + myrole + ': ' + newName);
}
}
} }
}; };
module.exports = roleMiner; module.exports = roleMiner;

13
role.miner2.js Normal file
View File

@ -0,0 +1,13 @@
let roleMiner2 = {
run: function(creep) {
if(creep.memory.originroom === undefined){
creep.memory.originroom = creep.room.name
}
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);
}
}
};
module.exports = roleMiner2;

33
role.mineralhauler.js Normal file
View File

@ -0,0 +1,33 @@
let roleHauler = {
run: function(creep) {
if(creep.memory.originroom === undefined){
creep.memory.originroom = creep.room.name
}
if(creep.memory.hauling == undefined){creep.memory.hauling=false}
if(creep.memory.hauling && creep.carry.energy == 0) {
creep.memory.destsource=undefined
creep.memory.hauling = false;
creep.say('gathering');
}
if(!creep.memory.hauling && _.sum(creep.carry) == creep.carryCapacity) {
creep.memory.hauling = true;
creep.say('hauling');
}
if(creep.memory.hauling==false){
if(Game.getObjectById(creep.memory.destsource.id)==undefined){creep.memory.destsource=undefined}
let mysource=Game.getObjectById(creep.memory.destsource.id)
if(creep.pickup(mysource) == ERR_NOT_IN_RANGE && creep.carryCapacity > _.sum(creep.carry)) {
creep.moveTo(mysource);
}
} else {
let storagetargets = creep.pos.findClosestByRange(FIND_STRUCTURES, {
filter: (structure) => {return ((structure.structureType == STRUCTURE_TERMINAL ) && _.sum(structure.store) < structure.storeCapacity);}});
for(let resource in creep.carry){
if(creep.transfer(storagetargets, resource) == ERR_NOT_IN_RANGE) {
creep.moveTo(storagetargets);
}
}
}
}
};
module.exports = roleHauler;

60
role.nrbuilder.js Normal file
View File

@ -0,0 +1,60 @@
let rolenrBuilder = {
run: function(creep) {
if(creep.memory.building && creep.carry.energy == 0) {
creep.memory.building = false;
creep.say('Gathering');
}
if(!creep.memory.building && creep.carry.energy == creep.carryCapacity) {
creep.memory.building = true;
creep.say('building');
}
if(Game.flags.nrbuild.room == creep.room){
if(creep.memory.originroom === undefined){
creep.memory.originroom = creep.room.name
creep.memory.role = 'builder'
}
if(creep.memory.building) {
if(creep.memory.buildsite==undefined|| Game.getObjectById(creep.memory.buildsite.id) == undefined){
creep.memory.buildsite = creep.room.find(FIND_CONSTRUCTION_SITES)[0];
}
let target = Game.getObjectById(creep.memory.buildsite.id)
if(target) {
if(creep.build(target) == ERR_NOT_IN_RANGE) {
creep.moveTo(target);
if(creep.fatigue<1){
creep.say("MTCS");
} else { creep.say("Tired")}
}
} else {
creep.say('parking')
creep.moveTo(creep.room.memory.builderparkx,creep.room.memory.builderparky,creep.room.roomName)
}
}
else {
let containers =creep.room.find(FIND_STRUCTURES, {
filter: (structure) => {return ((structure.structureType == STRUCTURE_CONTAINER|| structure.structureType == STRUCTURE_STORAGE) && structure.store[RESOURCE_ENERGY] > 0) ;}});
let allcontainers = creep.room.find(FIND_STRUCTURES, {
filter: (structure) => {
return (structure.structureType == STRUCTURE_CONTAINER || structure.structureType == STRUCTURE_STORAGE ) ;
}});
let droppedenergy = creep.pos.findClosestByRange(FIND_DROPPED_RESOURCES, {filter: {resourceType: RESOURCE_ENERGY}});
if(containers.length==0){
if(creep.pickup(droppedenergy) == ERR_NOT_IN_RANGE) {
creep.say("MTDE");
creep.moveTo(droppedenergy);
}
} else {
if(creep.withdraw(containers[0],RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
creep.say("MTSC");
creep.moveTo(containers[0]);
}
}
}
} else {
creep.moveTo(Game.flags.nrbuild)
}
}
};
module.exports = rolenrBuilder;

25
role.nrminer.js Normal file
View File

@ -0,0 +1,25 @@
let assignMiners=require('sproc')
let rolenrMiner = {
run: function(creep) {
if(Game.flags.nrbuild.room == creep.room){
if(creep.memory.destsource==undefined){
creep.memory.role='miner'
assignMiners(creep.roomName)
}
if(creep.memory.originroom === undefined){
creep.memory.originroom = creep.room.name
creep.moveTo(Game.flags.nrbuild)
creep.memory.role='miner'
}
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);
}
} else {
creep.moveTo(Game.flags.nrbuild)
}
}
};
module.exports = rolenrMiner;

18
role.recharger.js
View File

@ -1,6 +1,5 @@
let buildparts=require('bodypartbuilder')
let roleTowerrecharger = { let roleTowerrecharger = {
/** @param {Creep} creep **/
run: function(creep) { run: function(creep) {
if(creep.memory.originroom === undefined){ if(creep.memory.originroom === undefined){
creep.memory.originroom = creep.room.name creep.memory.originroom = creep.room.name
@ -35,19 +34,6 @@
} }
} }
} }
}, }
spawn: function(roomname){
let myspawns=Game.rooms[roomname].find(FIND_MY_SPAWNS)
let myroom = Game.rooms[roomname]
for(let spawn of myspawns){
let myrole='towerrecharger';
let myroles = _.filter(Game.creeps, (creep) => creep.memory.role == myrole && creep.memory.originroom == roomname);
console.log(myrole + 's: ' + myroles.length + ' Needed: ' + Game.rooms[roomname].memory['max'+myrole+'s']);
if(myroles.length < Game.rooms[roomname].memory['max'+myrole+'s']) {
let newName = spawn.createCreep([CARRY,CARRY,CARRY,MOVE,MOVE], undefined, {role: myrole});
console.log('Spawning new ' + myrole + ': ' + newName);
}
}
}
}; };
module.exports = roleTowerrecharger; module.exports = roleTowerrecharger;

29
role.repairbot.js
View File

@ -1,6 +1,5 @@
let buildparts=require('bodypartbuilder')
let roleRepairbot = { let roleRepairbot = {
/** @param {Creep} creep **/
run: function(creep) { run: function(creep) {
if(creep.memory.originroom === undefined){ if(creep.memory.originroom === undefined){
creep.memory.originroom = creep.room.name creep.memory.originroom = creep.room.name
@ -24,16 +23,20 @@ let roleRepairbot = {
creep.moveTo(container); creep.moveTo(container);
} }
} else { } else {
if(Game.rooms[creep.memory.originroom].memory.containerstoragepercent > .7 || !(Game.rooms[creep.memory.originroom].memory.containerstoragepercent)){
let importantstructures = creep.room.find(FIND_STRUCTURES, { let importantstructures = creep.room.find(FIND_STRUCTURES, {
filter: (structure) => { filter: (structure) => {
return (structure.structureType == STRUCTURE_CONTAINER && structure.hits < structure.hitsMax) ; return ((structure.structureType == STRUCTURE_CONTAINER || structure.structureType==STRUCTURE_RAMPART) && structure.hits < structure.hitsMax) ;
}}); }});
importantstructures = _.sortBy(importantstructures, (s)=>s.hits / s.hitsMax) importantstructures = _.sortBy(importantstructures, (s)=>s.hits / s.hitsMax)
if(importantstructures.length > 0){ if(importantstructures.length > 0){
if(creep.repair(importantstructures[0]) == ERR_NOT_IN_RANGE){ if(Game.rooms[creep.memory.originroom].memory.containerstoragepercent > .5 || !(Game.rooms[creep.memory.originroom].memory.containerstoragepercent)){
creep.moveTo(importantstructures[0]) if(creep.repair(importantstructures[0]) == ERR_NOT_IN_RANGE){
creep.moveTo(importantstructures[0])
}
} }
} else { } else {
if(Game.rooms[creep.memory.originroom].memory.containerstoragepercent > .7 || !(Game.rooms[creep.memory.originroom].memory.containerstoragepercent)){
let damagedstructures = creep.room.find(FIND_STRUCTURES,{filter: (s) => s.hits < s.hitsMax}); let damagedstructures = creep.room.find(FIND_STRUCTURES,{filter: (s) => s.hits < s.hitsMax});
damagedstructures = _.sortBy(damagedstructures, (s)=>s.hits / s.hitsMax) damagedstructures = _.sortBy(damagedstructures, (s)=>s.hits / s.hitsMax)
if(damagedstructures.length>0){ if(damagedstructures.length>0){
@ -41,23 +44,11 @@ let roleRepairbot = {
creep.moveTo(damagedstructures[0]) creep.moveTo(damagedstructures[0])
} }
} }
}
} }
}
},
spawn: function(roomname){
let myspawns=Game.rooms[roomname].find(FIND_MY_SPAWNS)
let myroom = Game.rooms[roomname]
for(let spawn of myspawns){
let myrole='repairbot';
let myroles = _.filter(Game.creeps, (creep) => creep.memory.role == myrole && creep.memory.originroom == roomname);
console.log(myrole + 's: ' + myroles.length + ' Needed: ' + Game.rooms[roomname].memory['max'+myrole+'s']);
if(myroles.length < Game.rooms[roomname].memory['max'+myrole+'s']) {
let newName = spawn.createCreep([WORK,CARRY,MOVE], undefined, {role: myrole});
console.log('Spawning new ' + myrole + ': ' + newName);
} }
} }
} }
}; };
module.exports = roleRepairbot; module.exports = roleRepairbot;

36
role.upgrader.js
View File

@ -1,3 +1,4 @@
let buildparts=require('bodypartbuilder')
let roleUpgrader = { let roleUpgrader = {
run: function(creep) { run: function(creep) {
if(creep.memory.originroom === undefined){ if(creep.memory.originroom === undefined){
@ -13,7 +14,7 @@ let roleUpgrader = {
creep.say('upgrading'); creep.say('upgrading');
} }
if(creep.memory.upgrading) { if(creep.memory.upgrading) {
if(creep.room.memory.containerstoragepercent>.6){ if(creep.room.memory.containerstoragepercent>creep.room.memory.minupgradepct || !(creep.room.memory.containerstoragepercent) ){
if(creep.upgradeController(creep.room.controller) == ERR_NOT_IN_RANGE) { if(creep.upgradeController(creep.room.controller) == ERR_NOT_IN_RANGE) {
creep.say('MTRC') creep.say('MTRC')
creep.moveTo(creep.room.controller); creep.moveTo(creep.room.controller);
@ -25,33 +26,24 @@ let roleUpgrader = {
filter: (structure) => { filter: (structure) => {
return ((structure.structureType == STRUCTURE_CONTAINER|| structure.structureType == STRUCTURE_STORAGE) && structure.store[RESOURCE_ENERGY] > 0) ; return ((structure.structureType == STRUCTURE_CONTAINER|| structure.structureType == STRUCTURE_STORAGE) && structure.store[RESOURCE_ENERGY] > 0) ;
}}); }});
if(container){ let allcontainers = creep.room.find(FIND_STRUCTURES, {
filter: (structure) => {
if(creep.withdraw(container,RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) { return (structure.structureType == STRUCTURE_CONTAINER || structure.structureType == STRUCTURE_STORAGE ) ;
creep.say("MTSC"); }});
creep.moveTo(container); if(allcontainers.length==0){
} let droppedenergy = creep.room.find(FIND_DROPPED_RESOURCES, {filter: {resourceType: RESOURCE_ENERGY}});
}else{
let droppedenergy = creep.room.find(FIND_DROPPED_ENERGY );
if(creep.pickup(droppedenergy[0]) == ERR_NOT_IN_RANGE) { if(creep.pickup(droppedenergy[0]) == ERR_NOT_IN_RANGE) {
creep.say("MTDE"); creep.say("MTDE");
creep.moveTo(droppedenergy[0]); creep.moveTo(droppedenergy[0]);
} }
}else{
if(creep.withdraw(container,RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
creep.say("MTSC");
creep.moveTo(container);
}
} }
} }
},
spawn: function(roomname){
let myspawns=Game.rooms[roomname].find(FIND_MY_SPAWNS)
let myroom = Game.rooms[roomname]
for(let spawn of myspawns){
let myrole='upgrader';
let myroles = _.filter(Game.creeps, (creep) => creep.memory.role == myrole && creep.memory.originroom == roomname);
console.log(myrole + 's: ' + myroles.length + ' Needed: ' + Game.rooms[roomname].memory['max'+myrole+'s']);
if(myroles.length < Game.rooms[roomname].memory['max'+myrole+'s']) {
let newName = spawn.createCreep([MOVE,MOVE,WORK,WORK,WORK,CARRY,CARRY,CARRY], undefined, {role: myrole});
console.log('Spawning new ' + myrole + ': ' + newName);
}
}
} }
}; };
module.exports = roleUpgrader; module.exports = roleUpgrader;

25
role.warrior.js Normal file
View File

@ -0,0 +1,25 @@
let roleWarrior = {
run: function(creep) {
var hostile = creep.pos.findClosestByRange(FIND_HOSTILE_CREEPS);
var hostilebuilding = creep.pos.findClosestByRange(FIND_HOSTILE_STRUCTURES||FIND_HOSTILE_SPAWNS );
if(hostile!=undefined) {
creep.say('Sorry')
creep.moveTo(hostile);
creep.attack(hostile);
} else if(hostilebuilding!=undefined){
creep.say('Sorry')
creep.moveTo(hostilebuilding);
creep.attack(hostilebuilding);
}else if(Game.flags.Attack) {
creep.say('ATK')
creep.moveTo(Game.flags.Attack)
} else{
creep.say('parking')
creep.moveTo(creep.room.memory.warriorparkx,creep.room.memory.warriorparky,creep.room.roomName)
}
}
};
module.exports = roleWarrior;

5
sourceprocessing.js
View File

@ -1,6 +1,9 @@
let runSources = { let runSources = {
tick: function(roomname) { tick: function(roomname) {
let sources = Game.rooms[roomname].find(FIND_DROPPED_ENERGY ); let sources = Game.rooms[roomname].find(
FIND_DROPPED_RESOURCES, {
filter: (mineral) => mineral.resourceType === RESOURCE_ENERGY
});
for(let source of sources){ for(let source of sources){
try{ try{
let allhaulers = _.filter(Game.rooms[roomname].find(FIND_MY_CREEPS), (creep) => creep.memory.role=='hauler' ); let allhaulers = _.filter(Game.rooms[roomname].find(FIND_MY_CREEPS), (creep) => creep.memory.role=='hauler' );

99
spawnprocessing.js Normal file
View File

@ -0,0 +1,99 @@
let buildparts=require('bodypartbuilder')
let processSpawns = {
tick: function(roomname) {
let myspawns=Game.rooms[roomname].find(FIND_MY_SPAWNS)
for(let spawn of myspawns){
if(spawn.spawning){spawn.memory.spawnqueued=true}else {spawn.memory.spawnqueued=false}
}
let energyready = Game.rooms[roomname].energyAvailable
let energymax = Game.rooms[roomname].energyCapacityAvailable
console.log(Game.rooms[roomname].memory.tickssincespawn)
console.log(energyready / energymax)
if(energyready==energymax || energyready / energymax > .5 ||Game.rooms[roomname].memory.tickssincespawn>50){
Game.rooms[roomname].memory.tickssincespawn=0
let allcreeps = _.filter(Game.rooms[roomname].find(FIND_MY_CREEPS));
let allbuilders = _.filter(allcreeps,(creep) => (creep.memory.role=='builder'))
let allminers = _.filter(allcreeps,(creep) => (creep.memory.role=='miner'))
let allminer2s = _.filter(allcreeps,(creep) => (creep.memory.role=='miner2'))
let allhaulers = _.filter(allcreeps,(creep) => (creep.memory.role=='hauler'))
let allhauler2s = _.filter(allcreeps,(creep) => (creep.memory.role=='hauler2'))
let allhauler3s = _.filter(allcreeps,(creep) => (creep.memory.role=='hauler3'))
let alltowerrechargers = _.filter(allcreeps,(creep) => (creep.memory.role=='towerrecharger'))
let allrepairbots = _.filter(allcreeps,(creep) => (creep.memory.role=='repairbot'))
let allupgraders = _.filter(allcreeps,(creep) => (creep.memory.role=='upgrader'))
let allwarriors = _.filter(allcreeps,(creep) => (creep.memory.role=='warrior'))
let allclaimers = _.filter(allcreeps,(creep) => (creep.memory.role=='claimer'))
let allnrbuilders = _.filter(allcreeps,(creep) => (creep.memory.role=='nrbuilder'))
let allnrminers = _.filter(allcreeps,(creep) => (creep.memory.role=='nrminer'))
//console.log(allcreeps.length + " " + allbuilders.length + " " + allminers.length + " " + allhaulers.length + " " + allhauler2s.length + " " + alltowerrechargers.length + " " + allrepairbots.length + " " + allupgraders.length + " " + allwarriors.length)
for(let spawn of myspawns){
if(!spawn.spawning && !spawn.memory.spawnqueued){
console.log('WOULD SPAWN AT '+ spawn.name)
//spawn.memory.spawnqueued=true
if(Game.rooms[roomname].memory.maxminers > allminers.length){
console.log('spawn miner')
buildparts.tick(roomname,'miner')
spawn.memory.spawnqueued=true
} else if(Game.rooms[roomname].memory.maxminer2s > allminer2s.length){
console.log('spawn miner2s')
buildparts.tick(roomname,'miner2')
spawn.memory.spawnqueued=true
} else if(Game.rooms[roomname].memory.maxhaulers > allhaulers.length){
console.log('spawn hauler')
buildparts.tick(roomname,'hauler')
spawn.memory.spawnqueued=true
}else if(Game.rooms[roomname].memory.maxhauler3s > allhauler3s.length){
console.log('spawn hauler3')
buildparts.tick(roomname,'hauler3')
spawn.memory.spawnqueued=true
}else if(Game.rooms[roomname].memory.maxupgraders > allupgraders.length){
console.log('spawn upgrader')
buildparts.tick(roomname,'upgrader')
spawn.memory.spawnqueued=true
} else if(Game.rooms[roomname].memory.maxhauler2s > allhauler2s.length){
console.log('spawn hauler2')
buildparts.tick(roomname,'hauler2')
spawn.memory.spawnqueued=true
} else if(Game.rooms[roomname].memory.maxtowerrechargers > alltowerrechargers.length){
console.log('spawn towerrecharger')
buildparts.tick(roomname,'towerrecharger')
spawn.memory.spawnqueued=true
} else if(Game.rooms[roomname].memory.maxrepairbots > allrepairbots.length){
console.log('spawn repairbot')
buildparts.tick(roomname,'repairbot')
spawn.memory.spawnqueued=true
}else if(Game.rooms[roomname].memory.maxbuilders > allbuilders.length){
console.log('spawn builder')
buildparts.tick(roomname,'builder')
spawn.memory.spawnqueued=true
} else if (Game.rooms[roomname].memory.maxwarriors > allwarriors.length){
console.log('spawn warrior')
buildparts.tick(roomname,'warrior')
} else if(Game.rooms[roomname].memory.maxclaimers > allclaimers.length){
console.log('spawn claimer')
buildparts.tick(roomname,'claimer')
} else if(Game.rooms[roomname].memory.maxnrbuilders > allnrbuilders.length){
console.log('spawn nrbuilder')
buildparts.tick(roomname,'nrbuilder')
} else if(Game.rooms[roomname].memory.maxnrminers > allnrminers.length){
console.log('spawn nrminer')
buildparts.tick(roomname,'nrminer')
} else {}
} else if (!spawn.spawning && spawn.memory.spawnqueued) {
spawn.memory.spawnqueued=false
console.log('clearing spawn queue')
} else if (spawn.spawning && !spawn.memory.spawnqueued){
spawn.memory.spawnqueued=true
}
}
}else{
if(Game.rooms[roomname].memory.tickssincespawn==undefined){Game.rooms[roomname].memory.tickssincespawn=1} else{
Game.rooms[roomname].memory.tickssincespawn++
}
}
}
};
module.exports = processSpawns;

2
sproc.js
View File

@ -1,7 +1,7 @@
let assignMiners = { let assignMiners = {
tick: function(roomname) { tick: function(roomname) {
let sources = Game.rooms[roomname].find(FIND_SOURCES ); let sources = Game.rooms[roomname].find(FIND_SOURCES );
for(var source of sources){ for(let source of sources){
let allminers = _.filter(Game.rooms[roomname].find(FIND_MY_CREEPS), (creep) => creep.memory.role=='miner' ); let allminers = _.filter(Game.rooms[roomname].find(FIND_MY_CREEPS), (creep) => creep.memory.role=='miner' );
let unassignedminers = _.filter(allminers, (creep) => (creep.memory.destsource == undefined && creep.memory.role=='miner')); let unassignedminers = _.filter(allminers, (creep) => (creep.memory.destsource == undefined && creep.memory.role=='miner'));
let assignedminers = _.filter(allminers, (creep) => (creep.memory.destsource != undefined && creep.memory.role=='miner')); let assignedminers = _.filter(allminers, (creep) => (creep.memory.destsource != undefined && creep.memory.role=='miner'));

95
tower.js
View File

@ -1,48 +1,49 @@
var towers = { var towers = {
/** @param {Game} game **/ /** @param {Game} game **/
tick: function(roomname) { tick: function(roomname) {
towers = Game.rooms[roomname].find(FIND_MY_STRUCTURES, { towers = Game.rooms[roomname].find(FIND_MY_STRUCTURES, {
filter: { structureType: STRUCTURE_TOWER } filter: { structureType: STRUCTURE_TOWER }
}) })
_.forEach(towers, function(tower){ _.forEach(towers, function(tower){
let myclosestDamagedStructure = tower.room.find(FIND_STRUCTURES, {
filter: (structure) => structure.structureType != STRUCTURE_WALL && structure.structureType != STRUCTURE_RAMPART && structure.hits < structure.hitsMax
let myclosestDamagedStructure = tower.room.find(FIND_STRUCTURES, { });
filter: (structure) => structure.structureType != STRUCTURE_WALL && structure.structureType != STRUCTURE_RAMPART && structure.hits < structure.hitsMax let closestDamagedStructure = _.first(_.sortBy(myclosestDamagedStructure, (s)=>s.hits / s.hitsMax));
});
let closestDamagedStructure = _.first(_.sortBy(myclosestDamagedStructure, (s)=>s.hits / s.hitsMax)); let allcontainers = tower.room.find(FIND_STRUCTURES, {
filter: (s) => {
let allcontainers = tower.room.find(FIND_STRUCTURES, { return ( s.structureType == STRUCTURE_CONTAINER)
filter: (s) => { }
return ( s.structureType == STRUCTURE_CONTAINER) });
} let closestHostile = tower.pos.findClosestByRange(FIND_HOSTILE_CREEPS);
}); if(closestHostile) {
if(tower.energy > tower.energyCapacity * .7 ){ tower.attack(closestHostile);
let importantstructures = tower.room.find(FIND_STRUCTURES, { } else
filter: (structure) => { {
return (structure.structureType == STRUCTURE_CONTAINER && structure.hits < structure.hitsMax) ; if(tower.energy > tower.energyCapacity * .7 ){
}}); let importantstructures = tower.room.find(FIND_STRUCTURES, {
importantstructures = _.sortBy(importantstructures, (s)=>s.hits / s.hitsMax) filter: (structure) => {
if(importantstructures.length > 0){ return (structure.structureType == STRUCTURE_CONTAINER && structure.hits < structure.hitsMax) ;
tower.repair(importantstructures[0]); }});
} else importantstructures = _.sortBy(importantstructures, (s)=>s.hits / s.hitsMax)
{ if(importantstructures.length > 0){
if(closestDamagedStructure) { tower.repair(importantstructures[0]);
if(Game.rooms[roomname].memory.containerstoragepercent > .8){ } else
console.log("tower repairing. Currently at: " + Game.rooms[roomname].memory.containerstoragepercent) {
tower.repair(closestDamagedStructure); if(closestDamagedStructure) {
} else { console.log("tower waiting for more storage. Currently at: " + Game.rooms[roomname].memory.containerstoragepercent)} if(Game.rooms[roomname].memory.containerstoragepercent > .8){
} console.log("tower repairing. Currently at: " + Game.rooms[roomname].memory.containerstoragepercent)
} tower.repair(closestDamagedStructure);
let closestHostile = tower.pos.findClosestByRange(FIND_HOSTILE_CREEPS); } else { console.log("tower waiting for more storage. Currently at: " + Game.rooms[roomname].memory.containerstoragepercent)}
if(closestHostile) { }
tower.attack(closestHostile); }
}
} }
}) }
} })
}; }
};
module.exports = towers; module.exports = towers;