public override IEnumerator Play()
{
if (!base.Card.Location.IsNextToCard)
{
yield break;
}
CannotDealDamageStatusEffect cddse = new CannotDealDamageStatusEffect
{
IsPreventEffect = true,
SourceCriteria = { IsSpecificCard = base.GetCardThisCardIsNextTo() }
};
cddse.UntilCardLeavesPlay(base.Card);
IEnumerator routine = base.GameController.AddStatusEffect(cddse, true, GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(routine));
}
else
{
base.GameController.ExhaustCoroutine(routine);
}
}
protected void AddCannotDealTrigger(TurnTakerController ttc, Card card)
{
CannotDealDamageStatusEffect cannotDealDamageStatusEffect = new CannotDealDamageStatusEffect();
cannotDealDamageStatusEffect.SourceCriteria.IsSpecificCard = card;
this.RunCoroutine(this.GameController.AddStatusEffect(cannotDealDamageStatusEffect, true, new CardSource(ttc.CharacterCardController)));
}
public override IEnumerator UsePower(int index = 0)
{
// "Choose a target. Prevent the next damage that target would deal to {ImpulseCharacter}. Draw a card."
List <SelectCardDecision> targetChoices = new List <SelectCardDecision>();
IEnumerator chooseCoroutine = base.GameController.SelectCardAndStoreResults(base.HeroTurnTakerController, SelectionType.SelectTargetNoDamage, new LinqCardCriteria((Card c) => c.IsTarget && c.IsInPlayAndHasGameText && GameController.IsCardVisibleToCardSource(c, GetCardSource())), targetChoices, false, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(chooseCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(chooseCoroutine);
}
if (targetChoices != null && targetChoices.Count > 0)
{
Card targetChosen = targetChoices.FirstOrDefault().SelectedCard;
/*OnDealDamageStatusEffect preventNextDamage = new OnDealDamageStatusEffect(base.Card, "PreventDamage", "Prevent the next damage " + targetChosen.Title + " would deal to " + base.CharacterCard.Title + ".", new TriggerType[] { TriggerType.CancelAction }, base.TurnTaker, base.Card);
* preventNextDamage.SourceCriteria.IsSpecificCard = targetChosen;
* preventNextDamage.TargetCriteria.IsSpecificCard = base.CharacterCard;
* preventNextDamage.DamageAmountCriteria.GreaterThan = 0;
* preventNextDamage.NumberOfUses = 1;
* preventNextDamage.UntilCardLeavesPlay(targetChosen);
* preventNextDamage.UntilCardLeavesPlay(base.CharacterCard);
* preventNextDamage.CanEffectStack = true;
* preventNextDamage.IsPreventEffect = true;*/
CannotDealDamageStatusEffect preventNextDamage = new CannotDealDamageStatusEffect();
preventNextDamage.SourceCriteria.IsSpecificCard = targetChosen;
preventNextDamage.TargetCriteria.IsSpecificCard = base.CharacterCard;
preventNextDamage.NumberOfUses = 1;
preventNextDamage.IsPreventEffect = true;
preventNextDamage.UntilCardLeavesPlay(targetChosen);
preventNextDamage.UntilCardLeavesPlay(base.CharacterCard);
IEnumerator statusCoroutine = base.AddStatusEffect(preventNextDamage);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(statusCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(statusCoroutine);
}
}
IEnumerator drawCoroutine = base.GameController.DrawCard(base.HeroTurnTaker, optional: false, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(drawCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(drawCoroutine);
}
yield break;
}
private IEnumerator DoIncapacitateOption3()
{
//==============================================================
// Environment cards cannot deal damage until the start of your next turn..
//==============================================================
CannotDealDamageStatusEffect cannotDealDamageStatusEffect = new CannotDealDamageStatusEffect();
cannotDealDamageStatusEffect.IsPreventEffect = true;
cannotDealDamageStatusEffect.SourceCriteria.IsEnvironment = true;
cannotDealDamageStatusEffect.UntilStartOfNextTurn(this.TurnTaker);
return(this.GameController.AddStatusEffect(cannotDealDamageStatusEffect, true, this.GetCardSource()));
}
private IEnumerator DealDamageResponse(PhaseChangeAction pca)
{
//make hero targets who caused Teryx to gain HP last round to become immune to the next damage
IEnumerator makeImmune;
foreach (Card c in this.GetHeroesWhoCausedTeryxToGainHpLastRound())
{
CannotDealDamageStatusEffect cannotDealDamageStatusEffect = new CannotDealDamageStatusEffect();
cannotDealDamageStatusEffect.TargetCriteria.IsSpecificCard = c;
cannotDealDamageStatusEffect.NumberOfUses = new int?(1);
cannotDealDamageStatusEffect.UntilTargetLeavesPlay(c);
cannotDealDamageStatusEffect.IsPreventEffect = true;
makeImmune = base.AddStatusEffect(cannotDealDamageStatusEffect, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(makeImmune));
}
else
{
base.GameController.ExhaustCoroutine(makeImmune);
}
}
//this card deals each target other than Teryx 4 sonic damage
IEnumerator dealDamage = base.DealDamage(base.Card, (Card c) => c.Identifier != "Teryx", 4, DamageType.Sonic);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(dealDamage));
}
else
{
base.GameController.ExhaustCoroutine(dealDamage);
}
//Then, this card is destroyed.
IEnumerator destroy = 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(destroy));
}
else
{
base.GameController.ExhaustCoroutine(destroy);
}
yield break;
}
private IEnumerator EndOfTurnResponse()
{
List <SelectCardDecision> storedResults = new List <SelectCardDecision>();
IEnumerator coroutine = base.GameController.SelectTargetsAndDealDamage(base.HeroTurnTakerController, new DamageSource(base.GameController, base.CharacterCard), 1, DamageType.Sonic, 1, false, 1, false, false, false, null, storedResults, null, null, null, true, null, null, false, null, GetCardSource(null));
if (UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
Card target = storedResults.FirstOrDefault()?.SelectedCard;
if (base.GameController.IsCardInPlayAndNotUnderCard(base.VigilanteJusticeIdentifier) || base.GameController.IsCardInPlayAndNotUnderCard(base.ThunderStormIdentifier))
{
IncreaseDamageStatusEffect idse = new IncreaseDamageStatusEffect(1);
idse.TargetCriteria.IsSpecificCard = target;
idse.NumberOfUses = 1;
idse.UntilCardLeavesPlay(target);
coroutine = AddStatusEffect(idse, true);
if (UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
if (base.GameController.IsCardInPlayAndNotUnderCard(base.VigilanteJusticeIdentifier) && base.GameController.IsCardInPlayAndNotUnderCard(base.ThunderStormIdentifier))
{
CannotDealDamageStatusEffect cddse = new CannotDealDamageStatusEffect();
cddse.SourceCriteria.IsSpecificCard = target;
cddse.NumberOfUses = 1;
cddse.UntilCardLeavesPlay(target);
coroutine = AddStatusEffect(cddse, true);
if (UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
}
private IEnumerator Inhibit(DealDamageAction arg)
{
CannotDealDamageStatusEffect rdse = new CannotDealDamageStatusEffect();
rdse.UntilStartOfNextTurn(TurnTaker);
rdse.SourceCriteria.IsSpecificCard = arg.Target;
var status = AddStatusEffect(rdse);
if (UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(status));
}
else
{
this.GameController.ExhaustCoroutine(status);
}
}
public override IEnumerator UsePower(int index = 0)
{
// "Draw a card, then discard a card."
IEnumerator drawCoroutine = base.GameController.DrawCard(base.HeroTurnTaker, optional: false, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(drawCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(drawCoroutine);
}
IEnumerator discardCoroutine = base.GameController.SelectAndDiscardCard(base.HeroTurnTakerController, optional: false, responsibleTurnTaker: base.TurnTaker, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(discardCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(discardCoroutine);
}
// "Prevent the next damage that would be dealt to {ImpulseCharacter}."
CannotDealDamageStatusEffect preventNextDamage = new CannotDealDamageStatusEffect();
preventNextDamage.TargetCriteria.IsSpecificCard = base.Card;
preventNextDamage.NumberOfUses = 1;
preventNextDamage.IsPreventEffect = true;
IEnumerator statusCoroutine = base.AddStatusEffect(preventNextDamage);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(statusCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(statusCoroutine);
}
yield break;
}
public override IEnumerator Play()
{
// Select target
List <SelectCardDecision> selectCardResults = new List <SelectCardDecision>();
IEnumerator selectCardRoutine = base.GameController.SelectCardAndStoreResults(base.HeroTurnTakerController, SelectionType.SelectTargetNoDamage,
new LinqCardCriteria(c => c.IsTarget && c.IsInPlayAndHasGameText, "targets in play", false), selectCardResults, false, false, null, true, base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(selectCardRoutine));
}
else
{
base.GameController.ExhaustCoroutine(selectCardRoutine);
}
if (DidSelectCard(selectCardResults))
{
Card selectedCard = GetSelectedCard(selectCardResults);
// Apply cannot deal damage status effect to chosen card
CannotDealDamageStatusEffect effect = new CannotDealDamageStatusEffect();
effect.CardSource = Card;
effect.SourceCriteria.IsSpecificCard = selectedCard;
effect.UntilStartOfNextTurn(base.TurnTaker);
effect.UntilTargetLeavesPlay(selectedCard);
IEnumerator cannotDealDamageRoutine = base.AddStatusEffect(effect);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(cannotDealDamageRoutine));
}
else
{
base.GameController.ExhaustCoroutine(cannotDealDamageRoutine);
}
}
}
public override IEnumerator UseIncapacitatedAbility(int index)
{
IEnumerator coroutine;
switch (index)
{
case 0:
{
//Each hero may deal themselves 1 psychic damage to draw a card.
this.actedHeroes = new List <Card>();
IEnumerable <Function> functionsBasedOnCard(Card c) => new Function[]
{
new Function(base.FindCardController(c).DecisionMaker, "Deal self 1 psychic damage to draw a card now.", SelectionType.DrawCard, () => this.DealDamageAndDrawResponse(c))
};
coroutine = base.GameController.SelectCardsAndPerformFunction(this.DecisionMaker, new LinqCardCriteria((Card c) => c.IsHeroCharacterCard && c.IsInPlayAndHasGameText && !c.IsIncapacitatedOrOutOfGame && !this.actedHeroes.Contains(c), "active hero character cards", false, false, null, null, false), functionsBasedOnCard, true, base.GetCardSource(null));
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
case 1:
{
//Destroy an environment card.
coroutine = base.GameController.SelectAndDestroyCard(base.HeroTurnTakerController, new LinqCardCriteria((Card c) => c.IsEnvironment), false, cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
case 2:
{
//Prevent the next damage that would be dealt to a hero target.
CannotDealDamageStatusEffect statusEffect = new CannotDealDamageStatusEffect()
{
TargetCriteria = { IsHero = true },
NumberOfUses = 1
};
coroutine = base.AddStatusEffect(statusEffect);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
}
}
public override IEnumerator Play()
{
// "One player, other than you, may play a card or use a power."
LinqTurnTakerCriteria otherPlayer = new LinqTurnTakerCriteria((TurnTaker tt) => tt != base.TurnTaker);
List <Function> options = new List <Function>();
options.Add(new Function(base.HeroTurnTakerController, "Another player may play a card", SelectionType.PlayCard, () => SelectHeroToPlayCard(base.HeroTurnTakerController, false, true, heroCriteria: otherPlayer)));
options.Add(new Function(base.HeroTurnTakerController, "Another hero may use a power", SelectionType.UsePower, () => base.GameController.SelectHeroToUsePower(base.HeroTurnTakerController, additionalCriteria: otherPlayer, cardSource: GetCardSource())));
SelectFunctionDecision choice = new SelectFunctionDecision(base.GameController, base.HeroTurnTakerController, options, false, noSelectableFunctionMessage: "No other players may currently play cards or use powers.", cardSource: GetCardSource());
IEnumerator chooseCoroutine = base.GameController.SelectAndPerformFunction(choice);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(chooseCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(chooseCoroutine);
}
// "If another player played a card this turn, prevent the next damage dealt to a hero target."
List <PlayCardJournalEntry> thisTurnPlays = base.GameController.Game.Journal.PlayCardEntriesThisTurn().Where((PlayCardJournalEntry pcje) => pcje.CardPlayed.Owner.IsHero && pcje.CardPlayed.Owner != base.TurnTaker).ToList();
bool otherHasPlayed = thisTurnPlays.Count > 0;
if (otherHasPlayed)
{
CannotDealDamageStatusEffect preventNextDamage = new CannotDealDamageStatusEffect();
preventNextDamage.TargetCriteria.IsHero = true;
preventNextDamage.TargetCriteria.IsTarget = true;
preventNextDamage.NumberOfUses = 1;
preventNextDamage.IsPreventEffect = true;
IEnumerator statusCoroutine = base.AddStatusEffect(preventNextDamage);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(statusCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(statusCoroutine);
}
}
// "If another hero used a power this turn, you may play an Ongoing card."
List <UsePowerJournalEntry> thisTurnPowers = base.GameController.Game.Journal.UsePowerEntriesThisTurn().Where((UsePowerJournalEntry upje) => upje.PowerUser != base.HeroTurnTaker).ToList();
bool otherHasUsedPower = thisTurnPowers.Count > 0;
if (otherHasUsedPower)
{
IEnumerator ongoingCoroutine = SelectAndPlayCardFromHand(base.HeroTurnTakerController, cardCriteria: new LinqCardCriteria((Card c) => c.DoKeywordsContain("ongoing")));
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(ongoingCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(ongoingCoroutine);
}
}
// "If neither happened, {ImpulseCharacter} deals up to 2 targets 2 melee damage each."
if (!otherHasPlayed && !otherHasUsedPower)
{
IEnumerator damageCoroutine = base.GameController.SelectTargetsAndDealDamage(base.HeroTurnTakerController, new DamageSource(base.GameController, base.CharacterCard), 2, DamageType.Melee, 2, false, 0, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(damageCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(damageCoroutine);
}
}
yield break;
}
