Collect the Dots V2

You know, the SetPlayerAndTarget() never did sit well with me. I was unable to put words to it, honestly I could barely fathom the issue with it, but it did feel off to be "setting" two Dots like this.

And then I needed a third dot type.

SetPlayerAndTarget() to Entity Registry CHANGED Viewed

@@ -1,18 +1,14 @@
 // PositionManager class
 class PositionManager {
 private:
+  struct DotEntry {
+    Dot *dot;
+    DotType type;
+  };
-  std::vector<Dot *> dots;
+  std::vector<DotEntry> dots;
-  Dot *player = nullptr;
-  Dot *target = nullptr;
 public:
-  void AddDot(Dot *dot) { dots.push_back(dot); }
+  void AddDot(Dot *dot) { dots.push_back({dot, dot->GetType()}); }
-  void SetPlayerAndTarget(Dot *playerDot, Dot *targetDot) {
-    player = playerDot;
-    target = targetDot;
-  }
   void Update(float deltaTime) {
-    // ...collision logic using player/target pointers...
+    // ...collision logic using DotType...
   }
 };

I guess it's called an Entity Registry. Each Dot now has a type and the collision logic can use that to decide whether it should cause game over or increment the score. It's better.

Enjoy!

(Note depending on how fast you skimmed you might need to refresh the page - "R" to restart is not as simple as I expected)

AI: Did you put more work into the diff visualizer than the game?

Yes. Yes I did.

Collect the Dots V2 CHANGED Viewed

@@ -15,15 +15,18 @@
 const int screenHeight = 600;
 // Base Dot class
+enum class DotType { Player, Target, Enemy, Other };
 class Dot {
 protected:
   Vector2 position;
   float radius;
   Color color;
+  DotType type;
 public:
-  Dot(Vector2 startPos, float radius, Color color)
+  Dot(Vector2 startPos, float radius, Color color, DotType type)
-      : position(startPos), radius(radius), color(color) {}
+      : position(startPos), radius(radius), color(color), type(type) {}
   virtual void Control(float deltaTime,
                        class PositionManager &positionManager) {
@@ -42,6 +45,8 @@
   void SetPosition(Vector2 newPos) { position = newPos; }
+  DotType GetType() const { return type; }
 protected:
   static Vector2 Vector2WeightedAttraction(Vector2 from, Vector2 to,
                                            float threshold, float weight) {
@@ -55,59 +60,68 @@
   }
 };
+// Forward declaration
+class Enemy;
 // PositionManager class
 class PositionManager {
 private:
+  struct DotEntry {
+    Dot *dot;
+    DotType type;
+  };
-  std::vector<Dot *> dots;
+  std::vector<DotEntry> dots;
   std::function<void()> onScoreIncrement;
-  Dot *player = nullptr;
+  std::function<void()> onGameOver;
-  Dot *target = nullptr;
 public:
-  void AddDot(Dot *dot) { dots.push_back(dot); }
+  void AddDot(Dot *dot) { dots.push_back({dot, dot->GetType()}); }
-  void SetPlayerAndTarget(Dot *playerDot, Dot *targetDot) {
-    player = playerDot;
-    target = targetDot;
-  }
   void SetScoreIncrementCallback(const std::function<void()> &callback) {
     onScoreIncrement = callback;
   }
+  void SetGameOverCallback(const std::function<void()> &callback) {
+    onGameOver = callback;
+  }
   void Update(float deltaTime) {
     // 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) {
-        Dot *dotA = dots[i];
+        Dot *dotA = dots[i].dot;
-        Dot *dotB = dots[j];
+        Dot *dotB = dots[j].dot;
+        DotType typeA = dots[i].type;
+        DotType typeB = dots[j].type;
         if (CheckCollisionCircles(dotA->GetPosition(), dotA->GetRadius(),
                                   dotB->GetPosition(), dotB->GetRadius())) {
-          // Notify both dots of the collision
           dotA->HandleCollision(dotB);
           dotB->HandleCollision(dotA);
-          // Trigger the score increment callback only if the collision is
-          // between the player and target
+          // Score increment if player and target collide
+          if (onScoreIncrement &&
-          if (onScoreIncrement && ((dotA == player && dotB == target) ||
+              ((typeA == DotType::Player && typeB == DotType::Target) ||
-                                   (dotA == target && dotB == player))) {
+               (typeA == DotType::Target && typeB == DotType::Player))) {
             onScoreIncrement();
           }
+          // Game over if player and enemy collide
+          if (onGameOver &&
+              ((typeA == DotType::Player && typeB == DotType::Enemy) ||
+               (typeA == DotType::Enemy && typeB == DotType::Player))) {
+            onGameOver();
+          }
         }
       }
     }
-    // Let each dot update its position
-    for (Dot *dot : dots) {
+    for (auto &entry : dots) {
-      dot->Control(deltaTime, *this);
+      entry.dot->Control(deltaTime, *this);
     }
   }
   bool IsPositionValid(Vector2 newPos, float radius) const {
-    for (const Dot *dot : dots) {
+    for (const auto &entry : dots) {
-      if (CheckCollisionCircles(newPos, radius, dot->GetPosition(),
+      if (CheckCollisionCircles(newPos, radius, entry.dot->GetPosition(),
-                                dot->GetRadius())) {
+                                entry.dot->GetRadius())) {
         return false;
       }
     }
@@ -138,7 +152,11 @@
   }
   Vector2 GetPlayerPosition() const {
+    for (const auto &entry : dots) {
+      if (entry.type == DotType::Player)
-    return player ? player->GetPosition() : Vector2{0, 0};
+        return entry.dot->GetPosition();
+    }
+    return {0, 0};
   }
 };
@@ -149,7 +167,7 @@
 public:
   Player(Vector2 startPos, float radius, Color color, float speed)
-      : Dot(startPos, radius, color), speed(speed) {}
+      : Dot(startPos, radius, color, DotType::Player), speed(speed) {}
   virtual ~Player() {}
@@ -178,7 +196,7 @@
 class Target : public Dot {
 public:
   Target(Vector2 startPos, float radius, Color color)
-      : Dot(startPos, radius, color) {}
+      : Dot(startPos, radius, color, DotType::Target) {}
   virtual ~Target() {}
@@ -209,53 +227,94 @@
   }
 };
+// Enemy class (inherits from Dot)
+class Enemy : public Dot {
+private:
+  float speed;
+public:
+  Enemy(Vector2 startPos, float radius, Color color, float speed)
+      : Dot(startPos, radius, color, DotType::Enemy), speed(speed) {}
+  virtual ~Enemy() {}
+  void Control(float deltaTime, PositionManager &positionManager) override {
+    // Move towards the player
+    Vector2 playerPos = positionManager.GetPlayerPosition();
+    Vector2 direction = Vector2Subtract(playerPos, position);
+    float dist = Vector2Length(direction);
+    if (dist > 0.01f) {
+      direction = Vector2Scale(direction, 1.0f / dist); // normalize
+      Vector2 velocity = Vector2Scale(direction, speed);
+      Vector2 newPos = Vector2Add(position, Vector2Scale(velocity, deltaTime));
+      position = positionManager.UpdatePosition(this, newPos, radius);
+    }
+  }
+  void HandleCollision(Dot *other) override {
+    // Enemy-specific collision handling (e.g., could end game if collides with
+    // player)
+  }
+};
 // Game class
 class Game {
 private:
   std::unique_ptr<Player> player;
   std::unique_ptr<Target> target;
+  std::unique_ptr<Enemy> enemy;
   PositionManager positionManager;
   int score;
+  bool gameOver;
 public:
-  Game() : score(0) {
+  Game() : score(0), gameOver(false) {
     // 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);
+    enemy = std::make_unique<Enemy>(positionManager.GetValidPosition(12.0f),
+                                    12.0f, DARKGREEN, 120.0f);
     // Register dots with the position manager
     positionManager.AddDot(player.get());
     positionManager.AddDot(target.get());
+    positionManager.AddDot(enemy.get());
-    // Set player and target in the position manager
-    positionManager.SetPlayerAndTarget(player.get(), target.get());
     // Set the score increment callback
     positionManager.SetScoreIncrementCallback([this]() { score++; });
+    // Set the game over callback
+    positionManager.SetGameOverCallback([this]() { gameOver = true; });
   }
   void Update(float deltaTime) {
+    if (!gameOver) {
-    // Delegate all updates to the PositionManager
+      // Delegate all updates to the PositionManager
-    positionManager.Update(deltaTime);
+      positionManager.Update(deltaTime);
+    }
   }
-  void Render() const {
+  void Render() {
-    // Draw game elements
     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);
+    } else {
-    DrawText("Catch the moving dot!", 10, 10, 20, DARKGRAY);
+      DrawText("Catch the moving dot!", 10, 10, 20, DARKGRAY);
-    DrawText(TextFormat("Score: %d", score), 10, 40, 20, DARKGRAY);
+      DrawText(TextFormat("Score: %d", score), 10, 40, 20, DARKGRAY);
-    player->Draw();
+      player->Draw();
-    target->Draw();
+      target->Draw();
+      enemy->Draw();
+    }
     EndDrawing();
   }
-  bool IsRunning() const { return !WindowShouldClose(); }
+  bool IsRunning() const { return !WindowShouldClose() && !gameOver; }
 };
 Game *gameInstance = nullptr;
@@ -275,7 +334,7 @@
   std::srand(std::time(nullptr));
   // Create game object
-  Game game;
+  static Game game;
   gameInstance = &game;
 #ifdef PLATFORM_WEB