maincontrol.java~8~

Java做的黑白棋

                } else if (chessNum[0] < chessNum[2]) {
                    res = "白棋获胜！";
                } else {
                    res = "平局！";
                }

                JOptionPane.showMessageDialog(null,
                                              "本局游戏结束！\n" + res + "黑棋 " +
                                              chessNum[0] + " :" + chessNum[2] +
                                              " 白棋 ");
                ini();
                mode = -5;
                repaint();
                //重新开局，重新初始化矩阵
                return;
            }
            if (chessNum[0] + chessNum[2] >= 64) {
                String res = "";
                //比赛结果
                if (chessNum[0] > chessNum[2]) {
                    res = "黑棋获胜！";
                } else if (chessNum[0] < chessNum[2]) {
                    res = "白棋获胜！";
                } else {
                    res = "平局！";
                }
                repaint();
                JOptionPane.showMessageDialog(null,
                                              "本局游戏结束！\n" + res + "黑棋 " +
                                              chessNum[0] + " :" + chessNum[2] +
                                              " 白棋 ");
                ini();
                mode = -5;
                checkObjects( -1);
                repaint();
                //重新开局，重新初始化矩阵
                return;
            }
            repaint();

            nextToGo *= ( -1);
            //交换下一步走棋的人
            checkObjects(nextToGo);

            int exchange = 0;
            //交换次数，用来判断是否出现死锁情况！
            while (objectPlaces == 0)
            //if( objectPlaces == 0 )
            {
                exchange++;
                //交换次数加1
                if (exchange == 2) {
                    //还得判断输赢情况，双方棋子比例！告知用户！
                    String res = "";
                    //比赛结果
                    if (chessNum[0] > chessNum[2]) {
                        res = "黑棋获胜！";
                    } else if (chessNum[0] < chessNum[2]) {
                        res = "白棋获胜！";
                    } else {
                        res = "平局！";
                    }
                    if (chessNum[0] + chessNum[2] < 64) {
                        JOptionPane.showMessageDialog(null,
                                "双方均无棋可走，本局游戏结束！\n" + res + "黑棋 " + chessNum[0] +
                                " :" + chessNum[2] + " 白棋 ");
                        ini();
                        mode = -5;
                        checkObjects( -1);
                        repaint();
                        //重新开局，重新初始化矩阵
                    }
                    break;
                    //return;
                }
                //如果出现当前方nextToGo无法走棋的情况，则弹出提示信息告知用户，然后把走棋权交给对方，尤其注意死锁的情况，即两方都无法走棋时，则游戏中止
                String msg = "";
                //弹出对话框消息内容
                if (nextToGo == -1) {
                    msg = "黑棋无棋可走,必须停走一步！\n白棋连走一步！";
                } else {
                    msg = "白棋无棋可走,必须停走一步！\n黑棋连走一步！";
                }
                JOptionPane.showMessageDialog(null, msg);

                process.addElement(matrix);
                //把吃棋前的矩阵加入向量

                //System.exit( 0 );
                nextToGo *= ( -1);
                //交换下一步走棋的人
                checkObjects(nextToGo);
            }
            //从while循环中出来时已经保证已经有可放棋子的地方
            exchange = 0;
            //清0
            repaint();
        } else {
            //播放声音警告、声音提示( ao ao )，导入音频文件
            JOptionPane.showMessageDialog(null, "这里不能放棋子！");
            repaint();
            //System.exit( 0 );
        }
    }

    public
    /*static*/ void eat(int i, int j, int side) {
        //从8个方向上来看side这一方由于这一棋子(i,j)的加入所能吃掉的对方的棋子，并修改对应的matrix的值
        //紧挨着的是对方的棋子，并且有自方的棋子可以截至，中间若遇到空格则直接跳出，对方棋子则继续往下走，自方棋子则吃掉中间夹着的棋子(利用for循环，里面有一个计数器)并跳出
        //上
        //////////////////////////////////////////////////////////
        if (i != 0) {
            //如果不为第一行，则向上搜索
            if (matrix[i - 1][j] == ( -1) * side) {
                //说明在“上”这个方向是对方的棋子，则还有检索下去的必要
                for (int m = i - 2; m >= 0; m--) {
                    if (matrix[m][j] == side) {
                        for (int l = i; l >= m; l--) {
                            matrix[l][j] = side;
                            //中间夹着的所有棋子全部变为刚走的棋子(吃棋的一方)
                        }
                        //chessNum[side + 1] += ( i - m );
                        //side方增加的棋子：吃掉的加上刚加入的一个
                        //chessNum[(-1)*side + 1] -= ( i - m -1);
                        //对方损失的棋子：被吃掉的夹在中间的棋子
                        break;
                        //如果"遭遇"相同的棋子，则这个棋子就是吃棋的信号、或称导火索、终结符，停止搜索，跳出
                    } else if (matrix[m][j] == 0) {
                        break;
                        //如果出现“空格”，则没法吃棋，直接跳出
                    } else if (matrix[m][j] == ( -1) * side) {
                        //如果仍为与当前棋子不同颜色的棋子，则继续往下走
                    }
                }
            }
        }
        ///////////////////////////////////////////////////////////////////////

        //下
        //////////////////////////////////////////////////////////////////////
        if (i != 7) {
            //如果不为最后一行，则向下搜索
            if (matrix[i + 1][j] == ( -1) * side) {
                //说明在“下”这个方向是对方的棋子，则还有检索下去的必要
                for (int m = i + 2; m <= 7; m++) {
                    if (matrix[m][j] == side) {
                        for (int l = i; l <= m; l++) {
                            matrix[l][j] = side;
                            //中间夹着的所有棋子全部变为刚走的棋子(吃棋的一方)
                        }
                        //chessNum[side + 1] += ( m - i );
                        //side方增加的棋子：吃掉的加上刚加入的一个
                        //chessNum[(-1)*side + 1] -= ( m - i -1);
                        //对方损失的棋子：被吃掉的夹在中间的棋子

                        break;
                        //如果"遭遇"相同的棋子，则这个棋子就是吃棋的信号、或称导火索、终结符，停止搜索，跳出
                    } else if (matrix[m][j] == 0) {
                        break;
                        //如果出现“空格”，则没法吃棋，直接跳出
                    } else if (matrix[m][j] == ( -1) * side) {
                        //如果仍为与当前棋子不同颜色的棋子，则继续往下走
                    }
                }
            }
        }
        //////////////////////////////////////////////////////////////////////
        //左
        //////////////////////////////////////////////////////////
        if (j != 0) {
            //如果不为第一列，则向左搜索
            if (matrix[i][j - 1] == ( -1) * side) {
                //说明在“左”这个方向是对方的棋子，则还有检索下去的必要
                for (int m = j - 2; m >= 0; m--) {
                    if (matrix[i][m] == side) {
                        for (int l = j; l >= m; l--) {
                            matrix[i][l] = side;
                            //中间夹着的所有棋子全部变为刚走的棋子(吃棋的一方)
                        }
                        //chessNum[side + 1] += ( j - m );
                        //side方增加的棋子：吃掉的加上刚加入的一个
                        //chessNum[(-1)*side + 1] -= ( j - m -1);
                        //对方损失的棋子：被吃掉的夹在中间的棋子
                        break;
                        //如果"遭遇"相同的棋子，则这个棋子就是吃棋的信号、或称导火索、终结符，停止搜索，跳出
                    } else if (matrix[i][m] == 0) {
                        break;
                        //如果出现“空格”，则没法吃棋，直接跳出
                    } else if (matrix[i][m] == ( -1) * side) {
                        //如果仍为与当前棋子不同颜色的棋子，则继续往下走
                    }
                }
            }
        }
        ///////////////////////////////////////////////////////////////////////
        //右
        //////////////////////////////////////////////////////////////////////
        if (j != 7) {
            //如果不为最后一列，则向右搜索
            if (matrix[i][j + 1] == ( -1) * side) {
                //说明在“右”这个方向是对方的棋子，则还有检索下去的必要
                for (int m = j + 2; m <= 7; m++) {
                    if (matrix[i][m] == side) {
                        for (int l = j; l <= m; l++) {
                            matrix[i][l] = side;
                            //中间夹着的所有棋子全部变为刚走的棋子(吃棋的一方)
                        }
                        //chessNum[side + 1] += ( m - j );
                        //side方增加的棋子：吃掉的加上刚加入的一个
                        //chessNum[(-1)*side + 1] -= ( m - j -1);
                        //对方损失的棋子：被吃掉的夹在中间的棋子

                        break;
                        //如果"遭遇"相同的棋子，则这个棋子就是吃棋的信号、或称导火索、终结符，停止搜索，跳出
                    } else if (matrix[i][m] == 0) {
                        break;
                        //如果出现“空格”，则没法吃棋，直接跳出
                    } else if (matrix[i][m] == ( -1) * side) {
                        //如果仍为与当前棋子不同颜色的棋子，则继续往下走
                    }
                }
            }
        }
        //////////////////////////////////////////////////////////////////////
        //左上
        //////////////////////////////////////////////////////////////////////
        if (i != 0 && j != 0) {
            //如果不为第一列或第一列，则向左上搜索
            if (matrix[i - 1][j - 1] == ( -1) * side) {
                //说明在“左上”这个方向是对方的棋子，则还有检索下去的必要
                for (int m = i - 2, n = j - 2; m >= 0 && n >= 0; m--, n--) {
                    if (matrix[m][n] == side) {
                        //把先前的夹在中间的进行修改
                        for (int l = i, q = j; l >= m && q >= n; l--, q--) {
                            matrix[l][q] = side;
                            //中间夹着的所有棋子全部变为刚走的棋子(吃棋的一方)
                        }
                        //chessNum[side + 1] += ( i - m );
                        //side方增加的棋子：吃掉的加上刚加入的一个
                        //chessNum[(-1)*side + 1] -= ( i - m -1);
                        //对方损失的棋子：被吃掉的夹在中间的棋子
                        break;
                        //如果"遭遇"相同的棋子，则这个棋子就是吃棋的信号、或称导火索、终结符，停止搜索，跳出
                    } else if (matrix[m][n] == 0) {

                        break;
                        //如果出现“空格”，则没法吃棋，直接跳出
                    } else if (matrix[m][n] == ( -1) * side) {
                        //如果仍为与当前棋子不同颜色的棋子，则继续往下走
                    }
                }
            }
        }
        //////////////////////////////////////////////////////////////////////
        //右上
        //////////////////////////////////////////////////////////////////////
        if (i != 0 && j != 7) {
            //如果不为最后一列或第一行，则向右上搜索
            if (matrix[i - 1][j + 1] == ( -1) * side) {
                //说明在“右上”这个方向是对方的棋子，则还有检索下去的必要
                for (int m = i - 2, n = j + 2; m >= 0 && n <= 7; m--, n++) {
                    if (matrix[m][n] == side) {
                        //把先前的夹在中间的进行修改
                        for (int l = i, q = j; l >= m && q <= n; l--, q++) {
                            matrix[l][q] = side;
                            //中间夹着的所有棋子全部变为刚走的棋子(吃棋的一方)
                        }
                        //chessNum[side + 1] += ( i - m );
                        //side方增加的棋子：吃掉的加上刚加入的一个
                        //chessNum[(-1)*side + 1] -= ( i - m -1);
                        //对方损失的棋子：被吃掉的夹在中间的棋子

                        break;
                        //如果"遭遇"相同的棋子，则这个棋子就是吃棋的信号、或称导火索、终结符，停止搜索，跳出
                    } else if (matrix[m][n] == 0) {

                        break;