From ecef34601d87ad75e2746436867a9b0f77a4c72b Mon Sep 17 00:00:00 2001 From: LevelX2 Date: Tue, 12 Nov 2013 01:13:10 +0100 Subject: [PATCH] [C13] Added Fedundity, Fell Shepherd, Shattergang Brothers, Tempt with Vengeance. [C11] Riku of Two Reflections. --- .../sets/commander/RikuOfTwoReflections.java | 177 +++++++++++++++++ .../mage/sets/commander2013/Fecundity.java | 52 +++++ .../mage/sets/commander2013/FellShepherd.java | 180 ++++++++++++++++++ .../mage/sets/commander2013/Ophiomancer.java | 92 +++++++++ .../commander2013/ShattergangBrothers.java | 147 ++++++++++++++ .../commander2013/TemptWithDiscovery.java | 2 +- .../commander2013/TemptWithVengeance.java | 126 ++++++++++++ .../mage/sets/eighthedition/Fecundity.java | 52 +++++ .../sets/innistrad/GrimgrinCorpseBorn.java | 7 +- .../src/mage/sets/urzassaga/Fecundity.java | 99 ++++++++++ 10 files changed, 929 insertions(+), 5 deletions(-) create mode 100644 Mage.Sets/src/mage/sets/commander/RikuOfTwoReflections.java create mode 100644 Mage.Sets/src/mage/sets/commander2013/Fecundity.java create mode 100644 Mage.Sets/src/mage/sets/commander2013/FellShepherd.java create mode 100644 Mage.Sets/src/mage/sets/commander2013/Ophiomancer.java create mode 100644 Mage.Sets/src/mage/sets/commander2013/ShattergangBrothers.java create mode 100644 Mage.Sets/src/mage/sets/commander2013/TemptWithVengeance.java create mode 100644 Mage.Sets/src/mage/sets/eighthedition/Fecundity.java create mode 100644 Mage.Sets/src/mage/sets/urzassaga/Fecundity.java diff --git a/Mage.Sets/src/mage/sets/commander/RikuOfTwoReflections.java b/Mage.Sets/src/mage/sets/commander/RikuOfTwoReflections.java new file mode 100644 index 0000000000..5c3b198590 --- /dev/null +++ b/Mage.Sets/src/mage/sets/commander/RikuOfTwoReflections.java @@ -0,0 +1,177 @@ +/* + * 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.sets.commander; + +import java.util.UUID; +import mage.MageInt; +import mage.abilities.Ability; +import mage.abilities.common.EntersBattlefieldAllTriggeredAbility; +import mage.abilities.common.SpellCastControllerTriggeredAbility; +import mage.abilities.costs.mana.ManaCostsImpl; +import mage.abilities.effects.OneShotEffect; +import mage.abilities.effects.common.DoIfCostPaid; +import mage.cards.CardImpl; +import mage.constants.CardType; +import mage.constants.Outcome; +import mage.constants.Rarity; +import mage.constants.Zone; +import mage.filter.FilterSpell; +import mage.filter.common.FilterControlledCreaturePermanent; +import mage.filter.predicate.Predicates; +import mage.filter.predicate.mageobject.CardTypePredicate; +import mage.filter.predicate.permanent.AnotherPredicate; +import mage.filter.predicate.permanent.TokenPredicate; +import mage.game.Game; +import mage.game.permanent.Permanent; +import mage.game.stack.Spell; +import mage.players.Player; +import mage.sets.tokens.EmptyToken; +import mage.util.CardUtil; + +/** + * + * @author LevelX2 + */ +public class RikuOfTwoReflections extends CardImpl { + + private static final FilterSpell filter = new FilterSpell("an instant or sorcery spell"); + private static final FilterControlledCreaturePermanent filterPermanent = new FilterControlledCreaturePermanent("another nontoken creature"); + static { + filter.add(Predicates.or( + new CardTypePredicate(CardType.INSTANT), + new CardTypePredicate(CardType.SORCERY))); + filterPermanent.add(Predicates.not(new TokenPredicate())); + filterPermanent.add(new AnotherPredicate()); + + } + + public RikuOfTwoReflections(UUID ownerId) { + super(ownerId, 220, "Riku of Two Reflections", Rarity.MYTHIC, new CardType[]{CardType.CREATURE}, "{2}{U}{R}{G}"); + this.expansionSetCode = "CMD"; + this.supertype.add("Legendary"); + this.subtype.add("Human"); + this.subtype.add("Wizard"); + + this.color.setRed(true); + this.color.setBlue(true); + this.color.setGreen(true); + this.power = new MageInt(2); + this.toughness = new MageInt(2); + + // Whenever you cast an instant or sorcery spell, you may pay {U}{R}. If you do, copy that spell. You may choose new targets for the copy. + this.addAbility(new SpellCastControllerTriggeredAbility(new DoIfCostPaid(new RikuOfTwoReflectionsCopyEffect(), new ManaCostsImpl("{U}{R}")), filter, false, true)); + + // Whenever another nontoken creature enters the battlefield under your control, you may pay {G}{U}. If you do, put a token that's a copy of that creature onto the battlefield. + Ability ability = new EntersBattlefieldAllTriggeredAbility( + Zone.BATTLEFIELD, new RikuOfTwoReflectionsCopyTokenEffect(),filterPermanent, false, true, + "Whenever another nontoken creature enters the battlefield under your control, you may pay {G}{U}. If you do, put a token that's a copy of that creature onto the battlefield.", + true); + ability.addCost(new ManaCostsImpl("{G}{U}")); + this.addAbility(ability); + } + + public RikuOfTwoReflections(final RikuOfTwoReflections card) { + super(card); + } + + @Override + public RikuOfTwoReflections copy() { + return new RikuOfTwoReflections(this); + } +} + +class RikuOfTwoReflectionsCopyEffect extends OneShotEffect { + + public RikuOfTwoReflectionsCopyEffect() { + super(Outcome.Copy); + staticText = "copy that spell. You may choose new targets for the copy"; + } + + public RikuOfTwoReflectionsCopyEffect(final RikuOfTwoReflectionsCopyEffect effect) { + super(effect); + } + + @Override + public boolean apply(Game game, Ability source) { + Spell spell = game.getStack().getSpell(targetPointer.getFirst(game, source)); + if (spell != null) { + Spell copy = spell.copySpell(); + copy.setControllerId(source.getControllerId()); + copy.setCopiedSpell(true); + game.getStack().push(copy); + copy.chooseNewTargets(game, source.getControllerId()); + Player player = game.getPlayer(source.getControllerId()); + String activateMessage = copy.getActivatedMessage(game); + if (activateMessage.startsWith(" casts ")) { + activateMessage = activateMessage.substring(6); + } + game.informPlayers(player.getName() + " copies " + activateMessage); + return true; + } + return false; + } + + @Override + public RikuOfTwoReflectionsCopyEffect copy() { + return new RikuOfTwoReflectionsCopyEffect(this); + } +} + +class RikuOfTwoReflectionsCopyTokenEffect extends OneShotEffect { + + public RikuOfTwoReflectionsCopyTokenEffect() { + super(Outcome.PutCreatureInPlay); + this.staticText = "put a token that's a copy of that creature onto the battlefield"; + } + + public RikuOfTwoReflectionsCopyTokenEffect(final RikuOfTwoReflectionsCopyTokenEffect effect) { + super(effect); + } + + @Override + public RikuOfTwoReflectionsCopyTokenEffect copy() { + return new RikuOfTwoReflectionsCopyTokenEffect(this); + } + + @Override + public boolean apply(Game game, Ability source) { + Permanent permanent = game.getPermanent(this.getTargetPointer().getFirst(game, source)); + if (permanent == null) { + permanent = (Permanent) game.getLastKnownInformation(source.getFirstTarget(), Zone.BATTLEFIELD); + } + + if (permanent != null) { + EmptyToken token = new EmptyToken(); + CardUtil.copyTo(token).from(permanent); + token.putOntoBattlefield(1, game, source.getSourceId(), source.getControllerId()); + return true; + } + + return false; + } +} diff --git a/Mage.Sets/src/mage/sets/commander2013/Fecundity.java b/Mage.Sets/src/mage/sets/commander2013/Fecundity.java new file mode 100644 index 0000000000..9983b24ceb --- /dev/null +++ b/Mage.Sets/src/mage/sets/commander2013/Fecundity.java @@ -0,0 +1,52 @@ +/* + * 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.sets.commander2013; + +import java.util.UUID; + +/** + * + * @author LevelX2 + */ +public class Fecundity extends mage.sets.urzassaga.Fecundity { + + public Fecundity(UUID ownerId) { + super(ownerId); + this.cardNumber = 145; + this.expansionSetCode = "C13"; + } + + public Fecundity(final Fecundity card) { + super(card); + } + + @Override + public Fecundity copy() { + return new Fecundity(this); + } +} diff --git a/Mage.Sets/src/mage/sets/commander2013/FellShepherd.java b/Mage.Sets/src/mage/sets/commander2013/FellShepherd.java new file mode 100644 index 0000000000..42e34c7dba --- /dev/null +++ b/Mage.Sets/src/mage/sets/commander2013/FellShepherd.java @@ -0,0 +1,180 @@ +/* + * 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.sets.commander2013; + +import java.util.HashSet; +import java.util.Set; +import java.util.UUID; +import mage.MageInt; +import mage.MageObject; +import mage.abilities.Ability; +import mage.abilities.common.DealsCombatDamageToAPlayerTriggeredAbility; +import mage.abilities.common.SimpleActivatedAbility; +import mage.abilities.costs.common.SacrificeTargetCost; +import mage.abilities.costs.mana.ManaCostsImpl; +import mage.abilities.effects.OneShotEffect; +import mage.abilities.effects.common.continious.BoostTargetEffect; +import mage.cards.Card; +import mage.cards.CardImpl; +import mage.constants.CardType; +import mage.constants.Duration; +import mage.constants.Outcome; +import mage.constants.Rarity; +import mage.constants.WatcherScope; +import mage.constants.Zone; +import mage.filter.common.FilterControlledCreaturePermanent; +import mage.filter.predicate.permanent.AnotherPredicate; +import mage.game.Game; +import mage.game.events.GameEvent; +import mage.game.events.GameEvent.EventType; +import mage.game.events.ZoneChangeEvent; +import mage.target.common.TargetControlledCreaturePermanent; +import mage.target.common.TargetCreaturePermanent; +import mage.watchers.WatcherImpl; + +/** + * + * @author LevelX2 + */ +public class FellShepherd extends CardImpl { + + private static final FilterControlledCreaturePermanent filter = new FilterControlledCreaturePermanent("another creature"); + static { + filter.add(new AnotherPredicate()); + } + + public FellShepherd(UUID ownerId) { + super(ownerId, 78, "Fell Shepherd", Rarity.RARE, new CardType[]{CardType.CREATURE}, "{5}{B}{B}"); + this.expansionSetCode = "C13"; + this.subtype.add("Avatar"); + + this.color.setBlack(true); + this.power = new MageInt(8); + this.toughness = new MageInt(6); + + // Whenever Fell Shepherd deals combat damage to a player, you may return to your hand all creature cards that were put into your graveyard from the battlefield this turn. + this.addAbility(new DealsCombatDamageToAPlayerTriggeredAbility(new FellShepherdEffect(), true)); + this.addWatcher(new FellShepherdWatcher()); + + // {B}, Sacrifice another creature: Target creature gets -2/-2 until end of turn. + SimpleActivatedAbility ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new BoostTargetEffect(-2,-2, Duration.EndOfTurn), new ManaCostsImpl("{B}")); + ability.addCost(new SacrificeTargetCost(new TargetControlledCreaturePermanent(1, 1, filter, false))); + ability.addTarget(new TargetCreaturePermanent(true)); + this.addAbility(ability); + + } + + public FellShepherd(final FellShepherd card) { + super(card); + } + + @Override + public FellShepherd copy() { + return new FellShepherd(this); + } +} + +class FellShepherdWatcher extends WatcherImpl { + + private Set creatureIds = new HashSet(); + + public FellShepherdWatcher() { + super("YourCreaturesPutToGraveFromBattlefield", WatcherScope.PLAYER); + condition = true; + } + + public FellShepherdWatcher(final FellShepherdWatcher watcher) { + super(watcher); + this.creatureIds.addAll(watcher.creatureIds); + } + + @Override + public FellShepherdWatcher copy() { + return new FellShepherdWatcher(this); + } + + public Set getCreaturesIds() { + return creatureIds; + } + + @Override + public void watch(GameEvent event, Game game) { + if (event.getType() == EventType.ZONE_CHANGE && ((ZoneChangeEvent) event).isDiesEvent()) { + MageObject card = game.getLastKnownInformation(event.getTargetId(), Zone.BATTLEFIELD); + if (card != null && ((Card)card).getOwnerId().equals(this.controllerId) && card.getCardType().contains(CardType.CREATURE)) { + creatureIds.add(card.getId()); + } + } + } + + @Override + public void reset() { + super.reset(); + creatureIds.clear(); + } +} + +class FellShepherdEffect extends OneShotEffect { + + public FellShepherdEffect() { + super(Outcome.ReturnToHand); + this.staticText = "return to your hand all creature cards that were put into your graveyard from the battlefield this turn"; + } + + public FellShepherdEffect(final FellShepherdEffect effect) { + super(effect); + } + + @Override + public FellShepherdEffect copy() { + return new FellShepherdEffect(this); + } + + @Override + public boolean apply(Game game, Ability source) { + FellShepherdWatcher watcher = (FellShepherdWatcher) game.getState().getWatchers().get("YourCreaturesPutToGraveFromBattlefield", source.getControllerId()); + if (watcher != null) { + StringBuilder sb = new StringBuilder(); + for (UUID creatureId : watcher.getCreaturesIds()) { + if (game.getState().getZone(creatureId).equals(Zone.GRAVEYARD)) { + Card card = game.getCard(creatureId); + if (card != null) { + card.moveToZone(Zone.HAND, source.getSourceId(), game, false); + sb.append(" ").append(card.getName()); + } + } + } + if (sb.length()> 0) { + sb.insert(0, "Fell Shepherd - returning to hand:"); + game.informPlayers(sb.toString()); + } + return true; + } + return false; + } +} diff --git a/Mage.Sets/src/mage/sets/commander2013/Ophiomancer.java b/Mage.Sets/src/mage/sets/commander2013/Ophiomancer.java new file mode 100644 index 0000000000..41ce1cbd5b --- /dev/null +++ b/Mage.Sets/src/mage/sets/commander2013/Ophiomancer.java @@ -0,0 +1,92 @@ +/* + * 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.sets.commander2013; + +import java.util.UUID; +import mage.MageInt; +import mage.ObjectColor; +import mage.abilities.common.BeginningOfUpkeepTriggeredAbility; +import mage.abilities.condition.common.ControlsPermanentCondition; +import mage.abilities.condition.common.PermanentOnBattelfieldCondition; +import mage.abilities.decorator.ConditionalTriggeredAbility; +import mage.abilities.effects.common.CreateTokenEffect; +import mage.abilities.keyword.DeathtouchAbility; +import mage.cards.CardImpl; +import mage.constants.CardType; +import mage.constants.Rarity; +import mage.constants.TargetController; +import mage.constants.Zone; +import mage.filter.common.FilterCreaturePermanent; +import mage.game.permanent.token.Token; + +/** + * + * @author LevelX2 + */ +public class Ophiomancer extends CardImpl { + + public Ophiomancer(UUID ownerId) { + super(ownerId, 84, "Ophiomancer", Rarity.RARE, new CardType[]{CardType.CREATURE}, "{2}{B}"); + this.expansionSetCode = "C13"; + this.subtype.add("Human"); + this.subtype.add("Shaman"); + + this.color.setBlack(true); + this.power = new MageInt(2); + this.toughness = new MageInt(2); + + // At the beginning of each upkeep, if you control no Snakes, put a 1/1 black Snake creature token with deathtouch onto the battlefield. + this.addAbility(new ConditionalTriggeredAbility( + new BeginningOfUpkeepTriggeredAbility(Zone.BATTLEFIELD, new CreateTokenEffect(new OphiomancerSnakeToken()), TargetController.ANY, false), + new ControlsPermanentCondition(new FilterCreaturePermanent("Snake", "no Snakes"), ControlsPermanentCondition.CountType.EQUAL_TO, 0), + "At the beginning of each upkeep, if you control no Snakes, put a 1/1 black Snake creature token with deathtouch onto the battlefield.")); + } + + public Ophiomancer(final Ophiomancer card) { + super(card); + } + + @Override + public Ophiomancer copy() { + return new Ophiomancer(this); + } +} + +class OphiomancerSnakeToken extends Token { + + public OphiomancerSnakeToken() { + super("Snake", "1/1 black Snake creature token with deathtouch"); + cardType.add(CardType.CREATURE); + color = ObjectColor.BLACK; + subtype.add("Snake"); + power = new MageInt(1); + toughness = new MageInt(1); + this.addAbility(DeathtouchAbility.getInstance()); + } + +} diff --git a/Mage.Sets/src/mage/sets/commander2013/ShattergangBrothers.java b/Mage.Sets/src/mage/sets/commander2013/ShattergangBrothers.java new file mode 100644 index 0000000000..e645fce427 --- /dev/null +++ b/Mage.Sets/src/mage/sets/commander2013/ShattergangBrothers.java @@ -0,0 +1,147 @@ +/* + * 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.sets.commander2013; + +import java.util.UUID; +import mage.MageInt; +import mage.abilities.Ability; +import mage.abilities.common.SimpleActivatedAbility; +import mage.abilities.costs.common.SacrificeTargetCost; +import mage.abilities.costs.mana.ManaCostsImpl; +import mage.abilities.effects.OneShotEffect; +import mage.cards.CardImpl; +import mage.constants.CardType; +import mage.constants.Outcome; +import mage.constants.Rarity; +import mage.constants.Zone; +import mage.filter.FilterPermanent; +import mage.filter.common.FilterControlledArtifactPermanent; +import mage.filter.common.FilterControlledCreaturePermanent; +import mage.filter.common.FilterControlledPermanent; +import mage.filter.common.FilterCreaturePermanent; +import mage.filter.predicate.mageobject.CardTypePredicate; +import mage.game.Game; +import mage.game.permanent.Permanent; +import mage.players.Player; +import mage.target.TargetPermanent; +import mage.target.common.TargetControlledCreaturePermanent; +import mage.target.common.TargetControlledPermanent; + +/** + * + * @author LevelX2 + */ +public class ShattergangBrothers extends CardImpl { + + public ShattergangBrothers(UUID ownerId) { + super(ownerId, 213, "Shattergang Brothers", Rarity.MYTHIC, new CardType[]{CardType.CREATURE}, "{1}{B}{R}{G}"); + this.expansionSetCode = "C13"; + this.supertype.add("Legendary"); + this.subtype.add("Goblin"); + this.subtype.add("Artificer"); + + this.color.setRed(true); + this.color.setGreen(true); + this.color.setBlack(true); + this.power = new MageInt(3); + this.toughness = new MageInt(3); + + // {2}{B}, Sacrifice a creature: Each other player sacrifices a creature. + FilterControlledCreaturePermanent filterCreature = new FilterControlledCreaturePermanent("a creature"); + Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new ShattergangBrothersEffect(filterCreature), new ManaCostsImpl("{2}{B}")); + ability.addCost(new SacrificeTargetCost(new TargetControlledCreaturePermanent(1,1, filterCreature, true, true))); + this.addAbility(ability); + // {2}{R}, Sacrifice an artifact: Each other player sacrifices an artifact. + FilterControlledPermanent filter = new FilterControlledArtifactPermanent("an artifact"); + ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new ShattergangBrothersEffect(filter), new ManaCostsImpl("{2}{R}")); + ability.addCost(new SacrificeTargetCost(new TargetControlledPermanent(1,1, filter, true))); + this.addAbility(ability); + // {2}{G}, Sacrifice an enchantment: Each other player sacrifices an enchantment. + filter = new FilterControlledPermanent("an enchantment"); + filter.add(new CardTypePredicate(CardType.ENCHANTMENT)); + ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new ShattergangBrothersEffect(filter), new ManaCostsImpl("{2}{G}")); + ability.addCost(new SacrificeTargetCost(new TargetControlledPermanent(1,1, filter, true))); + this.addAbility(ability); + } + + public ShattergangBrothers(final ShattergangBrothers card) { + super(card); + } + + @Override + public ShattergangBrothers copy() { + return new ShattergangBrothers(this); + } +} + +class ShattergangBrothersEffect extends OneShotEffect { + + private FilterControlledPermanent filter; + + public ShattergangBrothersEffect(FilterControlledPermanent filter) { + super(Outcome.Sacrifice); + this.filter = filter; + this.staticText = new StringBuilder("Each other player sacrifices ").append(filter.getMessage()).toString(); + } + + public ShattergangBrothersEffect(final ShattergangBrothersEffect effect) { + super(effect); + this.filter = effect.filter; + } + + @Override + public ShattergangBrothersEffect copy() { + return new ShattergangBrothersEffect(this); + } + + @Override + public boolean apply(Game game, Ability source) { + Player controller = game.getPlayer(source.getControllerId()); + if (controller != null) { + for(UUID playerId : controller.getInRange()) { + if (playerId != source.getControllerId()) { + Player player = game.getPlayer(playerId); + if (player != null) { + TargetControlledPermanent target = new TargetControlledPermanent(filter); + target.setRequired(true); + target.setNotTarget(true); + if (target.canChoose(source.getSourceId(), playerId, game) && + player.chooseTarget(outcome, target, source, game)) { + Permanent permanent = game.getPermanent(target.getFirstTarget()); + if (permanent != null) { + permanent.sacrifice(source.getSourceId(), game); + } + } + } + } + } + return true; + } + return false; + } +} diff --git a/Mage.Sets/src/mage/sets/commander2013/TemptWithDiscovery.java b/Mage.Sets/src/mage/sets/commander2013/TemptWithDiscovery.java index 73be4c2a86..08d02590f9 100644 --- a/Mage.Sets/src/mage/sets/commander2013/TemptWithDiscovery.java +++ b/Mage.Sets/src/mage/sets/commander2013/TemptWithDiscovery.java @@ -74,7 +74,7 @@ class TemptWithDiscoveryEffect extends OneShotEffect { public TemptWithDiscoveryEffect() { super(Outcome.PutLandInPlay); - this.staticText = "Tempting offer - Search your library for a land card and put it onto the battlefield. Each opponent may search his or her library for a land card and put it onto the battlefield. For each opponent who searches a library this way, search your library for a land card and put it onto the battlefield. Then each player who searched a library this way shuffles it."; + this.staticText = "Tempting offer - Search your library for a land card and put it onto the battlefield. Each opponent may search his or her library for a land card and put it onto the battlefield. For each opponent who searches a library this way, search your library for a land card and put it onto the battlefield. Then each player who searched a library this way shuffles it"; } public TemptWithDiscoveryEffect(final TemptWithDiscoveryEffect effect) { diff --git a/Mage.Sets/src/mage/sets/commander2013/TemptWithVengeance.java b/Mage.Sets/src/mage/sets/commander2013/TemptWithVengeance.java new file mode 100644 index 0000000000..3a4240e723 --- /dev/null +++ b/Mage.Sets/src/mage/sets/commander2013/TemptWithVengeance.java @@ -0,0 +1,126 @@ +/* + * 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.sets.commander2013; + +import java.util.UUID; +import mage.MageInt; +import mage.abilities.Ability; +import mage.abilities.effects.OneShotEffect; +import mage.abilities.keyword.HasteAbility; +import mage.cards.CardImpl; +import mage.constants.CardType; +import mage.constants.Outcome; +import mage.constants.Rarity; +import mage.game.Game; +import mage.game.permanent.token.Token; +import mage.players.Player; + +/** + * + * @author LevelX2 + */ +public class TemptWithVengeance extends CardImpl { + + public TemptWithVengeance(UUID ownerId) { + super(ownerId, 125, "Tempt with Vengeance", Rarity.RARE, new CardType[]{CardType.SORCERY}, "{X}{R}"); + this.expansionSetCode = "C13"; + + this.color.setRed(true); + + // Tempting offer - Put X 1/1 red Elemental creature tokens with haste onto the battlefield. Each opponent may put X 1/1 red Elemental creature tokens with haste onto the battlefield. For each player who does, put X 1/1 red Elemental creature tokens with haste onto the battlefield. + this.getSpellAbility().addEffect(new TemptWithVengeanceEffect()); + } + + public TemptWithVengeance(final TemptWithVengeance card) { + super(card); + } + + @Override + public TemptWithVengeance copy() { + return new TemptWithVengeance(this); + } +} + +class TemptWithVengeanceEffect extends OneShotEffect { + + public TemptWithVengeanceEffect() { + super(Outcome.PutLandInPlay); + this.staticText = "Tempting offer - Put X 1/1 red Elemental creature tokens with haste onto the battlefield. Each opponent may put X 1/1 red Elemental creature tokens with haste onto the battlefield. For each player who does, put X 1/1 red Elemental creature tokens with haste onto the battlefield"; + } + + public TemptWithVengeanceEffect(final TemptWithVengeanceEffect effect) { + super(effect); + } + + @Override + public TemptWithVengeanceEffect copy() { + return new TemptWithVengeanceEffect(this); + } + + @Override + public boolean apply(Game game, Ability source) { + Player controller = game.getPlayer(source.getControllerId()); + int xValue = source.getManaCostsToPay().getX(); + if (controller != null && xValue > 0) { + + Token tokenCopy = new TemptWithVengeanceElementalToken(); + tokenCopy.putOntoBattlefield(xValue, game, source.getSourceId(), source.getControllerId(), false, false); + + int opponentsAddedTokens = 0; + for (UUID playerId : game.getOpponents(controller.getId())) { + Player opponent = game.getPlayer(playerId); + if (opponent != null) { + if (opponent.chooseUse(outcome, new StringBuilder("Put ").append(xValue).append(" Elemental Tokens onto the battlefield?").toString(), game)) { + opponentsAddedTokens += xValue; + tokenCopy.putOntoBattlefield(xValue, game, source.getSourceId(), playerId, false, false); + } + } + } + if (opponentsAddedTokens > 0) { + tokenCopy.putOntoBattlefield(opponentsAddedTokens, game, source.getSourceId(), source.getControllerId(), false, false); + } + return true; + } + + return false; + } +} + +class TemptWithVengeanceElementalToken extends Token { + + public TemptWithVengeanceElementalToken() { + super("Elemental", "1/1 red Elemental creature tokens with haste"); + cardType.add(CardType.CREATURE); + subtype.add("Elemental"); + + color.setRed(true); + power = new MageInt(1); + toughness = new MageInt(1); + this.addAbility(HasteAbility.getInstance()); + } +} diff --git a/Mage.Sets/src/mage/sets/eighthedition/Fecundity.java b/Mage.Sets/src/mage/sets/eighthedition/Fecundity.java new file mode 100644 index 0000000000..ea229411d3 --- /dev/null +++ b/Mage.Sets/src/mage/sets/eighthedition/Fecundity.java @@ -0,0 +1,52 @@ +/* + * 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.sets.eighthedition; + +import java.util.UUID; + +/** + * + * @author LevelX2 + */ +public class Fecundity extends mage.sets.urzassaga.Fecundity { + + public Fecundity(UUID ownerId) { + super(ownerId); + this.cardNumber = 247; + this.expansionSetCode = "8ED"; + } + + public Fecundity(final Fecundity card) { + super(card); + } + + @Override + public Fecundity copy() { + return new Fecundity(this); + } +} diff --git a/Mage.Sets/src/mage/sets/innistrad/GrimgrinCorpseBorn.java b/Mage.Sets/src/mage/sets/innistrad/GrimgrinCorpseBorn.java index 99ed20c496..6f7395d8f4 100644 --- a/Mage.Sets/src/mage/sets/innistrad/GrimgrinCorpseBorn.java +++ b/Mage.Sets/src/mage/sets/innistrad/GrimgrinCorpseBorn.java @@ -28,9 +28,6 @@ package mage.sets.innistrad; import java.util.UUID; -import mage.constants.CardType; -import mage.constants.Rarity; -import mage.constants.Zone; import mage.MageInt; import mage.abilities.TriggeredAbilityImpl; import mage.abilities.common.EntersBattlefieldTappedAbility; @@ -42,6 +39,9 @@ import mage.abilities.effects.common.SkipUntapSourceEffect; import mage.abilities.effects.common.UntapSourceEffect; import mage.abilities.effects.common.counter.AddCountersSourceEffect; import mage.cards.CardImpl; +import mage.constants.CardType; +import mage.constants.Rarity; +import mage.constants.Zone; import mage.counters.CounterType; import mage.filter.common.FilterControlledCreaturePermanent; import mage.filter.common.FilterCreaturePermanent; @@ -59,7 +59,6 @@ import mage.target.common.TargetCreaturePermanent; public class GrimgrinCorpseBorn extends CardImpl { private static final FilterControlledCreaturePermanent filter = new FilterControlledCreaturePermanent("another creature"); - static { filter.add(new AnotherPredicate()); } diff --git a/Mage.Sets/src/mage/sets/urzassaga/Fecundity.java b/Mage.Sets/src/mage/sets/urzassaga/Fecundity.java new file mode 100644 index 0000000000..264fe13d6b --- /dev/null +++ b/Mage.Sets/src/mage/sets/urzassaga/Fecundity.java @@ -0,0 +1,99 @@ +/* + * 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.sets.urzassaga; + +import java.util.UUID; +import mage.abilities.Ability; +import mage.abilities.common.DiesCreatureTriggeredAbility; +import mage.abilities.effects.OneShotEffect; +import mage.cards.CardImpl; +import mage.constants.CardType; +import mage.constants.Outcome; +import mage.constants.Rarity; +import mage.constants.Zone; +import mage.game.Game; +import mage.game.permanent.Permanent; +import mage.players.Player; + +/** + * + * @author LevelX2 + */ +public class Fecundity extends CardImpl { + + public Fecundity(UUID ownerId) { + super(ownerId, 251, "Fecundity", Rarity.UNCOMMON, new CardType[]{CardType.ENCHANTMENT}, "{2}{G}"); + this.expansionSetCode = "USG"; + + this.color.setGreen(true); + + // Whenever a creature dies, that creature's controller may draw a card. + this.addAbility(new DiesCreatureTriggeredAbility(new FecundityEffect(), false, false, true)); + } + + public Fecundity(final Fecundity card) { + super(card); + } + + @Override + public Fecundity copy() { + return new Fecundity(this); + } +} + +class FecundityEffect extends OneShotEffect { + + public FecundityEffect() { + super(Outcome.DrawCard); + this.staticText = "that creature's controller may draw a card"; + } + + public FecundityEffect(final FecundityEffect effect) { + super(effect); + } + + @Override + public FecundityEffect copy() { + return new FecundityEffect(this); + } + + @Override + public boolean apply(Game game, Ability source) { + Permanent permanent = (Permanent) game.getLastKnownInformation(this.getTargetPointer().getFirst(game, source), Zone.BATTLEFIELD); + if (permanent != null) { + Player controller = game.getPlayer(permanent.getControllerId()); + if (controller != null) { + if (controller.chooseUse(outcome, "Draw a card?", game)) { + controller.drawCards(1, game); + } + return true; + } + } + return false; + } +}