private new void DoSpecializedCleanupAtStartOfCleanup(PlayerState currentPlayer, GameState gameState)
 {
     if (currentPlayer.cardsPlayed.HasCard(Cards.Potion))
     {
         currentPlayer.RequestPlayerTopDeckCardFromCleanup(this, gameState);
     }
 }

        public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
        {
            Card revealedCard = currentPlayer.RequestPlayerRevealCardFromHand(acceptableCard => true, gameState);
            PlayerState.AttackAction attackAction = this.DoEmptyAttack;

            if (revealedCard != null && !revealedCard.isShelter)
            {
                int maxReturnCount = Math.Max(currentPlayer.Hand.CountOf(revealedCard), 2);

                int returnCount = currentPlayer.actions.GetCountToReturnToSupply(revealedCard, gameState);
                returnCount = Math.Min(returnCount, maxReturnCount);
                returnCount = Math.Max(returnCount, 0);

                for (int i = 0; i < returnCount; ++i)
                {
                    if (currentPlayer.hand.HasCard(revealedCard))
                    {
                        currentPlayer.ReturnCardFromHandToSupply(revealedCard, gameState);
                    }
                }

                attackAction = delegate(PlayerState currentPlayer2, PlayerState otherPlayer, GameState gameState2)
                {
                    otherPlayer.GainCardFromSupply(gameState, revealedCard);
                };
            }

            currentPlayer.AttackOtherPlayers(gameState, attackAction);
        }

 public void DrewCardIntoHand(PlayerState playerState, Card card)
 {
     for (int i = 0; i < this.gameLogs.Length; ++i)
     {
         this.gameLogs[i].DrewCardIntoHand(playerState, card);
     }
 }

 public void BeginTurn(PlayerState playerState)
 {
     for (int i = 0; i < this.gameLogs.Length; ++i)
     {
         this.gameLogs[i].BeginTurn(playerState);
     }
 }

 public void DiscardedCard(PlayerState playerState, Card card)
 {
     for (int i = 0; i < this.gameLogs.Length; ++i)
     {
         this.gameLogs[i].DiscardedCard(playerState, card);
     }
 }

        public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
        {
            Card revealedCard = currentPlayer.RequestPlayerRevealCardFromHand(acceptableCard => true, gameState);
            if (revealedCard == null)
            {
                return;
            }

            currentPlayer.MoveRevealedCardToHand(revealedCard);

            int maxReturnCount = 1;
            if (currentPlayer.Hand.CountWhere(card => card.Equals(revealedCard)) > 1)
            {
                maxReturnCount++;
            }

            int returnCount = currentPlayer.actions.GetCountToReturnToSupply(revealedCard, gameState);
            returnCount = Math.Min(returnCount, maxReturnCount);
            returnCount = Math.Max(returnCount, 0);

            for (int i = 0; i < returnCount; ++i)
            {
                currentPlayer.ReturnCardFromHandToSupply(revealedCard, gameState);
            }

            foreach (PlayerState otherPlayer in gameState.players.OtherPlayers)
            {
                if (!otherPlayer.IsAffectedByAttacks(gameState))
                {
                    otherPlayer.GainCardFromSupply(gameState, revealedCard);
                }
            }
        }

 public override void PlayerGainedCard(PlayerState playerState, Card card)
 {
     if (this.gainSequenceByPlayer != null)
     {
         List<Card> gainedList = this.gainSequenceByPlayer[playerState.PlayerIndex];
         gainedList.Add(card);
     }
 }

 public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
 {
     currentPlayer.RequestPlayerGainCardFromSupply(
         gameState,
         card => card.CurrentCoinCost(currentPlayer) <= 4 && card.potionCost == 0,
         "Gain a card costing up to 4",
         defaultLocation:DeckPlacement.TopOfDeck);
 }

        public override DeckPlacement DoSpecializedWhenGain(PlayerState currentPlayer, GameState gameState)
        {
            currentPlayer.RequestPlayerGainCardFromSupply(
                gameState,
                card => card.CurrentCoinCost(currentPlayer) < this.CurrentCoinCost(currentPlayer) && card.potionCost == 0,
                "Must gain a card costing less than this");

            return DeckPlacement.Default;
        }

        public void BeginTurn(PlayerState playerState)
        {
            this.textWriter.WriteLine("{0} begins turn", playerState.actions.PlayerName);
            this.textWriter.Write("With hand: ");

            foreach (Card card in playerState.Hand.OrderBy(card => card.name))
            {
                this.textWriter.Write(card.name + ",");
            }
            this.textWriter.WriteLine();
        }

 public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
 {
     if (currentPlayer.RequestPlayerDiscardCardFromHand(gameState, acceptableCard => acceptableCard == Estate.card, isOptional: true))
     {
         currentPlayer.AddCoins(4);
     }
     else
     {
         currentPlayer.GainCardFromSupply(Estate.card, gameState);
     }
 }

 public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
 {
     currentPlayer.RevealCardsFromDeck(5, gameState);
     Card cardType = gameState.players.PlayerLeft.actions.BanCardToDrawnIntoHandFromRevealedCards(gameState);
     if (!currentPlayer.cardsBeingRevealed.HasCard(cardType))
     {
         throw new Exception("Must ban a card currently being revealed");
     }
     currentPlayer.MoveRevealedCardToDiscard(cardType, gameState);
     currentPlayer.MoveAllRevealedCardsToHand();
 }

 public override bool ShouldPlayerDiscardCardFromDeck(GameState gameState, PlayerState player, Card card)
 {
     if (player == gameState.Self)
     {
         return !card.isAction;
     }
     else
     {
         return !playerAction.discardOrder.DoesCardPickerMatch(gameState, card);
     }
 }

        public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
        {
            Card card = currentPlayer.RequestPlayerTrashCardFromHand(gameState, acceptableCard => true, isOptional: false);

            if (card != null)
            {
                int cardsToDraw = card.CurrentCoinCost(currentPlayer) + 2 * card.potionCost;

                currentPlayer.DrawAdditionalCardsIntoHand(cardsToDraw, gameState);
            }
        }

 public override void DoSpecializedAttack(PlayerState currentPlayer, PlayerState otherPlayer, GameState gameState)
 {
     CardPredicate acceptableCard = card => card.isVictory;
     Card cardTopDecked = otherPlayer.RequestPlayerTopDeckCardFromHand(gameState, acceptableCard, isOptional: false);
     if (cardTopDecked == null)
     {
         otherPlayer.RevealHand();
     }
     else
     {
         otherPlayer.RevealCard(cardTopDecked, DeckPlacement.TopOfDeck);
     }
 }

        public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
        {
            currentPlayer.victoryTokenCount += 1;
            Card trashedCard = currentPlayer.RequestPlayerTrashCardFromHand(gameState, acceptableCardsToTrash => true, isOptional: false);
            if (trashedCard != null)
            {
                currentPlayer.victoryTokenCount += trashedCard.CurrentCoinCost(currentPlayer) / 2;
            }

            foreach (PlayerState otherPlayer in gameState.players.OtherPlayers)
            {
                otherPlayer.RequestPlayerTrashCardFromHand(gameState, acceptableCardsToTrash => true, isOptional: true);
            }
        }

        public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
        {
            PlayerActionChoice actionChoice = currentPlayer.RequestPlayerChooseBetween(
                gameState,
                acceptableChoice => acceptableChoice == PlayerActionChoice.GainCard ||
                                    acceptableChoice == PlayerActionChoice.PlusCoin ||
                                    acceptableChoice == PlayerActionChoice.Trash);

            switch (actionChoice)
            {
                case PlayerActionChoice.GainCard: currentPlayer.GainCardFromSupply(Silver.card, gameState); break;
                case PlayerActionChoice.PlusCoin: currentPlayer.AddCoins(1); break;
                case PlayerActionChoice.Trash: currentPlayer.RequestPlayerTrashCardsFromHand(gameState, 1, false); break;
                default: throw new Exception("Invalid case");
            }
        }

        public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
        {
            int countTreasureFound = 0;
            while (countTreasureFound < 2)
            {
                Card card = currentPlayer.DrawAndRevealOneCardFromDeck(gameState);
                if (card == null)
                {
                    break;
                }

                if (card.isTreasure)
                {
                    countTreasureFound += 1;
                    currentPlayer.MoveRevealedCardToHand(card);
                }
            }

            currentPlayer.MoveRevealedCardsToDiscard(gameState);
        }

 public void Write(IndentedTextWriter textWriter, PlayerState[] players)
 {
     foreach (PlayerState player in players)
     {
         textWriter.WriteLine("{0} GainSequence was:", player.actions.PlayerName);
         textWriter.Indent();
         int count = 0;
         foreach (Card card in this.gainSequenceByPlayer[player.PlayerIndex])
         {
             textWriter.Write("{0}, ", card.name);
             if (++count == 5)
             {
                 count = 0;
                 textWriter.WriteLine();
             };
         }
         textWriter.Unindent();
         textWriter.WriteLine();
         textWriter.WriteLine();
     }
 }

            public override Card GetCardFromOtherPlayersHandToDiscard(GameState gameState, PlayerState otherPlayer)
            {
                if (gameState.CurrentContext.CurrentCard != Cards.Pillage)
                    return base.GetCardFromOtherPlayersHandToDiscard(gameState, otherPlayer);

                if (otherPlayer.ExpectedCoinValueAtEndOfTurn >= 5)
                {
                    var returned = otherPlayer.Hand.Where(card => card != Cards.Familiar && card.isTreasure).OrderByDescending(c => c.DefaultCoinCost).FirstOrDefault();
                    if (returned == null)
                        throw new Exception();
                    return returned;
                }
                /*
                Card discard = otherPlayer.Hand.Where(card => card != Cards.Familiar && card.DefaultCoinCost >= 3).OrderByDescending(c => c.DefaultCoinCost).FirstOrDefault();
                if (discard != null)
                    return discard;*/

                if (otherPlayer.Hand.HasCard(Cards.Familiar))
                    return Cards.Familiar;

                return base.GetCardFromOtherPlayersHandToDiscard(gameState, otherPlayer);
            }