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

Created supplier and builder functions

Browse Source
This commit is contained in:
unknown
2023-08-29 20:43:10 +02:00
parent 523a2e0005
commit 112c3c3a97
8 changed files with 239 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
CreepClass.js
View File

@@ -1,5 +1,8 @@
const jobBuilder = require("JobBuilder");
const jobHarvester = require("JobHarvester"); const jobHarvester = require("JobHarvester");
const jobMiner = require("JobMiner"); const jobMiner = require("JobMiner");
const jobSupplier = require("JobSupplier");
const JobUpgrader = require("JobUpgrader");
module.exports = { module.exports = {
setup: function () { setup: function () {
@@ -20,8 +23,11 @@ class _Creep extends Creep {
begin(){ begin(){
if(!this.memory.job) this.memory.job = { role: Role.HARVESTER }; if(!this.memory.job) this.memory.job = { role: Role.HARVESTER };
switch (this.memory.job.role) { switch (this.memory.job.role) {
case Role.BUILDER: jobBuilder.begin(this); break;
case Role.HARVESTER: jobHarvester.begin(this); break; case Role.HARVESTER: jobHarvester.begin(this); break;
case Role.MINER: jobMiner.begin(this); break; case Role.MINER: jobMiner.begin(this); break;
case Role.SUPPLIER: jobSupplier.begin(this); break;
case Role.UPGRADER: JobUpgrader.begin(this); break;
} }
this.memory.init = true; this.memory.init = true;
} }
@@ -29,8 +35,11 @@ class _Creep extends Creep {
tick(){ tick(){
if(!this.memory.init) this.begin(); if(!this.memory.init) this.begin();
switch (this.memory.job.role) { switch (this.memory.job.role) {
case Role.BUILDER: jobBuilder.tick(this); break;
case Role.HARVESTER: jobHarvester.tick(this); break; case Role.HARVESTER: jobHarvester.tick(this); break;
case Role.MINER: jobMiner.tick(this); break; case Role.MINER: jobMiner.tick(this); break;
case Role.SUPPLIER: jobSupplier.tick(this); break;
case Role.UPGRADER: JobUpgrader.tick(this); break;
} }
} }
} }

81
JobBuilder.js
View File

@@ -1,8 +1,89 @@
module.exports = { module.exports = {
begin(creep){ begin(creep){
if(!creep.memory.collecting) creep.memory.collecting = false;
if(!creep.memory.counter) creep.memory.counter = 0;
}, },
tick(creep){ tick(creep){
if(creep.memory.collecting) {
GetEnergy(creep);
energyFullCheck(creep);
}
else {
BuildOrRepair(creep);
energyEmptyCheck(creep);
}
}
}
function GetEnergy(creep){
if(!creep.memory.target) findWithdrawTarget(creep);
const target = Game.getObjectById(creep.memory.target);
if(!target) creep.memory.target = undefined;
if(creep.pos.isNearTo(target)) {
if(!target.store) creep.pickup(target);
else creep.withdraw(target, RESOURCE_ENERGY);
}
else creep.moveTo(target);
}
function energyFullCheck(creep){
if(!creep.store.getFreeCapacity(RESOURCE_ENERGY)) {
creep.memory.collecting = false;
creep.memory.target = undefined;
} }
} }
function BuildOrRepair(creep){
if(!creep.memory.target) findBuildOrRepairTarget(creep);
if(!creep.memory.target) return;
const target = Game.getObjectById(creep.memory.target);
if(!target) { creep.memory.target = undefined; return; }
if(target.hits && target.hits === target.hitsMax) { creep.memory.target = undefined; return; }
if(creep.pos.isNearTo(target))
if(!target.hits) creep.build(target);
else creep.repair(target);
else creep.moveTo(target);
}
function energyEmptyCheck(creep){
if(!creep.store.getUsedCapacity(RESOURCE_ENERGY)) {
creep.memory.collecting = true;
creep.memory.target = undefined;
}
}
function findWithdrawTarget(creep){
var target = creep.pos.findClosestByRange(FIND_DROPPED_RESOURCES, {
filter: (r)=>{
return r.resourceType == RESOURCE_ENERGY && r.amount > creep.store.getFreeCapacity(RESOURCE_ENERGY);
}});
if(!target) target = creep.pos.findClosestByRange(FIND_RUINS, {
filter: (r)=>{
return r.store.getUsedCapacity(RESOURCE_ENERGY) > creep.store.getFreeCapacity(RESOURCE_ENERGY);
}});
if(!target) target = creep.pos.findClosestByRange(FIND_TOMBSTONES, {
filter: (t)=>{
return t.store.getUsedCapacity(RESOURCE_ENERGY) > creep.store.getFreeCapacity(RESOURCE_ENERGY);
}});
if(!target) target = creep.pos.findClosestByRange(FIND_STRUCTURES, {
filter: (st)=>{
return st.structureType == STRUCTURE_CONTAINER && st.store.getUsedCapacity(RESOURCE_ENERGY) > creep.store.getFreeCapacity(RESOURCE_ENERGY);
}});
if(target) creep.memory.target = target.id;
}
function findBuildOrRepairTarget(creep) {
var target;
switch (creep.memory.counter%2) {
case 0: target = creep.pos.findClosestByRange(FIND_MY_CONSTRUCTION_SITES); break;
case 1: target = creep.pos.findClosestByRange(FIND_STRUCTURES, {
filter:(s)=> {
return s.hitsMax - s.hits
&& s.structureType != STRUCTURE_WALL;
}});
break;
}
if(target) creep.memory.target = target.id;
creep.memory.counter++;
}

6
JobHarvester.js
View File

@@ -65,10 +65,11 @@ function getSourceIdFromRoomTable(creep) {
function getJobTarget(creep) { function getJobTarget(creep) {
var target; var target;
switch (creep.memory.counter%3) { switch (creep.memory.counter%4) {
case 0: target = creep.room.controller; break; case 0: target = creep.room.controller; break;
case 1: target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES, {filter:{structureType:STRUCTURE_SPAWN}}); 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; case 2: target = creep.pos.findClosestByRange(FIND_MY_CONSTRUCTION_SITES); break;
case 3: target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES, {filter:(s)=>{return s.hitsMax != s.hits;}}); break;
} }
if(target) return target.id; if(target) return target.id;
creep.memory.counter++; creep.memory.counter++;
@@ -77,10 +78,11 @@ function getJobTarget(creep) {
function doJob(creep, target){ function doJob(creep, target){
var response; var response;
switch (creep.memory.counter%3) { switch (creep.memory.counter%4) {
case 0: response = creep.upgradeController(target); break; case 0: response = creep.upgradeController(target); break;
case 1: response = creep.transfer(target, RESOURCE_ENERGY); break; case 1: response = creep.transfer(target, RESOURCE_ENERGY); break;
case 2: response = creep.build(target); break; case 2: response = creep.build(target); break;
case 3: response = creep.repair(target); break;
} }
if(response == ERR_FULL) { if(response == ERR_FULL) {
creep.memory.counter++; creep.memory.counter++;

23
JobMiner.js
View File

@@ -3,16 +3,23 @@ module.exports = {
tick(creep){ tick(creep){
const source = Game.getObjectById(creep.memory.job.source); 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.pos.isNearTo(source)) { creep.moveTo(source); return; }
if(creep.memory.container) { if(creep.memory.aboveContainer) { creep.harvest(source); return; }
if(creep.memory.container) { moveToContainer(creep); return; }
if(!(Game.time%100)) scanForContainer(creep, source);
creep.harvest(source);
}
}
function moveToContainer(creep){
const container = Game.getObjectById(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; if(container.pos.x === creep.pos.x && container.pos.y === creep.pos.y) creep.memory.aboveContainer = true;
else creep.moveTo(container); else creep.moveTo(container);
} else{ }
const container = source.pos.findInRange(FIND_STRUCTURES, 1, {filter:{structureType:STRUCTURE_CONTAINER}})[0];
function scanForContainer(creep, source){
const container = source.pos.findInRange(FIND_STRUCTURES, 1, {
filter:{structureType:STRUCTURE_CONTAINER}
})[0];
if(container) creep.memory.container = container.id; if(container) creep.memory.container = container.id;
else creep.harvest(source);
}
}
} }

84
JobSupplier.js
View File

@@ -1,8 +1,92 @@
module.exports = { module.exports = {
begin(creep){ begin(creep){
if(!creep.memory.collecting) creep.memory.collecting = false;
if(!creep.memory.counter) creep.memory.counter = 0;
}, },
tick(creep){ tick(creep){
if(creep.memory.collecting) {
withdrawEnergy(creep);
energyFullCheck(creep);
}
else {
transferEnergy(creep);
energyEmptyCheck(creep);
}
}
}
function withdrawEnergy(creep){
if(!creep.memory.target) findWithdrawTarget(creep);
const target = Game.getObjectById(creep.memory.target);
if(!target) creep.memory.target = undefined;
if(creep.pos.isNearTo(target)) {
if(!target.store) creep.pickup(target);
else creep.withdraw(target, RESOURCE_ENERGY);
}
else creep.moveTo(target);
}
function energyFullCheck(creep){
if(!creep.store.getFreeCapacity(RESOURCE_ENERGY)) {
creep.memory.collecting = false;
creep.memory.target = undefined;
} }
} }
function transferEnergy(creep){
if(!creep.memory.target) findTransferTarget(creep);
if(!creep.memory.target) return;
const target = Game.getObjectById(creep.memory.target);
if(target.store.getFreeCapacity(RESOURCE_ENERGY)==0) { creep.memory.target = undefined; creep.memory.counter++; }
if(creep.pos.isNearTo(target)) creep.transfer(target, RESOURCE_ENERGY);
else creep.moveTo(target);
}
function energyEmptyCheck(creep){
if(!creep.store.getUsedCapacity(RESOURCE_ENERGY)) {
creep.memory.collecting = true;
creep.memory.target = undefined;
}
}
function findWithdrawTarget(creep){
var target = creep.pos.findClosestByRange(FIND_DROPPED_RESOURCES, {
filter: (r)=>{
return r.resourceType == RESOURCE_ENERGY && r.amount > creep.store.getFreeCapacity(RESOURCE_ENERGY);
}});
if(!target) target = creep.pos.findClosestByRange(FIND_RUINS, {
filter: (r)=>{
return r.store.getUsedCapacity(RESOURCE_ENERGY) > creep.store.getFreeCapacity(RESOURCE_ENERGY);
}});
if(!target) target = creep.pos.findClosestByRange(FIND_TOMBSTONES, {
filter: (t)=>{
return t.store.getUsedCapacity(RESOURCE_ENERGY) > creep.store.getFreeCapacity(RESOURCE_ENERGY);
}});
if(!target) target = creep.pos.findClosestByRange(FIND_STRUCTURES, {
filter: (st)=>{
return st.structureType == STRUCTURE_CONTAINER && st.store.getUsedCapacity(RESOURCE_ENERGY) > 1000;
}});
if(target) creep.memory.target = target.id;
}
function findTransferTarget(creep) {
var target;
switch (creep.memory.counter%3) {
case 0: target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES, {
filter:(s)=> {
return (s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_EXTENSION)
&& s.store.getFreeCapacity(RESOURCE_ENERGY) > 0;
}});
break;
case 1: target = creep.pos.findClosestByRange(FIND_STRUCTURES, {
filter:(s)=> {
return s.structureType == STRUCTURE_CONTAINER
&& s.store.getFreeCapacity(RESOURCE_ENERGY) > 1000;
}});
break;
case 2: target = creep.room.storage; break;
}
if(target) creep.memory.target = target.id;
creep.memory.counter++;
}

20
JobUpgrader.js
View File

@@ -3,6 +3,26 @@ module.exports = {
}, },
tick(creep){ tick(creep){
if(!creep.pos.isNearTo(creep.room.controller)) { creep.moveTo(creep.room.controller); return; }
if(creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0) { getOrWaitForEnergy(creep); return; }
creep.upgradeController(creep.room.controller);
}
}
function getOrWaitForEnergy(creep){
if(!creep.memory.container) scanForContainer(creep);
if(creep.memory.container) getEnergyFromContainer(creep);
} }
function getEnergyFromContainer(creep){
const container = Game.getObjectById(creep.memory.container);
if(creep.withdraw(container, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(container);
}
// duplicate see miner
function scanForContainer(creep){
const container = creep.room.controller.pos.findInRange(FIND_STRUCTURES, 1, {
filter:{structureType:STRUCTURE_CONTAINER}
})[0];
if(container) creep.memory.container = container.id;
} }

22
RoomClass.js
View File

@@ -4,7 +4,7 @@ module.exports = {
class _Room extends Room { class _Room extends Room {
begin(){ begin(){
roomScan(this); roomLayoutScan(this);
jobScan(this); jobScan(this);
vacancyScan(this); vacancyScan(this);
this.memory.init = true; this.memory.init = true;
@@ -12,33 +12,33 @@ class _Room extends Room {
tick(){ tick(){
if(!this.memory.init) this.begin(); if(!this.memory.init) this.begin();
if(Game.time%100 === 1) vacancyScan(this); if(!(Game.time%100)) {
vacancyScan(this);
}
} }
} }
function roomScan(room){ function roomLayoutScan(room){
room.memory.layout = { if(!room.memory.layout) room.memory.layout = {};
sources: room.find(FIND_SOURCES).map(s=>s.id) if(!room.memory.layout.sources) room.memory.layout.sources = room.find(FIND_SOURCES).map(s=>s.id);
}; room.memory.layout.containers = room.find(FIND_MY_STRUCTURES, {filter:{structureType:STRUCTURE_CONTAINER}}).map(c=>c.id);
} }
function jobScan(room){ function jobScan(room){
if(!room.memory.jobs) room.memory.jobs = Array(10).fill({role: Role.HARVESTER}) if(!room.memory.jobs) room.memory.jobs = [{role:Role.UPGRADER}]
.concat(Array(2).fill({role: Role.BUILDER}))
.concat(Array(5).fill({role: Role.SUPPLIER}))
.concat(room.memory.layout.sources.map(s=> {return {role: Role.MINER, source: s}})); .concat(room.memory.layout.sources.map(s=> {return {role: Role.MINER, source: s}}));
} }
function vacancyScan(room){ function vacancyScan(room){
const activeJobs = room.find(FIND_MY_CREEPS).map(creep=>creep.memory.job); const activeJobs = room.find(FIND_MY_CREEPS).map(creep=>creep.memory.job);
console.log(activeJobs.toString());
console.log(room.memory.jobs.toString());
const jobs = room.memory.jobs.filter((j)=>{ const jobs = room.memory.jobs.filter((j)=>{
const index = activeJobs.findIndex(aj=> _.isEqual(aj,j)); const index = activeJobs.findIndex(aj=> _.isEqual(aj,j));
if(index < 0) return true; if(index < 0) return true;
activeJobs.splice(index,1); activeJobs.splice(index,1);
return false; return false;
}); });
console.log(jobs.toString());
room.memory.vacancies = jobs; room.memory.vacancies = jobs;
} }

10
StructureSpawnClass.js
View File

@@ -30,14 +30,20 @@ class _StructureSpawn extends StructureSpawn {
function getJobName(role){ function getJobName(role){
switch (role) { switch (role) {
case Role.BUILDER: return "Bob";
case Role.HARVESTER: return "Harvy"; case Role.HARVESTER: return "Harvy";
case Role.MINER: return "minny"; case Role.MINER: return "minny";
case Role.SUPPLIER: return "Sully";
case Role.UPGRADER: return "Uppa";
} }
} }
function getBodyByJob(role){ function getBodyByJob(role){
switch (role) { switch (role) {
case Role.HARVESTER: return [WORK, CARRY, MOVE, MOVE]; case Role.BUILDER:
case Role.MINER: return [WORK, WORK, MOVE]; case Role.HARVESTER: return [WORK, CARRY, CARRY, MOVE, MOVE];
case Role.UPGRADER: return [WORK, WORK, CARRY, MOVE];
case Role.MINER: return [WORK, WORK, MOVE, MOVE];
case Role.SUPPLIER: return [CARRY, CARRY, CARRY, MOVE, MOVE, MOVE]
} }
} }