/// <summary>
/// Purpose: To perform the minimax algorithm to determine chess move
/// </summary>
/// <param name="boardState"></param>
/// <param name="color"></param>
/// <returns>char[] board to represent the move</returns>
///
public static char[] miniMax(char[] SRFen, ChessColor color)
{
TimeSpan maxTime = TimeSpan.FromMilliseconds(5500);
Char[] initialBoard = (char[])SRFen.Clone();
bool white;
int alpha = -10000;
int beta = 10000;
int cutoff = 4;
if (color == ChessColor.White) white = true;
else white = false;
int depth = 0;
Stopwatch timer = new Stopwatch();
timer.Start();
int h;
h = minValue(ref SRFen, depth + 1, white, alpha, beta, cutoff, ref timer);
if (h == -5000)
return SRFen;
char[] bestSoFar = (char[])SRFen.Clone();
while (timer.Elapsed < maxTime && h != -9999)
{
cutoff += 2;
char[] temp = (char[])initialBoard.Clone();
h = minValue(ref temp, depth + 1, white, alpha, beta, cutoff, bestSoFar, ref timer);
if (h != -9999) bestSoFar = (char[])temp.Clone();
if (h == -5000)
return bestSoFar;
}
//this.Log("cutoff" + cutoff);
return bestSoFar;
}
public ChessSquare(int y, int x, ChessColor color)
{
Loc = new Location();
Loc.Y = y;
Loc.X = x;
Color = color;
}
/// <summary>
/// Takes a board and color, and returns a simplified state where friend pieces are represented
/// by positive integers and always start on the same side of the board (0,0). Foe pieces are
/// represented as negative values
/// </summary>
/// <param name="board">The board to convert</param>
/// <param name="color">The color of the player (friend)</param>
/// <returns>A simplified representation of the current board</returns>
public static int[,] GetSimpleState(ChessBoard board, ChessColor color)
{
int[,] state = new int[Columns, Rows];
for (int col = 0; col < Columns; col++)
{
for (int row = 0; row < Rows; row++)
{
int stateRow = row;
int stateCol = col;
if (color == ChessColor.White)
{
stateRow = Rows - row - 1;
stateCol = Columns - col - 1;
}
ChessPiece piece = board[col, row];
int multiplier = 1;
if (color == ChessColor.White && piece < ChessPiece.Empty
|| color == ChessColor.Black && piece > ChessPiece.Empty)
multiplier = -1;
state[stateCol, stateRow] = multiplier * GamePieceToStatePiece[piece];
}
}
return state;
}
/// <summary>
/// The constructor.
/// </summary>
/// <param name="board">The board in which the square is located.</param>
/// <param name="location">The location of the square.</param>
/// <param name="color">The color of the square.</param>
/// <param name="piece">The Chess piece that is on the square.</param>
public Square(ChessBoard board, Location location, ChessColor color, ChessPiece piece = null)
{
this.Board = board;
this.Location = location;
this.Color = color;
this.Piece = piece;
}
public Player(string name, ChessColor color)
{
// TODO: Validate name lenght
this.Name = name;
this.Color = color;
this.figures = new List<IFigure>();
}
/// <summary>
/// Purpose: To calculate a heuristic value for the given board state
/// </summary>
/// <param name="boardState"></param>
/// <param name="color"></param>
/// <returns>integer representing the heuristic</returns>
public static int GetHeuristicValue(byte[] boardState, ChessColor color)
{
bool white = color == ChessColor.White;
int pH = GetPieceValueHeuristic(boardState, color);
int pS = FEN.GetPieceHazard(boardState, white);
return pH + pS;
}
public static Piece GetType(string s, ChessColor color)
{
Piece p;
switch (s)
{
case "Bishop":
p = new Bishop(color);
break;
case "King":
p = new King(color);
break;
case "Knight":
p = new Knight(color);
break;
case "Pawn":
p = new Pawn(color);
break;
case "Queen":
p = new Queen(color);
break;
case "Rook":
p = new Rook(color);
break;
default:
throw new Exception("Piece unknown : " + s);
}
return p;
}
/// <summary>
/// Purpose: To calculate a heuristic based purely off piece value
/// </summary>
/// <param name="boardState"></param>
/// <param name="color"></param>
/// <returns></returns>
private static int GetPieceValueHeuristic(byte[] boardState, ChessColor color)
{
int whiteValue = 0;
int blackValue = 0;
for (int i = 0; i < boardState.Length; i++)
{
if (boardState[i] != FEN._)
{
if (boardState[i].IsUpper())
whiteValue += (pieceValues[boardState[i]] + GetPiecePositionValue(boardState[i], i));
else
blackValue += (pieceValues[boardState[i]] + GetPiecePositionValue(boardState[i], i));
}
}
//Log("WV -" + whiteValue.ToString());
//Log("BV -" + blackValue.ToString());
if (color == ChessColor.White)
{
if (whiteValue - 20000 < 1500)
{
lateGame = true;
}
return whiteValue - blackValue;
}
else
{
if (blackValue - 20000 < 1500)
{
lateGame = true;
}
return blackValue - whiteValue;
}
}
public void GenerateMoves(ChessBoard board, ChessColor color)
{
Moves = new List<ChessMove>();
for (int y = 0; y < ChessBoard.NumberOfRows; y++)
{
for (int x = 0; x < ChessBoard.NumberOfColumns; x++)
{
if (color == ChessColor.White) // if player is white
{
if (board[x, y] > ChessPiece.Empty)
{
switch (board[x, y])
{
case ChessPiece.WhiteBishop:
BishopMoves(board, x, y, color);
break;
case ChessPiece.WhiteQueen:
QueenMoves(board, x, y, color);
break;
case ChessPiece.WhiteKing:
break;
case ChessPiece.WhiteKnight:
KnightMoves(board, x, y, color);
break;
case ChessPiece.WhitePawn:
PawnMoves(board, x, y, color);
break;
case ChessPiece.WhiteRook:
RookMoves(board, x, y, color);
break;
}
}
}
else if ( color == ChessColor.Black)
{
switch (board[x, y])
{
case ChessPiece.BlackBishop:
BishopMoves(board, x, y, color);
break;
case ChessPiece.BlackQueen:
QueenMoves(board, x, y, color);
break;
case ChessPiece.BlackKing:
break;
case ChessPiece.BlackKnight:
KnightMoves(board, x, y, color);
break;
case ChessPiece.BlackPawn:
PawnMoves(board, x, y, color);
break;
case ChessPiece.BlackRook:
RookMoves(board, x, y, color);
break;
}
}
}
}
}
public Piece( ChessColor color )
{
Rules = new Collection<Rule>();
Color = color;
InitializeRules();
}
/// <summary>
/// this will define BoardAfterMove, TheMove, and HValue based on move
/// </summary>
/// <param name="board"></param>
/// <param name="move"></param>
/// <param name="colorofEnemy"></param>
public Hueristic(ChessBoard board, ChessMove move, ChessColor colorofEnemy)
{
BoardBeforeMove = board.Clone();
BoardAfterMove = board.Clone();
BoardAfterMove.MakeMove(move);
TheMove = move;
//HValue = CalculateHueristicBasic(board, colorofEnemy);
HValue = CalculateHueristicAdvanced(colorofEnemy);
}
private bool CheckOtherFigureIfValid(IBoard board, Position to, ChessColor color)
{
var otherFigure = board.GetFigureAtPosition(to);
if (otherFigure != null && otherFigure.Color == color)
{
return false;
}
return true;
}
internal Piece(Piece piece)
{
PieceColor = piece.PieceColor;
PieceType = piece.PieceType;
Moved = piece.Moved;
PieceValue = piece.PieceValue;
PieceActionValue = piece.PieceActionValue;
if (piece.ValidMoves != null)
LastValidMoveCount = piece.ValidMoves.Count;
}
/// <summary>
/// Purpose: Lower the Heuristic value if our queen is put in danger
/// </summary>
/// <param name="boardState"></param>
/// <param name="color"></param>
/// <returns></returns>
private static int PieceSafety(char[] boardState, ChessColor color)
{
int hazardPenalty = 0;
bool white = color == ChessColor.White;
hazardPenalty += FENExtensions.PieceNotSafe(boardState, FENExtensions.GetPiecePos(boardState, white, 'q'), white) ? -400 : 0;
hazardPenalty += FENExtensions.PieceNotSafe(boardState, FENExtensions.GetPiecePos(boardState, white, 'r'), white) ? -200 : 0;
hazardPenalty += FENExtensions.PieceNotSafe(boardState, FENExtensions.GetPiecePos(boardState, white, 'n'), white) ? -150 : 0;
hazardPenalty += FENExtensions.PieceNotSafe(boardState, FENExtensions.GetPiecePos(boardState, white, 'b'), white) ? -155 : 0;
hazardPenalty += FENExtensions.PieceNotSafe(boardState, FENExtensions.GetPiecePos(boardState, white, 'p'), white) ? -40 : 0;
return hazardPenalty;
}
public Node(ChessColor c, ChessMove m, Node p)
{
color = c;
move = m;
parent = p;
if (parent == null)
{
depth = 0;
}
else
{
depth = parent.depth + 1;
}
}
public GameGump( Mobile m, ChessGame game, ChessColor color, string message, bool move, bool moving ): base( 60, 25 )
{
m.CloseGump( typeof( GameGump ) );
m_Game = game;
m_Message = message;
m_Color = color;
m_Move = move;
m_Moving = moving;
if ( move && ! moving )
m_Game.SendMoveTarget( m );
MakeGump();
}
/// <summary>
/// Purpose: Lower the Heuristic value if our queen is put in danger
/// </summary>
/// <param name="boardState"></param>
/// <param name="color"></param>
/// <returns></returns>
private static int PieceSafety(byte[] boardState, ChessColor color)
{
int hazardPenalty = 0;
bool white = color == ChessColor.White;
hazardPenalty = FEN.GetPieceHazard (boardState, white);
/*
hazardPenalty += FEN.PieceNotSafe(boardState, FEN.GetPiecePos(boardState, white, FEN.q), white) ? -400 : 0;
//hazardPenalty += FEN.PieceNotSafe(boardState, FEN.GetPiecePos(boardState, white, FEN.r), white) ? -200 : 0;
//hazardPenalty += FEN.PieceNotSafe(boardState, FEN.GetPiecePos(boardState, white, FEN.n), white) ? -150 : 0;
//hazardPenalty += FEN.PieceNotSafe(boardState, FEN.GetPiecePos(boardState, white, FEN.b), white) ? -155 : 0;
//hazardPenalty += FEN.PieceNotSafe(boardState, FEN.GetPiecePos(boardState, white, FEN.p), white) ? -40 : 0;*/
return hazardPenalty;
}
/// <summary>
/// High Number = better board for your color
/// </summary>
/// <param name="board"></param>
/// <param name="colorOfEnemyTeam"></param>
/// <returns></returns>
int CalculateBoardHP(ChessBoard board, ChessColor colorOfMyTeam)
{
int score = 0;
for (int x = 0; x < 8; x++)
{
for (int y = 0; y < 8; y++)
{
if (colorOfMyTeam == ChessColor.Black && BoardAfterMove[x, y] < ChessPiece.Empty) //if black
score += StudentAI.Piece.CalculatePieceValue(BoardAfterMove[x, y]);
else if (colorOfMyTeam == ChessColor.White && BoardAfterMove[x, y] > ChessPiece.Empty) //if white
score += StudentAI.Piece.CalculatePieceValue(BoardAfterMove[x, y]);
}
}
return score;
}
/// <summary>
/// AIProfiler keeps the profiling stats for the AI. This object is what's passed
/// to each AI when they call the Profiler property from IChessAI
/// </summary>
/// <param name="myColor">This is the color of the AI being profiled. It's mostly used when outputing the results</param>
internal AIProfiler(ChessColor myColor)
{
NodesPerSecond = -1;
MinisProfilerTag = -1;
MaxsProfilerTag = -1;
AIName = string.Empty;
AIColor = myColor;
Depth = 0;
_numFrameworkMethods = Enum.GetValues(typeof(ProfilerMethodKey)).Length;
IsEnabled = false;
MoveDepths = new List<int>();
MoveTimes = new List<TimeSpan>();
Turns = new List<int[]>();
FxTurns = new List<int[]>();
}
/// <summary>
/// Converts a state based move to a ChessBoard move
/// </summary>
/// <param name="stateMove">The move the convert</param>
/// <param name="playerColor">The color of hte player</param>
/// <returns>The move corrected to work with ChessBoard</returns>
public static ChessMove GetGameMove(ChessMove stateMove, ChessColor playerColor)
{
if (stateMove == null)
return null;
ChessMove gameMove = stateMove.Clone();
if (playerColor == ChessColor.White)
{
gameMove.From.X = Columns - gameMove.From.X - 1;
gameMove.From.Y = Rows - gameMove.From.Y - 1;
gameMove.To.X = Columns - gameMove.To.X - 1;
gameMove.To.Y = Rows - gameMove.To.Y - 1;
}
return gameMove;
}
/// <summary>
/// gets a list of available moves for a color
/// </summary>
public static List<ChessMove> getmovesofcolor(StudentAI ai, ChessColor color, ChessBoard board)
{
List<ChessMove> colormoves = new List<ChessMove>();
for (int y = 0; y < 8; y++)
{
for (int x = 0; x < 8; x++)
{
if (color == ChessColor.Black)
{
switch (board[x, y])
{
case ChessPiece.BlackPawn:
case ChessPiece.BlackKnight:
case ChessPiece.BlackBishop:
case ChessPiece.BlackQueen:
case ChessPiece.BlackRook:
case ChessPiece.BlackKing:
colormoves.AddRange(getmovesofpiece(ai, color, board, new ChessLocation(x, y)));
break;
default:
break;
}
}
if (color == ChessColor.White)
{
switch (board[x, y])
{
case ChessPiece.WhitePawn:
case ChessPiece.WhiteKnight:
case ChessPiece.WhiteBishop:
case ChessPiece.WhiteQueen:
case ChessPiece.WhiteRook:
case ChessPiece.WhiteKing:
colormoves.AddRange(getmovesofpiece(ai, color, board, new ChessLocation(x, y)));
break;
default:
break;
}
}
}
}
return colormoves;
}
//checks if the move is still located on the board & is moved onto empty or kill spot
private static bool OnBoardAndKillOrEmpty(int X, int Y,ChessBoard board,ChessColor color)
{
if (X > 8 || X < 0 || Y > 8 || Y < 0)
return false;
if(board[X,Y] == ChessPiece.Empty)
{
if(color==ChessColor.White)
{
switch (board[X,Y])
{
case ChessPiece.BlackPawn:
case ChessPiece.BlackKnight:
case ChessPiece.BlackBishop:
case ChessPiece.BlackQueen:
case ChessPiece.BlackRook:
case ChessPiece.BlackKing:
return true;
default:
return false;
}
}
else if(color==ChessColor.Black)
{
switch (board[X, Y])
{
case ChessPiece.WhiteBishop:
case ChessPiece.WhiteKing:
case ChessPiece.WhiteKnight:
case ChessPiece.WhitePawn:
case ChessPiece.WhiteQueen:
case ChessPiece.WhiteRook:
return true;
default:
return false;
}
}
}
return true;
}
public Position GetKingPosition(ChessColor color)
{
var currentRow = 0;
var currentCol = (char)('a');
for (int row = 0; row < this.TotalCols; row++)
{
for (int col = 0; col < this.TotalRows; col++)
{
currentRow = row;
currentCol = (char)('a' + col);
var position = new Position(currentRow, currentCol);
var figureAtPosition = this.GetFigureAtPosition(position);
if (figureAtPosition is Figures.King && figureAtPosition.Color == color)
{
return new Position(currentRow, currentCol);
}
}
}
return new Position(currentRow, currentCol);
}
public static byte[] miniMax(byte[] SRFen, ChessColor color)
{
TimeSpan maxTime = TimeSpan.FromMilliseconds(5500);
byte[] initialBoard = (byte[])SRFen.Clone();
bool white= color == ChessColor.White? true:false;
int alpha = -10000;
int beta = 10000;
int cutoff = 4;
int depth = 0;
Stopwatch timer = new Stopwatch();
timer.Start();
int h;
//test is we are going back and forth
bool repeat= testRepeat(latestMove);
if (repeat)
h = minValue(ref SRFen, depth + 1, white, alpha, beta, cutoff, ref timer, latestMove[1]);
else
h = minValue(ref SRFen, depth + 1, white, alpha, beta, cutoff, ref timer, null);
if (h == -5000)
return SRFen;
byte[] bestSoFar = (byte[])SRFen.Clone();
while (timer.Elapsed < maxTime && h != -9999)
{
cutoff += 2;
byte[] temp = (byte[])initialBoard.Clone();
if (repeat)
h = minValue(ref temp, depth + 1, white, alpha, beta, cutoff, bestSoFar, ref timer, latestMove[1]);
else
h = minValue(ref temp, depth + 1, white, alpha, beta, cutoff, bestSoFar, ref timer, null);
if (temp!=null) bestSoFar = (byte[])temp.Clone();
if (h == -5000)
return bestSoFar;
}
// Log("cutoff" + cutoff);
//add bestSoFar to latest move
addLatestMove(ref latestMove, bestSoFar);
return bestSoFar;
}
/// <summary>
/// The lower the number returned the better off you are
/// </summary>
/// <param name="board"></param>
/// <param name="colorOfEnemyTeam"></param>
/// <returns></returns>
int CalculateHueristicAdvanced(ChessColor colorOfEnemyTeam)
{
int scoreB = 0;
int scoreW = 0;
for (int x = 0; x < 8; x++)
{
for (int y = 0; y < 8; y++)
{
if (BoardAfterMove[x, y] < ChessPiece.Empty) //if black
scoreB += StudentAI.Piece.CalculatePieceValue(BoardAfterMove[x, y]);
else if (BoardAfterMove[x, y] > ChessPiece.Empty) //if white
scoreW += StudentAI.Piece.CalculatePieceValue(BoardAfterMove[x, y]);
}
}
if(TheMove.From==null)
return colorOfEnemyTeam == ChessColor.Black ? scoreB - scoreW : scoreW - scoreB;
return colorOfEnemyTeam == ChessColor.Black ? scoreB - scoreW + StudentAI.Piece.CalculatePieceActionValue(BoardBeforeMove[TheMove.From.X, TheMove.From.Y])
: scoreW - scoreB + StudentAI.Piece.CalculatePieceActionValue(BoardBeforeMove[TheMove.From.X, TheMove.From.Y]);
//return score - StudentAI.Piece.CalculatePieceActionValue(board[TheMove.From.X, TheMove.From.Y]);
}
public Knight(ChessColor color) : base(color)
{
}
private MovementResult MovePiece(char column, int row, char targetColumn, int targetRow, bool forTest)
{
MovementResult result = new MovementResult();
var selectPiece = GetPiece(column, row);
// check if there is a piece at start position
if (selectPiece == null)
{
result.IsSuccess = false;
result.Description = String.Format("No piece is present at position {0}{1}", column, row.ToString());
return(result);
}
Piece targetPiece = null;
var isEnPassant = EnPassant != null && selectPiece is Pawn && targetColumn == EnPassant.Item1 && targetRow == EnPassant.Item2;
if (!isEnPassant)
{
targetPiece = GetPiece(targetColumn, targetRow);
}
else
{
targetPiece = GetPiece(targetColumn, row);
}
// check it is a valid movement for piece (rules piece validator)
if (!selectPiece.IsValidMovement(
(targetPiece != null && !selectPiece.ChessColor.Equals(targetPiece.ChessColor)),
row - 1, Columns[column], targetRow - 1, Columns[targetColumn]))
{
result.IsSuccess = false;
result.Description =
String.Format("The {0} {1} at position {2}{3} cannot move to {4}{5}",
selectPiece.ChessColor.ToString(), selectPiece.GetType().Name,
column, row.ToString(), targetColumn, targetRow.ToString());
return(result);
}
// check if the path is free if piece is not a knight
if (!(selectPiece is Knight) && !checkIfPathIsFree(column, row, targetColumn, targetRow))
{
result.IsSuccess = false;
result.Description =
String.Format("The path from {0}{1} to {2}{3} for {4}{5} is not free.",
column, row.ToString(), targetColumn, targetRow.ToString(),
selectPiece.ChessColor.ToString(), selectPiece.GetType().Name);
return(result);
}
// check if target position there is already present a piece with same color
if (targetPiece != null && selectPiece.ChessColor.Equals(targetPiece.ChessColor))
{
result.IsSuccess = false;
result.Description =
String.Format("There is already present a {0} piece at position {1}{2}",
selectPiece.ChessColor.ToString(), targetColumn, targetRow);
return(result);
}
//En passant done
if (isEnPassant && !forTest)
{
clearBoardPosition(targetColumn, row);
}
// set result information after ate
result.Ate = (targetPiece != null && !selectPiece.ChessColor.Equals(targetPiece.ChessColor));
if (result.Ate)
{
result.AtePiece = targetPiece;
}
// set EnPassant Information
EnPassant = null;
if ((selectPiece is Pawn) && (Math.Abs(row - targetRow) == 2))
{
//En passant possibilities
var pieceLeft = TryGetPiece(Columns[targetColumn], targetRow);
var pieceRigth = TryGetPiece(Columns[targetColumn] + 2, targetRow);
if ((pieceLeft != null && pieceLeft.ChessColor != selectPiece.ChessColor && pieceLeft is Pawn)
||
(pieceRigth != null && pieceRigth.ChessColor != selectPiece.ChessColor && pieceRigth is Pawn))
{
EnPassant = new Tuple <char, int>(targetColumn, (targetRow + row) / 2);
}
}
//Castling rules
bool isCastling = false;
if ((selectPiece is King) && Math.Abs(Columns[column] - Columns[targetColumn]) == 2)
{
//1-The king should not have moved yet
var king = (King)selectPiece;
if (king.HasAlreadyMoved || !(column == 'E' && (row == 1 || row == 8)))
{
result.IsSuccess = false;
result.Description =
String.Format("You cannot do the Castling because your king has already moved.");
return(result);
}
//2-The Rook should not have moved yet either
var rookColumn = (targetColumn == 'G') ? 'H' : 'A';
var pieceFound = GetPiece(rookColumn, targetRow);
if (pieceFound == null || pieceFound.ChessColor != king.ChessColor || !(pieceFound is Rook))
{
result.IsSuccess = false;
result.Description =
String.Format("You cannot do the Castling because there is no Rook at position {0}{1}.", rookColumn, targetRow);
return(result);
}
var goodRook = (Rook)pieceFound;
if (goodRook.HasAlreadyMoved)
{
result.IsSuccess = false;
result.Description =
String.Format("You cannot do the Castling as your rook has already moved at position {0}{1}.", rookColumn, targetRow);
return(result);
}
//3-The King should not be chess or passing on a echec position
var canMoveOnTheKing = CheckKingEchec(king.ChessColor);
if (canMoveOnTheKing != null)
{
result.IsSuccess = false;
result.Description =
String.Format("You cannot do the Castling because you are echec {0}{1}.", canMoveOnTheKing.Item1, canMoveOnTheKing.Item2);
return(result);
}
//4-Can do one step :
var oneStepColumn = (targetColumn == 'G') ? 'F' : 'D';
var canDoOne = this.MovePiece(column, row, oneStepColumn, targetRow);
if (!canDoOne.IsSuccess)
{
result.IsSuccess = false;
result.Description =
String.Format("You cannot do the Castling because you would be echec at the position {0}{1}.", oneStepColumn, targetRow);
return(result);
}
else
{
//One step is posible, so rollback, and test two step :
PutPiece(king, column, row);
clearBoardPosition(oneStepColumn, row);
king.HasAlreadyMoved = false;
isCastling = true;
}
}
// change position of piece
if (!forTest)
{
PutPiece(selectPiece, targetColumn, targetRow);
clearBoardPosition(column, row);
//Pawn reach the opposite side, can be promoted
if (selectPiece is Pawn && (targetRow == 1 || targetRow == 8))
{
PawnPromoted = true;
PawnPromotedColor = selectPiece.ChessColor;
}
// check if the move does not make our king in chess
Tuple <char, int> pieceWitchMakeChess = CheckKingEchec(selectPiece.ChessColor);
if (pieceWitchMakeChess != null)
{
//RollBack
PutPiece(selectPiece, column, row);
clearBoardPosition(targetColumn, targetRow);
PawnPromoted = false;
if (result.Ate == true)
{
var pieceEaten = result.AtePiece;
this.PutPiece(pieceEaten, targetColumn, targetRow);
result.AtePiece = null;
result.Ate = false;
}
result.IsSuccess = false;
result.Description =
String.Format("Your king is in echec from the piece {0} ({1}{2}).",
selectPiece.GetType().Name, pieceWitchMakeChess.Item1, pieceWitchMakeChess.Item2);
return(result);
}
if (selectPiece is IHasAlreadyMoved)
{
((IHasAlreadyMoved)selectPiece).HasAlreadyMoved = true;
//TODO : Move the rook in case of castling
if (isCastling)
{
var rookColumnOrigin = (targetColumn == 'G') ? 'H' : 'A';
var rookColumnTarget = (targetColumn == 'G') ? 'F' : 'D';
var pieceFound = GetPiece(rookColumnOrigin, row);
PutPiece(pieceFound, rookColumnTarget, row);
clearBoardPosition(rookColumnOrigin, row);
}
}
}
return(result);
}
/// <summary>
/// The constructor.
/// </summary>
/// <param name="board">The board where the Chess piece is located.</param>
/// <param name="color">The color of the Chess piece.</param>
/// <param name="square">The square where the Chess piece is located.</param>
public Bishop(ChessBoard board, ChessColor color, Square square = null)
: base(board, color, square)
{
this.Movement = new RowMovement(this, MovementDirection.Diagonal);
}
/// <summary>
/// Draw chessboard on screen
/// </summary>
/// <param name="date">What date is it?</param>
/// <param name="CC">What is the colour going to be displayed</param>
public void Draw(string date, ChessColor CC)
{
Draw(false, true, CC);
}
/// <summary>
/// Draw chessboard on screen
/// </summary>
/// <param name="scrollx">X direction to scroll</param>
/// <param name="scrolly">Y direction to scroll</param>
/// <param name="CC">What is the colour going to be displayed?</param>
public void Draw(bool scrollx, bool scrolly, ChessColor CC)
{
if (scrolly) this.m_scrollY += 0.005;
if (scrollx) this.m_scrollX += 0.005;
if (this.m_scrollY >= 1.0) this.m_scrollY = 0.0;
if (this.m_scrollX >= 1.0) this.m_scrollX = 0.0;
if (Util.Fog)
{
GL.Enable(EnableCap.Fog);
}
if (Util.Lightning)
{
GL.Enable(EnableCap.Lighting);
GL.Enable(EnableCap.Light0);
}
GL.Enable(EnableCap.Texture2D);
GL.BindTexture(TextureTarget.Texture2D, texture[(int)CC]);
GL.Begin(BeginMode.Quads);
//GL.TexCoord2(0.0 + this.m_scrollX, 0.0 + this.m_scrollY); GL.Vertex3(-2.30f, -1.50f, -1.0f); // bottom right
//GL.TexCoord2(0.0 + this.m_scrollX, 5.0 + this.m_scrollY); GL.Vertex3(-2.30f, 0.20f, 1.0f); // top right
//GL.TexCoord2(5.0 + this.m_scrollX, 5.0 + this.m_scrollY); GL.Vertex3(2.30f, 0.20f, 1.0f); // top left
//GL.TexCoord2(5.0 + this.m_scrollX, 0.0 + this.m_scrollY); GL.Vertex3(2.30f, -1.50f, -1.0f); // bottom left
/*
GL.Color4(System.Drawing.Color.White); GL.TexCoord2(0.0 - this.m_scrollX, 5.0 + this.m_scrollY); GL.Vertex3(2.50f, -1.50f, 0.0f); // bottom left
GL.Color4(System.Drawing.Color.Yellow); GL.TexCoord2(5.0 - this.m_scrollX, 5.0 + this.m_scrollY); GL.Vertex3(-2.50f, -1.50f, 0.0f); // bottom right
GL.Color4(System.Drawing.Color.Blue); GL.TexCoord2(5.0 - this.m_scrollX, 0.0 + this.m_scrollY); GL.Vertex3(-3.00f, 0.50f, 5.1f); // top right
GL.Color4(System.Drawing.Color.Red); GL.TexCoord2(0.0 - this.m_scrollX, 0.0 + this.m_scrollY); GL.Vertex3(3.00f, 0.50f, 5.1f); // top left
*/
GL.TexCoord2(0.0 + this.m_scrollX, 0.0 + this.m_scrollY); GL.Vertex3(-4.60f, -2.00f, 0.0f); // bottom right
GL.TexCoord2(0.0 + this.m_scrollX, 5.0 + this.m_scrollY); GL.Vertex3(-4.60f, 0.20f, 5.1f); // top right
GL.TexCoord2(5.0 + this.m_scrollX, 5.0 + this.m_scrollY); GL.Vertex3(4.60f, 0.20f, 5.1f); // top left
GL.TexCoord2(5.0 + this.m_scrollX, 0.0 + this.m_scrollY); GL.Vertex3(4.60f, -2.00f, 0.0f); // bottom left
GL.End();
GL.BindTexture(TextureTarget.Texture2D, 0);
GL.Disable(EnableCap.Texture2D);
if (Util.Fog)
{
GL.Disable(EnableCap.Fog);
}
if (Util.Lightning)
{
GL.Disable(EnableCap.Lighting);
GL.Disable(EnableCap.Light0);
}
}
internal Piece(Piece piece)
{
PieceColor = piece.PieceColor;
PieceType = piece.PieceType;
Moved = piece.Moved;
PieceValue = piece.PieceValue;
PieceActionValue = piece.PieceActionValue;
}
public Piece[] PawnPromotedChoice()
{
ChessColor color = PawnPromotedColor;
return(new Piece[] { GetPiecePromoted(1, color), GetPiecePromoted(2, color), GetPiecePromoted(3, color), GetPiecePromoted(4, color) });
}
// piece factory
public void SetPiece <T>(ChessColor color, char column, int row) where T : Piece
{
var piece = Activator.CreateInstance(typeof(T), color) as Piece;
PutPiece(piece, column, row);
}
internal Piece(ChessPiece chessPiece, ChessColor chessPieceColor)
{
PieceType = chessPiece;
PieceColor = chessPieceColor;
PieceValue = CalculatePieceValue(PieceType);
PieceActionValue = CalculatePieceActionValue(PieceType);
}
public Rook(ChessColor color) : base(color)
{
}
