From 160647c7cb3fa60ce03830f95c2e2c0219784023 Mon Sep 17 00:00:00 2001 From: fireshoes Date: Fri, 7 Jul 2017 01:11:27 -0500 Subject: [PATCH] [HOU] Added several cards --- Mage.Sets/src/mage/cards/i/IpnuRivulet.java | 91 ++++++++ Mage.Sets/src/mage/cards/j/JacesDefeat.java | 121 ++++++++++ .../src/mage/cards/k/KefnetsLastWord.java | 67 ++++++ Mage.Sets/src/mage/cards/l/LethalSting.java | 115 ++++++++++ .../src/mage/cards/m/MajesticMyriarch.java | 208 ++++++++++++++++++ ...reElemental.java => ManticoreEternal.java} | 14 +- .../src/mage/cards/m/MercilessEternal.java | 75 +++++++ Mage.Sets/src/mage/cards/m/MirageMirror.java | 100 +++++++++ Mage.Sets/src/mage/cards/n/NissasDefeat.java | 120 ++++++++++ Mage.Sets/src/mage/cards/o/ObeliskSpider.java | 125 +++++++++++ Mage.Sets/src/mage/cards/r/RamunapRuins.java | 93 ++++++++ .../src/mage/sets/HourOfDevastation.java | 11 +- .../main/java/mage/filter/StaticFilters.java | 7 + 13 files changed, 1134 insertions(+), 13 deletions(-) create mode 100644 Mage.Sets/src/mage/cards/i/IpnuRivulet.java create mode 100644 Mage.Sets/src/mage/cards/j/JacesDefeat.java create mode 100644 Mage.Sets/src/mage/cards/k/KefnetsLastWord.java create mode 100644 Mage.Sets/src/mage/cards/l/LethalSting.java create mode 100644 Mage.Sets/src/mage/cards/m/MajesticMyriarch.java rename Mage.Sets/src/mage/cards/m/{ManticoreElemental.java => ManticoreEternal.java} (62%) create mode 100644 Mage.Sets/src/mage/cards/m/MercilessEternal.java create mode 100644 Mage.Sets/src/mage/cards/m/MirageMirror.java create mode 100644 Mage.Sets/src/mage/cards/n/NissasDefeat.java create mode 100644 Mage.Sets/src/mage/cards/o/ObeliskSpider.java create mode 100644 Mage.Sets/src/mage/cards/r/RamunapRuins.java diff --git a/Mage.Sets/src/mage/cards/i/IpnuRivulet.java b/Mage.Sets/src/mage/cards/i/IpnuRivulet.java new file mode 100644 index 00000000000..1d63f3d2924 --- /dev/null +++ b/Mage.Sets/src/mage/cards/i/IpnuRivulet.java @@ -0,0 +1,91 @@ +/* + * Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of BetaSteward_at_googlemail.com. + */ +package mage.cards.i; + +import java.util.UUID; +import mage.abilities.Ability; +import mage.abilities.common.SimpleActivatedAbility; +import mage.abilities.costs.common.PayLifeCost; +import mage.abilities.costs.common.SacrificeTargetCost; +import mage.abilities.costs.common.TapSourceCost; +import mage.abilities.costs.mana.ManaCostsImpl; +import mage.abilities.effects.common.PutLibraryIntoGraveTargetEffect; +import mage.abilities.mana.BlueManaAbility; +import mage.abilities.mana.ColorlessManaAbility; +import mage.cards.CardImpl; +import mage.cards.CardSetInfo; +import mage.constants.CardType; +import mage.constants.SubType; +import mage.constants.Zone; +import mage.filter.common.FilterControlledPermanent; +import mage.filter.predicate.mageobject.SubtypePredicate; +import mage.target.TargetPlayer; +import mage.target.common.TargetControlledPermanent; + +/** + * + * @author fireshoes + */ +public class IpnuRivulet extends CardImpl { + + private static final FilterControlledPermanent filter = new FilterControlledPermanent("Desert"); + + static { + filter.add(new SubtypePredicate(SubType.DESERT)); + } + + public IpnuRivulet(UUID ownerId, CardSetInfo setInfo) { + super(ownerId, setInfo, new CardType[]{CardType.LAND}, ""); + + this.subtype.add("Desert"); + + // {t}: Add {C} to your mana pool. + this.addAbility(new ColorlessManaAbility()); + + // {t}, Pay 1 life: Add {U} to your mana pool. + Ability manaAbility = new BlueManaAbility(); + manaAbility.addCost(new PayLifeCost(1)); + this.addAbility(manaAbility); + + // {1}{U}, {t}, Sacrifice a Desert: Target player puts the top four cards of his or her library into his or her graveyard. + Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new PutLibraryIntoGraveTargetEffect(4), new ManaCostsImpl("{1}{U}")); + ability.addCost(new TapSourceCost()); + ability.addCost(new SacrificeTargetCost(new TargetControlledPermanent(1, 1, filter, true))); + ability.addTarget(new TargetPlayer()); + this.addAbility(ability); + } + + public IpnuRivulet(final IpnuRivulet card) { + super(card); + } + + @Override + public IpnuRivulet copy() { + return new IpnuRivulet(this); + } +} diff --git a/Mage.Sets/src/mage/cards/j/JacesDefeat.java b/Mage.Sets/src/mage/cards/j/JacesDefeat.java new file mode 100644 index 00000000000..225ee8b5432 --- /dev/null +++ b/Mage.Sets/src/mage/cards/j/JacesDefeat.java @@ -0,0 +1,121 @@ +/* + * Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of BetaSteward_at_googlemail.com. + */ +package mage.cards.j; + +import java.util.UUID; +import mage.MageObject; +import mage.ObjectColor; +import mage.abilities.Ability; +import mage.abilities.effects.OneShotEffect; +import mage.cards.CardImpl; +import mage.cards.CardSetInfo; +import mage.constants.CardType; +import mage.constants.Outcome; +import mage.constants.SubType; +import mage.filter.FilterSpell; +import mage.filter.predicate.mageobject.CardTypePredicate; +import mage.filter.predicate.mageobject.ColorPredicate; +import mage.filter.predicate.mageobject.SubtypePredicate; +import mage.game.Game; +import mage.game.stack.Spell; +import mage.players.Player; +import mage.target.TargetSpell; + +/** + * + * @author fireshoes + */ +public class JacesDefeat extends CardImpl { + + private static final FilterSpell filter = new FilterSpell("blue spell"); + + static { + filter.add(new ColorPredicate(ObjectColor.BLUE)); + } + + public JacesDefeat(UUID ownerId, CardSetInfo setInfo) { + super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{1}{U}"); + + // Counter target blue spell. If it was a Jace planeswalker spell, scry 2. + this.getSpellAbility().addEffect(new JacesDefeatEffect()); + this.getSpellAbility().addTarget(new TargetSpell(filter)); + } + + public JacesDefeat(final JacesDefeat card) { + super(card); + } + + @Override + public JacesDefeat copy() { + return new JacesDefeat(this); + } +} + +class JacesDefeatEffect extends OneShotEffect { + + private static final FilterSpell filter = new FilterSpell(); + + static { + filter.add(new CardTypePredicate(CardType.PLANESWALKER)); + filter.add(new SubtypePredicate(SubType.JACE)); + } + + public JacesDefeatEffect() { + super(Outcome.Damage); + this.staticText = "Counter target blue spell. If it was a Jace planeswalker spell, scry 2."; + } + + public JacesDefeatEffect(final JacesDefeatEffect effect) { + super(effect); + } + + @Override + public JacesDefeatEffect copy() { + return new JacesDefeatEffect(this); + } + + @Override + public boolean apply(Game game, Ability source) { + MageObject sourceObject = game.getObject(source.getSourceId()); + if (sourceObject != null) { + for (UUID targetId : getTargetPointer().getTargets(game, source) ) { + Spell spell = game.getStack().getSpell(targetId); + if (spell != null) { + game.getStack().counter(targetId, source.getSourceId(), game); + Player controller = game.getPlayer(source.getControllerId()); + // If it was a Jace planeswalker, you may discard a card. If you do, draw a card + if (filter.match(spell, game) && controller != null) { + controller.scry(2, source, game); + } + } + } + return true; + } + return false; + } +} diff --git a/Mage.Sets/src/mage/cards/k/KefnetsLastWord.java b/Mage.Sets/src/mage/cards/k/KefnetsLastWord.java new file mode 100644 index 00000000000..56676ce1b0f --- /dev/null +++ b/Mage.Sets/src/mage/cards/k/KefnetsLastWord.java @@ -0,0 +1,67 @@ +/* + * Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of BetaSteward_at_googlemail.com. + */ +package mage.cards.k; + +import java.util.UUID; +import mage.abilities.effects.common.DontUntapInControllersUntapStepAllEffect; +import mage.abilities.effects.common.continuous.GainControlTargetEffect; +import mage.cards.CardImpl; +import mage.cards.CardSetInfo; +import mage.constants.CardType; +import mage.constants.Duration; +import mage.constants.TargetController; +import mage.filter.StaticFilters; +import mage.filter.common.FilterControlledLandPermanent; +import mage.target.TargetPermanent; + +/** + * + * @author fireshoes + */ +public class KefnetsLastWord extends CardImpl { + + public KefnetsLastWord(UUID ownerId, CardSetInfo setInfo) { + super(ownerId, setInfo, new CardType[]{CardType.SORCERY}, "{2}{U}{U}"); + + // Gain control of target artifact, creature or enchantment. Lands you control don't untap during your next untap step. + this.getSpellAbility().addTarget(new TargetPermanent(StaticFilters.FILTER_PERMANENT_ARTIFACT_CREATURE_OR_ENCHANTMENT)); + this.getSpellAbility().addEffect(new GainControlTargetEffect(Duration.Custom)); + this.getSpellAbility().addEffect(new DontUntapInControllersUntapStepAllEffect( + Duration.UntilYourNextTurn, TargetController.YOU, new FilterControlledLandPermanent("Lands you control")) + .setText("Lands you control don't untap during your next untap phase")); + } + + public KefnetsLastWord(final KefnetsLastWord card) { + super(card); + } + + @Override + public KefnetsLastWord copy() { + return new KefnetsLastWord(this); + } +} diff --git a/Mage.Sets/src/mage/cards/l/LethalSting.java b/Mage.Sets/src/mage/cards/l/LethalSting.java new file mode 100644 index 00000000000..c341d1dda2a --- /dev/null +++ b/Mage.Sets/src/mage/cards/l/LethalSting.java @@ -0,0 +1,115 @@ +/* + * Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of BetaSteward_at_googlemail.com. + */ +package mage.cards.l; + +import java.util.UUID; +import mage.abilities.Ability; +import mage.abilities.costs.Cost; +import mage.abilities.costs.CostImpl; +import mage.abilities.effects.common.DestroyTargetEffect; +import mage.cards.CardImpl; +import mage.cards.CardSetInfo; +import mage.constants.CardType; +import mage.constants.Outcome; +import mage.counters.CounterType; +import mage.filter.common.FilterCreaturePermanent; +import mage.game.Game; +import mage.game.permanent.Permanent; +import mage.players.Player; +import mage.target.Target; +import mage.target.common.TargetControlledCreaturePermanent; +import mage.target.common.TargetCreaturePermanent; + +/** + * + * @author fireshoes + */ +public class LethalSting extends CardImpl { + + public LethalSting(UUID ownerId, CardSetInfo setInfo) { + super(ownerId, setInfo, new CardType[]{CardType.SORCERY}, "{2}{B}"); + + // As an additional cost to cast Lethal Sting, put a -1/-1 counter on a creature you control. + this.getSpellAbility().addCost(new LethalStingCost()); + + // Destroy target creature. + this.getSpellAbility().addEffect(new DestroyTargetEffect()); + this.getSpellAbility().addTarget(new TargetCreaturePermanent()); + } + + public LethalSting(final LethalSting card) { + super(card); + } + + @Override + public LethalSting copy() { + return new LethalSting(this); + } +} + +class LethalStingCost extends CostImpl { + + public LethalStingCost() { + this.text = "put a -1/-1 counter on a creature you control"; + } + + public LethalStingCost(LethalStingCost cost) { + super(cost); + } + + @Override + public boolean canPay(Ability ability, UUID sourceId, UUID controllerId, Game game) { + for (Permanent permanent : game.getBattlefield().getAllActivePermanents(new FilterCreaturePermanent(), controllerId, game)) { + return permanent != null; + } + return false; + } + + @Override + public boolean pay(Ability ability, Game game, UUID sourceId, UUID controllerId, boolean noMana, Cost costToPay) { + Player controller = game.getPlayer(ability.getControllerId()); + if (controller != null) { + Target target = new TargetControlledCreaturePermanent(); + target.setNotTarget(true); + controller.chooseTarget(Outcome.UnboostCreature, target, ability, game); + Permanent permanent = game.getPermanent(target.getFirstTarget()); + if (permanent != null) { + permanent.addCounters(CounterType.M1M1.createInstance(), ability, game); + game.informPlayers(controller.getLogName() + " puts a -1/-1 counter on " + permanent.getLogName()); + this.paid = true; + } + + } + return paid; + } + + @Override + public LethalStingCost copy() { + return new LethalStingCost(this); + } +} diff --git a/Mage.Sets/src/mage/cards/m/MajesticMyriarch.java b/Mage.Sets/src/mage/cards/m/MajesticMyriarch.java new file mode 100644 index 00000000000..506126d24e1 --- /dev/null +++ b/Mage.Sets/src/mage/cards/m/MajesticMyriarch.java @@ -0,0 +1,208 @@ +/* + * Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of BetaSteward_at_googlemail.com. + */ +package mage.cards.m; + +import java.util.UUID; +import mage.MageInt; +import mage.abilities.Ability; +import mage.abilities.common.BeginningOfCombatTriggeredAbility; +import mage.abilities.common.SimpleStaticAbility; +import mage.abilities.dynamicvalue.DynamicValue; +import mage.abilities.dynamicvalue.MultipliedValue; +import mage.abilities.dynamicvalue.common.PermanentsOnBattlefieldCount; +import mage.abilities.effects.Effect; +import mage.abilities.effects.OneShotEffect; +import mage.abilities.effects.common.continuous.GainAbilitySourceEffect; +import mage.abilities.effects.common.continuous.SetPowerToughnessSourceEffect; +import mage.abilities.keyword.DeathtouchAbility; +import mage.abilities.keyword.DoubleStrikeAbility; +import mage.abilities.keyword.FirstStrikeAbility; +import mage.abilities.keyword.FlyingAbility; +import mage.abilities.keyword.HasteAbility; +import mage.abilities.keyword.HexproofAbility; +import mage.abilities.keyword.IndestructibleAbility; +import mage.abilities.keyword.LifelinkAbility; +import mage.abilities.keyword.MenaceAbility; +import mage.abilities.keyword.ReachAbility; +import mage.abilities.keyword.TrampleAbility; +import mage.abilities.keyword.VigilanceAbility; +import mage.cards.CardImpl; +import mage.cards.CardSetInfo; +import mage.constants.CardType; +import mage.constants.Duration; +import mage.constants.Outcome; +import mage.constants.TargetController; +import mage.constants.Zone; +import mage.filter.common.FilterControlledCreaturePermanent; +import mage.filter.predicate.mageobject.AbilityPredicate; +import mage.game.Game; + +/** + * + * @author fireshoes + */ +public class MajesticMyriarch extends CardImpl { + + public MajesticMyriarch(UUID ownerId, CardSetInfo setInfo) { + super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{4}{G}"); + + this.subtype.add("Chimera"); + this.power = new MageInt(0); + this.toughness = new MageInt(0); + + // Majestic Myriarch's power and toughness are each equal to twice the number of creatures you control. + DynamicValue xValue= new MultipliedValue(new PermanentsOnBattlefieldCount(new FilterControlledCreaturePermanent()), 2); + Effect effect = new SetPowerToughnessSourceEffect(xValue, Duration.EndOfGame); + effect.setText("{this}'s power and toughness are each equal to twice the number of creatures you control"); + this.addAbility(new SimpleStaticAbility(Zone.ALL, effect)); + + // At the beginning of each combat, if you control a creature with flying, Majestic Myriarch gains flying until end of turn. + // The same is true for first strike, double strike, deathtouch, haste, hexproof, indestructible, lifelink, menace, reach, trample, and vigilance. + this.addAbility(new BeginningOfCombatTriggeredAbility(new MajesticMyriarchEffect(), TargetController.ANY, false)); + } + + public MajesticMyriarch(final MajesticMyriarch card) { + super(card); + } + + @Override + public MajesticMyriarch copy() { + return new MajesticMyriarch(this); + } +} + +class MajesticMyriarchEffect extends OneShotEffect { + + private static final FilterControlledCreaturePermanent filterFirstStrike = new FilterControlledCreaturePermanent(); + private static final FilterControlledCreaturePermanent filterFlying = new FilterControlledCreaturePermanent(); + private static final FilterControlledCreaturePermanent filterDeathtouch = new FilterControlledCreaturePermanent(); + private static final FilterControlledCreaturePermanent filterDoubleStrike = new FilterControlledCreaturePermanent(); + private static final FilterControlledCreaturePermanent filterHaste = new FilterControlledCreaturePermanent(); + private static final FilterControlledCreaturePermanent filterHexproof = new FilterControlledCreaturePermanent(); + private static final FilterControlledCreaturePermanent filterIndestructible = new FilterControlledCreaturePermanent(); + private static final FilterControlledCreaturePermanent filterLifelink = new FilterControlledCreaturePermanent(); + private static final FilterControlledCreaturePermanent filterMenace = new FilterControlledCreaturePermanent(); + private static final FilterControlledCreaturePermanent filterReach = new FilterControlledCreaturePermanent(); + private static final FilterControlledCreaturePermanent filterTrample = new FilterControlledCreaturePermanent(); + private static final FilterControlledCreaturePermanent filterVigilance = new FilterControlledCreaturePermanent(); + + static { + filterFirstStrike.add(new AbilityPredicate(FirstStrikeAbility.class)); + filterFlying.add(new AbilityPredicate(FlyingAbility.class)); + filterDeathtouch.add(new AbilityPredicate(DeathtouchAbility.class)); + filterDoubleStrike.add(new AbilityPredicate(DoubleStrikeAbility.class)); + filterHaste.add(new AbilityPredicate(HasteAbility.class)); + filterHexproof.add(new AbilityPredicate(HexproofAbility.class)); + filterIndestructible.add(new AbilityPredicate(IndestructibleAbility.class)); + filterLifelink.add(new AbilityPredicate(LifelinkAbility.class)); + filterMenace.add(new AbilityPredicate(MenaceAbility.class)); + filterReach.add(new AbilityPredicate(ReachAbility.class)); + filterTrample.add(new AbilityPredicate(TrampleAbility.class)); + filterVigilance.add(new AbilityPredicate(VigilanceAbility.class)); + } + + MajesticMyriarchEffect() { + super(Outcome.BoostCreature); + this.staticText = "if you control a creature with flying, Majestic Myriarch gains flying until end of turn. " + + "The same is true for first strike, double strike, deathtouch, haste, hexproof, indestructible, lifelink, menace, reach, trample, and vigilance."; + } + + MajesticMyriarchEffect(final MajesticMyriarchEffect effect) { + super(effect); + } + + @Override + public MajesticMyriarchEffect copy() { + return new MajesticMyriarchEffect(this); + } + + @Override + public boolean apply(Game game, Ability source) { + + // Flying + if (game.getBattlefield().contains(filterFlying, source.getControllerId(), 1, game)) { + game.addEffect(new GainAbilitySourceEffect(FlyingAbility.getInstance(), Duration.EndOfTurn), source); + } + + // First strike + if (game.getBattlefield().contains(filterFirstStrike, source.getControllerId(), 1, game)) { + game.addEffect(new GainAbilitySourceEffect(FirstStrikeAbility.getInstance(), Duration.EndOfTurn), source); + } + + // Double strike + if (game.getBattlefield().contains(filterDoubleStrike, source.getControllerId(), 1, game)) { + game.addEffect(new GainAbilitySourceEffect(DoubleStrikeAbility.getInstance(), Duration.EndOfTurn), source); + } + + // Deathtouch + if (game.getBattlefield().contains(filterDeathtouch, source.getControllerId(), 1, game)) { + game.addEffect(new GainAbilitySourceEffect(DeathtouchAbility.getInstance(), Duration.EndOfTurn), source); + } + + // Haste + if (game.getBattlefield().contains(filterHaste, source.getControllerId(), 1, game)) { + game.addEffect(new GainAbilitySourceEffect(HasteAbility.getInstance(), Duration.EndOfTurn), source); + } + + // Hexproof + if (game.getBattlefield().contains(filterHexproof, source.getControllerId(), 1, game)) { + game.addEffect(new GainAbilitySourceEffect(HexproofAbility.getInstance(), Duration.EndOfTurn), source); + } + + // Indestructible + if (game.getBattlefield().contains(filterIndestructible, source.getControllerId(), 1, game)) { + game.addEffect(new GainAbilitySourceEffect(IndestructibleAbility.getInstance(), Duration.EndOfTurn), source); + } + + // Lifelink + if (game.getBattlefield().contains(filterLifelink, source.getControllerId(), 1, game)) { + game.addEffect(new GainAbilitySourceEffect(LifelinkAbility.getInstance(), Duration.EndOfTurn), source); + } + + // Menace + if (game.getBattlefield().contains(filterMenace, source.getControllerId(), 1, game)) { + game.addEffect(new GainAbilitySourceEffect(new MenaceAbility(), Duration.EndOfTurn), source); + } + + // Reach + if (game.getBattlefield().contains(filterReach, source.getControllerId(), 1, game)) { + game.addEffect(new GainAbilitySourceEffect(ReachAbility.getInstance(), Duration.EndOfTurn), source); + } + + // Trample + if (game.getBattlefield().contains(filterTrample, source.getControllerId(), 1, game)) { + game.addEffect(new GainAbilitySourceEffect(TrampleAbility.getInstance(), Duration.EndOfTurn), source); + } + + // Vigilance + if (game.getBattlefield().contains(filterVigilance, source.getControllerId(), 1, game)) { + game.addEffect(new GainAbilitySourceEffect(VigilanceAbility.getInstance(), Duration.EndOfTurn), source); + } + return true; + } +} \ No newline at end of file diff --git a/Mage.Sets/src/mage/cards/m/ManticoreElemental.java b/Mage.Sets/src/mage/cards/m/ManticoreEternal.java similarity index 62% rename from Mage.Sets/src/mage/cards/m/ManticoreElemental.java rename to Mage.Sets/src/mage/cards/m/ManticoreEternal.java index 905f2d0f5f5..ee2f5f6d47c 100644 --- a/Mage.Sets/src/mage/cards/m/ManticoreElemental.java +++ b/Mage.Sets/src/mage/cards/m/ManticoreEternal.java @@ -9,9 +9,9 @@ import mage.constants.CardType; import java.util.UUID; -public class ManticoreElemental extends CardImpl { +public class ManticoreEternal extends CardImpl { - public ManticoreElemental(UUID ownerId, CardSetInfo cardSetInfo) { + public ManticoreEternal(UUID ownerId, CardSetInfo cardSetInfo) { super(ownerId, cardSetInfo, new CardType[]{CardType.CREATURE}, "{3}{R}{R}"); subtype.add("Zombie"); subtype.add("Manticore"); @@ -21,15 +21,15 @@ public class ManticoreElemental extends CardImpl { // Afflict 3 addAbility(new AfflictAbility(3)); - // Manticore Elemental attacks each combat if able + // Manticore Eternal attacks each combat if able addAbility(new AttacksEachCombatStaticAbility()); } - public ManticoreElemental(final ManticoreElemental manticoreElemental) { - super(manticoreElemental); + public ManticoreEternal(final ManticoreEternal manticoreEternal) { + super(manticoreEternal); } - public ManticoreElemental copy() { - return new ManticoreElemental(this); + public ManticoreEternal copy() { + return new ManticoreEternal(this); } } diff --git a/Mage.Sets/src/mage/cards/m/MercilessEternal.java b/Mage.Sets/src/mage/cards/m/MercilessEternal.java new file mode 100644 index 00000000000..d2fa6791bab --- /dev/null +++ b/Mage.Sets/src/mage/cards/m/MercilessEternal.java @@ -0,0 +1,75 @@ +/* + * Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of BetaSteward_at_googlemail.com. + */ +package mage.cards.m; + +import java.util.UUID; +import mage.MageInt; +import mage.abilities.Ability; +import mage.abilities.common.SimpleActivatedAbility; +import mage.abilities.costs.common.DiscardCardCost; +import mage.abilities.costs.mana.ManaCostsImpl; +import mage.abilities.effects.common.continuous.BoostSourceEffect; +import mage.abilities.keyword.AfflictAbility; +import mage.cards.CardImpl; +import mage.cards.CardSetInfo; +import mage.constants.CardType; +import mage.constants.Duration; +import mage.constants.Zone; + +/** + * + * @author fireshoes + */ +public class MercilessEternal extends CardImpl { + + public MercilessEternal(UUID ownerId, CardSetInfo setInfo) { + super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{2}{B}"); + + this.subtype.add("Zombie"); + this.subtype.add("Cleric"); + this.power = new MageInt(2); + this.toughness = new MageInt(2); + + // Afflict 2 + this.addAbility(new AfflictAbility(2)); + + // {2}{B}, Discard a card: Merciless Eternal gets +2/+2 until end of turn. + Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new BoostSourceEffect(2, 2, Duration.EndOfTurn), new ManaCostsImpl("{2}{B}")); + ability.addCost(new DiscardCardCost(false)); + this.addAbility(ability); + } + + public MercilessEternal(final MercilessEternal card) { + super(card); + } + + @Override + public MercilessEternal copy() { + return new MercilessEternal(this); + } +} diff --git a/Mage.Sets/src/mage/cards/m/MirageMirror.java b/Mage.Sets/src/mage/cards/m/MirageMirror.java new file mode 100644 index 00000000000..a7639eabdd1 --- /dev/null +++ b/Mage.Sets/src/mage/cards/m/MirageMirror.java @@ -0,0 +1,100 @@ +/* + * Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of BetaSteward_at_googlemail.com. + */ +package mage.cards.m; + +import java.util.UUID; +import mage.abilities.Ability; +import mage.abilities.common.SimpleActivatedAbility; +import mage.abilities.costs.mana.ManaCostsImpl; +import mage.abilities.effects.OneShotEffect; +import mage.cards.CardImpl; +import mage.cards.CardSetInfo; +import mage.constants.CardType; +import mage.constants.Duration; +import mage.constants.Outcome; +import mage.constants.Zone; +import mage.filter.StaticFilters; +import mage.game.Game; +import mage.game.permanent.Permanent; +import mage.target.TargetPermanent; +import mage.util.functions.EmptyApplyToPermanent; + +/** + * + * @author fireshoes + */ +public class MirageMirror extends CardImpl { + + + + public MirageMirror(UUID ownerId, CardSetInfo setInfo) { + super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT}, "{3}"); + + // {2}: Mirage Mirror becomes a copy of target artifact, creature, enchantment, or land until end of turn. + Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new MirageMirrorCopyEffect(), new ManaCostsImpl("{2}")); + ability.addTarget(new TargetPermanent(StaticFilters.FILTER_PERMANENT_ARTIFACT_CREATURE_ENCHANTMENT_OR_LAND)); + this.addAbility(ability); + } + + public MirageMirror(final MirageMirror card) { + super(card); + } + + @Override + public MirageMirror copy() { + return new MirageMirror(this); + } +} + +class MirageMirrorCopyEffect extends OneShotEffect { + + public MirageMirrorCopyEffect() { + super(Outcome.Copy); + this.staticText = "{this} becomes a copy of target artifact, creature, enchantment, or land until end of turn"; + } + + public MirageMirrorCopyEffect(final MirageMirrorCopyEffect effect) { + super(effect); + } + + @Override + public MirageMirrorCopyEffect copy() { + return new MirageMirrorCopyEffect(this); + } + + @Override + public boolean apply(Game game, Ability source) { + Permanent sourcePermanent = game.getPermanent(source.getSourceId()); + Permanent copyFromPermanent = game.getPermanent(getTargetPointer().getFirst(game, source)); + if (sourcePermanent != null && copyFromPermanent != null) { + game.copyPermanent(Duration.EndOfTurn, copyFromPermanent, sourcePermanent.getId(), source, new EmptyApplyToPermanent()); + return true; + } + return false; + } +} diff --git a/Mage.Sets/src/mage/cards/n/NissasDefeat.java b/Mage.Sets/src/mage/cards/n/NissasDefeat.java new file mode 100644 index 00000000000..ba0ab90e5a3 --- /dev/null +++ b/Mage.Sets/src/mage/cards/n/NissasDefeat.java @@ -0,0 +1,120 @@ +/* + * Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of BetaSteward_at_googlemail.com. + */ +package mage.cards.n; + +import java.util.UUID; +import mage.ObjectColor; +import mage.abilities.Ability; +import mage.abilities.effects.OneShotEffect; +import mage.cards.CardImpl; +import mage.cards.CardSetInfo; +import mage.constants.CardType; +import mage.constants.Outcome; +import mage.constants.SubType; +import mage.filter.FilterPermanent; +import mage.filter.predicate.Predicates; +import mage.filter.predicate.mageobject.CardTypePredicate; +import mage.filter.predicate.mageobject.ColorPredicate; +import mage.filter.predicate.mageobject.SubtypePredicate; +import mage.game.Game; +import mage.game.permanent.Permanent; +import mage.players.Player; +import mage.target.TargetPermanent; + +/** + * + * @author fireshoes + */ +public class NissasDefeat extends CardImpl { + + private final static FilterPermanent filter = new FilterPermanent("Forest, green enchantment, or green planeswalker"); + + static { + filter.add(Predicates.or(new SubtypePredicate(SubType.FOREST), + (Predicates.and(new ColorPredicate(ObjectColor.GREEN), new CardTypePredicate(CardType.ENCHANTMENT))), + (Predicates.and(new ColorPredicate(ObjectColor.GREEN), new CardTypePredicate(CardType.PLANESWALKER))))); + } + + public NissasDefeat(UUID ownerId, CardSetInfo setInfo) { + super(ownerId, setInfo, new CardType[]{CardType.SORCERY}, "{2}{G}"); + + // Destroy target Forest, green enchantment, or green planeswalker. If that permanent was a Nissa planeswalker, draw a card. + this.getSpellAbility().addEffect(new NissasDefeatEffect()); + this.getSpellAbility().addTarget(new TargetPermanent(filter)); + } + + public NissasDefeat(final NissasDefeat card) { + super(card); + } + + @Override + public NissasDefeat copy() { + return new NissasDefeat(this); + } +} + +class NissasDefeatEffect extends OneShotEffect { + + private static final FilterPermanent filter = new FilterPermanent(); + + static { + filter.add(new CardTypePredicate(CardType.PLANESWALKER)); + filter.add(new SubtypePredicate(SubType.NISSA)); + } + + public NissasDefeatEffect() { + super(Outcome.Damage); + this.staticText = "Destroy target Forest, green enchantment, or green planeswalker. If that permanent was a Nissa planeswalker, draw a card."; + } + + public NissasDefeatEffect(final NissasDefeatEffect effect) { + super(effect); + } + + @Override + public NissasDefeatEffect copy() { + return new NissasDefeatEffect(this); + } + + @Override + public boolean apply(Game game, Ability source) { + Permanent permanent = game.getPermanent(source.getFirstTarget()); + Player controller = game.getPlayer(source.getControllerId()); + + if (permanent != null) { + permanent.destroy(source.getSourceId(), game, false); + + // If it was a Nissa planeswalker, draw a card + if (filter.match(permanent, game) && controller != null) { + controller.drawCards(1, game); + } + return true; + } + return false; + } +} diff --git a/Mage.Sets/src/mage/cards/o/ObeliskSpider.java b/Mage.Sets/src/mage/cards/o/ObeliskSpider.java new file mode 100644 index 00000000000..b91448a525e --- /dev/null +++ b/Mage.Sets/src/mage/cards/o/ObeliskSpider.java @@ -0,0 +1,125 @@ +/* + * Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of BetaSteward_at_googlemail.com. + */ +package mage.cards.o; + +import java.util.UUID; +import mage.MageInt; +import mage.abilities.Ability; +import mage.abilities.TriggeredAbilityImpl; +import mage.abilities.common.DealsDamageToACreatureTriggeredAbility; +import mage.abilities.effects.Effect; +import mage.abilities.effects.common.GainLifeEffect; +import mage.abilities.effects.common.LoseLifeOpponentsEffect; +import mage.abilities.effects.common.counter.AddCountersTargetEffect; +import mage.abilities.keyword.ReachAbility; +import mage.cards.CardImpl; +import mage.cards.CardSetInfo; +import mage.constants.CardType; +import mage.constants.Zone; +import mage.counters.CounterType; +import mage.game.Game; +import mage.game.events.GameEvent; +import mage.game.permanent.Permanent; + +/** + * + * @author fireshoes + */ +public class ObeliskSpider extends CardImpl { + + public ObeliskSpider(UUID ownerId, CardSetInfo setInfo) { + super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{1}{B}{G}"); + + this.subtype.add("Spider"); + this.power = new MageInt(1); + this.toughness = new MageInt(4); + + // Reach + this.addAbility(ReachAbility.getInstance()); + + // Whenever Obelisk Spider deals combat damage to a creature, put a -1/-1 counter on that creature. + this.addAbility(new DealsDamageToACreatureTriggeredAbility(new AddCountersTargetEffect(CounterType.M1M1.createInstance(1)), true, false, true)); + + // Whenever you put one or more -1/-1 counters on a creature, each opponent loses 1 life and you gain 1 life. + Ability ability = new ObeliskSpiderTriggeredAbility(new LoseLifeOpponentsEffect(1), false); + Effect effect = new GainLifeEffect(1); + effect.setText("and you gain 1 life"); + ability.addEffect(effect); + this.addAbility(ability); + } + + public ObeliskSpider(final ObeliskSpider card) { + super(card); + } + + @Override + public ObeliskSpider copy() { + return new ObeliskSpider(this); + } +} + +class ObeliskSpiderTriggeredAbility extends TriggeredAbilityImpl { + + public ObeliskSpiderTriggeredAbility(Effect effect, boolean optional) { + super(Zone.BATTLEFIELD, effect, optional); + } + + public ObeliskSpiderTriggeredAbility(ObeliskSpiderTriggeredAbility ability) { + super(ability); + } + + @Override + public boolean checkEventType(GameEvent event, Game game) { + return event.getType() == GameEvent.EventType.COUNTERS_ADDED; + } + + @Override + public boolean checkTrigger(GameEvent event, Game game) { + if (event.getData().equals(CounterType.M1M1.getName()) + && controllerId.equals(game.getControllerId(event.getSourceId()))) { + Permanent permanent = game.getPermanentOrLKIBattlefield(event.getTargetId()); + if (permanent == null) { + permanent = game.getPermanentEntering(event.getTargetId()); + } + return (permanent != null + && permanent.isCreature()); + } + return false; + + } + + @Override + public ObeliskSpiderTriggeredAbility copy() { + return new ObeliskSpiderTriggeredAbility(this); + } + + @Override + public String getRule() { + return "Whenever you put one or more -1/-1 counters on a creature, " + super.getRule(); + } +} diff --git a/Mage.Sets/src/mage/cards/r/RamunapRuins.java b/Mage.Sets/src/mage/cards/r/RamunapRuins.java new file mode 100644 index 00000000000..ed41f99f1f0 --- /dev/null +++ b/Mage.Sets/src/mage/cards/r/RamunapRuins.java @@ -0,0 +1,93 @@ +/* + * Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of BetaSteward_at_googlemail.com. + */ +package mage.cards.r; + +import java.util.UUID; +import mage.abilities.Ability; +import mage.abilities.common.SimpleActivatedAbility; +import mage.abilities.costs.common.PayLifeCost; +import mage.abilities.costs.common.SacrificeTargetCost; +import mage.abilities.costs.common.TapSourceCost; +import mage.abilities.costs.mana.ManaCostsImpl; +import mage.abilities.dynamicvalue.common.StaticValue; +import mage.abilities.effects.common.DamagePlayersEffect; +import mage.abilities.mana.ColorlessManaAbility; +import mage.abilities.mana.RedManaAbility; +import mage.cards.CardImpl; +import mage.cards.CardSetInfo; +import mage.constants.CardType; +import mage.constants.Outcome; +import mage.constants.SubType; +import mage.constants.TargetController; +import mage.constants.Zone; +import mage.filter.common.FilterControlledPermanent; +import mage.filter.predicate.mageobject.SubtypePredicate; +import mage.target.common.TargetControlledPermanent; + +/** + * + * @author fireshoes + */ +public class RamunapRuins extends CardImpl { + + private static final FilterControlledPermanent filter = new FilterControlledPermanent("Desert"); + + static { + filter.add(new SubtypePredicate(SubType.DESERT)); + } + + public RamunapRuins(UUID ownerId, CardSetInfo setInfo) { + super(ownerId, setInfo, new CardType[]{CardType.LAND}, ""); + + this.subtype.add("Desert"); + + // {t}: Add {C} to your mana pool. + this.addAbility(new ColorlessManaAbility()); + + // {t}, Pay 1 life: Add {R} to your mana pool. + Ability manaAbility = new RedManaAbility(); + manaAbility.addCost(new PayLifeCost(1)); + this.addAbility(manaAbility); + + // {2}{R}{R}, {t}, Sacrifice a Desert: Ramunap Ruins deals 2 damage to each opponent. + Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new DamagePlayersEffect(Outcome.Damage, new StaticValue(2), TargetController.OPPONENT), + new ManaCostsImpl("{2}{R}{R}")); + ability.addCost(new TapSourceCost()); + ability.addCost(new SacrificeTargetCost(new TargetControlledPermanent(1, 1, filter, true))); + this.addAbility(ability); + } + + public RamunapRuins(final RamunapRuins card) { + super(card); + } + + @Override + public RamunapRuins copy() { + return new RamunapRuins(this); + } +} diff --git a/Mage.Sets/src/mage/sets/HourOfDevastation.java b/Mage.Sets/src/mage/sets/HourOfDevastation.java index 37dede483c5..f3769997699 100644 --- a/Mage.Sets/src/mage/sets/HourOfDevastation.java +++ b/Mage.Sets/src/mage/sets/HourOfDevastation.java @@ -64,6 +64,7 @@ public class HourOfDevastation extends ExpansionSet { this.numBoosterRare = 1; this.ratioBoosterMythic = 8; this.ratioBoosterSpecialLand = 144; + this.maxCardNumberInBooster = 199; cards.add(new SetCardInfo("Abrade", 83, Rarity.UNCOMMON, mage.cards.a.Abrade.class)); cards.add(new SetCardInfo("Accursed Horde", 56, Rarity.UNCOMMON, mage.cards.a.AccursedHorde.class)); @@ -71,13 +72,11 @@ public class HourOfDevastation extends ExpansionSet { cards.add(new SetCardInfo("Adorned Pouncer", 2, Rarity.RARE, mage.cards.a.AdornedPouncer.class)); cards.add(new SetCardInfo("Aerial Guide", 29, Rarity.COMMON, mage.cards.a.AerialGuide.class)); cards.add(new SetCardInfo("Ambuscade", 110, Rarity.COMMON, mage.cards.a.Ambuscade.class)); -<<<<<<< HEAD cards.add(new SetCardInfo("Ammit Eternal", 57, Rarity.RARE, mage.cards.a.AmmitEternal.class)); cards.add(new SetCardInfo("Angel of Condemnation", 3, Rarity.RARE, mage.cards.a.AngelOfCondemnation.class)); cards.add(new SetCardInfo("Angel of the God-Pharaoh", 4, Rarity.UNCOMMON, mage.cards.a.AngelOfTheGodPharaoh.class)); - cards.add(new SetCardInfo("Aven Reedstalker", 30, Rarity.COMMON, mage.cards.a.AvenReedstalker.class)); - cards.add(new SetCardInfo("Aven of Enduring Hope", 5, Rarity.COMMON, mage.cards.a.AvenOfEnduringHope.class)); cards.add(new SetCardInfo("Appeal // Authority", 152, Rarity.UNCOMMON, mage.cards.a.AppealAuthority.class)); + cards.add(new SetCardInfo("Aven of Enduring Hope", 5, Rarity.COMMON, mage.cards.a.AvenOfEnduringHope.class)); cards.add(new SetCardInfo("Aven Reedstalker", 30, Rarity.COMMON, mage.cards.a.AvenReedstalker.class)); cards.add(new SetCardInfo("Avid Reclaimer", 201, Rarity.UNCOMMON, mage.cards.a.AvidReclaimer.class)); cards.add(new SetCardInfo("Banewhip Punisher", 59, Rarity.UNCOMMON, mage.cards.b.BanewhipPunisher.class)); @@ -151,9 +150,9 @@ public class HourOfDevastation extends ExpansionSet { cards.add(new SetCardInfo("Khenra Eternal", 66, Rarity.COMMON, mage.cards.k.KhenraEternal.class)); cards.add(new SetCardInfo("Khenra Scrapper", 100, Rarity.COMMON, mage.cards.k.KhenraScrapper.class)); cards.add(new SetCardInfo("Kindled Fury", 101, Rarity.COMMON, mage.cards.k.KindledFury.class)); - cards.add(new SetCardInfo("Life Goes On", 121, Rarity.COMMON, mage.cards.l.LifeGoesOn.class)); cards.add(new SetCardInfo("Leave // Chance", 153, Rarity.RARE, mage.cards.l.LeaveChance.class)); cards.add(new SetCardInfo("Lethal Sting", 67, Rarity.COMMON, mage.cards.l.LethalSting.class)); + cards.add(new SetCardInfo("Life Goes On", 121, Rarity.COMMON, mage.cards.l.LifeGoesOn.class)); cards.add(new SetCardInfo("Liliana's Defeat", 68, Rarity.UNCOMMON, mage.cards.l.LilianasDefeat.class)); cards.add(new SetCardInfo("Lurching Rotbeast", 69, Rarity.COMMON, mage.cards.l.LurchingRotbeast.class)); cards.add(new SetCardInfo("Magmaroth", 102, Rarity.UNCOMMON, mage.cards.m.Magmaroth.class)); @@ -180,8 +179,8 @@ public class HourOfDevastation extends ExpansionSet { cards.add(new SetCardInfo("Oketra's Last Mercy", 18, Rarity.RARE, mage.cards.o.OketrasLastMercy.class)); cards.add(new SetCardInfo("Ominous Sphinx", 41, Rarity.UNCOMMON, mage.cards.o.OminousSphinx.class)); cards.add(new SetCardInfo("Open Fire", 105, Rarity.COMMON, mage.cards.o.OpenFire.class)); - cards.add(new SetCardInfo("Overwhelming Splendor", 19, Rarity.MYTHIC, mage.cards.o.OverwhelmingSplendor.class)); cards.add(new SetCardInfo("Overcome", 125, Rarity.UNCOMMON, mage.cards.o.Overcome.class)); + cards.add(new SetCardInfo("Overwhelming Splendor", 19, Rarity.MYTHIC, mage.cards.o.OverwhelmingSplendor.class)); cards.add(new SetCardInfo("Plains", 185, Rarity.LAND, mage.cards.basiclands.Plains.class, new CardGraphicInfo(FrameStyle.BFZ_FULL_ART_BASIC, true))); cards.add(new SetCardInfo("Plains", 190, Rarity.LAND, mage.cards.basiclands.Plains.class)); cards.add(new SetCardInfo("Plains", 191, Rarity.LAND, mage.cards.basiclands.Plains.class)); @@ -209,9 +208,9 @@ public class HourOfDevastation extends ExpansionSet { cards.add(new SetCardInfo("Sandblast", 20, Rarity.COMMON, mage.cards.s.Sandblast.class)); cards.add(new SetCardInfo("Saving Grace", 21, Rarity.UNCOMMON, mage.cards.s.SavingGrace.class)); cards.add(new SetCardInfo("Scavenger Grounds", 182, Rarity.RARE, mage.cards.s.ScavengerGrounds.class)); + cards.add(new SetCardInfo("Scrounger of Souls", 76, Rarity.COMMON, mage.cards.s.ScroungerOfSouls.class)); cards.add(new SetCardInfo("Seer of the Last Tomorrow", 44, Rarity.COMMON, mage.cards.s.SeerOfTheLastTomorrow.class)); cards.add(new SetCardInfo("Shefet Dunes", 183, Rarity.UNCOMMON, mage.cards.s.ShefetDunes.class)); - cards.add(new SetCardInfo("Scrounger of Souls", 76, Rarity.COMMON, mage.cards.s.ScroungerOfSouls.class)); cards.add(new SetCardInfo("Sidewinder Naga", 134, Rarity.COMMON, mage.cards.s.SidewinderNaga.class)); cards.add(new SetCardInfo("Sifter Wurm", 135, Rarity.UNCOMMON, mage.cards.s.SifterWurm.class)); cards.add(new SetCardInfo("Sinuous Striker", 45, Rarity.UNCOMMON, mage.cards.s.SinuousStriker.class)); diff --git a/Mage/src/main/java/mage/filter/StaticFilters.java b/Mage/src/main/java/mage/filter/StaticFilters.java index ec91b1c94dc..0f1c4c19bbd 100644 --- a/Mage/src/main/java/mage/filter/StaticFilters.java +++ b/Mage/src/main/java/mage/filter/StaticFilters.java @@ -36,6 +36,7 @@ public final class StaticFilters { public static final FilterCreaturePermanent FILTER_ARTIFACT_CREATURE_PERMANENT = new FilterArtifactCreaturePermanent(); public static final FilterPermanent FILTER_PERMANENT_ARTIFACT_OR_CREATURE = new FilterPermanent("artifact or creature"); public static final FilterPermanent FILTER_PERMANENT_ARTIFACT_CREATURE_OR_ENCHANTMENT = new FilterPermanent("artifact, creature, or enchantment"); + public static final FilterPermanent FILTER_PERMANENT_ARTIFACT_CREATURE_ENCHANTMENT_OR_LAND = new FilterPermanent("artifact, creature, enchantment, or land"); public static final FilterControlledPermanent FILTER_CONTROLLED_PERMANENT_ARTIFACT = new FilterControlledArtifactPermanent(); public static final FilterControlledPermanent FILTER_CONTROLLED_PERMANENT_ARTIFACT_OR_CREATURE = new FilterControlledPermanent("artifact or creature you control"); @@ -75,6 +76,12 @@ public final class StaticFilters { new CardTypePredicate(CardType.CREATURE), new CardTypePredicate(CardType.ENCHANTMENT) )); + FILTER_PERMANENT_ARTIFACT_CREATURE_ENCHANTMENT_OR_LAND.add(Predicates.or( + new CardTypePredicate(CardType.ARTIFACT), + new CardTypePredicate(CardType.CREATURE), + new CardTypePredicate(CardType.ENCHANTMENT), + new CardTypePredicate(CardType.LAND) + )); FILTER_CONTROLLED_PERMANENT_ARTIFACT_OR_CREATURE.add(Predicates.or( new CardTypePredicate(CardType.ARTIFACT), new CardTypePredicate(CardType.CREATURE)