Java小程序——简单五子棋(人机对战)

简介: 于某些原因,这里我给出的AI算法算是比较简单的,所以导致了电脑其实并没有很强,甚至你玩的多了还可以发现电脑的“致命缺点”,由于我只是借助这个项目来做一个java的入门练习,且我还在读研,所以本人并不准备对AI的算法进行改进。

由于某些原因,这里我给出的AI算法算是比较简单的,所以导致了电脑其实并没有很强,甚至你玩的多了还可以发现电脑的“致命缺点”,由于我只是借助这个项目来做一个java的入门练习,且我还在读研,所以本人并不准备对AI的算法进行改进。


五子棋游戏接口:


public interface WZQConfig {
    /*
     * 起始位置X
     */
    public static final int START_X = 60;
    /*
     * 起始位置Y
     */
    public static final int START_Y = 60;
    /*
     * 五子棋盘线条数
     */
    public static final int H_LINE = 15;
    /*
     * 五子棋盘竖线条数
     */
    public static final int V_LINE = 15;
    /*
     * 五子棋盘格子大小
     */
    public static final int SIZE = 60;
    /*
     * 储存棋子的x位置信息
     */
    public static final int[][] bx = new int[17][17];
    public static final int[][] bx_lastStep = new int[17][17];
    public static final int[][] weightArray = new int [17][17];
}



界面类:


import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
/*
 * 五子棋的界面类,该类继承JFrame,然后实现WZQConfig接口
 */
import javax.swing.JPanel;
public class WZQFrame extends JPanel implements WZQConfig {
    public void WZQFrame() {
        // WZQFrame ui = new WZQFrame();
        JFrame jf = new javax.swing.JFrame();
        jf.setTitle("五子棋");
        jf.setDefaultCloseOperation(3);
        jf.setSize(1246, 1080);
        jf.setLocationRelativeTo(null);
 jf.setResizable(false);
        jf.setLayout(new FlowLayout());
        this.setLayout(new FlowLayout());
        this.setPreferredSize(new Dimension(1030, 1080));
        // this.setBackground(Color.CYAN);
        // 把面板对象添加到窗体上
        jf.add(this);
        JPanel jp1 = new JPanel();
        jp1.setPreferredSize(new Dimension(200, 1080));
        jp1.setLayout(new FlowLayout());
        jf.add(jp1);
        LoginListener ll = new LoginListener();
        String[] str = { "悔棋", "重新开始" };
        for (int i = 0; i < str.length; i++) {
            JButton jbu1 = new JButton(str[i]);
            jbu1.setPreferredSize(new Dimension(150, 80));
            jbu1.setFont(new Font("楷体", Font.BOLD,20));//设置字体
            jp1.add(jbu1);
            jbu1.addActionListener(ll);
        }
        jf.setVisible(true);
        Graphics g = this.getGraphics();
        this.addMouseListener(ll);
        ll.setG(g);
        ll.setU(this);
    }
    /*
     * 重写窗体绘制容器的方法
     */
    public void paint(Graphics g) {
        super.paint(g);
        ImageIcon im2 = new ImageIcon(this.getClass().getResource("2.jpg"));
        g.drawImage(im2.getImage(), 0, 0, 1030, 1080, null);
        for (int i = 1; i < 17; i++) {
            Graphics2D g2 = (Graphics2D) g;
            g2.setStroke(new BasicStroke(4));
            g2.drawLine(START_X, START_Y * i, START_X + SIZE * V_LINE, START_Y
                    * i);// 横线
            g2.drawLine(START_X * i, START_Y, START_X * i, START_Y + SIZE
                    * V_LINE);// 竖线
            g2.setStroke(new BasicStroke(8));
            // 画边框
            g2.drawLine(35, 35, 990, 35);
            g2.drawLine(35, 990, 990, 990);
            g2.drawLine(35, 35, 35, 990);
            g2.drawLine(990, 35, 990, 990);
        }
        for (int k = 0; k < 17; k++) {
            for (int k1 = 0; k1 < 17; k1++) {
                if (bx[k][k1] == 1) {
                    g.setColor(Color.BLACK);
                    g.fillOval(Math.abs(k * SIZE - 25),
                            Math.abs(k1 * SIZE - 25), 50, 50);
                } else if (bx[k][k1] == 2) {
                    g.setColor(Color.WHITE);
                    g.fillOval(Math.abs(k * SIZE - 25),
                            Math.abs(k1 * SIZE - 25), 50, 50);
                }
            }
        }
    }
    public static void main(String[] args) {
        WZQFrame l = new WZQFrame();
        l.WZQFrame();
    }
}
控制器/监听类:
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.HashMap;
import java.util.Random;
import javax.swing.JButton;
import javax.swing.JOptionPane;
public class LoginListener implements MouseListener, WZQConfig, ActionListener {
    private int x, y;// 鼠标点击的位置
    private int x1, y1, xx, yy, x2, y2;// 鼠标点击附近格子交点的坐标
    private Graphics g;
    private int a = 0, i = 0, j = 0, count1 = 0;// count统计当前下的棋子数
    private String Str;// 定义全局变量获取按钮上的字符串
    private JButton jbu1, jbu2;
    private int GetX[] = new int[256];
    private int GetY[] = new int[256];
    WZQFrame ui;
    HashMap<String,Integer> map = new HashMap<String,Integer>();
    public LoginListener(){
        // 活一连
        map.put("010", 20);
        map.put("020", 20);
        map.put("01", 20);
        map.put("02", 20);
        map.put("10", 20);
        map.put("20", 20);
        // 活二连
        map.put("0110", 100);
        map.put("0220", 100);
        map.put("011", 100);
        map.put("110", 100);
        map.put("022", 100);
        map.put("220", 100);
        // 活三连
        map.put("01110", 500);
        map.put("02220", 500);
        map.put("1110", 500);
        map.put("0111", 500);
        map.put("2220", 500);
        map.put("0222", 500);
        // 活四连
        map.put("011110", 10000);
        map.put("022220", 10000);
        map.put("01111", 10000);
        map.put("11110", 10000);
        map.put("02222", 10000);
        map.put("22220", 10000);
        // 死一连
        map.put("012", 10);
        map.put("021", 10);
        map.put("120", 10);
        map.put("210", 10);
        // 死二连
        map.put("0112", 70);
        map.put("0221", 70);
        map.put("2110", 70);
        map.put("1220", 70);
        // 死三连
        map.put("01112", 200);
        map.put("02221", 200);
        map.put("21110", 200);
        map.put("12220", 200);
        // 死四连
        map.put("011112", 10000);
        map.put("022221", 10000);
        map.put("211110", 10000);
        map.put("122220", 10000);
    }
    public void setG(Graphics g) {
        this.g = g;
    }
    public void setT(JButton b) {
        jbu1 = b;
    }
    public void setU(WZQFrame u) {
        ui = u;
    }
    public void mouseClicked(MouseEvent e) {
    }
    public void mousePressed(MouseEvent e) {
    }
    public void mouseReleased(MouseEvent e) {
        x = e.getX();
        y = e.getY();
        x1 = Math.abs(x - START_X);
        y1 = Math.abs(y - START_Y);
        xx = x1 % SIZE;
        if (xx >= SIZE / 2) {
            x1 = (x1 / SIZE) + 2;
        } else {
            x1 = (x1 / SIZE) + 1;
        }
        yy = y1 % SIZE;// 判断横坐标是否超过格子长度的一半(防止玩家点偏)
        if (yy >= SIZE / 2) {
            y1 = (y1 / SIZE) + 2;
        } else {
            y1 = (y1 / SIZE) + 1;
        }
        g.setColor(Color.BLACK);
        if (bx[x1][y1] == 0) {
            bx[x1][y1] = 1;// 表示黑棋
            g.fillOval(Math.abs(x1 * SIZE - 25), Math.abs(y1 * SIZE - 25), 50,
                    50);
            count1++;// 所下棋子数加一
            GetX[count1] = x1;// 记录第count1步的棋子x值
            GetY[count1] = y1;// 记录第count1步的棋子y值
            if (CheckRow(x1, y1) >= 5) {
                JOptionPane.showMessageDialog(null, "BLACK   WIN!!");
            }
            if (CheckList(x1, y1) >= 5) {
                JOptionPane.showMessageDialog(null, "BLACK   WIN!!");
            }
            if (UpperRight(x1, y1) >= 5) {
                JOptionPane.showMessageDialog(null, "BLACK   WIN!!");
            }
            if (UpperLeft(x1, y1) >= 5) {
                JOptionPane.showMessageDialog(null, "BLACK   WIN!!");
            }
        }
        g.setColor(Color.WHITE);
        WZQAI();// 遍历棋盘
        AIcount();// 电脑计算应该下棋的坐标
        if (bx[x1][y1] == 0) {
            bx[x1][y1] = 2;// 表示白棋
            if(x1==0)
            {g.fillOval(Math.abs((x1+1)* SIZE - 25), Math.abs((y1+1) * SIZE - 25), 50,
                    50);}
            else
            {
                g.fillOval(Math.abs(x1* SIZE - 25), Math.abs(y1 * SIZE - 25), 50,
                        50);
            }
            count1++;// 所下棋子数加一
            GetX[count1] = x1;// 记录第count1步的棋子x值
            GetY[count1] = y1;// 记录第count1步的棋子y值
            if (CheckRow(x1, y1) >= 5) {
                JOptionPane.showMessageDialog(null, "WHITE   WIN!!");
            }
            if (CheckList(x1, y1) >= 5) {
                JOptionPane.showMessageDialog(null, "WHITE   WIN!!");
            }
            if (UpperRight(x1, y1) >= 5) {
                JOptionPane.showMessageDialog(null, "WHITE   WIN!!");
            }
            if (UpperLeft(x1, y1) >= 5) {
                JOptionPane.showMessageDialog(null, "WHITE   WIN!!");
            }
        }
        // 清空权值数组
        for (int r = 0; r < weightArray.length; r++) {
            for (int c = 0; c < weightArray.length; c++) {
                weightArray[r][c] = 0;
            }
        }
    }
    public void actionPerformed(ActionEvent e) {
        setT(jbu1);
        Str = e.getActionCommand();// 读取点击按钮上的字符串
        if ("悔棋".equals(Str)) {
            if (g.getColor() == Color.BLACK) {
                g.setColor(Color.WHITE);
            }
            if (g.getColor() == Color.WHITE) {
                g.setColor(Color.BLACK);
            }
            Regret();
            ui.repaint();
        } else if ("重新开始".equals(Str)) {
            Restart();
            ui.repaint();
        }
    }
    public void mouseEntered(MouseEvent e) {
    }
    public void mouseExited(MouseEvent e) {
    }
    public int CheckRow(int x, int y)// 横着五子连成一条直线
    {
        int count = 0;
        for (int i = x + 1; i < bx.length; i++)// 向右判断是否棋子一样
        {
            if (bx[i][y] == bx[x][y])
                count++;
            else
                break;
        }
        for (int i = x; i >= 0; i--)// 向右判断是否棋子一样
        {
            if (bx[i][y] == bx[x][y])
                count++;
            else
                break;
        }
        return count;
    }
    public int CheckList(int x, int y)// 竖着五子连成一条直线
    {
        int count = 0;
        for (int i = y + 1; i < bx.length; i++)// 向下判断是否棋子一样
        {
            if (bx[x][i] == bx[x][y])
                count++;
            else
                break;
        }
        for (int i = y; i >= 0; i--)// 向上判断是否棋子一样
        {
            if (bx[x][i] == bx[x][y])
                count++;
            else
                break;
        }
        return count;
    }
    public int UpperRight(int x, int y)// 右上到左下五子连成一条直线
    {
        int count = 0;
        for (int i = x + 1, j = y - 1; i < bx.length && j >= 0; i++, j--)// 向下判断是否棋子一样
        {
            if (bx[i][j] == bx[x][y])
                count++;
            else
                break;
        }
        for (int i = x, j = y; i >= 0 && j < bx.length; i--, j++)// 向上判断是否棋子一样
        {
            if (bx[i][j] == bx[x][y])
                count++;
            else
                break;
        }
        return count;
    }
    public int UpperLeft(int x, int y)// 左上到右下五子连成一条直线
    {
        int count = 0;
        for (int i = x - 1, j = y - 1; i >= 0 && j >= 0; i--, j--)// 向下判断是否棋子一样
        {
            if (bx[i][j] == bx[x][y])
                count++;
            else
                break;
        }
        for (int i = x, j = y; i < bx.length && j < bx.length; i++, j++)// 向上判断是否棋子一样
        {
            if (bx[i][j] == bx[x][y])
                count++;
            else
                break;
        }
        return count;
    }
    public void Regret() {// 悔棋
        assert count1 >= 2;
        bx[GetX[count1]][GetY[count1]] = 0;
        bx[GetX[count1-1]][GetY[count1-1]] = 0;
        if (count1 > 0) {
            count1 = count1 - 2;
        }
    }
    public void Restart() {// 重新开始
        {
            for (int k = 0; k <= count1; k++) {
                bx[GetX[k]][GetY[k]] = 0;
            }
        }
        count1 = 0;
        for (int i1 = 0; i1 < bx.length; i1++) {
            for (int j1 = 0; j1 < bx.length; j1++) {
                bx[i][j] = 0;
            }
        }
    }
    public void WZQAI() {
        // 这两个循环遍历整个存储棋子的数组
        for (int r = 0; r < bx.length; r++) {
            for (int c = 0; c < bx[r].length; c++) {
                if (bx[r][c] == 0) {// 判断是否是空位
                    int ch = 0;// 存储第一次出现棋子的变量
                    String chessCode = "0";// 存储统计棋子相连情况的变量
                    /*
                     * 横向向左 左面的棋子在chessCode为左方, 右面的棋子在chessCode为右方
                     */
                    for (int c1 = c - 1; c1 >= 0; c1--) {
                        if (bx[r][c1] == 0) {// 判断是否是空位
                            if (c1 + 1 == c) {// 判断是否是相邻的
                                break;
                            } else {// 判断是否不是相邻的
                                chessCode = bx[r][c1] + chessCode;// 记录棋子相连的情况
                                break;
                            }
                        } else {// 判断是否是棋子
                            if (ch == 0) {// 判断是否是第一次出现棋子
                                chessCode = bx[r][c1] + chessCode;// 记录棋子相连的情况
                                ch = bx[r][c1];// 存储第一次的棋子
                            } else if (ch == bx[r][c1]) {// 判断是否是一样颜色的棋子
                                chessCode = bx[r][c1] + chessCode;// 记录棋子相连的情况
                            } else {
                                chessCode = bx[r][c1] + chessCode;// 记录棋子相连的情况
                                break;
                            }
                        }
                    }
                    // 根据棋子相连的情况,获取HashMap中存储的权值
                    Integer weight = map.get(chessCode);
                    if(null==weight){
                        System.out.println(" get one null.....");
                    }
                    else{
                        int a;
                        a=weight.intValue();
                        // 存储入到权值数组中
                        weightArray[r][c] += a;
                    }
                    ch = 0;// 重置到初始状态
                    chessCode = "0";// 重置到初始状态
                    /*
                     * 横向向右 左面的棋子在chessCode为左方, 右面的棋子在chessCode为右方
                     */
                    for (int c2 = c + 1; c2 <= 15; c2++) {// 判断是是空位
                        if (bx[r][c2] == 0) {// 判断空位相邻的
                            if (c2 - 1 == c) {
                                break;
                            } else {// 判断空位是不相邻的
                                chessCode = chessCode + bx[r][c2];// 记录棋子相连的情况
                            }
                        }
                        // 判断是棋子
                        else {// 判断是第一次出现棋子
                            if (ch == 0) {
                                chessCode = chessCode + bx[r][c2];// 记录棋子相连的情况
                                ch = bx[r][c2];// 储存第一次出现的棋子
                            } else if (ch == bx[r][c2])// 判断棋子的颜色一样
                            {
                                chessCode = chessCode + bx[r][c2];
                            }// 记录棋子的连接情况
                            else {// 相邻棋子颜色不一样
                                chessCode = chessCode + bx[r][c2];
                                break;
                            }
                        }
                        weight = map.get(chessCode);
                        if(null==weight){
                            System.out.println(" get one null.....");
                        }
                        else{
                            int a;
                            a=weight.intValue();
                            // 存储入到权值数组中
                            weightArray[r][c] += a;
                        }
                        ch = 0;// 重置到初始状态
                        chessCode = "0";// 重置到初始状态
                    }
                    /*
                     * 竖向向上 上面的棋子在chessCode为左方, 下面的棋子在chessCode为右方
                     */
                    for (int r1 = r - 1; r1 >= 0; r1--) {
                        if (bx[r1][c] == 0) {// 判断是否是空位
                            if (r1 + 1 == r) {// 判断是否是相邻的
                                break;
                            } else {// 判断是否不是相邻的
                                chessCode = bx[r1][c] + chessCode;// 记录棋子相连的情况
                                break;
                            }
                        } else {// 判断是否是棋子
                            if (ch == 0) {// 判断是否是第一次出现棋子
                                chessCode = bx[r1][c] + chessCode;// 记录棋子相连的情况
                                ch = bx[r1][c];// 存储第一次的棋子
                            } else if (ch == bx[r1][c]) {// 判断是否是一样颜色的棋子
                                chessCode = bx[r1][c] + chessCode;// 记录棋子相连的情况
                            } else {
                                chessCode = bx[r1][c] + chessCode;// 记录棋子相连的情况
                                break;
                            }
                        }
                    }
                    // 根据棋子相连的情况,获取HashMap中存储的权值
                    weight = map.get(chessCode);
                    if(null==weight){
                        System.out.println(" get one null.....");
                    }
                    else{
                        int a;
                        a=weight.intValue();
                        // 存储入到权值数组中
                        weightArray[r][c] += a;
                    }
                    ch = 0;// 重置到初始状态
                    chessCode = "0";// 重置到初始状态
                    /*
                     * 竖向向下 上面的棋子在chessCode为左方, 下面的棋子在chessCode为右方
                     */
                    for (int r2 = r + 1; r2 <= 15; r2++) {// 判断是是空位
                        if (bx[r2][c] == 0) {// 判断空位相邻的
                            if (r2 - 1 == r) {
                                break;
                            } else {// 判断空位是不相邻的
                                chessCode = chessCode + bx[r2][c];// 记录棋子相连的情况
                            }
                        }
                        // 判断是棋子
                        else {// 判断是第一次出现棋子
                            if (ch == 0) {
                                chessCode = chessCode + bx[r][c];// 记录棋子相连的情况
                                ch = bx[r2][c];// 储存第一次出现的棋子
                            } else if (ch == bx[r2][c])// 判断棋子的颜色一样
                            {
                                chessCode = chessCode + bx[r2][c];
                            }// 记录棋子的连接情况
                            else {// 相邻棋子颜色不一样
                                chessCode = chessCode + bx[r2][c];
                                break;
                            }
                        }
                        weight = map.get(chessCode);
                        if(null==weight){
                            System.out.println(" get one null.....");
                        }
                        else{
                            int a;
                            a=weight.intValue();
                            // 存储入到权值数组中
                            weightArray[r][c] += a;
                        }
                        ch = 0;// 重置到初始状态
                        chessCode = "0";// 重置到初始状态
                    }
                    /*
                     * 左斜向上 左上面的棋子在chessCode为左方, 右下面的棋子在chessCode为右方
                     */
                    for (int r1 = r - 1, c1 = c - 1; c1 >= 0 && r1 >= 0; c1--, r1--) {
                        if (bx[r1][c1] == 0) {// 判断是否是空位
                            if (c1 + 1 == c && r1 + 1 == c) {// 判断是否是相邻的
                                break;
                            } else {// 判断是否不是相邻的
                                chessCode = bx[r1][c1] + chessCode;// 记录棋子相连的情况
                                break;
                            }
                        } else {// 判断是否是棋子
                            if (ch == 0) {// 判断是否是第一次出现棋子
                                chessCode = bx[r1][c1] + chessCode;// 记录棋子相连的情况
                                ch = bx[r1][c1];// 存储第一次的棋子
                            } else if (ch == bx[r1][c1]) {// 判断是否是一样颜色的棋子
                                chessCode = bx[r1][c1] + chessCode;// 记录棋子相连的情况
                            } else {
                                chessCode = bx[r1][c1] + chessCode;// 记录棋子相连的情况
                                break;
                            }
                        }
                    }
                    // 根据棋子相连的情况,获取HashMap中存储的权值
                    weight = map.get(chessCode);
                    if(null==weight){
                        System.out.println(" get one null.....");
                    }
                    else{
                        int a;
                        a=weight.intValue();
                        // 存储入到权值数组中
                        weightArray[r][c] += a;
                    }
                    ch = 0;// 重置到初始状态
                    chessCode = "0";// 重置到初始状态
                    /*
                     * 左斜向下 左上面的棋子在chessCode为左方, 右下面的棋子在chessCode为右方
                     */
                    for (int r1 = r + 1, c1 = c + 1; c1 <= 15 && r1 <= 15; c1++, r1++) {
                        if (bx[r1][c1] == 0) {// 判断是否是空位
                            if (c1 - 1 == c && r1 - 1 == c) {// 判断是否是相邻的
                                break;
                            } else {// 判断是否不是相邻的
                                chessCode = chessCode + bx[r1][c1];// 记录棋子相连的情况
                                break;
                            }
                        } else {// 判断是否是棋子
                            if (ch == 0) {// 判断是否是第一次出现棋子
                                chessCode = chessCode + bx[r1][c1];// 记录棋子相连的情况
                                ch = bx[r1][c1];// 存储第一次的棋子
                            } else if (ch == bx[r1][c1]) {// 判断是否是一样颜色的棋子
                                chessCode = chessCode + bx[r1][c1];// 记录棋子相连的情况
                            } else {
                                chessCode = chessCode + bx[r1][c1];// 记录棋子相连的情况
                                break;
                            }
                        }
                    }
                    /*
                     * 右斜向上 左下面的棋子在chessCode为左方, 右上面的棋子在chessCode为右方
                     */
                    for (int r1 = r - 1, c1 = c + 1; c1 <= 15 && r1 >= 0; c1++, r1--) // 行r,列c
                    {
                        if (bx[r1][c1] == 0) {// 判断是否是空位
                            if (c1 - 1 == c && r1 + 1 == c) {// 判断是否是相邻的
                                break;
                            } else {// 判断是否不是相邻的
                                chessCode = chessCode + bx[r1][c1];// 记录棋子相连的情况
                                break;
                            }
                        } else {// 判断是否是棋子
                            if (ch == 0) {// 判断是否是第一次出现棋子
                                chessCode = chessCode + bx[r1][c1];// 记录棋子相连的情况
                                ch = bx[r1][c1];// 存储第一次的棋子
                            } else if (ch == bx[r1][c1]) {// 判断是否是一样颜色的棋子
                                chessCode = chessCode + bx[r1][c1];// 记录棋子相连的情况
                            } else {
                                chessCode = chessCode + bx[r1][c1];// 记录棋子相连的情况
                                break;
                            }
                        }
                        weight = map.get(chessCode);
                        if(null==weight){
                            System.out.println(" get one null.....");
                        }
                        else{
                            int a;
                            a=weight.intValue();
                            // 存储入到权值数组中
                            weightArray[r][c] += a;
                        }
                        ch = 0;// 重置到初始状态
                        chessCode = "0";// 重置到初始状态
                    }
                    /*
                     * 右斜向下 左下面的棋子在chessCode为左方, 右上面的棋子在chessCode为右方
                     */
                    for (int r1 = r + 1, c1 = c - 1; c1 >= 0 && r1 <= 15; c1--, r1++) // 行r,列c
                    {
                        if (bx[r1][c1] == 0) {// 判断是否是空位
                            if (c1 + 1 == c && r1 - 1 == c) {// 判断是否是相邻的
                                break;
                            } else {// 判断是否不是相邻的
                                chessCode = bx[r1][c1] + chessCode;// 记录棋子相连的情况
                                break;
                            }
                        } else {// 判断是否是棋子
                            if (ch == 0) {// 判断是否是第一次出现棋子
                                chessCode = bx[r1][c1] + chessCode;// 记录棋子相连的情况
                                ch = bx[r1][c1];// 存储第一次的棋子
                            } else if (ch == bx[r1][c1]) {// 判断是否是一样颜色的棋子
                                chessCode = bx[r1][c1] + chessCode;// 记录棋子相连的情况
                            } else {
                                chessCode = bx[r1][c1] + chessCode;// 记录棋子相连的情况
                                break;
                            }
                        }
                    }
                    // 根据棋子相连的情况,获取HashMap中存储的权值
                    weight = map.get(chessCode);
                    if(null==weight){
                        System.out.println(" get one null.....");
                    }
                    else{
                        int a;
                        a=weight.intValue();
                        // 存储入到权值数组中
                        weightArray[r][c] += a;
                    }
                    ch = 0;// 重置到初始状态
                    chessCode = "0";// 重置到初始状态
                }
            }
        }
    }
    public void AIcount() {// 电脑统计应该下棋的坐标
        int max = -1;// 储存权值的最大值
        int rx = 0;// 储存最大值处的行坐标
        int cx = 0;// 储存最大值处的列坐标
        int k = 0;
        // 最大值的坐标为x1,y1
        for (int r = 0; r < weightArray.length; r++) {
            for (int c = 0; c < weightArray.length; c++) {
                if (weightArray[r][c] > max) {
                    System.out.println("weightArray=" + weightArray[r][c]);
                    max = weightArray[r][c];
                    rx = r;
                    cx = c;
                } else {
                    continue;
                }
            }
        }
        x1 = rx;
        y1 = cx;
        x2 = rx * SIZE - 25;
        y2 = cx * SIZE - 25;
    }
}
相关文章
|
2月前
|
存储 小程序 Java
热门小程序源码合集:微信抖音小程序源码支持PHP/Java/uni-app完整项目实践指南
小程序已成为企业获客与开发者创业的重要载体。本文详解PHP、Java、uni-app三大技术栈在电商、工具、服务类小程序中的源码应用,提供从开发到部署的全流程指南,并分享选型避坑与商业化落地策略,助力开发者高效构建稳定可扩展项目。
|
5月前
|
Java 开发者
【Java实例-英雄对战】Java战斗之旅,既分胜负也决生死
游戏规则:在“英雄对战”中,玩家和敌人轮流选择行动,目标是在对方生命值归零前将其击败。游戏开始时,玩家和敌人都有100生命值。每回合,玩家可以选择“攻击”,“追击”,“闪避反击”这三种行动之一。
68 0
|
9月前
|
存储 小程序 前端开发
微信小程序与Java后端实现微信授权登录功能
微信小程序极大地简化了登录注册流程。对于用户而言,仅仅需要点击授权按钮,便能够完成登录操作,无需经历繁琐的注册步骤以及输入账号密码等一系列复杂操作,这种便捷的登录方式极大地提升了用户的使用体验
2793 12
|
小程序 Java 关系型数据库
基于Java微信小程序同城家政服务系统设计和实现(源码+LW+调试文档+讲解等)
基于Java微信小程序同城家政服务系统设计和实现(源码+LW+调试文档+讲解等)
|
小程序 前端开发 算法
|
小程序 Java
小程序访问java后台失败解决方案
小程序访问java后台失败解决方案
131 2
|
小程序 JavaScript Java
小程序访问java后台
小程序访问java后台
110 1
|
小程序
java--微信小程序发送模板消息
java--微信小程序发送模板消息
520 0
|
小程序 前端开发 Java
java 生成小程序二维码
java 生成小程序二维码
227 0
|
小程序 Java
小程序通过get请求提交数据到java后台
小程序通过get请求提交数据到java后台
121 0