diff --git a/minecraft/.gitignore b/minecraft/.gitignore
index a4c6e69be..896c508ad 100644
--- a/minecraft/.gitignore
+++ b/minecraft/.gitignore
@@ -3,5 +3,6 @@
!/build.gradle
!/.gitignore
+!/1.11
!/1.8
!/1.7
diff --git a/minecraft/1.11/.gitignore b/minecraft/1.11/.gitignore
new file mode 100644
index 000000000..85be317cb
--- /dev/null
+++ b/minecraft/1.11/.gitignore
@@ -0,0 +1,17 @@
+# Ignore All
+/*
+
+# Sources
+!/src
+
+# github
+!/.gitignore
+!/README.md
+
+# gradle
+!/build.gradle
+!/build.properties
+!/settings.gradle
+!/gradle.properties
+!/gradlew*
+!/gradle
diff --git a/minecraft/1.11/build.gradle b/minecraft/1.11/build.gradle
new file mode 100644
index 000000000..e4c6fdf32
--- /dev/null
+++ b/minecraft/1.11/build.gradle
@@ -0,0 +1,135 @@
+apply from: "https://raw.githubusercontent.com/NOVA-Team/NOVA-Gradle/master/shared-scripts/java.gradle"
+
+apply plugin: "com.jfrog.artifactory"
+apply plugin: "com.github.johnrengelman.shadow"
+apply plugin: "maven-publish"
+
+idea.module.name = "Core-MC-1.11"
+archivesBaseName = "NOVA-Core-Wrapper-MC1.11"
+
+configurations {
+ fatJar
+ compile.extendsFrom fatJar
+}
+
+dependencies {
+ fatJar project(":")
+ testCompile project(path: ':', configuration: 'wrapperTests')
+
+ testCompile "junit:junit:4.12"
+ testCompile 'org.assertj:assertj-core:3.0.0'
+ testRuntime 'org.slf4j:slf4j-simple:1.7.10'
+}
+
+jar {
+ manifest {
+ attributes 'FMLCorePlugin': 'nova.core.wrapper.mc.forge.v1_11.NovaMinecraftCore'
+ attributes 'FMLCorePluginContainsFMLMod': 'true'
+ attributes 'FMLAT': 'nova_at.cfg'
+ }
+}
+
+task deobfJar(type: Jar) {
+ from sourceSets.main.output
+ classifier = 'deobf'
+ manifest {
+ attributes 'FMLCorePlugin': 'nova.core.wrapper.mc.forge.v1_11.NovaMinecraftCore'
+ attributes 'FMLCorePluginContainsFMLMod': 'true'
+ attributes 'FMLAT': 'nova_at.cfg'
+ }
+}
+
+/**
+ * Create fat jar file with all dependencies included.
+ */
+task fatJar(type: Jar) {
+ configurations.fatJar.each {dep ->
+ from(project.zipTree(dep)) {
+ exclude 'META-INF', 'META-INF/**'
+ }
+ }
+ with jar
+
+ manifest {
+ attributes 'FMLCorePlugin': 'nova.core.wrapper.mc.forge.v1_11.NovaMinecraftCore'
+ attributes 'FMLCorePluginContainsFMLMod': 'true'
+ attributes 'FMLAT': 'nova_at.cfg'
+ }
+ classifier = 'fat'
+}
+
+artifacts {
+ archives deobfJar
+ archives fatJar
+}
+
+publishing {
+ publications {
+ main(MavenPublication) {
+ from components.java
+
+ artifactId archivesBaseName
+
+ artifact sourcesJar
+ artifact javadocJar
+ artifact deobfJar
+ artifact fatJar
+
+ pom.withXml(writePom(project.properties))
+ pom.withXml {xml ->
+ def children = xml.asNode().get("dependencies")[0]
+ for (child in children) {
+ def artifactId = child.get("artifactId")[0].value()[0]
+ if (artifactId.equals("forgeSrc") || artifactId.equals("forgeBin")) {
+ children.remove(child)
+ break;
+ }
+ }
+ }
+ }
+ }
+}
+
+artifactory {
+ publish {
+ defaults {
+ publications("main")
+ publishPom = true
+ }
+ }
+}
+
+apply plugin: 'net.minecraftforge.gradle.forge'
+
+minecraft {
+ version = property("minecraft.version") + "-" + property("forge.version")
+ mappings = 'snapshot_20161220'
+ runDir = "run"
+}
+
+reobf {
+ // TODO Figure out how to make this work with maven-publish (creates a new task 'reobfFatJar' that isn't compatible with maven-publish)
+ fatJar {classpath += configurations.compile}
+}
+
+runClient {
+ jvmArgs '-Dfml.coreMods.load=nova.core.wrapper.mc.forge.v1_11.NovaMinecraftCore'
+}
+
+runServer {
+ jvmArgs '-Dfml.coreMods.load=nova.core.wrapper.mc.forge.v1_11.NovaMinecraftCore'
+}
+
+processResources {
+ inputs.property "version", project.version
+ inputs.property "mcversion", project.minecraft.version
+
+ from(sourceSets.main.resources.srcDirs) {
+ include 'mcmod.info'
+ expand 'version': project.version, 'mcversion': project.minecraft.version
+ }
+
+ from(sourceSets.main.resources.srcDirs) {
+ exclude 'mcmod.info'
+ }
+}
diff --git a/minecraft/1.11/gradle.properties b/minecraft/1.11/gradle.properties
new file mode 100644
index 000000000..3d511bebd
--- /dev/null
+++ b/minecraft/1.11/gradle.properties
@@ -0,0 +1,10 @@
+group = nova.core
+
+minecraft.version = 1.11
+forge.version = 13.19.1.2189
+forgeGradleVersion = 2.2-SNAPSHOT
+
+packaging = jar
+info.inceptionYear = 2016
+info.description = The wrapper of the Nova API to the MinecraftForge 1.11 modding system.
+info.organization.name = NOVA
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/NovaMinecraftCore.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/NovaMinecraftCore.java
new file mode 100644
index 000000000..ac9c77799
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/NovaMinecraftCore.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11;
+
+import net.minecraftforge.fml.relauncher.IFMLLoadingPlugin;
+import net.minecraftforge.fml.relauncher.IFMLLoadingPlugin.MCVersion;
+import nova.core.wrapper.mc.forge.v1_11.asm.transformers.Transformers;
+
+import java.util.Map;
+
+@MCVersion(value = "1.11")
+public class NovaMinecraftCore implements IFMLLoadingPlugin {
+ @Override
+ public String[] getASMTransformerClass() {
+ return new String[] { Transformers.class.getName() };
+ }
+
+ @Override
+ public String getModContainerClass() {
+ return "nova.core.wrapper.mc.forge.v1_11.NovaMinecraftPreloader";
+ }
+
+ @Override
+ public String getSetupClass() {
+ return null;
+ }
+
+ @Override
+ public void injectData(Map data) {
+
+ }
+
+ @Override
+ public String getAccessTransformerClass() {
+ return null;
+ }
+}
\ No newline at end of file
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/NovaMinecraftPreloader.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/NovaMinecraftPreloader.java
new file mode 100644
index 000000000..a3aee5cf0
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/NovaMinecraftPreloader.java
@@ -0,0 +1,328 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11;
+
+import com.google.common.eventbus.EventBus;
+import com.google.common.eventbus.Subscribe;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonPrimitive;
+import net.minecraft.client.resources.AbstractResourcePack;
+import net.minecraft.client.resources.FileResourcePack;
+import net.minecraft.client.resources.IResourcePack;
+import net.minecraft.launchwrapper.LaunchClassLoader;
+import net.minecraftforge.fml.client.FMLClientHandler;
+import net.minecraftforge.fml.common.DummyModContainer;
+import net.minecraftforge.fml.common.FMLCommonHandler;
+import net.minecraftforge.fml.common.LoadController;
+import net.minecraftforge.fml.common.Loader;
+import net.minecraftforge.fml.common.ModContainer;
+import net.minecraftforge.fml.common.ModMetadata;
+import net.minecraftforge.fml.common.discovery.ASMDataTable;
+import net.minecraftforge.fml.common.event.FMLConstructionEvent;
+import net.minecraftforge.fml.relauncher.FMLLaunchHandler;
+import net.minecraftforge.fml.relauncher.Side;
+import nova.core.loader.Mod;
+import nova.core.util.ClassLoaderUtil;
+import nova.core.wrapper.mc.forge.v1_11.render.NovaFolderResourcePack;
+import nova.core.wrapper.mc.forge.v1_11.render.NovaResourcePack;
+import nova.core.wrapper.mc.forge.v1_11.util.ReflectionUtil;
+
+import java.io.File;
+import java.lang.reflect.Field;
+import java.net.MalformedURLException;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+public class NovaMinecraftPreloader extends DummyModContainer {
+ public static final String version = "0.0.1";
+ private static final ModMetadata md;
+ public static Set> modClasses;
+ public static Map, File> modClassToFile;
+
+ static {
+ md = new ModMetadata();
+ md.modId = "novapreloader";
+ md.name = "NOVA Preloader";
+ md.version = version;
+ }
+
+ public NovaMinecraftPreloader() {
+ super(md);
+ }
+
+ /**
+ * Dynamically generates a sound JSON file based on a resource pack's file structure.
+ *
+ * If it's a folder, then load it as a sound collection.
+ * A sound collection falls under the same resource name. When called to play, it will pick a random sound from the collection to play it.
+ *
+ * If it's just a sound file, then load the sound file
+ */
+ public static String generateSoundJSON(AbstractResourcePack pack) {
+ JsonObject fakeSoundJSON = new JsonObject();
+
+ for (String domain : pack.getResourceDomains()) {
+
+ if (pack instanceof FileResourcePack) {
+ //For zip resource packs
+ try {
+ ZipFile zipFile = new ZipFile(pack.resourcePackFile);
+
+ if (zipFile.getEntry("assets/" + domain + "/sounds/") != null) {
+ Enumeration zipEntries = zipFile.entries();
+
+ while (zipEntries.hasMoreElements()) {
+ String zipPath = zipEntries.nextElement().getName();
+
+ String prefix = "assets/" + domain + "/sounds/";
+ if (zipPath.startsWith(prefix) && !zipPath.equals(prefix)) {
+ String soundName = zipPath.replaceFirst(prefix, "").replaceFirst("[.][^.]+$", "");
+ ZipEntry entry = zipFile.getEntry(zipPath);
+
+ if (!soundName.contains("/")) {
+ JsonObject sound = new JsonObject();
+ sound.addProperty("category", "ambient");
+ JsonArray sounds = new JsonArray();
+
+ if (entry.isDirectory()) {
+ //Sound Collection
+ Enumeration zipEntries2 = zipFile.entries();
+ while (zipEntries2.hasMoreElements()) {
+ String zipPath2 = zipEntries2.nextElement().getName();
+
+ if (zipPath2.startsWith(prefix + soundName + "/") && !zipFile.getEntry(zipPath2).isDirectory()) {
+ String randomSoundName = zipPath2.replaceFirst(prefix + soundName + "/", "");
+ sounds.add(new JsonPrimitive(soundName + "/" + randomSoundName.replaceFirst("[.][^.]+$", "")));
+ }
+ }
+ } else {
+ sounds.add(new JsonPrimitive(soundName));
+ }
+ sound.add("sounds", sounds);
+ fakeSoundJSON.add(soundName, sound);
+ }
+ }
+ }
+ }
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ throw new ExceptionInInitializerError("Error generating fake sound JSON file.");
+ }
+ } else {
+ //For folder resource packs
+ //Load all sounds in the assets/domain/sounds/*
+ File folder = new File(pack.resourcePackFile, "assets/" + domain + "/sounds/");
+
+ if (folder.exists()) {
+ File[] listOfFiles = folder.listFiles();
+
+ for (File listedFile : listOfFiles) {
+ JsonObject sound = new JsonObject();
+ sound.addProperty("category", "ambient");
+ JsonArray sounds = new JsonArray();
+
+ String listedName = listedFile.getName().replaceFirst("[.][^.]+$", "");
+ if (listedFile.isFile()) {
+ sounds.add(new JsonPrimitive(listedName));
+ } else if (listedFile.isDirectory()) {
+ for (File soundItemFile : listedFile.listFiles())
+ sounds.add(new JsonPrimitive(listedName + "/" + soundItemFile.getName().replaceFirst("[.][^.]+$", "")));
+ }
+
+ sound.add("sounds", sounds);
+ fakeSoundJSON.add(listedName, sound);
+ }
+ }
+ }
+ }
+
+ return fakeSoundJSON.toString();
+ }
+
+ public static String generatePackMcmeta() {
+ JsonObject jsonObject = new JsonObject();
+ jsonObject.addProperty("description", "NOVA mod resource pack");
+ jsonObject.addProperty("pack_format", "1");
+ JsonObject outerObj = new JsonObject();
+ outerObj.add("pack", jsonObject);
+ return outerObj.toString();
+ }
+
+ @Override
+ public boolean registerBus(EventBus bus, LoadController controller) {
+ bus.register(this);
+ return true;
+ }
+
+ @Subscribe
+ public void load(FMLConstructionEvent event) {
+ try {
+ //TODO: Use AT
+ //Apache Commons Hack
+ Field launchHandlerField = FMLLaunchHandler.class.getDeclaredField("INSTANCE");
+ launchHandlerField.setAccessible(true);
+ FMLLaunchHandler launchHandler = (FMLLaunchHandler) launchHandlerField.get(null);
+ Field clField = FMLLaunchHandler.class.getDeclaredField("classLoader");
+ clField.setAccessible(true);
+ LaunchClassLoader classLoader = (LaunchClassLoader) clField.get(launchHandler);
+ //Obfuscation?
+ Field setField = LaunchClassLoader.class.getDeclaredField("classLoaderExceptions");
+ setField.setAccessible(true);
+ Set classLoaderExceptions = (Set) setField.get(classLoader);
+ classLoaderExceptions.remove("org.apache.");
+ System.out.println("Successfully hacked 'org.apache' out of launcher exclusion");
+ } catch (Exception e) {
+ throw new ClassLoaderUtil.ClassLoaderException(e);
+ }
+
+ // Scan mod classes
+ ASMDataTable asmData = event.getASMHarvestedData();
+
+ modClassToFile = new HashMap<>();
+ modClasses = asmData
+ .getAll(Mod.class.getName())
+ .stream()
+ .map(ASMDataTable.ASMData::getClassName)
+ .map(c -> {
+ try {
+ return Class.forName(c);
+ } catch (ClassNotFoundException e) {
+ throw new ExceptionInInitializerError(e);
+ }
+ })
+ .collect(Collectors.toSet());
+
+ //Inject fake mod containers into FML
+ List fmlMods = ReflectionUtil.getPrivateObject(Loader.instance(), "mods");
+ List newMods = new ArrayList<>();
+ newMods.addAll(fmlMods);
+ modClasses.forEach(mod -> {
+ ModMetadata fakeMeta = new ModMetadata();
+ Mod annotation = mod.getAnnotation(Mod.class);
+ fakeMeta.modId = annotation.id();
+ fakeMeta.name = annotation.name();
+ fakeMeta.version = annotation.version();
+ fakeMeta.description = annotation.description();
+ newMods.add(new DummyNovaMod(fakeMeta, mod));
+ });
+ //TODO: Use AT
+ ReflectionUtil.setPrivateObject(Loader.instance(), newMods, "mods");
+
+ // Register resource packs
+ if (FMLCommonHandler.instance().getEffectiveSide() == Side.CLIENT) {
+ registerResourcePacks();
+ }
+ }
+
+ public void registerResourcePacks() {
+ Map> classesMap = modClasses
+ .stream()
+ .filter(clazz -> clazz.getAnnotation(Mod.class) != null)
+ .collect(Collectors.toMap((clazz) -> clazz.getAnnotation(Mod.class), Function.identity()));
+
+ try {
+ // The same list exists in the Minecraft class, but that can be SRG or not.
+ // Reflecting FML is just less work for us. (Minecraft.field_110449_ao)
+ Field resourcePackField = FMLClientHandler.class.getDeclaredField("resourcePackList");
+ resourcePackField.setAccessible(true);
+ List packs = (List) resourcePackField.get(FMLClientHandler.instance());
+
+ Set addedPacks = new HashSet<>();
+
+ classesMap.keySet().forEach(novaMod -> {
+ Class c = classesMap.get(novaMod);
+
+ //Add jar resource pack
+ String fn = c.getProtectionDomain().getCodeSource().getLocation().toExternalForm();
+
+ if (fn.contains("!")) {
+ fn = fn.substring(0, fn.indexOf('!')).replaceFirst("jar:", "");
+ File file;
+ try {
+ file = new File(new URL(fn).toURI());
+ } catch (MalformedURLException | URISyntaxException e) {
+ file = new File(fn); //This will probably not work on Windows, but we can at least try
+ }
+ modClassToFile.put(c, file);
+
+ if (!addedPacks.contains(fn)) {
+ addedPacks.add(fn);
+ packs.add(new NovaResourcePack(file, novaMod.id(), novaMod.domains()));
+ System.out.println("Registered NOVA jar resource pack: " + fn);
+ }
+ } else {
+ //Add folder resource pack location. The folderLocation is the root of the project, including the packages of classes, and an assets folder inside.
+ String folderLocation = c.getProtectionDomain().getCodeSource().getLocation().getPath();
+ String classPath = c.getCanonicalName().replaceAll("\\.", "/");
+ folderLocation = folderLocation.replaceFirst("file:", "").replace(classPath, "").replace("/.class", "").replaceAll("%20", " ");
+ File folderFile = new File(folderLocation);
+ if (!new File(folderFile, "assets").isDirectory()) {
+ //Try IDEA workaround.
+ folderFile = new File(folderLocation.replaceAll("build[\\\\/]classes", "build/resources"));
+ folderFile = new File(folderFile, "assets").isDirectory() ? folderFile : new File(folderLocation);
+ }
+ modClassToFile.put(c, folderFile);
+
+ addedPacks.add(folderLocation);
+ packs.add(new NovaFolderResourcePack(folderFile, novaMod.id(), novaMod.domains()));
+ System.out.println("Registered NOVA folder resource pack: " + folderFile.getAbsolutePath());
+ }
+ });
+ resourcePackField.set(FMLClientHandler.instance(), packs);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ /**
+ * A fake NovaMod to inject into FML.
+ */
+ private static class DummyNovaMod extends DummyModContainer {
+ private final Class mod;
+ private File source = null;
+
+ public DummyNovaMod(ModMetadata meta, Class mod) {
+ super(meta);
+ this.mod = mod;
+ }
+
+ @Override
+ public File getSource() {
+ if (this.source == null) {
+ this.source = NovaMinecraftPreloader.modClassToFile.get(mod);
+ }
+ return this.source;
+ }
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/StaticForwarder.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/StaticForwarder.java
new file mode 100644
index 000000000..43dc0a3e9
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/StaticForwarder.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.asm;
+
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+import net.minecraft.world.chunk.Chunk;
+import nova.core.event.BlockEvent;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.block.forward.FWTile;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.block.forward.FWTileLoader;
+import nova.internal.core.Game;
+import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
+
+/**
+ * Static forwarder forwards injected methods.
+ * @author Calclavia
+ */
+public class StaticForwarder {
+
+ public static void chunkSetBlockEvent(Chunk chunk, BlockPos pos, IBlockState oldBlockState, IBlockState newBlockState) {
+ // Publish the event
+ Game.events().publish(
+ new BlockEvent.Change(
+ Game.natives().toNova(chunk.getWorld()),
+ new Vector3D((chunk.xPosition << 4) + pos.getX(), pos.getY(), (chunk.zPosition << 4) + pos.getZ()),
+ Game.natives().toNova(oldBlockState.getBlock()), Game.natives().toNova(newBlockState.getBlock())
+ )
+ );
+ }
+
+ /**
+ * Used to inject forwarded TileEntites
+ * @param data
+ * @param clazz
+ * @return
+ * @throws Exception
+ */
+ public static TileEntity loadTileEntityHook(World world, NBTTagCompound data, Class clazz) throws Exception {
+ if (FWTile.class.isAssignableFrom(clazz)) {
+ return FWTileLoader.loadTile(data);
+ } else {
+ return clazz.newInstance();
+ }
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/ASMHelper.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/ASMHelper.java
new file mode 100644
index 000000000..956054244
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/ASMHelper.java
@@ -0,0 +1,391 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.asm.lib;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Multimap;
+import net.minecraft.launchwrapper.LaunchClassLoader;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.FieldNode;
+import org.objectweb.asm.tree.InsnList;
+import org.objectweb.asm.tree.LabelNode;
+import org.objectweb.asm.tree.LocalVariableNode;
+import org.objectweb.asm.tree.MethodNode;
+import org.objectweb.asm.tree.TryCatchBlockNode;
+
+import java.lang.reflect.Executable;
+import java.lang.reflect.Method;
+import java.security.ProtectionDomain;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.objectweb.asm.Opcodes.ARETURN;
+import static org.objectweb.asm.Opcodes.DRETURN;
+import static org.objectweb.asm.Opcodes.FRETURN;
+import static org.objectweb.asm.Opcodes.IRETURN;
+import static org.objectweb.asm.Opcodes.LRETURN;
+import static org.objectweb.asm.Opcodes.RET;
+import static org.objectweb.asm.Opcodes.RETURN;
+
+/**
+ * @author ChickenBones
+ */
+public class ASMHelper {
+ public static LaunchClassLoader cl = (LaunchClassLoader) ASMHelper.class.getClassLoader();
+ private static Method defineClass1;
+ private static Method defineClass2;
+
+ static {
+ try {
+ defineClass1 = ClassLoader.class.getDeclaredMethod("defineClass", new Class[] { String.class, byte[].class, int.class, int.class });
+ defineClass2 = ClassLoader.class.getDeclaredMethod("defineClass", new Class[] { String.class, byte[].class, int.class, int.class, ProtectionDomain.class });
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static MethodNode findMethod(ObfMapping methodmap, ClassNode cnode) {
+ for (MethodNode mnode : cnode.methods) {
+ if (methodmap.matches(mnode)) {
+ return mnode;
+ }
+ }
+ return null;
+ }
+
+ public static FieldNode findField(ObfMapping fieldmap, ClassNode cnode) {
+ for (FieldNode fnode : cnode.fields) {
+ if (fieldmap.matches(fnode)) {
+ return fnode;
+ }
+ }
+ return null;
+ }
+
+ public static ClassNode createClassNode(byte[] bytes) {
+ return createClassNode(bytes, 0);
+ }
+
+ public static ClassNode createClassNode(byte[] bytes, int flags) {
+ ClassNode cnode = new ClassNode();
+ ClassReader reader = new ClassReader(bytes);
+ reader.accept(cnode, flags);
+ return cnode;
+ }
+
+ public static byte[] createBytes(ClassNode cnode, int flags) {
+ ClassWriter cw = new CC_ClassWriter(flags);
+ cnode.accept(cw);
+ return cw.toByteArray();
+ }
+
+ public static byte[] writeMethods(String name, byte[] bytes, Multimap writers) {
+ if (writers.containsKey(name)) {
+ ClassNode cnode = createClassNode(bytes);
+
+ for (MethodWriter mw : writers.get(name)) {
+ MethodNode mv = findMethod(mw.method, cnode);
+ if (mv == null) {
+ mv = (MethodNode) cnode.visitMethod(mw.access, mw.method.s_name, mw.method.s_desc, null, mw.exceptions);
+ }
+
+ mv.access = mw.access;
+ mv.instructions.clear();
+ mw.write(mv);
+ }
+
+ bytes = createBytes(cnode, ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
+ }
+ return bytes;
+ }
+
+ public static byte[] injectMethods(String name, byte[] bytes, Multimap injectors) {
+ if (injectors.containsKey(name)) {
+ ClassNode cnode = createClassNode(bytes);
+
+ for (MethodInjector injector : injectors.get(name)) {
+ MethodNode method = findMethod(injector.method, cnode);
+ if (method == null) {
+ throw new RuntimeException("Method not found: " + injector.method);
+ }
+ System.out.println("Injecting into " + injector.method + "\n" + printInsnList(injector.injection));
+
+ List callNodes;
+ if (injector.before) {
+ callNodes = InstructionComparator.insnListFindStart(method.instructions, injector.needle);
+ } else {
+ callNodes = InstructionComparator.insnListFindEnd(method.instructions, injector.needle);
+ }
+
+ if (callNodes.size() == 0) {
+ throw new RuntimeException("Needle not found in Haystack: " + injector.method + "\n" + printInsnList(injector.needle));
+ }
+
+ for (AbstractInsnNode node : callNodes) {
+ if (injector.before) {
+ System.out.println("Injected before: " + printInsn(node));
+ method.instructions.insertBefore(node, cloneInsnList(injector.injection));
+ } else {
+ System.out.println("Injected after: " + printInsn(node));
+ method.instructions.insert(node, cloneInsnList(injector.injection));
+ }
+ }
+ }
+
+ bytes = createBytes(cnode, ClassWriter.COMPUTE_FRAMES);
+ }
+ return bytes;
+ }
+
+ public static String printInsnList(InsnList list) {
+ InsnListPrinter p = new InsnListPrinter();
+ p.visitInsnList(list);
+ return p.textString();
+ }
+
+ public static String printInsn(AbstractInsnNode insn) {
+ InsnListPrinter p = new InsnListPrinter();
+ p.visitInsn(insn);
+ return p.textString();
+ }
+
+ public static Map cloneLabels(InsnList insns) {
+ HashMap labelMap = new HashMap();
+ for (AbstractInsnNode insn = insns.getFirst(); insn != null; insn = insn.getNext()) {
+ if (insn.getType() == 8) {
+ labelMap.put((LabelNode) insn, new LabelNode());
+ }
+ }
+ return labelMap;
+ }
+
+ public static InsnList cloneInsnList(InsnList insns) {
+ return cloneInsnList(cloneLabels(insns), insns);
+ }
+
+ public static InsnList cloneInsnList(Map labelMap, InsnList insns) {
+ InsnList clone = new InsnList();
+ for (AbstractInsnNode insn = insns.getFirst(); insn != null; insn = insn.getNext()) {
+ clone.add(insn.clone(labelMap));
+ }
+
+ return clone;
+ }
+
+ public static List cloneTryCatchBlocks(Map labelMap, List tcblocks) {
+ ArrayList clone = new ArrayList();
+ for (TryCatchBlockNode node : tcblocks) {
+ clone.add(new TryCatchBlockNode(labelMap.get(node.start), labelMap.get(node.end), labelMap.get(node.handler), node.type));
+ }
+
+ return clone;
+ }
+
+ public static List cloneLocals(Map labelMap, List locals) {
+ ArrayList clone = new ArrayList();
+ for (LocalVariableNode node : locals) {
+ clone.add(new LocalVariableNode(node.name, node.desc, node.signature, labelMap.get(node.start), labelMap.get(node.end), node.index));
+ }
+
+ return clone;
+ }
+
+ public static void copy(MethodNode src, MethodNode dst) {
+ Map labelMap = cloneLabels(src.instructions);
+ dst.instructions = cloneInsnList(labelMap, src.instructions);
+ dst.tryCatchBlocks = cloneTryCatchBlocks(labelMap, src.tryCatchBlocks);
+ if (src.localVariables != null) {
+ dst.localVariables = cloneLocals(labelMap, src.localVariables);
+ }
+ dst.visibleAnnotations = src.visibleAnnotations;
+ dst.invisibleAnnotations = src.invisibleAnnotations;
+ dst.visitMaxs(src.maxStack, src.maxLocals);
+ }
+
+ public static byte[] alterMethods(String name, byte[] bytes, HashMultimap altercators) {
+ if (altercators.containsKey(name)) {
+ ClassNode cnode = createClassNode(bytes);
+
+ for (MethodAlterator injector : altercators.get(name)) {
+ MethodNode method = findMethod(injector.method, cnode);
+ if (method == null) {
+ throw new RuntimeException("Method not found: " + injector.method);
+ }
+
+ injector.alter(method);
+ }
+
+ bytes = createBytes(cnode, ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
+ }
+ return bytes;
+ }
+
+ public static int getLocal(List list, String name) {
+ int found = -1;
+ for (LocalVariableNode node : list) {
+ if (node.name.equals(name)) {
+ if (found >= 0) {
+ throw new RuntimeException("Duplicate local variable: " + name + " not coded to handle this scenario.");
+ }
+
+ found = node.index;
+ }
+ }
+ return found;
+ }
+
+ public static void replaceMethodCode(MethodNode original, MethodNode replacement) {
+ original.instructions.clear();
+ if (original.localVariables != null) {
+ original.localVariables.clear();
+ }
+ if (original.tryCatchBlocks != null) {
+ original.tryCatchBlocks.clear();
+ }
+ replacement.accept(original);
+ }
+
+ public static String printInsnList(InstructionComparator.InsnListSection subsection) {
+ InsnListPrinter p = new InsnListPrinter();
+ p.visitInsnList(subsection);
+ return p.textString();
+ }
+
+ public static void removeBlock(InsnList insns, InstructionComparator.InsnListSection block) {
+ AbstractInsnNode insn = block.first;
+ while (true) {
+ AbstractInsnNode next = insn.getNext();
+ insns.remove(insn);
+ if (insn == block.last) {
+ break;
+ }
+ insn = next;
+ }
+ }
+
+ public static boolean isReturn(AbstractInsnNode node) {
+ switch (node.getOpcode()) {
+ case RET:
+ case RETURN:
+ case ARETURN:
+ case DRETURN:
+ case FRETURN:
+ case IRETURN:
+ case LRETURN:
+ return true;
+
+ default:
+ return false;
+ }
+ }
+
+ public static String[] getExceptionTypes(Executable exec) {
+ return Arrays.stream(exec.getExceptionTypes()).map(Type::getInternalName).toArray(s -> new String[s]);
+ }
+
+ public static Class defineClass(ClassNode cn, int flags) {
+ try {
+ byte[] bytes = createBytes(cn, flags);
+ defineClass1.setAccessible(true);
+ Class clazz = (Class) defineClass1.invoke(Thread.currentThread().getContextClassLoader(), cn.name.replaceAll("/", "."), bytes, 0, bytes.length);
+ defineClass1.setAccessible(false);
+ return clazz;
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static Class defineClass(ClassNode cn, int flags, ProtectionDomain domain) {
+ if (domain == null) {
+ return defineClass(cn, flags);
+ }
+ try {
+ byte[] bytes = createBytes(cn, flags);
+ defineClass2.setAccessible(true);
+ Class clazz = (Class) defineClass2.invoke(Thread.currentThread().getContextClassLoader(), cn.name.replaceAll("/", "."), bytes, 0, bytes.length, domain);
+ defineClass2.setAccessible(false);
+ return clazz;
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static class CodeBlock {
+ public Label start = new Label();
+ public Label end = new Label();
+ }
+
+ public static class ForBlock extends CodeBlock {
+ public Label cmp = new Label();
+ public Label inc = new Label();
+ public Label body = new Label();
+ }
+
+ public static abstract class MethodAlterator {
+ public final ObfMapping method;
+
+ public MethodAlterator(ObfMapping method) {
+ this.method = method;
+ }
+
+ public abstract void alter(MethodNode mv);
+ }
+
+ public static abstract class MethodWriter {
+ public final int access;
+ public final ObfMapping method;
+ public final String[] exceptions;
+
+ public MethodWriter(int access, ObfMapping method) {
+ this(access, method, null);
+ }
+
+ public MethodWriter(int access, ObfMapping method, String[] exceptions) {
+ this.access = access;
+ this.method = method;
+ this.exceptions = exceptions;
+ }
+
+ public abstract void write(MethodNode mv);
+ }
+
+ public static class MethodInjector {
+ public final ObfMapping method;
+ public final InsnList needle;
+ public final InsnList injection;
+ public final boolean before;
+
+ public MethodInjector(ObfMapping method, InsnList needle, InsnList injection, boolean before) {
+ this.method = method;
+ this.needle = needle;
+ this.injection = injection;
+ this.before = before;
+ }
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/CC_ClassWriter.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/CC_ClassWriter.java
new file mode 100644
index 000000000..383fd30a0
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/CC_ClassWriter.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.asm.lib;
+
+import org.objectweb.asm.ClassWriter;
+
+/**
+ * @author ChickenBones
+ */
+public class CC_ClassWriter extends ClassWriter {
+ private final boolean runtime;
+
+ public CC_ClassWriter(int flags) {
+ this(flags, false);
+ }
+
+ public CC_ClassWriter(int flags, boolean runtime) {
+ super(flags);
+ this.runtime = runtime;
+ }
+
+ @Override
+ protected String getCommonSuperClass(String type1, String type2) {
+ String c = type1.replace('/', '.');
+ String d = type2.replace('/', '.');
+ if (ClassHeirachyManager.classExtends(d, c)) {
+ return type1;
+ }
+ if (ClassHeirachyManager.classExtends(c, d)) {
+ return type2;
+ }
+ do {
+ c = ClassHeirachyManager.getSuperClass(c, runtime);
+ }
+ while (!ClassHeirachyManager.classExtends(d, c));
+ return c.replace('.', '/');
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/ClassHeirachyManager.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/ClassHeirachyManager.java
new file mode 100644
index 000000000..726369343
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/ClassHeirachyManager.java
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.asm.lib;
+
+import net.minecraft.launchwrapper.IClassTransformer;
+import net.minecraft.launchwrapper.LaunchClassLoader;
+import net.minecraftforge.fml.common.asm.transformers.deobf.FMLDeobfuscatingRemapper;
+import nova.internal.core.Game;
+import org.objectweb.asm.tree.ClassNode;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+
+/**
+ * This is added as a class transformer if CodeChickenCore is installed. Adding it as a class
+ * transformer will speed evaluation up slightly by automatically caching superclasses when they are
+ * first loaded.
+ */
+public class ClassHeirachyManager implements IClassTransformer {
+ public static HashMap superclasses = new HashMap();
+ private static LaunchClassLoader cl = (LaunchClassLoader) ClassHeirachyManager.class.getClassLoader();
+
+ static {
+ cl.addTransformerExclusion("codechicken.lib.asm");
+ }
+
+ public static String toKey(String name) {
+ if (ObfMapping.obfuscated) {
+ name = FMLDeobfuscatingRemapper.INSTANCE.map(name.replace('.', '/')).replace('/', '.');
+ }
+ return name;
+ }
+
+ public static String unKey(String name) {
+ if (ObfMapping.obfuscated) {
+ name = FMLDeobfuscatingRemapper.INSTANCE.unmap(name.replace('.', '/')).replace('/', '.');
+ }
+ return name;
+ }
+
+ /**
+ * Returns true if clazz extends, either directly or indirectly, superclass.
+ * @param name The class in question
+ * @param superclass The class being extended
+ * @return
+ */
+ public static boolean classExtends(String name, String superclass) {
+ name = toKey(name);
+ superclass = toKey(superclass);
+
+ if (name.equals(superclass)) {
+ return true;
+ }
+
+ SuperCache cache = declareClass(name);
+ if (cache == null)// just can't handle this
+ {
+ return false;
+ }
+
+ cache.flatten();
+ return cache.parents.contains(superclass);
+ }
+
+ private static SuperCache declareClass(String name) {
+ name = toKey(name);
+ SuperCache cache = superclasses.get(name);
+
+ if (cache != null) {
+ return cache;
+ }
+
+ try {
+ byte[] bytes = cl.getClassBytes(unKey(name));
+ if (bytes != null) {
+ cache = declareASM(bytes);
+ }
+ } catch (IOException e) {
+ Game.logger().error(e.getMessage());
+ }
+
+ if (cache != null) {
+ return cache;
+ }
+
+ try {
+ cache = declareReflection(name);
+ } catch (ClassNotFoundException e) {
+ Game.logger().error(e.getMessage());
+ }
+
+ return cache;
+ }
+
+ private static SuperCache declareReflection(String name) throws ClassNotFoundException {
+ Class aclass = Class.forName(name);
+
+ SuperCache cache = getOrCreateCache(name);
+ if (aclass.isInterface()) {
+ cache.superclass = "java.lang.Object";
+ } else if (name.equals("java.lang.Object")) {
+ return cache;
+ } else {
+ cache.superclass = toKey(aclass.getSuperclass().getName());
+ }
+
+ cache.add(cache.superclass);
+ for (Class iclass : aclass.getInterfaces()) {
+ cache.add(toKey(iclass.getName()));
+ }
+
+ return cache;
+ }
+
+ private static SuperCache declareASM(byte[] bytes) {
+ ClassNode node = ASMHelper.createClassNode(bytes);
+ String name = toKey(node.name);
+
+ SuperCache cache = getOrCreateCache(name);
+ cache.superclass = toKey(node.superName.replace('/', '.'));
+ cache.add(cache.superclass);
+ for (String iclass : node.interfaces) {
+ cache.add(toKey(iclass.replace('/', '.')));
+ }
+
+ return cache;
+ }
+
+ public static SuperCache getOrCreateCache(String name) {
+ SuperCache cache = superclasses.get(name);
+ if (cache == null) {
+ superclasses.put(name, cache = new SuperCache());
+ }
+ return cache;
+ }
+
+ public static String getSuperClass(String name, boolean runtime) {
+ name = toKey(name);
+ SuperCache cache = declareClass(name);
+ if (cache == null) {
+ return "java.lang.Object";
+ }
+
+ cache.flatten();
+ String s = cache.superclass;
+ if (!runtime) {
+ s = FMLDeobfuscatingRemapper.INSTANCE.unmap(s);
+ }
+ return s;
+ }
+
+ @Override
+ public byte[] transform(String name, String tname, byte[] bytes) {
+ if (bytes == null) {
+ return null;
+ }
+
+ if (!superclasses.containsKey(tname)) {
+ declareASM(bytes);
+ }
+
+ return bytes;
+ }
+
+ public static class SuperCache {
+ public HashSet parents = new HashSet();
+ String superclass;
+ private boolean flattened;
+
+ public void add(String parent) {
+ parents.add(parent);
+ }
+
+ public void flatten() {
+ if (flattened) {
+ return;
+ }
+
+ for (String s : new ArrayList(parents)) {
+ SuperCache c = declareClass(s);
+ if (c != null) {
+ c.flatten();
+ parents.addAll(c.parents);
+ }
+ }
+ flattened = true;
+ }
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/ComponentInjector.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/ComponentInjector.java
new file mode 100644
index 000000000..28b1ea0fa
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/ComponentInjector.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.asm.lib;
+
+import nova.core.component.Component;
+import nova.core.component.ComponentProvider;
+import nova.core.component.Passthrough;
+import nova.core.network.NetworkTarget.Side;
+import nova.core.util.ClassLoaderUtil;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.ClassNode;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * The ComponentInjector is capable of creating dynamic classes that implement a
+ * specified super class and implement the interfaces specified by
+ * {@link Component} and {@link Passthrough}.
+ * @param
+ * @author Vic Nightfall
+ */
+public class ComponentInjector implements Opcodes {
+
+ private Class baseClazz;
+
+ /**
+ * Cache, contains already created class objects for later use
+ */
+ private Map>, Class> cache = new HashMap<>();
+
+ public ComponentInjector(Class baseClazz) {
+ this.baseClazz = baseClazz;
+ }
+
+ public synchronized T inject(ComponentProvider provider, Class[] typeArgs, Object[] args) {
+ try {
+ List components = provider.components().stream()
+ .filter(component -> component.getClass().getAnnotationsByType(Passthrough.class).length > 0)
+ .collect(Collectors.toList());
+
+ if (components.size() > 0) {
+ List> componentClazzes = components.stream().map(c -> c.getClass()).collect(Collectors.toList());
+ System.out.println(Side.get() + " " + componentClazzes);
+ if (cache.containsKey(componentClazzes))
+ // Cached class
+ {
+ return inject(cache.get(componentClazzes).getConstructor(typeArgs).newInstance(args), provider);
+ } else {
+ Class clazz = construct(componentClazzes);
+ cache.put(componentClazzes, clazz);
+ return inject(clazz.getConstructor(typeArgs).newInstance(args), provider);
+ }
+
+ } else {
+ // No components withPriority passthrough interfaces, we can use the
+ // base class.
+ return baseClazz.getConstructor(typeArgs).newInstance(args);
+ }
+ } catch (Exception e) {
+ throw new ClassLoaderUtil.ClassLoaderException("Failed to construct wrapper class for " + baseClazz, e);
+ }
+ }
+
+ private T inject(T instance, ComponentProvider provider) throws ReflectiveOperationException {
+ Field f = instance.getClass().getDeclaredField("$$_provider");
+ f.setAccessible(true);
+ f.set(instance, provider);
+ f.setAccessible(false);
+ return instance;
+ }
+
+ private Class construct(List> components) {
+
+ // Map components to specified wrapped interfaces
+ Map, Class> intfComponentMap = new HashMap<>();
+ for (Class component : components) {
+ for (Passthrough pt : component.getAnnotationsByType(Passthrough.class)) {
+ Class intf;
+ try {
+ intf = Class.forName(pt.value());
+ } catch (ClassNotFoundException exec) {
+ throw new ClassLoaderUtil.ClassLoaderException("Invalid passthrough \"%s\" on component %s, the specified interface doesn't exist.", pt.value(), component);
+ }
+ if (!intf.isAssignableFrom(component)) {
+ throw new ClassLoaderUtil.ClassLoaderException("Invalid passthrough \"%s\" on component %s, the specified interface isn't implemented.", pt.value(), component);
+ }
+ if (intfComponentMap.containsKey(intf)) {
+ throw new ClassLoaderUtil.ClassLoaderException("Duplicate Passthrough interface found: %s (%s, %s)", pt.value(), component, intfComponentMap.get(intf));
+ }
+ intfComponentMap.put(intf, component);
+ }
+ }
+
+ // Create new ClassNode from cached bytes
+ ClassNode clazzNode = new ClassNode();
+ String name = Type.getInternalName(baseClazz);
+ String classname = name + "_$$_NOVA_" + cache.size();
+
+ // Inject block field
+ clazzNode.visit(V1_8, ACC_PUBLIC | ACC_SUPER, classname, null, name, intfComponentMap.keySet().stream().map(Type::getInternalName).toArray(s -> new String[s]));
+ clazzNode.visitField(ACC_PRIVATE | ACC_FINAL, "$$_provider", Type.getDescriptor(ComponentProvider.class), null, null).visitEnd();
+
+ // Add constructors
+ for (Constructor constructor : baseClazz.getConstructors()) {
+ int mod = constructor.getModifiers();
+ String descr = Type.getConstructorDescriptor(constructor);
+
+ if (Modifier.isFinal(mod) || Modifier.isPrivate(mod)) {
+ continue;
+ }
+ MethodVisitor mv = clazzNode.visitMethod(mod, "", descr, null, ASMHelper.getExceptionTypes(constructor));
+
+ // Call super constructor
+ mv.visitCode();
+ // load this
+ mv.visitVarInsn(ALOAD, 0);
+ Class[] parameters = constructor.getParameterTypes();
+ for (int i = 0; i < constructor.getParameterCount(); i++) {
+ // variables
+ mv.visitVarInsn(Type.getType(parameters[i]).getOpcode(ILOAD), i + 1);
+ }
+ mv.visitMethodInsn(INVOKESPECIAL, Type.getInternalName(baseClazz), "", descr, false);
+ // return
+ mv.visitInsn(RETURN);
+ mv.visitMaxs(0, 0);
+ mv.visitEnd();
+ }
+
+ // Add methods
+ for (Class intf : intfComponentMap.keySet()) {
+ // Create class constant
+ Type clazzConst = Type.getType(intf.getClass());
+
+ for (Method m : intf.getMethods()) {
+ boolean isVoid = m.getReturnType() == null;
+ String descr = Type.getMethodDescriptor(m);
+
+ MethodVisitor mv = clazzNode.visitMethod(ACC_PUBLIC, m.getName(), descr, null, ASMHelper.getExceptionTypes(m));
+ mv.visitCode();
+
+ // load block instance
+ mv.visitVarInsn(ALOAD, 0);
+ mv.visitFieldInsn(GETFIELD, classname, "$$_provider", Type.getDescriptor(ComponentProvider.class));
+ mv.visitLdcInsn(clazzConst);
+ // load component instance
+ mv.visitMethodInsn(INVOKEVIRTUAL, Type.getInternalName(ComponentProvider.class), "get", Type.getMethodDescriptor(Type.getType(Component.class), Type.getType(Class.class)), false);
+
+ // add parameters
+ Class[] parameters = m.getParameterTypes();
+ for (int i = 0; i < m.getParameterCount(); i++) {
+ mv.visitVarInsn(Type.getType(parameters[i]).getOpcode(ILOAD), i + 1);
+ }
+
+ // invoke
+ mv.visitMethodInsn(INVOKEINTERFACE, Type.getInternalName(intf), m.getName(), descr, true);
+ mv.visitInsn(isVoid ? RETURN : Type.getType(m.getReturnType()).getOpcode(IRETURN));
+ mv.visitMaxs(0, 0);
+ mv.visitEnd();
+ }
+ }
+
+ clazzNode.visitEnd();
+
+ return ASMHelper.defineClass(clazzNode, ClassWriter.COMPUTE_MAXS, baseClazz.getProtectionDomain());
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/InsnListPrinter.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/InsnListPrinter.java
new file mode 100644
index 000000000..4a5cba910
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/InsnListPrinter.java
@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.asm.lib;
+
+import org.objectweb.asm.Label;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.FieldInsnNode;
+import org.objectweb.asm.tree.FrameNode;
+import org.objectweb.asm.tree.IincInsnNode;
+import org.objectweb.asm.tree.InsnList;
+import org.objectweb.asm.tree.IntInsnNode;
+import org.objectweb.asm.tree.InvokeDynamicInsnNode;
+import org.objectweb.asm.tree.JumpInsnNode;
+import org.objectweb.asm.tree.LabelNode;
+import org.objectweb.asm.tree.LdcInsnNode;
+import org.objectweb.asm.tree.LineNumberNode;
+import org.objectweb.asm.tree.LookupSwitchInsnNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MultiANewArrayInsnNode;
+import org.objectweb.asm.tree.TableSwitchInsnNode;
+import org.objectweb.asm.tree.TypeInsnNode;
+import org.objectweb.asm.tree.VarInsnNode;
+import org.objectweb.asm.util.Textifier;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.HashMap;
+
+public class InsnListPrinter extends Textifier {
+ private boolean buildingLabelMap = false;
+
+ public InsnListPrinter() {
+ super(Opcodes.ASM5);
+ }
+
+ public void visitInsnList(InsnList list) {
+ text.clear();
+ if (labelNames == null) {
+ labelNames = new HashMap();
+ } else {
+ labelNames.clear();
+ }
+
+ buildingLabelMap = true;
+ for (AbstractInsnNode insn = list.getFirst(); insn != null; insn = insn.getNext()) {
+ if (insn.getType() == 8) {
+ visitLabel(((LabelNode) insn).getLabel());
+ }
+ }
+
+ text.clear();
+ buildingLabelMap = false;
+
+ for (AbstractInsnNode insn = list.getFirst(); insn != null; insn = insn.getNext()) {
+ _visitInsn(insn);
+ }
+ }
+
+ public void visitInsnList(InstructionComparator.InsnListSection subsection) {
+ text.clear();
+ if (labelNames == null) {
+ labelNames = new HashMap();
+ } else {
+ labelNames.clear();
+ }
+
+ buildingLabelMap = true;
+ {
+ AbstractInsnNode insn = subsection.first;
+ while (true) {
+ if (insn.getType() == 8) {
+ visitLabel(((LabelNode) insn).getLabel());
+ }
+ if (insn == subsection.last) {
+ break;
+ }
+ insn = insn.getNext();
+ }
+ }
+
+ text.clear();
+ buildingLabelMap = false;
+
+ {
+ AbstractInsnNode insn = subsection.first;
+ while (true) {
+ _visitInsn(insn);
+ if (insn == subsection.last) {
+ break;
+ }
+ insn = insn.getNext();
+ }
+ }
+ }
+
+ public void visitInsn(AbstractInsnNode insn) {
+ text.clear();
+ if (labelNames == null) {
+ labelNames = new HashMap();
+ } else {
+ labelNames.clear();
+ }
+
+ _visitInsn(insn);
+ }
+
+ private void _visitInsn(AbstractInsnNode insn) {
+ switch (insn.getType()) {
+ case 0:
+ visitInsn(insn.getOpcode());
+ break;
+ case 1:
+ IntInsnNode iinsn = (IntInsnNode) insn;
+ visitIntInsn(iinsn.getOpcode(), iinsn.operand);
+ break;
+ case 2:
+ VarInsnNode vinsn = (VarInsnNode) insn;
+ visitVarInsn(vinsn.getOpcode(), vinsn.var);
+ break;
+ case 3:
+ TypeInsnNode tinsn = (TypeInsnNode) insn;
+ visitTypeInsn(tinsn.getOpcode(), tinsn.desc);
+ break;
+ case 4:
+ FieldInsnNode finsn = (FieldInsnNode) insn;
+ visitFieldInsn(finsn.getOpcode(), finsn.owner, finsn.name, finsn.desc);
+ break;
+ case 5:
+ MethodInsnNode minsn = (MethodInsnNode) insn;
+ visitMethodInsn(minsn.getOpcode(), minsn.owner, minsn.name, minsn.desc);
+ break;
+ case 6:
+ InvokeDynamicInsnNode idinsn = (InvokeDynamicInsnNode) insn;
+ visitInvokeDynamicInsn(idinsn.name, idinsn.desc, idinsn.bsm, idinsn.bsmArgs);
+ break;
+ case 7:
+ JumpInsnNode jinsn = (JumpInsnNode) insn;
+ visitJumpInsn(jinsn.getOpcode(), jinsn.label.getLabel());
+ break;
+ case 8:
+ LabelNode linsn = (LabelNode) insn;
+ visitLabel(linsn.getLabel());
+ break;
+ case 9:
+ LdcInsnNode ldcinsn = (LdcInsnNode) insn;
+ visitLdcInsn(ldcinsn.cst);
+ break;
+ case 10:
+ IincInsnNode iiinsn = (IincInsnNode) insn;
+ visitIincInsn(iiinsn.var, iiinsn.incr);
+ break;
+ case 11:
+ TableSwitchInsnNode tsinsn = (TableSwitchInsnNode) insn;
+ Label[] tslables = new Label[tsinsn.labels.size()];
+ for (int i = 0; i < tslables.length; i++) {
+ tslables[i] = tsinsn.labels.get(i).getLabel();
+ }
+ visitTableSwitchInsn(tsinsn.min, tsinsn.max, tsinsn.dflt.getLabel(), tslables);
+ break;
+ case 12:
+ LookupSwitchInsnNode lsinsn = (LookupSwitchInsnNode) insn;
+ Label[] lslables = new Label[lsinsn.labels.size()];
+ for (int i = 0; i < lslables.length; i++) {
+ lslables[i] = lsinsn.labels.get(i).getLabel();
+ }
+ int[] lskeys = new int[lsinsn.keys.size()];
+ for (int i = 0; i < lskeys.length; i++) {
+ lskeys[i] = lsinsn.keys.get(i);
+ }
+ visitLookupSwitchInsn(lsinsn.dflt.getLabel(), lskeys, lslables);
+ break;
+ case 13:
+ MultiANewArrayInsnNode ainsn = (MultiANewArrayInsnNode) insn;
+ visitMultiANewArrayInsn(ainsn.desc, ainsn.dims);
+ break;
+ case 14:
+ FrameNode fnode = (FrameNode) insn;
+ switch (fnode.type) {
+ case -1:
+ case 0:
+ visitFrame(fnode.type, fnode.local.size(), fnode.local.toArray(), fnode.stack.size(), fnode.stack.toArray());
+ break;
+ case 1:
+ visitFrame(fnode.type, fnode.local.size(), fnode.local.toArray(), 0, null);
+ break;
+ case 2:
+ visitFrame(fnode.type, fnode.local.size(), null, 0, null);
+ break;
+ case 3:
+ visitFrame(fnode.type, 0, null, 0, null);
+ break;
+ case 4:
+ visitFrame(fnode.type, 0, null, 1, fnode.stack.toArray());
+ }
+ break;
+ case 15:
+ LineNumberNode lnode = (LineNumberNode) insn;
+ visitLineNumber(lnode.line, lnode.start.getLabel());
+ break;
+ }
+ }
+
+ @Override
+ public void visitLabel(Label label) {
+ if (!buildingLabelMap && !labelNames.containsKey(label)) {
+ labelNames.put(label, "LEXT" + labelNames.size());
+ }
+ super.visitLabel(label);
+ }
+
+ public String textString() {
+ StringWriter sw = new StringWriter();
+ PrintWriter pw = new PrintWriter(sw);
+ print(pw);
+ pw.flush();
+ return sw.toString();
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/InstructionComparator.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/InstructionComparator.java
new file mode 100644
index 000000000..df12d50f4
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/InstructionComparator.java
@@ -0,0 +1,253 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.asm.lib;
+
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.FieldInsnNode;
+import org.objectweb.asm.tree.IincInsnNode;
+import org.objectweb.asm.tree.InsnList;
+import org.objectweb.asm.tree.IntInsnNode;
+import org.objectweb.asm.tree.JumpInsnNode;
+import org.objectweb.asm.tree.LabelNode;
+import org.objectweb.asm.tree.LdcInsnNode;
+import org.objectweb.asm.tree.LineNumberNode;
+import org.objectweb.asm.tree.LookupSwitchInsnNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.TableSwitchInsnNode;
+import org.objectweb.asm.tree.TypeInsnNode;
+import org.objectweb.asm.tree.VarInsnNode;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+
+import static org.objectweb.asm.tree.AbstractInsnNode.FIELD_INSN;
+import static org.objectweb.asm.tree.AbstractInsnNode.IINC_INSN;
+import static org.objectweb.asm.tree.AbstractInsnNode.INT_INSN;
+import static org.objectweb.asm.tree.AbstractInsnNode.LDC_INSN;
+import static org.objectweb.asm.tree.AbstractInsnNode.METHOD_INSN;
+import static org.objectweb.asm.tree.AbstractInsnNode.TYPE_INSN;
+import static org.objectweb.asm.tree.AbstractInsnNode.VAR_INSN;
+
+public class InstructionComparator {
+ public static boolean varInsnEqual(VarInsnNode insn1, VarInsnNode insn2) {
+ return insn1.var == -1 || insn2.var == -1 || insn1.var == insn2.var;
+ }
+
+ public static boolean methodInsnEqual(AbstractInsnNode absnode, int Opcode, ObfMapping method) {
+ return absnode.getOpcode() == Opcode && absnode instanceof MethodInsnNode && method.matches((MethodInsnNode) absnode);
+ }
+
+ public static boolean methodInsnEqual(MethodInsnNode insn1, MethodInsnNode insn2) {
+ return insn1.owner.equals(insn2.owner) && insn1.name.equals(insn2.name) && insn1.desc.equals(insn2.desc);
+ }
+
+ public static boolean fieldInsnEqual(FieldInsnNode insn1, FieldInsnNode insn2) {
+ return insn1.owner.equals(insn2.owner) && insn1.name.equals(insn2.name) && insn1.desc.equals(insn2.desc);
+ }
+
+ public static boolean ldcInsnEqual(LdcInsnNode insn1, LdcInsnNode insn2) {
+ return insn1.cst.equals("~") || insn2.cst.equals("~") || insn1.cst.equals(insn2.cst);
+ }
+
+ public static boolean typeInsnEqual(TypeInsnNode insn1, TypeInsnNode insn2) {
+ return insn1.desc.equals("~") || insn2.desc.equals("~") || insn1.desc.equals(insn2.desc);
+ }
+
+ public static boolean iincInsnEqual(IincInsnNode node1, IincInsnNode node2) {
+ return node1.var == node2.var && node1.incr == node2.incr;
+ }
+
+ public static boolean intInsnEqual(IntInsnNode node1, IntInsnNode node2) {
+ return node1.operand == -1 || node2.operand == -1 || node1.operand == node2.operand;
+ }
+
+ public static boolean insnEqual(AbstractInsnNode node1, AbstractInsnNode node2) {
+ if (node1.getOpcode() != node2.getOpcode()) {
+ return false;
+ }
+
+ switch (node2.getType()) {
+ case VAR_INSN:
+ return varInsnEqual((VarInsnNode) node1, (VarInsnNode) node2);
+ case TYPE_INSN:
+ return typeInsnEqual((TypeInsnNode) node1, (TypeInsnNode) node2);
+ case FIELD_INSN:
+ return fieldInsnEqual((FieldInsnNode) node1, (FieldInsnNode) node2);
+ case METHOD_INSN:
+ return methodInsnEqual((MethodInsnNode) node1, (MethodInsnNode) node2);
+ case LDC_INSN:
+ return ldcInsnEqual((LdcInsnNode) node1, (LdcInsnNode) node2);
+ case IINC_INSN:
+ return iincInsnEqual((IincInsnNode) node1, (IincInsnNode) node2);
+ case INT_INSN:
+ return intInsnEqual((IntInsnNode) node1, (IntInsnNode) node2);
+ default:
+ return true;
+ }
+ }
+
+ public static InsnList getImportantList(InsnList list) {
+ if (list.size() == 0) {
+ return list;
+ }
+
+ HashMap labels = new HashMap();
+ for (AbstractInsnNode insn = list.getFirst(); insn != null; insn = insn.getNext()) {
+ if (insn instanceof LabelNode) {
+ labels.put((LabelNode) insn, (LabelNode) insn);
+ }
+ }
+
+ InsnList importantNodeList = new InsnList();
+ for (AbstractInsnNode insn = list.getFirst(); insn != null; insn = insn.getNext()) {
+ if (insn instanceof LabelNode || insn instanceof LineNumberNode) {
+ continue;
+ }
+
+ importantNodeList.add(insn.clone(labels));
+ }
+ return importantNodeList;
+ }
+
+ public static boolean insnListMatches(InsnList haystack, InsnList needle, int start) {
+ if (haystack.size() - start < needle.size()) {
+ return false;
+ }
+
+ for (int i = 0; i < needle.size(); i++) {
+ if (!insnEqual(haystack.get(i + start), needle.get(i))) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ public static List insnListFind(InsnList haystack, InsnList needle) {
+ LinkedList list = new LinkedList();
+ for (int start = 0; start <= haystack.size() - needle.size(); start++) {
+ if (insnListMatches(haystack, needle, start)) {
+ list.add(start);
+ }
+ }
+
+ return list;
+ }
+
+ public static List insnListFindStart(InsnList haystack, InsnList needle) {
+ LinkedList callNodes = new LinkedList();
+ for (int callPoint : insnListFind(haystack, needle)) {
+ callNodes.add(haystack.get(callPoint));
+ }
+ return callNodes;
+ }
+
+ public static List insnListFindEnd(InsnList haystack, InsnList needle) {
+ LinkedList callNodes = new LinkedList();
+ for (int callPoint : insnListFind(haystack, needle)) {
+ callNodes.add(haystack.get(callPoint + needle.size() - 1));
+ }
+ return callNodes;
+ }
+
+ public static List insnListFindL(InsnList haystack, InsnList needle) {
+ HashSet controlFlowLabels = new HashSet();
+
+ for (AbstractInsnNode insn = haystack.getFirst(); insn != null; insn = insn.getNext()) {
+ switch (insn.getType()) {
+ case 8:
+ case 15:
+ break;
+ case 7:
+ JumpInsnNode jinsn = (JumpInsnNode) insn;
+ controlFlowLabels.add(jinsn.label);
+ break;
+ case 11:
+ TableSwitchInsnNode tsinsn = (TableSwitchInsnNode) insn;
+ for (LabelNode label : tsinsn.labels) {
+ controlFlowLabels.add(label);
+ }
+ break;
+ case 12:
+ LookupSwitchInsnNode lsinsn = (LookupSwitchInsnNode) insn;
+ for (LabelNode label : lsinsn.labels) {
+ controlFlowLabels.add(label);
+ }
+ break;
+ }
+ }
+
+ LinkedList list = new LinkedList();
+ nextsection:
+ for (int start = 0; start <= haystack.size() - needle.size(); start++) {
+ InsnListSection section = insnListMatchesL(haystack, needle, start, controlFlowLabels);
+ if (section != null) {
+ for (InsnListSection asection : list) {
+ if (asection.last == section.last) {
+ continue nextsection;
+ }
+ }
+
+ list.add(section);
+ }
+ }
+
+ return list;
+ }
+
+ private static InsnListSection insnListMatchesL(InsnList haystack, InsnList needle, int start, HashSet controlFlowLabels) {
+ int h = start, n = 0;
+ for (; h < haystack.size() && n < needle.size(); h++) {
+ AbstractInsnNode insn = haystack.get(h);
+ if (insn.getType() == 15) {
+ continue;
+ }
+ if (insn.getType() == 8 && !controlFlowLabels.contains(insn)) {
+ continue;
+ }
+
+ if (!insnEqual(haystack.get(h), needle.get(n))) {
+ return null;
+ }
+ n++;
+ }
+ if (n != needle.size()) {
+ return null;
+ }
+
+ return new InsnListSection(haystack, start, h - 1);
+ }
+
+ public static class InsnListSection {
+ public AbstractInsnNode first;
+ public AbstractInsnNode last;
+
+ public InsnListSection(AbstractInsnNode first, AbstractInsnNode last) {
+ this.first = first;
+ this.last = last;
+ }
+
+ public InsnListSection(InsnList haystack, int start, int end) {
+ this(haystack.get(start), haystack.get(end));
+ }
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/ObfMapping.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/ObfMapping.java
new file mode 100644
index 000000000..95776e95d
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/ObfMapping.java
@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.asm.lib;
+
+import com.google.common.base.Objects;
+import net.minecraft.launchwrapper.LaunchClassLoader;
+import net.minecraftforge.fml.common.asm.transformers.deobf.FMLDeobfuscatingRemapper;
+import nova.internal.core.Game;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.commons.Remapper;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.FieldInsnNode;
+import org.objectweb.asm.tree.FieldNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
+import org.objectweb.asm.tree.TypeInsnNode;
+
+import java.io.IOException;
+
+/**
+ * @author ChickenBones
+ */
+public class ObfMapping {
+ public static final boolean obfuscated;
+ /**
+ * CCC will deal withPriority this.
+ */
+ public static Remapper runtimeMapper = FMLDeobfuscatingRemapper.INSTANCE;
+ public static Remapper mcpMapper = null;
+
+ static {
+ boolean obf = true;
+ try {
+ obf = ((LaunchClassLoader) ObfMapping.class.getClassLoader()).getClassBytes("net.minecraft.world.World") == null;
+ } catch (IOException iox) {
+ Game.logger().error(iox.getMessage());
+ }
+ obfuscated = obf;
+ }
+
+ public String s_owner;
+ public String s_name;
+ public String s_desc;
+
+ public boolean runtime;
+
+ public ObfMapping(String owner) {
+ this(owner, "", "");
+ }
+
+ public ObfMapping(String owner, String name, String desc) {
+ this.s_owner = owner;
+ this.s_name = name;
+ this.s_desc = desc;
+
+ if (s_owner.contains(".")) {
+ throw new IllegalArgumentException(s_owner);
+ }
+
+ if (mcpMapper != null) {
+ map(mcpMapper);
+ }
+ }
+
+ public ObfMapping(ObfMapping descmap, String subclass) {
+ this(subclass, descmap.s_name, descmap.s_desc);
+ }
+
+ public static ObfMapping fromDesc(String s) {
+ int lastDot = s.lastIndexOf('.');
+ if (lastDot < 0) {
+ return new ObfMapping(s, "", "");
+ }
+ int sep = s.indexOf('(');// methods
+ int sep_end = sep;
+ if (sep < 0) {
+ sep = s.indexOf(' ');// some stuffs
+ sep_end = sep + 1;
+ }
+ if (sep < 0) {
+ sep = s.indexOf(':');// fields
+ sep_end = sep + 1;
+ }
+ if (sep < 0) {
+ return new ObfMapping(s.substring(0, lastDot), s.substring(lastDot + 1), "");
+ }
+
+ return new ObfMapping(s.substring(0, lastDot), s.substring(lastDot + 1, sep), s.substring(sep_end));
+ }
+
+ public ObfMapping subclass(String subclass) {
+ return new ObfMapping(this, subclass);
+ }
+
+ public boolean matches(MethodNode node) {
+ return s_name.equals(node.name) && s_desc.equals(node.desc);
+ }
+
+ public boolean matches(MethodInsnNode node) {
+ return s_owner.equals(node.owner) && s_name.equals(node.name) && s_desc.equals(node.desc);
+ }
+
+ public AbstractInsnNode toInsn(int opcode) {
+ if (isClass()) {
+ return new TypeInsnNode(opcode, s_owner);
+ } else if (isMethod()) {
+ return new MethodInsnNode(opcode, s_owner, s_name, s_desc);
+ } else {
+ return new FieldInsnNode(opcode, s_owner, s_name, s_desc);
+ }
+ }
+
+ public void visitTypeInsn(MethodVisitor mv, int opcode) {
+ mv.visitTypeInsn(opcode, s_owner);
+ }
+
+ public void visitMethodInsn(MethodVisitor mv, int opcode) {
+ mv.visitMethodInsn(opcode, s_owner, s_name, s_desc);
+ }
+
+ public void visitFieldInsn(MethodVisitor mv, int opcode) {
+ mv.visitFieldInsn(opcode, s_owner, s_name, s_desc);
+ }
+
+ public boolean isClass(String name) {
+ return name.replace('.', '/').equals(s_owner);
+ }
+
+ public boolean matches(String name, String desc) {
+ return s_name.equals(name) && s_desc.equals(desc);
+ }
+
+ public boolean matches(FieldNode node) {
+ return s_name.equals(node.name) && s_desc.equals(node.desc);
+ }
+
+ public boolean matches(FieldInsnNode node) {
+ return s_owner.equals(node.owner) && s_name.equals(node.name) && s_desc.equals(node.desc);
+ }
+
+ public String javaClass() {
+ return s_owner.replace('/', '.');
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (!(obj instanceof ObfMapping)) {
+ return false;
+ }
+
+ ObfMapping desc = (ObfMapping) obj;
+ return s_owner.equals(desc.s_owner) && s_name.equals(desc.s_name) && s_desc.equals(desc.s_desc);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(s_desc, s_name, s_owner);
+ }
+
+ @Override
+ public String toString() {
+ if (s_name.length() == 0) {
+ return "[" + s_owner + "]";
+ }
+ if (s_desc.length() == 0) {
+ return "[" + s_owner + "." + s_name + "]";
+ }
+ return "[" + (isMethod() ? methodDesc() : fieldDesc()) + "]";
+ }
+
+ public String methodDesc() {
+ return s_owner + "." + s_name + s_desc;
+ }
+
+ public String fieldDesc() {
+ return s_owner + "." + s_name + ":" + s_desc;
+ }
+
+ public boolean isClass() {
+ return s_name.length() == 0;
+ }
+
+ public boolean isMethod() {
+ return s_desc.contains("(");
+ }
+
+ public boolean isField() {
+ return !isClass() && !isMethod();
+ }
+
+ public ObfMapping map(Remapper mapper) {
+ if (isMethod()) {
+ s_name = mapper.mapMethodName(s_owner, s_name, s_desc);
+ } else if (isField()) {
+ s_name = mapper.mapFieldName(s_owner, s_name, s_desc);
+ }
+
+ s_owner = mapper.mapType(s_owner);
+
+ if (isMethod()) {
+ s_desc = mapper.mapMethodDesc(s_desc);
+ } else if (s_desc.length() > 0) {
+ s_desc = mapper.mapDesc(s_desc);
+ }
+
+ return this;
+ }
+
+ public ObfMapping toRuntime() {
+ if (!runtime) {
+ map(runtimeMapper);
+ }
+
+ runtime = true;
+ return this;
+ }
+
+ public ObfMapping copy() {
+ return new ObfMapping(s_owner, s_name, s_desc);
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/TemplateInjector.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/TemplateInjector.java
new file mode 100644
index 000000000..52f7fff99
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/TemplateInjector.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.asm.lib;
+
+import com.google.common.collect.HashBiMap;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.MethodNode;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * The template injection manager is capable of injecting default interfaces into classes.
+ * The default interface will have no overrides, thereby implementing the default methods.
+ * @author Calclavia, ChickenBones
+ */
+public class TemplateInjector {
+
+ public static final TemplateInjector instance = new TemplateInjector();
+ private HashBiMap templates = HashBiMap.create();
+
+ /**
+ * Registers a class to be injected by a default interface
+ * @param className - Class that will be injected
+ * @param template - Default interface used as a template to inject in the templateName
+ */
+ public void registerTemplate(String className, Class template) {
+ templates.put(className, new InjectionTemplate(template.getName()));
+ }
+
+ private ClassNode getClassNode(String name) {
+ try {
+ return ASMHelper.createClassNode(ASMHelper.cl.getClassBytes(name.replace('/', '.')));
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ public class InjectionTemplate {
+ /**
+ * The default interface class name that acts as a template.
+ */
+ public final String templateName;
+
+ /**
+ * The methods to be injected upon inject(ClassNode cnode);
+ */
+ public ArrayList methodImplementations = new ArrayList<>();
+
+ public InjectionTemplate(String templateName) {
+ this.templateName = templateName;
+
+ /**
+ * Read the class node, scanning all the method implementations
+ */
+ ClassNode cnode = getClassNode(templateName);
+
+ for (MethodNode method : cnode.methods) {
+ methodImplementations.add(method);
+ method.desc = new ObfMapping(cnode.name, method.name, method.desc).toRuntime().s_desc;
+ }
+ }
+
+ /**
+ * Patches the cnode withPriority the methods from this template.
+ * @param cnode
+ * @return
+ */
+ public boolean inject(ClassNode cnode) {
+
+ /**
+ * Inject the interface
+ */
+ String interfaceByteName = templateName.replace(".", "/");
+
+ if (!cnode.interfaces.contains(interfaceByteName)) {
+ cnode.interfaces.add(interfaceByteName);
+ }
+
+ boolean changed = false;
+
+ List names = new LinkedList<>();
+
+ for (MethodNode method : cnode.methods) {
+ ObfMapping m = new ObfMapping(cnode.name, method.name, method.desc).toRuntime();
+ names.add(m.s_name + m.s_desc);
+ }
+
+ for (MethodNode impl : this.methodImplementations) {
+ //Ignore the constructor
+ if (!impl.name.equals("")) {
+
+ //If the method is ALREADY implemented, then skip it.
+ if (names.contains(impl.name + impl.desc)) {
+ continue;
+ }
+
+ ObfMapping mapping = new ObfMapping(cnode.name, impl.name, impl.desc).toRuntime();
+ MethodNode copy = new MethodNode(impl.access, mapping.s_name, mapping.s_desc, impl.signature,
+ impl.exceptions == null ? null : impl.exceptions.toArray(new String[impl.exceptions.size()]));
+ ASMHelper.copy(impl, copy);
+ cnode.methods.add(impl);
+ changed = true;
+ }
+ }
+
+ return changed;
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/package-info.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/package-info.java
new file mode 100644
index 000000000..136f2221c
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/lib/package-info.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+/**
+ * ASM classes are used to help withPriority class transformations and bytecode injection.
+ * The ASM library is based on ChickenBone's ASM library.
+ * @author Calclavia
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.asm.lib;
\ No newline at end of file
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/transformers/ChunkTransformer.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/transformers/ChunkTransformer.java
new file mode 100644
index 000000000..e7ed4dda9
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/transformers/ChunkTransformer.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.asm.transformers;
+
+import nova.core.wrapper.mc.forge.v1_11.asm.lib.ASMHelper;
+import nova.core.wrapper.mc.forge.v1_11.asm.lib.ObfMapping;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.InsnList;
+import org.objectweb.asm.tree.LabelNode;
+import org.objectweb.asm.tree.LineNumberNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
+import org.objectweb.asm.tree.VarInsnNode;
+
+public class ChunkTransformer implements Transformer {
+
+ @Override
+ public void transform(ClassNode cnode) {
+ System.out.println("[NOVA] Transforming Chunk class for chunkModified event.");
+
+ //obf name: func_177436_a
+ MethodNode method = ASMHelper.findMethod(new ObfMapping("net/minecraft/world/chunk/Chunk", "setBlockState", "(Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/block/state/IBlockState;)Lnet/minecraft/block/state/IBlockState;"), cnode);
+
+ System.out.println("[NOVA] Found method " + method.name);
+
+ InsnList list = new InsnList();
+ list.add(new VarInsnNode(ALOAD, 0)); //this
+ list.add(new VarInsnNode(ALOAD, 1)); //BlockPos
+ list.add(new VarInsnNode(ALOAD, 8)); //oldBlock IBlockState
+ list.add(new VarInsnNode(ALOAD, 2)); //newBlock IBlockState
+ list.add(new MethodInsnNode(INVOKESTATIC, "nova/core/wrapper/mc/forge/v1_11/asm/StaticForwarder", "chunkSetBlockEvent", "(Lnet/minecraft/world/chunk/Chunk;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/block/state/IBlockState;Lnet/minecraft/block/state/IBlockState;)V", false));
+
+ AbstractInsnNode lastInsn = method.instructions.getLast();
+ while (lastInsn instanceof LabelNode || lastInsn instanceof LineNumberNode) {
+ lastInsn = lastInsn.getPrevious();
+ }
+
+ if (ASMHelper.isReturn(lastInsn)) {
+ method.instructions.insertBefore(lastInsn, list);
+ } else {
+ method.instructions.insert(list);
+ }
+
+ System.out.println("[NOVA] Injected instruction to method: " + method.name);
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/transformers/TileEntityTransformer.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/transformers/TileEntityTransformer.java
new file mode 100644
index 000000000..db682a886
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/transformers/TileEntityTransformer.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.asm.transformers;
+
+import nova.core.wrapper.mc.forge.v1_11.asm.lib.ASMHelper;
+import nova.core.wrapper.mc.forge.v1_11.asm.lib.InstructionComparator;
+import nova.core.wrapper.mc.forge.v1_11.asm.lib.ObfMapping;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.InsnList;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
+import org.objectweb.asm.tree.VarInsnNode;
+
+public class TileEntityTransformer implements Transformer {
+
+ @Override
+ public void transform(ClassNode cnode) {
+
+ System.out.println("[NOVA] Transforming TileEntity class for dynamic instance injection.");
+
+ ObfMapping obfMap = new ObfMapping("aqk", "a", "(Laid;Ldr;)Laqk;");
+ ObfMapping deobfMap = new ObfMapping("net/minecraft/tileentity/TileEntity", "create", "(Lnet/minecraft/world/World;Lnet/minecraft/nbt/NBTTagCompound;)Lnet/minecraft/tileentity/TileEntity;");
+
+ MethodNode method = ASMHelper.findMethod(obfMap, cnode);
+
+ if (method == null) {
+ System.out.println("[NOVA] Lookup " + obfMap + " failed. You are probably in a deobf environment.");
+ method = ASMHelper.findMethod(deobfMap, cnode);
+
+ if (method == null) {
+ System.out.println("[NOVA] Lookup " + deobfMap + " failed!");
+ }
+ }
+
+ System.out.println("[NOVA] Transforming method " + method.name);
+
+ ASMHelper.removeBlock(method.instructions, new InstructionComparator.InsnListSection(method.instructions, 31, 44));
+
+ InsnList list = new InsnList();
+ list.add(new VarInsnNode(ALOAD, 0)); // World
+ list.add(new VarInsnNode(ALOAD, 1)); // NBTTagCompound
+ list.add(new VarInsnNode(ALOAD, 4)); // Class
+ list.add(new MethodInsnNode(INVOKESTATIC, "nova/core/wrapper/mc/forge/v1_11/asm/StaticForwarder", "loadTileEntityHook", "(Lnet/minecraft/world/World;Lnet/minecraft/nbt/NBTTagCompound;Ljava/lang/Class;)Lnet/minecraft/tileentity/TileEntity;", false));
+ list.add(new VarInsnNode(ASTORE, 2)); // TileEntity
+
+ method.instructions.insert(method.instructions.get(31), list);
+
+ System.out.println("[NOVA] Injected instruction to method: " + method.name);
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/transformers/Transformer.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/transformers/Transformer.java
new file mode 100644
index 000000000..33fb0a284
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/transformers/Transformer.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.asm.transformers;
+
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.ClassNode;
+
+public interface Transformer extends Opcodes {
+
+ public void transform(ClassNode cnode);
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/transformers/Transformers.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/transformers/Transformers.java
new file mode 100644
index 000000000..6876bfc38
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/asm/transformers/Transformers.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.asm.transformers;
+
+import net.minecraft.launchwrapper.IClassTransformer;
+import nova.core.wrapper.mc.forge.v1_11.asm.lib.ASMHelper;
+import org.objectweb.asm.tree.ClassNode;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+public final class Transformers implements IClassTransformer {
+
+ private static Map> transformers = new HashMap<>();
+
+ public Transformers() {
+ registerTransformer(new ChunkTransformer(), "net.minecraft.world.chunk.Chunk");
+ //registerTransformer(new TileEntityTransformer(), "net.minecraft.tileentity.TileEntity");
+ }
+
+ public static void registerTransformer(Transformer transformer, String... classes) {
+ Objects.requireNonNull(classes);
+ for (String clazz : classes) {
+ List list = transformers.getOrDefault(clazz, new ArrayList<>());
+ list.add(transformer);
+ transformers.put(clazz, list);
+ }
+ }
+
+ @Override
+ public byte[] transform(String name, String transformedName, byte[] basicClass) {
+ if (transformers.containsKey(transformedName)) {
+ ClassNode cnode = ASMHelper.createClassNode(basicClass);
+ transformers.get(transformedName).forEach(t -> t.transform(cnode));
+ return ASMHelper.createBytes(cnode, 0);
+ }
+ return basicClass;
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/ClientModule.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/ClientModule.java
new file mode 100644
index 000000000..b87359207
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/ClientModule.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.depmodules;
+
+import nova.core.game.ClientManager;
+import nova.core.wrapper.mc.forge.v1_11.manager.FWClientManager;
+import se.jbee.inject.bind.BinderModule;
+
+public class ClientModule extends BinderModule {
+
+ @Override
+ protected void declare() {
+ bind(ClientManager.class).to(FWClientManager.class);
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/ComponentModule.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/ComponentModule.java
new file mode 100644
index 000000000..ac50e1676
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/ComponentModule.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.depmodules;
+
+import nova.core.entity.component.RigidBody;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.entity.forward.BWRigidBody;
+import se.jbee.inject.bind.BinderModule;
+
+/**
+ * @author Calclavia
+ */
+public class ComponentModule extends BinderModule {
+
+ @Override
+ protected void declare() {
+ bind(RigidBody.class).to(BWRigidBody.class);
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/GameInfoModule.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/GameInfoModule.java
new file mode 100644
index 000000000..b6790d0b1
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/GameInfoModule.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.depmodules;
+
+import nova.core.game.GameInfo;
+import se.jbee.inject.Dependency;
+import se.jbee.inject.Injector;
+import se.jbee.inject.Supplier;
+import se.jbee.inject.bind.BinderModule;
+
+public class GameInfoModule extends BinderModule {
+ private static final GameInfo minecraft = new GameInfo("minecraft", "1.11");
+
+ @Override
+ protected void declare() {
+ bind(GameInfo.class).toSupplier(GameInfoSupplier.class);
+ }
+
+ public static class GameInfoSupplier implements Supplier {
+ @Override
+ public GameInfo supply(Dependency dependency, Injector injector) {
+ return minecraft;
+ }
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/KeyModule.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/KeyModule.java
new file mode 100644
index 000000000..70fab59d6
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/KeyModule.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.depmodules;
+
+import nova.core.game.InputManager;
+import nova.core.wrapper.mc.forge.v1_11.util.MCInputManager;
+import se.jbee.inject.bind.BinderModule;
+
+public class KeyModule extends BinderModule {
+
+ @Override
+ protected void declare() {
+ bind(InputManager.class).to(MCInputManager.class);
+ }
+
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/LanguageModule.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/LanguageModule.java
new file mode 100644
index 000000000..af3f7a24a
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/LanguageModule.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.depmodules;
+
+import nova.core.util.registry.LanguageManager;
+import nova.core.wrapper.mc.forge.v1_11.util.MCLanguageManager;
+import se.jbee.inject.bind.BinderModule;
+
+public class LanguageModule extends BinderModule {
+
+ @Override
+ protected void declare() {
+ bind(LanguageManager.class).to(MCLanguageManager.class);
+ }
+
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/NetworkModule.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/NetworkModule.java
new file mode 100644
index 000000000..1682d0905
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/NetworkModule.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.depmodules;
+
+import nova.core.network.NetworkManager;
+import nova.core.wrapper.mc.forge.v1_11.network.netty.MCNetworkManager;
+import se.jbee.inject.bind.BinderModule;
+
+public class NetworkModule extends BinderModule {
+
+ @Override
+ protected void declare() {
+ bind(NetworkManager.class).to(MCNetworkManager.class);
+ }
+
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/RenderModule.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/RenderModule.java
new file mode 100644
index 000000000..1aec0cd07
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/RenderModule.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.depmodules;
+
+import nova.core.render.RenderManager;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.render.backward.BWClientRenderManager;
+import se.jbee.inject.bind.BinderModule;
+
+public class RenderModule extends BinderModule {
+
+ @Override
+ protected void declare() {
+ bind(RenderManager.class).to(BWClientRenderManager.class);
+ }
+
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/SaveModule.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/SaveModule.java
new file mode 100644
index 000000000..339d28ede
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/SaveModule.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.depmodules;
+
+import nova.core.util.registry.RetentionManager;
+import nova.core.wrapper.mc.forge.v1_11.manager.MCRetentionManager;
+import se.jbee.inject.bind.BinderModule;
+
+public class SaveModule extends BinderModule {
+
+ @Override
+ protected void declare() {
+ bind(RetentionManager.class).to(MCRetentionManager.class);
+ }
+
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/TickerModule.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/TickerModule.java
new file mode 100644
index 000000000..54be1bf1a
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/depmodules/TickerModule.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.depmodules;
+
+import nova.internal.core.tick.UpdateTicker;
+import se.jbee.inject.Dependency;
+import se.jbee.inject.Injector;
+import se.jbee.inject.Supplier;
+import se.jbee.inject.bind.BinderModule;
+import se.jbee.inject.util.Scoped;
+
+/**
+ * @author Calclavia
+ */
+public class TickerModule extends BinderModule {
+ public static final UpdateTicker.SynchronizedTicker synchronizedTicker = new UpdateTicker.SynchronizedTicker();
+ public static final UpdateTicker.ThreadTicker threadTicker = new UpdateTicker.ThreadTicker();
+ public static UpdateTicker.TickingThread tickingThread;
+
+ public TickerModule() {
+ super(Scoped.DEPENDENCY_TYPE);
+ }
+
+ @Override
+ protected void declare() {
+ bind(UpdateTicker.SynchronizedTicker.class).toSupplier(SynchronizedTickerSupplier.class);
+ bind(UpdateTicker.ThreadTicker.class).toSupplier(ThreadTickerSupplier.class);
+
+ /**
+ * Initiated threaded ticker
+ */
+ tickingThread = new UpdateTicker.TickingThread(threadTicker, 20);
+ tickingThread.start();
+ }
+
+ public static class SynchronizedTickerSupplier implements Supplier {
+ @Override
+ public UpdateTicker.SynchronizedTicker supply(Dependency dependency, Injector injector) {
+ return synchronizedTicker;
+ }
+ }
+
+ public static class ThreadTickerSupplier implements Supplier {
+ @Override
+ public UpdateTicker.ThreadTicker supply(Dependency dependency, Injector injector) {
+ return threadTicker;
+ }
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/launcher/ClientProxy.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/launcher/ClientProxy.java
new file mode 100644
index 000000000..259cfcabd
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/launcher/ClientProxy.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.launcher;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.particle.Particle;
+import net.minecraft.client.renderer.block.model.ModelResourceLocation;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraftforge.client.model.ModelLoader;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.client.FMLClientHandler;
+import net.minecraftforge.fml.client.registry.ClientRegistry;
+import net.minecraftforge.fml.client.registry.RenderingRegistry;
+import nova.core.entity.Entity;
+import nova.core.entity.EntityFactory;
+import nova.core.wrapper.mc.forge.v1_11.render.RenderUtility;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.block.forward.FWBlock;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.block.forward.FWTile;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.block.forward.FWTileRenderer;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.particle.backward.BWParticle;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.entity.forward.FWEntity;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.particle.forward.FWParticle;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.entity.forward.FWEntityRenderer;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.item.forward.FWItem;
+import nova.internal.core.Game;
+import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
+
+/**
+ * @author Calclavia
+ */
+public class ClientProxy extends CommonProxy {
+ @Override
+ public void preInit() {
+ super.preInit();
+ MinecraftForge.EVENT_BUS.register(RenderUtility.instance);
+ ClientRegistry.bindTileEntitySpecialRenderer(FWTile.class, FWTileRenderer.instance);
+ RenderUtility.instance.preInit();
+ }
+
+ @Override
+ public void init() {
+ super.init();
+ RenderingRegistry.registerEntityRenderingHandler(FWEntity.class, FWEntityRenderer.instance);
+ }
+
+ @Override
+ public void registerItem(FWItem item) {
+ super.registerItem(item);
+
+ //Hacks to inject custom item definition
+ ModelLoader.setCustomMeshDefinition(item, stack -> new ModelResourceLocation(Item.REGISTRY.getNameForObject(item), "inventory"));
+ }
+
+ @Override
+ public void postRegisterBlock(FWBlock block) {
+ super.postRegisterBlock(block);
+
+ //Hack to inject custom itemblock definition
+ Item itemFromBlock = Item.getItemFromBlock(block);
+
+ ModelLoader.setCustomMeshDefinition(itemFromBlock, stack -> new ModelResourceLocation(Item.REGISTRY.getNameForObject(itemFromBlock), "inventory"));
+ }
+
+ @Override
+ public boolean isPaused() {
+ if (FMLClientHandler.instance().getClient().isSingleplayer() && !FMLClientHandler.instance().getClient().getIntegratedServer().getPublic()) {
+ GuiScreen screen = FMLClientHandler.instance().getClient().currentScreen;
+ if (screen != null) {
+ if (screen.doesGuiPauseGame()) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public Entity spawnParticle(net.minecraft.world.World world, EntityFactory factory) {
+ //Backward entity particle unwrapper
+ Entity build = factory.build();
+ if (build instanceof BWParticle) {
+ Particle particle = ((BWParticle) build).createParticle(world);
+ FMLClientHandler.instance().getClient().effectRenderer.addEffect(particle);
+ return Game.natives().toNova(particle);
+ } else {
+ FWParticle bwEntityFX = new FWParticle(world, factory);
+ FMLClientHandler.instance().getClient().effectRenderer.addEffect(bwEntityFX);
+ return bwEntityFX.wrapped;
+ }
+ }
+
+ @Override
+ public Entity spawnParticle(net.minecraft.world.World world, Entity entity) {
+ //Backward entity particle unwrapper
+ if (entity instanceof BWParticle) {
+ Particle particle = ((BWParticle) entity).createParticle(world);
+ Vector3D position = entity.position();
+ particle.posX = position.getX();
+ particle.posY = position.getY();
+ particle.posZ = position.getZ();
+ FMLClientHandler.instance().getClient().effectRenderer.addEffect(particle);
+ return Game.natives().toNova(particle);
+ } else {
+ FWParticle bwEntityFX = new FWParticle(world, entity);
+ FMLClientHandler.instance().getClient().effectRenderer.addEffect(bwEntityFX);
+ return bwEntityFX.wrapped;
+ }
+ }
+
+ @Override
+ public EntityPlayer getClientPlayer() {
+ return Minecraft.getMinecraft().player;
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/launcher/CommonProxy.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/launcher/CommonProxy.java
new file mode 100644
index 000000000..ffd9fe85d
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/launcher/CommonProxy.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.launcher;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraftforge.fml.common.registry.EntityRegistry;
+import net.minecraftforge.fml.common.registry.GameRegistry;
+import nova.core.entity.Entity;
+import nova.core.entity.EntityFactory;
+import nova.core.loader.Loadable;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.block.forward.FWBlock;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.block.forward.FWTile;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.block.forward.FWTileUpdater;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.entity.forward.FWEntity;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.item.forward.FWItem;
+
+import java.util.Set;
+
+import net.minecraft.util.ResourceLocation;
+
+/**
+ * @author Calclavia
+ */
+public class CommonProxy implements Loadable {
+ @Override
+ public void preInit() {
+ GameRegistry.registerTileEntity(FWTile.class, "nova:novaTile");
+ GameRegistry.registerTileEntity(FWTileUpdater.class, "nova:novaTileUpdater");
+ EntityRegistry.registerModEntity(new ResourceLocation("nova", "novaEntity"), FWEntity.class, "novaEntity", 1, NovaMinecraft.instance, 64, 20, true);
+ }
+
+ public void registerResourcePacks(Set> modClasses) {
+
+ }
+
+ public void registerItem(FWItem item) {
+
+ }
+
+ public void postRegisterBlock(FWBlock block) {
+
+ }
+
+ public Entity spawnParticle(net.minecraft.world.World world, EntityFactory factory) {
+ return null;
+ }
+
+ public Entity spawnParticle(net.minecraft.world.World world, Entity entity) {
+ return null;
+ }
+
+ public boolean isPaused() {
+ return false;
+ }
+
+ public EntityPlayer getClientPlayer() {
+ return null;
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/launcher/FMLEventHandler.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/launcher/FMLEventHandler.java
new file mode 100644
index 000000000..1089c4c0e
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/launcher/FMLEventHandler.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.launcher;
+
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.common.gameevent.TickEvent;
+import nova.core.event.PlayerEvent;
+import nova.internal.core.Game;
+
+/**
+ * Handles FML events and forwards them to NOVA.
+ * @author Calclavia
+ */
+public class FMLEventHandler {
+ @SubscribeEvent
+ public void playerJoin(net.minecraftforge.fml.common.gameevent.PlayerEvent.PlayerLoggedInEvent evt) {
+ Game.events().publish(new PlayerEvent.Join(Game.natives().toNova(evt.player)));
+ }
+
+ @SubscribeEvent
+ public void playerLeave(net.minecraftforge.fml.common.gameevent.PlayerEvent.PlayerLoggedOutEvent evt) {
+ Game.events().publish(new PlayerEvent.Leave(Game.natives().toNova(evt.player)));
+ }
+
+ @SubscribeEvent
+ public void tickEnd(TickEvent.ServerTickEvent event) {
+ if (event.phase == TickEvent.Phase.END) {
+ Game.syncTicker().update();
+ }
+ }
+
+ @SubscribeEvent
+ public void tickEnd(TickEvent.ClientTickEvent event) {
+ if (event.phase == TickEvent.Phase.END) {
+ Game.syncTicker().update();
+ }
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/launcher/FMLProgressBar.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/launcher/FMLProgressBar.java
new file mode 100644
index 000000000..3f350a87a
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/launcher/FMLProgressBar.java
@@ -0,0 +1,34 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package nova.core.wrapper.mc.forge.v1_11.launcher;
+
+import net.minecraftforge.fml.common.ProgressManager.ProgressBar;
+
+/**
+ * Wrapper class for FML progress bar that is shown when Minecraft boots.
+ *
+ * @author ExE Boss
+ */
+public class FMLProgressBar extends nova.core.util.AbstractProgressBar {
+
+ private final ProgressBar progressBar;
+
+ public FMLProgressBar(ProgressBar progressBar) {
+ this.progressBar = progressBar;
+ }
+
+ @Override
+ public void stepImpl(String s) {
+ if (this.progressBar.getStep() >= this.progressBar.getSteps()) return;
+ this.progressBar.step(s);
+ }
+
+ @Override
+ protected void finishImpl() {
+ while (progressBar.getStep() < progressBar.getSteps())
+ progressBar.step("");
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/launcher/ForgeEventHandler.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/launcher/ForgeEventHandler.java
new file mode 100644
index 000000000..54e808c09
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/launcher/ForgeEventHandler.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.launcher;
+
+import net.minecraftforge.event.entity.player.PlayerInteractEvent;
+import net.minecraftforge.event.entity.player.PlayerInteractEvent.RightClickBlock;
+import net.minecraftforge.event.entity.player.PlayerInteractEvent.LeftClickBlock;
+import net.minecraftforge.event.world.WorldEvent;
+import net.minecraftforge.fml.common.eventhandler.Event;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.oredict.OreDictionary;
+import nova.core.item.Item;
+import nova.core.item.ItemDictionary;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.item.ItemConverter;
+import nova.internal.core.Game;
+import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
+
+/**
+ * @author Stan, Calclavia
+ */
+public class ForgeEventHandler {
+
+ @SubscribeEvent
+ public void worldUnload(WorldEvent.Load evt) {
+ Game.events().publish(new nova.core.event.WorldEvent.Load(Game.natives().toNova(evt.getWorld())));
+ }
+
+ @SubscribeEvent
+ public void worldLoad(WorldEvent.Unload evt) {
+ Game.events().publish(new nova.core.event.WorldEvent.Unload(Game.natives().toNova(evt.getWorld())));
+ }
+
+ @SubscribeEvent
+ public void onOreRegister(OreDictionary.OreRegisterEvent event) {
+ ItemDictionary novaItemDictionary = Game.itemDictionary();
+
+ Item item = ItemConverter.instance().getNovaItem(event.getOre());
+ if (!novaItemDictionary.get(event.getName()).contains(item)) {
+ novaItemDictionary.add(event.getName(), item);
+ }
+ }
+
+ @SubscribeEvent
+ public void playerInteractEvent(PlayerInteractEvent event) {
+ if (event.getWorld() != null && event.getPos() != null) {
+ nova.core.event.PlayerEvent.Interact evt = new nova.core.event.PlayerEvent.Interact(
+ Game.natives().toNova(event.getWorld()),
+ new Vector3D(event.getPos().getX(), event.getPos().getY(), event.getPos().getZ()),
+ Game.natives().toNova(event.getEntityPlayer()),
+ nova.core.event.PlayerEvent.Interact.Action.values()[toNovaInteractOrdinal(event)]
+ );
+
+ Game.events().publish(evt);
+
+ if (event instanceof RightClickBlock) {
+ ((RightClickBlock)event).setUseBlock(Event.Result.values()[evt.useBlock.ordinal()]);
+ ((RightClickBlock)event).setUseItem(Event.Result.values()[evt.useItem.ordinal()]);
+ } else if (event instanceof LeftClickBlock) {
+ ((LeftClickBlock)event).setUseBlock(Event.Result.values()[evt.useBlock.ordinal()]);
+ ((LeftClickBlock)event).setUseItem(Event.Result.values()[evt.useItem.ordinal()]);
+ }
+ if (event.isCancelable()) event.setCanceled(evt.isCanceled());
+ }
+ }
+
+ private static int toNovaInteractOrdinal(PlayerInteractEvent event) {
+ if (event instanceof RightClickBlock) return 1;
+ else if (event instanceof LeftClickBlock) return 2;
+ else return 0;
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/launcher/NovaMinecraft.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/launcher/NovaMinecraft.java
new file mode 100644
index 000000000..958fc60a7
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/launcher/NovaMinecraft.java
@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.launcher;
+
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.common.FMLCommonHandler;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.Mod.Metadata;
+import net.minecraftforge.fml.common.ModMetadata;
+import net.minecraftforge.fml.common.ProgressManager;
+import net.minecraftforge.fml.common.ProgressManager.ProgressBar;
+import net.minecraftforge.fml.common.SidedProxy;
+import net.minecraftforge.fml.common.event.FMLInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLServerStartingEvent;
+import net.minecraftforge.fml.common.event.FMLServerStoppingEvent;
+import net.minecraftforge.fml.relauncher.FMLInjectionData;
+import nova.core.deps.MavenDependency;
+import nova.core.event.ServerEvent;
+import nova.core.loader.Loadable;
+import nova.core.wrapper.mc.forge.v1_11.NovaMinecraftPreloader;
+import nova.core.wrapper.mc.forge.v1_11.depmodules.ClientModule;
+import nova.core.wrapper.mc.forge.v1_11.depmodules.ComponentModule;
+import nova.core.wrapper.mc.forge.v1_11.depmodules.GameInfoModule;
+import nova.core.wrapper.mc.forge.v1_11.depmodules.KeyModule;
+import nova.core.wrapper.mc.forge.v1_11.depmodules.LanguageModule;
+import nova.core.wrapper.mc.forge.v1_11.depmodules.NetworkModule;
+import nova.core.wrapper.mc.forge.v1_11.depmodules.RenderModule;
+import nova.core.wrapper.mc.forge.v1_11.depmodules.SaveModule;
+import nova.core.wrapper.mc.forge.v1_11.depmodules.TickerModule;
+import nova.core.wrapper.mc.forge.v1_11.recipes.MinecraftRecipeRegistry;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.DirectionConverter;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.VectorConverter;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.block.BlockConverter;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.block.world.WorldConverter;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.cuboid.CuboidConverter;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.data.DataWrapper;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.entity.EntityConverter;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.inventory.InventoryConverter;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.item.ItemConverter;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.item.OreDictionaryIntegration;
+import nova.internal.core.Game;
+import nova.internal.core.bootstrap.DependencyInjectionEntryPoint;
+import nova.internal.core.deps.DepDownloader;
+import nova.internal.core.launch.InitializationException;
+import nova.internal.core.launch.NovaLauncher;
+
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * The main Nova Minecraft Wrapper loader, using Minecraft Forge.
+ * @author Calclavia
+ */
+@Mod(modid = NovaMinecraft.id, name = NovaMinecraft.name, version = NovaMinecraftPreloader.version, acceptableRemoteVersions = "*")
+public class NovaMinecraft {
+
+ public static final String id = "nova";
+ public static final String name = "NOVA";
+ public static final String mcId = "minecraft";
+
+ @SidedProxy(clientSide = "nova.core.wrapper.mc.forge.v1_11.launcher.ClientProxy", serverSide = "nova.core.wrapper.mc.forge.v1_11.launcher.CommonProxy")
+ public static CommonProxy proxy;
+ @Mod.Instance(id)
+ public static NovaMinecraft instance;
+ private static NovaLauncher launcher;
+ @Metadata(id)
+ private static ModMetadata modMetadata;
+
+ private static Set nativeConverters;
+
+ /**
+ * ORDER OF LOADING.
+ *
+ * 1. Native Loaders 2. Native Converters 3. Mods
+ */
+ @Mod.EventHandler
+ public void preInit(FMLPreInitializationEvent evt) {
+ try {
+ /**
+ * Search through all classes withPriority @NovaMod
+ */
+ DependencyInjectionEntryPoint diep = new DependencyInjectionEntryPoint();
+ diep.install(NetworkModule.class);
+ diep.install(SaveModule.class);
+ diep.install(TickerModule.class);
+ diep.install(LanguageModule.class);
+ diep.install(KeyModule.class);
+ diep.install(ClientModule.class);
+ diep.install(GameInfoModule.class);
+ diep.install(RenderModule.class);
+ diep.install(ComponentModule.class);
+
+ Set> modClasses = NovaMinecraftPreloader.modClasses;
+
+ proxy.registerResourcePacks(modClasses);
+ launcher = new NovaLauncher(diep, modClasses);
+
+ Game.inject(diep);
+
+ /**
+ * Register native converters
+ */
+ Game.natives().registerConverter(new DataWrapper());
+ Game.natives().registerConverter(new EntityConverter());
+ Game.natives().registerConverter(new BlockConverter());
+ Game.natives().registerConverter(new ItemConverter());
+ Game.natives().registerConverter(new WorldConverter());
+ Game.natives().registerConverter(new CuboidConverter());
+ Game.natives().registerConverter(new InventoryConverter());
+ Game.natives().registerConverter(new VectorConverter());
+ Game.natives().registerConverter(new DirectionConverter());
+
+ /**
+ * Initiate recipe and ore dictionary integration
+ */
+ OreDictionaryIntegration.instance.registerOreDictionary();
+ MinecraftRecipeRegistry.instance.registerRecipes();
+
+ /**
+ * Download dependencies
+ */
+ launcher.generateDependencies();
+
+ try {
+ for (List dependencies : launcher.getNeededDeps().values()) {
+ for (MavenDependency dep : dependencies) {
+ DepDownloader.downloadDepdency(dep.getDownloadURL(), FMLInjectionData.data()[6] + "/mods/" + dep.getPath());
+ }
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ ProgressBar progressBar = ProgressManager.push("Loading NOVA mods", modClasses.size(), true);
+ launcher.load(new FMLProgressBar(progressBar));
+ ProgressManager.pop(progressBar);
+
+ /**
+ * Instantiate native loaders
+ */
+ nativeConverters = Game.natives().getNativeConverters().stream().filter(n -> n instanceof Loadable).map(n -> (Loadable) n).collect(Collectors.toSet());
+ nativeConverters.stream().forEachOrdered(Loadable::preInit);
+
+ Game.blocks().init();
+ Game.items().init();
+ Game.entities().init();
+ Game.render().init();
+ Game.language().init();
+
+ //Load preInit
+ progressBar = ProgressManager.push("Pre-initializing NOVA mods", modClasses.size(), true);
+ launcher.preInit(new FMLProgressBar(progressBar));
+ while (progressBar.getStep() < progressBar.getSteps())
+ progressBar.step("null");
+ ProgressManager.pop(progressBar);
+
+ // Initiate config system TODO: Storables
+ // launcher.getLoadedModMap().forEach((mod, loader) -> {
+ // Configuration config = new Configuration(new File(evt.getModConfigurationDirectory(), mod.name()));
+ // ConfigManager.instance.sync(config, loader.getClass().getPackage().getName());
+ // });
+
+ proxy.preInit();
+
+ /**
+ * Register event handlers
+ */
+ MinecraftForge.EVENT_BUS.register(new ForgeEventHandler());
+ FMLCommonHandler.instance().bus().register(new FMLEventHandler());
+ MinecraftForge.EVENT_BUS.register(Game.retention());
+ } catch (Exception e) {
+ System.out.println("Error during preInit");
+ e.printStackTrace();
+ throw new InitializationException(e);
+ }
+ }
+
+ @Mod.EventHandler
+ public void init(FMLInitializationEvent evt) {
+ try {
+ ProgressBar progressBar = ProgressManager.push("Initializing NOVA mods", NovaMinecraftPreloader.modClasses.size(), true);
+ proxy.init();
+ nativeConverters.stream().forEachOrdered(Loadable::init);
+ launcher.init(new FMLProgressBar(progressBar));
+ ProgressManager.pop(progressBar);
+ } catch (Exception e) {
+ System.out.println("Error during init");
+ e.printStackTrace();
+ throw new InitializationException(e);
+ }
+ }
+
+ @Mod.EventHandler
+ public void postInit(FMLPostInitializationEvent evt) {
+ try {
+ ProgressBar progressBar = ProgressManager.push("Post-initializing NOVA mods", NovaMinecraftPreloader.modClasses.size(), true);
+ Game.recipes().init();
+ proxy.postInit();
+ nativeConverters.stream().forEachOrdered(Loadable::postInit);
+ launcher.postInit(new FMLProgressBar(progressBar));
+ ProgressManager.pop(progressBar);
+ } catch (Exception e) {
+ System.out.println("Error during postInit");
+ e.printStackTrace();
+ throw new InitializationException(e);
+ }
+ }
+
+ @Mod.EventHandler
+ public void serverStarting(FMLServerStartingEvent event) {
+ Game.events().publish(new ServerEvent.Start());
+ }
+
+ @Mod.EventHandler
+ public void serverStopping(FMLServerStoppingEvent event) {
+ Game.events().publish(new ServerEvent.Stop());
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/manager/FWClientManager.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/manager/FWClientManager.java
new file mode 100644
index 000000000..f4487085d
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/manager/FWClientManager.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.manager;
+
+import net.minecraft.client.Minecraft;
+import nova.core.entity.Entity;
+import nova.core.game.ClientManager;
+import nova.core.wrapper.mc.forge.v1_11.launcher.NovaMinecraft;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.entity.backward.BWEntity;
+
+/**
+ * @author Calclavia
+ */
+public class FWClientManager extends ClientManager {
+
+ @Override
+ public Entity getPlayer() {
+ return new BWEntity(NovaMinecraft.proxy.getClientPlayer());
+ }
+
+ @Override
+ public boolean isPaused() {
+ return Minecraft.getMinecraft().isGamePaused();
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/manager/MCRetentionManager.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/manager/MCRetentionManager.java
new file mode 100644
index 000000000..81d21cc3b
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/manager/MCRetentionManager.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.manager;
+
+import net.minecraft.nbt.CompressedStreamTools;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.server.MinecraftServer;
+import net.minecraftforge.event.world.WorldEvent;
+import net.minecraftforge.fml.client.FMLClientHandler;
+import net.minecraftforge.fml.common.FMLCommonHandler;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import nova.core.retention.Data;
+import nova.core.retention.Storable;
+import nova.core.util.registry.RetentionManager;
+import nova.internal.core.Game;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import net.minecraftforge.fml.server.FMLServerHandler;
+
+/**
+ * A manager that handles external file saving.
+ * @author Calclavia
+ */
+public class MCRetentionManager extends RetentionManager {
+
+ /**
+ * Last time that the queueSave manager tried to queueSave a file
+ */
+ private long lastSaveMills = 0;
+
+ /**
+ * Save all storable queued
+ */
+ public void saveAll() {
+ saveQueue.forEach(this::save);
+ saveQueue.clear();
+ }
+
+ @Override
+ public void save(String filename, Storable storable) {
+ Data saveMap = new Data();
+ storable.save(saveMap);
+ saveFile(filename, Game.natives().toNative(saveMap));
+ }
+
+ @Override
+ public void load(String filename, Storable storable) {
+ NBTTagCompound nbt = loadFile(filename);
+ storable.load(Game.natives().toNova(nbt));
+ }
+
+ /**
+ * Saves NBT data in the world folder.
+ * @param file File to save data to
+ * @param data Data to save
+ * @return True on success.
+ */
+ public boolean saveFile(File file, NBTTagCompound data) {
+ try {
+ File tempFile = new File(file.getParent(), file.getName() + "_tmp.dat");
+
+ CompressedStreamTools.writeCompressed(data, new FileOutputStream(tempFile));
+
+ if (file.exists()) {
+ file.delete();
+ }
+
+ tempFile.renameTo(file);
+ return true;
+ } catch (Exception e) {
+ System.out.println("Failed to queueSave " + file.getName() + ".dat!");
+ e.printStackTrace();
+ return false;
+ }
+ }
+
+ public boolean saveFile(File saveDirectory, String filename, NBTTagCompound data) {
+ return saveFile(new File(saveDirectory, filename + ".dat"), data);
+ }
+
+ public boolean saveFile(String filename, NBTTagCompound data) {
+ return saveFile(getSaveDirectory(FMLServerHandler.instance().getServer().getFolderName()), filename, data);
+ }
+
+ public NBTTagCompound loadFile(File file) {
+ try {
+ if (file.exists()) {
+ return CompressedStreamTools.readCompressed(new FileInputStream(file));
+ } else {
+ return new NBTTagCompound();
+ }
+ } catch (Exception e) {
+ System.out.println("Failed to load " + file.getName() + ".dat!");
+ e.printStackTrace();
+ return null;
+ }
+ }
+
+ /**
+ * Reads NBT data from the world folder.
+ * @param saveDirectory Directory in which the file resides
+ * @param filename Name of the file
+ * @return The NBT data
+ */
+ public NBTTagCompound loadFile(File saveDirectory, String filename) {
+ return loadFile(new File(saveDirectory, filename + ".dat"));
+ }
+
+ public NBTTagCompound loadFile(String filename) {
+ return loadFile(getSaveDirectory(FMLServerHandler.instance().getServer().getFolderName()), filename);
+ }
+
+ @Override
+ public File getSaveDirectory() {
+ return getSaveDirectory(FMLServerHandler.instance().getServer().getFolderName());
+ }
+
+ public File getSaveDirectory(String worldName) {
+ File parent = getBaseDirectory();
+
+ if (FMLCommonHandler.instance().getSide().isClient()) {
+ parent = new File(getBaseDirectory(), "saves" + File.separator);
+ }
+
+ return new File(parent, worldName + File.separator);
+ }
+
+ public File getBaseDirectory() {
+ if (FMLCommonHandler.instance().getSide().isClient()) {
+ FMLClientHandler.instance().getClient();
+ return FMLClientHandler.instance().getClient().mcDataDir;
+ } else {
+ return new File(".");
+ }
+ }
+
+ @SubscribeEvent
+ public void worldSave(WorldEvent evt) {
+ //Current time milli-seconds is used to prevent the files from saving 20 times when the world loads
+ if (System.currentTimeMillis() - lastSaveMills > 2000) {
+ lastSaveMills = System.currentTimeMillis();
+ saveAll();
+ }
+ }
+
+ @Override
+ public void init() {
+
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/manager/config/NovaGuiConfig.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/manager/config/NovaGuiConfig.java
new file mode 100644
index 000000000..c045c7b35
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/manager/config/NovaGuiConfig.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.manager.config;
+
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraftforge.common.config.ConfigElement;
+import net.minecraftforge.common.config.Configuration;
+import net.minecraftforge.fml.client.config.GuiConfig;
+
+/**
+ * @author Calclavia
+ */
+public class NovaGuiConfig extends GuiConfig {
+ public NovaGuiConfig(GuiScreen parentScreen, Configuration config, String modID) {
+ super(parentScreen, new ConfigElement(config.getCategory(Configuration.CATEGORY_GENERAL)).getChildElements(), modID, false, false, GuiConfig.getAbridgedConfigPath(config.toString()));
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/manager/config/NovaGuiFactory.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/manager/config/NovaGuiFactory.java
new file mode 100644
index 000000000..2d7cd5345
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/manager/config/NovaGuiFactory.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.manager.config;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraftforge.fml.client.IModGuiFactory;
+
+import java.util.Set;
+
+/**
+ * @author Calclavia
+ */
+public class NovaGuiFactory implements IModGuiFactory {
+ @Override
+ public void initialize(Minecraft minecraftInstance) {
+
+ }
+
+ @Override
+ public Class mainConfigGuiClass() {
+ return NovaGuiConfig.class;
+ }
+
+ @Override
+ public Set runtimeGuiCategories() {
+ return null;
+ }
+
+ @Override
+ public RuntimeOptionGuiHandler getHandlerFor(RuntimeOptionCategoryElement element) {
+ return null;
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/network/MCPacket.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/network/MCPacket.java
new file mode 100644
index 000000000..2da87aa23
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/network/MCPacket.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.network;
+
+import io.netty.buffer.ByteBuf;
+import net.minecraftforge.fml.common.network.ByteBufUtils;
+import nova.core.entity.component.Player;
+import nova.core.network.Packet;
+
+/**
+ * Wraps ByteBuf into a NOVA Packet.
+ * @author Calclavia
+ */
+public class MCPacket implements Packet {
+
+ public final ByteBuf buf;
+ public final Player player;
+ private int id = 0;
+
+ public MCPacket(ByteBuf buf) {
+ this.buf = buf;
+ player = null;
+ }
+
+ public MCPacket(ByteBuf buf, Player player) {
+ this.buf = buf;
+ this.player = player;
+ }
+
+ @Override
+ public Player player() {
+ if (player == null) {
+ throw new RuntimeException("Attempt to get player in packet when it does not exist!");
+ }
+
+ return player;
+ }
+
+ @Override
+ public int getID() {
+ return id;
+ }
+
+ @Override
+ public Packet setID(int id) {
+ this.id = id;
+ return this;
+ }
+
+ @Override
+ public Packet writeBoolean(boolean value) {
+ buf.writeBoolean(value);
+ return this;
+ }
+
+ @Override
+ public Packet writeByte(int value) {
+ buf.writeByte(value);
+ return this;
+ }
+
+ @Override
+ public Packet writeShort(int value) {
+ buf.writeShort(value);
+ return this;
+ }
+
+ @Override
+ public Packet writeInt(int value) {
+ buf.writeInt(value);
+ return this;
+ }
+
+ @Override
+ public Packet writeLong(long value) {
+ buf.writeLong(value);
+ return this;
+ }
+
+ @Override
+ public Packet writeChar(int value) {
+ buf.writeChar(value);
+ return this;
+ }
+
+ @Override
+ public Packet writeFloat(float value) {
+ buf.writeFloat(value);
+ return this;
+ }
+
+ @Override
+ public Packet writeDouble(double value) {
+ buf.writeDouble(value);
+ return this;
+ }
+
+ @Override
+ public Packet writeString(String value) {
+ ByteBufUtils.writeUTF8String(buf, value);
+ return this;
+ }
+
+ @Override
+ public Packet writeBytes(byte[] array) {
+ buf.writeBytes(array);
+ return this;
+ }
+
+ @Override
+ public byte[] readBytes(int length) {
+ byte[] array = new byte[length];
+ for (int i = 0; i < length; i++)
+ array[i] = buf.readByte();
+ return array;
+ }
+
+ @Override
+ public boolean readBoolean() {
+ return buf.readBoolean();
+ }
+
+ @Override
+ public byte readByte() {
+ return buf.readByte();
+ }
+
+ @Override
+ public short readUnsignedByte() {
+ return buf.readUnsignedByte();
+ }
+
+ @Override
+ public short readShort() {
+ return buf.readShort();
+ }
+
+ @Override
+ public int readInt() {
+ return buf.readInt();
+ }
+
+ @Override
+ public long readUnsignedInt() {
+ return buf.readUnsignedInt();
+ }
+
+ @Override
+ public long readLong() {
+ return buf.readLong();
+ }
+
+ @Override
+ public char readChar() {
+ return buf.readChar();
+ }
+
+ @Override
+ public float readFloat() {
+ return buf.readFloat();
+ }
+
+ @Override
+ public double readDouble() {
+ return buf.readDouble();
+ }
+
+ @Override
+ public String readString() {
+ return ByteBufUtils.readUTF8String(buf);
+ }
+
+ public void writeTo(ByteBuf other) {
+ other.writeBytes(buf);
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/network/discriminator/NovaPacket.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/network/discriminator/NovaPacket.java
new file mode 100644
index 000000000..61b04541d
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/network/discriminator/NovaPacket.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.network.discriminator;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import net.minecraft.entity.player.EntityPlayer;
+import nova.core.entity.Entity;
+import nova.core.entity.component.Player;
+import nova.core.network.handler.PacketHandler;
+import nova.core.wrapper.mc.forge.v1_11.network.MCPacket;
+import nova.core.wrapper.mc.forge.v1_11.network.netty.MCNetworkManager;
+import nova.internal.core.Game;
+
+/**
+ * NOVA Packet Structure:
+ *
+ * 1. Packet Type ID
+ * 2. Packet Sub ID
+ * 3. Data
+ * @author Calclavia
+ */
+public class NovaPacket extends PacketAbstract {
+
+ @Override
+ public void encodeInto(ChannelHandlerContext ctx, ByteBuf buffer) {
+ buffer.writeBytes(data);
+ }
+
+ @Override
+ public void decodeInto(ChannelHandlerContext ctx, ByteBuf buffer) {
+ data = buffer.slice();
+ }
+
+ @Override
+ public void handleClientSide(EntityPlayer player) {
+ handle(player);
+ }
+
+ @Override
+ public void handleServerSide(EntityPlayer player) {
+ handle(player);
+ }
+
+ public void handle(EntityPlayer player) {
+ try {
+ MCNetworkManager network = (MCNetworkManager) Game.network();
+ PacketHandler packetHandler = network.getPacketType(data.readInt());
+ int subId = data.readInt();
+ MCPacket packet = new MCPacket(data.slice(), ((Entity) Game.natives().toNova(player)).components.get(Player.class));
+ //Set the ID of the packet
+ packet.setID(subId);
+ packetHandler.read(packet);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/network/discriminator/PacketAbstract.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/network/discriminator/PacketAbstract.java
new file mode 100644
index 000000000..3a866fc07
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/network/discriminator/PacketAbstract.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.network.discriminator;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.ChannelHandlerContext;
+import net.minecraft.entity.player.EntityPlayer;
+import nova.core.wrapper.mc.forge.v1_11.network.netty.MCNetworkManager;
+
+/**
+ * For custom packets extend this Class and register on Mod loading phase
+ *
+ * Without registering a NPE will be thrown as the {@link MCNetworkManager} won't know how to handle it
+ *
+ * To send this packet also look at {@link MCNetworkManager#sendToAll(PacketAbstract)}
+ * And other implementations there.
+ * @author tgame14, Calclavia
+ * @since 26/05/14
+ */
+public abstract class PacketAbstract {
+ public ByteBuf data = Unpooled.buffer();
+ EntityPlayer sender = null;
+
+ /**
+ * Encode the packet data into the ByteBuf stream. Complex data sets may need specific data handlers
+ * @param ctx channel context
+ * @param buffer the buffer to encode into
+ * @see net.minecraftforge.fml.common.network.ByteBufUtils
+ */
+ public abstract void encodeInto(ChannelHandlerContext ctx, ByteBuf buffer);
+
+ /**
+ * Decode the packet data from the ByteBuf stream. Complex data sets may need specific data handlers
+ * @param ctx channel context
+ * @param buffer the buffer to decode from
+ * @see net.minecraftforge.fml.common.network.ByteBufUtils
+ */
+ public abstract void decodeInto(ChannelHandlerContext ctx, ByteBuf buffer);
+
+ /**
+ * Handle a packet on the client side. Note this occurs after decoding has completed.
+ * @param player the player reference
+ */
+ public void handleClientSide(EntityPlayer player) {
+ throw new UnsupportedOperationException("Unsupported operation for Packet: " + getClass().getSimpleName());
+ }
+
+ /**
+ * Handle a packet on the server side. Note this occurs after decoding has completed.
+ * @param player the player reference
+ */
+ public void handleServerSide(EntityPlayer player) {
+ throw new UnsupportedOperationException("Unsupported operation for Packet: " + getClass().getSimpleName());
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/network/discriminator/PacketPlayerItem.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/network/discriminator/PacketPlayerItem.java
new file mode 100644
index 000000000..3d4f75858
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/network/discriminator/PacketPlayerItem.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.network.discriminator;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import nova.core.network.Syncable;
+import nova.core.wrapper.mc.forge.v1_11.network.MCPacket;
+
+/**
+ * A packet handler for players who are currently holding their item.
+ * @author Calclavia
+ */
+//TODO: Move to NOVA Core
+public class PacketPlayerItem extends PacketAbstract {
+ public int slotId;
+
+ public PacketPlayerItem() {
+
+ }
+
+ public PacketPlayerItem(int slotId) {
+ this.slotId = slotId;
+ }
+
+ public PacketPlayerItem(EntityPlayer player) {
+ this(player.inventory.currentItem);
+ }
+
+ @Override
+ public void encodeInto(ChannelHandlerContext ctx, ByteBuf buffer) {
+ buffer.writeInt(slotId);
+ buffer.writeBytes(data);
+ }
+
+ @Override
+ public void decodeInto(ChannelHandlerContext ctx, ByteBuf buffer) {
+ slotId = buffer.readInt();
+ data = buffer.slice();
+ }
+
+ @Override
+ public void handleClientSide(EntityPlayer player) {
+ ItemStack stack = player.inventory.getStackInSlot(this.slotId);
+
+ if (stack != null && stack.getItem() instanceof Syncable) {
+ MCPacket mcPacket = new MCPacket(data);
+ mcPacket.setID(data.readInt());
+ ((Syncable) stack.getItem()).read(mcPacket);
+ }
+ }
+
+ @Override
+ public void handleServerSide(EntityPlayer player) {
+ ItemStack stack = player.inventory.getStackInSlot(this.slotId);
+
+ if (stack != null && stack.getItem() instanceof Syncable) {
+ MCPacket mcPacket = new MCPacket(data);
+ mcPacket.setID(data.readInt());
+ ((Syncable) stack.getItem()).read(mcPacket);
+ }
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/network/netty/ChannelHandler.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/network/netty/ChannelHandler.java
new file mode 100644
index 000000000..d49859e0a
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/network/netty/ChannelHandler.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.network.netty;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import net.minecraftforge.fml.common.network.FMLIndexedMessageToMessageCodec;
+import nova.core.wrapper.mc.forge.v1_11.network.discriminator.NovaPacket;
+import nova.core.wrapper.mc.forge.v1_11.network.discriminator.PacketAbstract;
+import nova.core.wrapper.mc.forge.v1_11.network.discriminator.PacketPlayerItem;
+
+/**
+ * Handles the channel and discriminators.
+ * @author Calclavia
+ */
+public class ChannelHandler extends FMLIndexedMessageToMessageCodec {
+ public ChannelHandler() {
+ addDiscriminator(0, NovaPacket.class);
+ addDiscriminator(1, PacketPlayerItem.class);
+ }
+
+ @Override
+ public void encodeInto(ChannelHandlerContext ctx, PacketAbstract packet, ByteBuf target) throws Exception {
+ packet.encodeInto(ctx, target);
+ }
+
+ @Override
+ public void decodeInto(ChannelHandlerContext ctx, ByteBuf source, PacketAbstract packet) {
+ packet.decodeInto(ctx, source);
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/network/netty/MCNetworkManager.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/network/netty/MCNetworkManager.java
new file mode 100644
index 000000000..05922cc1e
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/network/netty/MCNetworkManager.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.network.netty;
+
+import io.netty.buffer.Unpooled;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.network.INetHandler;
+import net.minecraft.network.Packet;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.text.TextComponentString;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.common.FMLCommonHandler;
+import net.minecraftforge.fml.common.network.FMLEmbeddedChannel;
+import net.minecraftforge.fml.common.network.FMLOutboundHandler;
+import net.minecraftforge.fml.common.network.NetworkRegistry;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+import nova.core.entity.component.Player;
+import nova.core.network.NetworkManager;
+import nova.core.network.Syncable;
+import nova.core.wrapper.mc.forge.v1_11.launcher.NovaMinecraft;
+import nova.core.wrapper.mc.forge.v1_11.network.MCPacket;
+import nova.core.wrapper.mc.forge.v1_11.network.discriminator.NovaPacket;
+import nova.core.wrapper.mc.forge.v1_11.network.discriminator.PacketAbstract;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.entity.backward.BWEntity;
+import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
+
+import java.util.EnumMap;
+
+/**
+ * The implementation of NetworkManager that will be injected.
+ * @author Calclavia
+ * @since 26/05/14
+ */
+public class MCNetworkManager extends NetworkManager {
+ public final String channel = NovaMinecraft.id;
+ public final EnumMap channelEnumMap = NetworkRegistry.INSTANCE.newChannel(channel, new ChannelHandler(), new MCPacketHandler());
+
+ public Packet toMCPacket(PacketAbstract packet) {
+ return channelEnumMap.get(FMLCommonHandler.instance().getEffectiveSide()).generatePacketFrom(packet);
+ }
+
+ @Override
+ public nova.core.network.Packet newPacket() {
+ return new MCPacket(Unpooled.buffer());
+ }
+
+ @Override
+ public void sendPacket(nova.core.network.Packet packet) {
+ //Wrap the packet in NOVA's discriminator
+ PacketAbstract discriminator = new NovaPacket();
+ //Write packet
+ discriminator.data.writeBytes(((MCPacket) packet).buf);
+
+ if (isServer()) {
+ sendToAll(discriminator);
+ } else {
+ sendToServer(discriminator);
+ }
+ }
+
+ public PacketAbstract writePacket(int id, Syncable sender) {
+ PacketAbstract discriminator = new NovaPacket();
+ nova.core.network.Packet packet = newPacket();
+ packet.setID(id);
+
+ //Write packet
+ writePacket(sender, packet);
+ discriminator.data.writeBytes(((MCPacket) packet).buf);
+ return discriminator;
+ }
+
+ @Override
+ public void sendChat(Player player, String message) {
+ if (player instanceof BWEntity.MCPlayer) {
+ ((BWEntity.MCPlayer) player).entity.sendMessage(new TextComponentString(message));
+ }
+ }
+
+ @Override
+ public boolean isServer() {
+ return FMLCommonHandler.instance().getEffectiveSide().isServer();
+ }
+
+ /**
+ * @param packet the packet to send to the player
+ * @param player the player MP object
+ */
+ public void sendToPlayer(PacketAbstract packet, EntityPlayerMP player) {
+ this.channelEnumMap.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGET).set(FMLOutboundHandler.OutboundTarget.PLAYER);
+ this.channelEnumMap.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).set(player);
+ this.channelEnumMap.get(Side.SERVER).writeAndFlush(packet);
+ }
+
+ /**
+ * @param packet the packet to send to the players in the dimension
+ * @param dimId the dimension id to send to.
+ */
+ public void sendToAllInDimension(PacketAbstract packet, int dimId) {
+ this.channelEnumMap.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGET).set(FMLOutboundHandler.OutboundTarget.DIMENSION);
+ this.channelEnumMap.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).set(dimId);
+ this.channelEnumMap.get(Side.SERVER).writeAndFlush(packet);
+ }
+
+ public void sendToAllInDimension(PacketAbstract packet, World world) {
+ sendToAllInDimension(packet, world.provider.getDimension());
+ }
+
+ /**
+ * sends to all clients connected to the server
+ * @param packet the packet to send.
+ */
+ public void sendToAll(PacketAbstract packet) {
+ this.channelEnumMap.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGET).set(FMLOutboundHandler.OutboundTarget.ALL);
+ this.channelEnumMap.get(Side.SERVER).writeAndFlush(packet);
+ }
+
+ public void sendToAllAround(PacketAbstract message, NetworkRegistry.TargetPoint point) {
+ this.channelEnumMap.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGET).set(FMLOutboundHandler.OutboundTarget.ALLAROUNDPOINT);
+ this.channelEnumMap.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).set(point);
+ this.channelEnumMap.get(Side.SERVER).writeAndFlush(message);
+ }
+
+ public void sendToAllAround(PacketAbstract message, World world, Vector3D point, double range) {
+ sendToAllAround(message, world, point.getX(), point.getY(), point.getZ(), range);
+ }
+
+ public void sendToAllAround(PacketAbstract message, TileEntity tile) {
+ sendToAllAround(message, tile, 64);
+ }
+
+ public void sendToAllAround(PacketAbstract message, TileEntity tile, double range) {
+ sendToAllAround(message, tile.getWorld(), tile.getPos().getX(), tile.getPos().getY(), tile.getPos().getZ(), range);
+ }
+
+ public void sendToAllAround(PacketAbstract message, World world, double x, double y, double z, double range) {
+ sendToAllAround(message, new NetworkRegistry.TargetPoint(world.provider.getDimension(), x, y, z, range));
+ }
+
+ @SideOnly(Side.CLIENT)
+ public void sendToServer(PacketAbstract packet) {
+ this.channelEnumMap.get(Side.CLIENT).attr(FMLOutboundHandler.FML_MESSAGETARGET).set(FMLOutboundHandler.OutboundTarget.TOSERVER);
+ this.channelEnumMap.get(Side.CLIENT).writeAndFlush(packet);
+ }
+}
+
+
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/network/netty/MCPacketHandler.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/network/netty/MCPacketHandler.java
new file mode 100644
index 000000000..994303ffe
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/network/netty/MCPacketHandler.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.network.netty;
+
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.SimpleChannelInboundHandler;
+import net.minecraft.network.INetHandler;
+import net.minecraft.network.NetHandlerPlayServer;
+import net.minecraftforge.fml.client.FMLClientHandler;
+import net.minecraftforge.fml.common.FMLCommonHandler;
+import net.minecraftforge.fml.common.network.NetworkRegistry;
+import nova.core.wrapper.mc.forge.v1_11.launcher.NovaMinecraft;
+import nova.core.wrapper.mc.forge.v1_11.network.discriminator.PacketAbstract;
+
+/**
+ * @author tgame14
+ * @since 31/05/14
+ */
+@ChannelHandler.Sharable
+public class MCPacketHandler extends SimpleChannelInboundHandler {
+ @Override
+ protected void channelRead0(ChannelHandlerContext ctx, PacketAbstract packet) throws Exception {
+ INetHandler netHandler = ctx.channel().attr(NetworkRegistry.NET_HANDLER).get();
+
+ switch (FMLCommonHandler.instance().getEffectiveSide()) {
+ case CLIENT:
+ FMLClientHandler.instance().getClient().addScheduledTask(() -> packet.handleClientSide(NovaMinecraft.proxy.getClientPlayer()));
+ break;
+ case SERVER:
+ FMLCommonHandler.instance().getMinecraftServerInstance().addScheduledTask(() -> packet.handleServerSide(((NetHandlerPlayServer) netHandler).playerEntity));
+ break;
+ default:
+ break;
+ }
+
+ }
+
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/MCCraftingGrid.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/MCCraftingGrid.java
new file mode 100644
index 000000000..0eafaf8b9
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/MCCraftingGrid.java
@@ -0,0 +1,255 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.recipes;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.Container;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.InventoryCrafting;
+import net.minecraft.inventory.Slot;
+import net.minecraft.inventory.SlotCrafting;
+import net.minecraft.item.ItemStack;
+import nova.core.entity.component.Player;
+import nova.core.recipes.crafting.CraftingGrid;
+import nova.core.wrapper.mc.forge.v1_11.util.ReflectionUtil;
+import nova.core.wrapper.mc.forge.v1_11.util.WrapUtility;
+import nova.core.wrapper.mc.forge.v1_11.wrapper.item.ItemConverter;
+import nova.internal.core.Game;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * @author Stan Hebben
+ */
+public class MCCraftingGrid implements CraftingGrid {
+ private static final ThreadLocal cache = new ThreadLocal();
+ private static final ThreadLocal cache2 = new ThreadLocal();
+ private final IInventory inventory;
+ private final Optional player;
+ private final EntityPlayer playerOrig;
+ private int width;
+ private int height;
+ private nova.core.item.Item[] stacks;
+ private ItemStack[] original;
+ private int numberOfStacks;
+
+ private MCCraftingGrid(InventoryCrafting inventory) {
+ this.inventory = inventory;
+ width = height = (int) Math.sqrt(inventory.getSizeInventory());
+ stacks = new nova.core.item.Item[width * height];
+ original = new ItemStack[stacks.length];
+ numberOfStacks = 0;
+ update();
+
+ Container container = ReflectionUtil.getCraftingContainer(inventory);
+ if (container != null) {
+ List slots = container.inventorySlots;
+ if (!slots.isEmpty() && slots.get(0) instanceof SlotCrafting) {
+ SlotCrafting slotCrafting = (SlotCrafting) slots.get(0);
+ playerOrig = ReflectionUtil.getCraftingSlotPlayer(slotCrafting);
+ player = WrapUtility.getNovaPlayer(playerOrig);
+ } else {
+ playerOrig = null;
+ player = null;
+ }
+ } else {
+ playerOrig = null;
+ player = null;
+ }
+ }
+
+ public MCCraftingGrid(IInventory inventory, EntityPlayer player) {
+ this.inventory = inventory;
+ width = height = (int) Math.sqrt(inventory.getSizeInventory());
+ stacks = new nova.core.item.Item[width * height];
+ original = new ItemStack[stacks.length];
+ numberOfStacks = 0;
+ update();
+
+ playerOrig = player;
+ this.player = WrapUtility.getNovaPlayer(player);
+ }
+
+ public static MCCraftingGrid get(InventoryCrafting inventory) {
+ if (cache.get() == null || cache.get().inventory != inventory) {
+ MCCraftingGrid result = new MCCraftingGrid(inventory);
+ cache.set(result);
+ return result;
+ } else {
+ MCCraftingGrid result = cache.get();
+ result.update();
+ return result;
+ }
+ }
+
+ public static MCCraftingGrid get(IInventory inventory, EntityPlayer player) {
+ if (cache2.get() == null || cache2.get().inventory != inventory || cache2.get().playerOrig != player) {
+ MCCraftingGrid result = new MCCraftingGrid(inventory, player);
+ cache2.set(result);
+ return result;
+ } else {
+ MCCraftingGrid result = cache2.get();
+ result.update();
+ return result;
+ }
+ }
+
+ private void update() {
+ if (inventory.getSizeInventory() != original.length) {
+ width = height = (int) Math.sqrt(inventory.getSizeInventory());
+ stacks = new nova.core.item.Item[inventory.getSizeInventory()];
+ original = new ItemStack[stacks.length];
+ numberOfStacks = 0;
+ }
+
+ for (int i = 0; i < inventory.getSizeInventory(); i++) {
+ if (changed(i)) {
+ //System.out.println("Slot " + i + " changed");
+ original[i] = inventory.getStackInSlot(i);
+ if (inventory.getStackInSlot(i) != null) {
+ if (stacks[i] == null) {
+ numberOfStacks++;
+ }
+
+ stacks[i] = Game.natives().toNova(original[i]);
+ } else {
+ if (stacks[i] != null) {
+ numberOfStacks--;
+ }
+
+ stacks[i] = null;
+ }
+ }
+ }
+ //System.out.println("Num stack count: " + numberOfStacks);
+ }
+
+ @Override
+ public Optional getPlayer() {
+ return player;
+ }
+
+ @Override
+ public int size() {
+ return width * height;
+ }
+
+ @Override
+ public int getWidth() {
+ return width;
+ }
+
+ @Override
+ public int getHeight() {
+ return height;
+ }
+
+ @Override
+ public int countFilledStacks() {
+ return numberOfStacks;
+ }
+
+ @Override
+ public Optional getStack(int i) {
+ return Optional.ofNullable(stacks[i]);
+ }
+
+ @Override
+ public Optional getStack(int x, int y) {
+ return Optional.ofNullable(stacks[y * width + x]);
+ }
+
+ @Override
+ public boolean setStack(int x, int y, Optional stack) {
+ //System.out.println("SetStack(" + x + ", " + y + ") " + stack);
+
+ int ix = y * width + x;
+ if (stack.isPresent()) {
+ if (!stack.get().equals(stacks[ix])) {
+ inventory.setInventorySlotContents(ix, Game.natives().toNative(stack.get()));
+
+ if (stacks[ix] == null) {
+ numberOfStacks++;
+ }
+
+ stacks[ix] = stack.get();
+ }
+ } else {
+ numberOfStacks--;
+ inventory.setInventorySlotContents(ix, null);
+ stacks[ix] = null;
+ }
+
+ return true;
+ }
+
+ @Override
+ public boolean setStack(int i, Optional stack) {
+ //System.out.println("SetStack(" + i + ") " + stack);
+
+ if (stack.isPresent()) {
+ if (stacks[i] == null) {
+ numberOfStacks++;
+ }
+
+ inventory.setInventorySlotContents(i, Game.natives().toNative(stack.get()));
+ stacks[i] = stack.get();
+ } else {
+ if (stacks[i] == null) {
+ return true;
+ }
+
+ numberOfStacks--;
+ inventory.setInventorySlotContents(i, null);
+ stacks[i] = null;
+ }
+
+ return true;
+ }
+
+ @Override
+ public void giveBack(nova.core.item.Item itemStack) {
+ playerOrig.inventory.addItemStackToInventory(ItemConverter.instance().toNative(itemStack));
+ }
+
+ @Override
+ public String getTopology() {
+ return CraftingGrid.topologySquare;
+ }
+
+ @Override
+ public String getType() {
+ return CraftingGrid.typeCrafting;
+ }
+
+ private boolean changed(int i) {
+ if (original[i] != inventory.getStackInSlot(i)) {
+ return true;
+ }
+
+ if (original[i] != null && stacks[i].count() != original[i].getCount()) {
+ return true;
+ }
+
+ return false;
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/MCCraftingRecipe.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/MCCraftingRecipe.java
new file mode 100644
index 000000000..8b3a53453
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/MCCraftingRecipe.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.recipes;
+
+import net.minecraft.item.crafting.IRecipe;
+import nova.core.item.Item;
+import nova.core.recipes.crafting.CraftingGrid;
+import nova.core.recipes.crafting.CraftingRecipe;
+import nova.internal.core.Game;
+
+import java.util.Optional;
+
+/**
+ * @author Stan Hebben
+ */
+public class MCCraftingRecipe implements CraftingRecipe {
+ private final IRecipe recipe;
+
+ public MCCraftingRecipe(IRecipe recipe) {
+ this.recipe = recipe;
+ }
+
+ @Override
+ public boolean matches(CraftingGrid craftingGrid) {
+ // TODO: supply world somehow?
+ return recipe.matches(new NovaCraftingGrid(craftingGrid), null);
+ }
+
+ @Override
+ public Optional getCraftingResult(CraftingGrid craftingGrid) {
+ return Game.natives().toNova(recipe.getCraftingResult(new NovaCraftingGrid(craftingGrid)));
+ }
+
+ @Override
+ public void consumeItems(CraftingGrid craftingGrid) {
+ // not supported
+ }
+
+ @Override
+ public Optional getNominalOutput() {
+ return Game.natives().toNova(recipe.getRecipeOutput());
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/MinecraftItemIngredient.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/MinecraftItemIngredient.java
new file mode 100644
index 000000000..f430a58f0
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/MinecraftItemIngredient.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.recipes;
+
+import nova.core.item.Item;
+import nova.core.recipes.crafting.SpecificItemIngredient;
+import nova.internal.core.Game;
+
+/**
+ * @author Stan Hebben
+ */
+public class MinecraftItemIngredient extends SpecificItemIngredient {
+ public MinecraftItemIngredient(net.minecraft.item.ItemStack itemStack) {
+ super(((Item) Game.natives().toNova(itemStack)).getID());
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/MinecraftRecipeRegistry.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/MinecraftRecipeRegistry.java
new file mode 100644
index 000000000..af3f96b4a
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/MinecraftRecipeRegistry.java
@@ -0,0 +1,330 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.recipes;
+
+import net.minecraft.item.crafting.CraftingManager;
+import net.minecraft.item.crafting.IRecipe;
+import net.minecraftforge.oredict.RecipeSorter;
+import net.minecraftforge.oredict.RecipeSorter.Category;
+import nova.core.event.RecipeEvent;
+import nova.core.recipes.RecipeManager;
+import nova.core.recipes.crafting.CraftingRecipe;
+import nova.core.wrapper.mc.forge.v1_11.util.ReflectionUtil;
+import nova.internal.core.Game;
+
+import java.util.AbstractList;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Map;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+
+/**
+ * Created by Stan on 1/02/2015.
+ */
+public class MinecraftRecipeRegistry {
+ public static final MinecraftRecipeRegistry instance = new MinecraftRecipeRegistry();
+
+ private final Map forwardWrappers = new HashMap<>();
+ private final Map backwardWrappers = new HashMap<>();
+
+ private MinecraftRecipeRegistry() {
+ }
+
+ public void registerRecipes() {
+ long startTime = System.currentTimeMillis();
+
+ RecipeManager recipeManager = Game.recipes();
+
+ List recipes = CraftingManager.getInstance().getRecipeList();
+ for (IRecipe recipe : recipes) {
+ CraftingRecipe converted = convert(recipe);
+ if (converted != null) {
+ recipeManager.addRecipe(converted);
+ backwardWrappers.put(recipe, converted);
+ forwardWrappers.put(converted, recipe);
+ }
+ }
+
+ ReflectionUtil.setCraftingRecipeList(new RecipeListWrapper(recipes));
+
+ System.out.println("Initialized recipes in " + (System.currentTimeMillis() - startTime) + " ms");
+
+ RecipeSorter.register("nova:shaped", ShapedRecipeBasic.class, Category.SHAPED, "before:forge:shapedore");
+ RecipeSorter.register("nova:shaped.oredict", ShapedRecipeOre.class, Category.SHAPED, "after:nova:shaped after:minecraft:shaped before:minecraft:shapeless");
+
+ RecipeSorter.register("nova:shapeless", ShapelessRecipeBasic.class, Category.SHAPELESS, "after:minecraft:shapeless before:forge:shapelessore");
+ RecipeSorter.register("nova:shapeless.oredict", ShapelessRecipeOre.class, Category.SHAPELESS, "after:nova:shapeless after:minecraft:shapeless");
+
+ RecipeSorter.register("nova:unknown", NovaCraftingRecipe.class, Category.UNKNOWN, "");
+
+ recipeManager.whenRecipeAdded(CraftingRecipe.class, this::onNOVARecipeAdded);
+ recipeManager.whenRecipeRemoved(CraftingRecipe.class, this::onNOVARecipeRemoved);
+ }
+
+ private CraftingRecipe convert(IRecipe recipe) {
+ return RecipeConverter.toNova(recipe);
+ }
+
+ private IRecipe convert(CraftingRecipe recipe) {
+ return RecipeConverter.toMinecraft(recipe);
+ }
+
+ private void onNOVARecipeAdded(RecipeEvent.Add e) {
+ CraftingRecipe recipe = e.recipe;
+ if (forwardWrappers.containsKey(recipe)) {
+ return;
+ }
+
+ IRecipe minecraftRecipe = convert(recipe);
+
+ backwardWrappers.put(minecraftRecipe, recipe);
+ forwardWrappers.put(recipe, minecraftRecipe);
+
+ CraftingManager.getInstance().getRecipeList().add(minecraftRecipe);
+ }
+
+ private void onNOVARecipeRemoved(RecipeEvent.Remove e) {
+ IRecipe minecraftRecipe = forwardWrappers.get(e.recipe);
+
+ forwardWrappers.remove(e.recipe);
+ backwardWrappers.remove(minecraftRecipe);
+
+ CraftingManager.getInstance().getRecipeList().remove(minecraftRecipe);
+ }
+
+ private void onMinecraftRecipeAdded(IRecipe recipe) {
+ if (backwardWrappers.containsKey(recipe)) {
+ return;
+ }
+
+ CraftingRecipe novaRecipe = convert(recipe);
+
+ backwardWrappers.put(recipe, novaRecipe);
+ forwardWrappers.put(novaRecipe, recipe);
+
+ Game.recipes().addRecipe(novaRecipe);
+ }
+
+ private void onMinecraftRecipeRemoved(IRecipe recipe) {
+ CraftingRecipe novaRecipe = backwardWrappers.get(recipe);
+
+ forwardWrappers.remove(novaRecipe);
+ backwardWrappers.remove(recipe);
+
+ Game.recipes().removeRecipe(novaRecipe);
+ }
+
+ private class RecipeListWrapper extends AbstractList {
+ private final List original;
+
+ public RecipeListWrapper(List original) {
+ this.original = original;
+ }
+
+ @Override
+ public int size() {
+ return original.size();
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return original.isEmpty();
+ }
+
+ @Override
+ public boolean contains(Object o) {
+ return original.contains(o);
+ }
+
+ @Override
+ public Iterator iterator() {
+ return original.iterator();
+ }
+
+ @Override
+ public void forEach(Consumer action) {
+ original.forEach(action);
+ }
+
+ @Override
+ public Object[] toArray() {
+ return original.toArray();
+ }
+
+ @Override
+ public T[] toArray(T[] a) {
+ return original.toArray(a);
+ }
+
+ @Override
+ public boolean add(IRecipe iRecipe) {
+ boolean result = original.add(iRecipe);
+ if (result && !backwardWrappers.containsKey(iRecipe)) {
+ onMinecraftRecipeAdded(iRecipe);
+ }
+
+ return result;
+ }
+
+ @Override
+ public boolean remove(Object o) {
+ if (!backwardWrappers.containsKey(o)) {
+ return false;
+ }
+
+ boolean result = original.remove(o);
+ if (result) {
+ onMinecraftRecipeRemoved((IRecipe) o);
+ }
+
+ return result;
+ }
+
+ @Override
+ public boolean containsAll(Collection c) {
+ return original.containsAll(c);
+ }
+
+ @Override
+ public boolean addAll(Collection c) {
+ boolean result = false;
+ for (IRecipe recipe : c) {
+ result |= add(recipe);
+ }
+ return result;
+ }
+
+ @Override
+ public boolean addAll(int index, Collection c) {
+ for (IRecipe recipe : c) {
+ add(index, recipe);
+ index++;
+ }
+
+ return !c.isEmpty();
+ }
+
+ @Override
+ public boolean removeAll(Collection c) {
+ boolean result = false;
+ for (Object o : c) {
+ result |= c.remove(o);
+ }
+ return result;
+ }
+
+ @Override
+ public boolean retainAll(Collection c) {
+ return false;
+ }
+
+ @Override
+ public void sort(Comparator c) {
+ original.sort(c);
+ }
+
+ @Override
+ public void clear() {
+ // one would have to be a mad scientist to use this operation... but ok
+
+ for (IRecipe recipe : original) {
+ onMinecraftRecipeRemoved(recipe);
+ }
+
+ original.clear();
+ }
+
+ @Override
+ public IRecipe get(int index) {
+ return original.get(index);
+ }
+
+ @Override
+ public IRecipe set(int index, IRecipe element) {
+ IRecipe current = original.get(index);
+ onMinecraftRecipeRemoved(current);
+
+ original.set(index, element);
+ onMinecraftRecipeAdded(element);
+
+ return current;
+ }
+
+ @Override
+ public void add(int index, IRecipe element) {
+ original.add(index, element);
+ onMinecraftRecipeAdded(element);
+ }
+
+ @Override
+ public IRecipe remove(int index) {
+ IRecipe current = original.remove(index);
+ onMinecraftRecipeRemoved(current);
+ return current;
+ }
+
+ @Override
+ public int indexOf(Object o) {
+ return original.indexOf(o);
+ }
+
+ @Override
+ public int lastIndexOf(Object o) {
+ return original.lastIndexOf(o);
+ }
+
+ @Override
+ public ListIterator listIterator() {
+ return original.listIterator();
+ }
+
+ @Override
+ public ListIterator listIterator(int index) {
+ return original.listIterator(index);
+ }
+
+ @Override
+ public List subList(int fromIndex, int toIndex) {
+ return new RecipeListWrapper(original.subList(fromIndex, toIndex));
+ }
+
+ @Override
+ public Spliterator spliterator() {
+ return original.spliterator();
+ }
+
+ @Override
+ public Stream stream() {
+ return original.stream();
+ }
+
+ @Override
+ public Stream parallelStream() {
+ return original.parallelStream();
+ }
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/NovaCraftingGrid.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/NovaCraftingGrid.java
new file mode 100644
index 000000000..29d385bee
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/NovaCraftingGrid.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.recipes;
+
+import net.minecraft.inventory.InventoryCrafting;
+import nova.core.recipes.crafting.CraftingGrid;
+
+public class NovaCraftingGrid extends InventoryCrafting {
+ private final CraftingGrid craftingGrid;
+
+ public NovaCraftingGrid(CraftingGrid craftingGrid) {
+ super(new NovaCraftingGridContainer(craftingGrid), craftingGrid.getWidth(), craftingGrid.getHeight());
+ this.craftingGrid = craftingGrid;
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/NovaCraftingGridContainer.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/NovaCraftingGridContainer.java
new file mode 100644
index 000000000..2059423a5
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/NovaCraftingGridContainer.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.recipes;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.Container;
+import nova.core.recipes.crafting.CraftingGrid;
+
+/**
+ * TODO: complete this class. without it, modded recipes will not work when crafted from NOVA mods.
+ * @author Stan Hebben
+ */
+public class NovaCraftingGridContainer extends Container {
+ private final CraftingGrid craftingGrid;
+
+ public NovaCraftingGridContainer(CraftingGrid craftingGrid) {
+ this.craftingGrid = craftingGrid;
+ }
+
+ @Override
+ public boolean canInteractWith(EntityPlayer entityPlayer) {
+ return true;
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/NovaCraftingRecipe.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/NovaCraftingRecipe.java
new file mode 100644
index 000000000..c04a4c622
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/NovaCraftingRecipe.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.recipes;
+
+import net.minecraft.inventory.InventoryCrafting;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.IRecipe;
+import net.minecraft.util.NonNullList;
+import net.minecraft.world.World;
+import nova.core.item.Item;
+import nova.core.recipes.crafting.CraftingRecipe;
+import nova.internal.core.Game;
+
+import java.util.Optional;
+
+public class NovaCraftingRecipe implements IRecipe {
+ private final CraftingRecipe recipe;
+
+ public NovaCraftingRecipe(CraftingRecipe recipe) {
+ this.recipe = recipe;
+ }
+
+ @Override
+ public boolean matches(InventoryCrafting inventoryCrafting, World world) {
+ return recipe.matches(MCCraftingGrid.get(inventoryCrafting));
+ }
+
+ @Override
+ public ItemStack getCraftingResult(InventoryCrafting inventoryCrafting) {
+ Optional craftingResult = recipe.getCraftingResult(MCCraftingGrid.get(inventoryCrafting));
+ if (craftingResult.isPresent()) {
+ return Game.natives().toNative(craftingResult.get());
+ } else {
+ return null;
+ }
+ }
+
+ @Override
+ public int getRecipeSize() {
+ return 1;
+ }
+
+ @Override
+ public ItemStack getRecipeOutput() {
+ Optional nominalOutput = recipe.getNominalOutput();
+ if (nominalOutput.isPresent()) {
+ return Game.natives().toNative(nominalOutput.get());
+ }
+ return null;
+ }
+
+ @Override
+ public NonNullList getRemainingItems(InventoryCrafting inv) {
+ return NonNullList.create();
+ }
+}
diff --git a/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/RecipeConverter.java b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/RecipeConverter.java
new file mode 100644
index 000000000..eb711986f
--- /dev/null
+++ b/minecraft/1.11/src/main/java/nova/core/wrapper/mc/forge/v1_11/recipes/RecipeConverter.java
@@ -0,0 +1,275 @@
+/*
+ * Copyright (c) 2015 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA. If not, see .
+ */
+
+package nova.core.wrapper.mc.forge.v1_11.recipes;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.IRecipe;
+import net.minecraft.item.crafting.ShapedRecipes;
+import net.minecraft.item.crafting.ShapelessRecipes;
+import net.minecraftforge.oredict.ShapedOreRecipe;
+import net.minecraftforge.oredict.ShapelessOreRecipe;
+import nova.core.item.Item;
+import nova.core.recipes.crafting.CraftingRecipe;
+import nova.core.recipes.crafting.ItemIngredient;
+import nova.core.recipes.crafting.OreItemIngredient;
+import nova.core.recipes.crafting.ShapedCraftingRecipe;
+import nova.core.recipes.crafting.ShapelessCraftingRecipe;
+import nova.core.recipes.crafting.SpecificItemIngredient;
+import nova.core.wrapper.mc.forge.v1_11.util.ReflectionUtil;
+import nova.internal.core.Game;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Wraps Minecraft crafting recipes to NOVA crafting recipes and vice versa.
+ *
+ * Although a naive implementation could wrap NOVA recipes into its own recipe class and forward that, mods like NEI
+ * won't be able to handle those recipes. Hence we wrap them into ShapedRecipes / ShapelessRecipes / ShapedOreRecipes and ShapelessOreRecipes
+ * as much as possible. Only when that is not possible (a rare case, in practice) the generic wrapper is used.
+ *
+ * The reverse is also done, such that mods listening to NOVA ShapedCraftingRecipes and ShapelessCraftingRecipes would be
+ * given the proper information and be informed of their registration, if desired.
+ * @author Stan Hebben
+ */
+public class RecipeConverter {
+ public static final int TYPE_ADVANCED = 0;
+ public static final int TYPE_ORE = 1;
+ public static final int TYPE_BASIC = 2;
+
+ private RecipeConverter() {
+ }
+
+ private static int getIngredientType(ItemIngredient ingredient) {
+ if (ingredient instanceof SpecificItemIngredient) {
+ return TYPE_BASIC;
+ } else if (ingredient instanceof OreItemIngredient) {
+ return TYPE_ORE;
+ } else {
+ return TYPE_ADVANCED;
+ }
+ }
+
+ private static Object getInternal(ItemIngredient ingredient) {
+ if (ingredient instanceof SpecificItemIngredient) {
+ return wrapSpecific((SpecificItemIngredient) ingredient);
+ } else if (ingredient instanceof OreItemIngredient) {
+ return ((OreItemIngredient) ingredient).getName();
+ }
+
+ return null;
+ }
+
+ private static ItemIngredient getIngredient(Object ingredient) {
+ if (ingredient == null) {
+ return null;
+ } else if (ingredient instanceof ItemStack) {
+ return ((ItemStack) ingredient).isEmpty() ? null : ItemIngredient.forItem(net.minecraft.item.Item.REGISTRY.getNameForObject(((ItemStack) ingredient).getItem()).toString());
+ } else if (ingredient instanceof String) {
+ return ItemIngredient.forDictionary((String) ingredient);
+ } else if (ingredient instanceof List) {
+ @SuppressWarnings("unchecked")
+ String oreDictEntry = findOreDictEntryFor((List) ingredient);
+ if (oreDictEntry == null) {
+ return null;
+ }
+
+ return new OreItemIngredient(oreDictEntry);
+ } else {
+ return null;
+ }
+ }
+
+ private static String findOreDictEntryFor(List ingredient) {
+ for (String key : net.minecraftforge.oredict.OreDictionary.getOreNames()) {
+ if (net.minecraftforge.oredict.OreDictionary.getOres(key).equals(ingredient)) {
+ return key;
+ }
+ }
+
+ return null;
+ }
+
+ private static ItemStack wrapSpecific(SpecificItemIngredient ingredient) {
+ for (Item item : ingredient.getExampleItems().get()) {
+ return Game.natives().toNative(item.getFactory().build());
+ }
+
+ throw new AssertionError("this can't be!");
+ }
+
+ private static int getRecipeType(ItemIngredient[] ingredients) {
+ int type = TYPE_BASIC;
+ for (ItemIngredient ingredient : ingredients) {
+ type = Math.min(type, getIngredientType(ingredient));
+ }
+ return type;
+ }
+
+ public static IRecipe toMinecraft(CraftingRecipe recipe) {
+ if (recipe instanceof ShapedCraftingRecipe) {
+ return convert((ShapedCraftingRecipe) recipe);
+ } else if (recipe instanceof ShapelessCraftingRecipe) {
+ return convert((ShapelessCraftingRecipe) recipe);
+ } else {
+ return new NovaCraftingRecipe(recipe);
+ }
+ }
+
+ public static IRecipe convert(ShapelessCraftingRecipe recipe) {
+ ItemIngredient[] ingredients = recipe.getIngredients();
+ int type = getRecipeType(ingredients);
+
+ switch (type) {
+ case TYPE_BASIC: {
+ ItemStack[] items = new ItemStack[ingredients.length];
+ for (int i = 0; i < ingredients.length; i++) {
+ items[i] = wrapSpecific((SpecificItemIngredient) ingredients[i]);
+ }
+ return new ShapelessRecipeBasic(items, recipe);
+ }
+ case TYPE_ORE: {
+ Object[] items = new Object[ingredients.length];
+ for (int i = 0; i < ingredients.length; i++) {
+ items[i] = getInternal(ingredients[i]);
+ }
+ return new ShapelessRecipeOre(items, recipe);
+ }
+ default:
+ return new NovaCraftingRecipe(recipe);
+ }
+ }
+
+ public static IRecipe convert(ShapedCraftingRecipe recipe) {
+ ItemIngredient[] ingredients = recipe.getIngredients();
+ int[] posx = recipe.getIngredientsX();
+ int[] posy = recipe.getIngredientsY();
+
+ // determine recipe type
+ int type = getRecipeType(ingredients);
+
+ // construct recipe
+ switch (type) {
+ case TYPE_BASIC: {
+ ItemStack[] basicIngredients = new ItemStack[recipe.getHeight() * recipe.getWidth()];
+ for (int i = 0; i < ingredients.length; i++) {
+ basicIngredients[posx[i] + posy[i] * recipe.getWidth()] = wrapSpecific((SpecificItemIngredient) ingredients[i]);
+ }
+
+ return new ShapedRecipeBasic(basicIngredients, recipe);
+ }
+ case TYPE_ORE: {
+ Object[] converted = new Object[recipe.getHeight() * recipe.getWidth()];
+ for (int i = 0; i < ingredients.length; i++) {
+ converted[posx[i] + posy[i] * recipe.getWidth()] = getInternal(ingredients[i]);
+ }
+
+ // arguments contents:
+ // 1) recipe patterns
+ // 2) characters + ingredients
+
+ int counter = 0;
+ String[] parts = new String[recipe.getHeight()];
+ ArrayList