设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

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

2016-8-29 13:12| 发布者: zhangjf| 查看: 608| 评论: 0

摘要: 本文实例讲述了java实现的中国象棋游戏代码，分享给大家供大家参考，具体代码如下 一、实践目的： 1.鼠标点击、拖动等事件的应用与区别 2.棋谱文件的保存与读取 3.完善象棋的规则。 二、实践内容： 中国象棋历史悠久 ...

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

一、实践目的：

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

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

3.完善象棋的规则。

二、实践内容：

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

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


人人对弈图

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


选择“制作棋谱”菜单



棋谱制作完毕红方胜出

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


保存棋谱对话框

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


演示棋谱对话框


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

三、参考代码：

1.象棋主类 文件ChineseChess.java

  2. package cn.edu.ouc.chineseChess;
  4. import javax.swing.*;
  5. import java.awt.*;
  6. import java.awt.event.*;
  7. import java.io.*;
  8. import java.util.LinkedList;
  10. /**
  11. * 象棋主类
  12. *
  13. * @author cnlht
  14. */
  15. public class ChineseChess extends JFrame implements ActionListener {
  16. ChessBoard board = null;
  17. Demon demon = null;
  18. MakeChessManual record = null;
  19. Container con = null;
  20. JMenuBar bar;
  21. JMenu fileMenu;
  22. JMenuItem 制作棋谱, 保存棋谱, 演示棋谱;
  23. JFileChooser fileChooser = null;
  24. LinkedList 棋谱 = null;
  26. public ChineseChess() {
  27. bar = new JMenuBar();
  28. fileMenu = new JMenu("中国象棋");
  29. 制作棋谱 = new JMenuItem("制作棋谱");
  30. 保存棋谱 = new JMenuItem("保存棋谱");
  31. 保存棋谱.setEnabled(false);
  32. 演示棋谱 = new JMenuItem("演示棋谱");
  33. fileMenu.add(制作棋谱);
  34. fileMenu.add(保存棋谱);
  35. fileMenu.add(演示棋谱);
  36. bar.add(fileMenu);
  37. setJMenuBar(bar);
  38. setTitle(制作棋谱.getText());
  39. 制作棋谱.addActionListener(this);
  40. 保存棋谱.addActionListener(this);
  41. 演示棋谱.addActionListener(this);
  42. board = new ChessBoard(45, 45, 9, 10);
  43. record = board.record;
  44. con = getContentPane();
  45. JSplitPane split = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true,
  46. board, record);
  47. split.setDividerSize(5);
  48. split.setDividerLocation(460);
  49. con.add(split, BorderLayout.CENTER);
  50. addWindowListener(new WindowAdapter() {
  51. public void windowClosing(WindowEvent e) {
  52. System.exit(0);
  53. }
  54. });
  55. setVisible(true);
  56. setBounds(60, 20, 690, 540);
  57. fileChooser = new JFileChooser();
  58. con.validate();
  59. validate();
  60. }
  62. public void actionPerformed(ActionEvent e) {
  63. if (e.getSource() == 制作棋谱) {
  64. con.removeAll();
  65. 保存棋谱.setEnabled(true);
  66. this.setTitle(制作棋谱.getText());
  67. board = new ChessBoard(45, 45, 9, 10);
  68. record = board.record;
  69. JSplitPane split = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,
  70. true, board, record);
  71. split.setDividerSize(5);
  72. split.setDividerLocation(460);
  73. con.add(split, BorderLayout.CENTER);
  74. validate();
  75. }
  76. if (e.getSource() == 保存棋谱) {
  77. int state = fileChooser.showSaveDialog(null);
  78. File saveFile = fileChooser.getSelectedFile();
  79. if (saveFile != null && state == JFileChooser.APPROVE_OPTION) {
  80. try {
  81. FileOutputStream outOne = new FileOutputStream(saveFile);
  82. ObjectOutputStream outTwo = new ObjectOutputStream(outOne);
  83. outTwo.writeObject(record.获取棋谱());
  84. outOne.close();
  85. outTwo.close();
  86. } catch (IOException event) {
  87. }
  88. }
  89. }
  90. if (e.getSource() == 演示棋谱) {
  91. con.removeAll();
  92. con.repaint();
  93. con.validate();
  94. validate();
  95. 保存棋谱.setEnabled(false);
  97. int state = fileChooser.showOpenDialog(null);
  98. File openFile = fileChooser.getSelectedFile();
  99. if (openFile != null && state == JFileChooser.APPROVE_OPTION) {
  100. try {
  101. FileInputStream inOne = new FileInputStream(openFile);
  102. ObjectInputStream inTwo = new ObjectInputStream(inOne);
  103. 棋谱 = (LinkedList) inTwo.readObject();
  104. inOne.close();
  105. inTwo.close();
  106. ChessBoard board = new ChessBoard(45, 45, 9, 10);
  107. demon = new Demon(board);
  108. demon.set棋谱(棋谱);
  109. con.add(demon, BorderLayout.CENTER);
  110. con.validate();
  111. validate();
  112. this.setTitle(演示棋谱.getText() + ":" + openFile);
  113. } catch (Exception event) {
  114. JLabel label = new JLabel("不是棋谱文件");
  115. label.setFont(new Font("隶书", Font.BOLD, 60));
  116. label.setForeground(Color.red);
  117. label.setHorizontalAlignment(SwingConstants.CENTER);
  118. con.add(label, BorderLayout.CENTER);
  119. con.validate();
  120. this.setTitle("没有打开棋谱");
  121. validate();
  122. }
  123. } else {
  124. JLabel label = new JLabel("没有打开棋谱文件呢");
  125. label.setFont(new Font("隶书", Font.BOLD, 50));
  126. label.setForeground(Color.pink);
  127. label.setHorizontalAlignment(SwingConstants.CENTER);
  128. con.add(label, BorderLayout.CENTER);
  129. con.validate();
  130. this.setTitle("没有打开棋谱文件呢");
  131. validate();
  132. }
  133. }
  134. }
  136. public static void main(String args[]) {
  137. new ChineseChess();
  138. }
  139. }
复制代码

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

  2. package cn.edu.ouc.chineseChess;
  4. import javax.swing.*;
  5. import java.awt.*;
  6. import java.awt.event.*;
  8. /**
  9. * 棋盘类
  10. *
  11. * @author cnlht
  12. */
  13. public class ChessBoard extends JPanel implements MouseListener,
  14. MouseMotionListener {
  15. public ChessPoint point[][];
  16. public int unitWidth, unitHeight;
  17. private int x轴长, y轴长;
  18. private int x, y;
  19. private Image img;
  20. protected Image pieceImg;
  21. private boolean move = false;
  22. public String 红方颜色 = "红方", 黑方颜色 = "黑方";
  23. ChessPiece 红车1, 红车2, 红马1, 红马2, 红相1, 红相2, 红帅, 红士1, 红士2, 红兵1, 红兵2, 红兵3, 红兵4,
  24. 红兵5, 红炮1, 红炮2;
  25. ChessPiece 黑车1, 黑车2, 黑马1, 黑马2, 黑将, 黑士1, 黑士2, 黑卒1, 黑卒2, 黑卒3, 黑卒4, 黑卒5, 黑象1,
  26. 黑象2, 黑炮1, 黑炮2;
  28. int startX, startY;
  29. int startI, startJ;
  30. public boolean 红方走棋 = true, 黑方走棋 = false;
  31. Rule rule = null;
  32. public MakeChessManual record = null;
  34. public ChessBoard(int w, int h, int r, int c) {
  35. setLayout(null);
  36. addMouseListener(this);
  37. addMouseMotionListener(this);
  38. Color bc = getBackground();
  39. unitWidth = w;
  40. unitHeight = h;
  41. x轴长 = r;
  42. y轴长 = c;
  44. point = new ChessPoint[r + 1][c + 1];
  46. for (int i = 1; i <= r; i++) {
  47. for (int j = 1; j <= c; j++) {
  48. point[i][j] = new ChessPoint(i * unitWidth, j * unitHeight,
  49. false);
  50. }
  51. }
  53. rule = new Rule(this, point);
  54. record = new MakeChessManual(this, point);
  56. img = Toolkit.getDefaultToolkit().getImage("board.jpg");
  57. pieceImg = Toolkit.getDefaultToolkit().getImage("piece.gif");
  59. 红车1 = new ChessPiece("車", Color.red, bc, w - 4, h - 4, this);
  60. 红车1.set棋子类别(红方颜色);
  61. 红车2 = new ChessPiece("車", Color.red, bc, w - 4, h - 4, this);
  62. 红车2.set棋子类别(红方颜色);
  63. 红马1 = new ChessPiece("馬", Color.red, bc, w - 4, h - 4, this);
  64. 红马1.set棋子类别(红方颜色);
  65. 红马2 = new ChessPiece("馬", Color.red, bc, w - 4, h - 4, this);
  66. 红马2.set棋子类别(红方颜色);
  67. 红炮1 = new ChessPiece("炮", Color.red, bc, w - 4, h - 4, this);
  68. 红炮1.set棋子类别(红方颜色);
  69. 红炮2 = new ChessPiece("炮", Color.red, bc, w - 4, h - 4, this);
  70. 红炮2.set棋子类别(红方颜色);
  71. 红相1 = new ChessPiece("相", Color.red, bc, w - 4, h - 4, this);
  72. 红相1.set棋子类别(红方颜色);
  73. 红相2 = new ChessPiece("相", Color.red, bc, w - 4, h - 4, this);
  74. 红相2.set棋子类别(红方颜色);
  75. 红士1 = new ChessPiece("仕", Color.red, bc, w - 4, h - 4, this);
  76. 红士1.set棋子类别(红方颜色);
  77. 红士2 = new ChessPiece("仕", Color.red, bc, w - 4, h - 4, this);
  78. 红士2.set棋子类别(红方颜色);
  79. 红帅 = new ChessPiece("帅", Color.red, bc, w - 4, h - 4, this);
  80. 红帅.set棋子类别(红方颜色);
  81. 红兵1 = new ChessPiece("兵", Color.red, bc, w - 4, h - 4, this);
  82. 红兵1.set棋子类别(红方颜色);
  83. 红兵2 = new ChessPiece("兵", Color.red, bc, w - 4, h - 4, this);
  84. 红兵2.set棋子类别(红方颜色);
  85. 红兵3 = new ChessPiece("兵", Color.red, bc, w - 4, h - 4, this);
  86. 红兵3.set棋子类别(红方颜色);
  87. 红兵4 = new ChessPiece("兵", Color.red, bc, w - 4, h - 4, this);
  88. 红兵4.set棋子类别(红方颜色);
  89. 红兵5 = new ChessPiece("兵", Color.red, bc, w - 4, h - 4, this);
  90. 红兵5.set棋子类别(红方颜色);
  92. 黑将 = new ChessPiece("将", Color.black, bc, w - 4, h - 4, this);
  93. 黑将.set棋子类别(黑方颜色);
  94. 黑士1 = new ChessPiece("士", Color.black, bc, w - 4, h - 4, this);
  95. 黑士1.set棋子类别(黑方颜色);
  96. 黑士2 = new ChessPiece("士", Color.black, bc, w - 4, h - 4, this);
  97. 黑士2.set棋子类别(黑方颜色);
  98. 黑车1 = new ChessPiece("车", Color.black, bc, w - 4, h - 4, this);
  99. 黑车1.set棋子类别(黑方颜色);
  100. 黑车2 = new ChessPiece("车", Color.black, bc, w - 4, h - 4, this);
  101. 黑车2.set棋子类别(黑方颜色);
  102. 黑炮1 = new ChessPiece("炮", Color.black, bc, w - 4, h - 4, this);
  103. 黑炮1.set棋子类别(黑方颜色);
  104. 黑炮2 = new ChessPiece("炮", Color.black, bc, w - 4, h - 4, this);
  105. 黑炮2.set棋子类别(黑方颜色);
  106. 黑象1 = new ChessPiece("象", Color.black, bc, w - 4, h - 4, this);
  107. 黑象1.set棋子类别(黑方颜色);
  108. 黑象2 = new ChessPiece("象", Color.black, bc, w - 4, h - 4, this);
  109. 黑象2.set棋子类别(黑方颜色);
  110. 黑马1 = new ChessPiece("马", Color.black, bc, w - 4, h - 4, this);
  111. 黑马1.set棋子类别(黑方颜色);
  112. 黑马2 = new ChessPiece("马", Color.black, bc, w - 4, h - 4, this);
  113. 黑马2.set棋子类别(黑方颜色);
  114. 黑卒1 = new ChessPiece("卒", Color.black, bc, w - 4, h - 4, this);
  115. 黑卒1.set棋子类别(黑方颜色);
  116. 黑卒2 = new ChessPiece("卒", Color.black, bc, w - 4, h - 4, this);
  117. 黑卒2.set棋子类别(黑方颜色);
  118. 黑卒3 = new ChessPiece("卒", Color.black, bc, w - 4, h - 4, this);
  119. 黑卒3.set棋子类别(黑方颜色);
  120. 黑卒4 = new ChessPiece("卒", Color.black, bc, w - 4, h - 4, this);
  121. 黑卒4.set棋子类别(黑方颜色);
  122. 黑卒5 = new ChessPiece("卒", Color.black, bc, w - 4, h - 4, this);
  123. 黑卒5.set棋子类别(黑方颜色);
  124. point[1][10].setPiece(红车1, this);
  125. point[2][10].setPiece(红马1, this);
  126. point[3][10].setPiece(红相1, this);
  127. point[4][10].setPiece(红士1, this);
  128. point[5][10].setPiece(红帅, this);
  129. point[6][10].setPiece(红士2, this);
  130. point[7][10].setPiece(红相2, this);
  131. point[8][10].setPiece(红马2, this);
  132. point[9][10].setPiece(红车2, this);
  133. point[2][8].setPiece(红炮1, this);
  134. point[8][8].setPiece(红炮2, this);
  135. point[1][7].setPiece(红兵1, this);
  136. point[3][7].setPiece(红兵2, this);
  137. point[5][7].setPiece(红兵3, this);
  138. point[7][7].setPiece(红兵4, this);
  139. point[9][7].setPiece(红兵5, this);
  141. point[1][1].setPiece(黑车1, this);
  142. point[2][1].setPiece(黑马1, this);
  143. point[3][1].setPiece(黑象1, this);
  144. point[4][1].setPiece(黑士1, this);
  145. point[5][1].setPiece(黑将, this);
  146. point[6][1].setPiece(黑士2, this);
  147. point[7][1].setPiece(黑象2, this);
  148. point[8][1].setPiece(黑马2, this);
  149. point[9][1].setPiece(黑车2, this);
  150. point[2][3].setPiece(黑炮1, this);
  151. point[8][3].setPiece(黑炮2, this);
  152. point[1][4].setPiece(黑卒1, this);
  153. point[3][4].setPiece(黑卒2, this);
  154. point[5][4].setPiece(黑卒3, this);
  155. point[7][4].setPiece(黑卒4, this);
  156. point[9][4].setPiece(黑卒5, this);
  158. }
  160. public void paintComponent(Graphics g) {
  161. super.paintComponent(g);
  163. int imgWidth = img.getWidth(this);
  164. int imgHeight = img.getHeight(this);// 获得图片的宽度与高度
  165. int FWidth = getWidth();
  166. int FHeight = getHeight();// 获得窗口的宽度与高度
  167. int x = (FWidth - imgWidth) / 2;
  168. int y = (FHeight - imgHeight) / 2;
  169. g.drawImage(img, x, y, null);
  171. for (int j = 1; j <= y轴长; j++) {
  172. g.drawLine(point[1][j].x, point[1][j].y, point[x轴长][j].x,
  173. point[x轴长][j].y);
  174. }
  175. for (int i = 1; i <= x轴长; i++) {
  176. if (i != 1 && i != x轴长) {
  177. g.drawLine(point[i][1].x, point[i][1].y, point[i][y轴长 - 5].x,
  178. point[i][y轴长 - 5].y);
  179. g.drawLine(point[i][y轴长 - 4].x, point[i][y轴长 - 4].y,
  180. point[i][y轴长].x, point[i][y轴长].y);
  181. } else {
  182. g.drawLine(point[i][1].x, point[i][1].y, point[i][y轴长].x,
  183. point[i][y轴长].y);
  184. }
  185. }
  187. g.drawLine(point[4][1].x, point[4][1].y, point[6][3].x, point[6][3].y);
  188. g.drawLine(point[6][1].x, point[6][1].y, point[4][3].x, point[4][3].y);
  189. g.drawLine(point[4][8].x, point[4][8].y, point[6][y轴长].x,
  190. point[6][y轴长].y);
  191. g.drawLine(point[4][y轴长].x, point[4][y轴长].y, point[6][8].x,
  192. point[6][8].y);
  194. for (int i = 1; i <= x轴长; i++) {
  195. g.drawString("" + i, i * unitWidth, unitHeight / 2);
  196. }
  197. int j = 1;
  198. for (char c = 'A'; c <= 'J'; c++) {
  199. g.drawString("" + c, unitWidth / 4, j * unitHeight);
  200. j++;
  201. }
  203. }
  205. /**鼠标按下事件*/
  206. public void mousePressed(MouseEvent e) {
  207. ChessPiece piece = null;
  208. Rectangle rect = null;
  209. if (e.getSource() == this)
  210. move = false;
  211. if (move == false)
  212. if (e.getSource() instanceof ChessPiece) {
  213. piece = (ChessPiece) e.getSource();
  214. startX = piece.getBounds().x;
  215. startY = piece.getBounds().y;
  217. rect = piece.getBounds();
  218. for (int i = 1; i <= x轴长; i++) {
  219. for (int j = 1; j <= y轴长; j++) {
  220. int x = point[i][j].getX();
  221. int y = point[i][j].getY();
  222. if (rect.contains(x, y)) {
  223. startI = i;
  224. startJ = j;
  225. break;
  226. }
  228. }
  229. }
  230. }
  231. }
  233. public void mouseMoved(MouseEvent e) {
  234. }
  236. /**鼠标拖动事件*/
  237. public void mouseDragged(MouseEvent e) {
  239. ChessPiece piece = null;
  240. if (e.getSource() instanceof ChessPiece) {
  241. piece = (ChessPiece) e.getSource();
  243. move = true;
  245. e = SwingUtilities.convertMouseEvent(piece, e, this);
  246. }
  248. if (e.getSource() == this) {
  249. if (move && piece != null) {
  250. x = e.getX();
  251. y = e.getY();
  252. if (红方走棋 && ((piece.棋子类别()).equals(红方颜色))) {
  253. piece.setLocation(x - piece.getWidth() / 2,
  254. y - piece.getHeight() / 2);
  255. }
  256. if (黑方走棋 && (piece.棋子类别().equals(黑方颜色))) {
  257. piece.setLocation(x - piece.getWidth() / 2,
  258. y - piece.getHeight() / 2);
  259. }
  260. }
  261. }
  262. }
  264. /**松开鼠标事件*/
  265. public void mouseReleased(MouseEvent e) {
  266. ChessPiece piece = null;
  267. move = false;
  268. Rectangle rect = null;
  269. if (e.getSource() instanceof ChessPiece) {
  270. piece = (ChessPiece) e.getSource();
  271. rect = piece.getBounds();
  273. e = SwingUtilities.convertMouseEvent(piece, e, this);
  274. }
  275. if (e.getSource() == this) {
  276. boolean containChessPoint = false;
  277. int x = 0, y = 0;
  278. int m = 0, n = 0;
  279. if (piece != null) {
  280. for (int i = 1; i <= x轴长; i++) {
  281. for (int j = 1; j <= y轴长; j++) {
  282. x = point[i][j].getX();
  283. y = point[i][j].getY();
  284. if (rect.contains(x, y)) {
  286. containChessPoint = true;
  287. m = i;
  288. n = j;
  289. break;
  290. }
  292. }
  293. }
  294. }
  295. if (piece != null && containChessPoint) {
  296. Color pieceColor = piece.获取棋子颜色();
  297. if (point[m][n].isPiece()) {
  298. Color c = (point[m][n].getPiece()).获取棋子颜色();
  299. if (pieceColor.getRGB() == c.getRGB()) {
  300. piece.setLocation(startX, startY);
  302. (point[startI][startJ]).set有棋子(true);
  303. } else {
  304. boolean ok = rule.movePieceRule(piece, startI, startJ,
  305. m, n);
  306. if (ok) {
  307. ChessPiece pieceRemoved = point[m][n].getPiece();
  308. point[m][n].reMovePiece(pieceRemoved, this);
  309. point[m][n].setPiece(piece, this);
  310. (point[startI][startJ]).set有棋子(false);
  311. record.记录棋谱(piece, startI, startJ, m, n);
  312. record.记录吃掉的棋子(pieceRemoved);
  313. rule.isWine(pieceRemoved);
  314. if (piece.棋子类别().equals(红方颜色)) {
  315. 红方走棋 = false;
  316. 黑方走棋 = true;
  317. }
  318. if (piece.棋子类别().equals(黑方颜色)) {
  319. 黑方走棋 = false;
  320. 红方走棋 = true;
  321. }
  322. validate();
  323. repaint();
  324. } else {
  325. piece.setLocation(startX, startY);
  326. (point[startI][startJ]).set有棋子(true);
  327. }
  328. }
  330. } else {
  332. boolean ok = rule
  333. .movePieceRule(piece, startI, startJ, m, n);
  334. if (ok) {
  335. point[m][n].setPiece(piece, this);
  336. (point[startI][startJ]).set有棋子(false);
  337. record.记录棋谱(piece, startI, startJ, m, n);
  338. record.记录吃掉的棋子("没吃棋子");
  340. if (piece.棋子类别().equals(红方颜色)) {
  341. 红方走棋 = false;
  342. 黑方走棋 = true;
  343. }
  344. if (piece.棋子类别().equals(黑方颜色)) {
  345. 黑方走棋 = false;
  346. 红方走棋 = true;
  347. }
  348. } else {
  349. piece.setLocation(startX, startY);
  350. (point[startI][startJ]).set有棋子(true);
  351. }
  352. }
  353. }
  355. if (piece != null && !containChessPoint) {
  356. piece.setLocation(startX, startY);
  357. (point[startI][startJ]).set有棋子(true);
  358. }
  359. }
  360. }
  362. public void mouseEntered(MouseEvent e) {
  363. }
  365. public void mouseExited(MouseEvent e) {
  366. }
  368. public void mouseClicked(MouseEvent e) {
  369. }
  370. }
复制代码

3.棋子类文件ChessPiece.java

  2. package cn.edu.ouc.chineseChess;
  4. import javax.swing.*;
  5. import java.awt.*;
  6. import java.awt.event.*;
  8. /**
  9. * 棋子类
  10. *
  11. * @author cnlht
  12. */
  13. public class ChessPiece extends JLabel {
  14. String name; // 棋子名字
  15. Color backColor = null, foreColor;// 背景色和前景色
  16. String 颜色类别 = null;
  17. ChessBoard board = null;
  18. int width, height;// 大小
  20. public ChessPiece(String name, Color fc, Color bc, int width, int height,
  21. ChessBoard board) {// 构造棋子
  22. this.name = name;
  23. this.board = board;
  24. this.width = width;
  25. this.height = height;
  26. foreColor = fc;
  27. backColor = bc;
  28. setSize(width, height);
  29. setBackground(bc);
  30. addMouseMotionListener(board);
  31. addMouseListener(board);
  32. }
  34. // 绘制棋子
  35. public void paint(Graphics g) {
  36. g.drawImage(board.pieceImg, 2, 2, width-2, height-2, null);
  37. g.setColor(foreColor);
  38. g.setFont(new Font("楷体", Font.BOLD, 26));
  39. g.drawString(name, 7, height - 8);// 在棋子上绘制 “棋子名”
  40. g.setColor(Color.black);
  41. //g.drawOval(1, 1, width - 1, height - 1);
  42. float lineWidth = 2.3f;
  43. ((Graphics2D)g).setStroke(new BasicStroke(lineWidth));
  44. ((Graphics2D)g).drawOval(2, 2, width-2, height-2);
  45. }
  47. public int getWidth() {
  48. return width;
  49. }
  51. public int getHeight() {
  52. return height;
  53. }
  55. public String getName() {
  56. return name;
  57. }
  59. public Color 获取棋子颜色() {
  60. return foreColor;
  61. }
  63. public void set棋子类别(String 类别) {
  64. 颜色类别 = 类别;
  65. }
  67. public String 棋子类别() {
  68. return 颜色类别;
  69. }
  70. }
复制代码

4.棋子点坐标类文件

  2. package cn.edu.ouc.chineseChess;
  4. /**
  5. * 棋点类
  6. *
  7. * @author cnlht
  8. */
  9. public class ChessPoint {
  10. /** 棋子坐标 */
  11. int x, y;
  13. /** 该坐标 是否有子*/
  14. boolean 有棋子;
  16. /** 改坐标的棋子 */
  17. ChessPiece piece = null;
  19. /** 坐标所属棋盘 */
  20. ChessBoard board = null;
  22. public ChessPoint(int x, int y, boolean boo) {
  23. this.x = x;
  24. this.y = y;
  25. 有棋子 = boo;
  26. }
  28. public boolean isPiece() {
  29. return 有棋子;
  30. }
  32. public void set有棋子(boolean boo) {
  33. 有棋子 = boo;
  34. }
  36. public int getX() {
  37. return x;
  38. }
  40. public int getY() {
  41. return y;
  42. }
  44. // 设置改点棋子
  45. public void setPiece(ChessPiece piece, ChessBoard board) {
  46. this.board = board;
  47. this.piece = piece;
  48. board.add(piece);
  49. int w = (board.unitWidth);
  50. int h = (board.unitHeight);
  51. piece.setBounds(x - w / 2, y - h / 2, w, h);// 棋子位置，宽度，高度
  52. 有棋子 = true;
  53. board.validate();
  54. }
  56. public ChessPiece getPiece() {
  57. return piece;
  58. }
  60. public void reMovePiece(ChessPiece piece, ChessBoard board) {
  61. this.board = board;
  62. this.piece = piece;
  63. board.remove(piece);
  64. board.validate();
  65. 有棋子 = false;
  66. }
  67. }
复制代码

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

  2. package cn.edu.ouc.chineseChess;
  4. import javax.swing.*;
  6. import java.awt.*;
  7. import java.awt.event.*;
  9. /**
  10. * 走棋规则类
  11. *
  12. * @author cnlht
  13. */
  14. public class Rule {
  15. ChessBoard board = null;
  16. ChessPiece piece = null;
  17. ChessPoint point[][];
  18. int startI, startJ, endI, endJ;
  20. public Rule(ChessBoard board, ChessPoint point[][]) {
  21. this.board = board;
  22. this.point = point;
  23. }
  25. public void isWine(ChessPiece piece) {
  26. this.piece = piece;
  27. if (piece.getName() == "将" || piece.getName() == "帅") {
  28. if (piece.颜色类别 == "红方") {
  29. JOptionPane.showMessageDialog(null, "黑方 胜利！");
  30. } else {
  31. JOptionPane.showMessageDialog(null, "红方 胜利！");
  32. }
  33. }
  34. }
  36. public boolean movePieceRule(ChessPiece piece, int startI, int startJ,
  37. int endI, int endJ) {
  38. this.piece = piece;
  39. this.startI = startI;
  40. this.startJ = startJ;
  41. this.endI = endI;
  42. this.endJ = endJ;
  43. int minI = Math.min(startI, endI);
  44. int maxI = Math.max(startI, endI);
  45. int minJ = Math.min(startJ, endJ);
  46. int maxJ = Math.max(startJ, endJ);
  47. boolean 可否走棋 = false;
  48. if (piece.getName().equals("车")) {
  49. if (startI == endI) {
  50. int j = 0;
  51. for (j = minJ + 1; j <= maxJ - 1; j++) {
  52. if (point[startI][j].isPiece()) {
  53. 可否走棋 = false;
  54. break;
  55. }
  56. }
  57. if (j == maxJ) {
  58. 可否走棋 = true;
  59. }
  60. } else if (startJ == endJ) {
  61. int i = 0;
  62. for (i = minI + 1; i <= maxI - 1; i++) {
  63. if (point[i][startJ].isPiece()) {
  64. 可否走棋 = false;
  65. break;
  66. }
  67. }
  68. if (i == maxI) {
  69. 可否走棋 = true;
  70. }
  71. } else {
  72. 可否走棋 = false;
  73. }
  75. } else if (piece.getName().equals("車")) {
  76. if (startI == endI) {
  77. int j = 0;
  78. for (j = minJ + 1; j <= maxJ - 1; j++) {
  79. if (point[startI][j].isPiece()) {
  80. 可否走棋 = false;
  81. break;
  82. }
  83. }
  84. if (j == maxJ) {
  85. 可否走棋 = true;
  86. }
  87. } else if (startJ == endJ) {
  88. int i = 0;
  89. for (i = minI + 1; i <= maxI - 1; i++) {
  90. if (point[i][startJ].isPiece()) {
  91. 可否走棋 = false;
  92. break;
  93. }
  94. }
  95. if (i == maxI) {
  96. 可否走棋 = true;
  97. }
  98. } else {
  99. 可否走棋 = false;
  100. }
  102. }else if (piece.getName().equals("马")) {
  103. int xAxle = Math.abs(startI - endI);
  104. int yAxle = Math.abs(startJ - endJ);
  106. if (xAxle == 2 && yAxle == 1) {
  107. if (endI > startI) {
  108. if (point[startI + 1][startJ].isPiece()) {
  109. 可否走棋 = false;
  110. } else {
  111. 可否走棋 = true;
  112. }
  113. }
  114. if (endI < startI) {
  115. if (point[startI - 1][startJ].isPiece()) {
  116. 可否走棋 = false;
  117. } else {
  118. 可否走棋 = true;
  119. }
  120. }
  122. }else if (xAxle == 1 && yAxle == 2) {
  123. if (endJ > startJ) {
  124. if (point[startI][startJ + 1].isPiece()) {
  125. 可否走棋 = false;
  126. } else {
  127. 可否走棋 = true;
  128. }
  129. }
  130. if (endJ < startJ) {
  131. if (point[startI][startJ - 1].isPiece()) {
  132. 可否走棋 = false;
  133. } else {
  134. 可否走棋 = true;
  135. }
  136. }
  138. } else {
  139. 可否走棋 = false;
  140. }
  141. } else if (piece.getName().equals("馬")) {
  142. int xAxle = Math.abs(startI - endI);
  143. int yAxle = Math.abs(startJ - endJ);
  145. if (xAxle == 2 && yAxle == 1) {
  146. if (endI > startI) {
  147. if (point[startI + 1][startJ].isPiece()) {
  148. 可否走棋 = false;
  149. } else {
  150. 可否走棋 = true;
  151. }
  152. }
  153. if (endI < startI) {
  154. if (point[startI - 1][startJ].isPiece()) {
  155. 可否走棋 = false;
  156. } else {
  157. 可否走棋 = true;
  158. }
  159. }
  161. }else if (xAxle == 1 && yAxle == 2) {
  162. if (endJ > startJ) {
  163. if (point[startI][startJ + 1].isPiece()) {
  164. 可否走棋 = false;
  165. } else {
  166. 可否走棋 = true;
  167. }
  168. }
  169. if (endJ < startJ) {
  170. if (point[startI][startJ - 1].isPiece()) {
  171. 可否走棋 = false;
  172. } else {
  173. 可否走棋 = true;
  174. }
  175. }
  177. } else {
  178. 可否走棋 = false;
  179. }
  180. } else if (piece.getName().equals("象")) {
  181. int centerI = (startI + endI) / 2;
  182. int centerJ = (startJ + endJ) / 2;
  183. int xAxle = Math.abs(startI - endI);
  184. int yAxle = Math.abs(startJ - endJ);
  185. if (xAxle == 2 && yAxle == 2 && endJ <= 5) {
  186. if (point[centerI][centerJ].isPiece()) {
  187. 可否走棋 = false;
  188. } else {
  189. 可否走棋 = true;
  190. }
  191. } else {
  192. 可否走棋 = false;
  193. }
  194. } else if (piece.getName().equals("相")) {
  195. int centerI = (startI + endI) / 2;
  196. int centerJ = (startJ + endJ) / 2;
  197. int xAxle = Math.abs(startI - endI);
  198. int yAxle = Math.abs(startJ - endJ);
  199. if (xAxle == 2 && yAxle == 2 && endJ >= 6) {
  200. if (point[centerI][centerJ].isPiece()) {
  201. 可否走棋 = false;
  202. } else {
  203. 可否走棋 = true;
  204. }
  205. } else {
  206. 可否走棋 = false;
  207. }
  208. } else if (piece.getName().equals("炮")) {
  209. int number = 0;
  210. if (startI == endI) {
  211. int j = 0;
  212. for (j = minJ + 1; j <= maxJ - 1; j++) {
  213. if (point[startI][j].isPiece()) {
  214. number++;
  215. }
  216. }
  217. if (number > 1) {
  218. 可否走棋 = false;
  219. } else if (number == 1) {
  220. if (point[endI][endJ].isPiece()) {
  221. 可否走棋 = true;
  222. }
  223. } else if (number == 0 && !point[endI][endJ].isPiece()) {
  224. 可否走棋 = true;
  225. }
  226. } else if (startJ == endJ) {
  227. int i = 0;
  228. for (i = minI + 1; i <= maxI - 1; i++) {
  229. if (point[i][startJ].isPiece()) {
  230. number++;
  231. }
  232. }
  233. if (number > 1) {
  234. 可否走棋 = false;
  235. } else if (number == 1) {
  236. if (point[endI][endJ].isPiece()) {
  237. 可否走棋 = true;
  238. }
  239. } else if (number == 0 && !point[endI][endJ].isPiece()) {
  240. 可否走棋 = true;
  241. }
  242. } else {
  243. 可否走棋 = false;
  244. }
  245. } else if (piece.getName().equals("兵")) {
  246. int xAxle = Math.abs(startI - endI);
  247. int yAxle = Math.abs(startJ - endJ);
  249. if (endJ >= 6) {
  250. if (startJ - endJ == 1 && xAxle == 0) {
  251. 可否走棋 = true;
  252. }
  254. else {
  255. 可否走棋 = false;
  256. }
  257. } else if (endJ <= 5) {
  258. if ((startJ - endJ == 1) && (xAxle == 0)) {
  259. 可否走棋 = true;
  260. } else if ((endJ - startJ == 0) && (xAxle == 1)) {
  261. 可否走棋 = true;
  262. } else {
  263. 可否走棋 = false;
  264. }
  265. }
  266. } else if (piece.getName().equals("卒")) {
  267. int xAxle = Math.abs(startI - endI);
  268. int yAxle = Math.abs(startJ - endJ);
  270. if (endJ <= 5) {
  271. if (endJ - startJ == 1 && xAxle == 0) {
  272. 可否走棋 = true;
  273. } else {
  274. 可否走棋 = false;
  275. }
  276. } else if (endJ >= 6) {
  277. if ((endJ - startJ == 1) && (xAxle == 0)) {
  278. 可否走棋 = true;
  279. } else if ((endJ - startJ == 0) && (xAxle == 1)) {
  280. 可否走棋 = true;
  281. } else {
  282. 可否走棋 = false;
  283. }
  284. }
  285. }
  287. else if (piece.getName().equals("士")) {
  288. int xAxle = Math.abs(startI - endI);
  289. int yAxle = Math.abs(startJ - endJ);
  290. if (endI <= 6 && endI >= 4 && xAxle == 1 && yAxle == 1) {
  291. 可否走棋 = true;
  292. } else {
  293. 可否走棋 = false;
  294. }
  295. } else if (piece.getName().equals("仕")) {
  296. int xAxle = Math.abs(startI - endI);
  297. int yAxle = Math.abs(startJ - endJ);
  298. if (endI <= 6 && endI >= 4 && xAxle == 1 && yAxle == 1) {
  299. 可否走棋 = true;
  300. } else {
  301. 可否走棋 = false;
  302. }
  303. } else if ((piece.getName().equals("帅"))
  304. || (piece.getName().equals("将"))) {
  305. int xAxle = Math.abs(startI - endI);
  306. int yAxle = Math.abs(startJ - endJ);
  307. if (endI <= 6 && endI >= 4) {
  308. if ((xAxle == 1 && yAxle == 0) || (xAxle == 0 && yAxle == 1)) {
  309. 可否走棋 = true;
  310. } else {
  311. 可否走棋 = false;
  312. }
  313. } else {
  314. 可否走棋 = false;
  315. }
  316. }
  318. return 可否走棋;
  320. }
  321. }
复制代码

6.走步类文件MoveStep.java

  2. package cn.edu.ouc.chineseChess;
  4. import java.awt.Point;
  6. /**
  7. * 走步类
  8. *
  9. * @author cnlht
  10. *
  11. */
  12. public class MoveStep implements java.io.Serializable {
  13. public Point pStart, pEnd;
  15. public MoveStep(Point p1, Point p2) {
  16. pStart = p1;
  17. pEnd = p2;
  18. }
  19. }
复制代码

7.制作棋谱类MakeChessManual.java

  2. package cn.edu.ouc.chineseChess;
  4. import javax.swing.*;
  5. import java.awt.*;
  6. import java.awt.event.*;
  7. import java.util.LinkedList;
  9. /**
  10. * 制作棋谱类
  11. *
  12. * @author cnlht
  13. */
  14. public class MakeChessManual extends JPanel implements ActionListener {
  15. JTextArea text = null;
  16. JScrollPane scroll = null;
  17. ChessBoard board = null;
  18. ChessPoint[][] point;
  19. LinkedList 棋谱 = null;
  20. LinkedList 吃掉的棋子 = null;
  21. JButton buttonUndo;
  22. int i = 0;
  24. public MakeChessManual(ChessBoard board, ChessPoint[][] point) {
  25. this.board = board;
  26. this.point = point;
  27. text = new JTextArea();
  28. scroll = new JScrollPane(text);
  29. 棋谱 = new LinkedList();
  30. 吃掉的棋子 = new LinkedList();
  31. buttonUndo = new JButton("悔棋");
  32. buttonUndo.setFont(new Font("隶书", Font.PLAIN, 18));
  33. setLayout(new BorderLayout());
  34. add(scroll, BorderLayout.CENTER);
  35. add(buttonUndo, BorderLayout.SOUTH);
  36. buttonUndo.addActionListener(this);
  37. }
  39. public char numberToLetter(int n) {
  40. char c = '';
  41. switch (n) {
  42. case 1:
  43. c = 'A';
  44. break;
  45. case 2:
  46. c = 'B';
  47. break;
  48. case 3:
  49. c = 'C';
  50. break;
  51. case 4:
  52. c = 'D';
  53. break;
  54. case 5:
  55. c = 'E';
  56. break;
  57. case 6:
  58. c = 'F';
  59. break;
  60. case 7:
  61. c = 'G';
  62. break;
  63. case 8:
  64. c = 'H';
  65. break;
  66. case 9:
  67. c = 'I';
  68. break;
  69. case 10:
  70. c = 'J';
  71. break;
  72. }
  73. return c;
  74. }
  76. public void 记录棋谱(ChessPiece piece, int startI, int startJ, int endI,
  77. int endJ) {
  78. Point pStart = new Point(startI, startJ);
  79. Point pEnd = new Point(endI, endJ);
  80. MoveStep step = new MoveStep(pStart, pEnd);
  81. 棋谱.add(step);
  83. String 棋子类别 = piece.棋子类别();
  84. String name = piece.getName();
  85. String m = "#" + 棋子类别 + name + ": " + startI + numberToLetter(startJ)
  86. + " 到 " + endI + numberToLetter(endJ);
  87. text.append(m);
  88. if (piece.棋子类别().equals(board.黑方颜色))
  89. text.append("n");
  90. }
  92. public void 记录吃掉的棋子(Object object) {
  93. 吃掉的棋子.add(object);
  94. }
  96. public LinkedList 获取棋谱() {
  97. return 棋谱;
  98. }
  100. public void actionPerformed(ActionEvent e) {
  101. int position = text.getText().lastIndexOf("#");
  102. if (position != -1)
  103. text.replaceRange("", position, text.getText().length());
  104. if (棋谱.size() > 0) {
  105. MoveStep lastStep = (MoveStep) 棋谱.getLast();
  106. 棋谱.removeLast();
  107. Object qizi = 吃掉的棋子.getLast();
  108. 吃掉的棋子.removeLast();
  109. String temp = qizi.toString();
  110. if (temp.equals("没吃棋子")) {
  111. int startI = lastStep.pStart.x;
  112. int startJ = lastStep.pStart.y;
  113. int endI = lastStep.pEnd.x;
  114. int endJ = lastStep.pEnd.y;
  115. ChessPiece piece = point[endI][endJ].getPiece();
  117. point[startI][startJ].setPiece(piece, board);
  118. (point[endI][endJ]).set有棋子(false);
  120. if (piece.棋子类别().equals(board.红方颜色)) {
  121. board.红方走棋 = true;
  122. board.黑方走棋 = false;
  123. }
  124. if (piece.棋子类别().equals(board.黑方颜色)) {
  125. board.黑方走棋 = true;
  126. board.红方走棋 = false;
  127. }
  128. } else {
  129. ChessPiece removedPiece = (ChessPiece) qizi;
  130. int startI = lastStep.pStart.x;
  131. int startJ = lastStep.pStart.y;
  132. int endI = lastStep.pEnd.x;
  133. int endJ = lastStep.pEnd.y;
  134. ChessPiece piece = point[endI][endJ].getPiece();
  135. point[startI][startJ].setPiece(piece, board);
  136. point[endI][endJ].setPiece(removedPiece, board);
  137. (point[endI][endJ]).set有棋子(true);
  139. if (piece.棋子类别().equals(board.红方颜色)) {
  140. board.红方走棋 = true;
  141. board.黑方走棋 = false;
  142. }
  143. if (piece.棋子类别().equals(board.黑方颜色)) {
  144. board.黑方走棋 = true;
  145. board.红方走棋 = false;
  146. }
  147. }
  148. }
  149. }
  150. }
复制代码

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

  2. package cn.edu.ouc.chineseChess;
  4. import javax.swing.*;
  5. import java.awt.*;
  6. import java.awt.event.*;
  7. import java.util.*;
  9. /**
  10. * 演示棋谱类
  11. *
  12. * @author cnlht
  13. */
  14. public class Demon extends JPanel implements ActionListener, Runnable {
  15. public JButton replay = null, next = null, auto = null, stop = null;
  16. LinkedList 棋谱 = null;
  17. Thread 自动演示 = null;
  18. int index = -1;
  19. ChessBoard board = null;
  20. JTextArea text;
  21. JTextField 时间间隔 = null;
  22. int time = 1000;
  23. String 演示过程 = "";
  24. JSplitPane splitH = null, splitV = null;
  26. public Demon(ChessBoard board) {
  27. this.board = board;
  28. replay = new JButton("重新演示");
  29. next = new JButton("下一步");
  30. auto = new JButton("自动演示");
  31. stop = new JButton("暂停演示");
  32. 自动演示 = new Thread(this);
  33. replay.addActionListener(this);
  34. next.addActionListener(this);
  35. auto.addActionListener(this);
  36. stop.addActionListener(this);
  37. text = new JTextArea();
  38. 时间间隔 = new JTextField("1");
  39. setLayout(new BorderLayout());
  40. JScrollPane pane = new JScrollPane(text);
  41. JPanel p = new JPanel(new GridLayout(3, 2));
  42. p.add(next);
  43. p.add(replay);
  44. p.add(auto);
  45. p.add(stop);
  46. p.add(new JLabel("时间间隔(秒)", SwingConstants.CENTER));
  47. p.add(时间间隔);
  48. splitV = new JSplitPane(JSplitPane.VERTICAL_SPLIT, pane, p);
  49. splitH = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, board, splitV);
  50. splitV.setDividerSize(5);
  51. splitV.setDividerLocation(400);
  52. splitH.setDividerSize(5);
  53. splitH.setDividerLocation(460);
  54. add(splitH, BorderLayout.CENTER);
  55. validate();
  56. }
  58. public void set棋谱(LinkedList 棋谱) {
  59. this.棋谱 = 棋谱;
  60. }
  62. public char numberToLetter(int n) {
  63. char c = '';
  64. switch (n) {
  65. case 1:
  66. c = 'A';
  67. break;
  68. case 2:
  69. c = 'B';
  70. break;
  71. case 3:
  72. c = 'C';
  73. break;
  74. case 4:
  75. c = 'D';
  76. break;
  77. case 5:
  78. c = 'E';
  79. break;
  80. case 6:
  81. c = 'F';
  82. break;
  83. case 7:
  84. c = 'G';
  85. break;
  86. case 8:
  87. c = 'H';
  88. break;
  89. case 9:
  90. c = 'I';
  91. break;
  92. case 10:
  93. c = 'J';
  94. break;
  95. }
  96. return c;
  97. }
  99. public void actionPerformed(ActionEvent e) {
  100. if (e.getSource() == next) {
  101. index++;
  102. if (index < 棋谱.size()) {
  103. 演示一步(index);
  104. } else {
  105. 演示结束("棋谱演示完毕");
  106. }
  107. }
  108. if (e.getSource() == replay) {
  109. board = new ChessBoard(45, 45, 9, 10);
  110. splitH.remove(board);
  111. splitH.setDividerSize(5);
  112. splitH.setDividerLocation(460);
  113. splitH.setLeftComponent(board);
  114. splitH.validate();
  115. index = -1;
  116. text.setText(null);
  117. }
  118. if (e.getSource() == auto) {
  119. next.setEnabled(false);
  120. replay.setEnabled(false);
  121. try {
  122. time = 1000 * Integer.parseInt(时间间隔.getText().trim());
  123. } catch (NumberFormatException ee) {
  124. time = 1000;
  125. }
  127. if (!(自动演示.isAlive())) {
  128. 自动演示 = new Thread(this);
  129. board = new ChessBoard(45, 45, 9, 10);
  130. splitH.remove(board);
  131. splitH.setDividerSize(5);
  132. splitH.setDividerLocation(460);
  133. splitH.setLeftComponent(board);
  134. splitH.validate();
  135. text.setText(null);
  136. 自动演示.start();
  137. }
  139. }
  140. if (e.getSource() == stop) {
  141. if (e.getActionCommand().equals("暂停演示")) {
  142. 演示过程 = "暂停演示";
  143. stop.setText("继续演示");
  144. stop.repaint();
  145. }
  146. if (e.getActionCommand().equals("继续演示")) {
  147. 演示过程 = "继续演示";
  148. 自动演示.interrupt();
  149. stop.setText("暂停演示");
  150. stop.repaint();
  151. }
  152. }
  153. }
  155. public synchronized void run() {
  156. for (index = 0; index < 棋谱.size(); index++) {
  157. try {
  158. Thread.sleep(time);
  159. } catch (InterruptedException e) {
  160. }
  161. while (演示过程.equals("暂停演示")) {
  162. try {
  163. wait();
  164. } catch (InterruptedException e) {
  165. notifyAll();
  166. }
  167. }
  168. 演示一步(index);
  169. }
  170. if (index >= 棋谱.size()) {
  171. 演示结束("棋谱演示完毕");
  172. next.setEnabled(true);
  173. replay.setEnabled(true);
  174. }
  175. }
  177. public void 演示一步(int index) {
  178. MoveStep step = (MoveStep) 棋谱.get(index);
  179. Point pStart = step.pStart;
  180. Point pEnd = step.pEnd;
  181. int startI = pStart.x;
  182. int startJ = pStart.y;
  183. int endI = pEnd.x;
  184. int endJ = pEnd.y;
  185. ChessPiece piece = (board.point)[startI][startJ].getPiece();
  186. if ((board.point)[endI][endJ].isPiece() == true) {
  187. ChessPiece pieceRemoved = (board.point)[endI][endJ].getPiece();
  188. (board.point)[endI][endJ].reMovePiece(pieceRemoved, board);
  189. board.repaint();
  190. (board.point)[endI][endJ].setPiece(piece, board);
  191. (board.point)[startI][startJ].set有棋子(false);
  192. board.repaint();
  193. } else {
  194. (board.point)[endI][endJ].setPiece(piece, board);
  195. (board.point)[startI][startJ].set有棋子(false);
  197. }
  198. String 棋子类别 = piece.棋子类别();
  199. String name = piece.getName();
  200. String m = "#" + 棋子类别 + name + ": " + startI + numberToLetter(startJ)
  201. + " 到 " + endI + numberToLetter(endJ);
  202. text.append(m);
  203. if (piece.棋子类别().equals(board.黑方颜色))
  204. text.append("n");
  205. }
  207. public void 演示结束(String message) {
  208. splitH.remove(board);
  209. splitH.setDividerSize(5);
  210. splitH.setDividerLocation(460);
  211. JLabel label = new JLabel(message);
  212. label.setFont(new Font("隶书", Font.BOLD, 40));
  213. label.setForeground(Color.blue);
  214. label.setHorizontalAlignment(SwingConstants.CENTER);
  215. splitH.setLeftComponent(label);
  216. splitH.validate();
  217. }
  218. }
复制代码

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

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

收藏 邀请
上一篇：探讨java深拷贝下一篇：Java棋类游戏实践之单机版五子棋

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-7-8 07:04

Copyright 2015-2025 djqfx

返回顶部