Merge branch 'dev' into 4.2

(cherry picked from commit 4c41d0bb6e)

.gitignore

@@ -6,6 +6,7 @@
 !/gradle/wrapper
 !/src
 !/api
+!/test
 
 # files
 !/.gitignore
@@ -15,8 +16,9 @@
 !/LICENSE.txt
 !/license-header.txt
 !/README.md
-!/application.properties
+!/gradle.properties
 !/build.gradle
 !/build.xml
 !/gradlew
-!/gradlew.bat
+!/gradlew.bat
+.DS_Store

README.md

@@ -31,7 +31,7 @@ Beware of ugly code.
 
 Bugfixes are generally welcome. If you want to contribute something which changes game mechanics, please talk to someone with commit privileges first. Nothing is more frustrating than putting a lot of work and effort into a new game mechanic and then having the PR rejected because it doesn’t fit gameplay-wise.
 
-**If you submit a PR you must accept the [Contributor License Agreement](https://www.clahub.com/agreements/ForestryMC/ForestryMC). There is no way around that, since otherwise changing the license later - even to something more permissive! - , becomes close to impossible.**
+**If you submit a PR you must accept the [Contributor License Agreement](https://cla-assistant.io/ForestryMC/ForestryMC). There is no way around that, since otherwise changing the license later - even to something more permissive! - , becomes close to impossible.**
 
 ### License & Copyright
 

application.properties

@@ -1,5 +0,0 @@
-mcversion=1.7.10
-forgeversion=10.13.2.1286
-version_major=3
-version_minor=5
-version_patch=0

build.gradle

@@ -19,8 +19,7 @@ buildscript {
 
 apply plugin: 'forge'
 apply plugin: 'maven'
-
-loadProperties()
+apply plugin: 'java'
 
 version = version_major + '.' + version_minor + '.' + version_patch + '.' + getBuildNumber()
 if (project.hasProperty('buildQualifier')) {
@@ -35,8 +34,9 @@ ext.dirLang = "./lang"
 ext.apiForestry = "./api/forestry"
 ext.apiRedstoneFlux = "./api/redstoneflux"
 
-ext.CraftGuideRepo = "https://github.com/Uristqwerty/CraftGuide.git"
-ext.CraftGuideTmp = "build/tmp/CraftGuide"
+// java version
+sourceCompatibility = 1.7
+targetCompatibility = 1.7
 
 minecraft {
 	version = mcversion + "-" + forgeversion
@@ -44,16 +44,11 @@ minecraft {
 
 	replace '@VERSION@', project.version
 	replace '@BUILD_NUMBER@', getBuildNumber()
+
+	srgExtra "PK: chylex/javacheck forestry/shade/javacheck"
 }
 
 sourceSets {
-	api {
-		java {
-			srcDir CraftGuideTmp + "/src"
-			include '**/CraftGuide/api/**'
-		}
-	}
-	
 	main {
 		java {
 			srcDir project.apiForestry
@@ -70,16 +65,43 @@ repositories {
 		name = "ic2"
 		url = "http://maven.ic2.player.to/"
 	}
+	ivy {
+		name "BuildCraft"
+		artifactPattern "http://www.mod-buildcraft.com/releases/BuildCraft/[revision]/[module]-[revision]-[classifier].[ext]"
+	}
+	maven {
+		name = "chickenbones"
+		url = "http://chickenbones.net/maven/"
+	}
+	maven{
+		name "tterrag Repo"
+		url "http://maven.tterrag.com/"
+	}
 }
 
 configurations {
 	api
 	compile.extendsFrom api
+	shade
+	compile.extendsFrom shade
 }
 
 dependencies {
-	api 'net.industrial-craft:industrialcraft-2:2.2.575-experimental:api'
-	api 'com.mod-buildcraft:buildcraft:6.3.1:dev'
+	api 'net.industrial-craft:industrialcraft-2:2.2.790-experimental:api'
+	api name: "buildcraft", version: "7.1.12", classifier: "api"
+
+	// http://files.minecraftforge.net/CodeChickenLib/
+	compile "codechicken:CodeChickenLib:1.7.10-1.1.3.140:dev"
+
+	// http://chickenbones.net/maven
+	compile "codechicken:CodeChickenCore:1.7.10-1.0.7.47:dev"
+	compile "codechicken:NotEnoughItems:1.7.10-1.0.5.111:dev"
+	compile "codechicken:NotEnoughItems:1.7.10-1.0.5.111:src"
+
+	// http://maven.tterrag.com/
+	shade "chylex.javacheck:JavaChecker:v1.2-b1"
+
+	testCompile 'junit:junit:4.12'
 }
 
 processResources {
@@ -121,62 +143,6 @@ debugClient {
 	}
 }
 
-task echoVersion << {
-	printNextVersion()
-}
-
-def saveVersion() {
-	ant.propertyfile(
-		file: "application.properties") {
-		entry( key:"version_major", type:"int", value: version_major)
-		entry( key:"version_minor", type:"int", value: version_minor)
-		entry( key:"version_patch", type:"int", value: version_patch)
-	}
-	project.version = version_major + '.' + version_minor + '.' + version_patch + '.' + getBuildNumber()
-	printNextVersion()
-}
-
-def printNextVersion() {
-	println '*************************************************************'
-	println 'The next build will be version: ' +  project.version
-	println '*************************************************************'
-}
-
-task bumpMajor << {
-	project.version_major = Integer.parseInt(project.version_major) + 1
-	project.version_minor = "0"
-	project.version_patch = "0"
-	saveVersion()
-}
-
-task bumpMinor << {
-	project.version_minor = Integer.parseInt(project.version_minor) + 1
-	project.version_patch = "0"
-	saveVersion()
-}
-
-task bumpPatch << {
-	project.version_patch = Integer.parseInt(project.version_patch) + 1
-	saveVersion()
-}
-
-import org.ajoberstar.grgit.Grgit
-
-task initCraftGuide << {
-	def localRepo = file(CraftGuideTmp)
-
-	if (localRepo.exists()) {
-		println 'Updating CraftGuide repo'
-		def grgit = Grgit.open(localRepo)
-		grgit.pull()
-		grgit.close()
-	} else {
-		println 'Cloning CraftGuide repo'
-		def grgit = Grgit.clone(dir: localRepo, uri: CraftGuideRepo)
-		grgit.close()
-	}
-}
-
 jar {
 	destinationDir = file("build/tmp")
 	archiveName = "main.jar"
@@ -188,129 +154,79 @@ jar {
 	into ('cofh/api') {
 		from project.apiRedstoneFlux + "/LICENSE - LGPLv3.txt"
 	}
-	into ('buildcraft/api') {
-		from "./src/main/java/buildcraft/LICENSE-API"
-	}
-}
-
-task mainJarSigned ( type: Jar, dependsOn: 'reobf' ) {
-	from (zipTree(jar.getArchivePath())) {
-		exclude '**/api/**'
-		exclude '**/codechicken/**'
-		exclude '**/undergroundBiomes/**'
+	into ('invtweaks/api') {
+		from "./src/main/java/invtweaks/LICENSE.txt"
 	}
 
-	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-	destinationDir = file("build/tmp")
-	archiveName = "signed.jar"
-
-	doLast {
-		if (project.hasProperty('signingKeystore')) {
-			ant.signjar(jar: getArchivePath(),
-				alias: signingAlias,
-				keystore: signingKeystore,
-				storepass: signingStorepass)
-		} else {
-			println 'Signing disabled, gradle.properties is missing.'
+	configurations.shade.each{ dep ->
+		from(project.zipTree(dep)){
+			exclude 'META-INF', 'META-INF/**', 'mcmod.info'
 		}
 	}
 }
 
-task mainJar ( type: Zip, dependsOn: mainJarSigned ) {
-	from (zipTree(mainJarSigned.getArchivePath())) {
-		include '**'
-	}
-
+task mainJar(type: Jar, dependsOn: 'reobf') {
 	from (zipTree(jar.getArchivePath())) {
 		include '**'
 		exclude '**/codechicken/**'
-		exclude '**/undergroundBiomes/**'
+		exclude '**/uristqwerty/**'
 	}
 
-	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 	destinationDir = file(dirDest)
+	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 	includeEmptyDirs = false
-	extension = 'jar'
-}
 
-task devJarSigned ( type: Jar, dependsOn: 'classes' ) {
-	from(sourceSets.main.output) {
-		exclude '**/api/**'
-		exclude '**/codechicken/**'
-		exclude '**/undergroundBiomes/**'
-	}
-
-	destinationDir = file("build/tmp")
-	archiveName = "signed-dev.jar"
-
-	doLast {
-		if (project.hasProperty('signingKeystore')) {
-			ant.signjar(jar: getArchivePath(),
-				alias: signingAlias,
-				keystore: signingKeystore,
-				storepass: signingStorepass)
-		} else {
-			println 'Signing disabled, gradle.properties is missing.'
-		}
+	manifest{
+		attributes 'TweakClass': 'forestry.shade.javacheck.Java7Checker'
 	}
 }
 
-task devJar ( type: Zip, dependsOn: devJarSigned ) {
-	from (zipTree(devJarSigned.getArchivePath())) {
-		include '**'
-	}
-
-	from(sourceSets.main.allSource) {
-		include '**'
+task devJar(type: Jar, dependsOn: 'classes') {
+	from (sourceSets.main.output) {
 		exclude '**/codechicken/**'
-		exclude '**/undergroundBiomes/**'
+		exclude '**/uristqwerty/**'
 	}
 
-	from(sourceSets.main.output) {
-		include '**'
-		exclude '**/codechicken/**'
-		exclude '**/undergroundBiomes/**'
-	}
-
-	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 	destinationDir = file(dirDest)
-	extension = 'jar'
+	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+	includeEmptyDirs = false
 
 	classifier = 'dev'
 }
 
 task apiJar(type: Jar, dependsOn: 'classes') {
 	from project.apiForestry
-	
-	from (sourceSets.main.output) {
+	from(sourceSets.main.output) {
 		include 'forestry/api/**'
 	}
-	
+
 	destinationDir = file(dirDest)
-	extension = 'jar'
+	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+	includeEmptyDirs = false
+
 	classifier = 'api'
 }
 
-task releaseInit << {
-	println '*************************************************************'
-	println 'This build will be version: ' +  rootProject.version
-	println '*************************************************************'
+task sourceJar(type: Jar, dependsOn: 'classes') {
+	from (sourceSets.main.allSource) {
+		exclude '**/codechicken/**'
+		exclude '**/uristqwerty/**'
+	}
+
+	destinationDir = file(dirDest)
+	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+	includeEmptyDirs = false
+
+	classifier = 'sources'
 }
 
-task release (dependsOn: [releaseInit, apiJar, devJar, mainJar]) {
-}
-
-mainJar.shouldRunAfter releaseInit
-devJar.shouldRunAfter releaseInit
-apiJar.shouldRunAfter releaseInit
-
-afterEvaluate {
-	compileApiJava.dependsOn initCraftGuide
+task release (dependsOn: [mainJar, apiJar, devJar, sourceJar]) {
 }
 
 artifacts {
 	archives apiJar
 	archives devJar
+	archives sourceJar
 }
 
 uploadArchives {
@@ -325,6 +241,9 @@ uploadArchives {
 				addFilter('dev') { artifact, file ->
 					file == devJar.archivePath
 				}
+				addFilter('source') { artifact, file ->
+					file == sourceJar.archivePath
+				}
 			}
 		} else {
 			println 'Archives upload disabled, gradle.properties is missing.'
@@ -332,19 +251,6 @@ uploadArchives {
 	}
 }
 
-def loadProperties() {
-	println('loading application.properties')
-
-	file("application.properties").withReader { reader ->
-		def userProps = new Properties()
-		userProps.load(reader)
-
-		for (Map.Entry property in userProps) {
-			project.ext[property.getKey()] = property.getValue()
-		}
-	}
-}
-
 def getBuildNumber() {
 	return "$System.env.BUILD_NUMBER" != "null" ? "$System.env.BUILD_NUMBER" : "0"
 }

cla-signatures.txt

@@ -1,3 +1,6 @@
 Account;Email;Date;
 samtrion;[email protected];2015-01-18
 GenuineSounds;[email protected];2015-02-26
+airbreather;[email protected];2015-04-10
+ganymedes01;[email protected];2015-05-27
+infinityraider;theoneandonlyraider@gmail;com;2015-10-03

gradle.properties

@@ -0,0 +1,5 @@
+mcversion=1.7.10
+forgeversion=10.13.4.1541-1.7.10
+version_major=4
+version_minor=2
+version_patch=2

src/main/java/buildcraft/api/tools/IToolWrench.java

@@ -1,40 +0,0 @@
-/**
- * Copyright (c) 2011-2014, SpaceToad and the BuildCraft Team
- * http://www.mod-buildcraft.com
- *
- * The BuildCraft API is distributed under the terms of the MIT License.
- * Please check the contents of the license, which should be located
- * as "LICENSE.API" in the BuildCraft source code distribution.
- */
-package buildcraft.api.tools;
-
-import net.minecraft.entity.player.EntityPlayer;
-
-/***
- * Implement this interface on subclasses of Item to have that item work as a wrench for buildcraft
- */
-public interface IToolWrench {
-
-	/***
-	 * Called to ensure that the wrench can be used. To get the ItemStack that is used, check player.inventory.getCurrentItem()
-	 *
-	 * @param player
-	 *            - The player doing the wrenching
-	 * @param x
-	 *            ,y,z - The coordinates for the block being wrenched
-	 *
-	 * @return true if wrenching is allowed, false if not
-	 */
-	boolean canWrench(EntityPlayer player, int x, int y, int z);
-
-	/***
-	 * Callback after the wrench has been used. This can be used to decrease durability or for other purposes. To get the ItemStack that was used, check
-	 * player.inventory.getCurrentItem()
-	 *
-	 * @param player
-	 *            - The player doing the wrenching
-	 * @param x
-	 *            ,y,z - The coordinates of the block being wrenched
-	 */
-	void wrenchUsed(EntityPlayer player, int x, int y, int z);
-}

src/main/java/buildcraft/api/tools/package-info.java

@@ -1,11 +0,0 @@
-/**
- * Copyright (c) 2011-2014, SpaceToad and the BuildCraft Team
- * http://www.mod-buildcraft.com
- *
- * The BuildCraft API is distributed under the terms of the MIT License.
- * Please check the contents of the license, which should be located
- * as "LICENSE.API" in the BuildCraft source code distribution.
- */
-@API(apiVersion = "1.0", owner = "BuildCraftAPI|core", provides = "BuildCraftAPI|tools")
-package buildcraft.api.tools;
-import cpw.mods.fml.common.API;

src/main/java/codechicken/nei/VisiblityData.java

@@ -1,38 +0,0 @@
-package codechicken.nei;
-
-public class VisiblityData
-{
-    public boolean showUtilityButtons = true;
-    public boolean showStateButtons = true;
-    /**
-     * Item panel and associated buttons
-     */
-    public boolean showItemPanel = true;
-    /**
-     * Item and search section
-     */
-    public boolean showItemSection = true;
-    /**
-     * Dropdown and Item search field
-     */
-    public boolean showSearchSection = true;
-    /**
-     * All widgets except options button
-     */
-    public boolean showWidgets = true;
-    /**
-     * The entire NEI interface, aka hidden
-     */
-    public boolean showNEI = true;
-    public boolean enableDeleteMode = true;
-    
-    public void translateDependancies()
-    {
-        if(!showNEI)
-            showWidgets = false;
-        if(!showWidgets)
-            showItemSection = showUtilityButtons = showStateButtons = false;
-        if(!showItemSection)
-            showSearchSection = showItemPanel = false;
-    }
-}

src/main/java/codechicken/nei/api/INEIGuiHandler.java

@@ -1,49 +0,0 @@
-package codechicken.nei.api;
-
-import codechicken.nei.VisiblityData;
-import net.minecraft.client.gui.inventory.GuiContainer;
-import net.minecraft.item.ItemStack;
-
-import java.util.List;
-
-/**
- * If this is implemented on a gui, it will be automatically registered
- */
-public interface INEIGuiHandler
-{
-    public VisiblityData modifyVisiblity(GuiContainer gui, VisiblityData currentVisibility);
-    
-    /**
-     * NEI will give the specified item to the InventoryRange returned if the player's inventory is full.
-     * return null for no range
-     */
-    public Iterable<Integer> getItemSpawnSlots(GuiContainer gui, ItemStack item);
-    
-    /**
-     * @return A list of TaggedInventoryAreas that will be used with the savestates.
-     */
-    public List<TaggedInventoryArea> getInventoryAreas(GuiContainer gui);
-    
-    /**
-     * Handles clicks while an itemstack has been dragged from the item panel. Use this to set configurable slots and the like. 
-     * Changes made to the stackSize of the dragged stack will be kept
-     * @param gui The current gui instance
-     * @param mousex The x position of the mouse
-     * @param mousey The y position of the mouse
-     * @param draggedStack The stack being dragged from the item panel
-     * @param button The button presed
-     * @return True if the drag n drop was handled. False to resume processing through other routes. The held stack will be deleted if draggedStack.stackSize == 0
-     */
-    public boolean handleDragNDrop(GuiContainer gui, int mousex, int mousey, ItemStack draggedStack, int button);
-    
-    /**
-     * Used to prevent the item panel from drawing on top of other gui elements.
-     * This function will also be called with a 1x1 size rectangle on the mouse position for determining if the given coordinate should override item panel functions such as scrolling
-     * @param x The x coordinate of the rectangle bounding the slot
-     * @param y The y coordinate of the rectangle bounding the slot
-     * @param w The w coordinate of the rectangle bounding the slot
-     * @param h The h coordinate of the rectangle bounding the slot
-     * @return true if the item panel slot within the specified rectangle should not be rendered.
-     */
-    public boolean hideItemPanelSlot(GuiContainer gui, int x, int y, int w, int h);
-}

src/main/java/codechicken/nei/api/TaggedInventoryArea.java

@@ -1,48 +0,0 @@
-package codechicken.nei.api;
-
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.Container;
-import net.minecraft.inventory.IInventory;
-import net.minecraft.item.ItemStack;
-
-import java.util.HashSet;
-
-public class TaggedInventoryArea
-{
-    public HashSet<Integer> slots = new HashSet<Integer>();
-    public String tagName;
-    /**
-     * Only for player inventories.
-     */
-    private IInventory inventory;
-    /**
-     * Other inventories
-     */
-    private Container container;
-    
-    public TaggedInventoryArea(InventoryPlayer invPlayer)
-    {
-        this("InventoryPlayer", 0, 39, null);
-        inventory = invPlayer;
-    }
-    
-    public TaggedInventoryArea(String name, int first, int last, Container container)
-    {
-        this.container = container;
-        tagName = name;
-        for(int i = first; i <= last; i++)
-            slots.add(i);
-    }
-
-    public ItemStack getStackInSlot(int i)
-    {
-        if(inventory != null)
-            return inventory.getStackInSlot(i);
-        return container.getSlot(i).getStack();
-    }
-    
-    public boolean isContainer()
-    {
-        return inventory == null;
-    }
-}

src/main/java/exterminatorJeff/undergroundBiomes/api/UBAPIHook.java

@@ -1,11 +0,0 @@
-package exterminatorJeff.undergroundBiomes.api;
-
-/**
- * Striped down version, get the full API from here: https://github.com/Zeno410/UndergroundBiomes1.7API
- * @author Zeno410
- */
-public class UBAPIHook {
-    public static final UBAPIHook ubAPIHook = new UBAPIHook();
-    //public UBDimensionalStrataColumnProvider dimensionalStrataColumnProvider; // set in the main Underground Biomes
-    public UBOreTexturizer ubOreTexturizer;
-}

src/main/java/exterminatorJeff/undergroundBiomes/api/UBOreTexturizer.java

@@ -1,65 +0,0 @@
-package exterminatorJeff.undergroundBiomes.api;
-
-import cpw.mods.fml.common.event.FMLPreInitializationEvent;
-import net.minecraft.block.Block;
-import net.minecraft.world.World;
-
-/**
- * Striped down version, get the full API from here: https://github.com/Zeno410/UndergroundBiomes1.7API
- * This is an interface for the class that can create Underground Biomes versions of arbitary ores
- * It creates three new blocks for each texturized ore.
- * @author Zeno410
- */
-public interface UBOreTexturizer {
-    // usage: Block is the ore block.
-    // Overlay name is the fully qualified name, e.g. modname:overlayName
-    // that static vars are fully qualified names for all the textures in the UB pack, just pass as is
-    // the event isn't needed per se, but if this is called anytime else, the blocks will not "stick"
-    public void setupUBOre(Block oreBlock, String overlayName, FMLPreInitializationEvent event);
-    public void setupUBOre(Block oreBlock, int metadata, String overlayName, FMLPreInitializationEvent event);
-    public void setupUBOre(Block oreBlock, int metadata, String overlayName, String blockName, FMLPreInitializationEvent event);
-
-    public void requestUBOreSetup(Block oreBlock, String overlayName) throws BlocksAreAlreadySet;
-    public void requestUBOreSetup(Block oreBlock, int metadata, String overlayName) throws BlocksAreAlreadySet;
-    public void requestUBOreSetup(Block oreBlock, int metadata, String overlayName, String blockName) throws BlocksAreAlreadySet;
-    public void redoOres(int xInBlockCoordinates, int zInBlockCoordinates, World serverSideWorld) ;
-
-    public static String amber_overlay = "undergroundbiomes:amber_overlay";
-    public static String cinnabar_overlay = "undergroundbiomes:cinnabar_overlay";
-    public static String coal_overlay = "undergroundbiomes:coal_overlay";
-    public static String copper_overlay = "undergroundbiomes:copper_overlay";
-    public static String diamond_overlay = "undergroundbiomes:diamond_overlay";
-    public static String emerald_overlay = "undergroundbiomes:emerald_overlay";
-    public static String gold_overlay = "undergroundbiomes:gold_overlay";
-    public static String iron_overlay = "undergroundbiomes:iron_overlay";
-    public static String lapis_overlay = "undergroundbiomes:lapis_overlay";
-    public static String lead_overlay = "undergroundbiomes:lead_overlay";
-    public static String olivine_peridot_overlay = "undergroundbiomes:olivine-peridot_overlay";
-    public static String redstone_overlay = "undergroundbiomes:redstone_overlay";
-    public static String ruby_overlay = "undergroundbiomes:ruby_overlay";
-    public static String sapphire_overlay = "undergroundbiomes:sapphire_overlay";
-    public static String tin_overlay = "undergroundbiomes:tin_overlay";
-    public static String uranium_overlay = "undergroundbiomes:uranium_overlay";
-
-    public class BlocksAreAlreadySet extends RuntimeException {
-        // this is thrown if UB has already run its pre-initialization step and can no longer register blocks
-        public final Block oreBlock;
-        public final String overlayName;
-
-        public BlocksAreAlreadySet(Block oreBlock, String overlayName) {
-            this.oreBlock = oreBlock;
-            this.overlayName = overlayName;
-        }
-
-        @Override
-        public String toString() {
-            String blockDescription = "undefined block";
-            String overlayDescription = "undefined overlay";
-            if (oreBlock != null) blockDescription = oreBlock.getUnlocalizedName();
-            if (overlayName != null) overlayDescription = overlayName;
-            return "Attempt to create Underground Biomes ore for "+blockDescription+" with "+overlayDescription +
-                    " after blocks have already been defined";
-        }
-
-    }
-}

src/main/java/forestry/Forestry.java

@@ -11,41 +11,43 @@
 package forestry;
 
 import java.io.File;
-import java.util.HashMap;
-import java.util.Map;
 
 import net.minecraft.block.Block;
 import net.minecraft.item.Item;
 
+import net.minecraftforge.common.MinecraftForge;
+
+import cpw.mods.fml.common.FMLCommonHandler;
 import cpw.mods.fml.common.Mod;
 import cpw.mods.fml.common.Mod.EventHandler;
-import cpw.mods.fml.common.SidedProxy;
 import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.event.FMLInterModComms;
 import cpw.mods.fml.common.event.FMLInterModComms.IMCEvent;
 import cpw.mods.fml.common.event.FMLMissingMappingsEvent;
 import cpw.mods.fml.common.event.FMLMissingMappingsEvent.MissingMapping;
 import cpw.mods.fml.common.event.FMLPostInitializationEvent;
 import cpw.mods.fml.common.event.FMLPreInitializationEvent;
 import cpw.mods.fml.common.event.FMLServerStartingEvent;
+import cpw.mods.fml.common.network.NetworkRegistry;
 import cpw.mods.fml.common.registry.GameRegistry;
 import cpw.mods.fml.common.registry.GameRegistry.Type;
 
-import forestry.api.fuels.EngineBronzeFuel;
-import forestry.api.fuels.EngineCopperFuel;
-import forestry.api.fuels.FermenterFuel;
-import forestry.api.fuels.FuelManager;
-import forestry.api.fuels.GeneratorFuel;
-import forestry.api.fuels.MoistenerFuel;
-import forestry.api.fuels.RainSubstrate;
-import forestry.core.ForestryCore;
-import forestry.core.config.Defaults;
-import forestry.core.config.ForestryItem;
+import forestry.api.core.ForestryAPI;
+import forestry.core.EventHandlerCore;
+import forestry.core.config.Config;
+import forestry.core.config.Constants;
+import forestry.core.config.GameMode;
 import forestry.core.config.Version;
+import forestry.core.errors.EnumErrorCode;
+import forestry.core.errors.ErrorStateRegistry;
+import forestry.core.gui.GuiHandler;
+import forestry.core.multiblock.MultiblockEventHandler;
 import forestry.core.network.PacketHandler;
 import forestry.core.proxy.Proxies;
-import forestry.core.utils.FluidMap;
-import forestry.core.utils.ItemStackMap;
+import forestry.core.utils.Log;
 import forestry.core.utils.StringUtil;
+import forestry.core.worldgen.WorldGenerator;
+import forestry.plugins.PluginManager;
 
 /**
  * Forestry Minecraft Mod
@@ -53,111 +55,103 @@ import forestry.core.utils.StringUtil;
  * @author SirSengir
  */
 @Mod(
-		modid = Defaults.MOD,
+		modid = Constants.MOD,
 		name = "Forestry",
 		version = Version.VERSION,
-		dependencies = "required-after:Forge@[10.13.0.1207,);"
+		guiFactory = "forestry.core.config.ForestryGuiConfigFactory",
+		dependencies = "required-after:Forge@[10.13.4.1448,);"
 				+ "after:Buildcraft|Core@[6.1.7,);"
 				+ "after:ExtrabiomesXL;"
 				+ "after:BiomesOPlenty;"
 				+ "after:IC2@[2.0.140,);"
-				+ "before:UndergroundBiomes")
-//, certificateFingerprint = Version.FINGERPRINT)
+				+ "after:Natura@[2.2.0,);"
+				+ "after:HardcoreEnderExpansion;")
 public class Forestry {
 
-	@Mod.Instance(Defaults.MOD)
+	@Mod.Instance(Constants.MOD)
 	public static Forestry instance;
 	private File configFolder;
 
-	private static final Map<String, ForestryItem> mappedItems = new HashMap<String, ForestryItem>();
-
-	static {
-		mappedItems.put("Forestry:builderBackpack", ForestryItem.builderBackpack);
-		mappedItems.put("Forestry:builderBackpackT2", ForestryItem.builderBackpackT2);
-		mappedItems.put("Forestry:adventurerBackpack", ForestryItem.adventurerBackpack);
-		mappedItems.put("Forestry:adventurerBackpackT2", ForestryItem.adventurerBackpackT2);
-		mappedItems.put("Forestry:shortMead", ForestryItem.beverage);
-		mappedItems.put("Forestry:waterCan", ForestryItem.canWater);
-		mappedItems.put("Forestry:biofuelCan", ForestryItem.canEthanol);
-		mappedItems.put("Forestry:biomassCan", ForestryItem.canBiomass);
-		mappedItems.put("Forestry:bucketBiofuel", ForestryItem.bucketEthanol);
-		mappedItems.put("Forestry:refractoryBiofuel", ForestryItem.refractoryEthanol);
-		mappedItems.put("Forestry:waxCapsuleBiofuel", ForestryItem.waxCapsuleEthanol);
-	}
-
 	public Forestry() {
-		FuelManager.fermenterFuel = new ItemStackMap<FermenterFuel>();
-		FuelManager.moistenerResource = new ItemStackMap<MoistenerFuel>();
-		FuelManager.rainSubstrate = new ItemStackMap<RainSubstrate>();
-		FuelManager.bronzeEngineFuel = new FluidMap<EngineBronzeFuel>();
-		FuelManager.copperEngineFuel = new ItemStackMap<EngineCopperFuel>();
-		FuelManager.generatorFuel = new FluidMap<GeneratorFuel>();
+		ForestryAPI.instance = this;
+		ForestryAPI.forestryConstants = new Constants();
+		ForestryAPI.errorStateRegistry = new ErrorStateRegistry();
+		EnumErrorCode.init();
 	}
 
-	@SidedProxy(clientSide = "forestry.core.ForestryClient", serverSide = "forestry.core.ForestryCore")
-	public static ForestryCore core = new ForestryCore();
 	public static PacketHandler packetHandler;
 
 	@EventHandler
 	public void preInit(FMLPreInitializationEvent event) {
 		packetHandler = new PacketHandler();
-		
-		configFolder = new File(event.getModConfigurationDirectory(), "forestry");
 
-		core.preInit(event.getSourceFile(), this);
+		// Register event handler
+		EventHandlerCore eventHandlerCore = new EventHandlerCore();
+		MinecraftForge.EVENT_BUS.register(eventHandlerCore);
+		FMLCommonHandler.instance().bus().register(eventHandlerCore);
+		MinecraftForge.EVENT_BUS.register(new MultiblockEventHandler());
+
+		configFolder = new File(event.getModConfigurationDirectory(), "forestry");
+		Config.load();
+
+		PluginManager.runSetup();
+
+		ForestryAPI.activeMode = new GameMode(Config.gameMode);
+
+		PluginManager.runPreInit();
 	}
 
 	@EventHandler
 	public void init(FMLInitializationEvent event) {
-		core.init(this);
+		// Register gui handler
+		NetworkRegistry.INSTANCE.registerGuiHandler(this, new GuiHandler());
+
+		PluginManager.runInit();
 	}
 
 	@EventHandler
 	public void postInit(FMLPostInitializationEvent event) {
-		core.postInit();
+		PluginManager.runPostInit();
+
+		// Register world generator
+		WorldGenerator worldGenerator = new WorldGenerator();
+		GameRegistry.registerWorldGenerator(worldGenerator, 0);
+
+		// Register tick handlers
+		Proxies.common.registerTickHandlers(worldGenerator);
+
+		// Handle IMC messages.
+		PluginManager.processIMCMessages(FMLInterModComms.fetchRuntimeMessages(ForestryAPI.instance));
 	}
 
 	@EventHandler
 	public void serverStarting(FMLServerStartingEvent event) {
-		core.serverStarting(event.getServer());
+		PluginManager.serverStarting(event.getServer());
 	}
 
 	public File getConfigFolder() {
 		return configFolder;
 	}
-	/*@EventHandler
-	 public void fingerprintWarning(FMLFingerprintViolationEvent event) {
-	 Proxies.log.info("Fingerprint of the mod jar is invalid. The jar file was tampered with.");
-	 FMLInterModComms.sendMessage("Railcraft", "securityViolation", "Fingerprint of jar file did not match.");
-	 FMLInterModComms.sendMessage("Thaumcraft", "securityViolation", "Fingerprint of jar file did not match.");
-	 FMLInterModComms.sendMessage("IC2", "securityViolation", "Fingerprint of jar file did not match.");
-	 }*/
 
 	@EventHandler
 	public void processIMCMessages(IMCEvent event) {
-		core.processIMCMessages(event.getMessages());
+		PluginManager.processIMCMessages(event.getMessages());
 	}
 
 	@EventHandler
 	public void missingMapping(FMLMissingMappingsEvent event) {
 		for (MissingMapping mapping : event.get()) {
 			if (mapping.type == Type.BLOCK) {
-				Block block = GameRegistry.findBlock(Defaults.MOD, StringUtil.cleanTags(mapping.name));
+				Block block = GameRegistry.findBlock(Constants.MOD, StringUtil.cleanTags(mapping.name));
 				if (block != null) {
 					mapping.remap(block);
-					Proxies.log.warning("Remapping block " + mapping.name + " to " + StringUtil.cleanBlockName(block));
+					Log.warning("Remapping block " + mapping.name + " to " + StringUtil.cleanBlockName(block));
 				}
 			} else {
-				Block block = GameRegistry.findBlock(Defaults.MOD, StringUtil.cleanTags(mapping.name));
-				if (block != null) {
-					mapping.remap(Item.getItemFromBlock(block));
-					Proxies.log.warning("Remapping item " + mapping.name + " to " + StringUtil.cleanBlockName(block));
-				} else {
-					ForestryItem mappedItem = mappedItems.get(mapping.name);
-					if (mappedItem != null) {
-						mapping.remap(mappedItem.item());
-						Proxies.log.warning("Remapping item " + mapping.name + " to " + mappedItem.name());
-					}
+				Item item = GameRegistry.findItem(Constants.MOD, StringUtil.cleanTags(mapping.name));
+				if (item != null) {
+					mapping.remap(item);
+					Log.warning("Remapping item " + mapping.name + " to " + StringUtil.cleanItemName(item));
 				}
 			}
 		}

src/main/java/forestry/apiculture/AlvearyBeeModifier.java

@@ -1,24 +1,21 @@
-/*******************************************************************************
- * 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 forestry.apiculture.genetics;
-
-import forestry.api.apiculture.IAlleleBeeSpecies;
-import forestry.api.apiculture.IBeeGenome;
-import forestry.api.apiculture.IBeeHousing;
-
-public class JubilanceNone implements IJubilanceProvider {
-
-	@Override
-	public boolean isJubilant(IAlleleBeeSpecies species, IBeeGenome genome, IBeeHousing housing) {
-		return false;
-	}
-
-}
+/*******************************************************************************
+ * 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 forestry.apiculture;
+
+import forestry.api.apiculture.DefaultBeeModifier;
+import forestry.api.apiculture.IBeeGenome;
+
+public class AlvearyBeeModifier extends DefaultBeeModifier {
+	@Override
+	public float getTerritoryModifier(IBeeGenome genome, float currentModifier) {
+		return 2.0f;
+	}
+}

src/main/java/forestry/apiculture/ApiaryBeeListener.java

@@ -0,0 +1,28 @@
+/*******************************************************************************
+ * 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 forestry.apiculture;
+
+import forestry.api.apiculture.DefaultBeeListener;
+import forestry.apiculture.inventory.IApiaryInventory;
+
+public class ApiaryBeeListener extends DefaultBeeListener {
+	private final IApiary apiary;
+
+	public ApiaryBeeListener(IApiary apiary) {
+		this.apiary = apiary;
+	}
+
+	@Override
+	public void wearOutEquipment(int amount) {
+		IApiaryInventory apiaryInventory = apiary.getApiaryInventory();
+		apiaryInventory.wearOutFrames(apiary, amount);
+	}
+}

src/main/java/forestry/apiculture/ApiaryBeeModifier.java

@@ -0,0 +1,21 @@
+/*******************************************************************************
+ * 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 forestry.apiculture;
+
+import forestry.api.apiculture.DefaultBeeModifier;
+import forestry.api.apiculture.IBeeGenome;
+
+public class ApiaryBeeModifier extends DefaultBeeModifier {
+	@Override
+	public float getProductionModifier(IBeeGenome genome, float currentModifier) {
+		return 0.1f;
+	}
+}

src/main/java/forestry/apiculture/ArmorApiaristHelper.java

@@ -0,0 +1,69 @@
+/*******************************************************************************
+ * 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 forestry.apiculture;
+
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+
+import forestry.api.apiculture.IArmorApiarist;
+import forestry.api.apiculture.IArmorApiaristHelper;
+
+public class ArmorApiaristHelper implements IArmorApiaristHelper {
+
+	@Override
+	public boolean isArmorApiarist(ItemStack stack, EntityLivingBase entity, String cause, boolean doProtect) {
+		if (stack == null) {
+			return false;
+		}
+
+		Item item = stack.getItem();
+		if (!(item instanceof IArmorApiarist)) {
+			return false;
+		}
+
+		IArmorApiarist armorApiarist = (IArmorApiarist) item;
+		try {
+			return armorApiarist.protectEntity(entity, stack, cause, doProtect);
+		} catch (Throwable ignored) { // protectEntity is new to the API and may not be implemented by the armor
+			if (entity instanceof EntityPlayer) {
+				return armorApiarist.protectPlayer((EntityPlayer) entity, stack, cause, doProtect);
+			} else {
+				return true; // fallback on assuming IArmorApiarist will protect the entity
+			}
+		}
+	}
+
+	@Override
+	public int wearsItems(EntityLivingBase entity, String cause, boolean doProtect) {
+		int count = 0;
+
+		for (int i = 1; i <= 4; i++) {
+			ItemStack armorItem = entity.getEquipmentInSlot(i);
+			if (isArmorApiarist(armorItem, entity, cause, doProtect)) {
+				count++;
+			}
+		}
+
+		return count;
+	}
+
+	@Override
+	public boolean isArmorApiarist(ItemStack stack, EntityPlayer player, String cause, boolean doProtect) {
+		return isArmorApiarist(stack, (EntityLivingBase) player, cause, doProtect);
+	}
+
+	@Override
+	public int wearsItems(EntityPlayer player, String cause, boolean doProtect) {
+		return wearsItems((EntityLivingBase) player, cause, doProtect);
+	}
+}

src/main/java/forestry/apiculture/BeeHousingListener.java

@@ -0,0 +1,49 @@
+/*******************************************************************************
+ * 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 forestry.apiculture;
+
+import forestry.api.apiculture.IBeeHousing;
+import forestry.api.apiculture.IBeeListener;
+import forestry.api.genetics.IIndividual;
+
+public class BeeHousingListener implements IBeeListener {
+	private final IBeeHousing beeHousing;
+
+	public BeeHousingListener(IBeeHousing beeHousing) {
+		this.beeHousing = beeHousing;
+	}
+
+	@Override
+	public void wearOutEquipment(int amount) {
+		for (IBeeListener beeListener : beeHousing.getBeeListeners()) {
+			beeListener.wearOutEquipment(amount);
+		}
+	}
+
+	@Override
+	public void onQueenDeath() {
+		for (IBeeListener beeListener : beeHousing.getBeeListeners()) {
+			beeListener.onQueenDeath();
+		}
+	}
+
+	@Override
+	public boolean onPollenRetrieved(IIndividual pollen) {
+		for (IBeeListener beeListener : beeHousing.getBeeListeners()) {
+			if (beeListener.onPollenRetrieved(pollen)) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+}

src/main/java/forestry/apiculture/BeeHousingModifier.java

@@ -0,0 +1,117 @@
+/*******************************************************************************
+ * 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 forestry.apiculture;
+
+import forestry.api.apiculture.IBeeGenome;
+import forestry.api.apiculture.IBeeHousing;
+import forestry.api.apiculture.IBeeModifier;
+
+public class BeeHousingModifier implements IBeeModifier {
+	private final IBeeHousing beeHousing;
+
+	public BeeHousingModifier(IBeeHousing beeHousing) {
+		this.beeHousing = beeHousing;
+	}
+
+	@Override
+	public float getTerritoryModifier(IBeeGenome genome, final float currentModifier) {
+		float modifierValue = 1.0f;
+		for (IBeeModifier modifier : beeHousing.getBeeModifiers()) {
+			modifierValue *= modifier.getTerritoryModifier(genome, modifierValue * currentModifier);
+		}
+		return modifierValue;
+	}
+
+	@Override
+	public float getMutationModifier(IBeeGenome genome, IBeeGenome mate, final float currentModifier) {
+		float modifierValue = 1.0f;
+		for (IBeeModifier modifier : beeHousing.getBeeModifiers()) {
+			modifierValue *= modifier.getMutationModifier(genome, mate, modifierValue * currentModifier);
+		}
+		return modifierValue;
+	}
+
+	@Override
+	public float getLifespanModifier(IBeeGenome genome, IBeeGenome mate, final float currentModifier) {
+		float modifierValue = 1.0f;
+		for (IBeeModifier modifier : beeHousing.getBeeModifiers()) {
+			modifierValue *= modifier.getLifespanModifier(genome, mate, modifierValue * currentModifier);
+		}
+		return modifierValue;
+	}
+
+	@Override
+	public float getProductionModifier(IBeeGenome genome, final float currentModifier) {
+		float modifierValue = 1.0f;
+		for (IBeeModifier modifier : beeHousing.getBeeModifiers()) {
+			modifierValue *= modifier.getProductionModifier(genome, modifierValue * currentModifier);
+		}
+		return modifierValue;
+	}
+
+	@Override
+	public float getFloweringModifier(IBeeGenome genome, final float currentModifier) {
+		float modifierValue = 1.0f;
+		for (IBeeModifier modifier : beeHousing.getBeeModifiers()) {
+			modifierValue *= modifier.getFloweringModifier(genome, modifierValue * currentModifier);
+		}
+		return modifierValue;
+	}
+
+	@Override
+	public float getGeneticDecay(IBeeGenome genome, final float currentModifier) {
+		float modifierValue = 1.0f;
+		for (IBeeModifier modifier : beeHousing.getBeeModifiers()) {
+			modifierValue *= modifier.getGeneticDecay(genome, modifierValue * currentModifier);
+		}
+		return modifierValue;
+	}
+
+	@Override
+	public boolean isSealed() {
+		for (IBeeModifier modifier : beeHousing.getBeeModifiers()) {
+			if (modifier.isSealed()) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	@Override
+	public boolean isSelfLighted() {
+		for (IBeeModifier modifier : beeHousing.getBeeModifiers()) {
+			if (modifier.isSelfLighted()) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	@Override
+	public boolean isSunlightSimulated() {
+		for (IBeeModifier modifier : beeHousing.getBeeModifiers()) {
+			if (modifier.isSunlightSimulated()) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	@Override
+	public boolean isHellish() {
+		for (IBeeModifier modifier : beeHousing.getBeeModifiers()) {
+			if (modifier.isHellish()) {
+				return true;
+			}
+		}
+		return false;
+	}
+}

src/main/java/forestry/apiculture/BeehouseBeeModifier.java

@@ -0,0 +1,46 @@
+/*******************************************************************************
+ * 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 forestry.apiculture;
+
+import forestry.api.apiculture.DefaultBeeModifier;
+import forestry.api.apiculture.IBeeGenome;
+
+public class BeehouseBeeModifier extends DefaultBeeModifier {
+	@Override
+	public float getTerritoryModifier(IBeeGenome genome, float currentModifier) {
+		return 1.0f;
+	}
+
+	@Override
+	public float getProductionModifier(IBeeGenome genome, float currentModifier) {
+		return 0.25f;
+	}
+
+	@Override
+	public float getMutationModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
+		return 0.0f;
+	}
+
+	@Override
+	public float getLifespanModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
+		return 3.0f;
+	}
+
+	@Override
+	public float getFloweringModifier(IBeeGenome genome, float currentModifier) {
+		return 3.0f;
+	}
+
+	@Override
+	public float getGeneticDecay(IBeeGenome genome, float currentModifier) {
+		return 0.0f;
+	}
+}

src/main/java/forestry/apiculture/BeekeepingLogic.java

@@ -10,63 +10,112 @@
  ******************************************************************************/
 package forestry.apiculture;
 
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Set;
 import java.util.Stack;
 
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.nbt.NBTTagList;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
 
+import forestry.api.apiculture.BeeManager;
 import forestry.api.apiculture.EnumBeeType;
 import forestry.api.apiculture.IApiaristTracker;
 import forestry.api.apiculture.IBee;
 import forestry.api.apiculture.IBeeHousing;
+import forestry.api.apiculture.IBeeHousingInventory;
+import forestry.api.apiculture.IBeeListener;
+import forestry.api.apiculture.IBeeModifier;
 import forestry.api.apiculture.IBeekeepingLogic;
+import forestry.api.core.IErrorLogic;
 import forestry.api.core.IErrorState;
 import forestry.api.genetics.IEffectData;
 import forestry.api.genetics.IIndividual;
-import forestry.core.EnumErrorCode;
-import forestry.core.config.Defaults;
-import forestry.core.config.ForestryItem;
+import forestry.apiculture.network.packets.PacketBeeLogicActive;
+import forestry.apiculture.network.packets.PacketBeeLogicActiveEntity;
+import forestry.core.config.Constants;
+import forestry.core.errors.EnumErrorCode;
+import forestry.core.network.DataInputStreamForestry;
+import forestry.core.network.DataOutputStreamForestry;
+import forestry.core.network.IStreamable;
 import forestry.core.proxy.Proxies;
+import forestry.core.utils.Log;
 import forestry.plugins.PluginApiculture;
 
-public class BeekeepingLogic implements IBeekeepingLogic {
+public class BeekeepingLogic implements IBeekeepingLogic, IStreamable {
+
+	private static final int totalBreedingTime = Constants.APIARY_BREEDING_TIME;
 
-	private static final int MAX_POLLINATION_ATTEMPTS = 20;
 	private final IBeeHousing housing;
-	// Breeding
-	private int breedingTime;
-	private final int totalBreedingTime = Defaults.APIARY_BREEDING_TIME;
+	private final IBeeModifier beeModifier;
+	private final IBeeListener beeListener;
+
+	private int beeProgress;
+	private int beeProgressMax;
+
 	private int queenWorkCycleThrottle;
 	private IEffectData effectData[] = new IEffectData[2];
+
+	private final Stack<ItemStack> spawn = new Stack<>();
+
+	private final HasFlowersCache hasFlowersCache = new HasFlowersCache();
+	private final QueenCanWorkCache queenCanWorkCache = new QueenCanWorkCache();
+	private final PollenHandler pollenHandler = new PollenHandler();
+
+	// Client
+	private boolean active;
 	private IBee queen;
-	private IIndividual pollen;
-	private int attemptedPollinations = 0;
-	private final Stack<ItemStack> spawn = new Stack<ItemStack>();
+	private ItemStack queenStack; // used to detect server changes and sync clientQueen
 
 	public BeekeepingLogic(IBeeHousing housing) {
 		this.housing = housing;
+		this.beeModifier = BeeManager.beeRoot.createBeeHousingModifier(housing);
+		this.beeListener = BeeManager.beeRoot.createBeeHousingListener(housing);
 	}
 
 	// / SAVING & LOADING
 	@Override
 	public void readFromNBT(NBTTagCompound nbttagcompound) {
-		breedingTime = nbttagcompound.getInteger("BreedingTime");
+		beeProgress = nbttagcompound.getInteger("BreedingTime");
 		queenWorkCycleThrottle = nbttagcompound.getInteger("Throttle");
 
+		NBTTagCompound queenNBT = nbttagcompound.getCompoundTag("queen");
+		queenStack = ItemStack.loadItemStackFromNBT(queenNBT);
+		queen = BeeManager.beeRoot.getMember(queenStack);
+
+		setActive(nbttagcompound.getBoolean("Active"));
+
+		hasFlowersCache.readFromNBT(nbttagcompound);
+
 		NBTTagList nbttaglist = nbttagcompound.getTagList("Offspring", 10);
 		for (int i = 0; i < nbttaglist.tagCount(); i++) {
 			spawn.add(ItemStack.loadItemStackFromNBT(nbttaglist.getCompoundTagAt(i)));
 		}
-
 	}
 
 	@Override
 	public void writeToNBT(NBTTagCompound nbttagcompound) {
-		nbttagcompound.setInteger("BreedingTime", breedingTime);
+		nbttagcompound.setInteger("BreedingTime", beeProgress);
 		nbttagcompound.setInteger("Throttle", queenWorkCycleThrottle);
 
-		Stack<ItemStack> spawnCopy = new Stack<ItemStack>();
+		if (queenStack != null) {
+			NBTTagCompound queenNBT = new NBTTagCompound();
+			queenStack.writeToNBT(queenNBT);
+			nbttagcompound.setTag("queen", queenNBT);
+		}
+
+		nbttagcompound.setBoolean("Active", active);
+
+		hasFlowersCache.writeToNBT(nbttagcompound);
+
+		Stack<ItemStack> spawnCopy = new Stack<>();
 		spawnCopy.addAll(spawn);
 		NBTTagList nbttaglist = new NBTTagList();
 		while (!spawnCopy.isEmpty()) {
@@ -75,57 +124,112 @@ public class BeekeepingLogic implements IBeekeepingLogic {
 			nbttaglist.appendTag(nbttagcompound1);
 		}
 		nbttagcompound.setTag("Offspring", nbttaglist);
-		
-	}
-
-	// / STATE INFORMATION
-	@Override
-	public int getBreedingTime() {
-		return this.breedingTime;
 	}
 
 	@Override
-	public int getTotalBreedingTime() {
-		return this.totalBreedingTime;
+	public void writeData(DataOutputStreamForestry data) throws IOException {
+		data.writeBoolean(active);
+		if (active) {
+			data.writeItemStack(queenStack);
+		}
 	}
 
 	@Override
-	public IBee getQueen() {
-		return this.queen;
+	public void readData(DataInputStreamForestry data) throws IOException {
+		boolean active = data.readBoolean();
+		setActive(active);
+		if (active) {
+			queenStack = data.readItemStack();
+			queen = BeeManager.beeRoot.getMember(queenStack);
+		}
 	}
 
-	@Override
-	public IBeeHousing getHousing() {
-		return this.housing;
-	}
+	/* Activatable */
+	private void setActive(boolean active) {
+		if (this.active == active) {
+			return;
+		}
+		this.active = active;
 
-	@Override
-	public IEffectData[] getEffectData() {
-		return this.effectData;
+		syncToClient();
 	}
 
 	/* UPDATING */
+
 	@Override
-	public void update() {
+	public boolean canWork() {
 
-		this.queen = null;
+		IErrorLogic errorLogic = housing.getErrorLogic();
+		errorLogic.clearErrors();
 
-		if (!addPendingProducts()) {
-			return;
-		}
-		
-		if (tryBreedingPrincess() || !hasHealthyQueen()) {
-			return;
-		}
-		
-		if (!queenCanWork()) {
-			return;
+		IBeeHousingInventory beeInventory = housing.getBeeInventory();
+
+		boolean hasSpace = addPendingProducts(beeInventory, spawn);
+		errorLogic.setCondition(!hasSpace, EnumErrorCode.NO_SPACE_INVENTORY);
+
+		ItemStack queenStack = beeInventory.getQueen();
+		EnumBeeType beeType = BeeManager.beeRoot.getType(queenStack);
+		// check if we're breeding
+		if (beeType == EnumBeeType.PRINCESS) {
+			boolean hasDrone = BeeManager.beeRoot.isDrone(beeInventory.getDrone());
+			errorLogic.setCondition(!hasDrone, EnumErrorCode.NO_DRONE);
+
+			setActive(false); // not active (no bee FX) when we are breeding
+			return !errorLogic.hasErrors();
 		}
 
-		queenWorkTick();
+		if (beeType == EnumBeeType.QUEEN) {
+			if (!isQueenAlive(queenStack)) {
+				IBee dyingQueen = BeeManager.beeRoot.getMember(queenStack);
+				Collection<ItemStack> spawned = killQueen(dyingQueen, housing, beeListener);
+				spawn.addAll(spawned);
+				queenStack = null;
+			}
+		} else {
+			queenStack = null;
+		}
+
+		if (!ItemStack.areItemStacksEqual(this.queenStack, queenStack)) {
+			this.queen = BeeManager.beeRoot.getMember(queenStack);
+			this.queenStack = queenStack;
+		}
+
+		if (errorLogic.setCondition(queen == null, EnumErrorCode.NO_QUEEN)) {
+			setActive(false);
+			beeProgress = 0;
+			return false;
+		}
+
+		Set<IErrorState> queenErrors = queenCanWorkCache.queenCanWork(queen, housing);
+		for (IErrorState errorState : queenErrors) {
+			errorLogic.setCondition(true, errorState);
+		}
+
+		boolean hasFlowers = hasFlowersCache.hasFlowers(queen, housing);
+		errorLogic.setCondition(!hasFlowers, EnumErrorCode.NO_FLOWER);
+
+		boolean canWork = !errorLogic.hasErrors();
+		setActive(canWork);
+		return canWork;
 	}
 
-	private void queenWorkTick() {
+	@Override
+	public void doWork() {
+		IBeeHousingInventory beeInventory = housing.getBeeInventory();
+		ItemStack queenStack = beeInventory.getQueen();
+		EnumBeeType beeType = BeeManager.beeRoot.getType(queenStack);
+		if (beeType == EnumBeeType.PRINCESS) {
+			tickBreed();
+		} else {
+			queenWorkTick(queen);
+		}
+	}
+
+	private void queenWorkTick(IBee queen) {
+		if (queen == null) {
+			return;
+		}
+
 		// Effects only fire when queen can work.
 		effectData = queen.doEffect(effectData, housing);
 
@@ -133,282 +237,283 @@ public class BeekeepingLogic implements IBeekeepingLogic {
 		queenWorkCycleThrottle++;
 		if (queenWorkCycleThrottle >= PluginApiculture.ticksPerBeeWorkCycle) {
 			queenWorkCycleThrottle = 0;
-			
-			// Need a flower
-			if (queen.hasFlower(housing)) {
-				housing.setErrorState(EnumErrorCode.OK.ordinal());
-				doQueenWorkCycle();
-			} else {
-				housing.setErrorState(EnumErrorCode.NOFLOWER.ordinal());
-			}
+
+			doProduction(queen, housing, beeListener);
+			queen.plantFlowerRandom(housing);
+			pollenHandler.doPollination(queen, housing, beeListener);
+
+			// Age the queen
+			float lifespanModifier = beeModifier.getLifespanModifier(queen.getGenome(), queen.getMate(), 1.0f);
+			queen.age(housing.getWorld(), lifespanModifier);
+
+			// Write the changed queen back into the item stack.
+			NBTTagCompound nbttagcompound = new NBTTagCompound();
+			queen.writeToNBT(nbttagcompound);
+			housing.getBeeInventory().getQueen().setTagCompound(nbttagcompound);
 		}
-	}
-	
-	private void doQueenWorkCycle() {
-		doProduction();
-		queen.plantFlowerRandom(housing);
-		doPollination();
-		// Age the queen
-		queen.age(housing.getWorld(), housing.getLifespanModifier(queen.getGenome(), queen.getMate(), 0f));
-		updateQueenItemNBT();
+
+		beeProgress = queen.getHealth();
+		beeProgressMax = queen.getMaxHealth();
 	}
 
-	private void doProduction() {
+	private static void doProduction(IBee queen, IBeeHousing beeHousing, IBeeListener beeListener) {
 		// Produce and add stacks
-		ItemStack[] products = queen.produceStacks(housing);
-		housing.wearOutEquipment(1);
+		ItemStack[] products = queen.produceStacks(beeHousing);
+		if (products == null) {
+			return;
+		}
+		beeListener.wearOutEquipment(1);
+
+		IBeeHousingInventory beeInventory = beeHousing.getBeeInventory();
+
 		for (ItemStack stack : products) {
-			housing.addProduct(stack, false);
+			beeInventory.addProduct(stack, false);
 		}
 	}
 
-	private void doPollination() {
-		// Get pollen if none available yet
-		if (pollen == null) {
-			pollen = queen.retrievePollen(housing);
-			attemptedPollinations = 0;
-			if (pollen != null) {
-				if (housing.onPollenRetrieved(queen, pollen, false)) {
-					pollen = null;
-				}
-			}
-		}
-		if (pollen != null) {
-			attemptedPollinations++;
-			if (queen.pollinateRandom(housing, pollen) || attemptedPollinations >= MAX_POLLINATION_ATTEMPTS) {
-				pollen = null;
-			}
-		}
-	}
-
-	private void updateQueenItemNBT() {
-		// Write the changed queen back into the item stack.
-		NBTTagCompound nbttagcompound = new NBTTagCompound();
-		queen.writeToNBT(nbttagcompound);
-		housing.getQueen().setTagCompound(nbttagcompound);
-	}
-
-	private boolean addPendingProducts() {
-		EnumErrorCode housingErrorState = null;
+	private static boolean addPendingProducts(IBeeHousingInventory beeInventory, Stack<ItemStack> spawn) {
+		boolean housingHasSpace = true;
 
 		while (!spawn.isEmpty()) {
 			ItemStack next = spawn.peek();
-			if (housing.addProduct(next, true)) {
+			if (beeInventory.addProduct(next, true)) {
 				spawn.pop();
-				housingErrorState = EnumErrorCode.OK;
 			} else {
-				housingErrorState = EnumErrorCode.NOSPACE;
+				housingHasSpace = false;
 				break;
 			}
 		}
 
-		if (housingErrorState != null) {
-			try {
-				housing.setErrorState(housingErrorState);
-			} catch (Error e) {
-				housing.setErrorState(housingErrorState.ordinal());
-			}
-		}
-
-		return housingErrorState != EnumErrorCode.NOSPACE;
-	}
-	
-	private boolean hasHealthyQueen() {
-		boolean hasQueen = true;
-		EnumErrorCode housingErrorState = null;
-
-		if (housing.getQueen() == null || !ForestryItem.beeQueenGE.isItemEqual(housing.getQueen())) {
-			housingErrorState = EnumErrorCode.NOQUEEN;
-			hasQueen = false;
-		} else {
-			IBee queen = PluginApiculture.beeInterface.getMember(housing.getQueen());
-			// Kill dying queens
-			if (!queen.isAlive()) {
-				killQueen(queen);
-				housingErrorState = EnumErrorCode.OK;
-				hasQueen = false;
-			} else {
-				this.queen = queen;
-			}
-		}
-		if (housingErrorState != null) {
-			try {
-				housing.setErrorState(housingErrorState);
-			} catch (Error e) {
-				housing.setErrorState(housingErrorState.ordinal());
-			}
-		}
-		return hasQueen;
-	}
-	
-	private boolean tryBreedingPrincess() {
-		boolean isBreedingPrincess = false;
-
-		// Princess available? Try to breed!
-		if (ForestryItem.beePrincessGE.isItemEqual(housing.getQueen())) {
-			if (ForestryItem.beeDroneGE.isItemEqual(housing.getDrone())) {
-				housing.setErrorState(EnumErrorCode.OK.ordinal());
-			} else {
-				housing.setErrorState(EnumErrorCode.NODRONE.ordinal());
-			}
-			tickBreed();
-			isBreedingPrincess = true;
-		}
-		
-		return isBreedingPrincess;
+		return housingHasSpace;
 	}
 
-	private boolean queenCanWork() {
-		try {
-			boolean canWork = true;
-			// Not while raining, at night or without light
-			IErrorState state = queen.canWork(housing);
-			if (state != EnumErrorCode.OK) {
-				housing.setErrorState(state);
-				canWork = false;
-			} else if (housing.getErrorState() != EnumErrorCode.NOFLOWER) {
-				housing.setErrorState(EnumErrorCode.OK);
-			}
-			return canWork;
-		} catch (Error e) {
-			Proxies.log.logErrorAPI("Forestry", e, IBee.class);
-			return queenCanWorkDeprecated();
+	/** Checks if a queen is alive. Much faster than reading the whole bee nbt */
+	private static boolean isQueenAlive(ItemStack queenStack) {
+		if (queenStack == null) {
+			return false;
 		}
-	}
-
-	// fallback for outdated APIs
-	private boolean queenCanWorkDeprecated() {
-		boolean canWork = true;
-		// Not while raining, at night or without light
-		EnumErrorCode state = EnumErrorCode.values()[queen.isWorking(housing)];
-		if (state != EnumErrorCode.OK) {
-			housing.setErrorState(state.ordinal());
-			canWork = false;
-		} else if (housing.getErrorOrdinal() != EnumErrorCode.NOFLOWER.ordinal()) {
-			housing.setErrorState(EnumErrorCode.OK.ordinal());
+		NBTTagCompound nbtTagCompound = queenStack.getTagCompound();
+		if (nbtTagCompound == null) {
+			return false;
 		}
-		return canWork;
+		int health = nbtTagCompound.getInteger("Health");
+		return health > 0;
 	}
 
 	// / BREEDING
 	private void tickBreed() {
-		if (!tryBreed()) {
-			breedingTime = 0;
+		beeProgressMax = totalBreedingTime;
+
+		IBeeHousingInventory beeInventory = housing.getBeeInventory();
+
+		ItemStack droneStack = beeInventory.getDrone();
+		ItemStack princessStack = beeInventory.getQueen();
+
+		EnumBeeType droneType = BeeManager.beeRoot.getType(droneStack);
+		EnumBeeType princessType = BeeManager.beeRoot.getType(princessStack);
+		if (droneType != EnumBeeType.DRONE || princessType != EnumBeeType.PRINCESS) {
+			beeProgress = 0;
 			return;
 		}
 
-		if (breedingTime < totalBreedingTime) {
-			breedingTime++;
+		if (beeProgress < totalBreedingTime) {
+			beeProgress++;
 		}
-		if (breedingTime < totalBreedingTime) {
+		if (beeProgress < totalBreedingTime) {
 			return;
 		}
 
-		// Breeding done, create new queen if slot available
-		if (!ForestryItem.beePrincessGE.isItemEqual(housing.getQueen())) {
-			return;
-		}
-
-		// Replace
-		IBee princess = PluginApiculture.beeInterface.getMember(housing.getQueen());
-		IBee drone = PluginApiculture.beeInterface.getMember(housing.getDrone());
+		// Mate and replace princess with queen
+		IBee princess = BeeManager.beeRoot.getMember(princessStack);
+		IBee drone = BeeManager.beeRoot.getMember(droneStack);
 		princess.mate(drone);
 
 		NBTTagCompound nbttagcompound = new NBTTagCompound();
 		princess.writeToNBT(nbttagcompound);
-		ItemStack queen = ForestryItem.beeQueenGE.getItemStack();
-		queen.setTagCompound(nbttagcompound);
+		queenStack = new ItemStack(PluginApiculture.items.beeQueenGE);
+		queenStack.setTagCompound(nbttagcompound);
 
-		housing.setQueen(queen);
-		housing.onQueenChange(housing.getQueen());
+		beeInventory.setQueen(queenStack);
 
 		// Register the new queen with the breeding tracker
-		PluginApiculture.beeInterface.getBreedingTracker(housing.getWorld(), housing.getOwnerName()).registerQueen(princess);
+		BeeManager.beeRoot.getBreedingTracker(housing.getWorld(), housing.getOwner()).registerQueen(princess);
 
 		// Remove drone
-		housing.getDrone().stackSize--;
-		if (housing.getDrone().stackSize <= 0) {
-			housing.setDrone(null);
+		beeInventory.getDrone().stackSize--;
+		if (beeInventory.getDrone().stackSize <= 0) {
+			beeInventory.setDrone(null);
 		}
 
 		// Reset breeding time
-		breedingTime = 0;
+		queen = princess;
+		beeProgress = princess.getHealth();
+		beeProgressMax = princess.getMaxHealth();
 	}
 
-	private boolean tryBreed() {
-		if (housing.getDrone() == null || housing.getQueen() == null) {
-			return false;
+	private static Collection<ItemStack> killQueen(IBee queen, IBeeHousing beeHousing, IBeeListener beeListener) {
+		if (queen == null) {
+			return Collections.emptySet();
 		}
 
-		if (!ForestryItem.beeDroneGE.isItemEqual(housing.getDrone()) || !ForestryItem.beePrincessGE.isItemEqual(housing.getQueen())) {
-			return false;
-		}
+		IBeeHousingInventory beeInventory = beeHousing.getBeeInventory();
 
-		if (!housing.canBreed()) {
-			return false;
-		}
+		Collection<ItemStack> spawn;
 
-		return true;
-	}
-
-	private void killQueen(IBee queen) {
 		if (queen.canSpawn()) {
-			spawnOffspring(queen);
-			housing.getQueen().stackSize = 0;
-			housing.setQueen(null);
+			spawn = spawnOffspring(queen, beeHousing);
+			beeListener.onQueenDeath();
+			beeInventory.getQueen().stackSize = 0;
+			beeInventory.setQueen(null);
 		} else {
-			Proxies.log.warning("Tried to spawn offspring off an unmated queen. Devolving her to a princess.");
+			Log.warning("Tried to spawn offspring off an unmated queen. Devolving her to a princess.");
 
-			ItemStack convert = ForestryItem.beePrincessGE.getItemStack();
+			ItemStack convert = new ItemStack(PluginApiculture.items.beePrincessGE);
 			NBTTagCompound nbttagcompound = new NBTTagCompound();
 			queen.writeToNBT(nbttagcompound);
 			convert.setTagCompound(nbttagcompound);
 
-			spawn.add(convert);
-			housing.setQueen(null);
+			spawn = Collections.singleton(convert);
+			beeInventory.setQueen(null);
 		}
-		housing.onQueenChange(housing.getQueen());
+
+		return spawn;
 	}
 
 	/**
 	 * Creates the succeeding princess and between one and three drones.
 	 */
-	private void spawnOffspring(IBee queen) {
+	private static Collection<ItemStack> spawnOffspring(IBee queen, IBeeHousing beeHousing) {
 
-		Stack<ItemStack> offspring = new Stack<ItemStack>();
-		IApiaristTracker breedingTracker = PluginApiculture.beeInterface.getBreedingTracker(housing.getWorld(), housing.getOwnerName());
+		World world = beeHousing.getWorld();
 
-		housing.onQueenDeath(getQueen());
+		Stack<ItemStack> offspring = new Stack<>();
+		IApiaristTracker breedingTracker = BeeManager.beeRoot.getBreedingTracker(world, beeHousing.getOwner());
 
 		// Princess
-		boolean secondPrincess = this.housing.getWorld().rand.nextInt(100) < PluginApiculture.getSecondPrincessChance();
+		boolean secondPrincess = world.rand.nextInt(10000) < PluginApiculture.getSecondPrincessChance() * 100;
 		int count = secondPrincess ? 2 : 1;
 		while (count > 0) {
 			count--;
-			IBee heiress = queen.spawnPrincess(housing);
+			IBee heiress = queen.spawnPrincess(beeHousing);
 			if (heiress != null) {
-				ItemStack princess = PluginApiculture.beeInterface.getMemberStack(heiress, EnumBeeType.PRINCESS.ordinal());
+				ItemStack princess = BeeManager.beeRoot.getMemberStack(heiress, EnumBeeType.PRINCESS.ordinal());
 				breedingTracker.registerPrincess(heiress);
 				offspring.push(princess);
 			}
 		}
 
 		// Drones
-		IBee[] larvae = queen.spawnDrones(housing);
-		for (IBee larva : larvae) {
-			ItemStack drone = PluginApiculture.beeInterface.getMemberStack(larva, EnumBeeType.DRONE.ordinal());
-			breedingTracker.registerDrone(larva);
-			offspring.push(drone);
+		IBee[] drones = queen.spawnDrones(beeHousing);
+		for (IBee drone : drones) {
+			ItemStack droneStack = BeeManager.beeRoot.getMemberStack(drone, EnumBeeType.DRONE.ordinal());
+			breedingTracker.registerDrone(drone);
+			offspring.push(droneStack);
 		}
 
+		IBeeHousingInventory beeInventory = beeHousing.getBeeInventory();
+
+		Collection<ItemStack> spawn = new ArrayList<>();
+
 		while (!offspring.isEmpty()) {
 			ItemStack spawned = offspring.pop();
-			if (!housing.addProduct(spawned, true)) {
+			if (!beeInventory.addProduct(spawned, true)) {
 				spawn.add(spawned);
 			}
 		}
 
-		housing.onPostQueenDeath(getQueen());
-
+		return spawn;
 	}
+
+	/* CLIENT */
+
+	@Override
+	public void syncToClient() {
+		World world = housing.getWorld();
+		if (world != null && !world.isRemote) {
+			if (housing instanceof Entity) {
+				Proxies.net.sendNetworkPacket(new PacketBeeLogicActiveEntity(housing, (Entity) housing), world);
+			} else {
+				Proxies.net.sendNetworkPacket(new PacketBeeLogicActive(housing), world);
+			}
+		}
+	}
+
+	@Override
+	public void syncToClient(EntityPlayerMP player) {
+		World world = housing.getWorld();
+		if (world != null && !world.isRemote) {
+			if (housing instanceof TileEntity) {
+				Proxies.net.sendToPlayer(new PacketBeeLogicActive(housing), player);
+			} else if (housing instanceof Entity) {
+				Proxies.net.sendToPlayer(new PacketBeeLogicActiveEntity(housing, (Entity) housing), player);
+			}
+		}
+	}
+
+	@Override
+	public int getBeeProgressPercent() {
+		if (beeProgressMax == 0) {
+			return 0;
+		}
+
+		return Math.round(beeProgress * 100f / beeProgressMax);
+	}
+
+	@Override
+	public boolean canDoBeeFX() {
+		return active;
+	}
+
+	@Override
+	public void doBeeFX() {
+		if (queen != null) {
+			queen.doFX(effectData, housing);
+		}
+	}
+
+	private static class QueenCanWorkCache {
+		private static final int ticksPerCheckQueenCanWork = 10;
+
+		private Set<IErrorState> queenCanWorkCached = Collections.emptySet();
+		private int queenCanWorkCooldown = 0;
+
+		public Set<IErrorState> queenCanWork(IBee queen, IBeeHousing beeHousing) {
+			if (queenCanWorkCooldown <= 0) {
+				queenCanWorkCached = queen.getCanWork(beeHousing);
+				queenCanWorkCooldown = ticksPerCheckQueenCanWork;
+			} else {
+				queenCanWorkCooldown--;
+			}
+
+			return queenCanWorkCached;
+		}
+	}
+
+	private static class PollenHandler {
+		private static final int MAX_POLLINATION_ATTEMPTS = 20;
+
+		private IIndividual pollen;
+		private int attemptedPollinations = 0;
+
+		public void doPollination(IBee queen, IBeeHousing beeHousing, IBeeListener beeListener) {
+			// Get pollen if none available yet
+			if (pollen == null) {
+				attemptedPollinations = 0;
+				pollen = queen.retrievePollen(beeHousing);
+				if (pollen != null) {
+					if (beeListener.onPollenRetrieved(pollen)) {
+						pollen = null;
+					}
+				}
+			}
+
+			if (pollen != null) {
+				attemptedPollinations++;
+				if (queen.pollinateRandom(beeHousing, pollen) || attemptedPollinations >= MAX_POLLINATION_ATTEMPTS) {
+					pollen = null;
+				}
+			}
+		}
+	}
+
 }

src/main/java/forestry/apiculture/FakeBeekeepingLogic.java

@@ -0,0 +1,69 @@
+/*******************************************************************************
+ * 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 forestry.apiculture;
+
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.nbt.NBTTagCompound;
+
+import forestry.api.apiculture.IBeekeepingLogic;
+
+public class FakeBeekeepingLogic implements IBeekeepingLogic {
+	public static final FakeBeekeepingLogic instance = new FakeBeekeepingLogic();
+
+	private FakeBeekeepingLogic() {
+
+	}
+
+	@Override
+	public boolean canWork() {
+		return false;
+	}
+
+	@Override
+	public void doWork() {
+
+	}
+
+	@Override
+	public void syncToClient() {
+
+	}
+
+	@Override
+	public void syncToClient(EntityPlayerMP player) {
+
+	}
+
+	@Override
+	public int getBeeProgressPercent() {
+		return 0;
+	}
+
+	@Override
+	public boolean canDoBeeFX() {
+		return false;
+	}
+
+	@Override
+	public void doBeeFX() {
+
+	}
+
+	@Override
+	public void readFromNBT(NBTTagCompound nbttagcompound) {
+
+	}
+
+	@Override
+	public void writeToNBT(NBTTagCompound nbttagcompound) {
+
+	}
+}

src/main/java/forestry/apiculture/GuiHandlerApiculture.java

@@ -1,181 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture;
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.item.ItemStack;
-import net.minecraft.world.World;
-
-import forestry.apiculture.gadgets.TileAlvearyHygroregulator;
-import forestry.apiculture.gadgets.TileAlvearyPlain;
-import forestry.apiculture.gadgets.TileAlvearySieve;
-import forestry.apiculture.gadgets.TileAlvearySwarmer;
-import forestry.apiculture.gadgets.TileApiary;
-import forestry.apiculture.gadgets.TileBeehouse;
-import forestry.apiculture.genetics.BeeHelper;
-import forestry.apiculture.gui.ContainerAlveary;
-import forestry.apiculture.gui.ContainerAlvearyHygroregulator;
-import forestry.apiculture.gui.ContainerAlvearySieve;
-import forestry.apiculture.gui.ContainerAlvearySwarmer;
-import forestry.apiculture.gui.ContainerApiary;
-import forestry.apiculture.gui.ContainerHabitatLocator;
-import forestry.apiculture.gui.ContainerImprinter;
-import forestry.apiculture.gui.GuiAlveary;
-import forestry.apiculture.gui.GuiAlvearyHygroregulator;
-import forestry.apiculture.gui.GuiAlvearySieve;
-import forestry.apiculture.gui.GuiAlvearySwarmer;
-import forestry.apiculture.gui.GuiApiary;
-import forestry.apiculture.gui.GuiBeealyzer;
-import forestry.apiculture.gui.GuiHabitatLocator;
-import forestry.apiculture.gui.GuiImprinter;
-import forestry.apiculture.items.ItemBeealyzer.BeealyzerInventory;
-import forestry.apiculture.items.ItemHabitatLocator.HabitatLocatorInventory;
-import forestry.apiculture.items.ItemImprinter.ImprinterInventory;
-import forestry.core.GuiHandlerBase;
-import forestry.core.gui.ContainerAlyzer;
-import forestry.core.network.GuiId;
-import forestry.plugins.PluginApiculture;
-
-public class GuiHandlerApiculture extends GuiHandlerBase {
-
-	@Override
-	public Object getClientGuiElement(int id, EntityPlayer player, World world, int x, int y, int z) {
-		int cleanId = decodeGuiID(id);
-		int guiData = decodeGuiData(id);
-
-		if (cleanId >= GuiId.values().length) {
-			return null;
-		}
-
-		ItemStack equipped;
-		switch (GuiId.values()[cleanId]) {
-
-			case AlvearyGUI:
-				return new GuiAlveary(player.inventory, (TileAlvearyPlain) getTileForestry(world, x, y, z));
-
-			case AlvearySieveGUI:
-				return new GuiAlvearySieve(player.inventory, (TileAlvearySieve) getTileForestry(world, x, y, z));
-
-			case AlvearySwarmerGUI:
-				return new GuiAlvearySwarmer(player.inventory, (TileAlvearySwarmer) getTileForestry(world, x, y, z));
-
-			case ApiaristChestGUI:
-				return getNaturalistChestGui(BeeHelper.UID, player, world, x, y, z, guiData);
-
-			case ApiaryGUI:
-				return new GuiApiary(player.inventory, (TileApiary) getTileForestry(world, x, y, z));
-
-			case BeealyzerGUI:
-				equipped = player.getCurrentEquippedItem();
-				if (equipped == null) {
-					return null;
-				}
-
-				return new GuiBeealyzer(player, new BeealyzerInventory(player, equipped));
-
-			case BeehouseGUI:
-				return new GuiApiary(player.inventory, (TileBeehouse) getTileForestry(world, x, y, z));
-
-			case HabitatLocatorGUI:
-				equipped = player.getCurrentEquippedItem();
-				if (equipped == null) {
-					return null;
-				}
-
-				return new GuiHabitatLocator(player.inventory, new HabitatLocatorInventory(equipped));
-
-			case HygroregulatorGUI:
-				return new GuiAlvearyHygroregulator(player.inventory, (TileAlvearyHygroregulator) getTileForestry(world, x, y, z));
-
-			case ImprinterGUI:
-				equipped = player.getCurrentEquippedItem();
-				if (equipped == null) {
-					return null;
-				}
-				return new GuiImprinter(player.inventory, new ImprinterInventory(player, equipped));
-
-			default:
-				return null;
-
-		}
-	}
-
-	@Override
-	public Object getServerGuiElement(int id, EntityPlayer player, World world, int x, int y, int z) {
-		int cleanId = decodeGuiID(id);
-		int guiData = decodeGuiData(id);
-
-		if (cleanId >= GuiId.values().length) {
-			return null;
-		}
-
-		ItemStack equipped;
-		switch (GuiId.values()[cleanId]) {
-
-			case AlvearyGUI:
-				synchApiaristTracker(world, player);
-				return new ContainerAlveary(player.inventory, (TileAlvearyPlain) getTileForestry(world, x, y, z));
-
-			case AlvearySieveGUI:
-				return new ContainerAlvearySieve(player.inventory, (TileAlvearySieve) getTileForestry(world, x, y, z));
-
-			case AlvearySwarmerGUI:
-				return new ContainerAlvearySwarmer(player.inventory, (TileAlvearySwarmer) getTileForestry(world, x, y, z));
-
-			case ApiaristChestGUI:
-				return getNaturalistChestContainer(BeeHelper.UID, player, world, x, y, z, guiData);
-
-			case ApiaryGUI:
-				synchApiaristTracker(world, player);
-				return new ContainerApiary(player.inventory, (TileApiary) getTileForestry(world, x, y, z), true);
-
-			case BeealyzerGUI:
-				equipped = player.getCurrentEquippedItem();
-				if (equipped == null) {
-					return null;
-				}
-
-				synchApiaristTracker(world, player);
-				return new ContainerAlyzer(new BeealyzerInventory(player, equipped), player);
-
-			case BeehouseGUI:
-				synchApiaristTracker(world, player);
-				return new ContainerApiary(player.inventory, (TileBeehouse) getTileForestry(world, x, y, z), false);
-
-			case HabitatLocatorGUI:
-				equipped = player.getCurrentEquippedItem();
-				if (equipped == null) {
-					return null;
-				}
-
-				return new ContainerHabitatLocator(player.inventory, new HabitatLocatorInventory(equipped));
-
-			case HygroregulatorGUI:
-				return new ContainerAlvearyHygroregulator(player.inventory, (TileAlvearyHygroregulator) getTileForestry(world, x, y, z));
-
-			case ImprinterGUI:
-				synchApiaristTracker(world, player);
-				equipped = player.getCurrentEquippedItem();
-				if (equipped == null) {
-					return null;
-				}
-				return new ContainerImprinter(player.inventory, new ImprinterInventory(player, equipped));
-
-			default:
-				return null;
-
-		}
-	}
-
-	private void synchApiaristTracker(World world, EntityPlayer player) {
-		PluginApiculture.beeInterface.getBreedingTracker(world, player.getGameProfile()).synchToPlayer(player);
-	}
-}

src/main/java/forestry/apiculture/HasFlowersCache.java

@@ -0,0 +1,115 @@
+/*******************************************************************************
+ * 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 forestry.apiculture;
+
+import java.util.Random;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.ChunkCoordinates;
+import net.minecraft.world.World;
+
+import forestry.api.apiculture.BeeManager;
+import forestry.api.apiculture.FlowerManager;
+import forestry.api.apiculture.IBee;
+import forestry.api.apiculture.IBeeHousing;
+import forestry.api.apiculture.IBeeModifier;
+import forestry.api.core.INBTTagable;
+import forestry.api.genetics.IFlowerProvider;
+import forestry.core.utils.vect.Vect;
+import forestry.plugins.PluginApiculture;
+
+public class HasFlowersCache implements INBTTagable {
+	private static final String nbtKey = "hasFlowerCache";
+	private static final Random random = new Random();
+	private static final int flowerCheckInterval = 128;
+
+	private final int flowerCheckTime = random.nextInt(flowerCheckInterval);
+	private ChunkCoordinates flowerCoords = null;
+	private int cooldown = 0;
+
+	public boolean hasFlowers(IBee queen, IBeeHousing beeHousing) {
+		IFlowerProvider flowerProvider = queen.getGenome().getFlowerProvider();
+		String flowerType = flowerProvider.getFlowerType();
+		World world = beeHousing.getWorld();
+
+		if (flowerCoords != null) {
+			if (world.getTotalWorldTime() % flowerCheckInterval != flowerCheckTime) {
+				return true;
+			}
+
+			IBeeModifier beeModifier = BeeManager.beeRoot.createBeeHousingModifier(beeHousing);
+			ChunkCoordinates housingCoords = beeHousing.getCoordinates();
+
+			int[] genomeTerritory = queen.getGenome().getTerritory();
+			float housingModifier = beeModifier.getTerritoryModifier(queen.getGenome(), 1f);
+			Vect area = new Vect(genomeTerritory).multiply(housingModifier * 3.0f);
+			Vect min = new Vect(area).multiply(-0.5f).add(housingCoords);
+			Vect max = new Vect(area).multiply(0.5f).add(housingCoords);
+
+			if (isFlowerValid(world, flowerType, min, max)) {
+				return true;
+			} else {
+				flowerCoords = null;
+				cooldown = 0;
+			}
+		}
+
+		if (cooldown <= 0) {
+			flowerCoords = FlowerManager.flowerRegistry.getAcceptedFlowerCoordinates(beeHousing, queen, flowerType);
+			cooldown = PluginApiculture.ticksPerBeeWorkCycle;
+		} else {
+			cooldown--;
+		}
+
+		return flowerCoords != null;
+	}
+
+	private boolean isFlowerValid(World world, String flowerType, Vect min, Vect max) {
+		if (!isFlowerCoordInRange(flowerCoords, min, max)) {
+			return false;
+		}
+		return FlowerManager.flowerRegistry.isAcceptedFlower(flowerType, world, flowerCoords.posX, flowerCoords.posY, flowerCoords.posZ);
+	}
+
+	private static boolean isFlowerCoordInRange(ChunkCoordinates flowerCoords, Vect min, Vect max) {
+		return flowerCoords.posX >= min.x && flowerCoords.posX <= max.x && flowerCoords.posY >= min.y && flowerCoords.posY <= max.y && flowerCoords.posZ >= min.z && flowerCoords.posZ <= max.z;
+	}
+
+	@Override
+	public void readFromNBT(NBTTagCompound nbttagcompound) {
+		if (!nbttagcompound.hasKey(nbtKey)) {
+			return;
+		}
+
+		NBTTagCompound hasFlowerCacheNBT = nbttagcompound.getCompoundTag(nbtKey);
+		if (hasFlowerCacheNBT.hasKey("flowerX")) {
+			int x = hasFlowerCacheNBT.getInteger("flowerX");
+			int y = hasFlowerCacheNBT.getInteger("flowerY");
+			int z = hasFlowerCacheNBT.getInteger("flowerZ");
+			flowerCoords = new ChunkCoordinates(x, y, z);
+		}
+
+		cooldown = hasFlowerCacheNBT.getInteger("cooldown");
+	}
+
+	@Override
+	public void writeToNBT(NBTTagCompound nbttagcompound) {
+		NBTTagCompound hasFlowerCacheNBT = new NBTTagCompound();
+		if (flowerCoords != null) {
+			hasFlowerCacheNBT.setInteger("flowerX", flowerCoords.posX);
+			hasFlowerCacheNBT.setInteger("flowerY", flowerCoords.posY);
+			hasFlowerCacheNBT.setInteger("flowerZ", flowerCoords.posZ);
+		}
+		hasFlowerCacheNBT.setInteger("cooldown", cooldown);
+
+		nbttagcompound.setTag(nbtKey, hasFlowerCacheNBT);
+	}
+}

src/main/java/forestry/apiculture/IApiary.java

@@ -0,0 +1,18 @@
+/*******************************************************************************
+ * 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 forestry.apiculture;
+
+import forestry.api.apiculture.IBeeHousing;
+import forestry.apiculture.inventory.IApiaryInventory;
+
+public interface IApiary extends IBeeHousing {
+	IApiaryInventory getApiaryInventory();
+}

src/main/java/forestry/apiculture/InventoryBeeHousing.java

@@ -0,0 +1,78 @@
+/*******************************************************************************
+ * 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 forestry.apiculture;
+
+import net.minecraft.item.ItemStack;
+
+import forestry.api.apiculture.BeeManager;
+import forestry.api.apiculture.EnumBeeType;
+import forestry.api.apiculture.IBeeHousingInventory;
+import forestry.core.access.IAccessHandler;
+import forestry.core.inventory.InventoryAdapterRestricted;
+import forestry.core.utils.InventoryUtil;
+import forestry.core.utils.SlotUtil;
+
+public class InventoryBeeHousing extends InventoryAdapterRestricted implements IBeeHousingInventory {
+	public static final int SLOT_QUEEN = 0;
+	public static final int SLOT_DRONE = 1;
+	public static final int SLOT_PRODUCT_1 = 2;
+	public static final int SLOT_PRODUCT_COUNT = 7;
+
+	public InventoryBeeHousing(int size, IAccessHandler accessHandler) {
+		super(size, "Items", accessHandler);
+	}
+
+	@Override
+	public boolean canSlotAccept(int slotIndex, ItemStack itemStack) {
+		EnumBeeType beeType = BeeManager.beeRoot.getType(itemStack);
+
+		if (slotIndex == SLOT_QUEEN) {
+			return beeType == EnumBeeType.QUEEN || beeType == EnumBeeType.PRINCESS;
+		} else if (slotIndex == SLOT_DRONE) {
+			return beeType == EnumBeeType.DRONE;
+		}
+		return false;
+	}
+
+	@Override
+	public boolean canExtractItem(int slotIndex, ItemStack itemstack, int side) {
+		if (!super.canExtractItem(slotIndex, itemstack, side)) {
+			return false;
+		}
+		return SlotUtil.isSlotInRange(slotIndex, SLOT_PRODUCT_1, SLOT_PRODUCT_COUNT);
+	}
+
+	@Override
+	public final ItemStack getQueen() {
+		return getStackInSlot(SLOT_QUEEN);
+	}
+
+	@Override
+	public final ItemStack getDrone() {
+		return getStackInSlot(SLOT_DRONE);
+	}
+
+	@Override
+	public final void setQueen(ItemStack itemstack) {
+		setInventorySlotContents(SLOT_QUEEN, itemstack);
+	}
+
+	@Override
+	public final void setDrone(ItemStack itemstack) {
+		setInventorySlotContents(SLOT_DRONE, itemstack);
+	}
+
+	@Override
+	public final boolean addProduct(ItemStack product, boolean all) {
+		return InventoryUtil.tryAddStack(this, product, SLOT_PRODUCT_1, SLOT_PRODUCT_COUNT, all, true);
+	}
+
+}

src/main/java/forestry/apiculture/PacketHandlerApiculture.java

@@ -1,53 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture;
-
-import java.io.DataInputStream;
-import java.io.IOException;
-
-import net.minecraft.entity.player.EntityPlayer;
-
-import forestry.apiculture.gui.ContainerImprinter;
-import forestry.core.interfaces.IPacketHandler;
-import forestry.core.network.PacketCoordinates;
-import forestry.core.network.PacketIds;
-import forestry.core.proxy.Proxies;
-
-public class PacketHandlerApiculture implements IPacketHandler {
-
-	@Override
-	public boolean onPacketData(int packetID, DataInputStream data, EntityPlayer player) throws IOException {
-
-		switch (packetID) {
-			case PacketIds.HABITAT_BIOME_POINTER:
-				PacketCoordinates packetC = new PacketCoordinates();
-				packetC.readData(data);
-				Proxies.common.setHabitatLocatorCoordinates(player, packetC.getCoordinates());
-				return true;
-			case PacketIds.IMPRINT_SELECTION_GET:
-				onImprintSelectionGet(player);
-				return true;
-		}
-
-		return false;
-	}
-
-	private void onImprintSelectionGet(EntityPlayer playerEntity) {
-
-		if (!(playerEntity.openContainer instanceof ContainerImprinter)) {
-			return;
-		}
-
-		((ContainerImprinter) playerEntity.openContainer).sendSelection(playerEntity);
-
-	}
-
-}

src/main/java/forestry/apiculture/SaveEventHandlerApiculture.java

@@ -12,14 +12,14 @@ package forestry.apiculture;
 
 import net.minecraft.world.World;
 
-import forestry.core.interfaces.ISaveEventHandler;
-import forestry.plugins.PluginApiculture;
+import forestry.api.apiculture.BeeManager;
+import forestry.core.ISaveEventHandler;
 
 public class SaveEventHandlerApiculture implements ISaveEventHandler {
 
 	@Override
 	public void onWorldLoad(World world) {
-		PluginApiculture.beeInterface.resetBeekeepingMode();
+		BeeManager.beeRoot.resetBeekeepingMode();
 	}
 
 	@Override

src/main/java/forestry/apiculture/VillageHandlerApiculture.java

@@ -23,17 +23,16 @@ import net.minecraft.village.MerchantRecipeList;
 import net.minecraft.world.gen.structure.MapGenStructureIO;
 import net.minecraft.world.gen.structure.StructureVillagePieces;
 
+import net.minecraftforge.oredict.OreDictionary;
+
 import cpw.mods.fml.common.registry.VillagerRegistry.IVillageCreationHandler;
 import cpw.mods.fml.common.registry.VillagerRegistry.IVillageTradeHandler;
 
 import forestry.api.apiculture.EnumBeeType;
-import forestry.apiculture.genetics.BeeTemplates;
-import forestry.apiculture.items.ItemHoneycomb;
+import forestry.apiculture.blocks.BlockApicultureType;
+import forestry.apiculture.genetics.BeeDefinition;
 import forestry.apiculture.worldgen.ComponentVillageBeeHouse;
-import forestry.core.config.Defaults;
-import forestry.core.config.ForestryBlock;
-import forestry.core.config.ForestryItem;
-import forestry.core.proxy.Proxies;
+import forestry.core.utils.Log;
 import forestry.plugins.PluginApiculture;
 
 public class VillageHandlerApiculture implements IVillageCreationHandler, IVillageTradeHandler {
@@ -42,21 +41,27 @@ public class VillageHandlerApiculture implements IVillageCreationHandler, IVilla
 		try {
 			MapGenStructureIO.func_143031_a(ComponentVillageBeeHouse.class, "Forestry:BeeHouse");
 		} catch (Throwable e) {
-			Proxies.log.severe("Failed to register village beehouse.");
+			Log.severe("Failed to register village beehouse.");
 		}
 	}
 
 	@SuppressWarnings("unchecked")
 	@Override
 	public void manipulateTradesForVillager(EntityVillager villager, MerchantRecipeList recipeList, Random random) {
-		recipeList.add(new MerchantRecipe(ForestryItem.beePrincessGE.getItemStack(1, Defaults.WILDCARD), new ItemStack(Items.emerald, 1)));
-		recipeList.add(new MerchantRecipe(new ItemStack(Items.wheat, 2), ItemHoneycomb.getRandomComb(1, random, false)));
-		recipeList.add(new MerchantRecipe(new ItemStack(Blocks.log, 24, Defaults.WILDCARD), ForestryBlock.apiculture.getItemStack(1, Defaults.DEFINITION_APIARY_META)));
-		recipeList.add(new MerchantRecipe(new ItemStack(Items.emerald, 1), ForestryItem.frameProven.getItemStack(6)));
-		recipeList.add(new MerchantRecipe(new ItemStack(Items.emerald, 12), ForestryItem.beePrincessGE.getItemStack(1, Defaults.WILDCARD),
-				PluginApiculture.beeInterface.getMemberStack(
-						PluginApiculture.beeInterface.getBee(villager.worldObj, PluginApiculture.beeInterface.templateAsGenome(BeeTemplates.getMonasticTemplate())),
-						EnumBeeType.DRONE.ordinal())));
+		ItemStack wildcardPrincess = new ItemStack(PluginApiculture.items.beePrincessGE, 1, OreDictionary.WILDCARD_VALUE);
+		recipeList.add(new MerchantRecipe(wildcardPrincess, new ItemStack(Items.emerald, 1)));
+
+		ItemStack randomComb = PluginApiculture.items.beeComb.getRandomComb(1, random, false);
+		recipeList.add(new MerchantRecipe(new ItemStack(Items.wheat, 2), randomComb));
+
+		ItemStack apiary = PluginApiculture.blocks.apiculture.get(BlockApicultureType.APIARY);
+		recipeList.add(new MerchantRecipe(new ItemStack(Blocks.log, 24, OreDictionary.WILDCARD_VALUE), apiary));
+
+		ItemStack provenFrames = PluginApiculture.items.frameProven.getItemStack(6);
+		recipeList.add(new MerchantRecipe(new ItemStack(Items.emerald, 1), provenFrames));
+
+		ItemStack monasticDrone = BeeDefinition.MONASTIC.getMemberStack(EnumBeeType.DRONE);
+		recipeList.add(new MerchantRecipe(new ItemStack(Items.emerald, 12), wildcardPrincess, monasticDrone));
 	}
 
 	@Override

src/main/java/forestry/apiculture/blocks/BlockAlveary.java

@@ -8,7 +8,7 @@
  * Various Contributors including, but not limited to:
  * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
  ******************************************************************************/
-package forestry.apiculture.gadgets;
+package forestry.apiculture.blocks;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -28,15 +28,36 @@ import cpw.mods.fml.relauncher.SideOnly;
 
 import forestry.api.core.Tabs;
 import forestry.apiculture.MaterialBeehive;
-import forestry.core.gadgets.BlockStructure;
+import forestry.apiculture.multiblock.TileAlveary;
+import forestry.apiculture.multiblock.TileAlvearyFan;
+import forestry.apiculture.multiblock.TileAlvearyHeater;
+import forestry.apiculture.multiblock.TileAlvearyHygroregulator;
+import forestry.apiculture.multiblock.TileAlvearyPlain;
+import forestry.apiculture.multiblock.TileAlvearySieve;
+import forestry.apiculture.multiblock.TileAlvearyStabiliser;
+import forestry.apiculture.multiblock.TileAlvearySwarmer;
+import forestry.core.blocks.BlockStructure;
 import forestry.core.render.TextureManager;
 
 public class BlockAlveary extends BlockStructure {
+	public enum Type {
+		PLAIN,
+		ENTRANCE,
+		SWARMER,
+		FAN,
+		HEATER,
+		HYGRO,
+		STABILIZER,
+		SIEVE;
+
+		public static final Type[] VALUES = values();
+	}
 
 	public BlockAlveary() {
 		super(new MaterialBeehive(false));
 		setHardness(1.0f);
 		setCreativeTab(Tabs.tabApiculture);
+		setHarvestLevel("axe", 0);
 	}
 
 	@SuppressWarnings({"rawtypes", "unchecked"})
@@ -63,7 +84,7 @@ public class BlockAlveary extends BlockStructure {
 
 	@Override
 	public ArrayList<ItemStack> getDrops(World world, int x, int y, int z, int metadata, int fortune) {
-		ArrayList<ItemStack> drop = new ArrayList<ItemStack>();
+		ArrayList<ItemStack> drop = new ArrayList<>();
 		drop.add(new ItemStack(this, 1, metadata != 1 ? metadata : 0));
 		return drop;
 	}
@@ -77,19 +98,25 @@ public class BlockAlveary extends BlockStructure {
 	/* TILE ENTITY CREATION */
 	@Override
 	public TileEntity createTileEntity(World world, int metadata) {
-		switch (metadata) {
-			case TileAlvearySwarmer.BLOCK_META:
+		if (metadata < 0 || metadata > Type.VALUES.length) {
+			return null;
+		}
+
+		Type type = Type.VALUES[metadata];
+		switch (type) {
+			case SWARMER:
 				return new TileAlvearySwarmer();
-			case TileAlvearyFan.BLOCK_META:
+			case FAN:
 				return new TileAlvearyFan();
-			case TileAlvearyHeater.BLOCK_META:
+			case HEATER:
 				return new TileAlvearyHeater();
-			case TileAlvearyHygroregulator.BLOCK_META:
+			case HYGRO:
 				return new TileAlvearyHygroregulator();
-			case TileAlvearyStabiliser.BLOCK_META:
+			case STABILIZER:
 				return new TileAlvearyStabiliser();
-			case TileAlvearySieve.BLOCK_META:
+			case SIEVE:
 				return new TileAlvearySieve();
+			case PLAIN:
 			default:
 				return new TileAlvearyPlain();
 		}
@@ -123,47 +150,49 @@ public class BlockAlveary extends BlockStructure {
 	@Override
 	public void registerBlockIcons(IIconRegister register) {
 		icons = new IIcon[14];
-		icons[0] = TextureManager.getInstance().registerTex(register, "apiculture/alveary.plain");
-		icons[1] = TextureManager.getInstance().registerTex(register, "apiculture/alveary.entrance");
-		icons[2] = TextureManager.getInstance().registerTex(register, "apiculture/alveary.bottom");
-		icons[3] = TextureManager.getInstance().registerTex(register, "apiculture/alveary.left");
-		icons[4] = TextureManager.getInstance().registerTex(register, "apiculture/alveary.right");
-		icons[5] = TextureManager.getInstance().registerTex(register, "apiculture/alveary.swarmer.off");
-		icons[6] = TextureManager.getInstance().registerTex(register, "apiculture/alveary.swarmer.on");
-		icons[7] = TextureManager.getInstance().registerTex(register, "apiculture/alveary.heater.off");
-		icons[8] = TextureManager.getInstance().registerTex(register, "apiculture/alveary.heater.on");
-		icons[9] = TextureManager.getInstance().registerTex(register, "apiculture/alveary.fan.off");
-		icons[10] = TextureManager.getInstance().registerTex(register, "apiculture/alveary.fan.on");
-		icons[11] = TextureManager.getInstance().registerTex(register, "apiculture/alveary.valve");
-		icons[12] = TextureManager.getInstance().registerTex(register, "apiculture/alveary.stabiliser");
-		icons[13] = TextureManager.getInstance().registerTex(register, "apiculture/alveary.sieve");
+		icons[0] = TextureManager.registerTex(register, "apiculture/alveary.plain");
+		icons[1] = TextureManager.registerTex(register, "apiculture/alveary.entrance");
+		icons[2] = TextureManager.registerTex(register, "apiculture/alveary.bottom");
+		icons[3] = TextureManager.registerTex(register, "apiculture/alveary.left");
+		icons[4] = TextureManager.registerTex(register, "apiculture/alveary.right");
+		icons[5] = TextureManager.registerTex(register, "apiculture/alveary.swarmer.off");
+		icons[6] = TextureManager.registerTex(register, "apiculture/alveary.swarmer.on");
+		icons[7] = TextureManager.registerTex(register, "apiculture/alveary.heater.off");
+		icons[8] = TextureManager.registerTex(register, "apiculture/alveary.heater.on");
+		icons[9] = TextureManager.registerTex(register, "apiculture/alveary.fan.off");
+		icons[10] = TextureManager.registerTex(register, "apiculture/alveary.fan.on");
+		icons[11] = TextureManager.registerTex(register, "apiculture/alveary.valve");
+		icons[12] = TextureManager.registerTex(register, "apiculture/alveary.stabiliser");
+		icons[13] = TextureManager.registerTex(register, "apiculture/alveary.sieve");
 	}
 
 	@SideOnly(Side.CLIENT)
 	@Override
 	public IIcon getIcon(int side, int metadata) {
 		if ((metadata <= 1
-				|| metadata == TileAlvearySieve.BLOCK_META || metadata == TileAlvearySwarmer.BLOCK_META || metadata == TileAlvearyStabiliser.BLOCK_META)
+				|| metadata == Type.SIEVE.ordinal() || metadata == Type.SWARMER.ordinal() || metadata == Type.STABILIZER.ordinal())
 				&& (side == 1 || side == 0)) {
 			return icons[BOTTOM];
 		}
 
-		switch (metadata) {
-			case TileAlvearyPlain.BLOCK_META:
+		Type type = Type.VALUES[metadata];
+
+		switch (type) {
+			case PLAIN:
 				return icons[PLAIN];
-			case 1:
+			case ENTRANCE:
 				return icons[ENTRANCE];
-			case TileAlvearySwarmer.BLOCK_META:
+			case SWARMER:
 				return icons[ALVEARY_SWARMER_OFF];
-			case TileAlvearyFan.BLOCK_META:
+			case FAN:
 				return icons[ALVEARY_FAN_OFF];
-			case TileAlvearyHeater.BLOCK_META:
+			case HEATER:
 				return icons[ALVEARY_HEATER_OFF];
-			case TileAlvearyHygroregulator.BLOCK_META:
+			case HYGRO:
 				return icons[ALVEARY_HYGRO];
-			case TileAlvearyStabiliser.BLOCK_META:
+			case STABILIZER:
 				return icons[STABILISER];
-			case TileAlvearySieve.BLOCK_META:
+			case SIEVE:
 				return icons[SIEVE];
 			default:
 				return null;
@@ -219,11 +248,11 @@ public class BlockAlveary extends BlockStructure {
 	@SideOnly(Side.CLIENT)
 	private IIcon getBlockTextureFromSideAndTile(IBlockAccess world, int x, int y, int z, int side) {
 		TileEntity tile = world.getTileEntity(x, y, z);
-		if (tile == null || !(tile instanceof TileAlveary)) {
+		if (!(tile instanceof TileAlveary)) {
 			return getIcon(side, 0);
 		}
 
-		return icons[((TileAlveary) tile).getIcon(side, world.getBlockMetadata(x, y, z))];
+		return icons[((TileAlveary) tile).getIcon(side)];
 	}
 
 	@SideOnly(Side.CLIENT)
@@ -242,4 +271,21 @@ public class BlockAlveary extends BlockStructure {
 		}
 
 	}
+
+	@Override
+	public void onNeighborBlockChange(World world, int x, int y, int z, Block block) {
+		super.onNeighborBlockChange(world, x, y, z, block);
+
+		TileEntity tileEntity = world.getTileEntity(x, y, z);
+		if (tileEntity instanceof TileAlveary) {
+			TileAlveary tileAlveary = (TileAlveary) tileEntity;
+
+			// We must check that the slabs on top were not removed
+			tileAlveary.getMultiblockLogic().getController().reassemble();
+		}
+	}
+
+	public ItemStack get(Type type) {
+		return new ItemStack(this, 1, type.ordinal());
+	}
 }

src/main/java/forestry/apiculture/blocks/BlockApiculture.java

@@ -1,22 +1,22 @@
-/*******************************************************************************
- * 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 forestry.apiculture.gadgets;
-
-public class TileAlvearyFan extends TileAlvearyClimatiser {
-	
-	/* CONSTANTS */
-	public static final int BLOCK_META = 3;
-
-	public TileAlvearyFan() {
-		super(new ClimateControl(-0.01f, 0.05f, 2.5f), BlockAlveary.ALVEARY_FAN_OFF, BlockAlveary.ALVEARY_FAN_ON, BLOCK_META);
-	}
-
-}
+/*******************************************************************************
+ * 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 forestry.apiculture.blocks;
+
+import forestry.api.core.Tabs;
+import forestry.core.blocks.BlockBase;
+
+public class BlockApiculture extends BlockBase<BlockApicultureType> {
+	public BlockApiculture() {
+		super();
+		setCreativeTab(Tabs.tabApiculture);
+		setHarvestLevel("axe", 0);
+	}
+}

src/main/java/forestry/apiculture/blocks/BlockApicultureType.java

@@ -0,0 +1,58 @@
+/*******************************************************************************
+ * 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 forestry.apiculture.blocks;
+
+import java.util.Locale;
+
+import org.apache.commons.lang3.text.WordUtils;
+
+import forestry.apiculture.tiles.TileApiaristChest;
+import forestry.apiculture.tiles.TileApiary;
+import forestry.apiculture.tiles.TileBeehouse;
+import forestry.core.blocks.IMachineProperties;
+import forestry.core.tiles.TileForestry;
+
+public enum BlockApicultureType implements IMachineProperties {
+	APIARY(TileApiary.class),
+	APIARIST_CHEST_LEGACY(TileApiaristChest.class, "ApiaristChest"),
+	BEEHOUSE(TileBeehouse.class);
+
+	public static final BlockApicultureType[] VALUES = values();
+
+	private final String teIdent;
+	private final Class<? extends TileForestry> teClass;
+
+	BlockApicultureType(Class<? extends TileForestry> teClass) {
+		String name = toString().toLowerCase(Locale.ENGLISH);
+		this.teIdent = "forestry." + WordUtils.capitalize(name);
+		this.teClass = teClass;
+	}
+
+	BlockApicultureType(Class<? extends TileForestry> teClass, String name) {
+		this.teIdent = "forestry." + name;
+		this.teClass = teClass;
+	}
+
+	@Override
+	public int getMeta() {
+		return ordinal();
+	}
+
+	@Override
+	public String getTeIdent() {
+		return teIdent;
+	}
+
+	@Override
+	public Class<? extends TileForestry> getTeClass() {
+		return teClass;
+	}
+}

src/main/java/forestry/apiculture/blocks/BlockBeehives.java

@@ -8,7 +8,7 @@
  * Various Contributors including, but not limited to:
  * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
  ******************************************************************************/
-package forestry.apiculture.gadgets;
+package forestry.apiculture.blocks;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -32,14 +32,20 @@ import cpw.mods.fml.relauncher.SideOnly;
 import forestry.api.apiculture.IHiveDrop;
 import forestry.api.core.Tabs;
 import forestry.apiculture.MaterialBeehive;
+import forestry.apiculture.tiles.TileSwarm;
 import forestry.apiculture.worldgen.HiveRegistry;
 import forestry.core.config.Config;
-import forestry.core.inventory.InvTools;
 import forestry.core.render.TextureManager;
-import forestry.core.utils.StackUtils;
+import forestry.core.utils.InventoryUtil;
+import forestry.core.utils.ItemStackUtil;
 import forestry.plugins.PluginApiculture;
 
 public class BlockBeehives extends BlockContainer {
+	public enum Type {
+		LEGACY,
+		FOREST,
+		MEADOWS;
+	}
 
 	public BlockBeehives() {
 		super(new MaterialBeehive(true));
@@ -68,9 +74,9 @@ public class BlockBeehives extends BlockContainer {
 			if (tile instanceof TileSwarm) {
 				TileSwarm swarm = (TileSwarm) tile;
 				if (swarm.containsBees()) {
-					for (ItemStack beeStack : InvTools.getStacks(swarm.contained)) {
+					for (ItemStack beeStack : InventoryUtil.getStacks(swarm.contained)) {
 						if (beeStack != null) {
-							StackUtils.dropItemStackAsEntity(beeStack, world, x, y, z);
+							ItemStackUtil.dropItemStackAsEntity(beeStack, world, x, y, z);
 						}
 					}
 				}
@@ -82,7 +88,7 @@ public class BlockBeehives extends BlockContainer {
 
 	@Override
 	public ArrayList<ItemStack> getDrops(World world, int x, int y, int z, int metadata, int fortune) {
-		ArrayList<ItemStack> ret = new ArrayList<ItemStack>();
+		ArrayList<ItemStack> ret = new ArrayList<>();
 
 		// Handle legacy block
 		if (metadata == 0) {
@@ -132,7 +138,7 @@ public class BlockBeehives extends BlockContainer {
 		return meta;
 	}
 
-	private List<IHiveDrop> getDropsForHive(int meta) {
+	private static List<IHiveDrop> getDropsForHive(int meta) {
 		String hiveName = getHiveNameForMeta(meta);
 		if (hiveName == null) {
 			return Collections.emptyList();
@@ -140,7 +146,7 @@ public class BlockBeehives extends BlockContainer {
 		return PluginApiculture.hiveRegistry.getDrops(hiveName);
 	}
 
-	private String getHiveNameForMeta(int meta) {
+	private static String getHiveNameForMeta(int meta) {
 		switch (meta) {
 			case 1:
 				return HiveRegistry.forest;
@@ -184,8 +190,8 @@ public class BlockBeehives extends BlockContainer {
 	public void registerBlockIcons(IIconRegister register) {
 		icons = new IIcon[18];
 		for (int i = 1; i < 9; i++) {
-			icons[i * 2] = TextureManager.getInstance().registerTex(register, "beehives/beehive." + i + ".top");
-			icons[(i * 2) + 1] = TextureManager.getInstance().registerTex(register, "beehives/beehive." + i + ".side");
+			icons[i * 2] = TextureManager.registerTex(register, "beehives/beehive." + i + ".top");
+			icons[(i * 2) + 1] = TextureManager.registerTex(register, "beehives/beehive." + i + ".side");
 		}
 	}
 

src/main/java/forestry/apiculture/blocks/BlockCandle.java

@@ -0,0 +1,336 @@
+/*******************************************************************************
+ * 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 forestry.apiculture.blocks;
+
+import com.google.common.collect.ImmutableMap;
+
+import java.awt.Color;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+
+import net.minecraft.block.BlockTorch;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+
+import net.minecraftforge.oredict.OreDictionary;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+import forestry.api.core.Tabs;
+import forestry.apiculture.tiles.TileCandle;
+import forestry.core.proxy.Proxies;
+import forestry.core.render.TextureManager;
+import forestry.core.utils.ItemStackUtil;
+import forestry.core.utils.StringUtil;
+
+public class BlockCandle extends BlockTorch {
+
+	private static final ImmutableMap<String, Integer> colours;
+	private static final Set<Item> lightingItems;
+	public static final String colourTagName = "colour";
+
+	static {
+		colours = ImmutableMap.<String, Integer>builder()
+				.put("dyeWhite", new Color(255, 255, 255).getRGB())
+				.put("dyeOrange", new Color(219, 125, 62).getRGB())
+				.put("dyeMagenta", new Color(255, 20, 255).getRGB())
+				.put("dyeLightBlue", new Color(107, 138, 201).getRGB())
+				.put("dyeYellow", new Color(255, 255, 20).getRGB())
+				.put("dyeLime", new Color(20, 255, 20).getRGB())
+				.put("dyePink", new Color(208, 132, 153).getRGB())
+				.put("dyeGray", new Color(74, 74, 74).getRGB())
+				.put("dyeLightGray", new Color(154, 161, 161).getRGB())
+				.put("dyeCyan", new Color(20, 255, 255).getRGB())
+				.put("dyePurple", new Color(126, 61, 181).getRGB())
+				.put("dyeBlue", new Color(20, 20, 255).getRGB())
+				.put("dyeBrown", new Color(79, 50, 31).getRGB())
+				.put("dyeGreen", new Color(53, 70, 27).getRGB())
+				.put("dyeRed", new Color(150, 52, 48).getRGB())
+				.put("dyeBlack", new Color(20, 20, 20).getRGB())
+				.build();
+
+		lightingItems = new HashSet<>(Arrays.asList(
+				Items.flint_and_steel,
+				Items.flint,
+				Item.getItemFromBlock(Blocks.torch)
+		));
+	}
+
+	@SideOnly(Side.CLIENT)
+	private IIcon litStump;
+	@SideOnly(Side.CLIENT)
+	private IIcon litTip;
+	@SideOnly(Side.CLIENT)
+	private IIcon unlitStump;
+	@SideOnly(Side.CLIENT)
+	private IIcon unlitTip;
+
+	public BlockCandle() {
+		super();
+		this.setHardness(0.0F);
+		this.setStepSound(soundTypeWood);
+		setCreativeTab(Tabs.tabApiculture);
+	}
+
+	@Override
+	public boolean hasTileEntity(int metadata) {
+		return true;
+	}
+
+	@Override
+	public TileEntity createTileEntity(World world, int metadata) {
+		return new TileCandle();
+	}
+
+	@Override
+	public int getRenderType() {
+		return Proxies.render.getCandleRenderId();
+	}
+
+	@SideOnly(Side.CLIENT)
+	@Override
+	public void registerBlockIcons(IIconRegister register) {
+		String fileBase = StringUtil.cleanBlockName(this);
+		this.blockIcon = TextureManager.registerTex(register, "stump");
+		this.litStump = TextureManager.registerTex(register, fileBase + "StumpLit");
+		this.litTip = TextureManager.registerTex(register, fileBase + "TipLit");
+		this.unlitStump = TextureManager.registerTex(register, fileBase + "StumpUnlit");
+		this.unlitTip = TextureManager.registerTex(register, fileBase + "TipUnlit");
+	}
+
+	@Override
+	public int getLightValue(IBlockAccess world, int x, int y, int z) {
+		TileEntity tileEntity = world.getTileEntity(x, y, z);
+		if (tileEntity instanceof TileCandle && ((TileCandle) tileEntity).isLit()) {
+			return 14;
+		}
+		return 0;
+	}
+
+	@SideOnly(Side.CLIENT)
+	public IIcon getTextureFromPassAndLit(int pass, boolean isLit) {
+		IIcon i;
+		if (pass == 0) {
+			if (isLit) {
+				i = this.litTip;
+			} else {
+				i = this.unlitTip;
+			}
+		} else {
+			if (isLit) {
+				i = this.litStump;
+			} else {
+				i = this.unlitStump;
+			}
+		}
+		return i;
+	}
+
+	@SuppressWarnings({"rawtypes", "unchecked"})
+	@Override
+	public void getSubBlocks(Item item, CreativeTabs par2CreativeTabs, List itemList) {
+		itemList.add(new ItemStack(this, 1, 0));
+	}
+
+	@Override
+	public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int facing, float facingX, float facingY, float facingZ) {
+		TileEntity tileEntity = world.getTileEntity(x, y, z);
+		if (!(tileEntity instanceof TileCandle)) {
+			return false;
+		}
+
+		TileCandle tileCandle = (TileCandle) tileEntity;
+		final boolean isLit = tileCandle.isLit();
+
+		boolean flag = false;
+		boolean toggleLitState = true;
+		ItemStack heldItem = player.getCurrentEquippedItem();
+
+		if (!isLit) {
+			if (heldItem == null || !lightingItems.contains(heldItem.getItem())) {
+				toggleLitState = false;
+			} else if (ItemStackUtil.equals(this, heldItem) && isLit(heldItem)) {
+				toggleLitState = true;
+			}
+		}
+
+		if (heldItem != null) {
+			if (ItemStackUtil.equals(this, heldItem)) {
+				if (!isLit(heldItem)) {
+					// Copy the colour of an unlit, coloured candle.
+					if (heldItem.hasTagCompound() && heldItem.getTagCompound().hasKey(colourTagName)) {
+						tileCandle.setColour(heldItem.getTagCompound().getInteger(colourTagName));
+					} else {
+						// Reset to white if item has no
+						tileCandle.setColour(0xffffff);
+					}
+				} else {
+					toggleLitState = true;
+				}
+				flag = true;
+			} else {
+				boolean dyed = tryDye(heldItem, isLit, tileCandle);
+				if (dyed) {
+					world.markBlockForUpdate(x, y, z);
+					toggleLitState = false;
+					flag = true;
+				}
+			}
+		}
+
+		if (toggleLitState) {
+			tileCandle.setLit(!isLit);
+			world.markBlockForUpdate(x, y, z);
+			flag = true;
+		}
+		return flag;
+	}
+
+	private static boolean tryDye(ItemStack held, boolean isLit, TileCandle tileCandle) {
+		// Check for dye-able ness.
+		for (Map.Entry<String, Integer> colour : colours.entrySet()) {
+			String colourName = colour.getKey();
+			for (ItemStack stack : OreDictionary.getOres(colourName)) {
+				if (OreDictionary.itemMatches(stack, held, true)) {
+					if (isLit) {
+						tileCandle.setColour(colour.getValue());
+					} else {
+						tileCandle.addColour(colour.getValue());
+					}
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	/* DROP HANDLING */
+	// Hack: 	When harvesting we need to get the drops in onBlockHarvested,
+	// 			because Mojang destroys the block and tile before calling getDrops.
+	private final ThreadLocal<ItemStack> drop = new ThreadLocal<>();
+
+	@Override
+	public void onBlockHarvested(World world, int x, int y, int z, int metadata, EntityPlayer player) {
+		if (!world.isRemote) {
+			ItemStack itemStack = getCandleDrop(world, x, y, z);
+			drop.set(itemStack);
+		}
+	}
+
+	@Override
+	public ArrayList<ItemStack> getDrops(World world, int x, int y, int z, int metadata, int fortune) {
+		ItemStack dropStack = drop.get();
+		drop.remove();
+
+		// not harvested, get drops normally
+		if (dropStack == null) {
+			dropStack = getCandleDrop(world, x, y, z);
+		}
+
+		ArrayList<ItemStack> drops = new ArrayList<>(1);
+		drops.add(dropStack);
+
+		return drops;
+	}
+
+	@Override
+	public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z) {
+		return getCandleDrop(world, x, y, z);
+	}
+
+	private ItemStack getCandleDrop(World world, int x, int y, int z) {
+		TileEntity tileEntity = world.getTileEntity(x, y, z);
+		if (!(tileEntity instanceof TileCandle)) {
+			return null;
+		}
+		TileCandle tileCandle = (TileCandle) tileEntity;
+		int colour = tileCandle.getColour();
+
+		int newMeta = tileCandle.isLit() ? 1 : 0;
+		ItemStack itemStack = new ItemStack(this, 1, newMeta);
+		if (colour != 0xffffff) {
+			// When dropped, tag new item stack with colour. Unless it's white, then do no such thing for maximum stacking.
+			NBTTagCompound tag = new NBTTagCompound();
+			tag.setInteger(colourTagName, colour);
+			itemStack.setTagCompound(tag);
+		}
+		return itemStack;
+	}
+
+	@Override
+	public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase player, ItemStack itemStack) {
+		TileCandle tileCandle = (TileCandle) (world.getTileEntity(x, y, z));
+		int colour = getColourValueFromItemStack(itemStack);
+		boolean isLit = isLit(itemStack);
+		tileCandle.setColour(colour);
+		tileCandle.setLit(isLit);
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void randomDisplayTick(World world, int x, int y, int z, Random random) {
+		TileEntity tileEntity = world.getTileEntity(x, y, z);
+		if (tileEntity instanceof TileCandle && ((TileCandle) tileEntity).isLit()) {
+			super.randomDisplayTick(world, x, y, z, random);
+		}
+	}
+
+	private static int getColourValueFromItemStack(ItemStack itemStack) {
+		int value = 0xffffff; // default to white.
+		if (itemStack.hasTagCompound()) {
+			NBTTagCompound tag = itemStack.getTagCompound();
+			if (tag.hasKey(colourTagName)) {
+				value = tag.getInteger(colourTagName);
+			}
+		}
+		return value;
+	}
+
+	public static boolean isLit(ItemStack itemStack) {
+		return itemStack.getItemDamage() > 0;
+	}
+
+	public static void addItemToLightingList(Item item) {
+		if (item == null) {
+			throw new NullPointerException();
+		}
+
+		if (!lightingItems.contains(item)) {
+			lightingItems.add(item);
+		}
+	}
+
+	public ItemStack getUnlitCandle(int amount) {
+		return new ItemStack(this, amount, 0);
+	}
+
+	public ItemStack getLitCandle(int amount) {
+		return new ItemStack(this, amount, 1);
+	}
+}

src/main/java/forestry/apiculture/blocks/BlockRegistryApiculture.java

@@ -0,0 +1,41 @@
+/*******************************************************************************
+ * 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 forestry.apiculture.blocks;
+
+import forestry.api.core.Tabs;
+import forestry.apiculture.items.ItemBlockCandle;
+import forestry.core.blocks.BlockBase;
+import forestry.core.blocks.BlockRegistry;
+import forestry.core.items.ItemBlockForestry;
+
+public class BlockRegistryApiculture extends BlockRegistry {
+	public final BlockApiculture apiculture;
+	public final BlockBase apicultureChest;
+	public final BlockBeehives beehives;
+	public final BlockCandle candle;
+	public final BlockStump stump;
+	public final BlockAlveary alveary;
+
+	public BlockRegistryApiculture() {
+		apiculture = registerBlock(new BlockApiculture(), ItemBlockForestry.class, "apiculture");
+
+		apicultureChest = registerBlock(new BlockBase(true), ItemBlockForestry.class, "apicultureChest");
+		apicultureChest.setCreativeTab(Tabs.tabApiculture);
+		apicultureChest.setHarvestLevel("axe", 0);
+
+		beehives = registerBlock(new BlockBeehives(), ItemBlockForestry.class, "beehives");
+
+		candle = registerBlock(new BlockCandle(), ItemBlockCandle.class, "candle");
+		stump = registerBlock(new BlockStump(), ItemBlockForestry.class, "stump");
+
+		alveary = registerBlock(new BlockAlveary(), ItemBlockForestry.class, "alveary");
+	}
+}

src/main/java/forestry/apiculture/blocks/BlockStump.java

@@ -8,7 +8,7 @@
  * Various Contributors including, but not limited to:
  * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
  ******************************************************************************/
-package forestry.apiculture.gadgets;
+package forestry.apiculture.blocks;
 
 import java.util.List;
 import java.util.Random;
@@ -27,11 +27,12 @@ import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
 import forestry.api.core.Tabs;
-import forestry.core.config.Defaults;
-import forestry.core.config.ForestryBlock;
+import forestry.apiculture.tiles.TileCandle;
+import forestry.core.config.Constants;
 import forestry.core.render.TextureManager;
-import forestry.core.utils.StackUtils;
+import forestry.core.utils.ItemStackUtil;
 import forestry.core.utils.StringUtil;
+import forestry.plugins.PluginApiculture;
 
 public class BlockStump extends BlockTorch {
 
@@ -45,7 +46,7 @@ public class BlockStump extends BlockTorch {
 	@SideOnly(Side.CLIENT)
 	@Override
 	public void registerBlockIcons(IIconRegister register) {
-		this.blockIcon = TextureManager.getInstance().registerTex(register, StringUtil.cleanBlockName(this));
+		this.blockIcon = TextureManager.registerTex(register, StringUtil.cleanBlockName(this));
 	}
 
 	@SuppressWarnings({"rawtypes", "unchecked"})
@@ -61,8 +62,8 @@ public class BlockStump extends BlockTorch {
 		if (held != null &&
 				(held.getItem() == Items.flint_and_steel ||
 						held.getItem() == Items.flint ||
-						StackUtils.equals(Blocks.torch, held))) {
-			world.setBlock(x, y, z, ForestryBlock.candle.block(), world.getBlockMetadata(x, y, z) | 0x08, Defaults.FLAG_BLOCK_SYNCH);
+						ItemStackUtil.equals(Blocks.torch, held))) {
+			world.setBlock(x, y, z, PluginApiculture.blocks.candle, world.getBlockMetadata(x, y, z) | 0x08, Constants.FLAG_BLOCK_SYNCH);
 			TileCandle tc = new TileCandle();
 			tc.setColour(0); // default to white
 			world.setTileEntity(x, y, z, tc);

src/main/java/forestry/apiculture/commands/BeeModeHelper.java

@@ -15,17 +15,17 @@ import java.util.List;
 
 import net.minecraft.world.World;
 
+import forestry.api.apiculture.BeeManager;
 import forestry.api.apiculture.IBeekeepingMode;
 import forestry.core.commands.ICommandModeHelper;
-import forestry.plugins.PluginApiculture;
 
 public class BeeModeHelper implements ICommandModeHelper {
 
 	@Override
 	public String[] getModeNames() {
-		ArrayList<IBeekeepingMode> beekeepingModes = PluginApiculture.beeInterface.getBeekeepingModes();
+		ArrayList<IBeekeepingMode> beekeepingModes = BeeManager.beeRoot.getBeekeepingModes();
 		int modeStringCount = beekeepingModes.size();
-		List<String> modeStrings = new ArrayList<String>(modeStringCount);
+		List<String> modeStrings = new ArrayList<>(modeStringCount);
 		for (IBeekeepingMode mode : beekeepingModes) {
 			modeStrings.add(mode.getName());
 		}
@@ -35,7 +35,7 @@ public class BeeModeHelper implements ICommandModeHelper {
 
 	@Override
 	public String getModeNameMatching(String desired) {
-		IBeekeepingMode mode = PluginApiculture.beeInterface.getBeekeepingMode(desired);
+		IBeekeepingMode mode = BeeManager.beeRoot.getBeekeepingMode(desired);
 		if (mode == null) {
 			return null;
 		}
@@ -44,17 +44,17 @@ public class BeeModeHelper implements ICommandModeHelper {
 
 	@Override
 	public String getModeName(World world) {
-		return PluginApiculture.beeInterface.getBeekeepingMode(world).getName();
+		return BeeManager.beeRoot.getBeekeepingMode(world).getName();
 	}
 
 	@Override
 	public void setMode(World world, String modeName) {
-		PluginApiculture.beeInterface.setBeekeepingMode(world, modeName);
+		BeeManager.beeRoot.setBeekeepingMode(world, modeName);
 	}
 
 	@Override
 	public Iterable<String> getDescription(String modeName) {
-		IBeekeepingMode mode = PluginApiculture.beeInterface.getBeekeepingMode(modeName);
+		IBeekeepingMode mode = BeeManager.beeRoot.getBeekeepingMode(modeName);
 		return mode.getDescription();
 	}
 

src/main/java/forestry/apiculture/commands/BeeStatsSaveHelper.java

@@ -18,6 +18,7 @@ import net.minecraft.world.World;
 
 import com.mojang.authlib.GameProfile;
 
+import forestry.api.apiculture.BeeManager;
 import forestry.api.apiculture.IAlleleBeeSpecies;
 import forestry.api.apiculture.IApiaristTracker;
 import forestry.api.genetics.AlleleManager;
@@ -26,7 +27,6 @@ import forestry.api.genetics.IAlleleSpecies;
 import forestry.api.genetics.IBreedingTracker;
 import forestry.core.commands.IStatsSaveHelper;
 import forestry.core.utils.StringUtil;
-import forestry.plugins.PluginApiculture;
 
 public class BeeStatsSaveHelper implements IStatsSaveHelper {
 
@@ -53,7 +53,7 @@ public class BeeStatsSaveHelper implements IStatsSaveHelper {
 
 	@Override
 	public Collection<IAlleleSpecies> getSpecies() {
-		Collection<IAlleleSpecies> species = new ArrayList<IAlleleSpecies>();
+		Collection<IAlleleSpecies> species = new ArrayList<>();
 		for (IAllele allele : AlleleManager.alleleRegistry.getRegisteredAlleles().values()) {
 			if (allele instanceof IAlleleBeeSpecies) {
 				species.add((IAlleleBeeSpecies) allele);
@@ -69,7 +69,7 @@ public class BeeStatsSaveHelper implements IStatsSaveHelper {
 
 	@Override
 	public IBreedingTracker getBreedingTracker(World world, GameProfile gameProfile) {
-		return PluginApiculture.beeInterface.getBreedingTracker(world, gameProfile);
+		return BeeManager.beeRoot.getBreedingTracker(world, gameProfile);
 	}
 
 }

src/main/java/forestry/apiculture/commands/CommandBeeGive.java

@@ -18,6 +18,7 @@ import net.minecraft.command.ICommandSender;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
 
+import forestry.api.apiculture.BeeManager;
 import forestry.api.apiculture.EnumBeeType;
 import forestry.api.apiculture.IAlleleBeeSpecies;
 import forestry.api.apiculture.IBee;
@@ -28,7 +29,6 @@ import forestry.core.commands.CommandHelpers;
 import forestry.core.commands.SpeciesNotFoundException;
 import forestry.core.commands.SubCommand;
 import forestry.core.commands.TemplateNotFoundException;
-import forestry.plugins.PluginApiculture;
 
 public class CommandBeeGive extends SubCommand {
 
@@ -39,7 +39,7 @@ public class CommandBeeGive extends SubCommand {
 		super("give");
 		setPermLevel(PermLevel.ADMIN);
 
-		List<String> beeTypeStrings = new ArrayList<String>();
+		List<String> beeTypeStrings = new ArrayList<>();
 		for (EnumBeeType type : EnumBeeType.values()) {
 			if (type == EnumBeeType.NONE) {
 				continue;
@@ -87,13 +87,13 @@ public class CommandBeeGive extends SubCommand {
 			return;
 		}
 
-		IBee bee = PluginApiculture.beeInterface.getBee(player.worldObj, beeGenome);
+		IBee bee = BeeManager.beeRoot.getBee(player.worldObj, beeGenome);
 
 		if (beeType == EnumBeeType.QUEEN) {
 			bee.mate(bee);
 		}
 
-		ItemStack beeStack = PluginApiculture.beeInterface.getMemberStack(bee, beeType.ordinal());
+		ItemStack beeStack = BeeManager.beeRoot.getMemberStack(bee, beeType.ordinal());
 		player.dropPlayerItemWithRandomChoice(beeStack, true);
 
 		CommandHelpers.sendLocalizedChatMessage(sender, "for.chat.command.forestry.bee.give.given", player.getCommandSenderName(), bee.getGenome().getPrimary().getName(), beeType.getName());
@@ -127,13 +127,13 @@ public class CommandBeeGive extends SubCommand {
 			throw new SpeciesNotFoundException(speciesName);
 		}
 
-		IAllele[] template = PluginApiculture.beeInterface.getTemplate(species.getUID());
+		IAllele[] template = BeeManager.beeRoot.getTemplate(species.getUID());
 
 		if (template == null) {
 			throw new TemplateNotFoundException(species);
 		}
 
-		return PluginApiculture.beeInterface.templateAsGenome(template);
+		return BeeManager.beeRoot.templateAsGenome(template);
 	}
 
 	@Override
@@ -150,8 +150,8 @@ public class CommandBeeGive extends SubCommand {
 		return null;
 	}
 
-	String[] getSpecies() {
-		List<String> species = new ArrayList<String>();
+	private static String[] getSpecies() {
+		List<String> species = new ArrayList<>();
 
 		for (IAllele allele : AlleleManager.alleleRegistry.getRegisteredAlleles().values()) {
 			if (allele instanceof IAlleleBeeSpecies) {
@@ -162,7 +162,7 @@ public class CommandBeeGive extends SubCommand {
 		return species.toArray(new String[species.size()]);
 	}
 
-	EnumBeeType getBeeType(String beeTypeName) {
+	private static EnumBeeType getBeeType(String beeTypeName) {
 		for (EnumBeeType beeType : EnumBeeType.values()) {
 			if (beeType.getName().equalsIgnoreCase(beeTypeName)) {
 				return beeType;

src/main/java/forestry/apiculture/entities/AIAvoidPlayers.java

@@ -8,7 +8,7 @@
  * Various Contributors including, but not limited to:
  * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
  ******************************************************************************/
-package forestry.apiculture.genetics;
+package forestry.apiculture.entities;
 
 import net.minecraft.entity.EntityCreature;
 import net.minecraft.entity.ai.EntityAIBase;

src/main/java/forestry/apiculture/entities/EntityBee.java

@@ -18,20 +18,20 @@ import net.minecraft.world.World;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
+import forestry.api.apiculture.BeeManager;
 import forestry.api.apiculture.EnumBeeType;
 import forestry.api.apiculture.IAlleleBeeSpecies;
 import forestry.api.apiculture.IBee;
-import forestry.core.config.Defaults;
-import forestry.core.utils.ForestryResource;
-import forestry.plugins.PluginApiculture;
+import forestry.core.config.Constants;
+import forestry.core.render.ForestryResource;
 
 public class EntityBee extends EntityCreature implements IAnimals {
 
-	private static final String DEFAULT_TEXTURE = Defaults.TEXTURE_PATH_ENTITIES + "/bees/honeyBee.png";
+	private static final String DEFAULT_TEXTURE = Constants.TEXTURE_PATH_ENTITIES + "/bees/honeyBee.png";
 
-	IBee contained;
-	IAlleleBeeSpecies species;
-	EnumBeeType type = EnumBeeType.DRONE;
+	private IBee contained;
+	private IAlleleBeeSpecies species;
+	private EnumBeeType type = EnumBeeType.DRONE;
 
 	private String beeTexture = DEFAULT_TEXTURE;
 	private long lastUpdate;
@@ -48,7 +48,7 @@ public class EntityBee extends EntityCreature implements IAnimals {
 		if (bee != null) {
 			contained = bee;
 		} else {
-			contained = PluginApiculture.beeInterface.templateAsIndividual(PluginApiculture.beeInterface.getDefaultTemplate());
+			contained = BeeManager.beeRoot.templateAsIndividual(BeeManager.beeRoot.getDefaultTemplate());
 		}
 
 		//isImmuneToFire = contained.getGenome().getFireResist();

src/main/java/forestry/apiculture/entities/EntityFXBee.java

@@ -8,14 +8,14 @@
  * Various Contributors including, but not limited to:
  * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
  ******************************************************************************/
-package forestry.apiculture.render;
+package forestry.apiculture.entities;
 
 import net.minecraft.client.particle.EntityFX;
 import net.minecraft.client.renderer.Tessellator;
 import net.minecraft.world.World;
 
-public class EntityBeeFX extends EntityFX {
-	public EntityBeeFX(World world, double x, double y, double z, float motionScaleX, float motionScaleY, float motionScaleZ, int color) {
+public class EntityFXBee extends EntityFX {
+	public EntityFXBee(World world, double x, double y, double z, int color) {
 		super(world, x, y, z, 0.0D, 0.0D, 0.0D);
 
 		particleRed = (color >> 16 & 255) / 255.0F;
@@ -27,9 +27,9 @@ public class EntityBeeFX extends EntityFX {
 		this.particleMaxAge = (int) (20.0D / (Math.random() * 0.8D + 0.2D));
 		this.noClip = true;
 
-		this.motionX *= 0.119999999552965164D;
-		this.motionY *= 0.119999999552965164D;
-		this.motionZ *= 0.119999999552965164D;
+		this.motionX *= 0.1D;
+		this.motionY *= 0.015D;
+		this.motionZ *= 0.1D;
 	}
 
 	/**
@@ -41,11 +41,11 @@ public class EntityBeeFX extends EntityFX {
 		this.prevPosY = this.posY;
 		this.prevPosZ = this.posZ;
 		this.moveEntity(this.motionX, this.motionY, this.motionZ);
-		this.motionX *= 1.08D;
-		this.motionY *= 1.08D;
-		this.motionZ *= 1.08D;
+		this.motionX *= (1 + 0.2D * rand.nextFloat());
+		this.motionY = (this.motionY + 0.2 * (-0.5 + rand.nextFloat())) / 2;
+		this.motionZ *= (1 + 0.2D * rand.nextFloat());
 
-		if (this.particleMaxAge-- <= 0) {
+		if (this.particleAge++ >= this.particleMaxAge) {
 			this.setDead();
 		}
 	}

src/main/java/forestry/apiculture/entities/EntityMinecartApiary.java

@@ -0,0 +1,116 @@
+/*******************************************************************************
+ * 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 forestry.apiculture.entities;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+import forestry.api.apiculture.IBeeHousingInventory;
+import forestry.api.apiculture.IBeeListener;
+import forestry.api.apiculture.IBeeModifier;
+import forestry.api.apiculture.IHiveFrame;
+import forestry.apiculture.ApiaryBeeListener;
+import forestry.apiculture.ApiaryBeeModifier;
+import forestry.apiculture.IApiary;
+import forestry.apiculture.blocks.BlockApicultureType;
+import forestry.apiculture.gui.ContainerMinecartBeehouse;
+import forestry.apiculture.gui.GuiBeeHousing;
+import forestry.apiculture.inventory.IApiaryInventory;
+import forestry.apiculture.inventory.InventoryApiary;
+import forestry.core.config.Config;
+import forestry.core.inventory.IInventoryAdapter;
+import forestry.plugins.PluginApiculture;
+
+public class EntityMinecartApiary extends EntityMinecartBeeHousingBase implements IApiary {
+	private static final IBeeModifier beeModifier = new ApiaryBeeModifier();
+	private final IBeeListener beeListener = new ApiaryBeeListener(this);
+	private final InventoryApiary inventory = new InventoryApiary(getAccessHandler());
+
+	@SuppressWarnings("unused")
+	public EntityMinecartApiary(World world) {
+		super(world);
+	}
+
+	public EntityMinecartApiary(World world, double posX, double posY, double posZ) {
+		super(world, posX, posY, posZ);
+	}
+
+	@Override
+	public List<String> getHints() {
+		return Config.hints.get("apiary");
+	}
+
+	@Override
+	protected IInventoryAdapter getInternalInventory() {
+		return inventory;
+	}
+
+	@Override
+	public IApiaryInventory getApiaryInventory() {
+		return inventory;
+	}
+
+	@Override
+	public IBeeHousingInventory getBeeInventory() {
+		return inventory;
+	}
+
+	@Override
+	public Block func_145820_n() {
+		return PluginApiculture.blocks.apiculture;
+	}
+
+	@Override
+	public int getDisplayTileData() {
+		return BlockApicultureType.APIARY.ordinal();
+	}
+
+	@Override
+	public ItemStack getCartItem() {
+		return PluginApiculture.items.minecartBeehouse.getApiaryMinecart();
+	}
+
+	@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);
+	}
+
+	@Override
+	public Object getGui(EntityPlayer player, int data) {
+		ContainerMinecartBeehouse container = new ContainerMinecartBeehouse(player.inventory, this, true);
+		return new GuiBeeHousing<>(this, container, GuiBeeHousing.Icon.APIARY);
+	}
+
+	@Override
+	public Object getContainer(EntityPlayer player, int data) {
+		return new ContainerMinecartBeehouse(player.inventory, this, true);
+	}
+}

src/main/java/forestry/apiculture/entities/EntityMinecartBeeHousingBase.java

@@ -0,0 +1,184 @@
+/*******************************************************************************
+ * 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 forestry.apiculture.entities;
+
+import java.io.IOException;
+import java.util.Random;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.ChunkCoordinates;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.World;
+import net.minecraft.world.biome.BiomeGenBase;
+
+import com.mojang.authlib.GameProfile;
+
+import forestry.api.apiculture.BeeManager;
+import forestry.api.apiculture.IBeeHousing;
+import forestry.api.apiculture.IBeekeepingLogic;
+import forestry.api.core.EnumHumidity;
+import forestry.api.core.EnumTemperature;
+import forestry.api.core.ForestryAPI;
+import forestry.api.core.IErrorLogic;
+import forestry.apiculture.gui.IGuiBeeHousingInventory;
+import forestry.apiculture.network.packets.PacketBeeLogicEntityRequest;
+import forestry.apiculture.tiles.TileBeeHousingBase;
+import forestry.core.entities.EntityMinecartContainerForestry;
+import forestry.core.network.DataInputStreamForestry;
+import forestry.core.network.DataOutputStreamForestry;
+import forestry.core.network.IForestryPacketServer;
+import forestry.core.network.IStreamableGui;
+import forestry.core.proxy.Proxies;
+import forestry.core.tiles.IClimatised;
+
+public abstract class EntityMinecartBeeHousingBase extends EntityMinecartContainerForestry implements IBeeHousing, IGuiBeeHousingInventory, IClimatised, IStreamableGui {
+	private static final Random random = new Random();
+	private static final int beeFXInterval = 4;
+	private static final int pollenFXInterval = 50;
+
+	private final int beeFXTime = random.nextInt(beeFXInterval);
+	private final int pollenFXTime = random.nextInt(pollenFXInterval);
+
+	private final IBeekeepingLogic beeLogic = BeeManager.beeRoot.createBeekeepingLogic(this);
+	private final IErrorLogic errorLogic = ForestryAPI.errorStateRegistry.createErrorLogic();
+
+	// CLIENT
+	private int breedingProgressPercent = 0;
+	private boolean needsActiveUpdate = true;
+
+	@SuppressWarnings("unused")
+	public EntityMinecartBeeHousingBase(World world) {
+		super(world);
+	}
+
+	public EntityMinecartBeeHousingBase(World world, double posX, double posY, double posZ) {
+		super(world, posX, posY, posZ);
+	}
+
+	/* IBeeHousing */
+	@Override
+	public IBeekeepingLogic getBeekeepingLogic() {
+		return beeLogic;
+	}
+
+	@Override
+	public EnumTemperature getTemperature() {
+		return EnumTemperature.getFromBiome(getBiome(), (int) posX, (int) posY, (int) posZ);
+	}
+
+	@Override
+	public EnumHumidity getHumidity() {
+		return EnumHumidity.getFromValue(getBiome().rainfall);
+	}
+
+	@Override
+	public float getExactTemperature() {
+		return getBiome().temperature;
+	}
+
+	@Override
+	public float getExactHumidity() {
+		return getBiome().rainfall;
+	}
+
+	@Override
+	public int getBlockLightValue() {
+		return worldObj.getBlockLightValue((int) posX, (int) posY + 1, (int) posZ);
+	}
+
+	@Override
+	public boolean canBlockSeeTheSky() {
+		return worldObj.canBlockSeeTheSky((int) posX, (int) posY + 1, (int) posZ);
+	}
+
+	@Override
+	public World getWorld() {
+		return worldObj;
+	}
+
+	@Override
+	public BiomeGenBase getBiome() {
+		return worldObj.getBiomeGenForCoords((int) posX, (int) posZ);
+	}
+
+	@Override
+	public GameProfile getOwner() {
+		return getAccessHandler().getOwner();
+	}
+
+	@Override
+	public IErrorLogic getErrorLogic() {
+		return errorLogic;
+	}
+
+	@Override
+	public ChunkCoordinates getCoordinates() {
+		return new ChunkCoordinates((int) posX, (int) posY, (int) posZ);
+	}
+
+	@Override
+	public Vec3 getBeeFXCoordinates() {
+		return Vec3.createVectorHelper(posX, posY + 0.25, posZ);
+	}
+
+	@Override
+	public void writeGuiData(DataOutputStreamForestry data) throws IOException {
+		data.writeVarInt(beeLogic.getBeeProgressPercent());
+	}
+
+	@Override
+	public void readGuiData(DataInputStreamForestry data) throws IOException {
+		breedingProgressPercent = data.readVarInt();
+	}
+
+	@Override
+	public int getHealthScaled(int i) {
+		return (breedingProgressPercent * i) / 100;
+	}
+
+	@Override
+	public void onUpdate() {
+		super.onUpdate();
+		if (!worldObj.isRemote) {
+			if (beeLogic.canWork()) {
+				beeLogic.doWork();
+			}
+		} else {
+			if (needsActiveUpdate) {
+				IForestryPacketServer packet = new PacketBeeLogicEntityRequest(this);
+				Proxies.net.sendToServer(packet);
+				needsActiveUpdate = false;
+			}
+
+			if (beeLogic.canDoBeeFX()) {
+				if (worldObj.getTotalWorldTime() % beeFXInterval == beeFXTime) {
+					beeLogic.doBeeFX();
+				}
+
+				if (worldObj.getTotalWorldTime() % pollenFXInterval == pollenFXTime) {
+					TileBeeHousingBase.doPollenFX(worldObj, posX - 0.5, posY - 0.1, posZ - 0.5);
+				}
+			}
+		}
+	}
+
+	@Override
+	protected void readEntityFromNBT(NBTTagCompound nbtTagCompound) {
+		super.readEntityFromNBT(nbtTagCompound);
+		beeLogic.readFromNBT(nbtTagCompound);
+	}
+
+	@Override
+	protected void writeEntityToNBT(NBTTagCompound nbtTagCompound) {
+		super.writeEntityToNBT(nbtTagCompound);
+		beeLogic.writeToNBT(nbtTagCompound);
+	}
+}

src/main/java/forestry/apiculture/entities/EntityMinecartBeehouse.java

@@ -0,0 +1,101 @@
+/*******************************************************************************
+ * 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 forestry.apiculture.entities;
+
+import java.util.Collections;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+import forestry.api.apiculture.DefaultBeeListener;
+import forestry.api.apiculture.IBeeHousingInventory;
+import forestry.api.apiculture.IBeeListener;
+import forestry.api.apiculture.IBeeModifier;
+import forestry.apiculture.BeehouseBeeModifier;
+import forestry.apiculture.InventoryBeeHousing;
+import forestry.apiculture.blocks.BlockApicultureType;
+import forestry.apiculture.gui.ContainerMinecartBeehouse;
+import forestry.apiculture.gui.GuiBeeHousing;
+import forestry.core.config.Config;
+import forestry.core.inventory.IInventoryAdapter;
+import forestry.plugins.PluginApiculture;
+
+public class EntityMinecartBeehouse extends EntityMinecartBeeHousingBase {
+	private static final IBeeModifier beeModifier = new BeehouseBeeModifier();
+	private static final IBeeListener beeListener = new DefaultBeeListener();
+	private final InventoryBeeHousing beeInventory = new InventoryBeeHousing(9, getAccessHandler());
+
+	@SuppressWarnings("unused")
+	public EntityMinecartBeehouse(World world) {
+		super(world);
+		beeInventory.disableAutomation();
+	}
+
+	public EntityMinecartBeehouse(World world, double posX, double posY, double posZ) {
+		super(world, posX, posY, posZ);
+		beeInventory.disableAutomation();
+	}
+
+	@Override
+	public List<String> getHints() {
+		return Config.hints.get("bee.house");
+	}
+
+	@Override
+	public Block func_145820_n() {
+		return PluginApiculture.blocks.apiculture;
+	}
+
+	@Override
+	public int getDisplayTileData() {
+		return BlockApicultureType.BEEHOUSE.ordinal();
+	}
+
+	@Override
+	public ItemStack getCartItem() {
+		return PluginApiculture.items.minecartBeehouse.getBeeHouseMinecart();
+	}
+
+	/* IBeeHousing */
+	@Override
+	public Iterable<IBeeModifier> getBeeModifiers() {
+		return Collections.singleton(beeModifier);
+	}
+
+	@Override
+	public Iterable<IBeeListener> getBeeListeners() {
+		return Collections.singleton(beeListener);
+	}
+
+	@Override
+	public IBeeHousingInventory getBeeInventory() {
+		return beeInventory;
+	}
+
+	@Override
+	protected IInventoryAdapter getInternalInventory() {
+		return beeInventory;
+	}
+
+	@Override
+	public Object getGui(EntityPlayer player, int data) {
+		ContainerMinecartBeehouse container = new ContainerMinecartBeehouse(player.inventory, this, false);
+		return new GuiBeeHousing<>(this, container, GuiBeeHousing.Icon.BEE_HOUSE);
+	}
+
+	@Override
+	public Object getContainer(EntityPlayer player, int data) {
+		return new ContainerMinecartBeehouse(player.inventory, this, false);
+	}
+}

src/main/java/forestry/apiculture/flowers/Flower.java

@@ -10,6 +10,10 @@
  ******************************************************************************/
 package forestry.apiculture.flowers;
 
+import com.google.common.base.Objects;
+
+import javax.annotation.Nonnull;
+
 import net.minecraft.block.Block;
 
 import net.minecraftforge.oredict.OreDictionary;
@@ -44,10 +48,15 @@ final class Flower implements IFlower {
 	}
 
 	@Override
-	public int compareTo(IFlower other) {
+	public int compareTo(@Nonnull IFlower other) {
 		return this.weight.compareTo(other.getWeight());
 	}
 
+	@Override
+	public int hashCode() {
+		return Objects.hashCode(block);
+	}
+
 	@Override
 	public Block getBlock() {
 		return block;
@@ -67,4 +76,10 @@ final class Flower implements IFlower {
 	public void setWeight(double weight) {
 		this.weight = weight;
 	}
+
+	@Override
+	public String toString() {
+		return Objects.toStringHelper(this).add("block", block).add("meta", meta).add("weight", weight).toString();
+	}
+
 }

src/main/java/forestry/apiculture/flowers/FlowerProvider.java

@@ -11,7 +11,7 @@
 package forestry.apiculture.flowers;
 
 import java.util.EnumSet;
-import java.util.List;
+import java.util.Set;
 
 import net.minecraft.item.ItemStack;
 import net.minecraft.world.World;
@@ -36,8 +36,8 @@ public class FlowerProvider implements IFlowerProvider {
 	}
 
 	@Override
-	public boolean isAcceptedFlower(World world, IIndividual individual, int x, int y, int z) {
-		return FlowerManager.flowerRegistry.isAcceptedFlower(this.flowerType, world, individual, x, y, z);
+	public String getFlowerType() {
+		return flowerType;
 	}
 
 	@Override
@@ -45,12 +45,13 @@ public class FlowerProvider implements IFlowerProvider {
 
 		EnumSet<EnumPlantType> plantTypes = pollinatable.getPlantType();
 
-		if (flowerType.equals(FlowerManager.FlowerTypeNether)) {
-			return plantTypes.contains(EnumPlantType.Nether);
-		} else if (flowerType.equals(FlowerManager.FlowerTypeCacti)) {
-			return plantTypes.contains(EnumPlantType.Desert);
-		} else {
-			return plantTypes.size() > 1 || !plantTypes.contains(EnumPlantType.Nether);
+		switch (flowerType) {
+			case FlowerManager.FlowerTypeNether:
+				return plantTypes.contains(EnumPlantType.Nether);
+			case FlowerManager.FlowerTypeCacti:
+				return plantTypes.contains(EnumPlantType.Desert);
+			default:
+				return plantTypes.size() > 1 || !plantTypes.contains(EnumPlantType.Nether);
 		}
 	}
 
@@ -70,7 +71,7 @@ public class FlowerProvider implements IFlowerProvider {
 	}
 
 	@Override
-	public List<IFlower> getFlowers() {
+	public Set<IFlower> getFlowers() {
 		return FlowerManager.flowerRegistry.getAcceptableFlowers(this.flowerType);
 	}
 

src/main/java/forestry/apiculture/flowers/FlowerRegistry.java

@@ -11,46 +11,80 @@
 package forestry.apiculture.flowers;
 
 import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
 
-import java.util.Collections;
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import java.util.Random;
+import java.util.Set;
 import java.util.TreeMap;
 
 import net.minecraft.block.Block;
+import net.minecraft.block.BlockFlowerPot;
 import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.tileentity.TileEntityFlowerPot;
+import net.minecraft.util.ChunkCoordinates;
 import net.minecraft.world.World;
 
+import net.minecraftforge.common.IPlantable;
 import net.minecraftforge.oredict.OreDictionary;
 
+import cpw.mods.fml.common.registry.GameRegistry;
+
+import forestry.api.apiculture.BeeManager;
 import forestry.api.apiculture.FlowerManager;
+import forestry.api.apiculture.IBee;
+import forestry.api.apiculture.IBeeGenome;
+import forestry.api.apiculture.IBeeHousing;
+import forestry.api.apiculture.IBeeModifier;
 import forestry.api.genetics.IFlower;
+import forestry.api.genetics.IFlowerAcceptableRule;
+import forestry.api.genetics.IFlowerGrowthHelper;
 import forestry.api.genetics.IFlowerGrowthRule;
 import forestry.api.genetics.IFlowerRegistry;
 import forestry.api.genetics.IIndividual;
+import forestry.core.config.Constants;
+import forestry.core.utils.Log;
+import forestry.core.utils.vect.MutableVect;
+import forestry.core.utils.vect.Vect;
+import forestry.plugins.PluginManager;
 
-public final class FlowerRegistry implements IFlowerRegistry {
+public final class FlowerRegistry implements IFlowerRegistry, IFlowerGrowthHelper {
+
+	private final Set<String> defaultFlowerTypes = ImmutableSet.of(
+			FlowerManager.FlowerTypeVanilla,
+			FlowerManager.FlowerTypeNether,
+			FlowerManager.FlowerTypeCacti,
+			FlowerManager.FlowerTypeMushrooms,
+			FlowerManager.FlowerTypeEnd,
+			FlowerManager.FlowerTypeJungle,
+			FlowerManager.FlowerTypeSnow,
+			FlowerManager.FlowerTypeWheat,
+			FlowerManager.FlowerTypeGourd
+	);
+
+	private final HashMultimap<String, IFlowerAcceptableRule> registeredRules; // custom check
+	private final HashMultimap<String, Block> registeredBlocks; // quick first check
+	private final HashMultimap<String, Flower> registeredFlowers; // full check
 
-	private final ArrayListMultimap<String, IFlower> registeredFlowers;
 	private final ArrayListMultimap<String, IFlowerGrowthRule> growthRules;
-	private final Map<String, TreeMap<Double, IFlower>> chances;
-
-	private boolean hasDeprecatedFlowersImported;
+	private final Map<String, TreeMap<Double, Flower>> chances;
 
 	public FlowerRegistry() {
-		this.registeredFlowers = ArrayListMultimap.create();
+		this.registeredRules = HashMultimap.create();
+		this.registeredBlocks = HashMultimap.create();
+		this.registeredFlowers = HashMultimap.create();
 		this.growthRules = ArrayListMultimap.create();
-		this.chances = new HashMap<String, TreeMap<Double, IFlower>>();
+		this.chances = new HashMap<>();
 
-		this.hasDeprecatedFlowersImported = false;
-
-		registerVanillaFlowers();
 		registerVanillaGrowthRules();
 	}
 
@@ -64,6 +98,17 @@ public final class FlowerRegistry implements IFlowerRegistry {
 		registerFlower(block, meta, 0.0, flowerTypes);
 	}
 
+	@Override
+	public void registerAcceptableFlowerRule(IFlowerAcceptableRule acceptableFlower, String... flowerTypes) {
+		for (String flowerType : flowerTypes) {
+			if (defaultFlowerTypes.contains(flowerType)) {
+				Log.severe("IFlowerAcceptableRules are too slow to be applied to Forestry's built-in flower type: " + flowerType + ".");
+			} else {
+				registeredRules.put(flowerType, acceptableFlower);
+			}
+		}
+	}
+
 	@Override
 	public void registerPlantableFlower(Block block, int meta, double weight, String... flowerTypes) {
 		registerFlower(block, meta, weight, flowerTypes);
@@ -81,65 +126,141 @@ public final class FlowerRegistry implements IFlowerRegistry {
 		}
 
 		Flower newFlower = new Flower(block, meta, weight);
-		Integer index;
-		
-		for (String flowerType : flowerTypes) {
-			List<IFlower> flowers = this.registeredFlowers.get(flowerType);
 
-			index = flowers.indexOf(newFlower);
-			if (index == -1) {
-				flowers.add(newFlower);
-			} else if (flowers.get(index).getWeight() > newFlower.getWeight()) {
-				flowers.get(index).setWeight(newFlower.getWeight());
+		for (String flowerType : flowerTypes) {
+			if (flowerType == null) {
+				throw new NullPointerException("Tried to register flower with null type. " + block);
 			}
 
+			Set<Flower> flowers = this.registeredFlowers.get(flowerType);
+			flowers.add(newFlower);
+
+			Set<Block> blocks = this.registeredBlocks.get(flowerType);
+			blocks.add(block);
+
 			if (this.chances.containsKey(flowerType)) {
 				this.chances.remove(flowerType);
 			}
-
-			Collections.sort(this.registeredFlowers.get(flowerType));
 		}
 	}
 
+	private static Vect getArea(IBeeGenome genome, IBeeModifier beeModifier) {
+		int[] genomeTerritory = genome.getTerritory();
+		float housingModifier = beeModifier.getTerritoryModifier(genome, 1f);
+		return new Vect(genomeTerritory).multiply(housingModifier * 3.0f);
+	}
+
 	@Override
-	public boolean isAcceptedFlower(String flowerType, World world, IIndividual individual, int x, int y, int z) {
-		internalInitialize();
+	public ChunkCoordinates getAcceptedFlowerCoordinates(IBeeHousing beeHousing, IBee bee, String flowerType) {
+		if (!this.registeredFlowers.containsKey(flowerType)) {
+			return null;
+		}
+
+		Set<IFlowerAcceptableRule> acceptableRules = this.registeredRules.get(flowerType);
+		Set<Block> acceptedBlocks = this.registeredBlocks.get(flowerType);
+		Set<Flower> acceptedFlowers = this.registeredFlowers.get(flowerType);
+		World world = beeHousing.getWorld();
+
+		IBeeModifier beeModifier = BeeManager.beeRoot.createBeeHousingModifier(beeHousing);
+
+		Vect area = getArea(bee.getGenome(), beeModifier);
+		Vect housingPos = new Vect(beeHousing.getCoordinates()).add(-area.x / 2, -area.y / 2, -area.z / 2);
+
+		MutableVect posCurrent = new MutableVect(0, 0, 0);
+		while (posCurrent.advancePositionInArea(area)) {
+
+			Vect posBlock = Vect.add(housingPos, posCurrent);
+
+			for (IFlowerAcceptableRule acceptableRule : acceptableRules) {
+				if (acceptableRule.isAcceptableFlower(flowerType, world, posBlock.x, posBlock.y, posBlock.z)) {
+					return new ChunkCoordinates(posBlock.x, posBlock.y, posBlock.z);
+				}
+			}
+
+			if (isAcceptedFlower(flowerType, acceptedBlocks, acceptedFlowers, world, posBlock.x, posBlock.y, posBlock.z)) {
+				return new ChunkCoordinates(posBlock.x, posBlock.y, posBlock.z);
+			}
+		}
+
+		return null;
+	}
+
+	@Override
+	public boolean isAcceptedFlower(String flowerType, World world, int x, int y, int z) {
 		if (!this.registeredFlowers.containsKey(flowerType)) {
 			return false;
 		}
 
-		Block block = world.getBlock(x, y, z);
-
-		if (block.isAir(world, x, y, z) || block.equals(Blocks.bedrock) || block.equals(Blocks.dirt) || block.equals(Blocks.grass)) {
-			return false;
+		Set<IFlowerAcceptableRule> acceptedCustom = this.registeredRules.get(flowerType);
+		for (IFlowerAcceptableRule acceptableFlower : acceptedCustom) {
+			if (acceptableFlower.isAcceptableFlower(flowerType, world, x, y, z)) {
+				return true;
+			}
 		}
 
-		int meta;
+		Set<Block> acceptedBlocks = this.registeredBlocks.get(flowerType);
+		Set<Flower> acceptedFlowers = this.registeredFlowers.get(flowerType);
 
-		TileEntity tile = world.getTileEntity(x, y, z);
-		if (tile instanceof TileEntityFlowerPot) {
+		return isAcceptedFlower(flowerType, acceptedBlocks, acceptedFlowers, world, x, y, z);
+	}
+
+	private static boolean isAcceptedFlower(String flowerType, Set<Block> acceptedBlocks, Set<Flower> acceptedFlowers, World world, int x, int y, int z) {
+		Block block = world.getBlock(x, y, z);
+
+		final int meta;
+
+		if (block instanceof BlockFlowerPot) {
+			TileEntity tile = world.getTileEntity(x, y, z);
 			TileEntityFlowerPot tileFlowerPot = (TileEntityFlowerPot) tile;
 			Item item = tileFlowerPot.getFlowerPotItem();
 			block = Block.getBlockFromItem(item);
 			meta = tileFlowerPot.getFlowerPotData();
 		} else {
+			if (!acceptedBlocks.contains(block)) {
+				return false;
+			}
 			meta = world.getBlockMetadata(x, y, z);
 		}
 
+		if (PluginManager.Module.AGRICRAFT.isEnabled()) {
+			Block cropBlock = GameRegistry.findBlock("AgriCraft", "crops");
+			if (block == cropBlock) {
+				if(block instanceof IPlantable) {
+					//For agricraft versions which implement IPlantable in the BlockCrop class
+					block = ((IPlantable) block).getPlant(world, x, y, z);
+				} else {
+					//For earlier versions of AgriCraft
+					ArrayList<ItemStack> drops = block.getDrops(world, x, y, z, 7, 0);
+					if (drops.get(1).getItem() == Items.wheat_seeds && flowerType.equals(FlowerManager.FlowerTypeWheat)) {
+						return true;
+					}
+					if (drops.get(1).getItem() == Items.nether_wart && flowerType.equals(FlowerManager.FlowerTypeNether)) {
+						return true;
+					}
+				}
+			}
+		}
+
 		Flower flower = new Flower(block, meta, 0);
-		List<IFlower> acceptedFlowers = this.registeredFlowers.get(flowerType);
 		return acceptedFlowers.contains(flower);
 	}
 
 	@Override
 	public boolean growFlower(String flowerType, World world, IIndividual individual, int x, int y, int z) {
-		internalInitialize();
 		if (!this.growthRules.containsKey(flowerType)) {
 			return false;
 		}
 
 		for (IFlowerGrowthRule rule : this.growthRules.get(flowerType)) {
-			if (rule.growFlower(this, flowerType, world, individual, x, y, z)) {
+			boolean success;
+			try {
+				success = rule.growFlower(this, flowerType, world, x, y, z);
+			} catch (Throwable ignored) {
+				// legacy method
+				success = rule.growFlower(this, flowerType, world, individual, x, y, z);
+			}
+
+			if (success) {
 				return true;
 			}
 		}
@@ -148,10 +269,8 @@ public final class FlowerRegistry implements IFlowerRegistry {
 	}
 
 	@Override
-	public List<IFlower> getAcceptableFlowers(String flowerType) {
-		internalInitialize();
-
-		return this.registeredFlowers.get(flowerType);
+	public Set<IFlower> getAcceptableFlowers(String flowerType) {
+		return ImmutableSet.<IFlower>copyOf(this.registeredFlowers.get(flowerType));
 	}
 
 	@Override
@@ -167,16 +286,21 @@ public final class FlowerRegistry implements IFlowerRegistry {
 
 	@Override
 	public IFlower getRandomPlantableFlower(String flowerType, Random rand) {
-		TreeMap<Double, IFlower> chancesMap = getChancesMap(flowerType);
+		TreeMap<Double, Flower> chancesMap = getChancesMap(flowerType);
 		double maxKey = chancesMap.lastKey() + 1.0;
 		return chancesMap.get(chancesMap.lowerKey(rand.nextDouble() * maxKey));
 	}
 
-	private TreeMap<Double, IFlower> getChancesMap(String flowerType) {
+	@Override
+	public Collection<String> getFlowerTypes() {
+		return new ArrayList<>(Sets.union(defaultFlowerTypes, registeredFlowers.keySet()));
+	}
+
+	private TreeMap<Double, Flower> getChancesMap(String flowerType) {
 		if (!this.chances.containsKey(flowerType)) {
-			TreeMap<Double, IFlower> flowerChances = new TreeMap<Double, IFlower>();
+			TreeMap<Double, Flower> flowerChances = new TreeMap<>();
 			double count = 0.0;
-			for (IFlower flower : this.registeredFlowers.get(flowerType)) {
+			for (Flower flower : this.registeredFlowers.get(flowerType)) {
 				if (flower.isPlantable()) {
 					flowerChances.put(count, flower);
 					count += flower.getWeight();
@@ -187,62 +311,20 @@ public final class FlowerRegistry implements IFlowerRegistry {
 		return this.chances.get(flowerType);
 	}
 
-	/*
-	 * Method to support deprecated FlowerManager.plainFlowers
-	 */
-	@SuppressWarnings("deprecation")
-	private void internalInitialize() {
-		if (!hasDeprecatedFlowersImported) {
-			for (ItemStack plainFlower : FlowerManager.plainFlowers) {
-				Block flowerBlock = Block.getBlockFromItem(plainFlower.getItem());
-				int meta = plainFlower.getItemDamage();
-				registerPlantableFlower(flowerBlock, meta, 1.0, FlowerManager.FlowerTypeVanilla, FlowerManager.FlowerTypeSnow);
-			}
-
-			hasDeprecatedFlowersImported = true;
-		}
-	}
-
-	private void registerVanillaFlowers() {
-		// Register plantable plants
-		for (int meta = 0; meta <= 8; meta++) {
-			registerPlantableFlower(Blocks.red_flower, meta, 1.0, FlowerManager.FlowerTypeVanilla, FlowerManager.FlowerTypeSnow);
-		}
-
-		registerPlantableFlower(Blocks.yellow_flower, 0, 1.0, FlowerManager.FlowerTypeVanilla, FlowerManager.FlowerTypeSnow);
-		registerPlantableFlower(Blocks.brown_mushroom, 0, 1.0, FlowerManager.FlowerTypeMushrooms);
-		registerPlantableFlower(Blocks.red_mushroom, 0, 1.0, FlowerManager.FlowerTypeMushrooms);
-		registerPlantableFlower(Blocks.cactus, 0, 1.0, FlowerManager.FlowerTypeCacti);
-
-		// Register acceptable plants
-		registerAcceptableFlower(Blocks.red_flower, FlowerManager.FlowerTypeVanilla, FlowerManager.FlowerTypeSnow);
-		registerAcceptableFlower(Blocks.yellow_flower, FlowerManager.FlowerTypeVanilla, FlowerManager.FlowerTypeSnow);
-		registerAcceptableFlower(Blocks.brown_mushroom, FlowerManager.FlowerTypeMushrooms);
-		registerAcceptableFlower(Blocks.red_mushroom, FlowerManager.FlowerTypeMushrooms);
-		registerAcceptableFlower(Blocks.cactus, FlowerManager.FlowerTypeCacti);
-
-		registerAcceptableFlower(Blocks.dragon_egg, FlowerManager.FlowerTypeEnd);
-		registerAcceptableFlower(Blocks.vine, FlowerManager.FlowerTypeJungle);
-		registerAcceptableFlower(Blocks.tallgrass, FlowerManager.FlowerTypeJungle);
-		registerAcceptableFlower(Blocks.wheat, FlowerManager.FlowerTypeWheat);
-		registerAcceptableFlower(Blocks.pumpkin_stem, FlowerManager.FlowerTypeGourd);
-		registerAcceptableFlower(Blocks.melon_stem, FlowerManager.FlowerTypeGourd);
-		registerAcceptableFlower(Blocks.nether_wart, FlowerManager.FlowerTypeNether);
-
-		registerAcceptableFlower(Blocks.double_plant, 0, FlowerManager.FlowerTypeVanilla, FlowerManager.FlowerTypeSnow);
-		registerAcceptableFlower(Blocks.double_plant, 1, FlowerManager.FlowerTypeVanilla, FlowerManager.FlowerTypeSnow);
-		registerAcceptableFlower(Blocks.double_plant, 4, FlowerManager.FlowerTypeVanilla, FlowerManager.FlowerTypeSnow);
-		registerAcceptableFlower(Blocks.double_plant, 5, FlowerManager.FlowerTypeVanilla, FlowerManager.FlowerTypeSnow);
-	}
-
 	private void registerVanillaGrowthRules() {
-		registerGrowthRule(new VanillaDirtGrassGrowthRule(), FlowerManager.FlowerTypeVanilla, FlowerManager.FlowerTypeSnow);
-		registerGrowthRule(new VanillaSnowGrowthRule(), FlowerManager.FlowerTypeSnow);
-		registerGrowthRule(new VanillaFlowerPotGrowthRule(), FlowerManager.FlowerTypeVanilla, FlowerManager.FlowerTypeSnow, FlowerManager.FlowerTypeMushrooms, FlowerManager.FlowerTypeCacti,
+		registerGrowthRule(new GrowthRuleDirtGrass(), FlowerManager.FlowerTypeVanilla, FlowerManager.FlowerTypeSnow);
+		registerGrowthRule(new GrowthRuleSnow(), FlowerManager.FlowerTypeSnow);
+		registerGrowthRule(new GrowthRuleFlowerPot(), FlowerManager.FlowerTypeVanilla, FlowerManager.FlowerTypeSnow, FlowerManager.FlowerTypeMushrooms, FlowerManager.FlowerTypeCacti,
 				FlowerManager.FlowerTypeJungle);
-		registerGrowthRule(new VanillaMyceliumGrowthRule(), FlowerManager.FlowerTypeMushrooms);
-		registerGrowthRule(new VanillaDefaultGrowthRule(), FlowerManager.FlowerTypeEnd);
-		registerGrowthRule(new VanillaFertilizeGrowthRule(Blocks.melon_stem, Blocks.pumpkin_stem), FlowerManager.FlowerTypeGourd);
-		registerGrowthRule(new VanillaFertilizeGrowthRule(Blocks.wheat), FlowerManager.FlowerTypeWheat);
+		registerGrowthRule(new GrowthRuleMycelium(), FlowerManager.FlowerTypeMushrooms);
+		registerGrowthRule(new GrowthRuleNone(), FlowerManager.FlowerTypeEnd);
+		registerGrowthRule(new GrowthRuleFertilize(Blocks.melon_stem, Blocks.pumpkin_stem), FlowerManager.FlowerTypeGourd);
+		registerGrowthRule(new GrowthRuleFertilize(Blocks.wheat), FlowerManager.FlowerTypeWheat);
+	}
+
+	@Override
+	public boolean plantRandomFlower(String flowerType, World world, int x, int y, int z) {
+		IFlower flower = getRandomPlantableFlower(flowerType, world.rand);
+		return world.setBlock(x, y, z, flower.getBlock(), flower.getMeta(), Constants.FLAG_BLOCK_SYNCH);
 	}
 }

src/main/java/forestry/apiculture/flowers/GrowthRuleDirtGrass.java

@@ -15,12 +15,13 @@ import net.minecraft.init.Blocks;
 import net.minecraft.world.World;
 
 import forestry.api.genetics.IFlower;
+import forestry.api.genetics.IFlowerGrowthHelper;
 import forestry.api.genetics.IFlowerGrowthRule;
 import forestry.api.genetics.IFlowerRegistry;
 import forestry.api.genetics.IIndividual;
-import forestry.core.config.Defaults;
+import forestry.core.config.Constants;
 
-public class VanillaDirtGrassGrowthRule implements IFlowerGrowthRule {
+public class GrowthRuleDirtGrass implements IFlowerGrowthRule {
 
 	@Override
 	public boolean growFlower(IFlowerRegistry flowerRegistry, String flowerType, World world, IIndividual individual, int x, int y, int z) {
@@ -34,7 +35,21 @@ public class VanillaDirtGrassGrowthRule implements IFlowerGrowthRule {
 		}
 
 		IFlower flower = flowerRegistry.getRandomPlantableFlower(flowerType, world.rand);
-		return world.setBlock(x, y, z, flower.getBlock(), flower.getMeta(), Defaults.FLAG_BLOCK_SYNCH);
+		return world.setBlock(x, y, z, flower.getBlock(), flower.getMeta(), Constants.FLAG_BLOCK_SYNCH);
+	}
+
+	@Override
+	public boolean growFlower(IFlowerGrowthHelper helper, String flowerType, World world, int x, int y, int z) {
+		if (!world.isAirBlock(x, y, z)) {
+			return false;
+		}
+
+		Block ground = world.getBlock(x, y - 1, z);
+		if (ground != Blocks.dirt && ground != Blocks.grass) {
+			return false;
+		}
+
+		return helper.plantRandomFlower(flowerType, world, x, y, z);
 	}
 
 }

src/main/java/forestry/apiculture/flowers/GrowthRuleFertilize.java

@@ -16,20 +16,30 @@ import java.util.List;
 import net.minecraft.block.Block;
 import net.minecraft.world.World;
 
+import forestry.api.genetics.IFlowerGrowthHelper;
 import forestry.api.genetics.IFlowerGrowthRule;
 import forestry.api.genetics.IFlowerRegistry;
 import forestry.api.genetics.IIndividual;
 
-public class VanillaFertilizeGrowthRule implements IFlowerGrowthRule {
+public class GrowthRuleFertilize implements IFlowerGrowthRule {
 
 	private final List<Block> allowedItems;
 
-	public VanillaFertilizeGrowthRule(Block... allowedItems) {
+	public GrowthRuleFertilize(Block... allowedItems) {
 		this.allowedItems = Arrays.asList(allowedItems);
 	}
 
 	@Override
 	public boolean growFlower(IFlowerRegistry fr, String flowerType, World world, IIndividual individual, int x, int y, int z) {
+		return growFlower(world, x, y, z);
+	}
+
+	@Override
+	public boolean growFlower(IFlowerGrowthHelper helper, String flowerType, World world, int x, int y, int z) {
+		return growFlower(world, x, y, z);
+	}
+
+	private boolean growFlower(World world, int x, int y, int z) {
 		Block ground = world.getBlock(x, y, z);
 		int groundMeta;
 		for (Block b : this.allowedItems) {

src/main/java/forestry/apiculture/flowers/GrowthRuleFlowerPot.java

@@ -17,15 +17,24 @@ import net.minecraft.tileentity.TileEntityFlowerPot;
 import net.minecraft.world.World;
 
 import forestry.api.apiculture.FlowerManager;
+import forestry.api.genetics.IFlowerGrowthHelper;
 import forestry.api.genetics.IFlowerGrowthRule;
 import forestry.api.genetics.IFlowerRegistry;
 import forestry.api.genetics.IIndividual;
 
-public class VanillaFlowerPotGrowthRule implements IFlowerGrowthRule {
+public class GrowthRuleFlowerPot implements IFlowerGrowthRule {
 
 	@Override
 	public boolean growFlower(IFlowerRegistry fr, String flowerType, World world, IIndividual individual, int x, int y, int z) {
+		return growFlower(flowerType, world, x, y, z);
+	}
 
+	@Override
+	public boolean growFlower(IFlowerGrowthHelper helper, String flowerType, World world, int x, int y, int z) {
+		return growFlower(flowerType, world, x, y, z);
+	}
+
+	private static boolean growFlower(String flowerType, World world, int x, int y, int z) {
 		TileEntity tile = world.getTileEntity(x, y, z);
 		if (!(tile instanceof TileEntityFlowerPot)) {
 			return false;
@@ -44,16 +53,22 @@ public class VanillaFlowerPotGrowthRule implements IFlowerGrowthRule {
 		BlockFlowerPot flowerPot = (BlockFlowerPot) block;
 
 		int flower;
-		if (flowerType.equals(FlowerManager.FlowerTypeVanilla) || flowerType.equals(FlowerManager.FlowerTypeSnow)) {
-			flower = world.rand.nextInt(2) + 1;
-		} else if (flowerType.equals(FlowerManager.FlowerTypeJungle)) {
-			flower = 6;
-		} else if (flowerType.equals(FlowerManager.FlowerTypeCacti)) {
-			flower = world.rand.nextInt(2) + 9;
-		} else if (flowerType.equals(FlowerManager.FlowerTypeMushrooms)) {
-			flower = world.rand.nextInt(2) + 7;
-		} else {
-			return false;
+		switch (flowerType) {
+			case FlowerManager.FlowerTypeVanilla:
+			case FlowerManager.FlowerTypeSnow:
+				flower = world.rand.nextInt(2) + 1;
+				break;
+			case FlowerManager.FlowerTypeJungle:
+				flower = 6;
+				break;
+			case FlowerManager.FlowerTypeCacti:
+				flower = world.rand.nextInt(2) + 9;
+				break;
+			case FlowerManager.FlowerTypeMushrooms:
+				flower = world.rand.nextInt(2) + 7;
+				break;
+			default:
+				return false;
 		}
 
 		TileEntityFlowerPot newTile = (TileEntityFlowerPot) flowerPot.createNewTileEntity(world, flower);

src/main/java/forestry/apiculture/flowers/GrowthRuleMycelium.java

@@ -15,12 +15,13 @@ import net.minecraft.init.Blocks;
 import net.minecraft.world.World;
 
 import forestry.api.genetics.IFlower;
+import forestry.api.genetics.IFlowerGrowthHelper;
 import forestry.api.genetics.IFlowerGrowthRule;
 import forestry.api.genetics.IFlowerRegistry;
 import forestry.api.genetics.IIndividual;
-import forestry.core.config.Defaults;
+import forestry.core.config.Constants;
 
-public class VanillaMyceliumGrowthRule implements IFlowerGrowthRule {
+public class GrowthRuleMycelium implements IFlowerGrowthRule {
 
 	@Override
 	public boolean growFlower(IFlowerRegistry fr, String flowerType, World world, IIndividual individual, int x, int y, int z) {
@@ -34,7 +35,21 @@ public class VanillaMyceliumGrowthRule implements IFlowerGrowthRule {
 		}
 
 		IFlower flower = fr.getRandomPlantableFlower(flowerType, world.rand);
-		return world.setBlock(x, y, z, flower.getBlock(), flower.getMeta(), Defaults.FLAG_BLOCK_SYNCH);
+		return world.setBlock(x, y, z, flower.getBlock(), flower.getMeta(), Constants.FLAG_BLOCK_SYNCH);
+	}
+
+	@Override
+	public boolean growFlower(IFlowerGrowthHelper helper, String flowerType, World world, int x, int y, int z) {
+		if (!world.isAirBlock(x, y, z)) {
+			return false;
+		}
+
+		Block ground = world.getBlock(x, y - 1, z);
+		if (ground != Blocks.mycelium) {
+			return false;
+		}
+
+		return helper.plantRandomFlower(flowerType, world, x, y, z);
 	}
 
 }

src/main/java/forestry/apiculture/flowers/GrowthRuleNone.java

@@ -12,15 +12,21 @@ package forestry.apiculture.flowers;
 
 import net.minecraft.world.World;
 
+import forestry.api.genetics.IFlowerGrowthHelper;
 import forestry.api.genetics.IFlowerGrowthRule;
 import forestry.api.genetics.IFlowerRegistry;
 import forestry.api.genetics.IIndividual;
 
-public class VanillaDefaultGrowthRule implements IFlowerGrowthRule {
+public class GrowthRuleNone implements IFlowerGrowthRule {
 
 	@Override
 	public boolean growFlower(IFlowerRegistry fr, String flowerType, World world, IIndividual individual, int x, int y, int z) {
 		return true;
 	}
 
+	@Override
+	public boolean growFlower(IFlowerGrowthHelper helper, String flowerType, World world, int x, int y, int z) {
+		return true;
+	}
+
 }

src/main/java/forestry/apiculture/flowers/GrowthRuleSnow.java

@@ -15,12 +15,13 @@ import net.minecraft.init.Blocks;
 import net.minecraft.world.World;
 
 import forestry.api.genetics.IFlower;
+import forestry.api.genetics.IFlowerGrowthHelper;
 import forestry.api.genetics.IFlowerGrowthRule;
 import forestry.api.genetics.IFlowerRegistry;
 import forestry.api.genetics.IIndividual;
-import forestry.core.config.Defaults;
+import forestry.core.config.Constants;
 
-public class VanillaSnowGrowthRule implements IFlowerGrowthRule {
+public class GrowthRuleSnow implements IFlowerGrowthRule {
 
 	@Override
 	public boolean growFlower(IFlowerRegistry fr, String flowerType, World world, IIndividual individual, int x, int y, int z) {
@@ -34,7 +35,21 @@ public class VanillaSnowGrowthRule implements IFlowerGrowthRule {
 		}
 
 		IFlower flower = fr.getRandomPlantableFlower(flowerType, world.rand);
-		return world.setBlock(x, y, z, flower.getBlock(), flower.getMeta(), Defaults.FLAG_BLOCK_SYNCH);
+		return world.setBlock(x, y, z, flower.getBlock(), flower.getMeta(), Constants.FLAG_BLOCK_SYNCH);
+	}
+
+	@Override
+	public boolean growFlower(IFlowerGrowthHelper helper, String flowerType, World world, int x, int y, int z) {
+		if (world.getBlock(x, y, z) != Blocks.snow) {
+			return false;
+		}
+
+		Block ground = world.getBlock(x, y - 1, z);
+		if (ground != Blocks.dirt && ground != Blocks.grass) {
+			return false;
+		}
+
+		return helper.plantRandomFlower(flowerType, world, x, y, z);
 	}
 
 }

src/main/java/forestry/apiculture/gadgets/BlockCandle.java

@@ -1,389 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.gadgets;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
-
-import net.minecraft.block.Block;
-import net.minecraft.block.BlockTorch;
-import net.minecraft.client.renderer.texture.IIconRegister;
-import net.minecraft.creativetab.CreativeTabs;
-import net.minecraft.entity.EntityLivingBase;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.init.Blocks;
-import net.minecraft.init.Items;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.tileentity.TileEntity;
-import net.minecraft.util.IIcon;
-import net.minecraft.world.IBlockAccess;
-import net.minecraft.world.World;
-
-import net.minecraftforge.common.util.ForgeDirection;
-import net.minecraftforge.oredict.OreDictionary;
-
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
-
-import forestry.api.core.Tabs;
-import forestry.core.ForestryClient;
-import forestry.core.config.Defaults;
-import forestry.core.render.TextureManager;
-import forestry.core.utils.StackUtils;
-import forestry.core.utils.StringUtil;
-
-public class BlockCandle extends BlockTorch {
-
-	private final ArrayList<Item> lightingItems = new ArrayList<Item>();
-
-	@SideOnly(Side.CLIENT)
-	private IIcon litStump;
-	@SideOnly(Side.CLIENT)
-	private IIcon litTip;
-	@SideOnly(Side.CLIENT)
-	private IIcon unlitStump;
-	@SideOnly(Side.CLIENT)
-	private IIcon unlitTip;
-
-	public BlockCandle() {
-		super();
-		this.setHardness(0.0F);
-		this.setStepSound(soundTypeWood);
-		setCreativeTab(Tabs.tabApiculture);
-
-		lightingItems.add(Items.flint_and_steel);
-		lightingItems.add(Items.flint);
-		lightingItems.add(Item.getItemFromBlock(Blocks.torch));
-	}
-
-	@Override
-	public boolean hasTileEntity(int metadata) {
-		return true;
-	}
-
-	@Override
-	public TileEntity createTileEntity(World world, int metadata) {
-		return new TileCandle();
-	}
-
-	@Override
-	public int getRenderType() {
-		return ForestryClient.candleRenderId;
-	}
-
-	@SideOnly(Side.CLIENT)
-	@Override
-	public void registerBlockIcons(IIconRegister register) {
-		String fileBase = StringUtil.cleanBlockName(this);
-		this.blockIcon = TextureManager.getInstance().registerTex(register, "stump");
-		this.litStump = TextureManager.getInstance().registerTex(register, fileBase + "StumpLit");
-		this.litTip = TextureManager.getInstance().registerTex(register, fileBase + "TipLit");
-		this.unlitStump = TextureManager.getInstance().registerTex(register, fileBase + "StumpUnlit");
-		this.unlitTip = TextureManager.getInstance().registerTex(register, fileBase + "TipUnlit");
-	}
-
-	@Override
-	public int getLightValue(IBlockAccess world, int x, int y, int z) {
-		int meta = world.getBlockMetadata(x, y, z);
-		return (isLit(meta)) ? 14 : 0;
-	}
-
-	/*@SideOnly(Side.CLIENT)
-	@Override
-	public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
-		IIcon i = this.unlitStump;
-		if (this.isLit(world.getBlockMetadata(x, y, z))) {
-			i = this.litStump;
-		}
-		return i;
-	}*/
-
-	@SideOnly(Side.CLIENT)
-	public IIcon getTextureFromPassAndMeta(int meta, int pass) {
-		IIcon i;
-		if (pass == 0) {
-			if (isLit(meta)) {
-				i = this.litTip;
-			} else {
-				i = this.unlitTip;
-			}
-		} else {
-			if (isLit(meta)) {
-				i = this.litStump;
-			} else {
-				i = this.unlitStump;
-			}
-		}
-		return i;
-	}
-
-	public int getColourFromItemStack(ItemStack stack) {
-		int colour = 0xffffff;
-		if (stack.hasTagCompound()) {
-			NBTTagCompound tag = stack.getTagCompound();
-			colour = (tag.getByte("red") << 16) | (tag.getByte("green") << 8) | tag.getByte("blue");
-		}
-		return colour;
-	}
-
-	@SuppressWarnings({"rawtypes", "unchecked"})
-	@Override
-	public void getSubBlocks(Item item, CreativeTabs par2CreativeTabs, List itemList) {
-		itemList.add(new ItemStack(this, 1, 0));
-	}
-
-	// Dye names correspond to colour values as below.
-	private static final String[] dyes = {"dyeWhite", "dyeOrange", "dyeMagenta", "dyeLightBlue",
-			"dyeYellow", "dyeLime", "dyePink", "dyeGray",
-			"dyeLightGray", "dyeCyan", "dyePurple", "dyeBlue",
-			"dyeBrown", "dyeGreen", "dyeRed", "dyeBlack"};
-
-	private static final int[][] colours = {{255, 255, 255}, {219, 125, 62}, {255, 20, 255}, {107, 138, 201},
-			{255, 255, 20}, {20, 255, 20}, {208, 132, 153}, {74, 74, 74},
-			{154, 161, 161}, {20, 255, 255}, {126, 61, 181}, {20, 20, 255},
-			{79, 50, 31}, {53, 70, 27}, {150, 52, 48}, {20, 20, 20}};
-
-	public static final String colourTagName = "colour";
-
-	@Override
-	public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int facing, float facingX, float facingY, float facingZ) {
-		boolean flag = false;
-		int meta = world.getBlockMetadata(x, y, z);
-		boolean toggleLitState = true;
-		ItemStack held = player.getCurrentEquippedItem();
-
-		if (!isLit(meta)) {
-			if (held == null || !lightingItems.contains(held.getItem())) {
-				toggleLitState = false;
-			} else if (StackUtils.equals(this, held) && isLit(held)) {
-				toggleLitState = true;
-			}
-		}
-
-		if (held != null) {
-			// Ensure a TileEntity exists. May be able to remove this in future versions.
-			TileCandle te = (TileCandle) world.getTileEntity(x, y, z);
-			if (te == null) {
-				world.setTileEntity(x, y, z, this.createTileEntity(world, meta));
-				te = (TileCandle) world.getTileEntity(x, y, z);
-			}
-
-			if (StackUtils.equals(this, held)) {
-				if (!isLit(held)) {
-					// Copy the colour of an unlit, coloured candle.
-					if (held.hasTagCompound() && held.getTagCompound().hasKey(colourTagName)) {
-						te.setColour(held.getTagCompound().getInteger(colourTagName));
-					} else {
-						// Reset to white if item has no
-						te.setColour(0xffffff);
-					}
-				} else {
-					toggleLitState = true;
-				}
-				flag = true;
-			} else {
-				// Check for dye-able ness.
-				boolean matched = false;
-				for (int i = 0; i < dyes.length; ++i) {
-					for (ItemStack stack : OreDictionary.getOres(dyes[i])) {
-						if (OreDictionary.itemMatches(stack, held, true)) {
-							if (isLit(meta)) {
-								te.setColour(colours[i][0], colours[i][1], colours[i][2]);
-							} else {
-								te.addColour(colours[i][0], colours[i][1], colours[i][2]);
-							}
-							world.markBlockForUpdate(x, y, z);
-							matched = true;
-							toggleLitState = false;
-							flag = true;
-							break;
-						}
-					}
-					if (matched) {
-						break;
-					}
-				}
-			}
-		}
-
-		if (toggleLitState) {
-			meta = this.toggleLitStatus(meta);
-			world.setBlockMetadataWithNotify(x, y, z, meta, Defaults.FLAG_BLOCK_SYNCH | Defaults.FLAG_BLOCK_UPDATE);
-			flag = true;
-		}
-		return flag;
-	}
-
-	@Override
-	public void breakBlock(World world, int x, int y, int z, Block block, int meta) {
-		if (!world.isRemote) {
-			TileCandle tc = (TileCandle) world.getTileEntity(x, y, z);
-			int newMeta = isLit(meta) ? 1 : 0;
-			ItemStack stack = new ItemStack(this, 1, newMeta);
-			if (tc != null && tc.getColour() != 0xffffff) {
-				// When dropped, tag new item stack with colour. Unless it's white, then do no such thing for maximum stacking.
-				NBTTagCompound tag = new NBTTagCompound();
-				tag.setInteger(colourTagName, tc.getColour());
-				stack.setTagCompound(tag);
-			}
-			this.dropBlockAsItem(world, x, y, z, stack);
-		}
-		super.breakBlock(world, x, y, z, block, meta);
-	}
-
-	@Override
-	public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase player, ItemStack itemStack) {
-		TileCandle tc = (TileCandle) (world.getTileEntity(x, y, z));
-		tc.setColour(this.getColourValueFromItemStack(itemStack));
-		if (isLit(itemStack)) {
-			int meta = world.getBlockMetadata(x, y, z);
-			world.setBlockMetadataWithNotify(x, y, z, this.toggleLitStatus(meta), Defaults.FLAG_BLOCK_SYNCH | Defaults.FLAG_BLOCK_UPDATE);
-		}
-	}
-
-	@Override
-	public void dropBlockAsItemWithChance(World par1World, int par2, int par3, int par4, int par5, float par6, int par7) {
-		// Does nothing to prevent extra candles from falling.
-	}
-
-	@Override
-	public void onBlockHarvested(World par1World, int par2, int par3, int par4, int par5, EntityPlayer par6EntityPlayer) {
-		// Does nothing to prevent extra candles from falling.
-	}
-
-	@Override
-	protected boolean func_150109_e(World world, int x, int y, int z) {
-		// Slightly tweaked version of BlockTorch's version to account for TE nonsense.
-		if (!this.canPlaceBlockAt(world, x, y, z)) {
-			if (world.getBlock(x, y, z) == this) {
-				world.setBlockToAir(x, y, z);
-			}
-			return false;
-		} else {
-			return true;
-		}
-	}
-
-	@Override
-	@SideOnly(Side.CLIENT)
-	public void randomDisplayTick(World world, int x, int y, int z, Random random) {
-		if (isLit(world.getBlockMetadata(x, y, z))) {
-			int l = world.getBlockMetadata(x, y, z) & 0x07;
-			double d0 = x + 0.5F;
-			double d1 = y + 0.7F;
-			double d2 = z + 0.5F;
-			double d3 = 0.2199999988079071D;
-			double d4 = 0.27000001072883606D;
-
-			if (l == 1) {
-				world.spawnParticle("smoke", d0 - d4, d1 + d3, d2, 0.0D, 0.0D, 0.0D);
-				world.spawnParticle("flame", d0 - d4, d1 + d3, d2, 0.0D, 0.0D, 0.0D);
-			} else if (l == 2) {
-				world.spawnParticle("smoke", d0 + d4, d1 + d3, d2, 0.0D, 0.0D, 0.0D);
-				world.spawnParticle("flame", d0 + d4, d1 + d3, d2, 0.0D, 0.0D, 0.0D);
-			} else if (l == 3) {
-				world.spawnParticle("smoke", d0, d1 + d3, d2 - d4, 0.0D, 0.0D, 0.0D);
-				world.spawnParticle("flame", d0, d1 + d3, d2 - d4, 0.0D, 0.0D, 0.0D);
-			} else if (l == 4) {
-				world.spawnParticle("smoke", d0, d1 + d3, d2 + d4, 0.0D, 0.0D, 0.0D);
-				world.spawnParticle("flame", d0, d1 + d3, d2 + d4, 0.0D, 0.0D, 0.0D);
-			} else {
-				world.spawnParticle("smoke", d0, d1, d2, 0.0D, 0.0D, 0.0D);
-				world.spawnParticle("flame", d0, d1, d2, 0.0D, 0.0D, 0.0D);
-			}
-		}
-	}
-
-	@Override
-	protected boolean func_150108_b(World par1World, int par2, int par3, int par4, Block block) {
-		if (this.func_150109_e(par1World, par2, par3, par4)) {
-			int i1 = par1World.getBlockMetadata(par2, par3, par4) & 0x07;
-			boolean flag = false;
-
-			if (!par1World.isSideSolid(par2 - 1, par3, par4, ForgeDirection.EAST, true) && i1 == 1) {
-				flag = true;
-			}
-
-			if (!par1World.isSideSolid(par2 + 1, par3, par4, ForgeDirection.WEST, true) && i1 == 2) {
-				flag = true;
-			}
-
-			if (!par1World.isSideSolid(par2, par3, par4 - 1, ForgeDirection.SOUTH, true) && i1 == 3) {
-				flag = true;
-			}
-
-			if (!par1World.isSideSolid(par2, par3, par4 + 1, ForgeDirection.NORTH, true) && i1 == 4) {
-				flag = true;
-			}
-
-			if (!this.canPlaceTorchOn(par1World, par2, par3 - 1, par4) && i1 == 5) {
-				flag = true;
-			}
-
-			if (flag) {
-				this.dropBlockAsItem(par1World, par2, par3, par4, par1World.getBlockMetadata(par2, par3, par4), 0);
-				par1World.setBlockToAir(par2, par3, par4);
-				return true;
-			} else {
-				return false;
-			}
-		} else {
-			return true;
-		}
-	}
-
-	// Yes, function hiding. Go away.
-	public boolean canPlaceTorchOn(World par1World, int par2, int par3, int par4) {
-		if (World.doesBlockHaveSolidTopSurface(par1World, par2, par3, par4)) {
-			return true;
-		} else {
-			Block block = par1World.getBlock(par2, par3, par4);
-			return block.canPlaceTorchOnTop(par1World, par2, par3, par4);
-		}
-	}
-
-	protected int getColourValueFromItemStack(ItemStack itemStack) {
-		int value = 0xffffff; // default to white.
-		if (itemStack.hasTagCompound()) {
-			NBTTagCompound tag = itemStack.getTagCompound();
-			if (tag.hasKey(colourTagName)) {
-				value = tag.getInteger(colourTagName);
-			}
-		}
-		return value;
-	}
-
-	public static boolean isLit(int meta) {
-		return (meta & 0x08) > 0;
-	}
-
-	public static boolean isLit(ItemStack itemStack) {
-		return itemStack.getItemDamage() > 0;
-	}
-
-	protected int toggleLitStatus(int meta) {
-		return meta ^ 0x08;
-	}
-
-	public void addItemToLightingList(Item item) {
-		if (item == null) {
-			throw new NullPointerException();
-		}
-
-		if (!this.lightingItems.contains(item)) {
-			this.lightingItems.add(item);
-		}
-	}
-
-}

src/main/java/forestry/apiculture/gadgets/StructureLogicAlveary.java

@@ -1,130 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.gadgets;
-
-import java.util.HashSet;
-
-import net.minecraft.block.Block;
-import net.minecraft.init.Blocks;
-import net.minecraft.tileentity.TileEntity;
-
-import forestry.api.apiculture.IAlvearyComponent;
-import forestry.api.core.ITileStructure;
-import forestry.core.config.ForestryBlock;
-import forestry.core.gadgets.BlockStructure.EnumStructureState;
-import forestry.core.gadgets.StructureLogic;
-import forestry.core.utils.Schemata;
-import forestry.core.utils.Schemata.EnumStructureBlock;
-import forestry.core.vect.Vect;
-
-public class StructureLogicAlveary extends StructureLogic {
-
-	/* CONSTANTS */
-	public static final String UID_ALVEARY = "alveary";
-	public static final Schemata SCHEMATA_ALVEARY = new Schemata("alveary3x3", 5, 6, 5, "FFFFF", "FFFFF", "FFFFF", "FFFFF", "FFFFF", "FFFFF", "FFFFF", "FAAAF",
-			"FAAAF", "FABAF", "FCCCF", "FFFFF", "FFFFF", "FAAAF", "FAAAF", "FBMBF", "FCCCF", "FFFFF", "FFFFF", "FAAAF", "FAAAF", "FABAF", "FCCCF", "FFFFF",
-			"FFFFF", "FFFFF", "FFFFF", "FFFFF", "FFFFF", "FFFFF").setOffsets(-2, -3, -2);
-
-	public static final HashSet<Block> slabBlocks = new HashSet<Block>();
-
-	static {
-		slabBlocks.add(Blocks.wooden_slab);
-		slabBlocks.add(ForestryBlock.slabs1.block());
-		slabBlocks.add(ForestryBlock.slabs2.block());
-		slabBlocks.add(ForestryBlock.slabs3.block());
-		slabBlocks.add(ForestryBlock.slabs4.block());
-	}
-
-	public StructureLogicAlveary(ITileStructure structure) {
-		super(UID_ALVEARY, structure);
-		schematas = new Schemata[]{SCHEMATA_ALVEARY};
-		metaOnValid.put(EnumStructureBlock.BLOCK_B, 1);
-	}
-
-	@Override
-	protected EnumStructureState determineMasterState(Schemata schemata, boolean rotate) {
-
-		Vect dimensions = schemata.getDimensions(rotate);
-		int offsetX = schemata.getxOffset();
-		int offsetZ = schemata.getzOffset();
-		if (rotate) {
-			offsetX = schemata.getzOffset();
-			offsetZ = schemata.getxOffset();
-		}
-
-		for (int i = 0; i < dimensions.x; i++) {
-			for (int j = 0; j < schemata.getHeight(); j++) {
-				for (int k = 0; k < dimensions.z; k++) {
-					int x = structureTile.xCoord + i + offsetX;
-					int y = structureTile.yCoord + j + schemata.getyOffset();
-					int z = structureTile.zCoord + k + offsetZ;
-
-					if (!structureTile.getWorldObj().blockExists(x, y, z)) {
-						return EnumStructureState.INDETERMINATE;
-					}
-
-					EnumStructureBlock required = schemata.getAt(i, j, k, rotate);
-					if (required == EnumStructureBlock.ANY) {
-						continue;
-					}
-
-					TileEntity tile = structureTile.getWorldObj().getTileEntity(x, y, z);
-					Block block = structureTile.getWorldObj().getBlock(x, y, z);
-
-					switch (required) {
-						case AIR:
-							if (!block.isAir(structureTile.getWorldObj(), x, y, z)) {
-								return EnumStructureState.INVALID;
-							}
-							break;
-						case BLOCK_A:
-							if (tile == null || !(tile instanceof IAlvearyComponent)) {
-								return EnumStructureState.INVALID;
-							}
-							if (!((ITileStructure) tile).getTypeUID().equals(UID_ALVEARY)) {
-								return EnumStructureState.INVALID;
-							}
-							break;
-						case MASTER:
-						case BLOCK_B:
-							if (tile == null || !(tile instanceof TileAlvearyPlain)) {
-								return EnumStructureState.INVALID;
-							}
-							break;
-						case BLOCK_C:
-							if (!slabBlocks.contains(block)) {
-								return EnumStructureState.INVALID;
-							}
-							if ((structureTile.getWorldObj().getBlockMetadata(x, y, z) & 8) != 0) {
-								return EnumStructureState.INVALID;
-							}
-							break;
-						case BLOCK_D:
-							if (block != Blocks.spruce_stairs) {
-								return EnumStructureState.INVALID;
-							}
-							break;
-						case FOREIGN:
-							if (tile instanceof ITileStructure) {
-								return EnumStructureState.INVALID;
-							}
-							break;
-						default:
-							return EnumStructureState.INDETERMINATE;
-					}
-				}
-			}
-		}
-
-		return EnumStructureState.VALID;
-	}
-
-}

src/main/java/forestry/apiculture/gadgets/TileAlveary.java

@@ -1,282 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.gadgets;
-
-import java.util.Collection;
-import java.util.LinkedList;
-
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.tileentity.TileEntity;
-
-import net.minecraftforge.common.util.ForgeDirection;
-
-import cpw.mods.fml.common.Optional;
-
-import forestry.api.apiculture.IAlvearyComponent;
-import forestry.api.apiculture.IBeeListener;
-import forestry.api.apiculture.IBeeModifier;
-import forestry.api.core.IStructureLogic;
-import forestry.api.core.ITileStructure;
-import forestry.apiculture.trigger.ApicultureTriggers;
-import forestry.core.config.Defaults;
-import forestry.core.config.ForestryBlock;
-import forestry.core.gadgets.TileForestry;
-import forestry.core.inventory.FakeInventoryAdapter;
-import forestry.core.inventory.IInventoryAdapter;
-import forestry.core.network.PacketPayload;
-import forestry.core.proxy.Proxies;
-
-import buildcraft.api.statements.ITriggerExternal;
-
-public abstract class TileAlveary extends TileForestry implements IAlvearyComponent {
-
-	private final IStructureLogic structureLogic;
-	private boolean isMaster;
-	protected int masterX, masterZ;
-	protected int masterY = -99;
-	protected final int componentBlockMeta;
-
-	public TileAlveary(int componentBlockMeta) {
-		this.structureLogic = new StructureLogicAlveary(this);
-		this.componentBlockMeta = componentBlockMeta;
-	}
-
-	/* UPDATING */
-	@Override
-	public void initialize() {
-		if (!ForestryBlock.alveary.isBlockEqual(worldObj, xCoord, yCoord, zCoord)) {
-			Proxies.log.info("Updating alveary block at %s/%s/%s.", xCoord, yCoord, zCoord);
-			worldObj.setBlock(xCoord, yCoord, zCoord, ForestryBlock.alveary.block(), componentBlockMeta, Defaults.FLAG_BLOCK_SYNCH);
-			validate();
-			worldObj.setTileEntity(xCoord, yCoord, zCoord, this);
-		}
-	}
-
-	@Override
-	public void updateEntity() {
-		super.updateEntity();
-
-		if (!Proxies.common.isSimulating(worldObj)) {
-			updateClientSide();
-		} else {
-			// Periodic validation if needed
-			if (updateOnInterval(200) && (!isIntegratedIntoStructure() || isMaster())) {
-				validateStructure();
-			}
-
-			updateServerSide();
-		}
-	}
-
-	protected void updateServerSide() {
-	}
-
-	protected void updateClientSide() {
-	}
-
-	/* TEXTURES */
-	public int getIcon(int side, int metadata) {
-		return BlockAlveary.PLAIN;
-	}
-
-	/* LOADING & SAVING */
-	@Override
-	public void readFromNBT(NBTTagCompound nbttagcompound) {
-		this.isMaster = nbttagcompound.getBoolean("IsMaster");
-		this.masterX = nbttagcompound.getInteger("MasterX");
-		this.masterY = nbttagcompound.getInteger("MasterY");
-		this.masterZ = nbttagcompound.getInteger("MasterZ");
-
-		// Init for master state
-		if (isMaster) {
-			makeMaster();
-		}
-		
-		super.readFromNBT(nbttagcompound);
-
-		structureLogic.readFromNBT(nbttagcompound);
-	}
-
-	@Override
-	public void writeToNBT(NBTTagCompound nbttagcompound) {
-		super.writeToNBT(nbttagcompound);
-
-		nbttagcompound.setBoolean("IsMaster", isMaster);
-		nbttagcompound.setInteger("MasterX", masterX);
-		nbttagcompound.setInteger("MasterY", masterY);
-		nbttagcompound.setInteger("MasterZ", masterZ);
-
-		structureLogic.writeToNBT(nbttagcompound);
-	}
-
-	protected void createInventory() {
-	}
-
-	@Override
-	public PacketPayload getPacketPayload() {
-		PacketPayload payload = new PacketPayload(0, 2);
-		payload.shortPayload[0] = (short) (isMaster() ? 1 : 0);
-
-		// so the client can know if it is part of an integrated structure
-		payload.shortPayload[1] = (short) this.masterY;
-
-		return payload;
-	}
-
-	@Override
-	public void fromPacketPayload(PacketPayload payload) {
-		if (payload.shortPayload[0] > 0) {
-			makeMaster();
-		}
-
-		// so the client can know if it is part of an integrated structure
-		this.masterY = payload.shortPayload[1];
-	}
-
-	/* ITILESTRUCTURE */
-	@Override
-	public String getTypeUID() {
-		return structureLogic.getTypeUID();
-	}
-
-	@Override
-	public void validateStructure() {
-		structureLogic.validateStructure();
-	}
-
-	@Override
-	public void makeMaster() {
-		setCentralTE(null);
-		isMaster = true;
-
-		if (getInternalInventory() instanceof FakeInventoryAdapter) {
-			createInventory();
-		}
-	}
-
-	@Override
-	public void onStructureReset() {
-		setCentralTE(null);
-		if (worldObj.getBlockMetadata(xCoord, yCoord, zCoord) == 1) {
-			worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, 0, 0);
-		}
-		isMaster = false;
-		worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
-	}
-
-	@Override
-	public ITileStructure getCentralTE() {
-
-		if (!isIntegratedIntoStructure()) {
-			return null;
-		}
-
-		if (!isMaster()) {
-			TileEntity tile = worldObj.getTileEntity(masterX, masterY, masterZ);
-			if (tile instanceof ITileStructure) {
-				ITileStructure master = (ITileStructure) worldObj.getTileEntity(masterX, masterY, masterZ);
-				if (master.isMaster()) {
-					return master;
-				} else {
-					return null;
-				}
-			} else {
-				return null;
-			}
-		} else {
-			return this;
-		}
-
-	}
-
-	private boolean isSameTile(TileEntity tile) {
-		return tile.xCoord == xCoord && tile.yCoord == yCoord && tile.zCoord == zCoord;
-	}
-
-	@Override
-	public void setCentralTE(TileEntity tile) {
-		if (tile == null || tile == this || isSameTile(tile)) {
-			this.masterX = this.masterZ = 0;
-			this.masterY = -99;
-			return;
-		}
-
-		this.isMaster = false;
-		this.masterX = tile.xCoord;
-		this.masterY = tile.yCoord;
-		this.masterZ = tile.zCoord;
-	}
-
-	@Override
-	public boolean isMaster() {
-		return isMaster;
-	}
-
-	protected boolean hasMaster() {
-		return masterY >= 0;
-	}
-
-	@Override
-	public boolean isIntegratedIntoStructure() {
-		return isMaster || masterY >= 0;
-	}
-
-	@Override
-	public final IInventoryAdapter getInventory() {
-		return getStructureInventory();
-	}
-
-	@Override
-	public IInventoryAdapter getStructureInventory() {
-		return getInternalInventory();
-	}
-
-	/* IALVEARY COMPONENT */
-	@Override
-	public boolean hasFunction() {
-		return false;
-	}
-
-	@Override
-	public void addTemperatureChange(float change, float boundaryDown, float boundaryUp) {
-	}
-
-	@Override
-	public void addHumidityChange(float change, float boundaryDown, float boundaryUp) {
-	}
-
-	@Override
-	public void registerBeeModifier(IBeeModifier modifier) {
-	}
-
-	@Override
-	public void removeBeeModifier(IBeeModifier modifier) {
-	}
-
-	@Override
-	public void registerBeeListener(IBeeListener event) {
-	}
-
-	@Override
-	public void removeBeeListener(IBeeListener event) {
-	}
-
-	/* ITRIGGERPROVIDER */
-	@Optional.Method(modid = "BuildCraftAPI|statements")
-	@Override
-	public Collection<ITriggerExternal> getExternalTriggers(ForgeDirection side, TileEntity tile) {
-		LinkedList<ITriggerExternal> res = new LinkedList<ITriggerExternal>();
-		res.add(ApicultureTriggers.missingQueen);
-		res.add(ApicultureTriggers.missingDrone);
-		return res;
-	}
-
-}

src/main/java/forestry/apiculture/gadgets/TileAlvearyClimatiser.java

@@ -1,155 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.gadgets;
-
-import net.minecraft.nbt.NBTTagCompound;
-
-import net.minecraftforge.common.util.ForgeDirection;
-
-import forestry.api.apiculture.IAlvearyComponent;
-import forestry.core.network.PacketPayload;
-import forestry.energy.EnergyManager;
-
-import cofh.api.energy.IEnergyHandler;
-
-public abstract class TileAlvearyClimatiser extends TileAlveary implements IEnergyHandler {
-
-	public static class ClimateControl {
-
-		final float changePerTransfer;
-		final float boundaryUp;
-		final float boundaryDown;
-
-		public ClimateControl(float changePerTransfer, float boundaryDown, float boundaryUp) {
-			this.changePerTransfer = changePerTransfer;
-			this.boundaryDown = boundaryDown;
-			this.boundaryUp = boundaryUp;
-		}
-	}
-
-	protected final EnergyManager energyManager;
-	private final ClimateControl climateControl;
-	private int workingTime = 0;
-	private final int textureOff;
-	private final int textureOn;
-
-	public TileAlvearyClimatiser(ClimateControl control, int textureOff, int textureOn, int componentBlockMeta) {
-		super(componentBlockMeta);
-		this.climateControl = control;
-		energyManager = new EnergyManager(1000, 50, 2000);
-		energyManager.setReceiveOnly();
-		this.textureOff = textureOff;
-		this.textureOn = textureOn;
-	}
-
-	/* UPDATING */
-	@Override
-	protected void updateServerSide() {
-		super.updateServerSide();
-
-		if (!this.hasMaster()) {
-			return;
-		}
-
-		boolean wasInactive = (workingTime == 0);
-
-		if (workingTime < 20 && energyManager.consumeEnergyToDoWork()) {
-			// consume 10 RF per tick of work
-			workingTime += energyManager.getEnergyPerWork() / 10;
-		}
-
-		if (workingTime > 0) {
-			workingTime--;
-			IAlvearyComponent component = (IAlvearyComponent) this.getCentralTE();
-			if (component != null) {
-				component.addTemperatureChange(climateControl.changePerTransfer, climateControl.boundaryDown, climateControl.boundaryUp);
-			}
-		}
-
-		if ((wasInactive && workingTime > 0) || (!wasInactive && workingTime == 0)) {
-			sendNetworkUpdate();
-		}
-	}
-
-	@Override
-	public boolean hasFunction() {
-		return true;
-	}
-
-	/* TEXTURES */
-	@Override
-	public int getIcon(int side, int metadata) {
-		if (workingTime > 0) {
-			return textureOn;
-		} else {
-			return textureOff;
-		}
-	}
-
-	/* LOADING & SAVING */
-	@Override
-	public void readFromNBT(NBTTagCompound nbttagcompound) {
-		super.readFromNBT(nbttagcompound);
-		energyManager.readFromNBT(nbttagcompound);
-		workingTime = nbttagcompound.getInteger("Heating");
-	}
-
-	@Override
-	public void writeToNBT(NBTTagCompound nbttagcompound) {
-		super.writeToNBT(nbttagcompound);
-		energyManager.writeToNBT(nbttagcompound);
-		nbttagcompound.setInteger("Heating", workingTime);
-	}
-
-
-	/* NETWORK */
-	@Override
-	public void fromPacketPayload(PacketPayload payload) {
-		short workingTime = payload.shortPayload[0];
-		if (this.workingTime != workingTime) {
-			this.workingTime = workingTime;
-			worldObj.func_147479_m(xCoord, yCoord, zCoord);
-		}
-	}
-
-	@Override
-	public PacketPayload getPacketPayload() {
-		PacketPayload payload = new PacketPayload(0, 1);
-		payload.shortPayload[0] = (short) workingTime;
-		return payload;
-	}
-
-	/* IEnergyHandler */
-	@Override
-	public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) {
-		return energyManager.receiveEnergy(from, maxReceive, simulate);
-	}
-
-	@Override
-	public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) {
-		return energyManager.extractEnergy(from, maxExtract, simulate);
-	}
-
-	@Override
-	public int getEnergyStored(ForgeDirection from) {
-		return energyManager.getEnergyStored(from);
-	}
-
-	@Override
-	public int getMaxEnergyStored(ForgeDirection from) {
-		return energyManager.getMaxEnergyStored(from);
-	}
-
-	@Override
-	public boolean canConnectEnergy(ForgeDirection from) {
-		return energyManager.canConnectEnergy(from);
-	}
-}

src/main/java/forestry/apiculture/gadgets/TileAlvearyPlain.java

@@ -1,677 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.gadgets;
-
-import java.util.LinkedHashSet;
-import java.util.Set;
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.inventory.ICrafting;
-import net.minecraft.inventory.IInventory;
-import net.minecraft.inventory.ISidedInventory;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.world.World;
-import net.minecraft.world.biome.BiomeGenBase;
-
-import com.mojang.authlib.GameProfile;
-
-import forestry.api.apiculture.IBee;
-import forestry.api.apiculture.IBeeGenome;
-import forestry.api.apiculture.IBeeHousing;
-import forestry.api.apiculture.IBeeListener;
-import forestry.api.apiculture.IBeeModifier;
-import forestry.api.apiculture.IBeekeepingLogic;
-import forestry.api.core.BiomeHelper;
-import forestry.api.core.EnumHumidity;
-import forestry.api.core.EnumTemperature;
-import forestry.api.core.ForestryAPI;
-import forestry.api.core.IErrorState;
-import forestry.api.core.ITileStructure;
-import forestry.api.genetics.IIndividual;
-import forestry.apiculture.gui.ContainerAlveary;
-import forestry.core.EnumErrorCode;
-import forestry.core.config.Config;
-import forestry.core.interfaces.IClimatised;
-import forestry.core.interfaces.IErrorSource;
-import forestry.core.interfaces.IHintSource;
-import forestry.core.inventory.IInventoryAdapter;
-import forestry.core.inventory.InvTools;
-import forestry.core.inventory.TileInventoryAdapter;
-import forestry.core.network.GuiId;
-import forestry.core.network.PacketIds;
-import forestry.core.network.PacketInventoryStack;
-import forestry.core.proxy.Proxies;
-import forestry.core.utils.Utils;
-import forestry.plugins.PluginApiculture;
-
-public class TileAlvearyPlain extends TileAlveary implements ISidedInventory, IBeeHousing, IClimatised, IHintSource {
-
-	// / CONSTANTS
-	public static final int SLOT_QUEEN = 0;
-	public static final int SLOT_DRONE = 1;
-	public static final int SLOT_PRODUCT_1 = 2;
-	public static final int SLOT_PRODUCTION_COUNT = 7;
-	public static final int BLOCK_META = 0;
-
-	// / MEMBERS
-	protected IBeekeepingLogic beekeepingLogic;
-	protected BiomeGenBase biome;
-	protected float tempChange = 0.0f;
-	protected float humidChange = 0.0f;
-	private int displayHealthMax = 0;
-	private int displayHealth = 0;
-
-	public TileAlvearyPlain() {
-		super(0);
-	}
-
-	@Override
-	public void openGui(EntityPlayer player) {
-		if (isMaster()) {
-			player.openGui(ForestryAPI.instance, GuiId.AlvearyGUI.ordinal(), worldObj, xCoord, yCoord, zCoord);
-		} else if (this.hasMaster()) {
-			player.openGui(ForestryAPI.instance, GuiId.AlvearyGUI.ordinal(), worldObj, masterX, masterY, masterZ);
-		}
-	}
-
-	@Override
-	public void validate() {
-		super.validate();
-		setBiomeInformation();
-	}
-
-	private void setBiomeInformation() {
-		this.biome = Utils.getBiomeAt(worldObj, xCoord, zCoord);
-		setErrorState(EnumErrorCode.OK);
-	}
-
-	/* LOADING & SAVING */
-	@Override
-	public void readFromNBT(NBTTagCompound nbttagcompound) {
-		super.readFromNBT(nbttagcompound);
-
-		this.tempChange = nbttagcompound.getFloat("TempChange");
-		this.humidChange = nbttagcompound.getFloat("HumidChange");
-
-		if (beekeepingLogic != null) {
-			beekeepingLogic.readFromNBT(nbttagcompound);
-		}
-
-	}
-
-	@Override
-	public void writeToNBT(NBTTagCompound nbttagcompound) {
-		super.writeToNBT(nbttagcompound);
-
-		nbttagcompound.setFloat("TempChange", tempChange);
-		nbttagcompound.setFloat("HumidChange", humidChange);
-
-		if (beekeepingLogic != null) {
-			beekeepingLogic.writeToNBT(nbttagcompound);
-		}
-
-	}
-
-	/* UPDATING */
-	@Override
-	public void initialize() {
-		super.initialize();
-		setBiomeInformation();
-	}
-
-	@Override
-	protected void updateServerSide() {
-
-		if (beekeepingLogic == null) {
-			return;
-		}
-		if (!isMaster()) {
-			return;
-		}
-
-		beekeepingLogic.update();
-
-		// Equalize humidity and temperature
-		equalizeTemperature();
-		equalizeHumidity();
-
-		IBee queen = beekeepingLogic.getQueen();
-		if (queen == null) {
-			return;
-		}
-
-		// Add swarm effects
-		if (updateOnInterval(200)) {
-			ISidedInventory inventory = getStructureInventory();
-			if (inventory != null) {
-				onQueenChange(inventory.getStackInSlot(SLOT_QUEEN));
-			}
-		}
-
-		if (getErrorState() == EnumErrorCode.OK) {
-			queen.doFX(beekeepingLogic.getEffectData(), this);
-		}
-
-		if (getErrorState() == EnumErrorCode.OK && updateOnInterval(50)) {
-			float f = xCoord + 0.5F;
-			float f1 = yCoord + 0.0F + (worldObj.rand.nextFloat() * 6F) / 16F;
-			float f2 = zCoord + 0.5F;
-			float f3 = 0.52F;
-			float f4 = worldObj.rand.nextFloat() * 0.6F - 0.3F;
-
-			Proxies.common.addEntitySwarmFX(worldObj, (f - f3), f1, (f2 + f4), 0F, 0F, 0F);
-			Proxies.common.addEntitySwarmFX(worldObj, (f + f3), f1, (f2 + f4), 0F, 0F, 0F);
-			Proxies.common.addEntitySwarmFX(worldObj, (f + f4), f1, (f2 - f3), 0F, 0F, 0F);
-			Proxies.common.addEntitySwarmFX(worldObj, (f + f4), f1, (f2 + f3), 0F, 0F, 0F);
-		}
-
-	}
-
-	@Override
-	protected void updateClientSide() {
-
-		if (!isMaster()) {
-			return;
-		}
-
-		ISidedInventory inventory = getStructureInventory();
-		if (inventory == null) {
-			return;
-		}
-
-		// / Multiplayer FX
-		ItemStack queenStack = inventory.getStackInSlot(SLOT_QUEEN);
-		if (PluginApiculture.beeInterface.isMated(queenStack)) {
-			if (getErrorState() == EnumErrorCode.OK && updateOnInterval(2)) {
-				IBee displayQueen = PluginApiculture.beeInterface.getMember(queenStack);
-				displayQueen.doFX(beekeepingLogic.getEffectData(), this);
-			}
-		}
-	}
-
-	private void equalizeTemperature() {
-		if (tempChange == 0) {
-			return;
-		}
-
-		tempChange -= 0.05f * tempChange;
-		if (tempChange <= 0.001f && tempChange >= -0.001f) {
-			tempChange = 0;
-		}
-	}
-
-	private void equalizeHumidity() {
-		if (humidChange == 0) {
-			return;
-		}
-
-		humidChange -= 0.05f * humidChange;
-		if (humidChange <= 0.001f && humidChange >= 0.001f) {
-			humidChange = 0;
-		}
-	}
-
-	/* STATE INFORMATION */
-	private int getHealthDisplay() {
-		IInventory inventory = getStructureInventory();
-		if (inventory == null || inventory.getStackInSlot(SLOT_QUEEN) == null) {
-			return 0;
-		}
-
-		if (PluginApiculture.beeInterface.isMated(inventory.getStackInSlot(SLOT_QUEEN))) {
-			return PluginApiculture.beeInterface.getMember(inventory.getStackInSlot(SLOT_QUEEN)).getHealth();
-		} else if (!PluginApiculture.beeInterface.isDrone(inventory.getStackInSlot(SLOT_QUEEN))) {
-			return displayHealth;
-		} else {
-			return 0;
-		}
-	}
-
-	private int getMaxHealthDisplay() {
-		IInventory inventory = getStructureInventory();
-		if (inventory == null || inventory.getStackInSlot(SLOT_QUEEN) == null) {
-			return 0;
-		}
-
-		if (PluginApiculture.beeInterface.isMated(inventory.getStackInSlot(SLOT_QUEEN))) {
-			return PluginApiculture.beeInterface.getMember(inventory.getStackInSlot(SLOT_QUEEN)).getMaxHealth();
-		} else if (!PluginApiculture.beeInterface.isDrone(inventory.getStackInSlot(SLOT_QUEEN))) {
-			return displayHealthMax;
-		} else {
-			return 0;
-		}
-	}
-
-	public int getHealthScaled(int i) {
-		if (getMaxHealthDisplay() == 0) {
-			return 0;
-		}
-
-		return (getHealthDisplay() * i) / getMaxHealthDisplay();
-	}
-
-	/* STRUCTURE MANAGMENT */
-	@Override
-	protected void createInventory() {
-		setInternalInventory(new TileInventoryAdapter(this, 9, "Items") {
-			@Override
-			public boolean canSlotAccept(int slotIndex, ItemStack itemStack) {
-				if (slotIndex == SLOT_QUEEN) {
-					return PluginApiculture.beeInterface.isMember(itemStack) && !PluginApiculture.beeInterface.isDrone(itemStack);
-				} else if (slotIndex == SLOT_DRONE) {
-					return PluginApiculture.beeInterface.isDrone(itemStack);
-				}
-				return false;
-			}
-
-			@Override
-			public boolean canExtractItem(int slotIndex, ItemStack itemstack, int side) {
-				return slotIndex != SLOT_QUEEN && slotIndex != SLOT_DRONE;
-			}
-		});
-	}
-
-	@Override
-	public void makeMaster() {
-		super.makeMaster();
-		if (beekeepingLogic == null) {
-			this.beekeepingLogic = PluginApiculture.beeInterface.createBeekeepingLogic(this);
-		}
-	}
-
-	@Override
-	public void onStructureReset() {
-		super.onStructureReset();
-		modifiers.clear();
-		eventHandlers.clear();
-	}
-
-	/* IALVEARYCOMPONENT */
-	private final Set<IBeeModifier> modifiers = new LinkedHashSet<IBeeModifier>();
-	private final Set<IBeeListener> eventHandlers = new LinkedHashSet<IBeeListener>();
-
-	@Override
-	public void registerBeeModifier(IBeeModifier modifier) {
-		modifiers.add(modifier);
-	}
-
-	@Override
-	public void removeBeeModifier(IBeeModifier modifier) {
-		modifiers.remove(modifier);
-	}
-
-	@Override
-	public void registerBeeListener(IBeeListener modifier) {
-		eventHandlers.add(modifier);
-	}
-
-	@Override
-	public void removeBeeListener(IBeeListener modifier) {
-		eventHandlers.remove(modifier);
-	}
-
-	@Override
-	public void addTemperatureChange(float change, float boundaryDown, float boundaryUp) {
-		float temperature = biome.temperature;
-		tempChange = Math.min(boundaryUp - temperature, Math.max(boundaryDown - temperature, tempChange + change));
-	}
-
-	@Override
-	public void addHumidityChange(float change, float boundaryDown, float boundaryUp) {
-		float humidity = biome.rainfall;
-		humidChange = Math.min(boundaryUp - humidity, Math.max(boundaryDown - humidity, humidChange + change));
-	}
-
-	/* IBEEHOUSING */
-	@Override
-	public int getXCoord() {
-		return xCoord;
-	}
-
-	@Override
-	public int getYCoord() {
-		return yCoord;
-	}
-
-	@Override
-	public int getZCoord() {
-		return zCoord;
-	}
-
-	@Override
-	public ItemStack getQueen() {
-		return getStackInSlot(SLOT_QUEEN);
-	}
-
-	@Override
-	public ItemStack getDrone() {
-		return getStackInSlot(SLOT_DRONE);
-	}
-
-	@Override
-	public void setQueen(ItemStack itemstack) {
-		setInventorySlotContents(SLOT_QUEEN, itemstack);
-	}
-
-	@Override
-	public void setDrone(ItemStack itemstack) {
-		setInventorySlotContents(SLOT_DRONE, itemstack);
-	}
-
-	@Override
-	public int getBiomeId() {
-		return biome.biomeID;
-	}
-
-	@Override
-	public BiomeGenBase getBiome() {
-		return biome;
-	}
-
-	@Override
-	public EnumTemperature getTemperature() {
-		if (BiomeHelper.isBiomeHellish(biome) && tempChange >= 0) {
-			return EnumTemperature.HELLISH;
-		}
-
-		return EnumTemperature.getFromValue(getExactTemperature());
-	}
-
-	@Override
-	public EnumHumidity getHumidity() {
-		return EnumHumidity.getFromValue(getExactHumidity());
-	}
-
-	@Override
-	public float getTerritoryModifier(IBeeGenome genome, float currentModifier) {
-		float mod = 2.0f;
-		for (IBeeModifier modifier : modifiers) {
-			mod *= modifier.getTerritoryModifier(genome, mod);
-		}
-		return mod;
-	}
-
-	@Override
-	public float getProductionModifier(IBeeGenome genome, float currentModifier) {
-		float mod = 1.0f;
-		for (IBeeModifier modifier : modifiers) {
-			mod *= modifier.getProductionModifier(genome, mod);
-		}
-		return mod;
-	}
-
-	@Override
-	public float getMutationModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
-		float mod = 1.0f;
-		for (IBeeModifier modifier : modifiers) {
-			mod *= modifier.getMutationModifier(genome, mate, mod);
-		}
-		return mod;
-	}
-
-	@Override
-	public float getLifespanModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
-		float mod = 1.0f;
-		for (IBeeModifier modifier : modifiers) {
-			mod *= modifier.getLifespanModifier(genome, mate, mod);
-		}
-		return mod;
-	}
-
-	@Override
-	public float getFloweringModifier(IBeeGenome genome, float currentModifier) {
-		float mod = 1.0f;
-		for (IBeeModifier modifier : modifiers) {
-			mod *= modifier.getFloweringModifier(genome, mod);
-		}
-		return mod;
-	}
-
-	@Override
-	public float getGeneticDecay(IBeeGenome genome, float currentModifier) {
-		float mod = 1.0f;
-		for (IBeeModifier modifier : modifiers) {
-			mod *= modifier.getGeneticDecay(genome, mod);
-		}
-		return mod;
-	}
-
-	@Override
-	public World getWorld() {
-		return worldObj;
-	}
-
-	@Override
-	public void setErrorState(int state) {
-		setErrorState(EnumErrorCode.values()[state]);
-	}
-
-	@Override
-	public int getErrorOrdinal() {
-		return getErrorState().getID();
-	}
-
-	@Override
-	public boolean canBreed() {
-		return true;
-	}
-
-	@Override
-	public boolean addProduct(ItemStack product, boolean all) {
-		IInventoryAdapter inventory = getStructureInventory();
-		if (inventory == null) {
-			return false;
-		}
-
-		return InvTools.tryAddStack(inventory, product, SLOT_PRODUCT_1, inventory.getSizeInventory() - SLOT_PRODUCT_1, all);
-	}
-
-	@Override
-	public void wearOutEquipment(int amount) {
-		for (IBeeListener eventHandler : eventHandlers) {
-			eventHandler.wearOutEquipment(amount);
-		}
-	}
-
-	@Override
-	public void onQueenChange(ItemStack queenStack) {
-		if (!Proxies.common.isSimulating(worldObj)) {
-			return;
-		}
-
-		Proxies.net.sendNetworkPacket(new PacketInventoryStack(PacketIds.IINVENTORY_STACK, xCoord, yCoord, zCoord, SLOT_QUEEN, queenStack), xCoord, yCoord,
-				zCoord);
-
-		for (IBeeListener eventHandler : eventHandlers) {
-			eventHandler.onQueenChange(queenStack);
-		}
-	}
-
-	@Override
-	public void onQueenDeath(IBee queen) {
-		for (IBeeListener eventHandler : eventHandlers) {
-			eventHandler.onQueenDeath(queen);
-		}
-	}
-
-	@Override
-	public void onPostQueenDeath(IBee queen) {
-		for (IBeeListener eventHandler : eventHandlers) {
-			eventHandler.onPostQueenDeath(queen);
-		}
-	}
-
-	@Override
-	public boolean onPollenRetrieved(IBee queen, IIndividual pollen, boolean isHandled) {
-
-		for (IBeeListener eventHandler : eventHandlers) {
-			if (eventHandler.onPollenRetrieved(queen, pollen, isHandled)) {
-				isHandled = true;
-			}
-		}
-
-		return isHandled;
-	}
-
-	@Override
-	public boolean onEggLaid(IBee queen) {
-		for (IBeeListener eventHandler : eventHandlers) {
-			if (eventHandler.onEggLaid(queen)) {
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	@Override
-	public boolean isSealed() {
-		for (IBeeModifier modifier : modifiers) {
-			if (modifier.isSealed()) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	@Override
-	public boolean isSelfLighted() {
-		for (IBeeModifier modifier : modifiers) {
-			if (modifier.isSelfLighted()) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	@Override
-	public boolean isSunlightSimulated() {
-		for (IBeeModifier modifier : modifiers) {
-			if (modifier.isSunlightSimulated()) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	@Override
-	public boolean isHellish() {
-		for (IBeeModifier modifier : modifiers) {
-			if (modifier.isHellish()) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	/* IINVENTORY */
-	@Override
-	public IInventoryAdapter getInternalInventory() {
-		IInventoryAdapter inventory = super.getInternalInventory();
-		if (isMaster()) {
-			return inventory;
-		} else if (hasMaster()) {
-			ITileStructure central = getCentralTE();
-			if (central instanceof TileAlveary) {
-				return ((TileAlveary) central).getInternalInventory();
-			}
-		}
-		return inventory;
-	}
-
-	/* SMP GUI */
-	public void getGUINetworkData(int i, int j) {
-		switch (i) {
-			case 0:
-				displayHealth = j;
-				break;
-			case 1:
-				displayHealthMax = j;
-				break;
-			case 4:
-				this.tempChange = (float) j / 100;
-				break;
-			case 5:
-				this.humidChange = (float) j / 100;
-				break;
-			case 6: {
-				this.biome = BiomeGenBase.getBiome(j);
-				break;
-			}
-		}
-
-	}
-
-	public void sendGUINetworkData(ContainerAlveary container, ICrafting iCrafting) {
-		if (beekeepingLogic == null) {
-			return;
-		}
-
-		iCrafting.sendProgressBarUpdate(container, 0, beekeepingLogic.getBreedingTime());
-		iCrafting.sendProgressBarUpdate(container, 1, beekeepingLogic.getTotalBreedingTime());
-		iCrafting.sendProgressBarUpdate(container, 4, Math.round(tempChange * 100));
-		iCrafting.sendProgressBarUpdate(container, 5, Math.round(humidChange * 100));
-		iCrafting.sendProgressBarUpdate(container, 6, biome.biomeID);
-	}
-
-	/* IERRORSOURCE */
-	@Override
-	public IErrorState getErrorState() {
-		if (hasMaster()) {
-			ITileStructure tile = this.getCentralTE();
-			if (tile != null) {
-				return ((IErrorSource) tile).getErrorState();
-			}
-		}
-
-		return errorState;
-	}
-
-	/* ICLIMATISED */
-	@Override
-	public boolean isClimatized() {
-		return true;
-	}
-
-	@Override
-	public float getExactTemperature() {
-		return biome.temperature + this.tempChange;
-	}
-
-	@Override
-	public float getExactHumidity() {
-		return biome.rainfall + this.humidChange;
-	}
-
-	/* IHINTSOURCE */
-	@Override
-	public boolean hasHints() {
-		return Config.hints.get("alveary").length > 0;
-	}
-
-	@Override
-	public String[] getHints() {
-		return Config.hints.get("alveary");
-	}
-
-	/* IOWNABLE */
-	@Override
-	public boolean isOwnable() {
-		return true;
-	}
-
-	/* IHousing */
-	@Override
-	public GameProfile getOwnerName() {
-		return this.getOwnerProfile();
-	}
-}

src/main/java/forestry/apiculture/gadgets/TileAlvearySieve.java

@@ -1,190 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.gadgets;
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.item.ItemStack;
-
-import forestry.api.apiculture.IAlvearyComponent;
-import forestry.api.apiculture.IBee;
-import forestry.api.apiculture.IBeeListener;
-import forestry.api.arboriculture.EnumGermlingType;
-import forestry.api.core.ForestryAPI;
-import forestry.api.genetics.AlleleManager;
-import forestry.api.genetics.IIndividual;
-import forestry.core.config.ForestryItem;
-import forestry.core.interfaces.ICrafter;
-import forestry.core.inventory.IInventoryAdapter;
-import forestry.core.inventory.TileInventoryAdapter;
-import forestry.core.network.GuiId;
-import forestry.core.proxy.Proxies;
-import forestry.core.utils.StackUtils;
-
-public class TileAlvearySieve extends TileAlveary implements ICrafter, IBeeListener {
-
-	/* CONSTANTS */
-	public static final int BLOCK_META = 7;
-	
-	public static final int SLOT_POLLEN_1 = 0;
-	public static final int SLOTS_POLLEN_COUNT = 4;
-	public static final int SLOT_SIEVE = 4;
-
-	public TileAlvearySieve() {
-		super(BLOCK_META);
-		setInternalInventory(new TileInventoryAdapter(this, 5, "Items", 1) {
-			@Override
-			public boolean canSlotAccept(int slotIndex, ItemStack itemStack) {
-				return StackUtils.isIdenticalItem(ForestryItem.craftingMaterial.getItemStack(1, 3), itemStack);
-			}
-		});
-	}
-
-	@Override
-	public void openGui(EntityPlayer player) {
-		player.openGui(ForestryAPI.instance, GuiId.AlvearySieveGUI.ordinal(), worldObj, xCoord, yCoord, zCoord);
-	}
-
-	@Override
-	public boolean hasFunction() {
-		return true;
-	}
-	
-	/* UPDATING */
-	@Override
-	public void initialize() {
-		super.initialize();
-		
-		if (!hasMaster() || !isIntegratedIntoStructure() || !Proxies.common.isSimulating(worldObj)) {
-			return;
-		}
-		
-		((IAlvearyComponent) getCentralTE()).registerBeeListener(this);
-	}
-	
-	@Override
-	protected void updateServerSide() {
-		super.updateServerSide();
-		if (!updateOnInterval(200)) {
-			return;
-		}
-		
-		if (!hasMaster() || !isIntegratedIntoStructure()) {
-			return;
-		}
-		
-		((IAlvearyComponent) getCentralTE()).registerBeeListener(this);
-	}
-	
-	/* TEXTURES & INTERNAL */
-	@Override
-	public int getIcon(int side, int metadata) {
-		if (side == 0 || side == 1) {
-			return BlockAlveary.BOTTOM;
-		}
-		return BlockAlveary.SIEVE;
-	}
-
-	private void destroySieve() {
-		IInventoryAdapter inventory = getInternalInventory();
-		inventory.setInventorySlotContents(SLOT_SIEVE, null);
-	}
-
-	private void destroyPollen() {
-		IInventoryAdapter inventory = getInternalInventory();
-		for (int i = SLOT_POLLEN_1; i < SLOT_POLLEN_1 + SLOTS_POLLEN_COUNT; i++) {
-			inventory.setInventorySlotContents(i, null);
-		}
-	}
-	
-	private boolean canStorePollen() {
-		IInventoryAdapter inventory = getInternalInventory();
-		if (inventory.getStackInSlot(SLOT_SIEVE) == null) {
-			return false;
-		}
-		
-		for (int i = SLOT_POLLEN_1; i < SLOT_POLLEN_1 + SLOTS_POLLEN_COUNT; i++) {
-			if (inventory.getStackInSlot(i) == null) {
-				return true;
-			}
-		}
-		
-		return false;
-	}
-	
-	private void storePollenStack(ItemStack itemstack) {
-		IInventoryAdapter inventory = getInternalInventory();
-		for (int i = SLOT_POLLEN_1; i < SLOT_POLLEN_1 + SLOTS_POLLEN_COUNT; i++) {
-			if (inventory.getStackInSlot(i) == null) {
-				inventory.setInventorySlotContents(i, itemstack);
-				return;
-			}
-		}
-	}
-
-	/* ICRAFTER */
-	@Override
-	public boolean canTakeStack(int slotIndex) {
-		return true;
-	}
-
-	@Override
-	public ItemStack takenFromSlot(int slotIndex, EntityPlayer player) {
-		IInventoryAdapter inventory = getInternalInventory();
-		if (slotIndex == SLOT_SIEVE) {
-			destroyPollen();
-			return inventory.getStackInSlot(SLOT_SIEVE);
-		} else {
-			destroySieve();
-			return inventory.getStackInSlot(slotIndex);
-		}
-	}
-
-	@Override
-	public ItemStack getResult() {
-		return null;
-	}
-
-	/* IBEELISTENER */
-	@Override
-	public void onQueenChange(ItemStack queen) {
-	}
-
-	@Override
-	public void wearOutEquipment(int amount) {
-	}
-
-	@Override
-	public void onQueenDeath(IBee queen) {
-	}
-
-	@Override
-	public void onPostQueenDeath(IBee queen) {
-	}
-
-	@Override
-	public boolean onPollenRetrieved(IBee queen, IIndividual pollen, boolean isHandled) {
-
-		if (isHandled) {
-			return true;
-		}
-		if (!canStorePollen()) {
-			return false;
-		}
-		
-		storePollenStack(AlleleManager.alleleRegistry.getSpeciesRoot(pollen.getClass()).getMemberStack(pollen, EnumGermlingType.POLLEN.ordinal()));
-		return true;
-	}
-
-	@Override
-	public boolean onEggLaid(IBee queen) {
-		return false;
-	}
-}

src/main/java/forestry/apiculture/gadgets/TileAlvearyStabiliser.java

@@ -1,120 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.gadgets;
-
-import forestry.api.apiculture.IAlvearyComponent;
-import forestry.api.apiculture.IBeeGenome;
-import forestry.api.apiculture.IBeeModifier;
-import forestry.core.proxy.Proxies;
-
-public class TileAlvearyStabiliser extends TileAlveary implements IBeeModifier {
-
-	public static final int BLOCK_META = 6;
-
-	public TileAlvearyStabiliser() {
-		super(BLOCK_META);
-	}
-
-	/* UPDATING */
-	@Override
-	public void initialize() {
-		super.initialize();
-		
-		if (!hasMaster() || !isIntegratedIntoStructure() || !Proxies.common.isSimulating(worldObj)) {
-			return;
-		}
-		
-		((IAlvearyComponent) getCentralTE()).registerBeeModifier(this);
-
-	}
-	
-	@Override
-	protected void updateServerSide() {
-		super.updateServerSide();
-		if (!updateOnInterval(200)) {
-			return;
-		}
-		
-		if (!hasMaster() || !isIntegratedIntoStructure()) {
-			return;
-		}
-		
-		((IAlvearyComponent) getCentralTE()).registerBeeModifier(this);
-	}
-	
-
-	@Override
-	public boolean hasFunction() {
-		return true;
-	}
-
-	/* TEXTURES */
-	@Override
-	public int getIcon(int side, int metadata) {
-		if (side == 0 || side == 1) {
-			return BlockAlveary.BOTTOM;
-		}
-
-		return BlockAlveary.STABILISER;
-	}
-
-	/* IBEEMODIFIER */
-	@Override
-	public float getMutationModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
-		return 0.0f;
-	}
-
-	@Override
-	public float getTerritoryModifier(IBeeGenome genome, float currentModifier) {
-		return 1.0f;
-	}
-
-	@Override
-	public float getLifespanModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
-		return 1.0f;
-	}
-
-	@Override
-	public float getProductionModifier(IBeeGenome genome, float currentModifier) {
-		return 1.0f;
-	}
-
-	@Override
-	public float getFloweringModifier(IBeeGenome genome, float currentModifier) {
-		return 1.0f;
-	}
-
-	@Override
-	public float getGeneticDecay(IBeeGenome genome, float currentModifier) {
-		return 1.0f;
-	}
-
-	@Override
-	public boolean isSealed() {
-		return false;
-	}
-
-	@Override
-	public boolean isSelfLighted() {
-		return false;
-	}
-
-	@Override
-	public boolean isSunlightSimulated() {
-		return false;
-	}
-
-	@Override
-	public boolean isHellish() {
-		return false;
-	}
-
-}

src/main/java/forestry/apiculture/gadgets/TileApiary.java

@@ -1,259 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.gadgets;
-
-import java.util.Collection;
-import java.util.LinkedList;
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.tileentity.TileEntity;
-
-import net.minecraftforge.common.util.ForgeDirection;
-
-import cpw.mods.fml.common.Optional;
-
-import forestry.api.apiculture.IBeeGenome;
-import forestry.api.apiculture.IHiveFrame;
-import forestry.api.core.ForestryAPI;
-import forestry.apiculture.trigger.ApicultureTriggers;
-import forestry.core.gadgets.TileBase;
-import forestry.core.inventory.IInventoryAdapter;
-import forestry.core.network.GuiId;
-import forestry.plugins.PluginApiculture;
-
-import buildcraft.api.statements.ITriggerExternal;
-
-public class TileApiary extends TileBeehouse {
-
-	public TileApiary() {
-		setInternalInventory(new BeehouseInventoryAdapter(this, 12, "Items"));
-	}
-
-	@Override
-	public void openGui(EntityPlayer player, TileBase tile) {
-		player.openGui(ForestryAPI.instance, GuiId.ApiaryGUI.ordinal(), worldObj, xCoord, yCoord, zCoord);
-	}
-
-	/* IBEEHOUSING */
-	@Override
-	public float getTerritoryModifier(IBeeGenome genome, float currentModifier) {
-		IInventoryAdapter inventory = getInternalInventory();
-		float mod = 1.0f;
-		for (int i = SLOT_FRAMES_1; i < SLOT_FRAMES_1 + SLOT_FRAMES_COUNT; i++) {
-			if (inventory.getStackInSlot(i) == null) {
-				continue;
-			}
-			if (inventory.getStackInSlot(i).getItem() instanceof IHiveFrame) {
-				mod *= ((IHiveFrame) inventory.getStackInSlot(i).getItem()).getTerritoryModifier(genome, mod);
-			}
-		}
-		return mod;
-	}
-
-	@Override
-	public float getProductionModifier(IBeeGenome genome, float currentModifier) {
-		IInventoryAdapter inventory = getInternalInventory();
-		float mod = 0.1f;
-		for (int i = SLOT_FRAMES_1; i < SLOT_FRAMES_1 + SLOT_FRAMES_COUNT; i++) {
-			if (inventory.getStackInSlot(i) == null) {
-				continue;
-			}
-			if (inventory.getStackInSlot(i).getItem() instanceof IHiveFrame) {
-				mod *= ((IHiveFrame) inventory.getStackInSlot(i).getItem()).getProductionModifier(genome, mod);
-			}
-		}
-		return mod;
-	}
-
-	@Override
-	public float getMutationModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
-		IInventoryAdapter inventory = getInternalInventory();
-		float mod = 1.0f;
-		for (int i = SLOT_FRAMES_1; i < SLOT_FRAMES_1 + SLOT_FRAMES_COUNT; i++) {
-			if (inventory.getStackInSlot(i) == null) {
-				continue;
-			}
-			if (inventory.getStackInSlot(i).getItem() instanceof IHiveFrame) {
-				mod *= ((IHiveFrame) inventory.getStackInSlot(i).getItem()).getMutationModifier(genome, mate, mod);
-			}
-		}
-		return mod;
-	}
-
-	@Override
-	public float getLifespanModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
-		IInventoryAdapter inventory = getInternalInventory();
-		float mod = 1.0f;
-		for (int i = SLOT_FRAMES_1; i < SLOT_FRAMES_1 + SLOT_FRAMES_COUNT; i++) {
-			if (inventory.getStackInSlot(i) == null) {
-				continue;
-			}
-			if (inventory.getStackInSlot(i).getItem() instanceof IHiveFrame) {
-				mod *= ((IHiveFrame) inventory.getStackInSlot(i).getItem()).getLifespanModifier(genome, mate, mod);
-			}
-		}
-		return mod;
-	}
-
-	@Override
-	public float getFloweringModifier(IBeeGenome genome, float currentModifier) {
-		IInventoryAdapter inventory = getInternalInventory();
-		float mod = 1f;
-		for (int i = SLOT_FRAMES_1; i < SLOT_FRAMES_1 + SLOT_FRAMES_COUNT; i++) {
-			if (inventory.getStackInSlot(i) == null) {
-				continue;
-			}
-			if (inventory.getStackInSlot(i).getItem() instanceof IHiveFrame) {
-				mod *= ((IHiveFrame) inventory.getStackInSlot(i).getItem()).getFloweringModifier(genome, mod);
-			}
-		}
-		return mod;
-	}
-
-	@Override
-	public float getGeneticDecay(IBeeGenome genome, float currentModifier) {
-		IInventoryAdapter inventory = getInternalInventory();
-		float mod = 1f;
-		for (int i = SLOT_FRAMES_1; i < SLOT_FRAMES_1 + SLOT_FRAMES_COUNT; i++) {
-			if (inventory.getStackInSlot(i) == null) {
-				continue;
-			}
-			if (inventory.getStackInSlot(i).getItem() instanceof IHiveFrame) {
-				mod *= ((IHiveFrame) inventory.getStackInSlot(i).getItem()).getGeneticDecay(genome, mod);
-			}
-		}
-		return mod;
-	}
-
-	@Override
-	public void wearOutEquipment(int amount) {
-		IInventoryAdapter inventory = getInternalInventory();
-		int wear = Math.round(amount * PluginApiculture.beeInterface.getBeekeepingMode(worldObj).getWearModifier());
-
-		for (int i = SLOT_FRAMES_1; i < SLOT_FRAMES_1 + SLOT_FRAMES_COUNT; i++) {
-			if (inventory.getStackInSlot(i) == null) {
-				continue;
-			}
-			if (!(inventory.getStackInSlot(i).getItem() instanceof IHiveFrame)) {
-				continue;
-			}
-
-			inventory.setInventorySlotContents(
-					i,
-					((IHiveFrame) inventory.getStackInSlot(i).getItem()).frameUsed(this, inventory.getStackInSlot(i),
-							PluginApiculture.beeInterface.getMember(inventory.getStackInSlot(SLOT_QUEEN)), wear));
-		}
-	}
-
-	/* ISPECIALINVENTORY */
-	//	@Override
-	//	public ItemStack[] extractItem(boolean doRemove, ForgeDirection from, int maxItemCount) {
-	//		ItemStack product = null;
-	//
-	//		for (int i = SLOT_PRODUCT_1; i < SLOT_PRODUCT_1 + SLOT_PRODUCT_COUNT; i++) {
-	//			if (inventory.getStackInSlot(i) == null)
-	//				continue;
-	//
-	//			// Princesses can only be extracted from top.
-	//			if (ForestryItem.beePrincessGE.isItemEqual(inventory.getStackInSlot(i))) {
-	//				if (PluginApiculture.apiarySideSensitive && from != ForgeDirection.UP)
-	//					continue;
-	//
-	//				product = inventory.getStackInSlot(i).copy();
-	//				if (doRemove) {
-	//					inventory.getStackInSlot(i).stackSize = 0;
-	//					inventory.setInventorySlotContents(i, null);
-	//				}
-	//				break;
-	//
-	//				// Drones can only be extracted from the bottom.
-	//			} else if (ForestryItem.beeDroneGE.isItemEqual(inventory.getStackInSlot(i))) {
-	//				if (PluginApiculture.apiarySideSensitive && from != ForgeDirection.DOWN)
-	//					continue;
-	//
-	//				product = StackUtils.createSplitStack(inventory.getStackInSlot(i), 1);
-	//				product.stackSize = 1;
-	//				if (doRemove) {
-	//					inventory.getStackInSlot(i).stackSize--;
-	//					if (inventory.getStackInSlot(i).stackSize <= 0)
-	//						inventory.setInventorySlotContents(i, null);
-	//				}
-	//				break;
-	//
-	//				// Everything else to be extracted from the sides
-	//			} else {
-	//				if (PluginApiculture.apiarySideSensitive && (from == ForgeDirection.UP || from == ForgeDirection.DOWN))
-	//					continue;
-	//
-	//				product = StackUtils.createSplitStack(inventory.getStackInSlot(i), 1);
-	//				if (doRemove) {
-	//					inventory.getStackInSlot(i).stackSize--;
-	//					if (inventory.getStackInSlot(i).stackSize <= 0)
-	//						inventory.setInventorySlotContents(i, null);
-	//				}
-	//				break;
-	//			}
-	//		}
-	//
-	//		return new ItemStack[] { product };
-	//	}
-	//
-	//	@Override
-	//	public int addItem(ItemStack stack, boolean doAdd, ForgeDirection from) {
-	//		// Princesses && Queens
-	//		if (ForestryItem.beePrincessGE.isItemEqual(stack) || ForestryItem.beeQueenGE.isItemEqual(stack))
-	//			if (inventory.getStackInSlot(SLOT_QUEEN) == null) {
-	//				if (doAdd) {
-	//					inventory.setInventorySlotContents(SLOT_QUEEN, stack.copy());
-	//					inventory.getStackInSlot(SLOT_QUEEN).stackSize = 1;
-	//				}
-	//
-	//				return 1;
-	//			}
-	//
-	//		// Drones
-	//		if (ForestryItem.beeDroneGE.isItemEqual(stack)) {
-	//
-	//			ItemStack droneStack = inventory.getStackInSlot(SLOT_DRONE);
-	//			if (droneStack == null) {
-	//				if (doAdd)
-	//					inventory.setInventorySlotContents(SLOT_DRONE, stack.copy());
-	//				return stack.stackSize;
-	//			} else {
-	//				if (!droneStack.isItemEqual(stack))
-	//					return 0;
-	//				if (!ItemStack.areItemStackTagsEqual(droneStack, stack))
-	//					return 0;
-	//				int space = droneStack.getMaxStackSize() - droneStack.stackSize;
-	//				if (space <= 0)
-	//					return 0;
-	//
-	//				int added = space > stack.stackSize ? stack.stackSize : space;
-	//				if (doAdd)
-	//					droneStack.stackSize += added;
-	//				return added;
-	//			}
-	//		}
-	//
-	//		return 0;
-	//	}
-
-	/* ITRIGGERPROVIDER */
-	@Optional.Method(modid = "BuildCraftAPI|statements")
-	@Override
-	public Collection<ITriggerExternal> getExternalTriggers(ForgeDirection side, TileEntity tile) {
-		LinkedList<ITriggerExternal> res = new LinkedList<ITriggerExternal>();
-		res.add(ApicultureTriggers.missingQueen);
-		res.add(ApicultureTriggers.missingDrone);
-		res.add(ApicultureTriggers.noFrames);
-		return res;
-	}
-}

src/main/java/forestry/apiculture/gadgets/TileBeehouse.java

@@ -1,440 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.gadgets;
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.inventory.Container;
-import net.minecraft.inventory.ICrafting;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.world.World;
-import net.minecraft.world.biome.BiomeGenBase;
-
-import com.mojang.authlib.GameProfile;
-
-import forestry.api.apiculture.IBee;
-import forestry.api.apiculture.IBeeGenome;
-import forestry.api.apiculture.IBeeHousing;
-import forestry.api.apiculture.IBeekeepingLogic;
-import forestry.api.apiculture.IHiveFrame;
-import forestry.api.core.EnumHumidity;
-import forestry.api.core.EnumTemperature;
-import forestry.api.core.ForestryAPI;
-import forestry.api.genetics.IIndividual;
-import forestry.core.EnumErrorCode;
-import forestry.core.config.Config;
-import forestry.core.config.ForestryItem;
-import forestry.core.gadgets.TileBase;
-import forestry.core.gadgets.TileForestry;
-import forestry.core.interfaces.IClimatised;
-import forestry.core.inventory.IInventoryAdapter;
-import forestry.core.inventory.InvTools;
-import forestry.core.inventory.TileInventoryAdapter;
-import forestry.core.network.GuiId;
-import forestry.core.network.PacketIds;
-import forestry.core.network.PacketInventoryStack;
-import forestry.core.network.PacketTileUpdate;
-import forestry.core.proxy.Proxies;
-import forestry.core.utils.GuiUtil;
-import forestry.core.utils.Utils;
-import forestry.plugins.PluginApiculture;
-
-public class TileBeehouse extends TileBase implements IBeeHousing, IClimatised {
-
-	protected static class BeehouseInventoryAdapter extends TileInventoryAdapter {
-		public BeehouseInventoryAdapter(TileForestry tile, int size, String name) {
-			super(tile, size, name);
-		}
-
-		@Override
-		public boolean canSlotAccept(int slotIndex, ItemStack itemStack) {
-			if (slotIndex == SLOT_QUEEN) {
-				return PluginApiculture.beeInterface.isMember(itemStack) && !PluginApiculture.beeInterface.isDrone(itemStack);
-			} else if (GuiUtil.isIndexInRange(slotIndex, SLOT_FRAMES_1, SLOT_FRAMES_COUNT)) {
-				return itemStack.getItem() instanceof IHiveFrame;
-			} else if (slotIndex == SLOT_DRONE) {
-				return PluginApiculture.beeInterface.isDrone(itemStack);
-			}
-			return false;
-		}
-
-		@Override
-		public boolean canExtractItem(int slotIndex, ItemStack itemstack, int side) {
-			return GuiUtil.isIndexInRange(slotIndex, SLOT_PRODUCT_1, SLOT_PRODUCT_COUNT);
-		}
-	}
-
-	// CONSTANTS
-	public static final int SLOT_QUEEN = 0;
-	public static final int SLOT_DRONE = 1;
-	public static final int SLOT_PRODUCT_1 = 2;
-	public static final int SLOT_PRODUCT_COUNT = 7;
-	public static final int SLOT_FRAMES_1 = 9;
-	public static final int SLOT_FRAMES_2 = 10;
-	public static final int SLOT_FRAMES_3 = 11;
-	public static final int SLOT_FRAMES_COUNT = 3;
-	private final IBeekeepingLogic logic;
-	private BiomeGenBase biome;
-	private int displayHealthMax = 0;
-	private int displayHealth = 0;
-
-	public TileBeehouse() {
-		setHints(Config.hints.get("apiary"));
-		logic = PluginApiculture.beeInterface.createBeekeepingLogic(this);
-		setInternalInventory(new BeehouseInventoryAdapter(this, 12, "Items").disableAutomation());
-	}
-
-	@Override
-	public void openGui(EntityPlayer player, TileBase tile) {
-		player.openGui(ForestryAPI.instance, GuiId.BeehouseGUI.ordinal(), worldObj, xCoord, yCoord, zCoord);
-	}
-
-	/* LOADING & SAVING */
-	@Override
-	public void writeToNBT(NBTTagCompound nbttagcompound) {
-		super.writeToNBT(nbttagcompound);
-
-		nbttagcompound.setInteger("BiomeId", biome.biomeID);
-		if (logic != null) {
-			logic.writeToNBT(nbttagcompound);
-		}
-	}
-
-	@Override
-	public void readFromNBT(NBTTagCompound nbttagcompound) {
-		super.readFromNBT(nbttagcompound);
-
-		int biomeId = nbttagcompound.getInteger("BiomeId");
-		biome = BiomeGenBase.getBiome(biomeId);
-		logic.readFromNBT(nbttagcompound);
-
-	}
-
-	@Override
-	public void initialize() {
-		super.initialize();
-		updateBiome();
-	}
-
-	@Override
-	public void validate() {
-		updateBiome();
-	}
-
-	/* ICLIMATISED */
-	@Override
-	public boolean isClimatized() {
-		return true;
-	}
-
-	@Override
-	public EnumTemperature getTemperature() {
-		return EnumTemperature.getFromBiome(biome);
-	}
-
-	@Override
-	public EnumHumidity getHumidity() {
-		return EnumHumidity.getFromValue(getExactHumidity());
-	}
-
-	@Override
-	public float getExactTemperature() {
-		return biome.temperature;
-	}
-
-	@Override
-	public float getExactHumidity() {
-		return biome.rainfall;
-	}
-
-	/* UPDATING */
-	@Override
-	public void updateClientSide() {
-
-		// / Multiplayer FX
-		if (PluginApiculture.beeInterface.isMated(getInternalInventory().getStackInSlot(SLOT_QUEEN))) {
-			if (getErrorState() == EnumErrorCode.OK && updateOnInterval(2)) {
-				IBee displayQueen = PluginApiculture.beeInterface.getMember(getInternalInventory().getStackInSlot(SLOT_QUEEN));
-				displayQueen.doFX(logic.getEffectData(), this);
-			}
-		}
-
-	}
-
-	@Override
-	public void updateServerSide() {
-
-		logic.update();
-
-		IBee queen = logic.getQueen();
-		if (queen == null) {
-			return;
-		}
-
-		// Add swarm effects
-		if (updateOnInterval(200)) {
-			onQueenChange(getInternalInventory().getStackInSlot(SLOT_QUEEN));
-		}
-	}
-
-	// @Override
-	public boolean isWorking() {
-		return getErrorState() == EnumErrorCode.OK;
-	}
-
-	@Override
-	public boolean addProduct(ItemStack product, boolean all) {
-		return InvTools.tryAddStack(getInternalInventory(), product, SLOT_PRODUCT_1, SLOT_PRODUCT_COUNT, all, true);
-	}
-
-	/* NETWORK SYNCH */
-	@Override
-	public void onQueenChange(ItemStack queenStack) {
-		if (!Proxies.common.isSimulating(worldObj)) {
-			return;
-		}
-
-		Proxies.net.sendNetworkPacket(new PacketInventoryStack(PacketIds.IINVENTORY_STACK, xCoord, yCoord, zCoord, SLOT_QUEEN, queenStack), xCoord, yCoord,
-				zCoord);
-		Proxies.net.sendNetworkPacket(new PacketTileUpdate(this), xCoord, yCoord, zCoord);
-	}
-
-	/* STATE INFORMATION */
-	private int getHealthDisplay() {
-		IInventoryAdapter inventory = getInternalInventory();
-		if (inventory.getStackInSlot(SLOT_QUEEN) == null) {
-			return 0;
-		}
-
-		if (ForestryItem.beeQueenGE.isItemEqual(inventory.getStackInSlot(SLOT_QUEEN))) {
-			return PluginApiculture.beeInterface.getMember(inventory.getStackInSlot(SLOT_QUEEN)).getHealth();
-		} else if (ForestryItem.beePrincessGE.isItemEqual(inventory.getStackInSlot(SLOT_QUEEN))) {
-			return displayHealth;
-		} else {
-			return 0;
-		}
-	}
-
-	private int getMaxHealthDisplay() {
-		IInventoryAdapter inventory = getInternalInventory();
-		if (inventory.getStackInSlot(SLOT_QUEEN) == null) {
-			return 0;
-		}
-
-		if (ForestryItem.beeQueenGE.isItemEqual(inventory.getStackInSlot(SLOT_QUEEN))) {
-			return PluginApiculture.beeInterface.getMember(inventory.getStackInSlot(SLOT_QUEEN)).getMaxHealth();
-		} else if (ForestryItem.beePrincessGE.isItemEqual(inventory.getStackInSlot(SLOT_QUEEN))) {
-			return displayHealthMax;
-		} else {
-			return 0;
-		}
-	}
-
-	/**
-	 * Returns scaled queen health or breeding progress
-	 */
-	public int getHealthScaled(int i) {
-		if (getMaxHealthDisplay() == 0) {
-			return 0;
-		}
-
-		return (getHealthDisplay() * i) / getMaxHealthDisplay();
-	}
-
-	public int getTemperatureScaled(int i) {
-		return Math.round(i * (getExactTemperature() / 2));
-	}
-
-	public int getHumidityScaled(int i) {
-		return Math.round(i * getExactHumidity());
-	}
-
-	public void updateBiome() {
-		if (worldObj != null) {
-			BiomeGenBase biome = Utils.getBiomeAt(worldObj, xCoord, zCoord);
-			if (biome != null) {
-				this.biome = biome;
-				setErrorState(EnumErrorCode.OK);
-			}
-		}
-	}
-
-	/* SMP */
-	// @Override
-	public void getGUINetworkData(int i, int j) {
-		if (logic == null) {
-			return;
-		}
-
-		switch (i) {
-			case 0:
-				displayHealth = j;
-				break;
-			case 1:
-				displayHealthMax = j;
-				break;
-		}
-	}
-
-	// @Override
-	public void sendGUINetworkData(Container container, ICrafting iCrafting) {
-		if (logic == null) {
-			return;
-		}
-
-		iCrafting.sendProgressBarUpdate(container, 0, logic.getBreedingTime());
-		iCrafting.sendProgressBarUpdate(container, 1, logic.getTotalBreedingTime());
-	}
-
-	// / IBEEHOUSING
-	@Override
-	public int getXCoord() {
-		return xCoord;
-	}
-
-	@Override
-	public int getYCoord() {
-		return yCoord;
-	}
-
-	@Override
-	public int getZCoord() {
-		return zCoord;
-	}
-
-	@Override
-	public int getBiomeId() {
-		return biome.biomeID;
-	}
-
-	@Override
-	public BiomeGenBase getBiome() {
-		return biome;
-	}
-
-	@Override
-	public ItemStack getQueen() {
-		return getStackInSlot(SLOT_QUEEN);
-	}
-
-	@Override
-	public ItemStack getDrone() {
-		return getStackInSlot(SLOT_DRONE);
-	}
-
-	@Override
-	public void setQueen(ItemStack itemstack) {
-		setInventorySlotContents(SLOT_QUEEN, itemstack);
-	}
-
-	@Override
-	public void setDrone(ItemStack itemstack) {
-		setInventorySlotContents(SLOT_DRONE, itemstack);
-	}
-
-	@Override
-	public World getWorld() {
-		return worldObj;
-	}
-
-	@Override
-	public void setErrorState(int state) {
-		setErrorState(EnumErrorCode.values()[state]);
-	}
-
-	@Override
-	public int getErrorOrdinal() {
-		return getErrorState().getID();
-	}
-
-	@Override
-	public boolean canBreed() {
-		return true;
-	}
-
-	@Override
-	public float getTerritoryModifier(IBeeGenome genome, float currentModifier) {
-		return 1.0f;
-	}
-
-	@Override
-	public float getProductionModifier(IBeeGenome genome, float currentModifier) {
-		return 0.25f;
-	}
-
-	@Override
-	public float getMutationModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
-		return 0.0f;
-	}
-
-	@Override
-	public float getLifespanModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
-		return 3.0f;
-	}
-
-	@Override
-	public float getFloweringModifier(IBeeGenome genome, float currentModifier) {
-		return 3.0f;
-	}
-
-	@Override
-	public float getGeneticDecay(IBeeGenome genome, float currentModifier) {
-		return 0.0f;
-	}
-
-	@Override
-	public void wearOutEquipment(int amount) {
-	}
-
-	@Override
-	public boolean isSealed() {
-		return false;
-	}
-
-	@Override
-	public boolean isSelfLighted() {
-		return false;
-	}
-
-	@Override
-	public boolean isSunlightSimulated() {
-		return false;
-	}
-
-	@Override
-	public boolean isHellish() {
-		return false;
-	}
-
-	@Override
-	public void onQueenDeath(IBee queen) {
-	}
-
-	@Override
-	public void onPostQueenDeath(IBee queen) {
-	}
-
-	@Override
-	public boolean onPollenRetrieved(IBee queen, IIndividual pollen, boolean isHandled) {
-		return false;
-	}
-
-	@Override
-	public boolean onEggLaid(IBee queen) {
-		return false;
-	}
-
-	/* IHousing */
-	@Override
-	public GameProfile getOwnerName() {
-		return this.getOwnerProfile();
-	}
-}

src/main/java/forestry/apiculture/genetics/AlleleBeeSpecies.java

@@ -1,251 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.genetics;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Locale;
-
-import net.minecraft.client.renderer.texture.IIconRegister;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.IIcon;
-import net.minecraft.world.World;
-
-import com.mojang.authlib.GameProfile;
-
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
-
-import forestry.api.apiculture.EnumBeeChromosome;
-import forestry.api.apiculture.EnumBeeType;
-import forestry.api.apiculture.IAlleleBeeSpecies;
-import forestry.api.apiculture.IBeeGenome;
-import forestry.api.apiculture.IBeeHousing;
-import forestry.api.apiculture.IBeeRoot;
-import forestry.api.core.IIconProvider;
-import forestry.api.genetics.AlleleManager;
-import forestry.api.genetics.IAllele;
-import forestry.api.genetics.IClassification;
-import forestry.api.genetics.IIndividual;
-import forestry.api.genetics.IMutation;
-import forestry.core.config.Defaults;
-import forestry.core.genetics.AlleleSpecies;
-import forestry.core.render.TextureManager;
-import forestry.core.utils.StackUtils;
-
-public class AlleleBeeSpecies extends AlleleSpecies implements IAlleleBeeSpecies, IIconProvider {
-
-	public IJubilanceProvider jubilanceProvider;
-
-	private final IBeeRoot root;
-
-	private final HashMap<ItemStack, Integer> products = new HashMap<ItemStack, Integer>();
-	private final HashMap<ItemStack, Integer> specialty = new HashMap<ItemStack, Integer>();
-
-	private String texture;
-	private final int primaryColour;
-	private final int secondaryColour;
-
-	private static final String iconType = "default";
-
-	public AlleleBeeSpecies(String uid, boolean dominant, String name, IClassification branch, int primaryColor, int secondaryColor) {
-		this(uid, dominant, name, branch, null, primaryColor, secondaryColor);
-	}
-
-	public AlleleBeeSpecies(String uid, boolean dominant, String name, IClassification branch, String binomial, int primaryColor, int secondaryColor) {
-		this(uid, dominant, name, branch, binomial, primaryColor, secondaryColor, new JubilanceDefault());
-	}
-
-	public AlleleBeeSpecies(String uid, boolean dominant, String name, IClassification branch, String binomial, int primaryColor, int secondaryColor,
-			IJubilanceProvider jubilanceProvider) {
-		super(uid, dominant, name, branch, binomial);
-
-		this.root = (IBeeRoot) AlleleManager.alleleRegistry.getSpeciesRoot("rootBees");
-		this.primaryColour = primaryColor;
-		this.secondaryColour = secondaryColor;
-		this.jubilanceProvider = jubilanceProvider;
-		texture = Defaults.TEXTURE_PATH_ENTITIES + "/bees/honeyBee.png";
-	}
-
-	@Override
-	public IBeeRoot getRoot() {
-		return root;
-	}
-
-	public AlleleBeeSpecies setEntityTexture(String texture) {
-		this.texture = Defaults.TEXTURE_PATH_ENTITIES + "/bees/" + texture + ".png";
-		return this;
-	}
-
-	public AlleleBeeSpecies addProduct(ItemStack product, int chance) {
-		if (product == null || product.getItem() == null) {
-			throw new IllegalArgumentException("Tried to add null product");
-		}
-		this.products.put(product, chance);
-		return this;
-	}
-
-	public AlleleBeeSpecies addSpecialty(ItemStack specialty, int chance) {
-		this.specialty.put(specialty, chance);
-		return this;
-	}
-
-	public AlleleBeeSpecies setJubilanceProvider(IJubilanceProvider provider) {
-		this.jubilanceProvider = provider;
-		return this;
-	}
-
-	/* RESEARCH */
-	@Override
-	public int getComplexity() {
-		return 1 + getGeneticAdvancement(this, new ArrayList<IAllele>());
-	}
-
-	private int getGeneticAdvancement(IAllele species, ArrayList<IAllele> exclude) {
-
-		int own = 1;
-		int highest = 0;
-		exclude.add(species);
-
-		for (IMutation mutation : getRoot().getPaths(species, EnumBeeChromosome.SPECIES)) {
-			if (!exclude.contains(mutation.getAllele0())) {
-				int otherAdvance = getGeneticAdvancement(mutation.getAllele0(), exclude);
-				if (otherAdvance > highest) {
-					highest = otherAdvance;
-				}
-			}
-			if (!exclude.contains(mutation.getAllele1())) {
-				int otherAdvance = getGeneticAdvancement(mutation.getAllele1(), exclude);
-				if (otherAdvance > highest) {
-					highest = otherAdvance;
-				}
-			}
-		}
-
-		return own + (highest < 0 ? 0 : highest);
-	}
-
-	@Override
-	public float getResearchSuitability(ItemStack itemstack) {
-		if (itemstack == null) {
-			return 0f;
-		}
-
-		for (ItemStack stack : products.keySet()) {
-			if (stack.isItemEqual(itemstack)) {
-				return 1.0f;
-			}
-		}
-		for (ItemStack stack : specialty.keySet()) {
-			if (stack.isItemEqual(itemstack)) {
-				return 1.0f;
-			}
-		}
-
-		return super.getResearchSuitability(itemstack);
-	}
-
-	@Override
-	public ItemStack[] getResearchBounty(World world, GameProfile researcher, IIndividual individual, int bountyLevel) {
-		ArrayList<ItemStack> bounty = new ArrayList<ItemStack>();
-		Collections.addAll(bounty, super.getResearchBounty(world, researcher, individual, bountyLevel));
-
-		if (bountyLevel > 10) {
-			for (ItemStack stack : specialty.keySet()) {
-				bounty.add(StackUtils.copyWithRandomSize(stack, (int) ((float) bountyLevel / 2), world.rand));
-			}
-		}
-		for (ItemStack stack : products.keySet()) {
-			bounty.add(StackUtils.copyWithRandomSize(stack, (int) ((float) bountyLevel / 2), world.rand));
-		}
-		return bounty.toArray(new ItemStack[bounty.size()]);
-	}
-
-	/* OTHER */
-	@Override
-	public boolean isNocturnal() {
-		return false;
-	}
-
-	@Override
-	public HashMap<ItemStack, Integer> getProducts() {
-		return products;
-	}
-
-	@Override
-	public HashMap<ItemStack, Integer> getSpecialty() {
-		return specialty;
-	}
-
-	@Override
-	public boolean isJubilant(IBeeGenome genome, IBeeHousing housing) {
-		return jubilanceProvider.isJubilant(this, genome, housing);
-	}
-
-	@Override
-	public String getEntityTexture() {
-		return texture;
-	}
-
-	@Override
-	public int getIconColour(int renderPass) {
-		if (renderPass == 0) {
-			return primaryColour;
-		}
-		if (renderPass == 1) {
-			return secondaryColour;
-		}
-		return 0xffffff;
-	}
-
-	@SideOnly(Side.CLIENT)
-	private static IIcon[][] icons;
-
-	@SideOnly(Side.CLIENT)
-	@Override
-	public void registerIcons(IIconRegister register) {
-		icons = new IIcon[EnumBeeType.values().length][3];
-
-		IIcon body1 = TextureManager.getInstance().registerTex(register, "bees/" + iconType + "/body1");
-
-		for (int i = 0; i < EnumBeeType.values().length; i++) {
-			if (EnumBeeType.values()[i] == EnumBeeType.NONE) {
-				continue;
-			}
-
-			icons[i][0] = TextureManager.getInstance().registerTex(register, "bees/" + iconType + "/" + EnumBeeType.values()[i].toString().toLowerCase(Locale.ENGLISH) + ".outline");
-			icons[i][1] = (EnumBeeType.values()[i] != EnumBeeType.LARVAE) ? body1
-					: TextureManager.getInstance().registerTex(register, "bees/" + iconType + "/" + EnumBeeType.values()[i].toString().toLowerCase(Locale.ENGLISH) + ".body");
-			icons[i][2] = TextureManager.getInstance().registerTex(register, "bees/" + iconType + "/" + EnumBeeType.values()[i].toString().toLowerCase(Locale.ENGLISH) + ".body2");
-		}
-
-	}
-
-	@Override
-	@SideOnly(Side.CLIENT)
-	public IIcon getIcon(EnumBeeType type, int renderPass) {
-		return icons[type.ordinal()][renderPass];
-	}
-
-	@Override
-	@SideOnly(Side.CLIENT)
-	public IIconProvider getIconProvider() {
-		return this;
-	}
-
-	@Override
-	@SideOnly(Side.CLIENT)
-	public IIcon getIcon(short texUID) {
-		return null;
-	}
-
-}

src/main/java/forestry/apiculture/genetics/AlleleEffectAggressive.java

@@ -1,72 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.genetics;
-
-import java.util.List;
-
-import net.minecraft.entity.EntityLivingBase;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.util.AxisAlignedBB;
-import net.minecraft.util.DamageSource;
-
-import forestry.api.apiculture.IBeeGenome;
-import forestry.api.apiculture.IBeeHousing;
-import forestry.api.genetics.IEffectData;
-import forestry.apiculture.items.ItemArmorApiarist;
-import forestry.core.utils.DamageSourceForestry;
-
-public class AlleleEffectAggressive extends AlleleEffectThrottled {
-
-	public static final DamageSource damageSourceBeeAggressive = new DamageSourceForestry("bee.aggressive");
-
-	public AlleleEffectAggressive(String uid) {
-		super(uid, "aggressive", true, 40, false, false);
-	}
-
-	@Override
-	public IEffectData doEffect(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) {
-
-		if (isHalted(storedData, housing)) {
-			return storedData;
-		}
-
-		AxisAlignedBB hurtBox = getBounding(genome, housing, 1.0f);
-		@SuppressWarnings("rawtypes")
-		List list = housing.getWorld().getEntitiesWithinAABB(EntityLivingBase.class, hurtBox);
-
-		for (Object obj : list) {
-			EntityLivingBase entity = (EntityLivingBase) obj;
-
-			int damage = 4;
-
-			// Players are not attacked if they wear a full set of apiarist's
-			// armor.
-			if (entity instanceof EntityPlayer) {
-				int count = ItemArmorApiarist.wearsItems((EntityPlayer) entity, getUID(), true);
-				// Full set, no damage/effect
-				if (count > 3) {
-					continue;
-				} else if (count > 2) {
-					damage = 1;
-				} else if (count > 1) {
-					damage = 2;
-				} else if (count > 0) {
-					damage = 3;
-				}
-			}
-
-			entity.attackEntityFrom(damageSourceBeeAggressive, damage);
-		}
-
-		return storedData;
-	}
-
-}

src/main/java/forestry/apiculture/genetics/AlleleEffectFertile.java

@@ -1,61 +0,0 @@
-package forestry.apiculture.genetics;
-
-import java.util.Random;
-
-import net.minecraft.block.Block;
-import net.minecraft.world.World;
-
-import forestry.api.apiculture.IBeeGenome;
-import forestry.api.apiculture.IBeeHousing;
-import forestry.api.genetics.IEffectData;
-
-public class AlleleEffectFertile extends AlleleEffectThrottled {
-	
-	public static final int MAX_BLOCK_FIND_TRIES = 5;
-
-	public AlleleEffectFertile(String uid) {
-		super(uid, "fertile", false, 6, true, false);
-	}
-
-	@Override
-	public IEffectData doEffect(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) {
-		
-		if (isHalted(storedData, housing)) {
-			return storedData;
-		}
-		
-		World world = housing.getWorld();
-		int territorySize[] = getModifiedArea(genome, housing);
-		
-		int blockX = getRandomOffset(world.rand, housing.getXCoord(), territorySize[0]);
-		int blockZ = getRandomOffset(world.rand, housing.getZCoord(), territorySize[2]);
-		int blockMaxY = housing.getYCoord() + territorySize[1] / 2 + 1;
-		int blockMinY = housing.getYCoord() - (territorySize[1] / 2) - 1;
-		
-		for (int attempt = 0; attempt < MAX_BLOCK_FIND_TRIES; ++attempt) {
-			if (tryTickColumn(world, blockX, blockZ, blockMaxY, blockMinY)) {
-				break;
-			}
-			blockX = getRandomOffset(world.rand, housing.getXCoord(), territorySize[0]);
-			blockZ = getRandomOffset(world.rand, housing.getZCoord(), territorySize[2]);
-		}
-		
-		return storedData;
-	}
-	
-	private int getRandomOffset(Random random, int centrePos, int offset) {
-		return centrePos + random.nextInt(offset) - (offset / 2);
-	}
-
-	private boolean tryTickColumn(World world, int x, int z, int maxY, int minY) {
-		for (int y = maxY; y >= minY; --y) {
-			if (!world.isAirBlock(x, y, z)) {
-				Block block = world.getBlock(x, y, z);
-				world.scheduleBlockUpdate(x, y, z, block, 5);
-				return true;
-			}
-		}
-		return false;
-	}
-
-}

src/main/java/forestry/apiculture/genetics/AlleleEffectIgnition.java

@@ -1,98 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.genetics;
-
-import java.util.List;
-
-import net.minecraft.entity.EntityLivingBase;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.util.AxisAlignedBB;
-import net.minecraft.world.World;
-
-import forestry.api.apiculture.IBeeGenome;
-import forestry.api.apiculture.IBeeHousing;
-import forestry.api.genetics.IEffectData;
-import forestry.apiculture.items.ItemArmorApiarist;
-import forestry.plugins.PluginApiculture;
-
-public class AlleleEffectIgnition extends AlleleEffectThrottled {
-
-	private static final int ignitionChance = 50;
-	private static final int fireDuration = 500;
-
-	public AlleleEffectIgnition(String uid) {
-		super(uid, "ignition", false, 20, false, true);
-	}
-
-	@Override
-	public IEffectData doEffect(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) {
-
-		World world = housing.getWorld();
-
-		if (isHalted(storedData, housing)) {
-			return storedData;
-		}
-
-		AxisAlignedBB hurtBox = getBounding(genome, housing, 1.0f);
-		@SuppressWarnings("rawtypes")
-		List list = world.getEntitiesWithinAABB(EntityLivingBase.class, hurtBox);
-
-		for (Object obj : list) {
-			EntityLivingBase entity = (EntityLivingBase) obj;
-
-			int chance = ignitionChance;
-			int duration = fireDuration;
-
-			// Players are not attacked if they wear a full set of apiarist's
-			// armor.
-			if (entity instanceof EntityPlayer) {
-				int count = ItemArmorApiarist.wearsItems((EntityPlayer) entity, getUID(), true);
-				// Full set, no damage/effect
-				if (count > 3) {
-					continue;
-				} else if (count > 2) {
-					chance = 5;
-					duration = 50;
-				} else if (count > 1) {
-					chance = 20;
-					duration = 200;
-				} else if (count > 0) {
-					chance = 35;
-					duration = 350;
-				}
-			}
-
-			if (world.rand.nextInt(1000) >= chance) {
-				continue;
-			}
-
-			entity.setFire(duration);
-		}
-
-		return storedData;
-	}
-
-	@Override
-	public IEffectData doFX(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) {
-
-		int[] area = getModifiedArea(genome, housing);
-
-		if (housing.getWorld().rand.nextBoolean()) {
-			PluginApiculture.proxy.addBeeHiveFX("particles/swarm_bee", housing.getWorld(), housing.getXCoord(), housing.getYCoord(),
-					housing.getZCoord(), genome.getPrimary().getIconColour(0), area[0], area[1], area[2]);
-		} else {
-			PluginApiculture.proxy.addBeeHiveFX("particles/ember", housing.getWorld(), housing.getXCoord(), housing.getYCoord(),
-					housing.getZCoord(), 0xffffff, area[0], area[1], area[2]);
-		}
-		return storedData;
-	}
-
-}

src/main/java/forestry/apiculture/genetics/AlleleEffectMiasmic.java

@@ -1,93 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.genetics;
-
-import java.util.List;
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.potion.Potion;
-import net.minecraft.potion.PotionEffect;
-import net.minecraft.util.AxisAlignedBB;
-import net.minecraft.world.World;
-
-import forestry.api.apiculture.IBeeGenome;
-import forestry.api.apiculture.IBeeHousing;
-import forestry.api.genetics.IEffectData;
-import forestry.apiculture.items.ItemArmorApiarist;
-import forestry.plugins.PluginApiculture;
-
-public class AlleleEffectMiasmic extends AlleleEffectThrottled {
-
-	private static final int infectionChance = 50;
-
-	public AlleleEffectMiasmic(String uid) {
-		super(uid, "misasmic", false, 50, false, false);
-	}
-
-	@Override
-	public IEffectData doEffect(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) {
-
-		World world = housing.getWorld();
-
-		if (isHalted(storedData, housing)) {
-			return storedData;
-		}
-
-		AxisAlignedBB infectionBox = getBounding(genome, housing, 1.0f);
-		@SuppressWarnings("rawtypes")
-		List list = world.getEntitiesWithinAABB(EntityPlayer.class, infectionBox);
-
-		for (Object obj : list) {
-
-			if (world.rand.nextInt(1000) >= infectionChance) {
-				continue;
-			}
-
-			EntityPlayer player = (EntityPlayer) obj;
-
-			int duration = 800;
-
-			// Players are not attacked if they wear a full set of apiarist's
-			// armor.
-			int count = ItemArmorApiarist.wearsItems(player, getUID(), true);
-			// Full set, no damage/effect
-			if (count > 3) {
-				continue;
-			} else if (count > 2) {
-				duration = 200;
-			} else if (count > 1) {
-				duration = 400;
-			} else if (count > 0) {
-				duration = 600;
-			}
-
-			player.addPotionEffect(new PotionEffect(Potion.poison.id, duration, 0));
-		}
-
-		return storedData;
-	}
-
-	@Override
-	public IEffectData doFX(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) {
-
-		int[] area = getModifiedArea(genome, housing);
-
-		if (housing.getWorld().rand.nextBoolean()) {
-			PluginApiculture.proxy.addBeeHiveFX("particles/swarm_bee", housing.getWorld(), housing.getXCoord(), housing.getYCoord(),
-					housing.getZCoord(), genome.getPrimary().getIconColour(0), area[0], area[1], area[2]);
-		} else {
-			PluginApiculture.proxy.addBeeHiveFX("particles/poison", housing.getWorld(), housing.getXCoord(), housing.getYCoord(),
-					housing.getZCoord(), 0xffffff, area[0], area[1], area[2]);
-		}
-		return storedData;
-	}
-
-}

src/main/java/forestry/apiculture/genetics/AlleleEffectNone.java

@@ -1,75 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.genetics;
-
-import net.minecraft.world.World;
-
-import forestry.api.apiculture.IAlleleBeeEffect;
-import forestry.api.apiculture.IBeeGenome;
-import forestry.api.apiculture.IBeeHousing;
-import forestry.api.genetics.IEffectData;
-import forestry.core.genetics.Allele;
-import forestry.plugins.PluginApiculture;
-
-public class AlleleEffectNone extends Allele implements IAlleleBeeEffect {
-
-	public AlleleEffectNone(String uid) {
-		super(uid, true);
-	}
-
-	@Override
-	public IEffectData validateStorage(IEffectData storedData) {
-		return null;
-	}
-
-	@Override
-	public boolean isCombinable() {
-		return false;
-	}
-
-	@Override
-	public IEffectData doEffect(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) {
-		return doEffect(genome, storedData, housing.getWorld(), housing.getBiomeId(), housing.getXCoord(), housing.getYCoord(), housing.getZCoord());
-	}
-
-	protected IEffectData doEffect(IBeeGenome genome, IEffectData storedData, World world, int biomeid, int x, int y, int z) {
-		return storedData;
-	}
-
-	@Override
-	public String getUnlocalizedName() {
-		return "apiculture.effect.none";
-	}
-
-	@Override
-	public IEffectData doFX(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) {
-
-		int[] area = genome.getTerritory();
-		area[0] *= housing.getTerritoryModifier(genome, 1f);
-		area[1] *= housing.getTerritoryModifier(genome, 1f);
-		area[2] *= housing.getTerritoryModifier(genome, 1f);
-
-		if (area[0] < 1) {
-			area[0] = 1;
-		}
-		if (area[1] < 1) {
-			area[1] = 1;
-		}
-		if (area[2] < 1) {
-			area[2] = 1;
-		}
-
-		PluginApiculture.proxy.addBeeHiveFX("particles/swarm_bee", housing.getWorld(), housing.getXCoord(), housing.getYCoord(),
-				housing.getZCoord(), genome.getPrimary().getIconColour(0), area[0], area[1], area[2]);
-		return storedData;
-	}
-
-}

src/main/java/forestry/apiculture/genetics/AlleleEffectPotion.java

@@ -1,89 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.genetics;
-
-import java.util.List;
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.potion.Potion;
-import net.minecraft.potion.PotionEffect;
-import net.minecraft.util.AxisAlignedBB;
-
-import cpw.mods.fml.relauncher.ReflectionHelper;
-
-import forestry.api.apiculture.IBeeGenome;
-import forestry.api.apiculture.IBeeHousing;
-import forestry.api.genetics.IEffectData;
-import forestry.apiculture.items.ItemArmorApiarist;
-import forestry.core.proxy.Proxies;
-
-public class AlleleEffectPotion extends AlleleEffectThrottled {
-
-	private final Potion potion;
-	private final boolean isBadEffect;
-	private final int duration;
-
-	public AlleleEffectPotion(String uid, String name, boolean isDominant, Potion potion, int duration, boolean requiresWorking) {
-		super(uid, name, isDominant, 200, requiresWorking, false);
-		this.potion = potion;
-		this.isBadEffect = isBadEffect(potion);
-		this.duration = duration;
-	}
-
-	@Override
-	public IEffectData doEffect(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) {
-
-		if (isHalted(storedData, housing)) {
-			return storedData;
-		}
-
-		AxisAlignedBB beatifyBox = getBounding(genome, housing, 1.0f);
-		List list = housing.getWorld().getEntitiesWithinAABB(EntityPlayer.class, beatifyBox);
-
-		for (Object entity : list) {
-			if (!(entity instanceof EntityPlayer)) {
-				continue;
-			}
-
-			EntityPlayer player = (EntityPlayer) entity;
-
-			int dur = this.duration;
-			if (isBadEffect) {
-				// Players are not attacked if they wear a full set of apiarist's armor.
-				int count = ItemArmorApiarist.wearsItems((EntityPlayer) entity, getUID(), true);
-				if (count >= 4) {
-					continue; // Full set, no damage/effect
-				} else if (count == 3) {
-					dur = this.duration / 4;
-				} else if (count == 2) {
-					dur = this.duration / 2;
-				} else if (count == 1) {
-					dur = this.duration * 3 / 4;
-				}
-			}
-
-			player.addPotionEffect(new PotionEffect(potion.getId(), dur, 0));
-		}
-
-		return storedData;
-	}
-
-	//FIXME: remove when Potion.isBadEffect() is available server-side
-	private static boolean isBadEffect(Potion potion) {
-		try {
-			return (Boolean) ReflectionHelper.getPrivateValue(Potion.class, potion, "field_76418_K", "isBadEffect");
-		} catch (ReflectionHelper.UnableToFindFieldException e) {
-			Proxies.log.severe("Could not access potion field isBadEffect.");
-			return false;
-		}
-	}
-
-}

src/main/java/forestry/apiculture/genetics/AlleleEffectRadioactive.java

@@ -1,134 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.genetics;
-
-import java.util.List;
-import java.util.Random;
-
-import net.minecraft.block.Block;
-import net.minecraft.entity.EntityLivingBase;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.tileentity.TileEntity;
-import net.minecraft.util.AxisAlignedBB;
-import net.minecraft.util.DamageSource;
-import net.minecraft.world.World;
-
-import forestry.api.apiculture.IBeeGenome;
-import forestry.api.apiculture.IBeeHousing;
-import forestry.api.genetics.IEffectData;
-import forestry.apiculture.gadgets.BlockAlveary;
-import forestry.apiculture.gadgets.TileAlveary;
-import forestry.apiculture.items.ItemArmorApiarist;
-import forestry.core.utils.DamageSourceForestry;
-import forestry.core.vect.Vect;
-
-public class AlleleEffectRadioactive extends AlleleEffectThrottled {
-
-	public static final DamageSource damageSourceBeeRadioactive = new DamageSourceForestry("bee.radioactive");
-
-	public AlleleEffectRadioactive(String uid) {
-		super(uid, "radioactive", true, 40, false, true);
-	}
-
-	@Override
-	public IEffectData doEffect(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) {
-
-		World world = housing.getWorld();
-
-		if (isHalted(storedData, housing)) {
-			return storedData;
-		}
-
-		int[] areaAr = genome.getTerritory();
-		Vect area = new Vect(areaAr[0] * 2, areaAr[1] * 2, areaAr[2] * 2);
-		Vect offset = new Vect(-Math.round(area.x / 2), -Math.round(area.y / 2), -Math.round(area.z / 2));
-
-		// Radioactivity hurts players and mobs
-		Vect min = new Vect(housing.getXCoord() + offset.x, housing.getYCoord() + offset.y, housing.getZCoord() + offset.z);
-		Vect max = new Vect(housing.getXCoord() + offset.x + area.x, housing.getYCoord() + offset.y + area.y, housing.getZCoord() + offset.z + area.z);
-
-		AxisAlignedBB hurtBox = AxisAlignedBB.getBoundingBox(min.x, min.y, min.z, max.x, max.y, max.z);
-
-		@SuppressWarnings("rawtypes")
-		List list = housing.getWorld().getEntitiesWithinAABB(EntityLivingBase.class, hurtBox);
-
-		for (Object obj : list) {
-			EntityLivingBase entity = (EntityLivingBase) obj;
-
-			int damage = 8;
-
-			// Players are not attacked if they wear a full set of apiarist's
-			// armor.
-			if (entity instanceof EntityPlayer) {
-				int count = ItemArmorApiarist.wearsItems((EntityPlayer) entity, getUID(), true);
-				// Full set, no damage/effect
-				if (count > 3) {
-					continue;
-				} else if (count > 2) {
-					damage = 1;
-				} else if (count > 1) {
-					damage = 2;
-				} else if (count > 0) {
-					damage = 3;
-				}
-			}
-
-			entity.attackEntityFrom(damageSourceBeeRadioactive, damage);
-
-		}
-
-		Random rand = housing.getWorld().rand;
-		// Radioactivity destroys environment
-		for (int i = 0; i < 20; i++) {
-
-			Vect randomPos = new Vect(rand.nextInt(area.x), rand.nextInt(area.y), rand.nextInt(area.z));
-
-			Vect posBlock = randomPos.add(new Vect(housing.getXCoord(), housing.getYCoord(), housing.getZCoord()));
-			posBlock = posBlock.add(offset);
-
-			if (posBlock.y <= 1 || posBlock.y >= housing.getWorld().getActualHeight()) {
-				continue;
-			}
-
-			// Don't destroy ourself and blocks below us.
-			if (posBlock.x == housing.getXCoord() && posBlock.z == housing.getZCoord() && posBlock.y <= housing.getYCoord()) {
-				continue;
-			}
-
-			if (world.isAirBlock(posBlock.x, posBlock.y, posBlock.z)) {
-				continue;
-			}
-
-			Block block = world.getBlock(posBlock.x, posBlock.y, posBlock.z);
-
-			if (block instanceof BlockAlveary) {
-				continue;
-			}
-
-			TileEntity tile = world.getTileEntity(posBlock.x, posBlock.y, posBlock.z);
-			if (tile instanceof IBeeHousing) {
-				continue;
-			}
-			if (tile instanceof TileAlveary) {
-				continue;
-			}
-
-			if (block.getBlockHardness(world, posBlock.x, posBlock.y, posBlock.z) < 0) {
-				continue;
-			}
-
-			world.setBlockToAir(posBlock.x, posBlock.y, posBlock.z);
-			break;
-		}
-
-		return storedData;
-	}
-}

src/main/java/forestry/apiculture/genetics/AlleleEffectSnowing.java

@@ -1,85 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.genetics;
-
-import net.minecraft.init.Blocks;
-import net.minecraft.world.World;
-import net.minecraft.world.biome.BiomeGenBase;
-
-import net.minecraftforge.common.util.ForgeDirection;
-
-import forestry.api.apiculture.IBeeGenome;
-import forestry.api.apiculture.IBeeHousing;
-import forestry.api.core.EnumTemperature;
-import forestry.api.genetics.IEffectData;
-import forestry.core.proxy.Proxies;
-import forestry.core.vect.Vect;
-
-public class AlleleEffectSnowing extends AlleleEffectThrottled {
-
-	public AlleleEffectSnowing(String uid) {
-		super(uid, "snowing", false, 20, true, true);
-	}
-
-	@Override
-	public IEffectData doEffect(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) {
-
-		World world = housing.getWorld();
-
-		if (isHalted(storedData, housing)) {
-			return storedData;
-		}
-
-		EnumTemperature temp = EnumTemperature.getFromValue(BiomeGenBase.getBiome(housing.getBiomeId()).temperature);
-
-		switch (temp) {
-			case HELLISH:
-			case HOT:
-			case WARM:
-				return storedData;
-			default:
-		}
-
-		int[] areaAr = genome.getTerritory();
-		Vect area = new Vect(areaAr[0], areaAr[1], areaAr[2]);
-		Vect offset = new Vect(-Math.round(area.x / 2), -Math.round(area.y / 2), -Math.round(area.z / 2));
-
-		for (int i = 0; i < 1; i++) {
-
-			Vect randomPos = new Vect(world.rand.nextInt(area.x), world.rand.nextInt(area.y), world.rand.nextInt(area.z));
-
-			Vect posBlock = randomPos.add(new Vect(housing.getXCoord(), housing.getYCoord(), housing.getZCoord()));
-			posBlock = posBlock.add(offset);
-
-			// Put snow on the ground
-			if (!world.isSideSolid(posBlock.x, posBlock.y - 1, posBlock.z, ForgeDirection.UP, false)) {
-				continue;
-			}
-
-			if (!world.isAirBlock(posBlock.x, posBlock.y, posBlock.z)) {
-				continue;
-			}
-
-			Proxies.common.setBlockWithNotify(world, posBlock.x, posBlock.y, posBlock.z, Blocks.snow_layer);
-		}
-
-		return storedData;
-	}
-
-	@Override
-	public IEffectData doFX(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) {
-		if (housing.getWorld().rand.nextInt(3) == 0) {
-			int[] area = getModifiedArea(genome, housing);
-			Proxies.render.addSnowFX(housing.getWorld(), housing.getXCoord(), housing.getYCoord(), housing.getZCoord(), genome.getPrimary().getIconColour(0), area[0], area[1], area[2]);
-		}
-		return storedData;
-	}
-}

src/main/java/forestry/apiculture/genetics/AlleleEffectThrottled.java

@@ -1,116 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.genetics;
-
-import net.minecraft.util.AxisAlignedBB;
-
-import forestry.api.apiculture.IAlleleBeeEffect;
-import forestry.api.apiculture.IBeeGenome;
-import forestry.api.apiculture.IBeeHousing;
-import forestry.api.genetics.IEffectData;
-import forestry.core.EnumErrorCode;
-import forestry.core.genetics.Allele;
-import forestry.core.genetics.EffectData;
-import forestry.core.vect.Vect;
-import forestry.plugins.PluginApiculture;
-
-public abstract class AlleleEffectThrottled extends Allele implements IAlleleBeeEffect {
-
-	private boolean isCombinable = false;
-	private final int throttle;
-	private boolean requiresWorkingQueen = false;
-
-	public AlleleEffectThrottled(String uid, String name, boolean isDominant, int throttle, boolean requiresWorking, boolean isCombinable) {
-		super(uid, isDominant);
-		this.name = "apiculture.effect." + name;
-		this.throttle = throttle;
-		this.isCombinable = isCombinable;
-		this.requiresWorkingQueen = requiresWorking;
-	}
-
-	public int getThrottle() {
-		return throttle;
-	}
-
-	@Override
-	public boolean isCombinable() {
-		return isCombinable;
-	}
-
-	@Override
-	public IEffectData validateStorage(IEffectData storedData) {
-		if (storedData instanceof EffectData) {
-			return storedData;
-		}
-
-		return new EffectData(1, 0);
-	}
-
-	public boolean isHalted(IEffectData storedData, IBeeHousing housing) {
-
-		if (requiresWorkingQueen && housing.getErrorState() != EnumErrorCode.OK) {
-			return true;
-		}
-
-		int throt = storedData.getInteger(0);
-		throt++;
-		storedData.setInteger(0, throt);
-
-		if (throt < getThrottle()) {
-			return true;
-		}
-
-		// Reset since we are done throttling.
-		storedData.setInteger(0, 0);
-		return false;
-	}
-
-	@Override
-	public IEffectData doFX(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) {
-
-		int[] area = getModifiedArea(genome, housing);
-
-		PluginApiculture.proxy.addBeeHiveFX("particles/swarm_bee", housing.getWorld(), housing.getXCoord(), housing.getYCoord(),
-				housing.getZCoord(), genome.getPrimary().getIconColour(0), area[0], area[1], area[2]);
-		return storedData;
-	}
-
-	protected int[] getModifiedArea(IBeeGenome genome, IBeeHousing housing) {
-		int[] area = genome.getTerritory();
-		area[0] *= housing.getTerritoryModifier(genome, 1f) * 3;
-		area[1] *= housing.getTerritoryModifier(genome, 1f) * 3;
-		area[2] *= housing.getTerritoryModifier(genome, 1f) * 3;
-
-		if (area[0] < 1) {
-			area[0] = 1;
-		}
-		if (area[1] < 1) {
-			area[1] = 1;
-		}
-		if (area[2] < 1) {
-			area[2] = 1;
-		}
-
-		return area;
-	}
-
-	protected AxisAlignedBB getBounding(IBeeGenome genome, IBeeHousing housing, float modifier) {
-		int[] areaAr = genome.getTerritory();
-		Vect area = new Vect(areaAr[0], areaAr[1], areaAr[2]).multiply(modifier);
-		Vect offset = new Vect(-Math.round(area.x / 2), -Math.round(area.y / 2), -Math.round(area.z / 2));
-
-		// Radioactivity hurts players and mobs
-		Vect min = new Vect(housing.getXCoord() + offset.x, housing.getYCoord() + offset.y, housing.getZCoord() + offset.z);
-		Vect max = new Vect(housing.getXCoord() + offset.x + area.x, housing.getYCoord() + offset.y + area.y, housing.getZCoord() + offset.z + area.z);
-
-		return AxisAlignedBB.getBoundingBox(min.x, min.y, min.z, max.x, max.y, max.z);
-	}
-}

src/main/java/forestry/apiculture/genetics/ApiaristTracker.java

@@ -13,24 +13,19 @@ package forestry.apiculture.genetics;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.nbt.NBTTagCompound;
 
-import com.mojang.authlib.GameProfile;
-
+import forestry.api.apiculture.BeeManager;
 import forestry.api.apiculture.EnumBeeChromosome;
 import forestry.api.apiculture.IApiaristTracker;
 import forestry.api.genetics.IBreedingTracker;
 import forestry.api.genetics.IIndividual;
+import forestry.api.genetics.ISpeciesRoot;
 import forestry.core.genetics.BreedingTracker;
-import forestry.plugins.PluginApiculture;
 
 public class ApiaristTracker extends BreedingTracker implements IApiaristTracker {
 
 	/** Required for creation from map storage */
 	public ApiaristTracker(String s) {
-		this(s, null);
-	}
-
-	public ApiaristTracker(String s, GameProfile player) {
-		super(s, player);
+		super(s);
 	}
 
 	private int queensTotal = 0;
@@ -61,13 +56,16 @@ public class ApiaristTracker extends BreedingTracker implements IApiaristTracker
 
 	@Override
 	public void registerPickup(IIndividual individual) {
-		if (!individual.getGenome().getPrimary().getRoot().getUID().equals(BeeHelper.UID)) {
+		ISpeciesRoot speciesRoot = individual.getGenome().getPrimary().getRoot();
+		if (!speciesRoot.getUID().equals(speciesRootUID())) {
 			return;
 		}
+
 		if (!individual.isPureBred(EnumBeeChromosome.SPECIES)) {
 			return;
 		}
-		if (PluginApiculture.beeInterface.getCombinations(individual.getGenome().getPrimary()).size() > 0) {
+
+		if (speciesRoot.getCombinations(individual.getGenome().getPrimary()).size() > 0) {
 			return;
 		}
 
@@ -109,7 +107,7 @@ public class ApiaristTracker extends BreedingTracker implements IApiaristTracker
 
 	@Override
 	protected IBreedingTracker getBreedingTracker(EntityPlayer player) {
-		return PluginApiculture.beeInterface.getBreedingTracker(player.worldObj, player.getGameProfile());
+		return BeeManager.beeRoot.getBreedingTracker(player.worldObj, player.getGameProfile());
 	}
 
 	@Override

src/main/java/forestry/apiculture/genetics/Bee.java

@@ -11,6 +11,7 @@
 package forestry.apiculture.genetics;
 
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Random;
@@ -20,52 +21,59 @@ import net.minecraft.item.EnumRarity;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ChunkCoordinates;
 import net.minecraft.util.EnumChatFormatting;
 import net.minecraft.world.World;
 import net.minecraft.world.biome.BiomeGenBase;
 
+import com.mojang.authlib.GameProfile;
+
+import forestry.api.apiculture.BeeManager;
 import forestry.api.apiculture.EnumBeeChromosome;
+import forestry.api.apiculture.FlowerManager;
 import forestry.api.apiculture.IAlleleBeeEffect;
 import forestry.api.apiculture.IAlleleBeeSpecies;
 import forestry.api.apiculture.IApiaristTracker;
 import forestry.api.apiculture.IBee;
 import forestry.api.apiculture.IBeeGenome;
 import forestry.api.apiculture.IBeeHousing;
+import forestry.api.apiculture.IBeeModifier;
 import forestry.api.apiculture.IBeeMutation;
 import forestry.api.apiculture.IBeekeepingMode;
 import forestry.api.core.BiomeHelper;
 import forestry.api.core.EnumHumidity;
 import forestry.api.core.EnumTemperature;
+import forestry.api.core.IErrorState;
 import forestry.api.genetics.AlleleManager;
+import forestry.api.genetics.EnumTolerance;
 import forestry.api.genetics.IAllele;
 import forestry.api.genetics.IAlleleTolerance;
 import forestry.api.genetics.IChromosome;
 import forestry.api.genetics.IEffectData;
 import forestry.api.genetics.IFlowerProvider;
-import forestry.api.genetics.IGenome;
 import forestry.api.genetics.IIndividual;
+import forestry.api.genetics.IMutation;
 import forestry.api.genetics.IPollinatable;
-import forestry.arboriculture.genetics.FakePollinatable;
-import forestry.arboriculture.genetics.ICheckPollinatable;
-import forestry.core.EnumErrorCode;
-import forestry.core.config.Defaults;
+import forestry.arboriculture.genetics.pollination.FakePollinatable;
+import forestry.arboriculture.genetics.pollination.ICheckPollinatable;
+import forestry.core.config.Config;
+import forestry.core.config.Constants;
+import forestry.core.errors.EnumErrorCode;
 import forestry.core.genetics.Chromosome;
 import forestry.core.genetics.GenericRatings;
 import forestry.core.genetics.IndividualLiving;
-import forestry.core.proxy.Proxies;
 import forestry.core.utils.GeneticsUtil;
+import forestry.core.utils.Log;
 import forestry.core.utils.StringUtil;
-import forestry.core.vect.MutableVect;
-import forestry.core.vect.Vect;
-import forestry.plugins.PluginApiculture;
+import forestry.core.utils.vect.Vect;
 
 public class Bee extends IndividualLiving implements IBee {
 
-	protected int generation;
-	protected boolean isNatural = true;
+	private int generation;
+	private boolean isNatural = true;
 
-	public IBeeGenome genome;
-	public IBeeGenome mate;
+	private IBeeGenome genome;
+	private IBeeGenome mate;
 
 	/* CONSTRUCTOR */
 	public Bee(NBTTagCompound nbttagcompound) {
@@ -81,7 +89,7 @@ public class Bee extends IndividualLiving implements IBee {
 		this(genome, true, 0);
 	}
 
-	public Bee(IBeeGenome genome, boolean isNatural, int generation) {
+	private Bee(IBeeGenome genome, boolean isNatural, int generation) {
 		super(genome.getLifespan());
 		this.genome = genome;
 		this.isNatural = isNatural;
@@ -93,7 +101,7 @@ public class Bee extends IndividualLiving implements IBee {
 	public void readFromNBT(NBTTagCompound nbttagcompound) {
 
 		if (nbttagcompound == null) {
-			this.genome = PluginApiculture.beeInterface.templateAsGenome(BeeTemplates.getForestTemplate());
+			genome = BeeDefinition.FOREST.getGenome();
 			return;
 		}
 
@@ -108,13 +116,13 @@ public class Bee extends IndividualLiving implements IBee {
 		}
 
 		if (nbttagcompound.hasKey("Genome")) {
-			genome = new BeeGenome(nbttagcompound.getCompoundTag("Genome"));
+			genome = BeeGenome.fromNBT(nbttagcompound.getCompoundTag("Genome"));
 		} else {
-			genome = PluginApiculture.beeInterface.templateAsGenome(BeeTemplates.getForestTemplate());
+			genome = BeeDefinition.FOREST.getGenome();
 		}
 
 		if (nbttagcompound.hasKey("Mate")) {
-			mate = new BeeGenome(nbttagcompound.getCompoundTag("Mate"));
+			mate = BeeGenome.fromNBT(nbttagcompound.getCompoundTag("Mate"));
 		}
 
 	}
@@ -137,11 +145,6 @@ public class Bee extends IndividualLiving implements IBee {
 		this.isNatural = flag;
 	}
 
-	@Override
-	public boolean isIrregularMating() {
-		return false;
-	}
-
 	public boolean isNatural() {
 		return this.isNatural;
 	}
@@ -245,63 +248,97 @@ public class Bee extends IndividualLiving implements IBee {
 	}
 
 	@Override
-	public int isWorking(IBeeHousing housing) {
-		return canWork(housing).ordinal();
-	}
-
-	@Override
-	public EnumErrorCode canWork(IBeeHousing housing) {
-
+	public Set<IErrorState> getCanWork(IBeeHousing housing) {
 		World world = housing.getWorld();
+		BiomeGenBase biome = housing.getBiome();
+
+		Set<IErrorState> errorStates = new HashSet<>();
+
+		IBeeModifier beeModifier = BeeManager.beeRoot.createBeeHousingModifier(housing);
+
 		// / Rain needs tolerant flyers
-		if (world.isRaining() && !genome.getTolerantFlyer() && BiomeHelper.canRainOrSnow(housing.getBiomeId()) && !housing.isSealed()) {
-			return EnumErrorCode.ISRAINING;
+		if (world.isRaining() && BiomeHelper.canRainOrSnow(biome) && !canFlyInRain(beeModifier)) {
+			errorStates.add(EnumErrorCode.IS_RAINING);
 		}
 
 		// / Night or darkness requires nocturnal species
 		if (world.isDaytime()) {
 			if (!canWorkDuringDay()) {
-				return EnumErrorCode.NOTNIGHT;
+				errorStates.add(EnumErrorCode.NOT_NIGHT);
+			}
+		} else {
+			if (!canWorkAtNight(beeModifier)) {
+				errorStates.add(EnumErrorCode.NOT_DAY);
 			}
-		} else if (!canWorkAtNight() && !housing.isSelfLighted()) {
-			return EnumErrorCode.NOTDAY;
 		}
 
-		if (world.getBlockLightValue(housing.getXCoord(), housing.getYCoord() + 2, housing.getZCoord()) > Defaults.APIARY_MIN_LEVEL_LIGHT) {
+		if (housing.getBlockLightValue() > Constants.APIARY_MIN_LEVEL_LIGHT) {
 			if (!canWorkDuringDay()) {
-				return EnumErrorCode.NOTGLOOMY;
+				errorStates.add(EnumErrorCode.NOT_GLOOMY);
+			}
+		} else {
+			if (!canWorkAtNight(beeModifier)) {
+				errorStates.add(EnumErrorCode.NOT_BRIGHT);
 			}
-		} else if (!canWorkAtNight() && !housing.isSelfLighted()) {
-			return EnumErrorCode.NOTLUCID;
 		}
 
-		// / No sky, except if in hell
-		BiomeGenBase biome = BiomeGenBase.getBiome(housing.getBiomeId());
-		if (biome == null) {
-			return EnumErrorCode.NOSKY;
-		}
-		if (!BiomeHelper.isBiomeHellish(biome) && !world.canBlockSeeTheSky(housing.getXCoord(), housing.getYCoord() + 3, housing.getZCoord())
-				&& !genome.getCaveDwelling() && !housing.isSunlightSimulated()) {
-			return EnumErrorCode.NOSKY;
+		// / Check for the sky, except if in hell
+		if (biome != null && !BiomeHelper.isBiomeHellish(biome)) {
+			if (!housing.canBlockSeeTheSky() && !canWorkUnderground(beeModifier)) {
+				errorStates.add(EnumErrorCode.NO_SKY);
+			}
 		}
 
 		// / And finally climate check
-		if (!isSuitableClimate(housing.getTemperature(), housing.getHumidity())) {
-			return EnumErrorCode.INVALIDBIOME;
+		IAlleleBeeSpecies species = genome.getPrimary();
+		{
+			EnumTemperature actualTemperature = housing.getTemperature();
+			EnumTemperature beeBaseTemperature = species.getTemperature();
+			EnumTolerance beeToleranceTemperature = genome.getToleranceTemp();
+
+			if (!AlleleManager.climateHelper.isWithinLimits(actualTemperature, beeBaseTemperature, beeToleranceTemperature)) {
+				if (beeBaseTemperature.ordinal() > actualTemperature.ordinal()) {
+					errorStates.add(EnumErrorCode.TOO_COLD);
+				} else {
+					errorStates.add(EnumErrorCode.TOO_HOT);
+				}
+			}
 		}
 
-		return EnumErrorCode.OK;
+		{
+			EnumHumidity actualHumidity = housing.getHumidity();
+			EnumHumidity beeBaseHumidity = species.getHumidity();
+			EnumTolerance beeToleranceHumidity = genome.getToleranceHumid();
+
+			if (!AlleleManager.climateHelper.isWithinLimits(actualHumidity, beeBaseHumidity, beeToleranceHumidity)) {
+				if (beeBaseHumidity.ordinal() > actualHumidity.ordinal()) {
+					errorStates.add(EnumErrorCode.TOO_ARID);
+				} else {
+					errorStates.add(EnumErrorCode.TOO_HUMID);
+				}
+			}
+		}
+
+		return errorStates;
 	}
 
-	private boolean canWorkAtNight() {
-		return genome.getPrimary().isNocturnal() || genome.getNocturnal();
+	private boolean canWorkAtNight(IBeeModifier beeModifier) {
+		return genome.getPrimary().isNocturnal() || genome.getNocturnal() || beeModifier.isSelfLighted();
 	}
 
 	private boolean canWorkDuringDay() {
 		return !genome.getPrimary().isNocturnal() || genome.getNocturnal();
 	}
 
-	public boolean isSuitableBiome(BiomeGenBase biome) {
+	private boolean canWorkUnderground(IBeeModifier beeModifier) {
+		return genome.getCaveDwelling() || beeModifier.isSunlightSimulated();
+	}
+
+	private boolean canFlyInRain(IBeeModifier beeModifier) {
+		return genome.getTolerantFlyer() || beeModifier.isSealed();
+	}
+
+	private boolean isSuitableBiome(BiomeGenBase biome) {
 		if (biome == null) {
 			return false;
 		}
@@ -317,47 +354,9 @@ public class Bee extends IndividualLiving implements IBee {
 				genome.getPrimary().getHumidity(), genome.getToleranceHumid());
 	}
 
-	@Override
-	public boolean hasFlower(IBeeHousing housing) {
-
-		IFlowerProvider provider = genome.getFlowerProvider();
-
-		Vect housingPos = new Vect(housing.getXCoord(), housing.getYCoord(), housing.getZCoord());
-		Vect area = getArea(genome, housing);
-		Vect offset = new Vect(-area.x / 2, -area.y / 2, -area.z / 2);
-
-		boolean hasFlower = false;
-
-		MutableVect posCurrent = new MutableVect(0, 0, 0);
-		while (posCurrent.advancePositionInArea(area)) {
-
-			Vect posBlock = Vect.add(housingPos, posCurrent, offset);
-
-			if (provider.isAcceptedFlower(housing.getWorld(), this, posBlock.x, posBlock.y, posBlock.z)) {
-				hasFlower = true;
-				break;
-			}
-
-		}
-
-		return hasFlower;
-	}
-
-	@Override
-	public ArrayList<Integer> getSuitableBiomeIds() {
-		ArrayList<Integer> suitableBiomes = new ArrayList<Integer>();
-		for (BiomeGenBase biome : BiomeGenBase.getBiomeGenArray()) {
-			if (isSuitableBiome(biome)) {
-				suitableBiomes.add(biome.biomeID);
-			}
-		}
-
-		return suitableBiomes;
-	}
-
 	@Override
 	public ArrayList<BiomeGenBase> getSuitableBiomes() {
-		ArrayList<BiomeGenBase> suitableBiomes = new ArrayList<BiomeGenBase>();
+		ArrayList<BiomeGenBase> suitableBiomes = new ArrayList<>();
 		for (BiomeGenBase biome : BiomeGenBase.getBiomeGenArray()) {
 			if (isSuitableBiome(biome)) {
 				suitableBiomes.add(biome);
@@ -403,15 +402,15 @@ public class Bee extends IndividualLiving implements IBee {
 		IAlleleTolerance tempToleranceAllele = (IAlleleTolerance) getGenome().getActiveAllele(EnumBeeChromosome.TEMPERATURE_TOLERANCE);
 		IAlleleTolerance humidToleranceAllele = (IAlleleTolerance) getGenome().getActiveAllele(EnumBeeChromosome.HUMIDITY_TOLERANCE);
 
-		String unlocalizedCustomSpeed = "tooltip.worker." + speedAllele.getUnlocalizedName().replaceFirst("gui.", "");
+		String unlocalizedCustomSpeed = "tooltip.worker." + speedAllele.getUnlocalizedName().replaceAll("(.*)\\.", "");
 		String speed;
 		if (StringUtil.canTranslate(unlocalizedCustomSpeed)) {
 			speed = StringUtil.localize(unlocalizedCustomSpeed);
 		} else {
-			speed = speedAllele.getName() + " " + StringUtil.localize("gui.worker");
+			speed = speedAllele.getName() + ' ' + StringUtil.localize("gui.worker");
 		}
 
-		String lifespan = genome.getActiveAllele(EnumBeeChromosome.LIFESPAN).getName() + " " + StringUtil.localize("gui.life");
+		String lifespan = genome.getActiveAllele(EnumBeeChromosome.LIFESPAN).getName() + ' ' + StringUtil.localize("gui.life");
 		String tempTolerance = EnumChatFormatting.GREEN + "T: " + AlleleManager.climateHelper.toDisplay(genome.getPrimary().getTemperature()) + " / " + tempToleranceAllele.getName();
 		String humidTolerance = EnumChatFormatting.GREEN + "H: " + AlleleManager.climateHelper.toDisplay(genome.getPrimary().getHumidity()) + " / " + humidToleranceAllele.getName();
 		String flowers = genome.getFlowerProvider().getDescription();
@@ -425,12 +424,17 @@ public class Bee extends IndividualLiving implements IBee {
 		if (genome.getNocturnal()) {
 			list.add(EnumChatFormatting.RED + GenericRatings.rateActivityTime(genome.getNocturnal(), false));
 		}
+
+		if (genome.getTolerantFlyer()) {
+			list.add(EnumChatFormatting.WHITE + StringUtil.localize("gui.flyer.tooltip"));
+		}
 	}
 
 	@Override
 	public void age(World world, float housingLifespanModifier) {
-		IBeekeepingMode mode = PluginApiculture.beeInterface.getBeekeepingMode(world);
-		float finalModifier = housingLifespanModifier * mode.getLifespanModifier(genome, mate, housingLifespanModifier);
+		IBeekeepingMode mode = BeeManager.beeRoot.getBeekeepingMode(world);
+		IBeeModifier beeModifier = mode.getBeeModifier();
+		float finalModifier = housingLifespanModifier * beeModifier.getLifespanModifier(genome, mate, housingLifespanModifier);
 
 		super.age(world, finalModifier);
 	}
@@ -438,14 +442,14 @@ public class Bee extends IndividualLiving implements IBee {
 	// / PRODUCTION
 	@Override
 	public ItemStack[] getProduceList() {
-		ArrayList<ItemStack> products = new ArrayList<ItemStack>();
+		ArrayList<ItemStack> products = new ArrayList<>();
 
 		IAlleleBeeSpecies primary = genome.getPrimary();
 		IAlleleBeeSpecies secondary = genome.getSecondary();
 
-		products.addAll(primary.getProducts().keySet());
+		products.addAll(primary.getProductChances().keySet());
 
-		Set<ItemStack> secondaryProducts = secondary.getProducts().keySet();
+		Set<ItemStack> secondaryProducts = secondary.getProductChances().keySet();
 		// Remove duplicates
 		for (ItemStack second : secondaryProducts) {
 			boolean skip = false;
@@ -468,27 +472,23 @@ public class Bee extends IndividualLiving implements IBee {
 
 	@Override
 	public ItemStack[] getSpecialtyList() {
-		Set<ItemStack> specialties = genome.getPrimary().getSpecialty().keySet();
+		Set<ItemStack> specialties = genome.getPrimary().getSpecialtyChances().keySet();
 		return specialties.toArray(new ItemStack[specialties.size()]);
 	}
 
 	@Override
 	public ItemStack[] produceStacks(IBeeHousing housing) {
-		if (!hasFlower(housing)) {
-			return null;
-		}
-
 		if (housing == null) {
-			Proxies.log.warning("Failed to produce in an apiary because the beehousing was null.");
+			Log.warning("Failed to produce in an apiary because the beehousing was null.");
 			return null;
 		}
-		IBeekeepingMode mode = PluginApiculture.beeInterface.getBeekeepingMode(housing.getWorld());
+		IBeekeepingMode mode = BeeManager.beeRoot.getBeekeepingMode(housing.getWorld());
 		if (mode == null) {
-			Proxies.log.warning("Failed to produce in an apiary because the beekeeping mode was null.");
+			Log.warning("Failed to produce in an apiary because the beekeeping mode was null.");
 			return null;
 		}
 
-		ArrayList<ItemStack> products = new ArrayList<ItemStack>();
+		List<ItemStack> products = new ArrayList<>();
 
 		IAlleleBeeSpecies primary = genome.getPrimary();
 		IAlleleBeeSpecies secondary = genome.getSecondary();
@@ -498,36 +498,37 @@ public class Bee extends IndividualLiving implements IBee {
 			setIsNatural(false);
 		}
 
+		IBeeModifier beeHousingModifier = BeeManager.beeRoot.createBeeHousingModifier(housing);
+		IBeeModifier beeModeModifier = mode.getBeeModifier();
+
 		// Bee genetic speed * beehousing * beekeeping mode
-		float speed = genome.getSpeed() * housing.getProductionModifier(genome, 1f) * mode.getProductionModifier(genome, 1f);
+		float speed = genome.getSpeed() * beeHousingModifier.getProductionModifier(genome, 1f) * beeModeModifier.getProductionModifier(genome, 1f);
 
 		// / Primary Products
-		for (Map.Entry<ItemStack, Integer> entry : primary.getProducts().entrySet()) {
-			if (housing.getWorld().rand.nextInt(100) < entry.getValue() * speed) {
+		for (Map.Entry<ItemStack, Float> entry : primary.getProductChances().entrySet()) {
+			if (housing.getWorld().rand.nextFloat() < entry.getValue() * speed) {
 				products.add(entry.getKey().copy());
 			}
 		}
 		// / Secondary Products
-		for (Map.Entry<ItemStack, Integer> entry : secondary.getProducts().entrySet()) {
-			if (housing.getWorld().rand.nextInt(100) < Math.round(entry.getValue() / 2) * speed) {
+		for (Map.Entry<ItemStack, Float> entry : secondary.getProductChances().entrySet()) {
+			if (housing.getWorld().rand.nextFloat() < Math.round(entry.getValue() / 2) * speed) {
 				products.add(entry.getKey().copy());
 			}
 		}
 
-		// We are done if the we are not jubilant.
-		if (!primary.isJubilant(genome, housing) || !secondary.isJubilant(genome, housing)) {
-			return products.toArray(new ItemStack[products.size()]);
-		}
-
 		// / Specialty products
-		for (Map.Entry<ItemStack, Integer> entry : primary.getSpecialty().entrySet()) {
-			if (housing.getWorld().rand.nextInt(100) < entry.getValue() * speed) {
-				products.add(entry.getKey().copy());
+		if (primary.isJubilant(genome, housing) && secondary.isJubilant(genome, housing)) {
+			for (Map.Entry<ItemStack, Float> entry : primary.getSpecialtyChances().entrySet()) {
+				if (housing.getWorld().rand.nextFloat() < entry.getValue() * speed) {
+					products.add(entry.getKey().copy());
+				}
 			}
 		}
 
-		return genome.getFlowerProvider().affectProducts(housing.getWorld(), this, housing.getXCoord(), housing.getYCoord(), housing.getZCoord(),
-				products.toArray(new ItemStack[products.size()]));
+		ItemStack[] productsArray = products.toArray(new ItemStack[products.size()]);
+		ChunkCoordinates housingCoordinates = housing.getCoordinates();
+		return genome.getFlowerProvider().affectProducts(housing.getWorld(), this, housingCoordinates.posX, housingCoordinates.posY, housingCoordinates.posZ, productsArray);
 	}
 
 	/* REPRODUCTION */
@@ -540,7 +541,7 @@ public class Bee extends IndividualLiving implements IBee {
 		}
 
 		// Fatigued queens do not produce princesses.
-		if (PluginApiculture.beeInterface.getBeekeepingMode(housing.getWorld()).isFatigued(this, housing)) {
+		if (BeeManager.beeRoot.getBeekeepingMode(housing.getWorld()).isFatigued(this, housing)) {
 			return null;
 		}
 
@@ -557,10 +558,10 @@ public class Bee extends IndividualLiving implements IBee {
 			return null;
 		}
 
-		ArrayList<IBee> bees = new ArrayList<IBee>();
+		List<IBee> bees = new ArrayList<>();
 
-		int toCreate = PluginApiculture.beeInterface.getBeekeepingMode(world).getFinalFertility(this, world, housing.getXCoord(), housing.getYCoord(),
-				housing.getZCoord());
+		ChunkCoordinates housingCoordinates = housing.getCoordinates();
+		int toCreate = BeeManager.beeRoot.getBeekeepingMode(world).getFinalFertility(this, world, housingCoordinates.posX, housingCoordinates.posY, housingCoordinates.posZ);
 
 		if (toCreate <= 0) {
 			toCreate = 1;
@@ -606,42 +607,59 @@ public class Bee extends IndividualLiving implements IBee {
 			}
 		}
 
-		IBeekeepingMode mode = PluginApiculture.beeInterface.getBeekeepingMode(world);
+		IBeekeepingMode mode = BeeManager.beeRoot.getBeekeepingMode(world);
 		return new Bee(new BeeGenome(chromosomes), mode.isNaturalOffspring(this), generation);
 	}
 
-	private IChromosome[] mutateSpecies(IBeeHousing housing, IGenome genomeOne, IGenome genomeTwo) {
+	private static IChromosome[] mutateSpecies(IBeeHousing housing, IBeeGenome genomeOne, IBeeGenome genomeTwo) {
 
 		World world = housing.getWorld();
 
 		IChromosome[] parent1 = genomeOne.getChromosomes();
 		IChromosome[] parent2 = genomeTwo.getChromosomes();
 
-		IGenome genome0;
-		IGenome genome1;
-		IAllele allele0;
-		IAllele allele1;
+		IBeeGenome genome0;
+		IBeeGenome genome1;
+
+		IAlleleBeeSpecies allele0;
+		IAlleleBeeSpecies allele1;
 
 		if (world.rand.nextBoolean()) {
-			allele0 = parent1[EnumBeeChromosome.SPECIES.ordinal()].getPrimaryAllele();
-			allele1 = parent2[EnumBeeChromosome.SPECIES.ordinal()].getSecondaryAllele();
+			allele0 = (IAlleleBeeSpecies) parent1[EnumBeeChromosome.SPECIES.ordinal()].getPrimaryAllele();
+			allele1 = (IAlleleBeeSpecies) parent2[EnumBeeChromosome.SPECIES.ordinal()].getSecondaryAllele();
 
 			genome0 = genomeOne;
 			genome1 = genomeTwo;
 		} else {
-			allele0 = parent2[EnumBeeChromosome.SPECIES.ordinal()].getPrimaryAllele();
-			allele1 = parent1[EnumBeeChromosome.SPECIES.ordinal()].getSecondaryAllele();
+			allele0 = (IAlleleBeeSpecies) parent2[EnumBeeChromosome.SPECIES.ordinal()].getPrimaryAllele();
+			allele1 = (IAlleleBeeSpecies) parent1[EnumBeeChromosome.SPECIES.ordinal()].getSecondaryAllele();
 
 			genome0 = genomeTwo;
 			genome1 = genomeOne;
 		}
 
-		for (IBeeMutation mutation : PluginApiculture.beeInterface.getMutations(true)) {
-			float chance = mutation.getChance(housing, allele0, allele1, genome0, genome1);
+		GameProfile playerProfile = housing.getOwner();
+		IApiaristTracker breedingTracker = BeeManager.beeRoot.getBreedingTracker(world, playerProfile);
+
+		List<IMutation> combinations = BeeManager.beeRoot.getCombinations(allele0, allele1, true);
+		for (IMutation mutation : combinations) {
+			IBeeMutation beeMutation = (IBeeMutation) mutation;
+
+			float chance = beeMutation.getChance(housing, allele0, allele1, genome0, genome1);
+			if (chance <= 0) {
+				continue;
+			}
+
+			// boost chance for researched mutations
+			if (breedingTracker.isResearched(beeMutation)) {
+				float mutationBoost = chance * (Config.researchMutationBoostMultiplier - 1.0f);
+				mutationBoost = Math.min(Config.maxResearchMutationBoostPercent, mutationBoost);
+				chance += mutationBoost;
+			}
+
 			if (chance > world.rand.nextFloat() * 100) {
-				IApiaristTracker breedingTracker = PluginApiculture.beeInterface.getBreedingTracker(world, housing.getOwnerName());
 				breedingTracker.registerMutation(mutation);
-				return PluginApiculture.beeInterface.templateAsChromosomes(mutation.getTemplate());
+				return BeeManager.beeRoot.templateAsChromosomes(mutation.getTemplate());
 			}
 		}
 
@@ -652,7 +670,9 @@ public class Bee extends IndividualLiving implements IBee {
 	@Override
 	public IIndividual retrievePollen(IBeeHousing housing) {
 
-		int chance = Math.round(genome.getFlowering() * housing.getFloweringModifier(getGenome(), 1f));
+		IBeeModifier beeModifier = BeeManager.beeRoot.createBeeHousingModifier(housing);
+
+		int chance = Math.round(genome.getFlowering() * beeModifier.getFloweringModifier(getGenome(), 1f));
 
 		World world = housing.getWorld();
 		Random random = world.rand;
@@ -662,9 +682,9 @@ public class Bee extends IndividualLiving implements IBee {
 			return null;
 		}
 
-		Vect area = getArea(genome, housing);
+		Vect area = getArea(genome, beeModifier);
 		Vect offset = new Vect(-area.x / 2, -area.y / 4, -area.z / 2);
-		Vect housingPos = new Vect(housing.getXCoord(), housing.getYCoord(), housing.getZCoord());
+		Vect housingPos = new Vect(housing.getCoordinates());
 
 		IIndividual pollen = null;
 
@@ -693,7 +713,9 @@ public class Bee extends IndividualLiving implements IBee {
 	@Override
 	public boolean pollinateRandom(IBeeHousing housing, IIndividual pollen) {
 
-		int chance = (int) (genome.getFlowering() * housing.getFloweringModifier(getGenome(), 1f));
+		IBeeModifier beeModifier = BeeManager.beeRoot.createBeeHousingModifier(housing);
+
+		int chance = (int) (genome.getFlowering() * beeModifier.getFloweringModifier(getGenome(), 1f));
 
 		World world = housing.getWorld();
 		Random random = world.rand;
@@ -703,9 +725,9 @@ public class Bee extends IndividualLiving implements IBee {
 			return false;
 		}
 
-		Vect area = getArea(genome, housing);
+		Vect area = getArea(genome, beeModifier);
 		Vect offset = new Vect(-area.x / 2, -area.y / 4, -area.z / 2);
-		Vect housingPos = new Vect(housing.getXCoord(), housing.getYCoord(), housing.getZCoord());
+		Vect housingPos = new Vect(housing.getCoordinates());
 
 		for (int i = 0; i < 30; i++) {
 
@@ -724,7 +746,7 @@ public class Bee extends IndividualLiving implements IBee {
 				continue;
 			}
 
-			IPollinatable realPollinatable = GeneticsUtil.getOrCreatePollinatable(housing.getOwnerName(), world, posBlock.x, posBlock.y, posBlock.z);
+			IPollinatable realPollinatable = GeneticsUtil.getOrCreatePollinatable(housing.getOwner(), world, posBlock.x, posBlock.y, posBlock.z);
 
 			if (realPollinatable != null) {
 				realPollinatable.mateWith(pollen);
@@ -738,7 +760,9 @@ public class Bee extends IndividualLiving implements IBee {
 	@Override
 	public void plantFlowerRandom(IBeeHousing housing) {
 
-		int chance = Math.round(genome.getFlowering() * housing.getFloweringModifier(getGenome(), 1f));
+		IBeeModifier beeModifier = BeeManager.beeRoot.createBeeHousingModifier(housing);
+
+		int chance = Math.round(genome.getFlowering() * beeModifier.getFloweringModifier(getGenome(), 1f));
 
 		World world = housing.getWorld();
 		Random random = world.rand;
@@ -750,23 +774,23 @@ public class Bee extends IndividualLiving implements IBee {
 
 		// Gather required info
 		IFlowerProvider provider = genome.getFlowerProvider();
-		Vect area = getArea(genome, housing);
+		Vect area = getArea(genome, beeModifier);
 		Vect offset = new Vect(-area.x / 2, -area.y / 4, -area.z / 2);
-		Vect housingPos = new Vect(housing.getXCoord(), housing.getYCoord(), housing.getZCoord());
+		Vect housingPos = new Vect(housing.getCoordinates());
 
 		for (int i = 0; i < 10; i++) {
 			Vect randomPos = Vect.getRandomPositionInArea(random, area);
 			Vect posBlock = Vect.add(housingPos, randomPos, offset);
 
-			if (provider.growFlower(world, this, posBlock.x, posBlock.y, posBlock.z)) {
+			if (FlowerManager.flowerRegistry.growFlower(provider.getFlowerType(), world, this, posBlock.x, posBlock.y, posBlock.z)) {
 				break;
 			}
 		}
 	}
 
-	private static Vect getArea(IBeeGenome genome, IBeeHousing housing) {
+	private static Vect getArea(IBeeGenome genome, IBeeModifier beeModifier) {
 		int[] genomeTerritory = genome.getTerritory();
-		float housingModifier = housing.getTerritoryModifier(genome, 1f);
+		float housingModifier = beeModifier.getTerritoryModifier(genome, 1f);
 		return new Vect(genomeTerritory).multiply(housingModifier * 3.0f);
 	}
 }

src/main/java/forestry/apiculture/genetics/BeeBranchDefinition.java

@@ -0,0 +1,159 @@
+package forestry.apiculture.genetics;
+
+import java.util.Arrays;
+import java.util.Locale;
+
+import forestry.api.apiculture.BeeManager;
+import forestry.api.apiculture.EnumBeeChromosome;
+import forestry.api.genetics.IAllele;
+import forestry.api.genetics.IClassification;
+import forestry.apiculture.genetics.alleles.AlleleEffect;
+import forestry.core.genetics.IBranchDefinition;
+import forestry.core.genetics.alleles.AlleleHelper;
+import forestry.core.genetics.alleles.EnumAllele;
+
+public enum BeeBranchDefinition implements IBranchDefinition {
+	HONEY("Apis"),
+	NOBLE("Probapis"),
+	INDUSTRIOUS("Industrapis"),
+	HEROIC("Herapis"),
+	INFERNAL("Diapis") {
+		@Override
+		protected void setBranchProperties(IAllele[] alleles) {
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.DOWN_2);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.NOCTURNAL, true);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.NETHER);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.AVERAGE);
+		}
+	},
+	AUSTERE("Modapis") {
+		@Override
+		protected void setBranchProperties(IAllele[] alleles) {
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_1);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.DOWN_1);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.NOCTURNAL, true);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.CACTI);
+		}
+	},
+	TROPICAL("Caldapis") {
+		@Override
+		protected void setBranchProperties(IAllele[] alleles) {
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.UP_1);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.UP_1);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.JUNGLE);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.EFFECT, AlleleEffect.effectMiasmic);
+		}
+	},
+	END("Finapis") {
+		@Override
+		protected void setBranchProperties(IAllele[] alleles) {
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.LONGER);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.UP_1);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.TERRITORY, EnumAllele.Territory.LARGE);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.END);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.NOCTURNAL, true);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.EFFECT, AlleleEffect.effectMisanthrope);
+		}
+	},
+	FROZEN("Coagapis") {
+		@Override
+		protected void setBranchProperties(IAllele[] alleles) {
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.UP_1);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.BOTH_1);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.SNOW);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.EFFECT, AlleleEffect.effectGlacial);
+		}
+	},
+	VENGEFUL("Punapis") {
+		@Override
+		protected void setBranchProperties(IAllele[] alleles) {
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.TERRITORY, EnumAllele.Territory.LARGEST);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.EFFECT, AlleleEffect.effectRadioactive);
+		}
+	},
+	FESTIVE("Festapis") {
+		@Override
+		protected void setBranchProperties(IAllele[] alleles) {
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_2);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.BOTH_1);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.NORMAL);
+		}
+	},
+	AGRARIAN("Rustapis") {
+		@Override
+		protected void setBranchProperties(IAllele[] alleles) {
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORTER);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.WHEAT);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.FASTER);
+		}
+	},
+	BOGGY("Paludapis") {
+		@Override
+		protected void setBranchProperties(IAllele[] alleles) {
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.MUSHROOMS);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.SLOWER);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_1);
+		}
+	},
+	MONASTIC("Monapis") {
+		@Override
+		protected void setBranchProperties(IAllele[] alleles) {
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.LONG);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.FASTER);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.BOTH_1);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_1);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.CAVE_DWELLING, true);
+			AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.WHEAT);
+		}
+	};
+
+	private final IClassification branch;
+
+	BeeBranchDefinition(String scientific) {
+		branch = BeeManager.beeFactory.createBranch(this.name().toLowerCase(Locale.ENGLISH), scientific);
+	}
+
+	protected void setBranchProperties(IAllele[] template) {
+
+	}
+
+	@Override
+	public final IAllele[] getTemplate() {
+		IAllele[] template = getDefaultTemplate();
+		setBranchProperties(template);
+		return template;
+	}
+
+	@Override
+	public final IClassification getBranch() {
+		return branch;
+	}
+
+	private static IAllele[] defaultTemplate;
+
+	private static IAllele[] getDefaultTemplate() {
+		if (defaultTemplate == null) {
+			defaultTemplate = new IAllele[EnumBeeChromosome.values().length];
+
+			AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWEST);
+			AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORTER);
+			AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.NORMAL);
+			AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.NONE);
+			AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.NOCTURNAL, false);
+			AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.NONE);
+			AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.TOLERANT_FLYER, false);
+			AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.CAVE_DWELLING, false);
+			AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.VANILLA);
+			AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.SLOWEST);
+			AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.TERRITORY, EnumAllele.Territory.AVERAGE);
+			AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.EFFECT, AlleleEffect.effectNone);
+		}
+		return Arrays.copyOf(defaultTemplate, defaultTemplate.length);
+	}
+}

src/main/java/forestry/apiculture/genetics/BeeFactory.java

@@ -0,0 +1,32 @@
+/*******************************************************************************
+ * 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 forestry.apiculture.genetics;
+
+import forestry.api.apiculture.EnumBeeChromosome;
+import forestry.api.apiculture.IAlleleBeeSpeciesCustom;
+import forestry.api.apiculture.IBeeFactory;
+import forestry.api.genetics.AlleleManager;
+import forestry.api.genetics.IClassification;
+import forestry.apiculture.genetics.alleles.AlleleBeeSpecies;
+
+public class BeeFactory implements IBeeFactory {
+	@Override
+	public IAlleleBeeSpeciesCustom createSpecies(String uid, boolean dominant, String authority, String unlocalizedName, String unlocalizedDescription, IClassification branch, String binomial, int primaryColor, int secondaryColor) {
+		IAlleleBeeSpeciesCustom species = new AlleleBeeSpecies(uid, unlocalizedName, authority, unlocalizedDescription, dominant, branch, binomial, primaryColor, secondaryColor);
+		AlleleManager.alleleRegistry.registerAllele(species, EnumBeeChromosome.SPECIES);
+		return species;
+	}
+
+	@Override
+	public IClassification createBranch(String uid, String scientific) {
+		return new BranchBees(uid, scientific);
+	}
+}

src/main/java/forestry/apiculture/genetics/BeeGenome.java

@@ -10,60 +10,73 @@
  ******************************************************************************/
 package forestry.apiculture.genetics;
 
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+
+import javax.annotation.Nonnull;
+import java.util.concurrent.TimeUnit;
+
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 
+import forestry.api.apiculture.BeeManager;
 import forestry.api.apiculture.EnumBeeChromosome;
 import forestry.api.apiculture.IAlleleBeeEffect;
 import forestry.api.apiculture.IAlleleBeeSpecies;
 import forestry.api.apiculture.IBeeGenome;
 import forestry.api.genetics.EnumTolerance;
-import forestry.api.genetics.IAllele;
 import forestry.api.genetics.IAlleleFloat;
 import forestry.api.genetics.IAlleleFlowers;
 import forestry.api.genetics.IAlleleInteger;
+import forestry.api.genetics.IAlleleSpecies;
 import forestry.api.genetics.IChromosome;
 import forestry.api.genetics.IFlowerProvider;
 import forestry.api.genetics.ISpeciesRoot;
-import forestry.core.genetics.AlleleArea;
-import forestry.core.genetics.AlleleBoolean;
-import forestry.core.genetics.AlleleTolerance;
 import forestry.core.genetics.Genome;
-import forestry.core.vect.Vect;
-import forestry.plugins.PluginApiculture;
+import forestry.core.genetics.alleles.AlleleArea;
+import forestry.core.genetics.alleles.AlleleBoolean;
+import forestry.core.genetics.alleles.AlleleTolerance;
+import forestry.core.utils.vect.Vect;
 
 public class BeeGenome extends Genome implements IBeeGenome {
 	/**
 	 * 0 - Species (determines product)
-	 *
 	 * 1 - Speed
-	 *
 	 * 2 - Lifespan
-	 *
 	 * 3 - Fertility (Maximum number of offspring)
-	 *
 	 * 4 - Preferred temperature Icy: Snow biomes Cold: Tundra/Steppe, Extreme Mountains/Hills? Normal: Plains, Forests, Mountains Hot: Desert Hellish: Nether
-	 *
 	 * 5 - Temperature tolerance (Range +/-)
-	 *
 	 * 6 - Nocturnal
-	 *
 	 * 7 - Preferred humidity (Arid - Normal - Damp)
-	 *
 	 * 8 - Humidity tolerance (Range +/-)
-	 *
 	 * 9 - Flight interference tolerance (stuff falling from the sky/other hindrances -> tolerates dampness + flight interference tolerance => rain resistance)
-	 *
 	 * 10 - Cave dwelling
-	 *
 	 * 11 - Required flowers
-	 *
 	 * 12 - Flower plant chance
-	 *
 	 * 13 - Territory
 	 */
+
+	private static final LoadingCache<NBTTagCompound, BeeGenome> beeGenomeCache = CacheBuilder.newBuilder()
+			.maximumSize(128)
+			.expireAfterAccess(1, TimeUnit.MINUTES)
+			.build(new CacheLoader<NBTTagCompound, BeeGenome>() {
+				@Override
+				public BeeGenome load(@Nonnull NBTTagCompound tagCompound) {
+					return new BeeGenome(tagCompound);
+				}
+			});
+
+	public static BeeGenome fromNBT(NBTTagCompound nbtTagCompound) {
+		if (nbtTagCompound == null) {
+			return null;
+		}
+
+		return beeGenomeCache.getUnchecked(nbtTagCompound);
+	}
+
 	/* CONSTRUCTOR */
-	public BeeGenome(NBTTagCompound nbttagcompound) {
+	private BeeGenome(NBTTagCompound nbttagcompound) {
 		super(nbttagcompound);
 	}
 
@@ -73,12 +86,16 @@ public class BeeGenome extends Genome implements IBeeGenome {
 
 	// NBT RETRIEVAL
 	public static IAlleleBeeSpecies getSpecies(ItemStack itemStack) {
-		IAllele speciesAllele = Genome.getActiveAllele(itemStack, EnumBeeChromosome.SPECIES);
-		if (speciesAllele instanceof IAlleleBeeSpecies) {
-			return (IAlleleBeeSpecies) speciesAllele;
-		} else {
+		if (!BeeManager.beeRoot.isMember(itemStack)) {
 			return null;
 		}
+
+		IAlleleSpecies species = getSpeciesDirectly(itemStack);
+		if (species instanceof IAlleleBeeSpecies) {
+			return (IAlleleBeeSpecies) species;
+		}
+
+		return (IAlleleBeeSpecies) getActiveAllele(itemStack, EnumBeeChromosome.SPECIES, BeeManager.beeRoot);
 	}
 
 	// / INFORMATION RETRIEVAL
@@ -155,6 +172,6 @@ public class BeeGenome extends Genome implements IBeeGenome {
 
 	@Override
 	public ISpeciesRoot getSpeciesRoot() {
-		return PluginApiculture.beeInterface;
+		return BeeManager.beeRoot;
 	}
 }

src/main/java/forestry/apiculture/genetics/BeeHelper.java

@@ -25,33 +25,35 @@ import com.mojang.authlib.GameProfile;
 
 import cpw.mods.fml.common.FMLCommonHandler;
 
+import forestry.api.apiculture.BeeManager;
 import forestry.api.apiculture.EnumBeeChromosome;
 import forestry.api.apiculture.EnumBeeType;
 import forestry.api.apiculture.IAlleleBeeSpecies;
-import forestry.api.apiculture.IAlvearyComponent;
 import forestry.api.apiculture.IApiaristTracker;
 import forestry.api.apiculture.IBee;
 import forestry.api.apiculture.IBeeGenome;
 import forestry.api.apiculture.IBeeHousing;
+import forestry.api.apiculture.IBeeListener;
+import forestry.api.apiculture.IBeeModifier;
 import forestry.api.apiculture.IBeeMutation;
 import forestry.api.apiculture.IBeeRoot;
 import forestry.api.apiculture.IBeekeepingLogic;
 import forestry.api.apiculture.IBeekeepingMode;
-import forestry.api.core.IStructureLogic;
 import forestry.api.genetics.AlleleManager;
 import forestry.api.genetics.IAllele;
+import forestry.api.genetics.IChromosome;
 import forestry.api.genetics.IChromosomeType;
 import forestry.api.genetics.IIndividual;
 import forestry.api.genetics.IMutation;
+import forestry.apiculture.BeeHousingListener;
+import forestry.apiculture.BeeHousingModifier;
 import forestry.apiculture.BeekeepingLogic;
-import forestry.apiculture.gadgets.StructureLogicAlveary;
-import forestry.core.config.ForestryItem;
 import forestry.core.genetics.SpeciesRoot;
 import forestry.plugins.PluginApiculture;
 
 public class BeeHelper extends SpeciesRoot implements IBeeRoot {
 
-	public static int beeSpeciesCount = -1;
+	private static int beeSpeciesCount = -1;
 	public static final String UID = "rootBees";
 
 	@Override
@@ -96,24 +98,29 @@ public class BeeHelper extends SpeciesRoot implements IBeeRoot {
 	}
 
 	@Override
-	public ItemStack getMemberStack(IIndividual bee, int type) {
-		if (!isMember(bee)) {
+	public ItemStack getMemberStack(IIndividual individual, int type) {
+		if (!isMember(individual)) {
 			return null;
 		}
+		IBee bee = (IBee) individual;
 
 		Item beeItem;
 		switch (EnumBeeType.VALUES[type]) {
 			case QUEEN:
-				beeItem = ForestryItem.beeQueenGE.item();
+				beeItem = PluginApiculture.items.beeQueenGE;
+				// ensure a queen is always mated
+				if (bee.getMate() == null) {
+					bee.mate(bee);
+				}
 				break;
 			case PRINCESS:
-				beeItem = ForestryItem.beePrincessGE.item();
+				beeItem = PluginApiculture.items.beePrincessGE;
 				break;
 			case DRONE:
-				beeItem = ForestryItem.beeDroneGE.item();
+				beeItem = PluginApiculture.items.beeDroneGE;
 				break;
 			case LARVAE:
-				beeItem = ForestryItem.beeLarvaeGE.item();
+				beeItem = PluginApiculture.items.beeLarvaeGE;
 				break;
 			default:
 				throw new RuntimeException("Cannot instantiate a bee of type " + type);
@@ -132,13 +139,15 @@ public class BeeHelper extends SpeciesRoot implements IBeeRoot {
 			return EnumBeeType.NONE;
 		}
 
-		if (ForestryItem.beeDroneGE.isItemEqual(stack)) {
+		Item item = stack.getItem();
+
+		if (PluginApiculture.items.beeDroneGE == item) {
 			return EnumBeeType.DRONE;
-		} else if (ForestryItem.beePrincessGE.isItemEqual(stack)) {
+		} else if (PluginApiculture.items.beePrincessGE == item) {
 			return EnumBeeType.PRINCESS;
-		} else if (ForestryItem.beeQueenGE.isItemEqual(stack)) {
+		} else if (PluginApiculture.items.beeQueenGE == item) {
 			return EnumBeeType.QUEEN;
-		} else if (ForestryItem.beeLarvaeGE.isItemEqual(stack)) {
+		} else if (PluginApiculture.items.beeLarvaeGE == item) {
 			return EnumBeeType.LARVAE;
 		}
 
@@ -156,8 +165,8 @@ public class BeeHelper extends SpeciesRoot implements IBeeRoot {
 			return false;
 		}
 
-		IBee bee = getMember(stack);
-		return bee.getMate() != null;
+		NBTTagCompound nbt = stack.getTagCompound();
+		return nbt != null && nbt.hasKey("Mate");
 	}
 
 	@Override
@@ -187,7 +196,8 @@ public class BeeHelper extends SpeciesRoot implements IBeeRoot {
 	/* GENOME CONVERSIONS */
 	@Override
 	public IBeeGenome templateAsGenome(IAllele[] template) {
-		return new BeeGenome(templateAsChromosomes(template));
+		IChromosome[] chromosomes = templateAsChromosomes(template);
+		return new BeeGenome(chromosomes);
 	}
 
 	@Override
@@ -206,7 +216,7 @@ public class BeeHelper extends SpeciesRoot implements IBeeRoot {
 	}
 
 	/* TEMPLATES */
-	public static final ArrayList<IBee> beeTemplates = new ArrayList<IBee>();
+	private static final ArrayList<IBee> beeTemplates = new ArrayList<>();
 
 	@Override
 	public ArrayList<IBee> getIndividualTemplates() {
@@ -215,20 +225,22 @@ public class BeeHelper extends SpeciesRoot implements IBeeRoot {
 
 	@Override
 	public void registerTemplate(String identifier, IAllele[] template) {
-		beeTemplates.add(new Bee(PluginApiculture.beeInterface.templateAsGenome(template)));
+		IBeeGenome beeGenome = BeeManager.beeRoot.templateAsGenome(template);
+		IBee bee = new Bee(beeGenome);
+		beeTemplates.add(bee);
 		speciesTemplates.put(identifier, template);
 	}
 
 	@Override
 	public IAllele[] getDefaultTemplate() {
-		return BeeTemplates.getDefaultTemplate();
+		return BeeDefinition.FOREST.getTemplate();
 	}
 
 	/* MUTATIONS */
 	/**
 	 * List of possible mutations on species alleles.
 	 */
-	private static final ArrayList<IBeeMutation> beeMutations = new ArrayList<IBeeMutation>();
+	private static final ArrayList<IBeeMutation> beeMutations = new ArrayList<>();
 
 	@Override
 	public Collection<IBeeMutation> getMutations(boolean shuffle) {
@@ -254,8 +266,8 @@ public class BeeHelper extends SpeciesRoot implements IBeeRoot {
 	}
 
 	/* BREEDING MODES */
-	final ArrayList<IBeekeepingMode> beekeepingModes = new ArrayList<IBeekeepingMode>();
-	public static IBeekeepingMode activeBeekeepingMode;
+	private final ArrayList<IBeekeepingMode> beekeepingModes = new ArrayList<>();
+	private static IBeekeepingMode activeBeekeepingMode;
 
 	@Override
 	public void resetBeekeepingMode() {
@@ -316,10 +328,13 @@ public class BeeHelper extends SpeciesRoot implements IBeeRoot {
 
 		// Create a tracker if there is none yet.
 		if (tracker == null) {
-			tracker = new ApiaristTracker(filename, player);
+			tracker = new ApiaristTracker(filename);
 			world.setItemData(filename, tracker);
 		}
 
+		tracker.setUsername(player);
+		tracker.setWorld(world);
+
 		return tracker;
 	}
 
@@ -329,8 +344,13 @@ public class BeeHelper extends SpeciesRoot implements IBeeRoot {
 	}
 
 	@Override
-	public IStructureLogic createAlvearyStructureLogic(IAlvearyComponent structure) {
-		return new StructureLogicAlveary(structure);
+	public IBeeModifier createBeeHousingModifier(IBeeHousing housing) {
+		return new BeeHousingModifier(housing);
+	}
+
+	@Override
+	public IBeeListener createBeeHousingListener(IBeeHousing housing) {
+		return new BeeHousingListener(housing);
 	}
 
 	@Override

src/main/java/forestry/apiculture/genetics/BeeMutation.java

@@ -10,129 +10,50 @@
  ******************************************************************************/
 package forestry.apiculture.genetics;
 
-import java.util.ArrayList;
-
+import net.minecraft.util.ChunkCoordinates;
 import net.minecraft.world.World;
-import net.minecraft.world.biome.BiomeGenBase;
-
-import net.minecraftforge.common.BiomeDictionary;
 
+import forestry.api.apiculture.BeeManager;
+import forestry.api.apiculture.IAlleleBeeSpecies;
 import forestry.api.apiculture.IBeeGenome;
 import forestry.api.apiculture.IBeeHousing;
-import forestry.api.apiculture.IBeeMutation;
+import forestry.api.apiculture.IBeeModifier;
+import forestry.api.apiculture.IBeeMutationCustom;
 import forestry.api.apiculture.IBeeRoot;
-import forestry.api.genetics.AlleleManager;
 import forestry.api.genetics.IAllele;
-import forestry.api.genetics.IGenome;
-import forestry.core.genetics.Mutation;
-import forestry.plugins.PluginApiculture;
+import forestry.core.genetics.mutations.Mutation;
 
-public class BeeMutation extends Mutation implements IBeeMutation {
+public class BeeMutation extends Mutation implements IBeeMutationCustom {
 
-	private final IBeeRoot root;
-
-	boolean requiresDay = false;
-	boolean requiresNight = false;
-
-	private final ArrayList<BiomeDictionary.Type> restrictBiomeTypes = new ArrayList<BiomeDictionary.Type>();
-	private boolean strictBiomeCheck = false;
-
-	public BeeMutation(IAllele allele0, IAllele allele1, IAllele[] template, int chance) {
-		super(allele0, allele1, template, chance);
-
-		root = (IBeeRoot) AlleleManager.alleleRegistry.getSpeciesRoot("rootBees");
-		PluginApiculture.beeInterface.registerMutation(this);
+	public BeeMutation(IAlleleBeeSpecies bee0, IAlleleBeeSpecies bee1, IAllele[] result, int chance) {
+		super(bee0, bee1, result, chance);
 	}
 
 	@Override
 	public IBeeRoot getRoot() {
-		return root;
-	}
-
-	public BeeMutation enableStrictBiomeCheck() {
-		strictBiomeCheck = true;
-		return this;
-	}
-
-	public BeeMutation restrictBiomeType(BiomeDictionary.Type type) {
-		restrictBiomeTypes.add(type);
-		specialConditions.add(String.format("Is restricted to %s-like environments.", type.toString()));
-		return this;
-	}
-
-	public BeeMutation requireDay() {
-		requiresDay = true;
-		requiresNight = false;
-		specialConditions.add("Can only occur during the day.");
-		return this;
-	}
-
-	public BeeMutation requireNight() {
-		requiresDay = false;
-		requiresNight = true;
-		specialConditions.add("Can only occur during the night.");
-		return this;
+		return BeeManager.beeRoot;
 	}
 
 	@Override
-	public float getChance(IBeeHousing housing, IAllele allele0, IAllele allele1, IGenome genome0, IGenome genome1) {
-
+	public float getChance(IBeeHousing housing, IAlleleBeeSpecies allele0, IAlleleBeeSpecies allele1, IBeeGenome genome0, IBeeGenome genome1) {
 		World world = housing.getWorld();
-		if (requiresDay && !world.isDaytime()) {
-			return 0;
-		}
+		ChunkCoordinates housingCoordinates = housing.getCoordinates();
+		int x = housingCoordinates.posX;
+		int y = housingCoordinates.posY;
+		int z = housingCoordinates.posZ;
 
-		if (requiresNight && world.isDaytime()) {
-			return 0;
-		}
-
-		// Skip if we are restricted by biomes and this one does not match.
-		if (restrictBiomeTypes.size() > 0) {
-			boolean noneMatched = true;
-
-			BiomeGenBase biome = BiomeGenBase.getBiome(housing.getBiomeId());
-			if (strictBiomeCheck) {
-				BiomeDictionary.Type[] types = BiomeDictionary.getTypesForBiome(biome);
-				if (types.length == 1 && restrictBiomeTypes.contains(types[0])) {
-					noneMatched = false;
-				}
-			} else {
-				for (BiomeDictionary.Type type : restrictBiomeTypes) {
-					if (BiomeDictionary.isBiomeOfType(biome, type)) {
-						noneMatched = false;
-						break;
-					}
-				}
-			}
-
-			if (noneMatched) {
-				return 0;
-			}
-		}
-
-		BiomeGenBase biome = world.getWorldChunkManager().getBiomeGenAt(housing.getXCoord(), housing.getZCoord());
-		if (biome.temperature < minTemperature || biome.temperature > maxTemperature) {
-			return 0;
-		}
-		if (biome.rainfall < minRainfall || biome.rainfall > maxRainfall) {
-			return 0;
-		}
-
-		float processedChance = chance * housing.getMutationModifier((IBeeGenome) genome0, (IBeeGenome) genome1, 1f)
-				* PluginApiculture.beeInterface.getBeekeepingMode(world).getMutationModifier((IBeeGenome) genome0, (IBeeGenome) genome1, 1f);
+		float processedChance = super.getChance(world, x, y, z, allele0, allele1, genome0, genome1);
 		if (processedChance <= 0) {
 			return 0;
 		}
 
-		if (this.allele0.getUID().equals(allele0.getUID()) && this.allele1.getUID().equals(allele1.getUID())) {
-			return processedChance;
-		}
-		if (this.allele1.getUID().equals(allele0.getUID()) && this.allele0.getUID().equals(allele1.getUID())) {
-			return processedChance;
-		}
+		IBeeModifier beeHousingModifier = BeeManager.beeRoot.createBeeHousingModifier(housing);
+		IBeeModifier beeModeModifier = BeeManager.beeRoot.getBeekeepingMode(world).getBeeModifier();
 
-		return 0;
+		processedChance *= beeHousingModifier.getMutationModifier(genome0, genome1, processedChance);
+		processedChance *= beeModeModifier.getMutationModifier(genome0, genome1, processedChance);
 
+		return processedChance;
 	}
 
 }

src/main/java/forestry/apiculture/genetics/BeeMutationFactory.java

@@ -0,0 +1,27 @@
+/*******************************************************************************
+ * 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 forestry.apiculture.genetics;
+
+import forestry.api.apiculture.BeeManager;
+import forestry.api.apiculture.IAlleleBeeSpecies;
+import forestry.api.apiculture.IBeeMutationCustom;
+import forestry.api.apiculture.IBeeMutationFactory;
+import forestry.api.genetics.IAllele;
+
+public class BeeMutationFactory implements IBeeMutationFactory {
+
+	@Override
+	public IBeeMutationCustom createMutation(IAlleleBeeSpecies parentBee0, IAlleleBeeSpecies parentBee1, IAllele[] result, int chance) {
+		IBeeMutationCustom mutation = new BeeMutation(parentBee0, parentBee1, result, chance);
+		BeeManager.beeRoot.registerMutation(mutation);
+		return mutation;
+	}
+}

src/main/java/forestry/apiculture/genetics/BeeTemplates.java

@@ -1,640 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.genetics;
-
-import java.util.Arrays;
-
-import forestry.api.apiculture.EnumBeeChromosome;
-import forestry.api.genetics.IAllele;
-import forestry.api.genetics.IMutation;
-import forestry.core.genetics.Allele;
-
-public class BeeTemplates {
-
-	// / MUTATIONS
-	public static IMutation commonA;
-
-	public static IMutation commonB;
-	public static IMutation commonC;
-
-	public static IMutation commonD;
-	public static IMutation commonE;
-	public static IMutation commonF;
-
-	public static IMutation commonG;
-	public static IMutation commonH;
-	public static IMutation commonI;
-	public static IMutation commonJ;
-
-	public static IMutation commonK;
-	public static IMutation commonL;
-	public static IMutation commonM;
-	public static IMutation commonN;
-	public static IMutation commonO;
-
-	public static IMutation cultivatedA;
-	public static IMutation cultivatedB;
-	public static IMutation cultivatedC;
-	public static IMutation cultivatedD;
-	public static IMutation cultivatedE;
-	public static IMutation cultivatedF;
-
-	public static IMutation nobleA;
-	public static IMutation majesticA;
-	public static IMutation imperialA;
-
-	public static IMutation diligentA;
-	public static IMutation unwearyA;
-	public static IMutation industriousA;
-
-	public static IMutation heroicA;
-
-	public static IMutation sinisterA;
-	public static IMutation sinisterB;
-	public static IMutation fiendishA;
-	public static IMutation fiendishB;
-	public static IMutation fiendishC;
-	public static IMutation demonicA;
-
-	// Austere branch
-	public static IMutation frugalA;
-	public static IMutation frugalB;
-	public static IMutation austereA;
-
-	// Tropical branch
-	public static IMutation exoticA;
-	public static IMutation edenicA;
-
-	// Wintry branch
-	public static IMutation icyA;
-	public static IMutation glacialA;
-
-	// Festive branch
-	public static IMutation leporineA;
-	public static IMutation merryA;
-	public static IMutation tipsyA;
-	public static IMutation trickyA;
-
-	// Agrarian branch
-	public static IMutation ruralA;
-
-	// Monastic branch
-	public static IMutation secludedA;
-	public static IMutation hermiticA;
-
-	// End branch
-	public static IMutation spectralA;
-	public static IMutation phantasmalA;
-
-	public static IMutation vindictiveA;
-
-	public static IMutation vengefulA;
-	public static IMutation vengefulB;
-	public static IMutation avengingA;
-
-	public static IAllele[] defaultTemplate;
-
-	public static IAllele[] getDefaultTemplate() {
-		if (defaultTemplate == null) {
-			defaultTemplate = new IAllele[EnumBeeChromosome.values().length];
-
-			defaultTemplate[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesForest;
-			defaultTemplate[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlowest;
-			defaultTemplate[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShorter;
-			defaultTemplate[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.fertilityNormal;
-			defaultTemplate[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceNone;
-			defaultTemplate[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolFalse;
-			defaultTemplate[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceNone;
-			defaultTemplate[EnumBeeChromosome.TOLERANT_FLYER.ordinal()] = Allele.boolFalse;
-			defaultTemplate[EnumBeeChromosome.CAVE_DWELLING.ordinal()] = Allele.boolFalse;
-			defaultTemplate[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersVanilla;
-			defaultTemplate[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringSlowest;
-			defaultTemplate[EnumBeeChromosome.TERRITORY.ordinal()] = Allele.territoryDefault;
-			defaultTemplate[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectNone;
-		}
-		return Arrays.copyOf(defaultTemplate, defaultTemplate.length);
-	}
-
-	// / COMMON BRANCH
-
-	public static IAllele[] getForestTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringSlower;
-		alleles[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.fertilityHigh;
-		return alleles;
-	}
-
-	public static IAllele[] getForestRainResistTemplate() {
-		IAllele[] alleles = getForestTemplate();
-		alleles[EnumBeeChromosome.TOLERANT_FLYER.ordinal()] = Allele.boolTrue;
-		return alleles;
-	}
-
-	public static IAllele[] getMeadowsTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesMeadows;
-		alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringSlower;
-		return alleles;
-	}
-
-	public static IAllele[] getCommonTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesCommon;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower;
-		return alleles;
-	}
-
-	public static IAllele[] getCultivatedTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesCultivated;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedFast;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShortest;
-		return alleles;
-	}
-
-	// / NOBLE BRANCH
-
-	public static IAllele[] getNobleTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesNoble;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShort;
-		alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringSlow;
-		return alleles;
-	}
-
-	public static IAllele[] getMajesticTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesMajestic;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedNorm;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShortened;
-		alleles[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.fertilityMaximum;
-		return alleles;
-	}
-
-	public static IAllele[] getImperialTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesImperial;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanNormal;
-		alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectBeatific;
-		return alleles;
-	}
-
-	// / INDUSTRIOUS BRANCH
-
-	public static IAllele[] getDiligentTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesDiligent;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShort;
-		alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringSlow;
-		return alleles;
-	}
-
-	public static IAllele[] getUnwearyTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesUnweary;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedNorm;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShortened;
-		return alleles;
-	}
-
-	public static IAllele[] getIndustriousTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesIndustrious;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanNormal;
-		alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringFast;
-		return alleles;
-	}
-
-	// / HEROIC BRANCH
-
-	public static IAllele[] getSteadfastTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesSteadfast;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanNormal;
-		alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue;
-		alleles[EnumBeeChromosome.CAVE_DWELLING.ordinal()] = Allele.boolTrue;
-		return alleles;
-	}
-
-	public static IAllele[] getValiantTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesValiant;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlow;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLong;
-		alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue;
-		alleles[EnumBeeChromosome.CAVE_DWELLING.ordinal()] = Allele.boolTrue;
-		return alleles;
-	}
-
-	public static IAllele[] getHeroicTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesHeroic;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlow;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLong;
-		alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue;
-		alleles[EnumBeeChromosome.CAVE_DWELLING.ordinal()] = Allele.boolTrue;
-		alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectHeroic;
-		return alleles;
-	}
-
-	// / INFERNAL BRANCH
-
-	public static IAllele[] getBranchInfernalTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceDown2;
-		alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue;
-		alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersNether;
-		alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringAverage;
-		return alleles;
-	}
-
-	public static IAllele[] getSinisterTemplate() {
-		IAllele[] alleles = getBranchInfernalTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesSinister;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanNormal;
-		alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectAggressive;
-		return alleles;
-	}
-
-	public static IAllele[] getFiendishTemplate() {
-		IAllele[] alleles = getBranchInfernalTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesFiendish;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedNorm;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLong;
-		alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectAggressive;
-		return alleles;
-	}
-
-	public static IAllele[] getDemonicTemplate() {
-		IAllele[] alleles = getBranchInfernalTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesDemonic;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLonger;
-		alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectIgnition;
-		return alleles;
-	}
-
-	// / AUSTERE BRANCH
-
-	public static IAllele[] getAustereBranchTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceBoth1;
-		alleles[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceDown1;
-		alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue;
-		alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersCacti;
-		return alleles;
-	}
-
-	public static IAllele[] getModestTemplate() {
-		IAllele[] alleles = getAustereBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesModest;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShort;
-		return alleles;
-	}
-
-	public static IAllele[] getFrugalTemplate() {
-		IAllele[] alleles = getAustereBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesFrugal;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedNorm;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLong;
-		return alleles;
-	}
-
-	public static IAllele[] getAustereTemplate() {
-		IAllele[] alleles = getAustereBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesAustere;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlowest;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLonger;
-		alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceDown2;
-		alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectCreeper;
-		return alleles;
-	}
-
-	// / TROPICAL BRANCH
-	public static IAllele[] getTropicalBranchTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceUp1;
-		alleles[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceUp1;
-		alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersJungle;
-		alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectMiasmic;
-		return alleles;
-	}
-
-	public static IAllele[] getTropicalTemplate() {
-		IAllele[] alleles = getTropicalBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesTropical;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShort;
-		return alleles;
-	}
-
-	public static IAllele[] getExoticTemplate() {
-		IAllele[] alleles = getTropicalBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesExotic;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedNorm;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLong;
-		return alleles;
-	}
-
-	public static IAllele[] getEdenicTemplate() {
-		IAllele[] alleles = getTropicalBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesEdenic;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlowest;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLonger;
-		alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceBoth2;
-		alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectExploration;
-		return alleles;
-	}
-
-	// / END BRANCH
-	public static IAllele[] getEndBranchTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.fertilityLow;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLonger;
-		alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceUp1;
-		alleles[EnumBeeChromosome.TERRITORY.ordinal()] = Allele.territoryLarge;
-		alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersEnd;
-		alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue;
-		alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectMisanthrope;
-		return alleles;
-	}
-
-	public static IAllele[] getEnderTemplate() {
-		IAllele[] alleles = getEndBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesEnded;
-		return alleles;
-	}
-
-	public static IAllele[] getSpectralTemplate() {
-		IAllele[] alleles = getEndBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesSpectral;
-		alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectReanimation;
-		return alleles;
-	}
-
-	public static IAllele[] getPhantasmalTemplate() {
-		IAllele[] alleles = getEndBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesPhantasmal;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlowest;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLongest;
-		alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectResurrection;
-		return alleles;
-	}
-
-	// / FROZEN BRANCH
-	public static IAllele[] getFrozenBranchTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceUp1;
-		alleles[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceBoth1;
-		alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersSnow;
-		alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectGlacial;
-		return alleles;
-	}
-
-	public static IAllele[] getWintryTemplate() {
-		IAllele[] alleles = getFrozenBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesWintry;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShort;
-		alleles[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.fertilityMaximum;
-		return alleles;
-	}
-
-	public static IAllele[] getIcyTemplate() {
-		IAllele[] alleles = getFrozenBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesIcy;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlow;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShort;
-		return alleles;
-	}
-
-	public static IAllele[] getGlacialTemplate() {
-		IAllele[] alleles = getFrozenBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesGlacial;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShort;
-		return alleles;
-	}
-
-	// / VENGEFUL BRANCH
-	public static IAllele[] getVengefulBranchTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.TERRITORY.ordinal()] = Allele.territoryLargest;
-		alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectRadioactive;
-		return alleles;
-	}
-
-	public static IAllele[] getVindictiveTemplate() {
-		IAllele[] alleles = getVengefulBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesVindictive;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanNormal;
-		return alleles;
-	}
-
-	public static IAllele[] getVengefulTemplate() {
-		IAllele[] alleles = getVengefulBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesVengeful;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedNorm;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLonger;
-		return alleles;
-	}
-
-	public static IAllele[] getAvengingTemplate() {
-		IAllele[] alleles = getVengefulBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesAvenging;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlowest;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLongest;
-		return alleles;
-	}
-
-	// / REDDENED BRANCH
-	public static IAllele[] getReddenedBranchTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlow;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanNormal;
-		alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceBoth2;
-		alleles[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceBoth1;
-		return alleles;
-	}
-
-	public static IAllele[] getDarkenedTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesDarkened;
-		return alleles;
-	}
-
-	public static IAllele[] getReddenedTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesReddened;
-		return alleles;
-	}
-
-	public static IAllele[] getOmegaTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesOmega;
-		return alleles;
-	}
-
-	// / FESTIVE BRANCH
-	public static IAllele[] getFestiveBranchTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower;
-		alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceBoth2;
-		alleles[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceBoth1;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanNormal;
-		return alleles;
-	}
-
-	public static IAllele[] getLeporineTemplate() {
-		IAllele[] alleles = getFestiveBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesLeporine;
-		alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectFestiveEaster;
-		return alleles;
-	}
-
-	public static IAllele[] getMerryTemplate() {
-		IAllele[] alleles = getFestiveBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesMerry;
-		alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue;
-		alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectSnowing;
-		return alleles;
-	}
-
-	public static IAllele[] getTipsyTemplate() {
-		IAllele[] alleles = getFestiveBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesTipsy;
-		alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue;
-		alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectDrunkard;
-		return alleles;
-	}
-	
-	public static IAllele[] getTrickyTemplate() {
-		IAllele[] alleles = getFestiveBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesTricky;
-		alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue;
-		alleles[EnumBeeChromosome.TOLERANT_FLYER.ordinal()] = Allele.boolTrue;
-		alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersGourd;
-		return alleles;
-	}
-
-	// / AGRARIAN BRANCH
-	public static IAllele[] getAgrarianBranchTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShorter;
-		alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersWheat;
-		alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringFaster;
-		return alleles;
-	}
-
-	public static IAllele[] getRuralTemplate() {
-		IAllele[] alleles = getAgrarianBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesRural;
-		return alleles;
-	}
-	
-	public static IAllele[] getFarmerlyTemplate() {
-		IAllele[] alleles = getAgrarianBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesFarmerly;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlow;
-		alleles[EnumBeeChromosome.TERRITORY.ordinal()] = Allele.territoryLarge;
-		return alleles;
-	}
-	
-	public static IAllele[] getAgrarianTemplate() {
-		IAllele[] alleles = getAgrarianBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesArgrarian;
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlow;
-		alleles[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceBoth2;
-		alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectFertile;
-		alleles[EnumBeeChromosome.TERRITORY.ordinal()] = Allele.territoryLarge;
-		return alleles;
-	}
-
-	// / BOGGY BRANCH
-	public static IAllele[] getBoggyBranchTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersMushrooms;
-		alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringSlower;
-		alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceBoth1;
-		return alleles;
-	}
-
-	public static IAllele[] getMarshyTemplate() {
-		IAllele[] alleles = getBoggyBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesMarshy;
-		return alleles;
-	}
-	
-	public static IAllele[] getMiryTemplate() {
-		IAllele[] alleles = getBoggyBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesMiry;
-		alleles[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.fertilityMaximum;
-		alleles[EnumBeeChromosome.TOLERANT_FLYER.ordinal()] = Allele.boolTrue;
-		alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue;
-		return alleles;
-	}
-	
-	public static IAllele[] getBoggyTemplate() {
-		IAllele[] alleles = getBoggyBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesBoggy;
-		alleles[EnumBeeChromosome.TOLERANT_FLYER.ordinal()] = Allele.boolTrue;
-		alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue;
-		alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectMycophilic;
-		alleles[EnumBeeChromosome.TERRITORY.ordinal()] = Allele.territoryLarger;
-		return alleles;
-	}
-
-	/* MONASTIC BRANCH */
-	public static IAllele[] getMonasticBranchTemplate() {
-		IAllele[] alleles = getDefaultTemplate();
-		alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower;
-		alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLong;
-		alleles[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.fertilityLow;
-		alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringFaster;
-		alleles[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceBoth1;
-		alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceBoth1;
-		alleles[EnumBeeChromosome.CAVE_DWELLING.ordinal()] = Allele.boolTrue;
-		alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersWheat;
-		return alleles;
-	}
-
-	public static IAllele[] getMonasticTemplate() {
-		IAllele[] alleles = getMonasticBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesMonastic;
-		return alleles;
-	}
-
-	public static IAllele[] getSecludedTemplate() {
-		IAllele[] alleles = getMonasticBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesSecluded;
-		alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringFastest;
-		return alleles;
-	}
-
-	public static IAllele[] getHermiticTemplate() {
-		IAllele[] alleles = getMonasticBranchTemplate();
-		alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesHermitic;
-		alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringFastest;
-		alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectRepulsion;
-		return alleles;
-	}
-
-}

src/main/java/forestry/apiculture/genetics/BeeVariation.java

@@ -0,0 +1,57 @@
+package forestry.apiculture.genetics;
+
+import net.minecraft.item.ItemStack;
+
+import forestry.api.apiculture.BeeManager;
+import forestry.api.apiculture.EnumBeeChromosome;
+import forestry.api.apiculture.EnumBeeType;
+import forestry.api.apiculture.IBee;
+import forestry.api.apiculture.IBeeGenome;
+import forestry.api.genetics.IAllele;
+import forestry.core.genetics.alleles.AlleleHelper;
+
+public abstract class BeeVariation implements IBeeDefinition {
+
+	private final IAllele[] template;
+	private final IBeeGenome genome;
+
+	protected BeeVariation(IBeeDefinition bee) {
+		template = bee.getTemplate();
+		initializeTemplate(template);
+		genome = BeeManager.beeRoot.templateAsGenome(template);
+	}
+
+	protected abstract void initializeTemplate(IAllele[] template);
+
+	@Override
+	public IAllele[] getTemplate() {
+		return template;
+	}
+
+	@Override
+	public IBeeGenome getGenome() {
+		return genome;
+	}
+
+	@Override
+	public IBee getIndividual() {
+		return new Bee(genome);
+	}
+
+	@Override
+	public final ItemStack getMemberStack(EnumBeeType beeType) {
+		IBee bee = getIndividual();
+		return BeeManager.beeRoot.getMemberStack(bee, beeType.ordinal());
+	}
+
+	public static class RainResist extends BeeVariation {
+		public RainResist(IBeeDefinition bee) {
+			super(bee);
+		}
+
+		@Override
+		protected void initializeTemplate(IAllele[] template) {
+			AlleleHelper.instance.set(template, EnumBeeChromosome.TOLERANT_FLYER, true);
+		}
+	}
+}

src/main/java/forestry/apiculture/genetics/BeekeepingMode.java

@@ -16,9 +16,12 @@ import java.util.Random;
 
 import net.minecraft.world.World;
 
+import forestry.api.apiculture.BeeManager;
+import forestry.api.apiculture.DefaultBeeModifier;
 import forestry.api.apiculture.IBee;
 import forestry.api.apiculture.IBeeGenome;
 import forestry.api.apiculture.IBeeHousing;
+import forestry.api.apiculture.IBeeModifier;
 import forestry.api.apiculture.IBeekeepingMode;
 
 public class BeekeepingMode implements IBeekeepingMode {
@@ -29,22 +32,18 @@ public class BeekeepingMode implements IBeekeepingMode {
 	public static final IBeekeepingMode hardcore = new BeekeepingMode("HARDCORE", 0.5f, 5.0f, 0.8f, true, true);
 	public static final IBeekeepingMode insane = new BeekeepingMode("INSANE", 0.2f, 10.0f, 0.6f, true, true);
 
-	final Random rand;
-	final String name;
-	final float mutationModifier;
-	final float lifespanModifier;
-	final float speedModifier;
-	final boolean reducesFertility;
-	final boolean canFatigue;
+	private final Random rand;
+	private final String name;
+	private final boolean reducesFertility;
+	private final boolean canFatigue;
+	private final IBeeModifier beeModifier;
 
 	public BeekeepingMode(String name, float mutationModifier, float lifespanModifier, float speedModifier, boolean reducesFertility, boolean canFatigue) {
 		this.rand = new Random();
 		this.name = name;
-		this.mutationModifier = mutationModifier;
-		this.lifespanModifier = lifespanModifier;
-		this.speedModifier = speedModifier;
 		this.reducesFertility = reducesFertility;
 		this.canFatigue = canFatigue;
+		this.beeModifier = new BeekeepingModeBeeModifier(mutationModifier, lifespanModifier, speedModifier);
 	}
 
 	@Override
@@ -54,7 +53,7 @@ public class BeekeepingMode implements IBeekeepingMode {
 
 	@Override
 	public ArrayList<String> getDescription() {
-		ArrayList<String> ret = new ArrayList<String>();
+		ArrayList<String> ret = new ArrayList<>();
 		ret.add("beemode." + name.toLowerCase(Locale.ENGLISH) + ".desc");
 		return ret;
 	}
@@ -64,36 +63,6 @@ public class BeekeepingMode implements IBeekeepingMode {
 		return 1.0f;
 	}
 
-	@Override
-	public float getMutationModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
-		return this.mutationModifier;
-	}
-
-	@Override
-	public float getLifespanModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
-		return this.lifespanModifier;
-	}
-
-	@Override
-	public float getProductionModifier(IBeeGenome genome, float currentModifier) {
-		return this.speedModifier;
-	}
-
-	@Override
-	public float getTerritoryModifier(IBeeGenome genome, float currentModifier) {
-		return 1.0f;
-	}
-
-	@Override
-	public float getFloweringModifier(IBeeGenome genome, float currentModifier) {
-		return 1.0f;
-	}
-
-	@Override
-	public float getGeneticDecay(IBeeGenome genome, float currentModifier) {
-		return 1.0f;
-	}
-
 	@Override
 	public int getFinalFertility(IBee queen, World world, int x, int y, int z) {
 		int toCreate = queen.getGenome().getFertility();
@@ -115,17 +84,17 @@ public class BeekeepingMode implements IBeekeepingMode {
 			return false;
 		}
 
-		if (queen.getGeneration() > 96 + rand.nextInt(6) + rand.nextInt(6) &&
-				rand.nextFloat() < 0.02f * housing.getGeneticDecay(queen.getGenome(), 1f)) {
-			return true;
-		}
+		IBeeModifier beeModifier = BeeManager.beeRoot.createBeeHousingModifier(housing);
 
-		return false;
+		return queen.getGeneration() > 96 + rand.nextInt(6) + rand.nextInt(6) &&
+				rand.nextFloat() < 0.02f * beeModifier.getGeneticDecay(queen.getGenome(), 1f);
 	}
 
 	@Override
 	public boolean isOverworked(IBee queen, IBeeHousing housing) {
-		float productionModifier = housing.getProductionModifier(queen.getGenome(), 1f);
+		IBeeModifier beeModifier = BeeManager.beeRoot.createBeeHousingModifier(housing);
+
+		float productionModifier = beeModifier.getProductionModifier(queen.getGenome(), 1f);
 		if (productionModifier > 16) {
 			if (housing.getWorld().rand.nextFloat() * 100 < 0.01 * ((productionModifier * productionModifier) - 100)) {
 				return true;
@@ -137,7 +106,9 @@ public class BeekeepingMode implements IBeekeepingMode {
 	
 	@Override
 	public boolean isDegenerating(IBee queen, IBee offspring, IBeeHousing housing) {
-		float mutationModifier = housing.getMutationModifier(queen.getGenome(), queen.getMate(), 1.0f);
+		IBeeModifier beeModifier = BeeManager.beeRoot.createBeeHousingModifier(housing);
+
+		float mutationModifier = beeModifier.getMutationModifier(queen.getGenome(), queen.getMate(), 1.0f);
 		if (mutationModifier > 10) {
 			if (housing.getWorld().rand.nextFloat() * 100 < 0.4 * ((mutationModifier * mutationModifier) - 100)) {
 				return true;
@@ -158,23 +129,34 @@ public class BeekeepingMode implements IBeekeepingMode {
 	}
 
 	@Override
-	public boolean isSealed() {
-		return false;
+	public IBeeModifier getBeeModifier() {
+		return beeModifier;
 	}
 
-	@Override
-	public boolean isSelfLighted() {
-		return false;
-	}
+	private static class BeekeepingModeBeeModifier extends DefaultBeeModifier {
+		private final float mutationModifier;
+		private final float lifespanModifier;
+		private final float speedModifier;
 
-	@Override
-	public boolean isSunlightSimulated() {
-		return false;
-	}
+		public BeekeepingModeBeeModifier(float mutationModifier, float lifespanModifier, float speedModifier) {
+			this.mutationModifier = mutationModifier;
+			this.lifespanModifier = lifespanModifier;
+			this.speedModifier = speedModifier;
+		}
 
-	@Override
-	public boolean isHellish() {
-		return false;
-	}
+		@Override
+		public float getMutationModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
+			return this.mutationModifier;
+		}
 
+		@Override
+		public float getLifespanModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
+			return this.lifespanModifier;
+		}
+
+		@Override
+		public float getProductionModifier(IBeeGenome genome, float currentModifier) {
+			return this.speedModifier;
+		}
+	}
 }

src/main/java/forestry/apiculture/genetics/DefaultBeeIconColourProvider.java

@@ -0,0 +1,34 @@
+/*******************************************************************************
+ * 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 forestry.apiculture.genetics;
+
+import forestry.api.apiculture.IBeeIconColourProvider;
+
+public class DefaultBeeIconColourProvider implements IBeeIconColourProvider {
+	private final int primaryColour;
+	private final int secondaryColour;
+
+	public DefaultBeeIconColourProvider(int primaryColour, int secondaryColour) {
+		this.primaryColour = primaryColour;
+		this.secondaryColour = secondaryColour;
+	}
+
+	@Override
+	public int getIconColour(int renderPass) {
+		if (renderPass == 0) {
+			return primaryColour;
+		}
+		if (renderPass == 1) {
+			return secondaryColour;
+		}
+		return 0xffffff;
+	}
+}

src/main/java/forestry/apiculture/genetics/DefaultBeeIconProvider.java

@@ -0,0 +1,64 @@
+/*******************************************************************************
+ * 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 forestry.apiculture.genetics;
+
+import java.util.Locale;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.util.IIcon;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+import forestry.api.apiculture.EnumBeeType;
+import forestry.api.apiculture.IBeeIconProvider;
+import forestry.core.render.TextureManager;
+
+public class DefaultBeeIconProvider implements IBeeIconProvider {
+
+	public static final DefaultBeeIconProvider instance = new DefaultBeeIconProvider();
+
+	private DefaultBeeIconProvider() {
+
+	}
+
+	private static final IIcon[][] icons = new IIcon[EnumBeeType.values().length][3];
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void registerIcons(IIconRegister register) {
+		String beeIconDir = "bees/default/";
+		IIcon body1 = TextureManager.registerTex(register, beeIconDir + "body1");
+
+		for (int i = 0; i < EnumBeeType.values().length; i++) {
+			EnumBeeType beeType = EnumBeeType.values()[i];
+			if (beeType == EnumBeeType.NONE) {
+				continue;
+			}
+
+			String beeTypeNameBase = beeIconDir + beeType.toString().toLowerCase(Locale.ENGLISH);
+
+			icons[i][0] = TextureManager.registerTex(register, beeTypeNameBase + ".outline");
+			if (beeType == EnumBeeType.LARVAE) {
+				icons[i][1] = TextureManager.registerTex(register, beeTypeNameBase + ".body");
+			} else {
+				icons[i][1] = body1;
+			}
+			icons[i][2] = TextureManager.registerTex(register, beeTypeNameBase + ".body2");
+		}
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public IIcon getIcon(EnumBeeType type, int renderPass) {
+		return icons[type.ordinal()][renderPass];
+	}
+}

src/main/java/forestry/apiculture/genetics/HiveDrop.java

@@ -12,25 +12,25 @@ package forestry.apiculture.genetics;
 
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.List;
 
 import net.minecraft.item.ItemStack;
 import net.minecraft.world.World;
 
+import forestry.api.apiculture.BeeManager;
 import forestry.api.apiculture.EnumBeeType;
 import forestry.api.apiculture.IBee;
 import forestry.api.apiculture.IHiveDrop;
-import forestry.api.genetics.IAllele;
-import forestry.plugins.PluginApiculture;
 
 public class HiveDrop implements IHiveDrop {
 
-	private final IAllele[] template;
-	private final ArrayList<ItemStack> additional = new ArrayList<ItemStack>();
+	private final IBeeDefinition beeTemplate;
+	private final ArrayList<ItemStack> additional = new ArrayList<>();
 	private final int chance;
 	private float ignobleShare = 0.0f;
 
-	public HiveDrop(IAllele[] template, ItemStack[] bonus, int chance) {
-		this.template = template;
+	public HiveDrop(int chance, IBeeDefinition beeTemplate, ItemStack... bonus) {
+		this.beeTemplate = beeTemplate;
 		this.chance = chance;
 
 		Collections.addAll(this.additional, bonus);
@@ -41,30 +41,25 @@ public class HiveDrop implements IHiveDrop {
 		return this;
 	}
 	
-	private IBee createBee(World world) {
-		return PluginApiculture.beeInterface.getBee(world, PluginApiculture.beeInterface.templateAsGenome(template));
-	}
-	
 	@Override
 	public ItemStack getPrincess(World world, int x, int y, int z, int fortune) {
-		IBee bee = createBee(world);
+		IBee bee = beeTemplate.getIndividual();
 		if (world.rand.nextFloat() < ignobleShare) {
 			bee.setIsNatural(false);
 		}
 
-		return PluginApiculture.beeInterface.getMemberStack(bee, EnumBeeType.PRINCESS.ordinal());
+		return BeeManager.beeRoot.getMemberStack(bee, EnumBeeType.PRINCESS.ordinal());
 	}
 
 	@Override
-	public ArrayList<ItemStack> getDrones(World world, int x, int y, int z, int fortune) {
-		ArrayList<ItemStack> ret = new ArrayList<ItemStack>();
-		ret.add(PluginApiculture.beeInterface.getMemberStack(createBee(world), EnumBeeType.DRONE.ordinal()));
-		return ret;
+	public List<ItemStack> getDrones(World world, int x, int y, int z, int fortune) {
+		ItemStack drone = beeTemplate.getMemberStack(EnumBeeType.DRONE);
+		return Collections.singletonList(drone);
 	}
 
 	@Override
 	public ArrayList<ItemStack> getAdditional(World world, int x, int y, int z, int fortune) {
-		ArrayList<ItemStack> ret = new ArrayList<ItemStack>();
+		ArrayList<ItemStack> ret = new ArrayList<>();
 		for (ItemStack stack : additional) {
 			ret.add(stack.copy());
 		}

src/main/java/forestry/apiculture/genetics/IBeeDefinition.java

@@ -0,0 +1,28 @@
+/*******************************************************************************
+ * 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 forestry.apiculture.genetics;
+
+import net.minecraft.item.ItemStack;
+
+import forestry.api.apiculture.EnumBeeType;
+import forestry.api.apiculture.IBee;
+import forestry.api.apiculture.IBeeGenome;
+import forestry.core.genetics.IGeneticDefinition;
+
+public interface IBeeDefinition extends IGeneticDefinition {
+	@Override
+	IBeeGenome getGenome();
+
+	@Override
+	IBee getIndividual();
+
+	ItemStack getMemberStack(EnumBeeType beeType);
+}

src/main/java/forestry/apiculture/genetics/JubilanceDefault.java

@@ -10,39 +10,27 @@
  ******************************************************************************/
 package forestry.apiculture.genetics;
 
-import net.minecraft.util.AxisAlignedBB;
-import net.minecraft.world.biome.BiomeGenBase;
-
 import forestry.api.apiculture.IAlleleBeeSpecies;
 import forestry.api.apiculture.IBeeGenome;
 import forestry.api.apiculture.IBeeHousing;
+import forestry.api.apiculture.IJubilanceProvider;
 import forestry.api.core.EnumHumidity;
 import forestry.api.core.EnumTemperature;
-import forestry.core.vect.Vect;
 
 public class JubilanceDefault implements IJubilanceProvider {
 
-	@Override
-	public boolean isJubilant(IAlleleBeeSpecies species, IBeeGenome genome, IBeeHousing housing) {
-		BiomeGenBase biome = BiomeGenBase.getBiome(housing.getBiomeId());
+	public static final JubilanceDefault instance = new JubilanceDefault();
 
-		if (EnumTemperature.getFromValue(biome.temperature) != species.getTemperature() ||
-				EnumHumidity.getFromValue(biome.rainfall) != species.getHumidity()) {
-			return false;
-		}
+	protected JubilanceDefault() {
 
-		return true;
 	}
 
-	protected AxisAlignedBB getBounding(IBeeGenome genome, IBeeHousing housing, float modifier) {
-		int[] areaAr = genome.getTerritory();
-		Vect area = new Vect(areaAr[0], areaAr[1], areaAr[2]).multiply(modifier);
-		Vect offset = new Vect(-Math.round(area.x / 2), -Math.round(area.y / 2), -Math.round(area.z / 2));
+	@Override
+	public boolean isJubilant(IAlleleBeeSpecies species, IBeeGenome genome, IBeeHousing housing) {
+		EnumTemperature temperature = housing.getTemperature();
+		EnumHumidity humidity = housing.getHumidity();
 
-		Vect min = new Vect(housing.getXCoord() + offset.x, housing.getYCoord() + offset.y, housing.getZCoord() + offset.z);
-		Vect max = new Vect(housing.getXCoord() + offset.x + area.x, housing.getYCoord() + offset.y + area.y, housing.getZCoord() + offset.z + area.z);
-
-		return AxisAlignedBB.getBoundingBox(min.x, min.y, min.z, max.x, max.y, max.z);
+		return temperature == species.getTemperature() && humidity == species.getHumidity();
 	}
 
 }

src/main/java/forestry/apiculture/genetics/JubilanceFactory.java

@@ -1,33 +1,28 @@
-/*******************************************************************************
- * 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 forestry.core;
-
-import forestry.api.core.IForestryConstants;
-import forestry.core.config.Defaults;
-
-public class ForestryConstants implements IForestryConstants {
-
-	@Override
-	public int getApicultureVillagerID() {
-		return Defaults.ID_VILLAGER_BEEKEEPER;
-	}
-
-	@Override
-	public int getArboricultureVillagerID() {
-		return Defaults.ID_VILLAGER_LUMBERJACK;
-	}
-
-	@Override
-	public String getVillagerChestGenKey() {
-		return Defaults.CHEST_GEN_HOOK_NATURALIST_CHEST;
-	}
-
-}
+/*******************************************************************************
+ * 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 forestry.apiculture.genetics;
+
+import net.minecraft.block.Block;
+
+import forestry.api.apiculture.IJubilanceFactory;
+import forestry.api.apiculture.IJubilanceProvider;
+
+public class JubilanceFactory implements IJubilanceFactory {
+	@Override
+	public IJubilanceProvider getDefault() {
+		return JubilanceDefault.instance;
+	}
+
+	@Override
+	public IJubilanceProvider getRequiresResource(Block block, int meta) {
+		return new JubilanceRequiresResource(block, meta);
+	}
+}

src/main/java/forestry/apiculture/genetics/JubilanceProviderHermit.java

@@ -13,24 +13,19 @@ package forestry.apiculture.genetics;
 import java.util.List;
 
 import net.minecraft.entity.EntityLiving;
-import net.minecraft.util.AxisAlignedBB;
 
 import forestry.api.apiculture.IAlleleBeeSpecies;
 import forestry.api.apiculture.IBeeGenome;
 import forestry.api.apiculture.IBeeHousing;
+import forestry.apiculture.genetics.alleles.AlleleEffect;
 
 /**
  * Hermits will not produce if there are any other living creatures nearby.
  */
 public class JubilanceProviderHermit extends JubilanceDefault {
-
 	@Override
 	public boolean isJubilant(IAlleleBeeSpecies species, IBeeGenome genome, IBeeHousing housing) {
-		AxisAlignedBB bounding = this.getBounding(genome, housing, 1.0f);
-
-		@SuppressWarnings("rawtypes")
-		List list = housing.getWorld().getEntitiesWithinAABB(EntityLiving.class, bounding);
+		List<EntityLiving> list = AlleleEffect.getEntitiesInRange(genome, housing, EntityLiving.class);
 		return list.size() <= 0;
 	}
-
 }

src/main/java/forestry/apiculture/genetics/JubilanceRequiresResource.java

@@ -12,33 +12,31 @@ package forestry.apiculture.genetics;
 
 import net.minecraft.block.Block;
 import net.minecraft.item.ItemStack;
+import net.minecraft.util.ChunkCoordinates;
 import net.minecraft.world.World;
 
 import forestry.api.apiculture.IAlleleBeeSpecies;
 import forestry.api.apiculture.IBeeGenome;
 import forestry.api.apiculture.IBeeHousing;
-import forestry.core.utils.StackUtils;
+import forestry.api.apiculture.IJubilanceProvider;
+import forestry.core.utils.ItemStackUtil;
 
-public class JubilanceReqRes implements IJubilanceProvider {
+public class JubilanceRequiresResource implements IJubilanceProvider {
 
 	private final ItemStack blockRequired;
 
-	public JubilanceReqRes(ItemStack blockRequired) {
-		this.blockRequired = blockRequired;
+	public JubilanceRequiresResource(Block block, int meta) {
+		this.blockRequired = new ItemStack(block, meta);
 	}
 
 	@Override
 	public boolean isJubilant(IAlleleBeeSpecies species, IBeeGenome genome, IBeeHousing housing) {
-
-		if (blockRequired == null) {
-			return true;
-		}
-
 		World world = housing.getWorld();
+		ChunkCoordinates housingCoords = housing.getCoordinates();
 
-		Block block = world.getBlock(housing.getXCoord(), housing.getYCoord() - 1, housing.getZCoord());
-		int meta = world.getBlockMetadata(housing.getXCoord(), housing.getYCoord() - 1, housing.getZCoord());
-		return StackUtils.equals(block, meta, blockRequired);
+		Block block = world.getBlock(housingCoords.posX, housingCoords.posY - 1, housingCoords.posZ);
+		int meta = world.getBlockMetadata(housingCoords.posX, housingCoords.posY - 1, housingCoords.posZ);
+		return ItemStackUtil.equals(block, meta, blockRequired);
 	}
 
 }

src/main/java/forestry/apiculture/genetics/MutationEMC.java

@@ -1,102 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.genetics;
-
-import java.lang.reflect.Field;
-
-import net.minecraft.item.ItemStack;
-import net.minecraft.tileentity.TileEntity;
-import net.minecraft.world.World;
-
-import forestry.api.apiculture.IBeeHousing;
-import forestry.api.genetics.IAllele;
-import forestry.api.genetics.IGenome;
-import forestry.core.proxy.Proxies;
-import forestry.core.vect.Vect;
-
-public class MutationEMC extends MutationReqRes {
-
-	private final int emcRequired;
-	private final Class<?> condenserClass;
-	private final Field emcField;
-
-	public MutationEMC(IAllele allele0, IAllele allele1, IAllele[] template, int chance, ItemStack blockRequired, Class<?> condenserClass, Field emcField,
-			int emcRequired) {
-		super(allele0, allele1, template, chance, blockRequired);
-
-		this.condenserClass = condenserClass;
-		this.emcField = emcField;
-		this.emcRequired = emcRequired;
-	}
-
-	@Override
-	public float getChance(IBeeHousing housing, IAllele allele0, IAllele allele1, IGenome genome0, IGenome genome1) {
-		float chance = super.getChance(housing, allele0, allele1, genome0, genome1);
-
-		// If we don't have any chance, return at once.
-		if (chance <= 0) {
-			return 0;
-		}
-
-		if (emcRequired <= 0) {
-			return chance;
-		}
-
-		World world = housing.getWorld();
-
-		Vect[] possibleTargets = new Vect[]{new Vect(housing.getXCoord() + 1, housing.getYCoord(), housing.getZCoord()),
-				new Vect(housing.getXCoord() - 1, housing.getYCoord(), housing.getZCoord()),
-				new Vect(housing.getXCoord(), housing.getYCoord(), housing.getZCoord() + 1),
-				new Vect(housing.getXCoord(), housing.getYCoord(), housing.getZCoord() - 1)};
-
-		for (Vect target : possibleTargets) {
-			if (!world.blockExists(target.x, target.y, target.z)) {
-				continue;
-			}
-
-			TileEntity entity = world.getTileEntity(target.x, target.y, target.z);
-			if (entity == null) {
-				continue;
-			}
-
-			if (!condenserClass.isInstance(entity)) {
-				Proxies.log.warning("Did not find a relay at " + target.toString());
-				continue;
-			}
-
-			int emc = 0;
-			try {
-				emc = emcField.getInt(entity);
-			} catch (Exception ex) {
-				Proxies.log.warning("Failed to fetch EMC information.");
-			}
-
-			if (emc < emcRequired * 80) {
-				continue;
-			}
-
-			boolean removedEMC = false;
-			try {
-				emcField.set(entity, emc - (emcRequired * 80));
-				removedEMC = true;
-			} catch (Exception ex) {
-				Proxies.log.warning("Failed to set EMC information.");
-			}
-
-			if (removedEMC) {
-				return chance;
-			}
-
-		}
-
-		return 0;
-	}
-}

src/main/java/forestry/apiculture/genetics/MutationReqRes.java

@@ -1,53 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.genetics;
-
-import net.minecraft.block.Block;
-import net.minecraft.item.ItemStack;
-import net.minecraft.world.World;
-
-import forestry.api.apiculture.IBeeHousing;
-import forestry.api.genetics.IAllele;
-import forestry.api.genetics.IGenome;
-import forestry.core.utils.StackUtils;
-
-public class MutationReqRes extends BeeMutation {
-
-	private final ItemStack blockRequired;
-
-	public MutationReqRes(IAllele allele0, IAllele allele1, IAllele[] template, int chance, ItemStack blockRequired) {
-		super(allele0, allele1, template, chance);
-		this.blockRequired = blockRequired;
-	}
-
-	@Override
-	public float getChance(IBeeHousing housing, IAllele allele0, IAllele allele1, IGenome genome0, IGenome genome1) {
-		float chance = super.getChance(housing, allele0, allele1, genome0, genome1);
-
-		// If we have no chance anyway, we don't need to check.
-		if (chance <= 0) {
-			return 0;
-		}
-
-		World world = housing.getWorld();
-		if (blockRequired == null) {
-			return chance;
-		}
-
-		Block block = world.getBlock(housing.getXCoord(), housing.getYCoord() - 1, housing.getZCoord());
-		int meta = world.getBlockMetadata(housing.getXCoord(), housing.getYCoord() - 1, housing.getZCoord());
-		if (StackUtils.equals(block, blockRequired) && meta == blockRequired.getItemDamage()) {
-			return chance;
-		} else {
-			return 0;
-		}
-	}
-}

src/main/java/forestry/apiculture/genetics/MutationTimeLimited.java

@@ -1,157 +0,0 @@
-/*******************************************************************************
- * 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 forestry.apiculture.genetics;
-
-import java.util.Calendar;
-
-import forestry.api.apiculture.IBeeHousing;
-import forestry.api.genetics.IAllele;
-import forestry.api.genetics.IGenome;
-
-public class MutationTimeLimited extends BeeMutation {
-
-	/**
-	 * Fed up with Date and Calendar and their shenanigans
-	 */
-	public static class DayMonth {
-
-		public final int day;
-		public final int month;
-
-		public DayMonth() {
-			this.day = Calendar.getInstance().get(Calendar.DAY_OF_MONTH);
-			this.month = Calendar.getInstance().get(Calendar.MONTH) + 1;
-		}
-
-		public DayMonth(int day, int month) {
-			this.day = day;
-			this.month = month;
-		}
-
-		public boolean between(DayMonth start, DayMonth end) {
-			if (equals(start) || equals(end)) {
-				return true;
-			}
-			if (start.month > end.month) {
-				return after(start) || before(end);
-			}
-			return after(start) && before(end);
-		}
-
-		public boolean before(DayMonth other) {
-
-			if (other.month > this.month) {
-				return true;
-			}
-
-			if (other.month < this.month) {
-				return false;
-			}
-
-			return this.day < other.day;
-		}
-
-		public boolean after(DayMonth other) {
-
-			if (other.month < this.month) {
-				return true;
-			}
-
-			if (other.month > this.month) {
-				return false;
-			}
-
-			return this.day > other.day;
-		}
-
-		@Override
-		public int hashCode() {
-			int hash = 7;
-			hash = 89 * hash + this.day;
-			hash = 89 * hash + this.month;
-			return hash;
-		}
-
-		@Override
-		public boolean equals(Object obj) {
-			if (obj == null) {
-				return false;
-			}
-			if (getClass() != obj.getClass()) {
-				return false;
-			}
-			final DayMonth other = (DayMonth) obj;
-			if (this.day != other.day) {
-				return false;
-			}
-			if (this.month != other.month) {
-				return false;
-			}
-			return true;
-		}
-
-		@Override
-		public String toString() {
-			return day + "." + month;
-		}
-	}
-
-	private final DayMonth start;
-	private final DayMonth end;
-
-	public MutationTimeLimited(IAllele allele0, IAllele allele1, IAllele[] template, int chance, DayMonth start) {
-		this(allele0, allele1, template, chance, start, null);
-	}
-
-	public MutationTimeLimited(IAllele allele0, IAllele allele1, IAllele[] template, int chance, DayMonth start, DayMonth end) {
-		super(allele0, allele1, template, chance);
-		this.start = start;
-		this.end = end;
-	}
-
-	@Override
-	public float getChance(IBeeHousing housing, IAllele allele0, IAllele allele1, IGenome genome0, IGenome genome1) {
-		float chance = super.getChance(housing, allele0, allele1, genome0, genome1);
-
-		if (chance == 0) {
-			return 0;
-		}
-
-		if (start == null) {
-			return chance;
-		}
-
-		DayMonth now = new DayMonth();
-
-		// If we are equal to start day, return chance.
-		if (Calendar.getInstance().get(Calendar.DAY_OF_MONTH) == start.day && Calendar.getInstance().get(Calendar.MONTH) + 1 == start.month) {
-			return chance;
-		}
-
-		// Still here but not time span? No mutation!
-		if (end == null) {
-			return 0;
-		}
-
-		// Equal to end date, return chance.
-		if (Calendar.getInstance().get(Calendar.DAY_OF_MONTH) == end.day && Calendar.getInstance().get(Calendar.MONTH) + 1 == end.month) {
-			return chance;
-		}
-
-		// Still a chance we are in between
-		if (now.between(start, end)) {
-			return chance;
-		}
-
-		// Now we finally failed.
-		return 0;
-	}
-}

src/main/java/forestry/apiculture/genetics/alleles/AlleleBeeSpecies.java

@@ -0,0 +1,213 @@
+/*******************************************************************************
+ * 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 forestry.apiculture.genetics.alleles;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+
+import com.mojang.authlib.GameProfile;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+import forestry.api.apiculture.BeeManager;
+import forestry.api.apiculture.EnumBeeType;
+import forestry.api.apiculture.IAlleleBeeSpeciesCustom;
+import forestry.api.apiculture.IBeeGenome;
+import forestry.api.apiculture.IBeeHousing;
+import forestry.api.apiculture.IBeeIconColourProvider;
+import forestry.api.apiculture.IBeeIconProvider;
+import forestry.api.apiculture.IBeeRoot;
+import forestry.api.apiculture.IJubilanceProvider;
+import forestry.api.core.IIconProvider;
+import forestry.api.genetics.IClassification;
+import forestry.api.genetics.IIndividual;
+import forestry.apiculture.genetics.DefaultBeeIconColourProvider;
+import forestry.apiculture.genetics.DefaultBeeIconProvider;
+import forestry.apiculture.genetics.JubilanceDefault;
+import forestry.core.genetics.alleles.AlleleSpecies;
+import forestry.core.utils.ItemStackUtil;
+
+public class AlleleBeeSpecies extends AlleleSpecies implements IAlleleBeeSpeciesCustom {
+	private final Map<ItemStack, Float> productChances = new HashMap<>();
+	private final Map<ItemStack, Float> specialtyChances = new HashMap<>();
+
+	private IBeeIconProvider beeIconProvider;
+	private IBeeIconColourProvider beeIconColourProvider;
+	private IJubilanceProvider jubilanceProvider;
+	private boolean nocturnal = false;
+
+	public AlleleBeeSpecies(String uid, String unlocalizedName, String authority, String unlocalizedDescription, boolean dominant, IClassification branch, String binomial, int primaryColor, int secondaryColor) {
+		super(uid, unlocalizedName, authority, unlocalizedDescription, dominant, branch, binomial);
+
+		beeIconProvider = DefaultBeeIconProvider.instance;
+		beeIconColourProvider = new DefaultBeeIconColourProvider(primaryColor, secondaryColor);
+		jubilanceProvider = JubilanceDefault.instance;
+	}
+
+	@Override
+	public IBeeRoot getRoot() {
+		return BeeManager.beeRoot;
+	}
+
+	@Override
+	public IAlleleBeeSpeciesCustom addProduct(ItemStack product, Float chance) {
+		if (product == null || product.getItem() == null) {
+			throw new IllegalArgumentException("Tried to add null product");
+		}
+		if (chance <= 0.0f || chance > 1.0f) {
+			throw new IllegalArgumentException("chance must be in the range (0, 1]");
+		}
+		this.productChances.put(product, chance);
+		return this;
+	}
+
+	@Override
+	public IAlleleBeeSpeciesCustom addSpecialty(ItemStack specialty, Float chance) {
+		if (specialty == null || specialty.getItem() == null) {
+			throw new IllegalArgumentException("Tried to add null specialty");
+		}
+		if (chance <= 0.0f || chance > 1.0f) {
+			throw new IllegalArgumentException("chance must be in the range (0, 1]");
+		}
+		this.specialtyChances.put(specialty, chance);
+		return this;
+	}
+
+	@Override
+	public IAlleleBeeSpeciesCustom setJubilanceProvider(IJubilanceProvider provider) {
+		this.jubilanceProvider = provider;
+		return this;
+	}
+
+	@Override
+	public IAlleleBeeSpeciesCustom setNocturnal() {
+		nocturnal = true;
+		return this;
+	}
+
+	@Override
+	public IAlleleBeeSpeciesCustom setCustomBeeIconProvider(IBeeIconProvider beeIconProvider) {
+		this.beeIconProvider = beeIconProvider;
+		return this;
+	}
+
+	@Override
+	public IAlleleBeeSpeciesCustom setCustomBeeIconColourProvider(IBeeIconColourProvider beeIconColourProvider) {
+		this.beeIconColourProvider = beeIconColourProvider;
+		return this;
+	}
+
+	/* RESEARCH */
+	@Override
+	public float getResearchSuitability(ItemStack itemstack) {
+		if (itemstack == null) {
+			return 0f;
+		}
+
+		for (ItemStack stack : productChances.keySet()) {
+			if (stack.isItemEqual(itemstack)) {
+				return 1.0f;
+			}
+		}
+		for (ItemStack stack : specialtyChances.keySet()) {
+			if (stack.isItemEqual(itemstack)) {
+				return 1.0f;
+			}
+		}
+
+		return super.getResearchSuitability(itemstack);
+	}
+
+	@Override
+	public ItemStack[] getResearchBounty(World world, GameProfile researcher, IIndividual individual, int bountyLevel) {
+		ArrayList<ItemStack> bounty = new ArrayList<>();
+		Collections.addAll(bounty, super.getResearchBounty(world, researcher, individual, bountyLevel));
+
+		if (bountyLevel > 10) {
+			for (ItemStack stack : specialtyChances.keySet()) {
+				bounty.add(ItemStackUtil.copyWithRandomSize(stack, (int) ((float) bountyLevel / 2), world.rand));
+			}
+		}
+		for (ItemStack stack : productChances.keySet()) {
+			bounty.add(ItemStackUtil.copyWithRandomSize(stack, (int) ((float) bountyLevel / 2), world.rand));
+		}
+		return bounty.toArray(new ItemStack[bounty.size()]);
+	}
+
+	/* OTHER */
+	@Override
+	public boolean isNocturnal() {
+		return nocturnal;
+	}
+
+	@Override
+	public Map<ItemStack, Float> getProductChances() {
+		return productChances;
+	}
+
+	@Override
+	public Map<ItemStack, Float> getSpecialtyChances() {
+		return specialtyChances;
+	}
+
+	@Override
+	public boolean isJubilant(IBeeGenome genome, IBeeHousing housing) {
+		return jubilanceProvider.isJubilant(this, genome, housing);
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public IIconProvider getIconProvider() {
+		return new BeeIconProviderWrapper(beeIconProvider);
+	}
+
+	@Override
+	public IIcon getIcon(EnumBeeType type, int renderPass) {
+		return beeIconProvider.getIcon(type, renderPass);
+	}
+
+	@Override
+	public int getIconColour(int renderPass) {
+		return beeIconColourProvider.getIconColour(renderPass);
+	}
+
+	@Override
+	public String getEntityTexture() {
+		return null;
+	}
+
+	private static class BeeIconProviderWrapper implements IIconProvider {
+
+		private final IBeeIconProvider beeIconProvider;
+
+		public BeeIconProviderWrapper(IBeeIconProvider beeIconProvider) {
+			this.beeIconProvider = beeIconProvider;
+		}
+
+		@Override
+		public IIcon getIcon(short texUID) {
+			return null;
+		}
+
+		@Override
+		public void registerIcons(IIconRegister register) {
+			beeIconProvider.registerIcons(register);
+		}
+	}
+}