From 429e114f69b69a9812e6be5c613eea39bfd23011 Mon Sep 17 00:00:00 2001 From: LevelX2 Date: Fri, 15 Aug 2014 12:42:56 +0200 Subject: [PATCH] * Convoke - Fixed that creatures with protection from color of convoke spell could not be tapped. Fixes #513- --- .../cards/abilities/keywords/ConvokeTest.java | 133 ++++++++++++++++++ .../java/org/mage/test/player/TestPlayer.java | 28 ++-- .../base/impl/CardTestPlayerAPIImpl.java | 9 ++ Mage/src/mage/target/TargetPermanent.java | 10 +- 4 files changed, 164 insertions(+), 16 deletions(-) create mode 100644 Mage.Tests/src/test/java/org/mage/test/cards/abilities/keywords/ConvokeTest.java diff --git a/Mage.Tests/src/test/java/org/mage/test/cards/abilities/keywords/ConvokeTest.java b/Mage.Tests/src/test/java/org/mage/test/cards/abilities/keywords/ConvokeTest.java new file mode 100644 index 0000000000..5211e586cc --- /dev/null +++ b/Mage.Tests/src/test/java/org/mage/test/cards/abilities/keywords/ConvokeTest.java @@ -0,0 +1,133 @@ +/* + * 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 org.mage.test.cards.abilities.keywords; + +import mage.constants.PhaseStep; +import mage.constants.Zone; +import mage.filter.common.FilterLandPermanent; +import mage.game.permanent.Permanent; +import org.junit.Assert; +import org.junit.Test; +import org.mage.test.serverside.base.CardTestPlayerBase; + +/** + * + * @author LevelX2 + */ + +public class ConvokeTest extends CardTestPlayerBase { + + @Test + public void testConvokeTwoCreatures() { + /** + * Ephemeral Shields {1}{W} + * Instant + * Convoke (Your creatures can help cast this spell. Each creature you tap while casting this spell pays for or one mana of that creature's color.) + * Target creature gains indestructible until end of turn. (Damage and effects that say "destroy" don't destroy it.) + */ + + addCard(Zone.BATTLEFIELD, playerA, "Plains", 2); // must be added because getPlayable does not take Convoke into account + + addCard(Zone.BATTLEFIELD, playerA, "Silvercoat Lion", 1); + addCard(Zone.BATTLEFIELD, playerA, "Oreskos Swiftclaw", 1); + + addCard(Zone.HAND, playerA, "Ephemeral Shields"); + + addCard(Zone.BATTLEFIELD, playerB, "Mountain", 1); + addCard(Zone.HAND, playerB, "Lightning Bolt"); + + + castSpell(1, PhaseStep.PRECOMBAT_MAIN, playerA, "Ephemeral Shields", "Silvercoat Lion"); + setChoice(playerA, "Yes"); + addTarget(playerA, "Silvercoat Lion^Oreskos Swiftclaw"); + + castSpell(1, PhaseStep.POSTCOMBAT_MAIN, playerB, "Lightning Bolt", "Silvercoat Lion"); + setStopAt(1, PhaseStep.END_TURN); + execute(); + + assertLife(playerA, 20); + assertLife(playerB, 20); + + assertGraveyardCount(playerB, "Lightning Bolt", 1); + + assertGraveyardCount(playerA, "Ephemeral Shields", 1); + assertPermanentCount(playerA, "Silvercoat Lion", 1); // was indestructible + assertPermanentCount(playerA, "Oreskos Swiftclaw", 1); + + for (Permanent permanent: currentGame.getBattlefield().getAllActivePermanents(new FilterLandPermanent(), playerA.getId(), currentGame)) { + Assert.assertTrue(permanent.getName() + " may not be tapped", !permanent.isTapped()); + } + } + + + @Test + public void testConvokeTwoCreaturesOneWithProtection() { + /** + * Ephemeral Shields {1}{W} + * Instant + * Convoke (Your creatures can help cast this spell. Each creature you tap while casting this spell pays for or one mana of that creature's color.) + * Target creature gains indestructible until end of turn. (Damage and effects that say "destroy" don't destroy it.) + */ + + addCard(Zone.BATTLEFIELD, playerA, "Plains", 2); // must be added because getPlayable does not take Convoke into account + + addCard(Zone.BATTLEFIELD, playerA, "Silvercoat Lion", 1); + addCard(Zone.BATTLEFIELD, playerA, "Black Knight", 1); + + addCard(Zone.HAND, playerA, "Ephemeral Shields"); + + addCard(Zone.BATTLEFIELD, playerB, "Mountain", 1); + addCard(Zone.HAND, playerB, "Lightning Bolt"); + + + castSpell(1, PhaseStep.PRECOMBAT_MAIN, playerA, "Ephemeral Shields", "Silvercoat Lion"); + setChoice(playerA, "Yes"); + addTarget(playerA, "Silvercoat Lion^Black Knight"); + + castSpell(1, PhaseStep.POSTCOMBAT_MAIN, playerB, "Lightning Bolt", "Silvercoat Lion"); + setStopAt(1, PhaseStep.END_TURN); + execute(); + + assertLife(playerA, 20); + assertLife(playerB, 20); + + assertGraveyardCount(playerB, "Lightning Bolt", 1); + + assertGraveyardCount(playerA, "Ephemeral Shields", 1); + assertPermanentCount(playerA, "Silvercoat Lion", 1); // was indestructible + assertPermanentCount(playerA, "Black Knight", 1); + assertTapped("Silvercoat Lion", true); + assertTapped("Black Knight", true); + + for (Permanent permanent: currentGame.getBattlefield().getAllActivePermanents(new FilterLandPermanent(), playerA.getId(), currentGame)) { + Assert.assertTrue(permanent.getName() + " may not be tapped", !permanent.isTapped()); + } + } + +} \ No newline at end of file diff --git a/Mage.Tests/src/test/java/org/mage/test/player/TestPlayer.java b/Mage.Tests/src/test/java/org/mage/test/player/TestPlayer.java index 18fec992c5..56263a1a57 100644 --- a/Mage.Tests/src/test/java/org/mage/test/player/TestPlayer.java +++ b/Mage.Tests/src/test/java/org/mage/test/player/TestPlayer.java @@ -285,22 +285,24 @@ public class TestPlayer extends ComputerPlayer { public boolean chooseTarget(Outcome outcome, Target target, Ability source, Game game) { if (!targets.isEmpty()) { if (target instanceof TargetPermanent) { - for (Permanent permanent : game.getBattlefield().getAllActivePermanents((FilterPermanent)target.getFilter(), game)) { - for (String _target: targets) { - if (permanent.getName().equals(_target)) { - if (((TargetPermanent)target).canTarget(playerId, permanent.getId(), null, game) && !target.getTargets().contains(permanent.getId())) { - target.add(permanent.getId(), game); - targets.remove(_target); - return true; - } - } else if ((permanent.getName()+"-"+permanent.getExpansionSetCode()).equals(_target)) { - if (((TargetPermanent)target).canTarget(playerId, permanent.getId(), null, game) && !target.getTargets().contains(permanent.getId())) { - target.add(permanent.getId(), game); - targets.remove(_target); - return true; + for (String targetDefinition: targets) { + String[] targetList = targetDefinition.split("\\^"); + boolean targetFound = false; + for (String targetName: targetList) { + for (Permanent permanent : game.getBattlefield().getAllActivePermanents((FilterPermanent)target.getFilter(), game)) { + if (permanent.getName().equals(targetName) || (permanent.getName()+"-"+permanent.getExpansionSetCode()).equals(targetName)) { + if (((TargetPermanent)target).canTarget(source.getControllerId(), permanent.getId(), source, game) && !target.getTargets().contains(permanent.getId())) { + target.add(permanent.getId(), game); + targetFound = true; + break; + } } } } + if (targetFound) { + targets.remove(targetDefinition); + return true; + } } } } diff --git a/Mage.Tests/src/test/java/org/mage/test/serverside/base/impl/CardTestPlayerAPIImpl.java b/Mage.Tests/src/test/java/org/mage/test/serverside/base/impl/CardTestPlayerAPIImpl.java index c539d4e9dd..533b895b03 100644 --- a/Mage.Tests/src/test/java/org/mage/test/serverside/base/impl/CardTestPlayerAPIImpl.java +++ b/Mage.Tests/src/test/java/org/mage/test/serverside/base/impl/CardTestPlayerAPIImpl.java @@ -764,6 +764,15 @@ public abstract class CardTestPlayerAPIImpl extends MageTestPlayerBase implement player.addModeChoice(choice); } + /** + * Set target Permanents + * + * @param player + * @param target you can add multiple targets by seperating them by the "^" character + * e.g. "creatureName1^creatureName2" + * you can qualify the target additional by setcode + * e.g. "creatureName-M15" + */ public void addTarget(TestPlayer player, String target) { player.addTarget(target); } diff --git a/Mage/src/mage/target/TargetPermanent.java b/Mage/src/mage/target/TargetPermanent.java index 4549e9dfa5..cbca0bbf2c 100644 --- a/Mage/src/mage/target/TargetPermanent.java +++ b/Mage/src/mage/target/TargetPermanent.java @@ -87,9 +87,13 @@ public class TargetPermanent extends TargetObject { //2. We need to check both source.getId() and source.getSourceId() // first for protection from spells or abilities (e.g. protection from colored spells, r1753) // second for protection from sources (e.g. protection from artifacts + equip ability) - return permanent.canBeTargetedBy(game.getObject(source.getId()), controllerId, game) - && permanent.canBeTargetedBy(game.getObject(source.getSourceId()), controllerId, game) - && filter.match(permanent, source.getSourceId(), controllerId, game); + if (!isNotTarget()) { + if (!permanent.canBeTargetedBy(game.getObject(source.getId()), controllerId, game) || + !permanent.canBeTargetedBy(game.getObject(source.getSourceId()), controllerId, game)) { + return false; + } + } + return filter.match(permanent, source.getSourceId(), controllerId, game); } else { return filter.match(permanent, null, controllerId, game); }