C# Dominion.PlayerState类代码示例

 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);
     }
 }