Added Asteroid size and breaking functionality

Author: Gallasko

exemples/Asteroid/application.cpp

@@ -41,9 +41,9 @@ StandardSystemImpl* createAsteroidSpawnTimerSystem()
             float timer = sys->getData("spawnTimer").get<float>();
             timer += deltaTime;
 
-            if (timer > 2.0f)
+            if (timer > 10.0f)
             {
-                timer -= 2.0f;
+                timer -= 10.0f;
                 // for (int i = 0; i < 10; i++)
                     sys->sendEvent("SpawnAsteroid");
             }
@@ -140,6 +140,8 @@ GameApp::GameApp(const std::string &appName) : engine(appName)
 
     engine.setSetupFunction([this](EntitySystem& ecs, Window& window)
     {
+        ecs.setVMOptimizationLevel(VmOptimizationLevel::O0);
+
         ecs.createSystem<CollisionSystem>();
 
         ecs.createSystem<CollisionHandlerSystem>();

res/asteroid/README_ASTEROID.md

@@ -125,6 +125,54 @@ All bullet data stored in `sysData`:
 - `bullet[N]_lifetime` - Remaining lifetime
 - `bullet[N]_spawn` - Flag to trigger spawning (1 = spawn, 0 = spawned)
 
+## Asteroid Health and Splitting System
+
+### Three-Tier Asteroid System:
+
+The game features a three-tier asteroid system where larger asteroids break apart into smaller ones:
+
+1. **Big Asteroids** (60px)
+   - Health: 3 hits required
+   - Splits into: 2 medium asteroids
+   - Speed: 50-150 px/s
+
+2. **Medium Asteroids** (40px)
+   - Health: 2 hits required
+   - Splits into: 2 small asteroids
+   - Speed: 60-120 px/s (spawned from big asteroids)
+
+3. **Small Asteroids** (20px)
+   - Health: 1 hit required
+   - Splits into: Nothing (completely destroyed)
+   - Speed: 80-150 px/s (spawned from medium asteroids)
+
+### How It Works:
+
+1. When a bullet hits an asteroid, the asteroid's health decreases by 1
+2. If health reaches 0:
+   - Big asteroids spawn 2 medium asteroids at the destruction location
+   - Medium asteroids spawn 2 small asteroids at the destruction location
+   - Small asteroids are completely destroyed with no fragments
+3. Fragment asteroids inherit the parent's position but get random velocities in opposite directions
+4. Each fragment has its own rotation speed for visual variety
+
+### Asteroid Component Data:
+
+Each asteroid stores the following in its `Asteroid` component:
+- `size` - Visual size in pixels (60/40/20)
+- `vx`, `vy` - Velocity components
+- `rotSpeed` - Rotation speed
+- `health` - Current health (decreases when hit)
+- `maxHealth` - Maximum health for this asteroid type
+- `type` - Asteroid type: "big", "medium", or "small"
+
+### Spawning Custom Asteroids:
+
+To spawn a specific asteroid type, set these values in `sysData` before calling the spawn script:
+- `spawnAsteroidType` - "big", "medium", or "small" (defaults to "big")
+- `spawnAsteroidX`, `spawnAsteroidY` - Optional spawn position
+- `spawnAsteroidVX`, `spawnAsteroidVY` - Optional velocity
+
 ## Next Steps for Full Game
 
 ### TODO:
@@ -135,13 +183,14 @@ All bullet data stored in `sysData`:
 5. ✅ Player ship thrust (up arrow)
 6. ✅ Player velocity/momentum
 7. ✅ Shooting bullets (spacebar with fire rate limiting)
-8. ⬜ Collision detection (bullets vs asteroids, player vs asteroids)
-9. ⬜ Asteroid splitting (large → 2 medium → 2 small)
-10. ⬜ Score tracking
-11. ⬜ Lives system
-12. ⬜ Game over/win conditions
-13. ⬜ Different textures for different sized asteroids
-14. ⬜ Sound effects
+8. ✅ Collision detection (bullets vs asteroids)
+9. ✅ Asteroid health system and splitting (big(3hp) → 2 medium(2hp) → 2 small(1hp))
+10. ⬜ Collision detection (player vs asteroids)
+11. ⬜ Score tracking
+12. ⬜ Lives system
+13. ⬜ Game over/win conditions
+14. ⬜ Different textures for different sized asteroids
+15. ⬜ Sound effects
 
 ## Module Usage
 
@@ -151,6 +200,7 @@ The spawn script uses these modules:
 - `ecs` - For entity management
 - `math` - For trigonometry (sin, cos, sqrt)
 - `random` - For random number generation
+- `algorithm` - For utility functions like `contain()` to check if keys exist in tables
 
 ## How Asteroid Data is Stored
 

res/asteroid/bullet_asteroid_collision.pg

@@ -1,14 +1,130 @@
 import "ecs"
 import "string"
+import "math"
+import "random"
+import "texture"
+import "algorithm"
 
 // This script is called when a Bullet and an Asteroid collide
-// ent1 and ent2 are automatically provided by the collision system
+// Need to detect which entity is which since order can vary
 
-// Log the collision
-logInfo("Collision! Bullet " + toString(ent1.__entityId) + " hit asteroid " + toString(ent2.__entityId))
+// Detect which entity is the bullet and which is the asteroid
+var bullet = 0
+var asteroid = 0
 
-// Remove both entities
-removeEntity(ent1.__entityId)
-removeEntity(ent2.__entityId)
+if (contain(ent1, "Bullet"))
+{
+    bullet = ent1
+    asteroid = ent2
+}
+else
+{
+    bullet = ent2
+    asteroid = ent1
+}
 
-logInfo("Both entities destroyed")
+logInfo("Collision! Bullet " + toString(bullet.__entityId) + " hit asteroid " + toString(asteroid.__entityId))
+
+// Always remove the bullet
+removeEntity(bullet.__entityId)
+
+// Get asteroid data
+var asteroidData = asteroid["Asteroid"]
+var currentHealth = asteroidData.health
+var asteroidType = asteroidData.type
+
+logInfo("Asteroid type: " + asteroidType + ", Health before hit: " + toString(currentHealth))
+
+// Reduce health by 1
+currentHealth = currentHealth - 1
+
+if (currentHealth <= 0)
+{
+    logInfo("Asteroid health depleted")
+
+    debugTable(asteroid)
+
+    var pos = asteroid["PositionComponent"]
+    var asteroidX = pos.x
+    var asteroidY = pos.y
+    var parentVX = asteroidData.vx
+    var parentVY = asteroidData.vy
+
+    // Remove the destroyed asteroid
+    removeEntity(asteroid.__entityId)
+
+    // Asteroid is destroyed - spawn smaller asteroids if applicable
+    logInfo("Asteroid destroyed!")
+
+    // Spawn 2 smaller asteroids if this was big or medium
+    if (asteroidType == "big")
+    {
+        logInfo("Big asteroid destroyed - spawning 2 medium asteroids")
+
+        // Spawn first medium asteroid
+        var angle1 = randomRange(0, 6.28)
+        var speed1 = randomRange(60, 120)
+        var vx1 = cos(angle1) * speed1
+        var vy1 = sin(angle1) * speed1
+        var rotSpeed1 = randomRange(-2, 2)
+
+        var medium1 = createTexture("Ghost", 40, 40)
+        medium1["PositionComponent"].setX(asteroidX)
+        medium1["PositionComponent"].setY(asteroidY)
+        medium1.attachComp("Asteroid", "size", 40, "vx", vx1, "vy", vy1, "rotSpeed", rotSpeed1, "health", 2, "maxHealth", 2, "type", "medium")
+        medium1.attachComp("Collision")
+
+        // Spawn second medium asteroid (opposite direction)
+        var angle2 = angle1 + 3.14 + randomRange(-0.5, 0.5)
+        var speed2 = randomRange(60, 120)
+        var vx2 = cos(angle2) * speed2
+        var vy2 = sin(angle2) * speed2
+        var rotSpeed2 = randomRange(-2, 2)
+
+        var medium2 = createTexture("Ghost", 40, 40)
+        medium2["PositionComponent"].setX(asteroidX)
+        medium2["PositionComponent"].setY(asteroidY)
+        medium2.attachComp("Asteroid", "size", 40, "vx", vx2, "vy", vy2, "rotSpeed", rotSpeed2, "health", 2, "maxHealth", 2, "type", "medium")
+        medium2.attachComp("Collision")
+    }
+    else if (asteroidType == "medium")
+    {
+        logInfo("Medium asteroid destroyed - spawning 2 small asteroids")
+
+        // Spawn first small asteroid
+        var angle1 = randomRange(0, 6.28)
+        var speed1 = randomRange(80, 150)
+        var vx1 = cos(angle1) * speed1
+        var vy1 = sin(angle1) * speed1
+        var rotSpeed1 = randomRange(-2, 2)
+
+        var small1 = createTexture("Ghost", 20, 20)
+        small1["PositionComponent"].setX(asteroidX)
+        small1["PositionComponent"].setY(asteroidY)
+        small1.attachComp("Asteroid", "size", 20, "vx", vx1, "vy", vy1, "rotSpeed", rotSpeed1, "health", 1, "maxHealth", 1, "type", "small")
+        small1.attachComp("Collision")
+
+        // Spawn second small asteroid (opposite direction)
+        var angle2 = angle1 + 3.14 + randomRange(-0.5, 0.5)
+        var speed2 = randomRange(80, 150)
+        var vx2 = cos(angle2) * speed2
+        var vy2 = sin(angle2) * speed2
+        var rotSpeed2 = randomRange(-2, 2)
+
+        var small2 = createTexture("Ghost", 20, 20)
+        small2["PositionComponent"].setX(asteroidX)
+        small2["PositionComponent"].setY(asteroidY)
+        small2.attachComp("Asteroid", "size", 20, "vx", vx2, "vy", vy2, "rotSpeed", rotSpeed2, "health", 1, "maxHealth", 1, "type", "small")
+        small2.attachComp("Collision")
+    }
+    else
+    {
+        logInfo("Small asteroid destroyed - no fragments")
+    }
+}
+else
+{
+    // Asteroid still has health - just update the health value
+    logInfo("Asteroid damaged! Remaining health: " + toString(currentHealth))
+    asteroidData.setHealth(currentHealth)
+}

res/asteroid/spawn_single_asteroid.pg

@@ -3,15 +3,46 @@ import "string"
 import "ecs"
 import "math"
 import "random"
+import "algorithm"
 
 // Screen dimensions (these should match your window size)
 var screenWidth = 800
 var screenHeight = 600
 
 logInfo("Spawning new asteroid")
 
-// Create asteroid with random size
-var size = randomInt(30, 60)
+// Determine asteroid type: "big", "medium", or "small"
+// Default to "big" if no type specified in sysData
+var asteroidType = "big"
+if (contain(sysData, "spawnAsteroidType"))
+{
+    asteroidType = sysData["spawnAsteroidType"]
+}
+
+// Set size and health based on type
+var size = 60
+var health = 3
+var maxHealth = 3
+
+if (asteroidType == "big")
+{
+    size = 60
+    health = 3
+    maxHealth = 3
+}
+else if (asteroidType == "medium")
+{
+    size = 40
+    health = 2
+    maxHealth = 2
+}
+else if (asteroidType == "small")
+{
+    size = 20
+    health = 1
+    maxHealth = 1
+}
+
 var asteroid = createTexture("Ghost", size, size)
 
 // Random spawn position on screen edges
@@ -76,12 +107,42 @@ var vy = finalDirY * speed
 // Random rotation speed (in degrees per second for visual rotation)
 var rotSpeed = randomRange(-2, 2)
 
+// Allow spawning at a specific position (for when asteroids split)
+if (contain(sysData, "spawnAsteroidX") and contain(sysData, "spawnAsteroidY"))
+{
+    spawnX = sysData["spawnAsteroidX"]
+    spawnY = sysData["spawnAsteroidY"]
+    asteroid["PositionComponent"].setX(spawnX)
+    asteroid["PositionComponent"].setY(spawnY)
+
+    // Clear the position override
+    sysData.remove("spawnAsteroidX")
+    sysData.remove("spawnAsteroidY")
+}
+
+// Allow custom velocity (for when asteroids split)
+if (contain(sysData, "spawnAsteroidVX") and contain(sysData, "spawnAsteroidVY"))
+{
+    vx = sysData["spawnAsteroidVX"]
+    vy = sysData["spawnAsteroidVY"]
+
+    // Clear the velocity override
+    sysData.remove("spawnAsteroidVX")
+    sysData.remove("spawnAsteroidVY")
+}
+
 debugTable(asteroid)
 
-// Attach Asteroid component with all necessary data
-asteroid.attachComp("Asteroid", "size", size, "vx", vx, "vy", vy, "rotSpeed", rotSpeed)
+// Attach Asteroid component with all necessary data including health and type
+asteroid.attachComp("Asteroid", "size", size, "vx", vx, "vy", vy, "rotSpeed", rotSpeed, "health", health, "maxHealth", maxHealth, "type", asteroidType)
 
 asteroid.attachComp("Collision")
 
-logInfo("Asteroid spawned at (" + toString(spawnX) + ", " + toString(spawnY) + ")")
-logInfo("Velocity: (" + toString(vx) + ", " + toString(vy) + ")")
+// Clear the type override for next spawn
+if (contain(sysData, "spawnAsteroidType"))
+{
+    sysData.remove("spawnAsteroidType")
+}
+
+logInfo("Asteroid (" + asteroidType + ") spawned at (" + toString(spawnX) + ", " + toString(spawnY) + ")")
+logInfo("Velocity: (" + toString(vx) + ", " + toString(vy) + "), Health: " + toString(health) + "/" + toString(maxHealth))