AI人机对战五子棋游戏Python(pygame)+AI并实现软件输出

Posted 栩珩

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了AI人机对战五子棋游戏Python(pygame)+AI并实现软件输出相关的知识,希望对你有一定的参考价值。

注意:本篇文章是基于清华大学出版社,陈强教授编写的《Python项目实战开发》一书来行文的,具体有写的不清楚的地方,建议参考陈强教授写的具体内容,若写的有错误的地方,欢迎大家及时指出,更改。同时,本文适用于有一定Python基础的同学阅读学习,能够理解一定的算法思想。

对于pygame模块不是很清楚的可以参考文章点击这里

目录

1.系统架构分析

1.1五子棋的基本棋型

1.2功能模块

2.具体实现

2.1设置基础参数

2.2绘制棋盘

2.3编写函数intoNextTurn()

2.4编写函数getLocate()

2.5编写函数getIdex()

2.6编写函数isInside()

2.7编写函数isEmpty()

2.8编写函数printChessPiece()

2.9实现AI功能

2.9.1方法分析

2.9.2功能实现

2.10实现按钮功能

2.11实现重写功能(即游戏的调用函数)

3.完整代码及运行结果图

 4.软件封装

4.1pyinstaller的简介

4.2pyinstaller的安装

4.3准备

4.4程序打包


1.系统架构分析

1.1五子棋的基本棋型

对五子棋游戏来说,有常见的七种基本棋型:连五,活四,冲四,活三,眠三,活二,眠二。   

①连五:顾名思义,五颗同色棋子连在一起。
②活四:有两个连五点(即有两个点可以形成五)。
③冲四:有一个连五点,均为冲四棋型。
④活三:可以形成活四的三,代表两种最基本的活三棋型。活三棋型是进攻中最常见的一种,因为活三之后,如果对方不以理会,将可以下一手将活三变成活四,而活四是已经无法单纯防守住了。所以,当面对活三的时候,需要非常谨慎对待。在自己没有更好的进攻手段的情况下,需要对其进行防守,以防止其形成可怕的活四棋型。
⑤眠三:只能够形成冲四的三。眠三的棋型与活三的棋型相比,危险系数下降不少,因为眠三棋型即使不去防守,下一手它也只能形成冲四,而对于单纯的冲四棋型,是可以防守住的。
⑥活二:能够形成活三的二,是三种基本的活二棋型。活二棋型看起来似乎很无害,因为下一手棋才能形成活三,等形成活三,再防守也不迟。但其实活二棋型是非常重要的,尤其是在开局阶段,形成较多的活二棋型的话,将活二变成活三时,才能够令自己的活三绵绵不绝微风里,让对手防不胜防。
⑦眠二:能够形成眠三的二。

1.2功能模块

根据五子棋的游戏规则和基本棋型分析项目架构,最终得出的功能模块如下图:  

2.具体实现

2.1设置基础参数

在实例文件中,会多次用到这些基础参数,例如:设置棋盘单元格的大小,棋盘的大小,按钮的位置和大小信息等,故将这些基础参数写在代码前面,如下:

# 基础参数设置
square_size = 40  # 单格的宽度(不是格数!是为了方便绘制棋盘用的变量
chess_size = square_size // 2 - 2  # 棋子大小
web_broad = 15  # 棋盘格数+1(nxn)
map_w = web_broad * square_size  # 棋盘长度
map_h = web_broad * square_size  # 棋盘高度
info_w = 60  # 按钮界面宽度
button_w = 120  # 按钮长宽
button_h = 45
screen_w = map_w  # 总窗口长宽
screen_h = map_h + info_w

2.2绘制棋盘

在实例文件中,使用如下MAP_ENUM和Map两个类,来绘制棋盘的界面。

在MAP_ENUM类中使用的数字表示当前格子的使用情况,

class MAP_ENUM(IntEnum):  # 用数字表示当前格的情况
    be_empty = 0,  # 无人下
    player1 = 1,  # 玩家一,执白
    player2 = 2,  # 玩家二,执黑
    out_of_range = 3,  # 出界

在Map类中,使用self.map初始化二维数组来表示棋盘的大小,该数组中的值与类MAP_ENUM中的值对应,0表示空,该处没人下棋,1表示玩家一下的棋(在实例中为白棋),2表示玩家二下的棋,3表示超出允许下棋的界面,用self.steps来按顺序保存一下的棋子。

class Map:  # 地图类
    def __init__(self, width, height):  # 构造函数
        self.width = width
        self.height = height
        self.map = [[0 for x in range(self.width)] for y in range(self.height)]  # 存储棋盘的二维数组
        self.steps = []  # 记录步骤先后

    def get_init(self):  # 重置棋盘
        for y in range(self.height):
            for x in range(self.width):
                self.map[y][x] = 0
        self.steps = []

2.3编写函数intoNextTurn()

编写intoNextTurn()函数,意思是进入下一回合的比赛,交换下棋人。

    def intoNextTurn(self, turn):  # 进入下一回合,交换下棋人
        if turn == MAP_ENUM.player1:
            return MAP_ENUM.player2
        else:
            return MAP_ENUM.player1

2.4编写函数getLocate()

编写getLocate()函数,功能是根据出入的下标返回棋子的具体位置。

    def getLocate(self, x, y):  # 输入下标,返回具体位置
        map_x = x * square_size
        map_y = y * square_size
        return (map_x, map_y, square_size, square_size)  # 返回位置信息

2.5编写函数getIdex()

编写getIdex()函数,功能是根据输入的具体位置,返回棋子的下标。

    def getIndex(self, map_x, map_y):  # 输入具体位置,返回下标
        x = map_x // square_size
        y = map_y // square_size
        return (x, y)

2.6编写函数isInside()

编写isInside()函数,功能是判断当前位置是否在棋盘的有效位置,即没有出界。

    def isInside(self, map_x, map_y):  # 是否在有效范围内
        if (map_x <= 0 or map_x >= map_w or
                map_y <= 0 or map_y >= map_h):
            return False
        return True

2.7编写函数isEmpty()

编写isEmpty()函数,功能是判断当前的格子是否已经存在棋子。

    def isEmpty(self, x, y):  # 当前格子是否已经有棋子
        return (self.map[y][x] == 0)

2.8编写函数printChessPiece()

编写printChessPiece()函数,功能是在棋盘中绘制已经下的棋子,并且会按照下棋的顺序加上序号,在绘制时会区分黑棋和白棋。

    def printChessPiece(self, screen):  # 绘制棋子
        player_one = (255, 245, 238)  # 象牙白
        player_two = (41, 36, 33)  # 烟灰
        player_color = [player_one, player_two]
        for i in range(len(self.steps)):
            x, y = self.steps[i]
            map_x, map_y, width, height = self.getLocate(x, y)
            pos, radius = (map_x + width // 2, map_y + height // 2), chess_size
            turn = self.map[y][x]
            pygame.draw.circle(screen, player_color[turn - 1], pos, radius)  # 画棋子

    def drawBoard(self, screen):  # 画棋盘
        color = (0, 0, 0)  # 线色
        for y in range(self.height):
            # 画横着的棋盘线
            start_pos, end_pos = (square_size // 2, square_size // 2 + square_size * y), (
                map_w - square_size // 2, square_size // 2 + square_size * y)
            pygame.draw.line(screen, color, start_pos, end_pos, 1)
        for x in range(self.width):
            # 画竖着的棋盘线
            start_pos, end_pos = (square_size // 2 + square_size * x, square_size // 2), (
                square_size // 2 + square_size * x, map_h - square_size // 2)
            pygame.draw.line(screen, color, start_pos, end_pos, 1)

2.9实现AI功能

2.9.1方法分析

在文章的一开始,已经说明了,五子棋游戏有七种基本棋型,那么究竟如何记录棋盘上个的棋型个数呢?我们可以创建黑棋和白棋两个数组,记录棋盘上的黑棋和白棋分别形成的所有棋型的个数,然后按照一定的评分规则进行评分。本文的记录棋型的方法就是对整个棋盘进行遍历,对于每一个白棋或者黑棋,以它为中心,记录符合棋型的个数。具体诗仙女如下:

1)遍历棋盘上的每个点,对这个点所在的四个方向(水平,竖直,\\,/)形成的四条线进行评估。

2)对于一条具体的线,以它为中心,取这条线为方向上的前后各四个点,组成一个长度为9的数组。

3)找出这个长度为9的数组里面和中心点相同颜色的棋子有多少,在进行下一次评估的时候要将在数组内的同色棋子排除,避免重复统计棋型。

4)根据棋盘上的黑棋和白棋的棋型信息,按照一定的评分规则进行评分。值得注意一点的是,在评分的时候要标记最后一步棋是什么颜色的,因为,假设,最后一步是黑棋下的(评分规则是黑棋得分-白棋得分),那么在相同棋型和相同个数的情况下,即评分相同,白棋会占优,因为下一步是白棋下。本实例按照下面的评分规则进行依次匹配:
黑棋连五,评分为10000,
白棋连五,评分为-10000,
黑棋有两个冲四,可以当成一个活四,
白棋有活四,评分为-9050,
白棋有冲四,评分为-9040,
黑棋有活四,评分为9030,
黑棋有冲四和活三,评分为9020,
黑棋没有冲四,且白棋有活三,评分为9010,
黑棋有2个活三,且白棋没有活三或眠三,评分为9000,
最后针对黑棋或者白棋的活三,眠三,活二,眠二的个数进行依次增加分数,具体评分值为(黑棋得分-白棋得分)。

2.9.2功能实现

有了上面的评分标准后,当轮到AI下棋的时候,只要针对当前的棋型,找到一个最有利的位置进行下棋即可。下面进行编写评估函数,来获取最有利的位置:
先遍历整个棋盘的每一个空点,并在这个空点上下棋,获取新的棋局评分,
如果是比之前更高的得分,则保存该位置,
然后将这个位置恢复为空点,
最后获取最高得分的位置。

在实例文件中,通过类MyChessAI实现AI的功能,实现流程如下:
1)使用构造函数试下初始化的功能,在数组record中记录所有位置的4个方向是否被检测过,使用二维数组count记录白棋和黑棋的棋型个数统计。通过position_isgreat方法给棋盘上的每个位置设置一个初始分数,越靠近棋盘中心,分数越高,这样在最初没有任何棋型的时候,AI会优先选择靠近中心的位置。

class MyChessAI():
    def __init__(self, chess_len):  # 构造函数
        self.len = chess_len  # 当前棋盘大小
        # 二维数组,每一格存的是:横评分,纵评分,左斜评分,右斜评分
        self.record = [[[0, 0, 0, 0] for i in range(chess_len)] for j in range(chess_len)]
        # 存储当前格具体棋型数量
        self.count = [[0 for i in range(SITUATION_NUM)] for j in range(2)]
        # 位置分(同条件下越靠近棋盘中央越高)
        self.position_isgreat = [
            [(web_broad - max(abs(i - web_broad / 2 + 1), abs(j - web_broad / 2 + 1))) for i in range(chess_len)]
            for j in range(chess_len)]

    def get_init(self):  # 初始化
        for i in range(self.len):
            for j in range(self.len):
                for k in range(4):
                    self.record[i][j][k] = 0
        for i in range(len(self.count)):
            for j in range(len(self.count[0])):
                self.count[i][j] = 0
        self.save_count = 0

    def isWin(self, board, turn):  # 当前人胜利
        return self.evaluate(board, turn, True)

2)编写函数genmove(),功能是返回所有没有下棋的坐标(位置从好到坏)。

    def genmove(self, board, turn):
        moves = []
        for y in range(self.len):
            for x in range(self.len):
                if board[y][x] == 0:
                    score = self.position_isgreat[y][x]
                    moves.append((score, x, y))
        moves.sort(reverse=True)
        return moves

3)编写search()函数,功能是返回当前最优解的下标。先通过函数genmove()获取棋盘上所有的点,然后一次尝试,获得评分最高的位置,并且返回。

    def search(self, board, turn):
        moves = self.genmove(board, turn)
        bestmove = None
        max_score = -99999  # 无穷小
        for score, x, y in moves:
            board[y][x] = turn.value
            score = self.evaluate(board, turn)
            board[y][x] = 0
            if score > max_score:
                max_score = score
                bestmove = (max_score, x, y)
        return bestmove

4)编写函数getScore(),功能是对黑棋和白棋进行评分。

    def getScore(self, mychess, yourchess):
        mscore, oscore = 0, 0
        if mychess[FIVE] > 0:
            return (10000, 0)
        if yourchess[FIVE] > 0:
            return (0, 10000)
        if mychess[S4] >= 2:
            mychess[L4] += 1
        if yourchess[L4] > 0:
            return (0, 9050)
        if yourchess[S4] > 0:
            return (0, 9040)
        if mychess[L4] > 0:
            return (9030, 0)
        if mychess[S4] > 0 and mychess[L3] > 0:
            return (9020, 0)
        if yourchess[L3] > 0 and mychess[S4] == 0:
            return (0, 9010)
        if (mychess[L3] > 1 and yourchess[L3] == 0 and yourchess[S3] == 0):
            return (9000, 0)
        if mychess[S4] > 0:
            mscore += 2000
        if mychess[L3] > 1:
            mscore += 500
        elif mychess[L3] > 0:
            mscore += 100
        if yourchess[L3] > 1:
            oscore += 2000
        elif yourchess[L3] > 0:
            oscore += 400
        if mychess[S3] > 0:
            mscore += mychess[S3] * 10
        if yourchess[S3] > 0:
            oscore += yourchess[S3] * 10
        if mychess[L2] > 0:
            mscore += mychess[L2] * 4
        if yourchess[L2] > 0:
            oscore += yourchess[L2] * 4
        if mychess[S2] > 0:
            mscore += mychess[S2] * 4
        if yourchess[S2] > 0:
            oscore += yourchess[S2] * 4
        return (mscore, oscore)  # 自我辅助效果,counter对面效果

5)编写evaluate()函数,功能是对上面的得分进行进一步的处理,参数turn表示最后一步棋是谁下的,根据turn的值决定的me(表示自己棋的值)和you(表示对手棋的值,下一步有对手下),在对棋型评分时会用到。checkWin用来判断是否有一方获胜。

    def evaluate(self, board, turn, checkWin=False):
        self.get_init()
        if turn == MAP_ENUM.player1:
            me = 1
            you = 2
        else:
            me = 2
            you = 1
        for y in range(self.len):
            for x in range(self.len):
                if board[y][x] == me:
                    self.evaluatePoint(board, x, y, me, you)
                elif board[y][x] == you:
                    self.evaluatePoint(board, x, y, you, me)
        mychess = self.count[me - 1]
        yourchess = self.count[you - 1]
        if checkWin:
            return mychess[FIVE] > 0  # 检查是否已经胜利
        else:
            mscore, oscore = self.getScore(mychess, yourchess)
            return (mscore - oscore)  # 自我辅助效果,counter对面效果

6)编写函数evaluatePoint(),功能是对某一个位置的4个方向分别进行检查。

    def evaluatePoint(self, board, x, y, me, you):
        direction = [(1, 0), (0, 1), (1, 1), (1, -1)]  # 四个方向
        for i in range(4):
            if self.record[y][x][i] == 0:
                # 检查当前方向棋型
                self.getBasicSituation(board, x, y, i, direction[i], me, you, self.count[me - 1])
            else:
                self.save_count += 1

7)编写getLine()函数,功能是把当前方向的棋型存储下来,方便后续的使用。改函数能够根据棋子的位置和方向,获取上面说的长度为9的线。如果线上的位置超出了棋盘的范围,就将这个位置设置为对手的值,因为超出范围和被对手的棋当着,对棋型判断的结果是相同的。

    def getLine(self, board, x, y, direction, me, you):
        line = [0 for i in range(9)]
        # “光标”移到最左端
        tmp_x = x + (-5 * direction[0])
        tmp_y = y + (-5 * direction[1])
        for i in range(9):
            tmp_x += direction[0]
            tmp_y += direction[1]
            if (tmp_x < 0 or tmp_x >= self.len or tmp_y < 0 or tmp_y >= self.len):
                line[i] = you  # 出界
            else:
                line[i] = board[tmp_y][tmp_x]
        return line

8)编写函数getBasicSituation(),功能是把当前方向的棋型识别成具体的情况,例如把MMMMX识别成活四冲四,活三眠三等。

    def getBasicSituation(self, board, x, y, dir_index, dir, me, you, count):
        # record赋值
        def setRecord(self, x, y, left, right, dir_index, direction):
            tmp_x = x + (-5 + left) * direction[0]
            tmp_y = y + (-5 + left) * direction[1]
            for i in range(left, right):
                tmp_x += direction[0]
                tmp_y += direction[1]
                self.record[tmp_y][tmp_x][dir_index] = 1

        empty = MAP_ENUM.be_empty.value
        left_index, right_index = 4, 4
        line = self.getLine(board, x, y, dir, me, you)
        while right_index < 8:
            if line[right_index + 1] != me:
                break
            right_index += 1
        while left_index > 0:
            if line[left_index - 1] != me:
                break
            left_index -= 1
        left_range, right_range = left_index, right_index
        while right_range < 8:
            if line[right_range + 1] == you:
                break
            right_range += 1
        while left_range > 0:
            if line[left_range - 1] == you:
                break
            left_range -= 1
        chess_range = right_range - left_range + 1
        if chess_range < 5:
            setRecord(self, x, y, left_range, right_range, dir_index, dir)
            return SITUATION.NONE
        setRecord(self, x, y, left_index, right_index, dir_index, dir)
        m_range = right_index - left_index + 1
        if m_range == 5:
            count[FIVE] += 1
        # 活四冲四
        if m_range == 4:
            left_empty = right_empty = False
            if line[left_index - 1] == empty:
                left_empty = True
            if line[right_index + 1] == empty:
                right_empty = True
            if left_empty and right_empty:
                count[L4] += 1
            elif left_empty or right_empty:
                count[S4] += 1
        # 活三眠三
        if m_range == 3:
            left_empty = right_empty = False
            left_four = right_four = False
            if line[left_index - 1] == empty:
                if line[left_index - 2] == me:  # MXMMM
                    setRecord(self, x, y, left_index - 2, left_index - 1, dir_index, dir)
                    count[S4] += 1
                    left_four = True
                left_empty = True
            if line[right_index + 1] == empty:
                if line[right_index + 2] == me:  # MMMXM
                    setRecord(self, x, y, right_index + 1, right_index + 2, dir_index, dir)
                    count[S4] += 1
                    right_four = True
                right_empty = True
            if left_four or right_four:
                pass
            elif left_empty and right_empty:
                if chess_range > 5:  # XMMMXX, XXMMMX
                    count[L3] += 1
                else:  # PXMMMXP
                    count[S3] += 1
            elif left_empty or right_empty:  # PMMMX, XMMMP
                count[S3] += 1
        # 活二眠二
        if m_range == 2:
            left_empty = right_empty = False
            left_three = right_three = False
            if line[left_index - 1] == empty:
                if line[left_index - 2] == me:
                    setRecord(self, x, y, left_index - 2, left_index - 1, dir_index, dir)
                    if line[left_index - 3] == empty:
                        if line[right_index + 1] == empty:  # XMXMMX
                            count[L3] += 1
                        else:  # XMXMMP
                            count[S3] += 1
                        left_three = True
                    elif line[left_index - 3] == you:  # PMXMMX
                        if line[right_index + 1] == empty:
                            count[S3] += 1
                            left_three = True
                left_empty = True
            if line[right_index + 1] == empty:
                if line[right_index + 2] == me:
                    if line[right_index + 3] == me:  # MMXMM
                        setRecord(self, x, y, right_index + 1, right_index + 2, dir_index, dir)
                        count[S4] += 1
                        right_three = True
                    elif line[right_index + 3] == empty:
                        # setRecord(self, x, y, right_index+1, right_index+2, dir_index, dir)
                        if left_empty:  # XMMXMX
                            count[L3] += 1
                        else:  # PMMXMX
                            count[S3] += 1
                        right_three = True
                    elif left_empty:  # XMMXMP
                        count[S3] += 1
                        right_three = True
                right_empty = True
            if left_three or right_three:
                pass
            elif left_empty and right_empty:  # XMMX
                count[L2] += 1
            elif left_empty or right_empty:  # PMMX, XMMP
                count[S2] += 1
        # 特殊活二眠二(有空格
        if m_range == 1:
            left_empty = right_empty = False
            if line[left_index - 1] == empty:
                if line[left_index - 2] == me:
                    if line[left_index - 3] == empty:
                        if line[right_index + 1] == you:  # XMXMP
                            count[S2] += 1
                left_empty = True
            if line[right_index + 1] == empty:
                if line[right_index + 2] == me:
                    if line[right_index + 3] == empty:
                        if left_empty:  # XMXMX
                            count[L2] += 1
                        else:  # PMXMX
                            count[S2] += 1
                elif line[right_index + 2] == empty:
                    if line[right_index + 3] == me and line[right_index + 4] == empty:  # XMXXMX
                        count[L2] += 1
        # 以上都不是则为none棋型
        return SITUATION.NONE

2.10实现按钮功能

该游戏的界面上会有四个按钮:
Pick White:选择白棋
Pick Black:选择黑棋
Surrender:投降
Multiple:多人对战

1)编写游戏的按钮类button,这是一个父类,通过函数draw()根据按钮的enablel状态填色。

class Button:
    def __init__(self, screen, text, x, y, color, enable):  # 构造函数
        self.screen = screen
        self.width = button_w
        self.height = button_h
        self.button_color = color
        self.text_color = (255, 255, 255)  # 纯白
        self.enable = enable
        self.font = pygame.font.SysFont(None, button_h * 2 // 3)
        self.rect = pygame.Rect(0, 0, self.width, self.height)
        self.rect.topleft = (x, y)
        self.text = text
        self.init_msg()

    # 重写pygame内置函数,初始化我们的按钮
    def init_msg(self):
        if self.enable:
            self.msg_image = self.font.render(self.text, True, self.text_color, self.button_color[0])
        else:
            self.msg_image = self.font.render(self.text, True, self.text_color, self.button_color[1])
        self.msg_image_rect = self.msg_image.get_rect()
        self.msg_image_rect.center = self.rect.center

    # 根据按钮enable状态填色,具体颜色在后续子类控制
    def draw(self):
        if self.enable:
            self.screen.fill(self.button_color[0], self.rect)
        else:
            self.screen.fill(self.button_color[1], self.rect)
        self.screen.blit(self.msg_image, self.msg_image_rect)

2)编写类WhiteStartButton,实现选择白棋的功能。

class WhiteStartButton(Button):  # 开始按钮(选白棋)
    def __init__(self, screen, text, x, y):  # 构造函数
        super().__init__(screen, text, x, y, [(26, 173, 25), (158, 217, 157)], True)

    def click(self, game):  # 点击,pygame内置方法
        if self.enable:  # 启动游戏并初始化,变换按钮颜色
            game.start()
            game.winner = None
            game.multiple = False
            self.msg_image = self.font.render(self.text, True, self.text_color, self.button_color[1])
            self.enable = False
            return True
        return False

    def unclick(self):  # 取消点击
        if not self.enable:
            self.msg_image = self.font.render(self.text, True, self.text_color, self.button_color[0])
            self.enable = True

3)编写类BlackStartButton,实现选择黑棋的功能。

class BlackStartButton(Button):  # 开始按钮(选黑棋)
    def __init__(self, screen, text, x, y):  # 构造函数
        super().__init__(screen, text, x, y, [(26, 173, 25), (158, 217, 157)], True)

    def click(self, game):  # 点击,pygame内置方法
        if self.enable:  # 启动游戏并初始化,变换按钮颜色,安排AI先手
            game.start()
            game.winner = None
            game.multiple = False
            game.useAI = True
            self.msg_image = self.font.render(self.text, True, self.text_color, self.button_color[1])
            self.enable = False
            return True
        return False

    def unclick(self):  # 取消点击
        if not self.enable:
            self.msg_image = self.font.render(self.text, True, self.text_color, self.button_color[0])
            self.enable = True

4)编写类GiveupButton,实现投降功能。

class GiveupButton(Button):  # 投降按钮(任何模式都能用
    def __init__(self, screen, text, x, y):
        super().__init__(screen, text, x, y, [(230, 67, 64), (236, 139, 137)], False)

    def click(self, game):  # 结束游戏,判断赢家
        if self.enable:
            game.is_play = False
            if game.winner is None:
                game.winner = game.map.intoNextTurn(game.player)
            self.msg_image = self.font.render(self.text, True, self.text_color, self.button_color[1])
            self.enable = False
            return True
        return False

    def unclick(self):  # 保持不变,填充颜色
        if not self.enable:
            self.msg_image = self.font.render(self.text, True, self.text_color, self.button_color[0])
            self.enable = True

5)编写类MultiStartButton,实现多人对战功能。

class MultiStartButton(Button):  # 开始按钮(多人游戏)
    def __init__(self, screen, text, x, y):  # 构造函数
        super().__init__(screen, text, x, y, [(153, 51, 250), (221, 160, 221)], True)  # 紫色

    def click(self, game):  # 点击,pygame内置方法
        if self.enable:  # 启动游戏并初始化,变换按钮颜色
            game.start()
            game.winner = None
            game.multiple=True
            self.msg_image = self.font.render(self.text, True, self.text_color, self.button_color[1])
            self.enable = False
            return True
        return False

    def unclick(self):  # 取消点击
        if not self.enable:
            self.msg_image = self.font.render(self.text, True, self.text_color, self.button_color[0])
            self.enable = True

2.11实现重写功能(即游戏的调用函数)

为了更好地在主函数中规划和控住整个游戏的代码,编写Game类,在Game类中调用上面的功能函数,然后分别绘制棋盘、按钮和判断获胜的一方。

1)通过__init__(self, caption)实现初始化处理,设置按钮的内容和可用性。

class Game:  # pygame类,以下所有功能都是根据需要重写
    def __init__(self, caption):
        # 使用pygame之前必须初始化
        pygame.init()
        self.screen = pygame.display.set_mode([screen_w, screen_h])        # 设置主屏窗口
        pygame.display.set_caption(caption)       #设置窗口标题,即游戏名称
        self.clock = pygame.time.Clock()
        self.buttons = []
        self.buttons.append(WhiteStartButton(self.screen, 'Pick White', 10, map_h))
        self.buttons.append(BlackStartButton(self.screen, 'Pick Black', 170, map_h))
        self.buttons.append(GiveupButton(self.screen, 'Surrender', 330, map_h))
        self.buttons.append(MultiStartButton(self.screen, 'Multiple', 490, map_h))
        self.is_play = False
        self.map = Map(web_broad, web_broad)
        self.player = MAP_ENUM.player1
        self.action = None
        self.AI = MyChessAI(web_broad)
        self.useAI = False
        self.winner = None
        self.multiple = False

2)定义函数start(self),功能为开始游戏,默认白棋先下。

    def start(self):
        self.is_play = True
        self.player = MAP_ENUM.player1  # 白棋先手
        self.map.get_init()

3)定义函数play(self),绘制出棋盘和按钮。

    def play(self):
        # 画底板
        self.clock.tick(60)
        wood_color = (210, 180, 140)
        pygame.draw.rect(self.screen, wood_color, pygame.Rect(0, 0, map_w, screen_h))
        pygame.draw.rect(self.screen, (255, 255, 255), pygame.Rect(map_w, 0, info_w, screen_h))
        # 画按钮
        for button in self.buttons:
            button.draw()
        if self.is_play and not self.isOver():
            if self.useAI and not self.multiple:
                x, y = self.AI.findBestChess(self.map.map, self.player)
                self.checkClick(x, y, True)
                self.useAI = False
            if self.action is not None:
                self.checkClick(self.action[0], self.action[1])
                self.action = None
            if not self.isOver():
                self.changeMouseShow()
        if self.isOver():
            self.showWinner()
            # self.buttons[0].enable = True
            # self.buttons[1].enable = True
            # self.buttons[2].enable = False
        self.map.drawBoard(self.screen)
        self.map.printChessPiece(self.screen)

4)定义函数changeMouseShow(self),在开始游戏的时候吧鼠标指针切换成棋子的形态。

    def changeMouseShow(self):  # 开始游戏的时候把鼠标预览切换成预览棋子的样子
        map_x, map_y = pygame.mouse.get_pos()
        x, y = self.map.getIndex(map_x, map_y)
        if self.map.isInside(map_x, map_y) and self.map.isEmpty(x, y):  # 在棋盘内且当前无棋子
            pygame.mouse.set_visible(False)
            smoke_blue = (176, 224, 230)
            pos, radius = (map_x, map_y), chess_size
            pygame.draw.circle(self.screen, smoke_blue, pos, radius)
        else:
            pygame.mouse.set_visible(True)

    def checkClick(self, x, y, isAI=False):  # 后续处理
        self.map.click(x, y, self.player)
        if self.AI.isWin(self.map.map, self.player):
            self.winner = self.player
            self.click_button(self.buttons[2])
        else:
            self.player = self.map.intoNextTurn(self.player)
            if not isAI:
                self.useAI = True

5)定义函数mouseClick(self, map_x, map_y),处理下棋动作,将某个棋子放到棋盘中的某个位置。

    def mouseClick(self, map_x, map_y):  # 处理下棋动作
        if self.is_play and self.map.isInside(map_x, map_y) and not self.isOver():
            x, y = self.map.getIndex(map_x, map_y)
            if self.map.isEmpty(x, y):
                self.action = (x, y)

6)定义函数isOver(self),如果一方获胜则中断游戏。

    def isOver(self):  # 中断条件
        return self.winner is not None

7)定义函数showWinner(self),功能是打印输出获胜者。

    def showWinner(self):  # 输出胜者
        def showFont(screen, text, location_x, locaiton_y, height):
            font = pygame.font.SysFont(None, height)
            font_image = font.render(text, True, (255, 215, 0), (255, 255, 255))  # 金黄色
            font_image_rect = font_image.get_rect()
            font_image_rect.x = location_x
            font_image_rect.y = locaiton_y
            screen.blit(font_image, font_image_rect)

        if self.winner == MAP_ENUM.player1:
            str = 'White Wins!'
        else:
            str = 'Black Wins!'
        showFont(self.screen, str, map_w / 5, screen_h / 8, 100)  # 居上中,字号100
        pygame.mouse.set_visible(True)

8)游戏开始入口

if __name__ == '__main__':
    game = Game(version)
    while True:
        game.play()
        # 更新屏幕内容
        pygame.display.update()
        # 循环获取事件,监听事件状态
        for event in pygame.event.get():
            # 判断用户是否点了"X"关闭按钮,并执行if代码段
            if event.type == pygame.QUIT:
                # 卸载所有模块
                pygame.quit()
                # 终止程序,确保退出程序
                sys.exit()
            elif event.type == pygame.MOUSEBUTTONDOWN:
                mouse_x, mouse_y = pygame.mouse.get_pos()
                game.mouseClick(mouse_x, mouse_y)
                game.check_buttons(mouse_x, mouse_y)

3.完整代码及运行结果图

完整代码如下:

import time
from enum import IntEnum
import pygame
import sys
t = time.localtime()
date = str(t.tm_year) + '-' + str(t.tm_mon) + '-' + str(t.tm_mday) + ' ' + str(t.tm_hour) + ':' + str(t.tm_min) + ':' + str(t.tm_sec)
version = 'FiveChessV1.0  作者:栩珩  time:' + date

# 基础参数设置
square_size = 40  # 单格的宽度(不是格数!是为了方便绘制棋盘用的变量
chess_size = square_size // 2 - 2  # 棋子大小
web_broad = 15  # 棋盘格数+1(nxn)
map_w = web_broad * square_size  # 棋盘长度
map_h = web_broad * square_size  # 棋盘高度
info_w = 60  # 按钮界面宽度
button_w = 120  # 按钮长宽
button_h = 45
screen_w = map_w  # 总窗口长宽
screen_h = map_h + info_w


# 地图绘制模块

class MAP_ENUM(IntEnum):  # 用数字表示当前格的情况
    be_empty = 0,  # 无人下
    player1 = 1,  # 玩家一,执白
    player2 = 2,  # 玩家二,执黑
    out_of_range = 3,  # 出界


class Map:  # 地图类
    def __init__(self, width, height):  # 构造函数
        self.width = width
        self.height = height
        self.map = [[0 for x in range(self.width)] for y in range(self.height)]  # 存储棋盘的二维数组
        self.steps = []  # 记录步骤先后

    def get_init(self):  # 重置棋盘
        for y in range(self.height):
            for x in range(self.width):
                self.map[y][x] = 0
        self.steps = []

    def intoNextTurn(self, turn):  # 进入下一回合,交换下棋人
        if turn == MAP_ENUM.player1:
            return MAP_ENUM.player2
        else:
            return MAP_ENUM.player1

    def getLocate(self, x, y):  # 输入下标,返回具体位置
        map_x = x * square_size
        map_y = y * square_size
        return (map_x, map_y, square_size, square_size)  # 返回位置信息

    def getIndex(self, map_x, map_y):  # 输入具体位置,返回下标
        x = map_x // square_size
        y = map_y // square_size
        return (x, y)

    def isInside(self, map_x, map_y):  # 是否在有效范围内
        if (map_x <= 0 or map_x >= map_w or
                map_y <= 0 or map_y >= map_h):
            return False
        return True

    def isEmpty(self, x, y):  # 当前格子是否已经有棋子
        return (self.map[y][x] == 0)

    def click(self, x, y, type):  # 点击的下棋动作
        self.map[y][x] = type.value  # 下棋
        self.steps.append((x, y))  # 记录步骤信息

    def printChessPiece(self, screen):  # 绘制棋子
        player_one = (255, 245, 238)  # 象牙白
        player_two = (41, 36, 33)  # 烟灰
        player_color = [player_one, player_two]
        for i in range(len(self.steps)):
            x, y = self.steps[i]
            map_x, map_y, width, height = self.getLocate(x, y)
            pos, radius = (map_x + width // 2, map_y + height // 2), chess_size
            turn = self.map[y][x]
            pygame.draw.circle(screen, player_color[turn - 1], pos, radius)  # 画棋子

    def drawBoard(self, screen):  # 画棋盘
        color = (0, 0, 0)  # 线色
        for y in range(self.height):
            # 画横着的棋盘线
            start_pos, end_pos = (square_size // 2, square_size // 2 + square_size * y), (
                map_w - square_size // 2, square_size // 2 + square_size * y)
            pygame.draw.line(screen, color, start_pos, end_pos, 1)
        for x in range(self.width):
            # 画竖着的棋盘线
            start_pos, end_pos = (square_size // 2 + square_size * x, square_size // 2), (
                square_size // 2 + square_size * x, map_h - square_size // 2)
            pygame.draw.line(screen, color, start_pos, end_pos, 1)


# 高级AI模块

class SITUATION(IntEnum):  # 棋型
    NONE = 0,  # 无
    SLEEP_TWO = 1,  # 眠二
    LIVE_TWO = 2,  # 活二
    SLEEP_THREE = 3,  # 眠三
    LIVE_THREE = 4,  # 活三
    CHONG_FOUR = 5,  # 冲四
    LIVE_FOUR = 6,  # 活四
    LIVE_FIVE = 7,  # 活五


SITUATION_NUM = 8  # 长度

# 方便后续调用枚举内容
FIVE = SITUATION.LIVE_FIVE.value
L4, L3, L2 = SITUATION.LIVE_FOUR.value, SITUATION.LIVE_THREE.value, SITUATION.LIVE_TWO.value
S4, S3, S2 = SITUATION.CHONG_FOUR.value, SITUATION.SLEEP_THREE.value, SITUATION.SLEEP_TWO.value


class MyChessAI():
    def __init__(self, chess_len):  # 构造函数
        self.len = chess_len  # 当前棋盘大小
        # 二维数组,每一格存的是:横评分,纵评分,左斜评分,右斜评分
        self.record = [[[0, 0, 0, 0] for i in range(chess_len)] for j in range(chess_len)]
        # 存储当前格具体棋型数量
        self.count = [[0 for i in range(SITUATION_NUM)] for j in range(2)]
        # 位置分(同条件下越靠近棋盘中央越高)
        self.position_isgreat = [
            [(web_broad - max(abs(i - web_broad / 2 + 1), abs(j - web_broad / 2 + 1))) for i in range(chess_len)]
            for j in range(chess_len)]

    def get_init(self):  # 初始化
        for i in range(self.len):
            for j in range(self.len):
                for k in range(4):
                    self.record[i][j][k] = 0
        for i in range(len(self.count)):
            for j in range(len(self.count[0])):
                self.count[i][j] = 0
        self.save_count = 0

    def isWin(self, board, turn):  # 当前人胜利
        return self.evaluate(board, turn, True)

    # 返回所有未下棋坐标(位置从好到坏)
    def genmove(self, board, turn):
        moves = []
        for y in range(self.len):
            for x in range(self.len):
                if board[y][x] == 0:
                    score = self.position_isgreat[y][x]
                    moves.append((score, x, y))
        moves.sort(reverse=True)
        return moves

    # 返回当前最优解下标
    def search(self, board, turn):
        moves = self.genmove(board, turn)
        bestmove = None
        max_score = -99999  # 无穷小
        for score, x, y in moves:
            board[y][x] = turn.value
            score = self.evaluate(board, turn)
            board[y][x] = 0
            if score > max_score:
                max_score = score
                bestmove = (max_score, x, y)
        return bestmove

    # 主要用于测试的函数,现在已经没什么用
    def findBestChess(self, board, turn):
        # time1 = time.time()
        score, x, y = self.search(board, turn)
        # time2 = time.time()
        # print('time:%f  (%d, %d)' % ((time2 - time1), x, y))
        return (x, y)

    # 得出一点的评分
    # 直接列举所有棋型
    def getScore(self, mychess, yourchess):
        mscore, oscore = 0, 0
        if mychess[FIVE] > 0:
            return (10000, 0)
        if yourchess[FIVE] > 0:
            return (0, 10000)
        if mychess[S4] >= 2:
            mychess[L4] += 1
        if yourchess[L4] > 0:
            return (0, 9050)
        if yourchess[S4] > 0:
            return (0, 9040)
        if mychess[L4] > 0:
            return (9030, 0)
        if mychess[S4] > 0 and mychess[L3] > 0:
            return (9020, 0)
        if yourchess[L3] > 0 and mychess[S4] == 0:
            return (0, 9010)
        if (mychess[L3] > 1 and yourchess[L3] == 0 and yourchess[S3] == 0):
            return (9000, 0)
        if mychess[S4] > 0:
            mscore += 2000
        if mychess[L3] > 1:
            mscore += 500
        elif mychess[L3] > 0:
            mscore += 100
        if yourchess[L3] > 1:
            oscore += 2000
        elif yourchess[L3] > 0:
            oscore += 400
        if mychess[S3] > 0:
            mscore += mychess[S3] * 10
        if yourchess[S3] > 0:
            oscore += yourchess[S3] * 10
        if mychess[L2] > 0:
            mscore += mychess[L2] * 4
        if yourchess[L2] > 0:
            oscore += yourchess[L2] * 4
        if mychess[S2] > 0:
            mscore += mychess[S2] * 4
        if yourchess[S2] > 0:
            oscore += yourchess[S2] * 4
        return (mscore, oscore)  # 自我辅助效果,counter对面效果

    # 对上述得分进行进一步处理
    def evaluate(self, board, turn, checkWin=False):
        self.get_init()
        if turn == MAP_ENUM.player1:
            me = 1
            you = 2
        else:
            me = 2
            you = 1
        for y in range(self.len):
            for x in range(self.len):
                if board[y][x] == me:
                    self.evaluatePoint(board, x, y, me, you)
                elif board[y][x] == you:
                    self.evaluatePoint(board, x, y, you, me)
        mychess = self.count[me - 1]
        yourchess = self.count[you - 1]
        if checkWin:
            return mychess[FIVE] > 0  # 检查是否已经胜利
        else:
            mscore, oscore = self.getScore(mychess, yourchess)
            return (mscore - oscore)  # 自我辅助效果,counter对面效果

    def evaluatePoint(self, board, x, y, me, you):
        direction = [(1, 0), (0, 1), (1, 1), (1, -1)]  # 四个方向
        for i in range(4):
            if self.record[y][x][i] == 0:
                # 检查当前方向棋型
                self.getBasicSituation(board, x, y, i, direction[i], me, you, self.count[me - 1])
            else:
                self.save_count += 1

    # 把当前方向棋型存储下来,方便后续使用
    def getLine(self, board, x, y, direction, me, you):
        line = [0 for i in range(9)]
        # “光标”移到最左端
        tmp_x = x + (-5 * direction[0])
        tmp_y = y + (-5 * direction[1])
        for i in range(9):
            tmp_x += direction[0]
            tmp_y += direction[1]
            if (tmp_x < 0 or tmp_x >= self.len or tmp_y < 0 or tmp_y >= self.len):
                line[i] = you  # 出界
            else:
                line[i] = board[tmp_y][tmp_x]
        return line

    # 把当前方向的棋型识别成具体情况(如把MMMMX识别成冲四)
    def getBasicSituation(self, board, x, y, dir_index, dir, me, you, count):
        # record赋值
        def setRecord(self, x, y, left, right, dir_index, direction):
            tmp_x = x + (-5 + left) * direction[0]
            tmp_y = y + (-5 + left) * direction[1]
            for i in range(left, right):
                tmp_x += direction[0]
                tmp_y += direction[1]
                self.record[tmp_y][tmp_x][dir_index] = 1

        empty = MAP_ENUM.be_empty.value
        left_index, right_index = 4, 4
        line = self.getLine(board, x, y, dir, me, you)
        while right_index < 8:
            if line[right_index + 1] != me:
                break
            right_index += 1
        while left_index > 0:
            if line[left_index - 1] != me:
                break
            left_index -= 1
        left_range, right_range = left_index, right_index
        while right_range < 8:
            if line[right_range + 1] == you:
                break
            right_range += 1
        while left_range > 0:
            if line[left_range - 1] == you:
                break
            left_range -= 1
        chess_range = right_range - left_range + 1
        if chess_range < 5:
            setRecord(self, x, y, left_range, right_range, dir_index, dir)
            return SITUATION.NONE
        setRecord(self, x, y, left_index, right_index, dir_index, dir)
        m_range = right_index - left_index + 1
        if m_range == 5:
            count[FIVE] += 1
        # 活四冲四
        if m_range == 4:
            left_empty = right_empty = False
            if line[left_index - 1] == empty:
                left_empty = True
            if line[right_index + 1] == empty:
                right_empty = True
            if left_empty and right_empty:
                count[L4] += 1
            elif left_empty or right_empty:
                count[S4] += 1
        # 活三眠三
        if m_range == 3:
            left_empty = right_empty = False
            left_four = right_four = False
            if line[left_index - 1] == empty:
                if line[left_index - 2] == me:  # MXMMM
                    setRecord(self, x, y, left_index - 2, left_index - 1, dir_index, dir)
                    count[S4] += 1
                    left_four = True
                left_empty = True
            if line[right_index + 1] == empty:
                if line[right_index + 2] == me:  # MMMXM
                    setRecord(self, x, y, right_index + 1, right_index + 2, dir_index, dir)
                    count[S4] += 1
                    right_four = True
                right_empty = True
            if left_four or right_four:
                pass
            elif left_empty and right_empty:
                if chess_range > 5:  # XMMMXX, XXMMMX
                    count[L3] += 1
                else:  # PXMMMXP
                    count[S3] += 1
            elif left_empty or right_empty:  # PMMMX, XMMMP
                count[S3] += 1
        # 活二眠二
        if m_range == 2:
            left_empty = right_empty = False
            left_three = right_three = False
            if line[left_index - 1] == empty:
                if line[left_index - 2] == me:
                    setRecord(self, x, y, left_index - 2, left_index - 1, dir_index, dir)
                    if line[left_index - 3] == empty:
                        if line[right_index + 1] == empty:  # XMXMMX
                            count[L3] += 1
                        else:  # XMXMMP
                            count[S3] += 1
                        left_three = True
                    elif line[left_index - 3] == you:  # PMXMMX
                        if line[right_index + 1] == empty:
                            count[S3] += 1
                            left_three = True
                left_empty = True
            if line[right_index + 1] == empty:
                if line[right_index + 2] == me:
                    if line[right_index + 3] == me:  # MMXMM
                        setRecord(self, x, y, right_index + 1, right_index + 2, dir_index, dir)
                        count[S4] += 1
                        right_three = True
                    elif line[right_index + 3] == empty:
                        # setRecord(self, x, y, right_index+1, right_index+2, dir_index, dir)
                        if left_empty:  # XMMXMX
                            count[L3] += 1
                        else:  # PMMXMX
                            count[S3] += 1
                        right_three = True
                    elif left_empty:  # XMMXMP
                        count[S3] += 1
                        right_three = True
                right_empty = True
            if left_three or right_three:
                pass
            elif left_empty and right_empty:  # XMMX
                count[L2] += 1
            elif left_empty or right_empty:  # PMMX, XMMP
                count[S2] += 1
        # 特殊活二眠二(有空格
        if m_range == 1:
            left_empty = right_empty = False
            if line[left_index - 1] == empty:
                if line[left_index - 2] == me:
                    if line[left_index - 3] == empty:
                        if line[right_index + 1] == you:  # XMXMP
                            count[S2] += 1
                left_empty = True
            if line[right_index + 1] == empty:
                if line[right_index + 2] == me:
                    if line[right_index + 3] == empty:
                        if left_empty:  # XMXMX
                            count[L2] += 1
                        else:  # PMXMX
                            count[S2] += 1
                elif line[right_index + 2] == empty:
                    if line[right_index + 3] == me and line[right_index + 4] == empty:  # XMXXMX
                        count[L2] += 1
        # 以上都不是则为none棋型
        return SITUATION.NONE


# 主程序实现部分

# 控制进程按钮类(父类)
class Button:
    def __init__(self, screen, text, x, y, color, enable):  # 构造函数
        self.screen = screen
        self.width = button_w
        self.height = button_h
        self.button_color = color
        self.text_color = (255, 255, 255)  # 纯白
        self.enable = enable
        self.font = pygame.font.SysFont(None, button_h * 2 // 3)
        self.rect = pygame.Rect(0, 0, self.width, self.height)
        self.rect.topleft = (x, y)
        self.text = text
        self.init_msg()

    # 重写pygame内置函数,初始化我们的按钮
    def init_msg(self):
        if self.enable:
            self.msg_image = self.font.render(self.text, True, self.text_color, self.button_color[0])
        else:
            self.msg_image = self.font.render(self.text, True, self.text_color, self.button_color[1])
        self.msg_image_rect = self.msg_image.get_rect()
        self.msg_image_rect.center = self.rect.center

    # 根据按钮enable状态填色,具体颜色在后续子类控制
    def draw(self):
        if self.enable:
            self.screen.fill(self.button_color[0], self.rect)
        else:
            self.screen.fill(self.button_color[1], self.rect)
        self.screen.blit(self.msg_image, self.msg_image_rect)


class WhiteStartButton(Button):  # 开始按钮(选白棋)
    def __init__(self, screen, text, x, y):  # 构造函数
        super().__init__(screen, text, x, y, [(26, 173, 25), (158, 217, 157)], True)

    def click(self, game):  # 点击,pygame内置方法
        if self.enable:  # 启动游戏并初始化,变换按钮颜色
            game.start()
            game.winner = None
            game.multiple = False
            self.msg_image = self.font.render(self.text, True, self.text_color, self.button_color[1])
            self.enable = False
            return True
        return False

    def unclick(self):  # 取消点击
        if not self.enable:
            self.msg_image = self.font.render(self.text, True, self.text_color, self.button_color[0])
            self.enable = True


class BlackStartButton(Button):  # 开始按钮(选黑棋)
    def __init__(self, screen, text, x, y):  # 构造函数
        super().__init__(screen, text, x, y, [(26, 173, 25), (158, 217, 157)], True)

    def click(self, game):  # 点击,pygame内置方法
        if self.enable:  # 启动游戏并初始化,变换按钮颜色,安排AI先手
            game.start()
            game.winner = None
            game.multiple = False
            game.useAI = True
            self.msg_image = self.font.render(self.text, True, self.text_color, self.button_color[1])
            self.enable = False
            return True
        return False

    def unclick(self):  # 取消点击
        if not self.enable:
            self.msg_image = self.font.render(self.text, True, self.text_color, self.button_color[0])
            self.enable = True


class GiveupButton(Button):  # 投降按钮(任何模式都能用
    def __init__(self, screen, text, x, y):
        super().__init__(screen, text, x, y, [(230, 67, 64), (236, 139, 137)], False)

    def click(self, game):  # 结束游戏,判断赢家
        if self.enable:
            game.is_play = False
            if game.winner is None:
                game.winner = game.map.intoNextTurn(game.player)
            self.msg_image = self.font.render(self.text, True, self.text_color, self.button_color[1])
            self.enable = False
            return True
        return False

    def unclick(self):  # 保持不变,填充颜色
        if not self.enable:
            self.msg_image = self.font.render(self.text, True, self.text_color, self.button_color[0])
            self.enable = True


class MultiStartButton(Button):  # 开始按钮(多人游戏)
    def __init__(self, screen, text, x, y):  # 构造函数
        super().__init__(screen, text, x, y, [(153, 51, 250), (221, 160, 221)], True)  # 紫色

    def click(self, game):  # 点击,pygame内置方法
        if self.enable:  # 启动游戏并初始化,变换按钮颜色
            game.start()
            game.winner = None
            game.multiple=True
            self.msg_image = self.font.render(self.text, True, self.text_color, self.button_color[1])
            self.enable = False
            return True
     

结对-结对编项目作业名称-设计文档

设计项目:五子棋游戏

设计人员:孙政凯

游戏设计平台:pygame

安装下载python,pygame 复习巩固知识点,设计窗口,设计落子,设计游戏规则,设计关闭窗口按键,检查程序。

游戏窗口:480,480

游戏模式:人机模式,人人对战

游戏双方:黑子,白子

初始界面:游戏开始按钮,当鼠标点击游戏开始后可以选择两种模式(是否人机对战,人人对战)

游戏窗口为九宫格,当一方的落子组成一条直线后,判定胜利

 

以上是关于AI人机对战五子棋游戏Python(pygame)+AI并实现软件输出的主要内容,如果未能解决你的问题,请参考以下文章

Python游戏开发,pygame模块,Python实现五子棋联机对战小游戏

Python Pygame制作简单五子棋游戏(详细代码+解释)

五子棋AI图形界面人机对战(JAVA实现)

C语言 AI智能,五子棋 人机对战,人人对战

C#五子棋小游戏源码(人机对战)

结对编程项目五子棋-需求分析