Exemple #1
0
 public override void PlayAttack(GameModel gameModel, IEnumerable<Player> attackedPlayers)
 {
     bool hitKnight = false;
     foreach (Player player in attackedPlayers)
     {
         IEnumerable<CardModel> cards = player.DrawCards(2);
         IEnumerable<CardModel> eligible = cards.Where(c => gameModel.GetCost(c) >= 3 && gameModel.GetCost(c) <= 6 && !c.CostsPotion);
         CardModel choice = player.Chooser.ChooseOneCard(CardChoiceType.TrashForKnight, "Choose a card to trash", Chooser.ChoiceSource.None, eligible);
         if (choice != null)
         {
             player.Trash(choice);
             if (choice.Is(CardType.Knight))
             {
                 hitKnight = true;
             }
         }
         foreach (CardModel card in cards)
         {
             if (card != choice)
             {
                 player.DiscardCard(card);
             }
         }
     }
     if (hitKnight)
     {
         gameModel.CurrentPlayer.Trash(this.ThisAsTrashTarget);
     }
 }
Exemple #2
0
 public override void OnTrash(GameModel gameModel, Player owner)
 {
     IEnumerable<Pile> piles = gameModel.SupplyPiles.Where(p => (p.GetCost() < gameModel.GetCost(this) && (!p.CostsPotion || this.CostsPotion)) || p.GetCost() == gameModel.GetCost(this) && !p.CostsPotion && this.CostsPotion);
     if(piles.Any())
     {
         Pile choice = owner.Chooser.ChooseOnePile(CardChoiceType.Gain, "Gain a card costing less than $" + gameModel.GetCost(this), piles);
         owner.GainCard(choice);
     }
 }
Exemple #3
0
 public override void PlayPostAttack(GameModel gameModel)
 {
     if (this.choice != null)
     {
         Pile pile = gameModel.CurrentPlayer.Chooser.ChooseOnePile(CardChoiceType.GainOnTopOfDeck, "Gain a treasure costing up to $" + (gameModel.GetCost(this.choice) + 3).ToString() + (this.choice.CostsPotion ? "P" : ""), gameModel.SupplyPiles.Where(p => p.Count > 0 && p.Card.Is(CardType.Treasure) && p.GetCost() <= gameModel.GetCost(this.choice) + 3 && (!p.CostsPotion || this.choice.CostsPotion)));
         if (pile != null)
         {
             gameModel.CurrentPlayer.GainCard(pile, GainLocation.TopOfDeck);
         }
     }
 }
Exemple #4
0
 public override void OnBuy(GameModel gameModel)
 {
     if (gameModel.CurrentPlayer.Hand.Count > 0)
     {
         CardModel choice = gameModel.CurrentPlayer.Chooser.ChooseOneCard(CardChoiceType.TrashForFarmland, "Trash a card", ChoiceSource.FromHand, gameModel.CurrentPlayer.Hand);
         gameModel.CurrentPlayer.Trash(choice);
         IEnumerable<Pile> piles = gameModel.SupplyPiles.Where(pile => gameModel.GetCost(pile) == gameModel.GetCost(choice) + 2 && choice.CostsPotion == pile.CostsPotion && pile.Count > 0);
         if (piles.Any())
         {
             Pile chosenPile = gameModel.CurrentPlayer.Chooser.ChooseOnePile(CardChoiceType.Gain, "Gain a card costing $" + (gameModel.GetCost(choice) + 2), piles);
             gameModel.CurrentPlayer.GainCard(chosenPile);
         }
     }
 }
Exemple #5
0
        public override void Play(GameModel gameModel)
        {
            CardModel trashedCard = gameModel.CurrentPlayer.Chooser.ChooseOneCard(CardChoiceType.TrashForExpand, "Choose a card to trash with Expand", ChoiceSource.FromHand, gameModel.CurrentPlayer.Hand);
            if (trashedCard != null)
            {
                gameModel.CurrentPlayer.Trash(trashedCard);
                Pile newChoice = gameModel.CurrentPlayer.Chooser.ChooseOnePile(CardChoiceType.Gain, "Gain a card costing up to $" + (gameModel.GetCost(trashedCard) + 3).ToString(),
                    gameModel.SupplyPiles.Where(pile => gameModel.GetCost(pile) <= gameModel.GetCost(trashedCard) + 3 && pile.Count > 0 && (trashedCard.CostsPotion || !pile.CostsPotion)));

                if (newChoice != null)
                {
                    gameModel.CurrentPlayer.GainCard(newChoice);
                }
            }
        }
Exemple #6
0
 public override void Play(GameModel gameModel)
 {
     IEnumerable<CardModel> trash = gameModel.Trash.Where(c => gameModel.GetCost(c) >= 3 && gameModel.GetCost(c) <= 6 && !c.CostsPotion);
     if (trash.Any())
     {
         this.foundTrash = true;
         CardModel card = gameModel.CurrentPlayer.Chooser.ChooseOneCard(CardChoiceType.Gain, "Gain a card costing between $3 and $6 from the trash.", Chooser.ChoiceSource.FromTrash, trash);
         gameModel.CurrentPlayer.GainCard(card, null);
         gameModel.Trash.Remove(card);
     }
     else
     {
         this.foundTrash = false;
     }
 }
Exemple #7
0
 private void DoRemake(GameModel gameModel)
 {
     CardModel trashedCard = gameModel.CurrentPlayer.Chooser.ChooseOneCard(CardChoiceType.TrashForRemake, "Trash a card", ChoiceSource.FromHand, gameModel.CurrentPlayer.Hand);
     if (trashedCard != null)
     {
         gameModel.CurrentPlayer.Trash(trashedCard);
         Pile newChoice = gameModel.CurrentPlayer.Chooser.ChooseOnePile(CardChoiceType.Gain, "Gain a card costing $" + (gameModel.GetCost(trashedCard) + 1).ToString(), gameModel.SupplyPiles.Where(pile =>
                                                         gameModel.GetCost(pile) == gameModel.GetCost(trashedCard) + 1 && pile.Count > 0 &&
                                                         (trashedCard.CostsPotion == pile.CostsPotion)));
         if (newChoice != null)
         {
             gameModel.CurrentPlayer.GainCard(newChoice);
         }
     }
 }
Exemple #8
0
 public override void Play(GameModel gameModel)
 {
     CardModel trashedCard = gameModel.CurrentPlayer.Chooser.ChooseOneCard(CardChoiceType.TrashForRemodel, "Choose a card to Remodel", ChoiceSource.FromHand, gameModel.CurrentPlayer.Hand);
     if (trashedCard != null)
     {
         gameModel.CurrentPlayer.Trash(trashedCard);
         Pile newChoice = gameModel.CurrentPlayer.Chooser.ChooseOnePile(CardChoiceType.Gain, "Choose a card to gain", gameModel.SupplyPiles.Where(pile =>
                                                         gameModel.GetCost(pile) <= gameModel.GetCost(trashedCard) + 2 && pile.Count > 0 &&
                                                         (trashedCard.CostsPotion || !pile.CostsPotion)));
         if (newChoice != null)
         {
             gameModel.CurrentPlayer.GainCard(newChoice);
         }
     }
 }
Exemple #9
0
 public override void BeforePlay(GameModel gameModel)
 {
     if (this.mimic == null)
     {
         CardModel target = null;
         if (this.forceMimic != null)
         {
             target = this.forceMimic;
         }
         else
         {
             Pile pile = gameModel.CurrentPlayer.Chooser.ChooseOnePile(CardChoiceType.BandOfMisfits, "Play Band of Misfits as...", gameModel.SupplyPiles.Where(p => p.GetCost() < gameModel.GetCost(this) && !p.CostsPotion && p.Count > 0 && p.Card.Is(CardType.Action)));
             if (pile != null)
             {
                 target = (CardModel)Activator.CreateInstance(pile.TopCard.GetType());
             }
         }
         if (target != null)
         {
             this.mimic = target;
             if (this.lockCount > 0)
             {
                 this.forceMimic = target;
             }
             this.SetMimic();
         }
     }
 }
Exemple #10
0
 public override void Play(GameModel gameModel)
 {
     IEnumerable<CardModel> trashedCards = gameModel.CurrentPlayer.Chooser.ChooseSeveralCards(CardChoiceType.TrashForForge, "Choose cards to trash", ChoiceSource.FromHand, 0, gameModel.CurrentPlayer.Hand.Count, gameModel.CurrentPlayer.Hand);
     int cost = 0;
     foreach (CardModel card in trashedCards.ToList())
     {
         gameModel.CurrentPlayer.Trash(card);
         cost += gameModel.GetCost(card);
     }
     IEnumerable<Pile> piles = from pile in gameModel.SupplyPiles where gameModel.GetCost(pile) == cost && pile.Count > 0 && !pile.CostsPotion select pile;
     Pile newChoice = gameModel.CurrentPlayer.Chooser.ChooseOnePile(CardChoiceType.Gain, "Gain a card costing " + cost, piles);
     if (newChoice != null)
     {
         gameModel.CurrentPlayer.GainCard(newChoice);
     }
 }
Exemple #11
0
 public override void Play(GameModel gameModel)
 {
     IEnumerable<CardModel> treasures = gameModel.CurrentPlayer.Hand.Where(card => card.Is(CardType.Treasure));
     Player currentPlayer = gameModel.CurrentPlayer;
     if (treasures.Any())
     {
         CardModel chosenCard = currentPlayer.Chooser.ChooseOneCard(CardChoiceType.TrashForMine, "Trash a treasure from your hand", ChoiceSource.FromHand, treasures);
         currentPlayer.Trash(chosenCard);
         Pile newCardPile = currentPlayer.Chooser.ChooseOnePile(CardChoiceType.GainInHand, "Gain a treasure costing up to $" + (gameModel.GetCost(chosenCard) + 3).ToString(),
             gameModel.SupplyPiles.Where(pile => pile.Card.Is(CardType.Treasure) && gameModel.GetCost(pile) <= gameModel.GetCost(chosenCard) + 3 &&
                 (chosenCard.CostsPotion || !pile.CostsPotion)));
         if (newCardPile != null)
         {
             currentPlayer.GainCard(newCardPile, GainLocation.InHand);
         }
     }
 }
Exemple #12
0
 public override void Play(GameModel gameModel)
 {
     Pile choice = gameModel.CurrentPlayer.Chooser.ChooseZeroOrOnePile(CardChoiceType.Gain, "You may gain an action costing up to $5", gameModel.SupplyPiles.Where(
                                                                 pile => gameModel.GetCost(pile) <= 5 && pile.Count > 0 && !pile.CostsPotion && pile.Card.Is(CardType.Action)));
     if (choice != null)
     {
         gameModel.CurrentPlayer.GainCard(choice);
     }
 }
Exemple #13
0
 public override void Play(GameModel gameModel)
 {
     IEnumerable<Pile> piles = gameModel.SupplyPiles.Where(pile => pile.Count > 0 && gameModel.GetCost(pile) <= 4 && !pile.CostsPotion);
     Pile chosenPile = gameModel.CurrentPlayer.Chooser.ChooseOnePile(CardChoiceType.Gain, "Gain a card costing up to $4", piles);
     if (chosenPile != null)
     {
         gameModel.CurrentPlayer.GainCard(chosenPile);
     }
 }
Exemple #14
0
 public override void Play(GameModel gameModel)
 {
     CardModel card = gameModel.CurrentPlayer.Chooser.ChooseOneCard(CardChoiceType.TrashForSalvager, "Choose a card to trash with Salvager", ChoiceSource.FromHand, gameModel.CurrentPlayer.Hand);
     if (card != null)
     {
         gameModel.CurrentPlayer.AddActionCoin(gameModel.GetCost(card));
         gameModel.CurrentPlayer.Trash(card);
     }
 }
Exemple #15
0
 public override void Play(GameModel gameModel)
 {
     Pile pile = gameModel.CurrentPlayer.Chooser.ChooseOnePile(CardChoiceType.Gain, "Gain a card costing $5 or less", gameModel.SupplyPiles.Where(p => gameModel.GetCost(p) <= 5 && !p.CostsPotion && p.Count > 0));
     gameModel.CurrentPlayer.Trash(this);
     if (pile != null)
     {
         gameModel.CurrentPlayer.GainCard(pile);
     }
 }
Exemple #16
0
        public override void PlayAttack(GameModel gameModel, IEnumerable<Player> attackedPlayers)
        {
            Player currentPlayer = gameModel.CurrentPlayer;

            foreach(Player player in attackedPlayers)
            {
                CardModel trashedCard = player.DrawCard();
                if (trashedCard != null)
                {
                    int cost = gameModel.GetCost(trashedCard);
                    player.Trash(trashedCard);
                    Pile pile = currentPlayer.Chooser.ChooseOnePile(CardChoiceType.ForceGain, "Pick a card for " + player.Name + " to gain", gameModel.SupplyPiles.Where(p => p.Count > 0 && gameModel.GetCost(p) == cost && p.CostsPotion == trashedCard.CostsPotion));
                    if (pile != null)
                    {
                        player.GainCard(pile);
                    }
                }
            }
        }
Exemple #17
0
        public override void Play(GameModel gameModel)
        {
            IEnumerable<CardModel> cardsInTrash = gameModel.Trash.Where(c => gameModel.GetCost(c) >= 3 && gameModel.GetCost(c) <= 6 && !c.CostsPotion);
            IEnumerable<CardModel> cardsInHand = gameModel.CurrentPlayer.Hand.Where(c => c.Is(CardType.Action));

            bool gainFromTrash = false;
            if (cardsInHand.Any() && cardsInTrash.Any())
            {
                int choice = gameModel.CurrentPlayer.Chooser.ChooseOneEffect(EffectChoiceType.Graverobber, "Choose one", choices, choiceText);
                gainFromTrash = choice == 1;
            }
            else if(cardsInHand.Any() && !cardsInTrash.Any())
            {
                gainFromTrash = false;
            }
            else if (!cardsInHand.Any() && cardsInTrash.Any())
            {
                gainFromTrash = true;
            }
            else
            {
                return;
            }
            if (gainFromTrash)
            {
                CardModel choice = gameModel.CurrentPlayer.Chooser.ChooseOneCard(CardChoiceType.GainOnTopOfDeck, "Gain a card from the trash costing between $3 and $6", Chooser.ChoiceSource.FromTrash, cardsInTrash);
                gameModel.Trash.Remove(choice);
                gameModel.CurrentPlayer.GainCard(choice, null, GainLocation.TopOfDeck);
            }
            else
            {
                CardModel choice = gameModel.CurrentPlayer.Chooser.ChooseOneCard(CardChoiceType.TrashForGraverobber, "Trash an action from your hand", Chooser.ChoiceSource.FromHand, cardsInHand.Where(c => c.Is(CardType.Action)));
                gameModel.CurrentPlayer.Trash(choice);
                IEnumerable<Pile> piles = gameModel.SupplyPiles.Where(p => p.Count > 0 && p.GetCost() <= gameModel.GetCost(choice) + 3 && (!p.CostsPotion || choice.CostsPotion));
                Pile pile = gameModel.CurrentPlayer.Chooser.ChooseOnePile(CardChoiceType.Gain, "Gain a card costing up to $" + (gameModel.GetCost(choice) + 3).ToString(), piles);
                if (pile != null)
                {
                    gameModel.CurrentPlayer.GainCard(pile);
                }
            }
        }
Exemple #18
0
 public override void Play(GameModel gameModel)
 {
     CardModel choice = gameModel.CurrentPlayer.Chooser.ChooseZeroOrOneCard(CardChoiceType.Procession, "You may play an action card from your hand twice.", Chooser.ChoiceSource.FromHand, gameModel.CurrentPlayer.Hand.Where(c => c.Is(CardType.Action)));
     if (choice != null)
     {
         using (choice.ForceMultipleCardPlayChoice())
         {
             gameModel.CurrentPlayer.Play(choice, false, true);
             gameModel.CurrentPlayer.Play(choice, false, false, " a second time");
         }
         if (gameModel.CurrentPlayer.Played.Contains(choice))
         {
             gameModel.CurrentPlayer.Trash(choice);
         }
         Pile pile = gameModel.CurrentPlayer.Chooser.ChooseOnePile(CardChoiceType.Gain, "Gain an action card costing $" + (gameModel.GetCost(choice) + 1).ToString(), gameModel.SupplyPiles.Where(p => p.Count > 0 && p.GetCost() == gameModel.GetCost(choice) + 1 && p.CostsPotion == choice.CostsPotion && p.Card.Is(CardType.Action)));
         if (pile != null)
         {
             gameModel.CurrentPlayer.GainCard(pile);
         }
     }
 }
Exemple #19
0
 public override void Play(GameModel gameModel)
 {
     CardModel card = gameModel.CurrentPlayer.Chooser.ChooseOneCard(CardChoiceType.TrashForStonemason, "Trash a card from your hand.", ChoiceSource.FromHand, gameModel.CurrentPlayer.Hand);
     if (card != null)
     {
         gameModel.CurrentPlayer.Trash(card);
         for (int i = 0; i < 2; i++)
         {
             Pile pile = gameModel.CurrentPlayer.Chooser.ChooseOnePile(CardChoiceType.Gain, "Gain a card costing less than $" + gameModel.GetCost(card),
                 gameModel.SupplyPiles.Where(
                 p =>
                     p.Count > 0 &&
                     (p.GetCost() < gameModel.GetCost(card) && (!p.CostsPotion || p.CostsPotion && card.CostsPotion) ||
                 (p.GetCost() == gameModel.GetCost(card) && !p.CostsPotion && card.CostsPotion))));
             if (pile != null)
             {
                 gameModel.CurrentPlayer.GainCard(pile);
             }
         }
     }
 }
Exemple #20
0
        public override void PlayAttack(GameModel gameModel, IEnumerable<Player> attackedPlayers)
        {
            Player currentPlayer = gameModel.CurrentPlayer;

            foreach (Player player in attackedPlayers)
            {
                List<CardModel> setAside = new List<CardModel>();
                CardModel card = player.DrawCard();
                while (card != null)
                {
                    gameModel.TextLog.WriteLine(player.Name + " reveals " + card.Name);
                    if (gameModel.GetCost(card) >= 3)
                    {
                        break;
                    }
                    else
                    {
                        setAside.Add(card);
                    }
                    card = player.DrawCard();
                }

                if (card != null)
                {
                    player.Trash(card);
                    Pile choice = player.Chooser.ChooseZeroOrOnePile(CardChoiceType.Gain, "You may gain a card costing up to $" + (gameModel.GetCost(card) - 2).ToString(),
                        gameModel.SupplyPiles.Where(p => gameModel.GetCost(p) <= gameModel.GetCost(card) - 2 && (card.CostsPotion || !p.CostsPotion) && p.Count > 0));

                    if (choice != null)
                    {
                        player.GainCard(choice);
                    }
                }

                foreach (CardModel temp in setAside)
                {
                    player.DiscardCard(temp);
                }
            }
        }
Exemple #21
0
 public override void Play(GameModel gameModel)
 {
     int value = gameModel.CurrentPlayer.Played.Select(card => card.Name).Distinct().Count();
     Pile choice = gameModel.CurrentPlayer.Chooser.ChooseOnePile(CardChoiceType.GainForHornOfPlenty, "Gain a card costing up to $" + value.ToString(), gameModel.SupplyPiles.Where(pile => gameModel.GetCost(pile) <= value && !pile.CostsPotion && pile.Count > 0));
     if (choice != null)
     {
         CardModel card = gameModel.CurrentPlayer.GainCard(choice);
         if (card != null && card.Is(CardType.Victory))
         {
             gameModel.CurrentPlayer.Trash(this);
         }
     }
 }
Exemple #22
0
 public override void PlayAttack(GameModel gameModel, IEnumerable<Player> attackedPlayers)
 {
     if (gameModel.CurrentPlayer.JourneyTokenIsFaceUp)
     {
         foreach (Player player in attackedPlayers)
         {
             CardModel card = player.DrawCards(1).FirstOrDefault();
             if(card != null)
             {
                 if (gameModel.GetCost(card) >= 3 && gameModel.GetCost(card) <= 6 && !card.CostsPotion)
                 {
                     player.Trash(card);
                 }
                 else
                 {
                     player.DiscardCard(card);
                     player.GainCard(typeof(Curse));
                 }
             }
         }
     }
 }
Exemple #23
0
 public override void Play(GameModel gameModel)
 {
     if (gameModel.CurrentPlayer.Hand.Count > 0)
     {
         CardModel choice = gameModel.CurrentPlayer.Chooser.ChooseOneCard(CardChoiceType.TrashForTrader, "Trash a card", ChoiceSource.FromHand, gameModel.CurrentPlayer.Hand);
         int cost = gameModel.GetCost(choice);
         gameModel.CurrentPlayer.Trash(choice);
         for (int i = 0; i < cost; i++)
         {
             gameModel.CurrentPlayer.GainCard(typeof(Silver));
         }
     }
 }
Exemple #24
0
 public override void PlayAttack(GameModel gameModel, IEnumerable<Player> attackedPlayers)
 {
     if (!this.foundTrash)
     {
         foreach (Player player in attackedPlayers)
         {
             IEnumerable<CardModel> cards = player.DrawCards(2);
             IEnumerable<CardModel> eligible = cards.Where(c => gameModel.GetCost(c) >= 3 && gameModel.GetCost(c) <= 6 && !c.CostsPotion);
             CardModel choice = player.Chooser.ChooseOneCard(CardChoiceType.Trash, "Choose a card to trash", Chooser.ChoiceSource.None, eligible);
             if (choice != null)
             {
                 player.Trash(choice);
             }
             foreach (CardModel card in cards)
             {
                 if (card != choice)
                 {
                     player.DiscardCard(card);
                 }
             }
         }
     }
 }
Exemple #25
0
        public override void Play(GameModel gameModel)
        {
            CardModel choice = gameModel.CurrentPlayer.Chooser.ChooseOneCard(CardChoiceType.NameACardForRebuild, "Name a card", Chooser.ChoiceSource.None, gameModel.AllCardsInGame.Where(c => c.Is(CardType.Victory)).Union(new CardModel[] { new Copper() }));
            CardModel found = null;
            List<CardModel> setAside = new List<CardModel>();
            do
            {
                CardModel card = gameModel.CurrentPlayer.DrawCard();
                if (card != null && card.Is(CardType.Victory) && card.Name != choice.Name)
                {
                    found = card;
                }
                else
                {
                    if (card == null)
                    {
                        break;
                    }
                    setAside.Add(card);
                }
            } while (found == null);

            foreach (CardModel card in setAside)
            {
                gameModel.CurrentPlayer.DiscardCard(card);
            }

            if (found != null)
            {
                gameModel.CurrentPlayer.Trash(found);
                Pile pile = gameModel.CurrentPlayer.Chooser.ChooseOnePile(CardChoiceType.Gain, "Gain a Victory card costing up to $" + (gameModel.GetCost(found) + 3).ToString() + (found.CostsPotion ? "P" : ""), gameModel.SupplyPiles.Where(p => p.Count > 0 && p.TopCard.Is(CardType.Victory) && p.GetCost() <= gameModel.GetCost(found) + 3 && (!p.CostsPotion || found.CostsPotion)));
                if (pile != null)
                {
                    gameModel.CurrentPlayer.GainCard(pile);
                }
            }
        }
Exemple #26
0
        public override void Play(GameModel gameModel)
        {
            Player player = gameModel.CurrentPlayer;
            CardModel choice = player.Chooser.ChooseOneCard(CardChoiceType.TrashForApprentice, "Trash a card", Chooser.ChoiceSource.FromHand, player.Hand);
            if (choice != null)
            {
                int cost = gameModel.GetCost(choice);
                if (choice.CostsPotion)
                {
                    cost += 2;
                }

                player.Trash(choice);
                player.Draw(cost);
            }
        }
Exemple #27
0
 public override void OnBuy(GameModel gameModel)
 {
     if(gameModel.CurrentPlayer.Bought.Count == 0)
     {
         IEnumerable<Pile> piles = gameModel.SupplyPiles.Where(pile => pile.Count > 0 && gameModel.GetCost(pile) <= 4 && !pile.CostsPotion);
         Pile chosenPile = gameModel.CurrentPlayer.Chooser.ChooseOnePile(CardChoiceType.Gain, "Gain a card costing up to $4", piles);
         if (chosenPile != null)
         {
             gameModel.CurrentPlayer.GainCard(chosenPile);
             foreach(Player otherPlayer in gameModel.Players)
             {
                 if(otherPlayer != gameModel.CurrentPlayer)
                 {
                     otherPlayer.GainCard(chosenPile);
                 }
             }
         }
     }
 }
Exemple #28
0
 public override void PlayAttack(GameModel gameModel, IEnumerable<Player> attackedPlayers)
 {
     for (int i = 0; i < gameModel.CurrentPlayer.Played.Count(c => c.Is(CardType.Traveller)) + 1; i++)
     {
         foreach (Player player in attackedPlayers)
         {
             CardModel topCard = player.DrawCard();
             int cost = gameModel.GetCost(topCard);
             if ((cost == 3 || cost == 4) && !topCard.CostsPotion)
             {
                 player.Trash(topCard);
             }
             else
             {
                 player.DiscardCard(topCard);
             }
         }
     }
 }
Exemple #29
0
 public override void Play(GameModel gameModel)
 {
     IEnumerable<CardModel> sources = gameModel.CurrentPlayer.Hand.Union(new CardModel[] {this});
     CardModel card = gameModel.CurrentPlayer.Chooser.ChooseOneCard(Chooser.CardChoiceType.Raze, "Trash this or a card from your hand", Chooser.ChoiceSource.FromHand, sources);
     if (card != null)
     {
         gameModel.CurrentPlayer.Trash(card.ThisAsTrashTarget);
         int cost = gameModel.GetCost(card);
         IList<CardModel> lookAt = gameModel.CurrentPlayer.DrawCards(cost);
         CardModel put = gameModel.CurrentPlayer.Chooser.ChooseOneCard(Chooser.CardChoiceType.PutInHand, "Put one into your hand and discard the rest", Chooser.ChoiceSource.None, lookAt);
         if(put != null)
         {
             lookAt.Remove(put);
             gameModel.CurrentPlayer.PutInHand(put);
             foreach (CardModel discard in lookAt)
             {
                 gameModel.CurrentPlayer.DiscardCard(discard);
             }
         }
     }
 }
Exemple #30
0
 public override void Play(GameModel gameModel)
 {
     int choice = gameModel.CurrentPlayer.Chooser.ChooseOneEffect(Chooser.EffectChoiceType.Prince, "You may set aside Prince", setAside, setAside);
     if (choice == 0)
     {
         bool didSetAside = gameModel.CurrentPlayer.Played.Remove(this);
         if (didSetAside)
         {
             gameModel.CurrentPlayer.SetAsidePrince.Add(this);
             CardModel card = gameModel.CurrentPlayer.Chooser.ChooseOneCard(Chooser.CardChoiceType.Prince, "Choose a card to set aside for Prince", Chooser.ChoiceSource.FromHand, gameModel.CurrentPlayer.Hand.Where(c => c.Is(CardType.Action) && gameModel.GetCost(c) <= 4 && !c.CostsPotion));
             if (card != null)
             {
                 gameModel.TextLog.WriteLine(gameModel.CurrentPlayer.Name + " sets aside " + card.Name);
                 gameModel.CurrentPlayer.Hand.Remove(card);
                 gameModel.CurrentPlayer.SetAsidePrincePlay.Add(card);
                 card.PlayedWithPrinceSource = this;
             }
         }
     }
     base.Play(gameModel);
 }