diff --git a/Mage.Sets/src/mage/sets/gatecrash/CracklingPerimeter.java b/Mage.Sets/src/mage/sets/gatecrash/CracklingPerimeter.java new file mode 100644 index 00000000000..fd25f05d5fa --- /dev/null +++ b/Mage.Sets/src/mage/sets/gatecrash/CracklingPerimeter.java @@ -0,0 +1,112 @@ +/* + * 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.gatecrash; + +import java.util.UUID; +import mage.Constants; +import mage.Constants.CardType; +import mage.Constants.Rarity; +import mage.abilities.Ability; +import mage.abilities.common.SimpleActivatedAbility; +import mage.abilities.costs.common.TapTargetCost; +import mage.abilities.effects.OneShotEffect; +import mage.cards.CardImpl; +import mage.filter.common.FilterControlledPermanent; +import mage.filter.predicate.Predicates; +import mage.filter.predicate.mageobject.SubtypePredicate; +import mage.filter.predicate.permanent.TappedPredicate; +import mage.game.Game; +import mage.players.Player; +import mage.target.common.TargetControlledPermanent; + +/** + * + * @author jeffwadsworth + */ +public class CracklingPerimeter extends CardImpl { + + private static final FilterControlledPermanent filter = new FilterControlledPermanent("untapped Gate you control"); + + static { + filter.add(new SubtypePredicate("Gate")); + filter.add(Predicates.not(new TappedPredicate())); + } + + public CracklingPerimeter(UUID ownerId) { + super(ownerId, 88, "Crackling Perimeter", Rarity.UNCOMMON, new CardType[]{CardType.ENCHANTMENT}, "{1}{R}"); + this.expansionSetCode = "GTC"; + + this.color.setRed(true); + + // Tap an untapped Gate you control: Crackling Perimeter deals 1 damage to each opponent. + this.addAbility(new SimpleActivatedAbility(Constants.Zone.BATTLEFIELD, new CracklingPerimeterEffect(), new TapTargetCost(new TargetControlledPermanent(filter)))); + } + + public CracklingPerimeter(final CracklingPerimeter card) { + super(card); + } + + @Override + public CracklingPerimeter copy() { + return new CracklingPerimeter(this); + } +} + +class CracklingPerimeterEffect extends OneShotEffect { + + public CracklingPerimeterEffect() { + super(Constants.Outcome.Damage); + staticText = "{this} deals 1 damage to each opponent"; + } + + public CracklingPerimeterEffect(final CracklingPerimeterEffect effect) { + super(effect); + } + + @Override + public boolean apply(Game game, Ability source) { + Player you = game.getPlayer(source.getControllerId()); + if (you != null) { + for (UUID playerId : you.getInRange()) { + if (playerId != source.getControllerId()) { + Player opponent = game.getPlayer(playerId); + if (opponent != null) { + opponent.damage(1, source.getId(), game, false, true); + } + } + } + return true; + } + return false; + } + + @Override + public CracklingPerimeterEffect copy() { + return new CracklingPerimeterEffect(this); + } +} \ No newline at end of file diff --git a/Mage.Sets/src/mage/sets/gatecrash/FuriousResistance.java b/Mage.Sets/src/mage/sets/gatecrash/FuriousResistance.java new file mode 100644 index 00000000000..77de198ec6a --- /dev/null +++ b/Mage.Sets/src/mage/sets/gatecrash/FuriousResistance.java @@ -0,0 +1,108 @@ +/* + * 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.gatecrash; + +import java.util.UUID; +import mage.Constants; +import mage.Constants.CardType; +import mage.Constants.Rarity; +import mage.abilities.Ability; +import mage.abilities.effects.ContinuousEffect; +import mage.abilities.effects.OneShotEffect; +import mage.abilities.effects.common.continious.BoostTargetEffect; +import mage.abilities.effects.common.continious.GainAbilityTargetEffect; +import mage.abilities.keyword.FirstStrikeAbility; +import mage.cards.CardImpl; +import mage.filter.common.FilterBlockingCreature; +import mage.filter.common.FilterCreaturePermanent; +import mage.game.Game; +import mage.game.permanent.Permanent; +import mage.target.common.TargetCreaturePermanent; +import mage.target.targetpointer.FixedTarget; + +/** + * + * @author jeffwadsworth + */ +public class FuriousResistance extends CardImpl { + + private final static FilterCreaturePermanent filter = new FilterBlockingCreature("blocking creature"); + + public FuriousResistance(UUID ownerId) { + super(ownerId, 93, "Furious Resistance", Rarity.COMMON, new CardType[]{CardType.INSTANT}, "{R}"); + this.expansionSetCode = "GTC"; + + this.color.setRed(true); + + // Target blocking creature gets +3/+0 and gains first strike until end of turn. + this.getSpellAbility().addEffect(new FuriousResistanceEffect()); + this.getSpellAbility().addTarget(new TargetCreaturePermanent(filter)); + } + + public FuriousResistance(final FuriousResistance card) { + super(card); + } + + @Override + public FuriousResistance copy() { + return new FuriousResistance(this); + } +} + +class FuriousResistanceEffect extends OneShotEffect { + + public FuriousResistanceEffect() { + super(Constants.Outcome.BoostCreature); + staticText = "Target blocking creature gets +3/+0 and gains first strike until end of turn"; + } + + public FuriousResistanceEffect(final FuriousResistanceEffect effect) { + super(effect); + } + + @Override + public boolean apply(Game game, Ability source) { + Permanent target = game.getPermanent(source.getFirstTarget()); + if (target == null) { + return false; + } + + ContinuousEffect effect = new BoostTargetEffect(3, 0, Constants.Duration.EndOfTurn); + ContinuousEffect effect2 = new GainAbilityTargetEffect(FirstStrikeAbility.getInstance(), Constants.Duration.EndOfTurn); + effect.setTargetPointer(new FixedTarget(target.getId())); + effect2.setTargetPointer(new FixedTarget(target.getId())); + game.addEffect(effect, source); + game.addEffect(effect2, source); + return true; + } + + @Override + public FuriousResistanceEffect copy() { + return new FuriousResistanceEffect(this); + } +} diff --git a/Mage.Sets/src/mage/sets/gatecrash/GruulRagebeast.java b/Mage.Sets/src/mage/sets/gatecrash/GruulRagebeast.java new file mode 100644 index 00000000000..39670d20855 --- /dev/null +++ b/Mage.Sets/src/mage/sets/gatecrash/GruulRagebeast.java @@ -0,0 +1,162 @@ +/* + * 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.gatecrash; + +import java.util.UUID; +import mage.Constants; +import mage.Constants.CardType; +import mage.Constants.Rarity; +import mage.Constants.TargetController; +import mage.MageInt; +import mage.abilities.Ability; +import mage.abilities.TriggeredAbilityImpl; +import mage.abilities.effects.Effect; +import mage.abilities.effects.OneShotEffect; +import mage.cards.CardImpl; +import mage.filter.common.FilterCreaturePermanent; +import mage.filter.predicate.mageobject.CardIdPredicate; +import mage.filter.predicate.permanent.ControllerPredicate; +import mage.game.Game; +import mage.game.events.GameEvent; +import mage.game.events.ZoneChangeEvent; +import mage.game.permanent.Permanent; +import mage.target.common.TargetCreaturePermanent; +import mage.target.targetpointer.FixedTarget; + +/** + * + * @author jeffwadsworth + */ +public class GruulRagebeast extends CardImpl { + + final private static FilterCreaturePermanent filter2 = new FilterCreaturePermanent("creature an opponent controls"); + + static { + filter2.add(new ControllerPredicate(TargetController.OPPONENT)); + } + + public GruulRagebeast(UUID ownerId) { + super(ownerId, 170, "Gruul Ragebeast", Rarity.RARE, new CardType[]{CardType.CREATURE}, "{5}{R}{G}"); + this.expansionSetCode = "GTC"; + this.subtype.add("Beast"); + + this.color.setRed(true); + this.color.setGreen(true); + this.power = new MageInt(6); + this.toughness = new MageInt(6); + + FilterCreaturePermanent filter = new FilterCreaturePermanent(); + filter.add(new CardIdPredicate(this.getId())); + + // Whenever Gruul Ragebeast or another creature enters the battlefield under your control, that creature fights target creature an opponent controls. + Ability ability = new GruulRagebeastTriggeredAbility(); + ability.addTarget(new TargetCreaturePermanent(filter2)); + this.addAbility(ability); + } + + public GruulRagebeast(final GruulRagebeast card) { + super(card); + } + + @Override + public GruulRagebeast copy() { + return new GruulRagebeast(this); + } +} + +class GruulRagebeastTriggeredAbility extends TriggeredAbilityImpl { + + GruulRagebeastTriggeredAbility() { + super(Constants.Zone.BATTLEFIELD, new GruulRagebeastEffect(), false); + } + + GruulRagebeastTriggeredAbility(final GruulRagebeastTriggeredAbility ability) { + super(ability); + } + + @Override + public GruulRagebeastTriggeredAbility copy() { + return new GruulRagebeastTriggeredAbility(this); + } + + @Override + public boolean checkTrigger(GameEvent event, Game game) { + if (event.getType() == GameEvent.EventType.ZONE_CHANGE) { + UUID targetId = event.getTargetId(); + Permanent permanent = game.getPermanent(targetId); + ZoneChangeEvent zEvent = (ZoneChangeEvent) event; + if (zEvent.getToZone() == Constants.Zone.BATTLEFIELD + && permanent.getControllerId().equals(this.controllerId) + && permanent.getCardType().contains(CardType.CREATURE) + && (targetId.equals(this.getSourceId()) + || !targetId.equals(this.getSourceId()))) { + for (Effect effect : this.getEffects()) { + effect.setTargetPointer(new FixedTarget(event.getTargetId())); + } + return true; + } + } + return false; + } + + @Override + public String getRule() { + return "Whenever {this} or another creature enters the battlefield under your control, that creature fights target creature an opponent controls."; + } +} + +class GruulRagebeastEffect extends OneShotEffect { + + GruulRagebeastEffect() { + super(Constants.Outcome.Damage); + } + + GruulRagebeastEffect(final GruulRagebeastEffect effect) { + super(effect); + } + + @Override + public boolean apply(Game game, Ability source) { + Permanent triggeredCreature = game.getPermanent(targetPointer.getFirst(game, source)); + Permanent target = game.getPermanent(source.getFirstTarget()); + if (triggeredCreature != null + && target != null + && triggeredCreature.getCardType().contains(CardType.CREATURE) + && target.getCardType().contains(CardType.CREATURE)) { + triggeredCreature.damage(target.getPower().getValue(), target.getId(), game, true, false); + target.damage(triggeredCreature.getPower().getValue(), triggeredCreature.getId(), game, true, false); + return true; + } + return false; + } + + @Override + public GruulRagebeastEffect copy() { + return new GruulRagebeastEffect(this); + } +} diff --git a/Mage.Sets/src/mage/sets/gatecrash/HomingLightning.java b/Mage.Sets/src/mage/sets/gatecrash/HomingLightning.java new file mode 100644 index 00000000000..1e83b69d020 --- /dev/null +++ b/Mage.Sets/src/mage/sets/gatecrash/HomingLightning.java @@ -0,0 +1,106 @@ +/* + * 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.gatecrash; + +import java.util.List; +import java.util.UUID; +import mage.Constants; +import mage.Constants.CardType; +import mage.Constants.Rarity; +import mage.abilities.Ability; +import mage.abilities.effects.OneShotEffect; +import mage.cards.CardImpl; +import mage.filter.common.FilterCreaturePermanent; +import mage.filter.predicate.mageobject.NamePredicate; +import mage.game.Game; +import mage.game.permanent.Permanent; +import mage.target.common.TargetCreaturePermanent; + +/** + * + * @author jeffwadsworth + */ +public class HomingLightning extends CardImpl { + + public HomingLightning(UUID ownerId) { + super(ownerId, 96, "Homing Lightning", Rarity.UNCOMMON, new CardType[]{CardType.INSTANT}, "{2}{R}{R}"); + this.expansionSetCode = "GTC"; + + this.color.setRed(true); + + // Homing Lightning deals 4 damage to target creature and each other creature with the same name as that creature. + this.getSpellAbility().addEffect(new HomingLightningEffect()); + this.getSpellAbility().addTarget(new TargetCreaturePermanent()); + } + + public HomingLightning(final HomingLightning card) { + super(card); + } + + @Override + public HomingLightning copy() { + return new HomingLightning(this); + } +} + +class HomingLightningEffect extends OneShotEffect { + + public HomingLightningEffect() { + super(Constants.Outcome.Damage); + staticText = "{this} deals 4 damage to target creature and each other creature with the same name as that creature"; + } + + public HomingLightningEffect(final HomingLightningEffect effect) { + super(effect); + } + + @Override + public boolean apply(Game game, Ability source) { + Permanent target = game.getPermanent(source.getFirstTarget()); + if (target == null) { + return false; + } + FilterCreaturePermanent filter = new FilterCreaturePermanent(); + filter.add(new NamePredicate(target.getName())); + List creatures = game.getBattlefield().getActivePermanents(filter, source.getControllerId(), game); + if (target != null) { + for (Permanent creature : creatures) { + if (creature != null) { + creature.damage(4, id, game, true, false); + } + } + return true; + } + return false; + } + + @Override + public HomingLightningEffect copy() { + return new HomingLightningEffect(this); + } +} \ No newline at end of file diff --git a/Mage.Sets/src/mage/sets/gatecrash/MarkForDeath.java b/Mage.Sets/src/mage/sets/gatecrash/MarkForDeath.java new file mode 100644 index 00000000000..6167c099ad3 --- /dev/null +++ b/Mage.Sets/src/mage/sets/gatecrash/MarkForDeath.java @@ -0,0 +1,119 @@ +/* + * 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.gatecrash; + +import java.util.UUID; +import mage.Constants; +import mage.Constants.CardType; +import mage.Constants.Rarity; +import mage.abilities.Ability; +import mage.abilities.effects.ContinuousEffect; +import mage.abilities.effects.OneShotEffect; +import mage.abilities.effects.common.BlocksIfAbleTargetEffect; +import mage.abilities.effects.common.CantBlockAllEffect; +import mage.cards.CardImpl; +import mage.filter.common.FilterCreaturePermanent; +import mage.filter.predicate.Predicates; +import mage.filter.predicate.mageobject.CardIdPredicate; +import mage.filter.predicate.permanent.ControllerIdPredicate; +import mage.filter.predicate.permanent.ControllerPredicate; +import mage.game.Game; +import mage.game.permanent.Permanent; +import mage.target.common.TargetCreaturePermanent; +import mage.target.targetpointer.FixedTarget; + +/** + * + * @author jeffwadsworth + */ +public class MarkForDeath extends CardImpl { + + final private static FilterCreaturePermanent filter = new FilterCreaturePermanent("creature an opponent controls"); + + static { + filter.add(new ControllerPredicate(Constants.TargetController.OPPONENT)); + } + + public MarkForDeath(UUID ownerId) { + super(ownerId, 99, "Mark for Death", Rarity.UNCOMMON, new CardType[]{CardType.SORCERY}, "{3}{R}"); + this.expansionSetCode = "GTC"; + + this.color.setRed(true); + + // Target creature an opponent controls blocks this turn if able. Untap that creature. Other creatures that player controls can't block this turn. + this.getSpellAbility().addEffect(new MarkForDeathEffect()); + this.getSpellAbility().addTarget(new TargetCreaturePermanent(filter)); + } + + public MarkForDeath(final MarkForDeath card) { + super(card); + } + + @Override + public MarkForDeath copy() { + return new MarkForDeath(this); + } +} + +class MarkForDeathEffect extends OneShotEffect { + + public MarkForDeathEffect() { + super(Constants.Outcome.Damage); + staticText = "Target creature an opponent controls blocks this turn if able. Untap that creature. Other creatures that player controls can't block this turn"; + } + + public MarkForDeathEffect(final MarkForDeathEffect effect) { + super(effect); + } + + @Override + public boolean apply(Game game, Ability source) { + Permanent target = game.getPermanent(source.getFirstTarget()); + if (target == null) { + return false; + } + FilterCreaturePermanent filter = new FilterCreaturePermanent(); + filter.add(new ControllerIdPredicate(target.getControllerId())); + filter.add(Predicates.not(new CardIdPredicate(target.getId()))); + + ContinuousEffect effect = new BlocksIfAbleTargetEffect(Constants.Duration.EndOfTurn); + effect.setTargetPointer(new FixedTarget(target.getId())); + game.addEffect(effect, source); + + target.untap(game); + + ContinuousEffect effect2 = new CantBlockAllEffect(filter, Constants.Duration.EndOfTurn); + game.addEffect(effect2, source); + return true; + } + + @Override + public MarkForDeathEffect copy() { + return new MarkForDeathEffect(this); + } +} \ No newline at end of file diff --git a/Mage.Sets/src/mage/sets/gatecrash/MassiveRaid.java b/Mage.Sets/src/mage/sets/gatecrash/MassiveRaid.java new file mode 100644 index 00000000000..6e3b980bf7b --- /dev/null +++ b/Mage.Sets/src/mage/sets/gatecrash/MassiveRaid.java @@ -0,0 +1,64 @@ +/* + * 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.gatecrash; + +import java.util.UUID; +import mage.Constants.CardType; +import mage.Constants.Rarity; +import mage.abilities.dynamicvalue.common.PermanentsOnBattlefieldCount; +import mage.abilities.effects.common.DamageTargetEffect; +import mage.cards.CardImpl; +import mage.filter.common.FilterControlledCreaturePermanent; +import mage.target.common.TargetCreatureOrPlayer; + +/** + * + * @author jeffwadsworth + */ +public class MassiveRaid extends CardImpl { + + public MassiveRaid(UUID ownerId) { + super(ownerId, 100, "Massive Raid", Rarity.COMMON, new CardType[]{CardType.INSTANT}, "{1}{R}{R}"); + this.expansionSetCode = "GTC"; + + this.color.setRed(true); + + // Massive Raid deals damage to target creature or player equal to the number of creatures you control. + this.getSpellAbility().addEffect(new DamageTargetEffect(new PermanentsOnBattlefieldCount(new FilterControlledCreaturePermanent()))); + this.getSpellAbility().addTarget(new TargetCreatureOrPlayer()); + } + + public MassiveRaid(final MassiveRaid card) { + super(card); + } + + @Override + public MassiveRaid copy() { + return new MassiveRaid(this); + } +}