@lagless/2d-map-generator 0.0.48

package/dist/lib/collision/spatial-grid-provider.js

@@ -0,0 +1,127 @@
+import { ShapeType } from '../types/geometry.js';
+import { testCircleCircle, testCircleAabb, testAabbAabb } from '../math/collision-test.js';
+export class SpatialGridCollisionProvider {
+    _cellSize;
+    _gridW;
+    _gridH;
+    _cells;
+    _shapes = new Map();
+    _queryId = 0;
+    _lastQueried = new Map();
+    constructor(width, height, cellSize = 32) {
+        this._cellSize = cellSize;
+        this._gridW = Math.ceil(width / cellSize);
+        this._gridH = Math.ceil(height / cellSize);
+        this._cells = new Map();
+    }
+    addShape(id, shape, posX, posY, rotation, scale) {
+        const stored = this._createStoredShape(id, shape, posX, posY, rotation, scale);
+        this._shapes.set(id, stored);
+        for (let cy = stored.minCellY; cy <= stored.maxCellY; cy++) {
+            for (let cx = stored.minCellX; cx <= stored.maxCellX; cx++) {
+                const key = cy * this._gridW + cx;
+                let cell = this._cells.get(key);
+                if (!cell) {
+                    cell = [];
+                    this._cells.set(key, cell);
+                }
+                cell.push(id);
+            }
+        }
+    }
+    testShape(shape, posX, posY, rotation, scale) {
+        this._queryId++;
+        const queryId = this._queryId;
+        const test = this._createStoredShape(-1, shape, posX, posY, rotation, scale);
+        for (let cy = test.minCellY; cy <= test.maxCellY; cy++) {
+            for (let cx = test.minCellX; cx <= test.maxCellX; cx++) {
+                const key = cy * this._gridW + cx;
+                const cell = this._cells.get(key);
+                if (!cell)
+                    continue;
+                for (const existingId of cell) {
+                    if (this._lastQueried.get(existingId) === queryId)
+                        continue;
+                    this._lastQueried.set(existingId, queryId);
+                    const existing = this._shapes.get(existingId);
+                    if (!existing)
+                        continue;
+                    if (this._testOverlap(test, existing)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    removeShape(id) {
+        const stored = this._shapes.get(id);
+        if (!stored)
+            return;
+        for (let cy = stored.minCellY; cy <= stored.maxCellY; cy++) {
+            for (let cx = stored.minCellX; cx <= stored.maxCellX; cx++) {
+                const key = cy * this._gridW + cx;
+                const cell = this._cells.get(key);
+                if (!cell)
+                    continue;
+                const idx = cell.indexOf(id);
+                if (idx !== -1) {
+                    cell.splice(idx, 1);
+                }
+                if (cell.length === 0) {
+                    this._cells.delete(key);
+                }
+            }
+        }
+        this._shapes.delete(id);
+        this._lastQueried.delete(id);
+    }
+    clear() {
+        this._cells.clear();
+        this._shapes.clear();
+        this._lastQueried.clear();
+        this._queryId = 0;
+    }
+    _createStoredShape(id, shape, posX, posY, rotation, scale) {
+        let halfExtX;
+        let halfExtY;
+        if (shape.type === ShapeType.Circle) {
+            const r = shape.radius * scale;
+            halfExtX = r;
+            halfExtY = r;
+        }
+        else {
+            halfExtX = shape.halfWidth * scale;
+            halfExtY = shape.halfHeight * scale;
+        }
+        const minCellX = Math.max(0, Math.floor((posX - halfExtX) / this._cellSize));
+        const minCellY = Math.max(0, Math.floor((posY - halfExtY) / this._cellSize));
+        const maxCellX = Math.min(this._gridW - 1, Math.floor((posX + halfExtX) / this._cellSize));
+        const maxCellY = Math.min(this._gridH - 1, Math.floor((posY + halfExtY) / this._cellSize));
+        return {
+            id, shape, posX, posY, rotation, scale,
+            minCellX, minCellY, maxCellX, maxCellY,
+        };
+    }
+    _testOverlap(a, b) {
+        const aShape = a.shape;
+        const bShape = b.shape;
+        if (aShape.type === ShapeType.Circle && bShape.type === ShapeType.Circle) {
+            return testCircleCircle(a.posX, a.posY, aShape.radius * a.scale, b.posX, b.posY, bShape.radius * b.scale);
+        }
+        if (aShape.type === ShapeType.Cuboid && bShape.type === ShapeType.Cuboid) {
+            const aHW = aShape.halfWidth * a.scale;
+            const aHH = aShape.halfHeight * a.scale;
+            const bHW = bShape.halfWidth * b.scale;
+            const bHH = bShape.halfHeight * b.scale;
+            return testAabbAabb(a.posX - aHW, a.posY - aHH, a.posX + aHW, a.posY + aHH, b.posX - bHW, b.posY - bHH, b.posX + bHW, b.posY + bHH);
+        }
+        // Circle vs Cuboid
+        const [circ, box] = aShape.type === ShapeType.Circle ? [a, b] : [b, a];
+        const circShape = circ.shape;
+        const boxShape = box.shape;
+        const bHW = boxShape.halfWidth * box.scale;
+        const bHH = boxShape.halfHeight * box.scale;
+        return testCircleAabb(circ.posX, circ.posY, circShape.radius * circ.scale, box.posX - bHW, box.posY - bHH, box.posX + bHW, box.posY + bHH);
+    }
+}

package/dist/lib/core/generated-map.d.ts

@@ -0,0 +1,14 @@
+import type { IGeneratedMap } from '../types/generated-map.js';
+import { FeatureId } from '../types/feature.js';
+export declare class GeneratedMap implements IGeneratedMap {
+    readonly width: number;
+    readonly height: number;
+    readonly gridSize: number;
+    private readonly _features;
+    constructor(width: number, height: number, gridSize: number);
+    setFeatureOutput(featureId: FeatureId, output: unknown): void;
+    get<T>(feature: {
+        readonly id: FeatureId;
+    }): T | undefined;
+}
+//# sourceMappingURL=generated-map.d.ts.map

package/dist/lib/core/generated-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generated-map.d.ts","sourceRoot":"","sources":["../../../src/lib/core/generated-map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAEhD,qBAAa,YAAa,YAAW,aAAa;IAI9C,QAAQ,CAAC,KAAK,EAAE,MAAM;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAL3B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiC;gBAGhD,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM;IAG3B,gBAAgB,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI;IAI7D,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE;QAAE,QAAQ,CAAC,EAAE,EAAE,SAAS,CAAA;KAAE,GAAG,CAAC,GAAG,SAAS;CAG3D"}

package/dist/lib/core/generated-map.js

@@ -0,0 +1,17 @@
+export class GeneratedMap {
+    width;
+    height;
+    gridSize;
+    _features = new Map();
+    constructor(width, height, gridSize) {
+        this.width = width;
+        this.height = height;
+        this.gridSize = gridSize;
+    }
+    setFeatureOutput(featureId, output) {
+        this._features.set(featureId, output);
+    }
+    get(feature) {
+        return this._features.get(feature.id);
+    }
+}

package/dist/lib/core/map-dimensions.d.ts

@@ -0,0 +1,8 @@
+import type { MapGeneratorConfig } from '../types/map-generator-config.js';
+export interface MapDimensions {
+    readonly width: number;
+    readonly height: number;
+    readonly gridSize: number;
+}
+export declare function computeDimensions(config: MapGeneratorConfig): MapDimensions;
+//# sourceMappingURL=map-dimensions.d.ts.map

package/dist/lib/core/map-dimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-dimensions.d.ts","sourceRoot":"","sources":["../../../src/lib/core/map-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAE3E,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,kBAAkB,GAAG,aAAa,CAM3E"}

package/dist/lib/core/map-dimensions.js

@@ -0,0 +1,7 @@
+export function computeDimensions(config) {
+    return {
+        width: config.baseWidth * config.scale + config.extension,
+        height: config.baseHeight * config.scale + config.extension,
+        gridSize: config.gridSize ?? 16,
+    };
+}

package/dist/lib/core/map-generator.d.ts

@@ -0,0 +1,14 @@
+import type { IMapFeature } from '../types/feature.js';
+import type { ISeededRandom } from '../types/prng-interface.js';
+import type { ICollisionProvider } from '../types/collision-provider.js';
+import type { MapGeneratorConfig } from '../types/map-generator-config.js';
+import { GeneratedMap } from './generated-map.js';
+export declare class MapGenerator {
+    private readonly _config;
+    private readonly _entries;
+    constructor(config: MapGeneratorConfig);
+    addFeature<TConfig, TOutput>(feature: IMapFeature<TConfig, TOutput>, config: TConfig): this;
+    generate(random: ISeededRandom, collision?: ICollisionProvider): GeneratedMap;
+    private _topologicalSort;
+}
+//# sourceMappingURL=map-generator.d.ts.map

package/dist/lib/core/map-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-generator.d.ts","sourceRoot":"","sources":["../../../src/lib/core/map-generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAqB,MAAM,qBAAqB,CAAC;AAE1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAE3E,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AA8ClD,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAC7C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsB;gBAEnC,MAAM,EAAE,kBAAkB;IAItC,UAAU,CAAC,OAAO,EAAE,OAAO,EACzB,OAAO,EAAE,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,EACtC,MAAM,EAAE,OAAO,GACd,IAAI;IAKP,QAAQ,CAAC,MAAM,EAAE,aAAa,EAAE,SAAS,CAAC,EAAE,kBAAkB,GAAG,YAAY;IAuC7E,OAAO,CAAC,gBAAgB;CAqDzB"}

package/dist/lib/core/map-generator.js

@@ -0,0 +1,124 @@
+import { FeatureId } from '../types/feature.js';
+import { GeneratedMap } from './generated-map.js';
+import { computeDimensions } from './map-dimensions.js';
+class GenerationContextImpl {
+    width;
+    height;
+    center;
+    random;
+    collision;
+    _outputs = new Map();
+    constructor(width, height, random, collision) {
+        this.width = width;
+        this.height = height;
+        this.center = { x: width / 2, y: height / 2 };
+        this.random = random;
+        this.collision = collision;
+    }
+    get(feature) {
+        if (!this._outputs.has(feature.id)) {
+            throw new Error(`Feature output "${FeatureId[feature.id]}" is not available. It may not have been run yet.`);
+        }
+        return this._outputs.get(feature.id);
+    }
+    hasFeature(featureId) {
+        return this._outputs.has(featureId);
+    }
+    setOutput(featureId, output) {
+        this._outputs.set(featureId, output);
+    }
+}
+export class MapGenerator {
+    _config;
+    _entries = [];
+    constructor(config) {
+        this._config = config;
+    }
+    addFeature(feature, config) {
+        this._entries.push({ feature, config });
+        return this;
+    }
+    generate(random, collision) {
+        const featureMap = new Map();
+        for (const entry of this._entries) {
+            featureMap.set(entry.feature.id, entry);
+        }
+        // Validate dependencies
+        for (const entry of this._entries) {
+            for (const req of entry.feature.requires) {
+                if (!featureMap.has(req)) {
+                    throw new Error(`Feature "${FeatureId[entry.feature.id]}" requires "${FeatureId[req]}" which was not included.`);
+                }
+            }
+        }
+        // Topological sort (Kahn's algorithm)
+        const sorted = this._topologicalSort(featureMap);
+        // Compute dimensions
+        const dims = computeDimensions(this._config);
+        // Create collision provider (placeholder noop if none provided)
+        const coll = collision ?? createNoopCollision();
+        // Create context and run features
+        const ctx = new GenerationContextImpl(dims.width, dims.height, random, coll);
+        const result = new GeneratedMap(dims.width, dims.height, dims.gridSize);
+        for (const entry of sorted) {
+            const output = entry.feature.generate(ctx, entry.config);
+            ctx.setOutput(entry.feature.id, output);
+            result.setFeatureOutput(entry.feature.id, output);
+        }
+        return result;
+    }
+    _topologicalSort(featureMap) {
+        const inDegree = new Map();
+        const adjacency = new Map();
+        for (const [id] of featureMap) {
+            inDegree.set(id, 0);
+            adjacency.set(id, []);
+        }
+        for (const [id, entry] of featureMap) {
+            for (const req of entry.feature.requires) {
+                const adj = adjacency.get(req);
+                const deg = inDegree.get(id);
+                if (adj && deg !== undefined) {
+                    adj.push(id);
+                    inDegree.set(id, deg + 1);
+                }
+            }
+        }
+        const queue = [];
+        for (const [id, degree] of inDegree) {
+            if (degree === 0) {
+                queue.push(id);
+            }
+        }
+        const sorted = [];
+        while (queue.length > 0) {
+            const id = queue.shift();
+            const entry = featureMap.get(id);
+            if (entry) {
+                sorted.push(entry);
+            }
+            const neighbors = adjacency.get(id);
+            if (neighbors) {
+                for (const neighbor of neighbors) {
+                    const newDegree = (inDegree.get(neighbor) ?? 1) - 1;
+                    inDegree.set(neighbor, newDegree);
+                    if (newDegree === 0) {
+                        queue.push(neighbor);
+                    }
+                }
+            }
+        }
+        if (sorted.length !== featureMap.size) {
+            throw new Error('Circular dependency detected among features.');
+        }
+        return sorted;
+    }
+}
+function createNoopCollision() {
+    return {
+        addShape() { return; },
+        testShape() { return false; },
+        removeShape() { return; },
+        clear() { return; },
+    };
+}

package/dist/lib/core/terrain-query.d.ts

@@ -0,0 +1,17 @@
+import { TerrainZone } from '../types/placed-object.js';
+import type { ShoreOutput, GrassOutput, RiverOutput, LakeOutput } from '../types/feature-configs.js';
+export interface TerrainQueryInputs {
+    shore?: ShoreOutput;
+    grass?: GrassOutput;
+    river?: RiverOutput;
+    lake?: LakeOutput;
+}
+export declare class TerrainQuery {
+    private readonly _shore;
+    private readonly _grass;
+    private readonly _rivers;
+    private readonly _lakes;
+    constructor(inputs: TerrainQueryInputs);
+    classify(x: number, y: number): TerrainZone;
+}
+//# sourceMappingURL=terrain-query.d.ts.map

package/dist/lib/core/terrain-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrain-query.d.ts","sourceRoot":"","sources":["../../../src/lib/core/terrain-query.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAKrG,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0B;IACjD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0B;IACjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA4B;IACpD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA4B;gBAEvC,MAAM,EAAE,kBAAkB;IAOtC,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,WAAW;CA0C5C"}

package/dist/lib/core/terrain-query.js

@@ -0,0 +1,54 @@
+import { TerrainZone } from '../types/placed-object.js';
+import { pointInPolygon } from '../math/polygon-utils.js';
+export class TerrainQuery {
+    _shore;
+    _grass;
+    _rivers;
+    _lakes;
+    constructor(inputs) {
+        this._shore = inputs.shore;
+        this._grass = inputs.grass;
+        this._rivers = inputs.river?.rivers ?? [];
+        this._lakes = inputs.lake?.lakes ?? [];
+    }
+    classify(x, y) {
+        // Check lakes first (highest priority water feature)
+        for (const lake of this._lakes) {
+            if (isInsideAabb(x, y, lake.aabb) && pointInPolygon({ x, y }, lake.waterPoly)) {
+                return TerrainZone.Lake;
+            }
+        }
+        // Check rivers
+        for (const river of this._rivers) {
+            if (!isInsideAabb(x, y, river.aabb))
+                continue;
+            if (pointInPolygon({ x, y }, river.waterPoly)) {
+                return TerrainZone.River;
+            }
+            if (pointInPolygon({ x, y }, river.shorePoly)) {
+                return TerrainZone.RiverShore;
+            }
+        }
+        // Check grass
+        if (this._grass) {
+            if (isInsideAabb(x, y, this._grass.bounds) && pointInPolygon({ x, y }, this._grass.polygon)) {
+                return TerrainZone.Grass;
+            }
+        }
+        // Check shore (beach = inside shore but outside grass)
+        if (this._shore) {
+            if (isInsideAabb(x, y, this._shore.bounds) && pointInPolygon({ x, y }, this._shore.polygon)) {
+                return TerrainZone.Beach;
+            }
+        }
+        // No shore feature → default to Grass
+        if (!this._shore) {
+            return TerrainZone.Grass;
+        }
+        // Outside shore → ocean
+        return TerrainZone.WaterEdge;
+    }
+}
+function isInsideAabb(x, y, aabb) {
+    return x >= aabb.min.x && x <= aabb.max.x && y >= aabb.min.y && y <= aabb.max.y;
+}

package/dist/lib/features/biome-feature.d.ts

@@ -0,0 +1,10 @@
+import type { IMapFeature, GenerationContext } from '../types/feature.js';
+import { FeatureId } from '../types/feature.js';
+import type { BiomeConfig, BiomeOutput } from '../types/feature-configs.js';
+export declare class BiomeFeature implements IMapFeature<BiomeConfig, BiomeOutput> {
+    static readonly id = FeatureId.Biome;
+    readonly id = FeatureId.Biome;
+    readonly requires: readonly FeatureId[];
+    generate(_ctx: GenerationContext, config: BiomeConfig): BiomeOutput;
+}
+//# sourceMappingURL=biome-feature.d.ts.map

package/dist/lib/features/biome-feature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"biome-feature.d.ts","sourceRoot":"","sources":["../../../src/lib/features/biome-feature.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAE5E,qBAAa,YAAa,YAAW,WAAW,CAAC,WAAW,EAAE,WAAW,CAAC;IACxE,MAAM,CAAC,QAAQ,CAAC,EAAE,mBAAmB;IACrC,QAAQ,CAAC,EAAE,mBAAmB;IAC9B,QAAQ,CAAC,QAAQ,EAAE,SAAS,SAAS,EAAE,CAAM;IAE7C,QAAQ,CAAC,IAAI,EAAE,iBAAiB,EAAE,MAAM,EAAE,WAAW,GAAG,WAAW;CAGpE"}

package/dist/lib/features/biome-feature.js

@@ -0,0 +1,9 @@
+import { FeatureId } from '../types/feature.js';
+export class BiomeFeature {
+    static id = FeatureId.Biome;
+    id = FeatureId.Biome;
+    requires = [];
+    generate(_ctx, config) {
+        return config;
+    }
+}

package/dist/lib/features/bridge-feature.d.ts

@@ -0,0 +1,10 @@
+import type { IMapFeature, GenerationContext } from '../types/feature.js';
+import { FeatureId } from '../types/feature.js';
+import type { BridgeConfig, BridgeOutput } from '../types/feature-configs.js';
+export declare class BridgeFeature implements IMapFeature<BridgeConfig, BridgeOutput> {
+    static readonly id = FeatureId.Bridge;
+    readonly id = FeatureId.Bridge;
+    readonly requires: readonly FeatureId[];
+    generate(ctx: GenerationContext, config: BridgeConfig): BridgeOutput;
+}
+//# sourceMappingURL=bridge-feature.d.ts.map

package/dist/lib/features/bridge-feature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge-feature.d.ts","sourceRoot":"","sources":["../../../src/lib/features/bridge-feature.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAe,MAAM,6BAA6B,CAAC;AAO3F,qBAAa,aAAc,YAAW,WAAW,CAAC,YAAY,EAAE,YAAY,CAAC;IAC3E,MAAM,CAAC,QAAQ,CAAC,EAAE,oBAAoB;IACtC,QAAQ,CAAC,EAAE,oBAAoB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,SAAS,SAAS,EAAE,CAAqB;IAE5D,QAAQ,CAAC,GAAG,EAAE,iBAAiB,EAAE,MAAM,EAAE,YAAY,GAAG,YAAY;CAsBrE"}

package/dist/lib/features/bridge-feature.js

@@ -0,0 +1,55 @@
+import { MathOps } from '@lagless/math';
+import { FeatureId } from '../types/feature.js';
+import { RiverFeature } from './river-feature.js';
+import { TerrainZone } from '../types/placed-object.js';
+import { Spline } from '../math/spline.js';
+export class BridgeFeature {
+    static id = FeatureId.Bridge;
+    id = FeatureId.Bridge;
+    requires = [FeatureId.River];
+    generate(ctx, config) {
+        const riverOutput = ctx.get(RiverFeature);
+        const bridges = [];
+        const counts = { medium: 0, large: 0, xlarge: 0 };
+        for (const river of riverOutput.normalRivers) {
+            if (river.looped)
+                continue;
+            const size = getBridgeSize(river.waterWidth);
+            if (counts[size] >= config.maxPerSize[size])
+                continue;
+            const bridgeTypeId = config.bridgeTypes[size];
+            const placed = placeBridge(ctx, river, bridgeTypeId);
+            if (placed) {
+                bridges.push(placed);
+                counts[size]++;
+            }
+        }
+        return { bridges };
+    }
+}
+function getBridgeSize(waterWidth) {
+    if (waterWidth >= 20)
+        return 'xlarge';
+    if (waterWidth >= 9)
+        return 'large';
+    return 'medium';
+}
+function placeBridge(ctx, river, bridgeTypeId) {
+    const spline = new Spline(river.splinePoints, false);
+    const t = 0.3 + ctx.random.getFloat() * 0.4;
+    const pos = spline.getPos(t);
+    const tangent = spline.getTangent(t);
+    const tangentLen = MathOps.sqrt(tangent.x * tangent.x + tangent.y * tangent.y);
+    if (tangentLen === 0)
+        return null;
+    const rotation = MathOps.atan2(tangent.y, tangent.x);
+    return {
+        typeId: bridgeTypeId,
+        posX: pos.x,
+        posY: pos.y,
+        rotation,
+        scale: 1,
+        terrainZone: TerrainZone.Bridge,
+        children: [],
+    };
+}

package/dist/lib/features/grass-feature.d.ts

@@ -0,0 +1,10 @@
+import type { IMapFeature, GenerationContext } from '../types/feature.js';
+import { FeatureId } from '../types/feature.js';
+import type { GrassConfig, GrassOutput } from '../types/feature-configs.js';
+export declare class GrassFeature implements IMapFeature<GrassConfig, GrassOutput> {
+    static readonly id = FeatureId.Grass;
+    readonly id = FeatureId.Grass;
+    readonly requires: readonly FeatureId[];
+    generate(ctx: GenerationContext, config: GrassConfig): GrassOutput;
+}
+//# sourceMappingURL=grass-feature.d.ts.map

package/dist/lib/features/grass-feature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grass-feature.d.ts","sourceRoot":"","sources":["../../../src/lib/features/grass-feature.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAe,MAAM,6BAA6B,CAAC;AAKzF,qBAAa,YAAa,YAAW,WAAW,CAAC,WAAW,EAAE,WAAW,CAAC;IACxE,MAAM,CAAC,QAAQ,CAAC,EAAE,mBAAmB;IACrC,QAAQ,CAAC,EAAE,mBAAmB;IAC9B,QAAQ,CAAC,QAAQ,EAAE,SAAS,SAAS,EAAE,CAAqB;IAE5D,QAAQ,CAAC,GAAG,EAAE,iBAAiB,EAAE,MAAM,EAAE,WAAW,GAAG,WAAW;CAgCnE"}

package/dist/lib/features/grass-feature.js

@@ -0,0 +1,36 @@
+import { MathOps } from '@lagless/math';
+import { FeatureId } from '../types/feature.js';
+import { ShoreFeature } from './shore-feature.js';
+import { polygonArea, computePolygonBounds } from '../math/polygon-utils.js';
+export class GrassFeature {
+    static id = FeatureId.Grass;
+    id = FeatureId.Grass;
+    requires = [FeatureId.Shore];
+    generate(ctx, config) {
+        const shore = ctx.get(ShoreFeature);
+        const centerX = ctx.center.x;
+        const centerY = ctx.center.y;
+        const points = shore.polygon.points.map((pos) => {
+            const dx = centerX - pos.x;
+            const dy = centerY - pos.y;
+            const len = MathOps.sqrt(dx * dx + dy * dy);
+            if (len === 0)
+                return { x: pos.x, y: pos.y };
+            const nx = dx / len;
+            const ny = dy / len;
+            const variation = (ctx.random.getFloat() * 2 - 1) * config.variation;
+            const inset = config.inset + variation;
+            return {
+                x: pos.x + nx * inset,
+                y: pos.y + ny * inset,
+            };
+        });
+        const bounds = computePolygonBounds(points);
+        const area = polygonArea(points);
+        return {
+            polygon: { points, count: points.length },
+            bounds,
+            area,
+        };
+    }
+}

package/dist/lib/features/ground-patch-feature.d.ts

@@ -0,0 +1,10 @@
+import type { IMapFeature, GenerationContext } from '../types/feature.js';
+import { FeatureId } from '../types/feature.js';
+import type { GroundPatchConfig, GroundPatchOutput } from '../types/feature-configs.js';
+export declare class GroundPatchFeature implements IMapFeature<GroundPatchConfig, GroundPatchOutput> {
+    static readonly id = FeatureId.GroundPatch;
+    readonly id = FeatureId.GroundPatch;
+    readonly requires: readonly FeatureId[];
+    generate(ctx: GenerationContext, config: GroundPatchConfig): GroundPatchOutput;
+}
+//# sourceMappingURL=ground-patch-feature.d.ts.map

package/dist/lib/features/ground-patch-feature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ground-patch-feature.d.ts","sourceRoot":"","sources":["../../../src/lib/features/ground-patch-feature.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAyB,MAAM,6BAA6B,CAAC;AAI/G,qBAAa,kBAAmB,YAAW,WAAW,CAAC,iBAAiB,EAAE,iBAAiB,CAAC;IAC1F,MAAM,CAAC,QAAQ,CAAC,EAAE,yBAAyB;IAC3C,QAAQ,CAAC,EAAE,yBAAyB;IACpC,QAAQ,CAAC,QAAQ,EAAE,SAAS,SAAS,EAAE,CAA+B;IAEtE,QAAQ,CAAC,GAAG,EAAE,iBAAiB,EAAE,MAAM,EAAE,iBAAiB,GAAG,iBAAiB;CAqD/E"}

package/dist/lib/features/ground-patch-feature.js

@@ -0,0 +1,57 @@
+import { MathOps } from '@lagless/math';
+import { FeatureId } from '../types/feature.js';
+import { ObjectPlacementFeature } from './object-placement-feature.js';
+export class GroundPatchFeature {
+    static id = FeatureId.GroundPatch;
+    id = FeatureId.GroundPatch;
+    requires = [FeatureId.ObjectPlacement];
+    generate(ctx, config) {
+        const placement = ctx.get(ObjectPlacementFeature);
+        const patches = [];
+        if (config.registry) {
+            for (const obj of placement.objects) {
+                const def = config.registry.get(obj.typeId);
+                if (!def?.groundPatches)
+                    continue;
+                for (const gpDef of def.groundPatches) {
+                    const scale = obj.scale;
+                    const rawOx = gpDef.offset.x * scale;
+                    const rawOy = gpDef.offset.y * scale;
+                    const cos = MathOps.cos(obj.rotation);
+                    const sin = MathOps.sin(obj.rotation);
+                    const ox = rawOx * cos - rawOy * sin;
+                    const oy = rawOx * sin + rawOy * cos;
+                    const hx = gpDef.halfExtents.x * scale;
+                    const hy = gpDef.halfExtents.y * scale;
+                    patches.push({
+                        minX: obj.posX + ox - hx,
+                        minY: obj.posY + oy - hy,
+                        maxX: obj.posX + ox + hx,
+                        maxY: obj.posY + oy + hy,
+                        color: gpDef.color,
+                        roughness: gpDef.roughness,
+                        offsetDist: gpDef.offsetDist,
+                        order: gpDef.order,
+                        useAsMapShape: gpDef.useAsMapShape,
+                    });
+                }
+            }
+        }
+        if (config.extraPatches) {
+            for (const gpDef of config.extraPatches) {
+                patches.push({
+                    minX: ctx.center.x + gpDef.offset.x - gpDef.halfExtents.x,
+                    minY: ctx.center.y + gpDef.offset.y - gpDef.halfExtents.y,
+                    maxX: ctx.center.x + gpDef.offset.x + gpDef.halfExtents.x,
+                    maxY: ctx.center.y + gpDef.offset.y + gpDef.halfExtents.y,
+                    color: gpDef.color,
+                    roughness: gpDef.roughness,
+                    offsetDist: gpDef.offsetDist,
+                    order: gpDef.order,
+                    useAsMapShape: gpDef.useAsMapShape,
+                });
+            }
+        }
+        return { patches };
+    }
+}

package/dist/lib/features/lake-feature.d.ts

@@ -0,0 +1,10 @@
+import type { IMapFeature, GenerationContext } from '../types/feature.js';
+import { FeatureId } from '../types/feature.js';
+import type { LakeConfig, LakeOutput } from '../types/feature-configs.js';
+export declare class LakeFeature implements IMapFeature<LakeConfig, LakeOutput> {
+    static readonly id = FeatureId.Lake;
+    readonly id = FeatureId.Lake;
+    readonly requires: readonly FeatureId[];
+    generate(ctx: GenerationContext, config: LakeConfig): LakeOutput;
+}
+//# sourceMappingURL=lake-feature.d.ts.map

package/dist/lib/features/lake-feature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lake-feature.d.ts","sourceRoot":"","sources":["../../../src/lib/features/lake-feature.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAO1E,qBAAa,WAAY,YAAW,WAAW,CAAC,UAAU,EAAE,UAAU,CAAC;IACrE,MAAM,CAAC,QAAQ,CAAC,EAAE,kBAAkB;IACpC,QAAQ,CAAC,EAAE,kBAAkB;IAC7B,QAAQ,CAAC,QAAQ,EAAE,SAAS,SAAS,EAAE,CAAM;IAE7C,QAAQ,CAAC,GAAG,EAAE,iBAAiB,EAAE,MAAM,EAAE,UAAU,GAAG,UAAU;CAmEjE"}