public void TestKnightValidMoves()
{
var fenList = new List <string>()
{
"4k3/8/8/4N3/8/8/8/4K3",
"w",
"KQkq",
"-"
};
var fenPosition = new FENNotationPosition(fenList);
this.CB = new ChessBoard(fenPosition);
var coordinatesExpected = "e5";
var whiteKnight = this.CB[3][4].CurrentPiece;
Assert.IsNotNull(whiteKnight);
Assert.IsInstanceOfType(whiteKnight, typeof(Knight));
Assert.AreEqual(coordinatesExpected, whiteKnight.CurrentCoordinates);
Assert.AreEqual(true, whiteKnight.isWhite);
AssertValidMoves(new List <ValidBoardMove>()
{
new ValidBoardMove(coordinatesExpected, "g6", ValidBoardMove.MovePath.KnightMove),
new ValidBoardMove(coordinatesExpected, "f7", ValidBoardMove.MovePath.KnightMove),
new ValidBoardMove(coordinatesExpected, "d7", ValidBoardMove.MovePath.KnightMove),
new ValidBoardMove(coordinatesExpected, "c6", ValidBoardMove.MovePath.KnightMove),
new ValidBoardMove(coordinatesExpected, "c4", ValidBoardMove.MovePath.KnightMove),
new ValidBoardMove(coordinatesExpected, "d3", ValidBoardMove.MovePath.KnightMove),
new ValidBoardMove(coordinatesExpected, "f3", ValidBoardMove.MovePath.KnightMove),
new ValidBoardMove(coordinatesExpected, "g4", ValidBoardMove.MovePath.KnightMove)
}, whiteKnight.ValidMoves);
}
public Game(string whiteMode, string blackMode, FENNotationPosition fnp) : this()
{
this.whiteMode = whiteMode;
this.blackMode = blackMode;
this.turnNumber = (byte)fnp.TurnNumber;
if (this.whiteMode == "ai" || this.blackMode == "ai")
{
throw new NotImplementedException();
}
this.InitializeGame(fnp);
}
public void TestQueenValidMoves()
{
var fenList = new List <string>()
{
"3k4/8/8/4Q3/8/8/8/4K3",
"w",
"KQkq",
"-"
};
var fenPosition = new FENNotationPosition(fenList);
this.CB = new ChessBoard(fenPosition);
var coordinatesExpected = "e5";
var whiteQueen = this.CB[3][4].CurrentPiece;
Assert.IsNotNull(whiteQueen);
Assert.IsInstanceOfType(whiteQueen, typeof(Queen));
Assert.AreEqual(coordinatesExpected, whiteQueen.CurrentCoordinates);
Assert.AreEqual(true, whiteQueen.isWhite);
AssertValidMoves(new List <ValidBoardMove>()
{
new ValidBoardMove(coordinatesExpected, "e6", ValidBoardMove.MovePath.Up),
new ValidBoardMove(coordinatesExpected, "e7", ValidBoardMove.MovePath.Up),
new ValidBoardMove(coordinatesExpected, "e8", ValidBoardMove.MovePath.Up),
new ValidBoardMove(coordinatesExpected, "e4", ValidBoardMove.MovePath.Down),
new ValidBoardMove(coordinatesExpected, "e3", ValidBoardMove.MovePath.Down),
new ValidBoardMove(coordinatesExpected, "e2", ValidBoardMove.MovePath.Down),
new ValidBoardMove(coordinatesExpected, "d5", ValidBoardMove.MovePath.Left),
new ValidBoardMove(coordinatesExpected, "c5", ValidBoardMove.MovePath.Left),
new ValidBoardMove(coordinatesExpected, "b5", ValidBoardMove.MovePath.Left),
new ValidBoardMove(coordinatesExpected, "a5", ValidBoardMove.MovePath.Left),
new ValidBoardMove(coordinatesExpected, "f5", ValidBoardMove.MovePath.Right),
new ValidBoardMove(coordinatesExpected, "g5", ValidBoardMove.MovePath.Right),
new ValidBoardMove(coordinatesExpected, "h5", ValidBoardMove.MovePath.Right),
new ValidBoardMove(coordinatesExpected, "f6", ValidBoardMove.MovePath.UpRight),
new ValidBoardMove(coordinatesExpected, "g7", ValidBoardMove.MovePath.UpRight),
new ValidBoardMove(coordinatesExpected, "h8", ValidBoardMove.MovePath.UpRight),
new ValidBoardMove(coordinatesExpected, "d6", ValidBoardMove.MovePath.UpLeft),
new ValidBoardMove(coordinatesExpected, "c7", ValidBoardMove.MovePath.UpLeft),
new ValidBoardMove(coordinatesExpected, "b8", ValidBoardMove.MovePath.UpLeft),
new ValidBoardMove(coordinatesExpected, "f4", ValidBoardMove.MovePath.DownRight),
new ValidBoardMove(coordinatesExpected, "g3", ValidBoardMove.MovePath.DownRight),
new ValidBoardMove(coordinatesExpected, "h2", ValidBoardMove.MovePath.DownRight),
new ValidBoardMove(coordinatesExpected, "d4", ValidBoardMove.MovePath.DownLeft),
new ValidBoardMove(coordinatesExpected, "c3", ValidBoardMove.MovePath.DownLeft),
new ValidBoardMove(coordinatesExpected, "b2", ValidBoardMove.MovePath.DownLeft),
new ValidBoardMove(coordinatesExpected, "a1", ValidBoardMove.MovePath.DownLeft),
}, whiteQueen.ValidMoves);
}
public void TestOneRookPinned()
{
var fenList = new List <string>()
{
"8/8/8/KPR2r1k/8/8/8/8",
"w",
"-",
"-"
};
var fenPosition = new FENNotationPosition(fenList);
this.CB = new ChessBoard(fenPosition);
var whiteCoordinatesExpected = "c5";
var whiteRook = this.CB[3][2].CurrentPiece;
Assert.IsNotNull(whiteRook);
Assert.IsInstanceOfType(whiteRook, typeof(Rook));
Assert.AreEqual(whiteCoordinatesExpected, whiteRook.CurrentCoordinates);
Assert.AreEqual(true, whiteRook.isWhite);
AssertValidMoves(new List <ValidBoardMove>()
{
new ValidBoardMove(whiteCoordinatesExpected, "d5", ValidBoardMove.MovePath.Right),
new ValidBoardMove(whiteCoordinatesExpected, "e5", ValidBoardMove.MovePath.Right),
new ValidBoardMove(whiteCoordinatesExpected, "f5", ValidBoardMove.MovePath.Right),
new ValidBoardMove(whiteCoordinatesExpected, "c1", ValidBoardMove.MovePath.Down),
new ValidBoardMove(whiteCoordinatesExpected, "c2", ValidBoardMove.MovePath.Down),
new ValidBoardMove(whiteCoordinatesExpected, "c3", ValidBoardMove.MovePath.Down),
new ValidBoardMove(whiteCoordinatesExpected, "c4", ValidBoardMove.MovePath.Down),
new ValidBoardMove(whiteCoordinatesExpected, "c6", ValidBoardMove.MovePath.Up),
new ValidBoardMove(whiteCoordinatesExpected, "c7", ValidBoardMove.MovePath.Up),
new ValidBoardMove(whiteCoordinatesExpected, "c8", ValidBoardMove.MovePath.Up),
}, whiteRook.ValidMoves);
var blackCoordinatesExpected = "f5";
var blackRook = this.CB[3][5].CurrentPiece;
Assert.IsNotNull(blackRook);
Assert.IsInstanceOfType(blackRook, typeof(Rook));
Assert.AreEqual(blackCoordinatesExpected, blackRook.CurrentCoordinates);
Assert.AreEqual(false, blackRook.isWhite);
AssertValidMoves(new List <ValidBoardMove>()
{
new ValidBoardMove(blackCoordinatesExpected, "e5", ValidBoardMove.MovePath.Left),
new ValidBoardMove(blackCoordinatesExpected, "d5", ValidBoardMove.MovePath.Left),
new ValidBoardMove(blackCoordinatesExpected, "c5", ValidBoardMove.MovePath.Left),
new ValidBoardMove(blackCoordinatesExpected, "g5", ValidBoardMove.MovePath.Right)
}, blackRook.ValidMoves);
}
public void TestDoubleQueenPin()
{
var fenList = new List <string>()
{
"rnb1kbnr/pppp1ppp/4q3/8/8/4Q3/PPPP1PPP/RNB1KBNR w KQkq",
"w",
"KQkq",
"-",
"1",
"1"
};
var fenPosition = new FENNotationPosition(fenList);
this.CB = new ChessBoard(fenPosition);
var blackQueen = this.CB[2][4].CurrentPiece;
Assert.IsNotNull(blackQueen);
Assert.IsInstanceOfType(blackQueen, typeof(Queen));
Assert.AreEqual("e6", blackQueen.CurrentCoordinates);
Assert.AreEqual(false, blackQueen.isWhite);
AssertValidMoves(new List <ValidBoardMove>()
{
new ValidBoardMove("e6", "e7", ValidBoardMove.MovePath.Up),
new ValidBoardMove("e6", "e5", ValidBoardMove.MovePath.Down),
new ValidBoardMove("e6", "e4", ValidBoardMove.MovePath.Down),
new ValidBoardMove("e6", "e3", ValidBoardMove.MovePath.Down)
}, blackQueen.ValidMoves);
var whiteQueen = this.CB[5][4].CurrentPiece;
Assert.IsNotNull(whiteQueen);
Assert.IsInstanceOfType(whiteQueen, typeof(Queen));
Assert.AreEqual("e3", whiteQueen.CurrentCoordinates);
Assert.AreEqual(true, whiteQueen.isWhite);
AssertValidMoves(new List <ValidBoardMove>()
{
new ValidBoardMove("e3", "e2", ValidBoardMove.MovePath.Down),
new ValidBoardMove("e3", "e4", ValidBoardMove.MovePath.Up),
new ValidBoardMove("e3", "e5", ValidBoardMove.MovePath.Up),
new ValidBoardMove("e3", "e6", ValidBoardMove.MovePath.Up)
}, whiteQueen.ValidMoves);
}
public void TestPinnedBishopsDLUR()
{
var fenList = new List <string>()
{
"7k/8/5b2/8/8/2B5/8/K7",
"w",
"-",
"-"
};
var fenPosition = new FENNotationPosition(fenList);
this.CB = new ChessBoard(fenPosition);
var whiteCoordinatesExpected = "c3";
var whiteBishop = this.CB[5][2].CurrentPiece;
Assert.IsNotNull(whiteBishop);
Assert.IsInstanceOfType(whiteBishop, typeof(Bishop));
Assert.AreEqual(whiteCoordinatesExpected, whiteBishop.CurrentCoordinates);
Assert.AreEqual(true, whiteBishop.isWhite);
AssertValidMoves(new List <ValidBoardMove>()
{
new ValidBoardMove(whiteCoordinatesExpected, "b2", ValidBoardMove.MovePath.DownLeft),
new ValidBoardMove(whiteCoordinatesExpected, "d4", ValidBoardMove.MovePath.UpRight),
new ValidBoardMove(whiteCoordinatesExpected, "e5", ValidBoardMove.MovePath.UpRight),
new ValidBoardMove(whiteCoordinatesExpected, "f6", ValidBoardMove.MovePath.UpRight)
}, whiteBishop.ValidMoves);
var blackCoordinatesExpected = "f6";
var blackBishop = this.CB[2][5].CurrentPiece;
Assert.IsNotNull(blackBishop);
Assert.IsInstanceOfType(blackBishop, typeof(Bishop));
Assert.AreEqual(blackCoordinatesExpected, blackBishop.CurrentCoordinates);
Assert.AreEqual(false, blackBishop.isWhite);
AssertValidMoves(new List <ValidBoardMove>()
{
new ValidBoardMove(blackCoordinatesExpected, "e5", ValidBoardMove.MovePath.DownLeft),
new ValidBoardMove(blackCoordinatesExpected, "d4", ValidBoardMove.MovePath.DownLeft),
new ValidBoardMove(blackCoordinatesExpected, "c3", ValidBoardMove.MovePath.DownLeft),
new ValidBoardMove(blackCoordinatesExpected, "g7", ValidBoardMove.MovePath.UpRight)
}, blackBishop.ValidMoves);
}
public void TestBishopValidMoves()
{
var fenList = new List <string>()
{
"4k3/8/8/4B3/8/8/8/4K3",
"w",
"KQkq",
"-"
};
var fenPosition = new FENNotationPosition(fenList);
this.CB = new ChessBoard(fenPosition);
var coordinatesExpected = "e5";
var whiteBishop = this.CB[3][4].CurrentPiece;
Assert.IsNotNull(whiteBishop);
Assert.IsInstanceOfType(whiteBishop, typeof(Bishop));
Assert.AreEqual(coordinatesExpected, whiteBishop.CurrentCoordinates);
Assert.AreEqual(true, whiteBishop.isWhite);
AssertValidMoves(new List <ValidBoardMove>()
{
new ValidBoardMove(coordinatesExpected, "f6", ValidBoardMove.MovePath.UpRight),
new ValidBoardMove(coordinatesExpected, "g7", ValidBoardMove.MovePath.UpRight),
new ValidBoardMove(coordinatesExpected, "h8", ValidBoardMove.MovePath.UpRight),
new ValidBoardMove(coordinatesExpected, "d6", ValidBoardMove.MovePath.UpLeft),
new ValidBoardMove(coordinatesExpected, "c7", ValidBoardMove.MovePath.UpLeft),
new ValidBoardMove(coordinatesExpected, "b8", ValidBoardMove.MovePath.UpLeft),
new ValidBoardMove(coordinatesExpected, "f4", ValidBoardMove.MovePath.DownRight),
new ValidBoardMove(coordinatesExpected, "g3", ValidBoardMove.MovePath.DownRight),
new ValidBoardMove(coordinatesExpected, "h2", ValidBoardMove.MovePath.DownRight),
new ValidBoardMove(coordinatesExpected, "d4", ValidBoardMove.MovePath.DownLeft),
new ValidBoardMove(coordinatesExpected, "c3", ValidBoardMove.MovePath.DownLeft),
new ValidBoardMove(coordinatesExpected, "b2", ValidBoardMove.MovePath.DownLeft),
new ValidBoardMove(coordinatesExpected, "a1", ValidBoardMove.MovePath.DownLeft),
}, whiteBishop.ValidMoves);
}
static void Main(string[] args)
{
Console.Title = "Salisbury Chess Engine v1.0";
InitText(args);
List <string> command = args.ToList();
while (!command.Contains("-q"))
{
if (command.Contains("-help"))
{
DisplayHelp();
continue;
}
var white = command.IndexOf("-white");
var black = command.IndexOf("-black");
if (white == -1)
{
Console.WriteLine("-white (human OR ai) required. /help for all commands");
command = Console.ReadLine().Split(' ').ToList();
continue;
}
if (black == -1)
{
Console.WriteLine("-black (human OR ai) required. /help for all commands");
command = Console.ReadLine().Split(' ').ToList();
continue;
}
var whiteMode = command[white + 1].ToLower();
var blackMode = command[black + 1].ToLower();
if (whiteMode != "human" && whiteMode != "ai")
{
Console.WriteLine("The argument following -white should be (human or ai");
command = Console.ReadLine().Split(' ').ToList();
continue;
}
if (blackMode != "human" && blackMode != "ai")
{
Console.WriteLine("The argument following -black should be (human or ai");
command = Console.ReadLine().Split(' ').ToList();
continue;
}
//init fen parser -- need a way to import custom board states.
var fen = command.IndexOf("-fen");
if (fen > -1)
{
const int FEN_FIELD_LENGTH = 6;
var fenContents = command.GetRange(fen + 1, FEN_FIELD_LENGTH); //important that we do not ToLower here. We need the exact string contents
FENNotationPosition fnp = new FENNotationPosition(fenContents);
var game = new Game(whiteMode, blackMode, fnp);
return;
}
else
{
var game = new Game(whiteMode, blackMode);
}
command = Console.ReadLine().Split(' ').ToList();
}
}
private void InitializeGame(FENNotationPosition fnp)
{
this.cb = new ChessBoard(fnp);
this.Begin();
}
public void InitializeBoard(FENNotationPosition fen)
{
this.InitializeCells();
this.CreatePieceFactory(fen);
}
public ChessBoard(FENNotationPosition fen) : this()
{
this.InitializeBoard(fen);
this.InitializeKingComponents();
this.UpdateBoardState();
}
