public void PieceAtBoardPositionTests() { //"r1bq1rk1/pp3ppp/3b1n2/3pN3/8/3B4/PPPN1PPP/R1BQ1RK1 b - - 0 11"; // This method assumes the FEN is already expanded on the correct rank, so just expand the // whole thing for the tests. Expansion has its own tests. string expandedFEN = "r1bq1rk1/pp111ppp/111b1n11/111pN111/11111111/111B1111/PPPN1PPP/R1BQ1RK1 b - - 0 11"; // Board position (WHITE IS UPPERCASE) // +---+---+---+---+---+---+---+---+ // | r | | b | q | | r | k | | // +---+---+---+---+---+---+---+---+ // | p | p | | | | p | p | p | // +---+---+---+---+---+---+---+---+ // | | | | b | | n | | | // +---+---+---+---+---+---+---+---+ // | | | | p | N | | | | // +---+---+---+---+---+---+---+---+ // | | | | | | | | | // +---+---+---+---+---+---+---+---+ // | | | | B | | | | | // +---+---+---+---+---+---+---+---+ // | P | P | P | N | | P | P | P | // +---+---+---+---+---+---+---+---+ // | R | | B | Q | | R | K | | // +---+---+---+---+---+---+---+---+ // File, Rank, Expected Tuple <int, int, char>[] testData = { new Tuple <int, int, char>(1, 1, 'R'), new Tuple <int, int, char>(3, 1, 'B'), new Tuple <int, int, char>(4, 1, 'Q'), new Tuple <int, int, char>(6, 1, 'R'), new Tuple <int, int, char>(7, 1, 'K'), new Tuple <int, int, char>(1, 2, 'P'), new Tuple <int, int, char>(2, 2, 'P'), new Tuple <int, int, char>(3, 2, 'P'), new Tuple <int, int, char>(4, 2, 'N'), new Tuple <int, int, char>(5, 2, '1'), // Empty space since expanded new Tuple <int, int, char>(6, 2, 'P'), new Tuple <int, int, char>(7, 2, 'P'), new Tuple <int, int, char>(8, 2, 'P'), new Tuple <int, int, char>(4, 3, 'B'), new Tuple <int, int, char>(4, 5, 'p'), new Tuple <int, int, char>(5, 5, 'N'), new Tuple <int, int, char>(4, 6, 'b'), new Tuple <int, int, char>(6, 6, 'n'), new Tuple <int, int, char>(1, 8, 'r'), new Tuple <int, int, char>(8, 8, '1'), }; foreach (Tuple <int, int, char> tuple in testData) { Trace.WriteLine(String.Format("Veriying {0} found at [{1}:{2}]", tuple.Item3, tuple.Item1, tuple.Item2)); Assert.AreEqual(tuple.Item3, FenParser.PieceAtBoardPosition(expandedFEN, tuple.Item1, tuple.Item2)); } }
public GameHub(IGameRepository gameRepository, IMoveValidator moveValidator, IMoveHandler moveHandler, CoordinateNotationParser coordinateNotationParser, FenParser fenParser, ILogger <GameHub> logger) { _gameRepository = gameRepository; _moveValidator = moveValidator; _moveHandler = moveHandler; _coordinateNotationParser = coordinateNotationParser; _fenParser = fenParser; _logger = logger; }
public void ExpandRankTests() { string[] testFENS = { "rnbqkbnr/pppppppp/8/8/3P4/8/PPP1PPPP/RNBQKBNR b KQkq - 0 1", "rnbqkb1r/pp3ppp/2p1pn2/6B1/2pP4/2N1PN2/PP3PPP/R2QKB1R b KQkq - 0 6", "rnb1kb1r/pp3ppp/2p1pn2/3p4/3PP3/3BBN2/PqPN1PPP/R2QK2R w KQkq - 2 7", }; // index to testFENS, rank to expand, expected result Tuple <int, int, string>[] testData = { // Expand each rank and check it // 0 new Tuple <int, int, string>(0, 8, "rnbqkbnr/pppppppp/8/8/3P4/8/PPP1PPPP/RNBQKBNR b KQkq - 0 1"), new Tuple <int, int, string>(0, 7, "rnbqkbnr/pppppppp/8/8/3P4/8/PPP1PPPP/RNBQKBNR b KQkq - 0 1"), new Tuple <int, int, string>(0, 6, "rnbqkbnr/pppppppp/11111111/8/3P4/8/PPP1PPPP/RNBQKBNR b KQkq - 0 1"), new Tuple <int, int, string>(0, 5, "rnbqkbnr/pppppppp/8/11111111/3P4/8/PPP1PPPP/RNBQKBNR b KQkq - 0 1"), new Tuple <int, int, string>(0, 4, "rnbqkbnr/pppppppp/8/8/111P1111/8/PPP1PPPP/RNBQKBNR b KQkq - 0 1"), new Tuple <int, int, string>(0, 3, "rnbqkbnr/pppppppp/8/8/3P4/11111111/PPP1PPPP/RNBQKBNR b KQkq - 0 1"), new Tuple <int, int, string>(0, 2, "rnbqkbnr/pppppppp/8/8/3P4/8/PPP1PPPP/RNBQKBNR b KQkq - 0 1"), new Tuple <int, int, string>(0, 1, "rnbqkbnr/pppppppp/8/8/3P4/8/PPP1PPPP/RNBQKBNR b KQkq - 0 1"), // 1 new Tuple <int, int, string>(1, 8, "rnbqkb1r/pp3ppp/2p1pn2/6B1/2pP4/2N1PN2/PP3PPP/R2QKB1R b KQkq - 0 6"), new Tuple <int, int, string>(1, 7, "rnbqkb1r/pp111ppp/2p1pn2/6B1/2pP4/2N1PN2/PP3PPP/R2QKB1R b KQkq - 0 6"), new Tuple <int, int, string>(1, 6, "rnbqkb1r/pp3ppp/11p1pn11/6B1/2pP4/2N1PN2/PP3PPP/R2QKB1R b KQkq - 0 6"), new Tuple <int, int, string>(1, 5, "rnbqkb1r/pp3ppp/2p1pn2/111111B1/2pP4/2N1PN2/PP3PPP/R2QKB1R b KQkq - 0 6"), new Tuple <int, int, string>(1, 4, "rnbqkb1r/pp3ppp/2p1pn2/6B1/11pP1111/2N1PN2/PP3PPP/R2QKB1R b KQkq - 0 6"), new Tuple <int, int, string>(1, 3, "rnbqkb1r/pp3ppp/2p1pn2/6B1/2pP4/11N1PN11/PP3PPP/R2QKB1R b KQkq - 0 6"), new Tuple <int, int, string>(1, 2, "rnbqkb1r/pp3ppp/2p1pn2/6B1/2pP4/2N1PN2/PP111PPP/R2QKB1R b KQkq - 0 6"), new Tuple <int, int, string>(1, 1, "rnbqkb1r/pp3ppp/2p1pn2/6B1/2pP4/2N1PN2/PP3PPP/R11QKB1R b KQkq - 0 6"), // 2 new Tuple <int, int, string>(2, 8, "rnb1kb1r/pp3ppp/2p1pn2/3p4/3PP3/3BBN2/PqPN1PPP/R2QK2R w KQkq - 2 7"), new Tuple <int, int, string>(2, 7, "rnb1kb1r/pp111ppp/2p1pn2/3p4/3PP3/3BBN2/PqPN1PPP/R2QK2R w KQkq - 2 7"), new Tuple <int, int, string>(2, 6, "rnb1kb1r/pp3ppp/11p1pn11/3p4/3PP3/3BBN2/PqPN1PPP/R2QK2R w KQkq - 2 7"), new Tuple <int, int, string>(2, 5, "rnb1kb1r/pp3ppp/2p1pn2/111p1111/3PP3/3BBN2/PqPN1PPP/R2QK2R w KQkq - 2 7"), new Tuple <int, int, string>(2, 4, "rnb1kb1r/pp3ppp/2p1pn2/3p4/111PP111/3BBN2/PqPN1PPP/R2QK2R w KQkq - 2 7"), new Tuple <int, int, string>(2, 3, "rnb1kb1r/pp3ppp/2p1pn2/3p4/3PP3/111BBN11/PqPN1PPP/R2QK2R w KQkq - 2 7"), new Tuple <int, int, string>(2, 2, "rnb1kb1r/pp3ppp/2p1pn2/3p4/3PP3/3BBN2/PqPN1PPP/R2QK2R w KQkq - 2 7"), new Tuple <int, int, string>(2, 1, "rnb1kb1r/pp3ppp/2p1pn2/3p4/3PP3/3BBN2/PqPN1PPP/R11QK11R w KQkq - 2 7"), }; foreach (Tuple <int, int, string> tuple in testData) { string result = FenParser.ExpandRank(testFENS[tuple.Item1], tuple.Item2); Trace.WriteLine(String.Format("Verifying {0} @ {1} => {2}", testFENS[tuple.Item1], tuple.Item2, tuple.Item3)); Assert.IsTrue(String.Compare(result, tuple.Item3) == 0); } }
public void CollapseRankTests() { string[] testFENS = { "rnbqkbnr/pppppppp/8/8/3P4/8/PPP1PPPP/RNBQKBNR b KQkq - 0 1", "rnbqkb1r/pp3ppp/2p1pn2/6B1/2pP4/2N1PN2/PP3PPP/R2QKB1R b KQkq - 0 6", "rnb1kb1r/pp3ppp/2p1pn2/3p4/3PP3/3BBN2/PqPN1PPP/R2QK2R w KQkq - 2 7", }; // input, rank, expected index Tuple <string, int, int>[] testData = { new Tuple <string, int, int>("rnbqkbnr/pppppppp/8/8/3P4/8/PPP1PPPP/RNBQKBNR b KQkq - 0 1", 8, 0), new Tuple <string, int, int>("rnbqkbnr/pppppppp/8/8/3P4/8/PPP1PPPP/RNBQKBNR b KQkq - 0 1", 7, 0), new Tuple <string, int, int>("rnbqkbnr/pppppppp/11111111/8/3P4/8/PPP1PPPP/RNBQKBNR b KQkq - 0 1", 6, 0), new Tuple <string, int, int>("rnbqkbnr/pppppppp/8/11111111/3P4/8/PPP1PPPP/RNBQKBNR b KQkq - 0 1", 5, 0), new Tuple <string, int, int>("rnbqkbnr/pppppppp/8/8/111P1111/8/PPP1PPPP/RNBQKBNR b KQkq - 0 1", 4, 0), new Tuple <string, int, int>("rnbqkbnr/pppppppp/8/8/3P4/11111111/PPP1PPPP/RNBQKBNR b KQkq - 0 1", 3, 0), new Tuple <string, int, int>("rnbqkbnr/pppppppp/8/8/3P4/8/PPP1PPPP/RNBQKBNR b KQkq - 0 1", 2, 0), new Tuple <string, int, int>("rnbqkbnr/pppppppp/8/8/3P4/8/PPP1PPPP/RNBQKBNR b KQkq - 0 1", 1, 0), new Tuple <string, int, int>("rnbqkb1r/pp3ppp/2p1pn2/6B1/2pP4/2N1PN2/PP3PPP/R2QKB1R b KQkq - 0 6", 8, 1), new Tuple <string, int, int>("rnbqkb1r/pp111ppp/2p1pn2/6B1/2pP4/2N1PN2/PP3PPP/R2QKB1R b KQkq - 0 6", 7, 1), new Tuple <string, int, int>("rnbqkb1r/pp3ppp/11p1pn11/6B1/2pP4/2N1PN2/PP3PPP/R2QKB1R b KQkq - 0 6", 6, 1), new Tuple <string, int, int>("rnbqkb1r/pp3ppp/2p1pn2/111111B1/2pP4/2N1PN2/PP3PPP/R2QKB1R b KQkq - 0 6", 5, 1), new Tuple <string, int, int>("rnbqkb1r/pp3ppp/2p1pn2/6B1/11pP1111/2N1PN2/PP3PPP/R2QKB1R b KQkq - 0 6", 4, 1), new Tuple <string, int, int>("rnbqkb1r/pp3ppp/2p1pn2/6B1/2pP4/11N1PN11/PP3PPP/R2QKB1R b KQkq - 0 6", 3, 1), new Tuple <string, int, int>("rnbqkb1r/pp3ppp/2p1pn2/6B1/2pP4/2N1PN2/PP111PPP/R2QKB1R b KQkq - 0 6", 2, 1), new Tuple <string, int, int>("rnbqkb1r/pp3ppp/2p1pn2/6B1/2pP4/2N1PN2/PP3PPP/R11QKB1R b KQkq - 0 6", 1, 1), new Tuple <string, int, int>("rnb1kb1r/pp3ppp/2p1pn2/3p4/3PP3/3BBN2/PqPN1PPP/R2QK2R w KQkq - 2 7", 8, 2), new Tuple <string, int, int>("rnb1kb1r/pp111ppp/2p1pn2/3p4/3PP3/3BBN2/PqPN1PPP/R2QK2R w KQkq - 2 7", 7, 2), new Tuple <string, int, int>("rnb1kb1r/pp3ppp/11p1pn11/3p4/3PP3/3BBN2/PqPN1PPP/R2QK2R w KQkq - 2 7", 6, 2), new Tuple <string, int, int>("rnb1kb1r/pp3ppp/2p1pn2/111p1111/3PP3/3BBN2/PqPN1PPP/R2QK2R w KQkq - 2 7", 5, 2), new Tuple <string, int, int>("rnb1kb1r/pp3ppp/2p1pn2/3p4/111PP111/3BBN2/PqPN1PPP/R2QK2R w KQkq - 2 7", 4, 2), new Tuple <string, int, int>("rnb1kb1r/pp3ppp/2p1pn2/3p4/3PP3/111BBN11/PqPN1PPP/R2QK2R w KQkq - 2 7", 3, 2), new Tuple <string, int, int>("rnb1kb1r/pp3ppp/2p1pn2/3p4/3PP3/3BBN2/PqPN1PPP/R2QK2R w KQkq - 2 7", 2, 2), new Tuple <string, int, int>("rnb1kb1r/pp3ppp/2p1pn2/3p4/3PP3/3BBN2/PqPN1PPP/R11QK11R w KQkq - 2 7", 1, 2), }; foreach (Tuple <string, int, int> tuple in testData) { string result = FenParser.CollapseRank(tuple.Item1, tuple.Item2); Trace.WriteLine(String.Format("Verifying {0} @ {1} => {2} : {3}", tuple.Item1, tuple.Item2, testFENS[tuple.Item3], result)); Assert.IsTrue(String.Compare(result, testFENS[tuple.Item3]) == 0); } }
public void RemovePieceTests() { //"r3r1k1/p2b1ppp/1p1q1n2/3p4/2P5/3BRN1P/PP1Q1PP1/R5K1 w - - 0 19"; string expandedFEN = "r111r1k1/p11b1ppp/1p1q1n11/111p1111/11P11111/111BRN1P/PP1Q1PP1/R11111K1 w - - 0 19"; // +---+---+---+---+---+---+---+---+ // | r | | | | r | | k | | // +---+---+---+---+---+---+---+---+ // | p | | | b | | p | p | p | // +---+---+---+---+---+---+---+---+ // | | p | | q | | n | | | // +---+---+---+---+---+---+---+---+ // | | | | p | | | | | // +---+---+---+---+---+---+---+---+ // | | | P | | | | | | // +---+---+---+---+---+---+---+---+ // | | | | B | R | N | | P | // +---+---+---+---+---+---+---+---+ // | P | P | | Q | | P | P | | // +---+---+---+---+---+---+---+---+ // | R | | | | | | K | | // +---+---+---+---+---+---+---+---+ // file, rank, expectedChar, expectedFEN Tuple <int, int, char, string>[] testData = { new Tuple <int, int, char, string>(1, 1, 'R', "r111r1k1/p11b1ppp/1p1q1n11/111p1111/11P11111/111BRN1P/PP1Q1PP1/111111K1 w - - 0 19"), new Tuple <int, int, char, string>(2, 1, '1', "r111r1k1/p11b1ppp/1p1q1n11/111p1111/11P11111/111BRN1P/PP1Q1PP1/R11111K1 w - - 0 19"), new Tuple <int, int, char, string>(4, 7, 'b', "r111r1k1/p1111ppp/1p1q1n11/111p1111/11P11111/111BRN1P/PP1Q1PP1/R11111K1 w - - 0 19"), new Tuple <int, int, char, string>(7, 1, 'K', "r111r1k1/p11b1ppp/1p1q1n11/111p1111/11P11111/111BRN1P/PP1Q1PP1/R1111111 w - - 0 19"), new Tuple <int, int, char, string>(1, 4, '1', "r111r1k1/p11b1ppp/1p1q1n11/111p1111/11P11111/111BRN1P/PP1Q1PP1/R11111K1 w - - 0 19"), new Tuple <int, int, char, string>(8, 8, '1', "r111r1k1/p11b1ppp/1p1q1n11/111p1111/11P11111/111BRN1P/PP1Q1PP1/R11111K1 w - - 0 19"), }; foreach (Tuple <int, int, char, string> tuple in testData) { char fenChar; Trace.WriteLine(String.Format("Verifying Remove @ [{0}:{1}] is '{2}', new fen is {3}", tuple.Item1, tuple.Item2, tuple.Item3, tuple.Item4)); string newFEN = FenParser.RemovePiece(expandedFEN, tuple.Item1, tuple.Item2, out fenChar); Assert.IsTrue(String.Compare(newFEN, tuple.Item4) == 0); Assert.AreEqual(fenChar, tuple.Item3); } }
public void InsertPieceTests() { // Note this is raw manipulation of the string, not logic, i.e. inserting a piece // with this method does not have side effects like updating the move counts or // castling rights //"r3r1k1/p2b1ppp/1p1q1n2/3p4/2P5/3BRN1P/PP1Q1PP1/R5K1 w - - 0 19"; string expandedFEN = "r111r1k1/p11b1ppp/1p1q1n11/111p1111/11P11111/111BRN1P/PP1Q1PP1/R11111K1 w - - 0 19"; // +---+---+---+---+---+---+---+---+ // | r | | | | r | | k | | // +---+---+---+---+---+---+---+---+ // | p | | | b | | p | p | p | // +---+---+---+---+---+---+---+---+ // | | p | | q | | n | | | // +---+---+---+---+---+---+---+---+ // | | | | p | | | | | // +---+---+---+---+---+---+---+---+ // | | | P | | | | | | // +---+---+---+---+---+---+---+---+ // | | | | B | R | N | | P | // +---+---+---+---+---+---+---+---+ // | P | P | | Q | | P | P | | // +---+---+---+---+---+---+---+---+ // | R | | | | | | K | | // +---+---+---+---+---+---+---+---+ // Piece, file, rank, expected Tuple <char, int, int, string>[] testData = { new Tuple <char, int, int, string>('Q', 3, 1, "r111r1k1/p11b1ppp/1p1q1n11/111p1111/11P11111/111BRN1P/PP1Q1PP1/R1Q111K1 w - - 0 19"), new Tuple <char, int, int, string>('P', 2, 8, "rP11r1k1/p11b1ppp/1p1q1n11/111p1111/11P11111/111BRN1P/PP1Q1PP1/R11111K1 w - - 0 19"), new Tuple <char, int, int, string>('b', 5, 5, "r111r1k1/p11b1ppp/1p1q1n11/111pb111/11P11111/111BRN1P/PP1Q1PP1/R11111K1 w - - 0 19"), }; foreach (Tuple <char, int, int, string> tuple in testData) { Trace.WriteLine(String.Format("Verifying piece '{0}' inserted at [{1}:{2}] => {3}", tuple.Item1, tuple.Item2, tuple.Item3, tuple.Item4)); Assert.IsTrue(String.Compare(FenParser.InsertPiece(expandedFEN, tuple.Item1, tuple.Item2, tuple.Item3), tuple.Item4) == 0); } }
// create a board with a FEN string public Board(string fen) { Match Match = FenParser.Match(fen); if (!Match.Success) { throw new ArgumentException(string.Format("invalid FEN string \"{0}\"", fen)); } // piece placement string Field = Match.Groups[1].Value; string[] RankPlacement = Field.Split('/'); BoardAddress Location; int File; Pieces = new PiecePositions(); for (int rank = 0; rank < 8; rank++) { File = 0; foreach (char c in RankPlacement[7 - rank]) { Location = new BoardAddress((char)('a' + File), rank); switch (c) { case 'p': Pieces.Black.Pawns |= Location.Position; break; case 'P': Pieces.White.Pawns |= Location.Position; break; case 'n': Pieces.Black.Knights |= Location.Position; break; case 'N': Pieces.White.Knights |= Location.Position; break; case 'b': Pieces.Black.Bishops |= Location.Position; break; case 'B': Pieces.White.Bishops |= Location.Position; break; case 'r': Pieces.Black.Rooks |= Location.Position; break; case 'R': Pieces.White.Rooks |= Location.Position; break; case 'q': Pieces.Black.Queens |= Location.Position; break; case 'Q': Pieces.White.Queens |= Location.Position; break; case 'k': Pieces.Black.King |= Location.Position; break; case 'K': Pieces.White.King |= Location.Position; break; default: // num empty spaces if (!char.IsDigit(c)) { throw new ArgumentException(string.Format("invalid character \"{0}\" in piece placement field", c)); } File += c - '1'; // convert char to int break; } File++; } } // active color Field = Match.Groups[2].Value.ToLower(); if (Field == "w") { ActiveColorWhite = true; } else { ActiveColorWhite = false; } // castling availablity CastlingAvailability = new Castling(); Field = Match.Groups[3].Value; if (Field == "-") // not available { CastlingAvailability.White = Castling.Move.Disallowed; CastlingAvailability.Black = Castling.Move.Disallowed; } else // available to at least one player // check white { if (Field.Contains("K") && Field.Contains("Q")) { CastlingAvailability.White = Castling.Move.BothSides; } else if (Field.Contains("K")) { CastlingAvailability.White = Castling.Move.KingSide; } else if (Field.Contains("Q")) { CastlingAvailability.White = Castling.Move.QueenSide; } else { CastlingAvailability.White = Castling.Move.Disallowed; } // check black if (Field.Contains("k") && Field.Contains("q")) { CastlingAvailability.Black = Castling.Move.BothSides; } else if (Field.Contains("k")) { CastlingAvailability.Black = Castling.Move.KingSide; } else if (Field.Contains("q")) { CastlingAvailability.Black = Castling.Move.QueenSide; } else { CastlingAvailability.Black = Castling.Move.Disallowed; } } // enpassant location Field = Match.Groups[4].Value; if (Field == "-") { EnPassantTarget = 0; } else { EnPassantTarget = new BoardAddress(Field).Position; } // halfmove clock Field = Match.Groups[5].Value; if (!byte.TryParse(Field, out HalfMoveClock)) { throw new ArgumentException(string.Format("could not parse halfmove clock \"{0}\"", Field)); } // halfmove clock Field = Match.Groups[6].Value; if (!int.TryParse(Field, out FullMoveNumber)) { throw new ArgumentException(string.Format("could not parse full move number \"{0}\"", Field)); } }
public FenParserTests() { Parser = new FenParser(TestFenString); }
public void Setup() { _parser = new FenParser(); }
public void Setup() { _moveValidator = new MoveValidator(); _fenParser = new FenParser(); }
public MoveHandlerTests() { _moveHandler = new MoveHandler(); _coordinateNotationParser = new CoordinateNotationParser(); _fenParser = new FenParser(); }
public void BeforeFirstTest() { _parser = new FenParser(); }
public void ApplyMoveToFENTests() { // This is the method meant to be called by clients for the most // part and does take side-effects into account, such as captures, // promotions, castlings, updating the move count and active player, etc // You should be able to replay a game by applying moves repeatedly string initialFEN = ChessBoard.InitialFENPosition; // These assume starting from the standard position with white // "san move", "expected new FEN" Tuple <string, string>[] testData = { // Records from a game where stockfish 8 played itself (plus some forced moves to test promotion) new Tuple <string, string>("d2d4", "rnbqkbnr/pppppppp/8/8/3P4/8/PPP1PPPP/RNBQKBNR b KQkq - 0 1"), new Tuple <string, string>("d7d5", "rnbqkbnr/ppp1pppp/8/3p4/3P4/8/PPP1PPPP/RNBQKBNR w KQkq - 0 2"), new Tuple <string, string>("c2c4", "rnbqkbnr/ppp1pppp/8/3p4/2PP4/8/PP2PPPP/RNBQKBNR b KQkq - 0 2"), new Tuple <string, string>("e7e6", "rnbqkbnr/ppp2ppp/4p3/3p4/2PP4/8/PP2PPPP/RNBQKBNR w KQkq - 0 3"), new Tuple <string, string>("g1f3", "rnbqkbnr/ppp2ppp/4p3/3p4/2PP4/5N2/PP2PPPP/RNBQKB1R b KQkq - 1 3"), new Tuple <string, string>("g8f6", "rnbqkb1r/ppp2ppp/4pn2/3p4/2PP4/5N2/PP2PPPP/RNBQKB1R w KQkq - 2 4"), new Tuple <string, string>("b1c3", "rnbqkb1r/ppp2ppp/4pn2/3p4/2PP4/2N2N2/PP2PPPP/R1BQKB1R b KQkq - 3 4"), new Tuple <string, string>("c7c6", "rnbqkb1r/pp3ppp/2p1pn2/3p4/2PP4/2N2N2/PP2PPPP/R1BQKB1R w KQkq - 0 5"), new Tuple <string, string>("e2e3", "rnbqkb1r/pp3ppp/2p1pn2/3p4/2PP4/2N1PN2/PP3PPP/R1BQKB1R b KQkq - 0 5"), new Tuple <string, string>("b8d7", "r1bqkb1r/pp1n1ppp/2p1pn2/3p4/2PP4/2N1PN2/PP3PPP/R1BQKB1R w KQkq - 1 6"), new Tuple <string, string>("f1d3", "r1bqkb1r/pp1n1ppp/2p1pn2/3p4/2PP4/2NBPN2/PP3PPP/R1BQK2R b KQkq - 2 6"), new Tuple <string, string>("d5c4", "r1bqkb1r/pp1n1ppp/2p1pn2/8/2pP4/2NBPN2/PP3PPP/R1BQK2R w KQkq - 0 7"), new Tuple <string, string>("d3c4", "r1bqkb1r/pp1n1ppp/2p1pn2/8/2BP4/2N1PN2/PP3PPP/R1BQK2R b KQkq - 0 7"), new Tuple <string, string>("b7b5", "r1bqkb1r/p2n1ppp/2p1pn2/1p6/2BP4/2N1PN2/PP3PPP/R1BQK2R w KQkq - 0 8"), new Tuple <string, string>("c4e2", "r1bqkb1r/p2n1ppp/2p1pn2/1p6/3P4/2N1PN2/PP2BPPP/R1BQK2R b KQkq - 1 8"), new Tuple <string, string>("c8b7", "r2qkb1r/pb1n1ppp/2p1pn2/1p6/3P4/2N1PN2/PP2BPPP/R1BQK2R w KQkq - 2 9"), new Tuple <string, string>("e1g1", "r2qkb1r/pb1n1ppp/2p1pn2/1p6/3P4/2N1PN2/PP2BPPP/R1BQ1RK1 b kq - 3 9"), new Tuple <string, string>("f8e7", "r2qk2r/pb1nbppp/2p1pn2/1p6/3P4/2N1PN2/PP2BPPP/R1BQ1RK1 w kq - 4 10"), new Tuple <string, string>("a2a3", "r2qk2r/pb1nbppp/2p1pn2/1p6/3P4/P1N1PN2/1P2BPPP/R1BQ1RK1 b kq - 0 10"), new Tuple <string, string>("a7a5", "r2qk2r/1b1nbppp/2p1pn2/pp6/3P4/P1N1PN2/1P2BPPP/R1BQ1RK1 w kq - 0 11"), new Tuple <string, string>("b2b3", "r2qk2r/1b1nbppp/2p1pn2/pp6/3P4/PPN1PN2/4BPPP/R1BQ1RK1 b kq - 0 11"), new Tuple <string, string>("e8g8", "r2q1rk1/1b1nbppp/2p1pn2/pp6/3P4/PPN1PN2/4BPPP/R1BQ1RK1 w - - 1 12"), new Tuple <string, string>("c1b2", "r2q1rk1/1b1nbppp/2p1pn2/pp6/3P4/PPN1PN2/1B2BPPP/R2Q1RK1 b - - 2 12"), new Tuple <string, string>("b5b4", "r2q1rk1/1b1nbppp/2p1pn2/p7/1p1P4/PPN1PN2/1B2BPPP/R2Q1RK1 w - - 0 13"), new Tuple <string, string>("a3b4", "r2q1rk1/1b1nbppp/2p1pn2/p7/1P1P4/1PN1PN2/1B2BPPP/R2Q1RK1 b - - 0 13"), new Tuple <string, string>("a5b4", "r2q1rk1/1b1nbppp/2p1pn2/8/1p1P4/1PN1PN2/1B2BPPP/R2Q1RK1 w - - 0 14"), new Tuple <string, string>("a1a8", "R2q1rk1/1b1nbppp/2p1pn2/8/1p1P4/1PN1PN2/1B2BPPP/3Q1RK1 b - - 0 14"), new Tuple <string, string>("d8a8", "q4rk1/1b1nbppp/2p1pn2/8/1p1P4/1PN1PN2/1B2BPPP/3Q1RK1 w - - 0 15"), new Tuple <string, string>("c3a4", "q4rk1/1b1nbppp/2p1pn2/8/Np1P4/1P2PN2/1B2BPPP/3Q1RK1 b - - 1 15"), new Tuple <string, string>("c6c5", "q4rk1/1b1nbppp/4pn2/2p5/Np1P4/1P2PN2/1B2BPPP/3Q1RK1 w - - 0 16"), new Tuple <string, string>("d4c5", "q4rk1/1b1nbppp/4pn2/2P5/Np6/1P2PN2/1B2BPPP/3Q1RK1 b - - 0 16"), new Tuple <string, string>("d7c5", "q4rk1/1b2bppp/4pn2/2n5/Np6/1P2PN2/1B2BPPP/3Q1RK1 w - - 0 17"), new Tuple <string, string>("a4c5", "q4rk1/1b2bppp/4pn2/2N5/1p6/1P2PN2/1B2BPPP/3Q1RK1 b - - 0 17"), new Tuple <string, string>("e7c5", "q4rk1/1b3ppp/4pn2/2b5/1p6/1P2PN2/1B2BPPP/3Q1RK1 w - - 0 18"), new Tuple <string, string>("d1c2", "q4rk1/1b3ppp/4pn2/2b5/1p6/1P2PN2/1BQ1BPPP/5RK1 b - - 1 18"), new Tuple <string, string>("f8c8", "q1r3k1/1b3ppp/4pn2/2b5/1p6/1P2PN2/1BQ1BPPP/5RK1 w - - 2 19"), new Tuple <string, string>("f1a1", "q1r3k1/1b3ppp/4pn2/2b5/1p6/1P2PN2/1BQ1BPPP/R5K1 b - - 3 19"), new Tuple <string, string>("a8b8", "1qr3k1/1b3ppp/4pn2/2b5/1p6/1P2PN2/1BQ1BPPP/R5K1 w - - 4 20"), new Tuple <string, string>("b2e5", "1qr3k1/1b3ppp/4pn2/2b1B3/1p6/1P2PN2/2Q1BPPP/R5K1 b - - 5 20"), new Tuple <string, string>("c5d6", "1qr3k1/1b3ppp/3bpn2/4B3/1p6/1P2PN2/2Q1BPPP/R5K1 w - - 6 21"), new Tuple <string, string>("c2b2", "1qr3k1/1b3ppp/3bpn2/4B3/1p6/1P2PN2/1Q2BPPP/R5K1 b - - 7 21"), new Tuple <string, string>("d6e5", "1qr3k1/1b3ppp/4pn2/4b3/1p6/1P2PN2/1Q2BPPP/R5K1 w - - 0 22"), new Tuple <string, string>("b2e5", "1qr3k1/1b3ppp/4pn2/4Q3/1p6/1P2PN2/4BPPP/R5K1 b - - 0 22"), new Tuple <string, string>("b8e5", "2r3k1/1b3ppp/4pn2/4q3/1p6/1P2PN2/4BPPP/R5K1 w - - 0 23"), new Tuple <string, string>("f3e5", "2r3k1/1b3ppp/4pn2/4N3/1p6/1P2P3/4BPPP/R5K1 b - - 0 23"), new Tuple <string, string>("c8c3", "6k1/1b3ppp/4pn2/4N3/1p6/1Pr1P3/4BPPP/R5K1 w - - 1 24"), new Tuple <string, string>("e2c4", "6k1/1b3ppp/4pn2/4N3/1pB5/1Pr1P3/5PPP/R5K1 b - - 2 24"), new Tuple <string, string>("g7g5", "6k1/1b3p1p/4pn2/4N1p1/1pB5/1Pr1P3/5PPP/R5K1 w - - 0 25"), new Tuple <string, string>("a1a7", "6k1/Rb3p1p/4pn2/4N1p1/1pB5/1Pr1P3/5PPP/6K1 b - - 1 25"), new Tuple <string, string>("b7d5", "6k1/R4p1p/4pn2/3bN1p1/1pB5/1Pr1P3/5PPP/6K1 w - - 2 26"), new Tuple <string, string>("f2f3", "6k1/R4p1p/4pn2/3bN1p1/1pB5/1Pr1PP2/6PP/6K1 b - - 0 26"), new Tuple <string, string>("d5c4", "6k1/R4p1p/4pn2/4N1p1/1pb5/1Pr1PP2/6PP/6K1 w - - 0 27"), new Tuple <string, string>("b3c4", "6k1/R4p1p/4pn2/4N1p1/1pP5/2r1PP2/6PP/6K1 b - - 0 27"), new Tuple <string, string>("b4b3", "6k1/R4p1p/4pn2/4N1p1/2P5/1pr1PP2/6PP/6K1 w - - 0 28"), new Tuple <string, string>("a7b7", "6k1/1R3p1p/4pn2/4N1p1/2P5/1pr1PP2/6PP/6K1 b - - 1 28"), new Tuple <string, string>("c3c1", "6k1/1R3p1p/4pn2/4N1p1/2P5/1p2PP2/6PP/2r3K1 w - - 2 29"), new Tuple <string, string>("g1f2", "6k1/1R3p1p/4pn2/4N1p1/2P5/1p2PP2/5KPP/2r5 b - - 3 29"), new Tuple <string, string>("b3b2", "6k1/1R3p1p/4pn2/4N1p1/2P5/4PP2/1p3KPP/2r5 w - - 0 30"), new Tuple <string, string>("c4c5", "6k1/1R3p1p/4pn2/2P1N1p1/8/4PP2/1p3KPP/2r5 b - - 0 30"), new Tuple <string, string>("b2b1q", "6k1/1R3p1p/4pn2/2P1N1p1/8/4PP2/5KPP/1qr5 w - - 0 31"), new Tuple <string, string>("b7b1", "6k1/5p1p/4pn2/2P1N1p1/8/4PP2/5KPP/1Rr5 b - - 0 31"), new Tuple <string, string>("c1b1", "6k1/5p1p/4pn2/2P1N1p1/8/4PP2/5KPP/1r6 w - - 0 32"), new Tuple <string, string>("e5d3", "6k1/5p1p/4pn2/2P3p1/8/3NPP2/5KPP/1r6 b - - 1 32"), new Tuple <string, string>("b1d1", "6k1/5p1p/4pn2/2P3p1/8/3NPP2/5KPP/3r4 w - - 2 33"), new Tuple <string, string>("f2e2", "6k1/5p1p/4pn2/2P3p1/8/3NPP2/4K1PP/3r4 b - - 3 33"), new Tuple <string, string>("d1a1", "6k1/5p1p/4pn2/2P3p1/8/3NPP2/4K1PP/r7 w - - 4 34"), new Tuple <string, string>("g2g4", "6k1/5p1p/4pn2/2P3p1/6P1/3NPP2/4K2P/r7 b - - 0 34"), new Tuple <string, string>("a1a2", "6k1/5p1p/4pn2/2P3p1/6P1/3NPP2/r3K2P/8 w - - 1 35"), new Tuple <string, string>("e2e1", "6k1/5p1p/4pn2/2P3p1/6P1/3NPP2/r6P/4K3 b - - 2 35"), new Tuple <string, string>("a2h2", "6k1/5p1p/4pn2/2P3p1/6P1/3NPP2/7r/4K3 w - - 0 36"), new Tuple <string, string>("d3f2", "6k1/5p1p/4pn2/2P3p1/6P1/4PP2/5N1r/4K3 b - - 1 36"), new Tuple <string, string>("f6d5", "6k1/5p1p/4p3/2Pn2p1/6P1/4PP2/5N1r/4K3 w - - 2 37"), new Tuple <string, string>("e3e4", "6k1/5p1p/4p3/2Pn2p1/4P1P1/5P2/5N1r/4K3 b - - 0 37"), new Tuple <string, string>("d5e7", "6k1/4np1p/4p3/2P3p1/4P1P1/5P2/5N1r/4K3 w - - 1 38"), }; string fen = initialFEN; foreach (Tuple <string, string> tuple in testData) { string newFen = FenParser.ApplyMoveToFEN(fen, tuple.Item1); Trace.WriteLine(String.Format("Verify \"{0}\" + \"{1}\" = \"{2}\" Ret: \"{3}\"", fen, tuple.Item1, tuple.Item2, newFen)); Assert.IsTrue(String.Compare(newFen, tuple.Item2) == 0); fen = newFen; } // White knight in position to capture black kingside rook string initialFEN2 = "r1b1kb1r/pp1n1ppp/2p1pnN1/q2p4/2PP4/2N5/PP2PPPP/R1BQKB1R w KQkq - 4 7"; Tuple <string, string>[] testData2 = { new Tuple <string, string>("g6h8", "r1b1kb1N/pp1n1ppp/2p1pn2/q2p4/2PP4/2N5/PP2PPPP/R1BQKB1R b KQq - 0 7"), }; fen = initialFEN2; foreach (Tuple <string, string> tuple in testData2) { string newFen = FenParser.ApplyMoveToFEN(fen, tuple.Item1); Trace.WriteLine(String.Format("Verify \"{0}\" + \"{1}\" = \"{2}\" Ret: \"{3}\"", fen, tuple.Item1, tuple.Item2, newFen)); Assert.IsTrue(String.Compare(newFen, tuple.Item2) == 0); fen = newFen; } }
public FenParserTests() { Parser = new FenParser(TestFenString); ChinaParser = new FenParser(TestChinaFenString, ChessType.ChinaChess); }
public void LoadChilds(Move m, Dictionary <string, DataRow> bookMovesCollection) { CheckAndAddMove(m, bookMovesCollection, false); string tempParentId = ""; bool isInitialFen = FenParser.IsInitialFen(m.Fen, true); if (m.Flags.IsRootMove && isInitialFen) { // if rootMove and initial fen, then CurrentMove's parent is "0" tempParentId = "0"; } else { #region Find Book's CurrentMove's Parent StringBuilder filter = new StringBuilder(); if (!m.Flags.IsRootMove) { filter.Append(BookMove.ColumnMoveNumber + " = " + m.MoveNo); filter.Append(" and " + BookMove.ColumnWhiteMove + " = " + m.White); filter.Append(" and " + BookMove.ColumnFrom + " = '" + m.From + "'"); filter.Append(" and " + BookMove.ColumnTo + " = '" + m.To + "'"); filter.Append(" and "); } filter.Append(BookMove.ColumnFen + " like '" + ChessLibrary.FenParser.GetOnlyFen(m.Fen) + "%'"); DataRow[] rows = this.DataTable.Select(filter.ToString()); if (rows.Length > 0) { tempParentId = rows[0][BookMove.ColumnId].ToString(); } #endregion } if (string.IsNullOrEmpty(tempParentId)) { #region if "tempParentId" not found, set defaultView to not display moves. DataTable.DefaultView.RowFilter = BookMove.ColumnParentId + " = " + -2; if (!AllowMoveAdding) { CheckAndAddMove(m, bookMovesCollection, true); } rowIndex = -1; #endregion } else { if (m.Flags.IsRootMove && isInitialFen) { #region If RootMove and initial fen, then set move to display according to white or black turn string filter = ""; if (m.White == 1) { filter += BookMove.ColumnParentId + " = " + tempParentId; } else { filter += BookMove.ColumnMoveNumber + " = 1"; } filter += " and " + BookMove.ColumnWhiteMove + " = " + m.White; DataTable.DefaultView.RowFilter = filter; #endregion } else { // if parent found(and not rootMove), then load its childs DataTable.DefaultView.RowFilter = BookMove.ColumnParentId + " = " + tempParentId; } // set CurrentParentMoveId to current parent founded. CurrentParentMoveId = BaseItem.ToInt32(tempParentId); #region Set rowIndex if (DataTable.DefaultView.Count > 0) { rowIndex = 0; if (m != null) { for (int i = 0; i < DataTable.DefaultView.Count; i++) { if (m.To == DataTable.DefaultView[i][BookMove.ColumnTo].ToString()) { rowIndex = i; } } } } else { rowIndex = -1; } #endregion } this.DataTable.DefaultView.Sort = BookMove.ColumnWinCount + " Desc"; }
internal static Chessboard LoadPositionFromFenString(string fenString) { return(FenParser.LoadPositionFromFenString(fenString)); }
public FenParserTests() { Parser = new FenParser(TestFenString); }