fix player 2 orbs

Author: matcool

src/Replay.cpp

@@ -53,7 +53,7 @@ void Replay::save(const std::string& path) {
 	file << format_magic << format_ver << type;
 	bin_write(file, fps);
 	for (const auto& action : actions) {
-		uint8_t state = action.hold | action.player2 << 1;
+		uint8_t state = static_cast<uint8_t>(action.hold) | static_cast<uint8_t>(action.player2) << 1;
 		if (type == ReplayType::XPOS)
 			bin_write(file, action.x);
 		else if (type == ReplayType::FRAME)
@@ -90,7 +90,12 @@ Replay Replay::load(const std::string& path)  {
 				auto state = bin_read<uint8_t>(file);
 				bool hold = state & 1;
 				bool player2 = state & 2;
-				replay.add_action({ replay.type == ReplayType::XPOS ? x : frame, hold, player2 });
+				Action action = { 0, hold, player2 };
+				if (replay.type == ReplayType::XPOS)
+					action.x = x;
+				else if (replay.type == ReplayType::FRAME)
+					action.frame = frame;
+				replay.add_action(action);
 			}
 		}
 	} else {

src/hooks.cpp

@@ -36,6 +36,7 @@ void Hooks::init() {
 
     ADD_GD_HOOK(0x1f4ff0, PlayerObject_ringJump);
     ADD_GD_HOOK(0xef0e0, GameObject_activateObject);
+    ADD_GD_HOOK(0x10ed50, GJBaseGameLayer_bumpPlayer);
 }
 
 void __fastcall Hooks::CCScheduler_update_H(CCScheduler* self, int, float dt) {
@@ -180,20 +181,34 @@ bool __fastcall Hooks::PauseLayer_init_H(gd::PauseLayer* self, int) {
     return false;
 }
 
-void __fastcall Hooks::PlayerObject_ringJump_H(gd::PlayerObject* self, int, gd::GameObject* ring) {
-    PlayerObject_ringJump(self, ring);
-    auto& rs = ReplaySystem::get_instance();
+void _handle_activated_object(bool a, bool b, gd::GameObject* object) {
     auto play_layer = gd::GameManager::sharedState()->getPlayLayer();
-    if (play_layer && play_layer->is_practice_mode && rs.is_recording() && ring->m_hasBeenActivated) {
-        rs.get_practice_fixes().add_activated_object(ring);
+    auto& rs = ReplaySystem::get_instance();
+    if (play_layer && play_layer->is_practice_mode && rs.is_recording()) {
+        if (object->m_hasBeenActivated && !a)
+            rs.get_practice_fixes().add_activated_object(object);
+        if (object->m_hasBeenActivatedP2 && !b)
+            rs.get_practice_fixes().add_activated_object_p2(object);
     }
 }
 
+void __fastcall Hooks::PlayerObject_ringJump_H(gd::PlayerObject* self, int, gd::GameObject* ring) {
+    bool a = ring->m_hasBeenActivated;
+    bool b = ring->m_hasBeenActivatedP2;
+    PlayerObject_ringJump(self, ring);
+    _handle_activated_object(a, b, ring);
+}
+
 void __fastcall Hooks::GameObject_activateObject_H(gd::GameObject* self, int, gd::PlayerObject* player) {
+    bool a = self->m_hasBeenActivated;
+    bool b = self->m_hasBeenActivatedP2;
     GameObject_activateObject(self, player);
-    auto& rs = ReplaySystem::get_instance();
-    auto play_layer = gd::GameManager::sharedState()->getPlayLayer();
-    if (play_layer && play_layer->is_practice_mode && rs.is_recording() && self->m_hasBeenActivated) {
-        rs.get_practice_fixes().add_activated_object(self);
-    }
+    _handle_activated_object(a, b, self);
+}
+
+void __fastcall Hooks::GJBaseGameLayer_bumpPlayer_H(gd::GJBaseGameLayer* self, int, gd::PlayerObject* player, gd::GameObject* object) {
+    bool a = object->m_hasBeenActivated;
+    bool b = object->m_hasBeenActivatedP2;
+    GJBaseGameLayer_bumpPlayer(self, player, object);
+    _handle_activated_object(a, b, object);
 }

src/hooks.hpp

@@ -36,4 +36,5 @@ namespace Hooks {
 
     _THISCALL_HOOK(PlayerObject_ringJump, void, gd::PlayerObject, gd::GameObject* ring)
     _THISCALL_HOOK(GameObject_activateObject, void, gd::GameObject, gd::PlayerObject* player)
+    _THISCALL_HOOK(GJBaseGameLayer_bumpPlayer, void, gd::GJBaseGameLayer, gd::PlayerObject* player, gd::GameObject* object)
 }

src/practice_fixes.hpp

@@ -19,22 +19,23 @@ struct Checkpoint {
     CheckpointData player1;
     CheckpointData player2;
     size_t activated_objects_size;
+    size_t activated_objects_p2_size;
     unsigned frame;
 };
 
 class PracticeFixes {
     std::stack<Checkpoint> checkpoints;
     std::vector<gd::GameObject*> activated_objects;
+    std::vector<gd::GameObject*> activated_objects_p2;
     friend class ReplaySystem;
 public:
-    PracticeFixes() {}
-
 	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_p2.size(),
             frame
         });
     }
@@ -67,4 +68,7 @@ class PracticeFixes {
     void add_activated_object(gd::GameObject* object) {
         activated_objects.push_back(object);
     }
+    void add_activated_object_p2(gd::GameObject* object) {
+        activated_objects_p2.push_back(object);
+    }
 };

src/replay_system.cpp

@@ -40,19 +40,24 @@ void ReplaySystem::on_reset() {
         Hooks::PlayLayer::releaseButton(play_layer, 0, true);
         action_index = 0;
     } else if (is_recording()) {
-        auto& activated_objects = practice_fixes.activated_objects;
         if (practice_fixes.checkpoints.empty()) {
-            activated_objects.clear();
+            practice_fixes.activated_objects.clear();
+            practice_fixes.activated_objects_p2.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()
-            );
-            for (const auto object : activated_objects) {
+            constexpr auto delete_from = [&](auto& vec, size_t index) {
+                vec.erase(vec.begin() + index, vec.end());
+            };
+            const auto& checkpoint = practice_fixes.checkpoints.top();
+            delete_from(practice_fixes.activated_objects, checkpoint.activated_objects_size);
+            delete_from(practice_fixes.activated_objects_p2, checkpoint.activated_objects_p2_size);
+            for (const auto& object : practice_fixes.activated_objects) {
                 object->m_hasBeenActivated = true;
             }
+            for (const auto& object : practice_fixes.activated_objects_p2) {
+                object->m_hasBeenActivatedP2 = true;
+            }
         }
         if (replay.get_type() == ReplayType::XPOS)
             replay.remove_actions_after(play_layer->m_player1->position.x);