Migrate into FuturaGradle and Gradle 8x

build.gradle.kts

@@ -0,0 +1,190 @@
+import proguard.gradle.ProGuardTask
+import java.util.Random
+import java.util.regex.Pattern
+
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+    dependencies {
+        classpath("com.guardsquare:proguard-gradle:7.1.0")
+    }
+}
+
+plugins {
+    id("java-library")
+    id("maven-publish")
+    id("org.jetbrains.gradle.plugin.idea-ext") version "1.1.8"
+    id("com.gtnewhorizons.retrofuturagradle") version "1.4.0"
+}
+
+group = "forgefuck.team"
+version = "1.0.0"
+
+minecraft {
+    mcVersion.set("1.7.10")
+}
+
+tasks.processResources.configure {
+    val projVersion = project.version.toString()
+
+    filesMatching("mcmod.info") {
+        expand(mapOf("modVersion" to projVersion))
+    }
+}
+
+tasks.injectTags.configure {
+    enabled = false
+    doFirst {
+        throw StopExecutionException("Task injectTags is disabled")
+    }
+}
+
+tasks.injectedTagsClasses.configure {
+    enabled = false
+    doFirst {
+        throw StopExecutionException("Task injectTags is disabled")
+    }
+}
+
+tasks.jar {
+    archiveVersion.set(version.toString())
+    archiveClassifier.set("")
+}
+
+val runtimeOnlyNonPublishable: Configuration by configurations.creating {
+    description = "Runtime only dependencies that are not published alongside the jar"
+    isCanBeConsumed = false
+    isCanBeResolved = true
+
+}
+listOf(configurations.runtimeClasspath, configurations.testRuntimeClasspath).forEach {
+    it.configure {
+        extendsFrom(
+            runtimeOnlyNonPublishable
+        )
+    }
+}
+
+repositories {
+    maven {
+        name = "GTNH Maven"
+        url = uri("https://nexus.gtnewhorizons.com/repository/public/")
+    }
+    maven("https://cursemaven.com")
+    flatDir {
+        dirs("libs")
+    }
+
+}
+
+dependencies {
+}
+
+fun generateString(alphabet: String, n: Int): String {
+    val random = Random()
+    return (1..n).map { alphabet[random.nextInt(alphabet.length)] }.joinToString("")
+}
+
+fun generateClassDictionaryFile(name: String) {
+    val dictionaryFile = File(name)
+    if (dictionaryFile.exists()) return
+
+    val alphabet = (('a'..'z') + ('A'..'Z') + ('0'..'9')).joinToString("")
+    val outputData = (1..10000).joinToString("\n") {
+        val firstPart = generateString(alphabet, Random().nextInt(8) + 1)
+        val secondPart = generateString(alphabet, Random().nextInt(8) + 1)
+        "$firstPart$$secondPart"
+    } + "\n"
+
+    dictionaryFile.parentFile.mkdirs()
+    dictionaryFile.delete()
+    dictionaryFile.writeText(outputData)
+}
+
+fun generateDictionaryFile(name: String) {
+    val dictionaryFile = File(name)
+    if (dictionaryFile.exists()) return
+
+    val alphabet = (('a'..'z') + ('A'..'Z') + ('0'..'9')).joinToString("")
+    val outputData = (1..10000).joinToString("\n") { generateString(alphabet, 16) } + "\n"
+
+    dictionaryFile.parentFile.mkdirs()
+    dictionaryFile.delete()
+    dictionaryFile.writeText(outputData)
+}
+
+val generateDictionary by tasks.registering {
+    doFirst {
+        generateClassDictionaryFile("$buildDir/proguard/class-dictionary.txt")
+        generateDictionaryFile("$buildDir/proguard/package-dictionary.txt")
+        generateDictionaryFile("$buildDir/proguard/fieldmethod-dictionary.txt")
+    }
+}
+
+
+val obfuscateProGuard by tasks.registering(ProGuardTask::class) {
+    dependsOn(generateDictionary)
+
+    outputs.upToDateWhen { false }
+
+    doFirst {
+        val jarTask = tasks.jar.get()
+        val archName = jarTask.archiveFileName.get()
+        println(archName)
+        injars("$buildDir/libs/$archName")
+        outjars("$buildDir/libs/final-$archName")
+        libraryjars("${System.getProperty("java.home")}/lib/rt.jar")
+        libraryjars("${System.getProperty("java.home")}/lib/jce.jar")
+        libraryjars(sourceSets.main.get().compileClasspath)
+
+        keepattributes("RuntimeVisibleAnnotations,RuntimeVisibleParameterAnnotations,RuntimeVisibleTypeAnnotations")
+        keep("class !forgefuck.team.xenobyte.** { *; }")
+
+        classobfuscationdictionary("$buildDir/proguard/class-dictionary.txt")
+        packageobfuscationdictionary("$buildDir/proguard/package-dictionary.txt")
+        obfuscationdictionary("$buildDir/proguard/fieldmethod-dictionary.txt")
+
+        dontshrink()
+        dontoptimize()
+        printmapping("$buildDir/libs/proguard-$archName.map")
+    }
+}
+
+
+val createJavaInjectorComment by tasks.registering {
+    dependsOn(obfuscateProGuard)
+    doFirst {
+        val mainClassFile = File("$projectDir/mainclass.txt")
+        if (mainClassFile.exists()) {
+            mainClassFile.delete()
+        }
+
+        val jarTask = tasks.jar.get()
+        val mappingsText = File("$buildDir/libs/proguard-${jarTask.archiveFileName.get()}.map").readText()
+        val pattern = Pattern.compile("forgefuck\\.team\\.xenobyte\\.api\\.integration\\.JavaInjector -> (.*?):")
+        val matcher = pattern.matcher(mappingsText)
+
+        if (matcher.find()) {
+            File("$projectDir/mainclass.txt").writeText(matcher.group(1))
+        }
+
+    }
+}
+
+val copyJar by tasks.registering {
+    dependsOn(createJavaInjectorComment)
+    doFirst {
+        val jarTask = tasks.jar.get()
+        copy {
+            from("$buildDir/libs")
+            include("final-${jarTask.archiveFileName.get()}")
+            into("$buildDir/libs")
+            rename("final-${jarTask.archiveFileName.get()}", jarTask.archiveFileName.get())
+        }
+    }
+}
+
+tasks.named("reobfJar") {
+    dependsOn(copyJar)
+}

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
-#Wed Jul 02 15:54:47 CDT 2014
+#Wed Jun 25 14:48:15 MSK 2025
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.4.1-all.zip

settings.gradle.kts

@@ -0,0 +1,22 @@
+pluginManagement {
+    repositories {
+        maven {
+            name = "GTNH Maven"
+            url = uri("https://nexus.gtnewhorizons.com/repository/public/")
+            mavenContent {
+                includeGroupByRegex("com\\.gtnewhorizons\\..+")
+                includeGroup("com.gtnewhorizons")
+            }
+        }
+        gradlePluginPortal()
+        mavenCentral()
+        mavenLocal()
+    }
+}
+
+plugins {
+    id("org.gradle.toolchains.foojay-resolver-convention") version "0.8.0"
+}
+
+rootProject.name = "Xenobyte"
+