Drop lib namespacec in subsystems

Author: CuddlyBunion341

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

@@ -43,7 +43,7 @@ pub fn send_messages_system(
 
         client.send_message(
             DefaultChannel::ReliableOrdered,
-            bincode::serialize(&lib::NetworkingMessage::ChatMessageSend(message)).unwrap(),
+            bincode::serialize(&NetworkingMessage::ChatMessageSend(message)).unwrap(),
         );
     }
 }
@@ -249,7 +249,7 @@ mod tests {
     use super::*;
     use bevy::ecs::event::Events;
     use chat_events::{ChatClearEvent, SingleChatSendEvent};
-    use crate::lib::ChatMessage;
+    use crate::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<lib::ChunkManager>,
+    mut chunk_manager: ResMut<ChunkManager>,
 ) {
     for event in collider_grid_events.read() {
         let event_position = Vec3::new(
@@ -56,7 +56,7 @@ pub fn handle_collider_update_events_system(
 
             match block {
                 Some(block) => {
-                    if block != lib::BlockId::Air {
+                    if block != BlockId::Air {
                         transform.translation = collider_position + COLLIDER_CUBOID_WIDTH / 2.0;
                     } else {
                         transform.translation = COLLIDER_RESTING_POSITION;
@@ -102,7 +102,7 @@ mod tests {
 
         app.add_event::<collider_events::ColliderUpdateEvent>();
         app.add_systems(Update, handle_collider_update_events_system);
-        app.insert_resource(lib::ChunkManager::new());
+        app.insert_resource(ChunkManager::new());
 
         app.world_mut().spawn((
             Transform {
@@ -122,12 +122,12 @@ mod tests {
             },
         ));
 
-        let block = lib::BlockId::Dirt;
+        let block = BlockId::Dirt;
         let mut resource = app
             .world_mut()
-            .get_resource_mut::<lib::ChunkManager>()
+            .get_resource_mut::<ChunkManager>()
             .unwrap();
-        let chunks = lib::ChunkManager::instantiate_chunks(
+        let chunks = ChunkManager::instantiate_chunks(
             Vec3 {
                 x: 0.0,
                 y: 0.0,

src/client/networking/mod.rs

@@ -4,7 +4,7 @@ use bevy_renet::{
     netcode::{ClientAuthentication, NetcodeClientPlugin, NetcodeClientTransport},
     RenetClientPlugin,
 };
-use crate::lib::connection_config;
+use crate::connection_config;
 
 use crate::prelude::*;
 

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<lib::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/mouse.rs

@@ -40,13 +40,13 @@ pub fn handle_mouse_events_system(
         if event.button == MouseButton::Left && event.state.is_pressed() {
             block_update_events.send(terrain_events::BlockUpdateEvent {
                 position,
-                block: lib::BlockId::Air,
+                block: BlockId::Air,
                 from_network: false,
             });
         } else if event.button == MouseButton::Right && event.state.is_pressed() {
             block_update_events.send(terrain_events::BlockUpdateEvent {
                 position: position + normal,
-                block: lib::BlockId::Dirt,
+                block: BlockId::Dirt,
                 from_network: false,
             });
         }

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<lib::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>,
@@ -12,7 +12,7 @@ pub fn handle_block_update_events(
         info!("Block update message: {:?}", event.position);
 
         chunk_mesh_update_events.send(terrain_events::ChunkMeshUpdateEvent {
-            position: event.position / lib::CHUNK_SIZE as f32,
+            position: event.position / CHUNK_SIZE as f32,
         });
 
         player_collider_events.send(player_events::PlayerColliderUpdateEvent);
@@ -21,7 +21,7 @@ pub fn handle_block_update_events(
             info!("sending block update event");
             client.send_message(
                 DefaultChannel::ReliableOrdered,
-                bincode::serialize(&lib::NetworkingMessage::BlockUpdate {
+                bincode::serialize(&NetworkingMessage::BlockUpdate {
                     position: event.position,
                     block: event.block,
                 })

src/client/prelude.rs

@@ -46,6 +46,7 @@ pub use terrain_util::CubeFace;
 // my crates
 pub use crate::states::GameState;
 pub use rsmc as lib;
+pub use lib::*;
 
 pub use crate::collider::components as collider_components;
 pub use crate::collider::events as collider_events;