2 files changed, 71 insertions, 5 deletions

@@ -270,14 +270,66 @@ void Randomizer2::RandomizeSymmetry() {
         p.grid[1][6].gap = Cell::Gap::BREAK;
 
         for (Pos pos : Randomizer2Core::CutSymmetricalEdgePairs(p, 1)) {
-            std::string text = std::to_string(pos.x) + " " + std::to_string(pos.y);
-            OutputDebugStringA(text.c_str());
             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[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);
+    }
 }
 
 void Randomizer2::RandomizeKeep() {
@@ -17,15 +17,28 @@ std::vector<Pos> Randomizer2Core::CutSymmetricalEdgePairs(const Puzzle& p, size_
         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);
-        // Pass, I think? Maybe this matters for odd numbers.
+        if (p.width%4 == 1) {
+            assert(p.width == 9);
+            copy.grid[2][3];
+            copy.grid[3][4];
+            copy.grid[3][6];
+            copy.grid[4][3];
+        // For odd grids, cut the center out.
+        // 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, numEdges);
     }
-    return CutEdgesInternal(copy, 0, (p.width-1)/2, 0, p.height, numEdges);
 }
 
 std::vector<Pos> Randomizer2Core::CutEdgesInternal(const Puzzle& p, int xMin, int xMax, int yMin, int yMax, size_t numEdges) {
@@ -36,6 +49,7 @@ std::vector<Pos> Randomizer2Core::CutEdgesInternal(const Puzzle& p, int xMin, in
             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 && 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;
@@ -51,7 +65,7 @@ std::vector<Pos> Randomizer2Core::CutEdgesInternal(const Puzzle& p, int xMin, in
 
     std::vector<Pos> cutEdges;
     for (int i=0; i<numEdges; i++) {
-        for (int j=0; j<edges.size(); j++) {
+        while (edges.size() > 0) {
             int edge = Random::RandInt(0, static_cast<int>(edges.size() - 1));
             Pos pos = edges[edge];
             edges.erase(edges.begin() + edge);