Java棋类游戏实践之中国象棋

本文实例讲述了java实现的中国象棋游戏代码，分享给大家供大家参考，具体代码如下

一、实践目的：

1.鼠标点击、拖动等事件的应用与区别

2.棋谱文件的保存与读取

3.完善象棋的规则。

二、实践内容：

中国象棋历史悠久，吸引了无数的人研究，现对中国象棋的对战和实现棋谱的制作做如下的设计和说明，供大家参考学习。

1、机机对弈，红方先手。在符合规则的情况下拖动棋子到目的地，松鼠标落子。

人人对弈图

2、制作棋谱，选择制作棋谱菜单后，对弈开始，并记录了下棋过程。

选择“制作棋谱”菜单

棋谱制作完毕红方胜出

一方胜出后弹出胜利消息对话框。点击确定后，选择“保存棋谱”菜单，弹出保存文件对话框。

保存棋谱对话框

3.演示棋谱，选择演示棋谱菜单后，弹出打开对话框，选择保存好的棋谱，开始演示。

演示棋谱对话框

演示棋谱过程（自动和手动两种）

三、参考代码：

1.象棋主类 文件chinesechess.java

package cn.edu.ouc.chinesechess; 
 
import javax.swing.*; 
import java.awt.*; 
import java.awt.event.*; 
import java.io.*; 
import java.util.linkedlist; 
 
/** 
 * 象棋主类 
 * 
 * @author cnlht 
 */ 
public class chinesechess extends jframe implements actionlistener { 
 chessboard board = null; 
 demon demon = null; 
 makechessmanual record = null; 
 container con = null; 
 jmenubar bar; 
 jmenu filemenu; 
 jmenuitem 制作棋谱, 保存棋谱, 演示棋谱; 
 jfilechooser filechooser = null; 
 linkedlist 棋谱 = null; 
 
 public chinesechess() { 
  bar = new jmenubar(); 
  filemenu = new jmenu("中国象棋"); 
  制作棋谱 = new jmenuitem("制作棋谱"); 
  保存棋谱 = new jmenuitem("保存棋谱"); 
  保存棋谱.setenabled(false); 
  演示棋谱 = new jmenuitem("演示棋谱"); 
  filemenu.add(制作棋谱); 
  filemenu.add(保存棋谱); 
  filemenu.add(演示棋谱); 
  bar.add(filemenu); 
  setjmenubar(bar); 
  settitle(制作棋谱.gettext()); 
  制作棋谱.addactionlistener(this); 
  保存棋谱.addactionlistener(this); 
  演示棋谱.addactionlistener(this); 
  board = new chessboard(45, 45, 9, 10); 
  record = board.record; 
  con = getcontentpane(); 
  jsplitpane split = new jsplitpane(jsplitpane.horizontal_split, true, 
    board, record); 
  split.setdividersize(5); 
  split.setdividerlocation(460); 
  con.add(split, borderlayout.center); 
  addwindowlistener(new windowadapter() { 
   public void windowclosing(windowevent e) { 
    system.exit(0); 
   } 
  }); 
  setvisible(true); 
  setbounds(60, 20, 690, 540); 
  filechooser = new jfilechooser(); 
  con.validate(); 
  validate(); 
 } 
 
 public void actionperformed(actionevent e) { 
  if (e.getsource() == 制作棋谱) { 
   con.removeall(); 
   保存棋谱.setenabled(true); 
   this.settitle(制作棋谱.gettext()); 
   board = new chessboard(45, 45, 9, 10); 
   record = board.record; 
   jsplitpane split = new jsplitpane(jsplitpane.horizontal_split, 
     true, board, record); 
   split.setdividersize(5); 
   split.setdividerlocation(460); 
   con.add(split, borderlayout.center); 
   validate(); 
  } 
  if (e.getsource() == 保存棋谱) { 
   int state = filechooser.showsavedialog(null); 
   file savefile = filechooser.getselectedfile(); 
   if (savefile != null && state == jfilechooser.approve_option) { 
    try { 
     fileoutputstream outone = new fileoutputstream(savefile); 
     objectoutputstream outtwo = new objectoutputstream(outone); 
     outtwo.writeobject(record.获取棋谱()); 
     outone.close(); 
     outtwo.close(); 
    } catch (ioexception event) { 
    } 
   } 
  } 
  if (e.getsource() == 演示棋谱) { 
   con.removeall(); 
   con.repaint(); 
   con.validate(); 
   validate(); 
   保存棋谱.setenabled(false); 
 
   int state = filechooser.showopendialog(null); 
   file openfile = filechooser.getselectedfile(); 
   if (openfile != null && state == jfilechooser.approve_option) { 
    try { 
     fileinputstream inone = new fileinputstream(openfile); 
     objectinputstream intwo = new objectinputstream(inone); 
     棋谱 = (linkedlist) intwo.readobject(); 
     inone.close(); 
     intwo.close(); 
     chessboard board = new chessboard(45, 45, 9, 10); 
     demon = new demon(board); 
     demon.set棋谱(棋谱); 
     con.add(demon, borderlayout.center); 
     con.validate(); 
     validate(); 
     this.settitle(演示棋谱.gettext() + ":" + openfile); 
    } catch (exception event) { 
     jlabel label = new jlabel("不是棋谱文件"); 
     label.setfont(new font("隶书", font.bold, 60)); 
     label.setforeground(color.red); 
     label.sethorizontalalignment(swingconstants.center); 
     con.add(label, borderlayout.center); 
     con.validate(); 
     this.settitle("没有打开棋谱"); 
     validate(); 
    } 
   } else { 
    jlabel label = new jlabel("没有打开棋谱文件呢"); 
    label.setfont(new font("隶书", font.bold, 50)); 
    label.setforeground(color.pink); 
    label.sethorizontalalignment(swingconstants.center); 
    con.add(label, borderlayout.center); 
    con.validate(); 
    this.settitle("没有打开棋谱文件呢"); 
    validate(); 
   } 
  } 
 } 
 
 public static void main(string args[]) { 
  new chinesechess(); 
 } 
} 

2.象棋棋盘类文件chessboard.java

package cn.edu.ouc.chinesechess; 
 
import javax.swing.*; 
import java.awt.*; 
import java.awt.event.*; 
 
/** 
 * 棋盘类 
 * 
 * @author cnlht 
 */ 
public class chessboard extends jpanel implements mouselistener, 
  mousemotionlistener { 
 public chesspoint point[][]; 
 public int unitwidth, unitheight; 
 private int x轴长, y轴长; 
 private int x, y; 
 private image img; 
 protected image pieceimg; 
 private boolean move = false; 
 public string 红方颜色 = "红方", 黑方颜色 = "黑方"; 
 chesspiece 红车1, 红车2, 红马1, 红马2, 红相1, 红相2, 红帅, 红士1, 红士2, 红兵1, 红兵2, 红兵3, 红兵4, 
   红兵5, 红炮1, 红炮2; 
 chesspiece 黑车1, 黑车2, 黑马1, 黑马2, 黑将, 黑士1, 黑士2, 黑卒1, 黑卒2, 黑卒3, 黑卒4, 黑卒5, 黑象1, 
   黑象2, 黑炮1, 黑炮2; 
 
 int startx, starty; 
 int starti, startj; 
 public boolean 红方走棋 = true, 黑方走棋 = false; 
 rule rule = null; 
 public makechessmanual record = null; 
 
 public chessboard(int w, int h, int r, int c) { 
  setlayout(null); 
  addmouselistener(this); 
  addmousemotionlistener(this); 
  color bc = getbackground(); 
  unitwidth = w; 
  unitheight = h; 
  x轴长 = r; 
  y轴长 = c; 
 
  point = new chesspoint[r + 1][c + 1]; 
 
  for (int i = 1; i <= r; i++) { 
   for (int j = 1; j <= c; j++) { 
    point[i][j] = new chesspoint(i * unitwidth, j * unitheight, 
      false); 
   } 
  } 
 
  rule = new rule(this, point); 
  record = new makechessmanual(this, point); 
 
  img = toolkit.getdefaulttoolkit().getimage("board.jpg"); 
  pieceimg = toolkit.getdefaulttoolkit().getimage("piece.gif"); 
   
  红车1 = new chesspiece("車", color.red, bc, w - 4, h - 4, this); 
  红车1.set棋子类别(红方颜色); 
  红车2 = new chesspiece("車", color.red, bc, w - 4, h - 4, this); 
  红车2.set棋子类别(红方颜色); 
  红马1 = new chesspiece("馬", color.red, bc, w - 4, h - 4, this); 
  红马1.set棋子类别(红方颜色); 
  红马2 = new chesspiece("馬", color.red, bc, w - 4, h - 4, this); 
  红马2.set棋子类别(红方颜色); 
  红炮1 = new chesspiece("炮", color.red, bc, w - 4, h - 4, this); 
  红炮1.set棋子类别(红方颜色); 
  红炮2 = new chesspiece("炮", color.red, bc, w - 4, h - 4, this); 
  红炮2.set棋子类别(红方颜色); 
  红相1 = new chesspiece("相", color.red, bc, w - 4, h - 4, this); 
  红相1.set棋子类别(红方颜色); 
  红相2 = new chesspiece("相", color.red, bc, w - 4, h - 4, this); 
  红相2.set棋子类别(红方颜色); 
  红士1 = new chesspiece("仕", color.red, bc, w - 4, h - 4, this); 
  红士1.set棋子类别(红方颜色); 
  红士2 = new chesspiece("仕", color.red, bc, w - 4, h - 4, this); 
  红士2.set棋子类别(红方颜色); 
  红帅 = new chesspiece("帅", color.red, bc, w - 4, h - 4, this); 
  红帅.set棋子类别(红方颜色); 
  红兵1 = new chesspiece("兵", color.red, bc, w - 4, h - 4, this); 
  红兵1.set棋子类别(红方颜色); 
  红兵2 = new chesspiece("兵", color.red, bc, w - 4, h - 4, this); 
  红兵2.set棋子类别(红方颜色); 
  红兵3 = new chesspiece("兵", color.red, bc, w - 4, h - 4, this); 
  红兵3.set棋子类别(红方颜色); 
  红兵4 = new chesspiece("兵", color.red, bc, w - 4, h - 4, this); 
  红兵4.set棋子类别(红方颜色); 
  红兵5 = new chesspiece("兵", color.red, bc, w - 4, h - 4, this); 
  红兵5.set棋子类别(红方颜色); 
 
  黑将 = new chesspiece("将", color.black, bc, w - 4, h - 4, this); 
  黑将.set棋子类别(黑方颜色); 
  黑士1 = new chesspiece("士", color.black, bc, w - 4, h - 4, this); 
  黑士1.set棋子类别(黑方颜色); 
  黑士2 = new chesspiece("士", color.black, bc, w - 4, h - 4, this); 
  黑士2.set棋子类别(黑方颜色); 
  黑车1 = new chesspiece("车", color.black, bc, w - 4, h - 4, this); 
  黑车1.set棋子类别(黑方颜色); 
  黑车2 = new chesspiece("车", color.black, bc, w - 4, h - 4, this); 
  黑车2.set棋子类别(黑方颜色); 
  黑炮1 = new chesspiece("炮", color.black, bc, w - 4, h - 4, this); 
  黑炮1.set棋子类别(黑方颜色); 
  黑炮2 = new chesspiece("炮", color.black, bc, w - 4, h - 4, this); 
  黑炮2.set棋子类别(黑方颜色); 
  黑象1 = new chesspiece("象", color.black, bc, w - 4, h - 4, this); 
  黑象1.set棋子类别(黑方颜色); 
  黑象2 = new chesspiece("象", color.black, bc, w - 4, h - 4, this); 
  黑象2.set棋子类别(黑方颜色); 
  黑马1 = new chesspiece("马", color.black, bc, w - 4, h - 4, this); 
  黑马1.set棋子类别(黑方颜色); 
  黑马2 = new chesspiece("马", color.black, bc, w - 4, h - 4, this); 
  黑马2.set棋子类别(黑方颜色); 
  黑卒1 = new chesspiece("卒", color.black, bc, w - 4, h - 4, this); 
  黑卒1.set棋子类别(黑方颜色); 
  黑卒2 = new chesspiece("卒", color.black, bc, w - 4, h - 4, this); 
  黑卒2.set棋子类别(黑方颜色); 
  黑卒3 = new chesspiece("卒", color.black, bc, w - 4, h - 4, this); 
  黑卒3.set棋子类别(黑方颜色); 
  黑卒4 = new chesspiece("卒", color.black, bc, w - 4, h - 4, this); 
  黑卒4.set棋子类别(黑方颜色); 
  黑卒5 = new chesspiece("卒", color.black, bc, w - 4, h - 4, this); 
  黑卒5.set棋子类别(黑方颜色); 
  point[1][10].setpiece(红车1, this); 
  point[2][10].setpiece(红马1, this); 
  point[3][10].setpiece(红相1, this); 
  point[4][10].setpiece(红士1, this); 
  point[5][10].setpiece(红帅, this); 
  point[6][10].setpiece(红士2, this); 
  point[7][10].setpiece(红相2, this); 
  point[8][10].setpiece(红马2, this); 
  point[9][10].setpiece(红车2, this); 
  point[2][8].setpiece(红炮1, this); 
  point[8][8].setpiece(红炮2, this); 
  point[1][7].setpiece(红兵1, this); 
  point[3][7].setpiece(红兵2, this); 
  point[5][7].setpiece(红兵3, this); 
  point[7][7].setpiece(红兵4, this); 
  point[9][7].setpiece(红兵5, this); 
 
  point[1][1].setpiece(黑车1, this); 
  point[2][1].setpiece(黑马1, this); 
  point[3][1].setpiece(黑象1, this); 
  point[4][1].setpiece(黑士1, this); 
  point[5][1].setpiece(黑将, this); 
  point[6][1].setpiece(黑士2, this); 
  point[7][1].setpiece(黑象2, this); 
  point[8][1].setpiece(黑马2, this); 
  point[9][1].setpiece(黑车2, this); 
  point[2][3].setpiece(黑炮1, this); 
  point[8][3].setpiece(黑炮2, this); 
  point[1][4].setpiece(黑卒1, this); 
  point[3][4].setpiece(黑卒2, this); 
  point[5][4].setpiece(黑卒3, this); 
  point[7][4].setpiece(黑卒4, this); 
  point[9][4].setpiece(黑卒5, this); 
 
 } 
 
 public void paintcomponent(graphics g) { 
  super.paintcomponent(g); 
 
  int imgwidth = img.getwidth(this); 
  int imgheight = img.getheight(this);// 获得图片的宽度与高度 
  int fwidth = getwidth(); 
  int fheight = getheight();// 获得窗口的宽度与高度 
  int x = (fwidth - imgwidth) / 2; 
  int y = (fheight - imgheight) / 2; 
  g.drawimage(img, x, y, null); 
 
  for (int j = 1; j <= y轴长; j++) { 
   g.drawline(point[1][j].x, point[1][j].y, point[x轴长][j].x, 
     point[x轴长][j].y); 
  } 
  for (int i = 1; i <= x轴长; i++) { 
   if (i != 1 && i != x轴长) { 
    g.drawline(point[i][1].x, point[i][1].y, point[i][y轴长 - 5].x, 
      point[i][y轴长 - 5].y); 
    g.drawline(point[i][y轴长 - 4].x, point[i][y轴长 - 4].y, 
      point[i][y轴长].x, point[i][y轴长].y); 
   } else { 
    g.drawline(point[i][1].x, point[i][1].y, point[i][y轴长].x, 
      point[i][y轴长].y); 
   } 
  } 
 
  g.drawline(point[4][1].x, point[4][1].y, point[6][3].x, point[6][3].y); 
  g.drawline(point[6][1].x, point[6][1].y, point[4][3].x, point[4][3].y); 
  g.drawline(point[4][8].x, point[4][8].y, point[6][y轴长].x, 
    point[6][y轴长].y); 
  g.drawline(point[4][y轴长].x, point[4][y轴长].y, point[6][8].x, 
    point[6][8].y); 
 
  for (int i = 1; i <= x轴长; i++) { 
   g.drawstring("" + i, i * unitwidth, unitheight / 2); 
  } 
  int j = 1; 
  for (char c = 'a'; c <= 'j'; c++) { 
   g.drawstring("" + c, unitwidth / 4, j * unitheight); 
   j++; 
  } 
 
 } 
 
 /**鼠标按下事件*/ 
 public void mousepressed(mouseevent e) { 
  chesspiece piece = null; 
  rectangle rect = null; 
  if (e.getsource() == this) 
   move = false; 
  if (move == false) 
   if (e.getsource() instanceof chesspiece) { 
    piece = (chesspiece) e.getsource(); 
    startx = piece.getbounds().x; 
    starty = piece.getbounds().y; 
 
    rect = piece.getbounds(); 
    for (int i = 1; i <= x轴长; i++) { 
     for (int j = 1; j <= y轴长; j++) { 
      int x = point[i][j].getx(); 
      int y = point[i][j].gety(); 
      if (rect.contains(x, y)) { 
       starti = i; 
       startj = j; 
       break; 
      } 
 
     } 
    } 
   } 
 } 
 
 public void mousemoved(mouseevent e) { 
 } 
 
 /**鼠标拖动事件*/ 
 public void mousedragged(mouseevent e) { 
 
  chesspiece piece = null; 
  if (e.getsource() instanceof chesspiece) { 
   piece = (chesspiece) e.getsource(); 
 
   move = true; 
 
   e = swingutilities.convertmouseevent(piece, e, this); 
  } 
 
  if (e.getsource() == this) { 
   if (move && piece != null) { 
    x = e.getx(); 
    y = e.gety(); 
    if (红方走棋 && ((piece.棋子类别()).equals(红方颜色))) { 
     piece.setlocation(x - piece.getwidth() / 2, 
       y - piece.getheight() / 2); 
    } 
    if (黑方走棋 && (piece.棋子类别().equals(黑方颜色))) { 
     piece.setlocation(x - piece.getwidth() / 2, 
       y - piece.getheight() / 2); 
    } 
   } 
  } 
 } 
 
 /**松开鼠标事件*/ 
 public void mousereleased(mouseevent e) { 
  chesspiece piece = null; 
  move = false; 
  rectangle rect = null; 
  if (e.getsource() instanceof chesspiece) { 
   piece = (chesspiece) e.getsource(); 
   rect = piece.getbounds(); 
 
   e = swingutilities.convertmouseevent(piece, e, this); 
  } 
  if (e.getsource() == this) { 
   boolean containchesspoint = false; 
   int x = 0, y = 0; 
   int m = 0, n = 0; 
   if (piece != null) { 
    for (int i = 1; i <= x轴长; i++) { 
     for (int j = 1; j <= y轴长; j++) { 
      x = point[i][j].getx(); 
      y = point[i][j].gety(); 
      if (rect.contains(x, y)) { 
 
       containchesspoint = true; 
       m = i; 
       n = j; 
       break; 
      } 
 
     } 
    } 
   } 
   if (piece != null && containchesspoint) { 
    color piececolor = piece.获取棋子颜色(); 
    if (point[m][n].ispiece()) { 
     color c = (point[m][n].getpiece()).获取棋子颜色(); 
     if (piececolor.getrgb() == c.getrgb()) { 
      piece.setlocation(startx, starty); 
 
      (point[starti][startj]).set有棋子(true); 
     } else { 
      boolean ok = rule.movepiecerule(piece, starti, startj, 
        m, n); 
      if (ok) { 
       chesspiece pieceremoved = point[m][n].getpiece(); 
       point[m][n].removepiece(pieceremoved, this); 
       point[m][n].setpiece(piece, this); 
       (point[starti][startj]).set有棋子(false); 
       record.记录棋谱(piece, starti, startj, m, n); 
       record.记录吃掉的棋子(pieceremoved); 
       rule.iswine(pieceremoved); 
       if (piece.棋子类别().equals(红方颜色)) { 
        红方走棋 = false; 
        黑方走棋 = true; 
       } 
       if (piece.棋子类别().equals(黑方颜色)) { 
        黑方走棋 = false; 
        红方走棋 = true; 
       } 
       validate(); 
       repaint(); 
      } else { 
       piece.setlocation(startx, starty); 
       (point[starti][startj]).set有棋子(true); 
      } 
     } 
 
    } else { 
 
     boolean ok = rule 
       .movepiecerule(piece, starti, startj, m, n); 
     if (ok) { 
      point[m][n].setpiece(piece, this); 
      (point[starti][startj]).set有棋子(false); 
      record.记录棋谱(piece, starti, startj, m, n); 
      record.记录吃掉的棋子("没吃棋子"); 
 
      if (piece.棋子类别().equals(红方颜色)) { 
       红方走棋 = false; 
       黑方走棋 = true; 
      } 
      if (piece.棋子类别().equals(黑方颜色)) { 
       黑方走棋 = false; 
       红方走棋 = true; 
      } 
     } else { 
      piece.setlocation(startx, starty); 
      (point[starti][startj]).set有棋子(true); 
     } 
    } 
   } 
 
   if (piece != null && !containchesspoint) { 
    piece.setlocation(startx, starty); 
    (point[starti][startj]).set有棋子(true); 
   } 
  } 
 } 
 
 public void mouseentered(mouseevent e) { 
 } 
 
 public void mouseexited(mouseevent e) { 
 } 
 
 public void mouseclicked(mouseevent e) { 
 } 
} 

3.棋子类文件chesspiece.java

package cn.edu.ouc.chinesechess; 
 
import javax.swing.*; 
import java.awt.*; 
import java.awt.event.*; 
 
/** 
 * 棋子类 
 * 
 * @author cnlht 
 */ 
public class chesspiece extends jlabel { 
 string name; // 棋子名字 
 color backcolor = null, forecolor;// 背景色和前景色 
 string 颜色类别 = null; 
 chessboard board = null; 
 int width, height;// 大小 
 
 public chesspiece(string name, color fc, color bc, int width, int height, 
   chessboard board) {// 构造棋子 
  this.name = name; 
  this.board = board; 
  this.width = width; 
  this.height = height; 
  forecolor = fc; 
  backcolor = bc; 
  setsize(width, height); 
  setbackground(bc); 
  addmousemotionlistener(board); 
  addmouselistener(board); 
 } 
 
 // 绘制棋子 
 public void paint(graphics g) {  
  g.drawimage(board.pieceimg, 2, 2, width-2, height-2, null); 
  g.setcolor(forecolor); 
  g.setfont(new font("楷体", font.bold, 26)); 
  g.drawstring(name, 7, height - 8);// 在棋子上绘制 “棋子名” 
  g.setcolor(color.black); 
  //g.drawoval(1, 1, width - 1, height - 1); 
  float linewidth = 2.3f; 
  ((graphics2d)g).setstroke(new basicstroke(linewidth)); 
  ((graphics2d)g).drawoval(2, 2, width-2, height-2); 
 } 
 
 public int getwidth() { 
  return width; 
 } 
 
 public int getheight() { 
  return height; 
 } 
 
 public string getname() { 
  return name; 
 } 
 
 public color 获取棋子颜色() { 
  return forecolor; 
 } 
 
 public void set棋子类别(string 类别) { 
  颜色类别 = 类别; 
 } 
 
 public string 棋子类别() { 
  return 颜色类别; 
 } 
} 

4.棋子点坐标类文件

package cn.edu.ouc.chinesechess; 
 
/** 
 * 棋点类 
 * 
 * @author cnlht 
 */ 
public class chesspoint { 
 /** 棋子坐标 */ 
 int x, y; 
  
 /** 该坐标 是否有子*/ 
 boolean 有棋子; 
  
 /** 改坐标的棋子 */ 
 chesspiece piece = null; 
  
 /** 坐标所属棋盘 */ 
 chessboard board = null; 
 
 public chesspoint(int x, int y, boolean boo) { 
  this.x = x; 
  this.y = y; 
  有棋子 = boo; 
 } 
 
 public boolean ispiece() { 
  return 有棋子; 
 } 
 
 public void set有棋子(boolean boo) { 
  有棋子 = boo; 
 } 
 
 public int getx() { 
  return x; 
 } 
 
 public int gety() { 
  return y; 
 } 
 
 // 设置改点棋子 
 public void setpiece(chesspiece piece, chessboard board) { 
  this.board = board; 
  this.piece = piece; 
  board.add(piece); 
  int w = (board.unitwidth); 
  int h = (board.unitheight); 
  piece.setbounds(x - w / 2, y - h / 2, w, h);// 棋子位置，宽度，高度 
  有棋子 = true; 
  board.validate(); 
 } 
 
 public chesspiece getpiece() { 
  return piece; 
 } 
 
 public void removepiece(chesspiece piece, chessboard board) { 
  this.board = board; 
  this.piece = piece; 
  board.remove(piece); 
  board.validate(); 
  有棋子 = false; 
 } 
} 

5.玩法规则类文件rule.java

package cn.edu.ouc.chinesechess; 
 
import javax.swing.*; 
 
import java.awt.*; 
import java.awt.event.*; 
 
/** 
 * 走棋规则类 
 * 
 * @author cnlht 
 */ 
public class rule { 
 chessboard board = null; 
 chesspiece piece = null; 
 chesspoint point[][]; 
 int starti, startj, endi, endj; 
 
 public rule(chessboard board, chesspoint point[][]) { 
  this.board = board; 
  this.point = point; 
 } 
 
 public void iswine(chesspiece piece) { 
  this.piece = piece; 
  if (piece.getname() == "将" || piece.getname() == "帅") { 
   if (piece.颜色类别 == "红方") { 
    joptionpane.showmessagedialog(null, "黑方 胜利！"); 
   } else { 
    joptionpane.showmessagedialog(null, "红方 胜利！"); 
   } 
  } 
 } 
 
 public boolean movepiecerule(chesspiece piece, int starti, int startj, 
   int endi, int endj) { 
  this.piece = piece; 
  this.starti = starti; 
  this.startj = startj; 
  this.endi = endi; 
  this.endj = endj; 
  int mini = math.min(starti, endi); 
  int maxi = math.max(starti, endi); 
  int minj = math.min(startj, endj); 
  int maxj = math.max(startj, endj); 
  boolean 可否走棋 = false; 
  if (piece.getname().equals("车")) { 
   if (starti == endi) { 
    int j = 0; 
    for (j = minj + 1; j <= maxj - 1; j++) { 
     if (point[starti][j].ispiece()) { 
      可否走棋 = false; 
      break; 
     } 
    } 
    if (j == maxj) { 
     可否走棋 = true; 
    } 
   } else if (startj == endj) { 
    int i = 0; 
    for (i = mini + 1; i <= maxi - 1; i++) { 
     if (point[i][startj].ispiece()) { 
      可否走棋 = false; 
      break; 
     } 
    } 
    if (i == maxi) { 
     可否走棋 = true; 
    } 
   } else { 
    可否走棋 = false; 
   } 
 
  } else if (piece.getname().equals("車")) { 
   if (starti == endi) { 
    int j = 0; 
    for (j = minj + 1; j <= maxj - 1; j++) { 
     if (point[starti][j].ispiece()) { 
      可否走棋 = false; 
      break; 
     } 
    } 
    if (j == maxj) { 
     可否走棋 = true; 
    } 
   } else if (startj == endj) { 
    int i = 0; 
    for (i = mini + 1; i <= maxi - 1; i++) { 
     if (point[i][startj].ispiece()) { 
      可否走棋 = false; 
      break; 
     } 
    } 
    if (i == maxi) { 
     可否走棋 = true; 
    } 
   } else { 
    可否走棋 = false; 
   } 
 
  }else if (piece.getname().equals("马")) { 
   int xaxle = math.abs(starti - endi); 
   int yaxle = math.abs(startj - endj); 
 
   if (xaxle == 2 && yaxle == 1) { 
    if (endi > starti) { 
     if (point[starti + 1][startj].ispiece()) { 
      可否走棋 = false; 
     } else { 
      可否走棋 = true; 
     } 
    } 
    if (endi < starti) { 
     if (point[starti - 1][startj].ispiece()) { 
      可否走棋 = false; 
     } else { 
      可否走棋 = true; 
     } 
    } 
 
   }else if (xaxle == 1 && yaxle == 2) { 
    if (endj > startj) { 
     if (point[starti][startj + 1].ispiece()) { 
      可否走棋 = false; 
     } else { 
      可否走棋 = true; 
     } 
    } 
    if (endj < startj) { 
     if (point[starti][startj - 1].ispiece()) { 
      可否走棋 = false; 
     } else { 
      可否走棋 = true; 
     } 
    } 
 
   } else { 
    可否走棋 = false; 
   } 
  } else if (piece.getname().equals("馬")) { 
   int xaxle = math.abs(starti - endi); 
   int yaxle = math.abs(startj - endj); 
 
   if (xaxle == 2 && yaxle == 1) { 
    if (endi > starti) { 
     if (point[starti + 1][startj].ispiece()) { 
      可否走棋 = false; 
     } else { 
      可否走棋 = true; 
     } 
    } 
    if (endi < starti) { 
     if (point[starti - 1][startj].ispiece()) { 
      可否走棋 = false; 
     } else { 
      可否走棋 = true; 
     } 
    } 
 
   }else if (xaxle == 1 && yaxle == 2) { 
    if (endj > startj) { 
     if (point[starti][startj + 1].ispiece()) { 
      可否走棋 = false; 
     } else { 
      可否走棋 = true; 
     } 
    } 
    if (endj < startj) { 
     if (point[starti][startj - 1].ispiece()) { 
      可否走棋 = false; 
     } else { 
      可否走棋 = true; 
     } 
    } 
 
   } else { 
    可否走棋 = false; 
   } 
  } else if (piece.getname().equals("象")) { 
   int centeri = (starti + endi) / 2; 
   int centerj = (startj + endj) / 2; 
   int xaxle = math.abs(starti - endi); 
   int yaxle = math.abs(startj - endj); 
   if (xaxle == 2 && yaxle == 2 && endj <= 5) { 
    if (point[centeri][centerj].ispiece()) { 
     可否走棋 = false; 
    } else { 
     可否走棋 = true; 
    } 
   } else { 
    可否走棋 = false; 
   } 
  } else if (piece.getname().equals("相")) { 
   int centeri = (starti + endi) / 2; 
   int centerj = (startj + endj) / 2; 
   int xaxle = math.abs(starti - endi); 
   int yaxle = math.abs(startj - endj); 
   if (xaxle == 2 && yaxle == 2 && endj >= 6) { 
    if (point[centeri][centerj].ispiece()) { 
     可否走棋 = false; 
    } else { 
     可否走棋 = true; 
    } 
   } else { 
    可否走棋 = false; 
   } 
  } else if (piece.getname().equals("炮")) { 
   int number = 0; 
   if (starti == endi) { 
    int j = 0; 
    for (j = minj + 1; j <= maxj - 1; j++) { 
     if (point[starti][j].ispiece()) { 
      number++; 
     } 
    } 
    if (number > 1) { 
     可否走棋 = false; 
    } else if (number == 1) { 
     if (point[endi][endj].ispiece()) { 
      可否走棋 = true; 
     } 
    } else if (number == 0 && !point[endi][endj].ispiece()) { 
     可否走棋 = true; 
    } 
   } else if (startj == endj) { 
    int i = 0; 
    for (i = mini + 1; i <= maxi - 1; i++) { 
     if (point[i][startj].ispiece()) { 
      number++; 
     } 
    } 
    if (number > 1) { 
     可否走棋 = false; 
    } else if (number == 1) { 
     if (point[endi][endj].ispiece()) { 
      可否走棋 = true; 
     } 
    } else if (number == 0 && !point[endi][endj].ispiece()) { 
     可否走棋 = true; 
    } 
   } else { 
    可否走棋 = false; 
   } 
  } else if (piece.getname().equals("兵")) { 
   int xaxle = math.abs(starti - endi); 
   int yaxle = math.abs(startj - endj); 
 
   if (endj >= 6) { 
    if (startj - endj == 1 && xaxle == 0) { 
     可否走棋 = true; 
    } 
 
    else { 
     可否走棋 = false; 
    } 
   } else if (endj <= 5) { 
    if ((startj - endj == 1) && (xaxle == 0)) { 
     可否走棋 = true; 
    } else if ((endj - startj == 0) && (xaxle == 1)) { 
     可否走棋 = true; 
    } else { 
     可否走棋 = false; 
    } 
   } 
  } else if (piece.getname().equals("卒")) { 
   int xaxle = math.abs(starti - endi); 
   int yaxle = math.abs(startj - endj); 
 
   if (endj <= 5) { 
    if (endj - startj == 1 && xaxle == 0) { 
     可否走棋 = true; 
    } else { 
     可否走棋 = false; 
    } 
   } else if (endj >= 6) { 
    if ((endj - startj == 1) && (xaxle == 0)) { 
     可否走棋 = true; 
    } else if ((endj - startj == 0) && (xaxle == 1)) { 
     可否走棋 = true; 
    } else { 
     可否走棋 = false; 
    } 
   } 
  } 
 
  else if (piece.getname().equals("士")) { 
   int xaxle = math.abs(starti - endi); 
   int yaxle = math.abs(startj - endj); 
   if (endi <= 6 && endi >= 4 && xaxle == 1 && yaxle == 1) { 
    可否走棋 = true; 
   } else { 
    可否走棋 = false; 
   } 
  } else if (piece.getname().equals("仕")) { 
   int xaxle = math.abs(starti - endi); 
   int yaxle = math.abs(startj - endj); 
   if (endi <= 6 && endi >= 4 && xaxle == 1 && yaxle == 1) { 
    可否走棋 = true; 
   } else { 
    可否走棋 = false; 
   } 
  } else if ((piece.getname().equals("帅")) 
    || (piece.getname().equals("将"))) { 
   int xaxle = math.abs(starti - endi); 
   int yaxle = math.abs(startj - endj); 
   if (endi <= 6 && endi >= 4) { 
    if ((xaxle == 1 && yaxle == 0) || (xaxle == 0 && yaxle == 1)) { 
     可否走棋 = true; 
    } else { 
     可否走棋 = false; 
    } 
   } else { 
    可否走棋 = false; 
   } 
  } 
 
  return 可否走棋; 
 
 } 
} 

6.走步类文件movestep.java

package cn.edu.ouc.chinesechess; 
 
import java.awt.point; 
 
/** 
 * 走步类 
 * 
 * @author cnlht 
 * 
 */ 
public class movestep implements java.io.serializable { 
 public point pstart, pend; 
 
 public movestep(point p1, point p2) { 
  pstart = p1; 
  pend = p2; 
 } 
} 

7.制作棋谱类makechessmanual.java

package cn.edu.ouc.chinesechess; 
 
import javax.swing.*; 
import java.awt.*; 
import java.awt.event.*; 
import java.util.linkedlist; 
 
/** 
 * 制作棋谱类 
 * 
 * @author cnlht 
 */ 
public class makechessmanual extends jpanel implements actionlistener { 
 jtextarea text = null; 
 jscrollpane scroll = null; 
 chessboard board = null; 
 chesspoint[][] point; 
 linkedlist 棋谱 = null; 
 linkedlist 吃掉的棋子 = null; 
 jbutton buttonundo; 
 int i = 0; 
 
 public makechessmanual(chessboard board, chesspoint[][] point) { 
  this.board = board; 
  this.point = point; 
  text = new jtextarea(); 
  scroll = new jscrollpane(text); 
  棋谱 = new linkedlist(); 
  吃掉的棋子 = new linkedlist(); 
  buttonundo = new jbutton("悔棋"); 
  buttonundo.setfont(new font("隶书", font.plain, 18)); 
  setlayout(new borderlayout()); 
  add(scroll, borderlayout.center); 
  add(buttonundo, borderlayout.south); 
  buttonundo.addactionlistener(this); 
 } 
 
 public char numbertoletter(int n) { 
  char c = '\0'; 
  switch (n) { 
  case 1: 
   c = 'a'; 
   break; 
  case 2: 
   c = 'b'; 
   break; 
  case 3: 
   c = 'c'; 
   break; 
  case 4: 
   c = 'd'; 
   break; 
  case 5: 
   c = 'e'; 
   break; 
  case 6: 
   c = 'f'; 
   break; 
  case 7: 
   c = 'g'; 
   break; 
  case 8: 
   c = 'h'; 
   break; 
  case 9: 
   c = 'i'; 
   break; 
  case 10: 
   c = 'j'; 
   break; 
  } 
  return c; 
 } 
 
 public void 记录棋谱(chesspiece piece, int starti, int startj, int endi, 
   int endj) { 
  point pstart = new point(starti, startj); 
  point pend = new point(endi, endj); 
  movestep step = new movestep(pstart, pend); 
  棋谱.add(step); 
 
  string 棋子类别 = piece.棋子类别(); 
  string name = piece.getname(); 
  string m = "#" + 棋子类别 + name + ": " + starti + numbertoletter(startj) 
    + " 到 " + endi + numbertoletter(endj); 
  text.append(m); 
  if (piece.棋子类别().equals(board.黑方颜色)) 
   text.append("\n"); 
 } 
 
 public void 记录吃掉的棋子(object object) { 
  吃掉的棋子.add(object); 
 } 
 
 public linkedlist 获取棋谱() { 
  return 棋谱; 
 } 
 
 public void actionperformed(actionevent e) { 
  int position = text.gettext().lastindexof("#"); 
  if (position != -1) 
   text.replacerange("", position, text.gettext().length()); 
  if (棋谱.size() > 0) { 
   movestep laststep = (movestep) 棋谱.getlast(); 
   棋谱.removelast(); 
   object qizi = 吃掉的棋子.getlast(); 
   吃掉的棋子.removelast(); 
   string temp = qizi.tostring(); 
   if (temp.equals("没吃棋子")) { 
    int starti = laststep.pstart.x; 
    int startj = laststep.pstart.y; 
    int endi = laststep.pend.x; 
    int endj = laststep.pend.y; 
    chesspiece piece = point[endi][endj].getpiece(); 
 
    point[starti][startj].setpiece(piece, board); 
    (point[endi][endj]).set有棋子(false); 
 
    if (piece.棋子类别().equals(board.红方颜色)) { 
     board.红方走棋 = true; 
     board.黑方走棋 = false; 
    } 
    if (piece.棋子类别().equals(board.黑方颜色)) { 
     board.黑方走棋 = true; 
     board.红方走棋 = false; 
    } 
   } else { 
    chesspiece removedpiece = (chesspiece) qizi; 
    int starti = laststep.pstart.x; 
    int startj = laststep.pstart.y; 
    int endi = laststep.pend.x; 
    int endj = laststep.pend.y; 
    chesspiece piece = point[endi][endj].getpiece(); 
    point[starti][startj].setpiece(piece, board); 
    point[endi][endj].setpiece(removedpiece, board); 
    (point[endi][endj]).set有棋子(true); 
 
    if (piece.棋子类别().equals(board.红方颜色)) { 
     board.红方走棋 = true; 
     board.黑方走棋 = false; 
    } 
    if (piece.棋子类别().equals(board.黑方颜色)) { 
     board.黑方走棋 = true; 
     board.红方走棋 = false; 
    } 
   } 
  } 
 } 
} 

8.演示棋谱类文件demon.java

package cn.edu.ouc.chinesechess; 
 
import javax.swing.*; 
import java.awt.*; 
import java.awt.event.*; 
import java.util.*; 
 
/** 
 * 演示棋谱类 
 * 
 * @author cnlht 
 */ 
public class demon extends jpanel implements actionlistener, runnable { 
 public jbutton replay = null, next = null, auto = null, stop = null; 
 linkedlist 棋谱 = null; 
 thread 自动演示 = null; 
 int index = -1; 
 chessboard board = null; 
 jtextarea text; 
 jtextfield 时间间隔 = null; 
 int time = 1000; 
 string 演示过程 = ""; 
 jsplitpane splith = null, splitv = null; 
 
 public demon(chessboard board) { 
  this.board = board; 
  replay = new jbutton("重新演示"); 
  next = new jbutton("下一步"); 
  auto = new jbutton("自动演示"); 
  stop = new jbutton("暂停演示"); 
  自动演示 = new thread(this); 
  replay.addactionlistener(this); 
  next.addactionlistener(this); 
  auto.addactionlistener(this); 
  stop.addactionlistener(this); 
  text = new jtextarea(); 
  时间间隔 = new jtextfield("1"); 
  setlayout(new borderlayout()); 
  jscrollpane pane = new jscrollpane(text); 
  jpanel p = new jpanel(new gridlayout(3, 2)); 
  p.add(next); 
  p.add(replay); 
  p.add(auto); 
  p.add(stop); 
  p.add(new jlabel("时间间隔(秒)", swingconstants.center)); 
  p.add(时间间隔); 
  splitv = new jsplitpane(jsplitpane.vertical_split, pane, p); 
  splith = new jsplitpane(jsplitpane.horizontal_split, board, splitv); 
  splitv.setdividersize(5); 
  splitv.setdividerlocation(400); 
  splith.setdividersize(5); 
  splith.setdividerlocation(460); 
  add(splith, borderlayout.center); 
  validate(); 
 } 
 
 public void set棋谱(linkedlist 棋谱) { 
  this.棋谱 = 棋谱; 
 } 
 
 public char numbertoletter(int n) { 
  char c = '\0'; 
  switch (n) { 
  case 1: 
   c = 'a'; 
   break; 
  case 2: 
   c = 'b'; 
   break; 
  case 3: 
   c = 'c'; 
   break; 
  case 4: 
   c = 'd'; 
   break; 
  case 5: 
   c = 'e'; 
   break; 
  case 6: 
   c = 'f'; 
   break; 
  case 7: 
   c = 'g'; 
   break; 
  case 8: 
   c = 'h'; 
   break; 
  case 9: 
   c = 'i'; 
   break; 
  case 10: 
   c = 'j'; 
   break; 
  } 
  return c; 
 } 
 
 public void actionperformed(actionevent e) { 
  if (e.getsource() == next) { 
   index++; 
   if (index < 棋谱.size()) { 
    演示一步(index); 
   } else { 
    演示结束("棋谱演示完毕"); 
   } 
  } 
  if (e.getsource() == replay) { 
   board = new chessboard(45, 45, 9, 10); 
   splith.remove(board); 
   splith.setdividersize(5); 
   splith.setdividerlocation(460); 
   splith.setleftcomponent(board); 
   splith.validate(); 
   index = -1; 
   text.settext(null); 
  } 
  if (e.getsource() == auto) { 
   next.setenabled(false); 
   replay.setenabled(false); 
   try { 
    time = 1000 * integer.parseint(时间间隔.gettext().trim()); 
   } catch (numberformatexception ee) { 
    time = 1000; 
   } 
 
   if (!(自动演示.isalive())) { 
    自动演示 = new thread(this); 
    board = new chessboard(45, 45, 9, 10); 
    splith.remove(board); 
    splith.setdividersize(5); 
    splith.setdividerlocation(460); 
    splith.setleftcomponent(board); 
    splith.validate(); 
    text.settext(null); 
    自动演示.start(); 
   } 
 
  } 
  if (e.getsource() == stop) { 
   if (e.getactioncommand().equals("暂停演示")) { 
    演示过程 = "暂停演示"; 
    stop.settext("继续演示"); 
    stop.repaint(); 
   } 
   if (e.getactioncommand().equals("继续演示")) { 
    演示过程 = "继续演示"; 
    自动演示.interrupt(); 
    stop.settext("暂停演示"); 
    stop.repaint(); 
   } 
  } 
 } 
 
 public synchronized void run() { 
  for (index = 0; index < 棋谱.size(); index++) { 
   try { 
    thread.sleep(time); 
   } catch (interruptedexception e) { 
   } 
   while (演示过程.equals("暂停演示")) { 
    try { 
     wait(); 
    } catch (interruptedexception e) { 
     notifyall(); 
    } 
   } 
   演示一步(index); 
  } 
  if (index >= 棋谱.size()) { 
   演示结束("棋谱演示完毕"); 
   next.setenabled(true); 
   replay.setenabled(true); 
  } 
 } 
 
 public void 演示一步(int index) { 
  movestep step = (movestep) 棋谱.get(index); 
  point pstart = step.pstart; 
  point pend = step.pend; 
  int starti = pstart.x; 
  int startj = pstart.y; 
  int endi = pend.x; 
  int endj = pend.y; 
  chesspiece piece = (board.point)[starti][startj].getpiece(); 
  if ((board.point)[endi][endj].ispiece() == true) { 
   chesspiece pieceremoved = (board.point)[endi][endj].getpiece(); 
   (board.point)[endi][endj].removepiece(pieceremoved, board); 
   board.repaint(); 
   (board.point)[endi][endj].setpiece(piece, board); 
   (board.point)[starti][startj].set有棋子(false); 
   board.repaint(); 
  } else { 
   (board.point)[endi][endj].setpiece(piece, board); 
   (board.point)[starti][startj].set有棋子(false); 
 
  } 
  string 棋子类别 = piece.棋子类别(); 
  string name = piece.getname(); 
  string m = "#" + 棋子类别 + name + ": " + starti + numbertoletter(startj) 
    + " 到 " + endi + numbertoletter(endj); 
  text.append(m); 
  if (piece.棋子类别().equals(board.黑方颜色)) 
   text.append("\n"); 
 } 
 
 public void 演示结束(string message) { 
  splith.remove(board); 
  splith.setdividersize(5); 
  splith.setdividerlocation(460); 
  jlabel label = new jlabel(message); 
  label.setfont(new font("隶书", font.bold, 40)); 
  label.setforeground(color.blue); 
  label.sethorizontalalignment(swingconstants.center); 
  splith.setleftcomponent(label); 
  splith.validate(); 
 } 
} 

四、总结与要求
1.理解8个文件，没有太复杂的代码。
2.理解鼠标的mouselistener,mousemotionlistener两个接口的区别，五子棋的实现不需要mousemotionlistener。
3.使用linkedlist记录棋谱的方法。

希望大家喜欢这篇文章，制作一款属于自己的中国象棋游戏。