Tick: function() {
for(var name in Game.creeps) {
var creep = Game.creeps[name]
if (creep){
switch(creep.memory.role) {
case 'smallharvester' :
case 'harvester' : roleHarvester.Tick(creep); continue;
case 'upgrader' : roleUpgrader.Tick(creep); continue;
case 'builder' : roleBuilder.Tick(creep); continue;
case 'distributor' :
case 'smalldistributor' :
case 'towerdistributor': roleDistributor.Tick(creep); continue;
case 'repairer' : roleRepairer.Tick(creep); continue;
case 'carrier' : roleCarrier.Tick(creep); continue;
case 'explorer' : roleExplorer.Tick(creep); continue;
case 'reserver' : roleReserver.Tick(creep); continue;
case 'custom' : roleCustom.Tick(creep); continue;
case 'sapper' : roleSapper.Tick(creep); continue;
case 'claimer' : roleClaimer.Tick(creep); continue;
case 'soaker' : roleSoaker.Tick(creep); continue;
case 'healer' : roleHealer.Tick(creep); continue;
case 'defender' : roleDefender.Tick(creep); continue;
}
}
}
}
module.exports.loop = function () {
global.removeDeadCreeps();
for (var name in Game.creeps) {
var creep = Game.creeps[name];
if (creep.memory.role == 'harvester') { roleHarvester.run(creep); }
if (creep.memory.role == 'upgrader') { roleUpgrader.run(creep); }
if (creep.memory.role == 'builder') { roleBuilder.run(creep); }
if( creep.memory.role == 'guard'){ roleGuard.run(creep);}
if( creep.memory.role == 'roadrepairer'){ roleRoadRepairer.run(creep);}
}
countRoles();
var now = new Date();
var creepSuffix = now.getDate() + now.getHours();
if(global.creepRoleCount["harvester"] < 2) {
Game.spawns.Home.createCreep([WORK, CARRY, MOVE, MOVE], 'Harvester'.concat(creepSuffix), { role: 'harvester'});
}
if(global.creepRoleCount["builder"] < 2) {
Game.spawns.Home.createCreep([WORK, CARRY, MOVE], 'Builder'.concat(creepSuffix), { role: 'builder'});
}
if(global.creepRoleCount["upgrader"] < 2) {
Game.spawns.Home.createCreep([WORK, WORK, CARRY, MOVE], 'Upgrader'.concat(creepSuffix), { role: 'upgrader'});
}
if(global.creepRoleCount["roadrepairer"] < 2) {
Game.spawns.Home.createCreep([WORK, WORK, CARRY, MOVE], 'RoadRepairer'.concat(creepSuffix), { role: 'roadrepairer'});
}
if(global.creepRoleCount["guard"] < 2) {
//console.log("Spawning guard: " +
Game.spawns.Home.createCreep([TOUGH, ATTACK, RANGED_ATTACK, MOVE], 'Guard'.concat(creepSuffix) , { role: 'guard'});//);
}
}
module.exports.loop = function () {
var i = 0;
for(var name in Game.creeps) {
var creep = Game.creeps[name];
if(creep.memory.role == 'harvester') {
roleHarvester.run(creep);
}
if(creep.memory.role == 'builder') {
creep.memory.sourceNr = 1;
roleBuilder.run(creep);
}
if(creep.memory.role == 'upgrader') {
creep.memory.sourceNr = 0;
roleUpgrader.run(creep);
}
if(creep.memory.role == 'defender') {
roleDefender.run(creep);
}
if(creep.memory.role == 'transporter') {
roleTransporter.run(creep);
}
i++;
}
rolePopulate.run(Game.spawns.ComandCenter);
garbagecollector();
tower.guard("E11S48");
var containers = Game.rooms["E11S48"].find(
FIND_STRUCTURES, {filter: {structureType: STRUCTURE_CONTAINER}});
//containers.forEach(container => console.log(container.structureType));
//console.log("\n\n")
container.fill(containers[0]);
container.fill(containers[1]);
}
module.exports.loop = function () {
console.log("=============TICK==============")
for(var name in Game.rooms) {
spawner.run(Game.rooms[name])
}
var towers = _.filter(Game.structures, {structureType: STRUCTURE_TOWER})
for (var tower in _.filter(Game.structures, {structureType: STRUCTURE_TOWER})) {
towerDefender.run(tower);
}
for(var name in Game.creeps) {
var creep = Game.creeps[name];
if(creep.memory.role == 'harvester') {
roleHarvester.run(creep);
}
if(creep.memory.role == 'upgrader') {
roleUpgrader.run(creep);
}
if(creep.memory.role == 'builder') {
roleBuilder.run(creep);
}
}
}
module.exports.loop = function () {
// console.log('tick');
for (var name in Memory.creeps) {
if (!Game.creeps[name]) {
delete Memory.creeps[name];
console.log('Clearing non-existing creep memory:', name);
} else {
var creep = Game.creeps[name];
if (typeof creep.memory.sourceId !== 'number') {
var sources = creep.room.find(FIND_SOURCES);
creep.memory.sourceId = utils.getRandomInt(0, 3) >= 1 ? 0 : 1;
//Math.round(Math.random() * (sources.length - 1));
}
}
}
bio.recreate();
towerLogic.do([]);
for (var name in Game.creeps) {
var creep = Game.creeps[name];
switch (creep.memory.role) {
case C.HARVESTER_ROLE: roleHarvester.run(creep); break;
case C.UPGRADER_ROLE: roleUpgrader.run(creep); break;
case C.BUILDER_ROLE: roleBuilder.run(creep); break;
case C.WARRIOR_ROLE: roleWarrior.run(creep); break;
default: console.log("unknow role: " + creep.memory.role + "; for " + name);
}
}
}
workers.sort().map((worker, i) => {
if (i === 0 && worker.length > 1) {
// make sure someone is always upgrading (unless only 1 worker exists)
roleUpgrader.run(worker, i);
} else if (needMoreEnergy) {
// we are not at full capacity - let's harvest!
roleHarvester.run(worker, i);
} else if(i > (workers.length / 2) && constructionSites.length !== 0) {
// Use half the workforce to keep building
roleBuilder.run(worker, i);
} else if(i <= controller.level && brokenStructures.length > 0) {
roleFixer.run(worker, i);
} else {
// Everyone else upgrades
roleUpgrader.run(worker, i);
}
});
module.exports.loop = function () {
var roomName = _.filter(Game.creeps, function(creep){return creep})[0].room.name;
var controller = Game.rooms[roomName].find(FIND_MY_STRUCTURES, {filter: {structureType: STRUCTURE_CONTROLLER}})[0];
if(controller.level == 1){
phaseOne.run();
}
else if(controller.level == 2){
phaseTwo.run();
}
for(var name in Game.creeps) {
var creep = Game.creeps[name];
creep.say("Don't Kill Me")
if(creep.memory.role == 'harvester') {
roleHarvester.run(creep);
}
if(creep.memory.role == 'builder') {
roleBuilder.run(creep);
}
if(creep.memory.role == 'upgrader') {
roleUpgrader.run(creep);
}
}
}
run: function(creep) {
// if creep is trying to repair something but has no energy left
if (creep.memory.working == true && creep.carry.energy == 0) {
// switch state
creep.memory.working = false;
}
// if creep is harvesting energy but is full
else if (creep.memory.working == false && creep.carry.energy == creep.carryCapacity) {
// switch state
creep.memory.working = true;
}
// if creep is supposed to repair something
if (creep.memory.working == true) {
// find all walls in the room
var walls = creep.room.find(FIND_STRUCTURES, {
filter: (s) => s.structureType == STRUCTURE_WALL
});
var target = undefined;
// loop with increasing percentages
for (let percentage = 0.0001; percentage <= 1; percentage = percentage + 0.0001){
// find a wall with less than percentage hits
target = creep.pos.findClosestByPath(walls, {
filter: (w) => w.hits / w.hitsMax < percentage
});
// if there is one
if (target != undefined) {
// break the loop
break;
}
}
// if we find a wall that has to be repaired
if (target != undefined) {
// try to repair it, if not in range
if (creep.repair(target) == ERR_NOT_IN_RANGE) {
// move towards it
creep.moveTo(target);
}
}
// if we can't fine one
else {
// look for construction sites
roleBuilder.run(creep);
}
}
// if creep is supposed to harvest energy from source
else {
// find closest source
var source = creep.pos.findClosestByPath(FIND_SOURCES);
// try to harvest energy, if the source is not in range
if (creep.harvest(source) == ERR_NOT_IN_RANGE) {
// move towards the source
creep.moveTo(source);
}
}
}
module.exports.loop = function () {
// Always place this memory cleaning code at the very top of your main loop!
for(var name in Memory.creeps) {
if(!Game.creeps[name]) {
delete Memory.creeps[name];
console.log('Clearing non-existing creep memory:', name);
}
}
//call our module for spawning creeps:
buildCreeps.run();
for(var name in Game.creeps) {
var creep = Game.creeps[name];
if(creep.memory.role == 'harvester') {
roleHarvester.run(creep);
}
if(creep.memory.role == 'upgrader') {
roleUpgrader.run(creep);
}
if(creep.memory.role == 'builder') {
roleBuilder.run(creep);
}
if(creep.memory.role == 'storekeeper') {
roleStorekeeper.run(creep);
}
if(creep.memory.role == 'repairbot') {
roleRepairbot.run(creep);
}
}
}
exports.loop = function () {
// spawn('claimer', 1);
spawn('builder', 7);
spawn('upgrader', 8);
spawn('harvester', 7);
stats.status();
structureKeeper.run();
//console.log(JSON.stringify(creepKeeper.findSource(['576a9bad57110ab231d87b8e'])));
for (var name in Game.creeps) {
var creep = Game.creeps[name];
if (creepKeeper.recycle(creep)) {
continue;
}
if (creep.memory.role === 'harvester') {
roleHarvester.run(creep);
}
if (creep.memory.role === 'upgrader') {
roleUpgrader.run(creep);
}
if (creep.memory.role === 'builder') {
roleBuilder.run(creep);
}
}
};
work: function() {
for (var name in Game.creeps) {
var creep = Game.creeps[name]
if (creep.memory.role == 'harvester' || creep.memory.role == 'longDistanceHarvester') {
roleHarvester.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 == 'repairer') {
roleRepairer.run(creep)
}
else if (creep.memory.role == 'transporter') {
roleTransporter.run(creep)
}
else if (creep.memory.role == 'claimer') {
roleClaimer.run(creep)
}
else if (creep.memory.role == 'defender') {
roleDefender.run(creep)
}
}
},
module.exports.loop = function () {
var tower = Game.getObjectById('d96dc1852977a45ffb8b6c8f');
if(tower) {
var closestDamagedStructure = tower.pos.findClosestByRange(FIND_STRUCTURES, {
filter: (structure) => structure.hits < structure.hitsMax
});
if(closestDamagedStructure) {
tower.repair(closestDamagedStructure);
}
var closestHostile = tower.pos.findClosestByRange(FIND_HOSTILE_CREEPS);
if(closestHostile) {
tower.attack(closestHostile);
}
}
for(var name in Game.creeps) {
var creep = Game.creeps[name];
if(creep.memory.role == 'harvester') {
roleHarvester.run(creep);
}
if(creep.memory.role == 'upgrader') {
roleUpgrader.run(creep);
}
if(creep.memory.role == 'builder') {
roleBuilder.run(creep);
}
}
}
run: function(creep) {
if (creep.memory.working && creep.carry.energy == 0) {
creep.memory.working = false;
}
if (!creep.memory.working && creep.carry.energy == creep.carryCapacity) {
creep.memory.working = true;
}
if (creep.memory.working) {
var closestDamagedStructure = creep.pos.findClosestByRange(FIND_STRUCTURES, {
filter: (structure) => (structure.hits < structure.hitsMax && structure.structureType != STRUCTURE_WALL)
});
if (closestDamagedStructure) {
if (creep.repair(closestDamagedStructure) == ERR_NOT_IN_RANGE) {
creep.moveTo(closestDamagedStructure);
}
}
else if(!closestDamagedStructure){
var targets = creep.room.find(FIND_STRUCTURES, {
filter: (structure) => {return structure.structureType == STRUCTURE_TOWER && structure.energy < structure.energyCapacity;}
});
if(targets != undefined && targets.length > 0) {
if(creep.transfer(targets[0], RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
creep.moveTo(targets[0]);
}
}
else {roleBuilder.run(creep);}
}
}
else {
var sources = creep.room.find(FIND_SOURCES);
if(creep.harvest(sources[1]) == ERR_NOT_IN_RANGE) {
creep.moveTo(sources[1]);
}
}
}
module.exports.loop = function () {
// Always place this memory cleaning code at the very top of your main loop!
for(var name in Memory.creeps) {
if(!Game.creeps[name]) {
delete Memory.creeps[name];
console.log('Clearing non-existing creep memory:', name);
}
}
taskPopControl.run();
taskTower.defend();
taskTower.repair();
for(var name in Game.creeps) {
var creep = Game.creeps[name];
if(creep.memory.role == 'harvester') {
roleHarvester.run(creep);
}
if(creep.memory.role == 'builder'){
roleBuilder.run(creep);
}
if(creep.memory.role == 'upgrader') {
roleUpgrader.run(creep);
}
if(creep.memory.role == 'repairer') {
roleRepairer.run(creep);
}
}
};
module.exports.loop = function () {
for (let name in Memory.creeps) {
if (!Game.creeps[name]) {
delete Memory.creeps[name];
console.log('Clearing non-existing creep memory: ', name);
}
}
spawner.check();
spawner.spawn();
let towers = _.filter(Game.structures, (structure) => structure.structureType == STRUCTURE_TOWER);
if (towers.length > 0) {
let targets = towers[0].room.find(FIND_STRUCTURES, {
filter: object => object.hits < object.hitsMax &&
object.structureType == STRUCTURE_CONTAINER ||
object.structureType == STRUCTURE_WALL ||
object.structureType == STRUCTURE_RAMPART
});
if (targets != null) {
targets.sort((a, b) => a.hits - b.hits);
towers.forEach(tower => {
tower.repair(targets[0]);
});
}
}
for (let name in Game.creeps) {
let creep = Game.creeps[name];
if (creep.memory.role == 'harvester') {
roleHarvester.run(creep);
}
else if (creep.memory.role == 'carry') {
roleCarry.run(creep);
}
else if (creep.memory.role == 'melee') {
roleMelee.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 == 'repair') {
roleRepair.run(creep);
}
else if (creep.memory.role == 'supply') {
roleSupply.run(creep);
}
}
};
module.exports.loop = function () {
for(var name in Game.creeps) {
var creep = Game.creeps[name];
if(creep.memory.role == 'harvester') {
roleHarvester.run(creep);
}
if(creep.memory.role == 'builder') {
roleBuilder.run(creep);
}
}
}
run: function(creep) {
// if creep is bringing energy to the spawn but has no energy left
if (creep.memory.working == true && creep.carry.energy == 0) {
// switch state
creep.memory.working = false;
}
// if creep is harvesting energy but is full
else if (creep.memory.working == false && creep.carry.energy == creep.carryCapacity) {
// switch state
creep.memory.working = true;
}
// if creep is supposed to transfer energy to the spawn
if (creep.memory.working == true) {
// try to transfer energy, if the spawn is not in range
var structure = creep.pos.findClosestByPath(FIND_MY_STRUCTURES, {
// the second argument for findClosestByPath is an object which takes
// a property called filter which can be a function
// we use the arrow operator to define it
filter: (s) => (s.structureType == STRUCTURE_SPAWN
|| s.structureType == STRUCTURE_EXTENSION
|| s.structureType == STRUCTURE_CONTAINER)
&& s.energy < s.energyCapacity
});
if (structure != undefined) {
if (creep.transfer(structure, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
// move towards the spawn
creep.moveTo(structure);
}
}
else {
roleBuilder.run(creep);
}
}
// if creep is supposed to harvest energy from source
else {
// find closest source
var source = creep.pos.findClosestByPath(FIND_SOURCES);
// try to harvest energy, if the source is not in range
if (creep.harvest(source) == ERR_NOT_IN_RANGE) {
// move towards the source
creep.moveTo(source);
}
}
}
module.exports.loop = function () {
for(var name in Memory.creeps) {
if(!Game.creeps[name]) {
delete Memory.creeps[name];
}
}
for (var name in Game.spawns)
{
var spawn = Game.spawns[name]
structSpawn.run(spawn);
}
for(var name in Game.creeps) {
var creep = Game.creeps[name];
creepActions.run(creep);
switch(creep.memory.role)
{
case 'pick':
pickAndGo.run(creep);
break;
case 'harvester':
roleHarvester.run(creep);
break;
case 'upgrader':
roleUpgrader.run(creep);
break;
case 'builder':
roleBuilder.run(creep);
break;
case 'guard':
case 'archer':
roleGuard.run(creep);
break;
case 'mechanic':
roleMechanic.run(creep);
break;
case 'transfer':
roleTransfer.run(creep);
break;
case 'extend':
roleExtend.run(creep);
break;
case 'taker':
creep.memory.role = 'pick';
break;
}
}
}
module.exports.loop = function () {
for(var name in Memory.creeps) {
if(!Game.creeps[name]) {
delete Memory.creeps[name];
}
}
//var structures = _.filter(Game.structures, (s) => { return s.hits != undefined && s.hitsMax != undefined});
//console.log(structures);
//console.log("Structures needs repair: " + structures.filter((s) => { return s.hits < s.hitsMax; }).length + "/" + structures.length);
roleSpawn.run(Game.spawns['Central command']);
for(var name in Game.creeps) {
var creep = Game.creeps[name];
if(creep.memory.role == 'harvester') {
roleHarvester.run(creep);
}
if(creep.memory.role == 'upgrader') {
roleUpgrader.run(creep);
}
if(creep.memory.role == 'builder') {
//roleBuilder.run(creep, 0);
var targets = creep.room.find(FIND_FLAGS, {
filter: { name : 'Idle' }
});
if(targets.length)
{
creep.moveTo(targets[0]);
}
}
if(creep.memory.role == 'builder2') {
roleBuilder.run(creep, 0);
}
if(creep.memory.role == 'miner') {
roleMiner.run(creep);
}
if(creep.memory.role == 'repairder') {
//roleRepairder.run(creep);
var targets = creep.room.find(FIND_FLAGS, {
filter: { name : 'Idle' }
});
if(targets.length)
{
creep.moveTo(targets[0]);
}
}
}
}
module.exports.loop = function () {
for(var name in Game.rooms) {
console.log('Room ""'+name+'"" has '+Game.rooms[name].energyAvailable+' energy');
Memory.SourceController = helperCreateSourceModel.createSourceModel(Game.rooms[name]);
}
for(var name in Memory.creeps) {
if(!Game.creeps[name]) {
delete Memory.creeps[name];
}
}
var harvesters = _.filter(Game.creeps, (creep) => creep.memory.role == 'harvester');
//console.log('Harvesters: ' + harvesters.length);
if(harvesters.length < 0) {
var newName = Game.spawns.Spawn1.createCreep([WORK,CARRY,MOVE], undefined, {role: 'harvester'});
console.log('Spawning new harvester: ' + newName);
}
for(var name in Game.rooms) {
/**console.log('Room ""'+name+'"" has '+Game.rooms[name].energyAvailable+' energy');**/
}
for (var name in Game.creeps) {
var creep = Game.creeps[name];
if(creep.memory.role == 'harvester') {
roleHarvester.run(creep);
}
if(_bPauseBuilders == 0 && (creep.memory.role == 'builder' || (_bUpgradersAreBuilders == 1 && creep.memory.role == 'upgrader'))) {
roleBuilder.run(creep);
}
if(creep.memory.role == 'upgrader' && _bUpgradersAreBuilders == 0 && _bPauseUpgraders == 0) {
roleUpgrader.run(creep);
}
if (_bPauseMules == 0 && creep.memory.role == 'mule') {
roleMule.run(creep);
}
if (creep.memory.role == 'recycle') {
roleRecycle.run(creep);
}
if (creep.memory.role == 'builderMiner') {
roleBuilderMiner.run(creep);
}
}
//console.log(helperFindSource.findSource(Game.creeps["Harvester1"]));
}
module.exports.loop = function () {
for(var name in Memory.creeps) {
if(!Game.creeps[name]) {
delete Memory.creeps[name];
console.log('Clearing non-existing creep memory:', name);
}
}
var harvesters = _.filter(Game.creeps, (creep) => creep.memory.role == 'harvester');
var upgraders = _.filter(Game.creeps, (creep) => creep.memory.role == 'upgrader');
var builders = _.filter(Game.creeps, (creep) => creep.memory.role == 'builder');
for (var name in counts) {
var creeps = _.filter(Game.creeps, (creep) => creep.memory.role == name);
if (creeps.length >= counts[name]) {
continue;
}
var newName = Game.spawns.Spawn1.createCreep([WORK,CARRY,MOVE], undefined, {role: name});
console.log('Spawning new ' + name + ': ' + newName);
}
var tower = Game.getObjectById('TOWER_ID');
if(tower) {
var closestDamagedStructure = tower.pos.findClosestByRange(FIND_STRUCTURES, {
filter: (structure) => structure.hits < structure.hitsMax
});
if(closestDamagedStructure) {
tower.repair(closestDamagedStructure);
}
var closestHostile = tower.pos.findClosestByRange(FIND_HOSTILE_CREEPS);
if(closestHostile) {
tower.attack(closestHostile);
}
}
for(var name in Game.creeps) {
var creep = Game.creeps[name];
if(creep.memory.role == 'harvester') {
roleHarvester.run(creep);
}
if(creep.memory.role == 'upgrader') {
roleUpgrader.run(creep);
}
if(creep.memory.role == 'builder') {
roleBuilder.run(creep);
}
}
}
run: function(creep) {
// if creep is trying to repair something but has no energy left
if (creep.memory.working == true && creep.carry.energy == 0) {
// switch state
creep.memory.working = false;
}
// if creep is harvesting energy but is full
else if (creep.memory.working == false && creep.carry.energy == creep.carryCapacity) {
// switch state
creep.memory.working = true;
}
// if creep is supposed to repair something
if (creep.memory.working == true) {
// find closest structure with less than max hits
// Exclude walls because they have way too many max hits and would keep
// our repairers busy forever. We have to find a solution for that later.
var structure = creep.pos.findClosestByPath(FIND_STRUCTURES, {
// the second argument for findClosestByPath is an object which takes
// a property called filter which can be a function
// we use the arrow operator to define it
filter: (s) => s.hits < s.hitsMax && s.structureType != STRUCTURE_WALL
});
// if we find one
if (structure != undefined) {
// try to repair it, if it is out of range
if (creep.repair(structure) == ERR_NOT_IN_RANGE) {
// move towards it
creep.moveTo(structure);
}
}
// if we can't fine one
else {
// look for construction sites
roleBuilder.run(creep);
}
}
// if creep is supposed to harvest energy from source
else {
// find closest source
var source = creep.pos.findClosestByPath(FIND_SOURCES_ACTIVE);
// try to harvest energy, if the source is not in range
if (creep.harvest(source) == ERR_NOT_IN_RANGE) {
// move towards the source
creep.moveTo(source);
}
}
}
module.exports.loop = function () {
/**
* logic for creeps goes here
*/
for (let name in Game.creeps) {
var creep = Game.creeps[name];
switch (creep.memory.role) {
case 'harvester':
roleHarvester.run(creep);
break;
case 'upgrader':
roleUpgrader.run(creep);
break;
case 'builder':
roleBuilder.run(creep);
break;
case 'repairer':
roleRepairer.run(creep);
break;
case 'defender':
roleDefender.run(creep);
}
}
/**
* logic for spawning goes here
*/
if (Game.time % 5 == 0) {
for(var i in Memory.creeps) {
if(!Game.creeps[i]) {
delete Memory.creeps[i];
}
}
spawn();
}
/**
* logic for defending goes her
*/
defend();
}
module.exports.loop = function() {
for (var name in Game.rooms) {
console.log('Room "' + name + '" has ' + Game.rooms[name].energyAvailable + ' energy');
}
for (var name in Game.creeps) {
var creep = Game.creeps[name];
if (creep.memory.role == 'harvester') {
roleHarvester.run(creep);
}
if (creep.memory.role == 'builder') {
roleBuilder.run(creep);
}
}
}
_doWork: function() {
for(var name in Game.creeps) {
var creep = Game.creeps[name];
switch(creep.memory.role) {
case 'builder':
roleBuilder.determineTasks(creep);
break;
case 'upgrader':
roleUpgrader.determineTasks(creep);
break;
default:
roleHarvester.determineTasks(creep);
}
}
},
run: function(creep) {
//
// If we're out of energy, go get some
//
if (creep.carry.energy < creep.carryCapacity) {
utils.harvest(creep);
return;
}
//
// Find the closest damaged structure (if any)
//
var closestDamagedStructure = creep.pos.findClosestByRange(FIND_STRUCTURES, {
filter: (structure) => structure.hits < structure.hitsMax
});
//
// If we found one, repair it
//
if (closestDamagedStructure) {
// console.log('Repairer ' + creep.name + ' moving to ' + closestDamagedStructure.id + ' (' + closestDamagedStructure.structureType + ')');
//
// Attempt repair
//
if (creep.repair(closestDamagedStructure) == ERR_NOT_IN_RANGE) {
//
// Too far away, move to it
//
creep.moveTo(closestDamagedStructure);
}
}
//
// If there's nothing to repair, build
//
else {
roleBuilder.run(creep);
}
}
runCreeps: function() {
for(var name in Game.creeps) {
var creep = Game.creeps[name];
if(creep.memory.role == 'harvester') {
roleHarvester.run(creep);
}
if(creep.memory.role == 'upgrader') {
roleUpgrader.run(creep);
}
if(creep.memory.role == 'builder') {
roleBuilder.run(creep);
}
if(creep.memory.role == 'supplier') {
roleSupplier.run(creep);
}
}
},
module.exports.loop = function () {
var builders = _.filter(Game.creeps, (creep) => creep.memory.role == 'builder');
console.log('builders: ' + builders.length);
if(builders.length < 1) {
var newName = Game.spawns.Spawn1.createCreep([WORK,CARRY,MOVE], undefined, {role: 'builder'});
console.log('Spawning new builder: ' + newName);
for(var name in Game.creeps) {
var creep = Game.creeps[name];
if(creep.memory.role == 'builder') {
roleBuilder.run(creep);
}
}
}
}
module.exports.loop = function () {
spawner.run(HARVESTER_MAX, BUILDER_MAX, UPGRADER_MAX);
for(var name in Game.creeps) {
var creep = Game.creeps[name];
if(creep.memory.role === 'harvester') {
var birth = roleHarvester.run(creep);
}
if (creep.memory.role === 'builder') {
roleBuilder.run(creep);
}
if (creep.memory.role === 'upgrader') {
roleUpgrader.run(creep);
}
}
}
module.exports.loop = function () {
//moneytouse = Game.rooms.filter;
for(var name in Game.rooms){
moneyCapa = Game.rooms[name].energyCapacityAvailable;
moneyAvai = Game.rooms[name].energyAvailable;
}
console.log('----------------------------------');
console.log('Energie: ' + moneyAvai);
console.log('Energie zu gebrauchen: ' + moneyCapa*0.75);
console.log('----------------------------------');
/* Löscht die Memory der Creeps*/
for(var name in Memory.creeps) {
if(!Game.creeps[name]) {
delete Memory.creeps[name];
}
}
/*AutoSpwan*/
spawner.run(moneyCapa);
spawnerbuilding.run();
/*Tasks*/
for(var name in Game.creeps){
//Game.spawns.Spawn1.room.createConstructionSite(Game.creeps[name].pos.x,Game.creeps[name].pos.y,STRUCTURE_ROAD);
var target = Game.creeps[name];
if(target.memory.role == "harvester"){
roleHarvester.run(target);
}else
if(target.memory.role == "upgrader"){
roleUpgrader.run(target,moneyCapa,moneyAvai);
}else
if(target.memory.role == "builder"){
roleBuilder.run(target,moneyCapa,moneyAvai);
}else
if(target.memory.role == "repairer"){
roleRepairer.run(target);
}
}
}