/// <summary>
/// 判断是否被将军
/// </summary>
/// <returns></returns>
public static bool Checked( )
{
int i, j, sqSrc, sqDst;
int pcSelfSide, pcOppSide, pcDst, nDelta;
pcSelfSide = Chess_LoadUtil.SIDE_TAG(sdPlayer); // 获得红黑标记(红子是8，黑子是16)
pcOppSide = Chess_LoadUtil.OPP_SIDE_TAG(sdPlayer); // 获得红黑标记，对方的
// 找到棋盘上的帅(将)，再做以下判断：
for (sqSrc = 0; sqSrc < 256; sqSrc++)
{
if (ucpcSquares[sqSrc] != pcSelfSide + GameConstant.PIECE_KING)
{
continue;
}
// 1. 判断是否被对方的兵(卒)将军
if (ucpcSquares[Chess_LoadUtil.SQUARE_FORWARD(sqSrc, sdPlayer)] == pcOppSide
+ GameConstant.PIECE_PAWN)
{
return(true);
}
for (nDelta = -1; nDelta <= 1; nDelta += 2)
{
if (ucpcSquares[sqSrc + nDelta] == pcOppSide + GameConstant.PIECE_PAWN)
{
return(true);
}
}
// 2. 判断是否被对方的马将军(以仕(士)的步长当作马腿)
for (i = 0; i < 4; i++)
{
if (ucpcSquares[sqSrc + GameConstant.ccAdvisorDelta[i]] != 0)
{
continue;
}
for (j = 0; j < 2; j++)
{
int pcDstt = ucpcSquares[sqSrc + GameConstant.ccKnightCheckDelta[i][j]];
if (pcDstt == pcOppSide + GameConstant.PIECE_KNIGHT)
{
return(true);
}
}
}
// 3. 判断是否被对方的车或炮将军(包括将帅对脸)
for (i = 0; i < 4; i++)
{
nDelta = GameConstant.ccKingDelta[i];
sqDst = sqSrc + nDelta;
while (Chess_LoadUtil.IN_BOARD(sqDst))
{
pcDst = ucpcSquares[sqDst];
if (pcDst != 0)
{
if (pcDst == pcOppSide + GameConstant.PIECE_ROOK || pcDst == pcOppSide + GameConstant.PIECE_KING)
{
return(true);
}
break;
}
sqDst += nDelta;
}
sqDst += nDelta;
while (Chess_LoadUtil.IN_BOARD(sqDst))
{
pcDst = ucpcSquares[sqDst];
if (pcDst != 0)
{
if (pcDst == pcOppSide + GameConstant.PIECE_CANNON)
{
return(true);
}
break;
}
sqDst += nDelta;
}
}
return(false);
}
return(false);
}
/// <summary>
/// 判断走法是否合理，生成所有走法后，判断每个走法是否合理，只把合理的走法留下来。
/// </summary>
/// <param name="mv"></param>
/// <returns></returns>
public static bool LegalMove(int mv)
{
int sqSrc, sqDst, sqPin;
int pcSelfSide, pcSrc, pcDst, nDelta;
// 判断走法是否合法，需要经过以下的判断过程：
// 1. 判断起始格是否有自己的棋子
sqSrc = Chess_LoadUtil.SRC(mv);
pcSrc = ucpcSquares[sqSrc];
pcSelfSide = Chess_LoadUtil.SIDE_TAG(sdPlayer); // 获得红黑标记(红子是8，黑子是16)
Debuger.Log(string.Format("下棋方pcSelfSide = {0}, pcSrc = {1}", pcSelfSide, pcSrc));
if ((pcSrc & pcSelfSide) == 0)
{
return(false);
}
// 2. 判断目标格是否有自己的棋子
sqDst = Chess_LoadUtil.DST(mv);
pcDst = ucpcSquares[sqDst];
if ((pcDst & pcSelfSide) != 0)
{
return(false);
}
// 3. 根据棋子的类型检查走法是否合理
switch (pcSrc - pcSelfSide)
{
case GameConstant.PIECE_KING:
return(Chess_LoadUtil.IN_FORT(sqDst) && Chess_LoadUtil.KING_SPAN(sqSrc, sqDst));
case GameConstant.PIECE_ADVISOR:
return(Chess_LoadUtil.IN_FORT(sqDst) && Chess_LoadUtil.ADVISOR_SPAN(sqSrc, sqDst));
case GameConstant.PIECE_BISHOP:
return(Chess_LoadUtil.SAME_HALF(sqSrc, sqDst) && Chess_LoadUtil.BISHOP_SPAN(sqSrc, sqDst) &&
ucpcSquares[Chess_LoadUtil.BISHOP_PIN(sqSrc, sqDst)] == 0);
case GameConstant.PIECE_KNIGHT:
sqPin = Chess_LoadUtil.KNIGHT_PIN(sqSrc, sqDst);
return(sqPin != sqSrc && ucpcSquares[sqPin] == 0);
case GameConstant.PIECE_ROOK:
case GameConstant.PIECE_CANNON:
if (Chess_LoadUtil.SAME_RANK(sqSrc, sqDst))
{
nDelta = (sqDst < sqSrc ? -1 : 1);
}
else if (Chess_LoadUtil.SAME_FILE(sqSrc, sqDst))
{
nDelta = (sqDst < sqSrc ? -16 : 16);
}
else
{
return(false);
}
sqPin = sqSrc + nDelta;
while (sqPin != sqDst && ucpcSquares[sqPin] == 0)
{
sqPin += nDelta;
}
if (sqPin == sqDst)
{
return(pcDst == 0 || pcSrc - pcSelfSide == GameConstant.PIECE_ROOK);
}
else if (pcDst != 0 && pcSrc - pcSelfSide == GameConstant.PIECE_CANNON)
{
sqPin += nDelta;
while (sqPin != sqDst && ucpcSquares[sqPin] == 0)
{
sqPin += nDelta;
}
return(sqPin == sqDst);
}
else
{
return(false);
}
case GameConstant.PIECE_PAWN:
Debuger.Log(string.Format("走的炮"));
if (Chess_LoadUtil.AWAY_HALF(sqDst, sdPlayer) &&
(sqDst == sqSrc - 1 || sqDst == sqSrc + 1))
{
return(true);
}
return(sqDst == Chess_LoadUtil.SQUARE_FORWARD(sqSrc, sdPlayer));
default:
return(false);
}
}
/// <summary>
/// 生成所有走法，该方法根据该局面来生成所有该方的走棋步骤
/// </summary>
/// <param name="mvs"></param>
/// <returns></returns>
public static int GenerateMoves(int[] mvs)
{
int i, j, nGenMoves, nDelta, sqSrc, sqDst;
int pcSelfSide, pcOppSide, pcSrc, pcDst;
// 生成所有走法，需要经过以下2个步骤：
nGenMoves = 0;
pcSelfSide = Chess_LoadUtil.SIDE_TAG(sdPlayer);
pcOppSide = Chess_LoadUtil.OPP_SIDE_TAG(sdPlayer);
for (sqSrc = 0; sqSrc < 256; sqSrc++)
{
// 1. 找到一个本方棋子，再做以下判断：
pcSrc = ucpcSquares[sqSrc];
if ((pcSrc & pcSelfSide) == 0)
{
continue;
}
// 2. 根据棋子确定走法
switch (pcSrc - pcSelfSide)
{
// 帅(将)
case GameConstant.PIECE_KING:
for (i = 0; i < 4; i++)
{
sqDst = sqSrc + GameConstant.ccKingDelta[i];
if (!Chess_LoadUtil.IN_FORT(sqDst))
{
continue;
}
pcDst = ucpcSquares[sqDst];
if ((pcDst & pcSelfSide) == 0)
{
mvs[nGenMoves] = Chess_LoadUtil.MOVE(sqSrc, sqDst); // 根据起点和终点获得走法
//Debuger.LogWarning(string.Format("GameLogic->GenerateMoves(),帅(将)moves[{0}] = {1}", nGenMoves, mvs[nGenMoves]));
nGenMoves++;
}
}
break;
// 士
case GameConstant.PIECE_ADVISOR:
for (i = 0; i < 4; i++)
{
sqDst = sqSrc + GameConstant.ccAdvisorDelta[i];
if (!Chess_LoadUtil.IN_FORT(sqDst))
{
continue;
}
pcDst = ucpcSquares[sqDst];
if ((pcDst & pcSelfSide) == 0)
{
mvs[nGenMoves] = Chess_LoadUtil.MOVE(sqSrc, sqDst);
nGenMoves++;
}
}
break;
// 象
case GameConstant.PIECE_BISHOP:
for (i = 0; i < 4; i++)
{
sqDst = sqSrc + GameConstant.ccAdvisorDelta[i];
if (!(Chess_LoadUtil.IN_BOARD(sqDst) && Chess_LoadUtil.HOME_HALF(sqDst, sdPlayer) && ucpcSquares[sqDst] == 0))
{
continue;
}
sqDst += GameConstant.ccAdvisorDelta[i];
pcDst = ucpcSquares[sqDst];
if ((pcDst & pcSelfSide) == 0)
{
mvs[nGenMoves] = Chess_LoadUtil.MOVE(sqSrc, sqDst);
nGenMoves++;
}
}
break;
//马
case GameConstant.PIECE_KNIGHT:
for (i = 0; i < 4; i++)
{
sqDst = sqSrc + GameConstant.ccKingDelta[i];
if (ucpcSquares[sqDst] != 0)
{
continue;
}
for (j = 0; j < 2; j++)
{
sqDst = sqSrc + GameConstant.ccKnightDelta[i][j];
if (!Chess_LoadUtil.IN_BOARD(sqDst))
{
continue;
}
pcDst = ucpcSquares[sqDst];
if ((pcDst & pcSelfSide) == 0)
{
mvs[nGenMoves] = Chess_LoadUtil.MOVE(sqSrc, sqDst);
nGenMoves++;
}
}
}
break;
// 车
case GameConstant.PIECE_ROOK:
for (i = 0; i < 4; i++)
{
nDelta = GameConstant.ccKingDelta[i];
sqDst = sqSrc + nDelta;
while (Chess_LoadUtil.IN_BOARD(sqDst))
{
pcDst = ucpcSquares[sqDst];
if (pcDst == 0)
{
mvs[nGenMoves] = Chess_LoadUtil.MOVE(sqSrc, sqDst);
nGenMoves++;
}
else
{
if ((pcDst & pcOppSide) != 0)
{
mvs[nGenMoves] = Chess_LoadUtil.MOVE(sqSrc, sqDst);
nGenMoves++;
}
break;
}
sqDst += nDelta;
}
}
break;
// 炮
case GameConstant.PIECE_CANNON:
for (i = 0; i < 4; i++)
{
nDelta = GameConstant.ccKingDelta[i];
sqDst = sqSrc + nDelta;
while (Chess_LoadUtil.IN_BOARD(sqDst))
{
pcDst = ucpcSquares[sqDst];
if (pcDst == 0)
{
mvs[nGenMoves] = Chess_LoadUtil.MOVE(sqSrc, sqDst);
nGenMoves++;
}
else
{
break;
}
sqDst += nDelta;
}
sqDst += nDelta;
while (Chess_LoadUtil.IN_BOARD(sqDst))
{
pcDst = ucpcSquares[sqDst];
if (pcDst != 0)
{
if ((pcDst & pcOppSide) != 0)
{
mvs[nGenMoves] = Chess_LoadUtil.MOVE(sqSrc, sqDst);
nGenMoves++;
}
break;
}
sqDst += nDelta;
}
}
break;
//小兵
case GameConstant.PIECE_PAWN:
sqDst = Chess_LoadUtil.SQUARE_FORWARD(sqSrc, sdPlayer); // 格子水平镜像
if (Chess_LoadUtil.IN_BOARD(sqDst)) // 判断棋子是否在棋盘中
{
pcDst = ucpcSquares[sqDst];
if ((pcDst & pcSelfSide) == 0)
{
mvs[nGenMoves] = Chess_LoadUtil.MOVE(sqSrc, sqDst);
nGenMoves++;
}
}
if (Chess_LoadUtil.AWAY_HALF(sqSrc, sdPlayer))
{
for (nDelta = -1; nDelta <= 1; nDelta += 2)
{
sqDst = sqSrc + nDelta;
if (Chess_LoadUtil.IN_BOARD(sqDst))
{
pcDst = ucpcSquares[sqDst];
if ((pcDst & pcSelfSide) == 0)
{
mvs[nGenMoves] = Chess_LoadUtil.MOVE(sqSrc, sqDst);
nGenMoves++;
}
}
}
}
break;
}
}
return(nGenMoves);
}
