wip

src/behavior/animate.rs

             Order::MoveTo(_) => {
                 scene_item_modifiers.push(SceneItemModifier::SwitchToCurrentOrder);
             }
+            Order::MoveFastTo(_) => {
+                scene_item_modifiers.push(SceneItemModifier::SwitchToCurrentOrder)
+            }
+            Order::HideTo(_) => {
+                scene_item_modifiers.push(SceneItemModifier::SwitchToCurrentOrder)
+            }
         }
     }
 
     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::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(

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/scene/item.rs

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

src/scene/main.rs

         }
 
         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) => {
+                ItemBehavior::MoveTo(scene_point) => {
                     // FIXME BS NOW: velocity
                     let move_vector = (scene_point - scene_item.position).normalize() * 1.0;
                     // TODO ici il faut calculer le déplacement réél (en fonction des ticks, etc ...)

src/ui/mod.rs

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