build.gradle

buildscript { dependencies { classpath 'org.kohsuke:github-api:1.307' } }

plugins {
  id 'java-library'
  id 'idea'
  id 'eclipse'

  id 'fabric-loom' version '0.13-SNAPSHOT'
  id 'maven-publish'

  id 'com.modrinth.minotaur' version '2.+'
  id 'com.matthewprenger.cursegradle' version '1.4.0'
}

/* Setup */

def ENV = System.getenv()

sourceCompatibility = targetCompatibility = JavaVersion.VERSION_17
tasks.withType(JavaCompile).configureEach { it.options.release = 17 }

String ver = "${project.version_id}+${project.major_version}-fabric"
version = ENV.GITHUB_ACTIONS ? "${ver}.build.${ENV.GITHUB_RUN_NUMBER}" : ver

archivesBaseName = project.mod_id
group = project.maven_group

/* Dependencies */

repositories {
  maven {
    name = 'Shedaniel'
    url  = 'https://maven.shedaniel.me/'
  }

  maven {
    name = 'Terraformers'
    url  = 'https://maven.terraformersmc.com/releases/'
  }
}

dependencies {
  minecraft "com.mojang:minecraft:${project.ver_minecraft}"
  mappings "net.fabricmc:yarn:${project.ver_minecraft}+build.${project.ver_yarn}:v2"
  modImplementation "net.fabricmc:fabric-loader:${project.ver_loader}"

  modImplementation "net.fabricmc.fabric-api:fabric-api:${project.ver_fabric}"
  modImplementation include("me.shedaniel.cloth:cloth-config-fabric:${project.ver_cloth_config}")
  modImplementation "com.terraformersmc:modmenu:${project.ver_mod_menu}"
}

/* Loom */

loom {
  runtimeOnlyLog4j = true
  accessWidenerPath = file("src/main/resources/${project.mod_id}.accesswidener")
}

/* Data Generation */

def dataOutput = 'src/main/generated'

loom {
  runs {
    datagen {
      server()

      name "Data Generation"
      vmArg "-Dfabric-api.datagen"
      vmArg "-Dfabric-api.datagen.output-dir=${file(dataOutput)}"

      runDir "build/datagen"
    }
  }
}

sourceSets { main { resources { srcDirs += dataOutput } } }

/* Resource Processing */

import groovy.json.*
processResources {
  // populate fabric.mod.json with defined version property
  inputs.property 'version', version
  filesMatching('fabric.mod.json') { expand 'version': version }

  doLast {
    // minify json files
    def start = System.currentTimeMillis()
    def minif = 0
    def bytes = 0
    fileTree(dir: outputs.files.asPath, include: '**/*.json').each {
      File file = it
      minif++
      def oldLength = file.length()
      file.text = JsonOutput.toJson(new JsonSlurper().parse(file))
      bytes += oldLength - file.length()
    }
    println("Minified $minif json files. Saved $bytes bytes. Took ${System.currentTimeMillis() - start} ms.")
  }
}

// add/remove files in jar
jar { from('README.md', 'LICENSE', 'LICENSE_ASSETS') exclude('.cache') }

/* Publishing */

java { withSourcesJar() }

publishing {
  publications {
    mavenJava(MavenPublication) {
      artifact(remapJar) { builtBy remapJar }
      artifact(sourcesJar) { builtBy remapSourcesJar }
    }
  }
}

loom { disableDeprecatedPomGeneration(publishing.publications.mavenJava) }

/* Releasing */

def VER_NAME = "[$project.major_version] $project.mod_name $project.version_id"
def CHANGELOG = new File("./gradle", "CHANGELOG.md").text
def SUPPORTED_VERSIONS = Arrays.asList(project.supported_versions.split(','))

import org.kohsuke.github.*
task github(dependsOn: build) {
  onlyIf { ENV.GITHUB_TOKEN }
  doLast {
    def github = GitHub.connectUsingOAuth(ENV.GITHUB_TOKEN)
    def repository = github.getRepository(project.github_repository)

    def builder = new GHReleaseBuilder(repository, version)
    builder.name(VER_NAME)
    builder.body(CHANGELOG)
    builder.commitish(project.github_branch)
    builder.prerelease(project.release_type != 'release')
    builder.create().uploadAsset(file("${project.buildDir}/libs/${archivesBaseName}-${version}.jar"), "application/java-archive");
  }
}

import com.modrinth.minotaur.dependencies.*
if (ENV.MODRINTH_TOKEN) modrinth {
  token         = ENV.MODRINTH_TOKEN
  projectId     = project.modrinth_id
  versionNumber = version
  versionName   = VER_NAME
  versionType   = project.release_type
  changelog     = CHANGELOG
  uploadFile    = remapJar
  gameVersions  = SUPPORTED_VERSIONS
  loaders       = [ "fabric", "quilt" ]
  dependencies  = [
          new ModDependency("fabric-api", DependencyType.REQUIRED)
  ]
}

if (ENV.CURSEFORGE_API_KEY) curseforge {
  apiKey = ENV.CURSEFORGE_API_KEY

  project {
    id = project.curseforge_id

    addGameVersion 'Fabric'
    addGameVersion 'Quilt'
    for (final def cf_ver in SUPPORTED_VERSIONS) addGameVersion cf_ver

    changelog   = CHANGELOG
    releaseType = project.release_type

    mainArtifact(remapJar) {
      displayName = VER_NAME
      relations {
        requiredDependency 'fabric-api'
      }
    }

    afterEvaluate { uploadTask.dependsOn(remapJar) }
  }

  options { forgeGradleIntegration = false }
}

task releaseVersion(dependsOn: [ build, 'github', 'modrinth', 'curseforge' ])