src/behavior/mod.rs

-use crate::Vector2;
+pub mod order;
+
+use crate::ScenePoint;
 
 pub enum ItemBehavior {
     Standing(u32), // since
-    Crawling,
-    Walking(Vector2),
+    CrawlingTo(ScenePoint),
+    WalkingTo(ScenePoint),
 }

src/behavior/order.rs

+use crate::ScenePoint;
+
+#[derive(Clone)]
+pub enum Order {
+    MoveTo(ScenePoint),
+}

src/main.rs

 mod scene;
 mod ui;
 
-type Point2 = Vec2;
 type WindowPoint = Vec2;
 type Offset = Vec2;
 type ScenePoint = Vec2;

src/scene/item.rs

 use ggez::graphics;
 
+use crate::behavior::order::Order;
 use crate::behavior::ItemBehavior;
 use crate::config::{SCENE_ITEMS_SPRITE_SHEET_HEIGHT, SCENE_ITEMS_SPRITE_SHEET_WIDTH};
 use crate::physics::GridPosition;
 use crate::physics::{util, MetaEvent};
 use crate::scene::SpriteType;
-use crate::{Offset, Point2, ScenePoint};
+use crate::{Offset, ScenePoint};
 
 pub struct SceneItemSpriteInfo {
     pub relative_start_y: f32,
     pub state: ItemState,
     pub meta_events: Vec<MetaEvent>,
     pub current_frame: u16,
+    pub current_order: Option<Order>,
+    pub next_order: Option<Order>,
+    pub display_angle: f32,
 }
 
 impl SceneItem {
             state,
             meta_events: vec![],
             current_frame: 0,
+            current_order: None,
+            next_order: None,
+            display_angle: 0.0,
         }
     }
 
                 sprite_info.relative_tile_width,
                 sprite_info.relative_tile_height,
             ))
-            .rotation(90.0f32.to_radians())
+            .rotation(self.display_angle)
             .offset(Offset::new(0.5, 0.5))
     }
 
         // Here some logical about state, nature (soldier, tank, ...) and current behavior to
         // determine sprite type
         match self.state.current_behavior {
-            ItemBehavior::Crawling => SpriteType::CrawlingSoldier,
-            ItemBehavior::Walking(_) => SpriteType::WalkingSoldier,
+            ItemBehavior::CrawlingTo(_) => SpriteType::CrawlingSoldier,
+            ItemBehavior::WalkingTo(_) => SpriteType::WalkingSoldier,
             ItemBehavior::Standing(_) => SpriteType::StandingSoldier,
         }
     }

src/scene/main.rs

 use ggez::timer::check_update_time;
 use ggez::{event, graphics, input, Context, GameResult};
 
+use crate::behavior::order::Order;
 use crate::behavior::ItemBehavior;
 use crate::config::{
     ANIMATE_EACH, DEBUG, DEFAULT_SELECTED_SQUARE_SIDE, DEFAULT_SELECTED_SQUARE_SIDE_HALF,
 use crate::ui::scene_item_menu::SceneItemMenuItem;
 use crate::ui::{SceneItemPrepareOrder, UiItem, UiSpriteInfo, UserEvent};
 use crate::{Offset, ScenePoint, WindowPoint};
+use std::f32::consts::FRAC_PI_2;
 
 pub struct MainState {
     // time
         let mut scene_items = vec![];
         for x in 0..1 {
             for y in 0..4 {
-                let current_behavior = if y % 2 == 0 {
-                    ItemBehavior::Walking(util::vec_from_angle(90.0))
-                } else {
-                    ItemBehavior::Crawling
-                };
+                // let current_behavior = if y % 2 == 0 {
+                //     ItemBehavior::WalkingTo(util::vec_from_angle(90.0))
+                // } else {
+                //     ItemBehavior::CrawlingTo()
+                // };
 
                 scene_items.push(SceneItem::new(
                     SceneItemType::Soldier,
                     ScenePoint::new((x as f32 * 24.0) + 100.0, (y as f32 * 24.0) + 100.0),
-                    ItemState::new(current_behavior),
+                    ItemState::new(ItemBehavior::Standing(0)),
                 ));
             }
         }
         Ok(main_state)
     }
 
+    fn get_scene_item(&self, index: usize) -> &SceneItem {
+        self.scene_items
+            .get(index)
+            .expect(SCENE_ITEMS_CHANGE_ERR_MSG)
+    }
+
+    fn get_scene_item_mut(&mut self, index: usize) -> &mut SceneItem {
+        self.scene_items
+            .get_mut(index)
+            .expect(SCENE_ITEMS_CHANGE_ERR_MSG)
+    }
+
     fn inputs(&mut self, ctx: &Context) {
         let display_offset_by =
             if input::keyboard::is_mod_active(ctx, input::keyboard::KeyMods::SHIFT) {
 
         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_position));
+                }
+            }
+
             self.scene_item_prepare_order = None;
         }
 
             let window_menu_point =
                 window_point_from_scene_point(&scene_menu_point, &self.display_offset);
             let menu_sprite_info = UiSpriteInfo::from_type(UiItem::SceneItemMenu);
-            let scene_item = self
-                .scene_items
-                .get(scene_item_usize)
-                .expect(SCENE_ITEMS_CHANGE_ERR_MSG);
+            let scene_item = self.get_scene_item(scene_item_usize);
             if window_click_point.x >= window_menu_point.x
                 && window_click_point.x <= window_menu_point.x + menu_sprite_info.width
                 && window_click_point.y >= window_menu_point.y
             self.get_first_scene_item_for_scene_point(&scene_right_click_point)
         {
             if self.selected_scene_items.contains(&scene_item_usize) {
-                let scene_item = self
-                    .scene_items
-                    .get(scene_item_usize)
-                    .expect(SCENE_ITEMS_CHANGE_ERR_MSG);
+                let scene_item = self.get_scene_item(scene_item_usize);
                 self.scene_item_menu = Some((scene_item_usize, scene_item.position))
             }
         }
         // Scene items movements
         for scene_item in self.scene_items.iter_mut() {
             match scene_item.state.current_behavior {
-                ItemBehavior::Walking(vector) => {
+                ItemBehavior::WalkingTo(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 ...)
-                    scene_item.position.x += 1.0;
+                    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);
                 }
         // TODO: ici il faut reflechir a comment organiser les comportements
 
         for scene_item in self.scene_items.iter_mut() {
-            for meta_event in &scene_item.meta_events {
-                match meta_event {
-                    MetaEvent::FeelExplosion => {
-                        scene_item.state = ItemState::new(ItemBehavior::Standing(self.frame_i));
+            // for meta_event in &scene_item.meta_events {
+            //     match meta_event {
+            //         MetaEvent::FeelExplosion => {
+            //             scene_item.state = ItemState::new(ItemBehavior::Standing(self.frame_i));
+            //         }
+            //     }
+            // }
+
+            // match scene_item.state.current_behavior {
+            //     ItemBehavior::Crawling => {
+            //         scene_item.state =
+            //             ItemState::new(ItemBehavior::Walking(util::vec_from_angle(90.0)));
+            //     }
+            //     ItemBehavior::Walking(_) => {
+            //         scene_item.state = ItemState::new(ItemBehavior::Crawling);
+            //     }
+            //     ItemBehavior::Standing(since) => {
+            //         if self.frame_i - since >= 120 {
+            //             scene_item.state =
+            //                 ItemState::new(ItemBehavior::Walking(util::vec_from_angle(90.0)));
+            //         }
+            //     }
+            // }
+
+            scene_item.meta_events.drain(..);
+
+            if let Some(next_order) = &scene_item.next_order {
+                // TODO: Compute here if it possible (fear, compatible with current order, etc)
+                match next_order {
+                    Order::MoveTo(move_to_scene_point) => {
+                        scene_item.current_order = Some(Order::MoveTo(*move_to_scene_point));
                     }
                 }
+                scene_item.next_order = None;
             }
 
-            match scene_item.state.current_behavior {
-                ItemBehavior::Crawling => {
-                    scene_item.state =
-                        ItemState::new(ItemBehavior::Walking(util::vec_from_angle(90.0)));
-                }
-                ItemBehavior::Walking(_) => {
-                    scene_item.state = ItemState::new(ItemBehavior::Crawling);
-                }
-                ItemBehavior::Standing(since) => {
-                    if self.frame_i - since >= 120 {
-                        scene_item.state =
-                            ItemState::new(ItemBehavior::Walking(util::vec_from_angle(90.0)));
+            // FIXME BS NOW: stop move when move is accomplished; warn: recompute move_vector here
+            if let Some(current_order) = &scene_item.current_order {
+                match current_order {
+                    Order::MoveTo(move_to_scene_point) => {
+                        let change_to_walk = match scene_item.state.current_behavior {
+                            ItemBehavior::Standing(_) => true,
+                            ItemBehavior::CrawlingTo(_) => true,
+                            ItemBehavior::WalkingTo(_) => false,
+                        };
+
+                        if change_to_walk {
+                            scene_item.state =
+                                ItemState::new(ItemBehavior::WalkingTo(*move_to_scene_point));
+                        }
                     }
                 }
             }
 
-            scene_item.meta_events.drain(..);
+            match scene_item.state.current_behavior {
+                ItemBehavior::Standing(_) => {}
+                ItemBehavior::CrawlingTo(scene_point) => {
+                    let angle = f32::atan2(
+                        scene_point.y - scene_item.position.y,
+                        scene_point.x - scene_item.position.x,
+                    ) + FRAC_PI_2;
+                    scene_item.display_angle = angle;
+
+                    let move_vector = (scene_point - scene_item.position).normalize() * 1.0;
+                    println!("{:?}", move_vector);
+                }
+                ItemBehavior::WalkingTo(scene_point) => {
+                    let angle = f32::atan2(
+                        scene_point.y - scene_item.position.y,
+                        scene_point.x - scene_item.position.x,
+                    ) + FRAC_PI_2;
+                    scene_item.display_angle = angle;
+
+                    let move_vector = (scene_point - scene_item.position).normalize() * 1.0;
+                    println!("{:?}", move_vector);
+                }
+            }
         }
     }
 
         mut mesh_builder: MeshBuilder,
     ) -> GameResult<MeshBuilder> {
         for i in &self.selected_scene_items {
-            let selected_scene_item = self.scene_items.get(*i).expect(SCENE_ITEMS_CHANGE_ERR_MSG);
+            let selected_scene_item = self.get_scene_item(*i);
             mesh_builder.rectangle(
                 DrawMode::Stroke(StrokeOptions::default()),
                 graphics::Rect::new(
         if let Some(scene_item_prepare_order) = &self.scene_item_prepare_order {
             match scene_item_prepare_order {
                 SceneItemPrepareOrder::Move(scene_item_usize) => {
-                    let scene_item = self
-                        .scene_items
-                        .get(*scene_item_usize)
-                        .expect(SCENE_ITEMS_CHANGE_ERR_MSG);
+                    let scene_item = self.get_scene_item(*scene_item_usize);
                     mesh_builder.line(
                         &vec![
                             scene_item.position.clone(),
         graphics::clear(ctx, graphics::BLACK);
         let mut scene_mesh_builder = MeshBuilder::new();
 
-        self.generate_scene_item_sprites();
-        self.generate_scene_item_menu_sprites();
-        self.generate_map_sprites();
+        self.generate_scene_item_sprites()?;
+        self.generate_scene_item_menu_sprites()?;
+        self.generate_map_sprites()?;
 
         scene_mesh_builder = self.update_mesh_builder_with_debug(scene_mesh_builder)?;
         scene_mesh_builder = self.update_mesh_builder_with_selected_items(scene_mesh_builder)?;
 
         graphics::present(ctx)?;
 
-        println!("FPS: {}", ggez::timer::fps(ctx));
+        // println!("FPS: {}", ggez::timer::fps(ctx));
         Ok(())
     }
 

src/ui/mod.rs

 use crate::config::{UI_SPRITE_SHEET_HEIGHT, UI_SPRITE_SHEET_WIDTH};
 use crate::scene::item::SceneItem;
 use crate::ui::scene_item_menu::SceneItemMenuItem;
-use crate::{Point2, WindowPoint};
+use crate::WindowPoint;
 
 pub mod scene_item_menu;
 
 
     pub fn which_item_clicked(
         &self,
-        window_menu_point: WindowPoint,
-        window_click_point: WindowPoint,
-        scene_item: &SceneItem,
+        _window_menu_point: WindowPoint,
+        _window_click_point: WindowPoint,
+        _scene_item: &SceneItem,
     ) -> Option<SceneItemMenuItem> {
         Some(SceneItemMenuItem::Move)
     }