Update index.html

index.html

@@ -478,9 +478,272 @@
             }
 
             makeStrategicMove() {
-                this.makeRandomMove();
+    const depth = this.difficulty === 'hard' ? 3 : 1;
+    let bestMove = this.findBestMove(depth);
+    
+    if(bestMove) {
+        this.placeStone(bestMove[0], bestMove[1]);
+    } else {
+        this.pass();
+    }
+}
+
+findBestMove(depth) {
+    let bestScore = -Infinity;
+    let bestMove = null;
+    
+    // 전체 보드를 평가
+    for(let i = 0; i < this.size; i++) {
+        for(let j = 0; j < this.size; j++) {
+            if(this.isValidMove(i, j)) {
+                // 임시로 돌을 놓아보고 평가
+                this.board[i][j] = 'white';
+                const score = this.minimax(depth - 1, false);
+                this.board[i][j] = null;
+                
+                if(score > bestScore) {
+                    bestScore = score;
+                    bestMove = [i, j];
+                }
+            }
+        }
+    }
+    
+    return bestMove;
+}
+
+minimax(depth, isMaximizing) {
+    if(depth === 0) {
+        return this.evaluateBoard();
+    }
+    
+    if(isMaximizing) {
+        let maxScore = -Infinity;
+        for(let i = 0; i < this.size; i++) {
+            for(let j = 0; j < this.size; j++) {
+                if(this.isValidMove(i, j)) {
+                    this.board[i][j] = 'white';
+                    const score = this.minimax(depth - 1, false);
+                    this.board[i][j] = null;
+                    maxScore = Math.max(maxScore, score);
+                }
+            }
+        }
+        return maxScore;
+    } else {
+        let minScore = Infinity;
+        for(let i = 0; i < this.size; i++) {
+            for(let j = 0; j < this.size; j++) {
+                if(this.isValidMove(i, j)) {
+                    this.board[i][j] = 'black';
+                    const score = this.minimax(depth - 1, true);
+                    this.board[i][j] = null;
+                    minScore = Math.min(minScore, score);
+                }
+            }
+        }
+        return minScore;
+    }
+}
+
+evaluateBoard() {
+    return this.evaluateTerritory() + 
+           this.evaluateInfluence() + 
+           this.evaluateCaptureThreats() +
+           this.evaluateConnectivity();
+}
+
+evaluateTerritory() {
+    let score = 0;
+    const visited = new Set();
+    
+    for(let i = 0; i < this.size; i++) {
+        for(let j = 0; j < this.size; j++) {
+            if(!visited.has(`${i},${j}`) && this.board[i][j] === null) {
+                const territory = this.floodFillTerritory(i, j, visited);
+                const owner = this.determineTerritorySide(territory);
+                if(owner === 'white') score += territory.size;
+                else if(owner === 'black') score -= territory.size;
+            }
+        }
+    }
+    
+    return score;
+}
+
+floodFillTerritory(row, col, visited) {
+    const territory = new Set();
+    const stack = [[row, col]];
+    const borders = new Set();
+    
+    while(stack.length > 0) {
+        const [r, c] = stack.pop();
+        const key = `${r},${c}`;
+        
+        if(!visited.has(key)) {
+            visited.add(key);
+            if(this.board[r][c] === null) {
+                territory.add(key);
+                
+                const neighbors = this.getNeighbors(r, c);
+                for(const [nr, nc] of neighbors) {
+                    if(this.board[nr][nc] === null) {
+                        stack.push([nr, nc]);
+                    } else {
+                        borders.add(`${nr},${nc}`);
+                    }
+                }
+            }
+        }
+    }
+    
+    territory.borders = borders;
+    return territory;
+}
+
+determineTerritorySide(territory) {
+    let blackCount = 0;
+    let whiteCount = 0;
+    
+    for(const pos of territory.borders) {
+        const [row, col] = pos.split(',').map(Number);
+        if(this.board[row][col] === 'black') blackCount++;
+        else if(this.board[row][col] === 'white') whiteCount++;
+    }
+    
+    if(blackCount > whiteCount) return 'black';
+    if(whiteCount > blackCount) return 'white';
+    return null;
+}
+
+evaluateInfluence() {
+    let score = 0;
+    
+    for(let i = 0; i < this.size; i++) {
+        for(let j = 0; j < this.size; j++) {
+            if(this.board[i][j] === 'white') {
+                score += this.calculateInfluence(i, j, 3);
+            } else if(this.board[i][j] === 'black') {
+                score -= this.calculateInfluence(i, j, 3);
             }
         }
+    }
+    
+    return score;
+}
+
+calculateInfluence(row, col, radius) {
+    let influence = 0;
+    
+    for(let i = -radius; i <= radius; i++) {
+        for(let j = -radius; j <= radius; j++) {
+            const distance = Math.abs(i) + Math.abs(j);
+            if(distance <= radius) {
+                const newRow = row + i;
+                const newCol = col + j;
+                
+                if(newRow >= 0 && newRow < this.size && 
+                   newCol >= 0 && newCol < this.size) {
+                    influence += (radius - distance + 1) / radius;
+                }
+            }
+        }
+    }
+    
+    return influence;
+}
+
+evaluateCaptureThreats() {
+    let score = 0;
+    
+    for(let i = 0; i < this.size; i++) {
+        for(let j = 0; j < this.size; j++) {
+            if(this.board[i][j]) {
+                const group = this.getGroup(i, j);
+                const liberties = this.countLiberties(group);
+                
+                if(this.board[i][j] === 'white') {
+                    score += liberties * 2;
+                    if(liberties === 1) score -= 10;
+                } else {
+                    score -= liberties * 2;
+                    if(liberties === 1) score += 10;
+                }
+            }
+        }
+    }
+    
+    return score;
+}
+
+countLiberties(group) {
+    const liberties = new Set();
+    
+    for(const [row, col] of group) {
+        const neighbors = this.getNeighbors(row, col);
+        for(const [nRow, nCol] of neighbors) {
+            if(this.board[nRow][nCol] === null) {
+                liberties.add(`${nRow},${nCol}`);
+            }
+        }
+    }
+    
+    return liberties.size;
+}
+
+evaluateConnectivity() {
+    let score = 0;
+    
+    for(let i = 0; i < this.size; i++) {
+        for(let j = 0; j < this.size; j++) {
+            if(this.board[i][j] === 'white') {
+                score += this.evaluateStoneConnectivity(i, j);
+            } else if(this.board[i][j] === 'black') {
+                score -= this.evaluateStoneConnectivity(i, j);
+            }
+        }
+    }
+    
+    return score;
+}
+
+evaluateStoneConnectivity(row, col) {
+    let connectivity = 0;
+    const neighbors = this.getNeighbors(row, col);
+    const diagonalNeighbors = this.getDiagonalNeighbors(row, col);
+    
+    for(const [nRow, nCol] of neighbors) {
+        if(this.board[nRow][nCol] === this.board[row][col]) {
+            connectivity += 2;
+        }
+    }
+    
+    for(const [nRow, nCol] of diagonalNeighbors) {
+        if(this.board[nRow][nCol] === this.board[row][col]) {
+            connectivity += 1;
+        }
+    }
+    
+    return connectivity;
+}
+
+getDiagonalNeighbors(row, col) {
+    const neighbors = [];
+    const directions = [[-1,-1], [-1,1], [1,-1], [1,1]];
+    
+    for(const [dRow, dCol] of directions) {
+        const newRow = row + dRow;
+        const newCol = col + dCol;
+        
+        if(newRow >= 0 && newRow < this.size && 
+           newCol >= 0 && newCol < this.size) {
+            neighbors.push([newRow, newCol]);
+        }
+    }
+    
+    return neighbors;
+}
+        }
 
         const game = new GoGame();
     </script>