internal override void TrashedBy(Player player) { base.TrashedBy(player); // Need to reset any Gain triggers when we're trashed -- we can technically be gained from the Trash ResetTriggers(player._Game); }
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 void AddRange(Player player, IEnumerable<Card> cardCollection, DeckPosition deckPosition) { switch (deckPosition) { case DeckPosition.Top: _Cards.InsertRange(0, cardCollection.Reverse()); break; case DeckPosition.Bottom: _Cards.AddRange(cardCollection); break; } this.Sort(); if (cardCollection.Count() > 0) { if (_AsynchronousChanging) { if (_AsynchronousPileChangedEventArgs == null) _AsynchronousPileChangedEventArgs = new PileChangedEventArgs(player, PileChangedEventArgs.Operation.Added, cardCollection); else _AsynchronousPileChangedEventArgs.AddedCards.AddRange(cardCollection); } else if (PileChanged != null) { lock (PileChanged) { PileChangedEventArgs pcea = new PileChangedEventArgs(player, PileChangedEventArgs.Operation.Added, cardCollection); PileChanged(this, pcea); } } } }
public PlayerModeChangedEventArgs(Player player, PlayerMode oldPlayerMode) { CurrentPlayer = player; OldPlayerMode = oldPlayerMode; if (player != null) NewPlayerMode = player.PlayerMode; }
public PhaseChangedEventArgs(Player player, PhaseEnum oldPhase) { CurrentPlayer = player; OldPhase = oldPhase; if (player != null) NewPhase = player.Phase; }
public PhaseChangingEventArgs(Player player, PhaseEnum newPhase) { CurrentPlayer = player; if (player != null) CurrentPhase = player.Phase; NewPhase = newPhase; }
public override void Play(Player player) { base.Play(player); player.Gain(player._Game.Table.Silver, DeckLocation.Deck, DeckPosition.Top); // Perform attack on every player (including you) IEnumerator<Player> enumerator = player._Game.GetPlayersStartingWithEnumerator(player); enumerator.MoveNext(); while (enumerator.MoveNext()) { Player attackee = enumerator.Current; // Skip if the attack is blocked (Moat, Lighthouse, etc.) if (this.IsAttackBlocked[attackee]) continue; if (attackee.Hand[Category.Victory].Count == 0) { attackee.ReturnHand(attackee.RevealHand()); } else { Choice replaceChoice = new Choice("Choose a card to put back on your deck", this, attackee.Hand[Category.Victory], attackee); ChoiceResult replaceResult = attackee.MakeChoice(replaceChoice); if (replaceResult.Cards.Count > 0) { Card returnCard = attackee.RetrieveCardFrom(DeckLocation.Hand, replaceResult.Cards[0]); attackee.AddCardInto(DeckLocation.Revealed, returnCard); attackee.AddCardToDeck(attackee.RetrieveCardFrom(DeckLocation.Revealed, returnCard), DeckPosition.Top); } } } }
internal Card Retrieve(Player player, Card card) { CardCollection cc = Retrieve(player, c => c == card); if (cc.Count == 0) throw new Exception(String.Format("Cannot find card {0}", card)); return cc[0]; }
public override void Play(Player player) { base.Play(player); CardBenefit benefit = new CardBenefit(); benefit.Currency += new Coin(player.InPlay[Category.Treasure].Count); player.ReceiveBenefit(this, benefit); }
public BenefitsChangedEventArgs(Player player) { this.Player = player; this.Actions = player.Actions; this.Buys = player.Buys; // Make a copy of this so it can't be changed this.Currency = new Currency(player.Currency); }
internal void player_Action(Player player, ref CardsDiscardEventArgs e) { e.Cards.Remove(this.PhysicalCard); Card thisCard = null; if (player.InPlay.Contains(this.PhysicalCard)) thisCard = player.RetrieveCardFrom(DeckLocation.InPlay, this.PhysicalCard); else thisCard = player.RetrieveCardFrom(DeckLocation.SetAside, this.PhysicalCard); player.AddCardToDeck(thisCard, DeckPosition.Top); }
public override void Play(Player player) { base.Play(player); player.BeginDrawing(); while (player.Revealed[Category.Treasure].Count < 2 && player.CanDraw) player.Draw(DeckLocation.Revealed); player.EndDrawing(); player.AddCardsToHand(player.RetrieveCardsFrom(DeckLocation.Revealed, c => (c.Category & Category.Treasure) == Category.Treasure)); player.DiscardRevealed(); }
private Choice(String text, Card cardSource, CardCollection cardTriggers, ChoiceType choiceType, Player playerSource, EventArgs eventArgs, Boolean isOrdered, Boolean isSpecific, int minimum, int maximum) { _Text = text; _CardSource = cardSource; _CardTriggers = cardTriggers; _ChoiceType = choiceType; _PlayerSource = playerSource; _EventArgs = eventArgs; _IsOrdered = isOrdered; _IsSpecific = isSpecific; _Minimum = minimum < 0 ? 0 : minimum; _Maximum = maximum < _Minimum ? _Minimum : maximum; }
public override void Play(Player player) { base.Play(player); Choice choiceCard = new Choice("Reveal a card from your hand to return up to 2 to the Supply.", this, player.Hand, player); ChoiceResult resultCard = player.MakeChoice(choiceCard); if (resultCard.Cards.Count > 0) { Card revealedCard = resultCard.Cards[0]; player.AddCardInto(DeckLocation.Revealed, player.RetrieveCardFrom(DeckLocation.Hand, revealedCard)); player.AddCardInto(DeckLocation.Hand, player.RetrieveCardFrom(DeckLocation.Revealed, revealedCard)); Supply supply = player._Game.Table.FindSupplyPileByCard(revealedCard); if (supply != null) { List<String> options = new List<string>() { "0", "1" }; if (player.Hand[revealedCard.CardType].Count > 1) options.Add("2"); Choice choice = new Choice("How many would you like to return to the Supply?", this, new CardCollection() { revealedCard }, options, player); ChoiceResult result = player.MakeChoice(choice); int numberToReturn = int.Parse(result.Options[0]); if (numberToReturn > 0) { CardCollection cardsToReturn = player.RetrieveCardsFrom(DeckLocation.Hand, revealedCard.CardType, numberToReturn); player.Lose(cardsToReturn); supply.AddTo(cardsToReturn); } player._Game.SendMessage(player, this, supply, numberToReturn); } IEnumerator<Player> enumerator = player._Game.GetPlayersStartingWithEnumerator(player); enumerator.MoveNext(); while (enumerator.MoveNext()) { Player attackee = enumerator.Current; // Skip if the attack is blocked (Moat, Lighthouse, etc.) if (this.IsAttackBlocked[attackee]) continue; if (supply != null && supply.CanGain() && supply.TopCard.Name == revealedCard.Name) attackee.Gain(supply); } } }
public override void Play(Player player) { base.Play(player); player.Draw(3, DeckLocation.Revealed); IEnumerator<Player> enumerator = player._Game.GetPlayersStartingWithEnumerator(player); enumerator.MoveNext(); // Gets us... which we don't care about here. enumerator.MoveNext(); // Get the player to our left Player leftPlayer = enumerator.Current; Choice choice = new Choice(String.Format("Choose a card of {0}'s to discard", player), this, player.Revealed, player); ChoiceResult result = leftPlayer.MakeChoice(choice); // Discard the chosen card if (result.Cards.Count > 0) player.Discard(DeckLocation.Revealed, result.Cards[0]); player.AddCardsToHand(DeckLocation.Revealed); }
public override void Play(Player player) { base.Play(player); if (player.Hand[Cards.Universal.TypeClass.Estate].Count > 0) { Choice choice = Choice.CreateYesNoChoice("You may discard an Estate card for +<coin>4</coin>. Do you want to discard?", this, player); ChoiceResult result = player.MakeChoice(choice); if (result.Options.Contains("Yes")) { player.Discard(DeckLocation.Hand, Cards.Universal.TypeClass.Estate, 1); CardBenefit benefit = new CardBenefit(); benefit.Currency.Coin += 4; player.ReceiveBenefit(this, benefit); return; } } player.Gain(player._Game.Table.Estate); }
public PlayerChoiceMessage(Player player, ChoiceResult choiceResult) : this(null, player, choiceResult) { }
/// <summary> /// Fires off the Attack event, so any listeners can pick it up. /// </summary> /// <param name="player">The attacking player</param> /// <param name="attackingCard">The card that triggered the Attack event</param> /// <returns>"true" if the Attack can proceed (wasn't blocked). "false" if the Attack was blocked.</returns> /// <summary> public Boolean AttackedBy(Player attacker, Card attackingCard) { if (Attacked != null) { AttackedEventArgs aea = null; Boolean cancelled = false; do { aea = new AttackedEventArgs(attacker, attackingCard); aea.Cancelled |= cancelled; Attacked(this, aea); CardCollection cards = new CardCollection(aea.Revealable.Values.Select(s => s.Card)); if (cards.Count > 0) { cards.Sort(); Choice choice = new Choice("Reveal a card?", null, attackingCard, cards, this, true, aea); ChoiceResult result = this.MakeChoice(choice); if (result.Cards.Count > 0) aea.Revealable[result.Cards[0].CardType].Method(this, ref aea); else break; } cancelled |= aea.Cancelled; } while (Attacked != null && aea.HandledBy.Count > 0); if (aea != null) cancelled |= aea.Cancelled; return !cancelled; } return true; }
internal void SetupDeckAs(Player player) { CardCollection cards = new CardCollection(this.RetrieveCardsFrom(DeckLocation.Hand).Union(this.RetrieveCardsFrom(DeckLocation.Deck))); foreach (Card sourceCard in player.Hand) { Card myFoundCard = cards.First(c => c.CardType == sourceCard.CardType); cards.Remove(myFoundCard); this.AddCardInto(DeckLocation.Hand, myFoundCard); } this.AddCardsInto(DeckLocation.Deck, cards); }
internal double SumAll(Player fromPlayer, Predicate<Card> filterPredicate, Func<Card, double> sumSelector, Boolean onlyObtainable, Boolean onlyCurrentlyDrawable) { double sum = 0; sum += this.DiscardPile.LookThrough(filterPredicate).Sum(sumSelector); sum += this.DrawPile.LookThrough(filterPredicate).Sum(sumSelector); if (!onlyCurrentlyDrawable) { sum += this.Hand[filterPredicate].Sum(sumSelector); sum += this.Private[filterPredicate].Sum(sumSelector); sum += this.Revealed[filterPredicate].Sum(sumSelector); sum += this.InPlay[filterPredicate].Sum(sumSelector); sum += this.SetAside[filterPredicate].Sum(sumSelector); foreach (Type deckType in this.PlayerMats.Keys) { // Don't count cards on mats that you can't obtain cards from if (onlyObtainable && !this.PlayerMats[deckType].IsObtainable) continue; sum += this.PlayerMats[deckType].LookThrough(filterPredicate).Sum(sumSelector); } } return sum; }
internal double SumAll(Player fromPlayer, Predicate<Card> filterPredicate, Func<Card, double> sumSelector) { return SumAll(fromPlayer, filterPredicate, sumSelector, true, false); }
internal int CountAll(Player fromPlayer, Predicate<Card> predicate, Boolean onlyObtainable, Boolean onlyCurrentlyDrawable) { int count = 0; count += this.DiscardPile.LookThrough(predicate).Count; count += this.DrawPile.LookThrough(predicate).Count; if (!onlyCurrentlyDrawable) { count += this.Hand[predicate].Count; count += this.Private[predicate].Count; count += this.Revealed[predicate].Count; count += this.InPlay[predicate].Count; count += this.SetAside[predicate].Count; foreach (Type deckType in this.PlayerMats.Keys) { // Don't count cards on mats that you can't obtain cards from if (onlyObtainable && !this.PlayerMats[deckType].IsObtainable) continue; count += this.PlayerMats[deckType].LookThrough(predicate).Count; } } return count; }
internal int CountAll(Player fromPlayer, Predicate<Card> predicate) { return CountAll(fromPlayer, predicate, true, false); }
internal void player_DiscardHand(Player player, ref CardsDiscardEventArgs e) { CardMovementCollection cardsToMove = (CardMovementCollection)e.Data; // Discard Hand this.AddCardsInto(DeckLocation.Discard, this.RetrieveCardsFrom(DeckLocation.Hand, c => cardsToMove[c].CurrentLocation == DeckLocation.Hand && cardsToMove[c].Destination == DeckLocation.Discard)); e.HandledBy.Add(this); }
public void Receive(Player fromPlayer, Card card, DeckLocation location, DeckPosition position) { if (CurrentTurn != null) CurrentTurn.Received(card); this.AddCardInto(location, card, position); card.ReceivedBy(this); if (CardReceived != null) { CardReceivedEventArgs crea = new CardReceivedEventArgs(fromPlayer, card, location, position); CardReceived(this, crea); } }
public void TearDown() { this.IsActive = false; this.Player = null; }
public override void Play(Player player) { base.Play(player); CardCollection newCards = player.Draw(4, DeckLocation.Revealed); player.AddCardsToHand(player.RetrieveCardsFrom(DeckLocation.Revealed, c => c.CardType == Universal.TypeClass.Copper || c.CardType == Alchemy.TypeClass.Potion)); Choice replaceChoice = new Choice("Choose order of cards to put back on your deck", this, player.Revealed, player, true, player.Revealed.Count, player.Revealed.Count); ChoiceResult replaceResult = player.MakeChoice(replaceChoice); player.RetrieveCardsFrom(DeckLocation.Revealed, replaceResult.Cards); player.AddCardsToDeck(replaceResult.Cards, DeckPosition.Top); }
/// <summary> /// Fires off the TokenAction event, so any listeners can pick it up. /// </summary> /// <param name="actor">The acting player (the one playing the card)</param> /// <param name="actingCard">The card that triggered the TokenAction event</param> /// <returns>"true" if the TokenAction can proceed (wasn't blocked). "false" if the TokenAction was blocked.</returns> public Boolean TokenActOn(Player actor, Card actingCard) { if (TokenActedOn != null) { TokenActionEventArgs taea = new TokenActionEventArgs(actor, this, actingCard); TokenActedOn(this, taea); return !taea.Cancelled; } return true; }
public PlayerChoiceMessage(AutoResetEvent returnEvent, Player player, ChoiceResult choiceResult) : base(returnEvent) { Player = player; ChoiceResult = choiceResult; }
public override void Play(Player player) { base.Play(player); SupplyCollection gainableSupplies = player._Game.Table.Supplies.FindAll( supply => supply.CanGain() && ((supply.Category & Cards.Category.Action) == Cards.Category.Action) && supply.CurrentCost <= new Coin(5)); Choice choice = new Choice("You may gain an Action card costing up to <coin>5</coin>", this, gainableSupplies, player, true); ChoiceResult result = player.MakeChoice(choice); if (result.Supply != null) player.Gain(result.Supply); }