- Added the new static ability "CantTarget".

- Added a currently unused function canTarget to the card class.
- Little cleanup for the static ability CantBeActivated.

.gitattributes

@@ -10548,6 +10548,7 @@ src/main/java/forge/card/spellability/TargetSelection.java svneol=native#text/pl
 src/main/java/forge/card/spellability/package-info.java svneol=native#text/plain
 src/main/java/forge/card/staticability/StaticAbility.java svneol=native#text/plain
 src/main/java/forge/card/staticability/StaticAbilityCantBeCast.java svneol=native#text/plain
+src/main/java/forge/card/staticability/StaticAbilityCantTarget.java -text
 src/main/java/forge/card/staticability/StaticAbilityContinuous.java svneol=native#text/plain
 src/main/java/forge/card/staticability/StaticAbilityPreventDamage.java -text svneol=native#text/plain
 src/main/java/forge/card/staticability/package-info.java svneol=native#text/plain

src/main/java/forge/Card.java

@@ -8178,4 +8178,84 @@ public class Card extends GameEntity implements Comparable<Card> {
         return AllZone.isCardInZone(this, zone);
     }
     
+    /**
+     * Can target.
+     * 
+     * @param sa
+     *            the sa
+     * @return a boolean
+     */
+    @Override
+    public final boolean canTarget(final SpellAbility sa) {
+        
+        // CantTarget static abilities
+        final CardList allp = AllZoneUtil.getCardsIn(Zone.Battlefield);
+        for (final Card ca : allp) {
+            final ArrayList<StaticAbility> staticAbilities = ca.getStaticAbilities();
+            for (final StaticAbility stAb : staticAbilities) {
+                if (stAb.applyAbility("CantTarget", this, sa)) {
+                    return false;
+                }
+            }
+        }
+        
+        if(!isInZone(Constant.Zone.Battlefield)) { //keywords don't work outside the battlefield
+            return true;
+        }
+        
+        if (hasProtectionFrom(sa.getSourceCard())) {
+            return false;
+        }
+
+        if (getKeyword() != null) {
+            final ArrayList<String> list = getKeyword();
+            Card source = sa.getSourceCard();
+
+            String kw = "";
+            for (int i = 0; i < list.size(); i++) {
+                kw = list.get(i);
+                if (kw.equals("Shroud")) {
+                    return false;
+                }
+
+                if (kw.equals("Hexproof")) {
+                    if (!sa.getActivatingPlayer().equals(getController())) {
+                        return false;
+                    }
+                }
+
+                if (kw.equals("CARDNAME can't be the target of Aura spells.") || kw.equals("CARDNAME can't be enchanted.")) {
+                    if (source.isAura() && sa.isSpell()) {
+                        return false;
+                    }
+                }
+
+                if (kw.equals("CARDNAME can't be the target of red spells or abilities from red sources.")) {
+                    if (source.isRed()) {
+                        return false;
+                    }
+                }
+
+                if (kw.equals("CARDNAME can't be the target of black spells.")) {
+                    if (source.isBlack() && sa.isSpell()) {
+                        return false;
+                    }
+                }
+
+                if (kw.equals("CARDNAME can't be the target of blue spells.")) {
+                    if (source.isBlue() && sa.isSpell()) {
+                        return false;
+                    }
+                }
+
+                if (kw.equals("CARDNAME can't be the target of spells.")) {
+                    if (sa.isSpell()) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
 } // end Card class

src/main/java/forge/card/spellability/AbilityActivated.java

@@ -80,7 +80,7 @@ public abstract class AbilityActivated extends SpellAbility implements java.io.S
         for (final Card ca : allp) {
             final ArrayList<StaticAbility> staticAbilities = ca.getStaticAbilities();
             for (final StaticAbility stAb : staticAbilities) {
-                if (stAb.applyAbility("CantBeActivated", c, activator, this)) {
+                if (stAb.applyAbility("CantBeActivated", c, this)) {
                     return false;
                 }
             }

src/main/java/forge/card/staticability/StaticAbility.java

@@ -299,7 +299,7 @@ public class StaticAbility {
      *            the ability
      * @return true, if successful
      */
-    public final boolean applyAbility(final String mode, final Card card, final Player activator, SpellAbility sa) {
+    public final boolean applyAbility(final String mode, final Card card, SpellAbility sa) {
 
         // don't apply the ability if it hasn't got the right mode
         if (!this.mapParams.get("Mode").equals(mode)) {
@@ -311,7 +311,11 @@ public class StaticAbility {
         }
 
         if (mode.equals("CantBeActivated")) {
-            return StaticAbilityCantBeCast.applyCantBeActivatedAbility(this, card, activator, sa);
+            return StaticAbilityCantBeCast.applyCantBeActivatedAbility(this, card, sa);
+        }
+        
+        if (mode.equals("CantTarget")) {
+            return StaticAbilityCantTarget.applyCantTargetAbility(this, card, sa);
         }
 
         return false;

src/main/java/forge/card/staticability/StaticAbilityCantBeCast.java

@@ -56,10 +56,10 @@ public class StaticAbilityCantBeCast {
      *            the activator
      * @return true, if successful
      */
-    public static boolean applyCantBeActivatedAbility(final StaticAbility stAb, final Card card, 
-            final Player activator, SpellAbility sa) {
+    public static boolean applyCantBeActivatedAbility(final StaticAbility stAb, final Card card, SpellAbility sa) {
         final HashMap<String, String> params = stAb.getMapParams();
         final Card hostCard = stAb.getHostCard();
+        final Player activator = sa.getActivatingPlayer();
 
         if (params.containsKey("ValidCard")
                 && !card.isValid(params.get("ValidCard").split(","), hostCard.getController(), hostCard)) {

src/main/java/forge/card/staticability/StaticAbilityCantTarget.java

@@ -0,0 +1,53 @@
+package forge.card.staticability;
+
+import java.util.HashMap;
+
+import forge.Card;
+import forge.Player;
+import forge.card.spellability.SpellAbility;
+
+/**
+ * The Class StaticAbility_PreventDamage.
+ */
+public class StaticAbilityCantTarget {
+
+    /**
+     * TODO Write javadoc for this method.
+     * 
+     * @param stAb
+     *            a StaticAbility
+     * @param source
+     *            the source
+     * @param target
+     *            the target
+     * @param damage
+     *            the damage
+     * @param isCombat
+     *            the is combat
+     * @return the int
+     */
+    public static boolean applyCantTargetAbility(final StaticAbility stAb, final Card card, SpellAbility sa) {
+        final HashMap<String, String> params = stAb.getMapParams();
+        final Card hostCard = stAb.getHostCard();
+        final Card source = sa.getSourceCard();
+        final Player activator = sa.getActivatingPlayer();
+
+        if (params.containsKey("ValidCard")
+                && !card.isValid(params.get("ValidCard").split(","), hostCard.getController(), hostCard)) {
+            return false;
+        }
+        
+        if (params.containsKey("ValidSource")
+                && !source.isValid(params.get("ValidSource").split(","), hostCard.getController(), hostCard)) {
+            return false;
+        }
+
+        if (params.containsKey("Activator") && (activator != null)
+                && !activator.isValid(params.get("Activator"), hostCard.getController(), hostCard)) {
+            return false;
+        }
+
+        return true;
+    }
+
+}