private IEnumerator MoveCardResponse(DestroyCardAction destroyCard)
{
//Move card from under this card into the hand
IEnumerator coroutine = base.GameController.SelectAndMoveCard(base.HeroTurnTakerController, (Card c) => base.Card.UnderLocation.HasCard(c), base.HeroTurnTaker.Hand, false, false, false, false, null, null);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
//When there are no cards beneath this one, destroy this card."
if (base.Card.UnderLocation.Cards.Count <Card>() == 0)
{
IEnumerator coroutine2 = base.GameController.DestroyCard(this.DecisionMaker, base.Card, false, null, null, null, null, null, null, null, null, base.GetCardSource(null));
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine2));
}
else
{
base.GameController.ExhaustCoroutine(coroutine2);
}
yield break;
}
yield break;
}
public IEnumerator MoveItToTheBottomOfItsDeckResponse(DestroyCardAction d, HeroTurnTaker hero, StatusEffect effect, int[] powerNumerals = null)
{
//...you may move it to the bottom of its deck.
if (d.PostDestroyDestinationCanBeChanged)
{
var storedResults = new List <YesNoCardDecision>();
HeroTurnTakerController httc = null;
if (hero != null)
{
httc = FindHeroTurnTakerController(hero);
}
var e = this.GameController.MakeYesNoCardDecision(httc, SelectionType.MoveCardToHand, d.CardToDestroy.Card, storedResults: storedResults, cardSource: GetCardSource());
if (UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(e));
}
else
{
this.GameController.ExhaustCoroutine(e);
}
if (DidPlayerAnswerYes(storedResults))
{
var nativeDeck = d.CardToDestroy.Card.NativeDeck;
var hand = nativeDeck.OwnerTurnTaker.ToHero().Hand;
d.SetPostDestroyDestination(hand, false, storedResults.CastEnumerable <YesNoCardDecision, IDecision>(), cardSource: GetCardSource());
}
}
}
public IEnumerator CrashResponse(DestroyCardAction dca)
{
// "When this card is destroyed, it deals each other target in this play area 2 irreducible fire damage."
IEnumerator damageCoroutine = base.DealDamage(base.Card, (Card c) => c != base.Card && c.Location.HighestRecursiveLocation == base.Card.Location.HighestRecursiveLocation, 2, DamageType.Fire, isIrreducible: true, optional: false);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(damageCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(damageCoroutine);
}
// "Then, discard cards from the top of the environment deck until a Storage card is discarded. Put it into play."
IEnumerator digCoroutine = base.DigForStorage();
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(digCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(digCoroutine);
}
yield break;
}
private IEnumerator DestroyEnvironmentResponse(DestroyCardAction dca)
{
List <Card> highestHpTarget = new List <Card>();
var damageInfo = new DealDamageAction(GetCardSource(), new DamageSource(GameController, Card), null, PsychicDamageToDeal, DamageType.Psychic);
var coroutine = GameController.FindTargetWithHighestHitPoints(1, card => card.IsTarget, highestHpTarget,
dealDamageInfo: new[] { damageInfo },
evenIfCannotDealDamage: true,
cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
if (highestHpTarget.Any())
{
var target = highestHpTarget.First();
// Deal 5 psychic damage
coroutine = this.DealDamage(this.Card, target, PsychicDamageToDeal, DamageType.Psychic, cardSource: this.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
}
public IEnumerator OnDestroyResponse(DestroyCardAction dca)
{
// "When this card is destroyed, you may draw a card or use a power."
List <Function> options = new List <Function>();
Function drawOption = new Function(base.DecisionMaker, "Draw a card", SelectionType.DrawCard, () => base.GameController.DrawCard(base.HeroTurnTaker, cardSource: GetCardSource()), null, null, "Draw a card");
options.Add(drawOption);
Function powerOption = new Function(base.DecisionMaker, "Use a power", SelectionType.UsePower, () => base.GameController.SelectAndUsePower(base.HeroTurnTakerController, optional: true, null, 1, cardSource: GetCardSource()), null, null, "Use a power");
options.Add(powerOption);
if (options.Count > 0)
{
SelectFunctionDecision choice = new SelectFunctionDecision(base.GameController, base.HeroTurnTakerController, options, true, cardSource: GetCardSource());
IEnumerator chooseCoroutine = base.GameController.SelectAndPerformFunction(choice);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(chooseCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(chooseCoroutine);
}
}
yield break;
}
public IEnumerator CardDestroyedResponse(DestroyCardAction dca)
{
// "When a card is destroyed, you may reveal the top card of its deck, then replace it."
Card destroyed = dca.CardToDestroy.Card;
Location toCheck = destroyed.NativeDeck;
Card toReveal = toCheck.TopCard;
List <YesNoCardDecision> results = new List <YesNoCardDecision>();
IEnumerator chooseCoroutine = base.GameController.MakeYesNoCardDecision(base.HeroTurnTakerController, SelectionType.RevealTopCardOfDeck, base.Card, action: dca, storedResults: results, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(chooseCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(chooseCoroutine);
}
if (base.DidPlayerAnswerYes(results))
{
IEnumerator revealCoroutine = base.GameController.SendMessageAction(base.Card.Title + " revealed " + toReveal.Title + " on top of " + toCheck.GetFriendlyName() + "!", Priority.High, cardSource: GetCardSource(), associatedCards: toReveal.ToEnumerable(), showCardSource: true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(revealCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(revealCoroutine);
}
}
yield break;
}
private IEnumerator DoFrenzy(DestroyCardAction arg)
{
arg.SetPostDestroyDestination(Frenzy.UnderLocation);
return(DoNothing());
//var consume = this.GameController.Change(TurnTakerController, arg.CardToDestroy.Card, Card.UnderLocation, cardSource: GetCardSource());
//if(UseUnityCoroutines) { yield return this.GameController.StartCoroutine(consume); } else { this.GameController.ExhaustCoroutine(consume); }
}
public override IEnumerator DestroyAttempted(DestroyCardAction destroyCard)
{
if (base.Card.IsFlipped)
{
yield break;
}
}
private IEnumerator DestroyRadiationFrontResponse(DestroyCardAction action)
{
IEnumerator coroutine;
//...destroy 1 hero ongoing or equipment card and {Gray} deals each non-villain target {H - 1} energy damage
if (FindNumberOfHeroOngoingAndEquipmentInPlay() > 0)
{
int?numberOfCards = new int?(1);
if (Game.IsAdvanced)
{
//Advanced - Whenever a radiation card is destroyed, destroy a second hero ongoing or equipment card.
numberOfCards = new int?(2);
}
coroutine = base.GameController.SelectAndDestroyCards(this.DecisionMaker, new LinqCardCriteria((Card c) => c.IsHero && (c.IsOngoing || base.IsEquipment(c))), numberOfCards, cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
coroutine = base.DealDamage(base.Card, (Card c) => c.IsNonVillainTarget, Game.H - 1, DamageType.Energy);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
private IEnumerator MayReturnDestroyedResponse(DestroyCardAction dc)
{
Card toReturn = dc.CardToDestroy.Card;
var decisionResult = new List <YesNoCardDecision> {
};
IEnumerator coroutine = GameController.MakeYesNoCardDecision(DecisionMaker, SelectionType.MoveCardToHand, toReturn, storedResults: decisionResult, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
if (DidPlayerAnswerYes(decisionResult))
{
dc.SetPostDestroyDestination(dc.CardToDestroy.Card.Owner.ToHero().Hand);
dc.AddAfterDestroyedAction(() => DestroyThisCardIfMovedResponse(dc), this);
}
yield break;
}
private IEnumerator WhenDestroyedResponse(DestroyCardAction dca)
{
//Place the top card of the villain deck beneath him.
List <SelectLocationDecision> storedResults = new List <SelectLocationDecision>();
IEnumerator coroutine = base.FindVillainDeck(base.DecisionMaker, SelectionType.MoveCardToUnderCard, storedResults, (Location l) => l.HasCards);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
if (base.DidSelectLocation(storedResults))
{
Location villainDeck = storedResults.First().SelectedLocation.Location;
Card takAhab = base.FindTakAhabInPlay();
coroutine = base.GameController.MoveCard(base.DecisionMaker, villainDeck.TopCard, takAhab.UnderLocation, showMessage: true, cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
yield break;
}
private IEnumerator DealDamageResponse(DestroyCardAction destroyCard)
{
List <SelectCardDecision> selectCardResults = new List <SelectCardDecision>();
IEnumerator selectOwnCharacterRoutine = base.SelectOwnCharacterCard(selectCardResults, SelectionType.HeroToDealDamage);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(selectOwnCharacterRoutine));
}
else
{
base.GameController.ExhaustCoroutine(selectOwnCharacterRoutine);
}
// You may deal 1 target 1 projectile damage
Card characterCard = GetSelectedCard(selectCardResults);
IEnumerator dealDamageRoutine = base.GameController.SelectTargetsAndDealDamage(this.DecisionMaker,
new DamageSource(base.GameController, characterCard), DamageAmount,
DamageType.Projectile, 1, false, 0,
additionalCriteria: c => c.IsTarget && c.IsInPlayAndHasGameText && !c.IsBeingDestroyed,
cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(dealDamageRoutine));
}
else
{
base.GameController.ExhaustCoroutine(dealDamageRoutine);
}
}
private IEnumerator DealDamageResponse(DestroyCardAction action)
{
List <SelectCardDecision> targetDecision = new List <SelectCardDecision>();
//{Titan} deals 1 villain target 5 infernal damage.
IEnumerator coroutine = base.GameController.SelectTargetsAndDealDamage(base.HeroTurnTakerController, new DamageSource(base.GameController, base.CharacterCard), 5, DamageType.Infernal, 1, false, 1, storedResultsDecisions: targetDecision, cardSource: base.GetCardSource());
if (UseUnityCoroutines)
{
yield return(GameController.StartCoroutine(coroutine));
}
else
{
GameController.ExhaustCoroutine(coroutine);
}
// If Titanform is in play...
if (base.GetTitanform().Location.IsInPlayAndNotUnderCard)
{
//...{Titan} also deals that target 2 fire damage.
coroutine = base.DealDamage(base.CharacterCard, targetDecision.FirstOrDefault().SelectedCard, 2, DamageType.Fire, cardSource: base.GetCardSource());
if (UseUnityCoroutines)
{
yield return(GameController.StartCoroutine(coroutine));
}
else
{
GameController.ExhaustCoroutine(coroutine);
}
}
yield break;
}
private IEnumerator DealDamageResponse(DestroyCardAction d)
{
var microstormIdentifier = d.CardToDestroy.Card.Identifier;
var damageType = new DamageType();
if (microstormIdentifier == HailFlurryIdentifier)
{
damageType = DamageType.Cold;
}
else if (microstormIdentifier == FlaringBlazeIdentifier)
{
damageType = DamageType.Fire;
}
else if (microstormIdentifier == ScathingSandstormIdentifier)
{
damageType = DamageType.Projectile;
}
else if (microstormIdentifier == BladedGaleIdentifier)
{
damageType = DamageType.Sonic;
}
else if (microstormIdentifier == VigilanteJusticeIdentifier)
{
damageType = DamageType.Radiant;
}
else if (microstormIdentifier == ViciousRetributionIdentifier)
{
damageType = DamageType.Infernal;
}
else if (microstormIdentifier == ThunderStormIdentifier)
{
damageType = DamageType.Lightning;
}
else if (microstormIdentifier == ToxicCloudIdentifier)
{
damageType = DamageType.Toxic;
}
else if (microstormIdentifier == PsionicTorrentIdentifier)
{
damageType = DamageType.Psychic;
}
else if (microstormIdentifier == OverloadPulseIdentifier)
{
damageType = DamageType.Energy;
}
IEnumerator coroutine = base.GameController.SelectTargetsAndDealDamage(this.DecisionMaker, new DamageSource(base.GameController, base.CharacterCard), 1, damageType, 1, false, 0, false, false, false, null, null, null, null, null, false, null, null, false, null, GetCardSource(null));
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
private bool SelfDestructionCriteria(DestroyCardAction action)
{
//Destroy this card when {H} hero cards are destroyed this way in one round.
//prefilter to events that destroyed a hero ongoing before hitting the Journal
var destroyedCard = action.CardToDestroy?.Card;
return(destroyedCard != null && destroyedCard.IsHero && (destroyedCard.IsOngoing || IsEquipment(destroyedCard)) &&
this.GetHeroCardsDestroyedThisRound().Where(e => (e.Card.IsOngoing || IsEquipment(e.Card)) && e.CardSource == this.Card).Count() >= Game.H);
}
private bool LineEmUpTriggerCondition(DestroyCardAction destroyCard)
{
return(destroyCard.WasCardDestroyed &&
base.GameController.IsCardVisibleToCardSource(destroyCard.CardToDestroy.Card, base.GetCardSource()) &&
(
(destroyCard.ResponsibleCard != null && destroyCard.ResponsibleCard.Owner == this.TurnTaker) ||
(destroyCard.CardSource != null && destroyCard.CardSource.Card != null && destroyCard.CardSource.Card.Owner == this.TurnTaker)
));
}
private bool DestroyIsDueToDamageFromHighHitPoints(DestroyCardAction dc)
{
if (dc.ActionSource != null && dc.ActionSource is DealDamageAction)
{
var damageAction = dc.ActionSource as DealDamageAction;
return(damageAction.TargetHitPointsBeforeBeingDealtDamage > 1);
}
return(false);
}
public IEnumerator RescueOngoingResponse(DestroyCardAction dc, HeroTurnTaker _1, StatusEffect _2, int[] _3 = null)
{
if (dc.PostDestroyDestinationCanBeChanged && dc.CardToDestroy != null)
{
dc.PostDestroyDestinationCanBeChanged = false;
dc.AddAfterDestroyedAction(() => GameController.MoveCard(DecisionMaker, dc.CardToDestroy.Card, dc.CardToDestroy.HeroTurnTaker.Hand, cardSource: GetCardSource()), this);
}
yield break;
}
private IEnumerator DestroyedResponse(DestroyCardAction destroy)
{
List <Card> revealedCards = new List <Card>();
IEnumerator revealCardsRoutine = base.GameController.RevealCards(this.TurnTakerController, base.TurnTaker.Deck,
CardsToReveal, revealedCards, revealedCardDisplay: RevealedCardDisplay.ShowRevealedCards, cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(revealCardsRoutine));
}
else
{
base.GameController.ExhaustCoroutine(revealCardsRoutine);
}
if (!revealedCards.Any())
{
yield break;
}
IEnumerable <Function> choices = new[]
{
new Function(base.DecisionMaker, "Discard Card", SelectionType.DiscardCard,
() => base.GameController.MoveCard(base.DecisionMaker, revealedCards.First(), base.TurnTaker.Trash, showMessage: true, cardSource: GetCardSource())),
new Function(base.DecisionMaker, "Replace Card", SelectionType.MoveCardOnDeck,
() => base.GameController.MoveCard(base.DecisionMaker, revealedCards.First(), base.TurnTaker.Deck, showMessage: true, cardSource: GetCardSource()))
};
List <MoveCardAction> virusMoveAction = new List <MoveCardAction>();
if (IsSuperVirusInPlay() && IsVirus(revealedCards.First()))
{
choices = choices.Concat(new[]
{
new Function(base.DecisionMaker, "Put under Super Virus", SelectionType.MoveCardToUnderCard,
() => base.GameController.MoveCard(base.DecisionMaker, revealedCards.First(),
GetSuperVirusCard().UnderLocation, storedResults: virusMoveAction, showMessage: true, cardSource: GetCardSource())),
});
}
SelectFunctionDecision selectFunctionDecision
= new SelectFunctionDecision(base.GameController, this.DecisionMaker, choices, false, associatedCards: revealedCards, cardSource: base.GetCardSource());
IEnumerator routine = base.GameController.SelectAndPerformFunction(selectFunctionDecision);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(routine));
}
else
{
base.GameController.ExhaustCoroutine(routine);
}
yield break;
}
private bool DestroyCriteria(DestroyCardAction dca)
{
//this should only apply to the GrandOngoings that need High
//your are my requiredIdentifer
//me and you are both in play
//you are moving to the hand or trash
return((dca.CardToDestroy.Card.Identifier == _requiredIdentifier || dca.CardToDestroy.Card.Identifier == _attachIdentifier) &&
dca.WasCardDestroyed &&
dca.CardToDestroy.Card.Location.IsHeroPlayAreaRecursive);
}
private IEnumerator DestroyRadiationBackResponse(DestroyCardAction action)
{
TurnTaker responsibleTurnTaker;
if (action.ResponsibleCard != null)
{
responsibleTurnTaker = action.ResponsibleCard.Owner;
}
else
{
responsibleTurnTaker = base.TurnTaker;
}
//Whenever a radiation card is destroyed by a hero card, {Gray} deals that hero {H - 1} energy damage.
IEnumerator coroutine;
//if its not a hero destroying it do no damage
if (responsibleTurnTaker != null && responsibleTurnTaker.IsHero && !responsibleTurnTaker.IsIncapacitatedOrOutOfGame)
{
List <Card> results = new List <Card>();
coroutine = base.FindCharacterCardToTakeDamage(responsibleTurnTaker, results, Card, Game.H - 1, DamageType.Energy);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
coroutine = base.DealDamage(base.Card, results.First(), Game.H - 1, DamageType.Energy);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
//Whenever a copy of Radioactive Cascade is destroyed, {Gray} deals the hero with the highest HP {H - 1} energy damage.
if (action.CardToDestroy.Card.Identifier == "RadioactiveCascade")
{
coroutine = base.DealDamageToHighestHP(base.Card, 1, (Card c) => c.IsHero, (Card c) => new int?(Game.H - 1), DamageType.Energy);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
yield break;
}
private bool IsByHero(DestroyCardAction dc)
{
if (dc != null && dc.ActionSource is DealDamageAction damage)
{
return(damage.DamageSource.IsHero);
}
else if (dc != null && dc.CardSource != null)
{
return(dc.CardSource.Card.IsHero);
}
return(false);
}
private IEnumerator GameOverResponse(DestroyCardAction dca)
{
IEnumerator routine = base.GameController.GameOver(EndingResult.AlternateDefeat, LoseMessage, actionSource: dca, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(routine));
}
else
{
base.GameController.ExhaustCoroutine(routine);
}
}
private IEnumerator GainHpResponse(DestroyCardAction destroyCard)
{
IEnumerator gainHpRoutine = this.GameController.GainHP(this.CharacterCard, HpGain, cardSource: this.GetCardSource());
if (this.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(gainHpRoutine));
}
else
{
this.GameController.ExhaustCoroutine(gainHpRoutine);
}
}
protected override IEnumerator FireArrow(DestroyCardAction dca = null)
{
var damage = this.GameController.SelectTargetsAndDealDamage(DecisionMaker, new DamageSource(GameController, CharacterCard), 1, DamageType.Projectile, 1, false, 0, false, false, false, c => !c.IsHero, addStatusEffect: Debilitate, cardSource: GetCardSource());
if (UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(damage));
}
else
{
this.GameController.ExhaustCoroutine(damage);
}
}
public static Card GetCardDestroyer(this DestroyCardAction action)
{
if (action.ResponsibleCard != null)
{
return(action.ResponsibleCard);
}
if (action.CardSource != null)
{
return(action.CardSource.Card);
}
return(null);
}
private IEnumerator DestroyCardResponse(DestroyCardAction dca)
{
IEnumerator routine = base.GameController.EachPlayerDiscardsCards(CardsToDiscard, CardsToDiscard, cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(routine));
}
else
{
base.GameController.ExhaustCoroutine(routine);
}
}
private IEnumerator GainHPResponse(DestroyCardAction d)
{
IEnumerator healHero = base.GameController.SelectAndGainHP(this.DecisionMaker, 2, false, (Card c) => c.IsInPlay && c.IsHeroCharacterCard, 1, null, false, null, GetCardSource(null));
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(healHero));
}
else
{
base.GameController.ExhaustCoroutine(healHero);
}
}
protected IEnumerator FreeCaptive(DestroyCardAction arg)
{
var play = PlayCardsFromLocation(Card.UnderLocation, new LinqCardCriteria(c => true));
if (UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(play));
}
else
{
this.GameController.ExhaustCoroutine(play);
}
}
private IEnumerator Reclaim(DestroyCardAction arg)
{
var search = SearchForCards(HeroTurnTakerController, false, true, 1, 0, new LinqCardCriteria(c => c.DoKeywordsContain("arrow")), true, false, false);
if (UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(search));
}
else
{
this.GameController.ExhaustCoroutine(search);
}
}