distant-horizons-sharded/build.gradle

import io.github.ran.jarmerger.JarMergerPlugin


buildscript {
    dependencies {
        classpath files('plugins/DHJarMerger-1.0.jar')
    }
    repositories {
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath "gradle.plugin.com.github.johnrengelman:shadow:7.1.2"
    }
}

plugins {
    id "architectury-plugin" version "3.4-SNAPSHOT"
    id "dev.architectury.loom" version "0.12.0-SNAPSHOT" apply false
}

/**
 * Creates the list of preprocessors to use.
 *
 * @param mcVers array of all MC versions
 * @param mcIndex array index of the currently active MC version
 */
def writeBuildGradlePredefine(List<String> mcVers, int mcIndex) {

    ArrayList<String> redefineList = new ArrayList<String>()
    for (int i=0; i<mcVers.size(); i++) {
        String mcStr = mcVers.get(i).replace(".", "_")
        if (mcIndex<i) {
            redefineList.add("PRE_MC_"+mcStr)
        }
        if (mcIndex==i) {
            redefineList.add("MC_"+mcStr)
        }
        if (mcIndex>=i) {
            redefineList.add("POST_MC_"+mcStr)
        }
    }

    // build the list of preprocessors to use
    StringBuilder sb = new StringBuilder()

    // check if this is a development build
    if (mod_version.toLowerCase().contains("dev")) {
        // WARNING: only use this for logging, we don't want to have confusion
        // when a method doesn't work correctly in the release build.
        sb.append("DEV_BUILD")
        sb.append("=\n")
    }

    // build the MC version preprocessors
    for (String redefinedVersion : redefineList) {
        sb.append(redefinedVersion)
        sb.append("=\n")
    }
    new File(projectDir, "build.properties").text = sb.toString()
}

// Sets up the variables for Manifold in the code
def loadProperties() {
    def defaultMcVersion = "1.18.2"
//    def defaultMcVersion = "1.19" // For now use 1.18.2 as default until 1.19 is done
    def mcVersion = ""
    def mcVers = mcVersions.split(",")
    int mcIndex = -1
    println "Avalible MC versions: ${mcVersions}"
    if (project.hasProperty("mcVer")) {
        mcVersion = mcVer
        mcIndex = Arrays.asList(mcVers).indexOf(mcVer)
    }
    if (mcIndex == -1) {
        println "No mcVer set or the set mcVer is invalid! Defaulting to ${defaultMcVersion}."
        println "Tip: Use -PmcVer='${defaultMcVersion}' in cmd arg to set mcVer."
        mcVersion = defaultMcVersion
        mcIndex = Arrays.asList(mcVers).indexOf(defaultMcVersion)
        assert mcIndex != -1
    }

	println "Loading properties file at " + mcVersion + ".properties"
	def props = new Properties()
	props.load(new FileInputStream("$rootProject.rootDir/"+"$mcVersion"+".properties"))

    props.each { prop ->
      rootProject.ext.set(prop.key, prop.value)
	  // println "Added prop [key:" + prop.key + ", value:" + prop.value + "]"
    }
    writeBuildGradlePredefine(Arrays.asList(mcVers), mcIndex)

    // Stuff for access wideners
    def mcVersionToAcsessWidenerVersion = [
            "1.16.5": "1_16",
            "1.17.1": "1_17",
            "1.18.1": "1_18",
            "1.18.2": "1_18",
            "1.19": "1_19"
    ]
    // Use this as sometimes multiple versions use the same access wideners
    rootProject.ext.set("acsessWidenerVersion", mcVersionToAcsessWidenerVersion.get(mcVersion))
}
loadProperties()

apply plugin: JarMergerPlugin

architectury {
    minecraft = rootProject.minecraft_version
}


subprojects { p ->
    apply plugin: "com.github.johnrengelman.shadow"
    apply plugin: "dev.architectury.loom"
    if (p == project(":core"))
        apply plugin: "application"

    loom {
        silentMojangMappingsLicense()

        if (p != project(":core")) {
            accessWidenerPath.set(project(":common").file("src/main/resources/${acsessWidenerVersion}.lod.accesswidener"))
        }
    }

    configurations {
        common
        shadowMe
        implementation.extendsFrom shadowMe
    }

    dependencies {
        minecraft "com.mojang:minecraft:${rootProject.minecraft_version}"
        // The following line declares the mojmap mappings & parchment mappings
        mappings loom.layered() {
            // Mojmap mappings
            officialMojangMappings()
            // Parchment mappings (it adds parameter mappings & javadoc)
            if (rootProject.minecraft_version != "1.19")
                parchment("org.parchmentmc.data:parchment-${rootProject.minecraft_version}:${rootProject.parchment_version}@zip")
            else // As 1.19 dosnt have parchment mappings yet, we use 1.18.2 mapping
                parchment("org.parchmentmc.data:parchment-1.18.2:${rootProject.parchment_version}@zip")
        }

		// Manifold
		annotationProcessor "systems.manifold:manifold-preprocessor:${rootProject.manifold_version}"

        // Toml & Json for config
        implementation("com.electronwill.night-config:toml:${rootProject.toml_version}")
        implementation("com.googlecode.json-simple:json-simple:${rootProject.json_version}")

        // Theming
        implementation("com.formdev:flatlaf:${rootProject.flatlaf_version}")
        // svg
        implementation("com.formdev:flatlaf-extras:${rootProject.flatlaf_version}")
        implementation("com.formdev:svgSalamander:${rootProject.svgSalamander_version}")

        // JUnit tests
        implementation("org.junit.jupiter:junit-jupiter:5.8.2")
        implementation("org.junit.jupiter:junit-jupiter-engine:5.8.2")


        if (p == project(":core") || p == project(":fabric") || p == project(":forge")) {
            // Compression
            common 'org.tukaani:xz:1.9'
            common 'org.apache.commons:commons-compress:1.21'
            shadowMe 'org.tukaani:xz:1.9'
            shadowMe 'org.apache.commons:commons-compress:1.21'
            // Toml & Json for config
            shadowMe("com.electronwill.night-config:toml:${rootProject.toml_version}") {}
            shadowMe("com.googlecode.json-simple:json-simple:${rootProject.json_version}") {}
            // Theming
            shadowMe("com.formdev:flatlaf:${rootProject.flatlaf_version}")
            // svg
            shadowMe("com.formdev:flatlaf-extras:${rootProject.flatlaf_version}")
            shadowMe("com.formdev:svgSalamander:${rootProject.svgSalamander_version}")
        }

        if (p != project(":forge")) {
            // We depend on fabric loader here to use the fabric @Environment annotations and get the mixin dependencies
            // Do NOT use other classes from fabric loader unless working with fabric
            modImplementation "net.fabricmc:fabric-loader:${rootProject.fabric_loader_version}"
        }


        if (p != project(":core"))
            common(project(":core")) { transitive false }
        if (p == project(":common"))
            shadowMe(project(":core")) { transitive false }
    }

    if (p == project(":core") || p == project(":fabric") || p == project(":forge")) {
        shadowJar {
            configurations = [project.configurations.shadowMe]

            // Compression
            relocate 'org.tukaani', 'shaded.tukaani'
            relocate 'org.apache.commons.compress', 'shaded.apache.commons.compress'
            // Toml & Json for config
            relocate 'com.electronwill.nightconfig', 'shaded.electronwill.nightconfig'
            relocate 'com.googlecode.json-simple', 'shaded.googlecode.json-simple' // FIXME: This is a massive library that is located in lots of different spots
            // Theming
            relocate 'com.formdev.flatlaf', 'shaded.formdev.flatlaf'
            // svg
            relocate 'com.kitfox.svg', 'shared.kitfox.svg'
        }

        remapJar {
            input.set shadowJar.archiveFile
            dependsOn shadowJar
        }
    }

    // Allows the jar to run standalone
    jar {
        manifest {
            attributes 'Implementation-Title': rootProject.archives_base_name,
                    'Implementation-Version': rootProject.mod_version,
                    'Main-Class': 'com.seibel.lod.core.JarMain' // When changing the main of the jar change this line
        }
    }
    if (p == project(":core")) {
        application {
            mainClass.set('com.seibel.lod.core.JarMain')
        }
    }
}

allprojects { p ->
    apply plugin: "java"
    apply plugin: "architectury-plugin"
    apply plugin: "maven-publish"

    archivesBaseName = rootProject.archives_base_name
    version = rootProject.mod_version
    group = rootProject.maven_group


    repositories {
        mavenCentral()

        // For parchment mappings
        maven { url "https://maven.parchmentmc.org" }

        // For Architectury API
        maven { url "https://maven.architectury.dev" }

        // used to download and compile dependencies from git repos
        maven { url 'https://jitpack.io' }

        // For Manifold Preprocessor
        maven { url 'https://oss.sonatype.org/content/repositories/snapshots/' }

        // Required for importing Modrinth mods
        maven {
            name = "Modrinth"
            url = "https://api.modrinth.com/maven"
            content {
                includeGroup "maven.modrinth"
            }
        }

        // Required for importing CursedForge mods
        maven {
            url "https://www.cursemaven.com"
            content {
                includeGroup "curse.maven"
            }
        }

        // These 2 are for importing mods that arnt on CursedForge, Modrinth, GitHub, GitLab or anywhere opensource
        flatDir {
            dirs "${rootDir}/mods/fabric"
            content {
                includeGroup "fabric-mod"
            }
        }
        flatDir {
            dirs "${rootDir}/mods/forge"
            content {
                includeGroup "forge-mod"
            }
        }
    }


    // Put stuff from gradle.properties into the mod info
    processResources {
        def resourceTargets = ["fabric.mod.json", "META-INF/mods.toml"] // Location of where to put
        def intoTargets = ["$buildDir/resources/main/"] // Location of the built resources folder
        def replaceProperties = [
                version                      : mod_version,
                mod_name                     : mod_name,
                authors                      : mod_authors,
                description                  : mod_description,
                homepage                     : mod_homepage,
                source                       : mod_source,
                issues                       : mod_issues,
                minecraft_version            : minecraft_version,
                compatible_minecraft_versions: compatible_minecraft_versions,
                java_version                 : java_version
        ]
        // The left side is what gets replaced in the mod info and the right side is where to get it from in the gradle.properties
        //TODO: Make Forge loader version also be relaced with non hardcoded value instead of "[36,42)"

        inputs.properties replaceProperties
        replaceProperties.put 'project', project
        filesMatching(resourceTargets) {
            expand replaceProperties
        }

        intoTargets.each { target ->
            if (file(target).exists()) {
                copy {
                    from(sourceSets.main.resources) {
                        include resourceTargets
                        expand replaceProperties
                    }
                    into target
                }
            }
        }
    }


    // Copies the correct accesswidener and renames it
    task copyAccessWidener(type: Copy) {
        from project(":common").file("src/main/resources/${rootProject.acsessWidenerVersion}.lod.accesswidener")
        into(file(p.file("build/resources/main")))
        rename "${rootProject.acsessWidenerVersion}.lod.accesswidener", "lod.accesswidener"
    }

    task copyCoreResources(type: Copy) {
        from fileTree(project(":core").file("src/main/resources"))
        into p.file("build/resources/main")
    }

    task copyCommonResources(type: Copy) {
        from fileTree(project(":common").file("src/main/resources"))
        into p.file("build/resources/main")
    }


    // Is this necessary for running the fabric build
    if (p == project(":common")) {
        println "Copying [common/src/main/resources/${acsessWidenerVersion}.lod.accesswidner] to [fabric/build/resources/main]."

        copy {
            from project(":common").file("src/main/resources/${acsessWidenerVersion}.lod.accesswidener")
            into project(":fabric").file("build/resources/main")
            rename "${acsessWidenerVersion}.lod.accesswidener", "lod.accesswidener"
        }
    }

    tasks.withType(JavaCompile) {
        // Add Manifold Preprocessor
//		def excapedMCVersion = rootProject.minecraft_version.replace(".", "_")
//		options.compilerArgs += ['-Xplugin:Manifold', "-AMC_VERSION_${excapedMCVersion}"]
//
        //options.compilerArgs += ['-deprecation']
        //options.compilerArgs += ['-verbose']
        //options.compilerArgs += ['-Xlint:unchecked']
        //options.compilerArgs += ['-Xdiags:verbose']
        //options.compilerArgs += ['-Xprint']
        //options.compilerArgs += ['-XprintProcessorInfo']
        //options.compilerArgs += ['-XprintRounds']

        // println options.compilerArgs

        // Set the java version
        if (p != project(":core")) {
            options.release = rootProject.java_version as Integer
            options.compilerArgs += ['-Xplugin:Manifold']
        } else {
            options.release = 8; // Core should use Java 8 no matter what
        }
        options.encoding = "UTF-8" // Not requred but better to have

        // TODO: make everything use java 8
//        options.release = 8 // Use Java 8 for everything so back porting is easier
    }

    java {
        withSourcesJar()
    }

    // Disable running the core and common
    if (p == project(":core") || p == project(":common")) {
        runClient.enabled = false
        runServer.enabled = false
    }
}