@pascal-app/core 1.0.6 → 1.0.7

package/dist/systems/wall/wall-topology.js

@@ -1,9 +1,12 @@
 import { GROUND_SUPPORT_ID } from '../../hooks/spatial-grid/support-host-id.js';
+import { getDoorOpeningSize } from '../../lib/door-opening.js';
 import { withFoundationConstruction } from '../../lib/foundation-wall.js';
+import { openingHostFacing } from '../../lib/opening-casing.js';
 import { detectOpenWallEnds, wallEndJoinCandidates } from '../../lib/room-graph.js';
 import { terrainSupportLift } from '../../lib/terrain-support.js';
-import { getScaledDimensions, WallNode as WallSchema, } from '../../schema/index.js';
+import { getScaledDimensions, SeparatorNode, WallNode as WallSchema, } from '../../schema/index.js';
 import { getWallArcData, getWallCurveFrameAt, getWallCurveLength, isCurvedWall } from './wall-curve.js';
+import { getWallFaceOffsets } from './wall-frame.js';
 export const WALL_MIN_LENGTH = 0.01;
 const WALL_SPLIT_ENDPOINT_EPSILON = 0.02;
 const WALL_INTERSECTION_EPSILON = 1e-6;
@@ -114,6 +117,25 @@ function projectPointOntoWallCenterline(point, wall) {
         wallT,
     };
 }
+/**
+ * How near `end` of `host` a join on `host` counts as that end: the split
+ * epsilon, or as far as the bodies of the other walls meeting there reach, so a
+ * join inside a corner block takes the corner rather than splitting off a stub
+ * of `host` buried in it.
+ */
+function cornerBlockReach(end, host, walls, ignoreWallIds) {
+    let reach = WALL_SPLIT_ENDPOINT_EPSILON;
+    for (const other of walls) {
+        if (other.id === host.id || ignoreWallIds.has(other.id))
+            continue;
+        if (distanceSquared(other.start, end) > 1e-12 && distanceSquared(other.end, end) > 1e-12) {
+            continue;
+        }
+        const { a, b } = getWallFaceOffsets(other);
+        reach = Math.max(reach, a, -b);
+    }
+    return reach;
+}
 function nearestWallProjection(point, walls, radius, ignoreWallIds = new Set()) {
     let best = null;
     let bestDistance = Number.POSITIVE_INFINITY;
@@ -126,8 +148,10 @@ function nearestWallProjection(point, walls, radius, ignoreWallIds = new Set())
         const candidateDistance = distanceSquared(point, projection.point);
         if (candidateDistance > radius * radius || candidateDistance >= bestDistance)
             continue;
-        const corner = [wall.start, wall.end].find((candidate) => distanceSquared(projection.point, candidate) <=
-            WALL_SPLIT_ENDPOINT_EPSILON * WALL_SPLIT_ENDPOINT_EPSILON);
+        const corner = [wall.start, wall.end].find((candidate) => {
+            const reach = cornerBlockReach(candidate, wall, walls, ignoreWallIds);
+            return distanceSquared(projection.point, candidate) <= reach * reach;
+        });
         best = corner
             ? { wall: null, point: [corner[0], corner[1]], wallT: projection.wallT }
             : { wall, ...projection };
@@ -259,13 +283,16 @@ function segmentCurveOffset(wall, startT, endT) {
     const angle = Math.abs(arc.delta) * (endT - startT);
     return arc.direction * arc.radius * (1 - Math.cos(angle / 2));
 }
-function attachmentSpan(node) {
+/** Where a door, window or wall item sits along its wall: metres from the wall start. */
+export function wallAttachmentSpan(node) {
     if (node.type === 'door') {
         const door = node;
+        const size = getDoorOpeningSize(door);
+        const center = door.position[0] - size.leafOffsetX * openingHostFacing(door);
         return {
-            min: door.position[0] - door.width / 2,
-            max: door.position[0] + door.width / 2,
-            center: door.position[0],
+            min: center - size.width / 2,
+            max: center + size.width / 2,
+            center,
         };
     }
     if (node.type === 'window') {
@@ -352,7 +379,7 @@ export function splitWall(wall, splitParameters, nodes, mintId) {
     const segmentChildren = segments.map(() => []);
     const updates = [];
     for (const attachment of wallAttachments(wall, nodes)) {
-        const span = attachmentSpan(attachment);
+        const span = wallAttachmentSpan(attachment);
         if (!span)
             return null;
         const segmentIndex = parameters.slice(0, -1).findIndex((startT, index) => {
@@ -379,7 +406,7 @@ export function planWallInsertion(nodes, args) {
     const startProjection = nearestWallProjection(args.start, walls, args.joinRadius);
     const resolvedStart = startProjection?.point ?? args.start;
     const resolvedEnd = endProjection?.point ?? args.end;
-    if (wallSegmentsCoverSegment(resolvedStart, resolvedEnd, walls)) {
+    if (!args.replaceCovered && wallSegmentsCoverSegment(resolvedStart, resolvedEnd, walls)) {
         return { ok: false, reason: 'covered-existing-wall' };
     }
     const crossings = walls
@@ -469,6 +496,87 @@ export function planWallInsertion(nodes, args) {
     };
     return { ok: true, plan };
 }
+/**
+ * The stretches of `start` → `end` no line already closes rooms along: an invisible wall on it or
+ * a straight wall's reference line. Two lines on top of each other close no room; they leave a
+ * sliver between them.
+ */
+function uncoveredStretches(start, end, lines) {
+    const length = Math.hypot(end[0] - start[0], end[1] - start[1]);
+    const dir = [(end[0] - start[0]) / length, (end[1] - start[1]) / length];
+    const along = (point) => (point[0] - start[0]) * dir[0] + (point[1] - start[1]) * dir[1];
+    const at = (t) => t <= 0 ? start : t >= length ? end : [start[0] + dir[0] * t, start[1] + dir[1] * t];
+    const covered = lines
+        .flatMap((line) => {
+        if (distanceToLine(line.start, start, end) > 1e-3 ||
+            distanceToLine(line.end, start, end) > 1e-3)
+            return [];
+        const a = along(line.start);
+        const b = along(line.end);
+        const lo = Math.max(0, Math.min(a, b));
+        const hi = Math.min(length, Math.max(a, b));
+        return hi - lo > 1e-6 ? [[lo, hi]] : [];
+    })
+        .sort((a, b) => a[0] - b[0]);
+    const stretches = [];
+    let reach = 0;
+    for (const [lo, hi] of covered) {
+        if (lo > reach + 1e-6)
+            stretches.push([at(reach), at(lo)]);
+        reach = Math.max(reach, hi);
+    }
+    if (reach < length - 1e-6)
+        stretches.push([at(reach), at(length)]);
+    return stretches;
+}
+/**
+ * An invisible wall drawn `start` → `end` (a room divider): a room separator, so
+ * rooms close on it as on a wall, but it is no wall and cuts none. An end landing on a wall joins
+ * it on its reference line, where the room graph meets it (a join inside a corner block takes the
+ * corner), and the line breaks either side of a wall it crosses so each piece tees into it. A
+ * stretch drawn over an invisible wall or along a wall's reference line adds nothing. Null when
+ * nothing is left to add, or it would be too short.
+ */
+export function planSeparatorInsertion(nodes, args) {
+    const walls = Object.values(nodes).filter((node) => node.type === 'wall' && node.parentId === args.levelId);
+    const resolvedStart = nearestWallProjection(args.start, walls, args.joinRadius)?.point ?? args.start;
+    const resolvedEnd = nearestWallProjection(args.end, walls, args.joinRadius)?.point ?? args.end;
+    if (!isSegmentLongEnough(resolvedStart, resolvedEnd))
+        return null;
+    const crossings = walls
+        .flatMap((wall) => isCurvedWall(wall)
+        ? curvedSegmentIntersections(resolvedStart, resolvedEnd, wall)
+        : [straightSegmentIntersection(resolvedStart, resolvedEnd, wall)].filter((crossing) => crossing !== null))
+        .map((crossing) => joinCrossingAtNearbyWallEndpoint(crossing, walls))
+        .filter(({ draftT }) => draftT > WALL_INTERSECTION_EPSILON && draftT < 1 - WALL_INTERSECTION_EPSILON)
+        .sort((left, right) => left.draftT - right.draftT);
+    const vertices = [resolvedStart];
+    for (const { point } of crossings)
+        if (!vertices.some((vertex) => distanceSquared(vertex, point) <= 1e-12))
+            vertices.push(point);
+    vertices.push(resolvedEnd);
+    const lines = [
+        ...Object.values(nodes).filter((node) => node.type === 'separator' && node.parentId === args.levelId),
+        ...walls.filter((wall) => !isCurvedWall(wall)),
+    ];
+    const separators = vertices
+        .slice(0, -1)
+        .flatMap((start, index) => uncoveredStretches(start, vertices[index + 1], lines))
+        .filter(([from, to]) => isSegmentLongEnough(from, to))
+        .map(([start, end]) => SeparatorNode.parse({ id: args.mintId?.(), parentId: args.levelId, start, end }));
+    if (!separators.length)
+        return null;
+    return {
+        changes: {
+            create: separators.map((node) => ({ node, parentId: args.levelId })),
+            update: [],
+            delete: [],
+        },
+        separators,
+        resolvedStart,
+        resolvedEnd,
+    };
+}
 function distanceToLine(point, a, b) {
     const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
     return Math.abs((point[0] - a[0]) * (b[1] - a[1]) - (point[1] - a[1]) * (b[0] - a[0])) / length;
@@ -561,7 +669,7 @@ function planWallEndJoin(nodes, openEnd, cornerPoint) {
         const dz = (after.end[1] - after.start[1]) / length;
         const oldLength = wallLength(before);
         for (const attachment of wallAttachments(before, adjusted)) {
-            const span = attachmentSpan(attachment);
+            const span = wallAttachmentSpan(attachment);
             if (!span)
                 return false;
             const oldPoint = getWallCurveFrameAt(before, span.center / oldLength).point;

package/dist/systems/wall/wall-trim-profiles.d.ts

@@ -0,0 +1,12 @@
+import type { WallTrimKind, WallTrimProfile } from '../../schema/nodes/wall.js';
+/**
+ * How a wall trim stands out across its height: `proudAt(t)` is the share of the trim's `proud`
+ * at height fraction `t` (0 at its bottom edge, 1 at its top), sampled `samples` times. Pure data
+ * for the wall's skirting, crown and chair rail and for the mouldings of an opening's surround.
+ */
+export type TrimProfileDefinition = {
+    samples: number;
+    proudAt: (t: number) => number;
+};
+export declare const TRIM_PROFILES: Record<WallTrimKind, Partial<Record<WallTrimProfile, TrimProfileDefinition>>>;
+//# sourceMappingURL=wall-trim-profiles.d.ts.map

package/dist/systems/wall/wall-trim-profiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-trim-profiles.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-trim-profiles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AAE5E;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;CAC/B,CAAA;AAWD,eAAO,MAAM,aAAa,EAAE,MAAM,CAChC,YAAY,EACZ,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,qBAAqB,CAAC,CAAC,CAqKxD,CAAA"}

package/dist/systems/wall/wall-trim-profiles.js

@@ -0,0 +1,191 @@
+function clamp01(value) {
+    return Math.max(0, Math.min(1, value));
+}
+function eased(value) {
+    const t = clamp01(value);
+    return t * t * (3 - 2 * t);
+}
+export const TRIM_PROFILES = {
+    skirting: {
+        flat: {
+            samples: 8,
+            proudAt: (t) => (t < 0.72 ? 0.62 : 0.9),
+        },
+        bevel: {
+            samples: 10,
+            proudAt: (t) => 0.48 + 0.42 * eased(t),
+        },
+        triangle: {
+            samples: 10,
+            proudAt: (t) => 0.32 + 0.68 * (1 - t),
+        },
+        cove: {
+            samples: 12,
+            proudAt: (t) => 0.45 + 0.42 * Math.sin(t * Math.PI * 0.5),
+        },
+        bullnose: {
+            samples: 12,
+            proudAt: (t) => 0.35 + 0.65 * Math.sin(Math.PI * t),
+        },
+        'base-modern': {
+            samples: 10,
+            proudAt: (t) => {
+                if (t < 0.16)
+                    return 0.85;
+                if (t < 0.72)
+                    return 0.58;
+                if (t < 0.9)
+                    return 1;
+                return 0.62;
+            },
+        },
+        'base-colonial': {
+            samples: 14,
+            proudAt: (t) => {
+                if (t < 0.16)
+                    return 0.82;
+                if (t < 0.55)
+                    return 0.52;
+                const capT = (t - 0.55) / 0.45;
+                return 0.58 + 0.4 * Math.sin(capT * Math.PI);
+            },
+        },
+        'base-shoe': {
+            samples: 14,
+            proudAt: (t) => {
+                const quarterRound = Math.sqrt(Math.max(0, 1 - t * t));
+                return 0.28 + 0.72 * quarterRound;
+            },
+        },
+        'base-ogee': {
+            samples: 16,
+            proudAt: (t) => {
+                const ogee = 0.5 - 0.5 * Math.cos(Math.PI * t);
+                const bead = 0.16 * Math.sin(2 * Math.PI * t);
+                return clamp01(0.42 + 0.5 * ogee + bead);
+            },
+        },
+    },
+    crown: {
+        flat: {
+            samples: 8,
+            proudAt: (t) => (t < 0.2 ? 0.52 : t < 0.82 ? 0.78 : 1),
+        },
+        bevel: {
+            samples: 10,
+            proudAt: (t) => 0.45 + 0.55 * eased(t),
+        },
+        triangle: {
+            samples: 10,
+            proudAt: (t) => 0.35 + 0.65 * t,
+        },
+        cove: {
+            samples: 14,
+            proudAt: (t) => 0.46 + 0.45 * Math.sin(t * Math.PI * 0.5),
+        },
+        bullnose: {
+            samples: 14,
+            proudAt: (t) => 0.38 + 0.62 * Math.sin(Math.PI * t * 0.5),
+        },
+        'crown-cove': {
+            samples: 16,
+            proudAt: (t) => {
+                if (t < 0.12)
+                    return 0.48;
+                if (t > 0.9)
+                    return 1;
+                return 0.46 + 0.48 * Math.sin(((t - 0.12) / 0.78) * Math.PI * 0.5);
+            },
+        },
+        'crown-ogee': {
+            samples: 18,
+            proudAt: (t) => {
+                const sCurve = 0.5 - 0.5 * Math.cos(Math.PI * t);
+                const reverse = 0.18 * Math.sin(2 * Math.PI * (t - 0.12));
+                return clamp01(0.42 + 0.55 * sCurve + reverse);
+            },
+        },
+        'crown-craftsman': {
+            samples: 10,
+            proudAt: (t) => {
+                if (t < 0.16)
+                    return 0.48;
+                if (t < 0.4)
+                    return 0.88;
+                if (t < 0.78)
+                    return 0.64;
+                return 1;
+            },
+        },
+        'crown-layered': {
+            samples: 14,
+            proudAt: (t) => {
+                if (t < 0.12)
+                    return 0.46;
+                if (t < 0.28)
+                    return 0.82;
+                if (t < 0.48)
+                    return 0.56;
+                if (t < 0.72)
+                    return 0.9;
+                return 1;
+            },
+        },
+    },
+    chairRail: {
+        flat: {
+            samples: 8,
+            proudAt: (t) => (t < 0.18 || t > 0.82 ? 0.58 : 0.95),
+        },
+        bevel: {
+            samples: 10,
+            proudAt: (t) => 0.45 + 0.45 * Math.sin(Math.PI * t),
+        },
+        triangle: {
+            samples: 10,
+            proudAt: (t) => 0.35 + 0.65 * (1 - Math.abs(2 * t - 1)),
+        },
+        cove: {
+            samples: 12,
+            proudAt: (t) => 0.42 + 0.42 * Math.sin(Math.PI * t),
+        },
+        bullnose: {
+            samples: 14,
+            proudAt: (t) => 0.34 + 0.66 * Math.sin(Math.PI * t),
+        },
+        'rail-rounded': {
+            samples: 14,
+            proudAt: (t) => 0.34 + 0.66 * Math.sin(Math.PI * t),
+        },
+        'rail-ogee': {
+            samples: 16,
+            proudAt: (t) => {
+                const center = Math.sin(Math.PI * t);
+                const twist = 0.14 * Math.sin(2 * Math.PI * t);
+                return clamp01(0.36 + 0.58 * center + twist);
+            },
+        },
+        'rail-picture': {
+            samples: 12,
+            proudAt: (t) => {
+                if (t < 0.18)
+                    return 0.48;
+                if (t < 0.4)
+                    return 0.92;
+                if (t < 0.74)
+                    return 0.58;
+                return 1;
+            },
+        },
+        'rail-stepped': {
+            samples: 10,
+            proudAt: (t) => {
+                if (t < 0.22)
+                    return 0.55;
+                if (t < 0.78)
+                    return 1;
+                return 0.62;
+            },
+        },
+    },
+};