build.gradle

buildscript {
    ext.kotlin_version = project.kotlin_version
    repositories {
        mavenCentral()
        maven { url = "http://files.minecraftforge.net/maven" }
        maven { url = "https://repo.maven.apache.org/maven2" }
        maven { url = "https://plugins.gradle.org/m2/" }
        maven { url = "https://oss.sonatype.org/content/repositories/snapshots/" }
    }
    dependencies {
        classpath 'net.minecraftforge.gradle:ForgeGradle:2.3-SNAPSHOT'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${project.kotlin_version}"
        classpath "org.jetbrains.dokka:dokka-gradle-plugin:${project.dokka_version}"
    }
}
plugins {
    id 'com.matthewprenger.cursegradle' version '1.4.0'
}
apply plugin: 'kotlin'
apply plugin: "net.minecraftforge.gradle.forge"
apply plugin: 'com.matthewprenger.cursegradle'
apply plugin: "maven-publish"
apply plugin: "maven"
apply plugin: 'org.jetbrains.dokka'

archivesBaseName = project.mod_name.replace(' ', '-').toLowerCase()
group = "${project.group_name}"

// version = "${project.minecraft_version}-${project.mod_version}"
version = "${project.bc_version}-${project.mod_version}"
if (project.hasProperty('mod_suffix')) {
    version += "-${project.mod_suffix}"
}

compileJava { sourceCompatibility = targetCompatibility = "1.8" }
compileKotlin { kotlinOptions { jvmTarget = "1.8" } }

minecraft {
    version = "${project.minecraft_version}-${project.forge_version}"
    mappings = "${project.mcp_version}"
    runDir = "run"

    replace '@MOD-ID@', project.mod_id
    replace '@MOD-NAME@', project.mod_name
    replace '@MOD-VERSION@', project.mod_version
    replace '@MOD-MC-VERSION@', project.minecraft_version
    replace '@FORGELIN-VERSION@', project.forgelin_version
    replace '@FORGE-VERSION@', project.forge_version
    replace '@BC-VERSION@', project.bc_version
    replace '@JEI-VERSION@', project.jei_version
    replace '@FINGERPRINT@', project.findProperty('signSHA1')

    replaceIn 'constants.kt'

    if (project.hasProperty('mc_username')) {
        clientRunArgs += ['--username', "${project.mc_username}"]
        if (project.hasProperty('mc_password')) {
            clientRunArgs += ['--password=', "${project.mc_password}"]
        }
    }
    if (project.hasProperty('mc_uuid')) {
        clientRunArgs += ['--uuid', "${project.mc_uuid}"]
    }

    // disable server gui
    serverRunArgs += "nogui"

    // skip the screen to confirm that you want to load a world with missing registry entries
    serverJvmArgs += "-Dfml.doNotBackup=true"
    clientJvmArgs += "-Dfml.doNotBackup=true"

    // skip having to confirm on server
    serverJvmArgs += "-Dfml.queryResult=confirm"

    // skip jansi warnings in the log
    serverJvmArgs += "-Dlog4j.skipJansi=true"
    clientJvmArgs += "-Dlog4j.skipJansi=true"

    if (project.hasProperty('client_args')) {
        clientJvmArgs += "${project.client_args}"
    }
    if (project.hasProperty('server_args')) {
        serverJvmArgs += "${project.server_args}"
    }
}

import groovy.json.JsonSlurper

class Secrets {
    def data = null

    def getProperty(String key) {
        return data ? data[key] : ''
    }
}

def secretFile
if (System.getenv().SECRET_FILE) {
    secretFile = file System.getenv().SECRET_FILE
} else {
    secretFile = file 'secret.json'
}

project.ext.secret = new Secrets()
if (secretFile.exists()) {
    secretFile.withReader {
        project.ext.secret.data = new JsonSlurper().parse it
    }
}

// // Mad hacks to make source replacements work for Kotlin
// // "stolen" from: https://github.com/PaleoCrafter/VanillaImmersion/blob/ee82ecafb76659cf7d7822a722c8f63f43f41d01/build.gradle#L119-L136
// import net.minecraftforge.gradle.user.TaskSourceCopy
// for (set in sourceSets) {
//     def taskName = "source${set.name.capitalize()}Kotlin"
//     def dir = new File(project.getBuildDir(), "sources/${set.name}/kotlin")
//     task(taskName, type: TaskSourceCopy) {
//         source = set.getKotlin()
//         output = dir
//     }
//     def compileTask = tasks[set.getCompileTaskName("kotlin")]
//     compileTask.source = dir
//     compileTask.dependsOn taskName
//     def dirPath = dir.toPath()
//     compileTask.include {
//         return it.file.toPath().startsWith(dirPath)
//     }
// }
// end of "stolen" part :)

// configurations {
//     compile.extendsFrom exportedCompile
//     deployerJars

//     all { resolutionStrategy.cacheChangingModulesFor 0, 'seconds' }
// }

repositories {
    mavenCentral()
    mavenLocal()
    jcenter()
    maven { name='mmd'; url='https://maven.mcmoddev.com' }
    maven { name='forgelin'; url='http://maven.shadowfacts.net/' }

    maven { name='jei'; url="http://dvs1.progwml6.com/files/maven" }

    maven { name='build craft'; url='https://www.mod-buildcraft.com/maven' }
}

dependencies {
    compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:${project.kotlin_version}"
    compile "net.shadowfacts:Forgelin:${project.forgelin_version}+"

    deobfProvided "mezz.jei:jei_${project.minecraft_version}:${project.jei_version}+:api"
    runtime "mezz.jei:jei_${project.minecraft_version}:${project.jei_version}+"

    compileOnly "com.mod-buildcraft:buildcraft-api:${project.bc_version}"
    compileOnly "com.mod-buildcraft:buildcraft-lib:${project.bc_version}"
    runtime "com.mod-buildcraft:buildcraft-all:${project.bc_version}"
}

processResources {
    inputs.property "version", project.version
    inputs.property "mcversion", project.minecraft.version
    inputs.property "modid", project.mod_id
    inputs.property "modname", project.mod_name

    from(sourceSets.main.resources.srcDirs) {
        include '**/*.info'
        include '**/*.properties'

        // replace version and mcversion
        expand 'version':project.version, 'mcversion':project.minecraft.version, 'modid': project.mod_id, 'modname': project.mod_name
    }

    from(sourceSets.main.resources.srcDirs) {
        exclude '**/*.info'
        exclude '**/*.properties'
    }
}

jar {
    from sourceSets.api.output
    from sourceSets.main.output
}

task sourcesJar(type: Jar) {
    from sourceSets.api.allSource
    from sourceSets.main.allSource
    classifier = 'sources'
}

task deobfJar(type: Jar) {
    from sourceSets.api.output
    from sourceSets.main.output
    classifier = 'deobf'
}

task apiJar(type: Jar) {
    from sourceSets.api.output
    classifier = 'api'
}

task dokkaJavadoc(type: org.jetbrains.dokka.gradle.DokkaTask) {
    outputFormat = "javadoc"
    kotlinTasks {
        [':compileApiKotlin']
    }
    outputDirectory = "$buildDir/dokkaJavadoc"
}

task signJar(type: SignJar, dependsOn: reobfJar) {
    // Skips if the keyStore property is missing.
    onlyIf {
        project.hasProperty('keyStore')
    }

    // findProperty allows us to reference the property without it existing.
    // Using project.propName would cause the script to fail validation if
    // the property did not exist.
    keyStore = project.findProperty('keyStore')
    alias = project.findProperty('keyStoreAlias')
    storePass = project.findProperty('keyStorePass')
    keyPass = project.findProperty('keyStoreKeyPass')
    inputFile = jar.archivePath
    outputFile = jar.archivePath
}

build.dependsOn signJar
tasks.publish.dependsOn build
tasks.curseforge.dependsOn publish

task javadocJar(type: Jar, dependsOn: dokkaJavadoc) {
    classifier = 'javadoc'
    from dokkaJavadoc.outputDirectory
}

artifacts {
    archives apiJar, sourceJar, deobfJar, javadocJar
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            groupId project.group
            artifactId project.archivesBaseName
            def versionForMaven = "$project.bc_version-$project.mod_version"
            if (System.getenv().BUILD_NUMBER) {
                versionForMaven += '.' + System.getenv().BUILD_NUMBER
            }
            version versionForMaven
            from components.java
            artifact sourceJar {
                classifier 'sources'
            }
            artifact deobfJar {
                classifier 'deobf'
            }
            artifact javadocJar {
                classifier 'javadoc'
            }
            artifact apiJar {
                classifier 'api'
            }
        }
    }
    repositories {
        maven {
            credentials {
                username secret.username
                password secret.password
            }
            url secret.url
        }
    }
}

curseforge {
    if (project.hasProperty('cf_project_id') && project.hasProperty('cf_release_type') &&
            ((project.cf_release_type == "alpha") || (project.cf_release_type == "beta") || (project.cf_release_type == "release"))) {
        apiKey = secret.curseforgeAPIKey
        project {
            id = "$project.cf_project_id"
            changelog = file('current-changelog.txt')
            releaseType = project.cf_release_type
            addGameVersion(project.minecraft_version)
            def projectName = project.mod_name
            def displayVersion = "${project.bc_version} - ${project.mod_version}"
            if (System.getenv().BUILD_NUMBER) {
                displayVersion += '.' + System.getenv().BUILD_NUMBER
            }
            relations {
                requiredDependency 'shadowfacts-forgelin'
                requiredDependency 'buildcraft'
                // TODO: add relations ('requiredLibrary' || 'optionalLibrary')
            }
            mainArtifact(jar) {
                displayName = "$projectName : $displayVersion"
            }
            addArtifact(sourceJar) {
                displayName = "$projectName : $displayVersion : Sources"
            }
            addArtifact(deobfJar) {
                displayName = "$projectName : $displayVersion : Development"
            }
            addArtifact(apiJar) {
                displayName = "$projectName : $displayVersion : API"
            }
            addArtifact(javadocJar) {
                displayName = "$projectName : $displayVersion : API Javadoc"
            }
        }
    }
}