Java五子棋（人机版），昨天买的棋子今天就用不上了

青旅半醒 2021-08-11 03:25 439阅读 0赞

Java五子棋，老程序员也花了3天

效果图

在这里插入图片描述

实现思路

1.创建运行窗口并添加背景色。
2.绘制棋盘。
3.用二维数组来控制起码落子位置、绘制指示器。
4.鼠标在落子位置处点击可落子。
5.落子后检查是否获得胜利。
6.机器判断下一步，并落子。
7.机器判断是否获得胜利。

代码实现

创建窗口

首先创建一个游戏窗体类GameFrame，继承至JFrame，用来显示在屏幕上（window的对象），每个游戏都有一个窗口，设置好窗口标题、尺寸、布局等就可以。

  1. /* * 游戏窗体类 */
  2. public class GameFrame extends JFrame { 
  4.     public GameFrame() { 
  5.         setTitle("五子棋");//设置标题
  6.         setSize(620, 670);//设定尺寸
  7.         getContentPane().setBackground(new Color(209,146,17));//添加背景色
  8.         setLayout(new BorderLayout());
  9.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//点击关闭按钮是关闭程序
  10.         setLocationRelativeTo(null);   //设置居中
  11.         setResizable(false); //不允许修改界面大小
  12.     }
  13. }

创建面板容器GamePanel继承至JPanel

  1. import javax.swing.JFrame;
  2. import javax.swing.JPanel;
  4. /* * 画布类 */
  5. public class GamePanel extends JPanel { 
  6.     private static final long serialVersionUID = 1L;
  7.     GamePanel gamePanel=this;
  8.     private JFrame mainFrame=null;
  10.     //构造里面初始化相关参数
  11.     public GamePanel(JFrame frame){ 
  12.         this.setLayout(null);
  13.         this.setOpaque(false);
  14.         mainFrame = frame;
  16.         mainFrame.requestFocus();
  17.         mainFrame.setVisible(true);
  18.     }
  20. }

再创建一个Main类，来启动这个窗口。

  1. public class Main { 
  2.     //主类
  3.     public static void main(String[] args) { 
  4.         GameFrame frame = new GameFrame();
  5.         GamePanel gamePanel = new GamePanel(frame);
  6.         frame.add(gamePanel);
  7.         frame.setVisible(true);//设定显示
  8.     }
  9. }

右键执行这个Main类，窗口建出来了
在这里插入图片描述

创建菜单及菜单选项

创建菜单

  1. private void  initMenu(){ 
  2.     // 创建菜单及菜单选项
  3.     jmb = new JMenuBar();
  4.     JMenu jm1 = new JMenu("游戏");
  5.     jm1.setFont(new Font("思源宋体", Font.BOLD, 18));// 设置菜单显示的字体
  6.     JMenu jm2 = new JMenu("帮助");
  7.     jm2.setFont(new Font("思源宋体", Font.BOLD, 18));// 设置菜单显示的字体
  9.     JMenuItem jmi1 = new JMenuItem("开始新游戏");
  10.     JMenuItem jmi2 = new JMenuItem("退出");
  11.     jmi1.setFont(new Font("思源宋体", Font.BOLD, 18));
  12.     jmi2.setFont(new Font("思源宋体", Font.BOLD, 18));
  14.     JMenuItem jmi3 = new JMenuItem("操作说明");
  15.     jmi3.setFont(new Font("思源宋体", Font.BOLD, 18));
  16.     JMenuItem jmi4 = new JMenuItem("成功/失败判定");
  17.     jmi4.setFont(new Font("思源宋体", Font.BOLD, 18));
  19.     jm1.add(jmi1);
  20.     jm1.add(jmi2);
  22.     jm2.add(jmi3);
  23.     jm2.add(jmi4);
  25.     jmb.add(jm1);
  26.     jmb.add(jm2);
  27.     mainFrame.setJMenuBar(jmb);// 菜单Bar放到JFrame上
  28.     jmi1.addActionListener(this);
  29.     jmi1.setActionCommand("Restart");
  30.     jmi2.addActionListener(this);
  31.     jmi2.setActionCommand("Exit");
  33.     jmi3.addActionListener(this);
  34.     jmi3.setActionCommand("help");
  35.     jmi4.addActionListener(this);
  36.     jmi4.setActionCommand("lost");
  37. }

实现ActionListener并重写方法actionPerformed
在这里插入图片描述
此时GamePanel是报错的，重写actionPerformed方法。

actionPerformed方法的实现

  1. @Override
  2. public void actionPerformed(ActionEvent e) { 
  3.     String command = e.getActionCommand();
  4.     System.out.println(command);
  5.     UIManager.put("OptionPane.buttonFont", new FontUIResource(new Font("思源宋体", Font.ITALIC, 18)));
  6.     UIManager.put("OptionPane.messageFont", new FontUIResource(new Font("思源宋体", Font.ITALIC, 18)));
  7.     if ("Exit".equals(command)) { 
  8.         Object[] options = {  "确定", "取消" };
  9.         int response = JOptionPane.showOptionDialog(this, "您确认要退出吗", "",
  10.                 JOptionPane.YES_OPTION, JOptionPane.QUESTION_MESSAGE, null,
  11.                 options, options[0]);
  12.         if (response == 0) { 
  13.             System.exit(0);
  14.         } 
  15.     }else if("Restart".equals(command)){ 
  16.         if(!"end".equals(gamePanel.gameFlag)){ 
  17.             JOptionPane.showMessageDialog(null, "正在游戏中无法重新开始！",
  18.                     "提示！", JOptionPane.INFORMATION_MESSAGE); 
  19.         }else{ 
  20.             if(gamePanel!=null) { 
  21.                 gamePanel.restart();
  22.             }
  23.         }
  24.     }else if("help".equals(command)){ 
  25.         JOptionPane.showMessageDialog(null, "鼠标在指示器位置点下，则落子！",
  26.                 "提示！", JOptionPane.INFORMATION_MESSAGE);
  27.     }else if("lost".equals(command)){ 
  28.         JOptionPane.showMessageDialog(null, "五子连珠方获得胜利！",
  29.                 "提示！", JOptionPane.INFORMATION_MESSAGE);
  30.     }
  31. }

此时的GamePanel代码如下：

  1. package main;
  3. import java.awt.Font;
  4. import java.awt.event.ActionEvent;
  5. import java.awt.event.ActionListener;
  6. import javax.swing.JFrame;
  7. import javax.swing.JMenu;
  8. import javax.swing.JMenuBar;
  9. import javax.swing.JMenuItem;
  10. import javax.swing.JOptionPane;
  11. import javax.swing.JPanel;
  12. import javax.swing.UIManager;
  13. import javax.swing.plaf.FontUIResource;
  15. /* * 画布类 */
  16. public class GamePanel extends JPanel implements ActionListener{ 
  17.     private static final long serialVersionUID = 1L;
  18.     GamePanel gamePanel=this;
  19.     private JFrame mainFrame=null;
  20.     JMenuBar jmb=null;
  21.     public String gameFlag="";
  23.     //构造里面初始化相关参数
  24.     public GamePanel(JFrame frame){ 
  25.         this.setLayout(null);
  26.         this.setOpaque(false);
  27.         mainFrame = frame;
  29.         //创建按钮
  30.         initMenu();
  32.         mainFrame.requestFocus();
  33.         mainFrame.setVisible(true);
  34.     }
  36.     private void  initMenu(){ 
  37.         // 创建菜单及菜单选项
  38.         jmb = new JMenuBar();
  39.         JMenu jm1 = new JMenu("游戏");
  40.         jm1.setFont(new Font("思源宋体", Font.BOLD, 18));// 设置菜单显示的字体
  41.         JMenu jm2 = new JMenu("帮助");
  42.         jm2.setFont(new Font("思源宋体", Font.BOLD, 18));// 设置菜单显示的字体
  44.         JMenuItem jmi1 = new JMenuItem("开始新游戏");
  45.         JMenuItem jmi2 = new JMenuItem("退出");
  46.         jmi1.setFont(new Font("思源宋体", Font.BOLD, 18));
  47.         jmi2.setFont(new Font("思源宋体", Font.BOLD, 18));
  49.         JMenuItem jmi3 = new JMenuItem("操作说明");
  50.         jmi3.setFont(new Font("思源宋体", Font.BOLD, 18));
  51.         JMenuItem jmi4 = new JMenuItem("成功/失败判定");
  52.         jmi4.setFont(new Font("思源宋体", Font.BOLD, 18));
  54.         jm1.add(jmi1);
  55.         jm1.add(jmi2);
  57.         jm2.add(jmi3);
  58.         jm2.add(jmi4);
  60.         jmb.add(jm1);
  61.         jmb.add(jm2);
  62.         mainFrame.setJMenuBar(jmb);// 菜单Bar放到JFrame上
  63.         jmi1.addActionListener(this);
  64.         jmi1.setActionCommand("Restart");
  65.         jmi2.addActionListener(this);
  66.         jmi2.setActionCommand("Exit");
  68.         jmi3.addActionListener(this);
  69.         jmi3.setActionCommand("help");
  70.         jmi4.addActionListener(this);
  71.         jmi4.setActionCommand("lost");
  72.     }
  74.     //重新开始
  75.     public void restart() { 
  76.         //游戏开始标记
  77.         gameFlag="start";
  78.     }
  80.     @Override
  81.     public void actionPerformed(ActionEvent e) { 
  82.         String command = e.getActionCommand();
  83.         System.out.println(command);
  84.         UIManager.put("OptionPane.buttonFont", new FontUIResource(new Font("思源宋体", Font.ITALIC, 18)));
  85.         UIManager.put("OptionPane.messageFont", new FontUIResource(new Font("思源宋体", Font.ITALIC, 18)));
  86.         if ("Exit".equals(command)) { 
  87.             Object[] options = {  "确定", "取消" };
  88.             int response = JOptionPane.showOptionDialog(this, "您确认要退出吗", "",
  89.                     JOptionPane.YES_OPTION, JOptionPane.QUESTION_MESSAGE, null,
  90.                     options, options[0]);
  91.             if (response == 0) { 
  92.                 System.exit(0);
  93.             } 
  94.         }else if("Restart".equals(command)){ 
  95.             if(!"end".equals(gamePanel.gameFlag)){ 
  96.                 JOptionPane.showMessageDialog(null, "正在游戏中无法重新开始！",
  97.                         "提示！", JOptionPane.INFORMATION_MESSAGE); 
  98.             }else{ 
  99.                 if(gamePanel!=null) { 
  100.                     gamePanel.restart();
  101.                 }
  102.             }
  103.         }else if("help".equals(command)){ 
  104.             JOptionPane.showMessageDialog(null, "鼠标在指示器位置点下，则落子！",
  105.                     "提示！", JOptionPane.INFORMATION_MESSAGE);
  106.         }else if("lost".equals(command)){ 
  107.             JOptionPane.showMessageDialog(null, "五子连珠方获得胜利！",
  108.                     "提示！", JOptionPane.INFORMATION_MESSAGE);
  109.         }
  110.     }
  111. }

运行一下
在这里插入图片描述

绘制棋盘

重写paint方法

  1. @Override
  2. public void paint(java.awt.Graphics g) { 
  3.     super.paint(g);
  4. }

绘制横竖相交接的线
定义15行、15列

  1. public static final int ROWS=15;
  2. public static final int COLS=15;

绘制网格

  1. //绘制网格
  2. private void drawGrid(Graphics g) { 
  3.     Graphics2D g_2d=(Graphics2D)g;
  4.     int start=26;
  5.     int x1=start;
  6.     int y1=20;
  7.     int x2=586;
  8.     int y2=20;
  9.     for (int i = 0; i < ROWS; i++) { 
  10.         y1 = start + 40*i;
  11.         y2 = y1;
  12.         g_2d.drawLine(x1, y1, x2, y2);        
  13.     }
  15.     y1=start;
  16.     y2=586;
  17.     for (int i = 0; i < COLS; i++) { 
  18.         x1 = start + 40*i;
  19.         x2 = x1;
  20.         g_2d.drawLine(x1, y1, x2, y2);        
  21.     }
  22. }

绘制5个圆点

  1. //绘制5个黑点
  2. private void draw5Point(Graphics g) { 
  3.     //第1个点
  4.     g.fillArc(142, 142, 8, 8, 0, 360);
  5.     //第2个点
  6.     g.fillArc(462, 142, 8, 8, 0, 360);
  8.     //第3个点
  9.     g.fillArc(142, 462, 8, 8, 0, 360);
  10.     //第4个点
  11.     g.fillArc(462, 462, 8, 8, 0, 360);
  13.     //中心点
  14.     g.fillArc(302, 302, 8, 8, 0, 360);
  15. }

在paint方法里面调用以上2个方法

  1. @Override
  2. public void paint(java.awt.Graphics g) { 
  3.     super.paint(g);
  4.     //绘制网格
  5.     drawGrid(g);
  6.     //绘制5个黑点
  7.     draw5Point(g);
  8. }

棋盘已经绘制完成
在这里插入图片描述

实现落子指示器

  1. 创建指示器类

    1. package main;
    3. import java.awt.Color;
    4. import java.awt.Graphics;
    6. //指示器类
    7. public class Pointer { 
    8.     private int i=0;//二维下标i
    9.     private int j=0;//二维下标j
    10.     private int x=0;//坐标X
    11.     private int y=0;//坐标Y
    12.     private GamePanel panel=null;
    13.     private Color color=null;
    14.     private int h=40;//指示的大小
    15.     private boolean isShow=false;//是否展示
    16.     private int qizi = 0 ;//棋子类型 0：无 1：白棋 2：黑棋
    18.     public Pointer(int x,int y,int i,int j,Color color,GamePanel panel){ 
    19.         this.x=x;
    20.         this.y=y;
    21.         this.i=i;
    22.         this.j=j;
    23.         this.panel=panel;
    24.         this.color=color;
    25.     }
    26.     //绘制
    27.     void draw(Graphics g){ 
    28.         Color oColor = g.getColor();
    29.         if(color!=null){ 
    30.             g.setColor(color);
    31.         }
    32.         if(isShow){ 
    33.             //绘制指示器
    34.             g.drawRect(x-h/2, y-h/2, h, h);
    35.         }
    36.         if(color!=null){ //用完设置回去颜色
    37.             g.setColor(oColor);
    38.         }
    39.     }
    40.     //判断鼠标是否在指针范围内
    41.     boolean isPoint(int x,int y){ 
    42.         //大于左上角，小于右下角的坐标则肯定在范围内
    43.         if(x>this.x-h/2 && y >this.y-h/2
    44.             && x<this.x+h/2 && y <this.y+h/2){ 
    45.             return  true;
    46.         }
    47.         return false;
    48.     }
    49.     public boolean isShow() { 
    50.         return isShow;
    51.     }
    52.     public void setShow(boolean isShow) { 
    53.         this.isShow = isShow;
    54.     }
    55.     public int getQizi() { 
    56.         return qizi;
    57.     }
    58.     public void setQizi(int qizi) { 
    59.         this.qizi = qizi;
    60.     }
    61.     public int getX() { 
    62.         return x;
    63.     }
    64.     public void setX(int x) { 
    65.         this.x = x;
    66.     }
    67.     public int getY() { 
    68.         return y;
    69.     }
    70.     public void setY(int y) { 
    71.         this.y = y;
    72.     }
    73.     public int getI() { 
    74.         return i;
    75.     }
    76.     public void setI(int i) { 
    77.         this.i = i;
    78.     }
    79.     public int getJ() { 
    80.         return j;
    81.     }
    82.     public void setJ(int j) { 
    83.         this.j = j;
    84.     }
    85. }

  2. 初始化二维数组

    public Pointer points[][] = new Pointer[ROWS][COLS];

  3. 创建指示器实例对象

    //创建二维数组
    private void createArr() { 

    1. int x=0,y=0;
    2. for (int i = 0; i < ROWS; i++) { 
    3.     for (int j = 0; j < COLS; j++) { 
    4.         y = 26 + 40*i;
    5.         x = 26 + 40*j;
    6.         Pointer pointer = new Pointer(x, y, i,j,new Color(255,0,0), this);
    7.         points[i][j] = pointer;
    8.     }
    9. }

    }

  4. 初始化调用

    1. //初始化相关对象
    2. private void init() { 
    3.     createArr();
    4.     //游戏开始标记
    5.     gameFlag="start";
    6. }

    同时 init方法 在GamePanel 的构造方法调用。

  5. paint方法中遍历二维数组并且绘制。

    1. @Override
    2. public void paint(java.awt.Graphics g) { 
    3.     super.paint(g);
    4.     //绘制网格
    5.     drawGrid(g);
    6.     //绘制5个黑点
    7.     draw5Point(g);
    8.     //绘制指示器
    9.     Pointer pointer = null;
    10.     for (int i = 0; i < ROWS; i++) { 
    11.         for (int j = 0; j < COLS; j++) { 
    12.             pointer = points[i][j] ;
    13.             if(pointer!=null){ 
    14.                 pointer.draw(g);
    15.             }
    16.         }
    17.     }
    18. }

    运行如下
    在这里插入图片描述

但是这个指示器方块不是我们想要的，需要改一下

  1. 修改指示器类的绘图代码

在Pointer方法中新增方法，并在指示器绘制的时候调用此方法，而不是之前的drawRect。

  1. private void drawPointer(Graphics g) { 
  3.     Graphics2D g2 = (Graphics2D)g;  //g是Graphics对象
  4.     g2.setStroke(new BasicStroke(2.0f));
  6.     /* * 1.先计算4个顶点 * 2.依次从每个顶点绘制横竖两条线 */
  8.     //左上角
  9.     int x1 = x-h/2;
  10.     int y1 = y-h/2;
  11.     //向右画线
  12.     int x2 = x1+1*h/4;
  13.     int y2 = y1;
  14.     g2.drawLine(x1, y1, x2, y2);
  16.     //向下画线
  17.     x2 = x1;
  18.     y2 = y1+1*h/4;
  19.     g2.drawLine(x1, y1, x2, y2);
  21.     //右上角
  22.     x1 = x+h/2;
  23.     y1 = y-h/2;
  24.     //向左画线
  25.     x2 = x1-1*h/4;
  26.     y2 = y1;
  27.     g2.drawLine(x1, y1, x2, y2);
  29.     //向下画线
  30.     x2 = x1;
  31.     y2 = y1+1*h/4;
  32.     g2.drawLine(x1, y1, x2, y2);
  34.     //右下角
  35.     x1 = x+h/2;
  36.     y1 = y+h/2;
  37.     //向左画线
  38.     x2 = x1-1*h/4;
  39.     y2 = y1;
  40.     g2.drawLine(x1, y1, x2, y2);
  42.     //向上画线
  43.     x2 = x1;
  44.     y2 = y1-1*h/4;
  45.     g2.drawLine(x1, y1, x2, y2);
  47.     //左下角
  48.     x1 = x-h/2;
  49.     y1 = y+h/2;
  50.     //向右画线
  51.     x2 = x1+1*h/4;
  52.     y2 = y1;
  53.     g2.drawLine(x1, y1, x2, y2);
  55.     //向上画线
  56.     x2 = x1;
  57.     y2 = y1-1*h/4;
  58.     g2.drawLine(x1, y1, x2, y2);
  59. }

再运行

在这里插入图片描述

落子

  1. 创建ImageValue加载类

    1. import java.awt.image.BufferedImage;
    2. import java.io.IOException;
    3. import javax.imageio.ImageIO;
    5. public class ImageValue { 
    6.     public static BufferedImage whiteQiziImage  ;
    8.     public static BufferedImage blackQiziImage  ;
    9.     //路径
    10.     public static String ImagePath = "/images/";
    11.     //将图片初始化
    12.     public static void init(){ 
    13.         String whitePath = ImagePath +"white.png";
    14.         String blackPath = ImagePath +"black.png";
    15.         try { 
    16.             whiteQiziImage = ImageIO.read(ImageValue.class.getResource(whitePath));
    17.             blackQiziImage = ImageIO.read(ImageValue.class.getResource(blackPath));
    18.         } catch (IOException e) { 
    19.             e.printStackTrace();
    20.         }
    21.     }
    22. }

  2. 创建落子类

    1. import java.awt.Color;
    2. import java.awt.Graphics;
    3. import common.ImageValue;
    5. public class Qizi { 
    7.     private int x = 0;
    8.     private int y = 0;
    9.     private int r = 36;
    10.     private GamePanel panel = null;
    11.     private Color color = null;
    12.     private int type = 1;// 棋子类型 1：白棋 2：黑棋
    14.     public Qizi(int x, int y, int type, GamePanel panel) { 
    15.         this.x = x;
    16.         this.y = y;
    17.         this.panel = panel;
    18.         this.type=type;
    19.     }
    21.     // 绘制
    22.     void draw(Graphics g) { 
    23.         Color oColor = g.getColor();
    24.         if (type == 1) { // 白色
    25.             g.drawImage(ImageValue.whiteQiziImage, x - r / 2, y - r / 2,r,r, null);
    26.         } else { // 黑色
    27.             g.drawImage(ImageValue.blackQiziImage, x - r / 2, y - r / 2,r,r, null);
    28.         }
    30.         if (color != null) { // 用完设置回去颜色
    31.             g.setColor(oColor);
    32.         }
    33.     }
    35.     public int getType() { 
    36.         return type;
    37.     }
    39.     public void setType(int type) { 
    40.         this.type = type;
    41.     }
    42. }

  3. 在createMouseListener方法中重写mouseClicked，创建棋子

    1. @Override
    2. public void mouseClicked(MouseEvent e) { 
    3.     //在合适的位置点击则进行落子操作
    4.     if(!"start".equals(gameFlag)) return ;
    6.     int x = e.getX();
    7.     int y = e.getY();
    9.     Pointer pointer;
    10.     for (int i = 0; i <ROWS; i++) { 
    11.         for (int j = 0; j < COLS; j++) { 
    12.             pointer = points[i][j];
    13.             if(pointer==null)continue;
    14.             //被点击，且没有棋子，则可以落子
    15.             if(pointer.isPoint(x, y) && pointer.getQizi()==0){ 
    16.                 Qizi qizi = new Qizi(pointer.getX(), pointer.getY(), 2, gamePanel);
    17.                 pointer.setQizi(2);
    18.                 qizis.add(qizi);
    19.                 //重绘画布
    20.                 repaint();
    21.                 return ;
    22.             }
    23.         }
    24.     }
    25. }
  4. 在paint 方法中绘制棋子
    1. @Override
    2. public void paint(java.awt.Graphics g) { 
    3.     super.paint(g);
    4.     //绘制网格
    5.     drawGrid(g);
    6.     //绘制5个黑点
    7.     draw5Point(g);
    8.     //绘制指示器
    9.     Pointer pointer = null;
    10.     for (int i = 0; i < ROWS; i++) { 
    11.         for (int j = 0; j < COLS; j++) { 
    12.             pointer = points[i][j] ;
    13.             if(pointer!=null){ 
    14.                 pointer.draw(g);
    15.             }
    16.         }
    17.     }
    18.     //绘制棋子
    19.     Qizi qizi=null;
    20.     for (int i = 0; i < qizis.size(); i++) { 
    21.         qizi = (Qizi)qizis.get(i);
    22.         qizi.draw(g);
    23.     }
    24. }
    在这里插入图片描述

加入电脑AI

  1. 创建AI类
  2. 创建静态方法next（下一步）

  3. 创建静态方法has5（连成5子）

    1. public class AI { 
    2.     //AI进行下一步
    3.     static void next(GamePanel gamePanel){ 
    5.     }
    6.     //判断五子连珠
    7.     static boolean has5(Pointer pointer1,GamePanel gamePanel){ 
    9.         return false;
    10.     }
    11. }
  4. 在你落子后，会先执行has5方法，根据返回来决定走向

  5. has5返回true则表示你获得胜利，否则AI将会走一步棋
    在刚才的mouseClicked修改代码

    1. @Override
    2. public void mouseClicked(MouseEvent e) { 
    3.     //在合适的位置点击则进行落子操作
    4.     if(!"start".equals(gameFlag)) return ;
    6.     int x = e.getX();
    7.     int y = e.getY();
    9.     Pointer pointer;
    10.     for (int i = 0; i <ROWS; i++) { 
    11.         for (int j = 0; j < COLS; j++) { 
    12.             pointer = points[i][j];
    13.             if(pointer==null)continue;
    14.             //被点击，且没有棋子，则可以落子
    15.             if(pointer.isPoint(x, y) && pointer.getQizi()==0){ 
    16.                 Qizi qizi = new Qizi(pointer.getX(), pointer.getY(), 2, gamePanel);
    17.                 pointer.setQizi(2);
    18.                 qizis.add(qizi);
    19.                 //重绘画布
    20.                 repaint();
    21.                 //判断有没有五子连珠的情况
    22.                 if(AI.has5(pointer, gamePanel)){ 
    23.                     gamePanel.gameWin();
    24.                 }else{ 
    25.                     AI.next(gamePanel);
    26.                 }
    27.                 return ;
    28.             }
    29.         }
    30.     }
    31. }
  6. 在AI类中随机落子（创建方法）

- 随机获取下标 i 和 j。
- 通过下标从二维数组取到指示器对象。
- 如果此指示器被占用则再次随机（递归），直到正确获取到指示器对象。
- 在此指示器位置，创建棋子对象并更新指示器的棋子信息。
- Qizi类中加入last属性，表示AI下的最后一个棋子。
- 根据last在对应的位置创建一个小红方块标示AI的最后落子。
````
//随机落子
static boolean luoziRandom(GamePanel gamePanel){ 

  1.     Pointer pointer = getRandomPointer(gamePanel);
  3.     luozi(pointer, gamePanel,1);
  5.     return true;
  6. }
  8. //获取随机下的棋子
  9. static Pointer getRandomPointer(GamePanel gamePanel){ 
  10.     Random random = new Random();
  11.     int i = random.nextInt(gamePanel.ROWS);
  12.     int j = random.nextInt(gamePanel.COLS);
  13.     //取得随机到的格子
  14.     Pointer pointer = gamePanel.points[i][j];
  15.     if(pointer.getQizi()!=0){ //如果当前格子已经下了棋子，则递归重新取
  16.         pointer = getRandomPointer(gamePanel);
  17.     }
  18.     return pointer;
  19. }
  21. //AI落子操作
  22. static void luozi(Pointer pointer,GamePanel gamePanel,int type){ 
  23.     if(pointer.getQizi()==0){ //如果没有棋子，则落子
  24.         Qizi qizi = new Qizi(pointer.getX(), pointer.getY(), type, gamePanel);
  25.         qizi.setLast(true);
  26.         pointer.setQizi(type);
  27.         gamePanel.qizis.add(qizi);
  29.         //重绘画布
  30.         gamePanel.repaint();
  32.         //判断电脑有没有五子连珠的情况
  33.         if(AI.has5(pointer, gamePanel)){ 
  34.             gamePanel.gameOver();
  35.         }
  36.     }
  37. }
  1. 1.  AI的next方法调用随机落子
  1. //AI进行下一步
  2.     static void next(GamePanel gamePanel){ 
  3.         luoziRandom(gamePanel);
  4.     }
  1. 运行效果：
  3. ![在这里插入图片描述][20210719215047199.gif_pic_center]
  5. 1.  小红方块一直在，修改代码  
  6.     **仅需在落子前将其他小红方块清除即可**
  1. //清除电脑棋子的最后一个棋子指示器
  2. private void clearAILast() { 
  3.     Qizi qizi;
  4.     for (int i = 0; i < qizis.size(); i++) { 
  5.         qizi = (Qizi)qizis.get(i);
  6.         if(qizi!=null && qizi.getType()==1){ 
  7.             qizi.setLast(false);
  8.         }
  9.     }
  10. }

````
在这里插入图片描述
在这里插入图片描述

AI算法

棋子的4个方向

  • 横向
    在这里插入图片描述
  • 竖向
    在这里插入图片描述
  • 右捺
    在这里插入图片描述
  • 左撇
    在这里插入图片描述

权重分

描述：计算出分数，最高的分数来决定下一步的落子。
左开：就是说左边可落子
右开：右边可落子

3子的相关定义（4、5子类似）

什么是3子左开，就是目前有2个子，下一个子可以落子左边

在这里插入图片描述

3子只能落子在中间，图示：

在这里插入图片描述

3子右开就是落子在右边

在这里插入图片描述

只计算3个子以上的分数

类型 3子左开 3子 3子右开
得分 32 30 31
类型 4子左开 4子 4子右开
得分 42 40 41
类型 5子左开 5子 5子右开
得分 52 50 51

通过上述表可以看到，落子权重分顺序：5>4>3，同时：左>右>中。

计算横向权重分

  1. 从左往右判断

* 横向下标 i 是一样的，循环从当前位置 j 加1开始。
* 当碰到和当前子一样的就计数器 +1。
* 当碰到不一样的就退出循环，表示堵住 。
* 如果碰到空子，是第一次计数器 +1，第二次退出循环。
* 判断左开和右开的状态。
* 根据计数器和左右开的状态，计算出分数

  1. 从右往左判断

* 横向下标 i 是一样的，循环从当前位置 j 减1开始。
* 当碰到和当前子一样的就计数器 +1。
* 当碰到不一样的就退出循环，表示堵住 。
* 如果碰到空子，是第一次计数器 +1，第二次退出循环。
* 判断左开和右开的状态。
* 根据计数器、左右开的状态，计算出分数和落子的位置。

其实左右还是很相似的

  1. static Data getData(Pointer pointer,int dir,int type,GamePanel gamePanel){ 
  2.     Pointer[][] points = gamePanel.points;
  3.     int i = pointer.getI();
  4.     int j = pointer.getJ();
  6.     Data resData = new Data();
  7.     Pointer tempPointer;
  8.     int num=1;//默认是1，因为其中自己就是一个子。
  9.     int num2=1;//默认是1，用来累加连续的棋子数
  10.     int breakNum=0;//默认是0，有一个则不能通过了。
  12.     boolean lClosed=false;//左边是否关闭
  13.     boolean rClosed=false;//右边是否关闭
  14.     if(dir==1){ //横向
  15.         //往右循环，判断能与当前pointer 相同的棋子连续多少个。
  16.         if(type==1){ 
  17.             for (int k = j+1; k < gamePanel.COLS; k++) { 
  18.                 tempPointer = points[i][k];
  19.                 if(tempPointer.getQizi()==pointer.getQizi()){ //连续
  20.                     num++;
  21.                     num2++;
  22.                     if(k == gamePanel.COLS-1){ //如果最后一个子也是连续的，则也是右关闭的
  23.                         rClosed = true;
  24.                     }
  25.                 }else if(tempPointer.getQizi()==0){ //空白子
  26.                     if(breakNum==1){ //有一个则不能通过了
  27.                         if(points[i][k-1].getQizi()==0){ //如果前一个是空子，要设置成不是中断的
  28.                             breakNum=0;
  29.                         }else{ 
  30.                             breakNum=2;
  31.                         }
  32.                         break;
  33.                     }
  34.                     breakNum=1;
  35.                     num++;
  36.                     //是中断的那种，这里设定好落子位置
  37.                     resData.setI(i);
  38.                     resData.setJ(k);
  39.                 }else{ //对立子，右关闭
  40.                     rClosed = true;
  41.                     break;
  42.                 }
  43.             }
  44.             //判断是否左关闭
  45.             if(j==0){ //当前子就是最左边的子
  46.                 lClosed = true;
  47.             }else{ 
  48.                 tempPointer = points[i][j-1];
  49.                 if(tempPointer.getQizi()!=0){ //如果当前子的左边有子，则左关闭
  50.                     lClosed = true;
  51.                 }
  52.             }
  53.         }else{ //从右往左
  54.             for (int k = j-1; k >=0; k--) { 
  55.                 tempPointer = points[i][k];
  56.                 if(tempPointer.getQizi()==pointer.getQizi()){ //连续
  57.                     num++;
  58.                     num2++;
  59.                     if(k == 0){ //如果最后一个子也是连续的，则也是左关闭的
  60.                         lClosed = true;
  61.                     }
  62.                 }else if(tempPointer.getQizi()==0){ //空白子
  63.                     if(breakNum==1){ //有一个则不能通过了。
  64.                         if(points[i][k+1].getQizi()==0){ //如果前一个是空子，要设置成不是中断的
  65.                             breakNum=0;
  66.                         }else{ 
  67.                             breakNum=2;
  68.                         }
  69.                         break;
  70.                     }
  71.                     breakNum=1;
  72.                     num++;
  73.                     //是中断的那种，这里设定好落子位置
  74.                     resData.setI(i);
  75.                     resData.setJ(k);
  76.                 }else{ //对立子，左关闭
  77.                     lClosed = true;
  78.                     break;
  79.                 }
  80.             }
  81.             //判断是否右关闭
  82.             if(j==gamePanel.COLS-1){ //当前子就是最右边的子
  83.                 rClosed = true;
  84.             }else{ 
  85.                 tempPointer = points[i][j+1];
  86.                 if(tempPointer.getQizi()!=0){ //如果当前子的右边有子，则右关闭
  87.                     rClosed = true;
  88.                 }
  89.             }
  90.         }
  91.     }
  92.     setCount(resData, i, j, dir, type, num,num2, breakNum, lClosed, rClosed);
  94.     return resData;
  95. }
  97. //计算并设置分数
  98. static void setCount(Data data,int i,int j,int dir,int type,
  99.         int num,int num2,int breakNum,boolean lClosed,boolean rClosed){ 
  100.     int count=0;
  101.     if(num>2){ //连续3个子以上
  102.         if(num==3){ //设定默认分
  103.             count=30;
  104.         }else if(num==4){ 
  105.             count=40;
  106.         }else if(num==5){ 
  107.             count=50;
  108.         }
  109.         if(num2>=5&&breakNum==0){ //用来判断是否五子或五子以上
  110.             count=100;
  111.             //设定好权重分
  112.             data.setCount(count);
  113.             return ;
  114.         }
  115.         if(breakNum==0){ //如果不是中断的那种
  116.             if(lClosed&&rClosed){ //如果没有中断，并且左右都关闭了，则分数为-1，-1表示落子的时候要过滤掉
  117.                 count = -1;
  118.             }else if(!lClosed){ //如果是中断的那种，左边未关闭
  119.                 count+=2;//加2分
  120.                 if(dir==1){ 
  121.                     if(type==1){ 
  122.                         data.setI(i);
  123.                         data.setJ(j-1);
  124.                     }else{ 
  125.                         data.setI(i);
  126.                         data.setJ(j-num+1);
  127.                     }
  128.                 }else if(dir==2){ 
  129.                     if(type==1){ 
  130.                         data.setI(i-1);
  131.                         data.setJ(j);
  132.                     }else{ 
  133.                         data.setI(i-num+1);
  134.                         data.setJ(j);
  135.                     }
  136.                 }else if(dir==3){ 
  137.                     if(type==1){ 
  138.                         data.setI(i-1);
  139.                         data.setJ(j-1);
  140.                     }else{ 
  141.                         data.setI(i-num+1);
  142.                         data.setJ(j-num+1);
  143.                     }
  144.                 }else if(dir==4){ 
  145.                     if(type==1){ 
  146.                         data.setI(i+1);
  147.                         data.setJ(j-1);
  148.                     }else{ 
  149.                         data.setI(i+num-1);
  150.                         data.setJ(j-num+1);
  151.                     }
  152.                 }
  153.             }else if(!rClosed){ //如果是中断的那种，右边未关闭
  154.                 count+=1;//加1分
  155.                 if(dir==1){ 
  156.                     if(type==1){ 
  157.                         data.setI(i);
  158.                         data.setJ(j+num-1);
  159.                     }else{ 
  160.                         data.setI(i);
  161.                         data.setJ(j+1);
  162.                     }
  163.                 }else if(dir==2){ 
  164.                     if(type==1){ 
  165.                         data.setI(i+num-1);
  166.                         data.setJ(j);
  167.                     }else{ 
  168.                         data.setI(i+1);
  169.                         data.setJ(j);
  170.                     }
  171.                 }else if(dir==3){ 
  172.                     if(type==1){ 
  173.                         data.setI(i+num-1);
  174.                         data.setJ(j+num-1);
  175.                     }else{ 
  176.                         data.setI(i+1);
  177.                         data.setJ(j+1);
  178.                     }
  179.                 }else if(dir==4){ 
  180.                     if(type==1){ 
  181.                         data.setI(i-num+1);
  182.                         data.setJ(j+num-1);
  183.                     }else{ 
  184.                         data.setI(i-1);
  185.                         data.setJ(j+1);
  186.                     }
  187.                 }
  188.             }
  189.         }else{ //如果中断，
  190.             if(num!=5){ //num不是5， 并且左右都关闭，也要过滤
  191.                 if(lClosed&&rClosed){ 
  192.                     count = -1;
  193.                 }
  194.             }
  195.         }
  196.         //设定好权重分
  197.         data.setCount(count);
  198.     }
  199. }

AI落子处理

- 循环取横向、竖向、右捺、左撇 4种分数，放到List集合中
- 对集合进行排序（分数从高到底）
- 第一个分数值作为下一步落子的位置
- 落子操作（如果集合没有值，则进行随机落子）

  1. //进行下一步
  2. static boolean go(GamePanel gamePanel){ 
  4.     List<Data> datas=new ArrayList<Data>();
  5.     //循环找出黑棋，判断此棋子的1横向 2纵向 3右捺 4左撇 是否有4子的情况，
  6.     Pointer pointer;
  7.     for (int i = 0; i <gamePanel.ROWS; i++) { 
  8.         for (int j = 0; j < gamePanel.COLS; j++) { 
  9.             pointer = gamePanel.points[i][j];
  10.             if(pointer==null)continue;
  11.             if(pointer.getQizi()==0){ //没有棋子则跳过
  12.                 continue;
  13.             }
  14.             //循环4个方向
  15.             int dir=1;
  16.             for (int k = 1; k <= 4; k++) { 
  17.                 dir = k;
  18.                 Data data = getData(pointer, dir,1, gamePanel);
  19.                 if(data.getCount()!=-1&&data.getCount()!=0){ //0和-1 的过滤掉
  20.                     datas.add(data);
  21.                 }
  22.                 data = getData(pointer, dir, 2,gamePanel);
  23.                 if(data.getCount()!=-1&&data.getCount()!=0){ //0和-1 的过滤掉
  24.                     datas.add(data);
  25.                 }
  26.             }
  27.         }
  28.     }
  29.     //按权重分排序处理，从大到小
  30.     Collections.sort(datas, new DataCount());
  32.     /*for (int i = 0; i < datas.size(); i++) { System.out.println("----------"+datas.get(i).getCount()); }*/
  33.     if(datas.size()>0){ //取第一个位置落子
  34.         Data data = datas.get(0);
  35.         Pointer p = gamePanel.points[data.getI()][data.getJ()];
  36.         luozi(p, gamePanel, 1);
  37.         return true;
  38.     }
  40.     return false;
  41. }

五子或者以上的判断就很简单了，当棋子是连续的并且计数器大于5就成功了！

这里只介绍了横向的，另外3个情况也差不多，就是注意下标的处理即可。

在这里插入图片描述

最后

1. AI还不是特别智能，应该算简单版吧，赢的难度不大.
2. 可能会有我没发现的bug吧，望理解！

看到这里的大佬，动动发财的小手 点赞 + 回复 + 收藏，能【 关注 】一波就更好了。

发表评论

表情：
评论列表 （有 0 条评论，439人围观）

还没有评论，来说两句吧...

相关阅读

    相关 五子棋人机对战设计

    一、人机对战算法概述 人机对战属于一种弱人工智能算法，其核心是：当玩家落下一枚棋子后，计算出这枚棋子构成的所有棋型，找出威胁程度最大的棋型，并破解其产生的威胁。 五子棋中所

    古城微笑少年丶古城微笑少年丶/ 0 赞/ 306 阅读

    相关 昨天今天明天

    在即将毕业之季，写下自己的昨天今天明天。 昨天： 四年凭着自己努力，来到了四川成都一所不被人所赞赏的普通学校西华大学。也许你们会提到，这还需要努力？？？简直太搞笑了！在大多

    柔光的暖阳◎柔光的暖阳◎/ 0 赞/ 448 阅读

    相关 昨天，今天，明天

       06年哦，对我来说，真是个动荡的一年，或者也可以说真是个丰富多彩的一年哦， 算算，总共工作过4家公司，当然，里面还包括给人做的兼职，（到现在还没有拿到报酬呢，不知道现在为

    た 入场券た 入场券/ 0 赞/ 625 阅读