public void BlackCastleLeftTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
ml.MovePiece(gb.squares[7, 4], gb.squares[7, 2]);
Assert.AreEqual(ChessPiece.King, gb.squares[7, 4].Piece.Type);
Assert.AreEqual(ChessPiece.Bishop, gb.squares[7, 2].Piece.Type);
gb.RemovePiece(gb.squares[7, 2]);
ml.MovePiece(gb.squares[7, 4], gb.squares[7, 2]);
Assert.AreEqual(ChessPiece.King, gb.squares[0, 4].Piece.Type);
Assert.IsNull(gb.squares[7, 2].Piece);
gb.RemovePiece(gb.squares[7, 1]);
ml.MovePiece(gb.squares[7, 4], gb.squares[7, 2]);
Assert.AreEqual(ChessPiece.King, gb.squares[7, 4].Piece.Type);
Assert.IsNull(gb.squares[7, 2].Piece);
gb.RemovePiece(gb.squares[7, 3]);
ml.MovePiece(gb.squares[7, 4], gb.squares[7, 2]);
Assert.IsNull(gb.squares[7, 4].Piece);
Assert.AreEqual(ChessPiece.King, gb.squares[7, 2].Piece.Type);
Assert.AreEqual(ChessPiece.Rook, gb.squares[7, 3].Piece.Type);
}
/// <summary>
/// Collects input from user for passive turn, ensures legality, then executes move.
/// Also updates Turn properties to reflect upcoming aggressive turn.
/// </summary>
private void ExecutePassiveTurn()
{
while (!PassiveTurnDone)
{
while (!GetUserInputForTurn())
{
CurrentGame.Refresh();
}
if (MoveLogic.MoveIsLegal(this.CurrentMove))
{
ExecuteCurrentMove(this.CurrentMove);
CurrentPlayer.LastMoveMade = CurrentMove;
TurnIsPassive = false;
PassiveTurnDone = true;
this.currentTurnType = TurnType.Aggressive;
}
else
{
Console.WriteLine(MoveLogic.PrintErrorMessage(this.CurrentMove) + " Press enter to continue...");
Console.ReadLine();
PassiveTurnDone = false;
}
CurrentGame.Refresh();
}
}
public void CheckTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
GameState gs = new GameState(ml);
Assert.AreEqual(false, gs.Check(gb, ChessColor.White));
gb.MovePiece(gb.squares[0, 1], gb.squares[5, 3]);
Assert.AreEqual(true, gs.Check(gb, ChessColor.Black));
gb.MovePiece(gb.squares[5, 3], gb.squares[0, 1]);
gb.MovePiece(gb.squares[7, 1], gb.squares[2, 3]);
Assert.AreEqual(true, gs.Check(gb, ChessColor.White));
gb.MovePiece(gb.squares[0, 4], gb.squares[3, 4]);
gb.MovePiece(gb.squares[7, 4], gb.squares[4, 4]);
Assert.AreEqual(true, gs.Check(gb, ChessColor.White));
Assert.AreEqual(true, gs.Check(gb, ChessColor.Black));
gb.MovePiece(gb.squares[4, 4], gb.squares[7, 4]);
gb.MovePiece(gb.squares[0, 0], gb.squares[4, 4]);
gb.MovePiece(gb.squares[7, 0], gb.squares[5, 4]);
Assert.AreEqual(false, gs.Check(gb, ChessColor.White));
gb.MovePiece(gb.squares[4, 4], gb.squares[4, 3]);
Assert.AreEqual(true, gs.Check(gb, ChessColor.White));
}
public virtual void TwoDevicePartInit(Dictionary <InputDevicePartType, SCPointEventData> eventDataDic, Transform targetTransform, MoveLogic moveLogic, RotateLogic rotateLogic, ScaleLogic scaleLogic)
{
this.eventDataDic = eventDataDic;
this.targetTransform = targetTransform;
this.moveLogic = moveLogic;
this.rotateLogic = rotateLogic;
this.scaleLogic = scaleLogic;
}
public void CheckMateDefaultTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
GameState gs = new GameState(ml);
Assert.AreEqual(false, gs.CheckMate(gb, ChessColor.White));
Assert.AreEqual(false, gs.CheckMate(gb, ChessColor.Black));
}
public void CaptureTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
ml.Capture(ml.gb.squares[0, 0], ml.gb.squares[7, 0]);
Assert.AreEqual(ChessColor.White, gb.squares[7, 0].Piece.Color);
}
public void MoveTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
Assert.AreEqual(true, ml.MovePiece(gb.squares[1, 0], gb.squares[2, 0]));
Assert.AreEqual(true, ml.MovePiece(gb.squares[1, 1], gb.squares[3, 1]));
Assert.AreEqual(false, ml.MovePiece(gb.squares[2, 0], gb.squares[4, 0]));
}
public void MoveIsLegalTest(bool expected, int endIndex)
{
// Arrange
Board testBoard = new Board(1);
Move testMove = new Move(testBoard.SquaresOnBoard[0], testBoard.SquaresOnBoard[endIndex], testBoard, PlayerName.X, true);
// Act
bool result = MoveLogic.MoveIsLegal(testMove);
// Assert
Assert.AreEqual(expected, result);
}
public void MoveAnotherPieceCheckTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
gb.MovePiece(gb.squares[0, 4], gb.squares[5, 4]);
Assert.AreEqual(true, ml.MovePiece(gb.squares[7, 6], gb.squares[5, 5]));
Assert.AreEqual(ChessPiece.Knight, gb.squares[5, 5].Piece.Type);
Assert.AreEqual(ChessColor.Black, gb.squares[5, 5].Piece.Color);
Assert.IsNull(gb.squares[7, 6].Piece);
}
public void FoolsMateTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
GameState gs = new GameState(ml);
gb.MovePiece(gb.squares[1, 5], gb.squares[2, 5]);
gb.MovePiece(gb.squares[6, 4], gb.squares[4, 4]);
gb.MovePiece(gb.squares[1, 6], gb.squares[3, 6]);
gb.MovePiece(gb.squares[7, 3], gb.squares[3, 7]);
Assert.AreEqual(true, gs.CheckMate(gb, ChessColor.White));
Assert.AreEqual(false, gs.InPlay(gb, ChessColor.White));
}
public void MatchesPassiveMoveWhileAggressiveTest(int endIndex, bool expected)
{
// Arrange
Game testGame = new Game();
testGame.currentPlayer.LastMoveMade = new Move(testGame.mainBoards[0].SquaresOnBoard[0], testGame.mainBoards[0].SquaresOnBoard[8], testGame.mainBoards[0], PlayerName.X, true);
Move testMove = new Move(testGame.mainBoards[1].SquaresOnBoard[0], testGame.mainBoards[1].SquaresOnBoard[endIndex], testGame.mainBoards[1], PlayerName.X, false);
// Act
bool result = MoveLogic.MatchesPassiveMoveWhileAggressive(testMove, testGame.currentPlayer.LastMoveMade);
// Assert
Assert.AreEqual(expected, result);
}
public void HumanPlayerMoveTest()
{
GameBoard gb = new GameBoard();
MoveLogic ml = new MoveLogic(gb);
Player player = new Human();
player.Move(ml, gb.squares[0, 1], gb.squares[2, 0]);
Assert.AreEqual(ChessColor.White, player.Color);
Assert.AreEqual(new TimeSpan(0, 60, 0), player.Clock.TimeRemaining);
Assert.AreEqual(ChessPiece.Knight, gb.squares[2, 0].Piece.Type);
Assert.IsNull(gb.squares[0, 1].Piece);
}
public void FirstWhitePawnTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
var pawn = gb.squares[1, 0];
GetAllValidMoves.GetMoves(ml, pawn, ChessColor.White, false);
Assert.AreEqual(2, GetAllValidMoves.AllValidMoves.Count);
Assert.AreEqual(gb.squares[2, 0].Coord, GetAllValidMoves.AllValidMoves[0]);
Assert.AreEqual(gb.squares[3, 0].Coord, GetAllValidMoves.AllValidMoves[1]);
}
public void DoesNotPushTwoPiecesTest()
{
// Arrange
Game testGame = new Game();
Move testMove = new Move(testGame.mainBoards[0].SquaresOnBoard[0], testGame.mainBoards[0].SquaresOnBoard[8], testGame.mainBoards[0], PlayerName.X, true);
testGame.mainBoards[0].SquaresOnBoard[4].HasO = true;
// Act
bool result = MoveLogic.MoveIsLegal(testMove);
// Assert
Assert.IsFalse(result);
}
public void UndoCastleTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
gb.RemovePiece(gb.squares[0, 1]);
gb.RemovePiece(gb.squares[0, 2]);
gb.RemovePiece(gb.squares[0, 3]);
gb.RemovePiece(gb.squares[7, 5]);
gb.RemovePiece(gb.squares[7, 6]);
ml.MovePiece(gb.squares[0, 4], gb.squares[0, 2]);
Assert.AreEqual(ChessPiece.King, gb.squares[0, 2].Piece.Type);
Assert.AreEqual(ChessColor.White, gb.squares[0, 2].Piece.Color);
Assert.AreEqual(ChessPiece.Rook, gb.squares[0, 3].Piece.Type);
Assert.AreEqual(ChessColor.White, gb.squares[0, 3].Piece.Color);
Assert.IsNull(gb.squares[0, 0].Piece);
Assert.IsNull(gb.squares[0, 4].Piece);
Assert.AreEqual(1, gb.squares[0, 2].Piece.MoveCount);
Assert.AreEqual(1, gb.squares[0, 3].Piece.MoveCount);
ml.Undo();
Assert.AreEqual(ChessPiece.King, gb.squares[0, 4].Piece.Type);
Assert.AreEqual(ChessColor.White, gb.squares[0, 4].Piece.Color);
Assert.AreEqual(ChessPiece.Rook, gb.squares[0, 0].Piece.Type);
Assert.AreEqual(ChessColor.White, gb.squares[0, 0].Piece.Color);
Assert.IsNull(gb.squares[0, 2].Piece);
Assert.IsNull(gb.squares[0, 3].Piece);
Assert.AreEqual(0, gb.squares[0, 0].Piece.MoveCount);
Assert.AreEqual(0, gb.squares[0, 4].Piece.MoveCount);
ml.MovePiece(gb.squares[7, 4], gb.squares[7, 6]);
Assert.AreEqual(ChessPiece.King, gb.squares[7, 6].Piece.Type);
Assert.AreEqual(ChessColor.Black, gb.squares[7, 6].Piece.Color);
Assert.AreEqual(ChessPiece.Rook, gb.squares[7, 5].Piece.Type);
Assert.AreEqual(ChessColor.Black, gb.squares[7, 5].Piece.Color);
Assert.IsNull(gb.squares[7, 4].Piece);
Assert.IsNull(gb.squares[7, 7].Piece);
Assert.AreEqual(1, gb.squares[7, 5].Piece.MoveCount);
Assert.AreEqual(1, gb.squares[7, 6].Piece.MoveCount);
ml.Undo();
Assert.AreEqual(ChessPiece.King, gb.squares[7, 4].Piece.Type);
Assert.AreEqual(ChessColor.Black, gb.squares[7, 4].Piece.Color);
Assert.AreEqual(ChessPiece.Rook, gb.squares[7, 7].Piece.Type);
Assert.AreEqual(ChessColor.Black, gb.squares[7, 7].Piece.Color);
Assert.IsNull(gb.squares[7, 5].Piece);
Assert.IsNull(gb.squares[7, 6].Piece);
Assert.AreEqual(0, gb.squares[7, 4].Piece.MoveCount);
Assert.AreEqual(0, gb.squares[7, 7].Piece.MoveCount);
}
public void WhiteFakeEnPassantOtherSideTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
gb.MovePiece(gb.squares[6, 1], gb.squares[3, 5]);
gb.MovePiece(gb.squares[1, 6], gb.squares[3, 6]);
ml.MovePiece(gb.squares[1, 0], gb.squares[3, 0]);
ml.MovePiece(gb.squares[3, 5], gb.squares[2, 6]);
Assert.AreEqual(ChessColor.Black, gb.squares[3, 5].Piece.Color);
Assert.IsNull(gb.squares[2, 6].Piece);
Assert.AreEqual(ChessColor.White, gb.squares[3, 6].Piece.Color);
Assert.AreEqual(ChessColor.White, gb.squares[3, 0].Piece.Color);
}
public void UndoNormalMoveTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
ml.MovePiece(gb.squares[1, 0], gb.squares[2, 0]);
Assert.AreEqual(ChessPiece.Pawn, gb.squares[2, 0].Piece.Type);
Assert.IsNull(gb.squares[1, 0].Piece);
Assert.AreEqual(1, gb.squares[2, 0].Piece.MoveCount);
ml.Undo();
Assert.AreEqual(ChessPiece.Pawn, gb.squares[1, 0].Piece.Type);
Assert.IsNull(gb.squares[2, 0].Piece);
Assert.AreEqual(0, gb.squares[1, 0].Piece.MoveCount);
}
public void BlackFakeEnPassantTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
gb.MovePiece(gb.squares[6, 1], gb.squares[3, 1]);
gb.MovePiece(gb.squares[1, 6], gb.squares[4, 6]);
ml.MovePiece(gb.squares[6, 7], gb.squares[4, 7]);
ml.MovePiece(gb.squares[1, 0], gb.squares[3, 0]);
ml.MovePiece(gb.squares[7, 0], gb.squares[6, 0]);
ml.MovePiece(gb.squares[4, 6], gb.squares[5, 7]);
Assert.AreEqual(ChessColor.White, gb.squares[4, 6].Piece.Color);
Assert.IsNull(gb.squares[5, 7].Piece);
Assert.AreEqual(ChessColor.Black, gb.squares[4, 7].Piece.Color);
}
public void CheckMateFailTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
GameState gs = new GameState(ml);
gb.MovePiece(gb.squares[7, 6], gb.squares[2, 5]);
Assert.AreEqual(true, gs.Check(gb, ChessColor.White, true));
Assert.AreEqual(false, gs.CheckMate(gb, ChessColor.White));
gb.RemovePiece(gb.squares[1, 4]);
gb.RemovePiece(gb.squares[1, 6]);
gb.RemovePiece(gb.squares[0, 6]);
Assert.AreEqual(true, gs.Check(gb, ChessColor.White, true));
Assert.AreEqual(false, gs.CheckMate(gb, ChessColor.White));
}
public void IsPromotionTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
Assert.AreEqual(false, ml.IsPromotion(gb.squares[1, 0]));
Assert.AreEqual(false, ml.IsPromotion(gb.squares[6, 0]));
gb.RemovePiece(gb.squares[7, 0]);
gb.MovePiece(gb.squares[1, 0], gb.squares[7, 0]);
Assert.AreEqual(true, ml.IsPromotion(gb.squares[7, 0]));
gb.RemovePiece(gb.squares[0, 0]);
gb.MovePiece(gb.squares[6, 0], gb.squares[0, 0]);
Assert.AreEqual(true, ml.IsPromotion(gb.squares[0, 0]));
}
public void StaleMateFailTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
GameState gs = new GameState(ml);
gb.ClearBoard();
IPiece whiteKing = new King(ChessColor.White);
IPiece whiteQueen = new Queen(ChessColor.White);
IPiece blackKing = new King(ChessColor.Black);
gb.PlacePiece(whiteKing, gb.squares[6, 5]);
gb.PlacePiece(whiteQueen, gb.squares[5, 6]);
gb.PlacePiece(blackKing, gb.squares[7, 4]);
Assert.AreEqual(false, gs.StaleMate(gb, ChessColor.Black));
}
public void CheckMateValidTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
GameState gs = new GameState(ml);
gb.ClearBoard();
IPiece whiteKing = new King(ChessColor.White);
IPiece whiteQueen = new Queen(ChessColor.White);
IPiece blackKing = new King(ChessColor.Black);
gb.PlacePiece(whiteKing, gb.squares[5, 3]);
gb.PlacePiece(whiteQueen, gb.squares[6, 3]);
gb.PlacePiece(blackKing, gb.squares[7, 3]);
Assert.AreEqual(true, gs.CheckMate(gb, ChessColor.Black));
}
public void MovePieceTest()
{
GameBoard gb = new GameBoard(8, 8);
gb.InitializeBoard();
MoveLogic ml = new MoveLogic(gb);
ml.MovePiece(ml.gb.squares[1, 0], ml.gb.squares[2, 0]);
Assert.AreEqual(ChessPiece.Pawn, gb.squares[2, 0].Piece.Type);
gb.MovePiece(gb.squares[6, 0], gb.squares[3, 1]);
ml.MovePiece(ml.gb.squares[2, 0], ml.gb.squares[3, 1]);
Assert.AreEqual(ChessPiece.Pawn, ml.gb.squares[3, 1].Piece.Type);
Assert.AreEqual(ChessColor.White, ml.gb.squares[3, 1].Piece.Color);
ml.MovePiece(ml.gb.squares[1, 1], ml.gb.squares[4, 1]);
Assert.IsNull(ml.gb.squares[4, 1].Piece);
}
public ActionResult <MapDto> GetState([FromRoute] Guid id, Movement movement)
{
var map = repository.GetMapById(id);
if (map == null)
{
return(NotFound());
}
var mapNew = Service.MoveLogic.Move(movement, map);
var dto = new MapDto();
dto.map = mapNew.Serialize();
dto.id = id;
if (MoveLogic.IsFinished(mapNew))
{
dto.isFinished = true;
}
return(Ok(dto));
}
public void PromoteTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
ml.Promote(gb.squares[0, 0], Promotion.Queen);
Assert.AreEqual(ChessPiece.Queen, gb.squares[0, 0].Piece.Type);
ml.Promote(gb.squares[0, 0], Promotion.Knight);
Assert.AreEqual(ChessPiece.Knight, gb.squares[0, 0].Piece.Type);
ml.Promote(gb.squares[0, 0], Promotion.Rook);
Assert.AreEqual(ChessPiece.Rook, gb.squares[0, 0].Piece.Type);
ml.Promote(gb.squares[0, 0], Promotion.Bishop);
Assert.AreEqual(ChessPiece.Bishop, gb.squares[0, 0].Piece.Type);
ml.Promote(gb.squares[0, 0], Promotion.Bishop);
Assert.AreNotEqual(ChessPiece.Queen, gb.squares[0, 0].Piece.Type);
}
public void UndoCaptureTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
gb.MovePiece(gb.squares[6, 0], gb.squares[2, 1]);
ml.MovePiece(gb.squares[1, 0], gb.squares[2, 1], true);
Assert.AreEqual(ChessPiece.Pawn, gb.squares[2, 1].Piece.Type);
Assert.AreEqual(ChessColor.White, gb.squares[2, 1].Piece.Color);
Assert.IsNull(gb.squares[1, 0].Piece);
Assert.AreEqual(1, gb.squares[2, 1].Piece.MoveCount);
ml.Undo();
Assert.AreEqual(ChessPiece.Pawn, gb.squares[1, 0].Piece.Type);
Assert.AreEqual(ChessColor.White, gb.squares[1, 0].Piece.Color);
Assert.AreEqual(ChessPiece.Pawn, gb.squares[2, 1].Piece.Type);
Assert.AreEqual(ChessColor.Black, gb.squares[2, 1].Piece.Color);
Assert.AreEqual(0, gb.squares[1, 0].Piece.MoveCount);
Assert.AreEqual(1, gb.squares[2, 1].Piece.MoveCount);
}
public void BlackCastleRightTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
ml.MovePiece(gb.squares[7, 4], gb.squares[7, 6]);
Assert.AreEqual(ChessPiece.King, gb.squares[7, 4].Piece.Type);
Assert.AreEqual(ChessPiece.Knight, gb.squares[7, 6].Piece.Type);
gb.RemovePiece(gb.squares[7, 6]);
ml.MovePiece(gb.squares[7, 4], gb.squares[7, 6]);
Assert.AreEqual(ChessPiece.King, gb.squares[7, 4].Piece.Type);
Assert.IsNull(gb.squares[7, 6].Piece);
gb.RemovePiece(gb.squares[7, 5]);
ml.MovePiece(gb.squares[7, 4], gb.squares[7, 6]);
Assert.IsNull(gb.squares[7, 4].Piece);
Assert.AreEqual(ChessPiece.King, gb.squares[7, 6].Piece.Type);
Assert.AreEqual(ChessPiece.Rook, gb.squares[7, 5].Piece.Type);
}
public void CastleFailTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
gb.RemovePiece(gb.squares[0, 1]);
gb.RemovePiece(gb.squares[0, 2]);
gb.RemovePiece(gb.squares[0, 3]);
gb.RemovePiece(gb.squares[0, 5]);
gb.RemovePiece(gb.squares[0, 6]);
gb.RemovePiece(gb.squares[7, 1]);
gb.RemovePiece(gb.squares[7, 2]);
gb.RemovePiece(gb.squares[7, 3]);
gb.RemovePiece(gb.squares[7, 5]);
gb.RemovePiece(gb.squares[7, 6]);
ml.MovePiece(gb.squares[7, 0], gb.squares[7, 1]);
ml.MovePiece(gb.squares[7, 1], gb.squares[7, 0]);
ml.MovePiece(gb.squares[7, 4], gb.squares[7, 2]);
Assert.IsNull(gb.squares[7, 2].Piece);
Assert.AreEqual(ChessPiece.King, gb.squares[7, 4].Piece.Type);
Assert.AreEqual(ChessPiece.Rook, gb.squares[7, 0].Piece.Type);
ml.MovePiece(gb.squares[7, 4], gb.squares[7, 5]);
ml.MovePiece(gb.squares[7, 5], gb.squares[7, 4]);
ml.MovePiece(gb.squares[7, 4], gb.squares[7, 2]);
Assert.IsNull(gb.squares[7, 2].Piece);
Assert.AreEqual(ChessPiece.King, gb.squares[7, 4].Piece.Type);
Assert.AreEqual(ChessPiece.Rook, gb.squares[7, 0].Piece.Type);
ml.MovePiece(gb.squares[0, 4], gb.squares[7, 2]);
Assert.IsNull(gb.squares[7, 2].Piece);
Assert.AreEqual(ChessPiece.King, gb.squares[0, 4].Piece.Type);
Assert.AreEqual(ChessPiece.Rook, gb.squares[7, 0].Piece.Type);
Assert.AreEqual(ChessPiece.Rook, gb.squares[0, 0].Piece.Type);
ml.MovePiece(gb.squares[0, 4], gb.squares[0, 2]);
Assert.IsNull(gb.squares[0, 4].Piece);
Assert.AreEqual(ChessPiece.King, gb.squares[0, 2].Piece.Type);
Assert.AreEqual(ChessPiece.Rook, gb.squares[0, 3].Piece.Type);
}
public void MoveIntoCheckCastleTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
gb.RemovePiece(gb.squares[0, 5]);
gb.RemovePiece(gb.squares[0, 6]);
gb.MovePiece(gb.squares[7, 6], gb.squares[2, 5]);
Assert.AreEqual(false, ml.MovePiece(gb.squares[0, 4], gb.squares[0, 6]));
Assert.AreEqual(ChessPiece.King, gb.squares[0, 4].Piece.Type);
Assert.AreEqual(ChessColor.White, gb.squares[0, 4].Piece.Color);
Assert.AreEqual(ChessPiece.Rook, gb.squares[0, 7].Piece.Type);
Assert.AreEqual(ChessColor.White, gb.squares[0, 7].Piece.Color);
gb.MovePiece(gb.squares[2, 5], gb.squares[2, 6]);
Assert.AreEqual(false, ml.MovePiece(gb.squares[0, 4], gb.squares[0, 6]));
Assert.AreEqual(ChessPiece.King, gb.squares[0, 4].Piece.Type);
Assert.AreEqual(ChessColor.White, gb.squares[0, 4].Piece.Color);
Assert.AreEqual(ChessPiece.Rook, gb.squares[0, 7].Piece.Type);
Assert.AreEqual(ChessColor.White, gb.squares[0, 7].Piece.Color);
}
public void BlackEnPassantTest()
{
GameBoard gb = new GameBoard(8, 8);
MoveLogic ml = new MoveLogic(gb);
gb.MovePiece(gb.squares[1, 1], gb.squares[4, 1]);
ml.MovePiece(gb.squares[6, 0], gb.squares[4, 0]);
ml.MovePiece(gb.squares[4, 1], gb.squares[5, 0]);
Assert.AreEqual(ChessColor.White, gb.squares[5, 0].Piece.Color);
Assert.IsNull(gb.squares[4, 0].Piece);
gb.MovePiece(gb.squares[1, 2], gb.squares[4, 2]);
ml.MovePiece(gb.squares[6, 1], gb.squares[4, 1]);
ml.MovePiece(gb.squares[0, 0], gb.squares[1, 0]);
ml.MovePiece(gb.squares[7, 0], gb.squares[6, 0]);
ml.MovePiece(gb.squares[4, 2], gb.squares[5, 1]);
Assert.AreEqual(ChessColor.White, gb.squares[4, 2].Piece.Color);
Assert.IsNull(gb.squares[5, 1].Piece);
}
