Simplified / added two more

3 files changed, 53 insertions, 11 deletions

@@ -157,17 +157,20 @@ void PuzzleSerializer::ReadExtras(Puzzle& p) {
             // Note that Y coordinates are reversed: 0.0 (bottom) 1.0 (top)
             else if (y1 < y2) p.grid[x][y].end = Cell::Dir::DOWN;
             else if (y1 > y2) p.grid[x][y].end = Cell::Dir::UP;
+            else assert(false);
         } else if (_intersectionFlags[i] & Flags::HAS_DOT) {
                  if (x1 < x2) x--;
             else if (x1 > x2) x++;
             else if (y1 < y2) y++;
             else if (y1 > y2) y--;
+            else assert(false);
             p.grid[x][y].dot = FlagsToDot(_intersectionFlags[i]);
         } else if (_intersectionFlags[i] & Flags::HAS_ONE_CONN) {
                  if (x1 < x2) x--;
             else if (x1 > x2) x++;
             else if (y1 < y2) y++;
             else if (y1 > y2) y--;
+            else assert(false);
             p.grid[x][y].gap = Cell::Gap::BREAK;
             gapLocations[i] = Pos{x, y};
         }
@@ -208,6 +208,53 @@ void Randomizer2::RandomizeSymmetry() {
 
         _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);
+    }
+    { // 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;
+        }
+
+        _serializer.WritePuzzle(p, 0x5C);
+    }
 }
 
 void Randomizer2::RandomizeKeep() {
@@ -18,17 +18,9 @@ std::vector<Pos> Randomizer2Core::CutSymmetricalEdgePairs(const Puzzle& p, size_
     Puzzle copy = p;
     assert(p.symmetry != Puzzle::Symmetry::NONE);
     if (p.symmetry == Puzzle::Symmetry::X) {
-        if (p.width%4 == 1) {
-            // The puzle has an even width (e.g. 4x4), so it has a midline for symmetry.
-            //  Since this midline is unusable, we cut it pre-emptively.
-            for (int y=0; y<p.height; y++) {
-                copy.grid[p.width/2][y].gap = Cell::Gap::FULL;
-            }
-        } else {
-            // The puzzle has an odd width (e.g. 3x3), but we still need to cut the midline.
-            for (int y=0; y<p.height; y++) {
-                copy.grid[p.width/2][y].gap = Cell::Gap::FULL;
-            }
+        // Prevent cuts from landing on the midline
+        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);