from .zobrist import ZobristCache as Zobrist from .cache import Cache from .eval import Evaluate, FIVE from scipy import signal import pickle import os save_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'train_data/data', 'train_data.pkl') if 'numpy' not in globals(): import numpy as np class Board: def __init__(self, size=15, firstRole=1): self.size = size self.board = [[0] * self.size for _ in range(self.size)] self.firstRole = firstRole # 1 for black, -1 for white self.role = firstRole # 1 for black, -1 for white self.history = [] self.zobrist = Zobrist(self.size) self.winnerCache = Cache() self.gameoverCache = Cache() self.evaluateCache = Cache() self.valuableMovesCache = Cache() self.evaluateTime = 0 self.evaluator = Evaluate(self.size) self.available = [(i, j) for i in range(self.size) for j in range(self.size)] self.patterns = [np.ones((1, 5)), np.ones((5, 1)), np.eye(5), np.fliplr(np.eye(5))] self.train_data = {1:[], -1: []} if os.path.exists(save_path): with open(save_path, 'rb') as f: self.train_data = pickle.load(f) def isGameOver(self): # Checked hash = self.hash() if self.gameoverCache.get(hash): return self.gameoverCache.get(hash) if self.getWinner() != 0: self.gameoverCache.put(hash, True) # save train data # with open(save_path, 'wb') as f: # pickle.dump(self.train_data, f) return True # Someone has won # Game is over when there is no empty space on the board or someone has won if len(self.history) == self.size ** 2: self.gameoverCache.put(hash, True) return True else: self.gameoverCache.put(hash, False) return False def getWinner(self): # Checked hash = self.hash() flag = True if self.winnerCache.get(hash): return self.winnerCache.get(hash) directions = [[1, 0], [0, 1], [1, 1], [1, -1]] # Horizontal, Vertical, Diagonal for i in range(self.size): for j in range(self.size): if self.board[i][j] == 0: flag = False continue for direction in directions: count = 0 while ( 0 <= i + direction[0] * count < self.size and 0 <= j + direction[1] * count < self.size and self.board[i + direction[0] * count][j + direction[1] * count] == self.board[i][j] ): count += 1 if count >= 5: self.winnerCache.put(hash, self.board[i][j]) return self.board[i][j] if flag: print("tie!!!") return 0 self.winnerCache.put(hash, 0) return 0 def getValidMoves(self): return self.available def put(self, i, j, role=None): # Checked if role is None: role = self.role if not isinstance(i, int) or not isinstance(j, int): print("Invalid move: Not Number!", i, j) return False if self.board[i][j] != 0: print("Invalid move!", i, j) return False self.board[i][j] = role self.available.remove((i, j)) self.history.append({"i": i, "j": j, "role": role}) self.zobrist.togglePiece(i, j, role) self.evaluator.move(i, j, role) self.role *= -1 # Switch role return True def undo(self): # Checked if len(self.history) == 0: print("No moves to undo!") return False lastMove = self.history.pop() self.board[lastMove['i']][lastMove['j']] = 0 # Remove the piece from the board self.role = lastMove['role'] # Switch back to the previous player self.zobrist.togglePiece(lastMove['i'], lastMove['j'], lastMove['role']) self.evaluator.undo(lastMove['i'], lastMove['j']) self.available.append((lastMove['i'], lastMove['j'])) return True def position2coordinate(self, position): # checked row = position // self.size col = position % self.size return [row, col] def coordinate2position(self, coordinate): # Checked return coordinate[0] * self.size + coordinate[1] def getValuableMoves(self, role, depth=0, onlyThree=False, onlyFour=False): # Checked hash = self.hash() prev = self.valuableMovesCache.get(hash) if prev: if (prev["role"] == role and prev["depth"] == depth and prev["onlyThree"] == onlyThree and prev["onlyFour"] == onlyFour): return prev["moves"] moves, train_data = self.evaluator.getMoves(role, depth, onlyThree, onlyFour) self.train_data[self.role].append(train_data) # Handle a special case, if the center point is not occupied, add it by default # 开局的时候随机走一步，增加开局的多样性 if not onlyThree and not onlyFour: center = self.size // 2 if self.board[center][center] == 0: moves.append((center, center)) # x_step = np.random.randint(-self.size // 2, self.size // 2) # y_step = np.random.randint(-self.size // 2, self.size // 2) # x = center + x_step # y = center + y_step # if 0 <= x < self.size and 0 <= y < self.size and self.board[x][y] == 0: # moves.append((x, y)) self.valuableMovesCache.put(hash, { "role": role, "moves": moves, "depth": depth, "onlyThree": onlyThree, "onlyFour": onlyFour }) return moves def display(self, extraPoints=[]): # Checked extraPosition = [self.coordinate2position(point) for point in extraPoints] result = "" for i in range(self.size): for j in range(self.size): position = self.coordinate2position([i, j]) if position in extraPosition: result += "? " continue value = self.board[i][j] if value == 1: result += "B " # Black elif value == -1: result += "W " # White else: result += "- " result += "\n" return result def hash(self): # Checked return self.zobrist.getHash() # Return the hash value of the current board, used for caching def evaluate(self, role): # Checked hash_key = self.hash() prev = self.evaluateCache.get(hash_key) if prev: if prev["role"] == role: return prev["score"] winner = self.getWinner() score = 0 if winner != 0: score = FIVE * winner * role else: score = self.evaluator.evaluate(role) self.evaluateCache.put(hash_key, {"role": role, "score": score}) return score def reverse(self): # Checked new_board = Board(self.size, -self.firstRole) for move in self.history: x, y, role = move['i'], move['j'], move['role'] new_board.put(x, y, -role) return new_board def toString(self): # Checked return ''.join([''.join(map(str, row)) for row in self.board])