Move explosive enhancment into isolation

[no changelog]

build.gradle.kts

@@ -154,10 +154,6 @@ val SourceSet.modImplementationConfigurationName
 		loom.remapConfigurations.find {
 			it.targetConfigurationName.get() == this.implementationConfigurationName
 		}!!.sourceConfiguration
-val configuredSourceSet = createIsolatedSourceSet("configured")
-val sodiumSourceSet = createIsolatedSourceSet("sodium")
-val citResewnSourceSet = createIsolatedSourceSet("citresewn")
-val yaclSourceSet = createIsolatedSourceSet("yacl")
 
 val shadowMe by configurations.creating {
 	exclude(group = "org.jetbrains.kotlin")
@@ -182,6 +178,12 @@ val nonModImplentation by configurations.creating {
 }
 
 
+val configuredSourceSet = createIsolatedSourceSet("configured")
+val sodiumSourceSet = createIsolatedSourceSet("sodium")
+val citResewnSourceSet = createIsolatedSourceSet("citresewn")
+val yaclSourceSet = createIsolatedSourceSet("yacl")
+val explosiveEnhancementSourceSet = createIsolatedSourceSet("explosiveEnhancement")
+
 dependencies {
 	// Minecraft dependencies
 	"minecraft"(libs.minecraft)
@@ -196,7 +198,7 @@ dependencies {
 	modImplementation(libs.modmenu)
 	modImplementation(libs.moulconfig)
 	modImplementation(libs.manninghamMills)
-	modCompileOnly(libs.explosiveenhancement)
+	(explosiveEnhancementSourceSet.modImplementationConfigurationName)(libs.explosiveenhancement)
 	modImplementation(libs.hypixelmodapi)
 	include(libs.hypixelmodapi.fabric)
 	compileOnly(project(":javaplugin"))

src/compat/explosiveEnhancement/java/ExplosiveEnhancementSpawner.kt

@@ -0,0 +1,17 @@
+package moe.nea.firmament.compat.explosiveenhancement
+
+import com.google.auto.service.AutoService
+import net.superkat.explosiveenhancement.api.ExplosiveApi
+import net.minecraft.util.math.Vec3d
+import moe.nea.firmament.features.fixes.CompatibliltyFeatures
+import moe.nea.firmament.features.fixes.CompatibliltyFeatures.TConfig
+import moe.nea.firmament.util.MC
+import moe.nea.firmament.util.compatloader.CompatLoader
+
+@AutoService(CompatibliltyFeatures.ExplosiveApiWrapper::class)
+@CompatLoader.RequireMod("explosiveenhancement")
+class ExplosiveEnhancementSpawner : CompatibliltyFeatures.ExplosiveApiWrapper {
+	override fun spawnParticle(vec3d: Vec3d, power: Float) {
+		ExplosiveApi.spawnParticles(MC.world, vec3d.x, vec3d.y, vec3d.z, TConfig.explosionSize / 10F)
+	}
+}

src/main/kotlin/features/fixes/CompatibliltyFeatures.kt

@@ -1,51 +1,41 @@
-
-
 package moe.nea.firmament.features.fixes
 
-import net.fabricmc.loader.api.FabricLoader
-import net.superkat.explosiveenhancement.api.ExplosiveApi
 import net.minecraft.particle.ParticleTypes
 import net.minecraft.util.math.Vec3d
 import moe.nea.firmament.annotations.Subscribe
 import moe.nea.firmament.events.ParticleSpawnEvent
 import moe.nea.firmament.features.FirmamentFeature
 import moe.nea.firmament.gui.config.ManagedConfig
-import moe.nea.firmament.util.MC
+import moe.nea.firmament.util.compatloader.CompatLoader
 
 object CompatibliltyFeatures : FirmamentFeature {
-    override val identifier: String
+	override val identifier: String
-        get() = "compatibility"
+		get() = "compatibility"
 
-    object TConfig : ManagedConfig(identifier, Category.INTEGRATIONS) {
+	object TConfig : ManagedConfig(identifier, Category.INTEGRATIONS) {
-        val enhancedExplosions by toggle("explosion-enabled") { false }
+		val enhancedExplosions by toggle("explosion-enabled") { false }
-        val explosionSize by integer("explosion-power", 10, 50) { 1 }
+		val explosionSize by integer("explosion-power", 10, 50) { 1 }
-    }
+	}
 
-    override val config: ManagedConfig?
+	override val config: ManagedConfig?
-        get() = TConfig
+		get() = TConfig
 
-    interface ExplosiveApiWrapper {
+	interface ExplosiveApiWrapper {
-        fun spawnParticle(vec3d: Vec3d, power: Float)
+		fun spawnParticle(vec3d: Vec3d, power: Float)
-    }
 
-    class ExplosiveApiWrapperImpl : ExplosiveApiWrapper {
+		companion object : CompatLoader<ExplosiveApiWrapper>(ExplosiveApiWrapper::class.java)
-        override fun spawnParticle(vec3d: Vec3d, power: Float) {
+	}
-            ExplosiveApi.spawnParticles(MC.world, vec3d.x, vec3d.y, vec3d.z, TConfig.explosionSize / 10F)
-        }
-    }
 
-    val explosiveApiWrapper = if (FabricLoader.getInstance().isModLoaded("explosiveenhancement")) {
+	private val explosiveApiWrapper = ExplosiveApiWrapper.singleInstance
-        ExplosiveApiWrapperImpl()
-    } else null
 
-    @Subscribe
+	@Subscribe
-    fun onExplosion(it: ParticleSpawnEvent) {
+	fun onExplosion(it: ParticleSpawnEvent) {
-        if (TConfig.enhancedExplosions &&
+		if (TConfig.enhancedExplosions &&
-            it.particleEffect.type == ParticleTypes.EXPLOSION_EMITTER &&
+			it.particleEffect.type == ParticleTypes.EXPLOSION_EMITTER &&
-            explosiveApiWrapper != null
+			explosiveApiWrapper != null
-        ) {
+		) {
-            it.cancel()
+			it.cancel()
-            explosiveApiWrapper.spawnParticle(it.position, 2F)
+			explosiveApiWrapper.spawnParticle(it.position, 2F)
-        }
+		}
-    }
+	}
 }

src/main/kotlin/util/compatloader/CompatLoader.kt

@@ -0,0 +1,47 @@
+package moe.nea.firmament.util.compatloader
+
+import java.util.ServiceLoader
+import net.fabricmc.loader.api.FabricLoader
+import kotlin.streams.asSequence
+import moe.nea.firmament.Firmament
+
+abstract class CompatLoader<T : Any>(val kClass: Class<T>) {
+	val loader: ServiceLoader<T> = ServiceLoader.load(kClass)
+	val allValidInstances by lazy {
+		loader.reload()
+		loader.stream()
+			.asSequence()
+			.filter { provider ->
+				runCatching {
+					shouldLoad(provider.type())
+				}.getOrElse {
+					Firmament.logger.error("Could not determine whether to load a ${kClass.name} subclass", it)
+					false
+				}
+			}
+			.mapNotNull { provider ->
+				runCatching {
+					provider.get()
+				}.getOrElse {
+					Firmament.logger.error(
+						"Could not load desired instance ${provider.type().name} for ${kClass.name}",
+						it)
+					null
+				}
+			}
+			.toList()
+	}
+	val singleInstance by lazy { allValidInstances.singleOrNull() }
+
+	open fun shouldLoad(type: Class<out T>): Boolean {
+		return checkRequiredModsPresent(type)
+	}
+
+	fun checkRequiredModsPresent(type: Class<*>): Boolean {
+		val requiredMods = type.getAnnotationsByType(RequireMod::class.java)
+		return requiredMods.all { FabricLoader.getInstance().isModLoaded(it.modId) }
+	}
+
+	@Repeatable
+	annotation class RequireMod(val modId: String)
+}