feat: add crafting-table block entities

Add a reusable server-side block-entity system and wire crafting tables through the authoritative use-block path.

Persist crafting-table entities, add dedicated crafting-table textures and atlas tiles, and cover the new behavior with tests and follow-up plans.

Co-authored-by: Codex <codex@openai.com>

Author: r1tsuu

ARCHITECTURE.md

@@ -165,8 +165,12 @@ World-level entity state:
 - One `EntityRegistry` for actor ids in the active world.
 - Component stores for player identity, transform, mode, movement, inventory, session presence, and persistence.
 - Component stores for dropped-item transform, stack contents, and pickup cooldown.
+- Component stores for block-entity type and block position, with a dedicated
+  `BlockEntitySystem` owning entity-backed blocks such as crafting tables.
 
 Chunks are not entities — chunk data stays coordinate-addressed. World generation, chunk persistence, and chunk resend decisions stay in `AuthoritativeWorld`.
+Interactive blocks still live in chunk voxel data for placement/breaking, but their
+server-owned state, use handling, and future per-tick simulation live in the block-entity layer.
 
 #### World entry warmup
 
@@ -179,6 +183,7 @@ Chunks are not entities — chunk data stays coordinate-addressed. World generat
 - Chunk generation on demand.
 - Draining queued gameplay intents on the authoritative tick boundary.
 - Simulating dropped items and other world systems once per authoritative tick.
+- Simulating block entities once per authoritative tick, including future furnace/chest/door behavior.
 - Batching replication after each tick so clients observe coherent world-state updates.
 - Validating and applying block mutations.
 - Handling chat-driven commands such as `/gamemode` and `/timeset`.

README.md

@@ -165,6 +165,7 @@ The authoritative server autosaves periodically; successful autosaves are printe
 
 - First-person movement with grounded collision, jump physics, and creative flight toggled by double-tapping `Space`
 - Server-authoritative block breaking, placing, inventory mutation, dropped-item spawning, and pickups
+- Entity-backed crafting table blocks with server-side interaction handling and a reusable block-entity foundation for future interactive blocks
 - Authoritative fixed-step world tick loop for both local worker and dedicated server modes
 - Periodic server-side autosave on the authoritative tick loop, plus manual `/save` while in-game
 - Per-player position, rotation, gamemode, and inventory persistence inside each world
@@ -234,7 +235,7 @@ Content authoring and the asset pipeline are documented in [`ARCHITECTURE.md`](.
 ## Possible Future Work
 
 - Survival systems: health, fall damage, death/respawn, hunger, and healing
-- Crafting flows: player crafting and a crafting table
+- Crafting flows: player `2x2` crafting, crafting-table `3x3` recipes, and result-slot UX
 - Tool progression with mining tiers, faster harvesting, and block hardness
 - Furnace and smelting mechanics with fuel and ore processing
 - Day/night cycle and stronger atmosphere changes across time of day

apps/cli/src/default-voxel-tile-sources.ts

@@ -195,6 +195,103 @@ const createPlanksPixel = (x: number, y: number): Rgba => {
   return color
 }
 
+const createCraftingTableTopPixel = (x: number, y: number): Rgba => {
+  const border = rgba(88, 61, 34)
+  const woodA = rgba(170, 129, 75)
+  const woodB = rgba(151, 113, 65)
+  const seam = rgba(112, 78, 43)
+  const grid = rgba(69, 48, 28)
+  const highlight = rgba(204, 162, 100)
+
+  if (x === 0 || y === 0 || x === 15 || y === 15) {
+    return border
+  }
+
+  const innerX = x >= 2 && x <= 13
+  const innerY = y >= 2 && y <= 13
+  if (innerX && innerY && (x === 5 || x === 9 || y === 5 || y === 9)) {
+    return grid
+  }
+
+  const cellX = x <= 4 ? 0 : x <= 8 ? 1 : 2
+  const cellY = y <= 4 ? 0 : y <= 8 ? 1 : 2
+  const base = (cellX + cellY) % 2 === 0 ? woodA : woodB
+  let color = base
+
+  if ((x + y) % 5 === 0) {
+    color = tint(color, 8)
+  } else if ((hash2d(x, y, 0x9bcaf1) & 0xf) <= 2) {
+    color = tint(color, -10)
+  }
+
+  if (innerX && innerY && ((x >= 2 && x <= 4) || (x >= 10 && x <= 13))) {
+    color = tint(color, 5)
+  }
+  if (y === 3 || y === 7 || y === 12) {
+    color = seam
+  }
+  if (
+    (x === 3 || x === 7 || x === 12 || y === 3 || y === 7 || y === 12) &&
+    innerX &&
+    innerY
+  ) {
+    color = highlight
+  }
+
+  return color
+}
+
+const createCraftingTableBottomPixel = (x: number, y: number): Rgba => {
+  const base = rgba(120, 88, 50)
+  const groove = rgba(84, 58, 33)
+  if (y % 4 === 0) {
+    return groove
+  }
+
+  let color = tint(base, (Math.floor(y / 4) % 2 === 0 ? 1 : -1) * 10)
+  if ((hash2d(x, y, 0x52ab19) & 0x1f) < 5) {
+    color = tint(color, 8)
+  } else if ((x === 2 || x === 13) && y > 1 && y < 14) {
+    color = tint(color, -12)
+  }
+  return color
+}
+
+const createCraftingTableSidePixel = (x: number, y: number): Rgba => {
+  const frame = rgba(91, 62, 37)
+  const panel = rgba(146, 107, 63)
+  const shadow = rgba(106, 74, 44)
+  const strap = rgba(63, 44, 28)
+  const accent = rgba(184, 145, 84)
+
+  if (x === 0 || y === 0 || x === 15 || y === 15) {
+    return frame
+  }
+
+  if (x === 3 || x === 12 || y === 3 || y === 12) {
+    return shadow
+  }
+
+  if ((x === 7 || x === 8) && y >= 4 && y <= 11) {
+    return strap
+  }
+
+  let color = panel
+  if ((hash2d(x, y, 0x1f4ca2) & 0xf) <= 2) {
+    color = tint(color, 10)
+  } else if (((x + y) & 0x3) === 0) {
+    color = tint(color, -8)
+  }
+
+  const inLeftPanel = x >= 4 && x <= 6 && y >= 4 && y <= 11
+  const inRightPanel = x >= 9 && x <= 11 && y >= 4 && y <= 11
+  if ((inLeftPanel || inRightPanel) && (x === 5 || x === 10 || y === 5 || y === 10)) {
+    color = accent
+  }
+
+  return color
+}
+
 const createCobblestonePixel = (x: number, y: number): Rgba => {
   const MORTAR = rgba(75, 75, 77)
   const COLS = 3,
@@ -373,6 +470,9 @@ const DEFAULT_TILE_PIXEL_FACTORIES: Record<AtlasTileId, (x: number, y: number) =
   'diamond-ore': createDiamondOrePixel,
   arm: createArmPixel,
   glass: createGlassPixel,
+  'crafting-table-top': createCraftingTableTopPixel,
+  'crafting-table-bottom': createCraftingTableBottomPixel,
+  'crafting-table-side': createCraftingTableSidePixel,
 }
 
 export const buildDefaultVoxelTilePixels = (tileId: AtlasTileId): Uint8Array => {

apps/client/assets/textures/tiles-src/crafting-table-bottom.png

@@ -421,6 +421,15 @@ export class PlayController {
     }
 
     if (hit && input.placeBlockPressed) {
+      const targetedBlockId = worldRuntime.world.getBlock(hit.hit.x, hit.hit.y, hit.hit.z)
+      if (targetedBlockId === BLOCK_IDS.craftingTable) {
+        adapter.eventBus.send({
+          type: 'useBlock',
+          payload: { x: hit.hit.x, y: hit.hit.y, z: hit.hit.z },
+        })
+        return null
+      }
+
       const selectedSlot = getSelectedInventorySlot(worldRuntime.inventory)
       const placedBlockId = getPlacedBlockIdForItem(selectedSlot.itemId)
       if (selectedSlot.count <= 0 || placedBlockId === null) {

apps/client/assets/textures/tiles-src/crafting-table-side.png

@@ -32,6 +32,7 @@ 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'
+import { BlockEntitySystem } from './block-entity-system.ts'
 import { type DroppedItemSimulationResult, DroppedItemSystem } from './dropped-item-system.ts'
 import { LightingSystem } from './lighting-system.ts'
 import { PlayerSystem } from './player-system.ts'
@@ -128,6 +129,7 @@ export class AuthoritativeWorld {
   private readonly chunks = new Map<string, ServerChunkEntry>()
   private readonly entityState = new WorldEntityState()
   private readonly playerSystem: PlayerSystem
+  private readonly blockEntitySystem: BlockEntitySystem
   private readonly droppedItemSystem: DroppedItemSystem
   private readonly lightingSystem = new LightingSystem()
   private readonly initialization: Promise<void>
@@ -144,6 +146,16 @@ export class AuthoritativeWorld {
       this.entityState,
       options?.createInventory,
     )
+    this.blockEntitySystem = new BlockEntitySystem(
+      this.world.name,
+      this.storage,
+      this.entityState,
+      {
+        getWorld: () => this,
+        getActivePlayers: () => this.playerSystem.getActivePlayers(),
+        getPlayerSnapshot: (entityId) => this.getPlayerSnapshot(entityId),
+      },
+    )
     this.droppedItemSystem = new DroppedItemSystem(
       this.world.name,
       this.storage,
@@ -166,6 +178,18 @@ export class AuthoritativeWorld {
     return this.playerSystem.getPlayerName(entityId)
   }
 
+  public getPlayerSnapshot(entityId: EntityId): PlayerSnapshot | null {
+    if (!this.entityState.hasPlayerEntity(entityId)) {
+      return null
+    }
+
+    return this.playerSystem.getPlayerSnapshot(entityId)
+  }
+
+  public getActivePlayers(): PlayerSnapshot[] {
+    return this.playerSystem.getActivePlayers()
+  }
+
   public async joinPlayer(playerName: PlayerName): Promise<{
     clientPlayer: PlayerSnapshot
     players: PlayerSnapshot[]
@@ -294,6 +318,16 @@ export class AuthoritativeWorld {
     return this.playerSystem.interactInventorySlot(entityId, slot)
   }
 
+  public async useBlock(
+    entityId: EntityId,
+    worldX: number,
+    worldY: number,
+    worldZ: number,
+  ): Promise<void> {
+    await this.ensureInitialized()
+    await this.blockEntitySystem.useBlock(entityId, worldX, worldY, worldZ)
+  }
+
   public async givePlayerItem(
     entityId: EntityId,
     itemId: ItemId,
@@ -447,6 +481,7 @@ export class AuthoritativeWorld {
     entry.chunk.set(coords.local.x, coords.local.y, coords.local.z, blockId)
     entry.chunk.revision += 1
     entry.saveDirty = true
+    await this.blockEntitySystem.syncBlock(worldX, worldY, worldZ, blockId)
 
     const lightingChanged = this.relightMutationAffectedChunks(
       coords.chunk,
@@ -475,6 +510,7 @@ export class AuthoritativeWorld {
     await this.ensureInitialized()
     const savedChunks = await this.flushDirtyChunks(false)
     await this.playerSystem.save()
+    await this.blockEntitySystem.save()
     await this.droppedItemSystem.save()
     await this.storage.saveWorldTime(this.world.name, this.lightingSystem.getTimeState())
     this.world = await this.storage.touchWorld(this.world.name, Date.now())
@@ -512,6 +548,11 @@ export class AuthoritativeWorld {
           )
           break
         }
+        case 'useBlock': {
+          await this.useBlock(intent.playerEntityId, intent.x, intent.y, intent.z)
+          this.drainBlockEntityMessages(result)
+          break
+        }
         case 'interactInventorySlot': {
           this.mergeInventoryUpdate(
             result,
@@ -538,6 +579,8 @@ export class AuthoritativeWorld {
       }
     }
 
+    await this.blockEntitySystem.tick(deltaSeconds)
+    this.drainBlockEntityMessages(result)
     this.mergeSimulationResult(result, await this.stepSimulation(deltaSeconds))
     result.worldTime = this.lightingSystem.advanceTime(Math.max(1, Math.round(deltaSeconds * 20)))
     return result
@@ -712,6 +755,10 @@ export class AuthoritativeWorld {
     result.playerUpdates.push(player)
   }
 
+  private drainBlockEntityMessages(result: WorldTickResult): void {
+    result.chatMessages.push(...this.blockEntitySystem.drainChatMessages())
+  }
+
   private mergeSimulationResult(result: WorldTickResult, simulation: WorldSimulationResult): void {
     for (const update of simulation.inventoryUpdates) {
       this.mergeInventoryUpdate(result, update.playerEntityId, update.inventory)