本文实例为大家分享了java实现五子棋大战的具体代码，供大家参考，具体内容如下

这是我接近一年前的项目了，以前没有养成写博客的习惯，打算陆续把以前做过的项目补上来。

一、介绍
主要实现的功能有棋子颜色选择，悔棋，重新开始，玩家对战和人机对战，效果图如图所是：

模式选择：
https://zsrimg.ikafan.com/file_images/article/202203/2022325111336174.jpg?2022225111353
棋子选择：
https://zsrimg.ikafan.com/file_images/article/202203/2022325111403369.jpg?2022225111413
人机对战：
https://zsrimg.ikafan.com/file_images/article/202203/2022325111421262.jpg?2022225111431
玩家对战：
https://zsrimg.ikafan.com/file_images/article/202203/2022325111440409.jpg?2022225111449
*二、具体实现
五子棋的开发首先需要在界面上绘制一个表格，因为七班是不变的，棋子大小是不变的，所以我们首先可以自定义一个接口来设置项目中的常量，这样改变这些参数时也比较方便，CS.java代码如下：
public interface CS {
public static final int x0=60;//棋盘开始位置
public static final int y0=70;
public static final int line=15;//棋盘有多少条线
public static final int size=40;//棋子大小
和上一篇博客中的画图板类似，首先需要一个界面，这里可以定义一个Chess类继承Jframe,然后再重写paint(Graphics g)方法，来绘制棋盘，Chess.java代码如下：

Chess.java：
public class Chess extends JFrame implements CS{

  1.     int i=2;
  2.     private qizi qizilarry2[][]=new qizi[line][line];//用qizi类型的二维数组来存储棋子
  3.     private JButton b = new JButton("悔棋");
  4.     private JButton b2=new JButton("重新开始");
  5.     private JLabel jLabel=new JLabel("请选择对战模式");
  6.     private JLabel jLabel2=new JLabel("请选择棋子颜色");
  7.     private int value;//提示框选项的值
  8.     private int value2;
  9.     Dimension dimension=new Dimension(100, 30);
  10.     String color[]= {"白棋","黑棋"}; 
  11.     String moshi[]= {"玩家对战","人机对战"}; 
  13.     public void chessUI() {
  14.         b.setPreferredSize(dimension);
  15.         b2.setPreferredSize(dimension);
  16.         this.setSize(700, 700);
  17.         this.setLayout(new FlowLayout());
  18.         this.setTitle("五子棋");
  19.         this.setLocationRelativeTo(null);
  20.         this.setDefaultCloseOperation(3);
  21.         this.setVisible(true);
  22.         this.add(b);
  23.         this.add(b2);
  24.         value=JOptionPane.showOptionDialog(this, jLabel, "提示", JOptionPane.OK_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE, 
  25.                 null, moshi, null);
  26.         value2=JOptionPane.showOptionDialog(this, jLabel2, "提示", JOptionPane.OK_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE, 
  27.                 null, color, null);
  28.         //关闭提示框则退出程序 if(value==JOptionPane.CLOSED_OPTION||value2==JOptionPane.CLOSED_OPTION) {
  29.             System.exit(1);
  30.         }
  32.         Graphics g=this.getGraphics(); 
  33.         mouslistener mouslistener =new mouslistener(g,qizilarry2,this,value,value2);
  34.         this.addMouseListener(mouslistener);//窗口添加监听
  35.         b.addActionListener(mouslistener);//按钮添加监听
  36.         b2.addActionListener(mouslistener);
  38.     }
  40.     public void paint(Graphics g) {//重绘棋盘和棋子
  41.         super.paint(g);
  42.         drawChess(g);
  43.         drawQZ();
  45.     //画一个棋盘
  46.     public void drawChess(Graphics g) {
  47.         g.setColor(Color.black);
  48.         for(int i=0;i<line;i++) {
  49.             g.drawLine(x0, y0+size*i, x0+(line-1)*size, y0+size*i);
  50.         }
  51.         for(int j=0;j<line;j++) {
  52.             g.drawLine(x0+size*j, y0, x0+size*j, y0+(line-1)*size);
  53.         }
  54.     }
  55.     //重构画棋子
  56.     public void drawQZ() {
  57.         for(int ix=0;ix<line;ix++) {
  58.             for(int iy=0;iy<line;iy++) {
  59.                 if(qizilarry2[ix][iy]!=null) {
  60.                     qizi qizi21=qizilarry2[ix][iy];
  61.                     qizi21.drawq();
  63.                 }
  64.             }
  65.         }
  66.     }
  68.     public static void main(String[] args) {
  69.         new Chess().chessUI();
  70.     }
  72. }

用qizi类型的二维数组来存储棋子，在重绘时重绘整个棋盘和二维数组上的棋子，如果二维数组为null则不用重绘。
接下来该创建监听类了，在鼠标点击棋盘时，要使得棋子在棋盘的正中央，代码如下：
//x轴坐标 

  1. for(ix=0;x1>0;ix++) {
  2.     x1-=size;
  3. }
  4. x1+=size;
  5. x1-=size/2;
  6. ix--;
  7. if(x1<=0) {
  8.     x=x0+ix*size;
  9. }else
  10.     x=x0+(++ix)*size;
  11. //y轴坐标
  12. for(iy=0;y1>0;iy++) {
  13.     y1-=size;
  14. }
  15. y1+=size;
  16. y1-=size/2;
  17. iy--;
  18. if(y1<=0) {
  19.     y=y0+iy*size;
  20. }else
  21.     y=y0+(++iy)*size;

判赢的方法非常简单，只要计算棋子在它八个方向的相邻的且颜色相同的棋子个数即可，这里只展现向左查找棋子的代码（后续会附上整个监听类的代码）：

  1. public int zuo(int x,int y,Color c) {//向左找
  2.         int a=x;
  3.         for(int i=1;i<5;i++) {
  4.             a--;
  5.             if(a<0||qizilarry[a][y]==null) {
  6.                 break;
  7.             }else if(qizilarry[a][y].getColor()==c)
  8.                 count1++;
  9.             else 
  10.                 break;
  11.         }

return count1;
}
当模式为玩家和玩家模式时，需要每下一个棋子颜色改变，实现的代码如下：
if(a) {
color =c;
a=false;
}else {
color=c2;
a=true;
}
g.setColor(color);
g.fillOval(x-size/2, y-size/2, size, size);
prex=ix;
prey=iy;
qizi qizi=new qizi(g, color,ix,iy);
qizilarry[ix][iy]=qizi;
inte++;
玩家VS玩家和玩家VS电脑的判赢方法基本类似，这里只展现了玩家与玩家的判赢方法，即每下一个新的棋子，就计算这个棋子八个方向上相同且相邻棋子的个数，当同一直线两个方向的棋子个数之和为5时，则获取棋子颜色，判定为获胜，具体代码实现如下：
//判断输赢
if(zuo(ix,iy,color)+you(ix,iy,color)>=4||shang(ix,iy,color)+xia(ix,iy,color)>=4
||zuoshang(ix, iy,color)+youxia(ix, iy,color)>=4||zuoxia(ix, iy,color)+youshang(ix, iy,color)>=4) {
JLabel jLabel =new JLabel(“白棋获胜！”);
JLabel jlabel2 =new JLabel(“黑棋获胜！”);
if(color==Color.white)
JOptionPane.showMessageDialog(jFrame, jLabel, “游戏结束”, JOptionPane.PLAIN_MESSAGE);
else
JOptionPane.showMessageDialog(jFrame, jlabel2, “游戏结束”, JOptionPane.PLAIN_MESSAGE);
}else {
count1=0;//如果没有赢重新置0重新计算
count2=0;
countS=0;
countX=0;
countZS=0;
countZX=0;
countYS=0;
countYX=0;
}
这样玩家与玩家模式的大体功能就基本实现了，接下类就要实现五子棋的AI功能了

五子棋AI

这里我们主要针权值法讨论下，大致思路如下：

1.我们绘制好一个棋盘后，大小为 15*15；
2.下棋之前，对于棋盘中的每个空位，我们每都替电脑人“掂一掂”下在哪里合算；(估权过程)
3.对每个空位按照规则都计算完权重，我们找出权重最大的位置，此位置就是npc落子位置。

空子位置我们用 “0” 表示，白子用“2”表示，黑子用“1”表示；
我们主要分为以下几种情况：

定义 棋子相连情况 权值
活一连 010、020 40
活二连 0110、0220 400
活三连 01110、02220 3000
活四连 011110、022220 10000
眠一连 012、021 20
眠二连 0112、0221 200
眠三连 01112、02221 500
眠四连 011112、022221 3000
用hash表存储所有可能的情况并赋予一定的权值，每下一个棋子便更新棋盘上所有空位置的权值，电脑再寻找棋盘上权值最大的点下棋，computerChess()函数代码如下：
public void computerChess() {

  1.         hashMap.put("10000", 15);//眠1连
  2.         hashMap.put("20000", 10);//眠1连
  4.         hashMap.put("20100",17);//眠1连，15
  5.         hashMap.put("10200",12);//眠1连，10
  6.         hashMap.put("21000",15);//眠1连，15
  7.         hashMap.put("12000",10);//眠1连，10
  8.         hashMap.put("20010",19);//眠1连，15
  9.         hashMap.put("10020",14);//眠1连，10
  10.         hashMap.put("20100",17);//眠1连，15
  11.         hashMap.put("10200",12);//眠1连，10
  12. // 
  13. //        hashMap.put("00010",21);//活1连，15
  14. //        hashMap.put("00020",16);//活1连，10
  15. //        hashMap.put("00100",19);//活1连，15
  16. //        hashMap.put("00200",14);//活1连，10
  17. //        hashMap.put("01000",17);//活1连，15
  18. //        hashMap.put("02000",12);//活1连，10
  19. // 
  20.         //被堵住
  21.         hashMap.put("10100",65);//眠2连，40
  22.         hashMap.put("20200",60);//眠2连，30
  23.         hashMap.put("01100",65);//眠2连，40
  24.         hashMap.put("02200",60);//眠2连，30
  25.         hashMap.put("11000",65);//眠2连，40
  26.         hashMap.put("22000",60);//眠2连，30
  28.         hashMap.put("21010",65);//眠2连，40
  29.         hashMap.put("12020",60);//眠2连，30
  30.         hashMap.put("20110",65);//眠2连，40
  31.         hashMap.put("10220",60);//眠2连，30
  32.         hashMap.put("21100",65);//眠2连，40
  33.         hashMap.put("12200",60);//眠2连，30
  35. //        hashMap.put("01010",75);//活2连，40
  36. //        hashMap.put("02020",70);//活2连，30
  37. //        hashMap.put("00110",75);//活2连，40
  38. //        hashMap.put("00220",70);//活2连，30
  39. //        hashMap.put("01100",75);//活2连，40
  40. //        hashMap.put("02200",70);//活2连，30
  41. //        hashMap.put("11000",75);//活2连，40
  42. //        hashMap.put("00022",70);//活2连，30
  43. //        
  44. //        //被堵住
  45.         hashMap.put("11100",150);//眠3连，100
  46.         hashMap.put("22200",140);//眠3连，80
  47.         hashMap.put("21110",150);//眠3连，100
  48.         hashMap.put("12220",140);//眠3连，80
  49. //        
  50. //        hashMap.put("10110",1000);//活3连，130
  51. //        hashMap.put("20220",800);//活3连，110
  52. //        hashMap.put("11010",1000);//活3连，130
  53. //        hashMap.put("22020",800);//活3连，110
  54. //        hashMap.put("01110", 1000);//活3连
  55. //        hashMap.put("02220", 800);//活3连
  57.         hashMap.put("11110",3000);//4连，300
  58.         hashMap.put("11112",3000);//4连，300
  59.         hashMap.put("22220",3500);//4连，280
  60.         hashMap.put("22221",3500);//4连，280
  62.         int a;
  63.         int b;
  64.         for(int y=0;y<line;y++) {
  65.             for(int x=0;x<line;x++) {
  66.                 if(qizilarry[x][y]==null) {
  67.                     //向左
  68.                     a=x;
  69.                     for(int i=1;i<6;i++) {
  70.                         a--;
  71.                         if(a<0)
  72.                             break;
  73.                         if(qizilarry[a][y]!=null) {
  74.                             if(qizilarry[a][y].getColor()==c) {
  75.                                 zuo+='2';
  76.                             }else
  77.                                 zuo+='1';
  78.                         }else
  79.                             zuo+=0;
  80.                     }
  81.                     Integer integer=hashMap.get(zuo);
  82.                     if(integer!=null) 
  83.                         chessValue[x][y]+=integer;
  85.                     //向右
  86.                     a=x;
  87.                     for(int i=1;i<6;i++) {
  88.                         a++;
  89.                         if(a==line)
  90.                             break;
  91.                         if(qizilarry[a][y]!=null) {
  92.                             if(qizilarry[a][y].getColor()==c) {
  93.                                 you+='2';
  94.                             }else
  95.                                 you+='1';
  96.                         }else
  97.                             you+=0;
  98.                     }
  99.                     integer=hashMap.get(you);
  100.                     if(integer!=null) 
  101.                         chessValue[x][y]+=integer;
  103.                     //向上
  104.                     b=y;
  105.                     for(int i=1;i<6;i++) {
  106.                         b--;
  107.                         if(b<0)
  108.                             break;
  109.                         if(qizilarry[x][b]!=null) {
  110.                             if(qizilarry[x][b].getColor()==c) {
  111.                                 shang+='2';
  112.                             }else
  113.                                 shang+='1';
  114.                         }else
  115.                             shang+=0;
  116.                     }
  117.                     integer=hashMap.get(shang);
  118.                     if(integer!=null) 
  119.                         chessValue[x][y]+=integer;
  121.                     //向下
  122.                     b=y;
  123.                     for(int i=1;i<6;i++) {
  124.                         b++;
  125.                         if(b==line)
  126.                             break;
  127.                         if(qizilarry[x][b]!=null) {
  128.                             if(qizilarry[x][b].getColor()==c) {
  129.                                 xia+='2';
  130.                             }else
  131.                                 xia+='1';
  132.                         }else
  133.                             xia+=0;
  134.                     }
  135.                     integer=hashMap.get(xia);
  136.                     if(integer!=null) 
  137.                         chessValue[x][y]+=integer;
  139.                     //向左上
  140.                     a=x;
  141.                     b=y;
  142.                     for(int i=1;i<6;i++) {
  143.                         a--;
  144.                         b--;
  145.                         if(a<0||b<0)
  146.                             break;
  147.                         if(qizilarry[a][b]!=null) {
  148.                             if(qizilarry[a][b].getColor()==c) {
  149.                                 zuoshang+='2';
  150.                             }else
  151.                                 zuoshang+='1';
  152.                         }else
  153.                             zuoshang+=0;
  154.                     }
  155.                     integer=hashMap.get(zuoshang);
  156.                     if(integer!=null) 
  157.                         chessValue[x][y]+=integer;
  159.                     //向右下
  160.                     a=x;
  161.                     b=y;
  162.                     for(int i=1;i<6;i++) {
  163.                         a++;
  164.                         b++;
  165.                         if(a==line||b==line)
  166.                             break;
  167.                         if(qizilarry[a][b]!=null) {
  168.                             if(qizilarry[a][b].getColor()==c) {
  169.                                 youxia+='2';
  170.                             }else
  171.                                 youxia+='1';
  172.                         }else
  173.                             youxia+=0;
  174.                     }
  175.                     integer=hashMap.get(youxia);
  176.                     if(integer!=null) 
  177.                         chessValue[x][y]+=integer;
  179.                     //向左下
  180.                     a=x;
  181.                     b=y;
  182.                     for(int i=1;i<6;i++) {
  183.                         a--;
  184.                         b++;
  185.                         if(a<0||b==line)
  186.                             break;
  187.                         if(qizilarry[a][b]!=null) {
  188.                             if(qizilarry[a][b].getColor()==c) {
  189.                                 zuoxia+='2';
  190.                             }else
  191.                                 zuoxia+='1';
  192.                         }else
  193.                             zuoxia+=0;
  194.                     }
  195.                     integer=hashMap.get(zuoxia);
  196.                     if(integer!=null) 
  197.                         chessValue[x][y]+=integer;
  199.                     //向右上
  200.                     a=x;
  201.                     b=y;
  202.                     for(int i=1;i<6;i++) {
  203.                         a++;
  204.                         b--;
  205.                         if(a==line||b<0)
  206.                             break;
  207.                         if(qizilarry[a][b]!=null) {
  208.                             if(qizilarry[a][b].getColor()==c) {
  209.                                 youshang+='2';
  210.                             }else
  211.                                 youshang+='1';
  212.                         }else
  213.                             youshang+=0;
  214.                     }
  215.                     integer=hashMap.get(youshang);
  216.                     if(integer!=null) 
  217.                         chessValue[x][y]+=integer;
  218.                     zuo="";
  219.                     you="";
  220.                     shang="";
  221.                     xia="";
  222.                     zuoshang="";
  223.                     zuoxia="";
  224.                     youshang="";
  225.                     youxia="";
  226.                 }
  227.             }
  228.         }
  229.     }

完整代码

mouslistener.java:
public class mouslistener extends MouseAdapter implements CS,ActionListener{

  1.     private int x;//棋子像素坐标
  2.     private int y;
  3.     private int ix;//用户棋子坐标
  4.     private int iy;
  5.     private int cx;//电脑棋子坐标
  6.     private int cy;
  7.     private int n=1;//下黑棋或白棋
  8.     public int inte=0;//棋子数目
  9.     private int prex;//上一个棋子的坐标
  10.     private int prey;
  11.     private int count1=0;
  12.     private int count2=0;
  13.     private int countS=0;
  14.     private int countX=0;
  15.     private int countZS=0;
  16.     private int countYX=0;
  17.     private int countZX=0;
  18.     private int countYS=0;
  19.     private int value;
  20.     private int value2;
  21.     String zuo="";
  22.     String you="";
  23.     String shang="";
  24.     String xia="";
  25.     String zuoshang="";
  26.     String zuoxia="";
  27.     String youshang="";
  28.     String youxia="";
  29.     private boolean a=true;//玩家对战下棋顺序
  30.     private boolean b=true;//是否在同一个位置
  31. //    private boolean end=true;//是否电脑胜利
  32.     private Color c;//用户棋子颜色
  33.     private Color c2;//电脑棋子颜色
  34.     private Color color;//玩家对战颜色交替下棋
  35.     public qizi qizilarry[][]=new qizi[line][line];
  36.     private int chessValue[][]=new int[line][line];//权值表
  37.     private JLabel j=new JLabel("请选择对战模式");
  38.     private JLabel j2=new JLabel("请选择棋子颜色");
  39.     String moshi[]= {"玩家对战","人机对战"}; 
  40.     String co[]= {"白棋","黑棋"}; 
  41.     JFrame jFrame;//悔棋重绘传参 
  42.     Graphics g;
  43.     HashMap<String, Integer> hashMap=new HashMap<String, Integer>();
  46.     public mouslistener(Graphics g,qizi qizi[][],JFrame jFrame,int value,int value2) {
  47.         this.g=g;
  48.         qizilarry=qizi;
  49.         this.jFrame=jFrame;
  50.         this.value=value;
  51.         this.value2=value2;
  52.         if(value2==1) {
  53.             c=Color.black;
  54.             c2=Color.white;
  55.         }else {
  56.             c=Color.white;
  57.             c2=Color.black;
  58.         }
  60.     }
  64.     public void mouseClicked(MouseEvent e) {
  65.         x=e.getX();
  66.         y=e.getY();
  67.         int x1=x-x0;
  68.         int y1=y-y0;
  70.         //x轴坐标    
  71.         for(ix=0;x1>0;ix++) {
  72.             x1-=size;
  73.         }
  74.         x1+=size;
  75.         x1-=size/2;
  76.         ix--;
  77.         if(x1<=0) {
  78.             x=x0+ix*size;
  79.         }else
  80.             x=x0+(++ix)*size;
  81.         //y轴坐标
  82.         for(iy=0;y1>0;iy++) {
  83.             y1-=size;
  84.         }
  85.         y1+=size;
  86.         y1-=size/2;
  87.         iy--;
  88.         if(y1<=0) {
  89.             y=y0+iy*size;
  90.         }else
  91.             y=y0+(++iy)*size;
  92.         //判断是否在同一个地方    
  93.         b=true;
  94.         if(qizilarry[ix][iy]!=null) {
  95.             JLabel jLabel =new JLabel("不能下在同一个地方！");
  96.             JOptionPane.showMessageDialog(jFrame, jLabel, "警告", JOptionPane.WARNING_MESSAGE);
  97.             b=false;
  98.         }
  99.         //--------------------
  100.         //画圆及重构，一个黑棋一个白棋
  101.         //--------------------
  102.         if(b) {
  103.             if(value==1) {
  104.                 g.setColor(c);
  105.                 g.fillOval(x-size/2, y-size/2, size, size);
  106.                 prex=ix;
  107.                 prey=iy;
  108.                 qizi qizi=new qizi(g, c,ix,iy);
  109.                 qizilarry[ix][iy]=qizi;
  110.                 inte++;
  111.                 System.out.println("用户下棋");
  113.                 computerChess();
  114.                 int qzmax=0;
  115.                 for(int b=0;b<line;b++) {
  116.                     for(int a =0;a<line;a++) {
  117.                         if(chessValue[a][b]>qzmax) {
  118.                             qzmax=chessValue[a][b];
  119.                             cx=a;
  120.                             cy=b;
  121.                         }
  122.                     }
  123.                 }
  125.                 g.setColor(c2);
  126.                 g.fillOval(x0+cx*size-size/2, y0+cy*size-size/2, size, size);
  127.                 qizi qizi2=new qizi(g, c2,cx,cy);
  128.                 qizilarry[cx][cy]=qizi2;
  129.                 inte++;
  130.                 System.out.println("电脑下棋");
  132.                 for(int b=0;b<line;b++) {
  133.                     for(int a =0;a<line;a++) {
  134.                         chessValue[a][b]=0;
  136.                     }
  137.                 }
  139.                 //判断输赢
  140.                 if(zuo(ix,iy,c)+you(ix,iy,c)>=4||shang(ix,iy,c)+xia(ix,iy,c)>=4
  141.                         ||zuoshang(ix, iy,c)+youxia(ix, iy,c)>=4||zuoxia(ix, iy,c)+youshang(ix, iy,c)>=4) {
  142.                     JLabel jLabel =new JLabel("玩家获胜！");
  143.                     JOptionPane.showMessageDialog(jFrame, jLabel, "游戏结束", JOptionPane.PLAIN_MESSAGE);
  144.                 }else {
  145.                     count1=0;
  146.                     count2=0;
  147.                     countS=0;
  148.                     countX=0;
  149.                     countZS=0;
  150.                     countZX=0;
  151.                     countYS=0;
  152.                     countYX=0;
  153.                     if((zuo(cx,cy,c2)+you(cx,cy,c2)>=4||shang(cx,cy,c2)+xia(cx,cy,c2)>=4
  154.                             ||zuoshang(cx, cy,c2)+youxia(cx, cy,c2)>=4||zuoxia(cx, cy,c2)+youshang(cx, cy,c2)>=4) ){
  155.                         JLabel jLabel =new JLabel("电脑获胜！");
  156.                         JOptionPane.showMessageDialog(jFrame, jLabel, "游戏结束", JOptionPane.PLAIN_MESSAGE);
  157.                     }else {
  158.                         count1=0;
  159.                         count2=0;
  160.                         countS=0;
  161.                         countX=0;
  162.                         countZS=0;
  163.                         countZX=0;
  164.                         countYS=0;
  165.                         countYX=0;
  166.                     }
  167.                 }
  168.             }else {
  169.                 if(a) {
  170.                     color =c;
  171.                     a=false;
  172.                 }else {
  173.                     color=c2;
  174.                     a=true;
  175.                 }
  176.                 g.setColor(color);
  177.                 g.fillOval(x-size/2, y-size/2, size, size);
  178.                 prex=ix;
  179.                 prey=iy;
  180.                 qizi qizi=new qizi(g, color,ix,iy);
  181.                 qizilarry[ix][iy]=qizi;
  182.                 inte++;
  185.                 //判断输赢
  186.                 if(zuo(ix,iy,color)+you(ix,iy,color)>=4||shang(ix,iy,color)+xia(ix,iy,color)>=4
  187.                         ||zuoshang(ix, iy,color)+youxia(ix, iy,color)>=4||zuoxia(ix, iy,color)+youshang(ix, iy,color)>=4) {
  188.                     JLabel jLabel =new JLabel("白棋获胜！");
  189.                     JLabel jlabel2 =new JLabel("黑棋获胜！");
  190.                     if(color==Color.white)
  191.                         JOptionPane.showMessageDialog(jFrame, jLabel, "游戏结束", JOptionPane.PLAIN_MESSAGE);
  192.                     else
  193.                         JOptionPane.showMessageDialog(jFrame, jlabel2, "游戏结束", JOptionPane.PLAIN_MESSAGE);
  194.                 }else {
  195.                     count1=0;//如果没有赢重新置0重新计算
  196.                     count2=0;
  197.                     countS=0;
  198.                     countX=0;
  199.                     countZS=0;
  200.                     countZX=0;
  201.                     countYS=0;
  202.                     countYX=0;
  203.                 }
  204.             }
  207.         }
  213.     }
  215.     public int zuo(int x,int y,Color c) {//向左找
  216.         int a=x;
  217.         for(int i=1;i<5;i++) {
  218.             a--;
  219.             if(a<0||qizilarry[a][y]==null) {
  220.                 break;
  221.             }else if(qizilarry[a][y].getColor()==c)
  222.                 count1++;
  223.             else 
  224.                 break;
  225.         }
  227.         return count1;
  228.     }
  230.     public int you(int x,int y,Color c){//向右找
  231.         int a =x;
  232.         for(int i=1;i<5;i++) {
  233.             a++;
  234.             if(a==15||qizilarry[a][y]==null) {
  235.                 break;
  236.             }else if(qizilarry[a][y].getColor()==c)
  237.                 count2++;
  238.             else 
  239.                 break;
  240.         }
  241.         return count2;
  242.     }
  244.     public int xia(int x,int y,Color c) {//向下找
  245.         int a=y;
  246.         for(int i=1;i<5;i++) {
  247.             a++;
  248.             if(a==15||qizilarry[x][a]==null) {
  249.                 break;
  250.             }else if(qizilarry[x][a].getColor()==c)
  251.                 countX++;
  252.             else 
  253.                 break;
  254.         }
  255.         return countX;
  256.     }
  258.     public int shang(int x,int y,Color c){//向上找
  259.         int a =y;
  260.         for(int i=1;i<5;i++) {
  261.             a--;
  262.             if(a<0||qizilarry[x][a]==null) {
  263.                 break;
  264.             }else if(qizilarry[x][a].getColor()==c)
  265.                 countS++;
  266.             else 
  267.                 break;
  268.         }
  269.         return countS;
  270.     }
  272.     public int zuoshang(int x,int y,Color c) {//向左上找
  273.         int a=x;
  274.         int b=y;
  275.         for(int i=1;i<5;i++) {
  276.             a--;
  277.             b++;
  278.             if(a<0||b==15||qizilarry[a][b]==null) {
  279.                 break;
  280.             }else if(qizilarry[a][b].getColor()==c)
  281.                 countZS++;
  282.             else 
  283.                 break;
  284.         }
  285.         return countZS;
  286.     }
  288.     public int youxia(int x,int y,Color c) {//向右下找
  289.         int a=x;
  290.         int b=y;
  291.         for(int i=1;i<5;i++) {
  292.             a++;
  293.             b--;
  294.             if(b<0||a==15||qizilarry[a][b]==null) {
  295.                 break;
  296.             }else if(qizilarry[a][b].getColor()==c)
  297.                 countYX++;
  298.             else 
  299.                 break;
  300.         }
  301.         return countYX;
  302.     }
  304.     public int zuoxia(int x,int y,Color c) {//向左下找
  305.         int a=x;
  306.         int b=y;
  307.         for(int i=1;i<5;i++) {
  308.             a--;
  309.             b--;
  310.             if(a<0||b<0||qizilarry[a][b]==null) {
  311.                 break;
  312.             }else if(qizilarry[a][b].getColor()==c)
  313.                 countZX++;
  314.             else 
  315.                 break;
  316.         }
  317.         return countZX;
  318.     }
  320.     public int youshang(int x,int y,Color c) {//向右上找
  321.         int a=x;
  322.         int b=y;
  323.         for(int i=1;i<5;i++) {
  324.             a++;
  325.             b++;
  326.             if(a==15||b==15||qizilarry[a][b]==null) {
  327.                 break;
  328.             }else if(qizilarry[a][b].getColor()==c)
  329.                 countYS++;
  330.             else 
  331.                 break;
  332.         }
  333.         return countYS;
  334.     }
  336.     public void computerChess() {
  338.         hashMap.put("10000", 15);//眠1连
  339.         hashMap.put("20000", 10);//眠1连
  341.         hashMap.put("20100",17);//眠1连，15
  342.         hashMap.put("10200",12);//眠1连，10
  343.         hashMap.put("21000",15);//眠1连，15
  344.         hashMap.put("12000",10);//眠1连，10
  345.         hashMap.put("20010",19);//眠1连，15
  346.         hashMap.put("10020",14);//眠1连，10
  347.         hashMap.put("20100",17);//眠1连，15
  348.         hashMap.put("10200",12);//眠1连，10
  349. // 
  350. //        hashMap.put("00010",21);//活1连，15
  351. //        hashMap.put("00020",16);//活1连，10
  352. //        hashMap.put("00100",19);//活1连，15
  353. //        hashMap.put("00200",14);//活1连，10
  354. //        hashMap.put("01000",17);//活1连，15
  355. //        hashMap.put("02000",12);//活1连，10
  356. // 
  357.         //被堵住
  358.         hashMap.put("10100",65);//眠2连，40
  359.         hashMap.put("20200",60);//眠2连，30
  360.         hashMap.put("01100",65);//眠2连，40
  361.         hashMap.put("02200",60);//眠2连，30
  362.         hashMap.put("11000",65);//眠2连，40
  363.         hashMap.put("22000",60);//眠2连，30
  365.         hashMap.put("21010",65);//眠2连，40
  366.         hashMap.put("12020",60);//眠2连，30
  367.         hashMap.put("20110",65);//眠2连，40
  368.         hashMap.put("10220",60);//眠2连，30
  369.         hashMap.put("21100",65);//眠2连，40
  370.         hashMap.put("12200",60);//眠2连，30
  372. //        hashMap.put("01010",75);//活2连，40
  373. //        hashMap.put("02020",70);//活2连，30
  374. //        hashMap.put("00110",75);//活2连，40
  375. //        hashMap.put("00220",70);//活2连，30
  376. //        hashMap.put("01100",75);//活2连，40
  377. //        hashMap.put("02200",70);//活2连，30
  378. //        hashMap.put("11000",75);//活2连，40
  379. //        hashMap.put("00022",70);//活2连，30
  380. ////被堵住
  381.         hashMap.put("11100",150);//眠3连，100
  382.         hashMap.put("22200",140);//眠3连，80
  383.         hashMap.put("21110",150);//眠3连，100
  384.         hashMap.put("12220",140);//眠3连，80
  385. /
  386. //        hashMap.put("10110",1000);//活3连，130
  387. //        hashMap.put("20220",800);//活3连，110
  388. //        hashMap.put("11010",1000);//活3连，130
  389. //        hashMap.put("22020",800);//活3连，110
  390. //        hashMap.put("01110", 1000);//活3连
  391. //        hashMap.put("02220", 800);//活3连
  393.         hashMap.put("11110",3000);//4连，300
  394.         hashMap.put("11112",3000);//4连，300
  395.         hashMap.put("22220",3500);//4连，280
  396.         hashMap.put("22221",3500);//4连，280
  398.         int a;
  399.         int b;
  400.         for(int y=0;y<line;y++) {
  401.             for(int x=0;x<line;x++) {
  402.                 if(qizilarry[x][y]==null) {
  403.                     //向左
  404.                     a=x;
  405.                     for(int i=1;i<6;i++) {
  406.                         a--;
  407.                         if(a<0)
  408.                             break;
  409.                         if(qizilarry[a][y]!=null) {
  410.                             if(qizilarry[a][y].getColor()==c) {
  411.                                 zuo+='2';
  412.                             }else
  413.                                 zuo+='1';
  414.                         }else
  415.                             zuo+=0;
  416.                     }
  417.                     Integer integer=hashMap.get(zuo);
  418.                     if(integer!=null) 
  419.                         chessValue[x][y]+=integer;
  421.                     //向右
  422.                     a=x;
  423.                     for(int i=1;i<6;i++) {
  424.                         a++;
  425.                         if(a==line)
  426.                             break;
  427.                         if(qizilarry[a][y]!=null) {
  428.                             if(qizilarry[a][y].getColor()==c) {
  429.                                 you+='2';
  430.                             }else
  431.                                 you+='1';
  432.                         }else
  433.                             you+=0;
  434.                     }
  435.                     integer=hashMap.get(you);
  436.                     if(integer!=null) 
  437.                         chessValue[x][y]+=integer;
  439.                     //向上
  440.                     b=y;
  441.                     for(int i=1;i<6;i++) {
  442.                         b--;
  443.                         if(b<0)
  444.                             break;
  445.                         if(qizilarry[x][b]!=null) {
  446.                             if(qizilarry[x][b].getColor()==c) {
  447.                                 shang+='2';
  448.                             }else
  449.                                 shang+='1';
  450.                         }else
  451.                             shang+=0;
  452.                     }
  453.                     integer=hashMap.get(shang);
  454.                     if(integer!=null) 
  455.                         chessValue[x][y]+=integer;

下
b=y;
for(int i=1;i<6;i++) {
b++;
if(b==line)
break;
if(qizilarry[x][b]!=null) {
if(qizilarry[x][b].getColor()==c) {
xia+=’2’;
}else
xia+=’1’;
}else
xia+=0;
}
integer=hashMap.get(xia);
if(integer!=null)
chessValue[x][y]+=integer;

  1.                     //向左上
  2.                     a=x;
  3.                     b=y;
  4.                     for(int i=1;i<6;i++) {
  5.                         a--;
  6.                         b--;
  7.                         if(a<0||b<0)
  8.                             break;
  9.                         if(qizilarry[a][b]!=null) {
  10.                             if(qizilarry[a][b].getColor()==c) {
  11.                                 zuoshang+='2';
  12.                             }else
  13.                                 zuoshang+='1';
  14.                         }else
  15.                             zuoshang+=0;
  16.                     }
  17.                     integer=hashMap.get(zuoshang);
  18.                     if(integer!=null) 
  19.                         chessValue[x][y]+=integer;
  21.                     //向右下
  22.                     a=x;
  23.                     b=y;
  24.                     for(int i=1;i<6;i++) {
  25.                         a++;
  26.                         b++;
  27.                         if(a==line||b==line)
  28.                             break;
  29.                         if(qizilarry[a][b]!=null) {
  30.                             if(qizilarry[a][b].getColor()==c) {
  31.                                 youxia+='2';
  32.                             }else
  33.                                 youxia+='1';
  34.                         }else
  35.                             youxia+=0;
  36.                     }
  37.                     integer=hashMap.get(youxia);
  38.                     if(integer!=null) 
  39.                         chessValue[x][y]+=integer;
  41.                     //向左下
  42.                     a=x;
  43.                     b=y;
  44.                     for(int i=1;i<6;i++) {
  45.                         a--;
  46.                         b++;
  47.                         if(a<0||b==line)
  48.                             break;
  49.                         if(qizilarry[a][b]!=null) {
  50.                             if(qizilarry[a][b].getColor()==c) {
  51.                                 zuoxia+='2';
  52.                             }else
  53.                                 zuoxia+='1';
  54.                         }else
  55.                             zuoxia+=0;
  56.                     }
  57.                     integer=hashMap.get(zuoxia);
  58.                     if(integer!=null) 
  59.                         chessValue[x][y]+=integer;
  61.                     //向右上
  62.                     a=x;
  63.                     b=y;
  64.                     for(int i=1;i<6;i++) {
  65.                         a++;
  66.                         b--;
  67.                         if(a==line||b<0)
  68.                             break;
  69.                         if(qizilarry[a][b]!=null) {
  70.                             if(qizilarry[a][b].getColor()==c) {
  71.                                 youshang+='2';
  72.                             }else
  73.                                 youshang+='1';
  74.                         }else
  75.                             youshang+=0;
  76.                     }
  77.                     integer=hashMap.get(youshang);
  78.                     if(integer!=null) 
  79.                         chessValue[x][y]+=integer;
  80.                     zuo="";
  81.                     you="";
  82.                     shang="";
  83.                     xia="";
  84.                     zuoshang="";
  85.                     zuoxia="";
  86.                     youshang="";
  87.                     youxia="";
  88.                 }
  89.             }
  90.         }
  91.     }
  93.     @Override
  94.     public void actionPerformed(ActionEvent e) {
  96.         count1=0;
  97.         count2=0;
  98.         countS=0;
  99.         countX=0;
  100.         countZS=0;
  101.         countZX=0;
  102.         countYS=0;
  103.         countYX=0;
  104.         if("重新开始".equals(e.getActionCommand())) {
  105.             inte=0;
  106.             for(int ix=0;ix<line;ix++) {//设置所有棋子为null
  107.                 for(int iy=0;iy<line;iy++) {
  108.                     if(qizilarry[ix][iy]!=null) {
  109.                         qizilarry[ix][iy]=null;
  111.                     }
  112.                 }
  113.             }
  114.             value=JOptionPane.showOptionDialog(jFrame, j, "提示", JOptionPane.OK_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE, 
  115.                     null, moshi, null);
  116.             value2=JOptionPane.showOptionDialog(jFrame, j2, "提示", JOptionPane.OK_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE, 
  117.                     null, co, null);
  118.             if(value==JOptionPane.CLOSED_OPTION||value2==JOptionPane.CLOSED_OPTION) {
  119.                 System.exit(1);
  120.             }
  121.             if(value2==1) {
  122.                 c=Color.black;
  123.                 c2=Color.white;
  124.             }else {
  125.                 c=Color.white;
  126.                 c2=Color.black;
  127.             }
  128.             a=true;
  129.             jFrame.repaint();
  130.         }else {
  131.             if(qizilarry[prex][prey]==null) {//如果上一步棋子为null了
  132.                 JLabel jLabel1 =new JLabel("只能悔一步棋！");
  133.                 JOptionPane.showMessageDialog(jFrame, jLabel1, "提示！", JOptionPane.WARNING_MESSAGE);
  134.             }else {
  135.                 qizilarry[prex][prey]=null;
  136.                 inte--;
  137.                 if(value==1) {
  138.                     qizilarry[cx][cy]=null;
  139.                     inte--;
  140.                 }else {
  141.                     if(color ==c) 
  142.                         a=true;
  143.                     else
  144.                         a=false;
  145.                 }
  146.                 jFrame.repaint();

qizi.java:
package com.lxr.wzq1230;

  1. import java.awt.Color;
  2. import java.awt.Graphics;
  4. import jicheng.boss;
  6. public class qizi implements CS{
  7.     Graphics g;
  8.     Color color;
  9.     int x;
  10.     int y;

public qizi(Graphics g,Color color,int x,int y) {
this.g=g;
this.color=color;
this.x=x;
this.y=y;
}

  1.     //获取x坐标
  2.     public int getX() {
  3.         return x;
  4.     }
  6.     //获取y坐标
  7.     public int getY() {
  8.         return y;
  9.     }
  11.     //获取颜色
  12.     public Color getColor() {
  13.         return color;
  14.     }
  16.     public void drawq(){
  18.         g.setColor(color);
  19.         g.fillOval(x0+x*size-size/2, y0+y*size-size/2, size, size);

更多相关文章

  1. android 五子棋之小白java
  2. Android之自定义五子棋View
  3. Android开发-一个简单的五子棋游戏
  4. Android五子连珠
  5. Android(安卓)UI详解之动态布局
  6. Android开发-一个简单的五子棋游戏
  7. C语言之三字棋的实现及扩展
  8. 扫雷游戏
  9. 2021-02-22：一个象棋的棋盘，然后把整个棋盘放入第一象限，棋盘的最左

随机推荐

  1. Android Material Design之CoordinatorLa
  2. Android之蓝牙设备使用
  3. 安卓课程二十一 SeekBar拖动控件的使用
  4. Android 获取包名，版本信息
  5. Android attrs文件（自定义）属性详解
  6. android中的spinner动态加载内容
  7. android8.0屏蔽状态栏下拉
  8. Qt for Android Flutter - AAPT: error:
  9. Android 创建悬停通知栏
  10. android之hardwareAccelerated你不知道的