Works, on old version

8 files changed, 188 insertions, 19 deletions

@@ -2,6 +2,7 @@
 #include <Richedit.h>
 
 #include <string>
+#include <sstream>
 
 #include "Version.h"
 #include "Random.h"
@@ -18,7 +19,7 @@
 #define IDC_DUMP 0x408
 #define IDT_RANDOMIZED 0x409
 
-HWND hwndSeed, hwndRandomize;
+HWND hwndSeed, hwndRandomize, hwndDebug;
 // int panel = 0x18AF;
 int panel = 0x33D4;
 std::shared_ptr<Panel> _panel;
@@ -68,12 +69,21 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
                                 */
                                 if (randomizer->GameIsRandomized()) break;
                                 Random::SetSeed(seed);
+
+
+                                std::wstringstream debug;
+
                                 std::wstring seedString = std::to_wstring(seed);
                                 SetWindowText(hwndRandomize, L"Randomizing...");
                                 SetWindowText(hwndSeed, seedString.c_str());
                                 RedrawWindow(hwnd, NULL, NULL, RDW_UPDATENOW);
 
                                 randomizer->Randomize();
+                                debug << Random::RandInt(0, 1000) << " ";
+                                debug << Random::RandInt(0, 1000) << "\n";
+                                debug << Random::RandInt(0, 1000) << " ";
+                                debug << Random::RandInt(0, 1000);
+                                SetWindowText(hwndDebug, debug.str().c_str());
                                 if (IsDlgButtonChecked(hwnd, IDC_TOGGLESPEED)) {
                                         randomizer->AdjustSpeed();
                                 }
@@ -163,6 +173,10 @@ int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmd
                 WS_TABSTOP | WS_VISIBLE | WS_CHILD | SS_LEFT,
                 27, 50, 205, 16, hwnd, NULL, hInstance, NULL);
 
+        hwndDebug = CreateWindow(L"STATIC", L"",
+                WS_TABSTOP | WS_VISIBLE | WS_CHILD | SS_LEFT,
+                200, 200, 100, 100, hwnd, NULL, hInstance, NULL);
+
         /*
         CreateWindow(L"BUTTON", L"",
                 WS_VISIBLE | WS_CHILD | BS_CHECKBOX,
@@ -162,15 +162,15 @@
         {
         "Name" = "8:Microsoft Visual Studio"
         "ProductName" = "8:Witness Randomizer"
-        "ProductCode" = "8:{F734652B-1189-42EB-8C54-74AB360F0718}"
-        "PackageCode" = "8:{9AFF1832-7FC0-41C8-BC56-5F628694A1FF}"
+        "ProductCode" = "8:{ED6B3515-B039-4560-B97F-A61695CCDE5F}"
+        "PackageCode" = "8:{4C062EDD-4A06-4DC6-9C37-82A2BD37A0B5}"
         "UpgradeCode" = "8:{4CB5496B-A47E-41D3-B4A7-677E29AB7513}"
         "AspNetVersion" = "8:2.0.50727.0"
         "RestartWWWService" = "11:FALSE"
         "RemovePreviousVersions" = "11:FALSE"
         "DetectNewerInstalledVersion" = "11:TRUE"
         "InstallAllUsers" = "11:FALSE"
-        "ProductVersion" = "8:4.0.6"
+        "ProductVersion" = "8:4.0.8"
         "Manufacturer" = "8:jbzdarkid"
         "ARPHELPTELEPHONE" = "8:"
         "ARPHELPLINK" = "8:https://www.github.com/jbzdarkid/witness-randomizer/issues"
@@ -0,0 +1,145 @@
+#include "ChallengeRandomizer.h"
+#include <iostream>
+
+int find(const std::vector<byte> &data, const std::vector<byte>& search, size_t startIndex = 0) {
+        for (size_t i=startIndex; i<data.size() - search.size(); i++) {
+                bool match = true;
+                for (size_t j=0; j<search.size(); j++) {
+                        if (data[i+j] == search[j]) {
+                                continue;
+                        }
+                        match = false;
+                        break;
+                }
+                if (match) return static_cast<int>(i);
+        }
+        return -1;
+}
+
+void ChallengeRandomizer::AdjustRng(int offset) {
+        int currentRng = _memory->ReadData<int>({offset}, 0x1)[0];
+        _memory->WriteData<int>({offset}, {currentRng + 0x20});
+}
+
+ChallengeRandomizer::ChallengeRandomizer(const std::shared_ptr<Memory>& memory, int seed) : _memory(memory)
+{
+        int RNG_ADDR = _memory->ReadData<int>({GLOBALS + 0x10}, 1)[0];
+        int RNG2_ADDR = _memory->ReadData<int>({GLOBALS + 0x30}, 1)[0];
+        _memory->WriteData<int>({GLOBALS + 0x30}, {RNG_ADDR + 4});
+        if (RNG2_ADDR == RNG_ADDR + 4) return; // Already applied hack
+
+        int shuffle_integers = -1;
+        int cut_random_edges = -1;
+        int get_empty_decoration_slot = -1;
+        int get_empty_dot_spot = -1;
+        int add_exactly_this_many_bisection_dots = -1;
+        int make_a_shaper = -1;
+        int init_pattern_data_lotus = -1;
+        int reroll_lotus_eater_stuff = -1;
+        int do_lotus_minutes = -1;
+        int do_lotus_eighths = -1;
+        int do_success_side_effects = -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 (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);
+                        }
+                }
+                if (cut_random_edges == -1) {
+                        int index = find(data, {0x8B, 0x80, 0xBC, 0x03, 0x00, 0x00, 0x89, 0x44, 0x24, 0x3C, 0x33, 0xC0});
+                        if (index != -1) {
+                                cut_random_edges = i + index - 0x1C;
+                                AdjustRng(cut_random_edges + 0x5D);
+                        }
+                }
+                if (get_empty_decoration_slot == -1) {
+                        int index = find(data, {0x57, 0x48, 0x83, 0xEC, 0x20, 0x8B, 0xB9, 0x38, 0x04});
+                        if (index != -1) {
+                                get_empty_decoration_slot = i + index - 0x5;
+                                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 (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 (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 (/*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_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);
+                        }
+                }
+                // 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
+                                _memory->WriteData<byte>({do_lotus_minutes + 0x5B3}, {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
+                        }
+                }
+                // This injection ensures that the seed is set every time the challenge is started.
+                if (do_success_side_effects == -1) {
+                        int index = find(data, {0x85, 0xC0, 0x7E, 0x2C, 0x48, 0x6B, 0xC8, 0x34});
+                        if (index != -1) {
+                                do_success_side_effects = i + index;
+                                _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
+                                        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
+                                });
+                                int target = (GLOBALS + 0x30) - (do_success_side_effects + 0x6); // +6 is for the length of the line
+                                _memory->WriteData<int>({do_success_side_effects + 0x2}, {target});
+                                _memory->WriteData<int>({do_success_side_effects + 0x9}, {seed});
+                        }
+                }
+        }
+}
@@ -0,0 +1,12 @@
+#pragma once
+#include "Memory.h"
+#include <memory>
+
+class ChallengeRandomizer {
+public:
+        ChallengeRandomizer(const std::shared_ptr<Memory>& memory, int seed);
+
+private:
+        void AdjustRng(int offset);
+        std::shared_ptr<Memory> _memory;
+};
@@ -3,8 +3,8 @@
 #include <map>
 #include <windows.h>
 
-// #define GLOBALS 0x5B28C0
-#define GLOBALS 0x62A080
+#define GLOBALS 0x5B28C0
+// #define GLOBALS 0x62A080
 
 // https://github.com/erayarslan/WriteProcessMemory-Example
 // http://stackoverflow.com/q/32798185
@@ -77,4 +77,5 @@ private:
         HANDLE _handle = nullptr;
 
         friend class Temp;
+        friend class ChallengeRandomizer;
 };
\ No newline at end of file
@@ -13,7 +13,6 @@
  * Swap sounds in jungle (along with panels) -- maybe impossible
  * Make orange 7 (all of oranges?) hard. Like big = hard. (See: HARD_MODE)
  * Add a setting for "disable wonkavator and hotel", so that 100% runs are possible
- * Try to stabilize challenge/doors RNG
  * I probably can randomize targets in bunker UV
  * Random *rotation* of desert laser redirect?
  * Add setting to disable laser randomization
@@ -23,6 +22,7 @@
 */
 #include "Memory.h"
 #include "Randomizer.h"
+#include "ChallengeRandomizer.h"
 #include "Panels.h"
 #include "Random.h"
 #include <string>
@@ -54,6 +54,9 @@ void Randomizer::Randomize()
         if (GameIsRandomized()) return;  // Nice sanity check, but should be unnecessary (since Main checks anyways)
         _lastRandomizedFrame = _memory->GetCurrentFrame();
 
+        // Seed challenge first for future-proofing (?)
+        RandomizeChallenge();
+
         // Content swaps -- must happen before squarePanels
         Randomize(upDownPanels, SWAP::LINES);
         Randomize(leftForwardRightPanels, SWAP::LINES);
@@ -74,7 +77,6 @@ void Randomizer::Randomize()
         RandomizeJungle();
         RandomizeSwamp();
         RandomizeMountain();
-        // RandomizeChallenge();
         // RandomizeAudioLogs();
 }
 
@@ -215,16 +217,7 @@ void Randomizer::RandomizeMountain() {
 }
 
 void Randomizer::RandomizeChallenge() {
-        std::vector<int> randomOrder(challengePanels.size(), 0);
-        std::iota(randomOrder.begin(), randomOrder.end(), 0);
-        RandomizeRange(randomOrder, SWAP::NONE, 1, 9); // Easy maze - Triple 2
-        std::vector<int> triple1Target = _memory->ReadPanelData<int>(0x00C80, TARGET, 1);
-        _memory->WritePanelData<int>(0x00CA1, TARGET, triple1Target);
-        _memory->WritePanelData<int>(0x00CB9, TARGET, triple1Target);
-        std::vector<int> triple2Target = _memory->ReadPanelData<int>(0x00C22, TARGET, 1);
-        _memory->WritePanelData<int>(0x00C59, TARGET, triple2Target);
-        _memory->WritePanelData<int>(0x00C68, TARGET, triple2Target);
-        ReassignTargets(challengePanels, randomOrder);
+        ChallengeRandomizer cr(_memory, Random::RandInt(1, 0x1000));
 }
 
 void Randomizer::RandomizeAudioLogs() {
@@ -157,6 +157,7 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
+    <ClInclude Include="ChallengeRandomizer.h" />
     <ClInclude Include="json.hpp" />
     <ClInclude Include="Memory.h" />
     <ClInclude Include="Panel.h" />
@@ -165,6 +166,7 @@
     <ClInclude Include="Randomizer.h" />
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="ChallengeRandomizer.cpp" />
     <ClCompile Include="Memory.cpp" />
     <ClCompile Include="Panel.cpp" />
     <ClCompile Include="Random.cpp" />
@@ -32,6 +32,7 @@ TEST(SwapTests, Shipwreck) {
 
 }
 
+/*
 TEST_F(Temp, Extract) {
 //      std::vector<byte> data = ReadSubtitles(166480);
         std::vector<char> data = ReadSubtitles(166480);
@@ -45,4 +46,5 @@ TEST_F(Temp, Extract) {
 
         }
     file.close();
-}
\ No newline at end of file
+}
+*/
\ No newline at end of file