moved sigscans & wired up hotel + wonkavator

6 files changed, 137 insertions, 97 deletions

@@ -34,23 +34,20 @@ ChallengeRandomizer::ChallengeRandomizer(const std::shared_ptr<Memory>& memory,
         _memory->WriteData<int>({GLOBALS + 0x30, 0}, {seed});
 
         int do_success_side_effects = -1;
+        int reveal_exit_hall = -1;
+        int begin_endgame_1 = -1;
 
-        for (int i=0; i<0x200000; i+=0x1000) {
-                std::vector<byte> data = _memory->ReadData<byte>({i}, 0x1100);
-                std::cout << data.size() << std::endl;
-
-                if (!alreadyInjected) HandleSigScans(i, data);
-
+        _memory->SigScan([&](int offset, const std::vector<byte>& data) {
                 // This injection ensures that the seed is set every time the challenge is started.
                 // We always do this sigscan since it affects the seed.
                 if (do_success_side_effects == -1) {
                         int index = find(data, {0xFF, 0xC8, 0x99, 0x2B, 0xC2, 0xD1, 0xF8, 0x8B, 0xD0});
                         if (index != -1) {
-                                do_success_side_effects = i + index + 0x3E;
+                                do_success_side_effects = offset + index + 0x3E;
                                 if (GLOBALS == 0x62A080) do_success_side_effects += 4; // There's an extra 4 opcodes in the new version
                                 _memory->WriteData<byte>({do_success_side_effects}, {
-                                        0x8B, 0x0D, 0x00, 0x00, 0x00, 0x00,                     // mov ecx, [] ;This is going to be the address of the custom RNG
-                                        0x67, 0xC7, 0x01, 0x00, 0x00, 0x00, 0x00,       // mov dword ptr ds:[ecx], 0x0 ;This is going to be the seed value
+                                        0x8B, 0x0D, 0x00, 0x00, 0x00, 0x00,                     // mov ecx, [0x00000000] ;This is going to be the address of the custom RNG
+                                        0x67, 0xC7, 0x01, 0x00, 0x00, 0x00, 0x00,       // mov dword ptr ds:[ecx], 0x00000000 ;This is going to be the seed value
                                         0x48, 0x83, 0xF8, 0x02,                                         // cmp rax, 0x2 ;This is the short solve on the record player (which turns it off)
                                         0x90, 0x90, 0x90                                                        // nop nop nop
                                 });
@@ -59,10 +56,33 @@ ChallengeRandomizer::ChallengeRandomizer(const std::shared_ptr<Memory>& memory,
                                 _memory->WriteData<int>({do_success_side_effects + 0x9}, {seed});
                         }
                 }
-        }
+
+                // BLEH.
+                if (reveal_exit_hall == -1) {
+                        int index = find(data, {0x45, 0x8B, 0xF7, 0x48, 0x8B, 0x4D});
+                        if (index != -1) {
+                                reveal_exit_hall = offset + index;
+                                _memory->WriteData<byte>({reveal_exit_hall + 0x15}, {0xEB});
+                        }
+                }
+                if (begin_endgame_1 == -1) {
+                        int index = find(data, {0x83, 0x7C, 0x01, 0xD0, 0x04});
+                        if (index != -1) {
+                                begin_endgame_1 = offset + index;
+                                if (GLOBALS == 0x5B28C0) { // Version differences :/
+                                        begin_endgame_1 += 0x75;
+                                } else if (GLOBALS == 0x62A080) {
+                                        begin_endgame_1 += 0x86;
+                                }
+                                _memory->WriteData<byte>({begin_endgame_1}, {0xEB});
+                        }
+                }
+        });
+
+        if (!alreadyInjected) HandleSigScans();
 }
 
-void ChallengeRandomizer::HandleSigScans(int i, const std::vector<byte>& data) {
+void ChallengeRandomizer::HandleSigScans() {
         static int shuffle_integers = -1;
         static int shuffle_int = -1;
         static int cut_random_edges = -1;
@@ -76,99 +96,101 @@ void ChallengeRandomizer::HandleSigScans(int i, const std::vector<byte>& data) {
         static int do_lotus_tenths = -1;
         static int do_lotus_eighths = -1;
 
-        if (shuffle_integers == -1) {
-                int index = find(data, {0x48, 0x89, 0x5C, 0x24, 0x10, 0x56, 0x48, 0x83, 0xEC, 0x20, 0x48, 0x63, 0xDA, 0x48, 0x8B, 0xF1, 0x83, 0xFB, 0x01});
-                if (index != -1) {
-                        shuffle_integers = i + index;
-                        AdjustRng(shuffle_integers + 0x23);
+        _memory->SigScan([&](int offset, const std::vector<byte>& data) {
+                if (shuffle_integers == -1) {
+                        int index = find(data, {0x48, 0x89, 0x5C, 0x24, 0x10, 0x56, 0x48, 0x83, 0xEC, 0x20, 0x48, 0x63, 0xDA, 0x48, 0x8B, 0xF1, 0x83, 0xFB, 0x01});
+                        if (index != -1) {
+                                shuffle_integers = offset + index;
+                                AdjustRng(shuffle_integers + 0x23);
+                        }
                 }
-        }
-        // shuffle<int>
-        if (shuffle_int == -1) {
-                int index = find(data, {0x33, 0xF6, 0x48, 0x8B, 0xD9, 0x39, 0x31, 0x7E, 0x51});
-                if (index != -1) {
-                        shuffle_int = i + index - 0x16;
-                        AdjustRng(shuffle_int + 0x12);
+                // shuffle<int>
+                if (shuffle_int == -1) {
+                        int index = find(data, {0x33, 0xF6, 0x48, 0x8B, 0xD9, 0x39, 0x31, 0x7E, 0x51});
+                        if (index != -1) {
+                                shuffle_int = offset + index - 0x16;
+                                AdjustRng(shuffle_int + 0x12);
+                        }
                 }
-        }
-        if (cut_random_edges == -1) {
-                int index = find(data, {0x89, 0x44, 0x24, 0x3C, 0x33, 0xC0, 0x85, 0xC0, 0x75, 0xFA});
-                if (index != -1) {
-                        cut_random_edges = i + index - 0x22;
-                        AdjustRng(cut_random_edges + 0x5D);
+                if (cut_random_edges == -1) {
+                        int index = find(data, {0x89, 0x44, 0x24, 0x3C, 0x33, 0xC0, 0x85, 0xC0, 0x75, 0xFA});
+                        if (index != -1) {
+                                cut_random_edges = offset + index - 0x22;
+                                AdjustRng(cut_random_edges + 0x5D);
+                        }
                 }
-        }
-        if (get_empty_decoration_slot == -1) {
-                int index = find(data, {0x42, 0x83, 0x3C, 0x80, 0x00, 0x75, 0xDF});
-                if (index != -1) {
-                        get_empty_decoration_slot = i + index - 0x2D;
-                        AdjustRng(get_empty_decoration_slot + 0x16);
+                if (get_empty_decoration_slot == -1) {
+                        int index = find(data, {0x42, 0x83, 0x3C, 0x80, 0x00, 0x75, 0xDF});
+                        if (index != -1) {
+                                get_empty_decoration_slot = offset + index - 0x2D;
+                                AdjustRng(get_empty_decoration_slot + 0x16);
+                        }
                 }
-        }
-        if (get_empty_dot_spot == -1) {
-                int index = find(data, {0xF7, 0xF3, 0x85, 0xD2, 0x74, 0xEC});
-                if (index != -1) {
-                        get_empty_dot_spot = i + index - 0x2E;
-                        AdjustRng(get_empty_dot_spot + 0x23);
+                if (get_empty_dot_spot == -1) {
+                        int index = find(data, {0xF7, 0xF3, 0x85, 0xD2, 0x74, 0xEC});
+                        if (index != -1) {
+                                get_empty_dot_spot = offset + index - 0x2E;
+                                AdjustRng(get_empty_dot_spot + 0x23);
+                        }
                 }
-        }
-        if (add_exactly_this_many_bisection_dots == -1) {
-                int index = find(data, {0x48, 0x8B, 0xB4, 0x24, 0xB8, 0x00, 0x00, 0x00, 0x48, 0x8B, 0xBC, 0x24, 0xB0, 0x00, 0x00, 0x00});
-                if (index != -1) {
-                        add_exactly_this_many_bisection_dots = i + index - 0x20;
-                        AdjustRng(add_exactly_this_many_bisection_dots + 0x1C);
+                if (add_exactly_this_many_bisection_dots == -1) {
+                        int index = find(data, {0x48, 0x8B, 0xB4, 0x24, 0xB8, 0x00, 0x00, 0x00, 0x48, 0x8B, 0xBC, 0x24, 0xB0, 0x00, 0x00, 0x00});
+                        if (index != -1) {
+                                add_exactly_this_many_bisection_dots = offset + index - 0x20;
+                                AdjustRng(add_exactly_this_many_bisection_dots + 0x1C);
+                        }
                 }
-        }
-        if (make_a_shaper == -1) {
-                int index = find(data, {0xF7, 0xE3, 0xD1, 0xEA, 0x8D, 0x0C, 0x52});
-                if (index != -1) {
-                        make_a_shaper = i + index - 0x19;
-                        AdjustRng(make_a_shaper + 0x9);
-                        AdjustRng(make_a_shaper + 0x35);
-                        AdjustRng(make_a_shaper + 0x62);
+                if (make_a_shaper == -1) {
+                        int index = find(data, {0xF7, 0xE3, 0xD1, 0xEA, 0x8D, 0x0C, 0x52});
+                        if (index != -1) {
+                                make_a_shaper = offset + index - 0x19;
+                                AdjustRng(make_a_shaper + 0x9);
+                                AdjustRng(make_a_shaper + 0x35);
+                                AdjustRng(make_a_shaper + 0x62);
+                        }
                 }
-        }
-        if (/*Entity_Machine_Panel::*/init_pattern_data_lotus == -1) {
-                int index = find(data, {0x40, 0x55, 0x56, 0x48, 0x8D, 0x6C, 0x24, 0xB1});
-                if (index != -1) {
-                        init_pattern_data_lotus = i + index;
-                        AdjustRng(init_pattern_data_lotus + 0x433);
-                        AdjustRng(init_pattern_data_lotus + 0x45B);
-                        AdjustRng(init_pattern_data_lotus + 0x5A7);
-                        AdjustRng(init_pattern_data_lotus + 0x5D6);
-                        AdjustRng(init_pattern_data_lotus + 0x6F6);
-                        AdjustRng(init_pattern_data_lotus + 0xD17);
-                        AdjustRng(init_pattern_data_lotus + 0xFDA);
+                if (/*Entity_Machine_Panel::*/init_pattern_data_lotus == -1) {
+                        int index = find(data, {0x40, 0x55, 0x56, 0x48, 0x8D, 0x6C, 0x24, 0xB1});
+                        if (index != -1) {
+                                init_pattern_data_lotus = offset + index;
+                                AdjustRng(init_pattern_data_lotus + 0x433);
+                                AdjustRng(init_pattern_data_lotus + 0x45B);
+                                AdjustRng(init_pattern_data_lotus + 0x5A7);
+                                AdjustRng(init_pattern_data_lotus + 0x5D6);
+                                AdjustRng(init_pattern_data_lotus + 0x6F6);
+                                AdjustRng(init_pattern_data_lotus + 0xD17);
+                                AdjustRng(init_pattern_data_lotus + 0xFDA);
+                        }
                 }
-        }
-        if (/*Entity_Record_Player::*/reroll_lotus_eater_stuff == -1) {
-                int index = find(data, {0xB8, 0xAB, 0xAA, 0xAA, 0xAA, 0x41, 0xC1, 0xE8});
-                if (index != -1) {
-                        reroll_lotus_eater_stuff = i + index - 0x37;
-                        AdjustRng(reroll_lotus_eater_stuff + 0x24);
-                        AdjustRng(reroll_lotus_eater_stuff + 0x6B);
+                if (/*Entity_Record_Player::*/reroll_lotus_eater_stuff == -1) {
+                        int index = find(data, {0xB8, 0xAB, 0xAA, 0xAA, 0xAA, 0x41, 0xC1, 0xE8});
+                        if (index != -1) {
+                                reroll_lotus_eater_stuff = offset + index - 0x37;
+                                AdjustRng(reroll_lotus_eater_stuff + 0x24);
+                                AdjustRng(reroll_lotus_eater_stuff + 0x6B);
+                        }
                 }
-        }
-                        // These disable the random locations on timer panels, which would otherwise increment the RNG.
-        if (do_lotus_minutes == -1) {
-                int index = find(data, {0x0F, 0xBE, 0x6C, 0x08, 0xFF, 0x45});
-                if (index != -1) {
-                        do_lotus_minutes = i + index - 0x2B;
-                        _memory->WriteData<byte>({do_lotus_minutes + 0x43B}, {0x31, 0xC0, 0x90, 0x90, 0x90}); // xor eax, eax ;RNG returns 0
+                // These disable the random locations on timer panels, which would otherwise increment the RNG.
+                if (do_lotus_minutes == -1) {
+                        int index = find(data, {0x0F, 0xBE, 0x6C, 0x08, 0xFF, 0x45});
+                        if (index != -1) {
+                                do_lotus_minutes = offset + index - 0x2B;
+                                _memory->WriteData<byte>({do_lotus_minutes + 0x43B}, {0x31, 0xC0, 0x90, 0x90, 0x90}); // xor eax, eax ;RNG returns 0
+                        }
                 }
-        }
-        if (do_lotus_tenths == -1) {
-                int index = find(data, {0x00, 0x04, 0x00, 0x00, 0x41, 0x8D, 0x50, 0x09});
-                if (index != -1) {
-                        do_lotus_tenths = i + index - 0x61;
-                        _memory->WriteData<byte>({do_lotus_tenths + 0x103}, {0x31, 0xC0, 0x90, 0x90, 0x90}); // xor eax, eax ;RNG returns 0
+                if (do_lotus_tenths == -1) {
+                        int index = find(data, {0x00, 0x04, 0x00, 0x00, 0x41, 0x8D, 0x50, 0x09});
+                        if (index != -1) {
+                                do_lotus_tenths = offset + index - 0x61;
+                                _memory->WriteData<byte>({do_lotus_tenths + 0x103}, {0x31, 0xC0, 0x90, 0x90, 0x90}); // xor eax, eax ;RNG returns 0
+                        }
                 }
-        }
-        if (do_lotus_eighths == -1) {
-                int index = find(data, {0x75, 0xF5, 0x0F, 0xBE, 0x44, 0x08, 0xFF});
-                if (index != -1) {
-                        do_lotus_eighths = i + index - 0x39;
-                        _memory->WriteData<byte>({do_lotus_eighths + 0x1E7}, {0x31, 0xC0, 0x90, 0x90, 0x90}); // xor eax, eax ;RNG returns 0
+                if (do_lotus_eighths == -1) {
+                        int index = find(data, {0x75, 0xF5, 0x0F, 0xBE, 0x44, 0x08, 0xFF});
+                        if (index != -1) {
+                                do_lotus_eighths = offset + index - 0x39;
+                                _memory->WriteData<byte>({do_lotus_eighths + 0x1E7}, {0x31, 0xC0, 0x90, 0x90, 0x90}); // xor eax, eax ;RNG returns 0
+                        }
                 }
-        }
+        });
 }
\ No newline at end of file
@@ -7,7 +7,7 @@ public:
         ChallengeRandomizer(const std::shared_ptr<Memory>& memory, int seed);
 
 private:
-        void HandleSigScans(int i, const std::vector<byte>& data);
+        void HandleSigScans();
 
         void AdjustRng(int offset);
         std::shared_ptr<Memory> _memory;
@@ -39,6 +39,11 @@ Memory::Memory(const std::string& processName) {
         if (_baseAddress == 0) {
                 throw std::exception("Couldn't find the base process address!");
         }
+
+        // Unprotect regions of memory
+
+        DWORD oldProtect;
+        VirtualProtectEx(_handle, (LPVOID)_baseAddress, sizeof(DWORD), PAGE_READWRITE, &oldProtect); 
 }
 
 Memory::~Memory() {
@@ -58,6 +63,14 @@ int Memory::GetCurrentFrame()
         return ReadData<int>({SCRIPT_FRAMES}, 1)[0];
 }
 
+void Memory::SigScan(std::function<void(int offset, const std::vector<byte>& data)> scanFunc)
+{
+        for (int i=0; i<0x200000; i+=0x1000) {
+                std::vector<byte> data = ReadData<byte>({i}, 0x1100);
+                scanFunc(i, data);
+        }
+}
+
 void Memory::ThrowError() {
         std::string message(256, '\0');
         int length = FormatMessageA(4096, nullptr, GetLastError(), 1024, &message[0], static_cast<DWORD>(message.size()), nullptr);
@@ -1,6 +1,7 @@
 #pragma once
-#include <vector>
+#include <functional>
 #include <map>
+#include <vector>
 #include <windows.h>
 
 // #define GLOBALS 0x5B28C0
@@ -41,6 +42,8 @@ public:
                 WriteData<T>({GLOBALS, 0x18, panel*8, offset}, data);
         }
 
+        void SigScan(std::function<void(int offset, const std::vector<byte>& data)> scanFunc);
+
         void ClearOffsets() {_computedAddresses = std::map<uintptr_t, uintptr_t>();}
 
 private:
@@ -78,4 +81,5 @@ private:
 
         friend class Temp;
         friend class ChallengeRandomizer;
+        friend class Randomizer;
 };
\ No newline at end of file
@@ -1,6 +1,5 @@
 /*
  * Random *rotation* of desert laser redirect?
- * Disable wonkavator and hotel, so that 100% runs are possible
  * Try to wire up both keep halves
  * Wire up both halves of symmetry laser
  * Turn off floating panel in desert
@@ -119,6 +119,7 @@ private:
 #define AUDIO_LOG_NAME 0xC8
 #define OPEN_RATE 0xE8
 #define METADATA 0xF2 // sizeof(short)
+#define HOTEL_EP_NAME 0x4BC640
 #elif GLOBALS == 0x62A080
 #define PATH_COLOR 0xC0
 #define REFLECTION_PATH_COLOR 0xD0
@@ -184,4 +185,5 @@ private:
 #define AUDIO_LOG_NAME 0x0
 #define OPEN_RATE 0xE0
 #define METADATA 0x13A // sizeof(short)
+#define HOTEL_EP_NAME 0x51E340
 #endif
\ No newline at end of file