@lagless/2d-map-generator 0.0.48

package/dist/lib/math/jagged-aabb.js

@@ -0,0 +1,47 @@
+/**
+ * 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 function generateJaggedAabbPoints(aabb, divisionsX, divisionsY, variation, random) {
+    const llX = aabb.min.x;
+    const llY = aabb.min.y;
+    const lrX = aabb.max.x;
+    const lrY = aabb.min.y;
+    const ulX = aabb.min.x;
+    const ulY = aabb.max.y;
+    const urX = aabb.max.x;
+    const urY = aabb.max.y;
+    const distanceX = lrX - llX;
+    const distanceY = ulY - llY;
+    const spanX = distanceX / (divisionsX + 1);
+    const spanY = distanceY / (divisionsY + 1);
+    const points = [];
+    // Bottom edge: left → right
+    points.push({ x: llX, y: llY });
+    for (let i = 1; i <= divisionsX; i++) {
+        const vari = variation > 0 ? (random.getFloat() * 2 - 1) * variation : 0;
+        points.push({ x: llX + spanX * i, y: llY + vari });
+    }
+    // Right edge: bottom → top
+    points.push({ x: lrX, y: lrY });
+    for (let i = 1; i <= divisionsY; i++) {
+        const vari = variation > 0 ? (random.getFloat() * 2 - 1) * variation : 0;
+        points.push({ x: lrX + vari, y: lrY + spanY * i });
+    }
+    // Top edge: right → left
+    points.push({ x: urX, y: urY });
+    for (let i = 1; i <= divisionsX; i++) {
+        const vari = variation > 0 ? (random.getFloat() * 2 - 1) * variation : 0;
+        points.push({ x: urX - spanX * i, y: urY + vari });
+    }
+    // Left edge: top → bottom
+    points.push({ x: ulX, y: ulY });
+    for (let i = 1; i <= divisionsY; i++) {
+        const vari = variation > 0 ? (random.getFloat() * 2 - 1) * variation : 0;
+        points.push({ x: ulX + vari, y: ulY - spanY * i });
+    }
+    return points;
+}

package/dist/lib/math/polygon-utils.d.ts

@@ -0,0 +1,19 @@
+import type { ReadonlyVec2, AABB, Polygon } from '../types/geometry.js';
+/**
+ * Point-in-polygon test using ray casting algorithm.
+ * Uses AABB pre-check for early exit.
+ */
+export declare function pointInPolygon(point: ReadonlyVec2, polygon: Polygon): boolean;
+/**
+ * Polygon area via shoelace formula. Returns absolute value (positive regardless of winding).
+ */
+export declare function polygonArea(points: readonly ReadonlyVec2[]): number;
+/**
+ * Squared distance from a point to a line segment.
+ */
+export declare function distToSegmentSq(point: ReadonlyVec2, segA: ReadonlyVec2, segB: ReadonlyVec2): number;
+/**
+ * Compute AABB bounds for a set of points.
+ */
+export declare function computePolygonBounds(points: readonly ReadonlyVec2[]): AABB;
+//# sourceMappingURL=polygon-utils.d.ts.map

package/dist/lib/math/polygon-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/math/polygon-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAExE;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAkB7E;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,MAAM,CASnE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,YAAY,EAClB,IAAI,EAAE,YAAY,GACjB,MAAM,CAoBR;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,IAAI,CAiB1E"}

package/dist/lib/math/polygon-utils.js

@@ -0,0 +1,79 @@
+/**
+ * Point-in-polygon test using ray casting algorithm.
+ * Uses AABB pre-check for early exit.
+ */
+export function pointInPolygon(point, polygon) {
+    const pts = polygon.points;
+    const n = polygon.count;
+    if (n < 3)
+        return false;
+    let inside = false;
+    for (let i = 0, j = n - 1; i < n; j = i++) {
+        const xi = pts[i].x;
+        const yi = pts[i].y;
+        const xj = pts[j].x;
+        const yj = pts[j].y;
+        if (((yi > point.y) !== (yj > point.y)) &&
+            (point.x < (xj - xi) * (point.y - yi) / (yj - yi) + xi)) {
+            inside = !inside;
+        }
+    }
+    return inside;
+}
+/**
+ * Polygon area via shoelace formula. Returns absolute value (positive regardless of winding).
+ */
+export function polygonArea(points) {
+    const n = points.length;
+    if (n < 3)
+        return 0;
+    let area = 0;
+    for (let i = 0, j = n - 1; i < n; j = i++) {
+        area += (points[j].x + points[i].x) * (points[j].y - points[i].y);
+    }
+    return Math.abs(area) / 2;
+}
+/**
+ * Squared distance from a point to a line segment.
+ */
+export function distToSegmentSq(point, segA, segB) {
+    const dx = segB.x - segA.x;
+    const dy = segB.y - segA.y;
+    const lenSq = dx * dx + dy * dy;
+    if (lenSq === 0) {
+        // Degenerate segment (both points same)
+        const px = point.x - segA.x;
+        const py = point.y - segA.y;
+        return px * px + py * py;
+    }
+    let t = ((point.x - segA.x) * dx + (point.y - segA.y) * dy) / lenSq;
+    t = Math.max(0, Math.min(1, t));
+    const projX = segA.x + t * dx;
+    const projY = segA.y + t * dy;
+    const ex = point.x - projX;
+    const ey = point.y - projY;
+    return ex * ex + ey * ey;
+}
+/**
+ * Compute AABB bounds for a set of points.
+ */
+export function computePolygonBounds(points) {
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const p of points) {
+        if (p.x < minX)
+            minX = p.x;
+        if (p.y < minY)
+            minY = p.y;
+        if (p.x > maxX)
+            maxX = p.x;
+        if (p.y > maxY)
+            maxY = p.y;
+    }
+    return {
+        min: { x: minX, y: minY },
+        max: { x: maxX, y: maxY },
+    };
+}

package/dist/lib/math/river-polygon.d.ts

@@ -0,0 +1,12 @@
+import type { ReadonlyVec2 } from '../types/geometry.js';
+import type { GeneratedRiver } from '../types/generated-river.js';
+export interface RiverPolygonOptions {
+    splinePoints: ReadonlyVec2[];
+    waterWidth: number;
+    shoreWidth: number;
+    looped: boolean;
+    mapWidth: number;
+    mapHeight: number;
+}
+export declare function generateRiverPolygon(opts: RiverPolygonOptions): GeneratedRiver;
+//# sourceMappingURL=river-polygon.d.ts.map

package/dist/lib/math/river-polygon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"river-polygon.d.ts","sourceRoot":"","sources":["../../../src/lib/math/river-polygon.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAW,MAAM,sBAAsB,CAAC;AAClE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAIlE,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,YAAY,EAAE,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,mBAAmB,GAAG,cAAc,CA6E9E"}

package/dist/lib/math/river-polygon.js

@@ -0,0 +1,84 @@
+import { Spline } from './spline.js';
+import { computePolygonBounds } from './polygon-utils.js';
+export function generateRiverPolygon(opts) {
+    const { splinePoints, waterWidth, shoreWidth, looped, mapWidth, mapHeight } = opts;
+    const spline = new Spline(splinePoints, looped);
+    const numSamples = Math.max(splinePoints.length * 4, 20);
+    const waterLeft = [];
+    const waterRight = [];
+    const shoreLeft = [];
+    const shoreRight = [];
+    for (let i = 0; i <= numSamples; i++) {
+        const t = i / numSamples;
+        const pos = spline.getPos(t);
+        const normal = spline.getNormal(t);
+        let ww = waterWidth;
+        let sw = shoreWidth;
+        if (!looped) {
+            // Endpoint widening: (1 + end^3 * 1.5) * width
+            const end = 1 - Math.min(t, 1 - t) * 2; // 1 at endpoints, 0 at center
+            const endFactor = Math.max(0, end);
+            const widening = 1 + endFactor * endFactor * endFactor * 1.5;
+            ww *= widening;
+            sw *= widening;
+            // Map edge normal adjustment for flush ends
+            if (i === 0 || i === numSamples) {
+                const edgeNormal = getMapEdgeNormal(pos, mapWidth, mapHeight);
+                if (edgeNormal) {
+                    // Use edge normal instead of spline normal for flush alignment
+                    waterLeft.push({ x: pos.x + edgeNormal.x * ww, y: pos.y + edgeNormal.y * ww });
+                    waterRight.push({ x: pos.x - edgeNormal.x * ww, y: pos.y - edgeNormal.y * ww });
+                    shoreLeft.push({ x: pos.x + edgeNormal.x * (ww + sw), y: pos.y + edgeNormal.y * (ww + sw) });
+                    shoreRight.push({ x: pos.x - edgeNormal.x * (ww + sw), y: pos.y - edgeNormal.y * (ww + sw) });
+                    continue;
+                }
+            }
+        }
+        waterLeft.push({ x: pos.x + normal.x * ww, y: pos.y + normal.y * ww });
+        waterRight.push({ x: pos.x - normal.x * ww, y: pos.y - normal.y * ww });
+        shoreLeft.push({ x: pos.x + normal.x * (ww + sw), y: pos.y + normal.y * (ww + sw) });
+        shoreRight.push({ x: pos.x - normal.x * (ww + sw), y: pos.y - normal.y * (ww + sw) });
+    }
+    // For looped shapes (lakes), the spline winds CW in screen coords.
+    // The normal points inward, so waterRight/shoreRight are the outward boundaries.
+    const waterPoints = looped
+        ? [...waterRight, ...waterRight.slice(0, 1)]
+        : [...waterLeft, ...waterRight.reverse()];
+    const shorePoints = looped
+        ? [...shoreRight, ...shoreRight.slice(0, 1)]
+        : [...shoreLeft, ...shoreRight.reverse()];
+    const waterPoly = { points: waterPoints, count: waterPoints.length };
+    const shorePoly = { points: shorePoints, count: shorePoints.length };
+    // Compute center
+    let cx = 0, cy = 0;
+    for (const p of splinePoints) {
+        cx += p.x;
+        cy += p.y;
+    }
+    cx /= splinePoints.length;
+    cy /= splinePoints.length;
+    const allPoints = [...waterPoints, ...shorePoints];
+    const aabb = computePolygonBounds(allPoints);
+    return {
+        splinePoints,
+        waterWidth,
+        shoreWidth,
+        looped,
+        center: { x: cx, y: cy },
+        waterPoly,
+        shorePoly,
+        aabb,
+    };
+}
+function getMapEdgeNormal(pos, mapWidth, mapHeight) {
+    const edgeThreshold = 5;
+    if (pos.x <= edgeThreshold)
+        return { x: 0, y: 1 };
+    if (pos.x >= mapWidth - edgeThreshold)
+        return { x: 0, y: 1 };
+    if (pos.y <= edgeThreshold)
+        return { x: 1, y: 0 };
+    if (pos.y >= mapHeight - edgeThreshold)
+        return { x: 1, y: 0 };
+    return null;
+}

package/dist/lib/math/spline.d.ts

@@ -0,0 +1,15 @@
+import type { ReadonlyVec2 } from '../types/geometry.js';
+export declare class Spline {
+    readonly points: ReadonlyVec2[];
+    readonly arcLens: number[];
+    readonly totalArcLen: number;
+    readonly looped: boolean;
+    constructor(points: readonly ReadonlyVec2[], looped: boolean);
+    getPos(t: number): ReadonlyVec2;
+    getTangent(t: number): ReadonlyVec2;
+    getNormal(t: number): ReadonlyVec2;
+    getClosestTtoPoint(pos: ReadonlyVec2): number;
+    getTfromArcLen(arcLen: number): number;
+    getArcLen(t: number): number;
+}
+//# sourceMappingURL=spline.d.ts.map

package/dist/lib/math/spline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spline.d.ts","sourceRoot":"","sources":["../../../src/lib/math/spline.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAIzD,qBAAa,MAAM;IACjB,QAAQ,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;gBAEb,MAAM,EAAE,SAAS,YAAY,EAAE,EAAE,MAAM,EAAE,OAAO;IAsB5D,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,YAAY;IAQ/B,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,YAAY;IAQnC,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,YAAY;IASlC,kBAAkB,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM;IA0D7C,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAiBtC,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;CAS7B"}

package/dist/lib/math/spline.js

@@ -0,0 +1,127 @@
+import { MathOps } from '@lagless/math';
+import { catmullRom, catmullRomDerivative, getControlPoints } from './catmull-rom.js';
+import { distToSegmentSq } from './polygon-utils.js';
+export class Spline {
+    points;
+    arcLens;
+    totalArcLen;
+    looped;
+    constructor(points, looped) {
+        this.looped = looped;
+        this.points = points.map(p => ({ x: p.x, y: p.y }));
+        const arcLenSamples = points.length * 4;
+        this.arcLens = [];
+        let curX = this.points[0].x;
+        let curY = this.points[0].y;
+        for (let i = 0; i <= arcLenSamples; i++) {
+            const t = i / arcLenSamples;
+            const next = this.getPos(t);
+            const dx = next.x - curX;
+            const dy = next.y - curY;
+            const prevLen = i === 0 ? 0 : this.arcLens[i - 1];
+            this.arcLens[i] = prevLen + MathOps.sqrt(dx * dx + dy * dy);
+            curX = next.x;
+            curY = next.y;
+        }
+        this.totalArcLen = this.arcLens[this.arcLens.length - 1];
+    }
+    getPos(t) {
+        const { pt, p0, p1, p2, p3 } = getControlPoints(t, this.points, this.looped);
+        return {
+            x: catmullRom(pt, p0.x, p1.x, p2.x, p3.x),
+            y: catmullRom(pt, p0.y, p1.y, p2.y, p3.y),
+        };
+    }
+    getTangent(t) {
+        const { pt, p0, p1, p2, p3 } = getControlPoints(t, this.points, this.looped);
+        return {
+            x: catmullRomDerivative(pt, p0.x, p1.x, p2.x, p3.x),
+            y: catmullRomDerivative(pt, p0.y, p1.y, p2.y, p3.y),
+        };
+    }
+    getNormal(t) {
+        const tangent = this.getTangent(t);
+        const len = MathOps.sqrt(tangent.x * tangent.x + tangent.y * tangent.y);
+        if (len === 0)
+            return { x: 0, y: 1 };
+        const nx = tangent.x / len;
+        const ny = tangent.y / len;
+        return { x: -ny, y: nx };
+    }
+    getClosestTtoPoint(pos) {
+        let closestDistSq = Number.MAX_VALUE;
+        let closestSegIdx = 0;
+        for (let i = 0; i < this.points.length - 1; i++) {
+            const dSq = distToSegmentSq(pos, this.points[i], this.points[i + 1]);
+            if (dSq < closestDistSq) {
+                closestDistSq = dSq;
+                closestSegIdx = i;
+            }
+        }
+        const s0 = this.points[closestSegIdx];
+        const s1 = this.points[closestSegIdx + 1];
+        const segX = s1.x - s0.x;
+        const segY = s1.y - s0.y;
+        const segDot = segX * segX + segY * segY;
+        const proj = segDot > 0
+            ? Math.max(0, Math.min(1, ((pos.x - s0.x) * segX + (pos.y - s0.y) * segY) / segDot))
+            : 0;
+        const len = this.points.length - 1;
+        const tMin = Math.max(0, Math.min(1, (closestSegIdx + proj - 0.1) / len));
+        const tMax = Math.max(0, Math.min(1, (closestSegIdx + proj + 0.1) / len));
+        let nearestT = (closestSegIdx + proj) / len;
+        let nearestDistSq = Number.MAX_VALUE;
+        for (let i = 0; i <= 8; i++) {
+            const testT = tMin + (i / 8) * (tMax - tMin);
+            const testPos = this.getPos(testT);
+            const dx = testPos.x - pos.x;
+            const dy = testPos.y - pos.y;
+            const dSq = dx * dx + dy * dy;
+            if (dSq < nearestDistSq) {
+                nearestT = testT;
+                nearestDistSq = dSq;
+            }
+        }
+        const tangent = this.getTangent(nearestT);
+        const tanLen = MathOps.sqrt(tangent.x * tangent.x + tangent.y * tangent.y);
+        if (tanLen > 0) {
+            const nearest = this.getPos(nearestT);
+            const offset = (tangent.x * (pos.x - nearest.x) + tangent.y * (pos.y - nearest.y)) / tanLen;
+            const offsetT = nearestT + offset / (tanLen * len);
+            const offPos = this.getPos(offsetT);
+            const offDx = pos.x - offPos.x;
+            const offDy = pos.y - offPos.y;
+            const nDx = pos.x - nearest.x;
+            const nDy = pos.y - nearest.y;
+            if (offDx * offDx + offDy * offDy < nDx * nDx + nDy * nDy) {
+                nearestT = offsetT;
+            }
+        }
+        return nearestT;
+    }
+    getTfromArcLen(arcLen) {
+        arcLen = Math.max(0, Math.min(this.totalArcLen, arcLen));
+        let idx = 0;
+        while (idx < this.arcLens.length && arcLen > this.arcLens[idx]) {
+            idx++;
+        }
+        if (idx === 0)
+            return 0;
+        const prev = this.arcLens[idx - 1];
+        const curr = this.arcLens[idx];
+        const arcT = curr !== prev ? (arcLen - prev) / (curr - prev) : 0;
+        const arcCount = this.arcLens.length - 1;
+        const t0 = (idx - 1) / arcCount;
+        const t1 = idx / arcCount;
+        return t0 + arcT * (t1 - t0);
+    }
+    getArcLen(t) {
+        t = Math.max(0, Math.min(1, t));
+        const arcCount = this.arcLens.length - 1;
+        const idx0 = Math.floor(t * arcCount);
+        const idx1 = idx0 < arcCount ? idx0 + 1 : idx0;
+        const segLen = 1.0 / arcCount;
+        const arcT = segLen > 0 ? ((t % segLen) / segLen) : 0;
+        return this.arcLens[idx0] + arcT * (this.arcLens[idx1] - this.arcLens[idx0]);
+    }
+}

package/dist/lib/physics/canopy-sensor-tag.d.ts

@@ -0,0 +1,2 @@
+export declare const CANOPY_SENSOR_TAG = 1;
+//# sourceMappingURL=canopy-sensor-tag.d.ts.map

package/dist/lib/physics/canopy-sensor-tag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canopy-sensor-tag.d.ts","sourceRoot":"","sources":["../../../src/lib/physics/canopy-sensor-tag.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,IAAI,CAAC"}

package/dist/lib/physics/canopy-sensor-tag.js

@@ -0,0 +1 @@
+export const CANOPY_SENSOR_TAG = 1;

package/dist/lib/physics/create-map-colliders.d.ts

@@ -0,0 +1,12 @@
+import type { PlacedObject } from '../types/placed-object.js';
+import type { MapObjectRegistry } from '../types/object-def.js';
+export interface MapPhysicsProvider {
+    createFixedBody(x: number, y: number, rotation: number): unknown;
+    createCircleCollider(body: unknown, radius: number, offsetX: number, offsetY: number, isSensor: boolean, tag?: number, collisionGroup?: number): void;
+    createCuboidCollider(body: unknown, halfW: number, halfH: number, offsetX: number, offsetY: number, isSensor: boolean, tag?: number, collisionGroup?: number): void;
+}
+export interface CreateMapCollidersOptions {
+    skipTags?: readonly number[];
+}
+export declare function createMapColliders(physics: MapPhysicsProvider, objects: readonly PlacedObject[], registry: MapObjectRegistry, options?: CreateMapCollidersOptions): void;
+//# sourceMappingURL=create-map-colliders.d.ts.map

package/dist/lib/physics/create-map-colliders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-map-colliders.d.ts","sourceRoot":"","sources":["../../../src/lib/physics/create-map-colliders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAGhE,MAAM,WAAW,kBAAkB;IACjC,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IACjE,oBAAoB,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtJ,oBAAoB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACrK;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9B;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,kBAAkB,EAC3B,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,CAAC,EAAE,yBAAyB,GAClC,IAAI,CAIN"}

package/dist/lib/physics/create-map-colliders.js

@@ -0,0 +1,29 @@
+import { ShapeType } from '../types/geometry.js';
+export function createMapColliders(physics, objects, registry, options) {
+    for (const obj of objects) {
+        placeObject(physics, obj, registry, options);
+    }
+}
+function placeObject(physics, obj, registry, options) {
+    const def = registry.get(obj.typeId);
+    if (!def)
+        return;
+    const body = physics.createFixedBody(obj.posX, obj.posY, obj.rotation);
+    const skipTags = options?.skipTags;
+    for (const collider of def.colliders) {
+        if (skipTags && collider.tag !== undefined && skipTags.includes(collider.tag))
+            continue;
+        const ox = (collider.offsetX ?? 0) * obj.scale;
+        const oy = (collider.offsetY ?? 0) * obj.scale;
+        const isSensor = collider.isSensor ?? false;
+        if (collider.shape.type === ShapeType.Circle) {
+            physics.createCircleCollider(body, collider.shape.radius * obj.scale, ox, oy, isSensor, collider.tag, collider.collisionGroup);
+        }
+        else {
+            physics.createCuboidCollider(body, collider.shape.halfWidth * obj.scale, collider.shape.halfHeight * obj.scale, ox, oy, isSensor, collider.tag, collider.collisionGroup);
+        }
+    }
+    for (const child of obj.children) {
+        placeObject(physics, child, registry, options);
+    }
+}

package/dist/lib/presets/standard-biome.d.ts

@@ -0,0 +1,3 @@
+import type { BiomeConfig } from '../types/feature-configs.js';
+export declare const STANDARD_BIOME: BiomeConfig;
+//# sourceMappingURL=standard-biome.d.ts.map

package/dist/lib/presets/standard-biome.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-biome.d.ts","sourceRoot":"","sources":["../../../src/lib/presets/standard-biome.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAE/D,eAAO,MAAM,cAAc,EAAE,WAQ5B,CAAC"}

package/dist/lib/presets/standard-biome.js

@@ -0,0 +1,9 @@
+export const STANDARD_BIOME = {
+    background: 0x80af49,
+    water: 0x3d85c6,
+    waterRipple: 0x3478b2,
+    beach: 0xcdb35b,
+    riverbank: 0x905e24,
+    grass: 0x80af49,
+    underground: 0x1b0d00,
+};

package/dist/lib/presets/standard-map.d.ts

@@ -0,0 +1,6 @@
+import { MapGenerator } from '../core/map-generator.js';
+export interface StandardGeneratorOptions {
+    scale?: 'small' | 'large';
+}
+export declare function createStandardGenerator(options?: StandardGeneratorOptions): MapGenerator;
+//# sourceMappingURL=standard-map.d.ts.map

package/dist/lib/presets/standard-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-map.d.ts","sourceRoot":"","sources":["../../../src/lib/presets/standard-map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAYxD,MAAM,WAAW,wBAAwB;IACvC,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;CAC3B;AAED,wBAAgB,uBAAuB,CAAC,OAAO,CAAC,EAAE,wBAAwB,GAAG,YAAY,CAoDxF"}

package/dist/lib/presets/standard-map.js

@@ -0,0 +1,61 @@
+import { MapGenerator } from '../core/map-generator.js';
+import { BiomeFeature } from '../features/biome-feature.js';
+import { ShoreFeature } from '../features/shore-feature.js';
+import { GrassFeature } from '../features/grass-feature.js';
+import { RiverFeature } from '../features/river-feature.js';
+import { LakeFeature } from '../features/lake-feature.js';
+import { ObjectPlacementFeature } from '../features/object-placement-feature.js';
+import { PlacementKind } from '../types/feature-configs.js';
+import { TerrainZone } from '../types/placed-object.js';
+import { STANDARD_BIOME } from './standard-biome.js';
+import { StandardObjectType, STANDARD_OBJECT_REGISTRY } from './standard-objects.js';
+export function createStandardGenerator(options) {
+    const scaleFactor = options?.scale === 'large' ? 1.5 : 1.0;
+    const generator = new MapGenerator({
+        baseWidth: 720,
+        baseHeight: 720,
+        scale: scaleFactor,
+        extension: 80,
+        gridSize: 16,
+    });
+    generator
+        .addFeature(new BiomeFeature(), STANDARD_BIOME)
+        .addFeature(new ShoreFeature(), {
+        inset: 48,
+        divisions: 12,
+        variation: 4,
+    })
+        .addFeature(new GrassFeature(), {
+        inset: 18,
+        variation: 3,
+    })
+        .addFeature(new RiverFeature(), {
+        weights: [
+            { weight: 0.10, widths: [4] },
+            { weight: 0.25, widths: [8, 4] },
+            { weight: 0.20, widths: [16, 8, 4] },
+            { weight: 0.15, widths: [8, 6, 4] },
+            { weight: 0.15, widths: [8, 4] },
+            { weight: 0.15, widths: [4] },
+        ],
+        subdivisionPasses: 5,
+        masks: [],
+    })
+        .addFeature(new LakeFeature(), {
+        lakes: [
+            {
+                odds: 0.5,
+                innerRad: 30,
+                outerRad: 50,
+                spawnBound: { pos: { x: 0.5, y: 0.5 }, rad: 100 },
+            },
+        ],
+    })
+        .addFeature(new ObjectPlacementFeature(), {
+        registry: STANDARD_OBJECT_REGISTRY,
+        stages: [
+            { kind: PlacementKind.Density, typeId: StandardObjectType.Tree, density: 100, terrainZone: TerrainZone.Grass },
+        ],
+    });
+    return generator;
+}

package/dist/lib/presets/standard-objects.d.ts

@@ -0,0 +1,6 @@
+import type { MapObjectRegistry } from '../types/object-def.js';
+export declare enum StandardObjectType {
+    Tree = 0
+}
+export declare const STANDARD_OBJECT_REGISTRY: MapObjectRegistry;
+//# sourceMappingURL=standard-objects.d.ts.map

package/dist/lib/presets/standard-objects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-objects.d.ts","sourceRoot":"","sources":["../../../src/lib/presets/standard-objects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAI9E,oBAAY,kBAAkB;IAAG,IAAI,IAAI;CAAE;AAmB3C,eAAO,MAAM,wBAAwB,EAAE,iBAErC,CAAC"}

package/dist/lib/presets/standard-objects.js

@@ -0,0 +1,25 @@
+import { RenderLayer } from '../types/object-def.js';
+import { ShapeType } from '../types/geometry.js';
+export var StandardObjectType;
+(function (StandardObjectType) {
+    StandardObjectType[StandardObjectType["Tree"] = 0] = "Tree";
+})(StandardObjectType || (StandardObjectType = {}));
+const TREE_DEF = {
+    typeId: StandardObjectType.Tree,
+    colliders: [
+        { shape: { type: ShapeType.Circle, radius: 3 } },
+    ],
+    visuals: [
+        { texture: 'tree-trunk', layer: RenderLayer.Ground },
+        { texture: 'tree-foliage', layer: RenderLayer.Canopy },
+    ],
+    scaleRange: [0.8, 1.2],
+    mapDisplay: {
+        shapes: [
+            { collider: { type: ShapeType.Circle, radius: 3 }, color: 0x2d5a1e, scale: 1 },
+        ],
+    },
+};
+export const STANDARD_OBJECT_REGISTRY = new Map([
+    [StandardObjectType.Tree, TREE_DEF],
+]);

package/dist/lib/types/collision-provider.d.ts

@@ -0,0 +1,8 @@
+import type { MapCollisionShape } from './geometry.js';
+export interface ICollisionProvider {
+    addShape(id: number, shape: MapCollisionShape, posX: number, posY: number, rotation: number, scale: number): void;
+    testShape(shape: MapCollisionShape, posX: number, posY: number, rotation: number, scale: number): boolean;
+    removeShape(id: number): void;
+    clear(): void;
+}
+//# sourceMappingURL=collision-provider.d.ts.map

package/dist/lib/types/collision-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collision-provider.d.ts","sourceRoot":"","sources":["../../../src/lib/types/collision-provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEvD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAClH,SAAS,CAAC,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1G,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,KAAK,IAAI,IAAI,CAAC;CACf"}

package/dist/lib/types/collision-provider.js

@@ -0,0 +1 @@
+export {};