fix target fps:

always simulate at 60 fps, an exception is, when a replay says, it uses another simulation frequency (which is not part of the standard, since this is stored in the additional information section of the recording format)
- we simulate 60 times per second, even if the display /  render frequency may be less or more
- allow faster simulation frequencies per se, since later we might add a speedup, alias play speed for recordings or similar.
- since in recordings we store the simulation index it is crucial to know which simulation_frequency we used, but it's not an additional field, so that we don#t break backwards compatibility, for that I added the additional information format earlier

Author: Totto16

src/game/game.cpp

@@ -8,11 +8,12 @@ Game::Game(
         ServiceProvider* const service_provider,
         const std::shared_ptr<input::GameInput>& input,
         const tetrion::StartingParameters& starting_parameters,
+        u32 simulation_frequency,
         const ui::Layout& layout,
         bool is_top_level
 )
     : ui::Widget{ layout, ui::WidgetType::Component, is_top_level },
-      m_clock_source{ std::make_unique<LocalClock>(starting_parameters.target_fps) },
+      m_clock_source{ std::make_unique<LocalClock>(simulation_frequency) },
       m_input{ input } {
 
 

src/game/game.hpp

@@ -21,6 +21,7 @@ struct Game : public ui::Widget {
             ServiceProvider* service_provider,
             const std::shared_ptr<input::GameInput>& input,
             const tetrion::StartingParameters& starting_parameters,
+            u32 simulation_frequency,
             const ui::Layout& layout,
             bool is_top_level
     );

src/helper/constants.hpp

@@ -15,8 +15,9 @@ namespace constants {
     constexpr auto program_name = StaticString{ STRINGIFY(OOPETRIS_NAME) };
     constexpr auto author = StaticString{ STRINGIFY(OOPETRIS_AUTHOR) };
     constexpr auto version = StaticString{ STRINGIFY(OOPETRIS_VERSION) };
-    constexpr auto music_change_level = 30;
+    constexpr u32 music_change_level = 30;
     constexpr auto recordings_directory = "recordings";
+    constexpr u32 simulation_frequency = 60;
 
 #if not defined(AUDIO_QUALITY)
 #define AUDIO_QUALITY 0 // NOLINT(cppcoreguidelines-macro-usage)

src/input/input_creator.cpp

@@ -1,6 +1,7 @@
 
 
 #include "input_creator.hpp"
+#include "additional_information.hpp"
 #include "helper/command_line_arguments.hpp"
 #include "helper/date.hpp"
 #include "helper/errors.hpp"
@@ -44,7 +45,8 @@ namespace {
 } // namespace
 
 
-[[nodiscard]] std::vector<input::AdditionalInfo> input::get_game_parameters_for_replay(
+[[nodiscard]] std::pair<std::vector<input::AdditionalInfo>, recorder::AdditionalInformation>
+input::get_game_parameters_for_replay(
         ServiceProvider* const service_provider,
         const std::filesystem::path& recording_path
 ) {
@@ -67,6 +69,7 @@ namespace {
 
     const auto tetrion_headers = recording_reader->tetrion_headers();
 
+
     result.reserve(tetrion_headers.size());
 
     for (u8 tetrion_index = 0; tetrion_index < static_cast<u8>(tetrion_headers.size()); ++tetrion_index) {
@@ -87,7 +90,7 @@ namespace {
     }
 
 
-    return result;
+    return { result, recording_reader->information() };
 }
 
 

src/input/input_creator.hpp

@@ -36,7 +36,7 @@ namespace input {
 
     using AdditionalInfo = std::tuple<std::shared_ptr<input::GameInput>, tetrion::StartingParameters>;
 
-    [[nodiscard]] std::vector<input::AdditionalInfo>
+    [[nodiscard]] std::pair<std::vector<input::AdditionalInfo>, recorder::AdditionalInformation>
     get_game_parameters_for_replay(ServiceProvider* service_provider, const std::filesystem::path& recording_path);
 
     [[nodiscard]] helper::expected<input::AdditionalInfo, std::string> get_single_player_game_parameters(

src/recordings/additional_information.cpp

@@ -470,13 +470,18 @@ void recorder::AdditionalInformation::add_value(const std::string& key, const In
 
 helper::optional<recorder::InformationValue> recorder::AdditionalInformation::get(const std::string& key) const {
 
-    if (not m_values.contains(key)) {
+    if (not has(key)) {
         return helper::nullopt;
     }
 
     return m_values.at(key);
 }
 
+[[nodiscard]] bool recorder::AdditionalInformation::has(const std::string& key) const {
+    return m_values.contains(key);
+}
+
+
 [[nodiscard]] helper::expected<std::vector<char>, std::string> recorder::AdditionalInformation::to_bytes() const {
     auto bytes = std::vector<char>{};
 

src/recordings/additional_information.hpp

@@ -149,10 +149,12 @@ namespace recorder {
 
         [[nodiscard]] helper::optional<InformationValue> get(const std::string& key) const;
 
+        [[nodiscard]] bool has(const std::string& key) const;
+
         template<typename T>
         [[nodiscard]] helper::optional<T> get_if(const std::string& key) const {
 
-            if (not m_values.contains(key)) {
+            if (not has(key)) {
                 return helper::nullopt;
             }
 

src/scenes/replay_game/replay_game.cpp

@@ -16,7 +16,7 @@ namespace scenes {
     )
         : Scene{ service_provider, layout } {
 
-        auto parameters = input::get_game_parameters_for_replay(service_provider, recording_path);
+        auto [parameters, information] = input::get_game_parameters_for_replay(service_provider, recording_path);
 
 
         std::vector<ui::Layout> layouts{};
@@ -35,11 +35,18 @@ namespace scenes {
             throw std::runtime_error("At the moment only replays from up to two players are supported");
         }
 
+        u32 simulation_frequency = constants::simulation_frequency;
+        if (const auto stored_simulation_frequency = information.get_if<u32>("simulation_frequency");
+            stored_simulation_frequency.has_value()) {
+            simulation_frequency = stored_simulation_frequency.value();
+        }
+
+
         for (decltype(parameters.size()) i = 0; i < parameters.size(); ++i) {
             auto [input, starting_parameters] = std::move(parameters.at(i));
 
             m_games.emplace_back(std::make_unique<Game>(
-                    service_provider, std::move(input), starting_parameters, layouts.at(i), false
+                    service_provider, std::move(input), starting_parameters, simulation_frequency, layouts.at(i), false
             ));
         }
 

src/scenes/single_player_game/single_player_game.cpp

@@ -18,14 +18,16 @@ namespace scenes {
         : Scene{ service_provider, layout } {
 
         const auto date = date::ISO8601Date::now();
+        const auto simulation_frequency = constants::simulation_frequency;
+
 
         recorder::AdditionalInformation additional_information{};
+        additional_information.add<u32>("simulation_frequency", simulation_frequency);
         additional_information.add("mode", "single_player");
         additional_information.add("platform", std::string{ magic_enum::enum_name(utils::get_platform()) });
         additional_information.add("date", date.value());
         //TODO(Totto): add more information, if logged in
 
-
         auto result =
                 input::get_single_player_game_parameters(service_provider, std::move(additional_information), date);
 
@@ -38,7 +40,9 @@ namespace scenes {
 
         auto [input, starting_parameters] = result.value();
 
-        m_game = std::make_unique<Game>(service_provider, std::move(input), starting_parameters, layout, true);
+        m_game = std::make_unique<Game>(
+                service_provider, std::move(input), starting_parameters, simulation_frequency, layout, true
+        );
 
 
 #if defined(_HAVE_DISCORD_SDK)