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);
        }
Example #8
0
        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);
        }
Example #13
0
        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;
        }
Example #20
0
        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;
            });
        }
Example #36
0
        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));
 }
Example #38
0
 public override bool?ShouldPlay1(TimingRuleParameters p)
 {
     return(IsAfterYouDeclareAttackers(p.Controller) && Combat.AttackerCount > 0);
 }
Example #39
0
 public override bool?ShouldPlay1(TimingRuleParameters p)
 {
     return(p.Controller.IsActive && Turn.Step == _step && Stack.IsEmpty);
 }
Example #40
0
 public override bool?ShouldPlay1(TimingRuleParameters p)
 {
     return(Turn.Step == Step.FirstMain);
 }
Example #41
0
 public override bool ShouldPlayBeforeTargets(TimingRuleParameters p)
 {
     return(p.Controller.HasMana(_converted));
 }
Example #42
0
 public override bool ShouldPlayBeforeTargets(TimingRuleParameters p)
 {
     return(Stack.IsEmpty);
 }
Example #43
0
 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);
 }
Example #46
0
 public override bool?ShouldPlay1(TimingRuleParameters p)
 {
     return(Turn.Step == Step.EndOfTurn && !p.Controller.IsActive && Stack.IsEmpty);
 }
Example #47
0
 public override bool?ShouldPlay1(TimingRuleParameters p)
 {
     return((Turn.Step == Step.FirstMain || Turn.Step == Step.SecondMain) && p.Controller.IsActive && Stack.IsEmpty);
 }
Example #48
0
 public override bool ShouldPlayBeforeTargets(TimingRuleParameters p)
 {
     return(IsBeforeYouDeclareAttackers(p.Controller));
 }
Example #49
0
 public override bool?ShouldPlay1(TimingRuleParameters p)
 {
     return(!Stack.IsEmpty);
 }
Example #50
0
 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);
 }
Example #52
0
 public override bool?ShouldPlay1(TimingRuleParameters p)
 {
     return(IsEndOfOpponentsTurn(p.Controller));
 }
Example #53
0
 public override bool? ShouldPlay1(TimingRuleParameters p)
 {
     return Turn.Step == _step && Stack.IsEmpty;
 }
 public override bool ShouldPlayAfterTargets(TimingRuleParameters p)
 {
     return(!Stack.HasSpellWithSource(p.Card));
 }
Example #55
0
 public override bool ShouldPlayBeforeTargets(TimingRuleParameters p)
 {
     return(IsAfterOpponentDeclaresBlockers(p.Controller));
 }
 public override bool ShouldPlayBeforeTargets(TimingRuleParameters p)
 {
     return(IsEndOfOpponentsTurn(p.Controller));
 }
Example #57
0
 public override bool?ShouldPlay1(TimingRuleParameters p)
 {
     return(IsAfterOpponentDeclaresAttackers(p.Controller));
 }
Example #58
0
 public override bool?ShouldPlay1(TimingRuleParameters p)
 {
     return(Turn.Step == _step && Stack.IsEmpty);
 }
 public override bool ShouldPlayBeforeTargets(TimingRuleParameters p)
 {
     return(true);
 }
Example #60
0
 public override bool?ShouldPlay1(TimingRuleParameters p)
 {
     return(CanBeDestroyed(p.Card, _targetOnly, _considerCombat));
 }