Update index.html

index.html

@@ -459,46 +459,21 @@
                 }
             }
 
-            makeRandomMove() {
-                const validMoves = [];
-                for(let i = 0; i < this.size; i++) {
-                    for(let j = 0; j < this.size; j++) {
-                        if(this.isValidMove(i, j)) {
-                            validMoves.push([i, j]);
-                        }
-                    }
-                }
-
-                if(validMoves.length > 0) {
-                    const [row, col] = validMoves[Math.floor(Math.random() * validMoves.length)];
-                    this.placeStone(row, col);
-                } else {
-                    this.pass();
-                }
-            }
-
-            makeStrategicMove() {
-    const depth = this.difficulty === 'hard' ? 3 : 1;
-    let bestMove = this.findBestMove(depth);
+            // GoGame 클래스 내의 makeStrategicMove 메소드를 다음과 같이 수정
+makeStrategicMove() {
+    // 현재 보드 상태 평가
+    const boardScore = this.evaluateBoard();
     
-    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);
+                const score = this.calculateMoveScore(i, j, boardScore);
                 this.board[i][j] = null;
                 
                 if(score > bestScore) {
@@ -509,169 +484,116 @@ findBestMove(depth) {
         }
     }
     
-    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;
+    if(bestMove) {
+        this.placeStone(bestMove[0], bestMove[1]);
     } 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;
+        this.pass();
     }
 }
 
 evaluateBoard() {
-    return this.evaluateTerritory() + 
-           this.evaluateInfluence() + 
-           this.evaluateCaptureThreats() +
-           this.evaluateConnectivity();
+    const evaluation = {
+        territory: this.evaluateTerritory(),
+        influence: this.evaluateInfluence(),
+        connections: this.evaluateConnections(),
+        captures: this.captures
+    };
+    return evaluation;
 }
 
-evaluateTerritory() {
+calculateMoveScore(row, col, boardScore) {
     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;
-            }
-        }
-    }
+    // 1. 영토 점수
+    score += this.calculateTerritoryScore(row, col) * 2;
+    
+    // 2. 연결성 점수
+    score += this.calculateConnectionScore(row, col) * 1.5;
+    
+    // 3. 공격/방어 점수
+    score += this.calculateTacticalScore(row, col);
+    
+    // 4. 위험 회피 점수
+    score += this.calculateSafetyScore(row, col);
+    
+    // 5. 전략적 위치 점수
+    score += this.calculateStrategicScore(row, col);
     
     return score;
 }
 
-floodFillTerritory(row, col, visited) {
-    const territory = new Set();
-    const stack = [[row, col]];
-    const borders = new Set();
+calculateTerritoryScore(row, col) {
+    let score = 0;
+    const radius = 3;
     
-    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}`);
-                    }
-                }
+    for(let i = Math.max(0, row-radius); i <= Math.min(this.size-1, row+radius); i++) {
+        for(let j = Math.max(0, col-radius); j <= Math.min(this.size-1, col+radius); j++) {
+            const distance = Math.abs(row-i) + Math.abs(col-j);
+            if(distance <= radius) {
+                if(this.board[i][j] === null) score += (radius - distance + 1);
+                else if(this.board[i][j] === 'white') score += 2;
+                else score -= 1;
             }
         }
     }
-    
-    territory.borders = borders;
-    return territory;
+    return score;
 }
 
-determineTerritorySide(territory) {
-    let blackCount = 0;
-    let whiteCount = 0;
+calculateConnectionScore(row, col) {
+    let score = 0;
+    const neighbors = this.getNeighbors(row, col);
     
-    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++;
+    for(const [nRow, nCol] of neighbors) {
+        if(this.board[nRow][nCol] === 'white') {
+            score += 10;
+            // 두 돌이 연결되면 더 높은 점수
+            if(this.areConnected(row, col, nRow, nCol)) score += 5;
+        }
     }
-    
-    if(blackCount > whiteCount) return 'black';
-    if(whiteCount > blackCount) return 'white';
-    return null;
+    return score;
 }
 
-evaluateInfluence() {
+calculateTacticalScore(row, col) {
     let score = 0;
+    const neighbors = this.getNeighbors(row, col);
     
-    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);
-            }
+    // 상대 돌 공격 기회 확인
+    for(const [nRow, nCol] of neighbors) {
+        if(this.board[nRow][nCol] === 'black') {
+            const group = this.getGroup(nRow, nCol);
+            const liberties = this.countLiberties(group);
+            if(liberties <= 2) score += (20 - liberties * 5);
         }
     }
     
     return score;
 }
 
-calculateInfluence(row, col, radius) {
-    let influence = 0;
+calculateSafetyScore(row, col) {
+    let score = 0;
+    const group = [[row, col]];
+    const liberties = this.countLiberties(group);
     
-    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;
-                }
-            }
-        }
-    }
+    score += liberties * 5;
+    
+    // 눈 형성 가능성 체크
+    if(this.canFormEye(row, col)) score += 15;
     
-    return influence;
+    return score;
 }
 
-evaluateCaptureThreats() {
+calculateStrategicScore(row, col) {
     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;
-                }
-            }
-        }
-    }
+    // 중앙 지역 선호
+    const centerDistance = Math.abs(row - 9) + Math.abs(col - 9);
+    score += Math.max(0, 10 - centerDistance);
+    
+    // 변에 붙지 않도록
+    if(row === 0 || row === 18 || col === 0 || col === 18) score -= 5;
+    
+    // 스타포인트 근처 선호
+    if(this.isNearStarPoint(row, col)) score += 3;
     
     return score;
 }
@@ -691,57 +613,41 @@ countLiberties(group) {
     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;
+canFormEye(row, col) {
     const neighbors = this.getNeighbors(row, col);
-    const diagonalNeighbors = this.getDiagonalNeighbors(row, col);
+    let whiteCount = 0;
+    let emptyCount = 0;
     
     for(const [nRow, nCol] of neighbors) {
-        if(this.board[nRow][nCol] === this.board[row][col]) {
-            connectivity += 2;
-        }
+        if(this.board[nRow][nCol] === 'white') whiteCount++;
+        else if(this.board[nRow][nCol] === null) emptyCount++;
     }
     
-    for(const [nRow, nCol] of diagonalNeighbors) {
-        if(this.board[nRow][nCol] === this.board[row][col]) {
-            connectivity += 1;
-        }
-    }
+    return whiteCount >= 2 && emptyCount >= 1;
+}
+
+isNearStarPoint(row, col) {
+    const starPoints = [
+        [3,3], [3,9], [3,15],
+        [9,3], [9,9], [9,15],
+        [15,3], [15,9], [15,15]
+    ];
     
-    return connectivity;
+    return starPoints.some(point => 
+        Math.abs(point[0] - row) <= 1 && 
+        Math.abs(point[1] - col) <= 1
+    );
 }
 
-getDiagonalNeighbors(row, col) {
-    const neighbors = [];
-    const directions = [[-1,-1], [-1,1], [1,-1], [1,1]];
+areConnected(row1, col1, row2, col2) {
+    const diagonal = Math.abs(row1 - row2) === 1 && Math.abs(col1 - col2) === 1;
+    if(!diagonal) return true;
     
-    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]);
-        }
-    }
+    // 대각선 방향 연결 확인
+    const mid1 = this.board[row1][col2];
+    const mid2 = this.board[row2][col1];
     
-    return neighbors;
+    return mid1 === null || mid2 === null;
 }
         }