中国象棋(java)

   1 /*

   2  *中国象棋Java版V1.0

   3  * *源文件:Chess.java

   4  

   5  */

   6 

   7 import java.awt.*;

   8 import java.awt.event.*;

   9 import javax.swing.*;

  10 import java.util.*;

  11 import java.io.*;

  12 

  13 //主类

  14 public class Chess{

  15     public static void main(String args[]){

  16         new ChessMainFrame("中国象棋:观棋不语真君子,棋死无悔大丈夫");

  17     }

  18 }

  19 

  20 //主框架类

  21 class ChessMainFrame extends JFrame implements ActionListener,MouseListener,Runnable{

  22     //玩家

  23     JLabel play[] = new JLabel[32];

  24     //棋盘

  25     JLabel image;    

  26     //窗格

  27     Container con;

  28     //工具栏

  29     JToolBar jmain;    

  30     //重新开始

  31     JButton anew;

  32     //悔棋

  33     JButton repent;

  34     //退出

  35     JButton exit;

  36     //当前信息

  37     JLabel text;

  38     

  39     //保存当前操作

  40     Vector Var;

  41     

  42     //规则类对象(使于调用方法)

  43     ChessRule rule;

  44     

  45     /**

  46     ** 单击棋子

  47     ** chessManClick = true 闪烁棋子 并给线程响应

  48     ** chessManClick = false 吃棋子 停止闪烁  并给线程响应

  49     */

  50     boolean chessManClick;

  51     

  52     /**

  53     ** 控制玩家走棋

  54     ** chessPlayClick=1 黑棋走棋

  55     ** chessPlayClick=2 红棋走棋 默认红棋

  56     ** chessPlayClick=3 双方都不能走棋

  57     */

  58     int chessPlayClick=2;

  59     

  60     //控制棋子闪烁的线程

  61     Thread tmain;

  62     //把第一次的单击棋子给线程响应

  63     static int Man,i;

  64     

  65     ChessMainFrame(){

  66         new ChessMainFrame("中国象棋");

  67     }

  68     

  69     /**

  70     ** 构造函数

  71     ** 初始化图形用户界面

  72     */

  73     ChessMainFrame(String Title){

  74         //获行客格引用

  75         con = this.getContentPane();

  76         con.setLayout(null);

  77         //实例化规则类

  78         rule = new ChessRule();

  79         Var = new Vector();

  80         

  81         //创建工具栏

  82         jmain = new JToolBar();

  83         text = new JLabel("欢迎使用象棋对弈系统");

  84         //当鼠标放上显示信息

  85         text.setToolTipText("信息提示");

  86         anew = new JButton(" 新 游 戏 ");

  87         anew.setToolTipText("重新开始新的一局");

  88         exit = new JButton(" 退  出 ");

  89         exit.setToolTipText("退出象棋程序程序");

  90         repent = new JButton(" 悔  棋 ");

  91         repent.setToolTipText("返回到上次走棋的位置");

  92 

  93         //把组件添加到工具栏

  94         jmain.setLayout(new GridLayout(0,4));

  95         jmain.add(anew);

  96         jmain.add(repent);

  97         jmain.add(exit);

  98         jmain.add(text);

  99         jmain.setBounds(0,0,558,30);

 100         con.add(jmain);

 101         

 102         //添加棋子标签

 103         drawChessMan();

 104 

 105         //注册按扭监听

 106         anew.addActionListener(this);

 107         repent.addActionListener(this);

 108         exit.addActionListener(this);        

 109                 

 110         //注册棋子移动监听

 111         for (int i=0;i<32;i++){

 112             con.add(play[i]);

 113             play[i].addMouseListener(this);

 114         }

 115         

 116         //添加棋盘标签

 117         con.add(image = new JLabel(new ImageIcon("image\\Main.GIF")));

 118         image.setBounds(0,30,558,620);

 119         image.addMouseListener(this);

 120         

 121         //注册窗体关闭监听

 122         this.addWindowListener(

 123             new WindowAdapter() {

 124                 public void windowClosing(WindowEvent we){

 125                     System.exit(0);

 126                 }

 127             }

 128         );

 129         

 130         //窗体居中

 131         Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();

 132         Dimension frameSize = this.getSize();

 133         

 134         if (frameSize.height > screenSize.height){

 135             frameSize.height = screenSize.height;

 136         }

 137         if (frameSize.width > screenSize.width){

 138             frameSize.width = screenSize.width;

 139         }

 140         

 141         this.setLocation((screenSize.width - frameSize.width) / 2 - 280 ,(screenSize.height - frameSize.height ) / 2 - 350);

 142     

 143         //设置

 144         this.setIconImage(new ImageIcon("image\\红将.GIF").getImage());

 145         this.setResizable(false);

 146         this.setTitle(Title);

 147         this.setSize(558,670);

 148         this.show();

 149     }

 150     

 151     /**

 152     ** 添加棋子方法

 153     */

 154     public void drawChessMan(){

 155         //流程控制

 156         int i,k;

 157         //图标

 158         Icon in;

 159                 

 160         //黑色棋子

 161         

 162         //

 163         in = new ImageIcon("image\\黑车.GIF");

 164         for (i=0,k=24;i<2;i++,k+=456){        

 165             play[i] = new JLabel(in);

 166             play[i].setBounds(k,56,55,55);    

 167             play[i].setName("车1");            

 168         }    

 169         

 170         //

 171         in = new ImageIcon("image\\黑马.GIF");

 172         for (i=4,k=81;i<6;i++,k+=342){    

 173             play[i] = new JLabel(in);

 174             play[i].setBounds(k,56,55,55);

 175             play[i].setName("马1");

 176         }

 177         

 178         //

 179         in = new ImageIcon("image\\黑象.GIF");

 180         for (i=8,k=138;i<10;i++,k+=228){    

 181             play[i] = new JLabel(in);

 182             play[i].setBounds(k,56,55,55);

 183             play[i].setName("象1");

 184         }

 185         

 186         //

 187         in = new ImageIcon("image\\黑士.GIF");

 188         for (i=12,k=195;i<14;i++,k+=114){

 189             play[i] = new JLabel(in);

 190             play[i].setBounds(k,56,55,55);

 191             play[i].setName("士1");

 192         }

 193         

 194         //

 195         in = new ImageIcon("image\\黑卒.GIF");

 196         for (i=16,k=24;i<21;i++,k+=114){

 197             play[i] = new JLabel(in);

 198             play[i].setBounds(k,227,55,55);

 199             play[i].setName("卒1" + i);

 200         }

 201         

 202         //

 203         in = new ImageIcon("image\\黑炮.GIF");            

 204         for (i=26,k=81;i<28;i++,k+=342){

 205             play[i] = new JLabel(in);

 206             play[i].setBounds(k,170,55,55);

 207             play[i].setName("炮1" + i);

 208         }

 209         

 210         //

 211         in = new ImageIcon("image\\黑将.GIF");

 212         play[30] = new JLabel(in);

 213         play[30].setBounds(252,56,55,55);

 214         play[30].setName("将1");

 215 

 216         //红色棋子

 217         //

 218         in = new ImageIcon("image\\红车.GIF");

 219         for (i=2,k=24;i<4;i++,k+=456){

 220             play[i] = new JLabel(in);

 221             play[i].setBounds(k,569,55,55);

 222             play[i].setName("车2");

 223         }

 224         

 225         //

 226         in = new ImageIcon("image\\红马.GIF");

 227         for (i=6,k=81;i<8;i++,k+=342){

 228             play[i] = new JLabel(in);

 229             play[i].setBounds(k,569,55,55);

 230             play[i].setName("马2");

 231         }

 232         

 233         //

 234         in = new ImageIcon("image\\红象.GIF");            

 235         for (i=10,k=138;i<12;i++,k+=228){

 236             play[i] = new JLabel(in);

 237             play[i].setBounds(k,569,55,55);

 238             play[i].setName("象2");

 239         }

 240         

 241         //

 242         in = new ImageIcon("image\\红士.GIF");

 243         for (i=14,k=195;i<16;i++,k+=114){

 244             play[i] = new JLabel(in);

 245             play[i].setBounds(k,569,55,55);

 246             play[i].setName("士2");

 247         }

 248         

 249         //

 250         in = new ImageIcon("image\\红卒.GIF");

 251         for (i=21,k=24;i<26;i++,k+=114){

 252             play[i] = new JLabel(in);

 253             play[i].setBounds(k,398,55,55);

 254             play[i].setName("卒2" + i);

 255         }

 256         

 257         //

 258         in = new ImageIcon("image\\红炮.GIF");

 259         for (i=28,k=81;i<30;i++,k+=342){

 260             play[i] = new JLabel(in);

 261             play[i].setBounds(k,455,55,55);

 262             play[i].setName("炮2" + i);

 263         }

 264         

 265         //

 266         in = new ImageIcon("image\\红将.GIF");            

 267         play[31] = new JLabel(in);

 268         play[31].setBounds(252,569,55,55);        

 269         play[31].setName("帅2");

 270     }

 271     

 272     /**

 273     ** 线程方法控制棋子闪烁

 274     */

 275     public void run(){

 276         while (true){

 277             //单击棋子第一下开始闪烁

 278             if (chessManClick){

 279                 play[Man].setVisible(false);

 280 

 281                 //时间控制

 282                 try{

 283                     tmain.sleep(200);

 284                 }

 285                 catch(Exception e){

 286                 }

 287                 

 288                 play[Man].setVisible(true);

 289             }

 290             

 291             //闪烁当前提示信息 以免用户看不见

 292             else {

 293                 text.setVisible(false);

 294                 

 295                 //时间控制

 296                 try{

 297                     tmain.sleep(250);

 298                 }

 299                 catch(Exception e){

 300                 }

 301                 

 302                 text.setVisible(true);

 303             }

 304             

 305             try{

 306                 tmain.sleep(350);

 307             }

 308             catch (Exception e){

 309             }

 310         }

 311     }

 312     

 313     /**

 314     ** 单击棋子方法

 315     */

 316     public void mouseClicked(MouseEvent me){

 317         System.out.println("Mouse");

 318         

 319         //当前坐标

 320         int Ex=0,Ey=0;

 321         

 322         //启动线程

 323         if (tmain == null){

 324             tmain = new Thread(this);

 325             tmain.start();

 326         }

 327         

 328         //单击棋盘(移动棋子)

 329         if (me.getSource().equals(image)){

 330             //该红棋走棋的时候

 331             if (chessPlayClick == 2 && play[Man].getName().charAt(1) == '2'){    

 332                 Ex = play[Man].getX();

 333                 Ey = play[Man].getY();

 334                 //移动卒、兵

 335                 if (Man > 15 && Man < 26){

 336                     rule.armsRule(Man,play[Man],me);

 337                 }            

 338                 

 339                 //移动炮

 340                 else if (Man > 25 && Man < 30){            

 341                     rule.cannonRule(play[Man],play,me);

 342                 }

 343                 

 344                 //移动车

 345                 else if (Man >=0 && Man < 4){

 346                     rule.cannonRule(play[Man],play,me);

 347                 }

 348                 

 349                 //移动马

 350                 else if (Man > 3 && Man < 8){

 351                     rule.horseRule(play[Man],play,me);

 352                 }

 353                 

 354                 //移动相、象

 355                 else if (Man > 7 && Man < 12){

 356                     rule.elephantRule(Man,play[Man],play,me);

 357                 }

 358                 

 359                 //移动仕、士

 360                 else if (Man > 11 && Man < 16){

 361                     rule.chapRule(Man,play[Man],play,me);

 362                 }

 363                 

 364                 //移动将、帅

 365                 else if (Man == 30 || Man == 31){                

 366                     rule.willRule(Man,play[Man],play,me);

 367                 }

 368                 

 369                 //是否走棋错误(是否在原地没有动)

 370                 if (Ex == play[Man].getX() && Ey == play[Man].getY()){

 371                     text.setText("               红棋走棋");

 372                     chessPlayClick=2;

 373                 }

 374                 

 375                 else {

 376                     text.setText("               黑棋走棋");

 377                     chessPlayClick=1;

 378                 }

 379                 

 380             }//if

 381             

 382             //该黑棋走棋的时候

 383             else if (chessPlayClick == 1 && play[Man].getName().charAt(1) == '1'){

 384                 Ex = play[Man].getX();

 385                 Ey = play[Man].getY();

 386 

 387                 //移动卒、兵

 388                 if (Man > 15 && Man < 26){

 389                     rule.armsRule(Man,play[Man],me);

 390                 }

 391                 

 392                 //移动炮

 393                 else if (Man > 25 && Man < 30){

 394                     rule.cannonRule(play[Man],play,me);

 395                 }

 396                 

 397                 //移动车

 398                 else if (Man >=0 && Man < 4){

 399                     rule.cannonRule(play[Man],play,me);

 400                 }

 401                 

 402                 //移动马

 403                 else if (Man > 3 && Man < 8){

 404                     rule.horseRule(play[Man],play,me);

 405                 }

 406                 

 407                 //移动相、象

 408                 else if (Man > 7 && Man < 12){

 409                     rule.elephantRule(Man,play[Man],play,me);

 410                 }

 411                 

 412                 //移动仕、士

 413                 else if (Man > 11 && Man < 16){

 414                     rule.chapRule(Man,play[Man],play,me);

 415                 }

 416                 

 417                 //移动将、帅

 418                 else if (Man == 30 || Man == 31){

 419                     rule.willRule(Man,play[Man],play,me);

 420                 }

 421                 

 422                 //是否走棋错误(是否在原地没有动)

 423                 if (Ex == play[Man].getX() && Ey == play[Man].getY()){

 424                     text.setText("               黑棋走棋");

 425                     chessPlayClick=1;

 426                 }

 427                 

 428                 else {

 429                     text.setText("               红棋走棋");

 430                     chessPlayClick=2;    

 431                 }

 432 

 433                             

 434             }//else if        

 435             

 436             //当前没有操作(停止闪烁)

 437             chessManClick=false;

 438             

 439         }//if

 440         

 441         //单击棋子

 442         else{

 443             //第一次单击棋子(闪烁棋子)

 444             if (!chessManClick){

 445                 for (int i=0;i<32;i++){

 446                     //被单击的棋子

 447                     if (me.getSource().equals(play[i])){

 448                         //告诉线程让该棋子闪烁

 449                         Man=i;

 450                         //开始闪烁

 451                         chessManClick=true;

 452                         break;

 453                     }

 454                 }//for

 455             }//if

 456             

 457             //第二次单击棋子(吃棋子)

 458             else if (chessManClick){

 459                 //当前没有操作(停止闪烁)

 460                 chessManClick=false;

 461                 

 462                 for (i=0;i<32;i++){

 463                     //找到被吃的棋子

 464                     if (me.getSource().equals(play[i])){

 465                         //该红棋吃棋的时候

 466                         if (chessPlayClick == 2 && play[Man].getName().charAt(1) == '2'){

 467                             Ex = play[Man].getX();

 468                             Ey = play[Man].getY();

 469                             

 470                             //卒、兵吃规则

 471                             if (Man > 15 && Man < 26){

 472                                 rule.armsRule(play[Man],play[i]);

 473                             }

 474                             

 475                             //炮吃规则

 476                             else if (Man > 25 && Man < 30){

 477                                 rule.cannonRule(0,play[Man],play[i],play,me);

 478                             }

 479                             

 480                             //车吃规则

 481                             else if (Man >=0 && Man < 4){

 482                                 rule.cannonRule(1,play[Man],play[i],play,me);

 483                             }

 484                             

 485                             //马吃规则

 486                             else if (Man > 3 && Man < 8){

 487                                 rule.horseRule(play[Man],play[i],play,me);    

 488                             }

 489                             

 490                             //相、象吃规则

 491                             else if (Man > 7 && Man < 12){

 492                                 rule.elephantRule(play[Man],play[i],play);

 493                             }

 494                             

 495                             //士、仕吃棋规则

 496                             else if (Man > 11 && Man < 16){

 497                                 rule.chapRule(Man,play[Man],play[i],play);

 498                             }

 499                             

 500                             //将、帅吃棋规则

 501                             else if (Man == 30 || Man == 31){

 502                                 rule.willRule(Man,play[Man],play[i],play);

 503                                 play[Man].setVisible(true);    

 504                             }

 505                             

 506                             //是否走棋错误(是否在原地没有动)

 507                             if (Ex == play[Man].getX() && Ey == play[Man].getY()){

 508                                 text.setText("               红棋走棋");

 509                                 chessPlayClick=2;

 510                                 break;

 511                             }

 512                                                         

 513                             else{

 514                                 text.setText("               黑棋走棋");

 515                                 chessPlayClick=1;

 516                                 break;

 517                             }    

 518                             

 519                         }//if

 520                         

 521                         //该黑棋吃棋的时候

 522                         else if (chessPlayClick == 1 && play[Man].getName().charAt(1) == '1'){

 523                             Ex = play[Man].getX();

 524                             Ey = play[Man].getY();

 525                                                     

 526                             //卒吃规则

 527                             if (Man > 15 && Man < 26){

 528                                 rule.armsRule(play[Man],play[i]);

 529                             }

 530                             

 531                             //炮吃规则

 532                             else if (Man > 25 && Man < 30){

 533                                 rule.cannonRule(0,play[Man],play[i],play,me);

 534                             }

 535                             

 536                             //车吃规则

 537                             else if (Man >=0 && Man < 4){

 538                                 rule.cannonRule(1,play[Man],play[i],play,me);    

 539                             }

 540                             

 541                             //马吃规则

 542                             else if (Man > 3 && Man < 8){

 543                                 rule.horseRule(play[Man],play[i],play,me);

 544                             }

 545                             

 546                             //相、象吃规则

 547                             else if (Man > 7 && Man < 12){

 548                                 rule.elephantRule(play[Man],play[i],play);

 549                             }

 550                             

 551                             //士、仕吃棋规则

 552                             else if (Man > 11 && Man < 16){

 553                                 rule.chapRule(Man,play[Man],play[i],play);

 554                             }

 555                             

 556                             //将、帅吃棋规则

 557                             else if (Man == 30 || Man == 31){

 558                                 rule.willRule(Man,play[Man],play[i],play);

 559                                 play[Man].setVisible(true);            

 560                             }

 561                             

 562                             //是否走棋错误(是否在原地没有动)

 563                             if (Ex == play[Man].getX() && Ey == play[Man].getY()){

 564                                 text.setText("               黑棋走棋");

 565                                 chessPlayClick=1;

 566                                 break;

 567                             }

 568                 

 569                             else {

 570                                 text.setText("               红棋走棋");

 571                                 chessPlayClick=2;    

 572                                 break;

 573                             }

 574                                                         

 575                         }//else if 

 576                         

 577                     }//if

 578                     

 579                 }//for

 580                 

 581                 

 582                 //是否胜利

 583                 if (!play[31].isVisible()){

 584                     JOptionPane.showConfirmDialog(

 585                         this,"黑棋胜利","玩家一胜利",

 586                         JOptionPane.DEFAULT_OPTION,JOptionPane.WARNING_MESSAGE);

 587                     //双方都不可以在走棋了

 588                     chessPlayClick=3;

 589                     text.setText("  黑棋胜利");

 590                     

 591                 }//if 

 592 

 593                 else if (!play[30].isVisible()){

 594                     JOptionPane.showConfirmDialog(

 595                         this,"红棋胜利","玩家二胜利",

 596                         JOptionPane.DEFAULT_OPTION,JOptionPane.WARNING_MESSAGE);

 597                     chessPlayClick=3;

 598                     text.setText("  红棋胜利");

 599                 }//else if    

 600                 

 601             }//else

 602             

 603         }//else

 604         

 605     }

 606     

 607     public void mousePressed(MouseEvent me){

 608     }

 609     public void mouseReleased(MouseEvent me){

 610     }

 611     public void mouseEntered(MouseEvent me){

 612     }

 613     public void mouseExited(MouseEvent me){

 614     }

 615     

 616     /**

 617     ** 定义按钮的事件响应

 618     */

 619     public void actionPerformed(ActionEvent ae) {

 620         //重新开始按钮

 621         if (ae.getSource().equals(anew)){

 622             int i,k;

 623             //重新排列每个棋子的位置

 624             //黑色棋子

 625         

 626             //

 627             for (i=0,k=24;i<2;i++,k+=456){        

 628                 play[i].setBounds(k,56,55,55);    

 629             }    

 630             

 631             //

 632             for (i=4,k=81;i<6;i++,k+=342){    

 633                 play[i].setBounds(k,56,55,55);

 634             }

 635             

 636             //

 637             for (i=8,k=138;i<10;i++,k+=228){    

 638                 play[i].setBounds(k,56,55,55);

 639             }

 640             

 641             //

 642             for (i=12,k=195;i<14;i++,k+=114){

 643                 play[i].setBounds(k,56,55,55);

 644             }

 645             

 646             //

 647             for (i=16,k=24;i<21;i++,k+=114){

 648                 play[i].setBounds(k,227,55,55);

 649             }

 650             

 651             //

 652             for (i=26,k=81;i<28;i++,k+=342){

 653                 play[i].setBounds(k,170,55,55);

 654             }

 655             

 656             //

 657             play[30].setBounds(252,56,55,55);

 658 

 659             //红色棋子

 660             //

 661             for (i=2,k=24;i<4;i++,k+=456){

 662                 play[i].setBounds(k,569,55,55);

 663             }

 664             

 665             //

 666             for (i=6,k=81;i<8;i++,k+=342){

 667                 play[i].setBounds(k,569,55,55);

 668             }

 669             

 670             //

 671             for (i=10,k=138;i<12;i++,k+=228){

 672                 play[i].setBounds(k,569,55,55);

 673             }

 674             

 675             //

 676             for (i=14,k=195;i<16;i++,k+=114){

 677                 play[i].setBounds(k,569,55,55);

 678             }

 679             

 680             //

 681             for (i=21,k=24;i<26;i++,k+=114){

 682                 play[i].setBounds(k,398,55,55);

 683             }

 684             

 685             //

 686             for (i=28,k=81;i<30;i++,k+=342){

 687                 play[i].setBounds(k,455,55,55);

 688             }

 689             

 690             //

 691             play[31].setBounds(252,569,55,55);        

 692     

 693             chessPlayClick = 2;

 694             text.setText("               红棋走棋");

 695             

 696             for (i=0;i<32;i++){

 697                 play[i].setVisible(true);

 698             }

 699             //清除Vector中的内容

 700             Var.clear();

 701             

 702         }    

 703         

 704         //悔棋按钮

 705         else if (ae.getSource().equals(repent)){

 706             try{

 707                 //获得setVisible属性值

 708                 String S = (String)Var.get(Var.size()-4);

 709                 //获得X坐标

 710                 int x = Integer.parseInt((String)Var.get(Var.size()-3));

 711                 //获得Y坐标

 712                 int y = Integer.parseInt((String)Var.get(Var.size()-2));

 713                 //获得索引

 714                 int M = Integer.parseInt((String)Var.get(Var.size()-1));            

 715         

 716                 //赋给棋子

 717                 play[M].setVisible(true);            

 718                 play[M].setBounds(x,y,55,55);

 719                 

 720                 if (play[M].getName().charAt(1) == '1'){

 721                     text.setText("               黑棋走棋");

 722                     chessPlayClick = 1;

 723                 } 

 724                 else{

 725                     text.setText("               红棋走棋");

 726                     chessPlayClick = 2;

 727                 }

 728                 

 729                 //删除用过的坐标

 730                 Var.remove(Var.size()-4);

 731                 Var.remove(Var.size()-3);

 732                 Var.remove(Var.size()-2);

 733                 Var.remove(Var.size()-1);

 734                 

 735                 //停止旗子闪烁

 736                 chessManClick=false;

 737             }

 738             

 739             catch(Exception e){

 740             }

 741         }

 742     

 743         //退出

 744         else if (ae.getSource().equals(exit)){

 745             int j=JOptionPane.showConfirmDialog(

 746                 this,"真的要退出吗?","退出",

 747                 JOptionPane.YES_OPTION,JOptionPane.QUESTION_MESSAGE);

 748             

 749             if (j == JOptionPane.YES_OPTION){

 750                 System.exit(0);

 751             }

 752         }

 753     }

 754 

 755     /*定义中国象棋规则的类*/

 756     class ChessRule {

 757         /**卒子的移动规则*/

 758         public void armsRule(int Man,JLabel play,MouseEvent me){

 759             //黑卒向下

 760             if (Man < 21){

 761                 //向下移动、得到终点的坐标模糊成合法的坐标

 762                 if ((me.getY()-play.getY()) > 27 && (me.getY()-play.getY()) < 86 && (me.getX()-play.getX()) < 55 && (me.getX()-play.getX()) > 0){

 763                     

 764                     //当前记录添加到集合(用于悔棋)

 765                     Var.add(String.valueOf(play.isVisible()));

 766                     Var.add(String.valueOf(play.getX()));

 767                     Var.add(String.valueOf(play.getY()));

 768                     Var.add(String.valueOf(Man));

 769                     

 770                     play.setBounds(play.getX(),play.getY()+57,55,55);

 771                 }

 772                 

 773                 //向右移动、得到终点的坐标模糊成合法的坐标、必须过河                

 774                 else if (play.getY() > 284 && (me.getX() - play.getX()) >= 57 && (me.getX() - play.getX()) <= 112){

 775                     play.setBounds(play.getX()+57,play.getY(),55,55);    

 776                 }

 777                 

 778                 //向左移动、得到终点的坐标模糊成合法的坐标、必须过河

 779                 else if (play.getY() > 284 && (play.getX() - me.getX()) >= 2 && (play.getX() - me.getX()) <=58){

 780                     //模糊坐标

 781                     play.setBounds(play.getX()-57,play.getY(),55,55);

 782                 }

 783             }

 784             

 785             //红卒向上

 786             else{

 787                 //当前记录添加到集合(用于悔棋)

 788                 Var.add(String.valueOf(play.isVisible()));

 789                 Var.add(String.valueOf(play.getX()));

 790                 Var.add(String.valueOf(play.getY()));

 791                 Var.add(String.valueOf(Man));

 792                 

 793                 //向上移动、得到终点的坐标模糊成合法的坐标

 794                 if ((me.getX()-play.getX()) >= 0 && (me.getX()-play.getX()) <= 55 && (play.getY()-me.getY()) >27 && play.getY()-me.getY() < 86){

 795                     play.setBounds(play.getX(),play.getY()-57,55,55);

 796                 }

 797                 

 798                 //向右移动、得到终点的坐标模糊成合法的坐标、必须过河

 799                 else if (play.getY() <= 341 && (me.getX() - play.getX()) >= 57 && (me.getX() - play.getX()) <= 112){

 800                     play.setBounds(play.getX()+57,play.getY(),55,55);

 801                 }                

 802                 

 803                 //向左移动、得到终点的坐标模糊成合法的坐标、必须过河

 804                 else if (play.getY() <= 341 && (play.getX() - me.getX()) >= 3 && (play.getX() - me.getX()) <=58){

 805                     play.setBounds(play.getX()-57,play.getY(),55,55);

 806                 }

 807             }

 808         }//卒移动结束

 809 

 810         /**卒吃棋规则*/

 811         public void armsRule(JLabel play1,JLabel play2){

 812             //向右走

 813             if ((play2.getX() - play1.getX()) <= 112 && (play2.getX() - play1.getX()) >= 57 && (play1.getY() - play2.getY()) < 22 && (play1.getY() - play2.getY()) > -22 && play2.isVisible() && play1.getName().charAt(1)!=play2.getName().charAt(1)){

 814                 //黑棋要过河才能右吃棋

 815                 if (play1.getName().charAt(1) == '1' && play1.getY() > 284 && play1.getName().charAt(1) != play2.getName().charAt(1)){

 816 

 817                     play2.setVisible(false);

 818                     //把对方的位置给自己

 819                     play1.setBounds(play2.getX(),play2.getY(),55,55);

 820                 }

 821                 

 822                 //红棋要过河才左能吃棋

 823                 else if (play1.getName().charAt(1) == '2' && play1.getY() < 341 && play1.getName().charAt(1) != play2.getName().charAt(1)){

 824                     play2.setVisible(false);

 825                     //把对方的位置给自己

 826                     play1.setBounds(play2.getX(),play2.getY(),55,55);                

 827                 }

 828             }

 829             

 830             //向左走

 831             else if ((play1.getX() - play2.getX()) <= 112 && (play1.getX() - play2.getX()) >= 57 && (play1.getY() - play2.getY()) < 22 && (play1.getY() - play2.getY()) > -22 && play2.isVisible() && play1.getName().charAt(1)!=play2.getName().charAt(1)){

 832                 //黑棋要过河才能左吃棋

 833                 if (play1.getName().charAt(1) == '1' && play1.getY() > 284 && play1.getName().charAt(1) != play2.getName().charAt(1)){

 834                     play2.setVisible(false);

 835                     //把对方的位置给自己

 836                     play1.setBounds(play2.getX(),play2.getY(),55,55);

 837                 }

 838                 

 839                 //红棋要过河才能右吃棋

 840                 else if (play1.getName().charAt(1) == '2' && play1.getY() < 341 && play1.getName().charAt(1) != play2.getName().charAt(1)){

 841                     play2.setVisible(false);

 842                     //把对方的位置给自己

 843                     play1.setBounds(play2.getX(),play2.getY(),55,55);                

 844                 }

 845             }

 846             

 847             //向上走

 848             else if (play1.getX() - play2.getX() >= -22 && play1.getX() - play2.getX() <= 22 && play1.getY() - play2.getY() >= -112 && play1.getY() - play2.getY() <= 112){

 849                 //黑棋不能向上吃棋

 850                 if (play1.getName().charAt(1) == '1' && play1.getY() < play2.getY() && play1.getName().charAt(1) != play2.getName().charAt(1)){

 851                     play2.setVisible(false);

 852                     //把对方的位置给自己

 853                     play1.setBounds(play2.getX(),play2.getY(),55,55);

 854                 }

 855                 

 856                 //红棋不能向下吃棋

 857                 else if (play1.getName().charAt(1) == '2' && play1.getY() > play2.getY() && play1.getName().charAt(1) != play2.getName().charAt(1)){

 858                     play2.setVisible(false);

 859                     //把对方的位置给自己

 860                     play1.setBounds(play2.getX(),play2.getY(),55,55);

 861                 }            

 862             }

 863             

 864             //当前记录添加到集合(用于悔棋)

 865             Var.add(String.valueOf(play1.isVisible()));

 866             Var.add(String.valueOf(play1.getX()));

 867             Var.add(String.valueOf(play1.getY()));

 868             Var.add(String.valueOf(Man));

 869             

 870             //当前记录添加到集合(用于悔棋)

 871             Var.add(String.valueOf(play2.isVisible()));

 872             Var.add(String.valueOf(play2.getX()));

 873             Var.add(String.valueOf(play2.getY()));

 874             Var.add(String.valueOf(i));

 875 

 876         }//卒吃结束

 877         

 878         /**炮、车移动规则*/

 879         public void cannonRule(JLabel play,JLabel playQ[],MouseEvent me){

 880             //起点和终点之间是否有棋子

 881             int Count = 0;

 882             

 883             //上、下移动

 884             if (play.getX() - me.getX() <= 0 && play.getX() - me.getX() >= -55){

 885                 //指定所有模糊Y坐标

 886                 for (int i=56;i<=571;i+=57){

 887                     //移动的Y坐标是否有指定坐标相近的

 888                     if (i - me.getY() >= -27 && i - me.getY() <= 27){

 889                         //所有的棋子

 890                         for (int j=0;j<32;j++){

 891                             //找出在同一条竖线的所有棋子、并不包括自己

 892                             if (playQ[j].getX() - play.getX() >= -27 && playQ[j].getX() - play.getX() <= 27 && playQ[j].getName()!=play.getName() && playQ[j].isVisible()){

 893                                 //从起点到终点(从左到右)

 894                                 for (int k=play.getY()+57;k<i;k+=57){

 895                                     //大于起点、小于终点的坐标就可以知道中间是否有棋子

 896                                     if (playQ[j].getY() < i && playQ[j].getY() > play.getY()){

 897                                         //中间有一个棋子就不可以从这条竖线过去

 898                                         Count++;

 899                                         break;

 900                                     }

 901                                 }//for

 902                                 

 903                                 //从起点到终点(从右到左)

 904                                 for (int k=i+57;k<play.getY();k+=57){

 905                                     //找起点和终点的棋子

 906                                     if (playQ[j].getY() < play.getY() && playQ[j].getY() > i){

 907                                         Count++;

 908                                         break;

 909                                     }

 910                                 }//for

 911                             }//if

 912                         }//for

 913                         

 914                         //起点和终点没有棋子就可以移动了

 915                         if (Count == 0){

 916                             //当前记录添加到集合(用于悔棋)

 917                             Var.add(String.valueOf(play.isVisible()));

 918                             Var.add(String.valueOf(play.getX()));

 919                             Var.add(String.valueOf(play.getY()));

 920                             Var.add(String.valueOf(Man));

 921                             play.setBounds(play.getX(),i,55,55);

 922                             break;

 923                         }

 924                     }//if

 925                 }//for

 926             }//if

 927 

 928             //左、右移动

 929             else if (play.getY() - me.getY() >=-27 && play.getY() - me.getY() <= 27){

 930                 //指定所有模糊X坐标

 931                 for (int i=24;i<=480;i+=57){

 932                     //移动的X坐标是否有指定坐标相近的

 933                     if (i - me.getX() >= -55 && i-me.getX() <= 0){

 934                         //所有的棋子

 935                         for (int j=0;j<32;j++){

 936                             //找出在同一条横线的所有棋子、并不包括自己

 937                             if (playQ[j].getY() - play.getY() >= -27 && playQ[j].getY() - play.getY() <= 27 && playQ[j].getName()!=play.getName() && playQ[j].isVisible()){

 938                                 //从起点到终点(从上到下)                

 939                                 for (int k=play.getX()+57;k<i;k+=57){

 940                                     //大于起点、小于终点的坐标就可以知道中间是否有棋子

 941                                     if (playQ[j].getX() < i && playQ[j].getX() > play.getX()){

 942                                         //中间有一个棋子就不可以从这条横线过去

 943                                         Count++;

 944                                         break;

 945                                     }

 946                                 }//for

 947                                 

 948                                 //从起点到终点(从下到上)

 949                                 for (int k=i+57;k<play.getX();k+=57){

 950                                     //找起点和终点的棋子

 951                                     if (playQ[j].getX() < play.getX() && playQ[j].getX() > i){

 952                                         Count++;

 953                                         break;

 954                                     }

 955                                 }//for

 956                             }//if

 957                         }//for

 958                         

 959                         //起点和终点没有棋子

 960                         if (Count == 0){

 961                             //当前记录添加到集合(用于悔棋)

 962                             Var.add(String.valueOf(play.isVisible()));

 963                             Var.add(String.valueOf(play.getX()));

 964                             Var.add(String.valueOf(play.getY()));

 965                             Var.add(String.valueOf(Man));

 966                             

 967                             play.setBounds(i,play.getY(),55,55);

 968                             break;

 969                         }

 970                     }//if

 971                 }//for

 972             }//else

 973             

 974         }//炮、车移动方法结束

 975 

 976 

 977         /**炮、车吃棋规则*/

 978         public void cannonRule(int Chess,JLabel play,JLabel playTake,JLabel playQ[],MouseEvent me){

 979             //起点和终点之间是否有棋子

 980             int Count = 0;

 981 

 982 

 983             //所有的棋子

 984             for (int j=0;j<32;j++){

 985                 //找出在同一条竖线的所有棋子、并不包括自己

 986                 if (playQ[j].getX() - play.getX() >= -27 && playQ[j].getX() - play.getX() <= 27 && playQ[j].getName()!=play.getName() && playQ[j].isVisible()){

 987 

 988                     //自己是起点被吃的是终点(从上到下)

 989                     for (int k=play.getY()+57;k<playTake.getY();k+=57){

 990                         //大于起点、小于终点的坐标就可以知道中间是否有棋子

 991                         if (playQ[j].getY() < playTake.getY() && playQ[j].getY() > play.getY()){

 992                                 //计算起点和终点的棋子个数

 993                                 Count++;            

 994                                 break;                            

 995                         }

 996                     }//for

 997                                 

 998                     //自己是起点被吃的是终点(从下到上)

 999                     for (int k=playTake.getY();k<play.getY();k+=57){

1000                         //找起点和终点的棋子

1001                         if (playQ[j].getY() < play.getY() && playQ[j].getY() > playTake.getY()){

1002                                 Count++;    

1003                                 break;

1004                         }

1005                     }//for

1006                 }//if

1007                             

1008                 //找出在同一条竖线的所有棋子、并不包括自己

1009                 else if (playQ[j].getY() - play.getY() >= -10 && playQ[j].getY() - play.getY() <= 10 && playQ[j].getName()!=play.getName() && playQ[j].isVisible()){

1010                     //自己是起点被吃的是终点(从左到右)

1011                     for (int k=play.getX()+50;k<playTake.getX();k+=57){

1012                         //大于起点、小于终点的坐标就可以知道中间是否有棋子                        

1013                         if (playQ[j].getX() < playTake.getX() && playQ[j].getX() > play.getX()){

1014                             Count++;            

1015                             break;    

1016                         }

1017                     }//for

1018                                 

1019                     //自己是起点被吃的是终点(从右到左)

1020                     for (int k=playTake.getX();k<play.getX();k+=57){

1021                         //找起点和终点的棋子

1022                         if (playQ[j].getX() < play.getX() && playQ[j].getX() > playTake.getX()){

1023                                 Count++;

1024                                 break;

1025                         }

1026                     }//for

1027                 }//if

1028             }//for

1029                         

1030             //起点和终点之间要一个棋子是炮的规则、并不能吃自己的棋子

1031             if (Count == 1 && Chess == 0 && playTake.getName().charAt(1) != play.getName().charAt(1)){

1032                 //当前记录添加到集合(用于悔棋)

1033                 Var.add(String.valueOf(play.isVisible()));

1034                 Var.add(String.valueOf(play.getX()));

1035                 Var.add(String.valueOf(play.getY()));

1036                 Var.add(String.valueOf(Man));

1037                 

1038                 //当前记录添加到集合(用于悔棋)

1039                 Var.add(String.valueOf(playTake.isVisible()));

1040                 Var.add(String.valueOf(playTake.getX()));                                    

1041                 Var.add(String.valueOf(playTake.getY()));

1042                 Var.add(String.valueOf(i));

1043                 

1044                 playTake.setVisible(false);

1045                 play.setBounds(playTake.getX(),playTake.getY(),55,55);

1046             }

1047             

1048             //起点和终点之间没有棋子是车的规则、并不能吃自己的棋子            

1049             else if (Count ==0  && Chess == 1 && playTake.getName().charAt(1) != play.getName().charAt(1)){

1050                 

1051                 //当前记录添加到集合(用于悔棋)

1052                 Var.add(String.valueOf(play.isVisible()));

1053                 Var.add(String.valueOf(play.getX()));                                    

1054                 Var.add(String.valueOf(play.getY()));

1055                 Var.add(String.valueOf(Man));

1056                 

1057                 //当前记录添加到集合(用于悔棋)

1058                 Var.add(String.valueOf(playTake.isVisible()));

1059                 Var.add(String.valueOf(playTake.getX()));                                    

1060                 Var.add(String.valueOf(playTake.getY()));

1061                 Var.add(String.valueOf(i));

1062                 

1063                 playTake.setVisible(false);

1064                 play.setBounds(playTake.getX(),playTake.getY(),55,55);

1065             }

1066             

1067         }//炮、车吃棋方法结束

1068         

1069         /**马移动规则*/

1070         public void horseRule(JLabel play,JLabel playQ[],MouseEvent me){

1071             //保存坐标和障碍

1072             int Ex=0,Ey=0,Move=0;            

1073             

1074             //上移、左边

1075             if (play.getX() - me.getX() >= 2 && play.getX() - me.getX() <= 57 && play.getY() - me.getY() >= 87 && play.getY() - me.getY() <= 141){

1076                 //合法的Y坐标

1077                 for (int i=56;i<=571;i+=57){

1078                     //移动的Y坐标是否有指定坐标相近的

1079                     if (i - me.getY() >= -27 && i - me.getY() <= 27){

1080                         Ey = i;

1081                         break;

1082                     }

1083                 }

1084                 

1085                 //合法的X坐标

1086                 for (int i=24;i<=480;i+=57){

1087                     //移动的X坐标是否有指定坐标相近的

1088                     if (i - me.getX() >= -55 && i-me.getX() <= 0){

1089                         Ex = i;

1090                         break;

1091                     }

1092                 }

1093                 

1094                 //正前方是否有别的棋子

1095                 for (int i=0;i<32;i++){

1096                     if (playQ[i].isVisible() && play.getX() - playQ[i].getX() == 0  && play.getY() - playQ[i].getY() == 57 ){

1097                         Move = 1;

1098                         break;

1099                     }    

1100                 }

1101                 

1102                 //可以移动该棋子

1103                 if (Move == 0){

1104                     //当前记录添加到集合(用于悔棋)

1105                     Var.add(String.valueOf(play.isVisible()));

1106                     Var.add(String.valueOf(play.getX()));

1107                     Var.add(String.valueOf(play.getY()));

1108                     Var.add(String.valueOf(Man));

1109                                     

1110                     play.setBounds(Ex,Ey,55,55);

1111                 }

1112                 

1113             }//if

1114             

1115             //左移、上边

1116             else if (play.getY() - me.getY() >= 27 && play.getY() - me.getY() <= 86 && play.getX() - me.getX() >= 70 && play.getX() - me.getX() <= 130){

1117                 //Y

1118                 for (int i=56;i<=571;i+=57){

1119                     if (i - me.getY() >= -27 && i - me.getY() <= 27){

1120                         Ey = i;

1121                     }

1122                 }

1123                 

1124                 //X

1125                 for (int i=24;i<=480;i+=57){

1126                     if (i - me.getX() >= -55 && i-me.getX() <= 0){

1127                         Ex = i;

1128                     }

1129                 }

1130                 

1131                 //正左方是否有别的棋子

1132                 for (int i=0;i<32;i++){

1133                     if (playQ[i].isVisible() && play.getY() - playQ[i].getY() == 0 && play.getX() - playQ[i].getX() == 57 ){

1134                         Move = 1;

1135                         break;

1136                     }

1137                 }

1138                 

1139                 if (Move == 0){

1140                     //当前记录添加到集合(用于悔棋)

1141                     Var.add(String.valueOf(play.isVisible()));

1142                     Var.add(String.valueOf(play.getX()));

1143                     Var.add(String.valueOf(play.getY()));

1144                     Var.add(String.valueOf(Man));

1145                     

1146                     play.setBounds(Ex,Ey,55,55);

1147                 }

1148             }//else

1149             

1150             //下移、右边

1151             else if (me.getY() - play.getY() >= 87 && me.getY() - play.getY() <= 141 && me.getX() - play.getX() <= 87 && me.getX() - play.getX() >= 2 ){    

1152                 //Y        

1153                 for (int i=56;i<=571;i+=57){

1154                     if (i - me.getY() >= -27 && i - me.getY() <= 27){

1155                         Ey = i;

1156                     }

1157                 }

1158                 

1159                 //X

1160                 for (int i=24;i<=480;i+=57){

1161                     if (i - me.getX() >= -55 && i-me.getX() <= 0){

1162                         Ex = i;

1163                     }

1164                 }

1165                 

1166                 //正下方是否有别的棋子

1167                 for (int i=0;i<32;i++){

1168                     if (playQ[i].isVisible() && play.getX() - playQ[i].getX() == 0  && playQ[i].getY() - play.getY() == 57 ){

1169                         Move = 1;

1170                         break;

1171                     }

1172                 }

1173                 

1174                 if (Move == 0){

1175                     //当前记录添加到集合(用于悔棋)

1176                     Var.add(String.valueOf(play.isVisible()));

1177                     Var.add(String.valueOf(play.getX()));

1178                     Var.add(String.valueOf(play.getY()));

1179                     Var.add(String.valueOf(Man));

1180                     

1181                     play.setBounds(Ex,Ey,55,55);

1182                 }

1183             }//else

1184             

1185             //上移、右边

1186             else if (play.getY() - me.getY() >= 87 && play.getY() - me.getY() <= 141 && me.getX() - play.getX() <= 87 && me.getX() - play.getX() >= 30 ){

1187                 //合法的Y坐标

1188                 for (int i=56;i<=571;i+=57){

1189                     if (i - me.getY() >= -27 && i - me.getY() <= 27){

1190                         Ey = i;

1191                         break;

1192                     }

1193                 }

1194                 

1195                 //合法的X坐标

1196                 for (int i=24;i<=480;i+=57){

1197                     if (i - me.getX() >= -55 && i-me.getX() <= 0){

1198                         Ex = i;

1199                         break;

1200                     }

1201                 }

1202                 

1203                 //正前方是否有别的棋子

1204                 for (int i=0;i<32;i++){

1205                     System.out.println(i+"playQ[i].getX()="+playQ[i].getX());

1206                     //System.out.println("play.getX()="+play.getX());

1207                     if (playQ[i].isVisible() && play.getX() - playQ[i].getX() == 0 && play.getY() - playQ[i].getY() == 57 ){

1208                         Move = 1;

1209                         //System.out.println("play.getY()="+play.getY());

1210                         //System.out.println("playQ[i].getY()="+playQ[i].getY());

1211                         break;

1212                     }

1213                 }

1214                 

1215                 //可以移动该棋子

1216                 if (Move == 0){

1217                     //当前记录添加到集合(用于悔棋)

1218                     Var.add(String.valueOf(play.isVisible()));

1219                     Var.add(String.valueOf(play.getX()));    

1220                     Var.add(String.valueOf(play.getY()));

1221                     Var.add(String.valueOf(Man));

1222                     

1223                     play.setBounds(Ex,Ey,55,55);

1224                 }

1225             }//else 

1226             

1227             //下移、左边

1228             else if (me.getY() - play.getY() >= 87 && me.getY() - play.getY() <= 141 && play.getX() - me.getX() <= 87 && play.getX() - me.getX() >= 10 ){

1229                 //合法的Y坐标

1230                 for (int i=56;i<=571;i+=57){

1231                     if (i - me.getY() >= -27 && i - me.getY() <= 27){

1232                         Ey = i;

1233                         break;

1234                     }

1235                 }

1236                 

1237                 //合法的X坐标

1238                 for (int i=24;i<=480;i+=57){

1239                     if (i - me.getX() >= -55 && i-me.getX() <= 0){

1240                         Ex = i;

1241                         break;

1242                     }

1243                 }

1244                 

1245                 //正下方是否有别的棋子

1246                 for (int i=0;i<32;i++){

1247                     if (playQ[i].isVisible() && play.getX() - playQ[i].getX() == 0 && play.getY() - playQ[i].getY() == 57 ){

1248                         Move = 1;

1249                         break;

1250                     }

1251                 }

1252                 

1253                 //可以移动该棋子

1254                 if (Move == 0){

1255                     //当前记录添加到集合(用于悔棋)

1256                     Var.add(String.valueOf(play.isVisible()));

1257                     Var.add(String.valueOf(play.getX()));

1258                     Var.add(String.valueOf(play.getY()));

1259                     Var.add(String.valueOf(Man));

1260                     

1261                     play.setBounds(Ex,Ey,55,55);

1262                 }

1263             }//else

1264             

1265             //右移、上边

1266             else if (play.getY() - me.getY() >= 30 && play.getY() - me.getY() <= 87 && me.getX() - play.getX() <= 141 && me.getX() - play.getX() >= 87 ){

1267                 //Y        

1268                 for (int i=56;i<=571;i+=57){

1269                     if (i - me.getY() >= -27 && i - me.getY() <= 27){

1270                         Ey = i;

1271                     }

1272                 }

1273                 

1274                 //X

1275                 for (int i=24;i<=480;i+=57){

1276                     if (i - me.getX() >= -55 && i-me.getX() <= 0){

1277                         Ex = i;

1278                     }

1279                 }

1280                 

1281                 //正右方是否有别的棋子

1282                 for (int i=0;i<32;i++){

1283                     if (playQ[i].isVisible() && play.getY() - playQ[i].getY() == 0 && playQ[i].getX() - play.getX() == 57 ){

1284                         Move = 1;

1285                         break;

1286                     }

1287                 }

1288                 

1289                 if (Move == 0){

1290                     //当前记录添加到集合(用于悔棋)

1291                     Var.add(String.valueOf(play.isVisible()));

1292                     Var.add(String.valueOf(play.getX()));

1293                     Var.add(String.valueOf(play.getY()));

1294                     Var.add(String.valueOf(Man));

1295                     

1296                     play.setBounds(Ex,Ey,55,55);

1297                 }

1298             }//else

1299             

1300             //右移、下边

1301             else if (me.getY() - play.getY() >= 30 && me.getY() - play.getY() <= 87 && me.getX() - play.getX() <= 141 && me.getX() - play.getX() >= 87 ){

1302                 //Y        

1303                 for (int i=56;i<=571;i+=57){

1304                     if (i - me.getY() >= -27 && i - me.getY() <= 27){

1305                         Ey = i;

1306                     }

1307                 }

1308                 

1309                 //X

1310                 for (int i=24;i<=480;i+=57){

1311                     if (i - me.getX() >= -55 && i-me.getX() <= 0){

1312                         Ex = i;

1313                     }

1314                 }

1315                 

1316                 //正右方是否有别的棋子

1317                 for (int i=0;i<32;i++){

1318                     if (playQ[i].isVisible() && play.getY() - playQ[i].getY() == 0 && playQ[i].getX() - play.getX() == 57 ){

1319                         Move = 1;

1320                         break;

1321                     }

1322                 }

1323                 

1324                 if (Move == 0){

1325                     //当前记录添加到集合(用于悔棋)

1326                     Var.add(String.valueOf(play.isVisible()));

1327                     Var.add(String.valueOf(play.getX()));

1328                     Var.add(String.valueOf(play.getY()));

1329                     Var.add(String.valueOf(Man));

1330                     

1331                     play.setBounds(Ex,Ey,55,55);

1332                 }

1333             }//else

1334             

1335             //左移、下边

1336             else if (me.getY() - play.getY() >= 30 && me.getY() - play.getY() <= 87 && play.getX() - me.getX() <= 141 && play.getX() - me.getX() >= 87 ){

1337                 //Y        

1338                 for (int i=56;i<=571;i+=57){

1339                     if (i - me.getY() >= -27 && i - me.getY() <= 27){

1340                         Ey = i;

1341                     }

1342                 }

1343                 

1344                 //X

1345                 for (int i=24;i<=480;i+=57){

1346                     if (i - me.getX() >= -55 && i-me.getX() <= 0){

1347                         Ex = i;

1348                     }

1349                 }

1350                 

1351                 //正左方是否有别的棋子

1352                 for (int i=0;i<32;i++){

1353                     if (playQ[i].isVisible() && play.getY() - playQ[i].getY() == 0 && play.getX() - playQ[i].getX() == 57 ){

1354                         Move = 1;

1355                         break;

1356                     }

1357                 }

1358                 

1359                 if (Move == 0){

1360                     //当前记录添加到集合(用于悔棋)

1361                     Var.add(String.valueOf(play.isVisible()));

1362                     Var.add(String.valueOf(play.getX()));

1363                     Var.add(String.valueOf(play.getY()));

1364                     Var.add(String.valueOf(Man));

1365                 

1366                     play.setBounds(Ex,Ey,55,55);

1367                 }

1368                 

1369             }//else

1370             

1371         }//马移动结束

1372 

1373         /**马吃棋规则*/

1374         public void horseRule(JLabel play,JLabel playTake ,JLabel playQ[],MouseEvent me){

1375             //障碍

1376             int Move=0;

1377             boolean Chess=false;

1378             

1379             //上移、左吃

1380             if (play.getName().charAt(1)!=playTake.getName().charAt(1) && play.getX() - playTake.getX() == 57 && play.getY() - playTake.getY() == 114 ){

1381                 //正前方是否有别的棋子

1382                 for (int i=0;i<32;i++){

1383                     if (playQ[i].isVisible() && play.getX() - playQ[i].getX() == 0 && play.getY() - playQ[i].getY() == 57){

1384                         Move = 1;

1385                         break;

1386                     }

1387                 }//for

1388                 

1389                 Chess = true;

1390                 

1391             }//if

1392             

1393             //上移、右吃

1394             else if (play.getY() - playTake.getY() == 114 && playTake.getX() - play.getX() == 57 ){

1395                 //正前方是否有别的棋子

1396                 for (int i=0;i<32;i++){

1397                     if (playQ[i].isVisible() && play.getX() - playQ[i].getX() == 0 && play.getY() - playQ[i].getY() == 57){

1398                         Move = 1;

1399                         break;

1400                     }

1401                 }//for        

1402                 

1403                 Chess = true;

1404                 

1405             }//else

1406             

1407             //左移、上吃

1408             else if (play.getY() - playTake.getY() == 57 && play.getX() - playTake.getX() == 114 ){

1409                 //正左方是否有别的棋子

1410                 for (int i=0;i<32;i++){

1411                     if (playQ[i].isVisible() && play.getY() - playQ[i].getY() == 0 && play.getX() - playQ[i].getX() == 57){

1412                         Move = 1;

1413                         break;

1414                     }

1415                 }//for

1416                 

1417                 Chess = true;

1418                 

1419             }//else

1420             

1421             //左移、下吃

1422             else if (playTake.getY() - play.getY() == 57 && play.getX() - playTake.getX() == 114 ){

1423                 //正左方是否有别的棋子

1424                 for (int i=0;i<32;i++){

1425                     if (playQ[i].isVisible() && play.getY() - playQ[i].getY() == 0 && play.getX() - playQ[i].getX() == 57){

1426                         Move = 1;

1427                         break;

1428                     }

1429                 }//for

1430                 

1431                 Chess = true;

1432                 

1433             }//else

1434             

1435             //右移、上吃

1436             else if (play.getY() - playTake.getY() == 57 && playTake.getX() - play.getX() == 114 ){

1437                 //正右方是否有别的棋子

1438                 for (int i=0;i<32;i++){

1439                     if (playQ[i].isVisible() && play.getY() - playQ[i].getY() == 0 && playQ[i].getX() - play.getX() == 57){

1440                         Move = 1;

1441                         break;

1442                     }

1443                 }//for

1444                 

1445                 Chess = true;

1446                 

1447             }//else

1448             

1449             //右移、下吃

1450             else if (playTake.getY() - play.getY() == 57  && playTake.getX() - play.getX() == 114 ){

1451                 //正右方是否有别的棋子

1452                 for (int i=0;i<32;i++){

1453                     if (playQ[i].isVisible() && play.getY() - playQ[i].getY() == 0 && playQ[i].getX() - play.getX() == 57){

1454                         Move = 1;

1455                         break;

1456                     }

1457                 }//for

1458                 

1459                 Chess = true;

1460                 

1461             }//else

1462             

1463             //下移、左吃

1464             else if (playTake.getY() - play.getY() == 114 && play.getX() - playTake.getX() == 57 ){

1465                 //正下方是否有别的棋子

1466                 for (int i=0;i<32;i++){

1467                     if (playQ[i].isVisible() && play.getX() - playQ[i].getX() == 0 && play.getY() - playQ[i].getY() == -57 ){

1468                         Move = 1;

1469                         break;

1470                         

1471                     }

1472                 }//for

1473                 

1474                 Chess = true;

1475                 

1476             }//else 

1477             

1478             //下移、右吃

1479             else if (playTake.getY() - play.getY() == 114 && playTake.getX() - play.getX() == 57){

1480                 //正下方是否有别的棋子

1481                 for (int i=0;i<32;i++){

1482                     if (playQ[i].isVisible() && play.getX() - playQ[i].getX() == 0 && play.getY() - playQ[i].getY() == -57 ){

1483                         Move = 1;

1484                         break;

1485                     }

1486                 }//for

1487                 

1488                 Chess = true;

1489                 

1490             }//else  

1491             

1492             //没有障碍、并可以吃棋、不能吃自己颜色

1493             if (Chess && Move == 0 && playTake.getName().charAt(1) != play.getName().charAt(1)){

1494                 //当前记录添加到集合(用于悔棋)

1495                 Var.add(String.valueOf(play.isVisible()));

1496                 Var.add(String.valueOf(play.getX()));

1497                 Var.add(String.valueOf(play.getY()));

1498                 Var.add(String.valueOf(Man));

1499                 

1500                 //当前记录添加到集合(用于悔棋)

1501                 Var.add(String.valueOf(playTake.isVisible()));

1502                 Var.add(String.valueOf(playTake.getX()));

1503                 Var.add(String.valueOf(playTake.getY()));

1504                 Var.add(String.valueOf(i));            

1505                 

1506                 playTake.setVisible(false);

1507                 play.setBounds(playTake.getX(),playTake.getY(),55,55);

1508             }

1509         }

1510         

1511         /**相移动规则*/

1512         public void elephantRule(int Man,JLabel play,JLabel playQ[],MouseEvent me){

1513             //坐标和障碍

1514             int Ex=0,Ey=0,Move=0;

1515             

1516             //上左

1517             if (play.getX() - me.getX() <= 141 && play.getX() - me.getX() >= 87 && play.getY() - me.getY() <= 141 && play.getY() - me.getY() >= 87){

1518                 //合法的Y坐标

1519                 for (int i=56;i<=571;i+=57){

1520                     if (i - me.getY() >= -27 && i - me.getY() <= 27){

1521                         Ey = i;

1522                         break;

1523                     }

1524                 }

1525                 

1526                 //合法的X坐标

1527                 for (int i=24;i<=480;i+=57){

1528                     if (i - me.getX() >= -27 && i-me.getX() <= 27){

1529                         Ex = i;

1530                         break;

1531                     }

1532                 }

1533                 

1534                 //左上方是否有棋子

1535                 for (int i=0;i<32;i++){

1536                     if (playQ[i].isVisible() && play.getX() - playQ[i].getX() == 57 && play.getY() - playQ[i].getY() == 57){

1537                         Move++;

1538                         break;

1539                     }

1540                 }

1541                 

1542                 //红旗不能过楚河

1543                 if (Move == 0 && Ey >= 341 && Man > 9){

1544                     //当前记录添加到集合(用于悔棋)

1545                     Var.add(String.valueOf(play.isVisible()));

1546                     Var.add(String.valueOf(play.getX()));

1547                     Var.add(String.valueOf(play.getY()));

1548                     Var.add(String.valueOf(Man));

1549                                 

1550                                 System.out.println("Ex="+Ex);

1551                                 System.out.println("Ey="+Ey);

1552                     play.setBounds(Ex,Ey,55,55);

1553                 }

1554                 

1555                 //黑旗不能过汉界

1556                 else if (Move == 0 && Ey <= 284 && Man < 10){

1557                     //当前记录添加到集合(用于悔棋)

1558                     Var.add(String.valueOf(play.isVisible()));

1559                     Var.add(String.valueOf(play.getX()));

1560                     Var.add(String.valueOf(play.getY()));

1561                     Var.add(String.valueOf(Man));

1562                     

1563                     play.setBounds(Ex,Ey,55,55);    

1564                 }

1565             }//if

1566             

1567             //上右

1568             else if (play.getY() - me.getY() <= 141 && play.getY() - me.getY() >= 87 &&  me.getX() - play.getX() >= 87 && me.getX() - play.getX() <= 141){

1569                 //合法的Y坐标

1570                 for (int i=56;i<=571;i+=57){

1571                     if (i - me.getY() >= -27 && i - me.getY() <= 27){

1572                         Ey = i;

1573                         break;

1574                     }

1575                 }

1576                 

1577                 //合法的X坐标

1578                 for (int i=24;i<=480;i+=57){

1579                     if (i - me.getX() >= -27 && i-me.getX() <= 27){

1580                         Ex = i;

1581                         break;

1582                     }

1583                 }

1584                 

1585                 //右上方是否有棋子

1586                 for (int i=0;i<32;i++){

1587                     if (playQ[i].isVisible() &&  playQ[i].getX() - play.getX() == 57 && play.getY() - playQ[i].getY() == 57){

1588                         Move++;

1589                         break;

1590                     }

1591                 }

1592                 

1593                 //相、象规则

1594                 if (Move == 0 && Ey >= 341 && Man > 9){

1595                     //当前记录添加到集合(用于悔棋)

1596                     Var.add(String.valueOf(play.isVisible()));

1597                     Var.add(String.valueOf(play.getX()));

1598                     Var.add(String.valueOf(play.getY()));

1599                     Var.add(String.valueOf(Man));

1600                     

1601                     play.setBounds(Ex,Ey,55,55);

1602                 }

1603                 

1604                 else if (Move == 0 && Ey <= 284 && Man < 10){

1605                     //当前记录添加到集合(用于悔棋)

1606                     Var.add(String.valueOf(play.isVisible()));

1607                     Var.add(String.valueOf(play.getX()));

1608                     Var.add(String.valueOf(play.getY()));

1609                     Var.add(String.valueOf(Man));

1610                     

1611                     play.setBounds(Ex,Ey,55,55);

1612                 }

1613                 

1614             }// else if 

1615             

1616             //下左

1617             else if (play.getX() - me.getX() <= 141 && play.getX() - me.getX() >= 87 && me.getY() - play.getY() <= 141 && me.getY() - play.getY() >= 87){

1618                 //合法的Y坐标

1619                 for (int i=56;i<=571;i+=57){

1620                     if (i - me.getY() >= -27 && i - me.getY() <= 27){

1621                         Ey = i;

1622                         break;

1623                     }

1624                 }

1625                 

1626                 //合法的X坐标

1627                 for (int i=24;i<=480;i+=57){

1628                     if (i - me.getX() >= -27 && i-me.getX() <= 27){

1629                         Ex = i;

1630                         break;

1631                     }

1632                 }

1633                 

1634                 //下左方是否有棋子

1635                 for (int i=0;i<32;i++){

1636                     if (playQ[i].isVisible() && play.getX() - playQ[i].getX() == 57 && play.getY() - playQ[i].getY() == -57){

1637                         Move++;

1638                         break;

1639                     }

1640                 }            

1641                 

1642                 //相、象规则

1643                 

1644                 if (Move == 0 && Ey >= 341 && Man > 9){

1645                     //当前记录添加到集合(用于悔棋)

1646                     Var.add(String.valueOf(play.isVisible()));

1647                     Var.add(String.valueOf(play.getX()));

1648                     Var.add(String.valueOf(play.getY()));

1649                     Var.add(String.valueOf(Man));

1650                                     

1651                     play.setBounds(Ex,Ey,55,55);

1652                 }

1653                 

1654                 else if (Move == 0 && Ey <= 284 && Man < 10)

1655                 {

1656                     //当前记录添加到集合(用于悔棋)

1657                     Var.add(String.valueOf(play.isVisible()));

1658                     Var.add(String.valueOf(play.getX()));

1659                     Var.add(String.valueOf(play.getY()));

1660                     Var.add(String.valueOf(Man));

1661                     

1662                     play.setBounds(Ex,Ey,55,55);

1663                 }

1664             }//else if 

1665             

1666             //下右

1667             else if (me.getX() - play.getX() >= 87 &&  me.getX() - play.getX() <= 141 && me.getY() - play.getY() >= 87 && me.getY() - play.getY() <= 141){

1668                 //Y        

1669                 for (int i=56;i<=571;i+=57){

1670                     if (i - me.getY() >= -27 && i - me.getY() <= 27){

1671                         Ey = i;

1672                     }

1673                 }

1674                 

1675                 //X

1676                 for (int i=24;i<=480;i+=57){

1677                     if (i - me.getX() >= -27 && i-me.getX() <= 27){

1678                         Ex = i;

1679                     }

1680                 }

1681                 

1682                 //下右方是否有棋子

1683                 for (int i=0;i<32;i++){

1684                     if (playQ[i].isVisible() && playQ[i].getX() - play.getX() == 57 && playQ[i].getY() - play.getY() == 57){

1685                         Move = 1;

1686                         break;

1687                     }

1688                 }

1689                 

1690                 //相、象规则

1691                 if (Move == 0 && Ey >= 341 && Man > 9){

1692                     //当前记录添加到集合(用于悔棋)

1693                     Var.add(String.valueOf(play.isVisible()));

1694                     Var.add(String.valueOf(play.getX()));

1695                     Var.add(String.valueOf(play.getY()));

1696                     Var.add(String.valueOf(Man));

1697                     

1698                     play.setBounds(Ex,Ey,55,55);

1699                 }

1700                 

1701                 else if (Move == 0 && Ey <= 284 && Man < 10){

1702                     //当前记录添加到集合(用于悔棋)

1703                     Var.add(String.valueOf(play.isVisible()));

1704                     Var.add(String.valueOf(play.getX()));                                    

1705                     Var.add(String.valueOf(play.getY()));

1706                     Var.add(String.valueOf(Man));

1707                     

1708                     play.setBounds(Ex,Ey,55,55);

1709                 }

1710                 

1711             }//else

1712             

1713         }//相移动规则吉束

1714 

1715         /**相、象吃棋规则*/

1716         public void elephantRule(JLabel play,JLabel playTake,JLabel playQ[]){

1717             //障碍

1718             int Move=0;

1719             boolean Chess=false;

1720             

1721             //吃左上方的棋子

1722             if (play.getX() - playTake.getX() >= 87 && play.getX() - playTake.getX() <= 141 && play.getY() - playTake.getY() >= 87 && play.getY() - playTake.getY() <= 141){

1723                 //左上方是否有棋子

1724                 for (int i=0;i<32;i++){

1725                     if (playQ[i].isVisible() && play.getX() - playQ[i].getX() == 57 && play.getY() - playQ[i].getY() == 57){

1726                         Move++;

1727                         break;

1728                     }

1729                 }//for

1730 

1731                 Chess=true;

1732                 

1733             }//if

1734             

1735             //吃右上方的棋子

1736             else if (playTake.getX() - play.getX() >= 87 && playTake.getX() - play.getX() <= 141 && play.getY() - playTake.getY() >= 87 && play.getY() - playTake.getY() <= 141 ){

1737                 //右上方是否有棋子

1738                 for (int i=0;i<32;i++){

1739                     if (playQ[i].isVisible() &&  playQ[i].getX() - play.getX() == 57 && play.getY() - playQ[i].getY() == 57 ){

1740                         Move++;

1741                         break;

1742                     }

1743                 }//for    

1744                 

1745                 Chess=true;

1746             }//else

1747             

1748             //吃下左方的棋子

1749             else if (play.getX() - playTake.getX() >= 87 && play.getX() - playTake.getX() <= 141 && playTake.getY() - play.getY() >= 87 && playTake.getY() - play.getY() <= 141){

1750                 //下左方是否有棋子

1751                 for (int i=0;i<32;i++){

1752                     if (playQ[i].isVisible() && play.getX() - playQ[i].getX() == 57 && play.getY() - playQ[i].getY() == -57 ){

1753                         Move++;

1754                         break;

1755                     }

1756                 }//for

1757                 

1758                 Chess=true;

1759             }//else

1760             

1761             //吃下右放的棋子

1762             else if (playTake.getX() - play.getX() >= 87 && playTake.getX() - play.getX() <= 141 && playTake.getY() - play.getY() >= 87 && playTake.getY() - play.getY() <= 141){

1763                 //下右方是否有棋子

1764                 for (int i=0;i<32;i++){

1765                     if (playQ[i].isVisible() && playQ[i].getX() - play.getX() == 57 && playQ[i].getY() - play.getY() == 57 ){

1766                         Move = 1;

1767                         break;

1768                     }

1769                 }//for        

1770 

1771                 Chess=true;

1772                 

1773             }//else

1774             

1775             //没有障碍、并不能吃自己的棋子

1776             if (Chess && Move == 0 && playTake.getName().charAt(1) != play.getName().charAt(1)){

1777                 //当前记录添加到集合(用于悔棋)

1778                 Var.add(String.valueOf(play.isVisible()));

1779                 Var.add(String.valueOf(play.getX()));

1780                 Var.add(String.valueOf(play.getY()));

1781                 Var.add(String.valueOf(Man));

1782                 

1783                 //当前记录添加到集合(用于悔棋)

1784                 Var.add(String.valueOf(playTake.isVisible()));

1785                 Var.add(String.valueOf(playTake.getX()));

1786                 Var.add(String.valueOf(playTake.getY()));

1787                 Var.add(String.valueOf(i));

1788                 

1789                 playTake.setVisible(false);

1790                 play.setBounds(playTake.getX(),playTake.getY(),55,55);

1791             }

1792             

1793         }//相、象吃棋规则结束

1794         

1795         /**士、仕移动方法*/

1796         public void chapRule(int Man,JLabel play,JLabel playQ[],MouseEvent me){

1797             //上、右

1798             if (me.getX() - play.getX() >= 29 && me.getX() - play.getX() <= 114 && play.getY() - me.getY() >= 25 && play.getY() - me.getY() <= 90){

1799                 //士不能超过自己的界限

1800                 if (Man < 14 && (play.getX()+57) >= 195 && (play.getX()+57) <= 309 && (play.getY()-57) <= 170){

1801                     //当前记录添加到集合(用于悔棋)

1802                     Var.add(String.valueOf(play.isVisible()));

1803                     Var.add(String.valueOf(play.getX()));

1804                     Var.add(String.valueOf(play.getY()));

1805                     Var.add(String.valueOf(Man));

1806                     

1807                     play.setBounds(play.getX()+57,play.getY()-57,55,55);

1808                 }    

1809                 

1810                 //仕不能超过自己的界限

1811                 else if (Man > 13 && (play.getY()-57) >= 455 && (play.getX()+57)  >= 195 && (play.getX()+57) <= 309){

1812                     //当前记录添加到集合(用于悔棋)

1813                     Var.add(String.valueOf(play.isVisible()));

1814                     Var.add(String.valueOf(play.getX()));

1815                     Var.add(String.valueOf(play.getY()));

1816                     Var.add(String.valueOf(Man));

1817                     

1818                     play.setBounds(play.getX()+57,play.getY()-57,55,55);

1819                 }    

1820             }// else if 

1821             

1822             //上、左

1823             else if (play.getX() - me.getX() <= 114 && play.getX() - me.getX() >= 25 && play.getY() - me.getY() >= 20 && play.getY() - me.getY() <= 95){

1824                 //士不能超过自己的界限

1825                 if (Man < 14 &&  (play.getX()-57) >= 195 && (play.getX()-57) <= 309 && (play.getY()-57) <= 170  ){

1826                     //当前记录添加到集合(用于悔棋)

1827                     Var.add(String.valueOf(play.isVisible()));

1828                     Var.add(String.valueOf(play.getX()));

1829                     Var.add(String.valueOf(play.getY()));

1830                     Var.add(String.valueOf(Man));

1831                     

1832                     play.setBounds(play.getX()-57,play.getY()-57,55,55);

1833                 }    

1834                 

1835                 //仕不能超过自己的界限

1836                 else if (Man > 13 &&(play.getY()-57) >= 455 && (play.getX()-57)  >= 195 && (play.getX()-57) <= 309){

1837                     //当前记录添加到集合(用于悔棋)

1838                     Var.add(String.valueOf(play.isVisible()));

1839                     Var.add(String.valueOf(play.getX()));

1840                     Var.add(String.valueOf(play.getY()));

1841                     Var.add(String.valueOf(Man));

1842                     

1843                     play.setBounds(play.getX()-57,play.getY()-57,55,55);

1844                 }    

1845             }// else if 

1846             

1847             //下、左

1848             else if (play.getX() - me.getX() <= 114 && play.getX() - me.getX() >= 20 && me.getY() - play.getY() >= 2 && me.getY() - play.getY() <= 87){

1849                 //士不能超过自己的界限

1850                 if (Man < 14 && (play.getX()-57) >= 195 && (play.getX()-57) <= 309 && (play.getY()+57) <= 170 ){

1851                     //当前记录添加到集合(用于悔棋)

1852                     Var.add(String.valueOf(play.isVisible()));

1853                     Var.add(String.valueOf(play.getX()));

1854                     Var.add(String.valueOf(play.getY()));

1855                     Var.add(String.valueOf(Man));

1856                     

1857                     play.setBounds(play.getX()-57,play.getY()+57,55,55);

1858                 }    

1859                 

1860                 //仕不能超过自己的界限

1861                 else if (Man > 13 && (play.getY()+57) >= 455 && (play.getX()-57)  >= 195 && (play.getX()-57) <= 309){

1862                     //当前记录添加到集合(用于悔棋)

1863                     Var.add(String.valueOf(play.isVisible()));

1864                     Var.add(String.valueOf(play.getX()));

1865                     Var.add(String.valueOf(play.getY()));

1866                     Var.add(String.valueOf(Man));

1867                     

1868                     play.setBounds(play.getX()-57,play.getY()+57,55,55);

1869                 }

1870                 

1871             }// else if 

1872             

1873             

1874             //下、右

1875             else if (me.getX() - play.getX() >= 27 && me.getX() - play.getX() <= 114 && me.getY() - play.getY() >= 2 && me.getY() - play.getY() <= 87){

1876                 //士不能超过自己的界限

1877                 if (Man < 14 && (play.getX()+57) >= 195 && (play.getX()+57) <= 309 && (play.getY()+57) <= 170){

1878                     //当前记录添加到集合(用于悔棋)

1879                     Var.add(String.valueOf(play.isVisible()));

1880                     Var.add(String.valueOf(play.getX()));

1881                     Var.add(String.valueOf(play.getY()));

1882                     Var.add(String.valueOf(Man));

1883                     

1884                     play.setBounds(play.getX()+57,play.getY()+57,55,55);

1885                 }

1886                 

1887                 //仕不能超过自己的界限

1888                 else if (Man > 13 &&(play.getY()+57) >= 455 && (play.getX()+57)  >= 195 && (play.getX()+57) <= 309){

1889                     //当前记录添加到集合(用于悔棋)

1890                     Var.add(String.valueOf(play.isVisible()));

1891                     Var.add(String.valueOf(play.getX()));

1892                     Var.add(String.valueOf(play.getY()));

1893                     Var.add(String.valueOf(Man));

1894                     

1895                     play.setBounds(play.getX()+57,play.getY()+57,55,55);

1896                 }

1897             }//else if 

1898             

1899         }//士、仕移动规则结束

1900 

1901 

1902         /**士、仕吃棋规则*/

1903         public void chapRule(int Man ,JLabel play,JLabel playTake,JLabel playQ[]){

1904             //当前状态

1905             boolean Chap = false;    

1906             

1907             //上、右

1908             if (playTake.getX() - play.getX() >= 20 && playTake.getX() - play.getX() <= 114 && play.getY() - playTake.getY() >= 2 && play.getY() - playTake.getY() <= 87){

1909                 //被吃的棋子是否和当前士相近

1910                 if (Man < 14 && playTake.getX() >= 195 && playTake.getX() <= 309 && playTake.getY() <= 170 && playTake.isVisible()){

1911                     Chap = true;

1912                 }

1913                 

1914                 //被吃的棋子是否和当前仕相近

1915                 else if (Man > 13 && playTake.getX() >= 195 && playTake.getX() <= 309 && playTake.getY() >= 455 && playTake.isVisible()){

1916                     Chap = true;

1917                 }

1918             }//if

1919             

1920             //上、左

1921             else if (play.getX() - playTake.getX() <= 114 && play.getX() - playTake.getX() >= 25 && play.getY() - playTake.getY() >= 2 && play.getY() - playTake.getY() <= 87){

1922                 //被吃的棋子是否和当前士相近

1923                 if (Man < 14 && playTake.getX() >= 195 && playTake.getX() <= 309 && playTake.getY() <= 170 && playTake.isVisible()){

1924                     Chap = true;

1925                 }

1926                 

1927                 //被吃的棋子是否和当前仕相近

1928                 else if (Man > 13 && playTake.getX() >= 195 && playTake.getX() <= 309 && playTake.getY() >= 455 && playTake.isVisible()){

1929                     Chap = true;

1930                 }

1931             }// else if 

1932             

1933             //下、左

1934             else if (play.getX() - playTake.getX() <= 114 && play.getX() - playTake.getX() >= 25 && playTake.getY() - play.getY() >= 2 && playTake.getY() - play.getY() <= 87){

1935                 //被吃的棋子是否和当前士相近

1936                 if (Man < 14 && playTake.getX() >= 195 && playTake.getX() <= 309 && playTake.getY() <= 170 && playTake.isVisible()){

1937                     Chap = true;

1938                 }

1939                 

1940                 //被吃的棋子是否和当前仕相近

1941                 else if (Man > 13 && playTake.getX() >= 195 && playTake.getX() <= 309 && playTake.getY() >= 455 && playTake.isVisible()){

1942                     Chap = true;

1943                 }

1944             }// else if 

1945             

1946             //下、右

1947             else if (playTake.getX() - play.getX() >= 25 && playTake.getX() - play.getX() <= 114 && playTake.getY() - play.getY() >= 2 && playTake.getY() - play.getY() <= 87){

1948                 //被吃的棋子是否和当前士相近

1949                 if (Man < 14 && playTake.getX() >= 195 && playTake.getX() <= 309 && playTake.getY() <= 170 && playTake.isVisible()){

1950                     Chap = true;

1951                 }

1952                 

1953                 //被吃的棋子是否和当前仕相近

1954                 else if (Man > 13 && playTake.getX() >= 195 && playTake.getX() <= 309 && playTake.getY() >= 455 && playTake.isVisible()){

1955                     Chap = true;

1956                 }

1957             }//else if 

1958             

1959             //可移动、并不能吃自己的棋子

1960             if (Chap && playTake.getName().charAt(1) != play.getName().charAt(1)){

1961                 //当前记录添加到集合(用于悔棋)

1962                 Var.add(String.valueOf(play.isVisible()));

1963                 Var.add(String.valueOf(play.getX()));

1964                 Var.add(String.valueOf(play.getY()));

1965                 Var.add(String.valueOf(Man));

1966                 

1967                 //当前记录添加到集合(用于悔棋)

1968                 Var.add(String.valueOf(playTake.isVisible()));

1969                 Var.add(String.valueOf(playTake.getX()));

1970                 Var.add(String.valueOf(playTake.getY()));

1971                 Var.add(String.valueOf(i));

1972                 

1973                 playTake.setVisible(false);

1974                 play.setBounds(playTake.getX(),playTake.getY(),55,55);

1975             }

1976             

1977         }//士、仕吃棋规则结束

1978         

1979         /**将移动规则*/

1980         public void willRule(int Man,JLabel play,JLabel playQ[],MouseEvent me){

1981             //向上

1982             if ((me.getX()-play.getX()) >= 0 && (me.getX()-play.getX()) <= 55 && (play.getY()-me.getY()) >=2 && play.getY()-me.getY() <= 87){

1983                 //将是否超过自己的界限

1984                 if (Man == 30 && me.getX() >= 195 && me.getX() <= 359 && me.getY() <= 170){

1985                     //当前记录添加到集合(用于悔棋)

1986                     Var.add(String.valueOf(play.isVisible()));

1987                     Var.add(String.valueOf(play.getX()));

1988                     Var.add(String.valueOf(play.getY()));

1989                     Var.add(String.valueOf(Man));

1990                     

1991                     play.setBounds(play.getX(),play.getY()-57,55,55);    

1992                 }    

1993                 

1994                 //帅是否超过自己的界限

1995                 else if (Man == 31 && me.getY() >= 455 && me.getX() >= 195 && me.getX() <= 359){

1996                     //当前记录添加到集合(用于悔棋)

1997                     Var.add(String.valueOf(play.isVisible()));

1998                     Var.add(String.valueOf(play.getX()));

1999                     Var.add(String.valueOf(play.getY()));

2000                     Var.add(String.valueOf(Man));

2001                     

2002                     play.setBounds(play.getX(),play.getY()-57,55,55);

2003                 }

2004             }//if

2005             

2006             //向左

2007             else if (play.getX() - me.getX() >= 2 && play.getX() - me.getX() <= 57 && me.getY() - play.getY() <= 27 && me.getY() - play.getY() >= -27){

2008                 //将是否超过自己的界限

2009                 if (Man == 30 && me.getX() >= 195 && me.getX() <= 359 && me.getY() <= 170){

2010                     //当前记录添加到集合(用于悔棋)

2011                     Var.add(String.valueOf(play.isVisible()));

2012                     Var.add(String.valueOf(play.getX()));

2013                     Var.add(String.valueOf(play.getY()));

2014                     Var.add(String.valueOf(Man));

2015                     

2016                     play.setBounds(play.getX()-57,play.getY(),55,55);

2017                 }

2018                 

2019                 //帅是否超过自己的界限

2020                 else if (Man == 31 && me.getY() >= 455 && me.getX() >= 195 && me.getX() <= 359){

2021                     //当前记录添加到集合(用于悔棋)

2022                     Var.add(String.valueOf(play.isVisible()));

2023                     Var.add(String.valueOf(play.getX()));

2024                     Var.add(String.valueOf(play.getY()));

2025                     Var.add(String.valueOf(Man));

2026                     

2027                     play.setBounds(play.getX()-57,play.getY(),55,55);

2028                 }

2029             }//else if 

2030             

2031             //向右

2032             else if (me.getX() - play.getX() >= 57 && me.getX() - play.getX() <= 112 && me.getY() - play.getY() <= 27 && me.getY() - play.getY() >= -27){

2033                 //将、帅规则

2034                 if (Man == 30 && me.getX() >= 195 && me.getX() <= 359 && me.getY() <= 170){

2035                     //当前记录添加到集合(用于悔棋)

2036                     Var.add(String.valueOf(play.isVisible()));

2037                     Var.add(String.valueOf(play.getX()));

2038                     Var.add(String.valueOf(play.getY()));

2039                     Var.add(String.valueOf(Man));

2040                     

2041                     play.setBounds(play.getX()+57,play.getY(),55,55);    

2042                 }    

2043                 

2044                 else if (Man == 31 && me.getY() >= 455 && me.getX() >= 195 && me.getX() <= 359){

2045                     //当前记录添加到集合(用于悔棋)

2046                     Var.add(String.valueOf(play.isVisible()));

2047                     Var.add(String.valueOf(play.getX()));    

2048                     Var.add(String.valueOf(play.getY()));

2049                     Var.add(String.valueOf(Man));

2050                     

2051                     play.setBounds(play.getX()+57,play.getY(),55,55);

2052                 }

2053             }//else if 

2054             

2055             //向下

2056             else if (me.getX() - play.getX() >= 0 && me.getX() - play.getX() <= 55 && me.getY() - play.getY() <= 87 && me.getY() - play.getY() >= 27){

2057                 //将、帅规则

2058                 if (Man == 30 && me.getX() >= 195 && me.getX() <= 359 && me.getY() <= 170){

2059                     //当前记录添加到集合(用于悔棋)

2060                     Var.add(String.valueOf(play.isVisible()));

2061                     Var.add(String.valueOf(play.getX()));

2062                     Var.add(String.valueOf(play.getY()));

2063                     Var.add(String.valueOf(Man));

2064                     

2065                     play.setBounds(play.getX(),play.getY()+57,55,55);

2066                 }

2067                 

2068                 else if (Man == 31 && me.getY() >= 455 && me.getX() >= 195 && me.getX() <= 359){

2069                     //当前记录添加到集合(用于悔棋)

2070                     Var.add(String.valueOf(play.isVisible()));

2071                     Var.add(String.valueOf(play.getX()));

2072                     Var.add(String.valueOf(play.getY()));

2073                     Var.add(String.valueOf(Man));

2074                 

2075                     play.setBounds(play.getX(),play.getY()+57,55,55);

2076                 }

2077 

2078             }//else if

2079             

2080         }//将、帅移动规则结束

2081 

2082         public void willRule(int Man ,JLabel play,JLabel playTake ,JLabel playQ[]){

2083             //当前状态

2084             boolean will = false;

2085             

2086             //向上吃

2087             if (play.getX() - playTake.getX() >= 0 && play.getX() - playTake.getX() <= 55 && play.getY() - playTake.getY() >= 27 && play.getY() - playTake.getY() <= 87 && playTake.isVisible()){

2088                 //被吃的棋子是否和当前将相近

2089                 if (Man == 30 && playTake.getX() >= 195 && playTake.getX() <= 309 && playTake.getY() <= 170){

2090                     will = true;

2091                 }

2092                 

2093                 //被吃的棋子是否和当前帅相近

2094                 else if (Man == 31 && playTake.getY() >= 455 && playTake.getX() >= 195 && playTake.getX() <= 309){

2095                     will = true; 

2096                 }

2097             }

2098             

2099             //向左吃

2100             else if (play.getX() - playTake.getX() >= 2 && play.getX() - playTake.getX() <= 57 && playTake.getY() - play.getY() <= 27 && playTake.getY() - play.getY() >= -27 && playTake.isVisible()){

2101                 //被吃的棋子是否和当前将相近

2102                 if (Man == 30 && playTake.getX() >= 195 && playTake.getX() <= 309 && playTake.getY() <= 170){

2103                     will = true;

2104                 }

2105                 

2106                 //被吃的棋子是否和当前帅相近

2107                 else if (Man == 31 && playTake.getY() >= 455 && playTake.getX() >= 195 && playTake.getX() <= 309){

2108                     will = true; 

2109                 }

2110             }

2111             

2112             //向右吃

2113             else if (playTake.getX() - play.getX() >= 2 && playTake.getX() - play.getX() <= 57 && playTake.getY() - play.getY() <= 27 && playTake.getY() - play.getY() >= -27 && playTake.isVisible()){

2114                 //被吃的棋子是否和当前将相近

2115                 if (Man == 30 && playTake.getX() >= 195 && playTake.getX() <= 309 && playTake.getY() <= 170){

2116                     will = true;

2117                 }

2118                 

2119                 //被吃的棋子是否和当前帅相近

2120                 else if (Man == 31 && playTake.getY() >= 455 && playTake.getX() >= 195 && playTake.getX() <= 309){

2121                     will = true; 

2122                 }

2123             }

2124             

2125             //向下

2126             else if (playTake.getX() - play.getX() >= 0 && playTake.getX() - play.getX() <= 87 && playTake.getY() - play.getY() <= 27 && playTake.getY() - play.getY() >= 40 && playTake.isVisible()){

2127                 //被吃的棋子是否和当前将相近

2128                 if (Man == 30 && playTake.getX() >= 195 && playTake.getX() <= 309 && playTake.getY() <= 170){

2129                     will = true;

2130                 }

2131                 

2132                 //被吃的棋子是否和当前帅相近

2133                 else if (Man == 31 && playTake.getY() >= 455 && playTake.getX() >= 195 && playTake.getX() <= 309){

2134                     will = true; 

2135                 }

2136             }

2137                 

2138             //不能吃自己的棋子、符合当前要求    

2139             if (playTake.getName().charAt(1) != play.getName().charAt(1) && will){

2140                 //当前记录添加到集合(用于悔棋)

2141                 Var.add(String.valueOf(play.isVisible()));

2142                 Var.add(String.valueOf(play.getX()));

2143                 Var.add(String.valueOf(play.getY()));

2144                 Var.add(String.valueOf(Man));

2145                 

2146                 //当前记录添加到集合(用于悔棋)

2147                 Var.add(String.valueOf(playTake.isVisible()));

2148                 Var.add(String.valueOf(playTake.getX()));

2149                 Var.add(String.valueOf(playTake.getY()));

2150                 Var.add(String.valueOf(i));

2151 

2152                 playTake.setVisible(false);

2153                 play.setBounds(playTake.getX(),playTake.getY(),55,55);

2154             }            

2155             

2156         }//将、帅吃规则结束

2157         

2158     }//规则类

2159     

2160 }//主框架类
View Code

 

你可能感兴趣的:(java)