minecraft-renderer 0.1.64 → 0.1.65

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecraft-renderer",
-  "version": "0.1.64",
+  "version": "0.1.65",
   "description": "The most Modular Minecraft world renderer with Three.js WebGL backend",
   "type": "module",
   "main": "./dist/index.js",

package/src/three/entities.ts

@@ -45,14 +45,6 @@ export const TWEEN_DURATION = 120
 
 const degreesToRadians = (degrees: number) => degrees * (Math.PI / 180)
 
-const clamp01 = (v: number) => Math.max(0, Math.min(1, v))
-const clamp = (v: number, a: number, b: number) => Math.max(a, Math.min(b, v))
-const wrapPi = (a: number) => {
-  a = (a + Math.PI) % (Math.PI * 2)
-  if (a < 0) a += Math.PI * 2
-  return a - Math.PI
-}
-
 function convert2sComplementToHex(complement: number) {
   if (complement < 0) {
     complement = (0xFF_FF_FF_FF + complement + 1) >>> 0
@@ -280,130 +272,45 @@ export class Entities {
   pendingModelOverrides = new Map<string, { parts: EntityModelOverridePart[] }>()
 
   private motionCache = new Map<string, { pos: THREE.Vector3, speed: number }>()
-  private _wasThirdPerson = false
+  private readonly MOVE_ON = 0.05
+  private readonly MOVE_OFF = 0.02
+  private readonly RUN_ON = 4.8
+  private readonly RUN_OFF = 4.2
 
-  private _tpBodyYaw = 0
-  private _tpHasBodyYaw = false
-
-  private updateAutoWalkFlags(entityKey: string, entity: SceneEntity, dt: number, samplePos?: THREE.Vector3) {
+  private updateAutoWalkFlags(entityKey: string, entity: SceneEntity, dt: number) {
     if (!entity.playerObject?.animation) return
     const anim: any = entity.playerObject.animation
+    if (!('isMoving' in anim) || !('isRunning' in anim)) return
     if (dt <= 0) return
 
-    const pos = samplePos ?? entity.position
-
     const cached = this.motionCache.get(entityKey)
     if (!cached) {
-      this.motionCache.set(entityKey, { pos: pos.clone(), speed: 0 })
+      this.motionCache.set(entityKey, { pos: entity.position.clone(), speed: 0 })
       anim.isMoving = false
       anim.isRunning = false
-      anim.moveAmount = 0
-      anim.runAmount = 0
       return
     }
 
-    const dx = pos.x - cached.pos.x
-    const dz = pos.z - cached.pos.z
-    cached.pos.copy(pos)
+    const dx = entity.position.x - cached.pos.x
+    const dz = entity.position.z - cached.pos.z
+    cached.pos.copy(entity.position)
 
-    const instSpeed = Math.hypot(dx, dz) / Math.max(dt, 1e-6) // blocks/sec
+    const instSpeed = Math.hypot(dx, dz) / Math.max(dt, 1e-6)
 
-    const alpha = 1 - Math.exp(-dt * 12)
-    cached.speed += (instSpeed - cached.speed) * alpha
-
-    const speed = cached.speed
-
-    const smoothstep = (a: number, b: number, x: number) => {
-      const t = clamp01((x - a) / (b - a))
-      return t * t * (3 - 2 * t)
-    }
+    cached.speed = cached.speed * 0.8 + instSpeed * 0.2
 
-    const MOVE_START = 0.08
-    const MOVE_FULL = 0.6
+    const movingNow = anim.isMoving
+      ? cached.speed > this.MOVE_OFF
+      : cached.speed > this.MOVE_ON
 
-    const WALK_MAX = 4.3
-    const SPRINT_FULL = 5.6
+    const runningNow = anim.isRunning
+      ? cached.speed > this.RUN_OFF
+      : cached.speed > this.RUN_ON
 
-    const moveAmount = smoothstep(MOVE_START, MOVE_FULL, speed)
-    const runAmount = smoothstep(WALK_MAX, SPRINT_FULL, speed)
-
-    anim.moveAmount = moveAmount
-    anim.runAmount = runAmount
-
-    anim.isMoving = moveAmount > 0.15
-    anim.isRunning = runAmount > 0.55
-  }
-
-  private getLocalSneak(): boolean {
-    const ps: any = this.worldRenderer.playerStateReactive as any
-    return (
-      ps?.movementState === 'SNEAKING' ||
-      ps?.movementState === 'CROUCHING' ||
-      !!ps?.isSneaking ||
-      !!ps?.sneaking ||
-      !!ps?.isCrouching ||
-      !!ps?.crouching ||
-      !!ps?.controls?.sneak ||
-      !!ps?.controlState?.sneak
-    )
+    anim.isMoving = movingNow
+    anim.isRunning = movingNow && runningNow
   }
 
-  private updateThirdPersonHeadAndBody(entity: SceneEntity, dt: number) {
-    const anim: any = entity.playerObject?.animation
-    const rotation = this.worldRenderer.cameraShake.getBaseRotation()
-
-    const camYaw = rotation.yaw
-    const camPitch = rotation.pitch
-
-    const move = clamp01(anim?.moveAmount ?? (anim?.isMoving ? 1 : 0))
-    const run = clamp01(anim?.runAmount ?? (anim?.isRunning ? 1 : 0))
-    const moving = move > 0.15
-
-    if (!this._tpHasBodyYaw) {
-      this._tpHasBodyYaw = true
-      this._tpBodyYaw = camYaw
-    }
-
-    if (moving) {
-      const k = 1 - Math.exp(-dt * (18 + 10 * run))
-      this._tpBodyYaw = this._tpBodyYaw + wrapPi(camYaw - this._tpBodyYaw) * k
-
-      entity.rotation.set(0, this._tpBodyYaw, 0)
-
-      const headMax = ((25 - 8 * run) * Math.PI) / 180
-      const headYaw = clamp(wrapPi(camYaw - this._tpBodyYaw), -headMax, headMax)
-
-      if (anim && 'lookYaw' in anim) anim.lookYaw = headYaw
-      if (anim && 'lookPitch' in anim) anim.lookPitch = -camPitch
-      return
-    }
-
-    // idle behavior (head leads, body follows after threshold)
-    const maxHeadYaw = (85 * Math.PI) / 180
-    const bodyFollowStart = (55 * Math.PI) / 180
-
-    let desiredHeadYaw = wrapPi(camYaw - this._tpBodyYaw)
-    desiredHeadYaw = clamp(desiredHeadYaw, -maxHeadYaw, maxHeadYaw)
-
-    const excess = Math.abs(desiredHeadYaw) - bodyFollowStart
-    if (excess > 0) {
-      const push = excess / (maxHeadYaw - bodyFollowStart)
-      const targetBodyYaw = camYaw - Math.sign(desiredHeadYaw) * bodyFollowStart
-      const k = 1 - Math.exp(-dt * (6 + 10 * push))
-      this._tpBodyYaw = this._tpBodyYaw + wrapPi(targetBodyYaw - this._tpBodyYaw) * k
-      desiredHeadYaw = wrapPi(camYaw - this._tpBodyYaw)
-      desiredHeadYaw = clamp(desiredHeadYaw, -maxHeadYaw, maxHeadYaw)
-    } else {
-      const k = 1 - Math.exp(-dt * 5)
-      this._tpBodyYaw = this._tpBodyYaw + wrapPi(camYaw - this._tpBodyYaw) * (k * 0.15)
-    }
-
-    entity.rotation.set(0, this._tpBodyYaw, 0)
-    if (anim && 'lookYaw' in anim) anim.lookYaw = desiredHeadYaw
-    if (anim && 'lookPitch' in anim) anim.lookPitch = -camPitch
-  }
-
-
   get entitiesByName(): Record<string, SceneEntity[]> {
     const byName: Record<string, SceneEntity[]> = {}
     for (const entity of Object.values(this.entities)) {
@@ -477,8 +384,6 @@ export class Entities {
     this.currentSkinUrls = {}
 
     this.motionCache.clear()
-    this._wasThirdPerson = false
-    this._tpHasBodyYaw = false
 
     // Clean up player entity
     if (this.playerEntity) {
@@ -547,93 +452,67 @@ export class Entities {
     const botPos = this.worldRenderer.viewerChunkPosition
     const VISIBLE_DISTANCE = 10 * 10
 
-    const thirdPersonNow = this.worldRenderer.playerStateUtils.isThirdPerson()
-    if (thirdPersonNow !== this._wasThirdPerson) {
-      this._wasThirdPerson = thirdPersonNow
-      const key = String(this.playerEntity?.originalEntity.id ?? 'player_entity')
-      this.motionCache.delete(key)
-
-      const anim: any = this.playerEntity?.playerObject?.animation
-      if (anim?.resetLocomotion) anim.resetLocomotion()
-
-      this._tpHasBodyYaw = false
-    }
-
     for (const [entityIdRaw, entity] of [...Object.entries(this.entities), ['player_entity', this.playerEntity] as [string, SceneEntity | null]]) {
       if (!entity) continue
 
+      let entityKey = entityIdRaw
       const isPlayerEntity = entityIdRaw === 'player_entity'
-      const entityKey = isPlayerEntity ? String(this.playerEntity?.originalEntity.id ?? 'player_entity') : String(entityIdRaw)
 
       if (isPlayerEntity) {
-        entity.visible = thirdPersonNow
+        const thirdPerson = this.worldRenderer.playerStateUtils.isThirdPerson()
+        entity.visible = thirdPerson
 
-        if (thirdPersonNow) {
+        if (thirdPerson) {
           const yOffset = this.worldRenderer.playerStateReactive.eyeHeight
-          // Set world position — proxy auto-converts to scene coords
           entity.position.set(
             this.worldRenderer.cameraWorldPos.x,
             this.worldRenderer.cameraWorldPos.y - yOffset,
             this.worldRenderer.cameraWorldPos.z
           )
-
-          const p: any = (this.worldRenderer.playerStateReactive as any).position
-          if (p && typeof p.x === 'number') {
-            this.updateAutoWalkFlags(entityKey, entity, dtRaw, new THREE.Vector3(p.x, p.y, p.z))
-          } else {
-            const wp = this.worldRenderer.sceneOrigin.getWorldPosition(entity)
-            this.updateAutoWalkFlags(entityKey, entity, dtRaw, wp ? new THREE.Vector3(wp.x, wp.y, wp.z) : entity.position)
-          }
-
-          this.updateThirdPersonHeadAndBody(entity, dt)
-        } else {
-          const wp = this.worldRenderer.sceneOrigin.getWorldPosition(entity)
-          this.updateAutoWalkFlags(entityKey, entity, dtRaw, wp ? new THREE.Vector3(wp.x, wp.y, wp.z) : entity.position)
         }
-      } else {
-        const wp = this.worldRenderer.sceneOrigin.getWorldPosition(entity)
-        this.updateAutoWalkFlags(entityKey, entity, dtRaw, wp ? new THREE.Vector3(wp.x, wp.y, wp.z) : entity.position)
+
+        entityKey = String(this.playerEntity?.originalEntity.id ?? 'player_entity')
       }
 
       const { playerObject } = entity
 
-      if (playerObject?.animation) {
-        const anim: any = playerObject.animation
-
-        const flags = Number((entity.originalEntity?.metadata?.[0] ?? 0))
-        const remoteSneak = (flags & 0x02) !== 0
-
-        const localSneak = this.getLocalSneak()
-
-        if ('isCrouched' in anim) anim.isCrouched = isPlayerEntity ? localSneak : remoteSneak
+      this.updateAutoWalkFlags(entityKey, entity, dtRaw)
 
+      if (playerObject?.animation) {
         playerObject.animation.update(playerObject, dt)
       }
 
-      // Update GLTF animations
       entity.traverse(child => {
         if (child instanceof Entity.EntityMesh) {
           child.update(dt)
         }
       })
 
-      // Update visibility based on distance and chunk load status
       if (!isPlayerEntity && botPos && entity.position) {
         const dx = entity.position.x - botPos.x
         const dy = entity.position.y - botPos.y
         const dz = entity.position.z - botPos.z
         const distanceSquared = dx * dx + dy * dy + dz * dz
 
-        // Entity is visible if within 20 blocks OR in a finished chunk
         entity.visible = !!(distanceSquared < VISIBLE_DISTANCE || this.worldRenderer.shouldObjectVisible(entity))
 
         this.maybeRenderPlayerSkin(entityIdRaw)
       }
 
       if (entity.visible) {
-        // Update armor positions
         this.syncArmorPositions(entity)
       }
+
+      if (isPlayerEntity && entity.visible) {
+        const rotation = this.worldRenderer.cameraShake.getBaseRotation()
+        entity.rotation.set(0, rotation.yaw, 0)
+
+        entity.traverse((c) => {
+          if (c.name === 'head') {
+            c.rotation.set(-rotation.pitch, 0, 0)
+          }
+        })
+      }
     }
   }
 

package/src/three/entity/animations.js

@@ -2,27 +2,7 @@
 import { PlayerAnimation } from 'skinview3d'
 
 const clamp01 = (v) => Math.max(0, Math.min(1, v))
-const clamp = (v, a, b) => Math.max(a, Math.min(b, v))
 const mix = (a, b, t) => a + (b - a) * t
-const wrapPi = (a) => {
-  a = (a + Math.PI) % (Math.PI * 2)
-  if (a < 0) a += Math.PI * 2
-  return a - Math.PI
-}
-
-/**
- * @typedef {{
- *  playerRot: any,
- *  bodyPos: any, bodyRot: any,
- *  leftArmPos: any, leftArmRot: any,
- *  rightArmPos: any, rightArmRot: any,
- *  leftLegPos: any, leftLegRot: any,
- *  rightLegPos: any, rightLegRot: any,
- *  headPos: any, headRot: any,
- *  capePos: any, capeRot: any,
- *  elytraPos: any, elytraRot: any,
- * }} Defaults
- */
 
 function updateElytraRightWing(player) {
   const elytra = player?.elytra
@@ -53,32 +33,24 @@ export class WalkingGeneralSwing extends PlayerAnimation {
   isMoving = true
   isCrouched = false
 
-  /** @type {number} 0..1 */
-  moveAmount = 0
-  /** @type {number} 0..1 */
-  runAmount = 0
-
-  /** @type {number} radians */
-  lookYaw = 0
-  /** @type {number} radians */
-  lookPitch = 0
-
   _dt = 0
   _phase = 0
-  _idlePhase = 0
-
   _moveBlend = 0
-  _runBlend = 0
-  _crouchBlend = 0
-
-  _lookYawBlend = 0
-  _lookPitchBlend = 0
 
   /** @type {number | null} */
   _swingTime = null
   _swingDuration = 0.25
 
-  /** @type {Defaults | null} */
+  /** @type {{
+    bodyPos: any, bodyRot: any,
+    leftArmPos: any, leftArmRot: any,
+    rightArmPos: any, rightArmRot: any,
+    leftLegPos: any, leftLegRot: any,
+    rightLegPos: any, rightLegRot: any,
+    headPos: any, headRot: any,
+    capePos: any, capeRot: any,
+    elytraPos: any, elytraRot: any,
+  } | null} */
   _defaults = null
 
   update(player, delta) {
@@ -96,39 +68,29 @@ export class WalkingGeneralSwing extends PlayerAnimation {
     }
   }
 
-  resetLocomotion() {
-    this._moveBlend = 0
-    this._runBlend = 0
-    this._crouchBlend = 0
-    this._phase = 0
-  }
-
   _captureDefaults(player) {
-    const skin = player?.skin
     this._defaults = {
-      playerRot: player?.rotation?.clone?.(),
+      bodyPos: player.skin.body.position.clone(),
+      bodyRot: player.skin.body.rotation.clone(),
 
-      bodyPos: skin?.body?.position?.clone?.(),
-      bodyRot: skin?.body?.rotation?.clone?.(),
+      leftArmPos: player.skin.leftArm.position.clone(),
+      leftArmRot: player.skin.leftArm.rotation.clone(),
+      rightArmPos: player.skin.rightArm.position.clone(),
+      rightArmRot: player.skin.rightArm.rotation.clone(),
 
-      leftArmPos: skin?.leftArm?.position?.clone?.(),
-      leftArmRot: skin?.leftArm?.rotation?.clone?.(),
-      rightArmPos: skin?.rightArm?.position?.clone?.(),
-      rightArmRot: skin?.rightArm?.rotation?.clone?.(),
+      leftLegPos: player.skin.leftLeg.position.clone(),
+      leftLegRot: player.skin.leftLeg.rotation.clone(),
+      rightLegPos: player.skin.rightLeg.position.clone(),
+      rightLegRot: player.skin.rightLeg.rotation.clone(),
 
-      leftLegPos: skin?.leftLeg?.position?.clone?.(),
-      leftLegRot: skin?.leftLeg?.rotation?.clone?.(),
-      rightLegPos: skin?.rightLeg?.position?.clone?.(),
-      rightLegRot: skin?.rightLeg?.rotation?.clone?.(),
+      headPos: player.skin.head.position.clone(),
+      headRot: player.skin.head.rotation.clone(),
 
-      headPos: skin?.head?.position?.clone?.(),
-      headRot: skin?.head?.rotation?.clone?.(),
+      capePos: player.cape.position.clone(),
+      capeRot: player.cape.rotation.clone(),
 
-      capePos: player?.cape?.position?.clone?.(),
-      capeRot: player?.cape?.rotation?.clone?.(),
-
-      elytraPos: player?.elytra?.position?.clone?.(),
-      elytraRot: player?.elytra?.rotation?.clone?.(),
+      elytraPos: player.elytra.position.clone(),
+      elytraRot: player.elytra.rotation.clone(),
     }
   }
 
@@ -136,152 +98,102 @@ export class WalkingGeneralSwing extends PlayerAnimation {
     const d = this._defaults
     if (!d) return
 
-    const skin = player?.skin
-    const cape = player?.cape
-    const elytra = player?.elytra
-
-    if (d.playerRot && player?.rotation) player.rotation.copy(d.playerRot)
+    player.skin.body.position.copy(d.bodyPos)
+    player.skin.body.rotation.copy(d.bodyRot)
 
-    if (d.bodyPos && skin?.body?.position) skin.body.position.copy(d.bodyPos)
-    if (d.bodyRot && skin?.body?.rotation) skin.body.rotation.copy(d.bodyRot)
+    player.skin.leftArm.position.copy(d.leftArmPos)
+    player.skin.leftArm.rotation.copy(d.leftArmRot)
+    player.skin.rightArm.position.copy(d.rightArmPos)
+    player.skin.rightArm.rotation.copy(d.rightArmRot)
 
-    if (d.leftArmPos && skin?.leftArm?.position) skin.leftArm.position.copy(d.leftArmPos)
-    if (d.leftArmRot && skin?.leftArm?.rotation) skin.leftArm.rotation.copy(d.leftArmRot)
+    player.skin.leftLeg.position.copy(d.leftLegPos)
+    player.skin.leftLeg.rotation.copy(d.leftLegRot)
+    player.skin.rightLeg.position.copy(d.rightLegPos)
+    player.skin.rightLeg.rotation.copy(d.rightLegRot)
 
-    if (d.rightArmPos && skin?.rightArm?.position) skin.rightArm.position.copy(d.rightArmPos)
-    if (d.rightArmRot && skin?.rightArm?.rotation) skin.rightArm.rotation.copy(d.rightArmRot)
+    player.skin.head.position.copy(d.headPos)
+    player.skin.head.rotation.copy(d.headRot)
 
-    if (d.leftLegPos && skin?.leftLeg?.position) skin.leftLeg.position.copy(d.leftLegPos)
-    if (d.leftLegRot && skin?.leftLeg?.rotation) skin.leftLeg.rotation.copy(d.leftLegRot)
+    player.cape.position.copy(d.capePos)
+    player.cape.rotation.copy(d.capeRot)
 
-    if (d.rightLegPos && skin?.rightLeg?.position) skin.rightLeg.position.copy(d.rightLegPos)
-    if (d.rightLegRot && skin?.rightLeg?.rotation) skin.rightLeg.rotation.copy(d.rightLegRot)
-
-    if (d.headPos && skin?.head?.position) skin.head.position.copy(d.headPos)
-    if (d.headRot && skin?.head?.rotation) skin.head.rotation.copy(d.headRot)
-
-    if (d.capePos && cape?.position) cape.position.copy(d.capePos)
-    if (d.capeRot && cape?.rotation) cape.rotation.copy(d.capeRot)
-
-    if (d.elytraPos && elytra?.position) elytra.position.copy(d.elytraPos)
-    if (d.elytraRot && elytra?.rotation) elytra.rotation.copy(d.elytraRot)
+    player.elytra.position.copy(d.elytraPos)
+    player.elytra.rotation.copy(d.elytraRot)
   }
 
   animate(player) {
     const dt = this._dt || 0
+
     if (!this._defaults) this._captureDefaults(player)
     this._applyDefaults(player)
 
-    const externalMove = typeof this.moveAmount === 'number' ? this.moveAmount : (this.isMoving ? 1 : 0)
-    const externalRun = typeof this.runAmount === 'number' ? this.runAmount : (this.isRunning ? 1 : 0)
-
-    const targetMove = clamp01(externalMove)
-    const targetRun = clamp01(externalRun)
-    const targetCrouch = this.isCrouched ? 1 : 0
-
-    const kMove = Math.min(1, dt * 8)
-    const kRun = Math.min(1, dt * 6)
-    const kCrouch = Math.min(1, dt * 7)
-
+    const targetMove = this.isMoving ? 1 : 0
+    const kMove = Math.min(1, dt * 20)
     this._moveBlend += (targetMove - this._moveBlend) * kMove
-    this._runBlend += (targetRun - this._runBlend) * kRun
-    this._crouchBlend += (targetCrouch - this._crouchBlend) * kCrouch
 
-    const moveBlend = clamp01(this._moveBlend)
-    const runBlend = clamp01(this._runBlend)
-    const crouchBlend = clamp01(this._crouchBlend)
+    const speed = this.isRunning ? 10 : 8
+    this._phase += dt * speed * this._moveBlend
 
-    const baseSpeed = mix(8, 10, runBlend)
-    const crouchSpeedMul = mix(1, 0.55, crouchBlend)
-    const speed = baseSpeed * crouchSpeedMul
+    const t = this._phase + (this.isRunning ? Math.PI * 0.5 : 0)
+    let reset = false
 
-    this._phase += dt * speed * moveBlend
-    this._idlePhase += dt * 1.15
+    applyCrouchPose(player, this.isCrouched ? 1 : 0)
 
-    const t = this._phase + (runBlend > 0.5 ? Math.PI * 0.5 : 0)
-
-    if (this.switchAnimationCallback) {
-      const boundary = Math.abs(Math.sin(t))
-      if (boundary < 0.02) {
-        const cb = this.switchAnimationCallback
-        this.switchAnimationCallback = null
-        cb?.()
+    const boundary = this.isRunning ? Math.cos(t) : Math.sin(t)
+    if (Math.abs(boundary) < 0.02) {
+      if (this.switchAnimationCallback) {
+        reset = true
       }
     }
 
-    applyCrouchPose(player, crouchBlend)
-
-    const maxYaw = (80 * Math.PI) / 180
-    const maxPitch = (75 * Math.PI) / 180
-    const targetLookYaw = clamp(wrapPi(this.lookYaw || 0), -maxYaw, maxYaw)
-    const targetLookPitch = clamp(this.lookPitch || 0, -maxPitch, maxPitch)
-
-    const kLook = Math.min(1, dt * 14)
-    this._lookYawBlend += (targetLookYaw - this._lookYawBlend) * kLook
-    this._lookPitchBlend += (targetLookPitch - this._lookPitchBlend) * kLook
-
-    if (player?.skin?.head?.rotation) {
-      player.skin.head.rotation.y += this._lookYawBlend
-      player.skin.head.rotation.x += this._lookPitchBlend
+    if (this.isRunning) {
+      player.skin.leftLeg.rotation.x = Math.cos(t + Math.PI) * 1.3
+      player.skin.rightLeg.rotation.x = Math.cos(t) * 1.3
+    } else {
+      player.skin.leftLeg.rotation.x = Math.sin(t) * 0.5
+      player.skin.rightLeg.rotation.x = Math.sin(t + Math.PI) * 0.5
     }
 
-    const idleStrength = (1 - moveBlend) * (1 - 0.25 * runBlend)
-    if (idleStrength > 0.0001 && player?.skin) {
-      const b = Math.sin(this._idlePhase)
-      player.skin.body.rotation.x += b * 0.02 * idleStrength
-      player.skin.head.rotation.x += -b * 0.015 * idleStrength
-      player.skin.leftArm.rotation.x += b * 0.03 * idleStrength
-      player.skin.rightArm.rotation.x += -b * 0.03 * idleStrength
-      if (player?.cape?.rotation) player.cape.rotation.x += Math.sin(this._idlePhase * 0.7) * 0.03 * idleStrength
-    }
-
-    if (moveBlend > 0.0001 && player?.skin) {
-      const legAmp = mix(1, 0.85, crouchBlend)
-      const armAmp = mix(1, 0.7, crouchBlend)
-
-      const walkLegL = Math.sin(t) * 0.5
-      const walkLegR = Math.sin(t + Math.PI) * 0.5
-      const runLegL = Math.cos(t + Math.PI) * 1.3
-      const runLegR = Math.cos(t) * 1.3
-
-      player.skin.leftLeg.rotation.x += mix(walkLegL, runLegL, runBlend) * moveBlend * legAmp
-      player.skin.rightLeg.rotation.x += mix(walkLegR, runLegR, runBlend) * moveBlend * legAmp
-
-      const walkArmL = Math.sin(t + Math.PI) * 0.5
-      const walkArmR = Math.sin(t) * 0.5
-      const runArmL = Math.cos(t) * 1.5
-      const runArmR = Math.cos(t + Math.PI) * 1.5
-
-      player.skin.leftArm.rotation.x += mix(walkArmL, runArmL, runBlend) * moveBlend * armAmp
-      player.skin.rightArm.rotation.x += mix(walkArmR, runArmR, runBlend) * moveBlend * armAmp
-
-      const walkArmZBase = Math.PI * 0.02
-      const runArmZBase = Math.PI * 0.1
-      const armZBase = mix(walkArmZBase, runArmZBase, runBlend)
+    if (this.isRunning) {
+      player.skin.leftArm.rotation.x = Math.cos(t) * 1.5
+      player.skin.rightArm.rotation.x = Math.cos(t + Math.PI) * 1.5
 
-      const walkArmZL = Math.cos(t) * 0.03 + walkArmZBase
-      const walkArmZR = Math.cos(t + Math.PI) * 0.03 - walkArmZBase
-      const runArmZL = Math.cos(t) * 0.1 + runArmZBase
-      const runArmZR = Math.cos(t + Math.PI) * 0.1 - runArmZBase
+      const basicArmRotationZ = Math.PI * 0.1
+      player.skin.leftArm.rotation.z = Math.cos(t) * 0.1 + basicArmRotationZ
+      player.skin.rightArm.rotation.z = Math.cos(t + Math.PI) * 0.1 - basicArmRotationZ
+    } else {
+      player.skin.leftArm.rotation.x = Math.sin(t + Math.PI) * 0.5
+      player.skin.rightArm.rotation.x = Math.sin(t) * 0.5
 
-      player.skin.leftArm.rotation.z += (mix(walkArmZL, runArmZL, runBlend) * moveBlend + armZBase * 0.15 * moveBlend) * armAmp
-      player.skin.rightArm.rotation.z += (mix(walkArmZR, runArmZR, runBlend) * moveBlend - armZBase * 0.15 * moveBlend) * armAmp
-      
-      if (this._defaults?.playerRot) {
-        player.rotation.z = this._defaults.playerRot.z + Math.cos(t + Math.PI) * 0.01 * runBlend * moveBlend
-      }
-
-      const capeBase = mix(Math.PI * 0.06, Math.PI * 0.3, runBlend)
-      const capeWave = mix(Math.sin(t / 1.5) * 0.06, Math.sin(t * 2) * 0.1, runBlend)
-      if (player?.cape?.rotation) player.cape.rotation.x += (capeBase + capeWave) * moveBlend
+      const basicArmRotationZ = Math.PI * 0.02
+      player.skin.leftArm.rotation.z = Math.cos(t) * 0.03 + basicArmRotationZ
+      player.skin.rightArm.rotation.z = Math.cos(t + Math.PI) * 0.03 - basicArmRotationZ
     }
 
     if (this._swingTime !== null) {
       this._swingTime += dt
       const p = Math.min(this._swingTime / this._swingDuration, 1)
-      HitAnimation.animate(p, player, moveBlend > 0.2)
+      HitAnimation.animate(p, player, this.isMoving)
       if (p >= 1) this._swingTime = null
     }
+
+    if (this.isRunning) {
+      player.rotation.z = Math.cos(t + Math.PI) * 0.01
+    }
+
+    if (this.isRunning) {
+      const basicCapeRotationX = Math.PI * 0.3
+      player.cape.rotation.x = Math.sin(t * 2) * 0.1 + basicCapeRotationX
+    } else {
+      const basicCapeRotationX = Math.PI * 0.06
+      player.cape.rotation.x = Math.sin(t / 1.5) * 0.06 + basicCapeRotationX
+    }
+
+    if (reset) {
+      const cb = this.switchAnimationCallback
+      this.switchAnimationCallback = null
+      cb?.()
+    }
   }
 }
 
@@ -289,11 +201,6 @@ const HitAnimation = {
   animate(progress, player, isMovingOrRunning) {
     if (!player?.skin?.rightArm?.rotation) return
 
-    // One swing = one arc. `swing` rises to its peak at the middle of the swing
-    // (progress 0.5) and returns to rest at both ends, matching vanilla's
-    // `sin(swingProgress * PI)` and the first-person hand. Driving the trig with
-    // `progress * 18` previously ran ~3 sine cycles per click, which made other
-    // players' arms look like they were swinging several times per hit.
     const swing = Math.sin(progress * Math.PI)
     player.skin.rightArm.rotation.x = -0.4537860552 * 2 - 2 * swing * 0.3
 
@@ -354,4 +261,4 @@ function applyCrouchPose(player, crouchBlend) {
 
   skin.rightLeg.position.z += -3.4500310377 * s
   skin.leftLeg.position.z += -3.4500310377 * s
-}
+}