From 9a4d927d46fc7907ef88c78370fadac974ad3447 Mon Sep 17 00:00:00 2001
From: Victor <v.cornillere@gmail.com>
Date: Fri, 3 May 2019 08:53:30 +0200
Subject: [PATCH] Fixed custom state event reader

---
 src/main.rs                 |  1 -
 src/states/main_game.rs     | 79 ++++++++++++-------------------------
 src/states/mod.rs           | 51 ------------------------
 src/states/paused.rs        | 50 +++++++++--------------
 src/systems/time_control.rs |  1 -
 5 files changed, 44 insertions(+), 138 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index b041f27..358fb14 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -4,7 +4,6 @@ extern crate amethyst_derive;
 
 use amethyst;
 use amethyst::assets::PrefabLoaderSystem;
-use amethyst::derive;
 use amethyst::{
     audio::AudioBundle,
     core::transform::{Transform, TransformBundle},
diff --git a/src/states/main_game.rs b/src/states/main_game.rs
index 5a62b54..27e70fd 100644
--- a/src/states/main_game.rs
+++ b/src/states/main_game.rs
@@ -7,10 +7,9 @@ use amethyst::{
     },
     State,
     ecs::*,
-    input::{is_key_down, InputEvent},
+    input::{InputEvent},
     prelude::*,
     renderer::*,
-    shrev::{EventChannel, ReaderId},
 };
 use rand::{thread_rng, Rng};
 
@@ -21,15 +20,12 @@ use crate::resources::world_bounds::*;
 use crate::states::{
     paused::PausedState,
     CustomStateEvent,
-    CustomStateEventReader,
 };
 use crate::systems::*;
 
 pub struct MainGameState {
     dispatcher: Dispatcher<'static, 'static>,
     ui_dispatcher: Dispatcher<'static, 'static>,
-
-    input_event_reader_id: Option<ReaderId<InputEvent<String>>>,
 }
 
 impl Default for MainGameState {
@@ -100,20 +96,37 @@ impl Default for MainGameState {
                     &[],
                 )
                 .build(),
-
-            input_event_reader_id: None,
         }
     }
 }
 
 impl<'a> State<GameData<'a, 'a>, CustomStateEvent> for MainGameState {
-    fn handle_event(&mut self, _data: StateData<GameData<'a, 'a>>, event: CustomStateEvent) -> Trans<GameData<'a, 'a>, CustomStateEvent> {
+    fn handle_event(&mut self, data: StateData<GameData<'a, 'a>>, event: CustomStateEvent) -> Trans<GameData<'a, 'a>, CustomStateEvent> {
         match event {
-            CustomStateEvent::Window(ev) => println!("Got window event {:?}", ev), // Events related to the window and inputs.
-            CustomStateEvent::Ui(_) => {}, // Ui event. Button presses, mouse hover, etc...
-            CustomStateEvent::Input(ev) => println!("Got an input event: {:?}", ev),
+            CustomStateEvent::Window(_) => (), // Events related to the window and inputs.
+            CustomStateEvent::Ui(_) => (), // Ui event. Button presses, mouse hover, etc...
+            CustomStateEvent::Input(input_event) => {
+                match input_event {
+                    InputEvent::ActionPressed(action_name) => {
+                        match action_name.as_ref() {
+                            "TogglePause" => return Trans::Push(Box::new(PausedState::default())),
+                            "SpeedUp" => {
+                                let mut time_resource = data.world.write_resource::<Time>();
+                                let current_time_scale = time_resource.time_scale();
+                                time_resource.set_time_scale(2.0 * current_time_scale);
+                            }
+                            "SlowDown" => {
+                                let mut time_resource = data.world.write_resource::<Time>();
+                                let current_time_scale = time_resource.time_scale();
+                                time_resource.set_time_scale(0.5 * current_time_scale);
+                            }
+                            _ => (),
+                        }
+                    }
+                    _ => (),
+                }
+            },
         };
-
         Trans::None
     }
 
@@ -121,12 +134,6 @@ impl<'a> State<GameData<'a, 'a>, CustomStateEvent> for MainGameState {
         self.dispatcher.setup(&mut data.world.res);
         self.ui_dispatcher.setup(&mut data.world.res);
 
-        self.input_event_reader_id = Some(
-            data.world
-                .write_resource::<EventChannel<InputEvent<String>>>()
-                .register_reader(),
-        );
-
         data.world.add_resource(DebugLinesParams {
             line_width: 1.0 / 20.0,
         });
@@ -218,44 +225,10 @@ impl<'a> State<GameData<'a, 'a>, CustomStateEvent> for MainGameState {
 
     fn update(&mut self, data: StateData<'_, GameData<'a, 'a>>) -> Trans<GameData<'a, 'a>, CustomStateEvent> {
         self.dispatcher.dispatch(&mut data.world.res);
-
-        let input_event_channel = data
-            .world
-            .read_resource::<EventChannel<InputEvent<String>>>();
-        for event in input_event_channel.read(self.input_event_reader_id.as_mut().unwrap()) {
-            match event {
-                InputEvent::ActionPressed(action_name) => {
-                    match action_name.as_ref() {
-                        "TogglePause" => return Trans::Push(Box::new(PausedState::default())),
-                        "SpeedUp" => {
-                            let mut time_resource = data.world.write_resource::<Time>();
-                            let current_time_scale = time_resource.time_scale();
-                            time_resource.set_time_scale(2.0 * current_time_scale);
-                        }
-                        "SlowDown" => {
-                            let mut time_resource = data.world.write_resource::<Time>();
-                            let current_time_scale = time_resource.time_scale();
-                            time_resource.set_time_scale(0.5 * current_time_scale);
-                        }
-                        _ => (),
-                    }
-                }
-                _ => (),
-            }
-        }
+        data.data.update(&data.world);
         Trans::None
     }
 
-    fn on_resume(&mut self, data: StateData<'_, GameData<'a, 'a>>) {
-        // We re-register the ReaderId when switching back to the state to avoid reading events
-        // that happened when the state was inactive.
-        self.input_event_reader_id = Some(
-            data.world
-                .write_resource::<EventChannel<InputEvent<String>>>()
-                .register_reader(),
-        );
-    }
-
     fn shadow_update(&mut self, data: StateData<'_, GameData<'a, 'a>>) {
         self.ui_dispatcher.dispatch(&mut data.world.res);
     }
diff --git a/src/states/mod.rs b/src/states/mod.rs
index 65f2be7..f56fddc 100644
--- a/src/states/mod.rs
+++ b/src/states/mod.rs
@@ -1,8 +1,6 @@
 pub mod main_game;
 pub mod paused;
 
-use amethyst::derive;
-
 use amethyst::{
     core::EventReader,
     ui::UiEvent,
@@ -19,52 +17,3 @@ pub enum CustomStateEvent {
     Ui(UiEvent),
     Input(InputEvent<String>),
 }
-
-//#[derive(Default)]
-//pub struct CustomStateEventReader {
-//    window_reader_id: Option<ReaderId<WindowEvent>>,
-//    ui_reader_id: Option<ReaderId<UiEvent>>,
-//    input_reader_id: Option<ReaderId<InputEvent<String>>>,
-//}
-//
-//impl<'r> EventReader<'r> for CustomStateEventReader {
-//    type SystemData = (
-//    Read<'r, EventChannel<WindowEvent>>,
-//    Read<'r, EventChannel<UiEvent>>,
-//    Read<'r, EventChannel<InputEvent<String>>>,
-//    );
-//
-//    type Event = CustomStateEvent;
-//
-//    fn read(&mut self, (window_events, ui_events, input_events): Self::SystemData, events: &mut Vec<Self::Event>) {
-//        println!("Reading events");
-//        for event in window_events.read(self.window_reader_id.as_mut().unwrap()) {
-//            events.push(CustomStateEvent::Window(event.clone()));
-//            println!("Add window event.");
-//        }
-//        for event in ui_events.read(self.ui_reader_id.as_mut().unwrap()) {
-//            events.push(CustomStateEvent::Ui(event.clone()));
-//            println!("Add ui event.");
-//        }
-//        for event in input_events.read(self.input_reader_id.as_mut().unwrap()) {
-//            events.push(CustomStateEvent::Input(event.clone()));
-//            println!("Add input event.");
-//        }
-//    }
-//
-//    fn setup(&mut self, res: &mut Resources) {
-//        Self::SystemData::setup(res);
-//        self.window_reader_id = Some(
-//            res.fetch_mut::<EventChannel<WindowEvent>>()
-//                .register_reader(),
-//        );
-//        self.ui_reader_id = Some(
-//            res.fetch_mut::<EventChannel<UiEvent>>()
-//                .register_reader(),
-//        );
-//        self.input_reader_id = Some(
-//            res.fetch_mut::<EventChannel<InputEvent<String>>>()
-//                .register_reader(),
-//        );
-//    }
-//}
diff --git a/src/states/paused.rs b/src/states/paused.rs
index 79ff2e6..22d9058 100644
--- a/src/states/paused.rs
+++ b/src/states/paused.rs
@@ -1,58 +1,44 @@
 use amethyst::{
     input::InputEvent,
     prelude::*,
-    shrev::{EventChannel, ReaderId},
 };
 
 use crate::states::{
     CustomStateEvent,
-    CustomStateEventReader,
 };
 
 pub struct PausedState {
-    input_event_reader_id: Option<ReaderId<InputEvent<String>>>,
 }
 
 impl Default for PausedState {
     fn default() -> Self {
         PausedState {
-            input_event_reader_id: None,
         }
     }
 }
 
 impl<'a> State<GameData<'a, 'a>, CustomStateEvent> for PausedState {
-    fn on_start(&mut self, mut data: StateData<'_, GameData<'a, 'a>>) {
-        self.input_event_reader_id = Some(
-            data.world
-                .write_resource::<EventChannel<InputEvent<String>>>()
-                .register_reader(),
-        );
-    }
-
-    fn on_resume(&mut self, data: StateData<'_, GameData>) {
-        // We re-register the ReaderId when switching back to the state to avoid reading events
-        // that happened when the state was inactive.
-        self.input_event_reader_id = Some(
-            data.world
-                .write_resource::<EventChannel<InputEvent<String>>>()
-                .register_reader(),
-        );
+    fn handle_event(&mut self, _data: StateData<GameData<'a, 'a>>, event: CustomStateEvent) -> Trans<GameData<'a, 'a>, CustomStateEvent> {
+        match event {
+            CustomStateEvent::Window(_) => (), // Events related to the window and inputs.
+            CustomStateEvent::Ui(_) => (), // Ui event. Button presses, mouse hover, etc...
+            CustomStateEvent::Input(input_event) => {
+                match input_event {
+                    InputEvent::ActionPressed(action_name) => {
+                        match action_name.as_ref() {
+                            "TogglePause" => return Trans::Pop,
+                            _ => (),
+                        }
+                    }
+                    _ => (),
+                }
+            },
+        };
+        Trans::None
     }
 
     fn update(&mut self, data: StateData<'_, GameData<'a, 'a>>) -> Trans<GameData<'a, 'a>, CustomStateEvent> {
-        let input_event_channel = data
-            .world
-            .read_resource::<EventChannel<InputEvent<String>>>();
-        for event in input_event_channel.read(self.input_event_reader_id.as_mut().unwrap()) {
-            match event {
-                InputEvent::ActionPressed(action_name) => match action_name.as_ref() {
-                    "TogglePause" => return Trans::Pop,
-                    _ => (),
-                },
-                _ => (),
-            }
-        }
+        data.data.update(&data.world);
         Trans::None
     }
 }
diff --git a/src/systems/time_control.rs b/src/systems/time_control.rs
index 22cd984..d39645f 100644
--- a/src/systems/time_control.rs
+++ b/src/systems/time_control.rs
@@ -1,6 +1,5 @@
 use amethyst::{
     assets::{AssetStorage, Loader},
-    core::timing::Time,
     ecs::*,
     input::InputEvent,
     shrev::{EventChannel, ReaderId},