feat: cycle detection

Author: developer239

src/apps/2024day6/src/entities/GameObject.h

@@ -38,4 +38,17 @@ struct GameObject {
     );
     SDL_RenderFillRect(renderer.Get().get(), &rect);
   }
+
+  void RenderHollow(Core::Renderer& renderer) const {
+    SDL_Rect rect =
+        {(int)this->x + 15, (int)this->y + 15, (int)this->width, (int)this->height};
+    SDL_SetRenderDrawColor(
+        renderer.Get().get(),
+        color[0],
+        color[1],
+        color[2],
+        255
+    );
+    SDL_RenderDrawRect(renderer.Get().get(), &rect);
+  }
 };

src/apps/2024day6/src/main.cpp

@@ -6,6 +6,6 @@
 int main() {
   MinimalLoopStrategy strategy;
 
-  auto loop = Core::Loop({&strategy});
+  auto loop = Core::Loop({&strategy}, 1400, 3000);
   loop.Run();
 }

src/apps/2024day6/src/strategies/MinimalLoopStrategy.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <algorithm>
 #include <fstream>
 #include <iostream>
 
@@ -25,19 +26,108 @@ bool areOverlapping(GameObject& guard, GameObject& b) {
          guard.y < b.y + b.height && guard.y + guard.height > b.y;
 }
 
+bool isCornerPosition(GameObject& distinctPosition) {
+  if (distinctPosition.color[0] == 255 && distinctPosition.color[1] == 0 &&
+      distinctPosition.color[2] == 255) {
+    return true;
+  }
+  return false;
+}
+
+std::optional<GameObject> doLast4CornerDistinctPositionsFormRectangle(
+    std::vector<GameObject>& distinctPositions
+) {
+  // find last 4 corner distinct positions
+  std::vector<GameObject> corners;
+  for (int i = distinctPositions.size() - 1; i >= 0; i--) {
+    if (isCornerPosition(distinctPositions[i])) {
+      corners.push_back(distinctPositions[i]);
+    }
+    if (corners.size() == 4) {
+      break;
+    }
+  }
+
+  if (corners.size() != 4) {
+    return std::nullopt;
+  }
+
+  // Initialize with first corner
+  GameObject topLeft = corners[0];
+  GameObject topRight = corners[0];
+  GameObject bottomLeft = corners[0];
+  GameObject bottomRight = corners[0];
+
+  // Find the extreme corners
+  for (const auto& corner : corners) {
+    // Top-left has minimum x and y
+    if (corner.x + corner.y < topLeft.x + topLeft.y) {
+      topLeft = corner;
+    }
+    // Top-right has maximum x and minimum y
+    if (corner.x - corner.y > topRight.x - topRight.y) {
+      topRight = corner;
+    }
+    // Bottom-left has minimum x and maximum y
+    if (corner.x - corner.y < bottomLeft.x - bottomLeft.y) {
+      bottomLeft = corner;
+    }
+    // Bottom-right has maximum x and y
+    if (corner.x + corner.y > bottomRight.x + bottomRight.y) {
+      bottomRight = corner;
+    }
+  }
+
+  // Verify we have a rectangle by checking:
+  // 1. Width equality (top and bottom)
+  // 2. Height equality (left and right)
+  // 3. Diagonal equality
+  double topWidth = std::abs(topRight.x - topLeft.x);
+  double bottomWidth = std::abs(bottomRight.x - bottomLeft.x);
+  double leftHeight = std::abs(bottomLeft.y - topLeft.y);
+  double rightHeight = std::abs(bottomRight.y - topRight.y);
+
+  // Allow for small floating-point differences
+  const double epsilon = 0.001;
+
+  bool widthsEqual = std::abs(topWidth - bottomWidth) < epsilon;
+  bool heightsEqual = std::abs(leftHeight - rightHeight) < epsilon;
+
+  if (widthsEqual && heightsEqual) {
+    return GameObject(
+        topWidth,
+        leftHeight,
+        topLeft.x,
+        topLeft.y,
+        0,
+        0,
+        {255, 0, 255}
+    );
+  }
+
+  return std::nullopt;
+}
+
+struct Cycle {
+  GameObject rectangle;
+  GameObject corner;
+};
+
 class MinimalLoopStrategy : public Core::IStrategy {
  public:
   std::vector<GameObject> obstructions;
   GameObject guard;
   std::vector<GameObject> path;
   std::vector<GameObject> distinctPositions;
   std::vector<std::string> recentObstructionCoords;
+  GameObject distinctPathPieceNext;
+  std::vector<Cycle> cycles;
 
   int boundaryHeight;
   int boundaryWidth;
 
-  int scale = 10;
-  int defaultVelocity = 100;
+  int scale = 30;
+  int defaultVelocity = 30;
 
   double totalTime = 0;
 
@@ -46,7 +136,7 @@ class MinimalLoopStrategy : public Core::IStrategy {
 
     auto size = 1 * scale;
 
-    const std::string filePath = "assets/input.txt";
+    const std::string filePath = "assets/input-example-1.txt";
     auto input = ParseInput(filePath);
 
     boundaryWidth = input[0].size() * size;
@@ -83,6 +173,9 @@ class MinimalLoopStrategy : public Core::IStrategy {
               vel_y,
               {255, 0, 0}
           );
+
+          distinctPathPieceNext =
+              GameObject(size, size, guard.x, guard.y, 0, 0, {0, 0, 255});
         }
       }
     }
@@ -109,6 +202,8 @@ class MinimalLoopStrategy : public Core::IStrategy {
     guard.x += guard.velX * deltaTime;
     guard.y += guard.velY * deltaTime;
 
+    bool hasChangedDirection = false;
+
     for (auto& obstruction : obstructions) {
       auto obstructionCoords =
           std::to_string(obstruction.x) + "-" + std::to_string(obstruction.y);
@@ -149,6 +244,7 @@ class MinimalLoopStrategy : public Core::IStrategy {
         if (recentObstructionCoords.size() > 2) {
           recentObstructionCoords.erase(recentObstructionCoords.begin());
         }
+        hasChangedDirection = true;
       }
     }
 
@@ -199,14 +295,56 @@ class MinimalLoopStrategy : public Core::IStrategy {
         }
       }
 
+      // move distinct piece next in the direction of the guard
+      distinctPathPieceNext.x = guard.velX > 0   ? distinctPathPiece.x + scale
+                                : guard.velX < 0 ? distinctPathPiece.x - scale
+                                                 : distinctPathPiece.x;
+      distinctPathPieceNext.y = guard.velY > 0   ? distinctPathPiece.y + scale
+                                : guard.velY < 0 ? distinctPathPiece.y - scale
+                                                 : distinctPathPiece.y;
+
       if (!isOverlapping) {
         distinctPositions.push_back(distinctPathPiece);
+      } else {
+        if (hasChangedDirection) {
+          distinctPositions.back().color = {255, 0, 255};
+        }
+      }
+
+      // if distinctPathPieceNext overlapping with distinct path
+      for (auto& distinctPiece : distinctPositions) {
+        if (areOverlapping(distinctPiece, distinctPathPieceNext)) {
+          distinctPiece.color = {255, 0, 255};
+
+          auto rectangle =
+              doLast4CornerDistinctPositionsFormRectangle(distinctPositions);
+
+          if (rectangle.has_value()) {
+            // if rectangle doesn't exist in cycles
+            auto isRectangleInCycles = false;
+            for (auto& cycle : cycles) {
+              if (cycle.rectangle.x == rectangle.value().x &&
+                  cycle.rectangle.y == rectangle.value().y &&
+                  cycle.rectangle.width == rectangle.value().width &&
+                  cycle.rectangle.height == rectangle.value().height
+
+              ) {
+                isRectangleInCycles = true;
+                break;
+              }
+            }
+
+            if (!isRectangleInCycles) {
+              std::cout << "Rectangle found" << std::endl;
+              cycles.push_back(Cycle{rectangle.value(), distinctPathPieceNext});
+            }
+          }
+        }
       }
     }
   }
 
   void OnRender(Core::Window& window, Core::Renderer& renderer) override {
-    guard.Render(renderer);
     for (auto& obstruction : obstructions) {
       obstruction.Render(renderer);
     }
@@ -217,6 +355,13 @@ class MinimalLoopStrategy : public Core::IStrategy {
       distinctPiece.Render(renderer);
     }
 
+    for (auto& cycle : cycles) {
+      cycle.rectangle.RenderHollow(renderer);
+    }
+
+    distinctPathPieceNext.Render(renderer);
+    guard.Render(renderer);
+
     SDL_Rect rect = {0, 0, boundaryWidth, boundaryHeight};
     SDL_SetRenderDrawColor(renderer.Get().get(), 255, 255, 255, 255);
     SDL_RenderDrawRect(renderer.Get().get(), &rect);