module.exports.loop = function () {
/*
if (Game.cpu.bucket < Game.cpu.tickLimit * 2) {
return;
}
*/
profiler.wrap(function() {
for(var name in Memory.creeps){
if(!Game.creeps[name]){
console.log('Clearing creep memory: ' + name + ' (' + Memory.creeps[name].role + ')');
delete Memory.creeps[name];
}
}
for(var rm in Game.rooms){
//console.log('Current room: ' + rm);
for(var spawnN in Game.spawns) {
var spawnName = undefined;
var spawn = Game.spawns[spawnN];
if(spawn.room.name == rm) {
spawnName = spawnN;
break;
}
}
//console.log(Game.rooms[rm]);
//console.log(Game.rooms[rm].controller);
//console.log(Game.rooms[rm].controller.my);
if(Game.rooms[rm].controller === undefined && Game.rooms[rm].controller.my == false) {
continue;
}
towerControl.run(rm);
if(spawnName !== undefined && Game.spawns[spawnName].spawning === null) {
var harvesters = _.filter(Game.creeps, (creep) => creep.memory.role == 'harvester' && Game.creeps[creep.name].room.name == rm);
var haulers = _.filter(Game.creeps, (creep) => creep.memory.role == 'hauler' && Game.creeps[creep.name].room.name == rm);
var upgraders = _.filter(Game.creeps, (creep) => creep.memory.role == 'upgrader' && Game.creeps[creep.name].room.name == rm);
var builders = _.filter(Game.creeps, (creep) => creep.memory.role == 'builder' && Game.creeps[creep.name].room.name == rm);
var defenders = _.filter(Game.creeps, (creep) => creep.memory.role == 'defender' && Game.creeps[creep.name].room.name == rm);
var claimers = _.filter(Game.creeps, (creep) => creep.memory.role === 'claimer' && Game.creeps[creep.name].room.name == rm);
var unknowns = _.filter(Game.creeps, (creep) => creep.memory.role === undefined && Game.creeps[creep.name].room.name == rm);
if(Game.time % 30 == 0) {
console.log('##########################');
console.log('ROOM: ' + rm);
console.log(harvesters.length + ' Harvester(s): ' + harvesters);
console.log(haulers.length + ' Hauler(s): ' + haulers);
console.log(upgraders.length + ' Upgrader(s): ' + upgraders);
console.log(builders.length + ' Builder(s): ' + builders);
console.log(defenders.length + ' Defender(s): ' + defenders);
if(unknowns.length > 0) {
console.log(unknowns.length + ' without a role: ' + unknowns);
}
console.log('##########################');
}
var sources = Game.rooms[rm].find(FIND_SOURCES);
var droppedSources = Game.rooms[rm].find(FIND_DROPPED_ENERGY);
var newName;
var needCreep = false;
/*
if(defenders.length < 1) {
newName = Game.spawns['Spawn1'].createCreep([TOUGH,TOUGH,RANGED_ATTACK,ATTACK,HEAL,MOVE], {role: 'defender'});
if(_.isString(newName)) {
console.log('New Defender: ' + newName);
}
}
*/
// harvesters
if(harvesters.length < sources.length && !_.isString(newName)) {
needCreep = true;
if(harvesters.length < sources.length && Game.rooms[rm].energyAvailable < Game.rooms[rm].energyCapacityAvailable) {
// emergency harvester made with current energy
//console.log('Need emergency harvester');
var creep = CreepDesigner.createCreep({
base: CreepDesigner.baseDesign.harvester,
room: Game.rooms[rm],
cap: CreepDesigner.caps.harvester,
canAffordOnly: true
})
} else {
// best harvester with current max energy
var creep = CreepDesigner.createCreep({
base: CreepDesigner.baseDesign.harvester,
room: Game.rooms[rm],
cap: CreepDesigner.caps.harvester
})
}
newName = Game.spawns[spawnName].createCreep(creep, undefined, {role: 'harvester'});
if(_.isString(newName)) {
console.log('(' + rm + ') New Harvester: ' + newName);
} else {
//console.log(newName);
}
}
// upgraders
if(!needCreep && (upgraders.length - _.filter(upgraders, (c) => c.ticksToLive < 200).length) < 1 && !_.isString(newName)) {
if(Game.rooms[rm].controller.ticksToDowngrade < 1000 && Game.rooms[rm].energyAvailable < Game.rooms[rm].energyCapacityAvailable) {
needCreep = true;
// emergency upgrader made with current energy
var creep = CreepDesigner.createCreep({
base: CreepDesigner.baseDesign.upgrader,
room: Game.rooms[rm],
cap: CreepDesigner.caps.upgrader,
canAffordOnly: true
})
} else {
// best upgrader with current max energy
var creep = CreepDesigner.createCreep({
base: CreepDesigner.baseDesign.upgrader,
room: Game.rooms[rm],
cap: CreepDesigner.caps.upgrader
})
}
newName = Game.spawns[spawnName].createCreep(creep, undefined, {role: 'upgrader'});
if(_.isString(newName)) {
console.log('(' + rm + ') New Upgrader: ' + newName);
}
}
// haulers
if(!needCreep && (haulers.length - _.filter(haulers, (c) => c.ticksToLive < 200).length) < sources.length * 2 && !_.isString(newName)) {
needCreep = true;
//console.log(rm + '~ Need haulers. Have: ' + haulers.length);
if(haulers.length == 0 && Game.rooms[rm].energyAvailable < Game.rooms[rm].energyCapacityAvailable) {
// emergency hauler made with current energy
//console.log('Creating emergency hauler');
var creep = CreepDesigner.createCreep({
base: CreepDesigner.baseDesign.hauler,
room: Game.rooms[rm],
cap: CreepDesigner.caps.hauler,
canAffordOnly: true
})
} else {
// best hauler with current max energy
var creep = CreepDesigner.createCreep({
base: CreepDesigner.baseDesign.hauler,
room: Game.rooms[rm],
cap: CreepDesigner.caps.hauler
})
}
newName = Game.spawns[spawnName].createCreep(creep, undefined, {role: 'hauler'});
if(_.isString(newName)) {
console.log('(' + rm + ') New Hauler: ' + newName);
} else {
//console.log(newName);
}
}
// builders
if(!needCreep && (builders.length - _.filter(builders, (c) => c.ticksToLive < 200).length) < 3 && !_.isString(newName)) {
needCreep = true;
if(builders.length === 0 && Game.rooms[rm].energyAvailable < Game.rooms[rm].energyCapacityAvailable) {
// emergency builder made with current energy
var creep = CreepDesigner.createCreep({
base: CreepDesigner.baseDesign.builder,
room: Game.rooms[rm],
cap: CreepDesigner.caps.builder,
canAffordOnly: true
})
} else {
// best builder with current max energy
var sites = Game.rooms[rm].find(FIND_MY_CONSTRUCTION_SITES)
if(builders.length < sites.length / 5) {
var creep = CreepDesigner.createCreep({
base: CreepDesigner.baseDesign.builder,
room: Game.rooms[rm],
cap: CreepDesigner.caps.builder,
})
}
}
newName = Game.spawns[spawnName].createCreep(creep, undefined, {role: 'builder'});
if(_.isString(newName)) {
console.log('(' + rm + ') New Builder: ' + newName);
}
}
if(Game.time % 30 == 0) {
// check if there are any flag actions to process
FlagHandler.run(spawnName);
}
}
var roomCreeps = _.filter(Game.creeps, (c) => Game.creeps[c.name].room.name == rm)
//console.log('# creeps in ' + rm + ': ' + roomCreeps.length);
_.forIn(roomCreeps, function(creep) {
var creep = Game.creeps[creep.name];
//console.log(creep.name);
// move to controller of destination room if not in it
if(creep.memory.room !== undefined && creep.memory.role != 'claimer') {
if(creep.memory.room == creep.room.name) {
if(creep.pos.getRangeTo(Game.rooms[creep.memory.room].controller) < 3) {
creep.memory.room = undefined;
} else {
creep.moveTo(Game.rooms[creep.memory.room].controller);
}
} else {
//console.log('creep: ' + creep.name + ' going to room ' + creep.memory.room);
creep.moveTo(Game.rooms[creep.memory.room].controller);
return;
}
}
// give creep task based on role
switch(creep.memory.role) {
case 'builder':
roleBuilder.run(creep);
break;
case 'claimer':
roleClaimer.run(creep);
break;
case 'defender':
//roleDefender.run(creep);
break;
case 'harvester':
roleHarvester.run(creep);
break;
case 'hauler':
//if (Game.cpu.bucket > Game.cpu.tickLimit * 2) {
roleHauler.run(creep);
break;
case 'upgrader':
roleUpgrader.run(creep);
break;
default:
console.log(creep.name + ' has no assigned role');
}
});
// display cpu info if over limit
if(Game.cpu.getUsed() > Game.cpu.limit) {
console.log(rm + ' CPU: ' + Math.round(Game.cpu.getUsed()) + '/' + Game.cpu.tickLimit + ', Bucket: ' + Game.cpu.bucket);
}
}
});
}
module.exports.loop = ()=> profiler.wrap(()=> {
hiveMind.init()
PathFinder.use(true)
let stats = new Stats()
stats.begin()
if(Game.time % 50 == 0) {
spawnCreepWatcher.cleanupMemory()
}
if(Game.time % 5 == 0) {
// Logging purposes
// log.cyan('Removing Old HiveMindItems')
// new Overlord('NoFrigginRoom').removeOldHiveMindItems()
new Overseer().check()
}
if(Game.time % 3 === 0) {
for(let room of new Overseer().myMainRooms()) {
let seeder = new Seeding(room)
seeder.itemGenerator()
seeder.itemVerwertor()
}
}
modwide.h = helper
modwide.$ = $
modwide.Spawner = Spawner
modwide.Overlord = Overlord
modwide.hiveMind = hiveMind
modwide.logHiveMindOf = (spawnName)=> {
new Overlord(Game.spawns[spawnName].room.name).logQueuedItems()
}
modwide.Queueing = Queueing
modwide.Seeding = Seeding
modwide.Requesting = Requesting
modwide.ActiveProviding = ActiveProviding
modwide.Excavating = Excavating
new Overseer().parseCommands()
modwide.resetHive = ()=> {
Memory.hiveMind = {}
Memory.hiveMindIndex = 0
for(let roomName in Game.rooms) {
let room = Game.rooms[roomName]
if(!room.memory.priorityQueues) { continue }
for(let queueName in room.memory.priorityQueues) {
room.memory.priorityQueues[queueName] = []
}
}
for(let creepName in Game.creeps) {
let creep = Game.creeps[creepName]
delete creep.memory.item
delete creep.memory.sourcing
delete creep.memory.kind
}
}
modwide.setMissingCreepRoles = (role = $.ROLE_ZERG)=> {
for(let creepName in Game.creeps) {
let creep = Game.creeps[creepName]
if(!creep.memory.role) {
creep.memory.role = role
}
}
}
try {
for(let name in Game.spawns) {
spawnCreepWatcher.run(Game.spawns[name])
defense.defendRoom(Game.spawns[name].room)
}
try {
for(let roomName in Game.rooms) {
let room = Game.rooms[roomName]
let specialRoomState = room.memory.specialState
let priorityQueues = false
if(
room.memory.priorityQueues &&
Object.keys(room.memory.priorityQueues).length > 0
) {
priorityQueues = _.mapValues(room.memory.priorityQueues, (queue)=> (
new PriorityQueue(queue)
))
}
if(Game.time % 3 == 0) {
let overlord = new Overlord(roomName)
if(priorityQueues) {
overlord.update(priorityQueues)
}
}
let zerglings = room.find(FIND_MY_CREEPS, {filter: (c)=> (
c.memory.role == 'zergling' || // TODO remove zergling
c.memory.role == $.ROLE_ZERG
)})
if(zerglings.length > 0) {
zerglings.forEach((zerglingCreep)=> {
let zergling = new Zergling(zerglingCreep)
zergling.run(priorityQueues, specialRoomState)
})
}
if(room.memory.links && room.memory.links.providers) {
nextTarget:
for(let target of room.memory.links.providers) {
let targetLink = Game.getObjectById(target)
if(targetLink.energy < targetLink.energyCapacity) {
if(room.memory.links && room.memory.links.sources.length) {
for(let source of room.memory.links.sources) {
let sourceLink = Game.getObjectById(source)
if(sourceLink.energy > 0) {
sourceLink.transferEnergy(targetLink)
continue nextTarget
}
}
}
}
}
}
}
}
catch(e) {
console.log(`${e.name}: ${e.message} - ${e.stack}`);
}
for(let name in Game.creeps) {
let creep = Game.creeps[name];
if(creep.memory.role == 'harvester') {
roleHarvester.run(creep)
}
else if(creep.memory.role == 'transporter') {
roleTransporter.run(creep)
}
else if(creep.memory.role == 'upgrader') {
roleUpgrader.run(creep)
}
else if(creep.memory.role == 'builder') {
roleBuilder.run(creep)
}
else if(creep.memory.role == 'excavator') {
roleExcavator.run(creep)
}
else if(creep.memory.role == 'repairer') {
roleRepairer.run(creep)
}
else if(creep.memory.role == 'fighter') {
roleFighter.run(creep)
}
else if(creep.memory.role == 'rangedFighter') {
roleRangedFighter.run(creep)
}
else if(creep.memory.role == 'healer') {
roleHealer.run(creep)
}
else if(creep.memory.role == 'assimilator') {
roleAssimilator.run(creep)
}
else if(creep.memory.role == 'zergling') {
}
else if(creep.memory.role == $.ROLE_ZERG) {
}
else if(creep.memory.role == $.KIND_SWEEPER) {
roleSweeper.run(creep)
}
else {
creep.say("ROLE?!")
console.log("No role for ${creep.name}!")
}
}
}
catch(e) {
console.log(`${e.name}: ${e.message} - ${e.stack}`);
}
finally {
hiveMind.save()
stats.persist()
}
});
module.exports.loop = function () {
profiler.wrap(function() {
var LogLength = 20;
//var MyRoom = Game.spawns.Spawn1.room.name;
for(var name in Memory.creeps) {
if(!Game.creeps[name]) {
delete Memory.creeps[name];
}
}
var oneLoop = false;
var twoLoop = false;
for(var name in Game.spawns){ // Try to include All code except for FarmRoom code in this loop. Maybe multiple rooms can be controlled in this way.
var SpawnName = name;
var MyRoom = Game.spawns[SpawnName].room.name; //Then offcourse make everything depend from variable MyRoom(mostly the case)
var AvailableEnergy = 0;
AvailableEnergy = Game.rooms[MyRoom].energyAvailable;
if(!Memory.rooms[MyRoom] || !Memory.rooms[MyRoom].RoomInfo){ ///Use this method to save on CPU, try to add as much variables as possible without getting into memory problems.
Mem.set(MyRoom,SpawnName);
console.log('Setting memory for room: '+MyRoom);
}
var containers = Mem.run(Memory.rooms[MyRoom].RoomInfo.Containers);
var towers = Mem.run(Memory.rooms[MyRoom].RoomInfo.Towers);
var storages = Mem.run(Memory.rooms[MyRoom].RoomInfo.Storages); // that's it! this can save a lot of CPU of done everywhere.
var links = Mem.run(Memory.rooms[MyRoom].RoomInfo.Links);
var sources = Mem.run(Memory.rooms[MyRoom].RoomInfo.Sources);
var extensions = Mem.run(Memory.rooms[MyRoom].RoomInfo.Extensions);
var walls = Mem.run(Memory.rooms[MyRoom].RoomInfo.Walls);
var ramparts = Mem.run(Memory.rooms[MyRoom].RoomInfo.Ramparts);
var roads = Mem.run(Memory.rooms[MyRoom].RoomInfo.Roads);
//extractors = Mem.run(Memory.rooms[MyRoom].RoomInfo.Extractors);
//terminals = Mem.run(Memory.rooms[MyRoom].RoomInfo.Terminals);
//labs = Mem.run(Memory.rooms[MyRoom].RoomInfo.Labs);
/*console.log(containers == false);
console.log(towers == false);
console.log(links == false);
console.log(storages == false);
console.log(sources == false);
console.log(extensions == false);
console.log(walls == false);
console.log(ramparts == false);
console.log(roads == false);*/
//console.log('links[0]: '+(Memory.rooms[MyRoom].RoomInfo.Links[0] == null));
var harvester = _.filter(Game.creeps, (creep) => (creep.memory.role == 'harvester') && (creep.memory.Home == MyRoom));
var builder = _.filter(Game.creeps, (creep) => (creep.memory.role == 'builder') && (creep.memory.Home == MyRoom));
var upgrader = _.filter(Game.creeps, (creep) => (creep.memory.role == 'upgrader') && (creep.memory.Home == MyRoom));
var worker = _.filter(Game.creeps, (creep) => (creep.memory.role == 'worker') && (creep.memory.Home == MyRoom));
var defender = _.filter(Game.creeps, (creep) => (creep.memory.role == 'defender') && (creep.memory.Home == MyRoom));
var energymon = _.filter(Game.creeps, (creep) => (creep.memory.role == 'energymon') && (creep.memory.Home == MyRoom));
var healers = _.filter(Game.creeps, (creep) => (creep.memory.role == 'healer'));
var claimer = _.filter(Game.creeps, (creep) => (creep.memory.role == 'claimer'));
var SetupDefense = (function() {
var executed = false;
return function () {
if (!executed) {
executed = true;
var ExitCoords = Game.rooms[MyRoom].find(FIND_EXIT);
roomDefense.run(ExitCoords,MyRoom);
}
};
})();
if(Game.rooms[MyRoom].memory.Level == undefined || Game.rooms[MyRoom].controller.level != Game.rooms[MyRoom].memory.Level){
Memory.rooms[MyRoom].Level = Game.rooms[MyRoom].controller.level;
Game.notify('Room: '+MyRoom+' Just leveled up to'+Game.rooms[MyRoom].controller.level);
console.log('Room: '+MyRoom+' Just leveled up to'+Game.rooms[MyRoom].controller.level);
Memory.rooms[MyRoom].Eticks = 3;
Mem.reset(MyRoom);
}
if(Memory.rooms[MyRoom].Eticks > 0){ //spread more tasks over longer period
var Ecenter = Game.flags.EnergyCenter;
//SetupDefense();
//energyCenter(Ecenter);
Memory.rooms[MyRoom].Eticks -= 1;
}
/*console.log((roads == false));
console.log((links == false));
console.log(((links == false && links[0] != null) ||
(containers == false && containers[0] != null)||
(towers == false && towers[0] != null)||
(storages == false && storages[0] != null)||
(extensions == false && extensions[0] != null)||
(walls == false && walls[0] != null)||
(ramparts == false && ramparts[0] != null)||
(roads == false && roads[0] != null))&&
(Memory.rooms[MyRoom] != undefined ||
Memory.rooms[MyRoom].RoomInfo != undefined));*/
/*if(((links == false && links != null) ||
(containers == false && containers != null)||
(towers == false && towers != null)||
(storages == false && storages!= null)||
(extensions == false && extensions != null)||
(walls == false && walls != null)||
(ramparts == false && ramparts != null)||
(roads == false && roads != null))&&
(Memory.rooms[MyRoom] != undefined ||
Memory.rooms[MyRoom].RoomInfo != undefined)){
console.log("ObjectId mismatch, resetting memory for: "+MyRoom)
Mem.reset(MyRoom);
} //checks for destroyed buildings, if true: reset memory of that room.*/
function energyCenter(FlagPos){ //change loop order
//console.log(FlagPos.pos.x);
var BuildPosX = FlagPos.pos.x;
var BuildPosY = FlagPos.pos.y;
var c = 0;
var BuildingToggle = true; //true is positive, false is negative
for (var j = 0; j < 8; j++){
for(i = 0 ; i < 11; i++){
if(BuildingToggle){
BuildingToggle = false;
Game.rooms[MyRoom].createConstructionSite(BuildPosX,BuildPosY,STRUCTURE_EXTENSION);
}else{
Game.rooms[MyRoom].createConstructionSite(BuildPosX,BuildPosY,STRUCTURE_ROAD);
BuildingToggle = true;
}
c +=1;
BuildPosY += 1;
}
BuildPosY = FlagPos.pos.y;
BuildPosX -= 1;
}
}
var linkFrom = 0;
if(storages.length > 0){ // Rewrite Link-code, maybe put it in own Module, at least make it use the memory ID's.
var linkController = 0;
var linkTower = 0;
var linkTo = Game.rooms[MyRoom].storage.pos.findInRange(FIND_MY_STRUCTURES, 2,
{filter: {structureType: STRUCTURE_LINK}})[0];
for(id in sources){ // Look for link near sources
var linkTemp = sources[id].pos.findInRange(FIND_MY_STRUCTURES, 2, {filter: {structureType: STRUCTURE_LINK}});
if(linkTemp.length > 0){
linkFrom = linkTemp[0];
} // if link is found near a source, designate it as a linkFrom
}
if(Game.rooms[MyRoom].controller.pos.findInRange(FIND_MY_STRUCTURES, 2, {filter: {structureType: STRUCTURE_LINK}})){ //look for link near controller
linkController = Game.rooms[MyRoom].controller.pos.findInRange(FIND_MY_STRUCTURES, 2, {filter: {structureType: STRUCTURE_LINK}});
}
if(towers.length > 0){ //look for links near towers
for(var id in towers){
var linkTemp = towers[id].pos.findInRange(FIND_MY_STRUCTURES, 2, {filter: {structureType: STRUCTURE_LINK}});
if(linkTemp.length > 0){
linkTower = linkTemp;
}
}
}
if(linkTo != undefined){ //if controller || tower links are defined and empty, prioritize them over the storage link.
if(linkController.pos != undefined && linkController.energy == 0){
linkTo = LinkController[0];
}else if(linkTower.pos != undefined && linkTower.energy == 0){
linkTo = linkTower[0];
}
if(linkFrom.energy == linkFrom.energyCapacity && linkTo.energy == 0 && linkFrom.cooldown == 0){
linkFrom.transferEnergy(linkTo); //then send the energy
}
}
}
var hostiles = Game.spawns[SpawnName].pos.findClosestByRange(FIND_HOSTILE_CREEPS);
var healer = Game.spawns[SpawnName].pos.findClosestByRange(FIND_HOSTILE_CREEPS, { // <-----------------------that's how we find stuff in the room, check code for occurance.
filter: function(object) {
return object.getActiveBodyparts(HEAL) != 0;
}
});
if(healer){
hostiles = healer;
}
function NoCreeps(buil,upgr,work,harv,kill,AvailableEnergy,Hostiles){
var Nbuil = 2;
var Nupgr = 1;
var Nwork = 2;
var Nharv = 2;
var Nkill = 0;
var NEMon = 0;
if(Game.rooms[MyRoom].controller.level < 4){
Nupgr = 4;
}
if(Game.rooms[MyRoom].energyCapacityAvailable < 600){
Nharv = 3;
Nbuil = 3;
}
if(storages.length > 0){
NEMon = 2;
if(_.sum(storages[0].store) > 60000){
Nupgr += Math.round((_.sum(storages[0].store)-60000)/10000)
}
}
if(linkFrom.pos != undefined){
Nharv = 1;
}
if(buil >= Nbuil && work >= Nwork && harv >= Nharv && AvailableEnergy > (Game.rooms[MyRoom].energyCapacityAvailable-300)) {
Nkill = 1;
if(Game.flags.Flag2 != undefined){
Nkill += 4;
}
if(Hostiles){
Nkill += 3;
}
}
return [Nbuil,Nupgr,Nwork,Nharv,Nkill,NEMon];
}
var Nos = NoCreeps(builder.length,upgrader.length,worker.length,harvester.length,defender.length,AvailableEnergy,hostiles);
//console.log(Math.pow((10-Game.rooms[MyRoom].controller.level),(10-Game.rooms[MyRoom].controller.level)/2));
if(towers.length > 0){
var damagedStructures = roads.concat(walls,ramparts,containers);
var structHp = Math.pow((10-Game.rooms[MyRoom].controller.level),(10-Game.rooms[MyRoom].controller.level)/2)
//if(!damagedStructures){
// console.log(damagedStructures);
var damagedStructures = _.filter(damagedStructures, function(structure){return (structure.hits < structure.hitsMax/structHp); });
var c = 0;
for (i = 0; i < damagedStructures.length; i++){
if(damagedStructures[i].hits < damagedStructures[c].hits){
c = i;
}
}
for(var id in towers){
var tower = towers[id];
var closestDamagedStructure = tower.pos.findClosestByRange(damagedStructures);
if(closestDamagedStructure && !hostiles) {
tower.repair(damagedStructures[c]);
}
if(hostiles) {
tower.attack(hostiles);
}
}
}
//this should be replaced with a spawnqueue in-memory with priorities. Harvesters+workers+Energymanagers have highest priority. If invasion, one set of harvester+worker+energymanager get higher priority then defence
//also involve buffered amount in the priorities. A creep body size should also be taken into account, wait untill the harvested energy is available somewhere then spawn the creep and write the desired data to memory.
//make it possible to create creeps for other rooms with the spawn of the other room
if(((Game.flags.AttackController != undefined) || (Game.flags.ClaimController != undefined) || (Game.flags.ReserveController != undefined)) && claimer.length < 1 && Game.rooms[MyRoom].energyCapacityAvailable > 1200){
var Layout = CreepBuilder.Layout(Game.rooms[MyRoom].energyCapacityAvailable/2,AvailableEnergy,0,"Claim");
var newName = Game.spawns[SpawnName].createCreep(Layout, undefined, {role: 'claimer'});
console.log('Attack/Claim/Reserve Target Controller with creep: '+newName+ ' in room '+MyRoom);
}
if(harvester.length < Nos[3]) {
var Layout = CreepBuilder.Layout(Game.rooms[MyRoom].energyCapacityAvailable/2,AvailableEnergy,12,"Transport");
var newName = Game.spawns[SpawnName].createCreep(Layout, undefined, {role: 'harvester',Home: MyRoom});
console.log('Spawning new harvester: ' + newName+ ' in room '+MyRoom);
}
if(worker.length < Nos[2]) {
var Layout = CreepBuilder.Layout(Game.rooms[MyRoom].energyCapacityAvailable/2,AvailableEnergy,4,"Work");
console.log(Layout);
var newName = Game.spawns[SpawnName].createCreep(Layout, undefined, {role: 'worker',Home: MyRoom});
console.log('Spawning new worker: ' + newName+ ' in room '+MyRoom);
}
if(energymon.length < Nos[5]) {
var Layout = CreepBuilder.Layout(Game.rooms[MyRoom].energyCapacityAvailable/4,AvailableEnergy,10,"Transport");
var newName = Game.spawns[SpawnName].createCreep(Layout, undefined, {role: 'energymon',Home: MyRoom});
console.log('Spawning new EnergyManager: ' + newName+ ' in room '+MyRoom);
}
if(defender.length < Nos[4] && harvester.length >=Nos[3] && worker.length >= Nos[2] ) {
var Layout = CreepBuilder.Layout(Game.rooms[MyRoom].energyCapacityAvailable/4,AvailableEnergy,20,"Army");
var newName = Game.spawns[SpawnName].createCreep(Layout, undefined, {role: 'defender',Home: MyRoom});
console.log('Spawning new defender: ' + newName+ ' in room '+MyRoom);
}
if(Game.rooms[MyRoom].energyCapacityAvailable < 800){
if(builder.length < Nos[0] && harvester.length >= Nos[3] && worker.length >= Nos[2] ) {
var Layout = CreepBuilder.Layout(Game.rooms[MyRoom].energyCapacityAvailable/5,AvailableEnergy,10,"Build");
var newName = Game.spawns[SpawnName].createCreep(Layout, undefined, {role: 'builder',Home: MyRoom});
console.log('Spawning new builder: ' + newName+ ' in room '+MyRoom);
}
}else{
if(builder.length < Nos[0] && harvester.length >=Nos[3] && worker.length >= Nos[2] ) {
var Layout = CreepBuilder.Layout(Game.rooms[MyRoom].energyCapacityAvailable/2,AvailableEnergy,30,"Build");
var newName = Game.spawns[SpawnName].createCreep(Layout, undefined, {role: 'builder',Home: MyRoom});
console.log('Spawning new builder: ' + newName+ ' in room '+MyRoom);
}
}
if(upgrader.length < Nos[1] && harvester.length >=Nos[3] && worker.length >= Nos[2] ) {
var Layout = CreepBuilder.Layout(Game.rooms[MyRoom].energyCapacityAvailable/2,AvailableEnergy,30,"Build");
var newName = Game.spawns[SpawnName].createCreep(Layout, undefined, {role: 'upgrader',Home: MyRoom});
console.log('Spawning new upgrader: ' + newName+ ' in room '+MyRoom);
}
var IDCounter = 0;
var SourceToggle = 0;
var WorkCounter = 0;
var HarvesterCounter = 0;
var BuildCounter = 0;
var AmountWorkMain = 0;
var AmountHarvMain = 0;
var Creephit = false;
var EmonCounter = 0;
var Sites = Game.rooms[MyRoom].find(FIND_CONSTRUCTION_SITES);
var drops = Game.rooms[MyRoom].find(FIND_DROPPED_RESOURCES);
for(var name in Game.creeps) { //get rid of this, also stop looping the rooms?
var creep = Game.creeps[name];
if(creep.memory.role == 'claimer'){
roleClaimer.run(creep);
}
if(creep.memory.Home == MyRoom){
if(creep.hits < creep.hitsMax){
Creephit = true;
Game.notify('A creep has been attacked in '+creep.pos.roomName+' at: '+creep.pos+ ' in room '+MyRoom);
}
if(Creephit){
if(healers == undefined || healers.length < 3){
var Layout = CreepBuilder.Layout(Game.rooms[MyRoom].energyCapacityAvailable/4,AvailableEnergy,20,"Heal");
var newName = Game.spawns[SpawnName].createCreep(Layout, undefined, {role: 'healer',Home: MyRoom}); // <---- look for spawn in for loop and insert here with Game.spawns[SpawnName]
console.log('Spawning new Healer, under attack!: ' + newName+ ' in room '+MyRoom);
}
}
if(creep.memory.role == 'healer'){
roleHealer.run(creep);
}
if(creep.memory.role == 'harvester') {
if(HarvesterCounter >= drops.length){
HarvesterCounter =0;
}
roleHarvester.run(creep,AmountHarvMain);
AmountHarvMain+=1;
if(AmountHarvMain == 5){
AmountHarvMain =0;
}
HarvesterCounter +=1;
}
if(creep.memory.role == 'upgrader') {
roleUpgrader.run(creep,AvailableEnergy);
}
if(creep.memory.role == 'defender') {
roleDefender.run(creep,hostiles);
}
if(creep.memory.role == 'builder') {
roleBuilder.run(creep,AvailableEnergy,BuildCounter,Sites);
BuildCounter +=1;
}
if(creep.memory.role == 'worker') {
SourceToggle = Math.abs(SourceToggle - 1);
if(AmountWorkMain < 5){
creep.memory.sourceID = sources[SourceToggle].id;
AmountWorkMain+=1;
if(WorkCounter >= sources.length){
WorkCounter = 0;
}
roleWorker.run(creep);
}
WorkCounter +=1;
}
if(creep.memory.role == 'energymon'){
roleEnergyMon.run(creep,EmonCounter);
EmonCounter += 1;
}
if(creep.ticksToLive < 3){
console.log('creep:'+creep.name+' died, function: '+creep.memory.role+', left:'+creep.carry.energy);
creep.drop(RESOURCE_ENERGY);
}
}
}
if(Game.flags.FarmFlag != undefined && !oneLoop){
startCpu = Game.cpu.getUsed();
if(Game.rooms[MyRoom].energyCapacityAvailable > 1000){
farmTile.run(Game.flags.FarmFlag,Game.spawns[SpawnName],AvailableEnergy,Game.rooms[MyRoom].energyCapacityAvailable,false);
oneLoop = true;
}
}
if(Game.flags.FarmFlag2 != undefined && !twoLoop){
if(Game.rooms[MyRoom].energyCapacityAvailable > 1000){
farmTile.run(Game.flags.FarmFlag2,Game.spawns[SpawnName],AvailableEnergy,Game.rooms[MyRoom].energyCapacityAvailable,true);
twoLoop = true;
}
}
}
//Game.profiler.email(1800);
//Game.profiler.profile(10);
var MainLoop = Game.cpu.getUsed();
if(!Memory.CpuStats){
Memory.CpuStats = {
TickCounter: 0,
AggregatedAverage: MainLoop,
};
}
if(Memory.CpuStats.TickCounter > LogLength){
console.log('Aggregated average :'+Memory.CpuStats.AggregatedAverage+' collected over '+LogLength+' loops.');
Game.notify('Aggregated average :'+Memory.CpuStats.AggregatedAverage+' collected over '+LogLength+' loops.', 720);
Memory.CpuStats.TickCounter = 0;
Memory.CpuStats.AggregatedAverage = MainLoop;
Game.profiler.profile(5);
}else{
Memory.CpuStats.AggregatedAverage = (Memory.CpuStats.AggregatedAverage + MainLoop)/2;
}
Memory.CpuStats.TickCounter += 1;
var shortage = MainLoop-Game.cpu.limit;
if(shortage > 0){
var message = 'CPU usage-limit='+shortage+' - CPU:'+MainLoop+' ; Bucket:'+Game.cpu.bucket+'; TickLimit:'+Game.cpu.tickLimit+' ;happened at tick: '+Game.time;
console.log(message);
Game.notify(message, 720);
}else{
console.log('TickTime: '+Game.time+' ;Used CPU: '+MainLoop+' ; CPU to Bucket:'+Math.abs(shortage)+' ; BucketVolume:'+Game.cpu.bucket);
}
});
//Game.profiler.profile(10);
}
module.exports.loop = function () {
profiler.wrap(function() {
var LogLength = 20;
//var MyRoom = Game.spawns.Spawn1.room.name;
var NumberOfCreeps = 0;
for(var name in Memory.creeps) {
NumberOfCreeps += 1;
if(!Game.creeps[name]) {
delete Memory.creeps[name];
}
}
for(var i in Memory.Warband) {
Wb = Memory.Warband[i]
for(var j in Wb.Names){
var name = Memory.Warband[i].Names.shift();
if(!Game.creeps[name]) {
console.log("Deleting "+name);
}else{
Memory.Warband[i].Names.push(name);
//console.log(i+' '+name);
}
}
}
var oneLoop = false;
var twoLoop = false;
//MonMan.TacticalSetup('W14N48','W14N48');//works correctly
//Mem.initWarband('Light','test','test','Offensive',['henk','piet','fred'],1,2,3,4,5,6);
//MonMan.PrimeTargets(Game.rooms['W14N48'].storage,Memory.Warband[0]);
//console.log(Jobs.FindHostile('W14N48'));
//console.log(Jobs.FindHostile("W14N48"));<----- replace all FindHostileCreep functions with this function.
//
//MonMan.ManageWarbands();
//Jobs.FindHostile('W14N48');
if(Memory.SpawnActivity == undefined){
Memory.SpawnActivity = [];
}
if(Memory.SpawnActivityLt == undefined){
Memory.SpawnActivityLt = [];
}
if(Memory.Spawning){
var length = Memory.SpawnActivity.unshift(1);
}else{
var length = Memory.SpawnActivity.unshift(0);
}
if(Memory.SpawnActivity.length > 2999){
Memory.SpawnActivity.pop();
}
if(Memory.SpawnActivityLt.length > 99){
Memory.SpawnActivityLt.pop();
}
var SpawnActivity = 0;
for(i in Memory.SpawnActivity){
if(Memory.SpawnActivity[i] == 1){
SpawnActivity += 1;
}
}
Memory.SpawnActivityLt.unshift((SpawnActivity/length)*100);
if((Memory.tenCounter == undefined )|| (Memory.tenCounter < Game.time)){ //10 ticks counter
console.log('SpawnActivity 100 ticks ago: '+Memory.SpawnActivityLt[Memory.SpawnActivityLt.length - 1]+'%, Spawnactivity Now: '+Memory.SpawnActivityLt[0]+'%');
Memory.tenCounter = Game.time + 10;
MonMan.MonitorWarbands();
MonMan.TerritoryMonitor(false); //if set to true, expansion code will be active.
MonMan.SpawnCreep();
//Mem.Allies('Kwabratseur');
//Mem.Allies('Nutcustard');
//Mem.Allies('Garland');
}
if((Memory.fiftyCounter == undefined) || (Memory.fiftyCounter < Game.time)){ //50 ticks counter
Memory.fiftyCounter = Game.time + 50;
if((Memory.failedSpawn == undefined) || (Memory.failedSpawn > 0)){
Memory.failedSpawn = 0;
}
}
if((Memory.hourCounter == undefined) || (Memory.hourCounter < Game.time)){ //hour counter
Memory.hourCounter = Game.time + (3600/2.5);
}
for(var i in Memory.roomdb){// seek correct location in relation to DB initialization
var rooms = Memory.roomdb[i];
var Sites = 0;
if(Game.rooms[rooms[0]] != undefined){
var Sites = Game.rooms[rooms[0]].find(FIND_CONSTRUCTION_SITES);
}
var CreepState = MonMan.TerritoryManager(rooms,0,0,Sites); //uncomment
rooms[8] = CreepState[0]; //amount of creeps currently present
rooms[7] = 0; //amount of killed creeps within x ticks
Memory.roomdb[i] = rooms; //set to memory.
}
for(var name in Game.spawns){ // Try to include All code except for FarmRoom code in this loop. Maybe multiple rooms can be controlled in this way.
var SpawnName = name;
var MyRoom = Game.spawns[SpawnName].room.name; //Then offcourse make everything depend from variable MyRoom(mostly the case)
var AvailableEnergy = 0;
AvailableEnergy = Game.rooms[MyRoom].energyAvailable;
var buildInfra = false;
if((Memory.weekCounter == undefined) || (Memory.weekCounter < Game.time)){ //weekly counter
Memory.weekCounter = Game.time + ((3600*24*7)/2.5);
MonMan.ConsiderTerritory(MyRoom);
}//will only execute for first loop
var EcenterName = MyRoom+'EnergyCenter';
// make function which places this flag on a good pos.
// Just make a Flag-manager which places additional flags.
// Current implemented flags:
//'RoomName'@ 25,25 (used for creep navigation);
//'RoomName'EnergyCenter @ free grid of around 9*10 (L*B) orientated left, down relative from the flag.
// Siege'RoomName' @ room you want to attack (WIP)(Could be regulated with flagManager for holidays)
// include downgrading controllers in this section
// Reserve'RoomName' @ room you want to reserve (farm)(WIP, will be regulated with flagManager)
// Claim'RoomName' @ room you want to claim (probably a farm before)(WIP, will be regulated with flagManager)
/*
Add some bucket modes.
Depending what the circumstances are, the code execution should be prioritized differently.
When there is a need to defend territory, a more aggressive mode can be activated which prioritizes the
creation of defenders + their movement and the energy maintenance of all structures. The code can be allowed
to drain additional CPU from the bucket in this case.
When everything is fine, the bucket should be recharged to around 80% for the case another attack comes.
When attacking, the same can be done for the army's movement and attack moves to be sure it's effective.
*/
if(!Game.flags.MyRoom){ //'RoomName flag'
Game.rooms[MyRoom].createFlag(25, 25, MyRoom);
} //place flag for each room
if(!Memory.rooms[MyRoom]){
Memory.rooms[MyRoom] = {};
}
if(!Memory.rooms[MyRoom].RoomInfo){ ///Use this method to save on CPU, try to add as much variables as possible without getting into memory problems.
Mem.set(MyRoom,SpawnName);
console.log('Setting memory for room: '+MyRoom);
}
var containers = Mem.run(Memory.rooms[MyRoom].RoomInfo.Containers);
var towers = Mem.run(Memory.rooms[MyRoom].RoomInfo.Towers);
var storages = Mem.run(Memory.rooms[MyRoom].RoomInfo.Storages); // that's it! this can save a lot of CPU of done everywhere.
var links = Mem.run(Memory.rooms[MyRoom].RoomInfo.Links);
var sources = Mem.run(Memory.rooms[MyRoom].RoomInfo.Sources);
var extensions = Mem.run(Memory.rooms[MyRoom].RoomInfo.Extensions);
var walls = Mem.run(Memory.rooms[MyRoom].RoomInfo.Walls);
var ramparts = Mem.run(Memory.rooms[MyRoom].RoomInfo.Ramparts);
var roads = Mem.run(Memory.rooms[MyRoom].RoomInfo.Roads);
//extractors = Mem.run(Memory.rooms[MyRoom].RoomInfo.Extractors);
//terminals = Mem.run(Memory.rooms[MyRoom].RoomInfo.Terminals);
//labs = Mem.run(Memory.rooms[MyRoom].RoomInfo.Labs);
var Sites = Game.rooms[MyRoom].find(FIND_CONSTRUCTION_SITES);
var structs = Game.rooms[MyRoom].find(FIND_STRUCTURES);
var drops = Game.rooms[MyRoom].find(FIND_DROPPED_RESOURCES);
function removeSites(){
for(i in Sites){
Sites[i].remove();
}
}
//removeSites(); //in case something goes wrong..
//energyCenter(Game.flags[EcenterName]);
//SourceStorage();
var SetupDefense = (function() {
var executed = false;
return function () {
if (!executed) {
executed = true;
var ExitCoords = Game.rooms[MyRoom].find(FIND_EXIT);
roomDefense.run(ExitCoords,MyRoom);
}
};
})();
//SetupDefense();
if(Game.rooms[MyRoom].memory.Level == undefined || Game.rooms[MyRoom].controller.level != Game.rooms[MyRoom].memory.Level){
Memory.rooms[MyRoom].Level = Game.rooms[MyRoom].controller.level;
Game.notify('Room: '+MyRoom+' Just leveled up to'+Game.rooms[MyRoom].controller.level);
console.log('Room: '+MyRoom+' Just leveled up to'+Game.rooms[MyRoom].controller.level);
if(Game.rooms[MyRoom].controller.level == 2){
Memory.rooms[MyRoom].Eticks = Game.time + 500;
}else{
Memory.rooms[MyRoom].Eticks = Game.time + 3;
}
Mem.reset(MyRoom);
}
if((Memory.rooms[MyRoom].Eticks - Game.time) > 0){ //spread more tasks over longer period
var Ecenter = Game.flags[EcenterName];
buildInfra = true;
if((Memory.rooms[MyRoom].Eticks - Game.time) > 490){
console.log('setting up defenses and energycenter');
if((Memory.rooms[MyRoom].Eticks - Game.time) > 495){
energyCenter(Ecenter);
SourceStorage();
}else{
SetupDefense();
}
}
if((Memory.rooms[MyRoom].Eticks - Game.time) < 3){
energyCenter(Ecenter);
}
}
function SourceStorage(){ //jep, this works :) automated container building @ sources
for(id in sources){ // Look for link near sources
var creepTemp = sources[id].pos.findInRange(FIND_MY_CREEPS,2);
var containerTemp = sources[id].pos.findInRange(STRUCTURE_CONTAINER,2);
var creepTemp = sources[id].pos.findClosestByRange(creepTemp);//always returns 1 creep this way
console.log(containerTemp.length);
if(containerTemp.length < 1){
console.log(creepTemp.pos);
Game.rooms[MyRoom].createConstructionSite(creepTemp.pos,STRUCTURE_CONTAINER);
}
}
}
//SourceStorage();
function energyCenter(FlagPos){ //change loop order
//console.log(FlagPos.pos.x);
var BuildPosX = FlagPos.pos.x;
var BuildPosY = FlagPos.pos.y;
var c = 0;
var BuildingToggle = true; //true is positive, false is negative
var NoEx = 5;
if(Game.rooms[MyRoom].controller.level > 2){
NoEx = (NoEx*2)*(Game.rooms[MyRoom].controller.level-2);
}
for (var j = 0; j < (NoEx/5); j++){
for(i = 0 ; i < 9; i++){
if(BuildingToggle){
BuildingToggle = false;
Game.rooms[MyRoom].createConstructionSite(BuildPosX,BuildPosY,STRUCTURE_EXTENSION);
}else{
Game.rooms[MyRoom].createConstructionSite(BuildPosX,BuildPosY,STRUCTURE_ROAD);
BuildingToggle = true;
}
c +=1;
BuildPosX -= 1;
}
BuildPosX = FlagPos.pos.x;
BuildPosY += 1;
}
}
var linkFrom = 0;
if(storages.length > 0){ // Rewrite Link-code, maybe put it in own Module, at least make it use the memory ID's.
var linkController = 0;
var linkTower = 0;
var linkTo = Game.rooms[MyRoom].storage.pos.findInRange(links,2);
for(id in sources){ // Look for link near sources
var linkTemp = sources[id].pos.findInRange(links,2);
if(linkTemp.length > 0){
linkFrom = linkTemp[0];
} // if link is found near a source, designate it as a linkFrom
}
if(Game.rooms[MyRoom].controller.pos.findInRange(links, 2)){ //look for link near controller
linkController = Game.rooms[MyRoom].controller.pos.findInRange(links, 2);
}
if(towers.length > 0){ //look for links near towers
for(var id in towers){
var linkTemp = towers[id].pos.findInRange(links, 2);
if(linkTemp.length > 0){
linkTower = linkTemp;
}
}
}
if(linkTo != undefined){ //if controller || tower links are defined and empty, prioritize them over the storage link.
if(linkController.pos != undefined && linkController.energy == 0){
linkTo[0] = LinkController[0];
}else if(linkTower.pos != undefined && linkTower.energy == 0){
linkTo[0] = linkTower[0];
}
if(linkFrom.energy == linkFrom.energyCapacity && linkTo[0].energy == 0 && linkFrom.cooldown == 0){
linkFrom.transferEnergy(linkTo[0]); //then send the energy
}
}
}
var hostiles = Game.spawns[SpawnName].pos.findClosestByRange(Jobs.FindHostile(MyRoom));
if(hostiles){
var existingBand = false;
for(var i in Memory.Warband){
if(Memory.Warband[i].Flag == rooms[0]){
existingBand = true;
}
}
if(!existingBand){
MonMan.Warband('Light',MyRoom,'Defensive');
}
}
var healer = Game.spawns[SpawnName].pos.findClosestByRange(Jobs.FindHostile(MyRoom), { // <-----------------------that's how we find stuff in the room, check code for occurance.
filter: function(object) {
return object.getActiveBodyparts(HEAL) != 0;
}
});
if(healer){
hostiles = healer;
}
MonMan.manager(MyRoom,drops,buildInfra,AvailableEnergy,Sites,sources);
MonMan.monitor(MyRoom);
if(towers.length > 0){
var damagedStructures = ramparts;
var structHp = Math.pow((11-Game.rooms[MyRoom].controller.level),(11-Game.rooms[MyRoom].controller.level)/2)
var damagedStructures = _.filter(damagedStructures, function(structure){return (structure.hits < 300000); });
//var damagedStructures = damagedStructures.concat(roads,towers,Game.spawns[SpawnName])
damagedStructures.concat(containers);
var c = 0;
for (i = 0; i < damagedStructures.length; i++){
if(damagedStructures[i].hits < damagedStructures[c].hits){
c = i;
}
}
for(var id in towers){
var tower = towers[id];
if(damagedStructures[c] && tower.energy > tower.energyCapacity*0.89){
tower.repair(damagedStructures[c]);
}
if(hostiles) {
tower.attack(hostiles);
}
}
}
if((!Memory.rooms[MyRoom].Sites || (Memory.rooms[MyRoom].Sites != Sites.length)) && (Sites.length > 0)){
Memory.rooms[MyRoom].Sites = Sites.length;
console.log('Building structure /making build queue in room'+MyRoom+', BuildingSites:'+Sites.length);
Mem.reset(MyRoom);
}
if(!Memory.rooms[MyRoom].structs || (Memory.rooms[MyRoom].structs != structs.length)){
Memory.rooms[MyRoom].structs = structs.length;
console.log('Building Destroyed/built in '+MyRoom+', Buildings:'+structs.length);
Mem.reset(MyRoom);
}
//Game.profiler.email(1800);
//Game.profiler.profile(10);
var message = '';
var MainLoop = Game.cpu.getUsed();
if(!Memory.CpuStats){
Memory.CpuStats = {
TickCounter: 0,
AggregatedAverage: MainLoop,
};
}
if(Memory.CpuStats.TickCounter > LogLength){
message += ' Aggregated average :'+Memory.CpuStats.AggregatedAverage+' collected over '+LogLength+' loops.', 720;
//console.log('Aggregated average :'+Memory.CpuStats.AggregatedAverage+' collected over '+LogLength+' loops.');
Game.notify('Aggregated average :'+Memory.CpuStats.AggregatedAverage+' collected over '+LogLength+' loops.', 720);
Memory.CpuStats.TickCounter = 0;
Memory.CpuStats.AggregatedAverage = MainLoop;
Game.profiler.profile(5);
}else{
Memory.CpuStats.AggregatedAverage = (Memory.CpuStats.AggregatedAverage + MainLoop)/2;
}
Memory.CpuStats.TickCounter += 1;
if(Memory.roomdb == undefined){
Memory.roomdb = [];
MonMan.ConsiderTerritory(MyRoom);//change to MyRoom for online implementation
}
var shortage = MainLoop-10;
if(shortage > 0){
message += ' CPU usage-limit='+shortage+' ; Bucket:'+Game.cpu.bucket+' ;happened at tick: '+Game.time;
//var message = 'CPU usage-limit='+shortage+' ; Bucket:'+Game.cpu.bucket+' ;happened at tick: '+Game.time;
//console.log('Average CPU('+MainLoop+') Usage Per Creep('+NumberOfCreeps+') = '+(MainLoop/NumberOfCreeps));
Game.notify(message, 720);
}else{
message += ' TickTime: '+Game.time+' ; CPU to Bucket:'+Math.abs(shortage)+' ; BucketVolume:'+Game.cpu.bucket;
//console.log('Average CPU('+MainLoop+') Usage Per Creep('+NumberOfCreeps+') = '+(MainLoop/NumberOfCreeps));
//console.log('TickTime: '+Game.time+' ; CPU to Bucket:'+Math.abs(shortage)+' ; BucketVolume:'+Game.cpu.bucket);
}
message += ' Average CPU('+MainLoop+') Usage Per Creep('+NumberOfCreeps+') = '+(MainLoop/NumberOfCreeps);
console.log(message);
//if(TargetRoom.room != undefined && TargetRoom.room.controller.reservation != undefined && TargetRoom.room.controller.reservation.username == 'Kwabratseur'){
}
});
//Game.profiler.profile(10);
// Run Stats collection
}