minecraft-renderer 0.1.80 → 0.1.81

package/src/three/tests/chunkMeshManagerLegacy.test.ts

@@ -296,36 +296,6 @@ test('ChunkMeshManager: invalid blend geometry falls back to pooled mesh', () =>
   manager.dispose()
 })
 
-test('ChunkMeshManager: raycastGlobalLegacySections rejects off-ray sections within center distance', () => {
-  const manager = createManager()
-  const onRayKey = '0,0,0'
-  const offRayKey = '0,2,0'
-
-  manager.updateSection(onRayKey, makeBlendOnlyGeometry())
-
-  const offRayGeo = makeBlendOnlyGeometry()
-  offRayGeo.sz = 40
-  manager.updateSection(offRayKey, offRayGeo)
-
-  expect(manager.globalLegacyBlendBuffer?.hasSection(onRayKey)).toBe(true)
-  expect(manager.globalLegacyBlendBuffer?.hasSection(offRayKey)).toBe(true)
-  expect(manager.sectionObjects[offRayKey]?.worldZ).toBe(40)
-
-  const origin = new THREE.Vector3(4, 8, 8)
-  const direction = new THREE.Vector3(1, 0, 0).normalize()
-  const raycaster = new THREE.Raycaster(origin, direction)
-  raycaster.far = 4
-
-  const hit = manager.raycastGlobalLegacySections(raycaster, origin, 80)
-  expect(hit).toBeDefined()
-  expect(hit!).toBeGreaterThan(2)
-  expect(hit!).toBeLessThan(4)
-
-  manager.cleanupSection(onRayKey)
-  manager.cleanupSection(offRayKey)
-  manager.dispose()
-})
-
 test('ChunkMeshManager: mixed opaque and blend route to separate global buffers', () => {
   const manager = createManager()
   const key = '0,0,0'

package/src/three/thirdPersonVoxelRaycast.ts

@@ -0,0 +1,120 @@
+//@ts-nocheck
+import { raycastAabb, raycastAabbFromInside } from './sectionRaycastAabb'
+
+export type VoxelRaycastHit = {
+  distance: number
+  blockX: number
+  blockY: number
+  blockZ: number
+}
+
+const intBound = (s: number, ds: number): number => {
+  if (ds === 0) return Infinity
+  if (ds < 0) return intBound(-s, -ds)
+  const frac = s - Math.floor(s)
+  return (1 - frac) / ds
+}
+
+const hitSolidBlock = (
+  ox: number,
+  oy: number,
+  oz: number,
+  dx: number,
+  dy: number,
+  dz: number,
+  bx: number,
+  by: number,
+  bz: number,
+  maxDist: number,
+  radius: number,
+  minCameraDistance: number
+): number | undefined => {
+  const minX = bx - radius
+  const minY = by - radius
+  const minZ = bz - radius
+  const maxX = bx + 1 + radius
+  const maxY = by + 1 + radius
+  const maxZ = bz + 1 + radius
+
+  let t = raycastAabb(ox, oy, oz, dx, dy, dz, minX, minY, minZ, maxX, maxY, maxZ, maxDist)
+  if (t === undefined) {
+    t = raycastAabbFromInside(ox, oy, oz, dx, dy, dz, minX, minY, minZ, maxX, maxY, maxZ, maxDist)
+  }
+  if (t === undefined) return undefined
+  return Math.max(minCameraDistance, t)
+}
+
+/**
+ * Amanatides–Woo grid traversal against solid block volumes (not rendered mesh faces).
+ * `radius` is baked into per-block AABB expansion (swept sphere).
+ */
+export function raycastVoxelSolid(
+  ox: number,
+  oy: number,
+  oz: number,
+  dx: number,
+  dy: number,
+  dz: number,
+  maxDist: number,
+  radius: number,
+  minCameraDistance: number,
+  isSolid: (x: number, y: number, z: number) => boolean
+): VoxelRaycastHit | undefined {
+  if (maxDist <= 0) return undefined
+
+  let x = Math.floor(ox)
+  let y = Math.floor(oy)
+  let z = Math.floor(oz)
+
+  const stepX = dx > 0 ? 1 : dx < 0 ? -1 : 0
+  const stepY = dy > 0 ? 1 : dy < 0 ? -1 : 0
+  const stepZ = dz > 0 ? 1 : dz < 0 ? -1 : 0
+
+  const tDeltaX = stepX !== 0 ? Math.abs(1 / dx) : Infinity
+  const tDeltaY = stepY !== 0 ? Math.abs(1 / dy) : Infinity
+  const tDeltaZ = stepZ !== 0 ? Math.abs(1 / dz) : Infinity
+
+  let tMaxX = stepX !== 0 ? intBound(ox, dx) : Infinity
+  let tMaxY = stepY !== 0 ? intBound(oy, dy) : Infinity
+  let tMaxZ = stepZ !== 0 ? intBound(oz, dz) : Infinity
+
+  const tryHit = (bx: number, by: number, bz: number): VoxelRaycastHit | undefined => {
+    if (!isSolid(bx, by, bz)) return undefined
+    const distance = hitSolidBlock(ox, oy, oz, dx, dy, dz, bx, by, bz, maxDist, radius, minCameraDistance)
+    if (distance === undefined || distance > maxDist) return undefined
+    return { distance, blockX: bx, blockY: by, blockZ: bz }
+  }
+
+  let hit = tryHit(x, y, z)
+  if (hit) return hit
+
+  let t = 0
+  while (t <= maxDist) {
+    if (tMaxX < tMaxY) {
+      if (tMaxX < tMaxZ) {
+        x += stepX
+        t = tMaxX
+        tMaxX += tDeltaX
+      } else {
+        z += stepZ
+        t = tMaxZ
+        tMaxZ += tDeltaZ
+      }
+    } else if (tMaxY < tMaxZ) {
+      y += stepY
+      t = tMaxY
+      tMaxY += tDeltaY
+    } else {
+      z += stepZ
+      t = tMaxZ
+      tMaxZ += tDeltaZ
+    }
+
+    if (t > maxDist) break
+
+    hit = tryHit(x, y, z)
+    if (hit) return hit
+  }
+
+  return undefined
+}

package/src/three/worldRendererThree.ts

@@ -33,6 +33,7 @@ import { FireworksManager } from './fireworks'
 import { SceneOrigin } from './sceneOrigin'
 import { downloadWorldGeometry } from './worldGeometryExport'
 import { ChunkMeshManager } from './chunkMeshManager'
+import { raycastVoxelSolid } from './thirdPersonVoxelRaycast'
 import type { RendererModuleManifest, RegisteredModule, RendererModuleController } from './rendererModuleSystem'
 import { BUILTIN_MODULES } from './modules/index'
 import { formatPerformanceFactorsDebug, PerformanceMonitor } from '../performanceMonitor'
@@ -149,7 +150,6 @@ export class WorldRendererThree extends WorldRendererCommon {
   private readonly _tpScenePos = new THREE.Vector3()
   private readonly _tpAxisX = new THREE.Vector3(1, 0, 0)
   private readonly _tpAxisY = new THREE.Vector3(0, 1, 0)
-  private readonly _tpRaycaster = new THREE.Raycaster()
   private readonly _tpChunkWorldPos = new THREE.Vector3()
 
   get tilesRendered() {
@@ -788,6 +788,10 @@ export class WorldRendererThree extends WorldRendererCommon {
           text += `LEG-B: ${formatCompact(s.used)}/${formatCompact(s.capacity)}q `
         }
         text += `MEM: ${this.chunkMeshManager.getEstimatedMemoryUsage().total} `
+        const camCollisionBytes = this.cameraCollisionBlockCache.getAllocatedBytes()
+        if (camCollisionBytes > 0) {
+          text += `CAM: ${formatCompact(camCollisionBytes)}b `
+        }
         const pf = formatPerformanceFactorsDebug(this.reactiveState.world.instabilityFactors)
         if (pf) text += `PF: ${pf} `
         // entities can be seen in F3
@@ -1006,50 +1010,36 @@ export class WorldRendererThree extends WorldRendererCommon {
       this.debugRaycast(pos, direction, distance)
     }
 
-    const raycaster = this._tpRaycaster
-    raycaster.set(pos, direction)
-    raycaster.far = distance
-
-    const maxCenterDistance = 80
-    const maxCenterDistSq = maxCenterDistance * maxCenterDistance
-    const ox = pos.x
-    const oy = pos.y
-    const oz = pos.z
-
-    // Legacy section meshes: world-space raycast (static mesh.matrix translation).
-    const legacyMeshes: THREE.Object3D[] = []
-    for (const obj of Object.values(this.sectionObjects)) {
-      if (obj.name !== 'chunk' || !obj.visible) continue
-      if (obj.worldX === undefined) continue
-      const dcx = obj.worldX - ox
-      const dcy = obj.worldY! - oy
-      const dcz = obj.worldZ! - oz
-      if (dcx * dcx + dcy * dcy + dcz * dcz > maxCenterDistSq) continue
-      const mesh = obj.children.find(child => child.name === 'mesh')
-      if (mesh) legacyMeshes.push(mesh)
-    }
-
-    const intersects = raycaster.intersectObjects(legacyMeshes, false)
+    /** Swept-sphere radius for third-person camera collision (baked into voxel AABB expansion). */
+    const CAMERA_COLLISION_RADIUS = 0.25
+    /** Hard floor only guards zero/negative; never clamp up past a hit distance. */
+    const MIN_CAMERA_DISTANCE = 0.05
+    /** Eye→camera minimum so the lens stays outside the player head when a wall squeeze would pull closer. */
+    const MIN_THIRD_PERSON_BODY_CLEARANCE = 0.4
+
+    const blockCache = this.cameraCollisionBlockCache
+    const voxelHit = raycastVoxelSolid(
+      pos.x,
+      pos.y,
+      pos.z,
+      direction.x,
+      direction.y,
+      direction.z,
+      distance,
+      CAMERA_COLLISION_RADIUS,
+      MIN_CAMERA_DISTANCE,
+      (bx, by, bz) => blockCache.isSolidBlock(bx, by, bz)
+    )
 
     let finalDistance = distance
-    if (intersects.length > 0) {
-      finalDistance = Math.max(0.5, intersects[0].distance - 0.2)
+    if (voxelHit !== undefined) {
+      finalDistance = Math.min(finalDistance, voxelHit.distance)
     }
-
-    // Shader cubes in global buffer: tight per-section AABBs (no mesh raycast).
-    const boxHit = this.chunkMeshManager.raycastShaderSectionAABBs(pos, direction, finalDistance, maxCenterDistance)
-    if (boxHit !== undefined) {
-      finalDistance = Math.max(0.5, boxHit - 0.2)
+    if (finalDistance < MIN_THIRD_PERSON_BODY_CLEARANCE) {
+      finalDistance = MIN_THIRD_PERSON_BODY_CLEARANCE
     }
 
-    const legacyGlobalHit = this.chunkMeshManager.raycastGlobalLegacySections(raycaster, pos, maxCenterDistance)
-    if (legacyGlobalHit !== undefined) {
-      finalDistance = Math.max(0.5, legacyGlobalHit - 0.2)
-    }
-
-    const finalPos = new Vec3(pos.x + direction.x * finalDistance, pos.y + direction.y * finalDistance, pos.z + direction.z * finalDistance)
-
-    return finalPos
+    return new Vec3(pos.x + direction.x * finalDistance, pos.y + direction.y * finalDistance, pos.z + direction.z * finalDistance)
   }
 
   private debugRaycastHelper?: THREE.ArrowHelper

package/src/wasm-mesher/tests/cameraCollisionBlockCache.test.ts

@@ -0,0 +1,82 @@
+//@ts-nocheck
+import { test, expect } from 'vitest'
+import Chunks from 'prismarine-chunk'
+import MinecraftData from 'minecraft-data'
+import { Vec3 } from 'vec3'
+import { CAMERA_COLLISION_BYTES_PER_SECTION, CameraCollisionBlockCache } from '../../three/cameraCollisionBlockCache'
+
+const VERSION = '1.16.5'
+
+function makeChunkWithStoneFloor(y: number) {
+  const mcData = MinecraftData(VERSION)
+  const Chunk = Chunks(VERSION) as any
+  const chunk = new Chunk(undefined as any)
+  const stoneId = mcData.blocksByName.stone.defaultState
+  for (let x = 0; x < 16; x++) {
+    for (let z = 0; z < 16; z++) {
+      chunk.setBlockStateId(new Vec3(x, y, z), stoneId)
+    }
+  }
+  return chunk
+}
+
+test('CameraCollisionBlockCache: ingestColumn sets solids and skips air sections', () => {
+  const cache = new CameraCollisionBlockCache(VERSION)
+  cache.setWorldBounds(0, 256)
+  const chunk = makeChunkWithStoneFloor(64)
+  cache.ingestColumn(0, 0, chunk.toJson())
+
+  expect(cache.isSolidBlock(0, 64, 0)).toBe(true)
+  expect(cache.isSolidBlock(15, 64, 15)).toBe(true)
+  expect(cache.isSolidBlock(0, 65, 0)).toBe(false)
+  expect(cache.isSolidBlock(0, 0, 0)).toBe(false)
+
+  // One 16³ section at y=64 only (not the whole column height).
+  expect(cache.getAllocatedSectionCount()).toBe(1)
+  expect(cache.getAllocatedBytes()).toBe(CAMERA_COLLISION_BYTES_PER_SECTION)
+})
+
+test('CameraCollisionBlockCache: setBlockStateId updates and frees empty sections', () => {
+  const cache = new CameraCollisionBlockCache(VERSION)
+  cache.setWorldBounds(0, 256)
+  const mcData = MinecraftData(VERSION)
+  const stoneId = mcData.blocksByName.stone.defaultState
+
+  cache.setBlockStateId(5, 70, 5, stoneId)
+  expect(cache.isSolidBlock(5, 70, 5)).toBe(true)
+  expect(cache.getAllocatedSectionCount()).toBe(1)
+
+  cache.setBlockStateId(5, 70, 5, 0)
+  expect(cache.isSolidBlock(5, 70, 5)).toBe(false)
+  expect(cache.getAllocatedSectionCount()).toBe(0)
+})
+
+test('CameraCollisionBlockCache: removeColumn frees all section bitsets in column', () => {
+  const cache = new CameraCollisionBlockCache(VERSION)
+  cache.setWorldBounds(0, 256)
+  const mcData = MinecraftData(VERSION)
+  const stoneId = mcData.blocksByName.stone.defaultState
+
+  cache.setBlockStateId(0, 64, 0, stoneId)
+  cache.setBlockStateId(0, 80, 0, stoneId)
+  expect(cache.getAllocatedSectionCount()).toBe(2)
+
+  cache.removeColumn(0, 0)
+  expect(cache.getAllocatedSectionCount()).toBe(0)
+  expect(cache.isSolidBlock(0, 64, 0)).toBe(false)
+})
+
+test('CameraCollisionBlockCache: clear and setWorldBounds drop all sections', () => {
+  const cache = new CameraCollisionBlockCache(VERSION)
+  cache.setWorldBounds(0, 256)
+  const chunk = makeChunkWithStoneFloor(10)
+  cache.ingestColumn(16, 32, chunk.toJson())
+  expect(cache.getAllocatedSectionCount()).toBeGreaterThan(0)
+
+  cache.clear()
+  expect(cache.getAllocatedSectionCount()).toBe(0)
+
+  cache.ingestColumn(16, 32, chunk.toJson())
+  cache.setWorldBounds(-64, 320)
+  expect(cache.getAllocatedSectionCount()).toBe(0)
+})

package/src/wasm-mesher/tests/sectionRaycastAabb.test.ts

@@ -1,27 +1,9 @@
 //@ts-nocheck
 import { test, expect } from 'vitest'
-import {
-  computeShaderSectionRaycastAabb,
-  raycastAabb,
-  raycastShaderBlocksAabb,
-  raycastSectionAabb,
-  sectionAabbIntersectsRay
-} from '../../three/sectionRaycastAabb'
-import { LEGACY_SECTION_HALF_EXTENT } from '../../three/legacySectionCull'
+import { computeShaderSectionRaycastAabb, raycastAabb } from '../../three/sectionRaycastAabb'
 import { SHADER_CUBES_WORDS_PER_FACE } from '../bridge/shaderCubeBridge'
 import { WORD0 } from '../../three/shaders/cubeBlockShader'
 
-test('raycastSectionAabb: hit along +X (full 16³)', () => {
-  const t = raycastSectionAabb(0, 0, 0, 1, 0, 0, 16, 0, 0, 100)
-  expect(t).toBeDefined()
-  expect(t!).toBeGreaterThanOrEqual(8)
-  expect(t!).toBeLessThanOrEqual(24)
-})
-
-test('raycastSectionAabb: miss behind ray', () => {
-  expect(raycastSectionAabb(0, 0, 0, 1, 0, 0, -32, 0, 0, 100)).toBeUndefined()
-})
-
 test('raycastAabb: respects maxDist', () => {
   expect(raycastAabb(0, 0, 0, 1, 0, 0, 100, 0, 0, 108, 0, 8, 10)).toBeUndefined()
 })
@@ -49,93 +31,6 @@ test('raycastAabb: origin inside box is ignored', () => {
   expect(t).toBeUndefined()
 })
 
-test('raycastShaderBlocksAabb: hits wall block when origin is inside section aggregate AABB', () => {
-  const words = new Uint32Array(SHADER_CUBES_WORDS_PER_FACE * 3)
-  words[0] = 8 | (4 << WORD0.LY_SHIFT) | (8 << WORD0.LZ_SHIFT)
-  words[4] = 8 | (5 << WORD0.LY_SHIFT) | (8 << WORD0.LZ_SHIFT)
-  words[8] = 8 | (6 << WORD0.LY_SHIFT) | (8 << WORD0.LZ_SHIFT)
-  const visitGen = new Uint16Array(4096)
-  const visitStamp = 1
-  const t = raycastShaderBlocksAabb(words, 0, 3, SHADER_CUBES_WORDS_PER_FACE, 8, 8, 8, 4.5, 5.5, 8.5, 1, 0, 0, 10, visitGen, visitStamp)!
-  expect(t).toBeGreaterThan(0)
-  expect(t).toBeLessThan(4)
-})
-
-test('raycastShaderBlocksAabb: ray into empty space does not hit', () => {
-  const words = new Uint32Array(SHADER_CUBES_WORDS_PER_FACE)
-  words[0] = 8 | (4 << WORD0.LY_SHIFT) | (8 << WORD0.LZ_SHIFT)
-  const visitGen = new Uint16Array(4096)
-  const visitStamp = 1
-  const t = raycastShaderBlocksAabb(words, 0, 1, SHADER_CUBES_WORDS_PER_FACE, 8, 8, 8, 4.5, 5.5, 8.5, -1, 0, 0, 10, visitGen, visitStamp)
-  expect(t).toBeUndefined()
-})
-
-test('raycastShaderBlocksAabb: eye inside solid block uses exit distance', () => {
-  const lx = 5
-  const ly = 3
-  const lz = 7
-  const sectionCenterX = 8
-  const sectionCenterY = 8
-  const sectionCenterZ = 8
-  const words = new Uint32Array(SHADER_CUBES_WORDS_PER_FACE)
-  words[0] = lx | (ly << WORD0.LY_SHIFT) | (lz << WORD0.LZ_SHIFT)
-  const visitGen = new Uint16Array(4096)
-  const visitStamp = 1
-  const ox = sectionCenterX - 8 + lx + 0.5
-  const oy = sectionCenterY - 8 + ly + 0.5
-  const oz = sectionCenterZ - 8 + lz + 0.5
-  const t = raycastShaderBlocksAabb(
-    words,
-    0,
-    1,
-    SHADER_CUBES_WORDS_PER_FACE,
-    sectionCenterX,
-    sectionCenterY,
-    sectionCenterZ,
-    ox,
-    oy,
-    oz,
-    0,
-    0,
-    1,
-    10,
-    visitGen,
-    visitStamp
-  )!
-  expect(t).toBeGreaterThan(0)
-  expect(t).toBeLessThanOrEqual(10)
-  expect(t).toBeCloseTo(0.5, 5)
-})
-
-test('raycastShaderBlocksAabb: SoA stride-1 layout (GlobalBlockBuffer style)', () => {
-  const w0 = new Uint32Array(2)
-  w0[0] = 8 | (4 << WORD0.LY_SHIFT) | (8 << WORD0.LZ_SHIFT)
-  w0[1] = 8 | (5 << WORD0.LY_SHIFT) | (8 << WORD0.LZ_SHIFT)
-  const visitGen = new Uint16Array(4096)
-  const visitStamp = 1
-  const t = raycastShaderBlocksAabb(w0, 0, 2, 1, 8, 8, 8, 4.5, 5.5, 8.5, 1, 0, 0, 10, visitGen, visitStamp)!
-  expect(t).toBeGreaterThan(0)
-  expect(t).toBeLessThan(4)
-})
-
-const SECTION_HALF = LEGACY_SECTION_HALF_EXTENT + 0.01
-
-test('sectionAabbIntersectsRay: ray toward section center within far', () => {
-  expect(sectionAabbIntersectsRay(8, 8, 8, 4, 8, 8, 1, 0, 0, 4, SECTION_HALF)).toBe(true)
-})
-
-test('sectionAabbIntersectsRay: far shorter than gap to section', () => {
-  expect(sectionAabbIntersectsRay(8, 8, 8, -20, 8, 8, 1, 0, 0, 3, SECTION_HALF)).toBe(false)
-})
-
-test('sectionAabbIntersectsRay: parallel offset ray misses box', () => {
-  expect(sectionAabbIntersectsRay(8, 8, 8, -20, 8, -20, 1, 0, 0, 100, SECTION_HALF)).toBe(false)
-})
-
-test('sectionAabbIntersectsRay: origin inside box', () => {
-  expect(sectionAabbIntersectsRay(8, 8, 8, 8, 8, 8, 0, 1, 0, 4, SECTION_HALF)).toBe(true)
-})
-
 test('raycastAabb: narrow floor slab blocks downward ray', () => {
   const words = new Uint32Array(SHADER_CUBES_WORDS_PER_FACE * 2)
   words[0] = 4 | (0 << WORD0.LY_SHIFT) | (4 << WORD0.LZ_SHIFT)

package/src/wasm-mesher/tests/thirdPersonVoxelRaycast.test.ts

@@ -0,0 +1,63 @@
+//@ts-nocheck
+import { test, expect } from 'vitest'
+import { raycastVoxelSolid } from '../../three/thirdPersonVoxelRaycast'
+
+const solid = (blocks: Set<string>) => (x: number, y: number, z: number) => blocks.has(`${x},${y},${z}`)
+
+test('raycastVoxelSolid: straight-back ray hits wall', () => {
+  const blocks = solid(new Set(['5,5,5', '5,5,6', '5,5,7', '5,5,8']))
+  const hit = raycastVoxelSolid(0.5, 5.5, 5.5, 1, 0, 0, 10, 0.25, 0.05, blocks)
+  expect(hit).toBeDefined()
+  expect(hit!.blockX).toBe(5)
+  expect(hit!.distance).toBeGreaterThan(0)
+  expect(hit!.distance).toBeLessThan(5)
+})
+
+test('raycastVoxelSolid: diagonal ray through corner seam still hits volume', () => {
+  // Pit walls: solid L-shape; eye above pit looks back-down through corner gap in mesh shell.
+  const blocks = solid(
+    new Set([
+      // floor y=5
+      '4,5,4',
+      '5,5,4',
+      '6,5,4',
+      '4,5,5',
+      '5,5,5',
+      '6,5,5',
+      // walls
+      '4,6,4',
+      '4,7,4',
+      '5,6,4',
+      '6,6,5',
+      '6,7,5',
+      // surrounding ground (would be hollow in mesh)
+      '3,5,3',
+      '3,6,3',
+      '3,7,3',
+      '7,5,7',
+      '7,6,7',
+      '7,7,7'
+    ])
+  )
+  const dx = -0.6
+  const dy = -0.5
+  const dz = -0.6
+  const len = Math.hypot(dx, dy, dz)
+  const hit = raycastVoxelSolid(5.5, 7.5, 5.5, dx / len, dy / len, dz / len, 4, 0.25, 0.05, blocks)
+  expect(hit).toBeDefined()
+  expect(hit!.distance).toBeLessThan(4)
+})
+
+test('raycastVoxelSolid: passes through air and decorative pass-through is caller responsibility', () => {
+  const blocks = solid(new Set(['0,0,3']))
+  const hit = raycastVoxelSolid(0.5, 0.5, 0.5, 0, 0, 1, 10, 0.25, 0.05, blocks)
+  expect(hit?.blockZ).toBe(3)
+})
+
+test('raycastVoxelSolid: downward ray hits floor slab', () => {
+  const blocks = solid(new Set(['0,4,0']))
+  const hit = raycastVoxelSolid(0.5, 6.5, 0.5, 0, -1, 0, 10, 0.25, 0.05, blocks)
+  expect(hit).toBeDefined()
+  expect(hit!.blockY).toBe(4)
+  expect(hit!.distance).toBeCloseTo(1.25, 1)
+})