Client / Server refactoring (#17)

* Update server

* Simplify server

* Implement chunk serde serialization

* Implement serverside ChunkRequest event

* Refactor chunk definition

* Fix linter

* Implement chunk response handling (almost)

* Update ChunkResponse message channel_id

* Fix linter, attempt fix max memory

* Attempt update channel configuration

* wip

* Implement chunk batch request

* Attempt fix batches

* Fix merge conflicts

* Fix linter

* Add terrain ready event, refactor

* Refactor

* Rework systems

* Refactor

* Fix linter

Author: CuddlyBunion341

Cargo.lock

@@ -16,8 +16,8 @@ bevy_renet = {version = "0.0.11", features = ["serde"]}
 bincode = "1.3.3"
 rand = "0.8.5"
 renet = "0.0.15"
-serde = "1.0.203"
-serde_repr = "0.1"
+serde = { version = "1.0.203", features = ["derive"] }
+serde-big-array = "0.5.1"
 
 [profile.dev.package."*"]
 opt-level = 3

Cargo.toml

@@ -1,5 +1,7 @@
 pub mod systems;
 
+use renet::{ChannelConfig, SendType};
+
 use crate::prelude::*;
 
 const SERVER_ADDR: &str = "127.0.0.1:5000";
@@ -9,7 +11,36 @@ impl Plugin for NetworkingPlugin {
     fn build(&self, app: &mut App) {
         app.add_plugins((RenetClientPlugin, NetcodeClientPlugin));
 
-        let client = RenetClient::new(ConnectionConfig::default());
+        let channel_config_unreliable = ChannelConfig {
+            channel_id: 0,
+            max_memory_usage_bytes: 1000 * 1024 * 1024,
+            send_type: SendType::Unreliable,
+        };
+
+        let channel_config_reliable_ordered = ChannelConfig {
+            channel_id: 1,
+            max_memory_usage_bytes: 1000 * 1024 * 1024,
+            send_type: SendType::ReliableOrdered {
+                resend_time: Duration::from_millis(300),
+            },
+        };
+
+        let channel_config_reliable_unordered = ChannelConfig {
+            channel_id: 2,
+            max_memory_usage_bytes: 1000 * 1024 * 1024,
+            send_type: SendType::ReliableUnordered {
+                resend_time: Duration::from_millis(300),
+            },
+        };
+
+        let client = RenetClient::new(ConnectionConfig {
+            client_channels_config: Vec::from([
+                channel_config_unreliable,
+                channel_config_reliable_ordered,
+                channel_config_reliable_unordered,
+            ]),
+            ..Default::default()
+        });
         app.insert_resource(client);
 
         let client_id = rand::random::<u64>();

src/client/networking/mod.rs

@@ -1,11 +1,15 @@
 use crate::prelude::*;
 
+#[allow(clippy::too_many_arguments)]
 pub fn receive_message_system(
     mut client: ResMut<RenetClient>,
     mut player_spawn_events: ResMut<Events<remote_player_events::RemotePlayerSpawnedEvent>>,
     mut player_despawn_events: ResMut<Events<remote_player_events::RemotePlayerDespawnedEvent>>,
     mut player_sync_events: ResMut<Events<remote_player_events::RemotePlayerSyncEvent>>,
     mut block_update_events: ResMut<Events<terrain_events::BlockUpdateEvent>>,
+    mut chunk_manager: ResMut<terrain_resources::ChunkManager>,
+    mut chunk_mesh_events: ResMut<Events<terrain_events::ChunkMeshUpdateEvent>>,
+    mut spawn_area_loaded: ResMut<terrain_resources::SpawnAreaLoaded>,
 ) {
     while let Some(message) = client.receive_message(DefaultChannel::ReliableOrdered) {
         let message = bincode::deserialize(&message).unwrap();
@@ -46,6 +50,29 @@ pub fn receive_message_system(
         if let Ok(message) = message {
             debug!("Received message: {:?}", message);
             match message {
+                lib::NetworkingMessage::ChunkBatchResponse(chunks) => {
+                    info!("Client received chunk batch response message.");
+                    for chunk in chunks {
+                        info!(
+                            "Client received chunk response message for: {:?}",
+                            chunk.position
+                        );
+                        let chunk_position = chunk.position;
+                        chunk_manager.insert_chunk(chunk);
+                        chunk_mesh_events.send(terrain_events::ChunkMeshUpdateEvent {
+                            position: chunk_position,
+                        });
+
+                        if chunk_position.eq(&Vec3 {
+                            x: 0.0,
+                            y: 0.0,
+                            z: 0.0,
+                        }) {
+                            info!("Spawn area loaded.");
+                            spawn_area_loaded.0 = true;
+                        }
+                    }
+                }
                 lib::NetworkingMessage::PlayerSync(event) => {
                     player_sync_events
                         .send(remote_player_events::RemotePlayerSyncEvent { players: event });

src/client/networking/systems.rs

@@ -9,11 +9,13 @@ pub struct PlayerPlugin;
 
 impl Plugin for PlayerPlugin {
     fn build(&self, app: &mut App) {
+        debug!("Building PlayerPlugin");
+        info!("Building PlayerPlugin");
         app.add_plugins(FpsControllerPlugin);
         app.add_plugins(RapierPhysicsPlugin::<NoUserData>::default());
         app.add_plugins(RapierDebugRenderPlugin::default());
         app.insert_resource(RapierConfiguration {
-            gravity: Vec3::new(0., -1.6, 0.),
+            gravity: Vec3::new(0., 0.0, 0.),
             physics_pipeline_active: true,
             force_update_from_transform_changes: false,
             scaled_shape_subdivision: 1,
@@ -25,14 +27,21 @@ impl Plugin for PlayerPlugin {
         });
         app.add_event::<player_events::PlayerColliderUpdateEvent>();
         app.insert_resource(player_resources::BlockSelection::new());
+        app.insert_resource(player_resources::PlayerSpawned(false));
         app.insert_resource(player_resources::LastPlayerPosition::new());
         app.add_systems(
             Startup,
             (
-                player_systems::setup_controller_system,
                 player_systems::setup_highlight_cube_system,
+                player_systems::setup_player_camera,
             ),
         );
+        app.add_systems(
+            Update,
+            (player_systems::setup_controller_on_area_ready_system,)
+                .run_if(terrain_resources::SpawnAreaLoaded::is_loaded)
+                .run_if(player_resources::PlayerSpawned::is_not_spawned),
+        );
         app.add_systems(
             Update,
             (
@@ -44,7 +53,8 @@ impl Plugin for PlayerPlugin {
                 player_systems::handle_block_update_events,
                 player_systems::broadcast_player_attributes_system,
                 player_systems::handle_player_collider_events_system,
-            ),
+            )
+                .run_if(player_resources::PlayerSpawned::is_spawned),
         );
     }
 }

src/client/player/mod.rs

@@ -6,6 +6,19 @@ pub struct BlockSelection {
     pub normal: Option<Vec3>,
 }
 
+#[derive(Resource)]
+pub struct PlayerSpawned(pub bool);
+
+impl PlayerSpawned {
+    pub fn is_spawned(resource: Res<PlayerSpawned>) -> bool {
+        resource.0
+    }
+
+    pub fn is_not_spawned(resource: Res<PlayerSpawned>) -> bool {
+        !resource.0
+    }
+}
+
 impl Default for BlockSelection {
     fn default() -> Self {
         Self::new()

src/client/player/resources.rs

@@ -1,10 +1,28 @@
 use crate::prelude::*;
 
-const SPAWN_POINT: Vec3 = Vec3::new(0.0, 20.0, 0.0);
+const SPAWN_POINT: Vec3 = Vec3::new(0.0, 32.0, 0.0);
 
-pub fn setup_controller_system(mut commands: Commands, mut window: Query<&mut Window>) {
-    let mut window = window.single_mut();
-    window.title = String::from("Minimal FPS Controller Example");
+pub fn setup_player_camera(mut commands: Commands) {
+    commands.spawn((
+        Camera3dBundle {
+            projection: Projection::Perspective(PerspectiveProjection {
+                fov: TAU / 5.0,
+                ..default()
+            }),
+            ..default()
+        },
+        RenderPlayer {
+            logical_entity: Entity::from_raw(0),
+        },
+    ));
+}
+
+pub fn setup_controller_on_area_ready_system(
+    mut commands: Commands,
+    mut player_spawned: ResMut<player_resources::PlayerSpawned>,
+    mut render_player: Query<&mut RenderPlayer>,
+) {
+    info!("Setting up controller");
 
     let logical_entity = commands
         .spawn((
@@ -47,16 +65,10 @@ pub fn setup_controller_system(mut commands: Commands, mut window: Query<&mut Wi
         .insert(player_components::Player)
         .id();
 
-    commands.spawn((
-        Camera3dBundle {
-            projection: Projection::Perspective(PerspectiveProjection {
-                fov: TAU / 5.0,
-                ..default()
-            }),
-            ..default()
-        },
-        RenderPlayer { logical_entity },
-    ));
+    let mut player = render_player.single_mut();
+    player.logical_entity = logical_entity;
+
+    player_spawned.0 = true;
 }
 
 pub fn handle_controller_movement_system(

src/client/player/systems/controller.rs

@@ -1,8 +1,8 @@
 // my crates
-pub use crate::terrain::util::chunk::CHUNK_SIZE;
 pub use rsmc as lib;
 pub use rsmc::BlockId;
 pub use rsmc::NetworkingMessage;
+pub use rsmc::CHUNK_SIZE;
 
 pub use crate::collider::components as collider_components;
 pub use crate::collider::events as collider_events;
@@ -64,8 +64,8 @@ pub use iyes_perf_ui::prelude::*;
 pub use iyes_perf_ui::PerfUiCompleteBundle;
 pub use serde::*;
 
+pub use self::lib::Chunk;
 pub use self::terrain_util::Block;
-pub use self::terrain_util::Chunk;
 pub use bevy::render::mesh::{Indices, PrimitiveTopology};
 pub use bevy::render::render_asset::RenderAssetUsages;
 pub use noise::NoiseFn;

src/client/prelude.rs

@@ -10,11 +10,14 @@ pub struct TerrainPlugin;
 
 impl Plugin for TerrainPlugin {
     fn build(&self, app: &mut App) {
+        info!("Building TerrainPlugin");
         app.insert_resource(terrain_resources::ChunkManager::new());
+        app.insert_resource(terrain_resources::SpawnAreaLoaded(false));
         app.insert_resource(util::TextureManager::new());
         app.add_event::<terrain_events::BlockUpdateEvent>();
         app.add_event::<terrain_events::ChunkMeshUpdateEvent>();
-        app.add_systems(Startup, terrain_systems::setup_world_system);
+        app.add_systems(Startup, terrain_systems::prepare_spawn_area_system);
+        app.add_systems(Startup, terrain_systems::generate_world_system);
         app.add_systems(Update, terrain_systems::handle_chunk_mesh_update_events);
     }
 }