diff --git a/Mage.Sets/src/mage/sets/betrayersofkamigawa/HigureTheStillWind.java b/Mage.Sets/src/mage/sets/betrayersofkamigawa/HigureTheStillWind.java new file mode 100644 index 0000000000..3034de29aa --- /dev/null +++ b/Mage.Sets/src/mage/sets/betrayersofkamigawa/HigureTheStillWind.java @@ -0,0 +1,95 @@ +/* + * 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.betrayersofkamigawa; + +import java.util.UUID; +import mage.Constants; +import mage.Constants.CardType; +import mage.Constants.Rarity; +import mage.MageInt; +import mage.abilities.Ability; +import mage.abilities.common.DealsCombatDamageToAPlayerTriggeredAbility; +import mage.abilities.common.SimpleActivatedAbility; +import mage.abilities.costs.mana.GenericManaCost; +import mage.abilities.costs.mana.ManaCostsImpl; +import mage.abilities.effects.common.UnblockableTargetEffect; +import mage.abilities.effects.common.search.SearchLibraryPutInHandEffect; +import mage.abilities.keyword.NinjutsuAbility; +import mage.cards.CardImpl; +import mage.filter.FilterCard; +import mage.filter.common.FilterCreaturePermanent; +import mage.filter.predicate.mageobject.SubtypePredicate; +import mage.target.common.TargetCardInLibrary; +import mage.target.common.TargetCreaturePermanent; + +/** + * + * @author LevelX2 + */ +public class HigureTheStillWind extends CardImpl { + + private static final FilterCard filter = new FilterCard("Ninja card"); + private static final FilterCreaturePermanent filterCreature = new FilterCreaturePermanent("Ninja creature"); + static { + filter.add((new SubtypePredicate("Ninja"))); + filterCreature.add((new SubtypePredicate("Ninja"))); + } + + public HigureTheStillWind(UUID ownerId) { + super(ownerId, 37, "Higure, the Still Wind", Rarity.RARE, new CardType[]{CardType.CREATURE}, "{3}{U}{U}"); + this.expansionSetCode = "BOK"; + this.subtype.add("Human"); + this.subtype.add("Ninja"); + this.supertype.add("Legendary"); + this.color.setBlue(true); + this.power = new MageInt(3); + this.toughness = new MageInt(4); + + // Ninjutsu {2}{U}{U} ({2}{U}{U}, Return an unblocked attacker you control to hand: Put this card onto the battlefield from your hand tapped and attacking.) + this.addAbility(new NinjutsuAbility(new ManaCostsImpl("{2}{U}{U}"))); + + // Whenever Higure, the Still Wind deals combat damage to a player, you may search your library for a Ninja card, reveal it, and put it into your hand. If you do, shuffle your library. + this.addAbility(new DealsCombatDamageToAPlayerTriggeredAbility(new SearchLibraryPutInHandEffect(new TargetCardInLibrary(filter)), true, false)); + + // {2}: Target Ninja creature is unblockable this turn. + Ability ability = new SimpleActivatedAbility(Constants.Zone.BATTLEFIELD, new UnblockableTargetEffect(), new GenericManaCost(2)); + ability.addTarget(new TargetCreaturePermanent(filterCreature)); + this.addAbility(ability); + + + } + + public HigureTheStillWind(final HigureTheStillWind card) { + super(card); + } + + @Override + public HigureTheStillWind copy() { + return new HigureTheStillWind(this); + } +} \ No newline at end of file diff --git a/Mage.Sets/src/mage/sets/betrayersofkamigawa/InkEyesServantOfOni.java b/Mage.Sets/src/mage/sets/betrayersofkamigawa/InkEyesServantOfOni.java new file mode 100644 index 0000000000..51a8426384 --- /dev/null +++ b/Mage.Sets/src/mage/sets/betrayersofkamigawa/InkEyesServantOfOni.java @@ -0,0 +1,122 @@ +/* + * 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.betrayersofkamigawa; + +import java.util.UUID; +import mage.Constants; +import mage.Constants.CardType; +import mage.Constants.Rarity; +import mage.MageInt; +import mage.abilities.Ability; +import mage.abilities.common.DealsCombatDamageToAPlayerTriggeredAbility; +import mage.abilities.common.SimpleActivatedAbility; +import mage.abilities.costs.mana.ManaCostsImpl; +import mage.abilities.effects.OneShotEffect; +import mage.abilities.effects.common.RegenerateSourceEffect; +import mage.abilities.keyword.NinjutsuAbility; +import mage.cards.Card; +import mage.cards.CardImpl; +import mage.filter.FilterCard; +import mage.filter.predicate.mageobject.CardTypePredicate; +import mage.filter.predicate.other.OwnerIdPredicate; +import mage.game.Game; +import mage.players.Player; +import mage.target.common.TargetCardInGraveyard; + +/** + * + * @author LevelX2 + */ +public class InkEyesServantOfOni extends CardImpl { + + public InkEyesServantOfOni(UUID ownerId) { + super(ownerId, 71, "Ink-Eyes, Servant of Oni", Rarity.RARE, new CardType[]{CardType.CREATURE}, "{4}{B}{B}"); + this.expansionSetCode = "BOK"; + this.subtype.add("Rat"); + this.subtype.add("Ninja"); + this.supertype.add("Legendary"); + this.color.setBlack(true); + this.power = new MageInt(5); + this.toughness = new MageInt(4); + + // Ninjutsu {3}{B}{B} ({3}{B}{B}, Return an unblocked attacker you control to hand: Put this card onto the battlefield from your hand tapped and attacking.) + this.addAbility(new NinjutsuAbility(new ManaCostsImpl("{3}{B}{B}"))); + + // Whenever Ink-Eyes, Servant of Oni deals combat damage to a player, you may put target creature card from that player's graveyard onto the battlefield under your control. + this.addAbility(new DealsCombatDamageToAPlayerTriggeredAbility(new InkEyesServantOfOniEffect(), true, true)); + + // {1}{B}: Regenerate Ink-Eyes. + this.addAbility(new SimpleActivatedAbility(Constants.Zone.BATTLEFIELD, new RegenerateSourceEffect(), new ManaCostsImpl("{1}{B}"))); + } + + public InkEyesServantOfOni(final InkEyesServantOfOni card) { + super(card); + } + + @Override + public InkEyesServantOfOni copy() { + return new InkEyesServantOfOni(this); + } +} + +class InkEyesServantOfOniEffect extends OneShotEffect { + + public InkEyesServantOfOniEffect() { + super(Constants.Outcome.PutCreatureInPlay); + this.staticText = "you may put target creature card from that player's graveyard onto the battlefield under your control"; + } + + public InkEyesServantOfOniEffect(final InkEyesServantOfOniEffect effect) { + super(effect); + } + + @Override + public InkEyesServantOfOniEffect copy() { + return new InkEyesServantOfOniEffect(this); + } + + @Override + public boolean apply(Game game, Ability source) { + Player damagedPlayer = game.getPlayer(targetPointer.getFirst(game, source)); + Player you = game.getPlayer(source.getControllerId()); + FilterCard filter = new FilterCard("creature in that player's graveyard"); + filter.add(new CardTypePredicate(CardType.CREATURE)); + filter.add(new OwnerIdPredicate(damagedPlayer.getId())); + TargetCardInGraveyard target = new TargetCardInGraveyard(filter); + if (target.canChoose(source.getSourceId(), you.getId(), game)) { + if (you.chooseTarget(Constants.Outcome.PutCreatureInPlay, target, source, game)) { + Card card = game.getCard(target.getFirstTarget()); + if (card != null) { + card.putOntoBattlefield(game, Constants.Zone.GRAVEYARD, id, you.getId()); + return true; + } + } + } + return false; + } +} diff --git a/Mage.Sets/src/mage/sets/betrayersofkamigawa/MistbladeShinobi.java b/Mage.Sets/src/mage/sets/betrayersofkamigawa/MistbladeShinobi.java new file mode 100644 index 0000000000..6e2bda8cff --- /dev/null +++ b/Mage.Sets/src/mage/sets/betrayersofkamigawa/MistbladeShinobi.java @@ -0,0 +1,116 @@ +/* + * 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.betrayersofkamigawa; + +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.costs.mana.ManaCostsImpl; +import mage.abilities.effects.common.ReturnToHandTargetEffect; +import mage.abilities.keyword.NinjutsuAbility; +import mage.cards.CardImpl; +import mage.filter.common.FilterCreaturePermanent; +import mage.filter.predicate.permanent.ControllerIdPredicate; +import mage.game.Game; +import mage.game.events.DamagedPlayerEvent; +import mage.game.events.GameEvent; +import mage.players.Player; +import mage.target.common.TargetCreaturePermanent; + +/** + * + * @author LevelX2 + */ +public class MistbladeShinobi extends CardImpl { + + public MistbladeShinobi(UUID ownerId) { + super(ownerId, 43, "Mistblade Shinobi", Rarity.COMMON, new CardType[]{CardType.CREATURE}, "{2}{U}"); + this.expansionSetCode = "BOK"; + this.subtype.add("Human"); + this.subtype.add("Ninja"); + this.color.setBlue(true); + this.power = new MageInt(1); + this.toughness = new MageInt(1); + + // Ninjutsu {1}{U} ({1}{U}, Return an unblocked attacker you control to hand: Put this card onto the battlefield from your hand tapped and attacking.) + this.addAbility(new NinjutsuAbility(new ManaCostsImpl("{U}"))); + + // Whenever Mistblade Shinobi deals combat damage to a player, you may return target creature that player controls to its owner's hand. + this.addAbility(new MistbladeShinobiTriggeredAbility()); + } + + public MistbladeShinobi(final MistbladeShinobi card) { + super(card); + } + + @Override + public MistbladeShinobi copy() { + return new MistbladeShinobi(this); + } +} + +class MistbladeShinobiTriggeredAbility extends TriggeredAbilityImpl { + + MistbladeShinobiTriggeredAbility() { + super(Zone.BATTLEFIELD, new ReturnToHandTargetEffect(), true); + } + + MistbladeShinobiTriggeredAbility(final MistbladeShinobiTriggeredAbility ability) { + super(ability); + } + + @Override + public MistbladeShinobiTriggeredAbility copy() { + return new MistbladeShinobiTriggeredAbility(this); + } + + @Override + public boolean checkTrigger(GameEvent event, Game game) { + if (event instanceof DamagedPlayerEvent + && ((DamagedPlayerEvent) event).isCombatDamage() + && event.getSourceId().equals(sourceId)) { + Player opponent = game.getPlayer(event.getPlayerId()); + if (opponent != null) { + FilterCreaturePermanent filter = new FilterCreaturePermanent("creature " + opponent.getName() + " controls"); + filter.add(new ControllerIdPredicate(opponent.getId())); + this.getTargets().clear(); + this.addTarget(new TargetCreaturePermanent(filter)); + return true; + } + } + return false; + } + + @Override + public String getRule() { + return "Whenever {this} deals combat damage to a player, you may return target creature that player controls to its owner's hand."; + } +} \ No newline at end of file diff --git a/Mage.Sets/src/mage/sets/betrayersofkamigawa/NinjaOfTheDeepHours.java b/Mage.Sets/src/mage/sets/betrayersofkamigawa/NinjaOfTheDeepHours.java new file mode 100644 index 0000000000..f961f24e3a --- /dev/null +++ b/Mage.Sets/src/mage/sets/betrayersofkamigawa/NinjaOfTheDeepHours.java @@ -0,0 +1,70 @@ +/* + * 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.betrayersofkamigawa; + +import java.util.UUID; +import mage.Constants.CardType; +import mage.Constants.Rarity; +import mage.MageInt; +import mage.abilities.common.DealsCombatDamageToAPlayerTriggeredAbility; +import mage.abilities.costs.mana.ManaCostsImpl; +import mage.abilities.effects.common.DrawCardControllerEffect; +import mage.abilities.keyword.NinjutsuAbility; +import mage.cards.CardImpl; + +/** + * + * @author LevelX2 + */ +public class NinjaOfTheDeepHours extends CardImpl { + + public NinjaOfTheDeepHours(UUID ownerId) { + super(ownerId, 44, "Ninja of the Deep Hours", Rarity.COMMON, new CardType[]{CardType.CREATURE}, "{3}{U}"); + this.expansionSetCode = "BOK"; + this.subtype.add("Human"); + this.subtype.add("Ninja"); + this.color.setBlue(true); + this.power = new MageInt(2); + this.toughness = new MageInt(2); + + // Ninjutsu {1}{U} ({1}{U}, Return an unblocked attacker you control to hand: Put this card onto the battlefield from your hand tapped and attacking.) + this.addAbility(new NinjutsuAbility(new ManaCostsImpl("{1}{U}"))); + + // Whenever Ninja of the Deep Hours deals combat damage to a player, you may draw a card. + this.addAbility(new DealsCombatDamageToAPlayerTriggeredAbility(new DrawCardControllerEffect(1), true, false)); + } + + public NinjaOfTheDeepHours(final NinjaOfTheDeepHours card) { + super(card); + } + + @Override + public NinjaOfTheDeepHours copy() { + return new NinjaOfTheDeepHours(this); + } +} \ No newline at end of file diff --git a/Mage.Sets/src/mage/sets/betrayersofkamigawa/OkibaGangShinobi.java b/Mage.Sets/src/mage/sets/betrayersofkamigawa/OkibaGangShinobi.java new file mode 100644 index 0000000000..9d412bb688 --- /dev/null +++ b/Mage.Sets/src/mage/sets/betrayersofkamigawa/OkibaGangShinobi.java @@ -0,0 +1,70 @@ +/* + * 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.betrayersofkamigawa; + +import java.util.UUID; +import mage.Constants.CardType; +import mage.Constants.Rarity; +import mage.MageInt; +import mage.abilities.common.DealsCombatDamageToAPlayerTriggeredAbility; +import mage.abilities.costs.mana.ManaCostsImpl; +import mage.abilities.effects.common.DiscardTargetEffect; +import mage.abilities.keyword.NinjutsuAbility; +import mage.cards.CardImpl; + +/** + * + * @author LevelX2 + */ +public class OkibaGangShinobi extends CardImpl { + + public OkibaGangShinobi(UUID ownerId) { + super(ownerId, 76, "Okiba-Gang Shinobi", Rarity.COMMON, new CardType[]{CardType.CREATURE}, "{3}{B}{B}"); + this.expansionSetCode = "BOK"; + this.subtype.add("Rat"); + this.subtype.add("Ninja"); + this.color.setBlack(true); + this.power = new MageInt(3); + this.toughness = new MageInt(2); + + // Ninjutsu {3}{B} ({3}{B}, Return an unblocked attacker you control to hand: Put this card onto the battlefield from your hand tapped and attacking.) + this.addAbility(new NinjutsuAbility(new ManaCostsImpl("{3}{B}"))); + + // Whenever Okiba-Gang Shinobi deals combat damage to a player, that player discards two cards. + this.addAbility(new DealsCombatDamageToAPlayerTriggeredAbility(new DiscardTargetEffect(2), false, true)); + } + + public OkibaGangShinobi(final OkibaGangShinobi card) { + super(card); + } + + @Override + public OkibaGangShinobi copy() { + return new OkibaGangShinobi(this); + } +} \ No newline at end of file diff --git a/Mage.Sets/src/mage/sets/betrayersofkamigawa/Skullsnatcher.java b/Mage.Sets/src/mage/sets/betrayersofkamigawa/Skullsnatcher.java new file mode 100644 index 0000000000..f3f869a06c --- /dev/null +++ b/Mage.Sets/src/mage/sets/betrayersofkamigawa/Skullsnatcher.java @@ -0,0 +1,122 @@ +/* + * 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.betrayersofkamigawa; + +import java.util.UUID; +import mage.Constants; +import mage.Constants.CardType; +import mage.Constants.Rarity; +import mage.MageInt; +import mage.abilities.TriggeredAbilityImpl; +import mage.abilities.costs.mana.ManaCostsImpl; +import mage.abilities.effects.common.ExileTargetEffect; +import mage.abilities.keyword.NinjutsuAbility; +import mage.cards.CardImpl; +import mage.filter.FilterCard; +import mage.filter.common.FilterControlledCreaturePermanent; +import mage.filter.predicate.other.OwnerIdPredicate; +import mage.filter.predicate.permanent.UnblockedPredicate; +import mage.game.Game; +import mage.game.events.DamagedPlayerEvent; +import mage.game.events.GameEvent; +import mage.target.common.TargetCardInOpponentsGraveyard; + +/** + * + * @author LevelX2 + */ +public class Skullsnatcher extends CardImpl { + + private static final FilterControlledCreaturePermanent filter = new FilterControlledCreaturePermanent("unblocked attacker you control"); + + static { + filter.add(new UnblockedPredicate()); + } + + public Skullsnatcher(UUID ownerId) { + super(ownerId, 84, "Skullsnatcher", Rarity.COMMON, new CardType[]{CardType.CREATURE}, "{1}{B}"); + this.expansionSetCode = "BOK"; + this.subtype.add("Rat"); + this.subtype.add("Ninja"); + this.color.setBlack(true); + this.power = new MageInt(2); + this.toughness = new MageInt(1); + + // Ninjutsu {B} ({B}, Return an unblocked attacker you control to hand: Put this card onto the battlefield from your hand tapped and attacking.) + this.addAbility(new NinjutsuAbility(new ManaCostsImpl("{B"))); + + // Whenever Skullsnatcher deals combat damage to a player, exile up to two target cards from that player's graveyard. + this.addAbility(new SkullsnatcherTriggeredAbility()); + } + + public Skullsnatcher(final Skullsnatcher card) { + super(card); + } + + @Override + public Skullsnatcher copy() { + return new Skullsnatcher(this); + } +} + +class SkullsnatcherTriggeredAbility extends TriggeredAbilityImpl { + + SkullsnatcherTriggeredAbility() { + super(Constants.Zone.BATTLEFIELD, new ExileTargetEffect(), false); + } + + SkullsnatcherTriggeredAbility(final SkullsnatcherTriggeredAbility ability) { + super(ability); + } + + @Override + public SkullsnatcherTriggeredAbility copy() { + return new SkullsnatcherTriggeredAbility(this); + } + + @Override + public boolean checkTrigger(GameEvent event, Game game) { + if (event instanceof DamagedPlayerEvent + && ((DamagedPlayerEvent) event).isCombatDamage() + && event.getSourceId().equals(sourceId)) { + + FilterCard filter = new FilterCard("up to two target cards from that player's graveyard"); + filter.add(new OwnerIdPredicate(event.getPlayerId())); + filter.setMessage("up to two cards in " + game.getPlayer(event.getTargetId()).getName() + "'s graveyard"); + this.getTargets().clear(); + this.addTarget(new TargetCardInOpponentsGraveyard(0,2,filter)); + return true; + } + return false; + } + + @Override + public String getRule() { + return "Whenever {this} deals combat damage to a player, exile up to two target cards from that player's graveyard."; + } +} \ No newline at end of file diff --git a/Mage.Sets/src/mage/sets/betrayersofkamigawa/ThroatSlitter.java b/Mage.Sets/src/mage/sets/betrayersofkamigawa/ThroatSlitter.java new file mode 100644 index 0000000000..78dbb8f5f9 --- /dev/null +++ b/Mage.Sets/src/mage/sets/betrayersofkamigawa/ThroatSlitter.java @@ -0,0 +1,118 @@ +/* + * 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.betrayersofkamigawa; + +import java.util.UUID; +import mage.Constants.CardType; +import mage.Constants.Rarity; +import mage.Constants.Zone; +import mage.MageInt; +import mage.ObjectColor; +import mage.abilities.TriggeredAbilityImpl; +import mage.abilities.costs.mana.ManaCostsImpl; +import mage.abilities.effects.common.DestroyTargetEffect; +import mage.abilities.keyword.NinjutsuAbility; +import mage.cards.CardImpl; +import mage.filter.common.FilterCreaturePermanent; +import mage.filter.predicate.Predicates; +import mage.filter.predicate.mageobject.ColorPredicate; +import mage.filter.predicate.permanent.ControllerIdPredicate; +import mage.game.Game; +import mage.game.events.DamagedPlayerEvent; +import mage.game.events.GameEvent; +import mage.target.TargetPermanent; + +/** + * + * @author LevelX2 + */ +public class ThroatSlitter extends CardImpl { + + public ThroatSlitter(UUID ownerId) { + super(ownerId, 88, "Throat Slitter", Rarity.UNCOMMON, new CardType[]{CardType.CREATURE}, "{4}{B}"); + this.expansionSetCode = "BOK"; + this.subtype.add("Rat"); + this.subtype.add("Ninja"); + this.color.setBlack(true); + this.power = new MageInt(2); + this.toughness = new MageInt(2); + + // Ninjutsu {2}{B} ({2}{B}, Return an unblocked attacker you control to hand: Put this card onto the battlefield from your hand tapped and attacking.) + this.addAbility(new NinjutsuAbility(new ManaCostsImpl("{2}{B}"))); + + // Whenever Throat Slitter deals combat damage to a player, destroy target nonblack creature that player controls. + this.addAbility(new ThroatSlitterTriggeredAbility()); + } + + public ThroatSlitter(final ThroatSlitter card) { + super(card); + } + + @Override + public ThroatSlitter copy() { + return new ThroatSlitter(this); + } +} + +class ThroatSlitterTriggeredAbility extends TriggeredAbilityImpl { + + ThroatSlitterTriggeredAbility() { + super(Zone.BATTLEFIELD, new DestroyTargetEffect(), false); + } + + ThroatSlitterTriggeredAbility(final ThroatSlitterTriggeredAbility ability) { + super(ability); + } + + @Override + public ThroatSlitterTriggeredAbility copy() { + return new ThroatSlitterTriggeredAbility(this); + } + + @Override + public boolean checkTrigger(GameEvent event, Game game) { + if (event instanceof DamagedPlayerEvent + && ((DamagedPlayerEvent) event).isCombatDamage() + && event.getSourceId().equals(sourceId)) { + + FilterCreaturePermanent filter = new FilterCreaturePermanent("nonblack creature that player controls"); + filter.add(new ControllerIdPredicate(event.getPlayerId())); + filter.add(Predicates.not(new ColorPredicate(ObjectColor.BLACK))); + filter.setMessage("nonblack creature controlled by " + game.getPlayer(event.getTargetId()).getName()); + this.getTargets().clear(); + this.addTarget(new TargetPermanent(filter)); + return true; + } + return false; + } + + @Override + public String getRule() { + return "Whenever {this} deals combat damage to a player, destroy target nonblack creature that player controls."; + } +} diff --git a/Mage.Sets/src/mage/sets/betrayersofkamigawa/WalkerOfSecretWays.java b/Mage.Sets/src/mage/sets/betrayersofkamigawa/WalkerOfSecretWays.java new file mode 100644 index 0000000000..200f558d00 --- /dev/null +++ b/Mage.Sets/src/mage/sets/betrayersofkamigawa/WalkerOfSecretWays.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.sets.betrayersofkamigawa; + +import java.util.UUID; +import mage.Constants; +import mage.Constants.CardType; +import mage.Constants.Rarity; +import mage.MageInt; +import mage.abilities.Ability; +import mage.abilities.common.DealsCombatDamageToAPlayerTriggeredAbility; +import mage.abilities.common.SimpleActivatedAbility; +import mage.abilities.costs.common.OnlyDuringYourTurnCost; +import mage.abilities.costs.mana.ManaCostsImpl; +import mage.abilities.effects.OneShotEffect; +import mage.abilities.effects.common.ReturnToHandTargetEffect; +import mage.abilities.keyword.NinjutsuAbility; +import mage.cards.CardImpl; +import mage.filter.common.FilterControlledCreaturePermanent; +import mage.filter.predicate.mageobject.SubtypePredicate; +import mage.game.Game; +import mage.players.Player; +import mage.target.common.TargetControlledCreaturePermanent; + +/** + * + * @author LevelX2 + */ +public class WalkerOfSecretWays extends CardImpl { + + private static final FilterControlledCreaturePermanent filterCreature = new FilterControlledCreaturePermanent("Ninja you control"); + static { + filterCreature.add((new SubtypePredicate("Ninja"))); + } + + public WalkerOfSecretWays(UUID ownerId) { + super(ownerId, 60, "Walker of Secret Ways", Rarity.UNCOMMON, new CardType[]{CardType.CREATURE}, "{2}{U}"); + this.expansionSetCode = "BOK"; + this.subtype.add("Human"); + this.subtype.add("Ninja"); + this.color.setBlue(true); + this.power = new MageInt(1); + this.toughness = new MageInt(2); + + // Ninjutsu {1}{U} ({1}{U}, Return an unblocked attacker you control to hand: Put this card onto the battlefield from your hand tapped and attacking.) + this.addAbility(new NinjutsuAbility(new ManaCostsImpl("{1}{U}"))); + + // Whenever Walker of Secret Ways deals combat damage to a player, look at that player's hand. + this.addAbility(new DealsCombatDamageToAPlayerTriggeredAbility(new WalkerOfSecretWaysEffect(), true, true)); + + // {1}{U}: Return target Ninja you control to its owner's hand. Activate this ability only during your turn. + Ability ability = new SimpleActivatedAbility(Constants.Zone.BATTLEFIELD, new ReturnToHandTargetEffect(), new ManaCostsImpl("{1}{U}")); + ability.addTarget(new TargetControlledCreaturePermanent(1,1, filterCreature, false)); + ability.addCost(new OnlyDuringYourTurnCost()); + this.addAbility(ability); + + + } + + public WalkerOfSecretWays(final WalkerOfSecretWays card) { + super(card); + } + + @Override + public WalkerOfSecretWays copy() { + return new WalkerOfSecretWays(this); + } +} + +class WalkerOfSecretWaysEffect extends OneShotEffect { + WalkerOfSecretWaysEffect() { + super(Constants.Outcome.Detriment); + staticText = "look at that player's hand"; + } + + WalkerOfSecretWaysEffect(final WalkerOfSecretWaysEffect effect) { + super(effect); + } + + @Override + public boolean apply(Game game, Ability source) { + Player controller = game.getPlayer(source.getControllerId()); + Player player = game.getPlayer(targetPointer.getFirst(game, source)); + if (player != null && controller != null) { + controller.lookAtCards("Walker of Secret Ways", player.getHand(), game); + } + return true; + } + + @Override + public WalkerOfSecretWaysEffect copy() { + return new WalkerOfSecretWaysEffect(this); + } + +} \ No newline at end of file