build.gradle

plugins {
    id 'java'

    // https://github.com/architectury/architectury-loom
    id 'dev.architectury.loom' version '1.7-SNAPSHOT' apply false

    // https://docs.papermc.io/paper/dev/userdev
    id 'io.papermc.paperweight.userdev' version '1.7.4' apply false
    // https://github.com/jpenilla/run-task
    id 'xyz.jpenilla.run-paper' version '2.3.1' apply false

    // https://github.com/Fallen-Breath/yamlang
    id 'me.fallenbreath.yamlang' version '1.4.0'
}

repositories {
    maven {
        url 'https://jitpack.io'
    }
    maven {
        url 'https://www.cursemaven.com'
    }
    maven {
        url = "https://api.modrinth.com/maven"
    }
    maven {
        url 'https://maven.neoforged.net/releases'
    }
    maven {
        name = 'papermc'
        url = 'https://repo.papermc.io/repository/maven-public/'
    }
}

def use_architectury_loom = project.platform in ['fabric', 'quilt', 'forge', 'neoforge']
def use_paperweight = project.platform in ['paper']

if (use_architectury_loom) {
    apply plugin: 'dev.architectury.loom'
}
if (use_paperweight) {
    apply plugin: 'io.papermc.paperweight.userdev'
    apply plugin: 'xyz.jpenilla.run-paper'
}

static Number convertVersion(String version) {
    def parts = version.split('\\.')*.toInteger()
    def major = parts[0] * 10000
    def minor = parts[1] * 100
    def patch = parts.size() > 2 ? parts[2] : 0
    return major + minor + patch
}

def mcVersion = convertVersion(project.minecraft_version)

String MOD_ICON_PATH = 'assets/kyoyu/icon.png'
String LANG_DIR = 'assets/kyoyu/lang'
JavaVersion JAVA_COMPATIBILITY
if (mcVersion >= 12005) {
    JAVA_COMPATIBILITY = JavaVersion.VERSION_21
} else if (mcVersion >= 11800) {
    JAVA_COMPATIBILITY = JavaVersion.VERSION_17
} else if (mcVersion >= 11700) {
    JAVA_COMPATIBILITY = JavaVersion.VERSION_16
} else {
    JAVA_COMPATIBILITY = JavaVersion.VERSION_1_8
}
JavaVersion MIXIN_COMPATIBILITY_LEVEL = JAVA_COMPATIBILITY


String modVersionSuffix = ''
String artifactVersion = project.mod_version
String artifactVersionSuffix = ''
// detect github action environment variables
// https://docs.github.com/en/actions/learn-github-actions/environment-variables#default-environment-variables
if (System.getenv("BUILD_RELEASE") != "true") {
    String buildNumber = System.getenv("BUILD_ID")
    modVersionSuffix += buildNumber != null ? ('+build.' + buildNumber) : '-SNAPSHOT'
    artifactVersionSuffix = '-SNAPSHOT'  // A non-release artifact is always a SNAPSHOT artifact
}
String fullModVersion = project.mod_version + modVersionSuffix
String fullProjectVersion = "v${artifactVersion}-mc${project.minecraft_version}-${project.platform}${modVersionSuffix}"
String fullArtifactVersion = "${artifactVersion}-mc${project.minecraft_version}-${project.platform}${artifactVersionSuffix}"
// Example version values:
//   artifactVersion         1.0.3                             (the base mod version)
//   modVersionSuffix        +build.88                         (use github action build number if possible)
//   artifactVersionSuffix   -SNAPSHOT
//   fullModVersion          1.0.3+build.88                    (the actual mod version to use in the mod)
//   fullProjectVersion      v1.0.3-mc1.15.2-fabric+build.88   (in build output jar name)
//   fullArtifactVersion     1.0.3-mc1.15.2-fabric-SNAPSHOT    (maven artifact version)



version = fullProjectVersion
group = project.maven_group
base { archivesName.set("${project.mod_name}") }

stonecutter.const('FABRIC', project.platform == 'fabric')
stonecutter.const('QUILT', project.platform == 'quilt')
stonecutter.const('FORGE', project.platform == 'forge')
stonecutter.const('NEOFORGE', project.platform == 'neoforge')
stonecutter.const('PAPER', project.platform == 'paper')
stonecutter.const('client', project.hasProperty('litematica_version') && project.hasProperty('malilib_version'))
stonecutter.swap("mod_version", "\"${fullArtifactVersion}\";")

if (use_architectury_loom) {
    configurations {
        modRuntimeOnly.exclude group: 'net.fabricmc', module: 'fabric-loader'
    }
}

dependencies {
    // loom
    if (use_architectury_loom) {
        minecraft "com.mojang:minecraft:${project.minecraft_version}"
        mappings loom.officialMojangMappings()
//        mappings loom.layered {
//            mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
//
//            // https://github.com/architectury/architectury-loom/issues/214
//            if (project.platform == 'neoforge' && project.hasProperty('yarn_mappings_patch')) {
//                it.mappings("dev.architectury:yarn-mappings-patch-neoforge:${project.yarn_mappings_patch}")
//            }
//        }
    }
    if (use_paperweight) {
        paperweight.paperDevBundle("${project.minecraft_version}-R0.1-SNAPSHOT")
    }

    if (project.platform == 'fabric') {
        modImplementation "net.fabricmc:fabric-loader:${project.fabric_loader_version}"
    }
    if (project.platform == 'forge') {
        forge "net.minecraftforge:forge:${project.minecraft_version}-${project.forge_version}"
        compileOnly "org.spongepowered:mixin:0.8.5"
    }
    if (project.platform == 'neoforge') {
        neoForge "net.neoforged:neoforge:${project.neoforge_version}"
    }
    if (project.platform == 'paper') {
        compileOnly "io.papermc.paper:paper-api:${project.minecraft_version}-R0.1-SNAPSHOT"
    }
    if (project.hasProperty('litematica_version')) {
        modImplementation "maven.modrinth:litematica:${project.litematica_version}"
    }
    if (project.hasProperty('malilib_version')) {
        modImplementation "maven.modrinth:malilib:${project.malilib_version}"
        if (project.platform == 'fabric') {
            modImplementation(fabricApi.module("fabric-networking-api-v1", project.fabric_api_version))
            modImplementation(fabricApi.module("fabric-resource-loader-v0", project.fabric_api_version))
        }
    }

    implementation("com.google.code.gson:gson:${project.gson_version}")
}

if (use_architectury_loom) {
    loom {
        def commonVmArgs = ['-Dmixin.debug.export=true', '-Dmixin.debug.countInjections=true']
        runConfigs.configureEach {
            // to make sure it generates all "Minecraft Client (:subproject_name)" applications
            ideConfigGenerated = true
            vmArgs commonVmArgs
        }

        if (project.platform == 'forge') {
            forge {
                mixinConfigs = ['kyoyu.mixins.json', 'kyoyu.client.mixins.json']
            }
        }
    }
    remapJar {
        remapperIsolation = true
    }
}

processResources {
    outputs.upToDateWhen { false }

    inputs.property "id", project.mod_id
    inputs.property "name", project.mod_name
    inputs.property "version", fullModVersion
    inputs.property "minecraft_dependency", project.minecraft_dependency

    def good_files = [] as Set
    def all_files = [] as Set
    [
            'fabric':   ['kyoyu.mixins.json', 'kyoyu.client.mixins.json', 'fabric.mod.json'],
            'forge':    ['kyoyu.mixins.json', 'kyoyu.client.mixins.json', 'META-INF', 'META-INF/mods.toml', 'pack.mcmeta'],
            'neoforge': ['kyoyu.mixins.json', 'kyoyu.client.mixins.json', 'META-INF', 'META-INF/neoforge.mods.toml', 'pack.mcmeta'],
            'paper':    ['plugin.yml'],
    ].forEach { brand, paths ->
        all_files.addAll(paths)
        if (brand == project.platform) {
            good_files.addAll(paths)
        }
    }
    all_files.forEach { it2 ->
        def path = it2 as String
        if (good_files.contains(path)) {
            filesMatching(path) {
                def valueMap = [
                        "id": project.mod_id,
                        "name": project.mod_name,
                        "version": fullModVersion,
                        "minecraft_dependency": project.minecraft_dependency,

                        "description": project.mod_description,
                        "authors": project.mod_authors,
                        "homepage": project.mod_homepage,
                        "sources": project.mod_sources,
                        "issue": project.mod_issue,
                        "java_compatibility_level": "JAVA_${MIXIN_COMPATIBILITY_LEVEL.ordinal() + 1}",
                ]
                expand valueMap
            }
        } else {
            exclude path
        }
    }

    if (project.platform in ['forge', 'neoforge']) {
        // forge requires the mod icon file to be at the resource root
        filesMatching(MOD_ICON_PATH) { f -> f.path = new File(f.path).getName() }
    }
}

// https://github.com/Fallen-Breath/yamlang
yamlang {
    targetSourceSets = [sourceSets.main]
    inputDir = LANG_DIR
}

tasks.withType(JavaCompile).configureEach {
    options.encoding = "UTF-8"
    options.compilerArgs << "-Xlint:deprecation" << "-Xlint:unchecked"
    if (JAVA_COMPATIBILITY <= JavaVersion.VERSION_1_8) {
        // suppressed "source/target value 8 is obsolete and will be removed in a future release"
        options.compilerArgs << '-Xlint:-options'
    }
}

java {
    sourceCompatibility = JAVA_COMPATIBILITY
    targetCompatibility = JAVA_COMPATIBILITY

    // Configure the java toolchain. This allows gradle to auto-provision JDK 21 on systems that only have JDK 11 installed for example.
    toolchain.languageVersion = JavaLanguageVersion.of(JAVA_COMPATIBILITY.ordinal() + 1)

    // Loom will automatically attach sourcesJar to a RemapSourcesJar task and to the "build" task
    // if it is present.
    // If you remove this line, sources will not be generated.
    withSourcesJar()
}

stonecutter {
    java {
        withSourcesJar()
        sourceCompatibility = JAVA_COMPATIBILITY
        targetCompatibility = JAVA_COMPATIBILITY
    }
}

jar {
    from(rootProject.file('LICENSE')) {
        rename { "${it}_${project.archives_base_name}" }
    }
}

if (use_paperweight) {
    tasks.assemble {
        dependsOn(tasks.reobfJar)
    }
    tasks {
        runServer {
            dependsOn(tasks.assemble)
            minecraftVersion(project.minecraft_version)
        }
        reobfJar {
            // This is an example of how you might change the output location for reobfJar. It's recommended not to do this
            // for a variety of reasons, however it's asked frequently enough that an example of how to do it is included here.
            outputJar = layout.buildDirectory.file("libs/${project.mod_name}-${fullProjectVersion}.jar")
        }
    }
}