fix: drive eating indication from a real use session

src/controls.ts

@@ -31,6 +31,7 @@
 import { tabListState } from './react/PlayerListOverlayProvider'
 import { type ActionType, type ActionHoldConfig, type CustomAction } from './appConfig'
 import { playerState } from './mineflayer/playerState'
+import { shouldBlockSprint, shouldSlowWhileUsing } from './mineflayer/movementWhileUsing'
 import { setTalking, toggleTalking } from './voice/voiceChat'
 import { voiceChatStatus } from './react/VoiceMicrophone'
 import { emulateMouseClick } from './app/gamepadCursor'
@@ -144,11 +145,139 @@
 subscribe(activeModalStack, updateDoPreventDefault)
 updateDoPreventDefault()
 
+type MovementControl = 'forward' | 'back' | 'left' | 'right'
+const movementControls = ['forward', 'back', 'left', 'right'] as const satisfies readonly MovementControl[]
+const movementPulsePeriodTicks = 5
+const movementPulseIntervalMs = 50
+const desiredMovementState: Record<MovementControl, boolean> = {
+  forward: false,
+  back: false,
+  left: false,
+  right: false,
+}
+let movementPulsePhase = 0
+let movementPulseTimer: number | undefined
+let movementGuardsBot: typeof bot | undefined
+let removeMovementUseSubscription: (() => void) | undefined
+
+const forceSprintOff = () => {
+  if (!bot) return
+  bot.setControlState('sprint', false)
+  gameAdditionalState.isSprinting = false
+}
+
 const setSprinting = (state: boolean) => {
+  if (state && shouldBlockSprint(playerState.reactive?.itemUseSession)) {
+    forceSprintOff()
+    return
+  }
   bot.setControlState('sprint', state)
   gameAdditionalState.isSprinting = state
 }
 
+const applyMovementControls = () => {
+  if (!bot) return
+
+  const slowInput = shouldSlowWhileUsing(playerState.reactive?.itemUseSession, Boolean(bot.vehicle))
+  const suppressInput = slowInput && movementPulsePhase !== 0
+  for (const key of movementControls) {
+    const nextState = desiredMovementState[key] && !suppressInput
+    if (nextState === Boolean(bot.controlState[key])) continue
+    bot.setControlState(key, nextState)
+  }
+}
+
+const refreshMovementControls = () => {
+  if (!bot) return
+
+  const slowInput = shouldSlowWhileUsing(playerState.reactive?.itemUseSession, Boolean(bot.vehicle))
+  const hasMovementInput = movementControls.some(key => desiredMovementState[key])
+  if (slowInput && hasMovementInput) {
+    if (!movementPulseTimer) {
+      // Mineflayer exposes boolean control states, not LocalPlayer's analog
+      // impulses. One enabled tick followed by four suppressed ticks is the
+      // closest input-stage equivalent to vanilla's * 0.2.
+      movementPulsePhase = 0
+      movementPulseTimer = window.setInterval(() => {
+        const stillSlow = shouldSlowWhileUsing(playerState.reactive?.itemUseSession, Boolean(bot.vehicle))
+        const stillMoving = movementControls.some(key => desiredMovementState[key])
+        if (!stillSlow || !stillMoving) {
+          if (movementPulseTimer) clearInterval(movementPulseTimer)
+          movementPulseTimer = undefined
+          movementPulsePhase = 0
+          applyMovementControls()
+          return
+        }
+        movementPulsePhase = (movementPulsePhase + 1) % movementPulsePeriodTicks
+        applyMovementControls()
+      }, movementPulseIntervalMs)
+    }
+  } else {
+    if (movementPulseTimer) {
+      clearInterval(movementPulseTimer)
+      movementPulseTimer = undefined
+    }
+    movementPulsePhase = 0
+  }
+  applyMovementControls()
+}
+
+const setupMovementUseGuards = () => {
+  if (!bot || movementGuardsBot === bot) return
+
+  removeMovementUseSubscription?.()
+  removeMovementUseSubscription = undefined
+  movementGuardsBot = bot
+  movementControls.forEach(key => {
+    desiredMovementState[key] = false
+  })
+  if (movementPulseTimer) {
+    clearInterval(movementPulseTimer)
+    movementPulseTimer = undefined
+  }
+  movementPulsePhase = 0
+
+  const originalSetControlState = bot.setControlState.bind(bot)
+  bot.setControlState = (control, state) => {
+    if (control === 'sprint' && state && shouldBlockSprint(playerState.reactive?.itemUseSession)) {
+      originalSetControlState('sprint', false)
+      gameAdditionalState.isSprinting = false
+      return
+    }
+    originalSetControlState(control, state)
+    if (control === 'sprint') {
+      gameAdditionalState.isSprinting = state
+    }
+  }
+
+  if (playerState.reactive) {
+    removeMovementUseSubscription = subscribe(playerState.reactive, (ops) => {
+      if (!ops.some(([, path]) => path[0] === 'itemUseSession')) return
+      if (shouldBlockSprint(playerState.reactive?.itemUseSession)) {
+        forceSprintOff()
+      }
+      refreshMovementControls()
+    }, true)
+  }
+
+  if (shouldBlockSprint(playerState.reactive?.itemUseSession)) {
+    forceSprintOff()
+  }
+  refreshMovementControls()
+}
+
+customEvents.on('mineflayerBotCreated', () => {
+  bot.once('inject_allowed', () => {
+    // viewerConnector installs its own setControlState wrapper at inject time;
+    // install this outer guard after that wrapper so pressure/mobile callers
+    // cannot send a sprint=true request around the using-item check.
+    setTimeout(setupMovementUseGuards, 0)
+  })
+})
+customEvents.on('gameLoaded', () => {
+  setTimeout(setupMovementUseGuards, 0)
+})
+
 const isSpectatingEntity = () => {
   return getPlayerStateUtils(playerState.reactive).isSpectatingEntity()
 }
@@ -197,29 +326,27 @@
     ['x', 1, 'right'],
   ] as const
 
-  const newState: Partial<typeof bot.controlState> = {}
+  const newState: Partial<Record<MovementControl, boolean>> = {}
   for (const [coord, v] of Object.entries(vector)) {
     if (v === undefined || Math.abs(v) < 0.3) continue
-    // todo use raw values eg for slow movement
+    // ControMax supplies analog vectors, but mineflayer's controlState is
+    // boolean-only; retain direction here and apply the using-item pulse below.
     const mappedValue = v < 0 ? -1 : 1
-    // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain
-    const foundAction = coordToAction.find(([c, mapV]) => c === coord && mapV === mappedValue)?.[2]!
+    const foundAction = coordToAction.find(([c, mapV]) => c === coord && mapV === mappedValue)?.[2]
+    if (!foundAction) continue
     newState[foundAction] = true
   }
 
-  for (const key of ['forward', 'back', 'left', 'right'] as const) {
-    if (!!(newState[key]) === !!(bot.controlState[key])) continue
+  for (const key of movementControls) {
     const action = !!newState[key]
     if (action && !isGameActive(true)) continue
-    bot.setControlState(key, action)
-
-    if (key === 'forward') {
+    desiredMovementState[key] = action
+    if (key === 'forward' && !action) {
       // todo workaround: need to refactor
-      if (!action) {
-        setSprinting(false)
-      }
+      setSprinting(false)
     }
   }
+  refreshMovementControls()
 })
 
 let lastCommandTrigger = null as { command: string, time: number } | null
@@ -242,6 +369,10 @@
     for (const key of contro.pressedKeys) {
       contro.pressedKeyOrButtonChanged({ code: key }, false)
     }
+    for (const key of movementControls) {
+      desiredMovementState[key] = false
+    }
+    refreshMovementControls()
   }
 })
 

src/mineflayer/movementWhileUsing.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from 'vitest'
+import type { UseItemAction, UseItemSession } from 'minecraft-renderer/src/playerState/types'
+import { shouldBlockSprint, shouldSlowWhileUsing } from './movementWhileUsing'
+
+const makeSession = (action: UseItemAction = 'EAT', status: UseItemSession['status'] = 'active'): UseItemSession => ({
+  id: 1,
+  itemSnapshot: {
+    name: action === 'BOW' ? 'bow' : 'bread',
+    durationTicks: 32,
+    action,
+    particleEffect: action === 'EAT' ? 'food' : 'none',
+  },
+  hand: 0,
+  action,
+  durationTicks: 32,
+  elapsedTicks: 0,
+  status,
+})
+
+describe('movement restrictions while using an item', () => {
+  test('requires an active or awaiting-completion session', () => {
+    expect(shouldSlowWhileUsing(undefined, false)).toBe(false)
+    expect(shouldBlockSprint(undefined)).toBe(false)
+    expect(shouldSlowWhileUsing(makeSession('EAT', 'completed'), false)).toBe(false)
+    expect(shouldBlockSprint(makeSession('EAT', 'cancelled'))).toBe(false)
+    expect(shouldSlowWhileUsing(makeSession('DRINK', 'awaitingCompletion'), false)).toBe(true)
+    expect(shouldBlockSprint(makeSession('EAT', 'active'))).toBe(true)
+  })
+
+  test('matches represented vanilla use actions, including bow draw', () => {
+    for (const action of ['EAT', 'DRINK', 'BOW', 'CROSSBOW', 'SHIELD'] as const) {
+      expect(shouldSlowWhileUsing(makeSession(action), false)).toBe(true)
+      expect(shouldBlockSprint(makeSession(action))).toBe(true)
+    }
+    expect(shouldSlowWhileUsing(makeSession('NONE'), false)).toBe(false)
+    expect(shouldBlockSprint(makeSession('NONE'))).toBe(false)
+  })
+
+  test('mounted players keep normal movement but still cannot sprint while using', () => {
+    const session = makeSession('BOW')
+    expect(shouldSlowWhileUsing(session, true)).toBe(false)
+    expect(shouldBlockSprint(session)).toBe(true)
+  })
+})

src/mineflayer/movementWhileUsing.ts

@@ -0,0 +1,34 @@
+import type { UseItemAction, UseItemSession } from 'minecraft-renderer/src/playerState/types'
+
+/**
+ * These are the use actions represented by the local item-use session. `NONE`
+ * is used for activatable inventory items that do not have a vanilla use
+ * animation; it is not a LocalPlayer.isUsingItem() state and must not apply
+ * the movement restriction.
+ */
+const MOVEMENT_RESTRICTED_USE_ACTIONS: Record<UseItemAction, true | undefined> = {
+  EAT: true,
+  DRINK: true,
+  BOW: true,
+  CROSSBOW: true,
+  SHIELD: true,
+  NONE: undefined,
+}
+
+const isActiveUseSession = (session: UseItemSession | null | undefined): boolean => {
+  if (!session || (session.status !== 'active' && session.status !== 'awaitingCompletion')) {
+    return false
+  }
+  return MOVEMENT_RESTRICTED_USE_ACTIONS[session.action] === true
+}
+
+/** Vanilla's input slow applies to unmounted players while an item is used. */
+export const shouldSlowWhileUsing = (
+  session: UseItemSession | null | undefined,
+  hasVehicle: boolean
+): boolean => !hasVehicle && isActiveUseSession(session)
+
+/** Vanilla sprint eligibility is blocked for every active represented use. */
+export const shouldBlockSprint = (session: UseItemSession | null | undefined): boolean => {
+  return isActiveUseSession(session)
+}