maincontrol.java~8~

Java做的黑白棋

        super.paint(g);
        //g.setXORMode( Color.GREEN );
        //int [][] matrix = this.getMatrix();
        int i = 0, j = 0;
        //后面循环用计数值
        //int x = 0 , y = 0 ;
        //棋子中心点的横纵座标
        chessNum[0] = 0;
        chessNum[2] = 0;

        //g.setColor( new Color( 122 , 132 ,156 ) );
        g.setColor(Color.pink);
        g.fillRect(DX, DY, INTERVAL * LINE_NUM, INTERVAL * COLUMN_NUM);
        {
            g.setColor(Color.blue);
            for (i = 0; i < LINE_NUM + 1; i++) {
                g.drawLine(DX, DY + INTERVAL * i, DX + INTERVAL * COLUMN_NUM,
                           DY + INTERVAL * i);
            }
            //画横线

            for (i = 0; i < COLUMN_NUM + 1; i++) {
                g.drawLine(DX + INTERVAL * i, DY, DX + INTERVAL * i,
                           DY + INTERVAL * LINE_NUM);
            }
            //画竖线
        }
        //应该根据matrix数组来画图，而不是每次都画一个完整的初始图，没分析清楚就去画图，浪费了大量的时间，吸取教训
        for (i = 0; i < LINE_NUM; i++) {
            for (j = 0; j < COLUMN_NUM; j++) {
                //尤其注意：这里的(i,j)指的是后台的矩阵的下标，在画图时尤其注意从后台矩阵到前台界面坐标的转化
                if (matrix[i][j] == -1) {
                    //画黑子
                    g.setColor(Color.black);
                    g.drawOval(DX + j * INTERVAL + (INTERVAL - D) / 2,
                               DY + i * INTERVAL + (INTERVAL - D) / 2, D, D);
                    g.setColor(Color.black);
                    g.fillOval(DX + j * INTERVAL + (INTERVAL - D) / 2,
                               DY + i * INTERVAL + (INTERVAL - D) / 2, D, D);
                    chessNum[0]++;
                } else if (matrix[i][j] == 1) {
                    //画白子
                    g.setColor(Color.WHITE);
                    g.drawOval(DX + j * INTERVAL + (INTERVAL - D) / 2,
                               DY + i * INTERVAL + (INTERVAL - D) / 2, D, D);
                    g.setColor(Color.WHITE);
                    g.fillOval(DX + j * INTERVAL + (INTERVAL - D) / 2,
                               DY + i * INTERVAL + (INTERVAL - D) / 2, D, D);
                    chessNum[2]++;
                } else if (matrix[i][j] > 1) {
                    if (direct.getState()) {
                        //画“X”，标志下一步可到达之处
                        /**/
                        g.setColor(Color.RED);
                        //g.setFont( new Font("隶书", Font.BOLD, 25) );
                        g.drawString("X", DX + j * INTERVAL + INTERVAL / 2,
                                     DY + i * INTERVAL + INTERVAL / 2);
                    }

                }
            }
        }
        {
//            for( int a = 0 ; a < LINE_NUM ; a++ )
//            {
//                for( int b = 0 ; b < COLUMN_NUM ; b++ )
//                {
//                    if()
//                    {}
//                }
//            }
            g.setColor(Color.RED);
            g.drawString("黑方棋子数：" + chessNum[0], 10, 420);
            //g.drawString( "白方棋子数：" + chessNum[2] , 180 , 420 );
            //g.drawString( "白方棋子数：" + chessNum[2] , 120 , 420 );
            g.drawString("白方棋子数：" + chessNum[2], 100, 420);
            g.drawString("空棋数：" + (64 - chessNum[0] - chessNum[2]), 190, 420);
            if (nextToGo == -1) {
                g.drawString("轮到 黑方 走棋！", 270, 420);
            } else if (nextToGo == 1) {
                g.drawString("轮到 白方 走棋！", 270, 420);
            }
        }
        if (needSpecialPaint) {
            needSpecialPaint = false;
            //特殊处理完了之后就不需要再特殊处理了，除非另一次特殊请求激活它
        }
        chessNum[0] = 0;
        chessNum[2] = 0;
    }

    //////////////////////////////////////////////////////
    /*鼠标事件的各项监听*/
    public void mouseExited(MouseEvent e) {
        //repaint();
    }

    public void mouseEntered(MouseEvent e) {
        //repaint();
    }

    public void mouseReleased(MouseEvent e) {
        //repaint();
    }

    public void mousePressed(MouseEvent e) {
        //repaint();
    }

    public void mouseClicked(MouseEvent e) {
        int windowX = e.getX();
        int windowY = e.getY();
        //先获取当前点击点的横纵座标，然后根据这两个座标判断是否为有效棋子
        int line = 0;
        int column = 0;
        line = (int) ((windowX - DX) / INTERVAL);
        column = (int) ((windowY - DY) / INTERVAL);
        //求出了前台坐标上的行和列，并不是矩阵上的行与列，注意！正好反了！

        if ( /*当前选择的是两人对弈*/mode == 0) {
            //则按部就班的来
            two_persons_response(line, column, nextToGo);
        } else if ( /*当前选择的是人机对战*/mode == 1 || mode == 2) {
            //并根据谁执黑修改nextToGo的初始值，总而言之，黑棋是首先走的
//            if( mode == 1 )
//            {
//                //计算机执黑，则计算机先走
//                //nextToGo = COMPUTER;
//            }
//            else if( mode == 2 )
//            {
//                //计算机执白,则人先走
//                //nextToGo = ;
//            }

            if (nextToGo == PEOPLE) {
                //则正常监听，并进行走棋
                System.out.println("该人走棋了 !");
                two_persons_response(line, column, nextToGo);
//                System.out.println("走完棋后的矩阵如下：");
//                for( int aa= 0 ; aa < 8 ; aa++ )
//                {
//                    for( int bb= 0 ; bb < 8 ; bb++ )
//                    {
//                        System.out.print(matrix[aa][bb]+"  ");
//                    }
//                    System.out.println();
//                }
                repaint();
                System.out.println("现在的nextToGo值为: " + nextToGo);
                //暂停一段时间
//                try
//                {
//                  Thread.sleep(1000);
//                  Thread.yield();
//                }
//                catch( Exception e1 )
//                {
//
//                }
//                long pre = System.currentTimeMillis();
//                for( int time = 0 ; time < 1000000000 ; time++ )
//                {
//
//                }
//                long latter = System.currentTimeMillis();
//                System.out.println( latter - pre );
                computerMove(COMPUTER);
                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]++;
                        }
                    }
                }

                if (chessNum[0] + chessNum[2] == 64)
                {
                    ini();
                    mode = -5;
                    repaint();
                }
                chessNum[0] = 0;
                chessNum[2] = 0;
            } else if (nextToGo == COMPUTER) {
                //调用电脑自动走棋的函数，使电脑走棋

            }
        } else if ( /*当前选择的是网络对战*/mode == 3) {
            /*谁先走棋按随机方法产生*/
            /*这一点类似操作系统中刚学的管道的用法，相当于两个联机对战的机器间建立了一个管道，并通过这个管道传递信息，一端传一端接收*/
            if ( /*该本机走棋了*/true) {
                //正常监听，并把欲走棋点坐标通过网络传给对手(同时反映在自己这一边的屏幕上，对手接受到信息后反映在他那一方)
            } else if ( /*该对手走了*/true) {
                //这边点击鼠标没任何反应，此时应等待对方动作
                //有一个方法等待并接受对方传过来的走棋信息反映在自己这一方的棋盘上
            }
        }
    }

    public void mouseClicked2(MouseEvent e) {
        //点击鼠标后的动作(响应事件)

        //只要能进入这里，就一定能保证现在已经可以走棋了并且点击了鼠标(否则根本不会有点击鼠标的机会，既然能点击鼠标了，说明轮空情况已过)，即当前要走的一方必然有地方放棋子！否则，就在下面一直弹出对话框让对方先走
        //点击鼠标后，要先后做一下几件事情：
        //1、先检测该点是否可放置当前方的棋子，若不能，则声音提示( ao ao )
        //2、若能，则先在选中点处绘制当前方颜色的棋子，并检测由于该棋子的加入所能吃掉的对方的棋子，改变其矩阵matrix的值
        //3、修改nextToGo = -1*(nextToGo)
        //4、调用checkObjects( nextToGo ),查找下一步能放棋子的地方，若objectPlaces为0,则弹出对话框，提示用户轮空，
        //同时修改nextToGo = ( -1 )*nextToGo,再次调用checkObjects()方法
        //调用checkObject()方法，看下一步能到达哪些地方，修改matrix的值并repaint(),但在调用之前注意释放之前那些大于1的matrix的值，并重新初始化objectPlaces为0
        //若可走通，则更新matrix并调用repaint()方法针对新的matrix进行重绘
        //5、循环判断是否有一方棋子数已经为0，若有则中止
        int windowX = e.getX();
        int windowY = e.getY();
        //JOptionPane.showMessageDialog( null , "x坐标："+windowX );
        //先获取当前点击点的横纵座标，然后根据这两个座标判断是否为有效棋子
        int line = 0;
        int column = 0;
        line = (int) ((windowX - DX) / INTERVAL);
        column = (int) ((windowY - DY) / INTERVAL);
        //求出了前台坐标上的行和列，并不是矩阵上的行与列，注意！正好反了！
        //JOptionPane.showMessageDialog( null , " x坐标："+line +"\n y坐标："+column);
        two_persons_response(line, column, nextToGo);
    }

    /*两人对弈时的相应方法*/
    public void two_persons_response(int line, int column, int side) {
        if (matrix[column][line] > 1) {
            //JOptionPane.showMessageDialog( null , "这里可以放棋子！" );
            //matrix[column][line] = nextToGo;
            //先在选中点处绘制当前方颜色的棋子
            //调用方法看因为该棋子的加入所能吃掉的对方的棋子，改变其矩阵matrix的值
            //借用线程休眠一定时间进行repaint(),注意美观性及用户用好性
            /*下面将要编的其实是release（）方法*/
            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;
            //重新初始化这个变量
            process.addElement(matrix);
            //把吃棋前的矩阵加入向量
            eat(column, line, nextToGo);
            ///////////////////////////
            repaint();
            ///////////////////////////
            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]++;
                    }
                }
            }

            if (chessNum[0] == 0 || chessNum[2] == 0) {
                //说明有一方的棋子数为0，则弹出
                //还得判断输赢情况，双方棋子比例！告知用户！
                String res = "";
                //比赛结果
                if (chessNum[0] > chessNum[2]) {
                    res = "黑棋获胜！";