ForestryMC/src/main/java/forestry/plugins/PluginStorage.java

/*******************************************************************************
 * Copyright (c) 2011-2014 SirSengir.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the GNU Lesser Public License v3
 * which accompanies this distribution, and is available at
 * http://www.gnu.org/licenses/lgpl-3.0.txt
 *
 * Various Contributors including, but not limited to:
 * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
 ******************************************************************************/
package forestry.plugins;

import java.awt.Color;
import java.util.ArrayList;
import java.util.List;

import net.minecraft.block.Block;
import net.minecraft.block.BlockBasePressurePlate;
import net.minecraft.block.BlockButton;
import net.minecraft.block.BlockChest;
import net.minecraft.block.BlockFence;
import net.minecraft.block.BlockFenceGate;
import net.minecraft.block.BlockFurnace;
import net.minecraft.block.BlockLadder;
import net.minecraft.block.BlockLever;
import net.minecraft.block.BlockLog;
import net.minecraft.block.BlockMelon;
import net.minecraft.block.BlockPumpkin;
import net.minecraft.block.BlockRedstoneDiode;
import net.minecraft.block.BlockStairs;
import net.minecraft.block.BlockTorch;
import net.minecraft.block.BlockTrapDoor;
import net.minecraft.block.BlockWall;
import net.minecraft.block.BlockWorkbench;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.item.Item;
import net.minecraft.item.ItemDoor;
import net.minecraft.item.ItemFood;
import net.minecraft.item.ItemStack;

import net.minecraftforge.common.IPlantable;
import net.minecraftforge.common.IShearable;

import cpw.mods.fml.common.SidedProxy;
import cpw.mods.fml.common.event.FMLInterModComms.IMCMessage;
import cpw.mods.fml.common.network.IGuiHandler;

import forestry.api.core.Tabs;
import forestry.api.recipes.RecipeManagers;
import forestry.api.storage.BackpackManager;
import forestry.api.storage.EnumBackpackType;
import forestry.api.storage.IBackpackDefinition;
import forestry.api.storage.StorageManager;
import forestry.core.config.Configuration;
import forestry.core.config.Defaults;
import forestry.core.config.ForestryBlock;
import forestry.core.config.ForestryItem;
import forestry.core.config.Property;
import forestry.core.fluids.Fluids;
import forestry.core.interfaces.IOreDictionaryHandler;
import forestry.core.interfaces.IPickupHandler;
import forestry.core.interfaces.IResupplyHandler;
import forestry.core.interfaces.ISaveEventHandler;
import forestry.core.items.ItemCrated;
import forestry.core.network.GuiId;
import forestry.core.proxy.Proxies;
import forestry.core.utils.StackUtils;
import forestry.factory.gadgets.MachineCarpenter;
import forestry.storage.BackpackDefinition;
import forestry.storage.BackpackHelper;
import forestry.storage.CrateRegistry;
import forestry.storage.GuiHandlerStorage;
import forestry.storage.PickupHandlerStorage;
import forestry.storage.ResupplyHandler;
import forestry.storage.items.ItemNaturalistBackpack;
import forestry.storage.items.ItemNaturalistBackpack.BackpackDefinitionApiarist;
import forestry.storage.items.ItemNaturalistBackpack.BackpackDefinitionLepidopterist;
import forestry.storage.proxy.ProxyStorage;

@Plugin(pluginID = "Storage", name = "Storage", author = "SirSengir", url = Defaults.URL, unlocalizedDescription = "for.plugin.storage.description")
public class PluginStorage extends ForestryPlugin implements IOreDictionaryHandler {

	private static final List<ItemCrated> crates = new ArrayList<ItemCrated>();
	private static final String CONFIG_CATEGORY = "backpacks";

	@SidedProxy(clientSide = "forestry.storage.proxy.ClientProxyStorage", serverSide = "forestry.storage.proxy.ProxyStorage")
	public static ProxyStorage proxy;
	private final ArrayList<ItemStack> minerItems = new ArrayList<ItemStack>();
	private final ArrayList<ItemStack> diggerItems = new ArrayList<ItemStack>();
	private final ArrayList<ItemStack> foresterItems = new ArrayList<ItemStack>();
	private final ArrayList<ItemStack> hunterItems = new ArrayList<ItemStack>();
	private final ArrayList<ItemStack> adventurerItems = new ArrayList<ItemStack>();
	private final ArrayList<ItemStack> builderItems = new ArrayList<ItemStack>();
	private Configuration config;

	@Override
	@SuppressWarnings({"unchecked", "rawtypes"})
	protected void setupAPI() {
		super.setupAPI();

		StorageManager.crateRegistry = new CrateRegistry();

		BackpackManager.backpackInterface = new BackpackHelper();

		BackpackManager.backpackItems = new ArrayList[6];

		BackpackManager.backpackItems[0] = minerItems;
		BackpackManager.backpackItems[1] = diggerItems;
		BackpackManager.backpackItems[2] = foresterItems;
		BackpackManager.backpackItems[3] = hunterItems;
		BackpackManager.backpackItems[4] = adventurerItems;
		BackpackManager.backpackItems[5] = builderItems;

		BackpackDefinition definition;

		if (PluginManager.Module.APICULTURE.isEnabled()) {
			definition = new BackpackDefinitionApiarist("apiarist", new Color(0xc4923d).getRGB());
			BackpackManager.definitions.put(definition.getKey(), definition);
		}

		if (PluginManager.Module.LEPIDOPTEROLOGY.isEnabled()) {
			definition = new BackpackDefinitionLepidopterist("lepidopterist", new Color(0x995b31).getRGB());
			BackpackManager.definitions.put(definition.getKey(), definition);
		}

		definition = new BackpackDefinition("miner",  new Color(0x36187d).getRGB());
		BackpackManager.definitions.put(definition.getKey(), definition);

		definition = new BackpackDefinition("digger",  new Color(0x363cc5).getRGB());
		BackpackManager.definitions.put(definition.getKey(), definition);

		definition = new BackpackDefinition("forester",  new Color(0x347427).getRGB());
		BackpackManager.definitions.put(definition.getKey(), definition);

		definition = new BackpackDefinition("hunter",  new Color(0x412215).getRGB());
		BackpackManager.definitions.put(definition.getKey(), definition);

		definition = new BackpackDefinition("adventurer",  new Color(0x7fb8c2).getRGB());
		BackpackManager.definitions.put(definition.getKey(), definition);

		definition = new BackpackDefinition("builder",  new Color(0xdd3a3a).getRGB());
		BackpackManager.definitions.put(definition.getKey(), definition);
	}

	@Override
	public void postInit() {
		scanForItems();

		config = new Configuration();

		Property backpackConf = config.get("backpacks.miner.items", CONFIG_CATEGORY, "");
		backpackConf.comment = "add additional blocks and items for the miner's backpack here in the format modid:name:meta. separate blocks and items using ';'. wildcard for metadata: '*'";
		parseBackpackItems(backpackConf.value, BackpackManager.definitions.get("miner"));
		backpackConf = config.get("backpacks.digger.items", CONFIG_CATEGORY, "");
		backpackConf.comment = "add additional blocks and items for the digger's backpack here in the format modid:name:meta. separate blocks and items using ';'. wildcard for metadata: '*'";
		parseBackpackItems(backpackConf.value, BackpackManager.definitions.get("digger"));
		backpackConf = config.get("backpacks.forester.items", CONFIG_CATEGORY, "");
		backpackConf.comment = "add additional blocks and items for the forester's backpack here in the format modid:name:meta. separate blocks and items using ';'. wildcard for metadata: '*'";
		parseBackpackItems(backpackConf.value, BackpackManager.definitions.get("forester"));
		backpackConf = config.get("backpacks.hunter.items", CONFIG_CATEGORY, "");
		backpackConf.comment = "add additional blocks and items for the hunter's backpack here in the format modid:name:meta. separate blocks and items using ';'. wildcard for metadata: '*'";
		parseBackpackItems(backpackConf.value, BackpackManager.definitions.get("hunter"));
		backpackConf = config.get("backpacks.adventurer.items", CONFIG_CATEGORY, "");
		backpackConf.comment = "add blocks and items for the adventurer's backpack here in the format modid:name:meta. separate blocks and items using ';'. wildcard for metadata: '*'";
		parseBackpackItems(backpackConf.value, BackpackManager.definitions.get("adventurer"));
		backpackConf = config.get("backpacks.builder.items", CONFIG_CATEGORY, "");
		backpackConf.comment = "add blocks and items for the builder's backpack here in the format modid:name:meta. separate blocks and items using ';'. wildcard for metadata: '*'";
		parseBackpackItems(backpackConf.value, BackpackManager.definitions.get("builder"));

		config.save();

		BackpackManager.definitions.get("miner").addValidItems(minerItems);
		BackpackManager.definitions.get("digger").addValidItems(diggerItems);
		BackpackManager.definitions.get("forester").addValidItems(foresterItems);
		BackpackManager.definitions.get("hunter").addValidItems(hunterItems);
		BackpackManager.definitions.get("adventurer").addValidItems(adventurerItems);
		BackpackManager.definitions.get("builder").addValidItems(builderItems);
	}

	public static void registerCrate(ItemCrated crate) {
		proxy.registerCrateForRendering(crate);
		crates.add(crate);
	}

	public static void createCrateRecipes() {
		MachineCarpenter.RecipeManager carpenterManager = (MachineCarpenter.RecipeManager) RecipeManagers.carpenterManager;
		for (ItemCrated crate : crates) {
			ItemStack itemStack = new ItemStack(crate);
			if (crate.usesOreDict()) {
				carpenterManager.addCratingWithOreDict(itemStack);
			} else {
				carpenterManager.addCrating(itemStack);
			}
		}
	}

	public static void addBackpackItem(String pack, ItemStack stack) {
		if (stack == null) {
			return;
		}
		BackpackManager.definitions.get(pack).addValidItem(stack);
	}

	public static void addBackpackItem(String pack, Block block) {
		BackpackManager.definitions.get(pack).addValidItem(new ItemStack(block, 1, Defaults.WILDCARD));
	}

	public static void addBackpackItem(String pack, Item item) {
		BackpackManager.definitions.get(pack).addValidItem(new ItemStack(item, 1, Defaults.WILDCARD));
	}

	public static void scanForItems() {
		for (Object id : Block.blockRegistry.getKeys()) {
			try {
				Block block = (Block) Block.blockRegistry.getObject(id);

				if (block instanceof IPlantable
						|| block instanceof IShearable
						|| block instanceof BlockLog
						|| block instanceof BlockMelon
						|| block instanceof BlockPumpkin) {
					addBackpackItem("forester", block);
				}
				if (block instanceof BlockStairs || block.getRenderType() == 10
						|| block instanceof BlockFence || block.getRenderType() == 11
						|| block instanceof BlockFenceGate || block.getRenderType() == 21
						|| block instanceof BlockWall || block.getRenderType() == 32
						|| block instanceof BlockBasePressurePlate
						|| block instanceof BlockLever
						|| block instanceof BlockButton
						|| block instanceof BlockTorch
						|| block instanceof BlockRedstoneDiode
						|| block instanceof BlockChest || block.getRenderType() == 22
						|| block instanceof BlockWorkbench
						|| block instanceof BlockFurnace
						|| block instanceof BlockLadder || block.getRenderType() == 8
						|| block instanceof BlockTrapDoor
						|| block.getUnlocalizedName().contains("door")) {
					addBackpackItem("builder", block);
				}
			} catch (Throwable error) {
				error.printStackTrace();
			}
		}

		for (Object id : Item.itemRegistry.getKeys()) {
			try {
				Item item = (Item) Item.itemRegistry.getObject(id);

				if (item instanceof IPlantable) {
					addBackpackItem("forester", item);
				} else if (item instanceof ItemFood) {
					addBackpackItem("hunter", item);
				} else if (item instanceof ItemDoor) {
					addBackpackItem("builder", item);
				}
			} catch (Throwable error) {
				error.printStackTrace();
			}
		}
	}

	@Override
	public boolean processIMCMessage(IMCMessage message) {
		if (message.key.equals("add-backpack-items")) {
			String[] tokens = message.getStringValue().split("@");
			if (tokens.length != 2) {
				logInvalidIMCMessage(message);
				return true;
			}

			if (!BackpackManager.definitions.containsKey(tokens[0])) {
				String errorMessage = getInvalidIMCMessageText(message);
				Proxies.log.warning("%s For non-existent backpack %s.", errorMessage, tokens[0]);
				return true;
			}

			parseBackpackItems(tokens[1], BackpackManager.definitions.get(tokens[0]));

			return true;
		}
		return false;
	}

	@Override
	public IPickupHandler getPickupHandler() {
		return new PickupHandlerStorage();
	}

	@Override
	public IGuiHandler getGuiHandler() {
		return new GuiHandlerStorage();
	}

	@Override
	public IResupplyHandler getResupplyHandler() {
		return new ResupplyHandler();
	}

	@Override
	protected void registerItems() {
		// CRATE
		ForestryItem.crate.registerItem((new ItemCrated(null, false)), "crate");

		// BACKPACKS
		IBackpackDefinition definition;

		if (PluginManager.Module.APICULTURE.isEnabled()) {
			definition = BackpackManager.definitions.get("apiarist");
			Item backpack = new ItemNaturalistBackpack(GuiId.ApiaristBackpackGUI.ordinal(), definition).setCreativeTab(Tabs.tabApiculture);
			ForestryItem.apiaristBackpack.registerItem(backpack, "apiaristBag");
		}

		if (PluginManager.Module.LEPIDOPTEROLOGY.isEnabled()) {
			definition = BackpackManager.definitions.get("lepidopterist");
			Item backpack = new ItemNaturalistBackpack(GuiId.LepidopteristBackpackGUI.ordinal(), definition).setCreativeTab(Tabs.tabLepidopterology);
			ForestryItem.lepidopteristBackpack.registerItem(backpack, "lepidopteristBag");
		}

		definition = BackpackManager.definitions.get("miner");
		ForestryItem.minerBackpack.registerItem(BackpackManager.backpackInterface.addBackpack(definition, EnumBackpackType.T1), "minerBag");
		ForestryItem.minerBackpackT2.registerItem(BackpackManager.backpackInterface.addBackpack(definition, EnumBackpackType.T2), "minerBagT2");

		definition = BackpackManager.definitions.get("digger");
		ForestryItem.diggerBackpack.registerItem(BackpackManager.backpackInterface.addBackpack(definition, EnumBackpackType.T1), "diggerBag");
		ForestryItem.diggerBackpackT2.registerItem(BackpackManager.backpackInterface.addBackpack(definition, EnumBackpackType.T2), "diggerBagT2");

		definition = BackpackManager.definitions.get("forester");
		ForestryItem.foresterBackpack.registerItem(BackpackManager.backpackInterface.addBackpack(definition, EnumBackpackType.T1), "foresterBag");
		ForestryItem.foresterBackpackT2.registerItem(BackpackManager.backpackInterface.addBackpack(definition, EnumBackpackType.T2), "foresterBagT2");

		definition = BackpackManager.definitions.get("hunter");
		ForestryItem.hunterBackpack.registerItem(BackpackManager.backpackInterface.addBackpack(definition, EnumBackpackType.T1), "hunterBag");
		ForestryItem.hunterBackpackT2.registerItem(BackpackManager.backpackInterface.addBackpack(definition, EnumBackpackType.T2), "hunterBagT2");

		definition = BackpackManager.definitions.get("adventurer");
		ForestryItem.adventurerBackpack.registerItem(BackpackManager.backpackInterface.addBackpack(definition, EnumBackpackType.T1), "adventurerBag");
		ForestryItem.adventurerBackpackT2.registerItem(BackpackManager.backpackInterface.addBackpack(definition, EnumBackpackType.T2), "adventurerBagT2");

		definition = BackpackManager.definitions.get("builder");
		ForestryItem.builderBackpack.registerItem(BackpackManager.backpackInterface.addBackpack(definition, EnumBackpackType.T1), "builderBag");
		ForestryItem.builderBackpackT2.registerItem(BackpackManager.backpackInterface.addBackpack(definition, EnumBackpackType.T2), "builderBagT2");
	}

	@Override
	protected void registerBackpackItems() {

		// [0] Set valid items in miner's backpack
		minerItems.add(new ItemStack(Blocks.obsidian));
		minerItems.add(new ItemStack(Blocks.coal_ore));
		minerItems.add(new ItemStack(Items.coal));
		minerItems.add(new ItemStack(Blocks.diamond_ore));
		minerItems.add(new ItemStack(Items.diamond));
		minerItems.add(new ItemStack(Blocks.gold_ore));
		minerItems.add(new ItemStack(Items.gold_ingot));
		minerItems.add(new ItemStack(Blocks.iron_ore));
		minerItems.add(new ItemStack(Items.iron_ingot));
		minerItems.add(new ItemStack(Blocks.lapis_ore));
		minerItems.add(new ItemStack(Blocks.redstone_ore));
		minerItems.add(new ItemStack(Items.redstone));
		minerItems.add(new ItemStack(Items.dye, 1, 4));
		minerItems.add(new ItemStack(Items.glowstone_dust));
		minerItems.add(new ItemStack(Items.emerald));
		minerItems.add(new ItemStack(Blocks.diamond_block));
		minerItems.add(new ItemStack(Blocks.emerald_block));
		minerItems.add(new ItemStack(Blocks.gold_block));
		minerItems.add(new ItemStack(Blocks.iron_block));
		minerItems.add(new ItemStack(Blocks.lapis_block));
		minerItems.add(ForestryItem.bronzePickaxe.getItemStack());
		minerItems.add(ForestryItem.kitPickaxe.getItemStack());
		minerItems.add(ForestryItem.brokenBronzePickaxe.getItemStack());
		minerItems.add(new ItemStack(Items.quartz));
		minerItems.add(new ItemStack(Blocks.emerald_ore));
		minerItems.add(new ItemStack(Blocks.quartz_ore));

		// [1] Set valid items in digger's backpack
		diggerItems.add(new ItemStack(Blocks.dirt));
		diggerItems.add(new ItemStack(Blocks.cobblestone));
		diggerItems.add(new ItemStack(Blocks.sand));
		diggerItems.add(new ItemStack(Blocks.sandstone));
		diggerItems.add(new ItemStack(Blocks.gravel));
		diggerItems.add(new ItemStack(Items.flint));
		diggerItems.add(new ItemStack(Blocks.netherrack));
		diggerItems.add(new ItemStack(Items.clay_ball));
		diggerItems.add(new ItemStack(Blocks.soul_sand));
		diggerItems.add(ForestryItem.bronzeShovel.getItemStack());
		diggerItems.add(ForestryItem.kitShovel.getItemStack());
		diggerItems.add(ForestryItem.brokenBronzeShovel.getItemStack());

		// [2] Set valid items in forester's backpack
		foresterItems.add(new ItemStack(Blocks.sapling, 1, Defaults.WILDCARD));
		foresterItems.add(new ItemStack(Blocks.red_mushroom));
		foresterItems.add(new ItemStack(Blocks.brown_mushroom));
		foresterItems.add(new ItemStack(Blocks.log, 1, Defaults.WILDCARD));
		foresterItems.add(new ItemStack(Items.wheat_seeds));
		foresterItems.add(new ItemStack(Blocks.red_flower));
		foresterItems.add(new ItemStack(Blocks.yellow_flower));
		foresterItems.add(new ItemStack(Blocks.leaves, 1, Defaults.WILDCARD));
		foresterItems.add(new ItemStack(Blocks.cactus));
		foresterItems.add(new ItemStack(Blocks.tallgrass, 1, Defaults.WILDCARD));
		foresterItems.add(new ItemStack(Blocks.vine));
		foresterItems.add(new ItemStack(Blocks.pumpkin));
		foresterItems.add(new ItemStack(Blocks.melon_block));
		foresterItems.add(new ItemStack(Items.apple));
		foresterItems.add(new ItemStack(Items.golden_apple));
		foresterItems.add(new ItemStack(Items.nether_wart));
		foresterItems.add(new ItemStack(Items.pumpkin_seeds));
		foresterItems.add(new ItemStack(Items.melon_seeds));
		foresterItems.add(new ItemStack(Items.wheat));
		if (PluginManager.Module.ARBORICULTURE.isEnabled()) {
			foresterItems.add(ForestryBlock.saplingGE.getWildcard());
		}

		// [3] Set valid items in hunter's backpack
		hunterItems.add(new ItemStack(Items.feather));
		hunterItems.add(new ItemStack(Items.gunpowder));
		hunterItems.add(new ItemStack(Items.blaze_powder));
		hunterItems.add(new ItemStack(Items.blaze_rod));
		hunterItems.add(new ItemStack(Items.bone));
		hunterItems.add(new ItemStack(Items.string));
		hunterItems.add(new ItemStack(Items.rotten_flesh));
		hunterItems.add(new ItemStack(Items.ghast_tear));
		hunterItems.add(new ItemStack(Items.gold_nugget));
		hunterItems.add(new ItemStack(Items.arrow));
		hunterItems.add(new ItemStack(Items.porkchop));
		hunterItems.add(new ItemStack(Items.cooked_porkchop));
		hunterItems.add(new ItemStack(Items.beef));
		hunterItems.add(new ItemStack(Items.cooked_beef));
		hunterItems.add(new ItemStack(Items.chicken));
		hunterItems.add(new ItemStack(Items.cooked_chicken));
		hunterItems.add(new ItemStack(Items.leather));
		hunterItems.add(new ItemStack(Items.egg));
		hunterItems.add(new ItemStack(Items.ender_pearl));
		hunterItems.add(new ItemStack(Items.spider_eye));
		hunterItems.add(new ItemStack(Items.fermented_spider_eye));
		hunterItems.add(new ItemStack(Items.slime_ball));
		hunterItems.add(new ItemStack(Items.dye, 1, 0));
		hunterItems.add(new ItemStack(Blocks.hay_block));
		hunterItems.add(new ItemStack(Blocks.wool));
		hunterItems.add(new ItemStack(Blocks.wool, 1, Defaults.WILDCARD));
		hunterItems.add(new ItemStack(Items.ender_eye));
		hunterItems.add(new ItemStack(Items.magma_cream));
		hunterItems.add(new ItemStack(Items.speckled_melon));
		hunterItems.add(new ItemStack(Items.fish));
		hunterItems.add(new ItemStack(Items.cooked_fished));
		hunterItems.add(new ItemStack(Items.lead));
		hunterItems.add(new ItemStack(Items.fishing_rod));
		hunterItems.add(new ItemStack(Items.name_tag));
		hunterItems.add(new ItemStack(Items.saddle));
		hunterItems.add(new ItemStack(Items.diamond_horse_armor));
		hunterItems.add(new ItemStack(Items.golden_horse_armor));
		hunterItems.add(new ItemStack(Items.iron_horse_armor));

		// [4] Set valid items in adventurer's backpack

		// [5] Set valid items in builder's backpack
		if (PluginManager.Module.APICULTURE.isEnabled()) {
			builderItems.add(ForestryBlock.candle.getWildcard());
			builderItems.add(ForestryBlock.stump.getWildcard());
		}

		builderItems.add(new ItemStack(Blocks.torch));
		builderItems.add(new ItemStack(Blocks.redstone_torch));
		builderItems.add(new ItemStack(Blocks.redstone_lamp));
		builderItems.add(new ItemStack(Blocks.stonebrick, 1, Defaults.WILDCARD));
		builderItems.add(new ItemStack(Blocks.sandstone, 1, 1));
		builderItems.add(new ItemStack(Blocks.sandstone, 1, 2));
		builderItems.add(new ItemStack(Blocks.stone));
		builderItems.add(new ItemStack(Blocks.brick_block));
		builderItems.add(new ItemStack(Blocks.planks, 1, Defaults.WILDCARD));
		builderItems.add(new ItemStack(Blocks.clay));
		builderItems.add(new ItemStack(Blocks.hardened_clay, 1, Defaults.WILDCARD));
		builderItems.add(new ItemStack(Blocks.stained_hardened_clay, 1, Defaults.WILDCARD));
		builderItems.add(new ItemStack(Blocks.packed_ice));
		builderItems.add(new ItemStack(Blocks.nether_brick));
		builderItems.add(new ItemStack(Blocks.nether_brick_fence));
		builderItems.add(new ItemStack(Blocks.stone_stairs));
		builderItems.add(new ItemStack(Blocks.oak_stairs));
		builderItems.add(new ItemStack(Blocks.brick_stairs));
		builderItems.add(new ItemStack(Blocks.nether_brick_stairs));
		builderItems.add(new ItemStack(Blocks.stone_brick_stairs));
		builderItems.add(new ItemStack(Blocks.glass));
		builderItems.add(new ItemStack(Blocks.glass_pane));
		builderItems.add(new ItemStack(Blocks.chest));
		builderItems.add(new ItemStack(Blocks.crafting_table));
		builderItems.add(new ItemStack(Blocks.furnace));
		builderItems.add(new ItemStack(Blocks.lever));
		builderItems.add(new ItemStack(Blocks.wooden_button));
		builderItems.add(new ItemStack(Blocks.stone_button));
		builderItems.add(new ItemStack(Blocks.dispenser));
		builderItems.add(new ItemStack(Blocks.dropper));
		builderItems.add(new ItemStack(Blocks.ladder));
		builderItems.add(new ItemStack(Blocks.fence));
		builderItems.add(new ItemStack(Blocks.fence_gate));
		builderItems.add(new ItemStack(Blocks.iron_bars));
		builderItems.add(new ItemStack(Blocks.stone_slab, 1, Defaults.WILDCARD));
		builderItems.add(new ItemStack(Blocks.quartz_block, 1, Defaults.WILDCARD));
		builderItems.add(new ItemStack(Blocks.quartz_stairs));
		builderItems.add(new ItemStack(Blocks.sandstone_stairs));
		builderItems.add(new ItemStack(Blocks.birch_stairs));
		builderItems.add(new ItemStack(Blocks.spruce_stairs));
		builderItems.add(new ItemStack(Blocks.jungle_stairs));
		builderItems.add(new ItemStack(Blocks.cobblestone_wall, 1, Defaults.WILDCARD));
		builderItems.add(new ItemStack(Items.iron_door));
		builderItems.add(new ItemStack(Items.wooden_door));
		builderItems.add(new ItemStack(Items.sign));
		builderItems.add(new ItemStack(Items.repeater));
		builderItems.add(new ItemStack(Items.comparator));
		builderItems.add(new ItemStack(Items.item_frame));
	}

	@Override
	protected void registerRecipes() {

		if (PluginManager.Module.APICULTURE.isEnabled()) {
			// Apiarist's Backpack
			Proxies.common.addRecipe(ForestryItem.apiaristBackpack.getItemStack(),
					"X#X",
					"VYV",
					"X#X",
					'#', Blocks.wool,
					'X', Items.string,
					'V', "stickWood",
					'Y', ForestryBlock.apiculture.getItemStack(1, Defaults.DEFINITION_APIARISTCHEST_META));
		}

		if (PluginManager.Module.LEPIDOPTEROLOGY.isEnabled()) {
			// Lepidopterist's Backpack
			Proxies.common.addRecipe(ForestryItem.lepidopteristBackpack.getItemStack(),
					"X#X",
					"VYV",
					"X#X",
					'#', Blocks.wool,
					'X', Items.string,
					'V', "stickWood",
					'Y', ForestryBlock.lepidopterology.getItemStack(1, Defaults.DEFINITION_LEPICHEST_META));
		}

		// Miner's Backpack
		Proxies.common.addRecipe(ForestryItem.minerBackpack.getItemStack(),
				"X#X", "VYV", "X#X", '#', Blocks.wool, 'X', Items.string, 'V',
				Items.iron_ingot, 'Y', Blocks.chest);
		// Digger's Backpack
		Proxies.common.addRecipe(ForestryItem.diggerBackpack.getItemStack(),
				"X#X", "VYV", "X#X", '#', Blocks.wool, 'X', Items.string, 'V',
				Blocks.stone, 'Y', Blocks.chest);
		// Forester's Backpack
		Proxies.common.addRecipe(ForestryItem.foresterBackpack.getItemStack(), "X#X", "VYV", "X#X", '#', Blocks.wool,
				'X', Items.string, 'V', "logWood", 'Y', Blocks.chest);
		// Hunter's Backpack
		Proxies.common.addRecipe(ForestryItem.hunterBackpack.getItemStack(),
				"X#X", "VYV", "X#X", '#', Blocks.wool, 'X', Items.string, 'V',
				Items.feather, 'Y', Blocks.chest);
		// Adventurer's Backpack
		Proxies.common.addRecipe(ForestryItem.adventurerBackpack.getItemStack(), "X#X", "VYV", "X#X", '#', Blocks.wool,
				'X', Items.string, 'V', Items.bone, 'Y', Blocks.chest);
		// Builder's Backpack
		Proxies.common.addRecipe(ForestryItem.builderBackpack.getItemStack(), "X#X", "VYV", "X#X", '#', Blocks.wool,
				'X', Items.string, 'V', Items.clay_ball, 'Y', Blocks.chest);

		if (PluginManager.Module.FACTORY.isEnabled()) {
			// / CARPENTER

			// / CRATES
			RecipeManagers.carpenterManager.addRecipe(20, Fluids.WATER.getFluid(1000), null, ForestryItem.crate.getItemStack(24),
					" # ", "# #", " # ", '#', "logWood");

			// / BACKPACKS T2
			RecipeManagers.carpenterManager.addRecipe(200, Fluids.WATER.getFluid(1000), null, ForestryItem.minerBackpackT2.getItemStack(),
					"WXW", "WTW", "WWW", 'X', Items.diamond, 'W',
					ForestryItem.craftingMaterial.getItemStack(1, 3), 'T', ForestryItem.minerBackpack);
			RecipeManagers.carpenterManager.addRecipe(200, Fluids.WATER.getFluid(1000), null, ForestryItem.diggerBackpackT2.getItemStack(),
					"WXW", "WTW", "WWW", 'X', Items.diamond, 'W',
					ForestryItem.craftingMaterial.getItemStack(1, 3), 'T', ForestryItem.diggerBackpack);
			RecipeManagers.carpenterManager.addRecipe(200, Fluids.WATER.getFluid(1000), null, ForestryItem.foresterBackpackT2.getItemStack(),
					"WXW", "WTW", "WWW", 'X', Items.diamond, 'W',
					ForestryItem.craftingMaterial.getItemStack(1, 3), 'T', ForestryItem.foresterBackpack);
			RecipeManagers.carpenterManager.addRecipe(200, Fluids.WATER.getFluid(1000), null, ForestryItem.hunterBackpackT2.getItemStack(),
					"WXW", "WTW", "WWW", 'X', Items.diamond, 'W',
					ForestryItem.craftingMaterial.getItemStack(1, 3), 'T', ForestryItem.hunterBackpack);
			RecipeManagers.carpenterManager.addRecipe(200, Fluids.WATER.getFluid(1000), null, ForestryItem.adventurerBackpackT2.getItemStack(),
					"WXW", "WTW", "WWW", 'X', Items.diamond, 'W',
					ForestryItem.craftingMaterial.getItemStack(1, 3), 'T', ForestryItem.adventurerBackpack);
			RecipeManagers.carpenterManager.addRecipe(200, Fluids.WATER.getFluid(1000), null, ForestryItem.builderBackpackT2.getItemStack(),
					"WXW", "WTW", "WWW", 'X', Items.diamond, 'W',
					ForestryItem.craftingMaterial.getItemStack(1, 3), 'T', ForestryItem.builderBackpack);
		}
	}

	@Override
	protected void registerCrates() {
	}

	private static void parseBackpackItems(String list, IBackpackDefinition target) {
		List<ItemStack> backpackItems = StackUtils.parseItemStackStrings(list);
		target.addValidItems(backpackItems);
	}

	@Override
	public ISaveEventHandler getSaveEventHandler() {
		return null;
	}

	@Override
	public IOreDictionaryHandler getDictionaryHandler() {
		return this;
	}

	@Override
	public void onOreRegistration(String name, ItemStack ore) {

		if (ore == null) {
			Proxies.log.warning("An ore/item of type %s was registered with the Forge ore dictionary, however the passed itemstack is null. Someone broke it. :(", name);
			return;
		}

		if (name.startsWith("ingot")) {
			minerItems.add(ore);
		} else if (name.startsWith("ore")) {
			minerItems.add(ore);
		} else if (name.startsWith("gem")) {
			minerItems.add(ore);
		} else if (name.startsWith("dust")) {
			minerItems.add(ore);
		} else if (name.startsWith("crystal")) {
			minerItems.add(ore);
		} else if (name.startsWith("cluster")) {
			minerItems.add(ore);
		} else if (name.startsWith("shard")) {
			minerItems.add(ore);
		} else if (name.startsWith("clump")) {
			minerItems.add(ore);
		} else if (name.matches("dropUranium")) {
			minerItems.add(ore);
		} else if (name.equals("treeLeaves") || name.equals("treeSapling") || name.equals("logWood")) {
			foresterItems.add(ore);
		} else if (name.equals("stairWood") || name.equals("plankWood") || name.equals("slabWood")) {
			builderItems.add(ore);
		} else if (name.startsWith("wood")) {
			foresterItems.add(ore);
		}
	}
}