private IEnumerator MoveCardResponse(DestroyCardAction destroyCard) { //Move card from under this card into the hand IEnumerator coroutine = base.GameController.SelectAndMoveCard(base.HeroTurnTakerController, (Card c) => base.Card.UnderLocation.HasCard(c), base.HeroTurnTaker.Hand, false, false, false, false, null, null); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(coroutine)); } else { base.GameController.ExhaustCoroutine(coroutine); } //When there are no cards beneath this one, destroy this card." if (base.Card.UnderLocation.Cards.Count <Card>() == 0) { IEnumerator coroutine2 = base.GameController.DestroyCard(this.DecisionMaker, base.Card, false, null, null, null, null, null, null, null, null, base.GetCardSource(null)); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(coroutine2)); } else { base.GameController.ExhaustCoroutine(coroutine2); } yield break; } yield break; }
public IEnumerator MoveItToTheBottomOfItsDeckResponse(DestroyCardAction d, HeroTurnTaker hero, StatusEffect effect, int[] powerNumerals = null) { //...you may move it to the bottom of its deck. if (d.PostDestroyDestinationCanBeChanged) { var storedResults = new List <YesNoCardDecision>(); HeroTurnTakerController httc = null; if (hero != null) { httc = FindHeroTurnTakerController(hero); } var e = this.GameController.MakeYesNoCardDecision(httc, SelectionType.MoveCardToHand, d.CardToDestroy.Card, storedResults: storedResults, cardSource: GetCardSource()); if (UseUnityCoroutines) { yield return(this.GameController.StartCoroutine(e)); } else { this.GameController.ExhaustCoroutine(e); } if (DidPlayerAnswerYes(storedResults)) { var nativeDeck = d.CardToDestroy.Card.NativeDeck; var hand = nativeDeck.OwnerTurnTaker.ToHero().Hand; d.SetPostDestroyDestination(hand, false, storedResults.CastEnumerable <YesNoCardDecision, IDecision>(), cardSource: GetCardSource()); } } }
public IEnumerator CrashResponse(DestroyCardAction dca) { // "When this card is destroyed, it deals each other target in this play area 2 irreducible fire damage." IEnumerator damageCoroutine = base.DealDamage(base.Card, (Card c) => c != base.Card && c.Location.HighestRecursiveLocation == base.Card.Location.HighestRecursiveLocation, 2, DamageType.Fire, isIrreducible: true, optional: false); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(damageCoroutine)); } else { base.GameController.ExhaustCoroutine(damageCoroutine); } // "Then, discard cards from the top of the environment deck until a Storage card is discarded. Put it into play." IEnumerator digCoroutine = base.DigForStorage(); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(digCoroutine)); } else { base.GameController.ExhaustCoroutine(digCoroutine); } yield break; }
private IEnumerator DestroyEnvironmentResponse(DestroyCardAction dca) { List <Card> highestHpTarget = new List <Card>(); var damageInfo = new DealDamageAction(GetCardSource(), new DamageSource(GameController, Card), null, PsychicDamageToDeal, DamageType.Psychic); var coroutine = GameController.FindTargetWithHighestHitPoints(1, card => card.IsTarget, highestHpTarget, dealDamageInfo: new[] { damageInfo }, evenIfCannotDealDamage: true, cardSource: GetCardSource()); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(coroutine)); } else { base.GameController.ExhaustCoroutine(coroutine); } if (highestHpTarget.Any()) { var target = highestHpTarget.First(); // Deal 5 psychic damage coroutine = this.DealDamage(this.Card, target, PsychicDamageToDeal, DamageType.Psychic, cardSource: this.GetCardSource()); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(coroutine)); } else { base.GameController.ExhaustCoroutine(coroutine); } } }
public IEnumerator OnDestroyResponse(DestroyCardAction dca) { // "When this card is destroyed, you may draw a card or use a power." List <Function> options = new List <Function>(); Function drawOption = new Function(base.DecisionMaker, "Draw a card", SelectionType.DrawCard, () => base.GameController.DrawCard(base.HeroTurnTaker, cardSource: GetCardSource()), null, null, "Draw a card"); options.Add(drawOption); Function powerOption = new Function(base.DecisionMaker, "Use a power", SelectionType.UsePower, () => base.GameController.SelectAndUsePower(base.HeroTurnTakerController, optional: true, null, 1, cardSource: GetCardSource()), null, null, "Use a power"); options.Add(powerOption); if (options.Count > 0) { SelectFunctionDecision choice = new SelectFunctionDecision(base.GameController, base.HeroTurnTakerController, options, true, cardSource: GetCardSource()); IEnumerator chooseCoroutine = base.GameController.SelectAndPerformFunction(choice); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(chooseCoroutine)); } else { base.GameController.ExhaustCoroutine(chooseCoroutine); } } yield break; }
public IEnumerator CardDestroyedResponse(DestroyCardAction dca) { // "When a card is destroyed, you may reveal the top card of its deck, then replace it." Card destroyed = dca.CardToDestroy.Card; Location toCheck = destroyed.NativeDeck; Card toReveal = toCheck.TopCard; List <YesNoCardDecision> results = new List <YesNoCardDecision>(); IEnumerator chooseCoroutine = base.GameController.MakeYesNoCardDecision(base.HeroTurnTakerController, SelectionType.RevealTopCardOfDeck, base.Card, action: dca, storedResults: results, cardSource: GetCardSource()); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(chooseCoroutine)); } else { base.GameController.ExhaustCoroutine(chooseCoroutine); } if (base.DidPlayerAnswerYes(results)) { IEnumerator revealCoroutine = base.GameController.SendMessageAction(base.Card.Title + " revealed " + toReveal.Title + " on top of " + toCheck.GetFriendlyName() + "!", Priority.High, cardSource: GetCardSource(), associatedCards: toReveal.ToEnumerable(), showCardSource: true); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(revealCoroutine)); } else { base.GameController.ExhaustCoroutine(revealCoroutine); } } yield break; }
private IEnumerator DoFrenzy(DestroyCardAction arg) { arg.SetPostDestroyDestination(Frenzy.UnderLocation); return(DoNothing()); //var consume = this.GameController.Change(TurnTakerController, arg.CardToDestroy.Card, Card.UnderLocation, cardSource: GetCardSource()); //if(UseUnityCoroutines) { yield return this.GameController.StartCoroutine(consume); } else { this.GameController.ExhaustCoroutine(consume); } }
public override IEnumerator DestroyAttempted(DestroyCardAction destroyCard) { if (base.Card.IsFlipped) { yield break; } }
private IEnumerator DestroyRadiationFrontResponse(DestroyCardAction action) { IEnumerator coroutine; //...destroy 1 hero ongoing or equipment card and {Gray} deals each non-villain target {H - 1} energy damage if (FindNumberOfHeroOngoingAndEquipmentInPlay() > 0) { int?numberOfCards = new int?(1); if (Game.IsAdvanced) { //Advanced - Whenever a radiation card is destroyed, destroy a second hero ongoing or equipment card. numberOfCards = new int?(2); } coroutine = base.GameController.SelectAndDestroyCards(this.DecisionMaker, new LinqCardCriteria((Card c) => c.IsHero && (c.IsOngoing || base.IsEquipment(c))), numberOfCards, cardSource: base.GetCardSource()); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(coroutine)); } else { base.GameController.ExhaustCoroutine(coroutine); } } coroutine = base.DealDamage(base.Card, (Card c) => c.IsNonVillainTarget, Game.H - 1, DamageType.Energy); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(coroutine)); } else { base.GameController.ExhaustCoroutine(coroutine); } yield break; }
private IEnumerator MayReturnDestroyedResponse(DestroyCardAction dc) { Card toReturn = dc.CardToDestroy.Card; var decisionResult = new List <YesNoCardDecision> { }; IEnumerator coroutine = GameController.MakeYesNoCardDecision(DecisionMaker, SelectionType.MoveCardToHand, toReturn, storedResults: decisionResult, cardSource: GetCardSource()); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(coroutine)); } else { base.GameController.ExhaustCoroutine(coroutine); } if (DidPlayerAnswerYes(decisionResult)) { dc.SetPostDestroyDestination(dc.CardToDestroy.Card.Owner.ToHero().Hand); dc.AddAfterDestroyedAction(() => DestroyThisCardIfMovedResponse(dc), this); } yield break; }
private IEnumerator WhenDestroyedResponse(DestroyCardAction dca) { //Place the top card of the villain deck beneath him. List <SelectLocationDecision> storedResults = new List <SelectLocationDecision>(); IEnumerator coroutine = base.FindVillainDeck(base.DecisionMaker, SelectionType.MoveCardToUnderCard, storedResults, (Location l) => l.HasCards); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(coroutine)); } else { base.GameController.ExhaustCoroutine(coroutine); } if (base.DidSelectLocation(storedResults)) { Location villainDeck = storedResults.First().SelectedLocation.Location; Card takAhab = base.FindTakAhabInPlay(); coroutine = base.GameController.MoveCard(base.DecisionMaker, villainDeck.TopCard, takAhab.UnderLocation, showMessage: true, cardSource: base.GetCardSource()); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(coroutine)); } else { base.GameController.ExhaustCoroutine(coroutine); } } yield break; }
private IEnumerator DealDamageResponse(DestroyCardAction destroyCard) { List <SelectCardDecision> selectCardResults = new List <SelectCardDecision>(); IEnumerator selectOwnCharacterRoutine = base.SelectOwnCharacterCard(selectCardResults, SelectionType.HeroToDealDamage); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(selectOwnCharacterRoutine)); } else { base.GameController.ExhaustCoroutine(selectOwnCharacterRoutine); } // You may deal 1 target 1 projectile damage Card characterCard = GetSelectedCard(selectCardResults); IEnumerator dealDamageRoutine = base.GameController.SelectTargetsAndDealDamage(this.DecisionMaker, new DamageSource(base.GameController, characterCard), DamageAmount, DamageType.Projectile, 1, false, 0, additionalCriteria: c => c.IsTarget && c.IsInPlayAndHasGameText && !c.IsBeingDestroyed, cardSource: base.GetCardSource()); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(dealDamageRoutine)); } else { base.GameController.ExhaustCoroutine(dealDamageRoutine); } }
private IEnumerator DealDamageResponse(DestroyCardAction action) { List <SelectCardDecision> targetDecision = new List <SelectCardDecision>(); //{Titan} deals 1 villain target 5 infernal damage. IEnumerator coroutine = base.GameController.SelectTargetsAndDealDamage(base.HeroTurnTakerController, new DamageSource(base.GameController, base.CharacterCard), 5, DamageType.Infernal, 1, false, 1, storedResultsDecisions: targetDecision, cardSource: base.GetCardSource()); if (UseUnityCoroutines) { yield return(GameController.StartCoroutine(coroutine)); } else { GameController.ExhaustCoroutine(coroutine); } // If Titanform is in play... if (base.GetTitanform().Location.IsInPlayAndNotUnderCard) { //...{Titan} also deals that target 2 fire damage. coroutine = base.DealDamage(base.CharacterCard, targetDecision.FirstOrDefault().SelectedCard, 2, DamageType.Fire, cardSource: base.GetCardSource()); if (UseUnityCoroutines) { yield return(GameController.StartCoroutine(coroutine)); } else { GameController.ExhaustCoroutine(coroutine); } } yield break; }
private IEnumerator DealDamageResponse(DestroyCardAction d) { var microstormIdentifier = d.CardToDestroy.Card.Identifier; var damageType = new DamageType(); if (microstormIdentifier == HailFlurryIdentifier) { damageType = DamageType.Cold; } else if (microstormIdentifier == FlaringBlazeIdentifier) { damageType = DamageType.Fire; } else if (microstormIdentifier == ScathingSandstormIdentifier) { damageType = DamageType.Projectile; } else if (microstormIdentifier == BladedGaleIdentifier) { damageType = DamageType.Sonic; } else if (microstormIdentifier == VigilanteJusticeIdentifier) { damageType = DamageType.Radiant; } else if (microstormIdentifier == ViciousRetributionIdentifier) { damageType = DamageType.Infernal; } else if (microstormIdentifier == ThunderStormIdentifier) { damageType = DamageType.Lightning; } else if (microstormIdentifier == ToxicCloudIdentifier) { damageType = DamageType.Toxic; } else if (microstormIdentifier == PsionicTorrentIdentifier) { damageType = DamageType.Psychic; } else if (microstormIdentifier == OverloadPulseIdentifier) { damageType = DamageType.Energy; } IEnumerator coroutine = base.GameController.SelectTargetsAndDealDamage(this.DecisionMaker, new DamageSource(base.GameController, base.CharacterCard), 1, damageType, 1, false, 0, false, false, false, null, null, null, null, null, false, null, null, false, null, GetCardSource(null)); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(coroutine)); } else { base.GameController.ExhaustCoroutine(coroutine); } yield break; }
private bool SelfDestructionCriteria(DestroyCardAction action) { //Destroy this card when {H} hero cards are destroyed this way in one round. //prefilter to events that destroyed a hero ongoing before hitting the Journal var destroyedCard = action.CardToDestroy?.Card; return(destroyedCard != null && destroyedCard.IsHero && (destroyedCard.IsOngoing || IsEquipment(destroyedCard)) && this.GetHeroCardsDestroyedThisRound().Where(e => (e.Card.IsOngoing || IsEquipment(e.Card)) && e.CardSource == this.Card).Count() >= Game.H); }
private bool LineEmUpTriggerCondition(DestroyCardAction destroyCard) { return(destroyCard.WasCardDestroyed && base.GameController.IsCardVisibleToCardSource(destroyCard.CardToDestroy.Card, base.GetCardSource()) && ( (destroyCard.ResponsibleCard != null && destroyCard.ResponsibleCard.Owner == this.TurnTaker) || (destroyCard.CardSource != null && destroyCard.CardSource.Card != null && destroyCard.CardSource.Card.Owner == this.TurnTaker) )); }
private bool DestroyIsDueToDamageFromHighHitPoints(DestroyCardAction dc) { if (dc.ActionSource != null && dc.ActionSource is DealDamageAction) { var damageAction = dc.ActionSource as DealDamageAction; return(damageAction.TargetHitPointsBeforeBeingDealtDamage > 1); } return(false); }
public IEnumerator RescueOngoingResponse(DestroyCardAction dc, HeroTurnTaker _1, StatusEffect _2, int[] _3 = null) { if (dc.PostDestroyDestinationCanBeChanged && dc.CardToDestroy != null) { dc.PostDestroyDestinationCanBeChanged = false; dc.AddAfterDestroyedAction(() => GameController.MoveCard(DecisionMaker, dc.CardToDestroy.Card, dc.CardToDestroy.HeroTurnTaker.Hand, cardSource: GetCardSource()), this); } yield break; }
private IEnumerator DestroyedResponse(DestroyCardAction destroy) { List <Card> revealedCards = new List <Card>(); IEnumerator revealCardsRoutine = base.GameController.RevealCards(this.TurnTakerController, base.TurnTaker.Deck, CardsToReveal, revealedCards, revealedCardDisplay: RevealedCardDisplay.ShowRevealedCards, cardSource: base.GetCardSource()); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(revealCardsRoutine)); } else { base.GameController.ExhaustCoroutine(revealCardsRoutine); } if (!revealedCards.Any()) { yield break; } IEnumerable <Function> choices = new[] { new Function(base.DecisionMaker, "Discard Card", SelectionType.DiscardCard, () => base.GameController.MoveCard(base.DecisionMaker, revealedCards.First(), base.TurnTaker.Trash, showMessage: true, cardSource: GetCardSource())), new Function(base.DecisionMaker, "Replace Card", SelectionType.MoveCardOnDeck, () => base.GameController.MoveCard(base.DecisionMaker, revealedCards.First(), base.TurnTaker.Deck, showMessage: true, cardSource: GetCardSource())) }; List <MoveCardAction> virusMoveAction = new List <MoveCardAction>(); if (IsSuperVirusInPlay() && IsVirus(revealedCards.First())) { choices = choices.Concat(new[] { new Function(base.DecisionMaker, "Put under Super Virus", SelectionType.MoveCardToUnderCard, () => base.GameController.MoveCard(base.DecisionMaker, revealedCards.First(), GetSuperVirusCard().UnderLocation, storedResults: virusMoveAction, showMessage: true, cardSource: GetCardSource())), }); } SelectFunctionDecision selectFunctionDecision = new SelectFunctionDecision(base.GameController, this.DecisionMaker, choices, false, associatedCards: revealedCards, cardSource: base.GetCardSource()); IEnumerator routine = base.GameController.SelectAndPerformFunction(selectFunctionDecision); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(routine)); } else { base.GameController.ExhaustCoroutine(routine); } yield break; }
private bool DestroyCriteria(DestroyCardAction dca) { //this should only apply to the GrandOngoings that need High //your are my requiredIdentifer //me and you are both in play //you are moving to the hand or trash return((dca.CardToDestroy.Card.Identifier == _requiredIdentifier || dca.CardToDestroy.Card.Identifier == _attachIdentifier) && dca.WasCardDestroyed && dca.CardToDestroy.Card.Location.IsHeroPlayAreaRecursive); }
private IEnumerator DestroyRadiationBackResponse(DestroyCardAction action) { TurnTaker responsibleTurnTaker; if (action.ResponsibleCard != null) { responsibleTurnTaker = action.ResponsibleCard.Owner; } else { responsibleTurnTaker = base.TurnTaker; } //Whenever a radiation card is destroyed by a hero card, {Gray} deals that hero {H - 1} energy damage. IEnumerator coroutine; //if its not a hero destroying it do no damage if (responsibleTurnTaker != null && responsibleTurnTaker.IsHero && !responsibleTurnTaker.IsIncapacitatedOrOutOfGame) { List <Card> results = new List <Card>(); coroutine = base.FindCharacterCardToTakeDamage(responsibleTurnTaker, results, Card, Game.H - 1, DamageType.Energy); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(coroutine)); } else { base.GameController.ExhaustCoroutine(coroutine); } coroutine = base.DealDamage(base.Card, results.First(), Game.H - 1, DamageType.Energy); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(coroutine)); } else { base.GameController.ExhaustCoroutine(coroutine); } } //Whenever a copy of Radioactive Cascade is destroyed, {Gray} deals the hero with the highest HP {H - 1} energy damage. if (action.CardToDestroy.Card.Identifier == "RadioactiveCascade") { coroutine = base.DealDamageToHighestHP(base.Card, 1, (Card c) => c.IsHero, (Card c) => new int?(Game.H - 1), DamageType.Energy); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(coroutine)); } else { base.GameController.ExhaustCoroutine(coroutine); } } yield break; }
private bool IsByHero(DestroyCardAction dc) { if (dc != null && dc.ActionSource is DealDamageAction damage) { return(damage.DamageSource.IsHero); } else if (dc != null && dc.CardSource != null) { return(dc.CardSource.Card.IsHero); } return(false); }
private IEnumerator GameOverResponse(DestroyCardAction dca) { IEnumerator routine = base.GameController.GameOver(EndingResult.AlternateDefeat, LoseMessage, actionSource: dca, cardSource: GetCardSource()); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(routine)); } else { base.GameController.ExhaustCoroutine(routine); } }
private IEnumerator GainHpResponse(DestroyCardAction destroyCard) { IEnumerator gainHpRoutine = this.GameController.GainHP(this.CharacterCard, HpGain, cardSource: this.GetCardSource()); if (this.UseUnityCoroutines) { yield return(this.GameController.StartCoroutine(gainHpRoutine)); } else { this.GameController.ExhaustCoroutine(gainHpRoutine); } }
protected override IEnumerator FireArrow(DestroyCardAction dca = null) { var damage = this.GameController.SelectTargetsAndDealDamage(DecisionMaker, new DamageSource(GameController, CharacterCard), 1, DamageType.Projectile, 1, false, 0, false, false, false, c => !c.IsHero, addStatusEffect: Debilitate, cardSource: GetCardSource()); if (UseUnityCoroutines) { yield return(this.GameController.StartCoroutine(damage)); } else { this.GameController.ExhaustCoroutine(damage); } }
public static Card GetCardDestroyer(this DestroyCardAction action) { if (action.ResponsibleCard != null) { return(action.ResponsibleCard); } if (action.CardSource != null) { return(action.CardSource.Card); } return(null); }
private IEnumerator DestroyCardResponse(DestroyCardAction dca) { IEnumerator routine = base.GameController.EachPlayerDiscardsCards(CardsToDiscard, CardsToDiscard, cardSource: base.GetCardSource()); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(routine)); } else { base.GameController.ExhaustCoroutine(routine); } }
private IEnumerator GainHPResponse(DestroyCardAction d) { IEnumerator healHero = base.GameController.SelectAndGainHP(this.DecisionMaker, 2, false, (Card c) => c.IsInPlay && c.IsHeroCharacterCard, 1, null, false, null, GetCardSource(null)); if (base.UseUnityCoroutines) { yield return(base.GameController.StartCoroutine(healHero)); } else { base.GameController.ExhaustCoroutine(healHero); } }
protected IEnumerator FreeCaptive(DestroyCardAction arg) { var play = PlayCardsFromLocation(Card.UnderLocation, new LinqCardCriteria(c => true)); if (UseUnityCoroutines) { yield return(this.GameController.StartCoroutine(play)); } else { this.GameController.ExhaustCoroutine(play); } }
private IEnumerator Reclaim(DestroyCardAction arg) { var search = SearchForCards(HeroTurnTakerController, false, true, 1, 0, new LinqCardCriteria(c => c.DoKeywordsContain("arrow")), true, false, false); if (UseUnityCoroutines) { yield return(this.GameController.StartCoroutine(search)); } else { this.GameController.ExhaustCoroutine(search); } }