python程序设计基础课程设计--五子棋小游戏

目录

一、项目简介

二、项目采用技术

1、基于的开发环境：

2、用到的框架：

三、功能需求分析

四、项目核心代码1、GameObject类

2、按钮类

3、判断落子位置是否合理

4、胜利说明

5、胜利检测

6、遍历棋盘每行获得的分数

7、 计算某一方的附加分

8、计算棋盘终总分

9、ai落子决策

10、窗体显示

11、棋形价值模型

12、游戏基础框架

五、系统演示操作视频

六、团队成员负责模块

一、项目简介

        使用python语言实现了五子棋小游戏，在游戏中，玩家可以与ai对战，两人轮流放置棋子，玩家在中途可以选着“悔棋”，撤销动作。最终，谁先连成五个棋子，游戏结束，获得胜利。

二、项目采用技术

1、基于的开发环境：

（1）Python解释器：

        从Python官方网站下载并安装适合本机操作系统的Python版本。

（2）PyCharm IDE：

        PyCharm是一个流行的Python集成开发环境（IDE），它提供了丰富的功能和工具，帮助你更高效地开发Python项目。从PyCharm官方网站下载并安装合适的PyCharm版本。

（3）五子棋库：

        为了实现五子棋游戏，需要使用一些额外的库，在PyCharm中，可以使用pip工具安装库。例如此次安装了Pygame游戏库。

2、用到的框架：

（1）pygame：

        pygame是一个用于编写视频游戏的Python库。虽然五子棋不是一个视频游戏，但pygame也可以用于创建图形用户界面，并且它提供了许多有用的工具和函数，可以帮助实现五子棋游戏。

（2）minimax：

        minimax是一种经典的AI算法，用于实现棋类游戏的AI。在五子棋游戏中，使用minimax算法来让计算最大得分。

3、引用的包：

        pygame、config、time。

三、功能需求分析

        玩家在一个15乘15的棋盘上轮流放置黑白棋子，谁先连成五个棋子就获得胜利。在游戏中，玩家可以与ai对战，两人轮流放置棋子，玩家在中途可以选着“悔棋”，点击悔棋按钮撤销一步（或几步）动作。最终，谁先连成五个棋子，游戏结束，获得胜利，并显示获胜者。五秒后，进去下一轮。

四、项目核心代码
1、GameObject类

class GameObject:
    # 具有棋子的图像、类别和坐标三个属性
    def __init__(self, image, color, pos):
        self.image = image
        self.color = color
        self.pos = image.get_rect(center=pos

2、按钮类

class Button(object):
    # 具有图像surface，宽高和坐标属性
    def __init__(self, text, color, x=None, y=None):
        self.surface = font_big.render(text, True, color)
        self.WIDTH = self.surface.get_width()
        self.HEIGHT = self.surface.get_height()
        self.x = x
        self.y = y
 
    # 这个方法用于确定鼠标是否点击了对应的按钮
    def check_click(self, position):
        x_match = self.x < position[0] < self.x + self.WIDTH
        y_match = self.y < position[1] < self.y + self.HEIGHT
        if x_match and y_match:
            return True
        else:
            return False

3、判断落子位置是否合理

def set_chess(board_inner, x, y, color):
    if board_inner[x][y] != ' ':
        print('该位置已有棋子')
        print(x, y)
        return False
    else:
        board_inner[x][y] = color
        print(x, y)
        # for _ in board_inner:
        #     print(_)
        # print()
        return True

4、胜利说明

def check_win(board_inner):
    for list_str in board_inner:
        if ''.join(list_str).find('O' * 5) != -1:
            print('白棋获胜')
            return 0
        elif ''.join(list_str).find('X' * 5) != -1:
            print('黑棋获胜')
            return 1
    else:
        return -1

5、胜利检测

def check_win_all(board_inner):
    board_c = [[] for _ in range(29)]
    for x in range(15):
        for y in range(15):
            board_c[x - y].append(board_inner[x][y])
    board_d = [[] for _ in range(29)]
    for x in range(15):
        for y in range(15):
            board_d[x + y].append(board_inner[x][y])
    return [check_win(board_inner), check_win([list(i) for i in zip(*board_inner)]), check_win(board_c),
            check_win(board_d)]

6、遍历棋盘每行获得的分数

def value(board_inner, temp_list, value_model):
    score = 0
    num = 0
    # 第一层循环，遍历棋盘，计算每一行的得分
    for list_str in board_inner:
        # 如果一行里棋子数量少于2个，则跳过这一行
        if len(''.join(list_str).replace(' ', '')) < 2:
            continue
        # a是一个跳过参数，识别到指定棋型后，需要跳过若干位
        a = 0
        # 第二层循环，双指针第一个指针。每一行需要逐位识别，因为最短的棋型是5位，因此range(11)就够了
        for i in range(11):
            # 若a为0，则正常处理
            if a == 0:
                # temp用于存储识别到的棋型
                temp = []
                # 第三层循环，双指针第二个指针。最短的棋型是5位，最长的棋型是11位；因此需要不断截取指定长度的切片与不同的棋型进行对比
                for j in range(5, 12):
                    # 如果超出本行长度，则跳出这层循环
                    if i + j > len(list_str):
                        break
                    # num用于测试调试时计算循环次数
                    num += 1
                    # 如果是本行的开头，则与开头棋型和通用棋型进行对比
                    if i == 0:
                        # 第四层循环，把截取的字符串与棋型字符串逐一比对
                        for k in value_model[0].items():
                            # 如果切片与棋型完全相等，则把结果记录在temp中
                            if ''.join(list_str[i:i + j]) == k[1][0]:
                                temp.append((i, k))
                    else:
                        # 如果既不是开头也不是结尾，与通用棋型进行对比
                        if i + j < len(list_str):
                            for k in value_model[1].items():
                                if ''.join(list_str[i:i + j]) == k[1][0]:
                                    temp.append((i, k))
                        # 如果是结尾，与结尾棋型和通用棋型进行对比
                        elif i + j == len(list_str):
                            for k in value_model[2].items():
                                if ''.join(list_str[i:i + j]) == k[1][0]:
                                    temp.append((i, k))
            # 如果a不等于1，则相当于跳过本次比对，a-1，temp要记得重新赋值为[]
            else:
                a -= 1
                temp = []
            # 对temp进行判空操作，避免报错
            if temp:
                # 用列表推导式从temp中抽离出有效信息，获得切片匹配到的最高分
                max_value = max([i[1][1][1] for i in temp])
                # 基于最高分找到匹配到的棋型
                max_shape = [i for i in temp if i[1][1][1] == max_value][0]
                # 棋型特殊处理，若匹配到某些棋型，需要在匹配时跳过若干位
                if max_shape[1][0] in ['4_3', '3_0', '3_16', '2_3']:
                    a = 1
                elif max_shape[1][0] in ['4_5', '4_13', '3_5', '2_0']:
                    a = 2
                elif max_shape[1][0] in ['4_4']:
                    a = 5
                # 用temp_list保存每一行、每一位匹配到的棋型
                temp_list.append(max_shape)
                # 用score记录总分值
                score += max_value
    # print(temp_list)
    # print('value函数循环次数{}'.format(num))
    return score

7、 计算某一方的附加分

def additional(te_list):
    score = 0
    # 对te_list做一些处理得到temp_list
    temp_list = [i[1][0] for i in te_list]
    # 死四 + 活三 >= 2，则附加分加30分
    if sum([temp_list.count(i) for i in ['3_0', '3_3', '3_4', '3_5', '3_6', '4_1', '4_2', '4_3', '4_4', '4_5', '4_6'，'4_7', '4_8', '4_9', '4_10', '4_11', '4_12', '4_13', '4_14', '4_15', '4_16', '4_17', '4_18', '4_19']]) >= 2:
        score += 30
    # 活三 + 死三 >= 2 且 活三 > 0，则附加分加15分
    elif sum([temp_list.count(i) for i in ['3_0', '3_3', '3_4', '3_5', '3_6', '3_1', '3_2', '3_7', '3_8', '3_9', '3_10', '3_11', '3_12', '3_13', '3_14', '3_15', '3_16', '3_17']]) >= 2 \
            and sum([temp_list.count(i) for i in ['3_0', '3_3', '3_4', '3_5', '3_6']]) > 0:
        score += 15
    return score

8、计算棋盘终总分

def value_all(board_inner, temp_list, value_model):
    board_c = [[] for _ in range(29)]
    for x in range(15):
        for y in range(15):
            board_c[x + y].append(board_inner[x][y])
    board_d = [[] for _ in range(29)]
    for x in range(15):
        for y in range(15):
            board_d[x - y].append(board_inner[x][y])
    a = value(board_inner, temp_list, value_model)
    b = value([list(i) for i in zip(*board_inner)], temp_list, value_model)
    c = value(board_c, temp_list, value_model)
    d = value(board_d, temp_list, value_model)
    # 进行四个方向检测时，共用一个temp_list，因此附加分是考虑了全部四个方向
    add = additional(temp_list)
    # print(temp_list)
    # print('横{},竖{},正斜{},反斜{},附加{}'.format(a, b, c, d, add))
    return a + b + c + d + add

9、ai落子决策

def value_chess(board_inner):
    t1 = time.time()
    # 如果棋盘为空，则黑棋直接落在天元位置，分数为0
    if board_inner == [[' '] * 15 for line in range(15)]:
        return 7, 7, 0
    # 一系列数据初始化
    temp_list_x = []
    temp_list_o = []
    tp_list_x_2 = []
    tp_list_o_2 = []
    tp_list_d = []
    score_x = value_all(board_inner, temp_list_x, value_model_X)  # 落子前，黑棋分数
    pos_x = (0, 0)
    score_o = value_all(board_inner, temp_list_o, value_model_O)  # 落子前，白棋分数
    pos_o = (0, 0)
    pos_d = (0, 0)
    score_x_2 = 0
    score_o_2 = 0
    score_diff = 0
    # 获得横竖两个方向，棋子落子范围；比如最左棋子在第5列，最右棋子在第9列；最上棋子在第5行，最下棋子在第9行；
    # 目的是为了缩小遍历范围；离当前棋子过远的区域，影响较小，就不再考虑遍历了；
    chess_range_x = [x for x in range(15) if ''.join(board_inner[x]).replace(' ', '') != '']
    chess_range_y = [y for y in range(15) if ''.join([list(i) for i in zip(*board_inner)][y]).replace(' ', '') != '']
    # 在棋子最大范围的基础上，做一些小小的拓展，得到落子检测区域；在上下左右四个方向各拓展4行/列；
    range_x = (max(0, min(chess_range_x) - 4), min(max(chess_range_x) + 4, 15))
    range_y = (max(0, min(chess_range_y) - 4), min(max(chess_range_y) + 4, 15))
    # 遍历落子检测区域所有的位置
    for x in range(*range_x):
        for y in range(*range_y):
            tp_list_x = []
            tp_list_o = []
            tp_list_c = []
            # 如果该位置已有棋子，则跳过
            if board_inner[x][y] != ' ':
                continue
            else:
                board_inner[x][y] = 'X'
                score_a = value_all(board_inner, tp_list_x, value_model_X)  # 该位置落黑子，黑棋分数
                score_c = value_all(board_inner, tp_list_c, value_model_O)  # 该位置落黑子，白棋分数
                # score_x_2用于记录黑棋最高分对应的落子信息
                if score_a > score_x_2:
                    pos_x = x, y
                    tp_list_x_2 = tp_list_x
                    score_x_2 = score_a
                # 假定在该位置落白子
                board_inner[x][y] = 'O'
                score_b = value_all(board_inner, tp_list_o, value_model_O)  # 该位置落白子，白棋分数
                # score_x_2用于记录白棋最高分对应的落子信息
                if score_b > score_o_2:
                    pos_o = x, y
                    tp_list_o_2 = tp_list_o
                    score_o_2 = score_b
                # 将该位置棋子信息复原
                board_inner[x][y] = ' '
                # diff = = 1.1 * 黑棋分数增长 + （白棋原分数 - 落子后白棋分数） +  （白棋预期最高分 - 落子后白棋分数）
                # 之所以（白棋预期最高分 - 落子后白棋分数），是为了增加防守的逻辑；
                # 之所以设置1.1的系数，是为了鼓励进攻，毕竟只有进攻才能获得胜利
                diff = 1.1 * (score_a - score_x) + score_o - score_c + score_b - score_c
                # score_diff用于记录diff的最大值
                if diff > score_diff:
                    pos_d = x, y
                    tp_list_d = tp_list_x
                    score_diff = diff
    # 三种不同的策略，打印出对应的信息
    if score_x_2 >= 1000:
        print('——' * 30)
        print('策略1棋面：')
        print('黑棋棋面：', temp_list_x)
        print('白棋棋面：', temp_list_o)
        score = score_x_2
        pos = pos_x
        x, y = pos
        board_inner[x][y] = 'X'
        # temp_list_x.clear()
        # score = value_all(board_inner, temp_list_x, value_model_X)
        score_o_e = value_all(board_inner, temp_list_o, value_model_O)
        board_inner[x][y] = ' '
        print('执行策略1、直接获胜')
        print('黑棋最佳落子：坐标{}，黑棋得分{}，白棋得分{}'.format(pos, score, score_o_e))
        # print('白棋最佳落子：坐标{}'.format(pos_o))
        print('白棋原分数{}，预期最高分数{}，分数差值{}'.format(score_o, score_o_2, score_o_2 - score_o))
        print('若白棋落子{}，白棋棋型{}'.format(pos_o, tp_list_o_2))
        print('黑棋原分数{}，预期最高分数{}，分数差值{}'.format(score_x, score_x_2, score_x_2 - score_x))
        print('若黑棋落子{}，黑棋棋型{}'.format(pos_x, tp_list_x_2))
        print('——' * 30)
    elif score_o_2 >= 1000:
        print('——' * 30)
        print('策略2棋面：')
        print('黑棋棋面：', temp_list_x)
        print('白棋棋面：', temp_list_o)
        x, y = pos_o
        board_inner[x][y] = 'X'
        temp_list_x.clear()
        score = value_all(board_inner, temp_list_x, value_model_X)
        score_o_e = value_all(board_inner, temp_list_o, value_model_O)
        board_inner[x][y] = ' '
        pos = pos_o
        print('执行策略2、防守：防止对方获胜')
        print('黑棋最佳落子：坐标{}，黑棋得分{}，白棋得分{}'.format(pos, score, score_o_e))
        # print('白棋最佳落子：坐标{}'.format(pos_o))
        print('白棋原分数{}，预期最高分数{}，分数差值{}'.format(score_o, score_o_2, score_o_2 - score_o))
        print('若白棋落子{}，白棋棋型{}'.format(pos_o, tp_list_o_2))
        print('黑棋原分数{}，预期最高分数{}，分数差值{}'.format(score_x, score_x_2, score_x_2 - score_x))
        print('若黑棋落子{}，黑棋棋型{}'.format(pos_x, tp_list_x_2))
        print('——' * 30)
    else:
        print('——' * 30)
        print('策略3棋面：')
        print('黑棋棋面：', temp_list_x)
        print('白棋棋面：', temp_list_o)
        x, y = pos_d
        board_inner[x][y] = 'X'
        temp_list_x.clear()
        temp_list_o.clear()
        score = value_all(board_inner, temp_list_x, value_model_X)
        score_o_e = value_all(board_inner, temp_list_o, value_model_O)
        board_inner[x][y] = 'O'
        score_test = value_all(board_inner, [], value_model_O)
        board_inner[x][y] = ' '
        pos = pos_d
        print('黑棋原得分', score_x)
        print('黑棋得分', score)
        print('白棋原得分', score_o)
        print('白棋得分', score_o_e)
        print('若该位置落白棋，白棋得分', score_test)
        print('落子后黑棋棋面', temp_list_x)
        print('执行策略3、防守：防守+进攻')
        print('我方增长得分+对方减少得分：{}'.format(score_diff))
        print('黑棋最佳落子：坐标{}，黑棋得分{}，白棋得分{}'.format(pos, score, score_o_e))
        # print('白棋最佳落子：坐标{}'.format(pos_o))
        print('白棋原分数{}，预期最高分数{}，分数差值{}'.format(score_o, score_o_2, score_o_2 - score_o))
        print('若白棋落子{}，白棋棋型{}'.format(pos_o, tp_list_o_2))
        print('黑棋原分数{}，预期最高分数{}，分数差值{}'.format(score_x, score_x_2, score_x_2 - score_x))
        print('若黑棋落子{}，黑棋棋型{}'.format(pos_x, tp_list_x_2))
        print('——' * 30)
    print("代码执行完毕，用时{}秒".format(round(time.time() - t1, 2)))
    # 返回最终策略对应的黑棋落子坐标和黑棋得分
    return *pos, score

10、窗体显示

def main(board_inner):
    pg.init()
    # 一系列数据初始化
    # pygame时钟
    clock = pg.time.Clock()
    # 下棋记录列表
    objects = []
    # 恢复棋子时用到的列表，即悔棋记录列表
    recover_objects = []
    # 将以上两个列表放到一个列表中，主要是增强抽象度，简少了代码行数
    ob_list = [objects, recover_objects]
    # 游戏窗口
    screen = pg.display.set_mode((WIDTH, HEIGHT))
    # 黑棋棋子图像
    black = pg.image.load("data/chess_black.png").convert_alpha()
    # 白棋棋子图像
    white = pg.image.load("data/chess_white.png").convert_alpha()
    # 棋盘背景图像
    background = pg.image.load("data/qp.png").convert_alpha()
    # 创建悔棋按钮
    regret_button = Button('悔棋', RED, 665, 200)
    # 创建恢复按钮
    recover_button = Button('恢复', BLUE, 665, 300)
    # 创建重新开始按钮
    restart_button = Button('重新开始', GREEN, 625, 400)
    # 把悔棋按钮打印游戏窗口
    screen.blit(regret_button.surface, (regret_button.x, regret_button.y))
    # 把恢复按钮打印游戏窗口
    screen.blit(recover_button.surface, (recover_button.x, recover_button.y))
    # 把重新开始按钮打印游戏窗口
    screen.blit(restart_button.surface, (restart_button.x, restart_button.y))
    # 窗体的标题
    pg.display.set_caption("五子棋")
    # 回合变量，用于识别当前是哪一方回合
    flag = 0
    # 主循环变量，用于控制主循环继续或者结束
    going = True
    # 棋子图像列表，主要是增强抽象度，简少了代码行数
    chess_list = [black, white]
    # 棋子类型列表，主要是增强抽象度，简少了代码行数
    letter_list = ['X', 'O']
    # 棋子文字名称列表，主要是增强抽象度，简少了代码行数
    word_list = ['黑棋', '白棋']
    # 棋子文字颜色列表，主要是增强抽象度，简少了代码行数
    word_color = [(0, 0, 0), (255, 255, 255)]
    while going:
        # 将棋盘背景打印到游戏窗口
        screen.blit(background, (0, 0))
        # 创建一个文本对象，显示当前是哪方的回合
        text = font.render("{}回合".format(word_list[flag]), True, word_color[flag])
        # 确定文本对象的显示位置
        text_pos = text.get_rect(centerx=background.get_width() / 2, y=2)
        # 将文本对象打印到游戏窗口
        screen.blit(text, text_pos)
        # 通过循环不断识别玩家操作
        for event in pg.event.get():
            # 如果关闭窗口，主循环结束
            if event.type == pg.QUIT:
                going = False
            # 如果点击键盘ESC键，主循环结束
            elif event.type == pg.KEYDOWN and event.key == pg.K_ESCAPE:
                going = False
            # 如果玩家进行了鼠标点击操作
            elif event.type == pg.MOUSEBUTTONDOWN:
                # 获取鼠标点击坐标
                pos = pg.mouse.get_pos()
                # 如果点击了悔棋按钮或者恢复按钮
                if regret_button.check_click(pos) or recover_button.check_click(pos):
                    # 点击悔棋按钮index = 0，点击恢复按钮index = 1
                    index = 0 if regret_button.check_click(pos) else 1
                    # 对指定列表进行判空操作，然后对下棋记录列表或者悔棋记录列表进行操作
                    if ob_list[index]:
                        # print(ob_list[index][-1].pos)
                        # 将游戏/悔棋记录列表里的图像坐标，转化为board坐标
                        # 人机对战需要黑方、白方各悔一步棋；（如果只是玩家悔棋，AI会立即下出一步，导致悔棋失败）
                        x, y = [round((p + 18 - 27) / 40) for p in ob_list[index][-1].pos[:2]]
                        # print(y, x)
                        # 如果是悔棋操作，则board指定元素值恢复为' '；如果是恢复操作，则指定坐标board指定元素重新赋值
                        board_inner[y][x] = ' ' if index == 0 else ob_list[index][-1].color
                        # 将游戏/悔棋记录列表的最后一个值添加到悔棋/下棋记录列表
                        ob_list[index - 1].append(ob_list[index][-1])
                        # 将游戏/悔棋记录列表的最后一个值删除
                        ob_list[index].pop()
 
                        x, y = [round((p + 18 - 27) / 40) for p in ob_list[index][-1].pos[:2]]
                        # print(y, x)
                        # 如果是悔棋操作，则board指定元素值恢复为' '；如果是恢复操作，则指定坐标board指定元素重新赋值
                        board_inner[y][x] = ' ' if index == 0 else ob_list[index][-1].color
                        # 将游戏/悔棋记录列表的最后一个值添加到悔棋/下棋记录列表
                        ob_list[index - 1].append(ob_list[index][-1])
                        # 将游戏/悔棋记录列表的最后一个值删除
                        ob_list[index].pop()
 
                        # flag = [1, 0][flag]  # 变更回合方
                elif restart_button.check_click(pos):
                    # 提示文案
                    hint_text = font.render("游戏重新开始", True, word_color[flag])
                    # 提示文案位置
                    hint_text_pos = hint_text.get_rect(centerx=background.get_width() / 2, y=200)
                    # 把提示文案打印到游戏窗口
                    screen.blit(hint_text, hint_text_pos)
                    # 对游戏窗口进行刷新
                    pg.display.update()
                    # 暂停1秒，保证文案能够清晰展示
                    pg.time.delay(1000)
                    # 对board进行初始化
                    board_inner = [[' '] * 15 for _ in range(15)]
                    # 下棋记录列表初始化
                    objects.clear()
                    # 悔棋记录列表初始化
                    recover_objects.clear()
                    # flag初始化
                    flag = 0
                    # 通过continue跳过下一行代码，从而保证flag赋值不会异常
                    continue
                else:
                    # 若用户点击的不是悔棋、恢复按钮，则进行落子操作
                    # 将用户鼠标点击位置的坐标，换算为board坐标
                    a, b = round((pos[0] - 27) / 40), round((pos[1] - 27) / 40)
                    # 若坐标非法（即点击到了黑色区域），则不做处理
                    if a >= 15 or b >= 15:
                        continue
                    else:
                        # 将a、b进行处理得到x和y
                        x, y = max(0, a) if a < 0 else min(a, 14), max(0, b) if b < 0 else min(b, 14)
                        # 若落子操作合法，则进行落子
                        if set_chess(board_inner, y, x, letter_list[flag]):
                            # 下棋记录列表添加指定棋子
                            objects.append(GameObject(chess_list[flag], letter_list[flag], (27 + x * 40, 27 + y * 40)))
                            # 一旦成功落子，则将悔棋记录列表清空；不这么做，一旦在悔棋和恢复中间掺杂落子操作，就会有问题
                            recover_objects.clear()
                            # 判断是否出现获胜方
                            if 0 in check_win_all(board_inner) or 1 in check_win_all(board_inner):
                                # 将下棋记录的棋子打印到游戏窗口
                                for o in objects:
                                    screen.blit(o.image, o.pos)
                                # 根据flag获取到当前获胜方，生成获胜文案
                                win_text = font.render("{}获胜，游戏5秒后重新开始".format(word_list[flag]), True,
                                                       word_color[flag])
                                # 设定获胜文案的位置
                                win_text_pos = win_text.get_rect(centerx=background.get_width() / 2, y=200)
                                # 把获胜文案打印到游戏窗口
                                screen.blit(win_text, win_text_pos)
                                # 对游戏窗口进行刷新
                                pg.display.update()
                                # 暂停5秒，保证文案能够清晰展示
                                pg.time.delay(5000)
                                # 对board进行初始化
                                board_inner = [[' '] * 15 for _ in range(15)]
                                # 下棋记录列表初始化
                                objects.clear()
                                # 悔棋记录列表初始化
                                recover_objects.clear()
                                # flag初始化
                                flag = 0
                                # 通过continue跳过下一行代码，从而保证flag赋值不会异常
                                continue
                            flag = [1, 0][flag]
                        # 若落子位置已经有棋子，则进行提示
                        else:
                            # 提示文案
                            hint_text = font.render("该位置已有棋子", True, word_color[flag])
                            # 提示文案位置
                            hint_text_pos = hint_text.get_rect(centerx=background.get_width() / 2, y=200)
                            # 将下棋记录的棋子打印到游戏窗口
                            for o in objects:
                                screen.blit(o.image, o.pos)
                            # 把提示文案打印到游戏窗口
                            screen.blit(hint_text, hint_text_pos)
                            # 对游戏窗口进行刷新
                            pg.display.update()
                            # 暂停0.3秒，保证文案能够清晰展示
                            pg.time.delay(300)
        # AI执黑，AI进行落子
        if flag == 0:
            y, x = value_chess(board_inner)[:2]
            if set_chess(board_inner, y, x, letter_list[flag]):
                objects.append(GameObject(chess_list[flag], letter_list[flag], (27 + x * 40, 27 + y * 40)))
                flag = [1, 0][flag]
        # 将下棋记录的棋子打印到游戏窗口
        for o in objects:
            screen.blit(o.image, o.pos)
        # 游戏帧率每秒60帧
        clock.tick(60)
        # 对游戏窗口进行刷新
        pg.display.update()

11、棋形价值模型

WIDTH, HEIGHT = 800, 615
RED = (255, 48, 48)
BLUE = (65, 105, 225)
GREEN = (0, 139, 0)
board = [[' '] * 15 for line in range(15)]
 
# value_model_X_test = {
#         '5': ('XXXXX', 1000),
#
#         '4_0': (' XXXX ', 400),
#         '4_1': (' XXXXO', 100),
#         '4_2': ('OXXXX ', 100),
#         '4_11': ('XXXX ', 100),  # 开头
#         '4_10': (' XXXX', 100),  # 结尾
#
#         '4_9': ('OXXX X', 82),
#         '4_17': ('XXX XO', 86),
#         '4_15': ('XXX X', 82),  # 开头
#         '4_19': ('XXX X', 86),  # 结尾
#         '4_5': ('  XXX X', 120),
#
#         '4_7': ('XX XXO', 84),
#         '4_8': ('OXX XX', 84),
#         '4_13': ('XX XX ', 84),  # 开头
#         '4_4': ('   XX XX   ', 110),
#         '4_14': ('XX XX', 84),  # 结尾
#
#         '4_3': ('X XXX  ', 120),
#         '4_6': ('X XXXO', 82),
#         '4_16': ('OX XXX', 86),
#         '4_18': ('X XXX', 86),  # 开头
#         '4_12': ('X XXX', 82),  # 结尾
#
#         '3_0': ('  XXX  ', 60),
#         '3_1': ('  XXXO', 25),
#         '3_2': ('OXXX  ', 25),
#         '3_3': (' XXX  ', 30),
#         '3_4': ('  XXX ', 30),
#         '3_10': ('XXX  ', 25),  # 开头
#         '3_12': ('  XXX', 25),  # 结尾
#
#         '3_6': (' XX X ', 37),
#         '3_17': (' XX X', 23),  # 结尾
#         '3_15': (' XX XO', 23),
#         '3_11': ('XX X ', 21),  # 开头
#         '3_8': ('OXX X ', 21),
#
#         '3_5': (' X XX ', 37),
#         '3_9': (' X XXO', 21),
#         '3_14': ('OX XX ', 23),
#         '3_16': ('X XX ', 23),  # 开头
#         '3_13': (' X XX', 21),  # 结尾
#
#         '3_7': (' X X X ', 27),
#
#         '2_0': ('   XX   ', 8),
#         '2_1': ('   XXO', 2),
#         '2_2': ('OXX   ', 2),
#         '2_3': ('  XX   ', 5),
#         '2_4': (' XX   ', 4),
#         '2_6': ('XX   ', 2),  # 开头
#         '2_7': ('   XX', 2),  # 结尾
#
#         '2_5': (' X X ', 4)
#     }
 
value_model_X = [
    # 开头检测
    {
        '5': ('XXXXX', 1000),
 
        '4_0': (' XXXX ', 400),
        '4_1': (' XXXXO', 100),
        '4_2': ('OXXXX ', 100),
        '4_3': ('X XXX  ', 120),
        '4_4': ('   XX XX   ', 110),
        '4_5': ('  XXX X', 120),
        '4_6': ('X XXXO', 82),
        '4_7': ('XX XXO', 84),
        '4_8': ('OXX XX', 84),
        '4_9': ('OXXX X', 82),
        '4_16': ('OX XXX', 86),
        '4_17': ('XXX XO', 86),
        '4_11': ('XXXX ', 100),  # 开头
        '4_13': ('XX XX ', 84),  # 开头
        '4_15': ('XXX X', 82),  # 开头
        '4_18': ('X XXX', 86),  # 开头
 
        '3_0': ('  XXX  ', 60),
        '3_1': ('  XXXO', 25),
        '3_2': ('OXXX  ', 25),
        '3_3': (' XXX  ', 30),
        '3_4': ('  XXX ', 30),
        '3_5': (' X XX ', 37),
        '3_6': (' XX X ', 37),
        '3_7': (' X X X ', 27),
        '3_8': ('OXX X ', 21),
        '3_9': (' X XXO', 21),
        '3_14': ('OX XX ', 23),
        '3_15': (' XX XO', 23),
        '3_10': ('XXX  ', 25),  # 开头
        '3_11': ('XX X ', 21),  # 开头
        '3_16': ('X XX ', 23),  # 开头
 
        '2_0': ('   XX   ', 8),
        '2_1': ('   XXO', 2),
        '2_2': ('OXX   ', 2),
        '2_3': ('  XX   ', 5),
        '2_4': (' XX   ', 4),
        '2_5': (' X X ', 4),
        '2_6': ('XX   ', 2),  # 开头
    },
    # 中间检测
    {
        '5': ('XXXXX', 1000),
 
        '4_0': (' XXXX ', 400),
        '4_1': (' XXXXO', 100),
        '4_2': ('OXXXX ', 100),
        '4_3': ('X XXX  ', 120),
        '4_4': ('   XX XX   ', 110),
        '4_5': ('  XXX X', 120),
        '4_6': ('X XXXO', 82),
        '4_7': ('XX XXO', 84),
        '4_8': ('OXX XX', 84),
        '4_9': ('OXXX X', 82),
        '4_16': ('OX XXX', 86),
        '4_17': ('XXX XO', 86),
 
        '3_0': ('  XXX  ', 60),
        '3_1': ('  XXXO', 25),
        '3_2': ('OXXX  ', 25),
        '3_3': (' XXX  ', 30),
        '3_4': ('  XXX ', 30),
        '3_5': (' X XX ', 37),
        '3_6': (' XX X ', 37),
        '3_7': (' X X X ', 27),
        '3_8': ('OXX X ', 21),
        '3_9': (' X XXO', 21),
        '3_14': ('OX XX ', 23),
        '3_15': (' XX XO', 23),
 
        '2_0': ('   XX   ', 8),
        '2_1': ('   XXO', 2),
        '2_2': ('OXX   ', 2),
        '2_3': ('  XX   ', 5),
        '2_4': (' XX   ', 4),
        '2_5': (' X X ', 4)
    },
    # 结尾检测
    {
        '5': ('XXXXX', 1000),
 
        '4_0': (' XXXX ', 400),
        '4_1': (' XXXXO', 100),
        '4_2': ('OXXXX ', 100),
        '4_3': ('X XXX  ', 120),
        '4_4': ('   XX XX   ', 110),
        '4_5': ('  XXX X', 120),
        '4_6': ('X XXXO', 82),
        '4_7': ('XX XXO', 84),
        '4_8': ('OXX XX', 84),
        '4_9': ('OXXX X', 82),
        '4_16': ('OX XXX', 86),
        '4_17': ('XXX XO', 86),
        '4_10': (' XXXX', 100),  # 结尾
        '4_12': ('X XXX', 82),  # 结尾
        '4_14': ('XX XX', 84),  # 结尾
        '4_19': ('XXX X', 86),  # 结尾
 
        '3_0': ('  XXX  ', 60),
        '3_1': ('  XXXO', 25),
        '3_2': ('OXXX  ', 25),
        '3_3': (' XXX  ', 30),
        '3_4': ('  XXX ', 30),
        '3_5': (' X XX ', 37),
        '3_6': (' XX X ', 37),
        '3_7': (' X X X ', 27),
        '3_8': ('OXX X ', 21),
        '3_9': (' X XXO', 21),
        '3_14': ('OX XX ', 23),
        '3_15': (' XX XO', 23),
        '3_12': ('  XXX', 25),  # 结尾
        '3_13': (' X XX', 21),  # 结尾
        '3_17': (' XX X', 23),  # 结尾
 
        '2_0': ('   XX   ', 8),
        '2_1': ('   XXO', 2),
        '2_2': ('OXX   ', 2),
        '2_3': ('  XX   ', 5),
        '2_4': (' XX   ', 4),
        '2_5': (' X X ', 4),
        '2_7': ('   XX', 2),  # 结尾
    }
]
value_model_O = [
    # 开头检测
    {
        '4_11': ('OOOO ', 100),  # 开头
        '4_13': ('OO OO ', 84),  # 开头
        '4_15': ('OOO O', 82),  # 开头
        '4_18': ('O OOO', 86),  # 开头
        '3_10': ('OOO  ', 25),  # 开头
        '3_11': ('OO O ', 21),  # 开头
        '3_16': ('O OO ', 23),  # 开头
        '2_6': ('OO   ', 2),  # 开头
 
        '5': ('OOOOO', 1000),
 
        '4_0': (' OOOO ', 400),
        '4_1': (' OOOOX', 100),
        '4_2': ('XOOOO ', 100),
        '4_3': ('O OOO  ', 120),
        '4_4': ('   OO OO   ', 110),
        '4_5': ('  OOO O', 120),
        '4_6': ('O OOOX', 82),
        '4_7': ('OO OOX', 84),
        '4_8': ('XOO OO', 84),
        '4_9': ('XOOO O', 84),
        '4_16': ('XO OOO', 86),
        '4_17': ('OOO OX', 86),
 
        '3_0': ('  OOO  ', 60),
        '3_1': ('  OOOX', 25),
        '3_2': ('XOOO  ', 25),
        '3_3': (' OOO  ', 30),
        '3_4': ('  OOO ', 30),
        '3_5': (' O OO ', 37),
        '3_6': (' OO O ', 37),
        '3_7': (' O O O ', 27),
        '3_8': ('XOO O ', 21),
        '3_9': (' O OOX', 21),
        '3_14': ('XO OO ', 23),
        '3_15': (' OO OX', 23),
 
        '2_0': ('   OO   ', 8),
        '2_1': ('   OOX', 2),
        '2_2': ('XOO   ', 2),
        '2_3': ('  OO   ', 5),
        '2_4': (' OO   ', 4),
        '2_5': (' O O ', 4)
    },
    # 中间检测
    {
        '5': ('OOOOO', 1000),
 
        '4_0': (' OOOO ', 400),
        '4_1': (' OOOOX', 100),
        '4_2': ('XOOOO ', 100),
        '4_3': ('O OOO  ', 120),
        '4_4': ('   OO OO   ', 110),
        '4_5': ('  OOO O', 120),
        '4_6': ('O OOOX', 82),
        '4_7': ('OO OOX', 84),
        '4_8': ('XOO OO', 84),
        '4_9': ('XOOO O', 84),
        '4_16': ('XO OOO', 86),
        '4_17': ('OOO OX', 86),
 
        '3_0': ('  OOO  ', 60),
        '3_1': ('  OOOX', 25),
        '3_2': ('XOOO  ', 25),
        '3_3': (' OOO  ', 30),
        '3_4': ('  OOO ', 30),
        '3_5': (' O OO ', 37),
        '3_6': (' OO O ', 37),
        '3_7': (' O O O ', 27),
        '3_8': ('XOO O ', 21),
        '3_9': (' O OOX', 21),
        '3_14': ('XO OO ', 23),
        '3_15': (' OO OX', 23),
 
        '2_0': ('   OO   ', 8),
        '2_1': ('   OOX', 2),
        '2_2': ('XOO   ', 2),
        '2_3': ('  OO   ', 5),
        '2_4': (' OO   ', 4),
        '2_5': (' O O ', 4)
    },
    # 结尾检测
    {
        '4_10': (' OOOO', 100),  # 结尾
        '4_12': ('O OOO', 82),  # 结尾
        '4_14': ('OO OO', 84),  # 结尾
        '4_19': ('OOO O', 86),  # 结尾
        '3_12': ('  OOO', 25),  # 结尾
        '3_13': (' O OO', 21),  # 结尾
        '3_17': (' OO O', 23),  # 结尾
        '2_7': ('   OO', 2),  # 结尾
 
        '5': ('OOOOO', 1000),
 
        '4_0': (' OOOO ', 400),
        '4_1': (' OOOOX', 100),
        '4_2': ('XOOOO ', 100),
        '4_3': ('O OOO  ', 120),
        '4_4': ('   OO OO   ', 110),
        '4_5': ('  OOO O', 120),
        '4_6': ('O OOOX', 82),
        '4_7': ('OO OOX', 84),
        '4_8': ('XOO OO', 84),
        '4_9': ('XOOO O', 84),
        '4_16': ('XO OOO', 86),
        '4_17': ('OOO OX', 86),
 
        '3_0': ('  OOO  ', 60),
        '3_1': ('  OOOX', 25),
        '3_2': ('XOOO  ', 25),
        '3_3': (' OOO  ', 30),
        '3_4': ('  OOO ', 30),
        '3_5': (' O OO ', 37),
        '3_6': (' OO O ', 37),
        '3_7': (' O O O ', 27),
        '3_8': ('XOO O ', 21),
        '3_9': (' O OOX', 21),
        '3_14': ('XO OO ', 23),
        '3_15': (' OO OX', 23),
 
        '2_0': ('   OO   ', 8),
        '2_1': ('   OOX', 2),
        '2_2': ('XOO   ', 2),
        '2_3': ('  OO   ', 5),
        '2_4': (' OO   ', 4),
        '2_5': (' O O ', 4)
    }
]
 
if __name__ == '__main__':
    test_list = list(set([_i[1] for _ in value_model_X for _i in _.items()]))
    print(test_list)
    print(len(test_list))

12、游戏基础框架

import pygame as pg
if __name__ == '__main__':
    # 模块初始化
    pg.init()
    # 基础设置：游戏窗口，帧率
    WIDTH = 615
    HEIGHT = 615
    # 时钟帧率
    clock = pg.time.Clock()
    # 游戏窗口
    screen = pg.display.set_mode((WIDTH, HEIGHT))
    # 导入素材
    black = pg.image.load("data/chess_black.png").convert_alpha()
    white = pg.image.load("data/chess_white.png").convert_alpha()
    background = pg.image.load("data/qp.png").convert_alpha()
    # 新创建的元素，全都放到这个列表里
    objects = []
    # 设置窗口标题
    pg.display.set_caption("五子棋")
    # 游戏主循环
    going = True
    while going:
        # 把背景图“打印”到窗口上
        screen.blit(background, (0, 0))
        # 根据玩家操作，执行对应指令
        for event in pg.event.get():
            # 如果关闭窗口，则主循环结束
            if event.type == pg.QUIT:
                going = False
            # 如果点击键盘esc键，则主循环结束
            elif event.type == pg.KEYDOWN and event.key == pg.K_ESCAPE:
                going = False
            # 如果点击鼠标，则执行某个操作
            elif event.type == pg.MOUSEBUTTONDOWN:
                # 获取鼠标点击位置的坐标
                pos = pg.mouse.get_pos()
                print(pos)
                objects.append([black,(pos[0]-18,pos[1]-18)])
        # 把objects列表里的所有对象都打印到窗口
        for o in objects:
            screen.blit(o[0], o[1])
        # 帧率设置为每秒60帧
        clock.tick(60)
        # 对游戏窗口进行刷新操作（如果不update，窗口是黑的）
        pg.display.update()
    # 如果循环结束，则关闭进程
    pg.quit()

五、系统演示操作视频

六、团队成员负责模块