Refactor Binnie's mods into separate modules (#260)

* Code improvement for genetics.api
Code improvement for genetics.core
Fix missed localization for info of Lab Stand
* Code improvement for genetics.genetics package

.gitignore

@@ -1,19 +1,12 @@
-.gradle
 # IntelliJ
-/build
-/run
-/eclipse
-/out
-/classes
-.idea
+.idea/
 *.iml
 *.ipr
 *.iws
-# minecraft
-/config
-/logs
-/saves
-/options.txt
-/usernamecache.json
 
-changelog.html
+# folders
+.gradle/
+classes/
+build/
+run/
+out/

README.md

@@ -10,7 +10,7 @@ along with new features such as fully breedable flowers and genetic manipulation
 
 [Wiki](https://binnie.mods.wiki/wiki/Main_Page)
 
-[Latest Builds for 1.7.10](https://ci.bymarcin.com/job/Binnie-Mods-MC1.7.10/)
+[Latest Builds for 1.11 / 1.11.2](http://jenkins.ic2.player.to/job/Binnie's%201.11.2/)
 
 ### Mods
 
@@ -36,9 +36,6 @@ Genetics is for those who want to eschew conventional breeding, and want to ente
 
 Binnie Core is a mod which contains a lot of the core functionality such as networking and GUI's for the other mods. The only in game features it currently contains are the Compartments
 
-### Warning
-
-Removed unused (unfinished) items and blocks: Honey Crystal, Alcohol, etc.
 
 ### Building
 

all/build.gradle

@@ -0,0 +1,10 @@
+archivesBaseName = 'all-' + mcversion
+
+dependencies {
+	compile project(":api")
+	compile project(":botany")
+	compile project(":core")
+	compile project(":extrabees")
+	compile project(":extratrees")
+	compile project(":genetics")
+}

api/build.gradle

@@ -0,0 +1 @@
+archivesBaseName = 'api-' + mcversion

api/src/main/java/binnie/botany/api/BotanyAPI.java

@@ -0,0 +1,22 @@
+package binnie.botany.api;
+
+import binnie.botany.api.gardening.IGardeningManager;
+import binnie.botany.api.genetics.IFlowerFactory;
+import binnie.botany.api.genetics.IFlowerRoot;
+
+public class BotanyAPI {
+	/**
+	 * Convenient access to AlleleManager.alleleRegistry.getSpeciesRoot("rootFlowers")
+	 */
+	public static IFlowerRoot flowerRoot;
+
+	/**
+	 * Used to create new flowers.
+	 */
+	public static IFlowerFactory flowerFactory;
+
+	/**
+	 * Used to manager soil.
+	 */
+	public static IGardeningManager gardening;
+}

api/src/main/java/binnie/botany/api/gardening/EnumAcidity.java

@@ -0,0 +1,43 @@
+package binnie.botany.api.gardening;
+
+import javax.annotation.Nullable;
+
+import net.minecraft.util.IStringSerializable;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.util.text.translation.I18n;
+
+public enum EnumAcidity implements IStringSerializable {
+	ACID(TextFormatting.RED),
+	NEUTRAL(null),
+	ALKALINE(TextFormatting.AQUA);
+
+	@Nullable
+	TextFormatting color;
+
+	EnumAcidity(@Nullable TextFormatting color) {
+		this.color = color;
+	}
+
+	@Override
+	public String getName() {
+		return name().toLowerCase();
+	}
+
+	public String getLocalisedName(boolean withColor) {
+		String localisedName = I18n.translateToLocal("botany.ph." + getName());
+		if (withColor && color != null) {
+			localisedName = color + localisedName;
+		}
+		return localisedName;
+	}
+
+	public static EnumAcidity getFromValue(float rawAcidity) {
+		if(rawAcidity <= -1.0f){
+			return EnumAcidity.ACID;
+		}else if(rawAcidity >= 1.0f){
+			return EnumAcidity.ALKALINE;
+		}else{
+			return EnumAcidity.NEUTRAL;
+		}
+	}
+}

api/src/main/java/binnie/botany/api/gardening/EnumFertiliserType.java

@@ -0,0 +1,5 @@
+package binnie.botany.api.gardening;
+
+public enum EnumFertiliserType {
+	ACID, ALKALINE, NUTRIENT
+}

api/src/main/java/binnie/botany/api/gardening/EnumMoisture.java

@@ -0,0 +1,44 @@
+package binnie.botany.api.gardening;
+
+import javax.annotation.Nullable;
+
+import net.minecraft.util.IStringSerializable;
+import net.minecraft.util.text.TextFormatting;
+
+import net.minecraft.util.text.translation.I18n;
+
+public enum EnumMoisture implements IStringSerializable {
+	DRY(TextFormatting.YELLOW),
+	NORMAL(null),
+	DAMP(TextFormatting.DARK_BLUE);
+
+	@Nullable
+	final TextFormatting color;
+
+	EnumMoisture(@Nullable TextFormatting color) {
+		this.color = color;
+	}
+
+	@Override
+	public String getName() {
+		return name().toLowerCase();
+	}
+
+	public String getLocalisedName(boolean withColor) {
+		String localisedName = I18n.translateToLocal("botany.moisture." + getName());
+		if (withColor && color != null) {
+			localisedName = color + localisedName + TextFormatting.GRAY;
+		}
+		return localisedName;
+	}
+
+	public static EnumMoisture getFromValue(float rawMoisture) {
+		if(rawMoisture <= -1.0f){
+			return EnumMoisture.DRY;
+		}else if(rawMoisture >= 1.0f){
+			return EnumMoisture.DAMP;
+		}else{
+			return EnumMoisture.NORMAL;
+		}
+	}
+}

api/src/main/java/binnie/botany/api/gardening/EnumSoilType.java

@@ -0,0 +1,29 @@
+package binnie.botany.api.gardening;
+
+import java.util.Locale;
+
+import net.minecraft.util.IStringSerializable;
+import net.minecraft.util.text.TextFormatting;
+
+import net.minecraft.util.text.translation.I18n;
+
+public enum EnumSoilType implements IStringSerializable {
+	SOIL(TextFormatting.DARK_GRAY),
+	LOAM(TextFormatting.GOLD),
+	FLOWERBED(TextFormatting.LIGHT_PURPLE);
+
+	private final TextFormatting color;
+
+	EnumSoilType(TextFormatting color) {
+		this.color = color;
+	}
+
+	@Override
+	public String getName() {
+		return name().toLowerCase(Locale.ENGLISH);
+	}
+
+	public String getTranslated() {
+		return color + I18n.translateToLocal("botany.soil." + getName());
+	}
+}

api/src/main/java/binnie/botany/api/gardening/IBlockSoil.java

@@ -0,0 +1,22 @@
+package binnie.botany.api.gardening;
+
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+public interface IBlockSoil {
+	EnumAcidity getPH(World world, BlockPos pos);
+
+	EnumMoisture getMoisture(World world, BlockPos pos);
+
+	EnumSoilType getType(World world, BlockPos pos);
+
+	boolean fertilise(World world, BlockPos pos, EnumSoilType soilType);
+
+	boolean degrade(World world, BlockPos pos, EnumSoilType soilType);
+
+	boolean setPH(World world, BlockPos pos, EnumAcidity acidity);
+
+	boolean setMoisture(World world, BlockPos pos, EnumMoisture moisture);
+
+	boolean resistsWeeds(World world, BlockPos pos);
+}

api/src/main/java/binnie/botany/api/gardening/IGardeningManager.java

@@ -0,0 +1,67 @@
+package binnie.botany.api.gardening;
+
+import javax.annotation.Nullable;
+import java.util.Collection;
+import java.util.Map;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+import forestry.api.core.EnumTemperature;
+
+import binnie.botany.api.genetics.IFlower;
+
+public interface IGardeningManager {
+	default boolean isSoil(Block block) {
+		return block instanceof IBlockSoil;
+	}
+
+	boolean isSoil(Item item);
+
+	boolean isSoil(ItemStack item);
+
+	EnumMoisture getNaturalMoisture(World world, BlockPos pos);
+
+	EnumAcidity getNaturalPH(World world, BlockPos pos);
+
+	float getBiomeMoisture(World world, BlockPos pos);
+
+	float getBiomePH(World world, BlockPos pos);
+
+	IBlockState getSoil(EnumSoilType soil, boolean weedKill, EnumMoisture moisture, EnumAcidity acidity);
+
+	void plantSoil(World world, BlockPos pos, EnumSoilType soil, EnumMoisture moisture, EnumAcidity acidity);
+
+	Collection<ItemStack> getFertilisers(EnumFertiliserType type);
+
+	Map<EnumFertiliserType, Map<ItemStack, Integer>> getFertilisers();
+
+	void registerFertiliser(EnumFertiliserType type, ItemStack stack, int strength);
+
+	boolean isFertiliser(EnumFertiliserType type, ItemStack stack);
+
+	int getFertiliserStrength(ItemStack stack);
+
+	boolean canTolerate(@Nullable IFlower flower, World world, BlockPos pos);
+
+	EnumSoilType getSoilType(World world, BlockPos pos);
+
+	default Block getSoilBlock(EnumSoilType type) {
+		return getSoilBlock(type, false);
+	}
+
+	Block getSoilBlock(EnumSoilType type, boolean weedKill);
+
+	boolean canTolerate(IFlower flower, EnumAcidity acidity, EnumMoisture moisture, EnumTemperature temperature);
+
+	boolean isWeedkiller(ItemStack heldItem);
+
+	boolean addWeedKiller(World world, BlockPos pos);
+
+	boolean onFertiliseSoil(ItemStack heldItem, IBlockSoil soil, World world, BlockPos pos, EntityPlayer player);
+}

api/src/main/java/binnie/botany/api/gardening/package-info.java

@@ -0,0 +1,7 @@
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+package binnie.botany.api.gardening;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import mcp.MethodsReturnNonnullByDefault;

api/src/main/java/binnie/botany/api/genetics/AlleleFlowerColor.java

@@ -0,0 +1,75 @@
+package binnie.botany.api.genetics;
+
+import forestry.api.genetics.IAlleleInteger;
+import net.minecraft.util.text.translation.I18n;
+
+// TODO: move out of API
+public class AlleleFlowerColor implements IAlleleFlowerColor {
+	private int color;
+	private String uid;
+	private boolean isDominant;
+	private String name;
+	private String unlocalizedName;
+	private int colorDis;
+	private int id;
+
+	public AlleleFlowerColor(String uid, int id, int color, int colorDis, String name, String unlocalizedName, boolean isDominant) {
+		this.color = color;
+		this.uid = uid;
+		this.isDominant = isDominant;
+		this.name = name;
+		this.unlocalizedName = unlocalizedName;
+		this.colorDis = colorDis;
+		this.id = id;
+	}
+
+	@Override
+	public int getValue() {
+		return color;
+	}
+
+	@Override
+	public String getUID() {
+		return uid;
+	}
+
+	@Override
+	public boolean isDominant() {
+		return isDominant;
+	}
+
+	@Override
+	public String getName() {
+		return name;
+	}
+
+	@Override
+	public String getAlleleName() {
+		return name;
+	}
+
+	@Override
+	public String getUnlocalizedName() {
+		return unlocalizedName;
+	}
+
+	@Override
+	public int getColor(boolean dis) {
+		return dis ? colorDis : color;
+	}
+
+	@Override
+	public IAlleleInteger getAllele() {
+		return this;
+	}
+
+	@Override
+	public int getID() {
+		return id;
+	}
+
+	@Override
+	public String getColorName() {
+		return I18n.translateToLocal("botany.color." + getAlleleName());
+	}
+}

api/src/main/java/binnie/botany/api/genetics/ColorMix.java

@@ -0,0 +1,40 @@
+package binnie.botany.api.genetics;
+
+public final class ColorMix implements IColorMix {
+	private final IFlowerColor colorFirst;
+	private final IFlowerColor colorSecond;
+	private final IFlowerColor result;
+	private final int chance;
+
+	public ColorMix(IFlowerColor colorFirst, IFlowerColor colorSecond, IFlowerColor result, int chance) {
+		this.colorFirst = colorFirst;
+		this.colorSecond = colorSecond;
+		this.result = result;
+		this.chance = chance;
+	}
+
+	@Override
+	public IFlowerColor getColorFirst() {
+		return colorFirst;
+	}
+
+	@Override
+	public IFlowerColor getColorSecond() {
+		return colorSecond;
+	}
+
+	@Override
+	public boolean isMutation(IFlowerColor colorFirst, IFlowerColor colorSecond) {
+		return (colorFirst == this.colorFirst && colorSecond == this.colorSecond) || (colorFirst == this.colorSecond && colorSecond == this.colorFirst);
+	}
+
+	@Override
+	public int getChance() {
+		return chance;
+	}
+
+	@Override
+	public IFlowerColor getResult() {
+		return result;
+	}
+}

api/src/main/java/binnie/botany/api/genetics/EnumFlowerChromosome.java

@@ -1,4 +1,6 @@
-package binnie.botany.api;
+package binnie.botany.api.genetics;
+
+import java.util.Locale;
 
 import forestry.api.genetics.AlleleManager;
 import forestry.api.genetics.IAllele;
@@ -36,7 +38,7 @@ public enum EnumFlowerChromosome implements IChromosomeType {
 
 	@Override
 	public String getName() {
-		return toString().toLowerCase();
+		return toString().toLowerCase(Locale.ENGLISH);
 	}
 
 	@Override

api/src/main/java/binnie/botany/api/genetics/EnumFlowerStage.java

@@ -0,0 +1,29 @@
+package binnie.botany.api.genetics;
+
+import forestry.api.genetics.ISpeciesType;
+
+public enum EnumFlowerStage implements ISpeciesType {
+	FLOWER("Flower"),
+	SEED("Seed"),
+	POLLEN("Pollen");
+
+	public static final EnumFlowerStage[] VALUES = values();
+	String name;
+
+	EnumFlowerStage(String name) {
+		this.name = name;
+	}
+
+	public static EnumFlowerStage getStage(IFlower flower) {
+		return getStage(flower.getAge());
+	}
+
+	public static EnumFlowerStage getStage(int age) {
+		return age == 0 ? EnumFlowerStage.SEED : EnumFlowerStage.FLOWER;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+}

api/src/main/java/binnie/botany/api/genetics/IAlleleFlowerColor.java

@@ -0,0 +1,6 @@
+package binnie.botany.api.genetics;
+
+import forestry.api.genetics.IAlleleInteger;
+
+public interface IAlleleFlowerColor extends IFlowerColor, IAlleleInteger {
+}

api/src/main/java/binnie/botany/api/genetics/IAlleleFlowerEffect.java

@@ -0,0 +1,10 @@
+package binnie.botany.api.genetics;
+
+import net.minecraft.world.World;
+
+import forestry.api.genetics.IAlleleEffect;
+import forestry.api.genetics.IEffectData;
+
+public interface IAlleleFlowerEffect extends IAlleleEffect {
+	IEffectData doEffect(IFlowerGenome genome, IEffectData effect, World world, int x, int y, int z);
+}

api/src/main/java/binnie/botany/api/genetics/IAlleleFlowerSpecies.java

@@ -0,0 +1,31 @@
+package binnie.botany.api.genetics;
+
+import net.minecraft.client.renderer.block.model.ModelResourceLocation;
+import net.minecraft.item.Item;
+
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import forestry.api.core.IModelManager;
+import forestry.api.genetics.IAlleleProperty;
+import forestry.api.genetics.IAlleleSpecies;
+
+import binnie.botany.api.gardening.EnumAcidity;
+import binnie.botany.api.gardening.EnumMoisture;
+
+public interface IAlleleFlowerSpecies extends IAlleleSpecies, IAlleleProperty<IAlleleFlowerSpecies> {
+	IFlowerType getType();
+
+	EnumAcidity getPH();
+
+	EnumMoisture getMoisture();
+
+	@SideOnly(Side.CLIENT)
+	int getFlowerColor(EnumFlowerStage type, int renderPass);
+
+	@SideOnly(Side.CLIENT)
+	ModelResourceLocation getFlowerModel(EnumFlowerStage type, boolean flowered);
+
+	@SideOnly(Side.CLIENT)
+	void registerModels(Item item, IModelManager manager, EnumFlowerStage type);
+}

api/src/main/java/binnie/botany/api/genetics/IAlleleFlowerSpeciesBuilder.java

@@ -0,0 +1,15 @@
+package binnie.botany.api.genetics;
+
+import forestry.api.genetics.IAlleleSpeciesBuilder;
+
+import binnie.botany.api.gardening.EnumAcidity;
+import binnie.botany.api.gardening.EnumMoisture;
+
+public interface IAlleleFlowerSpeciesBuilder extends IAlleleSpeciesBuilder {
+	@Override
+	IAlleleFlowerSpecies build();
+
+	IAlleleFlowerSpeciesBuilder setPH(EnumAcidity acidity);
+
+	IAlleleFlowerSpeciesBuilder setMoisture(EnumMoisture moisture);
+}

api/src/main/java/binnie/botany/api/genetics/IBotanistTracker.java

@@ -1,4 +1,4 @@
-package binnie.botany.api;
+package binnie.botany.api.genetics;
 
 import forestry.api.genetics.IBreedingTracker;
 

api/src/main/java/binnie/botany/api/genetics/IColorMix.java

@@ -0,0 +1,13 @@
+package binnie.botany.api.genetics;
+
+public interface IColorMix {
+	IFlowerColor getColorFirst();
+
+	IFlowerColor getColorSecond();
+
+	boolean isMutation(IFlowerColor colorFirst, IFlowerColor colorSecond);
+
+	int getChance();
+
+	IFlowerColor getResult();
+}

api/src/main/java/binnie/botany/api/genetics/IFlower.java

@@ -0,0 +1,76 @@
+package binnie.botany.api.genetics;
+
+import javax.annotation.Nullable;
+
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+import forestry.api.genetics.IIndividual;
+
+public interface IFlower extends IIndividual {
+	/**
+	 * @return Flowers's genetic information.
+	 */
+	@Override
+	IFlowerGenome getGenome();
+
+	/**
+	 * @return Genetic information of the flower's mate, null if unmated.
+	 */
+	@Nullable
+	IFlowerGenome getMate();
+
+	/**
+	 * Mate with the given flower.
+	 *
+	 * @param flower the {@link IFlower} to mate this one with.
+	 */
+	void mate(IFlower flower);
+
+	/**
+	 * Remove the mate of the flower.
+	 */
+	void removeMate();
+
+	IFlower getOffspring(World world, BlockPos pos);
+
+	/**
+	 * @return The current age of the flower.
+	 */
+	int getAge();
+
+	/**
+	 * Set the current age of the flower.
+	 */
+	void setAge(int age);
+
+	/**
+	 * Age the flower.
+	 */
+	void age();
+
+	/**
+	 * @return Maximum age of the flower.
+	 */
+	int getMaxAge();
+
+	/**
+	 * @return true if the flower is wilted.
+	 */
+	boolean isWilted();
+
+	/**
+	 * Set that the flower is wilted.
+	 */
+	void setWilted(boolean wilted);
+
+	/**
+	 * @return true if the flower has flowered.
+	 */
+	boolean hasFlowered();
+
+	/**
+	 * Set that the flower has flowered.
+	 */
+	void setFlowered(boolean flowered);
+}

api/src/main/java/binnie/botany/api/genetics/IFlowerColor.java

@@ -0,0 +1,13 @@
+package binnie.botany.api.genetics;
+
+import forestry.api.genetics.IAlleleInteger;
+
+public interface IFlowerColor {
+	int getColor(boolean dis);
+
+	IAlleleInteger getAllele();
+
+	int getID();
+
+	String getColorName();
+}

api/src/main/java/binnie/botany/api/genetics/IFlowerDefinition.java

@@ -0,0 +1,15 @@
+package binnie.botany.api.genetics;
+
+import net.minecraft.item.ItemStack;
+
+import forestry.core.genetics.IGeneticDefinition;
+
+public interface IFlowerDefinition extends IGeneticDefinition {
+	@Override
+	IFlowerGenome getGenome();
+
+	@Override
+	IFlower getIndividual();
+
+	ItemStack getMemberStack(EnumFlowerStage flowerStage);
+}

api/src/main/java/binnie/botany/api/genetics/IFlowerFactory.java

@@ -0,0 +1,10 @@
+package binnie.botany.api.genetics;
+
+import forestry.api.genetics.IAllele;
+import forestry.api.genetics.IClassification;
+
+public interface IFlowerFactory {
+	IAlleleFlowerSpeciesBuilder createSpecies(String uid, String unlocalizedName, String authority, String unlocalizedDescription, boolean isDominant, IClassification branch, String binomial, IFlowerType flowerType);
+
+	IFlowerMutationBuilder createMutation(IAlleleFlowerSpecies allele0, IAlleleFlowerSpecies allele1, IAllele[] result, int chance);
+}

api/src/main/java/binnie/botany/api/genetics/IFlowerGenome.java

@@ -0,0 +1,44 @@
+package binnie.botany.api.genetics;
+
+import forestry.api.core.EnumTemperature;
+import forestry.api.genetics.EnumTolerance;
+import forestry.api.genetics.IGenome;
+
+import binnie.botany.api.gardening.EnumAcidity;
+import binnie.botany.api.gardening.EnumMoisture;
+
+public interface IFlowerGenome extends IGenome {
+	@Override
+	IAlleleFlowerSpecies getPrimary();
+
+	@Override
+	IAlleleFlowerSpecies getSecondary();
+
+	IFlowerColor getPrimaryColor();
+
+	IFlowerColor getSecondaryColor();
+
+	IFlowerColor getStemColor();
+
+	int getFertility();
+
+	int getLifespan();
+
+	IFlowerType getType();
+
+	EnumTolerance getToleranceTemperature();
+
+	EnumTolerance getToleranceMoisture();
+
+	EnumTolerance getTolerancePH();
+
+	float getAgeChance();
+
+	float getSappiness();
+
+	boolean canTolerate(EnumAcidity acidity);
+
+	boolean canTolerate(EnumMoisture moisture);
+
+	boolean canTolerate(EnumTemperature temperature);
+}

api/src/main/java/binnie/botany/api/genetics/IFlowerMutation.java

@@ -0,0 +1,13 @@
+package binnie.botany.api.genetics;
+
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+import forestry.api.genetics.IMutation;
+
+public interface IFlowerMutation extends IMutation {
+	@Override
+	IFlowerRoot getRoot();
+
+	float getChance(World world, BlockPos pos, IAlleleFlowerSpecies allele0, IAlleleFlowerSpecies allele1, IFlowerGenome genome0, IFlowerGenome genome1);
+}

api/src/main/java/binnie/botany/api/genetics/IFlowerMutationBuilder.java

@@ -0,0 +1,6 @@
+package binnie.botany.api.genetics;
+
+import forestry.api.genetics.IMutationBuilder;
+
+public interface IFlowerMutationBuilder extends IMutationBuilder {
+}

api/src/main/java/binnie/botany/api/genetics/IFlowerRoot.java

@@ -0,0 +1,59 @@
+package binnie.botany.api.genetics;
+
+import javax.annotation.Nullable;
+import java.util.Collection;
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+import com.mojang.authlib.GameProfile;
+
+import forestry.api.genetics.IAllele;
+import forestry.api.genetics.ISpeciesRoot;
+
+public interface IFlowerRoot extends ISpeciesRoot {
+	@Override
+	@Nullable
+	IFlower getMember(ItemStack memberStack);
+
+	@Override
+	IFlower templateAsIndividual(IAllele[] template);
+
+	@Override
+	IFlower templateAsIndividual(IAllele[] templateFirst, IAllele[] templateSecond);
+
+	@Override
+	IFlowerGenome templateAsGenome(IAllele[] template);
+
+	@Override
+	IFlowerGenome templateAsGenome(IAllele[] templateActive, IAllele[] templateInactive);
+
+	@Override
+	IBotanistTracker getBreedingTracker(World world, @Nullable GameProfile profile);
+
+	@Override
+	List<? extends IFlowerMutation> getMutations(boolean shuffle);
+
+	@Override
+	@Nullable
+	EnumFlowerStage getType(ItemStack itemStack);
+
+	IFlower getFlower(IFlowerGenome genome);
+
+	void addConversion(ItemStack memberStack, IAllele[] template);
+
+	@Nullable
+	IFlower getConversion(ItemStack memberStack);
+
+	Collection<IColorMix> getColorMixes(boolean shuffle);
+
+	void registerColourMix(IColorMix colorMix);
+
+	boolean plant(World world, BlockPos pos, IFlower flower, GameProfile owner);
+
+	void tryGrowSection(World world, BlockPos pos);
+
+	void onGrowFromSeed(World world, BlockPos pos);
+}

api/src/main/java/binnie/botany/api/genetics/IFlowerType.java

@@ -0,0 +1,23 @@
+package binnie.botany.api.genetics;
+
+import net.minecraft.client.renderer.block.model.ModelResourceLocation;
+import net.minecraft.item.Item;
+
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import forestry.api.core.IModelManager;
+
+public interface IFlowerType<I extends IFlowerType<I>> extends Comparable<I> {
+	@SideOnly(Side.CLIENT)
+	void registerModels(Item item, IModelManager manager, EnumFlowerStage type);
+
+	@SideOnly(Side.CLIENT)
+	ModelResourceLocation getModel(EnumFlowerStage type, boolean flowered);
+
+	String getName();
+
+	int getSections();
+
+	int ordinal();
+}

api/src/main/java/binnie/botany/api/genetics/package-info.java

@@ -0,0 +1,7 @@
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+package binnie.botany.api.genetics;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import mcp.MethodsReturnNonnullByDefault;

api/src/main/java/binnie/botany/api/package-info.java

@@ -0,0 +1,7 @@
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+package binnie.botany.api;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import mcp.MethodsReturnNonnullByDefault;

api/src/main/java/binnie/core/api/IBinnieRecipe.java

@@ -0,0 +1,10 @@
+package binnie.core.api;
+
+import java.util.Collection;
+
+public interface IBinnieRecipe {
+
+	Collection<Object> getInputs();
+
+	Collection<Object> getOutputs();
+}

api/src/main/java/binnie/core/api/ICraftingManager.java

@@ -0,0 +1,24 @@
+package binnie.core.api;
+
+import java.util.Collection;
+
+public interface ICraftingManager<T extends IBinnieRecipe> {
+	/**
+	 * Add a new recipe to the crafting provider.
+	 *
+	 * @return <tt>true</tt> if this collection changed as a result of the call
+	 */
+	boolean addRecipe(T recipe);
+
+	/**
+	 * Remove a specific recipe from the crafting provider.
+	 *
+	 * @return <tt>true</tt> if an element was removed as a result of this call
+	 */
+	boolean removeRecipe(T recipe);
+
+	/**
+	 * @return an unmodifiable collection of all recipes registered to the crafting provider.
+	 */
+	Collection<T> recipes();
+}

api/src/main/java/binnie/core/api/block/BlockMetadata.java

@@ -0,0 +1,107 @@
+package binnie.core.api.block;
+
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.NonNullList;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.RayTraceResult;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+
+// TODO: move out of API
+public class BlockMetadata extends BlockContainer implements IBlockMetadata {
+	public BlockMetadata(final Material material) {
+		super(material);
+	}
+
+	public static ItemStack getBlockDropped(IBlockMetadata block, IBlockAccess world, BlockPos pos) {
+		TileEntityMetadata tile = TileEntityMetadata.getTile(world, pos);
+		if (tile != null && !tile.hasDroppedBlock()) {
+			int meta = block.getDroppedMeta(world.getBlockState(pos), tile.getTileMetadata());
+			return TileEntityMetadata.getItemStack((Block) block, meta);
+		}
+		return ItemStack.EMPTY;
+	}
+
+	public static void getDrops(NonNullList<ItemStack> drops, IBlockMetadata block, IBlockAccess world, BlockPos pos) {
+		ItemStack drop = getBlockDropped(block, world, pos);
+		if (!drop.isEmpty()) {
+			drops.add(drop);
+		}
+	}
+
+	public static boolean breakBlock(IBlockMetadata blockMetadata, @Nullable EntityPlayer player, World world, BlockPos pos) {
+		List<ItemStack> drops = new ArrayList<>();
+		Block block = (Block) blockMetadata;
+		TileEntityMetadata tile = TileEntityMetadata.getTile(world, pos);
+		if (tile != null && !tile.hasDroppedBlock()) {
+			drops = block.getDrops(world, pos, world.getBlockState(pos), 0);
+		}
+		boolean hasBeenBroken = world.setBlockToAir(pos);
+		if (hasBeenBroken && !world.isRemote && drops.size() > 0 && (player == null || !player.capabilities.isCreativeMode)) {
+			for (ItemStack drop : drops) {
+				spawnAsEntity(world, pos, drop);
+			}
+			if (tile != null) {
+				tile.dropBlock();
+			}
+		}
+		return hasBeenBroken;
+	}
+
+	public static ItemStack getPickBlock(World world, BlockPos pos) {
+		Block block = world.getBlockState(pos).getBlock();
+		return getBlockDropped((IBlockMetadata) block, world, pos);
+	}
+
+	@Override
+	public void getDrops(NonNullList<ItemStack> drops, IBlockAccess world, BlockPos pos, IBlockState state, int fortune) {
+		getDrops(drops, this, world, pos);
+	}
+
+	@Override
+	public boolean removedByPlayer(IBlockState state, World world, BlockPos pos, EntityPlayer player, boolean willHarvest) {
+		return breakBlock(this, player, world, pos);
+	}
+
+	@Override
+	public TileEntity createNewTileEntity(final World var1, final int i) {
+		return new TileEntityMetadata();
+	}
+
+	@Override
+	public boolean hasTileEntity(IBlockState state) {
+		return true;
+	}
+
+	@Override
+	public ItemStack getPickBlock(IBlockState state, RayTraceResult target, World world, BlockPos pos, EntityPlayer player) {
+		return getPickBlock(world, pos);
+	}
+
+	/* IBLOCKMETADATA */
+	@Override
+	public String getDisplayName(final ItemStack itemStack) {
+		return this.getLocalizedName();
+	}
+
+	@Override
+	public int getPlacedMeta(final ItemStack item, final World world, final BlockPos pos, final EnumFacing clickedBlock) {
+		return TileEntityMetadata.getItemDamage(item);
+	}
+
+	@Override
+	public int getDroppedMeta(IBlockState state, int tileMetadata) {
+		return getMetaFromState(state);
+	}
+}

api/src/main/java/binnie/core/api/block/IBlockMetadata.java

@@ -0,0 +1,17 @@
+package binnie.core.api.block;
+
+import net.minecraft.block.ITileEntityProvider;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+// TODO: move out of API
+public interface IBlockMetadata extends ITileEntityProvider {
+	int getPlacedMeta(ItemStack itemStack, World world, BlockPos pos, EnumFacing facing);
+
+	int getDroppedMeta(IBlockState state, int tileMetadata);
+
+	String getDisplayName(ItemStack itemStack);
+}

api/src/main/java/binnie/core/api/block/TileEntityMetadata.java

@@ -0,0 +1,125 @@
+package binnie.core.api.block;
+
+import com.google.common.base.Preconditions;
+
+import javax.annotation.Nullable;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.network.NetworkManager;
+import net.minecraft.network.play.server.SPacketUpdateTileEntity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.IBlockAccess;
+
+// TODO: move out of API
+public class TileEntityMetadata extends TileEntity {
+	private int meta;
+	private boolean droppedBlock;
+
+	public TileEntityMetadata() {
+		this.droppedBlock = false;
+	}
+
+	@Nullable
+	public static TileEntityMetadata getTile(final IBlockAccess world, final BlockPos pos) {
+		final TileEntity tile = world.getTileEntity(pos);
+		if (!(tile instanceof TileEntityMetadata)) {
+			return null;
+		}
+		return (TileEntityMetadata) tile;
+	}
+
+	public static ItemStack getItemStack(final Block block, final int damage) {
+		final Item item = Item.getItemFromBlock(block);
+		Preconditions.checkNotNull(item, "Could not get item for block %s", block);
+		final ItemStack itemStack = new ItemStack(item, 1, 0);
+		setItemDamage(itemStack, damage);
+		return itemStack;
+	}
+
+	public static void setItemDamage(final ItemStack item, final int i) {
+		item.setItemDamage((i < 16387) ? i : 16387);
+		final NBTTagCompound tag = new NBTTagCompound();
+		tag.setInteger("meta", i);
+		item.setTagCompound(tag);
+	}
+
+	public static int getItemDamage(final ItemStack item) {
+		if (item.hasTagCompound() && item.getTagCompound().hasKey("meta")) {
+			return item.getTagCompound().getInteger("meta");
+		}
+		return item.getItemDamage();
+	}
+
+	public static int getTileMetadata(final IBlockAccess world, final BlockPos pos) {
+		final TileEntityMetadata tile = getTile(world, pos);
+		return (tile == null) ? 0 : tile.getTileMetadata();
+	}
+
+	@Override
+	public boolean receiveClientEvent(final int id, final int type) {
+		if (id == 42) {
+			this.meta = type;
+			markDirty();
+		}
+		return true;
+	}
+
+	@Override
+	public NBTTagCompound getUpdateTag() {
+		return writeToNBT(new NBTTagCompound());
+	}
+
+	@Override
+	public void readFromNBT(final NBTTagCompound nbt) {
+		super.readFromNBT(nbt);
+		if(world!=null)
+			setTileMetadata(nbt.getInteger("meta"), world.isRemote);
+		else
+			this.meta = nbt.getInteger("meta");
+	}
+
+	@Override
+	public NBTTagCompound writeToNBT(final NBTTagCompound nbt) {
+		super.writeToNBT(nbt);
+		nbt.setInteger("meta", this.meta);
+		return nbt;
+	}
+
+	public int getTileMetadata() {
+		return this.meta;
+	}
+
+	public void setTileMetadata(final int meta, final boolean notify) {
+		if (this.meta != meta) {
+			this.meta = meta;
+			if (notify) {
+				IBlockState state = world.getBlockState(pos);
+				world.notifyBlockUpdate(pos, state, state, 3);
+			}
+		}
+	}
+
+	@Override
+	public void onDataPacket(NetworkManager net, SPacketUpdateTileEntity pkt) {
+		super.onDataPacket(net, pkt);
+		readFromNBT(pkt.getNbtCompound());
+	}
+
+	@Override
+	public SPacketUpdateTileEntity getUpdatePacket() {
+		return new SPacketUpdateTileEntity(pos, 0, getUpdateTag());
+	}
+
+	public boolean hasDroppedBlock() {
+		return this.droppedBlock;
+	}
+
+	public void dropBlock() {
+		this.droppedBlock = true;
+	}
+}

api/src/main/java/binnie/core/api/genetics/IBreedingSystem.java

@@ -0,0 +1,148 @@
+package binnie.core.api.genetics;
+
+import javax.annotation.Nullable;
+import java.util.Collection;
+import java.util.List;
+import java.util.TreeSet;
+
+import com.mojang.authlib.GameProfile;
+import forestry.api.core.ForestryEvent;
+import forestry.api.genetics.IAllele;
+import forestry.api.genetics.IAlleleSpecies;
+import forestry.api.genetics.IBreedingTracker;
+import forestry.api.genetics.IChromosomeType;
+import forestry.api.genetics.IClassification;
+import forestry.api.genetics.IIndividual;
+import forestry.api.genetics.IMutation;
+import forestry.api.genetics.ISpeciesRoot;
+import forestry.api.genetics.ISpeciesType;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public interface IBreedingSystem {
+	ISpeciesRoot getSpeciesRoot();
+
+	Collection<IAlleleSpecies> getAllSpecies();
+
+	Collection<IAlleleSpecies> getDiscoveredSpecies(World world, GameProfile player);
+
+	List<IClassification> getAllBranches();
+
+	Collection<IClassification> getDiscoveredBranches(World world, GameProfile player);
+
+	List<IMutation> getDiscoveredMutations(World world, GameProfile player);
+
+	List<IMutation> getResultantMutations(final IAlleleSpecies species);
+
+	List<IMutation> getFurtherMutations(final IAlleleSpecies species);
+
+	boolean isMutationDiscovered(IMutation mutation, World world, GameProfile name);
+
+	float getChance(IMutation mutation, EntityPlayer player, IAlleleSpecies firstSpecies, IAlleleSpecies secondSpecies);
+
+	String getAlleleName(final IChromosomeType chromosome, final IAllele allele);
+
+	String getChromosomeName(final IChromosomeType chromo);
+
+	String getChromosomeShortName(final IChromosomeType chromo);
+
+	@Nullable
+	IIndividual getConversion(final ItemStack stack);
+
+	ItemStack getConversionStack(final ItemStack stack);
+
+	@Nullable
+	IIndividual getIndividual(String uid);
+
+	void calculateArrays();
+
+	void addExtraAlleles(final IChromosomeType p0, final TreeSet<IAllele> p1);
+
+	String getDescriptor();
+
+	String getIdent();
+
+	ItemStack getItemStackRepresentitive();
+
+	int getColour();
+
+	int getDiscoveredSpeciesCount();
+
+	int getTotalSpeciesCount();
+
+	float getDiscoveredSpeciesPercentage();
+
+	int getTotalSecretCount();
+
+	int getDiscoveredSecretCount();
+
+	float getDiscoveredBranchPercentage();
+
+	int getTotalBranchCount();
+
+	int getDiscoveredBranchCount();
+
+	String getEpitome();
+
+	String getEpitome(float discoveredPercentage);
+
+	Collection<IMutation> getAllMutations();
+
+	void calculateAlleles(ISpeciesRoot speciesRoot);
+
+	void calculateBranches(ISpeciesRoot speciesRoot);
+
+	void calculateMutations(ISpeciesRoot speciesRoot);
+
+	boolean isBlacklisted(IAllele allele);
+
+	boolean isMutationDiscovered(IMutation mutation, IBreedingTracker tracker);
+
+	boolean isSpeciesDiscovered(IAlleleSpecies species, World world, GameProfile name);
+
+	boolean isSpeciesDiscovered(IAlleleSpecies species, IBreedingTracker tracker);
+
+	boolean isSecret(IAlleleSpecies species);
+
+	boolean isSecret(IClassification branch);
+
+	Collection<IClassification> getDiscoveredBranches(IBreedingTracker tracker);
+
+	Collection<IAlleleSpecies> getDiscoveredSpecies(IBreedingTracker tracker);
+
+	@SideOnly(Side.CLIENT)
+	TextureAtlasSprite getUndiscoveredIcon();
+
+	@SideOnly(Side.CLIENT)
+	TextureAtlasSprite getDiscoveredIcon();
+
+	Class<? extends IBreedingTracker> getTrackerClass();
+
+	@SubscribeEvent
+	void onSyncBreedingTracker(ForestryEvent.SyncedBreedingTracker event);
+
+	void syncTracker(IBreedingTracker tracker);
+
+	void onSyncBreedingTracker(IBreedingTracker tracker);
+
+	String getName();
+
+	boolean isDNAManipulable(ItemStack stack);
+
+	boolean isDNAManipulable(ISpeciesType type);
+
+	IIndividual getDefaultIndividual();
+
+	ISpeciesType getDefaultType();
+
+	ISpeciesType[] getActiveTypes();
+
+	Collection<IChromosomeType> getActiveKaryotype();
+
+	ItemStack getDefaultMember(String uid);
+}

api/src/main/java/binnie/core/api/package-info.java

@@ -0,0 +1,7 @@
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+package binnie.core.api;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import mcp.MethodsReturnNonnullByDefault;

api/src/main/java/binnie/extrabees/api/ExtraBeesAPI.java

@@ -0,0 +1,7 @@
+package binnie.extrabees.api;
+
+import binnie.core.api.genetics.IBreedingSystem;
+
+public class ExtraBeesAPI {
+	public static IBreedingSystem beeBreedingSystem;
+}

api/src/main/java/binnie/extratrees/api/ICarpentryInterface.java

@@ -0,0 +1,30 @@
+package binnie.extratrees.api;
+
+import javax.annotation.Nullable;
+import java.util.Collection;
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+
+public interface ICarpentryInterface {
+	boolean registerCarpentryWood(final int index, final IDesignMaterial material);
+
+	int getCarpentryWoodIndex(final IDesignMaterial material);
+
+	IDesignMaterial getWoodMaterial(final int p0);
+
+	boolean registerDesign(final int p0, final IDesign p1);
+
+	int getDesignIndex(final IDesign p0);
+
+	IDesign getDesign(final int p0);
+
+	@Nullable
+	IDesignMaterial getWoodMaterial(final ItemStack stack);
+
+	boolean registerDesignCategory(final IDesignCategory p0);
+
+	Collection<IDesignCategory> getAllDesignCategories();
+
+	List<IDesign> getSortedDesigns();
+}

api/src/main/java/binnie/extratrees/api/IDesignCategory.java

@@ -7,7 +7,7 @@ public interface IDesignCategory {
 
 	List<IDesign> getDesigns();
 
-	void addDesign(IDesign design);
+	void addDesign(final IDesign p0);
 
 	String getId();
 }

api/src/main/java/binnie/extratrees/api/IDesignMaterial.java

@@ -0,0 +1,13 @@
+package binnie.extratrees.api;
+
+import net.minecraft.item.ItemStack;
+
+public interface IDesignMaterial {
+	ItemStack getStack();
+
+	ItemStack getStack(boolean fireproof);
+
+	String getDesignMaterialName();
+
+	int getColour();
+}

api/src/main/java/binnie/extratrees/api/IDesignSystem.java

@@ -0,0 +1,36 @@
+package binnie.extratrees.api;
+
+import javax.annotation.Nullable;
+
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.item.ItemStack;
+
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public interface IDesignSystem {
+	@Nullable
+	@SideOnly(Side.CLIENT)
+	TextureAtlasSprite getPrimarySprite(final IPattern pattern);
+
+	@Nullable
+	@SideOnly(Side.CLIENT)
+	TextureAtlasSprite getSecondarySprite(final IPattern pattern);
+
+	@SideOnly(Side.CLIENT)
+	void registerSprites();
+
+	IDesignMaterial getDefaultMaterial();
+
+	@Nullable
+	IDesignMaterial getMaterial(final int p0);
+
+	int getMaterialIndex(final IDesignMaterial p0);
+
+	IDesignMaterial getDefaultMaterial2();
+
+	ItemStack getAdhesive();
+
+	@Nullable
+	IDesignMaterial getMaterial(final ItemStack p0);
+}

api/src/main/java/binnie/extratrees/api/ILayout.java

@@ -0,0 +1,28 @@
+package binnie.extratrees.api;
+
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public interface ILayout {
+	IPattern getPattern();
+
+	boolean isInverted();
+
+	ILayout rotateRight();
+
+	ILayout rotateLeft();
+
+	ILayout flipHorizontal();
+
+	ILayout flipVertical();
+
+	ILayout invert();
+
+	@SideOnly(Side.CLIENT)
+	TextureAtlasSprite getPrimarySprite(IDesignSystem system);
+
+	@SideOnly(Side.CLIENT)
+	TextureAtlasSprite getSecondarySprite(IDesignSystem system);
+}

api/src/main/java/binnie/extratrees/api/IPattern.java

@@ -0,0 +1,22 @@
+package binnie.extratrees.api;
+
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import forestry.api.core.ISpriteRegister;
+
+public interface IPattern extends ISpriteRegister {
+	@SideOnly(Side.CLIENT)
+	TextureAtlasSprite getPrimarySprite(IDesignSystem system);
+
+	@SideOnly(Side.CLIENT)
+	TextureAtlasSprite getSecondarySprite(IDesignSystem system);
+
+	ILayout getRotation();
+
+	ILayout getHorizontalFlip();
+
+	int getIndex();
+}

api/src/main/java/binnie/extratrees/api/IToolHammer.java

@@ -0,0 +1,10 @@
+package binnie.extratrees.api;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+
+public interface IToolHammer {
+	boolean isActive(final ItemStack p0);
+
+	void onHammerUsed(final ItemStack p0, final EntityPlayer p1);
+}

api/src/main/java/binnie/extratrees/api/carpentry/DesignerManager.java

@@ -0,0 +1,29 @@
+package binnie.extratrees.api.carpentry;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import binnie.extratrees.api.IDesignSystem;
+
+public final class DesignerManager {
+	public static DesignerManager instance = new DesignerManager();
+
+	private final List<IDesignSystem> systems;
+
+	private DesignerManager() {
+		this.systems = new ArrayList<>();
+	}
+
+	public void registerDesignSystem(final IDesignSystem system) {
+		this.systems.add(system);
+	}
+
+	public Collection<IDesignSystem> getDesignSystems() {
+		return this.systems;
+	}
+
+	public void addDesignSystem(final IDesignSystem system) {
+		this.systems.add(system);
+	}
+}

api/src/main/java/binnie/extratrees/api/carpentry/EnumPattern.java

@@ -1,11 +1,17 @@
-package binnie.extratrees.carpentry;
+package binnie.extratrees.api.carpentry;
+
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import forestry.api.core.ITextureManager;
 
 import binnie.extratrees.api.IDesignSystem;
 import binnie.extratrees.api.ILayout;
 import binnie.extratrees.api.IPattern;
-import net.minecraft.client.renderer.texture.IIconRegister;
-import net.minecraft.util.IIcon;
 
+// TODO: move out of API
 public enum EnumPattern implements IPattern {
 	Blank,
 	Octagon,
@@ -284,26 +290,26 @@ public enum EnumPattern implements IPattern {
 		EnumPattern.OverlappedSplitBarred2.setLeftRotation(EnumPattern.OverlappedSplitBarred, false);
 	}
 
-	protected ILayout leftRotation;
-	protected ILayout horizontalFlip;
+	ILayout leftRotation;
+	ILayout horizontalFlip;
 
 	EnumPattern() {
-		leftRotation = Layout.get(this, false);
-		horizontalFlip = Layout.get(this, false);
+		this.leftRotation = Layout.get(this, false);
+		this.horizontalFlip = Layout.get(this, false);
 	}
 
-	static void setupStripedPattern(EnumPattern vert, EnumPattern hori) {
+	static void setupStripedPattern(final EnumPattern vert, final EnumPattern hori) {
 		vert.setLeftRotation(hori, true);
 		hori.setLeftRotation(vert, false);
 		vert.setHorizontalFlip(vert, true);
 	}
 
-	static void setupChequeredPattern(EnumPattern cheq) {
+	static void setupChequeredPattern(final EnumPattern cheq) {
 		cheq.setLeftRotation(cheq, true);
 		cheq.setHorizontalFlip(cheq, true);
 	}
 
-	static void setupCornerPattern(EnumPattern tl, EnumPattern tr, EnumPattern br, EnumPattern bl) {
+	static void setupCornerPattern(final EnumPattern tl, final EnumPattern tr, final EnumPattern br, final EnumPattern bl) {
 		tl.setLeftRotation(bl, false);
 		tr.setLeftRotation(tl, false);
 		br.setLeftRotation(tr, false);
@@ -312,24 +318,24 @@ public enum EnumPattern implements IPattern {
 		bl.setHorizontalFlip(br, false);
 	}
 
-	static void setupInvert2Rot(EnumPattern a, EnumPattern b) {
+	static void setupInvert2Rot(final EnumPattern a, final EnumPattern b) {
 		a.setLeftRotation(b, true);
 		b.setLeftRotation(a, false);
 		a.setHorizontalFlip(b, false);
 	}
 
-	static void set2Rotation(EnumPattern a, EnumPattern b) {
+	static void set2Rotation(final EnumPattern a, final EnumPattern b) {
 		a.setLeftRotation(b, false);
 		b.setLeftRotation(a, false);
 		a.setHorizontalFlip(b, false);
 	}
 
-	static void setupBarredPattern(EnumPattern vert, EnumPattern hori) {
+	static void setupBarredPattern(final EnumPattern vert, final EnumPattern hori) {
 		vert.setLeftRotation(hori, false);
 		hori.setLeftRotation(vert, false);
 	}
 
-	static void setupEdgedPattern(EnumPattern l, EnumPattern t, EnumPattern r, EnumPattern b) {
+	static void setupEdgedPattern(final EnumPattern l, final EnumPattern t, final EnumPattern r, final EnumPattern b) {
 		l.setLeftRotation(b, false);
 		t.setLeftRotation(l, false);
 		r.setLeftRotation(t, false);
@@ -337,13 +343,13 @@ public enum EnumPattern implements IPattern {
 		l.setHorizontalFlip(r, false);
 	}
 
-	static void setupDiagonalPattern(EnumPattern a, EnumPattern b) {
+	static void setupDiagonalPattern(final EnumPattern a, final EnumPattern b) {
 		a.setLeftRotation(b, false);
 		b.setLeftRotation(a, false);
 		a.setHorizontalFlip(b, false);
 	}
 
-	static void setupBarredPattern(EnumPattern l, EnumPattern t, EnumPattern r, EnumPattern b) {
+	static void setupBarredPattern(final EnumPattern l, final EnumPattern t, final EnumPattern r, final EnumPattern b) {
 		l.setLeftRotation(b, false);
 		t.setLeftRotation(l, false);
 		r.setLeftRotation(t, false);
@@ -351,52 +357,59 @@ public enum EnumPattern implements IPattern {
 		l.setHorizontalFlip(r, false);
 	}
 
-	static void setupTSectionPattern(EnumPattern l, EnumPattern t, EnumPattern r, EnumPattern b) {
+	static void setupTSectionPattern(final EnumPattern l, final EnumPattern t, final EnumPattern r, final EnumPattern b) {
 		setupEdgedPattern(l, t, r, b);
 	}
 
-	private static void setupRotation(EnumPattern t, EnumPattern r, EnumPattern b, EnumPattern l) {
+	private static void setupRotation(final EnumPattern t, final EnumPattern r, final EnumPattern b, final EnumPattern l) {
 		setupEdgedPattern(l, t, r, b);
 	}
 
+	@SideOnly(Side.CLIENT)
 	@Override
-	public IIcon getPrimaryIcon(IDesignSystem system) {
-		return system.getPrimaryIcon(this);
+	public TextureAtlasSprite getPrimarySprite(IDesignSystem system) {
+		return system.getPrimarySprite(this);
 	}
 
-	private void setHorizontalFlip(EnumPattern pattern, boolean inverted) {
-		horizontalFlip = Layout.get(pattern, inverted);
+	private void setHorizontalFlip(final EnumPattern pattern, final boolean inverted) {
+		this.horizontalFlip = Layout.get(pattern, inverted);
 		pattern.horizontalFlip = Layout.get(this, inverted);
 	}
 
+	@SideOnly(Side.CLIENT)
 	@Override
-	public IIcon getSecondaryIcon(IDesignSystem system) {
-		return system.getSecondaryIcon(this);
+	public TextureAtlasSprite getSecondarySprite(IDesignSystem system) {
+		return system.getSecondarySprite(this);
 	}
 
 	@Override
 	public ILayout getRotation() {
-		return leftRotation;
+		return this.leftRotation;
 	}
 
 	@Override
 	public ILayout getHorizontalFlip() {
-		return horizontalFlip;
-	}
-
-	protected void setLeftRotation(EnumPattern pattern, boolean inverted) {
-		leftRotation = Layout.get(pattern, inverted);
+		return this.horizontalFlip;
 	}
 
 	@Override
-	public void registerIcons(IIconRegister register) {
+	public int getIndex() {
+		return ordinal();
+	}
+
+	protected void setLeftRotation(final EnumPattern pattern, final boolean inverted) {
+		this.leftRotation = Layout.get(pattern, inverted);
+	}
+
+	@Override
+	public void registerSprites(ITextureManager manager) {
 	}
 
 	public ILayout layout() {
-		return layout(false);
+		return this.layout(false);
 	}
 
-	public ILayout layout(boolean invert) {
+	public ILayout layout(final boolean invert) {
 		return Layout.get(this, invert);
 	}
 }

api/src/main/java/binnie/extratrees/api/carpentry/IBlockDesign.java

@@ -0,0 +1,7 @@
+package binnie.extratrees.api.carpentry;
+
+import binnie.extratrees.api.IDesignSystem;
+
+public interface IBlockDesign {
+	IDesignSystem getDesignSystem();
+}

api/src/main/java/binnie/extratrees/api/carpentry/IBlockDesignProperties.java

@@ -0,0 +1,4 @@
+package binnie.extratrees.api.carpentry;
+
+public interface IBlockDesignProperties {
+}

api/src/main/java/binnie/extratrees/api/carpentry/Layout.java

@@ -0,0 +1,79 @@
+package binnie.extratrees.api.carpentry;
+
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import binnie.extratrees.api.IDesignSystem;
+import binnie.extratrees.api.ILayout;
+import binnie.extratrees.api.IPattern;
+
+public class Layout implements ILayout {
+	IPattern pattern;
+	boolean inverted;
+
+	private Layout(final IPattern pattern, final boolean inverted) {
+		this.pattern = pattern;
+		this.inverted = inverted;
+	}
+
+	public static ILayout get(final IPattern pattern, final boolean inverted) {
+		return new Layout(pattern, inverted);
+	}
+
+	public static ILayout get(final IPattern pattern) {
+		return new Layout(pattern, false);
+	}
+
+	@Override
+	public IPattern getPattern() {
+		return this.pattern;
+	}
+
+	@Override
+	public boolean isInverted() {
+		return this.inverted;
+	}
+
+	ILayout newLayout(final ILayout newLayout) {
+		return new Layout(newLayout.getPattern(), this.inverted ^ newLayout.isInverted());
+	}
+
+	@Override
+	public ILayout rotateRight() {
+		return this.rotateLeft().rotateLeft().rotateLeft();
+	}
+
+	@Override
+	public ILayout rotateLeft() {
+		return this.newLayout(this.pattern.getRotation());
+	}
+
+	@Override
+	public ILayout flipHorizontal() {
+		return this.newLayout(this.pattern.getHorizontalFlip());
+	}
+
+	@Override
+	public ILayout flipVertical() {
+		return this.newLayout(this.pattern.getHorizontalFlip().rotateLeft().rotateLeft());
+	}
+
+	@SideOnly(Side.CLIENT)
+	@Override
+	public TextureAtlasSprite getPrimarySprite(IDesignSystem system) {
+		return this.inverted ? this.pattern.getSecondarySprite(system) : this.pattern.getPrimarySprite(system);
+	}
+
+	@SideOnly(Side.CLIENT)
+	@Override
+	public TextureAtlasSprite getSecondarySprite(IDesignSystem system) {
+		return this.inverted ? this.pattern.getPrimarySprite(system) : this.pattern.getSecondarySprite(system);
+	}
+
+	@Override
+	public ILayout invert() {
+		return new Layout(this.pattern, !this.inverted);
+	}
+}

api/src/main/java/binnie/extratrees/api/package-info.java

@@ -0,0 +1,7 @@
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+package binnie.extratrees.api;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import mcp.MethodsReturnNonnullByDefault;

api/src/main/java/binnie/extratrees/api/recipes/ExtraTreesRecipeManager.java

@@ -0,0 +1,15 @@
+package binnie.extratrees.api.recipes;
+
+import javax.annotation.Nullable;
+
+public class ExtraTreesRecipeManager {
+
+	@Nullable
+	public static IBreweryManager breweryManager;
+	@Nullable
+	public static ILumbermillManager lumbermillManager;
+	@Nullable
+	public static IFruitPressManager fruitPressManager;
+	@Nullable
+	public static IDistilleryManager distilleryManager;
+}

api/src/main/java/binnie/extratrees/api/recipes/IBreweryCrafting.java

@@ -0,0 +1,22 @@
+package binnie.extratrees.api.recipes;
+
+import javax.annotation.Nullable;
+
+import net.minecraft.item.ItemStack;
+
+import net.minecraftforge.fluids.FluidStack;
+
+public interface IBreweryCrafting {
+
+	@Nullable
+	FluidStack getInputFluid();
+
+	@Nullable
+	ItemStack[] getInputGrains();
+
+	ItemStack getIngredient();
+
+	ItemStack getYeast();
+
+	boolean hasInputGrainsEmpty();
+}

api/src/main/java/binnie/extratrees/api/recipes/IBreweryManager.java

@@ -0,0 +1,22 @@
+package binnie.extratrees.api.recipes;
+
+import javax.annotation.Nullable;
+
+import net.minecraft.item.ItemStack;
+
+import net.minecraftforge.fluids.FluidStack;
+
+import binnie.core.api.ICraftingManager;
+
+public interface IBreweryManager extends ICraftingManager<IBreweryRecipe> {
+
+	void addRecipe(FluidStack input, FluidStack output);
+
+	void addRecipe(FluidStack input, FluidStack output, ItemStack yeast);
+
+	void addGrainRecipe(String grainOreName, FluidStack output);
+
+	void addGrainRecipe(String grainOreName, FluidStack output, String ingredientOreName);
+
+	void addGrainRecipe(String grainOreName, FluidStack output, @Nullable String ingredientOreName, ItemStack yeast);
+}

api/src/main/java/binnie/extratrees/api/recipes/IBreweryRecipe.java

@@ -0,0 +1,29 @@
+package binnie.extratrees.api.recipes;
+
+import javax.annotation.Nullable;
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+
+import net.minecraftforge.fluids.FluidStack;
+
+import binnie.core.api.IBinnieRecipe;
+
+public interface IBreweryRecipe extends IBinnieRecipe {
+	@Nullable
+	FluidStack getOutput(IBreweryCrafting crafting);
+
+	FluidStack getInput();
+
+	FluidStack getOutput();
+
+	boolean isIngredient(ItemStack itemStack);
+
+	List<ItemStack> getIngredients();
+
+	boolean isGrain(ItemStack itemStack);
+
+	List<ItemStack> getGrains();
+
+	ItemStack getYeast();
+}

api/src/main/java/binnie/extratrees/api/recipes/IDistilleryManager.java

@@ -0,0 +1,14 @@
+package binnie.extratrees.api.recipes;
+
+import java.util.Collection;
+
+import net.minecraftforge.fluids.FluidStack;
+
+import binnie.core.api.ICraftingManager;
+
+public interface IDistilleryManager extends ICraftingManager<IDistilleryRecipe> {
+
+	void addRecipe(FluidStack input, FluidStack output, int level);
+
+	Collection<IDistilleryRecipe> recipes(int level);
+}

api/src/main/java/binnie/extratrees/api/recipes/IDistilleryRecipe.java

@@ -0,0 +1,14 @@
+package binnie.extratrees.api.recipes;
+
+import net.minecraftforge.fluids.FluidStack;
+
+import binnie.core.api.IBinnieRecipe;
+
+public interface IDistilleryRecipe extends IBinnieRecipe {
+
+	FluidStack getInput();
+
+	FluidStack getOutput();
+	
+	int getLevel();
+}

api/src/main/java/binnie/extratrees/api/recipes/IFruitPressManager.java

@@ -0,0 +1,12 @@
+package binnie.extratrees.api.recipes;
+
+import net.minecraft.item.ItemStack;
+
+import net.minecraftforge.fluids.FluidStack;
+
+import binnie.core.api.ICraftingManager;
+
+public interface IFruitPressManager extends ICraftingManager<IFruitPressRecipe> {
+
+	void addRecipe(ItemStack input, FluidStack output);
+}

api/src/main/java/binnie/extratrees/api/recipes/IFruitPressRecipe.java

@@ -0,0 +1,14 @@
+package binnie.extratrees.api.recipes;
+
+import net.minecraft.item.ItemStack;
+
+import net.minecraftforge.fluids.FluidStack;
+
+import binnie.core.api.IBinnieRecipe;
+
+public interface IFruitPressRecipe extends IBinnieRecipe {
+
+	ItemStack getInput();
+
+	FluidStack getOutput();
+}

api/src/main/java/binnie/extratrees/api/recipes/ILumbermillManager.java

@@ -0,0 +1,10 @@
+package binnie.extratrees.api.recipes;
+
+import net.minecraft.item.ItemStack;
+
+import binnie.core.api.ICraftingManager;
+
+public interface ILumbermillManager extends ICraftingManager<ILumbermillRecipe> {
+
+	void addRecipe(ItemStack input, ItemStack output);
+}

api/src/main/java/binnie/extratrees/api/recipes/ILumbermillRecipe.java

@@ -0,0 +1,12 @@
+package binnie.extratrees.api.recipes;
+
+import net.minecraft.item.ItemStack;
+
+import binnie.core.api.IBinnieRecipe;
+
+public interface ILumbermillRecipe extends IBinnieRecipe {
+
+	ItemStack getOutput();
+
+	ItemStack getInput();
+}

api/src/main/java/binnie/extratrees/api/recipes/package-info.java

@@ -0,0 +1,7 @@
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+package binnie.extratrees.api.recipes;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import mcp.MethodsReturnNonnullByDefault;

api/src/main/java/binnie/genetics/api/IGene.java

@@ -0,0 +1,21 @@
+package binnie.genetics.api;
+
+import net.minecraft.nbt.NBTTagCompound;
+
+import forestry.api.core.INbtReadable;
+import forestry.api.core.INbtWritable;
+import forestry.api.genetics.IAllele;
+import forestry.api.genetics.IChromosomeType;
+import forestry.api.genetics.ISpeciesRoot;
+
+public interface IGene extends INbtReadable, INbtWritable {
+	IChromosomeType getChromosome();
+
+	String getName();
+
+	ISpeciesRoot getSpeciesRoot();
+
+	IAllele getAllele();
+
+	NBTTagCompound getNBTTagCompound();
+}

api/src/main/java/binnie/genetics/api/IItemChargeable.java

@@ -0,0 +1,16 @@
+package binnie.genetics.api;
+
+import javax.annotation.Nullable;
+
+import net.minecraft.item.ItemStack;
+
+import forestry.api.genetics.ISpeciesRoot;
+
+public interface IItemChargeable {
+	int getCharges(ItemStack stack);
+
+	int getMaxCharges(ItemStack stack);
+
+	@Nullable
+	ISpeciesRoot getSpeciesRoot(ItemStack stack);
+}

api/src/main/java/binnie/genetics/api/IItemSerum.java

@@ -0,0 +1,14 @@
+package binnie.genetics.api;
+
+import javax.annotation.Nullable;
+
+import net.minecraft.item.ItemStack;
+
+public interface IItemSerum extends IItemChargeable {
+	IGene[] getGenes(ItemStack stack);
+
+	@Nullable
+	IGene getGene(ItemStack stack, int chromosome);
+
+	ItemStack addGene(ItemStack stack, IGene gene);
+}

api/src/main/java/binnie/genetics/api/package-info.java

@@ -0,0 +1,7 @@
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+package binnie.genetics.api;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import mcp.MethodsReturnNonnullByDefault;

botany/build.gradle

@@ -0,0 +1,9 @@
+archivesBaseName = 'botany-' + mcversion
+
+dependencies {
+	compile project(":api")
+	compile project(":core")
+
+	// TODO: remove
+	compile project(":extratrees")
+}

botany/src/main/java/binnie/botany/Botany.java

@@ -0,0 +1,105 @@
+package binnie.botany;
+
+import binnie.botany.genetics.FlowerBreedingSystem;
+import binnie.core.Binnie;
+import binnie.core.api.genetics.IBreedingSystem;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.SidedProxy;
+import net.minecraftforge.fml.common.event.FMLInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
+
+import binnie.core.Constants;
+import binnie.botany.gui.BotanyGUI;
+import binnie.botany.network.PacketID;
+import binnie.botany.proxy.Proxy;
+import binnie.core.BinnieCore;
+import binnie.core.gui.IBinnieGUID;
+import binnie.core.network.BinniePacketHandler;
+import binnie.core.network.IPacketID;
+import binnie.core.proxy.IProxyCore;
+import binnie.core.modules.BlankModuleContainer;
+
+@Mod(
+	modid = Constants.BOTANY_MOD_ID,
+	name = "Binnie's Botany",
+	dependencies = "required-after:" + Constants.CORE_MOD_ID
+)
+public class Botany extends BlankModuleContainer {
+	public static final float AGE_CHANCE = 0.2f;
+
+	@SuppressWarnings("NullableProblems")
+	@Mod.Instance(Constants.BOTANY_MOD_ID)
+	public static Botany instance;
+	@SuppressWarnings("NullableProblems")
+	@SidedProxy(clientSide = "binnie.botany.proxy.ProxyClient", serverSide = "binnie.botany.proxy.ProxyServer")
+	public static Proxy proxy;
+	public static IBreedingSystem flowerBreedingSystem;
+
+	@Mod.EventHandler
+	public void preInit(FMLPreInitializationEvent evt) {
+		super.preInit(evt);
+		flowerBreedingSystem = new FlowerBreedingSystem();
+		Binnie.GENETICS.registerBreedingSystem(flowerBreedingSystem);
+	}
+
+	@Mod.EventHandler
+	public void init(FMLInitializationEvent evt) {
+		super.init(evt);
+	}
+
+	@Mod.EventHandler
+	public void postInit(FMLPostInitializationEvent evt) {
+		super.postInit(evt);
+	}
+
+	@Override
+	protected void registerModules() {
+	}
+
+	@Override
+	public IBinnieGUID[] getGUIDs() {
+		return BotanyGUI.values();
+	}
+
+	@Override
+	public Class<?>[] getConfigs() {
+		return new Class[0];
+	}
+
+	@Override
+	public IPacketID[] getPacketIDs() {
+		return PacketID.values();
+	}
+
+	@Override
+	public IProxyCore getProxy() {
+		return Botany.proxy;
+	}
+
+	@Override
+	public String getChannel() {
+		return "BOT";
+	}
+
+	@Override
+	public String getModID() {
+		return Constants.BOTANY_MOD_ID;
+	}
+
+	@Override
+	protected Class<? extends BinniePacketHandler> getPacketHandler() {
+		return PacketHandler.class;
+	}
+
+	@Override
+	public boolean isAvailable() {
+		return BinnieCore.isBotanyActive();
+	}
+
+	public static class PacketHandler extends BinniePacketHandler {
+		public PacketHandler() {
+			super(Botany.instance);
+		}
+	}
+}

botany/src/main/java/binnie/botany/CreativeTabBotany.java

@@ -0,0 +1,36 @@
+package binnie.botany;
+
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import binnie.core.util.I18N;
+
+public class CreativeTabBotany extends CreativeTabs {
+	public static CreativeTabs instance = new CreativeTabBotany();
+
+	public CreativeTabBotany() {
+		super("Botany");
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public String getTranslatedTabLabel() {
+		return getTabLabel();
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public String getTabLabel() {
+		return I18N.localise("botany.tab.botany");
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public ItemStack getTabIconItem() {
+		return new ItemStack(Blocks.RED_FLOWER, 1, 5);
+	}
+}

botany/src/main/java/binnie/botany/GardeningManager.java

@@ -0,0 +1,274 @@
+package binnie.botany;
+
+import javax.annotation.Nullable;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+import net.minecraft.world.biome.Biome;
+
+import forestry.api.climate.IClimateInfo;
+import forestry.api.core.EnumTemperature;
+import forestry.api.core.ForestryAPI;
+
+import binnie.botany.api.gardening.EnumAcidity;
+import binnie.botany.api.gardening.EnumFertiliserType;
+import binnie.botany.api.gardening.EnumMoisture;
+import binnie.botany.api.gardening.EnumSoilType;
+import binnie.botany.api.gardening.IBlockSoil;
+import binnie.botany.api.gardening.IGardeningManager;
+import binnie.botany.api.genetics.IFlower;
+import binnie.botany.api.genetics.IFlowerGenome;
+import binnie.botany.blocks.BlockPlant;
+import binnie.botany.blocks.BlockSoil;
+import binnie.botany.modules.ModuleGardening;
+import binnie.core.util.OreDictionaryUtil;
+
+public class GardeningManager implements IGardeningManager {
+	private final Map<EnumFertiliserType, Map<ItemStack, Integer>> fertilisers = new LinkedHashMap<>();
+
+	public GardeningManager() {
+		for(EnumFertiliserType type : EnumFertiliserType.values()){
+			fertilisers.put(type, new LinkedHashMap<>());
+		}
+	}
+
+	@Override
+	public boolean isSoil(Block block) {
+		return block instanceof IBlockSoil;
+	}
+
+	@Override
+	public boolean isSoil(Item item) {
+		return item instanceof ItemBlock && isSoil(((ItemBlock) item).getBlock());
+	}
+
+	@Override
+	public boolean isSoil(ItemStack item) {
+		return isSoil(item.getItem());
+	}
+
+	@Override
+	public EnumMoisture getNaturalMoisture(World world, BlockPos pos) {
+		float moisture = getBiomeMoisture(world, pos);
+
+		for (int offsetX = -1; offsetX < 2; ++offsetX) {
+			for (int offsetY = -1; offsetY < 2; ++offsetY) {
+				if (offsetX != 0 || offsetY != 0) {
+					Block block = world.getBlockState(pos.add(offsetX, 0, offsetY)).getBlock();
+					if (block == Blocks.SAND) {
+						moisture -= 1.5;
+					} else if (block == Blocks.WATER) {
+						moisture += 1.5;
+					}
+				}
+			}
+		}
+
+		if (world.isRainingAt(pos.up())) {
+			moisture += 1.5;
+		}
+
+		for (int offsetX = -1; offsetX < 2; ++offsetX) {
+			for (int offsetY = -1; offsetY < 2; ++offsetY) {
+				if (offsetX != 0 || offsetY != 0) {
+					Block block = world.getBlockState(pos.add(offsetX, 0, offsetY)).getBlock();
+					if (block == Blocks.GRAVEL && moisture > 0.0f) {
+						moisture *= 0.4f;
+					}
+				}
+			}
+		}
+		return EnumMoisture.getFromValue(moisture);
+	}
+
+	@Override
+	public EnumAcidity getNaturalPH(World world, BlockPos pos) {
+		float acidity = getBiomePH(world, pos);
+		return EnumAcidity.getFromValue(acidity);
+	}
+
+	@Override
+	public float getBiomeMoisture(World world, BlockPos pos) {
+		IClimateInfo info = ForestryAPI.climateManager.getInfo(world, pos);
+		double humidity = info.getHumidity();
+		double temperature = info.getTemperature();
+		double moisture = 3.2 * (humidity - 0.5) - 0.4 * (1.0 + temperature + 0.5 * temperature * temperature) + 1.1 - 1.6 * (temperature - 0.9) * (temperature - 0.9) - 0.002 * (pos.getY() - 64);
+		return (float) ((moisture == 0.0) ? moisture : ((moisture < 0.0) ? (-Math.sqrt(moisture * moisture)) : Math.sqrt(moisture * moisture)));
+	}
+
+	@Override
+	public float getBiomePH(World world, BlockPos pos) {
+		IClimateInfo info = ForestryAPI.climateManager.getInfo(world, pos);
+		double humidity = info.getHumidity();
+		double temperature = info.getTemperature();
+		return (float) (-3.0 * (humidity - 0.5) + 0.5 * (temperature - 0.699999988079071) * (temperature - 0.699999988079071) + 0.02f * (pos.getY() - 64) - 0.15000000596046448);
+	}
+
+	@Override
+	public IBlockState getSoil(EnumSoilType soil, boolean weedKill, EnumMoisture moisture, EnumAcidity acidity) {
+		IBlockState blockState = getSoilBlock(soil, weedKill).getDefaultState();
+		return blockState.withProperty(BlockSoil.MOISTURE, moisture).withProperty(BlockSoil.ACIDITY, acidity);
+	}
+
+	@Override
+	public void plantSoil(World world, BlockPos pos, EnumSoilType soil, EnumMoisture moisture, EnumAcidity acidity) {
+		IBlockState blockState = getSoil(soil, false, moisture, acidity);
+		world.setBlockState(pos, blockState, 2);
+	}
+
+	public Map<EnumFertiliserType, Map<ItemStack, Integer>> getFertilisers() {
+		return fertilisers;
+	}
+
+	@Override
+	public Collection<ItemStack> getFertilisers(EnumFertiliserType type) {
+	Set<ItemStack> items = fertilisers.get(type).keySet();
+		return Collections.unmodifiableSet(items);
+	}
+
+	@Override
+	public boolean isFertiliser(EnumFertiliserType type, ItemStack stack) {
+		Collection<ItemStack> fertilisers = getFertilisers(type);
+		for (ItemStack fertiliser : fertilisers) {
+			if (!fertiliser.isEmpty() && fertiliser.isItemEqual(stack)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	@Override
+	public void registerFertiliser(EnumFertiliserType type, ItemStack stack, int strength) {
+		fertilisers.get(type).put(stack, strength);
+	}
+
+	@Override
+	public int getFertiliserStrength(ItemStack stack) {
+		for(EnumFertiliserType type : EnumFertiliserType.values()) {
+			for (Map.Entry<ItemStack, Integer> entry : fertilisers.get(type).entrySet()) {
+				if (entry.getKey().isItemEqual(stack)) {
+					return entry.getValue();
+				}
+			}
+		}
+		return 1;
+	}
+
+	@Override
+	public boolean onFertiliseSoil(ItemStack heldItem, IBlockSoil soil, World world, BlockPos pos, EntityPlayer player) {
+		int fertiliserStrength = getFertiliserStrength(heldItem);
+		if (isFertiliser(EnumFertiliserType.NUTRIENT, heldItem) && soil.getType(world, pos) != EnumSoilType.FLOWERBED) {
+			EnumSoilType type = soil.getType(world, pos);
+			int next = Math.min(type.ordinal() + fertiliserStrength, 2);
+			if (soil.fertilise(world, pos, EnumSoilType.values()[next])) {
+				if(!player.capabilities.isCreativeMode) {
+					heldItem.shrink(1);
+				}
+				return true;
+			}
+		}
+
+		if (isFertiliser(EnumFertiliserType.ACID, heldItem) && soil.getPH(world, pos) != EnumAcidity.ACID) {
+			EnumAcidity pH = soil.getPH(world, pos);
+			int next = Math.max(pH.ordinal() - fertiliserStrength, 0);
+			if (soil.setPH(world, pos, EnumAcidity.values()[next])) {
+				if(!player.capabilities.isCreativeMode) {
+					heldItem.shrink(1);
+				}
+				return true;
+			}
+		}
+
+		if (isFertiliser(EnumFertiliserType.ALKALINE, heldItem) && soil.getPH(world, pos) != EnumAcidity.ALKALINE) {
+			EnumAcidity pH = soil.getPH(world, pos);
+			int next = Math.min(pH.ordinal() + fertiliserStrength, 2);
+			if (soil.setPH(world, pos, EnumAcidity.values()[next])) {
+				if(!player.capabilities.isCreativeMode) {
+					heldItem.shrink(1);
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+
+	@Override
+	public boolean canTolerate(@Nullable IFlower flower, World world, BlockPos pos) {
+		if (flower == null) {
+			return false;
+		}
+		IBlockState soil = world.getBlockState(pos.down());
+		Biome biome = world.getBiome(pos);
+		EnumAcidity acidity = soil.getValue(BlockSoil.ACIDITY);
+		EnumMoisture moisture = soil.getValue(BlockSoil.MOISTURE);
+		EnumTemperature temperature = EnumTemperature.getFromValue(biome.getTemperature());
+		return canTolerate(flower, acidity, moisture, temperature);
+	}
+
+	@Override
+	public EnumSoilType getSoilType(World world, BlockPos pos) {
+		IBlockState blockState = world.getBlockState(pos);
+		if (blockState.getBlock() instanceof IBlockSoil) {
+			IBlockSoil soil = ((IBlockSoil) blockState.getBlock());
+			return soil.getType(world, pos);
+		}
+		return EnumSoilType.SOIL;
+	}
+
+	@Override
+	public Block getSoilBlock(EnumSoilType type) {
+		return getSoilBlock(type, false);
+	}
+
+	@Override
+	public Block getSoilBlock(EnumSoilType type, boolean weedKill) {
+		switch (type) {
+			case FLOWERBED:
+				return weedKill ? ModuleGardening.flowerbedNoWeed : ModuleGardening.flowerbed;
+
+			case LOAM:
+				return weedKill ? ModuleGardening.loamNoWeed : ModuleGardening.loam;
+			default:
+				return weedKill ? ModuleGardening.soilNoWeed : ModuleGardening.soil;
+		}
+	}
+
+	@Override
+	public boolean canTolerate(IFlower flower, EnumAcidity acidity, EnumMoisture moisture, EnumTemperature temperature) {
+		IFlowerGenome genome = flower.getGenome();
+		return genome.canTolerate(acidity) && genome.canTolerate(moisture) && genome.canTolerate(temperature);
+	}
+
+	@Override
+	public boolean isWeedkiller(ItemStack heldItem) {
+		return OreDictionaryUtil.hasOreName(heldItem, "weedkiller");
+	}
+
+	@Override
+	public boolean addWeedKiller(World world, BlockPos pos) {
+		IBlockState oldState = world.getBlockState(pos);
+		if (!(oldState.getBlock() instanceof IBlockSoil)) {
+			return false;
+		}
+
+		EnumSoilType type = getSoilType(world, pos);
+		IBlockState newState = getSoil(type, true,  oldState.getValue(BlockSoil.MOISTURE), oldState.getValue(BlockSoil.ACIDITY));
+		boolean done = world.setBlockState(pos, newState, 2);
+		if (done && BlockPlant.isWeed(world, pos.up())) {
+			world.setBlockToAir(pos.up());
+		}
+		return done;
+	}
+}

botany/src/main/java/binnie/botany/blocks/BlockCeramic.java

@@ -0,0 +1,118 @@
+package binnie.botany.blocks;
+
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.NonNullList;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.RayTraceResult;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import forestry.api.core.IItemModelRegister;
+import forestry.api.core.IModelManager;
+import forestry.core.blocks.IColoredBlock;
+
+import binnie.botany.CreativeTabBotany;
+import binnie.botany.api.genetics.EnumFlowerColor;
+import binnie.botany.tile.TileCeramic;
+import binnie.core.util.TileUtil;
+
+public class BlockCeramic extends Block implements IColoredBlock, IItemModelRegister {
+	public BlockCeramic() {
+		super(Material.ROCK);
+		setHardness(1.0f);
+		setResistance(5.0f);
+		setRegistryName("ceramic");
+		setCreativeTab(CreativeTabBotany.instance);
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void registerModel(Item item, IModelManager manager) {
+		for (EnumFlowerColor c : EnumFlowerColor.values()) {
+			manager.registerItemModel(item, c.ordinal());
+		}
+	}
+
+	@Override
+	public void getDrops(NonNullList<ItemStack> drops, IBlockAccess world, BlockPos pos, IBlockState state, int fortune) {
+
+	}
+
+	@Override
+	public boolean removedByPlayer(IBlockState state, World world, BlockPos pos, @Nullable EntityPlayer player, boolean willHarvest) {
+		List<ItemStack> drops = new ArrayList<>();
+		TileCeramic ceramic = TileUtil.getTile(world, pos, TileCeramic.class);
+		if (ceramic != null) {
+			drops = Collections.singletonList(ceramic.getStack());
+		}
+		boolean hasBeenBroken = world.setBlockToAir(pos);
+		if (hasBeenBroken && !world.isRemote && drops.size() > 0 && (player == null || !player.capabilities.isCreativeMode)) {
+			for (ItemStack drop : drops) {
+				spawnAsEntity(world, pos, drop);
+			}
+		}
+		return hasBeenBroken;
+	}
+
+	@Override
+	public TileEntity createTileEntity(World world, IBlockState state) {
+		return new TileCeramic();
+	}
+
+	@Override
+	public boolean hasTileEntity(IBlockState state) {
+		return true;
+	}
+
+	@Override
+	public void onBlockPlacedBy(World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack) {
+		TileCeramic ceramic = TileUtil.getTile(worldIn, pos, TileCeramic.class);
+		if (ceramic != null) {
+			ceramic.setColor(EnumFlowerColor.VALUES[stack.getItemDamage()]);
+		}
+	}
+
+	@Override
+	public void getSubBlocks(CreativeTabs tab, NonNullList<ItemStack> itemList) {
+		for (EnumFlowerColor c : EnumFlowerColor.values()) {
+			itemList.add(new ItemStack(this, 1, c.getFlowerColorAllele().getID()));
+		}
+	}
+
+	@Override
+	public ItemStack getPickBlock(IBlockState state, RayTraceResult target, World world, BlockPos pos, EntityPlayer player) {
+		TileCeramic ceramic = TileUtil.getTile(world, pos, TileCeramic.class);
+		if (ceramic != null) {
+			return ceramic.getStack();
+		}
+		return super.getPickBlock(state, target, world, pos, player);
+	}
+
+	@SideOnly(Side.CLIENT)
+	@Override
+	public int colorMultiplier(IBlockState state, @Nullable IBlockAccess world, @Nullable BlockPos pos, int tintIndex) {
+		if (world != null && pos != null) {
+			TileCeramic ceramic = TileUtil.getTile(world, pos, TileCeramic.class);
+			if (ceramic != null) {
+				return ceramic.getColor().getFlowerColorAllele().getColor(false);
+			}
+		}
+		return EnumFlowerColor.get(0).getFlowerColorAllele().getColor(false);
+	}
+}

botany/src/main/java/binnie/botany/blocks/BlockCeramicBrick.java

@@ -0,0 +1,265 @@
+package binnie.botany.blocks;
+
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.block.properties.IProperty;
+import net.minecraft.block.properties.PropertyEnum;
+import net.minecraft.block.state.BlockStateContainer;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.ItemMeshDefinition;
+import net.minecraft.client.renderer.block.model.ModelResourceLocation;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.client.renderer.texture.TextureMap;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.BlockRenderLayer;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.NonNullList;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.RayTraceResult;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+
+import net.minecraftforge.client.model.ModelLoader;
+import net.minecraftforge.common.property.ExtendedBlockState;
+import net.minecraftforge.common.property.IExtendedBlockState;
+import net.minecraftforge.common.property.IUnlistedProperty;
+
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import forestry.api.core.IItemModelRegister;
+import forestry.api.core.IModelManager;
+import forestry.api.core.ISpriteRegister;
+import forestry.api.core.IStateMapperRegister;
+import forestry.api.core.ITextureManager;
+import forestry.core.blocks.IColoredBlock;
+import forestry.core.blocks.properties.UnlistedBlockAccess;
+import forestry.core.blocks.properties.UnlistedBlockPos;
+import forestry.core.models.BlockModelEntry;
+
+import binnie.core.Constants;
+import binnie.botany.CreativeTabBotany;
+import binnie.botany.ceramic.brick.CeramicBrickPair;
+import binnie.botany.ceramic.brick.CeramicBrickType;
+import binnie.botany.api.genetics.EnumFlowerColor;
+import binnie.botany.tile.TileCeramic;
+import binnie.botany.tile.TileCeramicBrick;
+import binnie.core.block.IMultipassBlock;
+import binnie.core.models.DefaultStateMapper;
+import binnie.core.models.ModelManager;
+import binnie.core.models.ModelMutlipass;
+import binnie.core.util.TileUtil;
+
+public class BlockCeramicBrick extends Block implements IMultipassBlock<CeramicBrickPair>, IColoredBlock, ISpriteRegister, IStateMapperRegister, IItemModelRegister {
+	private static final PropertyEnum<CeramicBrickType> TYPE = PropertyEnum.create("type", CeramicBrickType.class);
+
+	public BlockCeramicBrick() {
+		super(Material.ROCK);
+		setHardness(1.0f);
+		setResistance(5.0f);
+		setRegistryName("ceramicBrick");
+		setCreativeTab(CreativeTabBotany.instance);
+	}
+
+	@Override
+	public void getDrops(NonNullList<ItemStack> drops, IBlockAccess world, BlockPos pos, IBlockState state, int fortune) {
+
+	}
+
+	@Override
+	public boolean removedByPlayer(IBlockState state, World world, BlockPos pos, @Nullable EntityPlayer player, boolean willHarvest) {
+		List<ItemStack> drops = new ArrayList<>();
+		TileCeramic ceramic = TileUtil.getTile(world, pos, TileCeramic.class);
+		if (ceramic != null) {
+			drops = Collections.singletonList(ceramic.getStack());
+		}
+		boolean hasBeenBroken = world.setBlockToAir(pos);
+		if (hasBeenBroken && !world.isRemote && drops.size() > 0 && (player == null || !player.capabilities.isCreativeMode)) {
+			for (ItemStack drop : drops) {
+				spawnAsEntity(world, pos, drop);
+			}
+		}
+		return hasBeenBroken;
+	}
+
+	@Override
+	public TileEntity createTileEntity(World world, IBlockState state) {
+		return new TileCeramicBrick();
+	}
+
+	@Override
+	public boolean hasTileEntity(IBlockState state) {
+		return true;
+	}
+
+	@Override
+	public void getSubBlocks(CreativeTabs tab, NonNullList<ItemStack> itemList) {
+		for (EnumFlowerColor color : EnumFlowerColor.values()) {
+			itemList.add(new CeramicBrickPair(color, color, CeramicBrickType.TILE).getStack(1));
+		}
+		for (CeramicBrickType type : CeramicBrickType.VALUES) {
+			if (type.canDouble()) {
+				itemList.add(new CeramicBrickPair(EnumFlowerColor.Brown, EnumFlowerColor.Gold, type).getStack(1));
+			}
+		}
+		itemList.add(new CeramicBrickPair(EnumFlowerColor.Gold, EnumFlowerColor.Gold, CeramicBrickType.SPLIT).getStack(1));
+		itemList.add(new CeramicBrickPair(EnumFlowerColor.Brown, EnumFlowerColor.Brown, CeramicBrickType.CHEQUERED).getStack(1));
+		itemList.add(new CeramicBrickPair(EnumFlowerColor.Gold, EnumFlowerColor.Brown, CeramicBrickType.LARGE_BRICK).getStack(1));
+	}
+
+	@SideOnly(Side.CLIENT)
+	@Override
+	public void registerStateMapper() {
+		ResourceLocation resourceLocation = new ResourceLocation(Constants.BOTANY_MOD_ID, "ceramicBrick");
+		ModelLoader.setCustomStateMapper(this, new DefaultStateMapper(resourceLocation));
+		ModelManager.registerCustomBlockModel(new BlockModelEntry(
+				new ModelResourceLocation(resourceLocation, "normal"),
+				new ModelResourceLocation(resourceLocation, "inventory"),
+				new ModelMutlipass<>(BlockCeramicBrick.class),
+				this
+		));
+	}
+
+	@SideOnly(Side.CLIENT)
+	@Override
+	public void registerModel(Item item, IModelManager manager) {
+		manager.registerItemModel(item, new CeramicBrickMeshDefinition());
+	}
+
+	@Override
+	protected BlockStateContainer createBlockState() {
+		return new ExtendedBlockState(
+				this,
+				new IProperty[]{TYPE},
+				new IUnlistedProperty[]{
+						UnlistedBlockPos.POS,
+						UnlistedBlockAccess.BLOCKACCESS
+				}
+		);
+	}
+
+	@Override
+	public IBlockState getStateFromMeta(int meta) {
+		return getDefaultState().withProperty(TYPE, CeramicBrickType.VALUES[meta]);
+	}
+
+	@Override
+	public int getMetaFromState(IBlockState state) {
+		return state.getValue(TYPE).ordinal();
+	}
+
+	@Override
+	public IBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos) {
+		return ((IExtendedBlockState) super.getExtendedState(state, world, pos)).withProperty(UnlistedBlockPos.POS, pos).withProperty(UnlistedBlockAccess.BLOCKACCESS, world);
+	}
+
+	@Override
+	public IBlockState getStateForPlacement(World world, BlockPos pos, EnumFacing facing, float hitX, float hitY, float hitZ, int meta, EntityLivingBase placer, EnumHand hand) {
+		ItemStack stack = placer.getHeldItem(hand);
+		CeramicBrickPair pair = new CeramicBrickPair(stack);
+		return getDefaultState().withProperty(TYPE, pair.type);
+	}
+
+	@Override
+	public void onBlockPlacedBy(World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack) {
+		TileCeramicBrick ceramic = TileUtil.getTile(worldIn, pos, TileCeramicBrick.class);
+		if (ceramic != null) {
+			CeramicBrickPair pair = new CeramicBrickPair(stack);
+			ceramic.setColors(pair.colorFirst, pair.colorSecond);
+		}
+	}
+
+	@Override
+	public ItemStack getPickBlock(IBlockState state, RayTraceResult target, World world, BlockPos pos, EntityPlayer player) {
+		TileCeramicBrick ceramic = TileUtil.getTile(world, pos, TileCeramicBrick.class);
+		if (ceramic != null) {
+			return ceramic.pair().getStack(0);
+		}
+		return super.getPickBlock(state, target, world, pos, player);
+	}
+
+	@SideOnly(Side.CLIENT)
+	@Override
+	public int colorMultiplier(IBlockState state, @Nullable IBlockAccess world, @Nullable BlockPos pos, int tintIndex) {
+		if (world != null && pos != null) {
+			TileCeramicBrick ceramic = TileUtil.getTile(world, pos, TileCeramicBrick.class);
+			if (ceramic != null) {
+				if (tintIndex == 1) {
+					return ceramic.getColorFirst().getFlowerColorAllele().getColor(false);
+				} else if (tintIndex == 2) {
+					return ceramic.getColorSecond().getFlowerColorAllele().getColor(false);
+				}
+			}
+		}
+		return 0xffffff;
+	}
+
+	@SideOnly(Side.CLIENT)
+	@Override
+	public BlockRenderLayer getBlockLayer() {
+		return BlockRenderLayer.CUTOUT;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public int getRenderPasses() {
+		return 3;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public CeramicBrickPair getInventoryKey(ItemStack stack) {
+		return new CeramicBrickPair(stack);
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public CeramicBrickPair getWorldKey(IBlockState state) {
+		IExtendedBlockState extendedState = (IExtendedBlockState) state;
+		IBlockAccess world = extendedState.getValue(UnlistedBlockAccess.BLOCKACCESS);
+		BlockPos pos = extendedState.getValue(UnlistedBlockPos.POS);
+		TileCeramicBrick ceramic = TileUtil.getTile(world, pos, TileCeramicBrick.class);
+		if (ceramic != null) {
+			return ceramic.pair();
+		}
+		return CeramicBrickPair.EMPTY;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public TextureAtlasSprite getSprite(CeramicBrickPair type, @Nullable EnumFacing facing, int pass) {
+		return type.getSprite(pass);
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void registerSprites(ITextureManager manager) {
+		TextureMap textureMap = Minecraft.getMinecraft().getTextureMapBlocks();
+		for (CeramicBrickType type : CeramicBrickType.VALUES) {
+			type.sprites = new TextureAtlasSprite[3];
+			for (int i = 0; i < 3; ++i) {
+				type.sprites[i] = textureMap.registerSprite(new ResourceLocation(Constants.BOTANY_MOD_ID + ":blocks/ceramic." + type.id + "." + i));
+			}
+		}
+	}
+
+	private class CeramicBrickMeshDefinition implements ItemMeshDefinition {
+		@Override
+		public ModelResourceLocation getModelLocation(ItemStack stack) {
+			return new ModelResourceLocation(Constants.BOTANY_MOD_ID + ":ceramicBrick", "inventory");
+		}
+	}
+}

botany/src/main/java/binnie/botany/blocks/BlockCeramicPatterned.java

@@ -0,0 +1,32 @@
+package binnie.botany.blocks;
+
+import net.minecraft.block.material.Material;
+import net.minecraft.item.ItemStack;
+
+import binnie.botany.ceramic.CeramicColor;
+import binnie.botany.ceramic.CeramicDesignSystem;
+import binnie.botany.api.genetics.EnumFlowerColor;
+import binnie.core.util.I18N;
+import binnie.extratrees.api.IDesign;
+import binnie.extratrees.carpentry.BlockDesign;
+import binnie.extratrees.carpentry.DesignBlock;
+import binnie.extratrees.carpentry.ModuleCarpentry;
+
+public class BlockCeramicPatterned extends BlockDesign {
+	public BlockCeramicPatterned() {
+		super(CeramicDesignSystem.instance, Material.ROCK);
+		setHardness(1.0f);
+		setResistance(5.0f);
+		setRegistryName("ceramicPattern");
+	}
+
+	@Override
+	public ItemStack getCreativeStack(IDesign design) {
+		return ModuleCarpentry.getItemStack(this, CeramicColor.get(EnumFlowerColor.White), CeramicColor.get(EnumFlowerColor.Black), design);
+	}
+
+	@Override
+	public String getBlockName(DesignBlock design) {
+		return I18N.localise("botany.ceramic.block.name", design.getDesign().getName());
+	}
+}

botany/src/main/java/binnie/botany/blocks/BlockFlower.java

@@ -0,0 +1,310 @@
+package binnie.botany.blocks;
+
+import javax.annotation.Nullable;
+import java.util.List;
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.SoundType;
+import net.minecraft.block.material.Material;
+import net.minecraft.block.properties.PropertyBool;
+import net.minecraft.block.properties.PropertyInteger;
+import net.minecraft.block.state.BlockStateContainer;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.BlockRenderLayer;
+import net.minecraft.util.EnumBlockRenderType;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.NonNullList;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+
+import com.mojang.authlib.GameProfile;
+
+import net.minecraftforge.client.model.ModelLoader;
+
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import forestry.api.core.IStateMapperRegister;
+import forestry.core.blocks.IColoredBlock;
+
+import binnie.botany.Botany;
+import binnie.botany.api.genetics.IFlower;
+import binnie.botany.api.genetics.IFlowerGenome;
+import binnie.botany.api.genetics.IFlowerRoot;
+import binnie.botany.api.genetics.IFlowerType;
+import binnie.botany.blocks.properties.PropertyFlower;
+import binnie.botany.core.BotanyCore;
+import binnie.botany.genetics.EnumFlowerType;
+import binnie.botany.genetics.FlowerDefinition;
+import binnie.botany.models.StateMapperFlower;
+import binnie.botany.modules.ModuleFlowers;
+import binnie.botany.network.PacketID;
+import binnie.botany.tile.TileEntityFlower;
+import binnie.core.BinnieCore;
+import binnie.core.network.packet.MessageNBT;
+import binnie.core.util.TileUtil;
+
+public class BlockFlower extends BlockContainer implements IColoredBlock, IStateMapperRegister {
+	public static final AxisAlignedBB FLOWER_BLOCK_AABB = new AxisAlignedBB(0.3D, 0.0D, 0.3D, 0.7D, 0.6D, 0.7D);
+	/* PROPERTIES */
+	public static final PropertyFlower FLOWER = new PropertyFlower("flower", IFlowerType.class);
+	public static final PropertyInteger SECTION = PropertyInteger.create("section", 0, EnumFlowerType.highestSection - 1);
+	public static final PropertyBool FLOWERED = PropertyBool.create("flowered");
+	public static final PropertyBool SEED = PropertyBool.create("seed");
+
+	public BlockFlower() {
+		super(Material.PLANTS);
+		setTickRandomly(true);
+		setRegistryName("flower");
+		setSoundType(SoundType.PLANT);
+	}
+
+	@Override
+	public TileEntity createNewTileEntity(World world, int meta) {
+		return new TileEntityFlower();
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void registerStateMapper() {
+		ModelLoader.setCustomStateMapper(this, new StateMapperFlower());
+	}
+
+	@Override
+	public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) {
+		ItemStack heldItem = player.getHeldItemMainhand();
+		if (heldItem.isEmpty() || heldItem.getItem() != BinnieCore.getFieldKit() || !player.isSneaking()) {
+			return false;
+		}
+		if (world.isRemote) {
+			return true;
+		}
+
+		TileEntity tile = world.getTileEntity(pos);
+		if (!(tile instanceof TileEntityFlower)) {
+			return true;
+		}
+
+		TileEntityFlower tileFlower = (TileEntityFlower) tile;
+		IFlower flower = tileFlower.getFlower();
+		if (flower == null) {
+			return true;
+		}
+
+		IFlowerGenome flowerGenome = flower.getGenome();
+		NBTTagCompound info = new NBTTagCompound();
+		info.setString("Species", flowerGenome.getPrimary().getUID());
+		info.setString("Species2", flowerGenome.getSecondary().getUID());
+		info.setFloat("Age", flower.getAge() / flowerGenome.getLifespan());
+		info.setShort("Colour", (short) flowerGenome.getPrimaryColor().getID());
+		info.setShort("Colour2", (short) flowerGenome.getSecondaryColor().getID());
+		info.setBoolean("Wilting", flower.isWilted());
+		info.setBoolean("Flowered", flower.hasFlowered());
+		Botany.proxy.sendToPlayer(new MessageNBT(PacketID.FIELDKIT.ordinal(), info), player);
+		heldItem.damageItem(1, player);
+		return true;
+	}
+
+	@Override
+	@Nullable
+	public AxisAlignedBB getCollisionBoundingBox(IBlockState blockState, IBlockAccess worldIn, BlockPos pos) {
+		return null;
+	}
+
+	@Override
+	public AxisAlignedBB getBoundingBox(IBlockState state, IBlockAccess source, BlockPos pos) {
+		TileEntity tile = source.getTileEntity(pos);
+		if (tile instanceof TileEntityFlower) {
+			TileEntityFlower flower = (TileEntityFlower) tile;
+			if (flower.getType().getSections() > 1) {
+				return FULL_BLOCK_AABB;
+			}
+		}
+		return FLOWER_BLOCK_AABB.offset(getOffset(state, source, pos));
+	}
+
+	@Override
+	public boolean isOpaqueCube(IBlockState state) {
+		return false;
+	}
+
+	@Override
+	public boolean isFullCube(IBlockState state) {
+		return false;
+	}
+
+	@Override
+	public void onBlockPlacedBy(World world, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack) {
+		super.onBlockPlacedBy(world, pos, state, placer, stack);
+		IFlowerRoot flowerRoot = BotanyCore.getFlowerRoot();
+		TileEntity flower = world.getTileEntity(pos);
+		if (!!world.isRemote) {
+			if (flower != null && flower instanceof TileEntityFlower) {
+				IFlower f = flowerRoot.getMember(stack);
+				if (f != null) {
+					((TileEntityFlower) flower).setRender(new TileEntityFlower.RenderInfo(f, (TileEntityFlower) flower));
+				}
+			}
+			return;
+		}
+
+		TileEntity below = world.getTileEntity(pos.down());
+		if (flower != null && flower instanceof TileEntityFlower) {
+			if (below instanceof TileEntityFlower) {
+				((TileEntityFlower) flower).setSection(((TileEntityFlower) below).getSection());
+			} else {
+				GameProfile owner = (placer instanceof EntityPlayer) ? ((EntityPlayer) placer).getGameProfile() : null;
+				((TileEntityFlower) flower).create(stack, owner);
+			}
+		}
+		flowerRoot.tryGrowSection(world, pos);
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public int colorMultiplier(IBlockState state, @Nullable IBlockAccess world, @Nullable BlockPos pos, int tintIndex) {
+		if (world != null && pos != null) {
+			TileEntity tile = world.getTileEntity(pos);
+			if (tile instanceof TileEntityFlower) {
+				TileEntityFlower flower = (TileEntityFlower) tile;
+				if (tintIndex == 0) {
+					return flower.getStemColour();
+				} else if (tintIndex == 1) {
+					return flower.getPrimaryColour();
+				}
+				return flower.getSecondaryColour();
+			}
+		}
+		return 0xffffff;
+	}
+
+	@Override
+	public boolean canPlaceBlockAt(World world, BlockPos pos) {
+		return super.canPlaceBlockAt(world, pos) && canBlockStay(world, pos);
+	}
+
+	public boolean canBlockStay(World world, BlockPos pos) {
+		TileEntity tile = world.getTileEntity(pos);
+		IBlockState downState = world.getBlockState(pos.down());
+		if (tile instanceof TileEntityFlower && ((TileEntityFlower) tile).getSection() > 0) {
+			return downState.getBlock() == ModuleFlowers.flower;
+		}
+		return canPlaceBlockOn(downState.getBlock());
+	}
+
+	protected boolean canPlaceBlockOn(Block block) {
+		return block == Blocks.GRASS
+				|| block == Blocks.DIRT
+				|| block == Blocks.FARMLAND
+				|| BotanyCore.getGardening().isSoil(block);
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public EnumBlockRenderType getRenderType(IBlockState state) {
+		return EnumBlockRenderType.MODEL;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public EnumOffsetType getOffsetType() {
+		return EnumOffsetType.XZ;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public IBlockState getActualState(IBlockState state, IBlockAccess world, BlockPos pos) {
+		TileEntityFlower flower = TileUtil.getTile(world, pos, TileEntityFlower.class);
+		if (flower != null && flower.getType() != null) {
+			state = state.withProperty(FLOWER, flower.getType());
+			state = state.withProperty(FLOWERED, flower.isFlowered());
+			state = state.withProperty(SECTION, flower.getRenderSection());
+			state = state.withProperty(SEED, flower.getAge() == 0);
+		} else {
+			state = state.withProperty(FLOWER, FlowerDefinition.Dandelion.getSpecies().getType());
+			state = state.withProperty(FLOWERED, false);
+			state = state.withProperty(SEED, false);
+		}
+		return state;
+	}
+
+	@Override
+	protected BlockStateContainer createBlockState() {
+		return new BlockStateContainer(this, FLOWER, FLOWERED, SECTION, SEED);
+	}
+
+	@Override
+	public int getMetaFromState(IBlockState state) {
+		return 0;
+	}
+
+	@Override
+	public BlockRenderLayer getBlockLayer() {
+		return BlockRenderLayer.CUTOUT;
+	}
+
+	@Override
+	public void neighborChanged(IBlockState state, World worldIn, BlockPos pos, Block blockIn, BlockPos fromPos) {
+		checkAndDropBlock(worldIn, pos);
+		TileEntity tile = worldIn.getTileEntity(pos);
+		if (tile instanceof TileEntityFlower) {
+			TileEntityFlower flower = (TileEntityFlower) tile;
+			if (flower.getSection() == 0 && flower.getFlower() != null && flower.getFlower().getAge() > 0 && flower.getFlower().getGenome().getPrimary().getType().getSections() > 1 && worldIn.getBlockState(pos.up()).getBlock() != ModuleFlowers.flower) {
+				dropBlockAsItem(worldIn, pos, worldIn.getBlockState(pos), 0);
+				worldIn.setBlockToAir(pos);
+			}
+		}
+	}
+
+	@Override
+	public void updateTick(World world, BlockPos pos, IBlockState state, Random rand) {
+		TileEntity tile = world.getTileEntity(pos);
+		if (tile instanceof TileEntityFlower) {
+			((TileEntityFlower) tile).randomUpdate(rand);
+			checkAndDropBlock(world, pos);
+			return;
+		}
+		world.setBlockToAir(pos);
+	}
+
+	protected void checkAndDropBlock(World world, BlockPos pos) {
+		if (!canBlockStay(world, pos)) {
+			dropBlockAsItem(world, pos, world.getBlockState(pos), 0);
+			world.setBlockToAir(pos);
+		}
+	}
+
+	@Override
+	public void getDrops(NonNullList<ItemStack> drops, IBlockAccess world, BlockPos pos, IBlockState state, int fortune) {
+		TileEntity tile = world.getTileEntity(pos);
+		if (tile instanceof TileEntityFlower && ((TileEntityFlower) tile).getSection() == 0) {
+			ItemStack flower = ((TileEntityFlower) tile).getItemStack();
+			if (!flower.isEmpty()) {
+				drops.add(flower);
+			}
+		}
+	}
+
+	@Override
+	public boolean removedByPlayer(IBlockState state, World world, BlockPos pos, EntityPlayer player, boolean willHarvest) {
+		List<ItemStack> drops = getDrops(world, pos, world.getBlockState(pos), 0);
+		boolean hasBeenBroken = world.setBlockToAir(pos);
+		if (hasBeenBroken && !world.isRemote && drops.size() > 0 && (player == null || !player.capabilities.isCreativeMode)) {
+			for (ItemStack drop : drops) {
+				spawnAsEntity(world, pos, drop);
+			}
+		}
+		return hasBeenBroken;
+	}
+}

botany/src/main/java/binnie/botany/blocks/BlockPlant.java

@@ -0,0 +1,150 @@
+package binnie.botany.blocks;
+
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockBush;
+import net.minecraft.block.SoundType;
+import net.minecraft.block.properties.PropertyEnum;
+import net.minecraft.block.state.BlockStateContainer;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.NonNullList;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import forestry.api.core.IItemModelRegister;
+import forestry.api.core.IModelManager;
+
+import binnie.botany.CreativeTabBotany;
+import binnie.botany.api.gardening.EnumSoilType;
+import binnie.botany.api.gardening.IBlockSoil;
+import binnie.botany.core.BotanyCore;
+
+public class BlockPlant extends BlockBush implements IItemModelRegister {
+	public static final PropertyEnum<PlantType> PLANT_TYPE = PropertyEnum.create("plant_type", PlantType.class);
+
+	public BlockPlant() {
+		setRegistryName("plant");
+		setCreativeTab(CreativeTabBotany.instance);
+		setTickRandomly(true);
+		setSoundType(SoundType.PLANT);
+	}
+
+	public static boolean isWeed(IBlockAccess world, BlockPos pos) {
+		IBlockState blockState = world.getBlockState(pos);
+		if (!(blockState.getBlock() instanceof BlockPlant)) {
+			return false;
+		}
+
+		PlantType type = blockState.getValue(PLANT_TYPE);
+		return type.isWeed();
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void registerModel(Item item, IModelManager manager) {
+		for (int i = 0;i < PlantType.values().length;i++) {
+			PlantType type = PlantType.getType(i);
+			manager.registerItemModel(item, i, type.getName());
+		}
+	}
+
+	@Override
+	protected BlockStateContainer createBlockState() {
+		return new BlockStateContainer(this, PLANT_TYPE);
+	}
+
+	@Override
+	public int getMetaFromState(IBlockState state) {
+		return state.getValue(PLANT_TYPE).ordinal();
+	}
+
+	@Override
+	public IBlockState getStateFromMeta(int meta) {
+		return getDefaultState().withProperty(PLANT_TYPE, PlantType.getType(meta));
+	}
+
+	@Override
+	public void getDrops(NonNullList<ItemStack> drops, IBlockAccess world, BlockPos pos, IBlockState state, int fortune) {
+
+	}
+
+	@Override
+	public boolean canPlaceBlockAt(World worldIn, BlockPos pos) {
+		return super.canPlaceBlockAt(worldIn, pos) || BotanyCore.getGardening().isSoil(worldIn.getBlockState(pos).getBlock());
+	}
+
+	@Override
+	public int damageDropped(IBlockState state) {
+		return getMetaFromState(state);
+	}
+
+	@Override
+	public void getSubBlocks(CreativeTabs p_149666_2_, NonNullList<ItemStack> subBlocks) {
+		for (PlantType type : PlantType.values()) {
+			subBlocks.add(type.get());
+		}
+	}
+
+	@Override
+	public void updateTick(World world, BlockPos pos, IBlockState state, Random rand) {
+		PlantType type = state.getValue(PLANT_TYPE);
+		if (rand.nextInt(4) == 0) {
+			if (type == PlantType.WEEDS) {
+				world.setBlockState(pos, state.withProperty(PLANT_TYPE, PlantType.WEEDS_LONG), 2);
+			} else if (type == PlantType.WEEDS_LONG) {
+				world.setBlockState(pos, state.withProperty(PLANT_TYPE, PlantType.WEEDS_VERY_LONG), 2);
+			} else if (type == PlantType.DEAD_FLOWER) {
+				world.setBlockState(pos, state.withProperty(PLANT_TYPE, PlantType.DECAYING_FLOWER), 2);
+			} else if (type == PlantType.DECAYING_FLOWER) {
+				world.setBlockToAir(pos);
+				return;
+			}
+		}
+
+		if (rand.nextInt(6) == 0) {
+			if (type == PlantType.WEEDS) {
+				world.setBlockToAir(pos);
+			} else if (type == PlantType.WEEDS_LONG) {
+				world.setBlockState(pos, state.withProperty(PLANT_TYPE, PlantType.WEEDS), 2);
+			} else if (type == PlantType.WEEDS_VERY_LONG) {
+				world.setBlockState(pos, state.withProperty(PLANT_TYPE, PlantType.WEEDS_LONG), 2);
+			}
+		}
+
+		Block below = world.getBlockState(pos.down()).getBlock();
+		if (!BotanyCore.getGardening().isSoil(below)) {
+			return;
+		}
+
+		IBlockSoil soil = (IBlockSoil) below;
+		if (rand.nextInt(3) != 0) {
+			return;
+		}
+
+		if (type.isWeed()) {
+			if (!soil.degrade(world, pos.down(), EnumSoilType.LOAM)) {
+				soil.degrade(world, pos.down(), EnumSoilType.SOIL);
+			}
+		} else if (type == PlantType.DECAYING_FLOWER && !soil.fertilise(world, pos.down(), EnumSoilType.LOAM)) {
+			soil.fertilise(world, pos.down(), EnumSoilType.FLOWERBED);
+		}
+	}
+
+	@Override
+	public boolean isReplaceable(IBlockAccess worldIn, BlockPos pos) {
+		return true;
+	}
+
+	@Override
+	public EnumOffsetType getOffsetType() {
+		return EnumOffsetType.XZ;
+	}
+}

botany/src/main/java/binnie/botany/blocks/BlockSoil.java

@@ -0,0 +1,322 @@
+package binnie.botany.blocks;
+
+import javax.annotation.Nullable;
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.SoundType;
+import net.minecraft.block.material.Material;
+import net.minecraft.block.properties.PropertyEnum;
+import net.minecraft.block.state.BlockStateContainer;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.NonNullList;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+
+import net.minecraftforge.common.IPlantable;
+
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import forestry.api.core.IItemModelRegister;
+import forestry.api.core.IModelManager;
+
+import binnie.core.Constants;
+import binnie.botany.CreativeTabBotany;
+import binnie.botany.api.gardening.EnumAcidity;
+import binnie.botany.api.gardening.EnumMoisture;
+import binnie.botany.api.gardening.EnumSoilType;
+import binnie.botany.api.gardening.IBlockSoil;
+import binnie.botany.core.BotanyCore;
+import binnie.core.modules.BotanyModuleUIDs;
+import binnie.botany.modules.ModuleFlowers;
+import binnie.botany.modules.ModuleGardening;
+import binnie.core.util.I18N;
+import binnie.core.modules.ModuleManager;
+
+public class BlockSoil extends Block implements IBlockSoil, IItemModelRegister {
+	public static final PropertyEnum<EnumMoisture> MOISTURE = PropertyEnum.create("moisture", EnumMoisture.class);
+	public static final PropertyEnum<EnumAcidity> ACIDITY = PropertyEnum.create("acidity", EnumAcidity.class);
+	public static final AxisAlignedBB SOIL_BLOCK_AABB = new AxisAlignedBB(0.0D, 0.0D, 0.0D, 1.0D, 0.9375D, 1.0D);
+	private final boolean weedKilled;
+	private final EnumSoilType type;
+
+	public BlockSoil(EnumSoilType type, String blockName, boolean weedKilled) {
+		super(Material.GROUND);
+		this.type = type;
+		this.weedKilled = weedKilled;
+		setUnlocalizedName("botany.soil." + type.getName());
+		setCreativeTab(CreativeTabBotany.instance);
+		setRegistryName(blockName);
+		setTickRandomly(true);
+		setLightOpacity(255);
+		setHardness(0.5f);
+		setSoundType(SoundType.GROUND);
+	}
+
+	public static int getMeta(EnumAcidity acid, EnumMoisture moisture) {
+		return acid.ordinal() * 3 + moisture.ordinal();
+	}
+
+	public static String getPH(ItemStack stack, boolean withColor, boolean byNeutralNone) {
+		EnumAcidity ph = EnumAcidity.values()[stack.getItemDamage() / 3];
+		if (byNeutralNone) {
+			if (ph == EnumAcidity.NEUTRAL) {
+				return "";
+			}
+		}
+		return TextFormatting.GRAY + I18N.localise("botany.ph") + ": " + ph.getLocalisedName(withColor);
+	}
+
+	public static String getMoisture(ItemStack stack, boolean withColor, boolean byNormalNone) {
+		EnumMoisture moisure = EnumMoisture.values()[stack.getItemDamage() % 3];
+		if (byNormalNone) {
+			if (moisure == EnumMoisture.NORMAL) {
+				return "";
+			}
+		}
+		return TextFormatting.GRAY + I18N.localise("botany.moisture") + ": " + moisure.getLocalisedName(withColor);
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public boolean shouldSideBeRendered(IBlockState blockState, IBlockAccess blockAccess, BlockPos pos, EnumFacing side) {
+		switch (side) {
+			case UP:
+				return true;
+
+			case NORTH:
+			case SOUTH:
+			case WEST:
+			case EAST:
+				IBlockState iblockstate = blockAccess.getBlockState(pos.offset(side));
+				Block block = iblockstate.getBlock();
+				return !iblockstate.isOpaqueCube() && block != Blocks.FARMLAND && block != Blocks.GRASS_PATH && block != this;
+		}
+		return super.shouldSideBeRendered(blockState, blockAccess, pos, side);
+	}
+
+	/**
+	 * Used to determine ambient occlusion and culling when rebuilding chunks for render
+	 */
+	@Override
+	public boolean isOpaqueCube(IBlockState state) {
+		return false;
+	}
+
+	@Override
+	public boolean isFullCube(IBlockState state) {
+		return false;
+	}
+
+	@Override
+	public String getUnlocalizedName() {
+		return super.getUnlocalizedName().replaceFirst("tile.", "");
+	}
+
+	@Override
+	public AxisAlignedBB getBoundingBox(IBlockState state, IBlockAccess source, BlockPos pos) {
+		return SOIL_BLOCK_AABB;
+	}
+
+	@Nullable
+	@Override
+	public AxisAlignedBB getCollisionBoundingBox(IBlockState blockState, IBlockAccess worldIn, BlockPos pos) {
+		return SOIL_BLOCK_AABB;
+	}
+
+	@Override
+	public AxisAlignedBB getSelectedBoundingBox(IBlockState state, World worldIn, BlockPos pos) {
+		return SOIL_BLOCK_AABB;
+	}
+
+	@Override
+	public void getSubBlocks(CreativeTabs tab, NonNullList<ItemStack> list) {
+		for (int i = 0; i < 9; ++i) {
+			list.add(new ItemStack(this, 1, i));
+		}
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void registerModel(Item item, IModelManager manager) {
+		for (EnumAcidity acidity : EnumAcidity.values()) {
+			for (EnumMoisture moisture : EnumMoisture.values()) {
+				String modelName = "";
+				if (acidity != EnumAcidity.NEUTRAL) {
+					modelName += acidity.getName();
+				}
+
+				if (moisture != EnumMoisture.NORMAL) {
+					if (!modelName.isEmpty()) {
+						modelName += "_";
+					}
+					modelName += moisture.getName();
+				}
+
+				if (modelName.isEmpty()) {
+					modelName = "normal";
+				}
+
+				String identifier;
+				if (weedKilled) {
+					identifier = type.getName() + "_no_weed/" + modelName;
+				} else {
+					identifier = type.getName() + "/" + modelName;
+				}
+				manager.registerItemModel(item, moisture.ordinal() + acidity.ordinal() * 3, identifier);
+			}
+		}
+	}
+
+	@Override
+	protected BlockStateContainer createBlockState() {
+		return new BlockStateContainer(this, MOISTURE, ACIDITY);
+	}
+
+	@Override
+	public int getMetaFromState(IBlockState state) {
+		return getMeta(state.getValue(ACIDITY), state.getValue(MOISTURE));
+	}
+
+	@Override
+	public IBlockState getStateFromMeta(int meta) {
+		EnumMoisture moisture = EnumMoisture.values()[meta % 3];
+		EnumAcidity acidity = EnumAcidity.values()[meta / 3];
+		return getDefaultState().withProperty(MOISTURE, moisture).withProperty(ACIDITY, acidity);
+	}
+
+	public EnumSoilType getType() {
+		return type;
+	}
+
+	@Override
+	public int damageDropped(IBlockState state) {
+		return getMetaFromState(state);
+	}
+
+	@Override
+	public void updateTick(World world, BlockPos pos, IBlockState state, Random rand) {
+		EnumMoisture moisture = state.getValue(MOISTURE);
+		EnumMoisture desiredMoisture = BotanyCore.getGardening().getNaturalMoisture(world, pos);
+		if (desiredMoisture.ordinal() > moisture.ordinal()) {
+			moisture = ((moisture == EnumMoisture.DRY) ? EnumMoisture.NORMAL : EnumMoisture.DAMP);
+		} else if (desiredMoisture.ordinal() < moisture.ordinal()) {
+			moisture = ((moisture == EnumMoisture.DAMP) ? EnumMoisture.NORMAL : EnumMoisture.DRY);
+		}
+
+		IBlockState blockState = state.withProperty(MOISTURE, moisture);
+		if (state != blockState) {
+			world.setBlockState(pos, blockState, 2);
+		}
+
+		if (!weedKilled) {
+			if (rand.nextInt(5 - getType(world, pos).ordinal()) != 0) {
+				return;
+			}
+			pos = pos.up();
+			if (!world.isAirBlock(pos)) {
+				return;
+			}
+			world.setBlockState(pos, ModuleGardening.plant.getStateFromMeta(PlantType.WEEDS.ordinal()), 2);
+		}
+	}
+
+	@Override
+	public void neighborChanged(IBlockState state, World worldIn, BlockPos pos, Block blockIn, BlockPos fromPos) {
+		super.neighborChanged(state, worldIn, pos, blockIn, fromPos);
+
+		if (worldIn.getBlockState(pos.up()).getMaterial().isSolid()) {
+			worldIn.setBlockState(pos, Blocks.DIRT.getDefaultState());
+		}
+	}
+
+	@Override
+	public EnumAcidity getPH(World world, BlockPos pos) {
+		return world.getBlockState(pos).getValue(ACIDITY);
+	}
+
+	@Override
+	public EnumMoisture getMoisture(World world, BlockPos pos) {
+		return world.getBlockState(pos).getValue(MOISTURE);
+	}
+
+	@Override
+	public EnumSoilType getType(World world, BlockPos pos) {
+		return type;
+	}
+
+	@Override
+	public boolean fertilise(World world, BlockPos pos, EnumSoilType maxLevel) {
+		EnumSoilType type = getType(world, pos);
+		if (type.ordinal() >= maxLevel.ordinal()) {
+			return false;
+		}
+		IBlockState old = world.getBlockState(pos);
+		IBlockState newState = BotanyCore.getGardening().getSoil(maxLevel, weedKilled, old.getValue(MOISTURE), old.getValue(ACIDITY));
+		return world.setBlockState(pos, newState, 2);
+	}
+
+	@Override
+	public boolean degrade(World world, BlockPos pos, EnumSoilType minLevel) {
+		EnumSoilType type = getType(world, pos);
+		if (type.ordinal() <= minLevel.ordinal()) {
+			return false;
+		}
+		IBlockState old = world.getBlockState(pos);
+		IBlockState newState = BotanyCore.getGardening().getSoil(minLevel, weedKilled, old.getValue(MOISTURE), old.getValue(ACIDITY));
+		return world.setBlockState(pos, newState, 2);
+	}
+
+	@Override
+	public boolean setPH(World world, BlockPos pos, EnumAcidity pH) {
+		IBlockState blockState = world.getBlockState(pos);
+		return world.setBlockState(pos, blockState.withProperty(ACIDITY, pH));
+	}
+
+	@Override
+	public boolean setMoisture(World world, BlockPos pos, EnumMoisture moisture) {
+		IBlockState blockState = world.getBlockState(pos);
+		return world.setBlockState(pos, blockState.withProperty(MOISTURE, moisture));
+	}
+
+	@Override
+	public void onNeighborChange(IBlockAccess world, BlockPos pos, BlockPos neighbor) {
+		super.onNeighborChange(world, pos, neighbor);
+		if (world.isSideSolid(pos.up(), EnumFacing.DOWN, false)) {
+			((World) world).setBlockState(pos, Blocks.DIRT.getDefaultState(), 2);
+		}
+	}
+
+	@Override
+	public boolean canSustainPlant(IBlockState state, IBlockAccess world, BlockPos pos, EnumFacing direction, IPlantable plantable) {
+		IBlockState plant = plantable.getPlant(world, pos.up());
+		if(ModuleManager.isModuleEnabled(Constants.BOTANY_MOD_ID, BotanyModuleUIDs.FLOWERS)) {
+			if (plant.getBlock() == ModuleFlowers.flower) {
+				return true;
+			}
+		}
+
+		if (plant.getBlock() == ModuleGardening.plant) {
+			return !weedKilled || !BlockPlant.isWeed(world, pos);
+		}
+		return world instanceof World && Blocks.DIRT.canSustainPlant(state, world, pos, direction, plantable);
+	}
+
+	@Override
+	public boolean resistsWeeds(World world, BlockPos pos) {
+		return weedKilled;
+	}
+
+	public boolean isWeedKilled() {
+		return weedKilled;
+	}
+}

botany/src/main/java/binnie/botany/blocks/BlockStainedGlass.java

@@ -0,0 +1,184 @@
+package binnie.botany.blocks;
+
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.SoundType;
+import net.minecraft.block.material.Material;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.enchantment.EnchantmentHelper;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Enchantments;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.stats.StatList;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.BlockRenderLayer;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.NonNullList;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.RayTraceResult;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+
+import net.minecraftforge.event.ForgeEventFactory;
+
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import forestry.api.core.IItemModelRegister;
+import forestry.api.core.IModelManager;
+import forestry.core.blocks.IColoredBlock;
+
+import binnie.botany.CreativeTabBotany;
+import binnie.botany.api.genetics.EnumFlowerColor;
+import binnie.core.api.block.BlockMetadata;
+import binnie.core.api.block.IBlockMetadata;
+import binnie.core.api.block.TileEntityMetadata;
+import binnie.core.util.I18N;
+
+public class BlockStainedGlass extends Block implements IBlockMetadata, IColoredBlock, IItemModelRegister {
+	public BlockStainedGlass() {
+		super(Material.GLASS);
+		setCreativeTab(CreativeTabBotany.instance);
+		setRegistryName("stained");
+		setSoundType(SoundType.GLASS);
+		setHardness(0.3F);
+	}
+
+	@Override
+	public int quantityDropped(Random rand) {
+		return 0;
+	}
+
+	@Override
+	public boolean isOpaqueCube(IBlockState state) {
+		return false;
+	}
+
+	@SideOnly(Side.CLIENT)
+	@Override
+	public BlockRenderLayer getBlockLayer() {
+		return BlockRenderLayer.TRANSLUCENT;
+	}
+
+	@SideOnly(Side.CLIENT)
+	@Override
+	public void registerModel(Item item, IModelManager manager) {
+		for (EnumFlowerColor color : EnumFlowerColor.values()) {
+			manager.registerItemModel(item, color.getFlowerColorAllele().getID());
+		}
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public boolean shouldSideBeRendered(IBlockState blockState, IBlockAccess blockAccess, BlockPos pos, EnumFacing side) {
+		IBlockState iblockstate = blockAccess.getBlockState(pos.offset(side));
+		Block block = iblockstate.getBlock();
+		return block != this;
+	}
+
+	@Override
+	public void harvestBlock(World worldIn, EntityPlayer player, BlockPos pos, IBlockState state, @Nullable TileEntity te, ItemStack stack) {
+		player.addStat(StatList.getBlockStats(this));
+		player.addExhaustion(0.005F);
+
+		if (EnchantmentHelper.getEnchantmentLevel(Enchantments.SILK_TOUCH, stack) > 0 && te instanceof TileEntityMetadata) {
+			List<ItemStack> items = new ArrayList<>();
+			TileEntityMetadata tile = (TileEntityMetadata) te;
+			int damage = getDroppedMeta(state, tile.getTileMetadata());
+			ItemStack itemstack = TileEntityMetadata.getItemStack(this, damage);
+
+			if (!itemstack.isEmpty()) {
+				items.add(itemstack);
+			}
+
+			ForgeEventFactory.fireBlockHarvesting(items, worldIn, pos, state, 0, 1.0f, true, player);
+			for (ItemStack item : items) {
+				spawnAsEntity(worldIn, pos, item);
+			}
+		}
+	}
+
+	@Override
+	public void getDrops(NonNullList<ItemStack> drops, IBlockAccess world, BlockPos pos, IBlockState state, int fortune) {
+
+	}
+
+	@Override
+	public TileEntity createNewTileEntity(World var1, int i) {
+		return new TileEntityMetadata();
+	}
+
+	@Override
+	public boolean hasTileEntity(IBlockState state) {
+		return true;
+	}
+
+	@Override
+	public boolean eventReceived(IBlockState state, World worldIn, BlockPos pos, int id, int param) {
+		TileEntity tileentity = worldIn.getTileEntity(pos);
+		return tileentity != null && tileentity.receiveClientEvent(id, param);
+	}
+
+	@Override
+	public int getPlacedMeta(ItemStack stack, World world, BlockPos pos, EnumFacing clickedBlock) {
+		return TileEntityMetadata.getItemDamage(stack);
+	}
+
+	@Override
+	public int getDroppedMeta(IBlockState state, int tileMetadata) {
+		return tileMetadata;
+	}
+
+	@Override
+	public String getDisplayName(ItemStack itemStack) {
+		EnumFlowerColor color = EnumFlowerColor.get(TileEntityMetadata.getItemDamage(itemStack));
+		return I18N.localise("botany.pigmented.glass.name", color.getDisplayName());
+	}
+
+	@Override
+	public void getSubBlocks(CreativeTabs tab, NonNullList<ItemStack> itemList) {
+		for (EnumFlowerColor color : EnumFlowerColor.values()) {
+			itemList.add(TileEntityMetadata.getItemStack(this, color.ordinal()));
+		}
+	}
+
+	@Override
+	public boolean isWood(IBlockAccess world, BlockPos pos) {
+		return true;
+	}
+
+	@Override
+	public int getFlammability(IBlockAccess world, BlockPos pos, EnumFacing face) {
+		return 20;
+	}
+
+	@Override
+	public boolean isFlammable(IBlockAccess world, BlockPos pos, EnumFacing face) {
+		return true;
+	}
+
+	@Override
+	public int getFireSpreadSpeed(IBlockAccess world, BlockPos pos, EnumFacing face) {
+		return 5;
+	}
+
+	@Override
+	public ItemStack getPickBlock(IBlockState state, RayTraceResult target, World world, BlockPos pos, EntityPlayer player) {
+		return BlockMetadata.getPickBlock(world, pos);
+	}
+
+	@Override
+	public int colorMultiplier(IBlockState state, @Nullable IBlockAccess worldIn, @Nullable BlockPos pos, int tintIndex) {
+		if (worldIn == null || pos == null) {
+			return 0;
+		}
+		EnumFlowerColor color = EnumFlowerColor.get(TileEntityMetadata.getTileMetadata(worldIn, pos));
+		return color.getFlowerColorAllele().getColor(false);
+	}
+}

botany/src/main/java/binnie/botany/blocks/PlantType.java

@@ -0,0 +1,46 @@
+package binnie.botany.blocks;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IStringSerializable;
+
+import binnie.botany.modules.ModuleGardening;
+
+public enum PlantType implements IStringSerializable {
+	WEEDS("weeds", true),
+	WEEDS_LONG("weeds_long", true),
+	WEEDS_VERY_LONG("weeds_very_long", true),
+	DEAD_FLOWER("dead_flower"),
+	DECAYING_FLOWER("decaying_flower");
+
+	String name;
+	boolean isWeed;
+
+	PlantType(String name) {
+		this(name, false);
+	}
+
+	PlantType(String name, boolean isWeed) {
+		this.name = name;
+		this.isWeed = isWeed;
+	}
+
+	public static PlantType getType(int meta){
+		if(meta >= values().length){
+			meta = values().length-1;
+		}
+		return values()[meta];
+	}
+
+	public ItemStack get() {
+		return new ItemStack(ModuleGardening.plant, 1, ordinal());
+	}
+
+	public boolean isWeed() {
+		return isWeed;
+	}
+
+	@Override
+	public String getName() {
+		return name;
+	}
+}

botany/src/main/java/binnie/botany/blocks/package-info.java

@@ -0,0 +1,9 @@
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+@FieldsAreNonnullByDefault
+package binnie.botany.blocks;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import binnie.core.util.FieldsAreNonnullByDefault;
+import mcp.MethodsReturnNonnullByDefault;

botany/src/main/java/binnie/botany/blocks/properties/PropertyFlower.java

@@ -0,0 +1,53 @@
+package binnie.botany.blocks.properties;
+
+import com.google.common.base.Optional;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+import net.minecraft.block.properties.PropertyHelper;
+
+import forestry.api.genetics.AlleleManager;
+import forestry.api.genetics.IAllele;
+
+import binnie.botany.api.genetics.IAlleleFlowerSpecies;
+import binnie.botany.api.genetics.IFlowerType;
+
+public class PropertyFlower<I extends IFlowerType<I>> extends PropertyHelper<I> {
+	public PropertyFlower(String name, Class<I> flowerTypeClass) {
+		super(name, flowerTypeClass);
+	}
+
+	@Override
+	public List<I> getAllowedValues() {
+		List<I> flowerTypes = new ArrayList<>();
+		for (IAllele allele : AlleleManager.alleleRegistry.getRegisteredAlleles().values()) {
+			if (allele instanceof IAlleleFlowerSpecies) {
+				IFlowerType flowerType = ((IAlleleFlowerSpecies) allele).getType();
+				if (!flowerTypes.contains(flowerType)) {
+					flowerTypes.add((I) flowerType);
+				}
+			}
+		}
+		return flowerTypes;
+	}
+
+	/**
+	 * Get the name for the given value.
+	 */
+	@Override
+	public String getName(IFlowerType value) {
+		return value.getName().toLowerCase(Locale.ENGLISH);
+	}
+
+	@Override
+	public Optional<I> parseValue(String value) {
+		IAllele allele = AlleleManager.alleleRegistry.getAllele(value);
+		if (IAlleleFlowerSpecies.class.isInstance(allele)) {
+			IAlleleFlowerSpecies alleleValue = IAlleleFlowerSpecies.class.cast(allele);
+			return Optional.of((I) alleleValue.getType());
+		}
+		return Optional.absent();
+	}
+}

botany/src/main/java/binnie/botany/blocks/properties/package-info.java

@@ -0,0 +1,9 @@
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+@FieldsAreNonnullByDefault
+package binnie.botany.blocks.properties;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import binnie.core.util.FieldsAreNonnullByDefault;
+import mcp.MethodsReturnNonnullByDefault;

botany/src/main/java/binnie/botany/ceramic/CeramicColor.java

@@ -0,0 +1,51 @@
+package binnie.botany.ceramic;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import net.minecraft.item.ItemStack;
+
+import binnie.botany.api.genetics.EnumFlowerColor;
+import binnie.botany.modules.ModuleCeramic;
+import binnie.core.api.block.TileEntityMetadata;
+import binnie.extratrees.api.IDesignMaterial;
+
+public class CeramicColor implements IDesignMaterial {
+	private final static Map<EnumFlowerColor, CeramicColor> map = new LinkedHashMap<>();
+
+	static {
+		for (EnumFlowerColor c : EnumFlowerColor.values()) {
+			CeramicColor.map.put(c, new CeramicColor(c));
+		}
+	}
+
+	EnumFlowerColor color;
+
+	CeramicColor(EnumFlowerColor color) {
+		this.color = color;
+	}
+
+	public static CeramicColor get(EnumFlowerColor c) {
+		return CeramicColor.map.get(c);
+	}
+
+	@Override
+	public ItemStack getStack() {
+		return TileEntityMetadata.getItemStack(ModuleCeramic.ceramic, color.ordinal());
+	}
+
+	@Override
+	public ItemStack getStack(boolean fireproof) {
+		return getStack();
+	}
+
+	@Override
+	public String getDesignMaterialName() {
+		return color.getName();
+	}
+
+	@Override
+	public int getColour() {
+		return color.getFlowerColorAllele().getColor(false);
+	}
+}

botany/src/main/java/binnie/botany/ceramic/CeramicDesignSystem.java

@@ -0,0 +1,113 @@
+package binnie.botany.ceramic;
+
+import javax.annotation.Nullable;
+import java.util.HashMap;
+import java.util.Map;
+
+import binnie.extratrees.api.carpentry.DesignerManager;
+import binnie.extratrees.api.carpentry.EnumPattern;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.client.renderer.texture.TextureMap;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import binnie.botany.Botany;
+import binnie.botany.api.genetics.EnumFlowerColor;
+import binnie.botany.items.CeramicItems;
+import binnie.botany.modules.ModuleCeramic;
+import binnie.core.AbstractMod;
+import binnie.extratrees.api.IDesignMaterial;
+import binnie.extratrees.api.IDesignSystem;
+import binnie.extratrees.api.IPattern;
+
+public class CeramicDesignSystem implements IDesignSystem {
+	public static CeramicDesignSystem instance = new CeramicDesignSystem();
+	Map<Integer, TextureAtlasSprite> primary;
+	Map<Integer, TextureAtlasSprite> secondary;
+
+	CeramicDesignSystem() {
+		primary = new HashMap<>();
+		secondary = new HashMap<>();
+		DesignerManager.instance.registerDesignSystem(this);
+	}
+
+	@Override
+	public IDesignMaterial getDefaultMaterial() {
+		return CeramicColor.get(EnumFlowerColor.White);
+	}
+
+	@Override
+	public IDesignMaterial getDefaultMaterial2() {
+		return CeramicColor.get(EnumFlowerColor.Black);
+	}
+
+	@Override
+	public IDesignMaterial getMaterial(int id) {
+		return CeramicColor.get(EnumFlowerColor.get(id));
+	}
+
+	@Override
+	public int getMaterialIndex(IDesignMaterial id) {
+		return ((CeramicColor) id).color.ordinal();
+	}
+
+	public String getTexturePath() {
+		return "blocks/ceramic";
+	}
+
+	@Override
+	@Nullable
+	@SideOnly(Side.CLIENT)
+	public TextureAtlasSprite getPrimarySprite(IPattern pattern) {
+		int index = pattern.getIndex();
+		if (index > 0 && index < primary.size()) {
+			return primary.get(index);
+		}
+		return null;
+	}
+
+	@Override
+	@Nullable
+	@SideOnly(Side.CLIENT)
+	public TextureAtlasSprite getSecondarySprite(IPattern pattern) {
+		int index = pattern.getIndex();
+		if (index > 0 && index < secondary.size()) {
+			return secondary.get(index);
+		}
+		return null;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void registerSprites() {
+		TextureMap textureMap = Minecraft.getMinecraft().getTextureMapBlocks();
+		for (EnumPattern pattern : EnumPattern.values()) {
+			ResourceLocation primaryLocation = new ResourceLocation(getMod().getModID(), getTexturePath() + "/" + pattern.toString().toLowerCase() + ".0");
+			ResourceLocation secondaryLocation = new ResourceLocation(getMod().getModID(), getTexturePath() + "/" + pattern.toString().toLowerCase() + ".1");
+			primary.put(pattern.getIndex(), textureMap.registerSprite(primaryLocation));
+			secondary.put(pattern.getIndex(), textureMap.registerSprite(secondaryLocation));
+		}
+	}
+
+	public AbstractMod getMod() {
+		return Botany.instance;
+	}
+
+	@Override
+	public ItemStack getAdhesive() {
+		return CeramicItems.MORTAR.get(1);
+	}
+
+	@Override
+	@Nullable
+	public IDesignMaterial getMaterial(ItemStack itemStack) {
+		return (itemStack.getItem() == Item.getItemFromBlock(ModuleCeramic.ceramic))
+				? getMaterial(itemStack.getItemDamage())
+				: null;
+	}
+}

botany/src/main/java/binnie/botany/ceramic/brick/CeramicBrickPair.java

@@ -0,0 +1,90 @@
+package binnie.botany.ceramic.brick;
+
+import com.google.common.base.Preconditions;
+
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagInt;
+
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import binnie.botany.api.genetics.EnumFlowerColor;
+import binnie.botany.modules.ModuleCeramic;
+import binnie.core.util.I18N;
+
+public class CeramicBrickPair {
+	public static final CeramicBrickPair EMPTY = new CeramicBrickPair(EnumFlowerColor.DarkSeaGreen, EnumFlowerColor.DarkSeaGreen, CeramicBrickType.TILE);
+
+	public final EnumFlowerColor colorFirst;
+	public final EnumFlowerColor colorSecond;
+
+	public CeramicBrickType type;
+	public int ordinal;
+
+	public CeramicBrickPair(EnumFlowerColor colorFirst, EnumFlowerColor colorSecond, CeramicBrickType type) {
+		this.colorFirst = colorFirst;
+		this.colorSecond = colorSecond;
+		this.type = type;
+		ordinal = colorFirst.ordinal() + colorSecond.ordinal() * 256 + type.ordinal() * 256 * 256;
+	}
+
+	public CeramicBrickPair(ItemStack stack) {
+		this(getId(stack));
+	}
+
+	public CeramicBrickPair(int id) {
+		colorFirst = EnumFlowerColor.get(id & 0xFF);
+		colorSecond = EnumFlowerColor.get(id >> 8 & 0xFF);
+		type = CeramicBrickType.get(id >> 16 & 0xFF);
+	}
+
+	public boolean isTwoColors() {
+		return type.canDouble() && colorSecond != colorFirst;
+	}
+
+	public static int getId(ItemStack stack){
+		if(!stack.hasTagCompound()){
+			return EMPTY.ordinal();
+		}
+		NBTTagCompound nbtTagCompound = stack.getTagCompound();
+		return nbtTagCompound.getInteger("id");
+	}
+
+	public ItemStack getStack(int i) {
+		ItemStack stack = new ItemStack(ModuleCeramic.ceramicBrick, i);
+		stack.setTagInfo("id", new NBTTagInt(ordinal()));
+		return stack;
+	}
+
+	public String getName() {
+		String name = colorFirst.getFlowerColorAllele().getColorName();
+		if (type.canDouble() && colorSecond != colorFirst) {
+			name = name + " & " + colorSecond.getFlowerColorAllele().getColorName();
+		}
+		return I18N.localise("botany.ceramic.type." + type.id + ".name", name);
+	}
+
+	public int ordinal() {
+		return ordinal;
+	}
+
+	@SideOnly(Side.CLIENT)
+	public TextureAtlasSprite getSprite(int pass) {
+		TextureAtlasSprite[] sprites = type.sprites;
+		Preconditions.checkState(sprites != null, "Sprites have not been registered.");
+		return sprites[pass];
+	}
+
+	@Override
+	public int hashCode() {
+		return Integer.hashCode(type.ordinal());
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		return obj instanceof CeramicBrickPair
+				&& ((CeramicBrickPair) obj).type == type;
+	}
+}

botany/src/main/java/binnie/botany/ceramic/brick/CeramicBrickType.java

@@ -0,0 +1,329 @@
+package binnie.botany.ceramic.brick;
+
+import javax.annotation.Nullable;
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IStringSerializable;
+
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import binnie.botany.api.genetics.EnumFlowerColor;
+import binnie.botany.items.CeramicItems;
+import binnie.botany.modules.ModuleCeramic;
+import binnie.core.api.block.TileEntityMetadata;
+
+public enum CeramicBrickType implements IStringSerializable {
+	TILE("tile") {
+		@Override
+		public ItemStack getRecipe(List<ItemStack> stacks) {
+			if (stacks.size() != 4) {
+				return ItemStack.EMPTY;
+			}
+			int mortars = 0;
+			int blocks = 0;
+			int blockColor = -1;
+			for (ItemStack stack : stacks) {
+				if (isMortar(stack)) {
+					++mortars;
+				} else {
+					if (stack.getItem() != Item.getItemFromBlock(ModuleCeramic.ceramic)) {
+						return ItemStack.EMPTY;
+					}
+					++blocks;
+					int color = TileEntityMetadata.getItemDamage(stack);
+					if (blockColor == -1) {
+						blockColor = color;
+					} else {
+						if (blockColor != color) {
+							return ItemStack.EMPTY;
+						}
+					}
+				}
+			}
+			if (mortars != 1) {
+				return ItemStack.EMPTY;
+			}
+			EnumFlowerColor c = EnumFlowerColor.get(blockColor);
+			return new CeramicBrickPair(c, c, CeramicBrickType.TILE).getStack(3);
+		}
+	},
+	BRICK("brick") {
+		@Override
+		public ItemStack getRecipe(List<ItemStack> stacks) {
+			return getBrickRecipe(this, stacks);
+		}
+	},
+	STRIPE_BRICK("brickstripe") {
+		@Override
+		public ItemStack getRecipe(List<ItemStack> stacks) {
+			return getBrickRecipe(this, stacks);
+		}
+	},
+	LARGE_BRICK("bricklarge") {
+		@Override
+		public ItemStack getRecipe(List<ItemStack> stacks) {
+			if (stacks.size() == 1) {
+				ItemStack stack3 = stacks.get(0);
+				CeramicBrickPair type3 = new CeramicBrickPair(stack3);
+				if (type3.type == CeramicBrickType.VERTICAL_LARGE_BRICK) {
+					type3.type = this;
+					return type3.getStack(1);
+				}
+				return ItemStack.EMPTY;
+			} else {
+				if (stacks.size() != 3) {
+					return ItemStack.EMPTY;
+				}
+				int[] colors = {-1, -1};
+				int a = 0;
+				int b = 0;
+				for (ItemStack stack4 : stacks) {
+					if (stack4.getItem() != Item.getItemFromBlock(ModuleCeramic.ceramicBrick)) {
+						return ItemStack.EMPTY;
+					}
+					CeramicBrickPair type4 = new CeramicBrickPair(stack4);
+					if (type4.type != CeramicBrickType.TILE) {
+						return ItemStack.EMPTY;
+					}
+					int color5 = type4.colorFirst.ordinal();
+					if (colors[0] == -1) {
+						colors[0] = color5;
+						a++;
+					} else if (colors[0] == color5) {
+						a++;
+					} else if (colors[1] == -1) {
+						colors[1] = color5;
+						b++;
+					} else {
+						if (colors[1] != color5) {
+							return ItemStack.EMPTY;
+						}
+						b++;
+					}
+				}
+				if (colors[1] == -1) {
+					colors[1] = colors[0];
+				}
+				return new CeramicBrickPair(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), CeramicBrickType.LARGE_BRICK).getStack(3);
+			}
+		}
+	},
+	SPLIT("split") {
+		@Override
+		public ItemStack getRecipe(List<ItemStack> stacks) {
+			if (stacks.size() != 4) {
+				return ItemStack.EMPTY;
+			}
+			int[] colors = {-1, -1};
+			int altCounter = 0;
+			for (ItemStack stack2 : stacks) {
+				int alt = (altCounter != 0 && altCounter != 3) ? 1 : 0;
+				if (stack2.getItem() != Item.getItemFromBlock(ModuleCeramic.ceramicBrick)) {
+					return ItemStack.EMPTY;
+				}
+				CeramicBrickPair type = new CeramicBrickPair(stack2);
+				if (type.type != CeramicBrickType.TILE) {
+					return ItemStack.EMPTY;
+				}
+				int color2 = type.colorFirst.ordinal();
+				if (colors[alt] == -1) {
+					colors[alt] = color2;
+				} else if (colors[alt] != color2) {
+					return ItemStack.EMPTY;
+				}
+				++altCounter;
+			}
+			return new CeramicBrickPair(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), CeramicBrickType.SPLIT).getStack(4);
+		}
+	},
+	CHEQUERED("cheque") {
+		@Override
+		public ItemStack getRecipe(List<ItemStack> stacks) {
+			if (stacks.size() != 4) {
+				return ItemStack.EMPTY;
+			}
+			int[] colors = {-1, -1};
+			for (ItemStack stack2 : stacks) {
+				if (stack2.getItem() != Item.getItemFromBlock(ModuleCeramic.ceramicBrick)) {
+					return ItemStack.EMPTY;
+				}
+				CeramicBrickPair type2 = new CeramicBrickPair(stack2);
+				if (type2.type != CeramicBrickType.SPLIT) {
+					return ItemStack.EMPTY;
+				}
+				int color3 = type2.colorFirst.ordinal();
+				int color4 = type2.colorSecond.ordinal();
+				if (colors[0] == -1) {
+					colors[0] = color3;
+					colors[1] = color4;
+				} else {
+					if (colors[0] != color3 || colors[1] != color4) {
+						return ItemStack.EMPTY;
+					}
+				}
+			}
+			return new CeramicBrickPair(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), CeramicBrickType.CHEQUERED).getStack(4);
+		}
+	},
+	MIXED("mixed") {
+		@Override
+		public ItemStack getRecipe(List<ItemStack> stacks) {
+			if (stacks.size() != 4) {
+				return ItemStack.EMPTY;
+			}
+			int[] colors = {-1, -1};
+			for (ItemStack stack2 : stacks) {
+				if (stack2.getItem() != Item.getItemFromBlock(ModuleCeramic.ceramicBrick)) {
+					return ItemStack.EMPTY;
+				}
+				CeramicBrickPair type2 = new CeramicBrickPair(stack2);
+				if (type2.isTwoColors()) {
+					return ItemStack.EMPTY;
+				}
+				int color3 = type2.colorFirst.ordinal();
+				if (type2.type == CeramicBrickType.SPLIT) {
+					if (colors[1] != -1) {
+						return ItemStack.EMPTY;
+					}
+					colors[1] = color3;
+				} else {
+					if (type2.type != CeramicBrickType.CHEQUERED) {
+						return ItemStack.EMPTY;
+					}
+					if (colors[0] == -1) {
+						colors[0] = color3;
+					} else if (colors[0] != color3) {
+						return ItemStack.EMPTY;
+					}
+				}
+				int color4 = type2.colorSecond.ordinal();
+			}
+			if (colors[0] == -1 || colors[1] == -1) {
+				return ItemStack.EMPTY;
+			}
+			return new CeramicBrickPair(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), CeramicBrickType.MIXED).getStack(4);
+		}
+	},
+	VERTICAL_BRICK("verticalbrick") {
+		@Override
+		public ItemStack getRecipe(List<ItemStack> stacks) {
+			return getVerticalBrickRecipe(stacks);
+		}
+	},
+	VERTICAL_STRIPE_BRICK("verticalbrickstripe") {
+		@Override
+		public ItemStack getRecipe(List<ItemStack> stacks) {
+			return getVerticalBrickRecipe(stacks);
+		}
+	},
+	VERTICAL_LARGE_BRICK("verticalbricklarge") {
+		@Override
+		public ItemStack getRecipe(List<ItemStack> stacks) {
+			return getVerticalBrickRecipe(stacks);
+		}
+	};
+
+	public static final CeramicBrickType[] VALUES = values();
+
+	public String id;
+
+	@SideOnly(Side.CLIENT)
+	@Nullable
+	public TextureAtlasSprite[] sprites;
+
+	CeramicBrickType(String id) {
+		this.id = id;
+	}
+
+	public static CeramicBrickType get(int id) {
+		return VALUES[id % VALUES.length];
+	}
+
+	public boolean canDouble() {
+		return this != CeramicBrickType.TILE;
+	}
+
+	public abstract ItemStack getRecipe(List<ItemStack> stacks);
+
+	protected ItemStack getVerticalBrickRecipe(List<ItemStack> stacks) {
+		if (stacks.size() != 1) {
+			return ItemStack.EMPTY;
+		}
+		ItemStack stack5 = stacks.get(0);
+		CeramicBrickPair type = new CeramicBrickPair(stack5);
+		if (type.type == CeramicBrickType.LARGE_BRICK) {
+			type.type = CeramicBrickType.VERTICAL_LARGE_BRICK;
+			return type.getStack(1);
+		}
+
+		if (type.type == CeramicBrickType.BRICK) {
+			type.type = CeramicBrickType.VERTICAL_BRICK;
+			return type.getStack(1);
+		}
+
+		if (type.type == CeramicBrickType.STRIPE_BRICK) {
+			type.type = CeramicBrickType.VERTICAL_STRIPE_BRICK;
+			return type.getStack(1);
+		}
+		return ItemStack.EMPTY;
+	}
+
+	protected ItemStack getBrickRecipe(CeramicBrickType ceramicType, List<ItemStack> stacks) {
+		if (stacks.size() == 1) {
+			ItemStack stack5 = stacks.get(0);
+			CeramicBrickPair type = new CeramicBrickPair(stack5);
+			if (type.type == CeramicBrickType.VERTICAL_BRICK) {
+				type.type = ceramicType;
+				return type.getStack(1);
+			}
+
+			if (type.type == CeramicBrickType.STRIPE_BRICK) {
+				type.type = ceramicType;
+				return type.getStack(1);
+			}
+			return ItemStack.EMPTY;
+		} else if (stacks.size() == 4) {
+			int[] colors = {-1, -1};
+			for (int index2 = 0; index2 < stacks.size(); ++index2) {
+				ItemStack stack4 = stacks.get(index2);
+				if (stack4.getItem() != Item.getItemFromBlock(ModuleCeramic.ceramicBrick)) {
+					return ItemStack.EMPTY;
+				}
+
+				CeramicBrickPair type4 = new CeramicBrickPair(stack4);
+				if (type4.type != CeramicBrickType.LARGE_BRICK) {
+					return ItemStack.EMPTY;
+				}
+
+				int color5 = type4.colorFirst.ordinal();
+				int color6 = type4.colorSecond.ordinal();
+				int alt2 = (index2 != 0 && index2 != 3) ? 1 : 0;
+				if (ceramicType == CeramicBrickType.STRIPE_BRICK) {
+					alt2 = 0;
+				}
+
+				if (colors[alt2] == -1) {
+					colors[alt2] = color5;
+					colors[1 - alt2] = color6;
+				} else if (colors[alt2] != color5 || colors[1 - alt2] != color6) {
+					return ItemStack.EMPTY;
+				}
+			}
+			return new CeramicBrickPair(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), ceramicType).getStack(4);
+		}
+		return ItemStack.EMPTY;
+	}
+
+	protected boolean isMortar(ItemStack stack) {
+		return stack.getItem() == ModuleCeramic.misc && stack.getItemDamage() == CeramicItems.MORTAR.ordinal();
+	}
+
+	@Override
+	public String getName() {
+		return id;
+	}
+}

botany/src/main/java/binnie/botany/ceramic/brick/package-info.java

@@ -0,0 +1,9 @@
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+@FieldsAreNonnullByDefault
+package binnie.botany.ceramic.brick;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import binnie.core.util.FieldsAreNonnullByDefault;
+import mcp.MethodsReturnNonnullByDefault;

botany/src/main/java/binnie/botany/ceramic/package-info.java

@@ -0,0 +1,9 @@
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+@FieldsAreNonnullByDefault
+package binnie.botany.ceramic;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import binnie.core.util.FieldsAreNonnullByDefault;
+import mcp.MethodsReturnNonnullByDefault;

botany/src/main/java/binnie/botany/core/BotanyCore.java

@@ -0,0 +1,25 @@
+package binnie.botany.core;
+
+import binnie.botany.GardeningManager;
+import binnie.botany.api.BotanyAPI;
+import binnie.botany.api.gardening.IGardeningManager;
+import binnie.botany.api.genetics.IFlowerRoot;
+import binnie.botany.genetics.FlowerRoot;
+
+public class BotanyCore {
+	public static final int CHANCE_INTERPOLLINATION = 20;
+
+	public static IFlowerRoot getFlowerRoot() {
+		if (BotanyAPI.flowerRoot == null) {
+			BotanyAPI.flowerRoot = new FlowerRoot();
+		}
+		return BotanyAPI.flowerRoot;
+	}
+
+	public static IGardeningManager getGardening() {
+		if (BotanyAPI.gardening == null) {
+			BotanyAPI.gardening = new GardeningManager();
+		}
+		return BotanyAPI.gardening;
+	}
+}

botany/src/main/java/binnie/botany/core/package-info.java

@@ -0,0 +1,9 @@
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+@FieldsAreNonnullByDefault
+package binnie.botany.core;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import binnie.core.util.FieldsAreNonnullByDefault;
+import mcp.MethodsReturnNonnullByDefault;

botany/src/main/java/binnie/botany/farming/CircuitGarden.java

@@ -0,0 +1,107 @@
+package binnie.botany.farming;
+
+import com.google.common.base.Preconditions;
+
+import javax.annotation.Nullable;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.text.TextFormatting;
+
+import forestry.api.circuits.ChipsetManager;
+import forestry.api.circuits.ICircuitLayout;
+import forestry.api.farming.FarmDirection;
+import forestry.api.farming.IFarmHousing;
+
+import binnie.botany.api.gardening.EnumAcidity;
+import binnie.botany.api.gardening.EnumMoisture;
+import binnie.core.circuits.BinnieCircuit;
+import binnie.core.util.I18N;
+
+public class CircuitGarden extends BinnieCircuit {
+	private boolean isManual;
+	private GardenLogic logic;
+
+	public CircuitGarden(EnumMoisture moisture, @Nullable EnumAcidity ph, boolean manual, boolean fertilised, ItemStack recipe, ItemStack icon) {
+		super(getName(moisture, ph, manual, fertilised), 4, getLayout(manual), recipe);
+		isManual = manual;
+		logic = new GardenLogic(moisture, ph, isManual, fertilised, icon, I18N.localise(getUnlocalizedName()));
+		String info = I18N.localise("botany.moisture") + ": " + moisture.getLocalisedName(true) + TextFormatting.GRAY + ", ";
+		if (ph != null) {
+			info += I18N.localise("botany.ph") + ": " + ph.getLocalisedName(true) + TextFormatting.GRAY + ", ";
+		}
+		String fertilizedKey = fertilised ? "for.binnie.circuit.garden.fertilized" : "for.binnie.circuit.garden.unfertilized";
+		info += (fertilised ? TextFormatting.GREEN : TextFormatting.RED) + I18N.localise(fertilizedKey) + TextFormatting.GRAY;
+		addTooltipString(I18N.localise("for.binnie.circuit.garden.info", info));
+	}
+
+	private static ICircuitLayout getLayout(boolean manual) {
+		String layoutUid = manual ? "forestry.farms.manual" : "forestry.farms.managed";
+		ICircuitLayout layout = ChipsetManager.circuitRegistry.getLayout(layoutUid);
+		Preconditions.checkState(layout != null, "Couldn't find Forestry circuit layout %s.", layoutUid);
+		return layout;
+	}
+
+	private static String getName(EnumMoisture moisture, @Nullable EnumAcidity ph, boolean manual, boolean fertilised) {
+		String name = "garden." + moisture.getName();
+		if (ph != null) {
+			name += "." + ph.getName();
+		}
+		if (manual) {
+			name += ".manual";
+		}
+		if (fertilised) {
+			name += ".fert";
+		}
+		return name;
+	}
+
+	public CircuitGarden setManual() {
+		isManual = true;
+		return this;
+	}
+
+	@Override
+	public boolean isCircuitable(Object tile) {
+		return tile instanceof IFarmHousing;
+	}
+
+	@Nullable
+	private IFarmHousing getCircuitable(Object tile) {
+		if (!isCircuitable(tile)) {
+			return null;
+		}
+		return (IFarmHousing) tile;
+	}
+
+	@Override
+	public void onInsertion(int slot, Object tile) {
+		IFarmHousing housing = getCircuitable(tile);
+		if (housing == null) {
+			return;
+		}
+
+		logic.setManual(isManual);
+
+		housing.setFarmLogic(FarmDirection.values()[slot], logic);
+	}
+
+	@Override
+	public void onLoad(int slot, Object tile) {
+		onInsertion(slot, tile);
+	}
+
+	@Override
+	public void onRemoval(int slot, Object tile) {
+		IFarmHousing farmHousing = getCircuitable(tile);
+		if (farmHousing == null) {
+			return;
+		}
+
+		farmHousing.resetFarmLogic(FarmDirection.values()[slot]);
+	}
+
+	@Override
+	public void onTick(int slot, Object tile) {
+		// ignored
+	}
+}

botany/src/main/java/binnie/botany/farming/FarmLogic.java

@@ -0,0 +1,49 @@
+package binnie.botany.farming;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+import forestry.api.farming.IFarmLogic;
+
+public abstract class FarmLogic implements IFarmLogic {
+	boolean isManual;
+
+	@Override
+	public IFarmLogic setManual(boolean flag) {
+		isManual = flag;
+		return this;
+	}
+
+	protected final boolean isAirBlock(World world, BlockPos pos) {
+		return world.isAirBlock(pos);
+	}
+
+	protected final IBlockState getBlockState(World world, BlockPos pos) {
+		return world.getBlockState(pos);
+	}
+
+	protected final Block getBlock(World world, BlockPos pos) {
+		return getBlockState(world, pos).getBlock();
+	}
+
+	protected final int getBlockMeta(World world, BlockPos pos) {
+		IBlockState blockState = world.getBlockState(pos);
+		return blockState.getBlock().getMetaFromState(blockState);
+	}
+
+	protected final ItemStack getAsItemStack(World world, BlockPos position) {
+		return new ItemStack(getBlock(world, position), 1, getBlockMeta(world, position));
+	}
+
+	protected final boolean isWaterBlock(World world, BlockPos pos) {
+		return getBlock(world, pos) == Blocks.WATER;
+	}
+
+	protected final void setBlock(World world, BlockPos pos, Block block, int meta) {
+		world.setBlockState(pos, block.getStateFromMeta(meta), 2);
+	}
+}

botany/src/main/java/binnie/botany/farming/FarmableFlower.java

@@ -0,0 +1,67 @@
+package binnie.botany.farming;
+
+import javax.annotation.Nullable;
+
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+import forestry.api.farming.ICrop;
+import forestry.api.farming.IFarmable;
+
+import binnie.botany.api.genetics.EnumFlowerStage;
+import binnie.botany.api.genetics.IFlower;
+import binnie.botany.api.genetics.IFlowerRoot;
+import binnie.botany.core.BotanyCore;
+import binnie.botany.modules.ModuleFlowers;
+import binnie.botany.tile.TileEntityFlower;
+
+public class FarmableFlower implements IFarmable {
+	@Override
+	public boolean isSaplingAt(World world, BlockPos pos) {
+		return world.getBlockState(pos) == ModuleFlowers.flower;
+	}
+
+	@Nullable
+	@Override
+	public ICrop getCropAt(World world, BlockPos pos, IBlockState blockState) {
+		IFlower flower = null;
+		if (world.getTileEntity(pos) instanceof TileEntityFlower) {
+			flower = ((TileEntityFlower) world.getTileEntity(pos)).getFlower();
+		}
+
+		// TODO Look at TileEntityFlower::onShear logic
+		if (flower != null && flower.getAge() > 1) {
+			IFlowerRoot flowerRoot = BotanyCore.getFlowerRoot();
+			ItemStack mature = flowerRoot.getMemberStack(flower, EnumFlowerStage.FLOWER);
+			ItemStack seed = flowerRoot.getMemberStack(flower, EnumFlowerStage.SEED);
+			if (!mature.isEmpty() && !seed.isEmpty()) {
+				world.setBlockState(pos, Blocks.AIR.getDefaultState(), 2);
+				return new FlowerCrop(pos, mature, seed);
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public boolean isGermling(ItemStack itemstack) {
+		EnumFlowerStage stage = BotanyCore.getFlowerRoot().getType(itemstack);
+		return stage == EnumFlowerStage.FLOWER || stage == EnumFlowerStage.SEED;
+	}
+
+	@Override
+	public boolean isWindfall(ItemStack itemstack) {
+		return false;
+	}
+
+	@Override
+	public boolean plantSaplingAt(EntityPlayer player, ItemStack germling, World world, BlockPos pos) {
+		IFlowerRoot flowerRoot = BotanyCore.getFlowerRoot();
+		IFlower flower = flowerRoot.getMember(germling);
+		flowerRoot.plant(world, pos, flower, player.getGameProfile());
+		return true;
+	}
+}

botany/src/main/java/binnie/botany/farming/FarmableVanillaFlower.java

@@ -0,0 +1,24 @@
+package binnie.botany.farming;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+import binnie.botany.api.genetics.IFlower;
+import binnie.botany.api.genetics.IFlowerRoot;
+import binnie.botany.core.BotanyCore;
+
+public class FarmableVanillaFlower extends FarmableFlower {
+	@Override
+	public boolean isGermling(ItemStack itemstack) {
+		return BotanyCore.getFlowerRoot().getConversion(itemstack) != null;
+	}
+
+	@Override
+	public boolean plantSaplingAt(EntityPlayer player, ItemStack germling, World world, BlockPos pos) {
+		IFlowerRoot flowerRoot = BotanyCore.getFlowerRoot();
+		IFlower flower = flowerRoot.getConversion(germling);
+		return flowerRoot.plant(world, pos, flower, player.getGameProfile());
+	}
+}