java写五子棋人机对弈五子棋java实现

转载

墨香四溢 2024-01-24 12:15:44

文章标签 java写五子棋人机对弈 java五子棋教程 java 权值数组 文章分类 Java 后端开发

1.需求分析

无论我们使用什么语言，去编写一个什么样的项目，我们的第一步，总是去分析这个项目需要满足怎样的需求。

五子棋需要满足什么需求呢，首先我们要有确定打算下棋的界面，还要有实现下棋的功能，下了棋子以后还要可以进行判断输赢。之后我们就要扩展游戏的功能了，比如创建新游戏，悔棋，认输，人机对战，人人对战等等。这些功能实现后就可以完成整个五子棋程序了。

2.实现步奏

(1)界面构建

那么，首先我们开始构建基础的界面，构建界面要分成实现按钮功能的区域和下棋的区域，因此我们最好使用java语言中分离界面的布局BorderLayout，然后分别对两侧再次添加布局。

首先建好界面

然后添加BorderLayout布局，在分别在BorderLayout布局的中间和东边添加流体布局一侧放按钮一侧准备画棋盘。(此处棋盘部分我的主界面类是继承了布局jpanel因此直接使用add即可)

然后就是在两部分分别添加按钮了。我在此处选择添加开始游戏，悔棋和认输三个游戏操作型按钮，人人对战，人机对战，电脑执黑和电脑执白4个游戏类型按钮。因为人人对战和人机对战与电脑执黑和执白各只能选择一个，因此我在这里设置ButtonGroup组来进行选择判断。(我给人人对战和电脑执白设成默认，此处listener是事件监听机制可以以后再写)

这样在给主界面设成可见后就有如下结果了。

接下来我们要构建棋盘了，五子棋一般为15*15的位置，因此横竖各需要14条线，并且我们的棋盘也应该像按钮一样可以进行重绘因此我们就可以将他们写在paint方法中

就可以得到如下棋盘样式咯。

(2)下棋基本功能实现

首先我们要理解棋子本质，棋子其实就是我们在棋盘上画的圆，黑子白子就是分别将画笔设置成黑色和白色后调用画填充圆的函数后在交叉处画的。

因此首先我们要建立一个鼠标监听机制。(我将鼠标监听和按钮监听放到一起)

再重写事件监听方法

给主界面添加事件监听

这样就构建好了事件监听机制，但是因为我们要画图所以需要得到画笔

这样就可以通过调用fillOval画圆了。

然后我们通过鼠标点击进行下棋，通过e.getX()和e.getY()来获取坐标值因为我们要保证我们的棋子要准确落在交叉点上因而要通过除以格子长度在乘以格子长度消除余数的影响。

这样就可以确保棋子落在交叉点上了。

然后我们要保证黑白棋交错下棋，那么我们就必须要一个黑棋还是白棋的判断，我在这里使用了一个整数类型的flag，flag初始为零，为零时黑棋下子，下子后flag+1；为1时白棋下子，下子后flag-1；同样记得设置画笔的颜色。

这样我们搞定了黑白棋但是在一个位置上还存在可以下多个棋子的问题，要解决这个问题我们必须对棋子位置进行存储来判断是否有棋子在鼠标点击的位置，因为棋盘相当于15*15的点，因此我们使用15*15的数组进行存储

每次下完棋子后将棋子数据传入二维数组中(我在此处将没有棋子设为0，白棋设为1，黑棋设为6)

这样我们就搞定了同一位置下棋的问题

同时我们也可以将已经存储好的位置传递到主界面中的paint方法里实现重绘。

在监听器中构建将坐标数组传递的函数

在主界面中构建存储的变量

调用监听器中数组传递的函数得到坐标值

改写画棋盘的方法在画棋盘的同时画上已经存在的棋子

然后就到了判断棋子胜负的问题我在此处给予2种方法

(1)全局判断：通过扫描各个横行，竖行，左右斜行5个5个来进行判断如果棋子累加达到目标值就可以认为存在5颗相同棋子相连(一个白棋为1，5个白棋相加为5；一个黑棋为6，5个黑棋相加为30因而不可能出现其他情况导致累加和达到目标值)

(2)对所有有棋子的位置进行判断：只判断有棋子的点周围是否可以出现5颗相连

这样简单的人人对战就基本上相当于做好了。

(3)下棋强化功能的实现

1.胜负后的情节：一般我们胜利后都要出现个强调框来显得胜负的不易，因此我们也最好使用新的窗体来实现(因为胜负未判断，所以窗体先设置成不可见，为了程序简单我们可以把新的窗体和旧的放在一起)

记得将界面和结果的按钮传到监听器中，我在这里直接改写构造函数

(f为输入的黑白棋在loc中的值如刚才默认的白棋为1黑棋为6)胜利出现后将新窗体可见并且在按钮上放上结果。

同时认输也就是同样的情况只是加上判断现在是轮到那一方下棋；flag为0时轮到黑棋下，黑棋认输相当于白棋胜利；flag为1时轮到白棋下，白棋认输相当于黑棋胜利.。

这样我们就可以在判断胜负后在新的界面上输出结果了。

2.构建新棋局：我们在新窗体和旧窗体的按钮都设置了开始游戏，并且在点击人人对战时都需要构建新棋局。

要构建新棋局就要将已经有的棋局无论是图形还是数据都要清除。先清除存储棋子的二位数组清零，同时将下棋的一方改为黑棋，即flag清零，游戏的结果也要清零，之后调用主界面的repaint()函数重新画图消去已经有的棋子重新开始，如：

结果如下

3.悔棋：悔棋是我们经常用的功能，因此也必须做出来。悔棋要退到上一步，因此就需要判断最后一步，甚至几步将他们那几点的数据清空，图形重画，flag倒退一步，其实就相当于开始新游戏的改进。

结果如下

4.人机对战：实现了以上功能就相当于已经解决了人人对战的用法了，然后就到了实现人机对战了。我们在这里采用的人机对战是权值人工智能算法，相当于一个简易的人工智能了。

那么我们就要有构建对应的权值表。因为我们棋子的位置使用二位数组保存的因此我们如果不打算进行每种情况的仔细计算的话最好用数字构成的字符传来表示棋子情况。而我们的人工智能是对没有棋子的位置进行处理的因此不能判断棋子不相连的情况。每个棋子有8个方向到没有棋子或者棋子被阻断共有如下表中可能构建权值表。并构建权值对应的权值表来存储每一点的全职情况

构建好表格后就要构建ai算法对每一个空位周围8个方向判断后将8个方向的权值累加并放入权值数组中，选择数组中权值最大的位置下棋。并且如果选择人机模式，我们下完棋的立刻运行电脑下棋。

我们下完后判断胜利，在运行电脑下棋并判断电脑是否胜利。

这样我们就搞定的人机对战，如果你想要电脑执黑的话就可以先随机下一颗黑棋，再到我们下棋，然后电脑下棋。

这样一个简易的五子棋就完成了。

3.最后附上所有代码

第一个类

package 五子棋2;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
public class Main extends JPanel {
public static void main(String[] args) {
Main m = new Main();
m.initUI();
}
private int [][]loca=new int[15][15];
private Color heiqi=new Color(0,0,0);
private Color baiqi=new Color(255,255,255);
private void initUI() {
JFrame frame2 = new JFrame();
frame2.setTitle("比赛结束");
frame2.setSize(500, 500);
frame2.setDefaultCloseOperation(3);//关闭就退出
frame2.setLocationRelativeTo(null);
frame2.setResizable(false);//大小不可变
JPanel jp=new JPanel();
jp.setBackground(Color.LIGHT_GRAY);
frame2.add(jp);
JButton buttonover=new JButton("继续研究棋面");
buttonover.setPreferredSize(new Dimension(200, 100));
jp.add(buttonover);
JButton buttonnew=new JButton("开始新游戏");
buttonnew.setPreferredSize(new Dimension(200, 100));
jp.add(buttonnew);
JButton buttonresult=new JButton("");
buttonresult.setPreferredSize(new Dimension(400, 400));
buttonresult.setFont(new Font("宋体",Font.BOLD,50));
jp.add(buttonresult);
frame2.setVisible(false);
JFrame frame = new JFrame();
frame.setTitle("五子棋");
frame.setSize(1000, 780);
frame.setDefaultCloseOperation(3);//关闭就退出
frame.setLocationRelativeTo(null);
frame.setResizable(false);//大小不可变
BorderLayout bl=new BorderLayout();
frame.setLayout(bl);
this.setBackground(Color.LIGHT_GRAY);
JPanel eastPanel = new JPanel(); //流体布局
eastPanel.setPreferredSize(new Dimension(250, 0));// 设置面板的大小高度因为没有南北因而固定
eastPanel.setBackground(Color.GRAY);
frame.add(eastPanel,BorderLayout.EAST);
listener ll=new listener(this,frame2,buttonresult);
JButton buttonStart=new JButton("开始游戏");
buttonStart.setPreferredSize(new Dimension(200, 100));
eastPanel.add(buttonStart);
buttonStart.addActionListener(ll);
JButton buttonBack=new JButton("悔棋");
buttonBack.setPreferredSize(new Dimension(200, 100));
eastPanel.add(buttonBack);
buttonBack.addActionListener(ll);
JButton buttonGiveup=new JButton("认输");
buttonGiveup.setPreferredSize(new Dimension(200, 100));
eastPanel.add(buttonGiveup);
buttonGiveup.addActionListener(ll);
ButtonGroup bg=new ButtonGroup();
JRadioButton buttonPVP=new JRadioButton("人人对战");
buttonPVP.setPreferredSize(new Dimension(200, 100));
buttonPVP.setOpaque(false);
JRadioButton buttonPVE=new JRadioButton("人机对战");
buttonPVE.setPreferredSize(new Dimension(200, 100));
buttonPVE.setOpaque(false);
bg.add(buttonPVP);
bg.add(buttonPVE);
buttonPVP.setSelected(true);
eastPanel.add(buttonPVP);
eastPanel.add(buttonPVE);
JRadioButton PVHE=new JRadioButton("电脑执黑");
PVHE.setPreferredSize(new Dimension(200, 100));
PVHE.setOpaque(false);
JRadioButton PVBE=new JRadioButton("电脑执白");
PVBE.setPreferredSize(new Dimension(200, 100));
PVBE.setOpaque(false);
ButtonGroup bg2=new ButtonGroup();
PVBE.setSelected(true);
bg2.add(PVHE);
bg2.add(PVBE);
eastPanel.add(PVHE);
eastPanel.add(PVBE);
PVHE.addActionListener(ll);
PVBE.addActionListener(ll);
buttonPVE.addActionListener(ll);
buttonPVP.addActionListener(ll);
frame.setVisible(true);
this.addMouseListener(ll);
ll.gethb(this.getGraphics());
loca=ll.getloc();
buttonover.addActionListener(ll);
buttonnew.addActionListener(ll);
}
public void getloc(int [][] x) {
loca=x;
}
public void paint(Graphics g) {
super.paint(g);// super表示父类的对象，super.paint(g)表示调用父类中的paint方法
drawCheeBorder(g);
}
private void drawCheeBorder(Graphics g) {
for (int i=0;i<15;i++){
g.drawLine(25,25+50*i,25+700,25+50*i);// 绘制横线
g.drawLine(25+50*i,25,25+50*i,25+700);// 绘制竖线
}
for (int i=0;i<15;i++){
for (int j=0;j<15;j++){
if(loca[i][j]==6){
g.setColor(heiqi);
g.fillOval(15+i*50, 15+j*50, 20, 20);
}
else if(loca[i][j]==1){
g.setColor(baiqi);
g.fillOval(15+i*50, 15+j*50, 20, 20);
}
}
}
}
}
第二个类
package 五子棋2;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseWheelEvent;
import java.util.HashMap;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
public class listener extends MouseAdapter implements ActionListener{
private String gameresult="";
private Graphics2D gr;
private Graphics2D ng;
private Main m;
private JFrame n;
private int [][] loc=new int[15][15]; //最后一位【1】棋子颜色白【6】棋子颜色黑【0】判断棋子不存在
private int flag=0;
private Color heiqi=new Color(0,0,0);
private Color baiqi=new Color(255,255,255);
private int lastbux[]=new int[255],lastbuy[]=new int[225];
private int number=0;
private String gametype="人人对战";
private String gameway="电脑执白";
private int [][] valueloc=new int[15][15];
private HashMaphm=new HashMap();
public JButton jw;
public int [][] getloc(){
return loc;
}
public void sethashmap(){
hm.put("",1);
hm.put("6",2);
hm.put("66",3);
hm.put("666",100);
hm.put("6666",1000);
hm.put("61",1);
hm.put("661",1);
hm.put("6661",10);
hm.put("66661",1000);
hm.put("1",3);
hm.put("11",100);
hm.put("111",200);
hm.put("1111",2000);
hm.put("16",1);
hm.put("116",10);
hm.put("1116",100);
hm.put("11116",2000);
}
public void sethashmap2(){
hm.put("11111",1000000);
hm.put("66666",1000000);
hm.put("111116",1000000);
hm.put("666661",1000000);
hm.put("611111",1000000);
hm.put("166666",1000000);
hm.put("6111116",1000000);
hm.put("1666661",1000000);
hm.put("1111",100000);
hm.put("6666",100000);
hm.put("11116",100000);
hm.put("66661",100000);
hm.put("61111",100000);
hm.put("16666",100000);
hm.put("611116",100000);
hm.put("166661",100000);
hm.put("11116+11116",10000);
hm.put("66661+66661",10000);
hm.put("11116+66661",10000);
hm.put("11116+111",10000);
hm.put("66661+666",10000);
hm.put("111+1116",10000);
hm.put("666+66661",10000);
hm.put("111+66661",10000);
hm.put("11116+666",10000);
hm.put("111+111",5000);
hm.put("666+666",5000);
hm.put("111+666",5000);
hm.put("1116+111",1000);
hm.put("6661+666",1000);
hm.put("111+1116",1000);
hm.put("666+6661",1000);
hm.put("1116+666",1000);
hm.put("111+6661",1000);
hm.put("11116",500);
hm.put("66661",500);
hm.put("111",200);
hm.put("666",200);
hm.put("11+11",100);
hm.put("66+66",100);
hm.put("11+66",100);
hm.put("1116",50);
hm.put("6661",50);
hm.put("16+16",10);
hm.put("61+61",10);
hm.put("16+61",10);
hm.put("11",5);
hm.put("66",5);
hm.put("1",0);
hm.put("6",0);
}
public void gethb(Graphics g) {
this.gr=(Graphics2D)g;
System.out.println(">>>>>");
}
public void gethb2(Graphics g) {
this.ng=(Graphics2D)g;
ng.setFont(new Font("宋体",Font.BOLD,50));
System.out.println(">>>>>");
}
public listener(Main x,JFrame y,JButton w) {
this.m =x;
this.n =y;
this.jw=w;
}
public void actionPerformed(ActionEvent e){
if(e.getActionCommand().equalsIgnoreCase("开始游戏")){
System.out.println(e.getActionCommand());
for (int i=0;i<15;i++){
for (int j=0;j<15;j++){
loc[i][j]=0;
}
}
flag=0;
m.repaint();
number=0;
gameresult="";
}
else if(e.getActionCommand().equalsIgnoreCase("悔棋")){
System.out.println(e.getActionCommand());
if(this.gametype.equals("人人对战")){
if(number>0){
loc[lastbux[number-1]][lastbuy[number-1]]=0;
number--;
}
if(this.flag==0)
flag++;
else if(this.flag==1)
flag--;
}
if(this.gametype.equals("人机对战")){
if(number>0){
loc[lastbux[number-1]][lastbuy[number-1]]=0;
loc[lastbux[number-2]][lastbuy[number-2]]=0;
number--;
number--;
}
}
m.repaint();
gameresult="";
}
else if(e.getActionCommand().equalsIgnoreCase("认输")){
System.out.println(e.getActionCommand());
if(flag==0)
victory(1);
if(flag==1)
victory(6);
for (int i=0;i<15;i++){
for (int j=0;j<15;j++){
loc[i][j]=0;
}
}
number=0;
}
if(e.getActionCommand().equalsIgnoreCase("继续研究棋面")){
System.out.println(e.getActionCommand());
n.setVisible(false);
for (int i=0;i<15;i++){
for (int j=0;j<15;j++){
if(loc[i][j]==0)
loc[i][j]=100;
}
}
}
else if(e.getActionCommand().equalsIgnoreCase("开始新游戏")){
System.out.println(e.getActionCommand());
n.setVisible(false);
for (int i=0;i<15;i++){
for (int j=0;j<15;j++){
loc[i][j]=0;
}
}
flag=0;
m.repaint();
gameresult="";
number=0;
}
else if(e.getActionCommand().equalsIgnoreCase("人人对战")){
System.out.println(e.getActionCommand());
this.gametype="人人对战";
for (int i=0;i<15;i++){
for (int j=0;j<15;j++){
loc[i][j]=0;
}
}
flag=0;
m.repaint();
number=0;
gameresult="";
}
else if(e.getActionCommand().equalsIgnoreCase("人机对战")){
System.out.println(e.getActionCommand());
this.gametype="人机对战";
for (int i=0;i<15;i++){
for (int j=0;j<15;j++){
loc[i][j]=0;
}
}
flag=0;
m.repaint();
number=0;
this.sethashmap2();
gameresult="";
}
if((e.getActionCommand().equalsIgnoreCase("电脑执白")&&this.gametype=="人机对战")||(e.getActionCommand().equalsIgnoreCase("人机对战")&&this.gameway=="电脑执白")){
System.out.println(e.getActionCommand());
this.gameway="电脑执白";
for (int i=0;i<15;i++){
for (int j=0;j<15;j++){
loc[i][j]=0;
}
}
flag=0;
m.repaint();
number=0;
this.sethashmap2();
gameresult="";
}
else if((e.getActionCommand().equalsIgnoreCase("电脑执黑")&&this.gametype=="人机对战")||(this.gameway=="电脑执黑"&&this.gametype=="人机对战"&&(e.getActionCommand().equalsIgnoreCase("人机对战")||e.getActionCommand().equalsIgnoreCase("开始新游戏")||e.getActionCommand().equalsIgnoreCase("开始游戏")))){
System.out.println(e.getActionCommand());
this.gameway="电脑执黑";
for (int i=0;i<15;i++){
for (int j=0;j<15;j++){
loc[i][j]=0;
}
}
flag=0;
m.repaint();
number=0;
this.sethashmap2();
gameresult="";
int x1=(int)(-Math.random()*4+9);
int y1=(int)(-Math.random()*4+9);
gr.setColor(heiqi);
loc[x1][y1]=6;
flag++;
System.out.println(x1+">>>>>"+y1);
gr.fillOval(15+x1*50, 15+y1*50, 20, 20);
}
}
private void victory(int f){ //f=0白棋赢f=1黑棋赢
n.setVisible(true);
this.gethb2(n.getGraphics());
if(f==1)
{
System.out.println("白棋胜利");
gameresult="白棋胜利";
}
else if(f==6){
System.out.println("黑棋胜利");
flag--;
gameresult="黑棋胜利";
}
jw.setText(gameresult);
n.setTitle(gameresult);
}
private void match(){
for(int j=0;j<15;j++) //判断列胜利
for(int i=0;i<11;i++){
int result=loc[i][j]+loc[i+1][j]+loc[i+2][j]+loc[i+3][j]+loc[i+4][j];
if(result==5)
System.out.println("白棋胜利");
if(result==30)
System.out.println("黑棋胜利");
}
for(int j=0;j<15;j++) //判断行胜利
for(int i=0;i<11;i++){
int result=loc[j][i]+loc[j][i]+loc[j][i+2]+loc[j][i+3]+loc[j][i+4];
if(result==5)
System.out.println("白棋胜利");
if(result==30)
System.out.println("黑棋胜利");
}
for(int i=4;i<=14;i++){
for(int j=0;j<=i-4;j++){
int result=loc[j][i-j]+loc[j+1][i-j-1]+loc[j+2][i-j-2]+loc[j+3][i-j-3]+loc[j+4][i-j-4];
if(result==5)
System.out.println("白棋胜利");
if(result==30)
System.out.println("黑棋胜利");
}
}
for(int w=24;w>=15;w--){
for(int j=10;j>=w-14;j--){
int i=w-j;
int result=loc[j][i]+loc[j+1][i-1]+loc[j+2][i-2]+loc[j+3][i-3]+loc[j+4][i-4];
if(result==5)
System.out.println("白棋胜利");
if(result==30)
System.out.println("黑棋胜利");
}
}
for(int w=10;w>=0;w--){
for(int j=w;j<=10;j++){
int i=j-w;
int result=loc[j][i]+loc[j+1][i+1]+loc[j+2][i+2]+loc[j+3][i+3]+loc[j+4][i+4];
if(result==5)
System.out.println("白棋胜利");
if(result==30)
System.out.println("黑棋胜利");
}
}
for(int w=10;w>0;w--){
for(int j=w;j<=10;j++){
int i=j-w;
int result=loc[i][j]+loc[i+1][j+1]+loc[i+2][j+2]+loc[i+3][j+3]+loc[i+4][j+4];
if(result==5)
System.out.println("白棋胜利");
if(result==30)
System.out.println("黑棋胜利");
}
}
}
private void match2(){
for(int i=0;i<=14;i++)
for(int j=0;j<=14;j++){
if(loc[i][j]!=0){
int a=hpd(i,j,loc[i][j]);
int b=lpd(i,j,loc[i][j]);
int c=zxpd(i,j,loc[i][j]);
int d=yxpd(i,j,loc[i][j]);
if(a==1||b==1||c==1||d==1)
victory(1);
if(a==6||b==6||c==6||d==6)
victory(6);
}
}
}
private int lpd(int x,int y,int r) {
int chass=0;
for(int i=y+1;i
{
if(loc[x][i]==r)
chass++;
else
break;
}
for(int i=y;i>=0;i--)
{
if(loc[x][i]==r)
chass++;
else
break;
}
if(chass>=5){
if(r==6){
System.out.println("黑棋胜利");
return 6;
}
if(r==1){
System.out.println("白棋胜利");
return 1;
}
}
return 0;
}
private int zxpd(int x,int y,int r) {
int chass=0,cxx=0;
for(int i=x;i>=0&&y-cxx>=0;i--)
{
if(loc[i][y-cxx]==r){
cxx++;
chass++;
}
else
break;
}
cxx=1;
for(int i=x+1;i
{
if(loc[i][y+cxx]==r){
cxx++;
chass++;
}
else
break;
}
if(chass>=5){
if(r==6){
System.out.println("黑棋胜利");
return 6;
}
if(r==1){
System.out.println("白棋胜利");
return 1;
}
}
return 0;
}
private int yxpd(int x,int y,int r) {
int chass=0,cxx=0;
for(int i=x;i>=0&&y+cxx
{
if(loc[i][y+cxx]==r){
cxx++;
chass++;
}
else
break;
}
cxx=1;
for(int i=x+1;i=0;i++)
{
if(loc[i][y-cxx]==r){
cxx++;
chass++;
}
else
break;
}
if(chass>=5){
if(r==6){
System.out.println("黑棋胜利");
return 6;
}
if(r==1){
System.out.println("白棋胜利");
return 1;
}
}
return 0;
}
private int hpd(int x,int y,int r) {
int chass=0;
for(int i=x+1;i
{
if(loc[i][y]==r)
chass++;
else
break;
}
for(int i=x;i>=0;i--)
{
if(loc[i][y]==r)
chass++;
else
break;
}
if(chass>=5){
if(r==6){
System.out.println("黑棋胜利");
return 6;
}
if(r==1){
System.out.println("白棋胜利");
return 1;
}
}
return 0;
}
private void AI(){ //权值算法
for(int i=0;i
for(int j=0;j
if(loc[i][j]==0){
String chess="";
int color=0;
for(int k=i+1;k
if(loc[k][j]==0)
break;
else{
if(color==0){
chess+=loc[k][j];
color=loc[k][j];
//System.out.println("<<<<
}
else if(color==loc[k][j]){
chess+=loc[k][j];
//System.out.println("<<<<
}
else{
chess+=loc[k][j];
//System.out.println("<<<<
break;
}
}
}
// System.out.println("<<<<
Integer value=hm.get(chess);
// System.out.println("<<<<
if(value!=null){
valueloc[i][j]+=value;
}
chess="";
color=0;
for(int k=i-1;k>=0;k--){//左搜索
if(loc[k][j]==0)
break;
else{
if(color==0){
chess+=loc[k][j];
color=loc[k][j];
}
else if(color==loc[k][j]){
chess+=loc[k][j];
}
else{
chess+=loc[k][j];
break;
}
}
}
value=hm.get(chess);
if(value!=null){
valueloc[i][j]+=value;
}
chess="";
color=0;
for(int k=j+1;k
if(loc[i][k]==0)
break;
else{
if(color==0){
chess+=loc[i][k];
color=loc[i][k];
//System.out.println("<<<<
}
else if(color==loc[i][k]){
chess+=loc[i][k];
//System.out.println("<<<<
}
else{
chess+=loc[i][k];
//System.out.println("<<<<
break;
}
}
}
// System.out.println("<<<<
value=hm.get(chess);
// System.out.println("<<<<
if(value!=null){
valueloc[i][j]+=value;
}
chess="";
color=0;
for(int k=j-1;k>=0;k--){//下搜索
if(loc[i][k]==0)
break;
else{
if(color==0){
chess+=loc[i][k];
color=loc[i][k];
}
else if(color==loc[i][k]){
chess+=loc[i][k];
}
else{
chess+=loc[i][k];
break;
}
}
}
value=hm.get(chess);
if(value!=null){
valueloc[i][j]+=value;
}
chess="";
color=0;
int jianbian=1;
for(int k=i+1;k
if(loc[k][j+jianbian]==0)
break;
else{
if(color==0){
chess+=loc[k][j+jianbian];
color=loc[k][j+jianbian];
}
else if(color==loc[k][j+jianbian]){
chess+=loc[k][j+jianbian];
}
else{
chess+=loc[k][j+jianbian];
break;
}
}
jianbian++;
}
value=hm.get(chess);
if(value!=null){
valueloc[i][j]+=value;
}
chess="";
color=0;
jianbian=1;
for(int k=i-1;k>=0&&j-jianbian>=0;k--){//右斜下搜索
if(loc[k][j-jianbian]==0)
break;
else{
if(color==0){
chess+=loc[k][j-jianbian];
color=loc[k][j-jianbian];
}
else if(color==loc[k][j-jianbian]){
chess+=loc[k][j-jianbian];
}
else{
chess+=loc[k][j-jianbian];
break;
}
}
jianbian++;
}
value=hm.get(chess);
if(value!=null){
valueloc[i][j]+=value;
}
chess="";
color=0;
jianbian=1;
for(int k=j+1;k=0;k++){//右斜上搜索
if(loc[i-jianbian][k]==0)
break;
else{
if(color==0){
chess+=loc[i-jianbian][k];
color=loc[i-jianbian][k];
}
else if(color==loc[i-jianbian][k]){
chess+=loc[i-jianbian][k];
}
else{
chess+=loc[i-jianbian][k];
break;
}
}
jianbian++;
}
value=hm.get(chess);
if(value!=null){
valueloc[i][j]+=value;
}
chess="";
color=0;
jianbian=1;
for(int k=j-1;k>=0&&i+jianbian
if(loc[i+jianbian][k]==0)
break;
else{
if(color==0){
chess+=loc[i+jianbian][k];
color=loc[i+jianbian][k];
}
else if(color==loc[i+jianbian][k]){
chess+=loc[i+jianbian][k];
}
else{
chess+=loc[i+jianbian][k];
break;
}
}
jianbian++;
}
value=hm.get(chess);
if(value!=null){
valueloc[i][j]+=value;
}
chess="";
color=0;
jianbian=1;
}
}
}
int maxx=0,maxy=0,maxvalue=0;
for(int i=0;i
for(int j=0;j
System.out.print(valueloc[i][j]+" ");
if(maxvalue<=valueloc[i][j]){
maxx=i;
maxy=j;
maxvalue=valueloc[i][j];
}
valueloc[i][j]=0;
}
System.out.println();
}

if(flag==0){
gr.setColor(heiqi);
loc[maxx][maxy]=6;
flag++;
}
else{
gr.setColor(baiqi);
loc[maxx][maxy]=1;
flag--;
}
lastbux[number]=maxx;
lastbuy[number]=maxy;
number++;
System.out.println(maxx+">>>>>"+maxy);
gr.fillOval(15+maxx*50, 15+maxy*50, 20, 20);
}
private void AI2(){ //博弈树算法
for(int i=0;i
for(int j=0;j
if(loc[i][j]==0){
String []nchess=new String[8];
String chess="";
int color=0;
for(int k=i+1;k
if(loc[k][j]==0)
break;
else{
if(color==0){
chess+=loc[k][j];
color=loc[k][j];
//System.out.println("<<<<
}
else if(color==loc[k][j]){
chess+=loc[k][j];
//System.out.println("<<<<
}
else{
chess+=loc[k][j];
//System.out.println("<<<<
break;
}
}
}
// System.out.println("<<<<
nchess[0]=chess;
chess="";
color=0;
for(int k=i-1;k>=0;k--){//左搜索
if(loc[k][j]==0)
break;
else{
if(color==0){
chess+=loc[k][j];
color=loc[k][j];
}
else if(color==loc[k][j]){
chess+=loc[k][j];
}
else{
chess+=loc[k][j];
break;
}
}
}
nchess[1]=chess;
chess="";
color=0;
for(int k=j+1;k
if(loc[i][k]==0)
break;
else{
if(color==0){
chess+=loc[i][k];
color=loc[i][k];
//System.out.println("<<<<
}
else if(color==loc[i][k]){
chess+=loc[i][k];
//System.out.println("<<<<
}
else{
chess+=loc[i][k];
//System.out.println("<<<<
break;
}
}
}
nchess[2]=chess;
chess="";
color=0;
for(int k=j-1;k>=0;k--){//下搜索
if(loc[i][k]==0)
break;
else{
if(color==0){
chess+=loc[i][k];
color=loc[i][k];
}
else if(color==loc[i][k]){
chess+=loc[i][k];
}
else{
chess+=loc[i][k];
break;
}
}
}
nchess[3]=chess;
chess="";
color=0;
int jianbian=1;
for(int k=i+1;k
if(loc[k][j+jianbian]==0)
break;
else{
if(color==0){
chess+=loc[k][j+jianbian];
color=loc[k][j+jianbian];
}
else if(color==loc[k][j+jianbian]){
chess+=loc[k][j+jianbian];
}
else{
chess+=loc[k][j+jianbian];
break;
}
}
jianbian++;
}
nchess[4]=chess;
chess="";
color=0;
jianbian=1;
for(int k=i-1;k>=0&&j-jianbian>=0;k--){//右斜下搜索
if(loc[k][j-jianbian]==0)
break;
else{
if(color==0){
chess+=loc[k][j-jianbian];
color=loc[k][j-jianbian];
}
else if(color==loc[k][j-jianbian]){
chess+=loc[k][j-jianbian];
}
else{
chess+=loc[k][j-jianbian];
break;
}
}
jianbian++;
}
nchess[5]=chess;
chess="";
color=0;
jianbian=1;
for(int k=j+1;k=0;k++){//右斜上搜索
if(loc[i-jianbian][k]==0)
break;
else{
if(color==0){
chess+=loc[i-jianbian][k];
color=loc[i-jianbian][k];
}
else if(color==loc[i-jianbian][k]){
chess+=loc[i-jianbian][k];
}
else{
chess+=loc[i-jianbian][k];
break;
}
}
jianbian++;
}
nchess[6]=chess;
chess="";
color=0;
jianbian=1;
for(int k=j-1;k>=0&&i+jianbian
if(loc[i+jianbian][k]==0)
break;
else{
if(color==0){
chess+=loc[i+jianbian][k];
color=loc[i+jianbian][k];
}
else if(color==loc[i+jianbian][k]){
chess+=loc[i+jianbian][k];
}
else{
chess+=loc[i+jianbian][k];
break;
}
}
jianbian++;
}
nchess[7]=chess;
chess="";
color=0;
jianbian=1;
String []heichess=new String[8];
String []baichess=new String[8];
String []hchess=new String[4];
String []bchess=new String[4];
for(int m=7;m>=0;m--){
baichess[m]="1"+nchess[m];
Integer value=hm.get(baichess[m]);
if(value!=null){
valueloc[i][j]+=value;
}
}
for(int m=7;m>0;m--){
for(int n=m-1;n>=0;n--){
Integer value=hm.get(baichess[m]+"+"+baichess[n]);
if(value!=null){
valueloc[i][j]+=value;
}
}
}
for(int m=7;m>=0;m--){
heichess[m]="6"+nchess[m];
Integer value=hm.get(heichess[m]);
if(value!=null){
valueloc[i][j]+=value;
}
}
for(int m=7;m>0;m--){
for(int n=m-1;n>=0;n--){
Integer value=hm.get(heichess[m]+"+"+heichess[n]);
if(value!=null){
valueloc[i][j]+=value;
}
}
}
for(int m=7;m>0;m--){
for(int n=7;n>0;n--){
Integer value=hm.get(baichess[m]+"+"+heichess[n]);
if(value!=null){
valueloc[i][j]+=value;
}
}
}
hchess[0]=heichess[0]+heichess[1];
hchess[1]=heichess[2]+heichess[3];
/* hchess[2]=heichess[4]+heichess[6];
hchess[3]=heichess[7]+heichess[5];*/
bchess[0]=baichess[0]+baichess[1];
bchess[1]=baichess[2]+baichess[3];
/* bchess[2]=baichess[4]+baichess[6];
bchess[3]=baichess[7]+baichess[5];*/
for(int m=3;m>0;m--){
Integer value=hm.get(bchess[m]);
if(value!=null){
valueloc[i][j]+=value;
}
value=hm.get(hchess[m]);
if(value!=null){
valueloc[i][j]+=value;
}
}
}
}
}
int maxx=0,maxy=0,maxvalue=0;
for(int i=0;i
for(int j=0;j
System.out.print(valueloc[i][j]+" ");
if(maxvalue<=valueloc[i][j]){
maxx=i;
maxy=j;
maxvalue=valueloc[i][j];
}
valueloc[i][j]=0;
}
System.out.println();
}
if(flag==0){
gr.setColor(heiqi);
loc[maxx][maxy]=6;
flag++;
}
else{
gr.setColor(baiqi);
loc[maxx][maxy]=1;
flag--;
}
lastbux[number]=maxx;
lastbuy[number]=maxy;
number++;
System.out.println(maxx+">>>>>"+maxy);
gr.fillOval(15+maxx*50, 15+maxy*50, 20, 20);
}
public void mouseClicked(MouseEvent e) {
// 获取鼠标点击位置的坐标值
int x = e.getX();
int y = e.getY();
// 绘制棋子了
int x1=x/50;
int y1=y/50;
if(loc[x1][y1]!=0)
System.out.println(x1+">>>>>"+y1+"有棋了");
else{
if(flag==0){
gr.setColor(heiqi);
loc[x1][y1]=6;
flag++;
}
else{
gr.setColor(baiqi);
loc[x1][y1]=1;
flag--;
}
System.out.println(x1+">>>>>"+y1);
gr.fillOval(15+x1*50, 15+y1*50, 20, 20);
match2();
if(gameresult.equals("")){
if(this.gametype.equals("人人对战")){
lastbux[number]=x1;
lastbuy[number]=y1;
number++;
}
else if(this.gametype.equals("人机对战")){
lastbux[number]=x1;
lastbuy[number]=y1;
number++;
this.AI2();
}
match2();
}
}
}
public void mousePressed(MouseEvent e) {}
public void mouseReleased(MouseEvent e) {}
public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e) {}
public void mouseWheelMoved(MouseWheelEvent e){}
public void mouseDragged(MouseEvent e){}
public void mouseMoved(MouseEvent e){}
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。