コード例 #1
0
 private static void AddCards(List <Card> cardSet, ICardPicker matchingCards)
 {
     foreach (Card card in matchingCards.GetNeededCards())
     {
         cardSet.Add(card);
     }
 }
コード例 #2
0
        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);
        }
コード例 #3
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);
                }
            });
        }
コード例 #4
0
        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;
            });
        }
コード例 #5
0
        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);
        }
コード例 #6
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);
        }
コード例 #7
0
 public static void AddAllCards(HashSet <Card> cardSet, ICardPicker matchingCards)
 {
     foreach (Card card in matchingCards.GetNeededCards())
     {
         cardSet.Add(card);
     }
 }
コード例 #8
0
        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);
        }
コード例 #9
0
        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));
        }
コード例 #10
0
 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)));
 }
コード例 #11
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))
 {
 }
コード例 #12
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))
 {
 }
コード例 #13
0
 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))));
 }
コード例 #14
0
        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);
        }
コード例 #15
0
        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);
        }
コード例 #16
0
        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);
        }
コード例 #17
0
        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));
        }
コード例 #18
0
        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;
            };
        }
コード例 #19
0
 public CardPickForCondition(GameStatePredicate predicate, ICardPicker picker)
 {
     this.picker    = picker;
     this.predicate = predicate;
 }
コード例 #20
0
 public CardPickForCondition(GameStatePredicate predicate, ICardPicker picker)
 {
     this.picker = picker;
     this.predicate = predicate;
 }
コード例 #21
0
 public static bool HasCardIn(Card card, ICardPicker matchingCards, GameState gameState)
 {
     return(matchingCards.GetPreferredCard(gameState, c => c == card) != null);
 }
コード例 #22
0
 public static bool HasCardFromInHand(ICardPicker matchingCards, GameState gameState)
 {
     return(WhichCardFromInHand(matchingCards, gameState) != null);
 }
コード例 #23
0
 public static void AddAllCards(HashSet<Card> cardSet, ICardPicker matchingCards)
 {
     foreach (Card card in matchingCards.GetNeededCards())
     {
         cardSet.Add(card);
     }
 }
コード例 #24
0
 public SortCardByDefaultActionOrder(ICardPicker purchaseOrder)
 {
     this.purchaseOrder = purchaseOrder;
 }
コード例 #25
0
 public static ICardPicker DefaultActionPlayOrder(ICardPicker purchaseOrder)
 {
     return(new CardPickFromWhatsInHand(new SortCardByDefaultActionOrder(purchaseOrder)));
 }
コード例 #26
0
            // 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);
            }
コード例 #27
0
 public Comparer(GameState gameState, ICardPicker purchaseOrder)
 {
     this.gameState     = gameState;
     this.purchaseOrder = purchaseOrder;
 }
コード例 #28
0
 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));
 }
コード例 #29
0
 public static bool DoesCardPickerMatch(this ICardPicker pickOrder, GameState gameState, Card card)
 {
     return(pickOrder.GetPreferredCard(gameState, c => c == card) != null);
 }
コード例 #30
0
ファイル: Strategy.cs プロジェクト: NathanTeeuwen/Dominulator
 public static bool HasCardFromInHand(ICardPicker matchingCards, GameState gameState)
 {
     return WhichCardFromInHand(matchingCards, gameState) != null;
 }
コード例 #31
0
ファイル: Strategy.cs プロジェクト: NathanTeeuwen/Dominulator
 public static bool HasCardIn(Card card, ICardPicker matchingCards, GameState gameState)
 {
     return matchingCards.GetPreferredCard(gameState, c => c == card) != null;
 }
コード例 #32
0
ファイル: Strategy.cs プロジェクト: NathanTeeuwen/Dominulator
 public static Card WhichCardFromInHand(ICardPicker matchingCards, GameState gameState)
 {
     return matchingCards.GetPreferredCard(gameState, card => gameState.Self.Hand.HasCard(card));
 }
コード例 #33
0
 public static Card WhichCardFromInHand(ICardPicker matchingCards, GameState gameState)
 {
     return(matchingCards.GetPreferredCard(gameState, card => gameState.Self.Hand.HasCard(card)));
 }
コード例 #34
0
ファイル: Strategy.cs プロジェクト: NathanTeeuwen/Dominulator
 public static int CountAllOwned(ICardPicker matchingCards, GameState gameState)
 {
     return gameState.Self.AllOwnedCards.CountWhere(
         card => matchingCards.GetPreferredCard(gameState, testCard => testCard == card) != null);
 }
コード例 #35
0
 public static int CountInHandFrom(ICardPicker matchingCards, GameState gameState)
 {
     return(gameState.Self.Hand.CountWhere(card => matchingCards.GetPreferredCard(gameState, current => current == card) != null));
 }
コード例 #36
0
ファイル: Strategy.cs プロジェクト: NathanTeeuwen/Dominulator
 public static int CountInHandFrom(ICardPicker matchingCards, GameState gameState)
 {
     return gameState.Self.Hand.CountWhere(card => matchingCards.GetPreferredCard(gameState, current => current == card) != null);
 }
コード例 #37
0
 public static int CountAllOwned(ICardPicker matchingCards, GameState gameState)
 {
     return(gameState.Self.AllOwnedCards.CountWhere(
                card => matchingCards.GetPreferredCard(gameState, testCard => testCard == card) != null));
 }
コード例 #38
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);
                }
            };
        }