spectra-physics 1.1.0 → 1.3.0

package/lib/client/riding.js

@@ -17,20 +17,23 @@ function riderOffset (vehicle) {
 function installRiding (ctx) {
   const { bot, V, player, state, world } = ctx
 
-  function tickBoat (vehicle, keys) {
+  // the boat ticks before its rider, so it steers with the keys the rider set on the previous tick (Boat#setInput)
+  function tickBoat (vehicle) {
     if (!state.boat || state.boat.entityId !== vehicle.id) {
       state.boat = new BoatPhysics(world, V, { position: vehicle.position, yawDegrees: f32(conv.toNotchianYaw(vehicle.yaw)) })
       state.boat.entityId = vehicle.id
+      state.boat.input = { forward: false, back: false, left: false, right: false }
     }
-    state.boat.tick({ forward: keys.forward, back: keys.back, left: keys.left, right: keys.right })
+    state.boat.tick(state.boat.input)
     ctx.send('steer_boat', { leftPaddle: state.boat.paddle[0], rightPaddle: state.boat.paddle[1] })
     vehicle.position.set(state.boat.pos.x, state.boat.pos.y, state.boat.pos.z)
   }
 
   ctx.ridingTick = (vehicle) => {
+    ctx.flushActions()
     const keys = ctx.keys()
     const controlling = vehicle.passengers?.[0] === bot.entity
-    if (isBoat(vehicle) && controlling) tickBoat(vehicle, keys)
+    if (isBoat(vehicle) && controlling) tickBoat(vehicle)
     else state.boat = null
 
     player.riding = true
@@ -44,6 +47,7 @@ function installRiding (ctx) {
       player.yRot = f32(player.yRot + clamp(offset, -105, 105) - offset)
     }
     ctx.syncEntity()
+    if (state.boat) state.boat.input = { forward: keys.forward, back: keys.back, left: keys.left, right: keys.right }
 
     if (!V.playerInputPacket) {
       ctx.sendLook()

package/lib/client/server.js

@@ -85,6 +85,19 @@ function installServerHandlers (ctx) {
     state.boat = null
     bot.emit('dismount', vehicle)
   })
+
+  // the passenger list replaces the old one; mineflayer only appends and only leaves on vehicle id -1,
+  // which the server never sends, so a bot stays "mounted" after every dismount
+  client.on('set_passengers', ({ entityId, passengers }) => {
+    const vehicle = bot.entities[entityId]
+    if (vehicle) vehicle.passengers = passengers.map(id => bot.entities[id]).filter(Boolean)
+    const current = bot.vehicle
+    if (!current || current.id !== entityId || passengers.includes(bot.entity?.id)) return
+    bot.vehicle = null
+    if (bot.entity) bot.entity.vehicle = null
+    state.boat = null
+    bot.emit('dismount', current)
+  })
 }
 
 module.exports = { installServerHandlers }

package/lib/client/simulation.js

@@ -0,0 +1,35 @@
+'use strict'
+// bot.physics.simulatePlayer for plugins written against prismarine-physics (mineflayer-pathfinder plans
+// its jumps with it): the prediction runs on this engine, so plans match how the bot really moves.
+
+const conv = require('mineflayer/lib/conversions')
+
+function installSimulation (ctx) {
+  const { bot, player } = ctx
+  const running = new WeakMap()
+
+  bot.physics.simulatePlayer = (state) => {
+    let sim = running.get(state)
+    if (!sim) {
+      sim = player.clone()
+      running.set(state, sim)
+    }
+    sim.pos = { x: state.pos.x, y: state.pos.y, z: state.pos.z }
+    sim.vel = { x: state.vel.x, y: state.vel.y, z: state.vel.z }
+    sim.onGround = !!state.onGround
+    sim.yRot = conv.toNotchianYaw(state.yaw)
+    sim.xRot = conv.toNotchianPitch(state.pitch)
+    const c = state.control ?? {}
+    sim.tick({ forward: !!c.forward, back: !!c.back, left: !!c.left, right: !!c.right, jump: !!c.jump, sprint: !!c.sprint, sneak: !!c.sneak })
+    state.pos.set(sim.pos.x, sim.pos.y, sim.pos.z)
+    state.vel.set(sim.vel.x, sim.vel.y, sim.vel.z)
+    state.onGround = sim.onGround
+    state.isInWater = sim.isInWater()
+    state.isInLava = sim.isInLava()
+    state.isCollidedHorizontally = sim.horizontalCollision
+    state.isCollidedVertically = sim.verticalCollision
+    return state
+  }
+}
+
+module.exports = { installSimulation }

package/lib/client/ticker.js

@@ -1,10 +1,8 @@
 'use strict'
 // Minecraft#tick for the local player plus the timer that drives it.
 
-const { performance } = require('perf_hooks')
+const { startTicking, stopTicking } = require('./clock')
 
-const TICK_MS = 50
-const MAX_CATCH_UP = 10
 const LOAD_TIMEOUT_TICKS = 60
 const MAX_TURN_DELAY = 40
 
@@ -67,12 +65,14 @@ function installTicker (ctx) {
     }
     if (bot.isAlive === false) return
     player.riding = false
+    ctx.updateItemUse()
     // 1.17 - 1.18.1: a turn while creeping through the air can't be reported cleanly, the mouse waits a moment
     if (state.creeping && state.turnDelay < MAX_TURN_DELAY) state.turnDelay++
     else {
       ctx.turn(state.turnDelay >= MAX_TURN_DELAY ? Infinity : undefined)
       state.turnDelay = 0
     }
+    ctx.flushActions()
     if (bot.physicsEnabled) {
       player.tick(ctx.keys())
       if (player.events.abilitiesChanged) {
@@ -102,25 +102,13 @@ function installTicker (ctx) {
       state.boat = null
       playerTick()
     }
+    ctx.flushActions()
     if (V.tickEnd) ctx.send('tick_end', {})
     bot.emit('physicsTick')
   }
 
-  let timer = null
-  let nextAt = 0
-  function start () {
-    if (timer) return
-    nextAt = performance.now() + TICK_MS
-    const loop = () => {
-      const now = performance.now()
-      for (let n = 0; now >= nextAt && n < MAX_CATCH_UP; n++) {
-        try { clientTick() } catch (err) { bot.emit('error', err) }
-        nextAt += TICK_MS
-      }
-      if (now - nextAt > 1000) nextAt = now + TICK_MS
-      timer = setTimeout(loop, Math.max(0, nextAt - performance.now()))
-    }
-    timer = setTimeout(loop, TICK_MS)
+  const tick = () => {
+    try { clientTick() } catch (err) { bot.emit('error', err) }
   }
 
   client.on('login', () => {
@@ -129,14 +117,11 @@ function installTicker (ctx) {
     state.selectedSlot = 0
     state.carriedSlot = 0
     resetPlayer()
-    start()
+    startTicking(tick)
   })
   client.on('respawn', resetPlayer)
   client.on('start_configuration', () => { state.inLevel = false })
-  bot.on('end', () => {
-    clearTimeout(timer)
-    timer = null
-  })
+  bot.on('end', () => stopTicking(tick))
 
   resetPlayer()
 }

package/lib/engine/aabb.js

@@ -34,9 +34,11 @@ class AABB {
 
   // strict positive-volume intersection (Shapes.joinIsNotEmpty(..., AND))
   intersectsBox (b) {
-    return b[0] < this.maxX && b[3] > this.minX &&
-      b[1] < this.maxY && b[4] > this.minY &&
-      b[2] < this.maxZ && b[5] > this.minZ
+    return this.intersects(b[0], b[1], b[2], b[3], b[4], b[5])
+  }
+
+  intersects (minX, minY, minZ, maxX, maxY, maxZ) {
+    return minX < this.maxX && maxX > this.minX && minY < this.maxY && maxY > this.minY && minZ < this.maxZ && maxZ > this.minZ
   }
 
   min (axis) { return axis === 0 ? this.minX : (axis === 1 ? this.minY : this.minZ) }

package/lib/engine/boat.js

@@ -18,12 +18,14 @@ class BoatPhysics {
     this.yRot = entity.yawDegrees ?? 0
     this.xRot = 0
     this.deltaRotation = 0
-    this.status = 'IN_AIR'
-    this.oldStatus = 'IN_AIR'
     this.landFriction = 0
     this.waterLevel = 0
+    this.lastYd = 0
     this.onGround = false
     this.paddle = [false, false]
+    // the boat already ticked its status before this client took control
+    this.status = this.getStatus()
+    this.oldStatus = this.status
   }
 
   bb () {
@@ -57,6 +59,42 @@ class BoatPhysics {
     return n > 0 ? f32(sum / n) : 0
   }
 
+  // Boat#isUnderwater
+  underwater () {
+    const bb = this.bb()
+    const top = bb.maxY + 0.001
+    let under = false
+    for (let x = Math.floor(bb.minX); x < Math.ceil(bb.maxX); x++) {
+      for (let y = Math.floor(bb.maxY); y < Math.ceil(top); y++) {
+        for (let z = Math.floor(bb.minZ); z < Math.ceil(bb.maxZ); z++) {
+          const fl = this.world.fluidAt(x, y, z)
+          if (!fl || fl.type !== 'water' || !(top < y + this.world.fluidHeight(x, y, z, fl))) continue
+          if (!fl.source) return 'UNDER_FLOWING_WATER'
+          under = true
+        }
+      }
+    }
+    return under ? 'UNDER_WATER' : null
+  }
+
+  // Boat#getWaterLevelAbove
+  waterLevelAbove () {
+    const bb = this.bb()
+    const top = Math.ceil(bb.maxY - this.lastYd)
+    for (let y = Math.floor(bb.maxY); y < top; y++) {
+      let level = 0
+      for (let x = Math.floor(bb.minX); x < Math.ceil(bb.maxX) && level < 1; x++) {
+        for (let z = Math.floor(bb.minZ); z < Math.ceil(bb.maxZ); z++) {
+          const fl = this.world.fluidAt(x, y, z)
+          if (fl && fl.type === 'water') level = Math.max(level, this.world.fluidHeight(x, y, z, fl))
+          if (level >= 1) break
+        }
+      }
+      if (level < 1) return f32(y + level)
+    }
+    return top + 1
+  }
+
   inWater () {
     const bb = this.bb()
     const x0 = Math.floor(bb.minX); const x1 = Math.ceil(bb.maxX)
@@ -69,7 +107,7 @@ class BoatPhysics {
         for (let z = z0; z < z1; z++) {
           const fl = this.world.fluidAt(x, y, z)
           if (fl && fl.type === 'water') {
-            const top = y + this.world.fluidHeight(x, y, z, fl)
+            const top = f32(y + this.world.fluidHeight(x, y, z, fl))
             this.waterLevel = Math.max(top, this.waterLevel)
             found = found || bb.minY < top
           }
@@ -80,6 +118,11 @@ class BoatPhysics {
   }
 
   getStatus () {
+    const under = this.underwater()
+    if (under) {
+      this.waterLevel = this.bb().maxY
+      return under
+    }
     if (this.inWater()) return 'IN_WATER'
     const f = this.groundFriction()
     if (f > 0) { this.landFriction = f; return 'ON_LAND' }
@@ -89,16 +132,22 @@ class BoatPhysics {
   floatBoat () {
     let d2 = 0
     let inv = f32(0.05)
+    let gravity = G
     if (this.oldStatus === 'IN_AIR' && this.status !== 'IN_AIR' && this.status !== 'ON_LAND') {
-      this.pos.y = this.waterLevel - BOAT_H + 0.101
-      this.vel.y = 0
+      this.waterLevel = this.pos.y + BOAT_H
+      const y = this.waterLevelAbove() - BOAT_H + 0.101
+      if (this.world.noCollision(this.bb().move(0, y - this.pos.y, 0))) {
+        this.pos.y = y
+        this.vel.y = 0
+        this.lastYd = 0
+      }
       this.status = 'IN_WATER'
       return
     }
-    if (this.status === 'IN_WATER') { d2 = (this.waterLevel - this.pos.y) / BOAT_H; inv = f32(0.9) } else if (this.status === 'IN_AIR') inv = f32(0.9)
+    if (this.status === 'IN_WATER') { d2 = (this.waterLevel - this.pos.y) / BOAT_H; inv = f32(0.9) } else if (this.status === 'UNDER_FLOWING_WATER') { gravity = -7.0e-4; inv = f32(0.9) } else if (this.status === 'UNDER_WATER') { d2 = f32(0.01); inv = f32(0.45) } else if (this.status === 'IN_AIR') inv = f32(0.9)
     else if (this.status === 'ON_LAND') { inv = this.landFriction; this.landFriction = f32(this.landFriction / 2) }
     this.vel.x *= inv
-    this.vel.y += G
+    this.vel.y += gravity
     this.vel.z *= inv
     this.deltaRotation = f32(this.deltaRotation * inv)
     if (d2 > 0) this.vel.y = (this.vel.y + d2 * 0.06153846016296973) * 0.75
@@ -125,6 +174,7 @@ class BoatPhysics {
     this.controlBoat(keys)
     const collide = this.V.modernStepUp ? collideModern : collideLegacy
     const r = collide(this.world, this.vel.x, this.vel.y, this.vel.z, this.bb(), this.onGround, 0)
+    this.lastYd = this.vel.y
     if (r.x * r.x + r.y * r.y + r.z * r.z > 1.0e-7) { this.pos.x += r.x; this.pos.y += r.y; this.pos.z += r.z }
     const vertical = this.vel.y !== r.y
     this.onGround = vertical && this.vel.y < 0

package/lib/engine/player/effects.js

@@ -1,14 +1,12 @@
 'use strict'
 
-const AABB = require('../aabb')
 const { f32 } = require('../mth')
+const { traverseMoves, BlockList } = require('./traversal')
 
 const F_098 = f32(0.98)
 const F_08 = f32(0.8)
 const F_09 = f32(0.9)
 const F_005 = f32(0.05)
-const F_1EM5 = f32(1.0e-5)
-const LONG_MOVE = f32(0.99999) * f32(0.99999)
 const HALF_WIDTH = f32(0.3)
 
 const STUCK = {
@@ -69,6 +67,8 @@ function onInsideBlock (player, block, bx, by, bz, withVelocityEffects) {
   }
 }
 
+const visited = new BlockList()
+
 function forEachBlockIn (box, visit) {
   const x0 = Math.floor(box.minX); const x1 = Math.floor(box.maxX)
   const y0 = Math.floor(box.minY); const y1 = Math.floor(box.maxY)
@@ -94,57 +94,20 @@ function checkInsideBlocksLegacy (player) {
   settleStuck(player)
 }
 
-// voxel walk of the box corner between two points, used for moves longer than a block
-function blocksAlongTravel (from, to, box, out) {
-  const dx = to.x - from.x; const dy = to.y - from.y; const dz = to.z - from.z
-  const start = { x: box.minX - dx, y: box.minY - dy, z: box.minZ - dz }
-  let cx = Math.floor(start.x); let cy = Math.floor(start.y); let cz = Math.floor(start.z)
-  const sx = Math.sign(dx); const sy = Math.sign(dy); const sz = Math.sign(dz)
-  const tx = sx === 0 ? Infinity : sx / dx
-  const ty = sy === 0 ? Infinity : sy / dy
-  const tz = sz === 0 ? Infinity : sz / dz
-  const frac = (v) => v - Math.floor(v)
-  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))
-  const sizeX = box.maxX - box.minX; const sizeY = box.maxY - box.minY; const sizeZ = box.maxZ - box.minZ
-  for (let steps = 0; (nx <= 1 || ny <= 1 || nz <= 1) && steps <= 16; steps++) {
-    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 }
-    forEachBlockIn(new AABB(cx, cy, cz, cx + sizeX, cy + sizeY, cz + sizeZ), (x, y, z) => out.add(`${x},${y},${z}`))
-  }
-}
-
 // Entity#applyEffectsFromBlocks, 1.21.2+: after travel, along every movement made this tick
 function applyEffectsAfterTravel (player) {
   if (!player.V.blockEffectsAfterTravel) return
   player.stuck = null
-  const end = { ...player.pos }
-  const moves = player.V.blockEffectsPerAxis && player.movesThisTick.length ? [...player.movesThisTick] : [{ from: player.tickStart, to: end }]
+  const end = { x: player.pos.x, y: player.pos.y, z: player.pos.z }
+  const moves = player.V.blockEffectsPerAxis && player.movesThisTick.length ? player.movesThisTick.slice() : [{ from: player.tickStart, to: end, input: null }]
   const last = moves[moves.length - 1].to
-  if ((last.x - end.x) ** 2 + (last.y - end.y) ** 2 + (last.z - end.z) ** 2 > 9.9999994e-11) moves.push({ from: last, to: end })
-  const visited = new Set()
-  for (const { from, to } of moves) {
-    const endBox = player.bbAt(to.x, to.y, to.z).deflate(F_1EM5)
-    const keys = new Set()
-    forEachBlockIn(endBox, (x, y, z) => keys.add(`${x},${y},${z}`))
-    const lengthSq = (to.x - from.x) ** 2 + (to.y - from.y) ** 2 + (to.z - from.z) ** 2
-    const far = lengthSq >= LONG_MOVE
-    if (player.V.blockEffectsPerAxis && lengthSq > 0) {
-      forEachBlockIn(player.bbAt(from.x, from.y, from.z).deflate(F_1EM5), (x, y, z) => keys.add(`${x},${y},${z}`))
-    }
-    if (far) blocksAlongTravel(from, to, endBox, keys)
-    for (const key of keys) {
-      if (visited.has(key)) continue
-      visited.add(key)
-      const [x, y, z] = key.split(',').map(Number)
-      const block = player.world.blockAt(x, y, z)
-      if (block.isAir) continue
-      const inEndBox = endBox.intersectsBox([x, y, z, x + 1, y + 1, z + 1])
-      onInsideBlock(player, block, x, y, z, far || inEndBox)
-    }
-  }
+  if ((last.x - end.x) ** 2 + (last.y - end.y) ** 2 + (last.z - end.z) ** 2 > 9.9999994e-11) moves.push({ from: last, to: end, input: null })
+  visited.clear()
+  traverseMoves(player, moves, (x, y, z, applyVelocity) => {
+    const block = player.world.blockAt(x, y, z)
+    if (block.isAir || !visited.add(x, y, z)) return
+    onInsideBlock(player, block, x, y, z, applyVelocity)
+  })
   player.movesThisTick.length = 0
   settleStuck(player)
 }

package/lib/engine/player/fluids.js

@@ -105,7 +105,19 @@ function updateEyes (player) {
   const by = Math.floor(eyeY)
   const bz = Math.floor(player.pos.z)
   const fluid = player.world.fluidAt(bx, by, bz)
-  player.eyeInWater = !!(fluid && fluid.type === 'water' && by + player.world.fluidHeight(bx, by, bz, fluid) > eyeY)
+  const top = fluid && fluid.type === 'water' ? by + player.world.fluidHeight(bx, by, bz, fluid) : -Infinity
+  // 26.1 EntityFluidInteraction counts the surface itself as inside
+  player.eyeInWater = player.V.fluidInteraction ? top >= eyeY : top > eyeY
+}
+
+const lavaPush = (player) => player.env.ultraWarm() ? 0.007 : 0.0023333333333333335
+
+// 26.1 Entity#updateFluidInteraction: water and lava together
+function updateFluidInteraction (player) {
+  player.fluidHeight.water = 0
+  player.fluidHeight.lava = 0
+  updateWater(player)
+  touchFluid(player, 'lava', lavaPush(player))
 }
 
 // Player#updateSwimming
@@ -122,10 +134,7 @@ function updateSwimming (player) {
 }
 
 function updateFluids (player) {
-  player.fluidHeight.water = 0
-  player.fluidHeight.lava = 0
-  updateWater(player)
-  touchFluid(player, 'lava', player.env.ultraWarm() ? 0.007 : 0.0023333333333333335)
+  updateFluidInteraction(player)
   updateEyes(player)
   updateSwimming(player)
 }
@@ -138,4 +147,4 @@ function fluidFallingAdjusted (player, gravity, falling) {
   else player.vel.y = vy - gravity / 16
 }
 
-module.exports = { updateFluids, updateWater, fluidFallingAdjusted }
+module.exports = { updateFluids, updateWater, updateFluidInteraction, fluidFallingAdjusted }

package/lib/engine/player/index.js

@@ -34,6 +34,13 @@ class PlayerPhysics {
     this.world = world
     this.V = V
     this.env = { ...DEFAULT_ENV, ...env }
+    const player = this
+    this.collisionContext = {
+      get bottom () { return player.pos.y },
+      get fallDistance () { return player.fallDistance },
+      get walksOnPowderSnow () { return player.V.powderSnow && player.env.bootsItem() === 'leather_boots' },
+      get descending () { return player.input.shift }
+    }
     this.reset()
   }
 
@@ -72,6 +79,17 @@ class PlayerPhysics {
     this.events = { abilitiesChanged: false }
   }
 
+  // an independent copy for looking ahead: same world and environment, own state
+  clone () {
+    const copy = new PlayerPhysics(this.world, this.V, this.env)
+    for (const key of Object.keys(this)) {
+      if (key === 'world' || key === 'V' || key === 'env' || key === 'collisionContext') continue
+      const value = this[key]
+      copy[key] = value !== null && typeof value === 'object' ? structuredClone(value) : value
+    }
+    return copy
+  }
+
   height () { return pose.POSES[this.pose].height }
   eyeHeight () { return pose.POSES[this.pose].eye }
   bbAt (x, y, z) { return pose.boxFor(this.pose, x, y, z) }
@@ -94,7 +112,18 @@ class PlayerPhysics {
   }
 
   tick (keys) {
-    this.tickStart = { ...this.pos }
+    this.world.beginTick(this.collisionContext)
+    try {
+      this.tickInner(keys)
+    } finally {
+      this.world.endTick()
+    }
+  }
+
+  tickInner (keys) {
+    this.tickStart.x = this.pos.x
+    this.tickStart.y = this.pos.y
+    this.tickStart.z = this.pos.z
     this.movesThisTick.length = 0
     this.baseTick()
 

package/lib/engine/player/input.js

@@ -9,6 +9,8 @@ const F_MIN_LENGTH = f32(1.0e-4)
 
 const impulse = (positive, negative) => positive === negative ? 0 : (positive ? 1 : -1)
 
+const slowedByItem = (player) => player.env.usingItem() && !player.riding
+
 function sneakMultiplier (player) {
   return player.V.efficiencyAttributes ? f32(player.env.attribute('sneaking_speed', 0.3)) : F_03
 }
@@ -21,7 +23,7 @@ function legacyInput (player, left, forward, slow) {
     const k = sneakMultiplier(player)
     x = f32(x * k); z = f32(z * k)
   }
-  if (player.env.usingItem()) { x = f32(x * F_02); z = f32(z * F_02) }
+  if (slowedByItem(player)) { x = f32(x * F_02); z = f32(z * F_02) }
   return [f32(x * F_098), f32(z * F_098)]
 }
 
@@ -31,7 +33,7 @@ function modernInput (player, left, forward, slow) {
   if (length < F_MIN_LENGTH) return [0, 0]
   let x = f32(f32(left / length) * F_098)
   let z = f32(f32(forward / length) * F_098)
-  if (player.env.usingItem()) { x = f32(x * F_02); z = f32(z * F_02) }
+  if (slowedByItem(player)) { x = f32(x * F_02); z = f32(z * F_02) }
   if (slow) {
     const k = sneakMultiplier(player)
     x = f32(x * k); z = f32(z * k)
@@ -54,6 +56,7 @@ function readKeys (player, keys, slow) {
   const [xxa, zza] = player.V.inputModel === 'modern'
     ? modernInput(player, left, forward, slow)
     : legacyInput(player, left, forward, slow)
+  if (slowedByItem(player)) player.sprintTriggerTime = 0
   player.input = {
     left: xxa,
     forward: zza,

package/lib/engine/player/move.js

@@ -4,7 +4,7 @@ const { f32, sin, cos, degToRadF, equal } = require('../mth')
 const { collideLegacy, collideModern } = require('../collision')
 const { onPos, speedFactor, updateSupportingBlock } = require('./blocks')
 const { checkInsideBlocksLegacy } = require('./effects')
-const { updateWater } = require('./fluids')
+const { updateWater, updateFluidInteraction } = require('./fluids')
 
 const F_066 = f32(0.66)
 const F_1EM5 = f32(1.0e-5)
@@ -78,9 +78,12 @@ function zeroBlockedAxes (player, vx, vz, r) {
     return
   }
   // 1.14 - 1.18.1: the second write restores X when both axes are blocked
-  const before = { ...player.vel }
-  if (vx !== r.x) player.vel = { x: 0, y: before.y, z: before.z }
-  if (vz !== r.z) player.vel = { x: V.keepsXOnCornerCollision ? before.x : player.vel.x, y: before.y, z: 0 }
+  const x = player.vel.x
+  if (vx !== r.x) player.vel.x = 0
+  if (vz !== r.z) {
+    if (V.keepsXOnCornerCollision) player.vel.x = x
+    player.vel.z = 0
+  }
 }
 
 // Entity#move(MoverType.SELF, movement)
@@ -95,7 +98,7 @@ function move (player, mx, my, mz) {
   mx = bx; mz = bz
 
   const bb = player.bb()
-  const from = { ...player.pos }
+  const from = V.blockEffectsPerAxis ? { ...player.pos } : null
   const collide = V.modernStepUp ? collideModern : collideLegacy
   const r = collide(player.world, mx, my, mz, bb, player.onGround, player.maxUpStep())
   const lengthSq = r.x * r.x + r.y * r.y + r.z * r.z
@@ -111,7 +114,10 @@ function move (player, mx, my, mz) {
   player.onGround = player.verticalCollision && my < 0
   updateSupportingBlock(player, player.onGround, r.x, r.z)
 
-  if (V.fluidRecheckInMove && !player.wasTouchingWater && !player.riding) updateWater(player)
+  if (V.fluidRecheckInMove && !player.wasTouchingWater && !player.riding) {
+    if (V.fluidInteraction) updateFluidInteraction(player)
+    else updateWater(player)
+  }
   if (player.onGround) {
     player.fallDistance = 0
   } else if (r.y < 0) {
@@ -124,7 +130,7 @@ function move (player, mx, my, mz) {
   if (my !== r.y) landOn(player, block)
   if (player.onGround && !player.input.shift) stepOn(player, block)
 
-  if (V.blockEffectsPerAxis && applies) player.movesThisTick.push({ from, to: { ...player.pos } })
+  if (V.blockEffectsPerAxis && applies) player.movesThisTick.push({ from, to: { ...player.pos }, input: { x: mx, y: my, z: mz } })
   if (!V.blockEffectsAfterTravel) checkInsideBlocksLegacy(player)
 
   const factor = speedFactor(player)

package/lib/engine/player/pose.js

@@ -49,7 +49,7 @@ function suffocatesAt (player, bx, bz) {
         const block = player.world.blockAt(x, y, z)
         if (!block.suffocating) continue
         for (const s of block.shapes) {
-          if (box.intersectsBox([s[0] + x, s[1] + y, s[2] + z, s[3] + x, s[4] + y, s[5] + z])) return true
+          if (box.intersects(s[0] + x, s[1] + y, s[2] + z, s[3] + x, s[4] + y, s[5] + z)) return true
         }
       }
     }