- don#t use get_primary input to get navigation descriptions for game over or pause scene, use underlying input:

- make every game controller have an underlying input
- all have a really one, except replay input, that uses the primary input, so that you get the description for that!

Author: Totto16

src/input/controller_input.hpp

@@ -72,9 +72,6 @@ namespace input {
         ControllerInput* m_underlying_input;
 
 
-    protected:
-        [[nodiscard]] const ControllerInput* underlying_input() const;
-
     public:
         ControllerGameInput(
                 ControllerSettings settings,
@@ -86,6 +83,8 @@ namespace input {
 
         [[nodiscard]] std::string describe_menu_event(MenuEvent event) const override;
 
+        [[nodiscard]] const ControllerInput* underlying_input() const override;
+
     protected:
         [[nodiscard]] helper::optional<InputEvent> sdl_event_to_input_event(const SDL_Event& event) const override;
     };

src/input/game_input.hpp

@@ -30,16 +30,19 @@ namespace input {
     enum class MenuEvent : u8 { OpenSettings, Pause };
 
 
+    enum class HoldableKey : u8 {
+        Left,
+        Right,
+    };
+
+    // forward declaration
+    struct Input;
+
     struct GameInput {
     public:
         using OnEventCallback = std::function<void(InputEvent, SimulationStep)>;
 
     private:
-        enum class HoldableKey : u8 {
-            Left,
-            Right,
-        };
-
         static constexpr u64 delayed_auto_shift_frames = 10;
         static constexpr u64 auto_repeat_rate_frames = 2;
 
@@ -62,6 +65,15 @@ namespace input {
         }
 
     public:
+        GameInput(const GameInput&) = delete;
+        GameInput& operator=(const GameInput&) = delete;
+
+        GameInput(GameInput&&) = default;
+        GameInput& operator=(GameInput&&) = default;
+
+        virtual ~GameInput() = default;
+
+
         virtual void update(SimulationStep simulation_step_index);
         virtual void late_update(SimulationStep /*simulation_step*/){};
 
@@ -86,12 +98,7 @@ namespace input {
             m_on_event_callback = std::move(on_event_callback);
         }
 
-        GameInput(const GameInput&) = delete;
-        GameInput& operator=(const GameInput&) = delete;
 
-        GameInput(GameInput&&) = default;
-        GameInput& operator=(GameInput&&) = default;
-
-        virtual ~GameInput() = default;
+        [[nodiscard]] virtual const Input* underlying_input() const = 0;
     };
 } // namespace input

src/input/input.cpp

@@ -385,17 +385,17 @@ input::InputManager::get_game_input( //NOLINT(readability-convert-member-functio
     return helper::unexpected<std::string>{ "No input was found, failed to get by settings and by primary input" };
 }
 
-[[nodiscard]] const std::unique_ptr<input::Input>& input::InputManager::get_primary_input() {
+[[nodiscard]] const input::Input* input::InputManager::get_primary_input() {
 
     for (const auto& input : m_inputs) {
         if (const auto pointer_input = utils::is_child_class<PrimaryInputType>(input); pointer_input.has_value()) {
-            return input;
+            return input.get();
         }
     }
 
     // this should always be true, since in the initialization the first one, that is ALWAYS added is the KeyboardInput
     assert(not m_inputs.empty() && "at least one input has to be given");
-    return m_inputs.at(0);
+    return m_inputs.at(0).get();
 }
 
 input::PointerInput::PointerInput(const std::string& name) : Input{ name, input::InputType::Pointer } { }

src/input/input.hpp

@@ -109,7 +109,7 @@ namespace input {
                 ServiceProvider* service_provider
         );
 
-        [[nodiscard]] const std::unique_ptr<input::Input>& get_primary_input();
+        [[nodiscard]] const input::Input* get_primary_input();
     };
 
 

src/input/input_creator.cpp

@@ -71,7 +71,9 @@ namespace {
 
     for (u8 tetrion_index = 0; tetrion_index < static_cast<u8>(tetrion_headers.size()); ++tetrion_index) {
 
-        auto input = std::make_unique<ReplayGameInput>(recording_reader);
+        const auto* primary_input = service_provider->input_manager().get_primary_input();
+
+        auto input = std::make_unique<ReplayGameInput>(recording_reader, primary_input);
 
         const auto& header = tetrion_headers.at(tetrion_index);
 

src/input/joystick_input.hpp

@@ -261,9 +261,6 @@ namespace input {
     private:
         JoystickInput* m_underlying_input;
 
-    protected:
-        [[nodiscard]] const JoystickInput* underlying_input() const;
-
     public:
         JoystickGameInput(EventDispatcher* event_dispatcher, JoystickInput* underlying_input);
 
@@ -275,6 +272,8 @@ namespace input {
                 const JoystickSettings& settings
         );
 
+        [[nodiscard]] const JoystickInput* underlying_input() const override;
+
     protected:
         template<typename T>
         [[nodiscard]] static helper::expected<AbstractJoystickSettings<T>, std::string>

src/input/keyboard_input.cpp

@@ -149,7 +149,8 @@ helper::optional<InputEvent> input::KeyboardGameInput::sdl_event_to_input_event(
 input::KeyboardGameInput::KeyboardGameInput(const KeyboardSettings& settings, EventDispatcher* event_dispatcher)
     : GameInput{ GameInputType::Keyboard },
       m_settings{ settings },
-      m_event_dispatcher{ event_dispatcher } {
+      m_event_dispatcher{ event_dispatcher },
+      m_underlying_input{} {
     m_event_dispatcher->register_listener(this);
 }
 
@@ -216,3 +217,7 @@ sdl::Key json_helper::get_key(const nlohmann::json& obj, const std::string& name
             utils::unreachable();
     }
 }
+
+[[nodiscard]] const input::KeyboardInput* input::KeyboardGameInput::underlying_input() const {
+    return &m_underlying_input;
+}

src/input/keyboard_input.hpp

@@ -59,6 +59,7 @@ namespace input {
         KeyboardSettings m_settings;
         std::vector<SDL_Event> m_event_buffer;
         EventDispatcher* m_event_dispatcher;
+        KeyboardInput m_underlying_input;
 
     public:
         KeyboardGameInput(const KeyboardSettings& settings, EventDispatcher* event_dispatcher);
@@ -80,6 +81,8 @@ namespace input {
 
         [[nodiscard]] std::string describe_menu_event(MenuEvent event) const override;
 
+        [[nodiscard]] const KeyboardInput* underlying_input() const override;
+
     private:
         [[nodiscard]] helper::optional<InputEvent> sdl_event_to_input_event(const SDL_Event& event) const;
     };

src/input/replay_input.cpp

@@ -3,9 +3,13 @@
 #include "helper/magic_enum_wrapper.hpp"
 #include "helper/optional.hpp"
 
-input::ReplayGameInput::ReplayGameInput(std::shared_ptr<recorder::RecordingReader> recording_reader)
+input::ReplayGameInput::ReplayGameInput(
+        std::shared_ptr<recorder::RecordingReader> recording_reader,
+        const Input* underlying_input
+)
     : GameInput{ GameInputType::Recording },
-      m_recording_reader{ std::move(recording_reader) } { }
+      m_recording_reader{ std::move(recording_reader) },
+      m_underlying_input{ underlying_input } { }
 
 void input::ReplayGameInput::update(const SimulationStep simulation_step_index) {
     while (true) {
@@ -89,3 +93,7 @@ void input::ReplayGameInput::late_update(const SimulationStep simulation_step_in
 [[nodiscard]] bool input::ReplayGameInput::is_end_of_recording() const {
     return m_next_record_index >= m_recording_reader->num_records();
 }
+
+[[nodiscard]] const input::Input* input::ReplayGameInput::underlying_input() const {
+    return m_underlying_input;
+}

src/input/replay_input.hpp

@@ -13,9 +13,10 @@ namespace input {
         std::shared_ptr<recorder::RecordingReader> m_recording_reader;
         usize m_next_record_index{ 0 };
         usize m_next_snapshot_index{ 0 };
+        const Input* m_underlying_input;
 
     public:
-        explicit ReplayGameInput(std::shared_ptr<recorder::RecordingReader> recording_reader);
+        ReplayGameInput(std::shared_ptr<recorder::RecordingReader> recording_reader, const Input* underlying_input);
 
         void update(SimulationStep simulation_step_index) override;
         void late_update(SimulationStep simulation_step_index) override;
@@ -25,6 +26,8 @@ namespace input {
         [[nodiscard]] std::string describe_menu_event(MenuEvent event) const override;
 
         [[nodiscard]] bool is_end_of_recording() const;
+
+        [[nodiscard]] const Input* underlying_input() const override;
     };
 
 } // namespace input