public IEnumerator RetaliateRedirectResponse(DealDamageAction dda)
{
SetCardPropertyToTrueIfRealAction(OncePerTurn);
// "... {TheGoalieCharacter} may deal the source of that damage 1 projectile damage."
IEnumerator responseCoroutine = null;
if (dda.DamageSource != null && dda.DamageSource.IsTarget)
{
responseCoroutine = DealDamage(base.CharacterCard, dda.DamageSource.Card, 1, DamageType.Projectile, optional: true, isCounterDamage: true, cardSource: GetCardSource());
}
else
{
responseCoroutine = base.GameController.SendMessageAction("Damage was not dealt by a target, so " + base.CharacterCard.Title + " can't retaliate...", Priority.High, GetCardSource(), associatedCards: base.CharacterCard.ToEnumerable());
}
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(responseCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(responseCoroutine);
}
// "Then, you may destroy a Goalposts card."
List <DestroyCardAction> destroyed = new List <DestroyCardAction>();
IEnumerator destroyCoroutine = base.GameController.SelectAndDestroyCard(base.HeroTurnTakerController, GoalpostsCards, true, storedResultsAction: destroyed, responsibleCard: base.Card, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(destroyCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(destroyCoroutine);
}
// "If you do, redirect damage dealt by that source to {TheGoalieCharacter} until the start of your turn."
if (destroyed.FirstOrDefault() != null && destroyed.FirstOrDefault().WasCardDestroyed&& dda.DamageSource != null && dda.DamageSource.IsCard)
{
RedirectDamageStatusEffect focus = new RedirectDamageStatusEffect();
focus.RedirectTarget = base.CharacterCard;
focus.SourceCriteria.IsSpecificCard = dda.DamageSource.Card;
focus.TargetCriteria.IsNotSpecificCard = base.CharacterCard;
focus.UntilStartOfNextTurn(base.TurnTaker);
focus.UntilCardLeavesPlay(dda.DamageSource.Card);
focus.TargetLeavesPlayExpiryCriteria.Card = base.CharacterCard;
IEnumerator statusCoroutine = base.GameController.AddStatusEffect(focus, true, GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(statusCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(statusCoroutine);
}
}
yield break;
}
public override IEnumerator Play()
{
List <SelectCardDecision> target = new List <SelectCardDecision>();
//{Titan} deals 1 target 1 infernal damage.
IEnumerator coroutine = base.GameController.SelectTargetsAndDealDamage(base.HeroTurnTakerController, new DamageSource(base.GameController, base.CharacterCard), 1, DamageType.Infernal, 1, false, 1, storedResultsDecisions: target, cardSource: base.GetCardSource());
if (UseUnityCoroutines)
{
yield return(GameController.StartCoroutine(coroutine));
}
else
{
GameController.ExhaustCoroutine(coroutine);
}
if (target.FirstOrDefault() != null && target.FirstOrDefault().SelectedCard != null)
{
//Redirect the next damage dealt by that target back to itself.
RedirectDamageStatusEffect statusEffect = new RedirectDamageStatusEffect()
{
NumberOfUses = 1,
RedirectTarget = target.FirstOrDefault().SelectedCard,
SourceCriteria = { IsSpecificCard = target.FirstOrDefault().SelectedCard }
};
statusEffect.UntilCardLeavesPlay(target.FirstOrDefault().SelectedCard);
coroutine = base.AddStatusEffect(statusEffect);
if (UseUnityCoroutines)
{
yield return(GameController.StartCoroutine(coroutine));
}
else
{
GameController.ExhaustCoroutine(coroutine);
}
}
//If Titanform is in your trash, you may put it into play or into your hand.
if (base.GetTitanform().Location.IsTrash)
{
IEnumerable <MoveCardDestination> locations = new MoveCardDestination[]
{
new MoveCardDestination(base.TurnTaker.PlayArea),
new MoveCardDestination(base.HeroTurnTaker.Hand)
};
coroutine = base.GameController.SelectLocationAndMoveCard(base.HeroTurnTakerController, base.GetTitanform(), locations, true, cardSource: base.GetCardSource());
if (UseUnityCoroutines)
{
yield return(GameController.StartCoroutine(coroutine));
}
else
{
GameController.ExhaustCoroutine(coroutine);
}
}
yield break;
}
public override IEnumerator UsePower(int index = 0)
{
//{Rockstar} deals one target 2 melee damage.
int powerNumeral = GetPowerNumeral(0, 2);
int powerNumeral2 = GetPowerNumeral(1, 1);
List <DealDamageAction> storedResults = new List <DealDamageAction>();
IEnumerator coroutine = GameController.SelectTargetsAndDealDamage(HeroTurnTakerController, new DamageSource(GameController, CharacterCard), powerNumeral, DamageType.Melee, 1, false, 1, storedResultsDamage: storedResults, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
if (DidDealDamage(storedResults))
{
Card target = storedResults.First().Target;
//If a target takes damage this way, redirect all damage dealt by that target to { Rockstar} and reduce damage dealt by that target by 1 until the start of your next turn.
RedirectDamageStatusEffect redirectEffect = new RedirectDamageStatusEffect();
redirectEffect.SourceCriteria.IsSpecificCard = target;
redirectEffect.UntilStartOfNextTurn(TurnTaker);
redirectEffect.RedirectTarget = CharacterCard;
redirectEffect.UntilCardLeavesPlay(target);
redirectEffect.UntilTargetLeavesPlay(target);
redirectEffect.TargetRemovedExpiryCriteria.Card = target;
IEnumerator redirectCoroutine = AddStatusEffect(redirectEffect);
ReduceDamageStatusEffect reduceEffect = new ReduceDamageStatusEffect(1);
reduceEffect.SourceCriteria.IsSpecificCard = target;
reduceEffect.UntilStartOfNextTurn(TurnTaker);
reduceEffect.UntilCardLeavesPlay(target);
reduceEffect.UntilTargetLeavesPlay(target);
reduceEffect.TargetRemovedExpiryCriteria.Card = target;
IEnumerator reduceCoroutine = AddStatusEffect(reduceEffect);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(redirectCoroutine));
yield return(base.GameController.StartCoroutine(reduceCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(redirectCoroutine);
base.GameController.ExhaustCoroutine(reduceCoroutine);
}
}
}
public override IEnumerator UsePower(int index = 0)
{
//The next time {TheStranger} would deal himself damage, redirect it to another target.
RedirectDamageStatusEffect effect = new RedirectDamageStatusEffect();
effect.SourceCriteria.IsSpecificCard = base.Card;
effect.TargetCriteria.IsSpecificCard = base.Card;
effect.RedirectableTargets.IsTarget = true;
effect.RedirectableTargets.IsNotSpecificCard = base.Card;
effect.NumberOfUses = 1;
IEnumerator coroutine5 = AddStatusEffect(effect);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine5));
}
else
{
base.GameController.ExhaustCoroutine(coroutine5);
}
yield break;
}
public override IEnumerator Play()
{
RedirectDamageStatusEffect redirectDamageStatusEffect = new RedirectDamageStatusEffect
{
RedirectTarget = base.CharacterCard
};
redirectDamageStatusEffect.SourceCriteria.IsVillain = true;
redirectDamageStatusEffect.TargetCriteria.IsNotSpecificCard = base.CharacterCard;
redirectDamageStatusEffect.UntilStartOfNextTurn(base.TurnTaker);
redirectDamageStatusEffect.TargetRemovedExpiryCriteria.Card = base.CharacterCard;
IEnumerator coroutine = base.AddStatusEffect(redirectDamageStatusEffect, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
public override IEnumerator UseIncapacitatedAbility(int index)
{
/*
* "One player use a power now.",
* "Reveal the top card of 2 decks, then replace those cards.",
* "The next time a hero would be dealt damage, redirect that damage to a non-villain target."
*/
switch (index)
{
case 0:
{
//"One player use a power now."
IEnumerator coroutine = base.GameController.SelectHeroToUsePower(this.DecisionMaker, cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
case 1:
{
//"Reveal the top card of 2 decks, then replace those cards.",
List <SelectLocationDecision> storedResults = new List <SelectLocationDecision>();
IEnumerator coroutine = base.GameController.SelectADeck(this.DecisionMaker, SelectionType.RevealTopCardOfDeck, (Location l) => l.IsDeck && !l.OwnerTurnTaker.IsIncapacitatedOrOutOfGame, storedResults, cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
var location = GetSelectedLocation(storedResults);
if (location != null)
{
storedResults.Clear();
coroutine = RevealAndReplace(location);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
coroutine = base.GameController.SelectADeck(this.DecisionMaker, SelectionType.RevealTopCardOfDeck, (Location l) => l.IsDeck && !l.OwnerTurnTaker.IsIncapacitatedOrOutOfGame && l != location, storedResults, cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
location = GetSelectedLocation(storedResults);
if (location != null)
{
storedResults.Clear();
coroutine = RevealAndReplace(location);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
}
break;
}
case 2:
{
//"The next time a hero would be dealt damage, redirect that damage to a non-villain target."
var effect = new RedirectDamageStatusEffect();
effect.NumberOfUses = 1;
effect.RedirectableTargets.IsVillain = false;
effect.RedirectableTargets.IsTarget = true;
effect.TargetCriteria.IsHero = true;
effect.TargetCriteria.IsTarget = true;
effect.CardSource = Card;
var coroutine = base.AddStatusEffect(effect, true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
break;
}
}
yield break;
}
