Add Config to override mob drops + some fixes (#8)

* Add overrides

* GTNHCoreMod custom drops integration

* Update buildscript

* Bump

* EEC blacklist

* NEI info

* Loops optimization

* Warn when 0% loots are detected

* Detect looting drops

* No

* Super rare drops

* Keep the same naming

* Crash

* Fix meta

* maybe

* Run at least twice

* Fix stupid TF Lich boss

* Comments

* Fix EEC blacklist

5 files changed, 248 insertions, 3 deletions

diff --git a/src/main/java/kubatech/api/ConstructableItemStack.java b/src/main/java/kubatech/api/ConstructableItemStack.java
new file mode 100644
index 0000000000..668d21d803
--- /dev/null
+++ b/src/main/java/kubatech/api/ConstructableItemStack.java
@@ -0,0 +1,97 @@
+package kubatech.api;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import java.nio.charset.StandardCharsets;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.CompressedStreamTools;
+import net.minecraft.nbt.NBTSizeTracker;
+import net.minecraft.nbt.NBTTagCompound;
+
+public class ConstructableItemStack {
+    public final GameRegistry.UniqueIdentifier itemIdentifier;
+    public final int meta;
+    public final int size;
+    public final NBTTagCompound tagCompound;
+
+    private ConstructableItemStack(
+            GameRegistry.UniqueIdentifier itemIdentifier, int meta, int size, NBTTagCompound tagCompound) {
+        this.itemIdentifier = itemIdentifier;
+        this.meta = meta;
+        this.size = size;
+        this.tagCompound = tagCompound;
+    }
+
+    public ConstructableItemStack(ItemStack stack) {
+        itemIdentifier = GameRegistry.findUniqueIdentifierFor(stack.getItem());
+        meta = stack.getItemDamage();
+        size = stack.stackSize;
+        tagCompound = stack.stackTagCompound;
+    }
+
+    public ItemStack construct() {
+        if (itemIdentifier == null) return null;
+        Item it = GameRegistry.findItem(itemIdentifier.modId, itemIdentifier.name);
+        if (it == null) return null;
+        ItemStack stack = new ItemStack(it, size, meta);
+        stack.stackTagCompound = tagCompound;
+        return stack;
+    }
+
+    public boolean isSame(ConstructableItemStack stack, boolean ignoreSize) {
+        if (!stack.itemIdentifier.modId.equals(itemIdentifier.modId)) return false;
+        if (!stack.itemIdentifier.name.equals(itemIdentifier.name)) return false;
+        return ignoreSize || stack.size == size;
+    }
+
+    private static final ByteBuf BufHelper = Unpooled.buffer();
+
+    public void writeToByteBuf(ByteBuf byteBuf) {
+        BufHelper.clear();
+        byte[] bytes = itemIdentifier.modId.getBytes(StandardCharsets.UTF_8);
+        BufHelper.writeInt(bytes.length);
+        BufHelper.writeBytes(bytes);
+        bytes = itemIdentifier.name.getBytes(StandardCharsets.UTF_8);
+        BufHelper.writeInt(bytes.length);
+        BufHelper.writeBytes(bytes);
+        BufHelper.writeInt(meta);
+        BufHelper.writeInt(size);
+        BufHelper.writeBoolean(tagCompound != null);
+        if (tagCompound != null) {
+            try {
+                bytes = CompressedStreamTools.compress(tagCompound);
+            } catch (Exception ignored) {
+                bytes = new byte[0];
+            }
+            BufHelper.writeInt(bytes.length);
+            BufHelper.writeBytes(bytes);
+        }
+        byteBuf.writeInt(BufHelper.readableBytes());
+        byteBuf.writeBytes(BufHelper);
+    }
+
+    public static ConstructableItemStack readFromByteBuf(ByteBuf byteBuf) {
+        int size = byteBuf.readInt();
+        byte[] bytes = new byte[byteBuf.readInt()];
+        byteBuf.readBytes(bytes);
+        String modid = new String(bytes, StandardCharsets.UTF_8);
+        bytes = new byte[byteBuf.readInt()];
+        byteBuf.readBytes(bytes);
+        String name = new String(bytes, StandardCharsets.UTF_8);
+        int meta = byteBuf.readInt();
+        int stacksize = byteBuf.readInt();
+        NBTTagCompound nbtTagCompound = null;
+        if (byteBuf.readBoolean()) {
+            bytes = new byte[byteBuf.readInt()];
+            byteBuf.readBytes(bytes);
+            try {
+                nbtTagCompound = CompressedStreamTools.func_152457_a(bytes, new NBTSizeTracker(2097152L));
+            } catch (Exception ignored) {
+            }
+        }
+        return new ConstructableItemStack(
+                new GameRegistry.UniqueIdentifier(modid + ":" + name), meta, stacksize, nbtTagCompound);
+    }
+}
diff --git a/src/main/java/kubatech/api/LoaderReference.java b/src/main/java/kubatech/api/LoaderReference.java
index 418fe4a7ab..b41db59904 100644
--- a/src/main/java/kubatech/api/LoaderReference.java
+++ b/src/main/java/kubatech/api/LoaderReference.java
@@ -10,4 +10,5 @@ public class LoaderReference {
     public static final boolean Thaumcraft = Loader.isModLoaded("Thaumcraft");
     public static final boolean MineTweaker = Loader.isModLoaded("MineTweaker3");
     public static final boolean Bartworks = Loader.isModLoaded("bartworks");
+    public static final boolean GTNHCoreMod = Loader.isModLoaded("dreamcraft");
 }
diff --git a/src/main/java/kubatech/api/mobhandler/MobDrop.java b/src/main/java/kubatech/api/mobhandler/MobDrop.java
new file mode 100644
index 0000000000..76942b3148
--- /dev/null
+++ b/src/main/java/kubatech/api/mobhandler/MobDrop.java
@@ -0,0 +1,99 @@
+package kubatech.api.mobhandler;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import java.util.HashMap;
+import kubatech.api.ConstructableItemStack;
+import kubatech.api.utils.GSONUtils;
+import net.minecraft.item.ItemStack;
+
+public class MobDrop {
+    public enum DropType {
+        Normal,
+        Rare,
+        Additional,
+        Infernal;
+        private static final DropType[] values = values();
+
+        public static DropType get(int ordinal) {
+            return values[ordinal];
+        }
+    }
+
+    @GSONUtils.SkipGSON
+    public ItemStack stack;
+
+    public ConstructableItemStack reconstructableStack;
+    public DropType type;
+    public int chance;
+    public Integer enchantable;
+    public HashMap<Integer, Integer> damages;
+    public boolean lootable = false;
+    public boolean playerOnly = false;
+
+    private MobDrop() {}
+
+    public MobDrop(
+            ItemStack stack,
+            DropType type,
+            int chance,
+            Integer enchantable,
+            HashMap<Integer, Integer> damages,
+            boolean lootable,
+            boolean playerOnly) {
+        this.stack = stack;
+        this.reconstructableStack = new ConstructableItemStack(stack);
+        this.type = type;
+        this.chance = chance;
+        this.enchantable = enchantable;
+        this.damages = damages;
+        this.lootable = lootable;
+        this.playerOnly = playerOnly;
+    }
+
+    public void reconstructStack() {
+        this.stack = reconstructableStack.construct();
+    }
+
+    private static final ByteBuf BufHelper = Unpooled.buffer();
+
+    public void writeToByteBuf(ByteBuf byteBuf) {
+        BufHelper.clear();
+        reconstructableStack.writeToByteBuf(BufHelper);
+        BufHelper.writeInt(type.ordinal());
+        BufHelper.writeInt(chance);
+        BufHelper.writeBoolean(enchantable != null);
+        if (enchantable != null) BufHelper.writeInt(enchantable);
+        BufHelper.writeBoolean(damages != null);
+        if (damages != null) {
+            BufHelper.writeInt(damages.size());
+            damages.forEach((k, v) -> {
+                BufHelper.writeInt(k);
+                BufHelper.writeInt(v);
+            });
+        }
+        BufHelper.writeBoolean(lootable);
+        BufHelper.writeBoolean(playerOnly);
+        byteBuf.writeInt(BufHelper.readableBytes());
+        byteBuf.writeBytes(BufHelper);
+    }
+
+    public static MobDrop readFromByteBuf(ByteBuf byteBuf) {
+        MobDrop mobDrop = new MobDrop();
+        int size = byteBuf.readInt();
+        mobDrop.reconstructableStack = ConstructableItemStack.readFromByteBuf(byteBuf);
+        mobDrop.type = DropType.get(byteBuf.readInt());
+        mobDrop.chance = byteBuf.readInt();
+        if (byteBuf.readBoolean()) mobDrop.enchantable = byteBuf.readInt();
+        else mobDrop.enchantable = null;
+        if (byteBuf.readBoolean()) {
+            mobDrop.damages = new HashMap<>();
+            int damagessize = byteBuf.readInt();
+            for (int i = 0; i < damagessize; i++) mobDrop.damages.put(byteBuf.readInt(), byteBuf.readInt());
+        } else mobDrop.damages = null;
+        mobDrop.lootable = byteBuf.readBoolean();
+        mobDrop.playerOnly = byteBuf.readBoolean();
+        mobDrop.reconstructStack();
+        return mobDrop;
+    }
+}
diff --git a/src/main/java/kubatech/api/network/LoadConfigPacket.java b/src/main/java/kubatech/api/network/LoadConfigPacket.java
index f38293642e..2199eb2db9 100644
--- a/src/main/java/kubatech/api/network/LoadConfigPacket.java
+++ b/src/main/java/kubatech/api/network/LoadConfigPacket.java
@@ -24,8 +24,10 @@ import cpw.mods.fml.common.network.simpleimpl.IMessageHandler;
 import cpw.mods.fml.common.network.simpleimpl.MessageContext;
 import io.netty.buffer.ByteBuf;
 import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
 import java.util.HashSet;
-import kubatech.Config;
+import kubatech.config.Config;
+import kubatech.config.OverridesConfig;
 import kubatech.kubatech;
 import kubatech.loaders.MobRecipeLoader;
 
@@ -34,6 +36,7 @@ public class LoadConfigPacket implements IMessage {
     public static final LoadConfigPacket instance = new LoadConfigPacket();
 
     public final HashSet<String> mobsToLoad = new HashSet<>();
+    public final HashMap<String, OverridesConfig.MobOverride> mobsOverrides = new HashMap<>();
 
     @Override
     public void fromBytes(ByteBuf buf) {
@@ -46,6 +49,13 @@ public class LoadConfigPacket implements IMessage {
                 buf.readBytes(sbytes);
                 mobsToLoad.add(new String(sbytes, StandardCharsets.UTF_8));
             }
+            int overridessize = buf.readInt();
+            for (int i = 0; i < overridessize; i++) {
+                byte[] sbytes = new byte[buf.readInt()];
+                buf.readBytes(sbytes);
+                mobsOverrides.put(
+                        new String(sbytes, StandardCharsets.UTF_8), OverridesConfig.MobOverride.readFromByteBuf(buf));
+            }
         }
     }
 
@@ -60,6 +70,13 @@ public class LoadConfigPacket implements IMessage {
                 buf.writeInt(sbytes.length);
                 buf.writeBytes(sbytes);
             });
+            buf.writeInt(mobsOverrides.size());
+            mobsOverrides.forEach((k, v) -> {
+                byte[] sbytes = k.getBytes(StandardCharsets.UTF_8);
+                buf.writeInt(sbytes.length);
+                buf.writeBytes(sbytes);
+                v.writeToByteBuf(buf);
+            });
         }
     }
 
@@ -67,7 +84,7 @@ public class LoadConfigPacket implements IMessage {
         @Override
         public IMessage onMessage(LoadConfigPacket message, MessageContext ctx) {
             kubatech.info("Received Mob Handler config, parsing");
-            MobRecipeLoader.processMobRecipeMap(message.mobsToLoad);
+            MobRecipeLoader.processMobRecipeMap(message.mobsToLoad, message.mobsOverrides);
             return null;
         }
     }
diff --git a/src/main/java/kubatech/api/utils/GSONUtils.java b/src/main/java/kubatech/api/utils/GSONUtils.java
index 1c0e7ec3f4..90f777000c 100644
--- a/src/main/java/kubatech/api/utils/GSONUtils.java
+++ b/src/main/java/kubatech/api/utils/GSONUtils.java
@@ -1,12 +1,16 @@
 package kubatech.api.utils;
 
 import com.google.gson.*;
+import java.io.File;
 import java.io.IOException;
+import java.io.Reader;
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 import java.lang.reflect.Type;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
 import net.minecraft.nbt.CompressedStreamTools;
 import net.minecraft.nbt.NBTSizeTracker;
 import net.minecraft.nbt.NBTTagCompound;
@@ -66,5 +70,32 @@ public class GSONUtils {
             .addSerializationExclusionStrategy(GSONStrategy)
             .addDeserializationExclusionStrategy(GSONStrategy)
             .registerTypeAdapter(NBTTagCompound.class, NBTTagCompoundDeserializer)
-            .registerTypeAdapter(NBTTagCompound.class, NBTTagCompoundSerializer);
+            .registerTypeAdapter(NBTTagCompound.class, NBTTagCompoundSerializer)
+            .serializeNulls();
+    public static final GsonBuilder GSON_BUILDER_PRETTY = new GsonBuilder()
+            .addSerializationExclusionStrategy(GSONStrategy)
+            .addDeserializationExclusionStrategy(GSONStrategy)
+            .registerTypeAdapter(NBTTagCompound.class, NBTTagCompoundDeserializer)
+            .registerTypeAdapter(NBTTagCompound.class, NBTTagCompoundSerializer)
+            .serializeNulls()
+            .setPrettyPrinting();
+
+    public static <T> T readFile(Gson gson, File file, Class<T> tClass) {
+        if (!file.exists()) return null;
+        if (!file.isFile()) return null;
+        T t = null;
+        Reader reader = null;
+        try {
+            reader = Files.newBufferedReader(file.toPath(), StandardCharsets.UTF_8);
+            t = gson.fromJson(reader, tClass);
+        } catch (Exception ignored) {
+        } finally {
+            if (reader != null)
+                try {
+                    reader.close();
+                } catch (Exception ignored) {
+                }
+        }
+        return t;
+    }
 }