Java實現簡單的五子棋遊戲示例代碼

項目結構

這個是在網上找的資源,出處記不得瞭,記錄一下。程序的總體結構,很簡單的:

核心代碼

代碼如下:

ArrComparator.java類

import java.util.Comparator;

/**
 * 排序 Comparator
 */
class ArrComparator implements Comparator<Object> {
    int column = 2;

    int sortOrder = -1; // 遞減

    public ArrComparator() {
    }
    public int compare(Object a, Object b) {
        if (a instanceof int[]) {
            return sortOrder * (((int[]) a)[column] - ((int[]) b)[column]);
        }
        throw new IllegalArgumentException("param a,b must int[].");
    }
}

ChessMap.java類

import javax.swing.*;

import java.awt.*;
import java.awt.event.*;
import java.net.URL;
@SuppressWarnings("serial")
public class ChessMap extends JFrame {
	private ImageIcon map;				//棋盤背景位圖
	private ImageIcon blackchess;		//黑子位圖
	private ImageIcon whitechess;		//白子位圖
	private ChessPanel cp;				//棋盤
	private JPanel east;
	private JPanel west;
	private static final int FINAL_WIDTH = 450;
	private static final int FINAL_HEIGHT = 500;
	//以下為下拉菜單
	private JMenuBar menubar;			
	private JMenu[] menu={new JMenu("開始"),new JMenu("設置"),new JMenu("幫助")};
	private JMenuItem[] menuitem1={new JMenuItem("重新開始"),new JMenuItem("悔棋"),new JMenuItem("退出")};
	private JMenuItem[] menuitem2={new JMenuItem("禁手選擇"),new JMenuItem("人機博弈"),new JMenuItem("人人對弈")};
	private JMenuItem[] menuitem3={new JMenuItem("規則"),new JMenuItem("關於")};
	private boolean haveai=true;		//人與人下還是人與電腦下,true與電腦下
	Mouseclicked mouseclicked=new Mouseclicked();
	MouseMoved mousemoved=new MouseMoved();
	Menuitemclicked menuclicked=new Menuitemclicked();
	
	//構造函數
	public ChessMap(){
		//改變系統默認字體
		Font font = new Font("Dialog", Font.PLAIN, 12);
		java.util.Enumeration keys = UIManager.getDefaults().keys();
		while (keys.hasMoreElements()) {
			Object key = keys.nextElement();
			Object value = UIManager.get(key);
			if (value instanceof javax.swing.plaf.FontUIResource) {
				UIManager.put(key, font);
			}
		}
		setTitle("五子棋 ");
		setSize(FINAL_WIDTH,FINAL_HEIGHT);
		setResizable(false);
		init();
		setLocation(Toolkit.getDefaultToolkit().getScreenSize().width / 2
				- FINAL_WIDTH / 2, Toolkit.getDefaultToolkit()
				.getScreenSize().height
				/ 2 - FINAL_HEIGHT / 2);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		cp.reset();	
		setVisible(true);
	}
	
	//初始化與默認值
 	public void init() 
 	{
 		
		map=new ImageIcon(getClass().getResource("bg.jpg"));
		blackchess=new ImageIcon(getClass().getResource("blackchess.gif"));
		whitechess=new ImageIcon(getClass().getResource("whitechess.gif"));
		cp=new ChessPanel(map,blackchess,whitechess);
		menubar=new JMenuBar();
		menuitem1[0].setActionCommand("Restart");
		menuitem1[1].setActionCommand("Rollback");
		menuitem1[2].setActionCommand("Exit");
		menuitem2[0].setActionCommand("Forbid");
		menuitem2[1].setActionCommand("Robot");
		menuitem2[2].setActionCommand("Human");
		menuitem3[0].setActionCommand("Rule");
		menuitem3[1].setActionCommand("About");
		for(int i=0;i<3;i++)
			menu[0].add(menuitem1[i]);
		for(int i=0;i<3;i++)
			menu[1].add(menuitem2[i]);
		for(int i=0;i<2;i++)
			menu[2].add(menuitem3[i]);
		for(int i=0;i<3;i++)
			menubar.add(menu[i]);
		Container p = getContentPane();
		setJMenuBar(menubar);
		east = new JPanel();
		west = new JPanel();
		p.add(east, "East");
		p.add(west, "West");
		p.add(cp, "Center");
		cp.addMouseListener(mouseclicked);
		cp.addMouseMotionListener(mousemoved);
		menuitem1[0].addActionListener(menuclicked);
		menuitem1[1].addActionListener(menuclicked);
		menuitem1[2].addActionListener(menuclicked);
		menuitem2[0].addActionListener(menuclicked);
		menuitem2[1].addActionListener(menuclicked);
		menuitem2[2].addActionListener(menuclicked);
		menuitem3[0].addActionListener(menuclicked);
		menuitem3[1].addActionListener(menuclicked);
	
	}
	class Mouseclicked extends MouseAdapter		//判斷鼠標左擊並通知棋盤和電腦
	{
		public void mouseClicked(MouseEvent e)
		{
		  if(cp.win==false){
			    if(haveai){           //和電腦博弈
    		              Point p1=new Point();
    		              p1=cp.getPoint(e.getX(),e.getY());
    		              int x=p1.x;
    		              int y=p1.y;
                          // 如果該位置已經放置棋子
    		              System.out.println("x="+x+",y="+y);
                          if (cp.isChessOn[x][y] != 2)
                                     return;
                          // 玩傢為黑棋,考慮禁手
                          if( cp.able_flag && cp.bw == 0) {
             	                 int type = cp.getType(x,y,cp.bw);
             	                 String str = null;
             	                 switch(type){
             		             case 20: 
             			               str = "黑長連禁手!請選擇其它位置下棋!";
             			               break;
             		             case 21:
             			               str = "黑四四禁手!請選擇其它位置下棋!";
             			               break;
             		             case 22: 
             			               str = "黑三三禁手!請選擇其它位置下棋!";
             			               break;
             		             default : break;
             	                 }
             	                 if(str != null) {
             		                    JOptionPane.showMessageDialog(null,str);
             		                     return;
             	                 }
     		              }
                          boolean flag=cp.haveWin(x, y, cp.bw);
                          cp.update( x, y );
                          cp.putVoice();  //落子聲音
                          // 第一步棋,需初始化設置邊界值
                         if( cp.chess_num == 1){  
                      	 if(x-1>=0)
                     	          cp.x_min = x-1;
                         if(x-1<=15)
                     	          cp.x_max = x+1;
                         if(y-1>=0)
                     	          cp.y_min = y-1;
                         if(y-1<=15)
                     	          cp.y_max = y+1;
                  }
                 else 
                 	cp.resetMaxMin(x,y);
                 if (flag) {
                     cp.wined(1 - cp.bw);
                     return;
                 }
                 cp.putOne(cp.bw);
			}else{                                        //和人博弈
				Point p1=new Point();
 		        p1=cp.getPoint(e.getX(),e.getY());
 		        int x=p1.x;
 		        int y=p1.y;
                 // 如果該位置已經放置棋子
 		        System.out.println("x="+x+",y="+y);
                 if (cp.isChessOn[x][y] != 2)
                             return;
                 // 玩傢為黑棋,考慮禁手
                 if( cp.able_flag && cp.bw == 0) {
          	           int type = cp.getType(x,y,cp.bw);
          	           String str = null;
          	           switch(type){
          		       case 20: 
          			       str = "黑長連禁手!請選擇其它位置下棋!";
          			       break;
          		       case 21:
          			       str = "黑四四禁手!請選擇其它位置下棋!";
          			       break;
          		       case 22: 
          			       str = "黑三三禁手!請選擇其它位置下棋!";
          			       break;
          		       default : break;
          	           }
          	           if(str != null) {
          		               JOptionPane.showMessageDialog(null,str);
          		               return;
          	           }
  		       }
                boolean flag=cp.haveWin(x, y, cp.bw);
                cp.update( x, y );
                cp.putVoice();  //落子聲音
                cp.repaint();
              // 第一步棋,需初始化設置邊界值
              if( cp.chess_num == 1){  
              	if(x-1>=0)
                  	cp.x_min = x-1;
                  if(x-1<=15)
                  	cp.x_max = x+1;
                  if(y-1>=0)
                  	cp.y_min = y-1;
                  if(y-1<=15)
                  	cp.y_max = y+1;
              }
              else 
              	cp.resetMaxMin(x,y);
              if (flag) {
                  cp.wined(1 - cp.bw);
                  return;
              }
			}
    	} 
		}
	}
	class MouseMoved implements MouseMotionListener		//調試用,獲得鼠標位置
	{
		public void mouseMoved(MouseEvent e)
    	{
    		cp.showMousePos(e.getPoint());
    	}
    	public void mouseDragged(MouseEvent e)
    	{}
	}
	class Menuitemclicked implements ActionListener		//菜單消息處理
	{
		public void actionPerformed(ActionEvent e) 
		{
      		JMenuItem target = (JMenuItem)e.getSource();
      		String actionCommand = target.getActionCommand();
      		if(actionCommand.equals("Restart")){ 		//重開一局
        	   cp.reset();	
        	   if(cp.sbw==cp.WHITE_ONE)
        		   cp.update(7, 7); 
        	   //player=cp.BLACK_ONE;
      		}
      		if(actionCommand.equals("Rollback")){ 		//悔棋
      			if(cp.win) {
        			JOptionPane.showMessageDialog(null,"棋局已經結束,不能悔棋!請重新開始新的棋局!");
        			return;
                }
        		// 當前輪到玩傢下棋,取消兩步  否則,取消一步
        		if(cp.chess_num >= 2 && cp.bw == cp.sbw){
        			cp.isChessOn[cp.pre[cp.chess_num-1][0]][cp.pre[cp.chess_num-1][1]] = 2;
        			cp.isChessOn[cp.pre[cp.chess_num-2][0]][cp.pre[cp.chess_num-2][1]] = 2;
        			cp.chess_num -= 2;
        			cp.repaint();
        		}
        		else if(cp.chess_num >= 1 && cp.bw == 1-cp.sbw){
        			cp.isChessOn[cp.pre[cp.chess_num-1][0]][cp.pre[cp.chess_num-1][1]] = 2;
        			cp.chess_num --;
       				cp.repaint();
       			}
      		}
      		else if(actionCommand.equals("Exit")){ 		//退出
        		System.exit(1);	
      		}
      		else if(actionCommand.equals("Forbid")){     //禁手選擇
        		Object[] options = { "無禁手", "有禁手" };
        		int sel = JOptionPane.showOptionDialog(
          				null, "你的選擇:", "禁手選擇",
          				JOptionPane.DEFAULT_OPTION,
          				JOptionPane.QUESTION_MESSAGE, null,
          				options, options[0]);
          		if(sel==1){
                        cp.able_flag=true;
                        System.out.println("有禁手");
          		}else{
          			    cp.able_flag=false;
                        System.out.println("無禁手");
          		}
          	}
      		else if(actionCommand.equals("Robot")){            //人機博弈
      			haveai=true;
      			Object[] options = { "人類先手", "機器先手" };
        		int sel = JOptionPane.showOptionDialog(
          				null, "你的選擇:", "先手選擇",
          				JOptionPane.DEFAULT_OPTION,
          				JOptionPane.QUESTION_MESSAGE, null,
          				options, options[0]);
          		if(sel==1){       //機器先手
          			    cp.sbw=cp.WHITE_ONE;
          			    cp.update(7, 7);
          			    System.out.println("機器先手");
         			    
          		}else{             //人先手
          			    //player=cp.BLACK_ONE;
          			    cp.sbw=cp.BLACK_ONE;
          			    System.out.println("人先手");
          		}
      		}
          	else if(actionCommand.equals("Human")){ 		//人人博弈
        		haveai=false;	
        		cp.setHumanhuman(true);
      		}else if(actionCommand.equals("Rule")){          //規則
      			JOptionPane.showConfirmDialog(null,
      			"1、無禁手:" +"\n"+
				"   黑白雙方依次落子,任一方先在棋盤上形成連續的五個(含五個以上)棋子的一方為勝。" +"\n"+
				"2、有禁手:(走禁手就輸,禁手不能落子)" +"\n"+
				"   鑒於無禁手規則黑棋必勝,人們不斷采用一些方法限制黑棋先行的優勢,以平衡黑白雙方的形式。" +"\n"+
				"   於是針對黑棋的各種禁手逐漸形成。" +"\n"+
				"   禁手主要分為以下幾類:" +"\n"+
				"   (1)黑長連禁手:連成六個以上連續相同的棋子。" +"\n"+
				"   (2)黑三三禁手:兩個以上的活三。" + "\n"+
				"   (3)黑四四禁手:兩個以上的四。" + "\n"+
				"   禁手是針對黑棋而言的,白棋沒有任何禁手。" ,"規則",JOptionPane.CLOSED_OPTION,JOptionPane.INFORMATION_MESSAGE);
      		}
      		else if(actionCommand.equals("About")){ 		//版權與幫助
        		JOptionPane.showConfirmDialog(null,"團隊成員:\n" +"自行添加","關於",JOptionPane.CLOSED_OPTION,JOptionPane.INFORMATION_MESSAGE);	
      		}
    	}

	}
  public static void main(String[] args) {
	    new ChessMap();	
  }
} 

ChessPanel.java類

import javax.sound.sampled.AudioInputStream;
import javax.swing.*;
import java.applet.AudioClip;
import java.awt.*;
import java.net.URL;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Random;

@SuppressWarnings("serial")
public class ChessPanel extends JPanel{
	private ImageIcon map;					//棋盤背景位圖
  	private ImageIcon blackchess;			//黑子位圖
  	private ImageIcon whitechess;			//白子位圖
  	public int isChessOn [][];				//棋局
    protected boolean win = false;          // 是否已經分出勝負
    protected int win_bw;                   // 勝利棋色
    protected int deep = 3, weight = 7;    // 搜索的深度以及廣度
    public int drawn_num = 110;           // 和棋步數
    int chess_num = 0;                      // 總落子數目
    public int[][] pre = new int[drawn_num + 1][2];    // 記錄下棋點的x,y坐標   最多 (drawn_num + 1) 個
    public int sbw = 0;                          //玩傢棋色黑色0,白色1
    public int bw = 0;                           // 當前應該下的棋色  0:黑色(默認), 1:白色
  	  // 邊界值,用於速度優化
    protected int x_max = 15, x_min = 0;
    protected int y_max = 15, y_min = 0;
    protected boolean able_flag = true;       // 是否選擇禁手標志 0:無禁手  1:有禁手(默認
  	private int h;							//棋子長
 	private int w;							//棋子寬
 	private int insx;						//插入棋子的位置
 	private int insy;
 	private Point mousePoint;				//鼠標當前位置
 	private int winer;						//獲勝方
    private boolean humanhuman=false;       //是否是人人對弈
 	private int plast=0;					//走瞭幾步瞭,
 	public int BLACK_ONE;					//0表黑子
 	public int WHITE_ONE;					//1表白子
 	public int NONE_ONE;					//2表無子
 	public int N;							//棋盤邊長
 
 	//-------聲音
 	 String[] choics = { "put.wav", "win.wav","lost.wav" }; //聲音文件名數組
 	 URL file1 = getClass().getResource(choics[0]); //落子聲音文件
 	 URL file2 = getClass().getResource(choics[1]); //獲勝聲音文件
 	 URL file3 = getClass().getResource(choics[2]); //失敗聲音文件
 	 AudioClip soundPut = java.applet.Applet.newAudioClip(file1); //落子聲音剪輯對象
 	 AudioClip soundWin = java.applet.Applet.newAudioClip(file2); //獲勝聲音剪輯對象
 	 AudioClip soundLost = java.applet.Applet.newAudioClip(file3); //失敗聲音剪輯對象
 	
 	public ChessPanel(){}
 	public ChessPanel(ImageIcon r_map,ImageIcon r_blackchess,ImageIcon r_whitechess) {
 		
 		N=15;
 		map=new ImageIcon();
 		blackchess=new ImageIcon();
 		whitechess=new ImageIcon();
  		map=r_map;
  		blackchess=r_blackchess;
  		whitechess=r_whitechess;
  		NONE_ONE=2;
  		BLACK_ONE=0;
  		WHITE_ONE=1;
  		winer=NONE_ONE;
   		isChessOn=new int[N][N];
    	h=blackchess.getIconHeight()*(N-1);
    	w=blackchess.getIconWidth()*(N-1);
    	insx=0;
    	insy=0;
    	mousePoint=new Point();
    	
    }
	
    public void reset(){							//重開一局
  		winer=NONE_ONE;
  		for(int i=0;i<N;i++)
  			for(int j=0;j<N;j++){
  				isChessOn[i][j]=NONE_ONE;
  			}
  		chess_num = 0;  
  		win = false; 
  		win_bw=2;
  		bw = 0;
  		x_max = 15; x_min = 0;
  	    y_max = 15;y_min = 0;
  		repaint();
    }
    public void showMousePos(Point p){				//調試用,顯示鼠標位置
  	    int cw;
  	    cw=h/N;
  	    mousePoint.x=p.x/cw;
  	    mousePoint.y=p.y/cw;
  	    repaint();
    }
    public Point getPoint(int x,int y){
    	int cw;
  	    insx=x;
  	    insy=y;
  	    cw=h/N;
  	  Point r=new Point(x/cw,y/cw);
  	  return r;
    }
  public void gameOver(int r_winer){			//遊戲勝負已分
  	winer=r_winer;
  }
  public void paint(Graphics g){				//整體佈局
    super.paint(g);
    paintChessMap(g); 
    paintChess(g);
    if(winer==BLACK_ONE){
    	g.drawString(new String("遊戲結束!黑棋獲勝!"),500,200);
    	
    }
    else if(winer==WHITE_ONE){
    	g.drawString(new String("遊戲結束!白棋獲勝!"),500,200);
    }
  }
  private void paintChessMap(Graphics g){		//畫棋盤
  	map.paintIcon(this,g,10,10);
  	int j;
    g.setColor(Color.BLACK);
    for(j=0;j<N;j++){							//畫線
    	g.drawLine(h/N/2,h/N*j+h/N/2,w-w/N+(N%2)*(h/N/2),h/N*j+h/N/2);
    	g.drawLine(w/N*j+h/N/2,h/N/2,w/N*j+h/N/2,h-h/N+(N%2)*(h/N/2));
    }
    g.fillRect(w/N*7+h/N/2-3,h/N*7+h/N/2-3,6,6);//畫5個黑方塊
    g.fillRect(w/N*3+h/N/2-3,h/N*3+h/N/2-3,6,6);
    g.fillRect(w/N*11+h/N/2-3,h/N*3+h/N/2-3,6,6);
    g.fillRect(w/N*3+h/N/2-3,h/N*11+h/N/2-3,6,6);
    g.fillRect(w/N*11+h/N/2-3,h/N*11+h/N/2-3,6,6);
  }
  private void paintChess(Graphics g){			//畫棋子
  		int i,j;
  		for(i=0;i<N;i++)
  			for(j=0;j<N;j++){
  				if(isChessOn[i][j]==BLACK_ONE){
  					blackchess.paintIcon(this,g,w/N*i,h/N*j);
  				}
  				else if(isChessOn[i][j]==WHITE_ONE){
  					whitechess.paintIcon(this,g,w/N*i,h/N*j);
  				}	
  			}
  }
  //-------------------------------下棋聲音設置-------------------------------------------------
  
  //落子聲音
  public void putVoice(){
		soundPut.play();     
  }
  //獲勝聲音
  public void winVoice(){
	   soundWin.play();
  }
  //失敗聲音
  public void lostVoice(){
	  soundLost.play();
  }
  
   //----------------------電腦下棋-------------------------------//
  public void  putOne(int bwf ) {  //bwf 棋色 0:黑色 1:白色
      int x, y, mx = -100000000;
      x = y = -1;
      // 搜索最優下棋點
      int[][] bests = getBests( bwf );
      for (int k = 0; k < bests.length; k++) {
          int i = bests[k][0];
          int j = bests[k][1];
          // 有成5,則直接下子,並退出循環..沒有,則思考對方情況
          if (getType(i, j, bwf) == 1) {
              x = i;
              y = j;
              break;
          }
          if (getType(i, j,1 - bwf) == 1) {
              x = i;
              y = j;
              break;
          }
          // 預存當前邊界值
          int temp1=x_min,temp2=x_max,temp3=y_min,temp4=y_max;
          // 預設己方下棋,並更新邊界值
          isChessOn[i][j] = bwf;
          resetMaxMin(i,j);
          // 預測未來
          int t = findMin(-100000000, 100000000, deep);
          // 還原預設下棋位置以及邊界值
          isChessOn[i][j] = 2;
          x_min=temp1;
          x_max=temp2;
          y_min=temp3;
          y_max=temp4;
          // 差距小於1000,50%概率隨機選取
          //System.out.println("外       :" + i + "," + j + "  mx:" + mx + "  t:" + t);
          if (t - mx > 1000 || Math.abs(t - mx)<1000 && randomTest(3)) {
              x = i;
              y = j;
              mx = t;
              //System.out.println(i + "," + j + "  mx:" + mx + "  t:" + t);
          }
         
      }
      System.out.println("x="+x+",y="+y);
     // addChess(x,y,(bwf+1)%2,true);
     // repaint();
      int step=0;
		step++;
		System.out.println("step "+step+":-----------------------------------------------");
		for(int i=0;i<15;i++,System.out.print("\n"))
			for(int j=0;j<15;j++)
				{
					if(isChessOn[j][i]!=2)System.out.print(isChessOn[j][i]);
					else	System.out.print(isChessOn[j][i]);
				}	
  	// 判斷是否已分勝負
   	boolean flag = haveWin(x, y, bwf);
       //記錄
      update( x, y );
      repaint();
      // 重設邊界值
      resetMaxMin(x,y);
     //  勝負已分
      if (flag) 
          wined(bwf);
      if (!flag && chess_num >= drawn_num) {
          win = true;
          String str = drawn_num + "步沒分勝負,判和棋!";
          JOptionPane.showMessageDialog(null,str);
          return;
      }
         
  }
  
  //---------搜索當前搜索狀態極大值--------------------------------//
  //alpha 祖先節點得到的當前最小最大值,用於alpha 剪枝
  //beta  祖先節點得到的當前最大最小值,用於beta 剪枝。
  //step  還要搜索的步數
  //return 當前搜索子樹極大值
  protected int findMax(int alpha, int beta, int step) {
  	int max = alpha;
      if (step == 0) {
          return evaluate();
      }
      int[][] rt = getBests(1 - sbw);
      for (int i = 0; i < rt.length; i++) {
          int x = rt[i][0];
      	int y = rt[i][1];
      	if (getType(x, y, 1 - sbw) == 1)   //電腦可取勝
      		return 100 * ( getMark(1) + step*1000 );
          isChessOn[x][y] = 1 - sbw;
          // 預存當前邊界值
          int temp1=x_min,temp2=x_max,temp3=y_min,temp4=y_max;
          resetMaxMin(x,y);
          int t = findMin(max, beta, step - 1);
          isChessOn[x][y] = 2;
          // 還原預設邊界值
          x_min=temp1;
          x_max=temp2;
          y_min=temp3;
          y_max=temp4;
          if (t > max)
          	max = t;
          //beta 剪枝
          if (max >= beta) 
              return max;
      }
      return max;
  }
  

   //-----------------------搜索當前搜索狀態極小值---------------------------------//
   //alpha 祖先節點得到的當前最小最大值,用於alpha 剪枝
  //beta  祖先節點得到的當前最大最小值,用於beta 剪枝
  //step  還要搜索的步數
 //return 當前搜索子樹極小值。
  protected int findMin(int alpha, int beta, int step) {
  	int min = beta;
      if (step == 0) {
          return evaluate();
      }
      int[][] rt = getBests(sbw);
      for (int i = 0; i < rt.length; i++) {
          int x = rt[i][0];
          int y = rt[i][1];
          int type = getType(x, y, sbw);
          if (type == 1)     					  			//玩傢成5
              return -100 * ( getMark(1) + step*1000 );
          // 預存當前邊界值
          int temp1=x_min,temp2=x_max,temp3=y_min,temp4=y_max;
          isChessOn[x][y] = sbw;
          resetMaxMin(x,y);
          int t = findMax( alpha, min, step - 1 );
          isChessOn[x][y] = 2;
          // 還原預設邊界值
          x_min=temp1;
          x_max=temp2;
          y_min=temp3;
          y_max=temp4;
          if (t < min)
          	min = t;
          //alpha 剪枝
          if (min <= alpha) {
              return min;
          }
      }
      return min;
  }


   //-----------------選取局部最優的幾個落子點作為下一次擴展的節點---------//
   //bwf 棋色 0:黑棋 1:白棋
   //return 選出來的節點坐標
  private int[][] getBests(int bwf) {

      int i_min=(x_min==0 ? x_min:x_min-1);
      int j_min=(y_min==0 ? y_min:y_min-1);
      int i_max=(x_max==15 ? x_max:x_max+1);
      int j_max=(y_max==15 ? y_max:y_max+1);
      int n = 0;
      int type_1,type_2;
      int[][] rt = new int[(i_max-i_min) * (j_max-j_min)][3];
      for ( int i = i_min; i < i_max; i++) 
      	for (int j = j_min; j < j_max; j++)
      		if (isChessOn[i][j] == 2) {
                  type_1 = getType(i, j, bwf);
                  type_2 = getType(i, j, 1 - bwf);
                  if(able_flag && bwf==0 && (type_1 == 20 || type_1 == 21 || type_1 == 22)) // 禁手棋位置,不記錄
                  	continue;
                  rt[n][0] = i;
                  rt[n][1] = j;
                  rt[n][2] = getMark(type_1) + getMark(type_2);
                  n++;
      }
      // 對二維數組排序
      Arrays.sort(rt, new ArrComparator());
      int size = weight > n? n:weight;
      int[][] bests = new int[size][3];
      System.arraycopy(rt, 0, bests, 0, size);
      return bests;
  }

   //----------------------------計算指定方位上的棋型-------------------//
   // x,y 方向線基準一點。
   //ex,ey 指定方向步進向量。
   // k 棋子顏色,0:黑色,1:白色
   // 該方向上的棋子數目 以及 活度
  private int[] count(int x, int y, int ex, int ey, int bwf) {
  	// 該方向沒意義,返回0
      if( !makesense(x, y, ex, ey, bwf))
          return new int[] {0, 1};
      
      // 正方向 以及 反方向棋子個數
  	int rt_1 = 1,rt_2 = 1;
  	// 總棋子個數
  	int rt = 1;
  	// 正方向 以及 反方向連子的活度
      int ok_1 = 0,ok_2 =0;
      // 總活度
      int ok = 0;
      // 連子中間有無空格
      boolean flag_mid1 =false,flag_mid2 = false;
      // 連子中間空格的位置
      int flag_i1 = 1,flag_i2 = 1;
      
      if (isChessOn[x][y] != 2) {
          throw new IllegalArgumentException("position x,y must be empty!..");
      }
      int i;
      // 往正方向搜索
      for (i = 1; x + i * ex < 15 && x + i * ex >= 0 && y + i * ey < 15 && y + i * ey >= 0; i++) {
          if (isChessOn[x + i * ex][y + i * ey] == bwf)
              rt_1++;
      	// 位置為空,若中空標志為false,則記為中空並繼續搜索  否則,break
          else if(isChessOn[x + i * ex][y + i * ey] == 2) {
          		if(!flag_mid1) {
          			flag_mid1 = true;
          			flag_i1 = i;
          		}
          		else 
          			break;
          	}
          // 位置為對方棋子
          else    
          	break;
      }
      // 計算正方向活度,,
      // 最後一個位置不超過邊界
      if (x + i * ex < 15 && x + i * ex >= 0 && y + i * ey < 15 && y + i * ey >= 0) {
      	// 最後一個位置為空位 +1活
      	if( isChessOn[x + i * ex][y + i * ey] == 2) {
      		ok_1++;
      		// 若是在尾部檢測到連續的空格而退出搜索,則不算有中空
              if(rt_1 == flag_i1)
      			flag_mid1 = false;
              // 若中空的位置在4以下 且 棋子數>=4,則這一邊的4非活
              if(flag_mid1 && rt_1 > 3 && flag_i1 < 4) {
              	ok_1--;
              }
      	}
      	// 最後一個位置不是空格,且搜索瞭2步以上,若前一個是空格,  則不算中空,且為活的邊
      	else if( isChessOn[x + i * ex][y + i * ey] != bwf && i >= 2) 
          	if(isChessOn[x + (i-1) * ex][y + (i-1) * ey] == 2) {
          		ok_1++;
          		flag_mid1 = false;
          	}
      }
      // 最後一個位置是邊界  搜索瞭2步以上,且前一個是空格,  則不算中空,且為活的邊
      else if(i >= 2 && isChessOn[x + (i-1) * ex][y + (i-1) * ey] == 2) {
      	ok_1++;
      	flag_mid1 = false;
      }
      
      // 往反方向搜索        
      for (i = 1; x - i * ex >= 0 && x - i * ex < 15 && y - i * ey >= 0 && y - i * ey < 15; i++) {
          if (isChessOn[x - i * ex][y - i * ey] == bwf)
              rt_2++;
          else if(isChessOn[x - i * ex][y - i * ey] == 2) {
          		if(!flag_mid2) {
          			flag_mid2 = true;
          			flag_i2 = i;
          		}
          		else
          			break;
          	}
          else
              break;
      }
      // 計算反方向活度
      if (x - i * ex < 15 && x - i * ex >= 0 && y - i * ey < 15 && y - i * ey >= 0) {
      	if( isChessOn[x - i * ex][y - i * ey] == 2) {
      		ok_2++;
      		if(rt_2 == flag_i2)
      			flag_mid2 = false;
      	    if(flag_mid2 && rt_2 > 3 && flag_i2 < 4) {
              	ok_2--;
              }
      	}
      	else if( isChessOn[x - i * ex][y - i * ey] != bwf && i >= 2 ) 
      		if(isChessOn[x - (i-1) * ex][y - (i-1) * ey] == 2) {
      			ok_2++;
      			flag_mid2 = false;
      		}
      }
      else if(i >= 2 && isChessOn[x - (i-1) * ex][y - (i-1) * ey] == 2) {
      	ok_2++;
  		flag_mid2 = false;
      }
      
      //------------------分析棋子類型
      // 兩邊都沒中空,直接合成
      if( !flag_mid1 && !flag_mid2 ) {
      	rt = rt_1 + rt_2 - 1;
      	ok = ok_1 + ok_2;
      	return new int[] {rt, ok};
      }
      // 兩邊都有中空
      else if( flag_mid1 && flag_mid2 ){
      	int temp = flag_i1 + flag_i2 - 1;
      	// 判斷中間的純連子數,在5以上,直接返回;  為4,返回活4;  
      	if(temp >= 5)
      		return new int[] {temp, 2};
      	if(temp == 4) 
      		return new int[] {temp, 2};
      	// 先看有沒死4,再看有沒活3,剩下隻能是死3
      	if(rt_1 + flag_i2 - 1 >= 4 || rt_2 + flag_i1 - 1 >= 4) 
      		return new int[] {4, 1};
      	if(rt_1+flag_i2-1 == 3 && ok_1 > 0 || rt_2+flag_i1-1 == 3 && ok_2 > 0)
      		return new int[] {3, 2};
      	return new int[] {3, 1};
      }
      // 有一邊有中空
      else {
      	// 總棋子數少於5,直接合成
      	if( rt_1 + rt_2 - 1 < 5 )
      		return new int[] {rt_1 + rt_2 - 1, ok_1 + ok_2};
      	// 多於5,先找成5,再找活4,剩下的隻能是死4
      	else {
      		if(flag_mid1 && rt_2 + flag_i1 - 1 >= 5) 
      			return new int[] {rt_2 + flag_i1 - 1, ok_2 + 1};
      		if(flag_mid2 && rt_1 + flag_i2 - 1 >= 5) 
      			return new int[] {rt_1 + flag_i2 - 1, ok_1 + 1};
      		
      		if(flag_mid1 && (rt_2 + flag_i1 - 1 == 4 && ok_2 == 1 || flag_i1 == 4) )
      			return new int[] {4, 2};
      		if(flag_mid2 && (rt_1 + flag_i2 - 1 == 4 && ok_1 == 1 || flag_i2 == 4) )
      			return new int[] {4, 2};
      		
      		return new int[] {4, 1};
      	}
      }
  }

   //----------------------------判斷指定方向下棋是否有意義,即最大可能的棋子數是否 >=5-------------------------------//
   // x,y 評估的基準點
   // ex,ey 方向向量
   // k 棋色
   // true:有意義 false:沒意義
  private Boolean makesense(int x, int y, int ex, int ey, int bwf) {

      int rt = 1;
      for (int i = 1; x + i * ex < 15 && x + i * ex >= 0 && y + i * ey < 15 && y + i * ey >= 0 && rt < 5; i++)
          if (isChessOn[x + i * ex][y + i * ey] != 1 - bwf)
              rt++;
          else
              break;

      for (int i = 1; x - i * ex >= 0 && x - i * ex < 15 && y - i * ey >= 0 && y - i * ey < 15 && rt < 5; i++)
          if (isChessOn[x - i * ex][y - i * ey] != 1 - bwf)
              rt++;
          else
              break;
      return (rt >= 5);
  }

   //------------------------------------ 棋型判別-------------------------------------//
   // x,y 落子位置
   // bwf 棋色  0:黑子,1:白子
   // 對應的棋型: 棋型代碼對應如下:
   //             1:成5
   //             2:成活4或者是雙死4或者是死4活3
   //             3:成雙活3
   //             4:成死3活3
   //             5:成死4
   //             6:單活3
   //             7:成雙活2
  //             8:成死3
   //            9:成死2活2
   //            10:成活2
   //             11:成死2
   //             12: 其他
   //             20: 長連禁手
   //             21: 雙四禁手
   //            22: 雙活三禁手

  protected int getType(int x, int y, int bwf) {
  	if (isChessOn[x][y] != 2)
          return -1;
  	int[][] types = new int[4][2];
  	types[0] = count(x, y, 0, 1, bwf);   // 豎直
      types[1] = count(x, y, 1, 0, bwf);   // 橫向
      types[2] = count(x, y, -1, 1, bwf);  // 斜上
      types[3] = count(x, y, 1, 1, bwf);   // 斜下
      // 各種棋型的方向的數目
      int longfive = 0;
      int five_OR_more = 0;
      int four_died = 0, four_live = 0;
      int three_died = 0, three_live = 0;
      int two_died  = 0, two_live = 0;
      // 各方向上棋型的判別
      for (int k = 0; k < 4; k++) {
      	if (types[k][0] > 5) {  
      		longfive++;              // 長連
      		five_OR_more++;
      	}
      	else if (types[k][0] == 5)
      		five_OR_more++;          // 成5
          else if (types[k][0] == 4 && types[k][1] == 2)
          	four_live++;             // 活4
          else if (types[k][0] == 4 && types[k][1] != 2)
          	four_died++;             // 死4
          else if (types[k][0] == 3 && types[k][1] == 2)
          	three_live ++;           // 活3
          else if (types[k][0] == 3 && types[k][1] != 2)
          	three_died++;            // 死3
          else if (types[k][0] == 2 && types[k][1] == 2)
          	two_live++;              // 活2
          else if (types[k][0] == 2 && types[k][1] != 2)
          	two_died++;              // 死2
          else
              ;
      }
      // 總棋型的判別
      if(bwf == 0 && able_flag) {  		// 黑棋且選擇有禁手
      	if (longfive != 0)        		// 長連禁手
      		return 20;
      	if (four_live + four_died >=2)  // 雙4禁手
      		return 21;
      	if (three_live  >=2)        	// 雙活三禁手
      		return 22;
      }
      if (five_OR_more != 0)
          return 1;   // 成5
      if (four_live != 0 || four_died >= 2 || four_died != 0 && three_live  != 0)
          return 2;   // 成活4或者是雙死4或者是死4活3
      if (three_live  >= 2)
          return 3;   // 成雙活3
      if (three_died != 0 && three_live  != 0)
          return 4;   // 成死3活3
      if (four_died != 0)
          return 5;   // 成死4
      if (three_live  != 0)
          return 6;   // 單活3
      if (two_live >= 2)
          return 7;   // 成雙活2
      if (three_died != 0)
          return 8;   // 成死3
      if (two_live != 0 && two_died != 0)
          return 9;   // 成死2活2
      if (two_live != 0)
          return 10;  // 成活2
      if (two_died != 0)
          return 11;  // 成死2
      return 12;
  }

   //--------------------------對當前棋面進行打分------------------------------------------------------------//

  protected int evaluate() {
  	int rt = 0, mt_c = 1, mt_m = 1;
  	if(bw == sbw)
  		mt_m = 2;
  	else
  		mt_c = 2;
  	int i_min=(x_min==0 ? x_min:x_min-1);
      int j_min=(y_min==0 ? y_min:y_min-1);
      int i_max=(x_max==15 ? x_max:x_max+1);
      int j_max=(y_max==15 ? y_max:y_max+1);
      for (int i = i_min; i < i_max; i++)
          for (int j = j_min; j < j_max; j++)
              if (isChessOn[i][j] == 2) {
              	// 電腦棋面分數
                  int type = getType(i, j, 1 - sbw );
                  if(type == 1)      // 棋型1,棋型2以及棋型3,加權.  防止"4個雙活3"的局分大於"1個雙四"之類的錯誤出現
                  	rt += 30 * mt_c * getMark(type);
                  else if(type == 2)					
                  	rt += 10 * mt_c * getMark(type);
                  else if(type == 3)
                  	rt += 3 * mt_c * getMark(type);
                  else
                  	rt += mt_c * getMark(type);
                  // 玩傢棋面分數
                  type = getType(i, j, sbw );
                  if(type == 1)
                  	rt -= 30 * mt_m * getMark(type);
                  else if(type == 2)					
                  	rt -= 10 * mt_m * getMark(type);
                  else if(type == 3)
                  	rt -= 3 * mt_m * getMark(type);
                  else
                  	rt -= mt_m * getMark(type);
              }
      return rt;
  }

   //--------------------------------下棋後,更新信息-----------------------------//
  void update(int x,int y) {
  	isChessOn[x][y] = bw;
      bw = 1 - bw;
      pre[chess_num][0] = x;
      pre[chess_num][1] = y;
      chess_num++;
  }
  
   //-------------------------------------- 下棋後,重設邊界值------------------------------//
   // x 當前下棋位置的x坐標
   // y 當前下棋位置的y坐標

  public void resetMaxMin(int x,int y){
		if(x-1>=0)
      	x_min = (x_min<x-1 ? x_min:x-1);
      if(x+1<=15)
      	x_max = (x_max>x+1 ? x_max:x+1);
      if(y-1>=0)
      	y_min = (y_min<y-1 ? y_min:y-1);
      if(y+1<=15)
      	y_max = (y_max>y+1 ? y_max:y+1);
  
  }
  

   //------------------------------------------對分數相同的落子點,隨機選取-------------------//
   //   kt 隨機因子 值越小,被選取的概率越大
   //  return 是否選擇該位置

  private boolean randomTest(int kt) {
      Random rm = new Random();
      return rm.nextInt() % kt == 0;
  }


   //------------------------------------- 不同棋型對應分數---------------------------------
   // k 棋型代號
   //return 對應分數
  private int getMark(int k) {
      switch (k) {
      case 1:                   
          return 100000;
      case 2:                   
          return 30000;
      case 3:
          return 5000;
      case 4:
          return 1000;
      case 5:
          return 500;
      case 6:
          return 200;
      case 7:
          return 100;
      case 8:
          return 50;
      case 9:
          return 10;
      case 10:
          return 5;
      case 11:
          return 3;
      case 12:
       	  return 2;
      default:                     //禁手棋型
          return 0;
      }
  }

   //--------------------------------------- 判斷是否已分出勝負---------------------------------------------
   // x 落子點x坐標    y 落子點y坐標
   // bwf 棋色 0:黑色 1:白色
   // return true:分出勝負 false:未分出勝負

  public boolean haveWin(int x, int y, int bwf) {
      boolean flag = false;
      if (count(x, y, 1, 0, bwf)[0] >= 5)
          flag = true;
      if (!flag && count(x, y, 0, 1, bwf)[0] >= 5)
          flag = true;
      if (!flag && count(x, y, 1, 0, bwf)[0] >= 5)
          flag = true;
      if (!flag && count(x, y, 1, -1, bwf)[0] >= 5)
          flag = true;
      if (!flag && count(x, y, 1, 1, bwf)[0] >= 5)
          flag = true;
      // 測試用,激活此行代碼,不會有輸贏..   flag = false;
      return flag;
  }

  public void wined(int bw) {
	  boolean hh=getHumanhuman();
	  if(!hh){           //不是人人對弈
  	       win = true;
           win_bw = bw;
           String str = (bw == sbw ? "恭喜!你贏瞭!" : "電腦贏瞭,你還要繼續努力啊!");
           if(bw==sbw)
    	        winVoice();
           else
    	        lostVoice();
           JOptionPane.showMessageDialog(null,str);
	  }
	  else{             //人人對弈
		  win = true;
          win_bw = bw;
          String str = (bw == BLACK_ONE ? "恭喜!黑棋獲勝!" : "恭喜!白棋獲勝!");
   	      winVoice();
          JOptionPane.showMessageDialog(null,str);
	  }
  }
public void setHumanhuman(boolean humanhuman) {
	this.humanhuman = humanhuman;
}
public boolean getHumanhuman() {
	return humanhuman;
}
}

效果圖展示

運行截圖:

看瞭這麼多,是不是沒看懂,這裡給出鏈接,剩下的就靠大傢努力啦!

以上就是Java實現簡單的五子棋遊戲示例代碼的詳細內容,更多關於Java五子棋的資料請關註WalkonNet其它相關文章!

推薦閱讀: