Remove Mobs Info NEI page from KubaTech (#82)

* Add Mobs Info

* Use MobsInfo

* Update dependencies.gradle

* Update repositories.gradle

* Update GT_MetaTileEntity_ExtremeExterminationChamber.java

* Update dependencies.gradle

4 files changed, 262 insertions, 1332 deletions

diff --git a/src/main/java/kubatech/loaders/MobHandlerLoader.java b/src/main/java/kubatech/loaders/MobHandlerLoader.java
new file mode 100644
index 0000000000..2ebff9afaf
--- /dev/null
+++ b/src/main/java/kubatech/loaders/MobHandlerLoader.java
@@ -0,0 +1,258 @@
+package kubatech.loaders;
+
+import static kubatech.tileentity.gregtech.multiblock.GT_MetaTileEntity_ExtremeExterminationChamber.DIAMOND_SPIKES_DAMAGE;
+import static kubatech.tileentity.gregtech.multiblock.GT_MetaTileEntity_ExtremeExterminationChamber.MOB_SPAWN_INTERVAL;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+
+import net.minecraft.enchantment.EnchantmentHelper;
+import net.minecraft.entity.EntityList;
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.JsonToNBT;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.StatCollector;
+import net.minecraftforge.common.MinecraftForge;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import com.dreammaster.main.MainRegistry;
+import com.dreammaster.modcustomdrops.CustomDrops;
+import com.kuba6000.mobsinfo.api.MobDrop;
+import com.kuba6000.mobsinfo.api.MobOverride;
+import com.kuba6000.mobsinfo.api.MobRecipe;
+import com.kuba6000.mobsinfo.api.event.MobNEIRegistrationEvent;
+import com.kuba6000.mobsinfo.api.event.PostMobRegistrationEvent;
+import com.kuba6000.mobsinfo.api.event.PostMobsOverridesLoadEvent;
+import com.kuba6000.mobsinfo.api.event.PreMobsRegistrationEvent;
+
+import atomicstryker.infernalmobs.common.InfernalMobsCore;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.registry.GameRegistry;
+import gregtech.api.util.GT_Utility;
+import kubatech.Tags;
+import kubatech.api.LoaderReference;
+import kubatech.api.helpers.ReflectionHelper;
+import kubatech.config.Config;
+import kubatech.tileentity.gregtech.multiblock.GT_MetaTileEntity_ExtremeExterminationChamber;
+
+public class MobHandlerLoader {
+
+    private static final Logger LOG = LogManager.getLogger(Tags.MODID + "[Mob Handler Loader]");
+
+    private static MobHandlerLoader instance = null;
+
+    public static void init() {
+        instance = new MobHandlerLoader();
+        MinecraftForge.EVENT_BUS.register(instance);
+    }
+
+    public static Map<String, MobEECRecipe> recipeMap = new HashMap<>();
+
+    public static class MobEECRecipe {
+
+        public final List<MobDrop> mOutputs;
+
+        public final MobRecipe recipe;
+
+        public final int mEUt = 2000;
+        public final int mDuration;
+
+        public MobEECRecipe(List<MobDrop> transformedDrops, MobRecipe recipe) {
+            this.mOutputs = transformedDrops;
+            this.recipe = recipe;
+            mDuration = Math.max(MOB_SPAWN_INTERVAL, (int) ((recipe.maxEntityHealth / DIAMOND_SPIKES_DAMAGE) * 10d));
+        }
+
+        public ItemStack[] generateOutputs(Random rnd, GT_MetaTileEntity_ExtremeExterminationChamber MTE,
+            double attackDamage, int lootinglevel, boolean preferInfernalDrops) {
+            MTE.lEUt = mEUt;
+            MTE.mMaxProgresstime = Math.max(MOB_SPAWN_INTERVAL, (int) ((recipe.maxEntityHealth / attackDamage) * 10d));
+            ArrayList<ItemStack> stacks = new ArrayList<>(this.mOutputs.size());
+            for (MobDrop o : this.mOutputs) {
+                int chance = o.chance;
+                if (o.playerOnly) {
+                    chance = (int) ((double) chance * Config.MobHandler.playerOnlyDropsModifier);
+                    if (chance < 1) chance = 1;
+                }
+                int amount = o.stack.stackSize;
+                if (o.lootable && lootinglevel > 0) {
+                    chance += lootinglevel * 5000;
+                    if (chance > 10000) {
+                        int div = (int) Math.ceil(chance / 10000d);
+                        amount *= div;
+                        chance /= div;
+                    }
+                }
+                if (chance == 10000 || rnd.nextInt(10000) < chance) {
+                    ItemStack s = o.stack.copy();
+                    s.stackSize = amount;
+                    if (o.enchantable != null) EnchantmentHelper.addRandomEnchantment(rnd, s, o.enchantable);
+                    if (o.damages != null) {
+                        int rChance = rnd.nextInt(recipe.mMaxDamageChance);
+                        int cChance = 0;
+                        for (Map.Entry<Integer, Integer> damage : o.damages.entrySet()) {
+                            cChance += damage.getValue();
+                            if (rChance <= cChance) {
+                                s.setItemDamage(damage.getKey());
+                                break;
+                            }
+                        }
+                    }
+                    stacks.add(s);
+                }
+            }
+
+            if (LoaderReference.InfernalMobs) {
+                InfernalMobsCore infernalMobsCore = InfernalMobsCore.instance();
+                if (recipe.infernalityAllowed && mEUt * 8 < MTE.getMaxInputVoltage()
+                    && !infernalMobsCore.getDimensionBlackList()
+                        .contains(
+                            MTE.getBaseMetaTileEntity()
+                                .getWorld().provider.dimensionId)) {
+                    int p = 0;
+                    int mods = 0;
+                    if (recipe.alwaysinfernal
+                        || (preferInfernalDrops && rnd.nextInt(infernalMobsCore.getEliteRarity()) == 0)) {
+                        p = 1;
+                        if (rnd.nextInt(infernalMobsCore.getUltraRarity()) == 0) {
+                            p = 2;
+                            if (rnd.nextInt(infernalMobsCore.getInfernoRarity()) == 0) p = 3;
+                        }
+                    }
+                    ArrayList<ItemStack> infernalstacks = null;
+                    if (p > 0) if (p == 1) {
+                        infernalstacks = infernalMobsCore.getDropIdListElite();
+                        mods = infernalMobsCore.getMinEliteModifiers();
+                    } else if (p == 2) {
+                        infernalstacks = infernalMobsCore.getDropIdListUltra();
+                        mods = infernalMobsCore.getMinUltraModifiers();
+                    } else {
+                        infernalstacks = infernalMobsCore.getDropIdListInfernal();
+                        mods = infernalMobsCore.getMinInfernoModifiers();
+                    }
+                    if (infernalstacks != null) {
+                        ItemStack infernalstack = infernalstacks.get(rnd.nextInt(infernalstacks.size()))
+                            .copy();
+                        // noinspection ConstantConditions
+                        EnchantmentHelper.addRandomEnchantment(
+                            rnd,
+                            infernalstack,
+                            infernalstack.getItem()
+                                .getItemEnchantability());
+                        stacks.add(infernalstack);
+                        MTE.lEUt *= 8L;
+                        MTE.mMaxProgresstime *= mods * InfernalMobsCore.instance()
+                            .getMobModHealthFactor();
+                    }
+                }
+            }
+
+            return stacks.toArray(new ItemStack[0]);
+        }
+
+    }
+
+    @SubscribeEvent
+    public void onPreMobsRegistration(PreMobsRegistrationEvent event) {
+        recipeMap.clear();
+    }
+
+    @SubscribeEvent
+    public void onPostMobRegistration(PostMobRegistrationEvent event) {
+        if (!event.drops.isEmpty() && event.recipe.isUsableInVial) {
+            ArrayList<MobDrop> drops = (ArrayList<MobDrop>) event.drops.clone();
+            drops.removeIf(d -> d.chance == 0);
+            if (!drops.isEmpty()) {
+                recipeMap.put(event.currentMob, new MobEECRecipe(drops, event.recipe));
+                event.drops.stream()
+                    .filter(d -> d.chance == 0)
+                    .forEach(
+                        d -> d.additionalInfo.add(StatCollector.translateToLocal("kubatech.mobhandler.eec_disabled")));
+            }
+        }
+    }
+
+    @SubscribeEvent
+    public void onPostOverridesConfigLoad(PostMobsOverridesLoadEvent event) {
+        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 = event.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
+                            MobDrop mobDrop = new MobDrop(
+                                stack,
+                                MobDrop.DropType.Normal,
+                                chance,
+                                null,
+                                null,
+                                false,
+                                true);
+                            mobDrop.additionalInfo.add(
+                                StatCollector.translateToLocalFormatted(
+                                    "kubatech.mobhandler.eec_chance",
+                                    (((double) chance / 100d) * Config.MobHandler.playerOnlyDropsModifier)));
+                            override.additions.add(mobDrop);
+                        }
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        }
+
+    }
+
+    @SubscribeEvent
+    public void onMobNEIRegistration(MobNEIRegistrationEvent event) {
+        MobEECRecipe recipe = recipeMap.get(event.mobName);
+        if (recipe != null) {
+            event.additionalInformation.addAll(
+                Arrays.asList(
+                    GT_Utility.trans("153", "Usage: ") + GT_Utility.formatNumbers(recipe.mEUt) + " EU/t",
+                    GT_Utility.trans("158", "Time: ") + GT_Utility.formatNumbers(recipe.mDuration / 20d) + " secs"));
+        }
+    }
+}
diff --git a/src/main/java/kubatech/loaders/MobRecipeLoader.java b/src/main/java/kubatech/loaders/MobRecipeLoader.java
deleted file mode 100644
index da54d44117..0000000000
--- a/src/main/java/kubatech/loaders/MobRecipeLoader.java
+++ /dev/null
@@ -1,1326 +0,0 @@
-/*
- * spotless:off
- * KubaTech - Gregtech Addon
- * Copyright (C) 2022 - 2023  kuba6000
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library. If not, see <https://www.gnu.org/licenses/>.
- * spotless:on
- */
-
-package kubatech.loaders;
-
-import static kubatech.api.utils.ModUtils.isClientSided;
-import static kubatech.api.utils.ModUtils.isDeobfuscatedEnvironment;
-import static kubatech.tileentity.gregtech.multiblock.GT_MetaTileEntity_ExtremeExterminationChamber.DIAMOND_SPIKES_DAMAGE;
-import static kubatech.tileentity.gregtech.multiblock.GT_MetaTileEntity_ExtremeExterminationChamber.MOB_SPAWN_INTERVAL;
-import static kubatech.tileentity.gregtech.multiblock.GT_MetaTileEntity_ExtremeExterminationChamber.MobNameToRecipeMap;
-
-import java.io.File;
-import java.io.Reader;
-import java.io.Writer;
-import java.lang.reflect.Modifier;
-import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Random;
-import java.util.UUID;
-import java.util.function.Supplier;
-import java.util.stream.Collectors;
-
-import net.minecraft.block.Block;
-import net.minecraft.enchantment.Enchantment;
-import net.minecraft.enchantment.EnchantmentHelper;
-import net.minecraft.entity.Entity;
-import net.minecraft.entity.EntityList;
-import net.minecraft.entity.EntityLiving;
-import net.minecraft.entity.item.EntityItem;
-import net.minecraft.entity.monster.EntitySkeleton;
-import net.minecraft.entity.monster.EntitySlime;
-import net.minecraft.entity.monster.IMob;
-import net.minecraft.init.Blocks;
-import net.minecraft.init.Items;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.util.AxisAlignedBB;
-import net.minecraft.util.DamageSource;
-import net.minecraft.util.StatCollector;
-import net.minecraft.world.World;
-import net.minecraftforge.common.ForgeHooks;
-import net.minecraftforge.common.util.FakePlayer;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-
-import com.google.common.io.Files;
-import com.google.gson.Gson;
-import com.mojang.authlib.GameProfile;
-
-import atomicstryker.infernalmobs.common.InfernalMobsCore;
-import atomicstryker.infernalmobs.common.MobModifier;
-import atomicstryker.infernalmobs.common.mods.api.ModifierLoader;
-import cpw.mods.fml.common.FMLCommonHandler;
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
-import gregtech.api.util.GT_Utility;
-import gregtech.common.GT_DummyWorld;
-import kubatech.Tags;
-import kubatech.api.LoaderReference;
-import kubatech.api.helpers.EnderIOHelper;
-import kubatech.api.helpers.ProgressBarWrapper;
-import kubatech.api.mobhandler.MobDrop;
-import kubatech.api.network.LoadConfigPacket;
-import kubatech.api.utils.FastRandom;
-import kubatech.api.utils.GSONUtils;
-import kubatech.api.utils.ModUtils;
-import kubatech.api.utils.ModUtils.TriConsumer;
-import kubatech.config.Config;
-import kubatech.config.OverridesConfig;
-import kubatech.mixin.mixins.minecraft.EntityAccessor;
-import kubatech.mixin.mixins.minecraft.EntityLivingAccessor;
-import kubatech.mixin.mixins.minecraft.EntityLivingBaseAccessor;
-import kubatech.mixin.mixins.minecraft.EntitySlimeAccessor;
-import kubatech.nei.Mob_Handler;
-import kubatech.tileentity.gregtech.multiblock.GT_MetaTileEntity_ExtremeExterminationChamber;
-import minetweaker.MineTweakerAPI;
-import minetweaker.api.entity.IEntityDefinition;
-import minetweaker.api.item.IItemStack;
-import minetweaker.mc1710.item.MCItemStack;
-import stanhebben.zenscript.value.IntRange;
-import thaumcraft.common.items.wands.ItemWandCasting;
-
-public class MobRecipeLoader {
-
-    private static final Logger LOG = LogManager.getLogger(Tags.MODID + "[Mob Recipe Loader]");
-
-    private static final String addRandomArmorName = isDeobfuscatedEnvironment ? "addRandomArmor" : "func_82164_bB";
-    private static final String enchantEquipmentName = isDeobfuscatedEnvironment ? "enchantEquipment" : "func_82162_bC";
-
-    private static boolean alreadyGenerated = false;
-    public static boolean isInGenerationProcess = false;
-    public static final String randomEnchantmentDetectedString = "RandomEnchantmentDetected";
-
-    public static class MobRecipe {
-
-        public final ArrayList<MobDrop> mOutputs;
-        public final int mEUt = 2000;
-        public final int mDuration;
-        public int mMaxDamageChance;
-        public final boolean infernalityAllowed;
-        public final boolean alwaysinfernal;
-        public static droplist infernaldrops;
-        public final boolean isPeacefulAllowed;
-        public final EntityLiving entity;
-        public final float maxEntityHealth;
-        public final boolean isUsable;
-
-        @SuppressWarnings("unchecked")
-        public MobRecipe copy() {
-            return new MobRecipe(
-                (ArrayList<MobDrop>) mOutputs.clone(),
-                mDuration,
-                mMaxDamageChance,
-                infernalityAllowed,
-                alwaysinfernal,
-                isPeacefulAllowed,
-                entity,
-                maxEntityHealth,
-                isUsable);
-        }
-
-        private MobRecipe(ArrayList<MobDrop> mOutputs, int mDuration, int mMaxDamageChance, boolean infernalityAllowed,
-            boolean alwaysinfernal, boolean isPeacefulAllowed, EntityLiving entity, float maxEntityHealth,
-            boolean isUsable) {
-            this.mOutputs = mOutputs;
-            this.mDuration = mDuration;
-            this.mMaxDamageChance = mMaxDamageChance;
-            this.infernalityAllowed = infernalityAllowed;
-            this.alwaysinfernal = alwaysinfernal;
-            this.isPeacefulAllowed = isPeacefulAllowed;
-            this.entity = entity;
-            this.maxEntityHealth = maxEntityHealth;
-            this.isUsable = isUsable;
-        }
-
-        public static MobRecipe generateMobRecipe(EntityLiving e, String entityID, ArrayList<MobDrop> outputs) {
-            return new MobRecipe(e, entityID, outputs);
-        }
-
-        @SuppressWarnings("unchecked")
-        private MobRecipe(EntityLiving e, String entityID, ArrayList<MobDrop> outputs) {
-            if (LoaderReference.InfernalMobs) {
-                InfernalMobsCore infernalMobsCore = InfernalMobsCore.instance();
-                if (infernaldrops == null) {
-                    infernaldrops = new droplist();
-                    LOG.info("Generating Infernal drops");
-                    ArrayList<ModifierLoader<?>> modifierLoaders = (ArrayList<ModifierLoader<?>>) infernalMobsCore
-                        .getModifierLoaders()
-                        .clone();
-                    int i = 0;
-                    for (ModifierLoader<?> modifierLoader : modifierLoaders) {
-                        MobModifier nextMod = modifierLoader.make(null);
-                        if (nextMod.getBlackListMobClasses() != null)
-                            for (Class<?> cl : nextMod.getBlackListMobClasses()) if (e.getClass()
-                                .isAssignableFrom(cl)) break;
-                        i++;
-                    }
-                    if (i > 0) {
-                        double chance = infernalMobsCore.checkEntityClassForced(e) ? 1d
-                            : (1d / infernalMobsCore.getEliteRarity());
-                        ArrayList<ItemStack> elitelist = infernalMobsCore.getDropIdListElite();
-                        for (ItemStack stack : elitelist) {
-                            dropinstance instance = infernaldrops
-                                .add(new dropinstance(stack.copy(), infernaldrops), chance / elitelist.size());
-                            instance.isEnchatmentRandomized = true;
-                            // noinspection ConstantConditions
-                            instance.enchantmentLevel = stack.getItem()
-                                .getItemEnchantability();
-                        }
-                        ArrayList<ItemStack> ultralist = infernalMobsCore.getDropIdListUltra();
-                        chance *= 1d / infernalMobsCore.getUltraRarity();
-                        for (ItemStack stack : ultralist) {
-                            dropinstance instance = infernaldrops
-                                .add(new dropinstance(stack.copy(), infernaldrops), chance / ultralist.size());
-                            instance.isEnchatmentRandomized = true;
-                            // noinspection ConstantConditions
-                            instance.enchantmentLevel = stack.getItem()
-                                .getItemEnchantability();
-                        }
-                        ArrayList<ItemStack> infernallist = infernalMobsCore.getDropIdListInfernal();
-                        chance *= 1d / infernalMobsCore.getInfernoRarity();
-                        for (ItemStack stack : infernallist) {
-                            dropinstance instance = infernaldrops
-                                .add(new dropinstance(stack.copy(), infernaldrops), chance / infernallist.size());
-                            instance.isEnchatmentRandomized = true;
-                            // noinspection ConstantConditions
-                            instance.enchantmentLevel = stack.getItem()
-                                .getItemEnchantability();
-                        }
-                    }
-                }
-                infernalityAllowed = infernalMobsCore.isClassAllowed(e);
-                alwaysinfernal = infernalMobsCore.checkEntityClassForced(e);
-            } else {
-                infernalityAllowed = false;
-                alwaysinfernal = false;
-            }
-
-            if (infernaldrops == null) infernaldrops = new droplist();
-
-            isPeacefulAllowed = !(e instanceof IMob);
-
-            mOutputs = (ArrayList<MobDrop>) outputs.clone();
-            int maxdamagechance = 0;
-            for (MobDrop o : mOutputs) if (o.damages != null) for (int v : o.damages.values()) maxdamagechance += v;
-            mMaxDamageChance = maxdamagechance;
-            maxEntityHealth = e.getMaxHealth();
-            mDuration = Math.max(MOB_SPAWN_INTERVAL, (int) ((maxEntityHealth / DIAMOND_SPIKES_DAMAGE) * 10d));
-            entity = e;
-            isUsable = EnderIOHelper.canEntityBeCapturedWithSoulVial(e, entityID);
-        }
-
-        public void refresh() {
-            int maxdamagechance = 0;
-            for (MobDrop o : mOutputs) if (o.damages != null) for (int v : o.damages.values()) maxdamagechance += v;
-            mMaxDamageChance = maxdamagechance;
-        }
-
-        public ItemStack[] generateOutputs(Random rnd, GT_MetaTileEntity_ExtremeExterminationChamber MTE,
-            double attackDamage, int lootinglevel, boolean preferInfernalDrops) {
-            MTE.lEUt = mEUt;
-            MTE.mMaxProgresstime = Math.max(MOB_SPAWN_INTERVAL, (int) ((maxEntityHealth / attackDamage) * 10d));
-            ArrayList<ItemStack> stacks = new ArrayList<>(mOutputs.size());
-            for (MobDrop o : mOutputs) {
-                int chance = o.chance;
-                if (o.playerOnly) {
-                    chance = (int) ((double) chance * Config.MobHandler.playerOnlyDropsModifier);
-                    if (chance < 1) chance = 1;
-                }
-                int amount = o.stack.stackSize;
-                if (o.lootable && lootinglevel > 0) {
-                    chance += lootinglevel * 5000;
-                    if (chance > 10000) {
-                        int div = (int) Math.ceil(chance / 10000d);
-                        amount *= div;
-                        chance /= div;
-                    }
-                }
-                if (chance == 10000 || rnd.nextInt(10000) < chance) {
-                    ItemStack s = o.stack.copy();
-                    s.stackSize = amount;
-                    if (o.enchantable != null) EnchantmentHelper.addRandomEnchantment(rnd, s, o.enchantable);
-                    if (o.damages != null) {
-                        int rChance = rnd.nextInt(mMaxDamageChance);
-                        int cChance = 0;
-                        for (Map.Entry<Integer, Integer> damage : o.damages.entrySet()) {
-                            cChance += damage.getValue();
-                            if (rChance <= cChance) {
-                                s.setItemDamage(damage.getKey());
-                                break;
-                            }
-                        }
-                    }
-                    stacks.add(s);
-                }
-            }
-
-            if (LoaderReference.InfernalMobs) {
-                InfernalMobsCore infernalMobsCore = InfernalMobsCore.instance();
-                if (infernalityAllowed && mEUt * 8 < MTE.getMaxInputVoltage()
-                    && !infernalMobsCore.getDimensionBlackList()
-                        .contains(
-                            MTE.getBaseMetaTileEntity()
-                                .getWorld().provider.dimensionId)) {
-                    int p = 0;
-                    int mods = 0;
-                    if (alwaysinfernal
-                        || (preferInfernalDrops && rnd.nextInt(infernalMobsCore.getEliteRarity()) == 0)) {
-                        p = 1;
-                        if (rnd.nextInt(infernalMobsCore.getUltraRarity()) == 0) {
-                            p = 2;
-                            if (rnd.nextInt(infernalMobsCore.getInfernoRarity()) == 0) p = 3;
-                        }
-                    }
-                    ArrayList<ItemStack> infernalstacks = null;
-                    if (p > 0) if (p == 1) {
-                        infernalstacks = infernalMobsCore.getDropIdListElite();
-                        mods = infernalMobsCore.getMinEliteModifiers();
-                    } else if (p == 2) {
-                        infernalstacks = infernalMobsCore.getDropIdListUltra();
-                        mods = infernalMobsCore.getMinUltraModifiers();
-                    } else {
-                        infernalstacks = infernalMobsCore.getDropIdListInfernal();
-                        mods = infernalMobsCore.getMinInfernoModifiers();
-                    }
-                    if (infernalstacks != null) {
-                        ItemStack infernalstack = infernalstacks.get(rnd.nextInt(infernalstacks.size()))
-                            .copy();
-                        // noinspection ConstantConditions
-                        EnchantmentHelper.addRandomEnchantment(
-                            rnd,
-                            infernalstack,
-                            infernalstack.getItem()
-                                .getItemEnchantability());
-                        stacks.add(infernalstack);
-                        MTE.lEUt *= 8L;
-                        MTE.mMaxProgresstime *= mods * InfernalMobsCore.instance()
-                            .getMobModHealthFactor();
-                    }
-                }
-            }
-
-            return stacks.toArray(new ItemStack[0]);
-        }
-    }
-
-    public static class fakeRand extends Random {
-
-        private static class nexter {
-
-            private final int type;
-            private final int bound;
-            private int next;
-
-            public nexter(int type, int bound) {
-                this.next = 0;
-                this.bound = bound;
-                this.type = type;
-            }
-
-            private int getType() {
-                return type;
-            }
-
-            private boolean getBoolean() {
-                return next == 1;
-            }
-
-            private int getInt() {
-                return next;
-            }
-
-            private float getFloat() {
-                return next * 0.1f;
-            }
-
-            private boolean next() {
-                next++;
-                return next >= bound;
-            }
-        }
-
-        private final ArrayList<nexter> nexts = new ArrayList<>();
-        private int walkCounter = 0;
-        private double chance;
-        private boolean exceptionOnEnchantTry = false;
-        private int maxWalkCount = -1;
-        private float forceFloatValue = -1.f;
-
-        @Override
-        public int nextInt(int bound) {
-            if (exceptionOnEnchantTry && bound == Enchantment.enchantmentsBookList.length) return -1;
-            if (nexts.size() <= walkCounter) { // new call
-                if (maxWalkCount == walkCounter) {
-                    return 0;
-                }
-                nexts.add(new nexter(0, bound));
-                walkCounter++;
-                chance /= bound;
-                return 0;
-            }
-            chance /= bound;
-            return nexts.get(walkCounter++)
-                .getInt();
-        }
-
-        @Override
-        public float nextFloat() {
-            if (forceFloatValue != -1f) return forceFloatValue;
-            if (nexts.size() <= walkCounter) { // new call
-                if (maxWalkCount == walkCounter) {
-                    return 0f;
-                }
-                nexts.add(new nexter(2, 10));
-                walkCounter++;
-                chance /= 10;
-                return 0f;
-            }
-            chance /= 10;
-            return nexts.get(walkCounter++)
-                .getFloat();
-        }
-
-        @Override
-        public boolean nextBoolean() {
-            if (nexts.size() <= walkCounter) { // new call
-                if (maxWalkCount == walkCounter) {
-                    return false;
-                }
-                nexts.add(new nexter(1, 2));
-                walkCounter++;
-                chance /= 2;
-                return false;
-            }
-            chance /= 2;
-            return nexts.get(walkCounter++)
-                .getBoolean();
-        }
-
-        public void newRound() {
-            walkCounter = 0;
-            nexts.clear();
-            chance = 1d;
-            maxWalkCount = -1;
-            exceptionOnEnchantTry = false;
-            forceFloatValue = -1f;
-        }
-
-        public boolean nextRound() {
-            walkCounter = 0;
-            chance = 1d;
-            while (nexts.size() > 0 && nexts.get(nexts.size() - 1)
-                .next()) nexts.remove(nexts.size() - 1);
-            return nexts.size() > 0;
-        }
-    }
-
-    private static class dropinstance {
-
-        public boolean isDamageRandomized = false;
-        public HashMap<Integer, Integer> damagesPossible = new HashMap<>();
-        public boolean isEnchatmentRandomized = false;
-        public int enchantmentLevel = 0;
-        public final ItemStack stack;
-        public final GT_Utility.ItemId itemId;
-        private double dropchance = 0d;
-        private int dropcount = 1;
-        private final droplist owner;
-
-        public dropinstance(ItemStack s, droplist owner) {
-            this.owner = owner;
-            stack = s;
-            itemId = GT_Utility.ItemId.createNoCopy(stack);
-        }
-
-        public int getchance(int chancemodifier) {
-            dropchance = (double) Math.round(dropchance * 100000) / 100000d;
-            return (int) (dropchance * chancemodifier);
-        }
-
-        @Override
-        public int hashCode() {
-            return itemId.hashCode();
-        }
-    }
-
-    public static class droplist {
-
-        private final ArrayList<dropinstance> drops = new ArrayList<>();
-        private final HashMap<GT_Utility.ItemId, Integer> dropschecker = new HashMap<>();
-
-        public dropinstance add(dropinstance i, double chance) {
-            if (contains(i)) {
-                int ssize = i.stack.stackSize;
-                i = get(dropschecker.get(i.itemId));
-                i.dropchance += chance * ssize;
-                i.dropcount += ssize;
-                return i;
-            }
-            drops.add(i);
-            i.dropchance += chance * i.stack.stackSize;
-            i.dropcount += i.stack.stackSize - 1;
-            i.stack.stackSize = 1;
-            dropschecker.put(i.itemId, drops.size() - 1);
-            return i;
-        }
-
-        public dropinstance get(int index) {
-            return drops.get(index);
-        }
-
-        public dropinstance get(dropinstance i) {
-            if (!contains(i)) return null;
-            return get(dropschecker.get(i.itemId));
-        }
-
-        public boolean contains(dropinstance i) {
-            return dropschecker.containsKey(i.itemId);
-        }
-
-        public boolean contains(ItemStack stack) {
-            return dropschecker.containsKey(GT_Utility.ItemId.createNoCopy(stack));
-        }
-
-        public boolean isEmpty() {
-            return drops.isEmpty();
-        }
-
-        public int size() {
-            return drops.size();
-        }
-
-        public int indexOf(dropinstance i) {
-            if (!contains(i)) return -1;
-            return dropschecker.get(i.itemId);
-        }
-    }
-
-    private static class dropCollector {
-
-        final HashMap<GT_Utility.ItemId, Integer> damagableChecker = new HashMap<>();
-        private boolean booksAlwaysRandomlyEnchanted = false;
-
-        public void addDrop(droplist fdrops, ArrayList<EntityItem> listToParse, double chance) {
-            for (EntityItem entityItem : listToParse) {
-                ItemStack ostack = entityItem.getEntityItem();
-                if (ostack == null) continue;
-                dropinstance drop;
-                boolean randomchomenchantdetected = ostack.hasTagCompound()
-                    && ostack.stackTagCompound.hasKey(randomEnchantmentDetectedString);
-                int randomenchantmentlevel = 0;
-                if (randomchomenchantdetected) {
-                    randomenchantmentlevel = ostack.stackTagCompound.getInteger(randomEnchantmentDetectedString);
-                    ostack.stackTagCompound.removeTag("ench");
-                    ostack.stackTagCompound.setInteger(randomEnchantmentDetectedString, 0);
-                }
-                if ((booksAlwaysRandomlyEnchanted || randomchomenchantdetected)
-                    && Items.enchanted_book == ostack.getItem()) {
-                    NBTTagCompound tagCompound = (NBTTagCompound) ostack.stackTagCompound.copy();
-                    tagCompound.removeTag("StoredEnchantments");
-                    ostack = new ItemStack(Items.book, ostack.stackSize, 0);
-                    if (!tagCompound.hasNoTags()) ostack.stackTagCompound = tagCompound;
-                    if (randomenchantmentlevel == 0) randomenchantmentlevel = 1;
-                    randomchomenchantdetected = true;
-                }
-                boolean randomdamagedetected = false;
-                int newdamage = -1;
-                if (ostack.isItemStackDamageable()) {
-                    int odamage = ostack.getItemDamage();
-                    ostack.setItemDamage(1);
-                    GT_Utility.ItemId id = GT_Utility.ItemId.createNoCopy(ostack);
-                    damagableChecker.putIfAbsent(id, odamage);
-                    int check = damagableChecker.get(id);
-                    if (check != odamage) {
-                        randomdamagedetected = true;
-                        newdamage = odamage;
-                        ostack.setItemDamage(check);
-                    } else ostack.setItemDamage(odamage);
-                }
-                drop = fdrops.