@pascal-app/editor 1.0.5 → 1.0.7

package/src/components/tools/wall/wall-drafting.ts

@@ -1,21 +1,30 @@
 import {
   type AnyNodeId,
   DEFAULT_ANGLE_STEP,
+  finishWallEdit,
+  generateId,
+  planSeparatorInsertion,
   planWallInsertion,
   planWallSplitAtPoint,
+  railingWallDefaults,
   resolveWallConstruction,
   runAsSingleSceneHistoryStep,
+  type SeparatorNode,
+  sameWallConstruction,
   snapPointAlongAngleRay,
   useScene,
   type WallConstructionOptions,
   type WallNode,
+  wallsRunAlong,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import { sfxEmitter } from '../../../lib/sfx-bus'
 import { resolveSnapFlags } from '../../../lib/snapping-mode'
+import { getWallLineKind } from '../../../lib/wall-draw-variant'
 import useEditor, { getActiveSnappingMode, isMagneticSnapActive } from '../../../store/use-editor'
 import {
   distanceSquared,
+  findWallBodySnapTarget,
   findWallSnapTarget,
   findWallSpecialPointSnap,
   WALL_CONNECT_SNAP_RADIUS,
@@ -109,14 +118,30 @@ type SnapWallDraftArgs = {
    */
   magnetic?: boolean
   /**
-   * Optional grid-snap override. Lets the caller route grid snapping
-   * through a world-XZ aligned snap (so a rotated building's draft
-   * lands on the visible grid). When omitted, falls back to the
-   * local-axis grid at `step`.
+   * Optional grid-snap override, in the caller's plan frame. When omitted,
+   * falls back to the building-local grid at `step` — the lattice the wall
+   * tools draft on, square to the house however the building is turned.
    */
   gridSnap?: (point: WallPlanPoint) => WallPlanPoint
   /** Optional magnetic snap radii. Omitted means wall tools keep their defaults. */
   snapRadii?: WallSnapRadii
+  /**
+   * The point is a wall end (drawn or dragged): in the non-magnetic modes an
+   * end aimed into another wall's drawn body, or within the connect radius of
+   * either face, lands on that wall's reference line — where the wall
+   * topology T-joins it — ahead of the grid / angle placement, keeping the
+   * segment's direction from `start` (see `findWallBodySnapTarget`). Without
+   * it the grid quantises an end aimed at a face to the nearest lattice point,
+   * a fraction short of the face, and the end stays open with a gap.
+   */
+  captureWallBodies?: boolean
+  /**
+   * The walls `captureWallBodies` may join an end into; `walls` when omitted.
+   * A body capture T-joins the wall, so a caller that adds reference walls it
+   * can't join (the floor below) keeps them out of this list while they still
+   * serve the corner and edge snaps.
+   */
+  bodyWalls?: WallNode[]
 }
 
 export function snapWallDraftPointDetailed(args: SnapWallDraftArgs): WallDraftSnapResult {
@@ -131,6 +156,8 @@ export function snapWallDraftPointDetailed(args: SnapWallDraftArgs): WallDraftSn
     magnetic = true,
     gridSnap,
     snapRadii,
+    captureWallBodies = false,
+    bodyWalls = walls,
   } = args
 
   if (bypassSnap) return { point, snap: null, targetWallIds: [] }
@@ -144,9 +171,8 @@ export function snapWallDraftPointDetailed(args: SnapWallDraftArgs): WallDraftSn
   }
 
   const step = overrideStep ?? getSegmentGridStep()
-  // The angle path snaps the distance ALONG the 15° ray — a scalar, the
-  // same in world and local frames — so the `gridSnap` world-grid override
-  // only applies when the angle lock is off.
+  // The angle path snaps the distance ALONG the 15° ray from `start`, so the
+  // `gridSnap` override only applies when the angle lock is off.
   const basePoint: WallPlanPoint =
     start && angleSnap
       ? [...snapPointAlongAngleRay(start, point, DEFAULT_ANGLE_STEP, step)]
@@ -182,6 +208,30 @@ export function snapWallDraftPointDetailed(args: SnapWallDraftArgs): WallDraftSn
   }
   const connectSpecial = findWallSpecialPointSnap(basePoint, walls, ignoreWallIds, connectRadii)
   if (connectSpecial) return connectSpecial
+  // A wall end aimed into a wall's body joins it, whichever lattice point or
+  // ray station the mode picked near its face.
+  const bodySnap = captureWallBodies
+    ? findWallBodySnapTarget(point, bodyWalls, {
+        ignoreWallIds,
+        placed: basePoint,
+        start,
+        margin: WALL_CONNECT_SNAP_RADIUS,
+      })
+    : null
+  if (bodySnap) {
+    // An end aimed into a corner block joins the corner, and reads as one.
+    const atCorner = bodyWalls.some(
+      (wall) =>
+        !ignoreWallIds?.includes(wall.id) &&
+        (distanceSquared(bodySnap, wall.start) <= 1e-12 ||
+          distanceSquared(bodySnap, wall.end) <= 1e-12),
+    )
+    return {
+      point: bodySnap,
+      snap: atCorner ? 'endpoint' : 'wall',
+      targetWallIds: wallIdsAtSnapPoint(bodySnap, walls, ignoreWallIds),
+    }
+  }
   const connectWall = findWallSnapTarget(basePoint, walls, {
     ignoreWallIds,
     radius: WALL_CONNECT_SNAP_RADIUS,
@@ -205,6 +255,36 @@ export function isSegmentLongEnough(start: WallPlanPoint, end: WallPlanPoint): b
   return distanceSquared(start, end) >= WALL_MIN_LENGTH * WALL_MIN_LENGTH
 }
 
+/**
+ * An invisible wall drawn `start` → `end` on the current level (the Walls variant's Invisible, a room
+ * divider): room separators, each end joined to a wall it lands on and broken
+ * either side of a wall it crosses (`planSeparatorInsertion`), as one undo step. Rooms close on
+ * it; a room it closes off outside the house becomes a porch. The last piece, for the run to go
+ * on from its end; null when it would be too short.
+ */
+export function createInvisibleWallOnCurrentLevel(
+  start: WallPlanPoint,
+  end: WallPlanPoint,
+): SeparatorNode | null {
+  const currentLevelId = useViewer.getState().selection.levelId
+  const { nodes, applyNodeChanges } = useScene.getState()
+  if (!(currentLevelId && isSegmentLongEnough(start, end))) return null
+  const joinRadius = isMagneticSnapActive() ? WALL_JOIN_SNAP_RADIUS : WALL_CONNECT_SNAP_RADIUS
+  return runAsSingleSceneHistoryStep(useScene, () => {
+    const plan = planSeparatorInsertion(nodes, {
+      levelId: currentLevelId as AnyNodeId,
+      start,
+      end,
+      joinRadius,
+      mintId: () => generateId('separator'),
+    })
+    if (!plan) return null
+    applyNodeChanges(plan.changes)
+    sfxEmitter.emit('sfx:structure-build')
+    return plan.separators.at(-1) ?? null
+  })
+}
+
 export function createWallOnCurrentLevel(
   start: WallPlanPoint,
   end: WallPlanPoint,
@@ -220,13 +300,33 @@ export function createWallOnCurrentLevel(
   const joinRadius = isMagneticSnapActive() ? WALL_JOIN_SNAP_RADIUS : WALL_CONNECT_SNAP_RADIUS
 
   return runAsSingleSceneHistoryStep(useScene, () => {
-    const result = planWallInsertion(nodes, {
+    // The Walls variant's Railing draws railings: a guard of their own.
+    const insertion = {
       levelId: currentLevelId as AnyNodeId,
       start,
       end,
       joinRadius,
-      wallDefaults: useEditor.getState().toolDefaults.wall ?? {},
-    })
+      wallDefaults:
+        getWallLineKind() === 'railing'
+          ? railingWallDefaults()
+          : (useEditor.getState().toolDefaults.wall ?? {}),
+    }
+    let result = planWallInsertion(nodes, insertion)
+    if (!result.ok && result.reason === 'covered-existing-wall') {
+      // Drawn over walls built another way (an outside wall over an inside
+      // jog), the new wall takes their stretch over; over walls built the
+      // same, it would change nothing, so it stays refused.
+      const replacing = planWallInsertion(nodes, { ...insertion, replaceCovered: true })
+      if (
+        replacing.ok &&
+        replacing.plan.insertedWalls.some((wall) =>
+          wallsRunAlong(nodes, { ...wall, parentId: currentLevelId } as WallNode).some(
+            (covered) => !sameWallConstruction(covered, wall),
+          ),
+        )
+      )
+        result = replacing
+    }
     if (!result.ok) return null
     const { plan } = result
 
@@ -237,20 +337,28 @@ export function createWallOnCurrentLevel(
     const sourceAlreadyUpdated = sourceUpdate
       ? plan.changes.update.some((operation) => operation.id === sourceUpdate.id)
       : false
-    applyNodeChanges({
-      ...plan.changes,
-      update: plan.changes.update
-        .map((operation) =>
-          sourceUpdate?.id === operation.id
-            ? { ...operation, data: { ...operation.data, ...sourceUpdate.data } }
-            : operation,
-        )
-        .concat(sourceUpdate && !sourceAlreadyUpdated ? [sourceUpdate] : []),
-      create: plan.changes.create.map((operation) => ({
-        ...operation,
-        node: finalizedWallsById.get(operation.node.id as WallNode['id']) ?? operation.node,
-      })),
-    })
+    // A wall drawn along part of a parallel wall takes that stretch over, so
+    // drawing on from a wall never doubles the one it runs along.
+    applyNodeChanges(
+      finishWallEdit(
+        nodes,
+        {
+          ...plan.changes,
+          update: plan.changes.update
+            .map((operation) =>
+              sourceUpdate?.id === operation.id
+                ? { ...operation, data: { ...operation.data, ...sourceUpdate.data } }
+                : operation,
+            )
+            .concat(sourceUpdate && !sourceAlreadyUpdated ? [sourceUpdate] : []),
+          create: plan.changes.create.map((operation) => ({
+            ...operation,
+            node: finalizedWallsById.get(operation.node.id as WallNode['id']) ?? operation.node,
+          })),
+        },
+        { winnerIds: finalizedWalls.map((wall) => wall.id), mintId: () => generateId('wall') },
+      ),
+    )
     sfxEmitter.emit('sfx:structure-build')
 
     const terminalWall = finalizedWalls.at(-1)!

package/src/components/tools/wall/wall-pull-snap.test.ts

@@ -0,0 +1,274 @@
+import { describe, expect, test } from 'bun:test'
+import type { WallNode } from '@pascal-app/core'
+import { lockWallPullDirection, snapWallPullPoint, type WallPullSnapInput } from './wall-pull-snap'
+import type { WallPlanPoint } from './wall-snap-geometry'
+
+function makeWall(start: WallPlanPoint, end: WallPlanPoint, id?: string): WallNode {
+  return {
+    object: 'node',
+    id: (id ?? `wall_${start.join('_')}_${end.join('_')}`) as WallNode['id'],
+    type: 'wall',
+    name: 'Wall',
+    parentId: null,
+    visible: true,
+    metadata: {},
+    children: [],
+    start,
+    end,
+    thickness: 0.1,
+    frontSide: 'unknown',
+    backSide: 'unknown',
+  } as unknown as WallNode
+}
+
+const deg = (degrees: number) => (degrees * Math.PI) / 180
+const polar = (from: WallPlanPoint, degrees: number, length: number): WallPlanPoint => [
+  from[0] + Math.cos(deg(degrees)) * length,
+  from[1] + Math.sin(deg(degrees)) * length,
+]
+
+function expectPoint(actual: WallPlanPoint, expected: WallPlanPoint) {
+  expect(actual[0]).toBeCloseTo(expected[0], 6)
+  expect(actual[1]).toBeCloseTo(expected[1], 6)
+}
+
+// A 4 × 3 m room; the pull starts at the south wall's east end.
+const ROOM = [
+  makeWall([0, 0], [4, 0], 'south'),
+  makeWall([4, 0], [4, 3], 'east'),
+  makeWall([4, 3], [0, 3], 'north'),
+  makeWall([0, 3], [0, 0], 'west'),
+]
+
+function pullFromRoom(point: WallPlanPoint, extra: Partial<WallPullSnapInput> = {}) {
+  return snapWallPullPoint({
+    point,
+    start: [4, 0],
+    runStart: [4, 0],
+    reference: [1, 0],
+    walls: ROOM,
+    gridStep: 0.5,
+    ...extra,
+  })
+}
+
+describe('lockWallPullDirection', () => {
+  test('holds straight on from the wall it comes from within about 7°', () => {
+    expect(lockWallPullDirection(polar([0, 0], 6, 3), [1, 0])).toEqual({
+      direction: [1, 0],
+      lock: 'straight',
+    })
+    expect(lockWallPullDirection(polar([0, 0], 8, 3), [1, 0]).lock).toBe('angle')
+  })
+
+  test('holds square to the wall it comes from, either side', () => {
+    const left = lockWallPullDirection(polar([0, 0], 85, 3), [1, 0])
+    expect(left.lock).toBe('square')
+    expectPoint(left.direction, [0, 1])
+    const right = lockWallPullDirection(polar([0, 0], -96, 3), [1, 0])
+    expect(right.lock).toBe('square')
+    expectPoint(right.direction, [0, -1])
+  })
+
+  test('holds straight on to a skewed wall, and the house axes beside it', () => {
+    const skew: WallPlanPoint = [Math.cos(deg(20)), Math.sin(deg(20))]
+    const straight = lockWallPullDirection(polar([0, 0], 23, 3), skew)
+    expect(straight.lock).toBe('straight')
+    expectPoint(straight.direction, skew)
+    const axis = lockWallPullDirection(polar([0, 0], 4, 3), skew)
+    expect(axis.lock).toBe('axis')
+    expectPoint(axis.direction, [1, 0])
+  })
+
+  test('past the lock it steps by 15° on the house axes', () => {
+    for (const [cursor, expected] of [
+      [40, 45],
+      [28, 30],
+      [52, 45],
+      [-118, -120],
+    ] as const) {
+      const { direction, lock } = lockWallPullDirection(polar([0, 0], cursor, 3), [1, 0])
+      expect(lock).toBe('angle')
+      expectPoint(direction, polar([0, 0], expected, 1))
+    }
+  })
+})
+
+describe('snapWallPullPoint', () => {
+  test('a straight pull steps its length on the grid', () => {
+    const result = pullFromRoom([6.6, 0.2])
+    expect(result.lock).toBe('straight')
+    expect(result.snap).toBe('grid')
+    expect(result.label).toBe('Grid')
+    expectPoint(result.point, [6.5, 0])
+  })
+
+  test('a square pull holds 90° to the pulled wall', () => {
+    const result = pullFromRoom([4.25, -2.6])
+    expect(result.lock).toBe('square')
+    expectPoint(result.point, [4, -2.5])
+  })
+
+  test('further round it snaps to 15° steps, with a grid length along them', () => {
+    const result = pullFromRoom(polar([4, 0], -40, 3))
+    expect(result.lock).toBe('angle')
+    // 3 m at 40° is 2.99 m along 45°: 3 m on the 0.5 m grid.
+    expectPoint(result.point, polar([4, 0], -45, 3))
+  })
+
+  test('Alt is fully free', () => {
+    const cursor = polar([4, 0], -40, 3.13)
+    const result = pullFromRoom(cursor, { free: true })
+    expect(result.lock).toBe('free')
+    expect(result.snap).toBeNull()
+    expectPoint(result.point, cursor)
+  })
+
+  test('the extension of the pulled wall is always drawn', () => {
+    const result = pullFromRoom([5.3, -1.9])
+    const extension = result.guides.find((guide) => guide.kind === 'extension')
+    expect(extension?.from).toEqual([4, 0])
+    expect(extension?.to[1]).toBeCloseTo(0, 9)
+    expect(extension?.to[0] ?? 0).toBeGreaterThan(5.3)
+  })
+
+  test('an existing wall end wins over the held direction', () => {
+    const result = snapWallPullPoint({
+      point: [4.15, 3.2],
+      start: [7, 3],
+      runStart: [4, 0],
+      reference: [0, 1],
+      walls: [...ROOM, makeWall([4, 0], [7, 0], 'p1'), makeWall([7, 0], [7, 3], 'p2')],
+      gridStep: 0.5,
+    })
+    expect(result.snap).toBe('endpoint')
+    expect(result.label).toBe('Endpoint')
+    expect(result.point).toEqual([4, 3])
+    expect(result.targetWallIds.sort()).toEqual(['east', 'north'])
+  })
+
+  test('a held direction running into a wall lands on its line, square', () => {
+    // From the east of the room, back west at the north wall's height: the
+    // wall runs into the east wall at (4, 1.5), square to it.
+    const result = snapWallPullPoint({
+      point: [4.2, 1.52],
+      start: [7, 1.5],
+      runStart: [7, -1],
+      reference: [0, 1],
+      walls: ROOM,
+      gridStep: 0.5,
+    })
+    expect(result.snap).toBe('perpendicular')
+    expect(result.label).toBe('Perpendicular')
+    expectPoint(result.point, [4, 1.5])
+    expect(result.targetWallIds).toEqual(['east'])
+  })
+
+  test('a run lines up with its start, then closes on it', () => {
+    // Pulled east out of a lone wall's end S = (0, 0): east to (5, 0), north
+    // to (5, 4), then west — the run's start guide catches x = 0 …
+    const source = makeWall([-4, 0], [0, 0], 'source')
+    const walls = [source, makeWall([0, 0], [5, 0], 'r1'), makeWall([5, 0], [5, 4], 'r2')]
+    const across = snapWallPullPoint({
+      point: [0.1, 4.05],
+      start: [5, 4],
+      runStart: [0, 0],
+      reference: [0, 1],
+      walls,
+      gridStep: 0,
+    })
+    expect(across.snap).toBe('alignment')
+    expect(across.label).toBe('In line with start')
+    expectPoint(across.point, [0, 4])
+    const startGuide = across.guides.find((guide) => guide.kind === 'run-start')
+    expect(startGuide?.from).toEqual([0, 0])
+    expect(startGuide?.to[0]).toBeCloseTo(0, 9)
+    expect(startGuide?.to[1] ?? 0).toBeGreaterThan(4)
+    // … and the last wall closes square back onto it.
+    const close = snapWallPullPoint({
+      point: [0.12, 0.2],
+      start: [0, 4],
+      runStart: [0, 0],
+      reference: [-1, 0],
+      walls: [...walls, makeWall([5, 4], [0, 4], 'r3')],
+      gridStep: 0.5,
+    })
+    expect(close.snap).toBe('endpoint')
+    expect(close.point).toEqual([0, 0])
+  })
+
+  test('guides cross near the cursor: the crossing is marked and snaps', () => {
+    // The run's start S = (0, 0) and another wall's end P = (2, 6): S's
+    // vertical and P's horizontal cross at (0, 6).
+    const walls = [
+      makeWall([-4, 0], [0, 0], 'source'),
+      makeWall([0, 0], [5, 0], 'r1'),
+      makeWall([5, 0], [5, 4], 'r2'),
+      makeWall([2, 6], [2, 9], 'p'),
+    ]
+    const near = snapWallPullPoint({
+      point: [0.45, 5.6],
+      start: [5, 4],
+      runStart: [0, 0],
+      reference: [0, 1],
+      walls,
+      gridStep: 0.5,
+    })
+    expect(near.intersections.some((point) => point[0] === 0 && point[1] === 6)).toBe(true)
+    expect(near.snap).not.toBe('intersection')
+
+    const on = snapWallPullPoint({
+      point: [0.1, 5.9],
+      start: [5, 4],
+      runStart: [0, 0],
+      reference: [0, 1],
+      walls,
+      gridStep: 0.5,
+    })
+    expect(on.snap).toBe('intersection')
+    expect(on.label).toBe('Intersection')
+    expect(on.point).toEqual([0, 6])
+    expect(on.guides.map((guide) => guide.kind).sort()).toEqual([
+      'alignment',
+      'extension',
+      'run-start',
+    ])
+    const vertical = on.guides.find((guide) => guide.kind === 'run-start')
+    expect(vertical?.from).toEqual([0, 0])
+    const horizontal = on.guides.find((guide) => guide.kind === 'alignment')
+    expect(horizontal?.from).toEqual([2, 6])
+  })
+
+  test('a wall middle and a wall crossing snap too', () => {
+    const midpoint = pullFromRoom([2.1, 3.15], { start: [4, -2], reference: [0, -1] })
+    expect(midpoint.snap).toBe('midpoint')
+    expect(midpoint.point).toEqual([2, 3])
+  })
+
+  test("on a turned building the lock follows the house's axes, not the world's", () => {
+    // The house is turned 30° on its lot. Plan points are in its own frame,
+    // as both views hand them to the tools; a world cursor along the house's
+    // east side comes in along the house's X, and the held wall goes back out
+    // along it.
+    const yaw = deg(30)
+    const origin: WallPlanPoint = [12, -7]
+    const toWorld = ([x, z]: WallPlanPoint): WallPlanPoint => [
+      origin[0] + x * Math.cos(yaw) + z * Math.sin(yaw),
+      origin[1] - x * Math.sin(yaw) + z * Math.cos(yaw),
+    ]
+    const toLocal = ([x, z]: WallPlanPoint): WallPlanPoint => {
+      const dx = x - origin[0]
+      const dz = z - origin[1]
+      return [dx * Math.cos(yaw) - dz * Math.sin(yaw), dx * Math.sin(yaw) + dz * Math.cos(yaw)]
+    }
+    const worldCursor = toWorld([6.6, 0.25])
+    const result = pullFromRoom(toLocal(worldCursor))
+    expect(result.lock).toBe('straight')
+    expectPoint(result.point, [6.5, 0])
+    const worldStart = toWorld([4, 0])
+    const worldEnd = toWorld(result.point)
+    const bearing = Math.atan2(worldEnd[1] - worldStart[1], worldEnd[0] - worldStart[0])
+    // Along the house's X, which sits 30° off the world's.
+    expect(bearing).toBeCloseTo(-yaw, 9)
+  })
+})