reorganize code:

- move reticle.rs to hud folder
- move block destruction logic to player module
- move mouse capturing logic to input module
- add debug folder in hud module

Author: eztaah

get_source.py

@@ -1,5 +1,6 @@
 #!/bin/python
 import os
+import argparse
 
 def collect_rust_files(directory, output_file):
     with open(output_file, 'w') as outfile:
@@ -13,8 +14,15 @@ def collect_rust_files(directory, output_file):
                     outfile.write("\n\n") 
 
 if __name__ == "__main__":
-    source_directory = "./src"
-    output_file = "source_code.txt"
+    parser = argparse.ArgumentParser(description="Collect Rust source files from a directory.")
+    parser.add_argument("directory", help="The path to the source directory.")
+    parser.add_argument("-o", "--output", default="source_code.txt", help="The output file (default: source_code.txt)")
+
+    args = parser.parse_args()
+
+    source_directory = args.directory
+    output_file = args.output
 
     collect_rust_files(source_directory, output_file)
-    print(f"source code collected in {output_file}")
+    print(f"Source code collected in {output_file}")
+

src/camera/cursor.rs

@@ -1,7 +1,3 @@
 mod controller;
-mod cursor;
-mod reticle;
 
 pub use controller::*;
-pub use cursor::*;
-pub use reticle::*;

src/camera/mod.rs

@@ -0,0 +1,14 @@
+pub mod blocks;
+pub mod chunks;
+pub mod coords;
+pub mod fps;
+mod loaded_stats;
+pub mod setup;
+pub mod targeted_block;
+
+pub use blocks::*;
+pub use chunks::*;
+pub use coords::*;
+pub use fps::*;
+pub use loaded_stats::*;
+pub use setup::*;

src/debug/mod.rs

@@ -1,6 +1,6 @@
-use crate::hud::block::BlockText;
-use crate::hud::loaded_stats::{BlocksNumberText, ChunksNumberText};
-use crate::hud::{CoordsText, FpsText};
+use crate::hud::debug::loaded_stats::{BlocksNumberText, ChunksNumberText};
+use crate::hud::debug::targeted_block::BlockText;
+use crate::hud::debug::{CoordsText, FpsText};
 use crate::input::keyboard::{get_action_keys, GameAction};
 use bevy::prelude::*;
 

src/debug/blocks.rs renamed to src/hud/debug/blocks.rs

@@ -1,10 +1,4 @@
-pub mod block;
-pub mod coords;
 pub mod debug;
-pub mod fps;
-mod loaded_stats;
+pub mod reticle;
 
-pub use coords::*;
-pub use debug::*;
-pub use fps::*;
-pub use loaded_stats::*;
+pub use reticle::*;

src/debug/chunks.rs renamed to src/hud/debug/chunks.rs

@@ -1,106 +1,20 @@
-use crate::constants::{CUBE_SIZE, INTERACTION_DISTANCE};
-use crate::player::inventory::*;
 use crate::player::Player;
-use crate::{items, UIMode};
-use crate::world::WorldMap;
-use crate::world::WorldRenderRequestUpdateEvent;
-use crate::camera::*;
-use bevy::math::NormedVectorSpace;
+use crate::UIMode;
 use bevy::prelude::*;
-use bevy_mod_raycast::prelude::*;
+use bevy::window::{CursorGrabMode, PrimaryWindow};
 
-// Helper function to snap a Vec3 position to the grid
-fn snap_to_grid(position: Vec3) -> Vec3 {
-    Vec3::new(position.x.round(), position.y.round(), position.z.round())
+// System to hide and lock the cursor
+pub fn mouse_grab_system(mut windows: Query<&mut Window, With<PrimaryWindow>>) {
+    let mut window = windows.single_mut();
+    window.cursor.visible = false;
+    window.cursor.grab_mode = CursorGrabMode::Locked;
 }
 
-// Function to handle block placement and breaking
-pub fn handle_block_interactions(
-    mut player: Query<&mut Player>,
-    mut p_transform: Query<&mut Transform, With<Player>>,
-    mouse_input: Res<ButtonInput<MouseButton>>, // to handle mouse input
-    raycast_source: Query<&RaycastSource<BlockRaycastSet>>, // raycast from the camera
-    mut world_map: ResMut<WorldMap>,
-    mut ev_render: EventWriter<WorldRenderRequestUpdateEvent>,
+pub fn set_mouse_visibility(
+    mut windows: Query<&mut Window, With<PrimaryWindow>>,
+    player: Query<&Player>,
 ) {
-    if player.single().ui_mode == UIMode::Opened {
-        return;
-    }
-
-    let raycast_source = raycast_source.single();
-
-    // Handle left-click for breaking blocks
-    if mouse_input.just_pressed(MouseButton::Left) {
-        // Check if there are any intersections with a block
-        if let Some((_, intersection)) = raycast_source.intersections().first() {
-            // Check if block is close enough to the player
-            if (intersection.position() - p_transform.single_mut().translation).norm()
-                < INTERACTION_DISTANCE
-            {
-                let block_pos = intersection.position() - intersection.normal() * (CUBE_SIZE / 2.);
-                let global_block_coords = IVec3::new(
-                    block_pos.x.floor() as i32,
-                    block_pos.y.floor() as i32,
-                    block_pos.z.floor() as i32,
-                );
-
-                // Remove the hit block
-                let block = world_map.remove_block_by_coordinates(&global_block_coords);
-
-                if let Some(block) = block {
-                    // add the block to the player's inventory
-                    let item_type = items::item_from_block(block);
-                    // If block has corresponding item, add it to inventory
-                    if let Some(item_type) = item_type {
-                        add_item_to_inventory(&mut player, item_type, 1);
-                    }
-
-                    ev_render.send(WorldRenderRequestUpdateEvent::BlockToReload(
-                        global_block_coords,
-                    ));
-                }
-            }
-        }
-    }
-
-    // Handle right-click for placing blocks
-    if mouse_input.just_pressed(MouseButton::Right) {
-        if let Some((_entity, intersection)) = raycast_source.intersections().first() {
-            let block_pos = intersection.position() - intersection.normal() * (CUBE_SIZE / 2.);
-            let global_block_coords = IVec3::new(
-                block_pos.x.floor() as i32,
-                block_pos.y.floor() as i32,
-                block_pos.z.floor() as i32,
-            );
-
-            // Get the normal of the face where the block will be placed
-            let normal = intersection.normal(); // This is already a Vec3, no need to unwrap
-                                                // Calculate the block position by adding a small offset to the intersection point
-            let mut position = global_block_coords.as_vec3() + normal * 0.51;
-            // Snap the position to the grid
-            position = snap_to_grid(position);
-
-            // Check if target space is close enough to the player
-            // Guarantees a block cannot be placed too close to the player (which would be unable to move because of constant collision)
-            if (intersection.position() - p_transform.single_mut().translation).norm()
-                <= INTERACTION_DISTANCE
-                && (position - p_transform.single_mut().translation).norm() >= CUBE_SIZE
-            {
-                let item_type = items::ItemsType::Dirt;
-                // Check if the block is in the player's inventory
-                if has_item(&mut player, item_type) {
-                    // Remove the block from the player's inventory
-                    remove_item_from_inventory(&mut player, item_type, 1);
-                } else {
-                    return;
-                }
-
-                let block_pos = IVec3::new(position.x as i32, position.y as i32, position.z as i32);
-
-                world_map.set_block(&block_pos, items::block_from_item(item_type).unwrap());
-
-                ev_render.send(WorldRenderRequestUpdateEvent::BlockToReload(block_pos));
-            }
-        }
-    }
+    let mut window = windows.single_mut();
+    let player = player.single();
+    window.cursor.visible = player.ui_mode == UIMode::Opened;
 }

src/hud/coords.rs renamed to src/hud/debug/coords.rs

@@ -1,3 +1,4 @@
+use crate::debug::BlockDebugWireframeSettings;
 use bevy::color::palettes::basic::WHITE;
 use bevy::diagnostic::FrameTimeDiagnosticsPlugin;
 use bevy::pbr::wireframe::{WireframeConfig, WireframePlugin};
@@ -6,12 +7,12 @@ use bevy::render::render_resource::WgpuFeatures;
 use bevy::render::settings::{RenderCreation, WgpuSettings};
 use bevy::render::RenderPlugin;
 use bevy_mod_raycast::deferred::DeferredRaycastingPlugin;
-use block::block_text_update_system;
+use debug::targeted_block::block_text_update_system;
 use lighting::setup_main_lighting;
 
 use camera::*;
-use debug::*;
 use exit::*;
+use hud::debug::*;
 use hud::*;
 use input::*;
 use lighting::*;
@@ -20,7 +21,6 @@ use ui::inventory::*;
 use world::*;
 mod camera;
 mod constants;
-mod debug;
 mod exit;
 mod hud;
 mod input;
@@ -79,7 +79,7 @@ fn main() {
         .add_systems(Startup, spawn_reticle)
         .add_systems(Startup, setup_hud)
         .add_systems(Startup, setup_inventory)
-        .add_systems(Startup, cursor_grab_system)
+        .add_systems(Startup, mouse_grab_system)
         .add_systems(Startup, setup_chunk_ghost)
         .add_systems(Update, toggle_inventory)
         .add_systems(Update, set_ui_mode)
@@ -99,7 +99,7 @@ fn main() {
         .add_systems(Update, exit_system)
         .add_systems(Update, toggle_wireframe_system)
         .add_systems(Update, world_render_system)
-        .add_systems(Update, set_cursor_visibility)
+        .add_systems(Update, set_mouse_visibility)
         .add_systems(Update, inventory_cell_interaction_system)
         .add_systems(Update, update_celestial_bodies)
         .run();

src/hud/fps.rs renamed to src/hud/debug/fps.rs

@@ -2,8 +2,8 @@ use crate::camera::CameraController;
 use crate::constants::GRAVITY;
 use crate::input::keyboard::*;
 use crate::player::{Player, ViewMode};
-use crate::UIMode;
 use crate::world::{load_chunk_around_player, WorldMap, WorldRenderRequestUpdateEvent, WorldSeed};
+use crate::UIMode;
 use bevy::prelude::*;
 
 fn is_block_at_position(position: Vec3, world_map: &WorldMap) -> bool {

src/hud/loaded_stats.rs renamed to src/hud/debug/loaded_stats.rs

@@ -0,0 +1,106 @@
+use crate::camera::*;
+use crate::constants::{CUBE_SIZE, INTERACTION_DISTANCE};
+use crate::player::inventory::*;
+use crate::player::Player;
+use crate::world::WorldMap;
+use crate::world::WorldRenderRequestUpdateEvent;
+use crate::{items, UIMode};
+use bevy::math::NormedVectorSpace;
+use bevy::prelude::*;
+use bevy_mod_raycast::prelude::*;
+
+// Helper function to snap a Vec3 position to the grid
+fn snap_to_grid(position: Vec3) -> Vec3 {
+    Vec3::new(position.x.round(), position.y.round(), position.z.round())
+}
+
+// Function to handle block placement and breaking
+pub fn handle_block_interactions(
+    mut player: Query<&mut Player>,
+    mut p_transform: Query<&mut Transform, With<Player>>,
+    mouse_input: Res<ButtonInput<MouseButton>>, // to handle mouse input
+    raycast_source: Query<&RaycastSource<BlockRaycastSet>>, // raycast from the camera
+    mut world_map: ResMut<WorldMap>,
+    mut ev_render: EventWriter<WorldRenderRequestUpdateEvent>,
+) {
+    if player.single().ui_mode == UIMode::Opened {
+        return;
+    }
+
+    let raycast_source = raycast_source.single();
+
+    // Handle left-click for breaking blocks
+    if mouse_input.just_pressed(MouseButton::Left) {
+        // Check if there are any intersections with a block
+        if let Some((_, intersection)) = raycast_source.intersections().first() {
+            // Check if block is close enough to the player
+            if (intersection.position() - p_transform.single_mut().translation).norm()
+                < INTERACTION_DISTANCE
+            {
+                let block_pos = intersection.position() - intersection.normal() * (CUBE_SIZE / 2.);
+                let global_block_coords = IVec3::new(
+                    block_pos.x.floor() as i32,
+                    block_pos.y.floor() as i32,
+                    block_pos.z.floor() as i32,
+                );
+
+                // Remove the hit block
+                let block = world_map.remove_block_by_coordinates(&global_block_coords);
+
+                if let Some(block) = block {
+                    // add the block to the player's inventory
+                    let item_type = items::item_from_block(block);
+                    // If block has corresponding item, add it to inventory
+                    if let Some(item_type) = item_type {
+                        add_item_to_inventory(&mut player, item_type, 1);
+                    }
+
+                    ev_render.send(WorldRenderRequestUpdateEvent::BlockToReload(
+                        global_block_coords,
+                    ));
+                }
+            }
+        }
+    }
+
+    // Handle right-click for placing blocks
+    if mouse_input.just_pressed(MouseButton::Right) {
+        if let Some((_entity, intersection)) = raycast_source.intersections().first() {
+            let block_pos = intersection.position() - intersection.normal() * (CUBE_SIZE / 2.);
+            let global_block_coords = IVec3::new(
+                block_pos.x.floor() as i32,
+                block_pos.y.floor() as i32,
+                block_pos.z.floor() as i32,
+            );
+
+            // Get the normal of the face where the block will be placed
+            let normal = intersection.normal(); // This is already a Vec3, no need to unwrap
+                                                // Calculate the block position by adding a small offset to the intersection point
+            let mut position = global_block_coords.as_vec3() + normal * 0.51;
+            // Snap the position to the grid
+            position = snap_to_grid(position);
+
+            // Check if target space is close enough to the player
+            // Guarantees a block cannot be placed too close to the player (which would be unable to move because of constant collision)
+            if (intersection.position() - p_transform.single_mut().translation).norm()
+                <= INTERACTION_DISTANCE
+                && (position - p_transform.single_mut().translation).norm() >= CUBE_SIZE
+            {
+                let item_type = items::ItemsType::Dirt;
+                // Check if the block is in the player's inventory
+                if has_item(&mut player, item_type) {
+                    // Remove the block from the player's inventory
+                    remove_item_from_inventory(&mut player, item_type, 1);
+                } else {
+                    return;
+                }
+
+                let block_pos = IVec3::new(position.x as i32, position.y as i32, position.z as i32);
+
+                world_map.set_block(&block_pos, items::block_from_item(item_type).unwrap());
+
+                ev_render.send(WorldRenderRequestUpdateEvent::BlockToReload(block_pos));
+            }
+        }
+    }
+}

src/hud/debug/mod.rs

@@ -1,9 +1,9 @@
 use crate::constants::MAX_ITEM_SLOTS;
 use crate::constants::MAX_ITEM_STACK;
 use crate::player::Player;
-use bevy::prelude::*;
 use crate::ui::inventory::items;
 use crate::ui::inventory::items::Item;
+use bevy::prelude::*;
 
 // Ajoute un item à l'inventaire du joueur
 pub fn add_item_to_inventory(