use open combat tiles

src/main.rs

 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 SPRITE_SHEET_WIDTH: f32 = 168.0;
-const SPRITE_SHEET_HEIGHT: f32 = 72.0;
+const SPRITE_SHEET_WIDTH: f32 = 800.0;
+const SPRITE_SHEET_HEIGHT: f32 = 600.0;
 
 fn vec_from_angle(angle: f32) -> Vector2 {
     let vx = angle.sin();
     relative_tile_width: f32,
     relative_tile_height: f32,
     tile_count: u16,
+    tile_width: f32,
+    tile_height: f32,
+    half_tile_width: f32,
+    half_tile_height: f32,
 }
 
 impl SpriteInfo {
-    pub fn new(
-        relative_start_y: f32,
-        relative_tile_width: f32,
-        relative_tile_height: f32,
-        tile_count: u16,
-    ) -> Self {
-        Self {
-            relative_start_y,
-            relative_tile_width,
-            relative_tile_height,
-            tile_count,
-        }
-    }
-
     // TODO: ask on rust community if this is performant, or how to make it static
     pub fn from_type(type_: &SpriteType) -> Self {
         let (start_y, tile_width, tile_height, tile_count) = match type_ {
-            SpriteType::WalkingSoldier => (0.0, 24.0, 24.0, 7),
-            SpriteType::JumpingSoldier => (24.0, 24.0, 24.0, 2),
-            SpriteType::StandingSoldier => (48.0, 24.0, 24.0, 1),
+            SpriteType::WalkingSoldier => (12.0, 12.0, 12.0, 8),
+            SpriteType::CrawlingSoldier => (26.0, 26.0, 26.0, 8),
+            SpriteType::StandingSoldier => (0.0, 12.0, 12.0, 1),
         };
 
         Self {
             relative_tile_width: tile_width / SPRITE_SHEET_WIDTH,
             relative_tile_height: tile_height / SPRITE_SHEET_HEIGHT,
             tile_count,
+            tile_width,
+            tile_height,
+            half_tile_width: tile_width / 2.0,
+            half_tile_height: tile_height / 2.0,
         }
     }
 
 
 enum SpriteType {
     WalkingSoldier,
-    JumpingSoldier,
+    CrawlingSoldier,
     StandingSoldier,
 }
 
 enum ItemBehavior {
     Standing(u32), // since
-    Jumping,
-    Running(Vector2),
+    Crawling,
+    Walking(Vector2),
 }
 
 struct ItemState {
     pub fn sprite_type(&self) -> SpriteType {
         // Here some logical about state and current behavior to determine sprite type
         match self.current_behavior {
-            ItemBehavior::Jumping => SpriteType::JumpingSoldier,
-            ItemBehavior::Running(_) => SpriteType::WalkingSoldier,
+            ItemBehavior::Crawling => SpriteType::CrawlingSoldier,
+            ItemBehavior::Walking(_) => SpriteType::WalkingSoldier,
             ItemBehavior::Standing(_) => SpriteType::StandingSoldier,
         }
     }
             self.current_frame = 0;
         }
     }
+
+    pub fn position_with_tile_decal(&self) -> na::Point2<f32> {
+        let sprite_info = self.sprite_info();
+        na::Point2::new(
+            self.position.x - sprite_info.half_tile_width,
+            self.position.y - sprite_info.half_tile_height,
+        )
+    }
 }
 
 enum PhysicEvent {
 
 impl MainState {
     fn new(ctx: &mut Context) -> GameResult<MainState> {
-        let image = graphics::Image::new(ctx, "/test.png").unwrap();
+        let image = graphics::Image::new(ctx, "/sprite_sheet.png").unwrap();
         let batch = graphics::spritebatch::SpriteBatch::new(image);
 
         let mut scene_items = vec![];
         for x in 0..1 {
             for y in 0..4 {
                 let current_behavior = if y % 2 == 0 {
-                    ItemBehavior::Running(vec_from_angle(90.0))
+                    ItemBehavior::Walking(vec_from_angle(90.0))
                 } else {
-                    ItemBehavior::Jumping
+                    ItemBehavior::Crawling
                 };
 
                 scene_items.push(SceneItem::new(
         // Scene items movements
         for scene_item in self.scene_items.iter_mut() {
             match scene_item.state.current_behavior {
-                ItemBehavior::Running(vector) => {
+                ItemBehavior::Walking(vector) => {
                     // TODO ici il faut calculer le déplacement réél (en fonction des ticks, etc ...)
                     scene_item.position.x += 1.0;
                 }
         }
 
         // (FAKE) Drop a bomb to motivate stop move
-        if self.frame_i % 300 == 0 && self.frame_i != 0 {
+        if self.frame_i % 600 == 0 && self.frame_i != 0 {
             self.physics_events.push(PhysicEvent::Explosion);
         }
     }
             }
 
             match scene_item.state.current_behavior {
-                ItemBehavior::Jumping => {
-                    scene_item.state = ItemState::new(ItemBehavior::Running(vec_from_angle(90.0)));
+                ItemBehavior::Crawling => {
+                    scene_item.state = ItemState::new(ItemBehavior::Walking(vec_from_angle(90.0)));
                 }
-                ItemBehavior::Running(_) => {
-                    scene_item.state = ItemState::new(ItemBehavior::Jumping);
+                ItemBehavior::Walking(_) => {
+                    scene_item.state = ItemState::new(ItemBehavior::Crawling);
                 }
                 ItemBehavior::Standing(since) => {
                     if self.frame_i - since >= 120 {
                         scene_item.state =
-                            ItemState::new(ItemBehavior::Running(vec_from_angle(90.0)));
+                            ItemState::new(ItemBehavior::Walking(vec_from_angle(90.0)));
                     }
                 }
             }
                 scene_item
                     .sprite_info()
                     .as_draw_param(scene_item.current_frame as f32)
-                    .dest(scene_item.position.clone()),
+                    .dest(scene_item.position_with_tile_decal()),
             );
         }
         graphics::draw(