grid position computed with map infos

src/map/mod.rs

     pub tiled_map: TiledMap,
     pub background_image: TiledImage,
     pub terrain_image: TiledImage,
+    pub terrain_tileset: Tileset,
     pub tiles: HashMap<(u32, u32), Tile>,
 }
 
             tiled_map: tiled_map.clone(),
             background_image: background_image.clone(),
             terrain_image,
+            terrain_tileset,
             tiles,
         })
     }

src/physics/util.rs

-use crate::config::{GRID_TILE_HEIGHT, GRID_TILE_WIDTH};
+use crate::map::Map;
 use crate::physics::GridPosition;
 use crate::{ScenePoint, WindowPoint};
 
-pub fn grid_position_from_scene_point(position: &ScenePoint) -> GridPosition {
+pub fn grid_position_from_scene_point(position: &ScenePoint, map: &Map) -> GridPosition {
     GridPosition::new(
-        (position.x / GRID_TILE_WIDTH) as i32,
-        (position.y / GRID_TILE_HEIGHT) as i32,
+        (position.x / map.terrain_tileset.tile_width as f32) as i32,
+        (position.y / map.terrain_tileset.tile_height as f32) as i32,
     )
 }
 

src/scene/item.rs

 use crate::behavior::order::Order;
 use crate::behavior::ItemBehavior;
 use crate::config::{SCENE_ITEMS_SPRITE_SHEET_HEIGHT, SCENE_ITEMS_SPRITE_SHEET_WIDTH};
+use crate::map::Map;
 use crate::physics::GridPosition;
 use crate::physics::{util, MetaEvent};
 use crate::scene::SpriteType;
 }
 
 impl SceneItem {
-    pub fn new(type_: SceneItemType, position: ScenePoint, state: ItemState) -> Self {
+    pub fn new(type_: SceneItemType, position: ScenePoint, state: ItemState, map: &Map) -> Self {
         Self {
             type_,
             position: position.clone(),
-            grid_position: util::grid_position_from_scene_point(&position.clone()),
+            grid_position: util::grid_position_from_scene_point(&position.clone(), map),
             state,
             meta_events: vec![],
             current_frame: 0.0,

src/scene/main.rs

                     SceneItemType::Soldier,
                     ScenePoint::new((x as f32 * 24.0) + 100.0, (y as f32 * 24.0) + 100.0),
                     ItemState::new(ItemBehavior::Standing),
+                    &map,
                 ));
             }
         }
 
+        let mut scene_items_by_grid_position: HashMap<GridPosition, Vec<usize>> = HashMap::new();
+        for (i, scene_item) in scene_items.iter().enumerate() {
+            let grid_position = util::grid_position_from_scene_point(&scene_item.position, &map);
+            scene_items_by_grid_position
+                .entry(grid_position)
+                .or_default()
+                .push(i);
+        }
+
         let mut main_state = MainState {
             frame_i: 0,
             start: Instant::now(),
             ui_batch,
             terrain_batch,
             scene_items,
-            scene_items_by_grid_position: HashMap::new(),
+            scene_items_by_grid_position,
             physics_events: vec![],
             last_key_consumed: HashMap::new(),
             left_click_down: None,
             scene_item_prepare_order: None,
         };
 
-        for (i, scene_item) in main_state.scene_items.iter().enumerate() {
-            let grid_position = util::grid_position_from_scene_point(&scene_item.position);
-            main_state
-                .scene_items_by_grid_position
-                .entry(grid_position)
-                .or_default()
-                .push(i);
-        }
-
         Ok(main_state)
     }
 
                     scene_item.position.x += move_vector.x;
                     scene_item.position.y += move_vector.y;
                     scene_item.grid_position =
-                        util::grid_position_from_scene_point(&scene_item.position);
+                        util::grid_position_from_scene_point(&scene_item.position, &self.map);
                 }
             }
         }