Fix #326 decorative leaves should not pollinate

Minor code cleanup
Fix #325 Centrifuge dupe bug
2026-11-14 17:14:46 +00:00 · 2014-11-15 04:15:20 -08:00 · 2014-11-15 04:15:14 -08:00 · 2014-11-15 04:13:46 -08:00 · 2014-11-15 04:12:44 -08:00 · 2014-11-08 21:40:45 -08:00
1701 changed files with 63436 additions and 81646 deletions
@@ -5,8 +5,6 @@
 !/forestry_techne
 !/gradle/wrapper
 !/src
-!/api
-!/test

 # files
 !/.gitignore
@@ -14,11 +12,9 @@
 !/CLA.txt
 !/CONTRIBUTING.md
 !/LICENSE.txt
-!/license-header.txt
 !/README.md
-!/gradle.properties
+!/application.properties
 !/build.gradle
 !/build.xml
 !/gradlew
-!/gradlew.bat
-.DS_Store
+!/gradlew.bat
@@ -1,9 +1,6 @@
 [submodule "lang"]
 	path = lang
 	url = https://github.com/ForestryMC/Forestry-Localization.git
-[submodule "api/redstoneflux"]
-	path = api/redstoneflux
-	url = https://github.com/CoFH/RedstoneFlux-API.git
-[submodule "api/forestry"]
-	path = api/forestry
+[submodule "api"]
+	path = api
 	url = https://github.com/ForestryMC/ForestryAPI.git
@@ -1,6 +1,6 @@
 Forestry
 ====================================
-
+ 
 ### What is it?

 Forestry is a modification for the game Minecraft and known primarily for its farms and bees. 
@@ -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://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.**
+**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.**

 ### License & Copyright

@@ -0,0 +1,6 @@
+mcversion=1.7.10
+forgeversion=10.13.0.1207
+version_major=3
+version_minor=2
+version_patch=0
+
@@ -19,7 +19,8 @@ buildscript {

 apply plugin: 'forge'
 apply plugin: 'maven'
-apply plugin: 'java'
+
+loadProperties()

 version = version_major + '.' + version_minor + '.' + version_patch + '.' + getBuildNumber()
 if (project.hasProperty('buildQualifier')) {
@@ -30,13 +31,10 @@ archivesBaseName = "forestry_" + mcversion

 ext.dirDest = './build/dist'
 ext.dirLang = "./lang"
+ext.dirApi = "./api"

-ext.apiForestry = "./api/forestry"
-ext.apiRedstoneFlux = "./api/redstoneflux"
-
-// java version
-sourceCompatibility = 1.7
-targetCompatibility = 1.7
+ext.CraftGuideRepo = "https://github.com/Uristqwerty/CraftGuide.git"
+ext.CraftGuideTmp = "build/tmp/CraftGuide"

 minecraft {
 	version = mcversion + "-" + forgeversion
@@ -44,15 +42,19 @@ 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
-			srcDir project.apiRedstoneFlux + "/src/main/java"
+			srcDir project.dirApi
 		}
 		resources {
 			srcDir project.dirLang
@@ -65,43 +67,16 @@ 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
+	apis
+	compile.extendsFrom apis
 }

 dependencies {
-	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'
+	compile 'net.industrial-craft:industrialcraft-2:2.2.575-experimental:api'
+	apis 'com.mod-buildcraft:buildcraft:6.1.5:dev'
 }

 processResources {
@@ -143,90 +118,198 @@ 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"

-	// Copy various READMEs and Licensing files into the jar
-	into ('forestry/api') {
-		from project.apiForestry + "/LICENSE.txt"
-	}
-	into ('cofh/api') {
-		from project.apiRedstoneFlux + "/LICENSE - LGPLv3.txt"
-	}
-	into ('invtweaks/api') {
-		from "./src/main/java/invtweaks/LICENSE.txt"
-	}
-
-	configurations.shade.each{ dep ->
-		from(project.zipTree(dep)){
-			exclude 'META-INF', 'META-INF/**', 'mcmod.info'
+	from {
+		configurations.apis.collect {
+			it.isDirectory() ? it : zipTree(it).matching {
+				include '**/api/**'
+			}
 		}
 	}
 }

-task mainJar(type: Jar, dependsOn: 'reobf') {
+task mainJarSigned ( type: Jar, dependsOn: 'reobf' ) {
 	from (zipTree(jar.getArchivePath())) {
-		include '**'
+		exclude '**/api/**'
 		exclude '**/codechicken/**'
-		exclude '**/uristqwerty/**'
+		exclude '**/old/lang/**'
 	}

-	destinationDir = file(dirDest)
 	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-	includeEmptyDirs = false
+	destinationDir = file("build/tmp")
+	archiveName = "signed.jar"

-	manifest{
-		attributes 'TweakClass': 'forestry.shade.javacheck.Java7Checker'
+	doLast {
+		if (project.hasProperty('signingKeystore')) {
+			ant.signjar(jar: getArchivePath(),
+				alias: signingAlias,
+				keystore: signingKeystore,
+				storepass: signingStorepass)
+		} else {
+			println 'Signing disabled, gradle.properties is missing.'
+		}
 	}
 }

-task devJar(type: Jar, dependsOn: 'classes') {
-	from (sourceSets.main.output) {
-		exclude '**/codechicken/**'
-		exclude '**/uristqwerty/**'
+task mainJar ( type: Zip, dependsOn: mainJarSigned ) {
+	from (zipTree(mainJarSigned.getArchivePath())) {
+		include '**'
+	}
+
+	from (zipTree(jar.getArchivePath())) {
+		include '**'
+		exclude '**/codechicken/**'
+		exclude '**/old/lang/**'
 	}

-	destinationDir = file(dirDest)
 	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+	destinationDir = file(dirDest)
 	includeEmptyDirs = false
+	extension = 'jar'
+}
+
+task devJarSigned ( type: Jar, dependsOn: 'classes' ) {
+	from(sourceSets.main.output) {
+		exclude '**/api/**'
+		exclude '**/codechicken/**'
+		exclude '**/old/lang/**'
+	}
+
+	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.'
+		}
+	}
+}
+
+task devJar ( type: Zip, dependsOn: devJarSigned ) {
+	from (zipTree(devJarSigned.getArchivePath())) {
+		include '**'
+	}
+
+	from(sourceSets.main.allSource) {
+		include '**'
+		exclude '**/codechicken/**'
+		exclude '**/old/lang/**'
+	}
+
+	from(sourceSets.main.output) {
+		include '**'
+		exclude '**/codechicken/**'
+		exclude '**/old/lang/**'
+	}
+
+	from {
+		configurations.apis.collect {
+			it.isDirectory() ? it : zipTree(it).matching {
+				include '**/api/**'
+			}
+		}
+	}
+
+	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+	destinationDir = file(dirDest)
+	extension = 'jar'

 	classifier = 'dev'
 }

 task apiJar(type: Jar, dependsOn: 'classes') {
-	from project.apiForestry
-	from(sourceSets.main.output) {
+	from (dirApi) {
+		include '**'
+	}
+	
+	from (sourceSets.main.output) {
 		include 'forestry/api/**'
 	}
-
+	
 	destinationDir = file(dirDest)
-	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-	includeEmptyDirs = false
-
+	extension = 'jar'
 	classifier = 'api'
 }

-task sourceJar(type: Jar, dependsOn: 'classes') {
-	from (sourceSets.main.allSource) {
-		exclude '**/codechicken/**'
-		exclude '**/uristqwerty/**'
+task release(dependsOn: [apiJar, devJar, mainJar]) {
+	doLast {
+		println '*************************************************************'
+		println 'This build will be version: ' +  project.version
+		println '*************************************************************'
 	}
-
-	destinationDir = file(dirDest)
-	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-	includeEmptyDirs = false
-
-	classifier = 'sources'
 }

-task release (dependsOn: [mainJar, apiJar, devJar, sourceJar]) {
+afterEvaluate {
+	compileApiJava.dependsOn initCraftGuide
 }

 artifacts {
 	archives apiJar
 	archives devJar
-	archives sourceJar
 }

 uploadArchives {
@@ -241,9 +324,6 @@ uploadArchives {
 				addFilter('dev') { artifact, file ->
 					file == devJar.archivePath
 				}
-				addFilter('source') { artifact, file ->
-					file == sourceJar.archivePath
-				}
 			}
 		} else {
 			println 'Archives upload disabled, gradle.properties is missing.'
@@ -251,6 +331,19 @@ 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"
 }
@@ -1,6 +0,0 @@
-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
@@ -1,5 +0,0 @@
-mcversion=1.7.10
-forgeversion=10.13.4.1566-1.7.10
-version_major=4
-version_minor=2
-version_patch=4
@@ -1,12 +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
- *******************************************************************************
- */
@@ -1,21 +1,21 @@
-The MIT License (MIT)
-
-Copyright (c) 2014 Uristqwerty
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+The MIT License (MIT)
+
+Copyright (c) 2014 ChickenBones
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
@@ -0,0 +1,38 @@
+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;
+    }
+}
@@ -0,0 +1,49 @@
+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);
+}
@@ -0,0 +1,48 @@
+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;
+    }
+}
@@ -0,0 +1,11 @@
+package cofh.api;
+
+public class CoFHAPIProps {
+
+	private CoFHAPIProps() {
+
+	}
+
+	public static final String VERSION = "1.7.10R1.0.1";
+
+}
@@ -0,0 +1,158 @@
+package cofh.api.energy;
+
+import net.minecraft.nbt.NBTTagCompound;
+
+/**
+ * Reference implementation of {@link IEnergyStorage}. Use/extend this or implement your own.
+ * 
+ * @author King Lemming
+ * 
+ */
+public class EnergyStorage implements IEnergyStorage {
+
+	protected int energy;
+	protected int capacity;
+	protected int maxReceive;
+	protected int maxExtract;
+
+	public EnergyStorage(int capacity) {
+
+		this(capacity, capacity, capacity);
+	}
+
+	public EnergyStorage(int capacity, int maxTransfer) {
+
+		this(capacity, maxTransfer, maxTransfer);
+	}
+
+	public EnergyStorage(int capacity, int maxReceive, int maxExtract) {
+
+		this.capacity = capacity;
+		this.maxReceive = maxReceive;
+		this.maxExtract = maxExtract;
+	}
+
+	public EnergyStorage readFromNBT(NBTTagCompound nbt) {
+
+		this.energy = nbt.getInteger("Energy");
+
+		if (energy > capacity) {
+			energy = capacity;
+		}
+		return this;
+	}
+
+	public NBTTagCompound writeToNBT(NBTTagCompound nbt) {
+
+		if (energy < 0) {
+			energy = 0;
+		}
+		nbt.setInteger("Energy", energy);
+		return nbt;
+	}
+
+	public void setCapacity(int capacity) {
+
+		this.capacity = capacity;
+
+		if (energy > capacity) {
+			energy = capacity;
+		}
+	}
+
+	public void setMaxTransfer(int maxTransfer) {
+
+		setMaxReceive(maxTransfer);
+		setMaxExtract(maxTransfer);
+	}
+
+	public void setMaxReceive(int maxReceive) {
+
+		this.maxReceive = maxReceive;
+	}
+
+	public void setMaxExtract(int maxExtract) {
+
+		this.maxExtract = maxExtract;
+	}
+
+	public int getMaxReceive() {
+
+		return maxReceive;
+	}
+
+	public int getMaxExtract() {
+
+		return maxExtract;
+	}
+
+	/**
+	 * This function is included to allow for server -&gt; client sync. Do not call this externally to the containing Tile Entity, as not all IEnergyHandlers are
+	 * guaranteed to have it.
+	 * 
+	 * @param energy
+	 */
+	public void setEnergyStored(int energy) {
+
+		this.energy = energy;
+
+		if (this.energy > capacity) {
+			this.energy = capacity;
+		} else if (this.energy < 0) {
+			this.energy = 0;
+		}
+	}
+
+	/**
+	 * This function is included to allow the containing tile to directly and efficiently modify the energy contained in the EnergyStorage. Do not rely on this
+	 * externally, as not all IEnergyHandlers are guaranteed to have it.
+	 * 
+	 * @param energy
+	 */
+	public void modifyEnergyStored(int energy) {
+
+		this.energy += energy;
+
+		if (this.energy > capacity) {
+			this.energy = capacity;
+		} else if (this.energy < 0) {
+			this.energy = 0;
+		}
+	}
+
+	/* IEnergyStorage */
+	@Override
+	public int receiveEnergy(int maxReceive, boolean simulate) {
+
+		int energyReceived = Math.min(capacity - energy, Math.min(this.maxReceive, maxReceive));
+
+		if (!simulate) {
+			energy += energyReceived;
+		}
+		return energyReceived;
+	}
+
+	@Override
+	public int extractEnergy(int maxExtract, boolean simulate) {
+
+		int energyExtracted = Math.min(energy, Math.min(this.maxExtract, maxExtract));
+
+		if (!simulate) {
+			energy -= energyExtracted;
+		}
+		return energyExtracted;
+	}
+
+	@Override
+	public int getEnergyStored() {
+
+		return energy;
+	}
+
+	@Override
+	public int getMaxEnergyStored() {
+
+		return capacity;
+	}
+
+}
@@ -0,0 +1,21 @@
+package cofh.api.energy;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+/**
+ * Implement this interface on TileEntities which should connect to energy transportation blocks. This is intended for blocks which generate energy but do not
+ * accept it; otherwise just use IEnergyHandler.
+ * 
+ * Note that {@link IEnergyHandler} is an extension of this.
+ * 
+ * @author King Lemming
+ * 
+ */
+public interface IEnergyConnection {
+
+	/**
+	 * Returns TRUE if the TileEntity can connect on a given side.
+	 */
+	boolean canConnectEnergy(ForgeDirection from);
+
+}
@@ -0,0 +1,52 @@
+package cofh.api.energy;
+
+import net.minecraft.item.ItemStack;
+
+/**
+ * Implement this interface on Item classes that support external manipulation of their internal energy storages.
+ * 
+ * A reference implementation is provided {@link ItemEnergyContainer}.
+ * 
+ * @author King Lemming
+ * 
+ */
+public interface IEnergyContainerItem {
+
+	/**
+	 * Adds energy to a container item. Returns the quantity of energy that was accepted. This should always return 0 if the item cannot be externally charged.
+	 * 
+	 * @param container
+	 *            ItemStack to be charged.
+	 * @param maxReceive
+	 *            Maximum amount of energy to be sent into the item.
+	 * @param simulate
+	 *            If TRUE, the charge will only be simulated.
+	 * @return Amount of energy that was (or would have been, if simulated) received by the item.
+	 */
+	int receiveEnergy(ItemStack container, int maxReceive, boolean simulate);
+
+	/**
+	 * Removes energy from a container item. Returns the quantity of energy that was removed. This should always return 0 if the item cannot be externally
+	 * discharged.
+	 * 
+	 * @param container
+	 *            ItemStack to be discharged.
+	 * @param maxExtract
+	 *            Maximum amount of energy to be extracted from the item.
+	 * @param simulate
+	 *            If TRUE, the discharge will only be simulated.
+	 * @return Amount of energy that was (or would have been, if simulated) extracted from the item.
+	 */
+	int extractEnergy(ItemStack container, int maxExtract, boolean simulate);
+
+	/**
+	 * Get the amount of energy currently stored in the container item.
+	 */
+	int getEnergyStored(ItemStack container);
+
+	/**
+	 * Get the max amount of energy that can be stored in the container item.
+	 */
+	int getMaxEnergyStored(ItemStack container);
+
+}
@@ -0,0 +1,51 @@
+package cofh.api.energy;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+/**
+ * Implement this interface on Tile Entities which should handle energy, generally storing it in one or more internal {@link IEnergyStorage} objects.
+ * 
+ * A reference implementation is provided {@link TileEnergyHandler}.
+ * 
+ * @author King Lemming
+ * 
+ */
+public interface IEnergyHandler extends IEnergyConnection {
+
+	/**
+	 * Add energy to an IEnergyHandler, internal distribution is left entirely to the IEnergyHandler.
+	 * 
+	 * @param from
+	 *            Orientation the energy is received from.
+	 * @param maxReceive
+	 *            Maximum amount of energy to receive.
+	 * @param simulate
+	 *            If TRUE, the charge will only be simulated.
+	 * @return Amount of energy that was (or would have been, if simulated) received.
+	 */
+	int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate);
+
+	/**
+	 * Remove energy from an IEnergyHandler, internal distribution is left entirely to the IEnergyHandler.
+	 * 
+	 * @param from
+	 *            Orientation the energy is extracted from.
+	 * @param maxExtract
+	 *            Maximum amount of energy to extract.
+	 * @param simulate
+	 *            If TRUE, the extraction will only be simulated.
+	 * @return Amount of energy that was (or would have been, if simulated) extracted.
+	 */
+	int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate);
+
+	/**
+	 * Returns the amount of energy currently stored.
+	 */
+	int getEnergyStored(ForgeDirection from);
+
+	/**
+	 * Returns the maximum amount of energy that can be stored.
+	 */
+	int getMaxEnergyStored(ForgeDirection from);
+
+}
@@ -0,0 +1,45 @@
+package cofh.api.energy;
+
+/**
+ * An energy storage is the unit of interaction with Energy inventories.
+ * 
+ * A reference implementation can be found at {@link EnergyStorage}.
+ * 
+ * @author King Lemming
+ * 
+ */
+public interface IEnergyStorage {
+
+	/**
+	 * Adds energy to the storage. Returns quantity of energy that was accepted.
+	 * 
+	 * @param maxReceive
+	 *            Maximum amount of energy to be inserted.
+	 * @param simulate
+	 *            If TRUE, the insertion will only be simulated.
+	 * @return Amount of energy that was (or would have been, if simulated) accepted by the storage.
+	 */
+	int receiveEnergy(int maxReceive, boolean simulate);
+
+	/**
+	 * Removes energy from the storage. Returns quantity of energy that was removed.
+	 * 
+	 * @param maxExtract
+	 *            Maximum amount of energy to be extracted.
+	 * @param simulate
+	 *            If TRUE, the extraction will only be simulated.
+	 * @return Amount of energy that was (or would have been, if simulated) extracted from the storage.
+	 */
+	int extractEnergy(int maxExtract, boolean simulate);
+
+	/**
+	 * Returns the amount of energy currently stored.
+	 */
+	int getEnergyStored();
+
+	/**
+	 * Returns the maximum amount of energy that can be stored.
+	 */
+	int getMaxEnergyStored();
+
+}
@@ -0,0 +1,110 @@
+package cofh.api.energy;
+
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+
+/**
+ * Reference implementation of {@link IEnergyContainerItem}. Use/extend this or implement your own.
+ * 
+ * @author King Lemming
+ * 
+ */
+public class ItemEnergyContainer extends Item implements IEnergyContainerItem {
+
+	protected int capacity;
+	protected int maxReceive;
+	protected int maxExtract;
+
+	public ItemEnergyContainer() {
+
+	}
+
+	public ItemEnergyContainer(int capacity) {
+
+		this(capacity, capacity, capacity);
+	}
+
+	public ItemEnergyContainer(int capacity, int maxTransfer) {
+
+		this(capacity, maxTransfer, maxTransfer);
+	}
+
+	public ItemEnergyContainer(int capacity, int maxReceive, int maxExtract) {
+
+		this.capacity = capacity;
+		this.maxReceive = maxReceive;
+		this.maxExtract = maxExtract;
+	}
+
+	public ItemEnergyContainer setCapacity(int capacity) {
+
+		this.capacity = capacity;
+		return this;
+	}
+
+	public void setMaxTransfer(int maxTransfer) {
+
+		setMaxReceive(maxTransfer);
+		setMaxExtract(maxTransfer);
+	}
+
+	public void setMaxReceive(int maxReceive) {
+
+		this.maxReceive = maxReceive;
+	}
+
+	public void setMaxExtract(int maxExtract) {
+
+		this.maxExtract = maxExtract;
+	}
+
+	/* IEnergyContainerItem */
+	@Override
+	public int receiveEnergy(ItemStack container, int maxReceive, boolean simulate) {
+
+		if (container.stackTagCompound == null) {
+			container.stackTagCompound = new NBTTagCompound();
+		}
+		int energy = container.stackTagCompound.getInteger("Energy");
+		int energyReceived = Math.min(capacity - energy, Math.min(this.maxReceive, maxReceive));
+
+		if (!simulate) {
+			energy += energyReceived;
+			container.stackTagCompound.setInteger("Energy", energy);
+		}
+		return energyReceived;
+	}
+
+	@Override
+	public int extractEnergy(ItemStack container, int maxExtract, boolean simulate) {
+
+		if (container.stackTagCompound == null || !container.stackTagCompound.hasKey("Energy")) {
+			return 0;
+		}
+		int energy = container.stackTagCompound.getInteger("Energy");
+		int energyExtracted = Math.min(energy, Math.min(this.maxExtract, maxExtract));
+
+		if (!simulate) {
+			energy -= energyExtracted;
+			container.stackTagCompound.setInteger("Energy", energy);
+		}
+		return energyExtracted;
+	}
+
+	@Override
+	public int getEnergyStored(ItemStack container) {
+
+		if (container.stackTagCompound == null || !container.stackTagCompound.hasKey("Energy")) {
+			return 0;
+		}
+		return container.stackTagCompound.getInteger("Energy");
+	}
+
+	@Override
+	public int getMaxEnergyStored(ItemStack container) {
+
+		return capacity;
+	}
+
+}
@@ -0,0 +1,62 @@
+package cofh.api.energy;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.ForgeDirection;
+
+/**
+ * Reference implementation of {@link IEnergyHandler}. Use/extend this or implement your own.
+ * 
+ * @author King Lemming
+ * 
+ */
+public class TileEnergyHandler extends TileEntity implements IEnergyHandler {
+
+	protected EnergyStorage storage = new EnergyStorage(32000);
+
+	@Override
+	public void readFromNBT(NBTTagCompound nbt) {
+
+		super.readFromNBT(nbt);
+		storage.readFromNBT(nbt);
+	}
+
+	@Override
+	public void writeToNBT(NBTTagCompound nbt) {
+
+		super.writeToNBT(nbt);
+		storage.writeToNBT(nbt);
+	}
+
+	/* IEnergyHandler */
+	@Override
+	public boolean canConnectEnergy(ForgeDirection from) {
+
+		return true;
+	}
+
+	@Override
+	public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) {
+
+		return storage.receiveEnergy(maxReceive, simulate);
+	}
+
+	@Override
+	public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) {
+
+		return storage.extractEnergy(maxExtract, simulate);
+	}
+
+	@Override
+	public int getEnergyStored(ForgeDirection from) {
+
+		return storage.getEnergyStored();
+	}
+
+	@Override
+	public int getMaxEnergyStored(ForgeDirection from) {
+
+		return storage.getMaxEnergyStored();
+	}
+
+}
@@ -0,0 +1,10 @@
+/**
+ * (C) 2014 Team CoFH / CoFH / Cult of the Full Hub
+ * http://www.teamcofh.com
+ */
+@API(apiVersion = CoFHAPIProps.VERSION, owner = "CoFHAPI", provides = "CoFHAPI|energy")
+package cofh.api.energy;
+
+import cofh.api.CoFHAPIProps;
+import cpw.mods.fml.common.API;
+
@@ -0,0 +1,9 @@
+/**
+ * (C) 2014 Team CoFH / CoFH / Cult of the Full Hub
+ * http://www.teamcofh.com
+ */
+@API(apiVersion = CoFHAPIProps.VERSION, owner = "CoFHLib", provides = "CoFHAPI")
+package cofh.api;
+
+import cpw.mods.fml.common.API;
+
@@ -4,50 +4,43 @@
 * 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;

-import java.io.File;
-
-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.core.ForestryAPI;
-import forestry.core.EventHandlerCore;
-import forestry.core.config.Config;
-import forestry.core.config.Constants;
-import forestry.core.config.GameMode;
+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.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.Log;
+import forestry.core.utils.FluidMap;
+import forestry.core.utils.ItemStackMap;
 import forestry.core.utils.StringUtil;
-import forestry.core.worldgen.WorldGenerator;
-import forestry.plugins.PluginManager;
+import java.io.File;
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;

 /**
 * Forestry Minecraft Mod
@@ -55,105 +48,103 @@ import forestry.plugins.PluginManager;
 * @author SirSengir
 */
@Mod(
-		modid = Constants.MOD,
+		modid = Defaults.MOD,
 		name = "Forestry",
 		version = Version.VERSION,
-		guiFactory = "forestry.core.config.ForestryGuiConfigFactory",
-		dependencies = "required-after:Forge@[10.13.4.1566,);"
-				+ "after:Buildcraft|Core@[6.1.7,);"
-				+ "after:ExtrabiomesXL;"
-				+ "after:BiomesOPlenty;"
-				+ "after:IC2@[2.0.140,);"
-				+ "after:Natura@[2.2.0,);"
-				+ "after:HardcoreEnderExpansion;")
+		dependencies = "required-after:Forge@[10.13.0.1207,);"
+		+ "after:Buildcraft|Core;"
+		+ "after:ExtrabiomesXL;"
+		+ "after:BiomesOPlenty;"
+		+ "after:IC2")
+//, certificateFingerprint = Version.FINGERPRINT)
 public class Forestry {

-	@Mod.Instance(Constants.MOD)
+	@Mod.Instance(Defaults.MOD)
 	public static Forestry instance;
 	private File configFolder;

 	public Forestry() {
-		ForestryAPI.instance = this;
-		ForestryAPI.forestryConstants = new Constants();
-		ForestryAPI.errorStateRegistry = new ErrorStateRegistry();
-		EnumErrorCode.init();
+		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>();
 	}
-
+	@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();
-
-		// 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();
+		core.preInit(event.getSourceFile(), this);
 	}

 	@EventHandler
 	public void init(FMLInitializationEvent event) {
-		// Register gui handler
-		NetworkRegistry.INSTANCE.registerGuiHandler(this, new GuiHandler());
-
-		PluginManager.runInit();
+		core.init(this);
 	}

 	@EventHandler
 	public void postInit(FMLPostInitializationEvent event) {
-		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));
+		core.postInit();
 	}

 	@EventHandler
 	public void serverStarting(FMLServerStartingEvent event) {
-		PluginManager.serverStarting(event.getServer());
+		core.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) {
-		PluginManager.processIMCMessages(event.getMessages());
+		core.processIMCMessages(event.getMessages());
 	}

 	@EventHandler
 	public void missingMapping(FMLMissingMappingsEvent event) {
-		for (MissingMapping mapping : event.get()) {
+		for (MissingMapping mapping : event.get())
 			if (mapping.type == Type.BLOCK) {
-				Block block = GameRegistry.findBlock(Constants.MOD, StringUtil.cleanTags(mapping.name));
+				Block block = GameRegistry.findBlock(Defaults.MOD, StringUtil.cleanTags(mapping.name));
 				if (block != null) {
 					mapping.remap(block);
-					Log.warning("Remapping block " + mapping.name + " to " + StringUtil.cleanBlockName(block));
+					Proxies.log.warning("Remapping block " + mapping.name + " to " + StringUtil.cleanBlockName(block));
 				}
 			} else {
-				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));
+				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 if (mapping.name.equals("Forestry:builderBackpack")) {
+					mapping.remap(ForestryItem.builderBackpack.item());
+					Proxies.log.warning("Remapping item " + mapping.name + " to " + ForestryItem.builderBackpack.name());
+				} else if (mapping.name.equals("Forestry:builderBackpackT2")) {
+					mapping.remap(ForestryItem.builderBackpackT2.item());
+					Proxies.log.warning("Remapping item " + mapping.name + " to " + ForestryItem.builderBackpackT2.name());
+				} else if (mapping.name.equals("Forestry:adventurerBackpack")) {
+					mapping.remap(ForestryItem.adventurerBackpack.item());
+					Proxies.log.warning("Remapping item " + mapping.name + " to " + ForestryItem.adventurerBackpack.name());
+				} else if (mapping.name.equals("Forestry:adventurerBackpackT2")) {
+					mapping.remap(ForestryItem.adventurerBackpackT2.item());
+					Proxies.log.warning("Remapping item " + mapping.name + " to " + ForestryItem.adventurerBackpackT2.name());
+				} else if (mapping.name.equals("Forestry:shortMead")) {
+					mapping.remap(ForestryItem.beverage.item());
+					Proxies.log.warning("Remapping item " + mapping.name + " to " + ForestryItem.beverage.name());
 				}
 			}
-		}
 	}
 }
@@ -1,28 +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 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);
-	}
-}
@@ -1,21 +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 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;
-	}
-}
@@ -1,69 +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.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);
-	}
-}
@@ -1,49 +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 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;
-	}
-
-}
@@ -1,117 +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 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;
-	}
-}
@@ -1,46 +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 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;
-	}
-}
@@ -4,118 +4,68 @@
 * 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.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.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.EnumErrorCode;
+import forestry.core.config.Defaults;
+import forestry.core.config.ForestryItem;
 import forestry.core.proxy.Proxies;
-import forestry.core.utils.Log;
 import forestry.plugins.PluginApiculture;

-public class BeekeepingLogic implements IBeekeepingLogic, IStreamable {
+public class BeekeepingLogic implements IBeekeepingLogic {

-	private static final int totalBreedingTime = Constants.APIARY_BREEDING_TIME;
-
-	private final IBeeHousing housing;
-	private final IBeeModifier beeModifier;
-	private final IBeeListener beeListener;
-
-	private int beeProgress;
-	private int beeProgressMax;
-
-	private int queenWorkCycleThrottle;
+	private static final int MAX_POLLINATION_ATTEMPTS = 20;
+	IBeeHousing housing;
+	// Breeding
+	private int breedingTime;
+	private final int totalBreedingTime = Defaults.APIARY_BREEDING_TIME;
+	private int throttle;
 	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 ItemStack queenStack; // used to detect server changes and sync clientQueen
+	private IIndividual pollen;
+	private int attemptedPollinations = 0;
+	private final Stack<ItemStack> spawn = new Stack<ItemStack>();

 	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) {
-		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);
+		breedingTime = nbttagcompound.getInteger("BreedingTime");
+		throttle = nbttagcompound.getInteger("Throttle");

 		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", beeProgress);
-		nbttagcompound.setInteger("Throttle", queenWorkCycleThrottle);
+		nbttagcompound.setInteger("BreedingTime", breedingTime);
+		nbttagcompound.setInteger("Throttle", throttle);

-		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<>();
+		Stack<ItemStack> spawnCopy = new Stack<ItemStack>();
 		spawnCopy.addAll(spawn);
 		NBTTagList nbttaglist = new NBTTagList();
 		while (!spawnCopy.isEmpty()) {
@@ -124,396 +74,257 @@ public class BeekeepingLogic implements IBeekeepingLogic, IStreamable {
 			nbttaglist.appendTag(nbttagcompound1);
 		}
 		nbttagcompound.setTag("Offspring", nbttaglist);
+		
+	}
+
+	// / STATE INFORMATION
+	@Override
+	public int getBreedingTime() {
+		return this.breedingTime;
 	}

 	@Override
-	public void writeData(DataOutputStreamForestry data) throws IOException {
-		data.writeBoolean(active);
-		if (active) {
-			data.writeItemStack(queenStack);
-		}
+	public int getTotalBreedingTime() {
+		return this.totalBreedingTime;
 	}

 	@Override
-	public void readData(DataInputStreamForestry data) throws IOException {
-		boolean active = data.readBoolean();
-		setActive(active);
-		if (active) {
-			queenStack = data.readItemStack();
-			queen = BeeManager.beeRoot.getMember(queenStack);
-		}
+	public IBee getQueen() {
+		return this.queen;
 	}

-	/* Activatable */
-	private void setActive(boolean active) {
-		if (this.active == active) {
-			return;
-		}
-		this.active = active;
+	@Override
+	public IBeeHousing getHousing() {
+		return this.housing;
+	}

-		syncToClient();
+	@Override
+	public IEffectData[] getEffectData() {
+		return this.effectData;
 	}

 	/* UPDATING */
-
 	@Override
-	public boolean canWork() {
+	public void update() {

-		IErrorLogic errorLogic = housing.getErrorLogic();
-		errorLogic.clearErrors();
+		resetQueen(null);

-		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();
-		}
-
-		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;
-	}
-
-	@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) {
+		// Still something to spawn, try it
+		while (!spawn.isEmpty()) {
+			ItemStack next = spawn.peek();
+			if (housing.addProduct(next, true)) {
+				spawn.pop();
+				housing.setErrorState(EnumErrorCode.OK.ordinal());
+			} else
+				housing.setErrorState(EnumErrorCode.NOSPACE.ordinal());
 			return;
 		}

+		// No queen? And no princess?
+		if (housing.getQueen() == null) {
+			housing.setErrorState(EnumErrorCode.NOQUEEN.ordinal());
+			return;
+		}
+
+		// 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();
+			return;
+		}
+
+		// Can't continue if an item of the wrong type is in the queen slot.
+		if (!ForestryItem.beeQueenGE.isItemEqual(housing.getQueen())) {
+			housing.setErrorState(EnumErrorCode.NOQUEEN.ordinal());
+			return;
+		}
+
+		IBee queen = PluginApiculture.beeInterface.getMember(housing.getQueen());
+		// Kill dying queens
+		if (!queen.isAlive()) {
+			killQueen(queen);
+			housing.setErrorState(EnumErrorCode.OK.ordinal());
+			return;
+		}
+
+		resetQueen(queen);
+
+		// Not while raining, at night or without light
+		EnumErrorCode state = EnumErrorCode.values()[queen.isWorking(housing)];
+		if (state != EnumErrorCode.OK) {
+			housing.setErrorState(state.ordinal());
+			return;
+		} else if (housing.getErrorOrdinal() != EnumErrorCode.NOFLOWER.ordinal())
+			housing.setErrorState(EnumErrorCode.OK.ordinal());
+
 		// Effects only fire when queen can work.
 		effectData = queen.doEffect(effectData, housing);

-		// Work cycles are throttled, rather than occurring every game tick.
-		queenWorkCycleThrottle++;
-		if (queenWorkCycleThrottle >= PluginApiculture.ticksPerBeeWorkCycle) {
-			queenWorkCycleThrottle = 0;
+		// We have a queen, work!
+		throttle++;

-			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);
-		}
-
-		beeProgress = queen.getHealth();
-		beeProgressMax = queen.getMaxHealth();
-	}
-
-	private static void doProduction(IBee queen, IBeeHousing beeHousing, IBeeListener beeListener) {
-		// Produce and add stacks
-		ItemStack[] products = queen.produceStacks(beeHousing);
-		if (products == null) {
+		if (throttle >= PluginApiculture.beeCycleTicks)
+			throttle = 0;
+		else
 			return;
-		}
-		beeListener.wearOutEquipment(1);

-		IBeeHousingInventory beeInventory = beeHousing.getBeeInventory();
+		// Need a flower
+		if (!queen.hasFlower(housing)) {
+			housing.setErrorState(EnumErrorCode.NOFLOWER.ordinal());
+			return;
+		} else
+			housing.setErrorState(EnumErrorCode.OK.ordinal());

+		// Produce and add stacks
+		ItemStack[] products = queen.produceStacks(housing);
+		housing.wearOutEquipment(1);
 		for (ItemStack stack : products) {
-			beeInventory.addProduct(stack, false);
+			housing.addProduct(stack, false);
 		}
-	}

-	private static boolean addPendingProducts(IBeeHousingInventory beeInventory, Stack<ItemStack> spawn) {
-		boolean housingHasSpace = true;
-
-		while (!spawn.isEmpty()) {
-			ItemStack next = spawn.peek();
-			if (beeInventory.addProduct(next, true)) {
-				spawn.pop();
-			} else {
-				housingHasSpace = false;
-				break;
+		// Plant a flower
+		queen.plantFlowerRandom(housing);
+		// 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;
 			}
 		}

-		return housingHasSpace;
+		// Age the queen
+		queen.age(housing.getWorld(), housing.getLifespanModifier(queen.getGenome(), queen.getMate(), 0f));
+
+		// Write the changed queen back into the item stack.
+		NBTTagCompound nbttagcompound = new NBTTagCompound();
+		queen.writeToNBT(nbttagcompound);
+		housing.getQueen().setTagCompound(nbttagcompound);
+
+		return;
 	}

-	/** 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;
-		}
-		NBTTagCompound nbtTagCompound = queenStack.getTagCompound();
-		if (nbtTagCompound == null) {
-			return false;
-		}
-		int health = nbtTagCompound.getInteger("Health");
-		return health > 0;
+	private void resetQueen(IBee bee) {
+		this.queen = bee;
 	}

 	// / BREEDING
 	private void tickBreed() {
-		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;
+		if (!tryBreed()) {
+			breedingTime = 0;
 			return;
 		}

-		if (beeProgress < totalBreedingTime) {
-			beeProgress++;
-		}
-		if (beeProgress < totalBreedingTime) {
+		if (breedingTime < totalBreedingTime)
+			breedingTime++;
+		if (breedingTime < totalBreedingTime)
 			return;
-		}

-		// Mate and replace princess with queen
-		IBee princess = BeeManager.beeRoot.getMember(princessStack);
-		IBee drone = BeeManager.beeRoot.getMember(droneStack);
+		// 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());
 		princess.mate(drone);

 		NBTTagCompound nbttagcompound = new NBTTagCompound();
 		princess.writeToNBT(nbttagcompound);
-		queenStack = new ItemStack(PluginApiculture.items.beeQueenGE);
-		queenStack.setTagCompound(nbttagcompound);
+		ItemStack queen = ForestryItem.beeQueenGE.getItemStack();
+		queen.setTagCompound(nbttagcompound);

-		beeInventory.setQueen(queenStack);
+		housing.setQueen(queen);
+		housing.onQueenChange(housing.getQueen());

 		// Register the new queen with the breeding tracker
-		BeeManager.beeRoot.getBreedingTracker(housing.getWorld(), housing.getOwner()).registerQueen(princess);
+		PluginApiculture.beeInterface.getBreedingTracker(housing.getWorld(), housing.getOwnerName()).registerQueen(princess);

 		// Remove drone
-		beeInventory.getDrone().stackSize--;
-		if (beeInventory.getDrone().stackSize <= 0) {
-			beeInventory.setDrone(null);
-		}
+		housing.getDrone().stackSize--;
+		if (housing.getDrone().stackSize <= 0)
+			housing.setDrone(null);

 		// Reset breeding time
-		queen = princess;
-		beeProgress = princess.getHealth();
-		beeProgressMax = princess.getMaxHealth();
+		breedingTime = 0;
 	}

-	private static Collection<ItemStack> killQueen(IBee queen, IBeeHousing beeHousing, IBeeListener beeListener) {
-		if (queen == null) {
-			return Collections.emptySet();
-		}
+	private boolean tryBreed() {
+		if (housing.getDrone() == null || housing.getQueen() == null)
+			return false;

-		IBeeHousingInventory beeInventory = beeHousing.getBeeInventory();
+		if (!ForestryItem.beeDroneGE.isItemEqual(housing.getDrone()) || !ForestryItem.beePrincessGE.isItemEqual(housing.getQueen()))
+			return false;

-		Collection<ItemStack> spawn;
+		if (!housing.canBreed())
+			return false;

+		return true;
+	}
+
+	private void killQueen(IBee queen) {
 		if (queen.canSpawn()) {
-			spawn = spawnOffspring(queen, beeHousing);
-			beeListener.onQueenDeath();
-			beeInventory.getQueen().stackSize = 0;
-			beeInventory.setQueen(null);
+			spawnOffspring(queen);
+			housing.getQueen().stackSize = 0;
+			housing.setQueen(null);
 		} else {
-			Log.warning("Tried to spawn offspring off an unmated queen. Devolving her to a princess.");
+			Proxies.log.warning("Tried to spawn offspring off an unmated queen. Devolving her to a princess.");

-			ItemStack convert = new ItemStack(PluginApiculture.items.beePrincessGE);
+			ItemStack convert = ForestryItem.beePrincessGE.getItemStack();
 			NBTTagCompound nbttagcompound = new NBTTagCompound();
 			queen.writeToNBT(nbttagcompound);
 			convert.setTagCompound(nbttagcompound);

-			spawn = Collections.singleton(convert);
-			beeInventory.setQueen(null);
+			spawn.add(convert);
+			housing.setQueen(null);
 		}
-
-		return spawn;
+		housing.onQueenChange(housing.getQueen());
 	}

 	/**
 	 * Creates the succeeding princess and between one and three drones.
 	 */
-	private static Collection<ItemStack> spawnOffspring(IBee queen, IBeeHousing beeHousing) {
+	private void spawnOffspring(IBee queen) {

-		World world = beeHousing.getWorld();
+		Stack<ItemStack> offspring = new Stack<ItemStack>();
+		IApiaristTracker breedingTracker = PluginApiculture.beeInterface.getBreedingTracker(housing.getWorld(), housing.getOwnerName());

-		Stack<ItemStack> offspring = new Stack<>();
-		IApiaristTracker breedingTracker = BeeManager.beeRoot.getBreedingTracker(world, beeHousing.getOwner());
+		housing.onQueenDeath(getQueen());

 		// Princess
-		boolean secondPrincess = world.rand.nextInt(10000) < PluginApiculture.getSecondPrincessChance() * 100;
-		int count = secondPrincess ? 2 : 1;
-		while (count > 0) {
-			count--;
-			IBee heiress = queen.spawnPrincess(beeHousing);
-			if (heiress != null) {
-				ItemStack princess = BeeManager.beeRoot.getMemberStack(heiress, EnumBeeType.PRINCESS.ordinal());
-				breedingTracker.registerPrincess(heiress);
-				offspring.push(princess);
-			}
+		IBee heiress = queen.spawnPrincess(housing);
+		if (heiress != null) {
+			ItemStack princess = PluginApiculture.beeInterface.getMemberStack(heiress, EnumBeeType.PRINCESS.ordinal());
+			breedingTracker.registerPrincess(heiress);
+			offspring.push(princess);
 		}

 		// Drones
-		IBee[] drones = queen.spawnDrones(beeHousing);
-		for (IBee drone : drones) {
-			ItemStack droneStack = BeeManager.beeRoot.getMemberStack(drone, EnumBeeType.DRONE.ordinal());
-			breedingTracker.registerDrone(drone);
-			offspring.push(droneStack);
+		IBee[] larvae = queen.spawnDrones(housing);
+		for (IBee larva : larvae) {
+			ItemStack drone = PluginApiculture.beeInterface.getMemberStack(larva, EnumBeeType.DRONE.ordinal());
+			breedingTracker.registerDrone(larva);
+			offspring.push(drone);
 		}

-		IBeeHousingInventory beeInventory = beeHousing.getBeeInventory();
-
-		Collection<ItemStack> spawn = new ArrayList<>();
-
 		while (!offspring.isEmpty()) {
 			ItemStack spawned = offspring.pop();
-			if (!beeInventory.addProduct(spawned, true)) {
+			if (!housing.addProduct(spawned, true))
 				spawn.add(spawned);
-			}
 		}

-		return spawn;
+		housing.onPostQueenDeath(getQueen());
+
 	}
-
-	/* 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;
-				}
-			}
-		}
-	}
-
 }
@@ -0,0 +1,255 @@
+/*******************************************************************************
+ * 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.BufferedWriter;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.text.DateFormat;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+
+import net.minecraft.command.CommandException;
+import net.minecraft.command.ICommand;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.command.WrongUsageException;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.World;
+
+import com.mojang.authlib.GameProfile;
+
+import forestry.api.apiculture.IAlleleBeeSpecies;
+import forestry.api.apiculture.IApiaristTracker;
+import forestry.api.apiculture.IBeekeepingMode;
+import forestry.api.genetics.AlleleManager;
+import forestry.api.genetics.IAllele;
+import forestry.core.config.Defaults;
+import forestry.core.config.Version;
+import forestry.core.proxy.Proxies;
+import forestry.core.utils.CommandMC;
+import forestry.core.utils.StringUtil;
+import forestry.plugins.PluginApiculture;
+
+public class CommandBeekeepingMode extends CommandMC {
+
+	String[] modeStrings;
+
+	public CommandBeekeepingMode() {
+		modeStrings = new String[PluginApiculture.beeInterface.getBeekeepingModes().size()];
+		for (int i = 0; i < PluginApiculture.beeInterface.getBeekeepingModes().size(); i++)
+			modeStrings[i] = PluginApiculture.beeInterface.getBeekeepingModes().get(i).getName();
+	}
+
+	@Override
+	public int compareTo(Object arg0) {
+		return this.getCommandName().compareTo(((ICommand) arg0).getCommandName());
+	}
+
+	@Override
+	public String getCommandName() {
+		return "beekeeping";
+	}
+
+	@Override
+	public String getCommandUsage(ICommandSender var1) {
+		return "/" + this.getCommandName() + " help";
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public List getCommandAliases() {
+		return null;
+	}
+
+	@Override
+	public void processCommand(ICommandSender sender, String[] arguments) {
+
+		if (arguments.length <= 0)
+			throw new WrongUsageException(StringUtil.localizeAndFormat("chat.help", this.getCommandUsage(sender)));
+
+		if (arguments[0].matches("list"))
+			listModes(sender, arguments);
+		else if (arguments[0].matches("info"))
+			listModeInfo(sender, arguments);
+		else if (arguments[0].matches("set")) {
+			if (arguments.length <= 1)
+				throw new WrongUsageException("/" + this.getCommandName() + " set [<world-#>] <mode-name>");
+
+			World world = getWorld(sender, arguments);
+			String desired = arguments[arguments.length - 1];
+
+			IBeekeepingMode mode = PluginApiculture.beeInterface.getBeekeepingMode(desired);
+			if (mode == null)
+				throw new CommandException(StringUtil.localize("chat.bees.command.beekeeping.error"), desired);
+
+			PluginApiculture.beeInterface.setBeekeepingMode(world, mode.getName());
+			func_152373_a(sender, this, StringUtil.localize("chat.bees.command.beekeeping.set"), mode.getName());
+
+		} else if (arguments[0].matches("save")) {
+			if (arguments.length <= 1)
+				throw new WrongUsageException("/" + this.getCommandName() + " save <player-name>");
+
+			saveStatistics(sender, arguments);
+		} else if (arguments[0].matches("help")) {
+			sendChatMessage(sender, StringUtil.localizeAndFormat("chat.bees.command.help.0", this.getCommandName()));
+			sendChatMessage(sender, StringUtil.localize("chat.bees.command.help.1"));
+			sendChatMessage(sender, StringUtil.localize("chat.bees.command.help.2"));
+			sendChatMessage(sender, StringUtil.localize("chat.bees.command.help.3"));
+			sendChatMessage(sender, StringUtil.localize("chat.bees.command.help.4"));
+			sendChatMessage(sender, StringUtil.localize("chat.bees.command.help.5"));
+		}
+	}
+
+	private void saveStatistics(ICommandSender sender, String[] arguments) {
+
+		String newLine = System.getProperty("line.separator");
+		World world = getWorld(sender, arguments);
+
+		String player = arguments[1];
+		Collection<String> statistics = new ArrayList<String>();
+
+		statistics.add(String.format("Beekeeping statistics for %s on %s:", player, DateFormat.getInstance().format(new Date())));
+		statistics.add("");
+		statistics.add("MODE: " + PluginApiculture.beeInterface.getBeekeepingMode(world).getName());
+		statistics.add("");
+
+		GameProfile profile = MinecraftServer.getServer().func_152358_ax().func_152655_a(player);
+		IApiaristTracker tracker = PluginApiculture.beeInterface.getBreedingTracker(world, profile);
+		if (tracker == null)
+			statistics.add("No statistics found.");
+		else {
+			statistics.add("BRED:");
+			statistics.add("-----");
+			statistics.add("");
+
+			statistics.add("Queens:\t\t" + tracker.getQueenCount());
+			statistics.add("Princesses:\t" + tracker.getPrincessCount());
+			statistics.add("Drones:\t\t" + tracker.getDroneCount());
+			statistics.add("");
+
+			Collection<IAlleleBeeSpecies> species = new ArrayList<IAlleleBeeSpecies>();
+			for (IAllele allele : AlleleManager.alleleRegistry.getRegisteredAlleles().values())
+				if (allele instanceof IAlleleBeeSpecies)
+					species.add((IAlleleBeeSpecies) allele);
+
+			statistics.add(String.format("SPECIES (%s):", species.size()));
+			statistics.add("-------------");
+			statistics.add("");
+
+			for (IAlleleBeeSpecies allele : species)
+				statistics.add(generateSpeciesListEntry(allele, tracker));
+		}
+
+		File file = new File(Proxies.common.getForestryRoot(), "config/" + Defaults.MOD.toLowerCase(Locale.ENGLISH) + "/stats/" + player + ".log");
+		try {
+
+			if (file.getParentFile() != null)
+				file.getParentFile().mkdirs();
+
+			if (!file.exists() && !file.createNewFile()) {
+				sendChatMessage(sender, StringUtil.localize("chat.bees.command.stats.error1"));
+				return;
+			}
+
+			if (!file.canWrite()) {
+				sendChatMessage(sender, StringUtil.localize("chat.bees.command.stats.error2"));
+				return;
+			}
+
+			FileOutputStream fileout = new FileOutputStream(file);
+			BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(fileout, "UTF-8"));
+
+			writer.write("# " + Defaults.MOD + newLine + "# " + Version.getVersion() + newLine);
+
+			for (String line : statistics)
+				writer.write(line + newLine);
+
+			writer.close();
+
+		} catch (Exception ex) {
+			sendChatMessage(sender, StringUtil.localize("chat.bees.command.stats.error3"));
+			ex.printStackTrace();
+		}
+
+		sendChatMessage(sender, StringUtil.localizeAndFormat("chat.bees.command.stats.saved", player));
+	}
+
+	private String generateSpeciesListEntry(IAlleleBeeSpecies species, IApiaristTracker tracker) {
+		String discovered = "[   ]";
+		if (tracker.isDiscovered(species))
+			discovered = "[ X ]";
+		String blacklisted = "[    ]";
+		if (AlleleManager.alleleRegistry.isBlacklisted(species.getUID()))
+			blacklisted = "[ BL ]";
+		String notcounted = "[    ]";
+		if (!species.isCounted())
+			notcounted = "[ NC ]";
+
+		return String.format("%s %s %s\t%-40s %-20s %-20s", discovered, blacklisted, notcounted, species.getUID(), species.getName(), species.getAuthority());
+	}
+
+	private void listModes(ICommandSender sender, String[] arguments) {
+		World world = getWorld(sender, arguments);
+
+		String message = StringUtil.localize("chat.bees.command.mode.current");
+		message = message.replaceAll("%MODE", PluginApiculture.beeInterface.getBeekeepingMode(world).getName());
+		message = message.replaceAll("%WORLD", String.valueOf(world.getWorldInfo().getSaveVersion()));
+		sendChatMessage(sender, message);
+
+		String help = "";
+		for (IBeekeepingMode mode : PluginApiculture.beeInterface.getBeekeepingModes()) {
+			if (!help.isEmpty())
+				help += ", ";
+			help += mode.getName();
+		}
+		sendChatMessage(sender, StringUtil.localizeAndFormat("chat.bees.command.mode.help", help));
+		return;
+	}
+
+	private void listModeInfo(ICommandSender sender, String[] arguments) {
+		if (arguments.length <= 1)
+			throw new WrongUsageException("/" + this.getCommandName() + " info <mode-name>");
+
+		IBeekeepingMode found = null;
+		for (IBeekeepingMode mode : PluginApiculture.beeInterface.getBeekeepingModes())
+			if (mode.getName().equalsIgnoreCase(arguments[1])) {
+				found = mode;
+				break;
+			}
+
+		if (found == null)
+			throw new CommandException("No beekeeping mode called '%s' is available.", arguments[1]);
+
+		sendChatMessage(sender, "\u00A7aMode: " + found.getName());
+		for (String desc : found.getDescription())
+			sendChatMessage(sender, StringUtil.localize(desc));
+	}
+
+	@Override
+	public boolean canCommandSenderUseCommand(ICommandSender sender) {
+		if (sender instanceof EntityPlayer)
+			return Proxies.common.isOp((EntityPlayer) sender);
+		else
+			return sender.canCommandSenderUseCommand(4, getCommandName());
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public List addTabCompletionOptions(ICommandSender sender, String[] incomplete) {
+		return getListOfStringsMatchingLastWord(incomplete, modeStrings);
+	}
+
+}
@@ -0,0 +1,122 @@
+/*******************************************************************************
+ * 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.ArrayList;
+import java.util.List;
+
+import net.minecraft.command.ICommandSender;
+import net.minecraft.command.WrongUsageException;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+
+import forestry.api.apiculture.EnumBeeType;
+import forestry.api.apiculture.IAlleleBeeSpecies;
+import forestry.api.apiculture.IBee;
+import forestry.api.apiculture.IBeeGenome;
+import forestry.api.genetics.AlleleManager;
+import forestry.api.genetics.IAllele;
+import forestry.api.genetics.IAlleleSpecies;
+import forestry.core.utils.CommandMC;
+import forestry.plugins.PluginApiculture;
+
+public class CommandGiveBee extends CommandMC {
+
+	EnumBeeType type;
+
+	public CommandGiveBee(EnumBeeType type) {
+		this.type = type;
+	}
+
+	@Override
+	public String getCommandName() {
+		return "give" + type.toString().toLowerCase();
+	}
+
+	@Override
+	public String getCommandUsage(ICommandSender par1ICommandSender) {
+		return "/" + getCommandName() + " <player-name> <species-name>";
+	}
+
+	@Override
+	public void processCommand(ICommandSender sender, String[] arguments) {
+		if (arguments.length >= 2) {
+			EntityPlayer player = getPlayer(sender, arguments[0]);
+
+			String parameter = arguments[1];
+
+			IAlleleBeeSpecies species = null;
+
+			search: for (String uid : AlleleManager.alleleRegistry.getRegisteredAlleles().keySet()) {
+
+				if (!uid.equals(parameter))
+					continue;
+
+				if (AlleleManager.alleleRegistry.getAllele(uid) instanceof IAlleleBeeSpecies) {
+					species = (IAlleleBeeSpecies) AlleleManager.alleleRegistry.getAllele(uid);
+					break search;
+				}
+			}
+
+			search: if (species == null)
+				for (IAllele allele : AlleleManager.alleleRegistry.getRegisteredAlleles().values())
+					if (allele instanceof IAlleleBeeSpecies)
+						if (((IAlleleBeeSpecies) allele).getName().equals(parameter)) {
+							species = (IAlleleBeeSpecies) allele;
+							break search;
+						}
+
+			if (species == null)
+				throw new SpeciesNotFoundException(parameter);
+
+			IAllele[] template = PluginApiculture.beeInterface.getTemplate(species.getUID());
+
+			if (template == null)
+				throw new TemplateNotFoundException(species);
+
+			IBeeGenome genome = PluginApiculture.beeInterface.templateAsGenome(template);
+
+			IBee bee = PluginApiculture.beeInterface.getBee(player.worldObj, genome);
+
+			if(this.type == EnumBeeType.QUEEN)
+				bee.mate(bee);
+			
+			ItemStack beestack = PluginApiculture.beeInterface.getMemberStack(bee, type.ordinal());
+			player.dropPlayerItemWithRandomChoice(beestack, true);
+			func_152373_a(sender, this, "Player %s was given a %s bee.", player.getCommandSenderName(), ((IAlleleSpecies) template[0]).getName());
+		} else
+			throw new WrongUsageException("/" + getCommandName() + " <player-name> <species-name>");
+	}
+
+	/**
+	 * Adds the strings available in this command to the given list of tab completion options.
+	 */
+	@SuppressWarnings("rawtypes")
+	@Override
+	public List addTabCompletionOptions(ICommandSender sender, String[] parameters) {
+		if (parameters.length == 1)
+			return getListOfStringsMatchingLastWord(parameters, this.getPlayers());
+		else if (parameters.length == 2)
+			return getListOfStringsMatchingLastWord(parameters, this.getSpecies());
+		else
+			return null;
+	}
+
+	protected String[] getSpecies() {
+		List<String> species = new ArrayList<String>();
+
+		for (IAllele allele : AlleleManager.alleleRegistry.getRegisteredAlleles().values())
+			if (allele instanceof IAlleleBeeSpecies)
+				species.add(((IAlleleSpecies) allele).getName());
+
+		return species.toArray(new String[] {});
+	}
+}
@@ -1,69 +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.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) {
-
-	}
-}
@@ -0,0 +1,84 @@
+/*******************************************************************************
+ * 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.block.Block;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+import net.minecraftforge.common.EnumPlantType;
+
+import forestry.api.genetics.IFlowerProvider;
+import forestry.api.genetics.IIndividual;
+import forestry.api.genetics.IPollinatable;
+import forestry.core.config.Defaults;
+import forestry.core.utils.StringUtil;
+
+public class FlowerProviderCacti implements IFlowerProvider {
+
+	@Override
+	public boolean isAcceptedFlower(World world, IIndividual individual, int x, int y, int z) {
+		Block block = world.getBlock(x, y, z);
+
+		// Specific check for flower pots.
+		if (block == Blocks.flower_pot)
+			return checkFlowerPot(world.getBlockMetadata(x, y, z));
+
+		return block == Blocks.cactus;
+	}
+
+	@Override
+	public boolean isAcceptedPollinatable(World world, IPollinatable pollinatable) {
+		return pollinatable.getPlantType().contains(EnumPlantType.Desert);
+	}
+
+	private boolean checkFlowerPot(int meta) {
+		if (meta == 9)
+			return true;
+		else
+			return false;
+	}
+
+	@Override
+	public boolean growFlower(World world, IIndividual individual, int x, int y, int z) {
+		Block block = world.getBlock(x, y, z);
+
+		if (block == Blocks.flower_pot && world.getBlockMetadata(x, y, z) == 0)
+			return growInPot(world, x, y, z);
+
+		return false;
+	}
+
+	private boolean growInPot(World world, int x, int y, int z) {
+		if (world.rand.nextBoolean())
+			world.setBlock(x, y, z, Blocks.flower_pot, 9, Defaults.FLAG_BLOCK_SYNCH);
+		else
+			world.setBlock(x, y, z, Blocks.flower_pot, 10, Defaults.FLAG_BLOCK_SYNCH);
+		return true;
+	}
+
+	@Override
+	public String getDescription() {
+		return StringUtil.localize("flowers.cacti");
+	}
+
+	@Override
+	public ItemStack[] affectProducts(World world, IIndividual individual, int x, int y, int z, ItemStack[] products) {
+		return products;
+	}
+
+	@Override
+	public ItemStack[] getItemStacks() {
+		return new ItemStack[] { new ItemStack(Blocks.cactus) };
+	}
+
+}
@@ -0,0 +1,61 @@
+/*******************************************************************************
+ * 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.EnumSet;
+
+import net.minecraft.block.Block;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+import net.minecraftforge.common.EnumPlantType;
+
+import forestry.api.genetics.IFlowerProvider;
+import forestry.api.genetics.IIndividual;
+import forestry.api.genetics.IPollinatable;
+import forestry.core.utils.StringUtil;
+
+public class FlowerProviderEnd implements IFlowerProvider {
+
+	@Override
+	public boolean isAcceptedFlower(World world, IIndividual individual, int x, int y, int z) {
+		Block block = world.getBlock(x, y, z);
+		return block == Blocks.dragon_egg;
+	}
+
+	@Override
+	public boolean isAcceptedPollinatable(World world, IPollinatable pollinatable) {
+		EnumSet<EnumPlantType> types = pollinatable.getPlantType();
+		return types.size() > 1 || !types.contains(EnumPlantType.Nether);
+	}
+
+	@Override
+	public boolean growFlower(World world, IIndividual individual, int x, int y, int z) {
+		return true;
+	}
+
+	@Override
+	public String getDescription() {
+		return StringUtil.localize("flowers.end");
+	}
+
+	@Override
+	public ItemStack[] affectProducts(World world, IIndividual individual, int x, int y, int z, ItemStack[] products) {
+		return products;
+	}
+
+	@Override
+	public ItemStack[] getItemStacks() {
+		return new ItemStack[] { new ItemStack(Blocks.dragon_egg) };
+	}
+
+}
@@ -4,65 +4,66 @@
 * 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.flowers;
+package forestry.apiculture;

 import java.util.EnumSet;
-import java.util.Set;

+import net.minecraft.block.Block;
+import net.minecraft.init.Blocks;
 import net.minecraft.item.ItemStack;
 import net.minecraft.world.World;

 import net.minecraftforge.common.EnumPlantType;

-import forestry.api.apiculture.FlowerManager;
-import forestry.api.genetics.IFlower;
 import forestry.api.genetics.IFlowerProvider;
 import forestry.api.genetics.IIndividual;
 import forestry.api.genetics.IPollinatable;
+import forestry.core.config.Defaults;
 import forestry.core.utils.StringUtil;

-public class FlowerProvider implements IFlowerProvider {
-
-	private final String flowerType;
-	private final String description;
-
-	public FlowerProvider(String flowerType, String description) {
-		this.flowerType = flowerType;
-		this.description = description;
-	}
+public class FlowerProviderGourd implements IFlowerProvider {

 	@Override
-	public String getFlowerType() {
-		return flowerType;
+	public boolean isAcceptedFlower(World world, IIndividual individual, int x, int y, int z) {
+		Block block = world.getBlock(x, y, z);
+		return block == Blocks.pumpkin_stem || block == Blocks.melon_stem;
 	}

 	@Override
 	public boolean isAcceptedPollinatable(World world, IPollinatable pollinatable) {
-
-		EnumSet<EnumPlantType> plantTypes = pollinatable.getPlantType();
-
-		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);
-		}
+		EnumSet<EnumPlantType> types = pollinatable.getPlantType();
+		return types.size() > 1 || !types.contains(EnumPlantType.Nether);
 	}

 	@Override
 	public boolean growFlower(World world, IIndividual individual, int x, int y, int z) {
-		return FlowerManager.flowerRegistry.growFlower(this.flowerType, world, individual, x, y, z);
+
+		Block block = world.getBlock(x, y, z);
+
+		// We only grow wheat, we don't plant it
+		if (block != Blocks.pumpkin_stem && block != Blocks.melon_stem)
+			return false;
+
+		int meta = world.getBlockMetadata(x, y, z);
+		if (meta > 6)
+			return false;
+
+		if (meta < 6)
+			meta += 2;
+		else
+			meta = 7;
+
+		world.setBlockMetadataWithNotify(x, y, z, meta, Defaults.FLAG_BLOCK_SYNCH);
+		return true;
 	}

 	@Override
 	public String getDescription() {
-		return StringUtil.localize(this.description);
+		return StringUtil.localize("flowers.gourd");
 	}

 	@Override
@@ -71,8 +72,8 @@ public class FlowerProvider implements IFlowerProvider {
 	}

 	@Override
-	public Set<IFlower> getFlowers() {
-		return FlowerManager.flowerRegistry.getAcceptableFlowers(this.flowerType);
+	public ItemStack[] getItemStacks() {
+		return new ItemStack[] { new ItemStack(Blocks.wheat, 1, 8) };
 	}

 }
@@ -0,0 +1,85 @@
+/*******************************************************************************
+ * 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.EnumSet;
+
+import net.minecraft.block.Block;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+import net.minecraftforge.common.EnumPlantType;
+
+import forestry.api.genetics.IFlowerProvider;
+import forestry.api.genetics.IIndividual;
+import forestry.api.genetics.IPollinatable;
+import forestry.core.config.Defaults;
+import forestry.core.utils.StringUtil;
+
+public class FlowerProviderJungle implements IFlowerProvider {
+
+	@Override
+	public boolean isAcceptedFlower(World world, IIndividual individual, int x, int y, int z) {
+		Block block = world.getBlock(x, y, z);
+		int meta = world.getBlockMetadata(x, y, z);
+
+		// Specific check for flower pots.
+		if (block == Blocks.flower_pot)
+			return checkFlowerPot(meta);
+
+		return block == Blocks.vine || (block == Blocks.tallgrass && meta == 2);
+	}
+
+	@Override
+	public boolean isAcceptedPollinatable(World world, IPollinatable pollinatable) {
+		EnumSet<EnumPlantType> types = pollinatable.getPlantType();
+		return types.size() > 1 || !types.contains(EnumPlantType.Nether);
+	}
+
+	private boolean checkFlowerPot(int meta) {
+		if (meta == 11)
+			return true;
+		else
+			return false;
+	}
+
+	@Override
+	public boolean growFlower(World world, IIndividual individual, int x, int y, int z) {
+		Block block = world.getBlock(x, y, z);
+
+		if (block == Blocks.flower_pot)
+			return growInPot(world, x, y, z);
+
+		return false;
+	}
+
+	private boolean growInPot(World world, int x, int y, int z) {
+		world.setBlock(x, y, z, Blocks.flower_pot, 11, Defaults.FLAG_BLOCK_SYNCH);
+		return true;
+	}
+
+	@Override
+	public String getDescription() {
+		return StringUtil.localize("flowers.jungle");
+	}
+
+	@Override
+	public ItemStack[] affectProducts(World world, IIndividual individual, int x, int y, int z, ItemStack[] products) {
+		return products;
+	}
+
+	@Override
+	public ItemStack[] getItemStacks() {
+		return new ItemStack[] { new ItemStack(Blocks.vine), new ItemStack(Blocks.tallgrass, 1, 2) };
+	}
+
+}
@@ -0,0 +1,103 @@
+/*******************************************************************************
+ * 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.EnumSet;
+
+import net.minecraft.block.Block;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+import net.minecraftforge.common.EnumPlantType;
+
+import forestry.api.genetics.IFlowerProvider;
+import forestry.api.genetics.IIndividual;
+import forestry.api.genetics.IPollinatable;
+import forestry.core.config.Defaults;
+import forestry.core.utils.StringUtil;
+
+public class FlowerProviderMushroom implements IFlowerProvider {
+
+	@Override
+	public boolean isAcceptedFlower(World world, IIndividual individual, int x, int y, int z) {
+		Block block = world.getBlock(x, y, z);
+
+		// Specific check for flower pots.
+		if (block == Blocks.flower_pot)
+			return checkFlowerPot(world.getBlockMetadata(x, y, z));
+
+		return block == Blocks.brown_mushroom || block == Blocks.red_mushroom;
+	}
+
+	@Override
+	public boolean isAcceptedPollinatable(World world, IPollinatable pollinatable) {
+		EnumSet<EnumPlantType> types = pollinatable.getPlantType();
+		return types.size() > 1 || !types.contains(EnumPlantType.Nether);
+	}
+
+	private boolean checkFlowerPot(int meta) {
+		if (meta == 7 || meta == 8)
+			return true;
+		else
+			return false;
+	}
+
+	@Override
+	public boolean growFlower(World world, IIndividual individual, int x, int y, int z) {
+		Block block = world.getBlock(x, y, z);
+
+		if (!block.isAir(world, x, y, z))
+			if (block == Blocks.flower_pot)
+				return growInPot(world, x, y, z);
+			else
+				return false;
+
+		// Check ground
+		Block ground = world.getBlock(x, y - 1, z);
+
+		if (ground != Blocks.mycelium)
+			return false;
+
+		Block mushroom;
+		if (world.rand.nextBoolean())
+			mushroom = Blocks.brown_mushroom;
+		else
+			mushroom = Blocks.red_mushroom;
+
+		world.setBlock(x, y, z, mushroom, 0, Defaults.FLAG_BLOCK_SYNCH);
+		return true;
+	}
+
+	private boolean growInPot(World world, int x, int y, int z) {
+		if (world.rand.nextBoolean())
+			world.setBlock(x, y, z, Blocks.flower_pot, 7, Defaults.FLAG_BLOCK_SYNCH);
+		else
+			world.setBlock(x, y, z, Blocks.flower_pot, 8, Defaults.FLAG_BLOCK_SYNCH);
+		return true;
+	}
+
+	@Override
+	public String getDescription() {
+		return StringUtil.localize("flowers.mushroom");
+	}
+
+	@Override
+	public ItemStack[] affectProducts(World world, IIndividual individual, int x, int y, int z, ItemStack[] products) {
+		return products;
+	}
+
+	@Override
+	public ItemStack[] getItemStacks() {
+		return new ItemStack[] { new ItemStack(Blocks.brown_mushroom), new ItemStack(Blocks.red_mushroom) };
+	}
+
+}
@@ -0,0 +1,76 @@
+/*******************************************************************************
+ * 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.block.Block;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+import net.minecraftforge.common.EnumPlantType;
+
+import forestry.api.genetics.IFlowerProvider;
+import forestry.api.genetics.IIndividual;
+import forestry.api.genetics.IPollinatable;
+import forestry.core.config.Defaults;
+import forestry.core.utils.StringUtil;
+
+public class FlowerProviderNetherwart implements IFlowerProvider {
+
+	@Override
+	public boolean isAcceptedFlower(World world, IIndividual individual, int x, int y, int z) {
+		Block block = world.getBlock(x, y, z);
+		return block == Blocks.nether_wart;
+	}
+
+	@Override
+	public boolean isAcceptedPollinatable(World world, IPollinatable pollinatable) {
+		return pollinatable.getPlantType().contains(EnumPlantType.Nether);
+	}
+
+	@Override
+	public boolean growFlower(World world, IIndividual individual, int x, int y, int z) {
+
+		Block block = world.getBlock(x, y, z);
+
+		// We only grow netherwart, we don't plant it
+		if (block != Blocks.nether_wart)
+			return false;
+
+		int meta = world.getBlockMetadata(x, y, z);
+		if (meta >= 3)
+			return false;
+
+		if (meta == 2)
+			meta = 3;
+		else
+			meta = 2;
+
+		world.setBlockMetadataWithNotify(x, y, z, meta, Defaults.FLAG_BLOCK_SYNCH);
+		return true;
+	}
+
+	@Override
+	public String getDescription() {
+		return StringUtil.localize("flowers.nether");
+	}
+
+	@Override
+	public ItemStack[] affectProducts(World world, IIndividual individual, int x, int y, int z, ItemStack[] products) {
+		return products;
+	}
+
+	@Override
+	public ItemStack[] getItemStacks() {
+		return new ItemStack[] { new ItemStack(Blocks.nether_wart) };
+	}
+
+}
@@ -0,0 +1,112 @@
+/*******************************************************************************
+ * 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.Collections;
+import java.util.EnumSet;
+
+import net.minecraft.block.Block;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+import net.minecraftforge.common.EnumPlantType;
+
+import forestry.api.apiculture.FlowerManager;
+import forestry.api.genetics.IFlowerProvider;
+import forestry.api.genetics.IIndividual;
+import forestry.api.genetics.IPollinatable;
+import forestry.core.config.Defaults;
+import forestry.core.utils.StackUtils;
+import forestry.core.utils.StringUtil;
+
+public class FlowerProviderVanilla implements IFlowerProvider {
+
+	@Override
+	public boolean isAcceptedFlower(World world, IIndividual individual, int x, int y, int z) {
+
+		Block block = world.getBlock(x, y, z);
+		int meta = world.getBlockMetadata(x, y, z);
+
+		// Specific check for flower pots.
+		if (block == Blocks.flower_pot)
+			return checkFlowerPot(meta);
+
+		ItemStack flower = new ItemStack(block, 1, meta);
+
+		for (ItemStack stack : FlowerManager.plainFlowers)
+			if (flower.isItemEqual(stack))
+				return true;
+
+		return false;
+	}
+
+	@Override
+	public boolean isAcceptedPollinatable(World world, IPollinatable pollinatable) {
+		EnumSet<EnumPlantType> types = pollinatable.getPlantType();
+		return types.size() > 1 || !types.contains(EnumPlantType.Nether);
+	}
+
+	private boolean checkFlowerPot(int meta) {
+		if (meta == 1 || meta == 2)
+			return true;
+		else
+			return false;
+	}
+
+	@Override
+	public boolean growFlower(World world, IIndividual individual, int x, int y, int z) {
+
+		Block block = world.getBlock(x, y, z);
+
+		if (!block.isAir(world, x, y, z))
+			if (block == Blocks.flower_pot  && world.getBlockMetadata(x, y, z) == 0)
+				return growInPot(world, x, y, z);
+			else
+				return false;
+
+		// Check ground
+		Block ground = world.getBlock(x, y - 1, z);
+
+		if (ground != Blocks.dirt && ground != Blocks.grass)
+			return false;
+
+		// Determine flower to plant
+		Collections.shuffle(FlowerManager.plainFlowers);
+		ItemStack flower = FlowerManager.plainFlowers.get(world.rand.nextInt(FlowerManager.plainFlowers.size() - 1));
+		world.setBlock(x, y, z, StackUtils.getBlock(flower), flower.getItemDamage(), Defaults.FLAG_BLOCK_SYNCH);
+		return true;
+	}
+
+	private boolean growInPot(World world, int x, int y, int z) {
+		if (world.rand.nextBoolean())
+			world.setBlock(x, y, z, Blocks.flower_pot, 1, Defaults.FLAG_BLOCK_SYNCH);
+		else
+			world.setBlock(x, y, z, Blocks.flower_pot, 2, Defaults.FLAG_BLOCK_SYNCH);
+		return true;
+	}
+
+	@Override
+	public String getDescription() {
+		return StringUtil.localize("flowers.vanilla");
+	}
+
+	@Override
+	public ItemStack[] affectProducts(World world, IIndividual individual, int x, int y, int z, ItemStack[] products) {
+		return products;
+	}
+
+	@Override
+	public ItemStack[] getItemStacks() {
+		return FlowerManager.plainFlowers.toArray(new ItemStack[0]);
+	}
+
+}
@@ -0,0 +1,79 @@
+/*******************************************************************************
+ * 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.EnumSet;
+
+import net.minecraft.block.Block;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+import net.minecraftforge.common.EnumPlantType;
+
+import forestry.api.genetics.IFlowerProvider;
+import forestry.api.genetics.IIndividual;
+import forestry.api.genetics.IPollinatable;
+import forestry.core.config.Defaults;
+import forestry.core.utils.StringUtil;
+
+public class FlowerProviderWheat implements IFlowerProvider {
+
+	@Override
+	public boolean isAcceptedFlower(World world, IIndividual individual, int x, int y, int z) {
+		Block block = world.getBlock(x, y, z);
+		return block == Blocks.wheat;
+	}
+
+	@Override
+	public boolean isAcceptedPollinatable(World world, IPollinatable pollinatable) {
+		EnumSet<EnumPlantType> types = pollinatable.getPlantType();
+		return types.size() > 1 || !types.contains(EnumPlantType.Nether);
+	}
+
+	@Override
+	public boolean growFlower(World world, IIndividual individual, int x, int y, int z) {
+
+		Block block = world.getBlock(x, y, z);
+
+		// We only grow wheat, we don't plant it
+		if (block != Blocks.wheat)
+			return false;
+
+		int meta = world.getBlockMetadata(x, y, z);
+		if (meta > 6)
+			return false;
+
+		if (meta < 6)
+			meta += 2;
+		else
+			meta = 7;
+
+		world.setBlockMetadataWithNotify(x, y, z, meta, Defaults.FLAG_BLOCK_SYNCH);
+		return true;
+	}
+
+	@Override
+	public String getDescription() {
+		return StringUtil.localize("flowers.wheat");
+	}
+
+	@Override
+	public ItemStack[] affectProducts(World world, IIndividual individual, int x, int y, int z, ItemStack[] products) {
+		return products;
+	}
+
+	@Override
+	public ItemStack[] getItemStacks() {
+		return new ItemStack[] { new ItemStack(Blocks.wheat, 1, 8) };
+	}
+
+}
@@ -0,0 +1,167 @@
+/*******************************************************************************
+ * 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.ContainerBeealyzer;
+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.ItemBiomefinder.BiomefinderInventory;
+import forestry.apiculture.items.ItemImprinter.ImprinterInventory;
+import forestry.core.GuiHandlerBase;
+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 = getEquippedItem(player);
+			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 = getEquippedItem(player);
+			if (equipped == null)
+				return null;
+
+			return new GuiHabitatLocator(player.inventory, new BiomefinderInventory(equipped));
+
+		case HygroregulatorGUI:
+			return new GuiAlvearyHygroregulator(player.inventory, (TileAlvearyHygroregulator) getTileForestry(world, x, y, z));
+
+		case ImprinterGUI:
+			return new GuiImprinter(player.inventory, new ImprinterInventory(player));
+
+		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 = getEquippedItem(player);
+			if (equipped == null)
+				return null;
+
+			synchApiaristTracker(world, player);
+			return new ContainerBeealyzer(player.inventory, new BeealyzerInventory(player, equipped));
+
+		case BeehouseGUI:
+			synchApiaristTracker(world, player);
+			return new ContainerApiary(player.inventory, (TileBeehouse) getTileForestry(world, x, y, z), false);
+
+		case HabitatLocatorGUI:
+			equipped = getEquippedItem(player);
+			if (equipped == null)
+				return null;
+
+			return new ContainerHabitatLocator(player.inventory, new BiomefinderInventory(equipped));
+
+		case HygroregulatorGUI:
+			return new ContainerAlvearyHygroregulator(player.inventory, (TileAlvearyHygroregulator) getTileForestry(world, x, y, z));
+
+		case ImprinterGUI:
+			synchApiaristTracker(world, player);
+			return new ContainerImprinter(player.inventory, new ImprinterInventory(player));
+
+		default:
+			return null;
+
+		}
+	}
+
+	private void synchApiaristTracker(World world, EntityPlayer player) {
+		PluginApiculture.beeInterface.getBreedingTracker(world, player.getGameProfile()).synchToPlayer(player);
+	}
+}
@@ -1,115 +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.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);
-	}
-}
@@ -1,18 +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 forestry.api.apiculture.IBeeHousing;
-import forestry.apiculture.inventory.IApiaryInventory;
-
-public interface IApiary extends IBeeHousing {
-	IApiaryInventory getApiaryInventory();
-}
@@ -1,78 +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.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);
-	}
-
-}
@@ -4,7 +4,7 @@
 * 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
 ******************************************************************************/
@@ -17,9 +17,8 @@ public class MaterialBeehive extends Material {

 	public MaterialBeehive(boolean noHarvest) {
 		super(MapColor.stoneColor);
-		if (noHarvest) {
+		if (noHarvest)
 			this.setRequiresTool();
-		}
 		setImmovableMobility();
 	}

@@ -0,0 +1,54 @@
+/*******************************************************************************
+ * 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 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 void onPacketData(int packetID, DataInputStream data, EntityPlayer player) {
+
+		try {
+
+			switch (packetID) {
+			case PacketIds.HABITAT_BIOME_POINTER:
+				PacketCoordinates packetC = new PacketCoordinates();
+				packetC.readData(data);
+				Proxies.common.setBiomefinderCoordinates(player, packetC.getCoordinates());
+				break;
+			case PacketIds.IMPRINT_SELECTION_GET:
+				onImprintSelectionGet(player);
+				break;
+			}
+		} catch (Exception ex) {
+			ex.printStackTrace();
+		}
+	}
+
+	private void onImprintSelectionGet(EntityPlayer playerEntity) {
+
+		if (!(playerEntity.openContainer instanceof ContainerImprinter))
+			return;
+
+		((ContainerImprinter) playerEntity.openContainer).sendSelection(playerEntity);
+
+	}
+
+}
@@ -4,7 +4,7 @@
 * 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
 ******************************************************************************/
@@ -12,14 +12,14 @@ package forestry.apiculture;

 import net.minecraft.world.World;

-import forestry.api.apiculture.BeeManager;
-import forestry.core.ISaveEventHandler;
+import forestry.core.interfaces.ISaveEventHandler;
+import forestry.plugins.PluginApiculture;

 public class SaveEventHandlerApiculture implements ISaveEventHandler {

 	@Override
 	public void onWorldLoad(World world) {
-		BeeManager.beeRoot.resetBeekeepingMode();
+		PluginApiculture.beeInterface.resetBeekeepingMode();
 	}

 	@Override
@@ -4,11 +4,11 @@
 * 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.commands;
+package forestry.apiculture;

 import net.minecraft.command.CommandException;

@@ -17,7 +17,7 @@ public class SpeciesNotFoundException extends CommandException {
 	private static final long serialVersionUID = 1L;

 	public SpeciesNotFoundException(String title) {
-		super("Could not find species with Name or UID %s", title);
+		super("Could not find bee species with Name or UID %s", title);
 	}

 }
@@ -4,11 +4,11 @@
 * 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.commands;
+package forestry.apiculture;

 import net.minecraft.command.CommandException;

@@ -4,7 +4,7 @@
 * 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
 ******************************************************************************/
@@ -23,16 +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.blocks.BlockApicultureType;
-import forestry.apiculture.genetics.BeeDefinition;
+import forestry.apiculture.genetics.BeeTemplates;
+import forestry.apiculture.items.ItemHoneycomb;
 import forestry.apiculture.worldgen.ComponentVillageBeeHouse;
-import forestry.core.utils.Log;
+import forestry.core.config.Defaults;
+import forestry.core.config.ForestryBlock;
+import forestry.core.config.ForestryItem;
 import forestry.plugins.PluginApiculture;

 public class VillageHandlerApiculture implements IVillageCreationHandler, IVillageTradeHandler {
@@ -41,32 +41,25 @@ public class VillageHandlerApiculture implements IVillageCreationHandler, IVilla
 		try {
 			MapGenStructureIO.func_143031_a(ComponentVillageBeeHouse.class, "Forestry:BeeHouse");
 		} catch (Throwable e) {
-			Log.severe("Failed to register village beehouse.");
 		}
 	}

 	@SuppressWarnings("unchecked")
 	@Override
 	public void manipulateTradesForVillager(EntityVillager villager, MerchantRecipeList recipeList, Random random) {
-		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));
+		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())));
 	}

 	@Override
 	public StructureVillagePieces.PieceWeight getVillagePieceWeight(Random random, int size) {
-		return new StructureVillagePieces.PieceWeight(ComponentVillageBeeHouse.class, 15, MathHelper.getRandomIntegerInRange(random, size, 1 + size));
+		return new StructureVillagePieces.PieceWeight(ComponentVillageBeeHouse.class, 15, MathHelper.getRandomIntegerInRange(random, 0 + size, 1 + size));
 	}

 	@Override
@@ -1,291 +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.blocks;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import net.minecraft.block.Block;
-import net.minecraft.client.renderer.texture.IIconRegister;
-import net.minecraft.creativetab.CreativeTabs;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.tileentity.TileEntity;
-import net.minecraft.util.IIcon;
-import net.minecraft.world.IBlockAccess;
-import net.minecraft.world.World;
-
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
-
-import forestry.api.core.Tabs;
-import forestry.apiculture.MaterialBeehive;
-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"})
-	@Override
-	@SideOnly(Side.CLIENT)
-	public void getSubBlocks(Item item, CreativeTabs tab, List list) {
-		for (int i = 0; i < 8; i++) {
-			if (i == 1) {
-				continue;
-			}
-			list.add(new ItemStack(item, 1, i));
-		}
-	}
-
-	@Override
-	public int getRenderType() {
-		return 0;
-	}
-
-	@Override
-	public boolean renderAsNormalBlock() {
-		return true;
-	}
-
-	@Override
-	public ArrayList<ItemStack> getDrops(World world, int x, int y, int z, int metadata, int fortune) {
-		ArrayList<ItemStack> drop = new ArrayList<>();
-		drop.add(new ItemStack(this, 1, metadata != 1 ? metadata : 0));
-		return drop;
-	}
-
-	@Override
-	public int getDamageValue(World world, int x, int y, int z) {
-		int meta = world.getBlockMetadata(x, y, z);
-		return meta != 1 ? meta : 0;
-	}
-
-	/* TILE ENTITY CREATION */
-	@Override
-	public TileEntity createTileEntity(World world, int metadata) {
-		if (metadata < 0 || metadata > Type.VALUES.length) {
-			return null;
-		}
-
-		Type type = Type.VALUES[metadata];
-		switch (type) {
-			case SWARMER:
-				return new TileAlvearySwarmer();
-			case FAN:
-				return new TileAlvearyFan();
-			case HEATER:
-				return new TileAlvearyHeater();
-			case HYGRO:
-				return new TileAlvearyHygroregulator();
-			case STABILIZER:
-				return new TileAlvearyStabiliser();
-			case SIEVE:
-				return new TileAlvearySieve();
-			case PLAIN:
-			default:
-				return new TileAlvearyPlain();
-		}
-	}
-
-	@Override
-	public TileEntity createNewTileEntity(World world, int meta) {
-		return createTileEntity(world, meta);
-	}
-
-	/* ICONS */
-	public static final int PLAIN = 0;
-	public static final int ENTRANCE = 1;
-	public static final int BOTTOM = 2;
-	public static final int LEFT = 3;
-	public static final int RIGHT = 4;
-	public static final int ALVEARY_SWARMER_OFF = 5;
-	public static final int ALVEARY_SWARMER_ON = 6;
-	public static final int ALVEARY_HEATER_OFF = 7;
-	public static final int ALVEARY_HEATER_ON = 8;
-	public static final int ALVEARY_FAN_OFF = 9;
-	public static final int ALVEARY_FAN_ON = 10;
-	public static final int ALVEARY_HYGRO = 11;
-	public static final int STABILISER = 12;
-	public static final int SIEVE = 13;
-
-	@SideOnly(Side.CLIENT)
-	private IIcon[] icons;
-
-	@SideOnly(Side.CLIENT)
-	@Override
-	public void registerBlockIcons(IIconRegister register) {
-		icons = new IIcon[14];
-		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 == Type.SIEVE.ordinal() || metadata == Type.SWARMER.ordinal() || metadata == Type.STABILIZER.ordinal())
-				&& (side == 1 || side == 0)) {
-			return icons[BOTTOM];
-		}
-
-		Type type = Type.VALUES[metadata];
-
-		switch (type) {
-			case PLAIN:
-				return icons[PLAIN];
-			case ENTRANCE:
-				return icons[ENTRANCE];
-			case SWARMER:
-				return icons[ALVEARY_SWARMER_OFF];
-			case FAN:
-				return icons[ALVEARY_FAN_OFF];
-			case HEATER:
-				return icons[ALVEARY_HEATER_OFF];
-			case HYGRO:
-				return icons[ALVEARY_HYGRO];
-			case STABILIZER:
-				return icons[STABILISER];
-			case SIEVE:
-				return icons[SIEVE];
-			default:
-				return null;
-		}
-
-	}
-
-	@SideOnly(Side.CLIENT)
-	@Override
-	public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
-		int meta = world.getBlockMetadata(x, y, z);
-
-		if (meta == 1) {
-			return this.getIcon(side, meta);
-		} else if (meta > 1) {
-			return getBlockTextureFromSideAndTile(world, x, y, z, side);
-		}
-
-		Block blockXP = world.getBlock(x + 1, y, z);
-		Block blockXM = world.getBlock(x - 1, y, z);
-
-		if (blockXP == this && blockXM != this) {
-
-			if (world.getBlockMetadata(x + 1, y, z) == 1) {
-
-				if (world.getBlock(x, y, z + 1) != this) {
-					return switchForSide(42, side);
-				} else {
-					return switchForSide(41, side);
-				}
-
-			} else {
-				return this.getIcon(side, meta);
-			}
-
-		} else if (blockXP != this && blockXM == this) {
-			if (world.getBlockMetadata(x - 1, y, z) == 1) {
-
-				if (world.getBlock(x, y, z + 1) != this) {
-					return switchForSide(41, side);
-				} else {
-					return switchForSide(42, side);
-				}
-
-			} else {
-				return this.getIcon(side, meta);
-			}
-		}
-
-		return this.getIcon(side, meta);
-	}
-
-	@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 instanceof TileAlveary)) {
-			return getIcon(side, 0);
-		}
-
-		return icons[((TileAlveary) tile).getIcon(side)];
-	}
-
-	@SideOnly(Side.CLIENT)
-	private IIcon switchForSide(int textureId, int side) {
-
-		if (side == 4 || side == 5) {
-			if (textureId == 41) {
-				return icons[LEFT];
-			} else {
-				return icons[RIGHT];
-			}
-		} else if (textureId == 41) {
-			return icons[RIGHT];
-		} else {
-			return icons[LEFT];
-		}
-
-	}
-
-	@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());
-	}
-}
@@ -1,22 +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.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);
-	}
-}
@@ -1,58 +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.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;
-	}
-}
@@ -1,336 +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.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);
-	}
-}
@@ -1,41 +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.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");
-	}
-}
@@ -1,61 +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.commands;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import net.minecraft.world.World;
-
-import forestry.api.apiculture.BeeManager;
-import forestry.api.apiculture.IBeekeepingMode;
-import forestry.core.commands.ICommandModeHelper;
-
-public class BeeModeHelper implements ICommandModeHelper {
-
-	@Override
-	public String[] getModeNames() {
-		ArrayList<IBeekeepingMode> beekeepingModes = BeeManager.beeRoot.getBeekeepingModes();
-		int modeStringCount = beekeepingModes.size();
-		List<String> modeStrings = new ArrayList<>(modeStringCount);
-		for (IBeekeepingMode mode : beekeepingModes) {
-			modeStrings.add(mode.getName());
-		}
-
-		return modeStrings.toArray(new String[modeStringCount]);
-	}
-
-	@Override
-	public String getModeNameMatching(String desired) {
-		IBeekeepingMode mode = BeeManager.beeRoot.getBeekeepingMode(desired);
-		if (mode == null) {
-			return null;
-		}
-		return mode.getName();
-	}
-
-	@Override
-	public String getModeName(World world) {
-		return BeeManager.beeRoot.getBeekeepingMode(world).getName();
-	}
-
-	@Override
-	public void setMode(World world, String modeName) {
-		BeeManager.beeRoot.setBeekeepingMode(world, modeName);
-	}
-
-	@Override
-	public Iterable<String> getDescription(String modeName) {
-		IBeekeepingMode mode = BeeManager.beeRoot.getBeekeepingMode(modeName);
-		return mode.getDescription();
-	}
-
-}
@@ -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.commands;
-
-import java.util.ArrayList;
-import java.util.Collection;
-
-import net.minecraft.util.StatCollector;
-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;
-import forestry.api.genetics.IAllele;
-import forestry.api.genetics.IAlleleSpecies;
-import forestry.api.genetics.IBreedingTracker;
-import forestry.core.commands.IStatsSaveHelper;
-import forestry.core.utils.StringUtil;
-
-public class BeeStatsSaveHelper implements IStatsSaveHelper {
-
-	@Override
-	public String getUnlocalizedSaveStatsString() {
-		return "for.chat.command.forestry.bee.save.stats";
-	}
-
-	@Override
-	public void addExtraInfo(Collection<String> statistics, IBreedingTracker breedingTracker) {
-		IApiaristTracker tracker = (IApiaristTracker) breedingTracker;
-		String discoveredLine = StatCollector.translateToLocal("for.chat.command.forestry.stats.save.key.discovered") + ":";
-		statistics.add(discoveredLine);
-		statistics.add(StringUtil.line(discoveredLine.length()));
-
-		String queen = StatCollector.translateToLocal("for.bees.grammar.queen.type");
-		String princess = StatCollector.translateToLocal("for.bees.grammar.princess.type");
-		String drone = StatCollector.translateToLocal("for.bees.grammar.drone.type");
-		statistics.add(queen + ":\t\t" + tracker.getQueenCount());
-		statistics.add(princess + ":\t" + tracker.getPrincessCount());
-		statistics.add(drone + ":\t\t" + tracker.getDroneCount());
-		statistics.add("");
-	}
-
-	@Override
-	public Collection<IAlleleSpecies> getSpecies() {
-		Collection<IAlleleSpecies> species = new ArrayList<>();
-		for (IAllele allele : AlleleManager.alleleRegistry.getRegisteredAlleles().values()) {
-			if (allele instanceof IAlleleBeeSpecies) {
-				species.add((IAlleleBeeSpecies) allele);
-			}
-		}
-		return species;
-	}
-
-	@Override
-	public String getFileSuffix() {
-		return "bees";
-	}
-
-	@Override
-	public IBreedingTracker getBreedingTracker(World world, GameProfile gameProfile) {
-		return BeeManager.beeRoot.getBreedingTracker(world, gameProfile);
-	}
-
-}
@@ -1,32 +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.commands;
-
-import forestry.core.commands.CommandMode;
-import forestry.core.commands.CommandSaveStats;
-import forestry.core.commands.ICommandModeHelper;
-import forestry.core.commands.IStatsSaveHelper;
-import forestry.core.commands.SubCommand;
-
-public class CommandBee extends SubCommand {
-
-	public CommandBee() {
-		super("bee");
-		addAlias("beekeeping");
-
-		IStatsSaveHelper saveHelper = new BeeStatsSaveHelper();
-		ICommandModeHelper modeHelper = new BeeModeHelper();
-
-		addChildCommand(new CommandMode(modeHelper));
-		addChildCommand(new CommandSaveStats(saveHelper, modeHelper));
-		addChildCommand(new CommandBeeGive());
-	}
-}
@@ -1,179 +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.commands;
-
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-
-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;
-import forestry.api.apiculture.IBeeGenome;
-import forestry.api.genetics.AlleleManager;
-import forestry.api.genetics.IAllele;
-import forestry.core.commands.CommandHelpers;
-import forestry.core.commands.SpeciesNotFoundException;
-import forestry.core.commands.SubCommand;
-import forestry.core.commands.TemplateNotFoundException;
-
-public class CommandBeeGive extends SubCommand {
-
-	private final String beeTypeHelpString;
-	private final String[] beeTypeArr;
-
-	public CommandBeeGive() {
-		super("give");
-		setPermLevel(PermLevel.ADMIN);
-
-		List<String> beeTypeStrings = new ArrayList<>();
-		for (EnumBeeType type : EnumBeeType.values()) {
-			if (type == EnumBeeType.NONE) {
-				continue;
-			}
-			beeTypeStrings.add(type.getName());
-		}
-
-		beeTypeArr = beeTypeStrings.toArray(new String[beeTypeStrings.size()]);
-
-		StringBuilder beeTypeHelp = new StringBuilder();
-		String separator = ", ";
-
-		Iterator<String> iter = beeTypeStrings.iterator();
-		while (iter.hasNext()) {
-			beeTypeHelp.append(iter.next());
-			if (iter.hasNext()) {
-				beeTypeHelp.append(separator);
-			}
-		}
-		beeTypeHelpString = beeTypeHelp.toString();
-	}
-
-	@Override
-	public void processSubCommand(ICommandSender sender, String[] arguments) {
-		if (arguments.length < 2) {
-			printHelp(sender);
-			return;
-		}
-
-		IBeeGenome beeGenome = getBeeGenome(arguments[0]);
-		EnumBeeType beeType = getBeeType(arguments[1]);
-		if (beeType == EnumBeeType.NONE) {
-			printHelp(sender);
-			return;
-		}
-
-		EntityPlayer player;
-		if (arguments.length == 3) {
-			player = CommandHelpers.getPlayer(sender, arguments[2]);
-		} else {
-			player = CommandHelpers.getPlayer(sender, sender.getCommandSenderName());
-		}
-		if (player == null) {
-			printHelp(sender);
-			return;
-		}
-
-		IBee bee = BeeManager.beeRoot.getBee(player.worldObj, beeGenome);
-
-		if (beeType == EnumBeeType.QUEEN) {
-			bee.mate(bee);
-		}
-
-		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());
-	}
-
-	private static IBeeGenome getBeeGenome(String speciesName) {
-		IAlleleBeeSpecies species = null;
-
-		for (String uid : AlleleManager.alleleRegistry.getRegisteredAlleles().keySet()) {
-
-			if (!uid.equals(speciesName)) {
-				continue;
-			}
-
-			if (AlleleManager.alleleRegistry.getAllele(uid) instanceof IAlleleBeeSpecies) {
-				species = (IAlleleBeeSpecies) AlleleManager.alleleRegistry.getAllele(uid);
-				break;
-			}
-		}
-
-		if (species == null) {
-			for (IAllele allele : AlleleManager.alleleRegistry.getRegisteredAlleles().values()) {
-				if (allele instanceof IAlleleBeeSpecies && allele.getName().equals(speciesName)) {
-					species = (IAlleleBeeSpecies) allele;
-					break;
-				}
-			}
-		}
-
-		if (species == null) {
-			throw new SpeciesNotFoundException(speciesName);
-		}
-
-		IAllele[] template = BeeManager.beeRoot.getTemplate(species.getUID());
-
-		if (template == null) {
-			throw new TemplateNotFoundException(species);
-		}
-
-		return BeeManager.beeRoot.templateAsGenome(template);
-	}
-
-	@Override
-	public List<String> addTabCompletionOptions(ICommandSender sender, String[] parameters) {
-		if (parameters.length == 1) {
-			List<String> tabCompletion = CommandHelpers.getListOfStringsMatchingLastWord(parameters, getSpecies());
-			tabCompletion.add("help");
-			return tabCompletion;
-		} else if (parameters.length == 2) {
-			return CommandHelpers.getListOfStringsMatchingLastWord(parameters, beeTypeArr);
-		} else if (parameters.length == 3) {
-			return CommandHelpers.getListOfStringsMatchingLastWord(parameters, CommandHelpers.getPlayers());
-		}
-		return null;
-	}
-
-	private static String[] getSpecies() {
-		List<String> species = new ArrayList<>();
-
-		for (IAllele allele : AlleleManager.alleleRegistry.getRegisteredAlleles().values()) {
-			if (allele instanceof IAlleleBeeSpecies) {
-				species.add(allele.getName());
-			}
-		}
-
-		return species.toArray(new String[species.size()]);
-	}
-
-	private static EnumBeeType getBeeType(String beeTypeName) {
-		for (EnumBeeType beeType : EnumBeeType.values()) {
-			if (beeType.getName().equalsIgnoreCase(beeTypeName)) {
-				return beeType;
-			}
-		}
-		return EnumBeeType.NONE;
-	}
-
-	@Override
-	public void printHelp(ICommandSender sender) {
-		super.printHelp(sender);
-		CommandHelpers.sendLocalizedChatMessage(sender, "for.chat.command.forestry.beekeeping.give.available", beeTypeHelpString);
-	}
-}
@@ -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.Constants;
-import forestry.core.render.ForestryResource;
+import forestry.core.config.Defaults;
+import forestry.core.utils.ForestryResource;
+import forestry.plugins.PluginApiculture;

 public class EntityBee extends EntityCreature implements IAnimals {

-	private static final String DEFAULT_TEXTURE = Constants.TEXTURE_PATH_ENTITIES + "/bees/honeyBee.png";
+	private static final String DEFAULT_TEXTURE = Defaults.TEXTURE_PATH_ENTITIES + "/bees/honeyBee.png";

-	private IBee contained;
-	private IAlleleBeeSpecies species;
-	private EnumBeeType type = EnumBeeType.DRONE;
+	IBee contained;
+	IAlleleBeeSpecies species;
+	EnumBeeType type = EnumBeeType.DRONE;

 	private String beeTexture = DEFAULT_TEXTURE;
 	private long lastUpdate;
@@ -45,11 +45,10 @@ public class EntityBee extends EntityCreature implements IAnimals {
 	}

 	public EntityBee setIndividual(IBee bee) {
-		if (bee != null) {
+		if (bee != null)
 			contained = bee;
-		} else {
-			contained = BeeManager.beeRoot.templateAsIndividual(BeeManager.beeRoot.getDefaultTemplate());
-		}
+		else
+			contained = PluginApiculture.beeInterface.templateAsIndividual(PluginApiculture.beeInterface.getDefaultTemplate());

 		//isImmuneToFire = contained.getGenome().getFireResist();
 		setSpecies(contained.getGenome().getPrimary());
@@ -84,9 +83,8 @@ public class EntityBee extends EntityCreature implements IAnimals {

 	@SideOnly(Side.CLIENT)
 	public ResourceLocation getTexture() {
-		if (textureResource == null || lastTextureUpdate != lastUpdate) {
+		if (textureResource == null || lastTextureUpdate != lastUpdate)
 			textureResource = new ForestryResource(beeTexture);
-		}

 		return textureResource;
 	}
@@ -1,121 +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.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);
-	}
-
-	@Override
-	public int getIdOfEntity() {
-		return getEntityId();
-	}
-}
@@ -1,184 +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.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);
-	}
-}
@@ -1,106 +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.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);
-	}
-
-	@Override
-	public int getIdOfEntity() {
-		return getEntityId();
-	}
-}
@@ -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.flowers;
-
-import com.google.common.base.Objects;
-
-import javax.annotation.Nonnull;
-
-import net.minecraft.block.Block;
-
-import net.minecraftforge.oredict.OreDictionary;
-
-import forestry.api.genetics.IFlower;
-
-final class Flower implements IFlower {
-
-	private final Block block;
-	private final int meta;
-	private Double weight;
-
-	public Flower(Block block, int meta, double weight) {
-		this.block = block;
-		this.meta = meta;
-		this.weight = weight;
-	}
-
-	public boolean isPlantable() {
-		return this.weight != 0.0;
-	}
-	
-	@Override
-	public boolean equals(Object obj) {
-		if (!(obj instanceof IFlower)) {
-			return false;
-		}
-
-		IFlower flower = (IFlower) obj;
-
-		return Block.isEqualTo(this.block, flower.getBlock()) && (this.meta == OreDictionary.WILDCARD_VALUE || flower.getMeta() == OreDictionary.WILDCARD_VALUE || this.meta == flower.getMeta());
-	}
-
-	@Override
-	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;
-	}
-
-	@Override
-	public int getMeta() {
-		return meta;
-	}
-
-	@Override
-	public double getWeight() {
-		return weight;
-	}
-
-	@Override
-	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();
-	}
-
-}
@@ -1,330 +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.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.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-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, 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, IFlowerGrowthRule> growthRules;
-	private final Map<String, TreeMap<Double, Flower>> chances;
-
-	public FlowerRegistry() {
-		this.registeredRules = HashMultimap.create();
-		this.registeredBlocks = HashMultimap.create();
-		this.registeredFlowers = HashMultimap.create();
-		this.growthRules = ArrayListMultimap.create();
-		this.chances = new HashMap<>();
-
-		registerVanillaGrowthRules();
-	}
-
-	@Override
-	public void registerAcceptableFlower(Block block, String... flowerTypes) {
-		registerFlower(block, OreDictionary.WILDCARD_VALUE, 0.0, flowerTypes);
-	}
-
-	@Override
-	public void registerAcceptableFlower(Block block, int meta, String... flowerTypes) {
-		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);
-	}
-
-	private void registerFlower(Block block, int meta, double weight, String... flowerTypes) {
-		if (block == null) {
-			return;
-		}
-		if (weight <= 0.0) {
-			weight = 0.0;
-		}
-		if (weight >= 1.0) {
-			weight = 1.0;
-		}
-
-		Flower newFlower = new Flower(block, meta, weight);
-
-		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);
-			}
-		}
-	}
-
-	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 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;
-		}
-
-		Set<IFlowerAcceptableRule> acceptedCustom = this.registeredRules.get(flowerType);
-		for (IFlowerAcceptableRule acceptableFlower : acceptedCustom) {
-			if (acceptableFlower.isAcceptableFlower(flowerType, world, x, y, z)) {
-				return true;
-			}
-		}
-
-		Set<Block> acceptedBlocks = this.registeredBlocks.get(flowerType);
-		Set<Flower> acceptedFlowers = this.registeredFlowers.get(flowerType);
-
-		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);
-		return acceptedFlowers.contains(flower);
-	}
-
-	@Override
-	public boolean growFlower(String flowerType, World world, IIndividual individual, int x, int y, int z) {
-		if (!this.growthRules.containsKey(flowerType)) {
-			return false;
-		}
-
-		for (IFlowerGrowthRule rule : this.growthRules.get(flowerType)) {
-			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;
-			}
-		}
-
-		return false;
-	}
-
-	@Override
-	public Set<IFlower> getAcceptableFlowers(String flowerType) {
-		return ImmutableSet.<IFlower>copyOf(this.registeredFlowers.get(flowerType));
-	}
-
-	@Override
-	public void registerGrowthRule(IFlowerGrowthRule rule, String... flowerTypes) {
-		if (rule == null) {
-			return;
-		}
-
-		for (String flowerType : flowerTypes) {
-			this.growthRules.get(flowerType).add(rule);
-		}
-	}
-
-	@Override
-	public IFlower getRandomPlantableFlower(String flowerType, Random rand) {
-		TreeMap<Double, Flower> chancesMap = getChancesMap(flowerType);
-		double maxKey = chancesMap.lastKey() + 1.0;
-		return chancesMap.get(chancesMap.lowerKey(rand.nextDouble() * maxKey));
-	}
-
-	@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, Flower> flowerChances = new TreeMap<>();
-			double count = 0.0;
-			for (Flower flower : this.registeredFlowers.get(flowerType)) {
-				if (flower.isPlantable()) {
-					flowerChances.put(count, flower);
-					count += flower.getWeight();
-				}
-			}
-			this.chances.put(flowerType, flowerChances);
-		}
-		return this.chances.get(flowerType);
-	}
-
-	private void registerVanillaGrowthRules() {
-		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 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);
-	}
-}
@@ -1,55 +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.flowers;
-
-import net.minecraft.block.Block;
-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.Constants;
-
-public class GrowthRuleDirtGrass implements IFlowerGrowthRule {
-
-	@Override
-	public boolean growFlower(IFlowerRegistry flowerRegistry, String flowerType, World world, IIndividual individual, 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;
-		}
-
-		IFlower flower = flowerRegistry.getRandomPlantableFlower(flowerType, world.rand);
-		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);
-	}
-
-}
@@ -1,64 +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.flowers;
-
-import java.util.Arrays;
-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 GrowthRuleFertilize implements IFlowerGrowthRule {
-
-	private final List<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) {
-			if (b == ground) {
-				groundMeta = world.getBlockMetadata(x, y, z);
-				if (groundMeta > 6) {
-					return false;
-				}
-				if (groundMeta < 6) {
-					groundMeta += world.rand.nextInt(2) + 1;
-				} else {
-					groundMeta = 7;
-				}
-
-				return world.setBlockMetadataWithNotify(x, y, z, groundMeta, 2);
-			}
-		}
-
-		return false;
-	}
-
-}
@@ -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.flowers;
-
-import net.minecraft.block.Block;
-import net.minecraft.block.BlockFlowerPot;
-import net.minecraft.tileentity.TileEntity;
-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 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;
-		}
-
-		TileEntityFlowerPot flowerPotTile = (TileEntityFlowerPot) tile;
-		if (flowerPotTile.getFlowerPotItem() != null) {
-			return false;
-		}
-
-		Block block = world.getBlock(x, y, z);
-		if (!(block instanceof BlockFlowerPot)) {
-			return false;
-		}
-
-		BlockFlowerPot flowerPot = (BlockFlowerPot) block;
-
-		int flower;
-		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);
-
-		flowerPotTile.func_145964_a(newTile.getFlowerPotItem(), newTile.getFlowerPotData());
-		flowerPotTile.markDirty();
-
-		if (!world.setBlockMetadataWithNotify(x, y, z, 1, 2)) {
-			world.markBlockForUpdate(x, y, z);
-		}
-
-		return true;
-	}
-}
@@ -1,55 +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.flowers;
-
-import net.minecraft.block.Block;
-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.Constants;
-
-public class GrowthRuleMycelium implements IFlowerGrowthRule {
-
-	@Override
-	public boolean growFlower(IFlowerRegistry fr, String flowerType, World world, IIndividual individual, 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;
-		}
-
-		IFlower flower = fr.getRandomPlantableFlower(flowerType, world.rand);
-		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);
-	}
-
-}
@@ -1,32 +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.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 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;
-	}
-
-}
@@ -1,55 +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.flowers;
-
-import net.minecraft.block.Block;
-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.Constants;
-
-public class GrowthRuleSnow implements IFlowerGrowthRule {
-
-	@Override
-	public boolean growFlower(IFlowerRegistry fr, String flowerType, World world, IIndividual individual, 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;
-		}
-
-		IFlower flower = fr.getRandomPlantableFlower(flowerType, world.rand);
-		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);
-	}
-
-}
@@ -0,0 +1,234 @@
+/*******************************************************************************
+ * 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 net.minecraft.block.Block;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+import forestry.api.core.Tabs;
+import forestry.apiculture.MaterialBeehive;
+import forestry.core.gadgets.BlockStructure;
+import forestry.core.render.TextureManager;
+
+public class BlockAlveary extends BlockStructure {
+
+	public BlockAlveary() {
+		super(new MaterialBeehive(false));
+		setHardness(1.0f);
+		setCreativeTab(Tabs.tabApiculture);
+	}
+
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void getSubBlocks(Item item, CreativeTabs tab, List list) {
+		for (int i = 0; i < 8; i++) {
+			if (i == 1)
+				continue;
+			list.add(new ItemStack(item, 1, i));
+		}
+	}
+
+	@Override
+	public int getRenderType() {
+		return 0;
+	}
+
+	@Override
+	public boolean renderAsNormalBlock() {
+		return true;
+	}
+
+	@Override
+	public ArrayList<ItemStack> getDrops(World world, int x, int y, int z, int metadata, int fortune) {
+		ArrayList<ItemStack> drop = new ArrayList<ItemStack>();
+		drop.add(new ItemStack(this, 1, metadata != 1 ? metadata : 0));
+		return drop;
+	}
+
+	@Override
+	public int getDamageValue(World world, int x, int y, int z) {
+		int meta = world.getBlockMetadata(x, y, z);
+		return meta != 1 ? meta : 0;
+	}
+
+	/* TILE ENTITY CREATION */
+	@Override
+	public TileEntity createTileEntity(World world, int metadata) {
+		switch (metadata) {
+		case TileAlvearySwarmer.BLOCK_META:
+			return new TileAlvearySwarmer();
+		case TileAlvearyFan.BLOCK_META:
+			return new TileAlvearyFan();
+		case TileAlvearyHeater.BLOCK_META:
+			return new TileAlvearyHeater();
+		case TileAlvearyHygroregulator.BLOCK_META:
+			return new TileAlvearyHygroregulator();
+		case TileAlvearyStabiliser.BLOCK_META:
+			return new TileAlvearyStabiliser();
+		case TileAlvearySieve.BLOCK_META:
+			return new TileAlvearySieve();
+		default:
+			return new TileAlvearyPlain();
+		}
+	}
+
+	@Override
+	public TileEntity createNewTileEntity(World world, int meta) {
+		return createTileEntity(world, meta);
+	}
+
+	/* ICONS */
+	public static final int PLAIN = 0;
+	public static final int ENTRANCE = 1;
+	public static final int BOTTOM = 2;
+	public static final int LEFT = 3;
+	public static final int RIGHT = 4;
+	public static final int TX_55_SWOF = 5;
+	public static final int TX_56_SWON = 6;
+	public static final int TX_57_HTOF = 7;
+	public static final int TX_58_HTON = 8;
+	public static final int TX_71_FNOF = 9;
+	public static final int TX_72_FNON = 10;
+	public static final int TX_73_VLVE = 11;
+	public static final int STABILISER = 12;
+	public static final int SIEVE = 13;
+
+	@SideOnly(Side.CLIENT)
+	private IIcon[] icons;
+
+	@SideOnly(Side.CLIENT)
+	@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");
+	}
+
+	@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)
+				&& (side == 1 || side == 0))
+			return icons[BOTTOM];
+
+		switch (metadata) {
+		case TileAlvearyPlain.BLOCK_META:
+			return icons[PLAIN];
+		case 1:
+			return icons[ENTRANCE];
+		case TileAlvearySwarmer.BLOCK_META:
+			return icons[TX_55_SWOF];
+		case TileAlvearyFan.BLOCK_META:
+			return icons[TX_71_FNOF];
+		case TileAlvearyHeater.BLOCK_META:
+			return icons[TX_57_HTOF];
+		case TileAlvearyHygroregulator.BLOCK_META:
+			return icons[TX_73_VLVE];
+		case TileAlvearyStabiliser.BLOCK_META:
+			return icons[STABILISER];
+		case TileAlvearySieve.BLOCK_META:
+			return icons[SIEVE];
+		default:
+			return null;
+		}
+
+	}
+
+	@SideOnly(Side.CLIENT)
+	@Override
+	public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
+		int meta = world.getBlockMetadata(x, y, z);
+
+		if (meta == 1)
+			return this.getIcon(side, meta);
+		else if (meta > 1)
+			return getBlockTextureFromSideAndTile(world, x, y, z, side);
+
+		Block blockXP = world.getBlock(x + 1, y, z);
+		Block blockXM = world.getBlock(x - 1, y, z);
+
+		if (blockXP == this && blockXM != this) {
+
+			if (world.getBlockMetadata(x + 1, y, z) == 1) {
+
+				if (world.getBlock(x, y, z + 1) != this)
+					return switchForSide(42, side);
+				else
+					return switchForSide(41, side);
+
+			} else
+				return this.getIcon(side, meta);
+
+		} else if (blockXP != this && blockXM == this)
+			if (world.getBlockMetadata(x - 1, y, z) == 1) {
+
+				if (world.getBlock(x, y, z + 1) != this)
+					return switchForSide(41, side);
+				else
+					return switchForSide(42, side);
+
+			} else
+				return this.getIcon(side, meta);
+
+		return this.getIcon(side, meta);
+	}
+
+	@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))
+			return getIcon(side, 0);
+
+		return icons[((TileAlveary) tile).getIcon(side, world.getBlockMetadata(x, y, z))];
+	}
+
+	@SideOnly(Side.CLIENT)
+	private IIcon switchForSide(int textureId, int side) {
+
+		if (side == 4 || side == 5) {
+			if (textureId == 41)
+				return icons[LEFT];
+			else
+				return icons[RIGHT];
+		} else if (textureId == 41)
+			return icons[RIGHT];
+		else
+			return icons[LEFT];
+
+	}
+}
@@ -4,11 +4,11 @@
 * 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;
+package forestry.apiculture.gadgets;

 import java.util.ArrayList;
 import java.util.Collections;
@@ -29,30 +29,21 @@ 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.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.render.TextureManager;
-import forestry.core.utils.InventoryUtil;
-import forestry.core.utils.ItemStackUtil;
-import forestry.plugins.PluginApiculture;
+import forestry.core.utils.StackUtils;

 public class BlockBeehives extends BlockContainer {
-	public enum Type {
-		LEGACY,
-		FOREST,
-		MEADOWS;
-	}

 	public BlockBeehives() {
 		super(new MaterialBeehive(true));
 		setLightLevel(0.8f);
 		setHardness(1.0f);
 		setCreativeTab(Tabs.tabApiculture);
-		setHarvestLevel("scoop", 0);
 	}

 	@Override
@@ -66,20 +57,17 @@ public class BlockBeehives extends BlockContainer {
 	}

 	@Override
-	public boolean removedByPlayer(World world, EntityPlayer player, int x, int y, int z) {
+	public boolean removedByPlayer(World world, EntityPlayer player, int x, int y, int z, boolean willHarvest) {
 		if (canHarvestBlock(player, world.getBlockMetadata(x, y, z))) {
 			// Handle TE'd beehives
 			TileEntity tile = world.getTileEntity(x, y, z);

 			if (tile instanceof TileSwarm) {
 				TileSwarm swarm = (TileSwarm) tile;
-				if (swarm.containsBees()) {
-					for (ItemStack beeStack : InventoryUtil.getStacks(swarm.contained)) {
-						if (beeStack != null) {
-							ItemStackUtil.dropItemStackAsEntity(beeStack, world, x, y, z);
-						}
-					}
-				}
+				if (swarm.containsBees())
+					for (ItemStack beeStack : swarm.contained.getStacks())
+						if (beeStack != null)
+							StackUtils.dropItemStackAsEntity(beeStack, world, x, y, z);
 			}
 		}

@@ -88,7 +76,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<>();
+		ArrayList<ItemStack> ret = new ArrayList<ItemStack>();

 		// Handle legacy block
 		if (metadata == 0) {
@@ -96,7 +84,7 @@ public class BlockBeehives extends BlockContainer {
 			return ret;
 		}

-		List<IHiveDrop> dropList = getDropsForHive(metadata);
+		ArrayList<IHiveDrop> dropList = BeeManager.hiveDrops[metadata - 1];

 		Collections.shuffle(dropList);
 		// Grab a princess
@@ -105,29 +93,26 @@ public class BlockBeehives extends BlockContainer {
 		while (tries <= 10 && !hasPrincess) {
 			tries++;

-			for (IHiveDrop drop : dropList) {
+			for (IHiveDrop drop : dropList)
 				if (world.rand.nextInt(100) < drop.getChance(world, x, y, z)) {
 					ret.add(drop.getPrincess(world, x, y, z, fortune));
 					hasPrincess = true;
 					break;
 				}
-			}
 		}

 		// Grab drones
-		for (IHiveDrop drop : dropList) {
+		for (IHiveDrop drop : dropList)
 			if (world.rand.nextInt(100) < drop.getChance(world, x, y, z)) {
 				ret.addAll(drop.getDrones(world, x, y, z, fortune));
 				break;
 			}
-		}
 		// Grab anything else on offer
-		for (IHiveDrop drop : dropList) {
+		for (IHiveDrop drop : dropList)
 			if (world.rand.nextInt(100) < drop.getChance(world, x, y, z)) {
 				ret.addAll(drop.getAdditional(world, x, y, z, fortune));
 				break;
 			}
-		}

 		return ret;
 	}
@@ -138,35 +123,7 @@ public class BlockBeehives extends BlockContainer {
 		return meta;
 	}

-	private static List<IHiveDrop> getDropsForHive(int meta) {
-		String hiveName = getHiveNameForMeta(meta);
-		if (hiveName == null) {
-			return Collections.emptyList();
-		}
-		return PluginApiculture.hiveRegistry.getDrops(hiveName);
-	}
-
-	private static String getHiveNameForMeta(int meta) {
-		switch (meta) {
-			case 1:
-				return HiveRegistry.forest;
-			case 2:
-				return HiveRegistry.meadows;
-			case 3:
-				return HiveRegistry.desert;
-			case 4:
-				return HiveRegistry.jungle;
-			case 5:
-				return HiveRegistry.end;
-			case 6:
-				return HiveRegistry.snow;
-			case 7:
-				return HiveRegistry.swamp;
-		}
-		return null;
-	}
-
-	@SuppressWarnings({"rawtypes", "unchecked"})
+	@SuppressWarnings({ "rawtypes", "unchecked" })
 	@Override
 	public void getSubBlocks(Item item, CreativeTabs par2CreativeTabs, List itemList) {
 		itemList.add(new ItemStack(this, 1, 1));
@@ -174,7 +131,7 @@ public class BlockBeehives extends BlockContainer {
 		itemList.add(new ItemStack(this, 1, 3));
 		itemList.add(new ItemStack(this, 1, 4));
 		if (Config.isDebug) {
-			itemList.add(new ItemStack(this, 1, 5));
+			itemList.add(new ItemStack(this, 1 ,5));
 		}
 		itemList.add(new ItemStack(this, 1, 6));
 		itemList.add(new ItemStack(this, 1, 7));
@@ -190,29 +147,26 @@ 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.registerTex(register, "beehives/beehive." + i + ".top");
-			icons[(i * 2) + 1] = TextureManager.registerTex(register, "beehives/beehive." + i + ".side");
+			icons[i * 2] = TextureManager.getInstance().registerTex(register, "beehives/beehive." + i + ".top");
+			icons[(i * 2) + 1] = TextureManager.getInstance().registerTex(register, "beehives/beehive." + i + ".side");
 		}
 	}

 	@Override
 	@SideOnly(Side.CLIENT)
 	public IIcon getIcon(int i, int j) {
-		if (j == 0 || j > 8) {
+		if (j == 0 || j >= 8)
 			return null;
-		}

 		if (i == 0 || i == 1) {
-			if (j * 2 < icons.length && icons[j * 2] != null) {
+			if (j * 2 < icons.length && icons[j * 2] != null)
 				return icons[j * 2];
-			} else {
+			else
 				return icons[2];
-			}
-		} else if (j * 2 + 1 < icons.length && icons[j * 2 + 1] != null) {
+		} else if (j * 2 + 1 < icons.length && icons[j * 2 + 1] != null)
 			return icons[j * 2 + 1];
-		} else {
+		else
 			return icons[3];
-		}
 	}

 }
@@ -0,0 +1,420 @@
+/*******************************************************************************
+ * 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 cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.oredict.OreDictionary;
+
+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 = this.unlitStump;
+		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));
+			}
+
+			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);
+		}
+	}
+
+}
@@ -4,11 +4,11 @@
 * 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;
+package forestry.apiculture.gadgets;

 import java.util.List;
 import java.util.Random;
@@ -27,12 +27,11 @@ 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.config.Constants;
+import forestry.core.config.Defaults;
+import forestry.core.config.ForestryBlock;
 import forestry.core.render.TextureManager;
-import forestry.core.utils.ItemStackUtil;
+import forestry.core.utils.StackUtils;
 import forestry.core.utils.StringUtil;
-import forestry.plugins.PluginApiculture;

 public class BlockStump extends BlockTorch {

@@ -46,10 +45,10 @@ public class BlockStump extends BlockTorch {
 	@SideOnly(Side.CLIENT)
 	@Override
 	public void registerBlockIcons(IIconRegister register) {
-		this.blockIcon = TextureManager.registerTex(register, StringUtil.cleanBlockName(this));
+		this.blockIcon = TextureManager.getInstance().registerTex(register, StringUtil.cleanBlockName(this));
 	}

-	@SuppressWarnings({"rawtypes", "unchecked"})
+	@SuppressWarnings({ "rawtypes", "unchecked" })
 	@Override
 	public void getSubBlocks(Item item, CreativeTabs par2CreativeTabs, List itemList) {
 		itemList.add(new ItemStack(this, 1, 0));
@@ -61,9 +60,9 @@ public class BlockStump extends BlockTorch {
 		ItemStack held = player.getCurrentEquippedItem();
 		if (held != null &&
 				(held.getItem() == Items.flint_and_steel ||
-						held.getItem() == Items.flint ||
-						ItemStackUtil.equals(Blocks.torch, held))) {
-			world.setBlock(x, y, z, PluginApiculture.blocks.candle, world.getBlockMetadata(x, y, z) | 0x08, Constants.FLAG_BLOCK_SYNCH);
+				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);
 			TileCandle tc = new TileCandle();
 			tc.setColour(0); // default to white
 			world.setTileEntity(x, y, z, tc);
@@ -0,0 +1,119 @@
+/*******************************************************************************
+ * 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.utils.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.stone_slab);
+		slabBlocks.add(Blocks.wooden_slab);
+		slabBlocks.add(ForestryBlock.slabs1.block());
+		slabBlocks.add(ForestryBlock.slabs2.block());
+		slabBlocks.add(ForestryBlock.slabs3.block());
+		if (ForestryBlock.slabs4 != null)
+			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;
+	}
+
+}
@@ -0,0 +1,262 @@
+/*******************************************************************************
+ * 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 buildcraft.api.statements.ITriggerExternal;
+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.core.config.Defaults;
+import forestry.core.config.ForestryBlock;
+import forestry.core.gadgets.TileForestry;
+import forestry.core.network.PacketPayload;
+import forestry.core.proxy.Proxies;
+import forestry.core.triggers.ForestryTrigger;
+import forestry.core.utils.TileInventoryAdapter;
+import forestry.core.utils.Utils;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+
+import java.util.LinkedList;
+
+public abstract class TileAlveary extends TileForestry implements IAlvearyComponent {
+
+	protected TileInventoryAdapter inventory;
+	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() {
+		if (!Proxies.common.isSimulating(worldObj))
+			updateClientSide();
+		else {
+			if (!isInited) {
+				initialize();
+				isInited = true;
+			}
+
+			// Periodic validation if needed
+			if (worldObj.getTotalWorldTime() % 200 == 0 && (!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) {
+		super.readFromNBT(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();
+
+		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 void fromPacketPayload(PacketPayload payload) {
+	}
+
+	@Override
+	public PacketPayload getPacketPayload() {
+		return null;
+	}
+
+	/* ITILESTRUCTURE */
+	IStructureLogic structureLogic;
+
+	private boolean isMaster;
+	protected int masterX, masterZ;
+	protected int masterY = -99;
+
+	@Override
+	public String getTypeUID() {
+		return structureLogic.getTypeUID();
+	}
+
+	@Override
+	public void validateStructure() {
+		structureLogic.validateStructure();
+	}
+
+	@Override
+	public void makeMaster() {
+		setCentralTE(null);
+		isMaster = true;
+
+		if (inventory == null)
+			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 IInventory getInventory() {
+		return inventory;
+	}
+
+	/* 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
+	@Override
+	public LinkedList<ITriggerExternal> getCustomTriggers() {
+		LinkedList<ITriggerExternal> res = new LinkedList<ITriggerExternal>();
+		res.add(ForestryTrigger.missingQueen);
+		res.add(ForestryTrigger.missingDrone);
+		return res;
+	}
+
+	@Override
+	public boolean isUseableByPlayer(EntityPlayer player) {
+		return Utils.isUseableByPlayer(player, this, worldObj, xCoord, yCoord, zCoord);
+	}
+
+}
@@ -0,0 +1,160 @@
+/*******************************************************************************
+ * 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 cofh.api.energy.IEnergyHandler;
+import forestry.api.apiculture.IAlvearyComponent;
+import forestry.core.network.PacketPayload;
+import forestry.energy.EnergyManager;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.ForgeDirection;
+
+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 EnergyManager energyManager;
+	ClimateControl climateControl;
+	private int transferTime = 0;
+	private int animationDelay = 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, 250, 2000);
+		energyManager.setReceiveOnly();
+		this.textureOff = textureOff;
+		this.textureOn = textureOn;
+	}
+
+	@Override
+	public void openGui(EntityPlayer player) {
+	}
+
+	/* UPDATING */
+	@Override
+	protected void updateServerSide() {
+		super.updateServerSide();
+
+		if (!this.hasMaster())
+			return;
+
+		if (energyManager.consumeEnergyToDoWork()) {
+
+			transferTime = energyManager.getEnergyPerWork();
+
+			if (animationDelay <= 0) {
+				animationDelay = 100;
+				sendNetworkUpdate();
+			} else
+				animationDelay = 100;
+		}
+
+		if (transferTime > 0) {
+			transferTime--;
+			IAlvearyComponent component = (IAlvearyComponent) this.getCentralTE();
+			if (component != null)
+				component.addTemperatureChange(climateControl.changePerTransfer, climateControl.boundaryDown, climateControl.boundaryUp);
+		}
+
+		if (animationDelay > 0) {
+			animationDelay--;
+			if (animationDelay <= 0)
+				sendNetworkUpdate();
+		}
+	}
+
+	@Override
+	public boolean hasFunction() {
+		return true;
+	}
+
+	/* TEXTURES */
+	@Override
+	public int getIcon(int side, int metadata) {
+		if (animationDelay > 0)
+			return textureOn;
+		else
+			return textureOff;
+	}
+
+	/* LOADING & SAVING */
+	@Override
+	public void readFromNBT(NBTTagCompound nbttagcompound) {
+		super.readFromNBT(nbttagcompound);
+		energyManager.readFromNBT(nbttagcompound);
+		transferTime = nbttagcompound.getInteger("Heating");
+	}
+
+	@Override
+	public void writeToNBT(NBTTagCompound nbttagcompound) {
+		super.writeToNBT(nbttagcompound);
+		energyManager.writeToNBT(nbttagcompound);
+		nbttagcompound.setInteger("Heating", transferTime);
+	}
+
+
+	/* NETWORK */
+	@Override
+	public void fromPacketPayload(PacketPayload payload) {
+		short delay = payload.shortPayload[0];
+		if (animationDelay != delay) {
+			animationDelay = delay;
+			worldObj.func_147479_m(xCoord, yCoord, zCoord);
+		}
+	}
+
+	@Override
+	public PacketPayload getPacketPayload() {
+		PacketPayload payload = new PacketPayload(0, 1);
+		payload.shortPayload[0] = (short) animationDelay;
+		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);
+	}
+}
@@ -1,19 +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.arboriculture.worldgen;
-
-import forestry.api.world.ITreeGenData;
-
-public abstract class WorldGenTreeVanilla extends WorldGenTree {
-	protected WorldGenTreeVanilla(ITreeGenData tree) {
-		super(tree, 5, 2);
-	}
-}
+/*******************************************************************************
+ * 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.TX_71_FNOF, BlockAlveary.TX_72_FNON, BLOCK_META);
+	}
+
+}
@@ -1,27 +1,25 @@
-/*******************************************************************************
- * 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.fluids;
-
-import forestry.core.fluids.tanks.StandardTank;
-
-public class FakeTankUpdateHandler implements ITankUpdateHandler {
-
-	public static final FakeTankUpdateHandler instance = new FakeTankUpdateHandler();
-
-	private FakeTankUpdateHandler() {
-
-	}
-
-	@Override
-	public void updateTankLevels(StandardTank tank) {
-
-	}
-}
+/*******************************************************************************
+ * 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 TileAlvearyHeater extends TileAlvearyClimatiser {
+
+	public static final int TEXTURE_OFF = 57;
+	public static final int TEXTURE_ON = 58;
+
+	/* CONSTANTS */
+	public static final int BLOCK_META = 4;
+
+	public TileAlvearyHeater() {
+		super(new ClimateControl(0.01f, 0.0f, 2.5f), BlockAlveary.TX_57_HTOF, BlockAlveary.TX_58_HTON, BLOCK_META);
+	}
+
+}
@@ -0,0 +1,328 @@
+/*******************************************************************************
+ * 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.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidContainerRegistry.FluidContainerData;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTankInfo;
+
+import forestry.api.apiculture.IAlvearyComponent;
+import forestry.api.core.ForestryAPI;
+import forestry.core.config.Defaults;
+import forestry.core.fluids.TankManager;
+import forestry.core.fluids.tanks.FilteredTank;
+import forestry.core.interfaces.ILiquidTankContainer;
+import forestry.core.network.GuiId;
+import forestry.core.proxy.Proxies;
+import forestry.core.utils.InventoryAdapter;
+import forestry.core.utils.LiquidHelper;
+import forestry.core.utils.StackUtils;
+
+public class TileAlvearyHygroregulator extends TileAlveary implements IInventory, ILiquidTankContainer {
+
+	/* CONSTANTS */
+	public static final int BLOCK_META = 5;
+
+	/* RECIPE MANAGMENT */
+	private static class HygroregulatorRecipe {
+		public final FluidStack liquid;
+		public final int transferTime;
+		public final float humidChange;
+		public final float tempChange;
+
+		public HygroregulatorRecipe(FluidStack liquid, int transferTime, float humidChange, float tempChange) {
+			this.liquid = liquid;
+			this.transferTime = transferTime;
+			this.humidChange = humidChange;
+			this.tempChange = tempChange;
+		}
+	}
+
+	private final HygroregulatorRecipe[] recipes;
+
+	/* MEMBERS */
+	InventoryAdapter canInventory = new InventoryAdapter(1, "CanInv");
+	private final TankManager tankManager;
+	private FilteredTank liquidTank;
+
+	private HygroregulatorRecipe currentRecipe;
+	private int transferTime;
+
+	public TileAlvearyHygroregulator() {
+		super(BLOCK_META);
+
+		Fluid water = LiquidHelper.getFluid(Defaults.LIQUID_WATER);
+		Fluid lava = LiquidHelper.getFluid(Defaults.LIQUID_LAVA);
+		Fluid liquidIce = LiquidHelper.getFluid(Defaults.LIQUID_ICE);
+
+		liquidTank = new FilteredTank(Defaults.PROCESSOR_TANK_CAPACITY, water, lava, liquidIce);
+		tankManager = new TankManager(liquidTank);
+
+		recipes = new HygroregulatorRecipe[] { new HygroregulatorRecipe(new FluidStack(water, 1), 1, 0.01f, -0.005f),
+				new HygroregulatorRecipe(new FluidStack(lava, 1), 10, -0.01f, +0.005f),
+				new HygroregulatorRecipe(new FluidStack(liquidIce, 1), 10, 0.02f, -0.01f) };
+	}
+
+	@Override
+	public void openGui(EntityPlayer player) {
+		player.openGui(ForestryAPI.instance, GuiId.HygroregulatorGUI.ordinal(), worldObj, xCoord, yCoord, zCoord);
+	}
+
+	@Override
+	public String getInventoryName() {
+		return getUnlocalizedName();
+	}
+
+	/* UPDATING */
+	private HygroregulatorRecipe getRecipe(FluidStack liquid) {
+		HygroregulatorRecipe recipe = null;
+		for (HygroregulatorRecipe rec : recipes)
+			if (rec.liquid.isFluidEqual(liquid)) {
+				recipe = rec;
+				break;
+			}
+		return recipe;
+	}
+
+	@Override
+	protected void updateServerSide() {
+		super.updateServerSide();
+
+		if (transferTime <= 0 && liquidTank.getFluidAmount() > 0) {
+			currentRecipe = getRecipe(liquidTank.getFluid());
+
+			if (currentRecipe != null) {
+				liquidTank.drain(currentRecipe.liquid.amount, true);
+				transferTime = currentRecipe.transferTime;
+			}
+		}
+
+		if (transferTime > 0) {
+
+			transferTime--;
+			if (currentRecipe != null) {
+				IAlvearyComponent component = (IAlvearyComponent) this.getCentralTE();
+				if (component != null) {
+					component.addHumidityChange(currentRecipe.humidChange, 0.0f, 1.0f);
+					component.addTemperatureChange(currentRecipe.tempChange, 0.0f, 2.0f);
+				}
+			} else
+				transferTime = 0;
+		}
+
+		if (worldObj.getTotalWorldTime() % 20 * 10 != 0)
+			return;
+
+		// Check if we have suitable items waiting in the item slot
+		if (canInventory.getStackInSlot(0) != null) {
+			FluidContainerData container = LiquidHelper.getLiquidContainer(canInventory.getStackInSlot(0));
+			if (container != null &&
+					(container.fluid.getFluid() == FluidRegistry.WATER || container.fluid.getFluid() == FluidRegistry.LAVA)) {
+
+				canInventory.setInventorySlotContents(0, StackUtils.replenishByContainer(this, canInventory.getStackInSlot(0), container, liquidTank));
+				if (canInventory.getStackInSlot(0).stackSize <= 0)
+					canInventory.setInventorySlotContents(0, null);
+			}
+		}
+
+	}
+
+	@Override
+	public boolean hasFunction() {
+		return true;
+	}
+
+	/* SAVING & LOADING */
+	@Override
+	public void readFromNBT(NBTTagCompound nbttagcompound) {
+		super.readFromNBT(nbttagcompound);
+
+		canInventory.readFromNBT(nbttagcompound);
+
+		tankManager.readTanksFromNBT(nbttagcompound);
+
+		transferTime = nbttagcompound.getInteger("TransferTime");
+
+		if (nbttagcompound.hasKey("CurrentLiquid")) {
+			FluidStack liquid = FluidStack.loadFluidStackFromNBT(nbttagcompound.getCompoundTag("CurrentLiquid"));
+			currentRecipe = getRecipe(liquid);
+		}
+	}
+
+	@Override
+	public void writeToNBT(NBTTagCompound nbttagcompound) {
+		super.writeToNBT(nbttagcompound);
+
+		canInventory.writeToNBT(nbttagcompound);
+
+		tankManager.writeTanksToNBT(nbttagcompound);
+
+		nbttagcompound.setInteger("TransferTime", transferTime);
+		if (currentRecipe != null) {
+			NBTTagCompound subcompound = new NBTTagCompound();
+			currentRecipe.liquid.writeToNBT(subcompound);
+			nbttagcompound.setTag("CurrentLiquid", subcompound);
+		}
+
+	}
+
+	/* TEXTURES */
+	@Override
+	public int getIcon(int side, int metadata) {
+		return BlockAlveary.TX_73_VLVE;
+	}
+
+	@Override
+	public IInventory getInventory() {
+		return canInventory;
+	}
+
+	/* IINVENTORY */
+	@Override
+	public int getSizeInventory() {
+		if (canInventory != null)
+			return canInventory.getSizeInventory();
+		else
+			return 0;
+	}
+
+	@Override
+	public ItemStack getStackInSlot(int slotIndex) {
+		if (canInventory != null)
+			return canInventory.getStackInSlot(slotIndex);
+		else
+			return null;
+	}
+
+	@Override
+	public ItemStack decrStackSize(int slotIndex, int amount) {
+		if (canInventory != null)
+			return canInventory.decrStackSize(slotIndex, amount);
+		else
+			return null;
+	}
+
+	@Override
+	public ItemStack getStackInSlotOnClosing(int slotIndex) {
+		if (canInventory != null)
+			return canInventory.getStackInSlotOnClosing(slotIndex);
+		else
+			return null;
+	}
+
+	@Override
+	public void setInventorySlotContents(int slotIndex, ItemStack itemstack) {
+		// Client side handling for container synch
+		if (canInventory == null && !Proxies.common.isSimulating(worldObj))
+			createInventory();
+
+		if (canInventory != null)
+			canInventory.setInventorySlotContents(slotIndex, itemstack);
+	}
+
+	@Override
+	public int getInventoryStackLimit() {
+		if (canInventory != null)
+			return canInventory.getInventoryStackLimit();
+		else
+			return 0;
+	}
+
+	@Override
+	public void openInventory() {
+	}
+
+	@Override
+	public void closeInventory() {
+	}
+
+	/**
+	 * TODO: just a specialsource workaround
+	 */
+	@Override
+	public boolean isUseableByPlayer(EntityPlayer player) {
+		return super.isUseableByPlayer(player);
+	}
+
+	/**
+	 * TODO: just a specialsource workaround
+	 */
+	@Override
+	public boolean hasCustomInventoryName() {
+		return super.hasCustomInventoryName();
+	}
+
+	/**
+	 * TODO: just a specialsource workaround
+	 */
+	@Override
+	public boolean isItemValidForSlot(int slotIndex, ItemStack itemstack) {
+		if (slotIndex == 0) {
+			FluidStack fluid = LiquidHelper.getFluidStackInContainer(itemstack);
+			if (fluid == null || fluid.amount <= 0)
+				return false;
+			return liquidTank.accepts(fluid.getFluid());
+		}
+
+		return super.isItemValidForSlot(slotIndex, itemstack);
+	}
+
+	/* ILIQUIDTANKCONTAINER */
+	@Override
+	public TankManager getTankManager() {
+		return tankManager;
+	}
+
+	@Override
+	public int fill(ForgeDirection from, FluidStack resource, boolean doFill) {
+		return tankManager.fill(from, resource, doFill);
+	}
+
+	public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) {
+		return tankManager.drain(from, resource, doDrain);
+	}
+
+	@Override
+	public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) {
+		return tankManager.drain(from, maxDrain, doDrain);
+	}
+
+	@Override
+	public boolean canFill(ForgeDirection from, Fluid fluid) {
+		return tankManager.canFill(from, fluid);
+	}
+
+	@Override
+	public boolean canDrain(ForgeDirection from, Fluid fluid) {
+		return tankManager.canDrain(from, fluid);
+	}
+
+	@Override
+	public FluidTankInfo[] getTankInfo(ForgeDirection from) {
+		return tankManager.getTankInfo(from);
+	}
+
+	@Override
+	public void getGUINetworkData(int messageId, int data) {}
+
+	@Override
+	public void sendGUINetworkData(Container container, ICrafting iCrafting) {}
+}
@@ -0,0 +1,845 @@
+/*******************************************************************************
+ * 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 com.mojang.authlib.GameProfile;
+
+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 net.minecraftforge.common.util.ForgeDirection;
+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.*;
+import forestry.api.genetics.IIndividual;
+import forestry.apiculture.gui.ContainerAlveary;
+import forestry.core.EnumErrorCode;
+import forestry.core.config.Config;
+import forestry.core.config.ForestryItem;
+import forestry.core.interfaces.IClimatised;
+import forestry.core.interfaces.IErrorSource;
+import forestry.core.interfaces.IHintSource;
+import forestry.core.network.GuiId;
+import forestry.core.network.PacketIds;
+import forestry.core.network.PacketInventoryStack;
+import forestry.core.proxy.Proxies;
+import forestry.core.utils.InventoryAdapter;
+import forestry.core.utils.TileInventoryAdapter;
+import forestry.plugins.PluginApiculture;
+
+public class TileAlvearyPlain extends TileAlveary implements ISidedInventory, ISpecialInventory, 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 int biomeId;
+	protected float temperature;
+	protected float humidity;
+	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);
+	}
+
+	/* LOADING & SAVING */
+	@Override
+	public void readFromNBT(NBTTagCompound nbttagcompound) {
+		super.readFromNBT(nbttagcompound);
+
+		this.tempChange = nbttagcompound.getFloat("TempChange");
+		this.humidChange = nbttagcompound.getFloat("HumidChange");
+
+		if (inventory != null)
+			inventory.readFromNBT(nbttagcompound);
+		if (beekeepingLogic != null)
+			beekeepingLogic.readFromNBT(nbttagcompound);
+
+	}
+
+	@Override
+	public void writeToNBT(NBTTagCompound nbttagcompound) {
+		super.writeToNBT(nbttagcompound);
+
+		nbttagcompound.setFloat("TempChange", tempChange);
+		nbttagcompound.setFloat("HumidChange", humidChange);
+
+		if (inventory != null)
+			inventory.writeToNBT(nbttagcompound);
+		if (beekeepingLogic != null)
+			beekeepingLogic.writeToNBT(nbttagcompound);
+
+	}
+
+	/* UPDATING */
+	@Override
+	public void initialize() {
+		super.initialize();
+		BiomeGenBase biome = worldObj.getBiomeGenForCoordsBody(xCoord, zCoord);
+		this.biomeId = biome.biomeID;
+		this.temperature = biome.temperature;
+		this.humidity = biome.rainfall;
+		setErrorState(EnumErrorCode.OK);
+	}
+
+	@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 (worldObj.getTotalWorldTime() % 200 * 10 == 0)
+			onQueenChange(inventory.getStackInSlot(SLOT_QUEEN));
+		if (getErrorState() == EnumErrorCode.OK)
+			queen.doFX(beekeepingLogic.getEffectData(), this);
+
+		if (getErrorState() == EnumErrorCode.OK && worldObj.getTotalWorldTime() % 50 == 0) {
+			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;
+
+		if (inventory == null)
+			return;
+
+		// / Multiplayer FX
+		if (PluginApiculture.beeInterface.isMated(inventory.getStackInSlot(SLOT_QUEEN)))
+			if (getErrorState() == EnumErrorCode.OK && worldObj.getTotalWorldTime() % 2 == 0) {
+				IBee displayQueen = PluginApiculture.beeInterface.getMember(inventory.getStackInSlot(SLOT_QUEEN));
+				displayQueen.doFX(beekeepingLogic.getEffectData(), this);
+			}
+		return;
+
+	}
+
+	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() {
+		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() {
+		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();
+	}
+
+	@Override
+	public boolean allowsInteraction(EntityPlayer player) {
+		if (!super.allowsInteraction(player))
+			return false;
+
+		return this.isIntegratedIntoStructure();
+	}
+
+	/* STRUCTURE MANAGMENT */
+	@Override
+	protected void createInventory() {
+		this.inventory = new TileInventoryAdapter(this, 9, "Items");
+	}
+
+	@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) {
+		tempChange = Math.min(boundaryUp - temperature, Math.max(boundaryDown - temperature, tempChange + change));
+	}
+
+	@Override
+	public void addHumidityChange(float change, float boundaryDown, float boundaryUp) {
+		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 this.biomeId;
+	}
+
+	@Override
+	public EnumTemperature getTemperature() {
+		if (EnumTemperature.isBiomeHellish(biomeId) && 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().ordinal();
+	}
+
+	@Override
+	public boolean canBreed() {
+		return true;
+	}
+
+	@Override
+	public boolean addProduct(ItemStack product, boolean all) {
+		if (inventory == null)
+			return false;
+
+		return inventory.tryAddStack(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 InventoryAdapter getInternalInventory() {
+		return (InventoryAdapter) getStructureInventory();
+	}
+
+	private IInventory getStructureInventory() {
+
+		if (inventory != null) {
+			if (isMaster() || !Proxies.common.isSimulating(worldObj))
+				return inventory;
+		} else if (hasMaster()) {
+			ITileStructure central = getCentralTE();
+			if (central != null)
+				return central.getInventory();
+		}
+
+		return null;
+	}
+
+	@Override
+	public int getSizeInventory() {
+		IInventory inv = getStructureInventory();
+		if (inv != null)
+			return inv.getSizeInventory();
+		else
+			return 0;
+	}
+
+	@Override
+	public ItemStack getStackInSlot(int slotIndex) {
+		IInventory inv = getStructureInventory();
+		if (inv != null)
+			return inv.getStackInSlot(slotIndex);
+		else
+			return null;
+	}
+
+	@Override
+	public ItemStack decrStackSize(int slotIndex, int amount) {
+		IInventory inv = getStructureInventory();
+		if (inv != null)
+			return inv.decrStackSize(slotIndex, amount);
+		else
+			return null;
+	}
+
+	@Override
+	public ItemStack getStackInSlotOnClosing(int slotIndex) {
+		IInventory inv = getStructureInventory();
+		if (inv != null)
+			return inv.getStackInSlotOnClosing(slotIndex);
+		else
+			return null;
+	}
+
+	@Override
+	public void setInventorySlotContents(int slotIndex, ItemStack itemstack) {
+		// Client side handling for container synch
+		if (inventory == null && !Proxies.common.isSimulating(worldObj))
+			createInventory();
+
+		IInventory inv = getStructureInventory();
+		if (inv != null)
+			inv.setInventorySlotContents(slotIndex, itemstack);
+	}
+
+	@Override
+	public String getInventoryName() {
+		return getUnlocalizedName();
+	}
+
+	@Override
+	public int getInventoryStackLimit() {
+		IInventory inv = getStructureInventory();
+		if (inv != null)
+			return inv.getInventoryStackLimit();
+		else
+			return 0;
+	}
+
+	@Override
+	protected boolean canTakeStackFromSide(int slotIndex, ItemStack itemstack, int side) {
+
+		if (!super.canTakeStackFromSide(slotIndex, itemstack, side))
+			return false;
+
+		if (slotIndex != SLOT_QUEEN && slotIndex != SLOT_DRONE)
+			return true;
+
+		return false;
+	}
+
+	@Override
+	protected boolean canPutStackFromSide(int slotIndex, ItemStack itemstack, int side) {
+
+		if (!super.canPutStackFromSide(slotIndex, itemstack, side))
+			return false;
+
+		if (slotIndex == SLOT_QUEEN && PluginApiculture.beeInterface.isMember(itemstack)
+				&& !PluginApiculture.beeInterface.isDrone(itemstack))
+			return true;
+		if (slotIndex == SLOT_DRONE && PluginApiculture.beeInterface.isDrone(itemstack))
+			return true;
+
+		return false;
+	}
+
+	@Override
+	public void openInventory() {
+	}
+
+	@Override
+	public void closeInventory() {
+	}
+
+	/**
+	 * TODO: just a specialsource workaround
+	 */
+	@Override
+	public boolean isUseableByPlayer(EntityPlayer player) {
+		return super.isUseableByPlayer(player);
+	}
+
+	/**
+	 * TODO: just a specialsource workaround
+	 */
+	@Override
+	public boolean hasCustomInventoryName() {
+		return super.hasCustomInventoryName();
+	}
+
+	/**
+	 * TODO: just a specialsource workaround
+	 */
+	@Override
+	public boolean isItemValidForSlot(int slotIndex, ItemStack itemstack) {
+		return super.isItemValidForSlot(slotIndex, itemstack);
+	}
+
+	/**
+	 * TODO: just a specialsource workaround
+	 */
+	@Override
+	public boolean canInsertItem(int i, ItemStack itemstack, int j) {
+		return super.canInsertItem(i, itemstack, j);
+	}
+
+	/**
+	 * TODO: just a specialsource workaround
+	 */
+	@Override
+	public boolean canExtractItem(int i, ItemStack itemstack, int j) {
+		return super.canExtractItem(i, itemstack, j);
+	}
+
+	/**
+	 * TODO: just a specialsource workaround
+	 */
+	@Override
+	public int[] getAccessibleSlotsFromSide(int side) {
+		return super.getAccessibleSlotsFromSide(side);
+	}
+
+	/* ISPECIALINVENTORY */
+	@Override
+	public int addItem(ItemStack stack, boolean doAdd, ForgeDirection from) {
+
+		IInventory inv = getStructureInventory();
+		if (inv == null)
+			return 0;
+
+		// Princesses && Queens
+		if (ForestryItem.beePrincessGE.isItemEqual(stack) || ForestryItem.beeQueenGE.isItemEqual(stack))
+			if (inv.getStackInSlot(SLOT_QUEEN) == null) {
+				if (doAdd) {
+					inv.setInventorySlotContents(SLOT_QUEEN, stack.copy());
+					inv.getStackInSlot(SLOT_QUEEN).stackSize = 1;
+				}
+				return 1;
+			}
+
+		// Drones
+		if (ForestryItem.beeDroneGE.isItemEqual(stack)) {
+
+			ItemStack droneStack = inv.getStackInSlot(SLOT_DRONE);
+			if (droneStack == null) {
+				if (doAdd)
+					inv.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;
+	}
+
+	@Override
+	public ItemStack[] extractItem(boolean doRemove, ForgeDirection from, int maxItemCount) {
+
+		IInventory inv = getStructureInventory();
+		if (inv == null)
+			return new ItemStack[0];
+
+		ItemStack product = null;
+
+		for (int i = SLOT_PRODUCT_1; i < inv.getSizeInventory(); i++) {
+			if (inv.getStackInSlot(i) == null)
+				continue;
+
+			ItemStack stack = inv.getStackInSlot(i);
+
+			if (doRemove)
+				product = inv.decrStackSize(i, 1);
+			else {
+				product = stack.copy();
+				product.stackSize = 1;
+			}
+			break;
+		}
+
+		return new ItemStack[] { product };
+	}
+
+	/* SMP GUI */
+	public void getGUINetworkData(int i, int j) {
+		switch (i) {
+		case 0:
+			displayHealth = j;
+			break;
+		case 1:
+			displayHealthMax = j;
+			break;
+		case 2:
+			this.temperature = (float) j / 100;
+			break;
+		case 3:
+			this.humidity = (float) j / 100;
+			break;
+		case 4:
+			this.tempChange = (float) j / 100;
+			break;
+		case 5:
+			this.humidChange = (float) j / 100;
+			break;
+		case 6:
+			this.biomeId = 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, 2, Math.round(temperature * 100));
+		iCrafting.sendProgressBarUpdate(container, 3, Math.round(humidity * 100));
+		iCrafting.sendProgressBarUpdate(container, 4, Math.round(tempChange * 100));
+		iCrafting.sendProgressBarUpdate(container, 5, Math.round(humidChange * 100));
+		iCrafting.sendProgressBarUpdate(container, 6, biomeId);
+	}
+
+	/* IERRORSOURCE */
+	@Override
+	public EnumErrorCode 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 this.temperature + this.tempChange;
+	}
+
+	@Override
+	public float getExactHumidity() {
+		return this.humidity + 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();
+	}
+}
@@ -0,0 +1,178 @@
+/*******************************************************************************
+ * 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 net.minecraft.nbt.NBTTagCompound;
+
+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.interfaces.ICrafter;
+import forestry.core.network.GuiId;
+import forestry.core.utils.InventoryAdapter;
+
+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;
+	
+	InventoryAdapter inventory = new InventoryAdapter(5, "Items", 1);
+
+	public TileAlvearySieve() {
+		super(BLOCK_META);
+	}
+
+	@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())
+			return;
+		
+		((IAlvearyComponent)getCentralTE()).registerBeeListener(this);
+	}
+	
+	
+	@Override
+	protected void updateServerSide() {
+		super.updateServerSide();
+		if(worldObj.getTotalWorldTime() % 200 != 0)
+			return;
+		
+		if(!hasMaster() || !isIntegratedIntoStructure())
+			return;
+		
+		((IAlvearyComponent)getCentralTE()).registerBeeListener(this);
+	}
+	
+	/* SAVING & LOADING */
+	@Override
+	public void readFromNBT(NBTTagCompound nbttagcompound) {
+		super.readFromNBT(nbttagcompound);
+		inventory.readFromNBT(nbttagcompound);
+	}
+	
+	@Override
+	public void writeToNBT(NBTTagCompound nbttagcompound) {
+		super.writeToNBT(nbttagcompound);
+		inventory.writeToNBT(nbttagcompound);
+	}
+	
+	/* TEXTURES & INTERNAL */
+	@Override
+	public int getIcon(int side, int metadata) {
+		if(side == 0 || side == 1)
+			return BlockAlveary.BOTTOM;
+		return BlockAlveary.SIEVE;
+	}
+
+	private void destroySieve() {
+		inventory.setInventorySlotContents(SLOT_SIEVE, null);
+	}
+	private void destroyPollen() {
+		for(int i = SLOT_POLLEN_1; i < SLOT_POLLEN_1 + SLOTS_POLLEN_COUNT; i++) {
+			inventory.setInventorySlotContents(i, null);
+		}
+	}
+	
+	private boolean canStorePollen() {
+		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) {
+		for(int i = SLOT_POLLEN_1; i < SLOT_POLLEN_1 + SLOTS_POLLEN_COUNT; i++) {
+			if(inventory.getStackInSlot(i) == null) {
+				inventory.setInventorySlotContents(i, itemstack);
+				return;
+			}
+		}
+	}
+	
+	/* INVENTORY */
+	public InventoryAdapter getInternalInventory() {
+		return inventory;
+	}
+
+	/* ICRAFTER */
+	@Override
+	public boolean canTakeStack(int slotIndex) {
+		return true;
+	}
+
+	@Override
+	public ItemStack takenFromSlot(int slotIndex, boolean consumeRecipe, EntityPlayer player) {
+		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 isHandled;
+		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;
+	}
+}
@@ -0,0 +1,114 @@
+/*******************************************************************************
+ * 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;
+
+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())
+			return;
+		
+		((IAlvearyComponent)getCentralTE()).registerBeeModifier(this);
+
+	}
+	
+	@Override
+	protected void updateServerSide() {
+		super.updateServerSide();
+		if(worldObj.getTotalWorldTime() % 200 != 0)
+			return;
+		
+		if(!hasMaster() || !isIntegratedIntoStructure())
+			return;
+		
+		((IAlvearyComponent)getCentralTE()).registerBeeModifier(this);
+	}
+	
+
+	@Override
+	public boolean hasFunction() {
+		return true;
+	}
+
+	/* TEXTURES */
+	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;
+	}
+
+}
@@ -0,0 +1,307 @@
+/*******************************************************************************
+ * 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.Map.Entry;
+import java.util.Stack;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+import forestry.api.apiculture.BeeManager;
+import forestry.api.apiculture.EnumBeeType;
+import forestry.api.apiculture.IAlvearyComponent;
+import forestry.api.apiculture.IBee;
+import forestry.api.apiculture.IBeeHousing;
+import forestry.api.core.ForestryAPI;
+import forestry.api.core.ISpecialInventory;
+import forestry.apiculture.worldgen.WorldGenHive;
+import forestry.apiculture.worldgen.WorldGenHiveSwamer;
+import forestry.core.network.GuiId;
+import forestry.core.proxy.Proxies;
+import forestry.core.utils.TileInventoryAdapter;
+import forestry.plugins.PluginApiculture;
+
+public class TileAlvearySwarmer extends TileAlveary implements ISpecialInventory {
+
+	/* CONSTANTS */
+	public static final int BLOCK_META = 2;
+
+	TileInventoryAdapter swarmerInventory;
+	private final Stack<ItemStack> pendingSpawns = new Stack<ItemStack>();
+
+	public TileAlvearySwarmer() {
+		super(BLOCK_META);
+	}
+
+	@Override
+	public void initialize() {
+		super.initialize();
+		if (swarmerInventory == null)
+			createInventory();
+	}
+
+	@Override
+	public void openGui(EntityPlayer player) {
+		player.openGui(ForestryAPI.instance, GuiId.AlvearySwarmerGUI.ordinal(), worldObj, xCoord, yCoord, zCoord);
+	}
+
+	/* UPDATING */
+	@Override
+	protected void updateServerSide() {
+		super.updateServerSide();
+
+		if (worldObj.getTotalWorldTime() % 100 != 0)
+			if (pendingSpawns.size() > 0)
+				trySpawnSwarm();
+
+		if (worldObj.getTotalWorldTime() % 500 != 0)
+			return;
+
+		if (!this.hasMaster())
+			return;
+
+		IAlvearyComponent master = (IAlvearyComponent) this.getCentralTE();
+		if (!(master instanceof IBeeHousing))
+			return;
+
+		IBeeHousing housing = (IBeeHousing) master;
+		ItemStack queenstack = housing.getQueen();
+		if (queenstack == null)
+			return;
+		if (!PluginApiculture.beeInterface.isMated(queenstack))
+			return;
+
+		// Calculate chance
+		int slot = getInducerSlot();
+		if (slot < 0)
+			return;
+		int chance = getChanceFor(swarmerInventory.getStackInSlot(slot));
+
+		// Remove resource
+		swarmerInventory.decrStackSize(slot, 1);
+
+		// Try to spawn princess
+		if (worldObj.rand.nextInt(1000) >= chance)
+			return;
+
+		// Queue swarm spawn
+		IBee spawn = PluginApiculture.beeInterface.getMember(queenstack);
+		spawn.setIsNatural(false);
+		pendingSpawns.push(PluginApiculture.beeInterface.getMemberStack(spawn, EnumBeeType.PRINCESS.ordinal()));
+
+	}
+
+	private int getChanceFor(ItemStack stack) {
+		for (Entry<ItemStack, Integer> entry : BeeManager.inducers.entrySet()) {
+			if (entry.getKey().isItemEqual(stack))
+				return entry.getValue();
+		}
+
+		return 0;
+	}
+
+	private int getInducerSlot() {
+		for (int i = 0; i < swarmerInventory.getSizeInventory(); i++) {
+			if (swarmerInventory.getStackInSlot(i) == null)
+				continue;
+			for (Entry<ItemStack, Integer> entry : BeeManager.inducers.entrySet()) {
+				if (entry.getKey().isItemEqual(swarmerInventory.getStackInSlot(i)))
+					return i;
+			}
+		}
+
+		return -1;
+	}
+
+	private void trySpawnSwarm() {
+
+		ItemStack toSpawn = pendingSpawns.peek();
+		WorldGenHive generator = new WorldGenHiveSwamer(new ItemStack[] { toSpawn });
+
+		int i = 0;
+		while (i < 10) {
+			i++;
+			int spawnX = xCoord + worldObj.rand.nextInt(40 * 2) - 40;
+			int spawnY = yCoord + worldObj.rand.nextInt(40);
+			int spawnZ = zCoord + worldObj.rand.nextInt(40 * 2) - 40;
+			if (generator.generate(worldObj, worldObj.rand, spawnX, spawnY, spawnZ)) {
+				pendingSpawns.pop();
+				break;
+			}
+		}
+
+	}
+
+	@Override
+	public boolean hasFunction() {
+		return true;
+	}
+
+	/* TEXTURES */
+	@Override
+	public int getIcon(int side, int metadata) {
+		if(side == 0 || side == 1)
+			return BlockAlveary.BOTTOM;
+
+		if (pendingSpawns.size() > 0)
+			return BlockAlveary.TX_56_SWON;
+		else
+			return BlockAlveary.TX_55_SWOF;
+	}
+
+	/* SAVING & LOADING */
+	@Override
+	public void readFromNBT(NBTTagCompound nbttagcompound) {
+		super.readFromNBT(nbttagcompound);
+		if (swarmerInventory == null)
+			createInventory();
+		swarmerInventory.readFromNBT(nbttagcompound);
+
+		NBTTagList nbttaglist = nbttagcompound.getTagList("PendingSpawns", 10);
+		for (int i = 0; i < nbttaglist.tagCount(); i++) {
+			NBTTagCompound nbttagcompound1 = nbttaglist.getCompoundTagAt(i);
+			pendingSpawns.add(ItemStack.loadItemStackFromNBT(nbttagcompound1));
+		}
+
+	}
+
+	@Override
+	public void writeToNBT(NBTTagCompound nbttagcompound) {
+		super.writeToNBT(nbttagcompound);
+		if (swarmerInventory != null)
+			swarmerInventory.writeToNBT(nbttagcompound);
+
+		NBTTagList nbttaglist = new NBTTagList();
+		ItemStack[] offspring = pendingSpawns.toArray(new ItemStack[pendingSpawns.size()]);
+		for (int i = 0; i < offspring.length; i++)
+			if (offspring[i] != null) {
+				NBTTagCompound nbttagcompound1 = new NBTTagCompound();
+				nbttagcompound1.setByte("Slot", (byte) i);
+				offspring[i].writeToNBT(nbttagcompound1);
+				nbttaglist.appendTag(nbttagcompound1);
+			}
+		nbttagcompound.setTag("PendingSpawns", nbttaglist);
+
+	}
+
+	@Override
+	protected void createInventory() {
+		swarmerInventory = new TileInventoryAdapter(this, 4, "SwarmInv");
+	}
+
+	@Override
+	public IInventory getInventory() {
+		return swarmerInventory;
+	}
+
+	/* ISPECIALINVENTORY */
+	@Override
+	public int addItem(ItemStack stack, boolean doAdd, ForgeDirection from) {
+		if (swarmerInventory != null)
+			return swarmerInventory.addStack(stack, false, doAdd);
+		else
+			return 0;
+	}
+
+	@Override
+	public ItemStack[] extractItem(boolean doRemove, ForgeDirection from, int maxItemCount) {
+		return null;
+	}
+
+	/* IINVENTORY */
+	@Override
+	public int getSizeInventory() {
+		if (swarmerInventory != null)
+			return swarmerInventory.getSizeInventory();
+		else
+			return 0;
+	}
+
+	@Override
+	public ItemStack getStackInSlot(int slotIndex) {
+		if (swarmerInventory != null)
+			return swarmerInventory.getStackInSlot(slotIndex);
+		else
+			return null;
+	}
+
+	@Override
+	public ItemStack decrStackSize(int slotIndex, int amount) {
+		if (swarmerInventory != null)
+			return swarmerInventory.decrStackSize(slotIndex, amount);
+		else
+			return null;
+	}
+
+	@Override
+	public ItemStack getStackInSlotOnClosing(int slotIndex) {
+		if (swarmerInventory != null)
+			return swarmerInventory.getStackInSlotOnClosing(slotIndex);
+		else
+			return null;
+	}
+
+	@Override
+	public void setInventorySlotContents(int slotIndex, ItemStack itemstack) {
+		// Client side handling for container synch
+		if (swarmerInventory == null && !Proxies.common.isSimulating(worldObj))
+			createInventory();
+
+		if (swarmerInventory != null)
+			swarmerInventory.setInventorySlotContents(slotIndex, itemstack);
+	}
+
+	@Override
+	public String getInventoryName() {
+		return getUnlocalizedName();
+	}
+
+	@Override
+	public int getInventoryStackLimit() {
+		if (swarmerInventory != null)
+			return swarmerInventory.getInventoryStackLimit();
+		else
+			return 0;
+	}
+
+	@Override public void openInventory() {}
+	@Override public void closeInventory() {}
+
+	/**
+	 * TODO: just a specialsource workaround
+	 */
+	@Override
+	public boolean isUseableByPlayer(EntityPlayer player) {
+		return super.isUseableByPlayer(player);
+	}
+
+	/**
+	 * TODO: just a specialsource workaround
+	 */
+	@Override
+	public boolean hasCustomInventoryName() {
+		return super.hasCustomInventoryName();
+	}
+
+	/**
+	 * TODO: just a specialsource workaround
+	 */
+	@Override
+	public boolean isItemValidForSlot(int slotIndex, ItemStack itemstack) {
+		return super.isItemValidForSlot(slotIndex, itemstack);
+	}
+}
@@ -4,27 +4,21 @@
 * 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.recipes.nei;
-
-import net.minecraft.item.ItemStack;
+package forestry.apiculture.gadgets;

 import forestry.api.genetics.AlleleManager;
+import forestry.apiculture.genetics.BeeHelper;
+import forestry.core.gadgets.TileNaturalistChest;
+import forestry.core.network.GuiId;

-/**
- * @author bdew
- */
-public class ItemFilterOther extends ItemFilterForestry {
+public class TileApiaristChest extends TileNaturalistChest {

-	public ItemFilterOther(Boolean items) {
-		super(items);
+	public TileApiaristChest() {
+		super(AlleleManager.alleleRegistry.getSpeciesRoot(BeeHelper.UID), GuiId.ApiaristChestGUI.ordinal());
 	}

-	@Override
-	public boolean matches(ItemStack item) {
-		return super.matches(item) && !AlleleManager.alleleRegistry.isIndividual(item);
-	}
 }
@@ -0,0 +1,353 @@
+/*******************************************************************************
+ * 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 buildcraft.api.statements.ITriggerExternal;
+import forestry.api.apiculture.IBeeGenome;
+import forestry.api.apiculture.IHiveFrame;
+import forestry.api.core.ForestryAPI;
+import forestry.core.gadgets.TileBase;
+import forestry.core.network.GuiId;
+import forestry.core.triggers.ForestryTrigger;
+import forestry.plugins.PluginApiculture;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.ISidedInventory;
+import net.minecraft.item.ItemStack;
+
+import java.util.LinkedList;
+
+public class TileApiary extends TileBeehouse implements ISidedInventory {
+
+	@Override
+	public String getInventoryName() {
+		return getUnlocalizedName();
+	}
+
+	@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) {
+		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) {
+		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) {
+		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) {
+		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) {
+		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) {
+		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) {
+		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));
+		}
+	}
+
+	/* IINVENTORY */
+	@Override
+	protected boolean canTakeStackFromSide(int slotIndex, ItemStack itemstack, int side) {
+		if (!super.canTakeStackFromSide(slotIndex, itemstack, side))
+			return false;
+
+		switch (slotIndex) {
+		case SLOT_QUEEN:
+		case SLOT_DRONE:
+		case SLOT_FRAMES_1:
+		case SLOT_FRAMES_2:
+		case SLOT_FRAMES_3:
+			return false;
+		default:
+			return true;
+		}
+	}
+
+	@Override
+	protected boolean canPutStackFromSide(int slotIndex, ItemStack itemstack, int side) {
+		if (!super.canPutStackFromSide(slotIndex, itemstack, side))
+			return false;
+
+		if (slotIndex == SLOT_QUEEN && PluginApiculture.beeInterface.isMember(itemstack)
+				&& !PluginApiculture.beeInterface.isDrone(itemstack))
+			return true;
+
+		if (slotIndex == SLOT_DRONE && PluginApiculture.beeInterface.isDrone(itemstack))
+			return true;
+
+		return false;
+	}
+
+	/**
+	 * TODO: just a specialsource workaround
+	 */
+	@Override
+	public ItemStack getStackInSlot(int i) {
+		return super.getStackInSlot(i);
+	}
+
+	@Override
+	public void setInventorySlotContents(int i, ItemStack itemstack) {
+		super.setSlotContents(i, itemstack);
+	}
+
+	@Override
+	public int getSizeInventory() {
+		return inventory.getSizeInventory();
+	}
+
+	@Override
+	public ItemStack decrStackSize(int i, int j) {
+		return inventory.decrStackSize(i, j);
+	}
+
+	@Override
+	public ItemStack getStackInSlotOnClosing(int slot) {
+		return inventory.getStackInSlotOnClosing(slot);
+	}
+
+	@Override
+	public int getInventoryStackLimit() {
+		return inventory.getInventoryStackLimit();
+	}
+
+	@Override
+	public void openInventory() {
+	}
+
+	@Override
+	public void closeInventory() {
+	}
+
+	/**
+	 * TODO: just a specialsource workaround
+	 */
+	@Override
+	public boolean isUseableByPlayer(EntityPlayer player) {
+		return super.isUseableByPlayer(player);
+	}
+
+	/**
+	 * TODO: just a specialsource workaround
+	 */
+	@Override
+	public boolean hasCustomInventoryName() {
+		return super.hasCustomInventoryName();
+	}
+
+	/**
+	 * TODO: just a specialsource workaround
+	 */
+	@Override
+	public boolean isItemValidForSlot(int slotIndex, ItemStack itemstack) {
+		return super.isItemValidForSlot(slotIndex, itemstack);
+	}
+
+	/**
+	 * TODO: just a specialsource workaround
+	 */
+	@Override
+	public boolean canInsertItem(int i, ItemStack itemstack, int j) {
+		return super.canInsertItem(i, itemstack, j);
+	}
+
+	/**
+	 * TODO: just a specialsource workaround
+	 */
+	@Override
+	public boolean canExtractItem(int i, ItemStack itemstack, int j) {
+		return super.canExtractItem(i, itemstack, j);
+	}
+
+	/**
+	 * TODO: just a specialsource workaround
+	 */
+	@Override
+	public int[] getAccessibleSlotsFromSide(int side) {
+		return super.getAccessibleSlotsFromSide(side);
+	}
+
+	/* 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 */
+	@Override
+	public LinkedList<ITriggerExternal> getCustomTriggers() {
+		LinkedList<ITriggerExternal> res = new LinkedList<ITriggerExternal>();
+		res.add(ForestryTrigger.missingQueen);
+		res.add(ForestryTrigger.missingDrone);
+		res.add(PluginApiculture.triggerNoFrames);
+		return res;
+	}
+}
@@ -0,0 +1,443 @@
+/*******************************************************************************
+ * 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 com.mojang.authlib.GameProfile;
+
+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 forestry.api.apiculture.IBee;
+import forestry.api.apiculture.IBeeGenome;
+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.genetics.IIndividual;
+import forestry.core.EnumErrorCode;
+import forestry.core.config.Config;
+import forestry.core.config.ForestryItem;
+import forestry.core.gadgets.TileBase;
+import forestry.core.interfaces.IClimatised;
+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.InventoryAdapter;
+import forestry.core.utils.Utils;
+import forestry.plugins.PluginApiculture;
+
+public class TileBeehouse extends TileBase implements IBeeHousing, IClimatised {
+
+	// CONSTANTS
+	public static final int SLOT_QUEEN = 0;
+	public static final int SLOT_DRONE = 1;
+	public static final int SLOT_INVENTORY_1 = 2;
+	protected static int SLOT_PRODUCT_1 = 2;
+	protected static 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_INVENTORY_COUNT = 7;
+	public static final int SLOT_FRAMES_COUNT = 3;
+	// Inventory
+	protected InventoryAdapter inventory = new InventoryAdapter(12, "Items");
+	private final IBeekeepingLogic logic;
+	private int biomeId = -1;
+	private float temperature;
+	private float humidity;
+	private int displayHealthMax = 0;
+	private int displayHealth = 0;
+
+	public TileBeehouse() {
+		setHints(Config.hints.get("apiary"));
+		logic = PluginApiculture.beeInterface.createBeekeepingLogic(this);
+	}
+
+	@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.setFloat("Temp", temperature);
+		nbttagcompound.setFloat("Humidity", humidity);
+		nbttagcompound.setInteger("BiomeId", biomeId);
+
+		inventory.writeToNBT(nbttagcompound);
+		if (logic != null)
+			logic.writeToNBT(nbttagcompound);
+	}
+
+	@Override
+	public void readFromNBT(NBTTagCompound nbttagcompound) {
+		super.readFromNBT(nbttagcompound);
+
+		temperature = nbttagcompound.getFloat("Temp");
+		humidity = nbttagcompound.getFloat("Humidity");
+		biomeId = nbttagcompound.getInteger("BiomeId");
+
+		inventory.readFromNBT(nbttagcompound);
+		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() {
+		if (EnumTemperature.isBiomeHellish(biomeId))
+			return EnumTemperature.HELLISH;
+		return EnumTemperature.getFromValue(temperature);
+	}
+
+	@Override
+	public EnumHumidity getHumidity() {
+		return EnumHumidity.getFromValue(humidity);
+	}
+
+	@Override
+	public float getExactTemperature() {
+		return this.temperature;
+	}
+
+	@Override
+	public float getExactHumidity() {
+		return this.humidity;
+	}
+
+	/* UPDATING */
+	@Override
+	public void updateClientSide() {
+
+		// / Multiplayer FX
+		if (PluginApiculture.beeInterface.isMated(inventory.getStackInSlot(SLOT_QUEEN)))
+			if (getErrorState() == EnumErrorCode.OK && worldObj.getTotalWorldTime() % 2 % 2 == 0) {
+				IBee displayQueen = PluginApiculture.beeInterface.getMember(inventory.getStackInSlot(SLOT_QUEEN));
+				displayQueen.doFX(logic.getEffectData(), this);
+			}
+		return;
+
+	}
+
+	@Override
+	public void updateServerSide() {
+
+		logic.update();
+
+		IBee queen = logic.getQueen();
+		if (queen == null)
+			return;
+
+		// Add swarm effects
+		if (worldObj.getTotalWorldTime() % 200 * 10 == 0)
+			onQueenChange(inventory.getStackInSlot(SLOT_QUEEN));
+		/* These should get already done on the client / doesn't work server-side anyway
+		 if (getErrorState() == EnumErrorCode.OK && worldObj.getTotalWorldTime() % 2 % 2 == 0)
+		 queen.doFX(logic.getEffectData(), this);
+
+		 if (getErrorState() == EnumErrorCode.OK && worldObj.getTotalWorldTime() % 50 == 0) {
+		 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
+	public boolean isWorking() {
+		return getErrorState() == EnumErrorCode.OK;
+	}
+
+	@Override
+	public boolean addProduct(ItemStack product, boolean all) {
+		return inventory.tryAddStack(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() {
+		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() {
+		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
+	 *
+	 * @param i
+	 * @return
+	 */
+	public int getHealthScaled(int i) {
+		if (getMaxHealthDisplay() == 0)
+			return 0;
+
+		return (getHealthDisplay() * i) / getMaxHealthDisplay();
+	}
+
+	public int getTemperatureScaled(int i) {
+		return Math.round(i * (temperature / 2));
+	}
+
+	public int getHumidityScaled(int i) {
+		return Math.round(i * humidity);
+	}
+
+	public void updateBiome() {
+		if (worldObj != null) {
+			BiomeGenBase biome = Utils.getBiomeAt(worldObj, xCoord, zCoord);
+			if (biome != null) {
+				this.biomeId = biome.biomeID;
+				this.temperature = biome.temperature;
+				this.humidity = biome.rainfall;
+				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());
+	}
+
+	/* INVENTORY MANAGMENT */
+	@Override
+	public InventoryAdapter getInternalInventory() {
+		return inventory;
+	}
+
+	public ItemStack getStackInSlot(int i) {
+		return inventory.getStackInSlot(i);
+	}
+
+	public void setSlotContents(int i, ItemStack itemstack) {
+		inventory.setInventorySlotContents(i, itemstack);
+	}
+
+	// / IBEEHOUSING
+	@Override
+	public int getXCoord() {
+		return xCoord;
+	}
+
+	@Override
+	public int getYCoord() {
+		return yCoord;
+	}
+
+	@Override
+	public int getZCoord() {
+		return zCoord;
+	}
+
+	@Override
+	public int getBiomeId() {
+		return this.biomeId;
+	}
+
+	@Override
+	public ItemStack getQueen() {
+		return getStackInSlot(SLOT_QUEEN);
+	}
+
+	@Override
+	public ItemStack getDrone() {
+		return getStackInSlot(SLOT_DRONE);
+	}
+
+	@Override
+	public void setQueen(ItemStack itemstack) {
+		setSlotContents(SLOT_QUEEN, itemstack);
+	}
+
+	@Override
+	public void setDrone(ItemStack itemstack) {
+		setSlotContents(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().ordinal();
+	}
+
+	@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();
+	}
+}
@@ -4,21 +4,20 @@
 * 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.tiles;
+package forestry.apiculture.gadgets;

 import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.network.NetworkManager;
 import net.minecraft.network.Packet;
+import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
 import net.minecraft.tileentity.TileEntity;

-import forestry.apiculture.network.packets.PacketCandleUpdate;
-
 public class TileCandle extends TileEntity {
 	private int colour;
-	private boolean lit;

 	// This is a non-ticking Tile Entity.
 	@Override
@@ -28,49 +27,48 @@ public class TileCandle extends TileEntity {

 	@Override
 	public Packet getDescriptionPacket() {
-		PacketCandleUpdate updateCandle = new PacketCandleUpdate(this);
-		return updateCandle.getPacket();
+		NBTTagCompound nbt = new NBTTagCompound();
+		writeToNBT(nbt);
+
+		return new S35PacketUpdateTileEntity(xCoord, yCoord, zCoord, 0, nbt);
 	}

-	public void onPacketUpdate(int colour, boolean isLit) {
-		this.colour = colour;
-		this.lit = isLit;
+	@Override
+	public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) {
+		readFromNBT(pkt.func_148857_g());
 	}

 	@Override
 	public void readFromNBT(NBTTagCompound tagRoot) {
 		super.readFromNBT(tagRoot);
-		colour = tagRoot.getInteger("colour");
-		lit = tagRoot.getBoolean("lit");
+		this.setColour(tagRoot.getInteger("colour"));
 	}

 	@Override
 	public void writeToNBT(NBTTagCompound tagRoot) {
 		super.writeToNBT(tagRoot);
 		tagRoot.setInteger("colour", this.colour);
-		tagRoot.setBoolean("lit", this.lit);
-	}
-
-	public boolean isLit() {
-		return lit;
-	}
-
-	public void setLit(boolean lit) {
-		this.lit = lit;
 	}

 	public int getColour() {
-		return colour;
+		return this.colour;
 	}

 	public void setColour(int value) {
 		this.colour = value;
 	}

-	public void addColour(int colour2) {
+	public void setColour(int red, int green, int blue) {
+		this.colour = toIntColour(red, green, blue);
+	}
+
+	/*public void setColour(int[] cs) {
+		this.colour = toIntColour(cs[0], cs[1], cs[2]);
+	}*/
+
+	public void addColour(int red, int green, int blue) {
 		int[] myColour = fromIntColour(this.colour);
-		int[] addColour = fromIntColour(colour2);
-		this.colour = toIntColour((addColour[0] + myColour[0]) / 2, (addColour[0] + myColour[0]) / 2, (addColour[2] + myColour[2]) / 2);
+		this.colour = toIntColour((red + myColour[0]) / 2, (green + myColour[0]) / 2, (blue + myColour[2]) / 2);
 	}

 	private static int[] fromIntColour(int value) {
@@ -4,57 +4,38 @@
 * 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.tiles;
+package forestry.apiculture.gadgets;

 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.tileentity.TileEntity;
-import net.minecraft.world.EnumSkyBlock;

-import forestry.core.inventory.InventoryAdapter;
-import forestry.core.utils.InventoryUtil;
+import forestry.core.utils.InventoryAdapter;

 public class TileSwarm extends TileEntity {

-	public final InventoryAdapter contained = new InventoryAdapter(2, "Contained");
+	public InventoryAdapter contained = new InventoryAdapter(2, "Contained");

 	@Override
 	public boolean canUpdate() {
-		return true;
-	}
-
-	// Hack to make sure that hives glow.
-	// TODO: remove when Mojang fixes this bug: https://bugs.mojang.com/browse/MC-3329
-	// Hives should not need to tick normally.
-	private boolean updatedLight;
-
-	@Override
-	public void updateEntity() {
-		super.updateEntity();
-
-		if (worldObj.isRemote && !updatedLight && worldObj.getWorldTime() % 20 == 0) {
-			updatedLight = worldObj.updateLightByType(EnumSkyBlock.Block, xCoord, yCoord, zCoord);
-		}
+		return false;
 	}

 	public TileSwarm setContained(ItemStack[] bees) {
-		for (ItemStack itemstack : bees) {
-			InventoryUtil.addStack(contained, itemstack, true);
-		}
+		for (ItemStack itemstack : bees)
+			contained.addStack(itemstack, false, true);

 		return this;
 	}

 	public boolean containsBees() {
-		for (int i = 0; i < contained.getSizeInventory(); i++) {
-			if (contained.getStackInSlot(i) != null) {
+		for (int i = 0; i < contained.getSizeInventory(); i++)
+			if (contained.getStackInSlot(i) != null)
 				return true;
-			}
-		}

 		return false;
 	}
@@ -4,11 +4,11 @@
 * 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;
+package forestry.apiculture.genetics;

 import net.minecraft.entity.EntityCreature;
 import net.minecraft.entity.ai.EntityAIBase;
@@ -46,27 +46,23 @@ public class AIAvoidPlayers extends EntityAIBase {

 		player = mob.worldObj.getClosestPlayerToEntity(mob, minDistance);

-		if (player == null) {
+		if (player == null)
 			return false;
-		}

-		if (!mob.getEntitySenses().canSee(player)) {
+		if (!mob.getEntitySenses().canSee(player))
 			return false;
-		}

 		Vec3 randomTarget = RandomPositionGenerator.findRandomTargetBlockAwayFrom(mob, 16, 7,
 				Vec3.createVectorHelper(player.posX, player.posY, player.posZ));

-		if (randomTarget == null) {
+		if (randomTarget == null)
 			return false;
-		}

-		if (player.getDistanceSq(randomTarget.xCoord, randomTarget.yCoord, randomTarget.zCoord) < player.getDistanceSqToEntity(mob)) {
+		if (player.getDistanceSq(randomTarget.xCoord, randomTarget.yCoord, randomTarget.zCoord) < player.getDistanceSqToEntity(mob))
 			return false;
-		}

 		pathing = pathNavigator.getPathToXYZ(randomTarget.xCoord, randomTarget.yCoord, randomTarget.zCoord);
-		return pathing != null && pathing.isDestinationSame(randomTarget);
+		return pathing == null ? false : pathing.isDestinationSame(randomTarget);
 	}

 	@Override
@@ -86,10 +82,9 @@ public class AIAvoidPlayers extends EntityAIBase {

 	@Override
 	public void updateTask() {
-		if (mob.getDistanceSqToEntity(player) < 49.0D) {
+		if (mob.getDistanceSqToEntity(player) < 49.0D)
 			mob.getNavigator().setSpeed(nearSpeed);
-		} else {
+		else
 			mob.getNavigator().setSpeed(farSpeed);
-		}
 	}
 }
@@ -0,0 +1,240 @@
+/*******************************************************************************
+ * 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.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 cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+import com.mojang.authlib.GameProfile;
+
+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 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.ordinal())) {
+			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>();
+		for(ItemStack stack : super.getResearchBounty(world, researcher, individual, bountyLevel))
+			bounty.add(stack);
+
+		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(StackUtils.EMPTY_STACK_ARRAY);
+	}
+
+	/* 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;
+	}
+
+}
@@ -0,0 +1,70 @@
+/*******************************************************************************
+ * 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 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;
+	}
+
+}
@@ -4,70 +4,79 @@
 * 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;
+package forestry.apiculture.genetics;

 import java.util.List;

 import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.util.ChunkCoordinates;
+import net.minecraft.util.AxisAlignedBB;
 import net.minecraft.world.World;

-import forestry.api.apiculture.BeeManager;
 import forestry.api.apiculture.IBeeGenome;
 import forestry.api.apiculture.IBeeHousing;
 import forestry.api.genetics.IEffectData;
+import forestry.apiculture.items.ItemArmorApiarist;
 import forestry.core.genetics.EffectData;

 public class AlleleEffectCreeper extends AlleleEffectThrottled {

-	private static final int explosionChance = 50;
-	private static final byte defaultForce = 12;
-	private static final byte indexExplosionTimer = 1;
-	private static final byte indexExplosionForce = 2;
+	private final int explosionChance = 50;
+	byte defaultForce = 12;
+	byte indexExplosionTimer = 1;
+	byte indexExplosionForce = 2;

-	public AlleleEffectCreeper() {
-		super("creeper", true, 20, false, true);
+	public AlleleEffectCreeper(String uid) {
+		super(uid, "creeper", true, 20, false, true);
 	}

 	@Override
 	public IEffectData validateStorage(IEffectData storedData) {
-		if (!(storedData instanceof EffectData)) {
+		if (!(storedData instanceof EffectData))
 			return new EffectData(3, 0);
-		}

-		if (((EffectData) storedData).getIntSize() < 3) {
+		if (((EffectData) storedData).getIntSize() < 3)
 			return new EffectData(3, 0);
-		}

 		return storedData;
 	}

 	@Override
-	public IEffectData doEffectThrottled(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) {
+	public IEffectData doEffect(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) {

 		World world = housing.getWorld();
-		ChunkCoordinates housingCoords = housing.getCoordinates();
+
+		if (isHalted(storedData, housing))
+			return storedData;

 		// If we are already triggered, we continue the explosion sequence.
 		if (storedData.getInteger(indexExplosionTimer) > 0) {
-			progressExplosion(storedData, world, housingCoords.posX, housingCoords.posY, housingCoords.posZ);
+			progressExplosion(storedData, world, housing.getXCoord(), housing.getYCoord(), housing.getZCoord());
 			return storedData;
 		}

-		List<EntityPlayer> players = getEntitiesInRange(genome, housing, EntityPlayer.class);
-		for (EntityPlayer player : players) {
+		AxisAlignedBB infectionBox = getBounding(genome, housing, 1.0f);
+
+		@SuppressWarnings("rawtypes")
+		List list = world.getEntitiesWithinAABB(EntityPlayer.class, infectionBox);
+
+		for (Object obj : list) {
+
+			EntityPlayer player = (EntityPlayer) obj;
+
 			int chance = explosionChance;
 			storedData.setInteger(indexExplosionForce, defaultForce);

-			// Entities are not attacked if they wear a full set of apiarist's armor.
-			int count = BeeManager.armorApiaristHelper.wearsItems(player, getUID(), true);
-			if (count > 3) {
-				continue; // Full set, no damage/effect
-			} else if (count > 2) {
+			// 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) {
 				chance = 5;
 				storedData.setInteger(indexExplosionForce, 6);
 			} else if (count > 1) {
@@ -78,27 +87,26 @@ public class AlleleEffectCreeper extends AlleleEffectThrottled {
 				storedData.setInteger(indexExplosionForce, 10);
 			}

-			if (world.rand.nextInt(1000) >= chance) {
+			if (world.rand.nextInt(1000) >= chance)
 				continue;
-			}

-			world.playSoundEffect(housingCoords.posX, housingCoords.posY, housingCoords.posZ, "mob.creeper", 4F,
+			world.playSoundEffect(housing.getXCoord(), housing.getYCoord(), housing.getZCoord(), "mob.creeper", 4F,
 					(1.0F + (world.rand.nextFloat() - world.rand.nextFloat()) * 0.2F) * 0.7F);
-			storedData.setInteger(indexExplosionTimer, 2); // Set explosion timer
+			storedData.setInteger(indexExplosionTimer, 2); // Set explosion
+			// timer
 		}

 		return storedData;
 	}

-	private static void progressExplosion(IEffectData storedData, World world, int x, int y, int z) {
+	private void progressExplosion(IEffectData storedData, World world, int x, int y, int z) {

 		int explosionTimer = storedData.getInteger(indexExplosionTimer);
 		explosionTimer--;
 		storedData.setInteger(indexExplosionTimer, explosionTimer);

-		if (explosionTimer > 0) {
+		if (explosionTimer > 0)
 			return;
-		}

 		world.createExplosion(null, x, y, z, storedData.getInteger(indexExplosionForce), false);
 	}
Author	SHA1	Message	Date
mezz	ac653d46c1	Fix #326 decorative leaves should not pollinate	2014-11-15 04:15:20 -08:00
mezz	63d9935d01	Minor code cleanup	2014-11-15 04:15:14 -08:00
mezz	ba695b977d	Fix #325 Centrifuge dupe bug	2014-11-15 04:13:46 -08:00
CovertJaguar	6b1dfb1596	Set submodules	2014-11-15 04:12:44 -08:00
CovertJaguar	fff02be71d	Bump version to 3.2	2014-11-08 21:40:45 -08:00
CovertJaguar	0e5b9e4957	Merge branch 'dev' into release_3.2 Conflicts: src/main/resources/assets/forestry/textures/blocks/storage/apatite.png src/main/resources/assets/forestry/textures/blocks/storage/bronze.png src/main/resources/assets/forestry/textures/blocks/storage/copper.png src/main/resources/assets/forestry/textures/blocks/storage/tin.png	2014-11-08 21:39:26 -08:00
MysteriousAges	3415030fbf	Revert "Storage block textures - Apatite, Bronze, Copper, Tin." This reverts commit `c8fd93873a`.	2014-10-24 20:18:30 -07:00