private static void AddCards(List <Card> cardSet, ICardPicker matchingCards) { foreach (Card card in matchingCards.GetNeededCards()) { cardSet.Add(card); } }
private static bool ShouldGainCopper(GameState gameState, ICardPicker gainOrder) { PlayerState self = gameState.Self; int minValue = self.ExpectedCoinValueAtEndOfTurn; int maxValue = minValue + Strategy.CountInHand(Dominion.Cards.IllGottenGains, gameState); if (maxValue == minValue) { return(false); } CardPredicate shouldGainCard = delegate(Card card) { int currentCardCost = card.CurrentCoinCost(self); return(currentCardCost >= minValue && currentCardCost <= maxValue); }; Card cardType = gainOrder.GetPreferredCard(gameState, shouldGainCard); if (cardType == null) { return(false); } int coppersToGain = DefaultPlayerAction.CostOfCard(cardType, gameState) - minValue; return(coppersToGain > 0); }
private static GameStatePredicate ShouldPlayMarketSquare(ICardPicker trashOrder) { return(delegate(GameState gameState) { var self = gameState.Self; if (!IsDoingMegaTurn(gameState)) { return !CanTrashForGold(gameState, trashOrder); } else { if (ShouldPlayMadman(trashOrder)(gameState)) { return false; } int numberOfProvincesCanAfford = self.ExpectedCoinValueAtEndOfTurn / Cards.Province.CurrentCoinCost(self); if (self.AvailableBuys < numberOfProvincesCanAfford) { return true; } return !CanTrashForGold(gameState, trashOrder); } }); }
private static GameStatePredicate ShouldPlayMadman(ICardPicker trashOrder) { return(delegate(GameState gameState) { PlayerState self = gameState.Self; if (!self.Hand.HasCard(Cards.Madman)) { return false; } if (CountAllOwned(Cards.Province, gameState) > 0) { return true; } if (ShouldStartMegaTurn(gameState)) { return true; } if (IsDoingMegaTurn(gameState)) { if (self.CardsInDeck.Count + self.Discard.Count > 5) { return true; } } return false; }); }
private static bool ShouldGainCopper(GameState gameState, ICardPicker gainOrder) { PlayerState self = gameState.Self; int minValue = self.ExpectedCoinValueAtEndOfTurn; int maxValue = minValue + Strategy.CountInHand(Dominion.Cards.IllGottenGains, gameState); if (maxValue == minValue) return false; CardPredicate shouldGainCard = delegate(Card card) { int currentCardCost = card.CurrentCoinCost(self); return currentCardCost >= minValue && currentCardCost <= maxValue; }; Card cardType = gainOrder.GetPreferredCard(gameState, shouldGainCard); if (cardType == null) return false; int coppersToGain = DefaultPlayerAction.CostOfCard(cardType, gameState) - minValue; return (coppersToGain > 0); }
public DefaultPlayerAction( string name, ICardPicker purchaseOrder, ICardPicker actionOrder, bool chooseDefaultActionOnNone, bool enablePenultimateProvinceRule, ICardPicker treasurePlayOrder, ICardPicker discardOrder, ICardPicker trashOrder, ICardPicker gainOrder) { this.purchaseOrder = purchaseOrder; this.actionOrder = actionOrder == null?DefaultStrategies.DefaultActionPlayOrder(purchaseOrder) : actionOrder; this.discardOrder = discardOrder == null?DefaultStrategies.DefaultDiscardOrder() : discardOrder; this.trashOrder = trashOrder == null?DefaultStrategies.DefaultTrashOrder(purchaseOrder) : trashOrder; this.treasurePlayOrder = treasurePlayOrder == null?DefaultStrategies.DefaultTreasurePlayOrder() : treasurePlayOrder; this.gainOrder = gainOrder != null ? gainOrder : purchaseOrder; this.chooseDefaultActionOnNone = chooseDefaultActionOnNone; this.enablePenultimateProvinceRule = enablePenultimateProvinceRule; this.name = name; this.defaultActionOrder = DefaultStrategies.DefaultActionPlayOrder(purchaseOrder); this.defaultShouldPlay = DefaultPlayRules.DefaultResponses.GetCardShouldPlayDefaults(this); }
public static void AddAllCards(HashSet <Card> cardSet, ICardPicker matchingCards) { foreach (Card card in matchingCards.GetNeededCards()) { cardSet.Add(card); } }
private static bool CanTrashForGold(GameState gameState, ICardPicker trashOrder) { PlayerState self = gameState.Self; return trashOrder.GetPreferredCard(gameState, c => (self.Hand.HasCard(c) || self.Discard.HasCard(c)) && CardTypes.Hermit.CanTrashCard(c)) != null && self.Hand.HasCard(Cards.Hermit) && self.Hand.HasCard(Cards.MarketSquare); }
private static bool CanTrashForGold(GameState gameState, ICardPicker trashOrder) { PlayerState self = gameState.Self; return(trashOrder.GetPreferredCard(gameState, c => (self.Hand.HasCard(c) || self.Discard.HasCard(c)) && CardTypes.Hermit.CanTrashCard(c)) != null && self.Hand.HasCard(Cards.Hermit) && self.Hand.HasCard(Cards.MarketSquare)); }
private static CardPickByPriority ActionOrder(ICardPicker trashOrder) { return(new CardPickByPriority( CardAcceptance.For(Cards.Madman, ShouldPlayMadman(trashOrder)), CardAcceptance.For(Cards.Hermit, IsDoingMegaTurn), CardAcceptance.For(Cards.MarketSquare, ShouldPlayMarketSquare(trashOrder)), CardAcceptance.For(Cards.Hermit, gameState => CountAllOwned(Cards.Madman, gameState) - CountAllOwned(Cards.Hermit, gameState) < 3), CardAcceptance.For(Cards.Hermit, gameState => CountAllOwned(Cards.Province, gameState) > 0))); }
public PlayerAction( string name, ICardPicker purchaseOrder, ICardPicker actionOrder = null, bool chooseDefaultActionOnNone = true, bool enablePenultimateProvinceRule = false, ICardPicker treasurePlayOrder = null, ICardPicker discardOrder = null, ICardPicker trashOrder = null, ICardPicker gainOrder = null) : base(new DefaultPlayerAction(name, purchaseOrder, actionOrder, chooseDefaultActionOnNone, enablePenultimateProvinceRule, treasurePlayOrder, discardOrder, trashOrder, gainOrder)) { }
public static ICardPicker DefaultTrashOrder(ICardPicker purchaseOrder) { return(new CardPickByPriority( CardAcceptance.For(Cards.Curse), CardAcceptance.For(Cards.RuinedVillage), CardAcceptance.For(Cards.RuinedMarket), CardAcceptance.For(Cards.Survivors), CardAcceptance.For(Cards.RuinedLibrary), CardAcceptance.For(Cards.AbandonedMine), CardAcceptance.For(Cards.Estate, gameState => !purchaseOrder.DoesCardPickerMatch(gameState, Cards.Estate)), CardAcceptance.For(Cards.OvergrownEstate), CardAcceptance.For(Cards.Hovel), CardAcceptance.For(Cards.Copper, gameState => !purchaseOrder.DoesCardPickerMatch(gameState, Cards.Copper)))); }
public Card GetPreferredCardReverse(GameState gameState, CardPredicate cardPredicate) { for (int i = this.matchers.Length - 1; i > 0; --i) { ICardPicker matcher = this.matchers[i]; Card result = matcher.GetPreferredCardReverse(gameState, cardPredicate); if (result != null) { return(result); } } return(null); }
public static int CountInSetMatching(this ICardPicker pickOrder, GameState gameState, CollectionCards collectionCards) { int result = 0; foreach (var cardType in collectionCards.AllTypes) { if (pickOrder.DoesCardPickerMatch(gameState, cardType)) { result += collectionCards.CountOf(cardType); } } return(result); }
private static ICardPicker PurchaseOrder(ICardPicker trashOrder) { var highPriority = new CardPickByPriority( CardAcceptance.For(Cards.Province, gameState => CountAllOwned(trashOrder, gameState) <= 3), CardAcceptance.For(Cards.Library, gameState => CountAllOwned(Cards.Library, gameState) < 1), CardAcceptance.For(Cards.Count, gameState => CountAllOwned(Cards.Count, gameState) < 1)); var buildOrder = new CardPickByBuildOrder( CardAcceptance.For(Cards.FishingVillage), CardAcceptance.For(Cards.Library), CardAcceptance.For(Cards.Count), CardAcceptance.For(Cards.Library)); var lowPriority = new CardPickByPriority( CardAcceptance.For(Cards.PoorHouse, gameState => CountAllOwned(Cards.PoorHouse, gameState) < 2 && CountAllOwned(Cards.Count, gameState) >= 1), CardAcceptance.For(Cards.FishingVillage)); return new CardPickConcatenator(highPriority, buildOrder, lowPriority); }
private static ICardPicker PurchaseOrder(ICardPicker trashOrder) { var highPriority = new CardPickByPriority( CardAcceptance.For(Cards.Province, gameState => CountAllOwned(trashOrder, gameState) <= 3), CardAcceptance.For(Cards.Library, gameState => CountAllOwned(Cards.Library, gameState) < 1), CardAcceptance.For(Cards.Count, gameState => CountAllOwned(Cards.Count, gameState) < 1)); var buildOrder = new CardPickByBuildOrder( CardAcceptance.For(Cards.FishingVillage), CardAcceptance.For(Cards.Library), CardAcceptance.For(Cards.Count), CardAcceptance.For(Cards.Library)); var lowPriority = new CardPickByPriority( CardAcceptance.For(Cards.PoorHouse, gameState => CountAllOwned(Cards.PoorHouse, gameState) < 2 && CountAllOwned(Cards.Count, gameState) >= 1), CardAcceptance.For(Cards.FishingVillage)); return(new CardPickConcatenator(highPriority, buildOrder, lowPriority)); }
private static GameStatePredicate ShouldPlayMadman(ICardPicker trashOrder) { return delegate(GameState gameState) { PlayerState self = gameState.Self; if (!self.Hand.HasCard(Cards.Madman)) return false; if (CountAllOwned(Cards.Province, gameState) > 0) return true; if (ShouldStartMegaTurn(gameState)) return true; if (IsDoingMegaTurn(gameState)) { if (self.CardsInDeck.Count + self.Discard.Count > 5) return true; } return false; }; }
public CardPickForCondition(GameStatePredicate predicate, ICardPicker picker) { this.picker = picker; this.predicate = predicate; }
public static bool HasCardIn(Card card, ICardPicker matchingCards, GameState gameState) { return(matchingCards.GetPreferredCard(gameState, c => c == card) != null); }
public static bool HasCardFromInHand(ICardPicker matchingCards, GameState gameState) { return(WhichCardFromInHand(matchingCards, gameState) != null); }
public static void AddAllCards(HashSet<Card> cardSet, ICardPicker matchingCards) { foreach (Card card in matchingCards.GetNeededCards()) { cardSet.Add(card); } }
public SortCardByDefaultActionOrder(ICardPicker purchaseOrder) { this.purchaseOrder = purchaseOrder; }
public static ICardPicker DefaultActionPlayOrder(ICardPicker purchaseOrder) { return(new CardPickFromWhatsInHand(new SortCardByDefaultActionOrder(purchaseOrder))); }
// TODO: implement a better default choice of which Ruins to player. private static int CompareRuins(Card first, Card second, GameState gameState, ICardPicker purchaseOrder) { PlayerState self = gameState.Self; int coinsToSpend = self.ExpectedCoinValueAtEndOfTurn; if (first == Cards.AbandonedMine || second == Cards.AbandonedMine) { CardPredicate shouldGainCard = delegate(Card card) { int currentCardCost = card.CurrentCoinCost(self); return(currentCardCost == coinsToSpend + 1); }; Card cardType = purchaseOrder.GetPreferredCard(gameState, shouldGainCard); if (cardType != null) { return(first == Cards.AbandonedMine ? 0 : 1); } //Card Card1 = purchaseOrder.GetPreferredCard( // gameState, // card => coinsToSpend >= card.CurrentCoinCost(currentPlayer) && // gameState.GetPile(card).Any()); //Card Card2 = purchaseOrder.GetPreferredCard( // gameState, // card => coinsToSpend + 1 >= card.CurrentCoinCost(currentPlayer) && // gameState.GetPile(card).Any()); //if (Card1 != Card2) // return first.name == "Abandoned Mine" ? 0 : 1; } return(0); }
public Comparer(GameState gameState, ICardPicker purchaseOrder) { this.gameState = gameState; this.purchaseOrder = purchaseOrder; }
private static CardPickByPriority ActionOrder(ICardPicker trashOrder) { return new CardPickByPriority( CardAcceptance.For(Cards.Madman, ShouldPlayMadman(trashOrder)), CardAcceptance.For(Cards.Hermit, IsDoingMegaTurn), CardAcceptance.For(Cards.MarketSquare, ShouldPlayMarketSquare(trashOrder)), CardAcceptance.For(Cards.Hermit, gameState => CountAllOwned(Cards.Madman, gameState) - CountAllOwned(Cards.Hermit, gameState) < 3), CardAcceptance.For(Cards.Hermit, gameState => CountAllOwned(Cards.Province, gameState) > 0)); }
public static bool DoesCardPickerMatch(this ICardPicker pickOrder, GameState gameState, Card card) { return(pickOrder.GetPreferredCard(gameState, c => c == card) != null); }
public static bool HasCardFromInHand(ICardPicker matchingCards, GameState gameState) { return WhichCardFromInHand(matchingCards, gameState) != null; }
public static bool HasCardIn(Card card, ICardPicker matchingCards, GameState gameState) { return matchingCards.GetPreferredCard(gameState, c => c == card) != null; }
public static Card WhichCardFromInHand(ICardPicker matchingCards, GameState gameState) { return matchingCards.GetPreferredCard(gameState, card => gameState.Self.Hand.HasCard(card)); }
public static Card WhichCardFromInHand(ICardPicker matchingCards, GameState gameState) { return(matchingCards.GetPreferredCard(gameState, card => gameState.Self.Hand.HasCard(card))); }
public static int CountAllOwned(ICardPicker matchingCards, GameState gameState) { return gameState.Self.AllOwnedCards.CountWhere( card => matchingCards.GetPreferredCard(gameState, testCard => testCard == card) != null); }
public static int CountInHandFrom(ICardPicker matchingCards, GameState gameState) { return(gameState.Self.Hand.CountWhere(card => matchingCards.GetPreferredCard(gameState, current => current == card) != null)); }
public static int CountInHandFrom(ICardPicker matchingCards, GameState gameState) { return gameState.Self.Hand.CountWhere(card => matchingCards.GetPreferredCard(gameState, current => current == card) != null); }
public static int CountAllOwned(ICardPicker matchingCards, GameState gameState) { return(gameState.Self.AllOwnedCards.CountWhere( card => matchingCards.GetPreferredCard(gameState, testCard => testCard == card) != null)); }
private static GameStatePredicate ShouldPlayMarketSquare(ICardPicker trashOrder) { return delegate(GameState gameState) { var self = gameState.Self; if (!IsDoingMegaTurn(gameState)) { return !CanTrashForGold(gameState, trashOrder); } else { if (ShouldPlayMadman(trashOrder)(gameState)) return false; int numberOfProvincesCanAfford = self.ExpectedCoinValueAtEndOfTurn / Cards.Province.CurrentCoinCost(self); if (self.AvailableBuys < numberOfProvincesCanAfford) return true; return !CanTrashForGold(gameState, trashOrder); } }; }