reorganise animate code

src/behavior/animate.rs

+use crate::behavior::order::Order;
+use crate::behavior::ItemBehavior;
+use crate::config::MOVE_TO_REACHED_WHEN_DISTANCE_INFERIOR_AT;
+use crate::scene::item::{ItemState, SceneItem, SceneItemModifier};
+use std::f32::consts::FRAC_PI_2;
+
+pub fn digest_next_order(scene_item: &SceneItem) -> Vec<SceneItemModifier> {
+    let mut scene_item_modifiers: Vec<SceneItemModifier> = vec![];
+
+    // TODO: Compute here if it possible (fear, compatible with current order, etc)
+    if let Some(next_order) = &scene_item.next_order {
+        match next_order {
+            Order::MoveTo(_) => {
+                scene_item_modifiers.push(SceneItemModifier::SwitchToCurrentOrder);
+            }
+        }
+    }
+
+    scene_item_modifiers
+}
+
+pub fn digest_current_order(scene_item: &SceneItem) -> Vec<SceneItemModifier> {
+    let mut scene_item_modifiers: Vec<SceneItemModifier> = vec![];
+
+    // TODO: here, compute state according to order. Ex: if too much fear, move order do not produce walking state
+    if let Some(current_order) = &scene_item.current_order {
+        match current_order {
+            Order::MoveTo(move_to_scene_point) => {
+                scene_item_modifiers.push(SceneItemModifier::ChangeState(ItemState::new(
+                    ItemBehavior::WalkingTo(*move_to_scene_point),
+                )))
+            }
+        }
+    }
+
+    scene_item_modifiers
+}
+
+pub fn digest_current_behavior(scene_item: &SceneItem) -> Vec<SceneItemModifier> {
+    let mut scene_item_modifiers: Vec<SceneItemModifier> = vec![];
+
+    match scene_item.state.current_behavior {
+        ItemBehavior::Standing => {}
+        ItemBehavior::WalkingTo(going_to_scene_point)
+        | ItemBehavior::CrawlingTo(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(
+                    going_to_scene_point.y - scene_item.position.y,
+                    going_to_scene_point.x - scene_item.position.x,
+                ) + FRAC_PI_2,
+            ));
+
+            // Check if scene_point reached
+            let distance = going_to_scene_point.distance(scene_item.position);
+            if distance < MOVE_TO_REACHED_WHEN_DISTANCE_INFERIOR_AT {
+                scene_item_modifiers.push(SceneItemModifier::ChangeState(ItemState::new(
+                    ItemBehavior::Standing,
+                )));
+                if let Some(current_order) = &scene_item.current_order {
+                    match current_order {
+                        Order::MoveTo(move_to_scene_point) => {
+                            if *move_to_scene_point == going_to_scene_point {
+                                scene_item_modifiers.push(SceneItemModifier::SwitchToCurrentOrder);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    scene_item_modifiers
+}

src/behavior/mod.rs

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

src/scene/item.rs

         match self.state.current_behavior {
             ItemBehavior::CrawlingTo(_) => SpriteType::CrawlingSoldier,
             ItemBehavior::WalkingTo(_) => SpriteType::WalkingSoldier,
-            ItemBehavior::Standing(_) => SpriteType::StandingSoldier,
+            ItemBehavior::Standing => SpriteType::StandingSoldier,
+        }
+    }
+}
+
+pub enum SceneItemModifier {
+    SwitchToCurrentOrder,
+    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 => {
+                let next_order = scene_item.next_order.clone();
+                scene_item.current_order = next_order;
+                scene_item.next_order = None;
+            }
+            SceneItemModifier::ChangeDisplayAngle(new_angle) => {
+                scene_item.display_angle = new_angle;
+            }
+            SceneItemModifier::ChangeState(new_state) => {
+                scene_item.state = new_state;
+            }
         }
     }
 }

src/scene/main.rs

 use ggez::timer::check_update_time;
 use ggez::{event, graphics, input, Context, GameResult};
 
+use crate::behavior::animate::{digest_current_behavior, digest_current_order, digest_next_order};
 use crate::behavior::order::Order;
 use crate::behavior::ItemBehavior;
 use crate::config::{
 use crate::physics::util::window_point_from_scene_point;
 use crate::physics::GridPosition;
 use crate::physics::{util, MetaEvent, PhysicEvent};
-use crate::scene::item::{ItemState, SceneItem, SceneItemType};
+use crate::scene::item::{
+    apply_scene_item_modifier, ItemState, SceneItem, SceneItemModifier, SceneItemType,
+};
 use crate::ui::scene_item_menu::SceneItemMenuItem;
 use crate::ui::{SceneItemPrepareOrder, UiItem, UiSpriteInfo, UserEvent};
 use crate::{Offset, ScenePoint, WindowPoint};
                 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(ItemBehavior::Standing(0)),
+                    ItemState::new(ItemBehavior::Standing),
                 ));
             }
         }
     }
 
     fn animate(&mut self) {
-        // 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));
-            //         }
-            //     }
-            // }
-
-            // 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;
-            }
-
-            // TODO: here, compute state according to order. Ex: if too much fear, move order do not produce walking state
-            if let Some(current_order) = &scene_item.current_order {
-                match current_order {
-                    Order::MoveTo(move_to_scene_point) => {
-                        scene_item.state =
-                            ItemState::new(ItemBehavior::WalkingTo(*move_to_scene_point));
-                    }
-                }
-            }
-
-            match scene_item.state.current_behavior {
-                ItemBehavior::Standing(_) => {}
-                ItemBehavior::WalkingTo(going_to_scene_point)
-                | ItemBehavior::CrawlingTo(going_to_scene_point) => {
-                    // Note: angle computed by adding FRAC_PI_2 because sprites are north oriented
-                    scene_item.display_angle = f32::atan2(
-                        going_to_scene_point.y - scene_item.position.y,
-                        going_to_scene_point.x - scene_item.position.x,
-                    ) + FRAC_PI_2;
-
-                    // Check if scene_point reached
-                    let distance = going_to_scene_point.distance(scene_item.position);
-                    println!("{:?}", distance);
-                    if distance < MOVE_TO_REACHED_WHEN_DISTANCE_INFERIOR_AT {
-                        scene_item.state = ItemState::new(ItemBehavior::Standing(self.frame_i));
-                        if let Some(current_order) = &scene_item.current_order {
-                            match current_order {
-                                Order::MoveTo(move_to_scene_point) => {
-                                    if *move_to_scene_point == going_to_scene_point {
-                                        // TODO: If multiple moves, setup next move order
-                                        scene_item.current_order = None;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
+        for (i, scene_item) in self.scene_items.iter_mut().enumerate() {
+            apply_scene_item_modifier(scene_item, digest_next_order(&scene_item));
+            apply_scene_item_modifier(scene_item, digest_current_order(&scene_item));
+            apply_scene_item_modifier(scene_item, digest_current_behavior(&scene_item));
         }
     }