Better Server Config

.gitignore

@@ -4,3 +4,4 @@
 
 # Screeps Config
 .screeps.yml
+docker/.env

docker/.env.sample

@@ -0,0 +1 @@
+STEAM_KEY="<https://steamcommunity.com/dev/apikey>"

docker/config.yml

@@ -0,0 +1,21 @@
+serverConfig:
+  tickRate: 100
+  whitelist:
+    - YoshiUnfriendly
+  gclToCPU: true
+  maxCPU: 100
+  baseCPU: 20
+  stepCPU: 10
+
+mods:
+  - screepsmod-auth
+  - screepsmod-admin-utils
+  - screepsmod-mongo
+bots:
+  simplebot: screepsbot-zeswarm
+
+launcherOptions:
+  # If set, automatically ensures all mods are updated
+  autoUpdate: false
+  # If set, forward console messages to terminal
+  logConsole: false

docker/docker-compose.yml

@@ -0,0 +1,38 @@
+services:
+  mongo:
+    container_name: screeps-mongo
+    image: mongo:4.4.18
+    volumes:
+      - mongo-data:/data/db
+    restart: unless-stopped
+
+  redis:
+    container_name: screeps-redis
+    image: redis:7
+    volumes:
+      - redis-data:/data
+    restart: unless-stopped
+
+  screeps:
+    container_name: screeps-server
+    image: ghcr.io/jomik/screeps-server:edge
+    depends_on:
+      - mongo
+      - redis
+    ports:
+      - 21025:21025
+    environment:
+      MONGO_HOST: mongo
+      REDIS_HOST: redis
+      STEAM_KEY: ${STEAM_KEY:?"Missing steam key"}
+    volumes:
+      - ./config.yml:/screeps/config.yml
+      - screeps-data:/data
+      - screeps-mods:/screeps/mods
+    restart: unless-stopped
+
+volumes:
+  screeps-data:
+  screeps-mods:
+  redis-data:
+  mongo-data:

esbuild.config.mjs

@@ -12,4 +12,7 @@ build({
   logLevel: 'info',
   minify: false,
   keepNames: true, // optional: keeps function/class names
+  banner: {
+    js: `// Vitor Hideyoshi <vitor.h.n.batista@gmail.com> - ${new Date().toISOString()}\n`
+  },
 }).catch(() => process.exit(1));

eslint.config.js

@@ -38,6 +38,14 @@ module.exports = defineConfig([{
     "rules": {
         "@typescript-eslint/no-namespace": "off",
         "@typescript-eslint/no-explicit-any": "off",
+        "@typescript-eslint/no-unused-vars": [
+            "error",
+            {
+                "argsIgnorePattern": "^_",
+                "varsIgnorePattern": "^_",
+                "caughtErrorsIgnorePattern": "^_"
+            }
+        ],
     },
 }, {
     languageOptions: {

package.json

@@ -6,6 +6,7 @@
     "build": "node esbuild.config.mjs",
     "push:main": "npm run build && screeps-api --server main upload dist/*.js",
     "push:sim": "npm run build && screeps-api --server main upload  --branch sim dist/*.js",
+    "push:local": "npm run build && screeps-api --server local upload dist/*.js",
     "format": "prettier --config .prettierrc 'src/**/*.ts' --write && eslint --fix src/"
   },
   "repository": {

src/CreepRunner.ts

@@ -0,0 +1,36 @@
+import { CreepRole, CreepRoles } from "types/creeps";
+import { getRoomCreeps } from "utils/funcs/getRoomCreeps";
+
+class CreepRunner {
+    public static run(room: Room, state: GameState): GameState {
+        for (const name in getRoomCreeps(room)) {
+            const creep = Game.creeps[name];
+
+            if (!creep) {
+                this.clearDeadCreepMemory(name, state);
+                continue;
+            }
+
+            const roleDefinition = CreepRoles[creep.memory.role as CreepRole];
+            if (!roleDefinition) {
+                this.clearDeadCreepMemory(name, state);
+                continue;
+            }
+
+            state = roleDefinition.handler.run(creep, state);
+        }
+
+        return state;
+    }
+
+    private static clearDeadCreepMemory(creepName: string, state: GameState): void {
+        console.log(`Creep ${creepName} is dead, cleaning up memory.`);
+
+        const roleDefinition = CreepRoles[Memory.creeps[creepName].role as CreepRole];
+        roleDefinition.handler.destroy(Memory.creeps[creepName], state);
+
+        delete Memory.creeps[creepName]; // Clean up memory for dead creeps
+    }
+}
+
+export default CreepRunner;

src/RequisitionsManager.ts

@@ -0,0 +1,88 @@
+import { CreepRequisition, CreepRole, CreepRoles } from "types/creeps";
+import { DEFAULT_GAME_CONFIG } from "types/gameConfig";
+import { get_role_cost } from "utils/funcs/getRoleCost";
+import { getRoomCreeps } from "utils/funcs/getRoomCreeps";
+import { sortCreepRolesByPriority } from "utils/funcs/sortCreepRolesByPriority";
+
+class RequisitionsManager {
+    public static validateState(room: Room, state: GameState): GameState {
+        const creepRequisition = this.getRoomRequisition(room);
+
+        if (Object.values(creepRequisition).every(count => count <= 0)) {
+            return state;
+        }
+
+        const totalCreeps = Object.values(room.find(FIND_MY_CREEPS)).length;
+        if (totalCreeps >= state.maxHarvesters) {
+            return state; // No need to spawn more creeps
+        }
+
+        for (const spawn of room.find(FIND_MY_SPAWNS)) {
+            this.fulfillSpawnRequisition(spawn, creepRequisition);
+        }
+
+        return state;
+    }
+
+    private static fulfillSpawnRequisition(spawn: StructureSpawn, creepRequisition: CreepRequisition): boolean {
+        if (spawn.spawning) {
+            return false;
+        }
+
+        const rolesToSpawn = sortCreepRolesByPriority(creepRequisition);
+
+        for (const role of rolesToSpawn) {
+            if (spawn.store[RESOURCE_ENERGY] < get_role_cost(role)) {
+                continue;
+            }
+
+            const newName = `${role.name}_${Game.time}`;
+            const spawnResult = spawn.spawnCreep(role.body, newName, {
+                memory: {
+                    role: role.name,
+                    room: spawn.room.name,
+                    spawnId: spawn.id,
+                    working: false
+                }
+            });
+            if (spawnResult === OK) {
+                console.log(`Spawn ${spawn.name} successfully spawned a new ${role.name}: ${newName}.`);
+                return true; // Exit after spawning one creep
+            } else {
+                console.error(`Spawn ${spawn.name} failed to spawn a new ${role.name}: ${spawnResult}`);
+            }
+        }
+
+        return false; // No creeps were spawned
+    }
+
+    private static getRoomRequisition(room: Room): CreepRequisition {
+        const creepCounts: Record<string, number> = {};
+        for (const creepMemory of Object.values(getRoomCreeps(room))) {
+            const role = creepMemory.role;
+            creepCounts[role] = (creepCounts[role] || 0) + 1;
+        }
+
+        const requisition: CreepRequisition = {
+            harvester: 0,
+            upgrader: 0,
+            builder: 0
+        };
+        for (const role in DEFAULT_GAME_CONFIG.minCreepsPerRole) {
+            if (!(role in CreepRoles)) {
+                console.log(`Unknown creep role: ${role}`);
+                continue;
+            }
+            const roleType = role as CreepRole;
+            requisition[roleType] = DEFAULT_GAME_CONFIG.minCreepsPerRole[roleType] - (creepCounts[role] || 0);
+
+            if (requisition[roleType] < 0) {
+                requisition[roleType] = 0; // Ensure we don't have negative requisitions
+            }
+        }
+
+        return requisition;
+    }
+}
+
+export default RequisitionsManager;

src/RoomInspector.ts

@@ -0,0 +1,59 @@
+import { checkPositionWalkable } from "utils/funcs/checkPosition";
+import {
+    createSourcePositionMatrix,
+    forEachMatrixSpot,
+    getPositionWithDelta,
+    PositionSpotStatus,
+    setSpotStatus
+} from "utils/positions";
+
+class RoomInspector {
+    public static inspectState(room: Room, state: GameState): GameState {
+        if (!this.stateWasInitialized(state)) {
+            state = this.initializeState(room, state);
+        }
+        return state;
+    }
+
+    private static stateWasInitialized(state: GameState): boolean {
+        return !!state.sourcesStates;
+    }
+
+    private static initializeState(room: Room, state: GameState): GameState {
+        state.sourcesStates = {};
+        state.maxHarvesters = 0;
+
+        for (const source of room.find(FIND_SOURCES)) {
+            this.configureSourceState(source, state);
+        }
+
+        return state;
+    }
+
+    private static configureSourceState(source: Source, state: GameState): void {
+        const sourceId = source.id.toString();
+
+        if (!state.sourcesStates[sourceId]) {
+            state.sourcesStates[sourceId] = {
+                id: sourceId,
+                pos: source.pos,
+                spots: createSourcePositionMatrix()
+            };
+        }
+
+        forEachMatrixSpot(state.sourcesStates[sourceId].spots, (delta, status) => {
+            if (status !== PositionSpotStatus.UNKNOWN) {
+                return; // Skip known spots
+            }
+            const pos = getPositionWithDelta(source.pos, delta);
+            if (checkPositionWalkable(pos)) {
+                setSpotStatus(state.sourcesStates[sourceId].spots, delta, PositionSpotStatus.EMPTY);
+                state.maxHarvesters += 1;
+            } else {
+                setSpotStatus(state.sourcesStates[sourceId].spots, delta, PositionSpotStatus.INVALID);
+            }
+        });
+    }
+}
+
+export default RoomInspector;

src/RoomRunner.ts

@@ -0,0 +1,15 @@
+import CreepRunner from "CreepRunner";
+import RequisitionsManager from "RequisitionsManager";
+import RoomInspector from "RoomInspector";
+
+class RoomRunner {
+    public static run(room: Room, state: GameState): GameState {
+        state = RoomInspector.inspectState(room, state);
+
+        state = CreepRunner.run(room, state);
+
+        return RequisitionsManager.validateState(room, state);
+    }
+}
+
+export default RoomRunner;

src/main.ts

@@ -1,6 +1,6 @@
 import { CreepDestination } from "types/creeps";
-import { SourcePositionMatrix, SourceSpotStatus } from "./types/source";
-import SpawnHandler from "spawnHandler";
+import RoomRunner from "RoomRunner";
+import { PositionMatrix } from "utils/positions";
 
 declare global {
     /*
@@ -13,7 +13,7 @@ declare global {
   */
     interface SourceState {
         id: string;
-        spots: SourcePositionMatrix;
+        spots: PositionMatrix;
         pos: RoomPosition;
     }
 
@@ -26,7 +26,7 @@ declare global {
     interface Memory {
         uuid: number;
         log: any;
-        spawnStates: { [name: string]: GameState };
+        roomStateRegistry: { [name: string]: GameState };
     }
 
     interface CreepMemory {
@@ -46,15 +46,18 @@ declare global {
     }
 }
 
-
 export const loop = () => {
-    Memory.spawnStates = Memory.spawnStates || {};
+    Memory.roomStateRegistry = Memory.roomStateRegistry || {};
 
-    for (const spawnName of Object.keys(Game.spawns)) {
-        const spawnState = Memory.spawnStates[spawnName] || {};
-
-        const spawnHandler = new SpawnHandler(Game.spawns[spawnName]);
-
-        Memory.spawnStates[spawnName] = spawnHandler.run(spawnState);
+    for (const roomName of Object.keys(Game.rooms)) {
+        try {
+            Memory.roomStateRegistry[roomName] = RoomRunner.run(
+                Game.rooms[roomName],
+                Memory.roomStateRegistry[roomName] || {}
+            );
+        } catch (error) {
+            console.log(`Error running RoomRunner for room ${roomName}:`, error);
+            delete Memory.roomStateRegistry[roomName]
+        }
     }
 };

src/roleHandlers/BaseHandler.interface.ts

@@ -0,0 +1,12 @@
+export abstract class RoleHandler {
+    public static destroy(_creepMemory: CreepMemory, _state: GameState): void {
+        // Default implementation does nothing
+        // Subclasses should override this method
+    }
+
+    public static run(_creep: Creep, state: GameState): GameState {
+        // Default implementation returns state unchanged
+        // Subclasses should override this method
+        return state;
+    }
+}

src/roleHandlers/base.handler.interface.ts

@@ -1,4 +0,0 @@
-export abstract class RoleHandler {
-    static destroy(creepMemory: CreepMemory, state: GameState): void {};
-    static run(creep: Creep, state: GameState): GameState {};
-}

src/roleHandlers/harvester.handler.ts

@@ -1,9 +1,7 @@
-import { getSourceById, getSpawnById } from "utils/funcs/get_by_id";
-import { RoleHandler } from "./base.handler.interface";
-import { getNextEmptySpot, getPositionWithDelta, setSpotStatus, SourceSpotStatus } from "types/source";
+import { getSourceById, getSpawnById } from "utils/funcs/getById";
+import { RoleHandler } from "./BaseHandler.interface";
 import { SourceDestination } from "types/creeps";
-
-
+import { getNextEmptySpot, getPositionWithDelta, PositionSpotStatus, setSpotStatus } from "utils/positions";
 
 class HarvesterHandler extends RoleHandler {
     public static destroy(creepMemory: CreepMemory, state: GameState): void {
@@ -40,7 +38,7 @@ class HarvesterHandler extends RoleHandler {
             setSpotStatus(
                 state.sourcesStates[creep.memory.previousDestination.id].spots,
                 creep.memory.previousDestination.sourceSpot,
-                SourceSpotStatus.EMPTY
+                PositionSpotStatus.EMPTY
             );
             delete creep.memory.previousDestination;
         }
@@ -80,23 +78,19 @@ class HarvesterHandler extends RoleHandler {
                 continue; // No empty spots available, skip to next source
             }
 
-            setSpotStatus(
-                sourceState.spots,
-                emptySpot,
-                SourceSpotStatus.OCCUPIED
-            );
+            setSpotStatus(sourceState.spots, emptySpot, PositionSpotStatus.OCCUPIED);
             creep.memory.destination = {
                 id: source.id,
                 type: "source",
                 sourceSpot: emptySpot
             };
-            return
+            return;
         }
 
         console.log(`Creep ${creep.name} could not find a valid source.`);
     }
 
-    private static onSourceDestination(creep: Creep, state: GameState) {
+    private static onSourceDestination(creep: Creep, _state: GameState) {
         if (!creep.memory.destination || creep.memory.destination.type !== "source") {
             console.log(`Creep ${creep.name} has no valid destination set.`);
             delete creep.memory.destination;
@@ -110,19 +104,20 @@ class HarvesterHandler extends RoleHandler {
         }
 
         if (creep.harvest(source) === ERR_NOT_IN_RANGE) {
-            const sourceSpotPosition = getPositionWithDelta(
-                source.pos, creep.memory.destination.sourceSpot
-            )
-            creep.moveTo(sourceSpotPosition, { reusePath: 10, visualizePathStyle: { stroke: '#ffffff', lineStyle: 'dashed', strokeWidth: 0.1 } });
+            const sourceSpotPosition = getPositionWithDelta(source.pos, creep.memory.destination.sourceSpot);
+            creep.moveTo(sourceSpotPosition, {
+                reusePath: 10,
+                visualizePathStyle: { stroke: "#ffffff", lineStyle: "dashed", strokeWidth: 0.1 }
+            });
         }
     }
 
-    private static onSpawnDestination(creep: Creep, state: GameState) {
+    private static onSpawnDestination(creep: Creep, _state: GameState) {
         if (creep.memory.destination === undefined) {
             creep.memory.destination = {
                 id: creep.memory.spawnId,
                 type: "spawn"
-            }
+            };
         }
 
         const spawn = getSpawnById(creep.memory.destination.id);
@@ -132,12 +127,13 @@ class HarvesterHandler extends RoleHandler {
         }
 
         if (creep.transfer(spawn, RESOURCE_ENERGY) === ERR_NOT_IN_RANGE) {
-            creep.moveTo(spawn, { reusePath: 10, visualizePathStyle: { stroke: '#ffffff', lineStyle: 'dashed', strokeWidth: 0.1 } });
+            creep.moveTo(spawn, {
+                reusePath: 10,
+                visualizePathStyle: { stroke: "#ffffff", lineStyle: "dashed", strokeWidth: 0.1 }
+            });
         }
     }
 
-
-
     private static findClosestSource(creep: Creep, state: GameState): Source[] {
         const sources = Object.keys(state.sourcesStates)
             .map(sourceId => getSourceById(sourceId))
@@ -158,16 +154,8 @@ class HarvesterHandler extends RoleHandler {
             return;
         }
 
-        setSpotStatus(
-            sourceState.spots,
-            destination.sourceSpot,
-            SourceSpotStatus.EMPTY
-        );
+        setSpotStatus(sourceState.spots, destination.sourceSpot, PositionSpotStatus.EMPTY);
     }
 }
 
-
-
-
-
 export default HarvesterHandler;

src/roleHandlers/index.ts

@@ -1,9 +1,6 @@
-import { RoleHandler } from "./base.handler.interface";
+import { RoleHandler } from "./BaseHandler.interface";
 
 import HarvesterHandler from "./harvester.handler";
 import UpgraderHandler from "./upgrader.handler";
 
-
-
-
 export { RoleHandler, HarvesterHandler, UpgraderHandler };

src/roleHandlers/upgrader.handler.ts

@@ -1,8 +1,7 @@
-import { getControllerById, getSourceById } from "utils/funcs/get_by_id";
-import { RoleHandler } from "./base.handler.interface";
-import { getNextEmptySpot, getPositionWithDelta, setSpotStatus, SourceSpotStatus } from "types/source";
-
-
+import { getControllerById, getSourceById } from "utils/funcs/getById";
+import { RoleHandler } from "./BaseHandler.interface";
+import { getNextEmptySpot, PositionSpotStatus, setSpotStatus, getPositionWithDelta } from "utils/positions";
+import { SourceDestination } from "types/creeps";
 
 class UpgraderHandler extends RoleHandler {
     public static destroy(creepMemory: CreepMemory, state: GameState): void {
@@ -39,7 +38,7 @@ class UpgraderHandler extends RoleHandler {
             setSpotStatus(
                 state.sourcesStates[creep.memory.previousDestination.id].spots,
                 creep.memory.previousDestination.sourceSpot,
-                SourceSpotStatus.EMPTY
+                PositionSpotStatus.EMPTY
             );
             delete creep.memory.previousDestination;
         }
@@ -86,23 +85,19 @@ class UpgraderHandler extends RoleHandler {
                 continue; // No empty spots available, skip to next source
             }
 
-            setSpotStatus(
-                sourceState.spots,
-                emptySpot,
-                SourceSpotStatus.OCCUPIED
-            );
+            setSpotStatus(sourceState.spots, emptySpot, PositionSpotStatus.OCCUPIED);
             creep.memory.destination = {
                 id: source.id,
                 type: "source",
                 sourceSpot: emptySpot
             };
-            return
+            return;
         }
 
         console.log(`Creep ${creep.name} could not find a valid source.`);
     }
 
-    private static onSourceDestination(creep: Creep, state: GameState) {
+    private static onSourceDestination(creep: Creep, _state: GameState) {
         if (!creep.memory.destination || creep.memory.destination.type !== "source") {
             console.log(`Creep ${creep.name} has no valid destination set.`);
             delete creep.memory.destination;
@@ -116,14 +111,15 @@ class UpgraderHandler extends RoleHandler {
         }
 
         if (creep.harvest(source) === ERR_NOT_IN_RANGE) {
-            const sourceSpotPosition = getPositionWithDelta(
-                source.pos, creep.memory.destination.sourceSpot
-            )
-            creep.moveTo(sourceSpotPosition, { reusePath: 10, visualizePathStyle: { stroke: '#ffffff', lineStyle: 'dashed', strokeWidth: 0.1 } });
+            const sourceSpotPosition = getPositionWithDelta(source.pos, creep.memory.destination.sourceSpot);
+            creep.moveTo(sourceSpotPosition, {
+                reusePath: 10,
+                visualizePathStyle: { stroke: "#ffffff", lineStyle: "dashed", strokeWidth: 0.1 }
+            });
         }
     }
 
-    private static onControllerDestination(creep: Creep, state: GameState) {
+    private static onControllerDestination(creep: Creep, _state: GameState) {
         if (creep.memory.destination === undefined) {
             if (!creep.room.controller) {
                 console.log(`Creep ${creep.name} has no valid controller to upgrade.`);
@@ -133,7 +129,7 @@ class UpgraderHandler extends RoleHandler {
             creep.memory.destination = {
                 id: creep.room.controller.id,
                 type: "controller"
-            }
+            };
         }
 
         const controller = getControllerById(creep.memory.destination.id);
@@ -143,12 +139,13 @@ class UpgraderHandler extends RoleHandler {
         }
 
         if (creep.upgradeController(controller) === ERR_NOT_IN_RANGE) {
-            creep.moveTo(controller, { reusePath: 10, visualizePathStyle: { stroke: '#ffffff', lineStyle: 'dashed', strokeWidth: 0.1 } });
+            creep.moveTo(controller, {
+                reusePath: 10,
+                visualizePathStyle: { stroke: "#ffffff", lineStyle: "dashed", strokeWidth: 0.1 }
+            });
         }
     }
 
-
-
     private static findClosestSource(creep: Creep, state: GameState): Source[] {
         const sources = Object.keys(state.sourcesStates)
             .map(sourceId => getSourceById(sourceId))
@@ -169,16 +166,8 @@ class UpgraderHandler extends RoleHandler {
             return;
         }
 
-        setSpotStatus(
-            sourceState.spots,
-            destination.sourceSpot,
-            SourceSpotStatus.EMPTY
-        );
+        setSpotStatus(sourceState.spots, destination.sourceSpot, PositionSpotStatus.EMPTY);
     }
 }
 
-
-
-
-
 export default UpgraderHandler;

src/spawnHandler.ts

@@ -1,154 +0,0 @@
-import { CreepRequisition, CreepRole, CreepRoles, RoleDefinition } from "types/creeps";
-import { DEFAULT_GAME_CONFIG } from "types/gameConfig";
-import { createSourcePositionMatrix, forEachMatrixSpot, getPositionWithDelta, setSpotStatus, SourceSpotStatus } from "types/source";
-import { checkPositionWalkable } from "utils/funcs/check_position";
-import { get_role_const as get_role_cost } from "utils/funcs/get_role_const";
-
-class SpawnHandler {
-    constructor(private spawn: StructureSpawn) {}
-
-    public get spawnName(): string {
-        return this.spawn.name;
-    }
-
-    public run(state: GameState): GameState {
-        this.updateSpawnState(state);
-
-        for(const name in Memory.creeps) {
-            if (!Game.creeps[name]) {
-                console.log(`Creep ${name} is dead, cleaning up memory.`);
-
-                const roleDefinition = CreepRoles[Memory.creeps[name].role as CreepRole];
-                roleDefinition.handler.destroy(Memory.creeps[name], state);
-                delete Memory.creeps[name]; // Clean up memory for dead creeps
-
-                continue; // Skip to the next creep
-            }
-            const creep = Game.creeps[name];
-
-            const roleDefinition = CreepRoles[creep.memory.role as CreepRole];
-            if (!roleDefinition) {
-                console.log(`Creep ${creep.name} has an unknown role: ${creep.memory.role}`);
-                continue;
-            }
-
-            state = roleDefinition.handler.run(creep, state);
-        }
-
-        this.validateSpawnState();
-
-        return state;
-    }
-
-    private updateSpawnState(state: GameState) {
-        const sources = this.spawn.room.find(FIND_SOURCES);
-        if (!state.sourcesStates) {
-            state.sourcesStates = {};
-            state.maxHarvesters = 0
-        }
-        for (const source of sources) {
-            const sourceId = source.id.toString();
-
-            if (!state.sourcesStates[sourceId]) {
-                state.sourcesStates[sourceId] = {
-                    "id": sourceId,
-                    "pos": source.pos,
-                    "spots": createSourcePositionMatrix(),
-                };
-                forEachMatrixSpot(state.sourcesStates[sourceId].spots, (delta, status) => {
-                    if (status !== SourceSpotStatus.UNKNOWN) {
-                        return; // Skip known spots
-                    }
-                    const pos = getPositionWithDelta(source.pos, delta);
-                    if (checkPositionWalkable(pos)) {
-                        setSpotStatus(state.sourcesStates[sourceId].spots, delta, SourceSpotStatus.EMPTY);
-                        state.maxHarvesters = state.maxHarvesters + 1;
-                    } else {
-                        setSpotStatus(state.sourcesStates[sourceId].spots, delta, SourceSpotStatus.INVALID);
-                    }
-                })
-            }
-        }
-    }
-
-    private validateSpawnState() {
-        if (this.spawn.spawning) {
-            // console.log(`Spawn ${this.spawn.name} is currently spawning a creep.`);
-            return;
-        }
-
-        const creepRequisition = this.checksNeedsCreeps();
-        if (Object.values(creepRequisition).every(count => count <= 0)) {
-            // console.log(`Spawn ${this.spawn.name} has no creep needs.`);
-            return;
-        }
-
-        const totalCreeps = Object.values(Game.creeps).length;
-        if (totalCreeps >= DEFAULT_GAME_CONFIG.maxCreeps) {
-            // console.log(`Spawn ${this.spawn.name} cannot spawn more creeps, limit reached.`);
-            return;
-        }
-
-        const rolesToSpawn = this.sortCreepRolesByPriority(creepRequisition);
-
-        for (const role of rolesToSpawn) {
-            if (this.spawn.store[RESOURCE_ENERGY] < get_role_cost(role)) {
-                // console.log(`Spawn ${this.spawn.name} does not have enough energy to spawn a ${role.name}.`);
-                continue;
-            }
-
-            const newName = `${role.name}_${Game.time}`;
-            const spawnResult = this.spawn.spawnCreep(role.body, newName, {
-                memory: {
-                    role: role.name,
-                    room: this.spawn.room.name,
-                    spawnId: this.spawn.id,
-                    working: false
-                }
-            });
-            if (spawnResult === OK) {
-                console.log(`Spawn ${this.spawn.name} successfully spawned a new ${role.name}: ${newName}.`);
-                return; // Exit after spawning one creep
-            } else {
-                console.error(`Spawn ${this.spawn.name} failed to spawn a new ${role.name}: ${spawnResult}`);
-            }
-        }
-    }
-
-    private checksNeedsCreeps(): CreepRequisition {
-        const creepCounts: Record<string, number> = {};
-        for (const creep of Object.values(Game.creeps)) {
-            const role = creep.memory.role;
-            creepCounts[role] = (creepCounts[role] || 0) + 1;
-        }
-
-        const requisition: CreepRequisition = {
-            harvester: 0,
-            upgrader: 0,
-            builder: 0
-        };
-        for (const role in DEFAULT_GAME_CONFIG.minCreepsPerRole) {
-            if (!(role in CreepRoles)) {
-                console.log(`Unknown creep role: ${role}`);
-                continue;
-            }
-            const roleType = role as CreepRole;
-            requisition[roleType] = DEFAULT_GAME_CONFIG.minCreepsPerRole[roleType] - (creepCounts[role] || 0);
-
-            if (requisition[roleType] < 0) {
-                requisition[roleType] = 0; // Ensure we don't have negative requisitions
-            }
-        }
-
-        return requisition;
-    }
-
-    private sortCreepRolesByPriority(requisition: CreepRequisition): RoleDefinition[] {
-        return Object.keys(requisition)
-            .filter(role => requisition[role as CreepRole] > 0)
-            .map(role => CreepRoles[role as CreepRole])
-            .sort((a, b) => a.priority - b.priority);
-    }
-}
-
-export default SpawnHandler;

src/types/creeps.ts

@@ -1,5 +1,5 @@
 import { HarvesterHandler, RoleHandler, UpgraderHandler } from "roleHandlers";
-import { PositionDelta } from "./source";
+import { PositionDelta } from "utils/positions";
 
 export type RoleDefinition = {
     name: string;
@@ -33,35 +33,29 @@ export type CreepRole = keyof typeof CreepRoles;
 
 export type CreepRequisition = Record<CreepRole, number>;
 
-
-
-
 export type SpawnDestination = {
     id: string; // ID of the spawn
     type: "spawn";
-}
+};
 
 export type SourceDestination = {
     id: string; // ID of the source
     type: "source";
     sourceSpot: PositionDelta; // Position delta for the source spot
-}
+};
 
 export type ControllerDestination = {
     id: string; // ID of the controller
     type: "controller";
-}
+};
 
 export type ConstructionSiteDestination = {
     id: string; // ID of the construction site
     type: "constructionSite";
-}
-
-
-export type CreepDestination = (
-    SpawnDestination |
-    SourceDestination |
-    ControllerDestination |
-    ConstructionSiteDestination
-);
+};
 
+export type CreepDestination =
+    | SpawnDestination
+    | SourceDestination
+    | ControllerDestination
+    | ConstructionSiteDestination;

src/types/gameConfig.ts

@@ -5,9 +5,6 @@ import { CreepRequisition } from "./creeps";
  * Used to manage the overall game state and ensure proper role distribution.
  */
 export type GameConfig = {
-    /** The maximum number of creeps allowed in the game. */
-    maxCreeps: number;
-
     /**
      * The minimum number of creeps required for each role.
      * Creeps will be spawned to meet these minimums before allocating new roles.
@@ -22,7 +19,6 @@ export type GameConfig = {
  * @type {GameConfig}
  */
 export const DEFAULT_GAME_CONFIG: GameConfig = {
-    maxCreeps: 10,
     minCreepsPerRole: {
         harvester: 3,
         upgrader: 7,

src/types/source.ts

@@ -1,81 +0,0 @@
-export const SourceSpotStatus = {
-    INVALID: "-2",
-    CENTER: "-1",
-    UNKNOWN: "0",
-    EMPTY: "1",
-    OCCUPIED: "2",
-} as const;
-
-
-export type SourceSpotStatus = (typeof SourceSpotStatus)[keyof typeof SourceSpotStatus];
-
-
-export type PositionDeltaValue = -1 | 0 | 1;
-
-export type PositionDelta = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
-
-export type SourcePositionMatrix = {
-    locked: boolean;
-    data: [
-        SourceSpotStatus, SourceSpotStatus, SourceSpotStatus,
-        SourceSpotStatus, SourceSpotStatus, SourceSpotStatus,
-        SourceSpotStatus, SourceSpotStatus, SourceSpotStatus
-    ];
-}
-
-
-type MatrixPoint = {
-    x: PositionDeltaValue;
-    y: PositionDeltaValue;
-}
-
-
-const indexToMatrixPoint = (index: number): MatrixPoint => {
-    // where the 0,0 point is the center of the matrix and -1, -1 is the top-left corner
-    const x = ((index % 3) - 1) as PositionDeltaValue; // Convert index to x coordinate (-1, 0, 1)
-    const y = (Math.floor(index / 3) - 1) as PositionDeltaValue; // Convert index to y coordinate (-1, 0, 1)
-    return { x, y };
-}
-
-export const createSourcePositionMatrix = () : SourcePositionMatrix => {
-    return {
-        locked: false,
-        data: [
-            SourceSpotStatus.UNKNOWN, SourceSpotStatus.UNKNOWN, SourceSpotStatus.UNKNOWN,
-            SourceSpotStatus.UNKNOWN, SourceSpotStatus.CENTER, SourceSpotStatus.UNKNOWN,
-            SourceSpotStatus.UNKNOWN, SourceSpotStatus.UNKNOWN, SourceSpotStatus.UNKNOWN
-        ]
-    };
-}
-
-
-export const getNextEmptySpot = (matrix: SourcePositionMatrix): PositionDelta | null => {
-    const index = matrix.data.findIndex( status => status === SourceSpotStatus.EMPTY);
-
-    if (index === -1) {
-        return null; // No empty spot found
-    }
-
-    return index as PositionDelta; // Convert index to PositionDelta
-};
-
-
-export const setSpotStatus = (matrix: SourcePositionMatrix, delta: PositionDelta, status: SourceSpotStatus): void => {
-    matrix.data[delta as number] = status;
-}
-
-
-export const getPositionWithDelta = (pos: RoomPosition, delta: PositionDelta): RoomPosition => {
-    const matrixPoint = indexToMatrixPoint(delta as number);
-    return new RoomPosition(
-        pos.x + matrixPoint.x,
-        pos.y + matrixPoint.y,
-        pos.roomName
-    );
-}
-
-export const forEachMatrixSpot = (matrix: SourcePositionMatrix, callback: (delta: PositionDelta, status: SourceSpotStatus) => void): void => {
-    for (const index in matrix.data) {
-        callback(index as PositionDelta, matrix.data[index]);
-    }
-};

src/utils/funcs/checkPosition.ts

@@ -1,5 +1,5 @@
 export const checkPositionWalkable = (pos: RoomPosition) => {
     // Check if the position is not obstructed by a wall
     const terrain = pos.lookFor(LOOK_TERRAIN);
-    return terrain.length === 0 || terrain[0] !== 'wall'
-}
+    return terrain.length === 0 || terrain[0] !== "wall";
+};

src/utils/funcs/getById.ts

@@ -11,8 +11,7 @@ export const getSourceById = (sourceId: string): Source | null => {
     }
 
     return source;
-}
-
+};
 
 export const getSpawnById = (spawnId: string): StructureSpawn | null => {
     if (!spawnId) {
@@ -27,8 +26,7 @@ export const getSpawnById = (spawnId: string): StructureSpawn | null => {
     }
 
     return spawn;
-}
-
+};
 
 export const getControllerById = (controllerId: string): StructureController | null => {
     if (!controllerId) {
@@ -43,4 +41,4 @@ export const getControllerById = (controllerId: string): StructureController | n
     }
 
     return controller;
-}
+};

src/utils/funcs/getRoleCost.ts

@@ -1,6 +1,6 @@
 import { RoleDefinition } from "types/creeps";
 
-export const get_role_const = (role: RoleDefinition) => {
+export const get_role_cost = (role: RoleDefinition) => {
     return role.body.reduce((cost, part) => {
         cost += BODYPART_COST[part] || 0;
         return cost;

src/utils/funcs/getRoomCreeps.ts

@@ -0,0 +1,8 @@
+export const getRoomCreeps = (room: Room): Record<string, CreepMemory> => {
+    return Object.keys(Memory.creeps)
+        .filter(name => Memory.creeps[name].room === room.name)
+        .reduce((creeps: Record<string, CreepMemory>, creepName: string) => {
+            creeps[creepName] = Memory.creeps[creepName];
+            return creeps;
+        }, {});
+};

src/utils/funcs/sortCreepRolesByPriority.ts

@@ -0,0 +1,8 @@
+import { CreepRequisition, CreepRole, CreepRoles, RoleDefinition } from "types/creeps";
+
+export const sortCreepRolesByPriority = (requisition: CreepRequisition): RoleDefinition[] => {
+    return Object.keys(requisition)
+        .filter(role => requisition[role as CreepRole] > 0)
+        .map(role => CreepRoles[role as CreepRole])
+        .sort((a, b) => a.priority - b.priority);
+};

src/utils/positions/index.ts

@@ -0,0 +1,21 @@
+import { PositionSpotStatus, PositionDeltaValue, PositionMatrix, PositionDelta } from "./position.types";
+
+import {
+    createSourcePositionMatrix,
+    forEachMatrixSpot,
+    getNextEmptySpot,
+    setSpotStatus,
+    getPositionWithDelta
+} from "./position.funcs";
+
+export {
+    PositionSpotStatus,
+    PositionDeltaValue,
+    PositionMatrix,
+    PositionDelta,
+    createSourcePositionMatrix,
+    forEachMatrixSpot,
+    getNextEmptySpot,
+    setSpotStatus,
+    getPositionWithDelta
+};

src/utils/positions/position.funcs.ts

@@ -0,0 +1,88 @@
+import { PositionDelta, PositionDeltaValue, PositionMatrix, PositionSpotStatus } from "./position.types";
+
+/**
+ * Represents a point in the matrix with x and y coordinates.
+ */
+type MatrixPoint = {
+    x: PositionDeltaValue;
+    y: PositionDeltaValue;
+};
+
+/**
+ * Converts a matrix index to a matrix point.
+ */
+const indexToMatrixPoint = (index: number): MatrixPoint => {
+    // where the 0,0 point is the center of the matrix and -1, -1 is the top-left corner
+    const x = ((index % 3) - 1) as PositionDeltaValue; // Convert index to x coordinate (-1, 0, 1)
+    const y = (Math.floor(index / 3) - 1) as PositionDeltaValue; // Convert index to y coordinate (-1, 0, 1)
+    return { x, y };
+};
+
+/**
+ * Creates a source position matrix with a default value.
+ * The center of the matrix is always `PositionSpotStatus.CENTER`.
+ * The default value is used for all other spots.
+ */
+export const createSourcePositionMatrix = (default_value?: PositionSpotStatus): PositionMatrix => {
+    const center_value = PositionSpotStatus.CENTER;
+
+    default_value = default_value || PositionSpotStatus.UNKNOWN;
+
+    return [
+        default_value,
+        default_value,
+        default_value,
+        default_value,
+        center_value,
+        default_value,
+        default_value,
+        default_value,
+        default_value
+    ];
+};
+
+/**
+ * Gets the next empty spot in the matrix.
+ */
+export const getNextEmptySpot = (matrix: PositionMatrix): PositionDelta | null => {
+    const index = matrix.findIndex(status => status === PositionSpotStatus.EMPTY);
+
+    if (index === -1) {
+        return null; // No empty spot found
+    }
+
+    return index as PositionDelta; // Convert index to PositionDelta
+};
+
+/**
+ * Sets the status of a spot in the matrix.
+ * Throws an error if the delta is out of bounds.
+ */
+export const setSpotStatus = (matrix: PositionMatrix, delta: PositionDelta, status: PositionSpotStatus): void => {
+    if (delta < 0 || delta >= matrix.length) {
+        throw new Error(`Invalid delta: ${delta}. Must be between 0 and ${matrix.length - 1}.`);
+    }
+    matrix[delta] = status;
+};
+
+/**
+ * Gets the position with a delta applied to the given RoomPosition.
+ */
+export const getPositionWithDelta = (pos: RoomPosition, delta: PositionDelta): RoomPosition => {
+    const matrixPoint = indexToMatrixPoint(delta as number);
+    return new RoomPosition(pos.x + matrixPoint.x, pos.y + matrixPoint.y, pos.roomName);
+};
+
+/**
+ * Iterates over each spot in the matrix and applies the callback function.
+ * The callback receives the delta (index) and the status of the spot.
+ */
+export const forEachMatrixSpot = (
+    matrix: PositionMatrix,
+    callback: (delta: PositionDelta, status: PositionSpotStatus) => void
+): void => {
+    for (const index in matrix) {
+        const positionIndex = Number(index);
+        callback(positionIndex as PositionDelta, matrix[positionIndex]);
+    }
+};

src/utils/positions/position.types.ts

@@ -0,0 +1,37 @@
+/**
+ * Represents the status of a position spot
+ */
+export const PositionSpotStatus = {
+    INVALID: "-2",
+    CENTER: "-1",
+    UNKNOWN: "0",
+    EMPTY: "1",
+    OCCUPIED: "2"
+} as const;
+
+export type PositionSpotStatus = (typeof PositionSpotStatus)[keyof typeof PositionSpotStatus];
+
+/**
+ * Represents dislocation to be applied a axis to a position relative to a source or a point of interest.
+ */
+export type PositionDeltaValue = -1 | 0 | 1;
+
+/**
+ * Represents a matrix of positions around a source or a point of interest.
+ * The matrix is a 3x3 grid where the center is the point of interest.
+ * The center should always be `PositionSpotStatus.CENTER`.
+ */
+export type PositionMatrix = [
+    PositionSpotStatus,
+    PositionSpotStatus,
+    PositionSpotStatus,
+    PositionSpotStatus,
+    PositionSpotStatus,
+    PositionSpotStatus,
+    PositionSpotStatus,
+    PositionSpotStatus,
+    PositionSpotStatus
+];
+
+// Valid indices for the 3x3 matrix (0-8)
+export type PositionDelta = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;

tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     "target": "ES6",
-    "lib": ["ES2015", "DOM"],
+    "lib": ["ES2017", "DOM"],
     "module": "commonjs",
     "moduleResolution": "node",
     "outDir": "dist",
@@ -18,6 +18,6 @@
     "allowSyntheticDefaultImports": true,
     "types": ["screeps"]
   },
-  "include": ["src/**/*"],
+  "include": ["src/**/*", "src/RequisitionsManager.ts"],
   "exclude": ["node_modules", "dist"]
 }