build.gradle

import org.apache.tools.ant.filters.ReplaceTokens

import java.nio.file.Paths

buildscript {
    repositories {
        maven { url = 'https://maven.minecraftforge.net' }
        maven { url = 'https://repo.spongepowered.org/repository/maven-public' }
        mavenCentral()
    }
    dependencies {
        classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '6.0.+', changing: true
        classpath "org.spongepowered:mixingradle:0.7-SNAPSHOT"
    }
}

plugins {
    //id 'wtf.gofancy.fancygradle' version '1.+'
}

apply plugin: 'net.minecraftforge.gradle'
apply plugin: 'eclipse'
apply plugin: 'maven-publish'
apply plugin: 'org.spongepowered.mixin'

version = "${minecraft_version}-${mod_version}"
group = mod_base_package
archivesBaseName = mod_id

java.toolchain.languageVersion = JavaLanguageVersion.of(8)
mixin {
    add sourceSets.main, "mixins.cta.refmap.json"
    disableAnnotationProcessorCheck()
}
minecraft {

    mappings channel: mappings_channel, version: mappings_version

    accessTransformer = file('src/main/resources/META-INF/cta_at.cfg')

    runs {
        client {
            workingDirectory project.file('run/client')
            jvmArg "-Dfml.coreMods.load=gkappa.cta.CTALoadingPlugin"
            jvmArg "-Dmixin.hotSwap=true"
            jvmArg "-Dmixin.checks.interfaces=true"
            args "--username=Dev"
            property 'forge.logging.markers', 'REGISTRIES'
            property 'forge.logging.console.level', 'debug'

        }

        server {
            workingDirectory project.file('run/server')
            jvmArg "-Dfml.coreMods.load=gkappa.cta.CTALoadingPlugin"
            jvmArg "-Dmixin.hotSwap=true"
            jvmArg "-Dmixin.checks.interfaces=true"

            property 'forge.logging.markers', 'REGISTRIES'
            property 'forge.logging.console.level', 'debug'

            mods {
                "${mod_id}" {
                    source sourceSets.main
                }
            }
        }
    }
}

sourceSets.main.resources { srcDir 'src/generated/resources' }

repositories {
    maven { url = 'https://sizableshrimp.me/maven' }
    maven { url = 'https://repo.spongepowered.org/maven' }
    maven { url = 'https://maven.cleanroommc.com' }
    maven {
        url "https://cursemaven.com"
        content {
            includeGroup "curse.maven"
        }
    }
}

dependencies {
    minecraft "net.minecraftforge:forge:${minecraft_version}-${forge_version}"

    annotationProcessor("org.spongepowered:mixin:0.8.5:processor")
    /*
    compileOnly("org.spongepowered:mixin:0.8.5") {
        exclude module: "asm-commons"
        exclude module: "asm-tree"
        exclude module: "launchwrapper"
        exclude module: "guava"
        exclude module: "log4j-core"
        exclude module: "gson"
        exclude module: "commons-io"
    }
    */

    compileOnly "zone.rong:mixinbooter:8.4"
    runtimeOnly "zone.rong:mixinbooter:8.4"
    compileOnly fg.deobf("curse.maven:ba-272515:2685984")
}

/*fancyGradle {
    patches {
        resources
        coremods
        //codeChickenLib
        asm
    }
}*/


def resourceTargets = ['mcmod.info', 'pack.mcmeta']
def intoTargets = ["$rootDir/out/production/resources/", "$rootDir/out/production/${project.name}.main/", "$rootDir/bin/main/"]
def replaceProperties = [mod_id: mod_id, mod_name: mod_name, mod_version: mod_version,
        mod_authors: mod_authors, mod_description: mod_description.replace('\n', '\\n'), minecraft_version: minecraft_version]
processResources {
    inputs.properties replaceProperties
    replaceProperties.put 'project', project

    filesMatching(resourceTargets) {
        expand replaceProperties
    }

    intoTargets.each { target ->
        if (file(target).exists()) {
            copy {
                from(sourceSets.main.resources) {
                    include resourceTargets
                    expand replaceProperties
                }
                into target
            }
        }
    }
}



def modFileTokens = [VERSION: mod_version]
def included = ["${mod_base_package.replace('.', '/')}/${mod_main_class}.java".toString()]

def expandedSrc = new File(project.buildDir, 'expandedSrc')
def srcMainJava = project.file('src/main/java').toPath()
def includedPaths = included.collect { Paths.get(it) }
task javaReplaceTokens(type: Copy) {
    inputs.property 'tokens', modFileTokens
    from(srcMainJava) {
        include included
    }
    into expandedSrc
    filter(ReplaceTokens, beginToken: '@', endToken: '@', tokens: modFileTokens)
}

compileJava {
    dependsOn javaReplaceTokens
    exclude {
        srcMainJava.relativize(it.file.toPath()) in includedPaths
    }
    source expandedSrc
}

jar {
    manifest {
        attributes([
                'Specification-Title': mod_id,
                'Specification-Vendor': mod_authors,
                'Specification-Version': '1', // We are version 1 of ourselves
                'Implementation-Title': project.name,
                'Implementation-Version': mod_version,
                'Implementation-Vendor': mod_authors,
                'Implementation-Timestamp': new Date().format('yyyy-MM-dd\'T\'HH:mm:ssZ'),
                //'FMLCorePluginContainsFMLMod': 'true',
                'TweakClass': 'org.spongepowered.asm.launch.MixinTweaker',
                'FMLCorePlugin': 'gkappa.cta.CTALoadingPlugin',
                'ForceLoadAsMod': true,
                'FMLCorePluginContainsFMLMod': true,
                'FMLAT': "cta_at.cfg"
        ])
    }
}

jar.finalizedBy('reobfJar')



publishing {
    publications {
        mavenJava(MavenPublication) {
            artifact jar
        }
    }
    repositories {
        maven {
            url "file://${project.projectDir}/mcmodsrepo"
        }
    }
}