% Tried to improve the logic for the Tree Farmer, to support Forestry 4.

% Moved COFH API related files.
+ Added a child mod, for misc handling.
$$ Borrowed some code from MFR, to attempt forestry support. (Credit left, will re-do if I even get it working).

10 files changed, 785 insertions, 0 deletions

diff --git a/src/Java/powercrystals/minefactoryreloaded/api/EmptyReplacement.java b/src/Java/powercrystals/minefactoryreloaded/api/EmptyReplacement.java
new file mode 100644
index 0000000000..ef3fd46bb2
--- /dev/null
+++ b/src/Java/powercrystals/minefactoryreloaded/api/EmptyReplacement.java
@@ -0,0 +1,20 @@
+package powercrystals.minefactoryreloaded.api;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+public class EmptyReplacement extends ReplacementBlock
+{
+	public static final EmptyReplacement INSTANCE = new EmptyReplacement();
+
+	public EmptyReplacement()
+	{
+		super((Block)null);
+	}
+
+	@Override
+	public boolean replaceBlock(World world, int x, int y, int z, ItemStack stack) {
+		return true;
+	}
+}
diff --git a/src/Java/powercrystals/minefactoryreloaded/api/HarvestType.java b/src/Java/powercrystals/minefactoryreloaded/api/HarvestType.java
new file mode 100644
index 0000000000..85ef23835c
--- /dev/null
+++ b/src/Java/powercrystals/minefactoryreloaded/api/HarvestType.java
@@ -0,0 +1,56 @@
+package powercrystals.minefactoryreloaded.api;
+
+/**
+ * Determines what algorithm the Harvester uses when it encounters this
+ * IFactoryHarvestable in the world.
+ *
+ * @author PowerCrystals
+ */
+public enum HarvestType {
+
+	/**
+	 * Just break the single block - no special action needed. e.g. Carrots,
+	 * flowers, wheat.
+	 */
+	Normal,
+	/**
+	 * Search for harvestable blocks adjacent to this block but leave this
+	 * block. e.g. Pumpkin, melon
+	 */
+	Gourd,
+	/**
+	 * Search for identical blocks above.
+	 */
+	Column,
+	/**
+	 * Search for identical blocks above but leave the bottom one for the
+	 * future. e.g. Cactus, sugarcane.
+	 */
+	LeaveBottom,
+	/**
+	 * This block is the base of a tree and the harvester should enter
+	 * tree-cutting mode.
+	 */
+	Tree,
+	/**
+	 * This block is the base of the tree and the harvester should enter
+	 * tree-cutting mode.
+	 * The tree is searched for in the negative y axis instead.
+	 */
+	TreeFlipped,
+	/**
+	 * This block is part of a tree as above, but leaves are cut before logs.
+	 * The tree is searched for in the current mode.
+	 * <p>
+	 * If not in tree-cutting mode, tree-cutting mode will be entered as though
+	 * the type was Tree.
+	 */
+	TreeLeaf,
+	/**
+	 * This block is part of a tree as above, but fruits are cut before logs.
+	 * e.g. cocoa
+	 * The tree is not searched for.
+	 */
+	TreeFruit
+
+}
diff --git a/src/Java/powercrystals/minefactoryreloaded/api/IFactoryFruit.java b/src/Java/powercrystals/minefactoryreloaded/api/IFactoryFruit.java
new file mode 100644
index 0000000000..3f956422c0
--- /dev/null
+++ b/src/Java/powercrystals/minefactoryreloaded/api/IFactoryFruit.java
@@ -0,0 +1,106 @@
+package powercrystals.minefactoryreloaded.api;
+
+import java.util.List;
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+/**
+ * Defines a fruit entry for the Fruit Picker.
+ *
+ * @author powercrystals
+ *
+ */
+public interface IFactoryFruit {
+
+	/**
+	 * @return The block this fruit has in the world.
+	 */
+	public Block getPlant();
+
+	/**
+	 * Used to determine if this fruit can be picked (is it ripe yet, etc)
+	 *
+	 * @param world
+	 *            The world where the fruit is being picked
+	 * @param x
+	 *            The x-coordinate of the fruit
+	 * @param y
+	 *            The y-coordinate of the fruit
+	 * @param z
+	 *            The z-coordinate of the fruit
+	 *
+	 * @return True if the fruit can be picked
+	 */
+	public boolean canBePicked(World world, int x, int y, int z);
+
+	/**
+	 * @deprecated This method is no longer called. ReplacementBlock now handles
+	 *             interaction.
+	 */
+	@Deprecated
+	public boolean breakBlock();
+
+	/**
+	 * Called by the Fruit Picker to determine what block to replace the picked
+	 * block with. At the time this method is called, the fruit still exists.
+	 *
+	 * @param world
+	 *            The world where the fruit is being picked
+	 * @param x
+	 *            The x-coordinate of the fruit
+	 * @param y
+	 *            The y-coordinate of the fruit
+	 * @param z
+	 *            The z-coordinate of the fruit
+	 *
+	 * @return The block to replace the fruit block with, or null for air.
+	 */
+	public ReplacementBlock getReplacementBlock(World world, int x, int y, int z);
+
+	/**
+	 * Called by the Fruit Picker to determine what drops to generate. At the
+	 * time this method is called, the fruit still exists.
+	 *
+	 * @param world
+	 *            The world where the fruit is being picked
+	 * @param x
+	 *            The x-coordinate of the fruit
+	 * @param y
+	 *            The y-coordinate of the fruit
+	 * @param z
+	 *            The z-coordinate of the fruit
+	 */
+	public List<ItemStack> getDrops(World world, Random rand, int x, int y, int z);
+
+	/**
+	 * Called by the Fruit Picker after getDrops, prior to the block being
+	 * replaced/removed.
+	 *
+	 * @param world
+	 *            The world where the fruit is being picked
+	 * @param x
+	 *            The x-coordinate of the fruit
+	 * @param y
+	 *            The y-coordinate of the fruit
+	 * @param z
+	 *            The z-coordinate of the fruit
+	 */
+	public void prePick(World world, int x, int y, int z);
+
+	/**
+	 * Called by the Fruit Picker after the fruit is picked.
+	 *
+	 * @param world
+	 *            The world where the fruit is being picked
+	 * @param x
+	 *            The x-coordinate of the fruit
+	 * @param y
+	 *            The y-coordinate of the fruit
+	 * @param z
+	 *            The z-coordinate of the fruit
+	 */
+	public void postPick(World world, int x, int y, int z);
+}
diff --git a/src/Java/powercrystals/minefactoryreloaded/api/IFactoryHarvestable.java b/src/Java/powercrystals/minefactoryreloaded/api/IFactoryHarvestable.java
new file mode 100644
index 0000000000..5b6be99f89
--- /dev/null
+++ b/src/Java/powercrystals/minefactoryreloaded/api/IFactoryHarvestable.java
@@ -0,0 +1,104 @@
+package powercrystals.minefactoryreloaded.api;
+
+import java.util.*;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+/**
+ * Defines a harvestable block for the Harvester.
+ *
+ * @author PowerCrystals
+ */
+public interface IFactoryHarvestable {
+
+	/**
+	 * @return The block this harvestable instance is managing.
+	 */
+	public Block getPlant();
+
+	/**
+	 * @return The type of harvest the Harvester should perform on this block.
+	 */
+	public HarvestType getHarvestType();
+
+	/**
+	 * Used to determine if the harvester should replace this block with air.
+	 *
+	 * @return Whether or not the Harvester should break the block when
+	 *         harvesting. If false, no changes will be performed by the
+	 *         Harvester itself.
+	 */
+	public boolean breakBlock();
+
+	/**
+	 * Used to determine if this crop can be harvested (is it at a stage that
+	 * drops crops, etc.)
+	 *
+	 * @param world
+	 *            The world this block is in.
+	 * @param harvesterSettings
+	 *            The harvester's current settings. Do not modify these.
+	 * @param x
+	 *            The X coordinate of the block being harvested.
+	 * @param y
+	 *            The Y coordinate of the block being harvested.
+	 * @param z
+	 *            The Z coordinate of the block being harvested.
+	 *
+	 * @return True if this block can be harvested.
+	 */
+	public boolean canBeHarvested(World world, Map<String, Boolean> harvesterSettings, int x, int y, int z);
+
+	/**
+	 * @param world
+	 *            The world this block is in.
+	 * @param rand
+	 *            A Random instance to use when generating drops.
+	 * @param harvesterSettings
+	 *            The harvester's current settings. Do not modify these.
+	 * @param x
+	 *            The X coordinate of the block being harvested.
+	 * @param y
+	 *            The Y coordinate of the block being harvested.
+	 * @param z
+	 *            The Z coordinate of the block being harvested.
+	 *
+	 * @return The drops generated by breaking this block. For a default
+	 *         implementation, calling Block.getDrops() is usually
+	 *         sufficient.
+	 */
+	public List<ItemStack> getDrops(World world, Random rand, Map<String, Boolean> harvesterSettings, int x, int y, int z);
+
+	/**
+	 * Called before the block is going to be harvested, after getDrops. Usually
+	 * empty.
+	 *
+	 * @param world
+	 *            The world this block is in.
+	 * @param x
+	 *            The X coordinate of the block being harvested.
+	 * @param y
+	 *            The Y coordinate of the block being harvested.
+	 * @param z
+	 *            The Z coordinate of the block being harvested.
+	 */
+	public void preHarvest(World world, int x, int y, int z);
+
+	/**
+	 * Called after the block is going to be harvested. Used to re-till soil,
+	 * for example.
+	 *
+	 * @param world
+	 *            The world this block is in.
+	 * @param x
+	 *            The X coordinate of the block being harvested.
+	 * @param y
+	 *            The Y coordinate of the block being harvested.
+	 * @param z
+	 *            The Z coordinate of the block being harvested.
+	 */
+	public void postHarvest(World world, int x, int y, int z);
+
+}
diff --git a/src/Java/powercrystals/minefactoryreloaded/api/IFactoryPlantable.java b/src/Java/powercrystals/minefactoryreloaded/api/IFactoryPlantable.java
new file mode 100644
index 0000000000..1d620b37ed
--- /dev/null
+++ b/src/Java/powercrystals/minefactoryreloaded/api/IFactoryPlantable.java
@@ -0,0 +1,94 @@
+package powercrystals.minefactoryreloaded.api;
+
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+/**
+ * Defines a plantable object for use in the Planter.
+ *
+ * @author PowerCrystals
+ */
+public interface IFactoryPlantable {
+
+	/**
+	 * @return The item this plantable is managing.
+	 */
+	public Item getSeed();
+
+	/**
+	 * @param stack
+	 *            The stack being planted.
+	 * @param forFermenting
+	 *            True if this stack will be converted to biofuel
+	 *
+	 * @return True if this plantable can be planted (useful for metadata
+	 *         items).
+	 */
+	public boolean canBePlanted(ItemStack stack, boolean forFermenting);
+
+	/**
+	 * @param world
+	 *            The world instance this block or item will be placed into.
+	 * @param x
+	 *            The destination X coordinate.
+	 * @param y
+	 *            The destination Y coordinate.
+	 * @param z
+	 *            The destination Z coordinate.
+	 * @param stack
+	 *            The stack being planted.
+	 *
+	 * @return The block that will be placed into the world.
+	 */
+	public ReplacementBlock getPlantedBlock(World world, int x, int y, int z, ItemStack stack);
+
+	/**
+	 * @param world
+	 *            The world instance this block or item will be placed into.
+	 * @param x
+	 *            The destination X coordinate.
+	 * @param y
+	 *            The destination Y coordinate.
+	 * @param z
+	 *            The destination Z coordinate.
+	 * @param stack
+	 *            The stack being planted.
+	 *
+	 * @return True if this plantable can be placed at the provided coordinates.
+	 */
+	public boolean canBePlantedHere(World world, int x, int y, int z, ItemStack stack);
+
+	/**
+	 * Called before planting is performed. Used to till soil, for example.
+	 *
+	 * @param world
+	 *            The world instance this block or item will be placed into.
+	 * @param x
+	 *            The destination X coordinate.
+	 * @param y
+	 *            The destination Y coordinate.
+	 * @param z
+	 *            The destination Z coordinate.
+	 * @param stack
+	 *            The stack being planted.
+	 */
+	public void prePlant(World world, int x, int y, int z, ItemStack stack);
+
+	/**
+	 * Called after planting is performed. Usually empty.
+	 *
+	 * @param world
+	 *            The world instance this block or item will be placed into.
+	 * @param x
+	 *            The destination X coordinate.
+	 * @param y
+	 *            The destination Y coordinate.
+	 * @param z
+	 *            The destination Z coordinate.
+	 * @param stack
+	 *            The stack being planted.
+	 */
+	public void postPlant(World world, int x, int y, int z, ItemStack stack);
+
+}
diff --git a/src/Java/powercrystals/minefactoryreloaded/api/ReplacementBlock.java b/src/Java/powercrystals/minefactoryreloaded/api/ReplacementBlock.java
new file mode 100644
index 0000000000..c67e8a39a2
--- /dev/null
+++ b/src/Java/powercrystals/minefactoryreloaded/api/ReplacementBlock.java
@@ -0,0 +1,135 @@
+package powercrystals.minefactoryreloaded.api;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.*;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+
+public class ReplacementBlock
+{
+	protected byte _hasMeta;
+	protected int _meta;
+	protected final Block _block;
+	protected final NBTTagCompound _tileTag;
+	
+	/**
+	 * Called to replace a block in the world.
+	 * @param world The world object
+	 * @param x The X coord
+	 * @param y The Y coord
+	 * @param z The Z coord
+	 * @param stack The ItemStack being used to replace the block (may be null)
+	 * @return True if the block was set successfully
+	 */
+	public boolean replaceBlock(World world, int x, int y, int z, ItemStack stack)
+	{
+		int meta = getMeta(world, x, y, z, stack);
+		if (world.setBlock(x, y, z, _block, meta, 3))
+		{
+			if (hasTag(stack) && _block.hasTileEntity(meta))
+			{
+				TileEntity tile = world.getTileEntity(x, y, z);
+				if (tile != null)
+					tile.readFromNBT(getTag(world, x, y, z, stack));
+			}
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * Called to get the metadata of the replacement block in the world.
+	 * @param world The world object
+	 * @param x The X coord
+	 * @param y The Y coord
+	 * @param z The Z coord
+	 * @param stack The ItemStack being used to replace the block (may be null)
+	 * @return The metadata of the block
+	 */
+	protected int getMeta(World world, int x, int y, int z, ItemStack stack)
+	{
+		int m = 0;
+		if (_hasMeta > 0)
+		{
+			if (_hasMeta > 1)
+				return _meta;
+			m = stack.getItemDamage();
+			Item item = stack.getItem();
+			if (item instanceof ItemBlock)
+				m = ((ItemBlock)item).getMetadata(m);
+		}
+		return m;
+	}
+	
+	/**
+	 * Called to set the metdata of this ReplacementBlock to a fixed value
+	 * @param meta The metadata of the block 
+	 * @return This instance
+	 */
+	public ReplacementBlock setMeta(int meta)
+	{
+		if (meta >= 0)
+		{
+			_hasMeta = 2;
+			_meta = meta;
+		}
+		return this;
+	}
+	
+	/**
+	 * Called to set the metdata of this ReplacementBlock to a value read from an ItemStack
+	 * @param meta The metadata of the block 
+	 * @return This instance
+	 */
+	public ReplacementBlock setMeta(boolean hasMeta)
+	{
+		_hasMeta = (byte) (hasMeta ? 1 : 0);
+		return this;
+	}
+	
+	/**
+	 * Called to get the NBTTagCompound a TileEntity will read its state from
+	 * @param world The world object
+	 * @param x The X coord
+	 * @param y The Y coord
+	 * @param z The Z coord
+	 * @param stack The ItemStack being used to replace the block (may be null)
+	 * @return The NBTTagCompound a TileEntity will read its state from
+	 */
+	protected NBTTagCompound getTag(World world, int x, int y, int z, ItemStack stack)
+	{
+		return _tileTag;
+	}
+	
+	/**
+	 * Called to see if a TileEntity should have its state set
+	 * @param stack The ItemStack being used to replace the block (may be null)
+	 * @return True if the TileEntity should have its state set
+	 */
+	protected boolean hasTag(ItemStack stack)
+	{
+		return _tileTag != null;
+	}
+	
+	public ReplacementBlock(Item block)
+	{
+		this(Block.getBlockFromItem(block));
+	}
+	
+	public ReplacementBlock(Item block, NBTTagCompound tag)
+	{
+		this(Block.getBlockFromItem(block), tag);
+	}
+	
+	public ReplacementBlock(Block block)
+	{
+		this(block, null);
+	}
+	
+	public ReplacementBlock(Block block, NBTTagCompound tag)
+	{
+		_block = block;
+		_tileTag = tag;
+	}
+}
diff --git a/src/Java/powercrystals/minefactoryreloaded/farmables/harvestables/HarvestableShearable.java b/src/Java/powercrystals/minefactoryreloaded/farmables/harvestables/HarvestableShearable.java
new file mode 100644
index 0000000000..1719ae2486
--- /dev/null
+++ b/src/Java/powercrystals/minefactoryreloaded/farmables/harvestables/HarvestableShearable.java
@@ -0,0 +1,50 @@
+package powercrystals.minefactoryreloaded.farmables.harvestables;
+
+import java.util.*;
+
+import net.minecraft.block.Block;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.common.IShearable;
+import powercrystals.minefactoryreloaded.api.HarvestType;
+
+public class HarvestableShearable extends HarvestableStandard
+{
+	public HarvestableShearable(Block block, HarvestType harvestType)
+	{
+		super(block, harvestType);
+	}
+
+	public HarvestableShearable(Block block)
+	{
+		super(block);
+	}
+
+	@Override
+	public List<ItemStack> getDrops(World world, Random rand, Map<String, Boolean> settings, int x, int y, int z)
+	{
+		Block block = world.getBlock(x, y, z);
+		if (settings.get("silkTouch") == Boolean.TRUE)
+		{
+			if (block instanceof IShearable)
+			{
+				ItemStack stack = new ItemStack(Items.shears, 1, 0);
+				if (((IShearable)block).isShearable(stack, world, x, y, z))
+				{
+					return ((IShearable)block).onSheared(stack, world, x, y, z, 0);
+				}
+			}
+			if (Item.getItemFromBlock(block) != null)
+			{
+				ArrayList<ItemStack> drops = new ArrayList<ItemStack>();
+				int meta = block.getDamageValue(world, x, y, z);
+				drops.add(new ItemStack(block, 1, meta));
+				return drops;
+			}
+		}
+
+		return block.getDrops(world, x, y, z, world.getBlockMetadata(x, y, z), 0);
+	}
+}
diff --git a/src/Java/powercrystals/minefactoryreloaded/farmables/harvestables/HarvestableStandard.java b/src/Java/powercrystals/minefactoryreloaded/farmables/harvestables/HarvestableStandard.java
new file mode 100644
index 0000000000..eeab615ed8
--- /dev/null
+++ b/src/Java/powercrystals/minefactoryreloaded/farmables/harvestables/HarvestableStandard.java
@@ -0,0 +1,71 @@
+package powercrystals.minefactoryreloaded.farmables.harvestables;
+
+import java.util.*;
+
+import net.minecraft.block.Block;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import powercrystals.minefactoryreloaded.api.HarvestType;
+import powercrystals.minefactoryreloaded.api.IFactoryHarvestable;
+
+public class HarvestableStandard implements IFactoryHarvestable
+{
+	private Block _block;
+	private HarvestType _harvestType;
+
+	public HarvestableStandard(Block block, HarvestType harvestType)
+	{
+		if (block == Blocks.air)
+			throw new IllegalArgumentException("Passed air FactoryHarvestableStandard");
+
+		_block = block;
+		_harvestType = harvestType;
+	}
+
+	public HarvestableStandard(Block block)
+	{
+		this(block, HarvestType.Normal);
+	}
+
+	@Override
+	public Block getPlant()
+	{
+		return _block;
+	}
+
+	@Override
+	public HarvestType getHarvestType()
+	{
+		return _harvestType;
+	}
+
+	@Override
+	public boolean breakBlock()
+	{
+		return true;
+	}
+
+	@Override
+	public boolean canBeHarvested(World world, Map<String, Boolean> harvesterSettings, int x, int y, int z)
+	{
+		return true;
+	}
+
+	@Override
+	public List<ItemStack> getDrops(World world, Random rand, Map<String, Boolean> harvesterSettings, int x, int y, int z)
+	{
+		return world.getBlock(x, y, z).getDrops(world, x, y, z, world.getBlockMetadata(x, y, z), 0);
+	}
+
+	@Override
+	public void preHarvest(World world, int x, int y, int z)
+	{
+	}
+
+	@Override
+	public void postHarvest(World world, int x, int y, int z)
+	{
+		world.notifyBlocksOfNeighborChange(x, y, z, getPlant());
+	}
+}
diff --git a/src/Java/powercrystals/minefactoryreloaded/farmables/harvestables/HarvestableTreeLeaves.java b/src/Java/powercrystals/minefactoryreloaded/farmables/harvestables/HarvestableTreeLeaves.java
new file mode 100644
index 0000000000..eaa23bd847
--- /dev/null
+++ b/src/Java/powercrystals/minefactoryreloaded/farmables/harvestables/HarvestableTreeLeaves.java
@@ -0,0 +1,33 @@
+package powercrystals.minefactoryreloaded.farmables.harvestables;
+
+import net.minecraft.block.Block;
+import net.minecraft.world.World;
+import powercrystals.minefactoryreloaded.api.HarvestType;
+
+public class HarvestableTreeLeaves extends HarvestableShearable
+{
+	public HarvestableTreeLeaves(Block block)
+	{
+		super(block, HarvestType.TreeLeaf);
+	}
+
+	@Override
+	public void postHarvest(World world, int x, int y, int z)
+	{
+		Block id = getPlant();
+
+		notifyBlock(world, x, y - 1, z, id);
+		notifyBlock(world, x - 1, y, z, id);
+		notifyBlock(world, x + 1, y, z, id);
+		notifyBlock(world, x, y, z - 1, id);
+		notifyBlock(world, x, y, z + 1, id);
+		notifyBlock(world, x, y + 1, z, id);
+	}
+
+	protected void notifyBlock(World world, int x, int y, int z, Block id)
+	{
+		Block block = world.getBlock(x, y, z);
+		if (!block.isLeaves(world, x, y, z))
+			world.notifyBlockOfNeighborChange(x, y, z, id);
+	}
+}
diff --git a/src/Java/powercrystals/minefactoryreloaded/farmables/plantables/PlantableStandard.java b/src/Java/powercrystals/minefactoryreloaded/farmables/plantables/PlantableStandard.java
new file mode 100644
index 0000000000..022d947150
--- /dev/null
+++ b/src/Java/powercrystals/minefactoryreloaded/farmables/plantables/PlantableStandard.java
@@ -0,0 +1,116 @@
+package powercrystals.minefactoryreloaded.farmables.plantables;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.common.IPlantable;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.oredict.OreDictionary;
+import powercrystals.minefactoryreloaded.api.IFactoryPlantable;
+import powercrystals.minefactoryreloaded.api.ReplacementBlock;
+
+/*
+ * Used for directly placing blocks (ie saplings) and items (ie sugarcane). Pass in source ID to constructor,
+ * so one instance per source ID.
+ */
+
+public class PlantableStandard implements IFactoryPlantable
+{
+	public static final int WILDCARD = OreDictionary.WILDCARD_VALUE;
+
+	protected Item _seed;
+	protected Block _block;
+	protected ReplacementBlock _plantedBlock;
+	protected int _validMeta;
+
+	public PlantableStandard(Block block)
+	{
+		this(Item.getItemFromBlock(block), block);
+	}
+
+	public PlantableStandard(Block block, Block plantedBlock)
+	{
+		this(Item.getItemFromBlock(block), plantedBlock);
+	}
+
+	public PlantableStandard(Item block, Block plantedBlock)
+	{
+		this(block, plantedBlock, WILDCARD);
+	}
+
+	public PlantableStandard(Block block, int meta)
+	{
+		this(Item.getItemFromBlock(block), block, meta);
+	}
+
+	public PlantableStandard(Block block, Block plantedBlock, int meta)
+	{
+		this(Item.getItemFromBlock(block), plantedBlock, meta);
+	}
+
+	public PlantableStandard(Item block, Block plantedBlock, int validMeta)
+	{
+		this(block, plantedBlock, validMeta, new ReplacementBlock(plantedBlock));
+	}
+
+	public PlantableStandard(Item block, Block plantedBlock, int validMeta, int plantedMeta)
+	{
+		this(block, plantedBlock, validMeta, new ReplacementBlock(plantedBlock).setMeta(plantedMeta));
+	}
+
+	public PlantableStandard(Item block, Block plantedBlock, int validMeta, boolean useItemMeta)
+	{
+		this(block, plantedBlock, validMeta, new ReplacementBlock(plantedBlock).setMeta(useItemMeta));
+	}
+
+	public PlantableStandard(Item block, Block plantedBlock, int validMeta, ReplacementBlock repl)
+	{
+		_seed = block;
+		_block = plantedBlock;
+		_validMeta = validMeta;
+		_plantedBlock = repl;
+	}
+
+	@Override
+	public boolean canBePlanted(ItemStack stack, boolean forFermenting)
+	{
+		return _validMeta == WILDCARD || stack.getItemDamage() == _validMeta;
+	}
+
+	@Override
+	public boolean canBePlantedHere(World world, int x, int y, int z, ItemStack stack)
+	{
+		if (!world.isAirBlock(x, y, z))
+			return false;
+
+		Block groundId = world.getBlock(x, y - 1, z);
+		return (_block.canPlaceBlockAt(world, x, y, z) && _block.canReplace(world, x, y, z, 0, stack)) ||
+				(_block instanceof IPlantable && groundId != null &&
+				groundId.canSustainPlant(world, x, y, z, ForgeDirection.UP, (IPlantable)_block));
+	}
+
+	@Override
+	public void prePlant(World world, int x, int y, int z, ItemStack stack)
+	{
+		return;
+	}
+
+	@Override
+	public void postPlant(World world, int x, int y, int z, ItemStack stack)
+	{
+		return;
+	}
+
+	@Override
+	public ReplacementBlock getPlantedBlock(World world, int x, int y, int z, ItemStack stack)
+	{
+		return _plantedBlock;
+	}
+
+	@Override
+	public Item getSeed()
+	{
+		return _seed;
+	}
+}