코드 2부: play() + score()

드디어 완성. 한 클래스 안에 모든 로직이 깔끔하게 정리됨.

🔑 play() 메서드 흐름 다시

유효성: 빈 자리가 아니면 'illegal'
둔다: self.grid[r][c] = color
적 따냄: 인접 적 그룹 중 활로 0인 것 제거
자살수 체크: 내 그룹 활로 0이면 무효, 복원
패 체크: 새 상태가 직전 상태와 같으면 무효, 복원
성공: prev_grid 갱신, 포로 카운트

위 테스트를 보면 마지막 흑 (2,4)에서 백 (2,3)이 활로 0 되어 잡힘. 흑 포로 1. 백돌이 깨끗이 사라진 게 보임.

다음 페이지에서 이 클래스로 진짜 짧은 대국을 시뮬레이션해보자.

PYTHON

# Board 클래스 2부 — play()와 score() 추가.
# 가장 복잡한 메서드들. 따냄+자살수+패까지 한 함수에.

class Board:
    EMPTY, BLACK, WHITE = 0, 1, 2

    def __init__(self, size=5):
        self.size = size
        self.grid = [[Board.EMPTY] * size for _ in range(size)]
        self.prev_grid = None
        self.captures = {Board.BLACK: 0, Board.WHITE: 0}

    def neighbors(self, r, c):
        result = []
        for dr, dc in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
            nr, nc = r + dr, c + dc
            if 0 <= nr < self.size and 0 <= nc < self.size:
                result.append((nr, nc))
        return result

    def find_group(self, r, c):
        if self.grid[r][c] == Board.EMPTY: return set()
        color = self.grid[r][c]
        group = set(); stack = [(r, c)]
        while stack:
            cr, cc = stack.pop()
            if (cr, cc) in group: continue
            if self.grid[cr][cc] != color: continue
            group.add((cr, cc))
            for nr, nc in self.neighbors(cr, cc):
                if (nr, nc) not in group: stack.append((nr, nc))
        return group

    def group_liberties(self, r, c):
        group = self.find_group(r, c)
        libs = set()
        for cr, cc in group:
            for nr, nc in self.neighbors(cr, cc):
                if self.grid[nr][nc] == Board.EMPTY: libs.add((nr, nc))
        return libs

    # 🆕 핵심 메서드 — play
    def play(self, r, c, color):
        """한 수. 따냄 + 자살수 + 패 처리.
        반환: 'illegal' / 'ko' / 잡은 돌 set (성공)"""

        if self.grid[r][c] != Board.EMPTY:
            return 'illegal'

        # 백업 (실패 시 복원)
        backup_grid = [row[:] for row in self.grid]

        # 1) 일단 둔다
        self.grid[r][c] = color
        enemy = Board.WHITE if color == Board.BLACK else Board.BLACK

        # 2) 적 따냄
        captured = set()
        for nr, nc in self.neighbors(r, c):
            if self.grid[nr][nc] == enemy and not self.group_liberties(nr, nc):
                captured |= self.find_group(nr, nc)
        for cr, cc in captured:
            self.grid[cr][cc] = Board.EMPTY

        # 3) 자살수 체크
        if not self.group_liberties(r, c):
            self.grid = backup_grid
            return 'illegal'

        # 4) 패 체크
        if self.prev_grid is not None and self.grid == self.prev_grid:
            self.grid = backup_grid
            return 'ko'

        # 성공: 직전 상태 갱신, 포로 카운트
        self.prev_grid = backup_grid
        self.captures[color] += len(captured)
        return captured

    # 🆕 점수 계산
    def find_territories(self):
        visited = set()
        result = {'black': [], 'white': [], 'neutral': []}
        for r in range(self.size):
            for c in range(self.size):
                if (r, c) in visited or self.grid[r][c] != Board.EMPTY: continue
                region = set(); border_colors = set(); stack = [(r, c)]
                while stack:
                    cr, cc = stack.pop()
                    if (cr, cc) in region: continue
                    if self.grid[cr][cc] == Board.EMPTY:
                        region.add((cr, cc)); visited.add((cr, cc))
                        for nr, nc in self.neighbors(cr, cc): stack.append((nr, nc))
                    else:
                        border_colors.add(self.grid[cr][cc])
                if border_colors == {Board.BLACK}: result['black'].extend(region)
                elif border_colors == {Board.WHITE}: result['white'].extend(region)
                else: result['neutral'].extend(region)
        return result

    def score(self, komi=6.5):
        t = self.find_territories()
        black = len(t['black'])
        white = len(t['white']) + komi
        if black > white: winner = f'흑 {black - white:.1f}집 승'
        elif white > black: winner = f'백 {white - black:.1f}집 승'
        else: winner = '무승부'
        return black, white, winner

    def show(self):
        sym = {Board.EMPTY: ".", Board.BLACK: "X", Board.WHITE: "O"}
        for row in self.grid:
            print(" ".join(sym[v] for v in row))


# === 테스트: 흑이 백 한 점 따내는 시퀀스 ===
b = Board(size=5)
b.play(2, 2, Board.BLACK)
b.play(2, 3, Board.WHITE)   # 백 (2,3) 둠
b.play(1, 3, Board.BLACK)   # 흑이 백 (2,3) 위 막음
b.play(4, 4, Board.WHITE)   # 백 다른 곳 (구석)
b.play(3, 3, Board.BLACK)   # 흑이 백 (2,3) 아래 막음 → 백 단수!
b.play(0, 0, Board.WHITE)   # 백 다른 곳
b.play(2, 4, Board.BLACK)   # 흑이 마지막 활로 메움 → 백 (2,3) 잡힘!

print("현재 보드:")
b.show()
print(f"흑 포로: {b.captures[Board.BLACK]}, 백 포로: {b.captures[Board.WHITE]}")

출력

기대 출력:

현재 보드:
O . . . .
. . . X .
. . X . X
. . . X .
. . . . O
흑 포로: 1, 백 포로: 0

← 이전 코드 1부: 구조 + 그룹 메서드 다음 → 실전: 짧은 대국 시뮬레이션