spectra-physics 1.0.0

package/README.md

@@ -0,0 +1,168 @@
+# SpectraPhysics
+
+[![npm](https://img.shields.io/npm/v/spectra-physics)](https://www.npmjs.com/package/spectra-physics)
+[![Tests](https://github.com/trqxyz/SpectraPhysics/actions/workflows/test.yml/badge.svg)](https://github.com/trqxyz/SpectraPhysics/actions/workflows/test.yml)
+
+Improved physics and movement engine for [mineflayer](https://github.com/PrismarineJS/mineflayer).
+
+SpectraPhysics replaces mineflayer's built-in `physics` plugin with a port of the vanilla client's movement code
+(`LocalPlayer#aiStep` → `LivingEntity#travel` → `Entity#move`) and of the way the client ticks and reports its
+position to the server. Movement is computed in the same order and with the same float rounding as the game client,
+so positions, velocities and packet timing match a vanilla player tick for tick.
+
+Supported versions: **1.16.5 – 26.1** (every version mineflayer supports in that range).
+
+## Why
+
+mineflayer's default physics (prismarine-physics) is a close approximation, but it differs from the client in
+several places that are visible to the server:
+
+| | mineflayer physics | SpectraPhysics |
+|---|---|---|
+| Collision | legacy 1.8 algorithm | `Shapes.collide` with VoxelShape epsilons, Y → larger horizontal axis order |
+| Step-up | single step | pre-1.21 heuristic and 1.21+ candidate step heights |
+| First tick after a teleport | moves immediately | no movement, gravity applied after `move`, like vanilla |
+| Position packets | time based, last-sent values reset on teleport | `sendPosition` rules: 2·10⁻⁴ threshold, 20-tick reminder, last-sent values kept across teleports |
+| Rotation | continuous interpolation | whole mouse steps of 0.15°, accumulated in float |
+| Sprint | applied the same tick | speed attribute updated at the end of the tick, as in `Player#aiStep` |
+| Tick loop | fixed interval | `Minecraft` timer: catches up at most 10 ticks |
+| 1.21.2+ | no `tick_end` | `tick_end` after every tick, `player_input` on key change |
+| 1.21.4+ | `player_loaded` on first health update | sent once the level around the player is loaded |
+| Teleport answer | one order for all versions | per version (1.21.2–1.21.3 send position before the confirmation) |
+| Vehicles | rotation packets only | boat simulation with paddle / input / vehicle move packets, minecart riding |
+| Brand, 1.20.2+ | sent in play state | sent in the configuration phase, once |
+
+It also fixes three mineflayer issues that leave a bot stuck:
+
+- an empty full chunk (no sections) sent to a 1.16 client is treated as an unload, so the player never ticks in it;
+- a removed vehicle is never dismounted (`entityGone` is listened for on the wrong emitter);
+- an out-of-range hotbar slot from the server throws inside the packet handler.
+
+## Installation
+
+```bash
+npm install spectra-physics mineflayer
+```
+
+Requires Node.js 22 or newer and mineflayer 4.30 or newer.
+
+## Usage
+
+```js
+const { createBot } = require('spectra-physics')
+
+const bot = createBot({
+  host: 'localhost',
+  port: 25565,
+  username: 'Steve',
+  version: '1.21.4',
+  spectra: { turnSpeed: 30 }
+})
+
+bot.once('spawn', async () => {
+  await bot.lookAt(bot.entity.position.offset(5, 1.6, 0))
+  bot.setControlState('forward', true)
+  bot.setControlState('sprint', true)
+  await bot.waitForTicks(40)
+  bot.clearControlStates()
+})
+```
+
+With an existing `mineflayer.createBot` call, install it under the `physics` key so it replaces the built-in plugin:
+
+```js
+const mineflayer = require('mineflayer')
+const spectraPhysics = require('spectra-physics')
+
+const bot = mineflayer.createBot({
+  host: 'localhost',
+  username: 'Steve',
+  plugins: { physics: spectraPhysics() }
+})
+```
+
+More in [`examples/`](examples).
+
+### Options
+
+| option | default | |
+|---|---|---|
+| `turnSpeed` | `35` | maximum rotation per tick in degrees |
+| `brand` | `'vanilla'` | client brand sent to the server |
+| `debug` | `false` | `true` logs every outgoing packet, or pass a function `(...args) => {}` |
+
+### Bot API
+
+The standard mineflayer movement API keeps working:
+`setControlState`, `getControlState`, `clearControlStates`, `controlState`, `look`, `lookAt`, `waitForTicks`,
+`physicsEnabled`, events `physicsTick`, `move`, `forcedMove`, `mount`, `dismount`.
+
+Added:
+
+- `bot.spectra.player` – the simulated player (`pos`, `vel`, `yRot`, `xRot`, `onGround`, `horizontalCollision`, `fallDistance`, `sprinting`, `abilities`, …)
+- `bot.spectra.flags` – version switches in effect for the connected protocol
+- `bot.spectra.world` – block and fluid lookups used by the engine
+- event `clientLoaded` – 1.21.4+, emitted when `player_loaded` is sent
+
+### Standalone engine
+
+The engine can run without a connection, for prediction or tests:
+
+```js
+const { PlayerPhysics, WorldView, versionFlags } = require('spectra-physics')
+
+// `source` needs { registry, world: { getColumn(chunkX, chunkZ) }, game: { minY, height } }
+const player = new PlayerPhysics(new WorldView(source), versionFlags(source.registry), {
+  attribute: (name, def) => def,
+  movementSpeed: (sprinting) => (sprinting ? 0.13 : 0.1),
+  effect: () => null,
+  food: () => 20,
+  usingItem: () => false,
+  gameMode: () => 'survival',
+  ultraWarm: () => false
+})
+
+player.pos = { x: 0.5, y: 80, z: 0.5 }
+player.tick({ forward: true, back: false, left: false, right: false, jump: false, sprint: false, sneak: false })
+```
+
+See [`test/helpers.js`](test/helpers.js) for a complete in-memory world.
+
+## What is simulated
+
+- gravity, air drag and ground friction (slipperiness per block, supporting block on 1.20+)
+- collisions against block shapes, step-up, sneaking edge back-off (both the old and the 1.21.2+ rules)
+- walking, sprinting (double-tap and key), sprint-jumping, crouch pose and its bounding box
+- water and lava with flow pushing, climbing (ladders, vines, scaffolding, trapdoors over ladders)
+- cobweb, sweet berry bush, powder snow, honey (sliding), soul sand, slime and bed bouncing
+- levitation, slow falling, jump boost, speed / slowness via attributes, dolphin's grace
+- creative flight, including toggling with a double jump and landing
+- knockback and explosion velocity, 1.21.2+ relative teleports with velocity
+- riding boats (client-controlled) and minecarts
+
+Not simulated yet: elytra flight, swimming pose, bubble columns, entity collisions, world border.
+
+## Tests
+
+```bash
+npm test
+```
+
+Offline tests for 1.16.5, 1.18.2, 1.20.4, 1.21.4 and 26.1 cover free fall, landing on full blocks and slabs,
+walking and sprinting speed, jump height, step-up, wall collision, sneaking at an edge, ice and cobwebs.
+
+## Releasing
+
+Releases are published to [npm](https://www.npmjs.com/package/spectra-physics) by GitHub Actions.
+
+1. Bump `version` in `package.json` and push to `main`.
+2. Create a GitHub release with the tag `v<version>` (for example `v1.0.1`).
+
+The *Publish to npm* workflow then runs the tests, checks that the tag matches `package.json`, and runs
+`npm publish --provenance --access public`. Publishing needs the repository secret `NPM_TOKEN`
+(an npm granular access token with read and write access to packages and two-factor bypass enabled;
+set it with `gh secret set NPM_TOKEN`). npm limits the lifetime of such tokens, so rotate it before it expires.
+
+## License
+
+[GPL-3.0](LICENSE)

package/index.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const spectraPhysics = require('./lib/plugin')
+const { PlayerPhysics } = require('./lib/engine/physics')
+const BoatPhysics = require('./lib/engine/boat')
+const WorldView = require('./lib/engine/world')
+const AABB = require('./lib/engine/aabb')
+const { versionFlags } = require('./lib/engine/version')
+
+// mineflayer.createBot with SpectraPhysics installed in place of the built-in physics plugin
+function createBot (options = {}) {
+  const mineflayer = require('mineflayer')
+  const { spectra, ...botOptions } = options
+  return mineflayer.createBot({
+    ...botOptions,
+    plugins: { ...(botOptions.plugins ?? {}), physics: spectraPhysics(spectra) }
+  })
+}
+
+module.exports = spectraPhysics
+module.exports.spectraPhysics = spectraPhysics
+module.exports.createBot = createBot
+module.exports.PlayerPhysics = PlayerPhysics
+module.exports.BoatPhysics = BoatPhysics
+module.exports.WorldView = WorldView
+module.exports.AABB = AABB
+module.exports.versionFlags = versionFlags

package/lib/engine/aabb.js

@@ -0,0 +1,46 @@
+'use strict'
+
+// Minimal immutable-style AABB matching net.minecraft.world.phys.AABB semantics.
+class AABB {
+  constructor (minX, minY, minZ, maxX, maxY, maxZ) {
+    this.minX = Math.min(minX, maxX)
+    this.minY = Math.min(minY, maxY)
+    this.minZ = Math.min(minZ, maxZ)
+    this.maxX = Math.max(minX, maxX)
+    this.maxY = Math.max(minY, maxY)
+    this.maxZ = Math.max(minZ, maxZ)
+  }
+
+  move (x, y, z) {
+    return new AABB(this.minX + x, this.minY + y, this.minZ + z, this.maxX + x, this.maxY + y, this.maxZ + z)
+  }
+
+  expandTowards (x, y, z) {
+    let minX = this.minX; let minY = this.minY; let minZ = this.minZ
+    let maxX = this.maxX; let maxY = this.maxY; let maxZ = this.maxZ
+    if (x < 0) minX += x; else if (x > 0) maxX += x
+    if (y < 0) minY += y; else if (y > 0) maxY += y
+    if (z < 0) minZ += z; else if (z > 0) maxZ += z
+    return new AABB(minX, minY, minZ, maxX, maxY, maxZ)
+  }
+
+  inflate (x, y = x, z = x) {
+    return new AABB(this.minX - x, this.minY - y, this.minZ - z, this.maxX + x, this.maxY + y, this.maxZ + z)
+  }
+
+  deflate (v) {
+    return this.inflate(-v)
+  }
+
+  // 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
+  }
+
+  min (axis) { return axis === 0 ? this.minX : (axis === 1 ? this.minY : this.minZ) }
+  max (axis) { return axis === 0 ? this.maxX : (axis === 1 ? this.maxY : this.maxZ) }
+}
+
+module.exports = AABB

package/lib/engine/boat.js

@@ -0,0 +1,137 @@
+'use strict'
+// Client-controlled boat (Boat#tick when isControlledByLocalInstance()).
+
+const AABB = require('./aabb')
+const { f32, sin, cos, degToRadF } = require('./mth')
+const { collideLegacy, collideModern } = require('./collision')
+
+const BOAT_W = f32(1.375)
+const BOAT_H = f32(0.5625)
+const G = f32(-0.04) // (double)-0.04F == -0.03999999910593033
+
+class BoatPhysics {
+  constructor (world, V, entity) {
+    this.world = world
+    this.V = V
+    this.pos = { x: entity.position.x, y: entity.position.y, z: entity.position.z }
+    this.vel = { x: 0, y: 0, z: 0 }
+    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.onGround = false
+    this.paddle = [false, false]
+  }
+
+  bb () {
+    const h = f32(BOAT_W / 2)
+    return new AABB(this.pos.x - h, this.pos.y, this.pos.z - h, this.pos.x + h, this.pos.y + BOAT_H, this.pos.z + h)
+  }
+
+  groundFriction () {
+    const bb = this.bb()
+    const probe = new AABB(bb.minX, bb.minY - 0.001, bb.minZ, bb.maxX, bb.minY, bb.maxZ)
+    const x0 = Math.floor(probe.minX) - 1; const x1 = Math.ceil(probe.maxX) + 1
+    const y0 = Math.floor(probe.minY) - 1; const y1 = Math.ceil(probe.maxY) + 1
+    const z0 = Math.floor(probe.minZ) - 1; const z1 = Math.ceil(probe.maxZ) + 1
+    let sum = 0; let n = 0
+    for (let x = x0; x < x1; x++) {
+      for (let z = z0; z < z1; z++) {
+        const edges = (x === x0 || x === x1 - 1 ? 1 : 0) + (z === z0 || z === z1 - 1 ? 1 : 0)
+        if (edges === 2) continue
+        for (let y = y0; y < y1; y++) {
+          if (edges > 0 && !(y !== y0 && y !== y1 - 1)) continue
+          const b = this.world.blockAt(x, y, z)
+          if (b.name.includes('lily_pad')) continue
+          let hit = false
+          for (const s of b.shapes) {
+            if (probe.intersectsBox([s[0] + x, s[1] + y, s[2] + z, s[3] + x, s[4] + y, s[5] + z])) { hit = true; break }
+          }
+          if (hit) { sum += b.friction; n++ }
+        }
+      }
+    }
+    return n > 0 ? f32(sum / n) : 0
+  }
+
+  inWater () {
+    const bb = this.bb()
+    const x0 = Math.floor(bb.minX); const x1 = Math.ceil(bb.maxX)
+    const y0 = Math.floor(bb.minY); const y1 = Math.ceil(bb.minY + 0.001)
+    const z0 = Math.floor(bb.minZ); const z1 = Math.ceil(bb.maxZ)
+    let found = false
+    this.waterLevel = -Infinity
+    for (let x = x0; x < x1; x++) {
+      for (let y = y0; y < y1; y++) {
+        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)
+            this.waterLevel = Math.max(top, this.waterLevel)
+            found = found || bb.minY < top
+          }
+        }
+      }
+    }
+    return found
+  }
+
+  getStatus () {
+    if (this.inWater()) return 'IN_WATER'
+    const f = this.groundFriction()
+    if (f > 0) { this.landFriction = f; return 'ON_LAND' }
+    return 'IN_AIR'
+  }
+
+  floatBoat () {
+    let d2 = 0
+    let inv = f32(0.05)
+    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.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)
+    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.z *= inv
+    this.deltaRotation = f32(this.deltaRotation * inv)
+    if (d2 > 0) this.vel.y = (this.vel.y + d2 * 0.06153846016296973) * 0.75
+  }
+
+  controlBoat (keys) {
+    let f = 0
+    if (keys.left) this.deltaRotation = f32(this.deltaRotation - 1)
+    if (keys.right) this.deltaRotation = f32(this.deltaRotation + 1)
+    if (keys.right !== keys.left && !keys.forward && !keys.back) f = f32(f + f32(0.005))
+    this.yRot = f32(this.yRot + this.deltaRotation)
+    if (keys.forward) f = f32(f + f32(0.04))
+    if (keys.back) f = f32(f - f32(0.005))
+    const r = degToRadF(this.yRot)
+    this.vel.x += sin(f32(-r)) * f
+    this.vel.z += cos(r) * f
+    this.paddle = [(keys.right && !keys.left) || keys.forward, (keys.left && !keys.right) || keys.forward]
+  }
+
+  tick (keys) {
+    this.oldStatus = this.status
+    this.status = this.getStatus()
+    this.floatBoat()
+    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)
+    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
+    if (this.vel.x !== r.x) this.vel.x = 0
+    if (this.vel.z !== r.z) this.vel.z = 0
+    if (vertical) this.vel.y = 0
+  }
+}
+
+module.exports = BoatPhysics

package/lib/engine/collision.js

@@ -0,0 +1,124 @@
+'use strict'
+// Port of Entity.collide / collideBoundingBox / Shapes.collide (VoxelShape.collide semantics).
+
+const { f32 } = require('./mth')
+
+const EPS = 1.0e-7
+
+// VoxelShape.collide(axis, aabb, d) for a list of boxes. axis: 0=x 1=y 2=z
+function collideAxis (axis, bb, boxes, d) {
+  if (Math.abs(d) < EPS) return 0
+  const a1 = axis === 0 ? 1 : 0
+  const a2 = axis === 2 ? 1 : 2
+  const bbMin = bb.min(axis); const bbMax = bb.max(axis)
+  const o1Min = bb.min(a1); const o1Max = bb.max(a1)
+  const o2Min = bb.min(a2); const o2Max = bb.max(a2)
+  for (let i = 0; i < boxes.length; i++) {
+    const b = boxes[i]
+    // overlap on the two other axes (cell index semantics of VoxelShape.collideX)
+    if (!(b[a1 + 3] > o1Min + EPS && b[a1] <= o1Max - EPS)) continue
+    if (!(b[a2 + 3] > o2Min + EPS && b[a2] <= o2Max - EPS)) continue
+    if (d > 0) {
+      if (b[axis] > bbMax - EPS) {
+        const g = b[axis] - bbMax
+        if (g >= -EPS && g < d) d = g
+      }
+    } else {
+      if (b[axis + 3] <= bbMin + EPS) {
+        const g = b[axis + 3] - bbMin
+        if (g <= EPS && g > d) d = g
+      }
+    }
+    if (Math.abs(d) < EPS) return 0
+  }
+  return d
+}
+
+// Entity.collideWithShapes / collideBoundingBox axis order: Y, then the larger horizontal axis last
+function collideWithShapes (vx, vy, vz, bb, boxes) {
+  if (boxes.length === 0) return { x: vx, y: vy, z: vz }
+  let dx = vx; let dy = vy; let dz = vz
+  if (dy !== 0) {
+    dy = collideAxis(1, bb, boxes, dy)
+    if (dy !== 0) bb = bb.move(0, dy, 0)
+  }
+  const zFirst = Math.abs(dx) < Math.abs(dz)
+  if (zFirst && dz !== 0) {
+    dz = collideAxis(2, bb, boxes, dz)
+    if (dz !== 0) bb = bb.move(0, 0, dz)
+  }
+  if (dx !== 0) {
+    dx = collideAxis(0, bb, boxes, dx)
+    if (!zFirst && dx !== 0) bb = bb.move(dx, 0, 0)
+  }
+  if (!zFirst && dz !== 0) {
+    dz = collideAxis(2, bb, boxes, dz)
+  }
+  return { x: dx, y: dy, z: dz }
+}
+
+function collideBoundingBox (world, vx, vy, vz, bb) {
+  const boxes = world.collisionBoxes(bb.expandTowards(vx, vy, vz))
+  return collideWithShapes(vx, vy, vz, bb, boxes)
+}
+
+const hdist = (v) => v.x * v.x + v.z * v.z
+
+// pre-1.21 step-up (1.14 - 1.20.6)
+function collideLegacy (world, vx, vy, vz, bb, onGround, maxUpStep) {
+  const r = (vx * vx + vy * vy + vz * vz) === 0 ? { x: vx, y: vy, z: vz } : collideBoundingBox(world, vx, vy, vz, bb)
+  const fx = vx !== r.x; const fy = vy !== r.y; const fz = vz !== r.z
+  const groundish = onGround || (fy && vy < 0)
+  if (maxUpStep > 0 && groundish && (fx || fz)) {
+    let v1 = collideBoundingBox(world, vx, maxUpStep, vz, bb)
+    const v2 = collideBoundingBox(world, 0, maxUpStep, 0, bb.expandTowards(vx, 0, vz))
+    if (v2.y < maxUpStep) {
+      const v3 = collideBoundingBox(world, vx, 0, vz, bb.move(v2.x, v2.y, v2.z))
+      const v3a = { x: v3.x + v2.x, y: v3.y + v2.y, z: v3.z + v2.z }
+      if (hdist(v3a) > hdist(v1)) v1 = v3a
+    }
+    if (hdist(v1) > hdist(r)) {
+      const down = collideBoundingBox(world, 0, -v1.y + vy, 0, bb.move(v1.x, v1.y, v1.z))
+      return { x: v1.x + down.x, y: v1.y + down.y, z: v1.z + down.z }
+    }
+  }
+  return r
+}
+
+// Entity.collectCandidateStepUpHeights
+function candidateStepHeights (bb, boxes, maxStep, skip) {
+  const set = new Set()
+  for (const b of boxes) {
+    for (const yc of [b[1], b[4]]) {
+      const f = f32(yc - bb.minY)
+      if (f < 0 || f === skip) continue
+      if (f > maxStep) break
+      set.add(f)
+    }
+  }
+  return [...set].sort((a, b) => a - b)
+}
+
+// 1.21+ step-up
+function collideModern (world, vx, vy, vz, bb, onGround, maxUpStep) {
+  const r = (vx * vx + vy * vy + vz * vz) === 0 ? { x: vx, y: vy, z: vz } : collideBoundingBox(world, vx, vy, vz, bb)
+  const fx = vx !== r.x; const fy = vy !== r.y; const fz = vz !== r.z
+  const landed = fy && vy < 0
+  if (maxUpStep > 0 && (landed || onGround) && (fx || fz)) {
+    const bb1 = landed ? bb.move(0, r.y, 0) : bb
+    let bb2 = bb1.expandTowards(vx, maxUpStep, vz)
+    if (!landed) bb2 = bb2.expandTowards(0, -f32(1.0e-5), 0)
+    const boxes = world.collisionBoxes(bb2)
+    const heights = candidateStepHeights(bb1, boxes, maxUpStep, f32(r.y))
+    for (const h of heights) {
+      const v = collideWithShapes(vx, h, vz, bb1, boxes)
+      if (hdist(v) > hdist(r)) {
+        const d0 = bb.minY - bb1.minY
+        return { x: v.x, y: v.y - d0, z: v.z }
+      }
+    }
+  }
+  return r
+}
+
+module.exports = { collideAxis, collideWithShapes, collideBoundingBox, collideLegacy, collideModern }

package/lib/engine/mth.js

@@ -0,0 +1,47 @@
+'use strict'
+// Port of net.minecraft.util.Mth pieces that affect movement results bit-for-bit.
+
+const f32 = Math.fround
+
+const SIN = new Float32Array(65536)
+for (let i = 0; i < 65536; i++) SIN[i] = Math.sin(i * Math.PI * 2 / 65536)
+
+const F_10430 = f32(10430.378)
+const F_16384 = f32(16384)
+const DEG_TO_RAD_F = f32(Math.PI / 180) // (float)Math.PI / 180F
+
+function sin (value) {
+  return SIN[Math.trunc(f32(f32(value) * F_10430)) & 65535]
+}
+
+function cos (value) {
+  return SIN[Math.trunc(f32(f32(f32(value) * F_10430) + F_16384)) & 65535]
+}
+
+// yRot (float degrees) -> radians exactly like `yRot * ((float)Math.PI / 180F)`
+function degToRadF (deg) {
+  return f32(f32(deg) * DEG_TO_RAD_F)
+}
+
+function clamp (v, lo, hi) {
+  return v < lo ? lo : (v > hi ? hi : v)
+}
+
+// Mth.equal(double, double) uses 1.0E-5F
+const EQ_EPS = f32(1.0e-5)
+function equal (a, b) {
+  return Math.abs(b - a) < EQ_EPS
+}
+
+function wrapDegrees (deg) {
+  let d = deg % 360
+  if (d >= 180) d -= 360
+  if (d < -180) d += 360
+  return d
+}
+
+function lengthSqr (x, y, z) {
+  return x * x + y * y + z * z
+}
+
+module.exports = { f32, sin, cos, degToRadF, clamp, equal, wrapDegrees, lengthSqr }