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

最新推荐文章于 2024-07-12 13:45:39 发布
最新推荐文章于 2024-07-12 13:45:39 发布
阅读量501 收藏 8
点赞数 5
文章标签： 人工智能 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_86187906/article/details/140357368
版权

【创新】教你用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()

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

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

只会编程的老程
关注
  • 5
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
python五子棋代码
吃不胖.
07-22 1087
【代码】python五子棋代码。
编写五子棋的完整python代码_python实现五子棋程序
weixin_39804620的博客
11-20 2567
五子棋游戏相信大部分人都玩过，今天我们用python来实现一次具体代码可以访问我的GitHub地址获取构建五子棋棋盘from collections import namedtupleChessman = namedtuple('Chessman', 'Name Value Color')Point = namedtuple('Point', 'X Y')BLACK_CHESSMAN = Ches...
基于Python的博弈树搜索人机交互五子棋人工智能实验
毕业作品网站
02-01 1808
需要注意的是，根节点没有父节点，故父节点的α和β值分别设置为负无穷和正无穷。叶子节点不需要向下拓展，而是直接进行打分。打分同时作为该叶子节点的。值即可将叶子节点也视作中间节点，方便统一处理。人工智能实验博弈树搜索 1。人工智能实验博弈树搜索。
python五子棋代码最简单的,python五子棋代码不用库
2401_85415578的博客
06-13 792
circle(screen, player_color[turn - 1], pos, radius) # 画圆。return (map_x, map_y, square_size, square_size) # 返回位置信息。def getIndex(self, map_x, map_y): # 输入具体位置，返回下标。def isInside(self, map_x, map_y): # 是否在有效范围内。def click(self, x, y, type): # 点击的下棋动作。
让电脑变得更聪明——用python实现五子棋游戏
weixin_55939638的博客
09-23 9430
让电脑变得更聪明——用python实现五子棋游戏
编写五子棋的完整python代码控制台版ai_python实现的控制台五子棋
weixin_39627390的博客
12-06 316
1.[代码][Python]代码import osimport pdb'''@author 阿肥(是我的猫)@date 2014年6月16日@title 双人五子棋@modified2014年6月16日 最初版本'''class five:def __init__(self,maxx,maxy):self.maxx=maxxself.maxy=maxyself.qipan=[]for i in r...
用python做五子棋入门教学（含源代码）
2401_86187906的博客
07-11 611
用python做五子棋
Python五子棋小游戏源代码，支持人机对战和局域网对战两模式
Python代码大全
03-31 7543
Python五子棋小游戏源代码，支持人机对战和局域网对战两模式
python五子棋代码最简单的,python五子棋代码能复制
wenangou6
02-18 1097
计算方法实际上是一样的，只是方向不同，所以定义一个偏移量数组，不同的偏移量表示不同的方向，这样就可以利用循环来实现了，节省了很多代码。这样不太严谨，写出来的电脑估计水平很菜，但是这个思路却是对的，落子就是要找到最值得的地方，那么我们干脆对每一个可落子的地方来做一个评估，选出最优解。五子棋执黑是必赢的，代码中，玩家就是执黑先手，电脑执白后手，所以，下的好是完全可以赢电脑的，不过一个小小失误也很可能被电脑翻盘。这里我们需要了解一下五子棋的几种基本棋形：连五，活四，冲四，活三，眠三，活二，眠二。
python五子棋AI代码
12-10
Python五子棋AI代码是基于Python编程语言和Pygame库实现的一个有趣且具有挑战性的项目。Pygame是一个Python模块，专为开发2D游戏而设计，包含了一系列用于处理图形、声音和其他媒体的工具。在这个五子棋AI程序中，...
pythonAI五子棋_python教程_五子棋_
09-30
五子棋是全国智力运动会竞技项目之一，是一种两人对弈的纯策略型棋类游戏。五子棋有两种玩法。玩法一：双方分别使用黑白两色的棋子，下在棋盘直线与横线的交叉点上，先形成五子连线者获胜。玩法二：自己形成五子连线...
AI智能五子棋Python代码
08-01
在本项目中，我们探索的是一个使用Python编程语言实现的AI智能五子棋游戏。五子棋是一种简单但策略丰富的双人对弈游戏，而这里的实现不仅提供了可视化的游戏界面，还结合了两种不同的AI算法：基于规则的算法和基于...
python五子棋人机对战代码，复制即用！
02-19
在本资源中，我们将探讨如何使用Python编程语言实现一个简单的五子棋人机对战游戏。该项目不仅能够帮助初学者理解基本的游戏开发流程，还能够提供一个平台，让玩家练习并提升自己的五子棋策略。 首先，我们会介绍...
AGI 之 【Hugging Face】 的【问答系统】的 [构建问答系统] / [ 构建基于评论的问答系统 ] 的简单整理
仙魁XAN
07-12 702
AGI，即通用人工智能（Artificial General Intelligence），是一种具备人类智能水平的人工智能系统。它不仅能够执行特定的任务，而且能够理解、学习和应用知识于广泛的问题解决中，具有较高的自主性和适应性。AGI的能力包括但不限于自我学习、自我改进、自我调整，并能在没有人为干预的情况下解决各种复杂问题。AGI能做的事情非常广泛：跨领域任务执行：AGI能够处理多领域的任务，不受限于特定应用场景。自主学习与适应：AGI能够从经验中学习，并适应新环境和新情境。
线性代数|机器学习-P22逐步最小化一个函数
scar2016的博客
07-10 876
主要讲的是无约束情况下的最小值问题。矩阵求导泰勒公式，函数到向量的转换梯度下降牛顿法梯度下降。
聊聊如何在内网下构建大模型微调环境
最新发布
python1234567_的博客
07-12 686
LlamaFactory新版更新后，还是比较方便，只是说llamafactory-cli命令的确是有点蒙，踩个坑就好了。对于LlamaFactory微调来说，本身不难，毕竟都是配置；主要是在内网环境下的依赖包拉取安装是真麻烦，但其实也还好。走一遍的话，还是可以学到很多的。​。
YOLOv10改进 | 特殊场景检测篇 | 轻量级的低照度图像增强网络IAT改进YOLOv10暗光检测（全网独家首发）
热门推荐
Snu77的博客
07-11 1万+
本文给大家带来的改进机制是轻量级的变换器模型：Illumination Adaptive Transformer (IAT)，用于图像增强和曝光校正。其基本原理是通过分解图像信号处理器（ISP）管道到局部和全局图像组件，从而恢复在低光或过/欠曝光条件下的正常光照sRGB图像。具体来说，IAT使用注意力查询来表示和调整ISP相关参数，例如颜色校正、伽马校正。模型具有约90k参数和约0.004s的处理速度，能够在低光增强和曝光校正的基准数据集上持续实现优于最新技术（State-of-The-Art, SOTA）
python做五子棋ai
07-20
Python可以用来制作一个五子棋AI。首先，我们可以使用Python中的一些机器学习库，例如TensorFlow或PyTorch，来构建一个深度学习模型。该模型将通过学习已经进行过的五子棋对局来预测下一步最佳的落子位置。 在训练模型之前，我们需要准备一些训练数据。我们可以通过自动播放大量的五子棋对局来生成这些数据。然后，我们可以将这些对局中的每个落子情况作为输入，对应的最佳落子位置作为输出进行训练。 训练完成后，我们就可以使用这个模型来作为AI的基础。当用户与AI进行对战时，AI可以根据当前的棋盘状态，通过调用训练好的模型来预测最佳的下一步落子位置。 除了机器学习方法外，我们还可以使用一些其他的算法来实现五子棋AI。例如，我们可以使用蒙特卡洛树搜索（Monte Carlo Tree Search）算法来评估每个落子位置的价值，并选择最好的一步。这个算法可以通过Python中的树结构和递归算法来实现。 总之，Python提供了丰富的机器学习库和算法来实现五子棋AI。我们可以根据自己的需求选择适合的方法来构建一个强大的AI，并通过与用户对战来测试和改进它。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值