build.gradle

/*
 * Mortvana's Master build file
 * Based on Tinker's Construct's and Applied Energergistics' build files
 */

// Load ForgeGradle
// Apply the forge plugin - this adds all the magic for automatically obfuscating, deobfuscating, etc.
apply plugin: 'forge'

// Apply the CurseForge plugin - this automatically uploads to betas to CurseForge (Not yet used)
//apply plugin: 'curseforge'

apply from: 'gradle/scripts/dependencies.gradle'
apply from: 'gradle/scripts/artifacts.gradle'
apply from: 'gradle/scripts/miscellaneous.gradle'

// This sets us up for building a forge project - you need all of these
buildscript {
    repositories {
        mavenLocal()
        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'
    }
}

configurations.all {
    resolutionStrategy.cacheDynamicVersionsFor 7200, 'hours'
}

sourceCompatibility = JavaVersion.VERSION_1_6
targetCompatibility = JavaVersion.VERSION_1_6

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

// Determines the version from the many variables, uses a convoluted method, because I can't strings in Gradle...
/*if (use_MC_version) {
	if (use_appendix) {
		version = "${minecraft_version}-v${mod_version_version}.${mod_version_major}.${mod_version_minor}.${mod_version_revision}${mod_version_patch}-${mod_version_appendix} ${mod_version_build}-${mod_internal_build}"
	} else {
		version = "${minecraft_version}-v${mod_version_version}.${mod_version_major}.${mod_version_minor}.${mod_version_revision}${mod_version_patch}-${mod_internal_build}"
	}
} else {
	if (use_appendix) {
		version = "v${mod_version_version}.${mod_version_major}.${mod_version_minor}.${mod_version_revision}${mod_version_patch}-${mod_version_appendix} ${mod_version_build}-${mod_internal_build}"
	} else {
		version = "v${mod_version_version}.${mod_version_major}.${mod_version_minor}.${mod_version_revision}${mod_version_patch}-${mod_internal_build}"
	}
}*/
version = mod_version//"v${mod_version_major}.${mod_version_minor}.${mod_version_revision}${mod_version_patch}-${mod_version_appendix}"


// This is our group.
group = mod_group

// This is our actual project within the group.
archivesBaseName = mod_archiveBaseName

// Add Coremod Manifest and Classifier (if I wanted one)
jar {
    manifest {
		attributes 'FMLAT': 'FluxGear_at.cfg'
		//attributes 'FMLCorePlugin': 'tconstruct.preloader.TConstructLoaderContainer'
        //attributes 'FMLCorePluginContainsFMLMod': 'true'
    }
    //classifier = 'universal'
    // Specify which files are really included, can control which APIs should be included.
    /*include "fluxgear/**"
    include "assets/**"
    include "mcmod.info"
    include "pack.mcmeta"*/
}

// Setup the forge minecraft plugin data.
minecraft {
    version = minecraft_version + "-" + forge_version
    //mappings = 'stable_12' //This seems to break stuff
    //if  (file('../run').exists) { runDir = "../run/" } else {
    runDir = "run"
    //}
    // Replace stuff
    //replace '${version}', mod_version
    replace "@VERSION@", "v${mod_version_version}.${mod_version_major}.${mod_version_minor}.${mod_version_revision}${mod_version_patch}-${mod_internal_build}"
    replace "@MC_VERSION@", project.minecraft_version
    //replace "@BUILD@", ${mod_version_build}
    replaceIn mod_mainClass
    //if (project.hasProperty("Mod_signature")) { replace "@FINGERPRINT@", project.Mod_signature }
}

/*sourceSets {WTF Gradle, why aren't you working?
    main {
        java {
            srcDirs += "src/api/main"
            srcDirs += "src/main/java"
        }

        resources {
            srcDir "src/main/resources", "mcmod.info"
            //"pack.mcmeta"
        }
    }
}*/

processResources {
    // this will ensure that this task is redone when the versions change.
    inputs.property "version", project.version
    inputs.property "mcversion", project.minecraft.version

    // we're omitting the .xcf files - they're development only
    exclude '**/*.xcf'

    // replace stuff in files
    from(sourceSets.main.resources.srcDirs) {
        include '**/*.lang'
        include '**/*.info'
        include '**/*.properties'

        // replace version and mcversion
        expand 'version':project.version, 'mcversion':project.minecraft.version
    }

    // copy everything else, that's not the files above
    from(sourceSets.main.resources.srcDirs) {
        exclude '**/*.lang'
        exclude '**/*.info'
        exclude '**/*.properties'
    }
}

/* *=-=-=-=* Deprecated Schtuff *=-=-=-=* */

/*configurations {
    deployerJars
}*/

/*task buildInfo() {
    def cmd = "git rev-parse --short HEAD"
    def proc = cmd.execute()
    proc.waitFor()
    if (proc.exitValue() == 0) {
        ext.revision = "DEV." + proc.text.trim()
    } else {
        ext.revision = "GITBORK"
    }
    if (System.getenv().BUILD_NUMBER != null) {
        ext.buildNum = "${System.getenv().BUILD_NUMBER}"
    } else {
        ext.buildNum = "${project.buildInfo.revision}"
    }
}
ext.artifact_version = 'NFG'
if (System.getenv().ARTIFACT_VERSION == null) {
    artifact_version = "${config.mod_version}-${project.buildInfo.buildNum}"
}
if(System.getenv().ARTIFACT_VERSION != null) {
    artifact_version = "${system.getenv().ARTIFACT_VERSION}"
}
// I don't always upload, but when I Dos Equis...
/*task("uploadJars", dependsOn:"reobf""signJar") {
    
    description = "uploads JARs"
    if (project.hasProperty("local_maven") || project.hasProperty("sftp_maven")) {
	    apply plugin: 'maven'
        uploadArchives {
            repositories {
		    	if(project.hasProperty("local_maven"))
			    {
                    mavenDeployer {
                        repository(url: "file://${local_maven}")
				    }
                }
				if(project.hasProperty("sftp_maven")) {
                    repositories.mavenDeployer {
					    configuration = configurations.deployerJars
                        repository(url: "sftp://${sftp_maven}"){
						authentication(userName: "${sftp_username}",privateKey: "${sftp_key}")}
				    }
                }
            }
        }    
    }
}*/