spectra-physics 1.0.0 → 1.1.0

package/lib/engine/player/fluids.js

@@ -0,0 +1,141 @@
+'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)
+  player.eyeInWater = !!(fluid && fluid.type === 'water' && by + player.world.fluidHeight(bx, by, bz, fluid) > eyeY)
+}
+
+// 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) {
+  player.fluidHeight.water = 0
+  player.fluidHeight.lava = 0
+  updateWater(player)
+  touchFluid(player, 'lava', player.env.ultraWarm() ? 0.007 : 0.0023333333333333335)
+  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, fluidFallingAdjusted }

package/lib/engine/player/index.js

@@ -0,0 +1,202 @@
+'use strict'
+// One client tick of the local player: LocalPlayer#aiStep -> Player#aiStep -> LivingEntity#aiStep -> travel.
+
+const { f32 } = require('../mth')
+const pose = require('./pose')
+const { readKeys } = require('./input')
+const { updateFluids } = require('./fluids')
+const { travel, handleJump } = require('./travel')
+const { applyEffectsAfterTravel } = require('./effects')
+const { pushByEntities } = require('./push')
+
+const F_002 = f32(0.02)
+const F_004 = f32(0.04)
+const F_1EM5 = f32(1.0e-5)
+const LEGACY_AIR_SPRINT = f32(F_002 + 0.005999999865889549)
+const AIR_SPRINT = f32(F_002 + f32(0.006))
+const STEP = f32(0.6)
+
+const DEFAULT_ENV = {
+  attribute: (name, fallback) => fallback,
+  movementSpeed: (sprinting) => sprinting ? 0.13 : 0.1,
+  effect: () => null,
+  bootsEnchant: () => 0,
+  bootsItem: () => null,
+  food: () => 20,
+  usingItem: () => false,
+  gameMode: () => 'survival',
+  ultraWarm: () => false,
+  nearbyEntities: () => []
+}
+
+class PlayerPhysics {
+  constructor (world, V, env = {}) {
+    this.world = world
+    this.V = V
+    this.env = { ...DEFAULT_ENV, ...env }
+    this.reset()
+  }
+
+  reset () {
+    this.pos = { x: 0, y: 0, z: 0 }
+    this.vel = { x: 0, y: 0, z: 0 }
+    this.yRot = 0
+    this.xRot = 0
+    this.pose = 'standing'
+    this.onGround = false
+    this.horizontalCollision = false
+    this.minorHorizontalCollision = false
+    this.verticalCollision = false
+    this.fallDistance = 0
+    this.sprinting = false
+    this.swimming = false
+    this.riding = false
+    this.noJumpDelay = 0
+    this.jumpTriggerTime = 0
+    this.sprintTriggerTime = 0
+    this.legacyFlyingSpeed = F_002
+    this.stuck = null
+    this.wasTouchingWater = false
+    this.fluidHeight = { water: 0, lava: 0 }
+    this.eyeInWater = false
+    this.wasEyeInWater = false
+    this.firstTick = true
+    this.supportingBlock = null
+    this.onGroundNoBlocks = false
+    this.movesThisTick = []
+    this.tickStart = { x: 0, y: 0, z: 0 }
+    this.abilities = { invulnerable: false, flying: false, mayfly: false, instabuild: false, flyingSpeed: f32(0.05), walkingSpeed: f32(0.1) }
+    this.input = { left: 0, forward: 0, forwardKey: 0, jumping: false, shift: false, keys: {} }
+    this.xxa = 0
+    this.zza = 0
+    this.events = { abilitiesChanged: false }
+  }
+
+  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) }
+  bb () { return this.bbAt(this.pos.x, this.pos.y, this.pos.z) }
+
+  maxUpStep () {
+    return this.V.attributes2005 ? f32(this.env.attribute('step_height', 0.6)) : STEP
+  }
+
+  // the server applies the sprint modifier as soon as it sees START_SPRINTING, so the speed follows it in the same tick
+  movementSpeed () { return f32(this.env.movementSpeed(this.sprinting)) }
+
+  isInWater () { return this.wasTouchingWater }
+  isInLava () { return !this.firstTick && this.fluidHeight.lava > 0 }
+  isUnderWater () { return this.wasEyeInWater && this.isInWater() }
+
+  hasEnoughImpulseToStartSprint () {
+    if (this.isUnderWater()) return this.input.forward > F_1EM5
+    return this.input.forwardKey > 0 && (this.V.inputModel === 'modern' || this.input.forward >= 0.8)
+  }
+
+  tick (keys) {
+    this.tickStart = { ...this.pos }
+    this.movesThisTick.length = 0
+    this.baseTick()
+
+    const previousJump = this.input.jumping
+    const previousShift = this.input.shift
+    const previousImpulse = this.hasEnoughImpulseToStartSprint()
+    const slow = pose.isMovingSlowly(this, previousShift)
+    readKeys(this, keys, slow)
+    pose.pushOutOfBlocks(this)
+    this.updateSprinting(keys, previousShift, previousImpulse, slow)
+    this.updateFlightToggle(previousJump)
+    if (this.isInWater() && this.input.shift && !this.abilities.flying) this.vel.y -= F_004
+    if (this.abilities.flying) {
+      const direction = (this.input.jumping ? 1 : 0) - (this.input.shift ? 1 : 0)
+      if (direction !== 0) this.vel.y += f32(f32(direction * this.abilities.flyingSpeed) * 3)
+    }
+    if (this.jumpTriggerTime > 0) this.jumpTriggerTime--
+
+    this.livingAiStep()
+
+    this.legacyFlyingSpeed = this.sprinting ? (this.V.airSprintFloatSum ? AIR_SPRINT : LEGACY_AIR_SPRINT) : F_002
+    if (this.onGround && this.abilities.flying && this.env.gameMode() !== 'spectator') {
+      this.abilities.flying = false
+      this.events.abilitiesChanged = true
+    }
+    pose.updatePose(this)
+  }
+
+  // Entity#baseTick
+  baseTick () {
+    updateFluids(this)
+    if (this.isInLava()) this.fallDistance = this.V.fallDistanceDouble ? this.fallDistance * 0.5 : f32(this.fallDistance * 0.5)
+    this.firstTick = false
+  }
+
+  livingAiStep () {
+    if (this.noJumpDelay > 0) this.noJumpDelay--
+    this.cutTinyVelocity()
+    this.xxa = this.input.left
+    this.zza = this.input.forward
+    handleJump(this)
+    if (this.env.gameMode() === 'spectator') {
+      this.pos.x += this.vel.x; this.pos.y += this.vel.y; this.pos.z += this.vel.z
+      return
+    }
+    travel(this)
+    applyEffectsAfterTravel(this)
+    pushByEntities(this)
+  }
+
+  cutTinyVelocity () {
+    const v = this.vel
+    if (this.V.horizontalThreshold && !this.riding) {
+      if (v.x * v.x + v.z * v.z < 9.0e-6) { v.x = 0; v.z = 0 }
+    } else {
+      if (Math.abs(v.x) < 0.003) v.x = 0
+      if (Math.abs(v.z) < 0.003) v.z = 0
+    }
+    if (Math.abs(v.y) < 0.003) v.y = 0
+  }
+
+  // sprint rules of LocalPlayer#aiStep
+  updateSprinting (keys, previousShift, previousImpulse, slow) {
+    const V = this.V
+    const food = this.env.food() > 6 || this.abilities.mayfly
+    const blocked = this.env.usingItem() || this.env.effect('blindness') != null ||
+      (V.playerInputPacket && slow && !this.isUnderWater())
+    if (previousShift) this.sprintTriggerTime = 0
+    if (this.sprintTriggerTime > 0) this.sprintTriggerTime--
+
+    const impulse = this.hasEnoughImpulseToStartSprint()
+    if (!this.sprinting && (this.onGround || this.isUnderWater()) && !previousShift && !previousImpulse && impulse && food && !blocked) {
+      if (this.sprintTriggerTime <= 0 && !keys.sprint) this.sprintTriggerTime = 7
+      else this.sprinting = true
+    }
+    if (!this.sprinting && (!this.isInWater() || this.isUnderWater()) && impulse && food && !blocked && keys.sprint) {
+      this.sprinting = true
+    }
+    if (!this.sprinting) return
+
+    const noForward = !(this.input.forward > F_1EM5) || !food
+    if (this.swimming) {
+      if ((!this.onGround && !this.input.shift && noForward) || !this.isInWater()) this.sprinting = false
+      return
+    }
+    const wall = V.minorCollision ? this.horizontalCollision && !this.minorHorizontalCollision : this.horizontalCollision
+    const sneaking = V.playerInputPacket && slow && !this.isUnderWater()
+    if (noForward || wall || (this.isInWater() && !this.isUnderWater()) || sneaking) this.sprinting = false
+  }
+
+  // double tap jump toggles creative flight
+  updateFlightToggle (previousJump) {
+    if (!this.abilities.mayfly || this.env.gameMode() === 'spectator') return
+    if (previousJump || !this.input.jumping) return
+    if (this.jumpTriggerTime === 0) {
+      this.jumpTriggerTime = 7
+      return
+    }
+    this.abilities.flying = !this.abilities.flying
+    this.events.abilitiesChanged = true
+    this.jumpTriggerTime = 0
+  }
+}
+
+module.exports = { PlayerPhysics }

package/lib/engine/player/input.js

@@ -0,0 +1,86 @@
+'use strict'
+
+const { f32, sin, cos, degToRadF } = require('../mth')
+
+const F_098 = f32(0.98)
+const F_02 = f32(0.2)
+const F_03 = f32(0.3)
+const F_MIN_LENGTH = f32(1.0e-4)
+
+const impulse = (positive, negative) => positive === negative ? 0 : (positive ? 1 : -1)
+
+function sneakMultiplier (player) {
+  return player.V.efficiencyAttributes ? f32(player.env.attribute('sneaking_speed', 0.3)) : F_03
+}
+
+// KeyboardInput + LivingEntity#aiStep scaling, 1.16 - 1.21.4
+function legacyInput (player, left, forward, slow) {
+  let x = left
+  let z = forward
+  if (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) }
+  return [f32(x * F_098), f32(z * F_098)]
+}
+
+// LocalPlayer#modifyInput, 1.21.5+
+function modernInput (player, left, forward, slow) {
+  const length = f32(Math.sqrt(f32(left * left + forward * forward)))
+  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 (slow) {
+    const k = sneakMultiplier(player)
+    x = f32(x * k); z = f32(z * k)
+  }
+  const scaled = f32(Math.sqrt(f32(x * x + z * z)))
+  if (scaled <= 0) return [x, z]
+  const nx = f32(x / scaled)
+  const nz = f32(z / scaled)
+  const ax = Math.abs(nx)
+  const az = Math.abs(nz)
+  const ratio = az > ax ? f32(ax / az) : f32(az / ax)
+  const toSquare = f32(Math.sqrt(f32(1 + f32(ratio * ratio))))
+  const k = Math.min(f32(scaled * toSquare), 1)
+  return [f32(nx * k), f32(nz * k)]
+}
+
+function readKeys (player, keys, slow) {
+  const forward = impulse(keys.forward, keys.back)
+  const left = impulse(keys.left, keys.right)
+  const [xxa, zza] = player.V.inputModel === 'modern'
+    ? modernInput(player, left, forward, slow)
+    : legacyInput(player, left, forward, slow)
+  player.input = {
+    left: xxa,
+    forward: zza,
+    forwardKey: forward,
+    jumping: !!keys.jump,
+    shift: !!keys.sneak,
+    keys: { ...keys }
+  }
+}
+
+// Entity#moveRelative
+function moveRelative (player, speed, ix, iy, iz) {
+  const lengthSq = ix * ix + iy * iy + iz * iz
+  if (lengthSq < 1.0e-7) return
+  let x = ix; let y = iy; let z = iz
+  if (lengthSq > 1) {
+    const length = player.V.floatSqrt ? f32(Math.sqrt(lengthSq)) : Math.sqrt(lengthSq)
+    if (length < player.V.normalizeEpsilon) return
+    x /= length; y /= length; z /= length
+  }
+  x *= speed; y *= speed; z *= speed
+  const r = degToRadF(player.yRot)
+  const s = sin(r)
+  const c = cos(r)
+  player.vel.x += x * c - z * s
+  player.vel.y += y
+  player.vel.z += z * c + x * s
+}
+
+module.exports = { readKeys, moveRelative }

package/lib/engine/player/move.js

@@ -0,0 +1,135 @@
+'use strict'
+
+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 F_066 = f32(0.66)
+const F_1EM5 = f32(1.0e-5)
+const MINOR_ANGLE = f32(0.13962634)
+
+// Entity#maybeBackOffFromEdge (1.11+ form, which is also what server-side prediction uses)
+function backOffFromEdge (player, vx, vy, vz) {
+  if (player.abilities.flying || !player.input.shift || vy > 0) return [vx, vz]
+  const step = player.maxUpStep()
+  const bb = player.bb()
+  const aboveGround = player.onGround ||
+    (player.fallDistance < step && !player.world.noCollision(bb.move(0, player.fallDistance - step, 0)))
+  if (!aboveGround) return [vx, vz]
+  const free = (x, z) => player.world.noCollision(bb.move(x, -step, z))
+  const shrink = (d) => (d < 0.05 && d >= -0.05) ? 0 : (d > 0 ? d - 0.05 : d + 0.05)
+  let x = vx
+  let z = vz
+  while (x !== 0 && free(x, 0)) x = shrink(x)
+  while (z !== 0 && free(0, z)) z = shrink(z)
+  while (x !== 0 && z !== 0 && free(x, z)) { x = shrink(x); z = shrink(z) }
+  return [x, z]
+}
+
+// LocalPlayer#isHorizontalCollisionMinor
+function isMinorCollision (player, mx, mz) {
+  const r = degToRadF(player.yRot)
+  const s = sin(r)
+  const c = cos(r)
+  const ix = player.xxa * c - player.zza * s
+  const iz = player.zza * c + player.xxa * s
+  const inputSq = ix * ix + iz * iz
+  const moveSq = mx * mx + mz * mz
+  if (inputSq < F_1EM5 || moveSq < F_1EM5) return false
+  return Math.acos((ix * mx + iz * mz) / Math.sqrt(inputSq * moveSq)) < MINOR_ANGLE
+}
+
+function landOn (player, block) {
+  const bounce = !player.input.shift && (block.isSlime ? 1 : (block.isBed ? F_066 : 0))
+  if (bounce && player.vel.y < 0) player.vel.y = -player.vel.y * bounce
+  else if (!bounce) player.vel.y = 0
+}
+
+function stepOn (player, block) {
+  if (!block.isSlime) return
+  const vy = Math.abs(player.vel.y)
+  if (vy < 0.1) {
+    const k = 0.4 + vy * 0.2
+    player.vel.x *= k
+    player.vel.z *= k
+  }
+}
+
+function applyPosition (player, bb, r) {
+  if (player.V.posFromBoundingBox) {
+    const moved = bb.move(r.x, r.y, r.z)
+    player.pos.x = (moved.minX + moved.maxX) / 2
+    player.pos.y = moved.minY
+    player.pos.z = (moved.minZ + moved.maxZ) / 2
+  } else {
+    player.pos.x += r.x
+    player.pos.y += r.y
+    player.pos.z += r.z
+  }
+}
+
+function zeroBlockedAxes (player, vx, vz, r) {
+  const V = player.V
+  if (V.epsilonCollisionFlags) {
+    if (!equal(vx, r.x)) player.vel.x = 0
+    if (!equal(vz, r.z)) player.vel.z = 0
+    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 }
+}
+
+// Entity#move(MoverType.SELF, movement)
+function move (player, mx, my, mz) {
+  const V = player.V
+  if (player.stuck) {
+    mx *= player.stuck.x; my *= player.stuck.y; mz *= player.stuck.z
+    player.stuck = null
+    player.vel = { x: 0, y: 0, z: 0 }
+  }
+  const [bx, bz] = backOffFromEdge(player, mx, my, mz)
+  mx = bx; mz = bz
+
+  const bb = player.bb()
+  const from = { ...player.pos }
+  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
+  const wantedSq = mx * mx + my * my + mz * mz
+  const applies = V.modernMoveThreshold ? (lengthSq > 1.0e-7 || wantedSq - lengthSq < 1.0e-7) : lengthSq > 1.0e-7
+  if (applies) applyPosition(player, bb, r)
+
+  const xBlocked = V.epsilonCollisionFlags ? !equal(mx, r.x) : mx !== r.x
+  const zBlocked = V.epsilonCollisionFlags ? !equal(mz, r.z) : mz !== r.z
+  player.horizontalCollision = xBlocked || zBlocked
+  player.minorHorizontalCollision = V.minorCollision && player.horizontalCollision && isMinorCollision(player, r.x, r.z)
+  player.verticalCollision = my !== r.y
+  player.onGround = player.verticalCollision && my < 0
+  updateSupportingBlock(player, player.onGround, r.x, r.z)
+
+  if (V.fluidRecheckInMove && !player.wasTouchingWater && !player.riding) updateWater(player)
+  if (player.onGround) {
+    player.fallDistance = 0
+  } else if (r.y < 0) {
+    player.fallDistance = V.fallDistanceDouble ? player.fallDistance - r.y : f32(player.fallDistance - r.y)
+  }
+
+  zeroBlockedAxes(player, mx, mz, r)
+  const standingOn = onPos(player)
+  const block = player.world.blockAt(standingOn.x, standingOn.y, standingOn.z)
+  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.blockEffectsAfterTravel) checkInsideBlocksLegacy(player)
+
+  const factor = speedFactor(player)
+  player.vel.x *= factor
+  player.vel.z *= factor
+}
+
+module.exports = { move }

package/lib/engine/player/pose.js

@@ -0,0 +1,95 @@
+'use strict'
+
+const AABB = require('../aabb')
+const { f32 } = require('../mth')
+
+const POSES = {
+  standing: { width: f32(0.6), height: f32(1.8), eye: f32(1.62) },
+  crouching: { width: f32(0.6), height: f32(1.5), eye: f32(1.27) },
+  swimming: { width: f32(0.6), height: f32(0.6), eye: f32(0.4) }
+}
+
+function boxFor (pose, x, y, z) {
+  const d = POSES[pose]
+  const r = f32(d.width / 2)
+  return new AABB(x - r, y, z - r, x + r, y + d.height, z + r)
+}
+
+function canEnterPose (player, pose, x = player.pos.x, y = player.pos.y, z = player.pos.z) {
+  return player.world.noCollision(boxFor(pose, x, y, z).deflate(1.0e-7))
+}
+
+// Player#updatePlayerPose, end of the tick
+function updatePose (player) {
+  if (!canEnterPose(player, 'swimming')) return
+  let pose = 'standing'
+  if (player.swimming) pose = 'swimming'
+  else if (player.input.shift && !player.abilities.flying) pose = 'crouching'
+  if (!canEnterPose(player, pose)) pose = canEnterPose(player, 'crouching') ? 'crouching' : 'swimming'
+  player.pose = pose
+}
+
+// LocalPlayer#isMovingSlowly, decided from the previous tick's keys and pose
+function isMovingSlowly (player, previousShift) {
+  const crouching = !player.abilities.flying && !player.swimming && canEnterPose(player, 'crouching') &&
+    (previousShift || !canEnterPose(player, 'standing'))
+  const crawling = player.pose === 'swimming' && !player.isInWater()
+  return crouching || crawling
+}
+
+function suffocatesAt (player, bx, bz) {
+  const bb = player.bb()
+  const box = new AABB(bx, bb.minY, bz, bx + 1, bb.maxY, bz + 1).deflate(1.0e-7)
+  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++) {
+        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
+        }
+      }
+    }
+  }
+  return false
+}
+
+const SIDES = [[-1, 0], [1, 0], [0, -1], [0, 1]] // west east north south
+
+function moveTowardsClosestSpace (player, x, z) {
+  const bx = Math.floor(x)
+  const bz = Math.floor(z)
+  if (!suffocatesAt(player, bx, bz)) return
+  const rx = x - bx
+  const rz = z - bz
+  let best = null
+  let bestDistance = Infinity
+  for (const [sx, sz] of SIDES) {
+    const along = sx !== 0 ? rx : rz
+    const distance = (sx > 0 || sz > 0) ? 1 - along : along
+    if (distance < bestDistance && !suffocatesAt(player, bx + sx, bz + sz)) {
+      bestDistance = distance
+      best = [sx, sz]
+    }
+  }
+  if (!best) return
+  if (best[0] !== 0) player.vel.x = 0.1 * best[0]
+  else player.vel.z = 0.1 * best[1]
+}
+
+// LocalPlayer pushes itself out of blocks it is stuck in, probing the four corners of its box
+function pushOutOfBlocks (player) {
+  const bb = player.bb()
+  const w = (bb.maxX - bb.minX) * 0.35
+  const d = (bb.maxZ - bb.minZ) * 0.35
+  const { x, z } = player.pos
+  moveTowardsClosestSpace(player, x - w, z + d)
+  moveTowardsClosestSpace(player, x - w, z - d)
+  moveTowardsClosestSpace(player, x + w, z - d)
+  moveTowardsClosestSpace(player, x + w, z + d)
+}
+
+module.exports = { POSES, boxFor, canEnterPose, updatePose, isMovingSlowly, pushOutOfBlocks }

package/lib/engine/player/push.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const AABB = require('../aabb')
+const { onClimbable } = require('./blocks')
+
+// Entity#push(Entity): overlapping pushable entities nudge the player away
+function pushByEntities (player) {
+  if (player.riding || player.env.gameMode() === 'spectator' || onClimbable(player)) return
+  const bb = player.bb()
+  for (const e of player.env.nearbyEntities()) {
+    const half = e.width / 2
+    const box = new AABB(e.x - half, e.y, e.z - half, e.x + half, e.y + e.height, e.z + half)
+    if (!(box.minX < bb.maxX && box.maxX > bb.minX && box.minY < bb.maxY && box.maxY > bb.minY && box.minZ < bb.maxZ && box.maxZ > bb.minZ)) continue
+    let dx = player.pos.x - e.x
+    let dz = player.pos.z - e.z
+    let distance = Math.max(Math.abs(dx), Math.abs(dz))
+    if (distance < 0.01) continue
+    distance = Math.sqrt(distance)
+    dx /= distance
+    dz /= distance
+    const falloff = Math.min(1, 1 / distance)
+    player.vel.x += dx * falloff * 0.05
+    player.vel.z += dz * falloff * 0.05
+  }
+}
+
+module.exports = { pushByEntities }