build.gradle

//file:noinspection All

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

plugins {
  id 'java-library'
  id 'maven-publish'
  id 'idea'
  id 'org.jetbrains.kotlin.jvm'

  id 'fabric-loom' version '1.3-SNAPSHOT'

  id 'org.ajoberstar.grgit' version '5.+'
  id 'com.matthewprenger.cursegradle' version '1.+'
  id 'com.modrinth.minotaur' version '2.+'
}


import com.modrinth.minotaur.dependencies.DependencyType
import com.modrinth.minotaur.dependencies.ModDependency
import groovy.json.JsonOutput
import groovy.json.JsonSlurper
import org.kohsuke.github.GHReleaseBuilder

version = mod_version
group = maven_group

compileKotlin.kotlinOptions.jvmTarget = "17"

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

  maven {
    name = 'Jitpack'
    url  = 'https://jitpack.io/'
  }

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

dependencies {
  minecraft "com.mojang:minecraft:$minecraft_version"
  mappings "net.fabricmc:yarn:$minecraft_version+build.$yarn_build:v2"
  modImplementation "net.fabricmc:fabric-loader:$loader_version"

  modImplementation "net.fabricmc.fabric-api:fabric-api:$fabric_version"
  include modImplementation ("net.fabricmc:fabric-language-kotlin:$fabric_kotlin_version")

  modCompileOnly "com.terraformersmc:modmenu:$mod_menu_version"

  testImplementation sourceSets.main.output
}

def githubUsername = System.getenv("GITHUB_USERNAME")
if (githubUsername != null) {
  repositories {
    maven {
      name = 'GitHub Packages (axieum/authme)'
      url = 'https://maven.pkg.github.com/axieum/authme/'
      credentials {
        username = project.findProperty("gpr.user") ?: githubUsername
        password = project.findProperty("gpr.key") ?: System.getenv("GITHUB_TOKEN")
      }
    }
  }

  dependencies {
    // try get authme, to be able to log into MCC: Island
    try {
      modRuntimeOnly "me.axieum.mcmod.authme:authme:${project.auth_me_version}"
    } catch (exception) {
      print("Could not depend on axeium/authme")
      exception.printStackTrace()
    }
  }
}

sourceSets {
  test
}

processResources {
  inputs.property "version", version
  filteringCharset "UTF-8"

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

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

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

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

  runs {
    server {
      ideConfigGenerated = false
    }

    testClient {
      client()

      name = "Minecraft Client (Test)"
      source sourceSets.test
    }
  }
}

jar {
  from("LICENSE") {
    rename { "${it}_${archivesBaseName}" }
  }
}

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

      artifact(remapSourcesJar) {
        builtBy remapSourcesJar
      }
    }
  }

  
  def ENV = System.getenv()
  if (ENV.MAVEN_URL) {
    repositories.maven {
      url ENV.MAVEN_URL
      allowInsecureProtocol = true
      if (ENV.MAVEN_USERNAME) {
        credentials {
          username ENV.MAVEN_USERNAME
          password ENV.MAVEN_PASSWORD
        }
      }
    }
  }
}

/* Data Generation */

def generatedResourcesDir = "src/main/generated"

loom {
    runs {
        create("Data Generation") {
            client()

            vmArg("-Dfabric-api.datagen")
            vmArg("-Dfabric-api.datagen.output-dir=${file(generatedResourcesDir)}")
            vmArg("-Dfabric-api.datagen.modid=${mod_id}")

            runDir("build/datagen")
        }
    }
}

sourceSets.main {
    resources {
        srcDir(generatedResourcesDir)
    }
}

/* Releasing */

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

tasks.register('github') {
  onlyIf { ENV.GITHUB_TOKEN }
  dependsOn(build)
  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 == 'beta')
    builder.create().uploadAsset(file("${project.buildDir}/libs/${archivesBaseName}-${version}.jar"), "application/java-archive");
  }
}

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
  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'

    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 }
}

tasks.register('releaseVersion').configure {
  dependsOn(build, 'modrinth', 'github', 'curseforge')
}