C# Player.Trash方法代码示例

		public override void Play(Player player)
		{
			base.Play(player);

			Choice choice = new Choice("Trash a card. +<vp/> equal to half its cost in coins, rounded down.", this, player.Hand, player);
			ChoiceResult result = player.MakeChoice(choice);
			if (result.Cards.Count > 0)
			{
				Card trash = player.RetrieveCardFrom(DeckLocation.Hand, result.Cards[0]);
				Cost trashedCardCost = player._Game.ComputeCost(trash);
				player.Trash(trash);

				player.ReceiveBenefit(this, new CardBenefit() { VictoryPoints = trashedCardCost.Coin.Value / 2 });
			}

			IEnumerator<Player> enumerator = player._Game.GetPlayersStartingWithEnumerator(player);
			enumerator.MoveNext(); // skip active player
			while (enumerator.MoveNext())
			{
				Player otherPlayer = enumerator.Current;
				Choice choicePlayer = new Choice("Trash a card if you wish", this, otherPlayer.Hand, otherPlayer, false, 0, 1);
				ChoiceResult resultPlayer = otherPlayer.MakeChoice(choicePlayer);
				if (resultPlayer.Cards.Count > 0)
				{
					otherPlayer.Trash(otherPlayer.RetrieveCardFrom(DeckLocation.Hand, resultPlayer.Cards[0]));
				}
			}
		}

		public override void Play(Player player)
		{
			base.Play(player);
			CardCollection singleCopper = player.RetrieveCardsFrom(DeckLocation.Hand, Cards.Universal.TypeClass.Copper, 1);
			if (singleCopper.Count > 0)
			{
				player.Trash(singleCopper[0]);
				CardBenefit benefit = new CardBenefit();
				benefit.Currency += new Coin(3);
				player.ReceiveBenefit(this, benefit);
			}
		}

		public override void Play(Player player)
		{
			base.Play(player);
			Choice choice = new Choice("Choose a card to trash", this, player.Hand, player, false, 1, 1);
			ChoiceResult result = player.MakeChoice(choice);
			if (result.Cards.Count > 0)
			{
				player.Trash(player.RetrieveCardFrom(DeckLocation.Hand, result.Cards[0]));

				Cost cardCost = player._Game.ComputeCost(result.Cards[0]);
				int toDraw = cardCost.Coin.Value;
				if (cardCost.Potion.Value > 0)
					toDraw += 2;
				player.ReceiveBenefit(this, new CardBenefit() { Cards = toDraw });
			}
		}

		public override void Play(Player player)
		{
			base.Play(player);

			Choice choiceTrash = new Choice("Choose a card to trash", this, player.Hand, player);
			ChoiceResult resultTrash = player.MakeChoice(choiceTrash);
			player.Trash(player.RetrieveCardsFrom(DeckLocation.Hand, resultTrash.Cards));

			SupplyCollection gainableSupplies = player._Game.Table.Supplies.FindAll(supply => supply.CanGain() && supply.CurrentCost <= new Coin(5));
			Choice choice = new Choice("Gain a card costing up to <coin>5</coin>", this, gainableSupplies, player, false);
			ChoiceResult result = player.MakeChoice(choice);
			if (result.Supply != null)
				player.Gain(result.Supply);
		}

		internal void player_FoolsGold(Player player, ref Players.CardGainEventArgs e)
		{
			if (player.Hand.Contains(this.PhysicalCard))
			{
				player.AddCardInto(DeckLocation.Revealed, player.RetrieveCardFrom(DeckLocation.Hand, this.PhysicalCard));
				player.Trash(player.RetrieveCardFrom(DeckLocation.Revealed, this.PhysicalCard));
				player.Gain(player._Game.Table.Gold, DeckLocation.Deck, DeckPosition.Top);
				e.HandledBy.Add(TypeClass.FoolsGold);
			}
		}

		public override void Play(Player player)
		{
			base.Play(player);

			// Step 1
			player.Gain(player._Game.Table.Silver);

			// Step 2
			if (player.CanDraw)
			{
				Card card = player.Draw(DeckLocation.Private);
				Choice choice = new Choice(String.Format("Do you want to discard {0} or put it back on top?", card.Name), this, new CardCollection() { card }, new List<string>() { "Discard", "Put it back" }, player);
				ChoiceResult result = player.MakeChoice(choice);
				if (result.Options[0] == "Discard")
					player.Discard(DeckLocation.Private);
				else
					player.AddCardsToDeck(player.RetrieveCardsFrom(DeckLocation.Private), DeckPosition.Top);
			}

			// Step 3
			player.Draw(5 - player.Hand.Count, DeckLocation.Hand);

			// Step 4
			Choice choiceTrash = new Choice("You may trash a card", this, player.Hand[c => (c.Category & Category.Treasure) != Category.Treasure], player, false, 0, 1);
			ChoiceResult resultTrash = player.MakeChoice(choiceTrash);
			player.Trash(player.RetrieveCardsFrom(DeckLocation.Hand, resultTrash.Cards));

		}

		internal void player_BuyFarmland(Player player, ref Players.CardBuyEventArgs e)
		{
			Choice choiceTrash = new Choice("Choose a card to trash", this, player.Hand, player);
			ChoiceResult resultTrash = player.MakeChoice(choiceTrash);
			player.Trash(player.RetrieveCardsFrom(DeckLocation.Hand, resultTrash.Cards));

			if (resultTrash.Cards.Count > 0)
			{
				Cost trashedCardCost = player._Game.ComputeCost(resultTrash.Cards[0]);
				SupplyCollection gainableSupplies = player._Game.Table.Supplies.FindAll(supply => supply.CanGain() && supply.CurrentCost == (trashedCardCost + new Coin(2)));
				Choice choice = new Choice("Gain a card", this, gainableSupplies, player, false);
				ChoiceResult result = player.MakeChoice(choice);
				if (result.Supply != null)
					player.Gain(result.Supply);
			}

			e.HandledBy.Add(TypeClass.Farmland);

			// Clear out the Event Triggers -- this only happens when its Gained, so we don't care any more
			foreach (Player playerLoop in _CardBoughtHandlers.Keys)
				playerLoop.CardBought -= _CardBoughtHandlers[playerLoop];
			_CardBoughtHandlers.Clear();
		}

		public override void Play(Player player)
		{
			base.Play(player);

			List<Type> cardTypes = new List<Type>();
			foreach (Card card in player.InPlay)
			{
				Type t = card.CardType;
				if (!cardTypes.Contains(t))
					cardTypes.Add(t);
			}
			foreach (Card card in player.SetAside)
			{
				Type t = card.CardType;
				if (!cardTypes.Contains(t))
					cardTypes.Add(t);
			}

			Currencies.Coin uniqueCardsInPlay = new Currencies.Coin(cardTypes.Count);
			SupplyCollection gainableSupplies = player._Game.Table.Supplies.FindAll(supply => supply.CanGain() && supply.CurrentCost <= uniqueCardsInPlay);
			Choice choice = new Choice("Gain a card.", this, gainableSupplies, player, false);
			ChoiceResult result = player.MakeChoice(choice);
			if (result.Supply != null)
			{
				player.Gain(result.Supply);
				if ((result.Supply.Category & Cards.Category.Victory) == Cards.Category.Victory)
				{
					player.RetrieveCardFrom(DeckLocation.InPlay, this);
					player.Trash(this);
				}
			}
		}

		internal void player_Action(Player player, ref CardsDiscardEventArgs e)
		{
			e.Cards.Remove(this.PhysicalCard);
			if (player.InPlay.Contains(this.PhysicalCard))
				player.Trash(player.RetrieveCardFrom(DeckLocation.InPlay, this.PhysicalCard));
			else if (player.SetAside.Contains(this.PhysicalCard))
				player.Trash(player.RetrieveCardFrom(DeckLocation.SetAside, this.PhysicalCard));

			player.Gain(player._Game.Table.SpecialPiles[TypeClass.Madman]);

			e.HandledBy.Add(this);
			_ShouldBeTrashed = false;
		}

		internal void player_TrashHovel(Player player, ref Players.CardBuyEventArgs e)
		{
			player.Trash(player.RetrieveCardFrom(DeckLocation.Hand, this.PhysicalCard));

			e.HandledBy.Add(this);
		}

		public void KnightAttack(Player player)
		{
			List<Cost> availableCosts = new List<Cost>() { new Cost(3), new Cost(4), new Cost(5), new Cost(6) };

			Boolean anyKnightsTrashed = false;
			IEnumerator<Player> enumerator = player._Game.GetPlayersStartingWithEnumerator(player);
			enumerator.MoveNext();
			while (enumerator.MoveNext())
			{
				Player attackee = enumerator.Current;
				if (this.IsAttackBlocked[attackee])
					continue;

				CardCollection attackeeCards = attackee.Draw(2, DeckLocation.Revealed);
				Choice choiceTrash = new Choice("Choose a card to trash", this, attackee.Revealed[c => availableCosts.Any(cost => player._Game.ComputeCost(c) == cost)], player);
				ChoiceResult resultTrash = attackee.MakeChoice(choiceTrash);
				if (resultTrash.Cards.Count > 0)
				{
					Card cardToTrash = attackee.RetrieveCardFrom(DeckLocation.Revealed, resultTrash.Cards[0]);
					if ((cardToTrash.Category & Cards.Category.Knight) == Cards.Category.Knight)
						anyKnightsTrashed = true;
					attackee.Trash(cardToTrash);
				}
				attackee.DiscardRevealed();
			}

			if (anyKnightsTrashed && player.InPlay.Contains(this.PhysicalCard))
				player.Trash(player.RetrieveCardFrom(DeckLocation.InPlay, this.PhysicalCard));
		}

		internal void player_BuyMint(Player player, ref Players.CardBuyEventArgs e)
		{
			player.Trash(player.RetrieveCardsFrom(DeckLocation.InPlay, Category.Treasure));
			player.Trash(player.RetrieveCardsFrom(DeckLocation.SetAside, Category.Treasure));

			e.HandledBy.Add(TypeClass.Mint);

			// Clear out the Event Triggers -- this only happens when its Gained, so we don't care any more
			foreach (Player playerLoop in _CardBoughtHandlers.Keys)
				playerLoop.CardBought -= _CardBoughtHandlers[playerLoop];
			_CardBoughtHandlers.Clear();
		}