Add conditional mod exclusions

module-gtnhmixins/src/main/java/com/gtnewhorizon/gtnhmixins/builders/AbstractBuilder.java

@@ -14,16 +14,20 @@
 import java.util.List;
 import java.util.Objects;
 import java.util.Set;
+import java.util.function.BooleanSupplier;
 import java.util.function.Supplier;
 
 @SuppressWarnings("ForLoopReplaceableByForEach")
 public abstract class AbstractBuilder {
+    private static final BooleanSupplier TRUE = () -> true;
 
     protected @Nullable List<String> commonClasses;
     protected @Nullable List<String> clientClasses;
     protected @Nullable List<String> serverClasses;
     protected @Nullable List<ITargetMod> requiredMods;
+    protected @Nullable List<BooleanSupplier> requiredModsCond;
     protected @Nullable List<ITargetMod> excludedMods;
+    protected @Nullable List<BooleanSupplier> excludedModsCond;
     protected @Nullable Phase phase;
     protected @Nonnull Supplier<Boolean> applyIf = () -> true;
 
@@ -69,16 +73,30 @@ protected AbstractBuilder setApplyIf(@Nonnull Supplier<Boolean> applyIf) {
     }
 
     protected AbstractBuilder addRequiredMod(@Nonnull ITargetMod mod) {
+        return addRequiredModIf(mod, TRUE);
+    }
+
+    protected AbstractBuilder addRequiredModIf(@Nonnull ITargetMod mod, @Nonnull BooleanSupplier condition) {
         Objects.requireNonNull(mod);
+        Objects.requireNonNull(condition);
         if (requiredMods == null) requiredMods = new ArrayList<>(2);
+        if (requiredModsCond == null) requiredModsCond = new ArrayList<>(2);
         requiredMods.add(mod);
+        requiredModsCond.add(condition);
         return this;
     }
 
     protected AbstractBuilder addExcludedMod(@Nonnull ITargetMod mod) {
+        return addExcludedModIf(mod, TRUE);
+    }
+
+    protected AbstractBuilder addExcludedModIf(@Nonnull ITargetMod mod, @Nonnull BooleanSupplier condition) {
         Objects.requireNonNull(mod);
+        Objects.requireNonNull(condition);
         if (excludedMods == null) excludedMods = new ArrayList<>(2);
+        if (excludedModsCond == null) excludedModsCond = new ArrayList<>(2);
         excludedMods.add(mod);
+        excludedModsCond.add(condition);
         return this;
     }
 
@@ -102,8 +120,12 @@ protected void addAllClassesTo(List<String> list) {
     }
 
     protected void addAllTargetsTo(Set<ITargetMod> set) {
-        if (requiredMods != null) set.addAll(requiredMods);
-        if (excludedMods != null) set.addAll(excludedMods);
+        if (requiredMods != null) {
+            set.addAll(requiredMods);
+        }
+        if (excludedMods != null) {
+            set.addAll(excludedMods);
+        }
     }
 
     protected boolean shouldLoad(Set<ITargetMod> loadedTargets) {
@@ -112,15 +134,21 @@ protected boolean shouldLoad(Set<ITargetMod> loadedTargets) {
 
     protected boolean allRequiredModsPresent(Set<ITargetMod> loadedTargets) {
         if (requiredMods == null) return true;
+        boolean hasCond = requiredModsCond != null;
         for (int i = 0; i < requiredMods.size(); i++) {
+            if (hasCond && !requiredModsCond.get(i).getAsBoolean())
+                continue;
             if (!loadedTargets.contains(requiredMods.get(i))) return false;
         }
         return true;
     }
 
     protected boolean noExcludedModsPresent(Set<ITargetMod> loadedTargets) {
         if (excludedMods == null) return true;
+        boolean hasCond = excludedModsCond != null;
         for (int i = 0; i < excludedMods.size(); i++) {
+            if (hasCond && !excludedModsCond.get(i).getAsBoolean())
+                continue;
             if (loadedTargets.contains(excludedMods.get(i))) return false;
         }
         return true;

module-gtnhmixins/src/main/java/com/gtnewhorizon/gtnhmixins/builders/MixinBuilder.java

@@ -8,6 +8,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Set;
+import java.util.function.BooleanSupplier;
 import java.util.function.Supplier;
 
 @SuppressWarnings("unused")
@@ -61,6 +62,14 @@ public MixinBuilder addRequiredMod(@Nonnull ITargetMod mod) {
         return (MixinBuilder) super.addRequiredMod(mod);
     }
 
+    /**
+     * Specify mods that are required to be present for this mixin to load and the condition is true. The condition is evaluated lazily during mixin loading.
+     */
+    @Override
+    public MixinBuilder addRequiredModIf(@Nonnull ITargetMod mod, @Nonnull BooleanSupplier condition) {
+        return (MixinBuilder) super.addExcludedModIf(mod, condition);
+    }
+
     /**
      * Specify mods that will disable this mixin if they are present
      */
@@ -69,6 +78,14 @@ public MixinBuilder addExcludedMod(@Nonnull ITargetMod mod) {
         return (MixinBuilder) super.addExcludedMod(mod);
     }
 
+    /**
+     * Specify mods that will disable this mixin if they are present and the condition is true. The condition is evaluated lazily during mixin loading.
+     */
+    @Override
+    public MixinBuilder addExcludedModIf(@Nonnull ITargetMod mod, @Nonnull BooleanSupplier condition) {
+        return (MixinBuilder) super.addExcludedModIf(mod, condition);
+    }
+
     /**
      * Mixins registered from a {@link com.gtnewhorizon.gtnhmixins.IEarlyMixinLoader} need to set this to
      * {@link com.gtnewhorizon.gtnhmixins.builders.IMixins.Phase#EARLY}.

module-gtnhmixins/src/main/java/com/gtnewhorizon/gtnhmixins/builders/TransformerBuilder.java

@@ -7,6 +7,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Set;
+import java.util.function.BooleanSupplier;
 import java.util.function.Supplier;
 
 public class TransformerBuilder extends AbstractBuilder {
@@ -58,13 +59,30 @@ public TransformerBuilder addRequiredMod(@Nonnull ITargetMod mod) {
         return (TransformerBuilder) super.addRequiredMod(mod);
     }
 
+    /**
+     * Specify mods that are required to be present for this transformer to load and the condition is true. The condition is evaluated lazily during transformer loading.
+     */
+    @Override
+    public TransformerBuilder addRequiredModIf(@Nonnull ITargetMod mod, @Nonnull BooleanSupplier condition) {
+        return (TransformerBuilder) super.addExcludedModIf(mod, condition);
+    }
+
     /**
      * Specify mods that will disable this transformer if they are present
      */
     public TransformerBuilder addExcludedMod(@Nonnull ITargetMod mod) {
         return (TransformerBuilder) super.addExcludedMod(mod);
     }
 
+
+    /**
+     * Specify mods that will disable this transformer if they are present and the condition is true. The condition is evaluated lazily during transformer loading.
+     */
+    @Override
+    public TransformerBuilder addExcludedModIf(@Nonnull ITargetMod mod, @Nonnull BooleanSupplier condition) {
+        return (TransformerBuilder) super.addExcludedModIf(mod, condition);
+    }
+
     protected static <E extends Enum<E> & ITransformers> void loadTransformers(Class<E> transformerEnum, List<String> toLoad, List<String> toNotLoad) {
         List<AbstractBuilder> builders = getEnabledBuildersForPhase(transformerEnum, toNotLoad);
         Set<ITargetMod> loadedTargets = getLoadedTargetedMods(builders, null, Collections.emptySet(), Collections.emptySet());