每周总结①——Java实现五子棋游戏（人机对弈+人人对弈）

这周有小学期，所以一直在做小学期，我选择的题目是五子棋游戏。

参考博客：https://blog.csdn.net/oldhunter686/article/details/104039536

界面截图如下：

  

    

 

代码如下：

Main.java

package wuziqii;

/**
 * Main方法创建了ChessFrame类的一个实例对象（chess_frame）
 * 并启动屏幕显示
 * 显示该实例对象
 * @author Administrator
 *
 */
public class Main {
    @SuppressWarnings("deprecation")
    public static void main(String[] args) {
        ChessFrame chess_frame = new ChessFrame();
        chess_frame.show();
    }
}

ChessFrame.java

package wuziqii;

import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.ButtonGroup;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JRadioButtonMenuItem;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;

/**
 * 主要功能：
 * 创建五子棋游戏主窗体和菜单
 * @author Administrator
 *
 */
@SuppressWarnings("serial")
public class ChessFrame extends JFrame implements ActionListener {
    private String[] strsize= {"20x15","30x20","40x30","50x50"};//棋盘
    private String[] strmode= {"人机对弈","人人对弈"};//模式
    
    public static boolean iscomputer=true;
    public static boolean checkcomputer=true;
    
    private int width;
    private int height;
    private ChessModel chessmodel;//ChessModel.java
    private MainPanel mainpanel;//MainPanel.java
    
    //构造五子棋游戏的主窗体
    public ChessFrame() {
        //菜单标题
        this.setTitle("五子棋游戏");
        //创建棋盘，默认第一种模式
        chessmodel=new ChessModel(1);//创建棋盘，默认第一种模式
        mainpanel=new MainPanel(chessmodel);//落子用的画笔，处理鼠标点击事件
        Container container=this.getContentPane();//获得当前JFramede的内容面板
        container.add(mainpanel,"Center");//添加面板对象到当前的jframe
        this.setResizable(false);//设置当前窗口不能自由改变大小
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//关闭窗口就结束程序
        //匿名内部类
        this.addWindowListener(new WindowAdapter(){            
            public void windowClosing(WindowEvent e){
                System.exit(0);//表示在窗口添加一个Windows事件消息，用于退出
            }
        });
        MapSize(20,15);//棋盘大小（默认）
        JMenuBar mbar=new JMenuBar();//创建菜单栏对象
        this.setJMenuBar(mbar);
        JMenu gameMenu=new JMenu("游戏");//创建菜单栏游戏
        mbar.add(makeMenu(gameMenu,new Object[] { "开局", "棋盘","模式",null,"退出" },this));
        JMenu lookMenu=new JMenu("视图");
        mbar.add(makeMenu(lookMenu,new Object[] { "Metal","Motif","Windows" },this));
        JMenu helpMenu=new JMenu("帮助");
        mbar.add(makeMenu(helpMenu,new Object[] { "游戏介绍" },this));
    }
    
    //构造五子棋游戏的主菜单
    public JMenu makeMenu(Object parent,Object items[],Object target){
        JMenu m=null;
        if(parent instanceof JMenu)
            m=(JMenu)parent;
        else if(parent instanceof String)
            m=new JMenu((String)parent);
        else
            return null;
        for(int i= 0;i<items.length;i++)
            if(items[i] == null)//如果为空，在菜单项添加分割线
                m.addSeparator();
            else if(items[i] == "棋盘"){
                JMenu jm=new JMenu("棋盘");
                //每个JRadioButton都是独立的，需要加入到ButtonGroup对象，
                ButtonGroup group=new ButtonGroup();
                //类表示可以包含在菜单中的复选框。选中菜单中的复选框可将控件的状态从打开更改为关闭或从关闭更改为打开。
                JRadioButtonMenuItem rmenu;
                for(int j=0;j<strsize.length;j++){
                    rmenu=makeRadioButtonMenuItem(strsize[j],target);
                    if(j==0) rmenu.setSelected(true);
                    jm.add(rmenu);
                    group.add(rmenu);
                }
                m.add(jm);
            }else if(items[i] == "模式"){
                JMenu jmenu=new JMenu("模式");
                ButtonGroup buttongroup=new ButtonGroup();
                JRadioButtonMenuItem rmenu;
                for(int h=0;h<strmode.length;h++){//strmode 人机对弈和人人对弈
                    rmenu=makeRadioButtonMenuItem(strmode[h],target);
                    if(h==0)
                        rmenu.setSelected(true);//默认人机对弈
                    jmenu.add(rmenu);
                    buttongroup.add(rmenu);
                }
                m.add(jmenu);
            }else
                m.add(makeMenuItem(items[i],target));
        return m;
    }
    
    //构造五子棋游戏的菜单项
    public JMenuItem makeMenuItem(Object item,Object target){
        JMenuItem jmenuitem= null;
        if(item instanceof String)
            jmenuitem=new JMenuItem((String)item);
        else if(item instanceof JMenuItem)
            jmenuitem=(JMenuItem)item;
        else
            return null;
        if(target instanceof ActionListener)
            jmenuitem.addActionListener((ActionListener)target);
        return jmenuitem;
    }
    
    //构造五子棋游戏的单选按钮式菜单项
    public JRadioButtonMenuItem makeRadioButtonMenuItem(Object item,Object target){
        JRadioButtonMenuItem jradiobuttonmenuitem= null;
        if(item instanceof String)
            jradiobuttonmenuitem=new JRadioButtonMenuItem((String)item);
        else if(item instanceof JRadioButtonMenuItem)
            jradiobuttonmenuitem=(JRadioButtonMenuItem)item;
        else
            return null;
        if(target instanceof ActionListener)
            jradiobuttonmenuitem.addActionListener((ActionListener)target);
        return jradiobuttonmenuitem;
    }
    
    @SuppressWarnings("static-access")
    public void MapSize(int width,int height){
        setSize(width*20+50,height*20+100);
        if(this.checkcomputer)
            this.iscomputer=true;
        else
            this.iscomputer=false;
        //设置棋盘大小的方法
        mainpanel.setModel(chessmodel);
        //component中己有的图形发生变化后不会立刻显示，须使用repaint方法
        mainpanel.repaint();
    }
    
    @SuppressWarnings("static-access")
    public boolean getiscomputer(){
        //返回是否为人机对弈模式
        return this.iscomputer;
    }
    
    public void restart(){
        //重新开局的方法
        int modeChess=chessmodel.getModeChess();
        if(modeChess<= 4&&modeChess>= 1){
            chessmodel=new ChessModel(modeChess);
            MapSize(chessmodel.getWidth(),chessmodel.getHeight());
            System.out.println("重新开局");
        }else{
            System.out.println("重新开局失败");
        }
    }
    
    @SuppressWarnings("static-access")
    public void actionPerformed(ActionEvent actionevent){
        String arg=actionevent.getActionCommand();
        
        //视图风格
        try{
            if(arg.equals("Windows"))
                UIManager.setLookAndFeel(
                        "com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
            else if(arg.equals("Motif"))
                UIManager.setLookAndFeel(
                        "com.sun.java.swing.plaf.motif.MotifLookAndFeel");
            else UIManager.setLookAndFeel(
                        "javax.swing.plaf.metal.MetalLookAndFeel");
            SwingUtilities.updateComponentTreeUI(this);
        }catch(Exception ee){}
        
        if(arg.equals("20x15")){
            this.width=20;
            this.height=15;
            chessmodel=new ChessModel(1);
            MapSize(this.width,this.height);
            SwingUtilities.updateComponentTreeUI(this);
        }
        if(arg.equals("30x20")){
            this.width=30;
            this.height=20;
            chessmodel=new ChessModel(2);
            MapSize(this.width,this.height);
            SwingUtilities.updateComponentTreeUI(this);
        }
        if(arg.equals("40x30")){
            this.width=40;
            this.height=30;
            chessmodel=new ChessModel(3);
            MapSize(this.width,this.height);
            SwingUtilities.updateComponentTreeUI(this);
        }
        if(arg.equals("50x50")){
            this.width=50;
            this.height=50;
            chessmodel=new ChessModel(4);
            MapSize(this.width,this.height);
            SwingUtilities.updateComponentTreeUI(this);
        }
        if(arg.equals("人机对弈")){
            System.out.println("进入人机对弈模式");
            this.checkcomputer=true;
            this.iscomputer=true;
            chessmodel=new ChessModel(chessmodel.getModeChess());
            MapSize(chessmodel.getWidth(),chessmodel.getHeight());
            SwingUtilities.updateComponentTreeUI(this);
        }
        if(arg.equals("人人对弈")){
            System.out.println("进入人人对弈模式");
            this.checkcomputer=false;
            this.iscomputer=false;
            chessmodel=new ChessModel(chessmodel.getModeChess());
            MapSize(chessmodel.getWidth(),chessmodel.getHeight());
            SwingUtilities.updateComponentTreeUI(this);
        }
        if(arg.equals("开局")){ 
            restart(); 
        }
        if(arg.equals("游戏介绍")) {
            System.out.println("打开游戏介绍");
            JOptionPane.showMessageDialog(this,"五子棋是一种受大众广泛喜爱的游戏，"
                    + "
其规则简单，非常富有趣味性和消遣性。"
                    + "
基本规则："
                    + "
选定一方先下，之后黑白双方依次落子。棋盘上形成横向、竖向、斜向的连续的相同颜色的五个棋子称为'五连' 。"
                    + "
黑白双方先在棋盘上形成五连的一方为胜。"
                    + "
若对局双方均认为不可能形成五连或是剩余棋盘空间已不足以形成五连则为和棋。", "游戏介绍",0);
        }
        if(arg.equals("退出")) {
            System.out.println("成功退出五子棋游戏");
            System.exit(0);
        }
    }
}

ChessModel.java

package wuziqii;

import javax.swing.JOptionPane;
import javax.swing.JPanel;

/**
 * 实现整个五子棋程序算法的核心
 * @author Administrator
 *
 */
public class ChessModel {
    /**
     * 棋盘的宽度
     * 棋盘的高度
     * 棋盘的模式（比如：20x15）
     * 
     */
    private int width,height,modeChess;//棋盘方格的横向、纵向坐标
    private int x = 0;//棋盘方格横向坐标所对应的棋子颜色
    private int y = 0;//棋盘方格纵向坐标所对应的棋子颜色
    private int[][]arrMapShow;//交换棋手的标识，棋盘方格上是否有棋子的标识符
    
    //获取某棋盘方格是否有棋子的标识值
    public boolean getisExist() {
        return this.isExist;
    }
    
    //获取棋盘宽度
    public int getWidth() {
        return this.width;
    }
    
    //获取棋盘高度
    public int getHeight() {
        return this.height;
    }
    
    //获取棋盘模式
    public int getModeChess() {
        return this.modeChess;
    }
    
    //获取棋盘方格上棋子的信息
    public int[][]getarrMapShow(){
        return arrMapShow;
    }
    
    //记录电脑下子后的横向坐标
    public void setX(int x) {
        this.x=x;
    }
    //获取电脑下子的横向坐标
    public int getX() {
        return this.x;
    }
    //记录电脑下子后的纵向坐标
    public void setY(int y) {
        this.y=y;
    }
    //获取电脑下子的纵向坐标
    public int getY() {
        return this.y;
    }
    
    /**
     * 数组arrMapShow只有4个值：1，2，3，-5
     * 1——该棋盘方格上下的棋子为黑子
     * 2——该棋盘方格上下的棋子为白子
     * 3——该棋盘方格上没有棋子
     * -5——该棋盘方格上不能够下棋子
     * ：
     */
    private boolean isOdd;
    private boolean isExist;
    
    //获取是否交换棋手的标识符
    public boolean getisOdd() {
        return this.isOdd;
    }
    //设置交换棋手的标识符
    public void setisOdd(boolean isOdd) {
        if(isOdd)
            this.isOdd = true;
        else
            this.isOdd = false;
    }
    
    //构造方法
    public ChessModel() {}
    public ChessModel(int modeChess) {//此构造方法根据不同的棋盘模式(modeChess)来构建对应大小的棋盘
        //默认先手——黑子
        this.isOdd = true;
        if(modeChess == 1) {
            Panellnit(20,15,modeChess);
        }
        if(modeChess == 2) {
            Panellnit(30,20,modeChess);
        }
        if(modeChess == 3) {
            Panellnit(40,30,modeChess);
        }
        if(modeChess == 4) {
            Panellnit(50,50,modeChess);
        }
    }
    
    //按照棋盘模式构建棋盘大小
    private void Panellnit(int width,int height,int modeChess) {
        this.width = width;
        this.height = height;
        this.modeChess = modeChess;
        
        arrMapShow = new int[width+1][height+1];
        for(int i = 0;i <= width;i++) {
            for(int j = 0;j <= height;j++) {
                arrMapShow[i][j] = -5;
            }
        }
    }
    
    //判断下子的横向、纵向是否越界
    private boolean badxy(int x,int y) {
        if(x >= width+20 || x<0) 
            return true;
        return y>=height||y<0;
    }
    
    //计算棋盘上某一方格上八个方向棋子的最大值
    //八个方向分别为：左-右-上-下-左上-左下-右上-右下
    public int checkMax(int x,int y,int black_or_white) {
        int num=0;
        int max_num;
        int max_temp=0;
        int x_temp=x;
        int y_temp=y;
        int x_temp1=x_temp;
        int y_temp1=y_temp;
        
        //右-x+
        for(int i=1;i<5;i++) {
            x_temp1+=1;
            if(x_temp1>this.width)//如果到达边界，跳出循环
                break;
            if(this.arrMapShow[x_temp1][y_temp1]==black_or_white)//如果右边的下一个落子与当前字相同，num+1
                num++;
            else
                break;
        }
        //左-x-
        x_temp1=x_temp;
        for(int i=1;i<5;i++) {
            x_temp1-=1;
            if(x_temp1<0)
                break;
            if(this.arrMapShow[x_temp1][y_temp1]==black_or_white)
                num++;
            else
                break;
        }
        if(num<5)
            max_temp=num;
        //上-x,y-
        x_temp1=x_temp;
        y_temp1=y_temp;
        num=0;
        for(int i=1;i<5;i++){
            y_temp1-=1;
            if(y_temp1<0)
                break;
            if(this.arrMapShow[x_temp1][y_temp1]==black_or_white)
                num++;
            else
                break;
        }
        //下-y+
        y_temp1=y_temp;
        for(int i=1;i<5;i++){
            y_temp1+=1;
            if(y_temp1>this.height)
                break;
            if(this.arrMapShow[x_temp1][y_temp1]==black_or_white)
                num++;
            else
                break;
        }
        if(num>max_temp&&num<5)
            max_temp=num;
        //左上-x-,y-
        x_temp1=x_temp;
        y_temp1=y_temp;
        num=0;
        for(int i=1;i<5;i++){
            x_temp1-=1; 
            y_temp1-=1;
            if(y_temp1<0||x_temp1<0)
                break;
            if(this.arrMapShow[x_temp1][y_temp1]==black_or_white)
                num++;
            else
                break;
        }
        //右下-x+,y+
        x_temp1=x_temp;
        y_temp1=y_temp;
        for(int i=1;i<5;i++){
            x_temp1+=1; 
            y_temp1+=1;
            if(y_temp1>this.height || x_temp1>this.width)
                break;
            if(this.arrMapShow[x_temp1][y_temp1]==black_or_white)
                num++;
            else
                break;
        }
        if(num>max_temp&&num<5)
            max_temp=num;
        //左下-x-,y+
        x_temp1=x_temp;
        y_temp1=y_temp;
        for(int i=1;i<5;i++){
            x_temp1-=1; 
            y_temp1+=1;
            if(y_temp1>this.height || x_temp1<0)
                break;
            if(this.arrMapShow[x_temp1][y_temp1]==black_or_white)
                num++;
            else
                break;
        }
        if(num>max_temp&&num<5)
            max_temp=num;
        max_num=max_temp;
        //右上-x+,y-
        x_temp1=x_temp;
        y_temp1=y_temp;
        num=0;
        for(int i=1;i<5;i++){
            x_temp1+=1;
            y_temp1-=1;
            if(y_temp1<0||x_temp1>this.width)
                break;
            if(this.arrMapShow[x_temp1][y_temp1]==black_or_white)
                num++;
            else
                break;
        }
        
        return max_num;
    }
    //判断位置是否已经落子-chessExist
    public boolean chessExist(int i,int j) {
        if(this.arrMapShow[i][j] == 1 || this.arrMapShow[i][j] == 2)//判断位置是否已经落子
            return true;
        return false;
    }
    //判断该坐标位置是否可下棋子-readyplay
    public void readyplay(int x,int y) {
        if(badxy(x,y))//判断是否越界
            return;
        if(chessExist(x,y))//判断是否已经落子
            return;
        this.arrMapShow[x][y]=3;//设置为3，可以落子
    }
    //在该坐标位置下棋子-play
    public void play(int x,int y) {
        if(badxy(x,y))
            return;//判断是否越界
        if(chessExist(x,y)) {
            this.isExist=true;
            return;//落子位置已经有子
        }else {
            this.isExist=false;
        }
        if(getisOdd()) {
            setisOdd(false);
            this.arrMapShow[x][y]=1;//先设置isOdd再下子
        }else {
            setisOdd(true);
            this.arrMapShow[x][y]=2;
        }
    }
    
    /**
     * 计算机走棋
     * 说明：
     * 用穷举法判断每一个坐标点的四个方向的的最大棋子数
     * 最后得出棋子数最大值的坐标
     * 下子
     * 
     */
    public void computerDo(int width,int height) {
        int max_black;
        int max_white;
        int max_temp;
        int max=0;
        
        setisOdd(true);
        for(int i=0;i<=width;i++) {
            for(int j=0;j<=height;j++) {
                if(!chessExist(i,j)) {
                    //如果当前位置没有落子
                    max_white=checkMax(i,j,2);//判断白子的最大值
                    max_black=checkMax(i,j,1);//判断黑子的最大值
                    max_temp=Math.max(max_white, max_black);
                    if(max_temp>max) {//最大值的坐标
                        max=max_temp;
                        this.x=i;
                        this.y=j;
                    }
                }
            }
        }
        
        setX(this.x);
        setY(this.y);
        this.arrMapShow[this.x][this.y]=2;//下子
    }
    
    //判断胜负
    public boolean judgeSuccess(int x,int y,boolean isOdd) {
        int num=1;
        int arrvalue;
        int x_temp=x;
        int y_temp=y;
        
        if(isOdd)//白子落子后判断胜负
            arrvalue=2;
        else//黑子落子后判断胜负
            arrvalue=1;
        
        int x_temp1=x_temp;
        int y_temp1=y_temp;
        
        //判断右边-x+
        for(int i=1;i<6;i++) {
            x_temp1+=1;
            if(x_temp1>this.width)
                break;
            if(this.arrMapShow[x_temp1][y_temp1]==arrvalue)
                num++;
            else
                break;
        }
        //判断左边-x-
        x_temp1=x_temp;
        for(int i=1;i<6;i++){
            x_temp1-=1;
            if(x_temp1<0)
                break;
            if(this.arrMapShow[x_temp1][y_temp1]==arrvalue)
                num++;
            else
                break;
        }
        if(num==5)
            return true;
        //判断上方-x,y-
        x_temp1=x_temp;
        y_temp1=y_temp;
        num=1;
        for(int i=1;i<6;i++){
            y_temp1-=1;
            if(y_temp1<0)
                break;
            if(this.arrMapShow[x_temp1][y_temp1]==arrvalue)
                num++;
            else
                break;
        }
        //判断下方-y+
        y_temp1=y_temp;
        for(int i=1;i<6;i++){
            y_temp1+=1;
            if(y_temp1>this.height)
                break;
            if(this.arrMapShow[x_temp1][y_temp1]==arrvalue)
                num++;
            else
                break;
        }
        if(num==5)
            return true;
        //判断左上-x-,y-
        x_temp1=x_temp;
        y_temp1=y_temp;
        num=1;
        for(int i=1;i<6;i++){
            x_temp1-=1;
            y_temp1-=1;
            if(y_temp1<0||x_temp1<0)
                break;
            if(this.arrMapShow[x_temp1][y_temp1]==arrvalue)
                num++;
            else
                break;
        }
        //判断右下-x+,y+
        x_temp1=x_temp;
        y_temp1=y_temp;
        for(int i=1;i<6;i++){
            x_temp1+=1;
            y_temp1+=1;
            if(y_temp1>this.height || x_temp1>this.width)
                break;
            if(this.arrMapShow[x_temp1][y_temp1]==arrvalue)
                num++;
            else
                break;
        }
        if(num==5)
            return true;
        //判断右上-x+,y-
        x_temp1=x_temp;
        y_temp1=y_temp;
        num=1;
        for(int i=1;i<6;i++){
            x_temp1+=1; 
            y_temp1-=1;
            if(y_temp1<0||x_temp1>this.width)
                break;
            if(this.arrMapShow[x_temp1][y_temp1]==arrvalue)
                num++;
            else break;
        }
        //判断左下-x-,y+
        x_temp1=x_temp;
        y_temp1=y_temp;
        for(int i=1;i<6;i++){
            x_temp1-=1;
            y_temp1+=1;
            if(y_temp1>this.height || x_temp1<0)
                break;
            if(this.arrMapShow[x_temp1][y_temp1]==arrvalue)
                num++;
            else
                break;
        }
        if(num==5)
            return true;
        
        return false;
    }
    
    //赢棋后的提示，根据判断是否为人机模式，以及胜负关系，显示不同的消息
    public void showSuccess(JPanel jpanel) {
        if(ChessFrame.iscomputer) {
            JOptionPane.showMessageDialog(jpanel, "你赢啦！","win",JOptionPane.INFORMATION_MESSAGE);
            System.out.println("win");
        }else {
            if(isOdd) {
                JOptionPane.showMessageDialog(jpanel, "白棋赢！","win",JOptionPane.INFORMATION_MESSAGE);
                System.out.println("白棋win");
            }else {
                JOptionPane.showMessageDialog(jpanel, "黑棋赢！","win",JOptionPane.INFORMATION_MESSAGE);
                System.out.println("黑棋win");
            }
        }
    }
    
    //输棋后的提示
    public void showDefault(JPanel jpanel) {
        System.out.println("lost");
        JOptionPane.showMessageDialog(jpanel, "很遗憾，你输了！请重新开始！","lost",JOptionPane.INFORMATION_MESSAGE);
    }
}

MainPanel.java

package wuziqii;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import javax.swing.JPanel;

/**
 * 功能如下:
 * 1、构建一个面板，在该面板上画上棋盘；
 * 2、处理在该棋盘上的鼠标事件（如鼠标左键点击、鼠标右键点击、鼠标拖动等）
 * @author Administrator
 *
 */
@SuppressWarnings("serial")
public class MainPanel extends JPanel implements MouseListener,MouseMotionListener {
    private int width;//棋盘的宽度
    private int height;//棋盘的高度
    private ChessModel chessmodel;
    
    //根据棋盘模式设定面板的大小-MainPanel(ChessModel cm)
    MainPanel(ChessModel cm){
        chessmodel=cm;
        width=chessmodel.getWidth();
        height=chessmodel.getHeight();
        addMouseListener(this);
    }
    
    //根据棋盘模式设定棋盘的宽度和高度-setModel(ChessModel cm)
    public void setModel(ChessModel cm){
        chessmodel=cm;
        width=chessmodel.getWidth();
        height =chessmodel.getHeight();
    }
    
    //根据坐标计算出棋盘方格棋子的信息（如白子还是黑子）,然后调用draw方法在棋盘上画出相应的棋子-paintComponent(Graphocs g)
    public void paintComponent(Graphics graphics){
        super.paintComponent(graphics);
        for(int j= 0;j<=height; j++){
            for(int i=0;i <=width; i++){
                int v= chessmodel.getarrMapShow()[i][j];
                draw(graphics,i,j,v);
            }
        }
    }
    
    //根据提供的棋子信息（颜色、坐标）画棋子
    public void draw(Graphics graphics,int i, int j,int v){
        int x=20*i+20;
        int y=20*j+20;
        //画棋盘
        if(i!=width&&j!=height){
            graphics.setColor(Color.white);
            graphics.drawRect(x,y,20,20);
        }
        //画黑色棋子
        if(v== 1){
            graphics.setColor(Color.gray);
            graphics.drawOval(x-8,y-8,16,16);
            graphics.setColor(Color.black);
            graphics.fillOval(x-8,y-8,16,16);
        }
        //画白色棋子
        if(v== 2){
            graphics.setColor(Color.gray);
            graphics.drawOval(x-8,y-8,16,16);
            graphics.setColor(Color.white);
            graphics.fillOval(x-8,y-8,16,16);
        }
        if(v==3){
            graphics.setColor(Color.cyan);
            graphics.drawOval(x-8,y-8,16,16);
        }
    }
    
    //响应鼠标的点击事件，根据鼠标的点击来下棋,根据下棋判断胜负等
    public void mousePressed(MouseEvent mouseevent){
        int x=(mouseevent.getX()-10)/20;
        int y=(mouseevent.getY()-10)/20;
        System.out.println("----------------------------------");
        System.out.println("x="+x+",y="+y);
        if(mouseevent.getModifiers()==MouseEvent.BUTTON1_MASK){
            chessmodel.play(x,y);
            //true-白棋，false-黑棋，人人对弈模式
            System.out.println("黑棋(false),白棋(true):"+chessmodel.getisOdd());
            //黑棋输出为1，白棋输出为2
            System.out.println("黑棋(1),白棋(2):"+chessmodel.getarrMapShow()[x][y]);
            repaint();
            //判断是否胜利并显示消息
            if(chessmodel.judgeSuccess(x,y,chessmodel.getisOdd())){
                chessmodel.showSuccess(this);
                mouseevent.consume();
                ChessFrame.iscomputer=false;
            }
            //判断是否为人机对弈
            //当机器获胜，上一个if语句无效
            if(ChessFrame.iscomputer&&!chessmodel.getisExist()){
                //当是人机模式，且棋盘上有子时，计算机走下一步
                chessmodel.computerDo(chessmodel.getWidth(),chessmodel.getHeight());
                repaint();
                if(chessmodel.judgeSuccess(chessmodel.getX(),chessmodel.getY(),chessmodel.getisOdd())){
                    chessmodel.showDefault(this);//调用ChessModel的showDefault()方法
                    mouseevent.consume();
                }
            }
        }
    }
    
    public void mouseClicked(MouseEvent evt){}
    public void mouseReleased(MouseEvent evt){}
    public void mouseEntered(MouseEvent mouseevt){}
    public void mouseExited(MouseEvent mouseevent){}
    public void mouseDragged(MouseEvent evt){}
    
    //响应鼠标的拖动事件
    public void mouseMoved(MouseEvent mouseevent){
        int x=(mouseevent.getX()-10)/ 20;
        int y=(mouseevent.getY()-10)/ 20;
        chessmodel.readyplay(x,y);
        repaint();
    }
}