devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JAVA五子棋AI（人机对战 颜色选择 悔棋等 可直接使用）

作者：笔触狂放9 | 2024-04-02 20:23:29

赞

踩

五子棋ai

        五子棋是全国智力运动会竞技项目之一，容易上手，老少皆宜，而且趣味横生，引人入胜，不仅能增强思维能力，提高智力，而且富含哲理，有助于修身养性。当然，用 JAVA 语言编写五子棋 AI 小游戏也是一件非常有意思的事：

先上效果图：

一、五子棋规则

五子棋的基本规则如下：
（1） 棋盘：采用国际上标准的 15×15 路线的正方形棋盘。
（2）下法：两人分别执黑白两色棋子，轮流在棋盘上选择一个无子的交叉点走子，无子的交叉点又称为空点，规定由黑方先行走棋。
（3）输赢判断：黑、白双方有一方的五个棋子在衡、竖或斜的方向上联接成无间断的一条线即为该方赢。

二、思路分析

（1）下五子棋首先需要一个棋盘，国际标准是 15×15 路线，为了增加趣味性，我们在编写程序时可以使用不同线路的棋盘。

（2）用户在开始游戏前可进行相关选择，如：模式选择（人人对战、人机对战），颜色选择（用户要黑棋、用户要白棋），下棋顺序（黑棋先行、白棋先行），并且设置有“开始游戏”、“重新开始”、“认输结束”、“悔棋”等按钮。

（3）开始游戏后，用户在棋盘上点击相应的位置就可以下棋子（人人模式黑白子交替出现，人机模式用户在下完一个子后电脑也会自动下一个子），且每下一步棋系统需要判断横竖斜这几个方向上是否有连续相同颜色的五个棋子。

（4）在游戏过程中，当用户改变界面大小和拖动界面，即调用 paint 函数时棋盘和棋子不会消失。

简简单单几个步骤，顿时感觉难度也不高，下面开工！let's go !!!

三、代码详解

        首先，我们需要画一个棋盘，new 一个 ImageUI 类（当然也可以取其他名字），在这个类中，我们需要把五子棋的界面画出来，为了方便管理，在 JFrame 上设置了两个 JPanel，一个JPanel 里放 ImagePanel，用于棋盘和棋子的绘制，另一个JPanel 里放相关按钮。

        为了能够实现模式选择等单选功能，这边使用了单选按钮 JRadioButton，并打包放入一个 group 中，由于按钮紧挨在一起不美观，我们在部分按钮后面增加了一个空的 JLabel。

  1. import javax.swing.*;
  2. import java.awt.*;
  3. import java.awt.event.ActionListener;
  4.  
  5. public class ImageUI extends JFrame implements Config{
  6.  
  7.     ImageListener ul = new ImageListener();
  8.     ImagePanel imgPanel = new ImagePanel();
  9.  
  10.     public static void main(String[] args){
  11.         new ImageUI();
  12.     }
  13.  
  14.     ImageUI(){
  15.         initUI();
  16.     }
  17.  
  18.     private void initUI(){
  19.         JFrame jf = frameInitUI();
  20.         JPanel[] jps = addPanel(jf);
  21.         addButton(jps,ul);
  22.         jf.setVisible(true);
  23.  
  24.         Graphics gr = imgPanel.getGraphics();
  25.         ul.g = gr;
  26.         ul.imgPanel = imgPanel;
  27.         imgPanel.qz = ul.qz;
  28.  
  29.         imgPanel.addMouseListener(ul);
  30.     }
  31.  
  32.     private void addButton(JPanel[] jps, ActionListener al) {
  33.         JLabel j0 = new JLabel("                        ");
  34.         jps[1].add(j0);
  35.  
  36.         String[] btnstrs = new String[]{"开始游戏","重新开始","认输结束","悔棋一步",
  37.                 "  模式  ","人人对战","人机对战","  颜色  ","我要黑棋","我要白棋",
  38.         "  顺序  ","黑棋先行","白棋先行"};
  39.         for (int i = 0; i < 4; i++){
  40.             JButton btn = new JButton(btnstrs[i]);
  41.             Dimension dim = new Dimension(120,40);
  42.             btn.setPreferredSize(dim);
  43.             btn.setFont(new Font("黑体",1,20));
  44.             btn.setBackground(Color.WHITE);
  45.             btn.addActionListener(ul);
  46.             jps[1].add(btn);
  47.         }
  48.  
  49.         JLabel j1 = new JLabel("                        ");
  50.         jps[1].add(j1);
  51.  
  52.         JLabel j2 = new JLabel(btnstrs[4]);
  53.         j2.setFont(new Font("楷体",1,30));
  54.         jps[1].add(j2);
  55.  
  56.         ButtonGroup group1 = new ButtonGroup();
  57.         for (int i = 5; i < 7; i++){
  58.             JRadioButton jrb = new JRadioButton(btnstrs[i]);
  59.             jrb.setPreferredSize(new Dimension(120,40));
  60.             jrb.setFont(new Font("黑体",1,20));
  61.             jrb.setSelected(true);
  62.             jrb.setBackground(Color.YELLOW);
  63.             jrb.addActionListener(ul);
  64.             group1.add(jrb);
  65.             jps[1].add(jrb);
  66.         }
  67.  
  68.         JLabel j3 = new JLabel("                        ");
  69.         jps[1].add(j3);
  70.  
  71.         JLabel j4 = new JLabel(btnstrs[7]);
  72.         j4.setFont(new Font("楷体",1,30));
  73.         jps[1].add(j4);
  74.  
  75.         ButtonGroup group2 = new ButtonGroup();
  76.         for (int i = 8; i < 10; i++){
  77.             JRadioButton jrb = new JRadioButton(btnstrs[i]);
  78.             jrb.setPreferredSize(new Dimension(120,40));
  79.             jrb.setFont(new Font("黑体",1,20));
  80.             jrb.setSelected(true);
  81.             jrb.setBackground(Color.YELLOW);
  82.             jrb.addActionListener(ul);
  83.             group2.add(jrb);
  84.             jps[1].add(jrb);
  85.         }
  86.  
  87.         JLabel j5 = new JLabel("                        ");
  88.         jps[1].add(j5);
  89.  
  90.         JLabel j6 = new JLabel(btnstrs[10]);
  91.         j6.setFont(new Font("楷体",1,30));
  92.         jps[1].add(j6);
  93.  
  94.         ButtonGroup group3 = new ButtonGroup();
  95.         for (int i = 11; i < 13; i++){
  96.             JRadioButton jrb = new JRadioButton(btnstrs[i]);
  97.             jrb.setPreferredSize(new Dimension(120,40));
  98.             jrb.setFont(new Font("黑体",1,20));
  99.             jrb.setSelected(true);
  100.             jrb.setBackground(Color.YELLOW);
  101.             jrb.addActionListener(ul);
  102.             group3.add(jrb);
  103.             jps[1].add(jrb);
  104.         }
  105.  
  106.     }
  107.  
  108.     private JPanel[] addPanel(JFrame jf) {
  109.  
  110.         JPanel[] jps = new JPanel[2];
  111.         String[] layoustrs = {BorderLayout.CENTER,BorderLayout.EAST};
  112.  
  113.         imgPanel.setBackground(Color.LIGHT_GRAY);
  114.         jf.add(imgPanel,layoustrs[0]);
  115.         jps[0] = imgPanel;
  116.  
  117.         Dimension dim = new Dimension(200,0);
  118.         JPanel jp_s = new JPanel();
  119.         jp_s.setBackground(Color.ORANGE);
  120.         jp_s.setPreferredSize(dim);
  121.         jf.add(jp_s,layoustrs[1]);
  122.         jps[1] = jp_s;
  123.  
  124.         return jps;
  125.     }
  126.  
  127.     private JFrame frameInitUI() {
  128.         setTitle("五子棋AI");
  129.         setSize(X0+SIZE*LINE+200,Y0+SIZE*LINE+SIZE);
  130.         setLocationRelativeTo(null);
  131.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  132.         return this;
  133.     }
  134.  
  135. }

        界面画好后，我们需要考虑下棋了，new 一个 ImageListener 类：

  1. import java.awt.*;
  2. import java.awt.event.ActionEvent;
  3. import java.awt.event.MouseEvent;
  4.  
  5. public class ImageListener extends Listen implements Config{
  6.  
  7.     public Graphics g = null;
  8.     private int count = 0;  //偶数黑棋 奇数白棋
  9.     private int index = 0;  //0无棋 1黑棋 2白棋
  10.     private int m,n;        //第m行 第n列
  11.     private String name = null;
  12.     private String option = null;
  13.     public int[][] qz = new int[LINE][LINE];
  14.     public int[][] score = new int[LINE][LINE];
  15.     public int[] cc = new int[4];
  16.     public int goalX = 0;
  17.     public int goalY = 0;
  18.     public int mark = 0;
  19.     public int p = 1;
  20.     Boolean moshi = true;
  21.     Boolean yanse = true;
  22.     Boolean shunxu = true;
  23.     Boolean renji = true;
  24.     Boolean same = true;
  25.  
  26.     ImagePanel imgPanel = new ImagePanel();
  27.     Login lo = new Login();
  28.  
  29.     @Override
  30.     public void actionPerformed(ActionEvent e){
  31.         System.out.println("按钮被调用");
  32.         name = e.getActionCommand();
  33.  
  34.         if("人人对战".equals(name)) moshi = true;
  35.         if("人机对战".equals(name)) moshi = false;
  36.         if("我要黑棋".equals(name)) yanse = true;
  37.         if("我要白棋".equals(name)) yanse = false;
  38.         if("黑棋先行".equals(name)) shunxu = true;
  39.         if("白棋先行".equals(name)) shunxu = false;
  40.  
  41.         if (moshi && shunxu) {
  42.             count = 2;
  43.         }
  44.         if (moshi && !shunxu) {
  45.             count = 1;
  46.         }
  47.  
  48.         if(!moshi && yanse && shunxu){  //人先出黑
  49.             count = 2;
  50.         }
  51.         if(!moshi && yanse && !shunxu){  //机先出白
  52.             count = 2;
  53.         }
  54.         if(!moshi && !yanse && shunxu){  //机先出黑
  55.             count = 1;
  56.         }
  57.         if(!moshi && !yanse && !shunxu){  //人先出白
  58.             count = 1;
  59.         }
  60.  
  61.         if("认输结束".equals(name)){
  62.             option = "认输结束";
  63.             lo.showU(option);
  64.         }
  65.         if("悔棋一步".equals(name)){
  66.             cancel(qz);
  67.         }
  68.         if("开始游戏".equals(name)){
  69.             same = true;
  70.             for(int i = 0; i < 4; i++){
  71.                 cc[i] = 0;
  72.             }
  73.             for(int i = 0; i < LINE; i++){
  74.                 for(int j = 0; j < LINE; j++){
  75.                     qz[i][j] = 0;
  76.                 }
  77.             }
  78.             if(!moshi && yanse && !shunxu) {
  79.                 cc[2] = LINE/2;
  80.                 cc[3] = LINE/2;
  81.                 qz[LINE/2][LINE/2] = 2;
  82.             }
  83.             if(!moshi && !yanse && shunxu) {
  84.                 cc[2] = LINE/2;
  85.                 cc[3] = LINE/2;
  86.                 qz[LINE/2][LINE/2] = 1;
  87.             }
  88.             imgPanel.paint(g);
  89.             option = "开始游戏";
  90.             lo.showU(option);
  91.             System.out.println("我去调用他");
  92.         }
  93.         if("重新开始".equals(name)){
  94.             same = true;
  95.             for(int i = 0; i < LINE; i++){
  96.                 for(int j = 0; j < LINE; j++){
  97.                     qz[i][j] = 0;
  98.                 }
  99.             }
  100.             imgPanel.paint(g);
  101.         }
  102.     }
  103.  
  104.     @Override
  105.     public void mousePressed(MouseEvent e){
  106.         if(renji) {
  107.             cc[0] = cc[2];
  108.             cc[1] = cc[3];
  109.         }
  110.     }
  111.  
  112.     @Override
  113.     public void mouseReleased(MouseEvent e){
  114.         System.out.println("释放被调用");
  115.         if(renji) {
  116.  
  117.             int x = e.getX();
  118.             int y = e.getY();
  119.  
  120.             if (count % 2 == 0) {
  121.                 index = 1;
  122.             }
  123.             if (count % 2 == 1) {
  124.                 index = 2;
  125.             }
  126.  
  127.             if ((x > (X0 - SIZE / 2)) && (x < (X0 - SIZE / 2 + SIZE * LINE)) &&
  128.                     (y > (Y0 - SIZE / 2)) && (y < (Y0 - SIZE / 2 + SIZE * LINE))) {
  129.                 m = (x - X0 + SIZE / 2) / SIZE;
  130.                 n = (y - Y0 + SIZE / 2) / SIZE;
  131.                 if (qz[m][n] == 0) {
  132.                     cc[2] = m;
  133.                     cc[3] = n;
  134.                     qz[m][n] = index;
  135.                     count++;
  136.                     imgPanel.drawqz(qz, g);
  137.                     judge(qz);
  138.                     System.out.println("判断被调用");
  139.                     same = true;
  140.                 } else {
  141.                     option = "同一位置";
  142.                     lo.showU(option);
  143.                     same = false;
  144.                 }
  145.  
  146.  
  147.                 System.out.println("m=" + m + ";n=" + n);
  148.             }
  149.  
  150.             try {
  151.                 Thread.sleep(500);
  152.             } catch (InterruptedException ex) {
  153.                 ex.printStackTrace();
  154.             }
  155.  
  156.             if (same && p < 5) {
  157.                 if (!moshi) {
  158.                     renji = false;
  159.                     AI(qz);
  160.                     if (yanse) qz[goalX][goalY] = 2;
  161.                     if (!yanse) qz[goalX][goalY] = 1;
  162.                     imgPanel.drawqz(qz, g);
  163.                     count++;
  164.                     cc[0] = cc[2];
  165.                     cc[1] = cc[3];
  166.                     cc[2] = goalX;
  167.                     cc[3] = goalY;
  168.                     judge(qz);
  169.                 }
  170.             }
  171.         }
  172.  
  173.     }
  174.  
  175.     private void judge(int[][] qz){
  176.  
  177.         //判断|情形
  178.         for(int i = 0; i < LINE; i++){
  179.             for(int j = 0; j < LINE-1; j++){
  180.                 if(qz[i][j] == qz[i][j+1] && qz[i][j] != 0){
  181.                     p++;
  182.                     if(p > 4 && qz[i][j] == 1) {
  183.                         option = "黑棋胜";
  184.                         lo.showU(option);
  185. //                        same = false;
  186.                         return;
  187.                     }
  188.                     if(p > 4 && qz[i][j] == 2) {
  189.                         option = "白棋胜";
  190.                         lo.showU(option);
  191. //                        same = false;
  192.                         return;
  193.                     }
  194.                 }
  195.                 if(qz[i][j] != qz[i][j+1]){
  196.                     p = 1;
  197.                 }
  198.             }
  199.         }
  200.  
  201.         //判断——情形
  202.         for(int j = 0; j < LINE; j++){
  203.             for(int i = 0; i < LINE-1; i++){
  204.                 if(qz[i][j] == qz[i+1][j] && qz[i][j] != 0){
  205.                     p++;
  206.                     if(p > 4 && qz[i][j] == 1) {
  207.                         option = "黑棋胜";
  208.                         lo.showU(option);
  209. //                        same = false;
  210.                     }
  211.                     if(p > 4 && qz[i][j] == 2) {
  212.                         option = "白棋胜";
  213.                         lo.showU(option);
  214. //                        same = false;
  215.                         return;
  216.                     }
  217.                 }
  218.                 if(qz[i][j] != qz[i+1][j]){
  219.                     p = 1;
  220.                 }
  221.             }
  222.         }
  223.  
  224.         //判断\情形
  225.         for(int i = 0; i < LINE-4; i++){
  226.             for(int j = 0; j < LINE-4; j++){
  227.                 int m = i;
  228.                 int n = j;
  229.                 for(int cishu = 0; cishu < 5; cishu++) {
  230.                     if (qz[m][n] == qz[m + 1][n + 1] && qz[m][n] != 0) {
  231.                         p++;
  232.                         m++;
  233.                         n++;
  234.                         if (p > 4 && qz[m][n] == 1) {
  235.                             System.out.println("调用黑棋胜1");
  236.                             option = "黑棋胜";
  237.                             lo.showU(option);
  238. //                            same = false;
  239.                             return;
  240.                         }
  241.                         if (p > 4 && qz[m][n] == 2) {
  242.                             System.out.println("调用白棋胜1");
  243.                             option = "白棋胜";
  244.                             lo.showU(option);
  245. //                            same = false;
  246.                             return;
  247.                         }
  248.                     }
  249.                     if (qz[m][n] != qz[m + 1][n + 1]) {
  250.                         p = 1;
  251.                     }
  252.                 }
  253.             }
  254.         }
  255.  
  256.         //判断/情形
  257.         for(int i = 4; i < LINE; i++){
  258.             for(int j = 0; j < LINE-4; j++){
  259.                 int m = i;
  260.                 int n = j;
  261.                 for(int cishu = 0; cishu < 5; cishu++) {
  262.                     if (qz[m][n] == qz[m - 1][n + 1] && qz[m][n] != 0) {
  263.                         p++;
  264.                         m--;
  265.                         n++;
  266.                         if (p > 4 && qz[m][n] == 1) {
  267.                             System.out.println("调用黑棋胜2");
  268.                             option = "黑棋胜";
  269.                             lo.showU(option);
  270. //                            same = false;
  271.                             return;
  272.                         }
  273.                         if (p > 4 && qz[m][n] == 2) {
  274.                             System.out.println("调用白棋胜2");
  275.                             option = "白棋胜";
  276.                             lo.showU(option);
  277. //                            same = false;
  278.                             return;
  279.                         }
  280.                     }
  281.                     if (qz[m][n] != qz[m - 1][n + 1]) {
  282.                         p = 1;
  283.                     }
  284.                 }
  285.             }
  286.         }
  287.     }
  288.  
  289.     private void cancel(int[][] qz){
  290.         qz[cc[0]][cc[1]] = 0;
  291.         qz[cc[2]][cc[3]] = 0;
  292.         imgPanel.paint(g);
  293.     }
  294.  
  295.     private void AI(int[][] qz){
  296.         for(int i = 0; i  < LINE; i++){
  297.             for(int j = 0; j < LINE; j++){
  298.                 score[i][j] = 0;
  299.             }
  300.         }
  301.  
  302.         int blackChessNum = 0;
  303.         int whiteChessNum = 0;
  304.  
  305.         //扫描|
  306.         for(int i = 0; i < LINE; i++){
  307.             System.out.println("|被扫描了");
  308.             for(int j = 0; j < LINE-4; j++){
  309.                 int k = j;
  310.                 while(k < j + 5){
  311.                     if(qz[i][k] == 1) blackChessNum++;
  312.                     if(qz[i][k] == 2) whiteChessNum++;
  313.                     k++;
  314.                 }
  315.                 mark = weight(blackChessNum, whiteChessNum);
  316.                 for(k = j; k < j + 5; k++){
  317.                     if(qz[i][k] == 0) score[i][k] += mark;
  318.                 }
  319.                 blackChessNum = 0;
  320.                 whiteChessNum = 0;
  321.                 mark = 0;
  322.             }
  323.         }
  324.  
  325.         //扫描——
  326.         for(int j = 0; j < LINE; j++){
  327.             System.out.println("——被扫描了");
  328.             for(int i = 0; i < LINE-4; i++){
  329.                 int k = i;
  330.                 while(k < i + 5){
  331.                     if(qz[k][j] == 1) blackChessNum++;
  332.                     if(qz[k][j] == 2) whiteChessNum++;
  333.                     k++;
  334.                 }
  335.                 mark = weight(blackChessNum, whiteChessNum);
  336.                 for(k = i; k < i + 5; k++){
  337.                     if(qz[k][j] == 0) score[k][j] += mark;
  338.                 }
  339.                 blackChessNum = 0;
  340.                 whiteChessNum = 0;
  341.                 mark = 0;
  342.             }
  343.         }
  344.  
  345.         //扫描\
  346.         for(int i = 0; i < LINE-4; i++){
  347.             System.out.println("\\被扫描了");
  348.             for(int j = 0; j < LINE-4; j++){
  349.                 int k = 0;
  350.                 while(k < 5){
  351.                     if(qz[i+k][j+k] == 1) blackChessNum++;
  352.                     if(qz[i+k][j+k] == 2) whiteChessNum++;
  353.                     k++;
  354.                 }
  355.                 mark = weight(blackChessNum, whiteChessNum);
  356.                 for(k = 0; k < 5; k++){
  357.                     if(qz[i+k][j+k] == 0) score[i+k][j+k] += mark;
  358.                 }
  359.                 blackChessNum = 0;
  360.                 whiteChessNum = 0;
  361.                 mark = 0;
  362.             }
  363.         }
  364.  
  365.         //扫描/
  366.         for(int i = 4; i < LINE; i++){
  367.             System.out.println("/被扫描了");
  368.             for(int j = 0; j < LINE-4; j++){
  369.                 int k = 0;
  370.                 while(k < 5){
  371.                     if(qz[i-k][j+k] == 1) blackChessNum++;
  372.                     if(qz[i-k][j+k] == 2) whiteChessNum++;
  373.                     k++;
  374.                 }
  375.                 mark = weight(blackChessNum, whiteChessNum);
  376.                 for(k = 0; k < 5; k++){
  377.                     if(qz[i-k][j+k] == 0) score[i-k][j+k] += mark;
  378.                 }
  379.                 blackChessNum = 0;
  380.                 whiteChessNum = 0;
  381.                 mark = 0;
  382.             }
  383.         }
  384.  
  385.         //从空位置中找到得分最大的位置
  386.         int scoremax = 0;
  387.  
  388.         for(int j = 0; j < LINE; j++){
  389.             System.out.println("");
  390.             for(int i = 0; i < LINE; i++){
  391.                 System.out.print(score[i][j]+";");
  392.                 if(scoremax < score[i][j]){
  393.                     scoremax = score[i][j];
  394.                     goalX = i;
  395.                     goalY = j;
  396.                 }
  397.             }
  398.         }
  399.         renji = true;
  400.  
  401.     }
  402.  
  403.     private int weight(int blackChessNum,int whiteChessNum) {
  404.         System.out.println("blackChessNum="+blackChessNum+";whiteChessNum="+whiteChessNum);
  405.         if(blackChessNum > 0 && whiteChessNum > 0) mark = 0;
  406.         if(blackChessNum == 0 && whiteChessNum == 0) mark = 7;
  407.  
  408.         if(blackChessNum == 1 && whiteChessNum == 0 && yanse) mark = 15;
  409.         if(blackChessNum == 1 && whiteChessNum == 0 && !yanse) mark = 35;
  410.         if(whiteChessNum == 1 && blackChessNum == 0 && yanse) mark = 35;
  411.         if(whiteChessNum == 1 && blackChessNum == 0 && !yanse) mark = 15;
  412.  
  413.         if(blackChessNum == 2 && whiteChessNum == 0 && yanse) mark = 400;
  414.         if(blackChessNum == 2 && whiteChessNum == 0 && !yanse) mark = 800;
  415.         if(whiteChessNum == 2 && blackChessNum == 0 && yanse) mark = 800;
  416.         if(whiteChessNum == 2 && blackChessNum == 0 && !yanse) mark = 400;
  417.  
  418.         if(blackChessNum == 3 && whiteChessNum == 0 && yanse) mark = 1800;
  419.         if(blackChessNum == 3 && whiteChessNum == 0 && !yanse) mark = 15000;
  420.         if(whiteChessNum == 3 && blackChessNum == 0 && yanse) mark = 15000;
  421.         if(whiteChessNum == 3 && blackChessNum == 0 && !yanse) mark = 1800;
  422.  
  423.         if(blackChessNum == 4 && whiteChessNum == 0 && yanse) mark = 100000;
  424.         if(blackChessNum == 4 && whiteChessNum == 0 && !yanse) mark = 800000;
  425.         if(whiteChessNum == 4 && blackChessNum == 0 && yanse) mark = 800000;
  426.         if(whiteChessNum == 4 && blackChessNum == 0 && !yanse) mark = 100000;
  427.  
  428.         return mark;
  429.     }
  430.  
  431. }

        ImageListener 类是五子棋 AI 代码的核心部分，下面从模式选择，胜负判断，悔棋三方面进行简要分析：

       模式判断：

        在人人对战中，我们用 count 计数，偶数下黑子，奇数下白子，为了实现下的第一颗棋子是黑子还是白子，可对应给 count 的初值赋 1 或 2，每下完一步棋进行胜负判断；

        在人机对战模式中，主要难点是电脑自主判断落子位置，本篇文章采用了已经公开的五元组评分算法，即对15X15的572个五元组分别评分，一个五元组的得分就是该五元组为其中每个位置贡献的分数，一个位置的分数就是其所在所有五元组分数之和，所有空位置中分数最高的那个位置就是落子位置。

        五子棋 AI 算法其实还有很多，这边再介绍一种也较广泛使用的算法，即根据特征来赋评估分值，同一特征可能在不同路上（甚至同一路上）会重复出现，一些威胁性小的特征即使出现多次，累加得分也不应该超过一个极有威胁性的特征得分。如特征“++OO++”威胁性小，特征“+OOOO+”威胁性非常大，不管前者出现多少个，原则上得分都不应该超过后者出现一个的得分，在此提供一个已有的特征评分表供参考：

        胜负判断

        在游戏过程中，我们初始化了一个和棋盘线数一样的二维数组，用于记录每一个交点的落子情况，我们规定：若该交点处没有棋子，则数组相应位置元素为0；若该交点处有一颗黑子，则数组相应位置为1；若该交点处有一颗白子，则数组相应位置为2；每下完一颗棋子，都会调用 judge 函数对该二维数组进行横向，竖向，左斜向，右斜向扫描，判断是否有连续五个1或者五个2.

        悔棋

        我们定义了一个长度为4的一维数组，分别记录倒数第二颗棋子的 x，y 坐标和最后一颗棋子的 x， y 坐标，当点击“悔棋一步”按钮时，把这两个棋子对应二维数组中的值置为0，并调用 paint 函数，则在重绘时这两颗棋子将不会绘制出来，即实现了悔棋功能！

        当界面发生改变时，会调用 paint 函数，因此我们还写了一个 ImagePanel 类，里面重写了 paint 函数。

  1. import javax.swing.*;
  2. import java.awt.*;
  3.  
  4. public class ImagePanel extends JPanel implements Config{
  5.  
  6.     public int[][] qz = new int[LINE][LINE];
  7.  
  8.     public void paint(Graphics gr){
  9.         super.paint(gr);
  10.         drawChessTable(gr);
  11.         drawqz(qz,gr);
  12.     }
  13.  
  14.     public void drawqz(int[][] qz,Graphics gr) {
  15.         System.out.println("棋子重绘");
  16.         for(int i = 0; i < LINE; i++){
  17.             for(int j = 0; j < LINE; j++){
  18.                 if(qz[i][j] == 1){
  19.                     System.out.println("qz["+i+"]["+j+"]="+qz[i][j]);
  20.                     gr.setColor(Color.BLACK);
  21.                     gr.fillOval(X0+i*SIZE-CHESS/2, Y0+j*SIZE-CHESS/2, CHESS, CHESS);
  22.                 }
  23.                 if(qz[i][j] == 2){
  24.                     System.out.println("qz["+i+"]["+j+"]="+qz[i][j]);
  25.                     gr.setColor(Color.WHITE);
  26.                     gr.fillOval(X0+i*SIZE-CHESS/2, Y0+j*SIZE-CHESS/2, CHESS, CHESS);
  27.                 }
  28.             }
  29.         }
  30.     }
  31.  
  32.     private void drawChessTable(Graphics gr) {
  33.         Graphics2D gr2 = (Graphics2D)gr;
  34.         gr2.setStroke(new BasicStroke(2.0f));
  35.  
  36.         for(int i = 0; i < LINE; i++){
  37.             gr2.drawLine(X0,SIZE*i+Y0,X0+SIZE*(LINE-1),SIZE*i+Y0);
  38.         }
  39.         for(int j = 0; j < LINE; j++){
  40.             gr2.drawLine(X0+SIZE*j,Y0,X0+SIZE*j,Y0+SIZE*(LINE-1));
  41.         }
  42.     }
  43.  
  44. }

        最后，为了能使这个代码能够顺利运行，还需要加上以下几个类：

  1. import java.awt.event.ActionEvent;
  2. import java.awt.event.ActionListener;
  3. import java.awt.event.MouseEvent;
  4. import java.awt.event.MouseListener;
  5.  
  6. public class Listen implements MouseListener, ActionListener {
  7.  
  8.     @Override
  9.     public void actionPerformed(ActionEvent e) {
  10.  
  11.     }
  12.  
  13.     @Override
  14.     public void mouseClicked(MouseEvent e) {
  15.  
  16.     }
  17.  
  18.     @Override
  19.     public void mousePressed(MouseEvent e) {
  20.  
  21.     }
  22.  
  23.     @Override
  24.     public void mouseReleased(MouseEvent e) {
  25.  
  26.     }
  27.  
  28.     @Override
  29.     public void mouseEntered(MouseEvent e) {
  30.  
  31.     }
  32.  
  33.     @Override
  34.     public void mouseExited(MouseEvent e) {
  35.  
  36.     }
  37. }
  1. public interface Config {
  2.     public static final int X0 = 50;
  3.     public static final int Y0 = 50;
  4.     public static final int SIZE = 50;
  5.     public static final int LINE = 15;
  6.     public static final int CHESS = 50;
  7. }
  1. public class Login {
  2.     public void showU(String option){
  3.         JFrame jf = new JFrame();
  4.         jf.setSize(500,300);
  5.  
  6.         switch (option){
  7.             case"黑棋胜":
  8.                 ImageIcon image1 = new ImageIcon("D:\\03.jpg");
  9.                 JLabel jl1 = new JLabel(image1);
  10.                 jf.add(jl1);
  11.                 jf.setTitle("黑棋胜");
  12.                 jf.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  13.                 break;
  14.             case"白棋胜":
  15.                 ImageIcon image2 = new ImageIcon("D:\\04.jpg");
  16.                 JLabel jl2 = new JLabel(image2);
  17.                 jf.add(jl2);
  18.                 jf.setTitle("白棋胜");
  19.                 jf.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  20.                 break;
  21.             case"开始游戏":
  22.                 ImageIcon image3 = new ImageIcon("D:\\01.jpg");
  23.                 JLabel jl3 = new JLabel(image3);
  24.                 jf.add(jl3);
  25.                 jf.setTitle("开始游戏");
  26.                 jf.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  27.                 break;
  28.             case"认输结束":
  29.                 ImageIcon image4 = new ImageIcon("D:\\02.jpg");
  30.                 JLabel jl4 = new JLabel(image4);
  31.                 jf.add(jl4);
  32.                 jf.setTitle("认输结束");
  33.                 jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  34.                 break;
  35.             case"同一位置":
  36.                 ImageIcon image5 = new ImageIcon("D:\\05.jpg");
  37.                 JLabel jl5 = new JLabel(image5);
  38.                 jf.add(jl5);
  39.                 jf.setTitle("无效棋");
  40.                 jf.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  41.                 break;
  42.         }
  43.  
  44.         jf.setLocationRelativeTo(null);
  45.         jf.setVisible(true);
  46.     }
  47. }

在最后，献上代码中使用到的五张图片：

01：

 

02：

03：

04：

 

05：

 

 

 

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/353692
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号