Phaser Baduk Metaverse 프로젝트의 바둑 게임 로직과 규칙 구현에 대해 설명합니다.

바둑 게임의 핵심 규칙과 로직을 JavaScript로 구현하여 정확한 바둑 게임을 제공합니다.

바둑의 기본 규칙: 1. 착수: 흑돌부터 시작하여 번갈아가며 돌을 놓습니다. 2. 자유도: 돌은 최소 하나의 자유도를 가져야 합니다. 3. 착수: 상대방 돌의 자유도를 모두 없애면 그 돌을 제거할 수 있습니다. 4. 자충: 자신의 돌을 자유도 없이 놓을 수 없습니다. 5. 계가: 게임 종료 후 점수를 계산합니다.

게임 상태 클래스:

export default class BadukGameState {
    constructor() {
        this.board = Array(19).fill().map(() => Array(19).fill(null));
        this.currentPlayer = 'black'; // 'black' 또는 'white'
        this.capturedStones = { black: 0, white: 0 };
        this.territory = { black: 0, white: 0 };
        this.gamePhase = 'playing'; // 'playing', 'counting', 'finished'
        this.moveHistory = [];
        this.lastMove = null;
    }
 
    // 게임 상태 초기화
    reset() {
        this.board = Array(19).fill().map(() => Array(19).fill(null));
        this.currentPlayer = 'black';
        this.capturedStones = { black: 0, white: 0 };
        this.territory = { black: 0, white: 0 };
        this.gamePhase = 'playing';
        this.moveHistory = [];
        this.lastMove = null;
    }
 
    // 현재 상태를 JSON으로 직렬화
    toJSON() {
        return {
            board: this.board,
            currentPlayer: this.currentPlayer,
            capturedStones: this.capturedStones,
            territory: this.territory,
            gamePhase: this.gamePhase,
            moveHistory: this.moveHistory,
            lastMove: this.lastMove
        };
    }
 
    // JSON에서 상태 복원
    fromJSON(data) {
        this.board = data.board;
        this.currentPlayer = data.currentPlayer;
        this.capturedStones = data.capturedStones;
        this.territory = data.territory;
        this.gamePhase = data.gamePhase;
        this.moveHistory = data.moveHistory;
        this.lastMove = data.lastMove;
    }
}

유효한 이동 확인:

export default class BadukMoveValidator {
    constructor(gameState) {
        this.gameState = gameState;
    }
 
    // 이동이 유효한지 확인
    isValidMove(x, y, player) {
        // 1. 바둑판 범위 확인
        if (!this.isInBounds(x, y)) {
            return { valid: false, reason: '바둑판 범위를 벗어났습니다.' };
        }
 
        // 2. 이미 돌이 놓인 위치인지 확인
        if (this.gameState.board[y][x] !== null) {
            return { valid: false, reason: '이미 돌이 놓인 위치입니다.' };
        }
 
        // 3. 자충 규칙 확인
        if (this.isSuicide(x, y, player)) {
            return { valid: false, reason: '자충은 허용되지 않습니다.' };
        }
 
        // 4. 코 규칙 확인 (같은 위치에 연속으로 놓을 수 없음)
        if (this.isKoViolation(x, y)) {
            return { valid: false, reason: '코 규칙 위반입니다.' };
        }
 
        return { valid: true, reason: '유효한 이동입니다.' };
    }
 
    // 바둑판 범위 확인
    isInBounds(x, y) {
        return x >= 0 && x < 19 && y >= 0 && y < 19;
    }
 
    // 자충 확인
    isSuicide(x, y, player) {
        // 임시로 돌을 놓아보고 자유도 확인
        this.gameState.board[y][x] = player;
 
        const hasLiberties = this.hasLiberties(x, y);
        const canCapture = this.canCaptureOpponent(x, y, player);
 
        // 원래 상태로 복원
        this.gameState.board[y][x] = null;
 
        // 자유도가 없고 상대방을 잡을 수 없다면 자충
        return !hasLiberties && !canCapture;
    }
 
    // 자유도 확인
    hasLiberties(x, y) {
        const color = this.gameState.board[y][x];
        if (!color) return false;
 
        const visited = new Set();
        return this.checkGroupLiberties(x, y, color, visited);
    }
 
    // 그룹의 자유도 확인
    checkGroupLiberties(x, y, color, visited) {
        const key = `${x},${y}`;
        if (visited.has(key)) return false;
        visited.add(key);
 
        const directions = [[0, 1], [0, -1], [1, 0], [-1, 0]];
 
        for (const [dx, dy] of directions) {
            const nx = x + dx;
            const ny = y + dy;
 
            if (!this.isInBounds(nx, ny)) continue;
 
            if (this.gameState.board[ny][nx] === null) {
                return true; // 자유도 발견
            }
 
            if (this.gameState.board[ny][nx] === color) {
                if (this.checkGroupLiberties(nx, ny, color, visited)) {
                    return true;
                }
            }
        }
 
        return false;
    }
 
    // 상대방 돌을 잡을 수 있는지 확인
    canCaptureOpponent(x, y, player) {
        const opponent = player === 'black' ? 'white' : 'black';
        const directions = [[0, 1], [0, -1], [1, 0], [-1, 0]];
 
        for (const [dx, dy] of directions) {
            const nx = x + dx;
            const ny = y + dy;
 
            if (!this.isInBounds(nx, ny)) continue;
 
            if (this.gameState.board[ny][nx] === opponent) {
                if (!this.hasLiberties(nx, ny)) {
                    return true;
                }
            }
        }
 
        return false;
    }
 
    // 코 규칙 확인
    isKoViolation(x, y) {
        if (!this.gameState.lastMove) return false;
 
        // 마지막 이동이 착수였다면, 같은 위치에 놓을 수 없음
        if (this.gameState.lastMove.type === 'capture') {
            return x === this.gameState.lastMove.capturedX && 
                   y === this.gameState.lastMove.capturedY;
        }
 
        return false;
    }
}

착수 처리:

export default class BadukCaptureLogic {
    constructor(gameState) {
        this.gameState = gameState;
    }
 
    // 돌 놓기 및 착수 처리
    placeStone(x, y, player) {
        const validator = new BadukMoveValidator(this.gameState);
        const validation = validator.isValidMove(x, y, player);
 
        if (!validation.valid) {
            return { success: false, reason: validation.reason };
        }
 
        // 돌 놓기
        this.gameState.board[y][x] = player;
 
        // 착수 확인 및 처리
        const captured = this.processCapture(x, y, player);
 
        // 이동 기록
        this.gameState.moveHistory.push({
            x: x,
            y: y,
            player: player,
            captured: captured,
            timestamp: Date.now()
        });
 
        this.gameState.lastMove = {
            x: x,
            y: y,
            player: player,
            type: captured > 0 ? 'capture' : 'place'
        };
 
        // 플레이어 변경
        this.gameState.currentPlayer = player === 'black' ? 'white' : 'black';
 
        return { success: true, captured: captured };
    }
 
    // 착수 처리
    processCapture(x, y, player) {
        const directions = [[0, 1], [0, -1], [1, 0], [-1, 0]];
        let totalCaptured = 0;
        const capturedPositions = [];
 
        for (const [dx, dy] of directions) {
            const nx = x + dx;
            const ny = y + dy;
 
            if (!this.isInBounds(nx, ny)) continue;
 
            const opponent = player === 'black' ? 'white' : 'black';
 
            if (this.gameState.board[ny][nx] === opponent) {
                if (!this.hasLiberties(nx, ny)) {
                    const captured = this.removeGroup(nx, ny);
                    totalCaptured += captured;
                    capturedPositions.push({ x: nx, y: ny, count: captured });
                }
            }
        }
 
        // 착수 기록
        if (capturedPositions.length > 0) {
            this.gameState.lastMove.capturedPositions = capturedPositions;
        }
 
        this.gameState.capturedStones[player] += totalCaptured;
 
        return totalCaptured;
    }
 
    // 그룹 제거
    removeGroup(x, y) {
        const color = this.gameState.board[y][x];
        if (!color) return 0;
 
        let count = 0;
        const stack = [[x, y]];
 
        while (stack.length > 0) {
            const [cx, cy] = stack.pop();
 
            if (this.gameState.board[cy][cx] === color) {
                this.gameState.board[cy][cx] = null;
                count++;
 
                const directions = [[0, 1], [0, -1], [1, 0], [-1, 0]];
                for (const [dx, dy] of directions) {
                    const nx = cx + dx;
                    const ny = cy + dy;
 
                    if (this.isInBounds(nx, ny) && this.gameState.board[ny][nx] === color) {
                        stack.push([nx, ny]);
                    }
                }
            }
        }
 
        return count;
    }
 
    // 자유도 확인 (BadukMoveValidator와 동일)
    hasLiberties(x, y) {
        const color = this.gameState.board[y][x];
        if (!color) return false;
 
        const visited = new Set();
        return this.checkGroupLiberties(x, y, color, visited);
    }
 
    checkGroupLiberties(x, y, color, visited) {
        const key = `${x},${y}`;
        if (visited.has(key)) return false;
        visited.add(key);
 
        const directions = [[0, 1], [0, -1], [1, 0], [-1, 0]];
 
        for (const [dx, dy] of directions) {
            const nx = x + dx;
            const ny = y + dy;
 
            if (!this.isInBounds(nx, ny)) continue;
 
            if (this.gameState.board[ny][nx] === null) {
                return true;
            }
 
            if (this.gameState.board[ny][nx] === color) {
                if (this.checkGroupLiberties(nx, ny, color, visited)) {
                    return true;
                }
            }
        }
 
        return false;
    }
 
    isInBounds(x, y) {
        return x >= 0 && x < 19 && y >= 0 && y < 19;
    }
}

패스 처리:

export default class BadukPassLogic {
    constructor(gameState) {
        this.gameState = gameState;
        this.consecutivePasses = 0;
    }
 
    // 패스 처리
    pass(player) {
        this.consecutivePasses++;
 
        this.gameState.moveHistory.push({
            type: 'pass',
            player: player,
            timestamp: Date.now()
        });
 
        this.gameState.currentPlayer = player === 'black' ? 'white' : 'black';
 
        // 연속 패스가 2번이면 게임 종료
        if (this.consecutivePasses >= 2) {
            this.endGame();
        }
 
        return { success: true, consecutivePasses: this.consecutivePasses };
    }
 
    // 항복 처리
    surrender(player) {
        const winner = player === 'black' ? 'white' : 'black';
 
        this.gameState.gamePhase = 'finished';
        this.gameState.winner = winner;
        this.gameState.surrender = true;
 
        this.gameState.moveHistory.push({
            type: 'surrender',
            player: player,
            timestamp: Date.now()
        });
 
        return { success: true, winner: winner };
    }
 
    // 게임 종료
    endGame() {
        this.gameState.gamePhase = 'counting';
        this.calculateTerritory();
        this.calculateFinalScore();
    }
 
    // 영역 계산
    calculateTerritory() {
        const visited = Array(19).fill().map(() => Array(19).fill(false));
 
        for (let y = 0; y < 19; y++) {
            for (let x = 0; x < 19; x++) {
                if (!visited[y][x] && this.gameState.board[y][x] === null) {
                    this.analyzeTerritory(x, y, visited);
                }
            }
        }
    }
 
    // 영역 분석
    analyzeTerritory(x, y, visited) {
        const territory = [];
        const stack = [[x, y]];
        let blackStones = 0;
        let whiteStones = 0;
 
        while (stack.length > 0) {
            const [cx, cy] = stack.pop();
 
            if (visited[cy][cx]) continue;
            visited[cy][cx] = true;
 
            if (this.gameState.board[cy][cx] === null) {
                territory.push([cx, cy]);
 
                const directions = [[0, 1], [0, -1], [1, 0], [-1, 0]];
                for (const [dx, dy] of directions) {
                    const nx = cx + dx;
                    const ny = cy + dy;
 
                    if (this.isInBounds(nx, ny) && !visited[ny][nx]) {
                        stack.push([nx, ny]);
                    }
                }
            } else if (this.gameState.board[cy][cx] === 'black') {
                blackStones++;
            } else if (this.gameState.board[cy][cx] === 'white') {
                whiteStones++;
            }
        }
 
        // 영역 소유자 결정
        if (territory.length > 0) {
            const owner = this.determineTerritoryOwner(blackStones, whiteStones);
            if (owner) {
                this.gameState.territory[owner] += territory.length;
            }
        }
    }
 
    // 영역 소유자 결정
    determineTerritoryOwner(blackStones, whiteStones) {
        if (blackStones > 0 && whiteStones === 0) {
            return 'black';
        } else if (whiteStones > 0 && blackStones === 0) {
            return 'white';
        }
        return null; // 중립 영역
    }
 
    // 최종 점수 계산
    calculateFinalScore() {
        const blackScore = this.gameState.territory.black + this.gameState.capturedStones.black;
        const whiteScore = this.gameState.territory.white + this.gameState.capturedStones.white + 6.5; // 백의 반집
 
        this.gameState.finalScore = {
            black: blackScore,
            white: whiteScore,
            winner: blackScore > whiteScore ? 'black' : 'white'
        };
    }
 
    isInBounds(x, y) {
        return x >= 0 && x < 19 && y >= 0 && y < 19;
    }
}

게임 통계 관리:

export default class BadukStatistics {
    constructor() {
        this.stats = {
            totalGames: 0,
            blackWins: 0,
            whiteWins: 0,
            averageGameLength: 0,
            totalMoves: 0,
            captures: { black: 0, white: 0 },
            passes: 0,
            surrenders: 0
        };
    }
 
    // 게임 결과 기록
    recordGameResult(gameState) {
        this.stats.totalGames++;
 
        if (gameState.surrender) {
            this.stats.surrenders++;
        } else {
            if (gameState.finalScore.winner === 'black') {
                this.stats.blackWins++;
            } else {
                this.stats.whiteWins++;
            }
        }
 
        // 평균 게임 길이 업데이트
        const gameLength = gameState.moveHistory.length;
        this.stats.averageGameLength = 
            (this.stats.averageGameLength * (this.stats.totalGames - 1) + gameLength) / this.stats.totalGames;
 
        // 총 이동 수 업데이트
        this.stats.totalMoves += gameLength;
 
        // 착수 통계 업데이트
        this.stats.captures.black += gameState.capturedStones.black;
        this.stats.captures.white += gameState.capturedStones.white;
 
        // 패스 통계 업데이트
        const passCount = gameState.moveHistory.filter(move => move.type === 'pass').length;
        this.stats.passes += passCount;
    }
 
    // 통계 가져오기
    getStats() {
        return {
            ...this.stats,
            winRate: {
                black: this.stats.totalGames > 0 ? (this.stats.blackWins / this.stats.totalGames * 100).toFixed(1) : 0,
                white: this.stats.totalGames > 0 ? (this.stats.whiteWins / this.stats.totalGames * 100).toFixed(1) : 0
            },
            averageCaptures: {
                black: this.stats.totalGames > 0 ? (this.stats.captures.black / this.stats.totalGames).toFixed(1) : 0,
                white: this.stats.totalGames > 0 ? (this.stats.captures.white / this.stats.totalGames).toFixed(1) : 0
            }
        };
    }
 
    // 통계 초기화
    reset() {
        this.stats = {
            totalGames: 0,
            blackWins: 0,
            whiteWins: 0,
            averageGameLength: 0,
            totalMoves: 0,
            captures: { black: 0, white: 0 },
            passes: 0,
            surrenders: 0
        };
    }
}

• Phaser.js 게임 엔진
• UI/UX 구현
• Socket.IO 실시간 통신

— 이 페이지는 자동으로 생성되었습니다.