private IEnumerator UseIncapOption3()
{
// "Until the start of your next turn, this card counts as a target with 1 HP that is indestructible and immune to damage."
MakeTargetStatusEffect animate = new MakeTargetStatusEffect(1, true);
animate.CardsToMakeTargets.IsSpecificCard = base.Card;
animate.UntilStartOfNextTurn(base.TurnTaker);
IEnumerator animateCoroutine = AddStatusEffect(animate);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(animateCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(animateCoroutine);
}
ImmuneToDamageStatusEffect immunity = new ImmuneToDamageStatusEffect();
immunity.TargetCriteria.IsSpecificCard = base.Card;
immunity.UntilStartOfNextTurn(base.TurnTaker);
IEnumerator immuneCoroutine = AddStatusEffect(immunity);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(immuneCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(immuneCoroutine);
}
yield break;
}
public IEnumerator CriminalCourierStartEachTurnResponse(PhaseChangeAction pca)
{
// "At the start of each turn, {Momentum} becomes immune to damage dealt by each environment card that dealt damage to it during the previous turn."
// For each card in hitMomentumLastTurn, if it's still in play...
foreach (Card c in hitMomentumLastTurn)
{
if (c.IsInPlayAndHasGameText)
{
// make Momentum immune to its damage until it leaves play.
ImmuneToDamageStatusEffect status = new ImmuneToDamageStatusEffect
{
TargetCriteria = { IsSpecificCard = base.TurnTaker.FindCard("MomentumCharacter") },
SourceCriteria = { IsSpecificCard = c }
};
status.UntilCardLeavesPlay(c);
IEnumerator statusCoroutine = base.GameController.AddStatusEffect(status, true, GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(statusCoroutine));
}
else
{
this.GameController.ExhaustCoroutine(statusCoroutine);
}
}
}
// Then, clear hitMomentumLastTurn for the new turn
hitMomentumLastTurn = new List <Card>();
yield break;
}
public override IEnumerator UseIncapacitatedAbility(int index)
{
/*
* "One player may use a power now.",
* "2 targets regain 1 HP each.",
* "Until the start of your next turn, whenever a hero would be dealt exactly 1 damage, prevent that damage."
*/
switch (index)
{
case 0:
{
IEnumerator drawCardRoutine = base.GameController.SelectHeroToUsePower(DecisionMaker, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(drawCardRoutine));
}
else
{
base.GameController.ExhaustCoroutine(drawCardRoutine);
}
break;
}
case 1:
{
var coroutine = base.GameController.SelectAndGainHP(DecisionMaker, 1, false, numberOfTargets: 2, requiredDecisions: 2, allowAutoDecide: true, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
case 2:
{
var effect = new ImmuneToDamageStatusEffect();
effect.DamageAmountCriteria.EqualTo = 1;
effect.TargetCriteria.IsHeroCharacterCard = true;
effect.UntilStartOfNextTurn(TurnTaker);
var coroutine = AddStatusEffect(effect, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
}
yield break;
}
protected void AddImmuneToNextDamageEffect(TurnTakerController ttc, bool villains, bool heroes)
{
ImmuneToDamageStatusEffect effect = new ImmuneToDamageStatusEffect();
effect.TargetCriteria.IsVillain = villains;
effect.TargetCriteria.IsHero = heroes;
effect.NumberOfUses = 1;
RunCoroutine(GameController.AddStatusEffect(effect, true, ttc.CharacterCardController.GetCardSource()));
}
protected void AddImmuneToDamageTrigger(TurnTakerController ttc, bool heroesImmune, bool villainsImmune)
{
ImmuneToDamageStatusEffect immuneToDamageStatusEffect = new ImmuneToDamageStatusEffect();
immuneToDamageStatusEffect.TargetCriteria.IsHero = new bool?(heroesImmune);
immuneToDamageStatusEffect.TargetCriteria.IsVillain = new bool?(villainsImmune);
immuneToDamageStatusEffect.UntilStartOfNextTurn(ttc.TurnTaker);
this.RunCoroutine(this.GameController.AddStatusEffect(immuneToDamageStatusEffect, true, new CardSource(ttc.CharacterCardController)));
}
private IEnumerator DealtDamageByEnvResponse(DealDamageAction dda)
{
ImmuneToDamageStatusEffect itdse = new ImmuneToDamageStatusEffect
{
TargetCriteria = { IsSpecificCard = this.CharacterCard },
SourceCriteria = { IsEnvironment = true }
};
itdse.UntilThisTurnIsOver(base.Game);
IEnumerator routine = base.GameController.AddStatusEffect(itdse, true, GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(routine));
}
else
{
base.GameController.ExhaustCoroutine(routine);
}
}
private IEnumerator ImmuneResponse(DealDamageAction dealDamage)
{
DamageType value = dealDamage.DamageType;
//this.GetDamageTypeThatHeadIsImmuneTo(dealDamage.Target) ?? default;
ImmuneToDamageStatusEffect immuneToDamageStatusEffect = new ImmuneToDamageStatusEffect();
immuneToDamageStatusEffect.DamageTypeCriteria.AddType(value);
immuneToDamageStatusEffect.TargetCriteria.IsSpecificCard = dealDamage.Target;
immuneToDamageStatusEffect.UntilStartOfNextTurn(base.TurnTaker);
immuneToDamageStatusEffect.CardDestroyedExpiryCriteria.Card = dealDamage.Target;
IEnumerator coroutine2 = base.AddStatusEffect(immuneToDamageStatusEffect);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine2));
}
else
{
base.GameController.ExhaustCoroutine(coroutine2);
}
yield break;
}
public override IEnumerator UsePower(int index = 0)
{
int targetNumeral = GetPowerNumeral(0, 1);
int damageNumeral = GetPowerNumeral(1, 2);
//{Cricket} deals 1 target 2 melee damage.
IEnumerator coroutine = base.GameController.SelectTargetsAndDealDamage(base.HeroTurnTakerController, new DamageSource(base.GameController, base.CharacterCard), damageNumeral, DamageType.Melee, targetNumeral, false, targetNumeral, cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
//{Cricket} is immune to damage dealt by environment targets until the start of your next turn.
ImmuneToDamageStatusEffect immuneToDamageStatusEffect = new ImmuneToDamageStatusEffect();
//{Cricket}...
immuneToDamageStatusEffect.TargetCriteria.IsSpecificCard = base.CharacterCard;
//...is immune to damage dealt by environment targets...
immuneToDamageStatusEffect.SourceCriteria.IsEnvironment = true;
immuneToDamageStatusEffect.SourceCriteria.IsTarget = true;
//...until the start of your next turn.
immuneToDamageStatusEffect.UntilStartOfNextTurn(base.TurnTaker);
immuneToDamageStatusEffect.CardDestroyedExpiryCriteria.Card = base.CharacterCard;
IEnumerator coroutine2 = base.AddStatusEffect(immuneToDamageStatusEffect, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine2));
}
else
{
base.GameController.ExhaustCoroutine(coroutine2);
}
yield break;
}
public override IEnumerator UseIncapacitatedAbility(int index)
{
switch (index)
{
case 0:
{
//Each Player may Discard a Card. Any Player who does so may Draw a Card.
IEnumerator coroutine = DoActionToEachTurnTakerInTurnOrder(tt => tt.IsHero && !tt.IsIncapacitatedOrOutOfGame, DiscardToDraw);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
case 1:
{
//Until the start of Headlong's next turn, Hero Targets are Immune to Damage from the Environment.
ImmuneToDamageStatusEffect effect = new ImmuneToDamageStatusEffect();
effect.SourceCriteria.IsEnvironment = true;
effect.TargetCriteria.IsHero = true;
effect.UntilStartOfNextTurn(TurnTaker);
IEnumerator coroutine = AddStatusEffect(effect);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
case 2:
{
//You may look at the top card of a deck, then replace it or Discard it.
List <SelectLocationDecision> storedResults = new List <SelectLocationDecision>();
IEnumerator coroutine = base.GameController.SelectADeck(DecisionMaker, SelectionType.MoveCard, (Location l) => true, storedResults, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
if (DidSelectDeck(storedResults))
{
Location selectedLocation = GetSelectedLocation(storedResults);
coroutine = RevealCard_DiscardItOrPutItOnDeck(DecisionMaker, TurnTakerController, selectedLocation, false);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
break;
}
}
yield break;
}
public override IEnumerator UseIncapacitatedAbility(int index)
{
/*
* "One player may use a power now.",
* "Destroy 1 ongoing card.",
* "Select 1 environment target in play. Destroy it at the start of your next turn. Until then, it is immune to damage."
*/
switch (index)
{
case 0:
{
//"One player may use a power now."
IEnumerator coroutine = base.GameController.SelectHeroToUsePower(this.DecisionMaker, cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
case 1:
{
//"Destroy 1 ongoing card.",
var coroutine = GameController.SelectAndDestroyCard(DecisionMaker, new LinqCardCriteria(c => c.IsOngoing, "ongoing"), false, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
case 2:
{
//"Select 1 environment target in play. Destroy it at the start of your next turn. Until then, it is immune to damage."
List <SelectCardDecision> storedResults = new List <SelectCardDecision>();
var coroutine = GameController.SelectCardAndStoreResults(DecisionMaker, SelectionType.DestroyCard, new LinqCardCriteria(c => c.IsEnvironmentTarget, "environment target", false), storedResults, false,
allowAutoDecide: true,
cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
if (DidSelectCard(storedResults))
{
var card = GetSelectedCard(storedResults);
if (IsRealAction())
{
Journal.RecordCardProperties(card, "MarkedForDestruction", true);
}
var immune = new ImmuneToDamageStatusEffect();
immune.CardSource = CharacterCard;
immune.TargetCriteria.IsSpecificCard = card;
immune.UntilCardLeavesPlay(card);
coroutine = base.AddStatusEffect(immune, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
var effect = new OnPhaseChangeStatusEffect(CardWithoutReplacements, nameof(DestroyMarkedTarget), $"{card.Title} will be destroyed at the start of {CharacterCard.Title}'s next turn.", new[] { TriggerType.DestroyCard }, CharacterCard);
effect.TurnPhaseCriteria.TurnTaker = TurnTaker;
effect.TurnPhaseCriteria.Phase = Phase.Start;
effect.NumberOfUses = 1;
effect.CanEffectStack = true;
effect.CardSource = CharacterCard;
effect.UntilTargetLeavesPlay(card);
coroutine = base.AddStatusEffect(effect, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
break;
}
}
yield break;
}
public override IEnumerator UseIncapacitatedAbility(int index)
{
IEnumerator coroutine;
switch (index)
{
case (0):
{
//"One hero may put a card from their trash on top of their deck.",
var turnTakerDecision = new SelectTurnTakerDecision(GameController, DecisionMaker, GameController.FindTurnTakersWhere((TurnTaker tt) => tt.IsHero && !tt.IsIncapacitatedOrOutOfGame && GameController.IsTurnTakerVisibleToCardSource(tt, GetCardSource())), SelectionType.MoveCardOnDeck, true, cardSource: GetCardSource());
coroutine = GameController.SelectTurnTakerAndDoAction(turnTakerDecision, (TurnTaker tt) => GameController.SelectAndMoveCard(FindHeroTurnTakerController(tt.ToHero()), (Card c) => c.Location == tt.Trash, tt.Deck, cardSource: GetCardSource()));
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
case (1):
{
//"Destroy 1 ongoing card.",
coroutine = GameController.SelectAndDestroyCard(DecisionMaker, new LinqCardCriteria((Card c) => c.IsOngoing, "ongoing"), false, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
case (2):
{
//"Select a target. Until the start of your next turn that target is immune to damage from environment cards."
var storedTarget = new List <SelectCardDecision> {
};
coroutine = GameController.SelectCardAndStoreResults(DecisionMaker, SelectionType.PreventDamage, new LinqCardCriteria((Card c) => c.IsInPlayAndHasGameText && AskIfCardIsVisibleToCardSource(c, GetCardSource()) != false && c.IsTarget), storedTarget, false, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
var card = storedTarget.FirstOrDefault()?.SelectedCard;
if (card != null)
{
var preventDamage = new ImmuneToDamageStatusEffect();
preventDamage.TargetCriteria.IsSpecificCard = card;
preventDamage.SourceCriteria.IsEnvironment = true;
preventDamage.UntilStartOfNextTurn(TurnTaker);
coroutine = AddStatusEffect(preventDamage);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
break;
}
}
yield break;
}
public override IEnumerator Play()
{
//Look at the Top 3 Cards of the Environment Deck. Put one into Play, one at the top or bottom of the Environment Deck, and one into the Trash.
List <Card> storedResults = new List <Card>();
IEnumerator coroutine = GameController.RevealCards(TurnTakerController, FindEnvironment().TurnTaker.Deck, 3, storedResults, revealedCardDisplay: RevealedCardDisplay.ShowRevealedCards, cardSource: GetCardSource());
if (UseUnityCoroutines)
{
yield return(GameController.StartCoroutine(coroutine));
}
else
{
GameController.ExhaustCoroutine(coroutine);
}
if (storedResults.Any())
{
//Put one into Play
List <PlayCardAction> playedCard = new List <PlayCardAction>();
coroutine = GameController.SelectAndPlayCard(HeroTurnTakerController, storedResults, isPutIntoPlay: true, storedResults: playedCard, cardSource: GetCardSource());
if (UseUnityCoroutines)
{
yield return(GameController.StartCoroutine(coroutine));
}
else
{
GameController.ExhaustCoroutine(coroutine);
}
if (DidPlayCards(playedCard))
{
Card toRemove = playedCard.First().CardToPlay;
storedResults.Remove(toRemove);
}
}
if (storedResults.Any())
{
//put one at the top or bottom of the Environment Deck
List <SelectCardDecision> moveCardResults = new List <SelectCardDecision>();
coroutine = GameController.SelectCardAndStoreResults(HeroTurnTakerController, SelectionType.MoveCard, storedResults, moveCardResults, cardSource: GetCardSource());
if (UseUnityCoroutines)
{
yield return(GameController.StartCoroutine(coroutine));
}
else
{
GameController.ExhaustCoroutine(coroutine);
}
if (DidSelectCard(moveCardResults))
{
Card selectedCard = GetSelectedCard(moveCardResults);
List <MoveCardDestination> list = new List <MoveCardDestination>();
list.Add(new MoveCardDestination(FindEnvironment().TurnTaker.Deck));
list.Add(new MoveCardDestination(FindEnvironment().TurnTaker.Deck, toBottom: true));
coroutine = GameController.SelectLocationAndMoveCard(HeroTurnTakerController, selectedCard, list, cardSource: GetCardSource());
if (UseUnityCoroutines)
{
yield return(GameController.StartCoroutine(coroutine));
}
else
{
GameController.ExhaustCoroutine(coroutine);
}
storedResults.Remove(selectedCard);
}
}
if (storedResults.Any())
{
//put one into the Trash
Card cardToMove = storedResults.First();
coroutine = GameController.MoveCard(TurnTakerController, cardToMove, FindEnvironment().TurnTaker.Trash, cardSource: GetCardSource());
if (UseUnityCoroutines)
{
yield return(GameController.StartCoroutine(coroutine));
}
else
{
GameController.ExhaustCoroutine(coroutine);
}
}
//Until the Start of {Headlong}’s next Turn, Heroes are Immune to Damage from Environment Cards.
ImmuneToDamageStatusEffect effect = new ImmuneToDamageStatusEffect();
effect.SourceCriteria.IsEnvironment = true;
effect.TargetCriteria.IsHeroCharacterCard = true;
effect.UntilStartOfNextTurn(TurnTaker);
coroutine = AddStatusEffect(effect);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
