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

Merge pull request #1 from DouweRavers/develop

Browse Source 
Develop
This commit is contained in:
Douwe Ravers
2023-08-26 20:49:17 +02:00
committed by GitHub
parent ccd0557339 e294ad29fe
commit cab2c3fd25
19 changed files with 345 additions and 153 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
Class.js
View File

@@ -1,11 +0,0 @@
const creepClass = require("ClassCreep");
const roomClass = require("ClassRoom");
const spawnClass = require("ClassSpawn");
module.exports = {
setup(){
creepClass.setup();
roomClass.setup();
spawnClass.setup();
}
}

16
ClassCreep.js
View File

@@ -1,16 +0,0 @@
module.exports = {
setup: function () {
Creep.prototype = _Creep.prototype;
global.Role = Role;
}
}
const Role = {
HARVESTER: 0
}
module.exports = {
setup: function () { Creep.prototype = _Creep.prototype; }
}
class _Creep extends Creep {}

6
ClassRoom.js
View File

@@ -1,6 +0,0 @@
module.exports = {
setup: function () { Room.prototype = _Room.prototype; }
}
class _Room extends Room {}

21
ClassSpawn.js
View File

@@ -1,21 +0,0 @@
module.exports = {
setup: function () { StructureSpawn.prototype = _Spawn.prototype; }
}
class _Spawn extends StructureSpawn {
createHarvester() {
var body = [WORK, CARRY, MOVE];
this.createCreep(body, "harvester", Role.HARVESTER);
}
createCreep(body, name, role) {
if (this.memory.creepCounter == undefined) this.memory.creepCounter = 0;
const response = this.spawnCreep(body, name + ": " + this.memory.creepCounter, {
memory: { job: { role: role } }
});
if (response == OK) this.memory.creepCounter++;
return response;
}
}

61
Commands.js Normal file
View File

@@ -0,0 +1,61 @@
module.exports = {
setup(){
global.fullReset = fullReset;
global.resetRooms = resetRooms;
global.resetStructures = resetStructures;
global.resetCreeps = resetCreeps;
global.resetConstruction = resetConstruction;
global.buildRoads = buildRoads;
}
}
function fullReset(){
resetRooms();
resetCreeps();
resetStructures();
resetConstruction();
global.started = false;
global.compiled = false;
return "OK";
}
function resetRooms(){
Object.values(Game.rooms).forEach(room => room.memory = {});
return "OK";
}
function resetStructures(){
Object.values(Game.structures).forEach(structure => structure.memory = {});
return "OK";
}
function resetCreeps(){
Object.values(Game.creeps).forEach(creep => creep.suicide());
return "OK";
}
function resetConstruction(){
Object.values(Game.rooms).forEach(room=>room.find(FIND_CONSTRUCTION_SITES).forEach(cs=>cs.remove()));
return "OK";
}
function buildRoads(){
Object.values(Game.rooms).forEach(room=>
{
room.memory.layout.sources.forEach(
sId => {
const source = Game.getObjectById(sId);
var roads = [];
roads = roads.concat(source.pos.findPathTo(this.controller));
roads.pop();
roads = roads.concat(source.pos.findPathTo(room.find(FIND_MY_STRUCTURES, { filter:{ structureType:STRUCTURE_SPAWN }})[0]));
roads.pop();
roads.forEach(tile => room.createConstructionSite(tile.x, tile.y, STRUCTURE_ROAD));
}
);
});
return "OK";
}

36
CreepClass.js Normal file
View File

@@ -0,0 +1,36 @@
const jobHarvester = require("JobHarvester");
const jobMiner = require("JobMiner");
module.exports = {
setup: function () {
Creep.prototype = _Creep.prototype;
global.Role = Role;
}
}
const Role = {
HARVESTER: 0,
MINER: 1,
SUPPLIER: 2,
UPGRADER: 3,
BUILDER: 4
}
class _Creep extends Creep {
begin(){
if(!this.memory.job) this.memory.job = { role: Role.HARVESTER };
switch (this.memory.job.role) {
case Role.HARVESTER: jobHarvester.begin(this); break;
case Role.MINER: jobMiner.begin(this); break;
}
this.memory.init = true;
}
tick(){
if(!this.memory.init) this.begin();
switch (this.memory.job.role) {
case Role.HARVESTER: jobHarvester.tick(this); break;
case Role.MINER: jobMiner.tick(this); break;
}
}
}

26
Job.js
View File

@@ -1,26 +0,0 @@
const jobHarvester = require("JobHarvester");
const Role = {
HARVESTER: 0
}
module.exports = {
setup(){
global.Role = Role;
},
begin(creep){
if(!creep.memory.job) creep.memory.job = { role: Role.HARVESTER };
switch (creep.memory.job.role) {
case Role.HARVESTER: jobHarvester.tick(creep); break;
}
},
tick(creep){
switch (creep.memory.job.role) {
case Role.HARVESTER: jobHarvester.tick(creep); break;
}
}
}

8
JobBuilder.js Normal file
View File

@@ -0,0 +1,8 @@
module.exports = {
begin(creep){
},
tick(creep){
}
}

94
JobHarvester.js
View File

@@ -1,21 +1,89 @@
module.exports = {
begin(creep){
const jobMemory = creep.memory.job;
if(!jobMemory.harvesting) creep.memory.job.harvesting = false;
if(!creep.memory.harvesting) creep.memory.harvesting = false;
if(!creep.memory.counter) creep.memory.counter = 0;
},
tick(creep){
const jobMemory = creep.memory.job;
if(jobMemory.harvesting){
const source = creep.pos.findClosestByRange(FIND_SOURCES);
if(creep.pos.isNearTo(source)) creep.harvest(source);
else creep.moveTo(source);
if(!creep.store.getFreeCapacity(RESOURCE_ENERGY)) jobMemory.harvesting = false;
} else{
const controller = creep.room.controller;
if(creep.pos.isNearTo(controller)) creep.upgradeController(controller);
else creep.moveTo(controller);
if(!creep.store.getUsedCapacity(RESOURCE_ENERGY)) jobMemory.harvesting = true;
if(creep.memory.harvesting) {
pickUpEnergy(creep);
onEnergyFullTurnToJobMode(creep);
}
else {
performJobs(creep);
onOutOfEnergyTurnHarvestingMode(creep);
}
}
}
function pickUpEnergy(creep){
if(!creep.memory.target) {
const target = creep.pos.findClosestByRange(FIND_DROPPED_RESOURCES, {filter: {resourceType: RESOURCE_ENERGY}});
if(target) creep.memory.target = target.id;
}
const resource = Game.getObjectById(creep.memory.target);
if(!resource) creep.memory.target = undefined;
if(creep.pos.isNearTo(resource)) creep.pickup(resource);
else creep.moveTo(resource);
}
function harvestSource(creep){
if(!creep.memory.target) creep.memory.target = getSourceIdFromRoomTable(creep);
var source = Game.getObjectById(creep.memory.target);
if(creep.pos.isNearTo(source)) creep.harvest(source);
else creep.moveTo(source);
}
function onEnergyFullTurnToJobMode(creep){
if(!creep.store.getFreeCapacity(RESOURCE_ENERGY)) {
creep.memory.harvesting = false;
creep.memory.target = undefined;
}
}
function performJobs(creep){
if(!creep.memory.target) creep.memory.target = getJobTarget(creep);
var target = Game.getObjectById(creep.memory.target);
if(creep.pos.isNearTo(target)) doJob(creep, target);
else creep.moveTo(target);
}
function onOutOfEnergyTurnHarvestingMode(creep){
if(!creep.store.getUsedCapacity(RESOURCE_ENERGY)) {
creep.memory.harvesting = true;
creep.memory.target = undefined;
creep.memory.counter += 1;
}
}
function getSourceIdFromRoomTable(creep) {
const sourceTable = creep.room.memory.layout.sources;
const sourceIterator = creep.memory.counter%creep.room.memory.layout.sources.length;
const sourceId = sourceTable[sourceIterator];
return sourceId;
}
function getJobTarget(creep) {
var target;
switch (creep.memory.counter%3) {
case 0: target = creep.room.controller; break;
case 1: target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES, {filter:{structureType:STRUCTURE_SPAWN}}); break;
case 2: target = creep.pos.findClosestByRange(FIND_MY_CONSTRUCTION_SITES); break;
}
if(target) return target.id;
creep.memory.counter++;
return undefined;
}
function doJob(creep, target){
var response;
switch (creep.memory.counter%3) {
case 0: response = creep.upgradeController(target); break;
case 1: response = creep.transfer(target, RESOURCE_ENERGY); break;
case 2: response = creep.build(target); break;
}
if(response == ERR_FULL) {
creep.memory.counter++;
creep.memory.target = undefined;
}
}

18
JobMiner.js Normal file
View File

@@ -0,0 +1,18 @@
module.exports = {
begin(creep){},
tick(creep){
const source = Game.getObjectById(creep.memory.job.source);
if(creep.memory.aboveContainer) creep.harvest(source);
if(!creep.pos.isNearTo(source)) { creep.moveTo(source); return; }
if(creep.memory.container) {
const container = Game.getObjectById(creep.memory.container);
if(container.pos.x === creep.pos.x, container.pos.y === creep.pos.y) creep.memory.aboveContainer = true;
else creep.moveTo(container);
} else{
const container = source.pos.findInRange(FIND_STRUCTURES, 1, {filter:{structureType:STRUCTURE_CONTAINER}})[0];
if(container) creep.memory.container = container.id;
else creep.harvest(source);
}
}
}

8
JobSupplier.js Normal file
View File

@@ -0,0 +1,8 @@
module.exports = {
begin(creep){
},
tick(creep){
}
}

8
JobUpgrader.js Normal file
View File

@@ -0,0 +1,8 @@
module.exports = {
begin(creep){
},
tick(creep){
}
}

7
Math.js Normal file
View File

@@ -0,0 +1,7 @@
module.exports = {
clamp: function(v, min, max){
if(v<min) v = min;
else if (max < v) v = max;
return v;
}
}

17
Room.js
View File

@@ -1,17 +0,0 @@
module.exports = {
setup(){},
begin(room){
if(!room.memory.jobs) room.memory.jobs = {
harvesters: 1
}
},
tick(room){
if(!(Game.time % 100)) calculateJobs(room);
}
}
function calculateJobs(room) {
room.memory.jobs.harvesters = 10 - Object.keys(Game.creeps).length;
}

39
RoomClass.js Normal file
View File

@@ -0,0 +1,39 @@
module.exports = {
setup: function () { Room.prototype = _Room.prototype; }
}
class _Room extends Room {
begin(){
roomScan(this);
jobScan(this);
vacancyScan(this);
this.memory.init = true;
}
tick(){
if(!this.memory.init) this.begin();
if(Game.time%100 === 1) vacancyScan(this);
}
}
function roomScan(room){
room.memory.layout = {
sources: room.find(FIND_SOURCES).map(s=>s.id)
};
}
function jobScan(room){
if(!room.memory.jobs) room.memory.jobs = Array(10).fill({role: Role.HARVESTER})
.concat(room.memory.layout.sources.map(s=> {return {role: Role.MINER, source: s}}));
}
function vacancyScan(room){
const activeJobs = room.find(FIND_MY_CREEPS).map(creep=>creep.memory.job);
const jobs = [].concat(room.memory.jobs);
activeJobs.forEach(job => {
const index = jobs.indexOf(job);
if(0 <= index) jobs.splice(index,1);
});
room.memory.vacancies = jobs;
}

30
Structure.js
View File

@@ -1,17 +1,21 @@
const StructureSpawn = require("StructureSpawn")
const spawnClass = require("StructureSpawnClass");
module.exports = {
setup(){},
setup() {
spawnClass.setup();
},
begin(structure){
switch (structure.structureType) {
case STRUCTURE_SPAWN: StructureSpawn.begin(structure); break;
}
},
tick(structure){
switch (structure.structureType) {
case STRUCTURE_SPAWN: StructureSpawn.tick(structure); break;
}
}
begin(structure){
switch (structure.structureType) {
case STRUCTURE_SPAWN: structure.begin(); break;
default: break;
}
},
tick(structure){
switch (structure.structureType) {
case STRUCTURE_SPAWN: structure.tick(); break;
default: break;
}
}
}

12
StructureSpawn.js
View File

@@ -1,12 +0,0 @@
module.exports = {
setup(){},
begin(spawn){
},
tick(spawn){
if(spawn.room.memory.jobs.harvesters) {
if(spawn.createHarvester());
}
}
}

42
StructureSpawnClass.js Normal file
View File

@@ -0,0 +1,42 @@
module.exports = {
setup: function () { StructureSpawn.prototype = _StructureSpawn.prototype; }
}
class _StructureSpawn extends StructureSpawn {
begin(){
if (!this.memory.creepCounter) this.memory.creepCounter = 0;
this.memory.init = true;
}
tick(){
if(!this.memory.init) this.begin();
const job = this.room.memory.vacancies.pop();
if(job){
const name = getJobName(job.role);
const body = getBodyByJob(job.role);
if(this.createCreep(job, name, body) != OK) this.room.memory.vacancies.push(job);
}
}
createCreep(job, name, body) {
const response = this.spawnCreep(body, name + ": " + this.memory.creepCounter, {
memory: { job: job }
});
if (response == OK) this.memory.creepCounter++;
return response;
}
}
function getJobName(role){
switch (role) {
case Role.HARVESTER: return "Harvy";
case Role.MINER: return "minny";
}
}
function getBodyByJob(role){
switch (role) {
case Role.HARVESTER: return [WORK, CARRY, MOVE, MOVE];
case Role.MINER: return [WORK, WORK, MOVE];
}
}

38
main.js
View File

@@ -1,40 +1,42 @@
// ########################################
// ########## MAIN ##########
// ########################################
const Class = require("Class");
const Job = require("Job");
const Room = require("Room");
const Commands = require("Commands");
const CreepClass = require("CreepClass");
const RoomClass = require("RoomClass");
const Structure = require("Structure");
module.exports.loop = function () {
if(!global.compiled) onRecompile();
else if (!global.started) onRestart();
else onTick();
}
function onRecompile(){
Class.setup();
Job.setup();
function onRecompile(){
setupClasses();
console.log("Script recompiled...");
global.compiled = true;
}
function onRestart(){
Object.values(Game.rooms).forEach(room => Room.begin(room));
Object.values(Game.spawns).forEach(spawn => Structure.begin(spawn));
Object.values(Game.creeps).forEach(creep => Job.begin(creep));
Object.values(Game.rooms).forEach(room => room.begin());
Object.values(Game.creeps).forEach(creep => creep.begin());
Object.values(Game.structures).forEach(structure => Structure.begin(structure));
global.started = true;
}
function onTick(){
Object.values(Game.rooms).forEach(room => Room.tick(room));
Object.values(Game.spawns).forEach(spawn => Structure.tick(spawn));
Object.values(Game.creeps).forEach(creep => Job.tick(creep));
Object.values(Game.rooms).forEach(room => room.tick());
Object.values(Game.creeps).forEach(creep => creep.tick());
Object.values(Game.structures).forEach(structure => Structure.tick(structure));
if(!(Game.time % 100)) cleanUp();
}
function setupClasses(){
Commands.setup();
CreepClass.setup();
RoomClass.setup();
Structure.setup();
}
function cleanUp(){
Object.keys(Memory.rooms).forEach(roomName => { if(!Game.rooms[roomName]) Memory.rooms[roomName] = undefined; });
Object.keys(Memory.creeps).forEach(creepName => { if(!Game.creeps[creepName]) Memory.creeps[creepName] = undefined; });