/// <summary>
/// Generates all legal <see cref="IPawn" /> moves
/// </summary>
/// <param name="boardState"></param>
public override void GenerateMoves(IBoardState boardState)
{
IChessPieceMover cpm = ModelLocator.ChessPieceMover;
MoveSet.Clear();
ChessPosition oneSpaceFromLocation = Color == ChessColor.White ? cpm.North(Location) : cpm.South(Location);
bool oneSpaceMoveIsLegal = !boardState.Contains(oneSpaceFromLocation);
if (oneSpaceMoveIsLegal)
{
MoveSet.Add(oneSpaceFromLocation);
}
else
{
return;
}
ChessPosition twoSpaceFromLocation = Color == ChessColor.White
? cpm.North(oneSpaceFromLocation)
: cpm.South(oneSpaceFromLocation);
bool twoSpaceMoveIsLegal = !boardState.Contains(twoSpaceFromLocation);
if (!HasMoved && twoSpaceMoveIsLegal)
{
MoveSet.Add(Color == ChessColor.White
? cpm.North(cpm.North(Location))
: cpm.South(cpm.South(Location)));
}
}
/// <summary>
/// Adds a capture to the capture set.
/// </summary>
/// <param name="capturePosition"></param>
/// <param name="enemyBoardState"></param>
protected void AddCaptureToCaptureSet(ChessPosition capturePosition, IBoardState enemyBoardState)
{
if (enemyBoardState.Contains(capturePosition))
{
CaptureSet.Add(capturePosition);
}
}
private ChessPosition GenerateCaptureWest(IBoardState enemyPieces, IChessPieceMover cpm)
{
ChessPosition potentialCapture =
Color == ChessColor.White ? cpm.NorthWest(Location) : cpm.SouthWest(Location);
bool isPieceAtCaptureLocation = enemyPieces.Contains(potentialCapture);
return(isPieceAtCaptureLocation ? potentialCapture : ChessPosition.None);
}
/// <summary>
/// Should only be used by Bishop, Rook and Queen
/// </summary>
/// <param name="owningPlayerBoardState"></param>
/// <param name="enemyBoardState"></param>
/// <param name="directionFunction"></param>
protected void GenerateDirectionalCaptures(IBoardState owningPlayerBoardState, IBoardState enemyBoardState,
Func <ChessPosition, ChessPosition> directionFunction)
{
var capture = ChessPosition.None;
ChessPosition resultFromLocation = directionFunction(Location);
if (!owningPlayerBoardState.Contains(resultFromLocation))
{
capture = resultFromLocation;
while (!enemyBoardState.Contains(capture) && !owningPlayerBoardState.Contains(capture))
{
capture = directionFunction(capture);
}
}
AddCaptureToCaptureSet(capture, enemyBoardState);
}
private void GenerateEastMoves(IBoardState boardState, IChessPieceMover cpm)
{
ChessPosition nextMove = cpm.East(Location);
if (!boardState.Contains(nextMove))
{
MoveSet.Add(nextMove);
}
}
private void GenerateEastNorthEastMove(IBoardState boardState, IChessPieceMover cpm)
{
ChessPosition move = cpm.East(cpm.NorthEast(Location));
if (!boardState.Contains(move))
{
MoveSet.Add(move);
}
}
private void GenerateSouthSouthWestMove(IBoardState boardState, IChessPieceMover cpm)
{
ChessPosition move = cpm.South(cpm.SouthWest(Location));
if (!boardState.Contains(move))
{
MoveSet.Add(move);
}
}
protected void GenerateDirectionalMoves(IBoardState boardState,
Func <ChessPosition, ChessPosition> directionFunction)
{
ChessPosition nextMove = directionFunction(Location);
while (!boardState.Contains(nextMove))
{
MoveSet.Add(nextMove);
nextMove = directionFunction(nextMove);
}
}
public void Should_AddLocation()
{
// setup
IBoardState state = ModelLocator.BoardState;
const ChessPosition POSITION = ChessPosition.A1;
// execute
state.Add(POSITION);
// verify
Assert.IsTrue(state.Contains(POSITION));
}
public void Should_ReturnFalseWhenDoesNotContain()
{
// setup
IBoardState state = ModelLocator.BoardState;
const ChessPosition POSITION = ChessPosition.A1;
// execute
bool contains = state.Contains(POSITION);
// verify
Assert.IsFalse(contains);
}
public void Should_ReturnTrueWhenContains()
{
// setup
IBoardState state = ModelLocator.BoardState;
const ChessPosition POSITION = ChessPosition.A1;
state.Add(POSITION);
// execute
bool contains = state.Contains(POSITION);
// verify
Assert.IsTrue(contains);
}
public void Should_RemovePositions()
{
// setup
IBoardState state = ModelLocator.BoardState;
const ChessPosition POSITION = ChessPosition.A1;
state.Add(POSITION);
// execute
state.Remove(POSITION);
// verify
Assert.IsFalse(state.Contains(POSITION));
}
public void Should_ClearPositions()
{
// setup
IBoardState state = ModelLocator.BoardState;
var positions = new[] { ChessPosition.A2, ChessPosition.A1, ChessPosition.A4, ChessPosition.E3 };
foreach (var position in positions)
{
state.Add(position);
}
// execute
state.Clear();
// verify
Assert.IsTrue(positions.All(p => !state.Contains(p)));
}
public void Should_AddAllPositionsFromBoardstate()
{
// setup
IBoardState state = ModelLocator.BoardState;
var positions = new[] { ChessPosition.A2, ChessPosition.A1, ChessPosition.A4, ChessPosition.E3 };
foreach (var position in positions)
{
state.Add(position);
}
IBoardState state2 = ModelLocator.BoardState;
// execute
state2.Add(state);
// verify
Assert.IsTrue(positions.All(p => state2.Contains(p)));
}
