spectra-physics 1.0.0 → 1.2.0

package/lib/engine/player/travel.js

@@ -0,0 +1,203 @@
+'use strict'
+
+const { f32, sin, cos, degToRadF, clamp } = require('../mth')
+const { moveRelative } = require('./input')
+const { move } = require('./move')
+const { fluidFallingAdjusted } = require('./fluids')
+const blocks = require('./blocks')
+
+const F_098 = f32(0.98)
+const F_091 = f32(0.91)
+const F_08 = f32(0.8)
+const F_09 = f32(0.9)
+const F_096 = f32(0.96)
+const F_002 = f32(0.02)
+const F_0026 = f32(0.025999999)
+const F_0216 = f32(0.21600002)
+const F_0546 = f32(0.54600006)
+const F_015 = f32(0.15)
+const F_042 = f32(0.42)
+const F_01 = f32(0.1)
+const F_02 = f32(0.2)
+const F_004 = f32(0.04)
+const F_06 = 0.6000000238418579
+const F_03 = 0.30000001192092896
+
+function flyingSpeed (player) {
+  if (!player.V.flyingSpeedLive) return player.legacyFlyingSpeed
+  if (player.abilities.flying) return player.sprinting ? f32(player.abilities.flyingSpeed * 2) : player.abilities.flyingSpeed
+  return player.sprinting ? F_0026 : F_002
+}
+
+function frictionInfluencedSpeed (player, friction) {
+  if (player.onGround) return f32(player.movementSpeed() * f32(F_0216 / f32(f32(friction * friction) * friction)))
+  return flyingSpeed(player)
+}
+
+function handleOnClimbable (player) {
+  if (!blocks.onClimbable(player)) return
+  player.fallDistance = 0
+  player.vel.x = clamp(player.vel.x, -F_015, F_015)
+  player.vel.z = clamp(player.vel.z, -F_015, F_015)
+  let vy = Math.max(player.vel.y, -F_015)
+  if (vy < 0 && !blocks.feetBlock(player).isScaffolding && player.input.shift) vy = 0
+  player.vel.y = vy
+}
+
+function isFree (player, dx, dy, dz) {
+  const box = player.bb().move(dx, dy, dz)
+  return player.world.noCollision(box) && !player.world.containsAnyLiquid(box)
+}
+
+// LivingEntity#jumpFromGround
+function jumpFromGround (player) {
+  const V = player.V
+  const strength = V.attributes2005 ? f32(player.env.attribute('jump_strength', 0.42)) : F_042
+  let power = f32(strength * blocks.jumpFactor(player))
+  const boost = player.env.effect('jump_boost')
+  if (boost != null) power = f32(power + f32(F_01 * (boost + 1)))
+  if (V.attributes2005 && power <= 1.0e-5) return
+  player.vel.y = V.jumpKeepsHigherY ? Math.max(power, player.vel.y) : power
+  if (!player.sprinting) return
+  const r = degToRadF(player.yRot)
+  if (V.jumpDoubleSprintBoost) {
+    player.vel.x += -sin(r) * 0.2
+    player.vel.z += cos(r) * 0.2
+  } else {
+    player.vel.x += f32(-sin(r) * F_02)
+    player.vel.z += f32(cos(r) * F_02)
+  }
+}
+
+// jump handling in LivingEntity#aiStep
+function handleJump (player) {
+  if (!player.input.jumping || player.abilities.flying) {
+    player.noJumpDelay = 0
+    return
+  }
+  const inLava = player.isInLava()
+  const height = inLava ? player.fluidHeight.lava : player.fluidHeight.water
+  const inWater = player.isInWater() && height > 0
+  const threshold = player.eyeHeight() < 0.4 ? 0 : 0.4
+  if (inWater && !(player.onGround && !(height > threshold))) {
+    player.vel.y += F_004
+  } else if (inLava && !(player.onGround && !(height > threshold))) {
+    player.vel.y += F_004
+  } else if ((player.onGround || (inWater && height <= threshold)) && player.noJumpDelay === 0) {
+    jumpFromGround(player)
+    player.noJumpDelay = 10
+  }
+}
+
+function travelInWater (player, ix, iy, iz, gravity, falling) {
+  const V = player.V
+  const startY = player.pos.y
+  let friction = player.sprinting ? F_09 : F_08
+  let speed = F_002
+  let strider = V.efficiencyAttributes
+    ? f32(player.env.attribute('water_movement_efficiency', 0))
+    : Math.min(3, player.env.bootsEnchant('depth_strider'))
+  if (!player.onGround) strider = f32(strider * 0.5)
+  if (strider > 0) {
+    const divisor = V.efficiencyAttributes ? 1 : 3
+    friction = f32(friction + f32(f32(f32(F_0546 - friction) * strider) / divisor))
+    speed = f32(speed + f32(f32(f32(player.movementSpeed() - speed) * strider) / divisor))
+  }
+  if (player.env.effect('dolphins_grace') != null) friction = F_096
+  moveRelative(player, speed, ix, iy, iz)
+  move(player, player.vel.x, player.vel.y, player.vel.z)
+  if (player.horizontalCollision && blocks.onClimbable(player)) player.vel.y = 0.2
+  player.vel.x *= friction
+  player.vel.y *= F_08
+  player.vel.z *= friction
+  fluidFallingAdjusted(player, gravity, falling)
+  if (player.horizontalCollision && isFree(player, player.vel.x, player.vel.y + F_06 - player.pos.y + startY, player.vel.z)) {
+    player.vel.y = F_03
+  }
+}
+
+function travelInLava (player, ix, iy, iz, gravity, falling) {
+  const startY = player.pos.y
+  moveRelative(player, F_002, ix, iy, iz)
+  move(player, player.vel.x, player.vel.y, player.vel.z)
+  if (player.fluidHeight.lava <= 0.4) {
+    player.vel.x *= 0.5
+    player.vel.y *= F_08
+    player.vel.z *= 0.5
+    fluidFallingAdjusted(player, gravity, falling)
+  } else {
+    player.vel.x *= 0.5
+    player.vel.y *= 0.5
+    player.vel.z *= 0.5
+  }
+  player.vel.y += -gravity / 4
+  if (player.horizontalCollision && isFree(player, player.vel.x, player.vel.y + F_06 - player.pos.y + startY, player.vel.z)) {
+    player.vel.y = F_03
+  }
+}
+
+function travelInAir (player, ix, iy, iz, gravity) {
+  const below = blocks.belowPos(player)
+  const friction = player.world.blockAt(below.x, below.y, below.z).friction
+  const drag = player.onGround ? f32(friction * F_091) : F_091
+  moveRelative(player, frictionInfluencedSpeed(player, friction), ix, iy, iz)
+  handleOnClimbable(player)
+  move(player, player.vel.x, player.vel.y, player.vel.z)
+  if ((player.horizontalCollision || player.input.jumping) && (blocks.onClimbable(player) || blocks.onPowderSnowWithBoots(player))) {
+    player.vel.y = 0.2
+  }
+  let vy = player.vel.y
+  const levitation = player.env.effect('levitation')
+  if (levitation != null) {
+    vy += (0.05 * (levitation + 1) - player.vel.y) * 0.2
+    player.fallDistance = 0
+  } else if (!player.world.hasChunk(below.x, below.z)) {
+    vy = player.pos.y > player.world.minY ? -0.1 : 0
+  } else {
+    vy -= gravity
+  }
+  player.vel.x *= drag
+  player.vel.y = vy * F_098
+  player.vel.z *= drag
+}
+
+// LivingEntity#travel
+function livingTravel (player, ix, iy, iz) {
+  const falling = player.vel.y <= 0
+  let gravity = player.V.attributes2005 ? player.env.attribute('gravity', 0.08) : 0.08
+  if (falling && player.env.effect('slow_falling') != null) {
+    gravity = player.V.attributes2005 ? Math.min(gravity, 0.01) : 0.01
+    player.fallDistance = 0
+  }
+  const affected = !player.abilities.flying
+  if (player.isInWater() && affected) travelInWater(player, ix, iy, iz, gravity, falling)
+  else if (player.isInLava() && affected) travelInLava(player, ix, iy, iz, gravity, falling)
+  else travelInAir(player, ix, iy, iz, gravity)
+}
+
+function swimTowardsLook (player) {
+  const lookY = -sin(degToRadF(player.xRot))
+  const k = lookY < -0.2 ? 0.085 : 0.06
+  const above = player.world.fluidAt(Math.floor(player.pos.x), Math.floor(player.pos.y + 1 - 0.1), Math.floor(player.pos.z))
+  if (lookY <= 0 || player.input.jumping || above) player.vel.y += (lookY - player.vel.y) * k
+}
+
+// Player#travel
+function travel (player) {
+  const ix = player.xxa
+  const iz = player.zza
+  if (player.swimming && !player.riding) swimTowardsLook(player)
+  if (!player.abilities.flying) {
+    livingTravel(player, ix, 0, iz)
+    return
+  }
+  const startVy = player.vel.y
+  const saved = player.legacyFlyingSpeed
+  if (!player.V.flyingSpeedLive) player.legacyFlyingSpeed = f32(player.abilities.flyingSpeed * (player.sprinting ? 2 : 1))
+  livingTravel(player, ix, 0, iz)
+  player.vel.y = startVy * 0.6
+  player.legacyFlyingSpeed = saved
+  player.fallDistance = 0
+}
+
+module.exports = { travel, handleJump }

package/lib/engine/player/traversal.js

@@ -0,0 +1,290 @@
+'use strict'
+// Which blocks Entity#applyEffectsFromBlocks visits after travel (1.21.2+), and in what order. The order
+// matters: effects such as bubble columns depend on the velocity left by the blocks visited before them.
+// Each client version walks the movement differently; the four variants below follow those versions.
+
+const { f32 } = require('../mth')
+
+const EPS = 1.0e-7
+const DEFLATE = f32(1.0e-5)
+const SHORT_MOVE_SQ = f32(f32(0.99999) * f32(0.99999))
+const TINY_MOVE_SQ = DEFLATE * DEFLATE
+const FAR_SQ = 0.9999900000002526 * 0.9999900000002526
+const STEP_LIMIT = 16
+
+// insertion-ordered set of block positions, small enough that a linear scan beats hashing
+class BlockList {
+  constructor () { this.coords = []; this.length = 0 }
+
+  clear () { this.length = 0; return this }
+
+  has (x, y, z) {
+    const c = this.coords
+    for (let i = 0; i < this.length * 3; i += 3) if (c[i] === x && c[i + 1] === y && c[i + 2] === z) return true
+    return false
+  }
+
+  // true when the position was not in the list yet
+  add (x, y, z) {
+    if (this.has(x, y, z)) return false
+    const i = this.length * 3
+    this.coords[i] = x; this.coords[i + 1] = y; this.coords[i + 2] = z
+    this.length++
+    return true
+  }
+
+  forEach (visit) {
+    const c = this.coords
+    for (let i = 0; i < this.length * 3; i += 3) visit(c[i], c[i + 1], c[i + 2])
+  }
+}
+
+const seenAlong = new BlockList()
+const seenBetween = new BlockList()
+const ordered = new BlockList()
+
+const frac = (v) => v - Math.floor(v)
+const sign = (v) => v === 0 ? 0 : (v > 0 ? 1 : -1)
+
+// BlockPos.betweenClosed: x fastest, then y, then z
+function forEachBetweenClosed (box, visit) {
+  const x0 = Math.floor(box.minX); const y0 = Math.floor(box.minY); const z0 = Math.floor(box.minZ)
+  const x1 = Math.floor(box.maxX); const y1 = Math.floor(box.maxY); const z1 = Math.floor(box.maxZ)
+  for (let z = z0; z <= z1; z++) {
+    for (let y = y0; y <= y1; y++) {
+      for (let x = x0; x <= x1; x++) visit(x, y, z)
+    }
+  }
+}
+
+// Y first, then the smaller of x/z ... matching Direction.axisStepOrder
+const axisStepOrder = (v) => Math.abs(v.x) < Math.abs(v.z) ? 'yzx' : 'yxz'
+
+// BlockPos.betweenCornersInDirection: starts at the corner facing away from the direction,
+// walks Y, then the smaller of x/z, then the other one (innermost)
+function forEachBetweenCorners (ax, ay, az, bx, by, bz, dir, visit) {
+  const minX = Math.min(ax, bx); const minY = Math.min(ay, by); const minZ = Math.min(az, bz)
+  const sizeX = Math.max(ax, bx) - minX; const sizeY = Math.max(ay, by) - minY; const sizeZ = Math.max(az, bz) - minZ
+  const sx = dir.x >= 0 ? 1 : -1; const sy = dir.y >= 0 ? 1 : -1; const sz = dir.z >= 0 ? 1 : -1
+  const x0 = sx > 0 ? minX : minX + sizeX; const y0 = sy > 0 ? minY : minY + sizeY; const z0 = sz > 0 ? minZ : minZ + sizeZ
+  const zSecond = Math.abs(dir.x) < Math.abs(dir.z)
+  for (let i = 0; i <= sizeY; i++) {
+    const y = y0 + sy * i
+    if (zSecond) {
+      for (let j = 0; j <= sizeZ; j++) {
+        const z = z0 + sz * j
+        for (let k = 0; k <= sizeX; k++) if (visit(x0 + sx * k, y, z) === false) return false
+      }
+    } else {
+      for (let j = 0; j <= sizeX; j++) {
+        const x = x0 + sx * j
+        for (let k = 0; k <= sizeZ; k++) if (visit(x, y, z0 + sz * k) === false) return false
+      }
+    }
+  }
+  return true
+}
+
+function clipPoint (best, delta, side, startSide, minA, maxA, minB, maxB, startA, deltaA, startB, deltaB) {
+  const t = (side - startSide) / delta
+  const a = startA + t * deltaA
+  const b = startB + t * deltaB
+  if (t > 0 && t < best.t && minA - EPS < a && a < maxA + EPS && minB - EPS < b && b < maxB + EPS) {
+    best.t = t
+    best.hit = true
+  }
+}
+
+// AABB.clip of the unit cube at (x, y, z) against the segment start -> end
+function clip (x, y, z, start, end) {
+  const dx = end.x - start.x; const dy = end.y - start.y; const dz = end.z - start.z
+  const best = { t: 1, hit: false }
+  if (dx > EPS) clipPoint(best, dx, x, start.x, y, y + 1, z, z + 1, start.y, dy, start.z, dz)
+  else if (dx < -EPS) clipPoint(best, dx, x + 1, start.x, y, y + 1, z, z + 1, start.y, dy, start.z, dz)
+  if (dy > EPS) clipPoint(best, dy, y, start.y, z, z + 1, x, x + 1, start.z, dz, start.x, dx)
+  else if (dy < -EPS) clipPoint(best, dy, y + 1, start.y, z, z + 1, x, x + 1, start.z, dz, start.x, dx)
+  if (dz > EPS) clipPoint(best, dz, z, start.z, x, x + 1, y, y + 1, start.x, dx, start.y, dy)
+  else if (dz < -EPS) clipPoint(best, dz, z + 1, start.z, x, x + 1, y, y + 1, start.x, dx, start.y, dy)
+  return best.hit ? { x: start.x + best.t * dx, y: start.y + best.t * dy, z: start.z + best.t * dz } : null
+}
+
+// voxel walk of one corner of the box from start to end; calls hit(cx, cy, cz, point, step) on every cell it enters
+function walk (start, end, limited, hit) {
+  const d = { x: end.x - start.x, y: end.y - start.y, z: end.z - start.z }
+  let cx = Math.floor(start.x); let cy = Math.floor(start.y); let cz = Math.floor(start.z)
+  const sx = sign(d.x); const sy = sign(d.y); const sz = sign(d.z)
+  const tx = sx === 0 ? Number.MAX_VALUE : sx / d.x
+  const ty = sy === 0 ? Number.MAX_VALUE : sy / d.y
+  const tz = sz === 0 ? Number.MAX_VALUE : sz / d.z
+  let nx = tx * (sx > 0 ? 1 - frac(start.x) : frac(start.x))
+  let ny = ty * (sy > 0 ? 1 - frac(start.y) : frac(start.y))
+  let nz = tz * (sz > 0 ? 1 - frac(start.z) : frac(start.z))
+  let steps = 0
+  while (nx <= 1 || ny <= 1 || nz <= 1) {
+    if (nx < ny) {
+      if (nx < nz) { cx += sx; nx += tx } else { cz += sz; nz += tz }
+    } else if (ny < nz) { cy += sy; ny += ty } else { cz += sz; nz += tz }
+    if (limited && steps++ > STEP_LIMIT) break
+    const point = clip(cx, cy, cz, start, end)
+    if (!point) continue
+    if (!limited) steps++
+    if (hit(cx, cy, cz, point, steps) === false) return -1
+  }
+  return steps
+}
+
+const clamp = (v, lo, hi) => v < lo ? lo : (v > hi ? hi : v)
+const clampInto = (point, cx, cy, cz) => ({
+  x: clamp(point.x, cx + DEFLATE, cx + 1 - DEFLATE),
+  y: clamp(point.y, cy + DEFLATE, cy + 1 - DEFLATE),
+  z: clamp(point.z, cz + DEFLATE, cz + 1 - DEFLATE)
+})
+
+// 1.21.2 - 1.21.8: the min corner of the box walks the movement; every cell hit adds a box-sized block range
+function legacyAlongTravel (box, direction, nudge, visit) {
+  const len = Math.sqrt(direction.x ** 2 + direction.y ** 2 + direction.z ** 2)
+  const n = nudge ? { x: direction.x / len * EPS, y: direction.y / len * EPS, z: direction.z / len * EPS } : { x: 0, y: 0, z: 0 }
+  const end = { x: box.minX + n.x, y: box.minY + n.y, z: box.minZ + n.z }
+  const start = { x: box.minX - direction.x - n.x, y: box.minY - direction.y - n.y, z: box.minZ - direction.z - n.z }
+  const sizeX = box.maxX - box.minX; const sizeY = box.maxY - box.minY; const sizeZ = box.maxZ - box.minZ
+  return walk(start, end, true, (cx, cy, cz, point, step) => {
+    const c = clampInto(point, cx, cy, cz)
+    const ex = Math.floor(c.x + sizeX); const ey = Math.floor(c.y + sizeY); const ez = Math.floor(c.z + sizeZ)
+    for (let x = cx; x <= ex; x++) {
+      for (let y = cy; y <= ey; y++) {
+        for (let z = cz; z <= ez; z++) visit(x, y, z, step)
+      }
+    }
+  })
+}
+
+// BlockCollisions#getFurthestCorner (1.21.10+)
+function furthestCorner (v) {
+  const ax = Math.abs(v.x); const ay = Math.abs(v.y); const az = Math.abs(v.z)
+  const xs = v.x >= 0 ? 1 : -1; const ys = v.y >= 0 ? 1 : -1; const zs = v.z >= 0 ? 1 : -1
+  if (ax <= ay && ax <= az) return { x: -xs, y: -zs, z: ys }
+  return ay <= az ? { x: zs, y: -ys, z: -xs } : { x: -ys, y: xs, z: -zs }
+}
+
+// 1.21.9+: BlockGetter#forEachBlockIntersectedBetween
+function modernBetween (from, to, box, visit) {
+  const d = { x: to.x - from.x, y: to.y - from.y, z: to.z - from.z }
+  if (d.x * d.x + d.y * d.y + d.z * d.z < TINY_MOVE_SQ) {
+    forEachBetweenClosed(box, (x, y, z) => visit(x, y, z, 0))
+    return
+  }
+  const seen = seenBetween.clear()
+  const back = box.move(-d.x, -d.y, -d.z)
+  const ok = forEachBetweenCorners(Math.floor(back.minX), Math.floor(back.minY), Math.floor(back.minZ),
+    Math.floor(back.maxX), Math.floor(back.maxY), Math.floor(back.maxZ), d, (x, y, z) => {
+      if (visit(x, y, z, 0) === false) return false
+      seen.add(x, y, z)
+    })
+  if (!ok) return
+  const sizeX = box.maxX - box.minX; const sizeY = box.maxY - box.minY; const sizeZ = box.maxZ - box.minZ
+  const corner = furthestCorner(d)
+  const center = { x: box.minX + 0.5 * sizeX, y: box.minY + 0.5 * sizeY, z: box.minZ + 0.5 * sizeZ }
+  const end = { x: center.x + sizeX * 0.5 * corner.x, y: center.y + sizeY * 0.5 * corner.y, z: center.z + sizeZ * 0.5 * corner.z }
+  const start = { x: end.x - d.x, y: end.y - d.y, z: end.z - d.z }
+  const steps = walk(start, end, false, (cx, cy, cz, point, step) => {
+    const c = clampInto(point, cx, cy, cz)
+    const ex = Math.floor(c.x - sizeX * corner.x); const ey = Math.floor(c.y - sizeY * corner.y); const ez = Math.floor(c.z - sizeZ * corner.z)
+    return forEachBetweenCorners(cx, cy, cz, ex, ey, ez, d, (x, y, z) => {
+      if (seen.add(x, y, z)) return visit(x, y, z, step)
+    })
+  })
+  if (steps < 0) return
+  forEachBetweenCorners(Math.floor(box.minX), Math.floor(box.minY), Math.floor(box.minZ),
+    Math.floor(box.maxX), Math.floor(box.maxY), Math.floor(box.maxZ), d, (x, y, z) => {
+      if (seen.add(x, y, z)) return visit(x, y, z, steps + 1)
+    })
+}
+
+/**
+ * Visits the blocks touched by this tick's movements in game order.
+ * moves: [{ from, to, input }] where input is the movement asked of Entity#move (1.21.5+), or null.
+ * visit(x, y, z, applyVelocity)
+ */
+function traverseMoves (player, moves, visit) {
+  const pv = player.V.protocol
+  const boxAt = (p) => player.bbAt(p.x, p.y, p.z).deflate(DEFLATE)
+
+  if (pv < 769) { // 1.21.2 - 1.21.3: the final box, nudged walk
+    const box = player.bb().deflate(DEFLATE)
+    for (const { from, to } of moves) {
+      const d = { x: to.x - from.x, y: to.y - from.y, z: to.z - from.z }
+      if (d.x * d.x + d.y * d.y + d.z * d.z < SHORT_MOVE_SQ) {
+        forEachBetweenClosed(box, (x, y, z) => visit(x, y, z, true))
+        continue
+      }
+      const list = ordered.clear()
+      const add = (x, y, z) => { list.add(x, y, z) }
+      legacyAlongTravel(box, d, true, add)
+      forEachBetweenClosed(box, add)
+      list.forEach((x, y, z) => visit(x, y, z, true))
+    }
+    return
+  }
+
+  if (pv < 770) { // 1.21.4: box at the end of each movement
+    for (const { from, to } of moves) {
+      const box = boxAt(to)
+      const d = { x: to.x - from.x, y: to.y - from.y, z: to.z - from.z }
+      if (d.x * d.x + d.y * d.y + d.z * d.z < SHORT_MOVE_SQ) {
+        forEachBetweenClosed(box, (x, y, z) => visit(x, y, z, true))
+        continue
+      }
+      const list = ordered.clear()
+      const add = (x, y, z) => { list.add(x, y, z) }
+      legacyAlongTravel(box, d, false, add)
+      forEachBetweenClosed(box, add)
+      list.forEach((x, y, z) => visit(x, y, z, true))
+    }
+    return
+  }
+
+  const modern = pv >= 773
+  for (const move of moves) {
+    const delta = { x: move.to.x - move.from.x, y: move.to.y - move.from.y, z: move.to.z - move.from.z }
+    let budget = STEP_LIMIT
+    const segment = (from, to, limit) => {
+      const box = boxAt(to)
+      if (!modern) {
+        const d = { x: to.x - from.x, y: to.y - from.y, z: to.z - from.z }
+        if (d.x * d.x + d.y * d.y + d.z * d.z < SHORT_MOVE_SQ) {
+          forEachBetweenClosed(box, (x, y, z) => visit(x, y, z, true))
+          return 0
+        }
+        const seen = seenAlong.clear()
+        const steps = legacyAlongTravel(box, d, false, (x, y, z) => {
+          if (seen.add(x, y, z)) visit(x, y, z, true)
+        })
+        forEachBetweenClosed(box, (x, y, z) => { if (!seen.has(x, y, z)) visit(x, y, z, true) })
+        return steps
+      }
+      const far = (to.x - from.x) ** 2 + (to.y - from.y) ** 2 + (to.z - from.z) ** 2 > FAR_SQ
+      let reached = 0
+      modernBetween(from, to, box, (x, y, z, step) => {
+        if (step >= limit) return false
+        reached = step
+        visit(x, y, z, far || box.intersects(x, y, z, x + 1, y + 1, z + 1))
+      })
+      return reached + 1
+    }
+    if (move.input && (delta.x || delta.y || delta.z)) {
+      let from = move.from
+      for (const axis of axisStepOrder(modern ? move.input : delta)) {
+        const value = delta[axis]
+        if (value === 0) continue
+        const to = { ...from, [axis]: from[axis] + value }
+        budget -= segment(from, to, budget)
+        from = to
+      }
+    } else {
+      budget -= segment(move.from, move.to, STEP_LIMIT)
+    }
+    if (modern && budget <= 0) segment(move.to, move.to, 1)
+  }
+}
+
+module.exports = { traverseMoves, BlockList, forEachBetweenCorners, furthestCorner, clip }

package/lib/engine/version.js

@@ -1,52 +1,77 @@
 'use strict'
-// Version switches for client behaviour that differs between 1.16.5 and 26.x.
-// Uses the protocol version number so "1.21.3" (768) == "1.21.2" etc.
+// Client behaviour that changed between 1.16.5 and 26.x, keyed by protocol number
+// ("1.21.3" is 768, the same as 1.21.2).
 
 const PV = {
   '1.16.5': 754,
   '1.17': 755,
+  '1.18.2': 758,
   '1.19.4': 762,
   '1.20': 763,
   '1.20.2': 764,
-  '1.20.3': 765,
   '1.20.5': 766,
   '1.21': 767,
   '1.21.2': 768,
   '1.21.4': 769,
   '1.21.5': 770,
   '1.21.6': 771,
-  '1.21.9': 773
+  '1.21.9': 773,
+  '26.1': 775
 }
 
 function versionFlags (registry) {
-  const pv = registry.version['>='] ? registry.version.version : registry.version
+  const pv = registry.version.version
   const at = (name) => pv >= PV[name]
   return {
     protocol: pv,
     name: registry.version.minecraftVersion,
-    // login / configuration
-    configPhase: at('1.20.2'), // brand + client information are sent in the configuration phase
-    // movement packets
-    movementFlags: at('1.21.2'), // onGround + horizontalCollision bitflags in move packets
-    tickEnd: at('1.21.2'), // ServerboundClientTickEndPacket after every client tick
-    playerInputPacket: at('1.21.2'), // ServerboundPlayerInputPacket sent on key change (replaces steer_vehicle)
-    shiftInInput: at('1.21.6'), // no more PRESS/RELEASE_SHIFT_KEY player commands
-    clientLoaded: at('1.21.4'), // player does not tick until the level screen closes, then sends player_loaded
-    posRotBeforeConfirm: pv === PV['1.21.2'], // 1.21.2/1.21.3 answer teleports with pos-rot *before* accept-teleportation
-    relativeTeleportVelocity: at('1.21.2'), // teleport packet carries delta movement + delta flags
-    lpVelocity: at('1.21.9'), // entity_velocity uses lpVec3 (already blocks/tick)
-    // physics
-    posFromBoundingBox: !at('1.17'), // 1.16 recalculates the position from the bounding box centre
-    flyingSpeedLive: at('1.19.4'), // Player#getFlyingSpeed() instead of the lagging flyingSpeed field
-    minorCollision: at('1.19.4'), // sprinting survives "minor" horizontal collisions
-    supportingBlock: at('1.20'), // mainSupportingBlockPos drives the block below
-    attributes2005: at('1.20.5'), // gravity / step_height / jump_strength attributes
-    jumpKeepsHigherY: at('1.21'),
-    modernStepUp: at('1.21'), // collectCandidateStepUpHeights step algorithm
-    normalizedInput: at('1.21.2'), // KeyboardInput#moveVector is normalized
-    modernBackOff: at('1.21.2'), // canFallAtLeast based sneak edge back-off
-    squareInput: at('1.21.5'), // modifyInputSpeedForSquareMovement
+
+    // connection
+    configPhase: at('1.20.2'),
+    movementFlags: at('1.21.2'),
+    tickEnd: at('1.21.2'),
+    playerInputPacket: at('1.21.2'),
+    shiftInInput: at('1.21.6'),
+    clientLoaded: at('1.21.4'),
+    posRotBeforeConfirm: pv === PV['1.21.2'],
+    relativeTeleportVelocity: at('1.21.2'),
+    lpVelocity: at('1.21.9'),
+    pointThree: !at('1.18.2'), // position is only reported after moving 0.03 (later 0.0002)
+
+    // input
+    inputModel: at('1.21.5') ? 'modern' : 'legacy',
+    floatSqrt: !at('1.17'),
+    normalizeEpsilon: at('1.21.2') ? Math.fround(1.0e-5) : 1.0e-4,
+    horizontalThreshold: at('1.21.5'), // tiny horizontal speed is cut by length, not per axis
+
+    // movement
+    posFromBoundingBox: !at('1.17'),
+    epsilonCollisionFlags: at('1.18.2'),
+    keepsXOnCornerCollision: !at('1.18.2'), // 1.14 - 1.18.1 bug
+    modernMoveThreshold: at('1.21.2'),
+    modernStepUp: at('1.21'),
+    supportingBlock: at('1.20'),
+    minorCollision: at('1.19.4'),
     fallDistanceDouble: at('1.21.5'),
+
+    // speed
+    flyingSpeedLive: at('1.19.4'),
+    airSprintFloatSum: at('1.18.2'),
+    attributes2005: at('1.20.5'),
+    efficiencyAttributes: at('1.21'), // movement_efficiency / water_movement_efficiency
+    soulSpeedBoots: pv >= 751 && !at('1.21'),
+    jumpDoubleSprintBoost: at('1.20.5'),
+    jumpKeepsHigherY: at('1.21.2'),
+
+    // world interaction
+    blockEffectsAfterTravel: at('1.21.2'),
+    blockEffectsPerAxis: at('1.21.5'),
+    insideBlockDeflate: at('1.19.4') ? 1.0e-5 : 0.001,
+    fluidRecheckInMove: pv !== PV['1.21.4'],
+    fluidInteraction: at('26.1'), // one pass over water and lava, also used by the recheck in move
+    swimmingNeedsFeetInWater: at('1.17'),
+    powderSnow: at('1.17'),
+
     // vehicles
     moveVehicleOnGround: at('1.21.2')
   }