build.gradle

def dateString = getDate()
group 'com.fbdev.helios'

//version dateString
version dateString + '-SNAPSHOT'
def jarNameHead = rootProject.name + "-" + version

assert JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_17) : "Java 17 or newer is required"

apply plugin: 'java'

repositories {
    mavenCentral()
}

dependencies {
    // https://mvnrepository.com/artifact/net.java.jinput/jinput
    implementation group: 'net.java.jinput', name: 'jinput', version: '2.0.10'
    // https://mvnrepository.com/artifact/com.google.guava/guava
    implementation group: 'com.google.guava', name: 'guava', version: '33.2.0-jre'
    implementation group: 'org.jctools', name: 'jctools-core', version: '4.0.3'
    // https://mvnrepository.com/artifact/org.digitalmediaserver/cuelib-core
    implementation group: 'org.digitalmediaserver', name: 'cuelib-core', version: '2.0.0'
    implementation group: 'com.github.trilarion', name: 'java-vorbis-support', version: '1.2.1'
    // https://mvnrepository.com/artifact/org.jaudiolibs/audioservers-javasound
    implementation group: 'org.jaudiolibs', name: 'audioservers-javasound', version: '2.0.0'
    implementation 'com.google.code.gson:gson:2.11.0'
    implementation 'com.formdev:flatlaf:3.4.1'
    implementation group: 'org.ow2.asm', name: 'asm', version: '9.7'
    implementation group: 'org.ow2.asm', name: 'asm-commons', version: '9.7'
    implementation group: 'org.ow2.asm', name: 'asm-util', version: '9.7'

    implementation 'org.tinylog:tinylog-api:2.7.0'
    implementation 'org.tinylog:tinylog-impl:2.7.0'
    implementation 'org.tinylog:slf4j-tinylog:2.7.0'

    testImplementation group: 'junit', name: 'junit', version: '4.13.2'
    // https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api
    testImplementation group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: '5.10.2'
    testImplementation group: 'org.junit.jupiter', name: 'junit-jupiter-params', version: '5.10.2'


    //include local jars
    implementation fileTree(dir: 'lib', include: ['*.jar'])
    testImplementation fileTree(dir: 'lib', include: ['*.jar'])
}

def static getDate() {
    String date = new Date().format('yyMMdd')
    date.substring(0,2) + "." + date.substring(2)
}

//create a single Jar with all dependencies
task fatJar(type: Jar) {
    manifest {
        attributes 'Implementation-Title': 'Helios',
                'Implementation-Version': archiveVersion,
                'Main-Class': 'omegadrive.SystemLoader'
    }
    getArchiveBaseName().set(project.name + "-all")//+ version
    from { configurations.implementation.collect { it.isDirectory() ? it : zipTree(it) } }
    from {
        ["CREDITS.md", "README.md", "HISTORY.md", "LICENSE.md", "helios.properties"]
    }
    from("bios"){
        include "*.rom"
    }
    with jar
    doLast {
        println("Creating fatJar in folder: " + destinationDirectory)
    }
}

task copyRes {
    copy {
        from (".") {
            include "res/**"
        }
        into "$buildDir/packageDir"
        exclude "**/*.col", "**/site/**", "**/misc/**"
    }
    copy {
        from {
            ["CREDITS.md", "README.md", "HISTORY.md",
             "LICENSE.md", "helios.properties", "key.config.1p"]
        }
        into "$buildDir/packageDir"
    }
    copy {
        from (".") {
            include "lib/**"
        }
        into "$buildDir/packageDir"
    }
    copy {
        from configurations.runtimeClasspath
        into "$buildDir/packageDir/lib"
    }
}

jar {
    manifest {
        attributes 'Implementation-Title': 'Helios',
                   'Implementation-Version': archiveVersion,
                   'Main-Class': 'omegadrive.SystemLoader',
                   'Class-Path': configurations.compileClasspath.collect { "lib/" + it.getName() }.join(' ')
    }
    getArchiveBaseName().set(rootProject.name)
    destinationDirectory = file("$buildDir/packageDir")
    doLast {
        println("Creating jar: " + getArchiveFileName().getOrNull() +
                " in folder: " + getDestinationDirectory().getOrNull())
    }
}

task jarWithSources(type: org.gradle.jvm.tasks.Jar) {
    from sourceSets.main.allSource
    manifest {
        attributes 'Implementation-Title': 'Helios',
                'Implementation-Version': archiveVersion,
                'Main-Class': 'omegadrive.SystemLoader',
                'Class-Path': configurations.compileClasspath.collect { "lib/" + it.getName() }.join(' ')
    }
    getArchiveFileName().set(rootProject.name + "-binsrc-${project.version}.jar")
    destinationDirectory = file("$buildDir/packageDir")
    with jar
    doLast {
        println("Creating jar with sources: " + getArchiveFileName().getOrNull() +
                " in folder: " + getDestinationDirectory().getOrNull())
    }
}

task packageDistribution(type: Zip) {
    dependsOn "test", "jar", "copyRes", "writeToFile"
    archiveFileName = jarNameHead + ".zip"
    destinationDirectory = file("$buildDir/dist")

    from "$buildDir/packageDir"
    doLast {
        println("Creating package: " + getArchiveFileName().getOrNull() +
                ", folder: " + getDestinationDirectory().getOrNull())
    }
}

task writeToFile {
    String jarName = jarNameHead + ".jar"
    List<String> javaAdvOpts =
            ["-XX:AutoBoxCacheMax=65536", "-XX:-DontCompileHugeMethods", "-XX:+AlwaysCompileLoopMethods"]
    //win: default to busy wait
    List<String> winOpts = ["-Dhelios.busy.wait=true"]
    List<String> sampleBase = ["java",
                               "-Dtinylog.configuration=./res/tinylog.properties",
                               "-Djinput.enable=true -Djinput.native.location=lib",
                               "-jar", "$jarName"] as String[]
    sampleBase.addAll(1, javaAdvOpts)
    List<String> sampleUx = new ArrayList<>(sampleBase)
    sampleUx.add("\"\$@\"" + "\n")
    List<String> sampleWin = new ArrayList<>(sampleBase)
    sampleWin.addAll(1, winOpts)
    sampleWin.add("\"%1\"" + "\n")
    // create the folders if it does not exist.(otherwise it will throw exception)
    File extraFolder = new File( "${buildDir}/packageDir")
    if( !extraFolder.exists() ) {
        extraFolder.mkdirs()
    }
    // create the file and write text to it.
    new File("${buildDir}/packageDir/launcher.sh").text = sampleUx.join (" ")
    new File("${buildDir}/packageDir/launcher.bat").text = sampleWin.join (" ")
}

test {
    testLogging {
        afterSuite { desc, result ->
            if (!desc.parent) { // will match the outermost suite
                println "Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} successes, ${result.failedTestCount} failures, ${result.skippedTestCount} skipped)"
            }
        }
    }
}