hoi4-agent-tools 3.10.0 → 4.0.0

package/dist/hoi4_agent_tools/map/job-operations.js

@@ -2,7 +2,7 @@ import { z } from 'zod/v4';
 import { IdleCacheLifetime } from '../core/idle-cache-lifetime.js';
 import { errorResult, toolResult } from '../core/operation-result.js';
 import { ServiceError } from '../core/result.js';
-import { mapInspectRequestSchema, mapRenderRequestSchema, mapRewriteRequestSchema, } from '../schemas/map-requests.js';
+import { MAP_VIEW_FIELDS, mapInspectRequestSchema, mapRewriteRequestSchema, } from '../schemas/map-requests.js';
 import { AgentNudger } from './service.js';
 import { inspectMap, completeMapRewrite, normalizeMapInspectRequest, normalizeMapRenderRequest, normalizeMapRewriteRequest, prepareMapRewrite, renderMapView, } from './tool-operations.js';
 const wireResult = z.record(z.string(), z.json());
@@ -43,8 +43,12 @@ export function registerMapJobs(operations, engine) {
             }
         });
     }
-    register('hoi4.map_inspect', mapInspectRequestSchema, normalizeMapInspectRequest, (nudger, input, context) => inspectMap(engine, nudger, input, context));
-    register('hoi4.map_render', mapRenderRequestSchema, normalizeMapRenderRequest, renderMapView);
+    register('hoi4.map_inspect', mapInspectRequestSchema, normalizeMapInspectRequest, (nudger, input, context) => MAP_VIEW_FIELDS.some((field) => input[field] !== undefined)
+        ? renderMapView(nudger, normalizeMapRenderRequest({
+            workspaceId: input.workspaceId,
+            ...Object.fromEntries(MAP_VIEW_FIELDS.flatMap((field) => input[field] === undefined ? [] : [[field, input[field]]])),
+        }), context)
+        : inspectMap(engine, nudger, input, context));
     operations.registerWrite('hoi4.map_rewrite', mapRewriteRequestSchema, async (input, context) => {
         if (input.workspaceId !== 'current' && input.workspaceId !== context.workspaceId)
             throw new ServiceError('JOB_ARGUMENT_SCOPE_MISMATCH', 'The request workspace does not match the authorized job workspace');

package/dist/hoi4_agent_tools/map/model.js

@@ -485,6 +485,73 @@ export function parseTerrainCategories(files, diagnostics) {
     }
     return categories;
 }
+/**
+ * When no building definitions are scanned, these state buildings are levels rather than slot
+ * counts, as in the base game: a split keeps the level in both states and a merge keeps the
+ * highest level.
+ */
+export const LEVEL_STATE_BUILDINGS = new Set([
+    'infrastructure',
+    'air_base',
+    'anti_air_building',
+    'radar_station',
+]);
+/** Building types and spawn points from the active `common/buildings` files. */
+export function parseBuildingDefinitions(files, diagnostics) {
+    const definitions = new Map();
+    const spawnPoints = new Map();
+    const yes = (block, key) => firstScalar(block, key)?.value === 'yes';
+    const numberIn = (block, key) => {
+        if (block === undefined)
+            return undefined;
+        const value = Number(firstScalar(block, key)?.value);
+        return Number.isFinite(value) ? value : undefined;
+    };
+    for (const file of [...files].sort((left, right) => compareCodeUnits(normalizedPath(left.relativePath), normalizedPath(right.relativePath)))) {
+        const document = parseClausewitz(file.bytes, file.displayPath);
+        addMapDiagnostics(diagnostics, document.diagnostics);
+        for (const entry of document.root.entries) {
+            if (entry.type !== 'assignment' || entry.value.type !== 'block')
+                continue;
+            if (entry.key.value === 'buildings') {
+                for (const building of entry.value.entries) {
+                    if (building.type !== 'assignment' || building.value.type !== 'block')
+                        continue;
+                    const block = building.value;
+                    const levelCap = assignments(block, 'level_cap')[0]?.value;
+                    const cap = levelCap?.type === 'block' ? levelCap : undefined;
+                    const provinceMax = numberIn(cap, 'province_max') ?? numberIn(block, 'province_max');
+                    const stateMax = numberIn(cap, 'state_max') ?? numberIn(block, 'state_max');
+                    const spawnPoint = firstScalar(block, 'spawn_point')?.value;
+                    definitions.set(building.key.value, {
+                        name: building.key.value,
+                        sharesSlots: yes(block, 'shares_slots') || (cap !== undefined && yes(cap, 'shares_slots')),
+                        provincial: yes(block, 'provincial') || provinceMax !== undefined,
+                        ...(stateMax === undefined ? {} : { stateMax }),
+                        ...(provinceMax === undefined ? {} : { provinceMax }),
+                        showOnMap: numberIn(block, 'show_on_map') ?? 0,
+                        onlyCoastal: yes(block, 'only_costal'),
+                        ...(spawnPoint === undefined ? {} : { spawnPoint }),
+                    });
+                }
+            }
+            else if (entry.key.value === 'spawn_points') {
+                for (const point of entry.value.entries) {
+                    if (point.type !== 'assignment' || point.value.type !== 'block')
+                        continue;
+                    spawnPoints.set(point.key.value, {
+                        name: point.key.value,
+                        provincial: firstScalar(point.value, 'type')?.value === 'province',
+                        max: numberIn(point.value, 'max') ?? 1,
+                        onlyCoastal: yes(point.value, 'only_costal'),
+                        autoNudged: !yes(point.value, 'disable_auto_nudging'),
+                    });
+                }
+            }
+        }
+    }
+    return { definitions, spawnPoints };
+}
 /** Continent names in `continent.txt`; their one-based positions are the continent IDs. */
 export function parseContinents(file, diagnostics) {
     const document = parseClausewitz(file.bytes, file.displayPath);
@@ -1040,8 +1107,39 @@ export class MapWorkspaceIndex {
     continents;
     /** Terrain categories when any `common/terrain` file was read. */
     terrainCategories;
+    /** Building types from `common/buildings`; empty when none were scanned. */
+    buildingDefinitions;
+    buildingSpawnPoints;
     supplyNodeFile;
     railwayFile;
+    /** The active heightmap, when the scan included it; decoded on first use. */
+    heightmapFile;
+    #heightmap;
+    /**
+     * Map height (the Y coordinate) at a bitmap pixel: the heightmap value divided by ten, as the
+     * game reads it. Without a readable heightmap of the province map's size, sea level (9.5).
+     */
+    heightAt(x, y) {
+        if (this.#heightmap === undefined) {
+            this.#heightmap = null;
+            if (this.heightmapFile !== undefined)
+                try {
+                    const decoded = BmpImage.decode(this.heightmapFile.bytes);
+                    if (decoded.bitsPerPixel === 8 &&
+                        decoded.width === this.raster?.width &&
+                        decoded.height === this.raster.height)
+                        this.#heightmap = decoded;
+                }
+                catch {
+                    this.#heightmap = null;
+                }
+        }
+        if (this.#heightmap === null)
+            return 9.5;
+        const index = this.#heightmap.paletteIndexAt(Math.min(Math.max(0, Math.floor(x)), this.#heightmap.width - 1), Math.min(Math.max(0, Math.floor(y)), this.#heightmap.height - 1));
+        const color = this.#heightmap.palette[index];
+        return (color === undefined ? index : color.r) / 10;
+    }
     constructor(files, sourceRoots = defaultMapIndexSourceRoots, sharedIndex = SymbolIndex.build(files)) {
         this.sourceFiles = [...files];
         this.sharedIndex = sharedIndex;
@@ -1198,6 +1296,11 @@ export class MapWorkspaceIndex {
             terrainFiles.length === 0
                 ? undefined
                 : parseTerrainCategories(terrainFiles, this.diagnostics);
+        this.heightmapFile = mapFile(this.activeFiles, defaultMapSelectorValue(this.defaultMapFile, 'heightmap', 'heightmap.bmp'), this.sourceRoots.map);
+        const buildingFiles = this.activeFiles.all.filter((file) => /^common\/buildings\/[^/]+\.txt$/iu.test(normalizedPath(file.relativePath)));
+        const buildings = parseBuildingDefinitions(buildingFiles, []);
+        this.buildingDefinitions = buildings.definitions;
+        this.buildingSpawnPoints = buildings.spawnPoints;
         this.adjacencyFile = mapFile(this.activeFiles, defaultMapSelectorValue(this.defaultMapFile, 'adjacencies', 'adjacencies.csv'), this.sourceRoots.map);
         this.adjacencies =
             this.adjacencyFile === undefined