Exemple #1
0
        public void AttackbyQueenTest()
        {
            string fen = "8/8/8/8/3Q4/8/8/8 w - - 0 1";

            Game_Accessor.NewInternal(fen);
            string[] good_squares = { "a4", "b4", "c4", "e4", "f4", "g4", "h4",
                                      "d1", "d2", "d3", "d5", "d6", "d7", "d8",
                                      "a1", "b2", "c3", "e5", "f6", "g7", "h8",
                                      "a7", "b6", "c5", "e3", "f2", "g1" };

            Piece queen = Game_Accessor.PlayerWhite.Pieces.Item(0);

            foreach (string s in good_squares)
            {
                bool canAttack = queen.CanAttackSquare(Board_Accessor.GetSquare(s));
                Assert.IsTrue(canAttack);
            }

            string[] bad_squares = { "b3", "b5", "a8", "c2", "c6", "d4", "e6", "f3", "f5" };
            foreach (string s in bad_squares)
            {
                bool canAttack = queen.CanAttackSquare(Board_Accessor.GetSquare(s));
                Assert.IsFalse(canAttack);
            }
        }
Exemple #2
0
        public void SquareAttackTest()
        {
            string fen = "k7/8/8/8/3N4/8/8/K7 w - - 0 1";

            Game_Accessor.NewInternal(fen);
            Square s;

            // white king is in the corner, check that it can attack everything around it
            s = Board_Accessor.GetSquare("b1");
            Assert.IsTrue(s.PlayerCanAttackSquare(Game_Accessor.PlayerWhite));
            s = Board_Accessor.GetSquare("a2");
            Assert.IsTrue(s.PlayerCanAttackSquare(Game_Accessor.PlayerWhite));
            s = Board_Accessor.GetSquare("b2");
            Assert.IsTrue(s.PlayerCanAttackSquare(Game_Accessor.PlayerWhite));

            // white can't attack far away squares
            s = Board_Accessor.GetSquare("h8");
            Assert.IsFalse(s.PlayerCanAttackSquare(Game_Accessor.PlayerWhite));
            s = Board_Accessor.GetSquare("b8");
            Assert.IsFalse(s.PlayerCanAttackSquare(Game_Accessor.PlayerWhite));

            // white knights can attack b3
            s = Board_Accessor.GetSquare("b3");
            Assert.IsTrue(s.PlayerCanAttackSquare(Game_Accessor.PlayerWhite));

            // black king can attack around it
            s = Board_Accessor.GetSquare("a7");
            Assert.IsTrue(s.PlayerCanAttackSquare(Game_Accessor.PlayerBlack));

            s = Board_Accessor.GetSquare("b7");
            Assert.IsTrue(s.PlayerCanAttackSquare(Game_Accessor.PlayerBlack));

            s = Board_Accessor.GetSquare("b8");
            Assert.IsTrue(s.PlayerCanAttackSquare(Game_Accessor.PlayerBlack));
        }
Exemple #3
0
 public void AddPointsToPlayersTest()
 {
     Game_Accessor target = new Game_Accessor(); // TODO: Initialize to an appropriate value
     int result = 0; // TODO: Initialize to an appropriate value
     target.AddPointsToPlayers(result);
     Assert.Inconclusive("A method that does not return a value cannot be verified.");
 }
Exemple #4
0
 public void GenerateCellsTest()
 {
     PrivateObject param0 = new PrivateObject(new Game(new List<Player>()));
     Game_Accessor target = new Game_Accessor(param0);
     int actualCount = 60;
     Assert.AreEqual(target.Cells.Count, actualCount);
 }
Exemple #5
0
        public void AddPointsToPlayersTest()
        {
            Game_Accessor target = new Game_Accessor(); // TODO: Initialize to an appropriate value
            int           result = 0;                   // TODO: Initialize to an appropriate value

            target.AddPointsToPlayers(result);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }
Exemple #6
0
 private int NodeCountTest(string fen, int depth)
 {
     Game_Accessor.NewInternal(fen);
     Game_Accessor.MaximumSearchDepth    = depth;
     Game_Accessor.ClockFixedTimePerMove = new TimeSpan(0, 10, 0); // 10 minute max
     Game_Accessor.UseRandomOpeningMoves = false;
     Game_Accessor.PlayerToPlay.Brain.Think();
     // TimeSpan elpased = Game_Accessor.PlayerToPlay.Brain.ThinkingTimeElpased;
     return(Game_Accessor.PlayerToPlay.Brain.Search.PositionsSearchedThisTurn);
 }
Exemple #7
0
        public void ScoreEvalHasntChanged()
        {
            const string Fen = "r2qk2r/ppp2ppp/2b5/4N3/1b1Pp3/8/PPP1QPPP/R1B2RK1 b k - 1 11";

            Game_Accessor.NewInternal(Fen);
            Game_Accessor.MaximumSearchDepth    = 3;
            Game_Accessor.ClockFixedTimePerMove = new TimeSpan(0, 10, 0); // 10 minute max
            Game_Accessor.UseRandomOpeningMoves = false;
            Game_Accessor.PlayerToPlay.Brain.Think();

            Assert.AreEqual(-441, Game.PlayerToPlay.Score);
        }
Exemple #8
0
        public void ShouldPlaceBishopsOnOppositeColorsforChess960WhitePlayer()
        {
            Game_Accessor.Mode = Game_Accessor.GameMode.Chess960;
            Game_Accessor.NewInternal("");
            Player       player  = Game_Accessor.PlayerWhite;
            List <Piece> bishops = FindPiecesWithQualities(player, "B", Piece.PieceNames.Bishop);

            Assert.AreEqual(2, bishops.Count);
            int bishop1File = bishops.ElementAt(0).StartLocation.File, bishop2File = bishops.ElementAt(1).StartLocation.File;

            Assert.IsTrue(bishop1File % 2 != bishop2File % 2);
        }
Exemple #9
0
        public void ShouldContainProperNumberAndTypeOfPiecesForChess960WhitePlayer()
        {
            Game_Accessor.Mode = Game_Accessor.GameMode.Chess960;
            Game_Accessor.NewInternal("");
            Player player = Game_Accessor.PlayerWhite;

            Assert.AreEqual(16, player.Pieces.Count);
            Assert.IsTrue(NPiecesWithQualities(player, "P", Piece.PieceNames.Pawn, 8));
            Assert.IsTrue(NPiecesWithQualities(player, "N", Piece.PieceNames.Knight, 2));
            Assert.IsTrue(NPiecesWithQualities(player, "B", Piece.PieceNames.Bishop, 2));
            Assert.IsTrue(NPiecesWithQualities(player, "Q", Piece.PieceNames.Queen, 1));
            Assert.IsTrue(NPiecesWithQualities(player, "K", Piece.PieceNames.King, 1));
        }
Exemple #10
0
        public void ShouldPlaceKingBetweenRooksForChess960WhitePlayer()
        {
            Game_Accessor.Mode = Game_Accessor.GameMode.Chess960;
            Game_Accessor.NewInternal("");
            Player       player = Game_Accessor.PlayerWhite;
            List <Piece> rooks  = FindPiecesWithQualities(player, "R", Piece.PieceNames.Rook);

            Assert.AreEqual(2, rooks.Count);
            int  kingFile = player.King.StartLocation.File, rook1File = rooks.ElementAt(0).StartLocation.File, rook2File = rooks.ElementAt(1).StartLocation.File;
            bool greaterThanOne = kingFile > rook1File || kingFile > rook2File;
            bool lessThanOne    = kingFile < rook1File || kingFile < rook2File;

            Assert.IsTrue(greaterThanOne && lessThanOne);
        }
Exemple #11
0
        public void SidesShouldMirrorEachOther()
        {
            Game_Accessor.Mode = Game_Accessor.GameMode.Chess960;
            Game_Accessor.NewInternal("");
            Player playerWhite = Game_Accessor.PlayerWhite;
            Player playerBlack = Game_Accessor.PlayerBlack;

            Assert.AreEqual(playerWhite.Pieces.Count, playerBlack.Pieces.Count);

            foreach (Piece white in playerWhite.Pieces)
            {
                List <Piece> blackMatches = FindPiecesWithQualities(playerBlack, white.Abbreviation, white.Name, white.StartLocation.File, 7 - white.StartLocation.Rank);
                Assert.AreEqual(1, blackMatches.Count);
            }
        }
Exemple #12
0
        private TimeSpan NodeCountTime(string fen, int depth)
        {
            Game_Accessor.NewInternal(fen);
            Game_Accessor.MaximumSearchDepth    = depth;
            Game_Accessor.ClockFixedTimePerMove = new TimeSpan(0, 10, 0); // 10 minute max
            Game_Accessor.UseRandomOpeningMoves = false;
            System.Diagnostics.Stopwatch s = new System.Diagnostics.Stopwatch();
            s.Start();
            Game_Accessor.PlayerToPlay.Brain.Think();
            s.Stop();
            System.Diagnostics.Debug.WriteLine("elapsted = " + s.Elapsed);
            return(s.Elapsed);
            // Console.Debug("asdafsd");
//            // TimeSpan elpased = Game_Accessor.PlayerToPlay.Brain.ThinkingTimeElpased;
//           return Game_Accessor.PlayerToPlay.Brain.Search.PositionsSearchedThisTurn;
        }
Exemple #13
0
        public void CanPieceTypeAttackSquareTest()
        {
            string fen = "1b1k3r/p1q3r1/npp1pp1n/2p5/8/3K4/8/8";

            Game_Accessor.NewInternal(fen);
            Square s = Board_Accessor.GetSquare("g4");

            Assert.IsTrue(Piece.CanPlayerPieceNameAttackSquare(s, Game_Accessor.PlayerBlack, Piece.PieceNames.Rook));
            Assert.IsTrue(Piece.CanPlayerPieceNameAttackSquare(s, Game_Accessor.PlayerBlack, Piece.PieceNames.Knight));
            Assert.IsFalse(Piece.CanPlayerPieceNameAttackSquare(s, Game_Accessor.PlayerBlack, Piece.PieceNames.Queen));
            Assert.IsFalse(Piece.CanPlayerPieceNameAttackSquare(s, Game_Accessor.PlayerBlack, Piece.PieceNames.Bishop));
            Assert.IsFalse(Piece.CanPlayerPieceNameAttackSquare(s, Game_Accessor.PlayerBlack, Piece.PieceNames.Pawn));
            Assert.IsFalse(Piece.CanPlayerPieceNameAttackSquare(s, Game_Accessor.PlayerBlack, Piece.PieceNames.King));


            s = Board_Accessor.GetSquare("d4");
            Assert.IsTrue(Piece.CanPlayerPieceNameAttackSquare(s, Game_Accessor.PlayerWhite, Piece.PieceNames.King));
            Assert.IsTrue(Piece.CanPlayerPieceNameAttackSquare(s, Game_Accessor.PlayerBlack, Piece.PieceNames.Pawn));
        }
Exemple #14
0
        /*
         *      [TestMethod]
         *      public void Sbd_004()
         *      {
         *          this.BestMoveTest("2b5/1p4k1/p2R2P1/4Np2/1P3Pp1/1r6/5K2/8 w", "d6", "d8", 7);
         *          // Nodes: 234,270
         *      }
         */
        #endregion

        #region Methods

        /// <summary>
        /// Helper method that tests that the nest move is found for a known test position, in the required search depth.
        /// </summary>
        private void BestMoveTest(
            string testPositionFen, string expectedMoveFrom, string expectedMoveTo, int expectedDepth)
        {
            Game_Accessor.NewInternal(testPositionFen);
            Game_Accessor.MaximumSearchDepth    = expectedDepth;
            Game_Accessor.ClockFixedTimePerMove = new TimeSpan(0, MaximumSecondsPerTest, 0);
            Game_Accessor.UseRandomOpeningMoves = false;
            Game_Accessor.PlayerToPlay.Brain.Think();
            int positions = Game_Accessor.PlayerToPlay.Brain.Search.PositionsSearchedThisTurn;

            TimeSpan elpased = Game_Accessor.PlayerToPlay.Brain.ThinkingTimeElpased;

            Debug.WriteLine(string.Format("Nodes: {0} ", Game_Accessor.PlayerToPlay.Brain.Search.PositionsSearchedThisTurn));
            Debug.WriteLine(string.Format("Time: {0} ", Game_Accessor.PlayerToPlay.Brain.ThinkingTimeElpased));
            Debug.WriteLine(string.Format("Score: {0} ", Game_Accessor.PlayerToPlay.Brain.PrincipalVariation[0].Score));

            Assert.AreEqual(expectedMoveFrom, Game_Accessor.PlayerToPlay.Brain.PrincipalVariation[0].From.Name, "From move wrong");
            Assert.AreEqual(expectedMoveTo, Game_Accessor.PlayerToPlay.Brain.PrincipalVariation[0].To.Name, "To move wrong");
        }
Exemple #15
0
        public void SquareAttackPerfTest()
        {
            string fen = "3k4/8/8/8/8/3K4/8/8";

            Game_Accessor.NewInternal(fen);
            Square s;

            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();
            for (int i = 0; i < 1000000; i++)
            {
                s = Board_Accessor.GetSquare("c2");
                s.PlayerCanAttackSquare(Game_Accessor.PlayerWhite);
            }
            stopwatch.Stop();
            s = Board_Accessor.GetSquare("c2");
            Assert.IsTrue(s.PlayerCanAttackSquare(Game_Accessor.PlayerWhite));
            Debug.WriteLine("Time elapsed: {0}", stopwatch.Elapsed);
        }
Exemple #16
0
        public void SquareAttackByBishopTest()
        {
            string fen = "8/5k2/1p3P2/8/3B4/8/8/K7 w - - 0 1";

            Game_Accessor.NewInternal(fen);
            Square square;

            string[] good_squares = { "b6", "c5", "e5", "f6", "g7", "e7", "b1", "b2", "a2" };
            foreach (string s in good_squares)
            {
                square = Board_Accessor.GetSquare(s);
                Assert.IsTrue(square.PlayerCanAttackSquare(Game_Accessor.PlayerWhite));
            }

            string[] bad_squares = { "a6", "c4", "e2", "e1", "f8", "h8" };
            foreach (string s in good_squares)
            {
                square = Board_Accessor.GetSquare(s);
                Assert.IsTrue(square.PlayerCanAttackSquare(Game_Accessor.PlayerWhite));
            }
        }
Exemple #17
0
        public void CheapestPieceDefendingThisSquareTest()
        {
            string fen = "1b1k3r/p1q3r1/npp1pp1n/2p5/8/3K4/8/8";

            Game_Accessor.NewInternal(fen);
            Square s = Board_Accessor.GetSquare("g4");
            Piece  p = s.CheapestPieceDefendingThisSquare(Game_Accessor.PlayerBlack);

            Assert.IsTrue(p.Top.Name == Piece.PieceNames.Knight);

            // time this
            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();
            for (int i = 0; i < 1000000; i++)
            {
                p = s.CheapestPieceDefendingThisSquare(Game_Accessor.PlayerBlack);
            }
            stopwatch.Stop();
            Debug.WriteLine("Time elapsed: {0}", stopwatch.Elapsed);
        }
Exemple #18
0
        public void AttackbyPawnTest()
        {
            string fen = "8/8/8/8/3P4/8/8/8 w - - 0 1";

            Game_Accessor.NewInternal(fen);
            string[] good_squares = { "c5", "e5" };

            Piece pawn = Game_Accessor.PlayerWhite.Pieces.Item(0);

            foreach (string s in good_squares)
            {
                bool canAttack = pawn.CanAttackSquare(Board_Accessor.GetSquare(s));
                Assert.IsTrue(canAttack);
            }

            string[] bad_squares = { "b3", "b5", "a8", "c2", "c6", "d4", "e6", "f3", "f5" };
            foreach (string s in bad_squares)
            {
                bool canAttack = pawn.CanAttackSquare(Board_Accessor.GetSquare(s));
                Assert.IsFalse(canAttack);
            }
        }
Exemple #19
0
        public void AttackByKnightTest()
        {
            // just test that a knight in center of board can attack squares
            string fen = "8/8/8/8/3N4/8/8/8 w - - 0 1";

            Game_Accessor.NewInternal(fen);
            string[] good_squares = { "b3", "b5", "b5", "c2", "c6", "e2", "e6", "f3", "f5" };

            Piece knight = Game_Accessor.PlayerWhite.Pieces.Item(0);

            foreach (string s in good_squares)
            {
                bool canAttack = knight.CanAttackSquare(Board_Accessor.GetSquare(s));
                Assert.IsTrue(canAttack);
            }

            string[] bad_squares = { "a3", "b6", "b7", "c1", "c5", "e1", "e8", "f4", "h5" };
            foreach (string s in bad_squares)
            {
                bool canAttack = knight.CanAttackSquare(Board_Accessor.GetSquare(s));
                Assert.IsFalse(canAttack);
            }
        }
Exemple #20
0
        public void AttackByBishopTest()
        {
            string fen = "8/8/8/8/3B4/8/8/8 w - - 0 1";

            Game_Accessor.NewInternal(fen);
            string[] good_squares = { "a1", "b2", "c3", "e5", "f6", "g7", "h8",
                                      "a7", "b6", "c5", "e3", "f2", "g1" };

            Piece bishop = Game_Accessor.PlayerWhite.Pieces.Item(0);

            foreach (string s in good_squares)
            {
                bool canAttack = bishop.CanAttackSquare(Board_Accessor.GetSquare(s));
                Assert.IsTrue(canAttack);
            }

            string[] bad_squares = { "b3", "b5", "a8", "c2", "c6", "d4", "e6", "f3", "f5" };
            foreach (string s in bad_squares)
            {
                bool canAttack = bishop.CanAttackSquare(Board_Accessor.GetSquare(s));
                Assert.IsFalse(canAttack);
            }
        }
Exemple #21
0
        public void ShouldPlaceStandardBoardProperlyForBlackPlayer()
        {
            Game_Accessor.Mode = Game_Accessor.GameMode.Chess;
            Game_Accessor.NewInternal("");
            Player player = Game_Accessor.PlayerBlack;

            Assert.AreEqual(16, player.Pieces.Count);
            Assert.IsTrue(PieceHasExpectedQualities(player.King, player, "K", Piece.PieceNames.King, 4, 7));
            Assert.IsTrue(NPiecesWithQualities(player, "P", Piece.PieceNames.Pawn, 1, 0, 6));
            Assert.IsTrue(NPiecesWithQualities(player, "P", Piece.PieceNames.Pawn, 1, 1, 6));
            Assert.IsTrue(NPiecesWithQualities(player, "P", Piece.PieceNames.Pawn, 1, 2, 6));
            Assert.IsTrue(NPiecesWithQualities(player, "P", Piece.PieceNames.Pawn, 1, 3, 6));
            Assert.IsTrue(NPiecesWithQualities(player, "P", Piece.PieceNames.Pawn, 1, 4, 6));
            Assert.IsTrue(NPiecesWithQualities(player, "P", Piece.PieceNames.Pawn, 1, 5, 6));
            Assert.IsTrue(NPiecesWithQualities(player, "P", Piece.PieceNames.Pawn, 1, 6, 6));
            Assert.IsTrue(NPiecesWithQualities(player, "P", Piece.PieceNames.Pawn, 1, 7, 6));
            Assert.IsTrue(NPiecesWithQualities(player, "R", Piece.PieceNames.Rook, 1, 0, 7));
            Assert.IsTrue(NPiecesWithQualities(player, "R", Piece.PieceNames.Rook, 1, 7, 7));
            Assert.IsTrue(NPiecesWithQualities(player, "N", Piece.PieceNames.Knight, 1, 6, 7));
            Assert.IsTrue(NPiecesWithQualities(player, "N", Piece.PieceNames.Knight, 1, 1, 7));
            Assert.IsTrue(NPiecesWithQualities(player, "B", Piece.PieceNames.Bishop, 1, 2, 7));
            Assert.IsTrue(NPiecesWithQualities(player, "B", Piece.PieceNames.Bishop, 1, 5, 7));
            Assert.IsTrue(NPiecesWithQualities(player, "Q", Piece.PieceNames.Queen, 1, 3, 7));
        }
Exemple #22
0
 public static void MyClassInitialize(TestContext testContext)
 {
     _target = new Game_Accessor(false);
 }
Exemple #23
0
 public void GameConstructorTest1()
 {
     Game_Accessor target2 = new Game_Accessor(data);
     Assert.AreEqual(target2.exportCurrentState(), _target.exportCurrentState());
 }
Exemple #24
0
 public static void MyClassInitialize(TestContext testContext)
 {
     _target = new Game_Accessor(false);
 }
Exemple #25
0
        public void GameConstructorTest1()
        {
            Game_Accessor target2 = new Game_Accessor(data);

            Assert.AreEqual(target2.exportCurrentState(), _target.exportCurrentState());
        }