public override IEnumerator UsePower(int index = 0)
{
//Each Player may Draw 2 Cards. Then Destroy this Card.
LinqTurnTakerCriteria heroCriteria = new LinqTurnTakerCriteria((TurnTaker tt) => tt.IsHero && !tt.ToHero().IsIncapacitatedOrOutOfGame, "active heroes");
IEnumerator coroutine = GameController.DrawCards(heroCriteria, 2, optional: true, cardSource: GetCardSource());
if (UseUnityCoroutines)
{
yield return(GameController.StartCoroutine(coroutine));
}
else
{
GameController.ExhaustCoroutine(coroutine);
}
coroutine = DestroyThisCardResponse(null);
if (UseUnityCoroutines)
{
yield return(GameController.StartCoroutine(coroutine));
}
else
{
GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
private IEnumerator TwoPlayersMayDrawACard()
{
LinqTurnTakerCriteria criteria = new LinqTurnTakerCriteria(tt => tt.IsHero && !tt.IsIncapacitatedOrOutOfGame && GameController.IsTurnTakerVisibleToCardSource(tt, GetCardSource()));
SelectTurnTakersDecision selectTurnTakersDecision = new SelectTurnTakersDecision(GameController, DecisionMaker, criteria, SelectionType.DrawCard, numberOfTurnTakers: 2, cardSource: GetCardSource());;
IEnumerator coroutine = GameController.SelectTurnTakersAndDoAction(selectTurnTakersDecision, tt => DrawCard(hero: tt.ToHero(), optional: true));
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
protected override IEnumerator SelectZombieTarget(List <MoveCardDestination> storedResults, List <IDecision> decisionSources, bool isPutIntoPlay, LinqTurnTakerCriteria additionalCriteria = null)
{
List <Card> storeHighest = new List <Card>();
var coroutine = GameController.FindTargetWithHighestHitPoints(1, c => c.IsHeroCharacterCard && (additionalCriteria?.Criteria(c.Owner) ?? true), storeHighest, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
if (storeHighest.Any())
{
storedResults.Add(new MoveCardDestination(storeHighest.First().NextToLocation));
}
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
//Play this card next to the hero with the lowest HP
List <Card> foundTarget = new List <Card>();
IEnumerator coroutine = base.GameController.FindTargetWithLowestHitPoints(1, (Card c) => c.IsHero && (overridePlayArea == null || c.IsAtLocationRecursive(overridePlayArea)), foundTarget, cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
Card lowestHero = foundTarget.FirstOrDefault();
if (lowestHero != null && storedResults != null)
{
//Play this card next to the hero with the lowest HP
storedResults.Add(new MoveCardDestination(lowestHero.NextToLocation, false, false, false));
}
yield break;
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
IEnumerator coroutine;
if (this.TurnTakerControllerWithoutReplacements.HasMultipleCharacterCards)
{
List <SelectCardDecision> selectedKnight = new List <SelectCardDecision> {
};
coroutine = SelectOwnCharacterCard(selectedKnight, SelectionType.HeroCharacterCard);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
if (DidSelectCard(selectedKnight))
{
AddCardPropertyJournalEntry(RoninKey, selectedKnight.FirstOrDefault().SelectedCard);
}
}
coroutine = base.DeterminePlayLocation(storedResults, isPutIntoPlay, decisionSources, overridePlayArea, additionalTurnTakerCriteria);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
// Find what to go next to.
IEnumerator coroutine = this.SelectCardThisCardWillMoveNextTo(this.NextToCriteria, storedResults, isPutIntoPlay, decisionSources);
if (this.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(coroutine));
}
else
{
this.GameController.ExhaustCoroutine(coroutine);
}
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
//"Play this card next to a target.",
//"Whenever that target would take damage, redirect that damage to {TheKnight}. Damage redirected this way is irreducible."
IEnumerator coroutine = base.SelectCardThisCardWillMoveNextTo(new LinqCardCriteria((Card c) => c.IsTarget && c.IsInPlayAndHasGameText, "targets", false), storedResults, isPutIntoPlay, decisionSources);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
//"Play this card next to a card with a power on it.",
IEnumerable <Card> viableCards = FindCardsWhere((Card c) => c.IsInPlayAndHasGameText && GameController.GetAllPowersForCardController(FindCardController(c)).Any());
IEnumerator coroutine = SelectCardThisCardWillMoveNextTo(new LinqCardCriteria((Card c) => viableCards.Contains(c)), storedResults, isPutIntoPlay, decisionSources);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
var equip = SelectCardThisCardWillMoveNextTo(new LinqCardCriteria(c => c.IsHeroCharacterCard), storedResults, isPutIntoPlay, decisionSources);
if (UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(equip));
}
else
{
this.GameController.ExhaustCoroutine(equip);
}
}
protected override IEnumerator SelectZombieTarget(List <MoveCardDestination> storedResults, List <IDecision> decisionSources, bool isPutIntoPlay, LinqTurnTakerCriteria additionalCriteria = null)
{
List <TurnTaker> turnTakers = new List <TurnTaker>();
var coroutine = FindHeroWithMostCardsInHand(turnTakers, 1, 1, additionalCriteria);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
coroutine = SelectCardThisCardWillMoveNextTo(new LinqCardCriteria(c => c.IsHeroCharacterCard && turnTakers.Contains(c.Owner), "hero character"), storedResults, isPutIntoPlay, decisionSources);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
public override IEnumerator UseIncapacitatedAbility(int index)
{
IEnumerator routine;
List <SelectTurnTakerDecision> storedHero;
List <DestroyCardAction> storedDestroy;
LinqCardCriteria cardCriteria;
LinqTurnTakerCriteria heroCriteria;
switch (index)
{
case 0:
// One player may destroy 1 of their ongoing cards to draw 3 cards.
storedDestroy = new List <DestroyCardAction> {
};
storedHero = new List <SelectTurnTakerDecision> {
};
cardCriteria = new LinqCardCriteria(c => c.IsOngoing, "ongoing");
heroCriteria = new LinqTurnTakerCriteria(tt => tt.GetCardsWhere((Card c) => c.IsInPlayAndHasGameText && c.IsOngoing).Any());
routine = GameController.SelectHeroToDestroyTheirCard(DecisionMaker, (httc) => cardCriteria, additionalCriteria: heroCriteria, storedResultsTurnTaker: storedHero, storedResultsAction: storedDestroy, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(routine));
}
else
{
base.GameController.ExhaustCoroutine(routine);
}
if (DidDestroyCard(storedDestroy))
{
HeroTurnTakerController httc = base.FindHeroTurnTakerController(GetSelectedTurnTaker(storedHero).ToHero());
routine = GameController.DrawCards(httc, Incapacitate1CardsToDraw, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(routine));
}
else
{
base.GameController.ExhaustCoroutine(routine);
}
}
break;
case 1:
// One player may destroy 1 of their equipment cards to play 3 cards.
storedDestroy = new List <DestroyCardAction> {
};
storedHero = new List <SelectTurnTakerDecision> {
};
cardCriteria = new LinqCardCriteria(c => IsEquipment(c), "equipment");
heroCriteria = new LinqTurnTakerCriteria(tt => tt.GetCardsWhere((Card c) => c.IsInPlayAndHasGameText && IsEquipment(c)).Any());
routine = GameController.SelectHeroToDestroyTheirCard(DecisionMaker, (httc) => cardCriteria, additionalCriteria: heroCriteria, storedResultsTurnTaker: storedHero, storedResultsAction: storedDestroy, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(routine));
}
else
{
base.GameController.ExhaustCoroutine(routine);
}
if (DidDestroyCard(storedDestroy))
{
HeroTurnTakerController httc = base.FindHeroTurnTakerController(GetSelectedTurnTaker(storedHero).ToHero());
routine = GameController.SelectAndPlayCardsFromHand(httc, Incapacitate2CardsToPlay, false, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(routine));
}
else
{
base.GameController.ExhaustCoroutine(routine);
}
}
break;
case 2:
// One target regains 1 HP.
routine = base.GameController.SelectAndGainHP(this.HeroTurnTakerController, Incapacitate3HpGain,
cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(routine));
}
else
{
base.GameController.ExhaustCoroutine(routine);
}
break;
}
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
var place = (this as CardController).DeterminePlayLocation(storedResults, isPutIntoPlay, decisionSources, overridePlayArea, additionalTurnTakerCriteria);
if (UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(place));
}
else
{
this.GameController.ExhaustCoroutine(place);
}
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
if (playToTheLeft != null && playToTheLeft.Value)
{
IEnumerator coroutine = MoveCardIntoFarLeft(base.Card);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
storedResults.Add(new MoveCardDestination(TurnTaker.PlayArea));
yield return(null);
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
IEnumerator coroutine;
if (this.TurnTakerControllerWithoutReplacements.HasMultipleCharacterCards && !_useSpecialAssignment)
{
coroutine = SelectCardThisCardWillMoveNextTo(new LinqCardCriteria((Card c) => IsOwnCharacterCard(c), "Knight character"), storedResults, isPutIntoPlay, decisionSources);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
if (storedResults.Any() && storedResults.FirstOrDefault().Location.IsNextToCard)
{
AddCardPropertyJournalEntry(RoninKey, storedResults.FirstOrDefault().Location.OwnerCard);
}
}
else
{
coroutine = base.DeterminePlayLocation(storedResults, isPutIntoPlay, decisionSources, overridePlayArea, additionalTurnTakerCriteria);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
yield break;
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
IEnumerator coroutine = base.SelectCardThisCardWillMoveNextTo(new LinqCardCriteria((Card c) => this.NextToCardCriteria.Criteria(c) && (additionalTurnTakerCriteria == null || additionalTurnTakerCriteria.Criteria(c.Owner)), this.NextToCardCriteria.Description, true, false, null, null, false), storedResults, isPutIntoPlay, decisionSources);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
//"Play this card next to a target"
IEnumerator coroutine = SelectCardThisCardWillMoveNextTo(new LinqCardCriteria((Card c) => c.IsTarget && c.IsInPlay, "targets", useCardsSuffix: false), storedResults, isPutIntoPlay, decisionSources);
if (UseUnityCoroutines)
{
yield return(GameController.StartCoroutine(coroutine));
}
else
{
GameController.ExhaustCoroutine(coroutine);
}
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
//Play this card next to the hero with the most cards in hand.
//find hero with the most cards in hand
List <TurnTaker> storedMostCards = new List <TurnTaker>();
IEnumerator coroutine = base.FindHeroWithMostCardsInHand(storedMostCards);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
//select the hero with the most cards in hand, resolving ties
IEnumerator coroutine2 = base.SelectCardThisCardWillMoveNextTo(new LinqCardCriteria((Card c) => storedMostCards.Contains(c.Owner) && c.IsHeroCharacterCard && (additionalTurnTakerCriteria == null || additionalTurnTakerCriteria.Criteria(c.Owner)), "hero target with the most cards in hand"), storedResults, isPutIntoPlay, decisionSources);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine2));
}
else
{
base.GameController.ExhaustCoroutine(coroutine2);
}
yield break;
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
//Play this card next to the hero with the highest HP
IEnumerator coroutine = base.SelectCardThisCardWillMoveNextTo(new LinqCardCriteria((Card c) => base.CanCardBeConsideredHighestHitPoints(c, (Card card) => card.IsHeroCharacterCard) && (additionalTurnTakerCriteria == null || additionalTurnTakerCriteria.Criteria(c.Owner)), "hero target with the lowest HP"), storedResults, isPutIntoPlay, decisionSources);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
//if we're given a hero to go to, go there
if (NextToHeroToGoTo != null)
{
storedResults.Add(new MoveCardDestination(NextToHeroToGoTo));
NextToHeroToGoTo = null;
yield break;
}
//Play this card next to a target.
IEnumerator coroutine = base.SelectCardThisCardWillMoveNextTo(new LinqCardCriteria((Card c) => c.IsTarget, "target"), storedResults, true, decisionSources);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
public override IEnumerator Play()
{
// "The {H - 2} players with the most cards in play each destroy 1 of their non-character cards."
// Find those players, store them as loadedHeroes...
List <TurnTaker> loadedHeroes = new List <TurnTaker>();
IEnumerator findPlayersCoroutine = base.FindHeroWithMostCardsInPlay(loadedHeroes, numberOfHeroes: base.H - 2);
if (base.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(findPlayersCoroutine));
}
else
{
this.GameController.ExhaustCoroutine(findPlayersCoroutine);
}
Log.Debug("LightenTheLoadCardController.Play: loadedHeroes.Count = " + loadedHeroes.Count.ToString());
foreach (TurnTaker hero in loadedHeroes)
{
Log.Debug(" " + hero.NameRespectingVariant);
}
LinqTurnTakerCriteria isListedHero = new LinqTurnTakerCriteria((TurnTaker tt) => tt.IsHero && loadedHeroes.Contains(tt));
// Ask each of them to destroy a card if they have at least 1 in play
List <DestroyCardAction> destroyAttempts = new List <DestroyCardAction>();
List <DestroyCardAction> playersDestroyed = new List <DestroyCardAction>();
if (GameController.FindCardsWhere(new LinqCardCriteria((Card c) => !c.IsCharacter && loadedHeroes.Contains(c.Owner))).Any())
{
SelectTurnTakersDecision destroyOrder = new SelectTurnTakersDecision(base.GameController, this.DecisionMaker, isListedHero, SelectionType.DestroyCard, numberOfTurnTakers: Game.H - 2, allowAutoDecide: true, cardSource: GetCardSource());
IEnumerator playersDestroyCoroutine = base.GameController.SelectTurnTakersAndDoAction(destroyOrder, (TurnTaker tt) => base.GameController.SelectAndDestroyCard(base.FindHeroTurnTakerController(tt.ToHero()), cardCriteria: new LinqCardCriteria((Card c) => !c.IsCharacter && c.Owner == tt, "non-character"), false, storedResultsAction: playersDestroyed, cardSource: GetCardSource()));
if (base.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(playersDestroyCoroutine));
}
else
{
this.GameController.ExhaustCoroutine(playersDestroyCoroutine);
}
}
// "Destroy a hero card in the villain play area."
List <DestroyCardAction> villainDestroyed = new List <DestroyCardAction>();
IEnumerator villainDestroyCoroutine = base.GameController.SelectAndDestroyCards(this.DecisionMaker, new LinqCardCriteria((Card c) => c.IsHero && c.Location.HighestRecursiveLocation == base.TurnTaker.FindCard("BreakawayCharacter").Location.HighestRecursiveLocation), new int?(1), storedResultsAction: villainDestroyed, responsibleCard: this.Card, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(villainDestroyCoroutine));
}
else
{
this.GameController.ExhaustCoroutine(villainDestroyCoroutine);
}
// "If a card was destroyed this way, {Breakaway} regains 2 HP."
DestroyCardAction villainAttempt = villainDestroyed.FirstOrDefault();
if (villainAttempt != null && villainAttempt.WasCardDestroyed)
{
IEnumerator hpGainCoroutine = base.GameController.GainHP(base.TurnTaker.FindCard("BreakawayCharacter"), 2, cardSource: GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(hpGainCoroutine));
}
else
{
this.GameController.ExhaustCoroutine(hpGainCoroutine);
}
}
// "Reduce the next damage dealt by each non-villain target by X, where X = 2 plus the number of cards destroyed by this card."
destroyAttempts = destroyAttempts.Concat(playersDestroyed).ToList();
destroyAttempts = destroyAttempts.Concat(villainDestroyed).ToList();
List <DestroyCardAction> destroySuccesses = destroyAttempts.FindAll((DestroyCardAction da) => da.WasCardDestroyed);
int reduction = 2 + destroySuccesses.Count();
// Do ReduceNextDamage for EACH non-villain target in play
foreach (Card nvt in base.GameController.FindTargetsInPlay((Card c) => c.IsNonVillainTarget))
{
IEnumerator reduceCoroutine = this.ReduceNextDamage(nvt, reduction);
if (base.UseUnityCoroutines)
{
yield return(this.GameController.StartCoroutine(reduceCoroutine));
}
else
{
this.GameController.ExhaustCoroutine(reduceCoroutine);
}
}
yield break;
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
List <Card> storedHeroes = new List <Card>();
IEnumerator routine = base.GameController.FindTargetWithLowestHitPoints(1,
c => c.IsHeroCharacterCard && !c.IsIncapacitatedOrOutOfGame && GameController.IsCardVisibleToCardSource(c, GetCardSource()),
storedHeroes, cardSource: this.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(routine));
}
else
{
base.GameController.ExhaustCoroutine(routine);
}
if (!storedHeroes.Any())
{
yield break;
}
routine = base.SelectCardThisCardWillMoveNextTo(new LinqCardCriteria(c => c == storedHeroes.First()),
storedResults, isPutIntoPlay, decisionSources);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(routine));
}
else
{
base.GameController.ExhaustCoroutine(routine);
}
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
IEnumerator coroutine = base.GameController.ChangeMaximumHP(base.Card, BaseHP + GetNumberOfRitualsInPlay(), true, cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
coroutine = base.DeterminePlayLocation(storedResults, isPutIntoPlay, decisionSources, overridePlayArea, additionalTurnTakerCriteria);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
//When this card enters play, place it next to the hero with the lowest HP.
IEnumerator coroutine = base.SelectCardThisCardWillMoveNextTo(new LinqCardCriteria((Card c) => base.CanCardBeConsideredLowestHitPoints(c, (Card card) => card.IsHeroCharacterCard && !card.IsIncapacitatedOrOutOfGame && GameController.IsCardVisibleToCardSource(card, GetCardSource())) && (additionalTurnTakerCriteria == null || additionalTurnTakerCriteria.Criteria(c.Owner)), "hero with the lowest hp"), storedResults, isPutIntoPlay, decisionSources);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
//Play this card next to the target with the lowest HP, other than {SwarmEater}. The target next to this card is Pursued.
List <Card> lowestCard = new List <Card>();
IEnumerator coroutine = base.GameController.FindTargetWithLowestHitPoints(1, (Card c) => c != base.CharacterCard, lowestCard, cardSource: base.GetCardSource());
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
Card selectedTarget = lowestCard.FirstOrDefault <Card>();
if (selectedTarget != null && storedResults != null)
{
//Play this card next to the target with the lowest HP, other than {SwarmEater}.
storedResults.Add(new MoveCardDestination(selectedTarget.NextToLocation, false, false, false));
}
yield break;
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
// "When this card enters play, move it next to a target."
IEnumerator selectCoroutine = SelectCardThisCardWillMoveNextTo(new LinqCardCriteria((Card c) => c.IsTarget, "targets", false), storedResults, isPutIntoPlay, decisionSources);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(selectCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(selectCoroutine);
}
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
// "When this card enters play, move it next to the hero with the most cards in hand."
List <TurnTaker> biggestHands = new List <TurnTaker>();
IEnumerator findCoroutine = FindHeroWithMostCardsInHand(biggestHands, ranking: 1, numberOfHeroes: 1, evenIfCannotDealDamage: true);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(findCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(findCoroutine);
}
TurnTaker player = biggestHands.FirstOrDefault();
if (player != null && storedResults != null)
{
List <Card> characterChoice = new List <Card>();
IEnumerator chooseCoroutine = FindCharacterCard(player, SelectionType.MoveCardNextToCard, characterChoice);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(chooseCoroutine));
}
else
{
base.GameController.ExhaustCoroutine(chooseCoroutine);
}
Card chosen = characterChoice.FirstOrDefault();
if (chosen != null)
{
storedResults.Add(new MoveCardDestination(chosen.NextToLocation));
}
}
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
//Play this card next to the hero character with the most cards in play.
List <TurnTaker> storedTurnTaker = new List <TurnTaker>();
IEnumerator coroutine = FindHeroWithMostCardsInPlay(storedTurnTaker, heroCriteria: new LinqTurnTakerCriteria(tt => GameController.IsTurnTakerVisibleToCardSource(tt, GetCardSource())));
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
if (storedTurnTaker is null || storedTurnTaker.Count == 0)
{
yield break;
}
TurnTaker selectedTurnTaker = storedTurnTaker.First();
coroutine = SelectCardThisCardWillMoveNextTo(new LinqCardCriteria((Card c) => c.Owner == selectedTurnTaker && c.IsHeroCharacterCard && !c.IsIncapacitatedOrOutOfGame && GameController.IsCardVisibleToCardSource(c, GetCardSource()) && (additionalTurnTakerCriteria == null || additionalTurnTakerCriteria.Criteria(c.Owner)), "active hero"), storedResults, isPutIntoPlay, decisionSources);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources,
Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
//When this card enters play, place it next to a hero character.
LinqCardCriteria validTargets = new LinqCardCriteria(c => c.IsHeroCharacterCard && c.IsTarget && c.IsInPlayAndHasGameText && (additionalTurnTakerCriteria == null || additionalTurnTakerCriteria.Criteria(c.Owner)), "hero character card");
IEnumerator routine = base.SelectCardThisCardWillMoveNextTo(validTargets, storedResults, isPutIntoPlay, decisionSources);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(routine));
}
else
{
base.GameController.ExhaustCoroutine(routine);
}
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
//"Play this card next to a non-character target.",
IEnumerator coroutine = SelectCardThisCardWillMoveNextTo(new LinqCardCriteria((Card c) => c.IsInPlayAndHasGameText && c.IsTarget && !c.IsCharacter), storedResults, isPutIntoPlay, decisionSources);
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
public override IEnumerator DeterminePlayLocation(List <MoveCardDestination> storedResults, bool isPutIntoPlay, List <IDecision> decisionSources, Location overridePlayArea = null, LinqTurnTakerCriteria additionalTurnTakerCriteria = null)
{
IEnumerator coroutine;
if (this.IsMakeshiftShelterInPlay())
{
coroutine = base.SelectCardThisCardWillMoveNextTo(new LinqCardCriteria((Card c) => c.IsHeroCharacterCard && !c.IsIncapacitatedOrOutOfGame && GameController.IsCardVisibleToCardSource(c, GetCardSource()) && (additionalTurnTakerCriteria == null || additionalTurnTakerCriteria.Criteria(c.Owner)), "active hero"), storedResults, isPutIntoPlay, decisionSources);
}
else
{
coroutine = base.GameController.SelectMoveCardDestination(base.DecisionMaker, base.Card, new[] { new MoveCardDestination(base.TurnTaker.PlayArea) }, storedResults, cardSource: base.GetCardSource());
}
if (base.UseUnityCoroutines)
{
yield return(base.GameController.StartCoroutine(coroutine));
}
else
{
base.GameController.ExhaustCoroutine(coroutine);
}
yield break;
}
