New common class CopyTargetStackAbilityEffect (#10525)

- Fix superfluous null check in Lithoform Engine
- Remove hardcoding of controlled abilities in TargetTriggeredAbility (used only in Strionic Resonator)
- EnchantmentSourcePredicate analogous to ArtifactSourcePredicate

Mage/src/main/java/mage/abilities/effects/common/CopyTargetStackAbilityEffect.java

@@ -0,0 +1,52 @@
+package mage.abilities.effects.common;
+
+import mage.abilities.Ability;
+import mage.abilities.Mode;
+import mage.abilities.effects.OneShotEffect;
+import mage.constants.Outcome;
+import mage.game.Game;
+import mage.game.stack.StackAbility;
+
+public class CopyTargetStackAbilityEffect extends OneShotEffect {
+
+    /**
+     * Copy target (activated/triggered) ability on the stack, choosing new targets for the copy
+     */
+    public CopyTargetStackAbilityEffect() {
+        super(Outcome.Copy);
+    }
+
+    public CopyTargetStackAbilityEffect(final CopyTargetStackAbilityEffect effect) {
+        super(effect);
+    }
+
+    @Override
+    public boolean apply(Game game, Ability source) {
+        StackAbility stackAbility = (StackAbility) game.getStack().getStackObject(targetPointer.getFirst(game, source));
+        if (stackAbility == null) {
+            return false;
+        }
+        stackAbility.createCopyOnStack(game, source, source.getControllerId(), true);
+        return true;
+    }
+
+    @Override
+    public CopyTargetStackAbilityEffect copy() {
+        return new CopyTargetStackAbilityEffect(this);
+    }
+
+    @Override
+    public String getText(Mode mode) {
+        if (staticText != null && !staticText.isEmpty()) {
+            return staticText;
+        }
+        StringBuilder sb = new StringBuilder();
+        sb.append("copy ");
+        if (!mode.getTargets().isEmpty()) {
+            sb.append("target ").append(mode.getTargets().get(0).getTargetName());
+        }
+        sb.append(". You may choose new targets for the copy");
+        return sb.toString();
+    }
+
+}

Mage/src/main/java/mage/filter/predicate/other/EnchantmentSourcePredicate.java

@@ -0,0 +1,24 @@
+package mage.filter.predicate.other;
+
+import mage.filter.predicate.Predicate;
+import mage.game.Game;
+import mage.game.stack.StackAbility;
+import mage.game.stack.StackObject;
+
+/**
+ * @author LevelX2
+ */
+public enum EnchantmentSourcePredicate implements Predicate<StackObject> {
+    instance;
+
+    @Override
+    public boolean apply(StackObject input, Game game) {
+        return input instanceof StackAbility
+                && ((StackAbility) input).getSourceObject(game).isEnchantment(game);
+    }
+
+    @Override
+    public String toString() {
+        return "Source(Enchantment)";
+    }
+}

Mage/src/main/java/mage/target/common/TargetTriggeredAbility.java

@@ -1,32 +1,36 @@
 package mage.target.common;
 
 import mage.abilities.Ability;
-import mage.abilities.TriggeredAbility;
+import mage.constants.AbilityType;
 import mage.constants.Zone;
 import mage.filter.Filter;
-import mage.filter.FilterAbility;
+import mage.filter.FilterStackObject;
 import mage.game.Game;
 import mage.game.stack.StackObject;
 import mage.target.TargetObject;
 
-import java.util.HashSet;
 import java.util.Set;
 import java.util.UUID;
+import java.util.stream.Collectors;
 
 /**
  * @author Styxo
  */
 public class TargetTriggeredAbility extends TargetObject {
 
-    public TargetTriggeredAbility() {
+    protected final FilterStackObject filter;
+
+    public TargetTriggeredAbility(FilterStackObject filter) {
         this.minNumberOfTargets = 1;
         this.maxNumberOfTargets = 1;
         this.zone = Zone.STACK;
-        this.targetName = "target triggered ability you control";
+        this.targetName = filter.getMessage();
+        this.filter = filter;
     }
 
     public TargetTriggeredAbility(final TargetTriggeredAbility target) {
         super(target);
+        this.filter = target.filter.copy();
     }
 
     @Override
@@ -37,28 +41,29 @@ public class TargetTriggeredAbility extends TargetObject {
         }
 
         StackObject stackObject = game.getStack().getStackObject(id);
-        return stackObject != null
-                && stackObject.getStackAbility() instanceof TriggeredAbility
+        return isTriggeredAbility(stackObject)
                 && source != null
-                && stackObject.getStackAbility().isControlledBy(source.getControllerId());
+                && filter.match(stackObject, source.getControllerId(), source, game);
     }
 
     @Override
     public boolean canChoose(UUID sourceControllerId, Ability source, Game game) {
-        return canChoose(sourceControllerId, game);
-    }
-
-    @Override
-    public boolean canChoose(UUID sourceControllerId, Game game) {
         for (StackObject stackObject : game.getStack()) {
-            if (stackObject.getStackAbility() instanceof TriggeredAbility
-                    && stackObject.getStackAbility().isControlledBy(sourceControllerId)) {
+            if (isTriggeredAbility(stackObject)
+                    && filter.match(stackObject, sourceControllerId, source, game)) {
                 return true;
             }
         }
         return false;
     }
 
+    @Override
+    public boolean canChoose(UUID sourceControllerId, Game game) {
+        return game.getStack()
+                .stream()
+                .anyMatch(TargetTriggeredAbility::isTriggeredAbility);
+    }
+
     @Override
     public Set<UUID> possibleTargets(UUID sourceControllerId, Ability source, Game game) {
         return possibleTargets(sourceControllerId, game);
@@ -66,14 +71,10 @@ public class TargetTriggeredAbility extends TargetObject {
 
     @Override
     public Set<UUID> possibleTargets(UUID sourceControllerId, Game game) {
-        Set<UUID> possibleTargets = new HashSet<>();
-        for (StackObject stackObject : game.getStack()) {
-            if (stackObject.getStackAbility() instanceof TriggeredAbility
-                    && stackObject.getStackAbility().isControlledBy(sourceControllerId)) {
-                possibleTargets.add(stackObject.getStackAbility().getId());
-            }
-        }
-        return possibleTargets;
+        return game.getStack().stream()
+                .filter(TargetTriggeredAbility::isTriggeredAbility)
+                .map(stackObject -> stackObject.getStackAbility().getId())
+                .collect(Collectors.toSet());
     }
 
     @Override
@@ -83,7 +84,18 @@ public class TargetTriggeredAbility extends TargetObject {
 
     @Override
     public Filter getFilter() {
-        return new FilterAbility();
+        return filter;
+    }
+
+    static boolean isTriggeredAbility(StackObject stackObject) {
+        if (stackObject == null) {
+            return false;
+        }
+        if (stackObject instanceof Ability) {
+            Ability ability = (Ability) stackObject;
+            return ability.getAbilityType() == AbilityType.TRIGGERED;
+        }
+        return false;
     }
 
 }