哨兵边界实现翻转棋Board

game/reversi.py

@@ -0,0 +1,220 @@
+import numpy as np
+from typing import Tuple, List, Optional
+
+class Board:
+    """
+    翻转棋 (Reversi/Othello)
+    为深度学习神经网络提供多通道输入。
+
+    核心算法基于从落子点向8个方向扫描，寻找并翻转被“夹住”的对方棋子。
+    """
+    def __init__(self, h: int, w: int):
+        """
+        初始化棋盘。
+
+        参数:
+        h, w: 棋盘的高度和宽度，建议为大于4的偶数。
+        """
+        if h < 4 or w < 4 or h % 2 != 0 or w % 2 != 0:
+            raise ValueError("高度和宽度必须是大于等于4的偶数。")
+        self.h = h
+        self.w = w
+        
+        # 定义8个方向的偏移量 (dr, dc)
+        self._DIRECTIONS = np.array([[-1, -1], [-1, 0], [-1, 1],
+                                     [0, -1],          [0, 1],
+                                     [1, -1], [1, 0], [1, 1]], dtype=np.int8)
+        
+        # 存储棋盘状态的变量
+        self.board: np.ndarray = None  # 主棋盘: 1=黑, -1=白, 0=空
+        self.player: int = None        # 当前玩家: 1=黑, -1=白
+        
+        # 为神经网络准备的通道
+        self.board_b: np.ndarray = None      # 通道2: 黑棋位置 (0/1)
+        self.board_w: np.ndarray = None      # 通道3: 白棋位置 (0/1)
+        self.board_move: np.ndarray = None   # 通道4: 当前玩家的合法走法 (0/1)
+        self.player_channel: np.ndarray = None # 通道5: 当前玩家指示 (全1或全-1)
+        
+        self.reset()
+
+    def reset(self):
+        """
+        重置棋盘到初始状态，开始新游戏。
+        """
+        board = np.zeros((self.h, self.w), dtype=np.int8)
+        # 初始中心棋子
+        mid_h, mid_w = self.h // 2, self.w // 2
+        board[mid_h - 1, mid_w - 1] = -1  # 白
+        board[mid_h - 1, mid_w]     = 1   # 黑
+        board[mid_h, mid_w - 1]     = 1   # 黑
+        board[mid_h, mid_w]         = -1  # 白
+        
+        # 黑棋先手
+        self.load(board, 1)
+
+    def load(self, board: np.ndarray, player: int):
+        """
+        加载指定的棋盘状态和当前玩家。
+
+        参数:
+        board: 一个 (h, w) 的 numpy 数组，1=黑, -1=白, 0=空。
+        player: 当前玩家, 1=黑, -1=白。
+        """
+        if board.shape != (self.h, self.w):
+            raise ValueError("加载的棋盘尺寸与初始化尺寸不符。")
+        self.board = board.copy().astype(np.int8)
+        self.player = player
+        self._update_channels()
+
+    def _update_channels(self):
+        """
+        【核心解析器】
+        根据 self.board 和 self.player，更新所有输入通道。
+        这个函数是所有状态变更后必须调用的，以确保数据一致性。
+        """
+        # 通道2 & 3: 使用布尔索引高效生成黑棋和白棋位置通道
+        self.board_b = (self.board == 1).astype(np.float32)
+        self.board_w = (self.board == -1).astype(np.float32)
+
+        # 通道4: 生成合法移动位置通道
+        self.board_move = np.zeros_like(self.board, dtype=np.float32)
+        # 遍历所有空位
+        empty_cells = np.argwhere(self.board == 0)
+        for r, c in empty_cells:
+            if len(self._get_flips_for_move(r, c)) > 0:
+                self.board_move[r, c] = 1.0
+
+        # 通道5: 生成玩家指示通道
+        self.player_channel = np.full((self.h, self.w), float(self.player), dtype=np.float32)
+
+    def _get_flips_for_move(self, r: int, c: int) -> List[Tuple[int, int]]:
+        """
+        【核心算法】
+        计算在 (r, c) 位置落子后，能够翻转的所有对方棋子的坐标列表。
+        这也是判断 (r, c) 是否为合法走法的基础。
+
+        返回:
+        一个包含所有可被翻转棋子坐标 `(row, col)` 的列表。如果列表为空，则该走法不合法。
+        """
+        opponent = -self.player
+        pieces_to_flip = []
+
+        # 扫描8个方向
+        for dr, dc in self._DIRECTIONS:
+            line_flips = []
+            curr_r, curr_c = r + dr, c + dc
+            
+            # 持续沿该方向探索
+            while 0 <= curr_r < self.h and 0 <= curr_c < self.w:
+                if self.board[curr_r, curr_c] == opponent:
+                    line_flips.append((curr_r, curr_c))
+                elif self.board[curr_r, curr_c] == self.player:
+                    # 找到了己方棋子，形成"夹击"，该方向上的翻转有效
+                    pieces_to_flip.extend(line_flips)
+                    break
+                else:
+                    # 遇到空位或边界，中断该方向的扫描
+                    break
+                curr_r, curr_c = curr_r + dr, curr_c + dc
+        
+        return pieces_to_flip
+
+    def play(self, r: int, c: int):
+        """
+        在 (r, c) 位置执行走子操作。
+
+        参数:
+        r, c: 落子位置的行和列。
+        """
+        if not (0 <= r < self.h and 0 <= c < self.w and self.board_move[r, c] == 1):
+            raise ValueError(f"位置 ({r}, {c}) 不是一个合法的走法。")
+
+        # 1. 获取要翻转的棋子
+        flips = self._get_flips_for_move(r, c)
+
+        # 2. 在棋盘上执行落子和翻转
+        self.board[r, c] = self.player
+        for fr, fc in flips:
+            self.board[fr, fc] = self.player
+
+        # 3. 交换玩家
+        self.player *= -1
+
+        # 4. 更新所有通道以反映新状态
+        self._update_channels()
+
+        # 5. 如果新玩家无棋可走，则跳过其回合
+        if np.sum(self.board_move) == 0 and not self.is_game_over():
+            self.player *= -1
+            self._update_channels()
+
+    def get_state(self) -> np.ndarray:
+        """
+        获取为神经网络准备的5通道输入状态。
+
+        返回:
+        一个 (5, h, w) 的 numpy 数组。
+        """
+        return np.stack([
+            self.board.astype(np.float32), # 通道1: 主棋盘 (1, -1, 0)
+            self.board_b,
+            self.board_w,
+            self.board_move,
+            self.player_channel
+        ])
+    
+    def is_game_over(self) -> bool:
+        """检查游戏是否结束。"""
+        # 如果棋盘已满
+        if np.all(self.board != 0):
+            return True
+        # 如果双方都无棋可走
+        if np.sum(self.board_move) == 0:
+            # 临时切换到对手，检查对手是否也无棋可走
+            original_player = self.player
+            self.player *= -1
+            
+            opponent_has_move = False
+            empty_cells = np.argwhere(self.board == 0)
+            for r, c in empty_cells:
+                if len(self._get_flips_for_move(r, c)) > 0:
+                    opponent_has_move = True
+                    break
+            
+            self.player = original_player # 恢复玩家
+            return not opponent_has_move
+        return False
+        
+    def get_winner(self) -> Optional[int]:
+        """
+        获取赢家。
+        返回: 1 (黑棋赢), -1 (白棋赢), 0 (平局), None (游戏未结束)。
+        """
+        if not self.is_game_over():
+            return None
+        
+        score = np.sum(self.board)
+        if score > 0:
+            return 1
+        elif score < 0:
+            return -1
+        else:
+            return 0
+
+    def __str__(self):
+        """方便打印和调试棋盘。"""
+        symbols = {1: 'X', -1: 'O', 0: '.'}
+        header = '   ' + ' '.join(f'{i:X}' for i in range(self.w)) + '\n'
+        board_str = header
+        for r in range(self.h):
+            board_str += f'{r:X}  ' + ' '.join(symbols[self.board[r, c]] for c in range(self.w)) + '\n'
+        
+        current_player = 'Black (X)' if self.player == 1 else 'White (O)'
+        board_str += f"\nCurrent Player: {current_player}\n"
+        
+        winner = self.get_winner()
+        if winner is not None:
+            winner_str = {1: "Black (X) Wins", -1: "White (O) Wins", 0: "Draw"}[winner]
+            board_str += f"Game Over! Winner: {winner_str}\n"
+
+        return board_str