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

12 files changed, 684 insertions, 76 deletions

diff --git a/src/main/java/kubatech/CommonProxy.java b/src/main/java/kubatech/CommonProxy.java
index 5f1ec40cad..db752f9fa0 100644
--- a/src/main/java/kubatech/CommonProxy.java
+++ b/src/main/java/kubatech/CommonProxy.java
@@ -24,6 +24,7 @@ import cpw.mods.fml.common.event.*;
 import kubatech.commands.CommandConfig;
 import kubatech.commands.CommandHandler;
 import kubatech.commands.CommandHelp;
+import kubatech.config.Config;
 import kubatech.loaders.RecipeLoader;
 
 public class CommonProxy {
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;
+    }
 }
diff --git a/src/main/java/kubatech/commands/CommandConfig.java b/src/main/java/kubatech/commands/CommandConfig.java
index a1c3659165..0c33c3dedf 100644
--- a/src/main/java/kubatech/commands/CommandConfig.java
+++ b/src/main/java/kubatech/commands/CommandConfig.java
@@ -21,8 +21,8 @@ package kubatech.commands;
 
 import static kubatech.commands.CommandConfig.Translations.*;
 
-import kubatech.Config;
 import kubatech.api.network.LoadConfigPacket;
+import kubatech.config.Config;
 import kubatech.kubatech;
 import kubatech.loaders.MobRecipeLoader;
 import net.minecraft.command.CommandBase;
diff --git a/src/main/java/kubatech/Config.java b/src/main/java/kubatech/config/Config.java
index feb8f96dae..72044ae899 100644
--- a/src/main/java/kubatech/Config.java
+++ b/src/main/java/kubatech/config/Config.java
@@ -17,9 +17,10 @@
  *
  */
 
-package kubatech;
+package kubatech.config;
 
 import java.io.File;
+import kubatech.Tags;
 import net.minecraftforge.common.config.Configuration;
 
 public class Config {
diff --git a/src/main/java/kubatech/config/OverridesConfig.java b/src/main/java/kubatech/config/OverridesConfig.java
new file mode 100644
index 0000000000..9c1ca6170c
--- /dev/null
+++ b/src/main/java/kubatech/config/OverridesConfig.java
@@ -0,0 +1,212 @@
+package kubatech.config;
+
+import com.dreammaster.main.MainRegistry;
+import com.dreammaster.modcustomdrops.CustomDrops;
+import com.google.common.io.Files;
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+import cpw.mods.fml.common.registry.GameRegistry;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import java.io.File;
+import java.io.Reader;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import kubatech.Tags;
+import kubatech.api.ConstructableItemStack;
+import kubatech.api.LoaderReference;
+import kubatech.api.mobhandler.MobDrop;
+import kubatech.api.utils.GSONUtils;
+import kubatech.api.utils.ReflectionHelper;
+import net.minecraft.entity.EntityList;
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.JsonToNBT;
+import net.minecraft.nbt.NBTTagCompound;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class OverridesConfig {
+
+    private static final Logger LOG = LogManager.getLogger(Tags.MODID + "[Config-Overrides]");
+
+    public static class MobDropSimplified {
+        @GSONUtils.SkipGSON
+        ItemStack stack;
+
+        ConstructableItemStack reconstructableStack;
+        MobDrop.DropType type;
+
+        private MobDropSimplified() {}
+
+        public MobDropSimplified(ItemStack stack, MobDrop.DropType type) {
+            reconstructableStack = new ConstructableItemStack(stack);
+            this.type = type;
+        }
+
+        public void reconstructStack() {
+            stack = reconstructableStack.construct();
+        }
+
+        public boolean isMatching(MobDrop drop) {
+            return reconstructableStack.isSame(drop.reconstructableStack, true);
+        }
+
+        private static final ByteBuf BufHelper = Unpooled.buffer();
+
+        public void writeToByteBuf(ByteBuf byteBuf) {
+            BufHelper.clear();
+            reconstructableStack.writeToByteBuf(BufHelper);
+            BufHelper.writeInt(type.ordinal());
+            byteBuf.writeInt(BufHelper.readableBytes());
+            byteBuf.writeBytes(BufHelper);
+        }
+
+        public static MobDropSimplified readFromByteBuf(ByteBuf byteBuf) {
+            MobDropSimplified mobDropSimplified = new MobDropSimplified();
+            int size = byteBuf.readInt();
+            mobDropSimplified.reconstructableStack = ConstructableItemStack.readFromByteBuf(byteBuf);
+            mobDropSimplified.type = MobDrop.DropType.get(byteBuf.readInt());
+            mobDropSimplified.reconstructStack();
+            return mobDropSimplified;
+        }
+    }
+
+    public static class MobOverride {
+        public boolean removeAll = false;
+        public List<MobDrop> additions = new ArrayList<>();
+        public List<MobDropSimplified> removals = new ArrayList<>();
+
+        private static final ByteBuf BufHelper = Unpooled.buffer();
+
+        public void writeToByteBuf(ByteBuf byteBuf) {
+            BufHelper.clear();
+            BufHelper.writeBoolean(removeAll);
+            BufHelper.writeInt(additions.size());
+            additions.forEach(drop -> drop.writeToByteBuf(BufHelper));
+            BufHelper.writeInt(removals.size());
+            removals.forEach(drop -> drop.writeToByteBuf(BufHelper));
+            byteBuf.writeInt(BufHelper.readableBytes());
+            byteBuf.writeBytes(BufHelper);
+        }
+
+        public static MobOverride readFromByteBuf(ByteBuf byteBuf) {
+            int size = byteBuf.readInt();
+            MobOverride mobOverride = new MobOverride();
+            mobOverride.removeAll = byteBuf.readBoolean();
+            int additionssize = byteBuf.readInt();
+            for (int i = 0; i < additionssize; i++) mobOverride.additions.add(MobDrop.readFromByteBuf(byteBuf));
+            int removalssize = byteBuf.readInt();
+            for (int i = 0; i < removalssize; i++) mobOverride.removals.add(MobDropSimplified.readFromByteBuf(byteBuf));
+            return mobOverride;
+        }
+    }
+
+    public static Map<String, MobOverride> overrides = new HashMap<>();
+    private static File overrideFile = null;
+
+    private static final Gson gson = GSONUtils.GSON_BUILDER_PRETTY.create();
+
+    @SuppressWarnings("UnstableApiUsage")
+    public static void LoadConfig() {
+        LOG.info("Loading Config");
+        if (overrideFile == null) overrideFile = Config.getConfigFile("MobOverrides.cfg");
+        if (!overrideFile.exists()) writeExampleFile();
+        Reader reader = null;
+        try {
+            reader = Files.newReader(overrideFile, StandardCharsets.UTF_8);
+            overrides = gson.fromJson(reader, new TypeToken<Map<String, MobOverride>>() {}.getType());
+            overrides.remove("ExampleMob");
+            if (LoaderReference.GTNHCoreMod) {
+                LOG.info("Detected GTNH Core Mod, parsing custom drops from there.");
+                CustomDrops coredrops =
+                        ReflectionHelper.getField(MainRegistry.Module_CustomDrops, "_mCustomDrops", null);
+                if (coredrops != null) {
+                    @SuppressWarnings("unchecked")
+                    ArrayList<CustomDrops.CustomDrop> customdrops = (ArrayList<CustomDrops.CustomDrop>)
+                            ((ArrayList<CustomDrops.CustomDrop>) coredrops.getCustomDrops()).clone();
+                    for (CustomDrops.CustomDrop customdrop : customdrops) {
+                        try {
+                            Class<?> eclass = Class.forName(customdrop.getEntityName());
+                            if (!EntityLiving.class.isAssignableFrom(eclass)) continue;
+                            String ename = (String) EntityList.classToStringMapping.get(eclass);
+                            if (ename == null) continue;
+                            MobOverride override = overrides.computeIfAbsent(ename, k -> new MobOverride());
+                            for (CustomDrops.CustomDrop.Drop drop : customdrop.getDrops()) {
+                                String[] parts = drop.getItemName().split(":");
+                                ItemStack stack = GameRegistry.findItemStack(parts[0], parts[1], 1);
+                                if (stack == null) continue;
+                                if (parts.length > 2) stack.setItemDamage(Integer.parseInt(parts[2]));
+                                String pNBT = ReflectionHelper.getField(drop, "mTag", null);
+                                if (pNBT != null && !pNBT.isEmpty()) {
+                                    try {
+                                        stack.stackTagCompound = (NBTTagCompound) JsonToNBT.func_150315_a(pNBT);
+                                    } catch (Exception ignored) {
+                                    }
+                                }
+                                int chance = drop.getChance() * 100;
+                                int amount = drop.getAmount();
+                                if (drop.getIsRandomAmount()) {
+                                    // average chance formula
+                                    // chance *= ((((amount * (amount + 1d)) / 2d)) + 1d) / (amount + 1d);
+                                    chance *= (2d + (amount * amount) + amount) / (2d * (amount + 1d));
+                                    amount = 1;
+                                    if (chance > 10000) {
+                                        int div = (int) Math.ceil(chance / 10000d);
+                                        amount *= div;
+                                        chance /= div;
+                                    }
+                                }
+                                stack.stackSize = amount;
+                                // Drops from coremod are player only
+                                override.additions.add(
+                                        new MobDrop(stack, MobDrop.DropType.Normal, chance, null, null, false, true));
+                            }
+                        } catch (Exception e) {
+                            e.printStackTrace();
+                        }
+                    }
+                }
+            }
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        } finally {
+            if (reader != null)
+                try {
+                    reader.close();
+                } catch (Exception ignored) {
+                }
+        }
+    }
+
+    @SuppressWarnings("UnstableApiUsage")
+    private static void writeExampleFile() {
+        LOG.info("No config has been detected, writing an example one");
+        Writer writer = null;
+        try {
+            writer = Files.newWriter(overrideFile, StandardCharsets.UTF_8);
+            Map<String, MobOverride> example = new HashMap<>(1);
+            MobOverride ex1 = new MobOverride();
+            ex1.removals.add(new MobDropSimplified(new ItemStack(Items.rotten_flesh, 1), MobDrop.DropType.Normal));
+            HashMap<Integer, Integer> exdamages = new HashMap<>(3);
+            exdamages.put(1, 1);
+            exdamages.put(2, 5);
+            exdamages.put(3, 10);
+            ex1.additions.add(new MobDrop(
+                    new ItemStack(Items.diamond_sword), MobDrop.DropType.Rare, 500, 20, exdamages, true, false));
+            example.put("ExampleMob", ex1);
+            gson.toJson(example, writer);
+            writer.flush();
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        } finally {
+            if (writer != null)
+                try {
+                    writer.close();
+                } catch (Exception ignored) {
+                }
+        }
+    }
+}
diff --git a/src/main/java/kubatech/loaders/MobRecipeLoader.java b/src/main/java/kubatech/loaders/MobRecipeLoader.java
index eb4d571819..1374c94d75 100644
--- a/src/main/java/kubatech/loaders/MobRecipeLoader.java
+++ b/src/main/java/kubatech/loaders/MobRecipeLoader.java
@@ -42,13 +42,15 @@ import java.lang.reflect.Modifier;
 import java.nio.charset.StandardCharsets;
 import java.util.*;
 import java.util.stream.Collectors;
-import kubatech.Config;
 import kubatech.Tags;
 import kubatech.api.LoaderReference;
+import kubatech.api.mobhandler.MobDrop;
 import kubatech.api.network.LoadConfigPacket;
 import kubatech.api.utils.GSONUtils;
 import kubatech.api.utils.InfernalHelper;
 import kubatech.api.utils.ModUtils;
+import kubatech.config.Config;
+import kubatech.config.OverridesConfig;
 import kubatech.nei.Mob_Handler;
 import kubatech.tileentity.gregtech.multiblock.GT_MetaTileEntity_ExtremeExterminationChamber;
 import minetweaker.MineTweakerAPI;
@@ -189,9 +191,14 @@ public class MobRecipeLoader {
             alwaysinfernal = InfernalHelper.checkEntityClassForced(e);
             isPeacefulAllowed = !(e instanceof IMob);
 
-            mOutputs = outputs;
+            mOutputs = (ArrayList<MobDrop>) outputs.clone();
             int maxdamagechance = 0;
-            for (MobDrop o : mOutputs) {
+            for (Iterator<MobDrop> iterator = mOutputs.iterator(); iterator.hasNext(); ) {
+                MobDrop o = iterator.next();
+                if (o.playerOnly) {
+                    iterator.remove();
+                    continue;
+                }
                 if (o.damages != null) for (int v : o.damages.values()) maxdamagechance += v;
             }
             mMaxDamageChance = maxdamagechance;
@@ -264,38 +271,6 @@ public class MobRecipeLoader {
         }
     }
 
-    public static class MobDrop {
-        public enum DropType {
-            Normal,
-            Rare,
-            Additional,
-            Infernal
-        }
-
-        @GSONUtils.SkipGSON
-        public ItemStack stack;
-
-        public NBTTagCompound reconstructableStack;
-        public DropType type;
-        public int chance;
-        public Integer enchantable;
-        public HashMap<Integer, Integer> damages;
-
-        public MobDrop(
-                ItemStack stack, DropType type, int chance, Integer enchantable, HashMap<Integer, Integer> damages) {
-            this.stack = stack;
-            this.reconstructableStack = stack.writeToNBT(new NBTTagCompound());
-            this.type = type;
-            this.chance = chance;
-            this.enchantable = enchantable;
-            this.damages = damages;
-        }
-
-        public void reconstructStack() {
-            this.stack = ItemStack.loadItemStackFromNBT(this.reconstructableStack);
-        }
-    }
-
     public static class fakeRand extends Random {
         private static class nexter {
             private final int type;
@@ -495,6 +470,7 @@ public class MobRecipeLoader {
                 if (randomchomenchantdetected) {
                     randomenchantmentlevel = ostack.stackTagCompound.getInteger(randomEnchantmentDetectedString);
                     ostack.stackTagCompound.removeTag("ench");
+                    ostack.stackTagCompound.setInteger(randomEnchantmentDetectedString, 0);
                 }
                 if ((booksAlwaysRandomlyEnchanted || randomchomenchantdetected)
                         && Items.enchanted_book == ostack.getItem()) {
@@ -722,7 +698,9 @@ public class MobRecipeLoader {
 
             droplist drops = new droplist();
             droplist raredrops = new droplist();
+            droplist superraredrops = new droplist();
             droplist additionaldrops = new droplist();
+            droplist dropslooting = new droplist();
 
             LOG.info("Generating normal drops");
 
@@ -753,6 +731,7 @@ public class MobRecipeLoader {
                 e.capturedDrops.clear();
             }
 
+            boolean second = false;
             do {
                 try {
                     dropFewItems.invoke(e, true, 0);
@@ -762,10 +741,58 @@ public class MobRecipeLoader {
                 }
                 collector.addDrop(drops, e.capturedDrops, frand.chance);
 
-                if (frand.chance < 0.0000001d) {
+                if (second && frand.chance < 0.0000001d) {
+                    LOG.info("Skipping " + k + " normal dropmap because it's too randomized");
+                    break;
+                }
+                second = true;
+
+            } while (frand.nextRound());
+
+            LOG.info("Generating normal drops with looting");
+
+            frand.newRound();
+            collector.newRound();
+
+            if (v.getName().startsWith("com.emoniph.witchery")) {
+                try {
+                    dropFewItems.invoke(e, true, 0);
+                } catch (Exception ex) {
+                    ex.printStackTrace();
+                    return;
+                }
+                frand.newRound();
+                frand.exceptionOnEnchantTry = true;
+                boolean enchantmentDetected = false;
+                try {
+                    dropFewItems.invoke(e, true, 0);
+                } catch (Exception ex) {
+                    enchantmentDetected = true;
+                }
+                int w = frand.walkCounter;
+                frand.newRound();
+                if (enchantmentDetected) {
+                    frand.maxWalkCount = w;
+                    collector.booksAlwaysRandomlyEnchanted = true;
+                }
+                e.capturedDrops.clear();
+            }
+
+            second = false;
+            do {
+                try {
+                    dropFewItems.invoke(e, true, 1);
+                } catch (Exception ex) {
+                    ex.printStackTrace();
+                    return;
+                }
+                collector.addDrop(dropslooting, e.capturedDrops, frand.chance);
+
+                if (second && frand.chance < 0.0000001d) {
                     LOG.info("Skipping " + k + " normal dropmap because it's too randomized");
                     break;
                 }
+                second = true;
 
             } while (frand.nextRound());
 
@@ -774,6 +801,7 @@ public class MobRecipeLoader {
             frand.newRound();
             collector.newRound();
 
+            second = false;
             do {
                 try {
                     dropRareDrop.invoke(e, 0);
@@ -783,10 +811,35 @@ public class MobRecipeLoader {
                 }
                 collector.addDrop(raredrops, e.capturedDrops, frand.chance);
 
-                if (frand.chance < 0.0000001d) {
+                if (second && frand.chance < 0.0000001d) {
                     LOG.info("Skipping " + k + " rare dropmap because it's too randomized");
                     break;
                 }
+                second = true;
+
+            } while (frand.nextRound());
+
+            LOG.info("Generating super rare drops");
+
+            frand.newRound();
+            collector.newRound();
+
+            second = false;
+            do {
+                try {
+                    dropRareDrop.invoke(e, 1);
+                } catch (Exception ex) {
+                    ex.printStackTrace();
+                    return;
+                }
+                collector.addDrop(superraredrops, e.capturedDrops, frand.chance);
+
+                if (second && frand.chance < 0.0000001d) {
+                    LOG.info("Skipping " + k + " rare dropmap because it's too randomized");
+                    break;
+                }
+                second = true;
+
             } while (frand.nextRound());
 
             LOG.info("Generating additional drops");
@@ -823,6 +876,7 @@ public class MobRecipeLoader {
                     frand.forceFloatValue = 0f;
                     chanceModifierLocal = 0.25f;
                 }
+                second = false;
                 do {
                     addRandomArmor.invoke(e);
                     if (!usingVanillaEnchantingMethod) enchantEquipment.invoke(e);
@@ -870,10 +924,11 @@ public class MobRecipeLoader {
                     }
                     Arrays.fill(e.getLastActiveItems(), null);
 
-                    if (frand.chance < 0.0000001d) {
+                    if (second && frand.chance < 0.0000001d) {
                         LOG.info("Skipping " + k + " additional dropmap because it's too randomized");
                         break;
                     }
+                    second = true;
 
                 } while (frand.nextRound());
             } catch (Exception ignored) {
@@ -894,46 +949,91 @@ public class MobRecipeLoader {
                 ItemStack stack = drop.stack;
                 if (stack.hasTagCompound()) stack.stackTagCompound.removeTag(randomEnchantmentDetectedString);
                 int chance = drop.getchance(10000);
-                while (chance > 10000) {
-                    stack.stackSize *= 2;
-                    chance /= 2;
+                if (chance > 10000) {
+                    int div = (int) Math.ceil(chance / 10000d);
+                    stack.stackSize *= div;
+                    chance /= div;
+                }
+                if (chance == 0) {
+                    LOG.warn("Detected 0% loot, setting to 0.01%");
+                    chance = 1;
                 }
+                dropinstance dlooting = dropslooting.get(drop);
                 moboutputs.add(new MobDrop(
                         stack,
                         MobDrop.DropType.Normal,
                         chance,
                         drop.isEnchatmentRandomized ? drop.enchantmentLevel : null,
-                        drop.isDamageRandomized ? drop.damagesPossible : null));
+                        drop.isDamageRandomized ? drop.damagesPossible : null,
+                        dlooting != null && dlooting.dropcount > drop.dropcount,
+                        false));
             }
             for (dropinstance drop : raredrops.drops) {
                 ItemStack stack = drop.stack;
                 if (stack.hasTagCompound()) stack.stackTagCompound.removeTag(randomEnchantmentDetectedString);
                 int chance = drop.getchance(250);
-                while (chance > 10000) {
-                    stack.stackSize *= 2;
-                    chance /= 2;
+                if (chance > 10000) {
+                    int div = (int) Math.ceil(chance / 10000d);
+                    stack.stackSize *= div;
+                    chance /= div;
+                }
+                if (chance == 0) {
+                    LOG.warn("Detected 0% loot, setting to 0.01%");
+                    chance = 1;
+                }
+                moboutputs.add(new MobDrop(
+                        stack,
+                        MobDrop.DropType.Rare,
+                        chance,
+                        drop.isEnchatmentRandomized ? drop.enchantmentLevel : null,
+                        drop.isDamageRandomized ? drop.damagesPossible : null,
+                        false,
+                        false));
+            }
+            for (dropinstance drop : superraredrops.drops) {
+                if (raredrops.contains(drop)) continue;
+                ItemStack stack = drop.stack;
+                if (stack.hasTagCompound()) stack.stackTagCompound.removeTag(randomEnchantmentDetectedString);
+                int chance = drop.getchance(50);
+                if (chance > 10000) {
+                    int div = (int) Math.ceil(chance / 10000d);
+                    stack.stackSize *= div;
+                    chance /= div;
+                }
+                if (chance == 0) {
+                    LOG.warn("Detected 0% loot, setting to 0.01%");
+                    chance = 1;
                 }
                 moboutputs.add(new MobDrop(
                         stack,
                         MobDrop.DropType.Rare,
                         chance,
                         drop.isEnchatmentRandomized ? drop.enchantmentLevel : null,
-                        drop.isDamageRandomized ? drop.damagesPossible : null));
+                        drop.isDamageRandomized ? drop.damagesPossible : null,
+                        false,
+                        false));
             }
             for (dropinstance drop : additionaldrops.drops) {
                 ItemStack stack = drop.stack;
                 if (stack.hasTagCompound()) stack.stackTagCompound.removeTag(randomEnchantmentDetectedString);
                 int chance = drop.getchance(850);
-                while (chance > 10000) {
-                    stack.stackSize *= 2;
-                    chance /= 2;
+                if (chance > 10000) {
+                    int div = (int) Math.ceil(chance / 10000d);
+                    stack.stackSize *= div;
+                    chance /= div;
+                }
+                if (chance == 0) {
+                    LOG.warn("Detected 0% loot, setting to 0.01%");
+                    chance = 1;
                 }
                 moboutputs.add(new MobDrop(
                         stack,
                         MobDrop.DropType.Additional,
                         chance,
                         drop.isEnchatmentRandomized ? drop.enchantmentLevel : null,
-                        drop.isDamageRandomized ? drop.damagesPossible : null));
+                        drop.isDamageRandomized ? drop.damagesPossible : null,
+                        false,
+                        false));
             }
 
             GeneralMobList.put(k, new GeneralMappedMob(e, new MobRecipe(e, moboutputs), moboutputs));
@@ -973,13 +1073,18 @@ public class MobRecipeLoader {
     public static void processMobRecipeMap() {
         LOG.info("Loading config");
 
+        OverridesConfig.LoadConfig();
+
         if (isClientSided) Mob_Handler.clearRecipes();
         MobNameToRecipeMap.clear();
         LoadConfigPacket.instance.mobsToLoad.clear();
-        GeneralMobList.forEach((k, v) -> {
+        LoadConfigPacket.instance.mobsOverrides.clear();
+        for (Map.Entry<String, GeneralMappedMob> entry : GeneralMobList.entrySet()) {
+            String k = entry.getKey();
+            GeneralMappedMob v = entry.getValue();
             if (Arrays.asList(Config.mobBlacklist).contains(k)) {
                 LOG.info("Entity " + k + " is blacklisted, skipping");
-                return;
+                continue;
             }
 
             MobRecipe recipe = v.recipe;
@@ -992,21 +1097,38 @@ public class MobRecipeLoader {
                 Optionals.parseMTAdditions(k, drops, recipe);
             }
 
+            OverridesConfig.MobOverride override = null;
+            if ((override = OverridesConfig.overrides.get(k)) != null) {
+                if (override.removeAll) drops.clear();
+                else
+                    for (OverridesConfig.MobDropSimplified removal : override.removals) {
+                        drops.removeIf(removal::isMatching);
+                        if (recipe != null) recipe.mOutputs.removeIf(removal::isMatching);
+                    }
+                drops.addAll(override.additions);
+                if (recipe != null)
+                    recipe.mOutputs.addAll(override.additions.stream()
+                            .filter(d -> !d.playerOnly)
+                            .collect(Collectors.toList()));
+                LoadConfigPacket.instance.mobsOverrides.put(k, override);
+            }
+
             if (drops.isEmpty()) {
                 LOG.info("Entity " + k + " doesn't drop any items, skipping EEC map");
-                if (!Config.includeEmptyMobs) return;
+                if (!Config.includeEmptyMobs) continue;
                 LoadConfigPacket.instance.mobsToLoad.add(k);
                 LOG.info("Registered " + k);
-                return;
+                continue;
             }
             if (v.recipe != null) MobNameToRecipeMap.put(k, recipe);
             LoadConfigPacket.instance.mobsToLoad.add(k);
             LOG.info("Registered " + k);
-        });
+        }
     }
 
     @SideOnly(Side.CLIENT)
-    public static void processMobRecipeMap(HashSet<String> mobs) {
+    public static void processMobRecipeMap(
+            HashSet<String> mobs, HashMap<String, OverridesConfig.MobOverride> overrides) {
         if (isClientSided) Mob_Handler.clearRecipes();
         MobNameToRecipeMap.clear();
         mobs.forEach(k -> {
@@ -1021,6 +1143,22 @@ public class MobRecipeLoader {
                 Optionals.parseMTAdditions(k, drops, recipe);
             }
 
+            OverridesConfig.MobOverride override = null;
+            if ((override = overrides.get(k)) != null) {
+                if (override.removeAll) drops.clear();
+                else
+                    for (OverridesConfig.MobDropSimplified removal : override.removals) {
+                        drops.removeIf(removal::isMatching);
+                        if (recipe != null) recipe.mOutputs.removeIf(removal::isMatching);
+                    }
+                drops.addAll(override.additions);
+                if (recipe != null)
+                    recipe.mOutputs.addAll(override.additions.stream()
+                            .filter(d -> !d.playerOnly)
+                            .collect(Collectors.toList()));
+                drops.sort(Comparator.comparing(d -> d.type)); // Fix gui
+            }
+
             Mob_Handler.addRecipe(v.mob, drops);
             if (recipe != null) MobNameToRecipeMap.put(k, recipe);
             LOG.info("Registered " + k);
@@ -1040,9 +1178,9 @@ public class MobRecipeLoader {
                     if (r.getFrom() == 0 && r.getTo() == 0) chance = 1d;
                     else chance = (((double) r.getTo() - (double) r.getFrom()) / 2d) + (double) r.getFrom();
                     ItemStack stack = ((ItemStack) entry.getKey().getInternal()).copy();
-                    MobDrop drop = new MobDrop(stack, MobDrop.DropType.Normal, (int) (chance * 10000), null, null);
+                    MobDrop drop = new MobDrop(
+                            stack, MobDrop.DropType.Normal, (int) (chance * 10000), null, null, false, true);
                     drops.add(drop);
-                    if (recipe != null) recipe.mOutputs.add(drop);
                 }
                 for (Map.Entry<IItemStack, IntRange> entry :
                         ie.getDropsToAddPlayerOnly().entrySet()) {
@@ -1052,9 +1190,9 @@ public class MobRecipeLoader {
                     if (r.getFrom() == 0 && r.getTo() == 0) chance = 1d;
                     else chance = (((double) r.getTo() - (double) r.getFrom()) / 2d) + (double) r.getFrom();
                     ItemStack stack = ((ItemStack) entry.getKey().getInternal()).copy();
-                    MobDrop drop = new MobDrop(stack, MobDrop.DropType.Normal, (int) (chance * 10000), null, null);
+                    MobDrop drop = new MobDrop(
+                            stack, MobDrop.DropType.Normal, (int) (chance * 10000), null, null, false, true);
                     drops.add(drop);
-                    if (recipe != null) recipe.mOutputs.add(drop);
                 }
                 for (IItemStack istack : ie.getDropsToRemove()) {
                     List<MobDrop> toRemove = drops.stream()
diff --git a/src/main/java/kubatech/nei/Mob_Handler.java b/src/main/java/kubatech/nei/Mob_Handler.java
index 5418aa1488..36fbb97231 100644
--- a/src/main/java/kubatech/nei/Mob_Handler.java
+++ b/src/main/java/kubatech/nei/Mob_Handler.java
@@ -36,6 +36,7 @@ import java.nio.FloatBuffer;
 import java.util.*;
 import java.util.List;
 import kubatech.api.LoaderReference;
+import kubatech.api.mobhandler.MobDrop;
 import kubatech.api.utils.FastRandom;
 import kubatech.api.utils.InfernalHelper;
 import kubatech.api.utils.MobUtils;
@@ -78,6 +79,8 @@ public class Mob_Handler extends TemplateRecipeHandler {
         AVERAGE_REMINDER,
         MOD,
         MAX_HEALTH,
+        LOOTABLE,
+        PLAYER_ONLY,
         ;
         final String key;
 
@@ -108,7 +111,7 @@ public class Mob_Handler extends TemplateRecipeHandler {
     public static int cycleTicksStatic = Math.abs((int) System.currentTimeMillis());
     private static final int itemsPerRow = 8, itemXShift = 18, itemYShift = 18, nextRowYShift = 35;
 
-    public static void addRecipe(EntityLiving e, List<MobRecipeLoader.MobDrop> drop) {
+    public static void addRecipe(EntityLiving e, List<MobDrop> drop) {
         List<MobPositionedStack> positionedStacks = new ArrayList<>();
         int xorigin = 7,
                 xoffset = xorigin,
@@ -117,8 +120,8 @@ public class Mob_Handler extends TemplateRecipeHandler {
                 raredrops = 0,
                 additionaldrops = 0,
                 infernaldrops = 0;
-        MobRecipeLoader.MobDrop.DropType i = null;
-        for (MobRecipeLoader.MobDrop d : drop) {
+        MobDrop.DropType i = null;
+        for (MobDrop d : drop) {
             if (i == d.type) {
                 xoffset += itemXShift;
                 if (xoffset >= xorigin + (itemXShift * itemsPerRow)) {
@@ -131,10 +134,10 @@ public class Mob_Handler extends TemplateRecipeHandler {
                 yoffset += nextRowYShift;
             }
             i = d.type;
-            if (d.type == MobRecipeLoader.MobDrop.DropType.Normal) normaldrops++;
-            else if (d.type == MobRecipeLoader.MobDrop.DropType.Rare) raredrops++;
-            else if (d.type == MobRecipeLoader.MobDrop.DropType.Additional) additionaldrops++;
-            else if (d.type == MobRecipeLoader.MobDrop.DropType.Infernal) break; // dont render infernal drops
+            if (d.type == MobDrop.DropType.Normal) normaldrops++;
+            else if (d.type == MobDrop.DropType.Rare) raredrops++;
+            else if (d.type == MobDrop.DropType.Additional) additionaldrops++;
+            else if (d.type == MobDrop.DropType.Infernal) break; // dont render infernal drops
             positionedStacks.add(new MobPositionedStack(
                     d.stack.copy(),
                     xoffset,
@@ -142,7 +145,9 @@ public class Mob_Handler extends TemplateRecipeHandler {
                     d.type,
                     d.chance,
                     d.enchantable,
-                    d.damages != null ? new ArrayList<>(d.damages.keySet()) : null));
+                    d.damages != null ? new ArrayList<>(d.damages.keySet()) : null,
+                    d.lootable,
+                    d.playerOnly));
         }
         instance.addRecipeInt(e, positionedStacks, normaldrops, raredrops, additionaldrops, infernaldrops);
     }
@@ -424,7 +429,7 @@ public class Mob_Handler extends TemplateRecipeHandler {
 
     public static class MobPositionedStack extends PositionedStack {
 
-        public final MobRecipeLoader.MobDrop.DropType type;
+        public final MobDrop.DropType type;
         public final int chance;
         public final boolean enchantable;
         public final boolean randomdamage;
@@ -436,10 +441,12 @@ public class Mob_Handler extends TemplateRecipeHandler {
                 Object object,
                 int x,
                 int y,
-                MobRecipeLoader.MobDrop.DropType type,
+                MobDrop.DropType type,
                 int chance,
                 Integer enchantable,
-                List<Integer> damages) {
+                List<Integer> damages,
+                boolean lootable,
+                boolean isPlayerOnly) {
             super(object, x, y, false);
             rand = new FastRandom();
             this.type = type;
@@ -455,6 +462,8 @@ public class Mob_Handler extends TemplateRecipeHandler {
             if (chance != 10000)
                 extratooltip.appendTag(new NBTTagString(
                         EnumChatFormatting.RESET + CHANCE.get() + (chance / 100) + "." + (chance % 100) + "%"));
+            if (lootable) extratooltip.appendTag(new NBTTagString(EnumChatFormatting.RESET + LOOTABLE.get()));
+            if (isPlayerOnly) extratooltip.appendTag(new NBTTagString(EnumChatFormatting.RESET + PLAYER_ONLY.get()));
             extratooltip.appendTag(new NBTTagString(EnumChatFormatting.RESET + AVERAGE_REMINDER.get()));
 
             NBTTagCompound itemtag = this.items[0].getTagCompound();
diff --git a/src/main/resources/assets/kubatech/lang/en_US.lang b/src/main/resources/assets/kubatech/lang/en_US.lang
index be22ffc8a2..c5a1658798 100644
--- a/src/main/resources/assets/kubatech/lang/en_US.lang
+++ b/src/main/resources/assets/kubatech/lang/en_US.lang
@@ -12,6 +12,8 @@ mobhandler.mod=Mod:
 mobhandler.max_health=Max health: 
 mobhandler.chance=Chance: 
 mobhandler.average_reminder=§7§oPlease remember that these are average drops.
+mobhandler.lootable=Looting is applied
+mobhandler.player_only=§7Does not drop in EEC
 
 #Commands
 commandhandler.invalid=§cInvalid use ! The proper use of this command is /%s