Keep WIP

6 files changed, 371 insertions, 150 deletions

@@ -170,7 +170,10 @@ void* Memory::ComputeOffset(std::vector<int> offsets) {
                 cumulativeAddress += offset;
 
                 const auto search = _computedAddresses.find(cumulativeAddress);
-                if (search == std::end(_computedAddresses)) {
+        // This is an issue with re-randomization. Always. Just disable it in debug mode!
+#ifdef NDEBUG
+            if (search == std::end(_computedAddresses)) {
+#endif
                         // If the address is not yet computed, then compute it.
                         uintptr_t computedAddress = 0;
                         if (bool result = !ReadProcessMemory(_handle, reinterpret_cast<LPVOID>(cumulativeAddress), &computedAddress, sizeof(uintptr_t), NULL)) {
@@ -180,7 +183,9 @@ void* Memory::ComputeOffset(std::vector<int> offsets) {
                 ThrowError();
             }
                         _computedAddresses[cumulativeAddress] = computedAddress;
+#ifdef NDEBUG
                 }
+#endif
 
                 cumulativeAddress = _computedAddresses[cumulativeAddress];
         }
@@ -188,6 +193,21 @@ void* Memory::ComputeOffset(std::vector<int> offsets) {
 }
 
 uintptr_t Memory::Allocate(size_t bytes) {
+/*
+uintptr_t ForeignProcessMemory::AllocateMemory(size_t Size, DWORD Flags) const {
+    if (!ProcessHandle) {
+        return 0;
+    }
+    return (uintptr_t)VirtualAllocEx(ProcessHandle, nullptr, Size, MEM_RESERVE | MEM_COMMIT, Flags);
+}
+
+void ForeignProcessMemory::DeallocateMemory(uintptr_t Addr) const {
+    if (!ProcessHandle || Addr == 0) {
+        return;
+    }
+    VirtualFreeEx(ProcessHandle, (void*)Addr, 0, MEM_RELEASE);
+}
+*/
     uintptr_t current = _freeMem;
     _freeMem += bytes;
 
@@ -41,6 +41,8 @@ void PuzzleSerializer::WritePuzzle(const Puzzle& p, int id) {
     VERTI_GAP_SIZE = HEIGHT_INTERVAL / 2;
 
         WriteIntersections(p);
+    WriteDots(p);
+    WriteGaps(p);
     WriteEndpoints(p);
     WriteDecorations(p, id);
     WriteSequence(p, id);
@@ -3,6 +3,7 @@
 #include "Random.h"
 #include "Solver.h"
 #include "Memory.h"
+#include "Randomizer2Core.h"
 #include "PuzzlerSerializer.h"
 #include <cassert>
 #include <string>
@@ -155,173 +156,184 @@ void Randomizer2::Randomize() {
 
 }
 
-void DebugColorGrid(const std::vector<std::vector<int>>& colorGrid) {
-    for (int y=0; y<colorGrid[0].size(); y++) {
-        std::wstring row;
-        for (int x=0; x<colorGrid.size(); x++) {
-            row += std::to_wstring(colorGrid[x][y]);
+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::CutEdgesToBeUnique(p);
+        assert(cutEdges.size() == 5);
+        Puzzle copy = p;
+        std::vector<int> gates = {0x00344, 0x00488,  0x00489, 0x00495, 0x00496};
+        for (int i=0; i<gates.size(); i++) {
+            Pos pos = cutEdges[i];
+            copy.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
+            SetGate(gates[i], pos.x, pos.y);
         }
-        row += L'\n';
-        OutputDebugString(row.c_str());
+        auto solutions = Solver::Solve(copy);
+        assert(solutions.size() == 1);
+        p.sequence = solutions[0].sequence;
+        PuzzleSerializer(_memory).WritePuzzle(solutions[0], 0x139);
     }
-    OutputDebugString(L"\n");
-}
-
-void 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 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::FULL) return; // Only flood-fill through full 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);
-}
+    // *** Hedges 2 ***
+    {
+        Puzzle p;
+        p.NewGrid(4, 4);
 
-/*
-    undefined -> 1 (color of outside) or * (any colored cell) or -1 (edge/intersection not part of any region)
+        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;
 
-    0 -> {} (this is a special edge case, which I don't need right now)
-    1 -> 0 (uncolored / ready to color)
-    2 -> 
-*/
-std::vector<std::vector<int>> CreateColorGrid(const Puzzle& p) {
-    std::vector<std::vector<int>> colorGrid;
-    colorGrid.resize(p.width);
+        p.grid[0][8].start = true;
+        p.grid[8][0].end = Cell::Dir::RIGHT;
 
-    for (int x=0; x<p.width; x++) {
-        colorGrid[x].resize(p.height);
-        for (int y=0; y<p.height; y++) {
-            // Mark all unbroken edges and intersections as 'do not color'
-            if (x%2 != y%2) {
-                if (p.grid[x][y].gap == Cell::Gap::NONE) colorGrid[x][y] = 1;
-            } else if (x%2 == 0 && y%2 == 0) {
-                // @Future: What about empty intersections?
-                colorGrid[x][y] = 1; // do not color intersections
-            }
+        std::vector<Pos> cutEdges = Randomizer2Core::CutEdgesToBeUnique(p);
+        assert(cutEdges.size() == 7);
+        for (Pos pos : cutEdges) {
+            p.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
+        }
+        auto solutions = Solver::Solve(p);
+        assert(solutions.size() == 1);
+
+        Puzzle q;
+        q.NewGrid(4, 4);
+        q.grid[0][8].start = true;
+        q.grid[8][0].end = Cell::Dir::RIGHT;
+        q.sequence = solutions[0].sequence;
+        for (Pos pos : cutEdges) {
+            q.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
         }
+        // Cut to 4 of 9 additional edges (total: 11)
+        Randomizer2Core::CutEdgesNotOutsideNotBreakingSequence(q, 4);
+        PuzzleSerializer(_memory).WritePuzzle(q, 0x19DC);
     }
+    
+    // *** Hedges 3 **
+    {
+        std::vector<int> audioMarkers = {
+            0x000034a9,
+            0x000034b1,
+            0x000034be,
+            0x000034c4,
+            0x000034cb,
+            0x000034cc,
+            0x000034cd,
+            0x000034ce,
+            0x000034df,
+            0x000034e0,
+            0x000034e1,
+            0x000034e2,
+            0x000034f3,
+            0x000131cb,
+            0x00017e34,
+            0x00017e6f,
+            0x00017e76,
+            0x00017e77,
+            0x00017e7a,
+            0x00017e7e,
+            0x00017e8b,
+            0x00017e8d,
+            0x00017eb5,
+            0x000394a4,
+            0x0003b54e,
+        };
+        std::vector<int> good;
+        for (int marker : audioMarkers) {
+            // std::vector<char> assetName = _memory->ReadArray<char>(marker, 0xD8, 100);
+            std::vector<char> name = {'m', 'a', 'z', 'e', '_', 'p', 'e', 'b', 'b', 'l', 'e', '\0'};
+            _memory->WriteNewArray(marker, 0xD8, name);
+        }
 
-    // @Future: Skip this loop if pillar = true;
-    for (int y=1; y<p.height; y+=2) {
-        FloodFillOutside(p, colorGrid, 0, y);
-        FloodFillOutside(p, colorGrid, p.width - 1, y);
-    }
+        Puzzle p;
+        p.NewGrid(4, 4);
 
-    for (int x=1; x<p.width; x+=2) {
-        FloodFillOutside(p, colorGrid, x, 0);
-        FloodFillOutside(p, colorGrid, x, p.height - 1);
-    }
+        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;
 
-    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);
+        p.grid[0][8].start = true;
+        p.grid[8][2].end = Cell::Dir::RIGHT;
+
+        std::vector<Pos> cutEdges = Randomizer2Core::CutEdgesToBeUnique(p);
+        assert(cutEdges.size() == 7);
+        for (Pos pos : cutEdges) {
+            p.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
         }
+        PuzzleSerializer(_memory).WritePuzzle(p, 0x19E7);
     }
 
-    return colorGrid;
-}
+    // *** Hedges 4 ***
+    {
+        Puzzle p;
+        p.NewGrid(4, 4);
 
-void Randomizer2::RandomizeKeep() {
-    Puzzle p;
-    p.NewGrid(4, 4);
-    // p.width = 9;
-    // p.height = 10;
-    // p.grid.clear();
-    // p.grid.resize(p.width);
-    // for (int x=0; x<p.width; x++) p.grid[x].resize(p.height);
-
-    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[0][9].gap = Cell::Gap::FULL;
-    // p.grid[2][9].gap = Cell::Gap::FULL;
-    // p.grid[6][9].gap = Cell::Gap::FULL;
-    // p.grid[8][9].gap = Cell::Gap::FULL;
-
-    p.grid[6][0].end = Cell::Dir::UP;
-    p.grid[4][8].start = true;
-
-    auto colorGrid = CreateColorGrid(p);
-
-    std::vector<Pos> edges;
-    for (int x=0; x<p.width; x++) {
-        for (int y=0; y<p.height; y++) {
-            if (x%2 == y%2) continue;
-            if (p.grid[x][y].gap != Cell::Gap::NONE) continue;
-            edges.emplace_back(Pos{x, y});
-        }
-    }
+        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;
 
-    Puzzle copy = p;
-    std::vector<int> gates = {0x00344, 0x00488,  0x00489, 0x00495, 0x00496};
-    for (int i=0; i<5; i++) {
-        for (int j=0; j<edges.size(); j++) {
-            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;
-                    }
-                }
-                copy.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
-                SetGate(gates[i], pos.x, pos.y);
-                break;
-            }
+        p.grid[0][8].start = true;
+        p.grid[4][0].end = Cell::Dir::UP;
+
+        std::vector<Pos> cutEdges = Randomizer2Core::CutEdgesToBeUnique(p);
+        assert(cutEdges.size() == 2);
+        for (Pos pos : cutEdges) {
+            p.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
         }
+        auto solutions = Solver::Solve(p);
+        assert(solutions.size() == 1);
+
+        Puzzle q;
+        q.NewGrid(4, 4);
+        q.grid[0][8].start = true;
+        q.grid[4][0].end = Cell::Dir::UP;
+        q.sequence = solutions[0].sequence;
+        for (Pos pos : cutEdges) {
+            q.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
+        }
+        // 9 cuts, -2 from existing cuts
+        Randomizer2Core::CutEdgesNotOutsideNotBreakingSequence(q, 7);
+        PuzzleSerializer(_memory).WritePuzzle(q, 0x1A0F);
     }
-
-    auto solutions = Solver::Solve(copy);
-    assert(solutions.size() == 1);
-    p.sequence = solutions[0].sequence;
-    PuzzleSerializer(_memory).WritePuzzle(solutions[0], 0x139);
 }
 
 void Randomizer2::SetGate(int panel, int X, int Y) {
@@ -0,0 +1,164 @@
+#include "Randomizer2Core.h"
+#include "Puzzle.h"
+#include "Random.h"
+
+#include <string>
+#include <iostream>
+#include <cassert>
+
+std::vector<Pos> Randomizer2Core::CutEdgesToBeUnique(const Puzzle& p) {
+    auto [colorGrid, numColors] = CreateColorGrid(p);
+    std::vector<Pos> edges;
+    for (int x=0; x<p.width; x++) {
+        for (int y=0; y<p.height; y++) {
+            if (x%2 == y%2) continue;
+            if (p.grid[x][y].gap != Cell::Gap::NONE) continue;
+            edges.emplace_back(Pos{x, y});
+        }
+    }
+    return CutEdgesInternal(p, colorGrid, edges, numColors);
+}
+
+void Randomizer2Core::CutEdgesNotOutsideNotBreakingSequence(Puzzle& p, size_t numEdges) {
+    auto [colorGrid, numColors] = CreateColorGrid(p);
+    assert(numEdges <= numColors);
+    std::vector<Pos> edges;
+    for (int x=1; x<p.width-1; x++) {
+        for (int y=1; y<p.height-1; y++) {
+            if (x%2 == y%2) continue;
+            if (p.grid[x][y].gap != Cell::Gap::NONE) continue;
+            bool inSequence = false;
+            for (Pos pos : p.sequence) inSequence |= (pos.x == x && pos.y == y);
+            if (inSequence) continue;
+            edges.emplace_back(Pos{x, y});
+        }
+    }
+    std::vector<Pos> cutEdges = CutEdgesInternal(p, colorGrid, edges, numEdges);
+    for (Pos pos : cutEdges) {
+        p.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
+    }
+}
+
+std::vector<Pos> Randomizer2Core::CutEdgesInternal(const Puzzle& p, std::vector<std::vector<int>>& colorGrid, std::vector<Pos>& edges, size_t numEdges) {
+    std::vector<Pos> cutEdges;
+    for (int i=0; i<numEdges; i++) {
+        for (int j=0; j<edges.size(); j++) {
+            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;
+            }
+        }
+    }
+    return cutEdges;
+}
+
+void Randomizer2Core::DebugColorGrid(const std::vector<std::vector<int>>& colorGrid) {
+    for (int y=0; y<colorGrid[0].size(); y++) {
+        std::string row;
+        for (int x=0; x<colorGrid.size(); x++) {
+            row += std::to_string(colorGrid[x][y]);
+        }
+        std::cerr << row << std::endl;
+    }
+    std::cerr << std::endl;
+}
+
+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::FULL) return; // Only flood-fill through full 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);
+}
+
+/*
+    undefined -> 1 (color of outside) or * (any colored cell) or -1 (edge/intersection not part of any region)
+
+    0 -> {} (this is a special edge case, which I don't need right now)
+    1 -> 0 (uncolored / ready to color)
+    2 -> 
+*/
+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++) {
+            // Mark all unbroken edges and intersections as 'do not color'
+            if (x%2 != y%2) {
+                if (p.grid[x][y].gap == Cell::Gap::NONE) colorGrid[x][y] = 1;
+            } else if (x%2 == 0 && y%2 == 0) {
+                // @Future: What about empty intersections?
+                colorGrid[x][y] = 1; // do not color intersections
+            }
+        }
+    }
+
+    // @Future: Skip this loop if pillar = true;
+    for (int y=1; y<p.height; y+=2) {
+        FloodFillOutside(p, colorGrid, 0, y);
+        FloodFillOutside(p, colorGrid, p.width - 1, y);
+    }
+
+    for (int x=1; x<p.width; x+=2) {
+        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
@@ -0,0 +1,21 @@
+#pragma once
+#include <vector>
+
+struct Pos;
+class Puzzle;
+
+class Randomizer2Core {
+public:
+    // CAUTION: Does not actually cut edges, just returns a list of suggested cuts.
+    // Cuts a number of edges equal to the number of colors in the color grid.
+    static std::vector<Pos> CutEdgesToBeUnique(const Puzzle& p);
+    static void CutEdgesNotOutsideNotBreakingSequence(Puzzle& p, size_t numEdges);
+
+private:
+    static std::vector<Pos> CutEdgesInternal(const Puzzle& p, std::vector<std::vector<int>>& colorGrid, std::vector<Pos>& edges, 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);
+};
+
@@ -165,6 +165,7 @@
     <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>
@@ -176,6 +177,7 @@
     <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>