SnowyGUI/build.gradle.kts

import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
import com.modrinth.minotaur.request.VersionType

buildscript {
    dependencies {
        classpath("com.guardsquare:proguard-gradle:7.1.0-beta2") {
            exclude("com.android.tools.build")
        }
    }
}

plugins {
    kotlin("jvm") version "1.5.0-RC"
    id("com.github.johnrengelman.shadow") version "6.1.0" apply false
    id("architectury-plugin") version "3.0-SNAPSHOT"
    id("forgified-fabric-loom") version "0.7.0-SNAPSHOT" apply false
    id("com.github.ben-manes.versions") version "0.38.0"
    id("com.modrinth.minotaur") version "1.2.0"
}

group = "fr.username404"
version = "0.0.1"
val groupAndName = "${rootProject.group}.${rootProject.name.toLowerCase()}"

architectury {
    minecraft = rootProject.property("minecraft") as String
}

subprojects {
    lateinit var MappingsDep: Dependency
    apply(plugin = "org.jetbrains.kotlin.jvm")
    apply(plugin = "forgified-fabric-loom")
    apply(plugin = "com.github.johnrengelman.shadow")
    val shadowC by configurations.creating
    tasks {
        withType(ShadowJar::class) { this.configurations = listOf(shadowC) }
        val shrinkJar = register("shrinkJar", proguard.gradle.ProGuardTask::class) {
            val dictionariesDir = "$rootDir/obfuscation"
            injars(this@tasks.getByName("remapJar"))
            outjars("$rootDir/shrinkedJars/")
            keep("class fr.username404.snowygui.mixins.* { * ; }")
            keep("class fr.username404.snowygui.fabric.** { * ; }")
            keep("class fr.username404.snowygui.forge.** { * ; }")
            keepclassmembers("class fr.username404.snowygui.** { public protected <methods>; }")
            keepattributes("*Annotation*, Signature, InnerClasses, EnclosingMethod, MethodParameters, Synthetic, Exceptions")
            obfuscationdictionary("$dictionariesDir/dictionary.txt")
            classobfuscationdictionary("$dictionariesDir/classdictionary.txt")
            packageobfuscationdictionary("$dictionariesDir/packagesdictionary.txt")
            adaptclassstrings()
            "fr.username404.**".also { dontwarn(it); dontnote(it) }

            // The following lines are needed at least for the current version of proguard
            dontwarn("java.**")
            onlyIf {
                JavaVersion.current().isJava8.also {
                    if (!it) {
                        println("The shrinkJar task is disabled because Java 9 or higher does not work with our current proguard configuration.")
                    }
                }
            }
            libraryjars("${System.getProperty("java.home")}/lib/rt.jar")
            libraryjars("${System.getProperty("java.home")}/lib/jce.jar")

            // Note: dontpreverify() should NOT be used, it will cause errors at runtime
            useuniqueclassmembernames()
            optimizations("method/inlining/*, code/allocation/variable, class/merging/vertical, class/merging/horizontal, code/removal/advanced, code/simplification/branch, code/merging")
            optimizationpasses(4)
            overloadaggressively()
        }
        if (this@subprojects.name != "common") build.get().finalizedBy(shrinkJar)
    }
    extensions.configure<net.fabricmc.loom.LoomGradleExtension>("loom") {
        MappingsDep = officialMojangMappings()
        silentMojangMappingsLicense()
        mixinConfig("snowygui-mixins.json")
        refmapName = "snowygui-common-refmap.json"
    }
    dependencies {
        shadowC(kotlin("stdlib-jdk8") as String) {
            exclude(module = "kotlin-stdlib-common")
            exclude(module = "annotations")
        }
        "io.github.config4k:config4k:0.4.2".also { implementation(it); shadowC(it) }
        "minecraft"("com.mojang:minecraft:${rootProject.property("minecraft")}")
        "mappings"(MappingsDep)
    }
}

val mcBase: String = rootProject.architectury.minecraft.dropLast(2)
allprojects {
    apply(plugin = "java")
    apply(plugin = "architectury-plugin")
    java {
        targetCompatibility = JavaVersion.VERSION_1_8
        sourceCompatibility = JavaVersion.VERSION_1_8
    }
    tasks {
        withType(ShadowJar::class) {
            relocate("kotlin", "${rootProject.group}.kotlin")
            relocate("com.typesafe.config", "${rootProject.group}.typesafe.config")
            relocate("io.github.config4k", "${rootProject.group}.config4k")
            exclude("**/*.kotlin_metadata")
            exclude("**/*.kotlin_builtins")
            exclude("META-INF/maven/**/*")
            archiveClassifier.set("shadow")
        }
        withType(Jar::class) {
            from("$rootDir/LICENSE.txt")
            archiveBaseName.set("${rootProject.name}-${rootProject.version}")
        }
        withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile::class) {
            with(kotlinOptions) {
                freeCompilerArgs = listOf("-Xjvm-default=all", "-Xlambdas=indy")
                jvmTarget = "1.8"
                languageVersion = "1.5"
                apiVersion = "1.5"
            }
        }
        withType(JavaCompile::class) {
            with(options) {
                encoding = "UTF-8"
                if (JavaVersion.current().isJava9Compatible) {
                    release.set(8)
                }; isFork = true
            }
        }
        withType(net.fabricmc.loom.task.RemapJarTask::class) {
            val shadowTask = getByName("shadowJar") as ShadowJar
            dependsOn(shadowTask)
            archiveBaseName.set(shadowTask.archiveBaseName)
            input.set(shadowTask.archiveFile)
            archiveClassifier.set(this@allprojects.name)
            if (!archiveFileName.get().contains("common")) destinationDirectory.set(file("$rootDir/remappedJars"))
        }
        withType(ProcessResources::class) {
            with(project(":common").sourceSets.main.get().resources.srcDirs) {
                if (!sourceSets.main.get().resources.srcDirs.containsAll(this)) {
                    from(this)
                }
            }
            val ModProperties = mapOf<String, String>(
                "mod_version" to (rootProject.version as String),
                "minecraft_version" to mcBase
            )
            inputs.properties(ModProperties)
            filesNotMatching(listOf("*.png")) {
                expand(ModProperties)
            }
        }
    }
}

tasks {
    listOf(
        file("remappedJars"),
        file("shrinkedJars")
    ).forEach { if (it.exists()) clean.get().delete.add(it) }
    val publishToModrinth = register<com.modrinth.minotaur.TaskModrinthUpload>("publishtoModrinth") {
        val envStr: String? = System.getenv("MODRINTH")
        onlyIf { envStr != null }
        versionNumber = version.toString()
        projectId = "OuGyGg6A"
        token = envStr
        addGameVersion(mcBase)
        versionType = VersionType.ALPHA
        detectLoaders = false
        versionName = "${project.name} $versionNumber for Minecraft $gameVersions and higher"
        fileTree("$rootDir/shrinkedJars/").files.forEach {
            with(it.name) {
                when {
                    contains("fabric") -> uploadFile = it
                    contains("forge") -> addFile(it)
                }
            }
        }
        addLoader("fabric"); addLoader("forge")
    }
    build.get().finalizedBy(publishToModrinth)
}