public void Randomize10Cards()
{
var selectedItems = this.CurrentCardsListView.SelectedItems.Select(item => (DominionCard)item).ToArray <DominionCard>();
bool useShelter = this.appDataContext.UseShelters.Value;
bool useColony = this.appDataContext.UseColonyPlatinum.Value;
DominionCard baneCard = this.appDataContext.BaneCard.CurrentCards.FirstOrDefault();
bool isCleanRoll = this.appDataContext.CurrentDeck.GenerateRandom(10, ref baneCard, this.appDataContext.AllCards.CurrentCards, itemsToReplace: selectedItems);
this.appDataContext.BaneCard.PopulateBaneCard(baneCard);
if (isCleanRoll)
{
this.appDataContext.UseColonyPlatinum.Value = ShouldIncludeExpansion(Dominion.Expansion.Prosperity);
this.appDataContext.UseShelters.Value = ShouldIncludeExpansion(Dominion.Expansion.DarkAges);
ReRollEvents();
this.appDataContext.player1Strategy.CardAcceptanceDescriptions.Clear();
this.appDataContext.player2Strategy.CardAcceptanceDescriptions.Clear();
}
if (this.CurrentCardsChanged != null)
{
this.CurrentCardsChanged();
}
}
private async void CurrentCardsListView_Drop(object sender, DragEventArgs e)
{
if (!e.Data.GetView().AvailableFormats.Contains("text"))
{
return;
}
string cardNames = (string)await e.Data.GetView().GetTextAsync("text");
Dominion.Strategy.Description.StrategyDescription strategy = this.appDataContext.currentStrategy.Value.ConvertToDominionStrategy();
foreach (var cardName in cardNames.Split(','))
{
DominionCard card = DominionCard.Create(cardName);
if (strategy.purchaseOrderDescription.descriptions.Length == 0)
{
strategy = Dominion.Strategy.Description.StrategyDescription.GetDefaultStrategyDescription(card.dominionCard);
}
else
{
strategy = strategy.AddCardToPurchaseOrder(card.dominionCard);
}
}
this.appDataContext.currentStrategy.Value.PopulateFrom(strategy);
}
private void ReRollEvents()
{
int cEventsToInclude = 0;
int cEventRemaining = 20;
int totalKingdomCount = Dominion.Cards.AllKingdomCards().Count();
for (int i = 0; i < 10; ++i)
{
int roll = MainPage.random.Next(totalKingdomCount);
if (roll <= cEventRemaining)
{
cEventsToInclude++;
cEventRemaining--;
i--;
continue;
}
totalKingdomCount--;
}
var allEventsCards = Dominion.Cards.AllCards().Where(c => c.isEvent).Select(c => DominionCard.Create(c)).ToArray();
var selectedItems = this.EventCardsListView.SelectedItems.Select(item => (DominionCard)item).ToArray <DominionCard>();
var cardPicker = new UniqueCardPicker(allEventsCards.Select(c => c.dominionCard));
DominionCard baneCard = null;
this.appDataContext.EventCards.Clear();
this.appDataContext.EventCards.GenerateRandom(cEventsToInclude, ref baneCard, allEventsCards, itemsToReplace: selectedItems);
}
private async System.Threading.Tasks.Task PopulateFromResources()
{
foreach (Dominion.Card card in Dominion.Cards.AllKingdomCards())
{
this.originalCards.Add(DominionCard.Create(card));
}
}
public void Randomize10Cards()
{
var selectedItems = this.CurrentCardsListView.SelectedItems.Select(item => (DominionCard)item).ToArray <DominionCard>();
bool useShelter = this.appDataContext.UseShelters.Value;
bool useColony = this.appDataContext.UseColonyPlatinum.Value;
DominionCard baneCard = this.appDataContext.BaneCards.CurrentCards.FirstOrDefault();
bool isCleanRoll = this.appDataContext.CurrentDeck.Generate10Random(ref baneCard, this.appDataContext.AllCards.Cards, itemsToReplace: selectedItems);
this.appDataContext.BaneCards.PopulateBaneCard(baneCard);
if (isCleanRoll)
{
// reroll shelter
{
int cProsperity = this.appDataContext.CurrentDeck.CurrentCards.Select(c => c.dominionCard).Where(c => c.expansion == Dominion.Expansion.Prosperity).Count();
int roll = MainPage.random.Next(1, 10);
this.appDataContext.UseColonyPlatinum.Value = cProsperity >= roll ? true : false;
}
// reroll shelter
{
int cDarkAges = this.appDataContext.CurrentDeck.CurrentCards.Select(c => c.dominionCard).Where(c => c.expansion == Dominion.Expansion.DarkAges).Count();
int roll = MainPage.random.Next(1, 10);
this.appDataContext.UseShelters.Value = cDarkAges >= roll ? true : false;
}
}
if (this.CurrentCardsChanged != null)
{
this.CurrentCardsChanged();
}
}
public CardAcceptanceDescription(DominionCard card)
: this()
{
this.Card.Value = card;
this.Count.Value = CountAsManyAsPossible;
this.SecondaryMatchVisible.Value = false;
this.TestCard.Value = card;
this.Comparison.Value = Dominion.Strategy.Description.Comparison.LessThan;
this.Threshhold.Value = 1;
this.CountSource.Value = Dominion.Strategy.Description.CountSource.Always;
}
public CardAcceptanceDescription(DominionCard card)
: this()
{
this.Card.Value = card;
this.Count.Value = CountAsManyAsPossible;
this.SecondaryMatchVisible.Value = false;
this.TestCard.Value = card;
this.Comparison.Value = Dominion.Strategy.Description.Comparison.LessThan;
this.Threshhold.Value = 1;
this.CountSource.Value = Dominion.Strategy.Description.CountSource.Always;
}
private async System.Threading.Tasks.Task PopulateCommonFromResources(Dominion.GameConfig gameConfig)
{
this.originalCards.Clear();
Dominion.CardGainAvailablility[] availabilities = gameConfig.GetCardAvailability(1, Dominion.CardAvailabilityType.AdditionalCardsAfterKingdom);
foreach (var availability in availabilities)
{
this.originalCards.Add(DominionCard.Create(availability.card));
}
}
public bool IsExcluded(DominionCard card)
{
bool unused;
if (this.excludes.TryGetValue(card, out unused))
{
return(true);
}
return(false);
}
public void PopulateBaneCard(DominionCard card)
{
if (this.originalCards.Contains(card))
{
return;
}
if (this.originalCards.Any())
{
this.originalCards.Clear();
}
this.originalCards.Add(card);
}
private async void CurrentCardsListView_Drop(object sender, DragEventArgs e)
{
if (!e.Data.GetView().AvailableFormats.Contains("text"))
{
return;
}
string cardNames = (string)await e.Data.GetView().GetTextAsync("text");
Dominion.Card[] cards = cardNames.Split(',').Select(cardName => DominionCard.Create(cardName).dominionCard).ToArray();
Dominion.Strategy.Description.StrategyDescription strategy = this.appDataContext.currentStrategy.Value.ConvertToDominionStrategy();
strategy = strategy.AddCardsToPurchaseOrder(cards);
this.appDataContext.currentStrategy.Value.PopulateFrom(strategy);
}
private async System.Threading.Tasks.Task PopulateCommonFromResources()
{
Dominion.Card[] commonCards = new Dominion.Card[] {
Dominion.Cards.Province,
Dominion.Cards.Duchy,
Dominion.Cards.Estate,
Dominion.Cards.Gold,
Dominion.Cards.Silver,
Dominion.Cards.Copper,
};
foreach (Dominion.Card card in commonCards)
{
this.originalCards.Add(DominionCard.Create(card));
}
}
public void PopulateBaneCard(DominionCard card)
{
if (this.originalCards.Contains(card))
{
return;
}
if (this.originalCards.Any())
{
this.originalCards.Clear();
}
if (card != null)
{
this.originalCards.Add(card);
}
this.UpdateUIFromUIThread();
}
public DominionCard GetCard(Func <DominionCard, bool> meetConstraint)
{
while (maxIndex > 0)
{
int resultCardIndex = NumberBetweenInclusive(MainPage.random, 0, maxIndex);
DominionCard currentCard = this.allCards[remainingCards[resultCardIndex]];
remainingCards[resultCardIndex] = remainingCards[maxIndex];
--maxIndex;
if (!IsExcluded(currentCard) && meetConstraint(currentCard))
{
return(currentCard);
}
}
return(null);
}
void AvailableCards_PropetyChanged(object sender, PropertyChangedEventArgs e)
{
var setCards = new HashSet <Dominion.Card>();
foreach (var card in this.currentDeck.Cards)
{
setCards.Add(card.dominionCard);
}
foreach (var card in this.commonCards.Cards)
{
setCards.Add(card.dominionCard);
}
this.player1Strategy.ConvertToDominionStrategy().GetAllCardsInStrategy(setCards);
this.player2Strategy.ConvertToDominionStrategy().GetAllCardsInStrategy(setCards);
var extraCards = new List <DominionCard>();
foreach (var card in this.availableCards)
{
if (!setCards.Contains(card.dominionCard))
{
extraCards.Add(card);
}
}
foreach (var card in setCards)
{
var dominionCard = DominionCard.Create(card);
if (!this.availableCards.Contains(dominionCard))
{
this.availableCards.Add(dominionCard);
}
}
foreach (var card in extraCards)
{
this.availableCards.Remove(card);
}
// this sort method will order but cause items in strategy to be data bound empty
//Sort(this.availableCards, c => c.dominionCard.name);
}
public bool Generate10Random(ref DominionCard baneCard, IList <DominionCard> allCards, IList <DominionCard> itemsToReplace)
{
bool isCleanRoll = MainPage.Generate10Random(
ref baneCard,
this.originalCards, this.Cards, allCards, itemsToReplace);
if (!isCleanRoll)
{
this.ClearSort();
}
else
{
ReapplySortOrder();
}
this.UpdateUIFromUIThread();
return(isCleanRoll);
}
public static CardAcceptanceDescription PopulateFrom(Dominion.Strategy.Description.CardAcceptanceDescription descr)
{
var result = new CardAcceptanceDescription();
result.Card.Value = DominionCard.Create(descr.card);
if (descr.matchDescriptions.Length != 1 && descr.matchDescriptions.Length != 2)
{
throw new Exception("Support only one match description in addition to count all owned");
}
if (descr.matchDescriptions[0].countSource == Dominion.Strategy.Description.CountSource.Always)
{
result.Count.Value = CountAsManyAsPossible;
}
else if (descr.matchDescriptions[0].countSource == Dominion.Strategy.Description.CountSource.CountAllOwned &&
descr.matchDescriptions[0].cardType == descr.card &&
descr.matchDescriptions[0].comparison == Dominion.Strategy.Description.Comparison.LessThan)
{
result.Count.Value = descr.matchDescriptions[0].countThreshHold;
}
else
{
throw new Exception("First match description needs to describe how many of the card to own");
}
if (descr.matchDescriptions.Length == 2)
{
result.TestCard.Value = descr.matchDescriptions[1].cardType != null?DominionCard.Create(descr.matchDescriptions[1].cardType) : null;
result.Threshhold.Value = descr.matchDescriptions[1].countThreshHold;
result.Comparison.Value = descr.matchDescriptions[1].comparison;
result.CountSource.Value = descr.matchDescriptions[1].countSource;
}
else
{
result.CountSource.Value = Dominion.Strategy.Description.CountSource.Always;
}
return(result);
}
public Dominion.GameConfig GetGameConfig()
{
Dominion.StartingCardSplit player1Split = this.player1Strategy.StartingCardSplit.Value;
Dominion.StartingCardSplit player2Split = this.player2Strategy.StartingCardSplit.Value;
Dominion.Card[] kingdomCards = this.currentDeck.Cards.Select(c => c.dominionCard).ToArray();
DominionCard baneCard = this.BaneCards.CurrentCards.FirstOrDefault();
var builder = new Dominion.GameConfigBuilder();
builder.SetKingdomPiles(kingdomCards);
if (baneCard != null)
{
builder.SetBaneCard(baneCard.dominionCard);
}
builder.useColonyAndPlatinum = this.UseColonyPlatinum.Value;
builder.useShelters = this.UseShelters.Value;
builder.SetCardSplitPerPlayer(new Dominion.StartingCardSplit[] { player1Split, player2Split });
return(builder.ToGameConfig());
}
internal static void Generate10Random(IList <DominionCard> resultList, IList <DominionCard> sourceList, IList <DominionCard> allCards, IList <DominionCard> itemsToReplace)
{
bool isReplacingItems = itemsToReplace != null && itemsToReplace.Count > 0 && sourceList.Count <= 10;
bool isReducingItems = itemsToReplace != null && itemsToReplace.Count > 0 && sourceList.Count > 10;
var cardPicker = new UniqueCardPicker(allCards);
if (isReplacingItems)
{
cardPicker.ExcludeCards(itemsToReplace);
if (itemsToReplace != null)
{
foreach (DominionCard cardToReplace in itemsToReplace)
{
for (int i = 0; i < resultList.Count; ++i)
{
if (resultList[i] == cardToReplace)
{
var nextCard = cardPicker.GetCard(c => true);
if (nextCard == null)
{
resultList.Remove(cardToReplace);
i--; // do this index again
}
else
{
resultList[i] = nextCard;
}
}
}
}
}
}
else if (sourceList.Count < 10)
{
var listRemoved = new List <DominionCard>();
foreach (var card in resultList)
{
if (!sourceList.Contains(card))
{
listRemoved.Add(card);
}
}
foreach (var card in listRemoved)
{
resultList.Remove(card);
}
}
else if (isReducingItems)
{
foreach (var card in itemsToReplace)
{
resultList.Remove(card);
}
}
else
{
resultList.Clear();
}
while (resultList.Count < 10)
{
DominionCard currentCard = cardPicker.GetCard(c => true);
if (currentCard == null)
{
break;
}
resultList.Add(currentCard);
}
}
public bool GenerateRandom(
int targetCount,
ref DominionCard baneCard,
IEnumerable<DominionCard> allCards,
IEnumerable<DominionCard> itemsToReplace)
{
bool isCleanRoll = MainPage.GenerateRandom(
targetCount,
ref baneCard,
this.originalCards, this.Cards, allCards, itemsToReplace);
if (!isCleanRoll)
this.ClearSort();
else
ReapplySortOrder();
this.UpdateUIFromUIThread();
return isCleanRoll;
}
public void PopulateBaneCard(DominionCard card)
{
if (this.originalCards.Contains(card))
return;
if (this.originalCards.Any())
this.originalCards.Clear();
if (card != null)
this.originalCards.Add(card);
this.UpdateUIFromUIThread();
}
private async System.Threading.Tasks.Task PopulatColonyPlatinumFromResources()
{
this.originalCards.Add(DominionCard.Create(Dominion.Cards.Platinum));
this.originalCards.Add(DominionCard.Create(Dominion.Cards.Colony));
}
internal static bool GenerateRandom(
int targetCount,
ref DominionCard baneCard,
IList <DominionCard> resultList,
IList <DominionCard> sourceList,
IEnumerable <DominionCard> allCards,
IEnumerable <DominionCard> itemsToReplace)
{
bool isReplacingItems = itemsToReplace != null && itemsToReplace.Any() && sourceList.Count <= targetCount;
bool isReducingItems = itemsToReplace != null && itemsToReplace.Any() && sourceList.Count > targetCount;
var cardPicker = new UniqueCardPicker(allCards.Select(c => c.dominionCard));
bool isCleanRoll = false;
if (isReplacingItems)
{
cardPicker.ExcludeCards(itemsToReplace.Select(c => c.dominionCard));
}
baneCard = DominionCard.Create(cardPicker.GetCard(c => c.DefaultCoinCost == 2 || c.DefaultCoinCost == 3));
if (isReplacingItems)
{
foreach (DominionCard cardToReplace in itemsToReplace)
{
for (int i = 0; i < resultList.Count; ++i)
{
if (resultList[i] == cardToReplace)
{
var nextCard = cardPicker.GetCard(c => true);
if (nextCard == null)
{
resultList.Remove(cardToReplace);
i--; // do this index again
}
else
{
resultList[i] = DominionCard.Create(nextCard);
}
}
}
}
}
else if (sourceList.Count < targetCount && sourceList.Count > 0)
{
var listRemoved = new List <DominionCard>();
foreach (var card in resultList)
{
if (!sourceList.Contains(card))
{
listRemoved.Add(card);
}
}
foreach (var card in listRemoved)
{
resultList.Remove(card);
}
}
else if (isReducingItems)
{
foreach (var card in itemsToReplace)
{
resultList.Remove(card);
}
}
else
{
resultList.Clear();
isCleanRoll = true;
}
while (resultList.Count < targetCount)
{
Dominion.Card currentCard = cardPicker.GetCard(c => true);
if (currentCard == null)
{
break;
}
resultList.Add(DominionCard.Create(currentCard));
}
return(isCleanRoll);
}
internal static bool GenerateRandom(
int targetCount,
ref DominionCard baneCard,
IList<DominionCard> resultList,
IList<DominionCard> sourceList,
IEnumerable<DominionCard> allCards,
IEnumerable<DominionCard> itemsToReplace)
{
bool isReplacingItems = itemsToReplace != null && itemsToReplace.Any() && sourceList.Count <= targetCount;
bool isReducingItems = itemsToReplace != null && itemsToReplace.Any() && sourceList.Count > targetCount;
var cardPicker = new Dominion.UniqueCardPicker(allCards.Select(c => c.dominionCard), MainPage.random);
bool isCleanRoll = false;
if (isReplacingItems)
{
cardPicker.ExcludeCards(itemsToReplace.Select(c => c.dominionCard));
}
baneCard = DominionCard.Create(cardPicker.GetCard(c => c.DefaultCoinCost == 2 || c.DefaultCoinCost == 3));
if (isReplacingItems)
{
foreach (DominionCard cardToReplace in itemsToReplace)
{
for (int i = 0; i < resultList.Count; ++i)
{
if (resultList[i] == cardToReplace)
{
var nextCard = cardPicker.GetCard(c => true);
if (nextCard == null)
{
resultList.Remove(cardToReplace);
i--; // do this index again
}
else
{
resultList[i] = DominionCard.Create(nextCard);
}
}
}
}
}
else if (sourceList.Count < targetCount && sourceList.Count > 0)
{
var listRemoved = new List<DominionCard>();
foreach(var card in resultList)
{
if (!sourceList.Contains(card))
listRemoved.Add(card);
}
foreach(var card in listRemoved)
{
resultList.Remove(card);
}
}
else if (isReducingItems)
{
foreach (var card in itemsToReplace)
{
resultList.Remove(card);
}
}
else
{
resultList.Clear();
isCleanRoll = true;
}
while (resultList.Count < targetCount)
{
Dominion.Card currentCard = cardPicker.GetCard(c => true);
if (currentCard == null)
break;
resultList.Add(DominionCard.Create(currentCard));
}
return isCleanRoll;
}
