/// <summary>
/// Moves the the given piece in the bitboards. May want to consider moving all of
/// the movePiece logic into the ChessPosition.removePiece function. This routine
/// basically mimics the ChessBitboard.removePiece and ChessBitboard.addPiece so maybe
/// simply call those routines to to simplify the logic. Currenty only being done
/// for a small optimization gain.
/// </summary>
/// <param name="piece">Piece we are deleting, note that the ChessPostion
/// class ignores the color of the piece as basically it is color blind.</param>
/// <param name="square"></param>
/// <param name="Pieces">Current bitboards to update.</param>
public void movePiece(Chess.Pieces piece, BitboardSquare from, BitboardSquare to)
{
// Move the piece.
removePiece(piece, from.getSquareMask());
addPiece(piece, to.getSquareMask());
// Remove any prevoious Enpasant.
Enpasant = 0x00;
// See if this move puts a pawn in danger of Enpasant
if (piece == Chess.Pieces.BPAWN || piece == Chess.Pieces.WPAWN)
{
if (isPotentialEnpasant(from.getSquareMask(), to.getSquareMask()))
{
// Set square of pawn susceptible to enpasant attack.
Enpasant = to.getSquareMask();
}
}
Board = (Board & (~from.getSquareMask())) | to.getSquareMask();
// Update attacker rotated boards:
Bitboard maskFrom = from.getA8H1Mask(); // getBitSquare(coFrom.A8H1Square);
Bitboard maskTo = to.getA8H1Mask(); //getBitSquare(coTo.A8H1Square);
RotatedA8H1 = (RotatedA8H1 & (~maskFrom)) | maskTo;
maskFrom = from.getA1H8Mask(); //getBitSquare(coFrom.A1H8Square);
maskTo = to.getA1H8Mask(); //getBitSquare(coTo.A1H8Square);
RotatedA1H8 = (RotatedA1H8 & (~maskFrom)) | maskTo;
maskFrom = from.getR90Mask(); //getBitSquare(coFrom.R90Square);
maskTo = to.getR90Mask(); //getBitSquare(coTo.R90Square);
RotatedR90 = (RotatedR90 & (~maskFrom)) | maskTo;
}
/// <summary>
/// This routine will grab ahold of a piece and allow us to move it around
/// the chess board.
/// </summary>
/// <param name="mouse"></param>
public void pickupPiece(MouseEventArgs mouse)
{
if (!isDragging)
{
coSourceSquare = coChessBitmap.findSquare(mouse.X, mouse.Y);
// Found a source square.
if (coSourceSquare != null)
{
// Do we have a hold of one of the little dudes?
if (coSourceSquare.Piece != Chess.Pieces.NONE)
{
// Let everyone know that we are dragging the little dude around.
isDragging = true;
coMovingSquare = coSourceSquare.Square;
coPoint = new Point(coMovingSquare.X + coMovingSquare.Width / 2, coMovingSquare.Y + coMovingSquare.Height / 2);
coPiece = coSourceSquare.Piece;
coSourceSquare.Piece = Chess.Pieces.NONE;
Graphics offScreenDC = Graphics.FromImage(coChessBitmap.coBmpBoard);
offScreenDC.DrawImage(coSourceSquare.Background, coSourceSquare.Square);
Cursor.Current = (Cursor)coChessCursors[Chess.Pieces.CLOSEDHAND];
// If we don't do this then resources do not get released. Memory leaks...
offScreenDC.Dispose();
}
}
}
}
public void placePiece(string notation, Chess.Pieces piece)
{
BoardSquare sq = (BoardSquare)coChessBoard[notation];
sq.PieceImage = (Bitmap)imagePieces.Images[((int)piece - 1)];
sq.Piece = piece;
}
/// <summary>
/// Removes the requested piece from the bitboards.
/// </summary>
/// <param name="piece"></param>
/// <param name="mask"></param>
public void removePiece(Chess.Pieces piece, Bitboard mask)
{
switch (piece)
{
case Chess.Pieces.WKING:
case Chess.Pieces.BKING:
this.King &= ~mask;
break;
case Chess.Pieces.WQUEEN:
case Chess.Pieces.BQUEEN:
this.Queens &= ~mask;
break;
case Chess.Pieces.WROOK:
case Chess.Pieces.BROOK:
this.Rooks &= ~mask;
break;
case Chess.Pieces.WBISHOP:
case Chess.Pieces.BBISHOP:
this.Bishops &= ~mask;
break;
case Chess.Pieces.WKNIGHT:
case Chess.Pieces.BKNIGHT:
this.Knights &= ~mask;
break;
case Chess.Pieces.WPAWN:
case Chess.Pieces.BPAWN:
this.Pawns &= ~mask;
break;
}
}
public void placePiece(Chess.Pieces piece, int square)
{
int col = square % 8;
int row = square / 8;
string notation = mapcol[col].ToString() + maprow[row].ToString();
placePiece(notation, piece);
}
/// <summary>
/// Adds the given piece to the bitboards. May want to consider moving all of
/// the addPiece logic into the ChessPosition.removePiece function.
/// </summary>
/// <param name="piece">Piece we are deleting, note that the ChessPostion
/// class ignores the color of the piece as basically it is color blind.</param>
/// <param name="Pieces">Current bitboards to update.</param>
public void addPiece(Chess.Pieces piece, BitboardSquare to)
{
// Add the piece to the piece board.
addPiece(piece, to.getSquareMask());
// Update main board.
Board = Board | to.getSquareMask();
// Update rotated boards:
Bitboard maskTo = to.getA8H1Mask(); // getBitSquare(coTo.A8H1Square);
RotatedA8H1 = RotatedA8H1 | maskTo;
maskTo = to.getA1H8Mask(); // getBitSquare(coTo.A1H8Square);
RotatedA1H8 = RotatedA1H8 | maskTo;
maskTo = to.getR90Mask(); // getBitSquare(coTo.R90Square);
RotatedR90 = RotatedR90 | maskTo;
}
/// <summary>
/// Removes the given piece from the bitboards. May want to consider moving all of
/// the removePiece logic into the ChessPosition.removePiece function.
/// </summary>
/// <param name="piece">Piece we are deleting, note that the ChessPostion
/// class ignores the color of the piece as basically it is color blind.</param>
/// <param name="square"></param>
/// <param name="Pieces"></param>
public void removePiece(Chess.Pieces piece, BitboardSquare square)
{
// Get the squares.
// BitboardSquare bbSquare = new BitboardSquare(square);
Bitboard mask = square.getSquareMask(); // getBitSquare(bbSquare.Square);
removePiece(piece, mask);
Board = Board & ~mask;
// Update rotated boards:
mask = square.getA8H1Mask(); // getBitSquare(bbSquare.A8H1Square);
RotatedA8H1 = RotatedA8H1 & ~mask;
mask = square.getA1H8Mask(); // getBitSquare(bbSquare.A1H8Square);
RotatedA1H8 = RotatedA1H8 & ~mask;
mask = square.getR90Mask(); // getBitSquare(bbSquare.R90Square);
RotatedR90 = RotatedR90 & ~mask;
}
public static char pieceToNotation(Chess.Pieces piece)
{
char aPiece = ' ';
switch (piece)
{
case Chess.Pieces.WKING:
case Chess.Pieces.BKING:
aPiece = 'K';
break;
case Chess.Pieces.WQUEEN:
case Chess.Pieces.BQUEEN:
aPiece = 'Q';
break;
case Chess.Pieces.WROOK:
case Chess.Pieces.BROOK:
aPiece = 'R';
break;
case Chess.Pieces.WBISHOP:
case Chess.Pieces.BBISHOP:
aPiece = 'B';
break;
case Chess.Pieces.WKNIGHT:
case Chess.Pieces.BKNIGHT:
aPiece = 'N';
break;
case Chess.Pieces.WPAWN:
case Chess.Pieces.BPAWN:
aPiece = 'P';
break;
}
return(aPiece);
}
/// <summary>
/// Removes the requested piece bitboard. Note you may have multiple bits set for all but
/// the kings bitboard.
/// </summary>
/// <param name="piece"></param>
/// <returns></returns>
public Bitboard getPiece(Chess.Pieces piece)
{
Bitboard mask = 0;
switch (piece)
{
case Chess.Pieces.WKING:
case Chess.Pieces.BKING:
mask = this.King;
break;
case Chess.Pieces.WQUEEN:
case Chess.Pieces.BQUEEN:
mask = this.Queens;
break;
case Chess.Pieces.WROOK:
case Chess.Pieces.BROOK:
mask = this.Rooks;
break;
case Chess.Pieces.WBISHOP:
case Chess.Pieces.BBISHOP:
mask = this.Bishops;
break;
case Chess.Pieces.WKNIGHT:
case Chess.Pieces.BKNIGHT:
mask = this.Knights;
break;
case Chess.Pieces.WPAWN:
case Chess.Pieces.BPAWN:
mask = this.Pawns;
break;
}
return(mask);
}
/// <summary>
/// Used to signal that we are ready to drop a chess piece on it's respective
/// target square.
/// </summary>
/// <param name="mouse"></param>
public void dropPiece(MouseEventArgs mouse)
{
// Only if we were moving a piece.
if (isDragging)
{
// Clear out coordinates used during the drag.
coMovingSquare.X = 0;
coMovingSquare.Y = 0;
coMovingSquare.Width = 0;
coMovingSquare.Height = 0;
coPoint.X = 0;
coPoint.Y = 0;
// Reset our source square to the original piece.
coSourceSquare.Piece = coPiece;
// Clear our temporary variable.
coPiece = Chess.Pieces.NONE;
// Locate where we want to drop the piece.
coTargetSquare = coChessBitmap.findSquare(mouse.X, mouse.Y);
Graphics offScreenDC = Graphics.FromImage(coChessBitmap.coBmpBoard);
// Found a target square
if (coTargetSquare != null)
{
// Make sure we had a chess piece in hand.
if (coSourceSquare.PieceImage != null)
{
// Used to see if hosting window says we can move the piece.
bool okMove = true;
if (EventPieceMoved != null)
{
okMove = EventPieceMoved(coSourceSquare.Piece, coSourceSquare.Name, coTargetSquare.Name);
}
if (okMove)
{
bool bValidMove = true;
// Make sure we are not moving to the same square the piece originally occupied.
// Then validate the move with the bitboard class.
if (coTargetSquare != coSourceSquare)
{
if (coValidateMoves)
{
bValidMove = coBitBoard.move(coSourceSquare.Piece, coSourceSquare.Name, coTargetSquare.Name);
}
if (bValidMove)
{
if (!promotion)
{
// Everything ok so now move the piece into the new square.
coTargetSquare.PieceImage = coSourceSquare.PieceImage;
coTargetSquare.Piece = coSourceSquare.Piece;
}
else
{
promotion = false;
}
// Clear chess image and piece.
coSourceSquare.PieceImage = null;
coSourceSquare.Piece = Chess.Pieces.NONE;
// Just draw the new background and image.
offScreenDC.DrawImage(coTargetSquare.Background, coTargetSquare.Square);
offScreenDC.DrawImage(coTargetSquare.PieceImage, coTargetSquare.Square);
}
else
{
// Redraw the original pieces.
offScreenDC.DrawImage(coSourceSquare.Background, coSourceSquare.Square);
offScreenDC.DrawImage(coSourceSquare.PieceImage, coSourceSquare.Square);
}
}
else
{
// Redraw the original pieces.
offScreenDC.DrawImage(coSourceSquare.Background, coSourceSquare.Square);
offScreenDC.DrawImage(coSourceSquare.PieceImage, coSourceSquare.Square);
}
}
}
}
else //Dragging a piece off board
{
// Redraw the original pieces.
offScreenDC.DrawImage(coSourceSquare.Background, coSourceSquare.Square);
offScreenDC.DrawImage(coSourceSquare.PieceImage, coSourceSquare.Square);
}
offScreenDC.Dispose();
Invalidate();
isDragging = false;
Cursor.Current = (Cursor)coChessCursors[Chess.Pieces.OPENHAND];
}
}
/// <summary>
///
/// </summary>
/// <param name="piece"></param>
/// <returns></returns>
public Cursor getCursor(Chess.Pieces piece)
{
return((Cursor)coChessCursors[piece]);
}
