java五子棋AI

最新推荐文章于 2023-02-08 02:06:56 发布
最新推荐文章于 2023-02-08 02:06:56 发布
阅读量508 收藏 5
点赞数 2
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzq1326253299/article/details/81711057
版权

思路：
①五子棋界面的实现
②交互下棋的实现
③重绘
④AI，实现人机对战

五子棋和简单AI的实现：
首先将五子棋的界面写出来。
首先我们写一个接口类，定义好棋盘的数据（目的是方便修改）。

public interface Config {
    public static final int X0=50;//左上角起点X值
    public static final int Y0=50;//左上角起点Y值
    public static final int ROWS=15;//横向线数
    public static final int COLUMNS=15;//纵向线数
    public static final int CHESSSIZE=40;//棋子直径
    public static final int SIZE=50;//单元格大小
}

再来写五子棋的界面。写界面的方法和画图板是一样的。

public class FiveChessUI extends JFrame  implements Config {
    static FiveChessUI fcUI = new FiveChessUI();
    public static void main(String[] args){
        fcUI.initUI();
    }
    private int [][] chesses = new int[ROWS][COLUMNS];//创建一个二维数组用来标记棋盘上的位置

    /**
     * 初始化五子棋窗体的方法
     */
    public void initUI(){
        ChessListener listener = new ChessListener(chesses,fcUI);
        this.setTitle("五子棋v1.0");
        this.setSize(900, 800);//设置界面尺寸
        this.setResizable(false);//界面不可改变大小
        this.setLocationRelativeTo(null);//设置界面居中
        this.setDefaultCloseOperation(3);//设置退出进程
        BorderLayout bl = new BorderLayout();//设置界面布局为窗体式布局
        this.setLayout(bl);
        JPanel jp = new JPanel();
        jp.setPreferredSize(new Dimension(100,0));
        this.add(jp,BorderLayout.EAST);
        String [] name ={"重新开始","黑棋先下","白棋先下","悔棋","人机对战","人人对战"};
        for(int i=0;i<name.length;i++){//依次给按钮添加动作监听，这里用循环可减少代码
            JButton jbu = new JButton(name[i]);
            jbu.setPreferredSize(new Dimension(95,30));
            jp.add(jbu);
            jbu.addActionListener(listener);

        }

        this.setVisible(true);//设置可见
        listener.gr = this.getGraphics();
        this.addMouseListener(listener);//给界面加上鼠标监听



    }
    /**
     * 重写绘制窗体的方法
     */
    public void paint(Graphics g){
        super.paint(g);
        //在重绘的同时绘制棋盘
        drawChessTable(g);
        //在重绘的同时绘制棋子
        drawChess(g);
    }
    public void drawChess(Graphics g){
        ImageIcon bai = new ImageIcon("C:\\Users\\Administrator\\Pictures\\五子棋\\baizi.png");//添加白子图片
        ImageIcon hei = new ImageIcon("C:\\Users\\Administrator\\Pictures\\五子棋\\heizi.png");//添加黑子图片
        for(int i=0;i<chesses.length;i++){
            for(int j=0;j<chesses.length;j++){
                if(chesses[i][j]==1){
                    g.drawImage(hei.getImage(), X0 + SIZE * i - Config.CHESSSIZE / 2, Y0 + SIZE * j - Config.CHESSSIZE / 2, Config.CHESSSIZE,
                            Config.CHESSSIZE, null);
                }else if(chesses[i][j]==-1){
                    g.drawImage(bai.getImage(), X0 + SIZE * i - Config.CHESSSIZE / 2, Y0 + SIZE * j - Config.CHESSSIZE / 2, Config.CHESSSIZE,
                            Config.CHESSSIZE, null);
                }
            }
        }
    }
    public void drawChessTable(Graphics g){
        //添加背景图片
        ImageIcon img= new ImageIcon("C:\\Users\\Administrator\\Pictures\\chesstable.jpg");
        g.drawImage(img.getImage(), 0, 0, 800, 800,null);
        //画棋盘横线
        for(int i=0;i<ROWS;i++){
            g.drawLine(X0, Y0+i*SIZE, X0+(COLUMNS-1)*SIZE, Y0+i*SIZE);
        }
        //画棋盘竖线
        for(int j=0;j<Config.COLUMNS;j++){
            g.drawLine(X0+j*SIZE, Y0, X0+j*SIZE,Y0+(ROWS-1)*SIZE );
        }
    }

}

监听器类代码如下：

import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.HashMap;

import javax.swing.ImageIcon;
import javax.swing.JOptionPane;

public class ChessListener extends MouseAdapter implements Config, ActionListener {
    public Graphics gr;
    private int count = 0;// 计数器
    private int[][] chesses;// 创建一个二维数组用来存放棋子的坐标
    private String name;
    private int t, r;
    private int cl = 0, AI=2;
    private int i, j, x, y, z = 0, w = 0,zz=0,ww=0;
    private FiveChessUI fc;// 声明FiveChessUI类的一个对象
    private int setX[] = new int[ROWS * COLUMNS];// 创建一维数组setX[]
    private int setY[] = new int[ROWS * COLUMNS];// 创建一维数组setY[]
    private int[][] chessValue = new int[ROWS][COLUMNS];
    private int index = 0;// 创建数组的下标

    HashMap<String, Integer> hm = new HashMap<String, Integer>();//创建权值表

    public ChessListener(int[][] chesses, FiveChessUI fc) {
        this.fc = fc;
        this.chesses = chesses;
        //权值设置，这个需要自己慢慢调，小编写的一般，AI有时会出问题
        hm.put("1", 20);
        hm.put("11", 60);
        hm.put("111", 200);
        hm.put("1111", 1000);

        hm.put("-1", 20);
        hm.put("-1-1", 60);
        hm.put("-1-1-1", 200);
        hm.put("-1-1-1-1", 1000);

        hm.put("1-1", 20);
        hm.put("11-1", 30);
        hm.put("111-1", 80);
        hm.put("1111-1", 1000);

        hm.put("-11", 20);
        hm.put("-111", 30);
        hm.put("-1111", 80);
        hm.put("-11111", 1000);

        hm.put("1-1", 20);
        hm.put("-1-11", 30);
        hm.put("-1-1-11", 80);
        hm.put("-1-1-1-11", 1000);

        hm.put("1-1", 20);
        hm.put("1-1-1", 30);
        hm.put("1-1-1-1", 80);
        hm.put("1-1-1-1-1", 1000);


    }

    public void mouseReleased(MouseEvent e) {
        // 得到鼠标事件发生的时候光标的位置
        int x1 = e.getX();
        int y1 = e.getY();
        // 按行遍历棋盘，坐标（i,j）
        for (j = 0; j < ROWS; j++) {
            for (i = 0; i < ROWS; i++) {// 得到交叉点的坐标
                x = X0 + SIZE * i;// 横坐标
                y = Y0 + SIZE * j;// 纵坐标
                // 与圆心的误差为size/3
                if (x1 > x - SIZE * 5 / 12 && x1 < x + SIZE * 5 / 12 && y1 > y - SIZE * 5 / 12
                        && y1 < y + SIZE * 5 / 12) {
                    ImageIcon bai = new ImageIcon("C:\\Users\\Administrator\\Pictures\\baizi5.png");
                    ImageIcon hei = new ImageIcon("C:\\Users\\Administrator\\Pictures\\heizi4.png");
                    if (AI == 0) { // 人人对战
                        if (chesses[i][j] == 0) {// 如果选的位置没有棋子
                            if (count == 0) {
                                chesses[i][j] = 1;// 如果是黑子，就为1
                                count++;
                                gr.drawImage(hei.getImage(), X0 + SIZE * i - CHESSSIZE / 2,
                                        Y0 + SIZE * j - CHESSSIZE / 2, CHESSSIZE, CHESSSIZE, null);
                                cl = 0;
                            } else {
                                chesses[i][j] = -1;// 如果是白子就为-1
                                count--;
                                gr.drawImage(bai.getImage(), X0 + SIZE * i - CHESSSIZE / 2,
                                        Y0 + SIZE * j - CHESSSIZE / 2, CHESSSIZE, CHESSSIZE, null);
                                cl = 1;
                            }
                            setX[index] = i;// 将下的棋子的横坐标存入setX[]
                            setY[index] = j;// 将下的棋子的纵坐标存入setY[]
                            index++;// 存入一个坐标，一维数组角标加1
                            // 以交叉点画圆
                            checkRow(i, j);
                            z = 1;
                            w = 1;
                            return;
                        }
                    }
                    if (AI == 1) { // 人机对战

                        if (chesses[i][j] == 0) {// 如果选的位置没有棋子
                            if (count == 0) {
                                // 玩家下棋
                                chesses[i][j] = 1;// 如果是黑子，就为1
                                // count++;
                                gr.drawImage(hei.getImage(), X0 + SIZE * i - CHESSSIZE / 2,
                                        Y0 + SIZE * j - CHESSSIZE / 2, CHESSSIZE, CHESSSIZE, null);
                                cl = 0;
                                count++;
                                checkRow(i, j);//判断是否胜利
                                setX[index] = i;// 将下的棋子的横坐标存入setX[]
                                setY[index] = j;// 将下的棋子的纵坐标存入setY[]
                                index++;// 存入一个坐标，一维数组角标加1
                            }
                            this.AI();
                            if (count == 1) {
                                // 输出所有点的权值
                                for (int j = 0; j < chessValue.length; j++) {
                                    for (int i = 0; i < chessValue.length; i++) {
                                        System.out.print(chessValue[i][j] + " ");
                                    }
                                    System.out.println();
                                }
                                // 电脑下棋
                                // 筛选出chessValue最大值的交点坐标, 该坐标电脑下棋
                                for (int j = 0; j < chessValue.length; j++) {
                                    for (int i = 0; i < chessValue.length; i++) {
                                        if (chessValue[0][0] < chessValue[i][j]) {
                                            chessValue[0][0] = chessValue[i][j];
                                            t = i;
                                            r = j;
                                        }
                                    }
                                }
                                count--;
                                chesses[t][r] = -1;
                                gr.drawImage(bai.getImage(), X0 + SIZE * t - CHESSSIZE / 2,
                                        Y0 + SIZE * r - CHESSSIZE / 2, CHESSSIZE, CHESSSIZE, null);
                                cl = 1;
                                setX[index] = r;// 将下的棋子的横坐标存入setX[]
                                setY[index] = t;// 将下的棋子的纵坐标存入setY[]
                                index++;// 存入一个坐标，一维数组角标加1
                                checkRow(t, r);//判断是否胜利
                                zz = 1;//
                                ww = 1;
                                // 清空value
                                for (int i = 0; i < chessValue.length; i++) {
                                    for (int j = 0; j < chessValue.length; j++) {
                                        chessValue[i][j] = 0;
                                    }

                                }

                            }
                        }
                    }
                }
            }

        }

    }

    // 判断胜利的条件
    public int checkRow(int x, int y) {
        int count1 = 0, count2 = 0, count3 = 0, count4 = 0;// 定义4个棋子计数器，分别计数水平，竖直、斜向右下、斜向左下

        for (int i = x + 1; i < chesses.length; i++) {
            if (chesses[i][y] == chesses[x][y]) {
                count1++;

            } else
                break;
        }
        for (int i = x; i >= 0; i--) {
            if (chesses[i][y] == chesses[x][y]) {
                count1++;
            } else
                break;
        }
        for (int j = y + 1; j < chesses.length; j++) {
            if (chesses[x][j] == chesses[x][y]) {
                count2++;
            } else
                break;
        }
        for (int j = y; j >= 0; j--) {
            if (chesses[x][y] == chesses[x][j]) {
                count2++;
            } else
                break;
        }
        for (int i = x + 1, j = y + 1; i < chesses.length && j < chesses.length; i++, j++) {
            if (chesses[i][j] == chesses[x][y]) {
                count3++;
            } else
                break;

        }
        for (int i = x, j = y; i >= 0 && j >= 0; i--, j--) {
            if (chesses[i][j] == chesses[x][y]) {
                count3++;
            } else
                break;

        }
        for (int i = x, j = y; i < chesses.length && j >= 0; i++, j--) {
            if (chesses[i][j] == chesses[x][y]) {

                count4++;
            } else
                break;

        }
        for (int i = x - 1, j = y + 1; i >= 0 && j < chesses.length; i--, j++) {
            if (chesses[i][j] == chesses[x][y]) {
                count4++;
            } else
                break;

        }
        if (count1 >= 5 || count2 >= 5 || count3 >= 5 || count4 >= 5) {

            count = 0;
            if (cl == 0) {
                JOptionPane.showMessageDialog(null, "黑棋赢！");
                for (int i = 0; i < chesses.length; i++) {
                    for (int j = 0; j < chesses.length; j++) {
                        chesses[i][j] = 0;

                    }
                }
                fc.repaint();

            }
            if (cl == 1) {
                JOptionPane.showMessageDialog(null, "白棋赢！");
                for (int i = 0; i < chesses.length; i++) {
                    for (int j = 0; j < chesses.length; j++) {
                        chesses[i][j] = 0;
                    }
                }
                fc.repaint();
            }
        }
        return count;

    }

    public void actionPerformed(ActionEvent e) {
        name = e.getActionCommand();

        if ("重新开始".equals(name)) {
            count = 0;
            z = 0;
            w = 0;
            for (int i = 0; i < chesses.length; i++) {
                for (int j = 0; j < chesses.length; j++) {
                    chesses[i][j] = 0;
                }
            }

            fc.repaint();
        }
        if ("白棋先下".equals(name)) {
            if (z == 0) {
                count = 1;
                z = 1;
            }
        }
        if ("黑棋先下".equals(name)) {
            if (w == 0) {
                count = 0;
                w = 1;
            }
        }
        if ("悔棋".equals(name)) {
            this.huiqi();
        }
        if ("人机对战".equals(name)) {
            if(w==0){
            AI = 1;
            ww=1;
            }

        }
        if ("人人对战".equals(name)) {
            if(z==0){
            AI = 0;
            }
        }
    }

    public void huiqi() {
        if (index >= 0) {
            index--;
            if (index < 0) {
                index = 0;
            }
            x = setX[index];
            y = setY[index];

            if (chesses[x][y] == 1) {
                chesses[x][y] = 0;
                count = 0;
            }
            if (chesses[x][y] == -1) {
                chesses[x][y] = 0;
                count = 1;

            }
            if(chesses[t][r]==-1){
                chesses[t][r]=0;
                count=1;
            }
            fc.repaint();
        }
    }

    public void AI() {
        for (int i = 0; i < chesses.length; i++) {
            for (int j = 0; j < chesses.length; j++) {
                if (chesses[i][j] == 0) {// 判断当前位置是否有棋子
                    // 定义两个变量分别保存棋局，颜色
                    String code = "";
                    int color = 0;
                    // 向右
                    for (int k = i + 1; k < chesses.length; k++) {
                        if (chesses[k][j] == 0) {
                            break;
                        } else {
                            if (color == 0) {// 右边第一颗棋子
                                color = chesses[k][j];// 保存颜色
                                code += chesses[k][j];// 保存棋局
                            } else if (chesses[k][j] == color) {// 右边第二，第三同颜色棋子
                                code += chesses[k][j];// 保存棋局
                            } else { // 右边不同颜色
                                code += chesses[k][j];
                                break;
                            }
                        }
                    }
                    // 根据code取出hm对应的权值
                    Integer value = hm.get(code);
                    if (value != null) {
                        chessValue[i][j] += value;
                    }
                    // 向左方向
                    code = "";
                    color = 0;
                    for (int k = i - 1; k >= 0; k--) {
                        if (chesses[k][j] == 0) {
                            break;
                        } else {
                            if (color == 0) {// 右边第一颗棋子
                                color = chesses[k][j];// 保存颜色
                                code += chesses[k][j];// 保存棋局
                            } else if (chesses[k][j] == color) {// 右边第二，第三同颜色棋子
                                code += chesses[k][j];// 保存棋局
                            } else { // 右边不同颜色
                                code += chesses[k][j];
                                break;
                            }
                        }
                    }
                    // 根据code取出hm对应的权值
                    Integer value2 = hm.get(code);
                    if (value2 != null) {
                        chessValue[i][j] += value2;
                    }
                    // 向上方向
                    code = "";
                    color = 0;
                    for (int k = j - 1; k >= 0; k--) {
                        if (chesses[i][k] == 0) {
                            break;
                        } else {
                            if (color == 0) {// 右边第一颗棋子
                                color = chesses[i][k];// 保存颜色
                                code += chesses[i][k];// 保存棋局
                            } else if (chesses[i][k] == color) {// 右边第二，第三同颜色棋子
                                code += chesses[i][k];// 保存棋局
                            } else { // 右边不同颜色
                                code += chesses[i][k];
                                break;
                            }
                        }
                    }
                    // 根据code取出hm对应的权值
                    Integer value3 = hm.get(code);
                    if (value3 != null) {
                        chessValue[i][j] += value3;
                    }
                    // 向下方向
                    code = "";
                    color = 0;
                    for (int k = j + 1; k < chesses.length; k++) {
                        if (chesses[i][k] == 0) {
                            break;
                        } else {
                            if (color == 0) {// 右边第一颗棋子
                                color = chesses[i][k];// 保存颜色
                                code += chesses[i][k];// 保存棋局
                            } else if (chesses[i][k] == color) {// 右边第二，第三同颜色棋子
                                code += chesses[i][k];// 保存棋局
                            } else { // 右边不同颜色
                                code += chesses[i][k];
                                break;
                            }
                        }
                    }
                    // 根据code取出hm对应的权值
                    Integer value4 = hm.get(code);
                    if (value4 != null) {
                        chessValue[i][j] += value4;
                    }

                    // 右上方向
                    code = "";
                    color = 0;
                    for (int k = j + 1, l = i - 1; l >= 0 && k < chesses.length; l--, k++) {
                        if (chesses[l][k] == 0) {
                            break;
                        } else {
                            if (color == 0) {// 右边第一颗棋子
                                color = chesses[l][k];// 保存颜色
                                code += chesses[l][k];// 保存棋局
                            } else if (chesses[l][k] == color) {// 右边第二，第三同颜色棋子
                                code += chesses[l][k];// 保存棋局
                            } else { // 右边不同颜色
                                code += chesses[l][k];
                                break;
                            }
                        }
                    }
                    // 根据code取出hm对应的权值
                    Integer value6 = hm.get(code);
                    if (value6 != null) {
                        chessValue[i][j] += value6;
                    }
                    // 左下方向
                    code = "";
                    color = 0;
                    for (int k = i + 1, l = j - 1; l >= 0 && k < chesses.length; k++, l--) {
                        if (chesses[k][l] == 0) {
                            break;
                        } else {
                            if (color == 0) {// 右边第一颗棋子
                                color = chesses[k][l];// 保存颜色
                                code += chesses[k][l];// 保存棋局
                            } else if (chesses[k][l] == color) {// 右边第二，第三同颜色棋子
                                code += chesses[k][l];// 保存棋局
                            } else { // 右边不同颜色
                                code += chesses[k][l];
                                break;
                            }
                        }
                    }
                    // 根据code取出hm对应的权值
                    Integer value7 = hm.get(code);
                    if (value7 != null) {
                        chessValue[i][j] += value7;
                    }
                    // 右下方向
                    code = "";
                    color = 0;
                    for (int k = i - 1, l = j - 1; l >= 0 && k >= 0; l--, k--) {
                        if (chesses[k][l] == 0) {
                            break;
                        } else {
                            if (color == 0) {// 右边第一颗棋子
                                color = chesses[k][l];// 保存颜色
                                code += chesses[k][l];// 保存棋局
                            } else if (chesses[k][l] == color) {// 右边第二，第三同颜色棋子
                                code += chesses[k][l];// 保存棋局
                            } else { // 右边不同颜色
                                code += chesses[k][l];
                                break;
                            }
                        }
                    }
                    // 根据code取出hm对应的权值
                    Integer value8 = hm.get(code);
                    if (value8 != null) {
                        chessValue[i][j] += value8;
                    }
                    // 左上方向
                    code = "";
                    color = 0;
                    for (int k = i + 1, l = j + 1; k < chesses.length && l < chesses.length; l++, k++) {
                        if (chesses[k][l] == 0) {
                            break;
                        } else {
                            if (color == 0) {// 右边第一颗棋子
                                color = chesses[k][l];// 保存颜色
                                code += chesses[k][l];// 保存棋局
                            } else if (chesses[k][l] == color) {// 右边第二，第三同颜色棋子
                                code += chesses[k][l];// 保存棋局
                            } else { // 右边不同颜色
                                code += chesses[k][l];
                                break;
                            }
                        }
                    }
                    // 根据code取出hm对应的权值
                    Integer value5 = hm.get(code);
                    if (value5 != null) {
                        chessValue[i][j] += value5;
                    }
                }
            }
        }
    }
}
凌晨两点半的太阳v
关注
专栏目录
JAVA五子棋AI（人机对战 颜色选择 悔棋等 可直接使用）
xinghuowuyin的博客
02-21 6809
用 JAVA 语言编写五子棋 AI 小游戏是一件非常有意思的事：下五子棋首先需要一个棋盘，国际标准是 15×15 路线，为了增加趣味性，我们在编写程序时可以使用不同线路的棋盘。用户在开始游戏前可进行相关选择，如：模式选择（人人对战、人机对战），颜色选择（用户要黑棋、用户要白棋），下棋顺序（黑棋先行、白棋先行），并且设置有“开始游戏”、“重新开始”、“认输结束”、“悔棋”等按钮。开始游戏后，用户在棋盘上点击相应的位置就可以下棋子。
java实现AI五子棋
LIAO_7053的博客
07-16 2637
       这是学习Java以来自己设计的第一款小游戏，虽然整体设计有点粗糙，电脑智能也比较低，不过也能满足基本需求，心里还是有点小激动。至于更高深的算法及其他功能的实现只能等以后再实现了。好了，闲话少述，咱们直奔主题吧！ 先上一张效果图： 一、五子棋设计要求：      1、设计一个能够实现双人对战及人机对战的五子棋游戏；      2、游戏可实现悔棋及认输等基本操作；     ...
五子棋AI JAVA
03-14
使用JAVA完成的五子棋游戏，Swing做成的界面，人机对弈
AI算法实现五子棋（java）
08-26
主要为大家详细介绍了AI算法实现五子棋，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
java 五子棋AI
他山之石 可以攻玉
04-14 286
package wuziqAI; //import jdk.nashorn.internal.scripts.JO; import javax.imageio.ImageIO; import javax.swing.*; import java.awt.*; import java.awt.event.MouseEvent; import java.awt.event.MouseListener; import java.awt.image.BufferedImage; import java.io.Fi.
Java五子棋(含简单AI)
01-23
原来想用博弈树 α-β剪枝法实现人工智能AI，试了2天没测试出来，但代码里有测试的demo已经测试通过，就跟五子棋还没结合起来，网上Java版的博弈树 α-β剪枝法我找不到，虽然最终没有完成，但对于这个算法本身我已经大概知道怎会事儿，算是学习了吧，日后有时间再回来继续完善。
Java实现五子棋AI算法
08-27
主要为大家详细介绍了Java实现五子棋AI算法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
JAVA五子棋AI对战版
01-23
【JAVA五子棋AI对战版】是一款基于Java编程语言开发的棋类游戏，它集成了人工智能算法，使得玩家可以与计算机进行智能对弈。在这款游戏中，AI（Artificial Intelligence）扮演着对手的角色，通过复杂的算法来模拟...
java五子棋人工智能
11-03
Java五子棋人工智能是一种利用编程技术来模拟人类智慧进行游戏对弈的应用。在这个项目中，开发者使用了Java语言实现了一个五子棋游戏，并且引入了人工智能的剪枝算法来提高计算机玩家的游戏水平。下面我们将详细探讨...
Java五子棋AI实现代码
08-26
标题《Java五子棋AI实现代码》指出本文主要讲述如何使用Java编程语言实现五子棋游戏，并集成人工智能（AI）算法，使玩家能与计算机进行对弈。五子棋是一种两人对弈的纯策略型棋类游戏，规则简单，但变化复杂，有着...
Java版AI五子棋
smile的博客
04-03 4606
去年暑假写的，没什么经验，代码写的那个乱啊！！！ AI思路：通过判断棋盘上每个空位的分数，去分数最高的几个点，随机下棋 分数计算思路：能成5个说明能赢了，给最高分 不能成5个，对方能成5个，说明对方要赢了，给第二高分 能成活4，给第三高分 能成活3，给第四高分 能成冲4，给第五高分 能成冲3，给第六高分 能成活2，给第七高分 能成冲2，给第八高分 其他，给最低分 分数
用Java实现简单的AI五子棋对弈
Cavendish_key的博客
08-09 722
很基础的实现AI对弈
java五子棋单机版（附带简单的AI实现）
07-21
java写的单机版五子棋AI版，源码在jar文件内～
Java 五子棋AI博弈树算法实现
weixin_54586460的博客
05-05 3962
实际上现在的棋类AI都是采用了效率更高的算法（如蒙特卡洛树搜索）+Deep Learning实现。今天我们只探讨较简单的五子棋AI，大致有两种算法：五元组和博弈树。 Java学习笔记 第一节 Java 类与对象以及继承 第二节 Java 对象的保存和传递 第三节 Java 数组和列表的使用 第四节 Java 五子棋AI博弈树算法 目录Java学习笔记前言一、HashMap的使用二、获取落子状态三、构建权值表并获取分数四、AI遍历与递归总结 前言 五子棋UI界面设计和博弈树的概念在这里不做介.
java毕业设计——基于Java+AI的五子棋游戏设计与实现（毕业论文+程序源码）——五子棋游戏
m0_66238867的博客
09-26 8001
五子棋作为一个棋类竞技运动，在民间十分流行，为了熟悉五子棋规则及技巧，以及研究简单的人工智能，决定用Java开发五子棋游戏。主要完成了人机对战和玩家之间联网对战2个功能。网络连接部分为Socket编程应用，客户端和服务器端的交互用Class Message定义，有很好的可扩展性，客户端负责界面维护和收集用户输入的信息，及错误处理。服务器维护在线用户的基本信息和任意两个对战用户的棋盘信息，动态维护用户列表。在人机对弈中通过深度搜索和估值模块，来提高电脑棋手的智能。
JAVA五子棋游戏（简单人工智能算法）
03-05
JAVA做的一个简单的五子棋游戏！涉及一些简单的人工智能算法！
java 五子棋中的AI技术
02-08 1758
java 五子棋中的AI技术package ball;import java.awt.*;import javax.swing.*;import javax.swing.table.*;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.Dimension;import
java五子棋 源代码_用JAVA做五子棋源代码
weixin_42499681的博客
02-12 654
展开全部java网络五子棋下面的源代码分为4个文件；chessClient.java:客户端主程序。chessInterface.java:客户端的界面。chessPad.java:棋盘的绘62616964757a686964616fe4b893e5b19e31333231376365制。chessServer.java:服务器端。可同时容纳50个人同时在线下棋，聊天。没有加上详细注释，不过绝对可...
JAVA项目-AI五子棋
最新发布
lwxklts的博客
02-08 338
简单来说，这个项目由两大部分组成，第一部分是界面设置，第二部分是功能实现。
Java学习笔记(七)：五子棋AI算法
菜????一只
02-08 1847
参考博客：https://www.cnblogs.com/songdechiu/p/5768999.html 一、五子棋棋型分析 参考：http://game.onegreen.net/wzq/HTML/142336.html 最常见的基本棋型大体有以下几种：连五，活四，冲四，活三，眠三，活二，眠二。 ①连五：顾名思义，五颗同色棋子连在一起，不需要多讲。 ②活四：有两个连五点（即有两个点可以形成...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值