Example #1
0
        public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
        {
            PlayerActionChoice choice = currentPlayer.RequestPlayerChooseBetween(gameState,
                acceptableChoice =>
                    acceptableChoice == PlayerActionChoice.PlusAction ||
                    acceptableChoice == PlayerActionChoice.PlusBuy ||
                    acceptableChoice == PlayerActionChoice.GainCard);

            switch (choice)
            {
                case PlayerActionChoice.PlusAction: currentPlayer.AddActions(2); break;
                case PlayerActionChoice.PlusBuy: currentPlayer.AddBuys(2); break;
                case PlayerActionChoice.GainCard: currentPlayer.GainCardFromSupply(Cards.Silver, gameState); break;
                default: throw new Exception();
            }
        }
Example #2
0
        public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
        {
            IsValidChoice choices = delegate(PlayerActionChoice choice)
            {
                return(choice == PlayerActionChoice.PlusCard ||
                       choice == PlayerActionChoice.PlusAction ||
                       choice == PlayerActionChoice.PlusCoin ||
                       choice == PlayerActionChoice.GainCard);
            };

            PlayerActionChoice choice1 = currentPlayer.RequestPlayerChooseBetween(gameState, choices);
            PlayerActionChoice choice2 = currentPlayer.RequestPlayerChooseBetween(gameState, c => choices(c) && c != choice1);

            ApplyChoice(choice1, currentPlayer, gameState);
            ApplyChoice(choice2, currentPlayer, gameState);
        }
Example #3
0
        public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
        {
            currentPlayer.LookAtCardsFromDeck(5);
            PlayerActionChoice choice = currentPlayer.RequestPlayerChooseBetween(gameState,
                                                                                 acceptableChoice => acceptableChoice == PlayerActionChoice.Discard ||
                                                                                 acceptableChoice == PlayerActionChoice.TopDeck);

            if (choice == PlayerActionChoice.TopDeck)
            {
                currentPlayer.RequestPlayerTopDeckRevealedCardsInAnyOrder(gameState);
            }
            else if (choice == PlayerActionChoice.Discard)
            {
                currentPlayer.MoveRevealedCardsToDiscard(gameState);
            }
        }
Example #4
0
        public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
        {
            PlayerActionChoice choice = currentPlayer.RequestPlayerChooseBetween(gameState,
                                                                                 acceptableChoice => acceptableChoice == PlayerActionChoice.PutNativeVillageMatInHand ||
                                                                                 acceptableChoice == PlayerActionChoice.SetAsideTopCardOnNativeVillageMat);

            if (choice == PlayerActionChoice.PutNativeVillageMatInHand)
            {
                currentPlayer.MoveNativeVillageMatToHand();
            }
            else if (choice == PlayerActionChoice.SetAsideTopCardOnNativeVillageMat)
            {
                currentPlayer.MoveCardFromPlayedCardToNativeVillageMatt(this);
                currentPlayer.PutOnNativeVillageMatCardFromTopOfDeck();
            }
        }
Example #5
0
        public override void DoSpecializedAttack(PlayerState currentPlayer, PlayerState otherPlayer, GameState gameState)
        {
            PlayerActionChoice playerChoice = otherPlayer.RequestPlayerChooseBetween(
                gameState,
                acceptableChoice => acceptableChoice == PlayerActionChoice.Discard ||
                acceptableChoice == PlayerActionChoice.GainCard);

            switch (playerChoice)
            {
            case PlayerActionChoice.Discard: otherPlayer.RequestPlayerDiscardCardsFromHand(gameState, 2, isOptional: false); break;

            case PlayerActionChoice.GainCard: otherPlayer.GainCardFromSupply(Curse.card, gameState, DeckPlacement.Hand); break;

            default: throw new Exception("Invalid Choice");
            }
        }
Example #6
0
        public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
        {
            PlayerActionChoice actionChoice = currentPlayer.RequestPlayerChooseBetween(
                gameState,
                acceptableChoice => acceptableChoice == PlayerActionChoice.PlusCard ||
                acceptableChoice == PlayerActionChoice.PlusCoin ||
                acceptableChoice == PlayerActionChoice.Trash);

            switch (actionChoice)
            {
            case PlayerActionChoice.PlusCard: currentPlayer.DrawAdditionalCardsIntoHand(2, gameState); break;

            case PlayerActionChoice.PlusCoin: currentPlayer.AddCoins(2); break;

            case PlayerActionChoice.Trash: currentPlayer.RequestPlayerTrashCardsFromHand(gameState, 2, false); break;

            default: throw new Exception("Invalid case");
            }
        }
Example #7
0
        public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
        {
            IsValidChoice acceptableFirstChoice = delegate(PlayerActionChoice acceptableChoice)
            {
                return(acceptableChoice == PlayerActionChoice.PlusCard ||
                       acceptableChoice == PlayerActionChoice.PlusAction ||
                       acceptableChoice == PlayerActionChoice.PlusBuy ||
                       acceptableChoice == PlayerActionChoice.PlusCoin);
            };

            PlayerActionChoice firstChoice = currentPlayer.RequestPlayerChooseBetween(
                gameState,
                acceptableFirstChoice);

            PlayerActionChoice secondChoice = currentPlayer.RequestPlayerChooseBetween(
                gameState,
                acceptableSecondChoice => acceptableSecondChoice != firstChoice && acceptableFirstChoice(acceptableSecondChoice));

            DoActionChoice(currentPlayer, firstChoice, gameState);
            DoActionChoice(currentPlayer, secondChoice, gameState);
        }
Example #8
0
 public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
 {
     currentPlayer.RevealCardsFromDeck(3, gameState);
     PlayerActionChoice choice = currentPlayer.RequestPlayerChooseBetween(gameState, actionChoice => actionChoice == PlayerActionChoice.Discard || actionChoice == PlayerActionChoice.PutInHand);
     switch (choice)
     {
         case PlayerActionChoice.Discard:
             {
                 currentPlayer.MoveRevealedCardsToDiscard(gameState);
                 currentPlayer.DrawAdditionalCardsIntoHand(3, gameState);
                 break;
             }
         case PlayerActionChoice.PutInHand:
             {
                 currentPlayer.MoveAllRevealedCardsToHand();
                 break;
             }
         default:
             throw new Exception();
     }
 }
Example #9
0
        public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
        {
            PlayerActionChoice choice = currentPlayer.RequestPlayerChooseBetween(gameState, c =>
                                                                                 c == PlayerActionChoice.PutCopperOnTavernMat ||
                                                                                 c == PlayerActionChoice.PlusCoinPerCoppperOnTavernMat);

            switch (choice)
            {
            case PlayerActionChoice.PutCopperOnTavernMat:
            {
                currentPlayer.MoveCardFromHandToTavernMatt(Cards.Copper);
                break;
            }

            case PlayerActionChoice.PlusCoinPerCoppperOnTavernMat:
            {
                int copperCount = PlayerMiserValue(currentPlayer);
                currentPlayer.AddCoins(copperCount);
                break;
            }
            }
        }
Example #10
0
        public override void DoSpecializedAttack(PlayerState currentPlayer, PlayerState otherPlayer, GameState gameState)
        {
            otherPlayer.RevealCardsFromDeck(2);
            PlayerActionChoice choice = currentPlayer.RequestPlayerChooseBetween(gameState, actionChoice => actionChoice == PlayerActionChoice.Discard || actionChoice == PlayerActionChoice.TopDeck);

            switch (choice)
            {
            case PlayerActionChoice.Discard:
            {
                otherPlayer.MoveRevealedCardsToDiscard(gameState);
                break;
            }

            case PlayerActionChoice.TopDeck:
            {
                otherPlayer.RequestPlayerTopDeckRevealedCardsInAnyOrder(gameState);
                break;
            }

            default:
                throw new Exception();
            }
        }
Example #11
0
        public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
        {
            PlayerActionChoice choice = currentPlayer.RequestPlayerChooseBetween(gameState, 
                acceptableChoice => acceptableChoice == PlayerActionChoice.GainCard || acceptableChoice == PlayerActionChoice.Trash);

            if (choice == PlayerActionChoice.GainCard)
            {
                currentPlayer.RequestPlayerGainCardFromTrash(gameState,
                    acceptableCard => CardValidToGainFromTrash(acceptableCard, currentPlayer),
                    "Must gain a card costing between 3 and 6",
                    defaultLocation: DeckPlacement.TopOfDeck);
            }
            else
            {
                Card trashedCard = currentPlayer.RequestPlayerTrashCardFromHand(gameState, acceptableCard => CardValidToTrash(acceptableCard), isOptional: false);
                if (trashedCard != null)
                {
                    int maxCost = trashedCard.CurrentCoinCost(currentPlayer) + 3;
                    currentPlayer.RequestPlayerGainCardFromSupply(gameState,
                        acceptableCard => acceptableCard.CurrentCoinCost(currentPlayer) <= maxCost && acceptableCard.potionCost <= trashedCard.potionCost,
                        "gain a card costing up to 3 more than the trashed card");
                }
            }
        }
Example #12
0
 private void DoActionChoice(PlayerState currentPlayer, PlayerActionChoice actionChoice)
 {
     switch (actionChoice)
     {
         case PlayerActionChoice.PlusCard: currentPlayer.DrawOneCardIntoHand(); break;
         case PlayerActionChoice.PlusAction: currentPlayer.AddActions(1); break;
         case PlayerActionChoice.PlusBuy: currentPlayer.AddBuys(1); break;
         case PlayerActionChoice.PlusCoin: currentPlayer.AddCoins(1); break;
         default: throw new Exception("Invalid pawn action choice");
     }
 }
Example #13
0
 private static void ApplyChoice(PlayerActionChoice choice, PlayerState currentPlayer, GameState gameState)
 {
     switch (choice)
     {
         case PlayerActionChoice.PlusCard: currentPlayer.DrawAdditionalCardsIntoHand(2, gameState); break;
         case PlayerActionChoice.PlusAction: currentPlayer.AddActions(2); break;
         case PlayerActionChoice.PlusCoin: currentPlayer.AddCoins(2); break;
         case PlayerActionChoice.GainCard: currentPlayer.GainCardsFromSupply(gameState, Cards.Silver, 4); break;
         default: throw new Exception();
     }
 }