@pascal-app/editor 1.0.3 → 1.0.5

package/src/lib/stair-levels.ts

@@ -6,6 +6,8 @@ import {
   type LevelNode as LevelNodeType,
   resolveBuildingForLevel,
   type StairNode,
+  servesAsRoofLevel,
+  storeyInsertIndex,
 } from '@pascal-app/core'
 
 function sortLevelsByHeight(levels: LevelNodeType[]) {
@@ -141,30 +143,46 @@ export function resolveStairDestinationLevel({
     nodes as Record<AnyNodeId, AnyNode>,
   )
   const levels = getBuildingLevelsForLevel(nodes, fromLevel.id)
-  const nextExistingLevel = levels.find((level) => level.level > fromLevel.level) ?? null
+  // A stair rises to a storey: the roof level over the top one is not a floor to climb to.
+  const nextExistingLevel =
+    levels.find((level) => level.level > fromLevel.level && !servesAsRoofLevel(nodes, level)) ??
+    null
   if (nextExistingLevel) {
     return {
       buildingId,
       createdLevel: null,
       fromLevel,
       levels,
+      liftedLevels: [],
       toLevel: nextExistingLevel,
     }
   }
 
   if (createMissing && buildingId) {
+    // The new storey goes under the roof level, which moves up over it.
+    const { floorIndex, shift } = storeyInsertIndex(nodes, buildingId)
     const createdLevel = LevelNode.parse({
       children: [],
       height: DEFAULT_LEVEL_HEIGHT,
-      level: fromLevel.level + 1,
+      level: floorIndex,
       parentId: buildingId,
     })
+    const lifted = new Map(shift.map(({ id, data }) => [id, data.level]))
 
     return {
       buildingId,
       createdLevel,
       fromLevel,
-      levels: sortLevelsByHeight([...levels, createdLevel]),
+      levels: sortLevelsByHeight([
+        ...levels.map((level) =>
+          lifted.has(level.id) ? { ...level, level: lifted.get(level.id)! } : level,
+        ),
+        createdLevel,
+      ]),
+      liftedLevels: shift.map(({ id, data }) => ({
+        id: id as AnyNodeId,
+        data: data as Partial<AnyNode>,
+      })),
       toLevel: createdLevel,
     }
   }
@@ -174,6 +192,7 @@ export function resolveStairDestinationLevel({
     createdLevel: null,
     fromLevel,
     levels,
+    liftedLevels: [],
     toLevel: fromLevel,
   }
 }

package/src/lib/terrace-draft.test.ts

@@ -0,0 +1,145 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  BuildingNode,
+  clearSceneHistory,
+  createZone,
+  generateId,
+  initSpaceDetectionSync,
+  LevelNode,
+  useScene,
+  type ZoneNode,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import useEditor from '../store/use-editor'
+import useInteractionScope from '../store/use-interaction-scope'
+import {
+  moveFloorRegion,
+  pressFloorRegion,
+  releaseFloorRegion,
+  useFloorRegionDraft,
+} from './floor-region-session'
+import type { FloorRegionPoint, FloorRegionSnapSettings } from './floor-region-snap'
+import { liveGestureKinds } from './gesture-lifecycle'
+import { applyRoomPlan } from './room-structure-commands'
+import {
+  cancelTerraceDraft,
+  planTerrace,
+  startTerraceDraft,
+  useTerraceDraft,
+} from './terrace-draft'
+
+const LEVEL = 'level_terrace'
+const OFF: FloorRegionSnapSettings = { mode: 'off', step: 0.5 }
+let stop = () => {}
+const nodes = () => useScene.getState().nodes as Record<string, AnyNode>
+const history = () => useScene.temporal.getState().pastStates.length
+const zones = () =>
+  Object.values(nodes()).filter((n): n is ZoneNode => n.type === 'zone' && n.spaceRole === 'room')
+
+function box(from: FloorRegionPoint, to: FloorRegionPoint) {
+  const host = useTerraceDraft.getState().host!
+  pressFloorRegion('rectangle', host, from, OFF, 0.2)
+  moveFloorRegion(to, OFF, 0.2)
+  releaseFloorRegion(0.2)
+}
+
+beforeEach(() => {
+  globalThis.requestAnimationFrame ??= (callback) => {
+    callback(0)
+    return 0
+  }
+  globalThis.cancelAnimationFrame ??= () => {}
+  useInteractionScope.getState().end()
+  const building = BuildingNode.parse({ id: 'building_terrace', children: [LEVEL] })
+  const level = LevelNode.parse({ id: LEVEL, parentId: building.id })
+  useScene.setState({
+    nodes: { [building.id]: building, [level.id]: level },
+    rootNodeIds: [building.id],
+    dirtyNodes: new Set(),
+    materials: {},
+    collections: {},
+    readOnly: false,
+  })
+  useScene.temporal.getState().resume()
+  stop = initSpaceDetectionSync(useScene, { getState: () => ({ spaces: {}, setSpaces: () => {} }) })
+  applyRoomPlan(
+    createZone(nodes(), {
+      levelId: LEVEL,
+      polygon: [
+        [0, 0],
+        [6, 0],
+        [6, 5],
+        [0, 5],
+      ],
+      enclose: true,
+      name: 'Living room',
+      mintId: generateId,
+    }),
+  )
+  useViewer.getState().setSelection({ buildingId: building.id, levelId: LEVEL, selectedIds: [] })
+  useEditor.setState({ phase: 'building', mode: 'select', room: null })
+  useFloorRegionDraft.setState({ draft: null, hover: null })
+  clearSceneHistory()
+})
+afterEach(() => {
+  cancelTerraceDraft()
+  stop()
+  stop = () => {}
+})
+
+describe('terrace tool', () => {
+  test('a terrace is an outdoor room: separators where no wall runs, no ceiling', () => {
+    const walls = Object.values(nodes()).filter((n) => n.type === 'wall').length
+    const result = planTerrace(nodes(), LEVEL, [
+      [6, 0],
+      [10, 0],
+      [10, 5],
+      [6, 5],
+    ])
+    expect('plan' in result).toBe(true)
+    if (!('plan' in result)) return
+    applyRoomPlan(result.plan)
+    const terrace = nodes()[result.plan.zoneId] as ZoneNode
+    expect(terrace).toMatchObject({ name: 'Terrace', spaceRole: 'room', hasCeiling: false })
+    expect(Object.values(nodes()).filter((n) => n.type === 'wall')).toHaveLength(walls)
+    // Three new sides are separators; the fourth is the house wall it shares.
+    expect(Object.values(nodes()).filter((n) => n.type === 'separator')).toHaveLength(3)
+    expect(
+      Object.values(nodes()).some((n) => n.type === 'ceiling' && n.zoneId === terrace.id),
+    ).toBe(false)
+  })
+
+  test('refuses an outline over a room', () => {
+    expect(
+      planTerrace(nodes(), LEVEL, [
+        [4, 1],
+        [8, 1],
+        [8, 3],
+        [4, 3],
+      ]),
+    ).toEqual({ message: 'The terrace overlaps Living room.' })
+  })
+
+  test('draws like the room tools: each outline one undo step, the tool stays armed', () => {
+    expect(startTerraceDraft(LEVEL)).toBe(true)
+    expect(liveGestureKinds()).toEqual(['terrace-draft'])
+    box([7, 0], [11, 4])
+    expect(
+      zones()
+        .map((zone) => zone.name)
+        .sort(),
+    ).toEqual(['Living room', 'Terrace'])
+    expect(history()).toBe(1)
+    expect(useTerraceDraft.getState().host).not.toBeNull()
+    // An outline over the house is refused in place; nothing is written.
+    box([2, 2], [4, 4])
+    expect(useFloorRegionDraft.getState().draft).toMatchObject({
+      refusal: 'The terrace overlaps Living room.',
+    })
+    expect(history()).toBe(1)
+    cancelTerraceDraft()
+    expect(useTerraceDraft.getState().host).toBeNull()
+    expect(useInteractionScope.getState().scope.kind).toBe('idle')
+  })
+})

package/src/lib/terrace-draft.ts

@@ -0,0 +1,214 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  area,
+  createZone,
+  generateId,
+  type MultiPolygon,
+  type StructurePlan,
+  type ToolHint,
+  useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { create } from 'zustand'
+import useEditor from '../store/use-editor'
+import { CROSSING_MESSAGE, floorRegionSelfIntersects } from './floor-region-geometry'
+import {
+  cancelFloorRegion,
+  type FloorDraftCommit,
+  type FloorDraftPurpose,
+  type FloorRegionRoom,
+  useFloorRegionDraft,
+} from './floor-region-session'
+import { type FloorRegionPoint, floorRegionSnapTargets } from './floor-region-snap'
+import { beginGesture, type GestureHandle } from './gesture-lifecycle'
+import { applyRoomPlan } from './room-structure-commands'
+import { sfxEmitter } from './sfx-bus'
+
+// "Terrace" (Build panel → Outdoor): draws an outdoor room on the level's
+// ground, rectangle or polygon, snapped to the rooms already there and the
+// grid. The terrace is a room like any other — bounded by separators (and by
+// the walls it shares), no walls of its own and no ceiling — so it gets
+// everything rooms have: finish paint, height arrows, Divide, Move, Delete.
+// The tool is one lifecycle gesture from `startTerraceDraft` until cancelled;
+// each outline commits as one undo step and the tool stays armed, like the
+// room tools.
+
+export const TERRACE_DRAFT_HANDLE = 'terrace-draft'
+export const TERRACE_NAME = 'Terrace'
+export const TERRACE_TOO_SMALL_MESSAGE = 'Too small for a terrace.'
+export const TERRACE_FAILED_MESSAGE = "Can't place a terrace here."
+
+export type TerraceShape = 'rectangle' | 'polygon'
+
+export const useTerraceDraft = create<{
+  host: FloorRegionRoom | null
+  shape: TerraceShape
+}>(() => ({ host: null, shape: 'rectangle' }))
+
+/** How far the terrace tool reaches from the origin when the site has no outline. */
+const OPEN_GROUND = 500
+
+/**
+ * Why a terrace outline cannot be built, or its plan: an outdoor room of the
+ * outline, closed with separators where no wall runs, without a ceiling.
+ * Core refuses an outline over a room (the same rule MCP's outdoor
+ * `create_room` follows) and names the room, except the numbered room its
+ * walls enclose exactly: a walled courtyard, which becomes the terrace.
+ */
+export function planTerrace(
+  nodes: Record<string, AnyNode>,
+  levelId: string,
+  polygon: readonly FloorRegionPoint[],
+): { plan: StructurePlan & { zoneId: string } } | { message: string } {
+  const outline = polygon.map(([x, z]): [number, number] => [x, z])
+  if (floorRegionSelfIntersects(outline)) return { message: CROSSING_MESSAGE }
+  if (area([{ outer: outline, holes: [] }]) < 1) return { message: TERRACE_TOO_SMALL_MESSAGE }
+  try {
+    const plan = createZone(nodes, {
+      levelId,
+      polygon: outline,
+      name: TERRACE_NAME,
+      enclose: false,
+      intent: { hasCeiling: false },
+      mintId: generateId,
+    })
+    const conflict = plan.conflicts?.[0]
+    return conflict ? { message: conflict.message || TERRACE_FAILED_MESSAGE } : { plan }
+  } catch {
+    return { message: TERRACE_FAILED_MESSAGE }
+  }
+}
+
+let tool: GestureHandle | null = null
+
+function reset() {
+  if (useTerraceDraft.getState().host) useTerraceDraft.setState({ host: null })
+  const { draft } = useFloorRegionDraft.getState()
+  if (draft?.room.purpose === TERRACE) useFloorRegionDraft.setState({ draft: null, hover: null })
+}
+
+function commitTerrace(
+  host: FloorRegionRoom,
+  polygon: readonly FloorRegionPoint[],
+): FloorDraftCommit {
+  const result = planTerrace(useScene.getState().nodes, host.levelId, polygon)
+  if ('message' in result) return { ok: false, message: result.message }
+  applyRoomPlan(result.plan)
+  sfxEmitter.emit('sfx:structure-build')
+  // The rooms (and this terrace) now snap the next outline.
+  useTerraceDraft.setState({ host: describeTerraceHost(useScene.getState().nodes, host.levelId) })
+  return { ok: true }
+}
+
+function beginTool(host: FloorRegionRoom) {
+  const handle = beginGesture({
+    kind: 'terrace-draft',
+    scope: { kind: 'handle-drag', nodeId: host.levelId, handle: TERRACE_DRAFT_HANDLE },
+    stale: () =>
+      useScene.getState().readOnly || !useScene.getState().nodes[host.levelId as AnyNodeId],
+    onCancel: () => {
+      if (tool === handle) tool = null
+      reset()
+    },
+  })
+  tool = handle
+  useTerraceDraft.setState({ host })
+  return handle
+}
+
+const TERRACE: FloorDraftPurpose = {
+  persistent: true,
+  own: (room) => (tool?.active ? tool : beginTool(room)),
+  commit: (room, polygon) => {
+    const current = useTerraceDraft.getState().host ?? room
+    return commitTerrace(current, polygon)
+  },
+  fill: '#818cf8',
+}
+
+/** The level's ground as a draft room: the site (or open ground), snapping to the rooms on it. */
+export function describeTerraceHost(
+  nodes: Record<string, AnyNode>,
+  levelId: string,
+): FloorRegionRoom | null {
+  const level = nodes[levelId]
+  if (level?.type !== 'level') return null
+  const site = Object.values(nodes).find((node) => node.type === 'site')
+  const outline =
+    site?.type === 'site' && site.polygon?.points?.length && site.polygon.points.length >= 3
+      ? site.polygon.points.map(([x, z]): [number, number] => [x, z])
+      : ([
+          [-OPEN_GROUND, -OPEN_GROUND],
+          [OPEN_GROUND, -OPEN_GROUND],
+          [OPEN_GROUND, OPEN_GROUND],
+          [-OPEN_GROUND, OPEN_GROUND],
+        ] as [number, number][])
+  const clear: MultiPolygon = [{ outer: outline, holes: [] }]
+  const rooms = Object.values(nodes).flatMap((node) =>
+    node.type === 'zone' && node.parentId === levelId && node.spaceRole === 'room'
+      ? [node.polygon]
+      : [],
+  )
+  return {
+    zoneId: '',
+    levelId,
+    clear,
+    elevation: 0,
+    angle: 0,
+    targets: floorRegionSnapTargets([], rooms),
+    purpose: TERRACE,
+  }
+}
+
+/** Arms the terrace tool on the current level (select mode, so nothing else draws). */
+export function startTerraceDraft(levelId = useViewer.getState().selection.levelId): boolean {
+  if (!levelId || useScene.getState().readOnly) return false
+  const host = describeTerraceHost(useScene.getState().nodes, levelId)
+  if (!host) return false
+  cancelTerraceDraft()
+  cancelFloorRegion()
+  const editor = useEditor.getState()
+  if (editor.phase === 'site') editor.setPhase('building')
+  if (editor.mode !== 'select') editor.setMode('select')
+  if (editor.room) editor.clearRoom()
+  useViewer.getState().setSelection({ selectedIds: [] })
+  beginTool(host)
+  return true
+}
+
+export function cancelTerraceDraft() {
+  const current = tool
+  tool = null
+  if (current?.active) current.cancel()
+  else reset()
+}
+
+export function terraceDraftActive() {
+  return !!useTerraceDraft.getState().host
+}
+
+export function setTerraceShape(shape: TerraceShape) {
+  if (useTerraceDraft.getState().shape === shape) return
+  const { draft } = useFloorRegionDraft.getState()
+  if (draft?.room.purpose === TERRACE) useFloorRegionDraft.setState({ draft: null })
+  useTerraceDraft.setState({ shape })
+}
+
+export function toggleTerraceShape() {
+  setTerraceShape(useTerraceDraft.getState().shape === 'rectangle' ? 'polygon' : 'rectangle')
+}
+
+/** The HUD's shape chip (T). */
+export const TERRACE_SHAPE_HINT: ToolHint = {
+  key: 'T',
+  label: 'Shape',
+  chip: {
+    subscribe: (onChange) => useTerraceDraft.subscribe(onChange),
+    value: () => useTerraceDraft.getState().shape,
+    cycle: toggleTerraceShape,
+    labels: { rectangle: 'Shape: Rectangle', polygon: 'Shape: Polygon' },
+    icons: { rectangle: 'lucide:square', polygon: 'lucide:pentagon' },
+    tooltip: 'Outline shape — click or press T to switch',
+  },
+}

package/src/lib/tool-cursor-icon.test.ts

@@ -0,0 +1,16 @@
+import { expect, test } from 'bun:test'
+import { wallCursorIcon } from './tool-cursor-icon'
+import { getWallDrawVariantInfo, WALL_DRAW_VARIANTS } from './wall-draw-variant'
+
+test('the wall cursor bubble shows the Rooms tile icon of the variant in hand', () => {
+  for (const variant of WALL_DRAW_VARIANTS) {
+    expect(wallCursorIcon(variant.mode)).toEqual({
+      label: getWallDrawVariantInfo(variant.id).title,
+      iconSrc: variant.iconSrc,
+    })
+  }
+  expect(
+    new Set(WALL_DRAW_VARIANTS.map((variant) => wallCursorIcon(variant.mode).iconSrc)).size,
+  ).toBe(3)
+  expect(getWallDrawVariantInfo('walls').iconSrc).toBe('/icons/wall.webp')
+})

package/src/lib/tool-cursor-icon.ts

@@ -0,0 +1,11 @@
+import type { ContinuationMode } from './continuation'
+import { getWallDrawVariantInfo, wallDrawVariantOf } from './wall-draw-variant'
+
+/**
+ * The cursor bubble's icon for the wall tool: the Rooms variant in hand
+ * (Rectangle / Polygon / Walls), the same art as the Build panel tile.
+ */
+export function wallCursorIcon(mode: ContinuationMode): { label: string; iconSrc: string } {
+  const variant = getWallDrawVariantInfo(wallDrawVariantOf(mode))
+  return { label: variant.title, iconSrc: variant.iconSrc }
+}

package/src/lib/typing-target.ts

@@ -0,0 +1,9 @@
+// Keys typed into a field (the room-name combobox, any input, an open dialog)
+// belong to that field, never to a canvas gesture.
+const TYPING_TARGET =
+  'input, textarea, select, [contenteditable]:not([contenteditable="false"]), [role="combobox"], [role="textbox"], [role="dialog"], [role="alertdialog"]'
+
+export function isTypingTarget(target: EventTarget | null) {
+  const element = target as { closest?: (selector: string) => unknown; isContentEditable?: boolean }
+  return !!element && (element.isContentEditable === true || !!element.closest?.(TYPING_TARGET))
+}