begin adding frame

Author: matcool

src/Replay.cpp

@@ -3,12 +3,19 @@
 #include "utils.hpp"
 
 void Replay::remove_actions_after(float x) {
-	auto check = [&](const Action& action) -> bool {
+	const auto check = [&](const Action& action) -> bool {
 		return action.x >= x;
 	};
 	actions.erase(std::remove_if(actions.begin(), actions.end(), check), actions.end());
 }
 
+void Replay::remove_actions_after(unsigned frame) {
+	const auto check = [&](const Action& action) -> bool {
+		return action.frame >= frame;
+	};
+	actions.erase(std::remove_if(actions.begin(), actions.end(), check), actions.end());
+}
+
 // these two functions are so stupid
 // why cant c++ do it for me :(
 
@@ -24,17 +31,33 @@ inline T bin_read(std::ifstream& stream) {
 	return value;
 }
 
-constexpr uint8_t format_ver = 1;
-constexpr const char format_magic[5] = "RPLY";
+/*
+ * Format changelog
+ *
+ * - version 1
+ * header | action[]
+ * header: "RPLY" | version as u8 | fps as f32
+ * action: x as f32 | state as u8
+ * 
+ * - version 2
+ * add `type as u8` between version and fps
+ * change action x to be either float or an unsigned int
+ */
+
+constexpr uint8_t format_ver = 2;
+constexpr const char format_magic[4] = {'R', 'P', 'L', 'Y'};
 
 void Replay::save(const std::string& path) {
 	std::ofstream file;
 	file.open(path, std::ios::binary | std::ios::out);
-	file << format_magic << format_ver;
+	file << format_magic << format_ver << type;
 	bin_write(file, fps);
 	for (const auto& action : actions) {
 		uint8_t state = action.hold | action.player2 << 1;
-		bin_write(file, action.x);
+		if (type == ReplayType::XPOS)
+			bin_write(file, action.x);
+		else if (type == ReplayType::FRAME)
+			bin_write(file, action.frame);
 		file << state;
 	}
 	file.close();
@@ -53,19 +76,25 @@ Replay Replay::load(const std::string& path)  {
 	file.read(magic, 4);
 	if (memcmp(magic, format_magic, 4) == 0) {
 		auto ver = bin_read<uint8_t>(file);
-		if (ver == 1) {
+		if (ver == 1 || ver == 2) {
+			if (ver == 2) replay.type = ReplayType(bin_read<uint8_t>(file));
 			replay.fps = bin_read<float>(file);
 			size_t left = file_size - static_cast<size_t>(file.tellg());
+			float x;
+			unsigned frame;
 			for (size_t _ = 0; _ < left / 5; ++_) {
-				float x = bin_read<float>(file);
+				if (replay.type == ReplayType::XPOS)
+					x = bin_read<float>(file);
+				else if (replay.type == ReplayType::FRAME)
+					frame = bin_read<unsigned>(file);
 				auto state = bin_read<uint8_t>(file);
 				bool hold = state & 1;
 				bool player2 = state & 2;
-				replay.add_action({ x, hold, player2 });
+				replay.add_action({ replay.type == ReplayType::XPOS ? x : frame, hold, player2 });
 			}
 		}
 	} else {
-		replay.fps = *reinterpret_cast<float*>(&magic);
+		replay.fps = *cast<float*>(&magic);
 		size_t left = file_size - static_cast<size_t>(file.tellg());
 		for (size_t _ = 0; _ < left / 6; ++_) {
 			float x = bin_read<float>(file);

src/dllmain.cpp

@@ -3,10 +3,10 @@
 
 #include "hooks.hpp"
 
-#define _SHOW_CONSOLE_UWU 1
+#define _DEBUG
 
 DWORD WINAPI thread_entry(void* module) {
-#if _SHOW_CONSOLE_UWU
+#ifdef _DEBUG
     AllocConsole();
     static std::ofstream conout("CONOUT$", std::ios::out);
     static std::ifstream conin("CONIN$", std::ios::in);
@@ -20,9 +20,8 @@ DWORD WINAPI thread_entry(void* module) {
 
     MH_EnableHook(MH_ALL_HOOKS);
 
-#if _SHOW_CONSOLE_UWU
-    std::string dababy;
-    std::getline(std::cin, dababy);
+#ifdef _DEBUG
+    std::getline(std::cin, std::string());
     MH_Uninitialize();
     conout.close();
     conin.close();
@@ -35,7 +34,7 @@ DWORD WINAPI thread_entry(void* module) {
 
 BOOL APIENTRY DllMain(HMODULE module, DWORD reason, LPVOID reserved) {
     if (reason == DLL_PROCESS_ATTACH) {
-        auto handle = CreateThread(0, 0x100, thread_entry, module, 0, 0);
+        auto handle = CreateThread(0, 0, thread_entry, module, 0, 0);
         if (handle) CloseHandle(handle);
     }
     return TRUE;

src/hooks.cpp

@@ -126,7 +126,7 @@ void __fastcall Hooks::PlayLayer::pauseGame_H(gd::PlayLayer* self, int, bool idk
 
 int __fastcall Hooks::PlayLayer::createCheckpoint_H(gd::PlayLayer* self, int) {
     auto& rs = ReplaySystem::get_instance();
-    if (rs.is_recording()) rs.get_practice_fixes().add_checkpoint();
+    if (rs.is_recording()) rs.get_practice_fixes().add_checkpoint(rs.get_frame());
     return createCheckpoint(self);
 }
 

src/practice_fixes.hpp

@@ -19,6 +19,7 @@ struct Checkpoint {
     CheckpointData player1;
     CheckpointData player2;
     size_t activated_objects_size;
+    unsigned frame;
 };
 
 class PracticeFixes {
@@ -28,12 +29,13 @@ class PracticeFixes {
 public:
     PracticeFixes() {}
 
-	void add_checkpoint() {
+	void add_checkpoint(unsigned frame = 0) {
         auto play_layer = gd::GameManager::sharedState()->getPlayLayer();
         checkpoints.push({
             CheckpointData::from_player(play_layer->m_player1),
             CheckpointData::from_player(play_layer->m_player2),
-            activated_objects.size()
+            activated_objects.size(),
+            frame
         });
     }
 

src/replay.hpp

@@ -3,23 +3,36 @@
 #include <string>
 #include <iostream>
 
+enum ReplayType : std::uint8_t {
+    XPOS,
+    FRAME
+};
+
 struct Action {
-	float x;
+    union {
+	    float x;
+        unsigned frame;
+    };
 	bool hold;
 	bool player2;
 };
 
 class Replay {
+protected:
     std::vector<Action> actions;
     float fps;
+    ReplayType type;
 public:
-    Replay(float fps) : fps(fps) {}
+    Replay(float fps, ReplayType type = ReplayType::FRAME) : fps(fps), type(type) {}
 
     float get_fps() { return fps; }
 
     void add_action(const Action& action) { actions.push_back(action); }
     auto& get_actions() { return actions; }
     void remove_actions_after(float x);
+    void remove_actions_after(unsigned frame);
+
+    auto get_type() { return type; }
 
     void save(const std::string& path);
     static Replay load(const std::string& path);

src/replay_system.cpp

@@ -7,7 +7,14 @@ void ReplaySystem::record_action(bool hold, bool player1, bool flip) {
         auto play_layer = gm->getPlayLayer();
         auto is_two_player = play_layer->m_levelSettings->m_twoPlayerMode;
         player1 ^= flip && gm->getGameVariable("0010");
-        get_replay().add_action({ play_layer->m_player1->position.x, hold, is_two_player && !player1 });
+        Action action;
+        action.hold = hold;
+        action.player2 = is_two_player && !player1;
+        if (replay.get_type() == ReplayType::XPOS)
+            action.x = play_layer->m_player1->position.x;
+        else if (replay.get_type() == ReplayType::FRAME)
+            action.frame = get_frame();
+        replay.add_action(action);
     }
 }
 
@@ -18,18 +25,27 @@ void ReplaySystem::play_action(const Action& action) {
     func(gm->getPlayLayer(), 0, !action.player2 ^ flip);
 }
 
+unsigned ReplaySystem::get_frame() {
+    auto play_layer = gd::GameManager::sharedState()->getPlayLayer();
+    if (play_layer != nullptr) {
+       return static_cast<unsigned>(play_layer->time * replay.get_fps()) + frame_offset;
+    }
+    return 0;
+}
+
 void ReplaySystem::on_reset() {
     auto play_layer = gd::GameManager::sharedState()->getPlayLayer();
     if (is_playing()) {
         Hooks::PlayLayer::releaseButton(play_layer, 0, false);
         Hooks::PlayLayer::releaseButton(play_layer, 0, true);
         action_index = 0;
     } else if (is_recording()) {
-        replay.remove_actions_after(play_layer->m_player1->position.x);
         auto& activated_objects = practice_fixes.activated_objects;
         if (practice_fixes.checkpoints.empty()) {
             activated_objects.clear();
+            frame_offset = 0;
         } else {
+            frame_offset = practice_fixes.checkpoints.top().frame;
             activated_objects.erase(
                 activated_objects.begin() + practice_fixes.checkpoints.top().activated_objects_size,
                 activated_objects.end()
@@ -38,6 +54,10 @@ void ReplaySystem::on_reset() {
                 object->m_hasBeenActivated = true;
             }
         }
+        if (replay.get_type() == ReplayType::XPOS)
+            replay.remove_actions_after(play_layer->m_player1->position.x);
+        else
+            replay.remove_actions_after(get_frame());
         const auto& actions = replay.get_actions();
         bool holding = play_layer->m_player1->isActuallyHolding;
         if ((holding && actions.empty()) || (!actions.empty() && actions.back().hold != holding)) {
@@ -62,9 +82,16 @@ void ReplaySystem::handle_playing() {
         auto x = gd::GameManager::sharedState()->getPlayLayer()->m_player1->position.x;
         auto& actions = replay.get_actions();
         Action action;
-        while (action_index < actions.size() && x >= (action = actions[action_index]).x) {
-            play_action(action);
-            ++action_index;
+        if (replay.get_type() == ReplayType::XPOS) {
+            while (action_index < actions.size() && x >= (action = actions[action_index]).x) {
+                play_action(action);
+                ++action_index;
+            }
+        } else {
+            while (action_index < actions.size() && get_frame() >= (action = actions[action_index]).frame) {
+                play_action(action);
+                ++action_index;
+            }
         }
         if (action_index >= actions.size())
             toggle_playing();

src/replay_system.hpp

@@ -14,16 +14,19 @@ class ReplaySystem {
 
     Replay replay;
     RSState state = NOTHING;
+    ReplayType replay_type;
 
     size_t action_index = 0;
 
     PracticeFixes practice_fixes;
 
     bool frame_advance = false;
 
-    ReplaySystem() : default_fps(120.f), replay(default_fps) {}
+    ReplaySystem() : default_fps(120.f), replay(default_fps), replay_type(replay.get_type()) {}
 
     void _update_status_label();
+
+    unsigned frame_offset = 0;
 public:
     static auto& get_instance() {
         static ReplaySystem instance;
@@ -39,18 +42,21 @@ class ReplaySystem {
 
     void toggle_playing() {
         state = is_playing() ? NOTHING : PLAYING;
+        frame_offset = 0;
         _update_status_label();
     }
     void toggle_recording() {
         state = is_recording() ? NOTHING : RECORDING;
         if (!is_recording()) frame_advance = false;
         else replay = Replay(default_fps);
+        frame_offset = 0;
         _update_status_label();
     }
 
     void reset_state() {
         state = NOTHING;
         frame_advance = false;
+        frame_offset = 0;
         _update_status_label();
     } 
 
@@ -65,4 +71,6 @@ class ReplaySystem {
 
     inline bool get_frame_advance() { return frame_advance; }
     inline void set_frame_advance(bool b) { frame_advance = b; }
+
+    unsigned get_frame();
 };