public override void Trigger(IGame game, IEffectHandle handle) { var defeatedEnemies = new List<IEnemyInPlay>(); foreach (var enemy in game.StagingArea.CardsInStagingArea.OfType<IEnemyInPlay>()) { if (enemy.Damage >= enemy.Card.PrintedHitPoints) { defeatedEnemies.Add(enemy); } } foreach (var player in game.Players) { foreach (var enemy in player.EngagedEnemies) { if (enemy.Damage >= enemy.Card.PrintedHitPoints) { defeatedEnemies.Add(enemy); } } } foreach (var enemy in defeatedEnemies) { var defeatedEffect = new EnemyDefeatedEffect(game, enemy, attackers); var defeatedHandle = defeatedEffect.GetHandle(game); game.AddEffect(defeatedEffect); game.TriggerEffect(defeatedHandle); } handle.Resolve(GetCompletedStatus()); }
private void PlayerDiscardsOneCard(IGame game, IEffectHandle handle, IPlayer player, IPlayerCard card) { if (player.Hand.Cards.Count() == 0) { handle.Cancel(string.Format("{0} does not have any cards in their hand to discard", player.Name)); return; } player.DiscardFromHand(new List<IPlayerCard> { card }); var controller = game.GetController(CardSource.Id); if (controller == null) { handle.Cancel(string.Format("Could not determine the controller of {0}", CardSource.Title)); return; } var willpowerful = controller.CardsInPlay.OfType<IWillpowerfulInPlay>().Where(x => x.Card.Id == source.Id).FirstOrDefault(); if (willpowerful == null) { handle.Cancel(string.Format("'{0}' is no longer in play", CardSource.Title)); return; } game.AddEffect(new WillpowerModifier(game.CurrentPhase.Code, source, willpowerful, TimeScope.Phase, 1)); handle.Resolve(string.Format("{0} discarded a card to give '{0}' +1 Willpower until the end of the phase", player.Name, CardSource.Title)); }
private void TriggerResponse(IGame game, IEffectHandle handle) { var responseHandle = responseEffect.GetHandle(game); game.TriggerEffect(responseHandle); handle.Resolve(string.Format("{0} decided to trigger '{1}'", player.Name, responseEffect)); }
private void HealOneDamageOnCharacter(IGame game, IEffectHandle handle, IPlayer player, ICharacterInPlay glorfindel, ICharacterInPlay character) { glorfindel.Resources -= 1; character.Damage -= 1; handle.Resolve(string.Format("{0} chose to heal 1 damage on '{1}'", player.Name, character.Title)); }
private void HealCreatureInPlay(IGame game, IEffectHandle handle, IPlayer controller, ICharacterInPlay radagast, ICharacterInPlay creature, byte numberOfResources) { radagast.Resources -= numberOfResources; creature.Damage -= numberOfResources; handle.Resolve(string.Format("{0} chose to have '{1}' heal {2} damage from '{3}'", controller.Name, CardSource.Title, numberOfResources, creature.Title)); }
public override void Trigger(IGame game, IEffectHandle handle) { var questPhase = game.CurrentPhase as IQuestPhase; if (questPhase == null || !questPhase.IsCommittedToQuest(CardSource.Id)) { handle.Cancel(string.Format("This ability only applies while '{0}' is committed to the quest", CardSource.Title)); return; } if (game.StagingArea.RevealedEncounterCard == null) { handle.Cancel(string.Format("There is no revealed encounter card for '{0}' to deal damage to", CardSource.Title)); return; } var enemy = game.StagingArea.RevealedEncounterCard as IEnemyInPlay; if (enemy == null) { handle.Cancel(string.Format("The revealed encounter card, '{0}' is not an enemy", game.StagingArea.RevealedEncounterCard.Title)); return; } enemy.Damage += 1; handle.Resolve(string.Format("'{0}' dealt 1 damage to '{1}' as it was revealed from the encounter deck", CardSource.Title, enemy.Title)); }
private void DiscardChosenAttachment(IGame game, IEffectHandle handle, IPlayer player, IAttachableInPlay attachment) { if (attachment.AttachedTo == null) { handle.Cancel(string.Format("Could not discard '{1}', it was not attached to anything", attachment.Title)); return; } attachment.AttachedTo.RemoveAttachment(attachment); if (attachment.Card is IObjectiveCard) { game.StagingArea.EncounterDeck.Discard(new List<IEncounterCard> { attachment.Card as IObjectiveCard }); } else if (attachment.Card is IPlayerCard) { player.Deck.Discard(new List<IPlayerCard> { attachment.Card as IPlayerCard }); } else { handle.Cancel(string.Format("'{0}' could not be discarded because it is not a valid attachment controlled by {1}", attachment.Title, player.Name)); return; } handle.Resolve(string.Format("{0} chose to have '{1}' discarded by the shadow effect of '{2}'", player.Name, attachment.Title, CardSource.Title)); }
public override void Trigger(IGame game, IEffectHandle handle) { var currentStage = game.QuestArea.GetCurrentQuestStage(); if (currentStage == null) { handle.Cancel(GetCancelledString()); return; } var random = new Random(); var number = random.Next(1, 2); if (number == 1) { var dontLeaveThePath = game.QuestArea.QuestDeck.Cards.Where(x => x.Title == "Don't Leave The Path").FirstOrDefault(); if (dontLeaveThePath != null) { currentStage.NextStage = dontLeaveThePath; } } else { var beornsPath = game.QuestArea.QuestDeck.Cards.Where(x => x.Title == "Beorn's Path").FirstOrDefault(); if (beornsPath != null) { currentStage.NextStage = beornsPath; } } handle.Resolve(GetCompletedStatus()); }
public override void Trigger(IGame game, IEffectHandle handle) { if (game.StagingArea.CardsInStagingArea.Any(x => x.Card.Id == cardInPlay.BaseCard.Id)) { game.StagingArea.RemoveFromStagingArea(cardInPlay as IEncounterInPlay); } else if (game.QuestArea.ActiveLocation != null && game.QuestArea.ActiveLocation.Card.Id == cardInPlay.BaseCard.Id) { game.QuestArea.RemoveActiveLocation(); } else { foreach (var player in game.Players) { if (player.CardsInPlay.Any(x => x.BaseCard.Id == cardInPlay.BaseCard.Id)) { player.RemoveCardInPlay(cardInPlay); break; } } } var state = new CardLeavesPlay(game, cardInPlay); foreach (var card in game.GetCardsInPlayWithEffect<ICardInPlay, IAfterCardLeavesPlay>()) { foreach (var effect in card.BaseCard.Text.Effects.OfType<IAfterCardLeavesPlay>()) { effect.AfterCardLeavesPlay(state); } } handle.Resolve(GetCompletedStatus()); }
public override void Trigger(IGame game, IEffectHandle handle) { var topTwo = game.FirstPlayer.Deck.GetFromTop(2); game.FirstPlayer.Hand.AddCards(topTwo); handle.Resolve(GetCompletedStatus()); }
private void PutAllyIntoPlayFromYourHand(IGame game, IEffectHandle handle, IPlayer player, IAllyCard allyCard) { player.Hand.RemoveCards(new List<IPlayerCard> { allyCard }); player.AddCardInPlay(new AllyInPlay(game, allyCard)); game.AddEffect(new AtEndOfPhaseReturnAllyToYourHand(CardSource, allyCard.Id)); handle.Resolve(GetCompletedStatus()); }
private void ResolveSuccessfulQuest(IGame game, IEffectHandle handle, byte difference) { game.QuestArea.AddProgress(difference); var description = GetProgressDescription(difference); var verb = difference > 1 ? "were" : "was"; handle.Resolve(string.Format("Questing was successful: {0} {1} added to the current quest.", description, verb)); }
private void ReduceEachPlayersThreatByTwo(IGame game, IEffectHandle handle) { foreach (var player in game.Players) { player.DecreaseThreat(2); } handle.Resolve("Each players had their threat reduced by 2"); }
private void AttachCaughtInAWebToHero(IGame game, IEffectHandle handle, IPlayer player, IAttachableCard attachable, IHeroInPlay hero) { var attachmentHost = hero as IAttachmentHostInPlay; attachmentHost.AddAttachment(new AttachableInPlay(game, attachable, attachmentHost)); handle.Resolve(string.Format("{0} chose to attach '{1}' to '{2}'", player.Name, CardSource.Title, hero.Title)); }
protected override void ResolveEffect(IGame game, IEffectHandle handle, string paymentText) { var attachedTo = handle.Target as IAttachmentHostInPlay; if (attachedTo == null) throw new InvalidOperationException("target undefined for this attachment"); handle.Resolve(string.Format("{0} chose to pay {1} to attach '{2}' to '{3}'", player.Name, paymentText, attachmentCard.Title, attachedTo.Title)); }
private void PutEncounterCardOnBottomOfDeck(IGame game, IEffectHandle handle, IPlayer player, IExhaustableInPlay denethor, IEncounterCard encounterCard) { denethor.Exhaust(); game.StagingArea.EncounterDeck.RemoveFromDeck(encounterCard); game.StagingArea.EncounterDeck.PutOnBottom(new List<IEncounterCard> { encounterCard }); handle.Resolve(string.Format("{0} chose to put '{1}' on the bottom of the encounter deck", player.Name, encounterCard.Title)); }
protected override void AfterCostPaid(IGame game, IEffectHandle handle, IEnumerable<Tuple<ICharacterInPlay, byte>> charactersAndPayments) { var allyCard = source as IAllyCard; var allyInPlay = new AllyInPlay(game, allyCard); player.AddCardInPlay(allyInPlay); player.Hand.RemoveCards(new List<IPlayerCard> { allyCard }); game.AddEffect(new ReturnToHandAfterSuccessfulQuest(cardSource)); }
private void DrawNewStartingHand(IEffectHandle handle) { var startingHand = Player.Hand.Cards.ToList(); Player.Hand.RemoveCards(startingHand); Player.Deck.ShuffleIn(startingHand); Player.DrawCards(6); handle.Resolve(string.Format("{0} chose to take a mulligan and draw a new starting hand", Player.Name)); }
public override void Trigger(IGame game, IEffectHandle handle) { if (numberOfCards == 0) { handle.Cancel(GetCancelledString()); return; } player.DrawCards(numberOfCards); handle.Resolve(GetCompletedStatus()); }
protected override void AfterCostPaid(IGame game, IEffectHandle handle, IEnumerable<Tuple<ICharacterInPlay, byte>> charactersAndPayments) { var eventEffect = eventCard.Text.Effects.First(); var eventHandle = eventEffect.GetHandle(game); player.Hand.RemoveCards(new List<IPlayerCard> { eventCard }); game.AddEffect(eventEffect); game.TriggerEffect(eventHandle); }
public override void Trigger(IGame game, IEffectHandle handle) { foreach (var player in game.Players) { var eventsToDiscard = player.Hand.Cards.OfType<IEventCard>().ToList(); player.DiscardFromHand(eventsToDiscard); } handle.Resolve(GetCompletedStatus()); }
public override void Trigger(IGame game, IEffectHandle handle) { var enemy = game.GetCardInPlay<IEnemyInPlay>(source.Id); if (enemy == null) { handle.Cancel(GetCancelledString()); return; } enemy.Resources += 1; handle.Resolve(GetCompletedStatus()); }
public override void Trigger(IGame game, IEffectHandle handle) { var enemy = game.GetCardInPlay<IEnemyInPlay>(source.Id); if (enemy == null || enemy.Resources == 0) { handle.Cancel(GetCancelledString()); return; } var bonus = enemy.Resources * 2; game.AddEffect(new AttackModifier(game.CurrentPhase.Code, source, enemy, TimeScope.None, bonus)); handle.Resolve(GetCompletedStatus()); }
public override void Validate(IGame game, IEffectHandle handle) { if (game.StagingArea.EncounterDeck.Size == 0) { handle.Reject(); return; } game.StagingArea.RevealEncounterCard(); handle.Accept(); }
public override void Trigger(IGame game, IEffectHandle handle) { var enemyAttack = game.CurrentPhase.GetEnemyAttacks().Where(x => x.Enemy.Card.Id == source.Id).FirstOrDefault(); if (enemyAttack == null) { handle.Cancel(GetCancelledString()); return; } var bonus = enemyAttack.IsUndefended ? 3 : 1; game.AddEffect(new AttackModifier(game.CurrentPhase.Code, source, enemyAttack.Enemy, TimeScope.None, bonus)); handle.Resolve(GetCompletedStatus()); }
public override void Trigger(IGame game, IEffectHandle handle) { var location = game.StagingArea.CardsInStagingArea.OfType<ILocationInPlay>().Where(x => x.Card.Id == source.Id).FirstOrDefault(); if (location == null) { handle.Cancel(string.Format("Could Not Travel To '{0}'", CardSource.Title)); return; } game.QuestArea.SetActiveLocation(location); handle.Resolve(string.Format("Traveled To '{0}'", CardSource.Title)); }
public override void Trigger(IGame game, IEffectHandle handle) { var playersDrawingCards = game.CurrentPhase.GetPlayersDrawingCards(); if (playersDrawingCards == null) { handle.Cancel(GetCancelledString()); return; } foreach (var playerId in playersDrawingCards.Players) { playersDrawingCards.DisablePlayerCardDraw(playerId); } handle.Resolve(GetCompletedStatus()); }
public override void Trigger(IGame game, IEffectHandle handle) { var chooseEnemy = game.CurrentPhase.GetEnemiesChosenToAttack().Where(x => x.Attackers.Any(y => y.Card.Id == source.Id)).FirstOrDefault(); if (chooseEnemy == null) { handle.Cancel(GetCancelledString()); return; } foreach (var enemy in game.StagingArea.CardsInStagingArea.OfType<IEnemyInPlay>()) { chooseEnemy.AddEnemy(enemy); } handle.Resolve(GetCompletedStatus()); }
public override void Trigger(IGame game, IEffectHandle handle) { var state = new CardEntersPlay(game, cardInPlay); foreach (var inPlay in game.GetCardsInPlayWithEffect<ICardInPlay, IAfterCardEntersPlay>()) { foreach (var effect in inPlay.BaseCard.Text.Effects.OfType<IAfterCardEntersPlay>()) { effect.AfterCardEntersPlay(state); } } handle.Resolve(GetCompletedStatus()); }
public override void Trigger(IGame game, IEffectHandle handle) { foreach (var player in game.Players) { //TODO: Check for IDuringDrawingCards effects here var drawEffect = new DrawingCardsEffect(game, player, 1); var drawHandle = drawEffect.GetHandle(game); game.AddEffect(drawEffect); game.TriggerEffect(drawHandle); } handle.Resolve(GetCompletedStatus()); }
public override void Trigger(IGame game, IEffectHandle handle) { var enemyAttack = game.CurrentPhase.GetEnemyAttacks().Where(x => x.Enemy.Card.Id == source.Id).FirstOrDefault(); if (enemyAttack == null) { handle.Cancel(GetCancelledString()); return; } enemyAttack.Attack += 1; if (enemyAttack.IsUndefended) { enemyAttack.DefendingPlayer.IncreaseThreat(3); } handle.Resolve(GetCompletedStatus()); }
public override void Trigger(IGame game, IEffectHandle handle) { var enemyAttack = game.CurrentPhase.GetEnemyAttacks().Where(x => x.Enemy.Card.Id == source.Id).FirstOrDefault(); if (enemyAttack == null) { handle.Cancel(GetCancelledString()); return; } var damage = enemyAttack.IsUndefended ? (byte)2 : (byte)1; foreach (var damageable in enemyAttack.DefendingPlayer.CardsInPlay.OfType <ICharacterInPlay>()) { damageable.Damage += damage; } handle.Resolve(GetCompletedStatus()); }
public override void Trigger(IGame game, IEffectHandle handle) { var defeatedState = new EnemyDefeated(game, enemy, attackers); foreach (var card in game.GetCardsInPlayWithEffect <ICardInPlay, IBeforeEnemyDefeated>()) { foreach (var effect in card.BaseCard.Text.Effects.OfType <IBeforeEnemyDefeated>()) { effect.BeforeEnemyDefeated(defeatedState); } } foreach (var card in game.GetCardsInPlayWithEffect <ICardInPlay, IDuringEnemyDefeated>()) { foreach (var effect in card.BaseCard.Text.Effects.OfType <IDuringEnemyDefeated>()) { effect.DuringEnemyDefeated(defeatedState); } } if (!defeatedState.IsEnemyDefeated) { handle.Cancel(GetCancelledString()); return; } foreach (var card in game.GetCardsInPlayWithEffect <ICardInPlay, IAfterEnemyDefeated>()) { foreach (var effect in card.BaseCard.Text.Effects.OfType <IAfterEnemyDefeated>()) { effect.AfterEnemyDefeated(defeatedState); } } var leavingPlayEffect = new CardLeavesPlayEffect(game, enemy); game.AddEffect(leavingPlayEffect); var leavingPlayHandle = leavingPlayEffect.GetHandle(game); game.TriggerEffect(leavingPlayHandle); handle.Resolve(GetCompletedStatus()); }
private void PayOneResourceToReadyAragorn(IGame game, IEffectHandle handle, IPlayer controller) { var exhaustable = game.GetCardInPlay <IExhaustableInPlay>(source.Id); if (exhaustable == null) { handle.Cancel(GetCancelledString()); return; } if (!exhaustable.IsExhausted) { handle.Cancel(GetCancelledString()); return; } exhaustable.Ready(); handle.Resolve(string.Format("{0} chose to pay 1 resource from '{0}' to ready him after committing to him to the quest", controller.Name, CardSource.Title)); }
public override void Trigger(IGame game, IEffectHandle handle) { var determineStrength = game.CurrentPhase.GetDetermineAttacks().Where(x => x.Attacker.Card.Id == source.Id).FirstOrDefault(); if (determineStrength == null) { handle.Cancel(GetCancelledString()); return; } var damagable = game.GetCardInPlay <IHeroInPlay>(CardSource.Id); if (damagable == null) { handle.Cancel(GetCancelledString()); return; } determineStrength.Attack += damagable.Damage; handle.Resolve(GetCompletedStatus()); }
private void AddSpiderToTheStagingArea(IGame game, IEffectHandle handle, IEnemyCard spider) { if (game.StagingArea.EncounterDeck.Cards.Any(x => x.Id == spider.Id)) { game.StagingArea.EncounterDeck.RemoveFromDeck(spider); game.StagingArea.AddToStagingArea(spider); handle.Resolve(string.Format("'{0}' added to the staging area from the encounter deck", spider.Title)); return; } else if (game.StagingArea.EncounterDeck.DiscardPile.Any(x => x.Id == spider.Id)) { game.StagingArea.EncounterDeck.RemoveFromDiscardPile(new List <IEncounterCard> { spider }); game.StagingArea.AddToStagingArea(spider); handle.Resolve(string.Format("'{0}' added to the staging area from the encounter discard pile", spider.Title)); } handle.Cancel(string.Format("'{0}' was not added to the staging area because it could not be located", spider.Title)); }
public override void Trigger(IGame game, IEffectHandle handle) { var damageDealt = game.CurrentPhase.GetDamageDealt().Where(x => x.Target.BaseCard.Id == source.Id).FirstOrDefault(); if (damageDealt == null || damageDealt.Damage == 0) { handle.Cancel(GetCancelledString()); return; } var resourceful = game.GetCardInPlay <ICharacterInPlay>(source.Id); if (resourceful == null) { handle.Cancel(GetCancelledString()); return; } resourceful.Resources += damageDealt.Damage; handle.Resolve(GetCompletedStatus()); }
private void ResolveFailedQuest(IGame game, IEffectHandle handle, int difference) { var sb = new StringBuilder("Questing was unsuccessful:\r\n"); foreach (var player in game.Players) { var value = outcome.GetThreatIncrease(player.StateId); if (value > 0) { player.IncreaseThreat(value); sb.AppendFormat("{0} raised their threat by {1}.\r\n", player.Name, value); } else { sb.AppendFormat("{0} did not raise their threat.\r\n", player.Name); } } handle.Resolve(sb.ToString()); }
private void PayResourcesToReadyAttachedCharacter(IGame game, IEffectHandle handle, IPlayer player, ICharacterInPlay character) { var refreshPhase = game.CurrentPhase as IRefreshPhase; if (refreshPhase == null) { throw new InvalidOperationException("This effect can only be triggered during the refresh phase"); } var readyingCard = refreshPhase.GetReadyingCards().Where(x => x.Exhaustable.BaseCard.Id == source.Id).FirstOrDefault(); if (readyingCard == null) { handle.Cancel(string.Format("Could not determine the readying state of '{0}'", character.Title)); return; } character.Resources -= 2; readyingCard.IsReadying = true; handle.Resolve(string.Format("{0} chose to pay 2 resources from {1}'s resource pool to allow them to ready ({2})", player.Name, character.Title, CardSource.Title)); }
public override void Trigger(IGame game, IEffectHandle handle) { IEnemyInPlay enemy = null; foreach (var player in game.Players) { enemy = player.EngagedEnemies.Where(x => x.Card.Id == source.Id).FirstOrDefault(); if (enemy != null) { break; } } if (enemy == null) { handle.Cancel(GetCancelledString()); return; } game.AddEffect(new AttackModifier(game.CurrentPhase.Code, source, enemy, TimeScope.Round, 1)); handle.Resolve(GetCompletedStatus()); }
public void TriggerEffect(IEffectHandle handle) { var effect = handle.Effect; if (!handle.IsAccepted && !handle.IsRejected) { Prepare(handle); } effect.Validate(this, handle); //if (handle.IsAccepted) //{ // controller.PaymentAccepted(effect, handle); //} //if (handle.IsRejected) //{ // controller.PaymentRejected(effect, handle); // return; //} effect.Trigger(this, handle); if (handle.IsResolved) { controller.EffectResolved(effect, handle); } else if (handle.IsCancelled) { controller.EffectCancelled(effect, handle); } if (currentEffects.Contains(effect)) { currentEffects.Remove(effect); } }
private void ExhaustToCancelRevealedTreachery(IGame game, IEffectHandle handle, IExhaustableInPlay exhaustable) { exhaustable.Exhaust(); if (game.StagingArea.RevealedEncounterCard == null) { handle.Cancel(string.Format("There is no revealed encounter card for '{0}' to cancel", CardSource.Title)); return; } if (!(game.StagingArea.RevealedEncounterCard.Card is ITreacheryCard) || !game.StagingArea.RevealedEncounterCard.Card.HasEffect <IWhenRevealedEffect>()) { handle.Cancel(string.Format("The revealed encounter card, '{0}', is not an Treachery with a 'When Revealed' effect for '{1}' to cancel", game.StagingArea.RevealedEncounterCard.Card.Title, CardSource.Title)); return; } var revealedTitle = game.StagingArea.RevealedEncounterCard.Title; game.StagingArea.CancelRevealedCard(this); game.StagingArea.RevealEncounterCard(); handle.Resolve(string.Format("The 'when revealed' effect of '{1}' has been cancelled", CardSource.Title, revealedTitle)); }
public override void Trigger(IGame game, IEffectHandle handle) { foreach (var player in game.Players) { foreach (var exhaustable in player.CardsInPlay.OfType <ICharacterInPlay>().OfType <IExhaustableInPlay>()) { if (!exhaustable.IsExhausted) { continue; } var damageable = exhaustable as ICardInPlay; if (damageable == null) { continue; } damageable.Damage += 1; } } handle.Resolve(GetCompletedStatus()); }
public override void Trigger(IGame game, IEffectHandle handle) { var playersDrawing = game.CurrentPhase.GetPlayersDrawingCards(); if (playersDrawing == null) { handle.Cancel(GetCancelledString()); return; } var firstPlayer = game.Players.Where(x => x.IsFirstPlayer).FirstOrDefault(); if (firstPlayer == null || !playersDrawing.Players.Contains(firstPlayer.StateId)) { handle.Cancel(GetCancelledString()); return; } var numberOfCards = playersDrawing.GetNumberOfCards(firstPlayer.StateId); numberOfCards += 1; playersDrawing.SetNumberOfCards(firstPlayer.StateId, numberOfCards); handle.Resolve(GetCompletedStatus()); }
private void DiscardOneAttachmentFromDefendingCharacter(IGame game, IEffectHandle handle, IPlayer player, IAttachableInPlay attachment) { attachment.AttachedTo.RemoveAttachment(attachment); if (attachment.Card is IObjectiveCard) { game.StagingArea.EncounterDeck.Discard(new List <IEncounterCard> { attachment.Card as IObjectiveCard }); } else if (attachment.Card is IPlayerCard) { player.Deck.Discard(new List <IPlayerCard> { attachment.Card as IPlayerCard }); } else { handle.Cancel(string.Format("Could not discard '{0}' because it was not a valid attachment controlled by {1}", attachment.Title, player.Name)); return; } handle.Resolve(string.Format("{0} chose to have '{1}' discarded", player.Name, attachment.Title)); }
protected override void AfterCostPaid(IGame game, IEffectHandle handle, IEnumerable <Tuple <ICharacterInPlay, byte> > charactersAndPayments) { var attachedTo = handle.Target as IAttachmentHostInPlay; if (attachedTo == null) { throw new InvalidOperationException("target undefined for this attachment"); } player.Hand.RemoveCards(new List <IPlayerCard> { costlyCard }); if (attachmentCard != null) { var attachmentInPlay = new AttachmentInPlay(game, attachmentCard, attachedTo); player.AddCardInPlay(attachmentInPlay); } else if (treasureCard != null) { var treasureInPlay = new TreasureInPlay(game, treasureCard, attachedTo); player.AddCardInPlay(treasureInPlay); } }
protected void UnableToPayCost(IGame game, IEffectHandle handler, IPlayer player) { var title = (costlyCard != null) ? costlyCard.Title : cardEffect.ToString(); handler.Cancel(string.Format("{0} was not able to pay the cost for '{1}'", player.Name, title)); }
protected void CancelPayingCost(IGame game, IEffectHandle handle, IPlayer player) { var title = (costlyCard != null) ? costlyCard.Title : cardEffect.ToString(); handle.Cancel(string.Format("{0} chose not to pay the cost for '{1}'", player.Name, title)); }
protected abstract void AfterCostPaid(IGame game, IEffectHandle handle, IEnumerable <Tuple <ICharacterInPlay, byte> > charactersAndPayments);
private void EffectResolvedCallback(IEffect effect, IEffectHandle handle) { SetCurrentStatus(handle.Status); }
private void EffectCancelledCallback(IEffect effect, IEffectHandle handle) { SetCurrentStatus("Cancelled: " + effect.ToString()); }
private static void PaymentRejectedCallback(IEffect effect, IEffectHandle handle) { WriteLine("The payment for this effect was rejected"); }
private void DiscardAllAttachmentsControlledByDefendingPlayer(IGame game, IEffectHandle handle, IPlayer player) { foreach (var attachable in player.CardsInPlay.OfType <IAttachableInPlay>().Where(x => player.IsTheControllerOf(x) && x.AttachedTo != null)) { attachable.AttachedTo.RemoveAttachment(attachable); if (attachable.Card is IPlayerCard) { player.Deck.Discard(new List <IPlayerCard> { attachable.Card as IPlayerCard }); } else if (attachable.Card is IObjectiveCard) { game.StagingArea.EncounterDeck.Discard(new List <IEncounterCard> { attachable.Card as IObjectiveCard }); } } handle.Resolve(string.Format("All attachments controlled by {0} were discarded", player.Name)); }
private void KeepStartingHand(IEffectHandle handle) { handle.Resolve(string.Format("{0} chose to keep their starting hand", Player.Name)); }
private void PassOnTakingAnAction(IGame game, IEffectHandle handle) { handle.Cancel(string.Format("{0} passed on taking an action", player.Name)); }
private void PutEncounterCardBackOnTopOfDeck(IGame game, IEffectHandle handle, IPlayer player, IExhaustableInPlay denethor, IEncounterCard encounterCard) { denethor.Exhaust(); handle.Resolve(string.Format("{0} chose to put '{1}' back on the top of the encounter deck", player.Name, encounterCard.Title)); }
private void CancelEffect(IGame game, IEffectHandle handle, IPlayer controller) { handle.Cancel(string.Format("{0} chose not to exhaust '{0}' to have a player draw 2 cards", controller.Name, CardSource.Title)); }
private void RemoveCharacterFromQuest(IGame game, IEffectHandle handle, IWillpowerfulInPlay character, IPlayer player, IQuestPhase questPhase) { questPhase.RemoveCharacterFromQuest(character); handle.Resolve(string.Format("{0} chose to remove '{1}' from the quest because of '{2}'", player.Name, character.Title, CardSource.Title)); }
public override void Trigger(IGame game, IEffectHandle handle) { handle.Resolve(GetCompletedStatus()); }
private void ChooseFirstPlayerRandomly(IEffectHandle handle, IPlayer player) { player.IsFirstPlayer = true; handle.Resolve(string.Format("{0} was chosen randomly as the first player", player.Name)); }