智能机器人游戏——五子棋AI算法大比拼！

最新推荐文章于 2023-01-07 17:22:21 发布
最新推荐文章于 2023-01-07 17:22:21 发布
阅读量342 收藏
点赞数
文章标签： java c/c++ c#
原文链接：http://www.cnblogs.com/Zimmem/archive/2008/05/21/1204011.html
版权

规则：
     1.棋局类是一个单例，可以通过 Chessboard.GetInstance()棋局类的单例对象。
     2.棋局会随机为两个玩家设置白棋或黑棋，白棋先手。
     3.每局每个玩家可以使用时间为10分钟，超时算负。
     4.如果玩家返回的坐标为非法，如该坐标已有棋子或超出棋局范围，系统将自动重新调用该玩家play()函数。
     5.玩家只要继承player类，并重写play函数，返回放置棋子的坐标。
     6.可通过GetMyChessStyle（）方法获取自子的棋子是白或黑。
     7.通过棋局类方法start()设置棋盘大小并开始比赛。
     8.可能过棋局类单例对象的getCurrentChessBoard()方法获取当前棋盘的一个拷贝以了解战况，可通过棋局类单例对象的GetSize()方法获取棋盘的大小。
     9.通过在main()函数中调用棋局类单例对象的SetPlayer方法设置比赛的AI，设用start方法开始比赛。
       main()函数示例：

  public   static   void  Main()
         {
            Chessboard cb = Chessboard.GetInstance();
            cb.SetPlayer(new Creazer (), new Zimmem_1());
            cb.start(15);
        }


示例1：
一个只会随机乱下的疯子：

class  Creazer:Player 
     {
        public override  Position play()
        {
            /**//*获取棋局对象*/
            Chessboard cb=Chessboard.GetInstance();
            /**//*随机数生成器*/
            Random ra = new Random();
            /**//*随机生成一个坐标*/
            Position pos = new Position();
            pos.x = ra.Next(cb.GetSize());
            pos.y = ra.Next(cb.GetSize());
            return pos;
        }   
    }
示例2:
可以让用户自已输入：
class  UserPlayer : Player
     {
        public override Position play()
        {
            /**//*获取棋局对象*/
            Chessboard cb = Chessboard.GetInstance();
            /**//*获取当前棋盘*/
            Chessboard.ChessState[,] chessboard = cb.getCurrentChessBoard();
            /**//*输出棋盘以让用户了解战况*/
            for (long i = 0; i < cb.GetSize(); i++)
            {
                for (long j = 0; j < cb.GetSize(); j++)
                {
                    Console.Write(chessboard[i, j].GetHashCode());
                }
                Console.WriteLine();
            }
            /**//*玩家输入坐标*/
            Position pos = new Position();
            pos.x = int.Parse(Console.ReadLine());
            pos.y = int.Parse(Console.ReadLine());


            return pos;
        }
    }

示例3：
我写的一个只会进攻，不会防守的算法，有点长.....
Code
class Zimmem_1 : Player
    {


        public override Position play()
        {
            Chessboard cb = Chessboard.GetInstance();
            Chessboard.ChessState[,] chessBoard = cb.getCurrentChessBoard();
            int BoardSize = cb.GetSize();
            int[,] Weight = new int[BoardSize, BoardSize];
            
          
            int temp;
          
            int i,j,k;
            #region  计算橫向权值
            for (i = 0; i < BoardSize; i++)
            {
                for (j = 0; j < BoardSize; j++)
                {
                    temp = 0;
                    if (chessBoard[i, j] != Chessboard.ChessState.Empty)
                    {
                        temp = 0;
                        continue;
                    }
                    /*向左*/
                    for (k = 1; k < 5; k++)
                    {
                        if ( j + k >= BoardSize)
                            break;
                        if (chessBoard[i, j + k] == GetMyChessStyle())
                        {
                            temp += 10;
                        }
                        else if (chessBoard[i, j + k] == Chessboard.ChessState.Empty)
                        {
                            temp += 1;
                            break;
                        }
                        else
                            break;
                    }
                    /*向右*/
                    for (k = 1; k < 5; k++)
                    {
                        if (j - k < 0 )
                            break;
                        if (chessBoard[i, j - k] == GetMyChessStyle())
                        {
                            temp += 10;
                        }
                        else if (chessBoard[i, j -k] == Chessboard.ChessState.Empty)
                        {
                            temp += 1;
                            break;
                        }
                        else
                            break;
                    }
                    if (Weight[i, j] < temp)
                        Weight[i,j] = temp;

                }
            } 
            #endregion
            #region  计算竖向权值
            for (i = 0; i < BoardSize; i++)
            {
                for (j = 0; j < BoardSize; j++)
                {
                    temp = 0;
                    if (chessBoard[i, j] != Chessboard.ChessState.Empty)
                    {
                        temp = 0;
                        continue;
                    }
                    /*向下*/
                    for (k = 1; k < 5; k++)
                    {
                        if ( i + k >= BoardSize)
                            break;
                        if (chessBoard[i+k, j ] == GetMyChessStyle())
                        {
                            temp += 10;
                        }
                        else if (chessBoard[i+k, j ] == Chessboard.ChessState.Empty)
                        {
                            temp += 1;
                            break;
                        }
                        else
                            break;
                    }
                    /*向上*/
                    for (k =1; k < 5; k++)
                    {
                        if (i - k < 0)
                            break;
                        if (chessBoard[i- k, j ] == GetMyChessStyle())
                        {
                            temp += 10;
                        }
                        else if (chessBoard[i- k, j ] == Chessboard.ChessState.Empty)
                        {
                            temp += 1;
                            break;
                        }
                        else
                            break;
                    }
                    if (Weight[i, j] < temp)
                        Weight[i,j] = temp;

                }
            }
            #endregion
            #region  计算斜45度权值
            for (i = 0; i < BoardSize; i++)
            {
                for (j = 0; j < BoardSize; j++)
                {
                    temp = 0;
                    if (chessBoard[i, j] != Chessboard.ChessState.Empty)
                    {
                        temp = 0;
                        continue;
                    }
                    /*向左下*/
                    for (k = 1; k < 5; k++)
                    {
                        if (j - k < 0 || i + k >= BoardSize)
                            break;
                        if (chessBoard[i+k, j - k] == GetMyChessStyle())
                        {
                            temp += 10;
                        }
                        else if (chessBoard[i+k, j - k] == Chessboard.ChessState.Empty)
                        {
                            temp += 1;
                            break;
                        }
                        else
                            break;
                    }
                    /*向右上*/
                    for (k = 1; k < 5; k++)
                    {
                        if (i- k < 0 || j + k >= BoardSize)
                            break;
                        if (chessBoard[i-k, j + k] == GetMyChessStyle())
                        {
                            temp += 10;
                        }
                        else if (chessBoard[i-k, j + k] == Chessboard.ChessState.Empty)
                        {
                            temp += 1;
                            break;
                        }
                        else
                            break;
                    }
                    if (Weight[i, j] < temp)
                        Weight[i,j] = temp;

                }
            }
            #endregion
            #region  计算斜135度权值
            for (i = 0; i < BoardSize; i++)
            {
                for (j = 0; j < BoardSize; j++)
                {
                    temp = 0;
                    if (chessBoard[i, j] != Chessboard.ChessState.Empty)
                    {
                        temp = 0;
                        continue;
                    }
                    /*向左上*/
                    for (k = 1; k < 5; k++)
                    {
                        if (j - k < 0 || i-k<0)
                            break;
                        if (chessBoard[i-k, j - k] == GetMyChessStyle())
                        {
                            temp += 10;
                        }
                        else if (chessBoard[i - k, j - k] == Chessboard.ChessState.Empty)
                        {
                            temp += 1;
                            break;
                        }
                        else
                            break;
                    }
                    /*向右下*/
                    for (k = 1; k < 5; k++)
                    {
                        if (i+ k >= BoardSize || j + k >= BoardSize)
                            break;
                        if (chessBoard[i+k, j + k] == GetMyChessStyle())
                        {
                            temp += 10;
                        }
                        else if (chessBoard[i+k, j + k] == Chessboard.ChessState.Empty)
                        {
                            temp += 1;
                            break;
                        }
                        else
                            break;
                    }
                    if (Weight[i, j] < temp)
                        Weight[i,j]= temp;

                }
            }
            #endregion
            int max = 0;
            IList<Position> weightList = new List<Position>();
            for (i = 0; i < BoardSize; i++)
            {
                for (j = 0; j < BoardSize; j++)
                {
                    if (max < Weight [i, j])
                        max = Weight[i, j];
                }
            }
            for (i = 0; i < BoardSize; i++)
            {
                for (j = 0; j < BoardSize; j++)
                {
                    if (Weight[i, j] == max)
                    {
                        Position pos = new Position();
                        pos.x = i;
                        pos.y = j;
                        weightList.Add(pos);
                    }
                }
            }
            Random ra = new Random();
            return weightList[ra.Next(weightList.Count)];
        }
    }


结果示例：
Gobang.Creazer 先手，使用白棋，标志为1！
Gobang.Zimmem_1使用黑棋，标志为2！
游戏开始！
最终棋局为！
 000000000000000
000000000000000
000000000000000
000000000000000
100000000000000
000000000000000
000000000000000
010000000000000
000000000122222
000000000000000
000000000000000
000100000000000
000000000000000
000000000000000
000010000000000
Gobang.Zimmem_1 胜！
由于时间不多，判胜负的算法没细想，有点垃圾，不过应该没问题，有兴趣的帮忙更进下。现在是用C#写，有兴趣的帮忙翻译成C++或java.

源码下载

转载于:https://www.cnblogs.com/Zimmem/archive/2008/05/21/1204011.html

baode20128
关注
五子棋AI算法
09-27
五子棋AI算法，采用Java实现，支持与电脑对战，自行选择难度和先手。 对应博文： https://blog.csdn.net/feifei316631241/article/details/82874681
五子棋简易AI算法
quarkx的博客
10-11 7245
Java实现简易五子棋人机算法
网络机器人(2)----开发游戏机器人所需要的基本功
大宝(sodme)的专栏
03-02 5282
本文作者：sodme　本文出处：http://blog.csdn.net/sodme版权声明：本文可以不经作者同意任意转载，但转载时烦请保留文章开始前两行的版权、作者及出处信息。　　当大家尝试了若干年由互联网信息资源大爆炸所带来的甜头后，我们开始为寻找有用资源以及有效利用这些庞大的资源而发愁，更多的时候，我们更象一只乱撞的苍蝇在这个URL和那个URL之间奔走，半天的忙碌说不定给我们带来的却是一场空
五子棋AI算法（一）
热门推荐
淡泊明志，宁静致远
10-19 3万+
五子棋AI算法第一章——框架的搭建
机器学习五子棋AI
08-02
机器学习五子棋 AI,构建决策树，代码中有大量数据，用于教会ai决定是及时阻止对方，还是提高自己的连子数。(跑两次不同的决策树)
人工智能大作业基于python实现五子棋游戏源码(含棋子识别+搜索算法+ANN棋局评估+DQN的棋力提升).zip
08-10
人工智能大作业基于python实现五子棋游戏源码(含棋子识别+搜索算法+ANN棋局评估+DQN的棋力提升).zip 1、该资源内项目代码都是经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关...
大一下人工智能程序设计课程大作业——五子棋.zip
03-09
在这个大一下人工智能程序设计课程的大作业中，学生们被要求实现一个五子棋游戏。五子棋，也称为连珠或Gomoku，是一种简单的两人对弈策略游戏，目标是在棋盘上先连成五子（水平、垂直或对角线）的一方获胜。通过这个...
史上最容易理解且强大的人工智能五子棋博弈算法
05-24
在本项目中，"史上最容易理解且强大的人工智能五子棋博弈算法" 提供了一个实现简单且高效的五子棋游戏的人工智能解决方案。该程序可能是用C++或C语言编写，因为标签中包含了这两种编程语言。五子棋是一种两人对弈的...
五子棋AI算法-极大极小值搜索算法代码实现
11-03
在本文中，我们将深入探讨五子棋AI算法的核心——极大极小值搜索（Minimax Search）算法及其优化版本，Alpha Beta剪枝。这个算法在计算机博弈领域有着广泛的应用，尤其适用于像五子棋这样的两人对弈游戏。我们将讨论...
人工智能第二次大作业——αβ剪枝五子棋.zip
最新发布
03-09
本篇将围绕“人工智能第二次大作业——αβ剪枝五子棋”这一主题，深入探讨如何利用AI技术，特别是αβ剪枝算法，来实现一个五子棋游戏的智能对手。 五子棋是一种策略性棋类游戏，对弈双方轮流在棋盘上下棋，先连成...
五子棋AI版
04-03
简单的AI，可用于大学编程作业，其中的代码易懂，一般能战胜大部分人。
五子棋(简易AI)
10-23
一个带有简易AI的五子棋小游戏，采用了极大极小搜索和估值函数，对弈规则是：指定开局、三手交换、五手N打、禁手
五子棋ai(C#)
01-01
自己C#写的五子棋AI，智能程度不是很高，适合初学者学习.
五子棋带ai
12-29
五子棋附ai附教程内容详细，适合初学者参考学习。。。
五子棋 ai算法
day day no bug
02-17 6128
博弈类人工智能，其中一个方法就是：博弈树极大极小值alpha-beta剪枝搜索。 是不是觉得这个名字很牛逼， 但经过我的详细解读， 你马上就会发现，原来不过如此。 对于要实现一个会智能下五子棋的AI，要怎么去实现呢？自然想到的方法就是，让计算机把每一步的可能性都试一遍，看走在那效果最好。 其实就是搜索的方法，搜索所有的下一步可能性，择优选择。这就是博弈树搜索。 博弈树搜索 什么是博弈树搜素呢？博弈就是相互采取最优策略斗争的意思。比如说下五子棋，你下一步，我下一步，这就是相互博弈。假设棋盘的大小是10*10,
五子棋 AI（一）
大田二十
03-26 4402
五子棋 AI（一）
五子棋AI（C++、QT）
HuanBianCheng27的博客
08-20 2472
学习视频链接五子棋-3_bilibili_哔哩哔哩_bilibili。
Java 五子棋AI 算法及实现 详细解析
weixin_71872462的博客
01-07 3940
连五，活四，冲四，活三，眠三，活二，眠二。①连五：顾名思义，五颗同色棋子连在一起，不需要多讲。②活四：有两个连五点（即有两个点可以形成五），图中白点即为连五点。稍微思考一下就能发现活四出现的时候，如果对方单纯过来防守的话，是已经无法阻止自己连五了。③冲四：有一个连五点，如下面三图，均为冲四棋型。图中白点为连五点。相对比活四来说，冲四的威胁性就小了很多，因为这个时候，对方只要跟着防守在那个唯一的连五点上，冲四就没法形成连五。④活三：可以形成活四的三，如下图，代表两种最基本的活三棋型。
五子棋人工智能算法设计与优化
这篇论文提供了设计和实现智能五子棋算法的全面指南，对于研究人工智能在棋类游戏中的应用具有重要的参考价值。通过理解并应用文中所述的技术和策略，开发者可以构建出更智能、更高效的五子棋游戏系统。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值