normalize point type and fix errors

Cargo.lock

 ]
 
 [[package]]
-name = "ggez_tests"
-version = "0.1.0"
-dependencies = [
- "ggez",
- "glam",
-]
-
-[[package]]
 name = "gif"
 version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "af8b08b04175473088b46763e51ee54da5f9a164bc162f615b91bc179dbf15a3"
 
 [[package]]
+name = "open_combat"
+version = "0.1.0"
+dependencies = [
+ "ggez",
+ "glam",
+]
+
+[[package]]
 name = "ordered-float"
 version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"

Cargo.toml

 [package]
-name = "ggez_tests"
+name = "open_combat"
 version = "0.1.0"
 authors = ["Sevajol Bastien <contact@bux.fr>"]
 edition = "2018"

src/main.rs

 mod scene;
 mod ui;
 
-// TODO: create a ScenePosition and a WindowPosition to be more explicit
 type Point2 = Vec2;
+type WindowPoint = Vec2;
+type Offset = Vec2;
+type ScenePoint = Vec2;
 type Vector2 = Vec2;
 
 const TARGET_FPS: u32 = 60; // execute update code 60x per seconds

src/physics/mod.rs

-pub mod position;
 pub mod util;
 
 #[derive(Debug)]
 pub enum MetaEvent {
     FeelExplosion,
 }
+
+#[derive(Eq, PartialEq, Hash)]
+pub struct GridPosition {
+    x: i32,
+    y: i32,
+}
+
+impl GridPosition {
+    pub fn new(x: i32, y: i32) -> Self {
+        Self { x, y }
+    }
+}

src/physics/position.rs

-#[derive(Eq, PartialEq, Hash)]
-pub struct GridPosition {
-    x: i32,
-    y: i32,
-}
-
-impl GridPosition {
-    pub fn new(x: i32, y: i32) -> Self {
-        Self { x, y }
-    }
-}

src/physics/util.rs

-use crate::physics::position::GridPosition;
-use crate::{Point2, Vector2, GRID_TILE_HEIGHT, GRID_TILE_WIDTH};
+use crate::physics::GridPosition;
+use crate::{ScenePoint, Vector2, WindowPoint, GRID_TILE_HEIGHT, GRID_TILE_WIDTH};
 
 pub fn vec_from_angle(angle: f32) -> Vector2 {
     let vx = angle.sin();
     Vector2::new(vx, vy)
 }
 
-pub fn grid_position_from_position(position: &Point2) -> GridPosition {
+pub fn grid_position_from_scene_point(position: &ScenePoint) -> GridPosition {
     GridPosition::new(
         (position.x / GRID_TILE_WIDTH) as i32,
         (position.y / GRID_TILE_HEIGHT) as i32,
     )
 }
+
+pub fn scene_point_from_window_point(
+    window_point: &WindowPoint,
+    display_offset: &WindowPoint,
+) -> ScenePoint {
+    ScenePoint::new(
+        window_point.x - display_offset.x,
+        window_point.y - display_offset.y,
+    )
+}
+
+pub fn window_point_from_scene_point(
+    scene_point: &ScenePoint,
+    display_offset: &WindowPoint,
+) -> WindowPoint {
+    WindowPoint::new(
+        scene_point.x + display_offset.x,
+        scene_point.y + display_offset.y,
+    )
+}

src/scene/item.rs

 use ggez::graphics;
 
 use crate::behavior::ItemBehavior;
-use crate::physics::position::GridPosition;
+use crate::physics::GridPosition;
 use crate::physics::{util, MetaEvent};
 use crate::scene::SpriteType;
-use crate::{Point2, SCENE_ITEMS_SPRITE_SHEET_HEIGHT, SCENE_ITEMS_SPRITE_SHEET_WIDTH};
+use crate::{
+    Offset, Point2, ScenePoint, SCENE_ITEMS_SPRITE_SHEET_HEIGHT, SCENE_ITEMS_SPRITE_SHEET_WIDTH,
+};
 
 pub struct SceneItemSpriteInfo {
     pub relative_start_y: f32,
 
 pub struct SceneItem {
     pub type_: SceneItemType,
-    pub position: Point2,
+    pub position: ScenePoint,
     pub grid_position: GridPosition,
     pub state: ItemState,
     pub meta_events: Vec<MetaEvent>,
 }
 
 impl SceneItem {
-    pub fn new(type_: SceneItemType, position: Point2, state: ItemState) -> Self {
+    pub fn new(type_: SceneItemType, position: ScenePoint, state: ItemState) -> Self {
         Self {
             type_,
             position: position.clone(),
-            grid_position: util::grid_position_from_position(&position.clone()),
+            grid_position: util::grid_position_from_scene_point(&position.clone()),
             state,
             meta_events: vec![],
             current_frame: 0,
                 sprite_info.relative_tile_height,
             ))
             .rotation(90.0f32.to_radians())
-            .offset(Point2::new(0.5, 0.5))
+            .offset(Offset::new(0.5, 0.5))
     }
 
     pub fn sprite_type(&self) -> SpriteType {

src/scene/main.rs

 use ggez::{event, graphics, input, Context, GameResult};
 
 use crate::behavior::ItemBehavior;
-use crate::physics::position::GridPosition;
+use crate::physics::util::scene_point_from_window_point;
+use crate::physics::util::window_point_from_scene_point;
+use crate::physics::GridPosition;
 use crate::physics::{util, MetaEvent, PhysicEvent};
 use crate::scene::item::{ItemState, SceneItem, SceneItemType};
 use crate::ui::scene_item_menu::SceneItemMenuItem;
 use crate::ui::{SceneItemPrepareOrder, UiItem, UiSpriteInfo, UserEvent};
 use crate::{
-    Point2, 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,
+    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;
 
     frame_i: u32,
 
     // display
-    display_offset: Point2,
+    display_offset: Offset,
     sprite_sheet_batch: graphics::spritebatch::SpriteBatch,
     map_batch: graphics::spritebatch::SpriteBatch,
     ui_batch: graphics::spritebatch::SpriteBatch,
     physics_events: Vec<PhysicEvent>,
 
     // user interactions
-    left_click_down: Option<Point2>,
-    right_click_down: Option<Point2>,
-    current_cursor_position: Point2,
+    left_click_down: Option<WindowPoint>,
+    right_click_down: Option<WindowPoint>,
+    current_cursor_position: WindowPoint,
     user_events: Vec<UserEvent>,
-    selected_scene_items: Vec<usize>,         // scene_item usize
-    scene_item_menu: Option<(usize, Point2)>, // scene_item usize, display_at
+    selected_scene_items: Vec<usize>,             // scene_item usize
+    scene_item_menu: Option<(usize, ScenePoint)>, // scene_item usize, display_at
     scene_item_prepare_order: Option<SceneItemPrepareOrder>,
 }
 
 
                 scene_items.push(SceneItem::new(
                     SceneItemType::Soldier,
-                    Point2::new((x as f32 * 24.0) + 100.0, (y as f32 * 24.0) + 100.0),
+                    ScenePoint::new((x as f32 * 24.0) + 100.0, (y as f32 * 24.0) + 100.0),
                     ItemState::new(current_behavior),
                 ));
             }
 
         let mut main_state = MainState {
             frame_i: 0,
-            display_offset: Point2::new(0.0, 0.0),
+            display_offset: Offset::new(0.0, 0.0),
             sprite_sheet_batch,
             map_batch,
             ui_batch,
             physics_events: vec![],
             left_click_down: None,
             right_click_down: None,
-            current_cursor_position: Point2::new(0.0, 0.0),
+            current_cursor_position: WindowPoint::new(0.0, 0.0),
             user_events: vec![],
             selected_scene_items: vec![],
             scene_item_menu: None,
         };
 
         for (i, scene_item) in main_state.scene_items.iter().enumerate() {
-            let grid_position = util::grid_position_from_position(&scene_item.position);
+            let grid_position = util::grid_position_from_scene_point(&scene_item.position);
             main_state
                 .scene_items_by_grid_position
                 .entry(grid_position)
 
         while let Some(user_event) = self.user_events.pop() {
             match user_event {
-                UserEvent::Click(click_position) => {
-                    let scene_position = Point2::new(
-                        click_position.x - self.display_offset.x,
-                        click_position.y - self.display_offset.y,
-                    );
+                UserEvent::Click(window_click_point) => {
+                    let scene_position =
+                        scene_point_from_window_point(&window_click_point, &self.display_offset);
                     self.selected_scene_items.drain(..);
                     if let Some(scene_item_usize) =
-                        self.get_first_scene_item_for_position(&scene_position)
+                        self.get_first_scene_item_for_scene_point(&scene_position)
                     {
                         self.selected_scene_items.push(scene_item_usize);
                     }
                     }
 
                     // FIXME BS NOW: interpreter sur quel element du menu on a click ...
-                    if let Some((scene_item_usize, menu_position)) = self.scene_item_menu {
+                    if let Some((scene_item_usize, scene_menu_point)) = self.scene_item_menu {
+                        let window_menu_point =
+                            window_point_from_scene_point(&scene_menu_point, &self.display_offset);
                         let menu_sprite_info = UiSpriteInfo::from_type(UiItem::SceneItemMenu);
                         let scene_item = self
                             .scene_items
                             .get(scene_item_usize)
                             .expect(SCENE_ITEMS_CHANGE_ERR_MSG);
-                        if click_position.x >= menu_position.x
-                            && click_position.x <= menu_position.x + menu_sprite_info.width
-                            && click_position.y >= menu_position.y
-                            && click_position.y <= menu_position.y + menu_sprite_info.height
+                        if window_click_point.x >= window_menu_point.x
+                            && window_click_point.x <= window_menu_point.x + menu_sprite_info.width
+                            && window_click_point.y >= window_menu_point.y
+                            && window_click_point.y <= window_menu_point.y + menu_sprite_info.height
                         {
                             if let Some(menu_item) = menu_sprite_info.which_item_clicked(
-                                menu_position,
-                                click_position,
+                                window_menu_point,
+                                window_click_point,
                                 scene_item,
                             ) {
                                 match menu_item {
                         }
                     };
                 }
-                UserEvent::AreaSelection(from, to) => {
-                    let scene_from = Point2::new(
-                        from.x - self.display_offset.x,
-                        from.y - self.display_offset.y,
-                    );
-                    let scene_to =
-                        Point2::new(to.x - self.display_offset.x, to.y - self.display_offset.y);
+                UserEvent::AreaSelection(window_from, window_to) => {
+                    let scene_from =
+                        scene_point_from_window_point(&window_from, &self.display_offset);
+                    let scene_to = scene_point_from_window_point(&window_to, &self.display_offset);
                     self.selected_scene_items.drain(..);
                     self.selected_scene_items
-                        .extend(self.get_scene_items_for_area(&scene_from, &scene_to));
+                        .extend(self.get_scene_items_for_scene_area(&scene_from, &scene_to));
                 }
-                UserEvent::RightClick(position) => {
-                    // FIXME BS NOW: il y a des probleme de position avec le offset !
+                UserEvent::RightClick(window_position) => {
+                    let scene_point =
+                        scene_point_from_window_point(&window_position, &self.display_offset);
                     if let Some(scene_item_usize) =
-                        self.get_first_scene_item_for_position(&position)
+                        self.get_first_scene_item_for_scene_point(&scene_point)
                     {
                         if self.selected_scene_items.contains(&scene_item_usize) {
                             let scene_item = self
                                 .scene_items
                                 .get(scene_item_usize)
                                 .expect(SCENE_ITEMS_CHANGE_ERR_MSG);
-                            self.scene_item_menu =
-                                Some((scene_item_usize, scene_item.position.clone()))
+                            self.scene_item_menu = Some((scene_item_usize, scene_item.position))
                         }
                     }
                 }
                     // TODO ici il faut calculer le déplacement réél (en fonction des ticks, etc ...)
                     scene_item.position.x += 1.0;
                     scene_item.grid_position =
-                        util::grid_position_from_position(&scene_item.position);
+                        util::grid_position_from_scene_point(&scene_item.position);
                 }
                 _ => {}
             }
         }
     }
 
-    fn position_with_display_offset(&self, position: &Point2) -> Point2 {
-        Point2::new(
-            position.x + self.display_offset.x,
-            position.y + self.display_offset.y,
-        )
-    }
-
-    fn get_first_scene_item_for_position(&self, position: &Point2) -> Option<usize> {
+    fn get_first_scene_item_for_scene_point(&self, scene_position: &ScenePoint) -> Option<usize> {
         // TODO: if found multiple: select nearest
         for (i, scene_item) in self.scene_items.iter().enumerate() {
             let sprite_info = scene_item.sprite_info();
-            if scene_item.position.x >= position.x - sprite_info.tile_width
-                && scene_item.position.x <= position.x + sprite_info.tile_width
-                && scene_item.position.y >= position.y - sprite_info.tile_height
-                && scene_item.position.y <= position.y + sprite_info.tile_height
+            if scene_item.position.x >= scene_position.x - sprite_info.tile_width
+                && scene_item.position.x <= scene_position.x + sprite_info.tile_width
+                && scene_item.position.y >= scene_position.y - sprite_info.tile_height
+                && scene_item.position.y <= scene_position.y + sprite_info.tile_height
             {
                 return Some(i);
             }
         None
     }
 
-    fn get_scene_items_for_area(&self, from: &Point2, to: &Point2) -> Vec<usize> {
+    fn get_scene_items_for_scene_area(&self, from: &ScenePoint, to: &ScenePoint) -> Vec<usize> {
         let mut selection = vec![];
 
         for (i, scene_item) in self.scene_items.iter().enumerate() {
 
             scene_mesh_builder.circle(
                 DrawMode::fill(),
-                left_click_down,
+                window_point_from_scene_point(&left_click_down, &self.display_offset),
                 2.0,
                 2.0,
                 graphics::YELLOW,
             )?;
         }
 
-        if let Some((_, position)) = self.scene_item_menu {
+        scene_mesh_builder.circle(
+            DrawMode::fill(),
+            scene_point_from_window_point(&self.current_cursor_position, &self.display_offset),
+            2.0,
+            2.0,
+            graphics::BLUE,
+        )?;
+
+        if let Some((_, scene_point)) = self.scene_item_menu {
             self.ui_batch.add(
                 UiSpriteInfo::from_type(UiItem::SceneItemMenu)
                     .as_draw_param()
-                    .dest(position),
+                    .dest(scene_point),
             );
         }
 
                         .get(*scene_item_usize)
                         .expect(SCENE_ITEMS_CHANGE_ERR_MSG);
                     scene_mesh_builder.line(
-                        &vec![scene_item.position.clone(), self.current_cursor_position],
+                        &vec![
+                            scene_item.position.clone(),
+                            scene_point_from_window_point(
+                                &self.current_cursor_position,
+                                &self.display_offset,
+                            ),
+                        ],
                         2.0,
                         graphics::WHITE,
                     )?;
         self.map_batch.add(
             graphics::DrawParam::new()
                 .src(graphics::Rect::new(0.0, 0.0, 1.0, 1.0))
-                .dest(Point2::new(0.0, 0.0)),
+                .dest(ScenePoint::new(0.0, 0.0)),
         );
 
         let scene_mesh = scene_mesh_builder.build(ctx)?;
         graphics::draw(
             ctx,
             &self.map_batch,
-            graphics::DrawParam::new()
-                .dest(self.position_with_display_offset(&Point2::new(0.0, 0.0))),
+            graphics::DrawParam::new().dest(window_point_from_scene_point(
+                &ScenePoint::new(0.0, 0.0),
+                &self.display_offset,
+            )),
         )?;
         graphics::draw(
             ctx,
             &self.sprite_sheet_batch,
-            graphics::DrawParam::new()
-                .dest(self.position_with_display_offset(&Point2::new(0.0, 0.0))),
+            graphics::DrawParam::new().dest(window_point_from_scene_point(
+                &ScenePoint::new(0.0, 0.0),
+                &self.display_offset,
+            )),
         )?;
         graphics::draw(
             ctx,
             &scene_mesh,
-            graphics::DrawParam::new()
-                .dest(self.position_with_display_offset(&Point2::new(0.0, 0.0))),
+            graphics::DrawParam::new().dest(window_point_from_scene_point(
+                &ScenePoint::new(0.0, 0.0),
+                &self.display_offset,
+            )),
         )?;
         graphics::draw(
             ctx,
             &self.ui_batch,
-            graphics::DrawParam::new()
-                .dest(self.position_with_display_offset(&Point2::new(0.0, 0.0))),
+            graphics::DrawParam::new().dest(window_point_from_scene_point(
+                &ScenePoint::new(0.0, 0.0),
+                &self.display_offset,
+            )),
         )?;
 
         self.sprite_sheet_batch.clear();
     fn mouse_button_down_event(&mut self, _ctx: &mut Context, button: MouseButton, x: f32, y: f32) {
         match button {
             MouseButton::Left => {
-                self.left_click_down = Some(Point2::new(x, y));
+                self.left_click_down = Some(WindowPoint::new(x, y));
             }
             MouseButton::Right => {
-                self.right_click_down = Some(Point2::new(x, y));
+                self.right_click_down = Some(WindowPoint::new(x, y));
             }
             MouseButton::Middle => {}
             MouseButton::Other(_) => {}
         match button {
             MouseButton::Left => {
                 if let Some(left_click_down) = self.left_click_down {
-                    if left_click_down == Point2::new(x, y) {
+                    if left_click_down == WindowPoint::new(x, y) {
                         self.user_events.push(UserEvent::Click(left_click_down));
                     } else {
-                        let from = Point2::new(
+                        let from = WindowPoint::new(
                             cmp::min(left_click_down.x as i32, x as i32) as f32,
                             cmp::min(left_click_down.y as i32, y as i32) as f32,
                         );
-                        let to = Point2::new(
+                        let to = WindowPoint::new(
                             cmp::max(left_click_down.x as i32, x as i32) as f32,
                             cmp::max(left_click_down.y as i32, y as i32) as f32,
                         );
     }
 
     fn mouse_motion_event(&mut self, _ctx: &mut Context, x: f32, y: f32, _dx: f32, _dy: f32) {
-        self.current_cursor_position = Point2::new(x, y);
+        self.current_cursor_position = WindowPoint::new(x, y);
     }
 }

src/ui/mod.rs

 
 use crate::scene::item::SceneItem;
 use crate::ui::scene_item_menu::SceneItemMenuItem;
-use crate::{Point2, UI_SPRITE_SHEET_HEIGHT, UI_SPRITE_SHEET_WIDTH};
+use crate::{Point2, WindowPoint, UI_SPRITE_SHEET_HEIGHT, UI_SPRITE_SHEET_WIDTH};
 
 pub mod scene_item_menu;
 
 
     pub fn which_item_clicked(
         &self,
-        menu_position: Point2,
-        click_position: Point2,
+        window_menu_point: WindowPoint,
+        window_click_point: WindowPoint,
         scene_item: &SceneItem,
     ) -> Option<SceneItemMenuItem> {
         Some(SceneItemMenuItem::Move)
 
 #[derive(Debug)]
 pub enum UserEvent {
-    Click(Point2),                 // Window coordinates
-    RightClick(Point2),            // Window coordinates
-    AreaSelection(Point2, Point2), // Window coordinates
+    Click(WindowPoint),                      // Window coordinates
+    RightClick(WindowPoint),                 // Window coordinates
+    AreaSelection(WindowPoint, WindowPoint), // Window coordinates
 }
 
 pub enum SceneItemPrepareOrder {