Add "Mob Drops" NEI page + Extreme Extermination Chamber (#1)

* First commit

* Mixins

* Merge the same items with diffrent damage

* Faster random in NEI

* More accuracy ?

* Update ClientProxy.java

* Renaming

* Update buildscript

* Use reserved MTE ID's

* EEC work

* Rework NEI page

* Fix inaccurate chances

* Basic equipment spawn

* Add config options

* Translations

* Add infernal drops

* Witchery fix

* Forestry fixes

* More fixes

* Default blacklist

* NEI sorting

* Comment out testing deps

* Clientsided check

* Blood Magic support

* LoaderReference

* Check if peacefull is allowed

* Add some XP output

* Add recipe

* Send Server config to Client

* Add command to reload config

* Translations

* Process MT additions

1 files changed, 592 insertions, 0 deletions

diff --git a/src/main/java/kubatech/nei/Mob_Handler.java b/src/main/java/kubatech/nei/Mob_Handler.java
new file mode 100644
index 0000000000..cd172a8797
--- /dev/null
+++ b/src/main/java/kubatech/nei/Mob_Handler.java
@@ -0,0 +1,592 @@
+/*
+ * KubaTech - Gregtech Addon
+ * Copyright (C) 2022  kuba6000
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+package kubatech.nei;
+
+import static kubatech.nei.Mob_Handler.Translations.*;
+import static org.lwjgl.opengl.GL11.GL_MODELVIEW_STACK_DEPTH;
+
+import codechicken.lib.gui.GuiDraw;
+import codechicken.nei.NEIClientUtils;
+import codechicken.nei.PositionedStack;
+import codechicken.nei.recipe.*;
+import cpw.mods.fml.common.event.FMLInterModComms;
+import crazypants.enderio.EnderIO;
+import crazypants.enderio.machine.spawner.BlockPoweredSpawner;
+import gregtech.api.util.GT_Utility;
+import java.awt.*;
+import java.lang.reflect.Field;
+import java.nio.FloatBuffer;
+import java.util.*;
+import java.util.List;
+import kubatech.api.LoaderReference;
+import kubatech.api.utils.FastRandom;
+import kubatech.api.utils.InfernalHelper;
+import kubatech.api.utils.ModUtils;
+import kubatech.common.tileentity.gregtech.multiblock.GT_MetaTileEntity_ExtremeExterminationChamber;
+import kubatech.kubatech;
+import kubatech.loaders.MobRecipeLoader;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.ScaledResolution;
+import net.minecraft.client.gui.inventory.GuiInventory;
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelBox;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.entity.Render;
+import net.minecraft.client.renderer.entity.RenderManager;
+import net.minecraft.client.renderer.entity.RendererLivingEntity;
+import net.minecraft.enchantment.EnchantmentHelper;
+import net.minecraft.entity.EntityList;
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.nbt.NBTTagString;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.StatCollector;
+import org.lwjgl.BufferUtils;
+import org.lwjgl.input.Mouse;
+import org.lwjgl.opengl.GL11;
+
+public class Mob_Handler extends TemplateRecipeHandler {
+
+    enum Translations {
+        NORMAL_DROPS,
+        RARE_DROPS,
+        ADDITIONAL_DROPS,
+        INFERNAL_DROPS,
+        INFERNAL_CANNOT,
+        INFERNAL_CAN,
+        INFERNAL_ALWAYS,
+        CHANCE,
+        AVERAGE_REMINDER,
+        MOD,
+        MAX_HEALTH,
+        ;
+        final String key;
+
+        Translations() {
+            key = "mobhandler." + this.name().toLowerCase();
+        }
+
+        public String get() {
+            return StatCollector.translateToLocal(key);
+        }
+
+        public String get(Object... args) {
+            return StatCollector.translateToLocalFormatted(key, args);
+        }
+
+        public String getKey() {
+            return key;
+        }
+
+        @Override
+        public String toString() {
+            return get();
+        }
+    }
+
+    private static final Mob_Handler instance = new Mob_Handler();
+    private static final List<MobCachedRecipe> cachedRecipes = new ArrayList<>();
+    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) {
+        List<MobPositionedStack> positionedStacks = new ArrayList<>();
+        int xorigin = 7,
+                xoffset = xorigin,
+                yoffset = 95,
+                normaldrops = 0,
+                raredrops = 0,
+                additionaldrops = 0,
+                infernaldrops = 0;
+        MobRecipeLoader.MobDrop.DropType i = null;
+        for (MobRecipeLoader.MobDrop d : drop) {
+            if (i == d.type) {
+                xoffset += itemXShift;
+                if (xoffset >= xorigin + (itemXShift * itemsPerRow)) {
+                    xoffset = xorigin;
+                    yoffset += itemYShift;
+                }
+            }
+            if (i != null && i != d.type) {
+                xoffset = xorigin;
+                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
+            positionedStacks.add(new MobPositionedStack(
+                    d.stack.copy(),
+                    xoffset,
+                    yoffset,
+                    d.type,
+                    d.chance,
+                    d.enchantable,
+                    d.damages != null ? new ArrayList<>(d.damages.keySet()) : null));
+        }
+        instance.addRecipeInt(e, positionedStacks, normaldrops, raredrops, additionaldrops, infernaldrops);
+    }
+
+    private void addRecipeInt(
+            EntityLiving e,
+            List<Mob_Handler.MobPositionedStack> l,
+            int normaldrops,
+            int raredrops,
+            int additionaldrops,
+            int infernalDrops) {
+        cachedRecipes.add(new MobCachedRecipe(e, l, normaldrops, raredrops, additionaldrops, infernalDrops));
+    }
+
+    public static void clearRecipes() {
+        cachedRecipes.clear();
+    }
+
+    public static void sortCachedRecipes() {
+        cachedRecipes.sort((o1, o2) -> {
+            boolean m1 = o1.mod.equals("Minecraft");
+            boolean m2 = o2.mod.equals("Minecraft");
+            if (m1 && !m2) return -1;
+            else if (!m1 && m2) return 1;
+            if (!o1.mod.equals(o2.mod)) return o1.mod.compareTo(o2.mod);
+            else return o1.localizedName.compareTo(o2.localizedName);
+        });
+    }
+
+    public Mob_Handler() {
+        this.transferRects.add(new RecipeTransferRect(new Rectangle(7, 62, 16, 16), getOverlayIdentifier()));
+        if (!NEI_Config.isAdded) {
+            FMLInterModComms.sendRuntimeMessage(
+                    kubatech.instance,
+                    "NEIPlugins",
+                    "register-crafting-handler",
+                    "kubatech@" + getRecipeName() + "@" + getOverlayIdentifier());
+            GuiCraftingRecipe.craftinghandlers.add(this);
+            GuiUsageRecipe.usagehandlers.add(this);
+        }
+    }
+
+    @Override
+    public TemplateRecipeHandler newInstance() {
+        return new Mob_Handler();
+    }
+
+    @Override
+    public String getOverlayIdentifier() {
+        return "kubatech.mobhandler";
+    }
+
+    @Override
+    public String getGuiTexture() {
+        return "kubatech:textures/gui/MobHandler.png";
+    }
+
+    private static final Field mainmodelfield;
+
+    static {
+        try {
+            mainmodelfield = RendererLivingEntity.class.getDeclaredField(
+                    ModUtils.isDeobfuscatedEnvironment ? "mainModel" : "field_77045_g");
+            mainmodelfield.setAccessible(true);
+        } catch (NoSuchFieldException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public void drawBackground(int recipe) {
+        GL11.glColor4f(1f, 1f, 1f, 1f);
+        GuiDraw.changeTexture(getGuiTexture());
+        GuiDraw.drawTexturedModalRect(0, 0, 0, 0, 168, 192);
+
+        MobCachedRecipe currentrecipe = ((MobCachedRecipe) arecipes.get(recipe));
+
+        {
+            int x = 6, y = 94, yshift = nextRowYShift;
+            if (currentrecipe.normalOutputsCount > 0) {
+                for (int i = 0; i < ((currentrecipe.normalOutputsCount - 1) / itemsPerRow) + 1; i++) {
+                    GuiDraw.drawTexturedModalRect(x, y + (18 * i), 0, 192, 144, 18);
+                    if (i > 0) GuiDraw.drawTexturedModalRect(x, y + ((18 * i) - 1), 0, 193, 144, 2);
+                }
+                y += yshift + ((currentrecipe.normalOutputsCount - 1) / itemsPerRow) * 18;
+            }
+            if (currentrecipe.rareOutputsCount > 0) {
+                for (int i = 0; i < ((currentrecipe.rareOutputsCount - 1) / itemsPerRow) + 1; i++) {
+                    GuiDraw.drawTexturedModalRect(x, y + (18 * i), 0, 192, 144, 18);
+                    if (i > 0) GuiDraw.drawTexturedModalRect(x, y + ((18 * i) - 1), 0, 193, 144, 2);
+                }
+                y += yshift + ((currentrecipe.rareOutputsCount - 1) / itemsPerRow) * 18;
+            }
+            if (currentrecipe.additionalOutputsCount > 0) {
+                for (int i = 0; i < ((currentrecipe.additionalOutputsCount - 1) / itemsPerRow) + 1; i++) {
+                    GuiDraw.drawTexturedModalRect(x, y + (18 * i), 0, 192, 144, 18);
+                    if (i > 0) GuiDraw.drawTexturedModalRect(x, y + ((18 * i) - 1), 0, 193, 144, 2);
+                }
+                y += yshift + ((currentrecipe.additionalOutputsCount - 1) / itemsPerRow) * 18;
+            }
+            if (currentrecipe.infernalOutputsCount > 0) {
+                for (int i = 0; i < ((currentrecipe.infernalOutputsCount - 1) / itemsPerRow) + 1; i++) {
+                    GuiDraw.drawTexturedModalRect(x, y + (18 * i), 0, 192, 144, 18);
+                    if (i > 0) GuiDraw.drawTexturedModalRect(x, y + ((18 * i) - 1), 0, 193, 144, 2);
+                }
+            }
+        }
+
+        GL11.glEnable(GL11.GL_DEPTH_TEST);
+        GL11.glColor4f(1f, 1f, 1f, 1f);
+
+        Minecraft mc = Minecraft.getMinecraft();
+
+        ScaledResolution scale = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
+
+        int width = scale.getScaledWidth();
+        int height = scale.getScaledHeight();
+        int mouseX = Mouse.getX() * width / mc.displayWidth;
+        int mouseZ = height - Mouse.getY() * height / mc.displayHeight - 1;
+
+        // Get current x,y from matrix
+        FloatBuffer buf = BufferUtils.createFloatBuffer(16);
+        GL11.glGetFloat(GL11.GL_MODELVIEW_MATRIX, buf);
+        float x = buf.get(12);
+        float y = buf.get(13);
+
+        int stackdepth = GL11.glGetInteger(GL_MODELVIEW_STACK_DEPTH);
+
+        GL11.glPushMatrix();
+
+        ItemStack s = getIngredientStacks(recipe).get(0).item;
+        try {
+            EntityLiving e = currentrecipe.mob;
+            float eheight = e.height;
+            float ewidth = e.width;
+
+            Render r = RenderManager.instance.getEntityRenderObject(e);
+            if (r instanceof RendererLivingEntity && mainmodelfield != null) {
+                ModelBase mainmodel = (ModelBase) mainmodelfield.get(r);
+                for (Object box : mainmodel.boxList) {
+                    if (box instanceof ModelRenderer) {
+                        float minY = 999f;
+                        float minX = 999f;
+                        float maxY = -999f;
+                        float maxX = -999f;
+                        for (Object cube : ((ModelRenderer) box).cubeList) {
+                            if (cube instanceof ModelBox) {
+                                if (minY > ((ModelBox) cube).posY1) minY = ((ModelBox) cube).posY1;
+                                if (minX > ((ModelBox) cube).posX1) minX = ((ModelBox) cube).posX1;
+                                if (maxY < ((ModelBox) cube).posY2) maxY = ((ModelBox) cube).posY2;
+                                if (maxX < ((ModelBox) cube).posX2) maxX = ((ModelBox) cube).posX2;
+                            }
+                        }
+                        float cubeheight = (maxY - minY) / 10f;
+                        float cubewidth = (maxX - minX) / 10f;
+                        if (eheight < cubeheight) eheight = cubeheight;
+                        if (ewidth < cubewidth) ewidth = cubewidth;
+                    }
+                }
+            }
+
+            int desiredheight = 27;
+            int scaled = (int) (desiredheight / eheight);
+            //
+            // int maxwidth = 15;
+            // scaled = (int) Math.min(scaled, maxwidth / ewidth);
+
+            int mobx = 30, moby = 50;
+            e.setPosition(mc.thePlayer.posX + 5, mc.thePlayer.posY, mc.thePlayer.posZ);
+            // ARGS: x, y, scale, rot, rot, entity
+            GuiInventory.func_147046_a(
+                    mobx, moby, scaled, (float) (x + mobx) - mouseX, (float) (y + moby - eheight * scaled) - mouseZ, e);
+        } catch (Throwable ex) {
+            Tessellator tes = Tessellator.instance;
+            try {
+                tes.draw();
+            } catch (Exception ignored) {
+            }
+        }
+
+        stackdepth -= GL11.glGetInteger(GL_MODELVIEW_STACK_DEPTH);
+        if (stackdepth < 0) for (; stackdepth < 0; stackdepth++) GL11.glPopMatrix();
+
+        GL11.glDisable(GL11.GL_DEPTH_TEST);
+    }
+
+    @Override
+    public void drawForeground(int recipe) {
+        MobCachedRecipe currentrecipe = ((MobCachedRecipe) arecipes.get(recipe));
+        int y = 7, yshift = 10, x = 57;
+        GuiDraw.drawString(currentrecipe.localizedName, x, y, 0xFF555555, false);
+        if (Minecraft.getMinecraft().gameSettings.advancedItemTooltips && NEIClientUtils.shiftKey())
+            GuiDraw.drawString(currentrecipe.mobname, x, y += yshift, 0xFF555555, false);
+        GuiDraw.drawString(MOD.get() + currentrecipe.mod, x, y += yshift, 0xFF555555, false);
+        GuiDraw.drawString(MAX_HEALTH.get() + currentrecipe.maxHealth, x, y += yshift, 0xFF555555, false);
+        switch (currentrecipe.infernaltype) {
+            case -1:
+                break;
+            case 0:
+                GuiDraw.drawString(INFERNAL_CANNOT.get(), x, y += yshift, 0xFF555555, false);
+                break;
+            case 1:
+                GuiDraw.drawString(INFERNAL_CAN.get(), x, y += yshift, 0xFFFF0000, false);
+                break;
+            case 2:
+                GuiDraw.drawString(INFERNAL_ALWAYS.get(), x, y += yshift, 0xFFFF0000, false);
+                break;
+        }
+        MobRecipeLoader.MobRecipe MBRecipe =
+                GT_MetaTileEntity_ExtremeExterminationChamber.MobNameToRecipeMap.get(currentrecipe.mobname);
+        if (MBRecipe != null) {
+            GuiDraw.drawString(
+                    GT_Utility.trans("153", "Usage: ") + GT_Utility.formatNumbers(MBRecipe.mEUt) + " EU/t",
+                    x,
+                    y += yshift,
+                    0xFF555555,
+                    false);
+            GuiDraw.drawString(
+                    GT_Utility.trans("158", "Time: ") + GT_Utility.formatNumbers(MBRecipe.mDuration / 20d) + " secs",
+                    x,
+                    y += yshift,
+                    0xFF555555,
+                    false);
+        }
+
+        x = 6;
+        y = 83;
+        yshift = nextRowYShift;
+        if (currentrecipe.normalOutputsCount > 0) {
+            GuiDraw.drawString(NORMAL_DROPS.get(), x, y, 0xFF555555, false);
+            y += yshift + ((currentrecipe.normalOutputsCount - 1) / itemsPerRow) * 18;
+        }
+        if (currentrecipe.rareOutputsCount > 0) {
+            GuiDraw.drawString(RARE_DROPS.get(), x, y, 0xFF555555, false);
+            y += yshift + ((currentrecipe.rareOutputsCount - 1) / itemsPerRow) * 18;
+        }
+        if (currentrecipe.additionalOutputsCount > 0) {
+            GuiDraw.drawString(ADDITIONAL_DROPS.get(), x, y, 0xFF555555, false);
+            y += yshift + ((currentrecipe.additionalOutputsCount - 1) / itemsPerRow) * 18;
+        }
+        if (currentrecipe.infernalOutputsCount > 0) {
+            GuiDraw.drawString(INFERNAL_DROPS.get(), x, y, 0xFF555555, false);
+            y += yshift + ((currentrecipe.additionalOutputsCount - 1) / itemsPerRow) * 18;
+        }
+        yshift = 10;
+    }
+
+    @Override
+    public String getRecipeName() {
+        return "Mob Drops";
+    }
+
+    @Override
+    public IUsageHandler getUsageAndCatalystHandler(String inputId, Object... ingredients) {
+        if (inputId.equals("item")) {
+            TemplateRecipeHandler handler = newInstance();
+            ItemStack candidate = (ItemStack) ingredients[0];
+            if (RecipeCatalysts.containsCatalyst(handler, candidate)) {
+                handler.loadCraftingRecipes(getOverlayIdentifier(), (Object) null);
+                return handler;
+            }
+        }
+        return this.getUsageHandler(inputId, ingredients);
+    }
+
+    @Override
+    public void loadCraftingRecipes(String outputId, Object... results) {
+        if (outputId.equals(getOverlayIdentifier())) {
+            arecipes.addAll(cachedRecipes);
+            return;
+        }
+        super.loadCraftingRecipes(outputId, results);
+    }
+
+    @Override
+    public void loadCraftingRecipes(ItemStack result) {
+        for (MobCachedRecipe r : cachedRecipes) if (r.contains(r.mOutputs, result)) arecipes.add(r);
+    }
+
+    @Override
+    public void loadUsageRecipes(ItemStack ingredient) {
+        if (LoaderReference.EnderIO && ingredient.getItem() == Item.getItemFromBlock(EnderIO.blockPoweredSpawner)) {
+            if (!ingredient.hasTagCompound() || !ingredient.getTagCompound().hasKey("mobType")) {
+                loadCraftingRecipes(getOverlayIdentifier(), (Object) null);
+                return;
+            }
+            for (MobCachedRecipe r : cachedRecipes)
+                if (r.mInput.stream()
+                        .anyMatch(s -> s.getItem() == ingredient.getItem()
+                                && Objects.equals(
+                                        s.getTagCompound().getString("mobType"),
+                                        ingredient.getTagCompound().getString("mobType")))) arecipes.add(r);
+        } else
+            for (MobCachedRecipe r : cachedRecipes)
+                if (r.mInput.stream().anyMatch(ingredient::isItemEqual)) arecipes.add(r);
+    }
+
+    @Override
+    public void onUpdate() {
+        cycleTicksStatic++;
+    }
+
+    public static class MobPositionedStack extends PositionedStack {
+
+        public final MobRecipeLoader.MobDrop.DropType type;
+        public final int chance;
+        public final boolean enchantable;
+        public final boolean randomdamage;
+        public final List<Integer> damages;
+        public final int enchantmentLevel;
+        private final Random rand;
+
+        public MobPositionedStack(
+                Object object,
+                int x,
+                int y,
+                MobRecipeLoader.MobDrop.DropType type,
+                int chance,
+                Integer enchantable,
+                List<Integer> damages) {
+            super(object, x, y, false);
+            rand = new FastRandom();
+            this.type = type;
+            this.chance = chance;
+            this.enchantable = enchantable != null;
+            if (this.enchantable) enchantmentLevel = enchantable;
+            else enchantmentLevel = 0;
+            this.randomdamage = damages != null;
+            if (this.randomdamage) this.damages = damages;
+            else this.damages = null;
+            NBTTagList extratooltip = new NBTTagList();
+
+            if (chance != 10000)
+                extratooltip.appendTag(new NBTTagString(
+                        EnumChatFormatting.RESET + CHANCE.get() + (chance / 100) + "." + (chance % 100) + "%"));
+            extratooltip.appendTag(new NBTTagString(EnumChatFormatting.RESET + AVERAGE_REMINDER.get()));
+
+            NBTTagCompound itemtag = this.items[0].getTagCompound();
+            if (itemtag == null) itemtag = new NBTTagCompound();
+            NBTTagCompound display = new NBTTagCompound();
+            if (itemtag.hasKey("display")) {
+                display = itemtag.getCompoundTag("display");
+                if (display.hasKey("Lore")) {
+                    NBTTagList lore = display.getTagList("Lore", 8);
+                    for (int i = 0; i < extratooltip.tagCount(); i++)
+                        lore.appendTag(new NBTTagString(extratooltip.getStringTagAt(i)));
+                    display.setTag("Lore", lore);
+                } else display.setTag("Lore", extratooltip);
+            } else display.setTag("Lore", extratooltip);
+            itemtag.setTag("display", display);
+            this.items[0].setTagCompound(itemtag);
+            this.item.setTagCompound((NBTTagCompound) itemtag.copy());
+            setPermutationToRender(0);
+        }
+
+        @Override
+        public void setPermutationToRender(int index) {
+            if (this.item == null) this.item = this.items[0].copy();
+            if (enchantable) {
+                if (this.item.getItem() == Items.enchanted_book) this.item = this.items[0].copy();
+                this.item.getTagCompound().removeTag("ench");
+                EnchantmentHelper.addRandomEnchantment(rand, this.item, enchantmentLevel);
+            }
+            if (randomdamage) this.item.setItemDamage(damages.get(rand.nextInt(damages.size())));
+        }
+    }
+
+    private class MobCachedRecipe extends TemplateRecipeHandler.CachedRecipe {
+
+        public final EntityLiving mob;
+        public final List<PositionedStack> mOutputs;
+        public final List<ItemStack> mInput;
+        public final String mobname;
+        public final int infernaltype;
+        public final PositionedStack ingredient;
+        public final String localizedName;
+        public final String mod;
+        public final float maxHealth;
+        public final int normalOutputsCount;
+        public final int rareOutputsCount;
+        public final int additionalOutputsCount;
+        public final int infernalOutputsCount;
+
+        public MobCachedRecipe(
+                EntityLiving mob,
+                List<MobPositionedStack> mOutputs,
+                int normalOutputsCount,
+                int rareOutputsCount,
+                int additionalOutputsCount,
+                int infernalOutputsCount) {
+            super();
+            String classname = mob.getClass().getName();
+            this.mod = ModUtils.getModNameFromClassName(classname);
+            this.mob = mob;
+            this.maxHealth = mob.getMaxHealth();
+            this.mOutputs = new ArrayList<>(mOutputs.size());
+            this.mOutputs.addAll(mOutputs);
+            this.normalOutputsCount = normalOutputsCount;
+            this.rareOutputsCount = rareOutputsCount;
+            this.additionalOutputsCount = additionalOutputsCount;
+            this.infernalOutputsCount = infernalOutputsCount;
+            this.mInput = new ArrayList<>();
+            int id = EntityList.getEntityID(mob);
+            mobname = EntityList.getEntityString(mob);
+            localizedName = StatCollector.translateToLocal("entity." + mobname + ".name");
+            if (id != 0) {
+                this.mInput.add(new ItemStack(Items.spawn_egg, 1, id));
+                this.mInput.add(new ItemStack(Blocks.mob_spawner, 1, id));
+            }
+            if (LoaderReference.EnderIO) {
+                ItemStack s = new ItemStack(EnderIO.blockPoweredSpawner, 1);
+                NBTTagCompound nbt = new NBTTagCompound();
+                BlockPoweredSpawner.writeMobTypeToNBT(nbt, mobname);
+                s.setTagCompound(nbt);
+                this.mInput.add(0, s);
+            } else if (id == 0) this.mInput.add(new ItemStack(Items.spawn_egg, 1, 0)); // ???
+            ingredient = new PositionedStack(this.mInput.get(0), 38, 44, false);
+
+            if (!LoaderReference.InfernalMobs) infernaltype = -1; // not supported
+            else {
+                if (!InfernalHelper.isClassAllowed(mob)) infernaltype = 0; // not allowed
+                else if (InfernalHelper.checkEntityClassForced(mob)) infernaltype = 2; // forced
+                else infernaltype = 1; // normal
+            }
+        }
+
+        @Override
+        public PositionedStack getIngredient() {
+            return ingredient;
+        }
+
+        @Override
+        public PositionedStack getResult() {
+            return null;
+        }
+
+        @Override
+        public List<PositionedStack> getOtherStacks() {
+            if (cycleTicksStatic % 10 == 0) mOutputs.forEach(p -> p.setPermutationToRender(0));
+            return mOutputs;
+        }
+    }
+}