maincontrol.java~6~

Java做的黑白棋

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

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

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

                        break;
                        //如果出现“空格”，则没法吃棋，直接跳出
                    }

                    else if (matrix[m][n] == ( -1) * side) {
                        //如果仍为与当前棋子不同颜色的棋子，则继续往下走
                    }
                }
            }
        }
        //////////////////////////////////////////////////////////////////////
        //右下
        //////////////////////////////////////////////////////////////////////
        if (i != 7 && j != 7) {
            //如果不为最后一列或最后一列，则向右下搜索
            if (matrix[i + 1][j + 1] == ( -1) * side) {
                //说明在“右下”这个方向是对方的棋子，则还有检索下去的必要
                for (int m = i + 2, n = j + 2; m <= 7 && 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] += ( m - i );
                        //side方增加的棋子：吃掉的加上刚加入的一个
                        //chessNum[(-1)*side + 1] -= ( m - i -1 );
                        //对方损失的棋子：被吃掉的夹在中间的棋子

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

                        break;
                        //如果出现“空格”，则没法吃棋，直接跳出
                    }

                    else if (matrix[m][n] == ( -1) * side) {
                        //如果仍为与当前棋子不同颜色的棋子，则继续往下走
                    }
                }
            }
        }
        //////////////////////////////////////////////////////////////////////
    }

    public void computerMove(int side) {
        //side参数表明电脑执哪一方棋子
        //电脑走棋的方法:主要分为两部分
        //1、通过估价函数确定在哪里下棋最好
        //2、调用eat()方法吃棋并进行一些判断及处理工作
        double max_score = -456231;
        double score = 0;
        //总得分
        int object_i = 0;
        int object_j = 0;
        //目标点的坐标
        int temp_matrix[][] = new int[8][8];
        //用于暂存矩阵
        temp_matrix = matrix;
        //暂存matrix
        for (int i = 0; i < LINE_NUM; i++) {
            for (int j = 0; j < COLUMN_NUM; j++) {
                if (matrix[i][j] > 1) {
                    //说明为电脑可下棋的位置
                    //则计算这一点的总得分，最后取总得分最高的点的坐标赋给：i,j
                    //总得分由三部分组成：1、本位置权重2、若放在这个地方能吃掉对方的棋子数3、若走了这一步留给对方的所有可走地方的平均权重
                    int first = 0, second = 0;
                    double third = 0;
                    int sum = 0;
                    //三部分
                    first = WEIGHT[i][j];
                    //本位置权重
                    //第二部分，要采用"预执行"的方法，即假设走了这一步，看看结果如何，故得先保存原先的matrix，一会儿再恢复

                    //下面假设走了这一步棋,走之前先记录先前的黑子白子的数量
//                    chessNum[0] = 0 ;
//                    chessNum[2] = 0 ;
//                    for( int ii = 0 ; ii < LINE_NUM ; ii++ )
//                    {
//                      for( int jj = 0 ; jj < COLUMN_NUM ; jj++ )
//                      {
//                          if( matrix[ii][jj] == -1 )
//                          {
//                             //黑子
//                             chessNum[0]++;
//                          }
//                          else if( matrix[ii][jj] == 1 )
//                          {
//                             //白子
//                             chessNum[2]++;
//                          }
//                      }
//                    }
//                    int black = 0 , white = 0;
//                    black = chessNum[0];
//                    white = chessNum[2];
//                    eat( i , j , COMPUTER );
//                    //吃棋,同时修改matrix的值
//                    //下面看修改了matrix的值之后，黑白两方的子的多少，以得出吃子的多少
//                    chessNum[0] = 0 ;
//                    chessNum[2] = 0 ;
//                    for( int ii = 0 ; ii < LINE_NUM ; ii++ )
//                    {
//                      for( int jj = 0 ; jj < COLUMN_NUM ; jj++ )
//                      {
//                          if( matrix[ii][jj] == -1 )
//                          {
//                             //黑子
//                             chessNum[0]++;
//                          }
//                          else if( matrix[ii][jj] == 1 )
//                          {
//                             //白子
//                             chessNum[2]++;
//                          }
//                      }
//                    }
//                    //假设电脑把棋子放在这里，让电脑先吃掉棋子，然后看能吃几个棋子
//                    second = chessNum[COMPUTER + 1]    -   ( ( COMPUTER == -1 ) ?  black : white );
//                    //得到吃棋数,计算方法(后来的减去原来的)
//                    chessNum[0] = 0 ;
//                    chessNum[2] = 0 ;
//                    checkObjects( PEOPLE );
//                    //看看此时人在哪些地方还可以走
//                    //修改了matrix的值
//                    for(  int m = 0 ; m < LINE_NUM ; m++ )
//                    {
//                      for( int n = 0 ; n < COLUMN_NUM ; n++ )
//                      {
//                         if( matrix[m][n] > 1 )
//                         {
//                                sum += WEIGHT[m][n];
//                         }
//                      }
//                    }
//                    third = sum / objectPlaces;
                    score = first + second - third;
                    //得到最后分数
                    if (score >= max_score) {
                        max_score = score;
                        //如果本位置的得分高于先前的最高得分，则覆盖先前的位置
                        object_i = i;
                        object_j = j;
                    }
                    matrix[i][j] = 0;
                }
                // this.setMatrix( temp_matrix );

            }
        }
        //完成循环后：得分最高的点的坐标已放在object_i 和 object_j 中
        //此时，还要记得恢复由于“预操作”所破坏掉的矩阵
        //this.setMatrix( temp_matrix );
        System.out.println("object_x :" + object_i + "   object_y :" + object_j);

//            for( int i = 0 ; i < LINE_NUM ; i++ )
//            {
//                for( int j = 0 ; j < COLUMN_NUM ; j++ )
//                {
//                    if( matrix[i][j] > 1  )
//                    {
//                        matrix[i][j] = 0 ;
//                        //若为可以到达的地方则这时这些地方已经没有用了，可以将其释放了
//                    }
//                }
//            }
        objectPlaces = 0;
        //重新初始化这个变量

        eat(object_i, object_j, side);
        //电脑按照他所认为的最好的一步棋走棋
        System.out.println("电脑吃棋完毕!下面检测人是否有棋可走!");
        //pause(1000);
        //暂停一段时间
//            try
//            {
//                Thread.sleep(4000);
//            }
//            catch( Exception e )
//            {
//
//            }
        repaint();

        for (int p = 0; p < LINE_NUM; p++) {
            for (int q = 0; q < COLUMN_NUM; q++) {
                System.out.print(matrix[p][q] + " ");
            }
            System.out.println();
        }

        nextToGo = PEOPLE;
        //把下一步走棋权交给人

        checkObjects(nextToGo);
        System.out.println((objectPlaces == 0) ? "人无棋可走!" : "人有棋可走!");
//        int exchange = 0;
//        //交换次数，用来判断是否出现死锁情况！
//            while( 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();
//                        checkObjects(-1);
//                        mode =-5;
//                        repaint();
//                        //重新开局，重新初始化矩阵
//                    }
//                    break;
//                }
//                //如果出现当前方nextToGo无法走棋的情况，则弹出提示信息告知用户，然后把走棋权交给对方，尤其注意死锁的情况，即两方都无法走棋时，则游戏中止
//                String msg = "";
//                //弹出对话框消息内容
//                if( nextToGo == -1 )
//                {
//                    msg = "黑棋无棋可走,必须停走一步！\n白棋连走一步！";
//                }
//                else
//                {
//                    msg = "白棋无棋可走,必须停走一步！\n黑棋连走一步！";
//