From 0985358150ba1c213e241adff9ba6adc95d28f53 Mon Sep 17 00:00:00 2001 From: Douwe Ravers Date: Fri, 15 Apr 2022 14:27:00 +0200 Subject: [PATCH] Adding source code to respository. --- .sync | 2 + .vscode/settings.json | 7 + ai_main.js | 59 +++++++ commands.js | 33 ++++ creeps.js | 92 ++++++++++ main.js | 40 +++++ roles.js | 398 ++++++++++++++++++++++++++++++++++++++++++ rooms.js | 7 + spawns.js | 183 +++++++++++++++++++ system.js | 19 ++ towers.js | 36 ++++ 11 files changed, 876 insertions(+) create mode 100644 .sync create mode 100644 .vscode/settings.json create mode 100644 ai_main.js create mode 100644 commands.js create mode 100644 creeps.js create mode 100644 main.js create mode 100644 roles.js create mode 100644 rooms.js create mode 100644 spawns.js create mode 100644 system.js create mode 100644 towers.js diff --git a/.sync b/.sync new file mode 100644 index 0000000..ac69617 --- /dev/null +++ b/.sync @@ -0,0 +1,2 @@ +1650024834746 +5ce5d401e947ee7ab16cc8db \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..44addcb --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,7 @@ +{ + "files.exclude": { + ".*": true, + "LICENSE": true, + "*.md": true + } +} \ No newline at end of file diff --git a/ai_main.js b/ai_main.js new file mode 100644 index 0000000..eec9b15 --- /dev/null +++ b/ai_main.js @@ -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 } + }); + } + } + } + } + } +}; \ No newline at end of file diff --git a/commands.js b/commands.js new file mode 100644 index 0000000..2d111e7 --- /dev/null +++ b/commands.js @@ -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 + diff --git a/creeps.js b/creeps.js new file mode 100644 index 0000000..af4f15e --- /dev/null +++ b/creeps.js @@ -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; +} \ No newline at end of file diff --git a/main.js b/main.js new file mode 100644 index 0000000..2f7fe2d --- /dev/null +++ b/main.js @@ -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]); + } + } +} diff --git a/roles.js b/roles.js new file mode 100644 index 0000000..f6150d5 --- /dev/null +++ b/roles.js @@ -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; + } + } + } +}; \ No newline at end of file diff --git a/rooms.js b/rooms.js new file mode 100644 index 0000000..22ca69f --- /dev/null +++ b/rooms.js @@ -0,0 +1,7 @@ +/** + * Managing the behavior of buildings and creeps is on a per room level. +*/ + + +module.exports = { +} \ No newline at end of file diff --git a/spawns.js b/spawns.js new file mode 100644 index 0000000..3e1984a --- /dev/null +++ b/spawns.js @@ -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; +} \ No newline at end of file diff --git a/system.js b/system.js new file mode 100644 index 0000000..8421f04 --- /dev/null +++ b/system.js @@ -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(); + } +} \ No newline at end of file diff --git a/towers.js b/towers.js new file mode 100644 index 0000000..e3891de --- /dev/null +++ b/towers.js @@ -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); + } + } + } + } + } +}; \ No newline at end of file