build.gradle

plugins {
    id 'java-library'
    id 'fabric-loom' version '1.9-SNAPSHOT' apply false
    id "me.champeau.jmh" version "0.7.2"
    id 'com.modrinth.minotaur' version '2.+' apply false
    id 'com.matthewprenger.cursegradle' version '1.4.0' apply false
    id 'com.gradleup.shadow' version '8.3.0' apply false
    id 'io.github.tomtzook.gradle-cmake' version '1.2.2' apply false
}

@SuppressWarnings('unused')
static def moduleDependencies(project, List<String> depNames) {
    project.dependencies {
        depNames.each {
            api project.dependencies.project(path: ":$it", configuration: 'namedElements')
        }
    }
}

configure(allprojects) {
    apply plugin: 'java'
    apply plugin: 'java-library'

    base {
        archivesName = "${project.name}-mc${project.minecraft_version}"
    }
    it.group = project.maven_group
    it.version = project.mod_version + "." + getVersionSuffix()
    java {
        sourceCompatibility = JavaVersion.VERSION_21
        targetCompatibility = JavaVersion.VERSION_21
    }

    afterEvaluate {
        if (it.plugins.hasPlugin("fabric-loom")) {
            afterEvaluate {
                migrateMappings.configure {
                    outputDir = project.file("src/main/java")
                }
            }
        }
    }
}

base {
    archivesName = "${project.archives_base_name}-mc${project.minecraft_version}"
}

clean.dependsOn gradle.includedBuild('FlowSched').task(':clean')

allprojects {
    repositories {
        maven { url 'https://jitpack.io' }
        maven {
            url "https://maven.bawnorton.com/releases"
            content {
                includeGroup "com.bawnorton.mixinsquared"
            }
        }
    }
}

configure (allprojects - project(":tests")) {
    if (project != project(":") && project.parent != project(":")) return

    apply plugin: 'fabric-loom'
    apply plugin: 'maven-publish'

    dependencies {
        //to change the versions see the gradle.properties file
        minecraft "com.mojang:minecraft:${project.minecraft_version}"
        mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
        modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"

        [
                "fabric-networking-api-v1",
                "fabric-lifecycle-events-v1",
        ].forEach {
            modCompileOnly(fabricApi.module(it, "${project.fabric_version}"))
        }
    }

    loom {
        def file = project(":c2me-base").file("src/main/resources/c2me-base.accesswidener")
        accessWidenerPath = file
        enableTransitiveAccessWideners = false
//        logger.lifecycle(String.format("%s: Using access widener at %s", project, file.getAbsolutePath()))
        runs {
            server {
                ideConfigGenerated project.rootProject == project
            }
            client {
                ideConfigGenerated project.rootProject == project
            }
        }
    }

    processResources {
        inputs.property "version", version + "+" + minecraft_version

        filesMatching("fabric.mod.json") {
            expand "version": version + "+" + minecraft_version
        }
    }

    jar {
        from rootProject.file("LICENSE")
    }

    java {
        withSourcesJar()
    }

    // ensure that the encoding is set to UTF-8, no matter what the system default is
    // this fixes some edge cases with special characters not displaying correctly
    // see http://yodaconditions.net/blog/fix-for-java-file-encoding-problems-with-gradle.html
    tasks.withType(JavaCompile) {
        options.encoding = "UTF-8"
    }

    // reproducible
    tasks.withType(AbstractArchiveTask) {
        preserveFileTimestamps = false
        reproducibleFileOrder = true
    }

    // configure the maven publication
    publishing {
        publications {
            mavenJava(MavenPublication) {
                from components.java
            }
        }

        // select the repositories you want to publish to
        repositories {
            // uncomment to publish to the local maven
            // mavenLocal()
        }
    }
}

configure (allprojects - project(":tests")) {
    dependencies {
        implementation "com.ibm.async:asyncutil:${async_util_version}"
        implementation "com.electronwill.night-config:toml:${night_config_version}"
        implementation "net.objecthunter:exp4j:${exp4j_version}"
        implementation "org.jctools:jctools-core:${jctools_version}"
        implementation annotationProcessor("com.github.bawnorton.mixinsquared:mixinsquared-fabric:${mixinsquared_version}")
        api "com.ishland.flowsched:flowsched"

        testImplementation platform("org.junit:junit-bom:${junit_version}")
        testImplementation 'org.junit.jupiter:junit-jupiter'
        testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
        testImplementation "net.fabricmc:fabric-loader-junit:${project.loader_version}"
    }

    test {
        useJUnitPlatform()
        workingDir getLayout().buildDirectory
    }

    jar.dependsOn test
}

subprojects {
    afterEvaluate {
        afterEvaluate {
            genSourcesWithFernFlower.enabled = false
            genSourcesWithVineflower.enabled = false
            genSourcesWithCfr.enabled = false
            downloadAssets.enabled = false
        }
    }
}

afterEvaluate {
    logger.lifecycle("Version String: ${version}")
    logger.lifecycle(com.ishland.c2me.gradle.ParseGItHubActionChangelog.getChangelog())
}

dependencies {
//    includeApi project(":libs")
//    include project(":libs")
    include implementation("com.ibm.async:asyncutil:${async_util_version}")
    include implementation("com.electronwill.night-config:toml:${night_config_version}")
    include implementation("com.electronwill.night-config:core:${night_config_version}")
    include implementation("net.objecthunter:exp4j:${exp4j_version}")
    include implementation("org.jctools:jctools-core:${jctools_version}")
    include implementation(annotationProcessor("com.github.bawnorton.mixinsquared:mixinsquared-fabric:${mixinsquared_version}"))
    include "io.reactivex.rxjava3:rxjava:${rxjava_version}"
    include "org.reactivestreams:reactive-streams:${reactive_streams_version}"
//    include implementation("com.ishland.flowsched:flowsched")

    // PSA: Some older mods, compiled on Loom 0.2.1, might have outdated Maven POMs.
    // You may need to force-disable transitiveness on them.

}

apply plugin: 'com.modrinth.minotaur'
modrinth {
    token = System.getenv("MODRINTH_TOKEN") // This is the default. Remember to have the MODRINTH_TOKEN environment variable set or else this will fail, or set it to whatever you want - just make sure it stays private!
    projectId = "c2me-fabric" // This can be the project ID or the slug. Either will work!
    versionNumber = project.version + "+" + project.minecraft_version // You don't need to set this manually. Will fail if Modrinth has this version already
    versionName = project.version + " devbuild for " + project.minecraft_version
    versionType = "alpha" // This is the default -- can also be `beta` or `alpha`
    uploadFile = remapJar // With Loom, this MUST be set to `remapJar` instead of `jar`!
    gameVersions = [project.minecraft_version] // Must be an array, even with only one version
    loaders = ["fabric"] // Must also be an array - no need to specify this if you're using Loom or ForgeGradle
    changelog = com.ishland.c2me.gradle.ParseGItHubActionChangelog.getChangelog()
}

apply plugin: 'com.matthewprenger.cursegradle'
if (System.getenv("CURSEFORGE_TOKEN")) {
    curseforge {
        apiKey = System.getenv("CURSEFORGE_TOKEN")
        project {
            id = '533097'
            changelogType = "markdown"
            changelog = com.ishland.c2me.gradle.ParseGItHubActionChangelog.getChangelog()
            releaseType = 'alpha'

            addGameVersion project.minecraft_version
            addGameVersion "Fabric"
            addGameVersion "Java 21"

            mainArtifact(remapJar) {
                displayName = project.version + " devbuild for " + project.minecraft_version
            }
        }
        options {
            forgeGradleIntegration = false
        }
    }
}

subprojects.forEach { remapJar.dependsOn("${it.path}:remapJar") }

dependencies {
    afterEvaluate {
        (subprojects - project(":tests")).forEach {
            if (it.parent != project(":")) return

            def projectName = it.name
            api project(path: ":${projectName}", configuration: "namedElements")
            include project("${projectName}:")
        }
    }
}

String getVersionSuffix() {
    def stdout = providers.exec {
        commandLine 'git', 'describe', '--tags', '--dirty', '--broken'
    }.standardOutput.asText.get()
    stdout = stdout.toString().strip()
    def suffix = ""
    if (stdout.endsWith("-dirty")) {
        stdout = stdout.substring(0, stdout.length() - "-dirty".length())
        suffix = "-dirty"
    }
    if (stdout.endsWith("-broken")) {
        stdout = stdout.substring(0, stdout.length() - "-broken".length())
        suffix = "-broken"
    }
    if (stdout.indexOf('-') < 0) {
        return "0" + suffix;
    }
    def split = stdout.split('-')
    return split[split.length - 2] + suffix
}

compileJmhJava {
    sourceCompatibility = JavaVersion.VERSION_22
    targetCompatibility = JavaVersion.VERSION_22
}

jmh {
//    includes = ['some regular expression'] // include pattern (regular expression) for benchmarks to be executed
//    excludes = ['some regular expression'] // exclude pattern (regular expression) for benchmarks to be executed
    iterations = 5 // Number of measurement iterations to do.
    benchmarkMode = ['avgt'] // Benchmark mode. Available modes are: [Throughput/thrpt, AverageTime/avgt, SampleTime/sample, SingleShotTime/ss, All/all]
    batchSize = 1 // Batch size: number of benchmark method calls per operation. (some benchmark modes can ignore this setting)
    fork = 2 // How many times to forks a single benchmark. Use 0 to disable forking altogether
    failOnError = false // Should JMH fail immediately if any benchmark had experienced the unrecoverable error?
//    forceGC = false // Should JMH force GC between iterations?
//    jvm = 'myjvm' // Custom JVM to use when forking.
//    jvmArgs = ['-XX:+UnlockDiagnosticVMOptions', '-XX:+LogCompilation', '-XX:+PrintAssembly', '-XX:+DebugNonSafepoints']
//    jvmArgsAppend = ['Custom JVM args to use when forking (append these)']
//    jvmArgsPrepend =[ 'Custom JVM args to use when forking (prepend these)']
//    humanOutputFile = project.file("${project.buildDir}/reports/jmh/human.txt") // human-readable output file
    resultsFile = project.file("${project.buildDir}/reports/jmh/results.txt") // results file
//    operationsPerInvocation = 10 // Operations per invocation.
//    benchmarkParameters =  [:] // Benchmark parameters.
    profilers = ['perf'] // Use profilers to collect additional data. Supported profilers: [cl, comp, gc, stack, perf, perfnorm, perfasm, xperf, xperfasm, hs_cl, hs_comp, hs_gc, hs_rt, hs_thr, async]
    timeOnIteration = '2s' // Time to spend at each measurement iteration.
    resultFormat = 'CSV' // Result format type (one of CSV, JSON, NONE, SCSV, TEXT)
//    synchronizeIterations = true // Synchronize iterations?
    threads = 1 // Number of worker threads to run with.
//    threadGroups = [2,3,4] //Override thread group distribution for asymmetric benchmarks.
//    timeout = '1s' // Timeout for benchmark iteration.
    timeUnit = 'ns' // Output time unit. Available time units are: [m, s, ms, us, ns].
    verbosity = 'NORMAL' // Verbosity mode. Available modes are: [SILENT, NORMAL, EXTRA]
    warmup = '1s' // Time to spend at each warmup iteration.
    warmupBatchSize = 1 // Warmup batch size: number of benchmark method calls per operation.
//    warmupForks = 0 // How many warmup forks to make for a single benchmark. 0 to disable warmup forks.
    warmupIterations = 16 // Number of warmup iterations to do.
    warmupMode = 'INDI' // Warmup mode for warming up selected benchmarks. Warmup modes are: [INDI, BULK, BULK_INDI].
    warmupBenchmarks = ['.*Warmup'] // Warmup benchmarks to include in the run in addition to already selected. JMH will not measure these benchmarks, but only use them for the warmup.

    zip64 = true // Use ZIP64 format for bigger archives
    jmhVersion = '1.34' // Specifies JMH version
    includeTests = true // Allows to include test sources into generate JMH jar, i.e. use it when benchmarks depend on the test classes.
    duplicateClassesStrategy = DuplicatesStrategy.FAIL // Strategy to apply when encountring duplicate classes during creation of the fat jar (i.e. while executing jmhJar task)
}