Add medium difficulty and main menu

Author: Paul Reesman

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "evil_penguin"
-version = "0.8.0"
+version = "0.8.1"
 authors = ["Paul Reesman <[email protected]>"]
 edition = "2018"
 

TODO.md

@@ -3,11 +3,13 @@
 - [x] Player sprite
 - [ ] Main menu
   - [X] Title Menu
-  - [ ] Main Menu
+  - [x] Main Menu
   - [ ] How to Play Menu
   - [ ] Settings Menu
-  - [ ] Play Menu
-- [ ] Pause Menu
+  - [x] Play Menu
+- [x] Pause Menu
 - [x] End game menu
 - [ ] Configurable difficulty
-  - [ ] Machine learned difficulty as hardest
+  - [x] Easy
+  - [x] Medium
+  - [ ] Hard

resources/assets/ui_layouts/main_menu.ron

@@ -11,14 +11,14 @@ Container(
                 id: "main_title",
                 anchor: Middle,
                 x: 0.0,
-                y: 100.0,
+                y: 150.0,
                 z: 1.0,
                 height: 100.0,
                 width: 500.0
             ),
             text: (
-                text: "Evil Penguin",
-                font_size: 50,
+                text: "Main Menu",
+                font_size: 40,
                 color: (1.0, 1.0, 1.0, 1.0),
                 align: Middle
             )
@@ -31,6 +31,55 @@ Container(
             background: SolidColor(0.0, 0.0, 0.0, 1.0),
             children: [
                 Button(
+                    transform: (
+                        id: "play_easy",
+                        anchor: Middle,
+                        x: 0.0,
+                        y: 100.0,
+                        z: 1.0,
+                        height: 50.0,
+                        width: 500.0
+                    ),
+                    button: (
+                        id: 0,
+                        text: "Play: Easy",
+                        font_size: 20,
+                        normal_text_color: (1.0, 1.0, 1.0, 1.0)
+                    )
+                ),
+                Button(
+                    transform: (
+                        id: "play_medium",
+                        anchor: Middle,
+                        x: 0.0,
+                        y: 50.0,
+                        z: 1.0,
+                        height: 50.0,
+                        width: 500.0
+                    ),
+                    button: (
+                        id: 1,
+                        text: "Play: Medium",
+                        font_size: 20,
+                        normal_text_color: (1.0, 1.0, 1.0, 1.0)
+                    )
+                ),
+                Button(
+                    transform: (
+                        id: "play_hard",
+                        anchor: Middle,
+                        x: 0.0,
+                        y: 0.0,
+                        z: 1.0,
+                        height: 50.0,
+                        width: 500.0
+                    ),
+                    button: (
+                        id: 2,
+                        text: "Play: Hard",
+                        font_size: 20,
+                        normal_text_color: (1.0, 1.0, 1.0, 1.0)
+                    )
                 )
             ]
         )

src/states/loading.state.rs

@@ -16,10 +16,12 @@ use crate::{
         RunState,
         menu::{
             LoseMenuState,
+            MainMenuState,
             StartMenuState,
             WinMenuState
         }
     },
+    systems::movement::Difficulty,
     util::types::SpritesheetLoadingData
 };
 
@@ -28,7 +30,8 @@ use std::collections::HashMap;
 pub enum NextLoadingState {
     Paused,
     UnPaused,
-    Run,
+    Run(Difficulty),
+    MainMenu,
     StartMenu,
     EndMenu(bool)
 }
@@ -45,12 +48,13 @@ impl SimpleState for LoadingState {
 
         let sprite_sheet_dependencies = match self.next_state {
             NextLoadingState::Paused => PausedState::get_dependent_spritesheets(),
-            NextLoadingState::Run => RunState::get_dependent_spritesheets(),
+            NextLoadingState::Run(_) => RunState::get_dependent_spritesheets(),
             NextLoadingState::StartMenu => StartMenuState::get_dependent_spritesheets(),
             NextLoadingState::EndMenu(is_win) => match is_win {
                 true => WinMenuState::get_dependent_spritesheets(),
                 false => LoseMenuState::get_dependent_spritesheets()
             },
+            NextLoadingState::MainMenu => MainMenuState::get_dependent_spritesheets(),
             _ => vec![]
         };
 
@@ -61,22 +65,24 @@ impl SimpleState for LoadingState {
 
     fn update(&mut self, _data: &mut StateData<GameData>) -> SimpleTrans {
         if self.progress_counter.is_complete() {
-            return match self.next_state {
+            return match &self.next_state {
                 NextLoadingState::Paused => Trans::Switch(Box::new(PausedState::default())),
                 NextLoadingState::UnPaused => Trans::Pop,
-                NextLoadingState::Run => {
+                NextLoadingState::Run(difficulty) => {
                     let mut run_state = RunState::default();
+                    run_state.set_difficulty((*difficulty).clone());
                     run_state.set_dependent_spritesheet_handles(&mut self.loading_assets);
                     Trans::Switch(Box::new(run_state))
                 },
                 NextLoadingState::StartMenu => Trans::None,
                 NextLoadingState::EndMenu(is_win) => {
-                    if is_win {
+                    if *is_win {
                         return Trans::Switch(Box::new(WinMenuState::default()));
                     }
 
                     Trans::Switch(Box::new(LoseMenuState::default()))
-                }
+                },
+                NextLoadingState::MainMenu => Trans::Switch(Box::new(MainMenuState::default()))
             }
         }
 

src/states/menu/lose_menu.state.rs

@@ -44,7 +44,7 @@ impl<'a, 'b> SimpleState for LoseMenuState<'a, 'b> {
     fn handle_event(&mut self, _data: StateData<'_, GameData<'_, '_>>, event: StateEvent) -> SimpleTrans {
         if let StateEvent::Window(e) = &event {
             if is_key_down(&e, VirtualKeyCode::Return) || is_key_down(&e, VirtualKeyCode::NumpadEnter) {
-                return Trans::Switch(Box::new(LoadingState::new(NextLoadingState::Run)));
+                return Trans::Switch(Box::new(LoadingState::new(NextLoadingState::MainMenu)));
             }
         }
 

src/states/menu/main_menu.state.rs

@@ -0,0 +1,78 @@
+use amethyst::{
+    assets::ProgressCounter,
+    ecs::{Dispatcher, DispatcherBuilder},
+    prelude::*,
+    ui::{FontHandle, UiFinder, UiEventType}
+};
+
+use crate::{
+    states::{
+        BaseState,
+        LoadingState,
+        NextLoadingState,
+        menu::BaseMenuState
+    },
+    systems::movement::Difficulty,
+    util::constants::MAIN_MENU_RON_PATH
+};
+
+#[derive(Default)]
+pub struct MainMenuState<'a, 'b> {
+    font: Option<FontHandle>,
+    dispatcher: Option<Dispatcher<'a, 'b>>,
+    progress_counter: ProgressCounter
+}
+
+impl<'a, 'b> SimpleState for MainMenuState<'a, 'b> {
+    fn on_start(&mut self, data: StateData<'_, GameData<'_, '_>>) {
+        let world = data.world;
+        let dispatcher_builder = DispatcherBuilder::new();
+
+        self.dispatcher = self.initialize_dispatcher(world, dispatcher_builder);
+        self.font = self.initialize_font(world);
+        self.initialize_menu(world, MAIN_MENU_RON_PATH);
+        self.initialize_camera(world);
+    }
+
+    fn on_stop(&mut self, data: StateData<'_, GameData<'_, '_>>) {
+        data.world.delete_all();
+    }
+
+    fn handle_event(&mut self, data: StateData<'_, GameData<'_, '_>>, event: StateEvent) -> SimpleTrans {
+        if let StateEvent::Ui(ui_event) = &event {
+            if ui_event.event_type == UiEventType::Click {
+                let (easy, medium, hard) = data.world.exec(|ui_finder: UiFinder<'_>| {
+                    (ui_finder.find("play_easy"), ui_finder.find("play_medium"), ui_finder.find("play_hard"))
+                });
+
+                if Some(ui_event.target) == easy {
+                    return Trans::Switch(Box::new(LoadingState::new(NextLoadingState::Run(Difficulty::Easy))))
+                } else if Some(ui_event.target) == medium {
+                    return Trans::Switch(Box::new(LoadingState::new(NextLoadingState::Run(Difficulty::Medium))))
+                } else if Some(ui_event.target) == hard {
+                    return Trans::Switch(Box::new(LoadingState::new(NextLoadingState::Run(Difficulty::Hard))))
+                }
+            }
+        }
+
+        Trans::None
+    }
+
+    fn update(&mut self, data: &mut StateData<GameData>) -> SimpleTrans {
+        if self.progress_counter.is_complete() {
+            if let Some(dispatcher) = self.dispatcher.as_mut() {
+                dispatcher.dispatch(&data.world);
+            }
+        }
+
+        Trans::None
+    }
+}
+
+impl<'a, 'b> BaseState for MainMenuState<'a,'b> {}
+
+impl<'a, 'b, 'c> BaseMenuState<'_, '_> for MainMenuState<'a, 'b> {
+    fn get_progress_counter(&mut self) -> &mut ProgressCounter {
+        &mut self.progress_counter
+    }
+}

src/states/menu/mod.rs

@@ -1,12 +1,15 @@
 #[path = "lose_menu.state.rs"]
 mod lose_menu_state;
+#[path = "main_menu.state.rs"]
+mod main_menu_state;
 #[path = "start_menu.state.rs"]
 mod start_menu_state;
 #[path = "win_menu.state.rs"]
 mod win_menu_state;
 
 pub use self::{
     lose_menu_state::LoseMenuState,
+    main_menu_state::MainMenuState,
     start_menu_state::StartMenuState,
     win_menu_state::WinMenuState
 };

src/states/menu/start_menu.state.rs

@@ -44,7 +44,7 @@ impl<'a, 'b> SimpleState for StartMenuState<'a, 'b> {
     fn handle_event(&mut self, _data: StateData<'_, GameData<'_, '_>>, event: StateEvent) -> SimpleTrans {
         if let StateEvent::Window(e) = &event {
             if is_key_down(&e, VirtualKeyCode::Return) || is_key_down(&e, VirtualKeyCode::NumpadEnter) {
-                return Trans::Switch(Box::new(LoadingState::new(NextLoadingState::Run)));
+                return Trans::Switch(Box::new(LoadingState::new(NextLoadingState::MainMenu)));
             }
         }
 

src/states/menu/win_menu.state.rs

@@ -44,7 +44,7 @@ impl<'a, 'b> SimpleState for WinMenuState<'a, 'b> {
     fn handle_event(&mut self, _data: StateData<'_, GameData<'_, '_>>, event: StateEvent) -> SimpleTrans {
         if let StateEvent::Window(e) = &event {
             if is_key_down(&e, VirtualKeyCode::Return) || is_key_down(&e, VirtualKeyCode::NumpadEnter) {
-                return Trans::Switch(Box::new(LoadingState::new(NextLoadingState::Run)));
+                return Trans::Switch(Box::new(LoadingState::new(NextLoadingState::MainMenu)));
             }
         }
 

src/states/run.state.rs

@@ -34,7 +34,9 @@ use crate::{
             EndConditionSystem
         },
         movement::{
-            PenguinMovementSystem,
+            EasyPenguinMovementSystem,
+            Difficulty,
+            MediumPenguinMovementSystem,
             PlayerMovementSystem
         }
     },
@@ -58,6 +60,7 @@ use crate::{
     }
 };
 use std::collections::HashMap;
+use crate::systems::movement::HardPenguinMovementSystem;
 
 /// Run State
 ///
@@ -70,7 +73,8 @@ pub struct RunState<'a, 'b> {
     progress_counter: ProgressCounter,
     coin_texture_handle: Option<Handle<SpriteSheet>>,
     penguin_texture_handle: Option<Handle<SpriteSheet>>,
-    player_texture_handle: Option<Handle<SpriteSheet>>
+    player_texture_handle: Option<Handle<SpriteSheet>>,
+    difficulty: Difficulty
 }
 
 impl<'a, 'b> SimpleState for RunState<'a, 'b> {
@@ -127,7 +131,8 @@ impl<'a, 'b> RunState<'a, 'b> {
             progress_counter: ProgressCounter::new(),
             coin_texture_handle: None,
             penguin_texture_handle: None,
-            player_texture_handle: None
+            player_texture_handle: None,
+            difficulty: Difficulty::Easy
         }
     }
 
@@ -137,9 +142,15 @@ impl<'a, 'b> RunState<'a, 'b> {
 
     fn initialize_dispatcher(&mut self, world: &mut World) {
         let mut dispatcher_builder = DispatcherBuilder::new();
-        dispatcher_builder.add(CoinRotationSystem, "coin_rotation_system", &[]);
         dispatcher_builder.add(PlayerMovementSystem, "player_movement_system", &[]);
-        dispatcher_builder.add(PenguinMovementSystem, "penguin_movement_system", &["player_movement_system"]);
+
+        match self.difficulty {
+            Difficulty::Easy => dispatcher_builder.add(EasyPenguinMovementSystem, "penguin_movement_system", &["player_movement_system"]),
+            Difficulty::Medium => dispatcher_builder.add(MediumPenguinMovementSystem, "penguin_movement_system", &["player_movement_system"]),
+            Difficulty::Hard => dispatcher_builder.add(HardPenguinMovementSystem, "penguin_movement_system", &["player_movement_system"])
+        }
+
+        dispatcher_builder.add(CoinRotationSystem, "coin_rotation_system", &[]);
         dispatcher_builder.add(CoinCollectionSystem, "coin_collection_system", &["player_movement_system"]);
         dispatcher_builder.add(EndConditionSystem, "end_condition_system", &["penguin_movement_system", "coin_collection_system"]);
 
@@ -221,6 +232,10 @@ impl<'a, 'b> RunState<'a, 'b> {
             .with(EndConditionComponent::default())
             .build();
     }
+
+    pub fn set_difficulty(&mut self, difficulty: Difficulty) {
+        self.difficulty = difficulty;
+    }
 }
 
 impl<'a, 'b> Default for RunState<'a, 'b> {

src/systems/movement/penguin_movement.system.rs src/systems/movement/easy_penguin_movement.system.rs

@@ -16,9 +16,9 @@ use crate::{
     systems::movement::EntityMovement
 };
 
-pub struct PenguinMovementSystem;
+pub struct EasyPenguinMovementSystem;
 
-impl<'a> System<'a> for PenguinMovementSystem {
+impl<'a> System<'a> for EasyPenguinMovementSystem {
     type SystemData = (
         ReadStorage<'a, PenguinComponent>,
         ReadStorage<'a, PlayerComponent>,
@@ -29,21 +29,21 @@ impl<'a> System<'a> for PenguinMovementSystem {
         Read<'a, AssetStorage<SpriteSheet>>
     );
 
-    fn run(&mut self, (penguin, player, sprite_renders, mut transform, mut movement, time, spritesheet_storage): Self::SystemData) {
+    fn run(&mut self, (penguin, player, sprite_renders, mut transform, mut movement, time, sprite_sheet_storage): Self::SystemData) {
         if let Some((player_transform, _)) = (&transform, &player).join().next() {
             let player_translation = player_transform.translation().clone();
             let (penguin_transform, penguin_movement, penguin_sprite_render, _) = (&mut transform, &mut movement, &sprite_renders, &penguin).join().next().unwrap();
             let penguin_translation = penguin_transform.translation().clone();
 
-            if let Some(penguin_spritesheet) = spritesheet_storage.get(&penguin_sprite_render.sprite_sheet) {
-                let penguin_sprite = penguin_spritesheet.sprites.get(0).unwrap();
+            if let Some(penguin_sprite_sheet) = sprite_sheet_storage.get(&penguin_sprite_render.sprite_sheet) {
+                let penguin_sprite = penguin_sprite_sheet.sprites.get(0).unwrap();
                 self.transform_entity(penguin_transform, &(player_translation, penguin_translation), &time, penguin_movement, penguin_sprite);
             }
         }
     }
 }
 
-impl EntityMovement for PenguinMovementSystem {
+impl EntityMovement for EasyPenguinMovementSystem {
     type AccelerationDirection = (
         Vector3<f32>,
         Vector3<f32>