@lagless/2d-map-generator 0.0.48

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

@@ -0,0 +1,65 @@
+import { MathOps } from '@lagless/math';
+import { FeatureId } from '../types/feature.js';
+import { generateRiverPolygon } from '../math/river-polygon.js';
+const TWO_PI = Math.PI * 2;
+export class LakeFeature {
+    static id = FeatureId.Lake;
+    id = FeatureId.Lake;
+    requires = [];
+    generate(ctx, config) {
+        const lakes = [];
+        for (const lakeDef of config.lakes) {
+            if (ctx.random.getFloat() >= lakeDef.odds) {
+                continue;
+            }
+            const boundCenterX = lakeDef.spawnBound.pos.x * ctx.width;
+            const boundCenterY = lakeDef.spawnBound.pos.y * ctx.height;
+            const boundRad = lakeDef.spawnBound.rad;
+            const angle = ctx.random.getFloat() * TWO_PI;
+            const dist = ctx.random.getFloat() * boundRad;
+            const centerX = boundCenterX + MathOps.cos(angle) * dist;
+            const centerY = boundCenterY + MathOps.sin(angle) * dist;
+            const numPoints = 20;
+            const smoothPasses = 3;
+            // Generate raw radii with random variation
+            const rawRadii = [];
+            for (let i = 0; i < numPoints; i++) {
+                rawRadii.push(lakeDef.innerRad + ctx.random.getFloat() * (lakeDef.outerRad - lakeDef.innerRad));
+            }
+            // Smooth radii with circular moving average to eliminate star-shaped spikes
+            let radii = rawRadii;
+            for (let pass = 0; pass < smoothPasses; pass++) {
+                const smoothed = [];
+                for (let i = 0; i < numPoints; i++) {
+                    const prev = radii[(i - 1 + numPoints) % numPoints];
+                    const curr = radii[i];
+                    const next = radii[(i + 1) % numPoints];
+                    smoothed.push(prev * 0.25 + curr * 0.5 + next * 0.25);
+                }
+                radii = smoothed;
+            }
+            const splinePoints = [];
+            for (let i = 0; i < numPoints; i++) {
+                const theta = (i / numPoints) * TWO_PI;
+                splinePoints.push({
+                    x: centerX + MathOps.cos(theta) * radii[i],
+                    y: centerY + MathOps.sin(theta) * radii[i],
+                });
+            }
+            splinePoints.push({ x: splinePoints[0].x, y: splinePoints[0].y });
+            // Control points already define the lake boundary — waterWidth is a small outward expansion
+            const waterWidth = 2;
+            const shoreWidth = Math.max(4, Math.min(8, (lakeDef.innerRad + lakeDef.outerRad) * 0.1));
+            const lake = generateRiverPolygon({
+                splinePoints,
+                waterWidth,
+                shoreWidth,
+                looped: true,
+                mapWidth: ctx.width,
+                mapHeight: ctx.height,
+            });
+            lakes.push(lake);
+        }
+        return { lakes };
+    }
+}

package/dist/lib/features/object-placement-feature.d.ts

@@ -0,0 +1,18 @@
+import type { IMapFeature, GenerationContext } from '../types/feature.js';
+import { FeatureId } from '../types/feature.js';
+import type { ObjectPlacementConfig, ObjectPlacementOutput } from '../types/feature-configs.js';
+import type { MapObjectDef } from '../types/object-def.js';
+export declare class ObjectPlacementFeature implements IMapFeature<ObjectPlacementConfig, ObjectPlacementOutput> {
+    static readonly id = FeatureId.ObjectPlacement;
+    readonly id = FeatureId.ObjectPlacement;
+    readonly requires: readonly FeatureId[];
+    generate(ctx: GenerationContext, config: ObjectPlacementConfig): ObjectPlacementOutput;
+}
+export interface PlacementBounds {
+    readonly halfWidth: number;
+    readonly halfHeight: number;
+    readonly centerX: number;
+    readonly centerY: number;
+}
+export declare function computePlacementBounds(def: MapObjectDef): PlacementBounds | undefined;
+//# sourceMappingURL=object-placement-feature.d.ts.map

package/dist/lib/features/object-placement-feature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-placement-feature.d.ts","sourceRoot":"","sources":["../../../src/lib/features/object-placement-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,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAShG,OAAO,KAAK,EAAE,YAAY,EAAqB,MAAM,wBAAwB,CAAC;AAU9E,qBAAa,sBAAuB,YAAW,WAAW,CAAC,qBAAqB,EAAE,qBAAqB,CAAC;IACtG,MAAM,CAAC,QAAQ,CAAC,EAAE,6BAA6B;IAC/C,QAAQ,CAAC,EAAE,6BAA6B;IACxC,QAAQ,CAAC,QAAQ,EAAE,SAAS,SAAS,EAAE,CAAsC;IAE7E,QAAQ,CAAC,GAAG,EAAE,iBAAiB,EAAE,MAAM,EAAE,qBAAqB,GAAG,qBAAqB;CA6BvF;AAsBD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,YAAY,GAAG,eAAe,GAAG,SAAS,CAsCrF"}

package/dist/lib/features/object-placement-feature.js

@@ -0,0 +1,229 @@
+import { MathOps } from '@lagless/math';
+import { FeatureId } from '../types/feature.js';
+import { PlacementKind } from '../types/feature-configs.js';
+import { ShoreFeature } from './shore-feature.js';
+import { GrassFeature } from './grass-feature.js';
+import { RiverFeature } from './river-feature.js';
+import { LakeFeature } from './lake-feature.js';
+import { ShapeType } from '../types/geometry.js';
+import { TerrainQuery } from '../core/terrain-query.js';
+const MAX_ATTEMPTS_NORMAL = 500;
+const MAX_ATTEMPTS_IMPORTANT = 5000;
+const AREA_DENOMINATOR = 250000;
+const DEFAULT_ORIENTATIONS = [0];
+export class ObjectPlacementFeature {
+    static id = FeatureId.ObjectPlacement;
+    id = FeatureId.ObjectPlacement;
+    requires = [FeatureId.Shore, FeatureId.Grass];
+    generate(ctx, config) {
+        const objects = [];
+        const terrainQuery = new TerrainQuery({
+            shore: ctx.hasFeature(FeatureId.Shore) ? ctx.get(ShoreFeature) : undefined,
+            grass: ctx.hasFeature(FeatureId.Grass) ? ctx.get(GrassFeature) : undefined,
+            river: ctx.hasFeature(FeatureId.River) ? ctx.get(RiverFeature) : undefined,
+            lake: ctx.hasFeature(FeatureId.Lake) ? ctx.get(LakeFeature) : undefined,
+        });
+        for (const stage of config.stages) {
+            switch (stage.kind) {
+                case PlacementKind.Location:
+                    placeLocation(ctx, config.registry, stage, objects, terrainQuery);
+                    break;
+                case PlacementKind.Fixed:
+                    placeFixed(ctx, config.registry, stage, objects, terrainQuery);
+                    break;
+                case PlacementKind.Random:
+                    placeRandom(ctx, config.registry, stage, objects, terrainQuery);
+                    break;
+                case PlacementKind.Density:
+                    placeDensity(ctx, config.registry, stage, objects, terrainQuery);
+                    break;
+            }
+        }
+        return { objects };
+    }
+}
+function matchesZone(terrainQuery, x, y, zone) {
+    if (zone == null)
+        return true;
+    return terrainQuery.classify(x, y) === zone;
+}
+function matchesZoneCorners(terrainQuery, x, y, zone, bounds, scale) {
+    const hw = bounds.halfWidth * scale;
+    const hh = bounds.halfHeight * scale;
+    const cx = x + bounds.centerX * scale;
+    const cy = y + bounds.centerY * scale;
+    return terrainQuery.classify(cx - hw, cy - hh) === zone
+        && terrainQuery.classify(cx + hw, cy - hh) === zone
+        && terrainQuery.classify(cx - hw, cy + hh) === zone
+        && terrainQuery.classify(cx + hw, cy + hh) === zone;
+}
+export function computePlacementBounds(def) {
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    let count = 0;
+    for (const collider of def.colliders) {
+        if (collider.isSensor && !def.includeSensorsInBounds)
+            continue;
+        count++;
+        const ox = collider.offsetX ?? 0;
+        const oy = collider.offsetY ?? 0;
+        if (collider.shape.type === ShapeType.Circle) {
+            const r = collider.shape.radius;
+            minX = Math.min(minX, ox - r);
+            minY = Math.min(minY, oy - r);
+            maxX = Math.max(maxX, ox + r);
+            maxY = Math.max(maxY, oy + r);
+        }
+        else {
+            const hw = collider.shape.halfWidth;
+            const hh = collider.shape.halfHeight;
+            minX = Math.min(minX, ox - hw);
+            minY = Math.min(minY, oy - hh);
+            maxX = Math.max(maxX, ox + hw);
+            maxY = Math.max(maxY, oy + hh);
+        }
+    }
+    if (count === 0)
+        return undefined;
+    return {
+        halfWidth: (maxX - minX) / 2,
+        halfHeight: (maxY - minY) / 2,
+        centerX: (minX + maxX) / 2,
+        centerY: (minY + maxY) / 2,
+    };
+}
+function placeLocation(ctx, registry, stage, objects, terrainQuery) {
+    const def = registry.get(stage.typeId);
+    if (!def)
+        return;
+    const bounds = computePlacementBounds(def);
+    const maxAttempts = stage.maxAttempts ?? MAX_ATTEMPTS_IMPORTANT;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        const angle = ctx.random.getFloat() * Math.PI * 2;
+        const dist = ctx.random.getFloat() * stage.rad;
+        const x = stage.pos.x + MathOps.cos(angle) * dist;
+        const y = stage.pos.y + MathOps.sin(angle) * dist;
+        const placed = tryPlace(ctx, def, x, y, objects, terrainQuery, bounds);
+        if (placed)
+            return;
+    }
+    if (stage.optional)
+        return;
+    tryPlace(ctx, def, stage.pos.x, stage.pos.y, objects, terrainQuery, bounds);
+}
+function placeFixed(ctx, registry, stage, objects, terrainQuery) {
+    const def = registry.get(stage.typeId);
+    if (!def)
+        return;
+    const bounds = computePlacementBounds(def);
+    const maxAttempts = stage.important ? MAX_ATTEMPTS_IMPORTANT : MAX_ATTEMPTS_NORMAL;
+    for (let i = 0; i < stage.count; i++) {
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            const x = ctx.random.getFloat() * ctx.width;
+            const y = ctx.random.getFloat() * ctx.height;
+            if (!matchesZone(terrainQuery, x, y, stage.terrainZone))
+                continue;
+            if (tryPlace(ctx, def, x, y, objects, terrainQuery, bounds, stage.terrainZone))
+                break;
+        }
+    }
+}
+function placeRandom(ctx, registry, stage, objects, terrainQuery) {
+    const chosen = chooseN(ctx, stage.spawns, stage.choose);
+    for (const typeId of chosen) {
+        const def = registry.get(typeId);
+        if (!def)
+            continue;
+        const bounds = computePlacementBounds(def);
+        for (let attempt = 0; attempt < MAX_ATTEMPTS_NORMAL; attempt++) {
+            const x = ctx.random.getFloat() * ctx.width;
+            const y = ctx.random.getFloat() * ctx.height;
+            if (!matchesZone(terrainQuery, x, y, stage.terrainZone))
+                continue;
+            if (tryPlace(ctx, def, x, y, objects, terrainQuery, bounds, stage.terrainZone))
+                break;
+        }
+    }
+}
+function placeDensity(ctx, registry, stage, objects, terrainQuery) {
+    const def = registry.get(stage.typeId);
+    if (!def)
+        return;
+    const bounds = computePlacementBounds(def);
+    const mapArea = ctx.width * ctx.height;
+    const count = Math.round(stage.density * (mapArea / AREA_DENOMINATOR));
+    for (let i = 0; i < count; i++) {
+        for (let attempt = 0; attempt < MAX_ATTEMPTS_NORMAL; attempt++) {
+            const x = ctx.random.getFloat() * ctx.width;
+            const y = ctx.random.getFloat() * ctx.height;
+            if (!matchesZone(terrainQuery, x, y, stage.terrainZone))
+                continue;
+            if (tryPlace(ctx, def, x, y, objects, terrainQuery, bounds, stage.terrainZone))
+                break;
+        }
+    }
+}
+function tryPlace(ctx, def, x, y, objects, terrainQuery, bounds, terrainZone) {
+    const scale = def.scaleRange[0] + ctx.random.getFloat() * (def.scaleRange[1] - def.scaleRange[0]);
+    const orientations = def.orientations ?? DEFAULT_ORIENTATIONS;
+    const ori = orientations[ctx.random.getRandomInt(0, orientations.length)];
+    if (bounds) {
+        const collisionX = x + bounds.centerX * scale;
+        const collisionY = y + bounds.centerY * scale;
+        const collisionShape = {
+            type: ShapeType.Cuboid,
+            halfWidth: bounds.halfWidth * scale,
+            halfHeight: bounds.halfHeight * scale,
+        };
+        if (ctx.collision.testShape(collisionShape, collisionX, collisionY, ori, 1)) {
+            return false;
+        }
+        // Corner terrain check: all 4 AABB corners must match the required zone
+        if (terrainZone != null && !matchesZoneCorners(terrainQuery, x, y, terrainZone, bounds, scale)) {
+            return false;
+        }
+        ctx.collision.addShape(objects.length, collisionShape, collisionX, collisionY, ori, 1);
+    }
+    const zone = terrainQuery.classify(x, y);
+    const children = [];
+    if (def.children) {
+        for (const childDef of def.children) {
+            const childX = x + childDef.offset.x * scale;
+            const childY = y + childDef.offset.y * scale;
+            const childOri = childDef.inheritOri ? ori + childDef.ori : childDef.ori;
+            children.push({
+                typeId: childDef.typeId,
+                posX: childX,
+                posY: childY,
+                rotation: childOri,
+                scale: childDef.scale * scale,
+                terrainZone: terrainQuery.classify(childX, childY),
+                children: [],
+            });
+        }
+    }
+    objects.push({
+        typeId: def.typeId,
+        posX: x,
+        posY: y,
+        rotation: ori,
+        scale,
+        terrainZone: zone,
+        children,
+    });
+    return true;
+}
+function chooseN(ctx, items, n) {
+    if (n >= items.length)
+        return [...items];
+    const available = [...items];
+    const result = [];
+    for (let i = 0; i < n; i++) {
+        const idx = ctx.random.getRandomInt(0, available.length);
+        result.push(available[idx]);
+        available.splice(idx, 1);
+    }
+    return result;
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"places-feature.d.ts","sourceRoot":"","sources":["../../../src/lib/features/places-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,YAAY,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE9E,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,CAAM;IAE7C,QAAQ,CAAC,GAAG,EAAE,iBAAiB,EAAE,MAAM,EAAE,YAAY,GAAG,YAAY;CASrE"}

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

@@ -0,0 +1,14 @@
+import { FeatureId } from '../types/feature.js';
+export class PlacesFeature {
+    static id = FeatureId.Places;
+    id = FeatureId.Places;
+    requires = [];
+    generate(ctx, config) {
+        const places = config.places.map(p => ({
+            name: p.name,
+            x: p.pos.x * ctx.width,
+            y: p.pos.y * ctx.height,
+        }));
+        return { places };
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"river-feature.d.ts","sourceRoot":"","sources":["../../../src/lib/features/river-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;AAK5E,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,GAAG,EAAE,iBAAiB,EAAE,MAAM,EAAE,WAAW,GAAG,WAAW;CAgCnE"}

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

@@ -0,0 +1,122 @@
+import { MathOps } from '@lagless/math';
+import { FeatureId } from '../types/feature.js';
+import { generateRiverPolygon } from '../math/river-polygon.js';
+export class RiverFeature {
+    static id = FeatureId.River;
+    id = FeatureId.River;
+    requires = [];
+    generate(ctx, config) {
+        const widths = selectWeightedWidths(ctx, config.weights);
+        const rivers = [];
+        for (const waterWidth of widths) {
+            const splinePoints = generateRiverPoints(ctx, config.subdivisionPasses, config.masks);
+            if (splinePoints.length < 2)
+                continue;
+            const shoreWidth = Math.max(4, Math.min(8, waterWidth * 0.75));
+            const river = generateRiverPolygon({
+                splinePoints,
+                waterWidth,
+                shoreWidth,
+                looped: false,
+                mapWidth: ctx.width,
+                mapHeight: ctx.height,
+            });
+            rivers.push(river);
+        }
+        return {
+            rivers,
+            normalRivers: rivers,
+        };
+    }
+}
+function selectWeightedWidths(ctx, weights) {
+    if (weights.length === 0)
+        return [];
+    let totalWeight = 0;
+    for (const w of weights) {
+        totalWeight += w.weight;
+    }
+    let roll = ctx.random.getFloat() * totalWeight;
+    for (const w of weights) {
+        roll -= w.weight;
+        if (roll <= 0) {
+            return w.widths;
+        }
+    }
+    return weights[weights.length - 1].widths;
+}
+function generateRiverPoints(ctx, subdivisionPasses, masks) {
+    const { width, height, random } = ctx;
+    const edge = random.getRandomInt(0, 4);
+    let start;
+    let end;
+    switch (edge) {
+        case 0:
+            start = { x: 0, y: random.getFloat() * height };
+            end = { x: width, y: random.getFloat() * height };
+            break;
+        case 1:
+            start = { x: width, y: random.getFloat() * height };
+            end = { x: 0, y: random.getFloat() * height };
+            break;
+        case 2:
+            start = { x: random.getFloat() * width, y: 0 };
+            end = { x: random.getFloat() * width, y: height };
+            break;
+        default:
+            start = { x: random.getFloat() * width, y: height };
+            end = { x: random.getFloat() * width, y: 0 };
+            break;
+    }
+    let points = [start, end];
+    for (let pass = 0; pass < subdivisionPasses; pass++) {
+        const newPoints = [points[0]];
+        for (let i = 0; i < points.length - 1; i++) {
+            const a = points[i];
+            const b = points[i + 1];
+            const mx = (a.x + b.x) * 0.5;
+            const my = (a.y + b.y) * 0.5;
+            const dx = b.x - a.x;
+            const dy = b.y - a.y;
+            const dist = MathOps.sqrt(dx * dx + dy * dy);
+            const perpX = dist > 0 ? -dy / dist : 0;
+            const perpY = dist > 0 ? dx / dist : 0;
+            const offset = (random.getFloat() * 2 - 1) * (dist / 7);
+            const midpoint = {
+                x: mx + perpX * offset,
+                y: my + perpY * offset,
+            };
+            newPoints.push(midpoint);
+            newPoints.push(b);
+        }
+        points = newPoints;
+    }
+    if (masks.length > 0) {
+        points = filterMaskedPoints(points, masks);
+    }
+    return points;
+}
+function filterMaskedPoints(points, masks) {
+    if (points.length <= 2)
+        return points;
+    const filtered = [points[0]];
+    for (let i = 1; i < points.length - 1; i++) {
+        const pt = points[i];
+        let masked = false;
+        for (const mask of masks) {
+            const cx = mask.pos ? mask.pos.x : 0;
+            const cy = mask.pos ? mask.pos.y : 0;
+            const dx = pt.x - cx;
+            const dy = pt.y - cy;
+            if (dx * dx + dy * dy < mask.rad * mask.rad) {
+                masked = true;
+                break;
+            }
+        }
+        if (!masked) {
+            filtered.push(pt);
+        }
+    }
+    filtered.push(points[points.length - 1]);
+    return filtered;
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"shore-feature.d.ts","sourceRoot":"","sources":["../../../src/lib/features/shore-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;AAK5E,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,GAAG,EAAE,iBAAiB,EAAE,MAAM,EAAE,WAAW,GAAG,WAAW;CAqBnE"}

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

@@ -0,0 +1,20 @@
+import { FeatureId } from '../types/feature.js';
+import { generateJaggedAabbPoints } from '../math/jagged-aabb.js';
+import { computePolygonBounds } from '../math/polygon-utils.js';
+export class ShoreFeature {
+    static id = FeatureId.Shore;
+    id = FeatureId.Shore;
+    requires = [];
+    generate(ctx, config) {
+        const shoreAabb = {
+            min: { x: config.inset, y: config.inset },
+            max: { x: ctx.width - config.inset, y: ctx.height - config.inset },
+        };
+        const points = generateJaggedAabbPoints(shoreAabb, config.divisions, config.divisions, config.variation, ctx.random);
+        const bounds = computePolygonBounds(points);
+        return {
+            polygon: { points, count: points.length },
+            bounds,
+        };
+    }
+}

package/dist/lib/math/catmull-rom.d.ts

@@ -0,0 +1,12 @@
+import type { ReadonlyVec2 } from '../types/geometry.js';
+export declare function catmullRom(t: number, p0: number, p1: number, p2: number, p3: number): number;
+export declare function catmullRomDerivative(t: number, p0: number, p1: number, p2: number, p3: number): number;
+export interface ControlPointResult {
+    pt: number;
+    p0: ReadonlyVec2;
+    p1: ReadonlyVec2;
+    p2: ReadonlyVec2;
+    p3: ReadonlyVec2;
+}
+export declare function getControlPoints(t: number, points: readonly ReadonlyVec2[], looped: boolean): ControlPointResult;
+//# sourceMappingURL=catmull-rom.d.ts.map

package/dist/lib/math/catmull-rom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catmull-rom.d.ts","sourceRoot":"","sources":["../../../src/lib/math/catmull-rom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAO5F;AAED,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAMtG;AAED,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,YAAY,CAAC;IACjB,EAAE,EAAE,YAAY,CAAC;IACjB,EAAE,EAAE,YAAY,CAAC;IACjB,EAAE,EAAE,YAAY,CAAC;CAClB;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,YAAY,EAAE,EAAE,MAAM,EAAE,OAAO,GAAG,kBAAkB,CA+BhH"}

package/dist/lib/math/catmull-rom.js

@@ -0,0 +1,42 @@
+export function catmullRom(t, p0, p1, p2, p3) {
+    return 0.5 * (2.0 * p1 +
+        t * (-p0 + p2) +
+        t * t * (2.0 * p0 - 5.0 * p1 + 4.0 * p2 - p3) +
+        t * t * t * (-p0 + 3.0 * p1 - 3.0 * p2 + p3));
+}
+export function catmullRomDerivative(t, p0, p1, p2, p3) {
+    return 0.5 * (-p0 + p2 +
+        2.0 * t * (2.0 * p0 - 5.0 * p1 + 4.0 * p2 - p3) +
+        3.0 * t * t * (-p0 + 3.0 * p1 - 3.0 * p2 + p3));
+}
+export function getControlPoints(t, points, looped) {
+    const count = points.length;
+    let i;
+    let i0;
+    let i1;
+    let i2;
+    let i3;
+    if (looped) {
+        t = ((t % 1.0) + 1.0) % 1.0; // fmod that handles negatives
+        i = ~~(t * (count - 1));
+        i1 = i;
+        i2 = (i1 + 1) % (count - 1);
+        i0 = i1 > 0 ? i1 - 1 : count - 2;
+        i3 = (i2 + 1) % (count - 1);
+    }
+    else {
+        t = Math.max(0, Math.min(1, t));
+        i = ~~(t * (count - 1));
+        i1 = i === count - 1 ? i - 1 : i;
+        i2 = i1 + 1;
+        i0 = i1 > 0 ? i1 - 1 : i1;
+        i3 = i2 < count - 1 ? i2 + 1 : i2;
+    }
+    return {
+        pt: t * (count - 1) - i1,
+        p0: points[i0],
+        p1: points[i1],
+        p2: points[i2],
+        p3: points[i3],
+    };
+}

package/dist/lib/math/collision-test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Test circle vs circle overlap.
+ */
+export declare function testCircleCircle(ax: number, ay: number, ar: number, bx: number, by: number, br: number): boolean;
+/**
+ * Test circle vs AABB overlap.
+ * AABB defined by (minX, minY) to (maxX, maxY).
+ */
+export declare function testCircleAabb(cx: number, cy: number, cr: number, minX: number, minY: number, maxX: number, maxY: number): boolean;
+/**
+ * Test AABB vs AABB overlap.
+ */
+export declare function testAabbAabb(aMinX: number, aMinY: number, aMaxX: number, aMaxY: number, bMinX: number, bMinY: number, bMaxX: number, bMaxY: number): boolean;
+//# sourceMappingURL=collision-test.d.ts.map

package/dist/lib/math/collision-test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collision-test.d.ts","sourceRoot":"","sources":["../../../src/lib/math/collision-test.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAClC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GACjC,OAAO,CAMT;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAClC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GACrD,OAAO,CAQT;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAC1D,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GACzD,OAAO,CAGT"}

package/dist/lib/math/collision-test.js

@@ -0,0 +1,29 @@
+/**
+ * Test circle vs circle overlap.
+ */
+export function testCircleCircle(ax, ay, ar, bx, by, br) {
+    const dx = bx - ax;
+    const dy = by - ay;
+    const distSq = dx * dx + dy * dy;
+    const rSum = ar + br;
+    return distSq <= rSum * rSum;
+}
+/**
+ * Test circle vs AABB overlap.
+ * AABB defined by (minX, minY) to (maxX, maxY).
+ */
+export function testCircleAabb(cx, cy, cr, minX, minY, maxX, maxY) {
+    // Find closest point on AABB to circle center
+    const closestX = Math.max(minX, Math.min(cx, maxX));
+    const closestY = Math.max(minY, Math.min(cy, maxY));
+    const dx = cx - closestX;
+    const dy = cy - closestY;
+    return (dx * dx + dy * dy) <= cr * cr;
+}
+/**
+ * Test AABB vs AABB overlap.
+ */
+export function testAabbAabb(aMinX, aMinY, aMaxX, aMaxY, bMinX, bMinY, bMaxX, bMaxY) {
+    return aMinX <= bMaxX && aMaxX >= bMinX &&
+        aMinY <= bMaxY && aMaxY >= bMinY;
+}

package/dist/lib/math/jagged-aabb.d.ts

@@ -0,0 +1,12 @@
+import type { IVector2Like } from '@lagless/math';
+import type { AABB } from '../types/geometry.js';
+import type { ISeededRandom } from '../types/prng-interface.js';
+/**
+ * Generates jagged polygon points around an AABB border.
+ * Counter-clockwise winding: bottom→right→top→left.
+ * Corner points are NOT offset. Intermediate points are offset by random variation.
+ *
+ * Port of survev/shared/utils/terrainGen.ts:15-56.
+ */
+export declare function generateJaggedAabbPoints(aabb: AABB, divisionsX: number, divisionsY: number, variation: number, random: ISeededRandom): IVector2Like[];
+//# sourceMappingURL=jagged-aabb.d.ts.map

package/dist/lib/math/jagged-aabb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jagged-aabb.d.ts","sourceRoot":"","sources":["../../../src/lib/math/jagged-aabb.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAEhE;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,IAAI,EACV,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,aAAa,GACpB,YAAY,EAAE,CA8ChB"}