private static void CalculateMulligan(int MaxManaCost)
{
List <CardTemplate> HandCards_BoardCards = MainLists.HandCards_BoardCards;
ManageTwins();
ManageCombos();
/*====================================main comparison===========================================*/
/*prefers whitelist over blacklist*/
foreach (CardTemplate card in HandCards_BoardCards.Where(x => !MainLists.chosenCards.Contains(x.Id)))
{
if (MainLists.whiteList.Contains(card.Id.ToString()))
{
MainLists.chosenCards.Add(BoardToMulliganCard(card));
}
else if (MainLists.blackList.Contains(card.Id.ToString()))
{
// ReSharper disable once RedundantJumpStatement
continue;
}
else if (new NeutralMinion(card).minionBoardCard != null &&
card.Cost <= MaxManaCost)
{
Task newT = new Task(() => NeutralMinion.ManageNeutralMinion(BoardToMulliganCard(card)));
neutralMinionTaskList.Add(newT);
newT.Start();
}
}
}
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;
}
public static void ManageNeutralMinion(Card.Cards card)
{
//<= max mana
var boardCard = new BoardCard(card);
if (boardCard.ResultingBoardCard.Quality >= ValueReader.MinCardQualityToInstantAddMinion) //epic by default
{
MainLists.chosenCards.Add(card);
}
else
{
//card quality not hight enoughbut <= max mana
if (!ValueReader.AttendMinionValue ||
boardCard.ResultingBoardCard.Cost < ValueReader.MinManaCostToAttendValue)
{
//mana <= max cost & mana < MinManaCostToAttendValue
MainLists.chosenCards.Add(card);
}
else if (boardCard.ResultingBoardCard.Cost >= ValueReader.MinManaCostToAttendValue)
{
var minionCard = new NeutralMinion(card);
MinionValue.Value requiredMinNeutralMinionValue =
minionCard.minionBoardCard.IsMaxManaCard && ValueReader.IncreaseMinMinionValueIfMaxCost
? ValueReader.IncreasedMinNeutralMinionValue
: ValueReader.MinNeutralMinionValue;
if (minionCard.thisCardValue >= requiredMinNeutralMinionValue)
{
MainLists.chosenCards.Add(card);
}
}
}
}
public static bool WouldTakeMinion(CardTemplate boardCard)
{
try
{
if (new NeutralMinion(boardCard).minionBoardCard == null) //not a neutral minion
{
return(false);
}
//<= max mana
Card.Cards card = CardTemplate.StringToCard(boardCard.Id.ToString());
#region normalChecks
if (MainLists.whiteList.Contains(boardCard.Id.ToString()))
{
return(true);
}
if (MainLists.blackList.Contains((boardCard.Id.ToString())))
{
return(false);
}
if (boardCard.Quality >= ValueReader.MinCardQualityToInstantAddMinion) //epic by default
{
return(true);
}
//card quality not hight enough and mana to high too
if ((!ValueReader.AttendMinionValue ||
boardCard.Cost < ValueReader.MinManaCostToAttendValue) && boardCard.Cost <= MainLists.MaxManaCost)
{
return(true);
}
if (boardCard.Cost > MainLists.MaxManaCost)
{
return(false);
}
//value has to be attended
var minionCard = new NeutralMinion(card);
MinionValue.Value requiredMinNeutralMinionValue =
minionCard.minionBoardCard.IsMaxManaCard && ValueReader.IncreaseMinMinionValueIfMaxCost
? ValueReader.IncreasedMinNeutralMinionValue
: ValueReader.MinNeutralMinionValue;
return(minionCard.thisCardValue >= requiredMinNeutralMinionValue);
#endregion normalChecks
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return(false);
}
}
/// <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))
)));
}
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
}
}
public static void ManageNeutralMinion(Card.Cards card)
{
//<= max mana
var boardCard = new BoardCard(card);
if (boardCard.ResultingBoardCard.Quality >= ValueReader.MinCardQualityToInstantAddMinion) //epic by default
MainLists.chosenCards.Add(card);
else
{
//card quality not hight enoughbut <= max mana
if (!ValueReader.AttendMinionValue ||
boardCard.ResultingBoardCard.Cost < ValueReader.MinManaCostToAttendValue)
//mana <= max cost & mana < MinManaCostToAttendValue
MainLists.chosenCards.Add(card);
else if (boardCard.ResultingBoardCard.Cost >= ValueReader.MinManaCostToAttendValue)
{
var minionCard = new NeutralMinion(card);
MinionValue.Value requiredMinNeutralMinionValue =
minionCard.minionBoardCard.IsMaxManaCard && ValueReader.IncreaseMinMinionValueIfMaxCost
? ValueReader.IncreasedMinNeutralMinionValue
: ValueReader.MinNeutralMinionValue;
if (minionCard.thisCardValue >= requiredMinNeutralMinionValue)
MainLists.chosenCards.Add(card);
}
}
}
public static bool WouldTakeMinion(CardTemplate boardCard)
{
try
{
if (new NeutralMinion(boardCard).minionBoardCard == null) //not a neutral minion
return false;
//<= max mana
Card.Cards card = CardTemplate.StringToCard(boardCard.Id.ToString());
#region normalChecks
if (MainLists.whiteList.Contains(boardCard.Id.ToString()))
return true;
if (MainLists.blackList.Contains((boardCard.Id.ToString())))
return false;
if (boardCard.Quality >= ValueReader.MinCardQualityToInstantAddMinion) //epic by default
return true;
//card quality not hight enough and mana to high too
if ((!ValueReader.AttendMinionValue ||
boardCard.Cost < ValueReader.MinManaCostToAttendValue) && boardCard.Cost <= MainLists.MaxManaCost)
return true;
if (boardCard.Cost > MainLists.MaxManaCost)
return false;
//value has to be attended
var minionCard = new NeutralMinion(card);
MinionValue.Value requiredMinNeutralMinionValue =
minionCard.minionBoardCard.IsMaxManaCard && ValueReader.IncreaseMinMinionValueIfMaxCost
? ValueReader.IncreasedMinNeutralMinionValue
: ValueReader.MinNeutralMinionValue;
return minionCard.thisCardValue >= requiredMinNeutralMinionValue;
#endregion normalChecks
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return false;
}
}
