build.gradle

import net.minecraftforge.gradle.curseforge.CurseUploadTask
import org.apache.tools.ant.filters.ReplaceTokens

buildscript {
    repositories {
        mavenCentral()
        maven {
            name = "forge"
            url = "http://files.minecraftforge.net/maven"
        }
        maven {
            name = "sonatype"
            url = "https://oss.sonatype.org/content/repositories/snapshots/"
        }
    }
    dependencies {
        classpath 'net.minecraftforge.gradle:ForgeGradle:1.2-SNAPSHOT'
    }
}

apply plugin: 'scala'
apply plugin: 'forge'
apply plugin: 'curseforge'


group = "mrtjp"
archivesBaseName = "ProjectRed"

ext.configFile = file "build.properties"
configFile.withReader {
    // Load config.  It shall from now be referenced as simply config or project.config
    def prop = new Properties()
    prop.load(it)
    project.ext.config = new ConfigSlurper().parse prop
}

repositories {
    maven {
        name "chickenbones"
        url "http://chickenbones.net/maven/"
    }

    maven {
        name "mvnmrtjp"
        url "http://files.projectredwiki.com/maven"
    }

    maven {
        name "dvs1"
        url "http://dvs1.progwml6.com/files/maven/"
    }
//    ivy {
//        name 'ThermalExpansion'
//        artifactPattern "http://addons.cursecdn.com/files/${config.texpan.cf}/[module]-[revision].[ext]"
//    }
    ivy {
        name 'CoFHCore'
        artifactPattern "http://addons-origin.cursecdn.com/files/${config.cofh.cf}/[module]-[revision].[ext]"
    }
}

configurations {
    deployerJars
}

dependencies {
    deployerJars "org.apache.maven.wagon:wagon-ftp:2.2"

    compile "mrtjp:MrTJPCore:${config.mc.version}-${config.mrtjp.version}:dev"
    compile "mrtjp:ForgeRelocation:${config.mc.version}-${config.fr.version}:dev"
    compile "codechicken:CodeChickenLib:${config.mc.version}-${config.ccl.version}:dev"
    compile "codechicken:CodeChickenCore:${config.mc.version}-${config.ccc.version}:dev"
    compile "codechicken:ForgeMultipart:${config.mc.version}-${config.fmp.version}:dev"
    compile "codechicken:NotEnoughItems:${config.mc.version}-${config.nei.version}:dev"
    compile "tconstruct:TConstruct:${config.mc.version}-${config.tc.version}:deobf"
    compile group: 'cofh', name: 'CoFHCore', version: config.cofh.version, ext: 'jar'

    compile fileTree(dir: 'libs', include: '*.jar')
}

def build_number = project.hasProperty("manualbuildnum") ? project.manualbuildnum : (Integer.parseInt(System.getenv("BUILD_NUMBER") ?: "1")+51).toString()
version = "${project.config.mod.version}."+build_number
println "Starting build for $archivesBaseName $version for MC $config.mc.version-$config.forge.version"

minecraft {
    version = config.mc.version+"-"+config.forge.version
    if (file('../run').exists()) {
        runDir = "../run"
    }
    else {
        runDir = "run"
    }
}

sourceSets {
    main {
        def root = project.projectDir
        scala {
            srcDir new File(root, "src")
        }
        resources {
            srcDir new File(root, "resources")
        }
    }
}

task updateVersion(type: Copy) {
    // Replace tokens
    from(sourceSets.main.scala.srcDirs)
    into 'build/sources/scala'
    filter(ReplaceTokens, tokens: [
            'VERSION'      : config.mod.version,
            'BUILD_NUMBER' : build_number,
            'MC_VERSION'   : config.mc.version,
            'FORGE_VERSION': config.forge.version,
            'FMP_VERSION'  : config.fmp.version,
            'CCL_VERSION'  : config.ccl.version,
            'CCC_VERSION': config.ccc.version,
            'MRTJP_VERSION': config.mrtjp.version,
            'FR_VERSION': config.fr.version,
            'FRFMP_VERSION': config.frfmp.version
    ])
}

processResources {
    //redo task if any of these properties change
    inputs.property "version", project.version
    inputs.property "mc.version", config.mc.version

    // Replace properties in all files
    from(sourceSets.main.resources.srcDirs) {
        include '**.info'
        filter(ReplaceTokens, tokens: [
                'VERSION'      : config.mod.version,
                'BUILD_NUMBER' : build_number,
                'MC_VERSION'   : config.mc.version,
                'FORGE_VERSION': config.forge.version,
                'FMP_VERSION'  : config.fmp.version,
                'CCL_VERSION'  : config.ccl.version,
                'CCC_VERSION': config.ccc.version,
                'MRTJP_VERSION': config.mrtjp.version,
                'FR_VERSION': config.fr.version,
                'FRFMP_VERSION': config.frfmp.version
        ])
    }
    // Copy everything else
    from(sourceSets.main.resources.srcDirs) {
        include 'assets/**/*.*'
    }
}

compileScala.dependsOn updateVersion
ext.jarVer = "${project.minecraft.version}-${project.version}"
ext.jarFile = zipTree(jar.archivePath)
ext.baseExcludes = ["**/dan200/**", "**/coloredlightscore/**"]

task integrationJar(type: Jar, dependsOn: reobf) {
    from(project.ext.jarFile) {
        include "**/ProjectRedIntegration*.class"
        include "**/ProjectRedTransmission*.class"
        include "**/mrtjp/projectred/integration/**"
        include "**/mrtjp/projectred/transmission/**"

        include "**/assets/projectred/textures/blocks/integration/**"
        include "**/assets/projectred/textures/obj/integration/**"

        include "integration_mod.info"
        rename("integration_mod.info", 'mcmod.info')

        project.ext.baseExcludes.addAll(includes)
    }
    version = project.ext.jarVer
    classifier = 'Integration'
}

task fabricationJar(type: Jar, dependsOn: reobf) {
    from(project.ext.jarFile) {
        include "**/ProjectRedFabrication*.class"
        include "**/mrtjp/projectred/fabrication/**"

        include "**/assets/projectred/textures/blocks/fabrication/**"
        include "**/assets/projectred/textures/items/fabrication/**"
        include "**/assets/projectred/textures/obj/fabrication/**"

        include "fabrication_mod.info"
        rename("fabrication_mod.info", 'mcmod.info')

        project.ext.baseExcludes.addAll(includes)
    }
    version = project.ext.jarVer
    classifier = 'Fabrication'
}

task lightingJar(type: Jar, dependsOn: reobf) {
    from(project.ext.jarFile) {
        include "**/ProjectRedIllumination*.class"
        include "**/mrtjp/projectred/illumination/**"

        include "**/assets/projectred/textures/blocks/lighting/**"
        include "**/assets/projectred/textures/obj/lighting/**"

        include "lighting_mod.info"
        rename("lighting_mod.info", 'mcmod.info')

        project.ext.baseExcludes.addAll(includes)
    }
    version = project.ext.jarVer
    classifier = 'Lighting'
}

task mechanicalJar(type: Jar, dependsOn: reobf) {
    from(project.ext.jarFile) {
        include "**/ProjectRedExpansion*.class"
        include "**/mrtjp/projectred/expansion/**"
        include "**/ProjectRedTransportation*.class"
        include "**/mrtjp/projectred/transportation/**"

        include "**/assets/projectred/textures/blocks/mechanical/**"
        include "**/assets/projectred/textures/items/mechanical/**"
        include "**/assets/projectred/textures/obj/mechanical/**"

        include "mechanical_mod.info"
        rename("mechanical_mod.info", 'mcmod.info')

        include("mechanical_dependancies.info")
        rename("mechanical_dependancies.info", "dependancies.info")

        project.ext.baseExcludes.addAll(includes)
    }
    version = project.ext.jarVer
    classifier = 'Mechanical'
}

task worldJar(type: Jar, dependsOn: reobf) {
    from(project.ext.jarFile) {
        include "**/ProjectRedExploration*.class"
        include "**/mrtjp/projectred/exploration/**"

        include "**/assets/projectred/textures/blocks/world/**"
        include "**/assets/projectred/textures/items/world/**"

        include "world_mod.info"
        rename("world_mod.info", 'mcmod.info')

        project.ext.baseExcludes.addAll(includes)
    }
    version = project.ext.jarVer
    classifier = 'World'
}

task compatJar(type: Jar, dependsOn: reobf) {
    from(project.ext.jarFile) {
        include "**/ProjectRedCompatibility*.class"
        include "**/mrtjp/projectred/compatibility/**"

        include "**/powercrystals/**"

        include "**/assets/asm/**"
        include "**/assets/projectred/textures/blocks/compat/**"

        include "compat_mod.info"
        rename("compat_mod.info", 'mcmod.info')

        project.ext.baseExcludes.addAll(includes)
    }
    version = project.ext.jarVer
    classifier = 'Compat'
}

task baseJar(type: Jar, dependsOn: reobf) {
    from(project.ext.jarFile) {
        exclude project.ext.baseExcludes

        rename("base_mod.info", 'mcmod.info')
        rename("base_dependancies.info", "dependancies.info")
    }
    manifest {
        attributes 'FMLCorePlugin': 'codechicken.core.launch.DepLoader'
        attributes 'FMLCorePluginContainsFMLMod': 'true'
    }
    version = project.ext.jarVer
    classifier = 'Base'

}

// baseJar pulls all files not in any other jar. Therefore must run last
baseJar.mustRunAfter { tasks.findAll { task -> (task.name.endsWith('Jar') && !task.name.equals('baseJar')) } }

jar {
    manifest {
        attributes 'FMLCorePlugin': 'codechicken.core.launch.DepLoader'
        attributes 'FMLCorePluginContainsFMLMod': 'true'
    }
}

task sourceJar(type: Jar) {
    from sourceSets.main.allSource
    classifier = 'sources'
    version = "${project.minecraft.version}-${project.version}"
}

task deobfJar(type: Jar) {
    from sourceSets.main.output
    classifier = 'dev'
    version = "${project.minecraft.version}-${project.version}"
    manifest {
        attributes 'FMLCorePlugin': 'codechicken.core.launch.DepLoader'
        attributes 'FMLCorePluginContainsFMLMod': 'true'
    }
}

artifacts {
    archives integrationJar
    archives fabricationJar
    archives lightingJar
    archives mechanicalJar
    archives worldJar
    archives compatJar
    archives baseJar

    archives sourceJar
    archives deobfJar
}

uploadArchives {
    dependsOn 'reobf'
    repositories {
        if (project.hasProperty("mavenurl")) {
            mavenDeployer {
                configuration = configurations.deployerJars

                repository(url: project.mavenurl) {
                    authentication(userName: project.mavenusername, password: project.mavenpassword)
                }

                pom {
                    groupId = project.group
                    version = "${project.minecraft.version}-${project.version}"
                    artifactId = project.archivesBaseName
                    project {
                        name project.archivesBaseName
                        packaging 'jar'
                        description project.archivesBaseName
                        url 'https://github.com/MrTJP/'+project.archivesBaseName

                        scm {
                            url 'https://github.com/MrTJP/'+project.archivesBaseName
                            connection 'scm:git:git://github.com/MrTJP/'+project.archivesBaseName+'.git'
                            developerConnection 'scm:git:git@github.com:MrTJP/'+project.archivesBaseName+'.git'
                        }

                        issueManagement {
                            system 'github'
                            url 'https://github.com/MrTJP/'+project.archivesBaseName+'/issues'
                        }

                        licenses {
                            license {
                                name 'Restricted Public Software License (RPSL) v1.3.1'
                                url 'https://raw.githubusercontent.com/MrTJP/ProjectRed/master/LICENSE.md'
                                distribution 'repo'
                            }
                        }

                        developers {
                            developer {
                                id 'mrtjp'
                                name 'mrtjp'
                                roles { role 'developer' }
                            }
                        }
                    }
                }
            }
        }
    }
}

if (project.hasProperty('curseapi')) {
    curse {
        doLast {
            curseIntegration.execute()
            curseFabrication.execute()
            curseLighting.execute()
            curseMechanical.execute()
            curseWorld.execute()
            curseCompat.execute()
        }
        projectId = '228702'
        artifact = baseJar

        additionalArtifact deobfJar
        additionalArtifact sourceJar
    }

    task curseIntegration(dependsOn: 'curse', type: CurseUploadTask) {
        projectId = '229045'
        artifact = integrationJar
    }

    task curseFabrication(dependsOn: 'curse', type: CurseUploadTask) {
        projectId = '230111'
        artifact = fabricationJar
        relatedProject 'project-red-integration': 'requiredLibrary'
    }

    task curseLighting(dependsOn: 'curse', type: CurseUploadTask) {
        projectId = '229046'
        artifact = lightingJar
    }

    task curseMechanical(dependsOn: 'curse', type: CurseUploadTask) {
        projectId = '229048'
        artifact = mechanicalJar
        relatedProject 'project-red-integration': 'requiredLibrary'
        relatedProject 'forge-relocation': 'requiredLibrary'
        relatedProject 'forge-relocation-fmp-plugin': 'requiredLibrary'
    }

    task curseWorld(dependsOn: 'curse', type: CurseUploadTask) {
        projectId = '229049'
        artifact = worldJar
    }

    task curseCompat(dependsOn: 'curse', type: CurseUploadTask) {
        projectId = '229050'
        artifact = compatJar
    }

    configure([curse, curseIntegration, curseFabrication, curseLighting, curseMechanical, curseWorld, curseCompat]) {
        apiKey = project.curseapi
        releaseType = 'release'
        relatedProject 'mrtjpcore': 'requiredLibrary'
        relatedProject 'forge-multi-part': 'requiredLibrary'
        addGameVersion project.minecraft.version
    }

    configure([curseIntegration, curseFabrication, curseLighting, curseMechanical, curseWorld, curseCompat]) {
        relatedProject 'project-red-base': 'requiredLibrary'
    }
}