JAVA中国象棋游戏设计.docx
《JAVA中国象棋游戏设计.docx》由会员分享，可在线阅读，更多相关《JAVA中国象棋游戏设计.docx（33页珍藏版）》请在冰豆网上搜索。
JAVA中国象棋游戏设计
佛山科学技术学院
《可视化编程技术》课程设计报告
中国象棋游戏设计
******
学号：
**********
年级专业：
12级教育技术学2
*******
学院：
教育科学学院
广东★佛山
提交日期：
2014年6月
1.前言………………………………………………………………………………2
2．概要设计…………………………………………………………………………2
2.1开发环境……………………………………………………………………2
2.2象棋功能……………………………………………………………………2
2.3界面设计……………………………………………………………………3
3.详细设计………………………………………………………………………4
3.1象棋面板的java类的说明………………………………………………4
4.运行结果…………………………………………………………………………8
6.源程序…………………………………………………………………………24
设计总结……………………………………………………………………………32
1前言
随着科学技术的不断发展，计算机已经成为我们工作学习和生活中不可缺少的工具。
文本编辑器是个人计算机最司空见惯的应用程序了，在学习了Java语言之后，我决定使用Java语言编写一个简单有趣的中国象棋游戏，可以实现简单的中国象棋游戏功能，满足日常益智娱乐需要。
Java是由Sun公司开发的新一代纯面向对象的网络编程语言。
其目标是建立一种在任意种机器、任一种操作系统的网络环境中运行的软件，实行所谓的“程序写一次，到处运行”的目标。
正因为如此，Java已成为当今Internet上最流行、最受欢迎的一种程序开发语言。
Java开发小组把Java按特性分为基本版、移动版、企业版，每个版本有一个软件开发包。
Java基本版本叫Java2标准版（Java2StandardEdition,J2SE）,它包含建立Java应用程序或者是Applet所需的应用程序编程接口（API）。
Java2移动版（TheJava2MobileEdition，J2ME）包含创建无线Java应用程序的API。
还有Java2企业版（TheJava2Enterprise，J2EE）是J2SE的增强版本，包含建立多层架构应用程序API。
Java语言是由C++语言发展起而来的，是一种彻底的面向对象的程序设计语言。
作为一种纯面向对象的程序设计语言，它非常适合大型软件的开发。
Java语言去掉了C++语言的一些容易引起错误的特性。
Java语言的特点有：
面向对象、跨平台、安全性、多线程和图形功能强。
关键字：
Java象棋游戏，游戏类，中国象棋游戏
2概要设计
2.1开发环境
开发平台：
MicrosoftWindowsXPProfessionalServicePack2
开发工具：
JBuilder2007+JDK1.6.0_02
2.2象棋功能
功能1：
下棋，游戏开始后通过鼠标点击对棋子进行移动。
功能2：
悔棋，通过back键可以后退一次最近的操作
功能3：
存档，对当前的棋局进行保存
功能4：
读档，可以继承之前保存的记录，继续进行游戏
功能5：
可以设置进行不同模式的对战，可进行双人单机，网络对战，人机对战
功能6：
翻转棋盘，可以使红黑双方对调
2.3界面设计
图2.3象棋面板
3详细设计
3.1象棋面板使用的Java类的说明
packageorg.acerge.engine;
importjava.io.Serializable;
importjava.util.ArrayList;
publicclassActiveBoardimplementsSerializable{
//Rank[x],File[x],Bottom[x]比x%10,x/10,x*10运算快
publicstaticfinalint[]RANK={//File[19]=1,Rank[19]=9;
0,1,2,3,4,5,6,7,8,9,
0,1,2,3,4,5,6,7,8,9,
0,1,2,3,4,5,6,7,8,9,
0,1,2,3,4,5,6,7,8,9,
0,1,2,3,4,5,6,7,8,9,
0,1,2,3,4,5,6,7,8,9,
0,1,2,3,4,5,6,7,8,9,
0,1,2,3,4,5,6,7,8,9,
0,1,2,3,4,5,6,7,8,9
};
publicstaticfinalintFILE[]={//File[12]=1,Rank[12]=2;
0,0,0,0,0,0,0,0,0,0,
1,1,1,1,1,1,1,1,1,1,
2,2,2,2,2,2,2,2,2,2,
3,3,3,3,3,3,3,3,3,3,
4,4,4,4,4,4,4,4,4,4,
5,5,5,5,5,5,5,5,5,5,
6,6,6,6,6,6,6,6,6,6,
7,7,7,7,7,7,7,7,7,7,
8,8,8,8,8,8,8,8,8,8
};
publicstaticfinalint[]BOTTOM={
0,10,20,30,40,50,60,70,80
};
publicstaticfinalint[]HORSE_LEG_TABLE={//int
-10,0,-10,0,0,0,0,0,0,-1,0,
0,0,1,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,-1,0,0,0,
1,0,0,0,0,0,0,10,0,10
//Move.Dst-Move.Src={-21,-19,-12,-8,8,12,19,21}
//HorseLeg[Dst-Src+21]={-10,-10,-1,1,-1,,1,10,10}:
蹩马腿的增量
//LegalMove:
returnSquares[Move.Src+HorseLegTab[Move.Dst-Move.Src+21]]==0
};
publicstaticfinalint[]PIECE_TYPES={
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
0,1,1,2,2,3,3,4,4,5,5,6,6,6,6,6,
7,8,8,9,9,10,10,11,11,12,12,13,13,13,13,13
};
publicfinalstaticintMAX_MOVE_NUM=256;
publicfinalstaticintLOOP_HASH_MASK=0x3ff;
publicfinalstaticintMAX_CONSECUTIVE_MOVES=200;
privateintplayer;//0=Red（White）and1=Black
privateint[]evalue;//int[2]TotalValueofRed（0）/Black
（1）Pieces
privateint[]squares;//int[90]PieceIndexesofeachsquare,Squares[i]=0:
Unoccupied,16-31:
Red,32-47=Black
privateint[]pieces;//int[48]SquareIndexesofeachpiece,-1=Captured//被吃了
//Square[x]=y（y:
indexofPieceTypesinSquare[x]）,
//Pieces[y]=x（yisthepieceType,xrepresentpieceTypeYinSquare5）,
//x:
indexoflocationinboard（0~89）
privateint[]bitFiles;//[9]方便按行位纵线查询BitFiles[1]表示第1列（b纵线）上的棋子
privateint[]bitRanks;//[10]方便按列位横线查询
privateBitBoard[]pieceBits;//[14]分兵种及红黑的棋子位棋盘
privateBitBoardallPieces;//整个棋盘
//ZobristKeyandLock
privatelongzobristKey,zobristLock;
//HistoryMoveNodes,用来作为循环重复检测
privateintmoveNum;
MoveNode[]moveList;//[ChessStruct.MaxMoveNum];
char[]loopHash;//[LoopHashMask+1];
publicActiveBoard（）{
inti;
player=0;
evalue=newint[2];
evalue[0]=evalue[1]=0;
squares=newint[90];
for（i=0;i<90;i++）{
squares[i]=0;
}
pieces=newint[48];
for（i=16;i<48;i++）{
pieces[i]=-1;
}
bitFiles=newint[9];
for（i=0;i<9;i++）{
bitFiles[i]=0;
}
bitRanks=newint[10];
for（i=0;i<10;i++）{
bitRanks[i]=0;
}
pieceBits=newBitBoard[14];
for（i=0;i<14;i++）{
pieceBits[i]=newBitBoard（0）;
}
allPieces=newBitBoard（0）;
zobristKey=zobristLock=0;
moveNum=1;
moveList=newMoveNode[MAX_MOVE_NUM];
for（i=0;imoveList[i]=newMoveNode（）;
}
loopHash=newchar[LOOP_HASH_MASK+1];
for（i=0;iloopHash[i]=0;
}
}
privatevoidchangeSide（）{
player=1-player;
zobristKey^=PreMoveNodesGen.ZobristKeyPlayer;
zobristLock^=PreMoveNodesGen.ZobristLockPlayer;
}
privatevoidclearSquare（intSquare）{
intPiece;
Piece=squares[Square];
squares[Square]=0;
pieces[Piece]=-1;
changePiece（Square,Piece）;
}
privatevoidclearPiece（intPiece）{
intSquare;
Square=pieces[Piece];
squares[Square]=0;
pieces[Piece]=-1;
changePiece（Square,Piece）;
}
privatevoidsetPiece（intSquare,intPiece）{
squares[Square]=Piece;
pieces[Piece]=Square;
changePiece（Square,Piece,true）;
}
publicvoidnullMove（）{
MoveNodeThisMove=newMoveNode（）;
changeSide（）;
ThisMove.src=ThisMove.dst=ThisMove.cap=-1;
ThisMove.chk=false;
moveList[moveNum]=ThisMove;
moveNum++;
}
publicvoidundoNull（）{
moveNum--;
changeSide（）;
}
//MoveDetectionProcedures
publicbooleannarrowCap（MoveNodeMove）{
returnnarrowCap（Move,false）;
}
publicbooleannarrowCap（MoveNodeMove,booleanAdvisorBishop）{//是否吃子
intCaptured;
//Move.Dst=00010001or00010010:
red仕相
//Move.Dst=00100010or00100010:
black士象
//>00010010or>00100010:
其他棋子
Captured=squares[Move.dst]&0xf;
if（Captured>10）{
Captured=RANK[Move.dst];
return（player!
=0）?
（Captured>=5）:
（Captured<=4）;
}else{
returnAdvisorBishop||Captured>4;
}
}
publicMoveNodelastMove（）{
returnmoveList[moveNum-1];
}
publicintevaluation（）{
returnevalue[player]-evalue[1-player];
}
privatevoidchangePiece（intSquare,intPiece）{
changePiece（Square,Piece,false）;
}
privatevoidchangePiece（intSquare,intPiece,booleanIsAdd）{
intx,y,PieceType,Side,Value;
allPieces.assignXor（PreMoveNodesGen.BitMask[Square]）;
x=FILE[Square];
y=RANK[Square];
bitFiles[x]^=1<bitRanks[y]^=1<PieceType=PIECE_TYPES[Piece];
pieceBits[PieceType].assignXor（PreMoveNodesGen.BitMask[Square]）;
zobristKey^=PreMoveNodesGen.ZobristKeyTable[PieceType][Square];
zobristLock^=PreMoveNodesGen.ZobristLockTable[PieceType][Square];
if（PieceType<7）{
Side=0;
Value=CCEvalue.BasicValues[PieceType]+CCEvalue.PosValues[PieceType][Square];
}else{
Side=1;
Value=CCEvalue.BasicValues[PieceType-7]+CCEvalue.PosValues[PieceType-7][89-Square];
}
if（IsAdd）{
evalue[Side]+=Value;
}else{
evalue[Side]-=Value;
}
}
publicbooleanmovePiece（MoveNodeMove）{
intMoved,Captured;
MoveNodeThisMove;
longOldZobristKey;
if（Move.src<0||Move.dst<0）returnfalse;//addforsearchfunction
OldZobristKey=zobristKey;
Moved=squares[Move.src];
Captured=squares[Move.dst];
if（Captured!
=0）{
clearSquare（Move.dst）;
}
clearSquare（Move.src）;
setPiece（Move.dst,Moved）;
if（checked（player））{
Moved=squares[Move.dst];
clearSquare（Move.dst）;
setPiece（Move.src,Moved）;
if（Captured!
=0）{
setPiece（Move.dst,Captured）;
}
returnfalse;
}else{
if（loopHash[（int）（OldZobristKey&LOOP_HASH_MASK）]==0）{
loopHash[（int）（OldZobristKey&LOOP_HASH_MASK）]=（char）moveNum;
}
changeSide（）;
ThisMove=Move;
ThisMove.cap=Captured;
ThisMove.chk=checked（player）;
moveList[moveNum]=ThisMove;
moveNum++;
returntrue;
}
}
publicvoidundoMove（）{
intMoved;
MoveNodeThisMove;
moveNum--;
ThisMove=moveList[moveNum];
Moved=squares[ThisMove.dst];
clearSquare（ThisMove.dst）;
setPiece（ThisMove.src,Moved）;
if（ThisMove.cap!
=0）{
setPiece（ThisMove.dst,ThisMove.cap）;
}
changeSide（）;
if（loopHash[（int）（zobristKey&LOOP_HASH_MASK）]==moveNum）{
loopHash[（int）（zobristKey&LOOP_HASH_MASK）]=0;
}
}
//LeagalMoveDetectionProcedures
publicbooleanleagalMove（MoveNodeMove）{
intPiece,Attack,x,y,BitWord;
Piece=squares[Move.src];
if（（Piece&（player!
=0?
32:
16））==0）{
returnfalse;//所选的棋子是否是当前Player的
}
Attack=squares[Move.dst];
if（（Attack&（player!
=0?
32:
16））!
=0）{
returnfalse;//所吃的棋子是否是对方的
}
switch（PIECE_TYPES[Piece]-（player!
=0?
7:
0））{
case5:
//炮,吃子时中间要有炮架
x=FILE[Move.src];
y=RANK[Move.src];
if（x==FILE[Move.dst]）{//进退
BitWord=bitFiles[x];
if（Move.srcif（（Attack&（player!
=0?
16:
32））!
=0）{//吃子
returnMove.dst==PreMoveNodesGen.FileCannonCapMax[y][BitWord]+BOTTOM[x];
}else{//不吃子
returnMove.dst<=PreMoveNodesGen.FileNonCapMax[y][BitWord]+BOTTOM[x];
}
}else{//Move.Src>Move.Dst,退
if（（Attack&（player!
=0?
16:
32））!
=0）{
returnMove.dst==PreMoveNodesGen.FileCannonCapMin[y][BitWord]+BOTTOM[x];
}else{
returnMove.dst>=PreM
升级会员 