protected IEnumerable <BoardPostion> GenerateDiagonalPositions(BoardPostion postion)
{
for (int i = 1; i < BoardSize; i++)
{
if (postion.Row - i >= 0 && postion.Column - i >= 0)
{
yield return(new BoardPostion(postion.Row - i, postion.Column - i));
}
if (postion.Row + i < BoardSize && postion.Column - i >= 0)
{
yield return(new BoardPostion(postion.Row + i, postion.Column - i));
}
if (postion.Row + i < BoardSize && postion.Column + i < BoardSize)
{
yield return(new BoardPostion(postion.Row + i, postion.Column + i));
}
if (postion.Row - i >= 0 && postion.Column + i < BoardSize)
{
yield return(new BoardPostion(postion.Row - i, postion.Column + i));
}
}
}
protected IEnumerable <BoardPostion> GenerateVerticalPositions(BoardPostion postion)
{
for (int i = 0; i < BoardSize; i++)
{
if (i != postion.Row)
{
yield return(new BoardPostion(i, postion.Column));
}
}
}
protected IEnumerable <BoardPostion> GenerateHorizontalPositions(BoardPostion postion)
{
for (int i = 0; i < BoardSize; i++)
{
if (i != postion.Column)
{
yield return(new BoardPostion(postion.Row, i));
}
}
}
public async Task <MoveCheckStatus> CheckMove(PieceType pieceType, BoardPostion currentPostion, BoardPostion boardPostion)
{
var moves = await GetAvailableMoves(pieceType, currentPostion);
if (moves == null)
{
return(await Task.FromResult(MoveCheckStatus.Error));
}
return(moves.Any(m => m.Equals(boardPostion))
? MoveCheckStatus.Ok
: MoveCheckStatus.Invalid);
}
protected override IEnumerable <BoardPostion> GetAvailableMoves(BoardPostion piecePostion)
{
for (int i = 0; i < BoardSize; i++)
{
if (i != piecePostion.Row)
{
yield return(new BoardPostion(i, piecePostion.Column));
}
if (i != piecePostion.Column)
{
yield return(new BoardPostion(piecePostion.Row, i));
}
}
}
public void GetAvailableMovesShouldReturnNull(PieceType pieceType)
{
//Arrange
var postion = new BoardPostion(1, 1);
var factoryMock = new Mock <IPieceStrategyFactory>();
var pieceStrategyMock = new Mock <IPieceStrategy>();
factoryMock
.Setup(x => x.Create(It.IsAny <PieceType>()))
.Returns <IPieceStrategyFactory>(null);
var uut = new BoardService(factoryMock.Object);
//Act
var result = uut.GetAvailableMoves(pieceType, postion).Result;
//Arrange
Assert.IsNull(result);
}
public void GetAvailableMovesShouldReturnAvailableMoves(PieceType pieceType)
{
//Arrange
var postion = new BoardPostion(1, 1);
var factoryMock = new Mock <IPieceStrategyFactory>();
var pieceStrategyMock = new Mock <IPieceStrategy>();
factoryMock
.Setup(x => x.Create(It.IsAny <PieceType>()))
.Returns(pieceStrategyMock.Object);
var uut = new BoardService(factoryMock.Object);
//Act
var result = uut.GetAvailableMoves(pieceType, postion);
//Arrange
pieceStrategyMock.Verify(x => x.GetAvailableMovesAsync(postion), Times.Once);
}
//TODO: and so on for all board postions
public void GetAvailableMovesShouldReturnCorrectMoves(int rowFrom, int columntFrom)
{
// Arrange
var from = new BoardPostion(rowFrom, columntFrom);
var legalMoves = GenerateHorizontalPositions(from)
.Union(GenerateVerticalPositions(from))
.ToList();
// Act
var moves = uut.GetAvailableMovesAsync(from).Result.ToList();
// Assert
foreach (var move in moves)
{
Assert.Contains(move, legalMoves);
}
foreach (var move in legalMoves)
{
Assert.Contains(move, moves);
}
}
public void CheckMoveShouldReturnOk(PieceType pieceType)
{
//Arrange
var postionFrom = new BoardPostion(1, 1);
var postionTo = new BoardPostion(3, 4);
var factoryMock = new Mock <IPieceStrategyFactory>();
var pieceStrategyMock = new Mock <IPieceStrategy>();
pieceStrategyMock
.Setup(x => x.GetAvailableMovesAsync(postionFrom))
.Returns(Task.FromResult <IEnumerable <BoardPostion> >(new [] { postionTo }));
factoryMock
.Setup(x => x.Create(It.IsAny <PieceType>()))
.Returns(pieceStrategyMock.Object);
var uut = new BoardService(factoryMock.Object);
//Act
var result = uut.CheckMove(pieceType, postionFrom, postionTo).Result;
//Arrange
Assert.That(result.Equals(MoveCheckStatus.Ok));
}
protected abstract IEnumerable <BoardPostion> GetAvailableMoves(BoardPostion piecePostion);
public async Task <IEnumerable <BoardPostion> > GetAvailableMovesAsync(BoardPostion piecePostion)
{
return(await Task.Run(() => GetAvailableMoves(piecePostion)));
}
public async Task <IEnumerable <BoardPostion> > GetAvailableMoves(PieceType pieceType, BoardPostion piecePostion)
{
try
{
var pieceStrategy = pieceStrategyFactory.Create(pieceType);
return(await pieceStrategy.GetAvailableMovesAsync(piecePostion));
}
catch (Exception e)
{
//TODO: log exception
return(await Task.FromResult <IEnumerable <BoardPostion> >(null));
}
}
