/// <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; }