public override IEnumerator UsePower(int index = 0)
{
//"Draw a card. Increase damage dealt by hero targets by 1 until the end of the turn."
int increase = GetPowerNumeral(0, 1);
var coroutine = DrawCard();
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
var effect = new IncreaseDamageStatusEffect(increase);
effect.SourceCriteria.IsHero = true;
effect.SourceCriteria.IsTarget = true;
effect.CardSource = Card;
effect.UntilThisTurnIsOver(Game);
coroutine = AddStatusEffect(effect);
if (base.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;
}
public override IEnumerator Play()
{
// Increase the next damage dealt by {TangoOne} by 3
var effect = new IncreaseDamageStatusEffect(DamageIncrease);
effect.SourceCriteria.IsSpecificCard = base.CharacterCard;
effect.CardSource = Card;
effect.Identifier = IncreaseDamageIdentifier;
effect.NumberOfUses = 1;
IEnumerator increaseDamageRoutine = base.AddStatusEffect(effect, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(increaseDamageRoutine));
}
else
{
base.GameController.ExhaustCoroutine(increaseDamageRoutine);
}
// Play a card
IEnumerator playCardRoutine = base.SelectAndPlayCardFromHand(DecisionMaker, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(playCardRoutine));
}
else
{
base.GameController.ExhaustCoroutine(playCardRoutine);
}
}
private IEnumerator FirstTimeDealDamageResponse(DealDamageAction action)
{
base.SetCardPropertyToTrueIfRealAction(FirstTimeDealDamage);
//Increase damage dealt to Obstacles by 1 by the first hero target damaged by {Phase} each round.
//...by 1...
IncreaseDamageStatusEffect statusEffect = new IncreaseDamageStatusEffect(1);
//...by the first hero target damaged by {Phase}...
statusEffect.SourceCriteria.IsSpecificCard = action.Target;
//...dealt to Obstacles...
statusEffect.TargetCriteria.HasAnyOfTheseKeywords = new List <string>()
{
"obstacle"
};
//...each round.
statusEffect.UntilStartOfNextTurn(base.TurnTaker);
IEnumerator coroutine = base.AddStatusEffect(statusEffect);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
public override IEnumerator UsePower(int index = 0)
{
// Draw a card
IEnumerator drawCardRoutine = base.DrawCard(this.HeroTurnTaker);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(drawCardRoutine));
}
else
{
base.GameController.ExhaustCoroutine(drawCardRoutine);
}
// Increase the next damage dealt by {TangoOne} by 2
int powerNumeral = GetPowerNumeral(0, DamageIncrease);
var effect = new IncreaseDamageStatusEffect(powerNumeral);
effect.SourceCriteria.IsSpecificCard = base.CharacterCard;
effect.CardSource = Card;
effect.Identifier = IncreaseDamageIdentifier;
effect.NumberOfUses = 1;
IEnumerator increaseDamageRoutine = base.AddStatusEffect(effect, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(increaseDamageRoutine));
}
else
{
base.GameController.ExhaustCoroutine(increaseDamageRoutine);
}
}
public override IEnumerator ActivateAbility(string abilityKey)
{
if (abilityKey == "enact")
{
List <SelectCardDecision> storedResults = new List <SelectCardDecision>();
var select = this.GameController.SelectCardAndStoreResults(DecisionMaker, SelectionType.IncreaseDamage, ArkHiveAndTheSparesCards, storedResults, false, true, cardSource: GetCardSource());
if (UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(select));
}
else
{
this.GameController.ExhaustCoroutine(select);
}
IncreaseDamageStatusEffect idse = new IncreaseDamageStatusEffect(2);
idse.NumberOfUses = 1;
idse.SourceCriteria.IsSpecificCard = GetSelectedCard(storedResults);
var effect = AddStatusEffect(idse);
if (UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(effect));
}
else
{
this.GameController.ExhaustCoroutine(effect);
}
}
}
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);
}
}
}
protected void AddIncreaseDamageOfDamageTypeTrigger(HeroTurnTakerController httc, DamageType damageType, int amount)
{
IncreaseDamageStatusEffect increaseDamageStatusEffect = new IncreaseDamageStatusEffect(amount);
increaseDamageStatusEffect.DamageTypeCriteria.AddType(damageType);
increaseDamageStatusEffect.NumberOfUses = 1;
this.RunCoroutine(this.GameController.AddStatusEffect(increaseDamageStatusEffect, true, new CardSource(httc.CharacterCardController)));
}
public override IEnumerator UseIncapacitatedAbility(int index)
{
IEnumerator coroutine;
switch (index)
{
case 0:
{
//One player may use a power now.
coroutine = base.GameController.SelectHeroToUsePower(base.HeroTurnTakerController, cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
case 1:
{
//One player may play a card now.
coroutine = base.SelectHeroToPlayCard(this.HeroTurnTakerController);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
case 2:
{
//Increase the next damage dealt by a hero target by 1.
IncreaseDamageStatusEffect statusEffect = new IncreaseDamageStatusEffect(1)
{
NumberOfUses = 1,
SourceCriteria = { IsHero = true }
};
coroutine = base.AddStatusEffect(statusEffect);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
}
}
public override IEnumerator Play()
{
//Find the hero with the most cards in hand
List <TurnTaker> storedResults = new List <TurnTaker>();
IEnumerator coroutine = base.FindHeroWithMostCardsInHand(storedResults, 1, 1, null, null, false, false);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
TurnTaker turnTaker = storedResults.FirstOrDefault <TurnTaker>();
if (turnTaker != null)
{
//Anathema deals the Hero target with the most cards in hand {H-1} melee damage.
HeroTurnTakerController hero = base.FindHeroTurnTakerController(turnTaker as HeroTurnTaker);
IEnumerator coroutine2 = base.DealDamage(base.CharacterCard, hero.CharacterCard, base.H - 1, DamageType.Melee, false, false, false, null, null, null, false, base.GetCardSource(null));
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine2));
}
else
{
base.GameController.ExhaustCoroutine(coroutine2);
}
}
//Until the start of the next Villain Turn, increase damage dealt by Villain targets by 1 and reduce damage dealt to Villain targets by 1.
ReduceDamageStatusEffect reduceDamageStatusEffect = new ReduceDamageStatusEffect(1);
reduceDamageStatusEffect.TargetCriteria.IsVillain = true;;
reduceDamageStatusEffect.UntilStartOfNextTurn(this.TurnTaker);
IEnumerator reduceCoroutine = this.AddStatusEffect(reduceDamageStatusEffect, true);
IncreaseDamageStatusEffect increaseDamageStatusEffect = new IncreaseDamageStatusEffect(1);
increaseDamageStatusEffect.SourceCriteria.IsVillain = true;;
increaseDamageStatusEffect.UntilStartOfNextTurn(this.TurnTaker);
IEnumerator increaseCoroutine = this.AddStatusEffect(increaseDamageStatusEffect, true);
if (this.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(reduceCoroutine));
yield return(this.GameController.StartCoroutine(increaseCoroutine));
}
else
{
this.GameController.ExhaustCoroutine(reduceCoroutine);
this.GameController.ExhaustCoroutine(increaseCoroutine);
}
yield break;
}
public override IEnumerator UseIncapacitatedAbility(int index)
{
switch (index)
{
case 0:
{
//One player may play a card now.
IEnumerator coroutine = base.SelectHeroToPlayCard(base.HeroTurnTakerController, false, true, false, null, null, null, false, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
case 1:
{
//Destroy 1 ongoing card.
IEnumerator coroutine2 = base.GameController.SelectAndDestroyCard(base.HeroTurnTakerController, new LinqCardCriteria((Card c) => c.IsOngoing, "ongoing", true, false, null, null, false), false, null, null, base.GetCardSource(null));
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine2));
}
else
{
base.GameController.ExhaustCoroutine(coroutine2);
}
break;
}
case 2:
{
//Until the start of your next turn increase melee damage dealt by hero targets by 1.
IncreaseDamageStatusEffect increaseDamageStatusEffect = new IncreaseDamageStatusEffect(1);
increaseDamageStatusEffect.SourceCriteria.IsHero = new bool?(true);
//increaseDamageStatusEffect.DamageTypeCriteria.invertTypes = true;
increaseDamageStatusEffect.DamageTypeCriteria.AddType(DamageType.Melee);
increaseDamageStatusEffect.UntilStartOfNextTurn(base.TurnTaker);
IEnumerator coroutine3 = base.AddStatusEffect(increaseDamageStatusEffect, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine3));
}
else
{
base.GameController.ExhaustCoroutine(coroutine3);
}
break;
}
}
yield break;
}
public override IEnumerator UseIncapacitatedAbility(int index)
{
switch (index)
{
case 0:
{
//Increase Damage dealt by Environment Cards to Villain Targets by 1 until the Start of your next turn
IncreaseDamageStatusEffect effect = new IncreaseDamageStatusEffect(1);
effect.SourceCriteria.IsEnvironment = true;
effect.TargetCriteria.IsVillain = true;
effect.UntilStartOfNextTurn(TurnTaker);
IEnumerator coroutine = AddStatusEffect(effect);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
case 1:
{
//2 Players may Draw a Card.
IEnumerator coroutine = TwoPlayersMayDrawACard();
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
case 2:
{
//One Hero may Play a Card.
IEnumerator coroutine = SelectHeroToPlayCard(DecisionMaker);
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 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:
{
//"Increase all damage by 1 until the start of your next turn.",
IncreaseDamageStatusEffect globalBoost = new IncreaseDamageStatusEffect(1);
globalBoost.UntilStartOfNextTurn(this.TurnTaker);
coroutine = GameController.AddStatusEffect(globalBoost, true, GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
case 2:
{
//"One target deals itself 1 psychic damage."
coroutine = GameController.SelectTargetsToDealDamageToSelf(DecisionMaker, 1, DamageType.Psychic, 1, false, 1, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
}
yield break;
}
private IEnumerator IncreaseDamageStatusEffectResponse()
{
var effect = new IncreaseDamageStatusEffect(2);
effect.SourceCriteria.IsVillain = true;
effect.SourceCriteria.IsTarget = true;
effect.UntilEndOfNextTurn(TurnTaker);
effect.CardSource = Card;
return(AddStatusEffect(effect));
}
public override IEnumerator UseIncapacitatedAbility(int index)
{
switch (index)
{
case 0:
{
//Destroy a Device
var rend = this.GameController.SelectAndDestroyCard(HeroTurnTakerController, new LinqCardCriteria(c => c.IsDevice), false, cardSource: GetCardSource());
if (UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(rend));
}
else
{
this.GameController.ExhaustCoroutine(rend);
}
break;
}
case 1:
{
//One Hero may Use a Power now
var pow = this.GameController.SelectHeroToUsePower(HeroTurnTakerController, cardSource: GetCardSource());
if (UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(pow));
}
else
{
this.GameController.ExhaustCoroutine(pow);
}
break;
}
case 2:
{
//Increase Hero Damage by 1 until the start of your next turn
IncreaseDamageStatusEffect idse = new IncreaseDamageStatusEffect(1);
idse.SourceCriteria.IsHero = true;
idse.UntilStartOfNextTurn(TurnTaker);
var bold = AddStatusEffect(idse);
if (UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(bold));
}
else
{
this.GameController.ExhaustCoroutine(bold);
}
break;
}
}
}
public override IEnumerator UseIncapacitatedAbility(int index)
{
switch (index)
{
case 0:
{
var rend = this.GameController.SelectAndDestroyCard(HeroTurnTakerController, new LinqCardCriteria(c => c.DoKeywordsContain("device") || c.DoKeywordsContain("ongoing")), true, cardSource: GetCardSource());
if (UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(rend));
}
else
{
this.GameController.ExhaustCoroutine(rend);
}
break;
}
case 1:
{
IncreaseDamageStatusEffect idse = new IncreaseDamageStatusEffect(1);
idse.SourceCriteria.IsHero = true;
idse.UntilStartOfNextTurn(TurnTaker);
var inspire = AddStatusEffect(idse);
if (UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(inspire));
}
else
{
this.GameController.ExhaustCoroutine(inspire);
}
break;
}
case 2:
{
var draw = this.GameController.SelectHeroToDrawCard(HeroTurnTakerController, numberOfCards: 1, cardSource: GetCardSource());
if (UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(draw));
}
else
{
this.GameController.ExhaustCoroutine(draw);
}
break;
}
}
}
public override IEnumerator Play()
{
//"Search your deck for a Single Hand Equipment card and put it into play. Shuffle your deck.",
//"Select a hero target. Until the start of your next turn, increase damage dealt by that target by 1."
var criteria = new LinqCardCriteria(c => IsEquipment(c) && IsSingleHandCard(c), "single hand equipment");
var coroutine = base.SearchForCards(this.DecisionMaker, true, false, 1, 1, criteria, true, false, false, shuffleAfterwards: true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
var storedResult = new List <SelectCardDecision>();
criteria = new LinqCardCriteria(c => c.IsHero && c.IsTarget && c.IsInPlayAndHasGameText, "hero target");
coroutine = base.GameController.SelectCardAndStoreResults(this.DecisionMaker, SelectionType.IncreaseDamage, criteria, storedResult, false, cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
if (DidSelectCard(storedResult))
{
Card card = GetSelectedCard(storedResult);
IncreaseDamageStatusEffect increaseDamageStatusEffect = new IncreaseDamageStatusEffect(1);
increaseDamageStatusEffect.SourceCriteria.IsSpecificCard = card;
increaseDamageStatusEffect.UntilStartOfNextTurn(base.TurnTaker);
increaseDamageStatusEffect.UntilTargetLeavesPlay(card);
coroutine = base.AddStatusEffect(increaseDamageStatusEffect, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
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 DealDamageResponseAndIncreaseDamageTaken(int X)
{
if (X > 0)
{
List <SelectDamageTypeDecision> storedResults = new List <SelectDamageTypeDecision>();
IEnumerator chooseDamageType = base.GameController.SelectDamageType(base.HeroTurnTakerController, storedResults, new DamageType[]
{
DamageType.Fire,
DamageType.Cold
}, null, SelectionType.DamageType, base.GetCardSource(null));
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(chooseDamageType));
}
else
{
base.GameController.ExhaustCoroutine(chooseDamageType);
}
DamageType value = storedResults.First((SelectDamageTypeDecision d) => d.Completed).SelectedDamageType.Value;
IEnumerator dealAuraDamage = base.GameController.SelectTargetsAndDealDamage(this.DecisionMaker, new DamageSource(base.GameController, base.CharacterCard), 6, value, new int?(X), false, new int?(0), false, false, false, null, null, null, null, null, false, null, null, false, null, base.GetCardSource(null));
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(dealAuraDamage));
}
else
{
base.GameController.ExhaustCoroutine(dealAuraDamage);
}
IncreaseDamageStatusEffect increaseDamageStatusEffect = new IncreaseDamageStatusEffect(X);
increaseDamageStatusEffect.TargetCriteria.IsSpecificCard = base.CharacterCard;
increaseDamageStatusEffect.UntilStartOfNextTurn(base.TurnTaker);
IEnumerator increaseDamageTaken = base.AddStatusEffect(increaseDamageStatusEffect, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(increaseDamageTaken));
}
else
{
base.GameController.ExhaustCoroutine(increaseDamageTaken);
}
yield break;
}
else
{
yield break;
}
}
protected override IEnumerator Effect(Card c)
{
IncreaseDamageStatusEffect idse = new IncreaseDamageStatusEffect(1);
idse.SourceCriteria.IsSpecificCard = c;
idse.NumberOfUses = 1;
var effect = AddStatusEffect(idse);
if (UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(effect));
}
else
{
this.GameController.ExhaustCoroutine(effect);
}
}
public override IEnumerator Play()
{
if (!FindCard("PaleMoonPendant").IsInPlay)
{
var search = this.GameController.PlayCard(TurnTakerController, FindCard("PaleMoonPendant"), true, null, false, evenIfAlreadyInPlay: false, associateCardSource: true, cardSource: GetCardSource());
//var search = SearchForCards(HeroTurnTakerController, true, true, 1, 1, new LinqCardCriteria(FindCard("PaleMoonPendant")), true, false, false);
if (UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(search));
}
else
{
this.GameController.ExhaustCoroutine(search);
}
}
if (ShouldActivate("human"))
{
var heal = this.GameController.GainHP(CharacterCard, 2, cardSource: GetCardSource());
if (UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(heal));
}
else
{
this.GameController.ExhaustCoroutine(heal);
}
}
if (ShouldActivate("wolf"))
{
IncreaseDamageStatusEffect boost = new IncreaseDamageStatusEffect(1);
boost.SourceCriteria.IsSpecificCard = CharacterCard;
boost.SourceCriteria.HasIdentifierOfSpecifiedCard = true;
boost.NumberOfUses = 1;
boost.TargetCriteria.IsHero = false;
var effect = AddStatusEffect(boost);
if (UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(effect));
}
else
{
this.GameController.ExhaustCoroutine(effect);
}
}
}
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);
}
}
private IEnumerator IncreaseNextDamageResponse(DealDamageAction dd)
{
base.SetCardPropertyToTrueIfRealAction("BlitzDealtEnoughDamage", null);
IncreaseDamageStatusEffect idse = new IncreaseDamageStatusEffect(1);
idse.SourceCriteria.IsSpecificCard = this.Card;
idse.NumberOfUses = 1;
IEnumerator coroutine = base.AddStatusEffect(idse, 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 AddSummerResponse()
{
//Increase fire damage dealt by heroes by 2
IncreaseDamageStatusEffect effect = new IncreaseDamageStatusEffect(2);
effect.SourceCriteria.IsHeroCharacterCard = true;
effect.DamageTypeCriteria.AddType(DamageType.Fire);
effect.UntilStartOfNextTurn(base.TurnTaker);
IEnumerator coroutine = AddStatusEffect(effect);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
private IEnumerator AddStatusEffectResponse(DealDamageAction dd)
{
IncreaseDamageStatusEffect increaseDamageStatusEffect = new IncreaseDamageStatusEffect(1);
increaseDamageStatusEffect.SourceCriteria.IsSpecificCard = this.CharacterCard;
increaseDamageStatusEffect.TargetCriteria.IsSpecificCard = dd.DamageSource.Card;
increaseDamageStatusEffect.NumberOfUses = 1;
IEnumerator coroutine = AddStatusEffect(increaseDamageStatusEffect);
if (UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(coroutine));
}
else
{
this.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
public IEnumerator IncreaseDamageResponse(PhaseChangeAction _, OnPhaseChangeStatusEffect sourceEffect)
{
int increaseNumeral = sourceEffect.PowerNumeralsToChange[0];
IncreaseDamageStatusEffect statusEffect = new IncreaseDamageStatusEffect(increaseNumeral);
statusEffect.UntilThisTurnIsOver(Game);
statusEffect.UntilTargetLeavesPlay(base.CharacterCard);
IEnumerator coroutine = base.AddStatusEffect(statusEffect);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
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 IncreaseDamageFromEffectResponse(AddStatusEffectAction se, int increaseAmount, Power power)
{
IncreaseDamageStatusEffect increaseDamageStatusEffect = new IncreaseDamageStatusEffect(increaseAmount);
increaseDamageStatusEffect.StatusEffectCriteria.Effect = se.StatusEffect;
if (power != null && power.CardController != null)
{
increaseDamageStatusEffect.StatusEffectCriteria.CardWithPower = power.CardController.Card;
}
IEnumerator coroutine = AddStatusEffect(increaseDamageStatusEffect);
if (UseUnityCoroutines)
{
yield return(GameController.StartCoroutine(coroutine));
}
else
{
GameController.ExhaustCoroutine(coroutine);
}
}
