build.gradle

import net.minecraftforge.gradle.common.tasks.SignJar

buildscript {
    repositories {
        maven { url = 'https://maven.minecraftforge.net' }
        mavenCentral()
        maven {url 'https://maven.parchmentmc.org'}
        maven {url 'https://repo.spongepowered.org/repository/maven-public/'}
    }
    dependencies {
        classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '5.1.+', changing: true
        classpath 'org.parchmentmc:librarian:1.+'
        classpath 'org.spongepowered:mixingradle:0.7-SNAPSHOT'
    }
}
apply plugin: 'net.minecraftforge.gradle'
// Only edit below this line, the above code adds and enables the necessary things for Forge to be setup.
apply plugin: 'maven-publish'
apply plugin: 'org.parchmentmc.librarian.forgegradle'
apply plugin: 'org.spongepowered.mixin'
apply plugin: 'eclipse'

version = project.ce_version+makeVersionSuffix()
group = "malte0811.controlengineering"
archivesBaseName = "ControlEngineering"

String makeVersionSuffix() {
    return System.getenv("GITHUB_ACTIONS") != null ? "-GH-" + System.getenv("GITHUB_RUN_NUMBER") : ""
}

sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = 17

sourceSets {
    main {
        resources {
            srcDirs = [
                    "$rootDir/src/main/resources",
                    "$rootDir/src/generated/resources"
            ]
        }
    }
    datagen {
        compileClasspath += main.output + main.compileClasspath
        runtimeClasspath += main.output + main.runtimeClasspath
    }
}

def setupSourceSet(SourceSet sourceSet, String name) {
    sourceSet.java {
        srcDir 'src/' + name + '/java'
    }
    sourceSet.resources {
        //Add the generated module resources
        srcDirs += 'src/generated/resources'
        //But exclude the cache of the generated data from what gets built
        exclude '.cache'
    }
}

def version_replacements = [
        'mc_version': minecraft_version,
        'ie_version': ie_version,
        'ce_version': project.version,
        'forge_version': forge_version,
]

processResources {
    inputs.properties(version_replacements)
    filesMatching("META-INF/mods.toml") {
        expand version_replacements
    }
    exclude ".cache"
}

// When using "Run using IntelliJ" (the only option with well-working hotswapping) the used "resources" directory is
// different from the one used by gradle/the processResources task
task copyModsTomlForIntelliJ(type: Copy) {
    from processResources.destinationDir
    into "$projectDir/out/production/resources"
    include "META-INF/mods.toml"
}

copyModsTomlForIntelliJ.dependsOn processResources
afterEvaluate {
    // prepareRuns doesn't exist before afterEvaluate
    prepareRuns.dependsOn copyModsTomlForIntelliJ
}

minecraft {
    mappings channel: 'parchment', version: "${parchment_version}-${minecraft_version}"

    // Default run configurations.
    // These can be tweaked, removed, or duplicated as needed.
    runs {
        client {
            workingDirectory project.file('run')

            // Recommended logging data for a userdev environment
            property 'forge.logging.markers', ''

            // Recommended logging level for the console
            property 'forge.logging.console.level', 'debug'
            mods {
                controlengineering {
                    source sourceSets.main
                }
            }
        }

        server {
            workingDirectory project.file('run')

            // Recommended logging data for a userdev environment
            property 'forge.logging.markers', ''

            // Recommended logging level for the console
            property 'forge.logging.console.level', 'debug'

            arg '-nogui'

            mods {
                controlengineering {
                    source sourceSets.main
                }
            }
        }
        data {
            workingDirectory project.file('run')

            // Recommended logging data for a userdev environment
            property 'forge.logging.markers', ''

            // Recommended logging level for the console
            property 'forge.logging.console.level', 'debug'
            ideaModule project.name+".datagen"

            args '--mod', 'controlengineering', '--all', '--output', file('src/generated/resources/'), '--validate',
                    '--existing', sourceSets.main.resources.srcDirs[0], '--existing-mod', 'immersiveengineering'

            mods {
                controlengineering {
                    source sourceSets.main
                    source sourceSets.datagen
                }
            }
        }
    }
}

repositories {
    maven { // JEI & Tinkers
        name = 'DVS1 Maven FS'
        url = 'https://dvs1.progwml6.com/files/maven'
    }
    maven {
        name = "BlameJared"
        url = "https://maven.blamejared.com/"
    }
}

dependencies {
    minecraft "net.minecraftforge:forge:${minecraft_version}-${forge_version}"
    runtimeOnly fg.deobf("blusunrize.immersiveengineering:ImmersiveEngineering:${ie_version}")
    compileOnly fg.deobf("blusunrize.immersiveengineering:ImmersiveEngineering:${ie_version}:api")
    datagenImplementation fg.deobf("blusunrize.immersiveengineering:ImmersiveEngineering:${ie_version}:datagen")
    testImplementation('junit:junit:4.13')
}

def customGradle = rootProject.file('custom.gradle');
if (customGradle.exists()) {
    apply from: customGradle;
}

def reobfFile = file("$buildDir/reobfJar/output.jar")
def reobfArtifact = artifacts.add('default', reobfFile) {
    type 'jar'
    builtBy 'reobfJar'
}

task signJar(type: SignJar, dependsOn: jar) {
    onlyIf {
        project.hasProperty('keyStore')
    }
    if (project.hasProperty('keyStore')) {
        keyStore = project.keyStore
        alias = project.storeAlias
        storePass = project.storePass
        keyPass = project.storePass
        inputFile = jar.archivePath
        outputFile = jar.archivePath
    } else {
        logger.warn("No key store found, not signing the output jar\n")
    }
}

build.dependsOn signJar

afterEvaluate {
    signJar.dependsOn reobfJar
}

task sourcesJar(type: Jar, dependsOn: classes) {
    classifier = 'sources'
    from sourceSets.main.allSource
}

artifacts {
    archives sourcesJar
}

task speedUpPreRun {
    doLast {
        for (String s : new String[]{"Client", "Server", "Data"}) {
            ant.replace(
                    file: ".idea/runConfigurations/run"+s+".xml",
                    // prepareRunX is prepareRuns + compile, but compiling is already handled by IntelliJ
                    token: "prepareRun"+s,
                    value: "prepareRuns"
            )
        }
    }
}

tasks.withType(Task) {
    if (it.name == "genIntellijRuns") {
        it.finalizedBy speedUpPreRun
    } else if (it.name == "runServer") {
        it.standardInput = System.in
    }
}

//Minimize/optimize all png files, requires optipng on the PATH
// Credits: BrainStone
void minimizePNGFile(File file) {
    long size = file.length()
    exec {
        executable "optipng"
        args "-q", "-o7", "-zm1-9", "-strip", "all", file
    }
    long newSize = file.length()
    if (newSize < size) {
        System.out.format("Reduced File size of %s from %d bytes to %d bytes (reduced by %.2f%%)\n",
                file, size, newSize, ((double) (size - newSize)) / ((double) size) * 100.0)
    }
}

task optimizePng {
    def pngPatterns = ["**/*.png"]
    doLast {
        //Ensure the logo is minimized (we add this file to each jar)
        //Minimize any PNGs in the source sets
        for (dir in sourceSets.main.resources.srcDirs) {
            fileTree(dir: dir, includes: pngPatterns).each { minimizePNGFile(it) }
        }
    }
}