refact menu code

src/scene/main.rs

 use std::cmp;
 use std::collections::HashMap;
+use std::f32::consts::FRAC_PI_2;
 
 use ggez::event::MouseButton;
 use ggez::graphics::{DrawMode, MeshBuilder, StrokeOptions};
 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::ui::vertical_menu::{vertical_menu_sprite_info, VerticalMenuSpriteInfo};
+use crate::ui::MenuItem;
+use crate::ui::{SceneItemPrepareOrder, UiComponent, UserEvent};
 use crate::{Offset, ScenePoint, WindowPoint};
-use std::f32::consts::FRAC_PI_2;
 
 pub struct MainState {
     // time
     }
 
     fn digest_click(&mut self, window_click_point: WindowPoint) {
-        let scene_position =
+        let scene_click_point =
             scene_point_from_window_point(&window_click_point, &self.display_offset);
         self.selected_scene_items.drain(..);
-        if let Some(scene_item_usize) = self.get_first_scene_item_for_scene_point(&scene_position) {
+        if let Some(scene_item_usize) =
+            self.get_first_scene_item_for_scene_point(&scene_click_point)
+        {
             self.selected_scene_items.push(scene_item_usize);
         }
 
             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));
+                    scene_item.next_order = Some(Order::MoveTo(scene_click_point));
                 }
             }
 
             self.scene_item_prepare_order = None;
         }
 
-        // FIXME BS NOW: interpreter sur quel element du menu on a click ...
         if let Some((scene_item_usize, scene_menu_point)) = self.scene_item_menu {
-            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.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
-                && window_click_point.y <= window_menu_point.y + menu_sprite_info.height
+            let menu_sprite_info = vertical_menu_sprite_info(UiComponent::SceneItemMenu);
+            if let Some(menu_item) =
+                menu_sprite_info.item_clicked(&scene_menu_point, &scene_click_point)
             {
-                if let Some(menu_item) = menu_sprite_info.which_item_clicked(
-                    window_menu_point,
-                    window_click_point,
-                    scene_item,
-                ) {
-                    match menu_item {
-                        SceneItemMenuItem::Move => {
-                            self.scene_item_prepare_order =
-                                Some(SceneItemPrepareOrder::Move(scene_item_usize));
-                            self.scene_item_menu = None;
-                        }
+                match menu_item {
+                    MenuItem::Move => {
+                        self.scene_item_prepare_order =
+                            Some(SceneItemPrepareOrder::Move(scene_item_usize));
+                        self.scene_item_menu = None;
                     }
+                    MenuItem::MoveFast => {}
+                    MenuItem::Hide => {}
                 }
-            } else {
-                self.scene_item_menu = None;
-            }
+            };
+            self.scene_item_menu = None;
         };
     }
 
 
     fn generate_scene_item_menu_sprites(&mut self) -> GameResult {
         if let Some((_, scene_point)) = self.scene_item_menu {
-            for draw_param in UiSpriteInfo::from_type(UiItem::SceneItemMenu)
+            for draw_param in vertical_menu_sprite_info(UiComponent::SceneItemMenu)
                 .as_draw_params(&scene_point, &self.current_cursor_position)
             {
                 self.ui_batch.add(draw_param);

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::{Offset, ScenePoint, WindowPoint};
 
-pub mod scene_item_menu;
+pub mod vertical_menu;
 
 const SCENE_ITEM_MENU_WIDTH: f32 = 71.0;
 const SCENE_ITEM_MENU_HEIGHT: f32 = 68.0;
 const SCENE_ITEM_MENU_ITEM_HEIGHT: f32 = 15.0;
 
-pub enum UiItem {
+pub enum UiComponent {
     SceneItemMenu,
 }
-// FIXME BS NOW: Transformer ça en VerticalMenu, où l'on donne les carac des item aussi
-// --> ce sera capable de manière generique d'eclairer le bon item et dire quel item affiché
-pub struct UiSpriteInfo {
-    pub relative_start_x: f32,
-    pub relative_start_y: f32,
-    pub relative_width: f32,
-    pub relative_height: f32,
-    pub width: f32,
-    pub height: f32,
-}
-
-impl UiSpriteInfo {
-    pub fn from_type(type_: UiItem) -> Self {
-        match type_ {
-            UiItem::SceneItemMenu => Self {
-                relative_start_x: 0.0,
-                relative_start_y: 0.0,
-                relative_width: SCENE_ITEM_MENU_WIDTH / UI_SPRITE_SHEET_WIDTH,
-                relative_height: SCENE_ITEM_MENU_HEIGHT / UI_SPRITE_SHEET_HEIGHT,
-                width: SCENE_ITEM_MENU_WIDTH,
-                height: SCENE_ITEM_MENU_HEIGHT,
-            },
-        }
-    }
-
-    pub fn as_draw_params(
-        &self,
-        scene_point: &ScenePoint,
-        scene_current_cursor_point: &ScenePoint,
-    ) -> Vec<graphics::DrawParam> {
-        // FIXME BS NOW: this is a generic struct ! not SceneItemMenu struct
-        let mut draw_params = vec![graphics::DrawParam::new()
-            .src(graphics::Rect::new(
-                self.relative_start_x,
-                self.relative_start_y,
-                self.relative_width,
-                self.relative_height,
-            ))
-            .dest(*scene_point)];
-
-        let relative_cursor_position: Offset = Offset::new(
-            scene_current_cursor_point.x - scene_point.x,
-            scene_current_cursor_point.y - scene_point.y,
-        );
-
-        // Cursor inside menu
-        if relative_cursor_position.x >= 0.0
-            && relative_cursor_position.x <= SCENE_ITEM_MENU_WIDTH
-            && relative_cursor_position.y >= 0.0
-            && relative_cursor_position.y <= SCENE_ITEM_MENU_HEIGHT
-        {
-            let hover_item_i = (relative_cursor_position.y / SCENE_ITEM_MENU_ITEM_HEIGHT) as i32;
-            let source = graphics::Rect::new(
-                self.relative_width,
-                (SCENE_ITEM_MENU_ITEM_HEIGHT / UI_SPRITE_SHEET_HEIGHT) * hover_item_i as f32,
-                self.relative_width,
-                SCENE_ITEM_MENU_ITEM_HEIGHT / UI_SPRITE_SHEET_HEIGHT,
-            );
-            let destination = ScenePoint::new(
-                scene_point.x,
-                scene_point.y + (SCENE_ITEM_MENU_ITEM_HEIGHT * hover_item_i as f32),
-            );
-            draw_params.push(graphics::DrawParam::new().src(source).dest(destination));
-        }
-
-        draw_params
-    }
-
-    // FIXME BS NOW: this is a generic struct ! not SceneItemMenu struct
-    pub fn which_item_clicked(
-        &self,
-        _window_menu_point: WindowPoint,
-        _window_click_point: WindowPoint,
-        _scene_item: &SceneItem,
-    ) -> Option<SceneItemMenuItem> {
-        Some(SceneItemMenuItem::Move)
-    }
-}
 
 #[derive(Debug)]
 pub enum UserEvent {
-    Click(WindowPoint),                      // Window coordinates
-    RightClick(WindowPoint),                 // Window coordinates
-    AreaSelection(WindowPoint, WindowPoint), // Window coordinates
+    Click(WindowPoint),
+    RightClick(WindowPoint),
+    AreaSelection(WindowPoint, WindowPoint),
 }
 
 pub enum SceneItemPrepareOrder {
     Move(usize), // scene_item usize
 }
+
+#[derive(Clone)]
+pub enum MenuItem {
+    Move,
+    MoveFast,
+    Hide,
+}

src/ui/scene_item_menu.rs

-pub enum SceneItemMenuItem {
-    Move,
-}

src/ui/vertical_menu.rs

+use ggez::graphics;
+
+use crate::config::{UI_SPRITE_SHEET_HEIGHT, UI_SPRITE_SHEET_WIDTH};
+use crate::ui::{
+    MenuItem, UiComponent, SCENE_ITEM_MENU_HEIGHT, SCENE_ITEM_MENU_ITEM_HEIGHT,
+    SCENE_ITEM_MENU_WIDTH,
+};
+use crate::{Offset, ScenePoint};
+
+pub fn vertical_menu_sprite_info(type_: UiComponent) -> VerticalMenuSpriteInfo {
+    match type_ {
+        UiComponent::SceneItemMenu => VerticalMenuSpriteInfo {
+            relative_start_x: 0.0,
+            relative_start_y: 0.0,
+            relative_width: SCENE_ITEM_MENU_WIDTH / UI_SPRITE_SHEET_WIDTH,
+            relative_height: SCENE_ITEM_MENU_HEIGHT / UI_SPRITE_SHEET_HEIGHT,
+            width: SCENE_ITEM_MENU_WIDTH,
+            height: SCENE_ITEM_MENU_HEIGHT,
+            item_height: SCENE_ITEM_MENU_ITEM_HEIGHT,
+            relative_item_height: SCENE_ITEM_MENU_ITEM_HEIGHT / UI_SPRITE_SHEET_HEIGHT,
+            item_matches: vec![MenuItem::Move, MenuItem::MoveFast, MenuItem::Hide],
+        },
+    }
+}
+
+pub struct VerticalMenuSpriteInfo {
+    pub relative_start_x: f32,
+    pub relative_start_y: f32,
+    pub relative_width: f32,
+    pub relative_height: f32,
+    pub width: f32,
+    pub height: f32,
+    pub item_height: f32,
+    pub relative_item_height: f32,
+    pub item_matches: Vec<MenuItem>,
+}
+
+impl VerticalMenuSpriteInfo {
+    fn item_position(
+        &self,
+        menu_scene_point: &ScenePoint,
+        current_cursor_scene_point: &ScenePoint,
+    ) -> Option<usize> {
+        let relative_cursor_position: Offset = Offset::new(
+            current_cursor_scene_point.x - menu_scene_point.x,
+            current_cursor_scene_point.y - menu_scene_point.y,
+        );
+
+        // Cursor inside menu
+        if relative_cursor_position.x >= 0.0
+            && relative_cursor_position.x <= SCENE_ITEM_MENU_WIDTH
+            && relative_cursor_position.y >= 0.0
+            && relative_cursor_position.y <= SCENE_ITEM_MENU_HEIGHT
+        {
+            return Some((relative_cursor_position.y / SCENE_ITEM_MENU_ITEM_HEIGHT) as usize);
+        }
+
+        None
+    }
+
+    pub fn as_draw_params(
+        &self,
+        menu_scene_point: &ScenePoint,
+        scene_current_cursor_point: &ScenePoint,
+    ) -> Vec<graphics::DrawParam> {
+        let mut draw_params = vec![graphics::DrawParam::new()
+            .src(graphics::Rect::new(
+                self.relative_start_x,
+                self.relative_start_y,
+                self.relative_width,
+                self.relative_height,
+            ))
+            .dest(*menu_scene_point)];
+
+        if let Some(item_position) =
+            self.item_position(menu_scene_point, scene_current_cursor_point)
+        {
+            let source = graphics::Rect::new(
+                self.relative_width,
+                self.relative_item_height * item_position as f32,
+                self.relative_width,
+                self.relative_item_height,
+            );
+            let destination = ScenePoint::new(
+                menu_scene_point.x,
+                menu_scene_point.y + (self.item_height * item_position as f32),
+            );
+            draw_params.push(graphics::DrawParam::new().src(source).dest(destination));
+        }
+
+        draw_params
+    }
+
+    pub fn item_clicked(
+        &self,
+        menu_scene_point: &ScenePoint,
+        scene_current_cursor_point: &ScenePoint,
+    ) -> Option<MenuItem> {
+        if let Some(item_position) =
+            self.item_position(menu_scene_point, scene_current_cursor_point)
+        {
+            if let Some(menu_item) = self.item_matches.get(item_position) {
+                return Some(menu_item.clone());
+            }
+        };
+
+        None
+    }
+}