spectra-physics 1.0.0 → 1.1.0

package/lib/client/server.js

@@ -0,0 +1,90 @@
+'use strict'
+// Clientbound packets that change the local player, answered the way the game client does.
+
+const { f32 } = require('../engine/mth')
+
+function installServerHandlers (ctx) {
+  const { bot, client, V, player, state, registry } = ctx
+
+  client.on('abilities', (packet) => {
+    const flags = packet.flags
+    player.abilities.invulnerable = !!(flags & 1)
+    player.abilities.flying = !!(flags & 2)
+    player.abilities.mayfly = !!(flags & 4)
+    player.abilities.instabuild = !!(flags & 8)
+    player.abilities.flyingSpeed = f32(packet.flyingSpeed)
+    player.abilities.walkingSpeed = f32(packet.walkingSpeed)
+  })
+
+  client.on('entity_velocity', (packet) => {
+    if (!bot.entity || packet.entityId !== bot.entity.id) return
+    const scale = V.lpVelocity ? 1 : 1 / 8000
+    player.vel = { x: packet.velocity.x * scale, y: packet.velocity.y * scale, z: packet.velocity.z * scale }
+  })
+
+  client.on('explosion', (packet) => {
+    const push = packet.playerKnockback ??
+      (('playerMotionX' in packet) ? { x: packet.playerMotionX, y: packet.playerMotionY, z: packet.playerMotionZ } : null)
+    if (!push) return
+    player.vel.x += push.x
+    player.vel.y += push.y
+    player.vel.z += push.z
+  })
+
+  // an invalid slot is ignored, a valid one is confirmed on the next tick by MultiPlayerGameMode#tick
+  client.removeAllListeners('held_item_slot')
+  const select = (slot) => {
+    state.selectedSlot = slot
+    bot.quickBarSlot = slot
+    try { bot.updateHeldItem?.() } catch (e) {}
+  }
+  client.on('held_item_slot', (packet) => {
+    const slot = packet.slot ?? packet.slotId
+    if (slot >= 0 && slot <= 8) select(slot)
+  })
+  bot.setQuickBarSlot = (slot) => {
+    if (!(slot >= 0 && slot < 9)) throw new Error('invalid hotbar slot ' + slot)
+    select(slot)
+  }
+
+  // LocalPlayer#swing is triggered by the animate packet for our own entity and sends a swing back
+  client.on('animation', (packet) => {
+    if (!bot.entity || packet.entityId !== bot.entity.id) return
+    if (packet.animation === 0) ctx.send('arm_animation', { hand: 0 })
+    else if (packet.animation === 3) ctx.send('arm_animation', { hand: 1 })
+  })
+
+  client.on('vehicle_move', (packet) => {
+    const boat = state.boat
+    if (!boat) return
+    boat.pos = { x: packet.x, y: packet.y, z: packet.z }
+    boat.yRot = f32(packet.yaw)
+    boat.xRot = f32(packet.pitch)
+    ctx.sendVehicleMove()
+  })
+
+  // mineflayer treats a full chunk without sections as an unload before 1.17; the game client keeps it loaded
+  const Chunk = require('prismarine-chunk')(registry)
+  client.on('map_chunk', (packet) => {
+    const empty = packet.bitMap === 0 ||
+      (Array.isArray(packet.bitMap) && packet.bitMap.every(n => !n || (Array.isArray(n) && n.every(m => !m))))
+    if (!empty || !packet.groundUp || bot.world.getColumn(packet.x, packet.z)) return
+    const column = new Chunk({ minY: bot.game.minY, worldHeight: bot.game.height })
+    try {
+      if (packet.biomes !== undefined) column.loadBiomes(packet.biomes)
+    } catch (e) {}
+    bot.world.setColumn(packet.x, packet.z, column)
+  })
+
+  // mineflayer listens for 'entityGone' on the client instead of the bot, so a removed vehicle is never left
+  client.on('entity_destroy', (packet) => {
+    const vehicle = bot.vehicle
+    if (!vehicle || !packet.entityIds.includes(vehicle.id)) return
+    bot.vehicle = null
+    if (bot.entity) bot.entity.vehicle = null
+    state.boat = null
+    bot.emit('dismount', vehicle)
+  })
+}
+
+module.exports = { installServerHandlers }

package/lib/client/teleport.js

@@ -0,0 +1,108 @@
+'use strict'
+// ClientboundPlayerPositionPacket handling and the answer each client version sends back.
+
+const conv = require('mineflayer/lib/conversions')
+const { f32, clamp } = require('../engine/mth')
+
+function relativeFlags (flags) {
+  if (flags && typeof flags === 'object') {
+    return {
+      x: !!flags.x, y: !!flags.y, z: !!flags.z, yaw: !!flags.yaw, pitch: !!flags.pitch,
+      dx: !!flags.dx, dy: !!flags.dy, dz: !!flags.dz, rotateDelta: !!flags.yawDelta
+    }
+  }
+  const n = flags | 0
+  return { x: !!(n & 1), y: !!(n & 2), z: !!(n & 4), yaw: !!(n & 8), pitch: !!(n & 16) }
+}
+
+// 1.16 - 1.21.1: relative axes keep their velocity, absolute ones reset it
+function legacyTarget (player, packet, r) {
+  const v = { ...player.vel }
+  const pos = {
+    x: r.x ? player.pos.x + packet.x : packet.x,
+    y: r.y ? player.pos.y + packet.y : packet.y,
+    z: r.z ? player.pos.z + packet.z : packet.z
+  }
+  if (!r.x) v.x = 0
+  if (!r.y) v.y = 0
+  if (!r.z) v.z = 0
+  let yaw = f32(packet.yaw)
+  let pitch = f32(packet.pitch)
+  if (r.pitch) pitch = f32(pitch + player.xRot)
+  if (r.yaw) yaw = f32(yaw + player.yRot)
+  return { pos, vel: v, yaw: f32(yaw % 360), pitch: f32(clamp(pitch, -90, 90) % 360) }
+}
+
+// 1.21.2+: PositionMoveRotation#calculateAbsolute
+function modernTarget (player, packet, r) {
+  const pos = {
+    x: (r.x ? player.pos.x : 0) + packet.x,
+    y: (r.y ? player.pos.y : 0) + packet.y,
+    z: (r.z ? player.pos.z : 0) + packet.z
+  }
+  const yaw = f32((r.yaw ? player.yRot : 0) + packet.yaw)
+  const pitch = f32(clamp(f32((r.pitch ? player.xRot : 0) + packet.pitch), -90, 90))
+  let v = { ...player.vel }
+  if (r.rotateDelta) {
+    const ax = (player.xRot - pitch) * Math.PI / 180
+    const ay = (player.yRot - yaw) * Math.PI / 180
+    const y1 = v.y * Math.cos(ax) + v.z * Math.sin(ax)
+    const z1 = v.z * Math.cos(ax) - v.y * Math.sin(ax)
+    v = { x: v.x * Math.cos(ay) + z1 * Math.sin(ay), y: y1, z: z1 * Math.cos(ay) - v.x * Math.sin(ay) }
+  }
+  const delta = (current, change, relative) => relative ? current + (change ?? 0) : (change ?? 0)
+  return {
+    pos,
+    vel: { x: delta(v.x, packet.dx, r.dx), y: delta(v.y, packet.dy, r.dy), z: delta(v.z, packet.dz, r.dz) },
+    yaw,
+    pitch
+  }
+}
+
+function installTeleport (ctx) {
+  const { bot, client, V, player, state } = ctx
+
+  const answerPosition = () => ctx.send('position_look', {
+    x: player.pos.x,
+    y: player.pos.y,
+    z: player.pos.z,
+    yaw: player.yRot,
+    pitch: player.xRot,
+    onGround: false,
+    flags: { onGround: false, hasHorizontalCollision: false }
+  })
+
+  client.on('position', (packet) => {
+    const r = relativeFlags(packet.flags)
+    const target = V.relativeTeleportVelocity ? modernTarget(player, packet, r) : legacyTarget(player, packet, r)
+    if (!bot.vehicle) {
+      player.pos = target.pos
+      player.vel = target.vel
+      player.onGround = false
+    }
+    player.yRot = target.yaw
+    player.xRot = target.pitch
+    bot.entity.yaw = conv.fromNotchianYaw(target.yaw)
+    bot.entity.pitch = conv.fromNotchianPitch(target.pitch)
+    ctx.syncEntity()
+
+    if (V.posRotBeforeConfirm) {
+      answerPosition()
+      ctx.send('teleport_confirm', { teleportId: packet.teleportId })
+    } else {
+      if (bot.supportFeature('teleportUsesOwnPacket')) ctx.send('teleport_confirm', { teleportId: packet.teleportId })
+      answerPosition()
+    }
+    state.positionReceived = true
+    bot.emit('forcedMove')
+  })
+
+  client.on('player_rotation', (packet) => {
+    player.yRot = f32(packet.yaw)
+    player.xRot = f32(clamp(packet.pitch, -90, 90))
+    bot.entity.yaw = conv.fromNotchianYaw(player.yRot)
+    bot.entity.pitch = conv.fromNotchianPitch(player.xRot)
+  })
+}
+
+module.exports = { installTeleport }

package/lib/client/ticker.js

@@ -0,0 +1,144 @@
+'use strict'
+// Minecraft#tick for the local player plus the timer that drives it.
+
+const { performance } = require('perf_hooks')
+
+const TICK_MS = 50
+const MAX_CATCH_UP = 10
+const LOAD_TIMEOUT_TICKS = 60
+const MAX_TURN_DELAY = 40
+
+const released = () => ({ forward: false, backward: false, left: false, right: false, jump: false, shift: false, sprint: false })
+
+function installTicker (ctx) {
+  const { bot, client, V, player, state, world } = ctx
+
+  ctx.syncEntity = () => {
+    const e = bot.entity
+    if (!e) return
+    e.position.set(player.pos.x, player.pos.y, player.pos.z)
+    e.velocity.set(player.vel.x, player.vel.y, player.vel.z)
+    e.onGround = player.onGround
+    e.isInWater = player.isInWater()
+    e.isInLava = player.isInLava()
+    e.height = player.height()
+    e.eyeHeight = player.eyeHeight()
+    e.isCollidedHorizontally = player.horizontalCollision
+    e.isCollidedVertically = player.verticalCollision
+  }
+
+  function resetPlayer () {
+    const abilities = player.abilities
+    player.reset()
+    player.abilities = abilities
+    Object.assign(state, {
+      positionReceived: false,
+      clientLoaded: false,
+      loadedReadyTicks: 0,
+      loadTimeout: LOAD_TIMEOUT_TICKS,
+      last: { x: 0, y: 0, z: 0, yRot: 0, xRot: 0, onGround: false, horizontalCollision: false },
+      positionReminder: 0,
+      creeping: false,
+      turnDelay: 0,
+      wasSprinting: false,
+      wasShift: false,
+      lastInput: released(),
+      boat: null
+    })
+  }
+
+  // 1.21.4+: the player only ticks once the level screen closes, which is when player_loaded is sent
+  function waitForLevel () {
+    const outside = player.pos.y < world.minY || player.pos.y >= world.maxY
+    state.loadedReadyTicks = (outside || world.hasChunk(player.pos.x, player.pos.z)) ? state.loadedReadyTicks + 1 : 0
+    if (state.loadedReadyTicks < 2 && --state.loadTimeout > 0) return false
+    state.clientLoaded = true
+    ctx.send('player_loaded', {})
+    bot.emit('clientLoaded')
+    return true
+  }
+
+  function playerTick () {
+    if (!state.positionReceived) return
+    if (!world.hasChunk(player.pos.x, player.pos.z)) return
+    if (V.clientLoaded && !state.clientLoaded) {
+      waitForLevel()
+      return
+    }
+    if (bot.isAlive === false) return
+    player.riding = false
+    // 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
+    }
+    if (bot.physicsEnabled) {
+      player.tick(ctx.keys())
+      if (player.events.abilitiesChanged) {
+        player.events.abilitiesChanged = false
+        ctx.send('abilities', { flags: player.abilities.flying ? 2 : 0 })
+      }
+    }
+    ctx.syncEntity()
+    if (V.playerInputPacket) {
+      ctx.sendShift()
+      ctx.sendInput()
+    }
+    ctx.sendPosition()
+  }
+
+  function clientTick () {
+    if (client.state !== 'play' || !state.inLevel || !bot.entity) return
+    if (state.selectedSlot !== state.carriedSlot) {
+      state.carriedSlot = state.selectedSlot
+      ctx.send('held_item_slot', { slotId: state.selectedSlot })
+    }
+    ctx.flushHeldBrand()
+    const vehicle = bot.vehicle
+    if (vehicle && vehicle !== bot.entity && state.positionReceived) {
+      ctx.ridingTick(vehicle)
+    } else {
+      state.boat = null
+      playerTick()
+    }
+    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)
+  }
+
+  client.on('login', () => {
+    state.inLevel = true
+    state.playSettingsSent = false
+    state.selectedSlot = 0
+    state.carriedSlot = 0
+    resetPlayer()
+    start()
+  })
+  client.on('respawn', resetPlayer)
+  client.on('start_configuration', () => { state.inLevel = false })
+  bot.on('end', () => {
+    clearTimeout(timer)
+    timer = null
+  })
+
+  resetPlayer()
+}
+
+module.exports = { installTicker }

package/lib/engine/player/blocks.js

@@ -0,0 +1,134 @@
+'use strict'
+
+const AABB = require('../aabb')
+const { f32 } = require('../mth')
+
+const ON_POS = f32(0.2)
+const BELOW_MODERN = f32(0.500001)
+const BELOW_LEGACY = 0.5000001
+
+// Entity#getOnPos(yOffset)
+function onPos (player, yOffset = ON_POS) {
+  const { pos, world } = player
+  const support = player.supportingBlock
+  if (player.V.supportingBlock && support) {
+    if (!(yOffset > 1.0e-5)) return support
+    const block = world.blockAt(support.x, support.y, support.z)
+    if (!(yOffset <= 0.5) || !block.isFenceLike) return { x: support.x, y: Math.floor(pos.y - yOffset), z: support.z }
+    return support
+  }
+  const p = { x: Math.floor(pos.x), y: Math.floor(pos.y - yOffset), z: Math.floor(pos.z) }
+  if (!player.V.supportingBlock && yOffset === ON_POS && world.blockAt(p.x, p.y, p.z).isAir) {
+    if (world.blockAt(p.x, p.y - 1, p.z).isFenceLike) return { x: p.x, y: p.y - 1, z: p.z }
+  }
+  return p
+}
+
+function belowPos (player) {
+  if (player.V.supportingBlock) return onPos(player, BELOW_MODERN)
+  return { x: Math.floor(player.pos.x), y: Math.floor(player.pos.y - BELOW_LEGACY), z: Math.floor(player.pos.z) }
+}
+
+function feetBlock (player) {
+  return player.world.blockAt(Math.floor(player.pos.x), Math.floor(player.pos.y), Math.floor(player.pos.z))
+}
+
+function friction (player) {
+  const p = belowPos(player)
+  return player.world.blockAt(p.x, p.y, p.z).friction
+}
+
+function soulSpeed (player, block) {
+  return block.name === 'soul_sand' && player.V.soulSpeedBoots && player.env.bootsEnchant('soul_speed') > 0
+}
+
+function blockSpeed (player, block) {
+  return soulSpeed(player, block) ? 1 : block.speedFactor
+}
+
+// Entity#getBlockSpeedFactor
+function speedFactor (player) {
+  if (player.abilities.flying) return 1
+  const inside = feetBlock(player)
+  let factor = blockSpeed(player, inside)
+  const keepsOwn = inside.name === 'water' || inside.name === 'bubble_column' ||
+    (!player.V.supportingBlock && inside.name === 'soul_sand')
+  if (factor === 1 && !keepsOwn) {
+    const p = belowPos(player)
+    factor = blockSpeed(player, player.world.blockAt(p.x, p.y, p.z))
+  }
+  if (player.V.efficiencyAttributes) {
+    const efficiency = f32(player.env.attribute('movement_efficiency', 0))
+    factor = f32(factor + efficiency * (1 - factor))
+  }
+  return factor
+}
+
+function jumpFactor (player) {
+  const inside = feetBlock(player).jumpFactor
+  if (inside !== 1) return inside
+  const p = belowPos(player)
+  return player.world.blockAt(p.x, p.y, p.z).jumpFactor
+}
+
+function onClimbable (player) {
+  const { world } = player
+  const bx = Math.floor(player.pos.x)
+  const by = Math.floor(player.pos.y)
+  const bz = Math.floor(player.pos.z)
+  const block = world.blockAt(bx, by, bz)
+  if (block.climbable) return true
+  if (block.isTrapdoor && (block.props.open === true || block.props.open === 'true')) {
+    const below = world.blockAt(bx, by - 1, bz)
+    return below.isLadder && below.props.facing === block.props.facing
+  }
+  return false
+}
+
+function onPowderSnowWithBoots (player) {
+  return player.V.powderSnow && feetBlock(player).isPowderSnow && player.env.bootsItem() === 'leather_boots'
+}
+
+function findSupport (player, box) {
+  let best = null
+  let bestDistance = Infinity
+  const x0 = Math.floor(box.minX) - 1; const x1 = Math.floor(box.maxX) + 1
+  const y0 = Math.floor(box.minY) - 1; const y1 = Math.floor(box.maxY) + 1
+  const z0 = Math.floor(box.minZ) - 1; const z1 = Math.floor(box.maxZ) + 1
+  for (let x = x0; x <= x1; x++) {
+    for (let y = y0; y <= y1; y++) {
+      for (let z = z0; z <= z1; z++) {
+        const shapes = player.world.blockAt(x, y, z).shapes
+        if (!shapes.some(s => box.intersectsBox([s[0] + x, s[1] + y, s[2] + z, s[3] + x, s[4] + y, s[5] + z]))) continue
+        const cx = x + 0.5 - player.pos.x
+        const cy = y + 0.5 - player.pos.y
+        const cz = z + 0.5 - player.pos.z
+        const distance = cx * cx + cy * cy + cz * cz
+        const greater = best && (y !== best.y ? y > best.y : (z !== best.z ? z > best.z : x > best.x))
+        if (distance < bestDistance || (distance === bestDistance && (!best || greater))) {
+          bestDistance = distance
+          best = { x, y, z }
+        }
+      }
+    }
+  }
+  return best
+}
+
+// Entity#checkSupportingBlock, 1.20+
+function updateSupportingBlock (player, onGround, mx, mz) {
+  if (!player.V.supportingBlock) return
+  if (!onGround) {
+    player.supportingBlock = null
+    player.onGroundNoBlocks = false
+    return
+  }
+  const bb = player.bb()
+  const feet = new AABB(bb.minX, bb.minY - 1.0e-6, bb.minZ, bb.maxX, bb.minY, bb.maxZ)
+  let found = findSupport(player, feet)
+  if (!found && !player.onGroundNoBlocks) found = findSupport(player, feet.move(-mx, 0, -mz))
+  player.supportingBlock = found
+  player.onGroundNoBlocks = !found
+}
+
+module.exports = { onPos, belowPos, feetBlock, friction, speedFactor, jumpFactor, onClimbable, onPowderSnowWithBoots, updateSupportingBlock }

package/lib/engine/player/effects.js

@@ -0,0 +1,152 @@
+'use strict'
+
+const AABB = require('../aabb')
+const { f32 } = require('../mth')
+
+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 = {
+  cobweb: { x: 0.25, y: F_005, z: 0.25 },
+  cobwebWeaving: { x: 0.5, y: 0.25, z: 0.5 },
+  berryBush: { x: F_08, y: 0.75, z: F_08 },
+  powderSnow: { x: F_09, y: 1.5, z: F_09 }
+}
+
+function makeStuck (player, multiplier) {
+  player.fallDistance = 0
+  player.stuck = multiplier
+}
+
+// 1.21.2 moved block effects after gravity and drag; honey keeps its old numbers by converting back and forth
+const oldDeltaY = (player, vy) => player.V.blockEffectsAfterTravel ? vy / F_098 + 0.08 : vy
+const newDeltaY = (player, vy) => player.V.blockEffectsAfterTravel ? (vy - 0.08) * F_098 : vy
+
+function honeySlide (player, bx, by, bz) {
+  if (player.onGround) return
+  if (player.pos.y > by + 0.9375 - 1.0e-7) return
+  const vy = oldDeltaY(player, player.vel.y)
+  if (vy >= -0.08) return
+  const dx = Math.abs(bx + 0.5 - player.pos.x)
+  const dz = Math.abs(bz + 0.5 - player.pos.z)
+  const edge = 0.4375 + HALF_WIDTH
+  if (!(dx + 1.0e-7 > edge || dz + 1.0e-7 > edge)) return
+  if (vy < -0.13) {
+    const k = -0.05 / vy
+    player.vel.x *= k
+    player.vel.z *= k
+  }
+  player.vel.y = newDeltaY(player, -0.05)
+  player.fallDistance = 0
+}
+
+function bubbleColumn (player, block, bx, by, bz) {
+  const surface = player.world.blockAt(bx, by + 1, bz).isAir
+  const vy = player.vel.y
+  if (block.bubbleDrag) player.vel.y = surface ? Math.max(-0.9, vy - 0.03) : Math.max(-0.3, vy - 0.03)
+  else player.vel.y = surface ? Math.min(1.8, vy + 0.1) : Math.min(0.7, vy + 0.06)
+  player.fallDistance = 0
+}
+
+function onInsideBlock (player, block, bx, by, bz, withVelocityEffects) {
+  if (block.isCobweb) {
+    makeStuck(player, player.env.effect('weaving') != null ? STUCK.cobwebWeaving : STUCK.cobweb)
+  } else if (block.isBerryBush) {
+    makeStuck(player, STUCK.berryBush)
+  } else if (block.isPowderSnow) {
+    if (bx === Math.floor(player.pos.x) && by === Math.floor(player.pos.y) && bz === Math.floor(player.pos.z)) {
+      makeStuck(player, STUCK.powderSnow)
+    }
+  } else if (block.isBubbleColumn) {
+    if (withVelocityEffects) bubbleColumn(player, block, bx, by, bz)
+  } else if (block.isHoney) {
+    honeySlide(player, bx, by, bz)
+  }
+}
+
+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)
+  const z0 = Math.floor(box.minZ); const z1 = Math.floor(box.maxZ)
+  for (let x = x0; x <= x1; x++) {
+    for (let y = y0; y <= y1; y++) {
+      for (let z = z0; z <= z1; z++) visit(x, y, z)
+    }
+  }
+}
+
+function settleStuck (player) {
+  if (player.abilities.flying) player.stuck = null
+}
+
+// Entity#checkInsideBlocks, before 1.21.2: runs inside Entity#move against the new box
+function checkInsideBlocksLegacy (player) {
+  const box = player.bb().deflate(player.V.insideBlockDeflate)
+  forEachBlockIn(box, (x, y, z) => {
+    const block = player.world.blockAt(x, y, z)
+    if (!block.isAir) onInsideBlock(player, block, x, y, z, true)
+  })
+  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 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)
+    }
+  }
+  player.movesThisTick.length = 0
+  settleStuck(player)
+}
+
+module.exports = { checkInsideBlocksLegacy, applyEffectsAfterTravel }