build.gradle

buildscript {
    repositories {
        jcenter()
        maven {
            name = "forge"
            url = "http://files.minecraftforge.net/maven"
        }
    }
    dependencies {
        classpath 'net.minecraftforge.gradle:ForgeGradle:2.3-SNAPSHOT'
    }
}


apply plugin: 'net.minecraftforge.gradle.forge'
apply plugin: 'scala'
apply plugin: 'maven'
//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/"
    }
}

configurations {
    deployerJars
}

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

    compile "mrtjp:MrTJPCore:${config.mc_version}-${config.tjpcore_version}:deobf"
    compile "codechicken:CodeChickenLib:${config.mc_version}-${config.ccl_version}:deobf"
    compile "codechicken:ForgeMultipart:${config.mc_version}-${config.fmp_version}:deobf"

    // compile against the JEI API
    deobfCompile "mezz.jei:jei_${config.mc_version}:${config.jei_version}:api"
    // at runtime, use the full JEI jar
    runtime "mezz.jei:jei_${config.mc_version}:${config.jei_version}"
}

def build_number = project.hasProperty("manualbuildnum") ? project.manualbuildnum : (Integer.parseInt(System.getenv("BUILD_NUMBER") ?: "1")).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
    mappings = config.mappings
    runDir = "run"
    makeObfSourceJar = false
    useDepAts = true
}

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

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'
        expand  'mod_version': version, 'mc_version': config.mc_version,
                'forge_version': config.forge_version,
                'tjcore_version': config.tjpcore_version.replace(".+", ""),
                'ccl_version': config.ccl_version.replace(".+", ""),
                'fmp_version': config.fmp_version.replace(".+", "")
    }
    // Copy everything else
    from(sourceSets.main.resources.srcDirs) {
        include 'assets/**/*.*'
    }
}

jar {//Because groovy we need to define these first other wise our zipTree call will fail.
    classifier = 'all'
    version = "${config.mc_version}-${project.version}"
}

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

task deobfJar(type: Jar) {
    from sourceSets.main.output
    classifier = 'deobf'
    version = "${config.mc_version}-${project.version}"
}

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

task integrationJar(type: Jar, dependsOn: reobfJar) {
    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 "**/assets/projectred-integration/recipes/**"
        include "**/assets/projectred-transmission/recipes/**"

        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: reobfJar) {
    from(project.ext.jarFile) {
        include "**/ProjectRedFabrication*.class"
        include "**/mrtjp/projectred/fabrication/**"

        include "**/assets/projectred/cc_blockstates/fabrication/**"

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

        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: reobfJar) {
    from(project.ext.jarFile) {
        include "**/ProjectRedIllumination*.class"
        include "**/mrtjp/projectred/illumination/**"

        include "**/assets/projectred/textures/blocks/lighting/**"
        include "**/assets/projectred/textures/obj/lighting/**"
        include "**/assets/projectred-illumination/recipes/**"

        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: reobfJar) {
    from(project.ext.jarFile) {
        include "**/ProjectRedExpansion*.class"
        include "**/mrtjp/projectred/expansion/**"

        include "**/ProjectRedTransportation*.class"
        include "**/mrtjp/projectred/transportation/**"

        include "**/ProjectRedRelocation*.class"
        include "**/mrtjp/projectred/relocation/**"

        include "**/assets/projectred/cc_blockstates/mechanical/**"

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

        include "**/assets/projectred-expansion/recipes/**"
        include "**/assets/projectred-transportation/recipes/**"
        include "**/assets/projectred-relocation/recipes/**"

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

        include "**/projectred-relocation_at.cfg"

        manifest.attributes('FMLAT': 'projectred-relocation_at.cfg')

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

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

        include "**/assets/projectred/cc_blockstates/world/**"

        include "**/assets/projectred/textures/blocks/world/**"
        include "**/assets/projectred/textures/items/world/**"
        include "**/assets/projectred-exploration/recipes/**"

        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: reobfJar) {
    from(project.ext.jarFile) {
        include "**/ProjectRedCompatibility*.class"
        include "**/mrtjp/projectred/compatibility/**"

        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: reobfJar) {
    from(project.ext.jarFile) {
        exclude project.ext.baseExcludes

        rename("base_mod.info", 'mcmod.info')
    }
    version = project.ext.jarVer
    classifier = 'Base'
}

// Dont include empty folders in jars
tasks.withType(Jar) {
    includeEmptyDirs = false
}

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

// Enable experimental features for scala compiler
tasks.withType(ScalaCompile) {
    scalaCompileOptions.additionalParameters = ["-Xexperimental"]
    scalaCompileOptions.setDeprecation false
}

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

    archives deobfJar
    archives srcJar
}

uploadArchives {
    repositories {
        mavenDeployer {
            if (project.hasProperty("local_maven")) {
                repository(url: "file://${local_maven}")
                pom {
                    groupId = project.group
                    version = "${config.mc_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'
    }
}*/