Code refactoring, bug fixes

Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 rust-version = "1.83.0"
 
 [dependencies]
-bevy = "0.15.1"
+bevy = { version = "0.15.1", features = ["dynamic_linking"] }
 bevy_fps_controller = "0.15.0"
 bevy_mod_raycast = { git = "https://github.com/CuddlyBunion341/bevy_mod_raycast.git", branch = "main" }
 bevy_rapier3d = "0.28.0"

src/client/chat/events.rs

@@ -1,10 +1,10 @@
 use crate::prelude::*;
 
 #[derive(Event)]
-pub struct ChatSyncEvent(pub Vec<lib::ChatMessage>);
+pub struct ChatSyncEvent(pub Vec<ChatMessage>);
 
 #[derive(Event)]
-pub struct SingleChatSendEvent(pub lib::ChatMessage);
+pub struct SingleChatSendEvent(pub ChatMessage);
 
 #[derive(Event)]
 pub struct ChatMessageSendEvent(pub String);

src/client/chat/resources.rs

@@ -2,7 +2,7 @@ use crate::prelude::*;
 
 #[derive(Resource, Default, Debug)]
 pub struct ChatHistory {
-    pub messages: Vec<lib::ChatMessage>,
+    pub messages: Vec<ChatMessage>,
 }
 
 #[derive(Resource, Default)]

src/client/chat/systems.rs

@@ -247,9 +247,9 @@ pub fn focus_chat_system(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::ChatMessage;
     use bevy::ecs::event::Events;
     use chat_events::{ChatClearEvent, SingleChatSendEvent};
-    use rsmc::ChatMessage;
 
     fn get_chat_messages(app: &mut App) -> Vec<String> {
         let mut messages = app

src/client/collider/systems.rs

@@ -39,7 +39,7 @@ pub fn setup_coliders_system(mut commands: Commands) {
 pub fn handle_collider_update_events_system(
     mut collider_grid_events: EventReader<collider_events::ColliderUpdateEvent>,
     mut query: Query<(&mut Transform, &collider_components::BlockCollider)>,
-    mut chunk_manager: ResMut<terrain_resources::ChunkManager>,
+    mut chunk_manager: ResMut<ChunkManager>,
 ) {
     for event in collider_grid_events.read() {
         let event_position = Vec3::new(
@@ -102,7 +102,7 @@ mod tests {
 
         app.add_event::<collider_events::ColliderUpdateEvent>();
         app.add_systems(Update, handle_collider_update_events_system);
-        app.insert_resource(terrain_resources::ChunkManager::new());
+        app.insert_resource(ChunkManager::new());
 
         app.world_mut().spawn((
             Transform {
@@ -123,17 +123,14 @@ mod tests {
         ));
 
         let block = BlockId::Dirt;
-        let mut resource = app
-            .world_mut()
-            .get_resource_mut::<terrain_resources::ChunkManager>()
-            .unwrap();
-        let chunks = terrain_resources::ChunkManager::instantiate_chunks(
+        let mut resource = app.world_mut().get_resource_mut::<ChunkManager>().unwrap();
+        let chunks = ChunkManager::instantiate_chunks(
             Vec3 {
                 x: 0.0,
                 y: 0.0,
                 z: 0.0,
             },
-            1,
+            Vec3::new(1.0, 1.0, 1.0),
         );
         resource.insert_chunks(chunks);
         resource.set_block(

src/client/networking/mod.rs

@@ -1,10 +1,10 @@
 pub mod systems;
 
+use crate::connection_config;
 use bevy_renet::{
     netcode::{ClientAuthentication, NetcodeClientPlugin, NetcodeClientTransport},
     RenetClientPlugin,
 };
-use renet::{ChannelConfig, SendType};
 
 use crate::prelude::*;
 
@@ -15,36 +15,7 @@ impl Plugin for NetworkingPlugin {
     fn build(&self, app: &mut App) {
         app.add_plugins((RenetClientPlugin, NetcodeClientPlugin));
 
-        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()
-        });
+        let client = RenetClient::new(connection_config());
         app.insert_resource(client);
 
         let client_id = rand::random::<u64>();

src/client/networking/systems.rs

@@ -7,7 +7,7 @@ pub fn receive_message_system(
     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_manager: ResMut<ChunkManager>,
     mut chunk_mesh_events: ResMut<Events<terrain_events::ChunkMeshUpdateEvent>>,
     mut chat_events: ResMut<Events<chat_events::ChatSyncEvent>>,
     mut single_chat_events: ResMut<Events<chat_events::SingleChatSendEvent>>,
@@ -16,30 +16,30 @@ pub fn receive_message_system(
     while let Some(message) = client.receive_message(DefaultChannel::ReliableOrdered) {
         match bincode::deserialize(&message) {
             Ok(message) => match message {
-                lib::NetworkingMessage::PlayerJoin(event) => {
+                NetworkingMessage::PlayerJoin(event) => {
                     player_spawn_events.send(remote_player_events::RemotePlayerSpawnedEvent {
                         client_id: event,
                         position: Vec3::ZERO,
                     });
                 }
-                lib::NetworkingMessage::PlayerLeave(event) => {
+                NetworkingMessage::PlayerLeave(event) => {
                     player_despawn_events.send(remote_player_events::RemotePlayerDespawnedEvent {
                         client_id: event,
                     });
                 }
-                lib::NetworkingMessage::BlockUpdate { position, block } => {
+                NetworkingMessage::BlockUpdate { position, block } => {
                     debug!("Client received block update message: {:?}", position);
                     block_update_events.send(terrain_events::BlockUpdateEvent {
                         position,
                         block,
                         from_network: true,
                     });
                 }
-                lib::NetworkingMessage::ChatMessageSync(messages) => {
+                NetworkingMessage::ChatMessageSync(messages) => {
                     info!("Client received {} chat messages", messages.len());
                     chat_events.send(chat_events::ChatSyncEvent(messages));
                 }
-                lib::NetworkingMessage::SingleChatMessageSync(message) => {
+                NetworkingMessage::SingleChatMessageSync(message) => {
                     info!("Client received chat message {}", message.message);
                     single_chat_events.send(chat_events::SingleChatSendEvent(message));
                 }
@@ -64,7 +64,7 @@ pub fn receive_message_system(
         if let Ok(message) = message {
             debug!("Received message: {:?}", message);
             match message {
-                lib::NetworkingMessage::ChunkBatchResponse(chunks) => {
+                NetworkingMessage::ChunkBatchResponse(chunks) => {
                     info!("Client received chunk batch response message.");
                     for chunk in chunks {
                         info!(
@@ -87,7 +87,7 @@ pub fn receive_message_system(
                         }
                     }
                 }
-                lib::NetworkingMessage::PlayerSync(event) => {
+                NetworkingMessage::PlayerSync(event) => {
                     player_sync_events
                         .send(remote_player_events::RemotePlayerSyncEvent { players: event });
                 }

src/client/player/systems/network.rs

@@ -12,13 +12,13 @@ pub fn broadcast_player_attributes_system(
     let (_, transform) = query.single();
     let (_, _, camera_transform) = camera_query.single();
 
-    let player_state = lib::PlayerState {
+    let player_state = PlayerState {
         position: transform.translation,
         rotation: camera_transform.rotation,
     };
 
     client.send_message(
         DefaultChannel::ReliableUnordered,
-        bincode::serialize(&lib::NetworkingMessage::PlayerUpdate(player_state)).unwrap(),
+        bincode::serialize(&NetworkingMessage::PlayerUpdate(player_state)).unwrap(),
     );
 }

src/client/player/systems/terrain.rs

@@ -1,7 +1,7 @@
 use crate::prelude::*;
 
 pub fn handle_block_update_events(
-    mut chunk_manager: ResMut<terrain_resources::ChunkManager>,
+    mut chunk_manager: ResMut<ChunkManager>,
     mut block_update_events: EventReader<terrain_events::BlockUpdateEvent>,
     mut chunk_mesh_update_events: EventWriter<terrain_events::ChunkMeshUpdateEvent>,
     mut player_collider_events: EventWriter<player_events::PlayerColliderUpdateEvent>,

src/client/prelude.rs

@@ -31,9 +31,11 @@ pub use renet::{ClientId, ConnectionConfig, DefaultChannel, RenetClient};
 
 // other crates
 pub use iyes_perf_ui::prelude::*;
+pub use rayon::iter::IntoParallelIterator;
+pub use rayon::iter::IntoParallelRefMutIterator;
+pub use rayon::iter::ParallelIterator;
 pub use serde::*;
 
-pub use self::lib::Chunk;
 pub use self::terrain_util::Block;
 pub use bevy::render::mesh::{Indices, PrimitiveTopology};
 pub use bevy::render::render_asset::RenderAssetUsages;
@@ -43,10 +45,8 @@ pub use terrain_util::CubeFace;
 
 // my crates
 pub use crate::states::GameState;
+pub use lib::*;
 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;

src/client/remote_player/events.rs

@@ -13,5 +13,5 @@ pub struct RemotePlayerDespawnedEvent {
 
 #[derive(Event)]
 pub struct RemotePlayerSyncEvent {
-    pub players: HashMap<ClientId, lib::PlayerState>,
+    pub players: HashMap<ClientId, PlayerState>,
 }

src/client/terrain/mod.rs

@@ -11,7 +11,7 @@ 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(ChunkManager::new());
         app.insert_resource(terrain_resources::SpawnAreaLoaded(false));
         app.insert_resource(util::TextureManager::new());
         app.add_event::<terrain_events::BlockUpdateEvent>();