Souped up the UI

5 files changed, 0 insertions, 887 deletions

@@ -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);
-};
-
@@ -172,8 +172,6 @@
     <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>
@@ -190,8 +188,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>