douwe/screeps
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

old source files of 2018-2020.

Browse Source
This commit is contained in:
Douwe Ravers
2022-04-15 14:29:07 +02:00
parent 0985358150
commit 85215ebd97
20 changed files with 676 additions and 795 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
GLOBAL_VARIABLES.js Normal file
View File

@@ -0,0 +1,15 @@
module.exports = {
// JOBS
JOB_HARVESTER: 0,
JOB_MINER: 1,
JOB_SUPPLIER: 2,
JOB_BUILDER:3,
JOB_UPGRADER: 4,
JOB_DEFENDER: 5,
JOB_RESERVER: 6,
JOB_RESERVED_HARVESTER: 7
// OTHER
};

58
ai_main.js
View File

@@ -3,57 +3,63 @@
# Cross room managment AI #
########################### */
var roles = require("roles");
var GLOBAL = require("GLOBAL_VARIABLES");
module.exports = {
run: function () {
if (Memory.AImain == null) Memory.AImain = {};
if (Memory.AImain.MainHub == null) Memory.AImain.MainHub = "insert name"
for (var n_flag in Game.flags) {
run_front: function()
{
if(Memory.AImain == null) Memory.AImain = {};
if(Memory.AImain.MainHub == null) Memory.AImain.MainHub = "insert name"
for(var n_flag in Game.flags){
var flag = Game.flags[n_flag];
if (flag.color == COLOR_YELLOW) {
if (flag.room != undefined && flag.room.find(FIND_MY_CREEPS).length != flag.room.find(FIND_CREEPS).length) {
Game.spawns[Memory.AImain.MainHub].spawnCreep([TOUGH, TOUGH, TOUGH, TOUGH, TOUGH, TOUGH, TOUGH, ATTACK, ATTACK, ATTACK, MOVE],
"Defender", { memory: { role: roles.ROLE_DEFENDER, flag: flag.name } });
if(flag.color == COLOR_YELLOW){
if(flag.room != undefined && flag.room.find(FIND_MY_CREEPS).length != flag.room.find(FIND_CREEPS).length){
Game.spawns[Memory.AImain.MainHub].spawnCreep([TOUGH, TOUGH, TOUGH, TOUGH, TOUGH, TOUGH, TOUGH, ATTACK, ATTACK, ATTACK, MOVE],
"Defender", { memory: { role:GLOBAL.JOB_DEFENDER , flag: flag.name }});
break;
}
if (flag.room == undefined || (flag.room != undefined && (flag.room.controller.reservation == undefined || flag.room.controller.reservation.ticksToEnd < 4500))) {
if (Memory.AImain.MainHub != "insert name") Game.spawns[Memory.AImain.MainHub].spawnCreep([MOVE, CLAIM, CLAIM], "columbus: "+flag.name, { memory: { role: roles.ROLE_RESERVER, target: flag.name, home: Memory.AImain.MainHub } });
if(flag.room == undefined || flag.room.controller.reservation == undefined || (
flag.room.controller.reservation.username == "DouweRavers" && flag.room.controller.reservation.ticksToEnd < 3500))
{
if(Memory.AImain.MainHub != "insert name") Game.spawns[Memory.AImain.MainHub].spawnCreep([MOVE, CLAIM, CLAIM], "columbus", { memory: { role:GLOBAL.JOB_RESERVER, target: flag.name, home: Memory.AImain.MainHub}});
}
if (flag.room != undefined && flag.room.controller.reservation != undefined) {
var containers = flag.room.find(FIND_STRUCTURES, { filter: (s) => (s.structureType == STRUCTURE_CONTAINER) });
if (containers.length > 0) {
if(flag.room != undefined && flag.room.controller.reservation != undefined && flag.room.controller.reservation.username == "DouweRavers")
{
var containers = flag.room.find(FIND_STRUCTURES, { filter:(s) => ( s.structureType == STRUCTURE_CONTAINER )});
if(containers.length > 0){
var has_miner = false;
console.log("test");
var creeps = flag.room.find(FIND_CREEPS);
for (var cp in creeps) {
for(var cp in creeps){
console.log(creeps[cp]);
var creep = creeps[cp];
if (creep.memory.role == roles.ROLE_MINER) {
if(creep.memory.role == GLOBAL.JOB_MINER){
has_miner = true;
}
}
if (!has_miner) {
Game.spawns[Memory.AImain.MainHub].spawnCreep([WORK, WORK, WORK, WORK, WORK, MOVE], "ForeignMiner", { memory: { role: roles.ROLE_MINER, container_id: containers[0].id } });
if(!has_miner) {
console.log("needs new miner")
Game.spawns[Memory.AImain.MainHub].spawnCreep([ WORK, WORK, WORK, WORK, WORK, MOVE ], "ForeignMiner", { memory: { role:GLOBAL.JOB_MINER, container_id: containers[0].id}});
}
}
var harvs = flag.room.find(FIND_MY_CREEPS).length;
var source_id = flag.room.find(FIND_SOURCES)[0].id;
if (harvs < 4) {
if(harvs < 4){
var spawn = Game.spawns[Memory.AImain.MainHub];
var body = [];
for (let i = 0; i < Math.floor(spawn.room.energyAvailable / 200); i++) {
for(let i=0;i<Math.floor(spawn.room.energyAvailable/200);i++){
body.push(WORK);
body.push(CARRY);
body.push(MOVE);
}
var name = "ForeignHarvy" + spawn.memory.creep_iterate;
spawn.spawnCreep(body, name, {
memory:
{ role: roles.ROLE_RESERVED_HARVESTER, source_id: source_id }
});
var name = "ForeignHarvy"+spawn.memory.creep_iterate;
spawn.spawnCreep( body, name, { memory:
{role: GLOBAL.JOB_RESERVED_HARVESTER, source_id: source_id}});
}
}
}
}
}
},
run_back: function(){}
};

33
commands.js
View File

@@ -1,33 +0,0 @@
module.exports = {
configure: function () {
// Room management
global.RoomInfo = function () { RoomInfo(); };
global.RoomAdd = function (name, colonize) { RoomAdd(name, colonize) };
global.RoomRemove = function (name) { RoomRemove(name) };
}
}
//#region Room management
function RoomInfo() {
var message = "";
Memory.system.rooms.forEach(room => {
message += room.name + ": ";
message += room.colonize ? "colonize: " : "control: ";
var roomObject = Game.rooms[room.name];
if (roomObject.controller != undefined) {
message += roomObject.controller.my ? "done" : "in progress";
}
message += "\n";
});
console.log(message);
}
function RoomAdd(name, colonize) {
Memory.system.rooms.push({ name: name, colonize: colonize });
}
function RoomRemove(name) {
Memory.system.rooms = Memory.system.rooms.filter((x) => { return x.name != name; })
}
//#endregion

41
controller_creeps.js Normal file
View File

@@ -0,0 +1,41 @@
/* #######################################
# Controls the jobs of all the creeps #
#######################################*/
var GLOBAL = require("GLOBAL_VARIABLES");
var job_harvester = require("job_harvester");
var job_miner = require("job_miner");
var job_supplier = require("job_supplier");
var job_builder = require("job_builder");
var job_upgrader = require("job_upgrader");
var job_defender = require("job_defender");
var job_reserver = require("job_reserver");
var job_reserved_harvester = require("job_reserved_harvester");
module.exports = {
run: function(){
for(var cr in Game.creeps){
cr = Game.creeps[cr];
switch(cr.memory.role){
case GLOBAL.JOB_HARVESTER: job_harvester.do(cr);
break;
case GLOBAL.JOB_MINER: job_miner.do(cr);
break;
case GLOBAL.JOB_SUPPLIER: job_supplier.do(cr);
break;
case GLOBAL.JOB_BUILDER: job_builder.do(cr);
break;
case GLOBAL.JOB_UPGRADER: job_upgrader.do(cr);
break;
case GLOBAL.JOB_DEFENDER: job_defender.do(cr);
break;
case GLOBAL.JOB_RESERVER: job_reserver.do(cr);
break;
case GLOBAL.JOB_RESERVED_HARVESTER: job_reserved_harvester.do(cr);
break;
}
}
}
};

171
controller_spawns.js Normal file
View File

@@ -0,0 +1,171 @@
/* #####################################
# Controls the way creeps are spawn #
#####################################*/
var GLOBAL = require("GLOBAL_VARIABLES");
module.exports = {
run: function(){
for(var sp in Game.spawns){
sp = Game.spawns[sp]
// values
var creep_count = 0
for(var cr in Game.creeps){
if(Game.creeps[cr].room.name == sp.room.name) creep_count += 1;
}
var source_count = 0;
if(sp.memory.sources_ids != undefined) source_count = sp.memory.sources_ids.length;
// Memory setup
if(sp.memory.creep_iterate == undefined) sp.memory.creep_iterate = 0;
if(sp.memory.sources_ids == undefined){
sp.memory.sources_ids = [];
var sources = sp.room.find(FIND_SOURCES);
for(var source in sources){
source = sources[source];
sp.memory.sources_ids.push(source.id);
}
source_count = sp.memory.sources_ids.length;
}
if(sp.memory.containers_ids == undefined || sp.memory.containers_ids.length != source_count){
sp.memory.containers_ids = [];
var containers = sp.room.find(FIND_STRUCTURES, { filter:{ structureType: STRUCTURE_CONTAINER }});
if(containers.length > 0){
for(let i=0;i<containers.length;i+=1){
sp.memory.containers_ids.push(containers[i].id);
}
}
}
// Different spawning configurations
// Add improved versions at top of if-else statement
if(sp.memory.containers_ids.length >= source_count && sp.room.energyCapacityAvailable >= 550 && creep_count > source_count ){ // Miner method: Miners fille containers rest picks up from them
// Check current creep_jobs
var jobs = { miner: 0, supplier: 0, builder: 0, upgrader: 0, defender: 0};
var container_id = sp.memory.containers_ids[0];
for(var creep in Game.creeps){
var creep = Game.creeps[creep];
if(creep.room.name != sp.room.name) continue;
switch (creep.memory.role) {
case GLOBAL.JOB_MINER:
jobs.miner += 1;
for(let i=0;i<sp.memory.containers_ids.length;i++){
if(creep.memory.container_id != sp.memory.containers_ids[i]) container_id = sp.memory.containers_ids[i];
}
break;
case GLOBAL.JOB_SUPPLIER:
jobs.supplier += creep.body.length;
break;
case GLOBAL.JOB_BUILDER:
jobs.builder += creep.body.length;
break;
case GLOBAL.JOB_UPGRADER:
jobs.upgrader += creep.body.length;
break;
case GLOBAL.JOB_DEFENDER:
jobs.defender += 1;
break;
default:
break;
}
}
if(jobs.miner < source_count){
if(sp.room.energyAvailable >= 550) create_miner(sp, container_id);
}
else if(jobs.supplier < source_count * 15 && sp.room.energyAvailable >= 300 && jobs.miner > 0) create_supplier(sp);
else if(jobs.builder < source_count * 5 && sp.room.energyAvailable >= 300 && jobs.miner > 0) create_builder(sp);
else if(jobs.upgrader < source_count * 5 && sp.room.energyAvailable >= 300 && jobs.miner > 0) create_upgrader(sp);
else if(jobs.defender < 0 && sp.room.energyAvailable >= sp.room.energyCapacityAvailable*0.8 && jobs.miner > 0) create_defender(sp);
} else { // Harvesting method: everybody mines own sources
if (sp.room.find(FIND_MY_CREEPS).length < source_count * 5 && sp.room.energyAvailable >= 300){
var source_id = sp.memory.sources_ids[sp.memory.creep_iterate % source_count];
create_harvester(sp, source_id);
}
}
}
}
};
function create_harvester(sp, source_id){
var body = [];
for(let i=0;i<Math.floor(sp.room.energyAvailable/200);i++){
body.push(WORK);
body.push(CARRY);
body.push(MOVE);
}
var name = "Harvy"+sp.memory.creep_iterate;
sp.spawnCreep( body, name, { memory:
{role: GLOBAL.JOB_HARVESTER, source_id: source_id}});
sp.memory.creep_iterate += 1;
}
function create_miner(sp, container_id){
var body = [ WORK, WORK, WORK, WORK, WORK, MOVE ]; // (creep)5*work(2energy/tick)=10energy/tick -> (source)3000energy/300tick=10energy/tick
var name = "Mindy"+sp.memory.creep_iterate;
sp.spawnCreep( body, name, { memory:
{role: GLOBAL.JOB_MINER, container_id: container_id}});
sp.memory.creep_iterate += 1;
}
function create_supplier(sp){
var body = [WORK];
for(let i=0;i<Math.floor(sp.room.energyAvailable/100)-1 && i < 8;i++){ // as big as possible
body.push(CARRY);
body.push(MOVE);
}
var name = "Suppry"+sp.memory.creep_iterate;
sp.spawnCreep( body, name, { memory:
{role: GLOBAL.JOB_SUPPLIER}});
sp.memory.creep_iterate += 1;
}
function create_builder(sp){
var body = [];
for(let i=0;i<Math.floor(sp.room.energyAvailable/200);i++){ // as big as possible
body.push(CARRY);
body.push(MOVE);
body.push(WORK);
}
var name = "Bobby"+sp.memory.creep_iterate;
sp.spawnCreep( body, name, { memory:
{role: GLOBAL.JOB_BUILDER}});
sp.memory.creep_iterate += 1;
}
function create_upgrader(sp){
var body = [];
for(let i=0;i<Math.floor(sp.room.energyAvailable/300);i++){ // as big as possible
body.push(CARRY);
body.push(MOVE);
body.push(WORK);
body.push(WORK);
}
var name = "Undy"+sp.memory.creep_iterate;
sp.spawnCreep( body, name, { memory:
{role: GLOBAL.JOB_UPGRADER}});
sp.memory.creep_iterate += 1;
}
function create_defender(sp){
var body = [];
for(let i=0;i<Math.floor(sp.room.energyAvailable/150);i++){ // as big as possible
body.push(TOUGH);
body.push(TOUGH);
body.push(ATTACK);
body.push(MOVE);
}
var name = "Destroyer CODE"+sp.memory.creep_iterate;
sp.spawnCreep( body, name, { memory:
{role: GLOBAL.JOB_DEFENDER}});
sp.memory.creep_iterate += 1;
}

19
towers.js → controller_towers.js
View File

@@ -4,8 +4,7 @@ module.exports = {
for(var spawn in Game.spawns){
var room = Game.spawns[spawn].room;
var towers = room.find(FIND_MY_STRUCTURES,
{filter: {structureType: STRUCTURE_TOWER}});
{filter: (s)=>(s.structureType == STRUCTURE_TOWER)});
for(var tower in towers){
tower = towers[tower];
var enemy = tower.pos.findClosestByRange(FIND_HOSTILE_CREEPS);
@@ -20,17 +19,19 @@ module.exports = {
}
}
if(!healt_creep && 500 < tower.energy){
var structure = tower.pos.findClosestByPath(FIND_STRUCTURES,
{filter: (s)=>(s.structureType != STRUCTURE_RAMPART && s.structureType != STRUCTURE_WALL && s.hits < s.hitsMax)});
if(750 < tower.energy && structure == null) {
var structures = tower.room.find(FIND_STRUCTURES, {filter: { structureType: STRUCTURE_RAMPART, structureType: STRUCTURE_WALL }});
structures.sort(function(a,b){return a.hits - b.hits});
structure = structures[0];
}
var structure = tower.pos.findClosestByPath(FIND_STRUCTURES,
{filter: (s)=>( (s.structureType != STRUCTURE_RAMPART && s.structureType != STRUCTURE_WALL && s.hits < s.hitsMax )
|| ( s.structureType == STRUCTURE_RAMPART && s.hits < 10000 ))});
if(structure == null) structure = tower.pos.findClosestByRange(FIND_STRUCTURES,
{filter: (s)=>((s.structureType == STRUCTURE_RAMPART) && s.hits < 1000)});
if(structure == null) structure = tower.pos.findClosestByRange(FIND_STRUCTURES,
{filter: (s)=>((s.structureType == STRUCTURE_WALL) && s.hits < 1000)});
tower.repair(structure);
}
}
}
}
}
};

92
creeps.js
View File

@@ -1,92 +0,0 @@
/* ###################################################################
# An inherited creep class and a module to expose it to the loop. #
###################################################################*/
const roles = require("roles");
module.exports = {
configure: function () {
// Replaces the creep class by the MyCreep class which changes the type of all Creep objects as well.
Creep.prototype = MyCreep.prototype;
setConstants();
// configure all creeps (in case new memory requirements).
for (const name in Game.creeps) {
Game.creeps[name].configure();
}
},
// All creeps execute their roles every tick.
execute: function () {
for (const name in Game.creeps) {
Game.creeps[name].execute();
}
}
};
class MyCreep extends Creep {
configure() {
}
execute() {
switch (this.memory.role) {
case roles.ROLE_HARVESTER: roles.harvest(this);
break;
case roles.ROLE_MINER:
if (this.goTo(this.memory.container_id)) {
this.harvestSource();
}
break;
case roles.ROLE_SUPPLIER: roles.supply(this);
break;
case roles.ROLE_BUILDER: roles.build(this);
break;
case roles.ROLE_UPGRADER: roles.upgrade(this);
break;
case roles.ROLE_DEFENDER: roles.defend(this);
break;
case roles.ROLE_RESERVER: roles.reserve(this);
break;
case roles.ROLE_RESERVED_HARVESTER: roles.harvest_reserved(this);
break;
}
}
// Moves to the object with given id. Returns true if arrived.
goTo(id) {
const target = Game.getObjectById(id)
if (target != null) {
if (this.pos.isEqualTo(target.pos)) return true;
this.moveTo(target);
} else {
console.log(this.name + " can't find object with id: " + id);
}
return false;
}
// harvests set or closest source, moves to it if to far and return true if fully loaded.
harvestSource() {
if (this.memory.source_id == undefined) {
this.memory.source_id = this.pos.findClosestByPath(FIND_SOURCES).id;
}
const result = this.harvest(Game.getObjectById(this.memory.source_id));
if (result == ERR_NOT_IN_RANGE) this.goTo(this.memory.source_id);
return this.store.getFreeCapacity(RESOURCE_ENERGY) == 0;
}
}
function setConstants() {
global.HARVESTER = 0;
global.MINER = 1;
global.SUPPLIER = 2;
global.BUILDER = 3;
global.UPGRADER = 4;
global.DEFENDER = 5;
global.RESERVER = 6;
global.RESERVED_HARVESTER = 7;
}

57
job_builder.js Normal file
View File

@@ -0,0 +1,57 @@
/* #######################################################
# Deliver energy to spawns, controller and extencions #
####################################################### */
module.exports = {
do: function(creep){
//creep.memory.target = null;
// Memory creation
if(creep.memory.restock == undefined) creep.memory.restock = true;
if(creep.memory.target == undefined) creep.memory.target = null;
// Job implementation
if(creep.memory.restock){
if(creep.memory.target == null){
if(creep.room.storage != null && 1000 < creep.room.storage.store.getUsedCapacity(RESOURCE_ENERGY)) creep.memory.target = creep.room.storage.id;
else {
var container = creep.pos.findClosestByPath(FIND_STRUCTURES,
{filter: (s)=>(s.structureType == STRUCTURE_CONTAINER
&& 0 < s.store.getUsedCapacity(RESOURCE_ENERGY))});
if(container != null) creep.memory.target = container.id;
}
}
var target = Game.getObjectById(creep.memory.target);
if(creep.withdraw(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
if(target != null && target.store.getUsedCapacity(RESOURCE_ENERGY) < creep.store.getFreeCapacity(RESOURCE_ENERGY)*0.4) creep.memory.target = null;
if(creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0){
creep.memory.restock = false;
creep.memory.target = null;
}
} else {
if(creep.memory.target == null){ // aquire target
// constuction
var structure = creep.pos.findClosestByRange(FIND_MY_CONSTRUCTION_SITES);
// ramparts
if(structure == null){
var ramparts = creep.room.find(FIND_STRUCTURES,
{filter: (s)=>((s.structureType == STRUCTURE_RAMPART || s.structureType == STRUCTURE_WALL) && s.hits < s.hitsMax)});
for(var ramp in ramparts){
ramp = ramparts[ramp];
if(structure == null || structure.hits > ramp.hits) structure = ramp;
}
}
creep.memory.target = structure.id;
}
var target = Game.getObjectById(creep.memory.target);
if(target == null || target.hits == target.hitsMax) creep.memory.target = null;
if(creep.build(target) == ERR_NOT_IN_RANGE || creep.repair(target) == ERR_NOT_IN_RANGE) creep.moveTo(target);
if(creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0){
creep.memory.restock = true;
creep.memory.target = null;
}
}
}
};

22
job_defender.js Normal file
View File

@@ -0,0 +1,22 @@
/* #######################################################
# Deliver energy to spawns, controller and extencions #
####################################################### */
module.exports = {
do: function(creep){
if(creep.memory.flag != undefined && Game.flags[creep.memory.flag].room.name != creep.room.name) creep.moveTo(Game.flags[creep.memory.flag]);
if(creep.memory.target == undefined) creep.memory.target = null;
if(creep.memory.target == null){
var enemy = creep.pos.findClosestByPath(FIND_HOSTILE_CREEPS);
if(enemy != null) creep.memory.target = enemy.id;
}
var enemy = Game.getObjectById(creep.memory.target);
if(enemy != null){
creep.say("ATTACK");
if(creep.attack(enemy) == ERR_NOT_IN_RANGE) creep.moveTo(enemy);
} else {
creep.memory.target = null;
}
}
};

92
job_harvester.js Normal file
View File

@@ -0,0 +1,92 @@
/* ###########################################
# Mine energy and do all fundamental jobs #
###########################################*/
module.exports = {
do: function(creep){
//memory setup
if(creep.memory.harvesting == undefined) creep.memory.harvesting = true;
if(creep.memory.counter == undefined) creep.memory.counter = 0;
if(creep.memory.target == undefined) creep.memory.target = null;
if (creep.memory.harvesting){
var source = Game.getObjectById(creep.memory.source_id);
var result = creep.harvest(source);
if (result == ERR_NOT_IN_RANGE){
creep.moveTo(source);
}
if (result == ERR_NOT_ENOUGH_RESOURCES || creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0){
creep.memory.harvesting = false;
creep.memory.target = null;
}
} else {
if(creep.memory.target == null){
switch(creep.memory.counter%10){
case 0: // upgrading
creep.memory.target = creep.room.controller.id;
break;
case 1: // suppling
case 2:
case 3:
case 4:
creep.memory.target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES,{
filter:(s) => ( s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_EXTENSION ) && s.store.getFreeCapacity(RESOURCE_ENERGY) > 0});
if(creep.memory.target != null) creep.memory.target = creep.memory.target.id;
else creep.memory.counter += 1;
break;
case 5:
case 6:
case 7:
case 8:
creep.memory.target = creep.pos.findClosestByRange(FIND_CONSTRUCTION_SITES);
if(creep.memory.target != null) creep.memory.target = creep.memory.target.id;
else creep.memory.counter += 1;
break;
case 9: // repairing (no walls or ramparts)
creep.memory.target = creep.pos.findClosestByRange(FIND_STRUCTURES,{
filter:(s) => ( s.structureType != STRUCTURE_WALL && s.structureType != STRUCTURE_RAMPART) && s.hits < s.hitsMax});
if(creep.memory.target != null) creep.memory.target = creep.memory.target.id;
else creep.memory.counter += 1;
break;
}
}
var target = Game.getObjectById(creep.memory.target);
var response = OK;
switch(creep.memory.counter%10){
case 0:
response = creep.transfer(target, RESOURCE_ENERGY);
break;
case 1:
case 2:
case 3:
case 4:
response = creep.transfer(target, RESOURCE_ENERGY);
if(target != null && target.store.getFreeCapacity(RESOURCE_ENERGY) == 0) creep.memory.target = null;
break;
case 5:
case 6:
case 7:
case 8:
response = creep.build(target);
if(target != null && target.progress == target.progressTotal) creep.memory.target = null;
break;
case 9:
response = creep.repair(target);
if(target != null && target.hits == target.hitsMax) creep.memory.target = null;
break;
}
if(response == ERR_NOT_IN_RANGE){
creep.moveTo(target);
} else if(response == ERR_FULL || response == ERR_INVALID_TARGET){
creep.memory.target = null;
}
if (creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0){
creep.memory.harvesting = true;
creep.memory.target = null;
creep.memory.counter += 1;
}
}
}
};

16
job_miner.js Normal file
View File

@@ -0,0 +1,16 @@
/* ########################################
# Mine energy and drop it in container #
########################################*/
module.exports = {
do: function(creep){
var container = Game.getObjectById(creep.memory.container_id);
if(container != null && creep.pos.isEqualTo(container.pos)){
if(creep.memory.source_id == undefined) creep.memory.source_id = creep.pos.findClosestByPath(FIND_SOURCES).id;
creep.harvest(Game.getObjectById(creep.memory.source_id));
} else {
creep.moveTo(Game.getObjectById(creep.memory.container_id));
}
}
};

93
job_reserved_harvester.js Normal file
View File

@@ -0,0 +1,93 @@
/* ###########################################
# Mine energy and do all fundamental jobs #
###########################################*/
module.exports = {
do: function(creep){
creep.memory.home = "Central"
//memory setup
if(creep.memory.harvesting == undefined) creep.memory.harvesting = true;
if(creep.memory.counter == undefined) creep.memory.counter = 0;
if(creep.memory.target == undefined) creep.memory.target = null;
if (creep.memory.harvesting){
var source = Game.getObjectById(creep.memory.source_id);
if(source != undefined && creep.room.name == source.room.name){
var container = creep.pos.findClosestByPath(FIND_STRUCTURES, { filter:(s) => ( s.structureType == STRUCTURE_CONTAINER && s.store.getUsedCapacity(RESOURCE_ENERGY) > creep.store.getFreeCapacity(RESOURCE_ENERGY))});
if(container == null) {
var source = Game.getObjectById(creep.memory.source_id);
result = creep.harvest(source);
if (result == ERR_NOT_IN_RANGE){
creep.moveTo(source);
}
} else {
var result = creep.withdraw(container, RESOURCE_ENERGY);
if (result == ERR_NOT_IN_RANGE){
creep.moveTo(container);
}
}
if (creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0){
creep.memory.harvesting = false;
creep.memory.target = null;
}
} else {
creep.moveTo(source);
}
} else {
if(creep.memory.target == null){
switch(creep.memory.counter%3){
case 0: // building
creep.memory.target = creep.pos.findClosestByRange(FIND_CONSTRUCTION_SITES);
if(creep.memory.target != null) creep.memory.target = creep.memory.target.id;
else creep.memory.counter += 1;
break;
case 1: // repairing (no walls or ramparts)
creep.memory.target = creep.pos.findClosestByRange(FIND_STRUCTURES,{
filter:(s) => ( s.structureType != STRUCTURE_WALL && s.structureType != STRUCTURE_RAMPART) && s.hits < s.hitsMax-creep.store.getUsedCapacity(RESOURCE_ENERGY)*3/4});
if(creep.memory.target != null) creep.memory.target = creep.memory.target.id;
else creep.memory.counter += 1;
break;
case 2:
var home = Game.spawns[creep.memory.home];
if(creep.room.name == home.room.name){
creep.memory.target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES,{
filter:(s) => ( s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_EXTENSION || s.structureType == STRUCTURE_STORAGE ) && s.store.getFreeCapacity(RESOURCE_ENERGY) > 0});
if(creep.memory.target != null) creep.memory.target = creep.memory.target.id;
else creep.memory.counter += 1;
} else {
creep.moveTo(home);
}
break;
}
}
var target = Game.getObjectById(creep.memory.target);
var response = OK;
switch(creep.memory.counter%3){
case 0: // building
response = creep.build(target);
if(target != null && target.progress == target.progressTotal) creep.memory.target = null;
break;
case 1:
response = creep.repair(target);
if(target != null && target.hits == target.hitsMax) creep.memory.target = null;
break;
case 2:
response = creep.transfer(target, RESOURCE_ENERGY);
if(target != null && target.store.getFreeCapacity(RESOURCE_ENERGY) == 0) creep.memory.target = null;
break;
}
if(response == ERR_NOT_IN_RANGE){
creep.moveTo(target);
} else if(response == ERR_FULL || response == ERR_INVALID_TARGET){
creep.memory.target = null;
}
if (creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0){
creep.memory.harvesting = true;
creep.memory.target = null;
creep.memory.counter += 1;
}
}
}
};

16
job_reserver.js Normal file
View File

@@ -0,0 +1,16 @@
/* ###########################################
# Go to a controller and reserve the room #
###########################################*/
module.exports = {
do: function(creep){
if(Game.flags[creep.memory.target].room != undefined && Game.flags[creep.memory.target].room == creep.room){
if(creep.reserveController(creep.room.controller) == ERR_NOT_IN_RANGE){
creep.moveTo(creep.room.controller);
}
} else {
creep.moveTo(Game.flags[creep.memory.target]);
}
}
};

54
job_supplier.js Normal file
View File

@@ -0,0 +1,54 @@
/* #######################################################
# Deliver energy to spawns, controller and extencions #
####################################################### */
module.exports = {
do: function(creep){
// Memory creation
if(creep.memory.restock == undefined) creep.memory.restock = true;
if(creep.memory.target == undefined) creep.memory.target = null;
// Job implementation
if(creep.memory.restock){
if(creep.memory.target == null){ // aquire target
var containers = creep.room.find(FIND_STRUCTURES,
{filter: (s)=>(s.structureType == STRUCTURE_CONTAINER
&& s.store.getUsedCapacity(RESOURCE_ENERGY) >= creep.store.getFreeCapacity(RESOURCE_ENERGY)/2)});
var container = containers[0];
for(var c in containers){
c = containers[c];
if(c.store.getUsedCapacity(RESOURCE_ENERGY) > container.store.getUsedCapacity(RESOURCE_ENERGY)) container = c;
}
if(container != null) creep.memory.target = container.id;
else creep.memory.target = creep.room.storage.id;
}
var target = Game.getObjectById(creep.memory.target);
if(creep.withdraw(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
if(target != null && target.store.getUsedCapacity(RESOURCE_ENERGY) < creep.store.getFreeCapacity(RESOURCE_ENERGY)*0.4) creep.memory.target = null;
if(creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0){
creep.memory.restock = false;
creep.memory.target = null;
}
} else {
if(creep.memory.target == null){ // aquire target
var structure = creep.pos.findClosestByPath(FIND_MY_STRUCTURES,
{filter: (s)=>(s.structureType == STRUCTURE_TOWER && s.store.getUsedCapacity(RESOURCE_ENERGY) < 900)});
if(structure == null) structure = creep.pos.findClosestByPath(FIND_MY_STRUCTURES,
{filter: (s)=>(( s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_EXTENSION)
&& s.store.getFreeCapacity(RESOURCE_ENERGY) > s.store.getCapacity(RESOURCE_ENERGY)*0.1)});
if(structure == null) structure = creep.pos.findClosestByPath(FIND_MY_STRUCTURES,
{filter: (s)=>(( s.id == "5f3e44e1014017c66fc5df10") && s.store.getFreeCapacity() > 100)});
if(structure == null) structure = creep.room.storage;
if(structure == null) return;
creep.memory.target = structure.id;
}
var target = Game.getObjectById(creep.memory.target);
if(creep.transfer(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
if(target != null && target.store.getFreeCapacity(RESOURCE_ENERGY) == 0) creep.memory.target = null;
if(creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0){
creep.memory.restock = true;
creep.memory.target = null;
}
}
}
};

43
job_upgrader.js Normal file
View File

@@ -0,0 +1,43 @@
/* #######################################################
# Deliver energy to spawns, controller and extencions #
####################################################### */
module.exports = {
do: function(creep){
// Memory creation
if(creep.memory.restock == undefined) creep.memory.restock = true;
if(creep.memory.target == undefined) creep.memory.target = null;
// Job implementation
if(creep.memory.restock){
if(creep.memory.target == null){
if(creep.room.storage != null && 1000 < creep.room.storage.store.getUsedCapacity(RESOURCE_ENERGY)) creep.memory.target = creep.room.storage.id;
else {
var container = creep.pos.findClosestByPath(FIND_STRUCTURES,
{filter: (s)=>(s.structureType == STRUCTURE_CONTAINER
&& 0 < s.store.getUsedCapacity(RESOURCE_ENERGY))});
if(container != null) creep.memory.target = container.id;
}
}
var target = Game.getObjectById(creep.memory.target);
if(creep.withdraw(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
if(target != null && target.store.getUsedCapacity(RESOURCE_ENERGY) < creep.store.getFreeCapacity(RESOURCE_ENERGY)*0.4) creep.memory.target = null;
if(creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0){
creep.memory.restock = false;
creep.memory.target = null;
}
} else {
if(creep.memory.target == null){ // aquire target
var structure = structure = creep.room.controller;
creep.memory.target = structure.id;
}
var target = Game.getObjectById(creep.memory.target);
if(creep.transfer(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
if(creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0){
creep.memory.restock = true;
creep.memory.target = null;
}
}
}
};

42
main.js
View File

@@ -1,35 +1,21 @@
/* ######################
# Screeps 2022 #
######################*/
const spawns = require("spawns");
const creeps = require("creeps");
const towers = require("towers");
const ai_main = require("ai_main");
const system = require("system");
var controller_spawns = require("controller_spawns");
var controller_creeps = require("controller_creeps");
var controller_towers = require("controller_towers");
var ai_main = require("ai_main");
module.exports.loop = function () {
// New system
if (global.started == undefined) {
console.log("Recompiled...");
global.started = true;
system.start();
}
system.update();
// Old system
ai_main.run();
towers.run();
spawns.run();
if (Game.time % 60 == 0) {
clear_dead_creeps_from_memory();
}
ai_main.run_front();
controller_creeps.run();
controller_towers.run();
controller_spawns.run();
if (Game.time % 60 == 30) clear_dead_creeps_from_memory();
ai_main.run_back();
}
/*
GLOBAL FUNCTIONS
*/
function clear_dead_creeps_from_memory() {
for (var cr in Memory.creeps) {
@@ -37,4 +23,4 @@ function clear_dead_creeps_from_memory() {
delete (Memory.creeps[cr]);
}
}
}
}

398
roles.js
View File

@@ -1,398 +0,0 @@
/* ##############################
# Roles: Creep functionality #
############################## */
module.exports = {
ROLE_HARVESTER: 0,
ROLE_MINER: 1,
ROLE_SUPPLIER: 2,
ROLE_BUILDER: 3,
ROLE_UPGRADER: 4,
ROLE_DEFENDER: 5,
ROLE_RESERVER: 6,
ROLE_RESERVED_HARVESTER: 7,
harvest: function (creep) {
setupMemory();
if (creep.memory.harvesting) {
extractEnergySource();
}
else {
searchTarget();
var response = performJob();
handleResponse(response);
}
function setupMemory() {
if (creep.memory.harvesting == undefined) creep.memory.harvesting = true;
if (creep.memory.counter == undefined) creep.memory.counter = 0;
if (creep.memory.target == undefined) creep.memory.target = null;
}
function extractEnergySource() {
var result = OK;
var target = creep.pos.findClosestByPath(FIND_STRUCTURES, { filter: (s) => (s.structureType == STRUCTURE_CONTAINER && s.store.getUsedCapacity(RESOURCE_ENERGY) > creep.store.getFreeCapacity(RESOURCE_ENERGY)) });
if (target == null) {
target = Game.getObjectById(creep.memory.source_id);
result = creep.harvest(target);
} else {
result = creep.withdraw(target, RESOURCE_ENERGY);
}
if (result == ERR_NOT_IN_RANGE) {
creep.moveTo(target);
}
if (result == ERR_NOT_ENOUGH_RESOURCES || creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0) {
creep.memory.harvesting = false;
creep.memory.target = null;
}
}
function searchTarget() {
if (creep.memory.target == null) {
var role_type = creep.memory.counter % 10;
if (role_type == 0) {
creep.memory.target = creep.room.controller.id;
}
else if (role_type < 5) {
var target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES, {
filter: (s) => (s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_EXTENSION) && s.store.getFreeCapacity(RESOURCE_ENERGY) > 0
});
if (target != null) creep.memory.target = target.id;
else creep.memory.counter += 1;
}
else if (role_type < 9) {
var target = creep.pos.findClosestByRange(FIND_CONSTRUCTION_SITES);
if (target != null) creep.memory.target = target.id;
else creep.memory.counter += 1;
} else {
var target = creep.pos.findClosestByRange(FIND_STRUCTURES, {
filter: (s) => (s.structureType != STRUCTURE_WALL && s.structureType != STRUCTURE_RAMPART) && s.hits < s.hitsMax
});
if (target != null) creep.memory.target = target.id;
else creep.memory.counter += 1;
}
}
}
function performJob() {
var target = Game.getObjectById(creep.memory.target);
var response = OK;
var role_type = creep.memory.counter % 10;
if (role_type == 0) {
response = creep.transfer(target, RESOURCE_ENERGY);
}
else if (role_type < 5) {
response = creep.transfer(target, RESOURCE_ENERGY);
if (target != null && target.store.getFreeCapacity(RESOURCE_ENERGY) == 0) creep.memory.target = null;
}
else if (role_type < 9) {
response = creep.build(target);
if (target != null && target.progress == target.progressTotal) creep.memory.target = null;
} else {
response = creep.repair(target);
if (target != null && target.hits == target.hitsMax) creep.memory.target = null;
}
return response;
}
function handleResponse(response) {
if (response == ERR_NOT_IN_RANGE) {
var target = Game.getObjectById(creep.memory.target);
creep.moveTo(target);
} else if (response == ERR_FULL || response == ERR_INVALID_TARGET) {
creep.memory.target = null;
}
if (creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0) {
creep.memory.harvesting = true;
creep.memory.target = null;
creep.memory.counter += 1;
}
}
},
mine: function (creep) {
var container = Game.getObjectById(creep.memory.container_id);
if (container != null && creep.pos.isEqualTo(container.pos)) {
if (creep.memory.source_id == undefined) creep.memory.source_id = creep.pos.findClosestByPath(FIND_SOURCES).id;
creep.harvest(Game.getObjectById(creep.memory.source_id));
} else {
creep.moveTo(Game.getObjectById(creep.memory.container_id));
}
},
supply: function (creep) {
// Memory creation
if (creep.memory.restock == undefined) creep.memory.restock = true;
if (creep.memory.target == undefined) creep.memory.target = null;
// Job implementation
if (creep.memory.restock) {
if (creep.memory.target == null) { // aquire target
var target = creep.pos.findClosestByPath(FIND_DROPPED_RESOURCES);
if (target == null) target = creep.pos.findClosestByPath(FIND_TOMBSTONES);
if (target == null) target = creep.pos.findClosestByPath(FIND_STRUCTURES,
{
filter: (s) => (s.structureType == STRUCTURE_CONTAINER
&& 0 < s.store.getUsedCapacity(RESOURCE_ENERGY))
});
if (target == null) target = creep.room.storage;
if (target != null) creep.memory.target = target.id;
}
var target = Game.getObjectById(creep.memory.target);
if (creep.withdraw(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE || creep.pickup(target) == ERR_NOT_IN_RANGE) creep.moveTo(target);
if (target != null && target.store != null && target.store.getUsedCapacity(RESOURCE_ENERGY) == 0) creep.memory.target = null;
if (creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0) {
creep.memory.restock = false;
creep.memory.target = null;
}
} else {
if (creep.memory.target == null) { // aquire target
var structure = creep.pos.findClosestByPath(FIND_MY_STRUCTURES,
{ filter: (s) => (s.structureType == STRUCTURE_TOWER && s.store.getUsedCapacity(RESOURCE_ENERGY) < 900) });
if (structure == null) structure = creep.pos.findClosestByPath(FIND_MY_STRUCTURES,
{
filter: (s) => ((s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_EXTENSION)
&& s.store.getFreeCapacity(RESOURCE_ENERGY) > s.store.getCapacity(RESOURCE_ENERGY) * 0.1)
});
if (structure == null) structure = creep.pos.findClosestByPath(FIND_MY_STRUCTURES,
{ filter: (s) => ((s.id == "5f3e44e1014017c66fc5df10") && s.store.getFreeCapacity() > 100) });
if (structure == null) structure = creep.room.storage;
if (structure == null) return;
creep.memory.target = structure.id;
}
var target = Game.getObjectById(creep.memory.target);
if (creep.transfer(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
if (target != null && target.store.getFreeCapacity(RESOURCE_ENERGY) == 0) creep.memory.target = null;
if (creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0) {
creep.memory.restock = true;
creep.memory.target = null;
}
}
},
build: function (creep) {
//creep.memory.target = null;
// Memory creation
if (creep.memory.restock == undefined) creep.memory.restock = true;
if (creep.memory.target == undefined) creep.memory.target = null;
// Job implementation
if (creep.memory.restock) {
if (creep.memory.target == null) {
if (creep.room.storage != null && 1000 < creep.room.storage.store.getUsedCapacity(RESOURCE_ENERGY)) creep.memory.target = creep.room.storage.id;
else {
var container = creep.pos.findClosestByPath(FIND_STRUCTURES,
{
filter: (s) => (s.structureType == STRUCTURE_CONTAINER
&& 0 < s.store.getUsedCapacity(RESOURCE_ENERGY))
});
if (container != null) creep.memory.target = container.id;
}
}
var target = Game.getObjectById(creep.memory.target);
if (creep.withdraw(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
if (target != null && target.store.getUsedCapacity(RESOURCE_ENERGY) < creep.store.getFreeCapacity(RESOURCE_ENERGY) * 0.4) creep.memory.target = null;
if (creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0) {
creep.memory.restock = false;
creep.memory.target = null;
}
} else {
if (creep.memory.target == null) { // aquire target
// constuction
var structure = creep.pos.findClosestByRange(FIND_MY_CONSTRUCTION_SITES);
// buildings
if (structure == null) {
var buildings = creep.room.find(FIND_STRUCTURES,
{ filter: (s) => ((s.structureType != STRUCTURE_RAMPART || s.structureType != STRUCTURE_WALL) && s.hits < s.hitsMax) });
for (var building in buildings) {
building = buildings[building];
if (structure == null || structure.hits > building.hits) structure = building;
}
}
// ramparts and walls
if (structure == null) {
var ramparts = creep.room.find(FIND_STRUCTURES,
{ filter: (s) => ((s.structureType == STRUCTURE_RAMPART || s.structureType == STRUCTURE_WALL) && s.hits < s.hitsMax) });
for (var ramp in ramparts) {
ramp = ramparts[ramp];
if (structure == null || structure.hits > ramp.hits) structure = ramp;
}
}
creep.memory.target = structure.id;
}
var target = Game.getObjectById(creep.memory.target);
if (target == null || target.hits == target.hitsMax) creep.memory.target = null;
if (creep.build(target) == ERR_NOT_IN_RANGE || creep.repair(target) == ERR_NOT_IN_RANGE) creep.moveTo(target);
if (creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0) {
creep.memory.restock = true;
creep.memory.target = null;
}
}
},
upgrade: function (creep) {
// Memory creation
if (creep.memory.restock == undefined) creep.memory.restock = true;
if (creep.memory.target == undefined) creep.memory.target = null;
// Job implementation
if (creep.memory.restock) {
if (creep.memory.target == null) {
if (creep.room.storage != null && 1000 < creep.room.storage.store.getUsedCapacity(RESOURCE_ENERGY)) creep.memory.target = creep.room.storage.id;
else {
var container = creep.pos.findClosestByPath(FIND_STRUCTURES,
{
filter: (s) => (s.structureType == STRUCTURE_CONTAINER
&& 0 < s.store.getUsedCapacity(RESOURCE_ENERGY))
});
if (container != null) creep.memory.target = container.id;
}
}
var target = Game.getObjectById(creep.memory.target);
if (creep.withdraw(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
if (target != null && target.store.getUsedCapacity(RESOURCE_ENERGY) < creep.store.getFreeCapacity(RESOURCE_ENERGY) * 0.4) creep.memory.target = null;
if (creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0) {
creep.memory.restock = false;
creep.memory.target = null;
}
} else {
if (creep.memory.target == null) { // aquire target
var structure = structure = creep.room.controller;
creep.memory.target = structure.id;
}
var target = Game.getObjectById(creep.memory.target);
if (creep.transfer(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
if (creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0) {
creep.memory.restock = true;
creep.memory.target = null;
}
}
},
defend: function (creep) {
if (creep.memory.flag != undefined && Game.flags[creep.memory.flag].room.name != creep.room.name) creep.moveTo(Game.flags[creep.memory.flag]);
if (creep.memory.target == undefined) creep.memory.target = null;
if (creep.memory.target == null) {
var enemy = creep.pos.findClosestByPath(FIND_HOSTILE_CREEPS);
if (enemy != null) creep.memory.target = enemy.id;
}
var enemy = Game.getObjectById(creep.memory.target);
if (enemy != null) {
creep.say("ATTACK");
if (creep.attack(enemy) == ERR_NOT_IN_RANGE) creep.moveTo(enemy);
} else {
creep.memory.target = null;
}
},
reserve: function (creep) {
if (Game.flags[creep.memory.target].room != undefined && Game.flags[creep.memory.target].room == creep.room) {
if (creep.memory.target == "xxx") {
if (creep.claimController(creep.room.controller) == ERR_NOT_IN_RANGE) {
creep.moveTo(creep.room.controller);
}
} else {
if (creep.reserveController(creep.room.controller) == ERR_NOT_IN_RANGE) {
creep.moveTo(creep.room.controller);
}
}
} else {
creep.moveTo(Game.flags[creep.memory.target]);
}
},
harvest_reserved: function (creep) {
creep.memory.home = "SpawnAlpha"
//memory setup
if (creep.memory.harvesting == undefined) creep.memory.harvesting = true;
if (creep.memory.counter == undefined) creep.memory.counter = 0;
if (creep.memory.target == undefined) creep.memory.target = null;
if (creep.memory.harvesting) {
var source = Game.getObjectById(creep.memory.source_id);
if (source != undefined && creep.room.name == source.room.name) {
var container = creep.pos.findClosestByPath(FIND_STRUCTURES, { filter: (s) => (s.structureType == STRUCTURE_CONTAINER && s.store.getUsedCapacity(RESOURCE_ENERGY) > creep.store.getFreeCapacity(RESOURCE_ENERGY)) });
if (container == null) {
result = creep.harvest(source);
if (result == ERR_NOT_IN_RANGE) {
creep.moveTo(source);
}
} else {
var result = creep.withdraw(container, RESOURCE_ENERGY);
if (result == ERR_NOT_IN_RANGE) {
creep.moveTo(container);
}
}
if (creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0) {
creep.memory.harvesting = false;
creep.memory.target = null;
}
} else {
creep.moveTo(source);
}
} else {
if (creep.memory.target == null) {
switch (creep.memory.counter % 3) {
case 0: // building
creep.memory.target = creep.pos.findClosestByRange(FIND_CONSTRUCTION_SITES);
if (creep.memory.target != null) creep.memory.target = creep.memory.target.id;
else creep.memory.counter += 1;
break;
case 1: // repairing (no walls or ramparts)
creep.memory.target = creep.pos.findClosestByRange(FIND_STRUCTURES, {
filter: (s) => (s.structureType != STRUCTURE_WALL && s.structureType != STRUCTURE_RAMPART) && s.hits < s.hitsMax - creep.store.getUsedCapacity(RESOURCE_ENERGY) * 3 / 4
});
if (creep.memory.target != null) creep.memory.target = creep.memory.target.id;
else creep.memory.counter += 1;
break;
case 2: // suppling
var home = Game.spawns[creep.memory.home];
if (creep.room.name == home.room.name) {
creep.memory.target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES, {
filter: (s) => (s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_EXTENSION || s.structureType == STRUCTURE_STORAGE) && s.store.getFreeCapacity(RESOURCE_ENERGY) > 0
});
if (creep.memory.target != null) creep.memory.target = creep.memory.target.id;
else creep.memory.counter += 1;
} else {
creep.moveTo(home);
}
break;
}
}
var target = Game.getObjectById(creep.memory.target);
var response = OK;
switch (creep.memory.counter % 3) {
case 0: // building
response = creep.build(target);
if (target != null && target.progress == target.progressTotal) creep.memory.target = null;
break;
case 1: // repairing
response = creep.repair(target);
if (target != null && target.hits == target.hitsMax) creep.memory.target = null;
break;
case 2: // suppling
response = creep.transfer(target, RESOURCE_ENERGY);
if (target != null && target.store.getFreeCapacity(RESOURCE_ENERGY) == 0) creep.memory.target = null;
break;
}
if (response == ERR_NOT_IN_RANGE) {
creep.moveTo(target);
} else if (response == ERR_FULL || response == ERR_INVALID_TARGET) {
creep.memory.target = null;
}
if (creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0) {
creep.memory.harvesting = true;
creep.memory.target = null;
creep.memory.counter += 1;
}
}
}
};

7
rooms.js
View File

@@ -1,7 +0,0 @@
/**
* Managing the behavior of buildings and creeps is on a per room level.
*/
module.exports = {
}

183
spawns.js
View File

@@ -1,183 +0,0 @@
/* #####################################
# Controls the way creeps are spawn #
#####################################*/
var roles = require("roles");
module.exports = {
run: function () {
for (var sp in Game.spawns) {
sp = Game.spawns[sp]
// values
var creep_count = 0
for (var cr in Game.creeps) {
if (Game.creeps[cr].room.name == sp.room.name) creep_count += 1;
}
var source_count = 0;
if (sp.memory.sources_ids != undefined) source_count = sp.memory.sources_ids.length;
// Memory setup
if (sp.memory.creep_iterate == undefined) sp.memory.creep_iterate = 0;
if (sp.memory.sources_ids == undefined) {
sp.memory.sources_ids = [];
var sources = sp.room.find(FIND_SOURCES);
for (var source in sources) {
source = sources[source];
sp.memory.sources_ids.push(source.id);
}
source_count = sp.memory.sources_ids.length;
}
if (sp.memory.containers_ids == undefined || sp.memory.containers_ids.length != source_count) {
sp.memory.containers_ids = [];
var containers = sp.room.find(FIND_STRUCTURES, { filter: { structureType: STRUCTURE_CONTAINER } });
if (containers.length > 0) {
for (let i = 0; i < containers.length; i += 1) {
sp.memory.containers_ids.push(containers[i].id);
}
}
}
// Different spawning configurations
// Add improved versions at top of if-else statement
if (sp.memory.containers_ids.length >= source_count && sp.room.energyCapacityAvailable >= 550 && creep_count > source_count) { // Miner method: Miners fille containers rest picks up from them
// Check current creep_jobs
var jobs = { miner: 0, supplier: 0, builder: 0, upgrader: 0, defender: 0 };
var container_id = sp.memory.containers_ids[0];
for (var creep in Game.creeps) {
var creep = Game.creeps[creep];
if (creep.room.name != sp.room.name) continue;
switch (creep.memory.role) {
case roles.ROLE_MINER:
jobs.miner += 1;
for (let i = 0; i < sp.memory.containers_ids.length; i++) {
if (creep.memory.container_id != sp.memory.containers_ids[i]) container_id = sp.memory.containers_ids[i];
}
break;
case roles.ROLE_SUPPLIER:
jobs.supplier += creep.body.length;
break;
case roles.ROLE_BUILDER:
jobs.builder += creep.body.length;
break;
case roles.ROLE_UPGRADER:
jobs.upgrader += creep.body.length;
break;
case roles.ROLE_DEFENDER:
jobs.defender += 1;
break;
default:
break;
}
}
if (jobs.miner < source_count) {
if (sp.room.energyAvailable >= 550) create_miner(sp, container_id);
}
else if (jobs.supplier < source_count * 15 && sp.room.energyAvailable >= 300 && jobs.miner > 0) create_supplier(sp);
else if (jobs.builder < source_count * 5 && sp.room.energyAvailable >= 300 && jobs.miner > 0) create_builder(sp);
else if (jobs.upgrader < source_count * 5 && sp.room.energyAvailable >= 300 && jobs.miner > 0) create_upgrader(sp);
else if (jobs.defender < 0 && sp.room.energyAvailable >= sp.room.energyCapacityAvailable * 0.8 && jobs.miner > 0) create_defender(sp);
} else { // Harvesting method: everybody mines own sources
if (sp.room.find(FIND_MY_CREEPS).length < source_count * 5 && sp.room.energyAvailable >= 300) {
var source_id = sp.memory.sources_ids[sp.memory.creep_iterate % source_count];
create_harvester(sp, source_id);
}
}
}
}
};
function create_harvester(sp, source_id) {
var body = [];
for (let i = 0; i < Math.floor(sp.room.energyAvailable / 200); i++) {
body.push(WORK);
body.push(CARRY);
body.push(MOVE);
}
var name = "Harvy" + sp.memory.creep_iterate;
sp.spawnCreep(body, name, {
memory:
{ role: roles.ROLE_HARVESTER, source_id: source_id }
});
sp.memory.creep_iterate += 1;
}
function create_miner(sp, container_id) {
var body = [WORK, WORK, WORK, WORK, WORK, MOVE]; // (creep)5*work(2energy/tick)=10energy/tick -> (source)3000energy/300tick=10energy/tick
var name = "Mindy" + sp.memory.creep_iterate;
sp.spawnCreep(body, name, {
memory:
{ role: roles.ROLE_MINER, container_id: container_id }
});
sp.memory.creep_iterate += 1;
}
function create_supplier(sp) {
var body = [WORK];
for (let i = 0; i < Math.floor(sp.room.energyAvailable / 100) - 1 && i < 8; i++) { // as big as possible
body.push(CARRY);
body.push(MOVE);
}
var name = "Suppry" + sp.memory.creep_iterate;
sp.spawnCreep(body, name, {
memory:
{ role: roles.ROLE_SUPPLIER }
});
sp.memory.creep_iterate += 1;
}
function create_builder(sp) {
var body = [];
for (let i = 0; i < Math.floor(sp.room.energyAvailable / 200); i++) { // as big as possible
body.push(CARRY);
body.push(MOVE);
body.push(WORK);
}
var name = "Bobby" + sp.memory.creep_iterate;
sp.spawnCreep(body, name, {
memory:
{ role: roles.ROLE_BUILDER }
});
sp.memory.creep_iterate += 1;
}
function create_upgrader(sp) {
var body = [];
for (let i = 0; i < Math.floor(sp.room.energyAvailable / 300); i++) { // as big as possible
body.push(CARRY);
body.push(MOVE);
body.push(WORK);
body.push(WORK);
}
var name = "Undy" + sp.memory.creep_iterate;
sp.spawnCreep(body, name, {
memory:
{ role: roles.ROLE_UPGRADER }
});
sp.memory.creep_iterate += 1;
}
function create_defender(sp) {
var body = [];
for (let i = 0; i < Math.floor(sp.room.energyAvailable / 150); i++) { // as big as possible
body.push(TOUGH);
body.push(TOUGH);
body.push(ATTACK);
body.push(MOVE);
}
var name = "Destroyer CODE" + sp.memory.creep_iterate;
sp.spawnCreep(body, name, {
memory:
{ role: roles.ROLE_DEFENDER }
});
sp.memory.creep_iterate += 1;
}

19
system.js
View File

@@ -1,19 +0,0 @@
/**
* Basis of the entire system. Everything will be managed from here on out.
*/
const commands = require("commands");
const creeps = require("creeps")
module.exports = {
// Gets called when recompiling and when Restart command is called.
start: function () {
commands.configure();
creeps.configure();
},
// Gets called every tick.
update: function () {
creeps.execute();
}
}