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