【创新】教你用python做五子棋AI（含代码）

已于 2024-07-13 08:54:35 修改
阅读量1.2k 收藏 19
点赞数 9
分类专栏： 五子棋AI 文章标签： python ai
于 2024-07-11 17:10:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_86187906/article/details/140356805
版权

【创新】教你用python做五子棋AI（含代码）

老样子先讲思路：

观点由作者老程想出，只供参考

  1. FiveChessGame 类的初始化：

  • 创建主窗口，设置标题和背景颜色。

  • 创建画布并绑定鼠标点击事件。

  1. draw_board 方法：
  • 在画布上绘制棋盘的横竖线条。
  1. place_piece 方法：

  • 根据鼠标点击位置确定棋子放置的行列。

  • 如果位置为空，放置棋子并更新棋盘状态。

  • 检查是否获胜或平局，如果是则显示相应的消息框并更新游戏状态。

  • 切换当前玩家，如果是 AI 回合则调用 ai_move 方法。

  1. draw_piece 方法：
  • 在指定位置绘制棋子。
  1. check_win 方法：
  • 遍历整个棋盘，对于每个非空棋子，调用 check_win_at_pos 方法检查是否获胜。
  1. check_win_at_pos 方法：
  • 针对特定位置和棋子类型，在四个方向上检查是否形成五子连珠。
  1. is_draw 方法：
  • 检查棋盘是否已满，以判断是否平局。
  1. ai_move 方法：

  • 进行一定深度的搜索，计算每个可能落子位置的得分。

  • 选择得分最高的位置放置 AI 的棋子。

  • 检查放置后是否获胜或平局，并更新游戏状态和显示相应消息框。

  1. minimax 方法：
  • 实现了极小极大算法，根据当前深度、搜索范围和玩家角色（最大化或最小化）进行递归搜索，计算局面得分。
  1. evaluate_position 方法：
  • 评估当前棋盘局面的得分，考虑棋子的布局情况，如活三、活四等。
  1. check_open_three 和 check_open_four 方法：
  • 分别检查是否存在活三或活四的情况。
  1. handle_click 方法：
  • 处理鼠标点击事件，调用 place_piece 方法放置玩家的棋子。
  1. run 方法：
  • 绘制棋盘并启动主事件循环。

总体思路是通过各种方法实现五子棋的游戏逻辑，包括玩家和 AI 的落子、胜负判断、局面评估等，以实现一个可交互的五子棋游戏，并且 AI 具有一定的智能水平。

理论已明确，以下是实践：

首先是导入模块

import tkinter as tk
from tkinter import messagebox

剩下是修改原五子棋的代码，添加了AI，增强了算法能力。

BOARD_SIZE = 20  
GRID_SIZE = 30  
WHITE = "white"
BLACK = "black"
YELLOW = "yellow"  
PLAYER1_COLOR = BLACK
PLAYER2_COLOR = WHITE
GAME_CONTINUE = 0
PLAYER1_WIN = 1
PLAYER2_WIN = 2
DRAW = 3

class FiveChessGame:
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("五子棋游戏")
        self.root.configure(bg=YELLOW)  

        self.canvas = tk.Canvas(self.root, width=BOARD_SIZE * GRID_SIZE, height=BOARD_SIZE * GRID_SIZE)
        self.canvas.pack()

        self.board = [[0 for _ in range(BOARD_SIZE)] for _ in range(BOARD_SIZE)]
        self.current_player = PLAYER1_COLOR
        self.game_state = GAME_CONTINUE

        self.canvas.bind("<Button-1>", self.handle_click)

    def draw_board(self):
        for i in range(BOARD_SIZE):
            self.canvas.create_line(0, i * GRID_SIZE, BOARD_SIZE * GRID_SIZE, i * GRID_SIZE)
            self.canvas.create_line(i * GRID_SIZE, 0, i * GRID_SIZE, BOARD_SIZE * GRID_SIZE)

    def place_piece(self, x, y):
        row = y // GRID_SIZE
        col = x // GRID_SIZE
        if self.board[row][col] == 0:
            self.board[row][col] = 1 if self.current_player == PLAYER1_COLOR else 2
            self.draw_piece(col * GRID_SIZE, row * GRID_SIZE)
            if self.check_win():  # 不再传递 row 和 col
                if self.current_player == PLAYER1_COLOR:
                    self.game_state = PLAYER1_WIN
                    messagebox.showinfo("游戏结果", "玩家胜利！")
                else:
                    self.game_state = PLAYER2_WIN
                    messagebox.showinfo("游戏结果", "AI 胜利！")
            elif self.is_draw():
                self.game_state = DRAW
                messagebox.showinfo("游戏结果", "平局！")
            else:
                self.current_player = PLAYER2_COLOR if self.current_player == PLAYER1_COLOR else PLAYER1_COLOR
                if self.current_player == PLAYER2_COLOR:  
                    self.ai_move()

    def draw_piece(self, x, y):
        color = self.current_player
        self.canvas.create_oval(x + 5, y + 5, x + GRID_SIZE - 5, y + GRID_SIZE - 5, fill=color)

    def check_win(self):  # 修改为不需要 row 和 col 参数
        for row in range(BOARD_SIZE):
            for col in range(BOARD_SIZE):
                if self.board[row][col]!= 0 and self.check_win_at_pos(row, col):  # 调用新的辅助方法
                    return True
        return False

    def check_win_at_pos(self, row, col):  # 新的辅助方法来检查特定位置是否导致获胜
        directions = [(1, 0), (0, 1), (1, 1), (1, -1)]
        piece_type = self.board[row][col]

        for dr, dc in directions:
            count = 1
            r, c = row + dr, col + dc
            while 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE and self.board[r][c] == piece_type:
                count += 1
                r += dr
                c += dc
            r, c = row - dr, col - dc
            while 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE and self.board[r][c] == piece_type:
                count += 1
                r -= dr
                c -= dc
            if count >= 5:
                return True
        return False

    def is_draw(self):
        for row in self.board:
            for col in row:
                if col == 0:
                    return False
        return True

    def ai_move(self):
        max_depth = 2  # 增加搜索深度，可根据性能和需求调整
        best_score = float('-inf')
        best_move = None

        for row in range(BOARD_SIZE):
            for col in range(BOARD_SIZE):
                if self.board[row][col] == 0:
                    self.board[row][col] = 2
                    score = self.minimax(max_depth, float('-inf'), float('inf'), False)
                    self.board[row][col] = 0

                    if score > best_score:
                        best_score = score
                        best_move = (col, row)

        if best_move:
            col, row = best_move
            self.board[row][col] = 2
            self.draw_piece(col * GRID_SIZE, row * GRID_SIZE)
            if self.check_win():  # 不再传递 row 和 col
                self.game_state = PLAYER2_WIN
                messagebox.showinfo("游戏结果", "AI 胜利！")
            elif self.is_draw():
                self.game_state = DRAW
                messagebox.showinfo("游戏结果", "平局！")
            else:
                self.current_player = PLAYER1_COLOR

    def minimax(self, depth, alpha, beta, is_maximizing_player):
        if depth == 0 or self.check_win():  # 不再传递 row 和 col
            return self.evaluate_position()

        if is_maximizing_player:
            max_eval = float('-inf')
            for row in range(BOARD_SIZE):
                for col in range(BOARD_SIZE):
                    if self.board[row][col] == 0:
                        self.board[row][col] = 2
                        eval_score = self.minimax(depth - 1, alpha, beta, False)
                        self.board[row][col] = 0
                        max_eval = max(max_eval, eval_score)
                        alpha = max(alpha, eval_score)
                        if beta <= alpha:
                            break
            return max_eval
        else:
            min_eval = float('inf')
            for row in range(BOARD_SIZE):
                for col in range(BOARD_SIZE):
                    if self.board[row][col] == 0:
                        self.board[row][col] = 1
                        eval_score = self.minimax(depth - 1, alpha, beta, True)
                        self.board[row][col] = 0
                        min_eval = min(min_eval, eval_score)
                        beta = min(beta, eval_score)
                        if beta <= alpha:
                            break
            return min_eval

    def evaluate_position(self):
        score = 0

        # 考虑更多的布局因素，如活三、活四等
        for row in range(BOARD_SIZE):
            for col in range(BOARD_SIZE):
                if self.board[row][col] == 2:  
                    for dr, dc in [(1, 0), (0, 1), (1, 1), (1, -1)]:
                        count = 1
                        r, c = row + dr, col + dc
                        while 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE and self.board[r][c] == 2:
                            count += 1
                            r += dr
                            c += dc
                        r, c = row - dr, col - dc
                        while 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE and self.board[r][c] == 2:
                            count += 1
                            r -= dr
                            c -= dc

                        if count == 2:
                            score += 20
                        elif count == 3:
                            score += 100
                        elif count == 4:
                            score += 1000
                        elif count == 3 and self.check_open_three(row, col, dr, dc):  # 活三
                            score += 500
                        elif count == 4 and self.check_open_four(row, col, dr, dc):  # 活四
                            score += 2000

        return score

    def check_open_three(self, row, col, dr, dc):
        count = 1
        r, c = row + dr, col + dc
        blocked = False
        while 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE:
            if self.board[r][c] == 0:
                break
            elif self.board[r][c] == 2:
                count += 1
                r += dr
                c += dc
            else:
                blocked = True
                break
        r, c = row - dr, col - dc
        while 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE:
            if self.board[r][c] == 0:
                break
            elif self.board[r][c] == 2:
                count += 1
                r -= dr
                c -= dc
            else:
                blocked = True
                break
        return count == 3 and not blocked

    def check_open_four(self, row, col, dr, dc):
        count = 1
        r, c = row + dr, col + dc
        blocked = False
        while 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE:
            if self.board[r][c] == 0:
                break
            elif self.board[r][c] == 2:
                count += 1
                r += dr
                c += dc
            else:
                blocked = True
                break
        r, c = row - dr, col - dc
        while 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE:
            if self.board[r][c] == 0:
                break
            elif self.board[r][c] == 2:
                count += 1
                r -= dr
                c -= dc
            else:
                blocked = True
                break
        return count == 4 and not blocked

    def handle_click(self, event):
        x = event.x
        y = event.y
        self.place_piece(x, y)

    def run(self):
        self.draw_board()
        self.root.mainloop()

if __name__ == "__main__":
    game = FiveChessGame()
    game.run()

以上是原代码，运行可能有点慢，这十分考验了高配置的电脑，低配置的需要等待一段时间初始化。

最后，请大家多多支持老程，老程花了两天时间研究，之后老程后更新更多的作品。

只会编程的老程
关注
专栏目录
python大作业 五子棋 ai
12-17
python编写的五子棋人机对战。由电脑判断怎么样落子，别小瞧AI的小聪明哦。这是某学校的python课程大作业，需要用到graphics.py库（这里免积分下载：http://download.csdn.net/detail/w1135181854u/6730647），把graphics.py 放进python安装文件夹的lib文件夹里就好了。
python五子棋人机对战代码，复制即用！
02-19
在本资源中，我们将探讨如何使用Python编程语言实现一个简单的五子棋人机对战游戏。该项目不仅能够帮助初学者理解基本的游戏开发流程，还能够提供一个平台，让玩家练习并提升自己的五子棋策略。 首先，我们会介绍游戏的基本规则以及所需的界面设计。 其次，我们将深入讲解后端逻辑的实现。这包括棋盘数据结构的设计、移动合法性的验证、胜负判定算法以及AI的决策过程。对于AI部分，我们将实现一个简单的启发式搜索算法，如Minimax算法结合Alpha-Beta剪枝，以提供一定程度的挑战性。 此外，我们还会讨论如何将前端界面和后端逻辑相结合，确保游戏能够顺畅运行。玩家可以通过图形界面进行操作，而AI则通过算法自动做出回应。 最后，我们将提供完整的代码示例，供读者参考和学习。这份资源适合对Python编程感兴趣的读者，特别是那些希望了解游戏开发和人工智能基础的学习者。通过本项目的实践，读者将能够掌握游戏设计的核心概念，并对策略型人工智能有一个初步的理解。
[Python/Tkinter]用Tkinter编写一个五子棋程序（附源代码和图片文件）
最新发布
2301_81965378的博客
09-21 766
先简单说明一下这个界面是怎样建构的再讲逻辑哦~棋盘和背景都是图片，使用导入，然后用画布控件的把图片放上去棋子是用画布的方法画出来的好了那么逻辑如何编写呢？这些都完成后在补充一些诸如步时局时的细节就完成了。
AI智能五子棋Python代码
08-01
这个代码是智能五子棋代码，使用python实现，可视化界面，有基于规则的算法和基于神经网络的算法，可以实现一定水准的五子棋棋力。
五子棋AI python实现
05-03
使用python写的基于两层博弈树的五子棋AI。加入了阿尔法贝塔剪枝。 python版本：3+，应该可以在命令行里直接跑。 电脑执黑，玩家执白。无禁手。 因为只有两层博弈树，请大家不要嫌他菜哈哈哈，仅供大家学习参考。 由于写得比较匆忙，代码写的十分丑陋，望海涵！
python五子棋AI代码
12-10
使用python pygame编写的五子棋AI 程序代码，AI使用极大极小值搜索和alpha beta剪枝，启发式评估等方法增加了搜索深度。
python实现AI五子棋
04-14
这是我写的一个基于神经网络的五子棋程序，用python3写的，需要配置tensorflow才能使用
让电脑变得更聪明——用python实现五子棋游戏
weixin_55939638的博客
09-23 1万+
让电脑变得更聪明——用python实现五子棋游戏
qpython3h教程_Python3实现AI五子棋【初版】|python3教程|python入门|python教程
weixin_39665060的博客
11-24 531
https://www.xin3721.com/eschool/pythonxin3721/本文转载至知乎ID：Charles（白露未晞）知乎个人专栏下载W3Cschool手机App，0基础随时随地学编程>>戳此了解导语闲来无事写了个比较愚蠢的AI五子棋。T_T当然你好好和它下，它还是比较机智的。让我们愉快地开始吧~~~相关文件网盘下载链接: https://pan.baidu.com/s/1DV...
python实现五子棋游戏程序
03-21
是上Python课程的期末大作业，设计五子棋游戏程序，界面都有
基于python的AI五子棋实现（极大极小值搜索和alpha beta剪枝）
05-27
基于python的AI五子棋实现（极大极小值搜索和alpha beta剪枝的实现与应用） 算法采用极大极小剪枝博弈算法。 运行环境：python3.6.5
pythonAI五子棋_python教程_五子棋_
09-30
五子棋是全国智力运动会竞技项目之一，是一种两人对弈的纯策略型棋类游戏。五子棋有两种玩法。玩法一：双方分别使用黑白两色的棋子，下在棋盘直线与横线的交叉点上，先形成五子连线者获胜。玩法二：自己形成五子连线就替换对方任意一枚棋子。被替换的棋子可以和对方交换棋子。最后以先出完所有棋子的一方为胜。五子棋的棋具与围棋通用，是一种传统的棋种。
python实现五子棋（pygame模块）
08-20
用python做的一个五子棋小游戏，画面精良，主题风格是欧洲大理石风格。代码简单，有一定基础的就都能够看懂，里面有非常多的注释
使用python实现简单五子棋游戏
09-19
主要为大家详细介绍了使用python实现简单五子棋游戏，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Python五子棋小游戏源代码，支持人机对战和局域网对战两模式
03-31
在人机对战模式中，程序需要实现一个AI（人工智能）对手。这通常涉及到搜索算法，如Minimax算法或Alpha-Beta剪枝。这些算法用于模拟对手的思考过程，寻找最佳落子位置。在五子棋中，由于游戏相对简单，可能采用更...
python-五子棋-AI
SCDS_Zyx的博客
01-31 4749
降智警告：本人为编程新手，遵守面向CSDN编程原则，代码架构具有个人特色，仅供参考   前言：课程期末项目写了个黑白棋，所以放假写个五子棋，作为今年的总结 （该五子棋仅涉及最基础的规则，轮留下，连五赢）   一.最终效果 功能：规定玩家先下，结束时展示结果。restart按钮会变色，鼠标在按钮上时颜色变深。按下restart按钮可以重新开局。   二.AI实现 1.思路 ①...
Python 五子棋AI实现(1):界面实现
热门推荐
marble_xu的博客
05-20 4万+
@[TOC](python 五子棋AI实现(1):界面和评估函数实现)
python制作五子棋_python制作简单五子棋游戏
weixin_39691233的博客
11-21 473
本文实例为大家分享了python五子棋游戏的具体代码，供大家参考，具体内容如下#五子棋‘''矩阵做棋盘 16*16 “+”打印棋盘 for for游戏是否结束开始下棋 while 游戏是否结束：黑白交替 player=0 p%2==0 ==1 p+=1下棋动作一样 但是棋子不一样‘''代码#创建棋盘的程序def initBoard():global board #调用全局的boardboard=[...
python 五子棋
08-13
你好！如果你想开发一个Python五子棋人机对战的程序，我可以给你一些指导。首先，你需要一个棋盘数据结构来存储棋局状态。你可以使用二维列表或者NumPy数组来表示棋盘。 接下来，你需要实现一个函数来判断游戏是否结束，即是否有玩家获胜或者棋盘已满。可以编写一个函数来检查每个位置的周围是否有五个相同颜色的棋子。 然后，你需要实现一个AI算法来计算电脑的下一步落子位置。常见的算法包括极大极小搜索和Alpha-Beta剪枝。你可以使用递归来实现这些算法，对每个可能的落子位置进行搜索，并评估每个位置的得分。 最后，你需要编写一个游戏循环，在每个回合中交替玩家和电脑进行落子，并根据游戏结束与否决定胜负。 这只是一个简单的指导，具体实现还需要考虑很多细节。希望对你有所帮助！如果你有更具体的问题，可以继续问我。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值