21 files changed, 369 insertions, 1779 deletions

@@ -84,7 +84,7 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <LinkIncremental>false</LinkIncremental>
-    <TargetName>WitnessRandomizer</TargetName>
+    <TargetName>WitnessTutorialiser</TargetName>
     <OutDir>..\GithubPackage\</OutDir>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
@@ -5,28 +5,18 @@
 #include "Memory.h"
 #include "Random.h"
 #include "Randomizer.h"
-#include "Randomizer2.h"
 #include "Panels_.h"
 
 #define HEARTBEAT 0x401
 #define RANDOMIZE_READY 0x402
 #define RANDOMIZING 0403
 #define RANDOMIZE_DONE 0x404
-#define RANDOMIZE_CHALLENGE_DONE 0x405
-#define CHALLENGE_ONLY 0x406
-#define DISABLE_SNIPES 0x407
-#define SPEED_UP_AUTOSCROLLERS 0x408
 
 /* ------- Temp ------- */
-#include "Solver.h"
 #include "PuzzleSerializer.h"
 #include <sstream>
 #include <iomanip>
 
-#define TMP1 0x501
-#define TMP2 0x502
-#define TMP3 0x503
-#define TMP4 0x504
 
 HWND g_panelId;
 Puzzle g_puzzle;
@@ -37,13 +27,11 @@ HWND g_rngDebug;
 
 // Globals
 HWND g_hwnd;
-HWND g_seed;
+//HWND g_seed;
 HWND g_randomizerStatus;
 HINSTANCE g_hInstance;
 auto g_witnessProc = std::make_shared<Memory>(L"witness64_d3d11.exe");
 std::shared_ptr<Randomizer> g_randomizer;
-std::shared_ptr<Randomizer2> g_randomizer2;
-void SetRandomSeed();
 
 LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {
         if (message == WM_DESTROY) {
@@ -64,171 +52,57 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
                         // Shut down randomizer, wait for startup
                         if (g_randomizer) {
                             g_randomizer = nullptr;
-                            g_randomizer2 = nullptr;
                             EnableWindow(g_randomizerStatus, FALSE);
                         }
                         break;
                     case ProcStatus::Running:
                         if (!g_randomizer) {
                             g_randomizer = std::make_shared<Randomizer>(g_witnessProc);
-                            g_randomizer2 = std::make_shared<Randomizer2>(g_witnessProc);
                             PostMessage(g_hwnd, WM_COMMAND, RANDOMIZE_READY, NULL);
                         }
                         break;
                     case ProcStatus::NewGame: // This status will fire only once per new game
-                        SetWindowText(g_seed, L"");
+                        //SetWindowText(g_seed, L"");
                         PostMessage(g_hwnd, WM_COMMAND, RANDOMIZE_READY, NULL);
                         break;
                     }
                 break;
             case RANDOMIZE_READY:
                 EnableWindow(g_randomizerStatus, TRUE);
-                if (IsDlgButtonChecked(hwnd, CHALLENGE_ONLY)) {
-                    SetWindowText(g_randomizerStatus, L"Randomize Challenge");
-                } else {
-                    SetWindowText(g_randomizerStatus, L"Randomize");
-                }
+                SetWindowText(g_randomizerStatus, L"Tutorialise");
                 break;
             case RANDOMIZING:
                 if (!g_randomizer) break; // E.g. an enter press at the wrong time
                 EnableWindow(g_randomizerStatus, FALSE);
 
-                SetRandomSeed();
                 std::thread([]{
-                    if (IsDlgButtonChecked(g_hwnd, DISABLE_SNIPES)) {
-                        MEMORY_CATCH(g_randomizer->PreventSnipes());
-                    }
-                    if (IsDlgButtonChecked(g_hwnd, SPEED_UP_AUTOSCROLLERS)) {
-                        MEMORY_CATCH(g_randomizer->AdjustSpeed());
-                    }
-                    if (IsDlgButtonChecked(g_hwnd, CHALLENGE_ONLY)) {
-                        SetWindowText(g_randomizerStatus, L"Randomizing Challenge...");
-                        MEMORY_CATCH(g_randomizer->RandomizeChallenge());
-                        PostMessage(g_hwnd, WM_COMMAND, RANDOMIZE_CHALLENGE_DONE, NULL);
-                    } else {
-                        SetWindowText(g_randomizerStatus, L"Randomizing...");
-                        MEMORY_CATCH(g_randomizer->Randomize());
-                        PostMessage(g_hwnd, WM_COMMAND, RANDOMIZE_DONE, NULL);
-                    }
+                    SetWindowText(g_randomizerStatus, L"Tutorialising...");
+                    g_randomizer->Randomize();
+                    PostMessage(g_hwnd, WM_COMMAND, RANDOMIZE_DONE, NULL);
                 }).detach();
                 break;
             case RANDOMIZE_DONE:
                 EnableWindow(g_randomizerStatus, FALSE);
-                SetWindowText(g_randomizerStatus, L"Randomized!");
-                break;
-            case RANDOMIZE_CHALLENGE_DONE:
-                EnableWindow(g_randomizerStatus, FALSE);
-                SetWindowText(g_randomizerStatus, L"Randomized Challenge!");
-                std::thread([]{
-                    // Allow re-randomization for challenge -- it doesn't break the rest of the game.
-                    std::this_thread::sleep_for(std::chrono::seconds(10));
-                    PostMessage(g_hwnd, WM_COMMAND, RANDOMIZE_READY, NULL);
-                }).detach();
-                break;
-            case CHALLENGE_ONLY:
-                CheckDlgButton(hwnd, CHALLENGE_ONLY, !IsDlgButtonChecked(hwnd, CHALLENGE_ONLY));
-                if (IsWindowEnabled(g_randomizerStatus)) {
-                    PostMessage(g_hwnd, WM_COMMAND, RANDOMIZE_READY, NULL);
-                }
-                break;
-            case DISABLE_SNIPES:
-                CheckDlgButton(hwnd, DISABLE_SNIPES, !IsDlgButtonChecked(hwnd, DISABLE_SNIPES));
-                break;
-            case SPEED_UP_AUTOSCROLLERS:
-                CheckDlgButton(hwnd, SPEED_UP_AUTOSCROLLERS, !IsDlgButtonChecked(hwnd, SPEED_UP_AUTOSCROLLERS));
-                break;
-            case TMP1:
-                {
-                    std::wstring text(128, L'\0');
-                    int length = GetWindowText(g_panelId, text.data(), static_cast<int>(text.size()));
-                    text.resize(length);
-                    std::wstringstream s;
-                    int panelId;
-                    s << text;
-                    s >> std::hex >> panelId;
-                    g_puzzle = PuzzleSerializer(g_witnessProc).ReadPuzzle(panelId);
-                }
-                break;
-            case TMP2:
-                {
-                    std::wstring text(128, L'\0');
-                    int length = GetWindowText(g_panelId, text.data(), static_cast<int>(text.size()));
-                    text.resize(length);
-                    std::wstringstream s;
-                    int panelId;
-                    s << text;
-                    s >> std::hex >> panelId;
-                    PuzzleSerializer(g_witnessProc).WritePuzzle(g_puzzle, panelId);
-                }
+                SetWindowText(g_randomizerStatus, L"Tutorialised!");
                 break;
-            case TMP3:
-                {
-                    for (auto [key, value] : PANELS) {
-                        std::stringstream out;
-                        std::string name(value);
-                        out << "  {'id': 0x" << std::hex << std::uppercase << std::setfill('0') << std::setw(5) << key << ", 'area':'";
-                        int k;  
-                        for (k=0; name[k] != ' '; k++) out << name[k];
-                        if (name[k+2] == ' ') {
-                            out << name[k] << name[k+1];
-                            k += 2;
-                        }
-                        out << "', 'name':'";
-                        k++;
-                        for (k; k < name.size(); k++) out << name[k];
-                        out << "', 'data':'";
-                        auto puzzle = PuzzleSerializer(g_witnessProc).ReadPuzzle(key);
-                        out << puzzle.Serialize();
-                        out << "'},\r\n";
-                        DebugPrint(out.str());
-                    }
-                }
 
-                // Solver::Solve(g_puzzle);
-                break;
-            case TMP4:
-                SetRandomSeed();
-                g_randomizer2->Randomize();
-            case TMP5:
-                {
-                    std::wstring text;
-                    for (int i=0; i<10; i++) {
-                        Random::SetSeed(i);
-                        int rng = Random::RandInt(0, 999999);
-                        text += std::to_wstring(rng) + L"\n";
-                    }
-                    SetWindowText(g_rngDebug, text.c_str());
-                }
         }
     }
     return DefWindowProc(hwnd, message, wParam, lParam);
 }
 
-void SetRandomSeed() {
-    std::wstring text(128, L'\0');
-    int length = GetWindowText(g_seed, text.data(), static_cast<int>(text.size()));
-    if (length > 0) { // Set seed
-        text.resize(length);
-        Random::SetSeed(_wtoi(text.c_str()));
-    } else { // Random seed
-        int seed = Random::RandInt(0, 999999);
-
-        text = std::to_wstring(seed);
-        SetWindowText(g_seed, text.c_str());
-        CHARRANGE range = {0, static_cast<long>(text.length())};
-        PostMessage(g_seed, EM_EXSETSEL, NULL, (LPARAM)&range);
-        SetFocus(g_seed);
-
-                Random::SetSeed(seed);
-    }
-}
-
 HWND CreateLabel(int x, int y, int width, LPCWSTR text) {
         return CreateWindow(L"STATIC", text,
                 WS_TABSTOP | WS_VISIBLE | WS_CHILD | SS_LEFT,
                 x, y, width, 16, g_hwnd, NULL, g_hInstance, NULL);
 }
 
+HWND CreateMultiLabel(int x, int y, int width, int height, LPCWSTR text) {
+    return CreateWindow(L"STATIC", text,
+        WS_TABSTOP | WS_VISIBLE | WS_CHILD | SS_LEFT,
+        x, y, width, height, g_hwnd, NULL, g_hInstance, NULL);
+}
+
 HWND CreateText(int x, int y, int width, LPCWSTR defaultText = L"") {
         return CreateWindow(MSFTEDIT_CLASS, defaultText,
         WS_TABSTOP | WS_VISIBLE | WS_CHILD | WS_BORDER,
@@ -271,32 +145,12 @@ int APIENTRY wWinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance
         RECT rect;
     GetClientRect(GetDesktopWindow(), &rect);
         g_hwnd = CreateWindow(WINDOW_CLASS, PRODUCT_NAME, WS_OVERLAPPEDWINDOW,
-      rect.right - 550, 200, 500, 500, nullptr, nullptr, hInstance, nullptr);
+      rect.right - 550, 200, 500, 180, nullptr, nullptr, hInstance, nullptr);
 
-    CreateLabel(390, 15, 90, L"Version: " VERSION_STR);
-    g_seed = CreateText(10, 10, 100);
-    PostMessage(g_seed, EM_SETEVENTMASK, 0, ENM_KEYEVENTS);
-    g_randomizerStatus = CreateButton(120, 10, 180, L"Randomize", RANDOMIZING);
+    CreateMultiLabel(10, 10, 460, 86, L"This mod replaces most puzzles in the game with Tutorial Straight (the first puzzle in the tunnel where you start the game). Certain special panels are unaffected. Additionally, some panels (e.g. the tutorial gate, and every puzzle in Bunker) behave a little strangely now, and can be solved by simply double clicking in the middle of the panel.");
+    CreateLabel(390, 110, 90, L"Version: " VERSION_STR);
+    g_randomizerStatus = CreateButton(120, 105, 180, L"Tutorialise", RANDOMIZING);
     EnableWindow(g_randomizerStatus, FALSE);
-    CreateCheckbox(10, 300, CHALLENGE_ONLY);
-    CreateLabel(30, 300, 200, L"Randomize the challenge only");
-    CreateCheckbox(10, 320, DISABLE_SNIPES);
-    CheckDlgButton(g_hwnd, DISABLE_SNIPES, TRUE);
-    CreateLabel(30, 320, 240, L"Disable Swamp and Shadows snipes");
-    CreateCheckbox(10, 340, SPEED_UP_AUTOSCROLLERS);
-    CreateLabel(30, 340, 205, L"Speed up various autoscrollers");
-
-    // CreateButton(200, 50, 200, L"Test RNG", TMP5);
-    // g_rngDebug = CreateWindow(L"STATIC", L"",
-        //     WS_TABSTOP | WS_VISIBLE | WS_CHILD | SS_LEFT,
-        //     200, 80, 200, 200, g_hwnd, NULL, g_hInstance, NULL);
-#ifndef NDEBUG
-    g_panelId = CreateText(200, 100, 100, L"59");
-    CreateButton(200, 130, 100, L"Read", TMP1);
-    CreateButton(200, 160, 100, L"Write", TMP2);
-    CreateButton(200, 190, 100, L"Solve", TMP3);
-    CreateButton(200, 220, 100, L"Randomize2", TMP4);
-#endif
 
     g_witnessProc->StartHeartbeat(g_hwnd, HEARTBEAT);
 
@@ -3,12 +3,12 @@
 #define TO_STRING2(s) L#s
 #define TO_STRING(s) TO_STRING2(s)
 
-#define MAJOR 6
-#define MINOR 0
-#define PATCH 1
+#define MAJOR 0
+#define MINOR 4
+#define PATCH 0
 
 #define VERSION_STR     TO_STRING(MAJOR) L"." TO_STRING(MINOR) L"." TO_STRING(PATCH)
 #define VERSION                 MAJOR, MINOR, PATCH
 
-#define PRODUCT_NAME L"Witness Randomizer"
-#define WINDOW_CLASS L"WitnessRandomizer"
+#define PRODUCT_NAME L"Witness Tutorialiser Mod"
+#define WINDOW_CLASS L"WitnessTutorialiser"
@@ -0,0 +1,20 @@
+# The Witness Tutorialiser Mod
+
+This mod replaces most puzzles in the game with Tutorial Straight (the first puzzle in the tunnel where you start the game). Certain special panels are unaffected. Additionally, some panels (e.g. the tutorial gate, and every puzzle in Bunker) behave a little strangely now, and can be solved by simply double clicking in the middle of the panel.
+
+## Is everything in the game still possible?
+
+As of version 0.2.0, all 523 counting panels can be solved. This may require some creativity on your part, as certain controls (e.g. everything that moves in Quarry) no longer function.
+
+The following environmental puzzles are impossible in this mod:
+
+* Mill Ramp Light EP
+* Mill Lift Light EP
+* Quarry Elevator EP
+* Boathouse Front Ramp EP
+* Boathouse Back Ramp EP
+* Swamp Underwater Sliding Bridge EP
+* Swamp Purple Sand Outward EP
+* Swamp Purple Sand Middle EP
+* Swamp Purple Sand Inward EP is a special case. This puzzle is solveable at the start of the game, but can become impossible depending on your actions. The Swamp Floodgate can only be closed in this mod, so if you want to solve this EP you must do it before solving the floodgate.
+* Swamp Floodgate EP
@@ -1,108 +0,0 @@
-#include "pch.h"
-#include "ChallengeRandomizer.h"
-
-// Modify an opcode to use RNG2 instead of main RNG
-void ChallengeRandomizer::AdjustRng(int offset) {
-    int currentRng = _memory->ReadData<int>({offset}, 0x1)[0];
-    _memory->WriteData<int>({offset}, {currentRng + 0x20});
-}
-
-// Overwrite the pointer for the lightmap_generator (which is unused, afaict) to point to a secondary RNG.
-// Then, adjust all the RNG functions in challenge/doors to use this RNG.
-ChallengeRandomizer::ChallengeRandomizer(const std::shared_ptr<Memory>& memory, int seed) : _memory(memory)
-{
-    RNG_ADDR = _memory->ReadData<int>({GLOBALS + 0x10}, 1)[0];
-    RNG2_ADDR = _memory->ReadData<int>({GLOBALS + 0x30}, 1)[0];
-    bool alreadyInjected = (RNG2_ADDR == RNG_ADDR + 4);
-
-    if (!alreadyInjected) _memory->WriteData<int>({GLOBALS + 0x30}, {RNG_ADDR + 4});
-    _memory->WriteData<int>({GLOBALS + 0x30, 0}, {seed});
-
-    // do_success_side_effects
-    _memory->AddSigScan({0xFF, 0xC8, 0x99, 0x2B, 0xC2, 0xD1, 0xF8, 0x8B, 0xD0}, [&](int index) {
-        if (GLOBALS == 0x5B28C0) { // Version differences.
-            index += 0x3E;
-        } else if (GLOBALS == 0x62D0A0) {
-            index += 0x42;
-        }
-        // Overwritten bytes start just after the movsxd rax, dword ptr ds:[rdi + 0x230]
-        // aka test eax, eax; jle 2C; imul rcx, rax, 34
-        _memory->WriteData<byte>({index}, {
-            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
-        });
-        int target = (GLOBALS + 0x30) - (index + 0x6); // +6 is for the length of the line
-        _memory->WriteData<int>({index + 0x2}, {target});
-        _memory->WriteData<int>({index + 0x9}, {seed}); // Because we're resetting seed every challenge, we need to run this injection every time.
-    });
-
-    if (!alreadyInjected) {
-        // shuffle_integers
-        _memory->AddSigScan({0x48, 0x89, 0x5C, 0x24, 0x10, 0x56, 0x48, 0x83, 0xEC, 0x20, 0x48, 0x63, 0xDA, 0x48, 0x8B, 0xF1, 0x83, 0xFB, 0x01}, [&](int index) {
-            AdjustRng(index + 0x23);
-        });
-        // shuffle<int>
-        _memory->AddSigScan({0x33, 0xF6, 0x48, 0x8B, 0xD9, 0x39, 0x31, 0x7E, 0x51}, [&](int index) {
-            AdjustRng(index - 0x4);
-        });
-        // cut_random_edges
-        _memory->AddSigScan({0x89, 0x44, 0x24, 0x3C, 0x33, 0xC0, 0x85, 0xC0, 0x75, 0xFA}, [&](int index) {
-            AdjustRng(index + 0x3B);
-        });
-        // get_empty_decoration_slot
-        _memory->AddSigScan({0x42, 0x83, 0x3C, 0x80, 0x00, 0x75, 0xDF}, [&](int index) {
-            AdjustRng(index - 0x17);
-        });
-        // get_empty_dot_spot
-        _memory->AddSigScan({0xF7, 0xF3, 0x85, 0xD2, 0x74, 0xEC}, [&](int index) {
-            AdjustRng(index - 0xB);
-        });
-        // add_exactly_this_many_bisection_dots
-        _memory->AddSigScan({0x48, 0x8B, 0xB4, 0x24, 0xB8, 0x00, 0x00, 0x00, 0x48, 0x8B, 0xBC, 0x24, 0xB0, 0x00, 0x00, 0x00}, [&](int index) {
-            AdjustRng(index - 0x4);
-        });
-        // make_a_shaper
-        _memory->AddSigScan({0xF7, 0xE3, 0xD1, 0xEA, 0x8D, 0x0C, 0x52}, [&](int index) {
-            AdjustRng(index - 0x10);
-            AdjustRng(index + 0x1C);
-            AdjustRng(index + 0x49);
-        });
-        // Entity_Machine_Panel::init_pattern_data_lotus
-        _memory->AddSigScan({0x40, 0x55, 0x56, 0x48, 0x8D, 0x6C, 0x24, 0xB1}, [&](int index) {
-            AdjustRng(index + 0x433);
-            AdjustRng(index + 0x45B);
-            AdjustRng(index + 0x5A7);
-            AdjustRng(index + 0x5D6);
-            AdjustRng(index + 0x6F6);
-            AdjustRng(index + 0xD17);
-            AdjustRng(index + 0xFDA);
-        });
-        // Entity_Record_Player::reroll_lotus_eater_stuff
-        _memory->AddSigScan({0xB8, 0xAB, 0xAA, 0xAA, 0xAA, 0x41, 0xC1, 0xE8}, [&](int index) {
-            AdjustRng(index - 0x13);
-            AdjustRng(index + 0x34);
-        });
-
-        // These disable the random locations on timer panels, which would otherwise increment the RNG.
-        // I'm writing 31 C0 (xor eax, eax), then 3 NOPs, which pretends the RNG returns 0.
-        // do_lotus_minutes
-        _memory->AddSigScan({0x0F, 0xBE, 0x6C, 0x08, 0xFF, 0x45}, [&](int index) {
-            _memory->WriteData<byte>({index + 0x410}, {0x31, 0xC0, 0x90, 0x90, 0x90});
-        });
-        // do_lotus_tenths
-        _memory->AddSigScan({0x00, 0x04, 0x00, 0x00, 0x41, 0x8D, 0x50, 0x09}, [&](int index) {
-            _memory->WriteData<byte>({index + 0xA2}, {0x31, 0xC0, 0x90, 0x90, 0x90});
-        });
-        // do_lotus_eighths
-        _memory->AddSigScan({0x75, 0xF5, 0x0F, 0xBE, 0x44, 0x08, 0xFF}, [&](int index) {
-            _memory->WriteData<byte>({index + 0x1AE}, {0x31, 0xC0, 0x90, 0x90, 0x90});
-        });
-    }
-
-    int failed = _memory->ExecuteSigScans();
-    if (failed != 0) {
-        std::cout << "Failed " << failed << " sigscans";
-    }
-}
@@ -1,13 +0,0 @@
-#pragma once
-
-class ChallengeRandomizer {
-public:
-    ChallengeRandomizer(const std::shared_ptr<Memory>& memory, int seed);
-
-private:
-    void AdjustRng(int offset);
-    std::shared_ptr<Memory> _memory;
-
-    int RNG_ADDR;
-    int RNG2_ADDR;
-};
@@ -187,7 +187,7 @@ void* Memory::ComputeOffset(std::vector<int> offsets) {
     return reinterpret_cast<void*>(cumulativeAddress + final_offset);
 }
 
-int GLOBALS, POSITION, ORIENTATION, PATH_COLOR, REFLECTION_PATH_COLOR, DOT_COLOR, ACTIVE_COLOR, BACKGROUND_REGION_COLOR, SUCCESS_COLOR_A, SUCCESS_COLOR_B, STROBE_COLOR_A, STROBE_COLOR_B, ERROR_COLOR, PATTERN_POINT_COLOR, PATTERN_POINT_COLOR_A, PATTERN_POINT_COLOR_B, SYMBOL_A, SYMBOL_B, SYMBOL_C, SYMBOL_D, SYMBOL_E, PUSH_SYMBOL_COLORS, OUTER_BACKGROUND, OUTER_BACKGROUND_MODE, TRACED_EDGES, AUDIO_PREFIX, POWER, TARGET, POWER_OFF_ON_FAIL, IS_CYLINDER, CYLINDER_Z0, CYLINDER_Z1, CYLINDER_RADIUS, CURSOR_SPEED_SCALE, NEEDS_REDRAW, SPECULAR_ADD, SPECULAR_POWER, PATH_WIDTH_SCALE, STARTPOINT_SCALE, NUM_DOTS, NUM_CONNECTIONS, MAX_BROADCAST_DISTANCE, DOT_POSITIONS, DOT_FLAGS, DOT_CONNECTION_A, DOT_CONNECTION_B, DECORATIONS, DECORATION_FLAGS, DECORATION_COLORS, NUM_DECORATIONS, REFLECTION_DATA, GRID_SIZE_X, GRID_SIZE_Y, STYLE_FLAGS, SEQUENCE_LEN, SEQUENCE, DOT_SEQUENCE_LEN, DOT_SEQUENCE, DOT_SEQUENCE_LEN_REFLECTION, DOT_SEQUENCE_REFLECTION, NUM_COLORED_REGIONS, COLORED_REGIONS, PANEL_TARGET, SPECULAR_TEXTURE, CABLE_TARGET_2, AUDIO_LOG_NAME, OPEN_RATE, METADATA, HOTEL_EP_NAME;
+int GLOBALS, POSITION, ORIENTATION, PATH_COLOR, REFLECTION_PATH_COLOR, DOT_COLOR, ACTIVE_COLOR, BACKGROUND_REGION_COLOR, SUCCESS_COLOR_A, SUCCESS_COLOR_B, STROBE_COLOR_A, STROBE_COLOR_B, ERROR_COLOR, PATTERN_POINT_COLOR, PATTERN_POINT_COLOR_A, PATTERN_POINT_COLOR_B, SYMBOL_A, SYMBOL_B, SYMBOL_C, SYMBOL_D, SYMBOL_E, PUSH_SYMBOL_COLORS, OUTER_BACKGROUND, OUTER_BACKGROUND_MODE, TRACED_EDGES, AUDIO_PREFIX, POWER, TARGET, POWER_OFF_ON_FAIL, IS_CYLINDER, CYLINDER_Z0, CYLINDER_Z1, CYLINDER_RADIUS, CURSOR_SPEED_SCALE, NEEDS_REDRAW, SPECULAR_ADD, SPECULAR_POWER, PATH_WIDTH_SCALE, STARTPOINT_SCALE, NUM_DOTS, NUM_CONNECTIONS, MAX_BROADCAST_DISTANCE, DOT_POSITIONS, DOT_FLAGS, DOT_CONNECTION_A, DOT_CONNECTION_B, DECORATIONS, DECORATION_FLAGS, DECORATION_COLORS, NUM_DECORATIONS, REFLECTION_DATA, GRID_SIZE_X, GRID_SIZE_Y, STYLE_FLAGS, SEQUENCE_LEN, SEQUENCE, DOT_SEQUENCE_LEN, DOT_SEQUENCE, DOT_SEQUENCE_LEN_REFLECTION, DOT_SEQUENCE_REFLECTION, NUM_COLORED_REGIONS, COLORED_REGIONS, PANEL_TARGET, SPECULAR_TEXTURE, CABLE_TARGET_2, AUDIO_LOG_NAME, OPEN_RATE, METADATA, HOTEL_EP_NAME, RANDOMISE_ON_POWER_ON;
 
 void Memory::LoadPanelOffsets() {
     AddSigScan({0x74, 0x41, 0x48, 0x85, 0xC0, 0x74, 0x04, 0x48, 0x8B, 0x48, 0x10}, [sharedThis = shared_from_this()](int index){
@@ -313,6 +313,7 @@ void Memory::LoadPanelOffsets() {
         DOT_FLAGS = 0x3C8;
         DOT_CONNECTION_A = 0x3D0;
         DOT_CONNECTION_B = 0x3D8;
+        RANDOMISE_ON_POWER_ON = 0x3E0;
         DECORATIONS = 0x418;
         DECORATION_FLAGS = 0x420;
         DECORATION_COLORS = 0x428;
@@ -1,6 +1,6 @@
 #pragma once
 
-extern int GLOBALS, POSITION, ORIENTATION, PATH_COLOR, REFLECTION_PATH_COLOR, DOT_COLOR, ACTIVE_COLOR, BACKGROUND_REGION_COLOR, SUCCESS_COLOR_A, SUCCESS_COLOR_B, STROBE_COLOR_A, STROBE_COLOR_B, ERROR_COLOR, PATTERN_POINT_COLOR, PATTERN_POINT_COLOR_A, PATTERN_POINT_COLOR_B, SYMBOL_A, SYMBOL_B, SYMBOL_C, SYMBOL_D, SYMBOL_E, PUSH_SYMBOL_COLORS, OUTER_BACKGROUND, OUTER_BACKGROUND_MODE, TRACED_EDGES, AUDIO_PREFIX, POWER, TARGET, POWER_OFF_ON_FAIL, IS_CYLINDER, CYLINDER_Z0, CYLINDER_Z1, CYLINDER_RADIUS, CURSOR_SPEED_SCALE, NEEDS_REDRAW, SPECULAR_ADD, SPECULAR_POWER, PATH_WIDTH_SCALE, STARTPOINT_SCALE, NUM_DOTS, NUM_CONNECTIONS, MAX_BROADCAST_DISTANCE, DOT_POSITIONS, DOT_FLAGS, DOT_CONNECTION_A, DOT_CONNECTION_B, DECORATIONS, DECORATION_FLAGS, DECORATION_COLORS, NUM_DECORATIONS, REFLECTION_DATA, GRID_SIZE_X, GRID_SIZE_Y, STYLE_FLAGS, SEQUENCE_LEN, SEQUENCE, DOT_SEQUENCE_LEN, DOT_SEQUENCE, DOT_SEQUENCE_LEN_REFLECTION, DOT_SEQUENCE_REFLECTION, NUM_COLORED_REGIONS, COLORED_REGIONS, PANEL_TARGET, SPECULAR_TEXTURE, CABLE_TARGET_2, AUDIO_LOG_NAME, OPEN_RATE, METADATA, HOTEL_EP_NAME;
+extern int GLOBALS, POSITION, ORIENTATION, PATH_COLOR, REFLECTION_PATH_COLOR, DOT_COLOR, ACTIVE_COLOR, BACKGROUND_REGION_COLOR, SUCCESS_COLOR_A, SUCCESS_COLOR_B, STROBE_COLOR_A, STROBE_COLOR_B, ERROR_COLOR, PATTERN_POINT_COLOR, PATTERN_POINT_COLOR_A, PATTERN_POINT_COLOR_B, SYMBOL_A, SYMBOL_B, SYMBOL_C, SYMBOL_D, SYMBOL_E, PUSH_SYMBOL_COLORS, OUTER_BACKGROUND, OUTER_BACKGROUND_MODE, TRACED_EDGES, AUDIO_PREFIX, POWER, TARGET, POWER_OFF_ON_FAIL, IS_CYLINDER, CYLINDER_Z0, CYLINDER_Z1, CYLINDER_RADIUS, CURSOR_SPEED_SCALE, NEEDS_REDRAW, SPECULAR_ADD, SPECULAR_POWER, PATH_WIDTH_SCALE, STARTPOINT_SCALE, NUM_DOTS, NUM_CONNECTIONS, MAX_BROADCAST_DISTANCE, DOT_POSITIONS, DOT_FLAGS, DOT_CONNECTION_A, DOT_CONNECTION_B, DECORATIONS, DECORATION_FLAGS, DECORATION_COLORS, NUM_DECORATIONS, REFLECTION_DATA, GRID_SIZE_X, GRID_SIZE_Y, STYLE_FLAGS, SEQUENCE_LEN, SEQUENCE, DOT_SEQUENCE_LEN, DOT_SEQUENCE, DOT_SEQUENCE_LEN_REFLECTION, DOT_SEQUENCE_REFLECTION, NUM_COLORED_REGIONS, COLORED_REGIONS, PANEL_TARGET, SPECULAR_TEXTURE, CABLE_TARGET_2, AUDIO_LOG_NAME, OPEN_RATE, METADATA, HOTEL_EP_NAME, RANDOMISE_ON_POWER_ON;
 
 enum class ProcStatus {
     NotRunning,
@@ -55,6 +55,42 @@ public:
     void AddSigScan(const std::vector<byte>& scanBytes, const std::function<void(int index)>& scanFunc);
     int ExecuteSigScans();
 
+    template <typename T>
+    void CopyEntityData(int fromId, int toId, int offset, int size) {
+        WriteEntityData<T>(toId, offset, ReadEntityData<T>(fromId, offset, size));
+    }
+
+    template <typename T>
+    void CopyArray(int fromId, int toId, int offset, int size) {
+        if (size == 0) {
+            WriteEntityData<uintptr_t>(toId, offset, { static_cast<uintptr_t>(0) });
+        }
+        else {
+            WriteNewArray<T>(toId, offset, ReadArray<T>(fromId, offset, size));
+        }
+    }
+
+    template <typename T>
+    void CopyArrayDynamicSize(int fromId, int toId, int arrayOffset, int sizeOffset) {
+        CopyArray<T>(fromId, toId, arrayOffset, ReadEntityData<int>(fromId, sizeOffset, sizeof(int))[0]);
+    }
+
+    template <class T>
+    void WritePanelData(int panel, int offset, const std::vector<T>& data) {
+        WriteData<T>({ GLOBALS, 0x18, panel * 8, offset }, data);
+    }
+
+    template <class T>
+    T ReadPanelData(int panel, int offset) {
+        return ReadData<T>({ GLOBALS, 0x18, panel * 8, offset }, 1)[0];
+    }
+
+    template <class T>
+    std::vector<T> ReadPanelData(int panel, int offset, size_t size) {
+        if (size == 0) return std::vector<T>();
+        return ReadData<T>({ GLOBALS, 0x18, panel * 8, offset }, size);
+    }
+
 private:
     template<class T>
     std::vector<T> ReadData(const std::vector<int>& offsets, size_t numItems) {
@@ -67,6 +67,20 @@ std::vector<int> leftForwardRightPanels = {
     0x17E52, // Treehouse Green 4
 };
 
+std::vector<int> treehousePivots = {
+    0x17DD1, // Treehouse Left Orange 9
+    0x17CE3, // Treehouse Right Orange 4
+    0x17DB7, // Treehouse Right Orange 10
+    0x17E52, // Treehouse Green 4
+};
+
+std::vector<int> utmPerspective = {
+    0x288EA, // UTM Perspective 1
+    0x288FC, // UTM Perspective 2
+    0x289E7, // UTM Perspective 3
+    0x288AA, // UTM Perspective 4
+};
+
 std::vector<int> pillars = {
     0x0383D, // Mountain 3 Left Pillar 1
     0x0383F, // Mountain 3 Left Pillar 2
@@ -117,8 +131,8 @@ std::vector<int> mountainMultipanel = {
 };
 
 std::vector<int> squarePanels = {
-    0x00064, // Tutorial Straight
-    0x00182, // Tutorial Bend
+    //0x00064, // Tutorial Straight
+    //0x00182, // Tutorial Bend
     0x0A3B2, // Tutorial Back Right
     0x00295, // Tutorial Center Left
     0x00293, // Tutorial Front Center
@@ -433,6 +447,191 @@ std::vector<int> squarePanels = {
     0x0A16E, // UTM Challenge Entrance
     0x039B4, // Tunnels Theater Catwalk
     0x09E85, // Tunnels Town Shortcut
+
+        0x00698, // Desert Surface 1
+        0x0048F, // Desert Surface 2
+        0x09F92, // Desert Surface 3
+        0x0A036, // Desert Surface 4
+        0x09DA6, // Desert Surface 5
+        0x0A049, // Desert Surface 6
+        0x0A053, // Desert Surface 7
+        0x09F94, // Desert Surface 8
+        0x00422, // Desert Light 1
+        0x006E3, // Desert Light 2
+        0x0A02D, // Desert Light 3
+        0x00C72, // Desert Pond 1
+        0x0129D, // Desert Pond 2
+        0x008BB, // Desert Pond 3
+        0x0078D, // Desert Pond 4
+        0x18313, // Desert Pond 5
+        0x04D18, // Desert Flood 1
+        0x01205, // Desert Flood 2
+        0x181AB, // Desert Flood 3
+        0x0117A, // Desert Flood 4
+        0x17ECA, // Desert Flood 5
+        0x18076, // Desert Flood Exit
+        0x0A15C, // Desert Final Left Convex
+        0x09FFF, // Desert Final Left Concave
+        0x0A15F, // Desert Final Near
+        0x012D7, // Desert Final Far
+        0x09F7D, // Bunker Tutorial 1
+        0x09FDC, // Bunker Tutorial 2
+        0x09FF7, // Bunker Tutorial 3
+        0x09F82, // Bunker Tutorial 4
+        0x09FF8, // Bunker Tutorial 5
+        0x09D9F, // Bunker Advanced 1
+        0x09DA1, // Bunker Advanced 2
+        0x09DA2, // Bunker Advanced 3
+        0x09DAF, // Bunker Advanced 4
+    //    0x0A099, // Bunker Glass Door
+        0x0A010, // Bunker Glass 1
+        0x0A01B, // Bunker Glass 2
+        0x0A01F, // Bunker Glass 3
+        0x17E63, // Bunker Ultraviolet 1
+        0x17E67, // Bunker Ultraviolet 2
+        0x002C4, // Jungle Waves 1
+        0x00767, // Jungle Waves 2
+        0x002C6, // Jungle Waves 3
+        0x0070E, // Jungle Waves 4
+        0x0070F, // Jungle Waves 5
+        0x0087D, // Jungle Waves 6
+        0x002C7, // Jungle Waves 7
+    //    0x17CAB, // Jungle Pop-up Wall
+        0x0026D, // Jungle Dots 1
+        0x0026E, // Jungle Dots 2
+        0x0026F, // Jungle Dots 3
+        0x00C3F, // Jungle Dots 4
+        0x00C41, // Jungle Dots 5
+        0x014B2, // Jungle Dots 6
+        0x198B5, // Shadows Tutorial 1
+        0x198BD, // Shadows Tutorial 2
+        0x198BF, // Shadows Tutorial 3
+        0x19771, // Shadows Tutorial 4
+        0x0A8DC, // Shadows Tutorial 5
+        0x0AC74, // Shadows Tutorial 6
+        0x0AC7A, // Shadows Tutorial 7
+        0x0A8E0, // Shadows Tutorial 8
+        0x386FA, // Shadows Avoid 1
+        0x1C33F, // Shadows Avoid 2
+        0x196E2, // Shadows Avoid 3
+        0x1972A, // Shadows Avoid 4
+        0x19809, // Shadows Avoid 5
+        0x19806, // Shadows Avoid 6
+        0x196F8, // Shadows Avoid 7
+        0x1972F, // Shadows Avoid 8
+        0x19797, // Shadows Follow 1
+        0x1979A, // Shadows Follow 2
+        0x197E0, // Shadows Follow 3
+        0x197E8, // Shadows Follow 4
+        0x197E5, // Shadows Follow 5
+        0x19650, // Shadows Laser
+
+        0x09FCC, // Mountain 2 Multipanel 1
+        0x09FCE, // Mountain 2 Multipanel 2
+        0x09FCF, // Mountain 2 Multipanel 3
+        0x09FD0, // Mountain 2 Multipanel 4
+        0x09FD1, // Mountain 2 Multipanel 5
+        0x09FD2, // Mountain 2 Multipanel 6
+
+        0x00290, // Monastery Exterior 1
+        0x00038, // Monastery Exterior 2
+        0x00037, // Monastery Exterior 3
+    //    0x09D9B, // Monastery Bonsai
+        0x193A7, // Monastery Interior 1
+        0x193AA, // Monastery Interior 2
+        0x193AB, // Monastery Interior 3
+        0x193A6, // Monastery Interior 4
+
+
+
+            0x03629, // Tutorial Gate Open
+            0x03505, // Tutorial Gate Close
+            
+            0x0C373, // Tutorial Patio floor
+            0x1C349, // Symmetry Island Door 2 - Collision fails here, sadly
+            
+            0x28A69, // Town Lattice
+            0x28A79, // Town Maze
+            0x28B39, // Town Red Hexagonal
+            
+            0x18590, // Town Transparent
+            0x28AE3, // Town Wire
+
+
+            0x0383D, // Mountain 3 Left Pillar 1
+            0x0383F, // Mountain 3 Left Pillar 2
+            0x03859, // Mountain 3 Left Pillar 3
+            0x339BB, // Mountain 3 Left Pillar 4
+     
+            0x0383A, // Mountain 3 Right Pillar 1
+            0x09E56, // Mountain 3 Right Pillar 2
+            0x09E5A, // Mountain 3 Right Pillar 3
+            0x33961, // Mountain 3 Right Pillar 4
+
+            0x09DD5, // UTM Challenge Pillar
+
+
+    0x09FD8, // Mountain 2 Rainbow 5
+            0x17CAA, // Jungle Courtyard Gate
+            0x0005C, // Glass Factory Vertical Symmetry 5
+            0x17C31, // Desert Final Transparent
+
+            0x00143, // Orchard Apple Tree 1
+            0x0003B, // Orchard Apple Tree 2
+            0x00055, // Orchard Apple Tree 3
+            0x032F7, // Orchard Apple Tree 4
+            0x032FF, // Orchard Apple Tree 5
+            0x009B8, // Symmetry Island Transparent 1
+            0x003E8, // Symmetry Island Transparent 2
+            0x00A15, // Symmetry Island Transparent 3
+            0x00B53, // Symmetry Island Transparent 4
+            0x00B8D, // Symmetry Island Transparent 5
+            0x0C335, // Tutorial Pillar
+
+            0x09F8E, //Bottom Right
+            0x09FC1, //Bottom Left
+            0x09F01, //Top Right
+            0x09EFF, //Top Left
+            0x09FDA, // metapuzzle
+
+            0x03678, // Mill Lower Ramp Contol
+            0x03679, // Mill Lower Lift Control
+            0x03675, // Mill Upper Lift Control
+            0x03676, // Mill Upper Ramp Control
+            0x03852, // Boathouse Ramp Angle Control
+            0x03858, // Boathouse Ramp Position Control
+            0x275FA, // Boathouse Hook Control
+            0x17CC4, // Railroad Elevator
+            0x17E2B, // Swamp Flood Gate Control
+            0x00609, // Swamp Surface Sliding Bridge Control
+            0x18488, // Swamp Underwater Sliding Bridge Control
+            0x17C0A, // Swamp Island Control 1
+            0x17E07, // Swamp Island Control 2
+
+            0x01983, // Mountain 3 Left Peekaboo
+            0x01987, // Mountain 3 Right Peekaboo
+
+            0x0088E, // Challenge Easy Maze
+            0x00BAF, // Challenge Hard Maze
+            0x00BF3, // Challenge Stones Maze
+            /*0x0051F, // Challenge Column Bottom Left
+            0x00524, // Challenge Column Top Right
+            0x00CDB, // Challenge Column Top Left
+            0x00CD4, // Challenge Column Far Panel*/
+            /*0x00C80, // Challenge Triple 1 Left
+            0x00CA1, // Challenge Triple 1 Center
+            0x00CB9, // Challenge Triple 1 Right
+            0x00C22, // Challenge Triple 2 Left
+            0x00C59, // Challenge Triple 2 Center
+            0x00C68, // Challenge Triple 2 Right*/
+            0x034EC, // Challenge Triangle
+            0x034F4, // Challenge Triangle
+            0x1C31A, // Challenge Left Pillar
+            0x1C319, // Challenge Right Pillar
+
+            0x33AF5, // Mountain 1 Blue 1
+            0x33AF7, // Mountain 1 Blue 2
+            0x09F6E, // Mountain 1 Blue 3
 };
 
 std::vector<int> desertPanels = {
@@ -93,7 +93,6 @@ Things to do for V2:
 */
 #include "pch.h"
 #include "Randomizer.h"
-#include "ChallengeRandomizer.h"
 #include "Panels.h"
 #include "Random.h"
 
@@ -124,344 +123,108 @@ void Randomizer::Randomize() {
         }
         _memory->WriteData<byte>({index}, {0xEB}); // jz -> jmp
     });
-    // Sig scans will be run during challenge randomization.
-
-    // Seed challenge first for future-proofing
-    MEMORY_CATCH(RandomizeChallenge());
-
-    // Content swaps -- must happen before squarePanels
-    MEMORY_CATCH(Randomize(upDownPanels, SWAP::LINES | SWAP::COLORS));
-    MEMORY_CATCH(Randomize(leftForwardRightPanels, SWAP::LINES | SWAP::COLORS));
-
-    MEMORY_CATCH(Randomize(squarePanels, SWAP::LINES | SWAP::COLORS));
-
-    // Individual area modifications
-    MEMORY_CATCH(RandomizeTutorial());
-    MEMORY_CATCH(RandomizeDesert());
-    MEMORY_CATCH(RandomizeQuarry());
-    MEMORY_CATCH(RandomizeTreehouse());
-    MEMORY_CATCH(RandomizeKeep());
-    MEMORY_CATCH(RandomizeShadows());
-    MEMORY_CATCH(RandomizeMonastery());
-    MEMORY_CATCH(RandomizeBunker());
-    MEMORY_CATCH(RandomizeJungle());
-    MEMORY_CATCH(RandomizeSwamp());
-    MEMORY_CATCH(RandomizeMountain());
-    MEMORY_CATCH(RandomizeTown());
-    MEMORY_CATCH(RandomizeSymmetry());
-    // RandomizeAudioLogs();
-}
 
-void Randomizer::AdjustSpeed() {
-    // Desert Surface Final Control
-    _memory->WriteEntityData<float>(0x09F95, OPEN_RATE, {0.04f}); // 4x
-    // Swamp Sliding Bridge
-    _memory->WriteEntityData<float>(0x0061A, OPEN_RATE, {0.1f}); // 4x
-    // Mountain 2 Elevator
-    _memory->WriteEntityData<float>(0x09EEC, OPEN_RATE, {0.075f}); // 3x
-}
+    _memory->ExecuteSigScans();
 
-void Randomizer::RandomizeLasers() {
-    Randomize(lasers, SWAP::TARGETS);
-    // Read the target of keep front laser, and write it to keep back laser.
-    std::vector<int> keepFrontLaserTarget = _memory->ReadEntityData<int>(0x0360E, TARGET, 1);
-    _memory->WriteEntityData<int>(0x03317, TARGET, keepFrontLaserTarget);
-}
+    // Tutorial Bend
+    for (int panel : utmPerspective) {
+        Tutorialise(panel, 0x00182);
+    }
+    // Tutorial Straight
+    for (int panel : squarePanels) {
+        Tutorialise(panel, 0x00064);
+    }
+    // Town Laser Redirect Control
+    for (int panel : treehousePivots) {
+        Tutorialise(panel, 0x09F98);
 
-void Randomizer::PreventSnipes()
-{
-    // Distance-gate swamp snipe 1 to prevent RNG swamp snipe
-    _memory->WriteEntityData<float>(0x17C05, MAX_BROADCAST_DISTANCE, {15.0});
-    // Distance-gate shadows laser to prevent sniping through the bars
-    _memory->WriteEntityData<float>(0x19650, MAX_BROADCAST_DISTANCE, {2.5});
-}
+        // Mark the panel as pivotable.
+        int panelFlags = _memory->ReadEntityData<int>(panel, STYLE_FLAGS, 1)[0];
+        _memory->WriteEntityData<int>(panel, STYLE_FLAGS, { panelFlags | 0x8000 });
+    }
 
-// Private methods
-void Randomizer::RandomizeTutorial() {
     // Disable tutorial cursor speed modifications (not working?)
-    _memory->WriteEntityData<float>(0x00295, CURSOR_SPEED_SCALE, {1.0});
-    _memory->WriteEntityData<float>(0x0C373, CURSOR_SPEED_SCALE, {1.0});
-    _memory->WriteEntityData<float>(0x00293, CURSOR_SPEED_SCALE, {1.0});
-    _memory->WriteEntityData<float>(0x002C2, CURSOR_SPEED_SCALE, {1.0});
-}
+    _memory->WriteEntityData<float>(0x00295, CURSOR_SPEED_SCALE, { 1.0 });
+    _memory->WriteEntityData<float>(0x0C373, CURSOR_SPEED_SCALE, { 1.0 });
+    _memory->WriteEntityData<float>(0x00293, CURSOR_SPEED_SCALE, { 1.0 });
+    _memory->WriteEntityData<float>(0x002C2, CURSOR_SPEED_SCALE, { 1.0 });
 
-void Randomizer::RandomizeSymmetry() {
-    std::vector<int> randomOrder(transparent.size(), 0);
-    std::iota(randomOrder.begin(), randomOrder.end(), 0);
-    Shuffle(randomOrder, 1, 5);
-    ReassignTargets(transparent, randomOrder);
-}
-
-void Randomizer::RandomizeDesert() {
-    Randomize(desertPanels, SWAP::LINES);
-
-    // Turn off desert surface 8
-    _memory->WriteEntityData<float>(0x09F94, POWER, {0.0, 0.0});
-    // Turn off desert flood final
-    _memory->WriteEntityData<float>(0x18076, POWER, {0.0, 0.0});
-    // Change desert floating target to desert flood final
-    _memory->WriteEntityData<int>(0x17ECA, TARGET, {0x18077});
-}
-
-void Randomizer::RandomizeQuarry() {
-}
-
-void Randomizer::RandomizeTreehouse() {
     // Ensure that whatever pivot panels we have are flagged as "pivotable"
     // @Bug: Can return {}, be careful!
     int panelFlags = _memory->ReadEntityData<int>(0x17DD1, STYLE_FLAGS, 1)[0];
-    _memory->WriteEntityData<int>(0x17DD1, STYLE_FLAGS, {panelFlags | 0x8000});
+    _memory->WriteEntityData<int>(0x17DD1, STYLE_FLAGS, { panelFlags | 0x8000 });
     panelFlags = _memory->ReadEntityData<int>(0x17CE3, STYLE_FLAGS, 1)[0];
-    _memory->WriteEntityData<int>(0x17CE3, STYLE_FLAGS, {panelFlags | 0x8000});
+    _memory->WriteEntityData<int>(0x17CE3, STYLE_FLAGS, { panelFlags | 0x8000 });
     panelFlags = _memory->ReadEntityData<int>(0x17DB7, STYLE_FLAGS, 1)[0];
-    _memory->WriteEntityData<int>(0x17DB7, STYLE_FLAGS, {panelFlags | 0x8000});
+    _memory->WriteEntityData<int>(0x17DB7, STYLE_FLAGS, { panelFlags | 0x8000 });
     panelFlags = _memory->ReadEntityData<int>(0x17E52, STYLE_FLAGS, 1)[0];
-    _memory->WriteEntityData<int>(0x17E52, STYLE_FLAGS, {panelFlags | 0x8000});
-}
-
-void Randomizer::RandomizeKeep() {
-}
-
-void Randomizer::RandomizeShadows() {
-    // Change the shadows tutorial cable to only activate avoid
-    _memory->WriteEntityData<int>(0x319A8, CABLE_TARGET_2, {0});
-    // Change shadows avoid 8 to power shadows follow
-    _memory->WriteEntityData<int>(0x1972F, TARGET, {0x1C34C});
-
-    std::vector<int> randomOrder(shadowsPanels.size(), 0);
-    std::iota(randomOrder.begin(), randomOrder.end(), 0);
-    Shuffle(randomOrder, 0, 8); // Tutorial
-    Shuffle(randomOrder, 8, 16); // Avoid
-    Shuffle(randomOrder, 16, 21); // Follow
-    ReassignTargets(shadowsPanels, randomOrder);
-    // Turn off original starting panel
-    _memory->WriteEntityData<float>(shadowsPanels[0], POWER, {0.0f, 0.0f});
-    // Turn on new starting panel
-    _memory->WriteEntityData<float>(shadowsPanels[randomOrder[0]], POWER, {1.0f, 1.0f});
-}
-
-void Randomizer::RandomizeTown() {
-    // @Hack...? To open the gate at the end
-    std::vector<int> randomOrder(orchard.size() + 1, 0);
-    std::iota(randomOrder.begin(), randomOrder.end(), 0);
-    Shuffle(randomOrder, 1, 5);
-    // Ensure that we open the gate before the final puzzle (by swapping)
-    int panel3Index = find(randomOrder, 3);
-    int panel4Index = find(randomOrder, 4);
-    randomOrder[std::min(panel3Index, panel4Index)] = 3;
-    randomOrder[std::max(panel3Index, panel4Index)] = 4;
-    ReassignTargets(orchard, randomOrder);
-}
-
-void Randomizer::RandomizeMonastery() {
-    std::vector<int> randomOrder(monasteryPanels.size(), 0);
-    std::iota(randomOrder.begin(), randomOrder.end(), 0);
-    Shuffle(randomOrder, 3, 9); // Outer 2 & 3, Inner 1-4
-    ReassignTargets(monasteryPanels, randomOrder);
-}
-
-void Randomizer::RandomizeBunker() {
-    std::vector<int> randomOrder(bunkerPanels.size(), 0);
-    std::iota(randomOrder.begin(), randomOrder.end(), 0);
-    // Randomize Tutorial 2-Advanced Tutorial 4 + Glass 1
-    // Tutorial 1 cannot be randomized, since no other panel can start on
-    // Glass 1 will become door + glass 1, due to the targetting system
-    Shuffle(randomOrder, 1, 10);
-    // Randomize Glass 1-3 into everything after the door/glass 1
-    const size_t glass1Index = find(randomOrder, 9);
-    Shuffle(randomOrder, glass1Index + 1, 12);
-    ReassignTargets(bunkerPanels, randomOrder);
-}
-
-void Randomizer::RandomizeJungle() {
-    std::vector<int> randomOrder(junglePanels.size(), 0);
-    std::iota(randomOrder.begin(), randomOrder.end(), 0);
-    // Waves 1 cannot be randomized, since no other panel can start on
-    Shuffle(randomOrder, 1, 7); // Waves 2-7
-    Shuffle(randomOrder, 8, 13); // Pitches 1-6
-    ReassignTargets(junglePanels, randomOrder);
-
-    // Fix the wall's target to point back to the cable, and the cable to point to the pitches panel.
-    // auto wallTarget = _memory->ReadPanelData<int>(junglePanels[7], TARGET, 1);
-    // _memory->WritePanelData<int>(junglePanels[7], TARGET, {0x3C113});
-    // _memory->WritePanelData<int>(0x3C112, CABLE_TARGET_1, wallTarget);
-}
-
-void Randomizer::RandomizeSwamp() {
-}
-
-void Randomizer::RandomizeMountain() {
-    // Randomize multipanel
-    Randomize(mountainMultipanel, SWAP::LINES | SWAP::COLORS);
-
-    // Randomize final pillars order
-    std::vector<int> targets = {pillars[0] + 1};
-    for (const int pillar : pillars) {
-        int target = _memory->ReadEntityData<int>(pillar, TARGET, 1)[0];
-        targets.push_back(target);
+    _memory->WriteEntityData<int>(0x17E52, STYLE_FLAGS, { panelFlags | 0x8000 });
+}
+
+void Randomizer::Tutorialise(int panel1, int tutorialStraight) {
+    //const int tutorialStraight = 0x00064;
+    
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, PATH_COLOR, 16);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, REFLECTION_PATH_COLOR, 16);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, DOT_COLOR, 16);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, ACTIVE_COLOR, 16);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, BACKGROUND_REGION_COLOR, 12);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, SUCCESS_COLOR_A, 16);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, SUCCESS_COLOR_B, 16);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, STROBE_COLOR_A, 16);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, STROBE_COLOR_B, 16);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, ERROR_COLOR, 16);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, PATTERN_POINT_COLOR, 16);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, PATTERN_POINT_COLOR_A, 16);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, PATTERN_POINT_COLOR_B, 16);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, SYMBOL_A, 16);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, SYMBOL_B, 16);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, SYMBOL_C, 16);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, SYMBOL_D, 16);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, SYMBOL_E, 16);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, PUSH_SYMBOL_COLORS, sizeof(int));
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, OUTER_BACKGROUND, 16);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, OUTER_BACKGROUND_MODE, sizeof(int));
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, NUM_COLORED_REGIONS, sizeof(int));
+    _memory->CopyArrayDynamicSize<int>(tutorialStraight, panel1, COLORED_REGIONS, NUM_COLORED_REGIONS);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, TRACED_EDGES, 16);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, PATH_WIDTH_SCALE, sizeof(float));
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, STARTPOINT_SCALE, sizeof(float));
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, NUM_DOTS, sizeof(int));
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, NUM_CONNECTIONS, sizeof(int));
+    _memory->CopyArray<float>(tutorialStraight, panel1, DOT_POSITIONS, _memory->ReadEntityData<int>(tutorialStraight, NUM_DOTS, sizeof(int))[0]*2);
+    _memory->CopyArrayDynamicSize<int>(tutorialStraight, panel1, DOT_FLAGS, NUM_DOTS);
+    _memory->CopyArrayDynamicSize<int>(tutorialStraight, panel1, DOT_CONNECTION_A, NUM_CONNECTIONS);
+    _memory->CopyArrayDynamicSize<int>(tutorialStraight, panel1, DOT_CONNECTION_B, NUM_CONNECTIONS);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, NUM_DECORATIONS, sizeof(int));
+    _memory->CopyArrayDynamicSize<int>(tutorialStraight, panel1, DECORATIONS, NUM_DECORATIONS);
+    _memory->CopyArrayDynamicSize<int>(tutorialStraight, panel1, DECORATION_FLAGS, NUM_DECORATIONS);
+    _memory->CopyArrayDynamicSize<int>(tutorialStraight, panel1, DECORATION_COLORS, NUM_DECORATIONS);
+    if (_memory->ReadPanelData<int>(tutorialStraight, REFLECTION_DATA)) {
+        _memory->CopyArrayDynamicSize<int>(tutorialStraight, panel1, REFLECTION_DATA, NUM_DOTS);
     }
-    targets[5] = pillars[5] + 1;
-
-    std::vector<int> randomOrder(pillars.size(), 0);
-    std::iota(randomOrder.begin(), randomOrder.end(), 0);
-    Shuffle(randomOrder, 0, 4); // Left Pillars 1-4
-    Shuffle(randomOrder, 5, 9); // Right Pillars 1-4
-    ReassignTargets(pillars, randomOrder, targets);
-    // Turn off original starting panels
-    _memory->WriteEntityData<float>(pillars[0], POWER, {0.0f, 0.0f});
-    _memory->WriteEntityData<float>(pillars[5], POWER, {0.0f, 0.0f});
-    // Turn on new starting panels
-    _memory->WriteEntityData<float>(pillars[randomOrder[0]], POWER, {1.0f, 1.0f});
-    _memory->WriteEntityData<float>(pillars[randomOrder[5]], POWER, {1.0f, 1.0f});
-}
-
-void Randomizer::RandomizeChallenge() {
-    ChallengeRandomizer cr(_memory, Random::RandInt(1, 0x7FFFFFFF)); // 0 will trigger an "RNG not initialized" block
-    for (int panel : challengePanels) {
-        _memory->WriteEntityData<int>(panel, POWER_OFF_ON_FAIL, {0});
-    }
-}
-
-void Randomizer::RandomizeAudioLogs() {
-    std::vector<int> randomOrder(audiologs.size(), 0);
-    std::iota(randomOrder.begin(), randomOrder.end(), 0);
-    Shuffle(randomOrder, 0, randomOrder.size());
-    ReassignNames(audiologs, randomOrder);
-}
-
-void Randomizer::Randomize(std::vector<int>& panels, int flags) {
-    return RandomizeRange(panels, flags, 0, panels.size());
-}
-
-// Range is [start, end)
-void Randomizer::Shuffle(std::vector<int> &order, size_t startIndex, size_t endIndex) {
-    if (order.size() == 0) return;
-    if (startIndex >= endIndex) return;
-    if (endIndex >= order.size()) endIndex = static_cast<int>(order.size());
-    for (size_t i = endIndex - 1; i > startIndex; i--) {
-        const int target = Random::RandInt(static_cast<int>(startIndex), static_cast<int>(i));
-        std::swap(order[i], order[target]);
-    }
-}
-
-// Range is [start, end)
-void Randomizer::RandomizeRange(std::vector<int> panels, int flags, size_t startIndex, size_t endIndex) {
-    if (panels.size() == 0) return;
-    if (startIndex >= endIndex) return;
-    if (endIndex >= panels.size()) endIndex = static_cast<int>(panels.size());
-    for (size_t i = endIndex-1; i > startIndex; i--) {
-        const int target = Random::RandInt(static_cast<int>(startIndex), static_cast<int>(i));
-        if (i != target) {
-            // std::cout << "Swapping panels " << std::hex << panels[i] << " and " << std::hex << panels[target] << std::endl;
-            SwapPanels(panels[i], panels[target], flags);
-            std::swap(panels[i], panels[target]); // Panel indices in the array
-        }
+    else {
+        _memory->WritePanelData<long long>(panel1, REFLECTION_DATA, { 0 });
     }
-}
-
-void Randomizer::SwapPanels(int panel1, int panel2, int flags) {
-    std::map<int, int> offsets;
-
-    if (flags & SWAP::TARGETS) {
-        offsets[TARGET] = sizeof(int);
-    }
-    if (flags & SWAP::AUDIO_NAMES) {
-        offsets[AUDIO_LOG_NAME] = sizeof(void*);
-    }
-    if (flags & SWAP::COLORS) {
-        offsets[PATH_COLOR] = 16;
-        offsets[REFLECTION_PATH_COLOR] = 16;
-        offsets[DOT_COLOR] = 16;
-        offsets[ACTIVE_COLOR] = 16;
-        offsets[BACKGROUND_REGION_COLOR] = 12; // Not copying alpha to preserve transparency.
-        offsets[SUCCESS_COLOR_A] = 16;
-        offsets[SUCCESS_COLOR_B] = 16;
-        offsets[STROBE_COLOR_A] = 16;
-        offsets[STROBE_COLOR_B] = 16;
-        offsets[ERROR_COLOR] = 16;
-        offsets[PATTERN_POINT_COLOR] = 16;
-        offsets[PATTERN_POINT_COLOR_A] = 16;
-        offsets[PATTERN_POINT_COLOR_B] = 16;
-        offsets[SYMBOL_A] = 16;
-        offsets[SYMBOL_B] = 16;
-        offsets[SYMBOL_C] = 16;
-        offsets[SYMBOL_D] = 16;
-        offsets[SYMBOL_E] = 16;
-        offsets[PUSH_SYMBOL_COLORS] = sizeof(int);
-        offsets[OUTER_BACKGROUND] = 16;
-        offsets[OUTER_BACKGROUND_MODE] = sizeof(int);
-        // These two control the "burn intensity", but I can't swap out burn marks in new ver, so they should probably stay tied to each frame.
-        // offsets[SPECULAR_ADD] = sizeof(float);
-        // offsets[SPECULAR_POWER] = sizeof(int);
-        offsets[NUM_COLORED_REGIONS] = sizeof(int);
-        offsets[COLORED_REGIONS] = sizeof(void*);
-    }
-    if (flags & SWAP::LINES) {
-        offsets[TRACED_EDGES] = 16;
-        offsets[AUDIO_PREFIX] = sizeof(void*);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, SEQUENCE_LEN, sizeof(int));
+    _memory->CopyArrayDynamicSize<int>(tutorialStraight, panel1, SEQUENCE, SEQUENCE_LEN);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, DOT_SEQUENCE_LEN, sizeof(int));
+    _memory->CopyArrayDynamicSize<int>(tutorialStraight, panel1, DOT_SEQUENCE, DOT_SEQUENCE_LEN);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, DOT_SEQUENCE_LEN_REFLECTION, sizeof(int));
+    _memory->CopyArrayDynamicSize<int>(tutorialStraight, panel1, DOT_SEQUENCE_REFLECTION, DOT_SEQUENCE_LEN_REFLECTION);
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, GRID_SIZE_X, sizeof(int));
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, GRID_SIZE_Y, sizeof(int));
+    _memory->CopyEntityData<byte>(tutorialStraight, panel1, STYLE_FLAGS, sizeof(int));
+    _memory->WritePanelData<byte>(panel1, RANDOMISE_ON_POWER_ON, { 0 });
+
+
+        //arrays.push_back(AUDIO_PREFIX);
 //        offsets[IS_CYLINDER] = sizeof(int);
 //        offsets[CYLINDER_Z0] = sizeof(float);
 //        offsets[CYLINDER_Z1] = sizeof(float);
 //        offsets[CYLINDER_RADIUS] = sizeof(float);
-        offsets[PATH_WIDTH_SCALE] = sizeof(float);
-        offsets[STARTPOINT_SCALE] = sizeof(float);
-        offsets[NUM_DOTS] = sizeof(int);
-        offsets[NUM_CONNECTIONS] = sizeof(int);
-        offsets[DOT_POSITIONS] = sizeof(void*);
-        offsets[DOT_FLAGS] = sizeof(void*);
-        offsets[DOT_CONNECTION_A] = sizeof(void*);
-        offsets[DOT_CONNECTION_B] = sizeof(void*);
-        offsets[DECORATIONS] = sizeof(void*);
-        offsets[DECORATION_FLAGS] = sizeof(void*);
-        offsets[DECORATION_COLORS] = sizeof(void*);
-        offsets[NUM_DECORATIONS] = sizeof(int);
-        offsets[REFLECTION_DATA] = sizeof(void*);
-        offsets[GRID_SIZE_X] = sizeof(int);
-        offsets[GRID_SIZE_Y] = sizeof(int);
-        offsets[STYLE_FLAGS] = sizeof(int);
-        offsets[SEQUENCE_LEN] = sizeof(int);
-        offsets[SEQUENCE] = sizeof(void*);
-        offsets[DOT_SEQUENCE_LEN] = sizeof(int);
-        offsets[DOT_SEQUENCE] = sizeof(void*);
-        offsets[DOT_SEQUENCE_LEN_REFLECTION] = sizeof(int);
-        offsets[DOT_SEQUENCE_REFLECTION] = sizeof(void*);
-        offsets[PANEL_TARGET] = sizeof(void*);
-        offsets[SPECULAR_TEXTURE] = sizeof(void*);
-    }
 
-    for (auto const& [offset, size] : offsets) {
-        std::vector<byte> panel1data = _memory->ReadEntityData<byte>(panel1, offset, size);
-        std::vector<byte> panel2data = _memory->ReadEntityData<byte>(panel2, offset, size);
-        _memory->WriteEntityData<byte>(panel2, offset, panel1data);
-        _memory->WriteEntityData<byte>(panel1, offset, panel2data);
-    }
-}
+        //arrays.push_back(PANEL_TARGET);
+        //arrays.push_back(SPECULAR_TEXTURE);
 
-void Randomizer::ReassignTargets(const std::vector<int>& panels, const std::vector<int>& order, std::vector<int> targets) {
-    if (targets.empty()) {
-        // This list is offset by 1, so the target of the Nth panel is in position N (aka the N+1th element)
-        // The first panel may not have a wire to power it, so we use the panel ID itself.
-        targets = {panels[0] + 1};
-        for (const int panel : panels) {
-            int target = _memory->ReadEntityData<int>(panel, TARGET, 1)[0];
-            targets.push_back(target);
-        }
-    }
-
-    for (size_t i=0; i<order.size() - 1; i++) {
-        // Set the target of order[i] to order[i+1], using the "real" target as determined above.
-        const int panelTarget = targets[order[i+1]];
-        _memory->WriteEntityData<int>(panels[order[i]], TARGET, {panelTarget});
-    }
-}
-
-void Randomizer::ReassignNames(const std::vector<int>& panels, const std::vector<int>& order) {
-    std::vector<int64_t> names;
-    for (const int panel : panels) {
-        names.push_back(_memory->ReadEntityData<int64_t>(panel, AUDIO_LOG_NAME, 1)[0]);
-    }
-
-    for (int i=0; i<panels.size(); i++) {
-        _memory->WriteEntityData<int64_t>(panels[i], AUDIO_LOG_NAME, {names[order[i]]});
-    }
 }
@@ -4,45 +4,14 @@ class Randomizer {
 public:
     Randomizer(const std::shared_ptr<Memory>& memory);
     void Randomize();
-    void RandomizeChallenge();
-
-    void AdjustSpeed();
-    void RandomizeLasers();
-    void PreventSnipes();
-
-    enum SWAP {
-        // NONE = 0,
-        TARGETS = 1,
-        LINES = 2,
-        AUDIO_NAMES = 4,
-        COLORS = 8,
-    };
 
 private:
     int _lastRandomizedFrame = 1 << 30;
-    void RandomizeTutorial();
-    void RandomizeSymmetry();
-    void RandomizeDesert();
-    void RandomizeQuarry();
-    void RandomizeTreehouse();
-    void RandomizeKeep();
-    void RandomizeShadows();
-    void RandomizeTown();
-    void RandomizeMonastery();
-    void RandomizeBunker();
-    void RandomizeJungle();
-    void RandomizeSwamp();
-    void RandomizeMountain();
-    void RandomizeAudioLogs();
 
-    void Randomize(std::vector<int>& panels, int flags);
-    void Shuffle(std::vector<int>&order, size_t startIndex, size_t endIndex);
-    void RandomizeRange(std::vector<int> panels, int flags, size_t startIndex, size_t endIndex);
-    void SwapPanels(int panel1, int panel2, int flags);
-    void ReassignTargets(const std::vector<int>& panels, const std::vector<int>& order, std::vector<int> targets = {});
-    void ReassignNames(const std::vector<int>& panels, const std::vector<int>& order);
+    void Tutorialise(int panel1, int copyFrom);
 
     std::shared_ptr<Memory> _memory;
 
     friend class SwapTests_Shipwreck_Test;
 };
+
@@ -1,644 +0,0 @@
-#include "pch.h"
-#include "Randomizer2.h"
-#include "PuzzleSerializer.h"
-#include "Randomizer2Core.h"
-#include "Random.h"
-#include "Solver.h"
-#include "Windows.h"
-
-Randomizer2::Randomizer2(const PuzzleSerializer& serializer) : _serializer(serializer) {
-}
-
-void Randomizer2::Randomize() {
-    // RandomizeTutorial();
-    // RandomizeGlassFactory();
-    RandomizeSymmetryIsland();
-    // RandomizeKeep();
-}
-
-void Randomizer2::RandomizeTutorial() {
-    { // Far center
-        Puzzle p;
-        p.NewGrid(4, 4);
-        p.grid[0][8].start = true;
-        p.grid[8][0].end = Cell::Dir::UP;
-
-        for (Pos pos : Randomizer2Core::CutEdges(p, 14)) {
-            p.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
-        }
-        _serializer.WritePuzzle(p, 0x293);
-    }
-
-    { // Center left
-        Puzzle p;
-        p.NewGrid(6, 6);
-
-        int x = Random::RandInt(0, (p.width-1)/2)*2;
-        int y = Random::RandInt(0, (p.height-1)/2)*2;
-        int rng = Random::RandInt(1, 4);
-             if (rng == 1) p.grid[x][0].end = Cell::Dir::UP;
-        else if (rng == 2) p.grid[x][p.height-1].end = Cell::Dir::DOWN;
-        else if (rng == 3) p.grid[0][y].end = Cell::Dir::LEFT;
-        else if (rng == 4) p.grid[p.width-1][y].end = Cell::Dir::RIGHT;
-
-        // [4/6/8][4/6/8]
-        p.grid[Random::RandInt(0, 2)*2 + 4][Random::RandInt(0, 2)*2 + 4].start = true;
-    
-        for (Pos pos : Randomizer2Core::CutEdges(p, 35)) {
-            p.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
-        }
-
-        _serializer.WritePuzzle(p, 0x295);
-    }
-
-    { // Far left
-        Puzzle p;
-        p.NewGrid(10, 10);
-
-        p.grid[0][20].start = true;
-        p.grid[20][0].end = Cell::Dir::RIGHT;
-
-        for (Pos pos : Randomizer2Core::CutEdges(p, 96)) {
-            p.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
-        }
-        _serializer.WritePuzzle(p, 0x2C2);
-    }
-
-    { // Back left
-        Puzzle p;
-        p.NewGrid(6, 6);
-
-        p.grid[0][12].start = true;
-        p.grid[12][0].end = Cell::Dir::RIGHT;
-        p.grid[12][12].end = Cell::Dir::RIGHT;
-
-        for (Pos pos : Randomizer2Core::CutEdges(p, 27)) {
-            p.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
-        }
-        _serializer.WritePuzzle(p, 0xA3B5);
-    }
-
-    { // Back right
-        Puzzle p;
-        p.NewGrid(6, 6);
-
-        p.grid[0][12].start = true;
-        p.grid[12][12].start = true;
-        p.grid[6][0].end = Cell::Dir::UP;
-
-        // @Cleanup
-        std::vector<Pos> cuts;
-        bool toTheRight;
-        // Start by generating a cut line, to ensure one of the two startpoints is inaccessible
-        int x, y;
-        switch (Random::RandInt(1, 4)) {
-            case 1:
-                x = 1; y = 1;
-                toTheRight = true;
-                cuts.emplace_back(0, 1);
-                break;
-            case 2:
-                x = 1; y = 1;
-                toTheRight = true;
-                cuts.emplace_back(1, 0);
-                break;
-            case 3:
-                x = 11; y = 1;
-                toTheRight = false;
-                cuts.emplace_back(12, 1);
-                break;
-            case 4:
-                x = 11; y = 1;
-                toTheRight = false;
-                cuts.emplace_back(11, 0);
-                break;
-        }
-        while (y < p.height) { // The final cut will push y below the bottom of the puzzle, which means we're done.
-            switch (Random::RandInt(1, 4)) {
-                case 1: // Go right
-                    if (x < p.width-2) {
-                        cuts.emplace_back(x+1, y);
-                        x += 2;
-                    }
-                    break;
-                case 2: // Go left
-                    if (x > 1) {
-                        cuts.emplace_back(x-1, y);
-                        x -= 2;
-                    }
-                    break;
-                case 3: 
-                case 4: // Go down (biased x2)
-                    cuts.emplace_back(x, y+1);
-                    y += 2;
-                    break;
-            }
-        }
-
-        for (Pos pos : cuts) {
-            p.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
-        }
-
-        for (Pos pos : Randomizer2Core::CutEdges(p, 30 - cuts.size())) {
-            p.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
-        }
-        _serializer.WritePuzzle(p, 0xA3B2);
-    }
-}
-
-void Randomizer2::RandomizeGlassFactory() {
-    { // Back wall 1
-        Puzzle p;
-        p.NewGrid(3, 3);
-        p.symmetry = Puzzle::Symmetry::X;
-        p.grid[0][6].start = true;
-        p.grid[6][6].start = true;
-        p.grid[2][0].end = Cell::Dir::UP;
-        p.grid[4][0].end = Cell::Dir::UP;
-
-        std::vector<Pos> cutEdges = Randomizer2Core::CutSymmetricalEdgePairs(p, 2);
-        for (Pos pos : cutEdges) {
-            Pos sym = p.GetSymmetricalPos(pos.x, pos.y);
-            p.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
-            p.grid[sym.x][sym.y].gap = Cell::Gap::BREAK;
-        }
-        _serializer.WritePuzzle(p, 0x86);
-    }
-    { // Back wall 2
-        Puzzle p;
-        p.NewGrid(4, 4);
-        p.symmetry = Puzzle::Symmetry::X;
-        p.grid[0][8].start = true;
-        p.grid[8][8].start = true;
-        p.grid[2][0].end = Cell::Dir::UP;
-        p.grid[6][0].end = Cell::Dir::UP;
-        std::vector<Pos> cutEdges = Randomizer2Core::CutSymmetricalEdgePairs(p, 4);
-        for (int i=0; i<cutEdges.size(); i++) {
-            Pos pos = cutEdges[i];
-            if (i%2 == 0) {
-                p.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
-            } else {
-                Pos sym = p.GetSymmetricalPos(pos.x, pos.y);
-                p.grid[sym.x][sym.y].gap = Cell::Gap::BREAK;
-            }
-        }
-
-        _serializer.WritePuzzle(p, 0x87);
-    }
-    { // Back wall 3
-        Puzzle p;
-        p.NewGrid(5, 6);
-        p.symmetry = Puzzle::Symmetry::X;
-        p.grid[2][10].start = true;
-        p.grid[8][10].start = true;
-        p.grid[4][0].end = Cell::Dir::UP;
-        p.grid[6][0].end = Cell::Dir::UP;
-        std::vector<Pos> cutEdges = Randomizer2Core::CutSymmetricalEdgePairs(p, 10);
-        for (int i=0; i<cutEdges.size(); i++) {
-            Pos pos = cutEdges[i];
-            if (i%2 == 0) {
-                p.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
-            } else {
-                Pos sym = p.GetSymmetricalPos(pos.x, pos.y);
-                p.grid[sym.x][sym.y].gap = Cell::Gap::BREAK;
-            }
-        }
-
-        _serializer.WritePuzzle(p, 0x59);
-    }
-    { // Back wall 4
-        Puzzle p;
-        p.NewGrid(5, 8);
-        p.symmetry = Puzzle::Symmetry::X;
-        p.grid[2][16].start = true;
-        p.grid[8][16].start = true;
-        p.grid[4][0].end = Cell::Dir::UP;
-        p.grid[6][0].end = Cell::Dir::UP;
-        std::vector<Pos> cutEdges = Randomizer2Core::CutSymmetricalEdgePairs(p, 15);
-        for (int i=0; i<cutEdges.size(); i++) {
-            Pos pos = cutEdges[i];
-            if (i%2 == 0) {
-                p.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
-            } else {
-                Pos sym = p.GetSymmetricalPos(pos.x, pos.y);
-                p.grid[sym.x][sym.y].gap = Cell::Gap::BREAK;
-            }
-        }
-
-        _serializer.WritePuzzle(p, 0x62);
-    }
-    // TODO: Positioning is off, slightly -- which means you can start from the bottom left, if you peek around.
-    { // Back wall 5
-        Puzzle p;
-        p.NewGrid(11, 8);
-        p.symmetry = Puzzle::Symmetry::X;
-        p.grid[0][16].start = true;
-        p.grid[10][16].start = true;
-        p.grid[12][16].start = true;
-        p.grid[22][16].start = true;
-        p.grid[2][0].end = Cell::Dir::UP;
-        p.grid[8][0].end = Cell::Dir::UP;
-        p.grid[14][0].end = Cell::Dir::UP;
-        p.grid[20][0].end = Cell::Dir::UP;
-
-        Puzzle q;
-        q.NewGrid(5, 8);
-        q.symmetry = Puzzle::Symmetry::X;
-
-        for (Pos pos : Randomizer2Core::CutSymmetricalEdgePairs(q, 16)) {
-            p.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
-        }
-        for (Pos pos : Randomizer2Core::CutSymmetricalEdgePairs(q, 16)) {
-            p.grid[pos.x + 12][pos.y].gap = Cell::Gap::BREAK;
-        }
-
-        for (int y=0; y<p.height; y+=2) {
-            p.grid[5][y].gap = Cell::Gap::BREAK;
-        }
-
-        _serializer.WritePuzzle(p, 0x5C);
-    }
-
-    { // Rotational 1
-        Puzzle p;
-        p.NewGrid(3, 3);
-        p.symmetry = Puzzle::Symmetry::XY;
-        p.grid[6][0].start = true;
-        p.grid[0][6].start = true;
-        p.grid[4][0].end = Cell::Dir::UP;
-        p.grid[2][6].end = Cell::Dir::DOWN;
-
-        p.grid[5][0].gap = Cell::Gap::BREAK;
-        p.grid[1][6].gap = Cell::Gap::BREAK;
-
-        for (Pos pos : Randomizer2Core::CutSymmetricalEdgePairs(p, 1)) {
-            p.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
-            Pos sym = p.GetSymmetricalPos(pos.x, pos.y);
-            p.grid[sym.x][sym.y].gap = Cell::Gap::BREAK;
-        }
-        _serializer.WritePuzzle(p, 0x8D);
-    }
-    { // Rotational 2
-        Puzzle p;
-        p.NewGrid(3, 3);
-        p.symmetry = Puzzle::Symmetry::XY;
-        p.grid[6][0].start = true;
-        p.grid[0][6].start = true;
-        p.grid[4][0].end = Cell::Dir::UP;
-        p.grid[2][6].end = Cell::Dir::DOWN;
-
-        p.grid[5][0].gap = Cell::Gap::BREAK;
-        p.grid[1][6].gap = Cell::Gap::BREAK;
-
-        std::vector<Pos> cutEdges = Randomizer2Core::CutSymmetricalEdgePairs(p, 3);
-        for (int i=0; i<cutEdges.size(); i++) {
-            Pos pos = cutEdges[i];
-            if (i%2 == 0) {
-                p.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
-            } else {
-                Pos sym = p.GetSymmetricalPos(pos.x, pos.y);
-                p.grid[sym.x][sym.y].gap = Cell::Gap::BREAK;
-            }
-        }
-
-        p.grid[1][6].gap = Cell::Gap::NONE;
-
-        _serializer.WritePuzzle(p, 0x81);
-    }
-    { // Rotational 3
-        Puzzle p;
-        p.NewGrid(4, 4);
-        p.symmetry = Puzzle::Symmetry::XY;
-        p.grid[8][0].start = true;
-        p.grid[0][8].start = true;
-        p.grid[0][0].end = Cell::Dir::LEFT;
-        p.grid[8][8].end = Cell::Dir::RIGHT;
-
-        std::vector<Pos> cutEdges = Randomizer2Core::CutSymmetricalEdgePairs(p, 7);
-        for (int i=0; i<cutEdges.size(); i++) {
-            Pos pos = cutEdges[i];
-            if (i%2 == 0) {
-                p.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
-            } else {
-                Pos sym = p.GetSymmetricalPos(pos.x, pos.y);
-                p.grid[sym.x][sym.y].gap = Cell::Gap::BREAK;
-            }
-        }
-
-        _serializer.WritePuzzle(p, 0x83);
-    }
-    { // Melting
-        Puzzle p;
-        p.NewGrid(6, 6);
-        p.symmetry = Puzzle::Symmetry::XY;
-        p.grid[12][0].start = true;
-        p.grid[0][12].start = true;
-        p.grid[0][0].end = Cell::Dir::LEFT;
-        p.grid[12][12].end = Cell::Dir::RIGHT;
-        Puzzle q = p;
-
-        std::vector<Pos> cutEdges = Randomizer2Core::CutSymmetricalEdgePairs(p, 15);
-        for (int i=0; i<cutEdges.size(); i++) {
-            Pos pos = cutEdges[i];
-            Pos sym = p.GetSymmetricalPos(pos.x, pos.y);
-
-            if (i%2 == 0) {
-                p.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
-            } else {
-                p.grid[sym.x][sym.y].gap = Cell::Gap::BREAK;
-            }
-
-            if (pos.x < sym.x) {
-                q.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
-            } else {
-                q.grid[sym.x][sym.y].gap = Cell::Gap::BREAK;
-            }
-        }
-
-        _serializer.WritePuzzle(p, 0x84); // Melting 1
-        _serializer.WritePuzzle(q, 0x82); // Melting 2
-        _serializer.WritePuzzle(q, 0x343A); // Melting 3
-    }
-}
-
-void Randomizer2::RandomizeSymmetryIsland() {
-    { // Entry door
-        Puzzle p;
-        p.NewGrid(4, 3);
-        p.grid[0][6].start = true;
-        p.grid[8][0].end = Cell::Dir::RIGHT;
-        p.grid[4][3].gap = Cell::Gap::FULL;
-
-        std::vector<Pos> corners;
-        std::vector<Pos> cells;
-        std::vector<Pos> edges;
-        for (int x=0; x<p.width; x++) {
-            for (int y=0; y<p.height; y++) {
-                if (x%2 == 0 && y%2 == 0) corners.emplace_back(Pos{x, y});
-                else if (x%2 == 1 && y%2 == 1) cells.emplace_back(Pos{x, y});
-                else edges.emplace_back(Pos{x, y});
-            }
-        }
-
-        for (int j=0;; j++) {
-            std::vector<Pos> dots = Random::SelectFromSet(edges, 4);
-            for (Pos pos : dots) p.grid[pos.x][pos.y].dot = Cell::Dot::BLACK;
-
-            auto solutions = Solver::Solve(p);
-            if (solutions.size() > 0 && solutions.size() < 10) break;
-
-            for (Pos pos : dots) p.grid[pos.x][pos.y].dot = Cell::Dot::NONE;
-        }
-
-        _serializer.WritePuzzle(p, 0xB0);
-    }
-
-    { // Dots 1
-        Puzzle p;
-        p.NewGrid(3, 3);
-        p.symmetry = Puzzle::Symmetry::Y;
-        p.grid[0][2].start = true;
-        p.grid[0][4].start = true;
-        p.grid[6][2].end = Cell::Dir::RIGHT;
-        p.grid[6][4].end = Cell::Dir::RIGHT;
-
-        std::vector<Pos> corners;
-        std::vector<Pos> cells;
-        std::vector<Pos> edges;
-        for (int x=0; x<p.width; x++) {
-            for (int y=0; y<p.height/2; y++) {
-                if (x%2 == 0 && y%2 == 0) corners.emplace_back(Pos{x, y});
-                else if (x%2 == 1 && y%2 == 1) cells.emplace_back(Pos{x, y});
-                else edges.emplace_back(Pos{x, y});
-            }
-        }
-        edges.insert(edges.end(), corners.begin(), corners.end());
-
-        std::vector<Pos> dots;
-        for (int j=0;; j++) {
-            dots = Random::SelectFromSet(edges, 3);
-            for (Pos pos : dots) p.grid[pos.x][pos.y].dot = Cell::Dot::BLACK;
-
-            auto solutions = Solver::Solve(p);
-            if (solutions.size() == 2) break;
-
-            for (Pos pos : dots) p.grid[pos.x][pos.y].dot = Cell::Dot::NONE;
-        }
-
-        for (Pos pos : dots) {
-            Pos sym = p.GetSymmetricalPos(pos.x, pos.y);
-            p.grid[sym.x][sym.y].dot = Cell::Dot::BLACK;
-        }
-
-        _serializer.WritePuzzle(p, 0x22);
-    }
-    { // Dots 2
-        Puzzle p;
-        p.NewGrid(3, 3);
-        p.symmetry = Puzzle::Symmetry::Y;
-        p.grid[0][2].start = true;
-        p.grid[0][4].start = true;
-        p.grid[6][2].end = Cell::Dir::RIGHT;
-        p.grid[6][4].end = Cell::Dir::RIGHT;
-
-        std::vector<Pos> corners;
-        std::vector<Pos> cells;
-        std::vector<Pos> edges;
-        for (int x=0; x<p.width; x++) {
-            for (int y=0; y<p.height/2; y++) {
-                if (x%2 == 0 && y%2 == 0) corners.emplace_back(Pos{x, y});
-                else if (x%2 == 1 && y%2 == 1) cells.emplace_back(Pos{x, y});
-                else edges.emplace_back(Pos{x, y});
-            }
-        }
-        edges.insert(edges.end(), corners.begin(), corners.end());
-
-        std::vector<Pos> dots;
-        for (int j=0;; j++) {
-            dots = Random::SelectFromSet(edges, 3);
-            for (Pos pos : dots) p.grid[pos.x][pos.y].dot = Cell::Dot::BLACK;
-
-            auto solutions = Solver::Solve(p);
-            if (solutions.size() == 2) break;
-
-            for (Pos pos : dots) p.grid[pos.x][pos.y].dot = Cell::Dot::NONE;
-        }
-
-        Pos pos = dots[1];
-        Pos sym = p.GetSymmetricalPos(pos.x, pos.y);
-        p.grid[pos.x][pos.y].dot = Cell::Dot::NONE;
-        p.grid[sym.x][sym.y].dot = Cell::Dot::BLACK;
-
-        _serializer.WritePuzzle(p, 0x23);
-    }
-}
-
-void Randomizer2::RandomizeKeep() {
-    { // Hedges 1
-        Puzzle p;
-        p.NewGrid(4, 4);
-
-        p.grid[2][1].gap = Cell::Gap::FULL;
-        p.grid[4][1].gap = Cell::Gap::FULL;
-        p.grid[6][1].gap = Cell::Gap::FULL;
-        p.grid[3][2].gap = Cell::Gap::FULL;
-        p.grid[5][2].gap = Cell::Gap::FULL;
-        p.grid[8][3].gap = Cell::Gap::FULL;
-        p.grid[2][5].gap = Cell::Gap::FULL;
-        p.grid[6][5].gap = Cell::Gap::FULL;
-        p.grid[7][6].gap = Cell::Gap::FULL;
-        p.grid[2][7].gap = Cell::Gap::FULL;
-        p.grid[4][7].gap = Cell::Gap::FULL;
-
-        p.grid[4][8].start = true;
-        p.grid[6][0].end = Cell::Dir::UP;
-
-        std::vector<Pos> cutEdges = Randomizer2Core::CutInsideEdges(p, 5);
-        Puzzle copy = p;
-        std::vector<int> gates = {0x00344, 0x00488,  0x00489, 0x00495, 0x00496};
-        for (int i=0; i<cutEdges.size(); i++) {
-            Pos pos = cutEdges[i];
-            copy.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
-            SetGate(gates[i], pos.x, pos.y);
-        }
-        auto solution = GetUniqueSolution(copy);
-        p.sequence = solution.sequence;
-        _serializer.WritePuzzle(p, 0x139);
-    }
-
-    { // Hedges 2
-        Puzzle p;
-        p.NewGrid(4, 4);
-
-        p.grid[2][1].gap = Cell::Gap::FULL;
-        p.grid[1][2].gap = Cell::Gap::FULL;
-        p.grid[5][2].gap = Cell::Gap::FULL;
-        p.grid[7][4].gap = Cell::Gap::FULL;
-        p.grid[4][5].gap = Cell::Gap::FULL;
-        p.grid[6][5].gap = Cell::Gap::FULL;
-        p.grid[1][6].gap = Cell::Gap::FULL;
-        p.grid[2][7].gap = Cell::Gap::FULL;
-        p.grid[5][8].gap = Cell::Gap::FULL;
-
-        p.grid[0][8].start = true;
-        p.grid[8][0].end = Cell::Dir::RIGHT;
-
-        std::vector<Pos> cutEdges = Randomizer2Core::CutInsideEdges(p, 7);
-        for (Pos pos : cutEdges) {
-            p.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
-        }
-        auto solution = GetUniqueSolution(p);
-
-        Puzzle q;
-        q.NewGrid(4, 4);
-        q.grid[0][8].start = true;
-        q.grid[8][0].end = Cell::Dir::RIGHT;
-        q.sequence = solution.sequence;
-        for (Pos pos : cutEdges) {
-            q.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
-        }
-        // Cut to 6 of 9 additional edges
-        for (Pos pos : Randomizer2Core::CutInsideEdges(q, 6)) {
-            q.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
-        }
-        _serializer.WritePuzzle(q, 0x19DC);
-    }
-    
-    { // Hedges 3 [WIP]
-        Puzzle p;
-        p.NewGrid(4, 4);
-
-        p.grid[2][1].gap = Cell::Gap::FULL;
-        p.grid[5][2].gap = Cell::Gap::FULL;
-        p.grid[7][2].gap = Cell::Gap::FULL;
-        p.grid[4][3].gap = Cell::Gap::FULL;
-        p.grid[1][4].gap = Cell::Gap::FULL;
-        p.grid[6][5].gap = Cell::Gap::FULL;
-        p.grid[1][6].gap = Cell::Gap::FULL;
-        p.grid[3][6].gap = Cell::Gap::FULL;
-        p.grid[6][7].gap = Cell::Gap::FULL;
-
-        p.grid[0][8].start = true;
-        p.grid[8][2].end = Cell::Dir::RIGHT;
-
-        std::vector<Pos> cutEdges = Randomizer2Core::CutInsideEdges(p, 7);
-        for (Pos pos : cutEdges) {
-            p.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
-        }
-
-        std::vector<int> pebbleMarkers = {0x034a9, 0x034b1, 0x034be, 0x034c4};
-
-        // _serializer.WritePuzzle(p, 0x19E7);
-    }
-
-    { // Hedges 4
-        Puzzle p;
-        p.NewGrid(4, 4);
-
-        p.grid[3][0].gap = Cell::Gap::FULL;
-        p.grid[4][1].gap = Cell::Gap::FULL;
-        p.grid[8][1].gap = Cell::Gap::FULL;
-        p.grid[1][2].gap = Cell::Gap::FULL;
-        p.grid[4][3].gap = Cell::Gap::FULL;
-        p.grid[8][3].gap = Cell::Gap::FULL;
-        p.grid[1][4].gap = Cell::Gap::FULL;
-        p.grid[5][4].gap = Cell::Gap::FULL;
-        p.grid[2][5].gap = Cell::Gap::FULL;
-        p.grid[6][5].gap = Cell::Gap::FULL;
-        p.grid[3][6].gap = Cell::Gap::FULL;
-        p.grid[0][7].gap = Cell::Gap::FULL;
-        p.grid[8][7].gap = Cell::Gap::FULL;
-        p.grid[5][8].gap = Cell::Gap::FULL;
-
-        p.grid[0][8].start = true;
-        p.grid[4][0].end = Cell::Dir::UP;
-
-        std::vector<Pos> cutEdges = Randomizer2Core::CutInsideEdges(p, 2);
-        for (Pos pos : cutEdges) {
-            p.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
-        }
-        auto solution = GetUniqueSolution(p);
-
-        Puzzle q;
-        q.NewGrid(4, 4);
-        q.grid[0][8].start = true;
-        q.grid[4][0].end = Cell::Dir::UP;
-        q.sequence = solution.sequence;
-        for (Pos pos : cutEdges) {
-            q.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
-        }
-        for (Pos pos : Randomizer2Core::CutInsideEdges(q, 7)) {
-            q.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
-        }
-        _serializer.WritePuzzle(q, 0x1A0F);
-    }
-}
-
-Puzzle Randomizer2::GetUniqueSolution(Puzzle& p) {
-    auto solutions = Solver::Solve(p);
-    assert(solutions.size() == 1);
-    return solutions[0];
-}
-
-void Randomizer2::SetGate(int panel, int X, int Y) {
-    float x, y, z, w;
-    if (X%2 == 0 && Y%2 == 1) { // Horizontal
-        x = -1.49f * X + 0.22f * Y + 66.58f;
-        y = 0.275f * X +  1.6f * Y + 108.4f;
-        z = -.77f;
-        w = .63f;
-    } else { // Vertical
-        assert(X%2 == 1 && Y%2 == 0);
-        x = -1.6f * X + 0.35f * Y +   66.5f;
-        y = 0.25f * X +  1.6f * Y + 108.55f;
-        z = -0.1f;
-        w = 1.0f;
-    }
-
-    SetPos(panel, x, y, 19.2f);
-    // _memory->WriteEntityData<float>(panel, ORIENTATION, {0.0f, 0.0f, z, w});
-}
-
-void Randomizer2::SetPos(int panel, float x, float y, float z) {
-    // _memory->WriteEntityData<float>(panel, POSITION, {x, y, z});
-}
\ No newline at end of file
@@ -1,19 +0,0 @@
-#pragma once
-#include "PuzzleSerializer.h"
-
-class Randomizer2 {
-public:
-    Randomizer2(const PuzzleSerializer& serializer);
-    void Randomize();
-    void RandomizeTutorial();
-    void RandomizeGlassFactory();
-    void RandomizeSymmetryIsland();
-    void RandomizeKeep();
-    
-private:
-    Puzzle GetUniqueSolution(Puzzle& p);
-    void SetGate(int panel, int X, int Y);
-    void SetPos(int panel, float x, float y, float z);
-
-    PuzzleSerializer _serializer;
-};
@@ -1,203 +0,0 @@
-#include "pch.h"
-#include "Randomizer2Core.h"
-#include "Random.h"
-
-std::vector<Pos> Randomizer2Core::CutEdges(const Puzzle& p, size_t numEdges) {
-    return CutEdgesInternal(p, 0, p.width, 0, p.height, numEdges);
-}
-
-std::vector<Pos> Randomizer2Core::CutInsideEdges(const Puzzle& p, size_t numEdges) {
-    return CutEdgesInternal(p, 1, p.width-1, 1, p.height-1, numEdges);
-}
-
-std::vector<Pos> Randomizer2Core::CutSymmetricalEdgePairs(const Puzzle& p, size_t numEdges) {
-    Puzzle copy = p;
-    // Prevent cuts from landing on the midline
-    if (p.symmetry == Puzzle::Symmetry::X) {
-        for (int y=0; y<p.height; y++) {
-            copy.grid[p.width/2][y].gap = Cell::Gap::FULL;
-        }
-        return CutEdgesInternal(copy, 0, (p.width-1)/2, 0, p.height, numEdges);
-    } else if (p.symmetry == Puzzle::Symmetry::Y) {
-        for (int x=0; x<p.width; x++) {
-            copy.grid[x][p.height/2].gap = Cell::Gap::FULL;
-        }
-        return CutEdgesInternal(copy, 0, p.width, 0, (p.height-1)/2, numEdges);
-    } else {
-        assert(p.symmetry == Puzzle::Symmetry::XY);
-        int midX = p.width/2;
-        int midY = p.height/2;
-        if (p.width%4 == 1 && p.height%4 == 1) { // For double-even grids, cut around the center
-            copy.grid[midX-1][midY].gap = Cell::Gap::FULL;
-            copy.grid[midX][midY-1].gap = Cell::Gap::FULL;
-            copy.grid[midX][midY+1].gap = Cell::Gap::FULL;
-            copy.grid[midX+1][midY].gap = Cell::Gap::FULL;
-        } else if (p.width%4 == 1 && p.height%4 == 3) { // For half-even grids, there's only one line to cut
-            copy.grid[midX][midY].gap = Cell::Gap::FULL;
-        } else if (p.width%4 == 3 && p.height%4 == 1) { // For half-even grids, there's only one line to cut
-            copy.grid[midX][midY].gap = Cell::Gap::FULL;
-        }
-        return CutEdgesInternal(copy, 0, p.width, 0, p.height, numEdges);
-    }
-}
-
-std::vector<Pos> Randomizer2Core::CutEdgesInternal(const Puzzle& p, int xMin, int xMax, int yMin, int yMax, size_t numEdges) {
-    std::vector<Pos> edges;
-    for (int x=xMin; x<xMax; x++) {
-        for (int y=yMin; y<yMax; y++) {
-            if (x%2 == y%2) continue;
-            if (p.grid[x][y].gap != Cell::Gap::NONE) continue;
-            if (p.grid[x][y].start) continue;
-            if (p.grid[x][y].end != Cell::Dir::NONE) continue;
-
-            if (p.symmetry == Puzzle::Symmetry::XY) {
-                assert(p.width == p.height); // TODO: This solution only supports square rotational symmetry.
-                if (x > y) continue; // Only allow cuts bottom-left of the diagonal
-            }
-
-            // If the puzzle already has a sequence, don't cut along it.
-            bool inSequence = false;
-            for (Pos pos : p.sequence) inSequence |= (pos.x == x && pos.y == y);
-            if (inSequence) continue;
-            edges.emplace_back(x, y);
-        }
-    }
-    assert(numEdges <= edges.size());
-
-    auto [colorGrid, numColors] = CreateColorGrid(p);
-    assert(numEdges <= numColors);
-
-    // @Hack... sort of. I couldn't think of a better way to do this.
-    if (p.symmetry == Puzzle::Symmetry::XY) {
-        // Recolor the diagonal so that opposite cells share a color. This is because we're only cutting along half their edges,
-        // so they are in fact two sides of the same cell.
-        for (int x=1; x<p.width/2; x+=2) {
-            assert(p.width == p.height); // TODO: This solution only supports square rotational symmetry.
-            colorGrid[x][x] = colorGrid[p.width-x-1][p.width-x-1];
-        }
-    }
-
-    std::vector<Pos> cutEdges;
-    for (int i=0; i<numEdges; i++) {
-        while (edges.size() > 0) {
-            int edge = Random::RandInt(0, static_cast<int>(edges.size() - 1));
-            Pos pos = edges[edge];
-            edges.erase(edges.begin() + edge);
-
-            int color1 = 0;
-            int color2 = 0;
-            if (pos.x%2 == 0 && pos.y%2 == 1) { // Vertical
-                if (pos.x > 0) color1 = colorGrid[pos.x-1][pos.y];
-                else color1 = 1;
-
-                if (pos.x < p.width - 1) color2 = colorGrid[pos.x+1][pos.y];
-                else color2 = 1;
-            } else { // Horizontal
-                assert(pos.x%2 == 1 && pos.y%2 == 0);
-                if (pos.y > 0) color1 = colorGrid[pos.x][pos.y-1];
-                else color1 = 1;
-
-                if (pos.y < p.height - 1) color2 = colorGrid[pos.x][pos.y+1];
-                else color2 = 1;
-            }
-            // Enforce color1 < color2
-            if (color1 > color2) std::swap(color1, color2);
-
-            // Colors mismatch, valid cut
-            if (color1 != color2) {
-                // @Performance... have a lookup table instead?
-                for (int x=0; x<p.width; x++) {
-                    for (int y=0; y<p.height; y++) {
-                        if (colorGrid[x][y] == color2) colorGrid[x][y] = color1;
-                    }
-                }
-                cutEdges.emplace_back(pos);
-                break;
-            }
-        }
-    }
-    assert(cutEdges.size() == numEdges);
-    return cutEdges;
-}
-
-#ifndef NDEBUG
-#include <Windows.h>
-#endif
-
-void Randomizer2Core::DebugColorGrid(const std::vector<std::vector<int>>& colorGrid) {
-#ifndef NDEBUG
-    static std::string colors = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-    for (int y=0; y<colorGrid[0].size(); y++) {
-        std::string row;
-        for (int x=0; x<colorGrid.size(); x++) {
-            row += colors[colorGrid[x][y]];
-        }
-        row += "\n";
-        OutputDebugStringA(row.c_str());
-    }
-    OutputDebugStringA("\n");
-#endif
-}
-
-void Randomizer2Core::FloodFill(const Puzzle& p, std::vector<std::vector<int>>& colorGrid, int color, int x, int y) {
-    if (!p.SafeCell(x, y)) return;
-    if (colorGrid[x][y] != 0) return; // Already processed.
-    colorGrid[x][y] = color;
-
-    FloodFill(p, colorGrid, color, x, y+1);
-    FloodFill(p, colorGrid, color, x, y-1);
-    FloodFill(p, colorGrid, color, x+1, y);
-    FloodFill(p, colorGrid, color, x-1, y);
-}
-
-void Randomizer2Core::FloodFillOutside(const Puzzle& p, std::vector<std::vector<int>>& colorGrid, int x, int y) {
-    if (!p.SafeCell(x, y)) return;
-    if (colorGrid[x][y] != 0) return; // Already processed.
-    if (x%2 != y%2 && p.grid[x][y].gap == Cell::Gap::NONE) return; // Only flood-fill through gaps
-    colorGrid[x][y] = 1; // Outside color
-
-    FloodFillOutside(p, colorGrid, x, y+1);
-    FloodFillOutside(p, colorGrid, x, y-1);
-    FloodFillOutside(p, colorGrid, x+1, y);
-    FloodFillOutside(p, colorGrid, x-1, y);
-}
-
-// Color key:
-// 0 (default): Uncolored
-// 1: Outside color and separator color
-// 2+: Flood-filled region color
-std::tuple<std::vector<std::vector<int>>, int> Randomizer2Core::CreateColorGrid(const Puzzle& p) {
-    std::vector<std::vector<int>> colorGrid;
-    colorGrid.resize(p.width);
-
-    for (int x=0; x<p.width; x++) {
-        colorGrid[x].resize(p.height);
-        for (int y=0; y<p.height; y++) {
-            if (x%2 == 1 && y%2 == 1) continue;
-            // Mark all unbroken edges and intersections as 'do not color'
-            if (p.grid[x][y].gap == Cell::Gap::NONE) colorGrid[x][y] = 1;
-        }
-    }
-
-    // @Future: Skip this loop if pillar = true;
-    for (int y=0; y<p.height; y++) {
-        FloodFillOutside(p, colorGrid, 0, y);
-        FloodFillOutside(p, colorGrid, p.width - 1, y);
-    }
-
-    for (int x=0; x<p.width; x++) {
-        FloodFillOutside(p, colorGrid, x, 0);
-        FloodFillOutside(p, colorGrid, x, p.height - 1);
-    }
-
-    int color = 1;
-    for (int x=0; x<p.width; x++) {
-        for (int y=0; y<p.height; y++) {
-            if (colorGrid[x][y] != 0) continue; // No dead colors
-            color++;
-            FloodFill(p, colorGrid, color, x, y);
-        }
-    }
-
-    return {colorGrid, color};
-}
\ No newline at end of file
@@ -1,17 +0,0 @@
-#pragma once
-
-class Randomizer2Core {
-public:
-    // CAUTION: These do not actually cut edges, they just returns a list of suggested cuts.
-    static std::vector<Pos> CutEdges(const Puzzle& p, size_t numEdges);
-    static std::vector<Pos> CutInsideEdges(const Puzzle& p, size_t numEdges);
-    static std::vector<Pos> CutSymmetricalEdgePairs(const Puzzle& p, size_t numEdges);
-
-private:
-    static std::vector<Pos> CutEdgesInternal(const Puzzle& p, int xMin, int xMax, int yMin, int yMax, size_t numEdges);
-    static void DebugColorGrid(const std::vector<std::vector<int>>& colorGrid);
-    static void FloodFill(const Puzzle& p, std::vector<std::vector<int>>& colorGrid, int color, int x, int y);
-    static void FloodFillOutside(const Puzzle& p, std::vector<std::vector<int>>& colorGrid, int x, int y);
-    static std::tuple<std::vector<std::vector<int>>, int> CreateColorGrid(const Puzzle& p);
-};
-
@@ -1,76 +0,0 @@
-#include "pch.h"
-#include "Solver.h"
-#include "Validator.h"
-
-int Solver::MAX_SOLUTIONS = 10000;
-
-std::vector<Puzzle> Solver::Solve(Puzzle& p) {
-    std::vector<Puzzle> solutions;
-    // var start = (new Date()).getTime()
-    for (int x = 0; x < p.width; x++) {
-        for (int y = 0; y < p.height; y++) {
-            Cell cell = p.grid[x][y];
-            if (cell.start) {
-                SolveLoop(p, x, y, solutions);
-            }
-        }
-    }
-    // var end = (new Date()).getTime()
-    // console.info('Solved', puzzle, 'in', (end-start)/1000, 'seconds')
-    return solutions;
-}
-
-void Solver::SolveLoop(Puzzle& p, int x, int y, std::vector<Puzzle>& solutions) {
-    // Stop trying to solve once we reach our goal
-    if (solutions.size() >= MAX_SOLUTIONS) return;
-    Cell cell = p.GetCell(x, y);
-    if (cell.undefined) return;
-    if (cell.gap != Cell::Gap::NONE) return;
-
-    if (p.symmetry == Puzzle::Symmetry::NONE) {
-        if (cell.color != Cell::Color::NONE) return; // Collided with ourselves
-        p.grid[x][y].color = Cell::Color::BLACK; // Otherwise, mark this cell as visited
-    } else {
-        // Get the symmetrical position, and try coloring it
-        auto sym = p.GetSymmetricalPos(x, y);
-        Cell::Color oldColor = p.GetLine(sym.x, sym.y);
-        p.grid[sym.x][sym.y].color = Cell::Color::YELLOW;
-
-        // Collided with ourselves or our reflection
-        if (cell.color != Cell::Color::NONE) {
-            p.grid[sym.x][sym.y].color = oldColor;
-            return;
-        }
-        p.grid[x][y].color = Cell::Color::BLUE; // Otherwise, mark this cell as visited
-    }
-    p.sequence.emplace_back(x, y);
-
-    if (cell.end != Cell::Dir::NONE) {
-        // Reached an endpoint, validate solution and keep going -- there may be other endpoints
-        Validator::Validate(p);
-        if (p.valid) {
-            Puzzle clone = p;
-            solutions.push_back(clone);
-        }
-    }
-
-    // Recursion order (LRUD) is optimized for BL->TR and mid-start puzzles
-    // Extend path left and right
-    if (y % 2 == 0) {
-        SolveLoop(p, x - 1, y, solutions);
-        SolveLoop(p, x + 1, y, solutions);
-    }
-    // Extend path up and down
-    if (x % 2 == 0) {
-        SolveLoop(p, x, y - 1, solutions);
-        SolveLoop(p, x, y + 1, solutions);
-    }
-
-    // Tail recursion: Back out of this cell
-    p.grid[x][y].color = Cell::Color::NONE;
-    p.sequence.pop_back();
-    if (p.symmetry != Puzzle::Symmetry::NONE) {
-        auto sym = p.GetSymmetricalPos(x, y);
-        p.grid[sym.x][sym.y].color = Cell::Color::NONE;
-    }
-}
@@ -1,13 +0,0 @@
-#pragma once
-#include <vector>
-
-class Puzzle;
-class Solver {
-public:
-    static int MAX_SOLUTIONS;
-    static std::vector<Puzzle> Solve(Puzzle& p);
-
-private:
-    static void SolveLoop(Puzzle& p, int x, int y, std::vector<Puzzle>& solutions);
-};
-
@@ -161,7 +161,6 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <ClInclude Include="ChallengeRandomizer.h" />
     <ClInclude Include="json.hpp" />
     <ClInclude Include="Memory.h" />
     <ClInclude Include="MemoryException.h" />
@@ -172,13 +171,8 @@
     <ClInclude Include="PuzzleSerializer.h" />
     <ClInclude Include="Random.h" />
     <ClInclude Include="Randomizer.h" />
-    <ClInclude Include="Randomizer2.h" />
-    <ClInclude Include="Randomizer2Core.h" />
-    <ClInclude Include="Solver.h" />
-    <ClInclude Include="Validator.h" />
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="ChallengeRandomizer.cpp" />
     <ClCompile Include="Memory.cpp" />
     <ClCompile Include="pch.cpp">
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
@@ -190,10 +184,6 @@
     <ClCompile Include="PuzzleSerializer.cpp" />
     <ClCompile Include="Random.cpp" />
     <ClCompile Include="Randomizer.cpp" />
-    <ClCompile Include="Randomizer2.cpp" />
-    <ClCompile Include="Randomizer2Core.cpp" />
-    <ClCompile Include="Solver.cpp" />
-    <ClCompile Include="Validator.cpp" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
@@ -1,97 +0,0 @@
-#include "pch.h"
-#include "Validator.h"
-
-void Validator::Validate(Puzzle& p) {
-    // console.log('Validating', puzzle);
-    p.valid = true; // Assume valid until we find an invalid element
-    p.invalidElements.clear();
-    p.negations.clear();
-
-    bool puzzleHasSymbols = false;
-    bool puzzleHasStart = false;
-    bool puzzleHasEnd = false;
-    // Validate gap failures as an early exit.
-    for (int x = 0; x < p.width; x++) {
-        for (int y = 0; y < p.height; y++) {
-            const Cell& cell = p.grid[x][y];
-            const auto& decoration = cell.decoration;
-            if (decoration) {
-                if (decoration->type == Type::Stone ||
-                    decoration->type == Type::Star ||
-                    decoration->type == Type::Nega ||
-                    decoration->type == Type::Poly ||
-                    decoration->type == Type::Ylop) {
-                    puzzleHasSymbols = true;
-                    continue;
-                }
-                if (decoration->type == Type::Triangle) {
-                    int actualCount = 0;
-                    if (p.GetLine(x - 1, y) != Cell::Color::NONE) actualCount++;
-                    if (p.GetLine(x + 1, y) != Cell::Color::NONE) actualCount++;
-                    if (p.GetLine(x, y - 1) != Cell::Color::NONE) actualCount++;
-                    if (p.GetLine(x, y + 1) != Cell::Color::NONE) actualCount++;
-                    if (decoration->count != actualCount) {
-                        // console.log('Triangle at grid['+x+']['+y+'] has', actualCount, 'borders')
-                        p.invalidElements.emplace_back(x, y);
-                    }
-                }
-            }
-            if (cell.gap != Cell::Gap::NONE && cell.color != Cell::Color::NONE) {
-                // console.log('Gap at', x, y, 'is covered')
-                p.valid = false;
-            }
-            if (cell.dot != Cell::Dot::NONE) {
-                if (cell.color == Cell::Color::NONE) {
-                    // console.log('Dot at', x, y, 'is not covered')
-                    p.invalidElements.emplace_back(x, y);
-                } else if (cell.color == Cell::Color::BLUE && cell.dot == Cell::Dot::YELLOW) {
-                    // console.log('Yellow dot at', x, y, 'is covered by blue line')
-                    p.valid = false;
-                } else if (cell.color == Cell::Color::YELLOW && cell.dot == Cell::Dot::BLUE) {
-                    // console.log('Blue dot at', x, y, 'is covered by yellow line')
-                    p.valid = false;
-                }
-            }
-            if (cell.color != Cell::Color::NONE) {
-                if (cell.start == true) puzzleHasStart = true;
-                if (cell.end != Cell::Dir::NONE) puzzleHasEnd = true;
-            }
-        }
-    }
-    if (!puzzleHasStart || !puzzleHasEnd) {
-        // console.log('There is no covered start or endpoint')
-        p.valid = false;
-    }
-
-    // Perf optimization: We can skip computing regions if the grid has no symbols.
-    if (!puzzleHasSymbols) { // No additional symbols, and we already checked dots & gaps
-        p.valid &= (p.invalidElements.size() == 0);
-    } else { // Additional symbols, so we need to discard dots & divide them by region
-        /*
-        p.invalidElements.clear();
-        std::vector<Region> regions = p.GetRegions();
-        // console.log('Found', regions.length, 'regions');
-        // console.debug(regions);
-
-        for (const Region& region : regions) {
-          std::string key = region.grid.ToString();
-          auto regionData = puzzle.regionCache[key];
-          if (regionData == undefined) {
-            console.log('Cache miss for region', region, 'key', key);
-            regionData = _regionCheckNegations(puzzle, region);
-            // Entirely for convenience
-            regionData.valid = (regionData.invalidElements.size() == 0)
-            // console.log('Region valid:', regionData.valid);
-
-            if (!DISABLE_CACHE) {
-              p.regionCache[key] = regionData;
-            }
-          }
-          p.negations = p.negations.concat(regionData.negations);
-          p.invalidElements = p.invalidElements.concat(regionData.invalidElements);
-          p.valid = p.valid && regionData.valid;
-        }
-        */
-    }
-    // console.log('Puzzle has', puzzle.invalidElements.length, 'invalid elements')
-}
@@ -1,27 +0,0 @@
-#pragma once
-#include <vector>
-#include <tuple>
-
-#ifndef NEGATIONS_CANCEL_NEGATIONS
-#define NEGATIONS_CANCEL_NEGATIONS true
-#endif
-
-#ifndef SIMPLE_POLYOMINOS
-#define SIMPLE_POLYOMINOS true
-#endif
-
-#ifndef DISABLE_CACHE
-#define DISABLE_CACHE false
-#endif
-
-struct Region{};
-class Puzzle;
-struct Pos;
-class Validator {
-public:
-    static void Validate(Puzzle& p);
-
-private:
-    static void RegionCheckNegations(Puzzle& p, const Region& r);
-    static std::vector<Pos> RegionCheck(Puzzle& p, const Region& r);
-};
@@ -12,18 +12,6 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Source", "Source\Source.vcx
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Test", "Test\Test.vcxproj", "{128784C2-9157-4291-8FD6-44637BE162FB}"
 EndProject
-Project("{54435603-DBB4-11D2-8724-00A0C9A8B90C}") = "Installer", "Installer\Installer.vdproj", "{F1B9D251-3DCC-4B19-A5C9-CA23AFD38632}"
-        ProjectSection(ProjectDependencies) = postProject
-                {6B5DF051-A51A-48CB-8ACD-C6FAD726019F} = {6B5DF051-A51A-48CB-8ACD-C6FAD726019F}
-                {5A4E859A-9756-463E-86E6-6EADBBA23021} = {5A4E859A-9756-463E-86E6-6EADBBA23021}
-                {235D27F1-9907-489B-8D58-636A0C5CD079} = {235D27F1-9907-489B-8D58-636A0C5CD079}
-        EndProjectSection
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "App2", "App2\App2.vcxproj", "{5A4E859A-9756-463E-86E6-6EADBBA23021}"
-        ProjectSection(ProjectDependencies) = postProject
-                {6B5DF051-A51A-48CB-8ACD-C6FAD726019F} = {6B5DF051-A51A-48CB-8ACD-C6FAD726019F}
-        EndProjectSection
-EndProject
 Global
         GlobalSection(SolutionConfigurationPlatforms) = preSolution
                 Debug|x64 = Debug|x64
@@ -56,19 +44,6 @@ Global
                 {128784C2-9157-4291-8FD6-44637BE162FB}.Release|x64.Build.0 = Release|x64
                 {128784C2-9157-4291-8FD6-44637BE162FB}.Release|x86.ActiveCfg = Debug|x64
                 {128784C2-9157-4291-8FD6-44637BE162FB}.Release|x86.Build.0 = Debug|x64
-                {F1B9D251-3DCC-4B19-A5C9-CA23AFD38632}.Debug|x64.ActiveCfg = Debug
-                {F1B9D251-3DCC-4B19-A5C9-CA23AFD38632}.Debug|x64.Build.0 = Debug
-                {F1B9D251-3DCC-4B19-A5C9-CA23AFD38632}.Debug|x86.ActiveCfg = Debug
-                {F1B9D251-3DCC-4B19-A5C9-CA23AFD38632}.Release|x64.ActiveCfg = Release
-                {F1B9D251-3DCC-4B19-A5C9-CA23AFD38632}.Release|x86.ActiveCfg = Release
-                {5A4E859A-9756-463E-86E6-6EADBBA23021}.Debug|x64.ActiveCfg = Debug|x64
-                {5A4E859A-9756-463E-86E6-6EADBBA23021}.Debug|x64.Build.0 = Debug|x64
-                {5A4E859A-9756-463E-86E6-6EADBBA23021}.Debug|x86.ActiveCfg = Debug|Win32
-                {5A4E859A-9756-463E-86E6-6EADBBA23021}.Debug|x86.Build.0 = Debug|Win32
-                {5A4E859A-9756-463E-86E6-6EADBBA23021}.Release|x64.ActiveCfg = Release|x64
-                {5A4E859A-9756-463E-86E6-6EADBBA23021}.Release|x64.Build.0 = Release|x64
-                {5A4E859A-9756-463E-86E6-6EADBBA23021}.Release|x86.ActiveCfg = Release|Win32
-                {5A4E859A-9756-463E-86E6-6EADBBA23021}.Release|x86.Build.0 = Release|Win32
         EndGlobalSection
         GlobalSection(SolutionProperties) = preSolution
                 HideSolutionNode = FALSE