Move Industrial Apiary to gregtech (#1107)

* Industrial Apiary

* Make Forestry not required.

* Add support for gendustry upgrades and lower energy demand

* Add item validation to input slots and fix battery + special slots

* Automation upgrade support and bug fixes

* Better canWork check and flower detection

* GUI work

* Better detection of modifier update

* Add button to cancel process

* Add textures

* Tooltip changes

* Add convert crafting

* Make top and sides glow

* Bug fix

* New textures

* Add bee effects

* Make all tooltips translatable

* Implement GT Apiary Upgrades

* Prevent inserting too many upgrades

* Just require gendustry instead of checking it everywhere

* Add blacklist (bug fix) and use hashsets instead of arrays

* Cache beemember to do effects

* Make blacklist automatic

* Add acceleration upgrades for all tiers (LV -> UV)

* Lock the machine to maxspeed by default

* Correct required energy in info tooltip

* Use isUpgrade method instead of manually checking

* Lower amperage to 4

* Save locked speed to nbt

2 files changed, 444 insertions, 0 deletions

diff --git a/src/main/java/gregtech/common/gui/GT_Container_IndustrialApiary.java b/src/main/java/gregtech/common/gui/GT_Container_IndustrialApiary.java
new file mode 100644
index 0000000000..45d455ff03
--- /dev/null
+++ b/src/main/java/gregtech/common/gui/GT_Container_IndustrialApiary.java
@@ -0,0 +1,292 @@
+package gregtech.common.gui;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import forestry.api.core.ForestryAPI;
+import forestry.api.core.IErrorState;
+import gregtech.api.gui.GT_ContainerMetaTile_Machine;
+import gregtech.api.gui.GT_Slot_Holo;
+import gregtech.api.gui.GT_Slot_Output;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.util.GT_ApiaryUpgrade;
+import gregtech.api.util.GT_Utility;
+import gregtech.common.tileentities.machines.basic.GT_MetaTileEntity_IndustrialApiary;
+import net.bdew.gendustry.api.items.IApiaryUpgrade;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.ICrafting;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.StatCollector;
+
+import java.util.ArrayList;
+
+public class GT_Container_IndustrialApiary extends GT_ContainerMetaTile_Machine {
+
+    GT_Slot_Holo slotItemTransferToggle;
+    GT_Slot_Holo slotSpeedToggle;
+    GT_Slot_Holo slotPollenToggle;
+    GT_Slot_Holo slotCancelProcess;
+    Slot slotBattery;
+    Slot slotSpecial;
+
+    boolean mItemTransfer;
+    boolean mStuttering;
+
+    int mSpeed = 0; // scale 0 - 8
+    boolean mLockedSpeed = true;
+    boolean retrievePollen;
+
+    ArrayList<String> mErrorStates = new ArrayList<>(50);
+
+    public GT_Container_IndustrialApiary(InventoryPlayer aInventoryPlayer, IGregTechTileEntity aTileEntity) {
+        super(aInventoryPlayer, aTileEntity);
+    }
+
+    @Override
+    public void addSlots(InventoryPlayer aInventoryPlayer) {
+        addSlotToContainer(slotItemTransferToggle = new GT_Slot_Holo(mTileEntity, 0, 8, 63, false, true, 1));
+        addSlotToContainer(slotSpeedToggle = new GT_Slot_Holo(mTileEntity, 0, 26, 63, false, true, 1));
+        addSlotToContainer(slotPollenToggle = new GT_Slot_Holo(mTileEntity, 0, 8, 45, false, true, 1));
+        addSlotToContainer(slotCancelProcess = new GT_Slot_Holo(mTileEntity, 0, 8, 27, false, true, 1));
+        int tStartIndex = 5;
+
+        addSlotToContainer(new ApiarySlot(this.mTileEntity, tStartIndex++, 37, 22));
+        addSlotToContainer(new ApiarySlot(this.mTileEntity, tStartIndex++, 37, 42));
+
+        addSlotToContainer(new ApiarySlot(this.mTileEntity, tStartIndex++, 62, 24));
+        addSlotToContainer(new ApiarySlot(this.mTileEntity, tStartIndex++, 80, 24));
+        addSlotToContainer(new ApiarySlot(this.mTileEntity, tStartIndex++, 62, 42));
+        addSlotToContainer(new ApiarySlot(this.mTileEntity, tStartIndex++, 80, 42));
+
+        for(int i = 107; i <= 143; i += 18)
+            for(int j = 6; j <= 42; j += 18)
+                addSlotToContainer(new GT_Slot_Output(this.mTileEntity, tStartIndex++, i, j));
+
+        addSlotToContainer(slotBattery = new Slot(mTileEntity, 1, 80, 63));
+        addSlotToContainer(slotSpecial = new Slot(mTileEntity, 3, 125, 63));
+
+    }
+
+    @Override
+    public ItemStack slotClick(int aSlotNumber, int aMouseclick, int aShifthold, EntityPlayer aPlayer) {
+        if (mTileEntity.getMetaTileEntity() == null) return null;
+        GT_MetaTileEntity_IndustrialApiary machine = getMachine();
+        if (machine == null) return null;
+        switch (aSlotNumber) {
+            case 0:
+                machine.mItemTransfer = !machine.mItemTransfer;
+                return null;
+            case 1:
+                if(aMouseclick == 0) {
+                    if(machine.mLockedSpeed)
+                        return null;
+                    if(aShifthold == 0) {
+                        machine.mSpeed++;
+                        if (machine.mSpeed > machine.getMaxSpeed()) machine.mSpeed = 0;
+                    }
+                    else if(aShifthold == 1)
+                    {
+                        machine.mSpeed--;
+                        if (machine.mSpeed < 0) machine.mSpeed = machine.getMaxSpeed();
+                    }
+                }
+                else if(aMouseclick == 1)
+                {
+                    machine.mLockedSpeed = !machine.mLockedSpeed;
+                    if(machine.mLockedSpeed)
+                        machine.mSpeed = machine.getMaxSpeed();
+                }
+                return null;
+            case 2:
+                machine.retreviePollen = !machine.retreviePollen;
+                return null;
+            case 3:
+                machine.cancelProcess();
+                detectAndSendChanges();
+                return null;
+        }
+
+        if(!(aSlotNumber >= getSlotStartIndex()+2 && aSlotNumber < getSlotStartIndex()+2+4))
+            return super.slotClick(aSlotNumber, aMouseclick, aShifthold, aPlayer);
+        if(aShifthold == 5)
+            return null;
+        if(aShifthold != 0)
+            return super.slotClick(aSlotNumber, aMouseclick, aShifthold, aPlayer);
+        if(aMouseclick > 1)
+            return super.slotClick(aSlotNumber, aMouseclick, aShifthold, aPlayer);
+        ItemStack s = aPlayer.inventory.getItemStack();
+        if(s == null)
+            return super.slotClick(aSlotNumber, aMouseclick, aShifthold, aPlayer);
+        Slot slot = getSlot(aSlotNumber);
+        ItemStack slotstack = slot.getStack();
+        if(slotstack != null && !GT_Utility.areStacksEqual(slotstack, s))
+            return null; // super would replace item
+        if(slotstack == null && !slot.isItemValid(s))
+            return super.slotClick(aSlotNumber, aMouseclick, aShifthold, aPlayer);
+        if(!(s.getItem() instanceof IApiaryUpgrade) && !GT_ApiaryUpgrade.isUpgrade(s))
+            return super.slotClick(aSlotNumber, aMouseclick, aShifthold, aPlayer);
+        int max = 1;
+        if (s.getItem() instanceof IApiaryUpgrade)
+            max = ((IApiaryUpgrade) s.getItem()).getMaxNumber(s);
+        else
+            max = GT_ApiaryUpgrade.getUpgrade(s).getMaxNumber();
+        if(slotstack != null)
+            max = Math.max(0, max - slotstack.stackSize);
+        max = Math.min(max, s.stackSize);
+        if(max == 0)
+            return null;
+        if(aMouseclick == 1)
+            max = 1;
+        if(max == s.stackSize)
+            return super.slotClick(aSlotNumber, aMouseclick, aShifthold, aPlayer);
+        ItemStack newstack = s.splitStack(s.stackSize - max);
+        ItemStack result = super.slotClick(aSlotNumber, aMouseclick, aShifthold, aPlayer);
+        aPlayer.inventory.setItemStack(newstack);
+        return result;
+    }
+
+    @Override
+    public int getSlotStartIndex() {
+        return 4;
+    }
+
+    @Override
+    public int getSlotCount() {
+        return 6+9+2;
+    }
+
+    @Override
+    public int getShiftClickSlotCount() {
+        return 6;
+    }
+
+    @Override
+    public void detectAndSendChanges() {
+        super.detectAndSendChanges();
+        if ((this.mTileEntity.isClientSide()) || (this.mTileEntity.getMetaTileEntity() == null)) {
+            return;
+        }
+
+        this.mSpeed = getMachine().mSpeed;
+        this.mItemTransfer = getMachine().mItemTransfer;
+        this.mStuttering = getMachine().mStuttering;
+        this.retrievePollen = getMachine().retreviePollen;
+        this.mLockedSpeed = getMachine().mLockedSpeed;
+
+        for (Object crafter : this.crafters) {
+            ICrafting var1 = (ICrafting) crafter;
+            var1.sendProgressBarUpdate(this, 100, this.mSpeed);
+            var1.sendProgressBarUpdate(this, 101, this.mItemTransfer ? 1 : 0);
+            var1.sendProgressBarUpdate(this, 102, 0);
+            for(IErrorState s : getMachine().mErrorStates)
+                var1.sendProgressBarUpdate(this, 103, s.getID());
+            var1.sendProgressBarUpdate(this, 104, this.mStuttering ? 1 : 0);
+            var1.sendProgressBarUpdate(this, 105, this.retrievePollen ? 1 : 0);
+            var1.sendProgressBarUpdate(this, 106, this.mLockedSpeed ? 1 : 0);
+        }
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void updateProgressBar(int par1, int par2) {
+        super.updateProgressBar(par1, par2);
+        switch (par1) {
+            case 100:
+                this.mSpeed = par2;
+                break;
+            case 101:
+                this.mItemTransfer = par2 == 1;
+                break;
+            case 102:
+                this.mErrorStates.clear();
+                break;
+            case 103:
+                this.mErrorStates.add(EnumChatFormatting.RED + StatCollector.translateToLocal("for." + ForestryAPI.errorStateRegistry.getErrorState((short) par2).getDescription()));
+                break;
+            case 104:
+                this.mStuttering = par2 == 1;
+                break;
+            case 105:
+                this.retrievePollen = par2 == 1;
+                break;
+            case 106:
+                this.mLockedSpeed = par2 == 1;
+                break;
+        }
+    }
+
+    public GT_MetaTileEntity_IndustrialApiary getMachine() {
+        return (GT_MetaTileEntity_IndustrialApiary) mTileEntity.getMetaTileEntity();
+    }
+
+    @Override
+    public ItemStack transferStackInSlot(EntityPlayer aPlayer, int aSlotIndex) {
+        Slot s = getSlot(aSlotIndex);
+        if(s == null)
+            return super.transferStackInSlot(aPlayer, aSlotIndex);
+        if(!(s.inventory instanceof InventoryPlayer))
+            return super.transferStackInSlot(aPlayer, aSlotIndex);
+        ItemStack aStack = s.getStack();
+        if(aStack == null)
+            return super.transferStackInSlot(aPlayer, aSlotIndex);
+        if(!(aStack.getItem() instanceof IApiaryUpgrade) && !GT_ApiaryUpgrade.isUpgrade(aStack))
+            return super.transferStackInSlot(aPlayer, aSlotIndex);
+        for(int i = getSlotStartIndex()+2; i < getSlotStartIndex()+2+4; i++) {
+            Slot iSlot = getSlot(i);
+            ItemStack iStack = iSlot.getStack();
+            if(iStack == null)
+            {
+                if(!iSlot.isItemValid(aStack))
+                    continue;
+            }
+            else
+            {
+                if(!GT_Utility.areStacksEqual(aStack, iStack))
+                    continue;
+            }
+            int max = 1;
+            if (aStack.getItem() instanceof IApiaryUpgrade)
+                max = ((IApiaryUpgrade) aStack.getItem()).getMaxNumber(aStack);
+            else
+                max = GT_ApiaryUpgrade.getUpgrade(aStack).getMaxNumber();
+            if (iStack == null) {
+                max = Math.min(max, aStack.stackSize);
+                ItemStack newstack = aStack.splitStack(max);
+                iSlot.putStack(newstack);
+            } else {
+                max = Math.max(0, max - iStack.stackSize);
+                max = Math.min(max, aStack.stackSize);
+                iStack.stackSize += max;
+                aStack.stackSize -= max;
+                iSlot.onSlotChanged();
+            }
+            if (aStack.stackSize == 0)
+                s.putStack(null);
+            else
+                s.onSlotChanged();
+            break;
+        }
+        return null;
+    }
+
+    private static class ApiarySlot extends Slot{
+
+        public ApiarySlot(IInventory p_i1824_1_, int p_i1824_2_, int p_i1824_3_, int p_i1824_4_) {
+            super(p_i1824_1_, p_i1824_2_, p_i1824_3_, p_i1824_4_);
+        }
+
+        @Override
+        public boolean isItemValid(ItemStack p_75214_1_) {
+            return this.inventory.isItemValidForSlot(this.getSlotIndex(), p_75214_1_);
+        }
+
+        @Override
+        public void onSlotChanged() {
+            super.onSlotChanged();
+            ((GT_MetaTileEntity_IndustrialApiary)((IGregTechTileEntity)this.inventory).getMetaTileEntity()).onInventoryUpdate(this.getSlotIndex());
+        }
+    }
+}
diff --git a/src/main/java/gregtech/common/gui/GT_GUIContainer_IndustrialApiary.java b/src/main/java/gregtech/common/gui/GT_GUIContainer_IndustrialApiary.java
new file mode 100644
index 0000000000..f901a78599
--- /dev/null
+++ b/src/main/java/gregtech/common/gui/GT_GUIContainer_IndustrialApiary.java
@@ -0,0 +1,152 @@
+package gregtech.common.gui;
+
+import forestry.api.apiculture.*;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.gui.GT_GUIContainerMetaTile_Machine;
+import gregtech.api.gui.widgets.GT_GuiSlotTooltip;
+import gregtech.api.gui.widgets.GT_GuiTooltip;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.util.GT_TooltipDataCache;
+import gregtech.api.util.GT_Utility;
+import gregtech.common.tileentities.machines.basic.GT_MetaTileEntity_IndustrialApiary;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.util.StatCollector;
+
+import java.awt.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class GT_GUIContainer_IndustrialApiary extends GT_GUIContainerMetaTile_Machine {
+
+
+    private static final String
+        BATTERY_SLOT_TOOLTIP = "GT5U.machines.battery_slot.tooltip",
+        UNUSED_SLOT_TOOLTIP = "GT5U.machines.unused_slot.tooltip",
+        STALLED_STUTTERING_TOOLTIP = "GT5U.machines.stalled_stuttering.tooltip",
+        ITEM_TRANSFER_TOOLTIP = "GT5U.machines.item_transfer.tooltip",
+        POWER_SOURCE_POWER = "GT5U.machines.powersource.power",
+        RETRIEVE_POLLEN_TOOLTIP = "GT5U.machines.industrialapiary.pollen.tooltip",
+        CANCEL_PROCESS_TOOLTIP = "GT5U.machines.industrialapiary.cancel.tooltip",
+        SPEED_TOOLTIP = "GT5U.machines.industrialapiary.speed.tooltip",
+        SPEED_LOCKED_TOOLTIP = "GT5U.machines.industrialapiary.speedlocked.tooltip",
+        INFO_TOOLTIP = "GT5U.machines.industrialapiary.info.tooltip",
+        INFO_WITH_BEE_TOOLTIP = "GT5U.machines.industrialapiary.infoextended.tooltip"
+            ;
+
+
+    GT_GuiTooltip mErrorStatesTooltip;
+    GT_GuiTooltip mSpeedToggleTooltip;
+    GT_GuiTooltip mInfoTooltip;
+
+    public GT_GUIContainer_IndustrialApiary(InventoryPlayer aInventoryPlayer, IGregTechTileEntity aTileEntity) {
+        super(new GT_Container_IndustrialApiary(aInventoryPlayer, aTileEntity), "gregtech:textures/gui/basicmachines/IndustrialApiary.png");
+    }
+
+    @Override
+    protected void setupTooltips() {
+        Rectangle tBeeProblemArea = new Rectangle(this.guiLeft + 100, this.guiTop + 63, 18, 18);
+        addToolTip(mErrorStatesTooltip = new GT_GuiTooltip(tBeeProblemArea, "") {
+            @Override
+            protected void onTick() {
+                boolean e = this.enabled;
+                super.onTick();
+                this.enabled = e;
+            }
+        });
+        addToolTip(mSpeedToggleTooltip = new GT_GuiSlotTooltip(getContainer().slotSpeedToggle, new GT_TooltipDataCache.TooltipData(null, null)));
+        mErrorStatesTooltip.enabled = false;
+        addToolTip(mInfoTooltip = new GT_GuiTooltip(new Rectangle(this.guiLeft + 163, guiTop + 5, 6, 17)));
+
+        addToolTip(new GT_GuiSlotTooltip(getContainer().slotPollenToggle, mTooltipCache.getData(RETRIEVE_POLLEN_TOOLTIP)));
+        addToolTip(new GT_GuiSlotTooltip(getContainer().slotCancelProcess, mTooltipCache.getData(CANCEL_PROCESS_TOOLTIP)));
+
+
+        addToolTip(new GT_GuiSlotTooltip(getContainer().slotItemTransferToggle, mTooltipCache.getData(ITEM_TRANSFER_TOOLTIP)));
+        addToolTip(new GT_GuiSlotTooltip(getContainer().slotBattery, mTooltipCache.getData(BATTERY_SLOT_TOOLTIP,
+                powerTierName(getContainer().getMachine().mTier),
+                powerTierName((byte)(getContainer().getMachine().mTier + 1)))));
+        addToolTip(new GT_GuiSlotTooltip(getContainer().slotSpecial, mTooltipCache.getData(UNUSED_SLOT_TOOLTIP)));
+    }
+
+    @Override
+    public void drawScreen(int mouseX, int mouseY, float parTicks) {
+        mErrorStatesTooltip.enabled = !getContainer().mErrorStates.isEmpty();
+        if(mErrorStatesTooltip.enabled){ mErrorStatesTooltip.setToolTipText(new GT_TooltipDataCache.TooltipData(getContainer().mErrorStates, getContainer().mErrorStates)); }
+        else if(getContainer().mStuttering)
+        {
+            mErrorStatesTooltip.enabled = true;
+            mErrorStatesTooltip.setToolTipText(mTooltipCache.getData(STALLED_STUTTERING_TOOLTIP, StatCollector.translateToLocal(POWER_SOURCE_POWER)));
+        }
+        int accelerated = (1 << getContainer().mSpeed);
+        int energyusage = 0;
+        if(accelerated == 2)
+            energyusage = 32;
+        else if(accelerated > 2)
+            energyusage = 32 * accelerated << (getContainer().mSpeed - 2);
+        mSpeedToggleTooltip.setToolTipText(mTooltipCache.getUncachedTooltipData(getContainer().mLockedSpeed ? SPEED_LOCKED_TOOLTIP : SPEED_TOOLTIP, accelerated, GT_Utility.formatNumbers(energyusage)));
+        ArrayList<String> s = new ArrayList<>();
+        GT_MetaTileEntity_IndustrialApiary IA = getContainer().getMachine();
+
+        String energyreq = GT_Utility.formatNumbers((int)((float)GT_MetaTileEntity_IndustrialApiary.baseEUtUsage * IA.getEnergyModifier() * accelerated) + energyusage);
+        String Temp = StatCollector.translateToLocal(IA.getTemperature().getName());
+        String Hum = StatCollector.translateToLocal(IA.getHumidity().getName());
+        boolean moreinformationgiven = false;
+        if(IA.getUsedQueen() != null && BeeManager.beeRoot.isMember(IA.getUsedQueen(), EnumBeeType.QUEEN.ordinal())) {
+            IBee bee = BeeManager.beeRoot.getMember(IA.getUsedQueen());
+            if (bee.isAnalyzed()) {
+                moreinformationgiven = true;
+                IBeeGenome genome = bee.getGenome();
+                IBeeModifier mod = BeeManager.beeRoot.getBeekeepingMode(IA.getWorld()).getBeeModifier();
+                float tmod = IA.getTerritoryModifier(null, 1f) * mod.getTerritoryModifier(null, 1f);
+                int[] t = Arrays.stream(genome.getTerritory()).map(i -> (int) ((float) i * tmod)).toArray();
+                mInfoTooltip.setToolTipText(mTooltipCache.getUncachedTooltipData(INFO_WITH_BEE_TOOLTIP, energyreq, Temp, Hum,
+                    Math.round(100f * IA.getProductionModifier(null, 1f) * genome.getSpeed() * mod.getProductionModifier(null, 1f)),
+                    Math.round(IA.getFloweringModifier(null, 1f) * genome.getFlowering() * mod.getFloweringModifier(null, 1f)),
+                    Math.round(IA.getLifespanModifier(null, null, 1f) * genome.getLifespan() * mod.getLifespanModifier(null, null, 1f)),
+                    t[0], t[1], t[2]));
+            }
+        }
+        if(!moreinformationgiven)
+            mInfoTooltip.setToolTipText(mTooltipCache.getUncachedTooltipData(INFO_TOOLTIP, energyreq, Temp, Hum));
+
+
+        super.drawScreen(mouseX, mouseY, parTicks);
+    }
+
+    @Override
+    protected void drawGuiContainerForegroundLayer(int par1, int par2) {
+        this.fontRendererObj.drawString("Ind. Apiary", 8, 4, 4210752);
+        this.fontRendererObj.drawString("x", 30, 63, 4210752);
+        this.fontRendererObj.drawString((1 << getContainer().mSpeed) + "", 26, 72, 4210752);
+    }
+
+    @Override
+    protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3) {
+        super.drawGuiContainerBackgroundLayer(par1, par2, par3);
+        int x = (this.width - this.xSize) / 2;
+        int y = (this.height - this.ySize) / 2;
+        drawTexturedModalRect(x, y, 0, 0, this.xSize, this.ySize);
+        if (this.mContainer != null) {
+            if (getContainer().mItemTransfer)
+                drawTexturedModalRect(x + 7, y + 62, 176, 18, 18, 18);
+            if(getContainer().retrievePollen)
+                drawTexturedModalRect(x + 7, y + 44, 194, 18, 18, 18);
+            if(getContainer().mMaxProgressTime > 0) {
+                double p = (double) getContainer().mProgressTime / getContainer().mMaxProgressTime;
+                drawTexturedModalRect(x+70, y+3, 176, 0, (int)(p*20), 18);
+            }
+            if(mErrorStatesTooltip.enabled)
+                drawTexturedModalRect(x+100, y+63, 176, 36, getContainer().mStuttering ? 18 : 9, 18);
+        }
+    }
+
+    private GT_Container_IndustrialApiary getContainer(){
+        return ((GT_Container_IndustrialApiary) this.mContainer);
+    }
+
+    // taken from GT_GUIContainer_BasicMachine
+    private String powerTierName(byte machineTier) {
+        return GT_Values.TIER_COLORS[machineTier] + GT_Values.VN[machineTier];
+    }
+
+}