2 files changed, 63 insertions, 22 deletions

@@ -307,15 +307,12 @@ void Randomizer2::RandomizeSymmetry() {
         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;
+        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, 3);
+        std::vector<Pos> cutEdges = Randomizer2Core::CutSymmetricalEdgePairs(p, 7);
         for (int i=0; i<cutEdges.size(); i++) {
             Pos pos = cutEdges[i];
             if (i%2 == 0) {
@@ -326,9 +323,39 @@ void Randomizer2::RandomizeSymmetry() {
             }
         }
 
-        p.grid[1][6].gap = Cell::Gap::NONE;
+        _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;
 
-        _serializer.WritePuzzle(p, 0x81);
+        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
     }
 }
 
@@ -25,17 +25,17 @@ std::vector<Pos> Randomizer2Core::CutSymmetricalEdgePairs(const Puzzle& p, size_
         return CutEdgesInternal(copy, 0, p.width, 0, (p.height-1)/2, numEdges);
     } else {
         assert(p.symmetry == Puzzle::Symmetry::XY);
-        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;
-        // }
-
+        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);
     }
@@ -49,7 +49,11 @@ 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 (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;
@@ -63,6 +67,16 @@ std::vector<Pos> Randomizer2Core::CutEdgesInternal(const Puzzle& p, int xMin, in
     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) {