From b725671dffa6fadb00d1f219bcc7f263812d6d75 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 14 Feb 2026 19:24:21 +0000
Subject: [PATCH 01/17] Initial plan


From d8d8a8750acd62f41d66cb22308dc137fa16fa9f Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 14 Feb 2026 19:26:10 +0000
Subject: [PATCH 02/17] Make drawEnemyResistanceIndicator resilient to missing
 resistance fields

Co-authored-by: Linkatplug <36280686+Linkatplug@users.noreply.github.com>
---
 js/systems/RenderSystem.js | 30 +++++++++++++++++++++---------
 1 file changed, 21 insertions(+), 9 deletions(-)

diff --git a/js/systems/RenderSystem.js b/js/systems/RenderSystem.js
index 9285e1c..30be335 100644
--- a/js/systems/RenderSystem.js
+++ b/js/systems/RenderSystem.js
@@ -318,21 +318,33 @@ class RenderSystem {
         let layerCount = 0;
 
         if (defense.shield.current > 0) {
-            const base = defense.shield.baseResistances[damageType] || 0;
-            const bonus = defense.shield.bonusResistances && defense.shield.bonusResistances[damageType] || 0;
-            totalResist += base + bonus;
+            const layerData = defense.shield;
+            const baseRes = layerData.baseResistances || layerData.resistances || {};
+            const bonusRes = layerData.bonusResistances || {};
+            const base = baseRes[damageType] || 0;
+            const bonus = bonusRes[damageType] || 0;
+            const total = base + bonus;
+            totalResist += total;
             layerCount++;
         }
         if (defense.armor.current > 0) {
-            const base = defense.armor.baseResistances[damageType] || 0;
-            const bonus = defense.armor.bonusResistances && defense.armor.bonusResistances[damageType] || 0;
-            totalResist += base + bonus;
+            const layerData = defense.armor;
+            const baseRes = layerData.baseResistances || layerData.resistances || {};
+            const bonusRes = layerData.bonusResistances || {};
+            const base = baseRes[damageType] || 0;
+            const bonus = bonusRes[damageType] || 0;
+            const total = base + bonus;
+            totalResist += total;
             layerCount++;
         }
         if (defense.structure.current > 0) {
-            const base = defense.structure.baseResistances[damageType] || 0;
-            const bonus = defense.structure.bonusResistances && defense.structure.bonusResistances[damageType] || 0;
-            totalResist += base + bonus;
+            const layerData = defense.structure;
+            const baseRes = layerData.baseResistances || layerData.resistances || {};
+            const bonusRes = layerData.bonusResistances || {};
+            const base = baseRes[damageType] || 0;
+            const bonus = bonusRes[damageType] || 0;
+            const total = base + bonus;
+            totalResist += total;
             layerCount++;
         }
 

From f76a9461a4bca3f5f452193f458650d46546df0d Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 14 Feb 2026 19:28:07 +0000
Subject: [PATCH 03/17] Apply code review feedback: remove unnecessary total
 variable

Co-authored-by: Linkatplug <36280686+Linkatplug@users.noreply.github.com>
---
 js/systems/RenderSystem.js | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/js/systems/RenderSystem.js b/js/systems/RenderSystem.js
index 30be335..3e84b3e 100644
--- a/js/systems/RenderSystem.js
+++ b/js/systems/RenderSystem.js
@@ -323,8 +323,7 @@ class RenderSystem {
             const bonusRes = layerData.bonusResistances || {};
             const base = baseRes[damageType] || 0;
             const bonus = bonusRes[damageType] || 0;
-            const total = base + bonus;
-            totalResist += total;
+            totalResist += base + bonus;
             layerCount++;
         }
         if (defense.armor.current > 0) {
@@ -333,8 +332,7 @@ class RenderSystem {
             const bonusRes = layerData.bonusResistances || {};
             const base = baseRes[damageType] || 0;
             const bonus = bonusRes[damageType] || 0;
-            const total = base + bonus;
-            totalResist += total;
+            totalResist += base + bonus;
             layerCount++;
         }
         if (defense.structure.current > 0) {
@@ -343,8 +341,7 @@ class RenderSystem {
             const bonusRes = layerData.bonusResistances || {};
             const base = baseRes[damageType] || 0;
             const bonus = bonusRes[damageType] || 0;
-            const total = base + bonus;
-            totalResist += total;
+            totalResist += base + bonus;
             layerCount++;
         }
 

From 9740fde512e37327db0220444dc20ce390bf0dc9 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 14 Feb 2026 19:45:37 +0000
Subject: [PATCH 04/17] Gate all debug logs behind COLLISION_DEBUG flag

Co-authored-by: Linkatplug <36280686+Linkatplug@users.noreply.github.com>
---
 js/systems/CollisionSystem.js | 193 +++++++++++++++++++++-------------
 1 file changed, 119 insertions(+), 74 deletions(-)

diff --git a/js/systems/CollisionSystem.js b/js/systems/CollisionSystem.js
index 0c3db4e..bdff7a6 100644
--- a/js/systems/CollisionSystem.js
+++ b/js/systems/CollisionSystem.js
@@ -3,6 +3,9 @@
  * @description Handles collision detection between entities
  */
 
+// Debug flag to control collision debug logging
+const COLLISION_DEBUG = false;
+
 // Hit cooldown constant (200ms to prevent instant melt from tick collisions)
 const HIT_COOLDOWN_MS = 200;
 
@@ -238,7 +241,9 @@ class CollisionSystem {
         const projectiles = this.world.getEntitiesByType('projectile');
 
         // 🔍 DEBUG: Log player and projectile counts
-        console.log(`[DEBUG COLLISION] Players found: ${players.length}, Projectiles found: ${projectiles.length}`);
+        if (COLLISION_DEBUG) {
+            console.log(`[DEBUG COLLISION] Players found: ${players.length}, Projectiles found: ${projectiles.length}`);
+        }
 
         for (const player of players) {
             const playerPos = player.getComponent('position');
@@ -246,27 +251,35 @@ class CollisionSystem {
             const playerHealth = player.getComponent('health');
             const playerDefense = player.getComponent('defense');
             
-            console.log(`[DEBUG COLLISION] Player entity:`, {
-                id: player.id,
-                type: player.type,
-                hasPos: !!playerPos,
-                hasCol: !!playerCol,
-                hasHealth: !!playerHealth,
-                hasDefense: !!playerDefense
-            });
+            if (COLLISION_DEBUG) {
+                console.log(`[DEBUG COLLISION] Player entity:`, {
+                    id: player.id,
+                    type: player.type,
+                    hasPos: !!playerPos,
+                    hasCol: !!playerCol,
+                    hasHealth: !!playerHealth,
+                    hasDefense: !!playerDefense
+                });
+            }
             
             if (!playerPos || !playerCol || (!playerHealth && !playerDefense)) {
-                console.log(`[DEBUG COLLISION] ❌ Player missing required components, skipping`);
+                if (COLLISION_DEBUG) {
+                    console.log(`[DEBUG COLLISION] ❌ Player missing required components, skipping`);
+                }
                 continue;
             }
             
             // BUG FIX: Check invulnerability on defense component (player uses defense, not health)
             if (playerDefense && (playerDefense.invulnerable || playerDefense.godMode)) {
-                console.log(`[DEBUG COLLISION] ❌ Player invulnerable (defense), skipping all projectiles`);
+                if (COLLISION_DEBUG) {
+                    console.log(`[DEBUG COLLISION] ❌ Player invulnerable (defense), skipping all projectiles`);
+                }
                 continue;
             }
             if (playerHealth && (playerHealth.invulnerable || playerHealth.godMode)) {
-                console.log(`[DEBUG COLLISION] ❌ Player invulnerable (health), skipping all projectiles`);
+                if (COLLISION_DEBUG) {
+                    console.log(`[DEBUG COLLISION] ❌ Player invulnerable (health), skipping all projectiles`);
+                }
                 continue;
             }
 
@@ -276,41 +289,51 @@ class CollisionSystem {
                 const projComp = projectile.getComponent('projectile');
                 
                 if (!projPos || !projCol || !projComp) {
-                    console.log(`[DEBUG COLLISION] ⚠️ Projectile ${projectile.id} missing components`);
+                    if (COLLISION_DEBUG) {
+                        console.log(`[DEBUG COLLISION] ⚠️ Projectile ${projectile.id} missing components`);
+                    }
                     continue;
                 }
                 
                 // 🔍 REQUESTED DEBUG: Log collision check details BEFORE ANY filtering
-                console.log(
-                    "[DEBUG COLLISION CHECK]",
-                    {
-                        projectileId: projectile.id,
-                        projectileOwner: projComp.owner,
-                        projectileTag: projectile.type,
-                        playerId: player.id,
-                        playerTags: player.type,
-                        projectilePos: { x: projPos.x, y: projPos.y },
-                        playerPos: { x: playerPos.x, y: playerPos.y }
-                    }
-                );
+                if (COLLISION_DEBUG) {
+                    console.log(
+                        "[DEBUG COLLISION CHECK]",
+                        {
+                            projectileId: projectile.id,
+                            projectileOwner: projComp.owner,
+                            projectileTag: projectile.type,
+                            playerId: player.id,
+                            playerTags: player.type,
+                            projectilePos: { x: projPos.x, y: projPos.y },
+                            playerPos: { x: playerPos.x, y: playerPos.y }
+                        }
+                    );
+                }
                 
                 // 🔍 DEBUG: Log projectile details BEFORE owner check
-                console.log(`[DEBUG COLLISION] Checking projectile ${projectile.id}:`, {
-                    owner: projComp.owner,
-                    damage: projComp.damage,
-                    damageType: projComp.damageType,
-                    pos: { x: projPos.x.toFixed(1), y: projPos.y.toFixed(1) }
-                });
+                if (COLLISION_DEBUG) {
+                    console.log(`[DEBUG COLLISION] Checking projectile ${projectile.id}:`, {
+                        owner: projComp.owner,
+                        damage: projComp.damage,
+                        damageType: projComp.damageType,
+                        pos: { x: projPos.x.toFixed(1), y: projPos.y.toFixed(1) }
+                    });
+                }
                 
                 // Check if projectile is from enemy (owner is an enemy entity or 'enemy' string)
                 const ownerEntity = this.world.getEntity(projComp.owner);
-                console.log(`[DEBUG COLLISION] Owner entity lookup for ${projComp.owner}:`, {
-                    found: !!ownerEntity,
-                    type: ownerEntity?.type
-                });
+                if (COLLISION_DEBUG) {
+                    console.log(`[DEBUG COLLISION] Owner entity lookup for ${projComp.owner}:`, {
+                        found: !!ownerEntity,
+                        type: ownerEntity?.type
+                    });
+                }
                 
                 if (!ownerEntity || ownerEntity.type !== 'enemy') {
-                    console.log(`[DEBUG COLLISION] ❌ Projectile ${projectile.id} not from enemy, skipping`);
+                    if (COLLISION_DEBUG) {
+                        console.log(`[DEBUG COLLISION] ❌ Projectile ${projectile.id} not from enemy, skipping`);
+                    }
                     continue;
                 }
                 
@@ -321,26 +344,32 @@ class CollisionSystem {
                 const collisionThreshold = playerCol.radius + projCol.radius;
                 
                 // 🔍 REQUESTED DEBUG: Log distance and radius details
-                console.log(
-                    "[DEBUG DISTANCE]",
-                    {
-                        distance: distance,
-                        projectileRadius: projCol.radius,
-                        playerRadius: playerCol.radius,
-                        sum: projCol.radius + playerCol.radius
-                    }
-                );
+                if (COLLISION_DEBUG) {
+                    console.log(
+                        "[DEBUG DISTANCE]",
+                        {
+                            distance: distance,
+                            projectileRadius: projCol.radius,
+                            playerRadius: playerCol.radius,
+                            sum: projCol.radius + playerCol.radius
+                        }
+                    );
+                }
                 
-                console.log(`[DEBUG COLLISION] Distance check:`, {
-                    distance: distance.toFixed(1),
-                    threshold: collisionThreshold.toFixed(1),
-                    willCollide: distance <= collisionThreshold
-                });
+                if (COLLISION_DEBUG) {
+                    console.log(`[DEBUG COLLISION] Distance check:`, {
+                        distance: distance.toFixed(1),
+                        threshold: collisionThreshold.toFixed(1),
+                        willCollide: distance <= collisionThreshold
+                    });
+                }
                 
                 // FIX: Check hit cooldown for this projectile
                 const sourceId = `projectile_${projectile.id}`;
                 if (this.hitCooldowns.has(sourceId)) {
-                    console.log(`[DEBUG COLLISION] ❌ Projectile ${projectile.id} on cooldown, skipping`);
+                    if (COLLISION_DEBUG) {
+                        console.log(`[DEBUG COLLISION] ❌ Projectile ${projectile.id} on cooldown, skipping`);
+                    }
                     continue; // Still on cooldown
                 }
 
@@ -348,8 +377,10 @@ class CollisionSystem {
                     playerPos.x, playerPos.y, playerCol.radius,
                     projPos.x, projPos.y, projCol.radius
                 )) {
-                    console.log(`[DEBUG COLLISION] ✅ COLLISION DETECTED! Projectile ${projectile.id} hit player ${player.id}`);
-                    console.log(`[DEBUG COLLISION] ✅ COLLISION DETECTED! Projectile ${projectile.id} hit player ${player.id}`);
+                    if (COLLISION_DEBUG) {
+                        console.log(`[DEBUG COLLISION] ✅ COLLISION DETECTED! Projectile ${projectile.id} hit player ${player.id}`);
+                        console.log(`[DEBUG COLLISION] ✅ COLLISION DETECTED! Projectile ${projectile.id} hit player ${player.id}`);
+                    }
                     
                     // Check hit cooldown to prevent instant melt from tick collisions
                     const now = performance.now();
@@ -360,20 +391,26 @@ class CollisionSystem {
                     const lastHitTime = this.hitCooldowns.get(cooldownKey) || 0;
                     const timeSinceLastHit = now - lastHitTime;
                     
-                    console.log(`[DEBUG COLLISION] Hit cooldown check:`, {
-                        cooldownKey,
-                        timeSinceLastHit: timeSinceLastHit.toFixed(0),
-                        cooldownThreshold: HIT_COOLDOWN_MS,
-                        willDamage: timeSinceLastHit >= HIT_COOLDOWN_MS
-                    });
+                    if (COLLISION_DEBUG) {
+                        console.log(`[DEBUG COLLISION] Hit cooldown check:`, {
+                            cooldownKey,
+                            timeSinceLastHit: timeSinceLastHit.toFixed(0),
+                            cooldownThreshold: HIT_COOLDOWN_MS,
+                            willDamage: timeSinceLastHit >= HIT_COOLDOWN_MS
+                        });
+                    }
                     
                     if (timeSinceLastHit < HIT_COOLDOWN_MS) {
                         // Still in cooldown, ignore this hit
-                        console.log(`[DEBUG COLLISION] ❌ Hit cooldown active, ignoring damage`);
+                        if (COLLISION_DEBUG) {
+                            console.log(`[DEBUG COLLISION] ❌ Hit cooldown active, ignoring damage`);
+                        }
                         logger.debug('Collision', `Hit cooldown active (${timeSinceLastHit.toFixed(0)}ms < ${HIT_COOLDOWN_MS}ms) - ignoring damage`);
                     } else {
                         // Cooldown expired or first hit, deal damage
-                        console.log(`[DEBUG COLLISION] ✅ Calling damagePlayer() with damage: ${projComp.damage}, type: ${damageType}`);
+                        if (COLLISION_DEBUG) {
+                            console.log(`[DEBUG COLLISION] ✅ Calling damagePlayer() with damage: ${projComp.damage}, type: ${damageType}`);
+                        }
                         this.damagePlayer(player, projComp.damage, damageType);
                         
                         // Update cooldown timestamp
@@ -470,22 +507,26 @@ class CollisionSystem {
     }
 
     damagePlayer(player, damage, damageType = 'kinetic') {
-        console.log(`[DEBUG DAMAGE] damagePlayer() called:`, {
-            playerId: player?.id,
-            damage,
-            damageType
-        });
+        if (COLLISION_DEBUG) {
+            console.log(`[DEBUG DAMAGE] damagePlayer() called:`, {
+                playerId: player?.id,
+                damage,
+                damageType
+            });
+        }
         
         const playerComp = player.getComponent('player');
         const defense = player.getComponent('defense');
         const health = player.getComponent('health');
         
-        console.log(`[DEBUG DAMAGE] Player components:`, {
-            hasPlayerComp: !!playerComp,
-            hasDefense: !!defense,
-            hasHealth: !!health,
-            defenseSystemExists: !!(this.world && this.world.defenseSystem)
-        });
+        if (COLLISION_DEBUG) {
+            console.log(`[DEBUG DAMAGE] Player components:`, {
+                hasPlayerComp: !!playerComp,
+                hasDefense: !!defense,
+                hasHealth: !!health,
+                defenseSystemExists: !!(this.world && this.world.defenseSystem)
+            });
+        }
         
         if (!playerComp) {
             console.error('[CollisionSystem] damagePlayer: Missing player component');
@@ -503,11 +544,15 @@ class CollisionSystem {
         // Apply damage through DefenseSystem (the only authority for defense modifications)
         // Use DamagePacket for proper structure
         if (defense && this.world && this.world.defenseSystem) {
-            console.log(`[DEBUG DAMAGE] Calling DefenseSystem.applyDamage()...`);
+            if (COLLISION_DEBUG) {
+                console.log(`[DEBUG DAMAGE] Calling DefenseSystem.applyDamage()...`);
+            }
             const damagePacket = DamagePacket.simple(damage, damageType);
             const result = this.world.defenseSystem.applyDamage(player, damagePacket);
             
-            console.log(`[DEBUG DAMAGE] DefenseSystem.applyDamage() result:`, result);
+            if (COLLISION_DEBUG) {
+                console.log(`[DEBUG DAMAGE] DefenseSystem.applyDamage() result:`, result);
+            }
             
             // Validate result
             if (!result || typeof result.dealt !== 'number') {

From cd11c4a87838c4f66e173a532079745c678ad53f Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 14 Feb 2026 20:07:56 +0000
Subject: [PATCH 05/17] Add Combat Dev Sandbox page for testing combat
 mechanics

Co-authored-by: Linkatplug <36280686+Linkatplug@users.noreply.github.com>
---
 dev/test-combat-sandbox.html | 749 +++++++++++++++++++++++++++++++++++
 1 file changed, 749 insertions(+)
 create mode 100644 dev/test-combat-sandbox.html

diff --git a/dev/test-combat-sandbox.html b/dev/test-combat-sandbox.html
new file mode 100644
index 0000000..5ef5fe0
--- /dev/null
+++ b/dev/test-combat-sandbox.html
@@ -0,0 +1,749 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Combat Dev Sandbox</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Courier New', monospace;
+            background: #0a0a0a;
+            color: #00ff00;
+            overflow: hidden;
+        }
+
+        #topBar {
+            background: #1a1a1a;
+            border-bottom: 2px solid #00ff00;
+            padding: 10px 20px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            flex-wrap: wrap;
+            gap: 10px;
+        }
+
+        h1 {
+            color: #00ff00;
+            text-shadow: 0 0 10px #00ff00;
+            font-size: 1.5em;
+            margin: 0;
+        }
+
+        #gameContainer {
+            position: relative;
+            width: 100%;
+            height: calc(100vh - 220px);
+            background: #000;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+        }
+
+        #gameCanvas {
+            border: 2px solid #00ff00;
+            box-shadow: 0 0 20px rgba(0, 255, 0, 0.3);
+        }
+
+        #controlPanel {
+            background: #1a1a1a;
+            border-top: 2px solid #00ff00;
+            padding: 15px 20px;
+            display: grid;
+            grid-template-columns: 1fr 1fr 1fr;
+            gap: 15px;
+        }
+
+        .panel-section {
+            background: #0f0f0f;
+            border: 1px solid #00ff00;
+            border-radius: 4px;
+            padding: 10px;
+        }
+
+        .panel-section h3 {
+            color: #00ffff;
+            font-size: 0.9em;
+            margin-bottom: 10px;
+            border-bottom: 1px solid #00ff00;
+            padding-bottom: 5px;
+        }
+
+        .button-group {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 5px;
+        }
+
+        button {
+            background: #1a1a1a;
+            color: #00ff00;
+            border: 2px solid #00ff00;
+            padding: 8px 12px;
+            font-family: 'Courier New', monospace;
+            font-size: 0.85em;
+            cursor: pointer;
+            border-radius: 4px;
+            transition: all 0.2s;
+            flex: 1;
+            min-width: 100px;
+        }
+
+        button:hover {
+            background: #00ff00;
+            color: #000;
+            box-shadow: 0 0 10px #00ff00;
+        }
+
+        button:active {
+            transform: scale(0.95);
+        }
+
+        .stat-row {
+            display: flex;
+            justify-content: space-between;
+            padding: 4px 0;
+            font-size: 0.85em;
+        }
+
+        .stat-label {
+            color: #888;
+        }
+
+        .stat-value {
+            color: #00ff00;
+            font-weight: bold;
+        }
+
+        .toggle-group {
+            display: flex;
+            flex-direction: column;
+            gap: 5px;
+        }
+
+        .toggle-item {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            padding: 5px;
+            background: #0a0a0a;
+            border-radius: 3px;
+        }
+
+        .toggle-item label {
+            font-size: 0.85em;
+        }
+
+        .toggle-button {
+            min-width: 60px;
+            padding: 4px 8px;
+            font-size: 0.75em;
+        }
+
+        .toggle-button.active {
+            background: #00ff00;
+            color: #000;
+        }
+
+        .layer-display {
+            font-size: 0.85em;
+            padding: 3px 0;
+        }
+
+        .layer-name {
+            color: #ffaa00;
+            display: inline-block;
+            width: 70px;
+        }
+
+        .layer-hp {
+            color: #00ff00;
+        }
+    </style>
+</head>
+<body>
+    <div id="topBar">
+        <h1>⚔️ Combat Dev Sandbox</h1>
+        <div style="color: #888; font-size: 0.9em;">Press WASD to move • Click to fire</div>
+    </div>
+
+    <div id="gameContainer">
+        <canvas id="gameCanvas" width="1280" height="720"></canvas>
+    </div>
+
+    <div id="controlPanel">
+        <div class="panel-section">
+            <h3>Spawn Controls</h3>
+            <div class="button-group">
+                <button onclick="spawnScout(1)">Spawn 1 Scout</button>
+                <button onclick="spawnScout(5)">Spawn 5 Scouts</button>
+                <button onclick="spawnElite()">Spawn 1 Elite</button>
+                <button onclick="clearEnemies()">Clear All Enemies</button>
+                <button onclick="resetPlayer()">Reset Player HP</button>
+            </div>
+        </div>
+
+        <div class="panel-section">
+            <h3>Player Status</h3>
+            <div id="playerStats">
+                <div class="layer-display">
+                    <span class="layer-name">Shield:</span>
+                    <span class="layer-hp" id="shieldHP">0/0</span>
+                </div>
+                <div class="layer-display">
+                    <span class="layer-name">Armor:</span>
+                    <span class="layer-hp" id="armorHP">0/0</span>
+                </div>
+                <div class="layer-display">
+                    <span class="layer-name">Structure:</span>
+                    <span class="layer-hp" id="structureHP">0/0</span>
+                </div>
+                <div class="stat-row">
+                    <span class="stat-label">Total HP:</span>
+                    <span class="stat-value" id="totalHP">0/0</span>
+                </div>
+                <div class="stat-row">
+                    <span class="stat-label">Enemies:</span>
+                    <span class="stat-value" id="enemyCount">0</span>
+                </div>
+            </div>
+        </div>
+
+        <div class="panel-section">
+            <h3>Combat Stats & Debug</h3>
+            <div class="stat-row">
+                <span class="stat-label">Shots/sec:</span>
+                <span class="stat-value" id="shotsPerSec">0</span>
+            </div>
+            <div class="stat-row">
+                <span class="stat-label">Damage/sec:</span>
+                <span class="stat-value" id="damagePerSec">0</span>
+            </div>
+            <div class="toggle-group" style="margin-top: 10px;">
+                <div class="toggle-item">
+                    <label>Combat Debug:</label>
+                    <button class="toggle-button" id="combatDebugBtn" onclick="toggleCombatDebug()">OFF</button>
+                </div>
+                <div class="toggle-item">
+                    <label>Defense Debug:</label>
+                    <button class="toggle-button" id="defenseDebugBtn" onclick="toggleDefenseDebug()">OFF</button>
+                </div>
+                <div class="toggle-item">
+                    <label>Collision Debug:</label>
+                    <button class="toggle-button" id="collisionDebugBtn" onclick="toggleCollisionDebug()">OFF</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Core Systems -->
+    <script src="../js/utils/Math.js"></script>
+    <script src="../js/utils/Logger.js"></script>
+    <script src="../js/core/ECS.js"></script>
+    <script src="../js/core/GameState.js"></script>
+    <script src="../js/core/stats/ShipStats.js"></script>
+    
+    <!-- Data -->
+    <script src="../js/data/DefenseData.js"></script>
+    <script src="../js/data/EnemyProfiles.js"></script>
+    <script src="../js/data/ShipData.js"></script>
+    <script src="../js/data/NewWeaponData.js"></script>
+    
+    <!-- Systems -->
+    <script src="../js/systems/DefenseSystem.js"></script>
+    <script src="../js/systems/AISystem.js"></script>
+    <script src="../js/systems/CollisionSystem.js"></script>
+    <script src="../js/systems/CombatSystem.js"></script>
+    <script src="../js/systems/MovementSystem.js"></script>
+
+    <script>
+        // Global state
+        let world, player, systems;
+        let canvas, ctx;
+        let lastTime = 0;
+        let running = false;
+        
+        // Stats tracking
+        let shotsFired = 0;
+        let damageTaken = 0;
+        let lastStatsUpdate = 0;
+        let shotsPerSecond = 0;
+        let damagePerSecond = 0;
+        
+        // Debug flags
+        let combatDebug = false;
+        let defenseDebug = false;
+        let collisionDebug = false;
+        
+        // Use global logger (already initialized by Logger.js)
+        if (typeof logger !== 'undefined') {
+            logger.enabled = false; // Keep quiet by default
+        }
+        
+        // Initialize the sandbox
+        function init() {
+            console.log('[Sandbox] Initializing Combat Dev Sandbox...');
+            
+            // Setup canvas
+            canvas = document.getElementById('gameCanvas');
+            ctx = canvas.getContext('2d');
+            
+            // Create ECS world
+            world = new World();
+            
+            // Initialize systems
+            const gameState = new GameState();
+            
+            systems = {
+                defense: new DefenseSystem(world),
+                ai: new AISystem(world, canvas),
+                collision: new CollisionSystem(world, gameState, null, null),
+                combat: new CombatSystem(world, gameState, null),
+                movement: new MovementSystem(world, canvas)
+            };
+            
+            // Link defense system to world for access by other systems
+            world.defenseSystem = systems.defense;
+            
+            // Create player
+            createPlayer();
+            
+            // Setup input
+            setupInput();
+            
+            // Start game loop
+            running = true;
+            requestAnimationFrame(gameLoop);
+            
+            console.log('[Sandbox] Initialization complete');
+        }
+        
+        // Create player entity
+        function createPlayer() {
+            player = world.createEntity('player');
+            
+            // Position at center
+            player.addComponent('position', Components.Position(
+                canvas.width / 2,
+                canvas.height / 2
+            ));
+            
+            player.addComponent('velocity', Components.Velocity(0, 0));
+            player.addComponent('collision', Components.Collision(15));
+            
+            // Get ship data
+            const shipInfo = window.ShipData?.SHIPS?.['ION_FRIGATE'];
+            
+            // Setup defense layers
+            const layerResistances = window.DefenseData?.LAYER_RESISTANCES || {
+                shield: { em: 0, thermal: 0.2, kinetic: 0.4, explosive: 0.5 },
+                armor: { em: 0.5, thermal: 0.35, kinetic: 0.25, explosive: 0.1 },
+                structure: { em: 0.3, thermal: 0, kinetic: 0.15, explosive: 0.2 }
+            };
+            
+            const defense = {
+                shield: {
+                    current: shipInfo?.baseStats?.maxShield || 150,
+                    max: shipInfo?.baseStats?.maxShield || 150,
+                    regen: shipInfo?.baseStats?.shieldRegen || 8,
+                    regenDelay: 0,
+                    regenDelayMax: 3,
+                    resistances: { ...layerResistances.shield }
+                },
+                armor: {
+                    current: shipInfo?.baseStats?.maxArmor || 120,
+                    max: shipInfo?.baseStats?.maxArmor || 120,
+                    regen: 0,
+                    regenDelay: 0,
+                    regenDelayMax: 0,
+                    resistances: { ...layerResistances.armor }
+                },
+                structure: {
+                    current: shipInfo?.baseStats?.maxStructure || 100,
+                    max: shipInfo?.baseStats?.maxStructure || 100,
+                    regen: 0.5,
+                    regenDelay: 0,
+                    regenDelayMax: 0,
+                    resistances: { ...layerResistances.structure }
+                }
+            };
+            
+            player.addComponent('defense', defense);
+            
+            // Add player component
+            const playerComp = {
+                speed: 250,
+                level: 1,
+                currentWeapon: {
+                    damageType: 'kinetic',
+                    damage: 10,
+                    fireRate: 0.2
+                },
+                lastFireTime: 0,
+                stats: {
+                    speed: 1,
+                    damage: 1,
+                    fireRate: 1
+                }
+            };
+            
+            player.addComponent('player', playerComp);
+            
+            // Add renderable
+            player.addComponent('renderable', {
+                color: '#00ffff',
+                size: 15,
+                shape: 'triangle'
+            });
+            
+            console.log('[Sandbox] Player created');
+        }
+        
+        // Spawn enemies
+        function spawnScout(count = 1) {
+            console.log(`[Sandbox] Spawning ${count} scout(s)`);
+            
+            for (let i = 0; i < count; i++) {
+                const profile = window.EnemyProfiles.PROFILES.SCOUT_DRONE;
+                const angle = Math.random() * Math.PI * 2;
+                const distance = 300 + Math.random() * 200;
+                const x = canvas.width / 2 + Math.cos(angle) * distance;
+                const y = canvas.height / 2 + Math.sin(angle) * distance;
+                
+                const enemy = world.createEntity('enemy');
+                enemy.addComponent('position', Components.Position(x, y));
+                enemy.addComponent('velocity', Components.Velocity(0, 0));
+                enemy.addComponent('collision', Components.Collision(profile.size));
+                
+                // Create defense
+                const defense = window.EnemyProfiles.createEnemyDefense(profile);
+                enemy.addComponent('defense', defense);
+                
+                // Enemy component
+                const enemyComp = {
+                    type: profile.aiType,
+                    speed: profile.speed,
+                    damage: 10,
+                    attackCooldown: 0,
+                    attackPattern: {
+                        type: 'shoot',
+                        cooldown: 2.0,
+                        range: 300,
+                        damage: 8
+                    }
+                };
+                enemy.addComponent('enemy', enemyComp);
+                
+                // Renderable
+                enemy.addComponent('renderable', {
+                    color: profile.color,
+                    size: profile.size,
+                    shape: 'circle'
+                });
+            }
+            
+            updateStats();
+        }
+        
+        function spawnElite() {
+            console.log('[Sandbox] Spawning elite');
+            
+            const profile = window.EnemyProfiles.PROFILES.SIEGE_HULK;
+            const angle = Math.random() * Math.PI * 2;
+            const distance = 400;
+            const x = canvas.width / 2 + Math.cos(angle) * distance;
+            const y = canvas.height / 2 + Math.sin(angle) * distance;
+            
+            const enemy = world.createEntity('enemy');
+            enemy.addComponent('position', Components.Position(x, y));
+            enemy.addComponent('velocity', Components.Velocity(0, 0));
+            enemy.addComponent('collision', Components.Collision(profile.size));
+            
+            // Create defense
+            const defense = window.EnemyProfiles.createEnemyDefense(profile);
+            enemy.addComponent('defense', defense);
+            
+            // Enemy component
+            const enemyComp = {
+                type: profile.aiType,
+                speed: profile.speed,
+                damage: 15,
+                attackCooldown: 0,
+                attackPattern: {
+                    type: 'special',
+                    cooldown: 1.5,
+                    range: 350,
+                    damage: 12
+                }
+            };
+            enemy.addComponent('enemy', enemyComp);
+            
+            // Renderable
+            enemy.addComponent('renderable', {
+                color: profile.color,
+                size: profile.size,
+                shape: 'circle'
+            });
+            
+            updateStats();
+        }
+        
+        function clearEnemies() {
+            console.log('[Sandbox] Clearing all enemies');
+            const enemies = world.getEntitiesByType('enemy');
+            enemies.forEach(enemy => world.removeEntity(enemy.id));
+            updateStats();
+        }
+        
+        function resetPlayer() {
+            console.log('[Sandbox] Resetting player HP');
+            const defense = player.getComponent('defense');
+            if (defense) {
+                defense.shield.current = defense.shield.max;
+                defense.armor.current = defense.armor.max;
+                defense.structure.current = defense.structure.max;
+                defense.shield.regenDelay = 0;
+                defense.armor.regenDelay = 0;
+                defense.structure.regenDelay = 0;
+            }
+            updateStats();
+        }
+        
+        // Debug toggles
+        function toggleCombatDebug() {
+            combatDebug = !combatDebug;
+            const btn = document.getElementById('combatDebugBtn');
+            btn.textContent = combatDebug ? 'ON' : 'OFF';
+            btn.classList.toggle('active', combatDebug);
+            console.log('[Sandbox] Combat debug:', combatDebug);
+        }
+        
+        function toggleDefenseDebug() {
+            defenseDebug = !defenseDebug;
+            const btn = document.getElementById('defenseDebugBtn');
+            btn.textContent = defenseDebug ? 'ON' : 'OFF';
+            btn.classList.toggle('active', defenseDebug);
+            console.log('[Sandbox] Defense debug:', defenseDebug);
+        }
+        
+        function toggleCollisionDebug() {
+            collisionDebug = !collisionDebug;
+            const btn = document.getElementById('collisionDebugBtn');
+            btn.textContent = collisionDebug ? 'ON' : 'OFF';
+            btn.classList.toggle('active', collisionDebug);
+            console.log('[Sandbox] Collision debug:', collisionDebug);
+        }
+        
+        // Input handling
+        const keys = {};
+        
+        function setupInput() {
+            document.addEventListener('keydown', (e) => {
+                keys[e.key.toLowerCase()] = true;
+            });
+            
+            document.addEventListener('keyup', (e) => {
+                keys[e.key.toLowerCase()] = false;
+            });
+            
+            canvas.addEventListener('click', (e) => {
+                firePlayerWeapon();
+            });
+        }
+        
+        function firePlayerWeapon() {
+            const playerComp = player.getComponent('player');
+            const now = performance.now() / 1000;
+            
+            if (now - playerComp.lastFireTime < playerComp.currentWeapon.fireRate) {
+                return;
+            }
+            
+            playerComp.lastFireTime = now;
+            shotsFired++;
+            
+            // Create projectile
+            const pos = player.getComponent('position');
+            const projectile = world.createEntity('projectile');
+            
+            const angle = Math.random() * Math.PI * 2; // Random direction for demo
+            const speed = 400;
+            
+            projectile.addComponent('position', Components.Position(pos.x, pos.y));
+            projectile.addComponent('velocity', Components.Velocity(
+                Math.cos(angle) * speed,
+                Math.sin(angle) * speed
+            ));
+            projectile.addComponent('collision', Components.Collision(5));
+            projectile.addComponent('renderable', {
+                color: '#ffff00',
+                size: 5,
+                shape: 'circle'
+            });
+            projectile.addComponent('projectile', {
+                damage: playerComp.currentWeapon.damage,
+                lifetime: 3,
+                owner: player.id,
+                damageType: playerComp.currentWeapon.damageType
+            });
+        }
+        
+        // Update stats display
+        function updateStats() {
+            const defense = player.getComponent('defense');
+            if (defense) {
+                document.getElementById('shieldHP').textContent = 
+                    `${Math.ceil(defense.shield.current)}/${defense.shield.max}`;
+                document.getElementById('armorHP').textContent = 
+                    `${Math.ceil(defense.armor.current)}/${defense.armor.max}`;
+                document.getElementById('structureHP').textContent = 
+                    `${Math.ceil(defense.structure.current)}/${defense.structure.max}`;
+                
+                const totalCurrent = defense.shield.current + defense.armor.current + defense.structure.current;
+                const totalMax = defense.shield.max + defense.armor.max + defense.structure.max;
+                document.getElementById('totalHP').textContent = 
+                    `${Math.ceil(totalCurrent)}/${totalMax}`;
+            }
+            
+            const enemies = world.getEntitiesByType('enemy');
+            document.getElementById('enemyCount').textContent = enemies.length;
+        }
+        
+        // Track damage taken
+        function trackDamage(amount) {
+            damageTaken += amount;
+        }
+        
+        // Main game loop
+        function gameLoop(timestamp) {
+            if (!running) return;
+            
+            const deltaTime = lastTime ? (timestamp - lastTime) / 1000 : 0;
+            lastTime = timestamp;
+            
+            // Clamp deltaTime to prevent large jumps
+            const dt = Math.min(deltaTime, 0.1);
+            
+            // Handle player movement
+            const vel = player.getComponent('velocity');
+            const playerComp = player.getComponent('player');
+            if (vel && playerComp) {
+                vel.vx = 0;
+                vel.vy = 0;
+                
+                if (keys['w'] || keys['arrowup']) vel.vy = -playerComp.speed;
+                if (keys['s'] || keys['arrowdown']) vel.vy = playerComp.speed;
+                if (keys['a'] || keys['arrowleft']) vel.vx = -playerComp.speed;
+                if (keys['d'] || keys['arrowright']) vel.vx = playerComp.speed;
+            }
+            
+            // Update systems
+            systems.movement.update(dt);
+            systems.ai.update(dt);
+            systems.defense.update(dt);
+            systems.collision.update(dt);
+            
+            // Update projectile lifetimes
+            const projectiles = world.getEntitiesByType('projectile');
+            projectiles.forEach(proj => {
+                const projComp = proj.getComponent('projectile');
+                if (projComp) {
+                    projComp.lifetime -= dt;
+                    if (projComp.lifetime <= 0) {
+                        world.removeEntity(proj.id);
+                    }
+                }
+            });
+            
+            // Render
+            render();
+            
+            // Update stats every second
+            if (timestamp - lastStatsUpdate > 1000) {
+                shotsPerSecond = shotsFired;
+                damagePerSecond = Math.ceil(damageTaken);
+                shotsFired = 0;
+                damageTaken = 0;
+                lastStatsUpdate = timestamp;
+                
+                document.getElementById('shotsPerSec').textContent = shotsPerSecond;
+                document.getElementById('damagePerSec').textContent = damagePerSecond;
+                
+                updateStats();
+            }
+            
+            requestAnimationFrame(gameLoop);
+        }
+        
+        // Render function
+        function render() {
+            // Clear canvas
+            ctx.fillStyle = '#000';
+            ctx.fillRect(0, 0, canvas.width, canvas.height);
+            
+            // Render all entities
+            const allEntities = [...world.entities.values()];
+            
+            allEntities.forEach(entity => {
+                const pos = entity.getComponent('position');
+                const renderable = entity.getComponent('renderable');
+                
+                if (!pos || !renderable) return;
+                
+                ctx.save();
+                ctx.fillStyle = renderable.color;
+                ctx.strokeStyle = renderable.color;
+                ctx.lineWidth = 2;
+                
+                if (renderable.shape === 'circle') {
+                    ctx.beginPath();
+                    ctx.arc(pos.x, pos.y, renderable.size, 0, Math.PI * 2);
+                    ctx.fill();
+                } else if (renderable.shape === 'triangle') {
+                    ctx.beginPath();
+                    ctx.moveTo(pos.x, pos.y - renderable.size);
+                    ctx.lineTo(pos.x - renderable.size, pos.y + renderable.size);
+                    ctx.lineTo(pos.x + renderable.size, pos.y + renderable.size);
+                    ctx.closePath();
+                    ctx.fill();
+                }
+                
+                // Draw collision radius in debug mode
+                if (collisionDebug) {
+                    const collision = entity.getComponent('collision');
+                    if (collision) {
+                        ctx.strokeStyle = '#ff00ff';
+                        ctx.beginPath();
+                        ctx.arc(pos.x, pos.y, collision.radius, 0, Math.PI * 2);
+                        ctx.stroke();
+                    }
+                }
+                
+                ctx.restore();
+            });
+            
+            // Debug info
+            if (defenseDebug) {
+                ctx.fillStyle = '#00ff00';
+                ctx.font = '12px monospace';
+                ctx.fillText(`Defense System Active`, 10, 20);
+            }
+            
+            if (combatDebug) {
+                ctx.fillStyle = '#ff0000';
+                ctx.font = '12px monospace';
+                ctx.fillText(`Combat Debug Active`, 10, 40);
+            }
+        }
+        
+        // Start on load
+        window.addEventListener('load', init);
+    </script>
+</body>
+</html>

From a4805a8b1aad3c8717ac3a8cb1a4c3978822f516 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 14 Feb 2026 20:22:01 +0000
Subject: [PATCH 06/17] Fix Combat Loop and System Wiring in Combat Dev Sandbox

Co-authored-by: Linkatplug <36280686+Linkatplug@users.noreply.github.com>
---
 dev/test-combat-sandbox.html | 22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/dev/test-combat-sandbox.html b/dev/test-combat-sandbox.html
index 5ef5fe0..b9b67d7 100644
--- a/dev/test-combat-sandbox.html
+++ b/dev/test-combat-sandbox.html
@@ -300,6 +300,10 @@ <h3>Combat Stats & Debug</h3>
             // Initialize systems
             const gameState = new GameState();
             
+            // Configure GameState minimally
+            gameState.isPaused = false;
+            gameState.isGameOver = false;
+            
             systems = {
                 defense: new DefenseSystem(world),
                 ai: new AISystem(world, canvas),
@@ -317,6 +321,15 @@ <h3>Combat Stats & Debug</h3>
             // Setup input
             setupInput();
             
+            // Wrap DefenseSystem.applyDamage to track player damage
+            const originalApplyDamage = systems.defense.applyDamage.bind(systems.defense);
+            systems.defense.applyDamage = function(entity, damagePacket) {
+                if (entity === player) {
+                    damageTaken += damagePacket.amount || damagePacket.damage || 0;
+                }
+                return originalApplyDamage(entity, damagePacket);
+            };
+            
             // Start game loop
             running = true;
             requestAnimationFrame(gameLoop);
@@ -380,6 +393,7 @@ <h3>Combat Stats & Debug</h3>
             const playerComp = {
                 speed: 250,
                 level: 1,
+                weapons: [], // Empty weapons array for CombatSystem
                 currentWeapon: {
                     damageType: 'kinetic',
                     damage: 10,
@@ -498,6 +512,7 @@ <h3>Combat Stats & Debug</h3>
             console.log('[Sandbox] Clearing all enemies');
             const enemies = world.getEntitiesByType('enemy');
             enemies.forEach(enemy => world.removeEntity(enemy.id));
+            world.processPendingRemovals();
             updateStats();
         }
         
@@ -512,6 +527,7 @@ <h3>Combat Stats & Debug</h3>
                 defense.armor.regenDelay = 0;
                 defense.structure.regenDelay = 0;
             }
+            world.processPendingRemovals();
             updateStats();
         }
         
@@ -643,12 +659,16 @@ <h3>Combat Stats & Debug</h3>
                 if (keys['d'] || keys['arrowright']) vel.vx = playerComp.speed;
             }
             
-            // Update systems
+            // Update systems (correct order)
             systems.movement.update(dt);
             systems.ai.update(dt);
+            systems.combat.update(dt);
             systems.defense.update(dt);
             systems.collision.update(dt);
             
+            // Process pending entity removals
+            world.processPendingRemovals();
+            
             // Update projectile lifetimes
             const projectiles = world.getEntitiesByType('projectile');
             projectiles.forEach(proj => {

From b540b675ee1d5f7af325d315d6ef42e12e890fed Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 14 Feb 2026 20:35:03 +0000
Subject: [PATCH 07/17] Create Professional Combat Dev Sandbox with Real Game
 Architecture

Co-authored-by: Linkatplug <36280686+Linkatplug@users.noreply.github.com>
---
 dev/combat-sandbox-pro.html | 804 ++++++++++++++++++++++++++++++++++++
 1 file changed, 804 insertions(+)
 create mode 100644 dev/combat-sandbox-pro.html

diff --git a/dev/combat-sandbox-pro.html b/dev/combat-sandbox-pro.html
new file mode 100644
index 0000000..19bbb71
--- /dev/null
+++ b/dev/combat-sandbox-pro.html
@@ -0,0 +1,804 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Combat Dev Sandbox - Professional</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            background: #0a0a1a;
+            font-family: 'Courier New', monospace;
+            color: #00ffff;
+            overflow-y: auto;
+            overflow-x: hidden;
+        }
+
+        #gameContainer {
+            position: fixed;
+            top: 0;
+            left: 0;
+            right: 400px;
+            bottom: 0;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            background: #000;
+        }
+
+        #gameCanvas {
+            display: block;
+            background: #000;
+            border: 2px solid #00ffff;
+            max-width: 100%;
+            max-height: 100%;
+        }
+
+        #ui {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            pointer-events: none;
+        }
+
+        .menu-screen, .level-up-screen, .game-over-screen {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background: rgba(10, 10, 26, 0.95);
+            display: none;
+            flex-direction: column;
+            justify-content: center;
+            align-items: center;
+            pointer-events: all;
+        }
+
+        .menu-screen.active, .level-up-screen.active, .game-over-screen.active {
+            display: flex;
+        }
+
+        #debugPanel {
+            position: fixed;
+            right: 0;
+            top: 0;
+            width: 400px;
+            height: 100vh;
+            background: #0a0a1a;
+            border-left: 2px solid #00ffff;
+            overflow-y: auto;
+            z-index: 1000;
+            padding: 20px;
+        }
+
+        .debug-section {
+            margin-bottom: 25px;
+            background: rgba(0, 255, 255, 0.05);
+            border: 1px solid rgba(0, 255, 255, 0.3);
+            border-radius: 5px;
+            padding: 15px;
+        }
+
+        .debug-section h2 {
+            color: #00ffff;
+            font-size: 16px;
+            margin-bottom: 15px;
+            border-bottom: 1px solid rgba(0, 255, 255, 0.3);
+            padding-bottom: 8px;
+            text-transform: uppercase;
+            letter-spacing: 1px;
+        }
+
+        .toggle-item {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            padding: 8px 0;
+            border-bottom: 1px solid rgba(0, 255, 255, 0.1);
+        }
+
+        .toggle-item:last-child {
+            border-bottom: none;
+        }
+
+        .toggle-label {
+            color: #aaa;
+            font-size: 13px;
+        }
+
+        .toggle-button {
+            background: #00ffff;
+            color: #000;
+            border: none;
+            padding: 6px 16px;
+            border-radius: 3px;
+            cursor: pointer;
+            font-family: inherit;
+            font-size: 12px;
+            font-weight: bold;
+            transition: all 0.2s;
+        }
+
+        .toggle-button.off {
+            background: #444;
+            color: #888;
+        }
+
+        .toggle-button:hover {
+            transform: scale(1.05);
+            box-shadow: 0 0 10px rgba(0, 255, 255, 0.5);
+        }
+
+        .control-button {
+            background: linear-gradient(135deg, #00ffff 0%, #0088ff 100%);
+            color: #000;
+            border: none;
+            padding: 10px 15px;
+            border-radius: 4px;
+            cursor: pointer;
+            font-family: inherit;
+            font-size: 13px;
+            font-weight: bold;
+            margin: 5px 5px 5px 0;
+            transition: all 0.2s;
+            display: inline-block;
+        }
+
+        .control-button:hover {
+            transform: scale(1.05);
+            box-shadow: 0 0 15px rgba(0, 255, 255, 0.5);
+        }
+
+        .control-button:active {
+            transform: scale(0.98);
+        }
+
+        .slider-control {
+            margin: 12px 0;
+        }
+
+        .slider-label {
+            color: #00ffff;
+            font-size: 12px;
+            margin-bottom: 5px;
+            display: flex;
+            justify-content: space-between;
+        }
+
+        .slider-value {
+            color: #0ff;
+            font-weight: bold;
+        }
+
+        input[type="range"] {
+            width: 100%;
+            height: 6px;
+            background: rgba(0, 255, 255, 0.2);
+            outline: none;
+            border-radius: 3px;
+            -webkit-appearance: none;
+        }
+
+        input[type="range"]::-webkit-slider-thumb {
+            -webkit-appearance: none;
+            appearance: none;
+            width: 16px;
+            height: 16px;
+            background: #00ffff;
+            cursor: pointer;
+            border-radius: 50%;
+            box-shadow: 0 0 10px rgba(0, 255, 255, 0.5);
+        }
+
+        input[type="range"]::-moz-range-thumb {
+            width: 16px;
+            height: 16px;
+            background: #00ffff;
+            cursor: pointer;
+            border-radius: 50%;
+            box-shadow: 0 0 10px rgba(0, 255, 255, 0.5);
+        }
+
+        .stat-display {
+            display: flex;
+            justify-content: space-between;
+            padding: 8px 0;
+            border-bottom: 1px solid rgba(0, 255, 255, 0.1);
+            font-size: 13px;
+        }
+
+        .stat-display:last-child {
+            border-bottom: none;
+        }
+
+        .stat-label {
+            color: #888;
+        }
+
+        .stat-value {
+            color: #00ffff;
+            font-weight: bold;
+        }
+
+        .hp-layer {
+            margin: 5px 0;
+            font-size: 12px;
+        }
+
+        .hp-layer-name {
+            color: #aaa;
+            display: inline-block;
+            width: 80px;
+        }
+
+        .hp-layer-value {
+            color: #0f0;
+            font-weight: bold;
+        }
+
+        #title {
+            position: fixed;
+            top: 10px;
+            left: 10px;
+            color: #00ffff;
+            font-size: 20px;
+            text-shadow: 0 0 10px #00ffff;
+            z-index: 100;
+            background: rgba(0, 0, 0, 0.7);
+            padding: 10px 20px;
+            border-radius: 5px;
+            border: 1px solid #00ffff;
+        }
+    </style>
+</head>
+<body>
+    <div id="title">Combat Dev Sandbox - Professional</div>
+
+    <div id="gameContainer">
+        <canvas id="gameCanvas" width="1280" height="720"></canvas>
+        <div id="ui">
+            <!-- Minimal UI elements to prevent Game init errors -->
+            <div class="menu-screen"></div>
+            <div class="level-up-screen"></div>
+            <div class="game-over-screen"></div>
+            <button id="startButton" style="display: none;"></button>
+            <button id="metaButton" style="display: none;"></button>
+            <button id="backToMenuButton" style="display: none;"></button>
+            <button id="returnMenuButton" style="display: none;"></button>
+            <button id="viewScoreboardButton" style="display: none;"></button>
+            <button id="scoreboardBackButton" style="display: none;"></button>
+            <button id="submitScoreButton" style="display: none;"></button>
+            <button id="skipScoreButton" style="display: none;"></button>
+            <input id="playerNameInput" style="display: none;">
+        </div>
+    </div>
+
+    <div id="debugPanel">
+        <div class="debug-section">
+            <h2>System Toggles</h2>
+            <div class="toggle-item">
+                <span class="toggle-label">AI System</span>
+                <button class="toggle-button" id="toggleAI" onclick="toggleSystem('ai')">ON</button>
+            </div>
+            <div class="toggle-item">
+                <span class="toggle-label">Enemy Fire</span>
+                <button class="toggle-button" id="toggleEnemyFire" onclick="toggleSystem('enemyFire')">ON</button>
+            </div>
+            <div class="toggle-item">
+                <span class="toggle-label">Player Fire</span>
+                <button class="toggle-button" id="togglePlayerFire" onclick="toggleSystem('playerFire')">ON</button>
+            </div>
+            <div class="toggle-item">
+                <span class="toggle-label">Collision</span>
+                <button class="toggle-button" id="toggleCollision" onclick="toggleSystem('collision')">ON</button>
+            </div>
+            <div class="toggle-item">
+                <span class="toggle-label">Defense Update</span>
+                <button class="toggle-button" id="toggleDefense" onclick="toggleSystem('defense')">ON</button>
+            </div>
+            <div class="toggle-item">
+                <span class="toggle-label">Movement</span>
+                <button class="toggle-button" id="toggleMovement" onclick="toggleSystem('movement')">ON</button>
+            </div>
+        </div>
+
+        <div class="debug-section">
+            <h2>Spawn Control</h2>
+            <button class="control-button" onclick="spawnScout(1)">Spawn 1 Scout</button>
+            <button class="control-button" onclick="spawnScout(5)">Spawn 5 Scouts</button>
+            <button class="control-button" onclick="spawnElite()">Spawn Elite</button>
+            <button class="control-button" onclick="clearAllEnemies()">Clear All Enemies</button>
+            <button class="control-button" onclick="resetPlayerHP()">Reset Player HP</button>
+        </div>
+
+        <div class="debug-section">
+            <h2>Runtime Modifiers</h2>
+            <div class="slider-control">
+                <div class="slider-label">
+                    <span>Player Damage</span>
+                    <span class="slider-value" id="playerDmgValue">1.0x</span>
+                </div>
+                <input type="range" id="playerDmgSlider" min="0.1" max="5" step="0.1" value="1" 
+                       oninput="updateModifier('playerDamage', this.value)">
+            </div>
+            <div class="slider-control">
+                <div class="slider-label">
+                    <span>Enemy Damage</span>
+                    <span class="slider-value" id="enemyDmgValue">1.0x</span>
+                </div>
+                <input type="range" id="enemyDmgSlider" min="0.1" max="5" step="0.1" value="1" 
+                       oninput="updateModifier('enemyDamage', this.value)">
+            </div>
+            <div class="slider-control">
+                <div class="slider-label">
+                    <span>Enemy Fire Cooldown</span>
+                    <span class="slider-value" id="enemyCooldownValue">1.0x</span>
+                </div>
+                <input type="range" id="enemyCooldownSlider" min="0.1" max="3" step="0.1" value="1" 
+                       oninput="updateModifier('enemyCooldown', this.value)">
+            </div>
+        </div>
+
+        <div class="debug-section">
+            <h2>Live Stats</h2>
+            <div class="stat-display">
+                <span class="stat-label">Total Enemies</span>
+                <span class="stat-value" id="statEnemies">0</span>
+            </div>
+            <div class="stat-display">
+                <span class="stat-label">Damage/sec</span>
+                <span class="stat-value" id="statDamageSec">0</span>
+            </div>
+            <div class="stat-display">
+                <span class="stat-label">Shots/sec</span>
+                <span class="stat-value" id="statShotsSec">0</span>
+            </div>
+            <div style="margin-top: 10px; padding-top: 10px; border-top: 1px solid rgba(0, 255, 255, 0.3);">
+                <div class="hp-layer">
+                    <span class="hp-layer-name">Shield:</span>
+                    <span class="hp-layer-value" id="hpShield">0/0</span>
+                </div>
+                <div class="hp-layer">
+                    <span class="hp-layer-name">Armor:</span>
+                    <span class="hp-layer-value" id="hpArmor">0/0</span>
+                </div>
+                <div class="hp-layer">
+                    <span class="hp-layer-name">Structure:</span>
+                    <span class="hp-layer-value" id="hpStructure">0/0</span>
+                </div>
+                <div class="stat-display" style="margin-top: 5px; padding-top: 5px;">
+                    <span class="stat-label">Total HP:</span>
+                    <span class="stat-value" id="hpTotal">0/0</span>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Load all game scripts in correct order (same as index.html) -->
+    <script src="../js/constants.js"></script>
+    <script src="../js/utils/Math.js"></script>
+    <script src="../js/utils/Logger.js"></script>
+    <script src="../js/utils/DebugOverlay.js"></script>
+    <script src="../js/utils/ScreenEffects.js"></script>
+    <script src="../js/core/ECS.js"></script>
+    <script src="../js/core/GameState.js"></script>
+    <script src="../js/core/stats/ShipStats.js"></script>
+    <script src="../js/core/stats/FinalStatsCalculator.js"></script>
+    <script src="../js/data/PassiveData.js"></script>
+    <script src="../js/data/ShipData.js"></script>
+    <script src="../js/data/SynergyData.js"></script>
+    <script src="../js/data/KeystoneData.js"></script>
+    <script src="../js/data/DefenseData.js"></script>
+    <script src="../js/data/HeatData.js"></script>
+    <script src="../js/data/NewWeaponData.js"></script>
+    <script src="../js/data/ModuleData.js"></script>
+    <script src="../js/data/EnemyProfiles.js"></script>
+    <script src="../js/data/LootData.js"></script>
+    <script src="../js/data/TagSynergyData.js"></script>
+    <script src="../js/data/BalanceConstants.js"></script>
+    <script src="../js/data/ShipUpgradeData.js"></script>
+    <script src="../js/data/WeaponDataBridge.js"></script>
+    <script src="../js/ui/EnhancedUIComponents.js"></script>
+    <script src="../js/systems/MovementSystem.js"></script>
+    <script src="../js/systems/CombatSystem.js"></script>
+    <script src="../js/systems/CollisionSystem.js"></script>
+    <script src="../js/systems/AISystem.js"></script>
+    <script src="../js/systems/SpawnerSystem.js"></script>
+    <script src="../js/systems/PickupSystem.js"></script>
+    <script src="../js/systems/RenderSystem.js"></script>
+    <script src="../js/systems/UISystem.js"></script>
+    <script src="../js/systems/ParticleSystem.js"></script>
+    <script src="../js/systems/WaveSystem.js"></script>
+    <script src="../js/systems/SynergySystem.js"></script>
+    <script src="../js/systems/WeatherSystem.js"></script>
+    <script src="../js/systems/DefenseSystem.js"></script>
+    <script src="../js/systems/HeatSystem.js"></script>
+    <script src="../js/systems/ModuleSystem.js"></script>
+    <script src="../js/systems/ShipUpgradeSystem.js"></script>
+    <script src="../js/managers/SaveManager.js"></script>
+    <script src="../js/managers/AudioManager.js"></script>
+    <script src="../js/managers/ScoreManager.js"></script>
+    <script src="../js/Game.js"></script>
+
+    <script>
+        // Dev mode flags - control which systems run
+        const devFlags = {
+            aiEnabled: true,
+            enemyFireEnabled: true,
+            playerFireEnabled: true,
+            collisionEnabled: true,
+            defenseEnabled: true,
+            movementEnabled: true
+        };
+
+        // Runtime modifiers
+        const modifiers = {
+            playerDamage: 1.0,
+            enemyDamage: 1.0,
+            enemyCooldown: 1.0
+        };
+
+        // Stats tracking
+        let statsTracking = {
+            damageTaken: 0,
+            shotsFired: 0,
+            lastUpdate: performance.now()
+        };
+
+        let game = null;
+        let originalUpdate = null;
+
+        // Initialize game with dev mode
+        function initDevSandbox() {
+            console.log('[DevSandbox] Initializing professional combat sandbox...');
+
+            // Create game instance
+            game = new Game();
+            
+            // Store original update method
+            originalUpdate = game.update.bind(game);
+            
+            // Override update method to include dev flags
+            game.update = function(deltaTime) {
+                // Update game time
+                this.gameState.stats.time += deltaTime;
+                
+                // Update wave system (always)
+                this.systems.wave.update(deltaTime);
+                this.systems.spawner.setWaveNumber(this.systems.wave.getWaveNumber());
+                
+                // Update synergy system (always)
+                if (this.synergySystem) {
+                    this.synergySystem.update(deltaTime);
+                }
+                
+                // Conditional system updates based on dev flags
+                if (devFlags.movementEnabled) {
+                    this.systems.movement.update(deltaTime);
+                }
+                
+                if (devFlags.aiEnabled) {
+                    this.systems.ai.update(deltaTime);
+                }
+                
+                // Combat system - split into player and enemy fire
+                if (devFlags.playerFireEnabled || devFlags.enemyFireEnabled) {
+                    // We'll need to handle this at the CombatSystem level
+                    this.systems.combat.update(deltaTime);
+                }
+                
+                if (devFlags.defenseEnabled) {
+                    this.systems.defense.update(deltaTime);
+                }
+                
+                this.systems.heat.update(deltaTime);
+                this.systems.weather.update(deltaTime);
+                
+                if (devFlags.collisionEnabled) {
+                    this.systems.collision.update(deltaTime);
+                }
+                
+                // Always update spawner, pickup, particle, effects
+                this.systems.spawner.update(deltaTime, this.systems.wave.canSpawn());
+                this.systems.pickup.update(deltaTime);
+                this.systems.particle.update(deltaTime);
+                this.screenEffects.update(deltaTime);
+                
+                // Update invulnerability
+                if (this.player) {
+                    const defense = this.player.getComponent('defense');
+                    if (defense && defense.invulnerable) {
+                        defense.invulnerableTime -= deltaTime;
+                        if (defense.invulnerableTime <= 0) {
+                            defense.invulnerable = false;
+                        }
+                    }
+                }
+                
+                // Process entity removals
+                this.world.processPendingRemovals();
+                
+                // Update stats display
+                updateStatsDisplay();
+            };
+            
+            // Wait for game to be ready, then start in dev mode
+            setTimeout(() => {
+                // Set default ship
+                game.gameState.selectedShip = 'ION_FRIGATE';
+                
+                // Start game directly (bypass menu)
+                game.startGame();
+                
+                console.log('[DevSandbox] Game started in dev mode');
+                console.log('[DevSandbox] Player:', game.player);
+                console.log('[DevSandbox] Systems:', game.systems);
+                
+                // Setup damage tracking
+                setupDamageTracking();
+            }, 100);
+        }
+
+        // Setup damage tracking wrapper
+        function setupDamageTracking() {
+            if (!game || !game.systems.defense) return;
+            
+            const originalApplyDamage = game.systems.defense.applyDamage.bind(game.systems.defense);
+            
+            game.systems.defense.applyDamage = function(entity, damagePacket) {
+                // Track player damage
+                if (entity === game.player) {
+                    const amount = damagePacket.amount || damagePacket.damage || 0;
+                    statsTracking.damageTaken += amount * modifiers.enemyDamage;
+                }
+                
+                // Apply enemy damage modifier
+                if (entity.type === 'enemy') {
+                    const modifiedPacket = {...damagePacket};
+                    if (modifiedPacket.amount) modifiedPacket.amount *= modifiers.playerDamage;
+                    if (modifiedPacket.damage) modifiedPacket.damage *= modifiers.playerDamage;
+                    return originalApplyDamage(entity, modifiedPacket);
+                }
+                
+                // Apply player damage modifier
+                if (entity === game.player) {
+                    const modifiedPacket = {...damagePacket};
+                    if (modifiedPacket.amount) modifiedPacket.amount *= modifiers.enemyDamage;
+                    if (modifiedPacket.damage) modifiedPacket.damage *= modifiers.enemyDamage;
+                    return originalApplyDamage(entity, modifiedPacket);
+                }
+                
+                return originalApplyDamage(entity, damagePacket);
+            };
+        }
+
+        // Toggle system on/off
+        function toggleSystem(systemName) {
+            const flagMap = {
+                'ai': 'aiEnabled',
+                'enemyFire': 'enemyFireEnabled',
+                'playerFire': 'playerFireEnabled',
+                'collision': 'collisionEnabled',
+                'defense': 'defenseEnabled',
+                'movement': 'movementEnabled'
+            };
+            
+            const flag = flagMap[systemName];
+            if (!flag) return;
+            
+            devFlags[flag] = !devFlags[flag];
+            
+            // Update button
+            const buttonMap = {
+                'ai': 'toggleAI',
+                'enemyFire': 'toggleEnemyFire',
+                'playerFire': 'togglePlayerFire',
+                'collision': 'toggleCollision',
+                'defense': 'toggleDefense',
+                'movement': 'toggleMovement'
+            };
+            
+            const button = document.getElementById(buttonMap[systemName]);
+            if (button) {
+                button.textContent = devFlags[flag] ? 'ON' : 'OFF';
+                button.classList.toggle('off', !devFlags[flag]);
+            }
+            
+            console.log(`[DevSandbox] ${systemName} ${devFlags[flag] ? 'enabled' : 'disabled'}`);
+        }
+
+        // Update runtime modifier
+        function updateModifier(modifierName, value) {
+            value = parseFloat(value);
+            
+            if (modifierName === 'playerDamage') {
+                modifiers.playerDamage = value;
+                document.getElementById('playerDmgValue').textContent = value.toFixed(1) + 'x';
+            } else if (modifierName === 'enemyDamage') {
+                modifiers.enemyDamage = value;
+                document.getElementById('enemyDmgValue').textContent = value.toFixed(1) + 'x';
+            } else if (modifierName === 'enemyCooldown') {
+                modifiers.enemyCooldown = value;
+                document.getElementById('enemyCooldownValue').textContent = value.toFixed(1) + 'x';
+                
+                // Apply to AI system enemy fire rates
+                if (game && game.systems.ai) {
+                    // This would need implementation in AISystem to respect this multiplier
+                }
+            }
+        }
+
+        // Spawn scout enemy
+        function spawnScout(count) {
+            if (!game || !game.player) return;
+            
+            console.log(`[DevSandbox] Spawning ${count} scout(s)`);
+            
+            const playerPos = game.player.getComponent('position');
+            if (!playerPos) return;
+            
+            for (let i = 0; i < count; i++) {
+                const angle = Math.random() * Math.PI * 2;
+                const distance = 300 + Math.random() * 200;
+                const x = playerPos.x + Math.cos(angle) * distance;
+                const y = playerPos.y + Math.sin(angle) * distance;
+                
+                const profile = window.EnemyProfiles.PROFILES.SCOUT_DRONE;
+                const enemy = game.world.createEntity('enemy');
+                
+                enemy.addComponent('position', Components.Position(x, y));
+                enemy.addComponent('velocity', Components.Velocity(0, 0));
+                enemy.addComponent('collision', Components.Collision(profile.size));
+                
+                const defense = window.EnemyProfiles.createEnemyDefense(profile);
+                enemy.addComponent('defense', defense);
+                
+                enemy.addComponent('enemy', {
+                    type: profile.aiType,
+                    speed: profile.speed,
+                    damage: 10,
+                    attackCooldown: 0,
+                    attackPattern: {
+                        type: 'shoot',
+                        cooldown: 2.0,
+                        range: 300,
+                        damage: 8
+                    }
+                });
+                
+                enemy.addComponent('renderable', {
+                    color: profile.color,
+                    size: profile.size,
+                    shape: 'circle'
+                });
+            }
+        }
+
+        // Spawn elite enemy
+        function spawnElite() {
+            if (!game || !game.player) return;
+            
+            console.log('[DevSandbox] Spawning elite');
+            
+            const playerPos = game.player.getComponent('position');
+            if (!playerPos) return;
+            
+            const angle = Math.random() * Math.PI * 2;
+            const distance = 400;
+            const x = playerPos.x + Math.cos(angle) * distance;
+            const y = playerPos.y + Math.sin(angle) * distance;
+            
+            const profile = window.EnemyProfiles.PROFILES.SIEGE_HULK;
+            const enemy = game.world.createEntity('enemy');
+            
+            enemy.addComponent('position', Components.Position(x, y));
+            enemy.addComponent('velocity', Components.Velocity(0, 0));
+            enemy.addComponent('collision', Components.Collision(profile.size));
+            
+            const defense = window.EnemyProfiles.createEnemyDefense(profile);
+            enemy.addComponent('defense', defense);
+            
+            enemy.addComponent('enemy', {
+                type: profile.aiType,
+                speed: profile.speed,
+                damage: 15,
+                attackCooldown: 0,
+                attackPattern: {
+                    type: 'special',
+                    cooldown: 1.5,
+                    range: 350,
+                    damage: 12
+                }
+            });
+            
+            enemy.addComponent('renderable', {
+                color: profile.color,
+                size: profile.size,
+                shape: 'circle'
+            });
+        }
+
+        // Clear all enemies
+        function clearAllEnemies() {
+            if (!game) return;
+            
+            console.log('[DevSandbox] Clearing all enemies');
+            
+            const enemies = game.world.getEntitiesByType('enemy');
+            enemies.forEach(enemy => game.world.removeEntity(enemy.id));
+            game.world.processPendingRemovals();
+        }
+
+        // Reset player HP
+        function resetPlayerHP() {
+            if (!game || !game.player) return;
+            
+            console.log('[DevSandbox] Resetting player HP');
+            
+            const defense = game.player.getComponent('defense');
+            if (defense) {
+                defense.shield.current = defense.shield.max;
+                defense.armor.current = defense.armor.max;
+                defense.structure.current = defense.structure.max;
+                defense.shield.regenDelay = 0;
+                defense.armor.regenDelay = 0;
+                defense.structure.regenDelay = 0;
+            }
+        }
+
+        // Update stats display
+        function updateStatsDisplay() {
+            if (!game || !game.player) return;
+            
+            // Enemy count
+            const enemies = game.world.getEntitiesByType('enemy');
+            document.getElementById('statEnemies').textContent = enemies.length;
+            
+            // Player HP
+            const defense = game.player.getComponent('defense');
+            if (defense) {
+                const shield = defense.shield;
+                const armor = defense.armor;
+                const structure = defense.structure;
+                
+                document.getElementById('hpShield').textContent = 
+                    `${Math.ceil(shield.current)}/${shield.max}`;
+                document.getElementById('hpArmor').textContent = 
+                    `${Math.ceil(armor.current)}/${armor.max}`;
+                document.getElementById('hpStructure').textContent = 
+                    `${Math.ceil(structure.current)}/${structure.max}`;
+                
+                const totalCurrent = shield.current + armor.current + structure.current;
+                const totalMax = shield.max + armor.max + structure.max;
+                document.getElementById('hpTotal').textContent = 
+                    `${Math.ceil(totalCurrent)}/${totalMax}`;
+            }
+            
+            // Update damage/shots per second (every second)
+            const now = performance.now();
+            if (now - statsTracking.lastUpdate >= 1000) {
+                const damageSec = Math.ceil(statsTracking.damageTaken);
+                const shotsSec = statsTracking.shotsFired;
+                
+                document.getElementById('statDamageSec').textContent = damageSec;
+                document.getElementById('statShotsSec').textContent = shotsSec;
+                
+                statsTracking.damageTaken = 0;
+                statsTracking.shotsFired = 0;
+                statsTracking.lastUpdate = now;
+            }
+        }
+
+        // Initialize on load
+        window.addEventListener('load', initDevSandbox);
+    </script>
+</body>
+</html>

From eefb9eebf223b31656f7dcd7dd4c5c1cb227437a Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 14 Feb 2026 20:42:54 +0000
Subject: [PATCH 08/17] Disable UI and Audio systems in combat sandbox to
 prevent DOM crashes

Co-authored-by: Linkatplug <36280686+Linkatplug@users.noreply.github.com>
---
 dev/combat-sandbox-pro.html | 40 +++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/dev/combat-sandbox-pro.html b/dev/combat-sandbox-pro.html
index 19bbb71..9574540 100644
--- a/dev/combat-sandbox-pro.html
+++ b/dev/combat-sandbox-pro.html
@@ -463,6 +463,46 @@ <h2>Live Stats</h2>
             // Create game instance
             game = new Game();
             
+            // Disable UI and Audio initialization methods BEFORE startGame
+            console.log('[DevSandbox] Disabling UI and Audio systems...');
+            
+            // Override methods that touch DOM elements
+            game.setupUIListeners = function() {
+                console.log('[DevSandbox] UI listeners disabled');
+            };
+            
+            // Replace UI system with stub that does nothing
+            game.systems.ui = {
+                showScreen: () => {},
+                showWaveAnnouncement: () => {},
+                showLevelUp: () => {},
+                showGameOver: () => {},
+                showPauseMenu: () => {},
+                hidePauseMenu: () => {},
+                showScoreboard: () => {},
+                hideScoreboard: () => {},
+                showNameEntryDialog: () => {},
+                hideNameEntryDialog: () => {},
+                updateHUD: () => {},
+                update: () => {},
+                waveSystem: null
+            };
+            
+            // Disable audio initialization
+            const originalAudioManager = game.audioManager;
+            game.audioManager = {
+                playSound: () => {},
+                playMusic: () => {},
+                stopMusic: () => {},
+                setMusicVolume: () => {},
+                setSFXVolume: () => {},
+                playWaveStart: () => {},
+                playLevelUp: () => {},
+                playGameOver: () => {},
+                startBackgroundMusic: () => {},
+                stopBackgroundMusic: () => {}
+            };
+            
             // Store original update method
             originalUpdate = game.update.bind(game);
             

From fb2e06fadd866234280d8dd1664501966c98502b Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 14 Feb 2026 20:50:38 +0000
Subject: [PATCH 09/17] Clean up combat sandbox to use real damage pipeline

Co-authored-by: Linkatplug <36280686+Linkatplug@users.noreply.github.com>
---
 dev/combat-sandbox-pro.html | 45 +++----------------------------------
 1 file changed, 3 insertions(+), 42 deletions(-)

diff --git a/dev/combat-sandbox-pro.html b/dev/combat-sandbox-pro.html
index 9574540..190d218 100644
--- a/dev/combat-sandbox-pro.html
+++ b/dev/combat-sandbox-pro.html
@@ -489,16 +489,13 @@ <h2>Live Stats</h2>
             };
             
             // Disable audio initialization
-            const originalAudioManager = game.audioManager;
             game.audioManager = {
+                init: () => {},
                 playSound: () => {},
                 playMusic: () => {},
                 stopMusic: () => {},
-                setMusicVolume: () => {},
-                setSFXVolume: () => {},
-                playWaveStart: () => {},
-                playLevelUp: () => {},
-                playGameOver: () => {},
+                stopAll: () => {},
+                setVolume: () => {},
                 startBackgroundMusic: () => {},
                 stopBackgroundMusic: () => {}
             };
@@ -581,45 +578,9 @@ <h2>Live Stats</h2>
                 console.log('[DevSandbox] Game started in dev mode');
                 console.log('[DevSandbox] Player:', game.player);
                 console.log('[DevSandbox] Systems:', game.systems);
-                
-                // Setup damage tracking
-                setupDamageTracking();
             }, 100);
         }
 
-        // Setup damage tracking wrapper
-        function setupDamageTracking() {
-            if (!game || !game.systems.defense) return;
-            
-            const originalApplyDamage = game.systems.defense.applyDamage.bind(game.systems.defense);
-            
-            game.systems.defense.applyDamage = function(entity, damagePacket) {
-                // Track player damage
-                if (entity === game.player) {
-                    const amount = damagePacket.amount || damagePacket.damage || 0;
-                    statsTracking.damageTaken += amount * modifiers.enemyDamage;
-                }
-                
-                // Apply enemy damage modifier
-                if (entity.type === 'enemy') {
-                    const modifiedPacket = {...damagePacket};
-                    if (modifiedPacket.amount) modifiedPacket.amount *= modifiers.playerDamage;
-                    if (modifiedPacket.damage) modifiedPacket.damage *= modifiers.playerDamage;
-                    return originalApplyDamage(entity, modifiedPacket);
-                }
-                
-                // Apply player damage modifier
-                if (entity === game.player) {
-                    const modifiedPacket = {...damagePacket};
-                    if (modifiedPacket.amount) modifiedPacket.amount *= modifiers.enemyDamage;
-                    if (modifiedPacket.damage) modifiedPacket.damage *= modifiers.enemyDamage;
-                    return originalApplyDamage(entity, modifiedPacket);
-                }
-                
-                return originalApplyDamage(entity, damagePacket);
-            };
-        }
-
         // Toggle system on/off
         function toggleSystem(systemName) {
             const flagMap = {

From fbea8a62cf0f9fff8869eacc95045321c30c1c96 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 14 Feb 2026 21:03:19 +0000
Subject: [PATCH 10/17] Create clean combat sandbox without Game class

Co-authored-by: Linkatplug <36280686+Linkatplug@users.noreply.github.com>
---
 dev/combat-sandbox-clean.html | 563 ++++++++++++++++++++++++++++++++++
 1 file changed, 563 insertions(+)
 create mode 100644 dev/combat-sandbox-clean.html

diff --git a/dev/combat-sandbox-clean.html b/dev/combat-sandbox-clean.html
new file mode 100644
index 0000000..42f1426
--- /dev/null
+++ b/dev/combat-sandbox-clean.html
@@ -0,0 +1,563 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Combat Sandbox - Clean (No Game Class)</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: 'Courier New', monospace;
+            background: #0a0a0a;
+            color: #00ff00;
+            overflow-y: auto;
+        }
+        
+        #gameCanvas {
+            position: fixed;
+            left: 0;
+            top: 0;
+            background: #000;
+            width: calc(100vw - 400px);
+            height: 100vh;
+        }
+        
+        #debugPanel {
+            position: fixed;
+            right: 0;
+            top: 0;
+            width: 400px;
+            height: 100vh;
+            background: #1a1a1a;
+            border-left: 2px solid #00ff00;
+            overflow-y: auto;
+            padding: 20px;
+        }
+        
+        .section {
+            margin-bottom: 30px;
+            padding: 15px;
+            background: #0a0a0a;
+            border: 1px solid #00ff00;
+        }
+        
+        h2 {
+            color: #00ff00;
+            margin-bottom: 15px;
+            font-size: 16px;
+            text-transform: uppercase;
+        }
+        
+        button {
+            background: #003300;
+            color: #00ff00;
+            border: 1px solid #00ff00;
+            padding: 8px 16px;
+            margin: 5px;
+            cursor: pointer;
+            font-family: 'Courier New', monospace;
+            font-size: 12px;
+        }
+        
+        button:hover {
+            background: #005500;
+        }
+        
+        button:active {
+            background: #007700;
+        }
+        
+        .toggle {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin: 10px 0;
+        }
+        
+        .toggle button {
+            min-width: 60px;
+        }
+        
+        .toggle button.on {
+            background: #005500;
+        }
+        
+        .toggle button.off {
+            background: #550000;
+            color: #ff5555;
+            border-color: #ff5555;
+        }
+        
+        .stat {
+            display: flex;
+            justify-content: space-between;
+            margin: 8px 0;
+            font-size: 12px;
+        }
+        
+        .stat-label {
+            color: #00cc00;
+        }
+        
+        .stat-value {
+            color: #00ff00;
+            font-weight: bold;
+        }
+    </style>
+</head>
+<body>
+    <canvas id="gameCanvas"></canvas>
+    
+    <div id="debugPanel">
+        <div class="section">
+            <h2>System Toggles</h2>
+            <div class="toggle">
+                <span>Movement</span>
+                <button id="toggleMovement" class="on" onclick="toggleSystem('movement')">ON</button>
+            </div>
+            <div class="toggle">
+                <span>AI</span>
+                <button id="toggleAI" class="on" onclick="toggleSystem('ai')">ON</button>
+            </div>
+            <div class="toggle">
+                <span>Combat</span>
+                <button id="toggleCombat" class="on" onclick="toggleSystem('combat')">ON</button>
+            </div>
+            <div class="toggle">
+                <span>Defense</span>
+                <button id="toggleDefense" class="on" onclick="toggleSystem('defense')">ON</button>
+            </div>
+            <div class="toggle">
+                <span>Collision</span>
+                <button id="toggleCollision" class="on" onclick="toggleSystem('collision')">ON</button>
+            </div>
+        </div>
+        
+        <div class="section">
+            <h2>Spawn Control</h2>
+            <button onclick="spawnScout(1)">Spawn 1 Scout</button>
+            <button onclick="spawnScout(5)">Spawn 5 Scouts</button>
+            <button onclick="spawnElite()">Spawn Elite</button>
+            <button onclick="clearEnemies()">Clear All</button>
+            <button onclick="resetPlayer()">Reset Player HP</button>
+        </div>
+        
+        <div class="section">
+            <h2>Live Stats</h2>
+            <div class="stat">
+                <span class="stat-label">Total Enemies:</span>
+                <span class="stat-value" id="enemyCount">0</span>
+            </div>
+            <div class="stat">
+                <span class="stat-label">Shield:</span>
+                <span class="stat-value" id="shieldHP">0/0</span>
+            </div>
+            <div class="stat">
+                <span class="stat-label">Armor:</span>
+                <span class="stat-value" id="armorHP">0/0</span>
+            </div>
+            <div class="stat">
+                <span class="stat-label">Structure:</span>
+                <span class="stat-value" id="structureHP">0/0</span>
+            </div>
+            <div class="stat">
+                <span class="stat-label">Total HP:</span>
+                <span class="stat-value" id="totalHP">0/0</span>
+            </div>
+        </div>
+    </div>
+
+    <!-- Core ECS -->
+    <script src="../js/core/ECS.js"></script>
+    <script src="../js/core/GameState.js"></script>
+    <script src="../js/core/Components.js"></script>
+    
+    <!-- Utils -->
+    <script src="../js/utils/Math.js"></script>
+    
+    <!-- Data -->
+    <script src="../js/data/Constants.js"></script>
+    <script src="../js/data/DefenseData.js"></script>
+    <script src="../js/data/EnemyProfiles.js"></script>
+    <script src="../js/data/NewWeaponData.js"></script>
+    <script src="../js/data/WeaponDataBridge.js"></script>
+    
+    <!-- Systems -->
+    <script src="../js/systems/MovementSystem.js"></script>
+    <script src="../js/systems/AISystem.js"></script>
+    <script src="../js/systems/CombatSystem.js"></script>
+    <script src="../js/systems/DefenseSystem.js"></script>
+    <script src="../js/systems/CollisionSystem.js"></script>
+    <script src="../js/systems/SpawnerSystem.js"></script>
+
+    <script>
+        // Global state
+        let world;
+        let player;
+        let canvas;
+        let ctx;
+        let systems = {};
+        let systemFlags = {
+            movement: true,
+            ai: true,
+            combat: true,
+            defense: true,
+            collision: true
+        };
+        
+        let lastTime = 0;
+        let running = false;
+
+        // Initialize
+        function init() {
+            console.log('[Sandbox] Initializing clean combat sandbox...');
+            
+            // Setup canvas
+            canvas = document.getElementById('gameCanvas');
+            ctx = canvas.getContext('2d');
+            resizeCanvas();
+            window.addEventListener('resize', resizeCanvas);
+            
+            // Create World
+            world = new World();
+            console.log('[Sandbox] World created');
+            
+            // Create systems (NO Game class)
+            systems.movement = new MovementSystem(world, canvas);
+            systems.ai = new AISystem(world, canvas);
+            systems.combat = new CombatSystem(world, null, null);
+            systems.defense = new DefenseSystem(world);
+            systems.collision = new CollisionSystem(world, null, null, null);
+            systems.spawner = new SpawnerSystem(world, null);
+            console.log('[Sandbox] Systems created');
+            
+            // Create player manually
+            createPlayer();
+            
+            // Start game loop
+            running = true;
+            lastTime = performance.now();
+            requestAnimationFrame(gameLoop);
+            
+            console.log('[Sandbox] Initialization complete');
+        }
+        
+        function resizeCanvas() {
+            canvas.width = window.innerWidth - 400;
+            canvas.height = window.innerHeight;
+        }
+        
+        function createPlayer() {
+            player = world.createEntity('player');
+            
+            // Position at center
+            player.addComponent('position', Components.Position(canvas.width / 2, canvas.height / 2));
+            player.addComponent('velocity', Components.Velocity(0, 0));
+            player.addComponent('collision', Components.Collision(15));
+            
+            // Defense layers manually
+            const defense = {
+                shield: {
+                    current: 180,
+                    max: 180,
+                    regen: 8,
+                    regenDelay: 0,
+                    regenDelayMax: 3,
+                    baseResistances: { em: 0, thermal: 0, kinetic: 0, explosive: 0 },
+                    bonusResistances: {}
+                },
+                armor: {
+                    current: 100,
+                    max: 100,
+                    regen: 0,
+                    regenDelay: 0,
+                    regenDelayMax: 0,
+                    baseResistances: { em: 0, thermal: 0, kinetic: 0, explosive: 0 },
+                    bonusResistances: {}
+                },
+                structure: {
+                    current: 120,
+                    max: 120,
+                    regen: 0.5,
+                    regenDelay: 0,
+                    regenDelayMax: 0,
+                    baseResistances: { em: 0, thermal: 0, kinetic: 0, explosive: 0 },
+                    bonusResistances: {}
+                },
+                invulnerable: false,
+                invulnerableTime: 0
+            };
+            player.addComponent('defense', defense);
+            
+            // Player component for CombatSystem and MovementSystem
+            player.addComponent('player', {
+                speed: 220,
+                shipId: 'ION_FRIGATE',
+                score: 0,
+                kills: 0,
+                level: 1,
+                xp: 0,
+                xpRequired: 100,
+                weapons: [],
+                modules: [],
+                stats: {
+                    damageMultiplier: 1.0,
+                    fireRateMultiplier: 1.0,
+                    speed: 220,
+                    critChance: 0.05,
+                    critMultiplier: 1.5
+                },
+                currentWeapon: null
+            });
+            
+            // Weapon
+            const weapon = {
+                id: 'ion_blaster',
+                level: 1,
+                cooldown: 0,
+                fireRate: 0.2,
+                damage: 22,
+                damageType: 'em',
+                projectileSpeed: 500,
+                range: 800
+            };
+            player.addComponent('weapons', [weapon]);
+            
+            // Renderable
+            player.addComponent('renderable', {
+                color: '#00ffff',
+                size: 15,
+                shape: 'triangle'
+            });
+            
+            console.log('[Sandbox] Player created:', player);
+        }
+        
+        function gameLoop(currentTime) {
+            if (!running) return;
+            
+            const deltaTime = Math.min((currentTime - lastTime) / 1000, 0.1);
+            lastTime = currentTime;
+            
+            // Update systems based on flags
+            if (systemFlags.movement) systems.movement.update(deltaTime);
+            if (systemFlags.ai) systems.ai.update(deltaTime);
+            if (systemFlags.combat) systems.combat.update(deltaTime);
+            if (systemFlags.defense) systems.defense.update(deltaTime);
+            if (systemFlags.collision) systems.collision.update(deltaTime);
+            
+            // Remove dead entities
+            world.processPendingRemovals();
+            
+            // Render
+            render();
+            
+            // Update stats
+            updateStats();
+            
+            requestAnimationFrame(gameLoop);
+        }
+        
+        function render() {
+            // Clear
+            ctx.fillStyle = '#000';
+            ctx.fillRect(0, 0, canvas.width, canvas.height);
+            
+            // Render entities
+            const allEntities = [...world.entities.values()];
+            
+            for (const entity of allEntities) {
+                const pos = entity.getComponent('position');
+                const renderable = entity.getComponent('renderable');
+                
+                if (!pos || !renderable) continue;
+                
+                ctx.save();
+                ctx.translate(pos.x, pos.y);
+                
+                // Draw based on shape
+                if (renderable.shape === 'triangle') {
+                    // Player
+                    ctx.fillStyle = renderable.color;
+                    ctx.beginPath();
+                    ctx.moveTo(0, -renderable.size);
+                    ctx.lineTo(-renderable.size * 0.7, renderable.size * 0.7);
+                    ctx.lineTo(renderable.size * 0.7, renderable.size * 0.7);
+                    ctx.closePath();
+                    ctx.fill();
+                } else if (renderable.shape === 'circle') {
+                    // Enemy
+                    ctx.fillStyle = renderable.color;
+                    ctx.beginPath();
+                    ctx.arc(0, 0, renderable.size, 0, Math.PI * 2);
+                    ctx.fill();
+                } else {
+                    // Projectile
+                    ctx.fillStyle = renderable.color;
+                    ctx.beginPath();
+                    ctx.arc(0, 0, renderable.size, 0, Math.PI * 2);
+                    ctx.fill();
+                }
+                
+                ctx.restore();
+            }
+        }
+        
+        function updateStats() {
+            const enemies = world.getEntitiesByType('enemy');
+            document.getElementById('enemyCount').textContent = enemies.length;
+            
+            if (player) {
+                const defense = player.getComponent('defense');
+                if (defense) {
+                    document.getElementById('shieldHP').textContent = 
+                        `${Math.round(defense.shield.current)}/${defense.shield.max}`;
+                    document.getElementById('armorHP').textContent = 
+                        `${Math.round(defense.armor.current)}/${defense.armor.max}`;
+                    document.getElementById('structureHP').textContent = 
+                        `${Math.round(defense.structure.current)}/${defense.structure.max}`;
+                    
+                    const total = defense.shield.current + defense.armor.current + defense.structure.current;
+                    const maxTotal = defense.shield.max + defense.armor.max + defense.structure.max;
+                    document.getElementById('totalHP').textContent = 
+                        `${Math.round(total)}/${maxTotal}`;
+                }
+            }
+        }
+        
+        // Toggle system
+        function toggleSystem(systemName) {
+            systemFlags[systemName] = !systemFlags[systemName];
+            const button = document.getElementById('toggle' + systemName.charAt(0).toUpperCase() + systemName.slice(1));
+            if (systemFlags[systemName]) {
+                button.textContent = 'ON';
+                button.classList.add('on');
+                button.classList.remove('off');
+            } else {
+                button.textContent = 'OFF';
+                button.classList.add('off');
+                button.classList.remove('on');
+            }
+            console.log(`[Sandbox] ${systemName} system: ${systemFlags[systemName] ? 'ON' : 'OFF'}`);
+        }
+        
+        // Spawn scout
+        function spawnScout(count) {
+            if (!player) return;
+            console.log(`[Sandbox] Spawning ${count} scout(s)`);
+            
+            const playerPos = player.getComponent('position');
+            const profile = window.EnemyProfiles.PROFILES.SCOUT_DRONE;
+            
+            for (let i = 0; i < count; i++) {
+                const angle = Math.random() * Math.PI * 2;
+                const distance = 300 + Math.random() * 200;
+                const x = playerPos.x + Math.cos(angle) * distance;
+                const y = playerPos.y + Math.sin(angle) * distance;
+                
+                const enemy = world.createEntity('enemy');
+                enemy.addComponent('position', Components.Position(x, y));
+                enemy.addComponent('velocity', Components.Velocity(0, 0));
+                enemy.addComponent('collision', Components.Collision(profile.size));
+                
+                // Defense
+                const defense = window.EnemyProfiles.createEnemyDefense(profile);
+                enemy.addComponent('defense', defense);
+                
+                // Enemy component
+                enemy.addComponent('enemy', {
+                    type: profile.aiType,
+                    speed: profile.speed,
+                    damage: 6,
+                    attackCooldown: 0,
+                    attackPattern: {
+                        type: 'shoot',
+                        cooldown: 2.0,
+                        range: 400,
+                        damage: 6
+                    }
+                });
+                
+                // Renderable
+                enemy.addComponent('renderable', {
+                    color: profile.color,
+                    size: profile.size,
+                    shape: 'circle'
+                });
+            }
+        }
+        
+        // Spawn elite
+        function spawnElite() {
+            if (!player) return;
+            console.log('[Sandbox] Spawning elite');
+            
+            const playerPos = player.getComponent('position');
+            const profile = window.EnemyProfiles.PROFILES.SIEGE_HULK;
+            
+            const angle = Math.random() * Math.PI * 2;
+            const distance = 400;
+            const x = playerPos.x + Math.cos(angle) * distance;
+            const y = playerPos.y + Math.sin(angle) * distance;
+            
+            const enemy = world.createEntity('enemy');
+            enemy.addComponent('position', Components.Position(x, y));
+            enemy.addComponent('velocity', Components.Velocity(0, 0));
+            enemy.addComponent('collision', Components.Collision(profile.size));
+            
+            // Defense
+            const defense = window.EnemyProfiles.createEnemyDefense(profile);
+            enemy.addComponent('defense', defense);
+            
+            // Enemy component
+            enemy.addComponent('enemy', {
+                type: profile.aiType,
+                speed: profile.speed,
+                damage: 12,
+                attackCooldown: 0,
+                attackPattern: {
+                    type: 'special',
+                    cooldown: 1.5,
+                    range: 450,
+                    damage: 12
+                }
+            });
+            
+            // Renderable
+            enemy.addComponent('renderable', {
+                color: profile.color,
+                size: profile.size,
+                shape: 'circle'
+            });
+        }
+        
+        // Clear enemies
+        function clearEnemies() {
+            const enemies = world.getEntitiesByType('enemy');
+            enemies.forEach(e => world.removeEntity(e.id));
+            world.processPendingRemovals();
+            console.log('[Sandbox] All enemies cleared');
+        }
+        
+        // Reset player
+        function resetPlayer() {
+            if (!player) return;
+            const defense = player.getComponent('defense');
+            if (defense) {
+                defense.shield.current = defense.shield.max;
+                defense.armor.current = defense.armor.max;
+                defense.structure.current = defense.structure.max;
+                console.log('[Sandbox] Player HP reset');
+            }
+        }
+        
+        // Start on load
+        window.addEventListener('load', init);
+    </script>
+</body>
+</html>

From 699cf7c9d610b4fce4e28bebc7285b27d38e2037 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 14 Feb 2026 21:09:20 +0000
Subject: [PATCH 11/17] Fix combat-sandbox-clean.html dependencies and script
 loading order

Co-authored-by: Linkatplug <36280686+Linkatplug@users.noreply.github.com>
---
 dev/combat-sandbox-clean.html | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/dev/combat-sandbox-clean.html b/dev/combat-sandbox-clean.html
index 42f1426..53be44d 100644
--- a/dev/combat-sandbox-clean.html
+++ b/dev/combat-sandbox-clean.html
@@ -172,16 +172,15 @@ <h2>Live Stats</h2>
         </div>
     </div>
 
+    <!-- Utils (must load first) -->
+    <script src="../js/utils/Logger.js"></script>
+    <script src="../js/utils/Math.js"></script>
+    
     <!-- Core ECS -->
     <script src="../js/core/ECS.js"></script>
     <script src="../js/core/GameState.js"></script>
-    <script src="../js/core/Components.js"></script>
-    
-    <!-- Utils -->
-    <script src="../js/utils/Math.js"></script>
     
     <!-- Data -->
-    <script src="../js/data/Constants.js"></script>
     <script src="../js/data/DefenseData.js"></script>
     <script src="../js/data/EnemyProfiles.js"></script>
     <script src="../js/data/NewWeaponData.js"></script>
@@ -195,6 +194,12 @@ <h2>Live Stats</h2>
     <script src="../js/systems/CollisionSystem.js"></script>
     <script src="../js/systems/SpawnerSystem.js"></script>
 
+    <script>
+        // Create global logger instance (required by systems)
+        window.logger = new Logger();
+        logger.enabled = true;
+    </script>
+
     <script>
         // Global state
         let world;

From 696932965d2695c4b2ae593e932a4bd3000c9b86 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 14 Feb 2026 21:27:22 +0000
Subject: [PATCH 12/17] Wire DefenseSystem to world in combat sandbox for
 CollisionSystem access

Co-authored-by: Linkatplug <36280686+Linkatplug@users.noreply.github.com>
---
 dev/combat-sandbox-clean.html | 1 +
 1 file changed, 1 insertion(+)

diff --git a/dev/combat-sandbox-clean.html b/dev/combat-sandbox-clean.html
index 53be44d..abea271 100644
--- a/dev/combat-sandbox-clean.html
+++ b/dev/combat-sandbox-clean.html
@@ -237,6 +237,7 @@ <h2>Live Stats</h2>
             systems.ai = new AISystem(world, canvas);
             systems.combat = new CombatSystem(world, null, null);
             systems.defense = new DefenseSystem(world);
+            world.defenseSystem = systems.defense; // Wire DefenseSystem to world for CollisionSystem
             systems.collision = new CollisionSystem(world, null, null, null);
             systems.spawner = new SpawnerSystem(world, null);
             console.log('[Sandbox] Systems created');

From e9013e1a7ffb08e2cefc615f513655077ec64408 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 14 Feb 2026 21:37:45 +0000
Subject: [PATCH 13/17] Fix GameState wiring in combat sandbox to prevent
 CollisionSystem crashes

Co-authored-by: Linkatplug <36280686+Linkatplug@users.noreply.github.com>
---
 dev/combat-sandbox-clean.html | 23 ++++++++++++++++++++---
 1 file changed, 20 insertions(+), 3 deletions(-)

diff --git a/dev/combat-sandbox-clean.html b/dev/combat-sandbox-clean.html
index abea271..ba0f86c 100644
--- a/dev/combat-sandbox-clean.html
+++ b/dev/combat-sandbox-clean.html
@@ -232,14 +232,31 @@ <h2>Live Stats</h2>
             world = new World();
             console.log('[Sandbox] World created');
             
+            // Create GameState (required by systems)
+            const gameState = new GameState();
+            gameState.isPaused = false;
+            gameState.isGameOver = false;
+            // Ensure stats object exists with all required fields
+            gameState.stats = {
+                time: 0,
+                kills: 0,
+                score: 0,
+                highestLevel: 1,
+                noyauxEarned: 0,
+                damageDealt: 0,
+                damageTaken: 0,
+                shotsFired: 0
+            };
+            console.log('[Sandbox] GameState created');
+            
             // Create systems (NO Game class)
             systems.movement = new MovementSystem(world, canvas);
             systems.ai = new AISystem(world, canvas);
-            systems.combat = new CombatSystem(world, null, null);
+            systems.combat = new CombatSystem(world, gameState, null);
             systems.defense = new DefenseSystem(world);
             world.defenseSystem = systems.defense; // Wire DefenseSystem to world for CollisionSystem
-            systems.collision = new CollisionSystem(world, null, null, null);
-            systems.spawner = new SpawnerSystem(world, null);
+            systems.collision = new CollisionSystem(world, gameState, null, null);
+            systems.spawner = new SpawnerSystem(world, gameState, null);
             console.log('[Sandbox] Systems created');
             
             // Create player manually

From a719d906caeb0e9bb23f9fd0ef478adaa25ae3b2 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 14 Feb 2026 21:41:21 +0000
Subject: [PATCH 14/17] Fix enemy spawn positions to stay within visible canvas
 bounds

Co-authored-by: Linkatplug <36280686+Linkatplug@users.noreply.github.com>
---
 dev/combat-sandbox-clean.html | 24 ++++++++++++++----------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/dev/combat-sandbox-clean.html b/dev/combat-sandbox-clean.html
index ba0f86c..c5de618 100644
--- a/dev/combat-sandbox-clean.html
+++ b/dev/combat-sandbox-clean.html
@@ -474,14 +474,16 @@ <h2>Live Stats</h2>
             if (!player) return;
             console.log(`[Sandbox] Spawning ${count} scout(s)`);
             
-            const playerPos = player.getComponent('position');
             const profile = window.EnemyProfiles.PROFILES.SCOUT_DRONE;
             
             for (let i = 0; i < count; i++) {
-                const angle = Math.random() * Math.PI * 2;
-                const distance = 300 + Math.random() * 200;
-                const x = playerPos.x + Math.cos(angle) * distance;
-                const y = playerPos.y + Math.sin(angle) * distance;
+                // Spawn near center with random offset
+                let x = canvas.width / 2 + (Math.random() - 0.5) * 300;
+                let y = canvas.height / 2 + (Math.random() - 0.5) * 300;
+                
+                // Clamp to stay inside bounds
+                x = Math.max(50, Math.min(canvas.width - 50, x));
+                y = Math.max(50, Math.min(canvas.height - 50, y));
                 
                 const enemy = world.createEntity('enemy');
                 enemy.addComponent('position', Components.Position(x, y));
@@ -520,13 +522,15 @@ <h2>Live Stats</h2>
             if (!player) return;
             console.log('[Sandbox] Spawning elite');
             
-            const playerPos = player.getComponent('position');
             const profile = window.EnemyProfiles.PROFILES.SIEGE_HULK;
             
-            const angle = Math.random() * Math.PI * 2;
-            const distance = 400;
-            const x = playerPos.x + Math.cos(angle) * distance;
-            const y = playerPos.y + Math.sin(angle) * distance;
+            // Spawn near center with random offset
+            let x = canvas.width / 2 + (Math.random() - 0.5) * 300;
+            let y = canvas.height / 2 + (Math.random() - 0.5) * 300;
+            
+            // Clamp to stay inside bounds
+            x = Math.max(50, Math.min(canvas.width - 50, x));
+            y = Math.max(50, Math.min(canvas.height - 50, y));
             
             const enemy = world.createEntity('enemy');
             enemy.addComponent('position', Components.Position(x, y));

From ec5fa423ac38fab14e7c0bbc3350b4388929d44f Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 14 Feb 2026 21:45:00 +0000
Subject: [PATCH 15/17] Fix deltaTime clamping pattern to prevent movement
 teleporting

Co-authored-by: Linkatplug <36280686+Linkatplug@users.noreply.github.com>
---
 dev/combat-sandbox-clean.html | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/dev/combat-sandbox-clean.html b/dev/combat-sandbox-clean.html
index c5de618..b0e1788 100644
--- a/dev/combat-sandbox-clean.html
+++ b/dev/combat-sandbox-clean.html
@@ -364,9 +364,12 @@ <h2>Live Stats</h2>
         function gameLoop(currentTime) {
             if (!running) return;
             
-            const deltaTime = Math.min((currentTime - lastTime) / 1000, 0.1);
+            let deltaTime = (currentTime - lastTime) / 1000;
             lastTime = currentTime;
             
+            // Clamp deltaTime to prevent teleporting
+            deltaTime = Math.min(deltaTime, 0.1);
+            
             // Update systems based on flags
             if (systemFlags.movement) systems.movement.update(deltaTime);
             if (systemFlags.ai) systems.ai.update(deltaTime);

From 253232fa7efd23a482523dc8499c64a2a7b0c990 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 14 Feb 2026 22:04:28 +0000
Subject: [PATCH 16/17] Create combat sandbox using real Game class with
 disabled subsystems

Co-authored-by: Linkatplug <36280686+Linkatplug@users.noreply.github.com>
---
 dev/combat-sandbox.html | 415 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 415 insertions(+)
 create mode 100644 dev/combat-sandbox.html

diff --git a/dev/combat-sandbox.html b/dev/combat-sandbox.html
new file mode 100644
index 0000000..08c69a9
--- /dev/null
+++ b/dev/combat-sandbox.html
@@ -0,0 +1,415 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Combat Sandbox - Real Game Class</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            background: #0a0a1a;
+            font-family: 'Courier New', monospace;
+            color: #00ff00;
+            display: flex;
+            height: 100vh;
+            overflow: hidden;
+        }
+
+        #gameContainer {
+            flex: 1;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            position: relative;
+        }
+
+        #gameCanvas {
+            display: block;
+            background: #000;
+            border: 2px solid #00ff00;
+        }
+
+        #debugPanel {
+            width: 350px;
+            background: rgba(10, 10, 26, 0.95);
+            border-left: 2px solid #00ff00;
+            padding: 20px;
+            overflow-y: auto;
+            display: flex;
+            flex-direction: column;
+            gap: 20px;
+        }
+
+        .section {
+            border: 1px solid #00ff00;
+            padding: 15px;
+            border-radius: 5px;
+        }
+
+        .section h2 {
+            color: #00ff00;
+            font-size: 18px;
+            margin-bottom: 15px;
+            text-transform: uppercase;
+            letter-spacing: 2px;
+        }
+
+        .button {
+            background: linear-gradient(135deg, #00ff00 0%, #00aa00 100%);
+            color: #000;
+            border: none;
+            padding: 12px 20px;
+            font-size: 14px;
+            font-weight: bold;
+            cursor: pointer;
+            margin: 5px 0;
+            border-radius: 3px;
+            transition: all 0.2s;
+            text-transform: uppercase;
+            width: 100%;
+        }
+
+        .button:hover {
+            transform: scale(1.05);
+            box-shadow: 0 0 15px #00ff00;
+        }
+
+        .button:active {
+            transform: scale(0.95);
+        }
+
+        .stat-line {
+            display: flex;
+            justify-content: space-between;
+            margin: 8px 0;
+            font-size: 14px;
+        }
+
+        .stat-label {
+            color: #888;
+        }
+
+        .stat-value {
+            color: #00ff00;
+            font-weight: bold;
+        }
+
+        .info {
+            background: rgba(0, 255, 0, 0.1);
+            padding: 10px;
+            border-radius: 3px;
+            font-size: 12px;
+            margin-top: 10px;
+            color: #00ff00;
+        }
+
+        /* Hide default UI elements that Game creates */
+        #ui, .menu-screen, .level-up-screen, .game-over-screen, .meta-screen {
+            display: none !important;
+        }
+    </style>
+</head>
+<body>
+    <div id="gameContainer">
+        <canvas id="gameCanvas" width="1200" height="800"></canvas>
+        <!-- UI elements for Game class (will be hidden) -->
+        <div id="ui"></div>
+    </div>
+
+    <div id="debugPanel">
+        <div class="section">
+            <h2>Combat Sandbox</h2>
+            <div class="info">
+                Using Real Game Class<br>
+                WaveSystem: Disabled<br>
+                UISystem: Disabled<br>
+                AudioManager: Disabled
+            </div>
+        </div>
+
+        <div class="section">
+            <h2>Spawn Control</h2>
+            <button class="button" onclick="spawnScout(1)">Spawn 1 Scout</button>
+            <button class="button" onclick="spawnScout(5)">Spawn 5 Scouts</button>
+            <button class="button" onclick="spawnElite()">Spawn Elite</button>
+            <button class="button" onclick="clearEnemies()">Clear All Enemies</button>
+            <button class="button" onclick="resetPlayer()">Reset Player HP</button>
+        </div>
+
+        <div class="section">
+            <h2>Live Stats</h2>
+            <div class="stat-line">
+                <span class="stat-label">Enemies:</span>
+                <span class="stat-value" id="enemyCount">0</span>
+            </div>
+            <div class="stat-line">
+                <span class="stat-label">Shield:</span>
+                <span class="stat-value" id="shieldHP">---</span>
+            </div>
+            <div class="stat-line">
+                <span class="stat-label">Armor:</span>
+                <span class="stat-value" id="armorHP">---</span>
+            </div>
+            <div class="stat-line">
+                <span class="stat-label">Structure:</span>
+                <span class="stat-value" id="structureHP">---</span>
+            </div>
+            <div class="stat-line">
+                <span class="stat-label">Total HP:</span>
+                <span class="stat-value" id="totalHP">---</span>
+            </div>
+        </div>
+
+        <div class="section">
+            <h2>Info</h2>
+            <div class="info">
+                • WASD to move<br>
+                • Weapons fire automatically<br>
+                • No wave system<br>
+                • Manual spawn only<br>
+                • Real Game architecture
+            </div>
+        </div>
+    </div>
+
+    <!-- Load all game scripts in exact order from index.html -->
+    <script src="../js/constants.js"></script>
+    <script src="../js/utils/Math.js"></script>
+    <script src="../js/utils/Logger.js"></script>
+    <script src="../js/utils/DebugOverlay.js"></script>
+    <script src="../js/utils/ScreenEffects.js"></script>
+    <script src="../js/core/ECS.js"></script>
+    <script src="../js/core/GameState.js"></script>
+    <script src="../js/core/stats/ShipStats.js"></script>
+    <script src="../js/core/stats/FinalStatsCalculator.js"></script>
+    <script src="../js/data/PassiveData.js"></script>
+    <script src="../js/data/ShipData.js"></script>
+    <script src="../js/data/SynergyData.js"></script>
+    <script src="../js/data/KeystoneData.js"></script>
+    <script src="../js/data/DefenseData.js"></script>
+    <script src="../js/data/HeatData.js"></script>
+    <script src="../js/data/NewWeaponData.js"></script>
+    <script src="../js/data/ModuleData.js"></script>
+    <script src="../js/data/EnemyProfiles.js"></script>
+    <script src="../js/data/LootData.js"></script>
+    <script src="../js/data/TagSynergyData.js"></script>
+    <script src="../js/data/BalanceConstants.js"></script>
+    <script src="../js/data/ShipUpgradeData.js"></script>
+    <script src="../js/data/WeaponDataBridge.js"></script>
+    <script src="../js/ui/EnhancedUIComponents.js"></script>
+    <script src="../js/systems/MovementSystem.js"></script>
+    <script src="../js/systems/CombatSystem.js"></script>
+    <script src="../js/systems/CollisionSystem.js"></script>
+    <script src="../js/systems/AISystem.js"></script>
+    <script src="../js/systems/SpawnerSystem.js"></script>
+    <script src="../js/systems/PickupSystem.js"></script>
+    <script src="../js/systems/RenderSystem.js"></script>
+    <script src="../js/systems/UISystem.js"></script>
+    <script src="../js/systems/ParticleSystem.js"></script>
+    <script src="../js/systems/WaveSystem.js"></script>
+    <script src="../js/systems/SynergySystem.js"></script>
+    <script src="../js/systems/WeatherSystem.js"></script>
+    <script src="../js/systems/DefenseSystem.js"></script>
+    <script src="../js/systems/HeatSystem.js"></script>
+    <script src="../js/systems/ModuleSystem.js"></script>
+    <script src="../js/systems/ShipUpgradeSystem.js"></script>
+    <script src="../js/managers/SaveManager.js"></script>
+    <script src="../js/managers/ScoreManager.js"></script>
+    <script src="../js/managers/AudioManager.js"></script>
+    <script src="../js/dev/ContentAuditor.js"></script>
+    <script src="../js/dev/DevTools.js"></script>
+    <script src="../js/Game.js"></script>
+
+    <script>
+        // Global game instance
+        let game;
+
+        // Initialize the sandbox
+        function init() {
+            console.log('[Combat Sandbox] Initializing with real Game class...');
+
+            // Override setupUIListeners on prototype before instantiation
+            // This prevents errors with missing UI DOM elements
+            Game.prototype.setupUIListeners = function() {
+                console.log('[Combat Sandbox] UI listeners disabled (prototype override)');
+            };
+
+            // Create the real Game instance
+            game = new Game();
+            
+            // Disable WaveSystem before starting
+            if (game.systems.wave) {
+                console.log('[Combat Sandbox] Disabling WaveSystem');
+                game.systems.wave.update = function() {};
+                game.systems.wave.spawnWave = function() {};
+            }
+
+            // Disable UISystem before starting
+            if (game.systems.ui) {
+                console.log('[Combat Sandbox] Disabling UISystem');
+                game.systems.ui.update = function() {};
+                game.systems.ui.updateHUD = function() {};
+                game.systems.ui.showScreen = function() {};
+                game.systems.ui.showWaveAnnouncement = function() {};
+                game.systems.ui.showLevelUp = function() {};
+                game.systems.ui.showGameOver = function() {};
+            }
+
+            // Disable AudioManager before starting
+            if (game.audioManager) {
+                console.log('[Combat Sandbox] Disabling AudioManager');
+                game.audioManager.init = function() {};
+                game.audioManager.play = function() {};
+                game.audioManager.playSound = function() {};
+                game.audioManager.playMusic = function() {};
+                game.audioManager.stopAll = function() {};
+                game.audioManager.stopMusic = function() {};
+                game.audioManager.update = function() {};
+                game.audioManager.setVolume = function() {};
+                game.audioManager.startBackgroundMusic = function() {};
+                game.audioManager.stopBackgroundMusic = function() {};
+            }
+
+            // Set selected ship
+            game.gameState.selectedShip = 'ION_FRIGATE';
+            
+            // Start the game (this will initialize everything)
+            console.log('[Combat Sandbox] Starting game...');
+            game.startGame();
+            
+            console.log('[Combat Sandbox] Game started successfully');
+            console.log('[Combat Sandbox] Player:', game.player);
+            console.log('[Combat Sandbox] World:', game.world);
+            console.log('[Combat Sandbox] Systems:', game.systems);
+
+            // Start stats update loop
+            setInterval(updateStats, 100);
+        }
+
+        // Spawn scout enemies
+        function spawnScout(count) {
+            if (!game || !game.systems.spawner) {
+                console.error('[Combat Sandbox] Game not initialized');
+                return;
+            }
+
+            console.log(`[Combat Sandbox] Spawning ${count} scout(s)`);
+            
+            const canvas = game.canvas;
+            
+            for (let i = 0; i < count; i++) {
+                // Spawn near center with random offset
+                const x = canvas.width / 2 + (Math.random() - 0.5) * 400;
+                const y = canvas.height / 2 + (Math.random() - 0.5) * 400;
+                
+                // Create enemy data object with profileId
+                const enemyData = {
+                    profileId: 'SCOUT_DRONE',
+                    level: 1
+                };
+                
+                // Use SpawnerSystem.createEnemy
+                game.systems.spawner.createEnemy(x, y, enemyData, false);
+            }
+        }
+
+        // Spawn elite enemy
+        function spawnElite() {
+            if (!game || !game.systems.spawner) {
+                console.error('[Combat Sandbox] Game not initialized');
+                return;
+            }
+
+            console.log('[Combat Sandbox] Spawning elite enemy');
+            
+            const canvas = game.canvas;
+            
+            // Spawn at center
+            const x = canvas.width / 2;
+            const y = canvas.height / 2 - 100;
+            
+            // Create enemy data object with profileId
+            const enemyData = {
+                profileId: 'SIEGE_HULK',
+                level: 1
+            };
+            
+            game.systems.spawner.createEnemy(x, y, enemyData, false);
+        }
+
+        // Clear all enemies
+        function clearEnemies() {
+            if (!game || !game.world) {
+                console.error('[Combat Sandbox] Game not initialized');
+                return;
+            }
+
+            console.log('[Combat Sandbox] Clearing all enemies');
+            
+            const enemies = game.world.getEntitiesByType('enemy');
+            enemies.forEach(enemy => {
+                game.world.removeEntity(enemy.id);
+            });
+            
+            // Process removals immediately
+            game.world.processPendingRemovals();
+        }
+
+        // Reset player HP
+        function resetPlayer() {
+            if (!game || !game.player) {
+                console.error('[Combat Sandbox] Game not initialized');
+                return;
+            }
+
+            console.log('[Combat Sandbox] Resetting player HP');
+            
+            const defense = game.player.getComponent('defense');
+            if (defense) {
+                defense.shield.current = defense.shield.max;
+                defense.armor.current = defense.armor.max;
+                defense.structure.current = defense.structure.max;
+            }
+        }
+
+        // Update stats display
+        function updateStats() {
+            if (!game || !game.world || !game.player) return;
+
+            // Enemy count
+            const enemies = game.world.getEntitiesByType('enemy');
+            document.getElementById('enemyCount').textContent = enemies.length;
+
+            // Player HP
+            const defense = game.player.getComponent('defense');
+            if (defense) {
+                const shield = defense.shield;
+                const armor = defense.armor;
+                const structure = defense.structure;
+                
+                document.getElementById('shieldHP').textContent = 
+                    `${Math.round(shield.current)}/${shield.max}`;
+                document.getElementById('armorHP').textContent = 
+                    `${Math.round(armor.current)}/${armor.max}`;
+                document.getElementById('structureHP').textContent = 
+                    `${Math.round(structure.current)}/${structure.max}`;
+                
+                const total = Math.round(shield.current + armor.current + structure.current);
+                const maxTotal = shield.max + armor.max + structure.max;
+                document.getElementById('totalHP').textContent = `${total}/${maxTotal}`;
+            }
+        }
+
+        // Start when page loads
+        window.addEventListener('load', () => {
+            console.log('[Combat Sandbox] Page loaded, initializing...');
+            init();
+        });
+    </script>
+</body>
+</html>

From d324fd1f78f09efe4a10bd67df8a9221f1eeb7cf Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 14 Feb 2026 22:09:27 +0000
Subject: [PATCH 17/17] Add position validation guard to prevent NaN distance
 calculations in combat sandbox

Co-authored-by: Linkatplug <36280686+Linkatplug@users.noreply.github.com>
---
 dev/combat-sandbox.html | 45 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/dev/combat-sandbox.html b/dev/combat-sandbox.html
index 08c69a9..f7ce4fb 100644
--- a/dev/combat-sandbox.html
+++ b/dev/combat-sandbox.html
@@ -287,6 +287,51 @@ <h2>Info</h2>
             console.log('[Combat Sandbox] World:', game.world);
             console.log('[Combat Sandbox] Systems:', game.systems);
 
+            // Add position validation guard to prevent NaN calculations
+            if (game.systems.combat) {
+                console.log('[Combat Sandbox] Adding position validation guard to CombatSystem');
+                
+                // Helper function to validate entity position
+                function hasValidPosition(entity) {
+                    if (!entity) return false;
+                    const pos = entity.getComponent('position');
+                    if (!pos) return false;
+                    if (typeof pos.x !== 'number' || typeof pos.y !== 'number') return false;
+                    if (isNaN(pos.x) || isNaN(pos.y)) return false;
+                    return true;
+                }
+                
+                // Save original update method
+                const originalCombatUpdate = game.systems.combat.update.bind(game.systems.combat);
+                
+                // Override with validation wrapper
+                game.systems.combat.update = function(deltaTime) {
+                    // Validate player position
+                    const players = game.world.getEntitiesByType('player');
+                    if (players.length > 0) {
+                        const player = players[0];
+                        if (!hasValidPosition(player)) {
+                            console.warn('[Sandbox] Invalid position detected on player entity', player.id);
+                            return; // Skip combat update this frame
+                        }
+                    }
+                    
+                    // Validate all enemy positions
+                    const enemies = game.world.getEntitiesByType('enemy');
+                    for (const enemy of enemies) {
+                        if (!hasValidPosition(enemy)) {
+                            console.warn('[Sandbox] Invalid position detected on enemy entity', enemy.id);
+                            // Remove this enemy to prevent future errors
+                            game.world.removeEntity(enemy.id);
+                            continue;
+                        }
+                    }
+                    
+                    // All positions valid, call original update
+                    originalCombatUpdate(deltaTime);
+                };
+            }
+
             // Start stats update loop
             setInterval(updateStats, 100);
         }