五子棋制作(具备基础功能:下棋与悔棋)

最新推荐文章于 2024-08-03 21:02:21 发布
最新推荐文章于 2024-08-03 21:02:21 发布
阅读量112 收藏
点赞数
文章标签： java 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LZ2587246324/article/details/132275683
版权 
代码全览
图1：Interface     图2：GoListener     图3：Chess
import javax.swing.*;
import java.awt.*;
import java.awt.event.MouseEvent;

public class Interface extends JFrame{
    GoListener gol=new GoListener();
    double Xd=gol.Xd,Yd=gol.Yd,SIZEd=gol.SIZEd,Rowd=gol.Rowd,Cold=gol.Cold,xbtnPaneld =gol.xbtnPaneld;
    int X=(int)Xd,Y=(int)Yd,SIZE=(int)SIZEd,ROW=(int)Rowd,COL=(int)Cold,xbtnPanel=(int)xbtnPaneld;

    double JFwidthd=900,JFheightd=730;
    int JFwidth=(int)JFwidthd,JFheight=(int)JFheightd;

    public void showUI() {
        setTitle("AI五子棋");
        setSize(JFwidth, JFheight);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
        setLayout(null);

        JButton startOverBT = new JButton("开始游戏");
        startOverBT.setBounds ( xbtnPanel/4+SIZE*(COL-1)+SIZE,xbtnPanel/4,xbtnPanel/2,xbtnPanel/4);
        JButton Undo = new JButton("悔      棋");
        Undo.setBounds (xbtnPanel/4+SIZE*(COL-1)+SIZE,xbtnPanel/4+xbtnPanel/2,xbtnPanel/2,xbtnPanel/4);

        add(startOverBT);
        add(Undo);

        setVisible(true);

// 添加鼠标监听器
        addMouseListener(gol);
//按钮添加动作监听器
        startOverBT.addActionListener (gol);
        Undo.addActionListener (gol);
        Graphics g = getGraphics ();
// 初始化Graphics - 画笔
// 将面板上的画笔对象 的地址复制一份给 监听器对象中的画笔对象变量名
        gol.g = g;
    }

    public void paint(Graphics g){
        super.paint(g);
        gol.repaint1(g);
    }

    public static void main(String[] args) {
        Interface goUI = new Interface();
        goUI.showUI();
    }
}
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseListener;
import java.awt.*;
import java.awt.event.MouseEvent;

public class GoListener implements MouseListener, ActionListener{

    // 棋盘参数：
    double Xd=50,Yd=70,SIZEd=40,Rowd=16,Cold=Rowd,xbtnPaneld =200;
    int X=(int)Xd,Y=(int)Yd,SIZE=(int)SIZEd,ROW=(int)Rowd,COL=(int)Cold,xbtnPanel=(int)xbtnPaneld;
    int halfSize=SIZE/2;
    Color bgcolor = new Color(0, 255, 216);
    Graphics g;
    int boolChessFlag=0,chessFlag=1,chessFlagInMouseEntered=0;// 0不能下棋 1黑棋 2白棋
    int[][] chessPiecesLocat=new int[COL][ROW];//chessPiecesLocat[列][有几列]
    Chess[] Chess1=new Chess[ROW*COL];
    int Chess1Index=0;

    public void paint(Graphics g,int chessflag,int x,int y){ //画棋子
        if(chessflag==1){
            int blackChange=200;//调黑棋渐变程度0(全黑)-blackChange
            for(int i = 0; i < blackChange; i++){
                Color colo5 = new Color (i,i,i);
                g.setColor (colo5);
                double di3=SIZEd/blackChange*i/2;
                double di2=SIZEd-SIZEd/blackChange*i;
                int i3=(int)di3;
                int i2=(int)di2;
                g.fillOval (x+i3, y+i3, i2, i2);
            }
        }else if (chessflag==2){
            int whiteChange=160;//调白棋渐变程度whiteChange-255(全白)
            int whiteRange=256-whiteChange;
            for(int i =0; i < whiteRange; i++){
                int colorSet=whiteChange+i;
                Color colo5 = new Color (colorSet,colorSet,colorSet);
                g.setColor (colo5);
                double di3=SIZEd/whiteRange*i/2;
                double di2=SIZEd-SIZEd/whiteRange*i;
                int i3=(int)di3;
                int i2=(int)di2;
                g.fillOval (x+i3, y+i3, i2, i2);
            }
        }
    }

    public int judgeHorizontal(int[][]a,int x,int y){
        int count = 0;// 连子数记录变量
// 向右边查找
        int c1 = a[x][y];
        for(int i = x + 1; i < a.length; i++){
// 右边取出的棋子
            int cn = a[i][y];
// 与c1进行比较
            if(c1 == cn){
                count++;
            } else{
//如果找到一颗棋子 不同于c1 要么是 0
                break;// 跳出循环
            }
        }
        //System.out.println ("向右边查找连子数为:" + count);
// 向左边查找 行不变 列减
// 包含当前棋子本身
        count++;
        for(int i = x - 1; i>=0; i--){
// 右边取出的棋子
            int cn = a[i][y];
// 与c1进行比较
            if(c1 == cn){
                count++;
            } else{
//如果找到一颗棋子 不同于c1 要么是 0
                break;// 跳出循环
            }
        }
        //System.out.println ("横向查找的连子数：" + count);
        return count;
    }
    public int judgeVertical(int[][]a,int x,int y){
        int count = 0;// 连子数记录变量
// 向上边查找
        int c1 = a[x][y];
        for(int i = y - 1; i >=0; i--){
            int cn = a[x][i];
            if(c1 == cn){
                count++;
            } else{
                break;
            }
        }
        //System.out.println ("向上边查找连子数为:" + count);
        count++;
// 向下边查找
        for(int i = y + 1; i<a[x].length; i++){
            int cn = a[x][i];
            if(c1 == cn){
                count++;
            } else{
                break;
            }
        }
        //System.out.println ("纵向查找的连子数：" + count);
        return count;
    }
    public int judgeIncline1(int[][]a,int x,int y){ //左上-右下
        int count = 0;// 连子数记录变量
// 向左上边查找
        int c1 = a[x][y];
        int j=y;
        for(int i = x - 1; i >=0; i--){
            if(j>0){
                j--;
            }else{break;}
            int cn = a[i][j];
            if(c1 == cn){
                count++;
            } else{
                break;
            }
        }
        //System.out.println ("向左上边查找连子数为:" + count);
        count++;
// 向右下边查找
        j=y;
        for(int i = x + 1; i<a.length; i++){
            if(j<a[x].length-1){
                j++;
            }else{break;}
            int cn = a[i][j];
            if(c1 == cn){
                count++;
            } else{
                break;
            }
        }
        //System.out.println ("左上-右下查找的连子数：" + count);
        return count;
    }
    public int judgeIncline2(int[][]a,int x,int y){ //右上-左下
        int count = 0;// 连子数记录变量
// 向右上边查找
        int c1 = a[x][y];
        int j=y;
        for(int i = x + 1; i<a.length; i++){
            if(j>0){
                j--;
            }else{break;}
            int cn = a[i][j];
            if(c1 == cn){
                count++;
            } else{
                break;
            }
        }
        //System.out.println ("向右上边查找连子数为:" + count);
        count++;
// 向左下边查找
        j=y;
        for(int i = x - 1; i>=0; i--){
            if(j<a[x].length-1){
                j++;
            }else{break;}
            int cn = a[i][j];
            if(c1 == cn){
                count++;
            } else{
                break;
            }
        }
        //System.out.println ("右上-左下查找的连子数：" + count);
        return count;
    }
    public boolean judge(int[][]a,int x,int y){
        int a1,b,c,d;
        a1=judgeHorizontal(a,x,y);
        b=judgeVertical(a,x,y);
        c=judgeIncline1(a,x,y);
        d=judgeIncline2(a,x,y);
        if(a1>=5 || b>=5 || c>=5 || d>=5){
            return true;
        }else{return false;}
    }

    public void actionPerformed(ActionEvent e){
        System.out.println ("按钮被点击了");
// 获取按钮的文本
        String btnStr = e.getActionCommand ();
// 获取按钮的对象
        JButton btn = (JButton) e.getSource ();
        if(btnStr.equals ("开始游戏")){
            boolChessFlag=1;// 设置标识 为 黑棋先下
// 点击开始游戏按钮之后 将文本替换成 结束游戏
            btn.setText ("结束游戏");
            //System.out.println("chessFlag"+chessFlag);
        }else if(btnStr.equals ("结束游戏")){
            boolChessFlag=0;// 设置标识 不能下棋
// 点击结束游戏按钮 替换成开始游戏
            btn.setText ("开始游戏");
            //System.out.println("chessFlag"+chessFlag);
        } else if (btnStr.equals ("悔      棋")) {
            if(Chess1Index<=0){
                JOptionPane.showMessageDialog (null,"没有棋子可悔了");
            }else if(Chess1Index>0){
                Chess Chess2=Chess1[Chess1Index-1];
                chessPiecesLocat[Chess2.x][Chess2.y]=0;
                Chess1[Chess1Index-1]=null;
                Chess1Index--;
                if(chessFlag == 1){
                    chessFlag = 2;
                } else if(chessFlag == 2){
                    chessFlag = 1;
                }
                repaint1(g);
            }
        }
    }

        public void repaint1(Graphics g){ //在Interface中需调整棋盘位置重新写repaint为repaint1重画棋盘
            System.out.println("repaint1绘制");
    //在Interface中需调整棋盘的位置，加上 上方边框 左边按钮面板的宽
            int Xboard=X;
            int Yboard=Y;
            g.setColor (bgcolor);
            g.fillRect(Xboard-SIZE/2, Yboard-SIZE/2, SIZE*(ROW-1)+SIZE,SIZE*(COL-1)+SIZE);
    // 绘制棋盘
            g.setColor (Color.black);
            for(int i = 0; i <ROW; i++){
                g.drawLine (Xboard, Yboard+i*SIZE, Xboard + (COL-1)* SIZE, Yboard+i*SIZE);
                g.drawLine (Xboard+i*SIZE,Yboard,Xboard+i*SIZE,Yboard+(ROW-1)*SIZE);
            }
            g.setColor (Color.red);
            g.drawRect (Xboard-halfSize,Yboard-halfSize,SIZE*(COL-1)+SIZE,SIZE*(ROW-1)+SIZE);
    //画棋子
            for(int i=0;i<chessPiecesLocat.length;i++){
                for(int j=0;j<chessPiecesLocat[i].length;j++){
                    if(chessPiecesLocat[i][j]==0){
                        continue;
                    } else if (chessPiecesLocat[i][j]==1) {
                        chessFlagInMouseEntered=1;
                    } else if (chessPiecesLocat[i][j]==2) {
                        chessFlagInMouseEntered=2;
                    }
                    double x1=i*SIZEd+Xd-SIZEd/2;
                    double y1=j*SIZEd+Yd-SIZEd/2;
                    int xshow=(int)x1;
                    int yshow=(int)y1;
                    paint(g,chessFlagInMouseEntered,xshow,yshow);
                }
            }
        }

    @Override
    public void mousePressed(MouseEvent e){
        if(boolChessFlag==0){
// 弹窗
            JOptionPane.showMessageDialog (null,"游戏未开始");
            return;// 结束方法
        }
        System.out.println ("鼠标按下事件");
// 获取坐标
        int x = e.getX ();
        int y = e.getY ();
        //System.out.println("获取坐标--x:"+x+",y:"+y);
        double xd=x,yd=y;
        double x2=(xd-Xd+SIZEd/2)/SIZEd;
        double y2=(yd-Yd+SIZEd/2)/SIZEd;
        int x3=(int)x2;
        int y3=(int)y2;
        System.out.println("x3:"+x3+",y3:"+y3);
        if(x2<0 || x3>COL-1 || y2<0 || y3>ROW-1){
            return;
        }
        double x1=x3*SIZEd+Xd-SIZEd/2;
        double y1=y3*SIZEd+Yd-SIZEd/2;
        int xshow=(int)x1;
        int yshow=(int)y1;

        if(chessPiecesLocat[x3][y3]!=0){
            //JOptionPane.showMessageDialog (null,"该位置已有棋子");
            System.out.println("该位置已有棋子");
            return;
        }
        chessPiecesLocat[x3][y3]=chessFlag;
        Chess chess=new Chess();
        chess.x=x3;
        chess.y=y3;
        chess.chessFlag=chessFlag;
        Chess1[Chess1Index]=chess;
        Chess1Index++;


//绘制 外切矩形的左上角坐标 宽度 高度
        paint(g,chessFlag,xshow,yshow);
        if(judge(chessPiecesLocat,x3,y3)){
            if(chessFlag==1){JOptionPane.showMessageDialog (null,"游戏结束,黑方胜利！");}
            if(chessFlag==2){JOptionPane.showMessageDialog (null,"游戏结束,白方胜利！");}
            int[][]newChessPiecesArray=new int[COL][ROW];
            chessPiecesLocat=newChessPiecesArray;
            chessFlag=1;
            Chess1Index=0;
            repaint1(g);
            return;
        }
// 将散坐标 转成 标准坐标
// 将58 转成 0 转成 50
        if(chessFlag == 1){
            chessFlag = 2;
        } else if(chessFlag == 2){
            chessFlag = 1;
        }
    }
    @Override
    public void mouseClicked(MouseEvent e){}
    @Override
    public void mouseReleased(MouseEvent e){}
    @Override
    public void mouseEntered(MouseEvent e){}
    @Override
    public void mouseExited(MouseEvent e){}
}

public class Chess {
    int x;
    int y;
    int chessFlag;
}

讲解

首先创建一个界面类Interface作为五子棋界面类(图1)
public class Interface extends JFrame继承JFrame使Interface拥有JFrame的方法，方便之后重写绘制底板的方法

在Interface中设置基本参数，边距X ,Y; 棋子大小/棋盘格子大小SIZE; 绘制棋盘纵向线数COL，横向线数ROW；以及按钮面板宽度xbtnPanel。这里为了方便修改数据直接在Golistener中设置，而界面类中调用数据即可，在后面会看到具体数据为

Xd=50,Yd=70,SIZEd=40,Rowd=16,Cold=Rowd,xbtnPaneld =200;

转换int和double为后期计算需要，可按自己的需要进行转换。

创建变量JFwidth=900，JFheight=730用来设置整个JFrame界面大小。

    GoListener gol=new GoListener();
    double Xd=gol.Xd,Yd=gol.Yd,SIZEd=gol.SIZEd,Rowd=gol.Rowd,Cold=gol.Cold,xbtnPaneld =gol.xbtnPaneld;
    int X=(int)Xd,Y=(int)Yd,SIZE=(int)SIZEd,ROW=(int)Rowd,COL=(int)Cold,xbtnPanel=(int)xbtnPaneld;

    double JFwidthd=900,JFheightd=730;
    int JFwidth=(int)JFwidthd,JFheight=(int)JFheightd;

创建showUI方法，设置界面标题，大小，关闭选项，位置和排列布局(showUI中的前5行)

接下去的4行设置了游戏开始和悔棋按钮位置和大小

之后添加鼠标监听器，按钮添加动作监听器，将面板上的画笔对象 的地址复制一份给监听器对象中的画笔对象变量名

其中GoListener为我们另外创建的监听器类(图2)

    public void showUI() {
        setTitle("AI五子棋");
        setSize(JFwidth, JFheight);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
        setLayout(null);

        JButton startOverBT = new JButton("开始游戏");
        startOverBT.setBounds ( xbtnPanel/4+SIZE*(COL-1)+SIZE,xbtnPanel/4,xbtnPanel/2,xbtnPanel/4);
        JButton Undo = new JButton("悔      棋");
        Undo.setBounds (xbtnPanel/4+SIZE*(COL-1)+SIZE,xbtnPanel/4+xbtnPanel/2,xbtnPanel/2,xbtnPanel/4);

        add(startOverBT);
        add(Undo);

        setVisible(true);

// 添加鼠标监听器
        addMouseListener(gol);
//按钮添加动作监听器
        startOverBT.addActionListener (gol);
        Undo.addActionListener (gol);
        Graphics g = getGraphics ();
// 初始化Graphics - 画笔
// 将面板上的画笔对象 的地址复制一份给 监听器对象中的画笔对象变量名
        gol.g = g;
    }

再创建main方法显示窗口界面

    public static void main(String[] args) {
        Interface goUI = new Interface();
        goUI.showUI();
    }

重写JFrame中paint方法，这样改变窗体大小时棋盘和棋子就不会消失，其中用到了GoListener中的方法在下面会讲到

    public void paint(Graphics g){
        super.paint(g);
        gol.repaint1(g);
    }

创建GoListener类调用接口MouseListener来检测按钮点击情况，ActionListener用来检测棋盘点击情况。设置基本变量的值。bgcolor是棋盘的背景颜色，创建Graphics g实现画笔功能boolChessFlag=0,chessFlag=1,chessFlagInMouseEntered=0; 二维数组int[][]用来存储棋子位置以达到还原棋子目的，Chess为我们之后建的棋子类，用来存储下棋时每颗棋的位置和顺序：

public class Chess {
    int x;
    int y;
    int chessFlag;
}

ChessIndex

public class GoListener implements MouseListener, ActionListener{
    // 棋盘参数：
    double Xd=50,Yd=70,SIZEd=40,Rowd=16,Cold=Rowd,xbtnPaneld =200;
    int X=(int)Xd,Y=(int)Yd,SIZE=(int)SIZEd,ROW=(int)Rowd,COL=(int)Cold,xbtnPanel=(int)xbtnPaneld;
    int halfSize=SIZE/2;
    Color bgcolor = new Color(0, 255, 216);
    Graphics g;
    int boolChessFlag=0,chessFlag=1,chessFlagInMouseEntered=0;// 0不能下棋 1黑棋 2白棋
    int[][] chessPiecesLocat=new int[COL][ROW];//chessPiecesLocat[列][有几列]
    Chess[] Chess1=new Chess[ROW*COL];
    int Chess1Index=0;
}

因为我们调用了两个接口，必须重写其中所有方法

    public void actionPerformed(ActionEvent e){};
    public void mouseClicked(MouseEvent e){};
    public void mousePressed(MouseEvent e){};
    public void mouseReleased(MouseEvent e){};
    public void mouseEntered(MouseEvent e){};
    public void mouseExited(MouseEvent e){};

而我们只想改变actionPerformed和mousePressed(下面会讲)方法，所以其他方法保留原样即可

actionPerformed方法可检测按钮的点击，写入点击 开始游戏 按键后按键上字符改为 结束游戏 并开始游戏(boolChessFlag=1)，反之同理。

    public void actionPerformed(ActionEvent e){
        System.out.println ("按钮被点击了");
// 获取按钮的文本
        String btnStr = e.getActionCommand ();
// 获取按钮的对象
        JButton btn = (JButton) e.getSource ();
        if(btnStr.equals ("开始游戏")){
            boolChessFlag=1;// 设置标识 为 黑棋先下
// 点击开始游戏按钮之后 将文本替换成 结束游戏
            btn.setText ("结束游戏");
        }else if(btnStr.equals ("结束游戏")){
            boolChessFlag=0;// 设置标识 不能下棋
// 点击结束游戏按钮 替换成开始游戏
            btn.setText ("开始游戏");
            }
        }
    }

在GoListener中创建方法repaint1，用于绘制棋盘，此方法就是上面看到的Interface类paint方法中调用的方法(保证棋盘画在JFrame下面，拖动窗口就不会消失了)

        public void repaint1(Graphics g){ //在Interface中需调整棋盘位置重新写repaint为repaint1重画棋盘
            System.out.println("repaint1绘制");
    //在Interface中需调整棋盘的位置，加上 上方边框 左边按钮面板的宽
            int Xboard=X;
            int Yboard=Y;
            g.setColor (bgcolor);
            g.fillRect(Xboard-SIZE/2, Yboard-SIZE/2, SIZE*(ROW-1)+SIZE,SIZE*(COL-1)+SIZE);
    // 绘制棋盘
            g.setColor (Color.black);
            for(int i = 0; i <ROW; i++){
                g.drawLine (Xboard, Yboard+i*SIZE, Xboard + (COL-1)* SIZE, Yboard+i*SIZE);
                g.drawLine (Xboard+i*SIZE,Yboard,Xboard+i*SIZE,Yboard+(ROW-1)*SIZE);
            }
            g.setColor (Color.red);
            g.drawRect (Xboard-halfSize,Yboard-halfSize,SIZE*(COL-1)+SIZE,SIZE*(ROW-1)+SIZE);
        }

之后，为了实现鼠标点击棋盘画出棋子，在GoListener中重写MousePressed方法，当开始游戏按钮没被点击时我们希望他不画棋子而是弹出一个游戏未开始的提示，反之画棋子

先获取每次点击的位置坐标，这时用坐标画棋子并不会对其棋盘规定落棋点，所以要把该坐标转化为棋盘坐标

x2=(xd-Xd+SIZEd/2)/SIZEd;
y2=(yd-Yd+SIZEd/2)/SIZEd;

再计算该棋盘坐标在界面上的坐标

x1=x3*SIZEd+Xd-SIZEd/2;
y1=y3*SIZEd+Yd-SIZEd/2;

在算出棋盘坐标后可判断点击位置是否超出棋盘，若超出就不画棋子；读取存储棋子位置的二维数组，若该位置有棋子，则不画，确保棋子在该点能画后画上棋子，再将坐标存入二维数组中，更换chessflag保证下一颗棋子为不同颜色的棋。

    public void mousePressed(MouseEvent e){
        if(boolChessFlag==0){
// 弹窗
            JOptionPane.showMessageDialog (null,"游戏未开始");
            return;// 结束方法
        }
        System.out.println ("鼠标按下事件");
// 获取坐标
        int x = e.getX ();
        int y = e.getY ();
        //System.out.println("获取坐标--x:"+x+",y:"+y);
        double xd=x,yd=y;
        double x2=(xd-Xd+SIZEd/2)/SIZEd;
        double y2=(yd-Yd+SIZEd/2)/SIZEd;
        int x3=(int)x2;
        int y3=(int)y2;
        System.out.println("x3:"+x3+",y3:"+y3);
        if(x2<0 || x3>COL-1 || y2<0 || y3>ROW-1){
            return;
        }
        double x1=x3*SIZEd+Xd-SIZEd/2;
        double y1=y3*SIZEd+Yd-SIZEd/2;
        int xshow=(int)x1;
        int yshow=(int)y1;

        if(chessPiecesLocat[x3][y3]!=0){
            //JOptionPane.showMessageDialog (null,"该位置已有棋子");
            System.out.println("该位置已有棋子");
            return;
        }
        chessPiecesLocat[x3][y3]=chessFlag;
        Chess chess=new Chess();
        chess.x=x3;
        chess.y=y3;
        chess.chessFlag=chessFlag;
        Chess1[Chess1Index]=chess;
        Chess1Index++;

        paint(g,chessFlag,xshow,yshow);

        if(chessFlag == 1){
            chessFlag = 2;
        } else if(chessFlag == 2){
            chessFlag = 1;
        }
    }

上面所用到的paint方法为我们另外创建的方法，用于绘制立体棋子

    public void paint(Graphics g,int chessflag,int x,int y){ //画棋子
        if(chessflag==1){
            int blackChange=200;//调黑棋渐变程度0(全黑)-blackChange
            for(int i = 0; i < blackChange; i++){
                Color colo5 = new Color (i,i,i);
                g.setColor (colo5);
                double di3=SIZEd/blackChange*i/2;
                double di2=SIZEd-SIZEd/blackChange*i;
                int i3=(int)di3;
                int i2=(int)di2;
                g.fillOval (x+i3, y+i3, i2, i2);
            }
        }else if (chessflag==2){
            int whiteChange=160;//调白棋渐变程度whiteChange-255(全白)
            int whiteRange=256-whiteChange;
            for(int i =0; i < whiteRange; i++){
                int colorSet=whiteChange+i;
                Color colo5 = new Color (colorSet,colorSet,colorSet);
                g.setColor (colo5);
                double di3=SIZEd/whiteRange*i/2;
                double di2=SIZEd-SIZEd/whiteRange*i;
                int i3=(int)di3;
                int i2=(int)di2;
                g.fillOval (x+i3, y+i3, i2, i2);
            }
        }
    }

因为我们有二维数组存储已下棋子的坐标和颜色，我们可以还原棋子，而我们拖动界面时棋子会消失，这时我们需要这个功能；重画棋盘时棋子也会消失，这时我们也需要这个功能。所以我们在repaint1方法末端加上重画棋子的代码，棋子就会一直留在界面上

        public void repaint1(Graphics g){ //在Interface中需调整棋盘位置重新写repaint为repaint1重画棋盘
            System.out.println("repaint1绘制");
    //在Interface中需调整棋盘的位置，加上 上方边框 左边按钮面板的宽
            int Xboard=X;
            int Yboard=Y;
            g.setColor (bgcolor);
            g.fillRect(Xboard-SIZE/2, Yboard-SIZE/2, SIZE*(ROW-1)+SIZE,SIZE*(COL-1)+SIZE);
    // 绘制棋盘
            g.setColor (Color.black);
            for(int i = 0; i <ROW; i++){
                g.drawLine (Xboard, Yboard+i*SIZE, Xboard + (COL-1)* SIZE, Yboard+i*SIZE);
                g.drawLine (Xboard+i*SIZE,Yboard,Xboard+i*SIZE,Yboard+(ROW-1)*SIZE);
            }
            g.setColor (Color.red);
            g.drawRect (Xboard-halfSize,Yboard-halfSize,SIZE*(COL-1)+SIZE,SIZE*(ROW-1)+SIZE);
    //画棋子
            for(int i=0;i<chessPiecesLocat.length;i++){
                for(int j=0;j<chessPiecesLocat[i].length;j++){
                    if(chessPiecesLocat[i][j]==0){
                        continue;
                    } else if (chessPiecesLocat[i][j]==1) {
                        chessFlagInMouseEntered=1;
                    } else if (chessPiecesLocat[i][j]==2) {
                        chessFlagInMouseEntered=2;
                    }
                    double x1=i*SIZEd+Xd-SIZEd/2;
                    double y1=j*SIZEd+Yd-SIZEd/2;
                    int xshow=(int)x1;
                    int yshow=(int)y1;
                    paint(g,chessFlagInMouseEntered,xshow,yshow);
                }
            }
        }

接下去实现悔棋功能。

在mousePressed方法的下半部分有写

Chess chess=new Chess();
chess.x=x3;
chess.y=y3;
chess.chessFlag=chessFlag;
Chess1[Chess1Index]=chess;
Chess1Index++;

这一段将棋子的位置和颜色编号，按下棋的顺序存入数组Chess1中，注意此数组为Chess类的数组，而Chess类中有三个变量为x，y和chessFlag，创建new Cjess()再把对应的值付给chess，再把当前的chess存到Chess1数组中，最后把ChessIndex也就是记录数组中对象总数的变量+1，要悔棋时从后往前删除对象。

所以我们在按钮被按下的方法中加入按下悔棋时的操作：先判断棋盘上有几个棋子，如果没有棋子那就不能悔棋，若有，将最后存入的棋取出，在二维数组chessPiecesLocat中删除对应位置的棋子chessPiecesLocat[Chess2.x][Chess2.y]=0，同时删除Chess1中的最后一个对象Chess1[Chess1Index-1]=null，之后重画棋盘和棋子就能达到悔棋的效果。

    public void actionPerformed(ActionEvent e){
        System.out.println ("按钮被点击了");
// 获取按钮的文本
        String btnStr = e.getActionCommand ();
// 获取按钮的对象
        JButton btn = (JButton) e.getSource ();
        if(btnStr.equals ("开始游戏")){
            boolChessFlag=1;// 设置标识 为 黑棋先下
// 点击开始游戏按钮之后 将文本替换成 结束游戏
            btn.setText ("结束游戏");
            //System.out.println("chessFlag"+chessFlag);
        }else if(btnStr.equals ("结束游戏")){
            boolChessFlag=0;// 设置标识 不能下棋
// 点击结束游戏按钮 替换成开始游戏
            btn.setText ("开始游戏");
            //System.out.println("chessFlag"+chessFlag);
        } else if (btnStr.equals ("悔      棋")) {
            if(Chess1Index<=0){
                JOptionPane.showMessageDialog (null,"没有棋子可悔了");
            }else if(Chess1Index>0){
                Chess Chess2=Chess1[Chess1Index-1];
                chessPiecesLocat[Chess2.x][Chess2.y]=0;
                Chess1[Chess1Index-1]=null;
                Chess1Index--;
                if(chessFlag == 1){
                    chessFlag = 2;
                } else if(chessFlag == 2){
                    chessFlag = 1;
                }
                repaint1(g);
            }
        }
    }

接下来实现判断输赢的功能

判断输赢需从4个方向判断，为了代码整齐，在GoListener中写4个方法判断+1个方法整合

    public int judgeHorizontal(int[][]a,int x,int y){
        int count = 0;// 连子数记录变量
// 向右边查找
        int c1 = a[x][y];
        for(int i = x + 1; i < a.length; i++){
// 右边取出的棋子
            int cn = a[i][y];
// 与c1进行比较
            if(c1 == cn){
                count++;
            } else{
//如果找到一颗棋子 不同于c1 要么是 0
                break;// 跳出循环
            }
        }
        //System.out.println ("向右边查找连子数为:" + count);
// 向左边查找 行不变 列减
// 包含当前棋子本身
        count++;
        for(int i = x - 1; i>=0; i--){
// 右边取出的棋子
            int cn = a[i][y];
// 与c1进行比较
            if(c1 == cn){
                count++;
            } else{
//如果找到一颗棋子 不同于c1 要么是 0
                break;// 跳出循环
            }
        }
        //System.out.println ("横向查找的连子数：" + count);
        return count;
    }
    public int judgeVertical(int[][]a,int x,int y){
        int count = 0;// 连子数记录变量
// 向上边查找
        int c1 = a[x][y];
        for(int i = y - 1; i >=0; i--){
            int cn = a[x][i];
            if(c1 == cn){
                count++;
            } else{
                break;
            }
        }
        //System.out.println ("向上边查找连子数为:" + count);
        count++;
// 向下边查找
        for(int i = y + 1; i<a[x].length; i++){
            int cn = a[x][i];
            if(c1 == cn){
                count++;
            } else{
                break;
            }
        }
        //System.out.println ("纵向查找的连子数：" + count);
        return count;
    }
    public int judgeIncline1(int[][]a,int x,int y){ //左上-右下
        int count = 0;// 连子数记录变量
// 向左上边查找
        int c1 = a[x][y];
        int j=y;
        for(int i = x - 1; i >=0; i--){
            if(j>0){
                j--;
            }else{break;}
            int cn = a[i][j];
            if(c1 == cn){
                count++;
            } else{
                break;
            }
        }
        //System.out.println ("向左上边查找连子数为:" + count);
        count++;
// 向右下边查找
        j=y;
        for(int i = x + 1; i<a.length; i++){
            if(j<a[x].length-1){
                j++;
            }else{break;}
            int cn = a[i][j];
            if(c1 == cn){
                count++;
            } else{
                break;
            }
        }
        //System.out.println ("左上-右下查找的连子数：" + count);
        return count;
    }
    public int judgeIncline2(int[][]a,int x,int y){ //右上-左下
        int count = 0;// 连子数记录变量
// 向右上边查找
        int c1 = a[x][y];
        int j=y;
        for(int i = x + 1; i<a.length; i++){
            if(j>0){
                j--;
            }else{break;}
            int cn = a[i][j];
            if(c1 == cn){
                count++;
            } else{
                break;
            }
        }
        //System.out.println ("向右上边查找连子数为:" + count);
        count++;
// 向左下边查找
        j=y;
        for(int i = x - 1; i>=0; i--){
            if(j<a[x].length-1){
                j++;
            }else{break;}
            int cn = a[i][j];
            if(c1 == cn){
                count++;
            } else{
                break;
            }
        }
        //System.out.println ("右上-左下查找的连子数：" + count);
        return count;
    }

整合上面四个方法

    public boolean judge(int[][]a,int x,int y){
        int a1,b,c,d;
        a1=judgeHorizontal(a,x,y);
        b=judgeVertical(a,x,y);
        c=judgeIncline1(a,x,y);
        d=judgeIncline2(a,x,y);
        if(a1>=5 || b>=5 || c>=5 || d>=5){
            return true;
        }else{return false;}
    }

判断输赢的最好时机就是鼠标点击下完棋子的时候，所以在mousePressed方法中，在将棋子存入二维数组之后加上判断输赢语句

if(judge(chessPiecesLocat,x3,y3)){
    if(chessFlag==1){JOptionPane.showMessageDialog (null,"游戏结束,黑方胜利！");}
    if(chessFlag==2){JOptionPane.showMessageDialog (null,"游戏结束,白方胜利！");}
    int[][]newChessPiecesArray=new int[COL][ROW];
    chessPiecesLocat=newChessPiecesArray;
    chessFlag=1;
    Chess1Index=0;
    repaint1(g);
    return;
}
    public void mousePressed(MouseEvent e){
        if(boolChessFlag==0){
// 弹窗
            JOptionPane.showMessageDialog (null,"游戏未开始");
            return;// 结束方法
        }
        System.out.println ("鼠标按下事件");
// 获取坐标
        int x = e.getX ();
        int y = e.getY ();
        //System.out.println("获取坐标--x:"+x+",y:"+y);
        double xd=x,yd=y;
        double x2=(xd-Xd+SIZEd/2)/SIZEd;
        double y2=(yd-Yd+SIZEd/2)/SIZEd;
        int x3=(int)x2;
        int y3=(int)y2;
        System.out.println("x3:"+x3+",y3:"+y3);
        if(x2<0 || x3>COL-1 || y2<0 || y3>ROW-1){
            return;
        }
        double x1=x3*SIZEd+Xd-SIZEd/2;
        double y1=y3*SIZEd+Yd-SIZEd/2;
        int xshow=(int)x1;
        int yshow=(int)y1;

        if(chessPiecesLocat[x3][y3]!=0){
            //JOptionPane.showMessageDialog (null,"该位置已有棋子");
            System.out.println("该位置已有棋子");
            return;
        }
        chessPiecesLocat[x3][y3]=chessFlag;
        Chess chess=new Chess();
        chess.x=x3;
        chess.y=y3;
        chess.chessFlag=chessFlag;
        Chess1[Chess1Index]=chess;
        Chess1Index++;


//绘制 外切矩形的左上角坐标 宽度 高度
        paint(g,chessFlag,xshow,yshow);
        if(judge(chessPiecesLocat,x3,y3)){
            if(chessFlag==1){JOptionPane.showMessageDialog (null,"游戏结束,黑方胜利！");}
            if(chessFlag==2){JOptionPane.showMessageDialog (null,"游戏结束,白方胜利！");}
            int[][]newChessPiecesArray=new int[COL][ROW];
            chessPiecesLocat=newChessPiecesArray;
            chessFlag=1;
            Chess1Index=0;
            repaint1(g);
            return;
        }

        if(chessFlag == 1){
            chessFlag = 2;
        } else if(chessFlag == 2){
            chessFlag = 1;
        }
    }

到此，一个基础的五子棋程序就完成了

LZ2587246324
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
山东大学项目实训——简易微信小游戏（五）
qq_47801057的博客
04-04 3655
本篇对cocos creator五子棋项目进行补充，例如输赢判定、悔棋的实现。由于在上一篇将该项目的核心：人机对战的“评分表法”进行了分析与实现山东大学项目实训——简易微信小游戏（四），因此这里相对容易些。 一、输赢判定及实现 五子棋只要有一方“五子连珠”则证明该方获胜，那么计算机如何知道棋盘上出现“五子连珠”呢？显然机器只能知道玩家鼠标点击的位置坐标或者是机器通过“评分表法”得到的最大分数位置坐标，因此最简单粗暴的方式就是遍历该位置的同一方向（水平、垂直、正斜、反斜）上是否有紧挨连续的棋子且多于.
P17 五子棋的实现4 悔棋功能
m0_54108654的博客
03-09 2696
这一节主要介绍如何实现悔棋功能 首先在UI中添加“悔棋“按钮，并给按钮添加监听器（过程省略） 接下来实现悔棋功能 之前的二维数组ChessArr[h][l]中存的是每个棋子的flag，0表示h行l列没有棋子，1表示有黑棋，2表示有白棋，关于整个下棋过程中某一步下的是什么棋，在这个数组中没有记录，所以需要一个按顺序专门存放已下的棋子顺序，这样悔棋就知道最后要撤回的是哪个棋子。 1 重新创建一个Chess03类 已下棋子顺序，就是所下位置也就是h1和l1的值 2 行列值存到对象chess03
java五子棋全代码—可实现悔棋功能
guyu的博客
01-25 6943
用Java编写简单的五子棋——可悔棋！ 前言   最近有网友仔细参考了我上一期的五子棋代码，发现了我偷懒没有做悔棋功能，并通过私信的方式找到了我，对我进行了狠狠地批评，说我不讲武德，来欺骗他们这些老同志。嗷，我一问，他们是有备而来，我大意了啊，没闪，就连夜补写了这篇文章。    测试类 public class Test { public static void main(String[] args) { MyJFrame mj = new MyJFrame();
java版本五子棋之悔棋篇
weixin_47166204的博客
03-30 863
本文介绍了用Java编写一个简单的五子棋小游戏的过程，重点说明了如何实现悔棋的功能。作者使用了面向对象的思想，将每个棋子封装成一个对象，用一个一维数组来存储每一步下的棋子。悔棋时，只需从数组中取出最后一个棋子对象，并将其对应位置的颜色设为背景色即可。文章还给出了完整的代码和运行效果图，方便读者学习和参考。本文是一篇有价值的技术文章，可以帮助读者了解Java编程的基本知识和技巧，以及五子棋游戏的设计思路和实现方法。
js数组案例---五子棋
赵佳敏的博客
10-02 405
js数组案例---五子棋一、效果图二、设计思路三、核心代码 一、效果图 二、设计思路 第一步：创建棋盘，生成棋盘所对应的数组坐标。 第二步：鼠标点击当前位置返回当前点的坐标。 第三步：生成对应的棋子。 第四步：添加悔棋、重新开始事件。 第五步：设置棋子输赢，若某个棋子五个连成一条线，则该棋子赢。 三、核心代码 //1.创建棋盘 var item = document.querySelector(".item-map"); var itemchild = docum.
C语言实现五子棋对弈（简单输入坐标下棋，可设置悔棋次数版）
04-22
主要功能是实现两人之间的对弈，在画好的棋盘上，两个玩家轮流选择自己的落子坐标，然后由五子棋系统自动识别判断游戏的进展，知道一方的五子连成一条线或者棋盘已经无法落子时游戏结束。 选定五子棋的棋盘大小为19...
C语言实现五子棋（双人对战，单人对战，悔棋等功能）.zip
12-18
在本项目中，"C语言实现五子棋（双人对战，单人对战，悔棋等功能）.zip" 是一个使用C语言编写的五子棋游戏程序。以下是关于这个项目的详细知识点： 1. **C语言编程**：C语言是一种强大的、底层的编程语言，适合开发...
c#单机五子棋，带悔棋功能
01-08
本项目"五子棋"是基于C#实现的一个单机版游戏，允许玩家进行对弈，并具备悔棋功能，提升了游戏体验。 一、基本原理 1. **图形界面**：C#中的Windows Forms或WPF（Windows Presentation Foundation）框架可用于构建...
wuziqi.rar_五子棋java悔棋
09-19
这个Java程序不仅实现了基本的游戏规则，还包含了额外的功能，如悔棋、和棋判断、认输机制以及计时功能，这些都为游戏增加了更多的互动性和挑战性。 首先，让我们深入了解一下Java编程语言。Java是一种面向对象的、...
Qt五子棋，双人对战与人机对战，可以悔棋，可以复盘
01-19
同时，该游戏还具备悔棋和复盘功能，增加了游戏的策略性和娱乐性。 1. **Qt框架介绍** Qt是一个跨平台的应用程序开发框架，支持Windows、Linux、macOS等多种操作系统。它使用C++语言编写，提供了一套完整的图形...
《原生js 实现五子棋 代码解析笔记》
yk_ddm的博客
04-30 223
五子棋效果 效果图 功能分析 1）计算步数功能 2）悔棋功能 3）开始游戏
给五子棋加个功能叫悔棋
热门推荐
ljw_Josie的博客
10-24 1万+
零基础又不太勤奋的编程小白这周只完成了一个悔棋功能~~~~(>_ 首先，要实现悔棋功能的话，首先要明白这几件事。第一，要使之前记录棋子的数组aGridState[i][j]=0;第二，要把棋盘上的棋子删除掉；第三，悔棋之后再下的那颗棋必须和之前悔掉的那颗棋颜色一致。 所以，第一：使之前记录棋子的数组aGridState[i][j]=0 思路：用两个for循环遍布整个
微信小程序
weixin_45625220的博客
09-09 86
五子棋@TOC 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会...
JS简易实现五子棋游戏(三)
weixin_46514047的博客
03-01 592
本篇为对JS实现双人五子棋简易游戏(上)进行补充，添加了悔棋的功能，并修改部分页面效果。
Unity中国象棋（四）——悔棋、判断胜负的实现，以及动画特效和代码的优化
LudoArtificis的成长之路
02-06 4018
悔棋功能的实现： 基本思路就是创建一个List，保存每一步所移动的棋子ID，移动前的位置A的坐标，移动后的位置B的坐标，以及吃掉的棋子的ID（若没有吃掉棋子则ID为-1） 附上相关代码： 结构体的List public struct step { public int moveId; public int killId; publ
J031_使用TCP协议支持与多个客户端同时通信
最新发布
lzn20161229的博客
08-03 186
使用TCP协议支持与多个客户端同时通信。
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 602
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
社区养老服务小程序的设计
Karen198的博客
07-31 525
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
深入理解Java注解
weixin_55745942的博客
08-01 565
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
C++实现五子棋游戏：控制台版带AI与悔棋功能
本文将深入讲解如何使用C++语言编写一个基本的五子棋游戏，这款游戏具备与计算机对战或双人对战模式，并具有AI算法和悔棋选项。对于初学者而言，这是一个很好的实践项目，可以帮助他们巩固C++基础知识，了解游戏逻辑...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值