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> {
 
             // 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)

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 = 2.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/main.rs

 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 {
                 ItemBehavior::MoveTo(move_to_scene_point)
                 | ItemBehavior::MoveFastTo(move_to_scene_point)
                 | ItemBehavior::HideTo(move_to_scene_point) => {
-                    let velocity = match &scene_item.state.current_behavior {
-                        ItemBehavior::MoveTo(_) => MOVE_VELOCITY,
-                        ItemBehavior::MoveFastTo(_) => MOVE_FAST_VELOCITY,
-                        ItemBehavior::HideTo(_) => MOVE_HIDE_VELOCITY,
-                        _ => {
-                            panic!("This code should not be reached")
-                        }
-                    };
-                    // FIXME BS NOW: velocity
+                    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 ...)

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,
+    }
+}