Example #1
0
        private int PerformCapMoves(string fen)
        {
            var helper = new Helper();
            var bs     = helper.BoardsetupFromFen(fen);
            var mg     = new KCE.Engine.MoveGenerator(bs);

            return(mg.AllCapMoves().Length);
        }
Example #2
0
        private ulong DividePerftTest(string FEN, int depth)
        {
            var helper = new Helper();

            _boardState = helper.BoardsetupFromFen(FEN);
            var moveGenerator = new KCE.Engine.MoveGenerator(_boardState);

            return(moveGenerator.Divide(depth));
        }
Example #3
0
        public void LegalKingMOvesTest()
        {
            BoardState bs = SetupBs("k7/8/K7/P7/8/8/8/8 w - - 0 1");

            KCE.Engine.MoveGenerator mg = new KCE.Engine.MoveGenerator(bs);
            var expected = 2;
            var actual   = mg.AllLegalMoves();

            foreach (var move in actual)
            {
                Console.WriteLine(move.GetAlgebraicPly());
            }

            Assert.AreEqual(expected, actual.Length);
        }
Example #4
0
        public void KingSquare3PlysMakeTest()
        {
            var helper = new Helper();
            var bs     = helper.BoardsetupFromFen("k7/8/K7/P7/8/8/8/8 w - - 0 1");

            helper.PrintBoardWhitePerspective(bs.BoardRepresentation);
            Console.WriteLine("\n");
            var firstPly = helper.MakePly(bs.BoardRepresentation,
                                          Definitions.AlgebraicToIndex["a6"], Definitions.AlgebraicToIndex["b6"],
                                          Definitions.NoEnPassantSquare,
                                          false, false,
                                          false, false,
                                          bs.SideToMove, -1);

            var moveGenerator = new KCE.Engine.MoveGenerator(bs);

            moveGenerator.MakeMove(firstPly);
            helper.PrintBoardWhitePerspective(bs.BoardRepresentation);
            Console.WriteLine("\n");

            int[] expected = { Definitions.AlgebraicToIndex["a8"], Definitions.AlgebraicToIndex["b6"] };
            Assert.AreEqual(expected[0], bs.KingSquares[0]);
            Assert.AreEqual(expected[1], bs.KingSquares[1]);

            var secondPly = helper.MakePly(bs.BoardRepresentation,
                                           Definitions.AlgebraicToIndex["a8"], Definitions.AlgebraicToIndex["b8"],
                                           Definitions.NoEnPassantSquare,
                                           false, false,
                                           false, false, bs.SideToMove);

            moveGenerator.MakeMove(secondPly);
            helper.PrintBoardWhitePerspective(bs.BoardRepresentation);
            Console.WriteLine("\n");

            expected[0] = Definitions.AlgebraicToIndex["b8"];
            expected[1] = Definitions.AlgebraicToIndex["b6"];
            Assert.AreEqual(expected[0], bs.KingSquares[0]);
            Assert.AreEqual(expected[1], bs.KingSquares[1]);

            var legalMoves = moveGenerator.AllLegalMoves();

            foreach (var legalMove in legalMoves)
            {
                Console.WriteLine("{0}.", legalMove.GetAlgebraicPly());
            }
        }
Example #5
0
        public void KingSquareMakeUnmakeTest()
        {
            var helper = new Helper();
            var bs     = helper.BoardsetupFromFen("k7/8/K7/P7/8/8/8/8 w - - 0 1");
            var ply    = helper.MakePly(bs.BoardRepresentation, Definitions.AlgebraicToIndex["a6"],
                                        Definitions.AlgebraicToIndex["b6"],
                                        Definitions.NoEnPassantSquare,
                                        false, false, false, false, bs.SideToMove, -1);
            var moveGenerator = new KCE.Engine.MoveGenerator(bs);

            moveGenerator.MakeMove(ply);

            int[] expected = { Definitions.AlgebraicToIndex["a8"], Definitions.AlgebraicToIndex["b6"] };
            Assert.AreEqual(expected[0], bs.KingSquares[0]);
            Assert.AreEqual(expected[1], bs.KingSquares[1]);
            moveGenerator.UndoMove(ply);
            expected[1] = Definitions.AlgebraicToIndex["a6"];
            Assert.AreEqual(expected[0], bs.KingSquares[0]);
            Assert.AreEqual(expected[1], bs.KingSquares[1]);
        }