Add sanity checks for overwriting buffers

5 files changed, 37 insertions, 35 deletions

@@ -65,8 +65,8 @@ struct Pos {int x; int y;};
 
 class Puzzle {
 public:
-    int16_t height = 0;
-    int16_t width = 0;
+    int height = 0;
+    int width = 0;
     bool hasDecorations = false;
 
     enum class Symmetry {NONE, X, Y, XY};
@@ -1,5 +1,6 @@
 #include "PuzzleSerializer.h"
 #include "Memory.h"
+#include <cassert>
 
 #pragma warning (disable:26451)
 #pragma warning (disable:26812)
@@ -47,6 +48,16 @@ void PuzzleSerializer::WritePuzzle(const Puzzle& p, int id) {
     WriteDecorations(p, id);
     WriteSequence(p, id);
 
+#ifndef NDEBUG
+    int maxDots = _memory->ReadEntityData<int>(id, NUM_DOTS, 1)[0];
+    assert(_intersectionFlags.size() <= maxDots);
+    assert(_intersectionLocations.size() <= maxDots*2);
+
+    int maxConnections = _memory->ReadEntityData<int>(id, NUM_CONNECTIONS, 1)[0];
+    assert(_connectionsA.size() <= maxConnections);
+    assert(_connectionsB.size() <= maxConnections);
+#endif
+
     _memory->WriteEntityData<int>(id, GRID_SIZE_X, {(p.width + 1)/2});
     _memory->WriteEntityData<int>(id, GRID_SIZE_Y, {(p.height + 1)/2});
     _memory->WriteEntityData<int>(id, NUM_DOTS, {static_cast<int>(_intersectionFlags.size())});
@@ -376,6 +387,10 @@ void PuzzleSerializer::WriteDecorations(const Puzzle& p, int id) {
         }
     }
 
+#ifndef NDEBUG
+    int maxDecorations = _memory->ReadEntityData<int>(id, NUM_DECORATIONS, 1)[0];
+    assert(decorations.size() < maxDecorations);
+#endif
     _memory->WriteEntityData<int>(id, NUM_DECORATIONS, {static_cast<int>(decorations.size())});
     _memory->WriteArray<int>(id, DECORATIONS, decorations);
 }
@@ -14,7 +14,7 @@ Randomizer2::Randomizer2(const std::shared_ptr<Memory>& memory) : _memory(memory
 
 void Randomizer2::Randomize() {
     RandomizeTutorial();
-    RandomizeKeep();
+    // RandomizeKeep();
 }
 
 void Randomizer2::RandomizeTutorial() {
@@ -24,7 +24,7 @@ void Randomizer2::RandomizeTutorial() {
         p.grid[0][8].start = true;
         p.grid[8][0].end = Cell::Dir::UP;
 
-        for (Pos pos : Randomizer2Core::CutEdges(p, 14)) {
+        for (Pos pos : Randomizer2Core::CutEdges(p, 14, true)) {
             p.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
         }
         _serializer.WritePuzzle(p, 0x293);
@@ -32,7 +32,7 @@ void Randomizer2::RandomizeTutorial() {
 
     {
         Puzzle p;
-        p.NewGrid(7, 7);
+        p.NewGrid(6, 6);
 
         switch (Random::RandInt(1, 4)) {
             case 1:
@@ -60,7 +60,7 @@ void Randomizer2::RandomizeTutorial() {
                 break;
         }
     
-        for (Pos pos : Randomizer2Core::CutEdges(p, 35)) {
+        for (Pos pos : Randomizer2Core::CutEdges(p, 35, true)) {
             p.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
         }
 
@@ -88,7 +88,7 @@ void Randomizer2::RandomizeKeep() {
         p.grid[4][8].start = true;
         p.grid[6][0].end = Cell::Dir::UP;
 
-        std::vector<Pos> cutEdges = Randomizer2Core::CutEdges2(p, 5);
+        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++) {
@@ -118,7 +118,7 @@ void Randomizer2::RandomizeKeep() {
         p.grid[0][8].start = true;
         p.grid[8][0].end = Cell::Dir::RIGHT;
 
-        std::vector<Pos> cutEdges = Randomizer2Core::CutEdges2(p, 7);
+        std::vector<Pos> cutEdges = Randomizer2Core::CutEdges(p, 7, false);
         for (Pos pos : cutEdges) {
             p.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
         }
@@ -133,7 +133,7 @@ void Randomizer2::RandomizeKeep() {
             q.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
         }
         // Cut to 6 of 9 additional edges
-        for (Pos pos : Randomizer2Core::CutEdges2(q, 6)) {
+        for (Pos pos : Randomizer2Core::CutEdges(q, 6, false)) {
             q.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
         }
         _serializer.WritePuzzle(q, 0x19DC);
@@ -158,7 +158,7 @@ void Randomizer2::RandomizeKeep() {
 
         std::vector<int> pebbleMarkers = {0x034a9, 0x034b1, 0x034be, 0x034c4};
 
-        std::vector<Pos> cutEdges = Randomizer2Core::CutEdges2(p, 7);
+        std::vector<Pos> cutEdges = Randomizer2Core::CutEdges(p, 7, false);
         for (Pos pos : cutEdges) {
             p.grid[pos.x][pos.y].gap = Cell::Gap::BREAK;
         }
@@ -187,7 +187,7 @@ void Randomizer2::RandomizeKeep() {
         p.grid[0][8].start = true;
         p.grid[4][0].end = Cell::Dir::UP;
 
-        std::vector<Pos> cutEdges = Randomizer2Core::CutEdges2(p, 2);
+        std::vector<Pos> cutEdges = Randomizer2Core::CutEdges(p, 2, false);
         for (Pos pos : cutEdges) {
             p.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
         }
@@ -201,7 +201,7 @@ void Randomizer2::RandomizeKeep() {
         for (Pos pos : cutEdges) {
             q.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
         }
-        for (Pos pos : Randomizer2Core::CutEdges2(q, 7)) {
+        for (Pos pos : Randomizer2Core::CutEdges(q, 7, false)) {
             q.grid[pos.x][pos.y].gap = Cell::Gap::FULL;
         }
         _serializer.WritePuzzle(q, 0x1A0F);
@@ -6,31 +6,19 @@
 #include <iostream>
 #include <cassert>
 
-// @Cutnpaste
-std::vector<Pos> Randomizer2Core::CutEdges(const Puzzle& p, size_t numEdges) {
+std::vector<Pos> Randomizer2Core::CutEdges(const Puzzle& p, size_t numEdges, bool allowEdges) {
     std::vector<Pos> edges;
-    for (int x=0; x<p.width; x++) {
-        for (int y=0; y<p.height; y++) {
-            if (x%2 == y%2) continue;
-            if (p.grid[x][y].gap != Cell::Gap::NONE) continue;
+    int xMin = allowEdges ? 0 : 1;
+    int xMax = allowEdges ? p.width : p.width-1;
+    int yMin = allowEdges ? 0 : 1;
+    int yMax = allowEdges ? p.height : p.height-1;
 
-            // If the puzzle already has a sequence, don't cut along it.
-            bool inSequence = false;
-            for (Pos pos : p.sequence) inSequence |= (pos.x == x && pos.y == y);
-            if (inSequence) continue;
-            edges.emplace_back(Pos{x, y});
-        }
-    }
-    return CutEdgesInternal(p, edges, numEdges);
-}
-
-std::vector<Pos> Randomizer2Core::CutEdges2(const Puzzle& p, size_t numEdges) {
-    std::vector<Pos> edges;
-    // Note the iterator bounds; we skip the outer edges.
-    for (int x=1; x<p.width-1; x++) {
-        for (int y=1; y<p.height-1; y++) {
+    for (int x=xMin; x<xMax; x++) {
+        for (int y=yMin; y<yMax; y++) {
             if (x%2 == y%2) continue;
             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 the puzzle already has a sequence, don't cut along it.
             bool inSequence = false;
@@ -7,8 +7,7 @@ class Puzzle;
 class Randomizer2Core {
 public:
     // CAUTION: Does not actually cut edges, just returns a list of suggested cuts.
-    static std::vector<Pos> CutEdges(const Puzzle& p, size_t numEdges);
-    static std::vector<Pos> CutEdges2(const Puzzle& p, size_t numEdges);
+    static std::vector<Pos> CutEdges(const Puzzle& p, size_t numEdges, bool allowEdges);
 
 private:
     static std::vector<Pos> CutEdgesInternal(const Puzzle& p, std::vector<Pos>& edges, size_t numEdges);