public override bool ShouldPlayBeforeTargets(TimingRuleParameters p) { return (Stack.TopSpell != null && Stack.TopSpell.Controller == p.Controller.Opponent && Stack.TopSpell.Targets.Effect.Any(c => Target.Zone(c) == Zone.Graveyard)); }
public override bool ShouldPlayAfterTargets(TimingRuleParameters p) { if (!Stack.IsEmpty) { return(false); } if (!p.Controller.IsActive) { return(false); } if (Turn.Step != Step.SecondMain) { return(false); } var availableMana = p.Controller.GetAvailableManaCount( new ConvokeAndDelveOptions { CanUseConvoke = p.Card.Has().Convoke, CanUseDelve = p.Card.Has().Delve }); return(SpellsNeedMana(p, availableMana) || AbilitiesNeedMana(p, availableMana)); }
public override bool?ShouldPlay2(TimingRuleParameters p) { var controllerCount = p.Controller.Battlefield.Count(_selector); var opponentCount = p.Controller.Opponent.Battlefield.Count(_selector); return(controllerCount > opponentCount); }
public override bool?ShouldPlay2(TimingRuleParameters p) { var power = _power.GetValue(p.X); var toughness = _toughness.GetValue(p.X); if (toughness > 0 && Stack.CanBeDealtLeathalDamageByTopSpell(p.Card)) { return(true); } if (IsAfterOpponentDeclaresBlockers(p.Controller) && p.Card.IsAttacker) { return(QuickCombat.CalculateGainAttackerWouldGetIfPowerAndThoughnessWouldIncrease( attacker: p.Card, blockers: Combat.GetBlockers(p.Card), powerIncrease: power, toughnessIncrease: toughness) > 0); } if (IsAfterYouDeclareBlockers(p.Controller) && p.Card.IsBlocker) { return(QuickCombat.CalculateGainBlockerWouldGetIfPowerAndThougnessWouldIncrease( blocker: p.Card, attacker: Combat.GetAttacker(p.Card), powerIncrease: power, toughnessIncrease: toughness) > 0); } return(false); }
public override bool ShouldPlayBeforeTargets(TimingRuleParameters p) { var level = p.Card.Level ?? 0; int?costToNextLevel = null; foreach (var definition in _levelDefinitions) { if (definition.Max == null) { break; } if (level < definition.Min) { costToNextLevel = definition.Min - level; break; } if (definition.Min <= level && definition.Max >= level) { costToNextLevel = definition.Max + 1 - level; break; } } if (costToNextLevel == null) { return(false); } var totalCostToNextLevel = _cost.Repeat(costToNextLevel.Value); return(p.Controller.HasMana(totalCostToNextLevel, ManaUsage.Abilities)); }
private bool AbilitiesNeedMana(TimingRuleParameters p, int availableMana) { return(p.Controller.Battlefield.Any(x => { var manaCosts = x.GetActivatedAbilitiesManaCost(); foreach (var manaCost in manaCosts) { if (manaCost.Converted <= availableMana) { continue; } if (_amount == null) { return true; } if (manaCost.Converted <= availableMana + _amount) { return true; } } return false; })); }
public override bool?ShouldPlay1(TimingRuleParameters p) { if (StackHasInterestingSpells()) { return(true); } if (IsBeforeYouDeclareAttackers(p.Controller)) { return(p.Controller.Opponent.Battlefield.CreaturesThatCanBlock.Count() > 0); } if (IsAfterOpponentDeclaresAttackers(p.Controller)) { return(Combat.Attackers.Count() > 0); } if (Stack.CanBeDestroyedByTopSpell(p.Card)) { return(true); } if (IsEndOfOpponentsTurn(p.Controller)) { return(true); } return(false); }
public override bool ShouldPlayBeforeTargets(TimingRuleParameters p) { _cached = _rules .Where(rule => !rule.ShouldPlayBeforeTargets(p)) .ToList(); return(_cached.Count < _rules.Count); }
private bool EotRemoval(TimingRuleParameters p) { if (_combatOnly) { return(false); } return(IsEndOfOpponentsTurn(p.Controller)); }
public void Process1(ActivationContext c) { var p = new TimingRuleParameters(c.Card); var result = ShouldPlayBeforeTargets(p); if (result == false) { c.CancelActivation = true; } }
public override bool?ShouldPlay2(TimingRuleParameters p) { bool?result = null; foreach (var rule in _rules) { result = rule.ShouldPlay2(p); if (result == true) { return(true); } } return(result); }
public override bool ShouldPlayAfterTargets(TimingRuleParameters p) { var result = true; if (_minCount.HasValue) { result = result && p.Controller.Hand.Count(_selector) >= _minCount; } if (_maxCount.HasValue) { result = result && p.Controller.Hand.Count(_selector) <= _maxCount; } return(result); }
public override bool?ShouldPlay2(TimingRuleParameters p) { foreach (var target in p.Targets <Card>()) { if (TargetCreatureRemoval(target, p)) { return(true); } if (TargetAuraRemoval(target, p)) { return(true); } } return(EotRemoval(p)); }
public override bool?ShouldPlay2(TimingRuleParameters p) { if (Stack.IsEmpty) { return(false); } if (Stack.TopSpell.Controller == p.Controller) { return(false); } var counterCost = _counterCost(p); return(!counterCost.HasValue || !p.Controller.Opponent.HasMana(counterCost.Value)); }
private bool SpellsNeedMana(TimingRuleParameters p, int availableMana) { return(p.Controller.Hand.Any(x => { if (x.ConvertedCost <= availableMana) { return false; } if (_amount == null) { return true; } return x.ConvertedCost <= availableMana + _amount; })); }
public override bool ShouldPlayAfterTargets(TimingRuleParameters p) { if (Stack.IsEmpty) { return(false); } var spellController = Stack.TopSpell.Controller; if (_controlledBy == ControlledBy.Any || spellController == p.Controller && _controlledBy == ControlledBy.SpellOwner || spellController != p.Controller && _controlledBy == ControlledBy.Opponent) { return(_selector(Stack.TopSpell.Source.OwningCard)); } return(false); }
public override bool?ShouldPlay2(TimingRuleParameters p) { var result = true; var count = p.Controller.Graveyard.Count(c => _selector(c, Game)); if (_minCount.HasValue) { result = count >= _minCount; } if (_maxCount.HasValue) { result = result && count <= _maxCount; } return(result); }
public override bool?ShouldPlay1(TimingRuleParameters p) { // quick check before target generation if (Stack.IsEmpty) { if (_removalTags.Contains(EffectTag.DealDamage) || _removalTags.Contains(EffectTag.CreaturesOnly) || _removalTags.Contains(EffectTag.ReduceToughness) || _removalTags.Contains(EffectTag.Humble) || _removalTags.Contains(EffectTag.CombatDisabler)) { return(IsBeforeYouDeclareAttackers(p.Controller) || IsBeforeYouDeclareBlockers(p.Controller) || IsEndOfOpponentsTurn(p.Controller)); } return(IsBeforeYouDeclareAttackers(p.Controller) || IsBeforeYouDeclareBlockers(p.Controller) || IsAfterOpponentDeclaresAttackers(p.Controller) || IsAfterOpponentDeclaresAttackers(p.Controller) || IsEndOfOpponentsTurn(p.Controller)); } return(StackHasInterestingSpells()); }
private bool TargetAuraRemoval(Card target, TimingRuleParameters p) { if ((!target.Is().Aura&& !target.Is().Equipment) || target.AttachedTo == null) { return(false); } if (IsAfterOpponentDeclaresBlockers(p.Controller) && target.AttachedTo.IsBlocker) { return(true); } if (IsAfterOpponentDeclaresAttackers(p.Controller) && target.AttachedTo.IsAttacker) { return(true); } return(false); }
public void Process2(ActivationContext c) { if (c.HasTargets == false) { // timing aplied before targeting, or // spell with no targets, evaluate just // one possiblility var p = new TimingRuleParameters(c.Card, x: c.X); var result = ShouldPlayAfterTargets(p); if (result == false) { c.CancelActivation = true; } return; } // check each target timing, if ok keep // the target otherwise remove it var targetsCombinations = c.TargetsCombinations().ToList(); foreach (var targetsCombination in targetsCombinations) { var p = new TimingRuleParameters(c.Card, targetsCombination.Targets, targetsCombination.X); var result = ShouldPlayAfterTargets(p); if (result == false) { c.RemoveTargetCombination(targetsCombination); } } if (c.TargetsCombinations().None()) { // if not targets are appropriate, cancel activation c.CancelActivation = true; } }
public override bool?ShouldPlay2(TimingRuleParameters p) { if (!Stack.IsEmpty) { return(false); } if (!p.Controller.IsActive) { return(false); } if (Turn.Step != Step.SecondMain) { return(false); } var availableMana = p.Controller.GetAvailableConvertedMana(); return(SpellsNeedMana(p, availableMana) || AbilitiesNeedMana(p, availableMana)); }
private bool Sorcery(TimingRuleParameters p) { var opponentCreatureCount = p.Controller.Opponent.Battlefield.Creatures.Count(); if (opponentCreatureCount == 0) { return(false); } if (opponentCreatureCount == 1) { return(Turn.Step == Step.FirstMain); } if (opponentCreatureCount > 2 * _count + 1) { return(false); } return(Turn.Step == Step.SecondMain); }
private bool Instant(TimingRuleParameters p) { var opponentCreatureCount = p.Controller.Opponent.Battlefield.Creatures.Count(); if (opponentCreatureCount == 0) { return(false); } if (opponentCreatureCount == 1) { return(IsBeforeYouDeclareBlockers(p.Controller) || IsBeforeYouDeclareAttackers(p.Controller)); } if (opponentCreatureCount > 2 * _count + 1) { return(false); } return(IsEndOfOpponentsTurn(p.Controller)); }
public override bool ShouldPlayAfterTargets(TimingRuleParameters p) { foreach (var target in p.Targets <Card>()) { if (target.Controller == p.Controller) { continue; } if (TargetCreatureRemoval(target, p)) { return(true); } if (TargetAuraRemoval(target, p)) { return(true); } } return(EotRemoval(p)); }
private bool TargetCreatureRemoval(Card target, TimingRuleParameters p) { if (!target.Is().Creature) { return(false); } if (IsBeforeYouDeclareAttackers(p.Controller)) { return(target.CanBlock()); } if (IsBeforeYouDeclareBlockers(p.Controller)) { return(target.IsAttacker); } if (_combatOnly) { return(false); } if (StackHasInterestingSpells()) { if (Stack.TopSpell.HasEffectTargets()) { return(Stack.TopSpell.HasEffectTarget(target)); } // e.g Nantuko Shade gives self a +1/+1 boost if (Stack.TopSpell.TargetsEffectSource) { return(target == Stack.TopSpell.Source.OwningCard); } } return(false); }
public virtual bool ShouldPlayBeforeTargets(TimingRuleParameters p) { return(true); }
public override bool ShouldPlayAfterTargets(TimingRuleParameters p) { return(_rules.Select(rule => !_cached.Contains(rule) && rule.ShouldPlayAfterTargets(p)).Any(x => x)); }
public override bool ShouldPlayAfterTargets(TimingRuleParameters p) { return(Players.Permanents().Count(x => _selector(x) && x.Controller != p.Controller) >= _minCount); }
public override bool?ShouldPlay1(TimingRuleParameters p) { return(p.Card.IsPermanent || p.Card.Is().Instant ? Instant(p) : Sorcery(p)); }
public override bool?ShouldPlay2(TimingRuleParameters p) { return(Players.Permanents().Count(x => _selector(x)) >= _minCount); }