/// <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>
/// Gets the kind of the move.
/// </summary>
/// <returns>The move kind.</returns>
/// <param name="move">The move.</param>
public CheckersMoveKind GetMoveKind(CheckersMove move)
{
var kind = CheckersMoveKind.Invalid;
var player = move.Piece.Player;
var currentSquareState = move.Piece.CurrentSquare.State;
if (currentSquareState == CheckersSquareState.OccupiedByPlayerOne || currentSquareState == CheckersSquareState.OccupiedByPlayerTwo)
{
var from = GetSquare(move.Piece.CurrentSquare.ColumnIndex, move.Piece.CurrentSquare.RowIndex);
var to = GetSquare(move.ToSquare.ColumnIndex, move.ToSquare.RowIndex);
// From is square of the AI player and To is a free square.
if (from.State == currentSquareState && to.State == CheckersSquareState.Free)
{
int indexModifier = GetIndexModifier(player);
var opponentState = from.State == CheckersSquareState.OccupiedByPlayerOne
? CheckersSquareState.OccupiedByPlayerTwo
: CheckersSquareState.OccupiedByPlayerOne;
// Forward move.
if (to.RowIndex == from.RowIndex + (1 * indexModifier) &&
(to.ColumnIndex == from.ColumnIndex - (1 * indexModifier) || to.ColumnIndex == from.ColumnIndex + (1 * indexModifier)))
{
kind = CheckersMoveKind.Forward;
}
else if (CanCapture(to, from, opponentState, indexModifier))
{
kind = CheckersMoveKind.Capture;
}
}
}
return(kind);
}
/// <summary>
/// Move a piece using the specified move.
/// </summary>
/// <param name="move">The move to perform.</param>
/// <returns>True if move was performed, otherwise false.</returns>
public bool MovePiece(CheckersMove move)
{
ExceptionHelper.ThrowIfNull("move", move);
bool moved = false;
var from = GetSquare(move.Piece.CurrentSquare.ColumnIndex, move.Piece.CurrentSquare.RowIndex);
var moveKind = GetMoveKind(move);
if (moveKind != CheckersMoveKind.Invalid)
{
var to = GetSquare(move.ToSquare.ColumnIndex, move.ToSquare.RowIndex);
to.PutPiece(from.CurrentPiece);
var indexModifier = to.State == CheckersSquareState.OccupiedByPlayerOne ? 1 : -1;
from.RemovePiece();
moved = true;
// Capture move.
if (moveKind == CheckersMoveKind.Capture)
{
if (to.ColumnIndex == from.ColumnIndex + (2 * indexModifier))
{
GetSquare(from.ColumnIndex + (1 * indexModifier), from.RowIndex + (1 * indexModifier)).RemovePiece();
}
else if (to.ColumnIndex == from.ColumnIndex - (2 * indexModifier))
{
GetSquare(from.ColumnIndex - (1 * indexModifier), from.RowIndex + (1 * indexModifier)).RemovePiece();
}
}
}
return(moved);
}
/// <summary>
/// Generates the gene for the specified index.
/// </summary>
/// <returns>The gene.</returns>
/// <param name="geneIndex">Gene index.</param>
public override Gene GenerateGene(int geneIndex)
{
var from = FindPlayableSquare();
from.PutPiece(new CheckersPiece(CheckersPlayer.PlayerOne));
var to = FindPlayableSquare();
var move = new CheckersMove(from.CurrentPiece, to);
Moves[geneIndex] = move;
return new Gene(move);
}
/// <summary>
/// Generates the gene for the specified index.
/// </summary>
/// <returns>The gene.</returns>
/// <param name="geneIndex">Gene index.</param>
public override Gene GenerateGene(int geneIndex)
{
var from = FindPlayableSquare();
from.PutPiece(new CheckersPiece(CheckersPlayer.PlayerOne));
var to = FindPlayableSquare();
var move = new CheckersMove(from.CurrentPiece, to);
Moves[geneIndex] = move;
return(new Gene(move));
}
/// <summary>
/// Generates the gene for the specified index.
/// </summary>
/// <returns>The gene.</returns>
/// <param name="geneIndex">Gene index.</param>
public override Gene GenerateGene(int geneIndex)
{
var rnd = RandomizationProvider.Current;
var from = GetPlayableSquare();
from.PutPiece(new CheckersPiece(CheckersPlayer.PlayerOne));
var to = GetPlayableSquare();
var move = new CheckersMove(from.CurrentPiece, to);
Moves[geneIndex] = move;
return(new Gene(move));
}
public void MoveCurrentPieceTo (SquareController square)
{
if (m_lastSelectedPiece != null && m_lastSelectedPiece.CurrentSquare.Model.CurrentPiece != null) {
var move = new CheckersMove (m_lastSelectedPiece.CurrentSquare.Model.CurrentPiece, square.Model);
var fitness = GAController.Instance.Fitness;
if (fitness.Board.GetMoveKind (move) == CheckersMoveKind.Invalid) {
HudController.IsInvalidMove = true;
} else {
HudController.IsInvalidMove = false;
fitness.Board.MovePiece (move);
GAController.Instance.MovePiece ();
}
}
}
/// <summary>
/// Move a piece using the specified move.
/// </summary>
/// <param name="move">The move to perform.</param>
/// <returns>True if move was performed, otherwise false.</returns>
public bool MovePiece(CheckersMove move)
{
ExceptionHelper.ThrowIfNull("move", move);
bool moved = false;
var from = GetSquare(move.Piece.CurrentSquare.ColumnIndex, move.Piece.CurrentSquare.RowIndex);
var moveKind = GetMoveKind(move);
if (moveKind != CheckersMoveKind.Invalid)
{
var to = GetSquare(move.ToSquare.ColumnIndex, move.ToSquare.RowIndex);
to.PutPiece(from.CurrentPiece);
var indexModifier = to.State == CheckersSquareState.OccupiedByPlayerOne ? 1 : -1;
from.RemovePiece();
// if (!to.PutPiece (from.CurrentPiece)) {
// throw new InvalidOperationException ("Trying to put a piece on a square that already have a piece.");
// }
// var indexModifier = to.State == CheckersSquareState.OccupiedByPlayerOne ? 1 : -1;
// if (!from.RemovePiece ()) {
// throw new InvalidOperationException ("Trying to remove a piece on a square that have no piece.");
// }
moved = true;
if (moveKind == CheckersMoveKind.Capture) // Capture move.
{
if (to.ColumnIndex == from.ColumnIndex + (2 * indexModifier))
{
GetSquare(from.ColumnIndex + (1 * indexModifier), from.RowIndex + (1 * indexModifier)).RemovePiece();
}
else if (to.ColumnIndex == from.ColumnIndex - (2 * indexModifier))
{
GetSquare(from.ColumnIndex - (1 * indexModifier), from.RowIndex + (1 * indexModifier)).RemovePiece();
}
// else {
// throw new InvalidOperationException ("Houston, we have a problem! Capture move without capture any piece.");
// }
moved = true;
}
}
return(moved);
}
public void Evaluate_ChromosomeForwardMoveAndCanCaptureAnotherOne_Fitness2()
{
var board = new CheckersBoard(8);
var target = new CheckersFitness(board);
var move = new CheckersMove(new CheckersPiece(CheckersPlayer.PlayerOne) { CurrentSquare = new CheckersSquare(3, 2) }, new CheckersSquare(4, 3));
Assert.IsTrue(board.MovePiece(move));
move = new CheckersMove(new CheckersPiece(CheckersPlayer.PlayerTwo) { CurrentSquare = new CheckersSquare(6, 5) }, new CheckersSquare(5, 4));
Assert.IsTrue(board.MovePiece(move));
var chromosome = new CheckersChromosome(2, 8);
chromosome.Moves.Clear();
chromosome.Moves.Add(new CheckersMove(new CheckersPiece(CheckersPlayer.PlayerOne) { CurrentSquare = new CheckersSquare(4, 3) }, new CheckersSquare(6, 5)));
target.Update(chromosome);
Assert.AreEqual(2, target.Evaluate(chromosome));
}
/// <summary>
/// Move a piece using the specified move.
/// </summary>
/// <param name="move">The move to perform.</param>
/// <returns>True if move was performed, otherwise false.</returns>
public bool MovePiece(CheckersMove move)
{
ExceptionHelper.ThrowIfNull(nameof(move), move);
// Gets the piece's actual position and movement kind.
bool moved = false;
var from = GetSquare(move.Piece.CurrentSquare.ColumnIndex, move.Piece.CurrentSquare.RowIndex);
var moveKind = GetMoveKind(move);
// Se the movement kind is invalid between From e To positions.
if (moveKind != CheckersMoveKind.Invalid)
{
// Moves the piece to 'To' position.
var to = GetSquare(move.ToSquare.ColumnIndex, move.ToSquare.RowIndex);
to.PutPiece(from.CurrentPiece);
// Geets the current indexModifier.
var indexModifier = to.State == CheckersSquareState.OccupiedByPlayerOne ? 1 : -1;
// Removes the piece "From" position.
from.RemovePiece();
moved = true;
// Capture move.
if (moveKind == CheckersMoveKind.Capture)
{
// Here is checked if needs to capture a piece between To and From.
if (to.ColumnIndex == from.ColumnIndex + (2 * indexModifier))
{
GetSquare(from.ColumnIndex + (1 * indexModifier), from.RowIndex + (1 * indexModifier)).RemovePiece();
}
else if (to.ColumnIndex == from.ColumnIndex - (2 * indexModifier))
{
GetSquare(from.ColumnIndex - (1 * indexModifier), from.RowIndex + (1 * indexModifier)).RemovePiece();
}
}
}
return(moved);
}
/// <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);
}
public void MovePiece_ValidMove_True()
{
var target = new CheckersBoard(8);
// Move to occupied square to right side.
var move = new CheckersMove(new CheckersPiece(CheckersPlayer.PlayerOne) { CurrentSquare = new CheckersSquare(3, 2) }, new CheckersSquare(4, 3));
Assert.IsTrue(target.MovePiece(move));
move = new CheckersMove(new CheckersPiece(CheckersPlayer.PlayerTwo) { CurrentSquare = new CheckersSquare(6, 5) }, new CheckersSquare(5, 4));
Assert.IsTrue(target.MovePiece(move));
move = new CheckersMove(new CheckersPiece(CheckersPlayer.PlayerOne) { CurrentSquare = new CheckersSquare(4, 3) }, new CheckersSquare(6, 5));
Assert.IsTrue(target.MovePiece(move));
}
public void MovePiece_InvalidMove_False()
{
var target = new CheckersBoard(8);
// Horizontal move.
var move = new CheckersMove(new CheckersPiece(CheckersPlayer.PlayerOne) { CurrentSquare = new CheckersSquare(1, 0) }, new CheckersSquare(3, 0));
Assert.IsFalse(target.MovePiece(move));
// Vertical move.
move = new CheckersMove(new CheckersPiece(CheckersPlayer.PlayerOne) { CurrentSquare = new CheckersSquare(1, 0) }, new CheckersSquare(1, 2));
Assert.IsFalse(target.MovePiece(move));
// Back move.
move = new CheckersMove(new CheckersPiece(CheckersPlayer.PlayerOne) { CurrentSquare = new CheckersSquare(2, 3) }, new CheckersSquare(1, 2));
Assert.IsFalse(target.MovePiece(move));
// Move to occupied square to right side.
move = new CheckersMove(new CheckersPiece(CheckersPlayer.PlayerOne) { CurrentSquare = new CheckersSquare(1, 2) }, new CheckersSquare(2, 3));
Assert.IsTrue(target.MovePiece(move));
move = new CheckersMove(new CheckersPiece(CheckersPlayer.PlayerOne) { CurrentSquare = new CheckersSquare(2, 3) }, new CheckersSquare(3, 4));
Assert.IsTrue(target.MovePiece(move));
move = new CheckersMove(new CheckersPiece(CheckersPlayer.PlayerOne) { CurrentSquare = new CheckersSquare(3, 4) }, new CheckersSquare(4, 5)); // Occupied.
Assert.IsFalse(target.MovePiece(move));
// Move to occupied square to left side.
move = new CheckersMove(new CheckersPiece(CheckersPlayer.PlayerOne) { CurrentSquare = new CheckersSquare(7, 2) }, new CheckersSquare(6, 3));
Assert.IsTrue(target.MovePiece(move));
move = new CheckersMove(new CheckersPiece(CheckersPlayer.PlayerOne) { CurrentSquare = new CheckersSquare(6, 3) }, new CheckersSquare(5, 4));
Assert.IsTrue(target.MovePiece(move));
move = new CheckersMove(new CheckersPiece(CheckersPlayer.PlayerOne) { CurrentSquare = new CheckersSquare(5, 4) }, new CheckersSquare(6, 5)); // Occupied.
Assert.IsFalse(target.MovePiece(move));
// Move more than 1 square not capturing.
move = new CheckersMove(new CheckersPiece(CheckersPlayer.PlayerOne) { CurrentSquare = new CheckersSquare(1, 2) }, new CheckersSquare(3, 4));
Assert.IsFalse(target.MovePiece(move));
}
/// <summary>
/// Generates the gene for the specified index.
/// </summary>
/// <returns>The gene.</returns>
/// <param name="geneIndex">Gene index.</param>
public override Gene GenerateGene(int geneIndex)
{
var rnd = RandomizationProvider.Current;
var from = GetPlayableSquare();
from.PutPiece (new CheckersPiece (CheckersPlayer.PlayerOne));
var to = GetPlayableSquare();
var move = new CheckersMove(from.CurrentPiece, to);
Moves[geneIndex] = move;
return new Gene(move);
}
/// <summary>
/// Gets the kind of the move.
/// </summary>
/// <returns>The move kind.</returns>
/// <param name="move">The move.</param>
public CheckersMoveKind GetMoveKind(CheckersMove move)
{
var kind = CheckersMoveKind.Invalid;
var player = move.Piece.Player;
var currentSquareState = move.Piece.CurrentSquare.State;
if (currentSquareState == CheckersSquareState.OccupiedByPlayerOne || currentSquareState == CheckersSquareState.OccupiedByPlayerTwo)
{
var from = GetSquare(move.Piece.CurrentSquare.ColumnIndex, move.Piece.CurrentSquare.RowIndex);
var to = GetSquare(move.ToSquare.ColumnIndex, move.ToSquare.RowIndex);
// From is square of the AI player and To is a free square.
if (from.State == currentSquareState && to.State == CheckersSquareState.Free)
{
int indexModifier = GetIndexModifier(player);
CheckersSquareState opponentState;
if (from.State == CheckersSquareState.OccupiedByPlayerOne)
{
opponentState = CheckersSquareState.OccupiedByPlayerTwo;
}
else
{
opponentState = CheckersSquareState.OccupiedByPlayerOne;
}
// Forward move.
if (to.RowIndex == from.RowIndex + (1 * indexModifier)
&& (to.ColumnIndex == from.ColumnIndex - (1 * indexModifier) || to.ColumnIndex == from.ColumnIndex + (1 * indexModifier)))
{
kind = CheckersMoveKind.Forward;
}
else
if (to.RowIndex == from.RowIndex + (2 * indexModifier))
{
// Capture move.
// To right or To left?
if (to.ColumnIndex == from.ColumnIndex + (2 * indexModifier)
&& GetSquare(from.ColumnIndex + (1 * indexModifier), from.RowIndex + (1 * indexModifier)).State == opponentState)
{
kind = CheckersMoveKind.Capture;
}
else
if (to.ColumnIndex == from.ColumnIndex - (2 * indexModifier)
&& GetSquare(from.ColumnIndex - (1 * indexModifier), from.RowIndex + (1 * indexModifier)).State == opponentState)
{
kind = CheckersMoveKind.Capture;
}
}
}
}
return kind;
}
/// <summary>
/// Move a piece using the specified move.
/// </summary>
/// <param name="move">The move to perform.</param>
/// <returns>True if move was performed, otherwise false.</returns>
public bool MovePiece(CheckersMove move)
{
ExceptionHelper.ThrowIfNull("move", move);
bool moved = false;
var from = GetSquare(move.Piece.CurrentSquare.ColumnIndex, move.Piece.CurrentSquare.RowIndex);
var moveKind = GetMoveKind(move);
if (moveKind != CheckersMoveKind.Invalid)
{
var to = GetSquare(move.ToSquare.ColumnIndex, move.ToSquare.RowIndex);
to.PutPiece(from.CurrentPiece);
var indexModifier = to.State == CheckersSquareState.OccupiedByPlayerOne ? 1 : -1;
from.RemovePiece();
moved = true;
// Capture move.
if (moveKind == CheckersMoveKind.Capture)
{
if (to.ColumnIndex == from.ColumnIndex + (2 * indexModifier))
{
GetSquare(from.ColumnIndex + (1 * indexModifier), from.RowIndex + (1 * indexModifier)).RemovePiece();
}
else if (to.ColumnIndex == from.ColumnIndex - (2 * indexModifier))
{
GetSquare(from.ColumnIndex - (1 * indexModifier), from.RowIndex + (1 * indexModifier)).RemovePiece();
}
moved = true;
}
}
return moved;
}
/// <summary>
/// Move a piece using the specified move.
/// </summary>
/// <param name="move">The move to perform.</param>
/// <returns>True if move was performed, otherwise false.</returns>
public bool MovePiece(CheckersMove move)
{
ExceptionHelper.ThrowIfNull ("move", move);
bool moved = false;
var from = GetSquare(move.Piece.CurrentSquare.ColumnIndex, move.Piece.CurrentSquare.RowIndex);
var moveKind = GetMoveKind(move);
if (moveKind != CheckersMoveKind.Invalid)
{
var to = GetSquare(move.ToSquare.ColumnIndex, move.ToSquare.RowIndex);
if (!to.PutPiece (from.CurrentPiece)) {
throw new InvalidOperationException ("Trying to put a piece on a square that already have a piece.");
}
var indexModifier = to.State == CheckersSquareState.OccupiedByPlayerOne ? 1 : -1;
if (!from.RemovePiece ()) {
throw new InvalidOperationException ("Trying to remove a piece on a square that have no piece.");
}
moved = true;
if (moveKind == CheckersMoveKind.Capture) // Capture move.
{
if (to.ColumnIndex == from.ColumnIndex + (2 * indexModifier)) {
GetSquare (from.ColumnIndex + (1 * indexModifier), from.RowIndex + (1 * indexModifier)).RemovePiece ();
} else if (to.ColumnIndex == from.ColumnIndex - (2 * indexModifier)) {
GetSquare (from.ColumnIndex - (1 * indexModifier), from.RowIndex + (1 * indexModifier)).RemovePiece ();
} else {
throw new InvalidOperationException ("Houston, we have a problem! Capture move without capture any piece.");
}
moved = true;
}
}
return moved;
}
