/// <summary>
/// Counts the number of pieces capturable by specified piece.
/// </summary>
/// <param name="piece">The piece which can capture another ones.</param>
/// <returns>The number of capturable pieces.</returns>
public int CountCapturableByPiece(CheckersPiece piece)
{
ExceptionHelper.ThrowIfNull("piece", piece);
var capturableCount = 0;
var square = piece.CurrentSquare;
var newRowIndex = square.RowIndex + 2 * GetIndexModifier(piece.Player);
if (IsValidIndex(newRowIndex))
{
var columnIndex = square.ColumnIndex;
var newColumnToLeftIndex = columnIndex - 2;
var newColumnToRightIndex = columnIndex + 2;
if (IsValidIndex(newColumnToLeftIndex))
{
capturableCount += GetMoveKind(new CheckersMove(piece, GetSquare(newColumnToLeftIndex, newRowIndex))) == CheckersMoveKind.Capture ? 1 : 0;
}
if (IsValidIndex(newColumnToRightIndex))
{
capturableCount += GetMoveKind(new CheckersMove(piece, GetSquare(newColumnToRightIndex, newRowIndex))) == CheckersMoveKind.Capture ? 1 : 0;
}
}
return(capturableCount);
}
/// <summary>
/// Reset the board to initial state (player one and two with pieces in start positions).
/// </summary>
public void Reset()
{
PlayerOnePieces = new List <CheckersPiece> ();
PlayerTwoPieces = new List <CheckersPiece> ();
for (int c = 0; c < Size; c++)
{
for (int r = 0; r < Size; r++)
{
var square = new CheckersSquare(c, r);
if (square.State == CheckersSquareState.Free)
{
if (r < 3)
{
var piece = new CheckersPiece(CheckersPlayer.PlayerOne);
PlayerOnePieces.Add(piece);
square.PutPiece(piece);
}
else if (r >= Size - 3)
{
var piece = new CheckersPiece(CheckersPlayer.PlayerTwo);
PlayerTwoPieces.Add(piece);
square.PutPiece(piece);
}
}
m_squares[c, r] = square;
}
}
}
/// <summary>
/// Counts the number of chances the specified piece to be captured.
/// </summary>
/// <param name="piece">The piece which can be captured.</param>
/// <returns>The number of changes of piece be captured.</returns>
public int CountPieceChancesToBeCaptured(CheckersPiece piece)
{
ExceptionHelper.ThrowIfNull("piece", piece);
var capturedCount = 0;
var square = piece.CurrentSquare;
var indexModifier = GetIndexModifier(piece.Player);
var enemyPieceRowIndex = square.RowIndex + indexModifier;
var enemyToSquareRowIndex = square.RowIndex - indexModifier;
if (IsValidIndex(enemyPieceRowIndex) && IsValidIndex(enemyToSquareRowIndex))
{
var columnIndex = square.ColumnIndex;
var enemyLeftColumnIndex = columnIndex - 1;
var enemyRightColumnIndex = columnIndex + 1;
if (IsValidIndex(enemyLeftColumnIndex) && IsValidIndex(enemyRightColumnIndex))
{
capturedCount += CountIfEnemyPiece(enemyPieceRowIndex, enemyToSquareRowIndex, enemyLeftColumnIndex, enemyRightColumnIndex);
capturedCount += CountIfEnemyPiece(enemyPieceRowIndex, enemyToSquareRowIndex, enemyRightColumnIndex, enemyLeftColumnIndex);
}
}
return(capturedCount);
}
/// <summary>
/// Initializes a new instance of the <see cref="GeneticSharp.Extensions.Checkers.CheckersMove"/> class.
/// </summary>
/// <param name="piece">The piece which will be moved.</param>
/// <param name="toSquare">The target square.</param>
public CheckersMove(CheckersPiece piece, CheckersSquare toSquare)
{
ExceptionHelper.ThrowIfNull("piece", piece);
if (piece.CurrentSquare == null)
{
throw new ArgumentException("A piece for a move should have a current square defined.");
}
ExceptionHelper.ThrowIfNull("toSquare", toSquare);
Piece = piece;
ToSquare = toSquare;
}
/// <summary>
/// Initializes a new instance of the <see cref="GeneticSharp.Extensions.Checkers.CheckersMove"/> class.
/// </summary>
/// <param name="piece">The piece which will be moved.</param>
/// <param name="toSquare">The target square.</param>
public CheckersMove(CheckersPiece piece, CheckersSquare toSquare)
{
ExceptionHelper.ThrowIfNull("piece", piece);
if (piece.CurrentSquare == null)
{
throw new ArgumentException("A piece for a move should have a current square defined.");
}
ExceptionHelper.ThrowIfNull("toSquare", toSquare);
Piece = piece;
ToSquare = toSquare;
}
/// <summary>
/// Put the specified piece above this square.
/// </summary>
/// <param name="piece">The piece.</param>
/// <returns>True if square was free and could receive the piece, otherwise false.</returns>
public bool PutPiece(CheckersPiece piece)
{
if (State == CheckersSquareState.Free)
{
CurrentPiece = piece;
State = piece.Player == CheckersPlayer.PlayerOne ? CheckersSquareState.OccupiedByPlayerOne : CheckersSquareState.OccupiedByPlayerTwo;
piece.CurrentSquare = this;
return(true);
}
else if (State == CheckersSquareState.NotPlayable)
{
throw new ArgumentException("Attempt to put a piece in a not playable square.");
}
return(false);
}
/// <summary>
/// Remove the current piece.
/// </summary>
/// <returns>True if has a piece to be removed, otherwise false.</returns>
public bool RemovePiece()
{
if (CurrentPiece != null)
{
if (CurrentPiece.CurrentSquare == this)
{
CurrentPiece.CurrentSquare = null;
}
CurrentPiece = null;
State = CheckersSquareState.Free;
return(true);
}
return(false);
}
/// <summary>
/// Evaluates the move.
/// </summary>
/// <returns>The move.</returns>
/// <param name="move">Move.</param>
public double EvaluateMove(CheckersMove move)
{
double moveFitness = 0;
// Evals the move kind.
var moveKind = Board.GetMoveKind(move);
switch (moveKind)
{
case CheckersMoveKind.Forward:
moveFitness = 0.5;
break;
case CheckersMoveKind.Capture:
moveFitness = 1;
break;
case CheckersMoveKind.Invalid:
moveFitness = 0;
break;
}
if (moveFitness > 0)
{
var futurePiece = new CheckersPiece(move.Piece.Player)
{
CurrentSquare = move.ToSquare
};
// Evals the possibilities to capture anothers pieces.
moveFitness += Board.CountCapturableByPiece(move.Piece);
// Evals the possibilities to be captured by another pieces.
moveFitness -= Board.CountPieceChancesToBeCaptured(futurePiece);
}
return(moveFitness);
}
/// <summary>
/// Reset the board to initial state (player one and two with pieces in start positions).
/// </summary>
public void Reset()
{
// Creates the two lists of pieces por player one and two.ß
PlayerOnePieces = new List <CheckersPiece>();
PlayerTwoPieces = new List <CheckersPiece>();
for (int c = 0; c < Size; c++)
{
for (int r = 0; r < Size; r++)
{
// For each combinatino of collumn and row of the board
// Is create a new CheckersSquare.
var square = new CheckersSquare(c, r);
// If the sqaure is free.
if (square.State == CheckersSquareState.Free)
{
// If the actual line index is lower than 3,
// then is a square for player one.
if (r < 3)
{
var piece = new CheckersPiece(CheckersPlayer.PlayerOne);
PlayerOnePieces.Add(piece);
square.PutPiece(piece);
}
/// fi the actual line index is bigger than max lines index -3,
/// then it is a square for player two.
else if (r >= Size - 3)
{
var piece = new CheckersPiece(CheckersPlayer.PlayerTwo);
PlayerTwoPieces.Add(piece);
square.PutPiece(piece);
}
}
m_squares[c, r] = square;
}
}
}
/// <summary>
/// Counts the number of chances the specified piece to be captured.
/// </summary>
/// <param name="piece">The piece which can be captured.</param>
/// <returns>The number of changes of piece be captured.</returns>
public int CountPieceChancesToBeCaptured(CheckersPiece piece)
{
ExceptionHelper.ThrowIfNull("piece", piece);
var capturedCount = 0;
var square = piece.CurrentSquare;
var indexModifier = GetIndexModifier(piece.Player);
var enemyPieceRowIndex = square.RowIndex + 1 * indexModifier;
var enemyToSquareRowIndex = square.RowIndex - 1 * indexModifier;
if (IsValidIndex(enemyPieceRowIndex) && IsValidIndex(enemyToSquareRowIndex))
{
var columnIndex = square.ColumnIndex;
var enemyLeftColumnIndex = columnIndex - 1;
var enemyRightColumnIndex = columnIndex + 1;
if (IsValidIndex(enemyLeftColumnIndex) && IsValidIndex(enemyRightColumnIndex))
{
var enemyPiece = GetSquare(enemyLeftColumnIndex, enemyPieceRowIndex).CurrentPiece;
if (enemyPiece != null)
{
capturedCount += GetMoveKind(new CheckersMove(enemyPiece, GetSquare(enemyRightColumnIndex, enemyToSquareRowIndex))) == CheckersMoveKind.Capture ? 1 : 0;
}
enemyPiece = GetSquare(enemyRightColumnIndex, enemyPieceRowIndex).CurrentPiece;
if (enemyPiece != null)
{
capturedCount += GetMoveKind(new CheckersMove(enemyPiece, GetSquare(enemyLeftColumnIndex, enemyToSquareRowIndex))) == CheckersMoveKind.Capture ? 1 : 0;
}
}
}
return(capturedCount);
}
/// <summary>
/// Put the specified piece above this square.
/// </summary>
/// <param name="piece">The piece.</param>
/// <returns>True if square was free and could receive the piece, otherwise false.</returns>
public bool PutPiece(CheckersPiece piece)
{
if (State == CheckersSquareState.Free)
{
CurrentPiece = piece;
State = piece.Player == CheckersPlayer.PlayerOne ? CheckersSquareState.OccupiedByPlayerOne : CheckersSquareState.OccupiedByPlayerTwo;
piece.CurrentSquare = this;
return true;
}
else if (State == CheckersSquareState.NotPlayable)
{
throw new ArgumentException("Attempt to put a piece in a not playable square.");
}
return false;
}
/// <summary>
/// Reset the board to initial state (player one and two with pieces in start positions).
/// </summary>
public void Reset()
{
PlayerOnePieces = new List<CheckersPiece>();
PlayerTwoPieces = new List<CheckersPiece>();
for (int c = 0; c < Size; c++)
{
for (int r = 0; r < Size; r++)
{
var square = new CheckersSquare(c, r);
if (square.State == CheckersSquareState.Free)
{
if (r < 3)
{
var piece = new CheckersPiece(CheckersPlayer.PlayerOne);
PlayerOnePieces.Add(piece);
square.PutPiece(piece);
}
else if (r >= Size - 3)
{
var piece = new CheckersPiece(CheckersPlayer.PlayerTwo);
PlayerTwoPieces.Add(piece);
square.PutPiece(piece);
}
}
m_squares[c, r] = square;
}
}
}
/// <summary>
/// Counts the number of chances the specified piece to be captured.
/// </summary>
/// <param name="piece">The piece which can be captured.</param>
/// <returns>The number of changes of piece be captured.</returns>
public int CountPieceChancesToBeCaptured(CheckersPiece piece)
{
ExceptionHelper.ThrowIfNull("piece", piece);
var capturedCount = 0;
var square = piece.CurrentSquare;
var indexModifier = GetIndexModifier(piece.Player);
var enemyPieceRowIndex = square.RowIndex + indexModifier;
var enemyToSquareRowIndex = square.RowIndex - indexModifier;
if (IsValidIndex(enemyPieceRowIndex) && IsValidIndex(enemyToSquareRowIndex))
{
var columnIndex = square.ColumnIndex;
var enemyLeftColumnIndex = columnIndex - 1;
var enemyRightColumnIndex = columnIndex + 1;
if (IsValidIndex(enemyLeftColumnIndex) && IsValidIndex(enemyRightColumnIndex))
{
var enemyPiece = GetSquare(enemyLeftColumnIndex, enemyPieceRowIndex).CurrentPiece;
if (enemyPiece != null)
{
capturedCount += GetMoveKind(new CheckersMove(enemyPiece, GetSquare(enemyRightColumnIndex, enemyToSquareRowIndex))) == CheckersMoveKind.Capture ? 1 : 0;
}
enemyPiece = GetSquare(enemyRightColumnIndex, enemyPieceRowIndex).CurrentPiece;
if (enemyPiece != null)
{
capturedCount += GetMoveKind(new CheckersMove(enemyPiece, GetSquare(enemyLeftColumnIndex, enemyToSquareRowIndex))) == CheckersMoveKind.Capture ? 1 : 0;
}
}
}
return capturedCount;
}
/// <summary>
/// Counts the number of pieces catchable by specified piece.
/// </summary>
/// <param name="piece">The piece which can capture another ones.</param>
/// <returns>The number of catchable pieces.</returns>
public int CountCatchableByPiece(CheckersPiece piece)
{
ExceptionHelper.ThrowIfNull("piece", piece);
var capturableCount = 0;
var square = piece.CurrentSquare;
var newRowIndex = square.RowIndex + (2 * GetIndexModifier(piece.Player));
if (IsValidIndex(newRowIndex))
{
var columnIndex = square.ColumnIndex;
var newColumnToLeftIndex = columnIndex - 2;
var newColumnToRightIndex = columnIndex + 2;
if (IsValidIndex(newColumnToLeftIndex))
{
capturableCount += GetMoveKind(new CheckersMove(piece, GetSquare(newColumnToLeftIndex, newRowIndex))) == CheckersMoveKind.Capture ? 1 : 0;
}
if (IsValidIndex(newColumnToRightIndex))
{
capturableCount += GetMoveKind(new CheckersMove(piece, GetSquare(newColumnToRightIndex, newRowIndex))) == CheckersMoveKind.Capture ? 1 : 0;
}
}
return capturableCount;
}
/// <summary>
/// Evaluates the move.
/// </summary>
/// <returns>The move.</returns>
/// <param name="move">Move.</param>
public double EvaluateMove(CheckersMove move)
{
double moveFitness = 0;
// Evals the move kind.
var moveKind = Board.GetMoveKind (move);
switch (moveKind) {
case CheckersMoveKind.Forward:
moveFitness = 0.5;
break;
case CheckersMoveKind.Capture:
moveFitness = 1;
break;
case CheckersMoveKind.Invalid:
moveFitness = 0;
break;
}
if (moveFitness > 0)
{
var futurePiece = new CheckersPiece(move.Piece.Player) { CurrentSquare = move.ToSquare };
// Evals the possibilities to capture anothers pieces.
moveFitness += Board.CountCapturableByPiece(move.Piece);
// Evals the possibilities to be captured by another pieces.
moveFitness -= Board.CountPieceChancesToBeCaptured(futurePiece);
}
return moveFitness;
}
/// <summary>
/// Remove the current piece.
/// </summary>
/// <returns>True if has a piece to be removed, otherwise false.</returns>
public bool RemovePiece()
{
if (CurrentPiece != null)
{
if (CurrentPiece.CurrentSquare == this)
{
CurrentPiece.CurrentSquare = null;
}
CurrentPiece = null;
State = CheckersSquareState.Free;
return true;
}
return false;
}