private IEnumerator GrowHeadAction(SelectCardDecision decision)
{
int HP = Game.H * 2;
if (Game.IsAdvanced && base.FindCardsWhere(new LinqCardCriteria((Card c) => c.DoKeywordsContain("head") && c.IsVillainCharacterCard && c.IsInPlayAndNotUnderCard)).Count <Card>() > 3)
{
//Every Instruction card has this as its Advanced Flipped Game Text, if there are ever more than 3 heads in play then one of the instructions are flipped
//Decapitated heads are restored to 3 times {H} HP when they become active.
HP = Game.H * 3;
}
//...flip 1 decapitated head to its active side...
IEnumerator coroutine = base.GameController.FlipCard(base.FindCardController(decision.SelectedCard), cardSource: base.GetCardSource());;
//...and restore it to 2 times {H} HP.
IEnumerator coroutine2 = base.GameController.MakeTargettable(decision.SelectedCard, 15, HP, base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
yield return(base.GameController.StartCoroutine(coroutine2));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
base.GameController.ExhaustCoroutine(coroutine2);
};
yield break;
}
protected IEnumerator SelectOwnCharacterCard(List <SelectCardDecision> results, SelectionType selectionType)
{
if (base.HeroTurnTakerController.HasMultipleCharacterCards)
{
LinqCardCriteria criteria = new LinqCardCriteria(IsOwnCharacterCard, "hero character cards");
var routine = base.GameController.SelectCardAndStoreResults(this.DecisionMaker, selectionType,
criteria, results, false, cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(routine));
}
else
{
base.GameController.ExhaustCoroutine(routine);
}
}
else
{
var result = new SelectCardDecision(this.GameController, this.DecisionMaker, selectionType,
new[] { base.CharacterCard }, false, true, cardSource: base.GetCardSource());
result.ChooseIndex(0);
result.AutoDecide();
results.Add(result);
}
yield break;
}
private IEnumerator MakeIrreducibleNextTurn(SelectCardDecision scd)
{
if (scd.SelectedCard != null)
{
var card = scd.SelectedCard;
var holderEffect = IrreducibleNextTurnHolder(card);
holderEffect.UntilCardLeavesPlay(card);
holderEffect.CanEffectStack = true;
holderEffect.TurnPhaseCriteria.IsEphemeral = false;
holderEffect.TurnTakerCriteria.IsSpecificTurnTaker = card.Owner;
holderEffect.NumberOfUses = 1;
holderEffect.BeforeOrAfter = BeforeOrAfter.After;
holderEffect.CardSource = CharacterCard;
GameController.AddCardPropertyJournalEntry(card, renegadeKey, true);
IEnumerator coroutine = GameController.AddStatusEffect(holderEffect, true, GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
yield break;
}
private IEnumerator UseIncapOption1()
{
// "Select a target. Reduce the next damage dealt to that target by 2."
List <SelectCardDecision> choices = new List <SelectCardDecision>();
IEnumerator chooseCoroutine = base.GameController.SelectCardAndStoreResults(base.HeroTurnTakerController, SelectionType.ReduceNextDamageTaken, new LinqCardCriteria((Card c) => c.IsInPlay && c.IsTarget, "target", useCardsSuffix: false), choices, false, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(chooseCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(chooseCoroutine);
}
SelectCardDecision choice = choices.FirstOrDefault();
if (choice != null && choice.SelectedCard != null)
{
ReduceDamageStatusEffect protectEffect = new ReduceDamageStatusEffect(2);
protectEffect.NumberOfUses = 1;
protectEffect.TargetCriteria.IsSpecificCard = choice.SelectedCard;
IEnumerator statusCoroutine = base.GameController.AddStatusEffect(protectEffect, true, GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(statusCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(statusCoroutine);
}
}
yield break;
}
private IEnumerator DiscardAndDealDamage(SelectCardDecision scd)
{
int targets2 = GetPowerNumeral(3, 1);
int damages2 = GetPowerNumeral(4, 1);
if (scd.SelectedCard != null)
{
List <DiscardCardAction> result = new List <DiscardCardAction>();
var coroutine = GameController.DiscardCard(scd.HeroTurnTakerController, scd.SelectedCard, new IDecision[] { scd }, storedResults: result, cardSource: scd.CardSource);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
if (DidDiscardCards(result, 1))
{
var damageSource = new DamageSource(GameController, CharacterCard);
coroutine = GameController.SelectTargetsAndDealDamage(scd.HeroTurnTakerController, damageSource, damages2, DamageType.Energy, targets2, false, targets2, cardSource: scd.CardSource);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
}
}
public IEnumerator SelectAndMoveCardOptional(HeroTurnTakerController hero, Func <Card, bool> criteria, Location toLocation, bool toBottom = false, bool optional = false, bool isPutIntoPlay = false, bool playIfMovingToPlayArea = true, List <SelectCardDecision> storedResults = null, CardSource cardSource = null)
{
BattleZone battleZone = null;
if (cardSource != null)
{
battleZone = cardSource.BattleZone;
}
SelectCardDecision selectCardDecision = new SelectCardDecision(this.GameController, hero, SelectionType.MoveCard, this.GameController.FindCardsWhere(criteria, true, null, battleZone), optional, false, null, null, null, null, null, false, true, cardSource, null);
selectCardDecision.BattleZone = battleZone;
if (storedResults != null)
{
storedResults.Add(selectCardDecision);
}
IEnumerator coroutine = this.GameController.SelectCardAndDoAction(selectCardDecision, (SelectCardDecision d) => this.GameController.MoveCard(hero, d.SelectedCard, toLocation, toBottom, isPutIntoPlay, playIfMovingToPlayArea, null, false, null, null, null, false, false, null, false, false, false, false, cardSource), true);
if (this.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(coroutine));
}
else
{
this.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
private IEnumerator ShufflePairIntoDeckResponse(SelectCardDecision decision)
{
List <SelectCardDecision> storedResults = new List <SelectCardDecision>();
//Pick second card
IEnumerator coroutine = base.GameController.SelectCardAndStoreResults(base.HeroTurnTakerController, SelectionType.ShuffleCardIntoDeck, new LinqCardCriteria((Card c) => c.Identifier == decision.SelectedCard.Identifier && c.InstanceIndex != decision.SelectedCard.InstanceIndex && c.IsInTrash, "two cards with the same name"), storedResults, false);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
//Actually shuffle cards into deck
coroutine = base.GameController.ShuffleCardsIntoLocation(base.HeroTurnTakerController, new Card[] { decision.SelectedCard, storedResults.FirstOrDefault().SelectedCard }, base.TurnTaker.Deck, false, cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
X++;
yield break;
}
public override IEnumerator Play()
{
// You may move 1 Augment in play next to a new hero.
SelectCardDecision scd = new SelectCardDecision(GameController, DecisionMaker,
SelectionType.MoveCardNextToCard, GetAugmentsInPlay(), true, cardSource: GetCardSource());
IEnumerator routine = base.GameController.SelectCardAndDoAction(scd, MoveAugment);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(routine));
}
else
{
base.GameController.ExhaustCoroutine(routine);
}
// One augmented hero deals 1 target 1 melee damage and draws a card now.
List <SelectCardDecision> storedHeroCard = new List <SelectCardDecision> {
};
routine = this.GameController.SelectCardAndStoreResults(DecisionMaker, SelectionType.HeroToDealDamage, base.AugmentedHeroCharacterCardCriteria(c => c.IsInPlayAndHasGameText), storedHeroCard, false, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(routine));
}
else
{
base.GameController.ExhaustCoroutine(routine);
}
if (!DidSelectCard(storedHeroCard))
{
yield break;
}
var selectedHero = storedHeroCard.FirstOrDefault().SelectedCard;
var heroController = FindHeroTurnTakerController(selectedHero.Owner.ToHero());
routine = base.GameController.SelectTargetsAndDealDamage(heroController,
new DamageSource(base.GameController, selectedHero), DamageToDeal, DamageType.Melee, 1,
false, 1, cardSource: GetCardSource());
IEnumerator routine2 = base.GameController.DrawCard(heroController.HeroTurnTaker, false,
cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(routine));
yield return(base.GameController.StartCoroutine(routine2));
}
else
{
base.GameController.ExhaustCoroutine(routine);
base.GameController.ExhaustCoroutine(routine2);
}
}
public override IEnumerator Play()
{
MoveCardDestination turnTakerDeck = new MoveCardDestination(base.TurnTaker.Deck, true);
MoveCardDestination turnTakerPlayArea = new MoveCardDestination(base.TurnTaker.PlayArea, true);
List <SelectCardDecision> storedResults = new List <SelectCardDecision>();
//You may shuffle a card from your trash into your deck...
IEnumerator coroutine = base.GameController.SelectCardFromLocationAndMoveIt(this.DecisionMaker, base.TurnTaker.Trash, new LinqCardCriteria((Card c) => c.IsInTrash), turnTakerDeck.ToEnumerable <MoveCardDestination>(), false, true, true, true, storedResults, showOutput: true, allowAutoDecide: true, cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
SelectCardDecision selectCardDecision = storedResults.FirstOrDefault <SelectCardDecision>();
LinqCardCriteria cardCriteria = new LinqCardCriteria((Card c) => c.Identifier == selectCardDecision.SelectedCard.Identifier, "card with the same name", false);
//...If you do...
if (selectCardDecision != null && selectCardDecision.SelectedCard != null)
{
//...put a card with the same name from your trash into play.
IEnumerable <Card> list = FindCardsWhere(new LinqCardCriteria((Card c) => c.Identifier == selectCardDecision.SelectedCard.Identifier && c.IsInTrash, "card with the same name", false));
coroutine = base.GameController.PlayCard(this.TurnTakerController, list.FirstOrDefault(), responsibleTurnTaker: this.TurnTaker, cardSource: base.GetCardSource(null));
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
//Shuffle all copies of that card from your trash into your deck.
coroutine = base.GameController.SelectCardsFromLocationAndMoveThem(this.HeroTurnTakerController, base.TurnTaker.Trash, list.Count <Card>(), this.TurnTaker.Trash.NumberOfCards, cardCriteria, turnTakerDeck.ToEnumerable <MoveCardDestination>(), responsibleTurnTaker: this.TurnTaker, selectionType: SelectionType.MoveCardOnDeck, cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
//actually shuffle deck
coroutine = base.GameController.ShuffleLocation(this.TurnTaker.Deck);
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:
{
//Select a card in a trash. Destroy a card in play with the same name.
SelectCardDecision selectDecision = new SelectCardDecision(GameController, base.HeroTurnTakerController, SelectionType.DestroyCard, base.FindCardsWhere(new LinqCardCriteria((Card c) => c.IsInTrash)), cardSource: base.GetCardSource());
IEnumerator coroutine = base.GameController.SelectCardAndDoAction(selectDecision, (SelectCardDecision decision) => base.GameController.SelectAndDestroyCard(base.HeroTurnTakerController, new LinqCardCriteria((Card c) => decision.SelectedCard.Identifier == c.Identifier && c.IsInPlayAndHasGameText, "selected card"), false, cardSource: base.GetCardSource()));
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
case 1:
{
//One target deals itself 1 energy damage.
SelectCardDecision selectDecision = new SelectCardDecision(GameController, base.HeroTurnTakerController, SelectionType.DealDamage, base.FindCardsWhere(new LinqCardCriteria((Card c) => c.IsTarget)), cardSource: base.GetCardSource());
IEnumerator coroutine2 = base.GameController.SelectCardAndDoAction(selectDecision, (SelectCardDecision decision) => base.DealDamage(decision.SelectedCard, decision.SelectedCard, 1, DamageType.Energy, cardSource: base.GetCardSource()));
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine2));
}
else
{
base.GameController.ExhaustCoroutine(coroutine2);
}
break;
}
case 2:
{
//Each hero character may deal themselves 1 toxic damage to draw a card now.
this.actedHeroes = new List <Card>();
IEnumerable <Function> functionsBasedOnCard(Card c) => new Function[]
{
new Function(base.FindCardController(c).DecisionMaker, "Deal self 1 toxic damage to draw a card now.", SelectionType.DrawCard, () => this.DealDamageAndDrawResponse(c))
};
IEnumerator coroutine3 = 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(coroutine3));
}
else
{
base.GameController.ExhaustCoroutine(coroutine3);
}
break;
}
}
yield break;
}
private IEnumerator ShuffleTwoSameCardFromTrashOrDestroyResponse(PhaseChangeAction phaseChange)
{
MoveCardDestination obj = new MoveCardDestination(base.TurnTaker.Deck, true);
List <SelectCardDecision> storedResults = new List <SelectCardDecision>();
//...shuffle 2 cards with the same name from your trash into your deck...
IEnumerator coroutine = base.GameController.SelectCardAndStoreResults(base.HeroTurnTakerController, SelectionType.ShuffleCardIntoDeck, new LinqCardCriteria((Card c) => TwoOrMoreCopiesInTrash(c) && c.IsInTrash, "two cards with the same name"), storedResults, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
SelectCardDecision selectCardDecision = storedResults.FirstOrDefault <SelectCardDecision>();
if (selectCardDecision != null && selectCardDecision.SelectedCard != null)
{
//Move second card
coroutine = base.GameController.SelectCardAndStoreResults(base.HeroTurnTakerController, SelectionType.ShuffleCardIntoDeck, new LinqCardCriteria((Card c) => c.Identifier == selectCardDecision.SelectedCard.Identifier && c.InstanceIndex != selectCardDecision.SelectedCard.InstanceIndex && c.IsInTrash, "two cards with the same name"), storedResults, false);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
//actually shuffle cards into deck
IEnumerable <Card> cards = new Card[] { storedResults.FirstOrDefault().SelectedCard, storedResults.LastOrDefault().SelectedCard };
coroutine = base.GameController.ShuffleLocation(this.TurnTaker.Deck);
coroutine = base.GameController.ShuffleCardsIntoLocation(HeroTurnTakerController, cards, base.TurnTaker.Deck, cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}//...or this card is destroyed.
else
{
coroutine = base.GameController.DestroyCard(this.DecisionMaker, base.Card);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
yield break;
}
private IEnumerator ShuffleTwoSameCardFromTrashOrDestroyResponse(PhaseChangeAction phaseChange)
{
MoveCardDestination obj = new MoveCardDestination(base.TurnTaker.Deck, true);
List <SelectCardDecision> storedResults = new List <SelectCardDecision>();
//...shuffle 2 cards with the same name from your trash into your deck...
IEnumerator coroutine = base.GameController.SelectCardFromLocationAndMoveIt(this.DecisionMaker, base.TurnTaker.Trash, new LinqCardCriteria((Card c) => TwoOrMoreCopiesInTrash(c), "two cards with the same name"), obj.ToEnumerable <MoveCardDestination>(), false, true, true, true, storedResults, false, true, null, false, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
SelectCardDecision selectCardDecision = storedResults.FirstOrDefault <SelectCardDecision>();
LinqCardCriteria cardCriteria = new LinqCardCriteria((Card c) => c.Identifier == selectCardDecision.SelectedCard.Identifier, "card with the same name", false);
if (selectCardDecision != null && selectCardDecision.SelectedCard != null)
{
//Move second card
coroutine = base.GameController.SelectCardFromLocationAndMoveIt(this.DecisionMaker, base.TurnTaker.Trash, new LinqCardCriteria((Card c) => c.Identifier == selectCardDecision.SelectedCard.Identifier, "two cards with the same name"), obj.ToEnumerable <MoveCardDestination>(), false, true, true, true, storedResults, false, true, null, false, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
//actually shuffle deck
coroutine = base.GameController.ShuffleLocation(this.TurnTaker.Deck);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}//...or this card is destroyed.
else
{
coroutine = base.GameController.DestroyCard(this.DecisionMaker, base.Card);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
yield break;
}
private IEnumerator WasDamagedReponse(SelectCardDecision scd)
{
if (scd.SelectedCard != null)
{
return(GameController.MoveCard(scd.HeroTurnTakerController, scd.SelectedCard, scd.SelectedCard.Owner.PlayArea, isPutIntoPlay: true, showMessage: true, decisionSources: new[] { scd }, cardSource: GetCardSource()));
}
else
{
return(DoNothing());
}
}
public override IEnumerator UseIncapacitatedAbility(int index)
{
IEnumerator coroutine;
switch (index)
{
case 0:
{
//"Select a target. Damage dealt by that target is irreducible during its next turn.",
var selectTarget = new SelectCardDecision(GameController, DecisionMaker, SelectionType.SelectTargetFriendly, GameController.FindCardsWhere((Card c) => c.IsInPlayAndHasGameText && c.IsTarget, visibleToCard: GetCardSource()), cardSource: GetCardSource());
coroutine = GameController.SelectCardAndDoAction(selectTarget, MakeIrreducibleNextTurn);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
case 1:
{
//"One hero may use a power now.",
coroutine = GameController.SelectHeroToUsePower(DecisionMaker, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
case 2:
{
//"The environment deals 1 target 2 projectile damage."
coroutine = GameController.SelectTargetsAndDealDamage(DecisionMaker, new DamageSource(GameController, FindEnvironment().TurnTaker), 2, DamageType.Projectile, 1, false, 1, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
}
yield break;
}
private IEnumerator ReturnEquipmentToHand(SelectCardDecision scd)
{
IEnumerator coroutine = GameController.MoveCard(DecisionMaker, scd.SelectedCard, HeroTurnTaker.Hand, cardSource: GetCardSource());
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:
{
//One player may draw 3 cards.
{
List <DrawCardAction> storedResults = new List <DrawCardAction>();
IEnumerator coroutine = base.GameController.SelectHeroToDrawCards(base.HeroTurnTakerController, 3, true, false, null, true, null);
//If they do, they must discard 1 card.
if (base.DidDrawCards(storedResults, new int?(1)))
{
IEnumerator coroutine2 = base.GameController.SelectAndDiscardCard(HeroTurnTakerController, false, null, null, SelectionType.DiscardCard, null, null, false, null, base.GetCardSource(null));
}
}
break;
}
case 1:
{
//One hero deals 1 target 3 melee damage.
IEnumerator coroutine = base.GameController.SelectHeroToSelectTargetAndDealDamage(this.DecisionMaker, 3, DamageType.Melee, false, false, true, false, null, base.GetCardSource(null));
break;
}
case 2:
{
//Choose a Target. Reduce damage dealt by that target by 2 until the start of your turn.
List <SelectCardDecision> storedResults = new List <SelectCardDecision>();
IEnumerator coroutine = base.GameController.SelectCardAndStoreResults(this.DecisionMaker, SelectionType.SelectTargetNoDamage, new LinqCardCriteria((Card c) => c.IsInPlay && c.IsTarget, "target", false, false, null, "targets", false), storedResults, false, false, null, true, base.GetCardSource(null));
SelectCardDecision selected = storedResults.FirstOrDefault <SelectCardDecision>();
if (selected != null && selected.SelectedCard != null)
{
ReduceDamageStatusEffect reduceDamageStatusEffect = new ReduceDamageStatusEffect(1);
reduceDamageStatusEffect.SourceCriteria.IsSpecificCard = selected.SelectedCard;
reduceDamageStatusEffect.UntilStartOfNextTurn(base.TurnTaker);
reduceDamageStatusEffect.UntilTargetLeavesPlay(selected.SelectedCard);
coroutine = base.AddStatusEffect(reduceDamageStatusEffect, true);
}
break;
}
}
return(base.UseIncapacitatedAbility(index));
}
private IEnumerator DistortionDamageResponse(SelectCardDecision sc, int numberOfTargets, int damageAmount)
{
Card selectedCard = sc.SelectedCard;
this.actedDistortions.Add(selectedCard);
IEnumerator coroutine = this.GameController.SelectTargetsAndDealDamage(this.DecisionMaker, new DamageSource(this.GameController, selectedCard), (Card c) => new int?(damageAmount), DamageType.Psychic, () => numberOfTargets, false, new int?(numberOfTargets), cardSource: this.GetCardSource(null));
if (this.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(coroutine));
}
else
{
this.GameController.ExhaustCoroutine(coroutine);
}
}
private IEnumerator GrowHeadResponse(PhaseChangeAction action)
{
IEnumerable <Card> decapitatedHeads = base.FindCardsWhere(new LinqCardCriteria((Card c) => c.IsFlipped && c.DoKeywordsContain("head") && c.IsInPlayAndNotUnderCard));
SelectCardDecision cardDecision = new SelectCardDecision(this.GameController, this.DecisionMaker, SelectionType.FlipCardFaceUp, decapitatedHeads, cardSource: base.GetCardSource());
//...flip 1 decapitated head...
IEnumerator coroutine = base.GameController.SelectCardAndDoAction(cardDecision, (SelectCardDecision decision) => this.GrowHeadAction(decision));
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
};
yield break;
}
public override IEnumerator Play()
{
var scd = new SelectCardDecision(GameController, DecisionMaker, SelectionType.MoveCardOnDeck, GameController.GetAllCards(),
additionalCriteria: c => c.IsInPlay && !c.IsCharacter && !GameController.IsCardIndestructible(c) && !c.IsOneShot && GameController.IsCardVisibleToCardSource(c, GetCardSource()),
cardSource: GetCardSource());
var coroutine = GameController.SelectCardAndDoAction(scd, SelectCardResponse);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
private IEnumerator MoveToBottomOfDeck(SelectCardDecision scd)
{
if (scd.SelectedCard != null)
{
var card = scd.SelectedCard;
IEnumerator coroutine = GameController.MoveCard(DecisionMaker, card, card.NativeDeck, toBottom: true, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
yield break;
}
private IEnumerator EnvironmentDamageResponse(SelectCardDecision sc, int?damageAmount)
{
Card selectedCard = sc.SelectedCard;
this.actedEnvironments.Add(selectedCard);
IEnumerator coroutine = this.DealDamageToHighestHP(selectedCard, 1, (Card c) => c.IsVillainTarget && this.GameController.IsCardVisibleToCardSource(c, this.GetCardSource()), (Card c) => damageAmount, DamageType.Projectile);
if (this.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(coroutine));
}
else
{
this.GameController.ExhaustCoroutine(coroutine);
}
}
public override IEnumerator UsePower(int index = 0)
{
var scd = new SelectCardDecision(GameController, DecisionMaker, SelectionType.MoveCardToHand, DecisionMaker.HeroTurnTaker.PlayArea.Cards,
additionalCriteria: c => c.IsTarget && IsDjinn(c),
cardSource: GetCardSource());
var coroutine = base.GameController.SelectCardAndDoAction(scd, CompassPowerResponse);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
public override IEnumerator Play()
{
MoveCardDestination turnTakerDeck = new MoveCardDestination(base.TurnTaker.Deck, true, false, false);
MoveCardDestination turnTakerPlayArea = new MoveCardDestination(base.TurnTaker.PlayArea, true, false, false);
List <SelectCardDecision> storedResults = new List <SelectCardDecision>();
//You may shuffle a card from your trash into your deck...
IEnumerator coroutine = base.GameController.SelectCardFromLocationAndMoveIt(this.DecisionMaker, base.TurnTaker.Trash, null, turnTakerDeck.ToEnumerable <MoveCardDestination>(), false, true, true, true, storedResults, false, true, null, false, true, null, null, base.GetCardSource(null));
SelectCardDecision selectCardDecision = storedResults.FirstOrDefault <SelectCardDecision>();
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
LinqCardCriteria cardCriteria = new LinqCardCriteria((Card c) => c.Identifier == selectCardDecision.SelectedCard.Identifier, "card with the same name", true, false, null, null, false);
//...If you do...
if (selectCardDecision != null && selectCardDecision.SelectedCard != null)
{
//...put a card with the same name from your trash into play.
IEnumerator coroutine2 = base.GameController.SelectCardFromLocationAndMoveIt(this.DecisionMaker, base.TurnTaker.Trash, cardCriteria, turnTakerPlayArea.ToEnumerable <MoveCardDestination>(), true, true, true, true, storedResults, false, true, null, false, true, null, null, base.GetCardSource(null));
//Shuffle all copies of that card from your trash into your deck.
IEnumerator coroutine3 = base.GameController.SelectCardsFromLocationAndMoveThem(this.HeroTurnTakerController, base.TurnTaker.Trash, new int?(0), base.TurnTaker.Deck.NumberOfCards, cardCriteria, turnTakerDeck.ToEnumerable <MoveCardDestination>(), false, true, true, false, storedResults, null, true, false, false, this.TurnTaker, false, true, null, null, base.GetCardSource(null));
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine2));
yield return(base.GameController.StartCoroutine(coroutine3));
}
else
{
base.GameController.ExhaustCoroutine(coroutine2);
base.GameController.ExhaustCoroutine(coroutine3);
}
}
yield break;
}
private IEnumerator SelectCardResponse(SelectCardDecision scd)
{
if (scd.SelectedCard != null)
{
var card = scd.SelectedCard;
var coroutine = GameController.MoveCard(DecisionMaker, card, card.NativeDeck,
showMessage: true,
decisionSources: new IDecision[] { scd },
evenIfIndestructible: false,
cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
yield break;
}
protected IEnumerator SelectActiveCharacterCardToDealDamage(List <Card> storedResults, int?damageAmount = null, DamageType?damageType = null)
{
//future-proofing for Nightlore Council
if (IsMultiCharPromo())
{
List <SelectCardDecision> storedDecision = new List <SelectCardDecision>();
IEnumerator coroutine;
if (damageAmount == null || damageType == null)
{
coroutine = base.GameController.SelectCardAndStoreResults(this.HeroTurnTakerController, SelectionType.HeroCharacterCard, new LinqCardCriteria((Card c) => c.Owner == base.TurnTaker && c.IsCharacter && !c.IsIncapacitatedOrOutOfGame, "active Starlight"), storedDecision, optional: false, allowAutoDecide: false, includeRealCardsOnly: true, cardSource: GetCardSource());
}
else
{
DealDamageAction previewDamage = new DealDamageAction(GetCardSource(), null, null, (int)damageAmount, (DamageType)damageType);
coroutine = base.GameController.SelectCardAndStoreResults(this.HeroTurnTakerController, SelectionType.HeroToDealDamage, new LinqCardCriteria((Card c) => c.Owner == base.TurnTaker && c.IsCharacter && !c.IsIncapacitatedOrOutOfGame, "active Starlight"), storedDecision, optional: false, allowAutoDecide: false, previewDamage, includeRealCardsOnly: true, GetCardSource());
}
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
SelectCardDecision selectCardDecision = storedDecision.FirstOrDefault();
if (selectCardDecision != null)
{
storedResults.Add(selectCardDecision.SelectedCard);
}
}
else
{
storedResults.Add(TurnTaker.CharacterCard);
}
yield break;
}
private IEnumerator HeroDiscardedResponse(DiscardCardAction dca)
{
//{Screech} deals that Target 1 Irreducible Sonic Damage.
SetCardPropertyToTrueIfRealAction(FirstTimeDiscardKey);
HeroTurnTakerController httc = dca.HeroTurnTakerController;
Card target = httc.CharacterCard;
IEnumerator coroutine;
if (httc.HasMultipleCharacterCards)
{
List <SelectCardDecision> storedDecision = new List <SelectCardDecision>();
DealDamageAction gameAction = new DealDamageAction(GetCardSource(), null, null, 1, DamageType.Sonic, isIrreducible: true);
coroutine = GameController.SelectCardAndStoreResults(DecisionMaker, SelectionType.DealDamage, new LinqCardCriteria((Card c) => c.Owner == httc.TurnTaker && c.IsCharacter && !c.IsIncapacitatedOrOutOfGame, $"active {httc.TurnTaker.Name} heroes"), storedDecision, false, gameAction: gameAction, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
SelectCardDecision selectCardDecision = storedDecision.FirstOrDefault();
if (DidSelectCard(storedDecision))
{
target = GetSelectedCard(storedDecision);
}
}
coroutine = DealDamage(CharacterCard, target, 1, DamageType.Sonic, isIrreducible: true, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
protected IEnumerator MoveAugment(SelectCardDecision scd)
{
if (scd.SelectedCard == null)
{
yield break;
}
var otherHeroLocations = FindCardsWhere(c => c != scd.SelectedCard.Location.OwnerCard && c.IsHeroCharacterCard &&
c.IsInPlayAndHasGameText && !c.IsIncapacitatedOrOutOfGame)
.Select(h => new MoveCardDestination(h.NextToLocation, showMessage: true)).ToList();
IEnumerator routine = GameController.SelectLocationAndMoveCard(this.DecisionMaker, scd.SelectedCard,
otherHeroLocations, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(routine));
}
else
{
base.GameController.ExhaustCoroutine(routine);
}
}
private IEnumerator SelectAndMoveCardOptional(HeroTurnTakerController hero, Func <Card, bool> criteria, Location toLocation, bool toBottom = false, bool optional = true, bool isPutIntoPlay = false, bool playIfMovingToPlayArea = true, List <SelectCardDecision> storedResults = null, CardSource cardSource = null)
{
BattleZone battleZone = null;
if (cardSource != null)
{
battleZone = cardSource.BattleZone;
}
SelectCardDecision selectCardDecision = new SelectCardDecision(GameController, hero, SelectionType.MoveCard, GameController.FindCardsWhere(criteria, realCardsOnly: true, null, battleZone), isOptional: optional, allowAutoDecide: false, null, null, null, null, null, maintainCardOrder: false, actionCanBeCancelled: true, cardSource);
selectCardDecision.BattleZone = battleZone;
storedResults?.Add(selectCardDecision);
IEnumerator coroutine = GameController.SelectCardAndDoAction(selectCardDecision, (SelectCardDecision d) => GameController.MoveCard(hero, d.SelectedCard, toLocation, toBottom, isPutIntoPlay, playIfMovingToPlayArea, null, showMessage: false, null, null, null, evenIfIndestructible: false, flipFaceDown: false, null, isDiscard: false, evenIfPretendGameOver: false, shuffledTrashIntoDeck: false, doesNotEnterPlay: false, cardSource));
if (UseUnityCoroutines)
{
yield return(GameController.StartCoroutine(coroutine));
}
else
{
GameController.ExhaustCoroutine(coroutine);
}
}
private IEnumerator CompassPowerResponse(SelectCardDecision scd)
{
if (scd.SelectedCard != null)
{
int plus = GetPowerNumeral(0, 1);
var number = scd.SelectedCard.NextToLocation.NumberOfCards + plus;
List <MoveCardAction> results = new List <MoveCardAction>();
var coroutine = GameController.MoveCard(DecisionMaker, scd.SelectedCard, DecisionMaker.HeroTurnTaker.Hand,
decisionSources: scd.ToEnumerable(),
storedResults: results,
cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
if (DidMoveCard(results))
{
coroutine = GameController.SelectAndDestroyCards(DecisionMaker, new LinqCardCriteria(c => c.IsEnvironment || c.IsOngoing, "ongoing or enviroment"), number,
requiredDecisions: 0,
responsibleCard: DecisionMaker.CharacterCard,
cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
}
yield break;
}
protected IEnumerator RevealCardsFromTopOfDeck_PutOnTopInChoosenOrder(HeroTurnTakerController hero, Location deck)
{
List <Card> revealedCards = new List <Card>();
IEnumerator coroutine = this.GameController.RevealCards(hero, deck, CardsToReveal, revealedCards, false, RevealedCardDisplay.None, null, this.GetCardSource(null));
if (this.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(coroutine));
}
else
{
this.GameController.ExhaustCoroutine(coroutine);
}
List <Card> allRevealedCards = new List <Card>(revealedCards);
if (revealedCards.Count == 2)
{
List <SelectCardsDecision> selectCardDecisions = new List <SelectCardsDecision>();
coroutine = GameController.SelectCardsAndStoreResults(hero, SelectionType.MoveCardOnDeck, (Card c) => revealedCards.Contains(c), 1, selectCardDecisions, false,
cardSource: GetCardSource(),
ignoreBattleZone: true);
if (this.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(coroutine));
}
else
{
this.GameController.ExhaustCoroutine(coroutine);
}
SelectCardsDecision selectCardsDecision = selectCardDecisions.FirstOrDefault();
SelectCardDecision selectCardDecision = selectCardsDecision?.SelectCardDecisions.FirstOrDefault();
Card selectedCard = selectCardDecision?.SelectedCard;
Card otherCard = revealedCards.First(c => c != selectedCard);
if (selectedCard != null)
{
coroutine = this.GameController.MoveCard(this.TurnTakerController, otherCard, deck, cardSource: GetCardSource());
if (this.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(coroutine));
}
else
{
this.GameController.ExhaustCoroutine(coroutine);
}
coroutine = this.GameController.MoveCard(this.TurnTakerController, selectedCard, deck, decisionSources: new[] { selectCardDecision }, cardSource: GetCardSource());
if (this.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(coroutine));
}
else
{
this.GameController.ExhaustCoroutine(coroutine);
}
}
}
else if (revealedCards.Count == 1)
{
Card card = revealedCards[0];
string message = $"{card.Title} is the only card in {deck.GetFriendlyName()}.";
coroutine = this.GameController.SendMessageAction(message, Priority.High, GetCardSource(), new Card[] { card });
if (this.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(coroutine));
}
else
{
this.GameController.ExhaustCoroutine(coroutine);
}
coroutine = this.GameController.MoveCard(this.TurnTakerController, card, deck, cardSource: GetCardSource());
if (this.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(coroutine));
}
else
{
this.GameController.ExhaustCoroutine(coroutine);
}
}
coroutine = this.CleanupCardsAtLocations(new List <Location>()
{
deck.OwnerTurnTaker.Revealed
}, deck, cardsInList: allRevealedCards);
if (this.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(coroutine));
}
else
{
this.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}