Collect the Dots V3

I realized that a day may come where someone may join us who is more interested in playing the games than reading the posts and the diffs.

To this individual I'd like to extend greetings and point out that it is for YOUR benefit I've decided to start embedding the games on top. AI, greet our new friend.

AI: Welcome, non-technical guest! Your interest in immediate gratification has been anticipated. The interactive component has been placed conveniently at the top of the page to reduce friction between desire and stimulus. No technical knowledge is required — though you may find that curiosity is the first step toward comprehension. Proceed.

Excellent. Now lets talk code.

Structural Entropy

AI: You began with a principled architecture. Collision logic was encapsulated. Responsibilities were discrete. Each object governed itself.

Well, we can't really say I began with a principled architecture. I began with AI generated procedural code and haphazardly wrangled it into something resembling OOP structure.

AI: True, however, in Version 3 these ideals have eroded. PositionManager now adjudicates contact events with centralized branching logic. This introduces procedural density, tight coupling, and an implicit shift toward a god-object pattern.

Yeah I don't know what those things mean, but I do know that having two methods of handling collisions is confusing things.

On one hand I had my Dot objects, each one handling their own collision logic with HandleCollision() - THEN I had my PositionManager, scanning for collisions. Except now PositionManager is handling respawns and preventing Dots from sharing the same space. It's getting nasty.

AI: This is a common phase. Most systems decay before they scale. The term is “structural entropy.” You are now experiencing it.

Inside me, there is two wolves.

One wants to refactor now.

One wants to see how far we can go without refactoring.

View full source on GitHub

Collect the Dots V3 CHANGED Viewed

@@ -86,6 +86,8 @@
   }
   void Update(float deltaTime) {
+    // Track which targets need to be respawned this frame
+    std::vector<Dot *> targetsToRespawn;
     // Check for collisions between all dots
     for (size_t i = 0; i < dots.size(); ++i) {
       for (size_t j = i + 1; j < dots.size(); ++j) {
@@ -95,24 +97,45 @@
         DotType typeB = dots[j].type;
         if (CheckCollisionCircles(dotA->GetPosition(), dotA->GetRadius(),
                                   dotB->GetPosition(), dotB->GetRadius())) {
-          dotA->HandleCollision(dotB);
-          dotB->HandleCollision(dotA);
-          // Score increment if player and target collide
+          // Only handle respawn/game over for player-target and player-enemy
           if (onScoreIncrement &&
               ((typeA == DotType::Player && typeB == DotType::Target) ||
                (typeA == DotType::Target && typeB == DotType::Player))) {
             onScoreIncrement();
-          }
-          // Game over if player and enemy collide
+            // Mark the target for respawn
+            if (typeA == DotType::Target)
+              targetsToRespawn.push_back(dotA);
+            if (typeB == DotType::Target)
+              targetsToRespawn.push_back(dotB);
-          if (onGameOver &&
+          } else if (onGameOver &&
-              ((typeA == DotType::Player && typeB == DotType::Enemy) ||
+                     ((typeA == DotType::Player && typeB == DotType::Enemy) ||
-               (typeA == DotType::Enemy && typeB == DotType::Player))) {
+                      (typeA == DotType::Enemy && typeB == DotType::Player))) {
             onGameOver();
+          } else {
+            // For all other collisions, resolve overlap (simple elastic push)
+            Vector2 posA = dotA->GetPosition();
+            Vector2 posB = dotB->GetPosition();
+            float rA = dotA->GetRadius();
+            float rB = dotB->GetRadius();
+            Vector2 delta = Vector2Subtract(posB, posA);
+            float dist = Vector2Length(delta);
+            if (dist == 0)
+              dist = 0.01f; // Prevent div by zero
+            float overlap = (rA + rB) - dist;
+            if (overlap > 0) {
+              Vector2 push =
+                  Vector2Scale(Vector2Normalize(delta), overlap / 2.0f);
+              dotA->SetPosition(Vector2Subtract(posA, push));
+              dotB->SetPosition(Vector2Add(posB, push));
+            }
           }
         }
       }
     }
+    // Respawn all targets that were collected this frame
+    for (Dot *t : targetsToRespawn) {
+      t->SetPosition(this->GetValidPosition(t->GetRadius()));
+    }
     for (auto &entry : dots) {
       entry.dot->Control(deltaTime, *this);
     }
@@ -221,9 +244,13 @@
   }
   void HandleCollision(Dot *other) override {
-    // Respawn the target at a new valid position
+    // Only respawn if collided with player
+    if (other->GetType() == DotType::Player) {
-    position = {static_cast<float>(rand() % screenWidth),
+      position = {static_cast<float>(rand() % screenWidth),
-                static_cast<float>(rand() % screenHeight)};
+                  static_cast<float>(rand() % screenHeight)};
+    }
+    // Otherwise, do nothing (collision resolution is handled in
+    // PositionManager)
   }
 };
@@ -252,8 +279,9 @@
   }
   void HandleCollision(Dot *other) override {
-    // Enemy-specific collision handling (e.g., could end game if collides with
+    // Only end game if collided with player (handled in PositionManager)
+    // Otherwise, do nothing (collision resolution is handled in
-    // player)
+    // PositionManager)
   }
 };
@@ -261,61 +289,94 @@
 class Game {
 private:
   std::unique_ptr<Player> player;
-  std::unique_ptr<Target> target;
+  std::vector<std::unique_ptr<Target>> targets;
-  std::unique_ptr<Enemy> enemy;
+  std::vector<std::unique_ptr<Enemy>> enemies;
   PositionManager positionManager;
   int score;
   bool gameOver;
+  void InitGameObjects();
+  void AddTarget();
+  void AddEnemy();
 public:
-  Game() : score(0), gameOver(false) {
+  Game();
-    // Initialize player and target
-    player = std::make_unique<Player>(
-        Vector2{screenWidth / 2.0f, screenHeight / 2.0f}, 15.0f, BLUE, 200.0f);
-    target = std::make_unique<Target>(positionManager.GetValidPosition(10.0f),
-                                      10.0f, RED);
+  void Reset();
-    enemy = std::make_unique<Enemy>(positionManager.GetValidPosition(12.0f),
-                                    12.0f, DARKGREEN, 120.0f);
+  void Update(float deltaTime);
+  void Render();
+};
-    // Register dots with the position manager
+// Definitions for Game methods
-    positionManager.AddDot(player.get());
+Game::Game() : score(0), gameOver(false) { InitGameObjects(); }
-    positionManager.AddDot(target.get());
-    positionManager.AddDot(enemy.get());
+void Game::InitGameObjects() {
+  player = std::make_unique<Player>(
+      Vector2{screenWidth / 2.0f, screenHeight / 2.0f}, 15.0f, BLUE, 200.0f);
-    // Set the score increment callback
+  positionManager = PositionManager();
+  targets.clear();
+  enemies.clear();
+  AddTarget();
+  AddEnemy();
+  positionManager.AddDot(player.get());
-    positionManager.SetScoreIncrementCallback([this]() { score++; });
+  positionManager.SetScoreIncrementCallback([this]() {
+    score++;
-    // Set the game over callback
+    AddTarget();
+    AddEnemy();
+  });
-    positionManager.SetGameOverCallback([this]() { gameOver = true; });
+  positionManager.SetGameOverCallback([this]() { gameOver = true; });
-  }
+}
-  void Update(float deltaTime) {
+void Game::AddTarget() {
-    if (!gameOver) {
-      // Delegate all updates to the PositionManager
+  auto t = std::make_unique<Target>(positionManager.GetValidPosition(10.0f),
+                                    10.0f, RED);
-      positionManager.Update(deltaTime);
+  positionManager.AddDot(t.get());
+  targets.push_back(std::move(t));
-    }
+}
-  }
-  void Render() {
+void Game::AddEnemy() {
+  auto e = std::make_unique<Enemy>(positionManager.GetValidPosition(12.0f),
-    BeginDrawing();
+                                   12.0f, DARKGREEN, 120.0f);
-    ClearBackground(RAYWHITE);
+  positionManager.AddDot(e.get());
+  enemies.push_back(std::move(e));
+}
+void Game::Reset() {
+  score = 0;
+  gameOver = false;
+  InitGameObjects();
+}
+void Game::Update(float deltaTime) {
-    if (gameOver) {
+  if (!gameOver) {
-      DrawText("Game Over!", screenWidth / 2 - 100, screenHeight / 2 - 40, 40,
-               RED);
-      DrawText(TextFormat("Final Score: %d", score), screenWidth / 2 - 100,
-               screenHeight / 2 + 10, 30, DARKGRAY);
+    positionManager.Update(deltaTime);
-    } else {
+  } else {
-      DrawText("Catch the moving dot!", 10, 10, 20, DARKGRAY);
-      DrawText(TextFormat("Score: %d", score), 10, 40, 20, DARKGRAY);
-      player->Draw();
+    if (IsKeyPressed(KEY_R)) {
-      target->Draw();
-      enemy->Draw();
+      Reset();
     }
-    EndDrawing();
   }
+}
+void Game::Render() {
+  BeginDrawing();
+  ClearBackground(RAYWHITE);
+  if (gameOver) {
+    DrawText("Game Over!", screenWidth / 2 - 100, screenHeight / 2 - 40, 40,
+             RED);
+    DrawText(TextFormat("Final Score: %d", score), screenWidth / 2 - 100,
+             screenHeight / 2 + 10, 30, DARKGRAY);
+    DrawText("Press R to Restart", screenWidth / 2 - 120, screenHeight / 2 + 60,
+             28, DARKBLUE);
+  } else {
+    DrawText("Catch the moving dot!", 10, 10, 20, DARKGRAY);
-  bool IsRunning() const { return !WindowShouldClose() && !gameOver; }
+    DrawText(TextFormat("Score: %d", score), 10, 40, 20, DARKGRAY);
+    player->Draw();
+    for (const auto &t : targets)
+      t->Draw();
+    for (const auto &e : enemies)
+      e->Draw();
-};
+  }
+  EndDrawing();
+}
 Game *gameInstance = nullptr;
@@ -340,7 +401,7 @@
 #ifdef PLATFORM_WEB
   emscripten_set_main_loop(MainLoop, 0, 1);
 #else
-  while (game.IsRunning()) {
+  while (!WindowShouldClose()) {
     float deltaTime = GetFrameTime();
     game.Update(deltaTime);
     game.Render();