Cleaned up a bunch of stuff I'm not using

9 files changed, 8 insertions, 614 deletions

@@ -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;
-};
@@ -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,14 +123,6 @@ 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));
 
     // Tutorial Bend
     for (int panel : utmPerspective) {
@@ -141,220 +132,23 @@ void Randomizer::Randomize() {
     for (int panel : squarePanels) {
         Tutorialise(panel, 0x00064);
     }
-    //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
-}
-
-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);
-}
 
-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});
-}
-
-// 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});
-}
-
-void Randomizer::RandomizeSymmetry() {
-    /*std::vector<int> randomOrder(transparent.size(), 0);
-    std::iota(randomOrder.begin(), randomOrder.end(), 0);
-    RandomizeRange(randomOrder, SWAP::NONE, 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() {
-}
+    _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::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);
-    RandomizeRange(randomOrder, SWAP::NONE, 0, 8); // Tutorial
-    RandomizeRange(randomOrder, SWAP::NONE, 8, 16); // Avoid
-    RandomizeRange(randomOrder, SWAP::NONE, 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);
-    RandomizeRange(randomOrder, SWAP::NONE, 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);
-    RandomizeRange(randomOrder, SWAP::NONE, 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
-    RandomizeRange(randomOrder, SWAP::NONE, 1, 10);
-    // Randomize Glass 1-3 into everything after the door/glass 1
-    const size_t glass1Index = find(randomOrder, 9);
-    RandomizeRange(randomOrder, SWAP::NONE, 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
-    RandomizeRange(randomOrder, SWAP::NONE, 1, 7); // Waves 2-7
-    RandomizeRange(randomOrder, SWAP::NONE, 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);
-    }
-    targets[5] = pillars[5] + 1;
-
-    std::vector<int> randomOrder(pillars.size(), 0);
-    std::iota(randomOrder.begin(), randomOrder.end(), 0);
-    RandomizeRange(randomOrder, SWAP::NONE, 0, 4); // Left Pillars 1-4
-    RandomizeRange(randomOrder, SWAP::NONE, 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);
-    Randomize(randomOrder, SWAP::NONE);
-    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::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 = 0; i < panels.size(); 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
-        }*/
-        
-    }
+    _memory->WriteEntityData<int>(0x17E52, STYLE_FLAGS, { panelFlags | 0x8000 });
 }
 
 void Randomizer::Tutorialise(int panel1, int tutorialStraight) {
@@ -421,32 +215,3 @@ void Randomizer::Tutorialise(int panel1, int tutorialStraight) {
         //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,42 +4,11 @@ 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 RandomizeRange(std::vector<int> &panels, int flags, size_t startIndex, size_t endIndex);
     void Tutorialise(int panel1, int copyFrom);
-    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);
 
     std::shared_ptr<Memory> _memory;
 
@@ -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,11 +171,8 @@
     <ClInclude Include="PuzzleSerializer.h" />
     <ClInclude Include="Random.h" />
     <ClInclude Include="Randomizer.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>
@@ -188,8 +184,6 @@
     <ClCompile Include="PuzzleSerializer.cpp" />
     <ClCompile Include="Random.cpp" />
     <ClCompile Include="Randomizer.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);
-};