004: full semantic parity — open container fix + eat handshake + click_slot pacing

Three remaining backlog items closed to bring Rust/accel implementation
into full behavioural parity with the Python reference.

1. open_block_container — was sending UseItem (right-click-air); now
   sends BlockPlace (right-click-block / "use_item_on") with the
   block position and a top-face cursor. This is the packet Python
   ref sends and the only one Paper accepts to open chests/furnaces/
   crafting tables.

2. eat — was a fixed 1.6 s sleep; now subscribes to clientbound
   EntityStatus (id 0x1C) via the existing packet-hook mechanism,
   awaits status=9 (player finished using item) matching the bot's
   own entity_id, falls back to `timeout` if the server is slow.
   Mirrors Python ref's async with-EntityStatus-listener pattern.

3. click_slot — was send-and-forget; now waits up to 200 ms for the
   dispatcher to apply the server's SetSlot/WindowItems echo and
   bump state_id. 1.20.1 has no WindowConfirmation packet — the
   state_id field on every click IS the handshake. Pacing rapid
   clicks against the echo prevents Paper anti-cheat desync.

Dispatcher additions to make the above work:
* SetSlot (0x14)        — updates state_id + per-slot
* WindowItems (0x12)    — updates state_id + bulk reload
* OpenWindow (0x30)     — sets window_id + container_slots size
* CloseWindow (0x10)    — clears transient state

Verification:
* cargo build -p minecraft_bot: clean.
* cargo fmt --check: clean (after `cargo fmt --all`).
* ruff check python/minecraft_bot tests: clean.
* maturin develop --release: clean.
* pytest tests/python/parity tests/python/perf -m "not live":
  104 passed, 5 skipped.
* pytest tests/python/unit: 980 passed.
* cargo test --features live-smoke --test integration_bot_full:
  test_state_movement_and_combat_combined green on Paper 1.20.1.

This brings 004 from "API parity" to "API + behavioural parity"
across the three artefacts. Backlog list from the previous turn:
* open_block_container — FIXED.
* eat handshake — FIXED.
* click_slot WindowConfirmation analogue — FIXED.
* entity_velocity packet — still not wired (low priority, no method
  reads vx/vy/vz in 004's surface).
* Per-method packet-trace tests — still smoke-only.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: AlexMelanFromRingo

rust/src/bot.rs

@@ -40,8 +40,9 @@ use crate::protocol::v763::packets::play::clientbound::{
     experience::Experience as CbExperience, game_state_change::GameStateChange,
     held_item_slot::HeldItemSlot as CbHeldItemSlot, login::Login as CbLogin, map_chunk::MapChunk,
     multi_block_change::MultiBlockChange, named_entity_spawn::NamedEntitySpawn,
-    position::Position as CbPosition, respawn::Respawn as CbRespawn, spawn_entity::SpawnEntity,
-    unload_chunk::UnloadChunk, update_health::UpdateHealth,
+    open_window::OpenWindow, position::Position as CbPosition, respawn::Respawn as CbRespawn,
+    set_slot::SetSlot, spawn_entity::SpawnEntity, unload_chunk::UnloadChunk,
+    update_health::UpdateHealth, window_items::WindowItems,
 };
 use crate::protocol::v763::packets::play::serverbound::block_dig::BlockDig;
 use crate::protocol::v763::packets::play::serverbound::position::Position as SbPosition;
@@ -71,6 +72,10 @@ const ID_SPAWN_ENTITY: i32 = 0x01;
 const ID_NAMED_ENTITY_SPAWN: i32 = 0x03;
 const ID_ENTITY_DESTROY: i32 = 0x3E;
 const ID_ENTITY_TELEPORT: i32 = 0x68;
+const ID_SET_SLOT: i32 = 0x14;
+const ID_WINDOW_ITEMS: i32 = 0x12;
+const ID_OPEN_WINDOW: i32 = 0x30;
+const ID_CLOSE_WINDOW: i32 = 0x10;
 /// Mojang entity type id for `minecraft:player`.
 const ENTITY_TYPE_PLAYER: i32 = 124;
 const ID_BLOCK_CHANGE: i32 = 0x0A;
@@ -226,6 +231,7 @@ impl Bot {
         let state = Arc::clone(&self.state);
         let hooks = Arc::clone(&self.hooks);
         let entities = Arc::clone(&self.entities_tracker);
+        let inventory = Arc::clone(&self.inventory);
 
         let handle = tokio::spawn(async move {
             while let Some((id, body)) = rx.recv().await {
@@ -409,6 +415,72 @@ impl Bot {
                         }
                         Ok(())
                     }
+                    ID_SET_SLOT => {
+                        if let Ok(pkt) = SetSlot::decode(&mut br) {
+                            let mut inv = inventory.lock().await;
+                            inv.state_id = pkt.state_id;
+                            let item = pkt.item.as_ref().map(|s| {
+                                crate::inventory::ItemSlot::new(
+                                    s.item_id as u32,
+                                    s.count as u8,
+                                    None, // NBT bytes — decoded later
+                                )
+                            });
+                            inv.apply_set_slot(pkt.window_id as u8, pkt.slot_index, item);
+                        }
+                        Ok(())
+                    }
+                    ID_WINDOW_ITEMS => {
+                        if let Ok(pkt) = WindowItems::decode(&mut br) {
+                            let mut inv = inventory.lock().await;
+                            inv.state_id = pkt.state_id;
+                            let items: Vec<Option<crate::inventory::ItemSlot>> = pkt
+                                .items
+                                .iter()
+                                .map(|opt| {
+                                    opt.as_ref().map(|s| {
+                                        crate::inventory::ItemSlot::new(
+                                            s.item_id as u32,
+                                            s.count as u8,
+                                            None,
+                                        )
+                                    })
+                                })
+                                .collect();
+                            inv.apply_window_items(pkt.window_id, items);
+                        }
+                        Ok(())
+                    }
+                    ID_OPEN_WINDOW => {
+                        if let Ok(pkt) = OpenWindow::decode(&mut br) {
+                            // Inventory type -> rough slot count.
+                            // Mojang inventory_type values: 0..5 = generic
+                            // chests (9..54), 6=hopper(5), 13=furnace(3),
+                            // 14=crafting(10), etc. Use a coarse fallback
+                            // table — the next WindowItems wholesale
+                            // overwrites the size anyway.
+                            let container_size = match pkt.inventory_type {
+                                0 => 9,
+                                1 => 18,
+                                2 => 27,
+                                3 => 36,
+                                4 => 45,
+                                5 => 54,
+                                6 => 5,
+                                13 => 3,
+                                14 => 10,
+                                _ => 27,
+                            };
+                            let mut inv = inventory.lock().await;
+                            inv.apply_open_screen(pkt.window_id as u8, container_size);
+                        }
+                        Ok(())
+                    }
+                    ID_CLOSE_WINDOW => {
+                        let mut inv = inventory.lock().await;
+                        inv.apply_close_window();
+                        Ok(())
+                    }
                     ID_SYNC_PLAYER_POSITION => {
                         if let Ok(pkt) = CbPosition::decode(&mut br) {
                             // Flags bits: 0x01=x rel, 0x02=y rel, 0x04=z rel,

rust/src/bot/containers.rs

@@ -12,6 +12,7 @@ use std::time::Duration;
 
 use super::Bot;
 use crate::errors::ProtocolError;
+use crate::protocol::v763::packets::play::serverbound::block_place::BlockPlace;
 use crate::protocol::v763::packets::play::serverbound::close_window::CloseWindow;
 
 impl Bot {
@@ -24,17 +25,34 @@ impl Bot {
         z: i32,
         timeout: Duration,
     ) -> Result<u8, ProtocolError> {
-        // Aim at the block, then use_item (which delegates to a
-        // right-click). The server replies with OpenScreen + WindowItems
-        // which the dispatcher picks up to populate InventoryState.
+        // v0.3.1: aim at block centre, then send BlockPlace (the
+        // serverbound "use item on block" / right-click-block packet).
+        // The previous UseItem (right-click-air) path didn't open
+        // chests on the live server. The server responds with
+        // OpenScreen + WindowItems, picked up by the dispatcher to
+        // populate InventoryState.
         self.look_at(x as f64 + 0.5, y as f64 + 0.5, z as f64 + 0.5)
             .await?;
-        self.use_item(0).await?;
-        // Wait up to `timeout` for the dispatcher to set window_id.
+        let pre_wid = self.inventory.lock().await.window_id;
+        self.connection
+            .send(&BlockPlace {
+                hand: 0,
+                location: (x, y, z),
+                direction: 1, // top face — works for any container
+                cursor_x: 0.5,
+                cursor_y: 0.5,
+                cursor_z: 0.5,
+                inside_block: false,
+                sequence: 0,
+            })
+            .await?;
+        // Wait up to `timeout` for the dispatcher to assign a new
+        // window_id. Pre-existing window_id (rare; bot was already
+        // in a window) is treated as "we already have one".
         let deadline = std::time::Instant::now() + timeout;
         while std::time::Instant::now() < deadline {
             let wid = self.inventory.lock().await.window_id;
-            if wid != 0 {
+            if wid != pre_wid && wid != 0 {
                 return Ok(wid);
             }
             tokio::time::sleep(Duration::from_millis(50)).await;

rust/src/bot/inventory.rs

@@ -297,7 +297,21 @@ impl Bot {
                 changed_slots: Vec::new(),
                 carried_item: None,
             })
-            .await
+            .await?;
+        // v0.3.1: wait briefly (<= 200 ms) for SetSlot/WindowItems to
+        // bump state_id. 1.20.1 has no WindowConfirmation packet; the
+        // state_id field on every click serves that role. Paper's
+        // anti-cheat rejects clicks whose state_id is stale, so
+        // pacing rapid clicks against the server echo prevents
+        // desync.
+        let deadline = std::time::Instant::now() + std::time::Duration::from_millis(200);
+        while std::time::Instant::now() < deadline {
+            tokio::time::sleep(std::time::Duration::from_millis(10)).await;
+            if self.inventory.lock().await.state_id != state_id {
+                break;
+            }
+        }
+        Ok(())
     }
 
     /// Move the entire stack at `src` to `dst` via pick-up + put-down

rust/src/bot/tasks.rs

@@ -68,11 +68,12 @@ impl Bot {
         self.swing_arm(0).await
     }
 
-    /// Eat the first food item in the hotbar. MVP: select food slot,
-    /// send use_item, wait ~1.5s for eating animation, return.
+    /// Eat the first food item in the hotbar. v0.3.1: subscribe to
+    /// `EntityStatus(status=9)` (player finished using item) via
+    /// the packet-hook mechanism, send `use_item`, await the status,
+    /// fall back to the timeout if the server is slow.
     pub async fn eat(&self, timeout: Duration) -> Result<(), ProtocolError> {
         let foods = food_table();
-        // Find a food item in player_slots.
         let mut food_slot: Option<u8> = None;
         {
             let inv = self.inventory.lock().await;
@@ -91,11 +92,48 @@ impl Bot {
                 return Err(ProtocolError::DecodeError("eat: no food in hotbar".into()));
             }
         };
+        let bot_eid = self.state.lock().await.entity_id.unwrap_or(0);
         self.select_slot(slot).await?;
+
+        // Register EntityStatus listener before sending use_item.
+        let (tx, rx) = tokio::sync::oneshot::channel::<()>();
+        let tx_arc = std::sync::Arc::new(std::sync::Mutex::new(Some(tx)));
+        let tx_clone = tx_arc.clone();
+        self.on_packet(
+            0x1C,
+            Box::new(move |_id, body| {
+                // EntityStatus body: VarInt(entity_id), i8(status).
+                let mut val: i32 = 0;
+                let mut bits = 0;
+                let mut idx = 0;
+                while idx < 5.min(body.len()) {
+                    let b = body[idx];
+                    val |= ((b & 0x7F) as i32) << bits;
+                    idx += 1;
+                    if (b & 0x80) == 0 {
+                        break;
+                    }
+                    bits += 7;
+                }
+                if val != bot_eid || idx >= body.len() {
+                    return;
+                }
+                let status = body[idx] as i8;
+                // Mojang status code 9 = "player finished using item".
+                if status == 9 {
+                    if let Ok(mut g) = tx_clone.lock() {
+                        if let Some(tx) = g.take() {
+                            let _ = tx.send(());
+                        }
+                    }
+                }
+            }),
+        )
+        .await;
+
         self.use_item(0).await?;
-        // Eating animation is ~1.6s for most foods. Wait up to `timeout`.
-        let dt = timeout.min(Duration::from_millis(1600));
-        tokio::time::sleep(dt).await;
+        // Await EntityStatus(9) or fall back to `timeout`.
+        let _ = tokio::time::timeout(timeout, rx).await;
         Ok(())
     }