From e72a3f37dd4fd89894e4cf99d7c923f1db4da44f Mon Sep 17 00:00:00 2001 From: dan Date: Mon, 9 Nov 2020 19:31:39 -0600 Subject: [PATCH] Resync with system --- Empire.js | 83 +++--- MinedMineralProc.js | 26 -- NOTES.js | 116 ++++---- README.md | 2 - Room.Phase0.js | 52 ++++ Room.Phase1.js | 41 +++ RoomInit.js | 13 + tower.js => Run.Tower.js | 108 ++++---- Traveler.js | 584 +++++++++++++++++++++++++++++++++++++++ assignsources.js | 21 ++ bodypartbuilder.js | 45 +-- flag.claim.js | 29 ++ flag.debug.js | 4 + flag.protect.js | 35 +++ initroom.js | 35 --- main.js | 104 +++---- mineralprocessing.js | 24 -- proc.market.js | 51 ++++ proc.sales.js | 14 - proc.spawning.js | 169 +++++++++++ role.builder.js | 64 ----- role.claimer.js | 19 +- role.hauler.js | 63 ----- role.hauler2.js | 45 --- role.miner.js | 10 +- role.miner2.js | 13 - role.mineralhauler.js | 33 --- role.mover.js | 43 +++ role.nrbuilder.js | 60 ---- role.nrminer.js | 26 -- role.nrworker.js | 10 + role.phase0worker.js | 50 ++++ role.phase1worker.js | 88 ++++++ role.recharger.js | 39 --- role.repairbot.js | 54 ---- role.upgrader.js | 49 ---- role.warrior.js | 23 +- sourceprocessing.js | 27 -- spawnprocessing.js | 131 --------- sproc.js | 24 -- 40 files changed, 1430 insertions(+), 997 deletions(-) delete mode 100644 MinedMineralProc.js delete mode 100644 README.md create mode 100644 Room.Phase0.js create mode 100644 Room.Phase1.js create mode 100644 RoomInit.js rename tower.js => Run.Tower.js (94%) create mode 100644 Traveler.js create mode 100644 assignsources.js create mode 100644 flag.claim.js create mode 100644 flag.debug.js create mode 100644 flag.protect.js delete mode 100644 initroom.js delete mode 100644 mineralprocessing.js create mode 100644 proc.market.js delete mode 100644 proc.sales.js create mode 100644 proc.spawning.js delete mode 100644 role.builder.js delete mode 100644 role.hauler.js delete mode 100644 role.hauler2.js delete mode 100644 role.miner2.js delete mode 100644 role.mineralhauler.js create mode 100644 role.mover.js delete mode 100644 role.nrbuilder.js delete mode 100644 role.nrminer.js create mode 100644 role.nrworker.js create mode 100644 role.phase0worker.js create mode 100644 role.phase1worker.js delete mode 100644 role.recharger.js delete mode 100644 role.repairbot.js delete mode 100644 role.upgrader.js delete mode 100644 sourceprocessing.js delete mode 100644 spawnprocessing.js delete mode 100644 sproc.js 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