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

Adding source code to respository.

Browse Source
This commit is contained in:
Douwe Ravers
2022-04-15 14:27:00 +02:00
parent ffc5d3df13
commit 0985358150
11 changed files with 876 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.sync Normal file
View File

@@ -0,0 +1,2 @@
1650024834746
5ce5d401e947ee7ab16cc8db

7
.vscode/settings.json vendored Normal file
View File

@@ -0,0 +1,7 @@
{
"files.exclude": {
".*": true,
"LICENSE": true,
"*.md": true
}
}

59
ai_main.js Normal file
View File

@@ -0,0 +1,59 @@
/* ###########################
# Cross room managment AI #
########################### */
var roles = require("roles");
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) {
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 } });
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) {
var containers = flag.room.find(FIND_STRUCTURES, { filter: (s) => (s.structureType == STRUCTURE_CONTAINER) });
if (containers.length > 0) {
var has_miner = false;
var creeps = flag.room.find(FIND_CREEPS);
for (var cp in creeps) {
console.log(creeps[cp]);
var creep = creeps[cp];
if (creep.memory.role == roles.ROLE_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 } });
}
}
var harvs = flag.room.find(FIND_MY_CREEPS).length;
var source_id = flag.room.find(FIND_SOURCES)[0].id;
if (harvs < 4) {
var spawn = Game.spawns[Memory.AImain.MainHub];
var body = [];
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 }
});
}
}
}
}
}
};

33
commands.js Normal file
View File

@@ -0,0 +1,33 @@
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

92
creeps.js Normal file
View File

@@ -0,0 +1,92 @@
/* ###################################################################
# 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;
}

40
main.js Normal file
View File

@@ -0,0 +1,40 @@
/* ######################
# Screeps 2022 #
######################*/
const spawns = require("spawns");
const creeps = require("creeps");
const towers = require("towers");
const ai_main = require("ai_main");
const system = require("system");
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();
}
}
function clear_dead_creeps_from_memory() {
for (var cr in Memory.creeps) {
if (Game.creeps[cr] == null) {
delete (Memory.creeps[cr]);
}
}
}

398
roles.js Normal file
View File

@@ -0,0 +1,398 @@
/* ##############################
# 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 Normal file
View File

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

183
spawns.js Normal file
View File

@@ -0,0 +1,183 @@
/* #####################################
# 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 Normal file
View File

@@ -0,0 +1,19 @@
/**
* 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();
}
}

36
towers.js Normal file
View File

@@ -0,0 +1,36 @@
module.exports = {
run: function(){
for(var spawn in Game.spawns){
var room = Game.spawns[spawn].room;
var towers = room.find(FIND_MY_STRUCTURES,
{filter: {structureType: STRUCTURE_TOWER}});
for(var tower in towers){
tower = towers[tower];
var enemy = tower.pos.findClosestByRange(FIND_HOSTILE_CREEPS);
if(enemy != null) tower.attack(enemy);
else {
var healt_creep = false;
for(var creep in Game.creeps){
creep = Game.creeps[creep];
if(creep.hits < creep.hitsMax) {
tower.heal(creep);
healt_creep = true;
}
}
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];
}
tower.repair(structure);
}
}
}
}
}
};