build.gradle

plugins {
    id 'net.minecraftforge.gradle' version '[6.0,6.2)'
    id("com.github.johnrengelman.shadow") version "8.1.1"
}

version = mod_version
group = mod_group_id

base {
    archivesName = mod_id
}

java.toolchain.languageVersion = JavaLanguageVersion.of(17)

minecraft {
    mappings channel: mapping_channel, version: mapping_version

    // When true, this property will have all Eclipse/IntelliJ IDEA run configurations run the "prepareX" task for the given run configuration before launching the game.
    // In most cases, it is not necessary to enable.
    // enableEclipsePrepareRuns = true
    // enableIdeaPrepareRuns = true

    // This property allows configuring Gradle's ProcessResources task(s) to run on IDE output locations before launching the game.
    // It is REQUIRED to be set to true for this template to function.
    // See https://docs.gradle.org/current/dsl/org.gradle.language.jvm.tasks.ProcessResources.html
    copyIdeResources = true

    // When true, this property will add the folder name of all declared run configurations to generated IDE run configurations.
    // The folder name can be set on a run configuration using the "folderName" property.
    // By default, the folder name of a run configuration is the name of the Gradle project containing it.
    // generateRunFolders = true

    // This property enables access transformers for use in development.
    // They will be applied to the Minecraft artifact.
    // The access transformer file can be anywhere in the project.
    // However, it must be at "META-INF/accesstransformer.cfg" in the final mod jar to be loaded by Forge.
    // This default location is a best practice to automatically put the file in the right place in the final jar.
    // See https://docs.minecraftforge.net/en/latest/advanced/accesstransformers/ for more information.
    // accessTransformer = file('src/main/resources/META-INF/accesstransformer.cfg')

    // Default run configurations.
    // These can be tweaked, removed, or duplicated as needed.
    runs {
        configureEach {
            workingDirectory project.file('run')

            property 'forge.logging.markers', 'REGISTRIES'

            property 'forge.logging.console.level', 'debug'

            mods {
                "${mod_id}" {
                    source sourceSets.main
                }
            }
        }

        client {
            property 'forge.enabledGameTestNamespaces', mod_id
        }

        server {
            property 'forge.enabledGameTestNamespaces', mod_id
            args '--nogui'
        }

        gameTestServer {
            property 'forge.enabledGameTestNamespaces', mod_id
        }

        data {
            workingDirectory project.file('run-data')

            args '--mod', mod_id, '--all', '--output', file('src/generated/resources/'), '--existing', file('src/main/resources/')
        }
    }
}

sourceSets.main.resources { srcDir 'src/generated/resources' }

repositories {
    mavenCentral()
    maven { url 'https://oss.sonatype.org/content/repositories/snapshots' }
    maven { url 'https://repo.lucko.me/' }
    maven { url = "https://repo.aikar.co/content/groups/aikar/" }
    maven { url = "https://jitpack.io" }
    maven {
        name = 'sponge'
        url = 'https://repo.spongepowered.org/maven'
    }
    ivy {
        setUrl('https://download.nodecdn.net/containers/reforged/universal/release')

        metadataSources {
            artifact()
        }
        patternLayout {
            artifact('[artifact].[ext]')
        }
    }
}


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

    implementation fg.deobf("pixelmon:Pixelmon-${minecraft_version}-${pixelmon_version}-universal:${pixelmon_version}")

    // Any other dependencies go here
    // To shade them do `shadow` rather than `implementation`
}

tasks.withType(JavaCompile) {
    options.encoding = 'UTF-8'
}

tasks.named('processResources', ProcessResources).configure {
    var replaceProperties = [
            minecraft_version: minecraft_version, minecraft_version_range: minecraft_version_range,
            forge_version: forge_version, forge_version_range: forge_version_range,
            loader_version_range: loader_version_range,
            mod_id: mod_id, mod_name: mod_name, mod_license: mod_license, mod_version: mod_version,
            mod_authors: mod_authors, mod_description: mod_description,
            pixelmon_version: pixelmon_version
    ]
    inputs.properties replaceProperties

    filesMatching(['META-INF/mods.toml', 'pack.mcmeta']) {
        expand replaceProperties + [project: project]
    }
}

shadowJar {
    configurations = [project.configurations.shadow]
    setArchiveBaseName(rootProject.name + '-Forge')

    // Where you relocate any shaded dependencies

    exclude 'net.minecraft'
    exclude "**/module-info.class"
}

tasks.named('jar', Jar).configure {
    manifest {
        attributes([
                'Specification-Title'     : mod_id,
                'Specification-Vendor'    : mod_authors,
                'Specification-Version'   : '1', // We are version 1 of ourselves
                'Implementation-Title'    : project.name,
                'Implementation-Version'  : project.jar.archiveVersion,
                'Implementation-Vendor'   : mod_authors,
                'Implementation-Timestamp': new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
        ])
    }
}

task versionedRelease(type: Copy) { // This creates a jar with a version number appended to the end in the `release` directory (for ease of use)
    delete fileTree('release/') {
        include '**/*.jar'
    }
    group "build"
    from('./build/libs/' + rootProject.name + '-Forge.jar')
    into('release/')
    include '*.jar'
    rename { String filename ->
        filename.replace(".jar", "-${project.version}.jar")
    }
}

javadoc {
    options {
        links 'https://reforged.gg/docs/1201/'
    }
}

jar.finalizedBy('shadowJar')
shadowJar.finalizedBy('reobfJar')
build.finalizedBy('versionedRelease')