java_day15
目标：Java web开发
昨天，新增三个类
ChessBoard board = null;//象棋棋盘类
Demon demon = null;//演示棋谱类
MakeChessManual record = null;//制作棋谱类
ChessBoard类：
package cn.edu.ouc.chineseChess;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
/**
* 棋盘类
*
* @author cnlht
*/
class ChessBoard extends JPanel implements MouseListener,MouseMotionListener {//重写鼠标监听器接口
public ChessPoint point[][];//ChessPoint在ChesePoint.java文件中被定义
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在ChesePiece.java文件中被定义
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;///Rule在Rule.java文件中被定义
public MakeChessManual record = null;///MakeChessManual在MakeChessManual.java文件中被定义
public ChessBoard(int w, int h, int r, int c) {
setLayout(null);//设置jpane的布局管理器为空，不用java提供的布局，要手动设置组件的坐标位置和大小。
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) {//重写paintComponent接口
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) {
//instanceof判定左边的引用类型是否与右边的引用类型的类型是否相同
//instanceof 的对比结果为 boolean 类型，如果左右两边比对成功，返回 true ；否则返回 flase
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) {
}
}
ChessBorad类牵扯出三个类：
ChessPoint.java
ChessPiece.java
Rule.java
算了，反正能读懂，一起发出来吧
ChessPoint.java
package cn.edu.ouc.chineseChess;
/**
* 棋点类
*
* @author cnlht
*/
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;
}
}
ChessPiece.java
package cn.edu.ouc.chineseChess;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
/**
* 棋子类
*
* @author cnlht
*/
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 颜色类别;
}
}
Rule.java
package cn.edu.ouc.chineseChess;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
/**
* 走棋规则类
*
* @author cnlht
*/
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 可否走棋;
}
}
😓😓😓智商欠费了。。。
把事情想像的过于简单了，理解这8个文件可要了命了。cnlht大神写的东西，果然不简单。
浙公网安备 33010602011771号