From 3386a2e9836e2785e6a96ff9cb7520bce09e8caf Mon Sep 17 00:00:00 2001 From: LevelX2 Date: Fri, 29 Mar 2013 19:00:38 +0100 Subject: [PATCH] Added Figure of Destiny, River of Tears, Ancient Amphitheater, Aunties Hovel, Gilt Leaf Palace, Mistbind Clique, Secluded Glen, Wanderwine Hub, Sygg, River Cutthroat, Sudden Spoiling, Trickbind. --- .../mage/sets/eventide/FigureOfDestiny.java | 156 ++++++++++++++++++ .../mage/sets/futuresight/RiverOfTears.java | 73 ++++++++ .../mage/sets/lorwyn/AncientAmphitheater.java | 75 +++++++++ .../src/mage/sets/lorwyn/AuntiesHovel.java | 73 ++++++++ .../src/mage/sets/lorwyn/GiltLeafPalace.java | 74 +++++++++ .../src/mage/sets/lorwyn/MistbindClique.java | 154 +++++++++++++++++ .../src/mage/sets/lorwyn/SecludedGlen.java | 73 ++++++++ .../src/mage/sets/lorwyn/WanderwineHub.java | 74 +++++++++ .../sets/shadowmoor/SyggRiverCutthroat.java | 76 +++++++++ .../mage/sets/timespiral/SuddenSpoiling.java | 138 ++++++++++++++++ .../src/mage/sets/timespiral/Trickbind.java | 141 ++++++++++++++++ 11 files changed, 1107 insertions(+) create mode 100644 Mage.Sets/src/mage/sets/eventide/FigureOfDestiny.java create mode 100644 Mage.Sets/src/mage/sets/futuresight/RiverOfTears.java create mode 100644 Mage.Sets/src/mage/sets/lorwyn/AncientAmphitheater.java create mode 100644 Mage.Sets/src/mage/sets/lorwyn/AuntiesHovel.java create mode 100644 Mage.Sets/src/mage/sets/lorwyn/GiltLeafPalace.java create mode 100644 Mage.Sets/src/mage/sets/lorwyn/MistbindClique.java create mode 100644 Mage.Sets/src/mage/sets/lorwyn/SecludedGlen.java create mode 100644 Mage.Sets/src/mage/sets/lorwyn/WanderwineHub.java create mode 100644 Mage.Sets/src/mage/sets/shadowmoor/SyggRiverCutthroat.java create mode 100644 Mage.Sets/src/mage/sets/timespiral/SuddenSpoiling.java create mode 100644 Mage.Sets/src/mage/sets/timespiral/Trickbind.java diff --git a/Mage.Sets/src/mage/sets/eventide/FigureOfDestiny.java b/Mage.Sets/src/mage/sets/eventide/FigureOfDestiny.java new file mode 100644 index 00000000000..2052f920937 --- /dev/null +++ b/Mage.Sets/src/mage/sets/eventide/FigureOfDestiny.java @@ -0,0 +1,156 @@ +/* + * 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.eventide; + +import java.util.UUID; +import mage.Constants.CardType; +import mage.Constants.Duration; +import mage.Constants.Rarity; +import mage.Constants.Zone; +import mage.MageInt; +import mage.abilities.common.SimpleActivatedAbility; +import mage.abilities.condition.common.SourceMatchesFilterCondition; +import mage.abilities.costs.mana.ManaCostsImpl; +import mage.abilities.decorator.ConditionalContinousEffect; +import mage.abilities.effects.common.continious.BecomesCreatureSourceEffect; +import mage.abilities.keyword.FirstStrikeAbility; +import mage.abilities.keyword.FlyingAbility; +import mage.cards.CardImpl; +import mage.filter.common.FilterCreaturePermanent; +import mage.filter.predicate.mageobject.SubtypePredicate; +import mage.game.permanent.token.Token; + +/** + * + * @author LevelX2 + */ +public class FigureOfDestiny extends CardImpl { + + private static final FilterCreaturePermanent filter2 = new FilterCreaturePermanent(); + private static final FilterCreaturePermanent filter3 = new FilterCreaturePermanent(); + static { + filter2.add(new SubtypePredicate("Spirit")); + filter3.add(new SubtypePredicate("Warrior")); + } + + public FigureOfDestiny(UUID ownerId) { + super(ownerId, 139, "Figure of Destiny", Rarity.RARE, new CardType[]{CardType.CREATURE}, "{R/W}"); + this.expansionSetCode = "EVE"; + this.subtype.add("Kithkin"); + + this.color.setRed(true); + this.color.setWhite(true); + this.power = new MageInt(1); + this.toughness = new MageInt(1); + + // {RW}: Figure of Destiny becomes a 2/2 Kithkin Spirit. + this.addAbility(new SimpleActivatedAbility( + Zone.BATTLEFIELD, + new BecomesCreatureSourceEffect(new FigureOfDestiny.FigureOfDestinyToken1(), "", Duration.WhileOnBattlefield), + new ManaCostsImpl("{R/W}"))); + // {RW}{RW}{RW}: If Figure of Destiny is a Spirit, it becomes a 4/4 Kithkin Spirit Warrior. + this.addAbility(new SimpleActivatedAbility( + Zone.BATTLEFIELD, + new ConditionalContinousEffect( + new BecomesCreatureSourceEffect(new FigureOfDestiny.FigureOfDestinyToken2(), "", Duration.WhileOnBattlefield), + new SourceMatchesFilterCondition(filter2), + "If Figure of Destiny is a Spirit, it becomes a 4/4 Kithkin Spirit Warrior", + true), + new ManaCostsImpl("{R/W}{R/W}{R/W}") + )); + // {RW}{RW}{RW}{RW}{RW}{RW}: If Figure of Destiny is a Warrior, it becomes an 8/8 Kithkin Spirit Warrior Avatar with flying and first strike. + this.addAbility(new SimpleActivatedAbility( + Zone.BATTLEFIELD, + new ConditionalContinousEffect( + new BecomesCreatureSourceEffect(new FigureOfDestiny.FigureOfDestinyToken3(), "", Duration.WhileOnBattlefield), + new SourceMatchesFilterCondition(filter3), + "If Figure of Destiny is a Warrior, it becomes an 8/8 Kithkin Spirit Warrior Avatar with flying and first strike", + true), + new ManaCostsImpl("{R/W}{R/W}{R/W}{R/W}{R/W}{R/W}") + )); + } + + public FigureOfDestiny(final FigureOfDestiny card) { + super(card); + } + + @Override + public FigureOfDestiny copy() { + return new FigureOfDestiny(this); + } + + private class FigureOfDestinyToken1 extends Token { + + public FigureOfDestinyToken1() { + super("Figure of Destiny", "2/2 Kithkin Spirit"); + this.cardType.add(CardType.CREATURE); + this.subtype.add("Kithkin"); + this.subtype.add("Spirit"); + + this.color.setRed(true); + this.color.setWhite(true); + this.power = new MageInt(2); + this.toughness = new MageInt(2); + } + } + + private class FigureOfDestinyToken2 extends Token { + + public FigureOfDestinyToken2() { + super("Figure of Destiny", "4/4 Kithkin Spirit Warrior"); + this.cardType.add(CardType.CREATURE); + this.subtype.add("Kithkin"); + this.subtype.add("Spirit"); + this.subtype.add("Warrior"); + + this.color.setRed(true); + this.color.setWhite(true); + this.power = new MageInt(4); + this.toughness = new MageInt(4); + } + } + + private class FigureOfDestinyToken3 extends Token { + + public FigureOfDestinyToken3() { + super("Figure of Destiny", "8/8 Kithkin Spirit Warrior Avatar with flying and first strike"); + this.cardType.add(CardType.CREATURE); + this.subtype.add("Kithkin"); + this.subtype.add("Spirit"); + this.subtype.add("Warrior"); + this.subtype.add("Avatar"); + + this.color.setRed(true); + this.color.setWhite(true); + this.power = new MageInt(8); + this.toughness = new MageInt(8); + this.addAbility(FlyingAbility.getInstance()); + this.addAbility(FirstStrikeAbility.getInstance()); + } + } +} diff --git a/Mage.Sets/src/mage/sets/futuresight/RiverOfTears.java b/Mage.Sets/src/mage/sets/futuresight/RiverOfTears.java new file mode 100644 index 00000000000..ba0c248ae20 --- /dev/null +++ b/Mage.Sets/src/mage/sets/futuresight/RiverOfTears.java @@ -0,0 +1,73 @@ +/* + * 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.futuresight; + +import java.util.UUID; +import mage.Constants.CardType; +import mage.Constants.Rarity; +import mage.Constants.Zone; +import mage.Mana; +import mage.abilities.condition.common.LandfallCondition; +import mage.abilities.costs.common.TapSourceCost; +import mage.abilities.decorator.ConditionalManaEffect; +import mage.abilities.effects.common.BasicManaEffect; +import mage.abilities.mana.SimpleManaAbility; +import mage.cards.CardImpl; +import mage.watchers.common.LandfallWatcher; + +/** + * + * @author LevelX2 + */ +public class RiverOfTears extends CardImpl { + + public RiverOfTears(UUID ownerId) { + super(ownerId, 179, "River of Tears", Rarity.RARE, new CardType[]{CardType.LAND}, ""); + this.expansionSetCode = "FUT"; + + // {tap}: Add {U} to your mana pool. If you played a land this turn, add {B} to your mana pool instead. + this.addAbility(new SimpleManaAbility(Zone.BATTLEFIELD, new ConditionalManaEffect( + new BasicManaEffect(Mana.BlackMana), + new BasicManaEffect(Mana.BlueMana), + LandfallCondition.getInstance(), + "Add {U} to your mana pool. If you played a land this turn, add {B} to your mana pool instead"), + new TapSourceCost())); + + + this.addWatcher(new LandfallWatcher()); + } + + public RiverOfTears(final RiverOfTears card) { + super(card); + } + + @Override + public RiverOfTears copy() { + return new RiverOfTears(this); + } +} diff --git a/Mage.Sets/src/mage/sets/lorwyn/AncientAmphitheater.java b/Mage.Sets/src/mage/sets/lorwyn/AncientAmphitheater.java new file mode 100644 index 00000000000..dc095287ceb --- /dev/null +++ b/Mage.Sets/src/mage/sets/lorwyn/AncientAmphitheater.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.sets.lorwyn; + +import java.util.UUID; +import mage.Constants.CardType; +import mage.Constants.Rarity; +import mage.abilities.common.AsEntersBattlefieldAbility; +import mage.abilities.costs.common.RevealTargetFromHandCost; +import mage.abilities.effects.common.TapSourceUnlessPaysEffect; +import mage.abilities.mana.RedManaAbility; +import mage.abilities.mana.WhiteManaAbility; +import mage.cards.CardImpl; +import mage.filter.FilterCard; +import mage.filter.predicate.mageobject.SubtypePredicate; +import mage.target.common.TargetCardInHand; + +/** + * + * @author LevelX2 + */ +public class AncientAmphitheater extends CardImpl { + + private static final FilterCard filter = new FilterCard("a Giant from your hand"); + static { + filter.add(new SubtypePredicate("Giant")); + } + + public AncientAmphitheater(UUID ownerId) { + super(ownerId, 266, "Ancient Amphitheater", Rarity.RARE, new CardType[]{CardType.LAND}, ""); + this.expansionSetCode = "LRW"; + + // As Ancient Amphitheater enters the battlefield, you may reveal a Giant card from your hand. If you don't, Ancient Amphitheater enters the battlefield tapped. + this.addAbility(new AsEntersBattlefieldAbility(new TapSourceUnlessPaysEffect(new RevealTargetFromHandCost(new TargetCardInHand(filter))), "you may reveal a Giant card from your hand. If you don't, {this} enters the battlefield tapped")); + // {tap}: Add {R} or {W} to your mana pool. + this.addAbility(new RedManaAbility()); + this.addAbility(new WhiteManaAbility()); + + + } + + public AncientAmphitheater(final AncientAmphitheater card) { + super(card); + } + + @Override + public AncientAmphitheater copy() { + return new AncientAmphitheater(this); + } +} diff --git a/Mage.Sets/src/mage/sets/lorwyn/AuntiesHovel.java b/Mage.Sets/src/mage/sets/lorwyn/AuntiesHovel.java new file mode 100644 index 00000000000..78154176dda --- /dev/null +++ b/Mage.Sets/src/mage/sets/lorwyn/AuntiesHovel.java @@ -0,0 +1,73 @@ +/* + * 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.lorwyn; + +import java.util.UUID; +import mage.Constants.CardType; +import mage.Constants.Rarity; +import mage.abilities.common.AsEntersBattlefieldAbility; +import mage.abilities.costs.common.RevealTargetFromHandCost; +import mage.abilities.effects.common.TapSourceUnlessPaysEffect; +import mage.abilities.mana.BlackManaAbility; +import mage.abilities.mana.RedManaAbility; +import mage.cards.CardImpl; +import mage.filter.FilterCard; +import mage.filter.predicate.mageobject.SubtypePredicate; +import mage.target.common.TargetCardInHand; + +/** + * + * @author LevelX2 + */ +public class AuntiesHovel extends CardImpl { + + private static final FilterCard filter = new FilterCard("a Goblin from your hand"); + static { + filter.add(new SubtypePredicate("Goblin")); + } + + public AuntiesHovel(UUID ownerId) { + super(ownerId, 267, "Auntie's Hovel", Rarity.RARE, new CardType[]{CardType.LAND}, ""); + this.expansionSetCode = "LRW"; + + // As Auntie's Hovel enters the battlefield, you may reveal a Goblin card from your hand. If you don't, Auntie's Hovel enters the battlefield tapped. + this.addAbility(new AsEntersBattlefieldAbility(new TapSourceUnlessPaysEffect(new RevealTargetFromHandCost(new TargetCardInHand(filter))), "you may reveal a Goblin card from your hand. If you don't, {this} enters the battlefield tapped")); + // {tap}: Add {B} or {R} to your mana pool. + this.addAbility(new BlackManaAbility()); + this.addAbility(new RedManaAbility()); + } + + public AuntiesHovel(final AuntiesHovel card) { + super(card); + } + + @Override + public AuntiesHovel copy() { + return new AuntiesHovel(this); + } +} diff --git a/Mage.Sets/src/mage/sets/lorwyn/GiltLeafPalace.java b/Mage.Sets/src/mage/sets/lorwyn/GiltLeafPalace.java new file mode 100644 index 00000000000..a48fd1a5992 --- /dev/null +++ b/Mage.Sets/src/mage/sets/lorwyn/GiltLeafPalace.java @@ -0,0 +1,74 @@ +/* + * 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.lorwyn; + +import java.util.UUID; +import mage.Constants.CardType; +import mage.Constants.Rarity; +import mage.abilities.common.AsEntersBattlefieldAbility; +import mage.abilities.costs.common.RevealTargetFromHandCost; +import mage.abilities.effects.common.TapSourceUnlessPaysEffect; +import mage.abilities.mana.BlackManaAbility; +import mage.abilities.mana.GreenManaAbility; +import mage.cards.CardImpl; +import mage.filter.FilterCard; +import mage.filter.predicate.mageobject.SubtypePredicate; +import mage.target.common.TargetCardInHand; + +/** + * + * @author LevelX2 + */ +public class GiltLeafPalace extends CardImpl { + + private static final FilterCard filter = new FilterCard("a Elf from your hand"); + static { + filter.add(new SubtypePredicate("Elf")); + } + + public GiltLeafPalace(UUID ownerId) { + super(ownerId, 268, "Gilt-Leaf Palace", Rarity.RARE, new CardType[]{CardType.LAND}, ""); + this.expansionSetCode = "LRW"; + + // As Gilt-Leaf Palace enters the battlefield, you may reveal an Elf card from your hand. If you don't, Gilt-Leaf Palace enters the battlefield tapped. + this.addAbility(new AsEntersBattlefieldAbility(new TapSourceUnlessPaysEffect(new RevealTargetFromHandCost(new TargetCardInHand(filter))), "you may reveal a Elf card from your hand. If you don't, {this} enters the battlefield tapped")); + // {tap}: Add {B} or {G} to your mana pool. + this.addAbility(new BlackManaAbility()); + this.addAbility(new GreenManaAbility()); + + } + + public GiltLeafPalace(final GiltLeafPalace card) { + super(card); + } + + @Override + public GiltLeafPalace copy() { + return new GiltLeafPalace(this); + } +} diff --git a/Mage.Sets/src/mage/sets/lorwyn/MistbindClique.java b/Mage.Sets/src/mage/sets/lorwyn/MistbindClique.java new file mode 100644 index 00000000000..30f9b18d79a --- /dev/null +++ b/Mage.Sets/src/mage/sets/lorwyn/MistbindClique.java @@ -0,0 +1,154 @@ +/* + * 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.lorwyn; + +import java.util.List; +import java.util.UUID; +import mage.Constants.CardType; +import mage.Constants.Outcome; +import mage.Constants.Rarity; +import mage.Constants.Zone; +import mage.MageInt; +import mage.MageObject; +import mage.abilities.Ability; +import mage.abilities.common.ZoneChangeTriggeredAbility; +import mage.abilities.effects.OneShotEffect; +import mage.abilities.keyword.ChampionAbility; +import mage.abilities.keyword.FlashAbility; +import mage.abilities.keyword.FlyingAbility; +import mage.cards.CardImpl; +import mage.filter.common.FilterLandPermanent; +import mage.filter.predicate.permanent.ControllerIdPredicate; +import mage.game.Game; +import mage.game.events.GameEvent; +import mage.game.events.ZoneChangeEvent; +import mage.game.permanent.Permanent; +import mage.target.TargetPlayer; + +/** + * + * @author LevelX2 + */ +public class MistbindClique extends CardImpl { + + public MistbindClique(UUID ownerId) { + super(ownerId, 75, "Mistbind Clique", Rarity.RARE, new CardType[]{CardType.CREATURE}, "{3}{U}"); + this.expansionSetCode = "LRW"; + this.subtype.add("Faerie"); + this.subtype.add("Wizard"); + + this.color.setBlue(true); + this.power = new MageInt(4); + this.toughness = new MageInt(4); + + // Flash + this.addAbility(FlashAbility.getInstance()); + // Flying + this.addAbility(FlyingAbility.getInstance()); + // Champion a Faerie + this.addAbility(new ChampionAbility(this, "Faerie")); + + // When a Faerie is championed with Mistbind Clique, tap all lands target player controls. + this.addAbility(new MistbindCliqueAbility()); + + + } + + public MistbindClique(final MistbindClique card) { + super(card); + } + + @Override + public MistbindClique copy() { + return new MistbindClique(this); + } +} + +class MistbindCliqueAbility extends ZoneChangeTriggeredAbility { + + public MistbindCliqueAbility() { + super(Zone.BATTLEFIELD, Zone.EXILED, new MistbindCliqueTapEffect(), "When a Faerie is championed with {this}, ", false); + this.addTarget(new TargetPlayer()); + } + + public MistbindCliqueAbility(MistbindCliqueAbility ability) { + super(ability); + } + + @Override + public MistbindCliqueAbility copy() { + return new MistbindCliqueAbility(this); + } + + @Override + public boolean checkTrigger(GameEvent event, Game game) { + if (event.getType() == GameEvent.EventType.ZONE_CHANGE && event.getSourceId() != null && event.getSourceId().equals(getSourceId())) { + ZoneChangeEvent zEvent = (ZoneChangeEvent)event; + if (zEvent.getFromZone() == Zone.BATTLEFIELD && zEvent.getToZone() == Zone.EXILED) { + MageObject object = game.getObject(event.getTargetId()); + if (object != null && object.getSubtype().contains("Faerie")) { + return true; + } + } + } + return false; + } +} + +class MistbindCliqueTapEffect extends OneShotEffect { + + public MistbindCliqueTapEffect() { + super(Outcome.Tap); + staticText = "tap all lands target player controls"; + } + + public MistbindCliqueTapEffect(final MistbindCliqueTapEffect effect) { + super(effect); + } + + @Override + public boolean apply(Game game, Ability source) { + if (source.getFirstTarget() == null) { + return false; + } + + FilterLandPermanent filter = new FilterLandPermanent(); + filter.add(new ControllerIdPredicate(source.getFirstTarget())); + + List lands = game.getBattlefield().getActivePermanents(filter, source.getControllerId(), source.getSourceId(), game); + for (Permanent land : lands) { + land.tap(game); + } + return true; + } + + @Override + public MistbindCliqueTapEffect copy() { + return new MistbindCliqueTapEffect(this); + } +} diff --git a/Mage.Sets/src/mage/sets/lorwyn/SecludedGlen.java b/Mage.Sets/src/mage/sets/lorwyn/SecludedGlen.java new file mode 100644 index 00000000000..f06c65a8596 --- /dev/null +++ b/Mage.Sets/src/mage/sets/lorwyn/SecludedGlen.java @@ -0,0 +1,73 @@ +/* + * 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.lorwyn; + +import java.util.UUID; +import mage.Constants.CardType; +import mage.Constants.Rarity; +import mage.abilities.common.AsEntersBattlefieldAbility; +import mage.abilities.costs.common.RevealTargetFromHandCost; +import mage.abilities.effects.common.TapSourceUnlessPaysEffect; +import mage.abilities.mana.BlackManaAbility; +import mage.abilities.mana.BlueManaAbility; +import mage.cards.CardImpl; +import mage.filter.FilterCard; +import mage.filter.predicate.mageobject.SubtypePredicate; +import mage.target.common.TargetCardInHand; + +/** + * + * @author LevelX2 + */ +public class SecludedGlen extends CardImpl { + + private static final FilterCard filter = new FilterCard("a Faerie from your hand"); + static { + filter.add(new SubtypePredicate("Faerie")); + } + + public SecludedGlen(UUID ownerId) { + super(ownerId, 271, "Secluded Glen", Rarity.RARE, new CardType[]{CardType.LAND}, ""); + this.expansionSetCode = "LRW"; + + // As Secluded Glen enters the battlefield, you may reveal a Faerie card from your hand. If you don't, Secluded Glen enters the battlefield tapped. + this.addAbility(new AsEntersBattlefieldAbility(new TapSourceUnlessPaysEffect(new RevealTargetFromHandCost(new TargetCardInHand(filter))), "you may reveal a Faerie card from your hand. If you don't, {this} enters the battlefield tapped")); + // {tap}: Add {U} or {B} to your mana pool. + this.addAbility(new BlueManaAbility()); + this.addAbility(new BlackManaAbility()); + } + + public SecludedGlen(final SecludedGlen card) { + super(card); + } + + @Override + public SecludedGlen copy() { + return new SecludedGlen(this); + } +} diff --git a/Mage.Sets/src/mage/sets/lorwyn/WanderwineHub.java b/Mage.Sets/src/mage/sets/lorwyn/WanderwineHub.java new file mode 100644 index 00000000000..b4d6f4ba3ef --- /dev/null +++ b/Mage.Sets/src/mage/sets/lorwyn/WanderwineHub.java @@ -0,0 +1,74 @@ +/* + * 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.lorwyn; + +import java.util.UUID; +import mage.Constants.CardType; +import mage.Constants.Rarity; +import mage.abilities.common.AsEntersBattlefieldAbility; +import mage.abilities.costs.common.RevealTargetFromHandCost; +import mage.abilities.effects.common.TapSourceUnlessPaysEffect; +import mage.abilities.mana.BlueManaAbility; +import mage.abilities.mana.WhiteManaAbility; +import mage.cards.CardImpl; +import mage.filter.FilterCard; +import mage.filter.predicate.mageobject.SubtypePredicate; +import mage.target.common.TargetCardInHand; + +/** + * + * @author LevelX2 + */ +public class WanderwineHub extends CardImpl { + + private static final FilterCard filter = new FilterCard("a Merfolk from your hand"); + static { + filter.add(new SubtypePredicate("Merfolk")); + } + + public WanderwineHub(UUID ownerId) { + super(ownerId, 280, "Wanderwine Hub", Rarity.RARE, new CardType[]{CardType.LAND}, ""); + this.expansionSetCode = "LRW"; + + // As Wanderwine Hub enters the battlefield, you may reveal a Merfolk card from your hand. If you don't, Wanderwine Hub enters the battlefield tapped. + this.addAbility(new AsEntersBattlefieldAbility(new TapSourceUnlessPaysEffect(new RevealTargetFromHandCost(new TargetCardInHand(filter))), "you may reveal a Merfolk card from your hand. If you don't, {this} enters the battlefield tapped")); + // {tap}: Add {W} or {U} to your mana pool. + this.addAbility(new WhiteManaAbility()); + this.addAbility(new BlueManaAbility()); + + } + + public WanderwineHub(final WanderwineHub card) { + super(card); + } + + @Override + public WanderwineHub copy() { + return new WanderwineHub(this); + } +} diff --git a/Mage.Sets/src/mage/sets/shadowmoor/SyggRiverCutthroat.java b/Mage.Sets/src/mage/sets/shadowmoor/SyggRiverCutthroat.java new file mode 100644 index 00000000000..46e815931bd --- /dev/null +++ b/Mage.Sets/src/mage/sets/shadowmoor/SyggRiverCutthroat.java @@ -0,0 +1,76 @@ +/* + * 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.shadowmoor; + +import java.util.UUID; +import mage.Constants; +import mage.Constants.CardType; +import mage.Constants.Rarity; +import mage.Constants.Zone; +import mage.MageInt; +import mage.abilities.common.BeginningOfEndStepTriggeredAbility; +import mage.abilities.condition.Condition; +import mage.abilities.condition.common.OpponentLostLifeCondition; +import mage.abilities.effects.common.DrawCardControllerEffect; +import mage.cards.CardImpl; + +/** + * + * @author LevelX2 + */ +public class SyggRiverCutthroat extends CardImpl { + + public SyggRiverCutthroat(UUID ownerId) { + super(ownerId, 176, "Sygg, River Cutthroat", Rarity.RARE, new CardType[]{CardType.CREATURE}, "{U/B}{U/B}"); + this.expansionSetCode = "SHM"; + this.supertype.add("Legendary"); + this.subtype.add("Merfolk"); + this.subtype.add("Rogue"); + + this.color.setBlue(true); + this.color.setBlack(true); + this.power = new MageInt(1); + this.toughness = new MageInt(3); + + // At the beginning of each end step, if an opponent lost 3 or more life this turn, you may draw a card. + this.addAbility(new BeginningOfEndStepTriggeredAbility(Zone.BATTLEFIELD, + new DrawCardControllerEffect(1), + Constants.TargetController.ANY, + new OpponentLostLifeCondition(Condition.ComparisonType.GreaterThan, 2), + true)); + } + + public SyggRiverCutthroat(final SyggRiverCutthroat card) { + super(card); + } + + @Override + public SyggRiverCutthroat copy() { + return new SyggRiverCutthroat(this); + } +} diff --git a/Mage.Sets/src/mage/sets/timespiral/SuddenSpoiling.java b/Mage.Sets/src/mage/sets/timespiral/SuddenSpoiling.java new file mode 100644 index 00000000000..8425981611b --- /dev/null +++ b/Mage.Sets/src/mage/sets/timespiral/SuddenSpoiling.java @@ -0,0 +1,138 @@ +/* + * 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.timespiral; + +import java.util.UUID; +import mage.Constants; +import mage.Constants.CardType; +import mage.Constants.Duration; +import mage.Constants.Layer; +import mage.Constants.Outcome; +import mage.Constants.Rarity; +import mage.Constants.SubLayer; +import mage.abilities.Ability; +import mage.abilities.effects.ContinuousEffectImpl; +import mage.abilities.keyword.SplitSecondAbility; +import mage.cards.CardImpl; +import mage.filter.common.FilterCreaturePermanent; +import mage.game.Game; +import mage.game.permanent.Permanent; +import mage.players.Player; +import mage.target.TargetPlayer; + +/** + * + * @author LevelX2 + */ +public class SuddenSpoiling extends CardImpl { + + public SuddenSpoiling(UUID ownerId) { + super(ownerId, 135, "Sudden Spoiling", Rarity.RARE, new CardType[]{CardType.INSTANT}, "{1}{B}{B}"); + this.expansionSetCode = "TSP"; + + this.color.setBlack(true); + + // Split second + this.addAbility(SplitSecondAbility.getInstance()); + // Creatures target player controls become 0/2 and lose all abilities until end of turn. + this.getSpellAbility().addEffect(new SuddenSpoilingEffect(Duration.EndOfTurn)); + this.getSpellAbility().addTarget(new TargetPlayer()); + + } + + public SuddenSpoiling(final SuddenSpoiling card) { + super(card); + } + + @Override + public SuddenSpoiling copy() { + return new SuddenSpoiling(this); + } +} + +class SuddenSpoilingEffect extends ContinuousEffectImpl { + + public SuddenSpoilingEffect(Duration duration) { + super(duration, Outcome.LoseAbility); + staticText = "Creatures target player controls become 0/2 and lose all abilities until end of turn"; + } + + public SuddenSpoilingEffect(final SuddenSpoilingEffect effect) { + super(effect); + } + + @Override + public SuddenSpoilingEffect copy() { + return new SuddenSpoilingEffect(this); + } + + @Override + public void init(Ability source, Game game) { + super.init(source, game); + Player player = game.getPlayer(this.getTargetPointer().getFirst(game, source)); + if (player != null) { + for (Permanent perm: game.getState().getBattlefield().getAllActivePermanents(new FilterCreaturePermanent(), player.getId(), game)) { + objects.add(perm.getId()); + } + } + } + + @Override + public boolean apply(Layer layer, Constants.SubLayer sublayer, Ability source, Game game) { + Player player = game.getPlayer(this.getTargetPointer().getFirst(game, source)); + if (player != null) { + for (Permanent permanent : game.getState().getBattlefield().getAllActivePermanents(new FilterCreaturePermanent(), player.getId(), game)) { + switch (layer) { + case AbilityAddingRemovingEffects_6: + permanent.removeAllAbilities(source.getSourceId(), game); + break; + case PTChangingEffects_7: + if (sublayer.equals(SubLayer.SetPT_7b)) { + if(objects.contains(permanent.getId())){ + permanent.getPower().setValue(0); + permanent.getToughness().setValue(2); + } + } + } + } + return true; + } + return false; + } + + @Override + public boolean apply(Game game, Ability source) { + return false; + } + + @Override + public boolean hasLayer(Constants.Layer layer) { + return layer == Layer.AbilityAddingRemovingEffects_6 || layer == Constants.Layer.PTChangingEffects_7; + } + +} diff --git a/Mage.Sets/src/mage/sets/timespiral/Trickbind.java b/Mage.Sets/src/mage/sets/timespiral/Trickbind.java new file mode 100644 index 00000000000..a4280896e00 --- /dev/null +++ b/Mage.Sets/src/mage/sets/timespiral/Trickbind.java @@ -0,0 +1,141 @@ +/* + * 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.timespiral; + +import java.util.UUID; +import mage.Constants.CardType; +import mage.Constants.Duration; +import mage.Constants.Outcome; +import mage.Constants.Rarity; +import mage.abilities.Ability; +import mage.abilities.effects.OneShotEffect; +import mage.abilities.effects.ReplacementEffectImpl; +import mage.abilities.keyword.SplitSecondAbility; +import mage.cards.CardImpl; +import mage.game.Game; +import mage.game.events.GameEvent; +import mage.game.stack.StackObject; +import mage.target.common.TargetActivatedOrTriggeredAbility; +import mage.target.targetpointer.FixedTarget; + +/** + * + * @author LevelX2 + */ +public class Trickbind extends CardImpl { + + public Trickbind(UUID ownerId) { + super(ownerId, 88, "Trickbind", Rarity.RARE, new CardType[]{CardType.INSTANT}, "{1}{U}"); + this.expansionSetCode = "TSP"; + + this.color.setBlue(true); + + // Split second + this.addAbility(SplitSecondAbility.getInstance()); + + // Counter target activated or triggered ability. If a permanent's ability is countered this way, activated abilities of that permanent can't be activated this turn. + this.getSpellAbility().addEffect(new TrickbindCounterEffect()); + this.getSpellAbility().addTarget(new TargetActivatedOrTriggeredAbility()); + } + + public Trickbind(final Trickbind card) { + super(card); + } + + @Override + public Trickbind copy() { + return new Trickbind(this); + } +} + +class TrickbindCounterEffect extends OneShotEffect { + + public TrickbindCounterEffect() { + super(Outcome.Detriment); + staticText = "Counter target activated or triggered ability. If a permanent's ability is countered this way, activated abilities of that permanent can't be activated this turn"; + } + + public TrickbindCounterEffect(final TrickbindCounterEffect effect) { + super(effect); + } + + @Override + public TrickbindCounterEffect copy() { + return new TrickbindCounterEffect(this); + } + + @Override + public boolean apply(Game game, Ability source) { + StackObject stackObject = game.getStack().getStackObject(source.getFirstTarget()); + if(stackObject != null && game.getStack().counter(source.getFirstTarget(), source.getSourceId(), game)) { + TrickbindReplacementEffect effect = new TrickbindReplacementEffect(); + effect.setTargetPointer(new FixedTarget(stackObject.getSourceId())); + game.getContinuousEffects().addEffect(effect, source); + return true; + } + return false; + } + +} + +class TrickbindReplacementEffect extends ReplacementEffectImpl { + + public TrickbindReplacementEffect() { + super(Duration.EndOfTurn, Outcome.LoseAbility); + staticText = "Activated abilities of that permanent can't be activated this turn"; + } + + public TrickbindReplacementEffect(final TrickbindReplacementEffect effect) { + super(effect); + } + + @Override + public TrickbindReplacementEffect copy() { + return new TrickbindReplacementEffect(this); + } + + @Override + public boolean apply(Game game, Ability source) { + return true; + } + + @Override + public boolean replaceEvent(GameEvent event, Ability source, Game game) { + return true; + } + + @Override + public boolean applies(GameEvent event, Ability source, Game game) { + if (event.getType() == GameEvent.EventType.ACTIVATE_ABILITY) { + if (this.targetPointer.getFirst(game, source).equals(event.getSourceId())) { + return true; + } + } + return false; + } +}