feat: drop items and srint

Author: r1tsuu

apps/client/src/app/play-controller.ts

@@ -44,6 +44,7 @@ import { buildPlayHud } from '../ui/hud.ts'
 import { createDefaultClientSettings } from './client-settings.ts'
 
 const FIXED_TIMESTEP = 1 / 60
+const DROP_STACK_THRESHOLD_SECONDS = 0.4
 const FIRST_PERSON_SWING_DURATION = 0.18
 const DEBUG_MEMORY_REFRESH_INTERVAL_SECONDS = 0.25
 
@@ -99,6 +100,8 @@ export class PlayController {
   private nextDebugMemoryRefreshTime = 0
   private predictedInventory: InventorySnapshot | null = null
   private breakState: BreakState | null = null
+  private dropHeldSeconds = 0
+  private droppedStackThisTap = false
 
   public constructor(private readonly deps: PlayControllerDeps) {}
 
@@ -129,6 +132,8 @@ export class PlayController {
     this.pauseScreen = 'closed'
     this.firstPersonSwingRemaining = 0
     this.breakState = null
+    this.dropHeldSeconds = 0
+    this.droppedStackThisTap = false
   }
 
   public async tick(context: PlayTickContext): Promise<PlayTickResult> {
@@ -294,6 +299,8 @@ export class PlayController {
       })
     ) {
       this.breakState = null
+      this.dropHeldSeconds = 0
+      this.droppedStackThisTap = false
       return null
     }
 
@@ -311,6 +318,33 @@ export class PlayController {
       adapter.eventBus.send({ type: 'selectInventorySlot', payload: { slot: next } })
     }
 
+    if (input.dropItemHeld) {
+      this.dropHeldSeconds += deltaSeconds
+    } else {
+      this.dropHeldSeconds = 0
+      this.droppedStackThisTap = false
+    }
+
+    const dropSlot = worldRuntime.inventory.selectedSlot
+    const dropSlotData = getSelectedInventorySlot(worldRuntime.inventory)
+
+    if (input.dropItemPressed && dropSlotData.count > 0) {
+      adapter.eventBus.send({ type: 'dropItem', payload: { slot: dropSlot, count: 1 } })
+    }
+
+    if (
+      input.dropItemHeld &&
+      !this.droppedStackThisTap &&
+      this.dropHeldSeconds >= DROP_STACK_THRESHOLD_SECONDS &&
+      dropSlotData.count > 1
+    ) {
+      adapter.eventBus.send({
+        type: 'dropItem',
+        payload: { slot: dropSlot, count: dropSlotData.count - 1 },
+      })
+      this.droppedStackThisTap = true
+    }
+
     void worldRuntime.requestChunksAroundPosition(
       this.deps.player.state.position,
       this.deps.getClientSettings().renderDistance,

apps/client/src/game/fixed-step-input.ts

@@ -5,26 +5,37 @@ export interface PendingFixedStepInputEdges {
   placeBlockPressed: boolean
   hotbarSelection: number | null
   hotbarScrollDelta: number
+  dropItemPressed: boolean
+  dropItemHeld: boolean
 }
 
 export const createPendingFixedStepInputEdges = (): PendingFixedStepInputEdges => ({
   breakBlockPressed: false,
   placeBlockPressed: false,
   hotbarSelection: null,
   hotbarScrollDelta: 0,
+  dropItemPressed: false,
+  dropItemHeld: false,
 })
 
 export const queueFixedStepInputEdges = (
   pending: PendingFixedStepInputEdges,
   input: Pick<
     InputState,
-    'breakBlockPressed' | 'placeBlockPressed' | 'hotbarSelection' | 'hotbarScrollDelta'
+    | 'breakBlockPressed'
+    | 'placeBlockPressed'
+    | 'hotbarSelection'
+    | 'hotbarScrollDelta'
+    | 'dropItemPressed'
+    | 'dropItemHeld'
   >,
 ): PendingFixedStepInputEdges => ({
   breakBlockPressed: pending.breakBlockPressed || input.breakBlockPressed,
   placeBlockPressed: pending.placeBlockPressed || input.placeBlockPressed,
   hotbarSelection: input.hotbarSelection ?? pending.hotbarSelection,
   hotbarScrollDelta: pending.hotbarScrollDelta + input.hotbarScrollDelta,
+  dropItemPressed: pending.dropItemPressed || input.dropItemPressed,
+  dropItemHeld: pending.dropItemHeld || input.dropItemHeld,
 })
 
 export const applyFixedStepInputEdges = (
@@ -36,4 +47,6 @@ export const applyFixedStepInputEdges = (
   placeBlockPressed: pending.placeBlockPressed || input.placeBlockPressed,
   hotbarSelection: pending.hotbarSelection ?? input.hotbarSelection,
   hotbarScrollDelta: pending.hotbarScrollDelta + input.hotbarScrollDelta,
+  dropItemPressed: pending.dropItemPressed || input.dropItemPressed,
+  dropItemHeld: pending.dropItemHeld || input.dropItemHeld,
 })

apps/client/src/game/player.ts

@@ -20,6 +20,7 @@ import type { ClientSettings, InputState } from '../types.ts'
 
 const WORLD_UP = vec3(0, 1, 0)
 const MOVE_SPEED = 4.75
+const SPRINT_SPEED = 6.18
 const JUMP_VELOCITY = 7.5
 const GRAVITY = 24
 const BASE_MOUSE_SENSITIVITY = 0.0025
@@ -41,10 +42,13 @@ export class PlayerController {
   private grounded = false
   private previousJumpDown = false
   private timeSinceJumpPress = Number.POSITIVE_INFINITY
+  private previousForwardDown = false
+  private timeSinceForwardPress = Number.POSITIVE_INFINITY
   private fovDegrees = DEFAULT_FOV_DEGREES
   private mouseSensitivityPercent = 100
   public gamemode: PlayerGamemode = 0
   public flying = false
+  public sprinting = false
 
   public state: PlayerState = {
     position: [0, 10, 0],
@@ -120,6 +124,7 @@ export class PlayerController {
 
   public update(input: InputState, deltaSeconds: number, world: VoxelWorld): void {
     this.timeSinceJumpPress += deltaSeconds
+    this.timeSinceForwardPress += deltaSeconds
     const jumpPressed = input.moveUp && !this.previousJumpDown
     if (this.gamemode === 1 && jumpPressed) {
       if (this.timeSinceJumpPress <= DOUBLE_TAP_WINDOW_SECONDS) {
@@ -135,9 +140,23 @@ export class PlayerController {
     if (this.flying) {
       this.updateFlying(input, deltaSeconds, world)
       this.previousJumpDown = input.moveUp
+      this.previousForwardDown = input.moveForward
+      this.sprinting = false
       return
     }
 
+    const forwardPressed = input.moveForward && !this.previousForwardDown
+    if (forwardPressed) {
+      if (this.timeSinceForwardPress <= DOUBLE_TAP_WINDOW_SECONDS) {
+        this.sprinting = true
+      }
+      this.timeSinceForwardPress = 0
+    }
+    if (!input.moveForward) {
+      this.sprinting = false
+    }
+    this.previousForwardDown = input.moveForward
+
     const forward = this.getWalkForwardVector()
     const right = normalizeVec3(crossVec3(forward, WORLD_UP))
     let movement = vec3()
@@ -158,8 +177,9 @@ export class PlayerController {
 
     this.verticalVelocity -= GRAVITY * deltaSeconds
 
-    position = this.moveAxis(world, position, 'x', normalized.x * MOVE_SPEED * deltaSeconds)
-    position = this.moveAxis(world, position, 'z', normalized.z * MOVE_SPEED * deltaSeconds)
+    const speed = this.sprinting ? SPRINT_SPEED : MOVE_SPEED
+    position = this.moveAxis(world, position, 'x', normalized.x * speed * deltaSeconds)
+    position = this.moveAxis(world, position, 'z', normalized.z * speed * deltaSeconds)
 
     const beforeVertical = position.y
     position = this.moveAxis(world, position, 'y', this.verticalVelocity * deltaSeconds)

apps/client/src/platform/native.ts

@@ -137,6 +137,7 @@ const library = dlopen(libraryPath, {
 
 const GLFW_KEY_W = 87
 const GLFW_KEY_E = 69
+const GLFW_KEY_Q = 81
 const GLFW_KEY_A = 65
 const GLFW_KEY_S = 83
 const GLFW_KEY_D = 68
@@ -303,6 +304,8 @@ export class NativeBridge {
       enterPressed: Boolean(library.symbols.bridge_consume_key_press(GLFW_KEY_ENTER)),
       tabPressed: Boolean(library.symbols.bridge_consume_key_press(GLFW_KEY_TAB)),
       inventoryToggle: Boolean(library.symbols.bridge_consume_key_press(GLFW_KEY_E)),
+      dropItemPressed: Boolean(library.symbols.bridge_consume_key_press(GLFW_KEY_Q)),
+      dropItemHeld: Boolean(library.symbols.bridge_is_key_down(GLFW_KEY_Q)),
       hotbarSelection,
       hotbarScrollDelta: library.symbols.bridge_consume_scroll_y() as number,
       windowWidth,

apps/client/src/types.ts

@@ -28,6 +28,8 @@ export interface InputState {
   inventoryToggle: boolean
   hotbarSelection: number | null
   hotbarScrollDelta: number
+  dropItemPressed: boolean
+  dropItemHeld: boolean
   windowWidth: number
   windowHeight: number
   framebufferWidth: number

packages/core/src/server/authoritative-world.ts

@@ -28,6 +28,7 @@ import {
   STARTUP_CHUNK_RADIUS,
   WORLD_SEA_LEVEL,
 } from '../world/constants.ts'
+import { getInventorySlot } from '../world/inventory.ts'
 import { getPlacedBlockIdForItem, isValidItemId } from '../world/items.ts'
 import { createGeneratedChunk, getTerrainHeight } from '../world/terrain.ts'
 import { worldToChunkCoord } from '../world/world.ts'
@@ -63,6 +64,12 @@ export interface WorldSimulationResult {
   inventoryUpdates: WorldInventoryUpdate[]
 }
 
+export interface DropItemResult {
+  inventory: InventorySnapshot
+  inventoryChanged: boolean
+  droppedItems: DroppedItemSimulationResult
+}
+
 export interface StartupAreaProgress {
   completedChunks: number
   totalChunks: number
@@ -300,6 +307,40 @@ export class AuthoritativeWorld {
     return { added: result.added, remaining: result.remaining, inventory: result.inventory }
   }
 
+  public async dropItem(
+    entityId: EntityId,
+    slot: number,
+    count: number,
+  ): Promise<DropItemResult> {
+    await this.ensureInitialized()
+    const inventory = this.playerSystem.getInventorySnapshot(entityId)
+    const slotData = getInventorySlot(inventory, slot)
+    if (slotData.count <= 0) {
+      return {
+        inventory,
+        inventoryChanged: false,
+        droppedItems: { spawned: [], updated: [], removed: [], inventoryUpdates: [] },
+      }
+    }
+
+    const dropCount = Math.min(Math.max(1, Math.trunc(count)), slotData.count)
+    const mutResult = this.playerSystem.removeInventorySlot(entityId, slot, dropCount)
+    const playerSnapshot = this.playerSystem.getPlayerSnapshot(entityId)
+    const PLAYER_EYE_HEIGHT = 1.62
+    const eyePosition: [number, number, number] = [
+      playerSnapshot.state.position[0],
+      playerSnapshot.state.position[1] + PLAYER_EYE_HEIGHT,
+      playerSnapshot.state.position[2],
+    ]
+    const droppedItems = await this.droppedItemSystem.spawnPlayerDrop(
+      slotData.itemId,
+      dropCount,
+      eyePosition,
+      playerSnapshot.state.yaw,
+    )
+    return { inventory: mutResult.inventory, inventoryChanged: mutResult.inventoryChanged, droppedItems }
+  }
+
   public getWorldTimeState(): WorldTimeState {
     return this.lightingSystem.getTimeState()
   }
@@ -486,6 +527,14 @@ export class AuthoritativeWorld {
           )
           break
         }
+        case 'dropItem': {
+          const dropped = await this.dropItem(intent.playerEntityId, intent.slot, intent.count)
+          if (dropped.inventoryChanged) {
+            this.mergeInventoryUpdate(result, intent.playerEntityId, dropped.inventory)
+          }
+          this.mergeSimulationResult(result, this.toWorldSimulationResult(dropped.droppedItems))
+          break
+        }
       }
     }
 

packages/core/src/server/dropped-item-system.ts

@@ -17,6 +17,7 @@ const GRAVITY = 16
 const PICKUP_RADIUS = 1.35
 const PICKUP_RADIUS_SQUARED = PICKUP_RADIUS * PICKUP_RADIUS
 const PICKUP_COOLDOWN_MS = 250
+const PLAYER_DROP_PICKUP_COOLDOWN_MS = 2000
 const ITEM_HALF_EXTENT = 0.18
 const GROUND_FRICTION = 0.82
 const AIR_DRAG = 0.98
@@ -84,6 +85,37 @@ export class DroppedItemSystem {
     }
   }
 
+  public async spawnPlayerDrop(
+    itemId: ItemId,
+    count: number,
+    position: readonly [number, number, number],
+    yaw: number,
+  ): Promise<DroppedItemSimulationResult> {
+    await this.ensureLoaded()
+    const THROW_HORIZONTAL = 4.5
+    const THROW_VERTICAL = 1.0
+    const entityId = this.entities.registry.createEntity('drop')
+    const spawnPosition: [number, number, number] = [position[0], position[1], position[2]]
+    const velocity: [number, number, number] = [
+      Math.cos(yaw) * THROW_HORIZONTAL,
+      THROW_VERTICAL,
+      Math.sin(yaw) * THROW_HORIZONTAL,
+    ]
+    this.entities.droppedItemTransform.set(entityId, { position: spawnPosition, velocity })
+    this.entities.droppedItemStack.set(entityId, {
+      itemId,
+      count: Math.max(1, Math.trunc(count)),
+    })
+    this.entities.droppedItemLifecycle.set(entityId, { pickupCooldownMs: PLAYER_DROP_PICKUP_COOLDOWN_MS })
+    this.addToChunkIndex(entityId, spawnPosition)
+    const item = this.getSnapshot(entityId)
+    this.saveDirty = true
+    return {
+      ...emptySimulationResult(),
+      spawned: [item],
+    }
+  }
+
   public async update(
     deltaSeconds: number,
     players: readonly PlayerSnapshot[],

packages/core/src/server/player-system.ts

@@ -16,6 +16,7 @@ import {
   interactInventorySlot,
   normalizeInventorySnapshot,
   removeFromSelectedInventorySlot,
+  removeInventorySlotCount,
   setSelectedInventorySlot,
 } from '../world/inventory.ts'
 import { type WorldEntityState } from './world-entity-state.ts'
@@ -331,6 +332,31 @@ export class PlayerSystem {
     }
   }
 
+  public removeInventorySlot(
+    entityId: EntityId,
+    slot: number,
+    count: number,
+  ): InventoryMutationResult {
+    const inventory = this.requireComponent(
+      this.entities.playerInventory,
+      entityId,
+      'player inventory',
+    )
+    const persistence = this.requireComponent(
+      this.entities.playerPersistence,
+      entityId,
+      'player persistence',
+    )
+    const next = removeInventorySlotCount(inventory.inventory, slot, count)
+    if (inventoriesEqual(next, inventory.inventory)) {
+      return { inventory: this.cloneInventory(inventory.inventory), inventoryChanged: false }
+    }
+
+    this.entities.playerInventory.set(entityId, { inventory: next })
+    this.entities.playerPersistence.set(entityId, { ...persistence, saveDirty: true })
+    return { inventory: this.cloneInventory(next), inventoryChanged: true }
+  }
+
   public getSelectedInventorySlot(entityId: EntityId) {
     return getSelectedInventorySlot(
       this.requireComponent(this.entities.playerInventory, entityId, 'player inventory').inventory,

packages/core/src/server/world-session-controller.ts

@@ -18,6 +18,7 @@ type QueuedGameplayIntentInput =
   | Omit<Extract<QueuedGameplayIntent, { kind: 'selectInventorySlot' }>, 'sequence'>
   | Omit<Extract<QueuedGameplayIntent, { kind: 'interactInventorySlot' }>, 'sequence'>
   | Omit<Extract<QueuedGameplayIntent, { kind: 'updatePlayerState' }>, 'sequence'>
+  | Omit<Extract<QueuedGameplayIntent, { kind: 'dropItem' }>, 'sequence'>
 
 export interface WorldSessionPeer {
   sendEvent<K extends keyof ServerEventMap>(message: { type: K; payload: ServerEventMap[K] }): void
@@ -269,6 +270,15 @@ export class WorldSessionController implements WorldSessionPeer {
           flying,
         })
       }),
+      this.adapter.eventBus.on('dropItem', ({ slot, count }) => {
+        this.requireWorld('dropping item')
+        this.enqueueIntent({
+          kind: 'dropItem',
+          playerEntityId: this.requireCurrentPlayerEntityId(),
+          slot,
+          count,
+        })
+      }),
       this.adapter.eventBus.on('submitChat', async ({ text }) => {
         const world = this.requireWorld('chatting')
         const playerEntityId = this.requireCurrentPlayerEntityId()