spectra-physics 1.0.0 → 1.2.0

package/lib/client/items.js

@@ -0,0 +1,85 @@
+'use strict'
+// LocalPlayer#startedUsingItem: whether a held item is being used, which slows movement to a fifth.
+// mineflayer's usingHeldItem is set for any item and cleared by any entity's status packet, so the state is
+// rebuilt here from what the client sends and from the server's own view of the player.
+
+const ALWAYS_EDIBLE = new Set(['golden_apple', 'enchanted_golden_apple', 'chorus_fruit', 'honey_bottle', 'suspicious_stew'])
+const DRINKS = new Set(['potion', 'milk_bucket', 'ominous_bottle'])
+const HELD_USE = new Set(['shield', 'trident', 'spyglass', 'goat_horn'])
+const ARROWS = new Set(['arrow', 'spectral_arrow', 'tipped_arrow'])
+const OFFHAND_SLOT = 45
+const FINISHED_USING = 9
+
+function isCharged (item) {
+  const projectiles = item.components?.find?.(c => c.type === 'charged_projectiles')
+  if (projectiles) return (projectiles.data?.projectiles ?? projectiles.data ?? []).length > 0
+  return item.nbt?.value?.Charged?.value === 1
+}
+
+function installItemUse (ctx) {
+  const { bot, client, V, state } = ctx
+  const flagsIndex = V.protocol >= 755 ? 8 : 7
+  const cooldowns = new Map()
+  state.using = null
+
+  const itemIn = (hand) => hand === 1 ? bot.inventory.slots[OFFHAND_SLOT] : bot.heldItem
+  const creative = () => bot.game?.gameMode === 'creative'
+  const hasAmmo = () => creative() || bot.inventory.slots.some(i => i && ARROWS.has(i.name))
+
+  // Item#use returning CONSUME / startUsingItem for the items that have a use animation
+  function canStartUsing (item) {
+    if (!item || (cooldowns.get(item.name) ?? 0) > Date.now()) return false
+    const name = item.name
+    if (DRINKS.has(name) || HELD_USE.has(name)) return true
+    if (name === 'bow') return hasAmmo()
+    if (name === 'crossbow') return !isCharged(item) && (hasAmmo() || bot.inventory.slots[OFFHAND_SLOT]?.name === 'firework_rocket')
+    if (bot.registry.foodsByName?.[name]) return ALWAYS_EDIBLE.has(name) || creative() || (bot.food ?? 20) < 20
+    return false
+  }
+
+  const start = (hand) => {
+    const item = itemIn(hand)
+    state.using = item ? { hand, name: item.name } : null
+  }
+  const stop = () => { state.using = null }
+
+  ctx.outgoing.push((name, params) => {
+    if (name === 'use_item') {
+      const hand = params.hand ?? 0
+      if (canStartUsing(itemIn(hand))) start(hand)
+    } else if (name === 'block_place' && params.direction === -1) {
+      if (canStartUsing(bot.heldItem)) start(0)
+    } else if (name === 'block_dig' && params.status === 5) {
+      stop()
+    }
+  })
+
+  client.on('entity_status', (packet) => {
+    if (packet.entityId === bot.entity?.id && packet.entityStatus === FINISHED_USING) stop()
+  })
+
+  // the server's living entity flags override the client state (LocalPlayer#onSyncedDataUpdated)
+  client.on('entity_metadata', (packet) => {
+    if (packet.entityId !== bot.entity?.id) return
+    const entry = packet.metadata?.find(m => m.key === flagsIndex)
+    if (!entry || typeof entry.value !== 'number') return
+    const active = (entry.value & 1) !== 0
+    if (active && !state.using) start((entry.value & 2) !== 0 ? 1 : 0)
+    else if (!active && state.using) stop()
+  })
+
+  client.on('set_cooldown', (packet) => {
+    const key = packet.cooldownGroup ?? bot.registry.items[packet.itemID]?.name
+    if (key) cooldowns.set(String(key).replace(/^minecraft:/, ''), Date.now() + (packet.cooldownTicks ?? 0) * 50)
+  })
+
+  client.on('respawn', stop)
+  bot.on('death', stop)
+
+  // LivingEntity#updatingUsingItem: switching or losing the item stops the use
+  ctx.updateItemUse = () => {
+    if (state.using && itemIn(state.using.hand)?.name !== state.using.name) stop()
+  }
+}
+
+module.exports = { installItemUse }

package/lib/client/protocol.js

@@ -0,0 +1,42 @@
+'use strict'
+// Fixes for packet layouts minecraft-data gets wrong. They are merged into the client's custom packets
+// before the play state starts, so the parser is built with them.
+
+const { PV } = require('../engine/version')
+
+// recipe and advancement packets whose layout in minecraft-data does not match the game; mineflayer reads neither
+function brokenPackets (pv) {
+  if (pv >= PV['1.20.5'] && pv < PV['1.21.2']) return ['declare_recipes']
+  if (pv === PV['1.21.2']) return ['declare_recipes', 'recipe_book_add', 'advancements']
+  return []
+}
+
+// minecraft-protocol merges custom packets field by field, so every original field has to be overridden:
+// the first one takes the whole payload, the others read nothing
+function rawLayout (original) {
+  const fields = Array.isArray(original?.[1]) ? original[1] : [{}]
+  return ['container', fields.map((field, i) => i === 0
+    ? { name: 'data', type: 'restBuffer' }
+    : { name: field.name ?? `unused${i}`, type: 'void' })]
+}
+
+function installProtocolPatches (ctx) {
+  const { client, registry } = ctx
+  const names = brokenPackets(registry.version.version)
+  if (!names.length) return
+  const types = registry.protocol?.play?.toClient?.types ?? {}
+  const patch = {}
+  for (const name of names) patch[`packet_${name}`] = rawLayout(types[`packet_${name}`])
+
+  const major = registry.version.majorVersion
+  const custom = client.customPackets ?? {}
+  const own = custom[major] ?? {}
+  const userTypes = own.play?.toClient?.types ?? {}
+  custom[major] = {
+    ...own,
+    play: { ...own.play, toClient: { ...own.play?.toClient, types: { ...patch, ...userTypes } } }
+  }
+  client.customPackets = custom
+}
+
+module.exports = { installProtocolPatches }

package/lib/client/registries.js

@@ -0,0 +1,86 @@
+'use strict'
+// Ids the server uses for attributes, effects and enchantments. minecraft-data is outdated or wrong for
+// several of them, so the tables here follow the game registries instead.
+
+const { PV } = require('../engine/version')
+
+const normalizeKey = (key) => String(key)
+  .replace(/^minecraft:/, '')
+  .replace(/^(generic|player|zombie)\./, '')
+  .replace(/([a-z])([A-Z])/g, '$1_$2')
+  .toLowerCase()
+
+// attribute registry order from 1.21 on; the protocol tables in minecraft-data stop at the 1.20.5 list
+function attributeRegistry (pv) {
+  if (pv < PV['1.21']) return null
+  return [
+    'armor', 'armor_toughness', 'attack_damage', 'attack_knockback', 'attack_speed', 'block_break_speed',
+    'block_interaction_range', 'burning_time', ...(pv >= PV['1.21.6'] ? ['camera_distance'] : []),
+    'explosion_knockback_resistance', 'entity_interaction_range', 'fall_damage_multiplier', 'flying_speed',
+    'follow_range', 'gravity', 'jump_strength', 'knockback_resistance', 'luck', 'max_absorption', 'max_health',
+    'mining_efficiency', 'movement_efficiency', 'movement_speed', 'oxygen_bonus', 'safe_fall_distance', 'scale',
+    'sneaking_speed', 'spawn_reinforcements', 'step_height', 'submerged_mining_speed', 'sweeping_damage_ratio',
+    ...(pv >= PV['1.21.2'] ? ['tempt_range'] : []), 'water_movement_efficiency',
+    ...(pv >= PV['1.21.6'] ? ['waypoint_receive_range', 'waypoint_transmit_range'] : [])
+  ]
+}
+
+// mineflayer names attributes through the outdated table; map those names back to ids and then to the real names
+function attributeKeyMapper (registry) {
+  const names = attributeRegistry(registry.version.version)
+  const type = registry.protocol?.play?.toClient?.types?.packet_entity_update_attributes
+  const table = type && JSON.stringify(type).match(/"mappings":(\{[^}]*\})/)
+  if (!names || !table) return normalizeKey
+  const ids = {}
+  for (const [id, name] of Object.entries(JSON.parse(table[1]))) ids[name] = Number(id)
+  return (key) => ids[key] != null && names[ids[key]] ? names[ids[key]] : normalizeKey(key)
+}
+
+// MobEffects registration order (stable for the effects movement cares about); 1-based before 1.20.2
+const EFFECTS = [
+  'speed', 'slowness', 'haste', 'mining_fatigue', 'strength', 'instant_health', 'instant_damage', 'jump_boost',
+  'nausea', 'regeneration', 'resistance', 'fire_resistance', 'water_breathing', 'invisibility', 'blindness',
+  'night_vision', 'hunger', 'weakness', 'poison', 'wither', 'health_boost', 'absorption', 'saturation', 'glowing',
+  'levitation', 'luck', 'unluck', 'slow_falling', 'conduit_power', 'dolphins_grace', 'bad_omen',
+  'hero_of_the_village', 'darkness'
+]
+
+function effectIdMapper (registry) {
+  const zeroBased = registry.version.version >= PV['1.20.2']
+  return (name) => {
+    const index = EFFECTS.indexOf(name)
+    return index < 0 ? null : index + (zeroBased ? 0 : 1)
+  }
+}
+
+// enchantments: item NBT names before 1.20.5, built-in ids in 1.20.5 - 1.20.6, the server's registry from 1.21
+function createEnchantmentReader (bot) {
+  const registry = bot.registry
+  let synced = null
+  bot._client.on('registry_data', (packet) => {
+    if (!/enchantment$/.test(String(packet.id ?? ''))) return
+    synced = (packet.entries ?? []).map(e => normalizeKey(e.key ?? e.id ?? ''))
+  })
+  const nameOf = (id) => synced?.[id] ?? registry.enchantments?.[id]?.name ?? null
+
+  return (item, name) => {
+    if (!item) return 0
+    const component = item.components?.find?.(c => c.type === 'enchantments')
+    if (component) {
+      const list = component.data?.enchantments ?? []
+      return list.find(e => nameOf(e.id) === name)?.level ?? 0
+    }
+    let legacy
+    try { legacy = item.enchants } catch { legacy = null }
+    return Array.isArray(legacy) ? (legacy.find(e => normalizeKey(e.name) === name)?.lvl ?? 0) : 0
+  }
+}
+
+// entity categories; the 1.16 tables mark every entity as a mob, so a later table is used by name
+let entityTable = null
+function entityCategory (entity) {
+  entityTable ??= require('minecraft-data')('1.20.4').entitiesByName
+  return entityTable[entity.name]?.type ?? entity.type
+}
+
+module.exports = { normalizeKey, attributeKeyMapper, effectIdMapper, createEnchantmentReader, entityCategory }

package/lib/client/reporter.js

@@ -0,0 +1,91 @@
+'use strict'
+// LocalPlayer#sendPosition and the state packets around it.
+
+const { Vec3 } = require('vec3')
+const { PV } = require('../engine/version')
+
+const POINT_THREE_SQ = 9.0e-4 // 0.03, before 1.18.2
+const MODERN_SQ = 4.0000000000000003e-8 // 2.0E-4 squared
+const REMINDER_TICKS = 20
+
+function installReporter (ctx) {
+  const { bot, V, player, state } = ctx
+  const moveThresholdSq = V.pointThree ? POINT_THREE_SQ : MODERN_SQ
+  const groundFlags = () => ({ onGround: player.onGround, hasHorizontalCollision: player.horizontalCollision })
+
+  ctx.sendSprinting = () => {
+    if (player.sprinting === state.wasSprinting) return
+    ctx.send('entity_action', { entityId: bot.entity.id, actionId: player.sprinting ? 'start_sprinting' : 'stop_sprinting', jumpBoost: 0 })
+    state.wasSprinting = player.sprinting
+  }
+
+  ctx.sendShift = () => {
+    if (V.shiftInInput) return
+    const shift = player.input.shift
+    if (shift === state.wasShift) return
+    ctx.send('entity_action', { entityId: bot.entity.id, actionId: shift ? 'start_sneaking' : 'stop_sneaking', jumpBoost: 0 })
+    state.wasShift = shift
+  }
+
+  ctx.sendInput = () => {
+    const k = ctx.keys()
+    const current = { forward: k.forward, backward: k.back, left: k.left, right: k.right, jump: k.jump, shift: k.sneak, sprint: k.sprint }
+    const last = state.lastInput
+    if (!Object.keys(current).some(key => current[key] !== last[key])) return
+    ctx.send('player_input', { inputs: current })
+    state.lastInput = current
+  }
+
+  ctx.sendLook = () => {
+    ctx.send('look', { yaw: player.yRot, pitch: player.xRot, onGround: player.onGround, flags: groundFlags() })
+    state.lastRotationAt = Date.now()
+  }
+
+  ctx.sendVehicleMove = () => {
+    const boat = state.boat
+    ctx.send('vehicle_move', { x: boat.pos.x, y: boat.pos.y, z: boat.pos.z, yaw: boat.yRot, pitch: boat.xRot, onGround: boat.onGround })
+  }
+
+  ctx.sendPosition = () => {
+    ctx.sendSprinting()
+    if (!V.playerInputPacket) ctx.sendShift()
+    const last = state.last
+    const { pos } = player
+    const dx = pos.x - last.x
+    const dy = pos.y - last.y
+    const dz = pos.z - last.z
+    state.positionReminder++
+    const rotated = player.yRot !== last.yRot || player.xRot !== last.xRot
+    // Grim drops the vertical 0.03 slack for skipped airborne and landing ticks, so those are always reported;
+    // 1.17+ position_look packets under 0.03 would be taken for the item-use duplicate and ignored
+    const airborne = !player.onGround || !last.onGround
+    const reportSmall = V.pointThree && airborne && dy !== 0 && !(rotated && V.protocol >= PV['1.17'])
+    const distanceSq = dx * dx + dy * dy + dz * dz
+    const moved = distanceSq > (reportSmall ? MODERN_SQ : moveThresholdSq) || state.positionReminder >= REMINDER_TICKS
+    state.creeping = V.pointThree && V.protocol >= PV['1.17'] && airborne && dy !== 0 && distanceSq <= POINT_THREE_SQ
+    const flags = { onGround: player.onGround, flags: groundFlags() }
+    const previous = new Vec3(last.x, last.y, last.z)
+
+    if (moved && rotated) ctx.send('position_look', { x: pos.x, y: pos.y, z: pos.z, yaw: player.yRot, pitch: player.xRot, ...flags })
+    else if (moved) ctx.send('position', { x: pos.x, y: pos.y, z: pos.z, ...flags })
+    else if (rotated) ctx.send('look', { yaw: player.yRot, pitch: player.xRot, ...flags })
+    else if (last.onGround !== player.onGround || (V.movementFlags && last.horizontalCollision !== player.horizontalCollision)) ctx.send('flying', flags)
+
+    if (moved) {
+      last.x = pos.x
+      last.y = pos.y
+      last.z = pos.z
+      state.positionReminder = 0
+    }
+    if (rotated) {
+      last.yRot = player.yRot
+      last.xRot = player.xRot
+      state.lastRotationAt = Date.now()
+    }
+    last.onGround = player.onGround
+    last.horizontalCollision = player.horizontalCollision
+    if (moved || rotated) bot.emit('move', previous)
+  }
+}
+
+module.exports = { installReporter }

package/lib/client/riding.js

@@ -0,0 +1,69 @@
+'use strict'
+// Passenger tick: the boat moves first (client controlled), then the rider sends rotation, input and vehicle move.
+
+const conv = require('mineflayer/lib/conversions')
+const BoatPhysics = require('../engine/boat')
+const { f32, clamp, wrapDegrees } = require('../engine/mth')
+const { readKeys } = require('../engine/player/input')
+
+const isBoat = (entity) => /boat|raft/.test(entity?.name ?? '')
+
+function riderOffset (vehicle) {
+  if (isBoat(vehicle)) return f32(-0.1 + -0.35)
+  if (/minecart/.test(vehicle?.name ?? '')) return f32(-0.35)
+  return (vehicle?.height ?? 1) * 0.75 - 0.35
+}
+
+function installRiding (ctx) {
+  const { bot, V, player, state, world } = ctx
+
+  // the boat ticks before its rider, so it steers with the keys the rider set on the previous tick (Boat#setInput)
+  function tickBoat (vehicle) {
+    if (!state.boat || state.boat.entityId !== vehicle.id) {
+      state.boat = new BoatPhysics(world, V, { position: vehicle.position, yawDegrees: f32(conv.toNotchianYaw(vehicle.yaw)) })
+      state.boat.entityId = vehicle.id
+      state.boat.input = { forward: false, back: false, left: false, right: false }
+    }
+    state.boat.tick(state.boat.input)
+    ctx.send('steer_boat', { leftPaddle: state.boat.paddle[0], rightPaddle: state.boat.paddle[1] })
+    vehicle.position.set(state.boat.pos.x, state.boat.pos.y, state.boat.pos.z)
+  }
+
+  ctx.ridingTick = (vehicle) => {
+    ctx.flushActions()
+    const keys = ctx.keys()
+    const controlling = vehicle.passengers?.[0] === bot.entity
+    if (isBoat(vehicle) && controlling) tickBoat(vehicle)
+    else state.boat = null
+
+    player.riding = true
+    player.vel = { x: 0, y: 0, z: 0 }
+    readKeys(player, keys, false)
+    player.pos = { x: vehicle.position.x, y: vehicle.position.y + riderOffset(vehicle), z: vehicle.position.z }
+    ctx.turn()
+    if (isBoat(vehicle)) {
+      const boatYaw = state.boat ? state.boat.yRot : f32(conv.toNotchianYaw(vehicle.yaw))
+      const offset = wrapDegrees(player.yRot - boatYaw)
+      player.yRot = f32(player.yRot + clamp(offset, -105, 105) - offset)
+    }
+    ctx.syncEntity()
+    if (state.boat) state.boat.input = { forward: keys.forward, back: keys.back, left: keys.left, right: keys.right }
+
+    if (!V.playerInputPacket) {
+      ctx.sendLook()
+      const flags = (player.input.jumping ? 1 : 0) | (player.input.shift ? 2 : 0)
+      ctx.send('steer_vehicle', { sideways: player.input.left, forward: player.input.forward, jump: flags })
+      if (state.boat) ctx.sendVehicleMove()
+      return
+    }
+    ctx.sendShift()
+    ctx.sendInput()
+    ctx.sendLook()
+    if (state.boat) {
+      ctx.sendVehicleMove()
+      ctx.sendSprinting()
+    }
+  }
+}
+
+module.exports = { installRiding }

package/lib/client/server.js

@@ -0,0 +1,103 @@
+'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)
+  })
+
+  // the passenger list replaces the old one; mineflayer only appends and only leaves on vehicle id -1,
+  // which the server never sends, so a bot stays "mounted" after every dismount
+  client.on('set_passengers', ({ entityId, passengers }) => {
+    const vehicle = bot.entities[entityId]
+    if (vehicle) vehicle.passengers = passengers.map(id => bot.entities[id]).filter(Boolean)
+    const current = bot.vehicle
+    if (!current || current.id !== entityId || passengers.includes(bot.entity?.id)) return
+    bot.vehicle = null
+    if (bot.entity) bot.entity.vehicle = null
+    state.boat = null
+    bot.emit('dismount', current)
+  })
+}
+
+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 }