- Added Dakkon Blackblade Avatar

forge-game/src/main/java/forge/game/ability/ApiType.java

@@ -85,6 +85,7 @@ public enum ApiType {
     Phases (PhasesEffect.class),
     Planeswalk (PlaneswalkEffect.class),
     Play (PlayEffect.class),
+    PlayLandVariant (PlayLandVariantEffect.class),
     Poison (PoisonEffect.class),
     PreventDamage (DamagePreventEffect.class),
     PreventDamageAll (DamagePreventAllEffect.class),

forge-game/src/main/java/forge/game/ability/effects/PlayLandVariantEffect.java

@@ -0,0 +1,101 @@
+package forge.game.ability.effects;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+
+import forge.StaticData;
+import forge.card.CardCharacteristicName;
+import forge.card.CardRulesPredicates;
+import forge.card.ColorSet;
+import forge.card.MagicColor;
+import forge.game.Game;
+import forge.game.ability.SpellAbilityEffect;
+import forge.game.card.Card;
+import forge.game.card.CardFactory;
+import forge.game.card.CardUtil;
+import forge.game.event.GameEventLandPlayed;
+import forge.game.player.Player;
+import forge.game.spellability.SpellAbility;
+import forge.game.trigger.TriggerType;
+import forge.game.zone.ZoneType;
+import forge.item.PaperCard;
+import forge.util.Aggregates;
+
+public class PlayLandVariantEffect extends SpellAbilityEffect {
+
+
+    /* (non-Javadoc)
+     * @see forge.card.abilityfactory.SpellEffect#resolve(java.util.Map, forge.card.spellability.SpellAbility)
+     */
+    @Override
+    public void resolve(SpellAbility sa) {
+        Card source = sa.getHostCard();
+        Player activator = sa.getActivatingPlayer();
+        final Game game = source.getGame();
+        final String landType = sa.getParam("Clone");
+        List<PaperCard> cards = Lists.newArrayList(StaticData.instance().getCommonCards().getUniqueCards());
+        if ("BasicLand".equals(landType)) {
+            Predicate<PaperCard> cpp = Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND, PaperCard.FN_GET_RULES);
+            cards = Lists.newArrayList(Iterables.filter(cards, cpp));
+        }
+        // current color of source card
+        ColorSet color = CardUtil.getColors(source);
+        if (color.isColorless()) {
+            return;
+        }
+        // find basic lands that can produce mana of one of the card's colors
+        final List<String> landnames = new ArrayList<String>();
+        for (byte i = 0; i < MagicColor.WUBRG.length; i++) {
+            if (color.hasAnyColor(MagicColor.WUBRG[i])) {
+                landnames.add(MagicColor.Constant.BASIC_LANDS.get(i));
+            }
+        }
+        Predicate<PaperCard> cp = Predicates.compose(new Predicate<String>() {
+            @Override
+            public boolean apply(final String name) {
+                return landnames.contains(name);
+            }
+        }, PaperCard.FN_GET_NAME);
+        cards = Lists.newArrayList(Iterables.filter(cards, cp));
+        // get a random basic land
+        PaperCard ran = Aggregates.random(cards);
+        Card random = CardFactory.getCard(ran, activator);
+        // if activator cannot play the random land, loop
+        while (!activator.canPlayLand(random, false) && !cards.isEmpty()) {
+            cards.remove(ran);
+            if (cards.isEmpty()) return;
+            ran = Aggregates.random(cards);
+            random = CardFactory.getCard(ran, activator);
+        }
+
+        String imageFileName = game.getRules().canCloneUseTargetsImage ? source.getImageKey() : random.getImageKey();
+        source.addAlternateState(CardCharacteristicName.Cloner);
+        source.switchStates(CardCharacteristicName.Original, CardCharacteristicName.Cloner);
+        source.setState(CardCharacteristicName.Original);
+        CardCharacteristicName stateToCopy = random.getCurState();
+        CardFactory.copyState(random, stateToCopy, source);
+        source.setImageKey(imageFileName);
+        
+        source.setController(activator, 0);
+        game.getAction().moveTo(activator.getZone(ZoneType.Battlefield), source);
+
+        // play a sound
+        game.fireEvent(new GameEventLandPlayed(activator, source));
+        
+        // Run triggers
+        final HashMap<String, Object> runParams = new HashMap<String, Object>();
+        runParams.put("Card", source);
+        game.getTriggerHandler().runTrigger(TriggerType.LandPlayed, runParams, false);
+        game.getStack().unfreezeStack();
+        activator.setNumLandsPlayed(activator.getNumLandsPlayed() + 1);
+
+
+    }
+
+}

forge-game/src/main/java/forge/game/player/Player.java

@@ -1732,6 +1732,7 @@ public class Player extends GameEntity implements Comparable<Player> {
      *            a {@link forge.game.card.Card} object.
      */
     public final boolean playLand(final Card land, final boolean ignoreZoneAndTiming) {
+        // Dakkon Blackblade Avatar will use a similar effect
         if (this.canPlayLand(land, ignoreZoneAndTiming)) {
             land.setController(this, 0);
             game.getAction().moveTo(this.getZone(ZoneType.Battlefield), land);
@@ -1793,7 +1794,7 @@ public class Player extends GameEntity implements Comparable<Player> {
                 return false;
 
             final Zone zone = game.getZoneOf(land);
-            if(zone.is(ZoneType.Battlefield) || (!zone.is(ZoneType.Hand) && !land.hasStartOfKeyword("May be played"))) {
+            if (zone != null && (zone.is(ZoneType.Battlefield) || (!zone.is(ZoneType.Hand) && !land.hasStartOfKeyword("May be played")))) {
                 return false;
             }
         }

forge-game/src/main/java/forge/game/staticability/StaticAbilityContinuous.java

@@ -450,7 +450,7 @@ public class StaticAbilityContinuous {
                         final String costcmc = Integer.toString(affectedCard.getCMC());
                         abilty = abilty.replace("ConvertedManaCost", costcmc);
                     }
-                    if (abilty.startsWith("AB")) { // grant the ability
+                    if (abilty.startsWith("AB") || abilty.startsWith("ST")) { // grant the ability
                         final SpellAbility sa = AbilityFactory.getAbility(abilty, affectedCard);
                         sa.setTemporary(true);
                         sa.setIntrinsic(false);