코드: 틱택토 Game 인터페이스

틱택토를 알파고 인터페이스에 맞춰 구현. 5개 메서드만 구현하면 알파고 코드가 동작.

🎯 핵심 — Board 클래스와 거의 동일

PART 1의 Board와 비교:

possible_moves(): 빈 자리 ✅ 동일
play(move): 새 보드 반환 ✅ 동일
is_terminal(): 승자 또는 보드 가득 ✅ 비슷
winner_value(): -1/0/+1 ✅ 비슷
to_input(): 3채널 (X/O/빈) ✅ 동일

차이: 보드 크기 (3x3), 종료 조건 (3 일직선)만. 인터페이스 그대로.

💡 이제 가능한 것

이 TicTacToe 클래스를 PART 5/6의 MCTS와 신경망 코드에 그대로 넘기면:

mcts_alphago(game, net, n_iter=500) — 동작!
play_one_game(net) — 동작! (game 인스턴스만 바꾸면)
학습 데이터 생성, 학습, 평가 — 모두 동작

알고리즘 코드는 0줄도 안 바꿈. 인터페이스의 힘.

📊 신경망 출력 크기만 조정

틱택토 9 자리 → 신경망의 policy 출력 크기 9 (alphago zero는 9+1=10 with pass).

알파고 7x7 49 자리 → 49. 19x19 → 361+1=362.

이것만 게임마다 다름. 나머지 100% 동일.

PYTHON

# 틱택토를 PART 5/6의 알고리즘 인터페이스에 맞춰 구현.
# 같은 MCTS, 같은 신경망 구조, 게임만 다름.

import numpy as np


class TicTacToe:
    EMPTY, X, O = 0, 1, 2
    SIZE = 3
    
    def __init__(self, board=None, turn=None, move_count=0):
        self.board = board if board is not None else np.zeros((3, 3), dtype=int)
        self.turn = turn if turn is not None else self.X
        self.move_count = move_count
    
    def possible_moves(self):
        return [(r, c) for r in range(3) for c in range(3) if self.board[r,c] == 0]
    
    def play(self, move):
        new = self.board.copy()
        new[move] = self.turn
        return TicTacToe(new, self.O if self.turn == self.X else self.X, self.move_count+1)
    
    def is_terminal(self):
        return self._check_winner() is not None or self.move_count >= 9
    
    def _check_winner(self):
        b = self.board
        for r in range(3):
            if b[r,0] == b[r,1] == b[r,2] != 0: return b[r,0]
        for c in range(3):
            if b[0,c] == b[1,c] == b[2,c] != 0: return b[0,c]
        if b[0,0] == b[1,1] == b[2,2] != 0: return b[0,0]
        if b[0,2] == b[1,1] == b[2,0] != 0: return b[0,2]
        return None
    
    def winner_value(self):
        """현재 차례 입장에서: +1 이김, -1 짐, 0 무승부/진행중"""
        w = self._check_winner()
        if w is None: return 0.0
        return 1.0 if w == self.turn else -1.0
    
    def to_input(self):
        """3 채널 (내 돌 / 상대 / 빈자리) — 알파고와 동일 형식!"""
        x = np.zeros((3, 3, 3))
        x[:,:,0] = (self.board == self.turn).astype(float)
        opp = self.O if self.turn == self.X else self.X
        x[:,:,1] = (self.board == opp).astype(float)
        x[:,:,2] = (self.board == 0).astype(float)
        return x
    
    def show(self):
        sym = {0: '.', 1: 'X', 2: 'O'}
        for row in self.board:
            print(' '.join(sym[v] for v in row))


# === 게임 진행 시뮬 ===
game = TicTacToe()
print("=== 틱택토 인터페이스 테스트 ===")
print("초기 보드:")
game.show()
print(f"가능한 수: {len(game.possible_moves())}개 (예: {game.possible_moves()[:5]})")
print()

# 몇 수 진행
game = game.play((1, 1))   # X 중앙
print("X 중앙 (1,1):")
game.show()
print(f"is_terminal: {game.is_terminal()}, winner_value: {game.winner_value()}")
print()

game = game.play((0, 0))   # O 좌상
game = game.play((0, 1))   # X 위
game = game.play((2, 2))   # O 우하
game = game.play((2, 1))   # X 아래 → 세로 3 (X 승리!)

print("X 승리 후:")
game.show()
print(f"is_terminal: {game.is_terminal()}")
print(f"winner_value (현재 차례 O 입장): {game.winner_value()}")
print(f"  → O 입장에서 -1.0 (X가 이긴 거)")
print()

# === 신경망 입력 형식 확인 ===
print("=== 신경망 입력 형식 (3채널) ===")
x = game.to_input()
print(f"입력 shape: {x.shape}")
print(f"채널 0 (현재 차례 O의 돌):")
print(x[:,:,0].astype(int))
print(f"채널 1 (상대 X의 돌):")
print(x[:,:,1].astype(int))
print(f"채널 2 (빈자리):")
print(x[:,:,2].astype(int))
print()
print("✅ 알파고와 같은 인터페이스. 같은 MCTS 코드가 이 게임에도 동작!")

출력

기대 출력:

=== 틱택토 인터페이스 테스트 ===
초기 보드:
. . .
. . .
. . .
가능한 수: 9개 (예: [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1)])

X 중앙 (1,1):
. . .
. X .
. . .
is_terminal: False, winner_value: 0.0

X 승리 후:
O X .
. X .
. X O
is_terminal: True
winner_value (현재 차례 O 입장): -1.0
  → O 입장에서 -1.0 (X가 이긴 거)

=== 신경망 입력 형식 (3채널) ===
입력 shape: (3, 3, 3)
채널 0 (현재 차례 O의 돌):
[[1 0 0]
 [0 0 0]
 [0 0 1]]
채널 1 (상대 X의 돌):
[[0 1 0]
 [0 1 0]
 [0 1 0]]
채널 2 (빈자리):
[[0 0 1]
 [1 0 1]
 [1 0 0]]

✅ 알파고와 같은 인터페이스. 같은 MCTS 코드가 이 게임에도 동작!

← 이전 같은 알고리즘, 다른 게임 다음 → 커넥트포 — 같은 알고리즘, 다른 규칙