public ProbabilityCalculation()
        {
            List <CardTemplate> HandCards_BoardCards = MainLists.HandCards_BoardCards;

            bool coinInHand = HandCards_BoardCards.Any(x => x.Id.ToString() == "GAME_005");

            currentHandCards = coinInHand ? HandCards_BoardCards.ToArray().
                               Where(x => x.Id.ToString() != "GAME_005") : HandCards_BoardCards.ToArray();
            currentDeck = MainLists.currentDeck;
            handCount   = coinInHand ? HandCards_BoardCards.Count : HandCards_BoardCards.Count - 1;

            mediumCardsInHandCount = MainLists.HandCards_BoardCards.Count(x => new NeutralMinion(x).minionBoardCard != null &&
                                                                          NeutralMinion.WouldTakeMinion(x) && !MainLists.whiteList.Contains(x.Id.ToString()));

            int _minProbability = ValueReader.MinProbabilityToReplace;

            if (_minProbability > 100)
            {
                _minProbability = 100;
            }
            else if (_minProbability < 0)
            {
                _minProbability = 0;
            }

            minProbability = _minProbability;
        }
        /// <summary>
        /// Inifinive
        /// </summary>
        /// <returns></returns>
        private int GetAcceptablePlusCountInDeckLeft()
        {
            return(currentDeck.Cards.Count(x =>

                                           (MainLists.whiteList.Contains(x))
                                           ||
                                           (
                                               new NeutralMinion(CardTemplate.LoadFromId(x)).minionBoardCard != null &&
                                               NeutralMinion.WouldTakeMinion(CardTemplate.LoadFromId(x))
                                           )


                                           &&
                                           !currentHandCards.ToList().Contains(
                                               CardTemplate.LoadFromId(CardTemplate.StringToCard(x))
                                               )));
        }
示例#3
0
        private static void CalculateDeckProbabilities()
        {
            try
            {
                int normalMinionCount = MainLists.HandCards_BoardCards.Count(x => new NeutralMinion(x).minionBoardCard != null &&
                                                                             NeutralMinion.WouldTakeMinion(x) && !MainLists.whiteList.Contains(x.Id.ToString()));

                if (normalMinionCount == 0)
                {
                    return;
                }

                float minProbabilityToReplace = ValueReader.MinProbabilityToReplace;

                ProbabilityCalculation probabilityCalculation = new ProbabilityCalculation();
                Tuple <int, float>     treeResult             = probabilityCalculation.GenerateTreeWhiteListDraw();

                //less medium cards than actually having possible
                if (treeResult.Item1 /*prospective refused*/ < normalMinionCount)
                {
                    int deltaReplaceCount = normalMinionCount - treeResult.Item1;

                    int i = 1;
                    foreach (CardTemplate badCard in MainLists.HandCards_BoardCards.
                             Where(x => new NeutralMinion(x).minionBoardCard != null && NeutralMinion.WouldTakeMinion(x) &&
                                   !MainLists.whiteList.Contains(x.Id.ToString())).
                             OrderBy(x => new NeutralMinion(x).thisCardValue).TakeWhile(x => i <= deltaReplaceCount))
                    {
                        MainLists.chosenCards.Remove(BoardToMulliganCard(badCard));
                        ++i;
                    }
                }
            }
            catch
            {
                //Ignored
            }
        }