build.gradle

import groovy.json.JsonOutput
import groovy.json.JsonSlurper
import net.minecraftforge.gradle.common.util.RunConfig

import java.util.function.Consumer

plugins {
    id 'java'
    id 'eclipse'
    id 'idea'
    id 'net.neoforged.gradle' version '[6.0.18,6.2)'
    id 'org.parchmentmc.librarian.forgegradle' version '1.+'
}

tasks.named('wrapper', Wrapper).configure {
    //Define wrapper values here so as to not have to always do so when updating gradlew.properties
    gradleVersion = '8.4'
    distributionType = Wrapper.DistributionType.ALL
}

defaultTasks 'build'

idea {
    module {
        //Exclude directories from being managed
        for (String excludeDirName in ["run", "out", "logs", "gradle"]) {
            excludeDirs.add(new File(projectDir, excludeDirName))
        }
    }
}

sourceSets {
    main {
        resources {
            srcDirs += 'src/datagen/generated'
            //There is no need to pack the Data Generator cache into the build
            exclude '.cache'
        }
    }
    datagen {
        java.srcDirs = ['src/datagen/java']
        //Data gen has no resources it just creates resources
        resources.srcDirs = []
        compileClasspath += project.sourceSets.main.output
    }
}

configurations {
    //Let the datagen source set know about forge
    datagenImplementation.extendsFrom(implementation)
    datagenCompileOnly.extendsFrom(compileOnly)
    datagenRuntimeOnly.extendsFrom(runtimeOnly)
}

ext {
    versionProperties = ["version"       : mod_version, "mc_version": minecraft_version_range, "forge_version": forge_version_range,
                         "loader_version": loader_version_range, "projecte_version": projecte_version_range]
    jsonPatterns = ["**/*.json", "**/*.mcmeta"]
    //Setup the UPDATE_SOURCESET property in case we are doing any remappings
    UPDATE_SOURCESETS = project.sourceSets.collect { it.name }.join(';')
}

def replaceResources = tasks.register("replaceResources", Copy) {
    it.outputs.upToDateWhen { false }
    def modsToml = copySpec {
        from(sourceSets.main.resources) {
            include "META-INF/mods.toml"
            expand versionProperties
        }
    }
    //Copy it into the build dir
    it.with modsToml
    it.into "$buildDir/resources/main/"
    //If IntelliJ's output dir exists, copy it there as well
    if (new File("$rootDir/out/production/").exists()) {
        copy {
            with modsToml
            into "$rootDir/out/production/"
        }
    }
    //If Eclipse's output dir exists, copy it there as well
    if (new File("$rootDir/bin/main/").exists()) {
        copy {
            with modsToml
            into "$rootDir/bin/main/"
        }
    }
}

group = 'gg.galaxygaming.projectextended'
version = "${minecraft_version}-${mod_version}"
archivesBaseName = 'ProjectExtended'

java {
    toolchain {
        languageVersion.set(JavaLanguageVersion.of(17))
        vendor.set(JvmVendorSpec.JETBRAINS)
    }
}

minecraft {
    if (mappings_channel == "parchment_previous") {
        mappings channel: 'parchment', version: "${previous_minecraft_version}-${mappings_version}"
    } else {
        mappings channel: "${mappings_channel}", version: "${mappings_version}"
    }

    accessTransformers.from(file('src/main/resources/META-INF/accesstransformer.cfg'))

    runs {
        client {
            setupRunConfig(it, true)

            //The below if statements are to add args to your gradle.properties file in user home
            // (DO NOT add them directly to the gradle.properties file for this project)
            // Setting the below properties allows use of your normal Minecraft account in the
            // dev environment including having your skin load. Each property also has a comment
            // explaining what information to set the value to/format it expects
            // One thing to note is because of the caching that goes on, after changing these
            // variables, you need to refresh the project and rerun genIntellijRuns/genEclipseRuns
            if (project.hasProperty('mc_uuid')) {
                //Your uuid without any dashes in the middle
                args '--uuid', project.getProperty('mc_uuid')
            }
            if (project.hasProperty('mc_username')) {
                //Your username/display name, this is the name that shows up in chat
                // Note: This is not your email, even if you have a Mojang account
                args '--username', project.getProperty('mc_username')
            }
            if (project.hasProperty('mc_accessToken')) {
                //Your access token, you can find it in your '.minecraft/launcher_accounts.json' file
                args '--accessToken', project.getProperty('mc_accessToken')
            }
        }
        server { setupRunConfig(it, true) }
        data {
            setupRunConfig(it, false)
            environment 'target', 'fmluserdevdata'

            args '--mod', 'projectextended', '--all', '--output', file('src/datagen/generated/'),
                    '--existing', file('src/main/resources/'), '--existing-mod', 'projecte'

            mods.named("projectextended").configure { source((SourceSet) sourceSets.datagen) }
        }
    }
}

def setupRunConfig(RunConfig runConfig, boolean supportsGameTests, String directory = "run") {
    runConfig.workingDirectory(file(directory))
    //This fixes Mixin application problems from other mods because their refMaps are SRG-based, but we're in a MCP env
    runConfig.property 'mixin.env.remapRefMap', 'true'
    runConfig.property 'mixin.env.refMapRemappingFile', "${projectDir}/build/createSrgToMcp/output.srg"
    if (supportsGameTests) {
        //Specify all our mods as domains to look for game tests
        runConfig.property 'forge.enabledGameTestNamespaces', 'projectextended'
    }

    if (project.hasProperty('forge_force_ansi')) {
        //Force ansi if declared as a gradle variable, as the auto detection doesn't detect IntelliJ properly
        // or eclipse's plugin that adds support for ansi escape in console
        runConfig.jvmArg("-Dterminal.ansi=${project.getProperty('forge_force_ansi')}")
    }

    runConfig.mods.register("projectextended").configure {
        source(sourceSets.main)
    }

    //if the selected toolchain is a JBR, enable DCEVM
    if(project.javaToolchains.launcherFor(java.toolchain).map{it.metadata.vendor }.getOrElse("").contains("JetBrains")) {
        runConfig.jvmArg("-XX:+AllowEnhancedClassRedefinition")
    }
}

void exclusiveRepo(RepositoryHandler handler, String url, String... groups) {
    exclusiveRepo(handler, url, filter -> {
        for (def group : groups) {
            filter.includeGroup(group)
        }
    })
}

//Note: This cannot be static so that fg.repository can be properly accessed
@SuppressWarnings('GrMethodMayBeStatic')
void exclusiveRepo(RepositoryHandler handler, String url, Consumer<InclusiveRepositoryContentDescriptor> filterSetup) {
    handler.exclusiveContent {
        it.forRepositories(handler.maven {
            setUrl(url)
        }, fg.repository)//Add FG's repo so we make sure we are able to then find the mapped deps
        it.filter { f -> filterSetup.accept(f) }
    }
}

repositories { RepositoryHandler handler ->
    exclusiveRepo(handler, 'https://maven.blamejared.com', filter -> {
        filter.includeGroupByRegex 'com\\.blamejared.*'
        filter.includeGroupByRegex 'net\\.darkhax.*'
        filter.includeGroup 'org.openzen.zencode'
        filter.includeGroup 'mezz.jei'
    })
    exclusiveRepo(handler, 'https://www.cursemaven.com', 'curse.maven')
    flatDir {
        dirs "libs"
    }
}

dependencies {
    minecraft "net.neoforged:forge:${minecraft_version}-${forge_version}"

    if (project.hasProperty('projecte_local_version')) {
        implementation fg.deobf("projecte:projecte:${projecte_local_version}:universal")
    } else {
        implementation fg.deobf("curse.maven:projecte-226410:${projecte_fileid}")
    }
    //Include JEI in the dev environment
    runtimeOnly fg.deobf("mezz.jei:jei-${minecraft_version}-forge:${jei_version}")

    runtimeOnly fg.deobf("net.darkhax.bookshelf:Bookshelf-Forge-${minecraft_version}:${bookshelf_version}")
    implementation fg.deobf("net.darkhax.gamestages:GameStages-Forge-${minecraft_version}:${gamestages_version}")
}

//Set the various variables/settings for the different process resources tasks
processResources {
    duplicatesStrategy(DuplicatesStrategy.FAIL)
    exclude('META-INF/mods.toml')
    configure { finalizedBy(replaceResources) }
    doLast {
        fileTree(dir: getOutputs().getFiles().getAsPath(), includes: jsonPatterns).each {
            File file -> file.setText(JsonOutput.toJson(new JsonSlurper().parse(file)))
        }
    }
}

//Make the various classes tasks depend on the corresponding replaceResources tasks in addition to the default processResources tasks they depend on
classes.configure { dependsOn(replaceResources) }

jar {
    duplicatesStrategy(DuplicatesStrategy.FAIL)
    manifest.attributes([
            "Specification-Title"     : "ProjectExtended",
            "Specification-Vendor"    : "pupnewfster",
            "Specification-Version"   : "${mod_version}",
            "Implementation-Title"    : "ProjectExtended",
            "Implementation-Version"  : "${mod_version}",
            "Implementation-Vendor"   : "pupnewfster",
            "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
            "Automatic-Module-Name"   : "projectextended"
    ])
    afterEvaluate { finalizedBy reobfJar }
}

reobf {
    jar { classpath.from(sourceSets.main.compileClasspath) }
}

tasks.withType(JavaCompile).configureEach({
    it.options.encoding = 'UTF-8'
    it.options.compilerArgs << "-Xmaxerrs" << "100000"
})