game.py

# -*- coding: utf-8 -*-

import numpy as np
import logging


class Game:
    def __init__(self):
        self.currentPlayer = 1
        # gameState & actionSpace 都是42格
        self.gameState = GameState(np.array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], dtype=np.int), 1)
        self.actionSpace = np.array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], dtype=np.int)
        self.pieces = {'1':'X', '0':'-', '-1':'O'}
        self.grid_shape = (6,7)
        self.input_shape = (2,6,7)  # 兩個玩家各一個盤面
        self.name = 'connect4'
        self.state_size = len(self.gameState.binary)
        self.action_size = len(self.actionSpace)

    def reset(self):
        self.gameState = GameState(np.array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], dtype=np.int), 1)
        self.currentPlayer = 1
        return self.gameState

    def step(self, action):
        next_state, value, done = self.gameState.takeAction(action)
        self.gameState = next_state  # next_state 不用用gameState包起來嗎?
        self.currentPlayer = -self.currentPlayer
        info = None
        return ((next_state, value, done, info))

    # 水平翻轉
    def identities(self, state, actionValues):
        identities = [(state, actionValues)]

        currentBoard = state.board
        currentAV = actionValues

        currentBoard = np.array([
            currentBoard[6], currentBoard[5], currentBoard[4], currentBoard[3], currentBoard[2], currentBoard[1], currentBoard[0],
            currentBoard[13], currentBoard[12], currentBoard[11], currentBoard[10], currentBoard[9], currentBoard[8], currentBoard[7],
            currentBoard[20], currentBoard[19], currentBoard[18], currentBoard[17], currentBoard[16], currentBoard[15], currentBoard[14],
            currentBoard[27], currentBoard[26], currentBoard[25], currentBoard[24], currentBoard[23], currentBoard[22], currentBoard[21],
            currentBoard[34], currentBoard[33], currentBoard[32], currentBoard[31], currentBoard[30], currentBoard[29], currentBoard[28],
            currentBoard[41], currentBoard[40], currentBoard[39], currentBoard[38], currentBoard[37], currentBoard[36], currentBoard[35]
        ])

        currentAV = np.array([
            currentAV[6], currentAV[5], currentAV[4], currentAV[3], currentAV[2], currentAV[1], currentAV[0],
            currentAV[13], currentAV[12], currentAV[11], currentAV[10], currentAV[9], currentAV[8], currentAV[7],
            currentAV[20], currentAV[19], currentAV[18], currentAV[17], currentAV[16], currentAV[15], currentAV[14],
            currentAV[27], currentAV[26], currentAV[25], currentAV[24], currentAV[23], currentAV[22], currentAV[21],
            currentAV[34], currentAV[33], currentAV[32], currentAV[31], currentAV[30], currentAV[29], currentAV[28],
            currentAV[41], currentAV[40], currentAV[39], currentAV[38], currentAV[37], currentAV[36], currentAV[35]
        ])

        identities.append((GameState(currentBoard, state.playerTurn), currentAV))

        return identities
    
class GameState:
    def __init__(self, board: np.array, playerTurn):
        self.board = board  # shape: (42,)
        self.pieces = {'1':'X', '0':'-', '-1':'O'}
        # 窮舉所有勝利狀況
        self.winners = [
            [0,1,2,3],
            [1,2,3,4],
            [2,3,4,5],
            [3,4,5,6],
            [7,8,9,10],
            [8,9,10,11],
            [9,10,11,12],
            [10,11,12,13],
            [14,15,16,17],
            [15,16,17,18],
            [16,17,18,19],
            [17,18,19,20],
            [21,22,23,24],
            [22,23,24,25],
            [23,24,25,26],
            [24,25,26,27],
            [28,29,30,31],
            [29,30,31,32],
            [30,31,32,33],
            [31,32,33,34],
            [35,36,37,38],
            [36,37,38,39],
            [37,38,39,40],
            [38,39,40,41],

            [0,7,14,21],
            [7,14,21,28],
            [14,21,28,35],
            [1,8,15,22],
            [8,15,22,29],
            [15,22,29,36],
            [2,9,16,23],
            [9,16,23,30],
            [16,23,30,37],
            [3,10,17,24],
            [10,17,24,31],
            [17,24,31,38],
            [4,11,18,25],
            [11,18,25,32],
            [18,25,32,39],
            [5,12,19,26],
            [12,19,26,33],
            [19,26,33,40],
            [6,13,20,27],
            [13,20,27,34],
            [20,27,34,41],

            [3,9,15,21],
            [4,10,16,22],
            [10,16,22,28],
            [5,11,17,23],
            [11,17,23,29],
            [17,23,29,35],
            [6,12,18,24],
            [12,18,24,30],
            [18,24,30,36],
            [13,19,25,31],
            [19,25,31,37],
            [20,26,32,38],

            [3,11,19,27],
            [2,10,18,26],
            [10,18,26,34],
            [1,9,17,25],
            [9,17,25,33],
            [17,25,33,41],
            [0,8,16,24],
            [8,16,24,32],
            [16,24,32,40],
            [7,15,23,31],
            [15,23,31,39],
            [14,22,30,38],
        ]
        self.playerTurn = playerTurn
        self.binary = self._binary()
        self.id = self._converStateToId()
        self.allowedActions = self._allowedActions()
        self.isEndGame = self._checkForEndGame()
        self.value = self._getValue()
        self.score = self._getScore()

    def _allowedActions(self) -> list:
        """
        [ 0, 1, 2, 3, 4, 5, 6,
          7, 8, 9,10,11,12,13,
         14,15,16,17,18,19,20,
         ...
         35,36,37,38,39,40,41]
        """
        allowed = []
        for i in range(len(self.board)):
            # 最下面一排還沒擺放的話都是允許的
            if i >= len(self.board) - 7:
                if self.board[i] == 0:
                    allowed.append(i)
            # 剩下的要下方位有擺放子才允許
            else:
                if self.board[i] == 0 and self.board[i+7] != 0:
                    allowed.append(i)
        # 返回允許擺放的index, ex: [0, 3, 17, ...]
        return allowed

    def _binary(self) -> list:
        """取得雙方盤面位置(相對視角)"""
        currentplayer_position = np.zeros(len(self.board), dtype=np.int)
        currentplayer_position[self.board==self.playerTurn] = 1

        other_postition = np.zeros(len(self.board), dtype=np.int)
        other_postition[self.board==-self.playerTurn] = 1

        position = np.append(currentplayer_position, other_postition)

        return position

    def _converStateToId(self) -> str:
        """轉化盤面為str(絕對視角)"""
        player1_position = np.zeros(len(self.board), dtype=np.int)
        player1_position[self.board==1] = 1

        other_postition = np.zeros(len(self.board), dtype=np.int)
        other_postition[self.board==-1] = 1

        position = np.append(player1_position, other_postition)

        id = ''.join(map(str, position))

        return id

    def _checkForEndGame(self):
        # 如果達成任一勝利條件則結束
        for x, y, z, a in self.winners:
            if (self.board[x]+self.board[y]+self.board[z]+self.board[a] == 4 * -self.playerTurn):
                return 1

        # 如果盤面已滿則結束
        if np.count_nonzero(self.board) == 42:
            return 1

        return 0

    def _getValue(self):
        for x, y, z, a in self.winners:
            if (self.board[x]+self.board[y]+self.board[z]+self.board[a] == 4 * -self.playerTurn):
                return (-1, -1, -1)
        return (0, 0, 0)

    def _getScore(self):
        tmp = self.value
        return (tmp[1], tmp[2])

    def takeAction(self, action):
        newBoard = np.array(self.board)
        # 不用檢查合法性嗎?
        newBoard[action] = self.playerTurn

        newState = GameState(newBoard, -self.playerTurn)

        value = 0
        done = 0

        if newState.isEndGame:
            value = newState.value[0]  # 結束就得到 -1
            done = 1

        return (newState, value, done)

    def render(self, logger):
        for r in range(6):
            logger.info([self.pieces[str(x)] for x in self.board[7*r : (7*r + 7)]])
        logger.info('--------------')