/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package 中国象棋打谱系统;
/**
*
* @author Administrator
*/
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
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.setColor(foreColor);
g.fillOval(2,2,width-2,height-2);
g.setColor(Color.white);
g.setFont(new Font("隶书",Font.BOLD,28));
g.drawString(name,7,height-8);
g.setColor(Color.yellow);
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 颜色类别;
}
}
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package 中国象棋打谱系统;
/**
*
* @author Administrator
*/
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;
}
}
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package 中国象棋打谱系统;
/**
*
* @author Administrator
*/
import java.awt.Point;
public class MoveStep implements java.io.Serializable
{
public Point pStart,pEnd;
public MoveStep(Point p1,Point p2)
{
pStart=p1;
pEnd=p2;
}
}
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package 中国象棋打谱系统;
/**
*
* @author Administrator
*/
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class ChessBoard extends JPanel implements MouseListener,MouseMotionListener
{
public ChessPoint point[][];
public int unitWidth,unitHeight;
int x轴长,y轴长;
int x,y;
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) ;
红车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.blue,bc,w-4,h-4,this);
黑将.set棋子类别(黑方颜色);
黑士1=new ChessPiece("士",Color.blue,bc,w-4,h-4,this);
黑士1.set棋子类别(黑方颜色);
黑士2=new ChessPiece("士",Color.blue,bc,w-4,h-4,this);
黑士2.set棋子类别(黑方颜色);
黑车1=new ChessPiece("车",Color.blue,bc,w-4,h-4,this);
黑车1.set棋子类别(黑方颜色);
黑车2=new ChessPiece("车",Color.blue,bc,w-4,h-4,this);
黑车2.set棋子类别(黑方颜色);
黑炮1=new ChessPiece("炮",Color.blue,bc,w-4,h-4,this);
黑炮1.set棋子类别(黑方颜色);
黑炮2=new ChessPiece("炮",Color.blue,bc,w-4,h-4,this);
黑炮2.set棋子类别(黑方颜色);
黑象1=new ChessPiece("象",Color.blue,bc,w-4,h-4,this);
黑象1.set棋子类别(黑方颜色);
黑象2=new ChessPiece("象",Color.blue,bc,w-4,h-4,this);
黑象2.set棋子类别(黑方颜色);
黑马1=new ChessPiece("马",Color.blue,bc,w-4,h-4,this);
黑马1.set棋子类别(黑方颜色);
黑马2=new ChessPiece("马",Color.blue,bc,w-4,h-4,this);
黑马2.set棋子类别(黑方颜色);
黑卒1=new ChessPiece("卒",Color.blue,bc,w-4,h-4,this);
黑卒1.set棋子类别(黑方颜色);
黑卒2=new ChessPiece("卒",Color.blue,bc,w-4,h-4,this);
黑卒2.set棋子类别(黑方颜色);
黑卒3=new ChessPiece("卒",Color.blue,bc,w-4,h-4,this);
黑卒3.set棋子类别(黑方颜色);
黑卒4=new ChessPiece("卒",Color.blue,bc,w-4,h-4,this);
黑卒4.set棋子类别(黑方颜色);
黑卒5=new ChessPiece("卒",Color.blue,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);
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) ;
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)
{
}
}
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package 中国象棋打谱系统;
/**
*
* @author Administrator
*/
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
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 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("马"))
{
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("帅"))||(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 可否走棋;
}
}
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package 中国象棋打谱系统;
/**
*
* @author Administrator
*/
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.LinkedList;
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;
}
}
}
}
}
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package 中国象棋打谱系统;
/**
*
* @author Administrator
*/
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
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();
}
}
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package 中国象棋打谱系统;
/**
*
* @author Administrator
*/
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.LinkedList;
public class Chess 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 Chess()
{
bar=new JMenuBar();
fileMenu=new JMenu("中国象棋");
制作棋谱=new JMenuItem("制作棋谱");
保存棋谱=new JMenuItem("保存棋谱");
演示棋谱=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,670,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 Chess();
}
}
本文介绍了中国象棋打谱系统的各个组件，包括棋子类 ChessPiece 的实现，棋盘 ChessBoard 的交互设计，以及关键逻辑如移动步数 MoveStep 和规则 Rule 的应用。通过实例展示了如何创建棋子、处理鼠标事件以及棋子移动的规则判断。
365
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
