// update castling state
public void UpdateCastlingState( ChessMover.sMove move )
{
// possible castling condition
//1.The king has not previously moved.
//2.The chosen rook has not previously moved.
//3.There are no pieces between the king and the chosen rook.
//4.The king is not currently in check.
//5.The king does not pass through a square that is under attack by enemy pieces.[2]
//6.The king does not end up in check (true of any legal move).
// 1 and 2 case, disable castling state
switch( move.srcSquare.piece.piecePlayerType )
{
case PiecePlayerType.eWhite_King:
{
currCastlingState.CastlingWKSide = CastlingState.eCastling_Disable_State;
currCastlingState.CastlingWQSide = CastlingState.eCastling_Disable_State;
}
break;
case PiecePlayerType.eWhite_RookLeft:
{
currCastlingState.CastlingWQSide = CastlingState.eCastling_Disable_State;
}
break;
case PiecePlayerType.eWhite_RookRight:
{
currCastlingState.CastlingWKSide = CastlingState.eCastling_Disable_State;
}
break;
case PiecePlayerType.eBlack_King:
{
currCastlingState.CastlingBKSide = CastlingState.eCastling_Disable_State;
currCastlingState.CastlingBQSide = CastlingState.eCastling_Disable_State;
}
break;
case PiecePlayerType.eBlack_RookLeft:
{
currCastlingState.CastlingBQSide = CastlingState.eCastling_Disable_State;
}
break;
case PiecePlayerType.eBlack_RookRight:
{
currCastlingState.CastlingBKSide = CastlingState.eCastling_Disable_State;
}
break;
}
int nWhiteKingSquare = 4;
int nWhiteKSideRookSquare = 7;
int nWhiteQSideRookSquare = 0;
int nBlackKingSquare = 60;
int nBlackKSideRookSquare = 63;
int nBlackQSideRookSquare = 56;
// white king side check
if( currCastlingState.CastlingWKSide != CastlingState.eCastling_Disable_State )
{
// 3, 4, 5 case
if( IsWKSideCastlingRangeBlank() == false || IsWhiteKingInCheck() ||
IsRangeNoneAttackBySquare( nWhiteKingSquare, nWhiteKSideRookSquare, BlackPBB ) == false ) {
currCastlingState.CastlingWKSide = CastlingState.eCastling_Temporary_Disable_State;
//UnityEngine.Debug.LogError( "ChessBitBoard::UpdateCastlingState() - CastlingWKSide disabled" );
}
else {
currCastlingState.CastlingWKSide = CastlingState.eCastling_Enable_State;
//UnityEngine.Debug.LogError( "ChessBitBoard::UpdateCastlingState() - CastlingWKSide enabled" );
}
}
// white queen side check
if( currCastlingState.CastlingWQSide != CastlingState.eCastling_Disable_State )
{
// 3 case
if( IsWQSideCastlingRangeBlank() == false || IsWhiteKingInCheck() ||
IsRangeNoneAttackBySquare( nWhiteKingSquare, nWhiteQSideRookSquare, BlackPBB ) == false ) {
currCastlingState.CastlingWQSide = CastlingState.eCastling_Temporary_Disable_State;
//UnityEngine.Debug.LogError( "ChessBitBoard::UpdateCastlingState() - CastlingWQSide disabled" );
}
else {
currCastlingState.CastlingWQSide = CastlingState.eCastling_Enable_State;
//UnityEngine.Debug.LogError( "ChessBitBoard::UpdateCastlingState() - CastlingWQSide enabled" );
}
}
// black king side check
if( currCastlingState.CastlingBKSide != CastlingState.eCastling_Disable_State )
{
// 3 case
if( IsBKSideCastlingRangeBlank() == false || IsBlackKingInCheck() ||
IsRangeNoneAttackBySquare( nBlackKingSquare, nBlackKSideRookSquare, WhitePBB ) == false ) {
currCastlingState.CastlingBKSide = CastlingState.eCastling_Temporary_Disable_State;
}
else {
currCastlingState.CastlingBKSide = CastlingState.eCastling_Enable_State;
}
}
// black queen side check
if( currCastlingState.CastlingBQSide != CastlingState.eCastling_Disable_State )
{
// 3 case
if( IsBQSideCastlingRangeBlank() == false || IsBlackKingInCheck() ||
IsRangeNoneAttackBySquare( nBlackKingSquare, nBlackQSideRookSquare, WhitePBB ) == false ) {
currCastlingState.CastlingBQSide = CastlingState.eCastling_Temporary_Disable_State;
}
else {
currCastlingState.CastlingBQSide = CastlingState.eCastling_Enable_State;
}
}
}
public void MoveUpdate( ChessMover.sMove move )
{
bool bWillEnpassantInit = true;
int nSrcPlayerSide, nSrcPieceBBIndex, nSrcSq, nTrgSq;
nSrcPlayerSide = (int)move.srcSquare.piece.playerSide;
nSrcPieceBBIndex = (int)move.srcSquare.piece.pieceType * 2 + 2 + nSrcPlayerSide;
nSrcSq = (int)move.srcSquare.position.pos;
nTrgSq = (int)move.trgSquare.position.pos;
ulong ulSrcSqBB = (ulong)1 << nSrcSq;
ulong ulTrgSqBB = (ulong)1 << nTrgSq;
// normal move
if( ChessMover.IsNormalMove( move.moveType ) ) {
// pawn move
if( ChessMover.IsPawnMove( move.moveType ) ) {
// promote move
if( ChessMover.IsPromoteMove( move.moveType ) ) {
}
// one/two move
else {
// normal one square move
if( ChessMover.IsPawnOneMove( move.moveType ) ) {
}
// two square move
else if( ChessMover.IsPawnTwoMove( move.moveType ) ) {
// en passant target square update
// if enemy pawn exist in east/west square, set enpassant target square
if( ((EastOne(ulTrgSqBB) & pieceBB[WhitePawnPBB + 1 - nSrcPlayerSide]) > 0) ||
((WestOne(ulTrgSqBB) & pieceBB[WhitePawnPBB + 1 - nSrcPlayerSide]) > 0) ) {
currEnPassantTrgSq.enpassantCapturSqBB = ulTrgSqBB;
bWillEnpassantInit = false;
}
}
}
}
// update piece bb for normal move
MoveUpdatePieceBB( nSrcPlayerSide, nSrcPieceBBIndex, ulSrcSqBB, ulTrgSqBB );
}
// capture move
else if( ChessMover.IsCaptureMove( move.moveType ) ) {
int nTrgPlayerSide, nTrgPieceBBIndex;
nTrgPlayerSide = (int)move.trgSquare.piece.playerSide;
nTrgPieceBBIndex = (int)move.trgSquare.piece.pieceType * 2 + 2 + nTrgPlayerSide;
// pawn move
if( ChessMover.IsPawnMove( move.moveType ) ) {
// promote move
if( ChessMover.IsPromoteMove( move.moveType ) ) {
}
}
// update piece bb for Capture
CaptureUpdatePieceBB( nSrcPlayerSide, nSrcPieceBBIndex, nTrgPlayerSide, nTrgPieceBBIndex, ulSrcSqBB, ulTrgSqBB );
}
// enpassantmove
else if( ChessMover.IsEnpassantMove( move.moveType ) ) {
ulong ulCaptureSqBB = 0;
int nCapturePlayerSide, nCapurePieceBBIndex;
nCapturePlayerSide = 1 - (int)move.srcSquare.piece.playerSide;
nCapurePieceBBIndex = (int)PieceType.e_Pawn * 2 + 2 + nCapturePlayerSide;
if( nSrcPlayerSide == WhitePBB )
ulCaptureSqBB = SoutOne(ulSrcSqBB);
else
ulCaptureSqBB = NortOne(ulSrcSqBB);
// update piece bb for en passant capture move
EnpassantCaptureUpdatePieceBB( nSrcPlayerSide, nSrcPieceBBIndex, nCapturePlayerSide, nCapurePieceBBIndex, ulSrcSqBB, ulTrgSqBB, ulCaptureSqBB );
}
// castling move
else if( ChessMover.IsCastlingMove( move.moveType ) ) {
// update piece bb for castling move
// king move
MoveUpdatePieceBB( nSrcPlayerSide, nSrcPieceBBIndex, ulSrcSqBB, ulTrgSqBB );
// rook move
ulong ulRookSrcSqBB = 0, ulRookTrgSqBB = 0;
int nRookSrcPieceBBIndex, nRookSrcSq, nRookTrgSq;
nRookSrcPieceBBIndex = (int)PieceType.e_Rook * 2 + 2 + nSrcPlayerSide;
if( ChessMover.IsWhiteKingSideCastlingMove( move.moveType ) ||
ChessMover.IsBlackKingSideCastlingMove( move.moveType ) ) {
nRookSrcSq = nSrcPlayerSide == WhitePBB ? 7 : 63;
ulRookSrcSqBB = (ulong)1 << nRookSrcSq;
nRookTrgSq = nRookSrcSq - 2;
ulRookTrgSqBB = (ulong)1 << nRookTrgSq;
}
else if( ChessMover.IsWhiteQueenSideCastlingMove( move.moveType ) ||
ChessMover.IsBlackQueenSideCastlingMove( move.moveType ) ) {
nRookSrcSq = nSrcPlayerSide == WhitePBB ? 0 : 56;
ulRookSrcSqBB = (ulong)1 << nRookSrcSq;
nRookTrgSq = nRookSrcSq + 3;
ulRookTrgSqBB = (ulong)1 << nRookTrgSq;
}
MoveUpdatePieceBB( nSrcPlayerSide, nRookSrcPieceBBIndex, ulRookSrcSqBB, ulRookTrgSqBB );
}
// en passant target square init
if( bWillEnpassantInit )
currEnPassantTrgSq.enpassantCapturSqBB = 0;
UpdateCastlingState( move );
}
bool IsValidAIMove( ChessBoardSquare srcSquare, ChessBoardSquare trgSquare, List<ChessMover.sMove> listMove, ChessMover.sMove aiMove )
{
foreach( ChessMover.sMove move in listMove ) {
if( move.srcSquare == srcSquare && move.trgSquare == trgSquare ) {
aiMove.Set( move );
return true;
}
}
aiMove.Clear();
return false;
}
bool IsValidMove( ChessBoardSquare srcSquare, ChessBoardSquare trgSquare, ChessMover.sMove userMove )
{
foreach( ChessMover.sMove move in listCurrMovable ) {
if( move.srcSquare == srcSquare && move.trgSquare == trgSquare ) {
userMove.Set( move );
return true;
}
}
userMove.Clear();
return false;
}
public void MoveUpdate( ChessMover.sMove move )
{
if( move.srcSquare.piece.playerSide == PlayerSide.e_White )
listWhiteMoveHistory.Add( move );
else if( move.srcSquare.piece.playerSide == PlayerSide.e_Black )
listBlackMoveHistory.Add( move );
// bit board update
bitBoard.MoveUpdate( move );
// normal move
if( ChessMover.IsNormalMove( move.moveType ) ) {
// promote move
if( ChessMover.IsPromoteMove( move.moveType ) ) {
//UnityEngine.Debug.LogError( "ChessBoard::MoveUpdate() - Normal Move(promote)" );
move.trgSquare.SetPiece( move.srcSquare.piece );
move.srcSquare.ClearPiece();
// show promte gui
//GUIManager.Instance.ShowPanelElement( "MainGameUI", "MainGamePanel", "PromotePopupMenu", true );
}
else {
//UnityEngine.Debug.LogError( "ChessBoard::MoveUpdate() - Normal Move" );
move.trgSquare.SetPiece( move.srcSquare.piece );
move.srcSquare.ClearPiece();
}
}
// capture move
else if( ChessMover.IsCaptureMove( move.moveType ) ) {
// promote move
if( ChessMover.IsPromoteMove( move.moveType ) ) {
//UnityEngine.Debug.LogError( "ChessBoard::MoveUpdate() - Capture Move(promote)" );
CaptureSquare( move.trgSquare );
move.trgSquare.SetPiece( move.srcSquare.piece );
move.srcSquare.ClearPiece();
//GUIManager.Instance.ShowPanelElement( "MainGameUI", "MainGamePanel", "PromotePopupMenu", true );
}
else {
//UnityEngine.Debug.LogError( "ChessBoard::MoveUpdate() - Capture Move" );
CaptureSquare( move.trgSquare );
move.trgSquare.SetPiece( move.srcSquare.piece );
move.srcSquare.ClearPiece();
}
}
// enpassantmove
if( ChessMover.IsEnpassantMove( move.moveType ) ) {
//UnityEngine.Debug.LogError( "ChessBoard::MoveUpdate() - en passant move" );
move.trgSquare.SetPiece( move.srcSquare.piece );
move.srcSquare.ClearPiece();
// remove captured pawn
CaptureSquare( move.capturedSquare );
}
// castling move
if( ChessMover.IsCastlingMove( move.moveType ) ) {
//UnityEngine.Debug.LogError( "ChessBoard::MoveUpdate() - castling move" );
int nDestRookRank = 0, nDestRookPile = 0;
nDestRookRank = move.trgSquare.position.nRank;
nDestRookPile = move.trgSquare.position.nPile;
// white king side castling
if( ChessMover.IsWhiteKingSideCastlingMove( move.moveType ) ) {
ChessBoardSquare rookSquare = aBoardSquare[0,7];
nDestRookRank = nDestRookRank - 1;
aBoardSquare[nDestRookPile, nDestRookRank].SetPiece( rookSquare.piece );
rookSquare.ClearPiece();
}
// white Queen side castling
if( ChessMover.IsWhiteQueenSideCastlingMove( move.moveType ) ) {
ChessBoardSquare rookSquare = aBoardSquare[0,0];
nDestRookRank = nDestRookRank + 1;
aBoardSquare[nDestRookPile, nDestRookRank].SetPiece( rookSquare.piece );
rookSquare.ClearPiece();
}
// black king side castling
if( ChessMover.IsBlackKingSideCastlingMove( move.moveType ) ) {
ChessBoardSquare rookSquare = aBoardSquare[7, 7];
nDestRookRank = nDestRookRank - 1;
aBoardSquare[nDestRookPile, nDestRookRank].SetPiece( rookSquare.piece );
rookSquare.ClearPiece();
}
// black queen side castling
if( ChessMover.IsBlackQueenSideCastlingMove( move.moveType ) ) {
ChessBoardSquare rookSquare = aBoardSquare[7, 0];
nDestRookRank = nDestRookRank + 1;
aBoardSquare[nDestRookPile, nDestRookRank].SetPiece( rookSquare.piece );
rookSquare.ClearPiece();
}
move.trgSquare.SetPiece( move.srcSquare.piece );
move.srcSquare.ClearPiece();
}
UpdateMoveCount();
// for debugging
if( bitBoard.CheckPositionSync( this ) == false ) {
UnityEngine.Debug.LogError( "ChessBoard::MoveUpdate() - Position Sync Broken!!!!!!!!" );
}
UpdateMoveFinalize();
}
