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

11 files changed, 1557 insertions, 20 deletions

diff --git a/src/main/java/gregtech/GT_Mod.java b/src/main/java/gregtech/GT_Mod.java
index 13c3dfd390..08303e9f10 100644
--- a/src/main/java/gregtech/GT_Mod.java
+++ b/src/main/java/gregtech/GT_Mod.java
@@ -103,7 +103,8 @@ import static gregtech.api.enums.GT_Values.MOD_ID_FR;
                 " after:RedPowerControl;" +
                 " after:UndergroundBiomes;" +
                 " after:TConstruct;" +
-                " after:Translocator;")
+                " after:Translocator;" +
+                " after:gendustry;")
 public class GT_Mod implements IGT_Mod {
 
     @Deprecated // Keep for use in BaseMetaTileEntity
diff --git a/src/main/java/gregtech/api/enums/ItemList.java b/src/main/java/gregtech/api/enums/ItemList.java
index b5898618f3..285d1fd542 100644
--- a/src/main/java/gregtech/api/enums/ItemList.java
+++ b/src/main/java/gregtech/api/enums/ItemList.java
@@ -1403,6 +1403,16 @@ public enum ItemList implements IItemContainer {
     Machine_MV_Miner,
     Machine_HV_Miner,
 
+    Machine_IndustrialApiary,
+    IndustrialApiary_Upgrade_Acceleration_1,
+    IndustrialApiary_Upgrade_Acceleration_2,
+    IndustrialApiary_Upgrade_Acceleration_3,
+    IndustrialApiary_Upgrade_Acceleration_4,
+    IndustrialApiary_Upgrade_Acceleration_5,
+    IndustrialApiary_Upgrade_Acceleration_6,
+    IndustrialApiary_Upgrade_Acceleration_7,
+    IndustrialApiary_Upgrade_Acceleration_8,
+
     Neutron_Reflector,
 
     Reactor_Coolant_He_1,
diff --git a/src/main/java/gregtech/api/enums/OrePrefixes.java b/src/main/java/gregtech/api/enums/OrePrefixes.java
index fa8bb0b2cb..7b480ea995 100644
--- a/src/main/java/gregtech/api/enums/OrePrefixes.java
+++ b/src/main/java/gregtech/api/enums/OrePrefixes.java
@@ -331,7 +331,9 @@ public enum OrePrefixes {
     cellSteamCracked2("Cells", "Moderately Steam-Cracked ", " Cell", true, true, true, true, false, false, false, true, false, false, 0, M * 1, 64, 30),
     cellSteamCracked3("Cells", "Severely Steam-Cracked ", " Cell", true, true, true, true, false, false, false, true, false, false, 0, M * 1, 64, 30),
 
-    componentCircuit("Circuit Parts", "", "", true, true, false, false, false, false, false, false, false, false, 0, -1, 64, -1);
+    componentCircuit("Circuit Parts", "", "", true, true, false, false, false, false, false, false, false, false, 0, -1, 64, -1),
+
+    apiaryUpgrade("Industrial Apiary Upgrade", "", "", false, false, true, false, false, false, false, false, true, false, 0, -1, 64, -1);
 
     public static final ImmutableList<OrePrefixes> CELL_TYPES =
             ImmutableList.of(
diff --git a/src/main/java/gregtech/api/enums/Textures.java b/src/main/java/gregtech/api/enums/Textures.java
index eee5425809..fb1ff424fc 100644
--- a/src/main/java/gregtech/api/enums/Textures.java
+++ b/src/main/java/gregtech/api/enums/Textures.java
@@ -593,6 +593,8 @@ public class Textures {
         OVERLAY_TOP_ROCK_BREAKER_GLOW,
         OVERLAY_TOP_SCANNER,
         OVERLAY_TOP_SCANNER_GLOW,
+        OVERLAY_TOP_INDUSTRIAL_APIARY,
+        OVERLAY_TOP_INDUSTRIAL_APIARY_GLOW,
 
         OVERLAY_FRONT_POTIONBREWER,
         OVERLAY_FRONT_POTIONBREWER_GLOW,
@@ -625,9 +627,11 @@ public class Textures {
         OVERLAY_FRONT_BOXINATOR_GLOW,
         OVERLAY_FRONT_ROCK_BREAKER,
         OVERLAY_FRONT_ROCK_BREAKER_GLOW,
-
         OVERLAY_FRONT_SCANNER,
         OVERLAY_FRONT_SCANNER_GLOW,
+        OVERLAY_FRONT_INDUSTRIAL_APIARY,
+        OVERLAY_FRONT_INDUSTRIAL_APIARY_GLOW,
+
         OVERLAY_BOTTOM_POTIONBREWER,
         OVERLAY_BOTTOM_POTIONBREWER_GLOW,
         OVERLAY_BOTTOM_REPLICATOR,
@@ -649,13 +653,15 @@ public class Textures {
         OVERLAY_BOTTOM_STEAM_EXTRACTOR_GLOW,
         OVERLAY_BOTTOM_DISASSEMBLER,
         OVERLAY_BOTTOM_DISASSEMBLER_GLOW,
-
         OVERLAY_BOTTOM_BOXINATOR,
         OVERLAY_BOTTOM_BOXINATOR_GLOW,
         OVERLAY_BOTTOM_ROCK_BREAKER,
         OVERLAY_BOTTOM_ROCK_BREAKER_GLOW,
         OVERLAY_BOTTOM_SCANNER,
         OVERLAY_BOTTOM_SCANNER_GLOW,
+        OVERLAY_BOTTOM_INDUSTRIAL_APIARY,
+        OVERLAY_BOTTOM_INDUSTRIAL_APIARY_GLOW,
+
         OVERLAY_SIDE_POTIONBREWER,
         OVERLAY_SIDE_POTIONBREWER_GLOW,
         OVERLAY_SIDE_REPLICATOR,
@@ -664,7 +670,6 @@ public class Textures {
         OVERLAY_SIDE_MASSFAB_GLOW,
         OVERLAY_SIDE_STEAM_HAMMER,
         OVERLAY_SIDE_STEAM_HAMMER_GLOW,
-
         OVERLAY_SIDE_STEAM_FURNACE,
         OVERLAY_SIDE_STEAM_FURNACE_GLOW,
         OVERLAY_SIDE_STEAM_ALLOY_SMELTER,
@@ -677,13 +682,15 @@ public class Textures {
         OVERLAY_SIDE_STEAM_EXTRACTOR_GLOW,
         OVERLAY_SIDE_DISASSEMBLER,
         OVERLAY_SIDE_DISASSEMBLER_GLOW,
-
         OVERLAY_SIDE_BOXINATOR,
         OVERLAY_SIDE_BOXINATOR_GLOW,
         OVERLAY_SIDE_ROCK_BREAKER,
         OVERLAY_SIDE_ROCK_BREAKER_GLOW,
         OVERLAY_SIDE_SCANNER,
         OVERLAY_SIDE_SCANNER_GLOW,
+        OVERLAY_SIDE_INDUSTRIAL_APIARY,
+        OVERLAY_SIDE_INDUSTRIAL_APIARY_GLOW,
+
         OVERLAY_TOP_POTIONBREWER_ACTIVE,
         OVERLAY_TOP_POTIONBREWER_ACTIVE_GLOW,
         OVERLAY_TOP_REPLICATOR_ACTIVE,
@@ -712,9 +719,11 @@ public class Textures {
         OVERLAY_TOP_ROCK_BREAKER_ACTIVE_GLOW,
         OVERLAY_TOP_SCANNER_ACTIVE,
         OVERLAY_TOP_SCANNER_ACTIVE_GLOW,
+        OVERLAY_TOP_INDUSTRIAL_APIARY_ACTIVE,
+        OVERLAY_TOP_INDUSTRIAL_APIARY_ACTIVE_GLOW,
+
         OVERLAY_FRONT_POTIONBREWER_ACTIVE,
         OVERLAY_FRONT_POTIONBREWER_ACTIVE_GLOW,
-
         OVERLAY_FRONT_REPLICATOR_ACTIVE,
         OVERLAY_FRONT_REPLICATOR_ACTIVE_GLOW,
         OVERLAY_FRONT_MASSFAB_ACTIVE,
@@ -730,18 +739,19 @@ public class Textures {
         OVERLAY_FRONT_STEAM_EXTRACTOR_ACTIVE_GLOW,
         OVERLAY_FRONT_BOXINATOR_ACTIVE,
         OVERLAY_FRONT_BOXINATOR_ACTIVE_GLOW,
-
         OVERLAY_FRONT_ROCK_BREAKER_ACTIVE,
         OVERLAY_FRONT_ROCK_BREAKER_ACTIVE_GLOW,
         OVERLAY_FRONT_SCANNER_ACTIVE,
         OVERLAY_FRONT_SCANNER_ACTIVE_GLOW,
+        OVERLAY_FRONT_INDUSTRIAL_APIARY_ACTIVE,
+        OVERLAY_FRONT_INDUSTRIAL_APIARY_ACTIVE_GLOW,
+
         OVERLAY_BOTTOM_POTIONBREWER_ACTIVE,
         OVERLAY_BOTTOM_POTIONBREWER_ACTIVE_GLOW,
         OVERLAY_BOTTOM_REPLICATOR_ACTIVE,
         OVERLAY_BOTTOM_REPLICATOR_ACTIVE_GLOW,
         OVERLAY_BOTTOM_MASSFAB_ACTIVE,
         OVERLAY_BOTTOM_MASSFAB_ACTIVE_GLOW,
-
         OVERLAY_BOTTOM_STEAM_HAMMER_ACTIVE,
         OVERLAY_BOTTOM_STEAM_HAMMER_ACTIVE_GLOW,
         OVERLAY_BOTTOM_STEAM_FURNACE_ACTIVE,
@@ -763,6 +773,8 @@ public class Textures {
         OVERLAY_BOTTOM_ROCK_BREAKER_ACTIVE_GLOW,
         OVERLAY_BOTTOM_SCANNER_ACTIVE,
         OVERLAY_BOTTOM_SCANNER_ACTIVE_GLOW,
+        OVERLAY_BOTTOM_INDUSTRIAL_APIARY_ACTIVE,
+        OVERLAY_BOTTOM_INDUSTRIAL_APIARY_ACTIVE_GLOW,
 
         OVERLAY_SIDE_POTIONBREWER_ACTIVE,
         OVERLAY_SIDE_POTIONBREWER_ACTIVE_GLOW,
@@ -787,11 +799,13 @@ public class Textures {
         OVERLAY_SIDE_DISASSEMBLER_ACTIVE_GLOW,
         OVERLAY_SIDE_BOXINATOR_ACTIVE,
         OVERLAY_SIDE_BOXINATOR_ACTIVE_GLOW,
-
         OVERLAY_SIDE_ROCK_BREAKER_ACTIVE,
         OVERLAY_SIDE_ROCK_BREAKER_ACTIVE_GLOW,
         OVERLAY_SIDE_SCANNER_ACTIVE,
         OVERLAY_SIDE_SCANNER_ACTIVE_GLOW,
+        OVERLAY_SIDE_INDUSTRIAL_APIARY_ACTIVE,
+        OVERLAY_SIDE_INDUSTRIAL_APIARY_ACTIVE_GLOW,
+
         OVERLAY_ADV_PUMP,
         OVERLAY_TELEPORTER,
         OVERLAY_TELEPORTER_GLOW,
diff --git a/src/main/java/gregtech/api/util/GT_ApiaryUpgrade.java b/src/main/java/gregtech/api/util/GT_ApiaryUpgrade.java
new file mode 100644
index 0000000000..4c60e6f8bc
--- /dev/null
+++ b/src/main/java/gregtech/api/util/GT_ApiaryUpgrade.java
@@ -0,0 +1,108 @@
+package gregtech.api.util;
+
+import cpw.mods.fml.common.Loader;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.common.items.GT_MetaGenerated_Item_03;
+import net.bdew.gendustry.api.ApiaryModifiers;
+import net.bdew.gendustry.api.items.IApiaryUpgrade;
+import net.minecraft.item.ItemStack;
+
+import java.util.*;
+import java.util.function.Consumer;
+
+public enum GT_ApiaryUpgrade {
+    speed1(UNIQUE_INDEX.SPEED_UPGRADE, 32200, 1, 1),
+    speed2(UNIQUE_INDEX.SPEED_UPGRADE, 32201, 1, 2),
+    speed3(UNIQUE_INDEX.SPEED_UPGRADE, 32202, 1, 3),
+    speed4(UNIQUE_INDEX.SPEED_UPGRADE, 32203, 1, 4),
+    speed5(UNIQUE_INDEX.SPEED_UPGRADE, 32204, 1, 5),
+    speed6(UNIQUE_INDEX.SPEED_UPGRADE, 32205, 1, 6),
+    speed7(UNIQUE_INDEX.SPEED_UPGRADE, 32206, 1, 7),
+    speed8(UNIQUE_INDEX.SPEED_UPGRADE, 32207, 1, 8),
+    ;
+
+    private enum UNIQUE_INDEX{
+        SPEED_UPGRADE,
+        ;
+        void apply(Consumer<GT_ApiaryUpgrade> fn){
+            UNIQUE_UPGRADE_LIST.get(this).forEach(fn);
+        }
+    }
+
+    private static final EnumMap<UNIQUE_INDEX, ArrayList<GT_ApiaryUpgrade>> UNIQUE_UPGRADE_LIST = new EnumMap<>(UNIQUE_INDEX.class);
+
+    private int meta = 0;
+    private int maxnumber = 1;
+    private int maxspeedmodifier = 0; // formula: maxspeed = modifier
+
+    private final GT_Utility.ItemId id;
+    private final UNIQUE_INDEX unique_index;
+
+    private final HashMap<GT_Utility.ItemId, ItemStack> additionalGendustryUpgrades = new HashMap<>();
+    private final HashSet<GT_Utility.ItemId> blacklistedUpgrades = new HashSet<>(); // additionalGendustryUpgrades are blacklisted by default
+
+    GT_ApiaryUpgrade(UNIQUE_INDEX unique_index, int meta, int maxnumber, int maxspeedmodifier){
+        this.unique_index = unique_index;
+        this.meta = meta;
+        this.maxnumber = maxnumber;
+        this.maxspeedmodifier = maxspeedmodifier;
+        this.id = GT_Utility.ItemId.createNoCopy(get(1));
+    }
+
+    private void setup_static_variables(){
+        quickLookup.put(this.meta, this);
+        ArrayList<GT_ApiaryUpgrade> un = UNIQUE_UPGRADE_LIST.get(this.unique_index);
+        if(un != null)
+            un.forEach((u) -> { u.blacklistedUpgrades.add(this.id); this.blacklistedUpgrades.add(u.id); });
+        else {
+            un = new ArrayList<>(1);
+            UNIQUE_UPGRADE_LIST.put(this.unique_index, un);
+        }
+        un.add(this);
+    }
+
+    public static GT_ApiaryUpgrade getUpgrade(ItemStack s){
+        if(s == null)
+            return null;
+        if(!isUpgrade(s))
+            return null;
+        return quickLookup.get(s.getItemDamage());
+    }
+
+    public boolean isAllowedToWorkWith(ItemStack s){
+        GT_Utility.ItemId id = GT_Utility.ItemId.createNoCopy(s);
+        return !additionalGendustryUpgrades.containsKey(id) && !blacklistedUpgrades.contains(id);
+    }
+
+    public int getMaxNumber(){
+        return maxnumber;
+    }
+
+    public void applyModifiers(ApiaryModifiers mods, ItemStack s){
+        additionalGendustryUpgrades.forEach((k, u) -> ((IApiaryUpgrade)u.getItem()).applyModifiers(mods, u));
+    }
+
+    public ItemStack get(int count){
+        return new ItemStack(GT_MetaGenerated_Item_03.INSTANCE, count, meta);
+    }
+
+    public static boolean isUpgrade(ItemStack s){
+        return OrePrefixes.apiaryUpgrade.contains(s);
+    }
+
+    public int applyMaxSpeedModifier(int maxspeed){
+        return Math.max(maxspeed, maxspeedmodifier);
+    }
+
+    private static final HashMap<Integer, GT_ApiaryUpgrade> quickLookup = new HashMap<>();
+
+    static{
+        EnumSet.allOf(GT_ApiaryUpgrade.class).forEach(GT_ApiaryUpgrade::setup_static_variables);
+
+        if(Loader.isModLoaded("gendustry")) {
+            ItemStack s = GT_ModHandler.getModItem("gendustry", "ApiaryUpgrade", 8L, 0);
+            GT_Utility.ItemId a = GT_Utility.ItemId.createNoCopy(s);
+            UNIQUE_INDEX.SPEED_UPGRADE.apply((u) -> u.additionalGendustryUpgrades.put(a, s));
+        }
+    }
+}
diff --git a/src/main/java/gregtech/api/util/GT_TooltipDataCache.java b/src/main/java/gregtech/api/util/GT_TooltipDataCache.java
index 7844bb04fd..4309958b82 100644
--- a/src/main/java/gregtech/api/util/GT_TooltipDataCache.java
+++ b/src/main/java/gregtech/api/util/GT_TooltipDataCache.java
@@ -23,8 +23,8 @@ public class GT_TooltipDataCache {
 
     /**
      * Returns tooltip data respecting the user's configured verbosity levels, applying any formatting arguments.
-     * 
-     * @param key the key to lookup 
+     *
+     * @param key the key to lookup
      * @param args arguments for string formatting (prefer using positional arguments)
      * @return The tooltip data the user asked for
      */
@@ -39,12 +39,12 @@ public class GT_TooltipDataCache {
 
     /**
      * Builds tooltip data respecting the user's configured verbosity levels, applying any formatting arguments.
-     * 
-     * @param key the key to lookup 
+     *
+     * @param key the key to lookup
      * @param args arguments for string formatting (prefer using positional arguments)
      * @return The tooltip data the user asked for
      */
-    private TooltipData getUncachedTooltipData(String key, Object... args) {
+    public TooltipData getUncachedTooltipData(String key, Object... args) {
         List<String> lines = getAllLines(key, args);
         int normalLines = lines.size();
         if (Math.max(GT_Mod.gregtechproxy.mTooltipVerbosity, GT_Mod.gregtechproxy.mTooltipShiftVerbosity) >= 3) {
@@ -60,8 +60,8 @@ public class GT_TooltipDataCache {
 
     /**
      * Gets all the lines for the given key and every other subsequent consecutive key with a .n suffix, n in {1,2,3...}
-     * 
-     * @param key the key to lookup 
+     *
+     * @param key the key to lookup
      * @param args arguments for string formatting (prefer using positional arguments)
      * @return The lines for the key and all of it's subkeys
      */
@@ -78,7 +78,7 @@ public class GT_TooltipDataCache {
 
     /**
      * Determines how many lines from a tooltip to include from the full line list to respect a given verbosity level.
-     * 
+     *
      * @param tooltipVerbosity the verbosity level we're applying
      * @param defaultIndex return if tooltipVerbosity is 2
      * @param maxIndex return if tooltipVerbosity is greater than 2
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);
+    }
+
+    @Ove