Move sources and resources

18 files changed, 2378 insertions, 0 deletions

diff --git a/src/main/java/gtPlusPlus/xmod/forestry/HANDLER_FR.java b/src/main/java/gtPlusPlus/xmod/forestry/HANDLER_FR.java
new file mode 100644
index 0000000000..05d00b06d9
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/forestry/HANDLER_FR.java
@@ -0,0 +1,61 @@
+package gtPlusPlus.xmod.forestry;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import cpw.mods.fml.common.Optional;
+
+import net.minecraft.block.Block;
+import net.minecraft.world.World;
+
+import gtPlusPlus.core.lib.LoadedMods;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+import gtPlusPlus.xmod.forestry.bees.items.FR_ItemRegistry;
+import gtPlusPlus.xmod.forestry.bees.recipe.FR_Gregtech_Recipes;
+
+public class HANDLER_FR {
+
+	public static void preInit(){
+		if (LoadedMods.Forestry){
+			FR_ItemRegistry.Register();
+		}		
+	}
+
+	public static void Init(){
+		if (LoadedMods.Forestry){
+			//new GTPP_Bees(); TODO- Will Investigate this properly later.
+		}
+	}
+
+	public static void postInit(){
+		if (LoadedMods.Forestry){
+			FR_Gregtech_Recipes.registerItems();
+		}
+	}
+
+	public static boolean createBlockBreakParticles(final World world, final int x, final int y, final int z, final Block block){
+		if (LoadedMods.Forestry){
+			createBlockBreakParticles_INTERNAL(world, x, y, z, block);
+		}
+		return false;
+	}
+
+	@Optional.Method(modid = "Forestry")
+	private static void createBlockBreakParticles_INTERNAL(final World world, final int x, final int y, final int z, final Block block){
+		if (LoadedMods.Forestry){
+			Class oClass;
+			try {
+				oClass = ReflectionUtils.getClass("forestry.core.proxy.ProxyCommon");
+				Object oProxy = ReflectionUtils.getField(oClass, "common");				
+				if (oProxy != null && oClass.isInstance(oProxy)){					
+					Method mParticles = ReflectionUtils.getMethod(oClass, "addBlockDestroyEffects", World.class, int.class, int.class, int.class, Block.class, int.class);					
+					mParticles.invoke(oProxy, world, x, y, z, block, 0);				
+				}
+			}
+			catch (SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+			}
+		}		
+	}
+
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/forestry/bees/blocks/BlockDenseBeeHouse.java b/src/main/java/gtPlusPlus/xmod/forestry/bees/blocks/BlockDenseBeeHouse.java
new file mode 100644
index 0000000000..77ee15c5d5
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/forestry/bees/blocks/BlockDenseBeeHouse.java
@@ -0,0 +1,24 @@
+
+/*******************************************************************************
+ * Copyright (c) 2011-2014 SirSengir.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v3
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/lgpl-3.0.txt
+ *
+ * Various Contributors including, but not limited to:
+ * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
+ ******************************************************************************/
+package gtPlusPlus.xmod.forestry.bees.blocks;
+
+import forestry.apiculture.blocks.BlockApicultureType;
+import forestry.core.blocks.BlockBase;
+import gtPlusPlus.core.creative.AddToCreativeTab;
+
+public class BlockDenseBeeHouse extends BlockBase<BlockApicultureType> {
+	public BlockDenseBeeHouse() {
+		super();
+		setCreativeTab(AddToCreativeTab.tabBOP);
+		setHarvestLevel("axe", 0);
+	}
+}
\ No newline at end of file
diff --git a/src/main/java/gtPlusPlus/xmod/forestry/bees/blocks/FR_BlockRegistry.java b/src/main/java/gtPlusPlus/xmod/forestry/bees/blocks/FR_BlockRegistry.java
new file mode 100644
index 0000000000..fa36732cb6
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/forestry/bees/blocks/FR_BlockRegistry.java
@@ -0,0 +1,26 @@
+package gtPlusPlus.xmod.forestry.bees.blocks;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+
+import forestry.core.utils.StringUtil;
+import forestry.plugins.PluginManager;
+import net.minecraftforge.oredict.OreDictionary;
+
+public abstract class FR_BlockRegistry {
+	protected static <T extends Block> T registerBlock(T block, Class<? extends ItemBlock> itemClass, String name) {
+		if (PluginManager.getStage() != PluginManager.Stage.SETUP) {
+			throw new RuntimeException("Tried to register Block outside of Setup");
+		}
+		block.setBlockName("for." + name);
+		GameRegistry.registerBlock(block, itemClass, StringUtil.cleanBlockName(block));
+		return block;
+	}
+
+	protected static void registerOreDictWildcard(String oreDictName, Block block) {
+		OreDictionary.registerOre(oreDictName, new ItemStack(block, 1, 32767));
+	}
+}
\ No newline at end of file
diff --git a/src/main/java/gtPlusPlus/xmod/forestry/bees/custom/CustomCombs.java b/src/main/java/gtPlusPlus/xmod/forestry/bees/custom/CustomCombs.java
new file mode 100644
index 0000000000..b4d6e4c2fc
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/forestry/bees/custom/CustomCombs.java
@@ -0,0 +1,119 @@
+package gtPlusPlus.xmod.forestry.bees.custom;
+
+import gregtech.api.enums.Materials;
+import gregtech.api.util.GT_LanguageManager;
+
+import gtPlusPlus.core.util.Utils;
+
+public enum CustomCombs {    
+    //Custom Bees
+    	
+    //Rubbers & Silicons
+    SILICON("silicon", true, Materials.Silicon, 100),
+    RUBBER("rubber", true, Materials.Rubber, 100),
+    PLASTIC("polyethylene", true, Materials.Plastic, 75),
+    PTFE("polytetrafluoroethylene", true, GTPP_Bees.PTFE, 50),
+    PBS("styrene-butadiene", true, GTPP_Bees.PBS, 25),
+    
+    //Fuels
+    BIOMASS("biomass", true, Materials.Biomass, 100),
+    ETHANOL("ethanol", true, Materials.Ethanol, 75),
+    DIESEL("diesel", true, Materials.Fuel, 50),
+    NITRO("nitro", true, Materials.NitroFuel, 25),
+    HOOTCH("hootch", true, Materials.Silicon, 50),
+    ROCKETFUEL("rocket", true, Materials.Silicon, 25),
+    
+    
+    //Materials which are hard, if not impossible to obtain.
+    FLUORINE("fluorine", true, Materials.Fluorine, 25),
+    COKE("coke", true, Materials._NULL, 50),
+    FORCE("force", true, Materials.Force, 50),
+    NIKOLITE("nikolite", true, Materials.Nikolite, 75),  
+    MITHRIL("mithril", true, Materials.Mithril, 10),
+    ADAMANTIUM("adamantium", true, Materials.Adamantium, 5),
+    
+	//Trash
+    SALT("salt", true, Materials.Salt, 75),
+    SAND("sand", true, Materials.Sand, 100), 
+    
+    ;
+
+    private static int[][] colours = new int[][]{
+        {Utils.rgbtoHexValue(75, 75, 75), Utils.rgbtoHexValue(125, 125, 125)}, //SILICON
+        {Utils.rgbtoHexValue(55, 55, 55), Utils.rgbtoHexValue(75, 75, 75)}, //RUBBER
+        {Utils.rgbtoHexValue(245, 245, 245), Utils.rgbtoHexValue(175, 175, 175)}, //PLASTIC
+        {Utils.rgbtoHexValue(150, 150, 150), Utils.rgbtoHexValue(75, 75, 75)}, //PTFE
+        {Utils.rgbtoHexValue(33, 26, 24), Utils.rgbtoHexValue(23, 16, 14)}, //PBS
+        //Unused
+        {Utils.rgbtoHexValue(33, 225, 24), Utils.rgbtoHexValue(23, 175, 14)}, //Biofuel
+        {Utils.rgbtoHexValue(255, 128, 0), Utils.rgbtoHexValue(220, 156, 32)}, //Ethanol
+        {Utils.rgbtoHexValue(75, 75, 75), Utils.rgbtoHexValue(125, 125, 125)}, //
+        {Utils.rgbtoHexValue(75, 75, 75), Utils.rgbtoHexValue(125, 125, 125)}, // 
+        {Utils.rgbtoHexValue(75, 75, 75), Utils.rgbtoHexValue(125, 125, 125)}, //
+        {Utils.rgbtoHexValue(75, 75, 75), Utils.rgbtoHexValue(125, 125, 125)}, //
+        {Utils.rgbtoHexValue(30, 230, 230), Utils.rgbtoHexValue(10, 150, 150)}, // Fluorine
+        {Utils.rgbtoHexValue(75, 75, 75), Utils.rgbtoHexValue(125, 125, 125)}, //
+        {Utils.rgbtoHexValue(250, 250, 20), Utils.rgbtoHexValue(200, 200, 5)}, // Force
+        {Utils.rgbtoHexValue(60, 180, 200), Utils.rgbtoHexValue(40, 150, 170)}, // Nikolite
+        {Utils.rgbtoHexValue(75, 75, 75), Utils.rgbtoHexValue(125, 125, 125)}, //
+        {Utils.rgbtoHexValue(75, 75, 75), Utils.rgbtoHexValue(125, 125, 125)}, //
+        {Utils.rgbtoHexValue(75, 75, 75), Utils.rgbtoHexValue(125, 125, 125)}, //
+        {Utils.rgbtoHexValue(75, 75, 75), Utils.rgbtoHexValue(125, 125, 125)}, //
+        {Utils.rgbtoHexValue(75, 75, 75), Utils.rgbtoHexValue(125, 125, 125)},
+            {0x666666, 0x525252},
+            {0x2E8F5B, 0xDCC289},
+            {0x4C4C4C, 0x333333},
+            {0x808080, 0x999999},
+            {0x57CFFB, 0xBBEEFF},
+            {0x7D0F0F, 0xD11919},
+            {0x1947D1, 0x476CDA},
+            {0xE6005C, 0xCC0052},
+            {0x0033CC, 0x00248F},
+            {0xCCFFFF, 0xA3CCCC},
+            {0x248F24, 0xCCFFCC},
+            {0x248F24, 0x2EB82E},
+            {0xD4D4D4, 0x58300B},
+            {0xFF6600, 0xE65C00},
+            {0xD4D4D4, 0xDDDDDD},
+            {0x666699, 0xA3A3CC},
+            {0xDA9147, 0xDE9C59},
+            {0x808080, 0x999999},
+            {0x8585AD, 0x9D9DBD},
+            {0xF0DEF0, 0xF2E1F2},
+            {0xC2C2D6, 0xCECEDE},
+            {0xE6B800, 0xCFA600},
+            {0x008AB8, 0xD6D6FF},
+            {0xD5D5D5, 0xAAAAAA},
+            {0xCC99FF, 0xDBB8FF},
+            {0xEBA1EB, 0xF2C3F2},
+            {0x62626D, 0x161620},
+            {0xE6E6E6, 0xFFFFCC},
+            {0xDADADA, 0xD1D1E0},
+            {0x19AF19, 0x169E16},
+            {0x335C33, 0x6B8F00},
+            {0x003300, 0x002400},
+    };
+    public boolean showInList;
+    public Materials material;
+    public int chance;
+    private String name;
+    private CustomCombs(String pName, boolean show, Materials material, int chance) {
+        this.name = pName;
+        this.material = material;
+        this.chance = chance;
+        this.showInList = show;
+    }
+
+    public void setHidden() {
+        this.showInList = false;
+    }
+
+    public String getName() {
+//		return "gt.comb."+this.name;
+        return GT_LanguageManager.addStringLocalization("comb." + this.name, this.name.substring(0, 1).toUpperCase() + this.name.substring(1) + " Comb");
+    }
+
+    public int[] getColours() {
+        return colours[this.ordinal()];
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/gtPlusPlus/xmod/forestry/bees/custom/GTPP_Bee_Definition.java b/src/main/java/gtPlusPlus/xmod/forestry/bees/custom/GTPP_Bee_Definition.java
new file mode 100644
index 0000000000..b36508f6aa
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/forestry/bees/custom/GTPP_Bee_Definition.java
@@ -0,0 +1,876 @@
+package gtPlusPlus.xmod.forestry.bees.custom;
+
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.Locale;
+
+import org.apache.commons.lang3.reflect.FieldUtils;
+import org.apache.commons.lang3.text.WordUtils;
+
+import net.minecraft.item.ItemStack;
+
+import forestry.api.apiculture.*;
+import forestry.api.core.EnumHumidity;
+import forestry.api.core.EnumTemperature;
+import forestry.api.genetics.AlleleManager;
+import forestry.api.genetics.IAllele;
+import forestry.apiculture.genetics.*;
+import forestry.core.genetics.alleles.AlleleHelper;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.item.ModItems;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+import net.minecraftforge.common.BiomeDictionary.Type;
+
+public enum GTPP_Bee_Definition implements IBeeDefinition {
+
+
+	SILICON(GTPP_Branch_Definition.ORGANIC, "Silicon", true, Utils.rgbtoHexValue(75, 75, 75), Utils.rgbtoHexValue(125, 125, 125)) {
+		@Override
+		protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+			beeSpecies.addProduct(getSlagComb(), 0.10f);
+			beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.SILICON), 0.20f);
+			beeSpecies.setHumidity(EnumHumidity.NORMAL);
+			beeSpecies.setTemperature(EnumTemperature.NORMAL);
+		}
+
+		@Override
+		protected void setAlleles(IAllele[] template) {
+			template = BeeDefinition.COMMON.getTemplate();
+		}
+
+		@Override
+		protected void registerMutations() {
+			IBeeMutationCustom tMutation = registerMutation(getGregtechBeeType("SLIMEBALL"), getGregtechBeeType("STICKYRESIN"), 10);
+		}
+	},
+
+	RUBBER(GTPP_Branch_Definition.ORGANIC, "Rubber", true, Utils.rgbtoHexValue(55, 55, 55), Utils.rgbtoHexValue(75, 75, 75)) {
+		@Override
+		protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+			beeSpecies.addProduct(getSlagComb(), 0.10f);
+			beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.RUBBER), 0.30f);
+			beeSpecies.setHumidity(EnumHumidity.NORMAL);
+			beeSpecies.setTemperature(EnumTemperature.NORMAL);
+		}
+
+		@Override
+		protected void setAlleles(IAllele[] template) {
+			template = BeeDefinition.COMMON.getTemplate();
+		}
+
+		@Override
+		protected void registerMutations() {
+			IBeeMutationCustom tMutation = registerMutation(getGregtechBeeType("SLIMEBALL"), getGregtechBeeType("STICKYRESIN"), 10);
+		}
+	},
+
+	PLASTIC(GTPP_Branch_Definition.ORGANIC, "Plastic", true, Utils.rgbtoHexValue(245, 245, 245), Utils.rgbtoHexValue(175, 175, 175)) {
+		@Override
+		protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+			beeSpecies.addProduct(getStoneComb(), 0.30f);
+			beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.PLASTIC), 0.15f);
+			beeSpecies.setHumidity(EnumHumidity.NORMAL);
+			beeSpecies.setTemperature(EnumTemperature.NORMAL);
+		}
+
+		@Override
+		protected void setAlleles(IAllele[] template) {
+			template = BeeDefinition.COMMON.getTemplate();
+		}
+
+		@Override
+		protected void registerMutations() {
+			IBeeMutationCustom tMutation = registerMutation(RUBBER.species, getGregtechBeeType("OIL"), 10);
+		}
+	},
+
+	PTFE(GTPP_Branch_Definition.ORGANIC, "Ptfe", true, Utils.rgbtoHexValue(150, 150, 150), Utils.rgbtoHexValue(75, 75, 75)) {
+		@Override
+		protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+			beeSpecies.addProduct(getStoneComb(), 0.30f);
+			beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.PTFE), 0.10f);
+			beeSpecies.setHumidity(EnumHumidity.NORMAL);
+			beeSpecies.setTemperature(EnumTemperature.NORMAL);
+		}
+
+		@Override
+		protected void setAlleles(IAllele[] template) {
+			template = BeeDefinition.COMMON.getTemplate();
+		}
+
+		@Override
+		protected void registerMutations() {
+			IBeeMutationCustom tMutation = registerMutation(RUBBER.species, PLASTIC.species, 10);
+		}
+	},
+
+	PBS(GTPP_Branch_Definition.ORGANIC, "Pbs", true, Utils.rgbtoHexValue(33, 26, 24), Utils.rgbtoHexValue(23, 16, 14)) {
+		@Override
+		protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+			beeSpecies.addProduct(getStoneComb(), 0.30f);
+			beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.PBS), 0.10f);
+			beeSpecies.setHumidity(EnumHumidity.NORMAL);
+			beeSpecies.setTemperature(EnumTemperature.NORMAL);
+		}
+
+		@Override
+		protected void setAlleles(IAllele[] template) {
+			template = BeeDefinition.COMMON.getTemplate();
+		}
+
+		@Override
+		protected void registerMutations() {
+			IBeeMutationCustom tMutation = registerMutation(PTFE.species, PLASTIC.species, 10);
+		}
+	},
+
+
+
+
+	/**
+	 * Fuels
+	 */
+
+	BIOMASS(GTPP_Branch_Definition.ORGANIC, "Biomass", true, Utils.rgbtoHexValue(33, 225, 24), Utils.rgbtoHexValue(23, 175, 14)) {
+		@Override
+		protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+			beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.SAND), 0.40f);
+			beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.BIOMASS), 0.20f);
+			beeSpecies.setHumidity(EnumHumidity.NORMAL);
+			beeSpecies.setTemperature(EnumTemperature.NORMAL);
+		}
+
+		@Override
+		protected void setAlleles(IAllele[] template) {
+			template = BeeDefinition.COMMON.getTemplate();
+		}
+
+		@Override
+		protected void registerMutations() {
+			IBeeMutationCustom tMutation = registerMutation(getSpecies("Industrious"), getSpecies("Rural"), 10);
+			tMutation.restrictBiomeType(Type.FOREST);
+		}
+	},
+
+	ETHANOL(GTPP_Branch_Definition.ORGANIC, "Ethanol", true, Utils.rgbtoHexValue(255, 128, 0), Utils.rgbtoHexValue(220, 156, 32)) {
+		@Override
+		protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+			beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.SAND), 0.40f);
+			beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.ETHANOL), 0.20f);
+			beeSpecies.setHumidity(EnumHumidity.NORMAL);
+			beeSpecies.setTemperature(EnumTemperature.NORMAL);
+		}
+
+		@Override
+		protected void setAlleles(IAllele[] template) {
+			template = BeeDefinition.COMMON.getTemplate();
+		}
+
+		@Override
+		protected void registerMutations() {
+			IBeeMutationCustom tMutation = registerMutation(BIOMASS.species, getSpecies("Farmerly"), 5);
+			tMutation.restrictBiomeType(Type.FOREST);
+		}
+	},
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+	/**
+	 * Materials
+	 */
+
+
+	FLUORINE(GTPP_Branch_Definition.ORGANIC, "Fluorine", true, Utils.rgbtoHexValue(30, 230, 230), Utils.rgbtoHexValue(10, 150, 150)) {
+		@Override
+		protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+			beeSpecies.addProduct(getStoneComb(), 0.40f);
+			beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.FLUORINE), 0.05f);
+			beeSpecies.setHumidity(EnumHumidity.NORMAL);
+			beeSpecies.setTemperature(EnumTemperature.COLD);
+		}
+
+		@Override
+		protected void setAlleles(IAllele[] template) {
+			template = BeeDefinition.COMMON.getTemplate();
+		}
+
+		@Override
+		protected void registerMutations() {
+			IBeeMutationCustom tMutation = registerMutation(getGregtechBeeType("LAPIS"), getGregtechBeeType("SAPPHIRE"), 5);
+			tMutation.restrictBiomeType(Type.COLD);
+		}
+	},
+
+	//Coke
+
+
+
+	//Force
+	FORCE(GTPP_Branch_Definition.METAL, "Force", true, Utils.rgbtoHexValue(250, 250, 20), Utils.rgbtoHexValue(200, 200, 5)) {
+		@Override
+		protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+			beeSpecies.addProduct(getStoneComb(), 0.30f);
+			beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.SAND), 0.25f);
+			beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.FORCE), 0.25f);
+			beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.SALT), 0.05f);
+			beeSpecies.setHumidity(EnumHumidity.NORMAL);
+			beeSpecies.setTemperature(EnumTemperature.HOT);
+		}
+
+		@Override
+		protected void setAlleles(IAllele[] template) {
+			template = BeeDefinition.COMMON.getTemplate();
+		}
+
+		@Override
+		protected void registerMutations() {
+			IBeeMutationCustom tMutation = registerMutation(getGregtechBeeType("STEEL"), getGregtechBeeType("GOLD"), 10);
+			tMutation.restrictBiomeType(Type.HOT);
+		}
+	},
+
+	//Nikolite
+	NIKOLITE(GTPP_Branch_Definition.METAL, "Nikolite", true, Utils.rgbtoHexValue(60, 180, 200), Utils.rgbtoHexValue(40, 150, 170)) {
+		@Override
+		protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+			beeSpecies.addProduct(getStoneComb(), 0.30f);
+			beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.NIKOLITE), 0.05f);
+			beeSpecies.setHumidity(EnumHumidity.NORMAL);
+			beeSpecies.setTemperature(EnumTemperature.HOT);
+		}
+
+		@Override
+		protected void setAlleles(IAllele[] template) {
+			template = BeeDefinition.COMMON.getTemplate();
+		}
+
+		@Override
+		protected void registerMutations() {
+			IBeeMutationCustom tMutation = registerMutation(getGregtechBeeType("ALUMINIUM"), getGregtechBeeType("SILVER"), 8);
+			tMutation.restrictBiomeType(Type.HOT);
+		}
+	},
+
+
+
+
+
+
+
+	/*
+
+
+	CLAY(GTPP_Branch_Definition.ORGANIC, "Clay", true, 0x19d0ec, 0xffdc16) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GT_ModHandler.getModItem(GT_Values.MOD_ID_FR, "beeCombs", 1, 0), 0.30f);
+            beeSpecies.addProduct(new ItemStack(Items.clay_ball, 1), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.DAMP);
+            beeSpecies.setTemperature(EnumTemperature.NORMAL);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.MEADOWS.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+            IBeeMutationCustom tMutation = registerMutation(getSpecies("Industrious"), getSpecies("Diligent"), 20);
+        }
+    },
+    SLIMEBALL(GTPP_Branch_Definition.ORGANIC, "SlimeBall", true, 0x4E9E55, 0x00FF15) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GT_ModHandler.getModItem(GT_Values.MOD_ID_FR, "beeCombs", 1, 15), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.STICKY), 0.30f);
+            beeSpecies.setHumidity(EnumHumidity.DAMP);
+            beeSpecies.setTemperature(EnumTemperature.NORMAL);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.MARSHY.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(getSpecies("Marshy"), CLAY.species, 15);
+        }
+    },
+    PEAT(GTPP_Branch_Definition.ORGANIC, "Peat", true, 0x906237, 0x58300B) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.LIGNIE), 0.30f);
+            beeSpecies.addProduct(GT_ModHandler.getModItem(GT_Values.MOD_ID_FR, "beeCombs", 1, 0), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.NORMAL);
+            beeSpecies.setTemperature(EnumTemperature.NORMAL);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.RURAL.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(getSpecies("Rural"), CLAY.species, 20);
+        }
+    },
+    STICKYRESIN(GTPP_Branch_Definition.ORGANIC, "StickyResin", true, 0x2E8F5B, 0xDCC289) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GT_ModHandler.getModItem(GT_Values.MOD_ID_FR, "beeCombs", 1, 0), 0.30f);
+            beeSpecies.addProduct(ItemList.IC2_Resin.get(1, new Object[0]), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.NORMAL);
+            beeSpecies.setTemperature(EnumTemperature.NORMAL);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.MEADOWS.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(SLIMEBALL.species, PEAT.species, 25);
+        }
+    },
+    COAL(GTPP_Branch_Definition.ORGANIC, "Coal", true, 0x666666, 0x525252) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.LIGNIE), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.COAL), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.NORMAL);
+            beeSpecies.setTemperature(EnumTemperature.NORMAL);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.AUSTERE.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(getSpecies("Industrious"), PEAT.species, 18);
+        }
+    },
+    OIL(GTPP_Branch_Definition.ORGANIC, "Oil", true, 0x4C4C4C, 0x333333) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GT_ModHandler.getModItem(GT_Values.MOD_ID_FR, "beeCombs", 1, 0), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.OIL), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.DAMP);
+            beeSpecies.setTemperature(EnumTemperature.NORMAL);
+            beeSpecies.setNocturnal();
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.MEADOWS.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(COAL.species, STICKYRESIN.species, 8);
+        }
+    },
+    REDSTONE(GTPP_Branch_Definition.GEM, "Redstone", true, 0x7D0F0F, 0xD11919) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.STONE), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.REDSTONE), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.NORMAL);
+            beeSpecies.setTemperature(EnumTemperature.NORMAL);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.COMMON.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(getSpecies("Industrious"), getSpecies("Demonic"), 20);
+        }
+    },
+    LAPIS(GTPP_Branch_Definition.GEM, "Lapis", true, 0x1947D1, 0x476CDA) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.STONE), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.LAPIS), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.NORMAL);
+            beeSpecies.setTemperature(EnumTemperature.NORMAL);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.COMMON.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(getSpecies("Demonic"), getSpecies("Imperial"), 20);
+        }
+    },
+    CERTUS(GTPP_Branch_Definition.GEM, "CertusQuartz", true, 0x57CFFB, 0xBBEEFF) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.STONE), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.CERTUS), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.NORMAL);
+            beeSpecies.setTemperature(EnumTemperature.NORMAL);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.COMMON.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(getSpecies("Hermitic"), LAPIS.species, 20);
+        }
+    },
+    RUBY(GTPP_Branch_Definition.GEM, "Ruby", true, 0xE6005C, 0xCC0052) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.STONE), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.RUBY), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.NORMAL);
+            beeSpecies.setTemperature(EnumTemperature.NORMAL);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.COMMON.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(REDSTONE.species, DIAMOND.species, 10);
+        }
+    },
+    SAPPHIRE(GTPP_Branch_Definition.GEM, "Sapphire", true, 0x0033CC, 0x00248F) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.STONE), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.SAPPHIRE), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.NORMAL);
+            beeSpecies.setTemperature(EnumTemperature.NORMAL);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.COMMON.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(CERTUS.species, LAPIS.species, 10);
+        }
+    },
+    DIAMOND(GTPP_Branch_Definition.GEM, "Diamond", true, 0xCCFFFF, 0xA3CCCC) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.STONE), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.DIAMOND), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.NORMAL);
+            beeSpecies.setTemperature(EnumTemperature.NORMAL);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.COMMON.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(CERTUS.species, COAL.species, 6);
+        }
+    },
+    OLIVINE(GTPP_Branch_Definition.GEM, "Olivine", true, 0x248F24, 0xCCFFCC) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.STONE), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.OLIVINE), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.NORMAL);
+            beeSpecies.setTemperature(EnumTemperature.NORMAL);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.COMMON.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(CERTUS.species, getSpecies("Ended"), 10);
+        }
+    },
+    EMERALD(GTPP_Branch_Definition.GEM, "Emerald", true, 0x248F24, 0x2EB82E) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.STONE), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.EMERALD), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.NORMAL);
+            beeSpecies.setTemperature(EnumTemperature.COLD);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.COMMON.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(OLIVINE.species, DIAMOND.species, 8);
+        }
+    },
+    COPPER(GTPP_Branch_Definition.METAL, "Copper", true, 0xFF6600, 0xE65C00) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.SLAG), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.COPPER), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.NORMAL);
+            beeSpecies.setTemperature(EnumTemperature.NORMAL);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.COMMON.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(getSpecies("Majestic"), CLAY.species, 25);
+        }
+    },
+    TIN(GTPP_Branch_Definition.METAL, "Tin", true, 0xD4D4D4, 0xDDDDDD) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.SLAG), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.TIN), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.NORMAL);
+            beeSpecies.setTemperature(EnumTemperature.NORMAL);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.COMMON.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(CLAY.species, getSpecies("Diligent"), 25);
+        }
+    },
+    LEAD(GTPP_Branch_Definition.METAL, "Lead", true, 0x666699, 0xA3A3CC) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.SLAG), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.LEAD), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.DAMP);
+            beeSpecies.setTemperature(EnumTemperature.WARM);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.COMMON.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(COAL.species, COPPER.species, 25);
+        }
+    },
+    IRON(GTPP_Branch_Definition.METAL, "Iron", true, 0xDA9147, 0xDE9C59) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.SLAG), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.IRON), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.NORMAL);
+            beeSpecies.setTemperature(EnumTemperature.NORMAL);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.COMMON.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(TIN.species, COPPER.species, 25);
+        }
+    },
+    STEEL(GTPP_Branch_Definition.METAL, "Steel", true, 0x808080, 0x999999) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.SLAG), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.STEEL), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.NORMAL);
+            beeSpecies.setTemperature(EnumTemperature.NORMAL);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.COMMON.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(IRON.species, COAL.species, 20);
+        }
+    },
+    NICKEL(GTPP_Branch_Definition.METAL, "Nickel", true, 0x8585AD, 0x8585AD) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.SLAG), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.NICKEL), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.NORMAL);
+            beeSpecies.setTemperature(EnumTemperature.NORMAL);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.COMMON.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(IRON.species, COPPER.species, 25);
+        }
+    },
+    ZINC(GTPP_Branch_Definition.METAL, "Zinc", true, 0xF0DEF0, 0xF2E1F2) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.SLAG), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.ZINC), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.NORMAL);
+            beeSpecies.setTemperature(EnumTemperature.NORMAL);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.COMMON.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(IRON.species, TIN.species, 20);
+        }
+    },
+    SILVER(GTPP_Branch_Definition.METAL, "Silver", true, 0xC2C2D6, 0xCECEDE) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.SLAG), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.SILVER), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.NORMAL);
+            beeSpecies.setTemperature(EnumTemperature.NORMAL);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.COMMON.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(LEAD.species, TIN.species, 20);
+        }
+    },
+    GOLD(GTPP_Branch_Definition.METAL, "Gold", true, 0xEBC633, 0xEDCC47) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.SLAG), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.GOLD), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.NORMAL);
+            beeSpecies.setTemperature(EnumTemperature.NORMAL);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.COMMON.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(LEAD.species, COPPER.species, 20);
+        }
+    },
+    ALUMINIUM(GTPP_Branch_Definition.RAREMETAL, "Aluminium", true, 0xB8B8FF, 0xD6D6FF) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.SLAG), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.ALUMINIUM), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.ARID);
+            beeSpecies.setTemperature(EnumTemperature.HOT);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.COMMON.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(NICKEL.species, ZINC.species, 18);
+        }
+    },
+    TITANIUM(GTPP_Branch_Definition.RAREMETAL, "Titanium", true, 0xCC99FF, 0xDBB8FF) {
+        @Override
+        protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.SLAG), 0.30f);
+            beeSpecies.addProduct(GTPP_Bees.combs.getStackForType(CustomCombs.TITANIUM), 0.15f);
+            beeSpecies.setHumidity(EnumHumidity.ARID);
+            beeSpecies.setTemperature(EnumTemperature.HOT);
+        }
+
+        @Override
+        protected void setAlleles(IAllele[] template) {
+            template = BeeDefinition.COMMON.getTemplate();
+        }
+
+        @Override
+        protected void registerMutations() {
+        	IBeeMutationCustom tMutation = registerMutation(REDSTONE.species, ALUMINIUM.species, 5);
+        }
+    }*/
+
+	;
+
+
+	private final GTPP_Branch_Definition branch;
+	private final IAlleleBeeSpeciesCustom species;
+
+	private IAllele[] template;
+	private IBeeGenome genome;
+
+	GTPP_Bee_Definition(GTPP_Branch_Definition branch, String binomial, boolean dominant, int primary, int secondary) {
+		String lowercaseName = this.toString().toLowerCase(Locale.ENGLISH);
+		String species = "species" + WordUtils.capitalize(lowercaseName);
+
+		String uid = "forestry." + species;
+		String description = "for.description." + species;
+		String name = "for.bees.species." + lowercaseName;
+
+		this.branch = branch;
+		this.species = BeeManager.beeFactory.createSpecies(uid, dominant, "Sengir", name, description, branch.getBranch(), binomial, primary, secondary);
+	}
+
+	public static void initBees() {
+		for (GTPP_Bee_Definition bee : values()) {
+			bee.init();
+		}
+		for (GTPP_Bee_Definition bee : values()) {
+			bee.registerMutations();
+		}
+	}
+
+	private static IAlleleBeeSpecies getSpecies(String name) {
+		return (IAlleleBeeSpecies) AlleleManager.alleleRegistry.getAllele((new StringBuilder()).append("forestry.species").append(name).toString());
+	}
+
+	protected abstract void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies);
+
+	protected abstract void setAlleles(IAllele[] template);
+
+	protected abstract void registerMutations();
+
+	private void init() {
+		setSpeciesProperties(species);
+
+		template = branch.getTemplate();
+		AlleleHelper.instance.set(template, EnumBeeChromosome.SPECIES, species);
+		setAlleles(template);
+
+		genome = BeeManager.beeRoot.templateAsGenome(template);
+
+		BeeManager.beeRoot.registerTemplate(template);
+	}
+
+	protected final IBeeMutationCustom registerMutation(IAlleleBeeSpecies parent1, IAlleleBeeSpecies parent2, int chance) {
+		IAllele[] template = getTemplate();
+		Logger.DEBUG_BEES("parent1: "+(parent1 != null));
+		Logger.DEBUG_BEES("parent2: "+(parent2 != null));
+		Logger.DEBUG_BEES("chance: "+(chance));
+		Logger.DEBUG_BEES("template: "+(template != null));
+		return BeeManager.beeMutationFactory.createMutation(parent1, parent2, template, chance);
+	}
+
+	@Override
+	public final IAllele[] getTemplate() {
+		return Arrays.copyOf(template, template.length);
+	}
+
+	@Override
+	public final IBeeGenome getGenome() {
+		return genome;
+	}
+
+	@Override
+	public final IBee getIndividual() {
+		return new Bee(genome);
+	}
+
+	@Override
+	public final ItemStack getMemberStack(EnumBeeType beeType) {
+		IBee bee = getIndividual();
+		return BeeManager.beeRoot.getMemberStack(bee, beeType.ordinal());
+	}
+
+	public final IBeeDefinition getRainResist() {
+		return new BeeVariation.RainResist(this);
+	}
+
+	private static ItemStack getSlagComb(){
+		return issStackValid(ItemUtils.getSimpleStack(GTPP_Bees.Comb_Slag, 1));
+	}
+	private static ItemStack getStoneComb(){
+		return issStackValid(ItemUtils.getSimpleStack(GTPP_Bees.Comb_Stone, 1));
+	}
+
+	private static ItemStack issStackValid(ItemStack result){
+		if (result == null){
+			return ItemUtils.getErrorStack(1);
+		}
+		return result;
+	}
+
+	public static IAlleleBeeSpecies getGregtechBeeType(String name){
+		Class<?> gtBees;    	
+		try {
+			Class gtBeeTypes = Class.forName("gregtech.loaders.misc.GT_BeeDefinition");
+			Enum gtBeeEnumObject = Enum.valueOf(gtBeeTypes, name); 	
+			Field gtBeesField = FieldUtils.getDeclaredField(gtBeeTypes, "species", true);
+			gtBeesField.setAccessible(true);
+			ReflectionUtils.makeFieldAccessible(gtBeesField);
+			Object beeType = gtBeesField.get(gtBeeEnumObject);	    		    	
+			return (IAlleleBeeSpecies) beeType;
+		}		
+		catch (ClassNotFoundException | IllegalArgumentException | IllegalAccessException e) {
+			e.printStackTrace();
+		}    	
+		return null;
+	}
+}
diff --git a/src/main/java/gtPlusPlus/xmod/forestry/bees/custom/GTPP_Bees.java b/src/main/java/gtPlusPlus/xmod/forestry/bees/custom/GTPP_Bees.java
new file mode 100644
index 0000000000..49b8da0d1b
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/forestry/bees/custom/GTPP_Bees.java
@@ -0,0 +1,195 @@
+package gtPlusPlus.xmod.forestry.bees.custom;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import org.apache.commons.lang3.reflect.FieldUtils;
+
+import cpw.mods.fml.common.Loader;
+import forestry.api.genetics.AlleleManager;
+import forestry.api.genetics.IAllele;
+import gregtech.GT_Mod;
+import gregtech.api.enums.Materials;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.item.base.ingots.BaseItemIngot_OLD;
+import gtPlusPlus.core.item.base.misc.BaseItemMisc;
+import gtPlusPlus.core.item.base.misc.BaseItemMisc.MiscTypes;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.minecraft.FluidUtils;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+public class GTPP_Bees {
+	
+	//Custom Comb Drop Base Items
+	public static Item dropForceGem;
+	public static Item dropBiomassBlob;
+	public static Item dropEthanolBlob;
+	public static Item dropNikoliteDust;
+	public static Item dropFluorineBlob;
+
+	//Base Comb Item
+    public static ItemCustomComb combs;
+
+    //Combs obtained via reflection
+    public static ItemStack Comb_Slag;
+    public static ItemStack Comb_Stone;
+    
+    //Materials obtained via reflection
+    public static Materials PTFE;
+    public static Materials PBS;
+
+	//public static GTPP_Branch_Definition definition;
+    
+
+    public GTPP_Bees() {
+        if (Loader.isModLoaded("Forestry") /*&& tryGetBeesBoolean()*/) {
+        	
+        	for (IAllele o : AlleleManager.alleleRegistry.getRegisteredAlleles().values()){
+        		//Utils.LOG_DEBUG_BEES(" ==================================================");
+        		//Utils.LOG_DEBUG_BEES(" Name: "+o.getName());
+        		//Utils.LOG_DEBUG_BEES(" Name: "+o.getUnlocalizedName());
+        		//Utils.LOG_DEBUG_BEES(" getUID: "+o.getUID());
+        		//Utils.LOG_DEBUG_BEES(" isDominant: "+o.isDominant());
+        	}
+        	
+        	//Set Materials and Comb stacks from GT via Reflection
+        	setMaterials();
+        	setCustomItems();
+        	
+        	try {
+            combs = new ItemCustomComb();
+            combs.initCombsRecipes();
+            GTPP_Bee_Definition.initBees();    
+        	}
+        	catch (Throwable t){
+        		Logger.BEES("Failed to load bees, probably due to an ancient forestry version");
+        		t.printStackTrace();
+        	}
+        }
+    }
+    
+    private void setCustomItems() {
+    	dropForceGem = new BaseItemMisc("Force", new short[]{250, 250, 20}, 64, MiscTypes.GEM, null);
+    	//mGregMatLoader.enableMaterial(Materials.Force);
+    	//MaterialUtils.tryEnableMaterial(Materials.Force);
+    	//MaterialUtils.tryEnableMaterialPart(OrePrefixes.dust, Materials.Force);
+    	//MaterialUtils.tryEnableMaterialPart(OrePrefixes.ingot, Materials.Force);
+    	dropBiomassBlob = new BaseItemMisc("Biomass", new short[]{33, 225, 24}, 64, MiscTypes.DROP, null);
+    	dropEthanolBlob = new BaseItemMisc("Ethanol", new short[]{255, 128, 0}, 64, MiscTypes.DROP, null);
+    	
+    	//Nikolite may not exist, so lets make it.
+    	dropNikoliteDust = ItemUtils.generateSpecialUseDusts("Nikolite", "Nikolite", Utils.rgbtoHexValue(60, 180, 200))[2];
+    	//mGregMatLoader.enableMaterial(Materials.BlueAlloy);
+    	//mGregMatLoader.enableMaterial(Materials.Nikolite);
+    	//MaterialUtils.tryEnableMaterial(Materials.Nikolite);
+    	//MaterialUtils.tryEnableMaterialPart(OrePrefixes.dust, Materials.Nikolite);
+    	//MaterialUtils.tryEnableMaterialPart(OrePrefixes.ingot, Materials.Nikolite);
+    	//MaterialUtils.tryEnableMaterialPart(OrePrefixes.plate, Materials.Nikolite);
+    	//MaterialUtils.tryEnableMaterial(Materials.BlueAlloy);
+    	if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("ingotNikolite", 1) == null){
+    		new BaseItemIngot_OLD("itemIngotNikolite", "Nikolite", Utils.rgbtoHexValue(60, 180, 200), 0);
+    	}
+    	
+    	dropFluorineBlob = new BaseItemMisc("Fluorine", new short[]{30, 230, 230}, 64, MiscTypes.DROP, null);
+    	addRecipes();
+	}
+    
+    private void addRecipes(){
+    	addExtractorRecipe(ItemUtils.getSimpleStack(dropBiomassBlob), FluidUtils.getFluidStack("biomass", 30));
+    	addExtractorRecipe(ItemUtils.getSimpleStack(dropEthanolBlob), FluidUtils.getFluidStack("ethanol", 6));
+    	addExtractorRecipe(ItemUtils.getSimpleStack(dropFluorineBlob), FluidUtils.getFluidStack("fluorine", 4));		
+    }
+    
+    private void addExtractorRecipe(ItemStack input, FluidStack output){
+    	CORE.RA.addFluidExtractionRecipe(
+    			input, 
+    			output, 
+    			30, 
+    			8);
+    }
+    
+
+	private static boolean tryGetBeesBoolean(){
+		try {
+			Class<?> mProxy = Class.forName("gregtech.GT_Mod.gregtechproxy");
+			Field mNerf = FieldUtils.getDeclaredField(mProxy, "mGTBees", true);
+			boolean returnValue = (boolean) mNerf.get(GT_Mod.gregtechproxy);
+			return returnValue;
+		}
+		catch (ClassNotFoundException | IllegalArgumentException | IllegalAccessException e) {
+			return false;
+		}		
+	}
+    
+    private void setMaterials(){
+    	try {
+    		
+    	Class<?> gtBees = Class.forName("gregtech.loaders.misc.GT_Bees");
+    	Class<?> gtCombItemClass = Class.forName("gregtech.common.items.ItemComb");
+    	Class gtCombEnumClass = Class.forName("gregtech.common.items.CombType");
+    	Field gtCombs = FieldUtils.getDeclaredField(gtBees, "combs", true);
+    	gtCombs.setAccessible(true);
+    	ReflectionUtils.makeFieldAccessible(gtCombs);
+    	Enum gtCombTypeSlag = Enum.valueOf(gtCombEnumClass, "SLAG");
+    	Enum gtCombTypeStone = Enum.valueOf(gtCombEnumClass, "STONE");    	
+    	Object oCombObject = gtCombs.get(null);
+
+    	Logger.DEBUG_BEES("Field getModifiers: "+gtCombs.getModifiers());
+    	Logger.DEBUG_BEES("Field toGenericString: "+gtCombs.toGenericString());
+    	Logger.DEBUG_BEES("Field getClass: "+gtCombs.getClass());
+    	Logger.DEBUG_BEES("Field isEnumConstant: "+gtCombs.isEnumConstant());
+    	Logger.DEBUG_BEES("Field isSynthetic: "+gtCombs.isSynthetic());
+    	Logger.DEBUG_BEES("Field get(gtBees) != null: "+(gtCombs.get(gtBees) != null));
+    	Logger.DEBUG_BEES("Field isAccessible: "+gtCombs.isAccessible());
+    	    	
+
+		Logger.BEES("gtBees: "+(gtBees != null));
+		Logger.BEES("gtCombItemClass: "+(gtCombItemClass != null));
+		Logger.BEES("gtCombEnumClass: "+(gtCombEnumClass != null));
+		Logger.BEES("gtCombs: "+(gtCombs != null));
+		Logger.BEES("gtCombTypeSlag: "+(gtCombTypeSlag != null));
+		Logger.BEES("gtCombTypeStone: "+(gtCombTypeStone != null));
+		Logger.BEES("oCombObject: "+(oCombObject != null));
+    	
+    	
+    	//if (gtCombItemClass.isInstance(oCombObject)){
+    		Method getStackForType;
+    		getStackForType = gtCombItemClass.getDeclaredMethod("getStackForType", gtCombEnumClass);
+    		
+        	if (getStackForType != null) {
+        		Logger.BEES("Found Method: getStackForType");
+        	}
+    		if (Comb_Slag == null){
+    			Comb_Slag = (ItemStack) getStackForType.invoke(gtBees, gtCombTypeSlag);
+        	}
+        	if (Comb_Stone == null){
+        		Comb_Stone = (ItemStack) getStackForType.invoke(gtBees, gtCombTypeStone);        		
+        	}
+    	/*} 	
+    	else {
+    		Utils.LOG_BEES("oCombObject was not an instance of gregtech.common.items.ItemComb");
+    	}*/
+    	
+    	}
+    	catch (NullPointerException | ClassNotFoundException | IllegalArgumentException | IllegalAccessException | NoSuchMethodException | SecurityException | InvocationTargetException e){
+    		Logger.BEES("Bad Reflection. setMaterials()");
+    	}
+    	
+    	PTFE = trySetValue("Polytetrafluoroethylene");
+    	PBS = trySetValue("StyreneButadieneRubber");
+    }
+    
+    private Materials trySetValue(String material){
+    	Materials mTemp =  Materials.valueOf(material);
+    	if (mTemp != null){
+    		return mTemp;
+    	}
+    	return Materials._NULL;    	
+    }
+}
diff --git a/src/main/java/gtPlusPlus/xmod/forestry/bees/custom/GTPP_Branch_Definition.java b/src/main/java/gtPlusPlus/xmod/forestry/bees/custom/GTPP_Branch_Definition.java
new file mode 100644
index 0000000000..f59f0c537f
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/forestry/bees/custom/GTPP_Branch_Definition.java
@@ -0,0 +1,80 @@
+package gtPlusPlus.xmod.forestry.bees.custom;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import forestry.api.genetics.IAllele;
+import forestry.api.genetics.IClassification;
+import gtPlusPlus.api.objects.Logger;
+
+public enum GTPP_Branch_Definition {
+
+	ORGANIC("ORGANIC"),
+	GEM("GEM"),
+	METAL("METAL"),
+	RAREMETAL("RAREMETAL"),
+	RADIOACTIVE("RADIOACTIVE");
+
+	final String mFieldName;
+	final Enum mActualValues;
+	GTPP_Branch_Definition(String mValue){
+		this.mFieldName = mValue;
+		this.mActualValues = setEnumVar(mValue);
+	}
+
+	public final IAllele[] getTemplate() {		
+		Class gtBranchDefClass;
+		try {
+			gtBranchDefClass = Class.forName("gregtech.loaders.misc.GT_BranchDefinition");
+			Enum enumA = mActualValues;
+			Method methodMyMethod = gtBranchDefClass.getMethod("getTemplate");
+
+			Logger.INFO("[Bees] gtBranchDefClass: "+(gtBranchDefClass != null));
+			Logger.INFO("[Bees] enumA: "+(enumA != null));
+			Logger.INFO("[Bees] methodMyMethod: "+(methodMyMethod != null));
+			
+			return (IAllele[]) methodMyMethod.invoke(enumA);
+		}
+		catch (ClassNotFoundException | NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+			Logger.INFO("[Bees] Bad Reflection. getTemplate()");
+			e.printStackTrace();
+			//gregtech.loaders.misc.GT_BranchDefinition.getTemplate()
+			return null;
+		}		
+	}
+
+	public final IClassification getBranch() {
+		Class gtBranchDefClass;
+		try {
+			gtBranchDefClass = Class.forName("gregtech.loaders.misc.GT_BranchDefinition");
+			Enum enum_MY_SAMPLE_ENUM = mActualValues;
+			Method methodMyMethod = gtBranchDefClass.getMethod("getBranch");
+			
+
+			Logger.INFO("[Bees] gtBranchDefClass: "+(gtBranchDefClass != null));
+			Logger.INFO("[Bees] enum_MY_SAMPLE_ENUM: "+(enum_MY_SAMPLE_ENUM != null));
+			Logger.INFO("[Bees] methodMyMethod: "+(methodMyMethod != null));
+			
+			return (IClassification) methodMyMethod.invoke(enum_MY_SAMPLE_ENUM);
+		}
+		catch (ClassNotFoundException | NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+			Logger.INFO("[Bees] Bad Reflection. getBranch()");
+			e.printStackTrace();
+			return null;
+		}
+	}	
+
+	private Enum setEnumVar(String value){
+		try {
+			Class gtBranchDefClass = Class.forName("gregtech.loaders.misc.GT_BranchDefinition");
+			Enum branchDef = Enum.valueOf(gtBranchDefClass, value);
+			return branchDef;
+		}
+		catch (ClassNotFoundException  e){
+			return null;
+		}
+	}
+
+
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/forestry/bees/custom/ItemCustomComb.java b/src/main/java/gtPlusPlus/xmod/forestry/bees/custom/ItemCustomComb.java
new file mode 100644
index 0000000000..813ebcbe25
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/forestry/bees/custom/ItemCustomComb.java
@@ -0,0 +1,181 @@
+package gtPlusPlus.xmod.forestry.bees.custom;
+
+import java.lang.reflect.Field;
+import java.util.List;
+
+import org.apache.commons.lang3.reflect.FieldUtils;
+
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+
+import gregtech.GT_Mod;
+import gregtech.api.enums.*;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Utility;
+
+import forestry.api.core.Tabs;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+
+public class ItemCustomComb extends Item {
+	@SideOnly(Side.CLIENT)
+	private IIcon secondIcon;
+
+	public ItemCustomComb() {
+		super();
+		this.setCreativeTab(Tabs.tabApiculture);
+		this.setHasSubtypes(true);
+		this.setUnlocalizedName("gtpp.comb");
+		GameRegistry.registerItem(this, "gtpp.comb", CORE.MODID);
+	}
+
+	public ItemStack getStackForType(CustomCombs type) {
+		return new ItemStack(this, 1, type.ordinal());
+	}
+
+	public ItemStack getStackForType(CustomCombs type, int count) {
+		return new ItemStack(this, count, type.ordinal());
+	}
+
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void getSubItems(Item item, CreativeTabs tabs, List list) {
+		for (CustomCombs type : CustomCombs.values()) {
+			if (type.showInList) {
+				list.add(this.getStackForType(type));
+			}
+		}
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public boolean requiresMultipleRenderPasses() {
+		return true;
+	}
+
+	@Override
+	public int getRenderPasses(int meta) {
+		return 2;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void registerIcons(IIconRegister par1IconRegister) {
+		this.itemIcon = par1IconRegister.registerIcon("forestry:beeCombs.0");
+		this.secondIcon = par1IconRegister.registerIcon("forestry:beeCombs.1");
+	}
+
+	@Override
+	public IIcon getIcon(ItemStack stack, int pass) {
+		return (pass == 0) ? itemIcon : secondIcon;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public int getColorFromItemStack(ItemStack stack, int pass) {
+		int meta = Math.max(0, Math.min(CustomCombs.values().length - 1, stack.getItemDamage()));
+		int colour = CustomCombs.values()[meta].getColours()[0];
+
+		if (pass >= 1) {
+			colour = CustomCombs.values()[meta].getColours()[1];
+		}
+
+		return colour;
+	}
+
+	@Override
+	public String getItemStackDisplayName(ItemStack stack) {
+		return CustomCombs.values()[stack.getItemDamage()].getName();
+	}
+
+	public void initCombsRecipes() {
+		ItemStack tComb;
+	    
+		tComb = getStackForType(CustomCombs.SILICON);
+		addSpecialCent(tComb, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Silicon, 1), 30);
+		//addProcess(tComb, Materials.Silver, 100);
+		//addProcess(tComb, Materials.Galena, 100);
+
+		//Rubbers
+		tComb = getStackForType(CustomCombs.RUBBER);
+		addSpecialCent(tComb, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Rubber, 1), 30);
+		tComb = getStackForType(CustomCombs.PLASTIC);
+		addSpecialCent(tComb, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Plastic, 1), 20);
+		tComb = getStackForType(CustomCombs.PTFE);
+		addSpecialCent(tComb, GT_OreDictUnificator.get(OrePrefixes.dustTiny, GTPP_Bees.PTFE, 1), 10);
+		tComb = getStackForType(CustomCombs.PBS);
+		addSpecialCent(tComb, GT_OreDictUnificator.get(OrePrefixes.dustTiny, GTPP_Bees.PBS, 1), 5);
+		
+		
+		//Fuels
+		tComb = getStackForType(CustomCombs.BIOMASS);
+		addSpecialCent(tComb, ItemUtils.getSimpleStack(GTPP_Bees.dropBiomassBlob), 5);
+		tComb = getStackForType(CustomCombs.PBS);
+		addSpecialCent(tComb, ItemUtils.getSimpleStack(GTPP_Bees.dropEthanolBlob), 5);
+
+		//Misc Materials
+		tComb = getStackForType(CustomCombs.FORCE);
+		addSpecialCent(tComb, ItemUtils.getSimpleStack(GTPP_Bees.dropForceGem), 5);
+		tComb = getStackForType(CustomCombs.FLUORINE);
+		addSpecialCent(tComb, ItemUtils.getSimpleStack(GTPP_Bees.dropFluorineBlob), 5);
+		tComb = getStackForType(CustomCombs.NIKOLITE);
+		addSpecialCent(tComb, ItemUtils.getSimpleStack(GTPP_Bees.dropNikoliteDust), 5);
+		
+	}
+	public void addSpecialCent(ItemStack tComb, ItemStack aOutput, int chance){
+		GT_Values.RA.addCentrifugeRecipe(tComb, GT_Values.NI, GT_Values.NF, GT_Values.NF, aOutput,	ItemList.FR_Wax.get(1, new Object[0]), GT_Values.NI, GT_Values.NI, GT_Values.NI, GT_Values.NI, new int[] { chance * 100, 3000 }, 128, 5);
+		//RecipeManagers.centrifugeManager.addRecipe(40, tComb, ImmutableMap.of(aOutput, chance * 0.01f, ItemList.FR_Wax.get(1, new Object[0]), 0.3f));
+	}
+	
+	public void addSpecialCent(ItemStack tComb, ItemStack aOutput, int chance, ItemStack aOutput2, int chance2){
+		GT_Values.RA.addCentrifugeRecipe(tComb, GT_Values.NI, GT_Values.NF, GT_Values.NF, aOutput,	ItemList.FR_Wax.get(1, new Object[0]), aOutput2, GT_Values.NI, GT_Values.NI, GT_Values.NI, new int[] { chance * 100, 3000, chance2 * 100 }, 128, 5);
+		//RecipeManagers.centrifugeManager.addRecipe(40, tComb, ImmutableMap.of(aOutput, chance * 0.01f, ItemList.FR_Wax.get(1, new Object[0]), 0.3f,aOutput2,chance2 * 0.01f));
+	}
+	
+	public void addSpecialCent(ItemStack tComb, ItemStack aOutput, int chance, ItemStack aOutput2, int chance2, ItemStack aOutput3, int chance3){
+		GT_Values.RA.addCentrifugeRecipe(tComb, GT_Values.NI, GT_Values.NF, GT_Values.NF, aOutput,	ItemList.FR_Wax.get(1, new Object[0]), aOutput2, aOutput3, GT_Values.NI, GT_Values.NI, new int[] { chance * 100, 3000, chance2 * 100, chance3*100 }, 128, 5);
+		//RecipeManagers.centrifugeManager.addRecipe(40, tComb, ImmutableMap.of(aOutput, chance * 0.01f, ItemList.FR_Wax.get(1, new Object[0]), 0.3f,aOutput2,chance2 * 0.01f,aOutput3,chance3*0.01f));
+	}
+	
+	public void addProcess(ItemStack tComb, Materials aMaterial, int chance){
+		if(tryGetNerfBoolean()){
+			GT_Values.RA.addChemicalRecipe(GT_Utility.copyAmount(9, tComb), GT_OreDictUnificator.get(OrePrefixes.crushed, aMaterial, 1), Materials.Water.getFluid(1000), aMaterial.mOreByProducts.isEmpty() ? null : aMaterial.mOreByProducts.get(0).getMolten(144), GT_OreDictUnificator.get(OrePrefixes.crushedPurified, aMaterial, 4), 96);
+			GT_Values.RA.addAutoclaveRecipe(GT_Utility.copyAmount(16, tComb), Materials.UUMatter.getFluid(Math.max(1, ((aMaterial.getMass()+9)/10))), GT_OreDictUnificator.get(OrePrefixes.crushedPurified, aMaterial, 1), 10000, (int) (aMaterial.getMass() * 128), 384);
+		}else{
+			GT_Values.RA.addCentrifugeRecipe(tComb, GT_Values.NI, GT_Values.NF, GT_Values.NF, GT_OreDictUnificator.get(OrePrefixes.dustTiny, aMaterial, 1),	ItemList.FR_Wax.get(1, new Object[0]), GT_Values.NI, GT_Values.NI, GT_Values.NI, GT_Values.NI, new int[] { chance * 100, 3000 }, 128, 5);
+			//RecipeManagers.centrifugeManager.addRecipe(40, tComb, ImmutableMap.of(GT_OreDictUnificator.get(OrePrefixes.dustTiny, aMaterial, 1), chance * 0.01f, ItemList.FR_Wax.get(1, new Object[0]), 0.3f));
+		}
+	}
+	
+	public void addProcess(ItemStack tComb, Materials aInMaterial, Materials aOutMaterial, int chance){
+		if(tryGetNerfBoolean()){
+			GT_Values.RA.addChemicalRecipe(GT_Utility.copyAmount(9, tComb), GT_OreDictUnificator.get(OrePrefixes.crushed, aInMaterial, 1), Materials.Water.getFluid(1000), aInMaterial.mOreByProducts.isEmpty() ? null : aInMaterial.mOreByProducts.get(0).getMolten(144), GT_OreDictUnificator.get(OrePrefixes.crushedPurified, aOutMaterial, 4), 96);
+			GT_Values.RA.addAutoclaveRecipe(GT_Utility.copyAmount(16, tComb), Materials.UUMatter.getFluid(Math.max(1, ((aOutMaterial.getMass()+9)/10))), GT_OreDictUnificator.get(OrePrefixes.crushedPurified, aOutMaterial, 1), 10000, (int) (aOutMaterial.getMass() * 128), 384);
+		}else{
+			GT_Values.RA.addCentrifugeRecipe(tComb, GT_Values.NI, GT_Values.NF, GT_Values.NF, GT_OreDictUnificator.get(OrePrefixes.dustTiny, aOutMaterial, 1),	ItemList.FR_Wax.get(1, new Object[0]), GT_Values.NI, GT_Values.NI, GT_Values.NI, GT_Values.NI, new int[] { chance * 100, 3000 }, 128, 5);
+			//RecipeManagers.centrifugeManager.addRecipe(40, tComb, ImmutableMap.of(GT_OreDictUnificator.get(OrePrefixes.dustTiny, aOutMaterial, 1), chance * 0.01f, ItemList.FR_Wax.get(1, new Object[0]), 0.3f));
+		}
+	}
+	
+	private static boolean tryGetNerfBoolean(){
+		try {
+			Class mProxy = Class.forName("gregtech.GT_Mod.gregtechproxy");
+			Field mNerf = FieldUtils.getDeclaredField(mProxy, "mNerfedCombs", true);
+			boolean returnValue = (boolean) mNerf.get(GT_Mod.gregtechproxy);
+			return returnValue;
+		}
+		catch (ClassNotFoundException | IllegalArgumentException | IllegalAccessException e) {
+			return false;
+		}		
+	}
+	
+}
\ No newline at end of file
diff --git a/src/main/java/gtPlusPlus/xmod/forestry/bees/gui/ContainerBeeHouse.java b/src/main/java/gtPlusPlus/xmod/forestry/bees/gui/ContainerBeeHouse.java
new file mode 100644
index 0000000000..4aa9de8220
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/forestry/bees/gui/ContainerBeeHouse.java
@@ -0,0 +1,43 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2014 SirSengir.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v3
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/lgpl-3.0.txt
+ *
+ * Various Contributors including, but not limited to:
+ * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
+ ******************************************************************************/
+package gtPlusPlus.xmod.forestry.bees.gui;
+
+import net.minecraft.entity.player.InventoryPlayer;
+
+import forestry.apiculture.gui.ContainerBeeHelper;
+import forestry.apiculture.gui.IContainerBeeHousing;
+import forestry.apiculture.tiles.TileBeeHousingBase;
+import forestry.core.gui.ContainerTile;
+import forestry.core.network.IForestryPacketClient;
+import forestry.core.network.packets.PacketGuiUpdate;
+
+public class ContainerBeeHouse extends ContainerTile<TileBeeHousingBase> implements IContainerBeeHousing {
+
+	public ContainerBeeHouse(InventoryPlayer player, TileBeeHousingBase tile, boolean hasFrames) {
+		super(tile, player, 8, 108);
+		ContainerBeeHelper.addSlots(this, tile, hasFrames);
+	}
+
+	private int beeProgress = 0;
+
+	@Override
+	public void detectAndSendChanges() {
+		super.detectAndSendChanges();
+
+		int beeProgress = tile.getBeekeepingLogic().getBeeProgressPercent();
+		if (this.beeProgress != beeProgress) {
+			this.beeProgress = beeProgress;
+			IForestryPacketClient packet = new PacketGuiUpdate(tile);
+			sendPacketToCrafters(packet);
+		}
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/forestry/bees/gui/GuiBeeHouse.java b/src/main/java/gtPlusPlus/xmod/forestry/bees/gui/GuiBeeHouse.java
new file mode 100644
index 0000000000..89a2f121d9
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/forestry/bees/gui/GuiBeeHouse.java
@@ -0,0 +1,53 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2014 SirSengir.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v3
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/lgpl-3.0.txt
+ *
+ * Various Contributors including, but not limited to:
+ * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
+ ******************************************************************************/
+package gtPlusPlus.xmod.forestry.bees.gui;
+
+import net.minecraft.inventory.Container;
+
+import forestry.apiculture.gui.IContainerBeeHousing;
+import forestry.apiculture.gui.IGuiBeeHousingInventory;
+import forestry.core.config.Constants;
+import forestry.core.gui.GuiForestryTitled;
+import forestry.core.render.EnumTankLevel;
+
+public class GuiBeeHouse<C extends Container & IContainerBeeHousing> extends GuiForestryTitled<C, IGuiBeeHousingInventory> {
+
+	public enum Icon {
+		APIARY("/apiary.png"),
+		BEE_HOUSE("/alveary.png");
+
+		private final String path;
+
+		Icon(String path) {
+			this.path = path;
+		}
+	}
+
+	public GuiBeeHouse(IGuiBeeHousingInventory tile, C container, Icon icon) {
+		super(Constants.TEXTURE_PATH_GUI + icon.path, container, tile);
+		ySize = 190;
+	}
+
+	@Override
+	protected void drawGuiContainerBackgroundLayer(float var1, int mouseX, int mouseY) {
+		super.drawGuiContainerBackgroundLayer(var1, mouseX, mouseY);
+
+		drawHealthMeter(guiLeft + 20, guiTop + 37, inventory.getHealthScaled(46), EnumTankLevel.rateTankLevel(inventory.getHealthScaled(100)));
+	}
+
+	private void drawHealthMeter(int x, int y, int height, EnumTankLevel rated) {
+		int i = 176 + rated.getLevelScaled(16);
+		int k = 0;
+
+		this.drawTexturedModalRect(x, y + 46 - height, i, k + 46 - height, 4, height);
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/forestry/bees/inventory/InventoryDenseBeeHouse.java b/src/main/java/gtPlusPlus/xmod/forestry/bees/inventory/InventoryDenseBeeHouse.java
new file mode 100644
index 0000000000..47c380fdfe
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/forestry/bees/inventory/InventoryDenseBeeHouse.java
@@ -0,0 +1,94 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2014 SirSengir.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v3
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/lgpl-3.0.txt
+ *
+ * Various Contributors including, but not limited to:
+ * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
+ ******************************************************************************/
+package gtPlusPlus.xmod.forestry.bees.inventory;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+
+import forestry.api.apiculture.*;
+import forestry.apiculture.InventoryBeeHousing;
+import forestry.apiculture.inventory.IApiaryInventory;
+import forestry.core.access.IAccessHandler;
+import forestry.core.utils.SlotUtil;
+
+public class InventoryDenseBeeHouse extends InventoryBeeHousing implements IApiaryInventory {
+	public static final int SLOT_FRAMES_1 = 9;
+	public static final int SLOT_FRAMES_COUNT = 3;
+
+	public InventoryDenseBeeHouse(IAccessHandler accessHandler) {
+		super(12, accessHandler);
+	}
+
+	@Override
+	public boolean canSlotAccept(int slotIndex, ItemStack itemStack) {
+		if (SlotUtil.isSlotInRange(slotIndex, SLOT_FRAMES_1, SLOT_FRAMES_COUNT)) {
+			return (itemStack.getItem() instanceof IHiveFrame) && (getStackInSlot(slotIndex) == null);
+		}
+
+		return super.canSlotAccept(slotIndex, itemStack);
+	}
+
+	// override for pipe automation
+	@Override
+	public boolean isItemValidForSlot(int slotIndex, ItemStack itemStack) {
+		if (SlotUtil.isSlotInRange(slotIndex, SLOT_FRAMES_1, SLOT_FRAMES_COUNT)) {
+			return false;
+		}
+		return super.isItemValidForSlot(slotIndex, itemStack);
+	}
+
+	public Collection<IHiveFrame> getFrames() {
+		Collection<IHiveFrame> hiveFrames = new ArrayList<>(SLOT_FRAMES_COUNT);
+
+		for (int i = SLOT_FRAMES_1; i < SLOT_FRAMES_1 + SLOT_FRAMES_COUNT; i++) {
+			ItemStack stackInSlot = getStackInSlot(i);
+			if (stackInSlot == null) {
+				continue;
+			}
+
+			Item itemInSlot = stackInSlot.getItem();
+			if (itemInSlot instanceof IHiveFrame) {
+				hiveFrames.add((IHiveFrame) itemInSlot);
+			}
+		}
+
+		return hiveFrames;
+	}
+
+	@Override
+	public void wearOutFrames(IBeeHousing beeHousing, int amount) {
+		IBeekeepingMode beekeepingMode = BeeManager.beeRoot.getBeekeepingMode(beeHousing.getWorld());
+		int wear = Math.round(amount * beekeepingMode.getWearModifier());
+
+		for (int i = SLOT_FRAMES_1; i < SLOT_FRAMES_1 + SLOT_FRAMES_COUNT; i++) {
+			ItemStack hiveFrameStack = getStackInSlot(i);
+			if (hiveFrameStack == null) {
+				continue;
+			}
+
+			Item hiveFrameItem = hiveFrameStack.getItem();
+			if (!(hiveFrameItem instanceof IHiveFrame)) {
+				continue;
+			}
+
+			IHiveFrame hiveFrame = (IHiveFrame) hiveFrameItem;
+
+			ItemStack queenStack = getQueen();
+			IBee queen = BeeManager.beeRoot.getMember(queenStack);
+			ItemStack usedFrame = hiveFrame.frameUsed(beeHousing, hiveFrameStack, queen, wear);
+
+			setInventorySlotContents(i, usedFrame);
+		}
+	}
+}
diff --git a/src/main/java/gtPlusPlus/xmod/forestry/bees/items/FR_CustomBee.java b/src/main/java/gtPlusPlus/xmod/forestry/bees/items/FR_CustomBee.java
new file mode 100644
index 0000000000..7d9a9e231b
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/forestry/bees/items/FR_CustomBee.java
@@ -0,0 +1,5 @@
+package gtPlusPlus.xmod.forestry.bees.items;
+
+public class FR_CustomBee {
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/forestry/bees/items/FR_ItemRegistry.java b/src/main/java/gtPlusPlus/xmod/forestry/bees/items/FR_ItemRegistry.java
new file mode 100644
index 0000000000..e1d37ab463
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/forestry/bees/items/FR_ItemRegistry.java
@@ -0,0 +1,107 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2014 SirSengir.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v3
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/lgpl-3.0.txt
+ *
+ * Various Contributors including, but not limited to:
+ * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
+ ******************************************************************************/
+package gtPlusPlus.xmod.forestry.bees.items;
+import cpw.mods.fml.common.Optional;
+import cpw.mods.fml.common.registry.GameRegistry;
+
+import net.minecraft.item.EnumRarity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.WeightedRandomChestContent;
+
+import forestry.core.utils.StringUtil;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.lib.LoadedMods;
+import net.minecraftforge.common.ChestGenHooks;
+
+public class FR_ItemRegistry {
+
+
+	//----- Apiary Frames ----------------------
+	//public static FR_ItemHiveFrame frameUntreated;
+	//public static FR_ItemHiveFrame frameImpregnated;
+	//public static FR_ItemHiveFrame frameProven;
+
+	//Magic Bee Frame Items
+	public static MB_ItemFrame hiveFrameAccelerated;
+	public static MB_ItemFrame hiveFrameVoid;
+	public static MB_ItemFrame hiveFrameMutagenic;
+	public static MB_ItemFrame hiveFrameBusy;
+
+	//Extra Bee Frame Items
+	public static MB_ItemFrame hiveFrameCocoa;
+	public static MB_ItemFrame hiveFrameCaged;
+	public static MB_ItemFrame hiveFrameSoul;
+	public static MB_ItemFrame hiveFrameClay;
+	public static MB_ItemFrame hiveFrameNova;
+	
+	// Frame Items added by bartimaeusnek
+	public static MB_ItemFrame hiveFrameDecay; 
+	public static MB_ItemFrame hiveFrameSlow;
+	public static MB_ItemFrame hiveFrameStalilize;
+	public static MB_ItemFrame hiveFrameArborist;
+	
+	@Optional.Method(modid = "Forestry")
+	public static void Register() {
+
+		//Forestry Frames
+		//frameUntreated = registerItem(new FR_ItemHiveFrame(80, 0.9f), "frameUntreated");
+		//frameImpregnated = registerItem(new FR_ItemHiveFrame(240, 0.4f), "frameImpregnated");
+		//frameProven = registerItem(new FR_ItemHiveFrame(720, 0.3f), "frameProven");
+
+		//Magic Bee like Frames
+		
+		if (!CORE.GTNH) {
+			hiveFrameVoid = new MB_ItemFrame(MB_FrameType.VOID, EnumRarity.rare, "Makes your bee die in the blink of an eye.");
+		}
+		else {
+			hiveFrameVoid = new MB_ItemFrame(MB_FrameType.USELESS, EnumRarity.common, "No more cheaty frames for GTNH players.");
+		}
+		
+		hiveFrameAccelerated = new MB_ItemFrame(MB_FrameType.ACCELERATED, "Longevity for bees isn't very common, especially if they're working harder.");
+		hiveFrameMutagenic = new MB_ItemFrame(MB_FrameType.MUTAGENIC, EnumRarity.epic, "Evolution of the fittest, finest and fastest.");
+		hiveFrameBusy = new MB_ItemFrame(MB_FrameType.BUSY, "Your bee will work harder and longer than you expected.");
+		ChestGenHooks.addItem(ChestGenHooks.STRONGHOLD_CORRIDOR, new WeightedRandomChestContent(new ItemStack(hiveFrameVoid), 1, 1, 14));
+		ChestGenHooks.addItem(ChestGenHooks.STRONGHOLD_LIBRARY, new WeightedRandomChestContent(new ItemStack(hiveFrameVoid), 1, 3, 18));
+		ChestGenHooks.addItem(ChestGenHooks.DUNGEON_CHEST, new WeightedRandomChestContent(new ItemStack(hiveFrameVoid), 1, 1, 14));
+		ChestGenHooks.addItem(ChestGenHooks.MINESHAFT_CORRIDOR, new WeightedRandomChestContent(new ItemStack(hiveFrameVoid), 1, 1, 9));
+		ChestGenHooks.addItem(ChestGenHooks.PYRAMID_DESERT_CHEST, new WeightedRandomChestContent(new ItemStack(hiveFrameMutagenic), 1, 1, 9));
+		ChestGenHooks.addItem(ChestGenHooks.PYRAMID_JUNGLE_CHEST, new WeightedRandomChestContent(new ItemStack(hiveFrameMutagenic), 1, 3, 12));
+		ChestGenHooks.addItem(ChestGenHooks.MINESHAFT_CORRIDOR, new WeightedRandomChestContent(new ItemStack(hiveFrameMutagenic), 1, 3, 8));
+		ChestGenHooks.addItem(ChestGenHooks.DUNGEON_CHEST, new WeightedRandomChestContent(new ItemStack(hiveFrameMutagenic), 1, 3, 12));
+
+		//Extra Bee like Frames
+		if (!LoadedMods.ExtraBees){
+			hiveFrameCocoa = new MB_ItemFrame(MB_FrameType.COCOA, EnumRarity.common, "");
+			hiveFrameCaged = new MB_ItemFrame(MB_FrameType.CAGE, EnumRarity.common, "");
+			hiveFrameSoul = new MB_ItemFrame(MB_FrameType.SOUL, EnumRarity.common, "");
+			hiveFrameClay = new MB_ItemFrame(MB_FrameType.CLAY, EnumRarity.common, "");
+			hiveFrameNova = new MB_ItemFrame(MB_FrameType.NOVA, EnumRarity.epic, "A Creative Only Frame.");
+		}
+		
+		// Frame Items added by bartimaeusnek
+		hiveFrameDecay = new MB_ItemFrame(MB_FrameType.DECAYING, EnumRarity.uncommon, "Who really needs stable genetics?");
+		hiveFrameSlow = new MB_ItemFrame(MB_FrameType.SLOWING, EnumRarity.common, "The journey is its own reward.");
+		hiveFrameStalilize = new MB_ItemFrame(MB_FrameType.STABILIZING, EnumRarity.rare, "If you wish your bees to keep their form.");
+		hiveFrameArborist = new MB_ItemFrame(MB_FrameType.ARBORISTS, EnumRarity.common, "Who need Bees when you can have Trees?");
+		ChestGenHooks.addItem(ChestGenHooks.PYRAMID_JUNGLE_CHEST, new WeightedRandomChestContent(new ItemStack(hiveFrameArborist), 1, 4, 24));
+		ChestGenHooks.addItem(ChestGenHooks.STRONGHOLD_LIBRARY, new WeightedRandomChestContent(new ItemStack(hiveFrameSlow), 1, 4, 24));
+	}
+
+	protected static <T extends Item> T registerItem(final T item, final String name) {
+		item.setUnlocalizedName(name);
+		GameRegistry.registerItem(item, StringUtil.cleanItemName(item));
+		return item;
+	}
+
+}
+
+
diff --git a/src/main/java/gtPlusPlus/xmod/forestry/bees/items/FR_StringUtil.java b/src/main/java/gtPlusPlus/xmod/forestry/bees/items/FR_StringUtil.java
new file mode 100644
index 0000000000..e075bf1eda
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/forestry/bees/items/FR_StringUtil.java
@@ -0,0 +1,24 @@
+package gtPlusPlus.xmod.forestry.bees.items;
+
+import net.minecraft.util.StatCollector;
+
+public class FR_StringUtil
+{
+	public static String getLocalizedString(final String key)
+	{
+		if(StatCollector.canTranslate(key))
+		{
+			return StatCollector.translateToLocal(key);
+		}
+		return StatCollector.translateToFallback(key);
+	}
+
+	public static String getLocalizedString(final String key, final Object... objects)
+	{
+		if(StatCollector.canTranslate(key))
+		{
+			return String.format(StatCollector.translateToLocal(key), objects);
+		}
+		return String.format(StatCollector.translateToFallback(key), objects);
+	}
+}
diff --git a/src/main/java/gtPlusPlus/xmod/forestry/bees/items/MB_FrameType.java b/src/main/java/gtPlusPlus/xmod/forestry/bees/items/MB_FrameType.java
new file mode 100644
index 0000000000..1016021e44
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/forestry/bees/items/MB_FrameType.java
@@ -0,0 +1,126 @@
+package gtPlusPlus.xmod.forestry.bees.items;
+
+import forestry.api.apiculture.IBeeGenome;
+import forestry.api.apiculture.IBeeModifier;
+
+public enum MB_FrameType implements IBeeModifier
+{
+	//ExtraBees Clone Frames
+	//Name, FrameHP, territory (1f), Mutation rate, lifespan rate, production rate, genetic decay (1f)
+	COCOA("Chocolate", 240, 1.0f, 1.0f, 0.50f, 1.50f, 1f),
+	CAGE("Restraint",  240, 0.5f, 1.0f, 0.75f, 0.75f, 1f),
+	SOUL("Soul", 	   80,  1.0f, 1.5f, 0.75f, 0.25f, 1f),
+	CLAY("Healing",    240, 1.0f, 0.5f, 1.50f, 0.75f, 1f),
+	NOVA("Nova",       240, 1.0f, 100.0f, 0.0001f, 1.00f, 1f),
+
+	
+	//Name, FrameHP, territory (1f), Mutation rate, lifespan rate, production rate, genetic decay (1f)
+	ACCELERATED("Accelerated", 175, 1f, 1.2f, 0.9f, 1.8f, 1f),
+	VOID("Void", 20, 1f, 1f, 0.0001f, 10f, 1f),
+	MUTAGENIC("Mutagenic", 3, 1f, 5f, 0.0001f, 10f, 1f),
+	BUSY("Busy", 2000, 1f, 0f, 3f, 4f, 1f),
+	USELESS("Useless", 100, 1f, 0f, 1f, 1f, 1f),
+	
+	// Frame Items added by bartimaeusnek
+	DECAYING("Decaying", 240, 1f, 1f, 1f, 1f, 10f), //enhanches decay to 10x
+	SLOWING("Slowing", 175, 1f, 0.5f, 2f, 0.5f, 1f), //reduces mutation, production rate and enhanches lifespan
+	STABILIZING("Stabilizing", 60, 1f, 0.1f, 1f, 0.1f, 0.5f), //reduces mutation, production and decay
+	ARBORISTS("Arborists", 240, 3f, 0f, 3f, 0f, 1f); //3x territory and lifespan, sets mutation and production to zero
+
+	private final String frameName;
+	public final int maxDamage;
+
+	private final float territoryMod;
+	private final float mutationMod;
+	private final float lifespanMod;
+	private final float productionMod;
+	private final float floweringMod;
+	private final float geneticDecayMod;
+	private final boolean isSealed;
+	private final boolean isLit;
+	private final boolean isSunlit;
+	private final boolean isHellish;
+
+	MB_FrameType(final String name, final int damage, final float territory, final float mutation, final float lifespan, final float production, final float geneticDecay) {
+		this(name, damage, territory, mutation, lifespan, production, 1f, geneticDecay, false, false, false, false);
+	}
+
+	MB_FrameType(final String name, final int damage,
+			final float territory, final float mutation, final float lifespan, final float production, final float flowering, final float geneticDecay,
+			final boolean sealed, final boolean lit, final boolean sunlit, final boolean hellish)
+	{
+		this.frameName = name;
+		this.maxDamage = damage;
+
+		this.territoryMod = territory;
+		this.mutationMod = mutation;
+		this.lifespanMod = lifespan;
+		this.productionMod = production;
+		this.floweringMod = flowering;
+		this.geneticDecayMod = geneticDecay;
+		this.isSealed = sealed;
+		this.isLit = lit;
+		this.isSunlit = sunlit;
+		this.isHellish = hellish;
+	}
+
+	public String getName()
+	{
+		return this.frameName;
+	}
+
+	public String getLocalizedName()
+	{
+		return FR_StringUtil.getLocalizedString("frame." + this.frameName);
+	}
+
+	@Override
+	public float getTerritoryModifier(final IBeeGenome genome, final float currentModifier) {
+		return this.territoryMod;
+	}
+
+	@Override
+	public float getMutationModifier(final IBeeGenome genome, final IBeeGenome mate, final float currentModifier) {
+		return this.mutationMod;
+	}
+
+	@Override
+	public float getLifespanModifier(final IBeeGenome genome, final IBeeGenome mate, final float currentModifier) {
+		return this.lifespanMod;
+	}
+
+	@Override
+	public float getProductionModifier(final IBeeGenome genome, final float currentModifier) {
+		return this.productionMod;
+	}
+
+	@Override
+	public float getFloweringModifier(final IBeeGenome genome, final float currentModifier) {
+		return this.floweringMod;
+	}
+
+	@Override
+	public float getGeneticDecay(final IBeeGenome genome, final float currentModifier) {
+		return this.geneticDecayMod;
+	}
+
+	@Override
+	public boolean isSealed() {
+		return this.isSealed;
+	}
+
+	@Override
+	public boolean isSelfLighted() {
+		return this.isLit;
+	}
+
+	@Override
+	public boolean isSunlightSimulated() {
+		return this.isSunlit;
+	}
+
+	@Override
+	public boolean isHellish() {
+		return this.isHellish;
+	}
+}
diff --git a/src/main/java/gtPlusPlus/xmod/forestry/bees/items/MB_ItemFrame.java b/src/main/java/gtPlusPlus/xmod/forestry/bees/items/MB_ItemFrame.java
new file mode 100644
index 0000000000..65b6977b8a
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/forestry/bees/items/MB_ItemFrame.java
@@ -0,0 +1,143 @@
+package gtPlusPlus.xmod.forestry.bees.items;
+
+import java.util.List;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.EnumRarity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+
+import forestry.api.apiculture.*;
+import gtPlusPlus.core.creative.AddToCreativeTab;
+import gtPlusPlus.core.lib.CORE;
+
+public class MB_ItemFrame extends Item implements IHiveFrame
+{
+	private final MB_FrameType type;
+	private EnumRarity rarity_value = EnumRarity.uncommon;
+	private final String toolTip;
+
+	public MB_ItemFrame(final MB_FrameType frameType, final String description)
+	{
+		this(frameType, EnumRarity.uncommon, description);
+	}
+
+	public MB_ItemFrame(final MB_FrameType frameType, final EnumRarity rarity, final String description)
+	{
+		super();
+		this.type = frameType;
+		this.setMaxDamage(this.type.maxDamage);
+		this.setMaxStackSize(1);
+		this.setCreativeTab(AddToCreativeTab.tabMisc);
+		this.setUnlocalizedName("frame" + frameType.getName());
+		this.rarity_value = rarity;
+		this.toolTip = description;
+		GameRegistry.registerItem(this, "frame" + frameType.getName());
+	}
+
+	@Override
+	public void addInformation(final ItemStack stack, final EntityPlayer aPlayer, final List list, final boolean bool) {
+		if ((this.toolTip != "") || !this.toolTip.equals("")){
+			list.add(EnumChatFormatting.GRAY+this.toolTip);
+		}
+		super.addInformation(stack, aPlayer, list, bool);
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void registerIcons(final IIconRegister par1IconRegister)
+	{
+		this.itemIcon = par1IconRegister.registerIcon(CORE.MODID + ":frame" + this.type.getName());
+	}
+
+	// --------- IHiveFrame functions -----------------------------------------
+
+	@Override
+	public ItemStack frameUsed(final IBeeHousing housing, ItemStack frame, final IBee queen, final int wear) {
+		frame.setItemDamage(frame.getItemDamage() + wear);
+
+		if (frame.getItemDamage() >= frame.getMaxDamage()) {
+			// Break the frame.
+			frame = null;
+		}
+
+		return frame;
+	}
+
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public EnumRarity getRarity(final ItemStack par1ItemStack){
+		return this.rarity_value;
+	}
+
+	@Override
+	public boolean hasEffect(final ItemStack par1ItemStack){
+		if ((this.rarity_value == EnumRarity.uncommon) || (this.rarity_value == EnumRarity.common)){
+			return false;
+		}
+		return true;
+	}
+
+	@Override
+	public IBeeModifier getBeeModifier() {
+		return this.type;
+	}
+
+	@Override
+	public boolean isBookEnchantable(final ItemStack itemstack1, final ItemStack itemstack2) {
+		return false;
+	}
+
+	@Override
+	public boolean isRepairable() {
+		return false;
+	}
+
+	public float getTerritoryModifier(final IBeeGenome genome, final float currentModifier) {
+		return this.type.getTerritoryModifier(genome, currentModifier);
+	}
+
+	public float getMutationModifier(final IBeeGenome genome, final IBeeGenome mate, final float currentModifier) {
+		return this.type.getMutationModifier(genome, mate, currentModifier);
+	}
+
+	public float getLifespanModifier(final IBeeGenome genome, final IBeeGenome mate, final float currentModifier) {
+		return this.type.getLifespanModifier(genome, mate, currentModifier);
+	}
+
+	public float getProductionModifier(final IBeeGenome genome, final float currentModifier) {
+		return this.type.getProductionModifier(genome, currentModifier);
+	}
+
+	public float getFloweringModifier(final IBeeGenome genome, final float currentModifier) {
+		return this.type.getFloweringModifier(genome, currentModifier);
+	}
+
+	public float getGeneticDecay(final IBeeGenome genome, final float currentModifier) {
+		return this.type.getGeneticDecay(genome, currentModifier);
+	}
+
+	public boolean isSealed() {
+		return this.type.isSealed();
+	}
+
+	public boolean isSelfLighted() {
+		return this.type.isSelfLighted();
+	}
+
+	public boolean isSunlightSimulated() {
+		return this.type.isSunlightSimulated();
+	}
+
+	public boolean isHellish(){
+		return this.type.isHellish();
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/forestry/bees/recipe/FR_Gregtech_Recipes.java b/src/main/java/gtPlusPlus/xmod/forestry/bees/recipe/FR_Gregtech_Recipes.java
new file mode 100644
index 0000000000..ddc401f752
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/forestry/bees/recipe/FR_Gregtech_Recipes.java
@@ -0,0 +1,129 @@
+package gtPlusPlus.xmod.forestry.bees.recipe;
+
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemStack;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.lib.LoadedMods;
+import gtPlusPlus.core.material.ALLOY;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.core.util.minecraft.RecipeUtils;
+import gtPlusPlus.xmod.forestry.bees.items.FR_ItemRegistry;
+
+public class FR_Gregtech_Recipes {
+
+	private static String rod_Electrum = "stickElectrum";
+	private static String rod_LongElectrum = "stickLongElectrum";
+	private static String foil_Electrum = "foilElectrum";
+	private static String rod_Uranium = "stickUranium";
+	private static String rod_LongUranium = "stickLongUranium";
+	private static String foil_Uranium235 = "foilUranium235";
+	private static ItemStack hiveFrameAccelerated = ItemUtils.getSimpleStack(FR_ItemRegistry.hiveFrameAccelerated);
+	private static ItemStack hiveFrameMutagenic = ItemUtils.getSimpleStack(FR_ItemRegistry.hiveFrameMutagenic);
+	private static ItemStack hiveFrameVoid = ItemUtils.getSimpleStack(FR_ItemRegistry.hiveFrameVoid);
+	private static ItemStack hiveFrameBusy = ItemUtils.getSimpleStack(FR_ItemRegistry.hiveFrameBusy);
+
+	private static ItemStack hiveFrameCocoa = ItemUtils.getSimpleStack(FR_ItemRegistry.hiveFrameCocoa);
+	private static ItemStack hiveFrameCaged = ItemUtils.getSimpleStack(FR_ItemRegistry.hiveFrameCaged);
+	private static ItemStack hiveFrameSoul = ItemUtils.getSimpleStack(FR_ItemRegistry.hiveFrameSoul);
+	private static ItemStack hiveFrameClay = ItemUtils.getSimpleStack(FR_ItemRegistry.hiveFrameClay);
+	private static ItemStack hiveFrameNova = ItemUtils.getSimpleStack(FR_ItemRegistry.hiveFrameNova);
+
+	private static ItemStack hiveFrameImpregnated = ItemUtils.getItemStackFromFQRN("Forestry:frameImpregnated", 1);
+	private static ItemStack blockSoulSand = new ItemStack(Blocks.soul_sand, 1);
+	private static ItemStack blockIronBars = new ItemStack (Blocks.iron_bars, 1);
+	private static ItemStack itemClayDust = new ItemStack(Items.clay_ball, 1);
+	private static ItemStack itemCocoaBeans = new ItemStack(Items.dye, 1, 3);
+
+	private static ItemStack hiveFrameDecay = ItemUtils.getSimpleStack(FR_ItemRegistry.hiveFrameDecay);
+	private static ItemStack hiveFrameSlow = ItemUtils.getSimpleStack(FR_ItemRegistry.hiveFrameSlow);
+	private static ItemStack hiveFrameStalilize = ItemUtils.getSimpleStack(FR_ItemRegistry.hiveFrameStalilize);
+	private static ItemStack hiveFrameArborist = ItemUtils.getSimpleStack(FR_ItemRegistry.hiveFrameArborist);
+
+	public static void registerItems(){	
+		//Magic Bee Like Frames
+		RecipeUtils.addShapedGregtechRecipe(
+				rod_LongElectrum, rod_Electrum, rod_LongElectrum,
+				rod_LongElectrum, foil_Electrum, rod_LongElectrum,
+				rod_Electrum, rod_Electrum, rod_Electrum,
+				hiveFrameAccelerated);
+
+		RecipeUtils.addShapedGregtechRecipe(
+				rod_LongUranium, rod_Uranium, rod_LongUranium,
+				rod_LongUranium, foil_Uranium235, rod_LongUranium,
+				rod_Uranium, rod_Uranium, rod_Uranium,
+				hiveFrameMutagenic);
+		if (!CORE.GTNH) {
+			RecipeUtils.addShapedGregtechRecipe(
+					"stickLongThaumium", "stickThaumium", "stickLongThaumium",
+					"stickLongThaumium", ItemUtils.getSimpleStack(Items.ender_pearl), "stickLongThaumium",
+					"stickThaumium", "stickThaumium", "stickThaumium",
+					hiveFrameVoid);
+		}
+		else {
+			if (LoadedMods.MagicBees) {
+				RecipeUtils.addShapelessGregtechRecipe(new ItemStack[] {hiveFrameVoid}, ItemUtils.getCorrectStacktype("MagicBees:frameOblivion", 1));				
+			}
+		}
+		RecipeUtils.addShapedGregtechRecipe(
+				"stickLongBlueSteel", "stickBlueSteel", "stickLongBlueSteel",
+				"stickLongBlueSteel", ItemUtils.getSimpleStack(Items.nether_star), "stickLongBlueSteel",
+				"stickBlueSteel", "stickBlueSteel", "stickBlueSteel",
+				hiveFrameBusy);
+
+		if (!LoadedMods.ExtraBees){
+			//Extra Bee Like Frames
+			RecipeUtils.addShapedRecipe(
+					null, itemCocoaBeans, null,
+					itemCocoaBeans, hiveFrameImpregnated, itemCocoaBeans,
+					null, itemCocoaBeans, null,
+					hiveFrameCocoa);
+
+			RecipeUtils.addShapedRecipe(
+					hiveFrameImpregnated, blockIronBars, null,
+					null, null, null,
+					null, null, null,
+					hiveFrameCaged);
+
+			RecipeUtils.addShapedRecipe(
+					hiveFrameImpregnated, blockSoulSand, null,
+					null, null, null,
+					null, null, null,
+					hiveFrameSoul);
+
+			RecipeUtils.addShapedRecipe(
+					null, itemClayDust, null,
+					itemClayDust, hiveFrameImpregnated, itemClayDust,
+					null, itemClayDust, null,
+					hiveFrameClay);
+		}
+
+		// Frame Items added by bartimaeusnek
+		RecipeUtils.addShapedGregtechRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict("stickLongTumbaga", 1),ItemUtils.getItemStackOfAmountFromOreDict("stickTumbaga", 1),ItemUtils.getItemStackOfAmountFromOreDict("stickLongTumbaga", 1),
+				ItemUtils.getItemStackOfAmountFromOreDict("stickLongTumbaga", 1),foil_Electrum,ItemUtils.getItemStackOfAmountFromOreDict("stickLongTumbaga", 1),
+				ItemUtils.getItemStackOfAmountFromOreDict("stickTumbaga", 1),ItemUtils.getItemStackOfAmountFromOreDict("stickTumbaga", 1),ItemUtils.getItemStackOfAmountFromOreDict("stickTumbaga", 1),
+				hiveFrameSlow);
+
+		RecipeUtils.addShapedGregtechRecipe(
+				"stickLongWroughtIron","stickWroughtIron","stickLongWroughtIron",
+				"stickLongWroughtIron","foilZinc","stickLongWroughtIron",
+				"stickWroughtIron","stickWroughtIron","stickWroughtIron",
+				hiveFrameDecay);
+
+		RecipeUtils.addShapedGregtechRecipe(
+				"stickLongOsmiridium","stickOsmiridium","stickLongOsmiridium",
+				"stickLongOsmiridium","foilOsmiridium","stickLongOsmiridium",
+				"stickOsmiridium","stickOsmiridium","stickOsmiridium",
+				hiveFrameStalilize);
+
+		RecipeUtils.addShapedGregtechRecipe(
+				"stickLongWoodSealed","stickWoodSealed","stickLongWoodSealed",
+				"stickLongWoodSealed",Items.paper,"stickLongWoodSealed",
+				"stickWoodSealed","stickWoodSealed","stickWoodSealed",
+				hiveFrameArborist);
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/forestry/bees/tileentities/TileDenseBeeHouse.java b/src/main/java/gtPlusPlus/xmod/forestry/bees/tileentities/TileDenseBeeHouse.java
new file mode 100644
index 0000000000..9b3424ef08
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/forestry/bees/tileentities/TileDenseBeeHouse.java
@@ -0,0 +1,92 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2014 SirSengir.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v3
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/lgpl-3.0.txt
+ *
+ * Various Contributors including, but not limited to:
+ * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
+ ******************************************************************************/
+package gtPlusPlus.xmod.forestry.bees.tileentities;
+
+import java.util.*;
+
+import cpw.mods.fml.common.Optional;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.tileentity.TileEntity;
+
+import buildcraft.api.statements.ITriggerExternal;
+import forestry.api.apiculture.*;
+import forestry.apiculture.ApiaryBeeListener;
+import forestry.apiculture.ApiaryBeeModifier;
+import forestry.apiculture.IApiary;
+import forestry.apiculture.inventory.IApiaryInventory;
+import forestry.apiculture.inventory.InventoryApiary;
+import forestry.apiculture.tiles.TileBeeHousingBase;
+import forestry.apiculture.trigger.ApicultureTriggers;
+import gtPlusPlus.xmod.forestry.bees.gui.ContainerBeeHouse;
+import gtPlusPlus.xmod.forestry.bees.gui.GuiBeeHouse;
+import net.minecraftforge.common.util.ForgeDirection;
+
+public class TileDenseBeeHouse extends TileBeeHousingBase implements IApiary {
+	private final IBeeModifier beeModifier = new ApiaryBeeModifier();
+	private final IBeeListener beeListener = new ApiaryBeeListener(this);
+	private final InventoryApiary inventory = new InventoryApiary(getAccessHandler());
+
+	public TileDenseBeeHouse() {
+		super("apiary2");
+		setInternalInventory(inventory);
+	}
+
+	@Override
+	public IBeeHousingInventory getBeeInventory() {
+		return inventory;
+	}
+
+	@Override
+	public IApiaryInventory getApiaryInventory() {
+		return inventory;
+	}
+
+	@Override
+	public Collection<IBeeModifier> getBeeModifiers() {
+		List<IBeeModifier> beeModifiers = new ArrayList<>();
+
+		beeModifiers.add(beeModifier);
+
+		for (IHiveFrame frame : inventory.getFrames()) {
+			beeModifiers.add(frame.getBeeModifier());
+		}
+
+		return beeModifiers;
+	}
+
+	@Override
+	public Iterable<IBeeListener> getBeeListeners() {
+		return Collections.singleton(beeListener);
+	}
+
+	/* ITRIGGERPROVIDER */
+	@Optional.Method(modid = "BuildCraftAPI|statements")
+	@Override
+	public Collection<ITriggerExternal> getExternalTriggers(ForgeDirection side, TileEntity tile) {
+		LinkedList<ITriggerExternal> res = new LinkedList<>();
+		res.add(ApicultureTriggers.missingQueen);
+		res.add(ApicultureTriggers.missingDrone);
+		res.add(ApicultureTriggers.noFrames);
+		return res;
+	}
+
+	@Override
+	public Object getGui(EntityPlayer player, int data) {
+		ContainerBeeHouse container = new ContainerBeeHouse(player.inventory, this, true);
+		return new GuiBeeHouse<>(this, container, GuiBeeHouse.Icon.APIARY);
+	}
+
+	@Override
+	public Object getContainer(EntityPlayer player, int data) {
+		return new ContainerBeeHouse(player.inventory, this, true);
+	}
+}