五子棋 AI 预测

  9月1日，又到了这个让我们又爱又恨的时候。算一下我们开学的剩余使用数量也没有几次了。想到这不觉有种蛋蛋的忧伤，不过离开校园迟早的事，我们何不好好享受在校园的日子。
   闲话少说，在我学习JAVA的第二周，我大概花了4天4夜写出了这个五子棋AI，其中包括预测，其中实现的基础是权值法，就是给棋盘上的每一个点赋予相应的值。择其最大值落子。所有的数据都存在接口里，方便操作。

这里要注意的几点是
数组越界的问题，这个要忒别小心。
第二，看到网上有人用三维数组，估计会比我用二维数组做代码要写的少。
博弈树+剪枝，Alpha-Beta搜索算法，这个我还没实现。

这里是我的接口

package xy_五子棋0717;

public interface data {

	int MAX[]=new int[1];
	int ROW=15;
	int COL=15;
	
	int SIZE=30;
	
	int ARRAY[][]=new int[15][15]; 
	
	int VALUE[][]=new int[15][15];
	
	int PREDICT[][]=new int[15][15];
	
	
	int FINAL[]=new int[2];
	
	int MAXK[][]=new int[15][15];
	
}

五子棋的界面

package xy_五子棋0717;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

/**
 * 在这继承面板对象是为了后面写重绘时方便
 * @author Administrator
 *
 */
public class chessBoard extends JPanel{
	
	AI1 a;
	public static void main(String[] args){
		chessBoard ch=new chessBoard();
		ch.initUI();
	}

	private void initUI() {
		JFrame jf=new JFrame();
		jf.setTitle("五子棋");
		jf.setSize(650,600);
		jf.setLocation(300,50);
		jf.setDefaultCloseOperation(3);
		
		JPanel jpNorth=new JPanel();
		JButton jb1=new JButton("保存");
		JButton jb2=new JButton("读出");
		JButton jb3=new JButton("悔棋");
		jpNorth.add(jb1);
		jpNorth.add(jb2);
		jpNorth.add(jb3);
		//用内部类给两个按钮加监听器
		ActionListener ac=new ActionListener(){

			@Override
			public void actionPerformed(ActionEvent e) {
				//得到动作命令
				String commond=e.getActionCommand();
				if("保存".equals(commond)){
//					System.out.println("保存");
					//创建文件输出对象
					FileIO fi=new FileIO();
					try {
						fi.save("F:\\java\\保存五子棋\\a1.as",data.ARRAY,a.getSt());
					} catch (IOException e1) {
						// TODO Auto-generated catch block
						e1.printStackTrace();
					}
				}
				else if("读出".equals(commond)){
					//创建文件输入对象
					FileIO fi=new FileIO();
					try {
						StepList st1=fi.read("F:\\java\\保存五子棋\\a1.as");
						StepList st=a.getSt();
						for(int i=0;i<st1.size();i++){
							st.add(st1.get(i));
						}
					} catch (IOException e1) {
						// TODO Auto-generated catch block
						e1.printStackTrace();
					}
					repaint();
				}
				else if("悔棋".equals(commond)){
					//得到下棋的每一步数据的队列
					StepList st=a.getSt();
					EveryStep ev=st.get();
					data.ARRAY[ev.bx][ev.by]=0;
					data.ARRAY[ev.wx][ev.wy]=0;
					st.delete();
					repaint();
				}
			}};
			jb1.addActionListener(ac);
			jb2.addActionListener(ac);
			jb3.addActionListener(ac);
		jpNorth.setPreferredSize(new Dimension(0,80));
		jpNorth.setBackground(Color.white);
		jf.add(jpNorth,BorderLayout.SOUTH);
		
		this.setBackground(Color.orange);
		jf.add(this,BorderLayout.CENTER);
		
		jf.setVisible(true);
		
		Graphics g=this.getGraphics();
		
		//实例化一个棋子的监听器
		//chessListener ch=new chessListener(g);
		
		//给棋盘加一个监听器（人人）
		//this.addMouseListener(ch);
		
//		gobangAI0 go=new gobangAI0(g);
//		给棋盘加一个监听器（人机0）
//		this.addMouseListener(go);
		 a=new AI1(g);
		this.addMouseListener(a);
		
//		g.setColor(Color.black);
//		// System.out.println(data.VALUE[i][j]);
//		g.fillOval(5 + 7 * data.SIZE, 5 + 7 * data.SIZE, 30, 30);
//		data.ARRAY[7][7] = 2;
		
		
	} 
	
	/**
	 * 调用重绘的方法
	 * 重写重绘的方法
	 * 每次显示窗体都会自动调用此方法
	 */
	public void paint(Graphics g){
		super.paint(g);//调用父类的方法
		board(g);
		chess(g);
	}
	
	//绘制棋盘的方法
	public void board(Graphics g){
	   for(int i=0;i<data.ROW;i++){
		   g.drawLine(20, 20+data.SIZE*i, 440, 20+data.SIZE*i);
	   }
	   for(int i=0;i<data.ROW;i++){
		   g.drawLine( 20+data.SIZE*i,20,  20+data.SIZE*i,440);
	   }
	}
	//写一个重绘棋子的方法
	public void chess(Graphics g){
		for(int i=0;i<15;i++)
			for(int j=0;j<15;j++){
				if(data.ARRAY[i][j]==1)
				{
					g.setColor(Color.white);
					g.fillOval(5+i*data.SIZE,5+j*data.SIZE,30,30);}
				if(data.ARRAY[i][j]==2)
				{
					g.setColor(Color.black);
					g.fillOval(5+i*data.SIZE,5+j*data.SIZE,30,30);}
			}
	}
	
}

人工智能开始的地方
其实实现五子棋AI最简单的方法就是贴着它的棋子下，我们就暂且称它为AI0。

package xy_五子棋0717;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.Random;

import javax.swing.ImageIcon;

public class gobangAI0 extends MouseAdapter {

	private Graphics g;
	private boolean k = true;
	Random r = new Random(2);

	public gobangAI0(Graphics g) {
		this.g = g;
	}

	public void mouseClicked(MouseEvent e) {
		int a = e.getX();
		int b = e.getY();

		for (int i = 0; i < 15; i++)
			for (int j = 0; j < 15; j++) {
				if (a < (35 + i * data.SIZE) && a > (5 + i * data.SIZE)
						&& b > (5 + j * data.SIZE) && b < (35 + j * data.SIZE)) {

					// 判断位置是否为空，是否是黑棋或白棋
					if (k && data.ARRAY[i][j] == 0) {
						g.setColor(Color.white);
						g.fillOval(5 + i * data.SIZE, 5 + j * data.SIZE, 30, 30);

						data.ARRAY[i][j] = 1;
						int w = r.nextInt(3) - 1;
						int c = r.nextInt(3) - 1;
						int w1 = r.nextInt(5) - 2;
						int c1 = r.nextInt(5) - 2;
						int w2 = r.nextInt(7) - 3;
						int c2 = r.nextInt(7) - 3;

						if (data.ARRAY[i + c][j + w] == 0) {
							g.setColor(Color.black);
							g.fillOval(5 + (i + c) * data.SIZE, 5 + (j + w)
									* data.SIZE, 30, 30);

							data.ARRAY[i + c][j + w] = 2;
						} else if (data.ARRAY[i + c1][j + w1] == 0) {
							g.setColor(Color.black);
							g.fillOval(5 + (i + c1) * data.SIZE, 5 + (j + w1)
									* data.SIZE, 30, 30);

							data.ARRAY[i + c1][j + w1] = 2;
						} else if (data.ARRAY[i + c2][j + w2] == 0) {
							g.setColor(Color.black);
							g.fillOval(5 + (i + c2) * data.SIZE, 5 + (j + w2)
									* data.SIZE, 30, 30);

							data.ARRAY[i + c2][j + w2] = 2;
						}

						// 显示图片
						judge j1 = new judge(g);
						j1.judge1();
					}

				}
			}

	}

}

判断输赢的算法

package xy_五子棋0717;

import java.awt.Graphics;
import java.awt.Image;

import javax.swing.ImageIcon;

public class judge {

	private Graphics g;

	public judge(Graphics g) {
		this.g = g;
	}

	// 判断输赢的方法
	public void judge1() {
		int j = 0, l = 0;
		for (int i = 0; i < data.ROW; i++)
			for (int k = 0; k < (data.ROW); k++) {
				// System.out.println(i+"   "+k);
				// 判断横排是否有5个

				if (i < 11 && (data.ARRAY[i][k] == 1 || data.ARRAY[i][k] == 2)
						&& data.ARRAY[i + 1][k] == data.ARRAY[i][k]
						&& data.ARRAY[i + 2][k] == data.ARRAY[i][k]
						&& data.ARRAY[i + 3][k] == data.ARRAY[i][k]
						&& data.ARRAY[i + 4][k] == data.ARRAY[i][k]) {
					// System.out.println("*******************");
					if (data.ARRAY[i][k] == 1)
						j = 9;
					if (data.ARRAY[i][k] == 2)
						j = 8;
				}
				// 判断竖排是否有5个
				if (k < 11 && (data.ARRAY[i][k] == 1 || data.ARRAY[i][k] == 2)
						&& data.ARRAY[i][k + 1] == data.ARRAY[i][k]
						&& data.ARRAY[i][k] == data.ARRAY[i][k + 2]
						&& data.ARRAY[i][k + 3] == data.ARRAY[i][k]
						&& data.ARRAY[i][k + 4] == data.ARRAY[i][k]) {
					// System.out.println("*******************");
					if (data.ARRAY[i][k] == 1)
						j = 9;
					if (data.ARRAY[i][k] == 2)
						j = 8;
				}

				// 判断右斜排是否有5个
				if (i < 11 && k < 11
						&& (data.ARRAY[i][k] == 1 || data.ARRAY[i][k] == 2)
						&& data.ARRAY[i + 1][k + 1] == data.ARRAY[i][k]
						&& data.ARRAY[i][k] == data.ARRAY[i + 2][k + 2]
						&& data.ARRAY[i + 3][k + 3] == data.ARRAY[i][k]
						&& data.ARRAY[i + 4][k + 4] == data.ARRAY[i][k]) {
					if (data.ARRAY[i][k] == 1)
						j = 9;
					if (data.ARRAY[i][k] == 2)
						j = 8;
				}
				// 判断左斜排是否有5个

				if (i > 3 && k < 11
						&& (data.ARRAY[i][k] == 1 || data.ARRAY[i][k] == 2)
						&& data.ARRAY[i - 1][k + 1] == data.ARRAY[i][k]
						&& data.ARRAY[i][k] == data.ARRAY[i - 2][k + 2]
						&& data.ARRAY[i - 3][k + 3] == data.ARRAY[i][k]
						&& data.ARRAY[i - 4][k + 4] == data.ARRAY[i][k]) {
					// System.out.println("*******************");
					if (data.ARRAY[i][k] == 1)
						j = 9;
					if (data.ARRAY[i][k] == 2)
						j = 8;
				}
			}

		// System.out.println(j);

		ImageIcon im = new ImageIcon("images/2.png");
		Image i = im.getImage();
		if (j == 9)
			g.drawImage(i, 0, 0, null);

		ImageIcon im1 = new ImageIcon("images/1.png");
		Image i1 = im1.getImage();
		if (j == 8)

			g.drawImage(i1, 0, 0, null);
	}

}

后来有了权值，五子棋一下子聪明了一大步。
用方法计算好了权值点，就可以下棋了。如果有几个权值点是一样的就取随机数。
我们称其为AI1。

package xy_五子棋0717;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.Random;

public class AI1 extends MouseAdapter {
	int K;
	int bx;
	int by;
	int wx;
	int wy;
	StepList st=new StepList();

	Random ra = new Random();
	private Graphics g;
	public AI1(Graphics g) {
		this.g = g;
	}

//	// 电脑下第一步
//	public void mousePressed(MouseEvent e) {
//		
//	}

	// 下棋
	public void mouseClicked(MouseEvent e) {
		// 重置权值点
		K = 0;
		// 看看棋盘上有多少个棋子
		for (int i = 0; i < 15; i++)
			for (int j = 0; j < 15; j++) {
				if (data.ARRAY[i][j] != 0)
					K++;
			}

		// System.out.println(K);
		fun f = new fun();
		prediction pr = new prediction();

		for (int i = 0; i < 15; i++)
			for (int j = 0; j < 15; j++) {
				data.VALUE[i][j] = 1000;
			}
		int a = e.getX();
		int b = e.getY();
		for (int i = 0; i < 15; i++)
			for (int j = 0; j < 15; j++) {
				if (a < (35 + i * data.SIZE) && a > (5 + i * data.SIZE)
						&& b > (5 + j * data.SIZE) && b < (35 + j * data.SIZE)) {

					if (data.ARRAY[i][j] == 0) {
						g.setColor(Color.white);
						g.fillOval(5 + i * data.SIZE, 5 + j * data.SIZE, 30, 30);
						data.ARRAY[i][j] = 1;
						wx=i;
						wy=j;

						// 赋值

						f.value();

						// 预测是否有双三
						if (K > 7) {
							pr.pre(3);
						}

						// 查找,并下棋子
						search();
						//记录这一步，人和电脑下的棋子
						EveryStep ev=new EveryStep(bx,by,wx,wy);
						//加入到队列
						st.add(ev);
					}

					// 显示图片
					judge j1 = new judge(g);
					j1.judge1();
				}
			}

	}

	public StepList getSt() {
		return st;
	}

	public void setSt(StepList st) {
		this.st = st;
	}

	// 寻找权值最大的点 ，并下棋子
	public void search() {
		int MAX = 0;
		int k = 0;

		for (int i = 0; i < 15; i++)
			for (int j = 0; j < 15; j++) {

				if (data.VALUE[i][j] > MAX) {
					MAX = data.VALUE[i][j];

				}
			}

		for (int i = 0; i < 15; i++)
			for (int j = 0; j < 15; j++) {
				if (data.VALUE[i][j] == MAX) {
					// System.out.println(MAX);
					data.VALUE[i][j] = k;
					k++;
					// System.out.println(data.VALUE[i][j]);
				}
			}

		// 取随机下的点
		int q = ra.nextInt(k);

		if (K > 7) {
			// System.out.println("hi");
			g.setColor(Color.black);
			//System.out.println(data.FINAL[0] + "          " + data.FINAL[1]);
			g.fillOval(5 + data.FINAL[0] * data.SIZE, 5 + data.FINAL[1]
					* data.SIZE, 30, 30);
			data.ARRAY[data.FINAL[0]][data.FINAL[1]] = 2;
			bx=data.FINAL[0];
			by=data.FINAL[1];
		}

		else {
			for (int i = 0; i < 15; i++)
				for (int j = 0; j < 15; j++) {
					if (q == data.VALUE[i][j]) {
						g.setColor(Color.black);
						g.fillOval(5 + i * data.SIZE, 5 + j * data.SIZE, 30, 30);
						data.ARRAY[i][j] = 2;
						bx=i;
						by=j;
					}
				}

		}
	}
}

给大家看一下我的一部分权值表

package xy_五子棋0717;

/**
 * 五子棋赋值算法
 * 
 * @author Administrator 还有一个BUG就是黑棋会往白棋堵死的地方下G
 */
public class fun {

	int ONE = 16;
	int NOONE = 5;
	int TWO = 136;
	int BTHREE = 1001;
	int NOTWO = 10;
	int THREE = 1000;
	int NOTHREE = 130;
	int WWIN = 3000;
	int BWIN = 3300;

	fun1 hu1 = new fun1();
	fun2 hu2 = new fun2();

	public void value() {

		four();
		three();
		two();
		one();
		hu1.five();
		hu1.eight();
		hu1.twotwo();
		hu2.seven();
		hu2.six();
		in();

		// System.out.println();
		// for(int k=0;k<data.ROW;k++)
		// {
		// for(int i=0;i<(data.ROW);i++){
		// System.out.print("  ["+(i+1)+"]["+(k+1)+"]="+data.ARRAY[i][k]);
		// }
		// System.out.println();
		// }
	}

	// 判断是否有棋子
	public void in() {
		for (int i = 0; i < 15; i++)
			for (int j = 0; j < 15; j++) {
				if (data.ARRAY[i][j] != 0) {
					data.VALUE[i][j] = -60000;
					// System.out.println("123");
				}
			}
	}

后来为了打败我们的熊哥，我又给电脑加了简单的预测，是用递归实现的，后来发现递归的使用大大增加了计算时间，而且简答的预测很明显是打不过熊哥的。不过电脑已经第一次看到了未来，我就暂且称它为AI1的修正版。

package xy_五子棋0717;

public class prediction {

	fun f = new fun();

	int NX;
	int NY;
	int NBXX;
	int NBYY;

	public void pre(int n) {
		if (n == 0) {
			return;
		}
		int MAX = 0;
		for (int i = 0; i < 15; i++)
			for (int j = 0; j < 15; j++) {

				if (data.VALUE[i][j] > MAX) {
					MAX = data.VALUE[i][j];

					data.FINAL[0] = i;
					//System.out.println();
					NX = i;
					data.FINAL[1] = j;
					NY = j;
					//System.out.println(data.FINAL[0] + " hihi       "
							//+ data.FINAL[1]);
					// System.out.println(data.FINAL[0]+"   "+data.FINAL[1]);
				}
			}

		// 先判断白棋，因为要堵白子的双三
		if (MAX < 1500) {

			// 假设白棋下的地方
			for (int i = 0; i < 15; i++)
				for (int j = 0; j < 15; j++) {

					// 找到没下的点
					if (data.ARRAY[i][j] == 0) {
						// 重置权值点
						for (int i2 = 0; i2 < 15; i2++)
							for (int j2 = 0; j2 < 15; j2++) {
								data.VALUE[i2][j2] = 1000;
							}
						int k = 0;

						// 假设白子下的地方
						data.ARRAY[i][j] = 1;
						f.value();
						// 遍历找极大值
						for (int i1 = 0; i1 < 15; i1++)
							for (int j1 = 0; j1 < 15; j1++) {
								if (data.VALUE[i1][j1] > 1700
										&& data.VALUE[i1][j1] < 2600) {
									k++;
									// System.out.println(k);
								}
								if (data.VALUE[i1][j1] > 2800) {
									k += 3;
									// System.out.println(k);
								}
							}
						// 存储极大值的全指点
						data.MAXK[i][j] = k;

						int MAX2 = 0;
						for (int i1 = 0; i1 < 15; i1++)
							for (int j1 = 0; j1 < 15; j1++) {
								if (data.MAXK[i1][j1] > MAX2) {
									MAX2 = data.MAXK[i1][j1];
									NBXX = i1;
									NBYY = j1;
								}
							}

						// 如果它的极值点有两个,
						// System.out.println(k);
						if (MAX2 > 3 && data.VALUE[NBXX][NBYY] > 0) {
							//System.out.println(NBXX + "  " + NBYY);
							//System.out.println(data.VALUE[NBXX][NBYY]);
							data.FINAL[0] = NBXX;
							data.FINAL[1] = NBYY;
							//System.out.println(MAX2);
							//System.out.println("HAHA" + data.FINAL[0]
								//	+ data.FINAL[1]);
							MAX2 = 0;
						} else {
							pre(n - 1);
						}

						// 把假设的白子去掉
						data.ARRAY[i][j] = 0;

					}

				}

		}

		// 后判断黑棋，因为要保证黑棋先赢
		if (MAX < 1500) {
			// 假设黑棋下的地方
			for (int i = 0; i < 15; i++)
				for (int j = 0; j < 15; j++) {
					// 重置权值点
					for (int i2 = 0; i2 < 15; i2++)
						for (int j2 = 0; j2 < 15; j2++) {
							data.VALUE[i2][j2] = 1000;
						}
					int k = 0;
					// 找到没下的点
					if (data.ARRAY[i][j] == 0) {
						// 假设黑子下的地方
						data.ARRAY[i][j] = 2;

						f.value();
						// 遍历找极大值
						for (int i1 = 0; i1 < 15; i1++)
							for (int j1 = 0; j1 < 15; j1++) {
								if (data.VALUE[i1][j1] > 1700
										&& data.VALUE[i1][j1] < 2600) {
									k++;
								}
								if (data.VALUE[i1][j1] > 2600) {
									k += 3;
								}

							}

						int MAX2 = 0;// 最大K值点
						for (int i1 = 0; i1 < 15; i1++)
							for (int j1 = 0; j1 < 15; j1++) {
								if (data.MAXK[i1][j1] > MAX2) {
									MAX2 = data.MAXK[i1][j1];
									NBXX = i1;
									NBYY = j1;
								}
							}
						// 如果它的极值点有两个,
						// System.out.println(k);
						if (MAX2 > 3 && data.VALUE[NBXX][NBYY] > 0) {
							//System.out.println(k);
							data.FINAL[0] = NBXX;
							data.FINAL[1] = NBYY;
							//System.out.println("LALA");
							MAX2 = 0;
						} else {
							pre(n - 1);
						}

						// 把假设的黑子去掉
						data.ARRAY[i][j] = 0;
					}

				}

		}

	}
}

对于AI的完美追求是没有止境的，但是在追求人工智能的道路上每一步都需要汗水与思维碰撞出新鲜的思维。对于AI2.0我已经把接口写好了，大概思路就是用博弈树+剪枝，Alpha-Beta搜索算法。但我现在还没有想好如何去写，等以后有机会我一定会好好完善我的五子棋AI2.0，实现我打败熊哥的承诺。
下面是还没填好的AI2.0

package xy_五子棋0717;

public class AI2 {
	
	int val;
	public int AlphaBeta(int depth, int alpha, int beta) { 
		if (depth == 0) { 
		return Evaluate(); 
		} 
		GenerateLegalMoves(); 
		while (MovesLeft()) { 
		MakeNextMove(); 
		val = -AlphaBeta(depth - 1, -beta, -alpha); 
		UnmakeMove(); 
		if (val >= beta) { 
		return beta; 
		} 
		if (val > alpha) { 
		alpha = val; 
		} 
	} 
		return alpha; 
		}

	private int Evaluate() {
		// TODO Auto-generated method stub
		return 0;
	}

	private void UnmakeMove() {
		// TODO Auto-generated method stub
		
	}

	private void MakeNextMove() {
		// TODO Auto-generated method stub
		
	}

	private boolean MovesLeft() {
		// TODO Auto-generated method stub
		return false;
	}

	private void GenerateLegalMoves() {
		// TODO Auto-generated method stub
		
	} 

}

其实，实现AI并不像我们想象的那么难，不要一开始就被它吓到了，试一下，你就会发现它真的很简单，至少比预测妹纸们的。。。要容易的多。。。。。。