build.gradle

buildscript {
    repositories {
        mavenCentral()
        maven {
            name 'JitPack'
            url 'https://jitpack.io'
        }
        maven {
            name 'forge'
            url 'https://maven.minecraftforge.net'
        }
    }
    dependencies {
        classpath('com.anatawa12.forge:ForgeGradle:1.2-1.1.+') {
            changing = true
        }
        classpath 'com.github.MJaroslav:Bon2Gradle:0.5.+'
    }
}


apply plugin: 'java'
apply plugin: 'forge'
apply plugin: 'maven-publish'
apply from: 'https://raw.githubusercontent.com/MJaroslav/MCInGameTester/master/gradle/configurations/v1.gradle'
apply plugin: 'bon2gradle'

repositories {
    mavenCentral()
    maven {
        name 'jitpack'
        url 'https://jitpack.io'
    }
    maven {
        name "Gregtech repo"
        url 'https://gregtech.overminddl1.com'
    }
    maven {
        name "CraftTweaker"
        url "https://maven.blamejared.com/"
    }
    maven {
        url 'https://cursemaven.com/'
        content {
            includeGroup 'curse.maven'
        }
    }
    // FG adds forge maven before central and forge maven contains only poms of lombok, not jars.
    exclusiveContent {
        forRepository {
            mavenCentral()
        }
        filter {
            includeGroup "org.projectlombok"
        }
    }
}

def buildprop = new Properties()
file("build.properties").withInputStream { buildprop.load(it) }

version = buildprop.version
group = buildprop.group
archivesBaseName = project.name

task devJar(type: Jar) {
    archiveClassifier = 'dev'
    manifest { from project.tasks.jar.manifest }
    from sourceSets.main.output
}

artifacts {
    archives devJar
}

java {
    withSourcesJar()
}

configure([tasks.compileJava, tasks.compileTestJava, tasks.compileApiJava]) {
    sourceCompatibility = 16 // for the IDE support
    options.release = 8

    javaCompiler = javaToolchains.compilerFor {
        languageVersion = JavaLanguageVersion.of(16)
    }
}

configurations {
    shade

    implementation.extendsFrom(shade)
}

minecraft {
    version = "${buildprop.game_version}-${buildprop.forge_version}-${buildprop.game_version}"
    runDir = buildprop.run_dir
    replace '@VERSION@', project.version
    srgExtra "PK: blue/endless/jankson io/github/mjaroslav/mjutils/library/blue/endless/jankson"
    // srgExtra "PK: io/github/mjaroslav/sharedjava io/github/mjaroslav/mjutils/library/io/github/mjaroslav/sharedjava"
}

dependencies {
    shade "blue.endless:jankson:${buildprop.jankson_version}"
    shade "com.github.MJaroslav:Shared-Java:${buildprop.sharedjava_version}"

    // All mods versions hardcoded because it's 1.7.10, my dude
    implementation "codechicken:CodeChickenLib:1.7.10-1.1.3.140:dev"
    implementation "codechicken:CodeChickenCore:1.7.10-1.0.7.47:dev"
    implementation "codechicken:NotEnoughItems:1.7.10-1.0.5.120:dev"
    implementation "mcp.mobius.waila:Waila:1.5.11-RC2-NONEI_1.7.10:dev"
    implementation "com.azanor.baubles:Baubles:1.7.10-1.0.1.10:deobf"
    implementation "thaumcraft:Thaumcraft:1.7.10-4.2.3.5:dev"
    implementation bon2.deobf("curse.maven:crafttweaker-239197:2838720")

    implementation "com.github.LegacyModdingMC.UniMixins:unimixins-mixin-1.7.10:${buildprop.unimixins_version}"
    annotationProcessor "com.github.LegacyModdingMC.UniMixins:unimixins-mixin-1.7.10:${buildprop.unimixins_version}"
    implementation bon2.deobf("com.github.LegacyModdingMC.UniMixins:unimixins-mixinbooterlegacy-1.7.10:${buildprop.unimixins_version}")

    compileOnly "org.jetbrains:annotations:${buildprop.jetbrains_annotations_version}"
    testCompileOnly "org.jetbrains:annotations:${buildprop.jetbrains_annotations_version}"

    compileOnly "org.projectlombok:lombok:${buildprop.lombok_version}"
    annotationProcessor "org.projectlombok:lombok:${buildprop.lombok_version}"

    testCompileOnly "org.projectlombok:lombok:${buildprop.lombok_version}"
    testAnnotationProcessor "org.projectlombok:lombok:${buildprop.lombok_version}"

    annotationProcessor "com.github.bsideup.jabel:jabel-javac-plugin:${buildprop.jabel_version}"
    testAnnotationProcessor "com.github.bsideup.jabel:jabel-javac-plugin:${buildprop.jabel_version}"

    testImplementation "junit:junit:${buildprop.junit_version}"
}

runClient {
    args += ["--tweakClass", "org.spongepowered.asm.launch.MixinTweaker"]
}

runServer {
    args += ["--tweakClass", "org.spongepowered.asm.launch.MixinTweaker"]
}

testClient {
    logOnlyTests = false
    args += ["--tweakClass", "org.spongepowered.asm.launch.MixinTweaker"]
}

testServer {
    logOnlyTests = false
    args += ["--tweakClass", "org.spongepowered.asm.launch.MixinTweaker"]
}

def outSrgFile = "${tasks.compileJava.temporaryDir}/outSrg.srg"
def outRefMapFile = "${tasks.compileJava.temporaryDir}/mixin.${project.name.replace(" ", "").toLowerCase()}.refmap.json"

test {
    useJUnit()
}

processResources {
    inputs.property 'version', project.version
    inputs.property 'mcversion', project.minecraft.version
    from(sourceSets.main.resources.srcDirs) {
        include 'mcmod.info'
        expand 'version': project.version, 'mcversion': project.minecraft.version
        duplicatesStrategy = DuplicatesStrategy.INCLUDE
    }
}

jar {
    if (buildprop.coremod.toBoolean())
        manifest {
            // TODO: Don't forged about -Dfml.coreMods.load
            attributes "FMLCorePlugin": "${project.group}.${project.name.replace(" ", "").toLowerCase()}" +
                ".asm.${project.name.replace(" ", "")}Plugin"
            attributes "FMLCorePluginContainsFMLMod": "true"
            attributes "ForceLoadAsMod": "true"
        }
    configurations.shade.each { dep ->
        from project.zipTree(dep)
    }
    from outRefMapFile
}

tasks.compileJava.options.compilerArgs += ["-AreobfSrgFile=${tasks.reobf.srg}", "-AoutSrgFile=${outSrgFile}", "-AoutRefMapFile=${outRefMapFile}"]

reobf {
    addExtraSrgFile outSrgFile
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            from components.java
            // artifact(jar) { builtBy build }
            // artifact(sourcesJar) { builtBy sourcesJar }
            // artifact(devJar) { builtBy devJar }
            pom {
                name = "MJUtils"
                description = "A set of tools to simplify writing mods. It contains a modular system for " +
                    "initialization of mods and a system of configurations by annotations."
            }
        }
    }
}