@pascal-app/editor 1.0.0-beta.5 → 1.0.1

package/src/components/tools/item/placement-strategies.test.ts

@@ -1,8 +1,299 @@
-import { describe, expect, test } from 'bun:test'
-import type { ItemNode, WallEvent, WallNode } from '@pascal-app/core'
-import { Mesh, type Object3D, Vector3 } from 'three'
-import { wallStrategy } from './placement-strategies'
+import { beforeEach, describe, expect, test } from 'bun:test'
+import {
+  BlockNode,
+  type GridEvent,
+  ItemNode,
+  type LevelNode,
+  type NodeEvent,
+  useScene,
+  type WallEvent,
+  type WallNode,
+} from '@pascal-app/core'
+import { BufferGeometry, Mesh, MeshBasicMaterial, type Object3D, Vector3 } from 'three'
+import { faceHostStrategy, floorStrategy, wallStrategy } from './placement-strategies'
 import type { PlacementContext, SpatialValidators } from './placement-types'
+import { registerTestBlockFaceHost } from './test-face-host'
+
+const BLOCK_ID = 'block_ceiling-host'
+const LEVEL_ID = 'level_ceiling-host' as LevelNode['id']
+
+beforeEach(() => {
+  registerTestBlockFaceHost()
+  useScene.setState((state) => ({
+    ...state,
+    nodes: {
+      ...state.nodes,
+      [BLOCK_ID]: BlockNode.parse({ id: BLOCK_ID, parentId: LEVEL_ID }),
+    },
+  }))
+})
+
+function ceilingContext(): PlacementContext {
+  return {
+    asset: {
+      id: 'ceiling-light',
+      category: 'lighting',
+      name: 'Ceiling light',
+      thumbnail: '/ceiling-light.png',
+      src: '/ceiling-light.glb',
+      dimensions: [1, 0.25, 1],
+      attachTo: 'ceiling',
+    },
+    levelId: LEVEL_ID,
+    draftItem: null,
+    gridPosition: new Vector3(),
+    state: {
+      surface: 'floor',
+      wallId: null,
+      roofSegmentId: null,
+      blockId: null,
+      ceilingId: null,
+      surfaceItemId: null,
+      shelfId: null,
+    },
+    currentCursorRotationY: 0,
+  }
+}
+
+function floorItemContext(): PlacementContext {
+  return {
+    ...ceilingContext(),
+    asset: {
+      id: 'potted-plant',
+      category: 'decor',
+      name: 'Potted plant',
+      thumbnail: '/potted-plant.png',
+      src: '/potted-plant.glb',
+      dimensions: [0.5, 0.39, 0.5],
+    },
+  }
+}
+
+function wallItemContext(): PlacementContext {
+  return {
+    ...ceilingContext(),
+    asset: {
+      id: 'wall-light',
+      category: 'lighting',
+      name: 'Wall light',
+      thumbnail: '/wall-light.png',
+      src: '/wall-light.glb',
+      dimensions: [0.5, 0.5, 0.25],
+      attachTo: 'wall-side',
+    },
+  }
+}
+
+function frontFaceEvent(slopeTopEdge = false): NodeEvent {
+  const box = BlockNode.parse({ id: BLOCK_ID, parentId: LEVEL_ID })
+  const node = slopeTopEdge
+    ? {
+        ...box,
+        topology: {
+          ...box.topology,
+          vertices: box.topology.vertices.map((vertex) =>
+            vertex.id === 'v4' || vertex.id === 'v5'
+              ? {
+                  ...vertex,
+                  position: [vertex.position[0], vertex.position[1], 0] satisfies [
+                    number,
+                    number,
+                    number,
+                  ],
+                }
+              : vertex,
+          ),
+        },
+      }
+    : box
+  const geometry = new BufferGeometry()
+  geometry.userData.blockFaces = [{ faceId: 'f-front', start: 0, count: 6 }]
+  const object = new Mesh(geometry, new MeshBasicMaterial())
+  object.updateMatrixWorld(true)
+
+  return {
+    node,
+    object,
+    faceIndex: 0,
+    position: [0, 1.2, slopeTopEdge ? -0.5 : -1],
+    localPosition: [0, 1.2, slopeTopEdge ? -0.5 : -1],
+    normal: [0, 0, -1],
+    stopPropagation: () => {},
+    nativeEvent: {} as NodeEvent['nativeEvent'],
+  }
+}
+
+function adjacentRightFaceEventOnFrontSurface(): NodeEvent {
+  const node = BlockNode.parse({ id: BLOCK_ID, parentId: LEVEL_ID })
+  const geometry = new BufferGeometry()
+  geometry.userData.blockFaces = [
+    { faceId: 'f-front', start: 0, count: 6 },
+    { faceId: 'f-right', start: 6, count: 6 },
+  ]
+  const object = new Mesh(geometry, new MeshBasicMaterial())
+  object.updateMatrixWorld(true)
+
+  return {
+    node,
+    object,
+    faceIndex: 2,
+    position: [0.5, 1.2, -1],
+    localPosition: [0.5, 1.2, -1],
+    normal: [1, 0, 0],
+    stopPropagation: () => {},
+    nativeEvent: {} as NodeEvent['nativeEvent'],
+  }
+}
+
+function bottomFaceEvent(): NodeEvent {
+  const node = BlockNode.parse({ id: BLOCK_ID, parentId: LEVEL_ID })
+  const geometry = new BufferGeometry()
+  geometry.userData.blockFaces = [{ faceId: 'f-bottom', start: 0, count: 6 }]
+  const object = new Mesh(geometry, new MeshBasicMaterial())
+  object.updateMatrixWorld(true)
+
+  return {
+    node,
+    object,
+    faceIndex: 0,
+    position: [0, 0, 0],
+    localPosition: [0, 0, 0],
+    normal: [0, -1, 0],
+    stopPropagation: () => {},
+    nativeEvent: {} as NodeEvent['nativeEvent'],
+  }
+}
+
+function topFaceEvent(): NodeEvent {
+  const node = BlockNode.parse({ id: BLOCK_ID, parentId: LEVEL_ID })
+  const geometry = new BufferGeometry()
+  geometry.userData.blockFaces = [{ faceId: 'f-top', start: 0, count: 6 }]
+  const object = new Mesh(geometry, new MeshBasicMaterial())
+  object.updateMatrixWorld(true)
+
+  return {
+    node,
+    object,
+    faceIndex: 0,
+    position: [0, 2.4, 0],
+    localPosition: [0, 2.4, 0],
+    normal: [0, 1, 0],
+    stopPropagation: () => {},
+    nativeEvent: {} as NodeEvent['nativeEvent'],
+  }
+}
+
+describe('faceHostStrategy', () => {
+  test('hosts a wall-mounted item on a vertical block face', () => {
+    expect(faceHostStrategy.enter(wallItemContext(), frontFaceEvent())).not.toBeNull()
+  })
+
+  test('does not host a wall-mounted item after the block face is edited into a slope', () => {
+    expect(faceHostStrategy.enter(wallItemContext(), frontFaceEvent(true))).toBeNull()
+  })
+
+  test('keeps a wall-mounted item on the active face during adjacent triangle hits', () => {
+    const context = wallItemContext()
+    const enter = faceHostStrategy.enter(context, frontFaceEvent())
+    expect(enter).not.toBeNull()
+
+    context.state.surface = 'block-face'
+    context.state.blockId = BLOCK_ID
+    context.draftItem = ItemNode.parse({
+      id: 'item_wall-light',
+      parentId: BLOCK_ID,
+      asset: context.asset,
+      ...enter?.nodeUpdate,
+    })
+    context.gridPosition.set(...enter!.gridPosition)
+
+    const move = faceHostStrategy.move(context, adjacentRightFaceEventOnFrontSurface())
+
+    expect(move?.nodeUpdate).toMatchObject({
+      blockFaceId: 'f-front',
+    } satisfies Partial<ItemNode>)
+    expect(move?.cursorPosition[2]).toBe(-1)
+  })
+
+  test('hosts a ceiling item on a downward-facing block face', () => {
+    const result = faceHostStrategy.enter(ceilingContext(), bottomFaceEvent())
+
+    expect(result).not.toBeNull()
+    expect(result?.stateUpdate).toMatchObject({
+      surface: 'block-face',
+      blockId: BLOCK_ID,
+    })
+    expect(result?.nodeUpdate).toMatchObject({
+      parentId: BLOCK_ID,
+      blockFaceId: 'f-bottom',
+      position: [0, 0, 0.25],
+      rotation: [-Math.PI / 2, 0, 0],
+    } satisfies Partial<ItemNode>)
+    expect(result?.cursorPosition).toEqual([0, -0.25, 0])
+  })
+
+  test('hosts a floor item on an upward-facing block face', () => {
+    const context = floorItemContext()
+    const event = topFaceEvent()
+    const result = faceHostStrategy.enter(context, event)
+
+    expect(result).not.toBeNull()
+    expect(result?.stateUpdate).toMatchObject({
+      surface: 'block-face',
+      blockId: BLOCK_ID,
+    })
+    expect(result?.nodeUpdate).toMatchObject({
+      parentId: BLOCK_ID,
+      blockFaceId: 'f-top',
+      position: [0, 0, 0],
+      rotation: [Math.PI / 2, 0, 0],
+    } satisfies Partial<ItemNode>)
+    expect(result?.cursorPosition).toEqual([0, 2.4, 0])
+
+    context.draftItem = ItemNode.parse({
+      id: 'item_potted-plant',
+      parentId: BLOCK_ID,
+      asset: context.asset,
+      ...result?.nodeUpdate,
+    })
+    Object.assign(context.state, result?.stateUpdate)
+    context.gridPosition.set(...result!.gridPosition)
+
+    expect(faceHostStrategy.click(context, event)?.nodeUpdate).toMatchObject({
+      parentId: BLOCK_ID,
+      blockFaceId: 'f-top',
+      position: [0, 0, 0],
+      rotation: [Math.PI / 2, 0, 0],
+    } satisfies Partial<ItemNode>)
+  })
+
+  test('restores floor-local position and rotation when an item leaves a block face', () => {
+    const context = floorItemContext()
+    context.state.surface = 'block-face'
+    context.state.blockId = BLOCK_ID
+    context.currentCursorRotationY = Math.PI / 4
+    context.gridPosition.set(1, -0.5, 2)
+    context.draftItem = ItemNode.parse({
+      id: 'item_moving-potted-plant',
+      parentId: BLOCK_ID,
+      asset: context.asset,
+      position: [0, 0, 0],
+      rotation: [Math.PI / 2, Math.PI / 4, 0],
+      blockFaceId: 'f-top',
+    })
+
+    expect(faceHostStrategy.leave(context)).toMatchObject({
+      nodeUpdate: {
+        parentId: LEVEL_ID,
+        blockFaceId: undefined,
+        position: [1, 0, 2],
+        rotation: [0, Math.PI / 4, 0],
+      } satisfies Partial<ItemNode>,
+      gridPosition: [1, 0, 2],
+      cursorPosition: [1, 0, 2],
+    })
+  })
+})
 
 /**
  * The wall frame the runtime builds in `updateWallGeometry`: origin at
@@ -165,3 +456,39 @@ describe('wallStrategy.move', () => {
     expect(result.cursorPosition[1]).toBeCloseTo(0.4 + 0.05, 6)
   })
 })
+
+describe('floorStrategy.move', () => {
+  function makeGridEvent(x: number, y: number, z: number): GridEvent {
+    return {
+      position: [x, y, z],
+      localPosition: [x, y, z],
+      nativeEvent: {} as GridEvent['nativeEvent'],
+    }
+  }
+
+  test('follows the live grid Y so a raised placement keeps its height', () => {
+    const context = floorItemContext()
+    context.gridPosition.set(0, 0.9, 0)
+
+    const result = floorStrategy.move(context, makeGridEvent(1.25, 0.9, 2.25))
+    if (!result) throw new Error('expected a placement result')
+
+    expect(result.gridPosition[1]).toBe(0.9)
+    expect(result.cursorPosition[1]).toBe(0.9)
+  })
+
+  // `detachItemSurfaceToFloor` zeroes the grid Y when an item is taken off a
+  // host; the floor path must honour that instead of a Y frozen at drag start,
+  // or the item commits floating at the shelf's height.
+  test('drops to the level plane once un-hosting zeroes the grid Y', () => {
+    const context = floorItemContext()
+    context.gridPosition.set(0, 0, 0)
+
+    const result = floorStrategy.move(context, makeGridEvent(1.25, 0.9, 2.25))
+    if (!result) throw new Error('expected a placement result')
+
+    expect(result.gridPosition[1]).toBe(0)
+    expect(result.cursorPosition[1]).toBe(0)
+    expect(result.nodeUpdate?.position?.[1]).toBe(0)
+  })
+})