Refactor Workspace (#386)

## Description

- Moved the `valence` crate to the top-level `Cargo.toml` to make tests,
examples and benches more discoverable. (This is similar to how bevy has
things set up)
- Renamed some miscellaneous items and tweaked examples.
- Tweaks to `valence::prelude`.

CONTRIBUTING.md

@@ -227,7 +227,7 @@ where appropriate.
 Unit tests help your contributions last! They ensure that your code works as expected and that it continues to work in
 the future.
 
-whole-server unit tests can be found in [`crates/valence/src/tests/`](crates/valence/src/tests).
+whole-server unit tests can be found in [`/src/tests/`](/src/tests).
 
 ## Naming Quantities
 

Cargo.toml

@@ -1,6 +1,80 @@
+[package]
+name = "valence"
+version.workspace = true
+edition.workspace = true
+description = "A framework for building Minecraft servers in Rust."
+documentation.workspace = true
+repository.workspace = true
+readme = "README.md"
+license.workspace = true
+keywords = ["minecraft", "gamedev", "server", "ecs"]
+categories = ["game-engines"]
+
+[features]
+default = [
+    "network",
+    "player_list",
+    "inventory",
+    "anvil",
+    "advancement",
+    "world_border",
+]
+network = ["dep:valence_network"]
+player_list = ["dep:valence_player_list"]
+inventory = ["dep:valence_inventory"]
+anvil = ["dep:valence_anvil"]
+advancement = ["dep:valence_advancement"]
+world_border = ["dep:valence_world_border"]
+
+[dependencies]
+bevy_app.workspace = true
+bevy_ecs.workspace = true
+glam.workspace = true
+uuid.workspace = true
+valence_nbt.workspace = true
+valence_core.workspace = true
+valence_registry.workspace = true
+valence_block.workspace = true
+valence_biome.workspace = true
+valence_dimension.workspace = true
+valence_entity.workspace = true
+valence_instance.workspace = true
+valence_client.workspace = true
+valence_network = { workspace = true, optional = true }
+valence_player_list = { workspace = true, optional = true }
+valence_inventory = { workspace = true, optional = true }
+valence_anvil = { workspace = true, optional = true }
+valence_advancement = { workspace = true, optional = true }
+valence_world_border = { workspace = true, optional = true }
+
+[dev-dependencies]
+anyhow.workspace = true
+bytes.workspace = true
+clap.workspace = true
+criterion.workspace = true
+flume.workspace = true
+noise.workspace = true              # For the terrain example.
+rand.workspace = true
+tracing-subscriber.workspace = true
+tracing.workspace = true
+
+[dev-dependencies.reqwest]
+workspace = true
+default-features = false
+features = ["rustls-tls", "blocking", "stream"]
+
+[[bench]]
+name = "main"
+harness = false
+
+[profile.dev.package."*"]
+opt-level = 3
+
+[profile.dev]
+opt-level = 1
+
 [workspace]
 members = ["crates/*", "tools/*"]
-exclude = ["rust-mc-bot"]
 resolver = "2"
 
 [workspace.package]
@@ -96,12 +170,5 @@ valence_network.path = "crates/valence_network"
 valence_player_list.path = "crates/valence_player_list"
 valence_registry.path = "crates/valence_registry"
 valence_world_border.path = "crates/valence_world_border"
-valence.path = "crates/valence"
-
+valence.path = "."
 zip = "0.6.3"
-
-[profile.dev.package."*"]
-opt-level = 3
-
-[profile.dev]
-opt-level = 1

crates/valence_client/src/command.rs

@@ -8,10 +8,10 @@ use valence_entity::{entity, Pose};
 use crate::event_loop::{EventLoopSchedule, EventLoopSet, PacketEvent};
 
 pub(super) fn build(app: &mut App) {
-    app.add_event::<Sprinting>()
-        .add_event::<Sneaking>()
-        .add_event::<JumpWithHorse>()
-        .add_event::<LeaveBed>()
+    app.add_event::<SprintEvent>()
+        .add_event::<SneakEvent>()
+        .add_event::<JumpWithHorseEvent>()
+        .add_event::<LeaveBedEvent>()
         .add_system(
             handle_client_command
                 .in_schedule(EventLoopSchedule)
@@ -20,7 +20,7 @@ pub(super) fn build(app: &mut App) {
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub struct Sprinting {
+pub struct SprintEvent {
     pub client: Entity,
     pub state: SprintState,
 }
@@ -32,7 +32,7 @@ pub enum SprintState {
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub struct Sneaking {
+pub struct SneakEvent {
     pub client: Entity,
     pub state: SneakState,
 }
@@ -44,7 +44,7 @@ pub enum SneakState {
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub struct JumpWithHorse {
+pub struct JumpWithHorseEvent {
     pub client: Entity,
     pub state: JumpWithHorseState,
 }
@@ -59,17 +59,17 @@ pub enum JumpWithHorseState {
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub struct LeaveBed {
+pub struct LeaveBedEvent {
     pub client: Entity,
 }
 
 fn handle_client_command(
     mut packets: EventReader<PacketEvent>,
     mut clients: Query<(&mut entity::Pose, &mut Flags)>,
-    mut sprinting_events: EventWriter<Sprinting>,
-    mut sneaking_events: EventWriter<Sneaking>,
-    mut jump_with_horse_events: EventWriter<JumpWithHorse>,
-    mut leave_bed_events: EventWriter<LeaveBed>,
+    mut sprinting_events: EventWriter<SprintEvent>,
+    mut sneaking_events: EventWriter<SneakEvent>,
+    mut jump_with_horse_events: EventWriter<JumpWithHorseEvent>,
+    mut leave_bed_events: EventWriter<LeaveBedEvent>,
 ) {
     for packet in packets.iter() {
         if let Some(pkt) = packet.decode::<ClientCommandC2s>() {
@@ -80,7 +80,7 @@ fn handle_client_command(
                         flags.set_sneaking(true);
                     }
 
-                    sneaking_events.send(Sneaking {
+                    sneaking_events.send(SneakEvent {
                         client: packet.client,
                         state: SneakState::Start,
                     })
@@ -91,20 +91,20 @@ fn handle_client_command(
                         flags.set_sneaking(false);
                     }
 
-                    sneaking_events.send(Sneaking {
+                    sneaking_events.send(SneakEvent {
                         client: packet.client,
                         state: SneakState::Stop,
                     })
                 }
-                ClientCommand::LeaveBed => leave_bed_events.send(LeaveBed {
+                ClientCommand::LeaveBed => leave_bed_events.send(LeaveBedEvent {
                     client: packet.client,
                 }),
                 ClientCommand::StartSprinting => {
                     if let Ok((_, mut flags)) = clients.get_mut(packet.client) {
                         flags.set_sprinting(true);
                     }
 
-                    sprinting_events.send(Sprinting {
+                    sprinting_events.send(SprintEvent {
                         client: packet.client,
                         state: SprintState::Start,
                     });
@@ -114,21 +114,25 @@ fn handle_client_command(
                         flags.set_sprinting(false);
                     }
 
-                    sprinting_events.send(Sprinting {
+                    sprinting_events.send(SprintEvent {
                         client: packet.client,
                         state: SprintState::Stop,
                     })
                 }
-                ClientCommand::StartJumpWithHorse => jump_with_horse_events.send(JumpWithHorse {
-                    client: packet.client,
-                    state: JumpWithHorseState::Start {
-                        power: pkt.jump_boost.0 as u8,
-                    },
-                }),
-                ClientCommand::StopJumpWithHorse => jump_with_horse_events.send(JumpWithHorse {
-                    client: packet.client,
-                    state: JumpWithHorseState::Stop,
-                }),
+                ClientCommand::StartJumpWithHorse => {
+                    jump_with_horse_events.send(JumpWithHorseEvent {
+                        client: packet.client,
+                        state: JumpWithHorseState::Start {
+                            power: pkt.jump_boost.0 as u8,
+                        },
+                    })
+                }
+                ClientCommand::StopJumpWithHorse => {
+                    jump_with_horse_events.send(JumpWithHorseEvent {
+                        client: packet.client,
+                        state: JumpWithHorseState::Stop,
+                    })
+                }
                 ClientCommand::OpenHorseInventory => {} // TODO
                 ClientCommand::StartFlyingWithElytra => {
                     if let Ok((mut pose, _)) = clients.get_mut(packet.client) {

crates/valence/examples/advancement.rs → examples/advancement.rs

@@ -1,9 +1,8 @@
 use std::collections::HashMap;
 
+use valence::advancement::bevy_hierarchy::{BuildChildren, Children, Parent};
+use valence::advancement::ForceTabUpdate;
 use valence::prelude::*;
-use valence_advancement::bevy_hierarchy::{BuildChildren, Children, Parent};
-use valence_advancement::ForceTabUpdate;
-use valence_client::SpawnClientsSet;
 
 #[derive(Component)]
 struct RootCriteria;
@@ -29,13 +28,14 @@ fn main() {
         .init_resource::<ClientSave>()
         .add_startup_system(setup)
         .add_systems((
+            load_clients,
+            apply_system_buffers
+                .after(load_clients)
+                .before(init_advancements),
             init_clients,
             init_advancements,
             sneak,
             tab_change,
-            load_clients
-                .after(SpawnClientsSet)
-                .in_base_set(CoreSet::PreUpdate),
         ))
         .run();
 }
@@ -225,7 +225,7 @@ fn init_advancements(
 }
 
 fn sneak(
-    mut sneaking: EventReader<Sneaking>,
+    mut sneaking: EventReader<SneakEvent>,
     mut client: Query<(&mut AdvancementClientUpdate, &mut RootCriteriaDone)>,
     root_criteria: Query<Entity, With<RootCriteria>>,
     client_uuid: Query<&UniqueId>,

crates/valence/examples/bench_players.rs → examples/bench_players.rs

@@ -2,9 +2,7 @@
 
 use std::time::Instant;
 
-use valence::instance::{Chunk, Instance};
 use valence::prelude::*;
-use valence_network::ConnectionMode;
 
 const SPAWN_Y: i32 = 64;
 

crates/valence/examples/building.rs → examples/building.rs

@@ -60,7 +60,10 @@ fn init_clients(
     }
 }
 
-fn toggle_gamemode_on_sneak(mut clients: Query<&mut GameMode>, mut events: EventReader<Sneaking>) {
+fn toggle_gamemode_on_sneak(
+    mut clients: Query<&mut GameMode>,
+    mut events: EventReader<SneakEvent>,
+) {
     for event in events.iter() {
         let Ok(mut mode) = clients.get_mut(event.client) else {
             continue;

crates/valence/examples/chest.rs → examples/chest.rs

@@ -59,7 +59,10 @@ fn init_clients(
     }
 }
 
-fn toggle_gamemode_on_sneak(mut clients: Query<&mut GameMode>, mut events: EventReader<Sneaking>) {
+fn toggle_gamemode_on_sneak(
+    mut clients: Query<&mut GameMode>,
+    mut events: EventReader<SneakEvent>,
+) {
     for event in events.iter() {
         let Ok(mut mode) = clients.get_mut(event.client) else {
             continue;

crates/valence/examples/combat.rs → examples/combat.rs

@@ -95,10 +95,10 @@ struct CombatQuery {
 fn handle_combat_events(
     server: Res<Server>,
     mut clients: Query<CombatQuery>,
-    mut sprinting: EventReader<Sprinting>,
+    mut sprinting: EventReader<SprintEvent>,
     mut interact_entity: EventReader<InteractEntityEvent>,
 ) {
-    for &Sprinting { client, state } in sprinting.iter() {
+    for &SprintEvent { client, state } in sprinting.iter() {
         if let Ok(mut client) = clients.get_mut(client) {
             client.state.has_bonus_knockback = state == SprintState::Start;
         }