move

src/behavior/mod.rs

+pub mod order;
+
 use crate::Vector2;
 
 pub enum ItemBehavior {

src/behavior/order.rs

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

src/scene/item.rs

 use crate::physics::{util, MetaEvent};
 use crate::scene::SpriteType;
 use crate::{Offset, ScenePoint};
+use crate::behavior::order::Order;
 
 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>,
 }
 
 impl SceneItem {
             state,
             meta_events: vec![],
             current_frame: 0,
+            current_order: None,
+            next_order: None,
         }
     }
 

src/scene/main.rs

 use ggez::{event, graphics, input, Context, GameResult};
 
 use crate::behavior::ItemBehavior;
+use crate::behavior::order::Order;
 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, PHYSICS_EACH,
             .expect(SCENE_ITEMS_CHANGE_ERR_MSG)
     }
 
-    fn get_scene_item_mut(&mut self, index: usize) -> &SceneItem {
+    fn get_scene_item_mut(&mut self, index: usize) -> &mut SceneItem {
         self.scene_items
             .get_mut(index)
             .expect(SCENE_ITEMS_CHANGE_ERR_MSG)
             // TODO: Add order to scene_item
             match scene_item_prepare_order {
                 SceneItemPrepareOrder::Move(scene_item_usize) => {
-                    let scene_item = self.get_scene_item(*scene_item_usize);
+                    let mut scene_item = self.get_scene_item_mut(*scene_item_usize);
+                    scene_item.next_order = Some(Order::MoveTo(scene_position));
+
                     // TODO: remove this code when used in right place
                     let angle = f32::atan2(
                         scene_position.y - scene_item.position.y,
         // Scene items movements
         for scene_item in self.scene_items.iter_mut() {
             match scene_item.state.current_behavior {
-                ItemBehavior::Walking(_vector) => {
+                ItemBehavior::Walking(move_vector) => {
                     // TODO ici il faut calculer le déplacement réél (en fonction des ticks, etc ...)
-                    scene_item.position.x += 1.0;
-                    scene_item.grid_position =
-                        util::grid_position_from_scene_point(&scene_item.position);
+                    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);
                 }
                 _ => {}
             }
                 }
             }
 
-            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)));
+            // 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 {
+                // 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));
+                        // FIXME BS NOW: velocity
+                        let move_vector = (*move_to_scene_point - scene_item.position).normalize() * 1.0;
+                        scene_item.state = ItemState::new(ItemBehavior::Walking(move_vector));
                     }
                 }
+                scene_item.next_order = None;
             }
 
-            scene_item.meta_events.drain(..);
+            // 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 move_vector = (*move_to_scene_point - scene_item.position).normalize() * 1.0;
+                        println!("{:?}", move_vector);
+                    }
+                }
+            }
         }
     }