spectra-physics 1.0.0 → 1.2.0

package/lib/client/ticker.js

@@ -0,0 +1,129 @@
+'use strict'
+// Minecraft#tick for the local player plus the timer that drives it.
+
+const { startTicking, stopTicking } = require('./clock')
+
+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
+    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) {
+        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()
+    }
+    ctx.flushActions()
+    if (V.tickEnd) ctx.send('tick_end', {})
+    bot.emit('physicsTick')
+  }
+
+  const tick = () => {
+    try { clientTick() } catch (err) { bot.emit('error', err) }
+  }
+
+  client.on('login', () => {
+    state.inLevel = true
+    state.playSettingsSent = false
+    state.selectedSlot = 0
+    state.carriedSlot = 0
+    resetPlayer()
+    startTicking(tick)
+  })
+  client.on('respawn', resetPlayer)
+  client.on('start_configuration', () => { state.inLevel = false })
+  bot.on('end', () => stopTicking(tick))
+
+  resetPlayer()
+}
+
+module.exports = { installTicker }

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/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,115 @@
+'use strict'
+
+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 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)
+  }
+}
+
+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)
+  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)
+}
+
+// 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 = { 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, 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)
+}
+
+module.exports = { checkInsideBlocksLegacy, applyEffectsAfterTravel }

package/lib/engine/player/fluids.js

@@ -0,0 +1,150 @@
+'use strict'
+
+const WorldView = require('../world')
+const { f32 } = require('../mth')
+
+const EYE_OFFSET = f32(0.11111111)
+const WATER_PUSH = 0.014
+const MIN_PUSH = 0.0045000000000000005
+const SIDES = [[0, -1], [0, 1], [-1, 0], [1, 0]]
+
+// FlowingFluid#getFlow
+function flowAt (world, x, y, z, fluid) {
+  const own = WorldView.ownHeight(fluid)
+  let dx = 0
+  let dz = 0
+  for (const [sx, sz] of SIDES) {
+    const nx = x + sx
+    const nz = z + sz
+    const other = world.fluidAt(nx, y, nz)
+    if (other && other.type !== fluid.type) continue
+    let height = other ? WorldView.ownHeight(other) : 0
+    let diff = 0
+    if (height === 0) {
+      const block = world.blockAt(nx, y, nz)
+      if (block.shapes.length === 0 || block.fluid) {
+        const below = world.fluidAt(nx, y - 1, nz)
+        if (!below || below.type === fluid.type) {
+          height = below ? WorldView.ownHeight(below) : 0
+          if (height > 0) diff = f32(own - f32(height - f32(0.8888889)))
+        }
+      }
+    } else {
+      diff = f32(own - height)
+    }
+    dx += sx * diff
+    dz += sz * diff
+  }
+  let vx = dx; let vy = 0; let vz = dz
+  if (fluid.falling) {
+    for (const [sx, sz] of SIDES) {
+      const side = world.blockAt(x + sx, y, z + sz)
+      const sideAbove = world.blockAt(x + sx, y + 1, z + sz)
+      if ((side.fullCube && !side.fluid) || (sideAbove.fullCube && !sideAbove.fluid)) {
+        const l = Math.sqrt(vx * vx + vz * vz)
+        if (l < 1.0e-4) { vx = 0; vz = 0 } else { vx /= l; vz /= l }
+        vy = -6
+        break
+      }
+    }
+  }
+  const length = Math.sqrt(vx * vx + vy * vy + vz * vz)
+  return length < 1.0e-4 ? { x: 0, y: 0, z: 0 } : { x: vx / length, y: vy / length, z: vz / length }
+}
+
+// Entity#updateFluidHeightAndDoFluidPushing
+function touchFluid (player, type, scale) {
+  const bb = player.bb().deflate(0.001)
+  const x0 = Math.floor(bb.minX); const x1 = Math.ceil(bb.maxX)
+  const y0 = Math.floor(bb.minY); const y1 = Math.ceil(bb.maxY)
+  const z0 = Math.floor(bb.minZ); const z1 = Math.ceil(bb.maxZ)
+  const pushed = !player.abilities.flying
+  let height = 0
+  let touching = false
+  let px = 0; let py = 0; let pz = 0; let count = 0
+  for (let x = x0; x < x1; x++) {
+    for (let y = y0; y < y1; y++) {
+      for (let z = z0; z < z1; z++) {
+        const fluid = player.world.fluidAt(x, y, z)
+        if (!fluid || fluid.type !== type) continue
+        const top = y + player.world.fluidHeight(x, y, z, fluid)
+        if (top < bb.minY) continue
+        touching = true
+        height = Math.max(top - bb.minY, height)
+        if (!pushed) continue
+        const flow = flowAt(player.world, x, y, z, fluid)
+        const k = height < 0.4 ? height : 1
+        px += flow.x * k; py += flow.y * k; pz += flow.z * k
+        count++
+      }
+    }
+  }
+  if (px * px + py * py + pz * pz > 0) {
+    px /= count; py /= count; pz /= count
+    px *= scale; py *= scale; pz *= scale
+    const length = Math.sqrt(px * px + py * py + pz * pz)
+    if (Math.abs(player.vel.x) < 0.003 && Math.abs(player.vel.z) < 0.003 && length < MIN_PUSH) {
+      px = px / length * MIN_PUSH; py = py / length * MIN_PUSH; pz = pz / length * MIN_PUSH
+    }
+    player.vel.x += px; player.vel.y += py; player.vel.z += pz
+  }
+  player.fluidHeight[type] = height
+  return touching
+}
+
+// Entity#updateInWaterStateAndDoWaterCurrentPushing
+function updateWater (player) {
+  player.wasTouchingWater = touchFluid(player, 'water', WATER_PUSH)
+  if (player.wasTouchingWater) player.fallDistance = 0
+}
+
+function updateEyes (player) {
+  player.wasEyeInWater = player.eyeInWater
+  const eyeY = player.pos.y + player.eyeHeight() - EYE_OFFSET
+  const bx = Math.floor(player.pos.x)
+  const by = Math.floor(eyeY)
+  const bz = Math.floor(player.pos.z)
+  const fluid = player.world.fluidAt(bx, by, bz)
+  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
+function updateSwimming (player) {
+  if (player.abilities.flying || player.riding) {
+    player.swimming = false
+  } else if (player.swimming) {
+    player.swimming = player.sprinting && player.isInWater()
+  } else {
+    const fluid = player.world.fluidAt(Math.floor(player.pos.x), Math.floor(player.pos.y), Math.floor(player.pos.z))
+    const feet = !player.V.swimmingNeedsFeetInWater || (fluid && fluid.type === 'water')
+    player.swimming = player.sprinting && player.isUnderWater() && !!feet
+  }
+}
+
+function updateFluids (player) {
+  updateFluidInteraction(player)
+  updateEyes(player)
+  updateSwimming(player)
+}
+
+// LivingEntity#getFluidFallingAdjustedMovement
+function fluidFallingAdjusted (player, gravity, falling) {
+  if (player.sprinting) return
+  const vy = player.vel.y
+  if (falling && Math.abs(vy - 0.005) >= 0.003 && Math.abs(vy - gravity / 16) < 0.003) player.vel.y = -0.003
+  else player.vel.y = vy - gravity / 16
+}
+
+module.exports = { updateFluids, updateWater, updateFluidInteraction, fluidFallingAdjusted }