implemented snapshots and their validation

Author: mgerhold

CMakeLists.txt

@@ -63,6 +63,8 @@ add_executable(oopetris
         src/controls.hpp
         src/mino_stack.cpp
         src/mino_stack.hpp
+        src/tetrion_snapshot.hpp
+        src/tetrion_snapshot.cpp
         )
 
 foreach (target ${TARGET_LIST})

src/controls.hpp

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "key_codes.hpp"
-#include "recording.hpp"
 
 struct KeyboardControls final {
     KeyCode rotate_left = KeyCode::Left;

src/input.cpp

@@ -1,6 +1,7 @@
 #include "input.hpp"
 #include "application.hpp"
 #include "key_codes.hpp"
+#include "recording.hpp"
 #include "tetrion.hpp"
 
 void Input::handle_event(const InputEvent event) {
@@ -176,3 +177,51 @@ void ReplayInput::update() {
 
     Input::update();
 }
+
+void ReplayInput::late_update() {
+    Input::late_update();
+
+    while (true) {
+        if (m_next_snapshot_index >= m_recording_reader->m_snapshots.size()) {
+            break;
+        }
+
+        const auto& snapshot = m_recording_reader->m_snapshots.at(m_next_snapshot_index);
+        if (snapshot.tetrion_index() != m_tetrion_index) {
+            ++m_next_snapshot_index;
+            continue;
+        }
+
+        // the snapshot corresponds to this tetrion
+        assert(snapshot.tetrion_index() == m_tetrion_index);
+
+        if (snapshot.simulation_step_index() != Application::simulation_step_index()) {
+            break;
+        }
+
+        // create a snapshot from the current state of the tetrion and compare it to the loaded snapshot
+        const auto current_snapshot = TetrionSnapshot{ *m_target_tetrion };
+#ifdef DEBUG_BUILD
+        static constexpr auto verbose_logging = true;
+#else
+        static constepxr auto verbose_logging = false;
+#endif
+        if constexpr (verbose_logging) {
+            spdlog::info("comparing tetrion snapshots");
+        }
+        const auto snapshots_are_equal = current_snapshot.compare_to(snapshot, verbose_logging);
+        if (snapshots_are_equal) {
+            if constexpr (verbose_logging) {
+                spdlog::info("snapshots are equal");
+            }
+        } else {
+            spdlog::error("snapshots are not equal");
+            throw std::exception{};
+        }
+        ++m_next_snapshot_index;
+    }
+}
+
+[[nodiscard]] bool ReplayInput::is_end_of_recording() const {
+    return m_next_record_index >= m_recording_reader->num_records();
+}

src/input.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "controls.hpp"
 #include "event_listener.hpp"
 #include "input_event.hpp"
 #include "random.hpp"
@@ -51,6 +52,7 @@ struct Input {
 
 public:
     virtual void update();
+    virtual void late_update() {};
     virtual ~Input() = default;
 };
 
@@ -73,11 +75,14 @@ struct KeyboardInput : public Input, public EventListener {
     [[nodiscard]] tl::optional<InputEvent> sdl_event_to_input_event(const SDL_Event& event) const;
 };
 
+struct RecordingReader;
+
 struct ReplayInput : public Input {
 private:
     u8 m_tetrion_index;
     RecordingReader* m_recording_reader;
     usize m_next_record_index{ 0 };
+    usize m_next_snapshot_index{ 0 };
 
 public:
     ReplayInput(
@@ -88,9 +93,8 @@ struct ReplayInput : public Input {
     );
 
     void update() override;
+    void late_update() override;
 
 private:
-    [[nodiscard]] bool is_end_of_recording() const {
-        return m_next_record_index >= m_recording_reader->num_records();
-    }
+    [[nodiscard]] bool is_end_of_recording() const;
 };

src/meson.build

@@ -47,6 +47,8 @@ src_files += files(
     'controls.hpp',
     'mino_stack.hpp',
     'mino_stack.cpp',
+    'tetrion_snapshot.hpp',
+    'tetrion_snapshot.cpp',
 )
 
 inc_dirs += include_directories('.')

src/mino.hpp

@@ -28,4 +28,12 @@ struct Mino final {
     Point& position() {
         return m_position;
     }
+
+    [[nodiscard]] bool operator==(const Mino& other) const {
+        return m_position == other.m_position and m_type == other.m_type;
+    }
+
+    [[nodiscard]] bool operator!=(const Mino& other) const {
+        return not (*this == other);
+    }
 };

src/mino_stack.cpp

@@ -40,3 +40,17 @@ void MinoStack::draw_minos(const Application& app, const Grid& grid) const {
         }
     }
 }
+
+std::ostream& operator<<(std::ostream& os, const MinoStack& mino_stack) {
+    os << "MinoStack(";
+    for (usize i = 0; i < mino_stack.num_minos(); ++i) {
+        const auto& mino = mino_stack.minos().at(i);
+        os << "{" << mino.position().x << ", " << mino.position().y << ", " << magic_enum::enum_name(mino.type())
+           << "}";
+        if (i < mino_stack.num_minos() - 1) {
+            os << ", ";
+        }
+    }
+    os << ")";
+    return os;
+}

src/mino_stack.hpp

@@ -1,6 +1,11 @@
 #pragma once
 
 #include "mino.hpp"
+#include "types.hpp"
+#include <algorithm>
+#include <iostream>
+#include <magic_enum.hpp>
+#include <ranges>
 #include <vector>
 
 struct Grid;
@@ -14,4 +19,38 @@ struct MinoStack final {
     [[nodiscard]] bool is_empty(Point coordinates) const;
     void set(Point coordinates, TetrominoType type);
     void draw_minos(const Application& app, const Grid& grid) const;
+
+    [[nodiscard]] usize num_minos() const {
+        return m_minos.size();
+    }
+
+    [[nodiscard]] const std::vector<Mino>& minos() const {
+        return m_minos;
+    }
+
+    [[nodiscard]] bool operator==(const MinoStack& other) const {
+        using std::ranges::all_of, std::ranges::find, std::ranges::end;
+
+        if (m_minos.size() != other.m_minos.size()) {
+            return false;
+        }
+
+        const auto all_of_this_in_other =
+                all_of(m_minos, [&](const auto& mino) { return find(other.m_minos, mino) != end(other.m_minos); });
+
+        if (not all_of_this_in_other) {
+            return false;
+        }
+
+        const auto all_of_other_in_this =
+                all_of(other.m_minos, [&](const auto& mino) { return find(m_minos, mino) != end(m_minos); });
+
+        return all_of_other_in_this;
+    }
+
+    [[nodiscard]] bool operator!=(const MinoStack& other) const {
+        return not(*this == other);
+    }
 };
+
+std::ostream& operator<<(std::ostream& os, const MinoStack& mino_stack);

src/recording.hpp

@@ -2,6 +2,8 @@
 
 #include "input_event.hpp"
 #include "random.hpp"
+#include "tetrion.hpp"
+#include "tetrion_snapshot.hpp"
 #include "types.hpp"
 #include "utils.hpp"
 #include <filesystem>
@@ -14,6 +16,12 @@
 struct RecordingError : public std::exception { };
 
 struct Recording {
+protected:
+    enum class MagicByte : u8 {
+        Record = 42,
+        Snapshot = 43,
+    };
+
 public:
     struct TetrionHeader final {
         Random::Seed seed;
@@ -34,6 +42,10 @@ struct Recording {
     explicit Recording(std::vector<TetrionHeader> tetrion_headers) : m_tetrion_headers{ std::move(tetrion_headers) } { }
 
 public:
+    Recording(const Recording&) = delete;
+    Recording(Recording&&) = delete;
+    Recording& operator=(const Recording&) = delete;
+    Recording& operator=(Recording&&) = delete;
     virtual ~Recording() = default;
 
     [[nodiscard]] const std::vector<TetrionHeader>& tetrion_headers() const {
@@ -43,6 +55,7 @@ struct Recording {
 
 struct RecordingReader : public Recording {
     std::vector<Record> m_records;
+    std::vector<TetrionSnapshot> m_snapshots;
 
 public:
     explicit RecordingReader(const std::filesystem::path& path) {
@@ -68,16 +81,33 @@ struct RecordingReader : public Recording {
         }
 
         while (true) {
-            const auto record = read_record_from_file(file);
-            if (not record.has_value()) {
-                if (record.error() == ReadError::EndOfFile) {
-                    // finished reading
-                    break;
+            const auto magic_byte = read_integral_from_file<std::underlying_type_t<MagicByte>>(file);
+            if (not magic_byte.has_value()) {
+                if (magic_byte.error() == ReadError::InvalidStream) {
+                    spdlog::error("unable to read magic byte");
+                    throw RecordingError{};
+                }
+                break;
+            }
+            if (*magic_byte == std::to_underlying(MagicByte::Record)) {
+                const auto record = read_record_from_file(file);
+                if (not record.has_value()) {
+                    if (record.error() == ReadError::EndOfFile) {
+                        // finished reading
+                        break;
+                    }
+                    spdlog::error("invalid record while reading recorded game");
+                    throw RecordingError{};
                 }
-                spdlog::error("invalid record while reading recorded game");
+                m_records.push_back(*record);
+            } else if (*magic_byte == std::to_underlying(MagicByte::Snapshot)) {
+                auto snapshot = TetrionSnapshot{ file }; // todo: handle exception
+                m_snapshots.push_back(std::move(snapshot));
+                spdlog::info("read snapshot");
+            } else {
+                spdlog::error("invalid magic byte: {}", static_cast<int>(*magic_byte));
                 throw RecordingError{};
             }
-            m_records.push_back(*record);
         }
     }
 
@@ -97,6 +127,10 @@ struct RecordingReader : public Recording {
         return m_records.cend();
     }
 
+    [[nodiscard]] const std::vector<TetrionSnapshot>& snapshots() const {
+        return m_snapshots;
+    }
+
 private:
     enum class ReadError {
         EndOfFile,
@@ -192,11 +226,20 @@ struct RecordingWriter : public Recording {
 
     void add_event(const u8 tetrion_index, const u64 simulation_step_index, const InputEvent event) {
         assert(tetrion_index < m_tetrion_headers.size());
+        write(std::to_underlying(MagicByte::Record));
         write(tetrion_index);
         write(simulation_step_index);
         write(static_cast<u8>(event));
     }
 
+    void add_snapshot(const u8 tetrion_index, const u64 simulation_step_index, const Tetrion& tetrion) {
+        write(std::to_underlying(MagicByte::Snapshot));
+        const auto snapshot = TetrionSnapshot{ tetrion_index,           tetrion.level(),       tetrion.score(),
+                                               tetrion.lines_cleared(), simulation_step_index, tetrion.mino_stack() };
+        const auto bytes = snapshot.to_bytes();
+        m_output_file.write(bytes.data(), static_cast<std::streamsize>(bytes.size()));
+    }
+
 private:
     static void write_integral_to_file(std::ofstream& file, const std::integral auto data) {
         if (not file) {

src/settings.hpp

@@ -2,7 +2,6 @@
 
 #include "controls.hpp"
 #include "magic_enum_wrapper.hpp"
-#include "recording.hpp"
 #include <array>
 #include <nlohmann/json.hpp>
 #include <string>