spectra-physics 1.0.0

package/lib/engine/version.js

@@ -0,0 +1,55 @@
+'use strict'
+// Version switches for client behaviour that differs between 1.16.5 and 26.x.
+// Uses the protocol version number so "1.21.3" (768) == "1.21.2" etc.
+
+const PV = {
+  '1.16.5': 754,
+  '1.17': 755,
+  '1.19.4': 762,
+  '1.20': 763,
+  '1.20.2': 764,
+  '1.20.3': 765,
+  '1.20.5': 766,
+  '1.21': 767,
+  '1.21.2': 768,
+  '1.21.4': 769,
+  '1.21.5': 770,
+  '1.21.6': 771,
+  '1.21.9': 773
+}
+
+function versionFlags (registry) {
+  const pv = registry.version['>='] ? registry.version.version : registry.version
+  const at = (name) => pv >= PV[name]
+  return {
+    protocol: pv,
+    name: registry.version.minecraftVersion,
+    // login / configuration
+    configPhase: at('1.20.2'), // brand + client information are sent in the configuration phase
+    // movement packets
+    movementFlags: at('1.21.2'), // onGround + horizontalCollision bitflags in move packets
+    tickEnd: at('1.21.2'), // ServerboundClientTickEndPacket after every client tick
+    playerInputPacket: at('1.21.2'), // ServerboundPlayerInputPacket sent on key change (replaces steer_vehicle)
+    shiftInInput: at('1.21.6'), // no more PRESS/RELEASE_SHIFT_KEY player commands
+    clientLoaded: at('1.21.4'), // player does not tick until the level screen closes, then sends player_loaded
+    posRotBeforeConfirm: pv === PV['1.21.2'], // 1.21.2/1.21.3 answer teleports with pos-rot *before* accept-teleportation
+    relativeTeleportVelocity: at('1.21.2'), // teleport packet carries delta movement + delta flags
+    lpVelocity: at('1.21.9'), // entity_velocity uses lpVec3 (already blocks/tick)
+    // physics
+    posFromBoundingBox: !at('1.17'), // 1.16 recalculates the position from the bounding box centre
+    flyingSpeedLive: at('1.19.4'), // Player#getFlyingSpeed() instead of the lagging flyingSpeed field
+    minorCollision: at('1.19.4'), // sprinting survives "minor" horizontal collisions
+    supportingBlock: at('1.20'), // mainSupportingBlockPos drives the block below
+    attributes2005: at('1.20.5'), // gravity / step_height / jump_strength attributes
+    jumpKeepsHigherY: at('1.21'),
+    modernStepUp: at('1.21'), // collectCandidateStepUpHeights step algorithm
+    normalizedInput: at('1.21.2'), // KeyboardInput#moveVector is normalized
+    modernBackOff: at('1.21.2'), // canFallAtLeast based sneak edge back-off
+    squareInput: at('1.21.5'), // modifyInputSpeedForSquareMovement
+    fallDistanceDouble: at('1.21.5'),
+    // vehicles
+    moveVehicleOnGround: at('1.21.2')
+  }
+}
+
+module.exports = { versionFlags, PV }

package/lib/engine/world.js

@@ -0,0 +1,162 @@
+'use strict'
+// Block / fluid access layer for the vanilla physics port.
+// Reads mineflayer's world (prismarine-world) and caches per-stateId block traits.
+
+const { f32 } = require('./mth')
+
+const CLIMBABLE = new Set([
+  'ladder', 'vine', 'scaffolding', 'weeping_vines', 'weeping_vines_plant',
+  'twisting_vines', 'twisting_vines_plant', 'cave_vines', 'cave_vines_plant'
+])
+const WATER_SOURCES = new Set(['seagrass', 'tall_seagrass', 'kelp', 'kelp_plant', 'bubble_column'])
+const FRICTION = { ice: 0.98, packed_ice: 0.98, frosted_ice: 0.98, blue_ice: 0.989, slime_block: 0.8, slime: 0.8 }
+const SPEED_FACTOR = { soul_sand: 0.4, honey_block: 0.4 }
+const JUMP_FACTOR = { honey_block: 0.5 }
+
+const FULL = [0, 0, 0, 1, 1, 1]
+
+class WorldView {
+  constructor (bot) {
+    this.bot = bot
+    this.registry = bot.registry
+    this.Block = require('prismarine-block')(bot.registry)
+    this.cache = new Map()
+    this.pos = { x: 0, y: 0, z: 0 }
+  }
+
+  get minY () { return this.bot.game?.minY ?? 0 }
+  get maxY () { return this.minY + (this.bot.game?.height ?? 256) }
+
+  hasChunk (bx, bz) {
+    return !!this.bot.world.getColumn(Math.floor(bx) >> 4, Math.floor(bz) >> 4)
+  }
+
+  // returns null when the column is not loaded
+  stateAt (x, y, z) {
+    const col = this.bot.world.getColumn(x >> 4, z >> 4)
+    if (!col) return null
+    if (y < this.minY || y >= this.maxY) return 0
+    this.pos.x = x & 15; this.pos.y = y; this.pos.z = z & 15
+    return col.getBlockStateId(this.pos)
+  }
+
+  info (stateId) {
+    let i = this.cache.get(stateId)
+    if (i) return i
+    i = this._build(stateId)
+    this.cache.set(stateId, i)
+    return i
+  }
+
+  blockAt (x, y, z) {
+    const s = this.stateAt(x, y, z)
+    return this.info(s ?? 0)
+  }
+
+  _build (stateId) {
+    let b
+    try { b = this.Block.fromStateId(stateId, 0) } catch (e) { b = null }
+    const name = b?.name ?? 'air'
+    const props = (b && b.getProperties) ? b.getProperties() : {}
+    const shapes = (b && Array.isArray(b.shapes)) ? b.shapes.filter(s => s && s.length === 6) : []
+    const info = {
+      stateId,
+      name,
+      props,
+      shapes,
+      isAir: name === 'air' || name === 'cave_air' || name === 'void_air',
+      friction: f32(FRICTION[name] ?? 0.6),
+      speedFactor: f32(SPEED_FACTOR[name] ?? 1.0),
+      jumpFactor: f32(JUMP_FACTOR[name] ?? 1.0),
+      climbable: CLIMBABLE.has(name),
+      isTrapdoor: name.endsWith('_trapdoor'),
+      isLadder: name === 'ladder',
+      isSlime: name === 'slime_block' || name === 'slime',
+      isBed: name.endsWith('_bed') || name === 'bed',
+      isHoney: name === 'honey_block',
+      isCobweb: name === 'cobweb' || name === 'web',
+      isBerryBush: name === 'sweet_berry_bush',
+      isPowderSnow: name === 'powder_snow',
+      isScaffolding: name === 'scaffolding',
+      isFenceLike: name.endsWith('_fence') || name.endsWith('_wall') || name.endsWith('_fence_gate'),
+      fullCube: shapes.length === 1 && shapes[0].every((v, k) => v === FULL[k]),
+      fluid: null
+    }
+    // fluids
+    if (name === 'water' || name === 'lava' || name === 'flowing_water' || name === 'flowing_lava') {
+      const level = Number(props.level ?? 0)
+      const falling = level >= 8
+      const amount = falling ? 8 : (level === 0 ? 8 : 8 - level)
+      info.fluid = { type: name.includes('water') ? 'water' : 'lava', amount, falling, source: level === 0 }
+    } else if (props.waterlogged === true || props.waterlogged === 'true' || WATER_SOURCES.has(name)) {
+      info.fluid = { type: 'water', amount: 8, falling: false, source: true }
+    }
+    return info
+  }
+
+  fluidAt (x, y, z) {
+    const s = this.stateAt(x, y, z)
+    if (s == null) return null
+    return this.info(s).fluid
+  }
+
+  // FluidState.getOwnHeight()
+  static ownHeight (fluid) {
+    return fluid ? f32(fluid.amount / 9.0) : 0
+  }
+
+  // FluidState.getHeight(level, pos)
+  fluidHeight (x, y, z, fluid) {
+    if (!fluid) return 0
+    const above = this.fluidAt(x, y + 1, z)
+    if (above && above.type === fluid.type) return 1.0
+    return WorldView.ownHeight(fluid)
+  }
+
+  // Collect every collision box that could touch `bb` (BlockCollisions semantics:
+  // unloaded chunks collide with nothing, outside build height is air).
+  collisionBoxes (bb, out = []) {
+    const x0 = Math.floor(bb.minX - 1.0e-7) - 1; const x1 = Math.floor(bb.maxX + 1.0e-7) + 1
+    const y0 = Math.floor(bb.minY - 1.0e-7) - 1; const y1 = Math.floor(bb.maxY + 1.0e-7) + 1
+    const z0 = Math.floor(bb.minZ - 1.0e-7) - 1; const z1 = Math.floor(bb.maxZ + 1.0e-7) + 1
+    for (let x = x0; x <= x1; x++) {
+      for (let z = z0; z <= z1; z++) {
+        const col = this.bot.world.getColumn(x >> 4, z >> 4)
+        if (!col) continue
+        for (let y = y0; y <= y1; y++) {
+          if (y < this.minY || y >= this.maxY) continue
+          this.pos.x = x & 15; this.pos.y = y; this.pos.z = z & 15
+          const info = this.info(col.getBlockStateId(this.pos))
+          const shapes = info.shapes
+          for (let k = 0; k < shapes.length; k++) {
+            const s = shapes[k]
+            out.push([s[0] + x, s[1] + y, s[2] + z, s[3] + x, s[4] + y, s[5] + z])
+          }
+        }
+      }
+    }
+    return out
+  }
+
+  noCollision (bb) {
+    const boxes = this.collisionBoxes(bb)
+    for (const b of boxes) if (bb.intersectsBox(b)) return false
+    return true
+  }
+
+  containsAnyLiquid (bb) {
+    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)
+    for (let x = x0; x < x1; x++) {
+      for (let y = y0; y < y1; y++) {
+        for (let z = z0; z < z1; z++) {
+          if (this.fluidAt(x, y, z)) return true
+        }
+      }
+    }
+    return false
+  }
+}
+
+module.exports = WorldView