Esempio n. 1
0
        public void TestOpenEndedBeatNutsTextureAnalyzer()
        {
            var analyzer = new OpenEndedBeatNutsTextureAnalyzer();

            var item3 = new StraightBoardTextureItem()
            {
                TargetStreet = Street.Turn, SelectedNumber = 1, SelectedSign = new KeyValuePair <Model.Enums.EnumEquality, string>(Model.Enums.EnumEquality.EqualTo, "")
            };

            /* true */
            var boardCards  = BoardCards.FromCards("6s 8s 5s 9s");
            var boardCards2 = BoardCards.FromCards("Js 8s 2s Ts 9h");
            var boardCards3 = BoardCards.FromCards("5s 4s Js 2s");
            var boardCards4 = BoardCards.FromCards("8s 6s 4s 8h 4h");
            var boardCards5 = BoardCards.FromCards("Ks Ts 8s 7s As");
            var boardCards8 = BoardCards.FromCards("3s 5h As 5s 2s");


            /* false */
            var boardCards6 = BoardCards.FromCards("8s Ks Qs 7s Js");
            var boardCards7 = BoardCards.FromCards("3s Ks 7s Qs Kh");

            Assert.That(analyzer.Analyze(boardCards, item3), Is.True);
            Assert.That(analyzer.Analyze(boardCards2, item3), Is.True);
            Assert.That(analyzer.Analyze(boardCards3, item3), Is.True);
            Assert.That(analyzer.Analyze(boardCards4, item3), Is.True);
            Assert.That(analyzer.Analyze(boardCards5, item3), Is.True);
            Assert.That(analyzer.Analyze(boardCards6, item3), Is.False);
            Assert.That(analyzer.Analyze(boardCards7, item3), Is.False);
            Assert.That(analyzer.Analyze(boardCards8, item3), Is.True);
        }
Esempio n. 2
0
        public void TestGutShotBeatNutsTextureAnalyzer()
        {
            var analyzer = new GutShotBeatNutsTextureAnalyzer();

            var item3 = new StraightBoardTextureItem()
            {
                TargetStreet = Street.Turn, SelectedNumber = 3, SelectedSign = new KeyValuePair <Model.Enums.EnumEquality, string>(Model.Enums.EnumEquality.EqualTo, "")
            };
            var itemLessThan3 = new StraightBoardTextureItem()
            {
                TargetStreet = Street.Turn, SelectedNumber = 3, SelectedSign = new KeyValuePair <Model.Enums.EnumEquality, string>(Model.Enums.EnumEquality.LessThan, "")
            };
            var item2 = new StraightBoardTextureItem()
            {
                TargetStreet = Street.Turn, SelectedNumber = 1, SelectedSign = new KeyValuePair <Model.Enums.EnumEquality, string>(Model.Enums.EnumEquality.EqualTo, "")
            };

            /* 3 */
            var boardCards  = BoardCards.FromCards("6s 8s 5s 9s");
            var boardCards2 = BoardCards.FromCards("Js 8s 2s Ts 9s");
            var boardCards3 = BoardCards.FromCards("2s 5s Js 4s");
            var boardCards4 = BoardCards.FromCards("5s 4s Js 2h 3h");
            var boardCards5 = BoardCards.FromCards("2s Ts Js 8s 7s");
            var boardCards6 = BoardCards.FromCards("4s 6s 7s 2s 5s");

            /* less than 3 */
            var boardCards7 = BoardCards.FromCards("3s 8s 6s 4s 4h");
            var boardCards8 = BoardCards.FromCards("Qs Qh 9s Js 5s");

            Assert.That(analyzer.Analyze(boardCards, item3), Is.True);
            Assert.That(analyzer.Analyze(boardCards2, item3), Is.True);
            Assert.That(analyzer.Analyze(boardCards3, item3), Is.True);
            Assert.That(analyzer.Analyze(boardCards4, item3), Is.True);
            Assert.That(analyzer.Analyze(boardCards5, item3), Is.True);
            Assert.That(analyzer.Analyze(boardCards6, item3), Is.True);
            Assert.That(analyzer.Analyze(boardCards7, item3), Is.True);
            Assert.That(analyzer.Analyze(boardCards8, item3), Is.False);

            Assert.That(analyzer.Analyze(boardCards, itemLessThan3), Is.False);
            Assert.That(analyzer.Analyze(boardCards2, itemLessThan3), Is.False);
            Assert.That(analyzer.Analyze(boardCards3, itemLessThan3), Is.False);
            Assert.That(analyzer.Analyze(boardCards4, itemLessThan3), Is.False);
            Assert.That(analyzer.Analyze(boardCards5, itemLessThan3), Is.False);
            Assert.That(analyzer.Analyze(boardCards6, itemLessThan3), Is.False);
            Assert.That(analyzer.Analyze(boardCards7, itemLessThan3), Is.False);
            Assert.That(analyzer.Analyze(boardCards8, itemLessThan3), Is.True);

            Assert.That(analyzer.Analyze(boardCards, item2), Is.False);
            Assert.That(analyzer.Analyze(boardCards2, item2), Is.False);
            Assert.That(analyzer.Analyze(boardCards3, item2), Is.False);
            Assert.That(analyzer.Analyze(boardCards4, item2), Is.False);
            Assert.That(analyzer.Analyze(boardCards5, item2), Is.False);
            Assert.That(analyzer.Analyze(boardCards6, item2), Is.False);
            Assert.That(analyzer.Analyze(boardCards7, item2), Is.False);
            Assert.That(analyzer.Analyze(boardCards8, item2), Is.True);
        }
Esempio n. 3
0
        public void TestMadeStraightTextureAnalyzer()
        {
            var analyzer = new MadeStraightTextureAnalyzer();

            var item3 = new StraightBoardTextureItem()
            {
                TargetStreet = Street.Turn, SelectedNumber = 3, SelectedSign = new KeyValuePair <Model.Enums.EnumEquality, string>(Model.Enums.EnumEquality.EqualTo, "")
            };
            var itemLessThan3 = new StraightBoardTextureItem()
            {
                TargetStreet = Street.Turn, SelectedNumber = 3, SelectedSign = new KeyValuePair <Model.Enums.EnumEquality, string>(Model.Enums.EnumEquality.LessThan, "")
            };
            var itemGreaterThan2 = new StraightBoardTextureItem()
            {
                TargetStreet = Street.Turn, SelectedNumber = 2, SelectedSign = new KeyValuePair <Model.Enums.EnumEquality, string>(Model.Enums.EnumEquality.GreaterThan, "")
            };

            /* 3 */
            var boardCards  = BoardCards.FromCards("Ks Qs 8s Js 4s"); // !
            var boardCards2 = BoardCards.FromCards("6s 5s 7s 5h");
            var boardCards3 = BoardCards.FromCards("3s 8s 6s 4s 4h"); // !
            var boardCards4 = BoardCards.FromCards("6s 4s 5s Qh 3h");
            var boardCards5 = BoardCards.FromCards("Qs 8s 7s 6s 6h");

            /* less than 3*/
            var boardCards6 = BoardCards.FromCards("4s 2s 6s 2h");
            var boardCards7 = BoardCards.FromCards("Qs 2s 3s 2h");
            var boardCards8 = BoardCards.FromCards("6s 2h Ks 2d 2s");

            Assert.That(analyzer.Analyze(boardCards, item3), Is.False);
            Assert.That(analyzer.Analyze(boardCards2, item3), Is.True);
            Assert.That(analyzer.Analyze(boardCards3, item3), Is.False);
            Assert.That(analyzer.Analyze(boardCards4, item3), Is.True);
            Assert.That(analyzer.Analyze(boardCards5, item3), Is.True);
            Assert.That(analyzer.Analyze(boardCards6, item3), Is.False);
            Assert.That(analyzer.Analyze(boardCards7, item3), Is.False);
            Assert.That(analyzer.Analyze(boardCards8, item3), Is.False);

            Assert.That(analyzer.Analyze(boardCards, itemLessThan3), Is.True);
            Assert.That(analyzer.Analyze(boardCards2, itemLessThan3), Is.False);
            Assert.That(analyzer.Analyze(boardCards3, itemLessThan3), Is.True);
            Assert.That(analyzer.Analyze(boardCards4, itemLessThan3), Is.False);
            Assert.That(analyzer.Analyze(boardCards5, itemLessThan3), Is.False);
            Assert.That(analyzer.Analyze(boardCards6, itemLessThan3), Is.True);
            Assert.That(analyzer.Analyze(boardCards7, itemLessThan3), Is.True);
            Assert.That(analyzer.Analyze(boardCards8, itemLessThan3), Is.True);

            Assert.That(analyzer.Analyze(boardCards, itemGreaterThan2), Is.False);
            Assert.That(analyzer.Analyze(boardCards2, itemGreaterThan2), Is.True);
            Assert.That(analyzer.Analyze(boardCards3, itemGreaterThan2), Is.False);
            Assert.That(analyzer.Analyze(boardCards4, itemGreaterThan2), Is.True);
            Assert.That(analyzer.Analyze(boardCards5, itemGreaterThan2), Is.True);
            Assert.That(analyzer.Analyze(boardCards6, itemGreaterThan2), Is.False);
            Assert.That(analyzer.Analyze(boardCards7, itemGreaterThan2), Is.False);
            Assert.That(analyzer.Analyze(boardCards8, itemGreaterThan2), Is.False);
        }
Esempio n. 4
0
        public void TestOpenEndedStraightTextureAnalyzer()
        {
            var analyzer = new OpenEndedStraightTextureAnalyzer();

            var item3 = new StraightBoardTextureItem()
            {
                TargetStreet = Street.Flop, SelectedNumber = 3, SelectedSign = new KeyValuePair <Model.Enums.EnumEquality, string>(Model.Enums.EnumEquality.EqualTo, "")
            };
            var itemLessThan3 = new StraightBoardTextureItem()
            {
                TargetStreet = Street.Flop, SelectedNumber = 3, SelectedSign = new KeyValuePair <Model.Enums.EnumEquality, string>(Model.Enums.EnumEquality.LessThan, "")
            };
            var itemGreaterThan2 = new StraightBoardTextureItem()
            {
                TargetStreet = Street.Flop, SelectedNumber = 2, SelectedSign = new KeyValuePair <Model.Enums.EnumEquality, string>(Model.Enums.EnumEquality.GreaterThan, "")
            };

            /* 3 */
            var boardCards  = BoardCards.FromCards("8s 3s 6s");
            var boardCards2 = BoardCards.FromCards("3s 8s 6s");
            var boardCards3 = BoardCards.FromCards("8s 5s Ts");
            var boardCards4 = BoardCards.FromCards("8s 6s 4s 8h 4h");
            var boardCards5 = BoardCards.FromCards("Ks Ts 8s 7s As");

            /* less than 3*/
            var boardCards6 = BoardCards.FromCards("8s Ks Qs 7s Js");
            var boardCards7 = BoardCards.FromCards("3s Ks 7s Qs Kh");
            var boardCards8 = BoardCards.FromCards("3s 5h As 5s 2s");

            Assert.That(analyzer.Analyze(boardCards, item3), Is.True);
            Assert.That(analyzer.Analyze(boardCards2, item3), Is.True);
            Assert.That(analyzer.Analyze(boardCards3, item3), Is.True);
            Assert.That(analyzer.Analyze(boardCards4, item3), Is.True);
            Assert.That(analyzer.Analyze(boardCards5, item3), Is.True);
            Assert.That(analyzer.Analyze(boardCards6, item3), Is.False);
            Assert.That(analyzer.Analyze(boardCards7, item3), Is.False);
            Assert.That(analyzer.Analyze(boardCards8, item3), Is.False);

            Assert.That(analyzer.Analyze(boardCards, itemLessThan3), Is.False);
            Assert.That(analyzer.Analyze(boardCards2, itemLessThan3), Is.False);
            Assert.That(analyzer.Analyze(boardCards3, itemLessThan3), Is.False);
            Assert.That(analyzer.Analyze(boardCards4, itemLessThan3), Is.False);
            Assert.That(analyzer.Analyze(boardCards5, itemLessThan3), Is.False);
            Assert.That(analyzer.Analyze(boardCards6, itemLessThan3), Is.True);
            Assert.That(analyzer.Analyze(boardCards7, itemLessThan3), Is.True);
            Assert.That(analyzer.Analyze(boardCards8, itemLessThan3), Is.True);

            Assert.That(analyzer.Analyze(boardCards, itemGreaterThan2), Is.True);
            Assert.That(analyzer.Analyze(boardCards2, itemGreaterThan2), Is.True);
            Assert.That(analyzer.Analyze(boardCards3, itemGreaterThan2), Is.True);
            Assert.That(analyzer.Analyze(boardCards4, itemGreaterThan2), Is.True);
            Assert.That(analyzer.Analyze(boardCards5, itemGreaterThan2), Is.True);
            Assert.That(analyzer.Analyze(boardCards6, itemGreaterThan2), Is.False);
            Assert.That(analyzer.Analyze(boardCards7, itemGreaterThan2), Is.False);
            Assert.That(analyzer.Analyze(boardCards8, itemGreaterThan2), Is.False);
        }
Esempio n. 5
0
        public static List <int> GetOrderedBoardNumericRanks(BoardCards boardCards, StraightBoardTextureItem boardTextureItem)
        {
            var board        = boardCards.GetBoardOnStreet(boardTextureItem.TargetStreet).OrderBy(x => x.RankNumericValue).ToList();
            var orderedRanks = board.Select(x => x.RankNumericValue).Distinct().ToList();

            if (board.Any(x => x.RankNumericValue == Cards.Card.GetRankNumericValue("A")))
            {
                orderedRanks.Insert(0, 1);
            }

            return(orderedRanks);
        }
Esempio n. 6
0
        public void TestFourConnectedTextureAnalyzer()
        {
            var analyzer = new FourConnectedTextureAnalyzer();

            var item = new StraightBoardTextureItem()
            {
                TargetStreet = Street.Turn
            };

            var boardCards  = BoardCards.FromCards("6s 5d 4d 7d Ad");
            var boardCards2 = BoardCards.FromCards("As 2d 3c 4c");
            var boardCards3 = BoardCards.FromCards("As 3d 4d 5c");
            var boardCards4 = BoardCards.FromCards("As 2d Qd Kc");
            var boardCards5 = BoardCards.FromCards("3s As 2d 4d");
            var boardCards6 = BoardCards.FromCards("As Ks Qs Js 8s");

            Assert.That(analyzer.Analyze(boardCards, item), Is.True);
            Assert.That(analyzer.Analyze(boardCards2, item), Is.True);
            Assert.That(analyzer.Analyze(boardCards3, item), Is.False);
            Assert.That(analyzer.Analyze(boardCards4, item), Is.False);
            Assert.That(analyzer.Analyze(boardCards5, item), Is.True);
            Assert.That(analyzer.Analyze(boardCards6, item), Is.True);
        }
Esempio n. 7
0
        public void TestThreeConnectedTextureAnalyzer()
        {
            var analyzer = new ThreeConnectedTextureAnalyzer();

            var item = new StraightBoardTextureItem()
            {
                TargetStreet = Street.Flop
            };

            var boardCards  = BoardCards.FromCards("6s 5d 4d 7d");
            var boardCards2 = BoardCards.FromCards("As 2d 3c");
            var boardCards3 = BoardCards.FromCards("As 3d 4d 5c");
            var boardCards4 = BoardCards.FromCards("4s 5d 7d");
            var boardCards5 = BoardCards.FromCards("7s 5s 4d");
            var boardCards6 = BoardCards.FromCards("3s As 2d");

            Assert.That(analyzer.Analyze(boardCards, item), Is.True);
            Assert.That(analyzer.Analyze(boardCards2, item), Is.True);
            Assert.That(analyzer.Analyze(boardCards3, item), Is.False);
            Assert.That(analyzer.Analyze(boardCards4, item), Is.False);
            Assert.That(analyzer.Analyze(boardCards5, item), Is.False);
            Assert.That(analyzer.Analyze(boardCards6, item), Is.True);
        }
Esempio n. 8
0
        public void TestTwoGapperTextureAnalyzer()
        {
            var analyzer = new TwoGapperTextureAnalyzer();

            var item = new StraightBoardTextureItem()
            {
                TargetStreet = Street.Flop
            };

            var boardCards  = BoardCards.FromCards("3s 4d 7d 5d");
            var boardCards2 = BoardCards.FromCards("4s 7d 3c");
            var boardCards3 = BoardCards.FromCards("4s 4d 5d 8c");
            var boardCards4 = BoardCards.FromCards("4s 5d 7d");
            var boardCards5 = BoardCards.FromCards("7s 5s 4d");
            var boardCards6 = BoardCards.FromCards("4s As 5d");

            Assert.That(analyzer.Analyze(boardCards, item), Is.True);
            Assert.That(analyzer.Analyze(boardCards2, item), Is.True);
            Assert.That(analyzer.Analyze(boardCards3, item), Is.False);
            Assert.That(analyzer.Analyze(boardCards4, item), Is.False);
            Assert.That(analyzer.Analyze(boardCards5, item), Is.False);
            Assert.That(analyzer.Analyze(boardCards6, item), Is.True);
        }
Esempio n. 9
0
        public void TestUncoordinatedTextureAnalyzer()
        {
            var analyzer = new UncoordinatedTextureAnalyzer();

            var item = new StraightBoardTextureItem()
            {
                TargetStreet = Street.Flop
            };

            var boardCards  = BoardCards.FromCards("6s 5s 4d");
            var boardCards2 = BoardCards.FromCards("4s 7d 3c");
            var boardCards3 = BoardCards.FromCards("4s 4d 7d 6c");
            var boardCards4 = BoardCards.FromCards("4s 4d 5d 8d");
            var boardCards5 = BoardCards.FromCards("4s 4d 6d 5d");
            var boardCards6 = BoardCards.FromCards("As 2d 4c");


            Assert.That(analyzer.Analyze(boardCards, item), Is.False);
            Assert.That(analyzer.Analyze(boardCards2, item), Is.False);
            Assert.That(analyzer.Analyze(boardCards3, item), Is.True);
            Assert.That(analyzer.Analyze(boardCards4, item), Is.False);
            Assert.That(analyzer.Analyze(boardCards5, item), Is.True);
            Assert.That(analyzer.Analyze(boardCards6, item), Is.False);
        }