Implement multiples moves

src/behavior/animate.rs

 use crate::behavior::ItemBehavior;
 use crate::config::MOVE_TO_REACHED_WHEN_DISTANCE_INFERIOR_AT;
 use crate::scene::item::{ItemState, SceneItem, SceneItemModifier};
+use crate::util::velocity_for_behavior;
 use std::f32::consts::FRAC_PI_2;
 
 pub fn digest_next_order(scene_item: &SceneItem) -> Vec<SceneItemModifier> {
     if let Some(next_order) = &scene_item.next_order {
         match next_order {
             Order::MoveTo(_) => {
-                scene_item_modifiers.push(SceneItemModifier::SwitchToCurrentOrder);
+                scene_item_modifiers.push(SceneItemModifier::SwitchToNextOrder);
             }
+            Order::MoveFastTo(_) => scene_item_modifiers.push(SceneItemModifier::SwitchToNextOrder),
+            Order::HideTo(_) => scene_item_modifiers.push(SceneItemModifier::SwitchToNextOrder),
         }
     }
 
     if let Some(current_order) = &scene_item.current_order {
         match current_order {
             Order::MoveTo(move_to_scene_point) => {
+                // FIXME BS NOW: Change order only if it is not the current order
                 scene_item_modifiers.push(SceneItemModifier::ChangeState(ItemState::new(
-                    ItemBehavior::WalkingTo(*move_to_scene_point),
+                    ItemBehavior::MoveTo(*move_to_scene_point),
+                )))
+            }
+            Order::MoveFastTo(move_to_scene_point) => {
+                // FIXME BS NOW: Change order only if it is not the current order
+                scene_item_modifiers.push(SceneItemModifier::ChangeState(ItemState::new(
+                    ItemBehavior::MoveFastTo(*move_to_scene_point),
+                )))
+            }
+            Order::HideTo(move_to_scene_point) => {
+                // FIXME BS NOW: Change order only if it is not the current order
+                scene_item_modifiers.push(SceneItemModifier::ChangeState(ItemState::new(
+                    ItemBehavior::HideTo(*move_to_scene_point),
                 )))
             }
         }
 
     match scene_item.state.current_behavior {
         ItemBehavior::Standing => {}
-        ItemBehavior::WalkingTo(going_to_scene_point)
-        | ItemBehavior::CrawlingTo(going_to_scene_point) => {
+        ItemBehavior::MoveTo(going_to_scene_point)
+        | ItemBehavior::MoveFastTo(going_to_scene_point)
+        | ItemBehavior::HideTo(going_to_scene_point) => {
             // Note: angle computed by adding FRAC_PI_2 because sprites are north oriented
             scene_item_modifiers.push(SceneItemModifier::ChangeDisplayAngle(
                 f32::atan2(
 
             // Check if scene_point reached
             let distance = going_to_scene_point.distance(scene_item.position);
-            if distance < MOVE_TO_REACHED_WHEN_DISTANCE_INFERIOR_AT {
+            let velocity = velocity_for_behavior(&scene_item.state.current_behavior)
+                .expect("must have velocity here");
+            if distance < MOVE_TO_REACHED_WHEN_DISTANCE_INFERIOR_AT * velocity {
                 scene_item_modifiers.push(SceneItemModifier::ChangeState(ItemState::new(
                     ItemBehavior::Standing,
                 )));
+
+                // Test if reached destination is from an order. If it is, switch to next order.
                 if let Some(current_order) = &scene_item.current_order {
                     match current_order {
-                        Order::MoveTo(move_to_scene_point) => {
+                        Order::MoveTo(move_to_scene_point)
+                        | Order::MoveFastTo(move_to_scene_point)
+                        | Order::HideTo(move_to_scene_point) => {
                             if *move_to_scene_point == going_to_scene_point {
-                                scene_item_modifiers.push(SceneItemModifier::SwitchToCurrentOrder);
+                                scene_item_modifiers.push(SceneItemModifier::SwitchToNextOrder);
                             }
                         }
                     }

src/behavior/mod.rs

 
 pub enum ItemBehavior {
     Standing, // since
-    CrawlingTo(ScenePoint),
-    WalkingTo(ScenePoint),
+    HideTo(ScenePoint),
+    MoveTo(ScenePoint),
+    MoveFastTo(ScenePoint),
 }

src/behavior/order.rs

 #[derive(Clone)]
 pub enum Order {
     MoveTo(ScenePoint),
+    MoveFastTo(ScenePoint),
+    HideTo(ScenePoint),
 }

src/config.rs

 //
 pub const DEBUG: bool = true;
 // Distance from move target point to consider reached
-pub const MOVE_TO_REACHED_WHEN_DISTANCE_INFERIOR_AT: f32 = 1.0;
+pub const MOVE_TO_REACHED_WHEN_DISTANCE_INFERIOR_AT: f32 = 3.0;
+// Velocity of move vector
+pub const MOVE_VELOCITY: f32 = 1.0;
+// Velocity of move fast vector
+pub const MOVE_FAST_VELOCITY: f32 = 2.0;
+// Velocity of move hide vector
+pub const MOVE_HIDE_VELOCITY: f32 = 0.5;

src/main.rs

 mod physics;
 mod scene;
 mod ui;
+mod util;
 
 type WindowPoint = Vec2;
 type Offset = Vec2;

src/scene/item.rs

     pub tile_height: f32,
     pub _half_tile_width: f32,
     pub _half_tile_height: f32,
+    pub tick_speed: f32,
 }
 
 impl SceneItemSpriteInfo {
     // 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 => (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),
+        let (start_y, tile_width, tile_height, tile_count, tick_speed) = match type_ {
+            SpriteType::WalkingSoldier => (12.0, 12.0, 12.0, 8, 0.5),
+            SpriteType::CrawlingSoldier => (26.0, 26.0, 26.0, 8, 1.0),
+            SpriteType::StandingSoldier => (0.0, 12.0, 12.0, 1, 0.0),
         };
 
         Self {
             tile_height,
             _half_tile_width: tile_width / 2.0,
             _half_tile_height: tile_height / 2.0,
+            tick_speed,
         }
     }
 }
     pub grid_position: GridPosition,
     pub state: ItemState,
     pub meta_events: Vec<MetaEvent>,
-    pub current_frame: u16,
+    pub current_frame: f32,
     pub current_order: Option<Order>,
     pub next_order: Option<Order>,
     pub display_angle: f32,
             grid_position: util::grid_position_from_scene_point(&position.clone()),
             state,
             meta_events: vec![],
-            current_frame: 0,
+            current_frame: 0.0,
             current_order: None,
             next_order: None,
             display_angle: 0.0,
     }
 
     pub fn tick_sprite(&mut self) {
-        self.current_frame += 1;
+        let sprite_info =self.sprite_info();
+        self.current_frame += sprite_info.tick_speed;
         // TODO: good way to have sprite info ? performant ?
-        if self.current_frame >= self.sprite_info().tile_count {
-            self.current_frame = 0;
+        if self.current_frame as u16 >= sprite_info.tile_count {
+            self.current_frame = 0.0;
         }
     }
 
         let sprite_info = self.sprite_info();
         graphics::DrawParam::new()
             .src(graphics::Rect::new(
-                current_frame as f32 * sprite_info.relative_tile_width,
+                (current_frame as u16) as f32 * sprite_info.relative_tile_width,
                 sprite_info.relative_start_y,
                 sprite_info.relative_tile_width,
                 sprite_info.relative_tile_height,
         // Here some logical about state, nature (soldier, tank, ...) and current behavior to
         // determine sprite type
         match self.state.current_behavior {
-            ItemBehavior::CrawlingTo(_) => SpriteType::CrawlingSoldier,
-            ItemBehavior::WalkingTo(_) => SpriteType::WalkingSoldier,
+            ItemBehavior::HideTo(_) => SpriteType::CrawlingSoldier,
+            ItemBehavior::MoveTo(_) => SpriteType::WalkingSoldier,
+            ItemBehavior::MoveFastTo(_) => SpriteType::WalkingSoldier,
             ItemBehavior::Standing => SpriteType::StandingSoldier,
         }
     }
 }
 
 pub enum SceneItemModifier {
-    SwitchToCurrentOrder,
+    SwitchToNextOrder,
     ChangeDisplayAngle(f32),
     ChangeState(ItemState),
 }
 pub fn apply_scene_item_modifier(scene_item: &mut SceneItem, modifiers: Vec<SceneItemModifier>) {
     for modifier in modifiers {
         match modifier {
-            SceneItemModifier::SwitchToCurrentOrder => {
+            SceneItemModifier::SwitchToNextOrder => {
                 let next_order = scene_item.next_order.clone();
                 scene_item.current_order = next_order;
                 scene_item.next_order = None;

src/scene/main.rs

 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,
-    MOVE_TO_REACHED_WHEN_DISTANCE_INFERIOR_AT, PHYSICS_EACH, SCENE_ITEMS_CHANGE_ERR_MSG,
-    SPRITE_EACH, TARGET_FPS,
+    DISPLAY_OFFSET_BY, DISPLAY_OFFSET_BY_SPEED, MAX_FRAME_I, META_EACH, MOVE_FAST_VELOCITY,
+    MOVE_HIDE_VELOCITY, MOVE_TO_REACHED_WHEN_DISTANCE_INFERIOR_AT, MOVE_VELOCITY, 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::ui::vertical_menu::{vertical_menu_sprite_info, VerticalMenuSpriteInfo};
 use crate::ui::MenuItem;
 use crate::ui::{SceneItemPrepareOrder, UiComponent, UserEvent};
+use crate::util::velocity_for_behavior;
 use crate::{Offset, ScenePoint, WindowPoint};
 
 pub struct MainState {
         }
 
         if let Some(scene_item_prepare_order) = &self.scene_item_prepare_order {
-            // TODO: Add order to scene_item
             match scene_item_prepare_order {
                 SceneItemPrepareOrder::Move(scene_item_usize) => {
                     let mut scene_item = self.get_scene_item_mut(*scene_item_usize);
                     scene_item.next_order = Some(Order::MoveTo(scene_click_point));
                 }
+                SceneItemPrepareOrder::MoveFast(scene_item_usize) => {
+                    let mut scene_item = self.get_scene_item_mut(*scene_item_usize);
+                    scene_item.next_order = Some(Order::MoveFastTo(scene_click_point));
+                }
+                SceneItemPrepareOrder::Hide(scene_item_usize) => {
+                    let mut scene_item = self.get_scene_item_mut(*scene_item_usize);
+                    scene_item.next_order = Some(Order::HideTo(scene_click_point));
+                }
             }
 
             self.scene_item_prepare_order = None;
                             Some(SceneItemPrepareOrder::Move(scene_item_usize));
                         self.scene_item_menu = None;
                     }
-                    MenuItem::MoveFast => {}
-                    MenuItem::Hide => {}
+                    MenuItem::MoveFast => {
+                        self.scene_item_prepare_order =
+                            Some(SceneItemPrepareOrder::MoveFast(scene_item_usize));
+                        self.scene_item_menu = None;
+                    }
+                    MenuItem::Hide => {
+                        self.scene_item_prepare_order =
+                            Some(SceneItemPrepareOrder::Hide(scene_item_usize));
+                        self.scene_item_menu = None;
+                    }
                 }
             };
             self.scene_item_menu = None;
         // Scene items movements
         for scene_item in self.scene_items.iter_mut() {
             match scene_item.state.current_behavior {
-                ItemBehavior::WalkingTo(scene_point) => {
-                    // FIXME BS NOW: velocity
-                    let move_vector = (scene_point - scene_item.position).normalize() * 1.0;
+                ItemBehavior::Standing => {}
+                ItemBehavior::MoveTo(move_to_scene_point)
+                | ItemBehavior::MoveFastTo(move_to_scene_point)
+                | ItemBehavior::HideTo(move_to_scene_point) => {
+                    let velocity = velocity_for_behavior(&scene_item.state.current_behavior)
+                        .expect("must have velocity here");
+                    let move_vector =
+                        (move_to_scene_point - scene_item.position).normalize() * velocity;
                     // TODO ici il faut calculer le déplacement réél (en fonction des ticks, etc ...)
                     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);
                 }
-                _ => {}
             }
         }
 
         for scene_item in self.scene_items.iter() {
             self.sprite_sheet_batch.add(
                 scene_item
-                    .as_draw_param(scene_item.current_frame as f32)
+                    .as_draw_param(scene_item.current_frame)
                     .dest(scene_item.position.clone()),
             );
         }
     ) -> GameResult<MeshBuilder> {
         if let Some(scene_item_prepare_order) = &self.scene_item_prepare_order {
             match scene_item_prepare_order {
-                SceneItemPrepareOrder::Move(scene_item_usize) => {
+                SceneItemPrepareOrder::Move(scene_item_usize)
+                | SceneItemPrepareOrder::MoveFast(scene_item_usize)
+                | SceneItemPrepareOrder::Hide(scene_item_usize) => {
+                    let color = match &scene_item_prepare_order {
+                        SceneItemPrepareOrder::Move(_) => graphics::BLUE,
+                        SceneItemPrepareOrder::MoveFast(_) => graphics::MAGENTA,
+                        SceneItemPrepareOrder::Hide(_) => graphics::YELLOW,
+                    };
+
                     let scene_item = self.get_scene_item(*scene_item_usize);
                     mesh_builder.line(
                         &vec![
                             ),
                         ],
                         2.0,
-                        graphics::WHITE,
+                        color,
                     )?;
                 }
             }

src/ui/mod.rs

 }
 
 pub enum SceneItemPrepareOrder {
-    Move(usize), // scene_item usize
+    Move(usize),     // scene_item usize
+    MoveFast(usize), // scene_item usize
+    Hide(usize),     // scene_item usize
 }
 
 #[derive(Clone)]

src/util.rs

+use crate::behavior::ItemBehavior;
+use crate::config::{MOVE_FAST_VELOCITY, MOVE_HIDE_VELOCITY, MOVE_VELOCITY};
+
+pub fn velocity_for_behavior(behavior: &ItemBehavior) -> Option<f32> {
+    match behavior {
+        ItemBehavior::MoveTo(_) => Some(MOVE_VELOCITY),
+        ItemBehavior::MoveFastTo(_) => Some(MOVE_FAST_VELOCITY),
+        ItemBehavior::HideTo(_) => Some(MOVE_HIDE_VELOCITY),
+        _ => None,
+    }
+}