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? ShouldPlay1(TimingRuleParameters p) { if (p.Card.AttachedTo == null) return false; return CanBeDestroyed(p.Card.AttachedTo); }
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? ShouldPlay1(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); }
public override bool? ShouldPlay2(TimingRuleParameters p) { var controllerCount = p.Controller.Hand.Count; var opponentCount = p.Controller.Opponent.Hand.Count; return controllerCount - _minDifference <= 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; }
private bool EotRemoval(TimingRuleParameters p) { if (_combatOnly) return false; return IsEndOfOpponentsTurn(p.Controller); }
public override bool?ShouldPlay2(TimingRuleParameters p) { var controllerCount = p.Controller.Hand.Count; var opponentCount = p.Controller.Opponent.Hand.Count; return(controllerCount - _minDifference <= opponentCount); }
public override bool?ShouldPlay1(TimingRuleParameters p) { if (p.Card.AttachedTo == null) { return(false); } return(CanBeDestroyed(p.Card.AttachedTo)); }
public override bool? ShouldPlay1(TimingRuleParameters p) { if (p.Card.IsAttached) { return Turn.Step == Step.SecondMain; } return Turn.Step == Step.FirstMain; }
public override bool?ShouldPlay1(TimingRuleParameters p) { if (p.Card.IsAttached) { return(Turn.Step == Step.SecondMain); } return(Turn.Step == Step.FirstMain); }
public override bool? ShouldPlay1(TimingRuleParameters p) { if (Stack.IsEmpty) { return Turn.Step == Step.DeclareBlockers; } return (Stack.TopSpell.HasTag(EffectTag.DealDamage) || Stack.TopSpell.HasTag(EffectTag.Destroy)) && !Stack.TopSpell.HasTag(EffectTag.CannotRegenerate); }
public override bool?ShouldPlay1(TimingRuleParameters p) { if (Stack.IsEmpty) { return(Turn.Step == Step.DeclareBlockers); } return((Stack.TopSpell.HasTag(EffectTag.DealDamage) || Stack.TopSpell.HasTag(EffectTag.Destroy)) && !Stack.TopSpell.HasTag(EffectTag.CannotRegenerate)); }
public override bool? ShouldPlay1(TimingRuleParameters p) { if (p.Card.Has().Haste) return Turn.Step == Step.FirstMain; if (p.Card.Power < 2 || p.Card.Has().Defender) return Turn.Step == Step.SecondMain; return true; }
public override bool? ShouldPlay1(TimingRuleParameters p) { if (p.Card.Has().Indestructible) return false; if (Stack.CanBeDestroyedByTopSpell(p.Card)) return true; return Stack.IsEmpty && Turn.Step == Step.DeclareBlockers && Combat.CanBeDealtLeathalCombatDamage(p.Card); }
public override bool? ShouldPlay1(TimingRuleParameters p) { if (!Stack.IsEmpty) { return (Stack.TopSpell.HasTag(EffectTag.DealDamage) || Stack.TopSpell.HasTag(EffectTag.ReduceToughness) || Stack.TopSpell.HasTag(EffectTag.Destroy)) && !Stack.TopSpell.HasTag(EffectTag.CannotRegenerate); } return IsBeforeYouDeclareAttackers(p.Controller) || IsAfterOpponentDeclaresBlockers(p.Controller) || IsAfterYouDeclareBlockers(p.Controller) || (IsEndOfOpponentsTurn(p.Controller) && !_untilEot); }
public override bool?ShouldPlay1(TimingRuleParameters p) { if (!Stack.IsEmpty) { return((Stack.TopSpell.HasTag(EffectTag.DealDamage) || Stack.TopSpell.HasTag(EffectTag.ReduceToughness) || Stack.TopSpell.HasTag(EffectTag.Destroy)) && !Stack.TopSpell.HasTag(EffectTag.CannotRegenerate)); } return(IsBeforeYouDeclareAttackers(p.Controller) || IsAfterOpponentDeclaresBlockers(p.Controller) || IsAfterYouDeclareBlockers(p.Controller) || (IsEndOfOpponentsTurn(p.Controller) && !_untilEot)); }
public override bool? ShouldPlay2(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) { var opponent = p.Controller.Opponent; if (opponent.Hand.Count < _minCount) return false; if (_maxCount.HasValue && opponent.Hand.Count > _maxCount) return false; return 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; }
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? 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); }
public override bool ShouldPlayBeforeTargets(TimingRuleParameters p) { if (p.Card.Has().Haste) { return(Turn.Step == Step.FirstMain); } if (p.Card.Power < 2 || p.Card.Has().Defender) { return(Turn.Step == Step.SecondMain); } return(true); }
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 ShouldPlayBeforeTargets(TimingRuleParameters p) { if (p.Card.Has().Indestructible) { return(false); } if (Stack.CanBeDestroyedByTopSpell(p.Card)) { return(true); } return(Stack.IsEmpty && Turn.Step == Step.DeclareBlockers && Combat.CanBeDealtLeathalCombatDamage(p.Card)); }
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; }
public override bool?ShouldPlay2(TimingRuleParameters p) { var opponent = p.Controller.Opponent; if (opponent.Hand.Count < _minCount) { return(false); } if (_maxCount.HasValue && opponent.Hand.Count > _maxCount) { return(false); } return(true); }
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); }
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? ShouldPlay2(TimingRuleParameters p) { if (p.Card.Counters > 0 && CanBeDestroyed(p.Card)) return true; if (p.Card.Counters >= _minCount) { if (IsEndOfOpponentsTurn(p.Controller)) return true; if (_onlyAtEot) return false; return Stack.IsEmpty; } return false; }
public override bool? ShouldPlay1(TimingRuleParameters p) { // currently somehow limited because of performance reasons if (Turn.Step != Step.FirstMain && Turn.Step != Step.SecondMain) return false; var availableMana = p.Controller.GetAvailableConvertedMana() - _relativeCost; // only cards in hand foreach (var card in p.Controller.Hand) { if (card.ManaCost.Converted <= availableMana && !p.Controller.HasMana(card.ManaCost)) { return true; } } return false; }
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(); }
public override bool ShouldPlayBeforeTargets(TimingRuleParameters p) { // currently somehow limited because of performance reasons if (Turn.Step != Step.FirstMain && Turn.Step != Step.SecondMain) { return(false); } var availableMana = p.Controller.GetAvailableManaCount() - _relativeCost; // only cards in hand foreach (var card in p.Controller.Hand) { if (card.ManaCost.Converted <= availableMana && !p.Controller.HasMana(card.ManaCost)) { return(true); } } return(false); }
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?ShouldPlay2(TimingRuleParameters p) { if (p.Card.Counters > 0 && CanBeDestroyed(p.Card)) { return(true); } if (p.Card.Counters >= _minCount) { if (IsEndOfOpponentsTurn(p.Controller)) { return(true); } if (_onlyAtEot) { return(false); } return(Stack.IsEmpty); } return(false); }
public override bool?ShouldPlay2(TimingRuleParameters p) { return(Stack.CanTopSpellReducePlayersLifeToZero(p.Controller)); }
public override bool?ShouldPlay1(TimingRuleParameters p) { return(IsAfterYouDeclareAttackers(p.Controller) && Combat.AttackerCount > 0); }
public override bool?ShouldPlay1(TimingRuleParameters p) { return(p.Controller.IsActive && Turn.Step == _step && Stack.IsEmpty); }
public override bool?ShouldPlay1(TimingRuleParameters p) { return(Turn.Step == Step.FirstMain); }
public override bool ShouldPlayBeforeTargets(TimingRuleParameters p) { return(p.Controller.HasMana(_converted)); }
public override bool ShouldPlayBeforeTargets(TimingRuleParameters p) { return(Stack.IsEmpty); }
public override bool ShouldPlayBeforeTargets(TimingRuleParameters p) { return(p.Controller.IsActive && Turn.Step == Step.FirstMain && Stack.IsEmpty); }
public override bool? ShouldPlay2(TimingRuleParameters p) { return Players.Permanents().Count(x => _selector(x)) >= _minCount; }
public override bool? ShouldPlay2(TimingRuleParameters p) { return !Stack.HasSpellWithSource(p.Card); }
public override bool?ShouldPlay1(TimingRuleParameters p) { return(Turn.Step == Step.EndOfTurn && !p.Controller.IsActive && Stack.IsEmpty); }
public override bool?ShouldPlay1(TimingRuleParameters p) { return((Turn.Step == Step.FirstMain || Turn.Step == Step.SecondMain) && p.Controller.IsActive && Stack.IsEmpty); }
public override bool ShouldPlayBeforeTargets(TimingRuleParameters p) { return(IsBeforeYouDeclareAttackers(p.Controller)); }
public override bool?ShouldPlay1(TimingRuleParameters p) { return(!Stack.IsEmpty); }
public override bool?ShouldPlay1(TimingRuleParameters p) { return(IsAfterYouDeclareBlockers(p.Controller)); }
public override bool? ShouldPlay1(TimingRuleParameters p) { return p.Card.IsPermanent || p.Card.Is().Instant ? Instant(p) : Sorcery(p); }
public override bool?ShouldPlay1(TimingRuleParameters p) { return(IsEndOfOpponentsTurn(p.Controller)); }
public override bool? ShouldPlay1(TimingRuleParameters p) { return Turn.Step == _step && Stack.IsEmpty; }
public override bool ShouldPlayAfterTargets(TimingRuleParameters p) { return(!Stack.HasSpellWithSource(p.Card)); }
public override bool ShouldPlayBeforeTargets(TimingRuleParameters p) { return(IsAfterOpponentDeclaresBlockers(p.Controller)); }
public override bool ShouldPlayBeforeTargets(TimingRuleParameters p) { return(IsEndOfOpponentsTurn(p.Controller)); }
public override bool?ShouldPlay1(TimingRuleParameters p) { return(IsAfterOpponentDeclaresAttackers(p.Controller)); }
public override bool?ShouldPlay1(TimingRuleParameters p) { return(Turn.Step == _step && Stack.IsEmpty); }
public override bool ShouldPlayBeforeTargets(TimingRuleParameters p) { return(true); }
public override bool?ShouldPlay1(TimingRuleParameters p) { return(CanBeDestroyed(p.Card, _targetOnly, _considerCombat)); }