五子棋ai如何判断棋型
ai如何判断棋型?下面学习啦小编给你介绍五子棋ai判断棋型的方法，欢迎阅读。
　　五子棋ai如何判断棋型
　　任何一种棋类其关键是对当前棋局是否有正确的评分,评分越准确则的AI越高。五子棋游戏也是如此，但在打分之前，我们先扫描
　　整个棋盘，把每个空位从八个方向上的棋型填入数组gStyle(2, 15, 15, 8,
2)，其中第一个下标为1时表示黑棋，为2时表示白棋，第二和第三
　　个下标表示(x,y)，第四个下标表示8个方向，最后一个下标为1时表示棋子数，为2时表示空格数，如：
　　gStyle(1,2,2,1,1)=3表示与坐标(2,2)在第1个方向上相邻的黑棋棋子数为3
　　gstyle(1,2,2,1,2)=4表示与坐标(2,2)在第1个方向上的最近的空格数为4
　　在定义方向时，也应该注意一定的技巧，表示两个相反的方向的数应该差4，在程序中我是这样定义的：
　　Const DIR_UP = 1
　　Const DIR_UPRIGHT = 2
　　Const DIR_RIGHT = 3
　　Const DIR_RIGHTDOWN = 4
　　Const DIR_DOWN = 5
　　Const DIR_DOWNLEFT = 6
　　Const DIR_LEFT = 7
　　Const DIR_LEFTUP = 8
　　这样我们前四个方向可以通过加四得到另一个方向的值。如果你还是不太明白，请看下面的图：
　　---------
　　---------
　　---oo----
　　-ox*xx---
　　---------
　　---------
　　图中的*点从标为(4,4),(打*的位置是空位),则:
　　gStyle(2,4,4,1,1)=1在(4,4)点相邻的上方白棋数为1
　　gStyle(2,4,4,1,2)=2在(4,4)点的上方距上方白棋最近的空格数为2
　　gStyle(1,4,4,3,1)=2在(4,4)点相邻的右方黑棋数为2
　　gStyle(1,4,4,3,2)=1在(4,4)点的右方距右方黑棋最近的空格数为3
　　一旦把所有空点的棋型值填完，我们很容易地得出黑棋水平方向上点(4,4)的价值，由一个冲1(我把有界的棋称为冲)和活2(两边无界的
　　棋称为活)组成的。对于而白棋在垂直方向上点(4,4)的价值是一个活1，而在/方向也是活1所以，只要我们把该点的对于黑棋和白棋的价值算出
　　来，然后我们就取棋盘上各个空点的这两个值的和的最大一点作为的点。然而，对各种棋型应该取什么值呢?我们可以先作如下假设：
　　Fn 表示先手n个棋子的活棋型，如：F4表示先手活四
　　Fn'表示先手n个棋子的冲棋型，如：F4'表示先手冲四
　　Ln 表示后手n个棋子的活棋型，如：L3表示后手活三
　　Ln'表示后手n个棋子的冲棋型，如：L3'表示后手冲三
　　根据在一行中的棋型分析，得到如下关系：
　　L1'&=F1'
　　从这个关系包含了进攻和防守的关系(当然，这个关系是由我定的，你可以自己定义这些关系)。对这些关系再进一步细化，如在一个可下
　　棋的点，其四个方向上都有活三，也比不上一个冲四，所以我们可以又得到4*F3
　　到了下面各种棋型的分值，由C语言表示为：
　　F[2][5]={{0,2,5,50,16000},{0,10,30,750,16000}};
　　L[2][5]={{0,1,5,50,3750},{0,10,30,150,4000}};
　　F数组表示先手，第一个下标为0时表示冲型，第二个下标表示棋子数，则F2'对应F[0][2]L数组表示后手，第一个下标为0时表示冲型，第二
　　个下标表示棋子数，则L2对应F[1][2]Ok，棋型的分值关系确定好了以后，我们把每一个可下点的四个方向的棋型值相加(包括先手和后手的分
　　值)，最后选择一个最大值，并把这一点作为要下的点就OK了:)。
　　后话：
　　1、得到最大值也许不止一个点，但在我的程序中只选择第一个最大点，当然你可以用于个随机数来
　　选择那一个最大值点，也可以对这些最大值点再作进一步的分析。
　　2、在这个算法中我只考虑了周围有棋子的点，而其它点我没有考虑。
　　3、可以再更进一步，用这个算法来预测以后的几步棋，再选择预测值最好的一步，这样电脑的AI就更高了
　　4、这个算法没有考虑黑棋的禁手(双3、双四和多于五子的连棋)。因为在平时我下的五子棋是没有这些
　　禁手的。
&&&&&&&&五子棋算法探讨
　　近来随着计算机的快速发展，各种棋类游戏被纷纷请进了电脑，使得那些喜爱下棋，又常常苦于没有对手的棋迷们能随时过足棋瘾。而且这类软件个个水平颇高，大有与人脑分庭抗礼之势。其中战胜过世界冠军-卡斯帕罗夫的“深蓝”便是最具说服力的代表;其它像的“手淡”、象棋的“将族”等也以其优秀的人工智能深受棋迷喜爱;而我们今天将向大家介绍的是五子棋的算法。
　　当我们与电脑对战时，您知道这些软件是怎样象人脑一样进行思考的吗?前不久我曾编写过一个五子棋的游戏，在这里就以此为例和大家一起探讨探讨。
　　总的来说(我们假定您熟悉五子棋的基本规则)，要让电脑知道该在哪一点下子，就要根据盘面的形势，为每一可能落子的点计算其重要程度，也就是当这子落下后会形成什么棋型(如：“冲四”、“活三”等)，然后通览全盘选出最重要的一点，这便是最基本的算法。当然，仅靠当前盘面进行判断是远远不够的，这样下棋很容易掉进玩家设下的陷阱，因为它没有考虑以后的变化。所以在此基础上我们加入递归调用，即：在电脑中预测出今后几步的各种走法，以便作出最佳选择，这也是我们下棋时常说的“想了几步”。如此一来您的程序便具有一定的水平了。什么?不信!过来试试吧!
　　总体思路弄清之后，下面进行具体讨论：
　　一：数据结构
　　先来看看数据结构，我们需要哪些变量?
　　首先得为整个棋盘建立一张表格用以记录棋子信息，我们使用一个15*15的二维数组 Table[15][15]
(15*15是五子棋棋盘的大小)，数组的每一个元素对应棋盘上的一个交叉点，用‘0’表示空位、‘1’代表己方的子、‘2’代表对方的子;这张表也是今后分析的基础。
　　在此之后还要为电脑和玩家双方各建立一张棋型表Computer[15][15][4]和Player[15][15][4]，用来存放棋型数据，就是刚才所说的重要程度，比如用‘20’代表“冲四”的点，用‘15’代表“活三”的点，那么在计算重要性时，就可以根据20&15得出前者比后者重要，下子时电脑便会自动选择“冲四”的点。那为什么棋型表要使用三维数组呢?因为棋盘上的每一个点都可以与横、竖、左斜、右斜四个方向的棋子构成不同的棋型，所以一个点总共有4个记录;这样做的另一个好处是可以轻易判断出复合棋型，例如：如果同一点上有2个‘15’就是双三、有一个‘15’和一个‘20’就是四三。
　　怎么样!3个数组构成了程序的基本数据骨架，今后只要再加入一些辅助变量便可以应付自如了。应该不会太难吧?OK!有了这么多有用的数据，我们就可以深入到程序的流程中去了。
　　二：程序流程
　　我们主要讨论五子棋的核心算法，即：人工智能部分，而其他像图形显示、控制等，因较为简单，所以就不作过多介绍了。
　　程序由六个基本功能模块构成，各模块的详细分析如下：
　　(1)初始化：首先，建立盘面数组Table[15][15]、对战双方的棋型表Computer[15][15][4]和Player[15][15][4]并将它们清零以备使用;然后初始化显示器、键盘、鼠等输入输出设备并在屏幕上画出棋盘。
　　(2)主循环控制模块：控制下棋顺序，当轮到某方下子时，负责将程序转到相应的模块中去，主要担当一个调度者的角色。
　　(3)玩家下子：当轮到玩家下时，您通过键盘或鼠标在棋盘上落子，程序会根据该点的位置，在Table[15][15]数组的相应地方记录‘2’，以表明该子是玩家下的。
　　(4)盘面分析填写棋型表：本程序核心模块之一，人工智能算法的根本依据!其具体实现方法如下：您在下五子棋时，一定会先根据棋盘上的情况，找出当前最重要的一些点位，如“活三”、“冲四”等;然后再在其中选择落子点。但是，电脑不会像人一样分析问题，要让它知道哪是“活三”、哪是“冲四”，就得在棋盘上逐点计算，一步一步的教它。
　　先来分析己方的棋型，我们从棋盘左上角出发，向右逐行搜索，当遇到一个空白点时，以它为中心向左挨个查找，如果遇到己方的子则记录然后继续，如果遇到对方的子、空白点或边界就停止查找。左边完成后再向右进行同样的操作;最后把左右两边的记录合并起来，得到的数据就是该点横向上的棋型，然后把棋型的编号填入到Computer[x][y][n]中就行了(x、y代表坐标，n=0、1、2、3分别代表横、竖、左斜、右斜四个方向)。而其他三个方向的棋型也可用同样的方法得到，当搜索完整张棋盘后，己方棋型表也就填写完毕了。然后再用同样的方法填写对方棋型表。
　　注意：所有棋型的编号都要事先定义好，越重要的号数越大!
　　OK! 怎么样?有点累了吧?不过千万别泄气!因为好戏还在后头。
　　Let's go!
　　(5)电脑下子：有了上面填写的两张棋型表，现在要作的就是让电脑知道在哪一点下子了。其中最简单的计算方法，就是遍历棋型表Computer[15][15][4]和Player[15][15][4]找出其中数值最大的一点，在该点下子即可。但这种算法的弱点非常明显，只顾眼前利益，不能顾全大局，这就和许多五子棋初学者一样犯了“目光短浅”的毛病。
　　要解决这个问题，我们引入‘今后几步预测法’，具体方法是这样的： 首先，
让电脑分析一个可能的点，如果在这儿下子将会形成对手不得不防守的棋型(例如：‘冲四’、‘活三’);那么下一步对手就会照您的思路下子来防守您，如此一来便完成了第一步的预测。这时再调用模块4对预测后的棋进行盘面分析，如果出现了‘四三’、‘双三’或‘双四’等制胜点，那么己方就可以获胜了(当然对黑棋而言‘双三’、‘双四’是禁手，另当别论);否则照同样的方法向下分析，就可预测出第二步、第三步……
　　等一等，要是盘面上没有对手必须防的棋型，哪该怎么办呢?进攻不成的话就得考虑防守了，将自己和对手调换一下位置，然后用上面的方法来预测对手的棋，这样既可以防住对手巧妙的攻击，又能侍机发动反击，何乐而不为呢!
　　但是必须告诉大家的是：预测法的运算量相当之大，据我的，用Pentium-100预测3步的走法平均需要15秒以上时间，所以建议预测量在5步以内。可别小瞧了这5步，有时它甚至会走出让您拍手叫绝的妙着呢!
　　(6)胜负判断：务须多言，某方形成五子连即获胜;若黑棋走出‘双三’、‘双四’或长连即以禁手判负。
　　到现在为止，整个五子棋软件就基本完成了，其水平大约在中级上下。当然，这种算法并不是最好的，但我相信它的基本思路是正确的。如果您有什么问题或好的想法，欢迎给我发E-mail:
，我期待着您的见解。
　　五子棋禁手判定算法
　　禁手的判定较为复杂，设计一个判断禁手的算法既要分析构成它的棋型又要找到合适的搜索方法。
　　首先分析棋型。
　　先考虑构成长连禁手的棋型，构成长连的棋型较简单，可归纳为一种，即相连后形成六子或更多相连。一旦发现产生此棋型，即判为长连禁手。
　　再考虑构成四四禁手、三三禁手的棋型。要判断下某一子是否构成四四禁手(或三三禁手)，只需判断下这一子后是否产生两个或两个以上的冲四或活四(或活三)即可。所以归结起来，要正确判断四四禁手、三三禁手就是要正确判断冲四、活四和活三。
　　考虑冲四、活四和活三的定义。冲四是只有一个点可以成五的四，这里我们将那个点称为关键点。同样，构成活四的有两个关键点，构成活三的有一个关键点。如图11，a,b两点是其构成活四的关键点，又如图12，a点是其构成活三的关键点。
　　以下是对各棋型和关键点的分析。
　　1、活四：
　　归结起来构成活四的只有一种棋型,如图13
　　这种棋型真正构成活四的条件是左右两空位(即a,b点)必须是黑棋可下的点，也就是在a,b点下黑子后都不会构成禁手。
　　2、冲四：
　　形成冲四有两种棋型，如图14和图15
　　这两种棋型真正构成冲四的条件是中间的空位(即a点)必须是黑棋可下的点，也就是在a点下子后不会构成禁手。
　　3、活三：
　　形成活三有两种棋型，如图16和图17
　　其中，a点是关键点，b,c点可以是边界、无子或白色棋子，但不能是黑色棋子。
　　这两种棋型真正构成活三的条件是a点必须是黑棋可下的点，也就是在a点下子后不会构成禁手，m,n两点不用管是否构成禁手，因为当a点放入黑子后，不管在m点还是n点放黑子，就会形成五连，即获胜，不构成禁手。
　　所以我们要判断一种棋型是否构成冲四、活四或活三，需要在已判断它是可能的冲四、活四或活三的棋型的基础上判断它的关键点是否可落黑色棋子，也就是判断关键点是否不会构成新的禁手点，这一步在程序中可以用递归实现。
　　棋型分析完成，我们就要据此考虑选择合适的算法。
　　基于禁手分析所需的精确度，我们在棋盘盘面搜索时，需要记录与待判断点相邻的连续黑色棋子数，并记录之后的连续空子数，并记录再之后的连续黑子数，和再之后的连续空子数，以及再之后的连续黑子数。所以可以说搜索的深度要达到5层。
　　在判断关键点的可下性时，选用递归的方法来判断其是否不是禁手点。
　　于是最后我们可以得出禁手判定算法的思路。
　　第一步：将待判断点放入黑棋子;
　　第二步：搜索待判断点周边棋盘;
　　第三步：还原棋盘;
　　第四步：利用搜索结果依次对各方向进行分析，判断黑棋放入后所产生的棋型是否形成长连或形成可能构成活四、冲四、活三的棋型。若形成长连，判定为禁手，返回长连禁手标识。若形成可能是活四、冲四、活三的棋型，判断关键点是否可下，若不可下，该棋型统计数加1，反之，则对下一个方向进行判断，直到各个方向分析结束。
　　第五步：若活四、冲四棋型的统计数大于1，返回四四禁手标识，若活三棋型的统计数大于1，返回三三禁手标识。其余情况返回非禁手标识。
　　源代码:
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。>> 一个五子棋游戏，AI算法写的很好。这个而且界面做的很漂亮，想研究AI算法的可以看看。...
一个五子棋游戏，AI算法写的很好。这个而且界面做的很漂亮，想研究AI算法的可以看看。...
所属分类：
下载地址：
Fivechess.rar文件大小：31.31 kB
分享有礼！ 》
请点击右侧的分享按钮，把本代码分享到各社交媒体。
通过您的分享链接访问Codeforge，每来2个新的IP，您将获得0.1 积分的奖励。
通过您的分享链接，每成功注册一个用户，该用户在Codeforge上所获得的每1个积分，您都将获得0.2 积分的分成奖励。
一个五子棋游戏，AI算法写的很好。这个而且界面做的很漂亮，想研究AI算法的可以看看。-A welcome to play, AI algorithm to write well. Interface to do this and that is very beautiful, want to study AI algorithms can look at.
Sponsored links
源码文件列表
温馨提示： 点击源码文件名可预览文件内容哦 ^_^
1.11 kB07-01-03 21:54
208.00 B06-01-03 21:30
1.03 kB06-01-03 21:30
五子棋.aps23.18 kB12-12-03 21:22
五子棋.clw1.64 kB01-06-04 22:28
1.97 kB06-01-03 21:30
五子棋.dsp4.27 kB07-01-03 21:16
五子棋.dsw537.00 B06-01-03 21:30
1.26 kB06-01-03 21:30
五子棋.ncb65.00 kB27-05-04 23:39
五子棋.opt54.50 kB27-05-04 23:39
五子棋.plg1.77 kB01-06-04 22:28
6.76 kB08-01-03 13:39
16.16 kB27-05-04 22:47
1.58 kB07-01-03 21:45
&五子棋&0.00 B17-12-09 23:07
（提交有效评论获得积分）
评论内容不能少于15个字，不要超出160个字。
评价成功，多谢！
下载Fivechess.rar
CodeForge积分（原CF币）全新升级，功能更强大，使用更便捷，不仅可以用来下载海量源代码马上还可兑换精美小礼品了
您的积分不足，优惠套餐快速获取 30 积分
10积分 / ￥100
30积分 / ￥200原价 ￥300 元
100积分 / ￥500原价 ￥1000 元
订单支付完成后，积分将自动加入到您的账号。以下是优惠期的人民币价格，优惠期过后将恢复美元价格。
支付宝支付宝付款
微信钱包微信付款
更多付款方式：、
您本次下载所消耗的积分将转交上传作者。
同一源码，30天内重复下载，只扣除一次积分。
鲁ICP备号-3 runtime:Elapsed:ms - init:0.1;find:20.5;t:1.6;tags:10.7;related:279.7;comment:0.8; 5.8
登录 CodeForge
还没有CodeForge账号？
Switch to the English version?
^_^"呃 ...
Sorry!这位大神很神秘，未开通博客呢，请浏览一下其他的吧没有更多推荐了，
不良信息举报
举报内容：
五子棋基础算法及胜利判定算法（无AI）
举报原因：
原文地址：
原因补充：
最多只允许输入30个字
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。
标签：至少1个，最多5个
BetaMeow的起源
前段时间AlphaGo和李世石广受关注，作为人工智能的脑残粉，看完比赛后激动不已，因为有一定的机器学习的基础，便打算撸一个棋类的AI，但我还算有点自知之明，围棋AI，甚至google打算做得通用AI是做不出的了，所以打算撸一个五子棋的AI。
选取五子棋作为试手项目主要是以下几点原因：
规则简单。为了简单起见，BetaMeow只要有一方练成五子就可以判输赢。
受众多。因为五子棋的规则相对简单，使得其受众远比围棋多，换句话来说，我把BetaMeow做出来了，那么可以测试的人也多。
机器学习的简单介绍
近年机器学习，数据挖掘,人工智能很火，但其实不少人对这些名词其实是一头雾水，我尝试用我自己的语言解释，如果有什么需要完善的地方，欢迎提出。
比如说，有一个模型能够能够根据一个人的社交动态，推断出他是喜欢苹果还是香蕉，那么，我现在想知道某个社交平台上市喜欢苹果的人多，还是喜欢香蕉的人多。显然，我把社交平台的数据扔进模型中跑一遍就可以了，但社交平台数据肯定不是说一两个txt文件这么简单啊。这时就可能涉及网络爬虫(收集数据)，分布式存储(数据量巨大的时候)，过滤无关的数据(数据清洗),修改模型使得符合当前业务场景(花式调参)，跑完数据获得结果后决定采取什么商业措施等。(BI)
机器学习就是负责考虑如何建立模型，而数据挖掘则是负责其他地方，不过一般来说，数据挖掘部分的工作可能会分开几个部门来做。
简言之，机器学习是内功，而数据挖掘则是机器学习的一种用途。而人工智能，就是更广的概念了
回到正题上，传统的五子棋AI采用的搜索算法，这个方面其实已经很完善，听闻已经出现了无解的结果(玩家无法取胜)。但BetaMeow本质上是我在学习机器学习方面的实战项目，所以我想办法利用机器学习的方面的算法实现。
最后选择决策树算法。通过决策树判断该局的状况，属于对方（玩家）占优还是己方（AI）占优。
什么叫决策树
至于什么叫决策树，有时真的是一图胜千言。
图片来至于
简单来说，通过一层层的筛选下来，你就能获得相应的结果。
如何构建决策树
关于如何构建决策树，如果需要了解文字说明，可以参考,如果需要参考python的代码实现，可以参考下文给出的github地址，这里只给出简单总结。
在一个二维集合（可以看成矩阵）中，第二维代表每一个决策的实例，用某种方式（例如信息增益（首先要计算熵））在确定一个最佳分割点（p），然后以该点作为根节点，此时剩下的子集有两种情况，要么作为决策树的结果，要么递归下去创建子树。
有句话叫好的数据胜过好的模型，经过这番实践我算是真正认识到这句话的意思。机器学习的算法不是你随便扔一个数据集下去，他都能训练出一个有效的模型。我曾经把整个棋局扔给他它训练，然而并没有什么乱用。几番周折才角色以连子形式作为训练的内容。
[1,1,0,1,2]
这个训练集表明，玩家的连子形式已经是1，1，0，1（0表示空位），如果玩家顺利连成了4子，那么AI则彻底出于劣势，因为如果4子是在棋盘中间的话，那么ai只能堵一边，玩家还是可以在另一边连成5子。
所以ai应该下在2号位，阻止其连成4子。
我的代码中有大量如此的数据，用于教会ai决定是及时阻止对方，还是提高自己的连子数。(跑两次不同的决策树)
BetaMeow的未来与本文后话
BetaMeow现在显然是不完善的。
首先是五子棋规则的本身，首先是五子棋棋盘应该15x15，然后无知的我把它弄成了19x19,然后规先后手的规则好像也有不同的规定，但我没有考虑太多这方面，毕竟我的主要目的是机器学习的实践，并非做出一个五子棋游戏。五子棋只是一个载体。同样是因为我的目的在于算法，所以界面不太美观，甚至在不同分辨率上可能有问题(使用的bootstrap应该问题不大)，所以如果有较为熟悉前端的朋友，欢迎修改修改后Pull Requese给我。
第二点，算法本身也有不完善的地方。因为目前的方案是遍历棋局，分析各店的形式，可能因为循环的原因，会导致后面的选择覆盖掉前一个选择，从而错过了一些最好的选择。
下一步会是给每一个选择的结果加上权重，从而避免上述问题。
嗯，说了这么多，最后给出这个项目的github地址
重要的事情再说一遍。
前端真的做得很烂，如果有熟悉前端的朋友帮我修改一下，真的万分感谢。
这个github地址会记录下我学习机器学习和数据挖掘的各种小项目(包括我之前的的项目)，将会持续更新很长一段时间，如果你对这个有兴趣，欢迎关注和支持。
如果你也有机器学习和数据挖掘等相关的项目，欢迎推荐给我，大家互相学习的同时，我也会在我的项目的README中给出你项目的URL(你也要给出我项目的URL哦，亲)
感谢关注和支持。
4 收藏&&|&&15
你可能感兴趣的文章
5 收藏，130
23 收藏，4.4k
2 收藏，440
你好，我看了你的代码，我没有找到如何生存决策树的逻辑？请问p_tree和w_tree的内容是怎么得到的呢？这部分代码我没有看到
你好，我看了你的代码，我没有找到如何生存决策树的逻辑？请问p_tree和w_tree的内容是怎么得到的呢？这部分代码我没有看到
分享到微博？
我要该，理由是：
在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。Java实现五子棋AI算法
转载 &发布时间：日 15:04:52 & 作者：彷徨的石头
这篇文章主要为大家详细介绍了Java实现五子棋AI算法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
五子棋AI算法 也算是一个典型的游戏AI算法，一些棋类的AI算法都可以参考实现，下面是Java实现代码
棋盘抽象接口
import java.util.L
public interface IChessboard {
//取得棋盘最大横坐标
public int getMaxX();
//最大纵坐标
public int getMaxY();
//取得当前所有空白点，这些点才可以下棋
public List&Point& getFreePoints();
棋子类实现
public class Point {
// 这了性能，设成公有
public int getX() {
public Point setX(int x) {
public int getY() {
public Point setY(int y) {
public Point(int x, int y) {
public int hashCode() {
return x +
public boolean equals(Object obj) {
if (this == obj)
Point other = (Point)
if (x != other.x)
if (y != other.y)
玩家抽象接口
import java.util.L
public interface IPlayer {
//下一步棋子，传入对手已经下的棋子集合
public void run(List&Point& enemyPoints, Point point);
public boolean hasWin();
public void setChessboard(IChessboard chessboard);
public List&Point& getMyPoints();
玩家基础抽象类
import java.util.ArrayL
import java.util.L
public abstract class BasePlayer implements IPlayer {
//我已下的棋子
protected List&Point& myPoints = new ArrayList&Point&(200);
protected IC
//棋盘最大横坐标和纵标，
protected int maxX;
protected int maxY;
//所有空白棋子
protected List&Point& allFreeP
public final List&Point& getMyPoints() {
return myP
public void setChessboard(IChessboard chessboard) {
this.chessboard =
allFreePoints = chessboard.getFreePoints();
maxX = chessboard.getMaxX();
maxY = chessboard.getMaxY();
myPoints.clear();
private final Point temp = new Point(0, 0);
//我是否是否赢了
public final boolean hasWin(){
if(myPoints.size()&5){
Point point = myPoints.get(myPoints.size()-1);
int count = 1;
int x=point.getX(),y=point.getY();
temp.setX(x).setY(y);
while (myPoints.contains(temp.setX(temp.getX()-1)) && temp.getX()&=0 && count&5) {
if(count&=5){
temp.setX(x).setY(y);
while (myPoints.contains(temp.setX(temp.getX()+1)) && temp.getX()&maxX && count&5) {
if(count&=5){
count = 1;
temp.setX(x).setY(y);
while (myPoints.contains(temp.setY(temp.getY()-1)) && temp.getY()&=0) {
if(count&=5){
temp.setX(x).setY(y);
while (myPoints.contains(temp.setY(temp.getY()+1)) && temp.getY()&maxY && count&5) {
if(count&=5){
//正斜向 /
temp.setX(x).setY(y);
while (myPoints.contains(temp.setX(temp.getX()-1).setY(temp.getY()+1)) && temp.getX()&=0 && temp.getY()&maxY) {
if(count&=5){
temp.setX(x).setY(y);
while (myPoints.contains(temp.setX(temp.getX()+1).setY(temp.getY()-1)) && temp.getX()&maxX && temp.getY()&=0 && count&6) {
if(count&=5){
count = 1;
temp.setX(x).setY(y);
while (myPoints.contains(temp.setX(temp.getX()-1).setY(temp.getY()-1)) && temp.getX()&=0 && temp.getY()&=0) {
if(count&=5){
temp.setX(x).setY(y);
while (myPoints.contains(temp.setX(temp.getX()+1).setY(temp.getY()+1)) && temp.getX()&maxX && temp.getY()&maxY && count&5) {
if(count&=5){
电脑AI类实现
import java.util.ArrayL
import java.util.C
import java.util.HashM
import java.util.L
import java.util.M
//算法核心类，算法的主体思想分三个步骤，
//第一步：根据双方的当前的形势循环地假设性的分别给自己和对方下一子（在某个范围内下子），并判断此棋子能带来的形势上的变化，如能不能冲4，能不能形成我方或敌方双3等，
//第二步：根据上一步结果，组合每一步棋子所带来的所有结果（如某一步棋子可能形成我方1个活3，1个冲4（我叫它半活4）等），包括敌方和我方的。
//第三步：根据用户给的规则对上一步结果进行排序，并选子（有进攻形、防守形规则）
public class BaseComputerAi extends BasePlayer {
// 四个方向，横- 、纵| 、正斜/ 、反斜\
private static final int HENG = 0;
private static final int ZHONG = 1;
private static final int ZHENG_XIE = 2;
private static final int FAN_XIE = 3;
//往前往后
private static final boolean FORWARD =
private static final boolean BACKWARD =
//标示分析结果当前点位是两头通（ALIVE）还是只有一头通（HALF_ALIVE），封死的棋子分析过程自动屏蔽，不作为待选棋子
private static final int ALIVE = 1;
private static final int HALF_ALIVE = 0;
//private static final int DEAD = -1;
//计算范围，太大的范围会有性能问题
private class CalcuteRange{
int xStart,yStart,xStop,yS
private CalcuteRange(int xStart, int yStart, int xStop, int yStop) {
this.xStart = xS
this.yStart = yS
this.xStop = xS
this.yStop = yS
//限定电脑计算范围，如果整个棋盘计算，性能太差，目前是根据所有已下的棋子的边界值加RANGE_STEP值形成，目前为1
private static final int RANGE_STEP = 1;
CalcuteRange currentRange = new CalcuteRange(0, 0, 0, 0);
private void initRange(List&Point& comuters, List&Point& humans){
currentRange.xStart = humans.get(0).getX()-RANGE_STEP;
currentRange.yStart = humans.get(0).getY()-RANGE_STEP;
currentRange.xStop = humans.get(0).getX()+RANGE_STEP;
currentRange.yStop = humans.get(0).getY()+RANGE_STEP;
for (Point point : humans) {
if(point.getX()-RANGE_STEP&currentRange.xStart){
currentRange.xStart = point.getX()-RANGE_STEP;
}else if(point.getX()+RANGE_STEP&currentRange.xStop){
currentRange.xStop = point.getX()+RANGE_STEP;
if(point.getY()-RANGE_STEP&currentRange.yStart){
currentRange.yStart = point.getY()-RANGE_STEP;
}else if(point.getY()+RANGE_STEP&currentRange.yStop){
currentRange.yStop = point.getY()+RANGE_STEP;
for (Point point : comuters) {
if(point.getX()-RANGE_STEP&currentRange.xStart){
currentRange.xStart = point.getX()-RANGE_STEP;
}else if(point.getX()+RANGE_STEP&currentRange.xStop){
currentRange.xStop = point.getX()+RANGE_STEP;
if(point.getY()-RANGE_STEP&currentRange.yStart){
currentRange.yStart = point.getY()-RANGE_STEP;
}else if(point.getY()+RANGE_STEP&currentRange.yStop){
currentRange.yStop = point.getY()+RANGE_STEP;
//如果范围扩大后超过了棋盘，则等于棋盘
currentRange.xStart=currentRange.xStart&0?0:currentRange.xS
currentRange.yStart=currentRange.yStart&0?0:currentRange.yS
currentRange.xStop=currentRange.xStop&=maxX?maxX-1:currentRange.xS
currentRange.yStop=currentRange.yStop&=maxY?maxY-1:currentRange.yS
// 分析当前形式的入口方法，分析总共分三个步骤，第三步骤可由子类干预以作难度控制
private Point doAnalysis(List&Point& comuters, List&Point& humans) {
if(humans.size()==1){//第一步
return getFirstPoint(humans);
//初始化计算范围
initRange(comuters, humans);
//清除以前的结果
initAnalysisResults();
// 开始分析，扫描所有空白点，形成第一次分析结果
Point bestPoint = doFirstAnalysis(comuters, humans);
if(bestPoint!=null){
//System.out.println("这个棋子最重要，只能下这个棋子");
return bestP
// 分析第一次结果，找到自己的最佳点位
bestPoint = doComputerSencondAnalysis(computerFirstResults,computerSencodResults);
if(bestPoint!=null){
//System.out.println("快要赢了，就下这个棋子");
return bestP
computerFirstResults.clear();
System.gc();
// 分析第一次结果，找到敌人的最佳点位
bestPoint = doHumanSencondAnalysis(humanFirstResults,humanSencodResults);
if(bestPoint!=null){
//System.out.println("再不下这个棋子就输了");
return bestP
humanFirstResults.clear();
System.gc();
//没找到绝杀点，第三次结果分析
return doThirdAnalysis();
//下第一步棋子，不需要复杂的计算，根据人类第一步棋子X值减1完成
private Point getFirstPoint(List&Point& humans) {
Point point = humans.get(0);
if(point.getX()==0 || point.getY()==0 || point.getX()==maxX && point.getY()==maxY)
return new Point(maxX/2, maxY/2);
return new Point(point.getX()-1,point.getY());
// private int debugx,//用于DEBUG
// 开始分析，扫描所有空白点，形成第一次分析结果
private Point doFirstAnalysis(List&Point& comuters, List&Point& humans){
int size = allFreePoints.size();
Point computerPoint =
Point humanPoint =
FirstAnalysisResult firstAnalysisR
for (int i = 0; i & i++) {
computerPoint = allFreePoints.get(i);
//先把X、Y坐标记下来，因为在分析过程中会改变原来的对象
x = computerPoint.getX();
y = computerPoint.getY();
if(x&currentRange.xStart || x&currentRange.xStop || y&currentRange.yStart || y&currentRange.yStop){
if(x==debugx && y==debugy){
System.out.println("sssssssssssss");
//尝试在此位置上下一个棋子，并分析在“横向”这个方向上我方可形成的状态，如活4，活3，半活4，活2等所有状态
firstAnalysisResult = tryAndCountResult(comuters,humans, computerPoint, HENG);
computerPoint.setX(x).setY(y);//回复点位的原值，以供下次分析
if(firstAnalysisResult!=null){//无返回结果此方向上不可能达到五个棋子，
if(firstAnalysisResult.count==5)//等于5表示在此点上下棋子即可连成5个，胜利了，不再往下进行分析
return computerP
//记录第一次分析结果
addToFirstAnalysisResult(firstAnalysisResult,computerFirstResults);
//在“纵向”这个方向上重复上面的步骤
firstAnalysisResult = tryAndCountResult(comuters,humans, computerPoint, ZHONG);
computerPoint.setX(x).setY(y);
if(firstAnalysisResult!=null){//死棋，不下
if(firstAnalysisResult.count==5)
return computerP
addToFirstAnalysisResult(firstAnalysisResult,computerFirstResults);
firstAnalysisResult = tryAndCountResult(comuters,humans, computerPoint, ZHENG_XIE);
computerPoint.setX(x).setY(y);
if(firstAnalysisResult!=null){//死棋，不下
if(firstAnalysisResult.count==5)
return computerP
addToFirstAnalysisResult(firstAnalysisResult,computerFirstResults);
firstAnalysisResult = tryAndCountResult(comuters,humans, computerPoint, FAN_XIE);
computerPoint.setX(x).setY(y);
if(firstAnalysisResult!=null){//死棋，不下
if(firstAnalysisResult.count==5)
return computerP
addToFirstAnalysisResult(firstAnalysisResult,computerFirstResults);
//在“横向”上分析此棋子可在敌方形成如何状态，如敌方的活3、半活4等
firstAnalysisResult = tryAndCountResult(humans,comuters, computerPoint, HENG);
computerPoint.setX(x).setY(y);
if(firstAnalysisResult!=null){//死棋，不下
if(firstAnalysisResult.count==5)
humanPoint = computerP
addToFirstAnalysisResult(firstAnalysisResult,humanFirstResults);
//“纵向”
firstAnalysisResult = tryAndCountResult(humans,comuters, computerPoint, ZHONG);
computerPoint.setX(x).setY(y);
if(firstAnalysisResult!=null){//死棋，不下
if(firstAnalysisResult.count==5)
humanPoint = computerP
addToFirstAnalysisResult(firstAnalysisResult,humanFirstResults);
//“正斜”
firstAnalysisResult = tryAndCountResult(humans,comuters, computerPoint, ZHENG_XIE);
computerPoint.setX(x).setY(y);
if(firstAnalysisResult!=null){//死棋，不下
if(firstAnalysisResult.count==5)
humanPoint = computerP
addToFirstAnalysisResult(firstAnalysisResult,humanFirstResults);
//“反斜”
firstAnalysisResult = tryAndCountResult(humans,comuters, computerPoint, FAN_XIE);
computerPoint.setX(x).setY(y);
if(firstAnalysisResult!=null){//死棋，不下
if(firstAnalysisResult.count==5)
humanPoint = computerP
addToFirstAnalysisResult(firstAnalysisResult,humanFirstResults);
//如果没有绝杀棋子，第一次分析不需要返回结果
return humanP
//第二次分析，分析第一次形成的结果，第一次分析结果会把一步棋在四个方向上可形成的结果生成最多四个FirstAnalysisResult对象（敌我各四）
//这里要把这四个对象组合成一个SencondAnalysisResult对象，
private Point doComputerSencondAnalysis(Map&Point,List&FirstAnalysisResult&& firstResults,List&SencondAnalysisResult& sencodResults) {
List&FirstAnalysisResult& list =
SencondAnalysisResult sr =
for (Point p : firstResults.keySet()) {
sr = new SencondAnalysisResult(p);
list = firstResults.get(p);
for (FirstAnalysisResult result : list) {
if(result.count==4){
if(result.aliveState==ALIVE){//经过前面的过滤，双方都排除了绝杀棋，有活4就下这一步了，再下一步就赢了
return result.//如果有绝杀，第一轮已返回，在此轮活4已经是好的棋子，直接返回，不再往下分析
sr.halfAlive4 ++;
computer4HalfAlives.add(sr);
}else if(result.count==3){
if(result.aliveState==ALIVE){
sr.alive3++;
if(sr.alive3==1){
computer3Alives.add(sr);
computerDouble3Alives.add(sr);
sr.halfAlive3++;
computer3HalfAlives.add(sr);
}else{//半活2在第一阶段已被排除，不再处理
sr.alive2++;
if(sr.alive2==1){
computer2Alives.add(sr);
computerDouble2Alives.add(sr);
sencodResults.add(sr);
//没有找到活4
//这个方法和上面的基本一样，但为了性能，少作几次判断，将人类和电脑的分开了
private Point doHumanSencondAnalysis(Map&Point,List&FirstAnalysisResult&& firstResults,List&SencondAnalysisResult& sencodResults) {
List&FirstAnalysisResult& list =
SencondAnalysisResult sr =
for (Point p : firstResults.keySet()) {
sr = new SencondAnalysisResult(p);
list = firstResults.get(p);
for (FirstAnalysisResult result : list) {
if(result.count==4){
if(result.aliveState==ALIVE){
human4Alives.add(sr);
sr.halfAlive4 ++;
human4HalfAlives.add(sr);
}else if(result.count==3){
if(result.aliveState==ALIVE){
sr.alive3++;
if(sr.alive3==1){
human3Alives.add(sr);
humanDouble3Alives.add(sr);
sr.halfAlive3++;
human3HalfAlives.add(sr);
sr.alive2++;
if(sr.alive2==1){
human2Alives.add(sr);
humanDouble2Alives.add(sr);
sencodResults.add(sr);
//没有找到活4
private void sleep(int miniSecond){
Thread.sleep(miniSecond);
} catch (InterruptedException e) {
//第三次分析，双方都不可以制造活4，找双活3棋子，不行就找半活4，再不行就找单活3，双活2
private Point doThirdAnalysis() {
if(!computer4HalfAlives.isEmpty()){
return computer4HalfAlives.get(0).
System.gc();
sleep(300);
Collections.sort(computerSencodResults);
System.gc();
//即将单活4，且我没有半活4以上的，只能堵
Point mostBest = getBestPoint(human4Alives, computerSencodResults);
if(mostBest!=null)
return mostB
Collections.sort(humanSencodResults);
System.gc();
mostBest = getBestPoint();
if(mostBest!=null)
return mostB
//拿出各自排第一的，谁好就下谁
return computerSencodResults.get(0).
//子类实现这个方法，并改变其顺序可以实现防守为主还是猛攻
protected Point getBestPoint(){
//即将单活4，且我没有半活4以上的，只能堵
Point mostBest = getBestPoint(computerDouble3Alives, humanSencodResults);
if(mostBest!=null)
return mostB
mostBest = getBestPoint(computer3Alives, humanSencodResults);
if(mostBest!=null)
return mostB
mostBest = getBestPoint(humanDouble3Alives, computerSencodResults);
if(mostBest!=null)
return mostB
mostBest = getBestPoint(human3Alives, computerSencodResults);
if(mostBest!=null)
return mostB
mostBest = getBestPoint(computerDouble2Alives, humanSencodResults);
if(mostBest!=null)
return mostB
mostBest = getBestPoint(computer2Alives, humanSencodResults);
if(mostBest!=null)
return mostB
mostBest = getBestPoint(computer3HalfAlives, humanSencodResults);
if(mostBest!=null)
return mostB
mostBest = getBestPoint(human4HalfAlives, computerSencodResults);
if(mostBest!=null)
return mostB
mostBest = getBestPoint(humanDouble2Alives, computerSencodResults);
if(mostBest!=null)
return mostB
mostBest = getBestPoint(human2Alives, computerSencodResults);
if(mostBest!=null)
return mostB
mostBest = getBestPoint(human3HalfAlives, computerSencodResults);
return mostB
//第三次分析的最后一步，第二次结果已经过排序，在此可以从前面选出最好的棋子
protected Point getBestPoint(List&SencondAnalysisResult& myBest,List&SencondAnalysisResult& yourSencodResults){
if(!myBest.isEmpty()){
if(myBest.size()&1){
for (SencondAnalysisResult your : yourSencodResults) {
if(myBest.contains(your)){
return your.
return myBest.get(0).
return myBest.get(0).
//第一次分析结果
private final Map&Point,List&FirstAnalysisResult&& computerFirstResults = new HashMap&Point,List&FirstAnalysisResult&&();
private final Map&Point,List&FirstAnalysisResult&& humanFirstResults = new HashMap&Point,List&FirstAnalysisResult&&();
//第二次总结果
protected final List&SencondAnalysisResult& computerSencodResults = new ArrayList&SencondAnalysisResult&();
protected final List&SencondAnalysisResult& humanSencodResults = new ArrayList&SencondAnalysisResult&();
//第二次分结果，电脑
protected final List&SencondAnalysisResult& computer4HalfAlives = new ArrayList&SencondAnalysisResult&(2);
protected final List&SencondAnalysisResult& computerDouble3Alives = new ArrayList&SencondAnalysisResult&(4);
protected final List&SencondAnalysisResult& computer3Alives = new ArrayList&SencondAnalysisResult&(5);
protected final List&SencondAnalysisResult& computerDouble2Alives = new ArrayList&SencondAnalysisResult&();
protected final List&SencondAnalysisResult& computer2Alives = new ArrayList&SencondAnalysisResult&();
protected final List&SencondAnalysisResult& computer3HalfAlives = new ArrayList&SencondAnalysisResult&();
//第二次分结果，人类
protected final List&SencondAnalysisResult& human4Alives = new ArrayList&SencondAnalysisResult&(2);
protected final List&SencondAnalysisResult& human4HalfAlives = new ArrayList&SencondAnalysisResult&(5);
protected final List&SencondAnalysisResult& humanDouble3Alives = new ArrayList&SencondAnalysisResult&(2);
protected final List&SencondAnalysisResult& human3Alives = new ArrayList&SencondAnalysisResult&(10);
protected final List&SencondAnalysisResult& humanDouble2Alives = new ArrayList&SencondAnalysisResult&(3);
protected final List&SencondAnalysisResult& human2Alives = new ArrayList&SencondAnalysisResult&();
protected final List&SencondAnalysisResult& human3HalfAlives = new ArrayList&SencondAnalysisResult&();
//第一次分析前清空上一步棋子的分析结果
private void initAnalysisResults(){
computerFirstResults.clear();
humanFirstResults.clear();
//第二次总结果
computerSencodResults.clear();
humanSencodResults.clear();
//第二次分结果
computer4HalfAlives.clear();
computerDouble3Alives.clear();
computer3Alives.clear();
computerDouble2Alives.clear();
computer2Alives.clear();
computer3HalfAlives.clear();
//第二次分结果，人类
human4Alives.clear();
human4HalfAlives.clear();
humanDouble3Alives.clear();
human3Alives.clear();
humanDouble2Alives.clear();
human2Alives.clear();
human3HalfAlives.clear();
System.gc();
//加入到第一次分析结果中
private void addToFirstAnalysisResult(FirstAnalysisResult result,Map&Point,List&FirstAnalysisResult&& dest){
if(dest.containsKey(result.point)){
dest.get(result.point).add(result);
List&FirstAnalysisResult& list = new ArrayList&FirstAnalysisResult&(1);
list.add(result);
dest.put(result.point, list);
//第一次分析结果类
private class FirstAnalysisResult{
int aliveS
private FirstAnalysisResult(int count, Point point, int direction) {
this(count, point, direction, ALIVE);
private FirstAnalysisResult(int count, Point point, int direction,int aliveState) {
this.count =
this.point =
this.direction =
this.aliveState = aliveS
private FirstAnalysisResult init(Point point,int direction,int aliveState){
this.count = 1;
this.point =
this.direction =
this.aliveState = aliveS
private FirstAnalysisResult cloneMe(){
return new FirstAnalysisResult(count, point, direction,aliveState);
//第二次分析结果类
class SencondAnalysisResult implements Comparable&SencondAnalysisResult&{
int alive4 = 0;
int alive3 = 0;
//半活4，一头封的
int halfAlive4 = 0;
//半活3，一头封的
int halfAlive3 = 0;
int alive2 = 0;
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((point == null) ? 0 : point.hashCode());
public boolean equals(Object obj) {
SencondAnalysisResult other = (SencondAnalysisResult)
if (point == null) {
if (other.point != null)
} else if (!point.equals(other.point))
private SencondAnalysisResult(Point point) {
this.point =
//第三次分析时，对第二次分析结果进行排序，此为排序回调函数
public int compareTo(SencondAnalysisResult another) {
return compareTowResult(this, another);
//返加-1则第一个参数优先，1则第二个参数优先，0则按原来顺序
private int compareTowResult(SencondAnalysisResult oneResult,SencondAnalysisResult another){
if(oneResult.alive4&another.alive4){
return -1;
if(oneResult.alive4&another.alive4){
if(oneResult.halfAlive4&another.halfAlive4){
return -1;
if(oneResult.halfAlive4&another.halfAlive4){
if(oneResult.alive3&another.alive3){
return -1;
if(oneResult.alive3&another.alive3){
if(oneResult.alive2&another.alive2){
return -1;
if(oneResult.alive2&another.alive2){
if(oneResult.halfAlive3&another.halfAlive3){
return -1;
if(oneResult.halfAlive3&another.halfAlive3){
//一个临时对象，供第一次分析时临时存放分析结果使用，如果分析出有活1以上（不含）的结果，则调用其cloneMe方法获得结果，否则抛弃此结果
private final FirstAnalysisResult far = new FirstAnalysisResult(1, null, HENG);
// 分析如果在当前位下一子，会形成某个方向上多少个子，参数：当前己方已下的所有点，当前要假设的点，需要判断的方向
private FirstAnalysisResult tryAndCountResult(List&Point& myPoints,List&Point& enemyPoints, Point point,int direction) {
int x = point.getX();
int y = point.getY();
FirstAnalysisResult fr =
int maxCountOnThisDirection = maxCountOnThisDirection(point, enemyPoints, direction, 1);
if(maxCountOnThisDirection&5){
//无意义的棋子
//此方向不足五个空位，已排除己方已下的棋子
}else if(maxCountOnThisDirection==5){
//半死状态，当是一头通
fr = far.init(point, direction,HALF_ALIVE);
//两头皆通
fr = far.init(point, direction,ALIVE);
//在前和后的方向上计算一次
countPoint(myPoints,enemyPoints,point.setX(x).setY(y),fr,direction,FORWARD);
countPoint(myPoints,enemyPoints,point.setX(x).setY(y),fr,direction,BACKWARD);
if(fr.count&=1 || (fr.count==2 && fr.aliveState==HALF_ALIVE)){//活1，半活2及其以下结果，抛弃
//返回复制的结果
return fr.cloneMe();
//棋子出了墙
private boolean isOutSideOfWall(Point point,int direction){
if(direction==HENG){
return point.getX()&0 || point.getX()&=maxX;//最大的X和Y值均在墙外所以用等号
}else if(direction==ZHONG){
return point.getY()&0 || point.getY()&=maxY;
}else{//这里可能有问题
return point.getX()&0 || point.getY()&0 || point.getX()&=maxX || point.getY()&=maxY;
private Point pointToNext(Point point,int direction,boolean forward){
switch (direction) {
case HENG:
if(forward)
point.x++;
point.x--;
case ZHONG:
if(forward)
point.y++;
point.y--;
case ZHENG_XIE:
if(forward){
point.x++;
point.y--;
point.x--;
point.y++;
case FAN_XIE:
if(forward){
point.x++;
point.y++;
point.x--;
point.y--;
//在某个方向（八个中的一个）可下多少棋子，这个方法是第一分析中的核心方法
private void countPoint(List&Point& myPoints, List&Point& enemyPoints, Point point, FirstAnalysisResult fr,int direction,boolean forward) {
if(myPoints.contains(pointToNext(point,direction,forward))){
fr.count ++;
if(myPoints.contains(pointToNext(point,direction,forward))){
fr.count ++;
if(myPoints.contains(pointToNext(point,direction,forward))){
fr.count ++;
if(myPoints.contains(pointToNext(point,direction,forward))){
fr.count ++;
}else if(enemyPoints.contains(point) || isOutSideOfWall(point,direction)){
fr.aliveState=HALF_ALIVE;
}else if(enemyPoints.contains(point) || isOutSideOfWall(point,direction)){
fr.aliveState=HALF_ALIVE;
}else if(enemyPoints.contains(point) || isOutSideOfWall(point,direction)){
fr.aliveState=HALF_ALIVE;
}else if(enemyPoints.contains(point) || isOutSideOfWall(point,direction)){
fr.aliveState=HALF_ALIVE;
//在某个方向上是否还能下到满五个棋子
private int maxCountOnThisDirection(Point point,List&Point& enemyPoints,int direction,int count){
int x=point.getX(),y=point.getY();
switch (direction) {
case HENG:
while (!enemyPoints.contains(point.setX(point.getX()-1)) && point.getX()&=0 && count&6) {
point.setX(x);
while (!enemyPoints.contains(point.setX(point.getX()+1)) && point.getX()&maxX && count&6) {
case ZHONG:
while (!enemyPoints.contains(point.setY(point.getY()-1)) && point.getY()&=0) {
point.setY(y);
while (!enemyPoints.contains(point.setY(point.getY()+1)) && point.getY()&maxY && count&6) {
//正斜向 /
case ZHENG_XIE:
while (!enemyPoints.contains(point.setX(point.getX()-1).setY(point.getY()+1)) && point.getX()&=0 && point.getY()&maxY) {
point.setX(x).setY(y);
while (!enemyPoints.contains(point.setX(point.getX()+1).setY(point.getY()-1)) && point.getX()&maxX && point.getY()&=0 && count&6) {
case FAN_XIE:
while (!enemyPoints.contains(point.setX(point.getX()-1).setY(point.getY()-1)) && point.getX()&=0 && point.getY()&=0) {
point.setX(x).setY(y);
while (!enemyPoints.contains(point.setX(point.getX()+1).setY(point.getY()+1)) && point.getX()&maxX && point.getY()&maxY && count&6) {
//下棋子，对外接口
public void run(List&Point& humans,Point p) {
//把人类下的最后一步棋子去除
allFreePoints.remove(humans.get(humans.size()-1));
//电脑可以下的一步棋子
Point result = doAnalysis(myPoints, humans);
//去除电脑下的棋子
allFreePoints.remove(result);
//加入到电脑棋子中，下棋了
myPoints.add(result);
人类玩家实现起来就非常简单
import java.util.L
public class HumanPlayer extends BasePlayer {
public void run(List&Point& enemyPoints,Point p) {
getMyPoints().add(p);
allFreePoints.remove(p);
总结：虽然是Java写的但算法已被抽象可以方便的修改成各种平台的实现。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具}