`
沉沦的夏天
  • 浏览: 10254 次
  • 性别: Icon_minigender_1
社区版块
存档分类
最新评论

五子棋项目总结

 
阅读更多
  其实上个学期接触了一点安卓，就有做人人算法的五子棋了，并且这学期开学不久做了简单的人机，但人太懒没有总结。目前主要还是在学习java版的程序，索性把java版的五子棋编出来，做个总结，也算是个交代吧。
记得熊哥说过，如果你会画布重绘，那么就能做五子棋项目了。确实如此，五子棋棋盘不就是一条一条的直线吗？而棋子的话也很简单，两种颜色的实心圆，当然高级点可以用图片代替。而这个项目的关键是五子棋的一些算法，比如判断输赢算法、悔棋实现和人机算法，我觉得人人算法这没什么，就是按顺序轮流下。 判断输赢的话也很简单，假设我们下的棋子分别是黑棋和白棋，可以定义一个静态二维数组，在黑棋下的地方赋标志1，白棋下的地方赋标志-1，当然没下的地方就是0 了。五子棋赢即同色的棋五子连珠，所以只需判断四个方向上有没有连续的1或者-1即可。而且赋标志也有好处，在重绘的时候根据标志就可以把原来下的棋子画出来了。
当然如果要悔棋的话，最后是把棋子的坐标存入自定义队列当中，这样可以实现任意步的悔棋。在安卓做的五子棋的时候，我还用队列存的棋子坐标重绘，感觉没有根据赋标志的二维数组重绘简单明了。
人机算法的话主要还是汪洋学弟教我的，那时还没有讲队列啥的。其主要方法是根据人下的棋子情况给每个没下的位置赋权值，权值越大表示该位置越危险，也是机方需要下的地方，当然这只是对人下棋子的简单防守。在网上，我找到某位大神写的防守权值表，这个应该算比较高级的了！见下图：





当然还可以根据电脑自己下的情况确定是否进攻，比如电脑有有三三连或者活四或者死四情况而人没有时，就可以毫不犹豫的进攻了，我后来给电脑加了进攻，但是电脑依旧很弱，大概人十几步就能搞定电脑！而高级的五子棋人机算法有待以后有时间研究！


下面是我做的效果图：
初始化界面，提示需要选择菜单栏中的对战模式：




人机大战，电脑赢（白棋），可惜没有考虑选择棋子颜色的设置





下面给出了我的五子棋代码：
首先是一些常数和静态变量的定义接口：

public interface Config {
	public static final int X0=30;//表格左上角的起点x坐标
	public static final int Y0=30;//表格左上角的起点Y坐标
	public static final int ROWS=17;//横向线的条数
	public static final int COLUMNS=17;//纵向线的条数
	public static final int CHESS_SIZE=35;
	public  static final int SIZE=35;//棋盘单元格大小（默认final？？？？
	public static  boolean ct=false;
	public static final int point[][]= new int [Config.COLUMNS][Config.ROWS];
	public static List<Qizi> list_chess= new ArrayList<Qizi>();
	//防守权值数组
	public static final int list_quan[]={0,5,10,150,650,700,3000,9000,10000};
	//进攻权值数组
	public static final int list_quan_gong[]={150,650,4000,5000,30000,30000};

}

[color=red][size=large]然后是棋子坐标队列的棋子类：[/size][/color]public class Qizi {
	public int int_x;
	public int int_y;
}

[color=red][size=large]紧接着是初始化窗口，对中间面板上的画布重绘： 

import java.awt.BasicStroke;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Shape;
import java.awt.Stroke;
import java.awt.TextArea;
import java.awt.event.ActionListener;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.plaf.PanelUI;


public class Fivechess extends JFrame{
	//传入背景图片
	ImageIcon image_table=new ImageIcon("images/table.jpg");
	Mylistener my;//创建继承动作和鼠标监听的类对象
	JTextField jtf=new JTextField();//显示当前模式文本框
	private String str_btn;
	public String getStr(){
		return this.str_btn;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		 Fivechess fc=new Fivechess();
		fc.initUI();//   初始化界面
		JOptionPane.showMessageDialog(null, "请选择对战模式，否则默认为人人对战", "Game Start", JOptionPane.INFORMATION_MESSAGE);
	}
	
	
	
	public void initUI(){
		
		//创建窗口，设置标题，大小，位置，窗口不可改变，关闭后结束程序
		this.setTitle("ZQ五子棋V1.0");
		this.setSize(new Dimension(750,700));
		this.setLocationRelativeTo(null);
		this.setResizable(false);
		this.setDefaultCloseOperation(3);
		//this.setLayout(new BorderLayout());窗口默认边框布局
	
		

		//新建东边面板和中间面板
	
		JPanel centerPanel = new JPanel(){
			
			//setOpaque(false); 设置面板透明
			public void paint(Graphics g){				
				super.paint(g);//重写父类方法
				//给画布添加背景图片
				g.drawImage(image_table.getImage(), 0, 0, null);
				drawTable(g);//画棋盘方法
				//重绘棋子
				for(int i=0;i<Config.COLUMNS;i++){
					for(int j=0;j<Config.ROWS;j++){
						if(Config.point[i][j]==1){
							g.setColor(Color.black);
							g.fillOval(Config.X0+Config.SIZE*i-Config.SIZE/2,Config.Y0+Config.SIZE*j-Config.SIZE/2,Config.SIZE,Config.SIZE);	
						}
						else if(Config.point[i][j]==-1){
							//g.setColor(JColorChooser.showDialog(null, null, Color.black));
							g.setColor(Color.white);
							g.fillOval(Config.X0+Config.SIZE*i-Config.SIZE/2,Config.Y0+Config.SIZE*j-Config.SIZE/2,Config.SIZE,Config.SIZE);
						}					
					}
					//最后一个索引位置
					int last=Config.list_chess.size()-1;
					if(last>=0){
						g.setColor(Color.red);
						int x=Config.list_chess.get(last).int_x;
						int y=Config.list_chess.get(last).int_y;
						//绝对坐标
						int xx=Config.X0+Config.SIZE*x;
						int yy=Config.Y0+Config.SIZE*y;
						g.drawLine(xx-7, yy, xx+7, yy);
						g.drawLine(xx, yy-7, xx, yy+7);
					}
					
					
					
//					//给最后一个棋子加标记
//				if(Config.list_chess.size()>1){
//					//如果棋子为偶数个数
//					if(Config.list_chess.size()%2==0){
//						g.setColor(Color.white);
//					}
//					else{
//						g.setColor(Color.black);
//					}
					
			//	}
					
				}
				
				
			}
		};
		
		
//		centerPanel.setOpaque(false);//设置面板透明
//		ImageIcon image=new ImageIcon("image/table.jpg");
		
		//创建监听器对象，并添加到中间面板上，这一步必须在创建东边面板上的按钮之前		
		my=new Mylistener(centerPanel,jtf);
		 centerPanel.addMouseListener(my);
			
			//创建菜单栏
			JMenuBar jmb=creatmenubar();
			//将菜单工具栏添加到窗体中
			this.setJMenuBar(jmb);
			
		 //创建东边面板对象
		JPanel eastPanel = creatEastPanel();
		//将东边面板和中间面板添加到窗体上
		this.add(eastPanel, BorderLayout.EAST);
		this.add(centerPanel,BorderLayout.CENTER);
		//设置窗体可见
		this.setVisible(true);
	
	}
	
	//创建菜单栏方法
	public JMenuBar creatmenubar(){
		//新建菜单工具栏
		JMenuBar jmb=new JMenuBar();
		jmb.setPreferredSize(new Dimension(0,35));
		//创建JMenu菜单对象
		//JMenu jm1=new JMenu("开始");
		JMenu jm2=new JMenu("对战模式");
		//创建两个菜单项
		JMenuItem jmi_1=new JMenuItem("人人对战");
		jmi_1.addActionListener(my);
		JMenuItem jmi_2=new JMenuItem("人机对战");
		jmi_2.addActionListener(my);
		//菜单项添加到菜单对象中
		jm2.add(jmi_1);
		jm2.add(jmi_2);
		//菜单对象添加到菜单工具栏中
		//jmb.add(jm1);
		jmb.add(jm2);
		
		return (jmb);
		
	}

	//创建东边面板及其上面的按钮方法
	public JPanel creatEastPanel(){
		JPanel panel = new JPanel();
		panel.setPreferredSize(new Dimension(120,0));
		panel.setBackground(new Color(190,180,230));
		panel.setLayout(null);//设置绝对布局
		String [] str_btn = {"重新开始","悔棋"}; 
		for(int i=0; i<str_btn.length; i++){
			JButton button = new JButton(str_btn[i]);
			//button.setPreferredSize(new Dimension(90, 35));
			button.setBounds(15,100+60*i, 90, 30);
			button.setActionCommand(str_btn[i]);
			//给按钮添加监听器对象
			button.addActionListener(my);
			panel.add(button);
			
			//panel.setLayout(new FlowLayout());//设置流式布局
			JLabel jla1=new JLabel("当前模式:");
			jla1.setBounds(5, 300, 80, 30);
			panel.add(jla1);
			
			jtf.setText("人人对战");
			jtf.setBounds(5, 350, 80, 30);
			panel.add(jtf);
			
		}
				
		return panel; 
	}
	
	
	//画棋盘方法
	public void drawTable(Graphics g){
		g.setColor(Color.BLACK);
		Graphics2D gg=(Graphics2D)g;
		gg.setStroke(new BasicStroke(2F,BasicStroke.CAP_ROUND,BasicStroke.JOIN_ROUND));
		//画竖线
		for(int i=0;i<Config.COLUMNS;i++){
			//g.getFont()
			gg.drawLine(Config.X0+Config.SIZE*i , Config.Y0, Config.X0+Config.SIZE*i, Config.Y0+Config.SIZE*(Config.ROWS-1));
		}
		//画行线
		for(int j=0;j<Config.ROWS;j++){
			gg.drawLine(Config.X0, Config.Y0+Config.SIZE *j, Config.X0+Config.SIZE *(Config.COLUMNS-1), Config.Y0+Config.SIZE*j);
		}
		//画四个标志
		//距边沿距离
		int d1=Config.SIZE*3;
		int d2=5;
		gg.fillRect(Config.X0+d1-d2, Config.Y0+d1-d2, 2*d2, 2*d2);
		gg.fillRect(Config.X0+Config.SIZE*(Config.COLUMNS-1)-d1-d2, Config.Y0+d1-d2, 2*d2, 2*d2);
		gg.fillRect(Config.X0+d1-d2, Config.Y0+Config.SIZE*(Config.ROWS-1)-d1-d2, 2*d2, 2*d2);
		gg.fillRect(Config.X0+Config.SIZE*(Config.COLUMNS-1)-d1-d2, Config.Y0+Config.SIZE*(Config.ROWS-1)-d1-d2, 2*d2, 2*d2);
		
	}

	
	
	}

[color=red][size=medium]

再就是监听器的对象类，包含人人和人机算法：[/size][/color] 

import java.awt.Color;
import java.awt.Graphics;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JPanel;
import javax.swing.JTextField;


public class Mylistener extends MouseAdapter implements ActionListener {
	
	private Graphics g;
	private String str_cmd;
	private String mode="人人对战";//默认人人大战
	private JPanel panel;
	private JTextField jtf;
	private boolean ct ;
	private boolean over=false;//分出胜负
	 //用于记录棋盘每个位置的权值大小
    int quanzhi[][]=new int[Config.COLUMNS][Config.ROWS];
	//构造方法，传入窗体和面板
	public Mylistener(JPanel panel,JTextField jtf){
		this.panel=panel;
		this.jtf=jtf;
	}
	
	
	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub
		
				//得到动作按钮
				str_cmd=e.getActionCommand();
				if(str_cmd.equals("人人对战")||str_cmd.equals("人机对战")){
					mode=str_cmd;
					jtf.setText(mode);
				}
				//以下动作都表示重新开始
				if(str_cmd.equals("重新开始")||str_cmd.equals("人人对战")||str_cmd.equals("人机对战")){
					
					over=false;//游戏结束位初始化
					Config.list_chess.clear();
					for( int ii=0;ii< Config.COLUMNS;ii++){
						for( int jj=0;jj<Config.ROWS;jj++){
							Config.point[ii][jj]=0;
						}
					}
					panel.repaint();
				}
				
				//人人对战的悔棋
				if(mode.equals("人人对战")&&str_cmd.equals("悔棋") && Config.list_chess.size()>0){	
					over=false;//游戏可能刚结束，将结束标志位初始化
					//悔棋的话取反ct
					ct=!ct;
					//得到队列最后一个棋子坐标
					int x=Config.list_chess.get(Config.list_chess.size()-1).int_x;
					int y=Config.list_chess.get(Config.list_chess.size()-1).int_y;
					//System.out.println(x+"  "+y);
					//将其坐标标志设为空
					Config.point[x][y]=0;
					//移除队列最后元素
					Config.list_chess.remove(Config.list_chess.size()-1);
					//重绘
					panel.repaint();
					//System.out.println("已执行repaint()");
				}
				//人机对战的悔棋，相当于清除队列中的最后两个
				if(mode.equals("人机对战")&&str_cmd.equals("悔棋") && Config.list_chess.size()>0){	
					
					//得到队列最后一个棋子坐标
					int x=Config.list_chess.get(Config.list_chess.size()-1).int_x;
					int y=Config.list_chess.get(Config.list_chess.size()-1).int_y;
					//将其坐标标志设为空
					Config.point[x][y]=0;
					//移除队列最后元素
					Config.list_chess.remove(Config.list_chess.size()-1);
					if(over==false||(over==true&&Config.list_chess.size()%2==1)){
						//得到队列最后一个棋子坐标
						 x=Config.list_chess.get(Config.list_chess.size()-1).int_x;
						 y=Config.list_chess.get(Config.list_chess.size()-1).int_y;
						//将其坐标标志设为空
						Config.point[x][y]=0;
						//移除队列最后元素
						Config.list_chess.remove(Config.list_chess.size()-1);
					}
					over=false;//游戏可能刚结束，将结束标志位初始化
					//重绘
					panel.repaint();
					//System.out.println("已执行repaint()");
				}
				
				
				
	}

	
	
	
	//鼠标监听，判断下棋
	public void mouseReleased(MouseEvent e) {
		//System.out.println(fc.getStr());
	
		//得到传入面板画布
		this.g=panel.getGraphics();
		//得到鼠标释放处坐标
		int x_point=e.getX();
		int y_point=e.getY();
		//转化得到棋盘上的位置
		int chess_x= (x_point-Config.X0)/Config.SIZE;
		int chess_y= (y_point-Config.Y0)/Config.SIZE;
		if((x_point-Config.X0)%Config.SIZE>Config.SIZE/2){
			chess_x++;
		}
		if((y_point-Config.Y0)%Config.SIZE>Config.SIZE/2){
			chess_y++;
		}
		
		//当该位置没下棋子时，按顺序下好
		if(over==false&&Config.point[chess_x][chess_y]==0){
			
			//System.out.println(mode);
			if(mode.equals("人人对战")){
				this.renren(chess_x,chess_y);
			}
			else {
				this.renji(chess_x,chess_y);
			}
			
		}
		
		
	
			
	}
	
	public void renren(int x,int y){
		if(ct==false){
			g.setColor(Color.black);
			Config.point[x][y]=1;	
			ct=true;
		}
		else{
			g.setColor(Color.white);
			Config.point[x][y]=-1;	
			ct=false;
		}
		g.fillOval(Config.X0+Config.SIZE*x-Config.SIZE/2,Config.Y0+Config.SIZE*y-Config.SIZE/2,Config.SIZE,Config.SIZE);
		//下好棋子后，保存到队列中
		Qizi qizi=new Qizi();
		qizi.int_x=x;
		qizi.int_y=y;
		Config.list_chess.add(qizi);
		//并判断下完该棋子输赢情况，ct为ture时，表示刚才下的是黑棋，否则为白棋
		 Win_lose wl = new Win_lose(x,y,ct);
		 panel.repaint();
		 //如果分出胜负
		 if(wl.getresult()){
			 over=true;
		 }
		 
	}
	
	public void renji(int x,int y){
		
		//首先，人下好该位置
		g.setColor(Color.black);		
		g.fillOval(Config.X0+Config.SIZE*x-Config.SIZE/2,Config.Y0+Config.SIZE*y-Config.SIZE/2,Config.SIZE,Config.SIZE);
		//赋标志位
		Config.point[x][y]=1;
		//下好棋子后，保存到队列中
		Qizi qizi=new Qizi();
		qizi.int_x=x;
		qizi.int_y=y;
		Config.list_chess.add(qizi);
		//并判断下完该棋子输赢情况，ct为ture时，表示刚才下的是黑棋，否则为白棋
		 Win_lose wl = new Win_lose(x,y,true);
		 panel.repaint();
		if(wl.getresult()==false){
			this.jixia();
		}
		else {
			over=true;
		}
		 
	}
	//当人下完后，电脑下棋位置判断
	public void jixia(){
		//最大权值初始化
	  int quanzhi_max=0;	
	  //权值最大的地方的坐标；
	  int m=0;
	  int n=0;
		//遍历棋盘判断坐标点
		for( int ii=0;ii< Config.COLUMNS;ii++){
			for( int jj=0;jj<Config.ROWS;jj++){
			
				//当棋子没下时，更新最大权值
				if(Config.point[ii][jj]==0){
					if(quanzhi_max<=count_quanzhi(ii,jj)){
						 m=ii;
						 n=jj;
						quanzhi_max=quanzhi[ii][jj];
					}
				}																								
			}						
		}
		g.setColor(Color.white);
		g.fillOval(Config.X0+Config.SIZE*m-Config.SIZE/2,Config.Y0+Config.SIZE*n-Config.SIZE/2,Config.SIZE,Config.SIZE);
		Config.point[m][n]=-1;
		Qizi qz=new Qizi();
		qz.int_x=m;
		qz.int_y=n;
		Config.list_chess.add(qz);
		//并判断下完该棋子输赢情况，ct为ture时，表示刚才下的是黑棋，否则为白棋
		Win_lose wl = new Win_lose(m,n,false);
		panel.repaint();
		 //如果分出胜负
		 if(wl.getresult()){
			 over=true;
		 }
		
		
	}
		
	public int count_quanzhi(int ii,int jj){

		
		quanzhi[ii][jj]=0;
		//**********将左右方向的权值计入总权值	
		
		//往右计数,累加权值
		int num=0;
		int num_gong;
		for(int m=ii+1;m<Config.COLUMNS;m++){
			if(Config.point[m][jj]==1){
				num=num+2;				
			}
			else if(Config.point[m][jj]==-1){
				num=num-1;	
				if(num<0){
					num=0;
				}
				break;									
			}
			else break;

		}	
		
		
		//往左计数,累加权值
		for(int m=ii-1;m>0;m--){
			if(Config.point[m][jj]==1){
				num=num+2;				
			}
			else if(Config.point[m][jj]==-1){
				num=num-1;	
				if(num<0){
					num=0;
				}
				break;									
			}
			else break;

		}
		quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan[num];
		
		

		
		
//**********将上下方向的权值计入总权值
		//往下计数,累加权值
		num=0;
		for(int m=jj+1;m<Config.ROWS;m++){
			if(Config.point[ii][m]==1){
				num=num+2;				
			}
			else if(Config.point[ii][m]==-1){
				num=num-1;	
				if(num<0){
					num=0;
				}
				break;									
			}
			else break;

		}
		//往上计数,累加权值
		for(int m=jj-1;m>0;m--){
			if(Config.point[ii][m]==1){
				num=num+2;				
			}
			else if(Config.point[ii][m]==-1){
				num=num-1;	
				if(num<0){
					num=0;
				}
				break;									
			}
			else break;

		}
		quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan[num];
		
		
		
		//**********将东北到西南方向的权值计入总权值
		//往东北计数,累加权值
		num=0;
		for(int m=ii+1,n=jj-1;m<Config.COLUMNS&&n>0;m++,n--){
			if(Config.point[m][n]==1){
				num=num+2;				
			}
			else if(Config.point[m][n]==-1){
				num=num-1;	
				if(num<0){
					num=0;
				}
				break;									
			}
			else break;

		}
		//往西南计数,累加权值
		for(int m=ii-1,n=jj+1;m>0&&n<Config.ROWS;m--,n++){
			if(Config.point[m][n]==1){
				num=num+2;				
			}
			else if(Config.point[m][n]==-1){
				num=num-1;	
				if(num<0){
					num=0;
				}
				break;									
			}
			else break;

		}
		quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan[num];
		
		
		
		//**********将到东南到西北方向的权值计入总权值
		//往东南计数,累加权值
		num=0;
		for(int m=ii+1,n=jj+1;m<Config.COLUMNS&&n<Config.ROWS;m++,n++){
			if(Config.point[m][n]==1){
				num=num+2;				
			}
			else if(Config.point[m][n]==-1){
				num=num-1;	
				if(num<0){
					num=0;
				}
				break;									
			}
			else break;

		}
		//往西南计数,累加权值
		for(int m=ii-1,n=jj-1;m>0&&n>0;m--,n--){
			if(Config.point[m][n]==1){
				num=num+2;				
			}
			else if(Config.point[m][n]==-1){
				num=num-1;	
				if(num<0){
					num=0;
				}
				break;									
			}
			else break;

		}
		quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan[num];
		
		//**************进攻权值判断
		
		//往右判断攻击棋子数量，赋权值
			num_gong=0;
			for(int m=ii+1;m<Config.COLUMNS;m++){
				if(Config.point[m][jj]==-1){
					num_gong++;
				}
				else 
						break;			
				
					
				}
	
		//往左判断攻击棋子数量，赋权值
			for(int m=ii-1;m>0;m--){
				if(Config.point[m][jj]==-1){
					num_gong++;
				}
				else if(Config.point[m][jj]==1){
					if(num_gong>=2){
						quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-4];
					}
					break;			
				}
				else if(Config.point[m][jj]==0){
					if(num_gong>=2){
						quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-3];
					}
					break;
					
				}
			}
			
			
			//往下判断攻击棋子数量，赋权值
			num_gong=0;
			
				for(int m=jj+1;m<Config.ROWS;m++){
					if(Config.point[ii][m]==-1){
						num_gong++;
					}
					else if(Config.point[ii][m]==1){
//						if(num_gong>=2){
//							quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-4];
//						}
						break;			
					}
					else if(Config.point[ii][m]==0){
//						if(num_gong>=2){
//							quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-3];
//						}
						break;
						
					}
				}
			
			
			
			
			//往上判断攻击棋子数量，赋权值
			//num_gong=0;	
				for(int m=jj-1;m>0;m--){
					if(Config.point[ii][m]==-1){
						num_gong++;
					}
					else if(Config.point[ii][m]==1){
						if(num_gong>=2){
							quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-4];
						}
						break;			
					}
					else if(Config.point[ii][m]==0){
						if(num_gong>=2){
							quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-3];
						}
						break;
						
					}
				}
				
				//往东南方向判断攻击棋子数量，赋权值
				num_gong=0;						
					for(int m=ii+1,n=jj+1;m<Config.COLUMNS&&n<Config.ROWS;m++,n++){
						if(Config.point[m][n]==-1){
							num_gong++;
						}
						else if(Config.point[m][n]==1){
//							if(num_gong>=2){
//								quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-4];
//							}
							break;			
						}
						else if(Config.point[m][n]==0){
//							if(num_gong>=2){
//								quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-3];
//							}
							break;
							
						}
					}
					
					
					//往西北方向判断攻击棋子数量，赋权值
					//num_gong=0;						
						for(int m=ii-1,n=jj-1;m>0&&n>0;m--,n--){
							if(Config.point[m][n]==-1){
								num_gong++;
							}
							else if(Config.point[m][n]==1){
//								if(num_gong>=2){
//									quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-4];
//								}
								break;			
							}
							else if(Config.point[m][n]==0){
//								if(num_gong>=2){
//									quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-3];
//								}
								break;
								
							}
						}
				
						
						//往东北向判断攻击棋子数量，赋权值
						num_gong=0;						
							for(int m=ii+1,n=jj-1;m<Config.COLUMNS&&n>0;m++,n--){
								if(Config.point[m][n]==-1){
									num_gong++;
								}
								else if(Config.point[m][n]==1){
//									if(num_gong>=2){
//										quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-4];
//									}
									break;			
								}
								else if(Config.point[m][n]==0){
//									if(num_gong>=2){
//										quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-3];
//									}r
									break;
									
								}
							}
							
							//往西南向判断攻击棋子数量，赋权值
							//num_gong=0;						
								for(int m=ii-1,n=jj+1;m>0&&n<Config.ROWS;m--,n++){
									if(Config.point[m][n]==-1){
										num_gong++;
									}
									else if(Config.point[m][n]==1){
										if(num_gong>=2){
											quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-4];
										}
										break;			
									}
									else if(Config.point[m][n]==0){
										if(num_gong>=2){
											quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-3];
										}
										break;
										
									}
								}
				
		
		return quanzhi[ii][jj];
		
	
		
	
	}	
		
}

最后是输赢判断：
import java.awt.Dialog;

import javax.swing.JOptionPane;


public class Win_lose {
int ii,jj;
private boolean ct;
private boolean over;
public boolean getresult(){
	return over;
}
	public Win_lose(int ii,int jj,Boolean ct){
		this.ii=ii;
		this.jj=jj;
		this.ct=ct;
		over=false;
		if(check_Row(ii,jj)>=5||check_Column(ii,jj)>=5||check_zsyx(ii,jj)>=5||check_yszx(ii,jj)>=5){
			over=true;
			if(ct==true){
				//黑棋赢
				System.out.println("黑棋胜利");
				JOptionPane.showMessageDialog(null, "黑棋胜利", "Game Over", JOptionPane.INFORMATION_MESSAGE);
			
			}
			else {
				//白棋赢
				System.out.println("白棋胜利");
				JOptionPane.showMessageDialog(null, "白棋胜利", "Game Over", JOptionPane.INFORMATION_MESSAGE);
			}
		}
	}
		
	
	
	//检测某个棋子水平方向的个数
	public int check_Row(int x,int y){
		int count=0;
		//int count1=0;
		//往右计数
		for(int i=x+1;i<Config.COLUMNS;i++){
			if(Config.point[i][y]==Config.point[x][y]){
				count++;				
			}
			else
				break;
		}
		//往左数
		for(int i=x;i>0;i--){
			if(Config.point[i][y]==Config.point[x][y]){
				count++;
			}
			else
				break;			
		}		
		
		return count;		
	}
	
	
	
	//检测某个棋子竖直的个数
	public int check_Column(int x,int y){
		int count=0;
		//往下计数
		for(int i=y+1;i<Config.ROWS;i++){
			if(Config.point[x][i]==Config.point[x][y]){
				count++;				
			}
			else
				break;
		}
		//往上计数
		for(int i=y;i>0;i--){
			if(Config.point[x][i]==Config.point[x][y]){
				count++;
			}
			else
				break;			
		}				
		return count;		
	}
	
	
	
	//检测某个棋子左上到右下方向的个数
		public int check_zsyx(int x,int y){
			int count=0;
			//往东南计数
			for(int i=x+1,j=y+1;i<Config.COLUMNS&&j<Config.ROWS;i++,j++){
				if(Config.point[i][j]==Config.point[x][y]){
					count++;				
				}
				else
					break;
			}
			//往西北计数
			for(int i=x,j=y;i>=0&&j>=0;i--,j--){
				if(Config.point[i][j]==Config.point[x][y]){
					count++;
				}
				else
					break;			
			}				
			return count;		
		}
		
		
		
		
		//检测某个棋子右上到左下方向的个数
				public int check_yszx(int x,int y){
					int count=0;
					//往东北计数
					for(int i=x+1,j=y-1;i<Config.COLUMNS&&j>0;i++,j--){
						if(Config.point[i][j]==Config.point[x][y]){
							count++;				
						}
						else
							break;
					}
					//往西南计数
					for(int i=x,j=y;i>0&&j<Config.ROWS;i--,j++){
						if(Config.point[i][j]==Config.point[x][y]){
							count++;
						}
						else
							break;			
					}				
					return count;		
				}
				
}


[/size][/color]

期待下一次能做个高级的五子棋人机算法项目和网络版五子棋！
  • 大小: 629.2 KB
  • 大小: 596.1 KB
  • 大小: 17.3 KB
1
顶
0
踩
分享到：
分形小结
评论
2 楼 沉沦的夏天 2014-03-22  
ayaome 写道
今天写了不少啊

恩，把以前的补回来！
1 楼 ayaome 2014-03-22  
今天写了不少啊
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    基于JAVA的升级版五子棋项目总结（PPT版）

    NULL 博文链接：https://javaprince.iteye.com/blog/818030

    网络五子棋设计报告

    网络五子棋设计报告 大家下载着看看吧 网络五子棋设计报告 网络五子棋设计报告

    python课程设计完整 五子棋

    python课程设计完整 五子棋

    五子棋实训报告（c语言）

    本文档是关于大学本科课程实训的一个项目，是用c语言写的一个关于五子棋的实训报告，并且可视化

    《QQ五子棋》项目总结

    五子棋是一种两人对弈纯策略型的棋类游戏。起源于中国古代的传统黑白棋种之一，发展于日本，流行于欧美。玩法容易上手，老少皆宜。《QQ五子棋》，是客户端“QQ游戏大厅”中较为经典的休闲游戏之一，日活跃用户最高近...

    粤嵌GEC6818开发板实训项目-五子棋

    在粤嵌实训，基于linux做的五子棋玩家对战小项目，代码仅供参考（只写了落子和判断输赢部分），代码不完整，没有写悔棋啥的（懒），需要自己后期加工。

    python小项目之五子棋游戏

    主要为大家详细介绍了python小项目之五子棋游戏，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下

    《人工智能》--人工智能的专业开发项目，用Java开发的人机对战的五子棋项目，初步实现了人机的智能化下子.zip

    人工智能学习总结成果，希望可以帮到大家，有疑问欢迎随时沟通~ 人工智能学习总结成果，希望可以帮到大家，有疑问欢迎随时沟通~ 人工智能学习总结成果，希望可以帮到大家，有疑问欢迎随时沟通~ 人工智能学习总结...

    Qt网络五子棋游戏

    描述：Qt学习结束后的一个总结性的练习项目，实现两个客户端（邀请和接受方）联机游戏，其它的客户端观看的功能。总代码量1200行。服务器为linux系统编程实现共370行，客户端Qt实现共740行。主要用到的知识点：线程...

    《人工智能》--人工智能课程项目，五子棋.zip

    人工智能学习总结成果，希望可以帮到大家，有疑问欢迎随时沟通~ 人工智能学习总结成果，希望可以帮到大家，有疑问欢迎随时沟通~ 人工智能学习总结成果，希望可以帮到大家，有疑问欢迎随时沟通~ 人工智能学习总结...

    C语言案例精选，250多个案例

    C语言案例精选，250多个案例：五子棋，黑白棋游戏，工资管理，计算器，教师工作量计算，进程调度，迷宫问题，扫雷游戏，数据结构CAI系统，贪吃蛇游戏，学生管理系统等。此外，还包括：C语言函数速查，C语言库函数...

    asp.net知识库

    也论该不该在项目中使用存储过程代替SQL语句 如何使数据库中的表更有弹性,更易于扩展 存储过程——天使还是魔鬼 如何获取MSSQLServer,Oracel,Access中的数据字典信息 C#中利用GetOleDbSchemaTable获取数据库内表信息...

Magicbox
Global site tag (gtag.js) - Google Analytics