feat: fixes project dependecies and publish script

.env

@@ -0,0 +1,2 @@
+SCREEPS_TOKEN=750fa279-9243-42f4-892f-614103d51394
+SCREEPS_BRANCH=default

.gitignore

@@ -5,3 +5,8 @@
 # Screeps Config
 .screeps.yml
 docker/.env
+
+.env*
+
+.idea/
+.vscode/

.prettierrc

@@ -1,9 +1,9 @@
 {
-  "semi": true,
+    "semi": true,
-  "tabWidth": 4,
+    "tabWidth": 4,
-  "printWidth": 120,
+    "printWidth": 120,
-  "singleQuote": false,
+    "singleQuote": false,
-  "trailingComma": "none",
+    "trailingComma": "none",
-  "arrowParens": "avoid",
+    "arrowParens": "avoid",
-  "endOfLine": "auto"
+    "endOfLine": "auto"
 }

.screeps.example.yml

@@ -1,16 +1,15 @@
 servers:
-  main:
+    main:
-    host: screeps.com
+        host: screeps.com
-    secure: true
+        secure: true
-    token: {TOKEN}
+        token: { TOKEN }
-  ptr:
+    ptr:
-    host: screeps.com
+        host: screeps.com
-    secure: true
+        secure: true
-    token: {TOKEN}
+        token: { TOKEN }
-    ptr: true
+        ptr: true
-
 
 configs:
-  screepsconsole:
+    screepsconsole:
-    maxHistory: 20000
+        maxHistory: 20000
-    maxScroll: 20000
+        maxScroll: 20000

.vscode/extensions.json

@@ -1,5 +1,3 @@
 {
-    "recommendations": [
+    "recommendations": ["ms-vscode-remote.vscode-remote-extensionpack"]
-        "ms-vscode-remote.vscode-remote-extensionpack"
-    ]
 }

docker/config.yml

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

docker/docker-compose.yml

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

esbuild.config.mjs

@@ -1,18 +1,18 @@
 import { build } from 'esbuild';
 
 build({
-  entryPoints: ['src/main.ts'],
+    entryPoints: ['src/main.ts'],
-  bundle: true,
+    bundle: true,
-  target: 'es6', // Screeps supports ES2018 well
+    target: 'es2018', // Screeps supports ES2018 well
-  platform: 'node',
+    platform: 'node',
-  tsconfig: 'tsconfig.json',
+    tsconfig: 'tsconfig.json',
-  format: 'cjs',
+    format: 'cjs',
-  outdir: 'dist',
+    outdir: 'dist',
-  sourcemap: true,
+    sourcemap: true,
-  logLevel: 'info',
+    logLevel: 'info',
-  minify: false,
+    minify: false,
-  keepNames: true, // optional: keeps function/class names
+    keepNames: true, // optional: keeps function/class names
-  banner: {
+    banner: {
-    js: `// Vitor Hideyoshi <vitor.h.n.batista@gmail.com> - ${new Date().toISOString()}\n`
+        js: `// Vitor Hideyoshi <vitor.h.n.batista@gmail.com> - ${new Date().toISOString()}\n`,
-  },
+    },
 }).catch(() => process.exit(1));

eslint.config.js

@@ -1,61 +1,64 @@
-const {
+const { defineConfig } = require('eslint/config');
-    defineConfig,
-} = require("eslint/config");
 
-const globals = require("globals");
+const globals = require('globals');
-const tsParser = require("@typescript-eslint/parser");
+const tsParser = require('@typescript-eslint/parser');
-const typescriptEslint = require("@typescript-eslint/eslint-plugin");
+const typescriptEslint = require('@typescript-eslint/eslint-plugin');
-const js = require("@eslint/js");
+const js = require('@eslint/js');
 
-const {
+const { FlatCompat } = require('@eslint/eslintrc');
-    FlatCompat,
-} = require("@eslint/eslintrc");
 
 const compat = new FlatCompat({
     baseDirectory: __dirname,
     recommendedConfig: js.configs.recommended,
-    allConfig: js.configs.all
+    allConfig: js.configs.all,
 });
 
-module.exports = defineConfig([{
+module.exports = defineConfig([
-    languageOptions: {
+    {
-        globals: {
+        languageOptions: {
-            ...globals.browser,
+            globals: {
+                ...globals.browser,
+            },
+
+            parser: tsParser,
+            ecmaVersion: 'latest',
+            sourceType: 'module',
+            parserOptions: {},
         },
 
-        parser: tsParser,
+        extends: compat.extends(
-        "ecmaVersion": "latest",
+            'eslint:recommended',
-        "sourceType": "module",
+            'plugin:@typescript-eslint/recommended',
-        parserOptions: {},
+            'prettier'
-    },
+        ),
 
-    extends: compat.extends("eslint:recommended", "plugin:@typescript-eslint/recommended", "prettier"),
+        plugins: {
-
+            '@typescript-eslint': typescriptEslint,
-    plugins: {
-        "@typescript-eslint": typescriptEslint,
-    },
-
-    "rules": {
-        "@typescript-eslint/no-namespace": "off",
-        "@typescript-eslint/no-explicit-any": "off",
-        "@typescript-eslint/no-unused-vars": [
-            "error",
-            {
-                "argsIgnorePattern": "^_",
-                "varsIgnorePattern": "^_",
-                "caughtErrorsIgnorePattern": "^_"
-            }
-        ],
-    },
-}, {
-    languageOptions: {
-        globals: {
-            ...globals.node,
         },
 
-        "sourceType": "script",
+        rules: {
-        parserOptions: {},
+            '@typescript-eslint/no-namespace': 'off',
+            '@typescript-eslint/no-explicit-any': 'off',
+            '@typescript-eslint/no-unused-vars': [
+                'error',
+                {
+                    argsIgnorePattern: '^_',
+                    varsIgnorePattern: '^_',
+                    caughtErrorsIgnorePattern: '^_',
+                },
+            ],
+        },
     },
+    {
+        languageOptions: {
+            globals: {
+                ...globals.node,
+            },
 
-    files: ["**/.eslintrc.{js,cjs}"],
+            sourceType: 'script',
-}]);
+            parserOptions: {},
+        },
+
+        files: ['**/.eslintrc.{js,cjs}'],
+    },
+]);

package.json

@@ -1,59 +1,40 @@
 {
-  "name": "screeps-typescript-starter",
+    "name": "hideyoshi-screeps",
-  "version": "3.0.0",
+    "version": "0.0.0",
-  "description": "",
+    "description": "Personal Screeps codebase for Hideyoshi",
-  "scripts": {
+    "scripts": {
-    "build": "node esbuild.config.mjs",
+        "build": "node esbuild.config.mjs",
-    "push:main": "npm run build && screeps-api --server main upload dist/*.js",
+        "push": "npm run build && ts-node publish.ts",
-    "push:sim": "npm run build && screeps-api --server main upload  --branch sim dist/*.js",
+        "format": "prettier --check --ignore-path .gitignore .",
-    "push:local": "npm run build && screeps-api --server local upload dist/*.js",
+        "format:fix": "prettier --write --ignore-path .gitignore ."
-    "format": "prettier --config .prettierrc 'src/**/*.ts' --write && eslint --fix src/"
+    },
-  },
+    "dependencies": {
-  "repository": {
+        "@trivago/prettier-plugin-sort-imports": "^6.0.2",
-    "type": "git",
+        "@types/screeps": "^3.3.8",
-    "url": "git+https://github.com/screepers/screeps-typescript-starter.git"
+        "dotenv": "^17.4.2",
-  },
+        "esbuild": "^0.28.0",
-  "author": "",
+        "prettier": "^3.8.3",
-  "license": "Unlicense",
+        "ts-node": "^10.9.2",
-  "bugs": {
+        "typescript": "^6.0.3",
-    "url": "https://github.com/screepers/screeps-typescript-starter/issues"
+        "zod": "^4.3.6"
-  },
+    },
-  "homepage": "https://github.com/screepers/screeps-typescript-starter#readme",
+    "devDependencies": {
-  "devDependencies": {
+        "@types/node": "^25.6.0"
-    "@eslint/eslintrc": "^3.3.1",
+    },
-    "@eslint/js": "^9.30.1",
+    "prettier": {
-    "@rollup/plugin-commonjs": "^28.0.6",
+        "trailingComma": "es5",
-    "@rollup/plugin-node-resolve": "^16.0.1",
+        "semi": true,
-    "@types/chai": "^5.2.2",
+        "tabWidth": 4,
-    "@types/lodash": "4.17.20",
+        "useTabs": false,
-    "@types/mocha": "^10.0.10",
+        "singleQuote": true,
-    "@types/node": "^24.0.10",
+        "jsxSingleQuote": true,
-    "@types/screeps": "^3.3.8",
+        "plugins": [
-    "@types/sinon": "^17.0.4",
+            "@trivago/prettier-plugin-sort-imports"
-    "@types/sinon-chai": "^4.0.0",
+        ],
-    "@typescript-eslint/eslint-plugin": "^8.35.1",
+        "importOrderParserPlugins": [
-    "@typescript-eslint/parser": "^8.35.1",
+            "typescript",
-    "@typescript-eslint/typescript-estree": "^8.35.1",
+            "jsx",
-    "chai": "^5.2.0",
+            "decorators-legacy"
-    "esbuild": "^0.25.5",
+        ]
-    "eslint": "^9.30.1",
+    }
-    "eslint-config-prettier": "^10.1.5",
-    "eslint-import-resolver-typescript": "^4.4.4",
-    "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-prettier": "^5.5.1",
-    "globals": "^16.3.0",
-    "lodash": "^4.17.21",
-    "mocha": "^11.7.1",
-    "prettier": "^3.6.2",
-    "screeps-api": "^1.7.2",
-    "shelljs": "^0.10.0",
-    "sinon": "^21.0.0",
-    "sinon-chai": "^4.0.0",
-    "ts-node": "^10.9.2",
-    "tsconfig-paths": "^4.2.0",
-    "typescript": "^5.8.3"
-  },
-  "dependencies": {
-    "source-map": "~0.7.4"
-  }
 }

publish.ts

@@ -0,0 +1,99 @@
+import * as dotenv from 'dotenv';
+import * as fs from 'node:fs';
+import { z } from 'zod';
+
+import path = require('node:path');
+
+const EnvVariables = z.object({
+    DIST_PATH: z.string().default('./dist'),
+    SCREEPS_SERVER: z.url().default('https://screeps.com'),
+    SCREEPS_TOKEN: z.string(),
+    SCREEPS_BRANCH: z.string().default('default'),
+});
+type EnvVariables = z.infer<typeof EnvVariables>;
+
+const readEnv = (): EnvVariables => {
+    return EnvVariables.parse(process.env);
+};
+
+type ScriptPayload = {
+    branch: string;
+    modules: Record<string, string>;
+};
+
+type ScreepsHeaders = {
+    'X-Token': string;
+} & object;
+
+const publishScript = async (
+    screeps_server: string,
+    payload: ScriptPayload,
+    headers: ScreepsHeaders
+) => {
+    const resp = await fetch(screeps_server + '/api/user/code', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...headers,
+        },
+        body: JSON.stringify(payload),
+    });
+    if (!resp.ok) {
+        const text = await resp.text();
+        throw new Error(`Upload failed: ${resp.status} ${text}`);
+    }
+};
+
+const genModuleKey = (filePath: string): string => {
+    filePath = filePath.split(path.sep).slice(1).join(path.sep);
+    return filePath.split('.')[0].split(path.sep).join('.');
+};
+
+const parseDist = (dist_path: string): Record<string, string> => {
+    let modules: Record<string, string> = {};
+
+    const files = fs.readdirSync(dist_path, { withFileTypes: true });
+    for (const file of files) {
+        if (file.isDirectory()) {
+            const subModules = parseDist(path.join(dist_path, file.name));
+            modules = {
+                ...modules,
+                ...subModules,
+            };
+            continue;
+        }
+
+        if (!file.name.endsWith('.js')) {
+            continue;
+        }
+
+        const filePath = path.join(dist_path, file.name);
+        const module_key = genModuleKey(filePath);
+        modules[module_key] = fs.readFileSync(filePath, 'utf-8');
+    }
+    return modules;
+};
+
+const main = async () => {
+    dotenv.config();
+
+    const env = readEnv();
+
+    const payload: ScriptPayload = {
+        branch: env.SCREEPS_BRANCH,
+        modules: parseDist(env.DIST_PATH),
+    };
+    const headers: ScreepsHeaders = {
+        'X-Token': env.SCREEPS_TOKEN,
+    };
+
+    await publishScript(env.SCREEPS_SERVER, payload, headers);
+};
+
+main()
+    .then(() => {
+        console.log('Script published successfully!');
+    })
+    .catch((error) => {
+        console.error(error);
+    });

src/CreepRunner.ts

@@ -1,5 +1,5 @@
-import { CreepRole, CreepRoles } from "types/creeps";
+import { CreepRole, CreepRoles } from 'types/creeps';
-import { getRoomCreeps } from "utils/funcs/getRoomCreeps";
+import { getRoomCreeps } from 'utils/funcs/getRoomCreeps';
 
 class CreepRunner {
     public static run(room: Room, state: GameState): GameState {
@@ -23,10 +23,14 @@ class CreepRunner {
         return state;
     }
 
-    private static clearDeadCreepMemory(creepName: string, state: GameState): void {
+    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];
+        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

src/RequisitionsManager.ts

@@ -1,14 +1,14 @@
-import { CreepRequisition, CreepRole, CreepRoles } from "types/creeps";
+import { CreepRequisition, CreepRole, CreepRoles } from 'types/creeps';
-import { DEFAULT_GAME_CONFIG } from "types/gameConfig";
+import { DEFAULT_GAME_CONFIG } from 'types/gameConfig';
-import { get_role_cost } from "utils/funcs/getRoleCost";
+import { get_role_cost } from 'utils/funcs/getRoleCost';
-import { getRoomCreeps } from "utils/funcs/getRoomCreeps";
+import { getRoomCreeps } from 'utils/funcs/getRoomCreeps';
-import { sortCreepRolesByPriority } from "utils/funcs/sortCreepRolesByPriority";
+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)) {
+        if (Object.values(creepRequisition).every((count) => count <= 0)) {
             return state;
         }
 
@@ -24,7 +24,10 @@ class RequisitionsManager {
         return state;
     }
 
-    private static fulfillSpawnRequisition(spawn: StructureSpawn, creepRequisition: CreepRequisition): boolean {
+    private static fulfillSpawnRequisition(
+        spawn: StructureSpawn,
+        creepRequisition: CreepRequisition
+    ): boolean {
         if (spawn.spawning) {
             return false;
         }
@@ -42,14 +45,18 @@ class RequisitionsManager {
                     role: role.name,
                     room: spawn.room.name,
                     spawnId: spawn.id,
-                    working: false
+                    working: false,
-                }
+                },
             });
             if (spawnResult === OK) {
-                console.log(`Spawn ${spawn.name} successfully spawned a new ${role.name}: ${newName}.`);
+                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}`);
+                console.error(
+                    `Spawn ${spawn.name} failed to spawn a new ${role.name}: ${spawnResult}`
+                );
             }
         }
 
@@ -66,7 +73,7 @@ class RequisitionsManager {
         const requisition: CreepRequisition = {
             harvester: 0,
             upgrader: 0,
-            builder: 0
+            builder: 0,
         };
         for (const role in DEFAULT_GAME_CONFIG.minCreepsPerRole) {
             if (!(role in CreepRoles)) {
@@ -74,7 +81,9 @@ class RequisitionsManager {
                 continue;
             }
             const roleType = role as CreepRole;
-            requisition[roleType] = DEFAULT_GAME_CONFIG.minCreepsPerRole[roleType] - (creepCounts[role] || 0);
+            requisition[roleType] =
+                DEFAULT_GAME_CONFIG.minCreepsPerRole[roleType] -
+                (creepCounts[role] || 0);
 
             if (requisition[roleType] < 0) {
                 requisition[roleType] = 0; // Ensure we don't have negative requisitions

src/RoomInspector.ts

@@ -1,11 +1,11 @@
-import { checkPositionWalkable } from "utils/funcs/checkPosition";
+import { checkPositionWalkable } from 'utils/funcs/checkPosition';
 import {
     createSourcePositionMatrix,
     forEachMatrixSpot,
     getPositionWithDelta,
     PositionSpotStatus,
-    setSpotStatus
+    setSpotStatus,
-} from "utils/positions";
+} from 'utils/positions';
 
 class RoomInspector {
     public static inspectState(room: Room, state: GameState): GameState {
@@ -30,29 +30,43 @@ class RoomInspector {
         return state;
     }
 
-    private static configureSourceState(source: Source, state: GameState): void {
+    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()
+                spots: createSourcePositionMatrix(),
             };
         }
 
-        forEachMatrixSpot(state.sourcesStates[sourceId].spots, (delta, status) => {
+        forEachMatrixSpot(
-            if (status !== PositionSpotStatus.UNKNOWN) {
+            state.sourcesStates[sourceId].spots,
-                return; // Skip known 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
+                    );
+                }
             }
-            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);
-            }
-        });
     }
 }
 

src/RoomRunner.ts

@@ -1,6 +1,6 @@
-import CreepRunner from "CreepRunner";
+import CreepRunner from 'CreepRunner';
-import RequisitionsManager from "RequisitionsManager";
+import RequisitionsManager from 'RequisitionsManager';
-import RoomInspector from "RoomInspector";
+import RoomInspector from 'RoomInspector';
 
 class RoomRunner {
     public static run(room: Room, state: GameState): GameState {

src/main.ts

@@ -1,6 +1,6 @@
-import { CreepDestination } from "types/creeps";
+import RoomRunner from 'RoomRunner';
-import RoomRunner from "RoomRunner";
+import { CreepDestination } from 'types/creeps';
-import { PositionMatrix } from "utils/positions";
+import { PositionMatrix } from 'utils/positions';
 
 declare global {
     /*
@@ -56,8 +56,11 @@ export const loop = () => {
                 Memory.roomStateRegistry[roomName] || {}
             );
         } catch (error) {
-            console.log(`Error running RoomRunner for room ${roomName}:`, error);
+            console.log(
-            delete Memory.roomStateRegistry[roomName]
+                `Error running RoomRunner for room ${roomName}:`,
+                error
+            );
+            delete Memory.roomStateRegistry[roomName];
         }
     }
 };

src/roleHandlers/harvester.handler.ts

@@ -1,15 +1,20 @@
-import { getSourceById, getSpawnById } from "utils/funcs/getById";
+import { RoleHandler } from './BaseHandler.interface';
-import { RoleHandler } from "./BaseHandler.interface";
+import { SourceDestination } from 'types/creeps';
-import { SourceDestination } from "types/creeps";
+import { getSourceById, getSpawnById } from 'utils/funcs/getById';
-import { getNextEmptySpot, getPositionWithDelta, PositionSpotStatus, setSpotStatus } from "utils/positions";
+import {
+    getNextEmptySpot,
+    getPositionWithDelta,
+    PositionSpotStatus,
+    setSpotStatus,
+} from 'utils/positions';
 
 class HarvesterHandler extends RoleHandler {
     public static destroy(creepMemory: CreepMemory, state: GameState): void {
-        if (creepMemory.destination?.type === "source") {
+        if (creepMemory.destination?.type === 'source') {
             this.releaseSourceSpot(creepMemory.destination, state);
             delete creepMemory.destination; // Clear destination after releasing the spot
         }
-        if (creepMemory.previousDestination?.type === "source") {
+        if (creepMemory.previousDestination?.type === 'source') {
             this.releaseSourceSpot(creepMemory.previousDestination, state);
             delete creepMemory.previousDestination; // Clear previous destination after releasing the spot
         }
@@ -19,10 +24,10 @@ class HarvesterHandler extends RoleHandler {
         this.validateCreepMemory(creep, state);
 
         switch (creep.memory.destination?.type) {
-            case "spawn":
+            case 'spawn':
                 this.onSpawnDestination(creep, state);
                 break;
-            case "source":
+            case 'source':
                 this.onSourceDestination(creep, state);
                 break;
             default:
@@ -34,7 +39,7 @@ class HarvesterHandler extends RoleHandler {
     }
 
     private static validateCreepMemory(creep: Creep, state: GameState) {
-        if (creep.memory.previousDestination?.type === "source") {
+        if (creep.memory.previousDestination?.type === 'source') {
             setSpotStatus(
                 state.sourcesStates[creep.memory.previousDestination.id].spots,
                 creep.memory.previousDestination.sourceSpot,
@@ -47,16 +52,22 @@ class HarvesterHandler extends RoleHandler {
             return; // No destination set, nothing to validate
         }
 
-        if (creep.memory.destination.type === "source" && !creep.store.getFreeCapacity(RESOURCE_ENERGY)) {
+        if (
+            creep.memory.destination.type === 'source' &&
+            !creep.store.getFreeCapacity(RESOURCE_ENERGY)
+        ) {
             creep.memory.previousDestination = creep.memory.destination;
             creep.memory.destination = {
                 id: creep.memory.spawnId,
-                type: "spawn"
+                type: 'spawn',
             };
             return;
         }
 
-        if (creep.memory.destination.type === "spawn" && creep.store.getUsedCapacity(RESOURCE_ENERGY) === 0) {
+        if (
+            creep.memory.destination.type === 'spawn' &&
+            creep.store.getUsedCapacity(RESOURCE_ENERGY) === 0
+        ) {
             delete creep.memory.destination; // Clear destination if no energy is available
             return;
         }
@@ -78,11 +89,15 @@ class HarvesterHandler extends RoleHandler {
                 continue; // No empty spots available, skip to next source
             }
 
-            setSpotStatus(sourceState.spots, emptySpot, PositionSpotStatus.OCCUPIED);
+            setSpotStatus(
+                sourceState.spots,
+                emptySpot,
+                PositionSpotStatus.OCCUPIED
+            );
             creep.memory.destination = {
                 id: source.id,
-                type: "source",
+                type: 'source',
-                sourceSpot: emptySpot
+                sourceSpot: emptySpot,
             };
             return;
         }
@@ -91,7 +106,10 @@ class HarvesterHandler extends RoleHandler {
     }
 
     private static onSourceDestination(creep: Creep, _state: GameState) {
-        if (!creep.memory.destination || creep.memory.destination.type !== "source") {
+        if (
+            !creep.memory.destination ||
+            creep.memory.destination.type !== 'source'
+        ) {
             console.log(`Creep ${creep.name} has no valid destination set.`);
             delete creep.memory.destination;
             return;
@@ -104,10 +122,17 @@ class HarvesterHandler extends RoleHandler {
         }
 
         if (creep.harvest(source) === ERR_NOT_IN_RANGE) {
-            const sourceSpotPosition = getPositionWithDelta(source.pos, creep.memory.destination.sourceSpot);
+            const sourceSpotPosition = getPositionWithDelta(
+                source.pos,
+                creep.memory.destination.sourceSpot
+            );
             creep.moveTo(sourceSpotPosition, {
                 reusePath: 10,
-                visualizePathStyle: { stroke: "#ffffff", lineStyle: "dashed", strokeWidth: 0.1 }
+                visualizePathStyle: {
+                    stroke: '#ffffff',
+                    lineStyle: 'dashed',
+                    strokeWidth: 0.1,
+                },
             });
         }
     }
@@ -116,7 +141,7 @@ class HarvesterHandler extends RoleHandler {
         if (creep.memory.destination === undefined) {
             creep.memory.destination = {
                 id: creep.memory.spawnId,
-                type: "spawn"
+                type: 'spawn',
             };
         }
 
@@ -129,22 +154,29 @@ 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 }
+                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))
+            .map((sourceId) => getSourceById(sourceId))
-            .filter(source => source !== null)
+            .filter((source) => source !== null)
             .sort((a, b) => creep.pos.getRangeTo(a) - creep.pos.getRangeTo(b));
 
         return sources as Source[];
     }
 
-    private static releaseSourceSpot(destination: SourceDestination, state: GameState) {
+    private static releaseSourceSpot(
-        if (!destination || destination.type !== "source") {
+        destination: SourceDestination,
+        state: GameState
+    ) {
+        if (!destination || destination.type !== 'source') {
             return; // Not a source destination, nothing to release
         }
 
@@ -154,7 +186,11 @@ class HarvesterHandler extends RoleHandler {
             return;
         }
 
-        setSpotStatus(sourceState.spots, destination.sourceSpot, PositionSpotStatus.EMPTY);
+        setSpotStatus(
+            sourceState.spots,
+            destination.sourceSpot,
+            PositionSpotStatus.EMPTY
+        );
     }
 }
 

src/roleHandlers/index.ts

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

src/roleHandlers/upgrader.handler.ts

@@ -1,15 +1,20 @@
-import { getControllerById, getSourceById } from "utils/funcs/getById";
+import { RoleHandler } from './BaseHandler.interface';
-import { RoleHandler } from "./BaseHandler.interface";
+import { SourceDestination } from 'types/creeps';
-import { getNextEmptySpot, PositionSpotStatus, setSpotStatus, getPositionWithDelta } from "utils/positions";
+import { getControllerById, getSourceById } from 'utils/funcs/getById';
-import { SourceDestination } from "types/creeps";
+import {
+    getNextEmptySpot,
+    PositionSpotStatus,
+    setSpotStatus,
+    getPositionWithDelta,
+} from 'utils/positions';
 
 class UpgraderHandler extends RoleHandler {
     public static destroy(creepMemory: CreepMemory, state: GameState): void {
-        if (creepMemory.destination?.type === "source") {
+        if (creepMemory.destination?.type === 'source') {
             this.releaseSourceSpot(creepMemory.destination, state);
             delete creepMemory.destination; // Clear destination after releasing the spot
         }
-        if (creepMemory.previousDestination?.type === "source") {
+        if (creepMemory.previousDestination?.type === 'source') {
             this.releaseSourceSpot(creepMemory.previousDestination, state);
             delete creepMemory.previousDestination; // Clear previous destination after releasing the spot
         }
@@ -19,10 +24,10 @@ class UpgraderHandler extends RoleHandler {
         this.validateCreepMemory(creep, state);
 
         switch (creep.memory.destination?.type) {
-            case "controller":
+            case 'controller':
                 this.onControllerDestination(creep, state);
                 break;
-            case "source":
+            case 'source':
                 this.onSourceDestination(creep, state);
                 break;
             default:
@@ -34,7 +39,10 @@ class UpgraderHandler extends RoleHandler {
     }
 
     private static validateCreepMemory(creep: Creep, state: GameState) {
-        if (!!creep.memory.previousDestination && creep.memory.previousDestination.type === "source") {
+        if (
+            !!creep.memory.previousDestination &&
+            creep.memory.previousDestination.type === 'source'
+        ) {
             setSpotStatus(
                 state.sourcesStates[creep.memory.previousDestination.id].spots,
                 creep.memory.previousDestination.sourceSpot,
@@ -47,23 +55,31 @@ class UpgraderHandler extends RoleHandler {
             return; // No destination set, nothing to validate
         }
 
-        if (creep.memory.destination.type === "source" && !creep.store.getFreeCapacity(RESOURCE_ENERGY)) {
+        if (
+            creep.memory.destination.type === 'source' &&
+            !creep.store.getFreeCapacity(RESOURCE_ENERGY)
+        ) {
             creep.memory.previousDestination = creep.memory.destination;
 
             if (!creep.room.controller) {
-                console.log(`Creep ${creep.name} has no valid controller to upgrade.`);
+                console.log(
+                    `Creep ${creep.name} has no valid controller to upgrade.`
+                );
                 delete creep.memory.destination;
                 return;
             }
 
             creep.memory.destination = {
                 id: creep.room.controller.id,
-                type: "controller"
+                type: 'controller',
             };
             return;
         }
 
-        if (creep.memory.destination.type === "controller" && creep.store.getUsedCapacity(RESOURCE_ENERGY) === 0) {
+        if (
+            creep.memory.destination.type === 'controller' &&
+            creep.store.getUsedCapacity(RESOURCE_ENERGY) === 0
+        ) {
             delete creep.memory.destination; // Clear destination if no energy is available
             return;
         }
@@ -85,11 +101,15 @@ class UpgraderHandler extends RoleHandler {
                 continue; // No empty spots available, skip to next source
             }
 
-            setSpotStatus(sourceState.spots, emptySpot, PositionSpotStatus.OCCUPIED);
+            setSpotStatus(
+                sourceState.spots,
+                emptySpot,
+                PositionSpotStatus.OCCUPIED
+            );
             creep.memory.destination = {
                 id: source.id,
-                type: "source",
+                type: 'source',
-                sourceSpot: emptySpot
+                sourceSpot: emptySpot,
             };
             return;
         }
@@ -98,7 +118,10 @@ class UpgraderHandler extends RoleHandler {
     }
 
     private static onSourceDestination(creep: Creep, _state: GameState) {
-        if (!creep.memory.destination || creep.memory.destination.type !== "source") {
+        if (
+            !creep.memory.destination ||
+            creep.memory.destination.type !== 'source'
+        ) {
             console.log(`Creep ${creep.name} has no valid destination set.`);
             delete creep.memory.destination;
             return;
@@ -111,10 +134,17 @@ class UpgraderHandler extends RoleHandler {
         }
 
         if (creep.harvest(source) === ERR_NOT_IN_RANGE) {
-            const sourceSpotPosition = getPositionWithDelta(source.pos, creep.memory.destination.sourceSpot);
+            const sourceSpotPosition = getPositionWithDelta(
+                source.pos,
+                creep.memory.destination.sourceSpot
+            );
             creep.moveTo(sourceSpotPosition, {
                 reusePath: 10,
-                visualizePathStyle: { stroke: "#ffffff", lineStyle: "dashed", strokeWidth: 0.1 }
+                visualizePathStyle: {
+                    stroke: '#ffffff',
+                    lineStyle: 'dashed',
+                    strokeWidth: 0.1,
+                },
             });
         }
     }
@@ -122,13 +152,15 @@ class UpgraderHandler extends RoleHandler {
     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.`);
+                console.log(
+                    `Creep ${creep.name} has no valid controller to upgrade.`
+                );
                 delete creep.memory.destination;
                 return;
             }
             creep.memory.destination = {
                 id: creep.room.controller.id,
-                type: "controller"
+                type: 'controller',
             };
         }
 
@@ -141,22 +173,29 @@ 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 }
+                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))
+            .map((sourceId) => getSourceById(sourceId))
-            .filter(source => source !== null)
+            .filter((source) => source !== null)
             .sort((a, b) => creep.pos.getRangeTo(a) - creep.pos.getRangeTo(b));
 
         return sources as Source[];
     }
 
-    private static releaseSourceSpot(destination: SourceDestination, state: GameState) {
+    private static releaseSourceSpot(
-        if (!destination || destination.type !== "source") {
+        destination: SourceDestination,
+        state: GameState
+    ) {
+        if (!destination || destination.type !== 'source') {
             return; // Not a source destination, nothing to release
         }
 
@@ -166,7 +205,11 @@ class UpgraderHandler extends RoleHandler {
             return;
         }
 
-        setSpotStatus(sourceState.spots, destination.sourceSpot, PositionSpotStatus.EMPTY);
+        setSpotStatus(
+            sourceState.spots,
+            destination.sourceSpot,
+            PositionSpotStatus.EMPTY
+        );
     }
 }
 

src/types/creeps.ts

@@ -1,5 +1,5 @@
-import { HarvesterHandler, RoleHandler, UpgraderHandler } from "roleHandlers";
+import { HarvesterHandler, RoleHandler, UpgraderHandler } from 'roleHandlers';
-import { PositionDelta } from "utils/positions";
+import { PositionDelta } from 'utils/positions';
 
 export type RoleDefinition = {
     name: string;
@@ -10,23 +10,23 @@ export type RoleDefinition = {
 
 export const CreepRoles = {
     harvester: {
-        name: "harvester",
+        name: 'harvester',
         body: [WORK, CARRY, MOVE],
         handler: HarvesterHandler,
-        priority: 1
+        priority: 1,
     },
     upgrader: {
-        name: "upgrader",
+        name: 'upgrader',
         body: [WORK, CARRY, MOVE],
         handler: UpgraderHandler,
-        priority: 2
+        priority: 2,
     },
     builder: {
-        name: "builder",
+        name: 'builder',
         body: [WORK, CARRY, MOVE],
         handler: HarvesterHandler,
-        priority: 3
+        priority: 3,
-    }
+    },
 } satisfies Record<string, RoleDefinition>;
 
 export type CreepRole = keyof typeof CreepRoles;
@@ -35,23 +35,23 @@ export type CreepRequisition = Record<CreepRole, number>;
 
 export type SpawnDestination = {
     id: string; // ID of the spawn
-    type: "spawn";
+    type: 'spawn';
 };
 
 export type SourceDestination = {
     id: string; // ID of the source
-    type: "source";
+    type: 'source';
     sourceSpot: PositionDelta; // Position delta for the source spot
 };
 
 export type ControllerDestination = {
     id: string; // ID of the controller
-    type: "controller";
+    type: 'controller';
 };
 
 export type ConstructionSiteDestination = {
     id: string; // ID of the construction site
-    type: "constructionSite";
+    type: 'constructionSite';
 };
 
 export type CreepDestination =

src/types/gameConfig.ts

@@ -1,4 +1,4 @@
-import { CreepRequisition } from "./creeps";
+import { CreepRequisition } from './creeps';
 
 /**
  * Configuration for the game, defining limits and minimum requirements for creeps.
@@ -22,6 +22,6 @@ export const DEFAULT_GAME_CONFIG: GameConfig = {
     minCreepsPerRole: {
         harvester: 3,
         upgrader: 7,
-        builder: 0
+        builder: 0,
-    }
+    },
 };

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

@@ -1,6 +1,8 @@
 export const getSourceById = (sourceId: string): Source | null => {
     if (!sourceId) {
-        console.log("getSourceById called with an empty or undefined sourceId.");
+        console.log(
+            'getSourceById called with an empty or undefined sourceId.'
+        );
         return null;
     }
 
@@ -15,7 +17,7 @@ export const getSourceById = (sourceId: string): Source | null => {
 
 export const getSpawnById = (spawnId: string): StructureSpawn | null => {
     if (!spawnId) {
-        console.log("getSpawnById called with an empty or undefined spawnId.");
+        console.log('getSpawnById called with an empty or undefined spawnId.');
         return null;
     }
 
@@ -28,9 +30,13 @@ export const getSpawnById = (spawnId: string): StructureSpawn | null => {
     return spawn;
 };
 
-export const getControllerById = (controllerId: string): StructureController | null => {
+export const getControllerById = (
+    controllerId: string
+): StructureController | null => {
     if (!controllerId) {
-        console.log("getControllerById called with an empty or undefined controllerId.");
+        console.log(
+            'getControllerById called with an empty or undefined controllerId.'
+        );
         return null;
     }
 

src/utils/funcs/getRoleCost.ts

@@ -1,4 +1,4 @@
-import { RoleDefinition } from "types/creeps";
+import { RoleDefinition } from 'types/creeps';
 
 export const get_role_cost = (role: RoleDefinition) => {
     return role.body.reduce((cost, part) => {

src/utils/funcs/getRoomCreeps.ts

@@ -1,6 +1,6 @@
 export const getRoomCreeps = (room: Room): Record<string, CreepMemory> => {
     return Object.keys(Memory.creeps)
-        .filter(name => Memory.creeps[name].room === room.name)
+        .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

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

src/utils/positions/index.ts

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

src/utils/positions/position.funcs.ts

@@ -1,4 +1,9 @@
-import { PositionDelta, PositionDeltaValue, PositionMatrix, PositionSpotStatus } from "./position.types";
+import {
+    PositionDelta,
+    PositionDeltaValue,
+    PositionMatrix,
+    PositionSpotStatus,
+} from './position.types';
 
 /**
  * Represents a point in the matrix with x and y coordinates.
@@ -23,7 +28,9 @@ const indexToMatrixPoint = (index: number): MatrixPoint => {
  * 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 => {
+export const createSourcePositionMatrix = (
+    default_value?: PositionSpotStatus
+): PositionMatrix => {
     const center_value = PositionSpotStatus.CENTER;
 
     default_value = default_value || PositionSpotStatus.UNKNOWN;
@@ -37,15 +44,19 @@ export const createSourcePositionMatrix = (default_value?: PositionSpotStatus):
         default_value,
         default_value,
         default_value,
-        default_value
+        default_value,
     ];
 };
 
 /**
  * Gets the next empty spot in the matrix.
  */
-export const getNextEmptySpot = (matrix: PositionMatrix): PositionDelta | null => {
+export const getNextEmptySpot = (
-    const index = matrix.findIndex(status => status === PositionSpotStatus.EMPTY);
+    matrix: PositionMatrix
+): PositionDelta | null => {
+    const index = matrix.findIndex(
+        (status) => status === PositionSpotStatus.EMPTY
+    );
 
     if (index === -1) {
         return null; // No empty spot found
@@ -58,9 +69,15 @@ export const getNextEmptySpot = (matrix: PositionMatrix): PositionDelta | null =
  * 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 => {
+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}.`);
+        throw new Error(
+            `Invalid delta: ${delta}. Must be between 0 and ${matrix.length - 1}.`
+        );
     }
     matrix[delta] = status;
 };
@@ -68,9 +85,16 @@ export const setSpotStatus = (matrix: PositionMatrix, delta: PositionDelta, stat
 /**
  * Gets the position with a delta applied to the given RoomPosition.
  */
-export const getPositionWithDelta = (pos: RoomPosition, delta: PositionDelta): 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);
+    return new RoomPosition(
+        pos.x + matrixPoint.x,
+        pos.y + matrixPoint.y,
+        pos.roomName
+    );
 };
 
 /**

src/utils/positions/position.types.ts

@@ -2,14 +2,15 @@
  * Represents the status of a position spot
  */
 export const PositionSpotStatus = {
-    INVALID: "-2",
+    INVALID: '-2',
-    CENTER: "-1",
+    CENTER: '-1',
-    UNKNOWN: "0",
+    UNKNOWN: '0',
-    EMPTY: "1",
+    EMPTY: '1',
-    OCCUPIED: "2"
+    OCCUPIED: '2',
 } as const;
 
-export type PositionSpotStatus = (typeof PositionSpotStatus)[keyof typeof PositionSpotStatus];
+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.
@@ -30,7 +31,7 @@ export type PositionMatrix = [
     PositionSpotStatus,
     PositionSpotStatus,
     PositionSpotStatus,
-    PositionSpotStatus
+    PositionSpotStatus,
 ];
 
 // Valid indices for the 3x3 matrix (0-8)

test/integration/helper.ts

@@ -9,51 +9,57 @@ const DIST_MAIN_JS = 'dist/main.js';
  * manipulating the terrain and game state.
  */
 class IntegrationTestHelper {
-  private _server: any;
+    private _server: any;
-  private _player: any;
+    private _player: any;
 
-  get server() {
+    get server() {
-    return this._server;
+        return this._server;
-  }
+    }
 
-  get player() {
+    get player() {
-    return this._player;
+        return this._player;
-  }
+    }
 
-  async beforeEach() {
+    async beforeEach() {
-    this._server = new ScreepsServer();
+        this._server = new ScreepsServer();
 
-    // reset world but add invaders and source keepers bots
+        // reset world but add invaders and source keepers bots
-    await this._server.world.reset();
+        await this._server.world.reset();
 
-    // create a stub world composed of 9 rooms with sources and controller
+        // create a stub world composed of 9 rooms with sources and controller
-    await this._server.world.stubWorld();
+        await this._server.world.stubWorld();
 
-    // add a player with the built dist/main.js file
+        // add a player with the built dist/main.js file
-    const modules = {
+        const modules = {
-        main: readFileSync(DIST_MAIN_JS).toString(),
+            main: readFileSync(DIST_MAIN_JS).toString(),
-    };
+        };
-    this._player = await this._server.world.addBot({ username: 'player', room: 'W0N1', x: 15, y: 15, modules });
+        this._player = await this._server.world.addBot({
+            username: 'player',
+            room: 'W0N1',
+            x: 15,
+            y: 15,
+            modules,
+        });
 
-    // Start server
+        // Start server
-    await this._server.start();
+        await this._server.start();
-  }
+    }
 
-  async afterEach() {
+    async afterEach() {
-    await this._server.stop();
+        await this._server.stop();
-  }
+    }
 }
 
 beforeEach(async () => {
-  await helper.beforeEach();
+    await helper.beforeEach();
 });
 
 afterEach(async () => {
-  await helper.afterEach();
+    await helper.afterEach();
 });
 
 before(() => {
-  stdHooks.hookWrite();
+    stdHooks.hookWrite();
 });
 
 export const helper = new IntegrationTestHelper();

test/integration/integration.test.ts

@@ -1,18 +1,18 @@
-import {assert} from "chai";
+import { helper } from './helper';
-import {helper} from "./helper";
+import { assert } from 'chai';
 
-describe("main", () => {
+describe('main', () => {
-  it("runs a server and matches the game tick", async function () {
+    it('runs a server and matches the game tick', async function () {
-    for (let i = 1; i < 10; i += 1) {
+        for (let i = 1; i < 10; i += 1) {
-      assert.equal(await helper.server.world.gameTime, i);
+            assert.equal(await helper.server.world.gameTime, i);
-      await helper.server.tick();
+            await helper.server.tick();
-    }
+        }
-  });
+    });
 
-  it("writes and reads to memory", async function () {
+    it('writes and reads to memory', async function () {
-    await helper.player.console(`Memory.foo = 'bar'`);
+        await helper.player.console(`Memory.foo = 'bar'`);
-    await helper.server.tick();
+        await helper.server.tick();
-    const memory = JSON.parse(await helper.player.memory);
+        const memory = JSON.parse(await helper.player.memory);
-    assert.equal(memory.foo, 'bar');
+        assert.equal(memory.foo, 'bar');
-  });
+    });
 });

test/setup-mocha.js

@@ -6,4 +6,4 @@ global.sinon = require('sinon');
 global.chai.use(require('sinon-chai'));
 
 // Override ts-node compiler options
-process.env.TS_NODE_PROJECT = 'tsconfig.test.json'
+process.env.TS_NODE_PROJECT = 'tsconfig.test.json';

test/unit/main.test.ts

@@ -1,37 +1,37 @@
-import {assert} from "chai";
+import { loop } from '../../src/main';
-import {loop} from "../../src/main";
+import { Game, Memory } from './mock';
-import {Game, Memory} from "./mock"
+import { assert } from 'chai';
 
-describe("main", () => {
+describe('main', () => {
-  before(() => {
+    before(() => {
-    // runs before all test in this block
+        // runs before all test in this block
-  });
+    });
 
-  beforeEach(() => {
+    beforeEach(() => {
-    // runs before each test in this block
+        // runs before each test in this block
-    // @ts-ignore : allow adding Game to global
+        // @ts-ignore : allow adding Game to global
-    global.Game = _.clone(Game);
+        global.Game = _.clone(Game);
-    // @ts-ignore : allow adding Memory to global
+        // @ts-ignore : allow adding Memory to global
-    global.Memory = _.clone(Memory);
+        global.Memory = _.clone(Memory);
-  });
+    });
 
-  it("should export a loop function", () => {
+    it('should export a loop function', () => {
-    assert.isTrue(typeof loop === "function");
+        assert.isTrue(typeof loop === 'function');
-  });
+    });
 
-  it("should return void when called with no context", () => {
+    it('should return void when called with no context', () => {
-    assert.isUndefined(loop());
+        assert.isUndefined(loop());
-  });
+    });
 
-  it("Automatically delete memory of missing creeps", () => {
+    it('Automatically delete memory of missing creeps', () => {
-    Memory.creeps.persistValue = "any value";
+        Memory.creeps.persistValue = 'any value';
-    Memory.creeps.notPersistValue = "any value";
+        Memory.creeps.notPersistValue = 'any value';
 
-    Game.creeps.persistValue = "any value";
+        Game.creeps.persistValue = 'any value';
 
-    loop();
+        loop();
 
-    assert.isDefined(Memory.creeps.persistValue);
+        assert.isDefined(Memory.creeps.persistValue);
-    assert.isUndefined(Memory.creeps.notPersistValue);
+        assert.isUndefined(Memory.creeps.notPersistValue);
-  });
+    });
 });

test/unit/mock.ts

@@ -1,17 +1,17 @@
 export const Game: {
-  creeps: { [name: string]: any };
+    creeps: { [name: string]: any };
-  rooms: any;
+    rooms: any;
-  spawns: any;
+    spawns: any;
-  time: any;
+    time: any;
 } = {
-  creeps: {},
+    creeps: {},
-  rooms: [],
+    rooms: [],
-  spawns: {},
+    spawns: {},
-  time: 12345
+    time: 12345,
 };
 
 export const Memory: {
-  creeps: { [name: string]: any };
+    creeps: { [name: string]: any };
 } = {
-  creeps: {}
+    creeps: {},
 };

tsconfig.json

@@ -1,23 +1,23 @@
 {
-  "compilerOptions": {
+    "compilerOptions": {
-    "target": "ES6",
+        "target": "ES6",
-    "lib": ["ES2017", "DOM"],
+        "lib": ["ES2017", "DOM"],
-    "module": "commonjs",
+        "module": "commonjs",
-    "moduleResolution": "node",
+        "moduleResolution": "node",
-    "outDir": "dist",
+        "outDir": "dist",
-    "rootDir": "src",
+        "rootDir": "src",
-    "baseUrl": "src",
+        "baseUrl": "src",
-    "strict": true,
+        "strict": true,
-    "noImplicitReturns": true,
+        "noImplicitReturns": true,
-    "noUnusedLocals": true,
+        "noUnusedLocals": true,
-    "noUnusedParameters": true,
+        "noUnusedParameters": true,
-    "noFallthroughCasesInSwitch": true,
+        "noFallthroughCasesInSwitch": true,
-    "allowUnreachableCode": false,
+        "allowUnreachableCode": false,
-    "sourceMap": true,
+        "sourceMap": true,
-    "experimentalDecorators": true,
+        "experimentalDecorators": true,
-    "allowSyntheticDefaultImports": true,
+        "allowSyntheticDefaultImports": true,
-    "types": ["screeps"]
+        "types": ["node", "screeps"]
-  },
+    },
-  "include": ["src/**/*", "src/RequisitionsManager.ts"],
+    "include": ["src/*.ts", "src/**/*.ts"],
-  "exclude": ["node_modules", "dist"]
+    "exclude": ["node_modules", "dist"]
 }

tsconfig.test.json

@@ -1,6 +1,6 @@
 {
-  "extends": "./tsconfig.json",
+    "extends": "./tsconfig.json",
-  "compilerOptions": {
+    "compilerOptions": {
-    "module": "CommonJs"
+        "module": "CommonJs"
-  }
+    }
 }