Merge pull request #5 from CodeKunalTomar/copilot/fix-ai-edge-threats

Fix AI edge/corner blind spot by rebalancing priorities and adding threat detection

Author: CodeKunalTomar

.gitignore

@@ -1,6 +1,7 @@
 # Test files
 test-*.html
 test-*.js
+validate-changes.js
 
 # macOS
 .DS_Store

Connect-4.js

@@ -43,6 +43,18 @@ const OPENING_BOOK = {
 
     // Early game center control patterns
     '3132113122': 2, '3132413242': 4, '3132513252': 4, '3132213222': 2,
+    
+    // Edge defense - Human opens on column 0
+    '0131': 0,       // Contest the edge!
+    '013101': 0,     // Continue contesting
+    
+    // Edge defense - Human opens on column 6  
+    '6131': 6,       // Contest the edge!
+    '613161': 6,     // Continue contesting
+    
+    // Block 3-stacks on edges
+    '010111': 0,     // Block left edge 3-stack
+    '616161': 6,     // Block right edge 3-stack
 };
 const MAX_OPENING_MOVES = 15; // Use opening book for first 15 moves (7-8 ply per side)
 
@@ -559,6 +571,38 @@ GameState.prototype.countPotentialLines = function(player) {
     return lines;
 }
 
+// Detect threats building on edges (columns 0, 1, 5, 6)
+GameState.prototype.detectEdgeThreats = function(player) {
+    let threats = 0;
+    const edgeCols = [0, 1, 5, 6];
+    
+    for (const col of edgeCols) {
+        const height = this.bitboard.heights[col];
+        
+        // Check vertical stacking - count consecutive pieces from the top
+        if (height >= 2) {
+            let consecutive = 0;
+            let maxConsecutive = 0;
+            
+            for (let row = 0; row < height; row++) {
+                if (this.board[col][row] === player) {
+                    consecutive++;
+                    maxConsecutive = Math.max(maxConsecutive, consecutive);
+                } else {
+                    consecutive = 0;
+                }
+            }
+            
+            // Threat if there are 2+ consecutive pieces and room to grow
+            if (maxConsecutive >= 2 && height < TOTAL_ROWS) {
+                threats++;
+            }
+        }
+    }
+    
+    return threats;
+};
+
 // Comprehensive evaluation for near-perfect play
 GameState.prototype.advancedEvaluate = function(player) {
     const opponent = player === 1 ? 2 : 1;
@@ -605,6 +649,12 @@ GameState.prototype.advancedEvaluate = function(player) {
     score += this.countPotentialLines(2) * AI_CONFIG.MOBILITY_WEIGHT;
     score -= this.countPotentialLines(1) * AI_CONFIG.MOBILITY_WEIGHT;
 
+    // 7. Edge threat detection
+    const aiEdgeThreats = this.detectEdgeThreats(2);
+    const humanEdgeThreats = this.detectEdgeThreats(1);
+    score += aiEdgeThreats * 400;
+    score -= humanEdgeThreats * 600; // Weight human edge threats higher (defensive)
+    
     return score;
 }
 
@@ -644,37 +694,40 @@ function orderMoves(node, depth, ttBestMove) {
     const moveScores = moves.map(col => {
         let score = 0;
 
-        // 1. TT move has highest priority (10000)
+        // 1. Immediate win detection (HIGHEST PRIORITY - always try winning moves first)
+        const testState = new GameState(node);
+        testState.makeMove(2, col);
+        if (testState.isWin() && testState.score === COMPUTER_WIN_SCORE) {
+            score += 100000;
+        }
+        
+        // 2. Block opponent's immediate win (CRITICAL - must block threats)
+        const blockState = new GameState(node);
+        blockState.makeMove(1, col);
+        if (blockState.isWin() && blockState.score === HUMAN_WIN_SCORE) {
+            score += 90000;
+        }
+        
+        // 3. TT move (good move from previous search)
         if (col === ttBestMove) {
-            score += 10000;
+            score += 5000;
         }
 
-        // 2. Killer moves (900 and 800)
+        // 4. Killer moves (900 and 800)
         if (depth < killerMoves.length) {
             if (col === killerMoves[depth][0]) score += 900;
             if (col === killerMoves[depth][1]) score += 800;
         }
 
-        // 3. History heuristic
+        // 5. History heuristic
         score += historyTable[col] || 0;
 
-        // 4. Center preference (positional bonus)
-        const centerBonus = [10, 20, 30, 40, 30, 20, 10];
+        // 6. Center preference (reduced bonus to avoid over-prioritization)
+        const centerBonus = [5, 10, 15, 20, 15, 10, 5];
         score += centerBonus[col];
 
-        // 5. Immediate win detection (should be tried first after TT)
-        const testState = new GameState(node);
-        testState.makeMove(2, col);
-        if (testState.isWin() && testState.score === COMPUTER_WIN_SCORE) {
-            score += 50000; // Even higher than TT move - always try winning moves first
-        }
-        
-        // 6. Block opponent's immediate win
-        const blockState = new GameState(node);
-        blockState.makeMove(1, col);
-        if (blockState.isWin() && blockState.score === HUMAN_WIN_SCORE) {
-            score += 8000; // High priority but below winning move
-        }
+        // 7. Threat prevention evaluation (reuse states to optimize performance)
+        score += evaluateThreatPrevention(node, col, blockState, testState);
 
         return { col, score };
     });
@@ -685,6 +738,49 @@ function orderMoves(node, depth, ttBestMove) {
     return moveScores.map(m => m.col);
 }
 
+// ============================================================================
+// THREAT PREVENTION EVALUATION
+// ============================================================================
+// Evaluate how important it is to play in this column to prevent opponent threats
+// This is a lighter-weight version that reuses states already created in orderMoves
+function evaluateThreatPrevention(node, col, blockState, testState) {
+    let score = 0;
+    const row = node.bitboard.heights[col];
+    if (row >= TOTAL_ROWS) return 0;
+    
+    // Reuse blockState if provided, otherwise create it
+    if (!blockState) {
+        blockState = new GameState(node);
+        blockState.makeMove(1, col); // Human moves here
+    }
+    
+    // Check if this creates a 3-in-a-row threat for opponent
+    const threatsAfter = blockState.countThreats(1, 3);
+    if (threatsAfter > 0) {
+        score += 3000 * threatsAfter;
+    }
+    
+    // Check for potential double-threat setup
+    const doubleThreatsAfter = blockState.countDoubleThreats(1);
+    if (doubleThreatsAfter > 0) {
+        score += 7000;
+    }
+    
+    // Reuse testState if provided, otherwise create it
+    if (!testState) {
+        testState = new GameState(node);
+        testState.makeMove(2, col);
+    }
+    
+    // Also reward moves that create threats for AI
+    const aiThreats = testState.countThreats(2, 3);
+    if (aiThreats > 0) {
+        score += 2000 * aiThreats;
+    }
+    
+    return score;
+}
+
 // listen for messages from the main thread
 self.addEventListener('message', function(e) {
     switch(e.data.messageType) {

README.md

@@ -286,7 +286,51 @@ This implementation now includes **10 advanced AI techniques** that create near-
 | **Research Platform** | Design a plug-and-play AI module interface, add an analytics dashboard            | 📝 **Planned** |
 
 ---
-## X. License and Citation
+## X. AI Testing & Robustness
+
+### Bug Fix: Edge/Corner Blind Spot (v2.0)
+A critical vulnerability was identified where the AI over-prioritized center positions and failed to respond to edge column threats. This has been fixed with:
+- **Rebalanced move ordering priorities**: Winning moves (100,000), blocking moves (90,000), TT moves (5,000), and reduced center bonus ([5, 10, 15, 20, 15, 10, 5])
+- **New threat prevention evaluation**: Detects 3-in-a-row threats and double-threat setups before they become critical
+- **Edge threat detection system**: Specifically monitors columns 0, 1, 5, and 6 for vertical stacking threats
+- **Expanded opening book for edge defense**: Pre-computed responses to edge and corner opening strategies
+
+### Running Tests
+The AI includes a comprehensive test suite in `ai-tests.js`:
+```javascript
+// In browser console (after loading Connect-4.js and ai-tests.js):
+runAITests();
+```
+
+Test categories:
+- ✅ Immediate win detection (horizontal, vertical, diagonal)
+- ✅ Immediate block detection (all directions)  
+- ✅ Edge/corner threat response (columns 0, 1, 5, 6)
+- ✅ Double threat creation and blocking
+- ✅ Win vs block priority
+- ✅ Strategic opening moves
+
+### Example Bug Scenario (Now Fixed)
+**Before Fix:**
+```
+Turn 1: Human plays column 0 (corner)
+Turn 2: AI plays column 3 (center) - IGNORING the threat
+Turn 3: Human plays column 0 (stacks corner)
+Turn 4: AI plays column 3 (center) - STILL IGNORING
+Turn 5: Human plays column 0 (3 in a row!)
+Turn 6: AI finally notices but it's too late
+```
+
+**After Fix:**
+```
+Turn 1: Human plays column 0 (corner)
+Turn 2: AI plays column 3 (center)
+Turn 3: Human plays column 0 (stacks corner)
+Turn 4: AI plays column 0 or 1 - BLOCKING the edge threat!
+```
+
+---
+## XI. License and Citation
 This project is licensed under the **MIT License**, granting broad permissions for academic, personal, and commercial use.
 
 

TESTING.md

@@ -0,0 +1,137 @@
+# AI Testing Guide
+
+## Overview
+This guide explains how to test the AI improvements for the edge/corner blind spot fix.
+
+## Quick Start
+
+### Browser-Based Testing (Recommended)
+1. Start a local web server:
+   ```bash
+   python3 -m http.server 8000
+   # OR
+   npx live-server
+   ```
+
+2. Open your browser to:
+   ```
+   http://localhost:8000/test-ai.html
+   ```
+
+3. Click "Run Tests" to execute all 13 test cases
+
+4. Review results:
+   - ✅ Green = Test passed
+   - ❌ Red = Test failed
+
+## Test Categories
+
+### 1. Immediate Win Detection
+- Tests that AI takes winning moves when available
+- Covers horizontal and vertical wins
+- Validates win priority over other moves
+
+### 2. Immediate Block Detection
+- Tests that AI blocks opponent's winning moves
+- Covers horizontal and vertical blocks
+- Validates blocking priority is high
+
+### 3. Edge/Corner Threat Response (THE BUG FIX)
+- Tests AI response to column 0 stacking
+- Tests AI response to column 6 stacking
+- Tests AI blocks 3-stacks on edges
+- Validates the fix for the reported vulnerability
+
+### 4. Double Threat Handling
+- Tests AI creates double threats when possible
+- Tests AI blocks opponent double threat setups
+- Validates advanced tactical awareness
+
+### 5. Win vs Block Priority
+- Tests AI takes wins over blocks
+- Validates priority ordering is correct
+
+### 6. Strategic Opening
+- Tests AI prefers center on empty board
+- Tests AI contests center appropriately
+
+## Manual Testing
+
+You can also test manually by playing the game:
+
+1. Open `index.html` in your browser
+2. Select "VS AI" mode
+3. Try to build a vertical stack on column 0 or 6
+4. The AI should now contest these edges instead of ignoring them
+
+### Test Scenario 1: Column 0 Stack
+```
+Turn 1: You play column 0
+Turn 2: AI plays column 3 (center)
+Turn 3: You play column 0 again
+Turn 4: AI should now play column 0 or 1 (not just column 3!)
+```
+
+### Test Scenario 2: Column 6 Stack
+```
+Turn 1: You play column 6
+Turn 2: AI plays column 3 (center)
+Turn 3: You play column 6 again
+Turn 4: AI should now play column 5 or 6 (not just column 3!)
+```
+
+## Expected Results
+
+All 13 tests should pass:
+- ✅ AI takes horizontal win
+- ✅ AI takes vertical win
+- ✅ AI blocks horizontal threat
+- ✅ AI blocks vertical threat
+- ✅ AI responds to column 0 stacking
+- ✅ AI responds to column 6 stacking
+- ✅ AI blocks corner 3-stack on column 0
+- ✅ AI blocks corner 3-stack on column 6
+- ✅ AI creates double threat
+- ✅ AI blocks opponent double threat setup
+- ✅ AI takes win over block
+- ✅ AI prefers center on empty board
+- ✅ AI contests center
+
+## Troubleshooting
+
+### Tests Don't Run
+- Ensure you're using a local web server (not file://)
+- Check browser console for errors
+- Verify Connect-4.js and ai-tests.js are loaded
+
+### Some Tests Fail
+- This may indicate the AI needs deeper search
+- Try increasing the depth parameter in the test (currently 10)
+- Check that all code changes were applied correctly
+
+### Manual Tests Show Different Behavior
+- AI uses randomness when multiple moves have equal scores
+- Try multiple games to see consistent patterns
+- The AI should generally contest edges, not always the exact same column
+
+## Performance Notes
+
+- Each test runs a depth-10 search
+- Full test suite takes 10-30 seconds
+- Browser may appear frozen during testing (this is normal)
+- Results are logged to console for debugging
+
+## Validation
+
+To verify all changes were applied correctly:
+```bash
+node validate-changes.js
+```
+
+This checks:
+- Move ordering priorities
+- Threat prevention function
+- Edge threat detection
+- Opening book expansion
+- Test file existence
+- Documentation updates