reorganize code

src/config.rs

+// execute update code 60x per seconds
+pub const TARGET_FPS: u32 = 60;
+// execute meta code each 20 frames
+pub const META_EACH: u32 = 20;
+// execute physics code each 10 frames
+pub const PHYSICS_EACH: u32 = 10;
+// execute animate code each 30 frames
+pub const ANIMATE_EACH: u32 = 60;
+// change sprite animation tile 30 frames
+pub const SPRITE_EACH: u32 = 10;
+// max of frame_i used to calculate ticks
+pub const MAX_FRAME_I: u32 = 4294967295;
+// pixel offset by tick when player move screen display
+pub const DISPLAY_OFFSET_BY: f32 = 3.0;
+// pixel offset by tick when player move screen display with speed
+pub const DISPLAY_OFFSET_BY_SPEED: f32 = 10.0;
+// Width of sprite sheet
+pub const SCENE_ITEMS_SPRITE_SHEET_WIDTH: f32 = 800.0;
+// Height of sprite sheet
+pub const SCENE_ITEMS_SPRITE_SHEET_HEIGHT: f32 = 600.0;
+// Width of sprite sheet
+pub const UI_SPRITE_SHEET_WIDTH: f32 = 800.0;
+// Height of sprite sheet
+pub const UI_SPRITE_SHEET_HEIGHT: f32 = 600.0;
+// Width of one grid tile
+pub const GRID_TILE_WIDTH: f32 = 5.0;
+// Height of one grid tile
+pub const GRID_TILE_HEIGHT: f32 = 5.0;
+//
+pub const DEFAULT_SELECTED_SQUARE_SIDE: f32 = 14.0;
+//
+pub const DEFAULT_SELECTED_SQUARE_SIDE_HALF: f32 = DEFAULT_SELECTED_SQUARE_SIDE / 2.0;
+//
+pub const SCENE_ITEMS_CHANGE_ERR_MSG: &str = "scene_items content change !";
+//
+pub const DEBUG: bool = true;

src/main.rs

 use std::env;
 use std::path;
 
-use scene::main::MainState;
-
 use ggez::{event, GameResult};
 use glam::Vec2;
 
+use scene::main::MainState;
+
 mod behavior;
+mod config;
 mod physics;
 mod scene;
 mod ui;
 type ScenePoint = Vec2;
 type Vector2 = Vec2;
 
-const TARGET_FPS: u32 = 60; // execute update code 60x per seconds
-const META_EACH: u32 = 20; // execute meta code each 20 frames
-const PHYSICS_EACH: u32 = 10; // execute physics code each 10 frames
-const ANIMATE_EACH: u32 = 60; // execute animate code each 30 frames
-const SPRITE_EACH: u32 = 10; // change sprite animation tile 30 frames
-const MAX_FRAME_I: u32 = 4294967295; // max of frame_i used to calculate ticks
-const DISPLAY_OFFSET_BY: f32 = 3.0; // pixel offset by tick when player move screen display
-const DISPLAY_OFFSET_BY_SPEED: f32 = 10.0; // pixel offset by tick when player move screen display with speed
-const SCENE_ITEMS_SPRITE_SHEET_WIDTH: f32 = 800.0; // Width of sprite sheet
-const SCENE_ITEMS_SPRITE_SHEET_HEIGHT: f32 = 600.0; // Height of sprite sheet
-const UI_SPRITE_SHEET_WIDTH: f32 = 800.0; // Width of sprite sheet
-const UI_SPRITE_SHEET_HEIGHT: f32 = 600.0; // Height of sprite sheet
-const GRID_TILE_WIDTH: f32 = 5.0; // Width of one grid tile
-const GRID_TILE_HEIGHT: f32 = 5.0; // Height of one grid tile
-const DEFAULT_SELECTED_SQUARE_SIDE: f32 = 14.0;
-const DEFAULT_SELECTED_SQUARE_SIDE_HALF: f32 = DEFAULT_SELECTED_SQUARE_SIDE / 2.0;
-const SCENE_ITEMS_CHANGE_ERR_MSG: &str = "scene_items content change !";
-
 pub fn main() -> GameResult {
     let resource_dir = if let Ok(manifest_dir) = env::var("CARGO_MANIFEST_DIR") {
         let mut path = path::PathBuf::from(manifest_dir);

src/physics/util.rs

+use crate::config::{GRID_TILE_HEIGHT, GRID_TILE_WIDTH};
 use crate::physics::GridPosition;
-use crate::{ScenePoint, Vector2, WindowPoint, GRID_TILE_HEIGHT, GRID_TILE_WIDTH};
+use crate::{ScenePoint, Vector2, WindowPoint};
 
 pub fn vec_from_angle(angle: f32) -> Vector2 {
     let vx = angle.sin();

src/scene/item.rs

 use ggez::graphics;
 
 use crate::behavior::ItemBehavior;
+use crate::config::{SCENE_ITEMS_SPRITE_SHEET_HEIGHT, SCENE_ITEMS_SPRITE_SHEET_WIDTH};
 use crate::physics::GridPosition;
 use crate::physics::{util, MetaEvent};
 use crate::scene::SpriteType;
-use crate::{
-    Offset, Point2, ScenePoint, SCENE_ITEMS_SPRITE_SHEET_HEIGHT, SCENE_ITEMS_SPRITE_SHEET_WIDTH,
-};
+use crate::{Offset, Point2, ScenePoint};
 
 pub struct SceneItemSpriteInfo {
     pub relative_start_y: f32,

src/scene/main.rs

 
 use ggez::event::MouseButton;
 use ggez::graphics::{DrawMode, MeshBuilder, StrokeOptions};
+use ggez::input::keyboard::KeyCode;
 use ggez::timer::check_update_time;
 use ggez::{event, graphics, input, Context, GameResult};
 
 use crate::behavior::ItemBehavior;
+use crate::config::{
+    ANIMATE_EACH, DEBUG, DEFAULT_SELECTED_SQUARE_SIDE, DEFAULT_SELECTED_SQUARE_SIDE_HALF,
+    DISPLAY_OFFSET_BY, DISPLAY_OFFSET_BY_SPEED, MAX_FRAME_I, META_EACH, PHYSICS_EACH,
+    SCENE_ITEMS_CHANGE_ERR_MSG, SPRITE_EACH, TARGET_FPS,
+};
 use crate::physics::util::scene_point_from_window_point;
 use crate::physics::util::window_point_from_scene_point;
 use crate::physics::GridPosition;
 use crate::scene::item::{ItemState, SceneItem, SceneItemType};
 use crate::ui::scene_item_menu::SceneItemMenuItem;
 use crate::ui::{SceneItemPrepareOrder, UiItem, UiSpriteInfo, UserEvent};
-use crate::{
-    Offset, ScenePoint, WindowPoint, ANIMATE_EACH, DEFAULT_SELECTED_SQUARE_SIDE,
-    DEFAULT_SELECTED_SQUARE_SIDE_HALF, DISPLAY_OFFSET_BY, DISPLAY_OFFSET_BY_SPEED, MAX_FRAME_I,
-    META_EACH, PHYSICS_EACH, SCENE_ITEMS_CHANGE_ERR_MSG, SPRITE_EACH, TARGET_FPS,
-};
-use ggez::input::keyboard::KeyCode;
+use crate::{Offset, ScenePoint, WindowPoint};
 
 pub struct MainState {
     // time
 
         selection
     }
+
+    fn build_scene_items_draw_params(&self) -> Vec<graphics::DrawParam> {
+        let mut draw_params = vec![];
+
+        for scene_item in self.scene_items.iter() {
+            draw_params.push(
+                scene_item
+                    .as_draw_param(scene_item.current_frame as f32)
+                    .dest(scene_item.position.clone()),
+            )
+        }
+
+        draw_params
+    }
+
+    fn update_mesh_builder_with_scene_items_positions(
+        &self,
+        mut mesh_builder: MeshBuilder,
+    ) -> GameResult<MeshBuilder> {
+        for scene_item in self.scene_items.iter() {
+            mesh_builder.circle(
+                DrawMode::fill(),
+                scene_item.position.clone(),
+                2.0,
+                2.0,
+                graphics::WHITE,
+            )?;
+        }
+
+        GameResult::Ok(mesh_builder)
+    }
+
+    fn update_mesh_builder_with_selected_items(
+        &self,
+        mut mesh_builder: MeshBuilder,
+    ) -> GameResult<MeshBuilder> {
+        for i in &self.selected_scene_items {
+            let selected_scene_item = self.scene_items.get(*i).expect(SCENE_ITEMS_CHANGE_ERR_MSG);
+            mesh_builder.rectangle(
+                DrawMode::Stroke(StrokeOptions::default()),
+                graphics::Rect::new(
+                    selected_scene_item.position.x - DEFAULT_SELECTED_SQUARE_SIDE_HALF,
+                    selected_scene_item.position.y - DEFAULT_SELECTED_SQUARE_SIDE_HALF,
+                    DEFAULT_SELECTED_SQUARE_SIDE,
+                    DEFAULT_SELECTED_SQUARE_SIDE,
+                ),
+                graphics::GREEN,
+            )?;
+        }
+
+        GameResult::Ok(mesh_builder)
+    }
+
+    fn update_mesh_builder_with_selection_area(
+        &self,
+        mut mesh_builder: MeshBuilder,
+        window_left_click_down_point: WindowPoint,
+    ) -> GameResult<MeshBuilder> {
+        let scene_left_click_down_point =
+            scene_point_from_window_point(&window_left_click_down_point, &self.display_offset);
+        let scene_current_cursor_position =
+            scene_point_from_window_point(&self.current_cursor_position, &self.display_offset);
+        if scene_left_click_down_point != scene_current_cursor_position {
+            mesh_builder.rectangle(
+                DrawMode::stroke(1.0),
+                graphics::Rect::new(
+                    scene_left_click_down_point.x,
+                    scene_left_click_down_point.y,
+                    scene_current_cursor_position.x - scene_left_click_down_point.x,
+                    scene_current_cursor_position.y - scene_left_click_down_point.y,
+                ),
+                graphics::GREEN,
+            )?;
+        }
+
+        GameResult::Ok(mesh_builder)
+    }
 }
 
 impl event::EventHandler for MainState {
 
     fn draw(&mut self, ctx: &mut Context) -> GameResult {
         graphics::clear(ctx, graphics::BLACK);
-
         let mut scene_mesh_builder = MeshBuilder::new();
 
-        for scene_item in self.scene_items.iter() {
-            self.sprite_sheet_batch.add(
-                scene_item
-                    .as_draw_param(scene_item.current_frame as f32)
-                    .dest(scene_item.position.clone()),
-            );
-            scene_mesh_builder.circle(
-                DrawMode::fill(),
-                scene_item.position.clone(),
-                2.0,
-                2.0,
-                graphics::WHITE,
-            )?;
+        for sprite in self.build_scene_items_draw_params() {
+            self.sprite_sheet_batch.add(sprite);
         }
 
-        for i in &self.selected_scene_items {
-            let selected_scene_item = self.scene_items.get(*i).expect(SCENE_ITEMS_CHANGE_ERR_MSG);
-            scene_mesh_builder.rectangle(
-                DrawMode::Stroke(StrokeOptions::default()),
-                graphics::Rect::new(
-                    selected_scene_item.position.x - DEFAULT_SELECTED_SQUARE_SIDE_HALF,
-                    selected_scene_item.position.y - DEFAULT_SELECTED_SQUARE_SIDE_HALF,
-                    DEFAULT_SELECTED_SQUARE_SIDE,
-                    DEFAULT_SELECTED_SQUARE_SIDE,
-                ),
-                graphics::GREEN,
-            )?;
+        if DEBUG {
+            scene_mesh_builder =
+                self.update_mesh_builder_with_scene_items_positions(scene_mesh_builder)?;
         }
 
+        scene_mesh_builder = self.update_mesh_builder_with_selected_items(scene_mesh_builder)?;
+
         if let Some(window_left_click_down_point) = self.left_click_down {
-            let scene_left_click_down_point =
-                scene_point_from_window_point(&window_left_click_down_point, &self.display_offset);
-            let scene_current_cursor_position =
-                scene_point_from_window_point(&self.current_cursor_position, &self.display_offset);
-            if scene_left_click_down_point != scene_current_cursor_position {
-                scene_mesh_builder.rectangle(
+            scene_mesh_builder = self.update_mesh_builder_with_selection_area(
+                scene_mesh_builder,
+                window_left_click_down_point,
+            )?;
+
+            if DEBUG {
+                let scene_left_click_down_point = scene_point_from_window_point(
+                    &window_left_click_down_point,
+                    &self.display_offset,
+                );
+                scene_mesh_builder.circle(
                     DrawMode::fill(),
-                    graphics::Rect::new(
-                        scene_left_click_down_point.x,
-                        scene_left_click_down_point.y,
-                        scene_current_cursor_position.x - scene_left_click_down_point.x,
-                        scene_current_cursor_position.y - scene_left_click_down_point.y,
-                    ),
-                    graphics::GREEN,
+                    scene_left_click_down_point,
+                    2.0,
+                    2.0,
+                    graphics::YELLOW,
                 )?;
             }
-
-            scene_mesh_builder.circle(
-                DrawMode::fill(),
-                scene_left_click_down_point,
-                2.0,
-                2.0,
-                graphics::YELLOW,
-            )?;
         }
 
         scene_mesh_builder.circle(

src/ui/mod.rs

 use ggez::graphics;
 
+use crate::config::{UI_SPRITE_SHEET_HEIGHT, UI_SPRITE_SHEET_WIDTH};
 use crate::scene::item::SceneItem;
 use crate::ui::scene_item_menu::SceneItemMenuItem;
-use crate::{Point2, WindowPoint, UI_SPRITE_SHEET_HEIGHT, UI_SPRITE_SHEET_WIDTH};
+use crate::{Point2, WindowPoint};
 
 pub mod scene_item_menu;