mcef-arm/fabric/build.gradle

plugins {
    id 'fabric-loom'
    id 'com.matthewprenger.cursegradle' version "${cursegradle_version}"
    id 'com.github.johnrengelman.shadow' version "${shadow_version}"
    id 'maven-publish'
}

sourceCompatibility = JavaLanguageVersion.of(java_version as int)
targetCompatibility = JavaLanguageVersion.of(java_version as int)

var mod_version = mcef_version

archivesBaseName = archives_base_name
version = mod_version
group = maven_group

repositories {
    mavenCentral()
    maven { url = 'https://maven.fabricmc.net/' }
    maven { url = 'https://oss.sonatype.org/content/repositories/snapshots' }
    mavenLocal()
}

/*
    Add the following to ~/.gradle/gradle.properties
    systemProp.org.gradle.s3.endpoint=https://<the s3 endpoint>
    MCEF_S3_PUBLISH_URL_SNAPSHOT=s3://<bucket>/repositories/snapshots
    MCEF_S3_PUBLISH_URL_RELEASE=s3://<bucket>/repositories/releases
    MCEF_S3_PUBLISH_ACCESS_KEY=<access key>
    MCEF_S3_PUBLISH_SECRET_KEY=<secret key>
 */
publishing {
    repositories {
        maven {
            url ((mcef_version.toString().endsWith("SNAPSHOT")) ? findProperty('MCEF_S3_PUBLISH_URL_SNAPSHOT') : findProperty('MCEF_S3_PUBLISH_URL_RELEASE'))
            credentials(AwsCredentials) {
                accessKey = findProperty('MCEF_S3_PUBLISH_ACCESS_KEY')
                secretKey = findProperty('MCEF_S3_PUBLISH_SECRET_KEY')
            }
        }
    }
    publications {
        mavenJava(MavenPublication) {
            from components.java
            groupId = 'com.cinemamod'
            artifactId = 'mcef-fabric'
            version = mcef_version
        }
    }
}

dependencies {
    minecraft "com.mojang:minecraft:${minecraft_version}"
    mappings loom.officialMojangMappings()
    modImplementation "net.fabricmc:fabric-loader:${fabric_loader_version}"

    Set<String> apiModules = [
            'fabric-api-base',
            'fabric-command-api-v2',
            'fabric-lifecycle-events-v1',
            'fabric-networking-api-v1',
            'fabric-resource-loader-v0',
            'fabric-key-binding-api-v1'
    ]

    apiModules.forEach {
        modImplementation(fabricApi.module(it, fabric_version))
    }

    implementation project(path: ':common', configuration: 'namedElements')
}

loom {
    mixin {
        defaultRefmapName = "mcef.refmap.json"
    }
}

tasks.register('generateJava', Copy) {
    from project(':common').file('src/template/java')
    into "${buildDir}/generated/java"
    expand 'compatibility_version': mod_compatibility_version
}
sourceSets.main.java {
    srcDir "${buildDir}/generated/java"
}
compileJava.dependsOn generateJava
generateJava.dependsOn('sourcesJar')

processResources {
    filesMatching('fabric.mod.json') {
        expand 'mod_id': mod_id,
                'mod_name': mod_name,
                'mod_vendor': mod_vendor,
                'mod_version': mod_version,
                'java_version': java_version,
                'minecraft_dependency': minecraft_dependency,
                'fabric_loader_version': fabric_loader_version,
                'min_fabric_version': min_fabric_version
    }
    from project(":common").sourceSets.main.resources
}

tasks.withType(JavaCompile).configureEach {
    source(project(':common').sourceSets.main.allSource)
    source(project(':common').sourceSets.jcef.allSource)
}

tasks.withType(JavaCompile).configureEach {
    it.options.encoding = 'UTF-8'
    it.options.release = java_version as int
}

java {
    withSourcesJar()
}

jar {
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
    manifest {
        attributes(['Specification-Title'     : mod_name,
                    'Specification-Vendor'    : mod_vendor,
                    'Specification-Version'   : "1",
                    'Implementation-Title'    : mod_name,
                    'Implementation-Version'  : mod_version,
                    'Implementation-Vendor'   : mod_vendor,
                    'Implementation-Timestamp': new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
                    'java-cef-commit'         : project.parent.getCheckedOutGitCommitHash(project.parent)
        ])
    }
    from('LICENSE') {
        rename { "${it}_${archivesBaseName}" }
    }
}

curseforge {
    apiKey = file("${rootDir}/curseforge_api_key.txt").exists() ? file("${rootDir}/curseforge_api_key.txt").text.trim() : ''
    project {
        id = curse_id
        releaseType = release_type
        addGameVersion minecraft_version
        addGameVersion 'Fabric'
        addGameVersion "Java ${java_version}"
        mainArtifact(file("${buildDir}/libs/${archivesBaseName}-${version}.jar")) {
            displayName = "[FABRIC][${minecraft_version}] ${mod_name} ${mod_version}"
        }
        afterEvaluate {
            uploadTask.dependsOn(remapJar)
        }
    }
    options {
        forgeGradleIntegration = false
    }
}

shadowJar {
    configurations = [project.configurations.shadow]
    archiveClassifier = 'shadow-dev'
}

remapJar {
    dependsOn shadowJar
    inputFile = shadowJar.archiveFile.get()
}