diff --git a/Empire.js b/Empire.js index ca4cdb7..3a1ca5b 100644 --- a/Empire.js +++ b/Empire.js @@ -1,43 +1,11 @@ -let buildparts=require('bodypartbuilder') +//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 + for(let room of _.filter(Game.rooms, 'controller.my')) { + roomcounts = _.countBy(room.find(FIND_MY_CREEPS), c => c.memory.role) + console.log(roomcounts['phase1worker']) + console.log(roomcounts['miner']) + } }, decrease: function(role,roomname){ let rolename = 'max' + role + 's' @@ -64,14 +32,49 @@ module.exports = { let me= Game.creeps[creepname].suicide() return me }, - spawn: function(roomname,role){ - buildparts.tick(roomname,role) + spawnwarrior: function(){ + for(let myroom of _.filter(Game.rooms, 'controller.my')) { + let name = myroom.name + require('proc.spawning').spawnwarrior(name) + } + return 'Spawning initiated' + }, + spawnnrworker: function(){ + for(let myroom of _.filter(Game.rooms, 'controller.my')) { + let name = myroom.name + require('proc.spawning').spawnnrworker(name) + } + return 'Spawning initiated' + }, + spawnworker: function(){ + for(let myroom of _.filter(Game.rooms, 'controller.my')) { + let name = myroom.name + require('proc.spawning').spawnworker(name) + } + return 'Spawning initiated' + }, + spawnclaimer: function(){ + for(let myroom of _.filter(Game.rooms, 'controller.my')) { + let name = myroom.name + require('proc.spawning').spawnclaimer(name) + } return 'Spawning initiated' }, removeConstruction: function(roomname){ _.invoke(Game.rooms[roomname].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()) + }, + removeRoads: function(roomname,hitsleft){ + Game.rooms[roomname].find(FIND_STRUCTURES, {filter: s => (s.structureType === STRUCTURE_ROAD && s.hits < hitsleft)}).forEach(s => s.destroy()) + return "done" + }, + sellEnergy: function(roomname){ + let myorders = Game.market.getAllOrders(order=>order.resourceType == RESOURCE_ENERGY && order.type == ORDER_SELL) + } }; \ No newline at end of file diff --git a/MinedMineralProc.js b/MinedMineralProc.js deleted file mode 100644 index bb68c08..0000000 --- a/MinedMineralProc.js +++ /dev/null @@ -1,26 +0,0 @@ -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; \ No newline at end of file diff --git a/NOTES.js b/NOTES.js index 1e07589..280d728 100644 --- a/NOTES.js +++ b/NOTES.js @@ -1,64 +1,62 @@ -if(containers.count==0 && structure_extensions.count==0 && storage.count==0 && miners.count==0){spawn harvester} else { spawn miners and haulers} -require('role.' + creep.memory.role).run(creep) -_.forEach(Game.creeps, creep => creep.suicide()) -_.forEach(Game.rooms[roomname].constructionSites, cs=>cs.remove()) -serializePos: function(pos) { - return pos.x + '_' + pos.y + '_' + pos.roomName; - }, - deserializePos: function(str) { - var ar = str.split('_'); - return new RoomPosition(ar[0], ar[1], ar[2]); - }, - - - - Structure.prototype.getResourceCapacity = function(resourceType) { - switch (this.structureType) { - case STRUCTURE_CONTAINER: - case STRUCTURE_STORAGE: - case STRUCTURE_TERMINAL: - return this.storeCapacity; - case STRUCTURE_SPAWN: - case STRUCTURE_EXTENSION: - case STRUCTURE_LINK: - case STRUCTURE_TOWER: - if (RESOURCE_ENERGY == resourceType) { - return(this.energyCapacity); - } else { - return(-1); +/* +||Game.rooms[room].find(FIND_MY_STRUCTURES, {filter: { structureType: STRUCTURE_EXTENSION }}).length == 5 + +{ignoreCreeps:true} on moveto, need to find how to check if stuck +let pos = _.create(RoomPosition.prototype, creep.memory.pos) +for(let road in look){if(road.structureType == STRUCTURE_ROAD){console.log('road at ' + creep.pos)}} + +let road = in_creep.pos.lookFor(LOOK_STRUCTURES)[0]; +if (road) {in_creep.repair(road);} +x=Game.getObjectById("58dbc3ad8283ff5308a3df08"); console.log(`${x.progressTotal - x.progress} to go!`); + + + +--------- code to check for open source spots ---- +RoomPosition.prototype.isOpen = function(opts){ +// opts.ignoreCreeps (boolean) default false. ignores creeps if true. +// opts.ignoreSolids (boolean) default false. ignores solid structures if true. + if ("wall" === Game.map.getTerrainAt(this)) return(false); + if (null==Game.rooms[this.roomName]) return (true); + if ((null==opts || !opts.ignoreCreeps) && + (this.lookFor(LOOK_CREEPS).length !== 0)) return(false); + if (null==opts || !opts.ignoreSolids){ + var objectList = this.lookFor(LOOK_STRUCTURES).concat( + this.lookFor(LOOK_CONSTRUCTION_SITES)); + for(let j=objectList.length; --j>=0; ){ + let rObj = objectList[j]; + if (rObj instanceof ConstructionSite && !rObj.my) continue; + if (rObj.structureType !== STRUCTURE_ROAD && + rObj.structureType !== STRUCTURE_CONTAINER && + (rObj.structureType !== STRUCTURE_RAMPART || + !rObj.my)) { + return false; + } } - case STRUCTURE_LAB: - if (RESOURCE_ENERGY == resourceType) { - return(this.energyCapacity); - } else { - return(this.mineralCapacity); - } - default: - return(-1); } + return(true); } -Structure.prototype.getResource = function(resourceType) { - switch (this.structureType) { - case STRUCTURE_CONTAINER: - case STRUCTURE_STORAGE: - case STRUCTURE_TERMINAL: - return this.store[resourceType]; - case STRUCTURE_SPAWN: - case STRUCTURE_EXTENSION: - case STRUCTURE_LINK: - case STRUCTURE_TOWER: - if (RESOURCE_ENERGY == resourceType) { - return(this.energy); - } else { - return(-1); +RoomPosition.prototype.nearOpenList = function(opts){ +// using .isOpen (above) this checks adjacent positions for openness. Room exits and +// other rooms are not considered. The position itself is also not considered. +// +// opts.ignoreCreeps (boolean) default false. ignores creeps if true. +// opts.ignoreSolids (boolean) default false. ignores solid structures if true. +// return (list) list of open adjacent positions. + var x=this.x; + var y=this.y; + var openPosList=[]; + var sList=[{x:x-1,y:y-1},{x:x, y:y-1},{x:x+1,y:y-1}, + {x:x-1,y:y }, {x:x+1,y:y }, + {x:x-1,y:y+1},{x:x, y:y+1},{x:x+1,y:y+1}]; + for (var i=sList.length; --i>=0; ){ + if (sList[i].x<49 && sList[i].x>0 && + sList[i].y<49 && sList[i].y>0 && + (global.myCache.getRoomPosition( + sList[i].x,sList[i].y,this.roomName)).isOpen(opts)){ + openPosList.push( + global.myCache.getRoomPosition(sList[i].x,sList[i].y,this.roomName)); } - case STRUCTURE_LAB: - if (RESOURCE_ENERGY == resourceType) { - return(this.energy); - } else { - return(this.mineralAmount); - } - default: - return(-1); } -} \ No newline at end of file + return(openPosList); +}; +--------- end open position code ----- \ No newline at end of file diff --git a/README.md b/README.md deleted file mode 100644 index 1ea0862..0000000 --- a/README.md +++ /dev/null @@ -1,2 +0,0 @@ -# screeps -my screeps code diff --git a/Room.Phase0.js b/Room.Phase0.js new file mode 100644 index 0000000..6c39877 --- /dev/null +++ b/Room.Phase0.js @@ -0,0 +1,52 @@ +let Phase0 = { + run: function(room) { + require('assignsources').tick(room) + creepcounts = _.countBy(Game.rooms[room].find(FIND_MY_CREEPS), c => c.memory.role) + let myspawns = Game.rooms[room].find(FIND_MY_SPAWNS) + let sources = Game.rooms[room].find(FIND_SOURCES ) + if(myspawns.length<1){ + if(Game.rooms[room].controller.level>1){ + + Game.rooms[room].memory.phase++ + let creeps=Game.rooms[room].find(FIND_MY_CREEPS) + let newworkerrolename = 'phase' + Game.rooms[room].memory.phase + 'worker' + for(let mycreep in creeps){ + creep=creeps[mycreep] + if(creep.memory.role == workerrolename){ + creep.memory.role=newworkerrolename + } + } + + Game.rooms[room].memory['tickstophase' + Game.rooms[room].memory.phase]=Game.rooms[room].memory.tickssofar + console.log(Game.rooms[room].memory['tickstophase' + Game.rooms[room].memory.phase]) + + } + } 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) ){ + if(Game.rooms[room].energyAvailable == Game.rooms[room].energyCapacityAvailable){ + require('proc.spawning').spawnworker(room) + } + } else { } + if(Game.rooms[room].controller.level>1){ + + Game.rooms[room].memory.phase++ + let creeps=Game.rooms[room].find(FIND_MY_CREEPS) + let newworkerrolename = 'phase' + Game.rooms[room].memory.phase + 'worker' + for(let mycreep in creeps){ + creep=creeps[mycreep] + if(creep.memory.role == workerrolename){ + creep.memory.role=newworkerrolename + } + } + + Game.rooms[room].memory['tickstophase' + Game.rooms[room].memory.phase]=Game.rooms[room].memory.tickssofar + console.log(Game.rooms[room].memory['tickstophase' + Game.rooms[room].memory.phase]) + + } + } + } +}; +module.exports = Phase0; diff --git a/Room.Phase1.js b/Room.Phase1.js new file mode 100644 index 0000000..aa3eb03 --- /dev/null +++ b/Room.Phase1.js @@ -0,0 +1,41 @@ +let Phase1 = { + run: function(room) { + require('assignsources').tick(room) + if(Game.time % 10 === 0){ + //console.log('processing spawn') + let myspawns = Game.rooms[room].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) + 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(Game.rooms[room].memory.NeedsRecharge) + } + if(Game.rooms[room].controller.ticksToDowngrade > CONTROLLER_DOWNGRADE[Game.rooms[room].controller.level]*.8){ + Game.rooms[room].memory.NeedsRecharge=0 + console.log(Game.rooms[room].memory.NeedsRecharge) + } + if(Game.flags.debug && Game.flags.debug.room == Game.rooms[room]){ + console.log(room) + console.log(workerrolename) + console.log(creepcounts[workerrolename]) + console.log(Game.rooms[room].energyAvailable + " of " + Game.rooms[room].energyCapacityAvailable) + } + + if((((creepcounts[workerrolename]< (sources.length * 3) || creepcounts[workerrolename]==undefined) && Game.rooms[room].energyAvailable >= Game.rooms[room].energyCapacityAvailable) ) || ((creepcounts[workerrolename]==0 || creepcounts[workerrolename]==undefined ) && Game.rooms[room].energyAvailable>100)) { + require('proc.spawning').spawnworker(room) + } + if(Game.rooms[room].storage && Game.rooms[room].terminal && (creepcounts["mover"] < 1 || creepcounts["mover"]==undefined) && Game.rooms[room].energyAvailable >= Game.rooms[room].energyCapacityAvailable){ + console.log("Spawning Mover") + require('proc.spawning').spawnmover(room) + } + //require('proc.market').sellEnergy(room) + } + } + if(Game.rooms[room].controller.level>2){ } + } +}; +module.exports = Phase1; \ No newline at end of file diff --git a/RoomInit.js b/RoomInit.js new file mode 100644 index 0000000..b12495f --- /dev/null +++ b/RoomInit.js @@ -0,0 +1,13 @@ +let initroom = { + run: function(name) { + console.log('Initing room ' + name) + Game.rooms[name].memory.phase=0 + Game.rooms[name].memory.CreepNum=0 + Game.rooms[name].memory.minbuildpct=-1 + Game.rooms[name].memory.minupgradepct=.5 + Game.rooms[name].memory.minrepairpct=.5 + Game.rooms[name].memory.hasbeeninited=1 + Game.rooms[name].memory.tickssofar=0 + } +} +module.exports = initroom \ No newline at end of file diff --git a/tower.js b/Run.Tower.js similarity index 94% rename from tower.js rename to Run.Tower.js index 561cbd1..573c372 100644 --- a/tower.js +++ b/Run.Tower.js @@ -1,55 +1,55 @@ -var towers = { - - /** @param {Game} game **/ - tick: function(roomname) { - - towers = Game.rooms[roomname].find(FIND_MY_STRUCTURES, { - filter: { structureType: STRUCTURE_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 closestDamagedStructure = _.first(_.sortBy(myclosestDamagedStructure, (s)=>s.hits / s.hitsMax)); - - let allcontainers = tower.room.find(FIND_STRUCTURES, { - filter: (s) => { - return ( s.structureType == STRUCTURE_CONTAINER) - } - }); - let closestHostile = tower.pos.findClosestByRange(FIND_HOSTILE_CREEPS); - if(closestHostile) { - tower.attack(closestHostile); - } else - { - if(tower.energy > tower.energyCapacity * .7 ){ - let importantstructures = tower.room.find(FIND_STRUCTURES, { - filter: (structure) => { - return (structure.structureType == STRUCTURE_CONTAINER && structure.hits < structure.hitsMax) ; - }}); - importantstructures = _.sortBy(importantstructures, (s)=>s.hits / s.hitsMax) - if(importantstructures.length > 0){ - tower.repair(importantstructures[0]); - } else - { - if(closestDamagedStructure) { - if(Game.rooms[roomname].memory.containerstoragepercent > .8){ - if(global.verbosity>0){ - console.log("tower repairing. Currently at: " + Game.rooms[roomname].memory.containerstoragepercent) - } - tower.repair(closestDamagedStructure); - } else { - if(global.verbosity>0){ - console.log("tower waiting for more storage. Currently at: " + Game.rooms[roomname].memory.containerstoragepercent) - } - } - } - } - - } - } - }) - } -}; - +var towers = { + + /** @param {Game} game **/ + tick: function(roomname) { + + towers = Game.rooms[roomname].find(FIND_MY_STRUCTURES, { + filter: { structureType: STRUCTURE_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 closestDamagedStructure = _.first(_.sortBy(myclosestDamagedStructure, (s)=>s.hits / s.hitsMax)); + + let allcontainers = tower.room.find(FIND_STRUCTURES, { + filter: (s) => { + return ( s.structureType == STRUCTURE_CONTAINER) + } + }); + let closestHostile = tower.pos.findClosestByRange(FIND_HOSTILE_CREEPS); + if(closestHostile) { + tower.attack(closestHostile); + } else + { + if(tower.energy > tower.energyCapacity * .7 ){ + let importantstructures = tower.room.find(FIND_STRUCTURES, { + filter: (structure) => { + return (structure.structureType == STRUCTURE_CONTAINER && structure.hits < structure.hitsMax) ; + }}); + importantstructures = _.sortBy(importantstructures, (s)=>s.hits / s.hitsMax) + if(importantstructures.length > 0){ + tower.repair(importantstructures[0]); + } else + { + if(closestDamagedStructure) { + if(tower.energy > tower.energyCapacity * 1.8 ){ + if(global.verbosity>0){ + console.log("tower repairing. Currently at: " + Game.rooms[roomname].memory.containerstoragepercent) + } + tower.repair(closestDamagedStructure); + } else { + if(global.verbosity>0){ + console.log("tower waiting for more storage. Currently at: " + Game.rooms[roomname].memory.containerstoragepercent) + } + } + } + } + + } + } + }) + } +}; + module.exports = towers; \ No newline at end of file diff --git a/Traveler.js b/Traveler.js new file mode 100644 index 0000000..7f91964 --- /dev/null +++ b/Traveler.js @@ -0,0 +1,584 @@ +/** + * To start using Traveler, require it in main.js: + * Example: var Traveler = require('Traveler.js'); + */ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +class Traveler { + /** + * move creep to destination + * @param creep + * @param destination + * @param options + * @returns {number} + */ + static travelTo(creep, destination, options = {}) { + // uncomment if you would like to register hostile rooms entered + // this.updateRoomStatus(creep.room); + if (!destination) { + return ERR_INVALID_ARGS; + } + if (creep.fatigue > 0) { + Traveler.circle(creep.pos, "aqua", .3); + return ERR_BUSY; + } + destination = this.normalizePos(destination); + // manage case where creep is nearby destination + let rangeToDestination = creep.pos.getRangeTo(destination); + if (options.range && rangeToDestination <= options.range) { + return OK; + } + else if (rangeToDestination <= 1) { + if (rangeToDestination === 1 && !options.range) { + let direction = creep.pos.getDirectionTo(destination); + if (options.returnData) { + options.returnData.nextPos = destination; + options.returnData.path = direction.toString(); + } + return creep.move(direction); + } + return OK; + } + // initialize data object + if (!creep.memory._trav) { + delete creep.memory._travel; + creep.memory._trav = {}; + } + let travelData = creep.memory._trav; + let state = this.deserializeState(travelData, destination); + // uncomment to visualize destination + // this.circle(destination.pos, "orange"); + // check if creep is stuck + if (this.isStuck(creep, state)) { + state.stuckCount++; + Traveler.circle(creep.pos, "magenta", state.stuckCount * .2); + } + else { + state.stuckCount = 0; + } + // handle case where creep is stuck + if (!options.stuckValue) { + options.stuckValue = DEFAULT_STUCK_VALUE; + } + if (state.stuckCount >= options.stuckValue && Math.random() > .5) { + options.ignoreCreeps = false; + options.freshMatrix = true; + delete travelData.path; + } + // TODO:handle case where creep moved by some other function, but destination is still the same + // delete path cache if destination is different + if (!this.samePos(state.destination, destination)) { + if (options.movingTarget && state.destination.isNearTo(destination)) { + travelData.path += state.destination.getDirectionTo(destination); + state.destination = destination; + } + else { + delete travelData.path; + } + } + if (options.repath && Math.random() < options.repath) { + // add some chance that you will find a new path randomly + delete travelData.path; + } + // pathfinding + let newPath = false; + if (!travelData.path) { + newPath = true; + if (creep.spawning) { + return ERR_BUSY; + } + state.destination = destination; + let cpu = Game.cpu.getUsed(); + let ret = this.findTravelPath(creep.pos, destination, options); + let cpuUsed = Game.cpu.getUsed() - cpu; + state.cpu = _.round(cpuUsed + state.cpu); + if (state.cpu > REPORT_CPU_THRESHOLD) { + // see note at end of file for more info on this + console.log(`TRAVELER: heavy cpu use: ${creep.name}, cpu: ${state.cpu} origin: ${creep.pos}, dest: ${destination}`); + } + let color = "orange"; + if (ret.incomplete) { + // uncommenting this is a great way to diagnose creep behavior issues + // console.log(`TRAVELER: incomplete path for ${creep.name}`); + color = "red"; + } + if (options.returnData) { + options.returnData.pathfinderReturn = ret; + } + travelData.path = Traveler.serializePath(creep.pos, ret.path, color); + state.stuckCount = 0; + } + this.serializeState(creep, destination, state, travelData); + if (!travelData.path || travelData.path.length === 0) { + return ERR_NO_PATH; + } + // consume path + if (state.stuckCount === 0 && !newPath) { + travelData.path = travelData.path.substr(1); + } + let nextDirection = parseInt(travelData.path[0], 10); + if (options.returnData) { + if (nextDirection) { + let nextPos = Traveler.positionAtDirection(creep.pos, nextDirection); + if (nextPos) { + options.returnData.nextPos = nextPos; + } + } + options.returnData.state = state; + options.returnData.path = travelData.path; + } + return creep.move(nextDirection); + } + /** + * make position objects consistent so that either can be used as an argument + * @param destination + * @returns {any} + */ + static normalizePos(destination) { + if (!(destination instanceof RoomPosition)) { + return destination.pos; + } + return destination; + } + /** + * check if room should be avoided by findRoute algorithm + * @param roomName + * @returns {RoomMemory|number} + */ + static checkAvoid(roomName) { + return Memory.rooms && Memory.rooms[roomName] && Memory.rooms[roomName].avoid; + } + /** + * check if a position is an exit + * @param pos + * @returns {boolean} + */ + static isExit(pos) { + return pos.x === 0 || pos.y === 0 || pos.x === 49 || pos.y === 49; + } + /** + * check two coordinates match + * @param pos1 + * @param pos2 + * @returns {boolean} + */ + static sameCoord(pos1, pos2) { + return pos1.x === pos2.x && pos1.y === pos2.y; + } + /** + * check if two positions match + * @param pos1 + * @param pos2 + * @returns {boolean} + */ + static samePos(pos1, pos2) { + return this.sameCoord(pos1, pos2) && pos1.roomName === pos2.roomName; + } + /** + * draw a circle at position + * @param pos + * @param color + * @param opacity + */ + static circle(pos, color, opacity) { + new RoomVisual(pos.roomName).circle(pos, { + radius: .45, fill: "transparent", stroke: color, strokeWidth: .15, opacity: opacity + }); + } + /** + * update memory on whether a room should be avoided based on controller owner + * @param room + */ + static updateRoomStatus(room) { + if (!room) { + return; + } + if (room.controller) { + if (room.controller.owner && !room.controller.my) { + room.memory.avoid = 1; + } + else { + delete room.memory.avoid; + } + } + } + /** + * find a path from origin to destination + * @param origin + * @param destination + * @param options + * @returns {PathfinderReturn} + */ + static findTravelPath(origin, destination, options = {}) { + _.defaults(options, { + ignoreCreeps: true, + maxOps: DEFAULT_MAXOPS, + range: 1, + }); + if (options.movingTarget) { + options.range = 0; + } + origin = this.normalizePos(origin); + destination = this.normalizePos(destination); + let originRoomName = origin.roomName; + let destRoomName = destination.roomName; + // check to see whether findRoute should be used + let roomDistance = Game.map.getRoomLinearDistance(origin.roomName, destination.roomName); + let allowedRooms = options.route; + if (!allowedRooms && (options.useFindRoute || (options.useFindRoute === undefined && roomDistance > 2))) { + let route = this.findRoute(origin.roomName, destination.roomName, options); + if (route) { + allowedRooms = route; + } + } + let roomsSearched = 0; + let callback = (roomName) => { + if (allowedRooms) { + if (!allowedRooms[roomName]) { + return false; + } + } + else if (!options.allowHostile && Traveler.checkAvoid(roomName) + && roomName !== destRoomName && roomName !== originRoomName) { + return false; + } + roomsSearched++; + let matrix; + let room = Game.rooms[roomName]; + if (room) { + if (options.ignoreStructures) { + matrix = new PathFinder.CostMatrix(); + if (!options.ignoreCreeps) { + Traveler.addCreepsToMatrix(room, matrix); + } + } + else if (options.ignoreCreeps || roomName !== originRoomName) { + matrix = this.getStructureMatrix(room, options.freshMatrix); + } + else { + matrix = this.getCreepMatrix(room); + } + if (options.obstacles) { + matrix = matrix.clone(); + for (let obstacle of options.obstacles) { + if (obstacle.pos.roomName !== roomName) { + continue; + } + matrix.set(obstacle.pos.x, obstacle.pos.y, 0xff); + } + } + } + if (options.roomCallback) { + if (!matrix) { + matrix = new PathFinder.CostMatrix(); + } + let outcome = options.roomCallback(roomName, matrix.clone()); + if (outcome !== undefined) { + return outcome; + } + } + return matrix; + }; + let ret = PathFinder.search(origin, { pos: destination, range: options.range }, { + maxOps: options.maxOps, + maxRooms: options.maxRooms, + plainCost: options.offRoad ? 1 : options.ignoreRoads ? 1 : 2, + swampCost: options.offRoad ? 1 : options.ignoreRoads ? 5 : 10, + roomCallback: callback, + }); + if (ret.incomplete && options.ensurePath) { + if (options.useFindRoute === undefined) { + // handle case where pathfinder failed at a short distance due to not using findRoute + // can happen for situations where the creep would have to take an uncommonly indirect path + // options.allowedRooms and options.routeCallback can also be used to handle this situation + if (roomDistance <= 2) { + console.log(`TRAVELER: path failed without findroute, trying with options.useFindRoute = true`); + console.log(`from: ${origin}, destination: ${destination}`); + options.useFindRoute = true; + ret = this.findTravelPath(origin, destination, options); + console.log(`TRAVELER: second attempt was ${ret.incomplete ? "not " : ""}successful`); + return ret; + } + // TODO: handle case where a wall or some other obstacle is blocking the exit assumed by findRoute + } + else { + } + } + return ret; + } + /** + * find a viable sequence of rooms that can be used to narrow down pathfinder's search algorithm + * @param origin + * @param destination + * @param options + * @returns {{}} + */ + static findRoute(origin, destination, options = {}) { + let restrictDistance = options.restrictDistance || Game.map.getRoomLinearDistance(origin, destination) + 10; + let allowedRooms = { [origin]: true, [destination]: true }; + let highwayBias = 1; + if (options.preferHighway) { + highwayBias = 2.5; + if (options.highwayBias) { + highwayBias = options.highwayBias; + } + } + let ret = Game.map.findRoute(origin, destination, { + routeCallback: (roomName) => { + if (options.routeCallback) { + let outcome = options.routeCallback(roomName); + if (outcome !== undefined) { + return outcome; + } + } + let rangeToRoom = Game.map.getRoomLinearDistance(origin, roomName); + if (rangeToRoom > restrictDistance) { + // room is too far out of the way + return Number.POSITIVE_INFINITY; + } + if (!options.allowHostile && Traveler.checkAvoid(roomName) && + roomName !== destination && roomName !== origin) { + // room is marked as "avoid" in room memory + return Number.POSITIVE_INFINITY; + } + let parsed; + if (options.preferHighway) { + parsed = /^[WE]([0-9]+)[NS]([0-9]+)$/.exec(roomName); + let isHighway = (parsed[1] % 10 === 0) || (parsed[2] % 10 === 0); + if (isHighway) { + return 1; + } + } + // SK rooms are avoided when there is no vision in the room, harvested-from SK rooms are allowed + if (!options.allowSK && !Game.rooms[roomName]) { + if (!parsed) { + parsed = /^[WE]([0-9]+)[NS]([0-9]+)$/.exec(roomName); + } + let fMod = parsed[1] % 10; + let sMod = parsed[2] % 10; + let isSK = !(fMod === 5 && sMod === 5) && + ((fMod >= 4) && (fMod <= 6)) && + ((sMod >= 4) && (sMod <= 6)); + if (isSK) { + return 10 * highwayBias; + } + } + return highwayBias; + }, + }); + if (!_.isArray(ret)) { + console.log(`couldn't findRoute to ${destination}`); + return; + } + for (let value of ret) { + allowedRooms[value.room] = true; + } + return allowedRooms; + } + /** + * check how many rooms were included in a route returned by findRoute + * @param origin + * @param destination + * @returns {number} + */ + static routeDistance(origin, destination) { + let linearDistance = Game.map.getRoomLinearDistance(origin, destination); + if (linearDistance >= 32) { + return linearDistance; + } + let allowedRooms = this.findRoute(origin, destination); + if (allowedRooms) { + return Object.keys(allowedRooms).length; + } + } + /** + * build a cost matrix based on structures in the room. Will be cached for more than one tick. Requires vision. + * @param room + * @param freshMatrix + * @returns {any} + */ + static getStructureMatrix(room, freshMatrix) { + if (!this.structureMatrixCache[room.name] || (freshMatrix && Game.time !== this.structureMatrixTick)) { + this.structureMatrixTick = Game.time; + let matrix = new PathFinder.CostMatrix(); + this.structureMatrixCache[room.name] = Traveler.addStructuresToMatrix(room, matrix, 1); + } + return this.structureMatrixCache[room.name]; + } + /** + * build a cost matrix based on creeps and structures in the room. Will be cached for one tick. Requires vision. + * @param room + * @returns {any} + */ + static getCreepMatrix(room) { + if (!this.creepMatrixCache[room.name] || Game.time !== this.creepMatrixTick) { + this.creepMatrixTick = Game.time; + this.creepMatrixCache[room.name] = Traveler.addCreepsToMatrix(room, this.getStructureMatrix(room, true).clone()); + } + return this.creepMatrixCache[room.name]; + } + /** + * add structures to matrix so that impassible structures can be avoided and roads given a lower cost + * @param room + * @param matrix + * @param roadCost + * @returns {CostMatrix} + */ + static addStructuresToMatrix(room, matrix, roadCost) { + let impassibleStructures = []; + for (let structure of room.find(FIND_STRUCTURES)) { + if (structure instanceof StructureRampart) { + if (!structure.my && !structure.isPublic) { + impassibleStructures.push(structure); + } + } + else if (structure instanceof StructureRoad) { + matrix.set(structure.pos.x, structure.pos.y, roadCost); + } + else if (structure instanceof StructureContainer) { + matrix.set(structure.pos.x, structure.pos.y, 5); + } + else { + impassibleStructures.push(structure); + } + } + for (let site of room.find(FIND_MY_CONSTRUCTION_SITES)) { + if (site.structureType === STRUCTURE_CONTAINER || site.structureType === STRUCTURE_ROAD + || site.structureType === STRUCTURE_RAMPART) { + continue; + } + matrix.set(site.pos.x, site.pos.y, 0xff); + } + for (let structure of impassibleStructures) { + matrix.set(structure.pos.x, structure.pos.y, 0xff); + } + return matrix; + } + /** + * add creeps to matrix so that they will be avoided by other creeps + * @param room + * @param matrix + * @returns {CostMatrix} + */ + static addCreepsToMatrix(room, matrix) { + room.find(FIND_CREEPS).forEach((creep) => matrix.set(creep.pos.x, creep.pos.y, 0xff)); + return matrix; + } + /** + * serialize a path, traveler style. Returns a string of directions. + * @param startPos + * @param path + * @param color + * @returns {string} + */ + static serializePath(startPos, path, color = "orange") { + let serializedPath = ""; + let lastPosition = startPos; + this.circle(startPos, color); + for (let position of path) { + if (position.roomName === lastPosition.roomName) { + new RoomVisual(position.roomName) + .line(position, lastPosition, { color: color, lineStyle: "dashed" }); + serializedPath += lastPosition.getDirectionTo(position); + } + lastPosition = position; + } + return serializedPath; + } + /** + * returns a position at a direction relative to origin + * @param origin + * @param direction + * @returns {RoomPosition} + */ + static positionAtDirection(origin, direction) { + let offsetX = [0, 0, 1, 1, 1, 0, -1, -1, -1]; + let offsetY = [0, -1, -1, 0, 1, 1, 1, 0, -1]; + let x = origin.x + offsetX[direction]; + let y = origin.y + offsetY[direction]; + if (x > 49 || x < 0 || y > 49 || y < 0) { + return; + } + return new RoomPosition(x, y, origin.roomName); + } + /** + * convert room avoidance memory from the old pattern to the one currently used + * @param cleanup + */ + static patchMemory(cleanup = false) { + if (!Memory.empire) { + return; + } + if (!Memory.empire.hostileRooms) { + return; + } + let count = 0; + for (let roomName in Memory.empire.hostileRooms) { + if (Memory.empire.hostileRooms[roomName]) { + if (!Memory.rooms[roomName]) { + Memory.rooms[roomName] = {}; + } + Memory.rooms[roomName].avoid = 1; + count++; + } + if (cleanup) { + delete Memory.empire.hostileRooms[roomName]; + } + } + if (cleanup) { + delete Memory.empire.hostileRooms; + } + console.log(`TRAVELER: room avoidance data patched for ${count} rooms`); + } + static deserializeState(travelData, destination) { + let state = {}; + if (travelData.state) { + state.lastCoord = { x: travelData.state[STATE_PREV_X], y: travelData.state[STATE_PREV_Y] }; + state.cpu = travelData.state[STATE_CPU]; + state.stuckCount = travelData.state[STATE_STUCK]; + state.destination = new RoomPosition(travelData.state[STATE_DEST_X], travelData.state[STATE_DEST_Y], travelData.state[STATE_DEST_ROOMNAME]); + } + else { + state.cpu = 0; + state.destination = destination; + } + return state; + } + static serializeState(creep, destination, state, travelData) { + travelData.state = [creep.pos.x, creep.pos.y, state.stuckCount, state.cpu, destination.x, destination.y, + destination.roomName]; + } + static isStuck(creep, state) { + let stuck = false; + if (state.lastCoord !== undefined) { + if (this.sameCoord(creep.pos, state.lastCoord)) { + // didn't move + stuck = true; + } + else if (this.isExit(creep.pos) && this.isExit(state.lastCoord)) { + // moved against exit + stuck = true; + } + } + return stuck; + } +} +Traveler.structureMatrixCache = {}; +Traveler.creepMatrixCache = {}; +exports.Traveler = Traveler; +// this might be higher than you wish, setting it lower is a great way to diagnose creep behavior issues. When creeps +// need to repath to often or they aren't finding valid paths, it can sometimes point to problems elsewhere in your code +const REPORT_CPU_THRESHOLD = 1000; +const DEFAULT_MAXOPS = 20000; +const DEFAULT_STUCK_VALUE = 2; +const STATE_PREV_X = 0; +const STATE_PREV_Y = 1; +const STATE_STUCK = 2; +const STATE_CPU = 3; +const STATE_DEST_X = 4; +const STATE_DEST_Y = 5; +const STATE_DEST_ROOMNAME = 6; +// assigns a function to Creep.prototype: creep.travelTo(destination) +Creep.prototype.travelTo = function (destination, options) { + return Traveler.travelTo(this, destination, options); +}; \ No newline at end of file diff --git a/assignsources.js b/assignsources.js new file mode 100644 index 0000000..1edfd43 --- /dev/null +++ b/assignsources.js @@ -0,0 +1,21 @@ +let assignMiners = { + tick: function(roomname) { + 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=='miner'|| 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)}}) + let unassignedminers = _.filter(allminers, (creep) => (creep.memory.destsource == undefined )); + let sourcecount = sources.length + let persrc = allminers.length / sourcecount + if(unassignedminers.length > 0){ + let myminers = _.filter(allminers, (creep) => (creep.memory.destsource != undefined && creep.memory.destsource.id==source.id )); + if(myminers.length >= persrc){ + //break; + } else { + unassignedminers[0].memory.destsource = source + } + } + } + } +}; +module.exports = assignMiners; \ No newline at end of file diff --git a/bodypartbuilder.js b/bodypartbuilder.js index 04bbea5..3b71f95 100644 --- a/bodypartbuilder.js +++ b/bodypartbuilder.js @@ -1,11 +1,5 @@ let buildparts = { tick: function(roomname,role) { - - console.log(Game.rooms[roomname].memory.tickssincespawn) - console.log(roomname + ":" + role) - let energyready = Game.rooms[roomname].energyAvailable - let energymax = Game.rooms[roomname].energyCapacityAvailable - Game.rooms[roomname].memory.tickssincespawn=0 let tobuild=[] let myspawns=Game.rooms[roomname].find(FIND_MY_SPAWNS) @@ -17,10 +11,10 @@ let buildparts = { for(let spawn of myspawns){ if(!spawn.spawning){ for(let totry of [ - [MOVE,MOVE,MOVE,MOVE,WORK,WORK,WORK,WORK,CARRY,CARRY,CARRY,CARRY], - [MOVE,MOVE,MOVE,WORK,WORK,WORK,CARRY,CARRY,CARRY], - [MOVE,MOVE,WORK,WORK,CARRY,CARRY], - [MOVE,WORK,CARRY] + [MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE,WORK,CARRY], + [MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE,WORK,CARRY], + [MOVE,WORK,CARRY,MOVE,WORK,CARRY], + [MOVE,WORK,CARRY,CARRY] ]){ let ispossible = spawn.canCreateCreep(totry) @@ -40,9 +34,9 @@ let buildparts = { for(let spawn of myspawns){ if(!spawn.spawning){ for(let totry of [ - [MOVE,MOVE,MOVE,MOVE,WORK,WORK,WORK,WORK,CARRY,CARRY,CARRY,CARRY], - [MOVE,MOVE,MOVE,WORK,WORK,WORK,CARRY,CARRY,CARRY], - [MOVE,MOVE,WORK,WORK,CARRY,CARRY], + [MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE,WORK,CARRY], + [MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE,WORK,CARRY], + [MOVE,WORK,CARRY,MOVE,WORK,CARRY], [MOVE,WORK,CARRY] ]){ @@ -63,10 +57,12 @@ let buildparts = { 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,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE] + [CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE], + [CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE], + [CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE], + [CARRY,CARRY,MOVE,CARRY,CARRY,MOVE], + [CARRY,CARRY,MOVE], [CARRY,MOVE] ]){ let ispossible = spawn.canCreateCreep(totry) @@ -181,10 +177,13 @@ let buildparts = { 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], + for(let totry of [ + [CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE] + [CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE], + [CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE], + [CARRY,CARRY,MOVE,CARRY,CARRY,MOVE,CARRY,CARRY,MOVE], + [CARRY,CARRY,MOVE,CARRY,CARRY,MOVE], + [CARRY,CARRY,MOVE], [CARRY,MOVE] ]){ let ispossible = spawn.canCreateCreep(totry) @@ -219,7 +218,9 @@ let buildparts = { 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,WORK,CARRY,MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE]//RCL3 + [WORK,CARRY,MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE], + [WORK,CARRY,MOVE,WORK,CARRY,MOVE], [WORK,CARRY,MOVE] ]){ let ispossible = spawn.canCreateCreep(totry) diff --git a/flag.claim.js b/flag.claim.js new file mode 100644 index 0000000..d39c328 --- /dev/null +++ b/flag.claim.js @@ -0,0 +1,29 @@ +let claim = { + run: function() { + if(Game.flags.claim.room==undefined){} else { + let creepcount = Game.flags.claim.room.find(FIND_MY_CREEPS).length + let totallife = _.sum(Game.flags.claim.room.find(FIND_MY_CREEPS), c => c.ticksToLive) + let avglife = totallife/creepcount + if(creepcount<3||(avglife<700 && creepcount < 4 )){ + if(Game.flags.claim.memory.requesttime==undefined){ + Game.flags.claim.memory.requesttime=Game.time + Game.notify('Spawning additional new room workers') + require('Empire').spawnnrworker() + } else { + if(Game.time - Game.flags.claim.memory.requesttime > 500){ + console.log('ticks have passed, trying agin.') + Game.flags.claim.memory.requesttime=undefined + } + } + } else { + Game.flags.claim.memory.requesttime=undefined + } + 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 ) + } + + } +}; +module.exports = claim; diff --git a/flag.debug.js b/flag.debug.js new file mode 100644 index 0000000..c941291 --- /dev/null +++ b/flag.debug.js @@ -0,0 +1,4 @@ +let debug = { + run: function() {} +}; +module.exports = debug; \ No newline at end of file diff --git a/flag.protect.js b/flag.protect.js new file mode 100644 index 0000000..a59f18b --- /dev/null +++ b/flag.protect.js @@ -0,0 +1,35 @@ +let protect = { + run: function() { + console.log(Game.flags.protect.room) + let creepcount=0 + let totallife=0 + let avglife=0 + if(Game.flags.protect.room.find(FIND_MY_CREEPS).length ==undefined){ + + } else { + creepcount = Game.flags.protect.room.find(FIND_MY_CREEPS).length + totallife = _.sum(Game.flags.protect.room.find(FIND_MY_CREEPS), c => c.ticksToLive) + avglife = totallife/creepcount + } + //console.log(avglife) + if(creepcount<3||(avglife<500 && creepcount < 4 )){ + if(Game.flags.protect.memory.requesttime==undefined){ + Game.flags.protect.memory.requesttime=Game.time + Game.notify('Spawning additional new room workers') + require('Empire').spawnwarrior() + } else { + if(Game.time - Game.flags.protect.memory.requesttime > 500){ + console.log('ticks have passed, trying agin.') + Game.flags.protect.memory.requesttime=undefined + } + } + } else { + Game.flags.protect.memory.requesttime=undefined + } + if(!Game.flags.protect.room.controller.my){ + console.log('not my controller') + } + } + +}; +module.exports = protect; diff --git a/initroom.js b/initroom.js deleted file mode 100644 index be90560..0000000 --- a/initroom.js +++ /dev/null @@ -1,35 +0,0 @@ -let initroom = { - run: function(name) { - console.log('Initing room ' + name) - if(Game.rooms[name].memory.CreepNum == undefined){Game.rooms[name].memory.CreepNum=0} - if(Game.rooms[name].memory.minbuildpct == undefined){Game.rooms[name].memory.minbuildpct=-1} - if(Game.rooms[name].memory.minupgradepct == undefined){Game.rooms[name].memory.minupgradepct=.5} - if(Game.rooms[name].memory.minrepairpct == undefined){Game.rooms[name].memory.minrepairpct=.5} - 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.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.maxharvester2s == undefined){ Game.rooms[name].memory.maxharvester2s = 0 } - if(Game.rooms[name].memory.maxrepairbots == undefined){ Game.rooms[name].memory.maxrepairbots = 1 } - if(Game.rooms[name].memory.minworkenergypct == undefined){ Game.rooms[name].memory.minworkenergypct = 0.3 } - if(Game.rooms[name].memory.builderparkx==undefined){Game.rooms[name].memory.builderparkx=24} - if(Game.rooms[name].memory.builderparky==undefined){Game.rooms[name].memory.builderparky=24} - if(Game.rooms[name].memory.hauler2parkx==undefined){Game.rooms[name].memory.hauler2parkx=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.upgraderparky==undefined){Game.rooms[name].memory.upgraderparky=24} - if(Game.rooms[name].memory.warriorparkx==undefined){Game.rooms[name].memory.warriorparkx=15} - if(Game.rooms[name].memory.warriorparky==undefined){Game.rooms[name].memory.warriorparky=34} - Game.rooms[name].memory.hasbeeninited=1 - } -} -module.exports = initroom \ No newline at end of file diff --git a/main.js b/main.js index ea352d5..a1a78d8 100644 --- a/main.js +++ b/main.js @@ -1,76 +1,54 @@ 'use strict'; global.Empire = require("Empire") -//let runTower = require('tower'); -//let assignMiners=require('sproc') -//let processSpawns=require('spawnprocessing') -//let minerals=require('mineralprocessing') -//let minedproc = require('MinedMineralProc') -//let runSources=require('sourceprocessing') +let Traveler = require("Traveler") global.verbosity=0 module.exports.loop = function () { - if(global.verbosity>0){ - console.log('---START---') - } + for(let name in Game.rooms){ + let myroom=Game.rooms[name] + + let towers = Game.rooms[name].find(FIND_MY_STRUCTURES, {filter: { structureType: STRUCTURE_TOWER }}) + //console.log(towers.length) + if(towers.length>0){ + // console.log('running towers in ' + name) + require('Run.Tower').tick(name) + + } + if(!myroom.memory.hasbeeninited && (myroom.controller!==undefined)){ + require('RoomInit').run(name) + } + if(myroom.controller!==undefined){ + myroom.memory.tickssofar++ + require('Room.Phase' + myroom.memory.phase).run(name) + } + } + for(let name in Memory.creeps) { if(!Game.creeps[name]) { delete Memory.creeps[name]; if(global.verbosity>0){ console.log('Clearing non-existing creep memory:', name); } - } - } - for(let myroom of _.filter(Game.rooms, 'controller.my')) { - let name = myroom.name - if(global.verbosity>0){ - console.log('---'+name+'---') - } - if(Game.rooms[name].memory.hasbeeninited==undefined){ - console.log('initing') - require('initroom').run(name) - } - require('tower').tick(name); - require('sproc').tick(name) // assignMiners - require('sourceprocessing').tick(name) - require('MinedMineralProc').tick(name) - try{ - 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 usedstorage = 0 - let mycapacity=0 - for(let i of allstorage){ - usedstorage+=_.sum(i.store) - mycapacity+=i.storeCapacity - } - let allcontainers = Game.rooms[name].find(FIND_STRUCTURES, {filter: (s) => {return ( s.structureType == STRUCTURE_CONTAINER)}}) - let containerusedstorage = 0 - let containercapacity=0 - for(let i=0; i < allcontainers.length;i++){ - containerusedstorage+=_.sum(allcontainers[i].store) - containercapacity+=allcontainers[i].storeCapacity - } - Game.rooms[name].memory.storagepercent = usedstorage/mycapacity - Game.rooms[name].memory.containerstoragepercent = containerusedstorage/containercapacity - if(!(Game.rooms[name].memory.containerstoragepercent >-.1)){Game.rooms[name].memory.containerstoragepercent=0} - - if(global.verbosity>0){ - 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') - } - } catch(e){} - require('spawnprocessing').tick(name) - require('mineralprocessing').tick(name) - } - let mycreeps = Game.creeps - for(let mycreep in mycreeps){ + } else { try{ - let creep = mycreeps[mycreep] - require('role.' + creep.memory.role).run(creep) - } catch (e) { - //console.log(e.toString) - } - + let creep = Game.creeps[name] + if(creep.spawning) return; + if(creep.fatigue>0){ + creep.say('fatigued') + creep.room.createConstructionSite(creep.pos.x,creep.pos.y,STRUCTURE_ROAD) + } + + require('role.' + creep.memory.role).run(creep) + //creep.say("TRYING") + } catch (e) {} } - if(global.verbosity>0){ - console.log('----END---') } -} \ No newline at end of file + let flags = Game.flags + for(let flag in flags){ + require('flag.' + flag ).run() + } + for(let name in Memory.rooms) { + let myroom = Game.rooms[name] + if(!Game.rooms[name]){delete Memory.rooms[name]} + } + + } diff --git a/mineralprocessing.js b/mineralprocessing.js deleted file mode 100644 index dff8349..0000000 --- a/mineralprocessing.js +++ /dev/null @@ -1,24 +0,0 @@ -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 - if(global.verbosity>0){ - 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; \ No newline at end of file diff --git a/proc.market.js b/proc.market.js new file mode 100644 index 0000000..0dbd563 --- /dev/null +++ b/proc.market.js @@ -0,0 +1,51 @@ +/* + * Module code goes here. Use 'module.exports' to export things: + * module.exports.thing = 'a thing'; + * + * You can import it from another modules like this: + * var mod = require('proc.market'); + * mod.thing == 'a thing'; // true + */ +let gomarket={ + sellEnergy: function(myroom) { + try{ + let availtosell= Game.rooms[myroom].terminal.store[RESOURCE_ENERGY] + + if(availtosell>5000){ + console.log(myroom + ":" + 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) + //console.log(myorders.length) + for(let i=0; i 500){ + for(let totry of [ + [MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE,CARRY,CARRY],//MOVE*6,WORK*5,CARRY*7 + [MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE,WORK,CARRY],// all * 5 + [MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE,CARRY],//move*5, work*4, carry*5 + [MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE,WORK,CARRY],//move*4,work*4,carry*4 + [MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE,CARRY],//move*4, work*3, carry*4 + [MOVE,WORK,CARRY,MOVE,WORK,CARRY,MOVE,CARRY], //move*3,work*2, carry*3 + [MOVE,WORK,CARRY,MOVE,WORK,CARRY], //move*2, work*2, carry*2 + [MOVE,WORK,CARRY,MOVE,CARRY],//move*2, work*1, carry*2 + [MOVE,WORK,CARRY] + ]){ + let ispossible = spawn.canCreateCreep(totry) + if(ispossible==OK){ + tobuild=totry + break; + } + } + let newcreep = spawn.createCreep(tobuild,CreepName,{role:"nrworker"}) + }} + + }, + spawnclaimer: function(roomname) { + let myspawns=Game.rooms[roomname].find(FIND_MY_SPAWNS) + Game.rooms[roomname].memory.CreepNum++ + let CreepName = "claimer" + roomname + "_" + (Game.rooms[roomname].memory.CreepNum) + for(let spawn of myspawns){ + if(!spawn.spawning){ + for(let totry of [ + [CLAIM,MOVE] + ]){ + let ispossible = spawn.canCreateCreep(totry) + if(ispossible==OK){ + tobuild=totry + break; + } else { + console.log("Couldn't find a size that could be made") + } + } + console.log(roomname + ' ' + tobuild) + let newcreep = spawn.createCreep(tobuild,CreepName,{role:'claimer'}) + }} + + } +}; +module.exports = buildparts; + +/* + +*/ + +/* +switch(role){ + case 'builder': + break; + default: + console.log('no match') + break; + } +*/ diff --git a/role.builder.js b/role.builder.js deleted file mode 100644 index ba07c58..0000000 --- a/role.builder.js +++ /dev/null @@ -1,64 +0,0 @@ -let buildparts=require('bodypartbuilder') -let roleBuilder = { - run: function(creep) { - if(creep.memory.originroom === undefined){ - creep.memory.originroom = creep.room.name - } - 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(creep.memory.building) { - - if(creep.memory.buildsite==undefined|| Game.getObjectById(creep.memory.buildsite.id) == undefined){ - creep.memory.buildsite = creep.pos.findClosestByRange(FIND_CONSTRUCTION_SITES); - } - let target = Game.getObjectById(creep.memory.buildsite.id) - if(target) { - - if(creep.room.memory.containerstoragepercent > creep.room.memory.minbuildpct || creep.room.memory.containerstoragepercent === undefined ){ - 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(creep.room.memory.containerstoragepercent + ' parking1') - creep.moveTo(creep.room.memory.builderparkx,creep.room.memory.builderparky,creep.room.roomName) - } - } else { - creep.say('parking2') - creep.moveTo(creep.room.memory.builderparkx,creep.room.memory.builderparky,creep.room.roomName) - } - } - else { - let containers =Game.rooms[creep.memory.originroom].find(FIND_STRUCTURES, { - 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, { - filter: (structure) => { - return (structure.structureType == STRUCTURE_CONTAINER || structure.structureType == STRUCTURE_STORAGE ) ; - }}); - let droppedenergy = creep.pos.findClosestByRange(FIND_DROPPED_RESOURCES, {filter: {resourceType: RESOURCE_ENERGY}}); - //find(FIND_DROPPED_RESOURCES, {filter: r => r.resourceType === RESOURCE_ENERGY}) is another option - if(allcontainers.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]); - } - - } - } - } -}; -module.exports = roleBuilder; \ No newline at end of file diff --git a/role.claimer.js b/role.claimer.js index ee3811b..5f42596 100644 --- a/role.claimer.js +++ b/role.claimer.js @@ -1,20 +1,11 @@ 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) + if(Game.flags.claim.room==undefined){ + creep.travelTo(Game.flags.claim) } else{ - creep.say('parking') - creep.moveTo(creep.room.memory.claimerparkx,creep.room.memory.claimerparky,creep.room) + if(creep.claimController(Game.flags.claim.room.controller) == ERR_NOT_IN_RANGE) { + creep.travelTo(Game.flags.claim.room.controller) + } } } }; diff --git a/role.hauler.js b/role.hauler.js deleted file mode 100644 index d119c2c..0000000 --- a/role.hauler.js +++ /dev/null @@ -1,63 +0,0 @@ -let buildparts=require('bodypartbuilder') -let roleHauler = { - 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){ - creep.memory.originroom = creep.room.name - } - if(creep.memory.hauling == undefined){creep.memory.hauling=false} - if(creep.memory.hauling && _.sum(creep.carry) == 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'); - } - let sources = creep.pos.findClosestByRange(FIND_DROPPED_RESOURCES, {filter: {resourceType: RESOURCE_ENERGY}} || STRUCTURE_TERMINAL ); - 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 { - if(sources != undefined ) { - if(spawntargets) { - if(creep.transfer(spawntargets, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) { - creep.moveTo(spawntargets); - } - } else if (containertargets) { - if(creep.transfer(containertargets, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) { - creep.moveTo(containertargets); - } - } else { - if(creep.transfer(storagetargets, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) { - creep.moveTo(storagetargets); - } - } - } - if(creep.carry.RESOURCE_ZYNTHIUM > 0){ - if(creep.transfer(storagetargets, RESOURCE_ZYNTHIUM) == ERR_NOT_IN_RANGE) { - creep.moveTo(storagetargets); - } - } - } - } -}; -module.exports = roleHauler; \ No newline at end of file diff --git a/role.hauler2.js b/role.hauler2.js deleted file mode 100644 index f4a8b72..0000000 --- a/role.hauler2.js +++ /dev/null @@ -1,45 +0,0 @@ - let buildparts=require('bodypartbuilder') - let roleHauler2 = { - 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.hauling = false; - creep.say('gathering'); - } - if(!creep.memory.hauling && creep.carry.energy == creep.carryCapacity) { - creep.memory.hauling = true; - creep.say('hauling'); - } - if(creep.memory.hauling==false){ - if(creep.carryCapacity > creep.carry.energy){ - let container = creep.pos.findClosestByRange(FIND_STRUCTURES, { - filter: (structure) => { - return ((structure.structureType == STRUCTURE_CONTAINER|| structure.structureType == STRUCTURE_STORAGE) && structure.store[RESOURCE_ENERGY] > 0) ; - }}); - if(creep.withdraw(container,RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) { - creep.say("MTSC"); - creep.moveTo(container); - } - } - } else { - let spawntarget = creep.pos.findClosestByRange(FIND_STRUCTURES, { - filter: (structure) => { - return ((structure.structureType == STRUCTURE_EXTENSION || structure.structureType == STRUCTURE_SPAWN) && structure.energy < structure.energyCapacity) - } - }); - if(spawntarget != undefined) { - if(creep.transfer(spawntarget, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) { - creep.say('refilling') - creep.moveTo(spawntarget); - } - } else { - creep.say('NTD'); - creep.moveTo(creep.room.memory.hauler2parkx,creep.room.memory.hauler2parky,creep.room.roomName) - } - } - } - }; - module.exports = roleHauler2; \ No newline at end of file diff --git a/role.miner.js b/role.miner.js index b4ea809..47d5056 100644 --- a/role.miner.js +++ b/role.miner.js @@ -1,14 +1,12 @@ -let buildparts=require('bodypartbuilder') let roleMiner = { 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) + let mysource=Game.getObjectById(creep.memory.destsource.id) + { if(creep.harvest(mysource) == ERR_NOT_IN_RANGE) { - creep.moveTo(mysource); + creep.travelTo(mysource); } + } } }; module.exports = roleMiner; \ No newline at end of file diff --git a/role.miner2.js b/role.miner2.js deleted file mode 100644 index 1a8aa3c..0000000 --- a/role.miner2.js +++ /dev/null @@ -1,13 +0,0 @@ -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; \ No newline at end of file diff --git a/role.mineralhauler.js b/role.mineralhauler.js deleted file mode 100644 index 0b299fc..0000000 --- a/role.mineralhauler.js +++ /dev/null @@ -1,33 +0,0 @@ -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; \ No newline at end of file diff --git a/role.mover.js b/role.mover.js new file mode 100644 index 0000000..7945f7f --- /dev/null +++ b/role.mover.js @@ -0,0 +1,43 @@ +let mover={ + run: function(creep) { + let ignorecreeps=true + if(creep.memory.lastpos==undefined || creep.memory.timeatpos==undefined){ + creep.memory.lastpos = creep.pos + creep.memory.timeatpos = 0 + } + 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.transfer(terminaltarget,RESOURCE_ENERGY)== ERR_NOT_IN_RANGE) { + creep.say('Putting Energy') + creep.travelTo(terminaltarget); + } + } 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) > 5000) ;}}); + if(creep.withdraw(storagetarget,RESOURCE_ENERGY)== ERR_NOT_IN_RANGE) { + creep.say('Getting Energy') + creep.travelTo(storagetarget); + } + } + } + creep.memory.lastpos=creep.pos +} +} +module.exports = mover; \ No newline at end of file diff --git a/role.nrbuilder.js b/role.nrbuilder.js deleted file mode 100644 index b946c8d..0000000 --- a/role.nrbuilder.js +++ /dev/null @@ -1,60 +0,0 @@ -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.pos.isEqualTo(creep.pos) && creep.room == Game.flags.nrbuild.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; \ No newline at end of file diff --git a/role.nrminer.js b/role.nrminer.js deleted file mode 100644 index 86e4e92..0000000 --- a/role.nrminer.js +++ /dev/null @@ -1,26 +0,0 @@ -let assignMiners=require('sproc') -let rolenrMiner = { - run: function(creep) { - - if(Game.flags.nrbuild.pos.isEqualTo(creep.pos) && creep.room == Game.flags.nrbuild.room){ - if(creep.memory.destsource===undefined){ - console.log("changing role from nrminer to miner") - 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; \ No newline at end of file diff --git a/role.nrworker.js b/role.nrworker.js new file mode 100644 index 0000000..b851004 --- /dev/null +++ b/role.nrworker.js @@ -0,0 +1,10 @@ +let rolenrBuilder = { + run: function(creep) { + if(Game.flags.claim.pos.isEqualTo(creep.pos) && creep.room == Game.flags.claim.room){ + creep.memory.role = 'phase' + creep.room.memory.phase + 'worker' + } else { + creep.travelTo(Game.flags.claim) + } + } +}; +module.exports = rolenrBuilder; diff --git a/role.phase0worker.js b/role.phase0worker.js new file mode 100644 index 0000000..ce463b6 --- /dev/null +++ b/role.phase0worker.js @@ -0,0 +1,50 @@ +//'use strict'; +let Phase0Worker = { + run: function(creep) { + 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){ + if(creep.room.controller.ticksToDowngrade<3100){ + if(creep.upgradeController(creep.room.controller) == ERR_NOT_IN_RANGE) { + creep.say('!MTRC!') + creep.travelTo(creep.room.controller); + } + } else if(creep.room.energyAvailable < creep.room.energyCapacityAvailable ){ + let spawntarget = creep.pos.findClosestByPath(FIND_STRUCTURES, {filter: (structure) => {return (((structure.structureType == STRUCTURE_EXTENSION || structure.structureType == STRUCTURE_SPAWN) && structure.energy < structure.energyCapacity))}}); + if(creep.transfer(spawntarget, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) { + creep.travelTo(spawntarget); + } + } else { + if(creep.upgradeController(creep.room.controller) == ERR_NOT_IN_RANGE) { + creep.say('MTRC') + creep.travelTo(creep.room.controller); + } + } + } 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 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(creep.pickup(droppedenergy) == ERR_NOT_IN_RANGE) { + if(global.verbosity>0){ + creep.say("MTDE"); + } + creep.travelTo(droppedenergy); + } + } + } + } +}; +module.exports = Phase0Worker; \ No newline at end of file diff --git a/role.phase1worker.js b/role.phase1worker.js new file mode 100644 index 0000000..d9e3dea --- /dev/null +++ b/role.phase1worker.js @@ -0,0 +1,88 @@ +//'use strict'; +let Phase1Worker = { + run: function(creep) { + let ignorecreeps=true + if(creep.memory.lastpos==undefined || creep.memory.timeatpos==undefined){ + creep.memory.lastpos = creep.pos + creep.memory.timeatpos = 0 + } + 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 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))}})){ + let spawntarget = creep.pos.findClosestByPath(FIND_STRUCTURES, {filter: (s) => {return (((s.structureType == STRUCTURE_EXTENSION || s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_TOWER) && s.energy < s.energyCapacity))}}); + if(creep.transfer(spawntarget, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) { + creep.moveTo(spawntarget,{ignoreCreeps:ignorecreeps}) + } + } else if(creep.pos.findClosestByPath(FIND_STRUCTURES, {filter: (s) => {return ((([STRUCTURE_RAMPART].includes(s.structureType)) && s.hits < 20000))}})){ + let ramparttarget = creep.pos.findClosestByPath(FIND_STRUCTURES, {filter: (s) => {return (((s.structureType == STRUCTURE_RAMPART) && s.hits < s.hitsMax))}}); + if(creep.repair(ramparttarget) == ERR_NOT_IN_RANGE) { + creep.moveTo(ramparttarget,{ignoreCreeps:ignorecreeps}) + } + } else if(creep.pos.findClosestByRange(FIND_CONSTRUCTION_SITES)){ + target = creep.pos.findClosestByRange(FIND_CONSTRUCTION_SITES) + if(creep.build(target) == ERR_NOT_IN_RANGE) { + if (road.length > 0) {creep.repair(road);} + creep.moveTo(target,{ignoreCreeps:ignorecreeps}) + } + } else if(storagetargets){ + 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(creep.room.controller,{ignoreCreeps:ignorecreeps}) + } + } + } else { + let droppedenergy = creep.pos.findClosestByRange(FIND_DROPPED_RESOURCES, {filter: (r) =>{return ( r.resourceType==RESOURCE_ENERGY&& r.amount>200)}}); + if(droppedenergy == 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(creep.pickup(droppedenergy) == ERR_NOT_IN_RANGE) { + if(global.verbosity>0){ + creep.say("MTDE"); + } + + creep.moveTo(droppedenergy,{ignoreCreeps:ignorecreeps}) + + } + } + } + creep.memory.lastpos=creep.pos + } +}; +module.exports = Phase1Worker; diff --git a/role.recharger.js b/role.recharger.js deleted file mode 100644 index a52a479..0000000 --- a/role.recharger.js +++ /dev/null @@ -1,39 +0,0 @@ - let buildparts=require('bodypartbuilder') - let roleTowerrecharger = { - run: function(creep) { - if(creep.memory.originroom === undefined){ - creep.memory.originroom = creep.room.name - } - if(creep.memory.recharging && creep.carry.energy == 0) { - creep.memory.recharging = false; - creep.say('refilling'); - } - if(!creep.memory.recharging && creep.carry.energy == creep.carryCapacity) { - creep.memory.recharging = true; - creep.say('building'); - } - - if(!creep.memory.recharging) { - let container = creep.pos.findClosestByRange(FIND_STRUCTURES, { - filter: (structure) => { - return ((structure.structureType == STRUCTURE_CONTAINER|| structure.structureType == STRUCTURE_STORAGE) && structure.store[RESOURCE_ENERGY] > 1000) ; - }}); - if(creep.withdraw(container,RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) { - creep.say("MTSC"); - creep.moveTo(container); - } - } else { - let spawntarget = creep.pos.findClosestByRange(FIND_STRUCTURES, { - filter: (structure) => { - return (structure.structureType == STRUCTURE_TOWER && structure.energy < structure.energyCapacity) - } - }); - if(spawntarget != undefined) { - if(creep.transfer(spawntarget, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) { - creep.moveTo(spawntarget); - } - } - } - } - }; - module.exports = roleTowerrecharger; \ No newline at end of file diff --git a/role.repairbot.js b/role.repairbot.js deleted file mode 100644 index 8638810..0000000 --- a/role.repairbot.js +++ /dev/null @@ -1,54 +0,0 @@ -let buildparts=require('bodypartbuilder') -let roleRepairbot = { - run: function(creep) { - if(creep.memory.originroom === undefined){ - creep.memory.originroom = creep.room.name - } - if(creep.memory.repairing == undefined){creep.memory.repairing=true} - if(creep.memory.repairing && creep.carry.energy == 0) { - creep.memory.repairing = false; - creep.say('gathering'); - } - if(!creep.memory.repairing && creep.carry.energy == creep.carryCapacity) { - creep.memory.repairing = true; - creep.say('repairing'); - } - if(creep.memory.repairing==false){ - let container = creep.pos.findClosestByRange(FIND_STRUCTURES, { - filter: (structure) => { - return ((structure.structureType == STRUCTURE_CONTAINER|| structure.structureType == STRUCTURE_STORAGE) && structure.store[RESOURCE_ENERGY] > 0) ; - }}); - if(creep.withdraw(container,RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) { - creep.say("MTSC"); - creep.moveTo(container); - } - } else { - if(Game.rooms[creep.memory.originroom].memory.containerstoragepercent > .7 || !(Game.rooms[creep.memory.originroom].memory.containerstoragepercent)){ - let importantstructures = creep.room.find(FIND_STRUCTURES, { - filter: (structure) => { - return ((structure.structureType == STRUCTURE_CONTAINER || structure.structureType==STRUCTURE_RAMPART) && structure.hits < structure.hitsMax) ; - }}); - importantstructures = _.sortBy(importantstructures, (s)=>s.hits / s.hitsMax) - if(importantstructures.length > 0){ - if(Game.rooms[creep.memory.originroom].memory.containerstoragepercent > .5 || !(Game.rooms[creep.memory.originroom].memory.containerstoragepercent)){ - if(creep.repair(importantstructures[0]) == ERR_NOT_IN_RANGE){ - creep.moveTo(importantstructures[0]) - } - } - } 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}); - damagedstructures = _.sortBy(damagedstructures, (s)=>s.hits / s.hitsMax) - if(damagedstructures.length>0){ - if(creep.repair(damagedstructures[0]) == ERR_NOT_IN_RANGE){ - creep.moveTo(damagedstructures[0]) - } - } - } - } - } - } - } -}; - -module.exports = roleRepairbot; \ No newline at end of file diff --git a/role.upgrader.js b/role.upgrader.js deleted file mode 100644 index a9b074c..0000000 --- a/role.upgrader.js +++ /dev/null @@ -1,49 +0,0 @@ -let buildparts=require('bodypartbuilder') -let roleUpgrader = { - run: function(creep) { - if(creep.memory.originroom === undefined){ - creep.memory.originroom = creep.room.name - } - if(creep.memory.upgrading==undefined){creep.memory.upgrading=true} - if(creep.memory.upgrading && creep.carry.energy == 0) { - creep.memory.upgrading = false; - creep.say('harvesting'); - } - if(!creep.memory.upgrading && creep.carry.energy == creep.carryCapacity) { - creep.memory.upgrading = true; - creep.say('upgrading'); - } - if(creep.memory.upgrading) { - if(creep.room.memory.containerstoragepercent>creep.room.memory.minupgradepct || !(creep.room.memory.containerstoragepercent) ){ - if(creep.upgradeController(creep.room.controller) == ERR_NOT_IN_RANGE) { - creep.say('MTRC') - creep.moveTo(creep.room.controller); - } - } else { creep.moveTo(creep.room.memory.upgraderparkx,creep.room.memory.upgraderparky,creep.room.roomName) } - } else { - - let container = creep.pos.findClosestByRange(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 ) ; - }}); - if(allcontainers.length==0){ - let droppedenergy = creep.room.find(FIND_DROPPED_RESOURCES, {filter: {resourceType: RESOURCE_ENERGY}}); - if(creep.pickup(droppedenergy[0]) == ERR_NOT_IN_RANGE) { - creep.say("MTDE"); - creep.moveTo(droppedenergy[0]); - } - }else{ - - if(creep.withdraw(container,RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) { - creep.say("MTSC"); - creep.moveTo(container); - } - } - } - } -}; -module.exports = roleUpgrader; \ No newline at end of file diff --git a/role.warrior.js b/role.warrior.js index 10be42a..deff1f0 100644 --- a/role.warrior.js +++ b/role.warrior.js @@ -1,25 +1,28 @@ -let roleWarrior = { +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) { + var hostile = creep.pos.findClosestByRange(FIND_HOSTILE_CREEPS); + var hostilebuilding = creep.pos.findClosestByRange(FIND_HOSTILE_SPAWNS ); + if(hostile!=undefined) { creep.say('Sorry') - creep.moveTo(hostile); + creep.travelTo(hostile,{ignoreCreeps:true}); creep.attack(hostile); } else if(hostilebuilding!=undefined){ creep.say('Sorry') - creep.moveTo(hostilebuilding); + creep.travelTo(hostilebuilding,{ignoreCreeps:true}); creep.attack(hostilebuilding); - }else if(Game.flags.Attack) { + }else if(Game.flags.protect,{ignoreCreeps:true}) { creep.say('ATK') - creep.moveTo(Game.flags.Attack) + creep.travelTo(Game.flags.protect,{ignoreCreeps:true}) } else{ creep.say('parking') - creep.moveTo(creep.room.memory.warriorparkx,creep.room.memory.warriorparky,creep.room.roomName) + creep.travelTo(creep.room.memory.warriorparkx,creep.room.memory.warriorparky,creep.room.roomName,{ignoreCreeps:true}) } } }; -module.exports = roleWarrior; \ No newline at end of file +module.exports = rolewarrior; + + + diff --git a/sourceprocessing.js b/sourceprocessing.js deleted file mode 100644 index 89819f7..0000000 --- a/sourceprocessing.js +++ /dev/null @@ -1,27 +0,0 @@ -let runSources = { - tick: function(roomname) { - let sources = Game.rooms[roomname].find( - FIND_DROPPED_RESOURCES, { - filter: (mineral) => mineral.resourceType === RESOURCE_ENERGY - }); - for(let source of sources){ - try{ - let allhaulers = _.filter(Game.rooms[roomname].find(FIND_MY_CREEPS), (creep) => creep.memory.role=='hauler' ); - let unassignedhaulers = _.filter(allhaulers, (creep) => (creep.memory.destsource == undefined && creep.memory.role=='hauler')); - let assignedhaulers = _.filter(allhaulers, (creep) => (creep.memory.destsource != undefined && creep.memory.role=='hauler')); - let myhaulers = _.filter(allhaulers, (creep) => (creep.memory.destsource != undefined && creep.memory.destsource.id==source.id && creep.memory.role=='hauler')); - let sourcecount = sources.length - let persrc = allhaulers.length / sourcecount - if(global.verbosity>0){ - console.log('My Assigned Haulers: ' +myhaulers.length + ' Max per source:' + persrc + ' Total Haulers:' + allhaulers.length + ' Total Sources:' + sourcecount + ' Unassigned Haulers:' + unassignedhaulers.length) - } - if(unassignedhaulers.length > 0){ - if(myhaulers.length < persrc){ - unassignedhaulers[0].memory.destsource = source - } else {} - } - } catch(e){} - } - } -}; -module.exports = runSources; \ No newline at end of file diff --git a/spawnprocessing.js b/spawnprocessing.js deleted file mode 100644 index e7ee337..0000000 --- a/spawnprocessing.js +++ /dev/null @@ -1,131 +0,0 @@ -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 - if(global.verbosity>0){ - 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){ - if(global.verbosity>0){ - console.log('WOULD SPAWN AT '+ spawn.name) - } - //spawn.memory.spawnqueued=true - - if(Game.rooms[roomname].memory.maxminers > allminers.length){ - if(global.verbosity>0){ - console.log('spawn miner') - } - buildparts.tick(roomname,'miner') - spawn.memory.spawnqueued=true - } else if(Game.rooms[roomname].memory.maxminer2s > allminer2s.length){ - if(global.verbosity>0){ - console.log('spawn miner2s') - } - buildparts.tick(roomname,'miner2') - spawn.memory.spawnqueued=true - } else if(Game.rooms[roomname].memory.maxhaulers > allhaulers.length){ - if(global.verbosity>0){ - console.log('spawn hauler') - } - buildparts.tick(roomname,'hauler') - spawn.memory.spawnqueued=true - }else if(Game.rooms[roomname].memory.maxhauler3s > allhauler3s.length){ - if(global.verbosity>0){ - console.log('spawn hauler3') - } - buildparts.tick(roomname,'hauler3') - spawn.memory.spawnqueued=true - }else if(Game.rooms[roomname].memory.maxupgraders > allupgraders.length){ - if(global.verbosity>0){ - console.log('spawn upgrader') - } - buildparts.tick(roomname,'upgrader') - spawn.memory.spawnqueued=true - } else if(Game.rooms[roomname].memory.maxhauler2s > allhauler2s.length){ - if(global.verbosity>0){ - console.log('spawn hauler2') - } - buildparts.tick(roomname,'hauler2') - spawn.memory.spawnqueued=true - } else if(Game.rooms[roomname].memory.maxtowerrechargers > alltowerrechargers.length){ - if(global.verbosity>0){ - console.log('spawn towerrecharger') - } - buildparts.tick(roomname,'towerrecharger') - spawn.memory.spawnqueued=true - } else if(Game.rooms[roomname].memory.maxrepairbots > allrepairbots.length){ - if(global.verbosity>0){ - console.log('spawn repairbot') - } - buildparts.tick(roomname,'repairbot') - spawn.memory.spawnqueued=true - }else if(Game.rooms[roomname].memory.maxbuilders > allbuilders.length){ - if(global.verbosity>0){ - console.log('spawn builder') - } - buildparts.tick(roomname,'builder') - spawn.memory.spawnqueued=true - } else if (Game.rooms[roomname].memory.maxwarriors > allwarriors.length){ - if(global.verbosity>0){ - console.log('spawn warrior') - } - buildparts.tick(roomname,'warrior') - } else if(Game.rooms[roomname].memory.maxclaimers > allclaimers.length){ - if(global.verbosity>0){ - console.log('spawn claimer') - } - buildparts.tick(roomname,'claimer') - } else if(Game.rooms[roomname].memory.maxnrbuilders > allnrbuilders.length){ - if(global.verbosity>0){ - console.log('spawn nrbuilder') - } - buildparts.tick(roomname,'nrbuilder') - } else if(Game.rooms[roomname].memory.maxnrminers > allnrminers.length){ - if(global.verbosity>0){ - console.log('spawn nrminer') - } - buildparts.tick(roomname,'nrminer') - } else {} - - } else if (!spawn.spawning && spawn.memory.spawnqueued) { - spawn.memory.spawnqueued=false - if(global.verbosity>0){ - 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; \ No newline at end of file diff --git a/sproc.js b/sproc.js deleted file mode 100644 index f052268..0000000 --- a/sproc.js +++ /dev/null @@ -1,24 +0,0 @@ -let assignMiners = { - tick: function(roomname) { - let sources = Game.rooms[roomname].find(FIND_SOURCES ); - for(let source of sources){ - 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 assignedminers = _.filter(allminers, (creep) => (creep.memory.destsource != undefined && creep.memory.role=='miner')); - 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 - if(global.verbosity>0){ - console.log('My Assigned Miners: ' +myminers.length + ' Max per source:' + persrc + ' Total Miners:' + 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 = assignMiners; \ No newline at end of file