public override void OnPlay(AbstractBattleUnit target, EnergyPaidInformation energyPaid)
{
var twoOtherRandomCards = state().Deck.Hand.Where(item => item != this).Shuffle().TakeUpTo(2);
foreach (var card in twoOtherRandomCards)
{
card.PersistentCostModifiers.Add(new RestOfCombatCostModifier(-1));
}
}
public BuffSelfIntent(AbstractBattleUnit self,
AbstractStatusEffect statusEffect,
int stacks = 1) :
base(self,
IntentIcons.BuffIntent)
{
Stacks = stacks;
this.StatusEffect = statusEffect;
}
public override void OnPlay(AbstractBattleUnit target, EnergyPaidInformation energyPaid)
{
var leftmostAttack = BattleHelpers.LeftmostCardInHandThat(item => item.CardType == CardType.AttackCard);
if (leftmostAttack != null)
{
leftmostAttack.DamageModifiers.Add(new AppliesWeakDamageModifier());
}
}
public override void OnAnyCardPlayed(AbstractCard cardPlayed, AbstractBattleUnit targetOfCard, bool cardIsOwnedByMe)
{
SecondaryStacks++;
if (SecondaryStacks >= 3)
{
SecondaryStacks -= 3;
ActionManager.Instance.ApplyDefense(OwnerUnit, null, Stacks);
}
}
public static SpecialEffect DefaultMuzzleFlashEffect(AbstractBattleUnit source)
{
return(new SimpleSpecialEffect()
{
ProtoSystem = ProtoParticleSystem.MuzzleFlash,
SpawnAt = source,
LocationToHit = HardpointLocation.LEFT
});
}
public override void OnPlay(AbstractBattleUnit target, EnergyPaidInformation energyPaid)
{
for (int i = 0; i < 2; i++)
{
var targetedEnemy = state().EnemyUnitsInBattle.PickRandom();
action().AttackUnitForDamage(targetedEnemy, this.Owner, BaseDamage, this);
action().ApplyStatusEffect(targetedEnemy, new VulnerableStatusEffect(), 2);
action().ApplyStatusEffect(targetedEnemy, new WeakenedStatusEffect(), 2);
}
}
public override void ModifyCardsUponAcquisition(AbstractCard card, AbstractBattleUnit soldierAffected)
{
if (Stacks <= 0)
{
return;
}
Stacks--;
soldierAffected.AddCardToPersistentDeck(card.CopyCard());
soldierAffected.AddCardToPersistentDeck(card.CopyCard());
}
public override void OnAnyCardPlayed(AbstractCard cardPlayed, AbstractBattleUnit targetOfCard, bool ownedByMe)
{
if (cardPlayed.NameContains("grenade"))
{
for (int i = 0; i < this.Stacks; i++)
{
cardPlayed.EvokeCardEffect(targetOfCard);
}
}
}
public static List <AbstractIntent> StatusEffectToRandomPc(
AbstractBattleUnit source,
AbstractStatusEffect effect,
int stacks)
{
return(DebuffOtherIntent.StatusEffectToRandomPc(
source,
effect, stacks
).ToSingletonList <AbstractIntent>());
}
public static SingleUnitAttackIntent AttackRandomPc(AbstractBattleUnit source, int damage, int numTimesStruck)
{
var target = IntentTargeting.GetRandomLivingPlayerUnit();
if (target == null)
{
return(null);
}
return(new SingleUnitAttackIntent(source, target, damage, numTimesStruck));
}
public override void OnPlay(AbstractBattleUnit target, EnergyPaidInformation energyPaid)
{
this.Sacrifice(() =>
{
action().PushActionToBack("VolatileChemicals_OnPlay", () =>
{
state().energy += 2;
});
});
}
public override void OnAnyCardPlayed(AbstractCard cardPlayed, AbstractBattleUnit targetOfCard, bool isMine)
{
if (cardPlayed.NameContains("blood"))
{
foreach (var ally in state().AllyUnitsInBattle)
{
action().HealUnit(ally, Stacks, this.OwnerUnit);
}
}
}
public static DebuffOtherIntent StatusEffectToRandomPc(
AbstractBattleUnit source,
AbstractStatusEffect effect,
int stacks)
{
return(StatusEffect(source,
GameState.Instance.AllyUnitsInBattle.Where(item => !item.IsDead).PickRandom(),
effect,
stacks));
}
public override void OnThisCardPlayed(AbstractCard card, AbstractBattleUnit target)
{
if (card.Owner != null)
{
return;
}
ActionManager.Instance.DamageUnitNonAttack(card.Owner, null, 3);
ActionManager.Instance.ApplyStress(card.Owner, 3);
}
private void Populate(IEnumerable <AbstractCard> cardsToDisplay, AbstractBattleUnit battleUnit)
{
Require.NotNull(cardsToDisplay);
var displaysCreated = CardPresentationUtil.PopulateCards(cardsToDisplay, CardsDisplayed, CardTemplate.gameObject, CardParent.gameObject);
foreach (var display in displaysCreated)
{
display.GetComponent <AssignCardDisplay>().Init(battleUnit, display.GameCard.LogicalCard);
}
}
public override void OnPlay(AbstractBattleUnit target, EnergyPaidInformation energyPaid)
{
CardAbilityProcs.GainDataPoints(this, 5);
action().ApplyStress(target, 30);
var erosions = state().Deck.TotalDeckList.Where(item => item.CardType == CardType.ErosionCard);
var numberOfErosions = erosions.Count();
action().ApplyStatusEffect(target, new StrengthStatusEffect(), numberOfErosions);
Action_Exhaust();
}
public override void OnPlay(AbstractBattleUnit target, EnergyPaidInformation energyPaid)
{
action().DrawCards(2, performOnCards: (cards) =>
{
foreach (var card in cards)
{
card.RestOfTurnCostMod += -1;
}
});
}
public override void OnPlay(AbstractBattleUnit target, EnergyPaidInformation energyPaid)
{
action().AttackUnitForDamage(target, this.Owner, BaseDamage, this);
foreach (var otherTarget in enemies())
{
action().AttackUnitForDamage(otherTarget, this.Owner, BaseDamage, this);
}
action().ExhaustCard(this);
}
public ParticleSystemContainer GenerateSpecialEffectAtCharacter(AbstractBattleUnit unit,
ProtoParticleSystem particleSystem,
HardpointLocation locationToHit,
Action afterAnimationIsFinishedAction = null)
{
return(PlaceParticleSystem(particleSystem,
unit.CorrespondingPrefab.Hardpoints.FromHardpointLocation(locationToHit),
afterAnimationIsFinishedAction
));
}
public void FallBack(AbstractBattleUnit unit)
{
QueuedActions.ImmediateAction("FallBack", () =>
{
if (unit.HasStatusEffect <AdvancedStatusEffect>())
{
unit.RemoveStatusEffect <AdvancedStatusEffect>();
}
});
}
public override void OnPlay(AbstractBattleUnit target, EnergyPaidInformation energyPaid)
{
for (int i = 0; i < 2; i++)
{
var newCard = new Crusher();
newCard.BaseDamage += 10;
newCard.BaseDefenseValue += 10;
action().CreateCardToHand(newCard);
}
}
public override void OnPlay(AbstractBattleUnit target, EnergyPaidInformation energyPaid)
{
var attackCardFromDrawPile = state().Deck.DrawPile.Where(item => item.CardType == CardType.AttackCard).FirstOrDefault();
if (attackCardFromDrawPile != null)
{
attackCardFromDrawPile.RestOfTurnCostMod--;
attackCardFromDrawPile.BaseDamage += 4;
}
}
public override bool SlayInner(AbstractCard damageSource, AbstractBattleUnit target)
{
var gildedCard = damageSource.CorrespondingPermanentCard().GetStickerOfType <GildedCardSticker>();
if (gildedCard != null)
{
gildedCard.GildedValue += 2;
}
return(true);
}
public override void OnStruck(AbstractBattleUnit unitStriking, AbstractCard cardUsedIfAny, int totalDamageTaken)
{
if (cardUsedIfAny != null)
{
cardUsedIfAny.BaseDamage -= Stacks;
if (cardUsedIfAny.BaseDamage < 0)
{
cardUsedIfAny.BaseDamage = 0;
}
}
}
public void ApplyDefense(AbstractBattleUnit target, AbstractBattleUnit source, int baseQuantity)
{
QueuedActions.ImmediateAction("ApplyDefense", () =>
{
target.CurrentBlock += BattleRules.GetDefenseApplied(source, target, baseQuantity);
if (target.CurrentBlock < 0)
{
target.CurrentBlock = 0;
}
});
}
public override void OnPlay(AbstractBattleUnit target, EnergyPaidInformation energyPaid)
{
foreach (var character in state().EnemyUnitsInBattle)
{
action().ApplyStatusEffect(character, new WeakenedStatusEffect(), 1);
}
foreach (var ally in state().AllyUnitsInBattle)
{
action().ApplyDefense(ally, this.Owner, BaseDefenseValue);
}
}
public override void OnPlay(AbstractBattleUnit target, EnergyPaidInformation energyPaid)
{
foreach (var cardInHand in state().Deck.Hand)
{
cardInHand.AddSticker(new BasicAttackRandomEnemyForSpecificDamageSticker
{
Damage = 5
});
}
action().CreateCardToBattleDeckDiscardPile(new OntologicalWaste());
}
public static void Manuever(AbstractBattleUnit target)
{
if (target.HasStatusEffect <AdvancedStatusEffect>())
{
ActionManager.Instance.RemoveStatusEffect <AdvancedStatusEffect>(target);
}
else
{
ActionManager.Instance.ApplyStatusEffect(target, new AdvancedStatusEffect(), 1);
}
}
public override void OnPlay(AbstractBattleUnit target, EnergyPaidInformation energyPaid)
{
action().ApplyDefense(target, Owner, BaseDefenseValue);
var retaliateApplied = MagicNumber;
if (state().Deck.Hand.Any(item => item.HasSticker <GildedCardSticker>()))
{
retaliateApplied += 1;
}
action().ApplyStatusEffect(target, new RetaliateStatusEffect(), retaliateApplied);
}
public override void OnPlay(AbstractCard damageSource, AbstractBattleUnit target)
{
var otherPossibleTargets = GameState.Instance.EnemyUnitsInBattle
.Where(item => item != target)
.Where(item => item.IsTargetable())
.Shuffle()
.TakeUpTo(2)
.ToList();
ActionManager.Instance.AttackUnitForDamage(target, damageSource.Owner, damageSource.BaseDamage / 4, damageSource);
}
