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

Removed the harvester. Introduced the cleaner (not active yet) spawners use full room capacity now.

Browse Source
This commit is contained in:
unknown
2023-08-30 23:37:04 +02:00
parent 112c3c3a97
commit eda20c2dce
6 changed files with 118 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
CreepClass.js
View File

@@ -1,8 +1,7 @@
const jobBuilder = require("JobBuilder");
const jobHarvester = require("JobHarvester");
const jobMiner = require("JobMiner");
const jobSupplier = require("JobSupplier");
const JobUpgrader = require("JobUpgrader");
const jobUpgrader = require("JobUpgrader");
module.exports = {
setup: function () {
@@ -12,11 +11,10 @@ module.exports = {
}
const Role = {
HARVESTER: 0,
BUILDER: 0,
MINER: 1,
SUPPLIER: 2,
UPGRADER: 3,
BUILDER: 4
UPGRADER: 3
}
class _Creep extends Creep {
@@ -24,10 +22,9 @@ class _Creep extends Creep {
if(!this.memory.job) this.memory.job = { role: Role.HARVESTER };
switch (this.memory.job.role) {
case Role.BUILDER: jobBuilder.begin(this); break;
case Role.HARVESTER: jobHarvester.begin(this); break;
case Role.MINER: jobMiner.begin(this); break;
case Role.SUPPLIER: jobSupplier.begin(this); break;
case Role.UPGRADER: JobUpgrader.begin(this); break;
case Role.UPGRADER: jobUpgrader.begin(this); break;
}
this.memory.init = true;
}
@@ -36,10 +33,9 @@ class _Creep extends Creep {
if(!this.memory.init) this.begin();
switch (this.memory.job.role) {
case Role.BUILDER: jobBuilder.tick(this); break;
case Role.HARVESTER: jobHarvester.tick(this); break;
case Role.MINER: jobMiner.tick(this); break;
case Role.SUPPLIER: jobSupplier.tick(this); break;
case Role.UPGRADER: JobUpgrader.tick(this); break;
case Role.UPGRADER: jobUpgrader.tick(this); break;
}
}
}

81
JobCleaner.js Normal file
View File

@@ -0,0 +1,81 @@
module.exports = {
begin(creep){
if(!creep.memory.collecting) creep.memory.collecting = false;
},
tick(creep){
if(creep.memory.collecting) {
searchForLooseEnergy(creep);
energyFullCheck(creep);
}
else {
DepositEnergy(creep);
energyEmptyCheck(creep);
}
}
}
function searchForLooseEnergy(creep){
if(!creep.memory.target) findLooseEnergyTarget(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 DepositEnergy(creep){
if(!creep.memory.target) findDepositTarget(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 findLooseEnergyTarget(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) creep.memory.target = target.id;
}
function findDepositTarget(creep) {
var target = creep.pos.findClosestByRange(FIND_STRUCTURES, {
filter:(s)=> {
return s.structureType == STRUCTURE_CONTAINER
&& s.store.getFreeCapacity(RESOURCE_ENERGY) > 1000;
}});
if(!target) target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES, {
filter:(s)=> {
return (s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_EXTENSION)
&& s.store.getFreeCapacity(RESOURCE_ENERGY) > 0;
}});
if(!target) target = creep.room.storage;
if(target) creep.memory.target = target.id;
}

91
JobHarvester.js
View File

@@ -1,91 +0,0 @@
module.exports = {
begin(creep){
if(!creep.memory.harvesting) creep.memory.harvesting = false;
if(!creep.memory.counter) creep.memory.counter = 0;
},
tick(creep){
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%4) {
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;
case 3: target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES, {filter:(s)=>{return s.hitsMax != s.hits;}}); break;
}
if(target) return target.id;
creep.memory.counter++;
return undefined;
}
function doJob(creep, target){
var response;
switch (creep.memory.counter%4) {
case 0: response = creep.upgradeController(target); break;
case 1: response = creep.transfer(target, RESOURCE_ENERGY); break;
case 2: response = creep.build(target); break;
case 3: response = creep.repair(target); break;
}
if(response == ERR_FULL) {
creep.memory.counter++;
creep.memory.target = undefined;
}
}

7
JobSupplier.js
View File

@@ -75,9 +75,14 @@ function findTransferTarget(creep) {
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)
return (s.structureType == STRUCTURE_EXTENSION)
&& s.store.getFreeCapacity(RESOURCE_ENERGY) > 0;
}});
if(!target) target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES, {
filter:(s)=> {
return (s.structureType == STRUCTURE_SPAWN)
&& s.store.getFreeCapacity(RESOURCE_ENERGY) > 0;
}});
break;
case 1: target = creep.pos.findClosestByRange(FIND_STRUCTURES, {
filter:(s)=> {

4
RoomClass.js
View File

@@ -26,8 +26,8 @@ function roomLayoutScan(room){
function jobScan(room){
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(Array(4).fill({role: Role.BUILDER}))
.concat(Array(2).fill({role: Role.SUPPLIER}))
.concat(room.memory.layout.sources.map(s=> {return {role: Role.MINER, source: s}}));
}

33
StructureSpawnClass.js
View File

@@ -1,3 +1,5 @@
const math = require("Math");
module.exports = {
setup: function () { StructureSpawn.prototype = _StructureSpawn.prototype; }
}
@@ -14,7 +16,7 @@ class _StructureSpawn extends StructureSpawn {
const job = this.room.memory.vacancies.pop();
if(job){
const name = getJobName(job.role);
const body = getBodyByJob(job.role);
const body = getBodyByJob(job.role, this.room.energyAvailable);
if(this.createCreep(job, name, body) != OK) this.room.memory.vacancies.push(job);
}
}
@@ -31,19 +33,32 @@ class _StructureSpawn extends StructureSpawn {
function getJobName(role){
switch (role) {
case Role.BUILDER: return "Bob";
case Role.HARVESTER: return "Harvy";
case Role.MINER: return "minny";
case Role.SUPPLIER: return "Sully";
case Role.UPGRADER: return "Uppa";
}
}
function getBodyByJob(role){
switch (role) {
case Role.BUILDER:
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]
function getBodyByJob(role, energyAvailability){
const body = [];
switch (role) {
case Role.UPGRADER: body.push(CARRY); body.push(MOVE); energyAvailability -= 100; break;
case Role.MINER: body.push(MOVE); energyAvailability -= 50; break;
}
var unitEnergyCost = 0;
while(unitEnergyCost <= energyAvailability) {
switch (role) {
case Role.BUILDER: body.push(WORK); body.push(CARRY); body.push(MOVE); unitEnergyCost = 200; break;
case Role.UPGRADER:
case Role.MINER:
body.push(WORK); unitEnergyCost = 100;
if(role === Role.MINER && body.length > 5) energyAvailability = -1;
break;
case Role.SUPPLIER: body.push(CARRY); body.push(MOVE); unitEnergyCost = 100; break;
default: energyAvailability = -1; break;
}
energyAvailability -= unitEnergyCost;
}
return body;
}