wip

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);
-            }
-            Order::MoveFastTo(_) => {
-                scene_item_modifiers.push(SceneItemModifier::SwitchToCurrentOrder)
-            }
-            Order::HideTo(_) => {
-                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),
         }
     }
 
                 // 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::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(
 
             // 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/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 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 {
                 }
                 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));}
+                    scene_item.next_order = Some(Order::HideTo(scene_click_point));
+                }
             }
 
             self.scene_item_prepare_order = None;
         // Scene items movements
         for scene_item in self.scene_items.iter_mut() {
             match scene_item.state.current_behavior {
-                ItemBehavior::MoveTo(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);
                 }
-                _ => {}
             }
         }
 
     ) -> 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
+    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,
+    }
+}