Client Component Division (#266)

## Description

Divides the `Client` component into a set of smaller components as
described by #199 (with many deviations). `McEntity` will be dealt with
in a future PR.

- Divide `Client` into smaller components (There's a lot to look at).
- Move common components to `component` module.
- Remove `Username` type from `valence_protocol` because the added
complexity wasn't adding much benefit.
- Clean up the inventory module.

I've stopped worrying about the "Effect When Added" and "Effect When
Removed" behavior of components so much, and instead assume that all
components of a particular thing are required unless otherwise stated.

## Test Plan

Steps:
1. Run examples and tests.

A large number of tweaks have been made to the inventory module. I tried
to preserve semantics but I could have made a mistake there.

---------

Co-authored-by: Carson McManus <[email protected]>
Co-authored-by: Carson McManus <[email protected]>

Author: rj00a

crates/playground/src/extras.rs

@@ -7,18 +7,17 @@ use valence::prelude::*;
 /// Toggles client's game mode between survival and creative when they start
 /// sneaking.
 pub fn toggle_gamemode_on_sneak(
-    mut clients: Query<&mut Client>,
+    mut clients: Query<&mut GameMode>,
     mut events: EventReader<StartSneaking>,
 ) {
     for event in events.iter() {
-        let Ok(mut client) = clients.get_component_mut::<Client>(event.client) else {
+        let Ok(mut mode) = clients.get_component_mut::<GameMode>(event.client) else {
             continue;
         };
-        let mode = client.game_mode();
-        client.set_game_mode(match mode {
+        *mode = match *mode {
             GameMode::Survival => GameMode::Creative,
             GameMode::Creative => GameMode::Survival,
             _ => GameMode::Creative,
-        });
+        };
     }
 }

crates/playground/src/playground.template.rs

@@ -9,8 +9,8 @@ const SPAWN_Y: i32 = 64;
 
 pub fn build_app(app: &mut App) {
     app.add_plugin(ServerPlugin::new(()))
-        .add_system(default_event_handler.in_schedule(EventLoopSchedule))
         .add_startup_system(setup)
+        .add_system(default_event_handler.in_schedule(EventLoopSchedule))
         .add_system(init_clients)
         .add_system(despawn_disconnected_clients);
 }
@@ -34,15 +34,12 @@ fn setup(mut commands: Commands, server: Res<Server>) {
 }
 
 fn init_clients(
-    mut clients: Query<&mut Client, Added<Client>>,
+    mut clients: Query<(&mut Position, &mut Location), Added<Client>>,
     instances: Query<Entity, With<Instance>>,
 ) {
-    let instance = instances.get_single().unwrap();
-
-    for mut client in &mut clients {
-        client.set_position([0.5, SPAWN_Y as f64 + 1.0, 0.5]);
-        client.set_instance(instance);
-        client.set_game_mode(GameMode::Survival);
+    for (mut pos, mut loc) in &mut clients {
+        pos.0 = [0.5, SPAWN_Y as f64 + 1.0, 0.5].into();
+        loc.0 = instances.single();
     }
 }
 

crates/valence/examples/bench_players.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::type_complexity)]
+
 use std::time::Instant;
 
 use valence::client::despawn_disconnected_clients;
@@ -65,19 +67,26 @@ fn setup(mut commands: Commands, server: Res<Server>) {
 }
 
 fn init_clients(
-    mut clients: Query<(Entity, &mut Client), Added<Client>>,
+    mut clients: Query<
+        (
+            Entity,
+            &UniqueId,
+            &mut Position,
+            &mut Location,
+            &mut GameMode,
+        ),
+        Added<Client>,
+    >,
     instances: Query<Entity, With<Instance>>,
     mut commands: Commands,
 ) {
-    let instance = instances.single();
-
-    for (client_entity, mut client) in &mut clients {
-        client.set_position([0.0, SPAWN_Y as f64 + 1.0, 0.0]);
-        client.set_instance(instance);
-        client.set_game_mode(GameMode::Creative);
-
-        let player_entity = McEntity::with_uuid(EntityKind::Player, instance, client.uuid());
-
-        commands.entity(client_entity).insert(player_entity);
+    for (entity, unique_id, mut pos, mut loc, mut game_mode) in &mut clients {
+        pos.0 = [0.0, SPAWN_Y as f64 + 1.0, 0.0].into();
+        loc.0 = instances.single();
+        *game_mode = GameMode::Creative;
+
+        commands
+            .entity(entity)
+            .insert(McEntity::with_uuid(EntityKind::Player, loc.0, unique_id.0));
     }
 }

crates/valence/examples/biomes.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::type_complexity)]
+
 use valence::client::despawn_disconnected_clients;
 use valence::client::event::default_event_handler;
 use valence::prelude::*;
@@ -77,14 +79,12 @@ fn setup(mut commands: Commands, server: Res<Server>) {
 }
 
 fn init_clients(
-    mut clients: Query<&mut Client, Added<Client>>,
+    mut clients: Query<(&mut Position, &mut Location, &mut GameMode), Added<Client>>,
     instances: Query<Entity, With<Instance>>,
 ) {
-    for mut client in &mut clients {
-        client.set_position([0.0, SPAWN_Y as f64 + 1.0, 0.0]);
-        client.set_respawn_screen(true);
-        client.set_instance(instances.single());
-        client.set_game_mode(GameMode::Creative);
-        client.send_message("Welcome to Valence!".italic());
+    for (mut pos, mut loc, mut game_mode) in &mut clients {
+        pos.set([0.0, SPAWN_Y as f64 + 1.0, 0.0]);
+        loc.0 = instances.single();
+        *game_mode = GameMode::Creative;
     }
 }

crates/valence/examples/block_entities.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::type_complexity)]
+
 use valence::client::despawn_disconnected_clients;
 use valence::client::event::{default_event_handler, ChatMessage, PlayerInteractBlock};
 use valence::nbt::{compound, List};
@@ -61,19 +63,34 @@ fn setup(mut commands: Commands, server: Res<Server>) {
 }
 
 fn init_clients(
-    mut clients: Query<&mut Client, Added<Client>>,
+    mut clients: Query<
+        (
+            Entity,
+            &UniqueId,
+            &mut Position,
+            &mut Look,
+            &mut Location,
+            &mut GameMode,
+        ),
+        Added<Client>,
+    >,
     instances: Query<Entity, With<Instance>>,
+    mut commands: Commands,
 ) {
-    for mut client in &mut clients {
-        client.set_position([1.5, FLOOR_Y as f64 + 1.0, 1.5]);
-        client.set_yaw(-90.0);
-        client.set_instance(instances.single());
-        client.set_game_mode(GameMode::Creative);
+    for (entity, uuid, mut pos, mut look, mut loc, mut game_mode) in &mut clients {
+        pos.set([1.5, FLOOR_Y as f64 + 1.0, 1.5]);
+        look.yaw = -90.0;
+        loc.0 = instances.single();
+        *game_mode = GameMode::Creative;
+
+        commands
+            .entity(entity)
+            .insert(McEntity::with_uuid(EntityKind::Player, loc.0, uuid.0));
     }
 }
 
 fn event_handler(
-    clients: Query<&Client>,
+    clients: Query<(&Username, &Properties, &UniqueId)>,
     mut messages: EventReader<ChatMessage>,
     mut block_interacts: EventReader<PlayerInteractBlock>,
     mut instances: Query<&mut Instance>,
@@ -83,14 +100,14 @@ fn event_handler(
         client, message, ..
     } in messages.iter()
     {
-        let Ok(client) = clients.get(*client) else {
+        let Ok((username, _, _)) = clients.get(*client) else {
             continue
         };
 
         let mut sign = instance.block_mut(SIGN_POS).unwrap();
         let nbt = sign.nbt_mut().unwrap();
         nbt.insert("Text2", message.to_string().color(Color::DARK_GREEN));
-        nbt.insert("Text3", format!("~{}", client.username()).italic());
+        nbt.insert("Text3", format!("~{}", username).italic());
     }
 
     for PlayerInteractBlock {
@@ -101,19 +118,19 @@ fn event_handler(
     } in block_interacts.iter()
     {
         if *hand == Hand::Main && *position == SKULL_POS {
-            let Ok(client) = clients.get(*client) else {
+            let Ok((_, properties, uuid)) = clients.get(*client) else {
                 continue
             };
 
-            let Some(textures) = client.properties().iter().find(|prop| prop.name == "textures") else {
-                continue
+            let Some(textures) = properties.textures() else {
+                continue;
             };
 
             let mut skull = instance.block_mut(SKULL_POS).unwrap();
             let nbt = skull.nbt_mut().unwrap();
             *nbt = compound! {
                 "SkullOwner" => compound! {
-                    "Id" => client.uuid(),
+                    "Id" => uuid.0,
                     "Properties" => compound! {
                         "textures" => List::Compound(vec![compound! {
                             "Value" => textures.value.clone(),

crates/valence/examples/building.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::type_complexity)]
+
 use valence::client::despawn_disconnected_clients;
 use valence::client::event::{
     default_event_handler, PlayerInteractBlock, StartDigging, StartSneaking, StopDestroyBlock,
@@ -48,85 +50,98 @@ fn setup(mut commands: Commands, server: Res<Server>) {
 }
 
 fn init_clients(
-    mut clients: Query<&mut Client, Added<Client>>,
+    mut clients: Query<
+        (
+            Entity,
+            &UniqueId,
+            &mut Client,
+            &mut Position,
+            &mut Location,
+            &mut GameMode,
+        ),
+        Added<Client>,
+    >,
     instances: Query<Entity, With<Instance>>,
+    mut commands: Commands,
 ) {
-    for mut client in &mut clients {
-        client.set_position([0.0, SPAWN_Y as f64 + 1.0, 0.0]);
-        client.set_instance(instances.single());
-        client.set_game_mode(GameMode::Creative);
+    for (entity, uuid, mut client, mut pos, mut loc, mut game_mode) in &mut clients {
+        pos.0 = [0.0, SPAWN_Y as f64 + 1.0, 0.0].into();
+        loc.0 = instances.single();
+        *game_mode = GameMode::Creative;
         client.send_message("Welcome to Valence! Build something cool.".italic());
+        commands
+            .entity(entity)
+            .insert(McEntity::with_uuid(EntityKind::Player, loc.0, uuid.0));
     }
 }
 
 fn toggle_gamemode_on_sneak(
-    mut clients: Query<&mut Client>,
+    mut clients: Query<&mut GameMode>,
     mut events: EventReader<StartSneaking>,
 ) {
     for event in events.iter() {
-        let Ok(mut client) = clients.get_component_mut::<Client>(event.client) else {
+        let Ok(mut mode) = clients.get_component_mut::<GameMode>(event.client) else {
             continue;
         };
-        let mode = client.game_mode();
-        client.set_game_mode(match mode {
+        *mode = match *mode {
             GameMode::Survival => GameMode::Creative,
             GameMode::Creative => GameMode::Survival,
             _ => GameMode::Creative,
-        });
+        };
     }
 }
 
 fn digging_creative_mode(
-    clients: Query<&Client>,
+    clients: Query<&GameMode>,
     mut instances: Query<&mut Instance>,
     mut events: EventReader<StartDigging>,
 ) {
     let mut instance = instances.single_mut();
 
     for event in events.iter() {
-        let Ok(client) = clients.get_component::<Client>(event.client) else {
+        let Ok(game_mode) = clients.get(event.client) else {
             continue;
         };
-        if client.game_mode() == GameMode::Creative {
+        if *game_mode == GameMode::Creative {
             instance.set_block(event.position, BlockState::AIR);
         }
     }
 }
 
 fn digging_survival_mode(
-    clients: Query<&Client>,
+    clients: Query<&GameMode>,
     mut instances: Query<&mut Instance>,
     mut events: EventReader<StopDestroyBlock>,
 ) {
     let mut instance = instances.single_mut();
 
     for event in events.iter() {
-        let Ok(client) = clients.get_component::<Client>(event.client) else {
+        let Ok(game_mode) = clients.get(event.client) else {
             continue;
         };
-        if client.game_mode() == GameMode::Survival {
+        if *game_mode == GameMode::Survival {
             instance.set_block(event.position, BlockState::AIR);
         }
     }
 }
 
 fn place_blocks(
-    mut clients: Query<(&Client, &mut Inventory)>,
+    mut clients: Query<(&mut Inventory, &GameMode, &PlayerInventoryState)>,
     mut instances: Query<&mut Instance>,
     mut events: EventReader<PlayerInteractBlock>,
 ) {
     let mut instance = instances.single_mut();
 
     for event in events.iter() {
-        let Ok((client, mut inventory)) = clients.get_mut(event.client) else {
+        let Ok((mut inventory, game_mode, inv_state)) = clients.get_mut(event.client) else {
             continue;
         };
         if event.hand != Hand::Main {
             continue;
         }
 
         // get the held item
-        let slot_id = client.held_item_slot();
+        let slot_id = inv_state.held_item_slot();
         let Some(stack) = inventory.slot(slot_id) else {
             // no item in the slot
             continue;
@@ -137,7 +152,7 @@ fn place_blocks(
             continue;
         };
 
-        if client.game_mode() == GameMode::Survival {
+        if *game_mode == GameMode::Survival {
             // check if the player has the item in their inventory and remove
             // it.
             if stack.count() > 1 {