5 files changed, 98 insertions, 10 deletions

@@ -1,7 +1,7 @@
 #include <chrono>
 #include "Random.h"
 
-int Random::s_seed = static_cast<int>(time(nullptr)); // Seed from the time in milliseconds
+uint32_t Random::s_seed = static_cast<int>(time(nullptr)); // Seed from the time in milliseconds
 
 void Random::SetSeed(int seed) {
     s_seed = seed;
@@ -9,6 +9,7 @@ void Random::SetSeed(int seed) {
 
 // Returns a random integer in [min, max]
 int Random::RandInt(int min, int max) {
-    s_seed = (214013 * s_seed + 2531011) % 2147483648;
-    return (s_seed % (max - min + 1)) + min;
+    s_seed = (214013 * s_seed + 2531011); // Implicit unsigned integer overflow
+    int32_t maskedSeed = ((s_seed >> 16) & 0x7fff); // Only use bits 16-30
+    return (maskedSeed % (max - min + 1)) + min;
 }
@@ -8,5 +8,5 @@ public:
     static int RandInt(int min, int max);
 
 private:
-    static int s_seed;
+    static uint32_t s_seed;
 };
@@ -84,6 +84,77 @@ void Randomizer2::RandomizeTutorial() {
         }
         _serializer.WritePuzzle(p, 0xA3B5);
     }
+
+    { // Back right
+        Puzzle p;
+        p.NewGrid(6, 6);
+
+        p.grid[0][12].start = true;
+        p.grid[12][12].start = true;
+        p.grid[6][0].end = Cell::Dir::UP;
+
+        std::vector<Pos> cuts;
+        bool toTheRight;
+        // Start by generating a cut line, to ensure one of the two startpoints is inaccessible
+        int x, y;
+        switch (Random::RandInt(1, 4))
+        {
+            case 1:
+                x = 1;
+                y = 1;
+                toTheRight = true;
+                cuts.emplace_back(Pos{0, 1});
+                break;
+            case 2:
+                x = 1;
+                y = 1;
+                toTheRight = true;
+                cuts.emplace_back(Pos{1, 0});
+                break;
+            case 3:
+                x = 11;
+                y = 1;
+                toTheRight = false;
+                cuts.emplace_back(Pos{12, 1});
+                break;
+            case 4:
+                x = 11;
+                y = 1;
+                toTheRight = false;
+                cuts.emplace_back(Pos{11, 0});
+                break;
+        }
+        while (y < p.height) { // The final cut will push y below the bottom of the puzzle, which means we're done.
+            switch (Random::RandInt(1, 4)) {
+                case 1: // Go right
+                    if (x < p.width-2) {
+                        cuts.emplace_back(Pos{x+1, y});
+                        x += 2;
+                    }
+                    break;
+                case 2: // Go left
+                    if (x > 1) {
+                        cuts.emplace_back(Pos{x-1, y});
+                        x -= 2;
+                    }
+                    break;
+                case 3: 
+                case 4: // Go down (biased)
+                    cuts.emplace_back(Pos{x, y+1});
+                    y += 2;
+                    break;
+            }
+        }
+
+        for (Pos pos : cuts) {
+            p.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
+        }
+
+        for (Pos pos : Randomizer2Core::CutEdges(p, 30 - cuts.size(), true)) {
+            p.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
+        }
+        _serializer.WritePuzzle(p, 0xA3B2);
+    }
 }
 
 void Randomizer2::RandomizeKeep() {
@@ -109,7 +180,7 @@ void Randomizer2::RandomizeKeep() {
         std::vector<Pos> cutEdges = Randomizer2Core::CutEdges(p, 5, false);
         Puzzle copy = p;
         std::vector<int> gates = {0x00344, 0x00488,  0x00489, 0x00495, 0x00496};
-        for (int i=0; i<gates.size(); i++) {
+        for (int i=0; i<cutEdges.size(); i++) {
             Pos pos = cutEdges[i];
             copy.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
             SetGate(gates[i], pos.x, pos.y);
@@ -174,12 +245,13 @@ void Randomizer2::RandomizeKeep() {
         p.grid[0][8].start = true;
         p.grid[8][2].end = Cell::Dir::RIGHT;
 
-        std::vector<int> pebbleMarkers = {0x034a9, 0x034b1, 0x034be, 0x034c4};
-
         std::vector<Pos> cutEdges = Randomizer2Core::CutEdges(p, 7, false);
         for (Pos pos : cutEdges) {
             p.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
         }
+
+        std::vector<int> pebbleMarkers = {0x034a9, 0x034b1, 0x034be, 0x034c4};
+
         // _serializer.WritePuzzle(p, 0x19E7);
     }
 
@@ -77,15 +77,22 @@ std::vector<Pos> Randomizer2Core::CutEdgesInternal(const Puzzle& p, std::vector<
     return cutEdges;
 }
 
+#ifndef NDEBUG
+#include <Windows.h>
+#endif
+
 void Randomizer2Core::DebugColorGrid(const std::vector<std::vector<int>>& colorGrid) {
+#ifndef NDEBUG
     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;
+        row += "\n";
+        OutputDebugStringA(row.c_str());
     }
-    std::cerr << std::endl;
+    OutputDebugStringA("\n");
+#endif
 }
 
 void Randomizer2Core::FloodFill(const Puzzle& p, std::vector<std::vector<int>>& colorGrid, int color, int x, int y) {
@@ -102,7 +109,7 @@ void Randomizer2Core::FloodFill(const Puzzle& p, std::vector<std::vector<int>>&
 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
+    if (x%2 != y%2 && p.grid[x][y].gap == Cell::Gap::NONE) return; // Only flood-fill through gaps
     colorGrid[x][y] = 1; // Outside color
 
     FloodFillOutside(p, colorGrid, x, y+1);
@@ -32,4 +32,12 @@ TEST(RandomTests, SeedChangesInitialValue) {
         int random3 = Random::RandInt(0, 1 << 30);
         ASSERT_NE(random3, random1);
         ASSERT_NE(random3, random2);
+}
+
+TEST(RandomTests, EvenOdd) {
+    std::vector<int> outputs;
+    for (int i=0; i<100; i++) {
+        outputs.emplace_back(Random::RandInt(0, 1));
+    }
+    int k = 0;
 }
\ No newline at end of file