build.gradle

buildscript {
    repositories {
        mavenLocal()
        jcenter()
        maven { url = "https://maven.minecraftforge.net/" }
        maven { url = "https://repo.spongepowered.org/maven" }
    }
    dependencies {
        classpath 'net.minecraftforge.gradle:ForgeGradle:5.1.+'
        classpath 'org.spongepowered:mixingradle:0.7-SNAPSHOT'
    }
}

plugins {
    id 'java'
}

apply plugin: 'net.minecraftforge.gradle'
apply plugin: 'org.spongepowered.mixin'
apply plugin: 'eclipse'

group = 'net.foxmcloud.realisticsleep'
archivesBaseName = 'RealisticSleep'

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

sourceSets.main.resources.srcDirs += "src/generated/resources"

file('build.properties').withReader {
    def prop = new Properties()
    prop.load(it)
    project.ext.config = new ConfigSlurper().parse prop
}

config.mod_version = "${config.mod_version}.${config.build_number}"
version = "${config.mc_version}-${config.mod_version}"
config.forge_version = "${config.forge_major_version}.${config.forge_minor_version}"
println "Starting build of ${archivesBaseName}, Version: ${config.mod_version}"
println "Using Forge: ${config.forge_version}, for Minecraft: ${config.mc_version}, with official mappings"

minecraft {
    mappings channel: 'official', version: config.mc_version
    accessTransformer = file("src/main/resources/META-INF/accesstransformer.cfg")
    runs {
        client {
            workingDirectory file('run')
            mods { realisticsleep { source sourceSets.main } }
        }
        server {
            workingDirectory file('run')
            mods { realisticsleep { source sourceSets.main } }
        }
        data {
            workingDirectory file('run')
            args '--mod', 'realisticsleep', '--all', '--output', file("src/generated/resources")
            mods { realisticsleep { source sourceSets.main } }
        }
    }
}

repositories {
    mavenLocal()
    maven { url = "https://maven.covers1624.net/" }
}

dependencies {
    minecraft "net.minecraftforge:forge:${config.mc_version}-${config.forge_version}"
    implementation fg.deobf("codechicken:CodeChickenLib:${config.mc_version}-${config.ccl_version}:universal")
}

processResources { task ->
    duplicatesStrategy = DuplicatesStrategy.INCLUDE
    from(sourceSets.main.resources.srcDirs) { spec ->
        spec.include 'META-INF/mods.toml'
        task.doFirst {
            spec.expand 'version': config.mod_version,
                'mc_version': config.mc_version,
                'forge_major_version': config.forge_major_version,
                'ccl_version': config.ccl_version
        }
    }
}

jar {
    finalizedBy 'reobfJar'
    classifier = 'universal'
    from file("LICENSE")
    manifest {
        attributes 'Specification-Title': archivesBaseName
        attributes 'Specification-Vendor': 'FoxMcloud5655'
        attributes 'Specification-Version': "1"
        attributes 'Implementation-Title': archivesBaseName
        attributes 'Implementation-Vendor': 'FoxMcloud5655'
        attributes 'Implementation-Version': version
        attributes 'Implementation-Timestamp': new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
        //attributes 'MixinConfigs': 'mixins.realisticsleep.json'
    }
}

task srcJar(type: Jar) {
    build.dependsOn it
    from sourceSets.main.allSource
    classifier = 'sources'
    from file("LICENSE")
}

/**
 * Polls the 'compile' configuration for a dependency with the given module name
 * and resolves, and returns its version. E.g: '1.2.+' will resolve to '1.2.3.4'
 *
 * @param module The module to search for.
 * @param chop If the string should be chopped on the last '-' in its string.
 * @param configuration The name of the configuration to search.
 * @param errorMissing If an error should be thrown if it can't be found.
 * @return The version string, '0' if 'errorMissing' is false and nothing was found.
 */
def resolve(module, chop = true, configuration = 'compile', errorMissing = true) {
    //Copy and lenient resolve the configuration, Forge cant be resolved at this time so lenient is required.
    def filtered = configurations.getByName(configuration).copy().incoming.artifactView({ it.lenient = true }).artifacts
            .findAll { it.id.componentIdentifier.module == module }
            .collect { it.id.componentIdentifier.version }
    if (filtered.size() > 1) {
        println "WARNING: Found ${filtered.size()} Dependencies with ModuleName '${module}' in configuration '${configuration.name}'"
    }
    if (errorMissing && filtered.isEmpty()) {
        throw new RuntimeException("Failed resolve dependency version for '${module}'")
    }
    if (filtered.isEmpty()) return "0"
    def version = filtered.first() as String
    if (chop) {
        def idx = version.lastIndexOf('-')
        return version.substring(idx + 1)
    }
    return version
}