[ECS] Inventory interactions (#189)

- add helper to convert slot ids
- implement system to handle click container events
- update inventory_test example with block platform and some chests to
open
- add toggle_gamemode_on_sneak system to example
- fix query filter that was causing clients to get spammed with
OpenScreen
- move state_id to `Client` component
- only send modified slots when observed inventories are changed
- force all click container packets to be handled before update packets
are built and sent
- mark inventories as dirty instead of just sending the contents
- add handle_set_slot_creative to handle SetCreativeModeSlot events
- exclude clients with currently open inventories from being updated by
`update_player_inventories`

### Test plan

1. Start the `inventory_test` example

```bash
cargo run --example inventory_test
```

2. Join the server
3. Walk to the small brick square
4. The copper, iron, and gold blocks have chests on top of them (they
are invisible until we have block entities)
5. Give yourself some items
6. Place those items in one of the inventories
7. Give yourself some more items
8. Sneak to change game mode to survival
9. Open the same inventory and move some items between your inventory
and the chest's inventory.
10. Repeat 5-9, but have another client join and observe the chest
you're interacting with.
11. The second client should be able to see the inventory update in real
time.

Author: dyc3

crates/valence_new/examples/inventory_test.rs

@@ -1,14 +1,15 @@
 use bevy_ecs::prelude::*;
 use bevy_ecs::schedule::ShouldRun;
 use tracing::info;
-use valence_new::client::event::default_event_handler;
+use valence_new::client::event::{default_event_handler, StartSneaking, UseItemOnBlock};
 use valence_new::client::{despawn_disconnected_clients, Client};
 use valence_new::config::{Config, ConnectionMode};
 use valence_new::dimension::DimensionId;
+use valence_new::instance::Chunk;
 use valence_new::inventory::{Inventory, InventoryKind, OpenInventory};
 use valence_new::protocol::types::GameMode;
 use valence_new::server::Server;
-use valence_protocol::{ItemKind, ItemStack};
+use valence_protocol::{BlockState, ItemKind, ItemStack};
 
 #[derive(Resource)]
 struct GameState {
@@ -17,26 +18,56 @@ struct GameState {
 }
 
 fn main() -> anyhow::Result<()> {
-    tracing_subscriber::fmt().init();
+    tracing_subscriber::fmt()
+        .with_max_level(tracing::Level::DEBUG)
+        .init();
 
     valence_new::run_server(
         Config::default().with_connection_mode(ConnectionMode::Offline),
         SystemStage::parallel()
             .with_system(setup.with_run_criteria(ShouldRun::once))
             .with_system(init_clients)
-            .with_system(open_inventory_test)
-            .with_system(blink_items)
             .with_system(default_event_handler())
-            .with_system(despawn_disconnected_clients),
+            .with_system(despawn_disconnected_clients)
+            // .with_system(open_inventory_test)
+            // .with_system(blink_items)
+            .with_system(open_inventory_on_interact)
+            .with_system(toggle_gamemode_on_sneak),
         (),
     )
 }
 
 fn setup(world: &mut World) {
-    let instance = world
+    let mut instance = world
         .resource::<Server>()
         .new_instance(DimensionId::default());
 
+    // Create spawn platform.
+    for z in -5..5 {
+        for x in -5..5 {
+            let mut chunk = Chunk::new(24);
+            for z in 0..16 {
+                for x in 0..16 {
+                    chunk.set_block_state(x, 10, z, BlockState::STONE);
+                }
+            }
+
+            if x == 0 && z == 0 {
+                for sx in 0..3 {
+                    for sz in 0..3 {
+                        chunk.set_block_state(sx, 10, sz, BlockState::BRICKS);
+                    }
+                    chunk.set_block_state(sx, 11, 0, BlockState::CHEST);
+                }
+                chunk.set_block_state(0, 10, 0, BlockState::COPPER_BLOCK);
+                chunk.set_block_state(1, 10, 0, BlockState::IRON_BLOCK);
+                chunk.set_block_state(2, 10, 0, BlockState::GOLD_BLOCK);
+            }
+
+            instance.insert_chunk([x, z], chunk);
+        }
+    }
+
     let id = world.spawn(instance).id();
     world.insert_resource(GameState {
         instance: id,
@@ -46,7 +77,7 @@ fn setup(world: &mut World) {
     // create inventories to view
     let mut inventories = [
         Inventory::new(InventoryKind::Generic9x2),
-        Inventory::new(InventoryKind::Generic9x3),
+        Inventory::new(InventoryKind::Generic9x6),
         Inventory::new(InventoryKind::Crafting),
     ];
 
@@ -94,3 +125,34 @@ fn blink_items(mut inventories: Query<&mut Inventory>) {
         }
     }
 }
+
+fn open_inventory_on_interact(
+    mut commands: Commands,
+    inventories: Query<(Entity, With<Inventory>, Without<Client>)>,
+    mut events: EventReader<UseItemOnBlock>,
+) {
+    for event in events.iter() {
+        let inventory_idx = event.position.x as usize % 3;
+        info!("opening inventory {}", inventory_idx);
+        let (target_inventory, _, _) = inventories.iter().skip(inventory_idx).next().unwrap();
+        commands
+            .entity(event.client)
+            .insert(OpenInventory::new(target_inventory));
+    }
+}
+
+fn toggle_gamemode_on_sneak(
+    mut clients: Query<&mut Client>,
+    mut events: EventReader<StartSneaking>,
+) {
+    for event in events.iter() {
+        if let Ok(mut client) = clients.get_component_mut::<Client>(event.client) {
+            let mode = client.game_mode();
+            client.set_game_mode(match mode {
+                GameMode::Survival => GameMode::Creative,
+                GameMode::Creative => GameMode::Survival,
+                _ => GameMode::Creative,
+            });
+        }
+    }
+}

crates/valence_new/src/client.rs

@@ -1,5 +1,6 @@
 use std::fmt;
 use std::net::IpAddr;
+use std::num::Wrapping;
 
 use anyhow::{bail, Context};
 use bevy_ecs::prelude::*;
@@ -79,6 +80,10 @@ pub struct Client {
     pub(crate) cursor_item_modified: bool,
     /// The current window ID. Incremented when inventories are opened.
     pub(crate) window_id: u8,
+    pub(crate) inventory_state_id: Wrapping<i32>,
+    /// Tracks what slots have been modified by this client in this tick, so we
+    /// don't need to send updates for them.
+    pub(crate) inventory_slots_modified: u64,
 }
 
 impl Client {
@@ -124,6 +129,8 @@ impl Client {
             cursor_item: None,
             cursor_item_modified: false,
             window_id: 0,
+            inventory_state_id: Wrapping(0),
+            inventory_slots_modified: 0,
         }
     }