diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 0000000..4ffbd90
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,22 @@
+# This is the universal Text Editor Configuration
+# for all GTNewHorizons projects
+# See: https://editorconfig.org/
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.{bat,ini}]
+end_of_line = crlf
+
+[*.{dtd,json,info,mcmeta,md,sh,svg,xml,xsd,xsl,yaml,yml}]
+indent_size = 2
+
+[*.lang]
+trim_trailing_whitespace = false
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..fd2792b
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,44 @@
+* text eol=lf
+
+*.[jJ][aA][rR] binary
+
+*.[pP][nN][gG] binary
+*.[jJ][pP][gG] binary
+*.[jJ][pP][eE][gG] binary
+*.[gG][iI][fF] binary
+*.[tT][iI][fF] binary
+*.[tT][iI][fF][fF] binary
+*.[iI][cC][oO] binary
+*.[sS][vV][gG] text
+*.[eE][pP][sS] binary
+*.[xX][cC][fF] binary
+
+*.[kK][aA][rR] binary
+*.[mM]4[aA] binary
+*.[mM][iI][dD] binary
+*.[mM][iI][dD][iI] binary
+*.[mM][pP]3 binary
+*.[oO][gG][gG] binary
+*.[rR][aA] binary
+
+*.7[zZ] binary
+*.[gG][zZ] binary
+*.[tT][aA][rR] binary
+*.[tT][gG][zZ] binary
+*.[zZ][iI][pP] binary
+
+*.[tT][cC][nN] binary
+*.[sS][oO] binary
+*.[dD][lL][lL] binary
+*.[dD][yY][lL][iI][bB] binary
+*.[pP][sS][dD] binary
+*.[tT][tT][fF] binary
+*.[oO][tT][fF] binary
+
+*.[pP][aA][tT][cC][hH] -text
+
+*.[bB][aA][tT] text eol=crlf
+*.[cC][mM][dD] text eol=crlf
+*.[pP][sS]1 text eol=crlf
+
+*[aA][uU][tT][oO][gG][eE][nN][eE][rR][aA][tT][eE][dD]* binary
diff --git a/.github/workflows/build-and-test.yml b/.github/workflows/build-and-test.yml
new file mode 100644
index 0000000..3ee2f68
--- /dev/null
+++ b/.github/workflows/build-and-test.yml
@@ -0,0 +1,13 @@
+
+name: Build and test
+
+on:
+ pull_request:
+ branches: [ master, main ]
+ push:
+ branches: [ master, main ]
+
+jobs:
+ build-and-test:
+ uses: GTNewHorizons/GTNH-Actions-Workflows/.github/workflows/build-and-test.yml@master
+ secrets: inherit
diff --git a/.github/workflows/release-tags.yml b/.github/workflows/release-tags.yml
new file mode 100644
index 0000000..e4c0be6
--- /dev/null
+++ b/.github/workflows/release-tags.yml
@@ -0,0 +1,14 @@
+
+name: Release tagged build
+
+on:
+ push:
+ tags: [ '*' ]
+
+permissions:
+ contents: write
+
+jobs:
+ release-tags:
+ uses: GTNewHorizons/GTNH-Actions-Workflows/.github/workflows/release-tags.yml@master
+ secrets: inherit
diff --git a/.gradle/8.2.1/checksums/checksums.lock b/.gradle/8.2.1/checksums/checksums.lock
new file mode 100644
index 0000000..9ed7997
Binary files /dev/null and b/.gradle/8.2.1/checksums/checksums.lock differ
diff --git a/.gradle/8.2.1/checksums/md5-checksums.bin b/.gradle/8.2.1/checksums/md5-checksums.bin
new file mode 100644
index 0000000..a5ecc88
Binary files /dev/null and b/.gradle/8.2.1/checksums/md5-checksums.bin differ
diff --git a/.gradle/8.2.1/checksums/sha1-checksums.bin b/.gradle/8.2.1/checksums/sha1-checksums.bin
new file mode 100644
index 0000000..7f36816
Binary files /dev/null and b/.gradle/8.2.1/checksums/sha1-checksums.bin differ
diff --git a/.gradle/8.2.1/dependencies-accessors/dependencies-accessors.lock b/.gradle/8.2.1/dependencies-accessors/dependencies-accessors.lock
new file mode 100644
index 0000000..3233e13
Binary files /dev/null and b/.gradle/8.2.1/dependencies-accessors/dependencies-accessors.lock differ
diff --git a/.gradle/8.2.1/dependencies-accessors/gc.properties b/.gradle/8.2.1/dependencies-accessors/gc.properties
new file mode 100644
index 0000000..e69de29
diff --git a/.gradle/8.2.1/executionHistory/executionHistory.bin b/.gradle/8.2.1/executionHistory/executionHistory.bin
new file mode 100644
index 0000000..fe9a188
Binary files /dev/null and b/.gradle/8.2.1/executionHistory/executionHistory.bin differ
diff --git a/.gradle/8.2.1/executionHistory/executionHistory.lock b/.gradle/8.2.1/executionHistory/executionHistory.lock
new file mode 100644
index 0000000..bf0ce11
Binary files /dev/null and b/.gradle/8.2.1/executionHistory/executionHistory.lock differ
diff --git a/.gradle/8.2.1/fileChanges/last-build.bin b/.gradle/8.2.1/fileChanges/last-build.bin
new file mode 100644
index 0000000..f76dd23
Binary files /dev/null and b/.gradle/8.2.1/fileChanges/last-build.bin differ
diff --git a/.gradle/8.2.1/fileHashes/fileHashes.bin b/.gradle/8.2.1/fileHashes/fileHashes.bin
new file mode 100644
index 0000000..af528cf
Binary files /dev/null and b/.gradle/8.2.1/fileHashes/fileHashes.bin differ
diff --git a/.gradle/8.2.1/fileHashes/fileHashes.lock b/.gradle/8.2.1/fileHashes/fileHashes.lock
new file mode 100644
index 0000000..10b3436
Binary files /dev/null and b/.gradle/8.2.1/fileHashes/fileHashes.lock differ
diff --git a/.gradle/8.2.1/fileHashes/resourceHashesCache.bin b/.gradle/8.2.1/fileHashes/resourceHashesCache.bin
new file mode 100644
index 0000000..9aba2dc
Binary files /dev/null and b/.gradle/8.2.1/fileHashes/resourceHashesCache.bin differ
diff --git a/.gradle/8.2.1/gc.properties b/.gradle/8.2.1/gc.properties
new file mode 100644
index 0000000..e69de29
diff --git a/.gradle/buildOutputCleanup/buildOutputCleanup.lock b/.gradle/buildOutputCleanup/buildOutputCleanup.lock
new file mode 100644
index 0000000..aa39459
Binary files /dev/null and b/.gradle/buildOutputCleanup/buildOutputCleanup.lock differ
diff --git a/.gradle/buildOutputCleanup/cache.properties b/.gradle/buildOutputCleanup/cache.properties
new file mode 100644
index 0000000..af6eb81
--- /dev/null
+++ b/.gradle/buildOutputCleanup/cache.properties
@@ -0,0 +1,2 @@
+#Thu Nov 30 11:14:33 EET 2023
+gradle.version=8.2.1
diff --git a/.gradle/buildOutputCleanup/outputFiles.bin b/.gradle/buildOutputCleanup/outputFiles.bin
new file mode 100644
index 0000000..b74fede
Binary files /dev/null and b/.gradle/buildOutputCleanup/outputFiles.bin differ
diff --git a/.gradle/file-system.probe b/.gradle/file-system.probe
new file mode 100644
index 0000000..9ed0a92
Binary files /dev/null and b/.gradle/file-system.probe differ
diff --git a/.gradle/vcs-1/gc.properties b/.gradle/vcs-1/gc.properties
new file mode 100644
index 0000000..e69de29
diff --git a/.project b/.project
new file mode 100644
index 0000000..f8e61e3
--- /dev/null
+++ b/.project
@@ -0,0 +1,17 @@
+
+
+ CinderCore
+ Project CinderCore created by Buildship.
+
+
+
+
+ org.eclipse.buildship.core.gradleprojectbuilder
+
+
+
+
+
+ org.eclipse.buildship.core.gradleprojectnature
+
+
diff --git a/.settings/org.eclipse.buildship.core.prefs b/.settings/org.eclipse.buildship.core.prefs
new file mode 100644
index 0000000..702ab3d
--- /dev/null
+++ b/.settings/org.eclipse.buildship.core.prefs
@@ -0,0 +1,13 @@
+arguments=
+auto.sync=false
+build.scans.enabled=false
+connection.gradle.distribution=GRADLE_DISTRIBUTION(WRAPPER)
+connection.project.dir=
+eclipse.preferences.version=1
+gradle.user.home=/usr/share/java/gradle
+java.home=
+jvm.arguments=
+offline.mode=false
+override.workspace.settings=true
+show.console.view=true
+show.executions.view=true
diff --git a/CODEOWNERS b/CODEOWNERS
new file mode 100644
index 0000000..a6b5f68
--- /dev/null
+++ b/CODEOWNERS
@@ -0,0 +1,3 @@
+# Any Github changes require admin approval
+/.github/** @GTNewHorizons/admin
+
diff --git a/LICENSE-template b/LICENSE-template
new file mode 100644
index 0000000..242da62
--- /dev/null
+++ b/LICENSE-template
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/build.gradle b/build.gradle
new file mode 100644
index 0000000..00da70c
--- /dev/null
+++ b/build.gradle
@@ -0,0 +1,1625 @@
+//version: 1699290261
+/*
+ DO NOT CHANGE THIS FILE!
+ Also, you may replace this file at any time if there is an update available.
+ Please check https://github.com/GTNewHorizons/ExampleMod1.7.10/blob/master/build.gradle for updates.
+ */
+
+
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import com.gtnewhorizons.retrofuturagradle.ObfuscationAttribute
+import com.gtnewhorizons.retrofuturagradle.mcp.ReobfuscatedJar
+import com.gtnewhorizons.retrofuturagradle.minecraft.RunMinecraftTask
+import com.gtnewhorizons.retrofuturagradle.util.Distribution
+import com.matthewprenger.cursegradle.CurseArtifact
+import com.matthewprenger.cursegradle.CurseRelation
+import com.modrinth.minotaur.dependencies.ModDependency
+import com.modrinth.minotaur.dependencies.VersionDependency
+import org.gradle.internal.logging.text.StyledTextOutput.Style
+import org.gradle.internal.logging.text.StyledTextOutputFactory
+import org.gradle.internal.xml.XmlTransformer
+import org.jetbrains.gradle.ext.Application
+import org.jetbrains.gradle.ext.Gradle
+
+import javax.inject.Inject
+import java.nio.file.Files
+import java.nio.file.Paths
+import java.util.concurrent.TimeUnit
+
+buildscript {
+ repositories {
+ mavenCentral()
+
+ maven {
+ name 'forge'
+ url 'https://maven.minecraftforge.net'
+ }
+ maven {
+ // GTNH RetroFuturaGradle and ASM Fork
+ name "GTNH Maven"
+ url "http://jenkins.usrv.eu:8081/nexus/content/groups/public/"
+ allowInsecureProtocol = true
+ }
+ maven {
+ name 'sonatype'
+ url 'https://oss.sonatype.org/content/repositories/snapshots/'
+ }
+ maven {
+ name 'Scala CI dependencies'
+ url 'https://repo1.maven.org/maven2/'
+ }
+
+ mavenLocal()
+ }
+}
+plugins {
+ id 'java-library'
+ id "org.jetbrains.gradle.plugin.idea-ext" version "1.1.7"
+ id 'eclipse'
+ id 'scala'
+ id 'maven-publish'
+ id 'org.jetbrains.kotlin.jvm' version '1.8.0' apply false
+ id 'org.jetbrains.kotlin.kapt' version '1.8.0' apply false
+ id 'com.google.devtools.ksp' version '1.8.0-1.0.9' apply false
+ id 'org.ajoberstar.grgit' version '4.1.1' // 4.1.1 is the last jvm8 supporting version, unused, available for addon.gradle
+ id 'com.github.johnrengelman.shadow' version '8.1.1' apply false
+ id 'com.palantir.git-version' version '3.0.0' apply false
+ id 'de.undercouch.download' version '5.4.0'
+ id 'com.github.gmazzo.buildconfig' version '3.1.0' apply false // Unused, available for addon.gradle
+ id 'com.diffplug.spotless' version '6.13.0' apply false // 6.13.0 is the last jvm8 supporting version
+ id 'com.modrinth.minotaur' version '2.+' apply false
+ id 'com.matthewprenger.cursegradle' version '1.4.0' apply false
+ id 'com.gtnewhorizons.retrofuturagradle' version '1.3.24'
+}
+
+print("You might want to check out './gradlew :faq' if your build fails.\n")
+
+boolean settingsupdated = verifySettingsGradle()
+settingsupdated = verifyGitAttributes() || settingsupdated
+if (settingsupdated)
+ throw new GradleException("Settings has been updated, please re-run task.")
+
+// In submodules, .git is a file pointing to the real git dir
+if (project.file('.git/HEAD').isFile() || project.file('.git').isFile()) {
+ apply plugin: 'com.palantir.git-version'
+}
+
+def out = services.get(StyledTextOutputFactory).create('an-output')
+
+def projectJavaVersion = JavaLanguageVersion.of(8)
+
+boolean disableSpotless = project.hasProperty("disableSpotless") ? project.disableSpotless.toBoolean() : false
+boolean disableCheckstyle = project.hasProperty("disableCheckstyle") ? project.disableCheckstyle.toBoolean() : false
+
+final String CHECKSTYLE_CONFIG = """
+
+
+
+
+
+
+
+
+
+
+
+"""
+
+checkPropertyExists("modName")
+checkPropertyExists("modId")
+checkPropertyExists("modGroup")
+checkPropertyExists("autoUpdateBuildScript")
+checkPropertyExists("minecraftVersion")
+checkPropertyExists("forgeVersion")
+checkPropertyExists("replaceGradleTokenInFile")
+checkPropertyExists("gradleTokenVersion")
+checkPropertyExists("apiPackage")
+checkPropertyExists("accessTransformersFile")
+checkPropertyExists("usesMixins")
+checkPropertyExists("mixinPlugin")
+checkPropertyExists("mixinsPackage")
+checkPropertyExists("coreModClass")
+checkPropertyExists("containsMixinsAndOrCoreModOnly")
+checkPropertyExists("usesShadowedDependencies")
+checkPropertyExists("developmentEnvironmentUserName")
+
+propertyDefaultIfUnset("generateGradleTokenClass", "")
+propertyDefaultIfUnset("includeWellKnownRepositories", true)
+propertyDefaultIfUnset("noPublishedSources", false)
+propertyDefaultIfUnset("usesMixinDebug", project.usesMixins)
+propertyDefaultIfUnset("forceEnableMixins", false)
+propertyDefaultIfUnset("channel", "stable")
+propertyDefaultIfUnset("mappingsVersion", "12")
+propertyDefaultIfUnset("usesMavenPublishing", true)
+propertyDefaultIfUnset("mavenPublishUrl", "http://jenkins.usrv.eu:8081/nexus/content/repositories/releases")
+propertyDefaultIfUnset("modrinthProjectId", "")
+propertyDefaultIfUnset("modrinthRelations", "")
+propertyDefaultIfUnset("curseForgeProjectId", "")
+propertyDefaultIfUnset("curseForgeRelations", "")
+propertyDefaultIfUnset("minimizeShadowedDependencies", true)
+propertyDefaultIfUnset("relocateShadowedDependencies", true)
+// Deprecated properties (kept for backwards compat)
+propertyDefaultIfUnset("gradleTokenModId", "")
+propertyDefaultIfUnset("gradleTokenModName", "")
+propertyDefaultIfUnset("gradleTokenGroupName", "")
+
+propertyDefaultIfUnset("enableModernJavaSyntax", false) // On by default for new projects only
+propertyDefaultIfUnset("enableGenericInjection", false) // On by default for new projects only
+
+// this is meant to be set using the user wide property file. by default we do nothing.
+propertyDefaultIfUnset("ideaOverrideBuildType", "") // Can be nothing, "gradle" or "idea"
+
+project.extensions.add(com.diffplug.blowdryer.Blowdryer, "Blowdryer", com.diffplug.blowdryer.Blowdryer) // Make blowdryer available in "apply from:" scripts
+if (!disableSpotless) {
+ apply plugin: 'com.diffplug.spotless'
+ apply from: Blowdryer.file('spotless.gradle')
+}
+
+if (!disableCheckstyle) {
+ apply plugin: 'checkstyle'
+ tasks.named("checkstylePatchedMc") { enabled = false }
+ tasks.named("checkstyleMcLauncher") { enabled = false }
+ tasks.named("checkstyleIdeVirtualMain") { enabled = false }
+ tasks.named("checkstyleInjectedTags") { enabled = false }
+ checkstyle {
+ config = resources.text.fromString(CHECKSTYLE_CONFIG)
+ }
+}
+
+String javaSourceDir = "src/main/java/"
+String scalaSourceDir = "src/main/scala/"
+String kotlinSourceDir = "src/main/kotlin/"
+
+if (usesShadowedDependencies.toBoolean()) {
+ apply plugin: "com.github.johnrengelman.shadow"
+}
+
+java {
+ toolchain {
+ if (enableModernJavaSyntax.toBoolean()) {
+ languageVersion.set(JavaLanguageVersion.of(17))
+ } else {
+ languageVersion.set(projectJavaVersion)
+ }
+ vendor.set(JvmVendorSpec.AZUL)
+ }
+ if (!noPublishedSources) {
+ withSourcesJar()
+ }
+}
+
+tasks.withType(JavaCompile).configureEach {
+ options.encoding = "UTF-8"
+}
+
+tasks.withType(ScalaCompile).configureEach {
+ options.encoding = "UTF-8"
+}
+
+pluginManager.withPlugin('org.jetbrains.kotlin.jvm') {
+ // If Kotlin is enabled in the project
+ kotlin {
+ jvmToolchain(8)
+ }
+ // Kotlin hacks our source sets, so we hack Kotlin's tasks
+ def disabledKotlinTaskList = [
+ "kaptGenerateStubsMcLauncherKotlin",
+ "kaptGenerateStubsPatchedMcKotlin",
+ "kaptGenerateStubsInjectedTagsKotlin",
+ "compileMcLauncherKotlin",
+ "compilePatchedMcKotlin",
+ "compileInjectedTagsKotlin",
+ "kaptMcLauncherKotlin",
+ "kaptPatchedMcKotlin",
+ "kaptInjectedTagsKotlin",
+ "kspMcLauncherKotlin",
+ "kspPatchedMcKotlin",
+ "kspInjectedTagsKotlin",
+ ]
+ tasks.configureEach { task ->
+ if (task.name in disabledKotlinTaskList) {
+ task.enabled = false
+ }
+ }
+}
+
+configurations {
+ create("runtimeOnlyNonPublishable") {
+ description = "Runtime only dependencies that are not published alongside the jar"
+ canBeConsumed = false
+ canBeResolved = false
+ }
+
+ create("devOnlyNonPublishable") {
+ description = "Runtime and compiletime dependencies that are not published alongside the jar (compileOnly + runtimeOnlyNonPublishable)"
+ canBeConsumed = false
+ canBeResolved = false
+ }
+ compileOnly.extendsFrom(devOnlyNonPublishable)
+ runtimeOnlyNonPublishable.extendsFrom(devOnlyNonPublishable)
+}
+
+if (enableModernJavaSyntax.toBoolean()) {
+ repositories {
+ mavenCentral {
+ mavenContent {
+ includeGroup("me.eigenraven.java8unsupported")
+ }
+ }
+ }
+
+ dependencies {
+ annotationProcessor 'com.github.bsideup.jabel:jabel-javac-plugin:1.0.0'
+ // workaround for https://github.com/bsideup/jabel/issues/174
+ annotationProcessor 'net.java.dev.jna:jna-platform:5.13.0'
+ compileOnly('com.github.bsideup.jabel:jabel-javac-plugin:1.0.0') {
+ transitive = false // We only care about the 1 annotation class
+ }
+ // Allow using jdk.unsupported classes like sun.misc.Unsafe in the compiled code, working around JDK-8206937.
+ patchedMinecraft('me.eigenraven.java8unsupported:java-8-unsupported-shim:1.0.0')
+ }
+
+ tasks.withType(JavaCompile).configureEach {
+ if (it.name in ["compileMcLauncherJava", "compilePatchedMcJava"]) {
+ return
+ }
+ sourceCompatibility = 17 // for the IDE support
+ options.release.set(8)
+
+ javaCompiler.set(javaToolchains.compilerFor {
+ languageVersion.set(JavaLanguageVersion.of(17))
+ vendor.set(JvmVendorSpec.AZUL)
+ })
+ }
+}
+
+eclipse {
+ classpath {
+ downloadSources = true
+ downloadJavadoc = true
+ }
+}
+
+final String modGroupPath = modGroup.toString().replace('.' as char, '/' as char)
+final String apiPackagePath = apiPackage.toString().replace('.' as char, '/' as char)
+
+String targetPackageJava = javaSourceDir + modGroupPath
+String targetPackageScala = scalaSourceDir + modGroupPath
+String targetPackageKotlin = kotlinSourceDir + modGroupPath
+if (!(getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists() || getFile(targetPackageKotlin).exists())) {
+ throw new GradleException("Could not resolve \"modGroup\"! Could not find " + targetPackageJava + " or " + targetPackageScala + " or " + targetPackageKotlin)
+}
+
+if (apiPackage) {
+ targetPackageJava = javaSourceDir + modGroupPath + "/" + apiPackagePath
+ targetPackageScala = scalaSourceDir + modGroupPath + "/" + apiPackagePath
+ targetPackageKotlin = kotlinSourceDir + modGroupPath + "/" + apiPackagePath
+ if (!(getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists() || getFile(targetPackageKotlin).exists())) {
+ throw new GradleException("Could not resolve \"apiPackage\"! Could not find " + targetPackageJava + " or " + targetPackageScala + " or " + targetPackageKotlin)
+ }
+}
+
+if (accessTransformersFile) {
+ for (atFile in accessTransformersFile.split(" ")) {
+ String targetFile = "src/main/resources/META-INF/" + atFile.trim()
+ if (!getFile(targetFile).exists()) {
+ throw new GradleException("Could not resolve \"accessTransformersFile\"! Could not find " + targetFile)
+ }
+ tasks.deobfuscateMergedJarToSrg.accessTransformerFiles.from(targetFile)
+ tasks.srgifyBinpatchedJar.accessTransformerFiles.from(targetFile)
+ }
+} else {
+ boolean atsFound = false
+ for (File at : sourceSets.getByName("main").resources.files) {
+ if (at.name.toLowerCase().endsWith("_at.cfg")) {
+ atsFound = true
+ tasks.deobfuscateMergedJarToSrg.accessTransformerFiles.from(at)
+ tasks.srgifyBinpatchedJar.accessTransformerFiles.from(at)
+ }
+ }
+ for (File at : sourceSets.getByName("api").resources.files) {
+ if (at.name.toLowerCase().endsWith("_at.cfg")) {
+ atsFound = true
+ tasks.deobfuscateMergedJarToSrg.accessTransformerFiles.from(at)
+ tasks.srgifyBinpatchedJar.accessTransformerFiles.from(at)
+ }
+ }
+ if (atsFound) {
+ logger.warn("Found and added access transformers in the resources folder, please configure gradle.properties to explicitly mention them by name")
+ }
+}
+
+if (usesMixins.toBoolean()) {
+ if (mixinsPackage.isEmpty()) {
+ throw new GradleException("\"usesMixins\" requires \"mixinsPackage\" to be set!")
+ }
+ final String mixinPackagePath = mixinsPackage.toString().replaceAll("\\.", "/")
+ final String mixinPluginPath = mixinPlugin.toString().replaceAll("\\.", "/")
+
+ targetPackageJava = javaSourceDir + modGroupPath + "/" + mixinPackagePath
+ targetPackageScala = scalaSourceDir + modGroupPath + "/" + mixinPackagePath
+ targetPackageKotlin = kotlinSourceDir + modGroupPath + "/" + mixinPackagePath
+ if (!(getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists() || getFile(targetPackageKotlin).exists())) {
+ throw new GradleException("Could not resolve \"mixinsPackage\"! Could not find " + targetPackageJava + " or " + targetPackageScala + " or " + targetPackageKotlin)
+ }
+
+ if (!mixinPlugin.isEmpty()) {
+ String targetFileJava = javaSourceDir + modGroupPath + "/" + mixinPluginPath + ".java"
+ String targetFileScala = scalaSourceDir + modGroupPath + "/" + mixinPluginPath + ".scala"
+ String targetFileScalaJava = scalaSourceDir + modGroupPath + "/" + mixinPluginPath + ".java"
+ String targetFileKotlin = kotlinSourceDir + modGroupPath + "/" + mixinPluginPath + ".kt"
+ if (!(getFile(targetFileJava).exists() || getFile(targetFileScala).exists() || getFile(targetFileScalaJava).exists() || getFile(targetFileKotlin).exists())) {
+ throw new GradleException("Could not resolve \"mixinPlugin\"! Could not find " + targetFileJava + " or " + targetFileScala + " or " + targetFileScalaJava + " or " + targetFileKotlin)
+ }
+ }
+}
+
+if (coreModClass) {
+ final String coreModPath = coreModClass.toString().replaceAll("\\.", "/")
+ String targetFileJava = javaSourceDir + modGroupPath + "/" + coreModPath + ".java"
+ String targetFileScala = scalaSourceDir + modGroupPath + "/" + coreModPath + ".scala"
+ String targetFileScalaJava = scalaSourceDir + modGroupPath + "/" + coreModPath + ".java"
+ String targetFileKotlin = kotlinSourceDir + modGroupPath + "/" + coreModPath + ".kt"
+ if (!(getFile(targetFileJava).exists() || getFile(targetFileScala).exists() || getFile(targetFileScalaJava).exists() || getFile(targetFileKotlin).exists())) {
+ throw new GradleException("Could not resolve \"coreModClass\"! Could not find " + targetFileJava + " or " + targetFileScala + " or " + targetFileScalaJava + " or " + targetFileKotlin)
+ }
+}
+
+configurations.configureEach {
+ resolutionStrategy.cacheChangingModulesFor(0, TimeUnit.SECONDS)
+
+ // Make sure GregTech build won't time out
+ System.setProperty("org.gradle.internal.http.connectionTimeout", 120000 as String)
+ System.setProperty("org.gradle.internal.http.socketTimeout", 120000 as String)
+}
+
+// Fix Jenkins' Git: chmod a file should not be detected as a change and append a '.dirty' to the version
+try {
+ 'git config core.fileMode false'.execute()
+}
+catch (Exception ignored) {
+ out.style(Style.Failure).println("git isn't installed at all")
+}
+
+// Pulls version first from the VERSION env and then git tag
+String identifiedVersion
+String versionOverride = System.getenv("VERSION") ?: null
+try {
+ // Produce a version based on the tag, or for branches something like 0.2.2-configurable-maven-and-extras.38+43090270b6-dirty
+ if (versionOverride == null) {
+ def gitDetails = versionDetails()
+ def isDirty = gitVersion().endsWith(".dirty") // No public API for this, isCleanTag has a different meaning
+ String branchName = gitDetails.branchName ?: (System.getenv('GIT_BRANCH') ?: 'git')
+ if (branchName.startsWith('origin/')) {
+ branchName = branchName.minus('origin/')
+ }
+ branchName = branchName.replaceAll("[^a-zA-Z0-9-]+", "-") // sanitize branch names for semver
+ identifiedVersion = gitDetails.lastTag ?: '${gitDetails.gitHash}'
+ if (gitDetails.commitDistance > 0) {
+ identifiedVersion += "-${branchName}.${gitDetails.commitDistance}+${gitDetails.gitHash}"
+ if (isDirty) {
+ identifiedVersion += "-dirty"
+ }
+ } else if (isDirty) {
+ identifiedVersion += "-${branchName}+${gitDetails.gitHash}-dirty"
+ }
+ } else {
+ identifiedVersion = versionOverride
+ }
+}
+catch (Exception ignored) {
+ out.style(Style.Failure).text(
+ 'This mod must be version controlled by Git AND the repository must provide at least one tag,\n' +
+ 'or the VERSION override must be set! ').style(Style.SuccessHeader).text('(Do NOT download from GitHub using the ZIP option, instead\n' +
+ 'clone the repository, see ').style(Style.Info).text('https://gtnh.miraheze.org/wiki/Development').style(Style.SuccessHeader).println(' for details.)'
+ )
+ versionOverride = '1.0'
+ identifiedVersion = versionOverride
+}
+version = identifiedVersion
+ext {
+ modVersion = identifiedVersion
+}
+
+if (identifiedVersion == versionOverride) {
+ out.style(Style.Failure).text('Override version to ').style(Style.Identifier).text(modVersion).style(Style.Failure).println('!\7')
+}
+
+group = "com.github.GTNewHorizons"
+if (project.hasProperty("customArchiveBaseName") && customArchiveBaseName) {
+ base {
+ archivesName = customArchiveBaseName
+ }
+} else {
+ base {
+ archivesName = modId
+ }
+}
+
+
+minecraft {
+ if (replaceGradleTokenInFile) {
+ for (f in replaceGradleTokenInFile.split(',')) {
+ tagReplacementFiles.add f
+ }
+ }
+ if (gradleTokenModId) {
+ injectedTags.put gradleTokenModId, modId
+ }
+ if (gradleTokenModName) {
+ injectedTags.put gradleTokenModName, modName
+ }
+ if (gradleTokenVersion) {
+ injectedTags.put gradleTokenVersion, modVersion
+ }
+ if (gradleTokenGroupName) {
+ injectedTags.put gradleTokenGroupName, modGroup
+ }
+ if (enableGenericInjection.toBoolean()) {
+ injectMissingGenerics.set(true)
+ }
+
+ username = developmentEnvironmentUserName.toString()
+
+ lwjgl3Version = "3.3.2"
+
+ // Enable assertions in the current mod
+ extraRunJvmArguments.add("-ea:${modGroup}")
+
+ if (usesMixins.toBoolean() || forceEnableMixins.toBoolean()) {
+ if (usesMixinDebug.toBoolean()) {
+ extraRunJvmArguments.addAll([
+ "-Dmixin.debug.countInjections=true",
+ "-Dmixin.debug.verbose=true",
+ "-Dmixin.debug.export=true"
+ ])
+ }
+ }
+
+ // Blowdryer is present in some old mod builds, do not propagate it further as a dependency
+ // IC2 has no reobf jars in its Maven
+ groupsToExcludeFromAutoReobfMapping.addAll(["com.diffplug", "com.diffplug.durian", "net.industrial-craft"])
+}
+
+if (generateGradleTokenClass) {
+ tasks.injectTags.outputClassName.set(generateGradleTokenClass)
+}
+
+// Custom reobf auto-mappings
+configurations.configureEach {
+ dependencies.configureEach { dep ->
+ if (dep instanceof org.gradle.api.artifacts.ExternalModuleDependency) {
+ if (dep.group == "net.industrial-craft" && dep.name == "industrialcraft-2") {
+ // https://www.curseforge.com/minecraft/mc-mods/industrial-craft/files/2353971
+ project.dependencies.reobfJarConfiguration("curse.maven:ic2-242638:2353971")
+ }
+ }
+ }
+ def obfuscationAttr = it.attributes.getAttribute(ObfuscationAttribute.OBFUSCATION_ATTRIBUTE)
+ if (obfuscationAttr != null && obfuscationAttr.name == ObfuscationAttribute.SRG) {
+ resolutionStrategy.eachDependency { DependencyResolveDetails details ->
+ // Remap CoFH core cursemaven dev jar to the obfuscated version for runObfClient/Server
+ if (details.requested.group == 'curse.maven' && details.requested.name.endsWith('-69162') && details.requested.version == '2388751') {
+ details.useVersion '2388750'
+ details.because 'Pick obfuscated jar'
+ }
+ }
+ }
+}
+
+// Ensure tests have access to minecraft classes
+sourceSets {
+ test {
+ java {
+ compileClasspath += sourceSets.patchedMc.output + sourceSets.mcLauncher.output
+ runtimeClasspath += sourceSets.patchedMc.output + sourceSets.mcLauncher.output
+ }
+ }
+}
+
+if (file('addon.gradle.kts').exists()) {
+ apply from: 'addon.gradle.kts'
+} else if (file('addon.gradle').exists()) {
+ apply from: 'addon.gradle'
+}
+
+// File for local tweaks not commited to Git
+if (file('addon.local.gradle.kts').exists()) {
+ apply from: 'addon.local.gradle.kts'
+} else if (file('addon.local.gradle').exists()) {
+ apply from: 'addon.local.gradle'
+}
+
+// Allow unsafe repos but warn
+repositories.configureEach { repo ->
+ if (repo instanceof org.gradle.api.artifacts.repositories.UrlArtifactRepository) {
+ if (repo.getUrl() != null && repo.getUrl().getScheme() == "http" && !repo.allowInsecureProtocol) {
+ logger.warn("Deprecated: Allowing insecure connections for repo '${repo.name}' - add 'allowInsecureProtocol = true'")
+ repo.allowInsecureProtocol = true
+ }
+ }
+}
+
+if (file('repositories.gradle.kts').exists()) {
+ apply from: 'repositories.gradle.kts'
+} else if (file('repositories.gradle').exists()) {
+ apply from: 'repositories.gradle'
+} else {
+ logger.error("Neither repositories.gradle.kts nor repositories.gradle was found, make sure you extracted the full ExampleMod template.")
+ throw new RuntimeException("Missing repositories.gradle[.kts]")
+}
+
+configurations {
+ runtimeClasspath.extendsFrom(runtimeOnlyNonPublishable)
+ testRuntimeClasspath.extendsFrom(runtimeOnlyNonPublishable)
+ for (config in [compileClasspath, runtimeClasspath, testCompileClasspath, testRuntimeClasspath]) {
+ if (usesShadowedDependencies.toBoolean()) {
+ config.extendsFrom(shadowImplementation)
+ // TODO: remove Compile after all uses are refactored to Implementation
+ config.extendsFrom(shadeCompile)
+ config.extendsFrom(shadowCompile)
+ }
+ }
+ // A "bag-of-dependencies"-style configuration for backwards compatibility, gets put in "api"
+ create("compile") {
+ description = "Deprecated: use api or implementation instead, gets put in api"
+ canBeConsumed = false
+ canBeResolved = false
+ visible = false
+ }
+ create("testCompile") {
+ description = "Deprecated: use testImplementation instead"
+ canBeConsumed = false
+ canBeResolved = false
+ visible = false
+ }
+ api.extendsFrom(compile)
+ testImplementation.extendsFrom(testCompile)
+}
+
+afterEvaluate {
+ if (!configurations.compile.allDependencies.empty || !configurations.testCompile.allDependencies.empty) {
+ logger.warn("This project uses deprecated `compile` dependencies, please migrate to using `api` and `implementation`")
+ logger.warn("For more details, see https://github.com/GTNewHorizons/ExampleMod1.7.10/blob/master/dependencies.gradle")
+ }
+}
+
+repositories {
+ maven {
+ name 'Overmind forge repo mirror'
+ url 'https://gregtech.overminddl1.com/'
+ }
+ maven {
+ name = "GTNH Maven"
+ url = "http://jenkins.usrv.eu:8081/nexus/content/groups/public/"
+ allowInsecureProtocol = true
+ }
+ maven {
+ name 'sonatype'
+ url 'https://oss.sonatype.org/content/repositories/snapshots/'
+ content {
+ includeGroup "org.lwjgl"
+ }
+ }
+ if (includeWellKnownRepositories.toBoolean()) {
+ exclusiveContent {
+ forRepository {
+ maven {
+ name "CurseMaven"
+ url "https://cursemaven.com"
+ }
+ }
+ filter {
+ includeGroup "curse.maven"
+ }
+ }
+ exclusiveContent {
+ forRepository {
+ maven {
+ name = "Modrinth"
+ url = "https://api.modrinth.com/maven"
+ }
+ }
+ filter {
+ includeGroup "maven.modrinth"
+ }
+ }
+ maven {
+ name = "ic2"
+ url = getURL("https://maven.ic2.player.to/", "https://maven2.ic2.player.to/")
+ content {
+ includeGroup "net.industrial-craft"
+ }
+ metadataSources {
+ mavenPom()
+ artifact()
+ }
+ }
+ maven {
+ name "MMD Maven"
+ url "https://maven.mcmoddev.com/"
+ }
+ }
+}
+
+def mixinProviderGroup = "io.github.legacymoddingmc"
+def mixinProviderModule = "unimixins"
+def mixinProviderVersion = "0.1.16" // Original version: 0.1.13
+def mixinProviderSpecNoClassifer = "${mixinProviderGroup}:${mixinProviderModule}:${mixinProviderVersion}"
+def mixinProviderSpec = "${mixinProviderSpecNoClassifer}:dev"
+ext.mixinProviderSpec = mixinProviderSpec
+
+def mixingConfigRefMap = 'mixins.' + modId + '.refmap.json'
+
+dependencies {
+ if (usesMixins.toBoolean()) {
+ annotationProcessor('org.ow2.asm:asm-debug-all:5.0.3')
+ annotationProcessor('com.google.guava:guava:24.1.1-jre')
+ annotationProcessor('com.google.code.gson:gson:2.8.6')
+ annotationProcessor(mixinProviderSpec)
+ if (usesMixinDebug.toBoolean()) {
+ runtimeOnlyNonPublishable('org.jetbrains:intellij-fernflower:1.2.1.16')
+ }
+ }
+ if (usesMixins.toBoolean()) {
+ implementation(modUtils.enableMixins(mixinProviderSpec, mixingConfigRefMap))
+ } else if (forceEnableMixins.toBoolean()) {
+ runtimeOnlyNonPublishable(mixinProviderSpec)
+ }
+}
+
+pluginManager.withPlugin('org.jetbrains.kotlin.kapt') {
+ if (usesMixins.toBoolean()) {
+ dependencies {
+ kapt(mixinProviderSpec)
+ }
+ }
+}
+
+// Replace old mixin mods with unimixins
+// https://docs.gradle.org/8.0.2/userguide/resolution_rules.html#sec:substitution_with_classifier
+configurations.all {
+ resolutionStrategy.dependencySubstitution {
+ substitute module('com.gtnewhorizon:gtnhmixins') using module(mixinProviderSpecNoClassifer) withClassifier("dev") because("Unimixins replaces other mixin mods")
+ substitute module('com.github.GTNewHorizons:Mixingasm') using module(mixinProviderSpecNoClassifer) withClassifier("dev") because("Unimixins replaces other mixin mods")
+ substitute module('com.github.GTNewHorizons:SpongePoweredMixin') using module(mixinProviderSpecNoClassifer) withClassifier("dev") because("Unimixins replaces other mixin mods")
+ substitute module('com.github.GTNewHorizons:SpongeMixins') using module(mixinProviderSpecNoClassifer) withClassifier("dev") because("Unimixins replaces other mixin mods")
+ substitute module('io.github.legacymoddingmc:unimixins') using module(mixinProviderSpecNoClassifer) withClassifier("dev") because("Our previous unimixins upload was missing the dev classifier")
+ }
+}
+
+dependencies {
+ constraints {
+ def minGtnhLibVersion = "0.0.13"
+ implementation("com.github.GTNewHorizons:GTNHLib:${minGtnhLibVersion}") {
+ because("fixes duplicate mod errors in java 17 configurations using old gtnhlib")
+ }
+ runtimeOnly("com.github.GTNewHorizons:GTNHLib:${minGtnhLibVersion}") {
+ because("fixes duplicate mod errors in java 17 configurations using old gtnhlib")
+ }
+ devOnlyNonPublishable("com.github.GTNewHorizons:GTNHLib:${minGtnhLibVersion}") {
+ because("fixes duplicate mod errors in java 17 configurations using old gtnhlib")
+ }
+ runtimeOnlyNonPublishable("com.github.GTNewHorizons:GTNHLib:${minGtnhLibVersion}") {
+ because("fixes duplicate mod errors in java 17 configurations using old gtnhlib")
+ }
+ }
+}
+
+if (file('dependencies.gradle.kts').exists()) {
+ apply from: 'dependencies.gradle.kts'
+} else if (file('dependencies.gradle').exists()) {
+ apply from: 'dependencies.gradle'
+} else {
+ logger.error("Neither dependencies.gradle.kts nor dependencies.gradle was found, make sure you extracted the full ExampleMod template.")
+ throw new RuntimeException("Missing dependencies.gradle[.kts]")
+}
+
+tasks.register('generateAssets') {
+ group = "GTNH Buildscript"
+ description = "Generates a mixin config file at /src/main/resources/mixins.modid.json if needed"
+ onlyIf { usesMixins.toBoolean() }
+ doLast {
+ def mixinConfigFile = getFile("/src/main/resources/mixins." + modId + ".json")
+ if (!mixinConfigFile.exists()) {
+ def mixinPluginLine = ""
+ if (!mixinPlugin.isEmpty()) {
+ // We might not have a mixin plugin if we're using early/late mixins
+ mixinPluginLine += """\n "plugin": "${modGroup}.${mixinPlugin}", """
+ }
+
+ mixinConfigFile.text = """{
+ "required": true,
+ "minVersion": "0.8.5-GTNH",
+ "package": "${modGroup}.${mixinsPackage}",${mixinPluginLine}
+ "refmap": "${mixingConfigRefMap}",
+ "target": "@env(DEFAULT)",
+ "compatibilityLevel": "JAVA_8",
+ "mixins": [],
+ "client": [],
+ "server": []
+}
+"""
+ }
+ }
+}
+
+if (usesMixins.toBoolean()) {
+ tasks.named("processResources").configure {
+ dependsOn("generateAssets")
+ }
+
+ tasks.named("compileJava", JavaCompile).configure {
+ options.compilerArgs += [
+ // Elan: from what I understand they are just some linter configs so you get some warning on how to properly code
+ "-XDenableSunApiLintControl",
+ "-XDignore.symbol.file"
+ ]
+ }
+}
+
+tasks.named("processResources", ProcessResources).configure {
+ duplicatesStrategy = DuplicatesStrategy.INCLUDE
+
+ // this will ensure that this task is redone when the versions change.
+ inputs.property "version", project.version
+ inputs.property "mcversion", project.minecraft.mcVersion
+ exclude("spotless.gradle")
+
+ // replace stuff in mcmod.info, nothing else. replaces ${key} with value in text
+ filesMatching("mcmod.info") {
+ expand "minecraftVersion": project.minecraft.mcVersion,
+ "modVersion": modVersion,
+ "modId": modId,
+ "modName": modName
+ }
+
+ if (usesMixins.toBoolean()) {
+ dependsOn("compileJava", "compileScala")
+ }
+}
+
+ext.java17Toolchain = (JavaToolchainSpec spec) -> {
+ spec.languageVersion.set(JavaLanguageVersion.of(17))
+ spec.vendor.set(JvmVendorSpec.matching("jetbrains"))
+}
+
+ext.java17DependenciesCfg = configurations.create("java17Dependencies") {
+ extendsFrom(configurations.getByName("runtimeClasspath")) // Ensure consistent transitive dependency resolution
+ canBeConsumed = false
+}
+ext.java17PatchDependenciesCfg = configurations.create("java17PatchDependencies") {
+ canBeConsumed = false
+}
+
+dependencies {
+ def lwjgl3ifyVersion = '1.5.1'
+ if (modId != 'lwjgl3ify') {
+ java17Dependencies("com.github.GTNewHorizons:lwjgl3ify:${lwjgl3ifyVersion}")
+ }
+ if (modId != 'hodgepodge') {
+ java17Dependencies('com.github.GTNewHorizons:Hodgepodge:2.3.17')
+ }
+
+ java17PatchDependencies("com.github.GTNewHorizons:lwjgl3ify:${lwjgl3ifyVersion}:forgePatches") {transitive = false}
+}
+
+ext.java17JvmArgs = [
+ // Java 9+ support
+ "--illegal-access=warn",
+ "-Djava.security.manager=allow",
+ "-Dfile.encoding=UTF-8",
+ "--add-opens", "java.base/jdk.internal.loader=ALL-UNNAMED",
+ "--add-opens", "java.base/java.net=ALL-UNNAMED",
+ "--add-opens", "java.base/java.nio=ALL-UNNAMED",
+ "--add-opens", "java.base/java.io=ALL-UNNAMED",
+ "--add-opens", "java.base/java.lang=ALL-UNNAMED",
+ "--add-opens", "java.base/java.lang.reflect=ALL-UNNAMED",
+ "--add-opens", "java.base/java.text=ALL-UNNAMED",
+ "--add-opens", "java.base/java.util=ALL-UNNAMED",
+ "--add-opens", "java.base/jdk.internal.reflect=ALL-UNNAMED",
+ "--add-opens", "java.base/sun.nio.ch=ALL-UNNAMED",
+ "--add-opens", "jdk.naming.dns/com.sun.jndi.dns=ALL-UNNAMED,java.naming",
+ "--add-opens", "java.desktop/sun.awt.image=ALL-UNNAMED",
+ "--add-modules", "jdk.dynalink",
+ "--add-opens", "jdk.dynalink/jdk.dynalink.beans=ALL-UNNAMED",
+ "--add-modules", "java.sql.rowset",
+ "--add-opens", "java.sql.rowset/javax.sql.rowset.serial=ALL-UNNAMED"
+]
+
+ext.hotswapJvmArgs = [
+ // DCEVM advanced hot reload
+ "-XX:+AllowEnhancedClassRedefinition",
+ "-XX:HotswapAgent=fatjar"
+]
+
+ext.setupHotswapAgentTask = tasks.register("setupHotswapAgent") {
+ group = "GTNH Buildscript"
+ description = "Installs a recent version of HotSwapAgent into the Java 17 JetBrains runtime directory"
+ def hsaUrl = 'https://github.com/HotswapProjects/HotswapAgent/releases/download/1.4.2-SNAPSHOT/hotswap-agent-1.4.2-SNAPSHOT.jar'
+ def targetFolderProvider = javaToolchains.launcherFor(java17Toolchain).map {it.metadata.installationPath.dir("lib/hotswap")}
+ def targetFilename = "hotswap-agent.jar"
+ onlyIf {
+ !targetFolderProvider.get().file(targetFilename).asFile.exists()
+ }
+ doLast {
+ def targetFolder = targetFolderProvider.get()
+ targetFolder.asFile.mkdirs()
+ download.run {
+ src hsaUrl
+ dest targetFolder.file(targetFilename).asFile
+ overwrite false
+ tempAndMove true
+ }
+ }
+}
+
+public abstract class RunHotswappableMinecraftTask extends RunMinecraftTask {
+ // IntelliJ doesn't seem to allow commandline arguments so we also support an env variable
+ private boolean enableHotswap = Boolean.valueOf(System.getenv("HOTSWAP"));
+
+ @Input
+ public boolean getEnableHotswap() { return enableHotswap }
+ @Option(option = "hotswap", description = "Enables HotSwapAgent for enhanced class reloading under a debugger")
+ public boolean setEnableHotswap(boolean enable) { enableHotswap = enable }
+
+ @Inject
+ public RunHotswappableMinecraftTask(Distribution side, String superTask, org.gradle.api.invocation.Gradle gradle) {
+ super(side, gradle)
+
+ this.lwjglVersion = 3
+ this.javaLauncher = project.javaToolchains.launcherFor(project.java17Toolchain)
+ this.extraJvmArgs.addAll(project.java17JvmArgs)
+ this.extraJvmArgs.addAll(project.provider(() -> enableHotswap ? project.hotswapJvmArgs : []))
+
+ this.classpath(project.java17PatchDependenciesCfg)
+ if (side == Distribution.CLIENT) {
+ this.classpath(project.minecraftTasks.lwjgl3Configuration)
+ }
+ // Use a raw provider instead of map to not create a dependency on the task
+ this.classpath(project.provider(() -> project.tasks.named(superTask, RunMinecraftTask).get().classpath))
+ this.classpath.filter { file ->
+ !file.path.contains("2.9.4-nightly-20150209") // Remove lwjgl2
+ }
+ this.classpath(project.java17DependenciesCfg)
+ }
+
+ public void setup(Project project) {
+ super.setup(project)
+ if (project.usesMixins.toBoolean()) {
+ this.extraJvmArgs.addAll(project.provider(() -> {
+ def mixinCfg = project.configurations.detachedConfiguration(project.dependencies.create(project.mixinProviderSpec))
+ mixinCfg.canBeConsumed = false
+ mixinCfg.transitive = false
+ enableHotswap ? ["-javaagent:" + mixinCfg.singleFile.absolutePath] : []
+ }))
+ }
+ }
+}
+
+def runClient17Task = tasks.register("runClient17", RunHotswappableMinecraftTask, Distribution.CLIENT, "runClient")
+runClient17Task.configure {
+ setup(project)
+ group = "Modded Minecraft"
+ description = "Runs the modded client using Java 17, lwjgl3ify and Hodgepodge"
+ dependsOn(setupHotswapAgentTask, mcpTasks.launcherSources.classesTaskName, minecraftTasks.taskDownloadVanillaAssets, mcpTasks.taskPackagePatchedMc, 'jar')
+ mainClass = "GradleStart"
+ username = minecraft.username
+ userUUID = minecraft.userUUID
+}
+
+def runServer17Task = tasks.register("runServer17", RunHotswappableMinecraftTask, Distribution.DEDICATED_SERVER, "runServer")
+runServer17Task.configure {
+ setup(project)
+ group = "Modded Minecraft"
+ description = "Runs the modded server using Java 17, lwjgl3ify and Hodgepodge"
+ dependsOn(setupHotswapAgentTask, mcpTasks.launcherSources.classesTaskName, minecraftTasks.taskDownloadVanillaAssets, mcpTasks.taskPackagePatchedMc, 'jar')
+ mainClass = "GradleStartServer"
+ extraArgs.add("nogui")
+}
+
+def getManifestAttributes() {
+ def manifestAttributes = [:]
+ if (!containsMixinsAndOrCoreModOnly.toBoolean() && (usesMixins.toBoolean() || coreModClass)) {
+ manifestAttributes += ["FMLCorePluginContainsFMLMod": true]
+ }
+
+ if (accessTransformersFile) {
+ manifestAttributes += ["FMLAT": accessTransformersFile.toString()]
+ }
+
+ if (coreModClass) {
+ manifestAttributes += ["FMLCorePlugin": modGroup + "." + coreModClass]
+ }
+
+ if (usesMixins.toBoolean()) {
+ manifestAttributes += [
+ "TweakClass" : "org.spongepowered.asm.launch.MixinTweaker",
+ "MixinConfigs" : "mixins." + modId + ".json",
+ "ForceLoadAsMod": !containsMixinsAndOrCoreModOnly.toBoolean()
+ ]
+ }
+ return manifestAttributes
+}
+
+tasks.named("jar", Jar).configure {
+ manifest {
+ attributes(getManifestAttributes())
+ }
+}
+
+if (usesShadowedDependencies.toBoolean()) {
+ tasks.named("shadowJar", ShadowJar).configure {
+ manifest {
+ attributes(getManifestAttributes())
+ }
+
+ if (minimizeShadowedDependencies.toBoolean()) {
+ minimize() // This will only allow shading for actually used classes
+ }
+ configurations = [
+ project.configurations.shadowImplementation,
+ project.configurations.shadowCompile,
+ project.configurations.shadeCompile
+ ]
+ archiveClassifier.set('dev')
+ if (relocateShadowedDependencies.toBoolean()) {
+ relocationPrefix = modGroup + ".shadow"
+ enableRelocation = true
+ }
+ }
+ configurations.runtimeElements.outgoing.artifacts.clear()
+ configurations.apiElements.outgoing.artifacts.clear()
+ configurations.runtimeElements.outgoing.artifact(tasks.named("shadowJar", ShadowJar))
+ configurations.apiElements.outgoing.artifact(tasks.named("shadowJar", ShadowJar))
+ tasks.named("jar", Jar) {
+ enabled = false
+ finalizedBy(tasks.shadowJar)
+ }
+ tasks.named("reobfJar", ReobfuscatedJar) {
+ inputJar.set(tasks.named("shadowJar", ShadowJar).flatMap({it.archiveFile}))
+ }
+ AdhocComponentWithVariants javaComponent = (AdhocComponentWithVariants) project.components.findByName("java")
+ javaComponent.withVariantsFromConfiguration(configurations.shadowRuntimeElements) {
+ skip()
+ }
+ for (runTask in ["runClient", "runServer", "runClient17", "runServer17"]) {
+ tasks.named(runTask).configure {
+ dependsOn("shadowJar")
+ }
+ }
+}
+ext.publishableDevJar = usesShadowedDependencies.toBoolean() ? tasks.shadowJar : tasks.jar
+ext.publishableObfJar = tasks.reobfJar
+
+tasks.register('apiJar', Jar) {
+ from(sourceSets.main.allSource) {
+ include modGroupPath + "/" + apiPackagePath + '/**'
+ }
+
+ from(sourceSets.main.output) {
+ include modGroupPath + "/" + apiPackagePath + '/**'
+ }
+
+ from(sourceSets.main.resources.srcDirs) {
+ include("LICENSE")
+ }
+
+ getArchiveClassifier().set('api')
+}
+
+artifacts {
+ if (!noPublishedSources) {
+ archives tasks.named("sourcesJar")
+ }
+ if (apiPackage) {
+ archives tasks.named("apiJar")
+ }
+}
+
+idea {
+ module {
+ downloadJavadoc = true
+ downloadSources = true
+ inheritOutputDirs = true
+ }
+ project {
+ settings {
+ if (ideaOverrideBuildType != "") {
+ delegateActions {
+ if ("gradle".equalsIgnoreCase(ideaOverrideBuildType)) {
+ delegateBuildRunToGradle = true
+ testRunner = org.jetbrains.gradle.ext.ActionDelegationConfig.TestRunner.GRADLE
+ } else if ("idea".equalsIgnoreCase(ideaOverrideBuildType)) {
+ delegateBuildRunToGradle = false
+ testRunner = org.jetbrains.gradle.ext.ActionDelegationConfig.TestRunner.PLATFORM
+ } else {
+ throw GradleScriptException('Accepted value for ideaOverrideBuildType is one of gradle or idea.')
+ }
+ }
+ }
+ runConfigurations {
+ "0. Build and Test"(Gradle) {
+ taskNames = ["build"]
+ }
+ "1. Run Client"(Gradle) {
+ taskNames = ["runClient"]
+ }
+ "2. Run Server"(Gradle) {
+ taskNames = ["runServer"]
+ }
+ "1a. Run Client (Java 17)"(Gradle) {
+ taskNames = ["runClient17"]
+ }
+ "2a. Run Server (Java 17)"(Gradle) {
+ taskNames = ["runServer17"]
+ }
+ "1b. Run Client (Java 17, Hotswap)"(Gradle) {
+ taskNames = ["runClient17"]
+ envs = ["HOTSWAP": "true"]
+ }
+ "2b. Run Server (Java 17, Hotswap)"(Gradle) {
+ taskNames = ["runServer17"]
+ envs = ["HOTSWAP": "true"]
+ }
+ "3. Run Obfuscated Client"(Gradle) {
+ taskNames = ["runObfClient"]
+ }
+ "4. Run Obfuscated Server"(Gradle) {
+ taskNames = ["runObfServer"]
+ }
+ if (!disableSpotless) {
+ "5. Apply spotless"(Gradle) {
+ taskNames = ["spotlessApply"]
+ }
+ }
+ def coreModArgs = ""
+ if (coreModClass) {
+ coreModArgs = ' "-Dfml.coreMods.load=' + modGroup + '.' + coreModClass + '"'
+ }
+ "Run Client (IJ Native)"(Application) {
+ mainClass = "GradleStart"
+ moduleName = project.name + ".ideVirtualMain"
+ afterEvaluate {
+ workingDirectory = tasks.runClient.workingDir.absolutePath
+ programParameters = tasks.runClient.calculateArgs(project).collect { '"' + it + '"' }.join(' ')
+ jvmArgs = tasks.runClient.calculateJvmArgs(project).collect { '"' + it + '"' }.join(' ') +
+ ' ' + tasks.runClient.systemProperties.collect { '"-D' + it.key + '=' + it.value.toString() + '"' }.join(' ') +
+ coreModArgs
+ }
+ }
+ "Run Server (IJ Native)"(Application) {
+ mainClass = "GradleStartServer"
+ moduleName = project.name + ".ideVirtualMain"
+ afterEvaluate {
+ workingDirectory = tasks.runServer.workingDir.absolutePath
+ programParameters = tasks.runServer.calculateArgs(project).collect { '"' + it + '"' }.join(' ')
+ jvmArgs = tasks.runServer.calculateJvmArgs(project).collect { '"' + it + '"' }.join(' ') +
+ ' ' + tasks.runServer.systemProperties.collect { '"-D' + it.key + '=' + it.value.toString() + '"' }.join(' ') +
+ coreModArgs
+ }
+ }
+ }
+ compiler.javac {
+ afterEvaluate {
+ javacAdditionalOptions = "-encoding utf8"
+ moduleJavacAdditionalOptions = [
+ (project.name + ".main"): tasks.compileJava.options.compilerArgs.collect { '"' + it + '"' }.join(' ')
+ ]
+ }
+ }
+ withIDEADir { File ideaDir ->
+ if (!ideaDir.path.contains(".idea")) {
+ // If an .ipr file exists, the project root directory is passed here instead of the .idea subdirectory
+ ideaDir = new File(ideaDir, ".idea")
+ }
+ if (ideaDir.isDirectory()) {
+ def miscFile = new File(ideaDir, "misc.xml")
+ if (miscFile.isFile()) {
+ boolean dirty = false
+ def miscTransformer = new XmlTransformer()
+ miscTransformer.addAction { root ->
+ Node rootNode = root.asNode()
+ def rootManager = rootNode
+ .component.find { it.@name == 'ProjectRootManager' }
+ if (!rootManager) {
+ rootManager = rootNode.appendNode('component', ['name': 'ProjectRootManager', 'version': '2'])
+ dirty = true
+ }
+ def output = rootManager.output
+ if (!output) {
+ output = rootManager.appendNode('output')
+ dirty = true
+ }
+ if (!output.@url) {
+ // Only modify the output url if it doesn't yet have one, or if the existing one is blank somehow.
+ // This is a sensible default for most setups
+ output.@url = 'file://$PROJECT_DIR$/build/ideaBuild'
+ dirty = true
+ }
+ }
+ def result = miscTransformer.transform(miscFile.text)
+ if (dirty) {
+ miscFile.write(result)
+ }
+ } else {
+ miscFile.text = """
+
+
+
+
+
+"""
+ }
+ }
+ }
+ }
+ }
+}
+
+tasks.named("processIdeaSettings").configure {
+ dependsOn("injectTags")
+}
+
+tasks.named("ideVirtualMainClasses").configure {
+ // Make IntelliJ "Build project" build the mod jars
+ dependsOn("jar", "reobfJar")
+ if (!disableSpotless) {
+ dependsOn("spotlessCheck")
+ }
+}
+
+// workaround variable hiding in pom processing
+def projectConfigs = project.configurations
+
+publishing {
+ publications {
+ create("maven", MavenPublication) {
+ from components.java
+
+ if (apiPackage) {
+ artifact apiJar
+ }
+
+ groupId = System.getenv("ARTIFACT_GROUP_ID") ?: project.group
+ artifactId = System.getenv("ARTIFACT_ID") ?: project.name
+ // Using the identified version, not project.version as it has the prepended 1.7.10
+ version = System.getenv("RELEASE_VERSION") ?: identifiedVersion
+ }
+ }
+ repositories {
+ if (usesMavenPublishing.toBoolean() && System.getenv("MAVEN_USER") != null) {
+ maven {
+ url = mavenPublishUrl
+ allowInsecureProtocol = mavenPublishUrl.startsWith("http://") // Mostly for the GTNH maven
+ credentials {
+ username = System.getenv("MAVEN_USER") ?: "NONE"
+ password = System.getenv("MAVEN_PASSWORD") ?: "NONE"
+ }
+ }
+ }
+ }
+}
+
+if (modrinthProjectId.size() != 0 && System.getenv("MODRINTH_TOKEN") != null) {
+ apply plugin: 'com.modrinth.minotaur'
+
+ File changelogFile = new File(System.getenv("CHANGELOG_FILE") ?: "CHANGELOG.md")
+
+ modrinth {
+ token = System.getenv("MODRINTH_TOKEN")
+ projectId = modrinthProjectId
+ versionNumber = identifiedVersion
+ versionType = identifiedVersion.endsWith("-pre") ? "beta" : "release"
+ changelog = changelogFile.exists() ? changelogFile.getText("UTF-8") : ""
+ uploadFile = publishableObfJar
+ additionalFiles = getSecondaryArtifacts()
+ gameVersions = [minecraftVersion]
+ loaders = ["forge"]
+ debugMode = false
+ }
+
+ if (modrinthRelations.size() != 0) {
+ String[] deps = modrinthRelations.split(";")
+ deps.each { dep ->
+ if (dep.size() == 0) {
+ return
+ }
+ String[] parts = dep.split(":")
+ String[] qual = parts[0].split("-")
+ addModrinthDep(qual[0], qual[1], parts[1])
+ }
+ }
+ if (usesMixins.toBoolean()) {
+ addModrinthDep("required", "project", "unimixins")
+ }
+ tasks.modrinth.dependsOn(build)
+ tasks.publish.dependsOn(tasks.modrinth)
+}
+
+if (curseForgeProjectId.size() != 0 && System.getenv("CURSEFORGE_TOKEN") != null) {
+ apply plugin: 'com.matthewprenger.cursegradle'
+
+ File changelogFile = new File(System.getenv("CHANGELOG_FILE") ?: "CHANGELOG.md")
+
+ curseforge {
+ apiKey = System.getenv("CURSEFORGE_TOKEN")
+ project {
+ id = curseForgeProjectId
+ if (changelogFile.exists()) {
+ changelogType = "markdown"
+ changelog = changelogFile
+ }
+ releaseType = identifiedVersion.endsWith("-pre") ? "beta" : "release"
+ addGameVersion minecraftVersion
+ addGameVersion "Forge"
+ mainArtifact publishableObfJar
+ for (artifact in getSecondaryArtifacts()) addArtifact artifact
+ }
+
+ options {
+ javaIntegration = false
+ forgeGradleIntegration = false
+ debug = false
+ }
+ }
+
+ if (curseForgeRelations.size() != 0) {
+ String[] deps = curseForgeRelations.split(";")
+ deps.each { dep ->
+ if (dep.size() == 0) {
+ return
+ }
+ String[] parts = dep.split(":")
+ addCurseForgeRelation(parts[0], parts[1])
+ }
+ }
+ if (usesMixins.toBoolean()) {
+ addCurseForgeRelation("requiredDependency", "unimixins")
+ }
+ tasks.curseforge.dependsOn(build)
+ tasks.publish.dependsOn(tasks.curseforge)
+}
+
+def addModrinthDep(String scope, String type, String name) {
+ com.modrinth.minotaur.dependencies.Dependency dep;
+ if (!(scope in ["required", "optional", "incompatible", "embedded"])) {
+ throw new Exception("Invalid modrinth dependency scope: " + scope)
+ }
+ switch (type) {
+ case "project":
+ dep = new ModDependency(name, scope)
+ break
+ case "version":
+ dep = new VersionDependency(name, scope)
+ break
+ default:
+ throw new Exception("Invalid modrinth dependency type: " + type)
+ }
+ project.modrinth.dependencies.add(dep)
+}
+
+def addCurseForgeRelation(String type, String name) {
+ if (!(type in ["requiredDependency", "embeddedLibrary", "optionalDependency", "tool", "incompatible"])) {
+ throw new Exception("Invalid CurseForge relation type: " + type)
+ }
+ CurseArtifact artifact = project.curseforge.curseProjects[0].mainArtifact
+ CurseRelation rel = (artifact.curseRelations ?: (artifact.curseRelations = new CurseRelation()))
+ rel."$type"(name)
+}
+
+// Updating
+
+def buildscriptGradleVersion = "8.2.1"
+
+tasks.named('wrapper', Wrapper).configure {
+ gradleVersion = buildscriptGradleVersion
+}
+
+tasks.register('updateBuildScript') {
+ group = 'GTNH Buildscript'
+ description = 'Updates the build script to the latest version'
+
+ if (gradle.gradleVersion != buildscriptGradleVersion && !Boolean.getBoolean('DISABLE_BUILDSCRIPT_GRADLE_UPDATE')) {
+ dependsOn('wrapper')
+ }
+
+ doLast {
+ if (performBuildScriptUpdate()) return
+
+ print("Build script already up-to-date!")
+ }
+}
+
+if (!project.getGradle().startParameter.isOffline() && !Boolean.getBoolean('DISABLE_BUILDSCRIPT_UPDATE_CHECK') && isNewBuildScriptVersionAvailable()) {
+ if (autoUpdateBuildScript.toBoolean()) {
+ performBuildScriptUpdate()
+ } else {
+ out.style(Style.SuccessHeader).println("Build script update available! Run 'gradle updateBuildScript'")
+ if (gradle.gradleVersion != buildscriptGradleVersion) {
+ out.style(Style.SuccessHeader).println("updateBuildScript can update gradle from ${gradle.gradleVersion} to ${buildscriptGradleVersion}\n")
+ }
+ }
+}
+
+// If you want to add more cases to this task, implement them as arguments if total amount to print gets too large
+tasks.register('faq') {
+ group = 'GTNH Buildscript'
+ description = 'Prints frequently asked questions about building a project'
+
+ doLast {
+ print("If your build fails to fetch dependencies, run './gradlew updateDependencies'. " +
+ "Or you can manually check if the versions are still on the distributing sites - " +
+ "the links can be found in repositories.gradle and build.gradle:repositories, " +
+ "but not build.gradle:buildscript.repositories - those ones are for gradle plugin metadata.\n\n" +
+ "If your build fails to recognize the syntax of new Java versions, enable Jabel in your " +
+ "gradle.properties. See how it's done in GTNH ExampleMod/gradle.properties. " +
+ "However, keep in mind that Jabel enables only syntax features, but not APIs that were introduced in " +
+ "Java 9 or later.")
+ }
+}
+
+static URL availableBuildScriptUrl() {
+ new URL("https://raw.githubusercontent.com/GTNewHorizons/ExampleMod1.7.10/master/build.gradle")
+}
+
+static URL exampleSettingsGradleUrl() {
+ new URL("https://raw.githubusercontent.com/GTNewHorizons/ExampleMod1.7.10/master/settings.gradle.example")
+}
+
+static URL exampleGitAttributesUrl() {
+ new URL("https://raw.githubusercontent.com/GTNewHorizons/ExampleMod1.7.10/master/.gitattributes")
+}
+
+
+boolean verifyGitAttributes() {
+ def gitattributesFile = getFile(".gitattributes")
+ if (!gitattributesFile.exists()) {
+ println("Downloading default .gitattributes")
+ exampleGitAttributesUrl().withInputStream { i -> gitattributesFile.withOutputStream { it << i } }
+ exec {
+ workingDir '.'
+ commandLine 'git', 'add', '--renormalize', '.'
+ }
+ return true
+ }
+ return false
+}
+
+boolean verifySettingsGradle() {
+ def settingsFile = getFile("settings.gradle")
+ if (!settingsFile.exists()) {
+ println("Downloading default settings.gradle")
+ exampleSettingsGradleUrl().withInputStream { i -> settingsFile.withOutputStream { it << i } }
+ return true
+ }
+ return false
+}
+
+boolean performBuildScriptUpdate() {
+ if (isNewBuildScriptVersionAvailable()) {
+ def buildscriptFile = getFile("build.gradle")
+ availableBuildScriptUrl().withInputStream { i -> buildscriptFile.withOutputStream { it << i } }
+ def out = services.get(StyledTextOutputFactory).create('buildscript-update-output')
+ out.style(Style.Success).print("Build script updated. Please REIMPORT the project or RESTART your IDE!")
+ boolean settingsupdated = verifySettingsGradle()
+ settingsupdated = verifyGitAttributes() || settingsupdated
+ if (settingsupdated)
+ throw new GradleException("Settings has been updated, please re-run task.")
+ return true
+ }
+ return false
+}
+
+boolean isNewBuildScriptVersionAvailable() {
+ Map parameters = ["connectTimeout": 2000, "readTimeout": 2000]
+
+ String currentBuildScript = getFile("build.gradle").getText()
+ String currentBuildScriptHash = getVersionHash(currentBuildScript)
+ String availableBuildScriptHash
+ try {
+ String availableBuildScript = availableBuildScriptUrl().newInputStream(parameters).getText()
+ availableBuildScriptHash = getVersionHash(availableBuildScript)
+ } catch (IOException e) {
+ logger.warn("Could not check for buildscript update availability: {}", e.message)
+ return false
+ }
+
+ boolean isUpToDate = currentBuildScriptHash.empty || availableBuildScriptHash.empty || currentBuildScriptHash == availableBuildScriptHash
+ return !isUpToDate
+}
+
+static String getVersionHash(String buildScriptContent) {
+ String versionLine = buildScriptContent.find("^//version: [a-z0-9]*")
+ if (versionLine != null) {
+ return versionLine.split(": ").last()
+ }
+ return ""
+}
+
+// Parameter Deobfuscation
+
+tasks.register('deobfParams') {
+ group = 'GTNH Buildscript'
+ description = 'Rename all obfuscated parameter names inherited from Minecraft classes'
+ doLast { // TODO
+
+ String mcpDir = "$project.gradle.gradleUserHomeDir/caches/minecraft/de/oceanlabs/mcp/mcp_$channel/$mappingsVersion"
+ String mcpZIP = "$mcpDir/mcp_$channel-$mappingsVersion-${minecraftVersion}.zip"
+ String paramsCSV = "$mcpDir/params.csv"
+
+ download.run {
+ src "https://maven.minecraftforge.net/de/oceanlabs/mcp/mcp_$channel/$mappingsVersion-$minecraftVersion/mcp_$channel-$mappingsVersion-${minecraftVersion}.zip"
+ dest mcpZIP
+ overwrite false
+ }
+
+ if (!file(paramsCSV).exists()) {
+ println("Extracting MCP archive ...")
+ copy {
+ from(zipTree(mcpZIP))
+ into(mcpDir)
+ }
+ }
+
+ println("Parsing params.csv ...")
+ Map params = new HashMap<>()
+ Files.lines(Paths.get(paramsCSV)).forEach { line ->
+ String[] cells = line.split(",")
+ if (cells.length > 2 && cells[0].matches("p_i?\\d+_\\d+_")) {
+ params.put(cells[0], cells[1])
+ }
+ }
+
+ out.style(Style.Success).println("Modified ${replaceParams(file("$projectDir/src/main/java"), params)} files!")
+ out.style(Style.Failure).println("Don't forget to verify that the code still works as before!\n It could be broken due to duplicate variables existing now\n or parameters taking priority over other variables.")
+ }
+}
+
+static int replaceParams(File file, Map params) {
+ int fileCount = 0
+
+ if (file.isDirectory()) {
+ for (File f : file.listFiles()) {
+ fileCount += replaceParams(f, params)
+ }
+ return fileCount
+ }
+ println("Visiting ${file.getName()} ...")
+ try {
+ String content = new String(Files.readAllBytes(file.toPath()))
+ int hash = content.hashCode()
+ params.forEach { key, value ->
+ content = content.replaceAll(key, value)
+ }
+ if (hash != content.hashCode()) {
+ Files.write(file.toPath(), content.getBytes("UTF-8"))
+ return 1
+ }
+ } catch (Exception e) {
+ e.printStackTrace()
+ }
+ return 0
+}
+
+// Dependency Deobfuscation (Deprecated, use the new RFG API documented in dependencies.gradle)
+
+def deobf(String sourceURL) {
+ try {
+ URL url = new URL(sourceURL)
+ String fileName = url.getFile()
+
+ //get rid of directories:
+ int lastSlash = fileName.lastIndexOf("/")
+ if (lastSlash > 0) {
+ fileName = fileName.substring(lastSlash + 1)
+ }
+ //get rid of extension:
+ if (fileName.endsWith(".jar") || fileName.endsWith(".litemod")) {
+ fileName = fileName.substring(0, fileName.lastIndexOf("."))
+ }
+
+ String hostName = url.getHost()
+ if (hostName.startsWith("www.")) {
+ hostName = hostName.substring(4)
+ }
+ List parts = Arrays.asList(hostName.split("\\."))
+ Collections.reverse(parts)
+ hostName = String.join(".", parts)
+
+ return deobf(sourceURL, "$hostName/$fileName")
+ } catch (Exception ignored) {
+ return deobf(sourceURL, "deobf/${sourceURL.hashCode()}")
+ }
+}
+
+def deobfMaven(String repoURL, String mavenDep) {
+ if (!repoURL.endsWith("/")) {
+ repoURL += "/"
+ }
+ String[] parts = mavenDep.split(":")
+ parts[0] = parts[0].replace('.', '/')
+ def jarURL = repoURL + parts[0] + "/" + parts[1] + "/" + parts[2] + "/" + parts[1] + "-" + parts[2] + ".jar"
+ return deobf(jarURL)
+}
+
+def deobfCurse(String curseDep) {
+ return dependencies.rfg.deobf("curse.maven:$curseDep")
+}
+
+// The method above is to be preferred. Use this method if the filename is not at the end of the URL.
+def deobf(String sourceURL, String rawFileName) {
+ String bon2Version = "2.5.1"
+ String fileName = URLDecoder.decode(rawFileName, "UTF-8")
+ String cacheDir = "$project.gradle.gradleUserHomeDir/caches"
+ String obfFile = "$cacheDir/modules-2/files-2.1/${fileName}.jar"
+
+ download.run {
+ src sourceURL
+ dest obfFile
+ quiet true
+ overwrite false
+ }
+ return dependencies.rfg.deobf(files(obfFile))
+}
+// Helper methods
+
+def checkPropertyExists(String propertyName) {
+ if (!project.hasProperty(propertyName)) {
+ throw new GradleException("This project requires a property \"" + propertyName + "\"! Please add it your \"gradle.properties\". You can find all properties and their description here: https://github.com/GTNewHorizons/ExampleMod1.7.10/blob/main/gradle.properties")
+ }
+}
+
+def propertyDefaultIfUnset(String propertyName, defaultValue) {
+ if (!project.hasProperty(propertyName) || project.property(propertyName) == "") {
+ project.ext.setProperty(propertyName, defaultValue)
+ }
+}
+
+def getFile(String relativePath) {
+ return new File(projectDir, relativePath)
+}
+
+def getSecondaryArtifacts() {
+ // Because noPublishedSources from the beginning of the script is somehow not visible here...
+ boolean noPublishedSources = project.hasProperty("noPublishedSources") ? project.noPublishedSources.toBoolean() : false
+ def secondaryArtifacts = [publishableDevJar]
+ if (!noPublishedSources) secondaryArtifacts += [sourcesJar]
+ if (apiPackage) secondaryArtifacts += [apiJar]
+ return secondaryArtifacts
+}
+
+def getURL(String main, String fallback) {
+ return pingURL(main, 10000) ? main : fallback
+}
+
+// credit: https://stackoverflow.com/a/3584332
+def pingURL(String url, int timeout) {
+ url = url.replaceFirst("^https", "http") // Otherwise an exception may be thrown on invalid SSL certificates.
+ try {
+ HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection()
+ connection.setConnectTimeout(timeout)
+ connection.setReadTimeout(timeout)
+ connection.setRequestMethod("HEAD")
+ int responseCode = connection.getResponseCode()
+ return 200 <= responseCode && responseCode <= 399
+ } catch (IOException ignored) {
+ return false
+ }
+}
+
+// For easier scripting of things that require variables defined earlier in the buildscript
+if (file('addon.late.gradle.kts').exists()) {
+ apply from: 'addon.late.gradle.kts'
+} else if (file('addon.late.gradle').exists()) {
+ apply from: 'addon.late.gradle'
+}
+
+// File for local tweaks not commited to Git
+if (file('addon.late.local.gradle.kts').exists()) {
+ apply from: 'addon.late.local.gradle.kts'
+} else if (file('addon.late.local.gradle').exists()) {
+ apply from: 'addon.late.local.gradle'
+}
diff --git a/dependencies.gradle b/dependencies.gradle
new file mode 100644
index 0000000..92b0873
--- /dev/null
+++ b/dependencies.gradle
@@ -0,0 +1,40 @@
+/*
+ * Add your dependencies here. Supported configurations:
+ * - api("group:name:version:classifier"): if you use the types from this dependency in the public API of this mod
+ * Available at runtime and compiletime for mods depending on this mod
+ * - implementation("g:n:v:c"): if you need this for internal implementation details of the mod, but none of it is visible via the public API
+ * Available at runtime but not compiletime for mods depending on this mod
+ * - compileOnly("g:n:v:c"): if the mod you're building doesn't need this dependency during runtime at all, e.g. for optional mods
+ * Not available at all for mods depending on this mod, only visible at compiletime for this mod
+ * - compileOnlyApi("g:n:v:c"): like compileOnly, but also visible at compiletime for mods depending on this mod
+ * Available at compiletime but not runtime for mods depending on this mod
+ * - runtimeOnlyNonPublishable("g:n:v:c"): if you want to include a mod in this mod's runClient/runServer runs, but not publish it as a dependency
+ * Not available at all for mods depending on this mod, only visible at runtime for this mod
+ * - devOnlyNonPublishable("g:n:v:c"): a combination of runtimeOnlyNonPublishable and compileOnly for dependencies present at both compiletime and runtime,
+ * but not published as Maven dependencies - useful for RFG-deobfuscated dependencies or local testing
+ * - runtimeOnly("g:n:v:c"): if you don't need this at compile time, but want it to be present at runtime
+ * Available at runtime for mods depending on this mod
+ * - annotationProcessor("g:n:v:c"): mostly for java compiler plugins, if you know you need this, use it, otherwise don't worry
+ * - testCONFIG("g:n:v:c") - replace CONFIG by one of the above (except api), same as above but for the test sources instead of main
+ *
+ * - shadowImplementation("g:n:v:c"): effectively the same as API, but the dependency is included in your jar under a renamed package name
+ * Requires you to enable usesShadowedDependencies in gradle.properties
+ *
+ * - compile("g:n:v:c"): deprecated, replace with "api" (works like the old "compile") or "implementation" (can be more efficient)
+ *
+ * You can exclude transitive dependencies (dependencies of the chosen dependency) by appending { transitive = false } if needed,
+ * but use this sparingly as it can break using your mod as another mod's dependency if you're not careful.
+ *
+ * To depend on obfuscated jars you can use `devOnlyNonPublishable(rfg.deobf("dep:spec:1.2.3"))` to fetch an obfuscated jar from maven,
+ * or `devOnlyNonPublishable(rfg.deobf(project.files("libs/my-mod-jar.jar")))` to use a file.
+ *
+ * Gradle names for some of the configuration can be misleading, compileOnlyApi and runtimeOnly both get published as dependencies in Maven, but compileOnly does not.
+ * The buildscript adds runtimeOnlyNonPublishable to also have a runtime dependency that's not published.
+ *
+ * For more details, see https://docs.gradle.org/8.0.1/userguide/java_library_plugin.html#sec:java_library_configurations_graph
+ */
+dependencies {
+ implementation files('libs/cindercore_modlist.jar')
+ implementation files('libs/lotr.jar')
+// shadowImplementation files('libs/cindercore_modlist.jar')
+}
diff --git a/gradle.properties b/gradle.properties
new file mode 100644
index 0000000..d75455e
--- /dev/null
+++ b/gradle.properties
@@ -0,0 +1,152 @@
+modName = CinderCore
+
+# This is a case-sensitive string to identify your mod. Convention is to use lower case.
+modId = cindercore
+
+modGroup = com.zivilon.cindercore
+
+# WHY is there no version field?
+# The build script relies on git to provide a version via tags. It is super easy and will enable you to always know the
+# code base or your binary. Check out this tutorial: https://blog.mattclemente.com/2017/10/13/versioning-with-git-tags/
+
+# Will update your build.gradle automatically whenever an update is available
+autoUpdateBuildScript = false
+
+minecraftVersion = 1.7.10
+forgeVersion = 10.13.4.1614
+
+# Specify a MCP channel and mappings version for dependency deobfuscation and the deobfParams task.
+channel = stable
+mappingsVersion = 12
+
+# Define other MCP mappings for dependency deobfuscation
+remoteMappings = https://raw.githubusercontent.com/MinecraftForge/FML/1.7.10/conf/
+
+# Select a username for testing your mod with breakpoints. You may leave this empty for a random username each time you
+# restart Minecraft in development. Choose this dependent on your mod:
+# Do you need consistent player progressing (for example Thaumcraft)? -> Select a name
+# Do you need to test how your custom blocks interacts with a player that is not the owner? -> leave name empty
+developmentEnvironmentUserName = Developer
+
+# Enables using modern java syntax (up to version 17) via Jabel, while still targeting JVM 8.
+# See https://github.com/bsideup/jabel for details on how this works.
+enableModernJavaSyntax = true
+
+# Enables injecting missing generics into the decompiled source code for a better coding experience
+# Turns most publicly visible List, Map, etc. into proper List, Map types
+enableGenericInjection = false
+
+# Generate a class with String fields for the mod id, name, version and group name named with the fields below
+generateGradleTokenClass = com.zivilon.cindercore.Tags
+gradleTokenModId = MODID
+gradleTokenModName = MODNAME
+gradleTokenVersion = VERSION
+gradleTokenGroupName = GROUPNAME
+# [DEPRECATED]
+# Multiple source files can be defined here by providing a comma-seperated list: Class1.java,Class2.java,Class3.java
+# public static final String VERSION = "GRADLETOKEN_VERSION";
+# The string's content will be replaced with your mod's version when compiled. You should use this to specify your mod's
+# version in @Mod([...], version = VERSION, [...])
+# Leave these properties empty to skip individual token replacements
+replaceGradleTokenInFile =
+
+# In case your mod provides an API for other mods to implement you may declare its package here. Otherwise, you can
+# leave this property empty.
+# Example value: apiPackage = api + modGroup = com.myname.mymodid -> com.myname.mymodid.api
+apiPackage =
+
+# Specify the configuration file for Forge's access transformers here. It must be placed into /src/main/resources/META-INF/
+# There can be multiple files in a space-separated list.
+# Example value: mymodid_at.cfg nei_at.cfg
+accessTransformersFile =
+
+# Provides setup for Mixins if enabled. If you don't know what mixins are: Keep it disabled!
+usesMixins = true
+# Adds some debug arguments like verbose output and export
+usesMixinDebug = false
+# Specify the location of your implementation of IMixinConfigPlugin. Leave it empty otherwise.
+mixinPlugin =
+# Specify the package that contains all of your Mixins. You may only place Mixins in this package or the build will fail!
+mixinsPackage = mixins
+# Specify the core mod entry class if you use a core mod. This class must implement IFMLLoadingPlugin!
+# This parameter is for legacy compatibility only
+# Example value: coreModClass = asm.FMLPlugin + modGroup = com.myname.mymodid -> com.myname.mymodid.asm.FMLPlugin
+coreModClass = coremod.CoreMod
+# If your project is only a consolidation of mixins or a core mod and does NOT contain a 'normal' mod ( = some class
+# that is annotated with @Mod) you want this to be true. When in doubt: leave it on false!
+containsMixinsAndOrCoreModOnly = false
+
+# Enables Mixins even if this mod doesn't use them, useful if one of the dependencies uses mixins.
+forceEnableMixins = true
+
+# If enabled, you may use 'shadowCompile' for dependencies. They will be integrated in your jar. It is your
+# responsibility check the licence and request permission for distribution, if required.
+usesShadowedDependencies = true
+# If disabled, won't remove unused classes from shaded dependencies. Some libraries use reflection to access
+# their own classes, making the minimization unreliable.
+minimizeShadowedDependencies = false
+# If disabled, won't rename the shadowed classes.
+relocateShadowedDependencies = false
+
+# Adds the GTNH maven, CurseMaven, IC2/Player maven, and some more well-known 1.7.10 repositories
+includeWellKnownRepositories = true
+
+# Change these to your Maven coordinates if you want to publish to a custom Maven repository instead of the default GTNH Maven.
+# Authenticate with the MAVEN_USERNAME and MAVEN_PASSWORD environment variables.
+# If you need a more complex setup disable maven publishing here and add a publishing repository to addon.gradle.
+usesMavenPublishing = false
+# mavenPublishUrl = http://jenkins.usrv.eu:8081/nexus/content/repositories/releases
+
+# Publishing to modrinth requires you to set the MODRINTH_TOKEN environment variable to your current modrinth API token.
+
+# The project's ID on Modrinth. Can be either the slug or the ID.
+# Leave this empty if you don't want to publish on Modrinth.
+modrinthProjectId =
+
+# The project's relations on Modrinth. You can use this to refer to other projects on Modrinth.
+# Syntax: scope1-type1:name1;scope2-type2:name2;...
+# Where scope can be one of [required, optional, incompatible, embedded],
+# type can be one of [project, version],
+# and the name is the Modrinth project or version slug/id of the other mod.
+# Example: required-project:fplib;optional-project:gasstation;incompatible-project:gregtech
+# Note: GTNH Mixins is automatically set as a required dependency if usesMixins = true
+modrinthRelations =
+
+
+# Publishing to CurseForge requires you to set the CURSEFORGE_TOKEN environment variable to one of your CurseForge API tokens.
+
+# The project's numeric ID on CurseForge. You can find this in the About Project box.
+# Leave this empty if you don't want to publish on CurseForge.
+curseForgeProjectId =
+
+# The project's relations on CurseForge. You can use this to refer to other projects on CurseForge.
+# Syntax: type1:name1;type2:name2;...
+# Where type can be one of [requiredDependency, embeddedLibrary, optionalDependency, tool, incompatible],
+# and the name is the CurseForge project slug of the other mod.
+# Example: requiredDependency:railcraft;embeddedLibrary:cofhlib;incompatible:buildcraft
+# Note: GTNH Mixins is automatically set as a required dependency if usesMixins = true
+curseForgeRelations =
+
+
+# Optional parameter to customize the produced artifacts. Use this to preserver artifact naming when migrating older
+# projects. New projects should not use this parameter.
+# customArchiveBaseName =
+
+# Optional parameter to prevent the source code from being published
+# noPublishedSources =
+
+# Uncomment this to disable spotless checks
+# This should only be uncommented to keep it easier to sync with upstream/other forks.
+# That is, if there is no other active fork/upstream, NEVER change this.
+disableSpotless = true
+
+# Uncomment this to disable checkstyle checks (currently wildcard import check).
+ disableCheckstyle = true
+
+# Override the IDEA build type. Valid value is "" (leave blank, do not override), "idea" (force use native IDEA build), "gradle"
+# (force use delegated build).
+# This is meant to be set in $HOME/.gradle/gradle.properties.
+# e.g. add "systemProp.org.gradle.project.ideaOverrideBuildType=idea" will override the build type to be always native build.
+# WARNING: If you do use this option, it will overwrite whatever you have in your existing projects. This might not be what you want!
+# Usually there is no need to uncomment this here as other developers do not necessarily use the same build type as you.
+# ideaOverrideBuildType = idea
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..033e24c
Binary files /dev/null and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..9f4197d
--- /dev/null
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.2.1-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/gradlew b/gradlew
new file mode 100755
index 0000000..fcb6fca
--- /dev/null
+++ b/gradlew
@@ -0,0 +1,248 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+# Gradle start up script for POSIX generated by Gradle.
+#
+# Important for running:
+#
+# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+# noncompliant, but you have some other compliant shell such as ksh or
+# bash, then to run this script, type that shell name before the whole
+# command line, like:
+#
+# ksh Gradle
+#
+# Busybox and similar reduced shells will NOT work, because this script
+# requires all of these POSIX shell features:
+# * functions;
+# * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+# «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+# * compound commands having a testable exit status, especially «case»;
+# * various built-in commands including «command», «set», and «ulimit».
+#
+# Important for patching:
+#
+# (2) This script targets any POSIX shell, so it avoids extensions provided
+# by Bash, Ksh, etc; in particular arrays are avoided.
+#
+# The "traditional" practice of packing multiple parameters into a
+# space-separated string is a well documented source of bugs and security
+# problems, so this is (mostly) avoided, by progressively accumulating
+# options in "$@", and eventually passing that to Java.
+#
+# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+# see the in-line comments for details.
+#
+# There are tweaks for specific operating systems such as AIX, CygWin,
+# Darwin, MinGW, and NonStop.
+#
+# (3) This script is generated from the Groovy template
+# https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+# within the Gradle project.
+#
+# You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+ APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path
+ [ -h "$app_path" ]
+do
+ ls=$( ls -ld "$app_path" )
+ link=${ls#*' -> '}
+ case $link in #(
+ /*) app_path=$link ;; #(
+ *) app_path=$APP_HOME$link ;;
+ esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+ echo "$*"
+} >&2
+
+die () {
+ echo
+ echo "$*"
+ echo
+ exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in #(
+ CYGWIN* ) cygwin=true ;; #(
+ Darwin* ) darwin=true ;; #(
+ MSYS* | MINGW* ) msys=true ;; #(
+ NONSTOP* ) nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+ if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+ # IBM's JDK on AIX uses strange locations for the executables
+ JAVACMD=$JAVA_HOME/jre/sh/java
+ else
+ JAVACMD=$JAVA_HOME/bin/java
+ fi
+ if [ ! -x "$JAVACMD" ] ; then
+ die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+ fi
+else
+ JAVACMD=java
+ if ! command -v java >/dev/null 2>&1
+ then
+ die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+ fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+ case $MAX_FD in #(
+ max*)
+ # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+ # shellcheck disable=SC3045
+ MAX_FD=$( ulimit -H -n ) ||
+ warn "Could not query maximum file descriptor limit"
+ esac
+ case $MAX_FD in #(
+ '' | soft) :;; #(
+ *)
+ # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+ # shellcheck disable=SC3045
+ ulimit -n "$MAX_FD" ||
+ warn "Could not set maximum file descriptor limit to $MAX_FD"
+ esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+# * args from the command line
+# * the main class name
+# * -classpath
+# * -D...appname settings
+# * --module-path (only if needed)
+# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+ APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+ CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+ JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+ # Now convert the arguments - kludge to limit ourselves to /bin/sh
+ for arg do
+ if
+ case $arg in #(
+ -*) false ;; # don't mess with options #(
+ /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath
+ [ -e "$t" ] ;; #(
+ *) false ;;
+ esac
+ then
+ arg=$( cygpath --path --ignore --mixed "$arg" )
+ fi
+ # Roll the args list around exactly as many times as the number of
+ # args, so each arg winds up back in the position where it started, but
+ # possibly modified.
+ #
+ # NB: a `for` loop captures its iteration list before it begins, so
+ # changing the positional parameters here affects neither the number of
+ # iterations, nor the values presented in `arg`.
+ shift # remove old arg
+ set -- "$@" "$arg" # push replacement arg
+ done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command;
+# * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+# shell script including quotes and variable substitutions, so put them in
+# double quotes to make sure that they get re-expanded; and
+# * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+ "-Dorg.gradle.appname=$APP_BASE_NAME" \
+ -classpath "$CLASSPATH" \
+ org.gradle.wrapper.GradleWrapperMain \
+ "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+ die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+# readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+# set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+ printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+ xargs -n1 |
+ sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+ tr '\n' ' '
+ )" '"$@"'
+
+exec "$JAVACMD" "$@"
diff --git a/gradlew.bat b/gradlew.bat
new file mode 100644
index 0000000..93e3f59
--- /dev/null
+++ b/gradlew.bat
@@ -0,0 +1,92 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/jitpack.yml b/jitpack.yml
new file mode 100644
index 0000000..09bbb51
--- /dev/null
+++ b/jitpack.yml
@@ -0,0 +1,2 @@
+before_install:
+ - ./gradlew setupCIWorkspace
\ No newline at end of file
diff --git a/libs/cindercore_modlist.jar b/libs/cindercore_modlist.jar
new file mode 100644
index 0000000..bae2c50
Binary files /dev/null and b/libs/cindercore_modlist.jar differ
diff --git a/libs/cindercore_modlist.jar_old b/libs/cindercore_modlist.jar_old
new file mode 100644
index 0000000..dcb2095
Binary files /dev/null and b/libs/cindercore_modlist.jar_old differ
diff --git a/libs/lotr.jar b/libs/lotr.jar
new file mode 100644
index 0000000..810493a
Binary files /dev/null and b/libs/lotr.jar differ
diff --git a/repositories.gradle b/repositories.gradle
new file mode 100644
index 0000000..c884390
--- /dev/null
+++ b/repositories.gradle
@@ -0,0 +1,5 @@
+// Add any additional repositories for your dependencies here
+
+repositories {
+
+}
diff --git a/run/natives/lwjgl2/jinput-dx8.dll b/run/natives/lwjgl2/jinput-dx8.dll
new file mode 100644
index 0000000..bf3fe90
Binary files /dev/null and b/run/natives/lwjgl2/jinput-dx8.dll differ
diff --git a/run/natives/lwjgl2/jinput-dx8_64.dll b/run/natives/lwjgl2/jinput-dx8_64.dll
new file mode 100644
index 0000000..a56d9a7
Binary files /dev/null and b/run/natives/lwjgl2/jinput-dx8_64.dll differ
diff --git a/run/natives/lwjgl2/jinput-raw.dll b/run/natives/lwjgl2/jinput-raw.dll
new file mode 100644
index 0000000..1131d47
Binary files /dev/null and b/run/natives/lwjgl2/jinput-raw.dll differ
diff --git a/run/natives/lwjgl2/jinput-raw_64.dll b/run/natives/lwjgl2/jinput-raw_64.dll
new file mode 100644
index 0000000..38e1c10
Binary files /dev/null and b/run/natives/lwjgl2/jinput-raw_64.dll differ
diff --git a/run/natives/lwjgl2/jinput-wintab.dll b/run/natives/lwjgl2/jinput-wintab.dll
new file mode 100644
index 0000000..e075ec3
Binary files /dev/null and b/run/natives/lwjgl2/jinput-wintab.dll differ
diff --git a/run/natives/lwjgl2/libjinput-linux.so b/run/natives/lwjgl2/libjinput-linux.so
new file mode 100644
index 0000000..dba9e59
Binary files /dev/null and b/run/natives/lwjgl2/libjinput-linux.so differ
diff --git a/run/natives/lwjgl2/libjinput-linux64.so b/run/natives/lwjgl2/libjinput-linux64.so
new file mode 100644
index 0000000..8b5f9d8
Binary files /dev/null and b/run/natives/lwjgl2/libjinput-linux64.so differ
diff --git a/run/natives/lwjgl2/libjinput-osx.jnilib b/run/natives/lwjgl2/libjinput-osx.jnilib
new file mode 100644
index 0000000..59a3eab
Binary files /dev/null and b/run/natives/lwjgl2/libjinput-osx.jnilib differ
diff --git a/run/natives/lwjgl2/liblwjgl.so b/run/natives/lwjgl2/liblwjgl.so
new file mode 100644
index 0000000..ba6e7f6
Binary files /dev/null and b/run/natives/lwjgl2/liblwjgl.so differ
diff --git a/run/natives/lwjgl2/liblwjgl64.so b/run/natives/lwjgl2/liblwjgl64.so
new file mode 100644
index 0000000..8ed0992
Binary files /dev/null and b/run/natives/lwjgl2/liblwjgl64.so differ
diff --git a/run/natives/lwjgl2/libopenal.so b/run/natives/lwjgl2/libopenal.so
new file mode 100644
index 0000000..0a3a619
Binary files /dev/null and b/run/natives/lwjgl2/libopenal.so differ
diff --git a/run/natives/lwjgl2/libopenal64.so b/run/natives/lwjgl2/libopenal64.so
new file mode 100644
index 0000000..e0693c0
Binary files /dev/null and b/run/natives/lwjgl2/libopenal64.so differ
diff --git a/settings.gradle b/settings.gradle
new file mode 100644
index 0000000..e334397
--- /dev/null
+++ b/settings.gradle
@@ -0,0 +1,28 @@
+
+pluginManagement {
+ repositories {
+ maven {
+ // RetroFuturaGradle
+ name "GTNH Maven"
+ url "http://jenkins.usrv.eu:8081/nexus/content/groups/public/"
+ allowInsecureProtocol = true
+ mavenContent {
+ includeGroup("com.gtnewhorizons.retrofuturagradle")
+ }
+ }
+ gradlePluginPortal()
+ mavenCentral()
+ mavenLocal()
+ }
+}
+
+plugins {
+ id 'com.diffplug.blowdryerSetup' version '1.6.0'
+ id 'org.gradle.toolchains.foojay-resolver-convention' version '0.4.0' // Provides java toolchains
+}
+
+blowdryerSetup {
+ repoSubfolder 'gtnhShared'
+ github('GTNewHorizons/ExampleMod1.7.10', 'tag', '0.2.2')
+ //devLocal '.' // Use this when testing config updates locally
+}
diff --git a/shortcut b/shortcut
new file mode 120000
index 0000000..d473c46
--- /dev/null
+++ b/shortcut
@@ -0,0 +1 @@
+src/main/java/com/zivilon/cindercore/
\ No newline at end of file
diff --git a/src/main/java/com/zivilon/cindercore/CinderCore.java b/src/main/java/com/zivilon/cindercore/CinderCore.java
new file mode 100644
index 0000000..eebab9b
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/CinderCore.java
@@ -0,0 +1,202 @@
+package com.zivilon.cindercore;
+
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.Mod;
+import cpw.mods.fml.common.Mod.EventHandler;
+import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.gameevent.PlayerEvent.PlayerChangedDimensionEvent;
+import cpw.mods.fml.common.network.FMLNetworkEvent;
+import cpw.mods.fml.common.network.FMLNetworkEvent.ServerConnectionFromClientEvent;
+import cpw.mods.fml.common.registry.EntityRegistry;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.UUID;
+
+
+import io.netty.channel.ChannelDuplexHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelPipeline;
+import io.netty.channel.ChannelPromise;
+
+import net.minecraft.command.CommandHandler;
+import net.minecraft.command.ICommand;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityList;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.network.NetHandlerPlayServer;
+import net.minecraft.network.play.server.S30PacketWindowItems;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.world.World;
+
+import io.netty.channel.Channel;
+
+import com.zivilon.cindercore.network.PacketInterceptor;
+
+import com.zivilon.cindercore.mixins.MixinEntityList;
+import com.zivilon.cindercore_modlist.CinderCoreModlist;
+import com.zivilon.cindercore_modlist.CustomFallbackEntry;
+import com.zivilon.cindercore_modlist.FallbackEntry;
+
+@Mod(modid = CinderCore.MODID, version = CinderCore.VERSION, dependencies = "required-after:spongemixins@[1.1.0,)", acceptableRemoteVersions = "*", useMetadata = true)
+public class CinderCore
+{
+ public static final String MODID = "cindercore";
+ public static final String VERSION = "1.0";
+ public static final Map playerChannelMap = new HashMap<>();
+ public static final boolean debug = false;
+
+ @EventHandler
+ public void init(FMLInitializationEvent event)
+ {
+ System.out.println("Cinder Core initialized");
+ if (FMLCommonHandler.instance().getEffectiveSide().isServer()) {
+ FMLCommonHandler.instance().bus().register(new PlayerEventHandler());
+ }
+ }
+
+ public static void registerItemFallback(int item_id, int fallback_id, String mod_name, String mod_version) {
+ FallbackEntry fallback = new FallbackEntry(item_id, fallback_id, mod_name, mod_version);
+ CinderCoreModlist.register_item_fallback(item_id, fallback);
+ }
+
+ public static void registerEntityFallback(Class entity_class, Class fallback_class, String mod_name, String mod_version) {
+ EntityRegistry registry_instance = EntityRegistry.instance();
+ int entity_id = registry_instance.lookupModSpawn(entity_class, false).getModEntityId();
+ int fallback_id;
+
+ EntityRegistry.EntityRegistration modRegistration = registry_instance.lookupModSpawn(fallback_class, false);
+ if (modRegistration != null) {
+ fallback_id = modRegistration.getModEntityId();
+ } else {
+
+ // If it's not a mod entity, check if it's a vanilla entity
+ Integer vanillaId = getEntityIDFromClass(fallback_class);
+ if (vanillaId != null) {
+ fallback_id = vanillaId;
+ } else {
+ System.out.println("[CinderCore] Attempted to register fallback with unregistered entity class. This will not work!");
+ return;
+ }
+ }
+
+ FallbackEntry fallback = new FallbackEntry(entity_id, fallback_id, mod_name, mod_version);
+ if (debug) System.out.println("[CinderCore] Registering entity " + entity_id + " with fallback " + fallback_id);
+ CinderCoreModlist.register_entity_fallback(entity_id, fallback);
+ }
+
+ public static int getEntityIDFromClass(Class entityClass) {
+ MinecraftServer server = FMLCommonHandler.instance().getMinecraftServerInstance();
+ World world = (World) server.worldServers[0];
+ try {
+ Entity entity = entityClass.getConstructor(World.class).newInstance(world);
+ return EntityList.getEntityID(entity);
+ } catch (Exception e) {
+ e.printStackTrace();
+ return 0;
+ }
+ }
+
+ public static void registerCustomFallback(int original_id, int fallback_id, String type, String mod_name, String mod_version) {
+ CustomFallbackEntry fallback = new CustomFallbackEntry(original_id, fallback_id, type, mod_name, mod_version);
+ CinderCoreModlist.register_custom_fallback(type, fallback);
+ }
+
+ public static Map getItemFallbackMap(UUID uuid) {
+ return CinderCoreModlist.getPlayerItemFallbacks(uuid);
+ }
+ public static Map getEntityFallbackMap(UUID uuid) {
+ return CinderCoreModlist.getPlayerEntityFallbacks(uuid);
+ }
+
+ public static Map> getCustomFallbackMap(UUID uuid) {
+ return CinderCoreModlist.getPlayerCustomFallbacks(uuid);
+ }
+
+ public static UUID getPlayerFromChannel(Channel channel) {
+ return CinderCore.playerChannelMap.get(channel);
+ }
+
+ // Debug method
+ public static void printMapContents(Map map) {
+ if (map.isEmpty()) {
+ System.out.println("Map is empty.");
+ } else {
+ for (Map.Entry entry : map.entrySet()) {
+ System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
+ }
+ }
+ }
+
+ public class PlayerEventHandler {
+ @SubscribeEvent
+ public void onConnectionFromClient(FMLNetworkEvent.ServerConnectionFromClientEvent event) {
+ // Record channel to map
+ Channel channel = event.manager.channel();
+ UUID uuid = ((NetHandlerPlayServer) event.handler).playerEntity.getUniqueID();
+
+ if (event.handler instanceof NetHandlerPlayServer) {
+ playerChannelMap.put(channel, uuid);
+ }
+ Map itemFallbackMap = getItemFallbackMap(uuid);
+ Map entityFallbackMap = getEntityFallbackMap(uuid);
+
+ if (debug) {
+ System.out.println("[CinderCore] Initiating Cinder for UUID: " + uuid);
+ if (itemFallbackMap == null) {
+ System.out.println("[CinderCore] Item fallback map is null");
+ } else if (itemFallbackMap.isEmpty()) {
+ System.out.println("[CinderCore] Item fallback map is empty");
+ } else {
+ System.out.println("[CinderCore] Item fallback map:");
+ printMapContents(itemFallbackMap);
+ }
+ if (entityFallbackMap == null) {
+ System.out.println("[CinderCore] Entity fallback map is null");
+ } else if (entityFallbackMap.isEmpty()) {
+ System.out.println("[CinderCore] Entity fallback map is empty");
+ } else {
+ System.out.println("[CinderCore] Entity fallback map:");
+ printMapContents(entityFallbackMap);
+ }
+ printMapContentsCustom(getCustomFallbackMap(uuid));
+ }
+
+
+ if (uuid != null) {
+ // Only attach packet listener if fallback maps are not empty
+ if (itemFallbackMap != null && !itemFallbackMap.isEmpty() && entityFallbackMap != null && !entityFallbackMap.isEmpty()) {
+ System.out.println("[CinderCore] Attaching packet interceptor to " + getPlayerFromChannel(channel));
+ channel.pipeline().addLast("modification_handler", new PacketInterceptor(uuid));
+ } else if (debug) {
+ System.out.println("[CinderCore] No item fallbacks needed for UUID: " + uuid);
+ }
+ }
+ }
+ }
+
+ // Debug method
+ public static void printMapContentsCustom(Map> data) {
+ if (data == null || data.isEmpty()) {
+ System.out.println("Map is empty.");
+ return;
+ }
+
+ for (String outerKey : data.keySet()) {
+ System.out.println("Key: " + outerKey);
+ Map innerMap = data.get(outerKey);
+ for (Integer innerKey : innerMap.keySet()) {
+ System.out.println(" - " + innerKey + ": " + innerMap.get(innerKey));
+ }
+ }
+ }
+}
diff --git a/src/main/java/com/zivilon/cindercore/coremod/ChunkMethodsTransformer.java b/src/main/java/com/zivilon/cindercore/coremod/ChunkMethodsTransformer.java
new file mode 100644
index 0000000..4d24396
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/coremod/ChunkMethodsTransformer.java
@@ -0,0 +1,39 @@
+package com.zivilon.cindercore.coremod;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.MethodNode;
+import org.objectweb.asm.tree.AnnotationNode;
+import net.minecraft.launchwrapper.IClassTransformer;
+
+
+public class ChunkMethodsTransformer implements IClassTransformer {
+ @Override
+ public byte[] transform(String name, String transformedName, byte[] classBytes) {
+ if ("net.minecraft.world.chunk.Chunk".equals(transformedName)) {
+ ClassReader reader = new ClassReader(classBytes);
+ ClassNode classNode = new ClassNode();
+ reader.accept(classNode, 0);
+
+ for (Object methodObj : classNode.methods) {
+ MethodNode method = (MethodNode) methodObj;
+ if ((method.name.equals("func_76607_a") && method.desc.equals("([BIIZ)V")) ||
+ (method.name.equals("func_76590_a") && method.desc.equals("()V"))) {
+ if (method.visibleAnnotations != null) {
+ method.visibleAnnotations.removeIf(annotation ->
+ ((AnnotationNode)annotation).desc.equals("Lcpw/mods/fml/relauncher/SideOnly;"));
+ }
+ }
+ }
+
+ ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
+ classNode.accept(writer);
+ return writer.toByteArray();
+ }
+
+ return classBytes;
+ }
+}
+
diff --git a/src/main/java/com/zivilon/cindercore/coremod/CoreMod.java b/src/main/java/com/zivilon/cindercore/coremod/CoreMod.java
new file mode 100644
index 0000000..6bfcc03
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/coremod/CoreMod.java
@@ -0,0 +1,40 @@
+package com.zivilon.cindercore.coremod;
+
+import cpw.mods.fml.relauncher.IFMLLoadingPlugin;
+import cpw.mods.fml.relauncher.IFMLLoadingPlugin.MCVersion;
+import cpw.mods.fml.relauncher.IFMLLoadingPlugin.SortingIndex;
+import cpw.mods.fml.relauncher.IFMLLoadingPlugin.TransformerExclusions;
+import org.spongepowered.asm.launch.MixinBootstrap;
+import org.spongepowered.asm.mixin.Mixins;
+import java.util.Map;
+
+@TransformerExclusions({"com.zivilon.cindercore.coremod"})
+@SortingIndex(1001)
+@MCVersion("1.7.10")
+public class CoreMod implements IFMLLoadingPlugin {
+ @Override
+ public String[] getASMTransformerClass() {
+ return new String[] { "com.zivilon.cindercore.coremod.PacketWindowItemsTransformer", "com.zivilon.cindercore.coremod.ChunkMethodsTransformer" };
+ }
+
+ @Override
+ public String getModContainerClass() {
+ return null;
+ }
+
+ @Override
+ public String getSetupClass() {
+ return null;
+ }
+
+ @Override
+ public void injectData(Map data) {
+ MixinBootstrap.init();
+ Mixins.addConfiguration("mixins.cindercore.json");
+ }
+
+ @Override
+ public String getAccessTransformerClass() {
+ return null;
+ }
+}
diff --git a/src/main/java/com/zivilon/cindercore/coremod/PacketWindowItemsTransformer.java b/src/main/java/com/zivilon/cindercore/coremod/PacketWindowItemsTransformer.java
new file mode 100644
index 0000000..2dd3d92
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/coremod/PacketWindowItemsTransformer.java
@@ -0,0 +1,51 @@
+package com.zivilon.cindercore.coremod;
+
+import net.minecraft.launchwrapper.IClassTransformer;
+import org.objectweb.asm.*;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.FileOutputStream;
+
+
+public class PacketWindowItemsTransformer implements IClassTransformer {
+ @Override
+ public byte[] transform(String name, String transformedName, byte[] classBytes) {
+ if (transformedName.equals("net.minecraft.network.play.server.S30PacketWindowItems")) {
+ System.out.println("Transforming: " + transformedName);
+ ClassReader reader = new ClassReader(classBytes);
+ ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
+ reader.accept(new ClassVisitor(Opcodes.ASM5, writer) {
+ @Override
+ public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
+ MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
+ if (name.equals("func_148911_c") || name.equals("func_148910_d")) {
+ return new MethodVisitor(Opcodes.ASM5, mv) {
+ @Override
+ public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
+ if (desc.equals("Lcpw/mods/fml/relauncher/SideOnly;")) {
+ return null;
+ }
+ return super.visitAnnotation(desc, visible);
+ }
+ };
+ }
+ return mv;
+ }
+ }, 0);
+ byte[] transformedBytes = writer.toByteArray();
+ writeToFile(transformedBytes, "S30PacketWindowItems.class");
+ return transformedBytes;
+ }
+ return classBytes;
+ }
+
+ private void writeToFile(byte[] data, String fileName) {
+ try (FileOutputStream out = new FileOutputStream(fileName)) {
+ out.write(data);
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+}
diff --git a/src/main/java/com/zivilon/cindercore/interfaces/ICustomChunk.java b/src/main/java/com/zivilon/cindercore/interfaces/ICustomChunk.java
new file mode 100644
index 0000000..13e9d38
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/interfaces/ICustomChunk.java
@@ -0,0 +1,5 @@
+package com.zivilon.cindercore.interfaces;
+
+public interface ICustomChunk {
+ void fillChunk(byte[] data, int additionalData1, int additionalData2, boolean flag);
+}
diff --git a/src/main/java/com/zivilon/cindercore/interfaces/IFMLNetworkHandlerMixin.java b/src/main/java/com/zivilon/cindercore/interfaces/IFMLNetworkHandlerMixin.java
new file mode 100644
index 0000000..37f7005
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/interfaces/IFMLNetworkHandlerMixin.java
@@ -0,0 +1,18 @@
+package com.zivilon.cindercore.interfaces;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.network.Packet;
+import cpw.mods.fml.common.registry.EntityRegistry.EntityRegistration;
+
+public interface IFMLNetworkHandlerMixin {
+ static Packet getEntitySpawningPacket(Entity entity, EntityPlayerMP player) {
+ throw new UnsupportedOperationException("This method should be implemented in a mixin");
+ }
+
+ static EntityRegistration get_entity_registration_by_entity_id(int entityId) {
+ throw new UnsupportedOperationException("This method should be implemented in a mixin");
+ }
+}
+
+
diff --git a/src/main/java/com/zivilon/cindercore/mixins/EntityRegistryAccessor.java b/src/main/java/com/zivilon/cindercore/mixins/EntityRegistryAccessor.java
new file mode 100644
index 0000000..0723cf2
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/EntityRegistryAccessor.java
@@ -0,0 +1,17 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Dynamic;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import net.minecraft.entity.Entity;
+import cpw.mods.fml.common.registry.EntityRegistry;
+import cpw.mods.fml.common.registry.EntityRegistry.EntityRegistration;
+
+import com.google.common.collect.BiMap;
+
+@Mixin(EntityRegistry.class)
+public interface EntityRegistryAccessor {
+ @Accessor("entityClassRegistrations")
+ BiMap, EntityRegistration> getEntityClassRegistrations();
+}
diff --git a/src/main/java/com/zivilon/cindercore/mixins/FMLNetworkHandlerAccessor.java b/src/main/java/com/zivilon/cindercore/mixins/FMLNetworkHandlerAccessor.java
new file mode 100644
index 0000000..f801f28
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/FMLNetworkHandlerAccessor.java
@@ -0,0 +1,22 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Dynamic;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import net.minecraft.entity.Entity;
+import cpw.mods.fml.common.registry.EntityRegistry;
+import cpw.mods.fml.common.registry.EntityRegistry.EntityRegistration;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.common.network.internal.FMLNetworkHandler;
+import cpw.mods.fml.common.network.FMLEmbeddedChannel;
+
+import java.util.EnumMap;
+
+
+@Mixin(FMLNetworkHandler.class)
+public interface FMLNetworkHandlerAccessor {
+ @Accessor("channelPair")
+ static EnumMap getChannelPair() { throw new AssertionError(); }
+}
+
diff --git a/src/main/java/com/zivilon/cindercore/mixins/LOTRPatches.java b/src/main/java/com/zivilon/cindercore/mixins/LOTRPatches.java
new file mode 100644
index 0000000..ba0b983
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/LOTRPatches.java
@@ -0,0 +1,149 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Dynamic;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.lang.reflect.Field;
+
+import net.minecraft.item.ItemStack;
+
+import com.zivilon.cindercore.network.PacketInterceptor;
+import com.zivilon.cindercore.CinderCore;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.DataWatcher;
+
+import lotr.common.item.LOTRItemBanner;
+import lotr.common.entity.item.LOTREntityBanner;
+import lotr.common.entity.item.LOTREntityBannerWall;
+
+@Mixin(PacketInterceptor.class)
+public abstract class LOTRPatches {
+
+ @Inject(method = "process_custom_item_datavalue", at = @At("HEAD"), cancellable = true, remap = false)
+ private void process(ItemStack item, UUID uuid, CallbackInfo ci) {
+ System.out.println("Running process_custom_item_datavalue");
+ int datavalue = item.getItemDamage();
+ String item_name = item.getItem().getUnlocalizedName();
+ if (item_name.equals("item.lotr:banner")) {
+ Map> fallbacks = CinderCore.getCustomFallbackMap(uuid);
+ Map bannerFallbacks = fallbacks.get("banner");
+ if (bannerFallbacks != null) {
+ Integer replacementDataValue = bannerFallbacks.get(datavalue);
+ if (replacementDataValue != null) {
+ item.setItemDamage(replacementDataValue);
+ }
+ }
+ }
+ }
+
+ @Inject(method = "process_custom_item_datavalue_int", at = @At("HEAD"), cancellable = true, remap = false)
+ private void process(int datavalue, String item_name, UUID uuid, CallbackInfoReturnable ci) {
+ System.out.println("Running process_custom_item_datavalue_int");
+ if (item_name.equals("item.lotr:banner")) {
+ Map> fallbacks = CinderCore.getCustomFallbackMap(uuid);
+ Map bannerFallbacks = fallbacks.get("banner");
+ if (bannerFallbacks != null) {
+ Integer replacementDataValue = bannerFallbacks.get(datavalue);
+ if (replacementDataValue != null) {
+ datavalue = replacementDataValue;
+ }
+ }
+ }
+ }
+ @Inject(method = "process_custom_entity", at = @At("HEAD"), cancellable = true, remap = false)
+ private static void process(Entity entity, UUID uuid, CallbackInfo ci) {
+ System.out.println("Running process_custom_entity");
+ if (entity == null) System.out.println("Entity is null");
+ String class_name = entity.getClass().getName();
+ System.out.println("[DEBUG] Entity class: " + class_name);
+ DataWatcher dataWatcher = null;
+ Field dataWatcherField = null;
+ Class currentClass = entity.getClass();
+ while (currentClass != null) {
+ try {
+ dataWatcherField = currentClass.getDeclaredField("field_70180_af");
+ dataWatcherField.setAccessible(true);
+ break;
+ } catch (NoSuchFieldException e) {
+ if (currentClass.getSuperclass() == null) System.out.println("Superclass is null");
+ currentClass = currentClass.getSuperclass();
+ }
+ }
+ try {
+ if (dataWatcherField == null) System.out.println("DataWatcherField is null");
+ dataWatcher = (DataWatcher)dataWatcherField.get(entity);
+ } catch (IllegalAccessException e) {
+ System.err.println("IllegalAccessException" + e);
+ }
+
+ if (dataWatcher == null) System.out.println("DataWatcher is null");
+ if (dataWatcher != null) System.out.println("DataWatcher is not null");
+
+ if (entity instanceof LOTREntityBanner || entity instanceof LOTREntityBannerWall) {
+ Map> fallbacks = CinderCore.getCustomFallbackMap(uuid);
+ System.out.println("Got custom fallbacks list");
+ Map bannerFallbacks = fallbacks.get("banner");
+ System.out.println("Got fallbacks list for banners");
+ if (bannerFallbacks != null) {
+ int originalBannerTypeID = dataWatcher.getWatchableObjectByte(18);;
+ Integer fallbackBannerTypeID = bannerFallbacks.get(originalBannerTypeID);
+
+ if (fallbackBannerTypeID != null) {
+ int id = fallbackBannerTypeID;
+ dataWatcher.updateObject(18, Byte.valueOf((byte)id));
+ }
+ }
+ }
+ }
+ @Inject(method = "process_custom_entity_metadata", at = @At("HEAD"), cancellable = true, remap = false)
+ private void process(Entity entity, int i, List originalMetadata, UUID uuid, CallbackInfo ci) {
+ System.out.println("Running process_custom_entity_metadata");
+ System.out.println("Sending metadata of entity class " + entity.getClass().getName());
+ DataWatcher.WatchableObject watchableObject = originalMetadata.get(i);
+ DataWatcher.WatchableObject modifiedWatchableObject = new DataWatcher.WatchableObject(watchableObject.getObjectType(), watchableObject.getDataValueId(), watchableObject.getObject());
+ Object obj = modifiedWatchableObject.getObject();
+
+ Map> fallbacks = CinderCore.getCustomFallbackMap(uuid);
+
+ if (entity != null && (entity instanceof LOTREntityBanner || entity instanceof LOTREntityBannerWall)) {
+ Map bannerFallbacks = fallbacks.get("banner");
+ System.out.println("Passed banner get");
+ if (bannerFallbacks != null) {
+ System.out.println("Fallbacks are not null");
+ if (obj instanceof Byte) {
+ System.out.println("Is byte");
+ Byte byteObj = (Byte) obj;
+ if (watchableObject.getDataValueId() == 18) {
+ System.out.println("Value is 18");
+ Integer fallbackBannerTypeID = bannerFallbacks.get((int)byteObj);
+ System.out.println("Fallback banner ID got: " + fallbackBannerTypeID);
+
+ if (fallbackBannerTypeID != null) {
+ System.out.println("Yes");
+ byteObj = (byte) fallbackBannerTypeID.byteValue();
+ modifiedWatchableObject.setObject(byteObj);
+ }
+ }
+ }
+ } else {
+ if (obj instanceof Byte) {
+ Byte byteObj = (Byte) obj;
+ System.out.println("Getting watchable object ID to check if banner: " + watchableObject.getDataValueId() + " with value " + byteObj);
+ }
+ }
+ }
+ originalMetadata.set(i, modifiedWatchableObject);
+ }
+}
+
diff --git a/src/main/java/com/zivilon/cindercore/mixins/MixinChunk.java b/src/main/java/com/zivilon/cindercore/mixins/MixinChunk.java
new file mode 100644
index 0000000..6d19872
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/MixinChunk.java
@@ -0,0 +1,239 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Dynamic;
+import org.spongepowered.asm.mixin.Shadow;
+import net.minecraft.world.chunk.Chunk;
+import net.minecraft.world.chunk.NibbleArray;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
+import net.minecraft.world.World;
+import net.minecraft.block.Block;
+import java.util.ArrayList;
+import java.util.Iterator;
+import org.apache.logging.log4j.Logger;
+import java.util.List;
+import java.util.Map;
+
+import com.zivilon.cindercore.interfaces.ICustomChunk;
+import com.zivilon.cindercore.util.MethodChecker;
+
+@Mixin(Chunk.class)
+public abstract class MixinChunk implements ICustomChunk {
+
+ @Shadow public static boolean isLit;
+ @Shadow private ExtendedBlockStorage[] storageArrays;
+ @Shadow private byte[] blockBiomeArray;
+ @Shadow public int[] precipitationHeightMap;
+ @Shadow public boolean[] updateSkylightColumns;
+ @Shadow public boolean isChunkLoaded;
+ @Shadow public World worldObj;
+ @Shadow public int[] heightMap;
+ @Shadow private boolean isGapLightingUpdated;
+ @Shadow public Map chunkTileEntityMap;
+ @Shadow public List[] entityLists;
+ @Shadow public boolean isTerrainPopulated;
+ @Shadow public boolean isLightPopulated;
+ @Shadow public boolean field_150815_m;
+ @Shadow public boolean isModified;
+ @Shadow public boolean hasEntities;
+ @Shadow public long lastSaveTime;
+ @Shadow public boolean sendUpdates;
+ @Shadow public int heightMapMinimum;
+ @Shadow public long inhabitedTime;
+ @Shadow private int queuedLightChecks;
+
+ @Shadow
+ public abstract Block getBlock(final int p_150810_1_, final int p_150810_2_, final int p_150810_3_);
+
+ @Shadow
+ public abstract int getBlockMetadata(int p_76628_1_, int p_76628_2_, int p_76628_3_);
+
+ @Shadow
+ public abstract int getTopFilledSegment();
+
+ @Shadow
+ public abstract int func_150808_b(int p_150808_1_, int p_150808_2_, int p_150808_3_);
+
+ @Dynamic
+ public void fillChunk(byte[] p_76607_1_, int p_76607_2_, int p_76607_3_, boolean p_76607_4_) {
+ Iterator iterator = chunkTileEntityMap.values().iterator();
+ while(iterator.hasNext())
+ {
+ TileEntity tileEntity = (TileEntity)iterator.next();
+ tileEntity.updateContainingBlockInfo();
+ tileEntity.getBlockMetadata();
+ tileEntity.getBlockType();
+ }
+
+ int k = 0;
+ boolean flag1 = !this.worldObj.provider.hasNoSky;
+ int l;
+
+ for (l = 0; l < this.storageArrays.length; ++l)
+ {
+ if ((p_76607_2_ & 1 << l) != 0)
+ {
+ if (this.storageArrays[l] == null)
+ {
+ this.storageArrays[l] = new ExtendedBlockStorage(l << 4, flag1);
+ }
+
+ byte[] abyte1 = this.storageArrays[l].getBlockLSBArray();
+ System.arraycopy(p_76607_1_, k, abyte1, 0, abyte1.length);
+ k += abyte1.length;
+ }
+ else if (p_76607_4_ && this.storageArrays[l] != null)
+ {
+ this.storageArrays[l] = null;
+ }
+ }
+
+ NibbleArray nibblearray;
+
+ for (l = 0; l < this.storageArrays.length; ++l)
+ {
+ if ((p_76607_2_ & 1 << l) != 0 && this.storageArrays[l] != null)
+ {
+ nibblearray = this.storageArrays[l].getMetadataArray();
+ System.arraycopy(p_76607_1_, k, nibblearray.data, 0, nibblearray.data.length);
+ k += nibblearray.data.length;
+ }
+ }
+
+ for (l = 0; l < this.storageArrays.length; ++l)
+ {
+ if ((p_76607_2_ & 1 << l) != 0 && this.storageArrays[l] != null)
+ {
+ nibblearray = this.storageArrays[l].getBlocklightArray();
+ System.arraycopy(p_76607_1_, k, nibblearray.data, 0, nibblearray.data.length);
+ k += nibblearray.data.length;
+ }
+ }
+
+ if (flag1)
+ {
+ for (l = 0; l < this.storageArrays.length; ++l)
+ {
+ if ((p_76607_2_ & 1 << l) != 0 && this.storageArrays[l] != null)
+ {
+ nibblearray = this.storageArrays[l].getSkylightArray();
+ System.arraycopy(p_76607_1_, k, nibblearray.data, 0, nibblearray.data.length);
+ k += nibblearray.data.length;
+ }
+ }
+ }
+
+ for (l = 0; l < this.storageArrays.length; ++l)
+ {
+ if ((p_76607_3_ & 1 << l) != 0)
+ {
+ if (this.storageArrays[l] == null)
+ {
+ k += 2048;
+ }
+ else
+ {
+ nibblearray = this.storageArrays[l].getBlockMSBArray();
+
+ if (nibblearray == null)
+ {
+ nibblearray = this.storageArrays[l].createBlockMSBArray();
+ }
+
+ System.arraycopy(p_76607_1_, k, nibblearray.data, 0, nibblearray.data.length);
+ k += nibblearray.data.length;
+ }
+ }
+ else if (p_76607_4_ && this.storageArrays[l] != null && this.storageArrays[l].getBlockMSBArray() != null)
+ {
+ this.storageArrays[l].clearMSBArray();
+ }
+ }
+
+ if (p_76607_4_)
+ {
+ System.arraycopy(p_76607_1_, k, this.blockBiomeArray, 0, this.blockBiomeArray.length);
+ int i1 = k + this.blockBiomeArray.length;
+ }
+
+ for (l = 0; l < this.storageArrays.length; ++l)
+ {
+ if (this.storageArrays[l] != null && (p_76607_2_ & 1 << l) != 0)
+ {
+ this.storageArrays[l].removeInvalidBlocks();
+ }
+ }
+
+ this.isLightPopulated = true;
+ this.isTerrainPopulated = true;
+ this.generateHeightMap();
+ List invalidList = new ArrayList();
+ iterator = this.chunkTileEntityMap.values().iterator();
+
+ while (iterator.hasNext())
+ {
+ TileEntity tileentity = (TileEntity)iterator.next();
+ int x = tileentity.xCoord & 15;
+ int y = tileentity.yCoord;
+ int z = tileentity.zCoord & 15;
+ Block block = tileentity.getBlockType();
+ if ((block != getBlock(x, y, z) || tileentity.blockMetadata != this.getBlockMetadata(x, y, z)) && tileentity.shouldRefresh(block, getBlock(x, y, z), tileentity.blockMetadata, this.getBlockMetadata(x, y, z), worldObj, x, y, z))
+ {
+ invalidList.add(tileentity);
+ }
+ tileentity.updateContainingBlockInfo();
+ }
+
+ for (TileEntity te : invalidList)
+ {
+ te.invalidate();
+ }
+ }
+
+ @Dynamic
+ public void generateHeightMap()
+ {
+ int i = this.getTopFilledSegment();
+ this.heightMapMinimum = Integer.MAX_VALUE;
+
+ for (int j = 0; j < 16; ++j)
+ {
+ int k = 0;
+
+ while (k < 16)
+ {
+ this.precipitationHeightMap[j + (k << 4)] = -999;
+ int l = i + 16 - 1;
+
+ while (true)
+ {
+ if (l > 0)
+ {
+ Block block = this.getBlock(j, l - 1, k);
+
+ if (func_150808_b(j, l - 1, k) == 0)
+ {
+ --l;
+ continue;
+ }
+
+ this.heightMap[k << 4 | j] = l;
+
+ if (l < this.heightMapMinimum)
+ {
+ this.heightMapMinimum = l;
+ }
+ }
+
+ ++k;
+ break;
+ }
+ }
+ }
+
+ this.isModified = true;
+ }
+
+
+}
\ No newline at end of file
diff --git a/src/main/java/com/zivilon/cindercore/mixins/MixinEntityList.java b/src/main/java/com/zivilon/cindercore/mixins/MixinEntityList.java
new file mode 100644
index 0000000..0a1e9ed
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/MixinEntityList.java
@@ -0,0 +1,18 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Dynamic;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityList;
+import net.minecraft.entity.DataWatcher;
+import java.util.List;
+import java.util.Map;
+
+@Mixin(EntityList.class)
+public interface MixinEntityList {
+ @Accessor("classToIDMapping")
+ Map, Integer> get_class_to_id_mapping();
+}
diff --git a/src/main/java/com/zivilon/cindercore/mixins/MixinEntityRegistry.java b/src/main/java/com/zivilon/cindercore/mixins/MixinEntityRegistry.java
new file mode 100644
index 0000000..8a91247
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/MixinEntityRegistry.java
@@ -0,0 +1,18 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Dynamic;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import net.minecraft.entity.Entity;
+import cpw.mods.fml.common.registry.EntityRegistry;
+import cpw.mods.fml.common.registry.EntityRegistry.EntityRegistration;
+
+import com.google.common.collect.BiMap;
+
+import com.zivilon.cindercore.mixins.EntityRegistryAccessor;
+
+@Mixin(EntityRegistry.class)
+public abstract class MixinEntityRegistry implements EntityRegistryAccessor {
+
+}
\ No newline at end of file
diff --git a/src/main/java/com/zivilon/cindercore/mixins/MixinEntityTrackerEntry.java b/src/main/java/com/zivilon/cindercore/mixins/MixinEntityTrackerEntry.java
new file mode 100644
index 0000000..8809215
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/MixinEntityTrackerEntry.java
@@ -0,0 +1,209 @@
+package com.zivilon.cindercore.mixins;
+
+import cpw.mods.fml.common.network.NetworkRegistry;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.Overwrite;
+import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import cpw.mods.fml.common.FMLLog;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.common.network.internal.FMLNetworkHandler;
+import cpw.mods.fml.common.registry.GameData;
+import cpw.mods.fml.common.registry.GameData.GameDataSnapshot;
+import cpw.mods.fml.common.registry.EntityRegistry;
+import cpw.mods.fml.common.registry.EntityRegistry.EntityRegistration;
+import cpw.mods.fml.common.network.internal.FMLMessage;
+
+import com.zivilon.cindercore.network.PacketInterceptor;
+import com.zivilon.cindercore_modlist.CinderCoreModlist;
+import com.zivilon.cindercore_modlist.util.HandshakeUtils;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.Map;
+import java.util.UUID;
+import net.minecraft.block.Block;
+import net.minecraft.entity.ai.attributes.ServersideAttributeMap;
+import net.minecraft.entity.boss.EntityDragon;
+import net.minecraft.entity.item.EntityBoat;
+import net.minecraft.entity.item.EntityEnderCrystal;
+import net.minecraft.entity.item.EntityEnderEye;
+import net.minecraft.entity.item.EntityEnderPearl;
+import net.minecraft.entity.item.EntityExpBottle;
+import net.minecraft.entity.item.EntityFallingBlock;
+import net.minecraft.entity.item.EntityFireworkRocket;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.item.EntityItemFrame;
+import net.minecraft.entity.item.EntityMinecart;
+import net.minecraft.entity.item.EntityPainting;
+import net.minecraft.entity.item.EntityTNTPrimed;
+import net.minecraft.entity.item.EntityXPOrb;
+import net.minecraft.entity.passive.IAnimals;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.projectile.EntityArrow;
+import net.minecraft.entity.projectile.EntityEgg;
+import net.minecraft.entity.projectile.EntityFireball;
+import net.minecraft.entity.projectile.EntityFishHook;
+import net.minecraft.entity.projectile.EntityPotion;
+import net.minecraft.entity.projectile.EntitySmallFireball;
+import net.minecraft.entity.projectile.EntitySnowball;
+import net.minecraft.entity.projectile.EntityWitherSkull;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.EntityLeashKnot;
+import net.minecraft.entity.EntityTrackerEntry;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemMap;
+import net.minecraft.item.ItemStack;
+import net.minecraft.network.Packet;
+import net.minecraft.network.play.server.S04PacketEntityEquipment;
+import net.minecraft.network.play.server.S0APacketUseBed;
+import net.minecraft.network.play.server.S0CPacketSpawnPlayer;
+import net.minecraft.network.play.server.S0EPacketSpawnObject;
+import net.minecraft.network.play.server.S0FPacketSpawnMob;
+import net.minecraft.network.play.server.S10PacketSpawnPainting;
+import net.minecraft.network.play.server.S11PacketSpawnExperienceOrb;
+import net.minecraft.network.play.server.S12PacketEntityVelocity;
+import net.minecraft.network.play.server.S14PacketEntity;
+import net.minecraft.network.play.server.S18PacketEntityTeleport;
+import net.minecraft.network.play.server.S19PacketEntityHeadLook;
+import net.minecraft.network.play.server.S1BPacketEntityAttach;
+import net.minecraft.network.play.server.S1CPacketEntityMetadata;
+import net.minecraft.network.play.server.S1DPacketEntityEffect;
+import net.minecraft.network.play.server.S20PacketEntityProperties;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.storage.MapData;
+
+import org.apache.logging.log4j.Logger;
+
+import com.zivilon.cindercore.interfaces.IFMLNetworkHandlerMixin;
+import com.zivilon.cindercore.mixins.MixinFMLNetworkHandler;
+import com.zivilon.cindercore.util.NetworkUtil;
+
+@Mixin(EntityTrackerEntry.class)
+public abstract class MixinEntityTrackerEntry {
+ private EntityPlayerMP capturedPlayer;
+
+ @Shadow public Entity myEntity;
+ @Shadow public int lastHeadMotion;
+
+
+ @Inject(method = "tryStartWachingThis", at = @At("HEAD"), locals = LocalCapture.CAPTURE_FAILHARD)
+ private void onTryStartWatchingThis(EntityPlayerMP player, CallbackInfo ci) {
+ this.capturedPlayer = player;
+ }
+
+ @Redirect(method = "tryStartWachingThis", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/EntityTrackerEntry;func_151260_c()Lnet/minecraft/network/Packet;"))
+ private Packet redirectFunc_151260_c(EntityTrackerEntry instance) {
+ return this.customFunc_151260_c(this.capturedPlayer);
+ }
+
+ private Packet customFunc_151260_c(EntityPlayerMP player) {
+ if (this.myEntity.isDead) {
+ System.err.println("Fetching addPacket for removed entity");
+ }
+
+ Packet pkt = NetworkUtil.getEntitySpawningPacket(myEntity, player);
+
+ if (pkt != null) {
+ return pkt;
+ }
+ if (this.myEntity instanceof EntityItem) {
+ return new S0EPacketSpawnObject(this.myEntity, 2, 1);
+ } else if (this.myEntity instanceof EntityPlayerMP) {
+ return new S0CPacketSpawnPlayer((EntityPlayer)this.myEntity);
+ } else if (this.myEntity instanceof EntityMinecart) {
+ EntityMinecart entityminecart = (EntityMinecart)this.myEntity;
+ return new S0EPacketSpawnObject(this.myEntity, 10, entityminecart.getMinecartType());
+ } else if (this.myEntity instanceof EntityBoat) {
+ return new S0EPacketSpawnObject(this.myEntity, 1);
+ } else if (!(this.myEntity instanceof IAnimals) && !(this.myEntity instanceof EntityDragon)) {
+ if (this.myEntity instanceof EntityFishHook) {
+ EntityPlayer entityplayer = ((EntityFishHook)this.myEntity).field_146042_b;
+ return new S0EPacketSpawnObject(this.myEntity, 90, entityplayer != null ? entityplayer.getEntityId() : this.myEntity.getEntityId());
+ } else if (this.myEntity instanceof EntityArrow) {
+ Entity entity = ((EntityArrow)this.myEntity).shootingEntity;
+ return new S0EPacketSpawnObject(this.myEntity, 60, entity != null ? entity.getEntityId() : this.myEntity.getEntityId());
+ } else if (this.myEntity instanceof EntitySnowball) {
+ return new S0EPacketSpawnObject(this.myEntity, 61);
+ } else if (this.myEntity instanceof EntityPotion) {
+ return new S0EPacketSpawnObject(this.myEntity, 73, ((EntityPotion)this.myEntity).getPotionDamage());
+ } else if (this.myEntity instanceof EntityExpBottle) {
+ return new S0EPacketSpawnObject(this.myEntity, 75);
+ } else if (this.myEntity instanceof EntityEnderPearl) {
+ return new S0EPacketSpawnObject(this.myEntity, 65);
+ } else if (this.myEntity instanceof EntityEnderEye) {
+ return new S0EPacketSpawnObject(this.myEntity, 72);
+ } else if (this.myEntity instanceof EntityFireworkRocket) {
+ return new S0EPacketSpawnObject(this.myEntity, 76);
+ } else {
+ S0EPacketSpawnObject s0epacketspawnobject;
+
+ if (this.myEntity instanceof EntityFireball) {
+ EntityFireball entityfireball = (EntityFireball)this.myEntity;
+ s0epacketspawnobject = null;
+ byte b0 = 63;
+
+ if (this.myEntity instanceof EntitySmallFireball) {
+ b0 = 64;
+ } else if (this.myEntity instanceof EntityWitherSkull) {
+ b0 = 66;
+ }
+
+ if (entityfireball.shootingEntity != null) {
+ s0epacketspawnobject = new S0EPacketSpawnObject(this.myEntity, b0, ((EntityFireball)this.myEntity).shootingEntity.getEntityId());
+ } else {
+ s0epacketspawnobject = new S0EPacketSpawnObject(this.myEntity, b0, 0);
+ }
+
+ s0epacketspawnobject.func_149003_d((int)(entityfireball.accelerationX * 8000.0D));
+ s0epacketspawnobject.func_149000_e((int)(entityfireball.accelerationY * 8000.0D));
+ s0epacketspawnobject.func_149007_f((int)(entityfireball.accelerationZ * 8000.0D));
+ return s0epacketspawnobject;
+ } else if (this.myEntity instanceof EntityEgg) {
+ return new S0EPacketSpawnObject(this.myEntity, 62);
+ } else if (this.myEntity instanceof EntityTNTPrimed) {
+ return new S0EPacketSpawnObject(this.myEntity, 50);
+ } else if (this.myEntity instanceof EntityEnderCrystal) {
+ return new S0EPacketSpawnObject(this.myEntity, 51);
+ } else if (this.myEntity instanceof EntityFallingBlock) {
+ EntityFallingBlock entityfallingblock = (EntityFallingBlock)this.myEntity;
+ return new S0EPacketSpawnObject(this.myEntity, 70, Block.getIdFromBlock(entityfallingblock.func_145805_f()) | entityfallingblock.field_145814_a << 16);
+ } else if (this.myEntity instanceof EntityPainting) {
+ return new S10PacketSpawnPainting((EntityPainting)this.myEntity);
+ } else if (this.myEntity instanceof EntityItemFrame) {
+ EntityItemFrame entityitemframe = (EntityItemFrame)this.myEntity;
+ s0epacketspawnobject = new S0EPacketSpawnObject(this.myEntity, 71, entityitemframe.hangingDirection);
+ s0epacketspawnobject.func_148996_a(MathHelper.floor_float((float)(entityitemframe.field_146063_b * 32)));
+ s0epacketspawnobject.func_148995_b(MathHelper.floor_float((float)(entityitemframe.field_146064_c * 32)));
+ s0epacketspawnobject.func_149005_c(MathHelper.floor_float((float)(entityitemframe.field_146062_d * 32)));
+ return s0epacketspawnobject;
+ } else if (this.myEntity instanceof EntityLeashKnot) {
+ EntityLeashKnot entityleashknot = (EntityLeashKnot)this.myEntity;
+ s0epacketspawnobject = new S0EPacketSpawnObject(this.myEntity, 77);
+ s0epacketspawnobject.func_148996_a(MathHelper.floor_float((float)(entityleashknot.field_146063_b * 32)));
+ s0epacketspawnobject.func_148995_b(MathHelper.floor_float((float)(entityleashknot.field_146064_c * 32)));
+ s0epacketspawnobject.func_149005_c(MathHelper.floor_float((float)(entityleashknot.field_146062_d * 32)));
+ return s0epacketspawnobject;
+ } else if (this.myEntity instanceof EntityXPOrb) {
+ return new S11PacketSpawnExperienceOrb((EntityXPOrb)this.myEntity);
+ } else {
+ throw new IllegalArgumentException("Don\'t know how to add " + this.myEntity.getClass() + "!");
+ }
+ }
+ } else {
+ this.lastHeadMotion = MathHelper.floor_float(this.myEntity.getRotationYawHead() * 256.0F / 360.0F);
+ return new S0FPacketSpawnMob((EntityLivingBase)this.myEntity);
+ }
+ }
+}
diff --git a/src/main/java/com/zivilon/cindercore/mixins/MixinExtendedBlockStorage.java b/src/main/java/com/zivilon/cindercore/mixins/MixinExtendedBlockStorage.java
new file mode 100644
index 0000000..0d4a94a
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/MixinExtendedBlockStorage.java
@@ -0,0 +1,22 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
+
+@Mixin(ExtendedBlockStorage.class)
+public interface MixinExtendedBlockStorage {
+
+ @Accessor("blockRefCount")
+ int getBlockRefCount();
+
+ @Accessor("tickRefCount")
+ int getTickRefCount();
+
+ @Accessor("blockRefCount")
+ void setBlockRefCount(int count);
+
+ @Accessor("tickRefCount")
+ void setTickRefCount(int count);
+
+}
diff --git a/src/main/java/com/zivilon/cindercore/mixins/MixinFMLNetworkHandler.java b/src/main/java/com/zivilon/cindercore/mixins/MixinFMLNetworkHandler.java
new file mode 100644
index 0000000..33342bd
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/MixinFMLNetworkHandler.java
@@ -0,0 +1,50 @@
+package com.zivilon.cindercore.mixins;
+
+import cpw.mods.fml.common.network.NetworkRegistry;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.Overwrite;
+import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import cpw.mods.fml.common.FMLLog;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.common.network.internal.FMLNetworkHandler;
+import cpw.mods.fml.common.network.FMLEmbeddedChannel;
+import cpw.mods.fml.common.registry.GameData;
+import cpw.mods.fml.common.registry.GameData.GameDataSnapshot;
+import cpw.mods.fml.common.registry.EntityRegistry;
+import cpw.mods.fml.common.registry.EntityRegistry.EntityRegistration;
+import cpw.mods.fml.common.network.internal.FMLMessage;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.network.Packet;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.Map;
+import java.util.UUID;
+import java.util.EnumMap;
+
+import org.apache.logging.log4j.Logger;
+
+import com.google.common.collect.BiMap;
+
+import com.zivilon.cindercore.interfaces.IFMLNetworkHandlerMixin;
+import com.zivilon.cindercore.CinderCore;
+import com.zivilon.cindercore.mixins.MixinEntityRegistry;
+import com.zivilon.cindercore.mixins.EntityRegistryAccessor;
+
+@Mixin(FMLNetworkHandler.class)
+public class MixinFMLNetworkHandler implements IFMLNetworkHandlerMixin {
+ private EntityPlayerMP capturedPlayer;
+
+ @Shadow private static EnumMap channelPair;
+}
diff --git a/src/main/java/com/zivilon/cindercore/mixins/MixinNibbleArray.java b/src/main/java/com/zivilon/cindercore/mixins/MixinNibbleArray.java
new file mode 100644
index 0000000..b1811bf
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/MixinNibbleArray.java
@@ -0,0 +1,12 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import net.minecraft.world.chunk.NibbleArray;
+
+@Mixin(NibbleArray.class)
+public interface MixinNibbleArray {
+
+ @Accessor("depthBits")
+ int getDepthBits();
+}
\ No newline at end of file
diff --git a/src/main/java/com/zivilon/cindercore/mixins/MixinPlayerManager.java b/src/main/java/com/zivilon/cindercore/mixins/MixinPlayerManager.java
new file mode 100644
index 0000000..b9ca947
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/MixinPlayerManager.java
@@ -0,0 +1,14 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import net.minecraft.world.WorldServer;
+import net.minecraft.server.management.PlayerManager;
+import java.util.List;
+
+@Mixin(PlayerManager.class)
+public interface MixinPlayerManager {
+
+ @Accessor("players")
+ List getPlayers();
+}
diff --git a/src/main/java/com/zivilon/cindercore/mixins/MixinS04PacketEntityEquipment.java b/src/main/java/com/zivilon/cindercore/mixins/MixinS04PacketEntityEquipment.java
new file mode 100644
index 0000000..9879036
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/MixinS04PacketEntityEquipment.java
@@ -0,0 +1,19 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Dynamic;
+import org.spongepowered.asm.mixin.Shadow;
+import net.minecraft.item.ItemStack;
+import net.minecraft.network.play.server.S04PacketEntityEquipment;
+
+@Mixin(S04PacketEntityEquipment.class)
+public abstract class MixinS04PacketEntityEquipment {
+
+ @Shadow private ItemStack field_149393_c;
+
+ @Dynamic
+ public ItemStack func_149390_c()
+ {
+ return this.field_149393_c;
+ }
+}
diff --git a/src/main/java/com/zivilon/cindercore/mixins/MixinS0CPacketSpawnPlayer.java b/src/main/java/com/zivilon/cindercore/mixins/MixinS0CPacketSpawnPlayer.java
new file mode 100644
index 0000000..3845ee0
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/MixinS0CPacketSpawnPlayer.java
@@ -0,0 +1,20 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Dynamic;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import net.minecraft.network.play.server.S0CPacketSpawnPlayer;
+
+@Mixin(S0CPacketSpawnPlayer.class)
+public interface MixinS0CPacketSpawnPlayer {
+
+ @Accessor("field_148959_h")
+ int get_item_ID();
+
+ @Accessor("field_148959_h")
+ void set_item_ID(int entity_ID);
+
+}
+
diff --git a/src/main/java/com/zivilon/cindercore/mixins/MixinS0EPacketSpawnObject.java b/src/main/java/com/zivilon/cindercore/mixins/MixinS0EPacketSpawnObject.java
new file mode 100644
index 0000000..d1730d5
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/MixinS0EPacketSpawnObject.java
@@ -0,0 +1,25 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Dynamic;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import net.minecraft.network.play.server.S0EPacketSpawnObject;
+
+@Mixin(S0EPacketSpawnObject.class)
+public interface MixinS0EPacketSpawnObject {
+
+ @Accessor("field_149019_j")
+ int get_id();
+
+ @Accessor("field_149019_j")
+ void set_id(int entity_ID);
+
+ @Accessor("field_149020_k")
+ int get_item_id();
+
+ @Accessor("field_149020_k")
+ void set_item_id(int item_ID);
+}
+
diff --git a/src/main/java/com/zivilon/cindercore/mixins/MixinS0FPacketSpawnMob.java b/src/main/java/com/zivilon/cindercore/mixins/MixinS0FPacketSpawnMob.java
new file mode 100644
index 0000000..e076076
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/MixinS0FPacketSpawnMob.java
@@ -0,0 +1,18 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Dynamic;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import net.minecraft.network.play.server.S0FPacketSpawnMob;
+
+@Mixin(S0FPacketSpawnMob.class)
+public interface MixinS0FPacketSpawnMob {
+
+ @Accessor("field_149040_b")
+ int get_id();
+
+ @Accessor("field_149040_b")
+ void set_id(int entity_ID);
+}
\ No newline at end of file
diff --git a/src/main/java/com/zivilon/cindercore/mixins/MixinS1CPacketEntityMetadata.java b/src/main/java/com/zivilon/cindercore/mixins/MixinS1CPacketEntityMetadata.java
new file mode 100644
index 0000000..c0d1c41
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/MixinS1CPacketEntityMetadata.java
@@ -0,0 +1,26 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Dynamic;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import net.minecraft.network.play.server.S1CPacketEntityMetadata;
+import net.minecraft.entity.DataWatcher;
+import java.util.List;
+
+@Mixin(S1CPacketEntityMetadata.class)
+public interface MixinS1CPacketEntityMetadata {
+
+ @Accessor("field_149379_a")
+ int get_entity_id();
+
+ @Accessor("field_149379_a")
+ void set_entity_id(int entityId);
+
+ @Accessor("field_149378_b")
+ List get_metadata();
+
+ @Accessor("field_149378_b")
+ void set_metadata(List metadata);
+}
diff --git a/src/main/java/com/zivilon/cindercore/mixins/MixinS21PacketChunkData.java b/src/main/java/com/zivilon/cindercore/mixins/MixinS21PacketChunkData.java
new file mode 100644
index 0000000..5fae454
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/MixinS21PacketChunkData.java
@@ -0,0 +1,53 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Dynamic;
+import org.spongepowered.asm.mixin.Shadow;
+import net.minecraft.network.play.server.S21PacketChunkData;
+
+@Mixin(S21PacketChunkData.class)
+public abstract class MixinS21PacketChunkData {
+
+ @Shadow private int field_149284_a; // X Coordinates
+ @Shadow private int field_149282_b; // Z Coordinates
+
+ // I have no idea but these are needed to decode the packet
+ @Shadow private int field_149283_c;
+ @Shadow private int field_149280_d;
+ @Shadow private byte[] field_149278_f;
+ @Shadow private boolean field_149279_g;
+
+ @Dynamic // Get Chunk X coordinates in packet
+ public int func_149273_e()
+ {
+ return this.field_149284_a;
+ }
+
+ @Dynamic // Get Chunk Z coordinates in packet
+ public int func_149271_f()
+ {
+ return this.field_149282_b;
+ }
+
+ // I have no idea but these are needed to decode the packet
+ @Dynamic
+ public byte[] func_149272_d()
+ {
+ return this.field_149278_f;
+ }
+ @Dynamic
+ public int func_149276_g()
+ {
+ return this.field_149283_c;
+ }
+ @Dynamic
+ public int func_149270_h()
+ {
+ return this.field_149280_d;
+ }
+ @Dynamic
+ public boolean func_149274_i()
+ {
+ return this.field_149279_g;
+ }
+}
diff --git a/src/main/java/com/zivilon/cindercore/mixins/MixinS22PacketMultiBlockChange.java b/src/main/java/com/zivilon/cindercore/mixins/MixinS22PacketMultiBlockChange.java
new file mode 100644
index 0000000..95cc3e9
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/MixinS22PacketMultiBlockChange.java
@@ -0,0 +1,19 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Dynamic;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import net.minecraft.network.play.server.S22PacketMultiBlockChange;
+import net.minecraft.block.Block;
+
+@Mixin(S22PacketMultiBlockChange.class)
+public interface MixinS22PacketMultiBlockChange {
+
+ @Accessor("field_148926_c")
+ byte[] get_block_data_array();
+
+ @Accessor("field_148926_c")
+ void set_block_data_array(byte[] array);
+}
diff --git a/src/main/java/com/zivilon/cindercore/mixins/MixinS23PacketBlockChange.java b/src/main/java/com/zivilon/cindercore/mixins/MixinS23PacketBlockChange.java
new file mode 100644
index 0000000..7e6acd9
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/MixinS23PacketBlockChange.java
@@ -0,0 +1,29 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Dynamic;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import net.minecraft.network.play.server.S23PacketBlockChange;
+import net.minecraft.block.Block;
+
+@Mixin(S23PacketBlockChange.class)
+public interface MixinS23PacketBlockChange {
+
+ @Accessor("field_148887_a")
+ int get_x();
+
+ @Accessor("field_148885_b")
+ int get_y();
+
+ @Accessor("field_148886_c")
+ int get_z();
+
+ @Accessor("field_148883_d")
+ Block get_block();
+
+ @Accessor("field_148883_d")
+ void set_block(Block block);
+
+}
diff --git a/src/main/java/com/zivilon/cindercore/mixins/MixinS24PacketBlockAction.java b/src/main/java/com/zivilon/cindercore/mixins/MixinS24PacketBlockAction.java
new file mode 100644
index 0000000..81b9704
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/MixinS24PacketBlockAction.java
@@ -0,0 +1,20 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Dynamic;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import net.minecraft.network.play.server.S24PacketBlockAction;
+import net.minecraft.block.Block;
+
+@Mixin(S24PacketBlockAction.class)
+public interface MixinS24PacketBlockAction {
+
+ @Accessor("field_148871_f")
+ Block get_block();
+
+ @Accessor("field_148871_f")
+ void set_block(Block block);
+
+}
diff --git a/src/main/java/com/zivilon/cindercore/mixins/MixinS26PacketMapChunkBulk.java b/src/main/java/com/zivilon/cindercore/mixins/MixinS26PacketMapChunkBulk.java
new file mode 100644
index 0000000..8729c96
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/MixinS26PacketMapChunkBulk.java
@@ -0,0 +1,48 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Dynamic;
+import org.spongepowered.asm.mixin.Shadow;
+import net.minecraft.network.play.server.S26PacketMapChunkBulk;
+
+@Mixin(S26PacketMapChunkBulk.class)
+public abstract class MixinS26PacketMapChunkBulk {
+
+ @Shadow private int[] field_149266_a; // X Coordinates
+ @Shadow private int[] field_149264_b; // Z Coordinates
+
+ // I have no idea but these are needed to decode the packet
+ @Shadow private int[] field_149265_c;
+ @Shadow private int[] field_149262_d;
+ @Shadow private byte[][] field_149260_f;
+
+ @Dynamic // Get Chunk X coordinates in packet
+ public int func_149255_a(int index) {
+ return this.field_149266_a[index];
+ }
+
+ @Dynamic // Get Chunk Z coordinates in packet
+ public int func_149253_b(int index) {
+ return this.field_149264_b[index];
+ }
+
+ @Dynamic // Get length of coordinate array (i.e. get number of chunks)
+ public int func_149254_d() {
+ return this.field_149266_a.length;
+ }
+
+ // I have no idea but these are needed to decode the packet
+ @Dynamic
+ public byte[] func_149256_c(int p_149256_1_) {
+ return this.field_149260_f[p_149256_1_];
+ }
+ @Dynamic
+ public int[] func_149252_e() {
+ return this.field_149265_c;
+ }
+ @Dynamic
+ public int[] func_149257_f() {
+ return this.field_149262_d;
+ }
+
+}
\ No newline at end of file
diff --git a/src/main/java/com/zivilon/cindercore/mixins/MixinS2FPacketSetSlot.java b/src/main/java/com/zivilon/cindercore/mixins/MixinS2FPacketSetSlot.java
new file mode 100644
index 0000000..985679a
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/MixinS2FPacketSetSlot.java
@@ -0,0 +1,30 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Dynamic;
+import org.spongepowered.asm.mixin.Shadow;
+import net.minecraft.item.ItemStack;
+import net.minecraft.network.play.server.S2FPacketSetSlot;
+
+@Mixin(S2FPacketSetSlot.class)
+public abstract class MixinS2FPacketSetSlot {
+
+ @Shadow private int field_149179_a;
+ @Shadow private int field_149177_b;
+ @Shadow private ItemStack field_149178_c;
+
+ @Dynamic
+ public int func_149175_c() {
+ return this.field_149179_a;
+ }
+
+ @Dynamic
+ public int func_149173_d() {
+ return this.field_149177_b;
+ }
+
+ @Dynamic
+ public ItemStack func_149174_e() {
+ return this.field_149178_c;
+ }
+}
diff --git a/src/main/java/com/zivilon/cindercore/mixins/MixinS30PacketWindowItems.java b/src/main/java/com/zivilon/cindercore/mixins/MixinS30PacketWindowItems.java
new file mode 100644
index 0000000..0a39ad9
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/MixinS30PacketWindowItems.java
@@ -0,0 +1,18 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Dynamic;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import net.minecraft.item.ItemStack;
+import net.minecraft.network.play.server.S30PacketWindowItems;
+
+@Mixin(S30PacketWindowItems.class)
+public interface MixinS30PacketWindowItems {
+
+ @Accessor("field_148914_a")
+ int func_148911_c();
+
+ @Accessor("field_148913_b")
+ ItemStack[] func_148910_d();
+}
diff --git a/src/main/java/com/zivilon/cindercore/mixins/MixinWorldServer.java b/src/main/java/com/zivilon/cindercore/mixins/MixinWorldServer.java
new file mode 100644
index 0000000..c67422f
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/mixins/MixinWorldServer.java
@@ -0,0 +1,13 @@
+package com.zivilon.cindercore.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import net.minecraft.world.WorldServer;
+import net.minecraft.server.management.PlayerManager;
+
+@Mixin(WorldServer.class)
+public interface MixinWorldServer {
+
+ @Accessor("thePlayerManager")
+ PlayerManager getPlayerManager();
+}
diff --git a/src/main/java/com/zivilon/cindercore/network/PacketInterceptor.java b/src/main/java/com/zivilon/cindercore/network/PacketInterceptor.java
new file mode 100644
index 0000000..0bed4a2
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/network/PacketInterceptor.java
@@ -0,0 +1,561 @@
+package com.zivilon.cindercore.network;
+
+import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.event.FMLServerStartingEvent;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.Mod;
+import cpw.mods.fml.common.Mod.EventHandler;
+import cpw.mods.fml.common.gameevent.PlayerEvent;
+import cpw.mods.fml.common.network.FMLNetworkEvent;
+import cpw.mods.fml.common.network.FMLNetworkEvent.ServerConnectionFromClientEvent;
+import cpw.mods.fml.common.network.NetworkRegistry;
+import cpw.mods.fml.common.network.handshake.FMLHandshakeMessage;
+import cpw.mods.fml.common.network.internal.EntitySpawnHandler;
+import cpw.mods.fml.common.network.internal.FMLMessage;
+import net.minecraftforge.common.MinecraftForge;
+
+import net.minecraft.entity.DataWatcher;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.block.Block;
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.network.NetHandlerPlayServer;
+import net.minecraft.network.Packet;
+import net.minecraft.network.play.server.S00PacketKeepAlive;
+import net.minecraft.network.play.server.S02PacketChat;
+import net.minecraft.network.play.server.S03PacketTimeUpdate;
+import net.minecraft.network.play.server.S04PacketEntityEquipment;
+import net.minecraft.network.play.server.S05PacketSpawnPosition;
+import net.minecraft.network.play.server.S06PacketUpdateHealth;
+import net.minecraft.network.play.server.S08PacketPlayerPosLook;
+import net.minecraft.network.play.server.S0CPacketSpawnPlayer;
+import net.minecraft.network.play.server.S0EPacketSpawnObject;
+import net.minecraft.network.play.server.S0FPacketSpawnMob;
+
+import net.minecraft.network.play.server.S12PacketEntityVelocity;
+import net.minecraft.network.play.server.S13PacketDestroyEntities;
+import net.minecraft.network.play.server.S14PacketEntity;
+import net.minecraft.network.play.server.S18PacketEntityTeleport;
+import net.minecraft.network.play.server.S19PacketEntityHeadLook;
+import net.minecraft.network.play.server.S1BPacketEntityAttach;
+import net.minecraft.network.play.server.S1CPacketEntityMetadata;
+import net.minecraft.network.play.server.S1FPacketSetExperience;
+
+import net.minecraft.network.play.server.S20PacketEntityProperties;
+import net.minecraft.network.play.server.S21PacketChunkData;
+import net.minecraft.network.play.server.S22PacketMultiBlockChange;
+import net.minecraft.network.play.server.S23PacketBlockChange;
+import net.minecraft.network.play.server.S24PacketBlockAction;
+import net.minecraft.network.play.server.S26PacketMapChunkBulk;
+import net.minecraft.network.play.server.S28PacketEffect;
+import net.minecraft.network.play.server.S29PacketSoundEffect;
+import net.minecraft.network.play.server.S2FPacketSetSlot;
+
+import net.minecraft.network.play.server.S30PacketWindowItems;
+import net.minecraft.network.play.server.S33PacketUpdateSign;
+import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
+import net.minecraft.network.play.server.S3FPacketCustomPayload;
+
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.chunk.Chunk;
+import net.minecraft.world.WorldServer;
+import net.minecraft.world.World;
+
+import cpw.mods.fml.common.network.internal.FMLProxyPacket;
+
+import io.netty.channel.ChannelDuplexHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelPromise;
+import io.netty.buffer.UnpooledUnsafeDirectByteBuf;
+
+import java.io.DataInputStream;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.List;
+import java.util.UUID;
+import java.util.zip.Inflater;
+import java.text.DecimalFormat;
+
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import com.zivilon.cindercore.CinderCore;
+import com.zivilon.cindercore.interfaces.ICustomChunk;
+
+import com.zivilon.cindercore_modlist.CinderCoreModlist;
+import com.zivilon.cindercore.mixins.MixinS0CPacketSpawnPlayer;
+import com.zivilon.cindercore.mixins.MixinS0EPacketSpawnObject;
+import com.zivilon.cindercore.mixins.MixinS0FPacketSpawnMob;
+import com.zivilon.cindercore.mixins.MixinS1CPacketEntityMetadata;
+import com.zivilon.cindercore.mixins.MixinS22PacketMultiBlockChange;
+import com.zivilon.cindercore.mixins.MixinS23PacketBlockChange;
+import com.zivilon.cindercore.mixins.MixinS24PacketBlockAction;
+import com.zivilon.cindercore.mixins.MixinS30PacketWindowItems;
+import com.zivilon.cindercore.mixins.MixinPlayerManager;
+import com.zivilon.cindercore.mixins.MixinWorldServer;
+import com.zivilon.cindercore.util.ChunkDeepCopy;
+
+import net.minecraft.server.management.PlayerManager;
+
+public class PacketInterceptor extends ChannelDuplexHandler {
+ public static boolean debug = false;
+ public UUID uuid;
+
+ public PacketInterceptor(UUID player_uuid) {
+ this.uuid = player_uuid;
+ }
+
+ @Override
+ public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
+ if (msg instanceof S30PacketWindowItems) {
+ S30PacketWindowItems packet = (S30PacketWindowItems) msg;
+ handle_window_items(packet, uuid);
+ }
+ if (msg instanceof S2FPacketSetSlot) {
+ S2FPacketSetSlot packet = (S2FPacketSetSlot) msg;
+ handle_set_slot(packet, uuid);
+ }
+
+ if (msg instanceof S26PacketMapChunkBulk) {
+ S26PacketMapChunkBulk packet = (S26PacketMapChunkBulk) msg;
+ List chunks = handle_map_chunk_bulk(packet, uuid);
+ if (chunks != null) {
+ msg = new S26PacketMapChunkBulk(chunks);
+ }
+ }
+ if (msg instanceof S21PacketChunkData) {
+ S21PacketChunkData packet = (S21PacketChunkData) msg;
+ Chunk chunk = handle_chunk_data(packet, uuid);
+ if (chunk != null) {
+ msg = new S21PacketChunkData(chunk, packet.func_149274_i(), 0);
+ }
+ }
+ if (msg instanceof S04PacketEntityEquipment) {
+ S04PacketEntityEquipment packet = (S04PacketEntityEquipment) msg;
+ handle_entity_equipment(packet, uuid);
+ }
+ if (msg instanceof S0FPacketSpawnMob) {
+ S0FPacketSpawnMob packet = (S0FPacketSpawnMob) msg;
+ handle_spawn_mob(packet, uuid);
+ }
+ if (msg instanceof S0EPacketSpawnObject) {
+ S0EPacketSpawnObject packet = (S0EPacketSpawnObject) msg;
+ handle_spawn_object(packet, uuid);
+ }
+ if (msg instanceof S23PacketBlockChange) {
+ S23PacketBlockChange packet = (S23PacketBlockChange) msg;
+ msg = handle_block_change(packet, uuid);
+ }
+ if (msg instanceof S1CPacketEntityMetadata) {
+ S1CPacketEntityMetadata packet = (S1CPacketEntityMetadata) msg;
+ packet = handle_entity_metadata(packet, uuid);
+ msg = packet;
+ }
+ if (msg instanceof S0CPacketSpawnPlayer) {
+ S0CPacketSpawnPlayer packet = (S0CPacketSpawnPlayer) msg;
+ handle_spawn_player(packet, uuid);
+ }
+ if (msg instanceof S22PacketMultiBlockChange) {
+ S22PacketMultiBlockChange packet = (S22PacketMultiBlockChange) msg;
+ handle_multi_block_change(packet, uuid);
+ msg = packet;
+ }
+ if (msg instanceof S24PacketBlockAction) {
+ S24PacketBlockAction packet = (S24PacketBlockAction) msg;
+ handle_block_action(packet, uuid);
+ }
+ super.write(ctx, msg, promise);
+ }
+
+ public S1CPacketEntityMetadata handle_entity_metadata(S1CPacketEntityMetadata packet, UUID uuid) {
+ // Rebuild the packet because it is a shared reference and otherwise changes propagate to other clients too
+ Integer entity_id = ((MixinS1CPacketEntityMetadata)packet).get_entity_id();
+ if (entity_id == null) return packet;
+ Entity entity = getPlayerByUUID(uuid).worldObj.getEntityByID(entity_id);
+ if (entity == null) return packet;
+ DataWatcher data_watcher = entity.getDataWatcher();
+ if (data_watcher == null) return packet;
+
+ // Apply any changes to this new packet instead of old packet
+ S1CPacketEntityMetadata new_packet = new S1CPacketEntityMetadata(entity_id, data_watcher, true);
+
+ List originalMetadataReference = ((MixinS1CPacketEntityMetadata)new_packet).get_metadata();
+ // Create new List object to dereference it from possible shared packets. Objects within are still shared references but List itself is not.
+ List originalMetadata = new ArrayList<>();
+ for (DataWatcher.WatchableObject watchableObject : originalMetadataReference) {
+ originalMetadata.add(watchableObject);
+ }
+
+ for (int i = 0; i < originalMetadata.size(); i++) {
+ DataWatcher.WatchableObject watchableObject = originalMetadata.get(i);
+ Object obj = watchableObject.getObject();
+
+ process_custom_entity_metadata(entity, i, originalMetadata, uuid); // Contents of originalMetadata are likely shared references here
+
+ if (obj instanceof ItemStack) {
+ ItemStack originalItem = (ItemStack) obj;
+ ItemStack modifiedItem = new ItemStack(originalItem.getItem(), originalItem.stackSize, originalItem.getItemDamage());
+ process_custom_item_datavalue(modifiedItem, uuid);
+ if (originalItem != null && (CinderCore.getItemFallbackMap(uuid).containsKey(Item.getIdFromItem(originalItem.getItem()))) || originalItem.getItemDamage() != modifiedItem.getItemDamage()) {
+ Integer fallbackItemId = CinderCore.getItemFallbackMap(uuid).get(Item.getIdFromItem(originalItem.getItem()));
+ if (fallbackItemId != null) modifiedItem.func_150996_a(Item.getItemById(fallbackItemId));
+ // Copy the NBT data from the original item, if present
+ if (originalItem.hasTagCompound()) {
+ NBTTagCompound originalTagCompound = originalItem.getTagCompound();
+ NBTTagCompound modifiedTagCompound = (NBTTagCompound) originalTagCompound.copy();
+
+ // Recursively process the NBT to handle nested items
+ process_item_nbt(modifiedTagCompound, uuid);
+
+ modifiedItem.setTagCompound(modifiedTagCompound);
+ }
+
+ // Construct a new WatchableObject with the modified item
+ DataWatcher.WatchableObject modifiedWatchableObject = new DataWatcher.WatchableObject(watchableObject.getObjectType(), watchableObject.getDataValueId(), modifiedItem);
+
+ // Replace the object at the same position
+ originalMetadata.set(i, modifiedWatchableObject);
+ }
+ }
+ }
+ ((MixinS1CPacketEntityMetadata)new_packet).set_metadata(originalMetadata);
+ return new_packet;
+ }
+
+ public void handle_block_action(S24PacketBlockAction packet, UUID uuid) {
+ EntityPlayerMP player = getPlayerByUUID(uuid);
+ Block block = ((MixinS24PacketBlockAction)packet).get_block();
+ Block processed_block = process_block(block, uuid);
+ ((MixinS24PacketBlockAction)packet).set_block(processed_block);
+ }
+
+ public S23PacketBlockChange handle_block_change(S23PacketBlockChange packet, UUID uuid) {
+ EntityPlayerMP player = getPlayerByUUID(uuid);
+ if (player != null) {
+ World world = player.worldObj;
+ int x = ((MixinS23PacketBlockChange)packet).get_x();
+ int y = ((MixinS23PacketBlockChange)packet).get_y();
+ int z = ((MixinS23PacketBlockChange)packet).get_z();
+ Block block = process_block(((MixinS23PacketBlockChange)packet).get_block(), uuid);
+
+ S23PacketBlockChange new_packet = new S23PacketBlockChange(x, y, z, world);
+ ((MixinS23PacketBlockChange)new_packet).set_block(block);
+ return new_packet;
+ }
+ return packet;
+ }
+
+ public void handle_multi_block_change(S22PacketMultiBlockChange packet, UUID uuid) {
+ byte[] blockDataArray = ((MixinS22PacketMultiBlockChange)packet).get_block_data_array();
+
+ DataInputStream dataInputStream = new DataInputStream(new ByteArrayInputStream(blockDataArray));
+
+ ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+ DataOutputStream dataOutputStream = new DataOutputStream(byteArrayOutputStream);
+
+ try {
+ while (dataInputStream.available() > 0) {
+ short positionShort = dataInputStream.readShort();
+ short blockStateShort = dataInputStream.readShort();
+
+ int blockId = (blockStateShort >> 4) & 4095; // Extract block ID
+ int metadata = blockStateShort & 15; // Extract metadata
+
+ // Apply fallback logic to block ID
+ if (CinderCore.getItemFallbackMap(uuid).containsKey(blockId)) {
+ blockId = CinderCore.getItemFallbackMap(uuid).get(blockId);
+ }
+
+ dataOutputStream.writeShort(positionShort);
+
+ short newBlockStateShort = (short)((blockId << 4) | metadata);
+ dataOutputStream.writeShort(newBlockStateShort);
+ }
+
+ byte[] modifiedBlockDataArray = byteArrayOutputStream.toByteArray();
+ ((MixinS22PacketMultiBlockChange)packet).set_block_data_array(modifiedBlockDataArray);
+ } catch (IOException e) {
+ }
+ }
+
+ public void handle_spawn_player(S0CPacketSpawnPlayer packet, UUID uuid) {
+ int item_id = ((MixinS0CPacketSpawnPlayer)packet).get_item_ID();
+ if (CinderCore.getItemFallbackMap(uuid).containsKey(item_id)) {
+ ((MixinS0CPacketSpawnPlayer)packet).set_item_ID(CinderCore.getItemFallbackMap(uuid).get(item_id));
+ }
+ }
+
+ public Block process_block(Block block, UUID uuid) {
+ Map fallbacks = CinderCore.getItemFallbackMap(uuid);
+ int originalBlockId = Block.getIdFromBlock(block);
+ if (fallbacks.containsKey(originalBlockId)) {
+ int fallbackBlockId = fallbacks.get(originalBlockId);
+ Block fallbackBlock = Block.getBlockById(fallbackBlockId);
+ return fallbackBlock;
+ }
+ return block;
+ }
+
+ public int process_entity(int entity_ID, UUID uuid) {
+ Map fallbacks = CinderCore.getEntityFallbackMap(uuid);
+ if (fallbacks.containsKey(entity_ID)) {
+ entity_ID = fallbacks.get(entity_ID);
+ }
+ return entity_ID;
+ }
+
+
+ public void handle_spawn_mob(S0FPacketSpawnMob packet, UUID uuid) {
+ int entity_ID = ((MixinS0FPacketSpawnMob)packet).get_id();
+ ((MixinS0FPacketSpawnMob)packet).set_id(process_entity(entity_ID, uuid));
+ }
+ public void handle_spawn_object(S0EPacketSpawnObject packet, UUID uuid) {
+ int entity_type = ((MixinS0EPacketSpawnObject)packet).get_id();
+ ((MixinS0EPacketSpawnObject)packet).set_id(process_entity(entity_type, uuid));
+ if (entity_type == 70) { // Test if entity is EntityFallingBlock
+ int item_id = ((MixinS0EPacketSpawnObject)packet).get_item_id();
+ if (CinderCore.getItemFallbackMap(uuid).containsKey(item_id)) {
+ int fallback_id = CinderCore.getItemFallbackMap(uuid).get(item_id);
+ ((MixinS0EPacketSpawnObject)packet).set_item_id(fallback_id);
+ }
+ }
+ }
+
+ public List handle_map_chunk_bulk(S26PacketMapChunkBulk packet, UUID uuid) {
+ List modified_chunks = null;
+ List chunks = new ArrayList<>();
+ boolean isChunkModified = false;
+ Integer chunk_count = packet.func_149254_d();
+ EntityPlayerMP player = getPlayerByUUID(uuid);
+ World world;
+ if (player != null) {
+ world = player.worldObj;
+ } else {
+ world = (World)getPlayerWorldByUUID(uuid);
+ if (world == null) {
+ world = MinecraftServer.getServer().worldServers[0]; // Default to overworld because bad data is probably better than crash
+ System.out.println("Defaulting to Overworld to save from crash");
+ }
+ }
+
+ for (int i = 0; i < chunk_count; i++) { // Get number of chunks and run once for each of them
+ Integer x = packet.func_149255_a(i); // Get chunk X coordinate
+ Integer z = packet.func_149253_b(i); // Get chunk Z coordinate
+
+ // Original in-world chunk. DO NOT MODIFY
+ Chunk originalChunk = world.getChunkFromChunkCoords(x, z);
+ Chunk chunk = ChunkDeepCopy.deepCopyChunk(originalChunk);
+
+ chunks.add(chunk);
+ }
+ for (int i = 0; i < packet.func_149254_d(); i++) {
+ if (process_chunk(chunks.get(i), uuid)) {
+ isChunkModified = true;
+ }
+ }
+ if (isChunkModified == true) {
+ modified_chunks = chunks;
+ }
+ return modified_chunks;
+ }
+
+ public Chunk handle_chunk_data(S21PacketChunkData packet, UUID uuid) {
+ Chunk modified_chunk = null; // Create null return value that can be replaced with chunk if modified
+ int x = packet.func_149273_e(); // Get chunk X coordinate
+ int z = packet.func_149271_f(); // Get chunk Z coordinate
+ EntityPlayerMP player = getPlayerByUUID(uuid);
+ World world;
+ if (player != null) {
+ world = player.worldObj;
+ } else {
+ world = (World)getPlayerWorldByUUID(uuid);
+ if (world == null) {
+ world = MinecraftServer.getServer().worldServers[0]; // Default to overworld because bad data is probably better than crash
+ System.out.println("Defaulting to Overworld to save from crash");
+ }
+ }
+ Chunk originalChunk = world.getChunkFromChunkCoords(x, z);
+
+ Chunk chunk = ChunkDeepCopy.deepCopyChunk(originalChunk);
+
+ if (process_chunk(chunk, uuid)) {
+ modified_chunk = chunk;
+ }
+ return modified_chunk;
+ }
+
+
+
+ public void handle_window_items(S30PacketWindowItems packet, UUID uuid) {
+ try {
+ ItemStack[] items = packet.func_148910_d();
+ if (items != null) {
+ boolean modified = false;
+ for (int i = 0; i < items.length; i++) {
+ if (items[i] != null) {
+ process_itemstack(items[i], uuid);
+ }
+ }
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+
+ public void handle_set_slot(S2FPacketSetSlot packet, UUID uuid) {
+ try {
+ ItemStack item = packet.func_149174_e();
+
+ if (item != null) {
+ process_itemstack(item, uuid);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ public void handle_entity_equipment(S04PacketEntityEquipment packet, UUID uuid) {
+ ItemStack item = packet.func_149390_c();
+ if (item != null) {
+ process_itemstack(item, uuid);
+ }
+ }
+
+ public void process_itemstack(ItemStack item, UUID uuid) {
+ Integer item_id = Item.getIdFromItem(item.getItem());
+ if (item_id == null) {
+ System.out.println("Item ID is null!");
+ return;
+ }
+ if (CinderCore.getItemFallbackMap(uuid).containsKey(item_id)) {
+ Item fallback_item = Item.getItemById(CinderCore.getItemFallbackMap(uuid).get(item_id));
+ item.func_150996_a(fallback_item);
+ }
+ process_custom_item_datavalue(item, uuid);
+ if (item.hasTagCompound()) {
+ process_item_nbt(item.getTagCompound(), uuid);
+ }
+ }
+
+ public void process_custom_item_datavalue(ItemStack item, UUID uuid) {
+ // Inject to HEAD with mixins if your mod needs custom handling
+ }
+ public int process_custom_item_datavalue_int(int datavalue, String item_name, UUID uuid) {
+ // Inject to HEAD with mixins if your mod needs custom handling
+ return datavalue;
+ }
+ public static void process_custom_entity(Entity entity, UUID uuid) {
+ // Inject to HEAD with mixins if your mod needs custom handling
+ }
+ public void process_custom_entity_metadata(Entity entity, int i, List originalMetadata, UUID uuid) {
+ // Inject to HEAD with mixins if your mod needs custom handling
+ }
+
+ public void process_item_nbt(NBTBase nbt, UUID uuid) {
+ if (nbt instanceof NBTTagCompound) {
+ NBTTagCompound compound = (NBTTagCompound) nbt;
+ // Check if this compound is an item by looking for 'id' and 'Count'
+ if (compound.hasKey("id", 99) && compound.hasKey("Count", 99)) {
+ int item_id = compound.getInteger("id");
+ if (CinderCore.getItemFallbackMap(uuid).containsKey(item_id)) {
+ int fallback_item_id = CinderCore.getItemFallbackMap(uuid).get(item_id);
+ compound.setInteger("id", fallback_item_id);
+ }
+ if (compound.hasKey("Damage")) {
+ int datavalue = compound.getInteger("Damage");
+ String item_type = Item.getItemById(item_id).getUnlocalizedName();
+ compound.setInteger("Damage", process_custom_item_datavalue_int(datavalue, item_type, uuid));
+ }
+ }
+
+ Set keySet = (Set) compound.func_150296_c();
+ for (String key : keySet) {
+ NBTBase inner_nbt = compound.getTag(key);
+ process_item_nbt(inner_nbt, uuid);
+ }
+
+ } else if (nbt instanceof NBTTagList) {
+ NBTTagList list = (NBTTagList) nbt;
+ for (int i = 0; i < list.tagCount(); i++) {
+ NBTBase inner_nbt = list.getCompoundTagAt(i);
+ process_item_nbt(inner_nbt, uuid);
+ }
+ }
+ }
+
+ public boolean process_chunk(Chunk chunk, UUID uuid) {
+ boolean isModified = false;
+ for (int x = 0; x < 16; x++) {
+ for (int z = 0; z < 16; z++) {
+ for (int y = 0; y < 256; y++) {
+ Block block = chunk.getBlock(x, y, z);
+ int blockId = Block.getIdFromBlock(block);
+
+ if (CinderCore.getItemFallbackMap(uuid).containsKey(blockId)) {
+ isModified = true;
+ int fallbackId = CinderCore.getItemFallbackMap(uuid).get(blockId);
+ Block fallbackBlock = Block.getBlockById(fallbackId);
+ int metadata = chunk.getBlockMetadata(x, y, z);
+
+ chunk.func_150807_a(x, y, z, fallbackBlock, metadata);
+ }
+ }
+ }
+ }
+ return isModified;
+ }
+
+
+
+ public static EntityPlayerMP getPlayerByUUID(UUID playerUUID) {
+ MinecraftServer server = MinecraftServer.getServer();
+ if (server == null) {
+ return null;
+ }
+
+ for (Object obj : server.getConfigurationManager().playerEntityList) {
+ if (obj instanceof EntityPlayerMP) {
+ EntityPlayerMP player = (EntityPlayerMP) obj;
+ if (player.getUniqueID().equals(playerUUID)) {
+ return player;
+ }
+ } else {
+ System.err.println("[CinderCore] Player list having non-players, WHAT?!?!?!");
+ }
+ }
+ return null; // Player not found or not online
+ }
+
+ public static World getPlayerWorldByUUID(UUID uuid) {
+ WorldServer[] worlds = MinecraftServer.getServer().worldServers;
+ for (WorldServer world : worlds) {
+ PlayerManager pm = ((MixinWorldServer)world).getPlayerManager();
+ List players = ((MixinPlayerManager)pm).getPlayers();
+ for (Object obj : players) {
+ EntityPlayerMP player = (EntityPlayerMP)obj;
+ if (uuid.equals(player.getUniqueID())) {
+ return world;
+ }
+ }
+ }
+ return null;
+ }
+}
diff --git a/src/main/java/com/zivilon/cindercore/util/ChunkDeepCopy.java b/src/main/java/com/zivilon/cindercore/util/ChunkDeepCopy.java
new file mode 100644
index 0000000..698d37d
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/util/ChunkDeepCopy.java
@@ -0,0 +1,91 @@
+package com.zivilon.cindercore.util;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Field;
+
+import java.util.Vector;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
+import net.minecraft.world.chunk.NibbleArray;
+import net.minecraft.world.chunk.Chunk;
+
+import java.util.Arrays;
+
+import com.zivilon.cindercore.mixins.MixinExtendedBlockStorage;
+import com.zivilon.cindercore.mixins.MixinNibbleArray;
+
+public class ChunkDeepCopy {
+ public static Chunk deepCopyChunk(Chunk original) {
+ Chunk copy = new Chunk(original.worldObj, original.xPosition, original.zPosition);
+ copy.isLit = original.isLit;
+ copy.setBiomeArray(original.getBiomeArray());
+ copy.precipitationHeightMap = original.precipitationHeightMap;
+ copy.updateSkylightColumns = original.updateSkylightColumns;
+ copy.isChunkLoaded = original.isChunkLoaded;
+ copy.heightMap = original.heightMap;
+ copy.chunkTileEntityMap = original.chunkTileEntityMap;
+ copy.entityLists = original.entityLists;
+ copy.isTerrainPopulated = original.isTerrainPopulated;
+ copy.isLightPopulated = original.isLightPopulated;
+ copy.field_150815_m = original.field_150815_m;
+ copy.isModified = original.isModified;
+ copy.hasEntities = original.hasEntities;
+ copy.lastSaveTime = original.lastSaveTime;
+ copy.sendUpdates = original.sendUpdates;
+ copy.heightMapMinimum = original.heightMapMinimum;
+ copy.inhabitedTime = original.inhabitedTime;
+
+ // Deep copy ExtendedBlockStorages
+ ExtendedBlockStorage[] original_arrays = original.getBlockStorageArray();
+ ExtendedBlockStorage[] copy_arrays = copy.getBlockStorageArray();
+
+ for (int i = 0; i < original_arrays.length; i++) {
+ if (original_arrays[i] != null) {
+ copy_arrays[i] = deepCopyExtendedBlockStorage(original_arrays[i]);
+ }
+ }
+
+ return copy;
+ }
+
+ public static ExtendedBlockStorage deepCopyExtendedBlockStorage(ExtendedBlockStorage original) {
+ ExtendedBlockStorage copy = new ExtendedBlockStorage(original.getYLocation(), false);
+
+ // Copies of primitives
+ ((MixinExtendedBlockStorage)copy).setBlockRefCount(((MixinExtendedBlockStorage)original).getBlockRefCount());
+ ((MixinExtendedBlockStorage)copy).setTickRefCount(((MixinExtendedBlockStorage)original).getTickRefCount());
+ copy.setBlockLSBArray(Arrays.copyOf(original.getBlockLSBArray(), original.getBlockLSBArray().length));
+
+ // NibbleArrays. Needs deep copy for each!
+ if (original.getBlockMSBArray() != null) {
+ copy.setBlockMSBArray(deepCopyNibbleArray(original.getBlockMSBArray()));
+ }
+ if (original.getBlocklightArray() != null) {
+ copy.setBlocklightArray(deepCopyNibbleArray(original.getBlocklightArray()));
+ }
+ if (original.getSkylightArray() != null) {
+ copy.setSkylightArray(deepCopyNibbleArray(original.getSkylightArray()));
+ }
+ if (original.getMetadataArray() != null) {
+ copy.setBlockMetadataArray(deepCopyNibbleArray(original.getMetadataArray()));
+ }
+ return copy;
+ }
+
+ public static NibbleArray deepCopyNibbleArray(NibbleArray original) {
+ int depthBits = ((MixinNibbleArray)original).getDepthBits();
+ byte[] data;
+
+ if (original.data == null) {
+ data = new byte[(1 << depthBits) * 2];
+ return new NibbleArray(data, depthBits);
+ } else {
+ data = Arrays.copyOf(original.data, original.data.length);
+ }
+ return new NibbleArray(data, depthBits);
+ }
+}
diff --git a/src/main/java/com/zivilon/cindercore/util/MethodChecker.java b/src/main/java/com/zivilon/cindercore/util/MethodChecker.java
new file mode 100644
index 0000000..aa4485c
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/util/MethodChecker.java
@@ -0,0 +1,74 @@
+package com.zivilon.cindercore.util;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Field;
+
+import java.util.Vector;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public class MethodChecker {
+
+ public static boolean isMethodValid() {
+ try {
+ Class chunkClass = Class.forName("net.minecraft.world.chunk.Chunk");
+
+ Class[] parameterTypes = new Class[] { byte[].class, int.class, int.class, boolean.class };
+
+ Method fillChunkMethod = chunkClass.getDeclaredMethod("fillChunk", parameterTypes);
+
+ if (fillChunkMethod != null) {
+ return true;
+ }
+ } catch (ClassNotFoundException | NoSuchMethodException | SecurityException e) {
+ System.err.println("Failed to validate method: " + e.getMessage());
+ }
+ return false;
+ }
+
+ public static void main() {
+ boolean isValid = isMethodValid();
+ }
+
+ public static void dumpClass(String className, String outputFilePath, Class contextClass) {
+ String resourcePath = className.replace('.', '/') + ".class";
+ try (InputStream classStream = contextClass.getClassLoader().getResourceAsStream(resourcePath)) {
+ if (classStream == null) {
+ System.err.println("Class " + className + " could not be found.");
+ return;
+ }
+ try (OutputStream outputStream = new FileOutputStream(outputFilePath)) {
+ byte[] buffer = new byte[4096];
+ int bytesRead;
+ while ((bytesRead = classStream.read(buffer)) != -1) {
+ outputStream.write(buffer, 0, bytesRead);
+ }
+ System.out.println("Dumped " + className + " to " + outputFilePath);
+ } catch (IOException e) {
+ System.err.println("Failed to write class file: " + e.getMessage());
+ }
+ } catch (IOException e) {
+ System.err.println("Failed to read class file: " + e.getMessage());
+ }
+ }
+
+ public static void printLoadedClasses() {
+ try {
+ ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
+
+ Field classesField = ClassLoader.class.getDeclaredField("classes");
+ classesField.setAccessible(true);
+
+ @SuppressWarnings("unchecked")
+ Vector> classes = (Vector>) classesField.get(systemClassLoader);
+
+ for (Class clazz : classes) {
+ System.out.println(clazz.getName());
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+}
diff --git a/src/main/java/com/zivilon/cindercore/util/NetworkUtil.java b/src/main/java/com/zivilon/cindercore/util/NetworkUtil.java
new file mode 100644
index 0000000..3c56779
--- /dev/null
+++ b/src/main/java/com/zivilon/cindercore/util/NetworkUtil.java
@@ -0,0 +1,139 @@
+package com.zivilon.cindercore.util;
+
+import cpw.mods.fml.common.network.NetworkRegistry;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.Overwrite;
+import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import cpw.mods.fml.common.FMLLog;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.common.network.internal.FMLNetworkHandler;
+import cpw.mods.fml.common.network.FMLEmbeddedChannel;
+import cpw.mods.fml.common.registry.GameData;
+import cpw.mods.fml.common.registry.GameData.GameDataSnapshot;
+import cpw.mods.fml.common.registry.EntityRegistry;
+import cpw.mods.fml.common.registry.EntityRegistry.EntityRegistration;
+import cpw.mods.fml.common.network.internal.FMLMessage;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityList;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.network.Packet;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.WorldServer;
+
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.Map;
+import java.util.UUID;
+import java.util.EnumMap;
+
+import org.apache.logging.log4j.Logger;
+
+import com.google.common.collect.BiMap;
+
+import com.zivilon.cindercore.interfaces.IFMLNetworkHandlerMixin;
+import com.zivilon.cindercore.CinderCore;
+import com.zivilon.cindercore.network.PacketInterceptor;
+import com.zivilon.cindercore.mixins.MixinEntityRegistry;
+import com.zivilon.cindercore.mixins.EntityRegistryAccessor;
+import com.zivilon.cindercore.mixins.FMLNetworkHandlerAccessor;
+
+public class NetworkUtil {
+
+ private static EnumMap channelPair;
+
+ private static EnumMap getChannelPair() {
+ if (channelPair == null) {
+ channelPair = FMLNetworkHandlerAccessor.getChannelPair();
+ }
+ return channelPair;
+ }
+
+ public static Packet getEntitySpawningPacket(Entity entity, EntityPlayerMP player) {
+ Entity new_entity = null;
+ UUID uuid = player.getUniqueID();
+ boolean modified = false;
+ Map> custom_fallback_map = CinderCore.getCustomFallbackMap(uuid);
+ if (custom_fallback_map != null && !(custom_fallback_map.isEmpty())) {
+ modified = true;
+ new_entity = deepCopy(entity);
+ PacketInterceptor.process_custom_entity(new_entity, uuid);
+ }
+
+ EntityRegistration er = EntityRegistry.instance().lookupModSpawn(entity.getClass(), false);
+
+ if (er == null || er.usesVanillaSpawning()) {
+ return null;
+ }
+ Map fallback_map = CinderCore.getEntityFallbackMap(uuid);
+ Integer entity_ID = er.getModEntityId();
+
+ if (fallback_map != null && fallback_map.containsKey(entity_ID)) {
+ modified = true;
+ int fallback_ID = fallback_map.get(entity_ID);
+ er = get_entity_registration_by_entity_id(fallback_ID) ;
+ }
+
+ if (!modified) {
+ FMLMessage.EntitySpawnMessage msg = new FMLMessage.EntitySpawnMessage(er, entity, er.getContainer());
+ return getChannelPair().get(Side.SERVER).generatePacketFrom(msg);
+ }
+
+ if (new_entity == null) {
+ new_entity = deepCopy(entity);
+ }
+ FMLMessage.EntitySpawnMessage msg = new FMLMessage.EntitySpawnMessage(er, new_entity, er.getContainer());
+ return getChannelPair().get(Side.SERVER).generatePacketFrom(msg);
+ }
+
+ public static EntityRegistration get_entity_registration_by_entity_id(int entityId) {
+ EntityRegistryAccessor accessor = (EntityRegistryAccessor) EntityRegistry.instance();
+ BiMap, EntityRegistration> entityClassRegistrations = accessor.getEntityClassRegistrations();
+
+ for (EntityRegistration registration : entityClassRegistrations.values()) {
+ if (registration.getModEntityId() == entityId) {
+ return registration;
+ }
+ }
+ return null;
+ }
+
+ public static Entity deepCopy(Entity entity) {
+ MinecraftServer minecraftserver = MinecraftServer.getServer();
+ WorldServer worldserver = minecraftserver.worldServerForDimension(entity.dimension);
+ if (worldserver == null) return entity;
+ Entity new_entity = EntityList.createEntityByName(EntityList.getEntityString(entity), worldserver);
+ if (new_entity == null) return entity;
+
+ new_entity.copyDataFrom(entity, true);
+ int old_entity_id = entity.getEntityId();
+ int new_entity_id = new_entity.getEntityId();
+ new_entity.setEntityId(old_entity_id);
+ return new_entity;
+ }
+
+ public static void writeLog(String message) {
+ try (BufferedWriter writer = new BufferedWriter(new FileWriter("custom_log.txt", true))) {
+ LocalDateTime now = LocalDateTime.now();
+ String timestamp = now.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
+ writer.write(timestamp + " - " + message + "\n");
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+}
diff --git a/src/main/resources/LICENSE b/src/main/resources/LICENSE
new file mode 100644
index 0000000..0856f77
--- /dev/null
+++ b/src/main/resources/LICENSE
@@ -0,0 +1 @@
+Code of CinderCore is marked with CC0 1.0 Universal. To view a copy of this license, visit http://creativecommons.org/publicdomain/zero/1.0
\ No newline at end of file
diff --git a/src/main/resources/META-INF/cindercore_at.cfg b/src/main/resources/META-INF/cindercore_at.cfg
new file mode 100644
index 0000000..f64f0a0
--- /dev/null
+++ b/src/main/resources/META-INF/cindercore_at.cfg
@@ -0,0 +1 @@
+public cpw.mods.fml.common.network.handshake.NetworkDispatcher player
diff --git a/src/main/resources/cindercore_at.cfg b/src/main/resources/cindercore_at.cfg
new file mode 100644
index 0000000..71047ba
--- /dev/null
+++ b/src/main/resources/cindercore_at.cfg
@@ -0,0 +1,2 @@
+public cpw.mods.fml.common.network.handshake.FMLHandshakeServerState
+public cpw.mods.fml.common.network.handshake.NetworkDispatcher player
diff --git a/src/main/resources/mcmod.info b/src/main/resources/mcmod.info
new file mode 100644
index 0000000..8451cc6
--- /dev/null
+++ b/src/main/resources/mcmod.info
@@ -0,0 +1,16 @@
+[
+{
+ "modid": "cindercore",
+ "name": "Cinder Core",
+ "description": "Mod that powers the Cinder Project. Responsible for providing fallbacks and mod lists.",
+ "version": "1.0",
+ "mcversion": "1.7.10",
+ "url": "",
+ "updateUrl": "",
+ "authorList": ["Shinare"],
+ "credits": "",
+ "logoFile": "",
+ "screenshots": [],
+ "dependencies": []
+}
+]
diff --git a/src/main/resources/mixins.cindercore.json b/src/main/resources/mixins.cindercore.json
new file mode 100644
index 0000000..86be6d9
--- /dev/null
+++ b/src/main/resources/mixins.cindercore.json
@@ -0,0 +1,33 @@
+{
+ "required": true,
+ "minVersion": "0.7.11",
+ "package": "com.zivilon.cindercore.mixins",
+ "refmap": "mixins.cindercore.refmap.json",
+ "target": "@env(DEFAULT)",
+ "compatibilityLevel": "JAVA_8",
+ "mixins": [
+ "MixinS30PacketWindowItems",
+ "MixinS2FPacketSetSlot",
+ "MixinS26PacketMapChunkBulk",
+ "MixinS21PacketChunkData",
+ "MixinS04PacketEntityEquipment",
+ "MixinS0FPacketSpawnMob",
+ "MixinS0EPacketSpawnObject",
+ "MixinS22PacketMultiBlockChange",
+ "MixinS23PacketBlockChange",
+ "MixinS24PacketBlockAction",
+ "MixinS1CPacketEntityMetadata",
+ "MixinS0CPacketSpawnPlayer",
+ "EntityRegistryAccessor",
+ "FMLNetworkHandlerAccessor",
+ "MixinEntityTrackerEntry",
+ "MixinExtendedBlockStorage",
+ "MixinNibbleArray",
+ "MixinChunk",
+ "MixinEntityList",
+ "MixinPlayerManager",
+ "MixinWorldServer",
+ "LOTRPatches"
+ ],
+ "client": []
+}