One down, 522 to go.

7 files changed, 147 insertions, 15 deletions

@@ -7,16 +7,14 @@
 PuzzleSerializer::PuzzleSerializer(const std::shared_ptr<Memory>& memory) : _memory(memory) {}
 
 Puzzle PuzzleSerializer::ReadPuzzle(int id) {
-    Puzzle p;
-    p.width = 2 * _memory->ReadPanelData<int>(id, GRID_SIZE_X, 1)[0] - 1;
-    p.height = 2 * _memory->ReadPanelData<int>(id, GRID_SIZE_Y, 1)[0] - 1;
-    if (p.width < 0 || p.height < 0) return p; // @Error: Grid size should be always positive? Looks like the starting panels break this rule, though.
-    p.grid.resize(p.width);
-        for (auto& row : p.grid) row.resize(p.height);
+    int width = 2 * _memory->ReadPanelData<int>(id, GRID_SIZE_X, 1)[0] - 1;
+    int height = 2 * _memory->ReadPanelData<int>(id, GRID_SIZE_Y, 1)[0] - 1;
+    if (width < 0 || height < 0) return Puzzle(); // @Error: Grid size should be always positive? Looks like the starting panels break this rule, though.
 
+    Puzzle p;
+    p.NewGrid(width, height);
         ReadIntersections(p, id);
         ReadDecorations(p, id);
-
     return p;
 }
 
@@ -37,7 +37,6 @@ struct Decoration {
     int count = 0;
 };
 
-
 struct Cell {
     inline static Cell Undefined() {
         Cell c;
@@ -63,7 +62,9 @@ struct Cell {
 struct Negation {};
 struct Pos {int x; int y;};
 
-struct Puzzle {
+#include <cassert> // TODO: Move this + impl to cpp
+class Puzzle {
+public:
     int16_t height;
     int16_t width;
     bool hasDecorations = false;
@@ -72,6 +73,10 @@ struct Puzzle {
     Symmetry sym = Symmetry::NONE;
     bool pillar = false;
 
+    bool valid;
+    std::vector<Negation> negations;
+    std::vector<Pos> invalidElements;
+
     inline Cell GetCell(int x, int y) const {
         x = Mod(x);
         if (!SafeCell(x, y)) return Cell::Undefined();
@@ -80,13 +85,24 @@ struct Puzzle {
     inline Cell::Color GetLine(int x, int y) const {
         return grid[x][y].color;
     }
+    inline void NewGrid(int newWidth, int newHeight) {
+        if (newWidth == 0) {
+            assert(false);
+            newWidth = width;
+            newHeight = height;
+        } else {
+            // @Cleanup! This should be in the ctor...
+            width = 2*newWidth + 1;
+            height = 2*newHeight + 1;
+        }
+        grid.clear();
+        grid.resize(width);
+        for (int x=0; x<width; x++) grid[x].resize(height);
+    }
+
     // @TODO:
     Pos GetSymmetricalPos(int x, int y);
 
-    bool valid;
-    std::vector<Negation> negations;
-    std::vector<Pos> invalidElements;
-
 // private:
     std::vector<std::vector<Cell>> grid;
 
@@ -0,0 +1,104 @@
+#include "Randomizer2.h"
+#include "Puzzle.h"
+#include "Random.h"
+#include "Solver.h"
+
+Randomizer2::Randomizer2(const std::shared_ptr<Memory>& memory) : _memory(memory) {}
+
+void Randomizer2::Randomize() {
+    // 4x4
+    // 14 gaps
+    // start (x=0, y=8)
+    // end (x=8, y=0) Up
+    // 1 solution
+    Puzzle p;
+    int attemptCount = 0;
+    while (true) {
+        attemptCount++;
+        p.NewGrid(4, 4);
+
+        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 i=0; i<14; i++) {
+            int edge = Random::RandInt(0, static_cast<int>(edges.size() - 1));
+            Pos pos = edges[edge];
+            p.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
+            edges.erase(edges.begin() + edge);
+        }
+
+        p.grid[0][8].start = true;
+        p.grid[8][0].end = Cell::Dir::UP;
+
+        auto solutions = Solver::Solve(p);
+        if (solutions.size() == 1) {
+            auto solution = solutions[0];
+            int solutionLength = 0;
+            for (int x=0; x<solution.width; x++) {
+                for (int y=0; y<solution.height; y++) {
+                    if (solution.grid[x][y].color == Cell::Color::BLACK) solutionLength++;
+                }
+            }
+            if (solutionLength == 25) break;
+        }
+    }
+    PuzzleSerializer(_memory).WritePuzzle(p, 0x293);
+
+
+
+
+    // 7x7
+    // 35 gaps
+    // start (x=8, y=8)
+    // end (x=4, y=0) Up
+    // 2 solutions, 37 & 39
+    attemptCount = 0;
+    while (true) {
+        attemptCount++;
+        p.NewGrid(7, 7);
+
+        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 i=0; i<35; i++) {
+            int edge = Random::RandInt(0, static_cast<int>(edges.size() - 1));
+            Pos pos = edges[edge];
+            p.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
+            edges.erase(edges.begin() + edge);
+        }
+
+        p.grid[8][8].start = true;
+        p.grid[4][0].end = Cell::Dir::UP;
+
+        auto solutions = Solver::Solve(p);
+        if (solutions.size() > 0) break;
+        if (solutions.size() > 0 && solutions.size() < 5) {
+            auto solution = solutions[0];
+            int solutionLength = 0;
+            for (int x=0; x<solution.width; x++) {
+                for (int y=0; y<solution.height; y++) {
+                    if (solution.grid[x][y].color == Cell::Color::BLACK) solutionLength++;
+                }
+            }
+            if (solutionLength > 30 && solutionLength < 40) break;
+        }
+    }
+    PuzzleSerializer(_memory).WritePuzzle(p, 0x295);
+
+}
@@ -0,0 +1,12 @@
+#pragma once
+#include <memory>
+
+class Memory;
+class Randomizer2 {
+public:
+    Randomizer2(const std::shared_ptr<Memory>& memory);
+    void Randomize();
+    
+private:
+    std::shared_ptr<Memory> _memory;
+};
@@ -5,7 +5,7 @@
 #define MAX_SOLUTIONS 10000
 #endif
 
-struct Puzzle;
+class Puzzle;
 class Solver {
 public:
     static std::vector<Puzzle> Solve(Puzzle& p);
@@ -163,6 +163,7 @@
     <ClInclude Include="Panels.h" />
     <ClInclude Include="Random.h" />
     <ClInclude Include="Randomizer.h" />
+    <ClInclude Include="Randomizer2.h" />
     <ClInclude Include="Solver.h" />
     <ClInclude Include="Validator.h" />
   </ItemGroup>
@@ -172,6 +173,7 @@
     <ClCompile Include="Puzzle.cpp" />
     <ClCompile Include="Random.cpp" />
     <ClCompile Include="Randomizer.cpp" />
+    <ClCompile Include="Randomizer2.cpp" />
     <ClCompile Include="Solver.cpp" />
     <ClCompile Include="Validator.cpp" />
   </ItemGroup>
@@ -15,7 +15,7 @@
 #endif
 
 struct Region{};
-struct Puzzle;
+class Puzzle;
 struct Pos;
 class Validator {
 public: