Implement world border

crates/valence/examples/world_border.rs

@@ -0,0 +1,101 @@
+use valence::client::chat::ChatMessageEvent;
+use valence::client::despawn_disconnected_clients;
+use valence::client::world_border::{
+    SetWorldBorderSizeEvent, WorldBorderBundle, WorldBorderCenter, WorldBorderDiameter,
+};
+use valence::prelude::*;
+
+const SPAWN_Y: i32 = 64;
+
+fn main() {
+    tracing_subscriber::fmt().init();
+
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_startup_system(setup)
+        .add_system(init_clients)
+        .add_system(despawn_disconnected_clients)
+        .add_system(border_controls)
+        .run();
+}
+
+fn setup(
+    mut commands: Commands,
+    server: Res<Server>,
+    biomes: Res<BiomeRegistry>,
+    dimensions: Res<DimensionTypeRegistry>,
+) {
+    let mut instance = Instance::new(ident!("overworld"), &dimensions, &biomes, &server);
+
+    for z in -5..5 {
+        for x in -5..5 {
+            instance.insert_chunk([x, z], Chunk::default());
+        }
+    }
+
+    for z in -25..25 {
+        for x in -25..25 {
+            instance.set_block([x, SPAWN_Y, z], BlockState::GRASS_BLOCK);
+        }
+    }
+
+    commands
+        .spawn(instance)
+        .insert(WorldBorderBundle::new([0.0, 0.0], 10.0));
+}
+
+fn init_clients(
+    mut clients: Query<(&mut Client, &mut Location, &mut Position), Added<Client>>,
+    instances: Query<Entity, With<Instance>>,
+) {
+    for (mut client, mut loc, mut pos) in &mut clients {
+        loc.0 = instances.single();
+        pos.set([0.5, SPAWN_Y as f64 + 1.0, 0.5]);
+        client.send_message("Border control: ");
+        client.send_message("- Modify size: add <amount(can be negative)> <time(ms)>");
+        client.send_message("- Change center: center <x> <z>");
+    }
+}
+
+fn border_controls(
+    mut events: EventReader<ChatMessageEvent>,
+    mut instances: Query<(Entity, &WorldBorderDiameter, &mut WorldBorderCenter), With<Instance>>,
+    mut event_writer: EventWriter<SetWorldBorderSizeEvent>,
+) {
+    for x in events.iter() {
+        let parts: Vec<&str> = x.message.split(' ').collect();
+        match parts[0] {
+            "resize" => {
+                let Ok(value) = parts[1].parse::<f64>() else {
+                    return;
+                };
+
+                let Ok(speed) = parts[2].parse::<i64>() else {
+                    return;
+                };
+
+                let Ok((entity, diameter, _)) = instances.get_single_mut() else {
+                    return;
+                };
+
+                event_writer.send(SetWorldBorderSizeEvent {
+                    instance: entity,
+                    new_diameter: diameter.diameter() + value,
+                    speed,
+                })
+            }
+            "center" => {
+                let Ok(x) = parts[1].parse::<f64>() else {
+                    return;
+                };
+
+                let Ok(z) = parts[2].parse::<f64>() else {
+                    return;
+                };
+
+                instances.single_mut().2 .0 = DVec2 { x, y: z };
+            }
+            _ => (),
+        }
+    }
+}

crates/valence/src/tests.rs

@@ -284,3 +284,4 @@ mod client;
 mod example;
 mod inventory;
 mod weather;
+mod world_border;

crates/valence/src/tests/world_border.rs

@@ -0,0 +1,136 @@
+use bevy_app::App;
+use valence_client::world_border::{
+    SetWorldBorderSizeEvent, WorldBorderBundle, WorldBorderCenter, WorldBorderPortalTpBoundary,
+    WorldBorderWarnBlocks, WorldBorderWarnTime,
+};
+use valence_entity::Location;
+use valence_instance::packet::{
+    WorldBorderCenterChangedS2c, WorldBorderInitializeS2c, WorldBorderSizeChangedS2c,
+    WorldBorderWarningBlocksChangedS2c, WorldBorderWarningTimeChangedS2c,
+};
+use valence_instance::Instance;
+use valence_registry::{Entity, Mut};
+
+use super::{scenario_single_client, MockClientHelper, create_mock_client};
+
+
+#[test]
+fn test_intialize_on_join() {
+    let mut app = App::new();
+    let (_, instance_ent) = prepare(&mut app);
+
+    let (client, mut client_helper) = create_mock_client();
+    let client_ent = app.world.spawn(client).id();
+
+    app.world.get_mut::<Location>(client_ent).unwrap().0 = instance_ent;
+    app.update();
+
+    client_helper.collect_sent().assert_count::<WorldBorderInitializeS2c>(1);
+}
+
+#[test]
+fn test_resizing() {
+    let mut app = App::new();
+    let (mut client_helper, instance_ent) = prepare(&mut app);
+
+    app.world.send_event(SetWorldBorderSizeEvent {
+        new_diameter: 20.0,
+        speed: 0,
+        instance: instance_ent,
+    });
+
+    app.update();
+    let frames = client_helper.collect_sent();
+    frames.assert_count::<WorldBorderSizeChangedS2c>(1);
+}
+
+#[test]
+fn test_center() {
+    let mut app = App::new();
+    let (mut client_helper, instance_ent) = prepare(&mut app);
+
+    let mut ins_mut = app.world.entity_mut(instance_ent);
+    let mut center: Mut<WorldBorderCenter> = ins_mut
+        .get_mut()
+        .expect("Expect world border to be present!");
+    center.0 = [10.0, 10.0].into();
+
+    app.update();
+    let frames = client_helper.collect_sent();
+    frames.assert_count::<WorldBorderCenterChangedS2c>(1);
+}
+
+#[test]
+fn test_warn_time() {
+    let mut app = App::new();
+    let (mut client_helper, instance_ent) = prepare(&mut app);
+
+    let mut ins_mut = app.world.entity_mut(instance_ent);
+    let mut wt: Mut<WorldBorderWarnTime> = ins_mut
+        .get_mut()
+        .expect("Expect world border to be present!");
+    wt.0 = 100;
+    app.update();
+
+    let frames = client_helper.collect_sent();
+    frames.assert_count::<WorldBorderWarningTimeChangedS2c>(1);
+}
+
+#[test]
+fn test_warn_blocks() {
+    let mut app = App::new();
+    let (mut client_helper, instance_ent) = prepare(&mut app);
+
+    let mut ins_mut = app.world.entity_mut(instance_ent);
+    let mut wb: Mut<WorldBorderWarnBlocks> = ins_mut
+        .get_mut()
+        .expect("Expect world border to be present!");
+    wb.0 = 100;
+    app.update();
+
+    let frames = client_helper.collect_sent();
+    frames.assert_count::<WorldBorderWarningBlocksChangedS2c>(1);
+}
+
+#[test]
+fn test_portal_tp_boundary() {
+    let mut app = App::new();
+    let (mut client_helper, instance_ent) = prepare(&mut app);
+
+    let mut ins_mut = app.world.entity_mut(instance_ent);
+    let mut tp: Mut<WorldBorderPortalTpBoundary> = ins_mut
+        .get_mut()
+        .expect("Expect world border to be present!");
+    tp.0 = 100;
+    app.update();
+
+    let frames = client_helper.collect_sent();
+    frames.assert_count::<WorldBorderInitializeS2c>(1);
+}
+
+fn prepare(mut app: &mut App) -> (MockClientHelper, Entity) {
+    let (_, mut client_helper) = scenario_single_client(&mut app);
+
+    // Process a tick to get past the "on join" logic.
+    app.update();
+    client_helper.clear_sent();
+
+    // Get the instance entity.
+    let instance_ent = app
+        .world
+        .iter_entities()
+        .find(|e| e.contains::<Instance>())
+        .expect("could not find instance")
+        .id();
+
+    // Insert a the world border bundle to the instance.
+    app.world
+        .entity_mut(instance_ent)
+        .insert(WorldBorderBundle::new([0.0, 0.0], 10.0));
+    for _ in 0..2 {
+        app.update();
+    }
+
+    client_helper.clear_sent();
+    return (client_helper, instance_ent);
+}

crates/valence_client/src/lib.rs

@@ -90,6 +90,7 @@ pub mod status;
 pub mod teleport;
 pub mod title;
 pub mod weather;
+pub mod world_border;
 
 pub struct ClientPlugin;
 
@@ -150,6 +151,7 @@ impl Plugin for ClientPlugin {
         action::build(app);
         teleport::build(app);
         weather::build(app);
+        world_border::build(app);
         chat::build(app);
         custom_payload::build(app);
         hand_swing::build(app);