public IEnumerator ApplyStatusesResponse(DealDamageAction dda)
{
// "... reduce damage dealt by that target to {TheGoalieCharacter} by 1 and increase damage dealt by {TheGoalieCharacter} to that target by 1 until the end of your next turn."
ReduceDamageStatusEffect reduction = new ReduceDamageStatusEffect(1);
reduction.SourceCriteria.IsSpecificCard = dda.DamageSource.Card;
reduction.TargetCriteria.IsSpecificCard = base.CharacterCard;
reduction.UntilCardLeavesPlay(dda.DamageSource.Card);
reduction.UntilCardLeavesPlay(base.CharacterCard);
reduction.UntilEndOfNextTurn(base.TurnTaker);
IncreaseDamageStatusEffect increase = new IncreaseDamageStatusEffect(1);
increase.SourceCriteria.IsSpecificCard = base.CharacterCard;
increase.TargetCriteria.IsSpecificCard = dda.DamageSource.Card;
increase.UntilCardLeavesPlay(dda.DamageSource.Card);
increase.UntilCardLeavesPlay(base.CharacterCard);
increase.UntilEndOfNextTurn(base.TurnTaker);
IEnumerator reduceCoroutine = AddStatusEffect(reduction);
IEnumerator increaseCoroutine = AddStatusEffect(increase);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(reduceCoroutine));
yield return(base.GameController.StartCoroutine(increaseCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(reduceCoroutine);
base.GameController.ExhaustCoroutine(increaseCoroutine);
}
yield break;
}
private IEnumerator EndOfTurnResponse()
{
var applyStatusFunction = new Func <DealDamageAction, IEnumerator>(this.ApplyStatusEffects);
if (!base.GameController.IsCardInPlayAndNotUnderCard(base.ViciousRetributionIdentifier))
{
applyStatusFunction = null;
}
IEnumerator coroutine = base.GameController.SelectTargetsAndDealDamage(base.HeroTurnTakerController, new DamageSource(base.GameController, base.CharacterCard), 1, DamageType.Psychic, 1, false, 1, false, false, false, null, null, null, null, applyStatusFunction, true, null, null, false, null, GetCardSource(null));
if (UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
if (base.GameController.IsCardInPlayAndNotUnderCard(base.FlaringBlazeIdentifier))
{
IncreaseDamageStatusEffect idse = new IncreaseDamageStatusEffect(1);
idse.SourceCriteria.IsSpecificCard = base.CharacterCard;
idse.NumberOfUses = 1;
idse.UntilCardLeavesPlay(base.CharacterCard);
coroutine = AddStatusEffect(idse, true);
if (UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
}
public override IEnumerator UsePower(int index = 0)
{
int powerNumeral = GetPowerNumeral(0, 2);
// "Draw 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);
}
// "Increase the next damage dealt by {PalmreaderCharacter} by 2."
IncreaseDamageStatusEffect increaseEffect = new IncreaseDamageStatusEffect(powerNumeral);
increaseEffect.SourceCriteria.IsSpecificCard = base.CharacterCard;
increaseEffect.NumberOfUses = 1;
increaseEffect.UntilCardLeavesPlay(base.CharacterCard);
IEnumerator increaseCoroutine = base.AddStatusEffect(increaseEffect);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(increaseCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(increaseCoroutine);
}
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 IncreaseNextDamageResponse(DealDamageAction dd)
{
IncreaseDamageStatusEffect increaseDamageStatusEffect = new IncreaseDamageStatusEffect(1);
increaseDamageStatusEffect.SourceCriteria.IsSpecificCard = this.HeroTurnTaker.CharacterCard;
increaseDamageStatusEffect.UntilCardLeavesPlay(this.HeroTurnTaker.CharacterCard);
increaseDamageStatusEffect.NumberOfUses = 1;
IEnumerator coroutine = base.AddStatusEffect(increaseDamageStatusEffect, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
public override IEnumerator Play()
{
List <SelectCardDecision> storedResults = new List <SelectCardDecision>();
IEnumerator coroutine = base.GameController.SelectCardAndStoreResults(this.DecisionMaker, SelectionType.SelectTargetFriendly, new LinqCardCriteria((Card c) => c.IsInPlayAndHasGameText && c.IsTarget, "hero target in play", false, false, null, null, false), storedResults, true, false, null, true, base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
Card selectedCard = base.GetSelectedCard(storedResults);
IncreaseDamageStatusEffect idse = new IncreaseDamageStatusEffect(1);
idse.SourceCriteria.IsSpecificCard = selectedCard;
idse.UntilStartOfNextTurn(base.TurnTaker);
idse.UntilCardLeavesPlay(selectedCard);
coroutine = base.AddStatusEffect(idse, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
IncreaseDamageStatusEffect idse2 = new IncreaseDamageStatusEffect(1);
idse2.SourceCriteria.IsSpecificCard = selectedCard;
idse2.UntilCardLeavesPlay(selectedCard);
idse2.NumberOfUses = 1;
IEnumerator coroutine2 = base.AddStatusEffect(idse2, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine2));
}
else
{
base.GameController.ExhaustCoroutine(coroutine2);
}
}
private IEnumerator IncreaseDamageResponse(DealDamageAction dd)
{
if (!dd.DidDealDamage)
{
IncreaseDamageStatusEffect increaseDamageStatusEffect = new IncreaseDamageStatusEffect(1);
increaseDamageStatusEffect.TargetCriteria.IsSpecificCard = dd.Target;
increaseDamageStatusEffect.UntilStartOfNextTurn(base.GameController.FindNextTurnTaker());
increaseDamageStatusEffect.UntilCardLeavesPlay(dd.Target);
IEnumerator coroutine = base.AddStatusEffect(increaseDamageStatusEffect, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
yield break;
}
private IEnumerator IncreaseDamageDealtByThatTargetResponse(DealDamageAction dd, int numBoost)
{
//Increase damage dealt by that target by 1 until the start of your next turn.
var target = dd.Target;
var boostEffect = new IncreaseDamageStatusEffect(numBoost);
boostEffect.UntilStartOfNextTurn(this.TurnTaker);
boostEffect.SourceCriteria.IsSpecificCard = target;
boostEffect.UntilCardLeavesPlay(target);
IEnumerator coroutine = AddStatusEffect(boostEffect);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
public IEnumerator IncreaseMeleeResponse(GameAction ga)
{
// "... increase melee damage dealt by {TheGoalieCharacter} this turn by 2."
IncreaseDamageStatusEffect targetLock = new IncreaseDamageStatusEffect(2);
targetLock.SourceCriteria.IsSpecificCard = base.CharacterCard;
targetLock.DamageTypeCriteria.AddType(DamageType.Melee);
targetLock.UntilThisTurnIsOver(base.Game);
targetLock.UntilCardLeavesPlay(base.CharacterCard);
IEnumerator statusCoroutine = base.GameController.AddStatusEffect(targetLock, true, GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(statusCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(statusCoroutine);
}
yield break;
}
public IEnumerator PermanentIncreaseResponse(DestroyCardAction dca)
{
// "When this card is destroyed, increase damage dealt by villain targets by 1..."
IncreaseDamageStatusEffect pitiless = new IncreaseDamageStatusEffect(1);
pitiless.SourceCriteria.IsVillain = true;
pitiless.UntilCardLeavesPlay(base.CharacterCard);
IEnumerator statusCoroutine = base.GameController.AddStatusEffect(pitiless, true, GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(statusCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(statusCoroutine);
}
// "... and remove this card from the game."
AddInhibitorException((GameAction ga) => ga is MoveCardAction && (ga as MoveCardAction).Destination.IsOutOfGame);
dca.SetPostDestroyDestination(base.TurnTaker.OutOfGame, showMessage: true, cardSource: GetCardSource());
AddInhibitorException((GameAction ga) => ga is TargetLeavesPlayAction);
yield break;
}
private IEnumerator StatusEffectResponse(DealDamageAction action)
{
int increases = GetPowerNumeral(2, 1);
var effect = new IncreaseDamageStatusEffect(increases);
effect.TargetCriteria.IsSpecificCard = action.Target;
effect.UntilStartOfNextTurn(TurnTaker);
effect.UntilCardLeavesPlay(action.Target);
effect.CardSource = Card;
effect.Identifier = Card.Title;
var coroutine = base.AddStatusEffect(effect, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
public override IEnumerator Play()
{
if (GameController.FindCardsWhere((Card c) => c.IsInPlay && c.IsHero && !c.IsCharacter).Any())
{
// "Each player may destroy any number of their non-character cards."
List <DestroyCardAction> destroyAttempts = new List <DestroyCardAction>();
//SelectTurnTakersDecision destroyOrder = new SelectTurnTakersDecision(base.GameController, this.DecisionMaker, new LinqTurnTakerCriteria((TurnTaker tt) => tt.IsHero), SelectionType.DestroyCard, isOptional: true, allowAutoDecide: true, cardSource: GetCardSource());
//IEnumerator playersDestroyCoroutine = base.GameController.SelectTurnTakersAndDoAction(destroyOrder, (TurnTaker tt) => base.GameController.SelectAndDestroyCard(base.FindHeroTurnTakerController(tt.ToHero()), new LinqCardCriteria((Card c) => !c.IsCharacter && c.Owner == tt, "non-character"), true, storedResultsAction: destroyAttempts, cardSource: GetCardSource()));
IEnumerator playersDestroyCoroutine = EachPlayerDestroysTheirCards(new LinqTurnTakerCriteria((TurnTaker tt) => true, "players with non-character cards in play"), new LinqCardCriteria((Card c) => !c.IsCharacter, "non-character"), null, requiredNumberOfCards: 0, requiredNumberOfHeroes: 0, storedResults: destroyAttempts);
if (base.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(playersDestroyCoroutine));
}
else
{
this.GameController.ExhaustCoroutine(playersDestroyCoroutine);
}
// "For each player who destroyed at least 1 card this way,..."
List <TurnTaker> heroesWithDestroyed = new List <TurnTaker>();
if (destroyAttempts.Count() > 0)
{
using (List <DestroyCardAction> .Enumerator enumerator = destroyAttempts.GetEnumerator())
{
while (enumerator.MoveNext())
{
DestroyCardAction destroyed = enumerator.Current;
if (destroyed.WasCardDestroyed && !heroesWithDestroyed.Contains(destroyed.CardToDestroy.TurnTaker))
{
Log.Debug(destroyed.CardToDestroy.TurnTaker.Identifier + " has destroyed a card");
heroesWithDestroyed.Add(destroyed.CardToDestroy.TurnTaker);
}
}
}
}
int numHeroesDestroyed = heroesWithDestroyed.Count();
for (int i = 0; i < numHeroesDestroyed; i++)
{
// "... increase the next damage dealt to {Momentum} by 1..."
IncreaseDamageStatusEffect plusX = new IncreaseDamageStatusEffect(1);
plusX.TargetCriteria.IsSpecificCard = base.TurnTaker.FindCard("MomentumCharacter");
plusX.NumberOfUses = 1;
plusX.UntilCardLeavesPlay(base.TurnTaker.FindCard("MomentumCharacter"));
IEnumerator increaseCoroutine = base.AddStatusEffect(plusX);
if (base.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(increaseCoroutine));
}
else
{
this.GameController.ExhaustCoroutine(increaseCoroutine);
}
// "... and 1 hero target regains 1 HP."
IEnumerator heroHealCoroutine = base.GameController.SelectAndGainHP(this.DecisionMaker, 1, additionalCriteria: (Card c) => c.IsHero && c.IsTarget && c.IsInPlayAndNotUnderCard, numberOfTargets: 1, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(heroHealCoroutine));
}
else
{
this.GameController.ExhaustCoroutine(heroHealCoroutine);
}
}
}
// "{Breakaway} regains X HP, where X = 3 plus the number of non-character hero cards in play."
int hpAmount = FindCardsWhere((Card c) => c.IsInPlay && c.IsHero && !c.IsCharacter).Count() + 3;
IEnumerator hpGainCoroutine = base.GameController.GainHP(base.TurnTaker.FindCard("BreakawayCharacter"), hpAmount, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(hpGainCoroutine));
}
else
{
this.GameController.ExhaustCoroutine(hpGainCoroutine);
}
yield break;
}
public override IEnumerator UseIncapacitatedAbility(int index)
{
IEnumerator coroutine;
switch (index)
{
case 0:
{
//"One player may draw a card now.",
coroutine = GameController.SelectHeroToDrawCard(DecisionMaker, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
case 1:
{
//"Reveal the top card of the villain deck, then replace it.",
coroutine = RevealTopCardOfVillainDeck();
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
case 2:
{
//"Select a target..."
var storedResults = new List <SelectCardDecision> {
};
coroutine = GameController.SelectCardAndStoreResults(DecisionMaker, SelectionType.IncreaseNextDamage, new LinqCardCriteria((Card c) => c.IsInPlayAndHasGameText && c.IsTarget), storedResults, false, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
if (DidSelectCard(storedResults))
{
//"...increase the next damage dealt to and by that target by 2."
var target = storedResults.FirstOrDefault().SelectedCard;
IncreaseDamageStatusEffect fromTarget = new IncreaseDamageStatusEffect(2);
fromTarget.SourceCriteria.IsSpecificCard = target;
fromTarget.UntilCardLeavesPlay(target);
fromTarget.NumberOfUses = 1;
IncreaseDamageStatusEffect toTarget = new IncreaseDamageStatusEffect(2);
toTarget.TargetCriteria.IsSpecificCard = target;
toTarget.UntilCardLeavesPlay(target);
toTarget.NumberOfUses = 1;
coroutine = AddStatusEffect(fromTarget);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
coroutine = AddStatusEffect(toTarget);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
break;
}
}
yield break;
}
private IEnumerator EndOfTurnResponse(PhaseChangeAction p)
{
var storedYesNo = new List <YesNoCardDecision>();
IEnumerator coroutine = base.GameController.MakeYesNoCardDecision(base.HeroTurnTakerController, SelectionType.IncreaseDamage, this.Card, p, storedYesNo, null, base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
if (DidPlayerAnswerYes(storedYesNo))
{
List <Card> selectedTargets = new List <Card>();
int X = 0;
while (X < 2)
{
List <SelectCardDecision> storedResults = new List <SelectCardDecision>();
IEnumerator chooseHeroTarget = base.GameController.SelectCardAndStoreResults(this.DecisionMaker, SelectionType.SelectTargetFriendly, new LinqCardCriteria((Card c) => c.IsInPlayAndHasGameText && c.IsTarget && !selectedTargets.Contains(c) && c != base.HeroTurnTaker.CharacterCard, "hero targets in play", false, false, null, null, false), storedResults, true, false, null, true, base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(chooseHeroTarget));
}
else
{
base.GameController.ExhaustCoroutine(chooseHeroTarget);
}
Card selectedCard = base.GetSelectedCard(storedResults);
if (selectedCard == null)
{
break;
}
selectedTargets.Add(selectedCard);
IncreaseDamageStatusEffect increaseDamageStatusEffect = new IncreaseDamageStatusEffect(1);
increaseDamageStatusEffect.SourceCriteria.IsSpecificCard = selectedCard;
increaseDamageStatusEffect.UntilCardLeavesPlay(selectedCard);
increaseDamageStatusEffect.NumberOfUses = 1;
coroutine = base.AddStatusEffect(increaseDamageStatusEffect, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
storedResults = null;
X++;
}
if (selectedTargets != null)
{
ReduceDamageStatusEffect reduceDamageStatusEffect = new ReduceDamageStatusEffect(1);
reduceDamageStatusEffect.SourceCriteria.IsSpecificCard = this.HeroTurnTaker.CharacterCard;
reduceDamageStatusEffect.UntilCardLeavesPlay(this.HeroTurnTaker.CharacterCard);
reduceDamageStatusEffect.NumberOfUses = 1;
coroutine = base.AddStatusEffect(reduceDamageStatusEffect, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
}
yield break;
}
public override IEnumerator UseIncapacitatedAbility(int index)
{
switch (index)
{
case 0:
{
List <SelectCardDecision> storedResults = new List <SelectCardDecision>();
IEnumerator coroutine2 = base.GameController.SelectCardAndStoreResults(this.DecisionMaker, SelectionType.SelectTargetNoDamage, new LinqCardCriteria((Card c) => c.IsTarget && c.IsInPlay, "target", true, false, null, null, false), storedResults, false, false, null, true, base.GetCardSource(null));
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine2));
}
else
{
base.GameController.ExhaustCoroutine(coroutine2);
}
SelectCardDecision selectCardDecision = storedResults.FirstOrDefault <SelectCardDecision>();
Card selectedCard = base.GetSelectedCard(storedResults);
ReduceDamageStatusEffect reduceDamageStatusEffect = new ReduceDamageStatusEffect(1);
reduceDamageStatusEffect.SourceCriteria.IsSpecificCard = selectedCard;
reduceDamageStatusEffect.UntilStartOfNextTurn(base.TurnTaker);
reduceDamageStatusEffect.UntilCardLeavesPlay(selectedCard);
coroutine2 = base.AddStatusEffect(reduceDamageStatusEffect, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine2));
}
else
{
base.GameController.ExhaustCoroutine(coroutine2);
}
break;
}
case 1:
{
List <SelectCardDecision> storedResults = new List <SelectCardDecision>();
IEnumerator coroutine2 = base.GameController.SelectCardAndStoreResults(this.DecisionMaker, SelectionType.SelectTargetNoDamage, new LinqCardCriteria((Card c) => c.IsTarget && c.IsInPlay, "target", true, false, null, null, false), storedResults, false, false, null, true, base.GetCardSource(null));
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine2));
}
else
{
base.GameController.ExhaustCoroutine(coroutine2);
}
Card selectedCard = base.GetSelectedCard(storedResults);
IncreaseDamageStatusEffect increaseDamageStatusEffect = new IncreaseDamageStatusEffect(1);
increaseDamageStatusEffect.SourceCriteria.IsSpecificCard = selectedCard;
increaseDamageStatusEffect.UntilStartOfNextTurn(base.TurnTaker);
increaseDamageStatusEffect.UntilCardLeavesPlay(selectedCard);
coroutine2 = base.AddStatusEffect(increaseDamageStatusEffect, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine2));
}
else
{
base.GameController.ExhaustCoroutine(coroutine2);
}
break;
}
case 2:
{
IEnumerator coroutine = base.GameController.SelectHeroToDrawCard(base.HeroTurnTakerController, false, true, false, null, null, null, base.GetCardSource(null));
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
}
}