Attempt to fix 1.16.3 branch's issues on the repository

Added the original 'wayoftime' folder back, so see if that fixed the multiple folder issue.

src/main/java/wayoftime/bloodmagic/BloodMagic.java

@@ -0,0 +1,249 @@
+package wayoftime.bloodmagic;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import com.google.gson.Gson;
+
+import net.minecraft.block.Block;
+import net.minecraft.data.DataGenerator;
+import net.minecraft.fluid.Fluid;
+import net.minecraft.item.ItemGroup;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.IRecipeSerializer;
+import net.minecraft.potion.Effect;
+import net.minecraft.tileentity.TileEntityType;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.model.generators.ItemModelProvider;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.common.crafting.CraftingHelper;
+import net.minecraftforge.event.RegistryEvent;
+import net.minecraftforge.eventbus.api.IEventBus;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.fml.client.registry.RenderingRegistry;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
+import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
+import net.minecraftforge.fml.event.lifecycle.FMLLoadCompleteEvent;
+import net.minecraftforge.fml.event.lifecycle.GatherDataEvent;
+import net.minecraftforge.fml.event.lifecycle.InterModEnqueueEvent;
+import net.minecraftforge.fml.event.lifecycle.InterModProcessEvent;
+import net.minecraftforge.fml.event.server.FMLServerStartingEvent;
+import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
+import wayoftime.bloodmagic.api.impl.BloodMagicAPI;
+import wayoftime.bloodmagic.api.impl.BloodMagicCorePlugin;
+import wayoftime.bloodmagic.client.ClientEvents;
+import wayoftime.bloodmagic.client.render.entity.BloodLightRenderer;
+import wayoftime.bloodmagic.client.render.entity.SoulSnareRenderer;
+import wayoftime.bloodmagic.common.block.BloodMagicBlocks;
+import wayoftime.bloodmagic.common.data.GeneratorBaseRecipes;
+import wayoftime.bloodmagic.common.data.GeneratorBlockStates;
+import wayoftime.bloodmagic.common.data.GeneratorBlockTags;
+import wayoftime.bloodmagic.common.data.GeneratorItemModels;
+import wayoftime.bloodmagic.common.data.GeneratorItemTags;
+import wayoftime.bloodmagic.common.data.GeneratorLanguage;
+import wayoftime.bloodmagic.common.data.GeneratorLootTable;
+import wayoftime.bloodmagic.common.data.recipe.BloodMagicRecipeProvider;
+import wayoftime.bloodmagic.common.item.BloodMagicItems;
+import wayoftime.bloodmagic.common.registries.BloodMagicEntityTypes;
+import wayoftime.bloodmagic.common.registries.BloodMagicRecipeSerializers;
+import wayoftime.bloodmagic.core.recipe.IngredientBloodOrb;
+import wayoftime.bloodmagic.core.registry.OrbRegistry;
+import wayoftime.bloodmagic.network.BloodMagicPacketHandler;
+import wayoftime.bloodmagic.potion.BloodMagicPotions;
+import wayoftime.bloodmagic.ritual.RitualManager;
+import wayoftime.bloodmagic.tile.TileAlchemicalReactionChamber;
+import wayoftime.bloodmagic.tile.TileAlchemyArray;
+import wayoftime.bloodmagic.tile.TileAltar;
+import wayoftime.bloodmagic.tile.TileMasterRitualStone;
+import wayoftime.bloodmagic.tile.TileSoulForge;
+import wayoftime.bloodmagic.util.handler.event.GenericHandler;
+import wayoftime.bloodmagic.util.handler.event.WillHandler;
+
+@Mod("bloodmagic")
+//@Mod.EventBusSubscriber(bus = Mod.EventBusSubscriber.Bus.MOD)
+public class BloodMagic
+{
+	public static final String MODID = "bloodmagic";
+	// Directly reference a log4j logger.
+	public static final Logger LOGGER = LogManager.getLogger();
+
+	private static Gson GSON = null;
+
+	public static final BloodMagicPacketHandler packetHandler = new BloodMagicPacketHandler();
+	public static final RitualManager RITUAL_MANAGER = new RitualManager();
+
+	public BloodMagic()
+	{
+		IEventBus modBus = FMLJavaModLoadingContext.get().getModEventBus();
+
+		modBus.addListener(this::setup);
+		modBus.addListener(this::onLoadComplete);
+
+		BloodMagicBlocks.BLOCKS.register(modBus);
+		BloodMagicItems.ITEMS.register(modBus);
+//		RegistrarBloodMagic.BLOOD_ORBS.createAndRegister(modBus, "bloodorbs");
+		BloodMagicItems.BLOOD_ORBS.createAndRegister(modBus, "bloodorbs");
+		BloodMagicItems.BASICITEMS.register(modBus);
+		BloodMagicBlocks.BASICBLOCKS.register(modBus);
+		BloodMagicBlocks.FLUIDS.register(modBus);
+		BloodMagicBlocks.CONTAINERS.register(modBus);
+		BloodMagicEntityTypes.ENTITY_TYPES.register(modBus);
+
+		BloodMagicRecipeSerializers.RECIPE_SERIALIZERS.register(modBus);
+
+		// Register the setup method for modloading
+		modBus.addListener(this::setup);
+		// Register the enqueueIMC method for modloading
+		modBus.addListener(this::enqueueIMC);
+		// Register the processIMC method for modloading
+		modBus.addListener(this::processIMC);
+		// Register the doClientStuff method for modloading
+		modBus.addListener(this::doClientStuff);
+		modBus.addListener(this::gatherData);
+
+		modBus.addGenericListener(Fluid.class, this::registerFluids);
+		modBus.addGenericListener(TileEntityType.class, this::registerTileEntityTypes);
+		modBus.addGenericListener(IRecipeSerializer.class, this::registerRecipes);
+		modBus.addGenericListener(Effect.class, BloodMagicPotions::registerPotions);
+
+		MinecraftForge.EVENT_BUS.register(new GenericHandler());
+
+		MinecraftForge.EVENT_BUS.register(new WillHandler());
+//		MinecraftForge.EVENT_BUS.register(new BloodMagicBlocks());
+//		MinecraftForge.EVENT_BUS.addListener(this::commonSetup);
+
+		// Register ourselves for server and other game events we are interested in
+		MinecraftForge.EVENT_BUS.register(this);
+	}
+
+	private void registerRecipes(RegistryEvent.Register<IRecipeSerializer<?>> event)
+	{
+//		System.out.println("Registering IngredientBloodOrb Serializer.");
+		CraftingHelper.register(IngredientBloodOrb.NAME, IngredientBloodOrb.Serializer.INSTANCE);
+
+//        event.getRegistry().registerAll(
+//                new SewingRecipe.Serializer().setRegistryName("sewing")
+//        );
+	}
+
+	public static ResourceLocation rl(String name)
+	{
+		return new ResourceLocation(BloodMagic.MODID, name);
+	}
+
+	public void registerFluids(RegistryEvent.Register<Fluid> event)
+	{
+
+	}
+
+	public void onLoadComplete(FMLLoadCompleteEvent event)
+	{
+		OrbRegistry.tierMap.put(BloodMagicItems.ORB_WEAK.get().getTier(), new ItemStack(BloodMagicItems.WEAK_BLOOD_ORB.get()));
+		OrbRegistry.tierMap.put(BloodMagicItems.ORB_APPRENTICE.get().getTier(), new ItemStack(BloodMagicItems.APPRENTICE_BLOOD_ORB.get()));
+		OrbRegistry.tierMap.put(BloodMagicItems.ORB_MAGICIAN.get().getTier(), new ItemStack(BloodMagicItems.MAGICIAN_BLOOD_ORB.get()));
+		OrbRegistry.tierMap.put(BloodMagicItems.ORB_MASTER.get().getTier(), new ItemStack(BloodMagicItems.MASTER_BLOOD_ORB.get()));
+		BloodMagicCorePlugin.INSTANCE.register(BloodMagicAPI.INSTANCE);
+		RITUAL_MANAGER.discover();
+	}
+
+	public void registerTileEntityTypes(RegistryEvent.Register<TileEntityType<?>> event)
+	{
+		LOGGER.info("Attempting to register Tile Entities");
+		event.getRegistry().register(TileEntityType.Builder.create(TileAltar::new, BloodMagicBlocks.BLOOD_ALTAR.get()).build(null).setRegistryName("altar"));
+		event.getRegistry().register(TileEntityType.Builder.create(TileAlchemyArray::new, BloodMagicBlocks.ALCHEMY_ARRAY.get()).build(null).setRegistryName("alchemyarray"));
+		event.getRegistry().register(TileEntityType.Builder.create(TileSoulForge::new, BloodMagicBlocks.SOUL_FORGE.get()).build(null).setRegistryName("soulforge"));
+		event.getRegistry().register(TileEntityType.Builder.create(TileMasterRitualStone::new, BloodMagicBlocks.MASTER_RITUAL_STONE.get()).build(null).setRegistryName("masterritualstone"));
+		event.getRegistry().register(TileEntityType.Builder.create(TileAlchemicalReactionChamber::new, BloodMagicBlocks.ALCHEMICAL_REACTION_CHAMBER.get()).build(null).setRegistryName("alchemicalreactionchamber"));
+	}
+
+	@SubscribeEvent
+	public void gatherData(GatherDataEvent event)
+	{
+//		GSON = new GsonBuilder().registerTypeAdapter(Variant.class, new Variant.Deserializer()).registerTypeAdapter(ItemCameraTransforms.class, new ItemCameraTransforms.Deserializer()).registerTypeAdapter(ItemTransformVec3f.class, new ItemTransformVec3f.Deserializer()).create();
+
+		DataGenerator gen = event.getGenerator();
+
+//        if(event.includeClient())
+		{
+			ItemModelProvider itemModels = new GeneratorItemModels(gen, event.getExistingFileHelper());
+			gen.addProvider(itemModels);
+			gen.addProvider(new GeneratorBlockStates(gen, itemModels.existingFileHelper));
+			gen.addProvider(new GeneratorLanguage(gen));
+			gen.addProvider(new BloodMagicRecipeProvider(gen));
+			gen.addProvider(new GeneratorBaseRecipes(gen));
+			gen.addProvider(new GeneratorLootTable(gen));
+
+			GeneratorBlockTags bmBlockTags = new GeneratorBlockTags(gen, event.getExistingFileHelper());
+			gen.addProvider(bmBlockTags);
+			gen.addProvider(new GeneratorItemTags(gen, bmBlockTags, event.getExistingFileHelper()));
+
+		}
+	}
+
+	private void setup(final FMLCommonSetupEvent event)
+	{
+		// some preinit code
+//		LOGGER.info("HELLO FROM PREINIT");
+//		LOGGER.info("DIRT BLOCK >> {}", Blocks.DIRT.getRegistryName());
+		packetHandler.initialize();
+	}
+
+	private void doClientStuff(final FMLClientSetupEvent event)
+	{
+		// do something that can only be done on the client
+//		LOGGER.info("Got game settings {}", event.getMinecraftSupplier().get().gameSettings);
+		ClientEvents.registerContainerScreens();
+
+		RenderingRegistry.registerEntityRenderingHandler(BloodMagicEntityTypes.SNARE.getEntityType(), SoulSnareRenderer::new);
+		RenderingRegistry.registerEntityRenderingHandler(BloodMagicEntityTypes.BLOOD_LIGHT.getEntityType(), BloodLightRenderer::new);
+		ClientEvents.registerItemModelProperties(event);
+	}
+
+	private void enqueueIMC(final InterModEnqueueEvent event)
+	{
+		// some example code to dispatch IMC to another mod
+//		InterModComms.sendTo("examplemod", "helloworld", () -> {
+//			LOGGER.info("Hello world from the MDK");
+//			return "Hello world";
+//		});
+	}
+
+	private void processIMC(final InterModProcessEvent event)
+	{
+		// some example code to receive and process InterModComms from other mods
+//		LOGGER.info("Got IMC {}", event.getIMCStream().map(m -> m.getMessageSupplier().get()).collect(Collectors.toList()));
+	}
+
+	// You can use SubscribeEvent and let the Event Bus discover methods to call
+	@SubscribeEvent
+	public void onServerStarting(FMLServerStartingEvent event)
+	{
+		// do something when the server starts
+//		LOGGER.info("HELLO from server starting");
+	}
+
+	// You can use EventBusSubscriber to automatically subscribe events on the
+	// contained class (this is subscribing to the MOD
+	// Event bus for receiving Registry Events)
+	@Mod.EventBusSubscriber(bus = Mod.EventBusSubscriber.Bus.MOD)
+	public static class RegistryEvents
+	{
+		@SubscribeEvent
+		public static void onBlocksRegistry(final RegistryEvent.Register<Block> blockRegistryEvent)
+		{
+			// register a new block here
+//			LOGGER.info("HELLO from Register Block");
+		}
+	}
+
+	// Custom ItemGroup TAB
+	public static final ItemGroup TAB = new ItemGroup("bloodmagictab")
+	{
+		@Override
+		public ItemStack createIcon()
+		{
+			return new ItemStack(BloodMagicBlocks.BLOOD_ALTAR.get());
+		}
+	};
+}

src/main/java/wayoftime/bloodmagic/ConfigHandler.java

@@ -0,0 +1,135 @@
+package wayoftime.bloodmagic;
+
+import net.minecraftforge.fml.common.Mod;
+
+@Mod.EventBusSubscriber(modid = BloodMagic.MODID)
+public class ConfigHandler
+{
+	// Most of this stuff is commented out because a proper replacement for the
+	// ConfigHandler is not yet implemented.
+
+//	@Config.Comment(
+//	{ "General settings" })
+//	public static ConfigGeneral general = new ConfigGeneral();
+//	@Config.Comment(
+//	{ "Blacklist options for various features" })
+//	public static ConfigBlacklist blacklist = new ConfigBlacklist();
+//	@Config.Comment(
+//	{ "Value modifiers for various features" })
+//	public static ConfigValues values = new ConfigValues();
+//	@Config.Comment(
+//	{ "Settings that only pertain to the client" })
+//	public static ConfigClient client = new ConfigClient();
+//	@Config.Comment(
+//	{ "Compatibility settings" })
+//	public static ConfigCompat compat = new ConfigCompat();
+//
+//	@SubscribeEvent
+//	public static void onConfigChanged(ConfigChangedEvent.OnConfigChangedEvent event)
+//	{
+//		if (event.getModID().equals(BloodMagic.MODID))
+//		{
+//			ConfigManager.sync(event.getModID(), Config.Type.INSTANCE); // Sync config values
+//			BloodMagic.RITUAL_MANAGER.syncConfig();
+//			MeteorConfigHandler.handleMeteors(false); // Reload meteors
+//		}
+//	}
+//
+//	public static class ConfigGeneral
+//	{
+//		@Config.Comment(
+//		{ "Enables extra information to be printed to the log.", "Warning: May drastically increase log size." })
+//		public boolean enableDebugLogging = false;
+//		@Config.Comment(
+//		{ "Enables extra information to be printed to the log." })
+//		public boolean enableAPILogging = false;
+//		@Config.Comment(
+//		{ "Enables extra information to be printed to the log.", "Warning: May drastically increase log size." })
+//		public boolean enableVerboseAPILogging = false;
+//		@Config.Comment(
+//		{ "Enables tier 6 related registrations. This is for pack makers." })
+//		@Config.RequiresMcRestart
+//		public boolean enableTierSixEvenThoughThereIsNoContent = false;
+//	}
+//
+//	public static class ConfigBlacklist
+//	{
+//		@Config.Comment(
+//		{ "Stops listed blocks and entities from being teleposed.",
+//				"Use the registry name of the block or entity. Vanilla objects do not require the modid.",
+//				"If a block is specified, you can list the variants to only blacklist a given state." })
+//		public String[] teleposer =
+//		{ "bedrock", "mob_spawner" };
+//		@Config.Comment(
+//		{ "Stops listed blocks from being transposed.",
+//				"Use the registry name of the block. Vanilla blocks do not require the modid." })
+//		public String[] transposer =
+//		{ "bedrock", "mob_spawner" };
+//		@Config.Comment(
+//		{ "Stops the listed entities from being used in the Well of Suffering.",
+//				"Use the registry name of the entity. Vanilla entities do not require the modid." })
+//		public String[] wellOfSuffering =
+//		{};
+//	}
+//
+//	public static class ConfigValues
+//	{
+//		@Config.Comment(
+//		{ "Declares the amount of LP gained per HP sacrificed for the given entity.",
+//				"Setting the value to 0 will blacklist it.",
+//				"Use the registry name of the entity followed by a ';' and then the value you want.",
+//				"Vanilla entities do not require the modid." })
+//		public String[] sacrificialValues =
+//		{ "villager;100", "slime;15", "enderman;10", "cow;100", "chicken;100", "horse;100", "sheep;100", "wolf;100",
+//				"ocelot;100", "pig;100", "rabbit;100" };
+//		@Config.Comment(
+//		{ "Amount of LP the Coat of Arms should provide for each damage dealt." })
+//		@Config.RangeInt(min = 0, max = 100)
+//		public int coatOfArmsConversion = 20;
+//		@Config.Comment(
+//		{ "Amount of LP the Sacrificial Dagger should provide for each damage dealt." })
+//		@Config.RangeInt(min = 0, max = 10000)
+//		public int sacrificialDaggerConversion = 100;
+//		@Config.Comment(
+//		{ "Will rewrite any default meteor types with new versions.",
+//				"Disable this if you want any of your changes to stay, or do not want default meteor types regenerated." })
+//		public boolean shouldResyncMeteors = true;
+//		@Config.Comment(
+//		{ "Should mobs that die through the Well of Suffering Ritual drop items?" })
+//		public boolean wellOfSufferingDrops = true;
+//	}
+//
+//	public static class ConfigClient
+//	{
+//		@Config.Comment(
+//		{ "Always render the beams between routing nodes.",
+//				"If disabled, the beams will only render while the Node Router is held." })
+//		public boolean alwaysRenderRoutingLines = false;
+//		@Config.Comment(
+//		{ "Completely hide spectral blocks from view.", "If disabled, a transparent block will be displayed." })
+//		public boolean invisibleSpectralBlocks = true;
+//		@Config.Comment(
+//		{ "When cycling through slots, the Sigil of Holding will skip over empty slots and move to the next occupied one.",
+//				"If disabled, it will behave identically to the default hotbar." })
+//		public boolean sigilHoldingSkipsEmptySlots = false;
+//	}
+//
+//	public static class ConfigCompat
+//	{
+//		@Config.Comment(
+//		{ "The display mode to use when looking at a Blood Altar.", "ALWAYS - Always display information.",
+//				"SIGIL_HELD - Only display information when a Divination or Seers sigil is held in either hand.",
+//				"SIGIL_CONTAINED - Only display information when a Divination or Seers sigil is somewhere in the inventory." })
+//		public AltarDisplayMode wailaAltarDisplayMode = AltarDisplayMode.SIGIL_HELD;
+//
+//		public enum AltarDisplayMode
+//		{
+//			ALWAYS, SIGIL_HELD, SIGIL_CONTAINED,;
+//		}
+//	}
+
+	public static class values
+	{
+		public static int sacrificialDaggerConversion = 100;
+	}
+}

src/main/java/wayoftime/bloodmagic/altar/AltarComponent.java

@@ -0,0 +1,62 @@
+package wayoftime.bloodmagic.altar;
+
+import net.minecraft.util.math.BlockPos;
+
+/**
+ * Used for building the altar structure.
+ */
+public class AltarComponent
+{
+	private final BlockPos offset;
+	private final ComponentType component;
+	private boolean upgradeSlot;
+
+	/**
+	 * Sets a component location for the altar.
+	 *
+	 * @param offset    - Where the block should be in relation to the Altar
+	 * @param component - The type of Component the location should contain
+	 */
+	public AltarComponent(BlockPos offset, ComponentType component)
+	{
+		this.offset = offset;
+		this.component = component;
+	}
+
+	/**
+	 * Use for setting a location at which there must be a block, but the type of
+	 * block does not matter.
+	 *
+	 * @param offset - Where the block should be in relation to the Altar
+	 */
+	public AltarComponent(BlockPos offset)
+	{
+		this(offset, ComponentType.NOTAIR);
+	}
+
+	/**
+	 * Sets the location to an upgrade slot.
+	 *
+	 * @return the current instance for further use.
+	 */
+	public AltarComponent setUpgradeSlot()
+	{
+		this.upgradeSlot = true;
+		return this;
+	}
+
+	public BlockPos getOffset()
+	{
+		return offset;
+	}
+
+	public boolean isUpgradeSlot()
+	{
+		return upgradeSlot;
+	}
+
+	public ComponentType getComponent()
+	{
+		return component;
+	}
+}

src/main/java/wayoftime/bloodmagic/altar/AltarTier.java

@@ -0,0 +1,172 @@
+package wayoftime.bloodmagic.altar;
+
+import java.util.List;
+import java.util.function.Consumer;
+
+import com.google.common.collect.Lists;
+
+import net.minecraft.util.math.BlockPos;
+
+public enum AltarTier
+{
+	ONE()
+	{
+		@Override
+		public void buildComponents(Consumer<AltarComponent> components)
+		{
+			// Nada
+		}
+	},
+	TWO()
+	{
+		@Override
+		public void buildComponents(Consumer<AltarComponent> components)
+		{
+			components.accept(new AltarComponent(new BlockPos(-1, -1, -1), ComponentType.BLOODRUNE));
+			components.accept(new AltarComponent(new BlockPos(0, -1, -1), ComponentType.BLOODRUNE).setUpgradeSlot());
+			components.accept(new AltarComponent(new BlockPos(1, -1, -1), ComponentType.BLOODRUNE));
+			components.accept(new AltarComponent(new BlockPos(-1, -1, 0), ComponentType.BLOODRUNE).setUpgradeSlot());
+			components.accept(new AltarComponent(new BlockPos(1, -1, 0), ComponentType.BLOODRUNE).setUpgradeSlot());
+			components.accept(new AltarComponent(new BlockPos(-1, -1, 1), ComponentType.BLOODRUNE));
+			components.accept(new AltarComponent(new BlockPos(0, -1, 1), ComponentType.BLOODRUNE).setUpgradeSlot());
+			components.accept(new AltarComponent(new BlockPos(1, -1, 1), ComponentType.BLOODRUNE));
+		}
+	},
+	THREE()
+	{
+		@Override
+		public void buildComponents(Consumer<AltarComponent> components)
+		{
+			// Doesn't pull from tier 2 because upgrades slots are different
+			components.accept(new AltarComponent(new BlockPos(-1, -1, -1), ComponentType.BLOODRUNE).setUpgradeSlot());
+			components.accept(new AltarComponent(new BlockPos(0, -1, -1), ComponentType.BLOODRUNE).setUpgradeSlot());
+			components.accept(new AltarComponent(new BlockPos(1, -1, -1), ComponentType.BLOODRUNE).setUpgradeSlot());
+			components.accept(new AltarComponent(new BlockPos(-1, -1, 0), ComponentType.BLOODRUNE).setUpgradeSlot());
+			components.accept(new AltarComponent(new BlockPos(1, -1, 0), ComponentType.BLOODRUNE).setUpgradeSlot());
+			components.accept(new AltarComponent(new BlockPos(-1, -1, 1), ComponentType.BLOODRUNE).setUpgradeSlot());
+			components.accept(new AltarComponent(new BlockPos(0, -1, 1), ComponentType.BLOODRUNE).setUpgradeSlot());
+			components.accept(new AltarComponent(new BlockPos(1, -1, 1), ComponentType.BLOODRUNE).setUpgradeSlot());
+			components.accept(new AltarComponent(new BlockPos(-3, -1, -3)));
+			components.accept(new AltarComponent(new BlockPos(-3, 0, -3)));
+			components.accept(new AltarComponent(new BlockPos(3, -1, -3)));
+			components.accept(new AltarComponent(new BlockPos(3, 0, -3)));
+			components.accept(new AltarComponent(new BlockPos(-3, -1, 3)));
+			components.accept(new AltarComponent(new BlockPos(-3, 0, 3)));
+			components.accept(new AltarComponent(new BlockPos(3, -1, 3)));
+			components.accept(new AltarComponent(new BlockPos(3, 0, 3)));
+			components.accept(new AltarComponent(new BlockPos(-3, 1, -3), ComponentType.GLOWSTONE));
+			components.accept(new AltarComponent(new BlockPos(3, 1, -3), ComponentType.GLOWSTONE));
+			components.accept(new AltarComponent(new BlockPos(-3, 1, 3), ComponentType.GLOWSTONE));
+			components.accept(new AltarComponent(new BlockPos(3, 1, 3), ComponentType.GLOWSTONE));
+
+			for (int i = -2; i <= 2; i++)
+			{
+				components.accept(new AltarComponent(new BlockPos(3, -2, i), ComponentType.BLOODRUNE).setUpgradeSlot());
+				components.accept(new AltarComponent(new BlockPos(-3, -2, i), ComponentType.BLOODRUNE).setUpgradeSlot());
+				components.accept(new AltarComponent(new BlockPos(i, -2, 3), ComponentType.BLOODRUNE).setUpgradeSlot());
+				components.accept(new AltarComponent(new BlockPos(i, -2, -3), ComponentType.BLOODRUNE).setUpgradeSlot());
+			}
+		}
+	},
+	FOUR()
+	{
+		@Override
+		public void buildComponents(Consumer<AltarComponent> components)
+		{
+			THREE.getAltarComponents().forEach(components);
+
+			for (int i = -3; i <= 3; i++)
+			{
+				components.accept(new AltarComponent(new BlockPos(5, -3, i), ComponentType.BLOODRUNE).setUpgradeSlot());
+				components.accept(new AltarComponent(new BlockPos(-5, -3, i), ComponentType.BLOODRUNE).setUpgradeSlot());
+				components.accept(new AltarComponent(new BlockPos(i, -3, 5), ComponentType.BLOODRUNE).setUpgradeSlot());
+				components.accept(new AltarComponent(new BlockPos(i, -3, -5), ComponentType.BLOODRUNE).setUpgradeSlot());
+			}
+
+			for (int i = -2; i <= 1; i++)
+			{
+				components.accept(new AltarComponent(new BlockPos(5, i, 5)));
+				components.accept(new AltarComponent(new BlockPos(5, i, -5)));
+				components.accept(new AltarComponent(new BlockPos(-5, i, -5)));
+				components.accept(new AltarComponent(new BlockPos(-5, i, 5)));
+			}
+
+			components.accept(new AltarComponent(new BlockPos(5, 2, 5), ComponentType.BLOODSTONE));
+			components.accept(new AltarComponent(new BlockPos(5, 2, -5), ComponentType.BLOODSTONE));
+			components.accept(new AltarComponent(new BlockPos(-5, 2, -5), ComponentType.BLOODSTONE));
+			components.accept(new AltarComponent(new BlockPos(-5, 2, 5), ComponentType.BLOODSTONE));
+		}
+	},
+	FIVE()
+	{
+		@Override
+		public void buildComponents(Consumer<AltarComponent> components)
+		{
+			FOUR.getAltarComponents().forEach(components);
+			components.accept(new AltarComponent(new BlockPos(-8, -3, 8), ComponentType.BEACON));
+			components.accept(new AltarComponent(new BlockPos(-8, -3, -8), ComponentType.BEACON));
+			components.accept(new AltarComponent(new BlockPos(8, -3, -8), ComponentType.BEACON));
+			components.accept(new AltarComponent(new BlockPos(8, -3, 8), ComponentType.BEACON));
+
+			for (int i = -6; i <= 6; i++)
+			{
+				components.accept(new AltarComponent(new BlockPos(8, -4, i), ComponentType.BLOODRUNE).setUpgradeSlot());
+				components.accept(new AltarComponent(new BlockPos(-8, -4, i), ComponentType.BLOODRUNE).setUpgradeSlot());
+				components.accept(new AltarComponent(new BlockPos(i, -4, 8), ComponentType.BLOODRUNE).setUpgradeSlot());
+				components.accept(new AltarComponent(new BlockPos(i, -4, -8), ComponentType.BLOODRUNE).setUpgradeSlot());
+			}
+		}
+	},
+	SIX()
+	{
+		@Override
+		public void buildComponents(Consumer<AltarComponent> components)
+		{
+			FIVE.getAltarComponents().forEach(components);
+
+			for (int i = -4; i <= 2; i++)
+			{
+				components.accept(new AltarComponent(new BlockPos(11, i, 11)));
+				components.accept(new AltarComponent(new BlockPos(-11, i, -11)));
+				components.accept(new AltarComponent(new BlockPos(11, i, -11)));
+				components.accept(new AltarComponent(new BlockPos(-11, i, 11)));
+			}
+
+			components.accept(new AltarComponent(new BlockPos(11, 3, 11), ComponentType.CRYSTAL));
+			components.accept(new AltarComponent(new BlockPos(-11, 3, -11), ComponentType.CRYSTAL));
+			components.accept(new AltarComponent(new BlockPos(11, 3, -11), ComponentType.CRYSTAL));
+			components.accept(new AltarComponent(new BlockPos(-11, 3, 11), ComponentType.CRYSTAL));
+
+			for (int i = -9; i <= 9; i++)
+			{
+				components.accept(new AltarComponent(new BlockPos(11, -5, i), ComponentType.BLOODRUNE).setUpgradeSlot());
+				components.accept(new AltarComponent(new BlockPos(-11, -5, i), ComponentType.BLOODRUNE).setUpgradeSlot());
+				components.accept(new AltarComponent(new BlockPos(i, -5, 11), ComponentType.BLOODRUNE).setUpgradeSlot());
+				components.accept(new AltarComponent(new BlockPos(i, -5, -11), ComponentType.BLOODRUNE).setUpgradeSlot());
+			}
+		}
+	};
+
+	public static final int MAXTIERS = values().length;
+
+	private List<AltarComponent> altarComponents;
+
+	AltarTier()
+	{
+		this.altarComponents = Lists.newArrayList();
+
+		buildComponents(altarComponents::add);
+	}
+
+	public abstract void buildComponents(Consumer<AltarComponent> components);
+
+	public int toInt()
+	{
+		return ordinal() + 1;
+	}
+
+	public List<AltarComponent> getAltarComponents()
+	{
+		return altarComponents;
+	}
+}

src/main/java/wayoftime/bloodmagic/altar/AltarUpgrade.java

@@ -0,0 +1,29 @@
+package wayoftime.bloodmagic.altar;
+
+import java.util.EnumMap;
+
+import com.google.common.collect.Maps;
+
+import wayoftime.bloodmagic.block.enums.BloodRuneType;
+
+public class AltarUpgrade
+{
+
+	private final EnumMap<BloodRuneType, Integer> upgradeLevels;
+
+	public AltarUpgrade()
+	{
+		this.upgradeLevels = Maps.newEnumMap(BloodRuneType.class);
+	}
+
+	public AltarUpgrade upgrade(BloodRuneType rune)
+	{
+		upgradeLevels.compute(rune, (r, l) -> l == null ? 1 : l + 1);
+		return this;
+	}
+
+	public int getLevel(BloodRuneType rune)
+	{
+		return upgradeLevels.getOrDefault(rune, 0);
+	}
+}

src/main/java/wayoftime/bloodmagic/altar/AltarUtil.java

@@ -0,0 +1,99 @@
+package wayoftime.bloodmagic.altar;
+
+import java.util.List;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import org.apache.commons.lang3.tuple.Pair;
+
+import net.minecraft.block.BlockState;
+import net.minecraft.block.material.Material;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+import wayoftime.bloodmagic.api.impl.BloodMagicAPI;
+import wayoftime.bloodmagic.common.block.BlockBloodRune;
+import wayoftime.bloodmagic.tile.TileAltar;
+
+public class AltarUtil
+{
+
+	@Nonnull
+	public static AltarTier getTier(World world, BlockPos pos)
+	{
+		TileEntity tile = world.getTileEntity(pos);
+		if (!(tile instanceof TileAltar))
+			return AltarTier.ONE;
+
+		AltarTier lastCheck = AltarTier.ONE;
+		for (AltarTier tier : AltarTier.values())
+		{
+			for (AltarComponent component : tier.getAltarComponents())
+			{
+				BlockPos componentPos = pos.add(component.getOffset());
+				BlockState worldState = world.getBlockState(componentPos);
+
+				if (worldState.getBlock() instanceof IAltarComponent)
+					if (((IAltarComponent) worldState.getBlock()).getType(world, worldState, componentPos) == component.getComponent())
+						continue;
+
+				if (component.getComponent() == ComponentType.NOTAIR && worldState.getMaterial() != Material.AIR
+						&& !worldState.getMaterial().isLiquid())
+					continue;
+
+				List<BlockState> validStates = BloodMagicAPI.INSTANCE.getComponentStates(component.getComponent());
+				if (!validStates.contains(worldState))
+					return lastCheck;
+			}
+
+			lastCheck = tier;
+		}
+
+		return lastCheck;
+	}
+
+	@Nonnull
+	public static AltarUpgrade getUpgrades(World world, BlockPos pos, AltarTier currentTier)
+	{
+		AltarUpgrade upgrades = new AltarUpgrade();
+
+		for (AltarComponent component : currentTier.getAltarComponents())
+		{
+			if (!component.isUpgradeSlot() || component.getComponent() != ComponentType.BLOODRUNE)
+				continue;
+
+			BlockPos componentPos = pos.add(component.getOffset());
+			BlockState state = world.getBlockState(componentPos);
+			if (state.getBlock() instanceof BlockBloodRune)
+				upgrades.upgrade(((BlockBloodRune) state.getBlock()).getBloodRune(world, componentPos));
+		}
+
+		return upgrades;
+	}
+
+	@Nullable
+	public static Pair<BlockPos, ComponentType> getFirstMissingComponent(World world, BlockPos pos, int altarTier)
+	{
+		if (altarTier >= AltarTier.MAXTIERS)
+			return null;
+
+		for (AltarTier tier : AltarTier.values())
+		{
+			for (AltarComponent component : tier.getAltarComponents())
+			{
+				BlockPos componentPos = pos.add(component.getOffset());
+				BlockState worldState = world.getBlockState(componentPos);
+				if (component.getComponent() == ComponentType.NOTAIR && worldState.getMaterial() != Material.AIR
+						&& !worldState.getMaterial().isLiquid())
+					continue;
+
+				List<BlockState> validStates = BloodMagicAPI.INSTANCE.getComponentStates(component.getComponent());
+				if (!validStates.contains(worldState))
+					return Pair.of(componentPos, component.getComponent());
+			}
+		}
+
+		return null;
+	}
+}

src/main/java/wayoftime/bloodmagic/altar/BloodAltar.java

@@ -0,0 +1,816 @@
+package wayoftime.bloodmagic.altar;
+
+import com.google.common.base.Enums;
+
+import net.minecraft.block.BlockState;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.particles.ParticleTypes;
+import net.minecraft.particles.RedstoneParticleData;
+import net.minecraft.util.Direction;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+import net.minecraft.world.server.ServerWorld;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.common.util.LazyOptional;
+import net.minecraftforge.fluids.FluidAttributes;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.capability.IFluidHandler;
+import net.minecraftforge.fluids.capability.templates.FluidTank;
+import net.minecraftforge.items.ItemHandlerHelper;
+import wayoftime.bloodmagic.api.event.BloodMagicCraftedEvent;
+import wayoftime.bloodmagic.api.impl.BloodMagicAPI;
+import wayoftime.bloodmagic.api.impl.recipe.RecipeBloodAltar;
+import wayoftime.bloodmagic.block.enums.BloodRuneType;
+import wayoftime.bloodmagic.common.block.BloodMagicBlocks;
+import wayoftime.bloodmagic.core.data.Binding;
+import wayoftime.bloodmagic.iface.IBindable;
+import wayoftime.bloodmagic.orb.BloodOrb;
+import wayoftime.bloodmagic.orb.IBloodOrb;
+import wayoftime.bloodmagic.tile.TileAltar;
+import wayoftime.bloodmagic.util.Constants;
+import wayoftime.bloodmagic.util.helper.NetworkHelper;
+
+public class BloodAltar// implements IFluidHandler
+{
+
+	public boolean isActive;
+
+	protected FluidStack fluidOutput = new FluidStack(BloodMagicBlocks.LIFE_ESSENCE_FLUID.get(), 0); // TODO: Fix
+	protected FluidStack fluidInput = new FluidStack(BloodMagicBlocks.LIFE_ESSENCE_FLUID.get(), 0);
+
+	protected FluidTank tank = new FluidTank(FluidAttributes.BUCKET_VOLUME);
+
+	private final LazyOptional<IFluidHandler> holder = LazyOptional.of(() -> tank);
+
+	private TileAltar tileAltar;
+	private int internalCounter = 0;
+	private AltarTier altarTier = AltarTier.ONE;
+	private AltarUpgrade upgrade;
+	private int capacity = FluidAttributes.BUCKET_VOLUME * 10;
+	private FluidStack fluid = new FluidStack(BloodMagicBlocks.LIFE_ESSENCE_FLUID.get(), 0);
+	private int liquidRequired; // mB
+	private boolean canBeFilled;
+	private int consumptionRate;
+	private int drainRate;
+	private float consumptionMultiplier;
+	private float efficiencyMultiplier;
+	private float sacrificeEfficiencyMultiplier;
+	private float selfSacrificeEfficiencyMultiplier;
+	private float capacityMultiplier = 1;
+	private float orbCapacityMultiplier;
+	private float dislocationMultiplier;
+	private int accelerationUpgrades;
+	private boolean isUpgraded;
+	private boolean isResultBlock;
+	private int bufferCapacity = FluidAttributes.BUCKET_VOLUME;
+	private int progress;
+	private int lockdownDuration;
+	private int demonBloodDuration;
+	private int totalCharge = 0; // TODO save
+	private int chargingRate = 0;
+	private int chargingFrequency = 0;
+	private int maxCharge = 0;
+	private int cooldownAfterCrafting = 60;
+	private RecipeBloodAltar recipe;
+	private AltarTier currentTierDisplayed = AltarTier.ONE;
+
+	public BloodAltar(TileAltar tileAltar)
+	{
+		this.tileAltar = tileAltar;
+	}
+
+	public void readFromNBT(CompoundNBT tagCompound)
+	{
+		if (!tagCompound.contains(Constants.NBT.EMPTY))
+		{
+			FluidStack fluid = FluidStack.loadFluidStackFromNBT(tagCompound);
+
+			if (fluid != null)
+			{
+				setMainFluid(new FluidStack(BloodMagicBlocks.LIFE_ESSENCE_FLUID.get(), fluid.getAmount()));
+//				setMainFluid(fluid);
+			} else
+			{
+//				setMainFluid(new FluidStack(BloodMagicBlocks.LIFE_ESSENCE_FLUID.get(), fluid.getAmount()));
+			}
+
+			FluidStack fluidOut = new FluidStack(BloodMagicBlocks.LIFE_ESSENCE_FLUID.get(), tagCompound.getInt(Constants.NBT.OUTPUT_AMOUNT));
+			setOutputFluid(fluidOut);
+
+			FluidStack fluidIn = new FluidStack(BloodMagicBlocks.LIFE_ESSENCE_FLUID.get(), tagCompound.getInt(Constants.NBT.INPUT_AMOUNT));
+			setInputFluid(fluidIn);
+		}
+
+		internalCounter = tagCompound.getInt("internalCounter");
+		altarTier = Enums.getIfPresent(AltarTier.class, tagCompound.getString(Constants.NBT.ALTAR_TIER)).or(AltarTier.ONE);
+		isActive = tagCompound.getBoolean(Constants.NBT.ALTAR_ACTIVE);
+		liquidRequired = tagCompound.getInt(Constants.NBT.ALTAR_LIQUID_REQ);
+		canBeFilled = tagCompound.getBoolean(Constants.NBT.ALTAR_FILLABLE);
+		isUpgraded = tagCompound.getBoolean(Constants.NBT.ALTAR_UPGRADED);
+		consumptionRate = tagCompound.getInt(Constants.NBT.ALTAR_CONSUMPTION_RATE);
+		drainRate = tagCompound.getInt(Constants.NBT.ALTAR_DRAIN_RATE);
+		consumptionMultiplier = tagCompound.getFloat(Constants.NBT.ALTAR_CONSUMPTION_MULTIPLIER);
+		efficiencyMultiplier = tagCompound.getFloat(Constants.NBT.ALTAR_EFFICIENCY_MULTIPLIER);
+		selfSacrificeEfficiencyMultiplier = tagCompound.getFloat(Constants.NBT.ALTAR_SELF_SACRIFICE_MULTIPLIER);
+		sacrificeEfficiencyMultiplier = tagCompound.getFloat(Constants.NBT.ALTAR_SACRIFICE_MULTIPLIER);
+		capacityMultiplier = tagCompound.getFloat(Constants.NBT.ALTAR_CAPACITY_MULTIPLIER);
+		orbCapacityMultiplier = tagCompound.getFloat(Constants.NBT.ALTAR_ORB_CAPACITY_MULTIPLIER);
+		dislocationMultiplier = tagCompound.getFloat(Constants.NBT.ALTAR_DISLOCATION_MULTIPLIER);
+		capacity = tagCompound.getInt(Constants.NBT.ALTAR_CAPACITY);
+		bufferCapacity = tagCompound.getInt(Constants.NBT.ALTAR_BUFFER_CAPACITY);
+		progress = tagCompound.getInt(Constants.NBT.ALTAR_PROGRESS);
+		isResultBlock = tagCompound.getBoolean(Constants.NBT.ALTAR_IS_RESULT_BLOCK);
+		lockdownDuration = tagCompound.getInt(Constants.NBT.ALTAR_LOCKDOWN_DURATION);
+		accelerationUpgrades = tagCompound.getInt(Constants.NBT.ALTAR_ACCELERATION_UPGRADES);
+		demonBloodDuration = tagCompound.getInt(Constants.NBT.ALTAR_DEMON_BLOOD_DURATION);
+		cooldownAfterCrafting = tagCompound.getInt(Constants.NBT.ALTAR_COOLDOWN_AFTER_CRAFTING);
+		chargingRate = tagCompound.getInt(Constants.NBT.ALTAR_CHARGE_RATE);
+		chargingFrequency = tagCompound.getInt(Constants.NBT.ALTAR_CHARGE_FREQUENCY);
+		totalCharge = tagCompound.getInt(Constants.NBT.ALTAR_TOTAL_CHARGE);
+		maxCharge = tagCompound.getInt(Constants.NBT.ALTAR_MAX_CHARGE);
+		currentTierDisplayed = Enums.getIfPresent(AltarTier.class, tagCompound.getString(Constants.NBT.ALTAR_CURRENT_TIER_DISPLAYED)).or(AltarTier.ONE);
+	}
+
+	public void writeToNBT(CompoundNBT tagCompound)
+	{
+
+		if (fluid != null)
+			fluid.writeToNBT(tagCompound);
+		else
+			tagCompound.putString(Constants.NBT.EMPTY, "");
+
+		if (fluidOutput != null)
+			tagCompound.putInt(Constants.NBT.OUTPUT_AMOUNT, fluidOutput.getAmount());
+
+		if (fluidInput != null)
+			tagCompound.putInt(Constants.NBT.INPUT_AMOUNT, fluidInput.getAmount());
+
+		tagCompound.putInt("internalCounter", internalCounter);
+		tagCompound.putString(Constants.NBT.ALTAR_TIER, altarTier.name());
+		tagCompound.putBoolean(Constants.NBT.ALTAR_ACTIVE, isActive);
+		tagCompound.putInt(Constants.NBT.ALTAR_LIQUID_REQ, liquidRequired);
+		tagCompound.putBoolean(Constants.NBT.ALTAR_FILLABLE, canBeFilled);
+		tagCompound.putBoolean(Constants.NBT.ALTAR_UPGRADED, isUpgraded);
+		tagCompound.putInt(Constants.NBT.ALTAR_CONSUMPTION_RATE, consumptionRate);
+		tagCompound.putInt(Constants.NBT.ALTAR_DRAIN_RATE, drainRate);
+		tagCompound.putFloat(Constants.NBT.ALTAR_CONSUMPTION_MULTIPLIER, consumptionMultiplier);
+		tagCompound.putFloat(Constants.NBT.ALTAR_EFFICIENCY_MULTIPLIER, efficiencyMultiplier);
+		tagCompound.putFloat(Constants.NBT.ALTAR_SACRIFICE_MULTIPLIER, sacrificeEfficiencyMultiplier);
+		tagCompound.putFloat(Constants.NBT.ALTAR_SELF_SACRIFICE_MULTIPLIER, selfSacrificeEfficiencyMultiplier);
+		tagCompound.putBoolean(Constants.NBT.ALTAR_IS_RESULT_BLOCK, isResultBlock);
+		tagCompound.putFloat(Constants.NBT.ALTAR_CAPACITY_MULTIPLIER, capacityMultiplier);
+		tagCompound.putFloat(Constants.NBT.ALTAR_ORB_CAPACITY_MULTIPLIER, orbCapacityMultiplier);
+		tagCompound.putFloat(Constants.NBT.ALTAR_DISLOCATION_MULTIPLIER, dislocationMultiplier);
+		tagCompound.putInt(Constants.NBT.ALTAR_CAPACITY, capacity);
+		tagCompound.putInt(Constants.NBT.ALTAR_PROGRESS, progress);
+		tagCompound.putInt(Constants.NBT.ALTAR_BUFFER_CAPACITY, bufferCapacity);
+		tagCompound.putInt(Constants.NBT.ALTAR_LOCKDOWN_DURATION, lockdownDuration);
+		tagCompound.putInt(Constants.NBT.ALTAR_ACCELERATION_UPGRADES, accelerationUpgrades);
+		tagCompound.putInt(Constants.NBT.ALTAR_DEMON_BLOOD_DURATION, demonBloodDuration);
+		tagCompound.putInt(Constants.NBT.ALTAR_COOLDOWN_AFTER_CRAFTING, cooldownAfterCrafting);
+		tagCompound.putInt(Constants.NBT.ALTAR_CHARGE_RATE, chargingRate);
+		tagCompound.putInt(Constants.NBT.ALTAR_CHARGE_FREQUENCY, chargingFrequency);
+		tagCompound.putInt(Constants.NBT.ALTAR_TOTAL_CHARGE, totalCharge);
+		tagCompound.putInt(Constants.NBT.ALTAR_MAX_CHARGE, maxCharge);
+		tagCompound.putString(Constants.NBT.ALTAR_CURRENT_TIER_DISPLAYED, currentTierDisplayed.name());
+	}
+
+	public void startCycle()
+	{
+		if (tileAltar.getWorld() != null)
+			tileAltar.getWorld().notifyBlockUpdate(tileAltar.getPos(), tileAltar.getWorld().getBlockState(tileAltar.getPos()), tileAltar.getWorld().getBlockState(tileAltar.getPos()), 3);
+
+		checkTier();
+
+		// Temporary thing to test the recipes.
+//		fluid.setAmount(10000);
+//		this.setMainFluid(new FluidStack(BloodMagicBlocks.LIFE_ESSENCE_FLUID.get(), 10000));
+
+		if ((fluid == null || fluid.getAmount() <= 0) && totalCharge <= 0)
+			return;
+
+		if (!isActive)
+			progress = 0;
+
+		ItemStack input = tileAltar.getStackInSlot(0);
+
+		if (!input.isEmpty())
+		{
+			// Do recipes
+			RecipeBloodAltar recipe = BloodMagicAPI.INSTANCE.getRecipeRegistrar().getBloodAltar(tileAltar.getWorld(), input);
+			if (recipe != null)
+			{
+				if (recipe.getMinimumTier().ordinal() <= altarTier.ordinal())
+				{
+					this.isActive = true;
+					this.recipe = recipe;
+					this.liquidRequired = recipe.getSyphon();
+					this.consumptionRate = recipe.getConsumeRate();
+					this.drainRate = recipe.getDrainRate();
+					this.canBeFilled = false;
+					return;
+				}
+			} else if (input.getItem() instanceof IBloodOrb)
+			{
+				this.isActive = true;
+				this.canBeFilled = true;
+				return;
+			}
+		}
+
+		isActive = false;
+	}
+
+	public void update()
+	{
+//		World world = tileAltar.getWorld();
+//
+//		RecipeBloodAltar recipe = BloodMagicAPI.INSTANCE.getRecipeRegistrar().getBloodAltar(world, new ItemStack(Items.DIAMOND));
+//
+//		if (recipe != null)
+//		{
+//			System.out.println("Found a recipe!");
+//		}
+//
+//		List<RecipeBloodAltar> altarRecipes = world.getRecipeManager().getRecipesForType(BloodMagicRecipeType.ALTAR);
+//
+//		System.out.println("There are currently " + altarRecipes.size() + " Altar Recipes loaded.");
+//
+		World world = tileAltar.getWorld();
+		BlockPos pos = tileAltar.getPos();
+
+		if (world.isRemote)
+			return;
+
+		// Used instead of the world time for checks that do not happen every tick
+		internalCounter++;
+
+		if (lockdownDuration > 0)
+			lockdownDuration--;
+
+		if (internalCounter % 20 == 0)
+		{
+			for (Direction facing : Direction.values())
+			{
+				BlockPos newPos = pos.offset(facing);
+				BlockState block = world.getBlockState(newPos);
+				block.getBlock().onNeighborChange(block, world, newPos, pos);
+			}
+		}
+		if (internalCounter % (Math.max(20 - this.accelerationUpgrades, 1)) == 0)
+		{
+			int syphonMax = (int) (20 * this.dislocationMultiplier);
+			int fluidInputted;
+			int fluidOutputted;
+			fluidInputted = Math.min(syphonMax, -this.fluid.getAmount() + capacity);
+			fluidInputted = Math.min(this.fluidInput.getAmount(), fluidInputted);
+			this.fluid.setAmount(this.fluid.getAmount() + fluidInputted);
+			this.fluidInput.setAmount(this.fluidInput.getAmount() - fluidInputted);
+			fluidOutputted = Math.min(syphonMax, this.bufferCapacity - this.fluidOutput.getAmount());
+			fluidOutputted = Math.min(this.fluid.getAmount(), fluidOutputted);
+			this.fluidOutput.setAmount(this.fluidOutput.getAmount() + fluidOutputted);
+			this.fluid.setAmount(this.fluid.getAmount() - fluidOutputted);
+			tileAltar.getWorld().notifyBlockUpdate(tileAltar.getPos(), tileAltar.getWorld().getBlockState(tileAltar.getPos()), tileAltar.getWorld().getBlockState(tileAltar.getPos()), 3);
+		}
+
+		if (internalCounter % this.getChargingFrequency() == 0 && !this.isActive)
+		{
+//			int chargeInputted = Math.min(chargingRate, this.fluid.getAmount());
+//			chargeInputted = Math.min(chargeInputted, maxCharge - totalCharge);
+//			totalCharge += chargeInputted;
+//			this.fluid.setAmount(this.fluid.getAmount() - chargeInputted);
+//			tileAltar.getWorld().notifyBlockUpdate(tileAltar.getPos(), tileAltar.getWorld().getBlockState(tileAltar.getPos()), tileAltar.getWorld().getBlockState(tileAltar.getPos()), 3);
+		}
+
+		if (internalCounter % 100 == 0 && (this.isActive || this.cooldownAfterCrafting <= 0))
+			startCycle();
+
+		updateAltar();
+	}
+
+	private void updateAltar()
+	{
+//		System.out.println("Updating altar.");
+		if (!isActive)
+		{
+			if (cooldownAfterCrafting > 0)
+				cooldownAfterCrafting--;
+			return;
+		}
+
+		if (!canBeFilled && recipe == null)
+		{
+			startCycle();
+			return;
+		}
+
+		ItemStack input = tileAltar.getStackInSlot(0);
+
+		if (input.isEmpty())
+			return;
+
+		World world = tileAltar.getWorld();
+		BlockPos pos = tileAltar.getPos();
+
+		if (world.isRemote)
+			return;
+
+		if (!canBeFilled)
+		{
+			boolean hasOperated = false;
+			int stackSize = input.getCount();
+
+			if (totalCharge > 0)
+			{
+				int chargeDrained = Math.min(liquidRequired * stackSize - progress, totalCharge);
+
+				totalCharge -= chargeDrained;
+				progress += chargeDrained;
+				hasOperated = true;
+			}
+			if (fluid != null && fluid.getAmount() >= 1)
+			{
+//				int liquidDrained = Math.min((int) (altarTier.ordinal() >= 1
+//						? consumptionRate * (1 + consumptionMultiplier)
+//						: consumptionRate), fluid.getAmount());
+				int liquidDrained = Math.min((int) (consumptionRate * (1 + consumptionMultiplier)), fluid.getAmount());
+
+				if (liquidDrained > (liquidRequired * stackSize - progress))
+					liquidDrained = liquidRequired * stackSize - progress;
+
+				fluid.setAmount(fluid.getAmount() - liquidDrained);
+				progress += liquidDrained;
+
+				hasOperated = true;
+
+				if (internalCounter % 4 == 0 && world instanceof ServerWorld)
+				{
+					ServerWorld server = (ServerWorld) world;
+//					server.spawnParticle(ParticleTypes.SPLASH, (double) pos.getX()
+//							+ worldIn.rand.nextDouble(), (double) (pos.getY() + 1), (double) pos.getZ()
+//									+ worldIn.rand.nextDouble(), 1, 0.0D, 0.0D, 0.0D, 1.0D);
+					server.spawnParticle(RedstoneParticleData.REDSTONE_DUST, pos.getX() + 0.5, pos.getY()
+							+ 1.0, pos.getZ() + 0.5, 1, 0.2, 0.0, 0.2, 0.0);
+				}
+
+			} else if (!hasOperated && progress > 0)
+			{
+				progress -= (int) (efficiencyMultiplier * drainRate);
+
+				if (internalCounter % 2 == 0 && world instanceof ServerWorld)
+				{
+					ServerWorld server = (ServerWorld) world;
+					server.spawnParticle(ParticleTypes.LARGE_SMOKE, pos.getX() + 0.5, pos.getY() + 1, pos.getZ()
+							+ 0.5, 1, 0.1, 0, 0.1, 0);
+				}
+			}
+
+			if (hasOperated)
+			{
+				if (progress >= liquidRequired * stackSize)
+				{
+					ItemStack result = ItemHandlerHelper.copyStackWithSize(recipe.getOutput(), stackSize);
+
+					BloodMagicCraftedEvent.Altar event = new BloodMagicCraftedEvent.Altar(result, input.copy());
+					MinecraftForge.EVENT_BUS.post(event);
+					tileAltar.setInventorySlotContents(0, event.getOutput());
+					progress = 0;
+
+					if (world instanceof ServerWorld)
+					{
+						ServerWorld server = (ServerWorld) world;
+						server.spawnParticle(RedstoneParticleData.REDSTONE_DUST, pos.getX() + 0.5, pos.getY()
+								+ 1, pos.getZ() + 0.5, 40, 0.3, 0, 0.3, 0);
+					}
+
+					this.cooldownAfterCrafting = 30;
+					this.isActive = false;
+				}
+			}
+		} else
+		{
+			ItemStack contained = tileAltar.getStackInSlot(0);
+
+			if (contained.isEmpty() || !(contained.getItem() instanceof IBloodOrb)
+					|| !(contained.getItem() instanceof IBindable))
+				return;
+
+			BloodOrb orb = ((IBloodOrb) contained.getItem()).getOrb(contained);
+			Binding binding = ((IBindable) contained.getItem()).getBinding(contained);
+
+			if (binding == null || orb == null)
+				return;
+
+			if (fluid != null && fluid.getAmount() >= 1)
+			{
+//				int liquidDrained = Math.min((int) (altarTier.ordinal() >= 2
+//						? orb.getFillRate() * (1 + consumptionMultiplier)
+//						: orb.getFillRate()), fluid.getAmount());
+				int liquidDrained = Math.min((int) (orb.getFillRate()
+						* (1 + consumptionMultiplier)), fluid.getAmount());
+				int drain = NetworkHelper.getSoulNetwork(binding).add(liquidDrained, (int) (orb.getCapacity()
+						* this.orbCapacityMultiplier));
+				fluid.setAmount(fluid.getAmount() - drain);
+
+				if (drain > 0 && internalCounter % 4 == 0 && world instanceof ServerWorld)
+				{
+					ServerWorld server = (ServerWorld) world;
+					server.spawnParticle(ParticleTypes.WITCH, pos.getX() + 0.5, pos.getY() + 1, pos.getZ()
+							+ 0.5, 1, 0, 0, 0, 0.001);
+				}
+			}
+		}
+
+		tileAltar.getWorld().notifyBlockUpdate(tileAltar.getPos(), tileAltar.getWorld().getBlockState(tileAltar.getPos()), tileAltar.getWorld().getBlockState(tileAltar.getPos()), 3);
+	}
+
+	public void checkTier()
+	{
+		AltarTier tier = AltarUtil.getTier(tileAltar.getWorld(), tileAltar.getPos());
+		this.altarTier = tier;
+
+		upgrade = AltarUtil.getUpgrades(tileAltar.getWorld(), tileAltar.getPos(), tier);
+
+		if (tier.equals(currentTierDisplayed))
+			currentTierDisplayed = AltarTier.ONE;
+
+		if (tier.equals(AltarTier.ONE))
+		{
+			upgrade = null;
+			isUpgraded = false;
+			this.consumptionMultiplier = 0;
+			this.efficiencyMultiplier = 1;
+			this.sacrificeEfficiencyMultiplier = 0;
+			this.selfSacrificeEfficiencyMultiplier = 0;
+			this.capacityMultiplier = 1;
+			this.orbCapacityMultiplier = 1;
+			this.dislocationMultiplier = 1;
+			this.accelerationUpgrades = 0;
+			this.chargingFrequency = 20;
+			this.chargingRate = 0;
+			this.maxCharge = 0;
+			this.totalCharge = 0;
+			return;
+		} else if (!tier.equals(AltarTier.ONE))
+		{
+			this.isUpgraded = true;
+			this.accelerationUpgrades = upgrade.getLevel(BloodRuneType.ACCELERATION);
+			this.consumptionMultiplier = (float) (0.20 * upgrade.getLevel(BloodRuneType.SPEED));
+			this.efficiencyMultiplier = (float) Math.pow(0.85, upgrade.getLevel(BloodRuneType.EFFICIENCY));
+			this.sacrificeEfficiencyMultiplier = (float) (0.10 * upgrade.getLevel(BloodRuneType.SACRIFICE));
+			this.selfSacrificeEfficiencyMultiplier = (float) (0.10 * upgrade.getLevel(BloodRuneType.SELF_SACRIFICE));
+			this.capacityMultiplier = (float) ((1 * Math.pow(1.10, upgrade.getLevel(BloodRuneType.AUGMENTED_CAPACITY)))
+					+ 0.20 * upgrade.getLevel(BloodRuneType.CAPACITY));
+			this.dislocationMultiplier = (float) (Math.pow(1.2, upgrade.getLevel(BloodRuneType.DISPLACEMENT)));
+			this.orbCapacityMultiplier = (float) (1 + 0.02 * upgrade.getLevel(BloodRuneType.ORB));
+			this.chargingFrequency = Math.max(20 - accelerationUpgrades, 1);
+			this.chargingRate = (int) (10 * upgrade.getLevel(BloodRuneType.CHARGING) * (1 + consumptionMultiplier / 2));
+			this.maxCharge = (int) (FluidAttributes.BUCKET_VOLUME * Math.max(0.5 * capacityMultiplier, 1)
+					* upgrade.getLevel(BloodRuneType.CHARGING));
+		}
+
+		this.capacity = (int) (FluidAttributes.BUCKET_VOLUME * 10 * capacityMultiplier);
+		this.bufferCapacity = (int) (FluidAttributes.BUCKET_VOLUME * 1 * capacityMultiplier);
+
+		if (this.fluid.getAmount() > this.capacity)
+			this.fluid.setAmount(this.capacity);
+		if (this.fluidOutput.getAmount() > this.bufferCapacity)
+			this.fluidOutput.setAmount(this.bufferCapacity);
+		if (this.fluidInput.getAmount() > this.bufferCapacity)
+			this.fluidInput.setAmount(this.bufferCapacity);
+		if (this.totalCharge > this.maxCharge)
+			this.totalCharge = this.maxCharge;
+
+		tileAltar.getWorld().notifyBlockUpdate(tileAltar.getPos(), tileAltar.getWorld().getBlockState(tileAltar.getPos()), tileAltar.getWorld().getBlockState(tileAltar.getPos()), 3);
+	}
+
+	public int fillMainTank(int amount)
+	{
+		int filledAmount = Math.min(capacity - fluid.getAmount(), amount);
+		fluid.setAmount(fluid.getAmount() + filledAmount);
+
+		return filledAmount;
+	}
+
+	public void sacrificialDaggerCall(int amount, boolean isSacrifice)
+	{
+		if (this.lockdownDuration > 0)
+		{
+			int amt = (int) Math.min(bufferCapacity
+					- fluidInput.getAmount(), (isSacrifice ? 1 + sacrificeEfficiencyMultiplier
+							: 1 + selfSacrificeEfficiencyMultiplier) * amount);
+			fluidInput.setAmount(fluidInput.getAmount() + amt);
+		} else
+		{
+			fluid.setAmount((int) (fluid.getAmount()
+					+ Math.min(capacity - fluid.getAmount(), (isSacrifice ? 1 + sacrificeEfficiencyMultiplier
+							: 1 + selfSacrificeEfficiencyMultiplier) * amount)));
+		}
+	}
+
+	public void setMainFluid(FluidStack fluid)
+	{
+		this.fluid = fluid;
+	}
+
+	public void setOutputFluid(FluidStack fluid)
+	{
+		this.fluidOutput = fluid;
+	}
+
+	public void setInputFluid(FluidStack fluid)
+	{
+		this.fluidInput = fluid;
+	}
+
+	public AltarUpgrade getUpgrade()
+	{
+		return upgrade;
+	}
+
+	public void setUpgrade(AltarUpgrade upgrade)
+	{
+		this.upgrade = upgrade;
+	}
+
+	public int getCapacity()
+	{
+		return capacity;
+	}
+
+	public FluidStack getFluid()
+	{
+		return fluid;
+	}
+
+	public int getFluidAmount()
+	{
+		return fluid.getAmount();
+	}
+
+	public int getCurrentBlood()
+	{
+		return getFluidAmount();
+	}
+
+	public AltarTier getTier()
+	{
+		return altarTier;
+	}
+
+	public void setTier(AltarTier tier)
+	{
+		this.altarTier = tier;
+	}
+
+	public int getProgress()
+	{
+		return progress;
+	}
+
+	public float getSacrificeMultiplier()
+	{
+		return sacrificeEfficiencyMultiplier;
+	}
+
+	public float getSelfSacrificeMultiplier()
+	{
+		return selfSacrificeEfficiencyMultiplier;
+	}
+
+	public float getOrbMultiplier()
+	{
+		return orbCapacityMultiplier;
+	}
+
+	public float getDislocationMultiplier()
+	{
+		return dislocationMultiplier;
+	}
+
+	public float getConsumptionMultiplier()
+	{
+		return consumptionMultiplier;
+	}
+
+	public float getConsumptionRate()
+	{
+		return consumptionRate;
+	}
+
+	public int getLiquidRequired()
+	{
+		return liquidRequired;
+	}
+
+	public int getBufferCapacity()
+	{
+		return bufferCapacity;
+	}
+
+	public boolean setCurrentTierDisplayed(AltarTier altarTier)
+	{
+		if (currentTierDisplayed == altarTier)
+			return false;
+		else
+			currentTierDisplayed = altarTier;
+		return true;
+	}
+
+	public void addToDemonBloodDuration(int dur)
+	{
+		this.demonBloodDuration += dur;
+	}
+
+	public boolean hasDemonBlood()
+	{
+		return this.demonBloodDuration > 0;
+	}
+
+	public void decrementDemonBlood()
+	{
+		this.demonBloodDuration = Math.max(0, this.demonBloodDuration - 1);
+	}
+
+	public void setActive()
+	{
+//		if (tileAltar.getStackInSlot(0).isEmpty())
+//		{
+//			isActive = false;
+//		}
+	}
+
+	public boolean isActive()
+	{
+		return isActive;
+	}
+
+	public void requestPauseAfterCrafting(int amount)
+	{
+		if (this.isActive)
+		{
+			this.cooldownAfterCrafting = amount;
+		}
+	}
+
+	public int getChargingRate()
+	{
+		return chargingRate;
+	}
+
+	public int getTotalCharge()
+	{
+		return totalCharge;
+	}
+
+	public int getChargingFrequency()
+	{
+		return chargingFrequency == 0 ? 1 : chargingFrequency;
+	}
+
+	public int fill(FluidStack resource, boolean doFill)
+	{
+		if (resource == null || resource.getFluid() != BloodMagicBlocks.LIFE_ESSENCE_FLUID.get())
+		{
+			return 0;
+		}
+
+		if (!doFill)
+		{
+			if (fluidInput == null)
+			{
+				return Math.min(bufferCapacity, resource.getAmount());
+			}
+
+			if (!fluidInput.isFluidEqual(resource))
+			{
+				return 0;
+			}
+
+			return Math.min(bufferCapacity - fluidInput.getAmount(), resource.getAmount());
+		}
+
+		if (fluidInput == null)
+		{
+			fluidInput = new FluidStack(resource, Math.min(bufferCapacity, resource.getAmount()));
+
+			return fluidInput.getAmount();
+		}
+
+		if (!fluidInput.isFluidEqual(resource))
+		{
+			return 0;
+		}
+		int filled = bufferCapacity - fluidInput.getAmount();
+
+		if (resource.getAmount() < filled)
+		{
+			fluidInput.setAmount(fluidInput.getAmount() + resource.getAmount());
+			filled = resource.getAmount();
+		} else
+		{
+			fluidInput.setAmount(bufferCapacity);
+		}
+
+		return filled;
+	}
+
+	public FluidStack drain(FluidStack resource, boolean doDrain)
+	{
+		if (resource == null || !resource.isFluidEqual(fluidOutput))
+		{
+			return null;
+		}
+		return drain(resource.getAmount(), doDrain);
+	}
+
+	public FluidStack drain(int maxDrain, boolean doDrain)
+	{
+		if (fluidOutput == null)
+		{
+			return null;
+		}
+
+		int drained = maxDrain;
+		if (fluidOutput.getAmount() < drained)
+		{
+			drained = fluidOutput.getAmount();
+		}
+
+		FluidStack stack = new FluidStack(fluidOutput, drained);
+		if (doDrain)
+		{
+			fluidOutput.setAmount(fluidOutput.getAmount() - drained);
+		}
+		return stack;
+	}
+
+//	@Override
+//	public IFluidTankProperties[] getTankProperties()
+//	{
+//		return new IFluidTankProperties[]
+//		{ new FluidTankPropertiesWrapper(new FluidTank(fluid, capacity)) };
+//	}
+
+	public AltarTier getCurrentTierDisplayed()
+	{
+		return currentTierDisplayed;
+	}
+
+	static class VariableSizeFluidHandler implements IFluidHandler
+	{
+		BloodAltar altar;
+
+		VariableSizeFluidHandler(BloodAltar altar)
+		{
+			this.altar = altar;
+		}
+
+		@Override
+		public int getTanks()
+		{
+			// TODO Auto-generated method stub
+			return 1;
+		}
+
+		@Override
+		public FluidStack getFluidInTank(int tank)
+		{
+			// TODO Auto-generated method stub
+			return null;
+		}
+
+		@Override
+		public int getTankCapacity(int tank)
+		{
+			// TODO Auto-generated method stub
+			return 0;
+		}
+
+		@Override
+		public boolean isFluidValid(int tank, FluidStack stack)
+		{
+			return false;
+		}
+
+		@Override
+		public int fill(FluidStack resource, FluidAction action)
+		{
+			return altar.fill(resource, action == FluidAction.EXECUTE);
+		}
+
+		@Override
+		public FluidStack drain(FluidStack resource, FluidAction action)
+		{
+			return altar.drain(resource, action == FluidAction.EXECUTE);
+		}
+
+		@Override
+		public FluidStack drain(int maxDrain, FluidAction action)
+		{
+			// TODO Auto-generated method stub
+			return null;
+		}
+	}
+}

src/main/java/wayoftime/bloodmagic/altar/ComponentType.java

@@ -0,0 +1,25 @@
+package wayoftime.bloodmagic.altar;
+
+import java.util.Locale;
+
+/**
+ * List of different components used to construct different tiers of altars.
+ */
+public enum ComponentType
+{
+	GLOWSTONE, BLOODSTONE, BEACON, BLOODRUNE, CRYSTAL, NOTAIR;
+
+	public static final ComponentType[] VALUES = values();
+	private static final String BASE = "chat.bloodmagic.altar.comp.";
+	private String key;
+
+	ComponentType()
+	{
+		this.key = BASE + name().toLowerCase(Locale.ENGLISH);
+	}
+
+	public String getKey()
+	{
+		return key;
+	}
+}

src/main/java/wayoftime/bloodmagic/altar/IAltarComponent.java

@@ -0,0 +1,13 @@
+package wayoftime.bloodmagic.altar;
+
+import javax.annotation.Nullable;
+
+import net.minecraft.block.BlockState;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+public interface IAltarComponent
+{
+	@Nullable
+	ComponentType getType(World world, BlockState state, BlockPos pos);
+}

src/main/java/wayoftime/bloodmagic/altar/IBloodAltar.java

@@ -0,0 +1,55 @@
+package wayoftime.bloodmagic.altar;
+
+public interface IBloodAltar
+{
+	int getCapacity();
+
+	int getCurrentBlood();
+
+	AltarTier getTier();
+
+	int getProgress();
+
+	float getSacrificeMultiplier();
+
+	float getSelfSacrificeMultiplier();
+
+	float getOrbMultiplier();
+
+	float getDislocationMultiplier();
+
+	float getConsumptionMultiplier();
+
+	float getConsumptionRate();
+
+	int getChargingRate();
+
+	int getChargingFrequency();
+
+	int getTotalCharge();
+
+	int getLiquidRequired();
+
+	int getBufferCapacity();
+
+	void sacrificialDaggerCall(int amount, boolean isSacrifice);
+
+	void startCycle();
+
+	void checkTier();
+
+	boolean isActive();
+
+	void setActive();
+
+	int fillMainTank(int amount);
+
+	/**
+	 * Will set the altar to initiate a cooldown cycle after it crafts before
+	 * starting to craft again, giving the user time to interact with the altar.
+	 * This can only be set while the altar is not active.
+	 *
+	 * @param cooldown - How long the cooldown should last
+	 */
+	void requestPauseAfterCrafting(int cooldown);
+}

src/main/java/wayoftime/bloodmagic/api/IBloodMagicAPI.java

@@ -0,0 +1,80 @@
+package wayoftime.bloodmagic.api;
+
+import javax.annotation.Nonnull;
+
+import net.minecraft.block.BlockState;
+
+/**
+ * The main interface between a plugin and Blood Magic's internals.
+ *
+ * This API is intended for <i>compatibility</i> between other mods and Blood
+ * Magic. More advanced integration is out of the scope of this API and are
+ * considered "addons".
+ *
+ * To get an instance of this without actually creating an
+ * {@link IBloodMagicPlugin}, use {@link BloodMagicPlugin.Inject}.
+ */
+public interface IBloodMagicAPI
+{
+
+//	/**
+//	 * Retrieves the instance of the blacklist.
+//	 *
+//	 * @return the active {@link IBloodMagicBlacklist} instance
+//	 */
+//	@Nonnull
+//	IBloodMagicBlacklist getBlacklist();
+
+	/**
+	 * Retrieves the instance of the recipe registrar.
+	 *
+	 * @return the active {@link IBloodMagicRecipeRegistrar} instance
+	 */
+	@Nonnull
+	IBloodMagicRecipeRegistrar getRecipeRegistrar();
+//
+//	/**
+//	 * Retrieves the instance of the value manager.
+//	 *
+//	 * @return the active {@link IBloodMagicValueManager} instance
+//	 */
+//	@Nonnull
+//	IBloodMagicValueManager getValueManager();
+
+	/**
+	 * Registers an {@link IBlockState} as a given component for the Blood Altar.
+	 * <p>
+	 * Valid component types:
+	 * <ul>
+	 * <li>GLOWSTONE</li>
+	 * <li>BLOODSTONE</li>
+	 * <li>BEACON</li>
+	 * <li>BLOODRUNE</li>
+	 * <li>CRYSTAL</li>
+	 * <li>NOTAIR</li>
+	 * </ul>
+	 *
+	 * @param state         The state to register
+	 * @param componentType The type of Blood Altar component to register as.
+	 */
+	void registerAltarComponent(@Nonnull BlockState state, @Nonnull String componentType);
+
+	/**
+	 * Removes an {@link IBlockState} from the component mappings
+	 * <p>
+	 * Valid component types:
+	 * <ul>
+	 * <li>GLOWSTONE</li>
+	 * <li>BLOODSTONE</li>
+	 * <li>BEACON</li>
+	 * <li>BLOODRUNE</li>
+	 * <li>CRYSTAL</li>
+	 * <li>NOTAIR</li>
+	 * </ul>
+	 *
+	 * @param state         The state to unregister
+	 * @param componentType The type of Blood Altar component to unregister from.
+	 */
+	void unregisterAltarComponent(@Nonnull BlockState state, @Nonnull String componentType);
+
+}

src/main/java/wayoftime/bloodmagic/api/IBloodMagicRecipeRegistrar.java

@@ -0,0 +1,100 @@
+package wayoftime.bloodmagic.api;
+
+/**
+ * Allows recipe addition and removal.
+ */
+public interface IBloodMagicRecipeRegistrar
+{
+
+//	/**
+//	 * Adds a new recipe to the Blood Altar.
+//	 *
+//	 * @param input       An input {@link Ingredient}.
+//	 * @param output      An output {@link ItemStack}.
+//	 * @param minimumTier The minimum Blood Altar tier required for this recipe.
+//	 * @param syphon      The amount of Life Essence to syphon from the Blood Altar
+//	 *                    over the course of the craft.
+//	 * @param consumeRate How quickly the Life Essence is syphoned.
+//	 * @param drainRate   How quickly progress is lost if the Blood Altar runs out
+//	 *                    of Life Essence during the craft.
+//	 */
+//	void addBloodAltar(@Nonnull Ingredient input, @Nonnull ItemStack output, @Nonnegative int minimumTier,
+//			@Nonnegative int syphon, @Nonnegative int consumeRate, @Nonnegative int drainRate);
+//
+//	/**
+//	 * Removes a Blood Altar recipe based on an input {@link ItemStack}.
+//	 *
+//	 * @param input The input item to remove the recipe of.
+//	 * @return Whether or not a recipe was removed.
+//	 */
+//	boolean removeBloodAltar(@Nonnull ItemStack input);
+//
+//	/**
+//	 * Adds a new recipe to the Alchemy Table.
+//	 *
+//	 * @param output      An output {@link ItemStack}.
+//	 * @param syphon      The amount of Life Essence to syphon from the Blood Orb's
+//	 *                    bound network over the course of the craft.
+//	 * @param ticks       The amount of ticks it takes to complete the craft.
+//	 * @param minimumTier The minimum Blood Orb tier required for this recipe.
+//	 * @param input       An array of {@link Ingredient}s to accept as inputs.
+//	 */
+//	void addAlchemyTable(@Nonnull ItemStack output, @Nonnegative int syphon, @Nonnegative int ticks,
+//			@Nonnegative int minimumTier, @Nonnull Ingredient... input);
+//
+//	/**
+//	 * Removes an Alchemy Table recipe based on an input {@link ItemStack} array.
+//	 *
+//	 * @param input The input items to remove the recipe of.
+//	 * @return Whether or not a recipe was removed.
+//	 */
+//	boolean removeAlchemyTable(@Nonnull ItemStack... input);
+//
+//	/**
+//	 * Adds a new recipe to the Soul/Tartaric Forge.
+//	 * 
+//	 * @param output       An output {@link ItemStack}.
+//	 * @param minimumSouls The minimum number of souls that must be contained in the
+//	 *                     Soul Gem.
+//	 * @param soulDrain    The number of souls to drain from the Soul Gem.
+//	 * @param input        An array of {@link Ingredient}s to accept as inputs.
+//	 */
+//	void addTartaricForge(@Nonnull ItemStack output, @Nonnegative double minimumSouls, @Nonnegative double soulDrain,
+//			@Nonnull Ingredient... input);
+//
+//	/**
+//	 * Removes a Soul/Tartaric Forge recipe based on an input {@link ItemStack}
+//	 * array.
+//	 *
+//	 * @param input The input items to remove the recipe of.
+//	 * @return Whether or not a recipe was removed.
+//	 */
+//	boolean removeTartaricForge(@Nonnull ItemStack... input);
+//
+//	/**
+//	 * Adds a new recipe to the Alchemy Array.
+//	 *
+//	 * @param input         An input {@link Ingredient}. First item put into the
+//	 *                      Alchemy Array.
+//	 * @param catalyst      A catalyst {@link Ingredient}. Second item put into the
+//	 *                      Alchemy Array.
+//	 * @param output        An output {@link ItemStack}.
+//	 * @param circleTexture The texture to render for the Alchemy Array circle.
+//	 */
+//	void addAlchemyArray(@Nonnull Ingredient input, @Nonnull Ingredient catalyst, @Nonnull ItemStack output,
+//			@Nullable ResourceLocation circleTexture);
+//
+//	/**
+//	 * Removes an Alchemy Array recipe based on an input {@link ItemStack} and it's
+//	 * catalyst {@link ItemStack}.
+//	 *
+//	 * @param input    The input item to remove the recipe of.
+//	 * @param catalyst The catalyst item to remove the recipe of.
+//	 * @return Whether or not a recipe was removed.
+//	 */
+//	boolean removeAlchemyArray(@Nonnull ItemStack input, @Nonnull ItemStack catalyst);
+//
+//	void addSacrificeCraft(@Nonnull ItemStack output, @Nonnegative double healthRequired, @Nonnull Ingredient... input);
+//
+//	boolean removeSacrificeCraft(@Nonnull ItemStack... input);
+}

src/main/java/wayoftime/bloodmagic/api/SerializerHelper.java

@@ -0,0 +1,129 @@
+package wayoftime.bloodmagic.api;
+
+import javax.annotation.Nonnull;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonSyntaxException;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+
+import net.minecraft.fluid.Fluid;
+import net.minecraft.fluid.Fluids;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.ShapedRecipe;
+import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.nbt.JsonToNBT;
+import net.minecraft.util.JSONUtils;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.registries.ForgeRegistries;
+import wayoftime.bloodmagic.util.Constants;
+
+/**
+ * Copied liberally from Mekanism. Thanks, pupnewfster!
+ *
+ */
+public class SerializerHelper
+{
+	private SerializerHelper()
+	{
+	}
+
+	private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
+
+	private static void validateKey(@Nonnull JsonObject json, @Nonnull String key)
+	{
+		if (!json.has(key))
+		{
+			throw new JsonSyntaxException("Missing '" + key + "', expected to find an object");
+		}
+		if (!json.get(key).isJsonObject())
+		{
+			throw new JsonSyntaxException("Expected '" + key + "' to be an object");
+		}
+	}
+
+	public static ItemStack getItemStack(@Nonnull JsonObject json, @Nonnull String key)
+	{
+		validateKey(json, key);
+		return ShapedRecipe.deserializeItem(JSONUtils.getJsonObject(json, key));
+	}
+
+	public static JsonElement serializeItemStack(@Nonnull ItemStack stack)
+	{
+		JsonObject json = new JsonObject();
+		json.addProperty(Constants.JSON.ITEM, stack.getItem().getRegistryName().toString());
+		if (stack.getCount() > 1)
+		{
+			json.addProperty(Constants.JSON.COUNT, stack.getCount());
+		}
+		if (stack.hasTag())
+		{
+			json.addProperty(Constants.JSON.NBT, stack.getTag().toString());
+		}
+		return json;
+	}
+
+	public static FluidStack getFluidStack(@Nonnull JsonObject json, @Nonnull String key)
+	{
+		validateKey(json, key);
+		return deserializeFluid(JSONUtils.getJsonObject(json, key));
+	}
+
+	public static FluidStack deserializeFluid(@Nonnull JsonObject json)
+	{
+		if (!json.has(Constants.JSON.AMOUNT))
+		{
+			throw new JsonSyntaxException("Expected to receive a amount that is greater than zero");
+		}
+		JsonElement count = json.get(Constants.JSON.AMOUNT);
+		if (!JSONUtils.isNumber(count))
+		{
+			throw new JsonSyntaxException("Expected amount to be a number greater than zero.");
+		}
+		int amount = count.getAsJsonPrimitive().getAsInt();
+		if (amount < 1)
+		{
+			throw new JsonSyntaxException("Expected amount to be greater than zero.");
+		}
+		ResourceLocation resourceLocation = new ResourceLocation(JSONUtils.getString(json, Constants.JSON.FLUID));
+		Fluid fluid = ForgeRegistries.FLUIDS.getValue(resourceLocation);
+		if (fluid == null || fluid == Fluids.EMPTY)
+		{
+			throw new JsonSyntaxException("Invalid fluid type '" + resourceLocation + "'");
+		}
+		CompoundNBT nbt = null;
+		if (json.has(Constants.JSON.NBT))
+		{
+			JsonElement jsonNBT = json.get(Constants.JSON.NBT);
+			try
+			{
+				if (jsonNBT.isJsonObject())
+				{
+					nbt = JsonToNBT.getTagFromJson(GSON.toJson(jsonNBT));
+				} else
+				{
+					nbt = JsonToNBT.getTagFromJson(JSONUtils.getString(jsonNBT, Constants.JSON.NBT));
+				}
+			} catch (CommandSyntaxException e)
+			{
+				throw new JsonSyntaxException("Invalid NBT entry for fluid '" + resourceLocation + "'");
+			}
+		}
+		return new FluidStack(fluid, amount, nbt);
+	}
+
+	public static JsonElement serializeFluidStack(@Nonnull FluidStack stack)
+	{
+		JsonObject json = new JsonObject();
+		json.addProperty(Constants.JSON.FLUID, stack.getFluid().getRegistryName().toString());
+		json.addProperty(Constants.JSON.AMOUNT, stack.getAmount());
+		if (stack.hasTag())
+		{
+			json.addProperty(Constants.JSON.NBT, stack.getTag().toString());
+		}
+		return json;
+	}
+}

src/main/java/wayoftime/bloodmagic/api/event/BloodMagicCraftedEvent.java

@@ -0,0 +1,84 @@
+package wayoftime.bloodmagic.api.event;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.eventbus.api.Event;
+
+public class BloodMagicCraftedEvent extends Event
+{
+
+	private final boolean modifiable;
+	private final ItemStack[] inputs;
+	private ItemStack output;
+
+	public BloodMagicCraftedEvent(ItemStack output, ItemStack[] inputs, boolean modifiable)
+	{
+		this.modifiable = modifiable;
+		this.inputs = inputs;
+		this.output = output;
+	}
+
+	public boolean isModifiable()
+	{
+		return modifiable;
+	}
+
+	public ItemStack[] getInputs()
+	{
+		return inputs;
+	}
+
+	public ItemStack getOutput()
+	{
+		return output;
+	}
+
+	public void setOutput(ItemStack output)
+	{
+		if (isModifiable())
+			this.output = output;
+	}
+
+	/**
+	 * Fired whenever a craft is completed in a Blood Altar.
+	 *
+	 * It is not cancelable, however you can modify the output stack.
+	 */
+	public static class Altar extends BloodMagicCraftedEvent
+	{
+
+		public Altar(ItemStack output, ItemStack input)
+		{
+			super(output, new ItemStack[]
+			{ input }, true);
+		}
+	}
+
+	/**
+	 * Fired whenever a craft is completed in a Soul Forge.
+	 *
+	 * It is not cancelable, however you can modify the output stack.
+	 */
+	public static class SoulForge extends BloodMagicCraftedEvent
+	{
+
+		public SoulForge(ItemStack output, ItemStack[] inputs)
+		{
+			super(output, inputs, true);
+		}
+	}
+
+	/**
+	 * Fired whenever a craft is completed in an Alchemy Table.
+	 *
+	 * It is not cancelable, however you can modify the output stack.
+	 */
+	public static class AlchemyTable extends BloodMagicCraftedEvent
+	{
+
+		public AlchemyTable(ItemStack output, ItemStack[] inputs)
+		{
+			super(output, inputs, true);
+		}
+	}
+
+}

src/main/java/wayoftime/bloodmagic/api/event/recipes/FluidStackIngredient.java

@@ -0,0 +1,385 @@
+package wayoftime.bloodmagic.api.event.recipes;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import com.google.gson.JsonSyntaxException;
+
+import net.minecraft.fluid.Fluid;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.tags.FluidTags;
+import net.minecraft.tags.ITag;
+import net.minecraft.tags.TagCollectionManager;
+import net.minecraft.util.JSONUtils;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.fluids.FluidStack;
+import wayoftime.bloodmagic.api.SerializerHelper;
+import wayoftime.bloodmagic.util.Constants;
+
+/**
+ * Created by Thiakil on 12/07/2019.
+ */
+public abstract class FluidStackIngredient implements InputIngredient<FluidStack>
+{
+
+	public static FluidStackIngredient from(@Nonnull Fluid instance, int amount)
+	{
+		return from(new FluidStack(instance, amount));
+	}
+
+	public static FluidStackIngredient from(@Nonnull FluidStack instance)
+	{
+		return new Single(instance);
+	}
+
+	public static FluidStackIngredient from(@Nonnull ITag<Fluid> fluidTag, int minAmount)
+	{
+		return new Tagged(fluidTag, minAmount);
+	}
+
+	public static FluidStackIngredient read(PacketBuffer buffer)
+	{
+		// TODO: Allow supporting serialization of different types than just the ones we
+		// implement?
+		IngredientType type = buffer.readEnumValue(IngredientType.class);
+		if (type == IngredientType.SINGLE)
+		{
+			return Single.read(buffer);
+		} else if (type == IngredientType.TAGGED)
+		{
+			return Tagged.read(buffer);
+		}
+		return Multi.read(buffer);
+	}
+
+	public static FluidStackIngredient deserialize(@Nullable JsonElement json)
+	{
+		if (json == null || json.isJsonNull())
+		{
+			throw new JsonSyntaxException("Ingredient cannot be null");
+		}
+		if (json.isJsonArray())
+		{
+			JsonArray jsonArray = json.getAsJsonArray();
+			int size = jsonArray.size();
+			if (size == 0)
+			{
+				throw new JsonSyntaxException("Ingredient array cannot be empty, at least one ingredient must be defined");
+			} else if (size > 1)
+			{
+				FluidStackIngredient[] ingredients = new FluidStackIngredient[size];
+				for (int i = 0; i < size; i++)
+				{
+					// Read all the ingredients
+					ingredients[i] = deserialize(jsonArray.get(i));
+				}
+				return createMulti(ingredients);
+			}
+			// If we only have a single element, just set our json as that so that we don't
+			// have to use Multi for efficiency reasons
+			json = jsonArray.get(0);
+		}
+		if (!json.isJsonObject())
+		{
+			throw new JsonSyntaxException("Expected fluid to be object or array of objects");
+		}
+		JsonObject jsonObject = json.getAsJsonObject();
+		if (jsonObject.has(Constants.JSON.FLUID) && jsonObject.has(Constants.JSON.TAG))
+		{
+			throw new JsonParseException("An ingredient entry is either a tag or an fluid, not both");
+		} else if (jsonObject.has(Constants.JSON.FLUID))
+		{
+			return from(SerializerHelper.deserializeFluid(jsonObject));
+		} else if (jsonObject.has(Constants.JSON.TAG))
+		{
+			if (!jsonObject.has(Constants.JSON.AMOUNT))
+			{
+				throw new JsonSyntaxException("Expected to receive a amount that is greater than zero");
+			}
+			JsonElement count = jsonObject.get(Constants.JSON.AMOUNT);
+			if (!JSONUtils.isNumber(count))
+			{
+				throw new JsonSyntaxException("Expected amount to be a number greater than zero.");
+			}
+			int amount = count.getAsJsonPrimitive().getAsInt();
+			if (amount < 1)
+			{
+				throw new JsonSyntaxException("Expected amount to be greater than zero.");
+			}
+			ResourceLocation resourceLocation = new ResourceLocation(JSONUtils.getString(jsonObject, Constants.JSON.TAG));
+			ITag<Fluid> tag = TagCollectionManager.getManager().getFluidTags().get(resourceLocation);
+			if (tag == null)
+			{
+				throw new JsonSyntaxException("Unknown fluid tag '" + resourceLocation + "'");
+			}
+			return from(tag, amount);
+		}
+		throw new JsonSyntaxException("Expected to receive a resource location representing either a tag or a fluid.");
+	}
+
+	public static FluidStackIngredient createMulti(FluidStackIngredient... ingredients)
+	{
+		if (ingredients.length == 0)
+		{
+			// TODO: Throw error
+		} else if (ingredients.length == 1)
+		{
+			return ingredients[0];
+		}
+		List<FluidStackIngredient> cleanedIngredients = new ArrayList<>();
+		for (FluidStackIngredient ingredient : ingredients)
+		{
+			if (ingredient instanceof Multi)
+			{
+				// Don't worry about if our inner ingredients are multi as well, as if this is
+				// the only external method for
+				// creating a multi ingredient, then we are certified they won't be of a higher
+				// depth
+				cleanedIngredients.addAll(Arrays.asList(((Multi) ingredient).ingredients));
+			} else
+			{
+				cleanedIngredients.add(ingredient);
+			}
+		}
+		// There should be more than a single fluid or we would have split out earlier
+		return new Multi(cleanedIngredients.toArray(new FluidStackIngredient[0]));
+	}
+
+	public static class Single extends FluidStackIngredient
+	{
+
+		@Nonnull
+		private final FluidStack fluidInstance;
+
+		public Single(@Nonnull FluidStack fluidInstance)
+		{
+			this.fluidInstance = Objects.requireNonNull(fluidInstance);
+		}
+
+		@Override
+		public boolean test(@Nonnull FluidStack fluidStack)
+		{
+			return testType(fluidStack) && fluidStack.getAmount() >= fluidInstance.getAmount();
+		}
+
+		@Override
+		public boolean testType(@Nonnull FluidStack fluidStack)
+		{
+			return Objects.requireNonNull(fluidStack).isFluidEqual(fluidInstance);
+		}
+
+		@Nonnull
+		@Override
+		public FluidStack getMatchingInstance(@Nonnull FluidStack fluidStack)
+		{
+			return test(fluidStack) ? fluidInstance : FluidStack.EMPTY;
+		}
+
+		@Nonnull
+		@Override
+		public List<FluidStack> getRepresentations()
+		{
+			return Collections.singletonList(fluidInstance);
+		}
+
+		@Override
+		public void write(PacketBuffer buffer)
+		{
+			buffer.writeEnumValue(IngredientType.SINGLE);
+			fluidInstance.writeToPacket(buffer);
+		}
+
+		@Nonnull
+		@Override
+		public JsonElement serialize()
+		{
+			JsonObject json = new JsonObject();
+			json.addProperty(Constants.JSON.AMOUNT, fluidInstance.getAmount());
+			json.addProperty(Constants.JSON.FLUID, fluidInstance.getFluid().getRegistryName().toString());
+			if (fluidInstance.hasTag())
+			{
+				json.addProperty(Constants.JSON.NBT, fluidInstance.getTag().toString());
+			}
+			return json;
+		}
+
+		public static Single read(PacketBuffer buffer)
+		{
+			return new Single(FluidStack.readFromPacket(buffer));
+		}
+	}
+
+	public static class Tagged extends FluidStackIngredient
+	{
+
+		@Nonnull
+		private final ITag<Fluid> tag;
+		private final int amount;
+
+		public Tagged(@Nonnull ITag<Fluid> tag, int amount)
+		{
+			this.tag = tag;
+			this.amount = amount;
+		}
+
+		@Override
+		public boolean test(@Nonnull FluidStack fluidStack)
+		{
+			return testType(fluidStack) && fluidStack.getAmount() >= amount;
+		}
+
+		@Override
+		public boolean testType(@Nonnull FluidStack fluidStack)
+		{
+			return Objects.requireNonNull(fluidStack).getFluid().isIn(tag);
+		}
+
+		@Nonnull
+		@Override
+		public FluidStack getMatchingInstance(@Nonnull FluidStack fluidStack)
+		{
+			if (test(fluidStack))
+			{
+				// Our fluid is in the tag so we make a new stack with the given amount
+				return new FluidStack(fluidStack, amount);
+			}
+			return FluidStack.EMPTY;
+		}
+
+		@Nonnull
+		@Override
+		public List<FluidStack> getRepresentations()
+		{
+			// TODO: Can this be cached some how
+			List<FluidStack> representations = new ArrayList<>();
+			for (Fluid fluid : TagResolverHelper.getRepresentations(tag))
+			{
+				representations.add(new FluidStack(fluid, amount));
+			}
+			return representations;
+		}
+
+		@Override
+		public void write(PacketBuffer buffer)
+		{
+			buffer.writeEnumValue(IngredientType.TAGGED);
+			buffer.writeResourceLocation(TagCollectionManager.getManager().getFluidTags().getValidatedIdFromTag(tag));
+			buffer.writeVarInt(amount);
+		}
+
+		@Nonnull
+		@Override
+		public JsonElement serialize()
+		{
+			JsonObject json = new JsonObject();
+			json.addProperty(Constants.JSON.AMOUNT, amount);
+			json.addProperty(Constants.JSON.TAG, TagCollectionManager.getManager().getFluidTags().getValidatedIdFromTag(tag).toString());
+			return json;
+		}
+
+		public static Tagged read(PacketBuffer buffer)
+		{
+			return new Tagged(FluidTags.makeWrapperTag(buffer.readResourceLocation().toString()), buffer.readVarInt());
+		}
+	}
+
+	public static class Multi extends FluidStackIngredient
+	{
+
+		private final FluidStackIngredient[] ingredients;
+
+		protected Multi(@Nonnull FluidStackIngredient... ingredients)
+		{
+			this.ingredients = ingredients;
+		}
+
+		@Override
+		public boolean test(@Nonnull FluidStack stack)
+		{
+			return Arrays.stream(ingredients).anyMatch(ingredient -> ingredient.test(stack));
+		}
+
+		@Override
+		public boolean testType(@Nonnull FluidStack stack)
+		{
+			return Arrays.stream(ingredients).anyMatch(ingredient -> ingredient.testType(stack));
+		}
+
+		@Nonnull
+		@Override
+		public FluidStack getMatchingInstance(@Nonnull FluidStack stack)
+		{
+			for (FluidStackIngredient ingredient : ingredients)
+			{
+				FluidStack matchingInstance = ingredient.getMatchingInstance(stack);
+				if (!matchingInstance.isEmpty())
+				{
+					return matchingInstance;
+				}
+			}
+			return FluidStack.EMPTY;
+		}
+
+		@Nonnull
+		@Override
+		public List<FluidStack> getRepresentations()
+		{
+			List<FluidStack> representations = new ArrayList<>();
+			for (FluidStackIngredient ingredient : ingredients)
+			{
+				representations.addAll(ingredient.getRepresentations());
+			}
+			return representations;
+		}
+
+		@Override
+		public void write(PacketBuffer buffer)
+		{
+			buffer.writeEnumValue(IngredientType.MULTI);
+			buffer.writeVarInt(ingredients.length);
+			for (FluidStackIngredient ingredient : ingredients)
+			{
+				ingredient.write(buffer);
+			}
+		}
+
+		@Nonnull
+		@Override
+		public JsonElement serialize()
+		{
+			JsonArray json = new JsonArray();
+			for (FluidStackIngredient ingredient : ingredients)
+			{
+				json.add(ingredient.serialize());
+			}
+			return json;
+		}
+
+		public static FluidStackIngredient read(PacketBuffer buffer)
+		{
+			FluidStackIngredient[] ingredients = new FluidStackIngredient[buffer.readVarInt()];
+			for (int i = 0; i < ingredients.length; i++)
+			{
+				ingredients[i] = FluidStackIngredient.read(buffer);
+			}
+			return createMulti(ingredients);
+		}
+	}
+
+	private enum IngredientType
+	{
+		SINGLE,
+		TAGGED,
+		MULTI
+	}
+}

src/main/java/wayoftime/bloodmagic/api/event/recipes/InputIngredient.java

@@ -0,0 +1,52 @@
+package wayoftime.bloodmagic.api.event.recipes;
+
+import java.util.List;
+import java.util.function.Predicate;
+
+import javax.annotation.Nonnull;
+
+import com.google.gson.JsonElement;
+
+import net.minecraft.network.PacketBuffer;
+
+public interface InputIngredient<TYPE> extends Predicate<TYPE>
+{
+
+	/**
+	 * Evaluates this predicate on the given argument, ignoring any size data.
+	 *
+	 * @param type the input argument
+	 *
+	 * @return {@code true} if the input argument matches the predicate, otherwise
+	 *         {@code false}
+	 */
+	boolean testType(@Nonnull TYPE type);
+
+	TYPE getMatchingInstance(TYPE type);
+
+	/**
+	 * Primarily for JEI, a list of valid instances of the type
+	 *
+	 * @return List (empty means no valid registrations found and recipe is to be
+	 *         hidden)
+	 *
+	 * @apiNote Do not modify any of the values returned by the representations
+	 */
+	@Nonnull
+	List<TYPE> getRepresentations();
+
+	/**
+	 * Writes this ingredient to a PacketBuffer.
+	 *
+	 * @param buffer The buffer to write to.
+	 */
+	void write(PacketBuffer buffer);
+
+	/**
+	 * Serializes this ingredient to a JsonElement
+	 *
+	 * @return JsonElement representation of this ingredient.
+	 */
+	@Nonnull
+	JsonElement serialize();
+}

src/main/java/wayoftime/bloodmagic/api/event/recipes/TagResolverHelper.java

@@ -0,0 +1,32 @@
+package wayoftime.bloodmagic.api.event.recipes;
+
+import java.util.Collections;
+import java.util.List;
+
+import net.minecraft.tags.ITag;
+
+/**
+ * Copied from Mekanism, including the author's rant about tags.
+ */
+public class TagResolverHelper
+{
+
+	public static <TYPE> List<TYPE> getRepresentations(ITag<TYPE> tag)
+	{
+		try
+		{
+			return tag.getAllElements();
+		} catch (IllegalStateException e)
+		{
+			// Why do tags have to be such an annoyance in 1.16
+			// This is needed so that we can ensure we give JEI an empty list of
+			// representations
+			// instead of crashing on the first run, as recipes get "initialized" before
+			// tags are
+			// done initializing, and we don't want to spam the log with errors. JEI and
+			// things
+			// still work fine regardless of this
+			return Collections.emptyList();
+		}
+	}
+}

src/main/java/wayoftime/bloodmagic/api/impl/BloodMagicAPI.java

@@ -0,0 +1,101 @@
+package wayoftime.bloodmagic.api.impl;
+
+import java.util.List;
+
+import javax.annotation.Nonnull;
+
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Multimap;
+
+import net.minecraft.block.BlockState;
+import wayoftime.bloodmagic.altar.ComponentType;
+import wayoftime.bloodmagic.api.IBloodMagicAPI;
+import wayoftime.bloodmagic.util.BMLog;
+
+public class BloodMagicAPI implements IBloodMagicAPI
+{
+
+	public static final BloodMagicAPI INSTANCE = new BloodMagicAPI();
+
+//	private final BloodMagicBlacklist blacklist;
+	private final BloodMagicRecipeRegistrar recipeRegistrar;
+//	private final BloodMagicValueManager valueManager;
+	private final Multimap<ComponentType, BlockState> altarComponents;
+
+	public BloodMagicAPI()
+	{
+//		this.blacklist = new BloodMagicBlacklist();
+		this.recipeRegistrar = new BloodMagicRecipeRegistrar();
+//		this.valueManager = new BloodMagicValueManager();
+		this.altarComponents = ArrayListMultimap.create();
+	}
+
+//	@Nonnull
+//	@Override
+//	public BloodMagicBlacklist getBlacklist()
+//	{
+//		return blacklist;
+//	}
+//
+	@Nonnull
+	@Override
+	public BloodMagicRecipeRegistrar getRecipeRegistrar()
+	{
+		return recipeRegistrar;
+	}
+//
+//	@Nonnull
+//	@Override
+//	public BloodMagicValueManager getValueManager()
+//	{
+//		return valueManager;
+//	}
+
+	@Override
+	public void registerAltarComponent(@Nonnull BlockState state, @Nonnull String componentType)
+	{
+		ComponentType component = null;
+		for (ComponentType type : ComponentType.VALUES)
+		{
+			if (type.name().equalsIgnoreCase(componentType))
+			{
+				component = type;
+				break;
+			}
+		}
+
+		if (component != null)
+		{
+			BMLog.API_VERBOSE.info("Registered {} as a {} altar component.", state, componentType);
+			altarComponents.put(component, state);
+		} else
+			BMLog.API.warn("Invalid Altar component type: {}.", componentType);
+	}
+
+	@Override
+	public void unregisterAltarComponent(@Nonnull BlockState state, @Nonnull String componentType)
+	{
+		ComponentType component = null;
+		for (ComponentType type : ComponentType.VALUES)
+		{
+			if (type.name().equalsIgnoreCase(componentType))
+			{
+				component = type;
+				break;
+			}
+		}
+
+		if (component != null)
+		{
+			BMLog.API_VERBOSE.info("Unregistered {} from being a {} altar component.", state, componentType);
+			altarComponents.remove(component, state);
+		} else
+			BMLog.API.warn("Invalid Altar component type: {}.", componentType);
+	}
+
+	@Nonnull
+	public List<BlockState> getComponentStates(ComponentType component)
+	{
+		return (List<BlockState>) altarComponents.get(component);
+	}
+}

src/main/java/wayoftime/bloodmagic/api/impl/BloodMagicCorePlugin.java

@@ -0,0 +1,29 @@
+package wayoftime.bloodmagic.api.impl;
+
+import net.minecraft.block.Blocks;
+import wayoftime.bloodmagic.altar.ComponentType;
+import wayoftime.bloodmagic.api.IBloodMagicAPI;
+import wayoftime.bloodmagic.common.block.BloodMagicBlocks;
+
+public class BloodMagicCorePlugin
+{
+	public static final BloodMagicCorePlugin INSTANCE = new BloodMagicCorePlugin();
+
+	public void register(IBloodMagicAPI apiInterface)
+	{
+		apiInterface.registerAltarComponent(Blocks.GLOWSTONE.getDefaultState(), ComponentType.GLOWSTONE.name());
+		apiInterface.registerAltarComponent(Blocks.SEA_LANTERN.getDefaultState(), ComponentType.GLOWSTONE.name());
+		apiInterface.registerAltarComponent(Blocks.BEACON.getDefaultState(), ComponentType.BEACON.name());
+
+		apiInterface.registerAltarComponent(BloodMagicBlocks.BLANK_RUNE.get().getDefaultState(), ComponentType.BLOODRUNE.name());
+		apiInterface.registerAltarComponent(BloodMagicBlocks.SPEED_RUNE.get().getDefaultState(), ComponentType.BLOODRUNE.name());
+		apiInterface.registerAltarComponent(BloodMagicBlocks.SACRIFICE_RUNE.get().getDefaultState(), ComponentType.BLOODRUNE.name());
+		apiInterface.registerAltarComponent(BloodMagicBlocks.SELF_SACRIFICE_RUNE.get().getDefaultState(), ComponentType.BLOODRUNE.name());
+		apiInterface.registerAltarComponent(BloodMagicBlocks.DISPLACEMENT_RUNE.get().getDefaultState(), ComponentType.BLOODRUNE.name());
+		apiInterface.registerAltarComponent(BloodMagicBlocks.CAPACITY_RUNE.get().getDefaultState(), ComponentType.BLOODRUNE.name());
+		apiInterface.registerAltarComponent(BloodMagicBlocks.AUGMENTED_CAPACITY_RUNE.get().getDefaultState(), ComponentType.BLOODRUNE.name());
+		apiInterface.registerAltarComponent(BloodMagicBlocks.ORB_RUNE.get().getDefaultState(), ComponentType.BLOODRUNE.name());
+		apiInterface.registerAltarComponent(BloodMagicBlocks.ACCELERATION_RUNE.get().getDefaultState(), ComponentType.BLOODRUNE.name());
+		apiInterface.registerAltarComponent(BloodMagicBlocks.CHARGING_RUNE.get().getDefaultState(), ComponentType.BLOODRUNE.name());
+	}
+}

src/main/java/wayoftime/bloodmagic/api/impl/BloodMagicRecipeRegistrar.java

@@ -0,0 +1,484 @@
+package wayoftime.bloodmagic.api.impl;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import org.apache.commons.lang3.tuple.Pair;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableSet;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.Ingredient;
+import net.minecraft.world.World;
+import net.minecraftforge.fluids.FluidStack;
+import wayoftime.bloodmagic.api.IBloodMagicRecipeRegistrar;
+import wayoftime.bloodmagic.api.impl.recipe.RecipeARC;
+import wayoftime.bloodmagic.api.impl.recipe.RecipeAlchemyArray;
+import wayoftime.bloodmagic.api.impl.recipe.RecipeBloodAltar;
+import wayoftime.bloodmagic.api.impl.recipe.RecipeTartaricForge;
+import wayoftime.bloodmagic.common.recipe.BloodMagicRecipeType;
+
+public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar
+{
+
+//	private final Set<RecipeBloodAltar> altarRecipes;
+//	private final Set<RecipeAlchemyTable> alchemyRecipes;
+//	private final Set<RecipeTartaricForge> tartaricForgeRecipes;
+//	private final Set<RecipeAlchemyArray> alchemyArrayRecipes;
+//	private final Set<RecipeSacrificeCraft> sacrificeCraftRecipes;
+
+	public BloodMagicRecipeRegistrar()
+	{
+//		this.altarRecipes = Sets.newHashSet();
+//		this.alchemyRecipes = Sets.newHashSet();
+//		this.tartaricForgeRecipes = Sets.newHashSet();
+//		this.alchemyArrayRecipes = Sets.newHashSet();
+//		this.sacrificeCraftRecipes = Sets.newHashSet();
+	}
+
+//	@Override
+//	public void addBloodAltar(@Nonnull Ingredient input, @Nonnull ItemStack output, @Nonnegative int minimumTier,
+//			@Nonnegative int syphon, @Nonnegative int consumeRate, @Nonnegative int drainRate)
+//	{
+//		Preconditions.checkNotNull(input, "input cannot be null.");
+//		Preconditions.checkNotNull(output, "output cannot be null.");
+//		Preconditions.checkArgument(minimumTier >= 0, "minimumTier cannot be negative.");
+//		Preconditions.checkArgument(syphon >= 0, "syphon cannot be negative.");
+//		Preconditions.checkArgument(consumeRate >= 0, "consumeRate cannot be negative.");
+//		Preconditions.checkArgument(drainRate >= 0, "drainRate cannot be negative.");
+//
+//		// TODO: Got to adda ResourceLocation argument.
+//		altarRecipes.add(new IRecipeBloodAltar(null, input, output, minimumTier, syphon, consumeRate, drainRate));
+//	}
+//
+//	@Override
+//	public boolean removeBloodAltar(@Nonnull ItemStack input)
+//	{
+//		Preconditions.checkNotNull(input, "input cannot be null.");
+//
+//		return altarRecipes.remove(getBloodAltar(input));
+//	}
+
+//	@Override
+//	public void addAlchemyTable(@Nonnull ItemStack output, @Nonnegative int syphon, @Nonnegative int ticks,
+//			@Nonnegative int minimumTier, @Nonnull Ingredient... input)
+//	{
+//		Preconditions.checkNotNull(output, "output cannot be null.");
+//		Preconditions.checkArgument(syphon >= 0, "syphon cannot be negative.");
+//		Preconditions.checkArgument(ticks >= 0, "ticks cannot be negative.");
+//		Preconditions.checkArgument(minimumTier >= 0, "minimumTier cannot be negative.");
+//		Preconditions.checkNotNull(input, "input cannot be null.");
+//
+//		NonNullList<Ingredient> inputs = NonNullList.from(Ingredient.EMPTY, input);
+//		alchemyRecipes.add(new RecipeAlchemyTable(inputs, output, syphon, ticks, minimumTier));
+//	}
+//
+//	public void addAlchemyTable(@Nonnull ItemStack output, @Nonnegative int syphon, @Nonnegative int ticks,
+//			@Nonnegative int minimumTier, @Nonnull Object... input)
+//	{
+//		Preconditions.checkNotNull(output, "output cannot be null.");
+//		Preconditions.checkArgument(syphon >= 0, "syphon cannot be negative.");
+//		Preconditions.checkArgument(ticks >= 0, "ticks cannot be negative.");
+//		Preconditions.checkArgument(minimumTier >= 0, "minimumTier cannot be negative.");
+//		Preconditions.checkNotNull(input, "input cannot be null.");
+//
+//		List<Ingredient> ingredients = Lists.newArrayList();
+//		for (Object object : input)
+//		{
+//			if (object instanceof ItemStack && ((ItemStack) object).getItem() instanceof IBloodOrb)
+//			{
+//				ingredients.add(new IngredientBloodOrb(((IBloodOrb) ((ItemStack) object).getItem()).getOrb((ItemStack) object)));
+//				continue;
+//			}
+//
+//			ingredients.add(CraftingHelper.getIngredient(object));
+//		}
+//
+//		addAlchemyTable(output, syphon, ticks, minimumTier, ingredients.toArray(new Ingredient[0]));
+//	}
+//
+//	public void addAlchemyTable(RecipeAlchemyTable recipe)
+//	{
+//		alchemyRecipes.add(recipe);
+//	}
+//
+//	@Override
+//	public boolean removeAlchemyTable(@Nonnull ItemStack... input)
+//	{
+//		Preconditions.checkNotNull(input, "inputs cannot be null.");
+//
+//		for (ItemStack stack : input) Preconditions.checkNotNull(stack, "input cannot be null.");
+//
+//		return alchemyRecipes.remove(getAlchemyTable(Lists.newArrayList(input)));
+//	}
+//
+//	@Override
+//	public void addTartaricForge(@Nonnull ItemStack output, @Nonnegative double minimumSouls,
+//			@Nonnegative double soulDrain, @Nonnull Ingredient... input)
+//	{
+//		Preconditions.checkNotNull(output, "output cannot be null.");
+//		Preconditions.checkArgument(minimumSouls >= 0, "minimumSouls cannot be negative.");
+//		Preconditions.checkArgument(soulDrain >= 0, "soulDrain cannot be negative.");
+//		Preconditions.checkNotNull(input, "input cannot be null.");
+//
+//		NonNullList<Ingredient> inputs = NonNullList.from(Ingredient.EMPTY, input);
+//		tartaricForgeRecipes.add(new RecipeTartaricForge(inputs, output, minimumSouls, soulDrain));
+//	}
+//
+//	@Override
+//	public boolean removeTartaricForge(@Nonnull ItemStack... input)
+//	{
+//		Preconditions.checkNotNull(input, "inputs cannot be null.");
+//
+//		for (ItemStack stack : input) Preconditions.checkNotNull(stack, "input cannot be null.");
+//
+//		return tartaricForgeRecipes.remove(getTartaricForge(Lists.newArrayList(input)));
+//	}
+//
+//	public void addTartaricForge(@Nonnull ItemStack output, @Nonnegative double minimumSouls,
+//			@Nonnegative double soulDrain, @Nonnull Object... input)
+//	{
+//		Preconditions.checkNotNull(output, "output cannot be null.");
+//		Preconditions.checkArgument(minimumSouls >= 0, "minimumSouls cannot be negative.");
+//		Preconditions.checkArgument(soulDrain >= 0, "soulDrain cannot be negative.");
+//		Preconditions.checkNotNull(input, "input cannot be null.");
+//
+//		List<Ingredient> ingredients = Lists.newArrayList();
+//		for (Object object : input)
+//		{
+//			if (object instanceof ItemStack && ((ItemStack) object).getItem() instanceof IBloodOrb)
+//			{
+//				ingredients.add(new IngredientBloodOrb(((IBloodOrb) ((ItemStack) object).getItem()).getOrb((ItemStack) object)));
+//				continue;
+//			}
+//
+//			ingredients.add(CraftingHelper.getIngredient(object));
+//		}
+//
+//		addTartaricForge(output, minimumSouls, soulDrain, ingredients.toArray(new Ingredient[0]));
+//	}
+//
+//	@Override
+//	public void addAlchemyArray(@Nonnull Ingredient input, @Nonnull Ingredient catalyst, @Nonnull ItemStack output,
+//			@Nullable ResourceLocation circleTexture)
+//	{
+//		Preconditions.checkNotNull(input, "input cannot be null.");
+//		Preconditions.checkNotNull(catalyst, "catalyst cannot be null.");
+//		Preconditions.checkNotNull(output, "output cannot be null.");
+//
+//		alchemyArrayRecipes.add(new RecipeAlchemyArray(input, catalyst, output, circleTexture));
+//	}
+//
+//	@Override
+//	public boolean removeAlchemyArray(@Nonnull ItemStack input, @Nonnull ItemStack catalyst)
+//	{
+//		Preconditions.checkNotNull(input, "input cannot be null.");
+//		Preconditions.checkNotNull(catalyst, "catalyst cannot be null.");
+//
+//		return alchemyArrayRecipes.remove(getAlchemyArray(input, catalyst));
+//	}
+//
+//	public void addAlchemyArray(@Nonnull ItemStack input, @Nonnull ItemStack catalyst, @Nonnull ItemStack output,
+//			@Nullable ResourceLocation circleTexture)
+//	{
+//		Preconditions.checkNotNull(input, "input cannot be null.");
+//		Preconditions.checkNotNull(catalyst, "catalyst cannot be null.");
+//		Preconditions.checkNotNull(output, "output cannot be null.");
+//
+//		addAlchemyArray(Ingredient.fromStacks(input), Ingredient.fromStacks(catalyst), output, circleTexture);
+//	}
+//
+//	public void addSacrificeCraft(@Nonnull ItemStack output, @Nonnegative double healthRequired,
+//			@Nonnull Object... input)
+//	{
+//		Preconditions.checkNotNull(output, "output cannot be null.");
+//		Preconditions.checkArgument(healthRequired >= 0, "healthRequired cannot be negative.");
+//		Preconditions.checkNotNull(input, "input cannot be null.");
+//
+//		List<Ingredient> ingredients = Lists.newArrayList();
+//		for (Object object : input)
+//		{
+//			if (object instanceof ItemStack && ((ItemStack) object).getItem() instanceof IBloodOrb)
+//			{
+//				ingredients.add(new IngredientBloodOrb(((IBloodOrb) ((ItemStack) object).getItem()).getOrb((ItemStack) object)));
+//				continue;
+//			}
+//
+//			ingredients.add(CraftingHelper.getIngredient(object));
+//		}
+//
+//		addSacrificeCraft(output, healthRequired, ingredients.toArray(new Ingredient[0]));
+//	}
+//
+//	@Override
+//	public boolean removeSacrificeCraft(@Nonnull ItemStack... input)
+//	{
+//		Preconditions.checkNotNull(input, "inputs cannot be null.");
+//
+//		for (ItemStack stack : input) Preconditions.checkNotNull(stack, "input cannot be null.");
+//
+//		return sacrificeCraftRecipes.remove(getSacrificeCraft(Lists.newArrayList(input)));
+//	}
+//
+//	@Override
+//	public void addSacrificeCraft(@Nonnull ItemStack output, @Nonnegative double healthRequired,
+//			@Nonnull Ingredient... input)
+//	{
+//		Preconditions.checkNotNull(output, "output cannot be null.");
+//		Preconditions.checkArgument(healthRequired >= 0, "healthRequired cannot be negative.");
+//		Preconditions.checkNotNull(input, "input cannot be null.");
+//
+//		NonNullList<Ingredient> inputs = NonNullList.from(Ingredient.EMPTY, input);
+//		sacrificeCraftRecipes.add(new RecipeSacrificeCraft(inputs, output, healthRequired));
+//	}
+
+	@Nullable
+	public RecipeBloodAltar getBloodAltar(World world, @Nonnull ItemStack input)
+	{
+		Preconditions.checkNotNull(input, "input cannot be null.");
+		if (input.isEmpty())
+			return null;
+
+		List<RecipeBloodAltar> altarRecipes = world.getRecipeManager().getRecipesForType(BloodMagicRecipeType.ALTAR);
+
+		for (RecipeBloodAltar recipe : altarRecipes) if (recipe.getInput().test(input))
+			return recipe;
+
+		return null;
+	}
+
+	public RecipeARC getARC(World world, @Nonnull ItemStack input, @Nonnull ItemStack arcToolInput, @Nonnull FluidStack inputFluid)
+	{
+		Preconditions.checkNotNull(input, "input cannot be null.");
+		Preconditions.checkNotNull(arcToolInput, "tool cannot be null.");
+		if (input.isEmpty() || arcToolInput.isEmpty())
+			return null;
+
+		List<RecipeARC> arcRecipes = world.getRecipeManager().getRecipesForType(BloodMagicRecipeType.ARC);
+
+		for (RecipeARC recipe : arcRecipes)
+		{
+			if (recipe.getInput().test(input) && recipe.getTool().test(arcToolInput))
+			{
+				if (recipe.getFluidIngredient() == null)
+				{
+					return recipe;
+				} else if (recipe.getFluidIngredient().test(inputFluid))
+				{
+					return recipe;
+				}
+			}
+		}
+
+//		if (input.isEmpty())
+//			return null;
+//
+//		List<RecipeBloodAltar> altarRecipes = world.getRecipeManager().getRecipesForType(BloodMagicRecipeType.ALTAR);
+//
+//		for (RecipeBloodAltar recipe : altarRecipes) if (recipe.getInput().test(input))
+//			return recipe;
+
+		return null;
+	}
+
+//	@Nullable
+//	public RecipeAlchemyTable getAlchemyTable(@Nonnull List<ItemStack> input)
+//	{
+//		Preconditions.checkNotNull(input, "input cannot be null.");
+//		if (input.isEmpty())
+//			return null;
+//
+//		mainLoop: for (RecipeAlchemyTable recipe : alchemyRecipes)
+//		{
+//			if (recipe.getInput().size() != input.size())
+//				continue;
+//
+//			List<Ingredient> recipeInput = new ArrayList<>(recipe.getInput());
+//
+//			for (int i = 0; i < input.size(); i++)
+//			{
+//				boolean matched = false;
+//				for (int j = 0; j < recipeInput.size(); j++)
+//				{
+//					Ingredient ingredient = recipeInput.get(j);
+//					if (ingredient.apply(input.get(i)))
+//					{
+//						matched = true;
+//						recipeInput.remove(j);
+//						break;
+//					}
+//				}
+//
+//				if (!matched)
+//					continue mainLoop;
+//			}
+//
+//			return recipe;
+//		}
+//
+//		return null;
+//	}
+//
+	@Nullable
+	public RecipeTartaricForge getTartaricForge(World world, @Nonnull List<ItemStack> input)
+	{
+		Preconditions.checkNotNull(input, "input cannot be null.");
+		if (input.isEmpty())
+			return null;
+
+		List<RecipeTartaricForge> tartaricForgeRecipes = world.getRecipeManager().getRecipesForType(BloodMagicRecipeType.TARTARICFORGE);
+		mainLoop: for (RecipeTartaricForge recipe : tartaricForgeRecipes)
+		{
+			if (recipe.getInput().size() != input.size())
+				continue;
+
+			List<Ingredient> recipeInput = new ArrayList<>(recipe.getInput());
+
+			for (int i = 0; i < input.size(); i++)
+			{
+				boolean matched = false;
+				for (int j = 0; j < recipeInput.size(); j++)
+				{
+					Ingredient ingredient = recipeInput.get(j);
+					if (ingredient.test(input.get(i)))
+					{
+						matched = true;
+						recipeInput.remove(j);
+						break;
+					}
+				}
+
+				if (!matched)
+					continue mainLoop;
+			}
+
+			return recipe;
+		}
+
+		return null;
+	}
+
+//
+//	@Nullable
+//	public RecipeSacrificeCraft getSacrificeCraft(@Nonnull List<ItemStack> input)
+//	{
+//		Preconditions.checkNotNull(input, "input cannot be null.");
+//		if (input.isEmpty())
+//			return null;
+//
+//		mainLoop: for (RecipeSacrificeCraft recipe : sacrificeCraftRecipes)
+//		{
+//			if (recipe.getInput().size() != input.size())
+//				continue;
+//
+//			List<Ingredient> recipeInput = new ArrayList<>(recipe.getInput());
+//
+//			for (int i = 0; i < input.size(); i++)
+//			{
+//				boolean matched = false;
+//				for (int j = 0; j < recipeInput.size(); j++)
+//				{
+//					Ingredient ingredient = recipeInput.get(j);
+//					if (ingredient.apply(input.get(i)))
+//					{
+//						matched = true;
+//						recipeInput.remove(j);
+//						break;
+//					}
+//				}
+//
+//				if (!matched)
+//					continue mainLoop;
+//			}
+//
+//			return recipe;
+//		}
+//
+//		return null;
+//	}
+//
+	/**
+	 * 
+	 * @param world
+	 * @param input
+	 * @param catalyst
+	 * @return If false and the recipe is nonnull, it is a partial match. If true,
+	 *         the returned recipe is a full match.
+	 */
+	@Nullable
+	public Pair<Boolean, RecipeAlchemyArray> getAlchemyArray(World world, @Nonnull ItemStack input, @Nonnull ItemStack catalyst)
+	{
+		Preconditions.checkNotNull(input, "input cannot be null.");
+		if (input.isEmpty())
+			return null;
+
+		List<RecipeAlchemyArray> altarRecipes = world.getRecipeManager().getRecipesForType(BloodMagicRecipeType.ARRAY);
+
+		RecipeAlchemyArray partialMatch = null;
+		for (RecipeAlchemyArray recipe : altarRecipes)
+		{
+			if (recipe.getBaseInput().test(input))
+			{
+				if (recipe.getAddedInput().test(catalyst))
+				{
+					return Pair.of(true, recipe);
+				} else if (partialMatch == null)
+				{
+					partialMatch = recipe;
+				}
+			}
+		}
+
+		return Pair.of(false, partialMatch);
+	}
+
+	public Set<RecipeBloodAltar> getAltarRecipes(World world)
+	{
+		return ImmutableSet.copyOf(world.getRecipeManager().getRecipesForType(BloodMagicRecipeType.ALTAR));
+	}
+
+	public Set<RecipeTartaricForge> getTartaricForgeRecipes(World world)
+	{
+		return ImmutableSet.copyOf(world.getRecipeManager().getRecipesForType(BloodMagicRecipeType.TARTARICFORGE));
+	}
+
+	public Set<RecipeAlchemyArray> getAlchemyArrayRecipes(World world)
+	{
+		return ImmutableSet.copyOf(world.getRecipeManager().getRecipesForType(BloodMagicRecipeType.ARRAY));
+	}
+
+	public Set<RecipeAlchemyArray> getCraftingAlchemyArrayRecipes(World world)
+	{
+		Set<RecipeAlchemyArray> recipes = Set.copyOf(world.getRecipeManager().getRecipesForType(BloodMagicRecipeType.ARRAY));
+		Set<RecipeAlchemyArray> copyRecipes = Set.of();
+		for (RecipeAlchemyArray recipe : recipes)
+		{
+			if (!recipe.getOutput().isEmpty())
+			{
+				copyRecipes.add(recipe);
+			}
+		}
+
+		return copyRecipes;
+	}
+
+//	public Set<RecipeAlchemyTable> getAlchemyRecipes()
+//	{
+//		return ImmutableSet.copyOf(alchemyRecipes);
+//	}
+//
+//	public Set<RecipeTartaricForge> getTartaricForgeRecipes()
+//	{
+//		return ImmutableSet.copyOf(tartaricForgeRecipes);
+//	}
+//
+//	public Set<RecipeAlchemyArray> getAlchemyArrayRecipes()
+//	{
+//		return ImmutableSet.copyOf(alchemyArrayRecipes);
+//	}
+}

src/main/java/wayoftime/bloodmagic/api/impl/recipe/BloodMagicRecipe.java

@@ -0,0 +1,69 @@
+package wayoftime.bloodmagic.api.impl.recipe;
+
+import javax.annotation.Nonnull;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.IRecipe;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.world.World;
+import wayoftime.bloodmagic.api.inventory.IgnoredIInventory;
+
+public abstract class BloodMagicRecipe implements IRecipe<IgnoredIInventory>
+{
+	private final ResourceLocation id;
+
+	protected BloodMagicRecipe(ResourceLocation id)
+	{
+		this.id = id;
+	}
+
+	/**
+	 * Writes this recipe to a PacketBuffer.
+	 *
+	 * @param buffer The buffer to write to.
+	 */
+	public abstract void write(PacketBuffer buffer);
+
+	@Nonnull
+	@Override
+	public ResourceLocation getId()
+	{
+		return id;
+	}
+
+	@Override
+	public boolean matches(@Nonnull IgnoredIInventory inv, @Nonnull World world)
+	{
+		return true;
+	}
+
+	@Override
+	public boolean isDynamic()
+	{
+		// Note: If we make this non dynamic, we can make it show in vanilla's crafting
+		// book and also then obey the recipe locking.
+		// For now none of that works/makes sense in our concept so don't lock it
+		return true;
+	}
+
+	@Nonnull
+	@Override
+	public ItemStack getCraftingResult(@Nonnull IgnoredIInventory inv)
+	{
+		return ItemStack.EMPTY;
+	}
+
+	@Override
+	public boolean canFit(int width, int height)
+	{
+		return true;
+	}
+
+	@Nonnull
+	@Override
+	public ItemStack getRecipeOutput()
+	{
+		return ItemStack.EMPTY;
+	}
+}

src/main/java/wayoftime/bloodmagic/api/impl/recipe/RecipeARC.java

@@ -0,0 +1,145 @@
+package wayoftime.bloodmagic.api.impl.recipe;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import javax.annotation.Nonnull;
+
+import org.apache.commons.lang3.tuple.Pair;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.Ingredient;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.util.NonNullList;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.fluids.FluidStack;
+import wayoftime.bloodmagic.api.event.recipes.FluidStackIngredient;
+
+public abstract class RecipeARC extends BloodMagicRecipe
+{
+	public static final int MAX_RANDOM_OUTPUTS = 3;
+
+	@Nonnull
+	private final Ingredient input;
+	@Nonnull
+	private final Ingredient arc_tool;
+	private final FluidStackIngredient inputFluid;
+	@Nonnull
+	private final ItemStack output;
+	private final FluidStack outputFluid;
+
+	private final List<Pair<ItemStack, Double>> addedItems;
+
+	protected RecipeARC(ResourceLocation id, Ingredient input, Ingredient arc_tool, FluidStackIngredient inputFluid, ItemStack output, FluidStack outputFluid)
+	{
+		this(id, input, arc_tool, inputFluid, output, new ArrayList<Pair<ItemStack, Double>>(), outputFluid);
+	}
+
+	protected RecipeARC(ResourceLocation id, Ingredient input, Ingredient arc_tool, FluidStackIngredient inputFluid, ItemStack output, List<Pair<ItemStack, Double>> addedItems, FluidStack outputFluid)
+	{
+		super(id);
+		this.input = input;
+		this.arc_tool = arc_tool;
+		this.inputFluid = inputFluid;
+		this.output = output;
+		this.addedItems = addedItems;
+		this.outputFluid = outputFluid;
+	}
+
+	public RecipeARC addRandomOutput(ItemStack stack, double chance)
+	{
+		if (addedItems.size() >= MAX_RANDOM_OUTPUTS)
+		{
+			return this;
+		}
+
+		addedItems.add(Pair.of(stack, chance));
+
+		return this;
+	}
+
+	@Nonnull
+	public final Ingredient getInput()
+	{
+		return input;
+	}
+
+	@Nonnull
+	public final Ingredient getTool()
+	{
+		return arc_tool;
+	}
+
+	public final FluidStackIngredient getFluidIngredient()
+	{
+		return inputFluid;
+	}
+
+	public final FluidStack getFluidOutput()
+	{
+		return outputFluid;
+	}
+
+	@Override
+	public final NonNullList<Ingredient> getIngredients()
+	{
+		NonNullList<Ingredient> list = NonNullList.create();
+		list.add(getInput());
+		list.add(getTool());
+		return list;
+	}
+
+	public List<ItemStack> getAllListedOutputs()
+	{
+		List<ItemStack> list = new ArrayList<ItemStack>();
+
+		list.add(output.copy());
+		for (Pair<ItemStack, Double> pair : addedItems)
+		{
+			list.add(pair.getLeft().copy());
+		}
+
+		return list;
+	}
+
+	public List<ItemStack> getAllOutputs(Random rand)
+	{
+		List<ItemStack> list = new ArrayList<ItemStack>();
+
+		list.add(output.copy());
+		for (Pair<ItemStack, Double> pair : addedItems)
+		{
+			if (rand.nextDouble() < pair.getRight())
+				list.add(pair.getLeft().copy());
+		}
+
+		return list;
+	}
+
+	@Override
+	public void write(PacketBuffer buffer)
+	{
+		input.write(buffer);
+		arc_tool.write(buffer);
+		buffer.writeItemStack(output);
+		buffer.writeInt(addedItems.size());
+		for (Pair<ItemStack, Double> pair : addedItems)
+		{
+			buffer.writeItemStack(pair.getLeft());
+			buffer.writeDouble(pair.getValue());
+		}
+
+		buffer.writeBoolean(inputFluid != null);
+		if (inputFluid != null)
+		{
+			inputFluid.write(buffer);
+		}
+
+		buffer.writeBoolean(outputFluid != null);
+		if (outputFluid != null)
+		{
+			outputFluid.writeToPacket(buffer);
+		}
+	}
+}

src/main/java/wayoftime/bloodmagic/api/impl/recipe/RecipeAlchemyArray.java

@@ -0,0 +1,87 @@
+package wayoftime.bloodmagic.api.impl.recipe;
+
+import javax.annotation.Nonnull;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.Ingredient;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.util.NonNullList;
+import net.minecraft.util.ResourceLocation;
+
+public abstract class RecipeAlchemyArray extends BloodMagicRecipe
+{
+	private final ResourceLocation id;
+	private final ResourceLocation texture;
+	@Nonnull
+	private final Ingredient baseInput;
+	@Nonnull
+	private final Ingredient addedInput;
+	@Nonnull
+	private final ItemStack output;
+
+	protected RecipeAlchemyArray(ResourceLocation id, ResourceLocation texture, @Nonnull Ingredient baseIngredient, @Nonnull Ingredient addedIngredient, @Nonnull ItemStack result)
+	{
+		super(id);
+		this.id = id;
+		this.texture = texture;
+		this.baseInput = baseIngredient;
+		this.addedInput = addedIngredient;
+		this.output = result;
+	}
+
+	@Nonnull
+	public final ResourceLocation getId()
+	{
+		return id;
+	}
+
+	@Nonnull
+	public final ResourceLocation getTexture()
+	{
+		return texture;
+	}
+
+	@Nonnull
+	public final Ingredient getBaseInput()
+	{
+		return baseInput;
+	}
+
+	@Nonnull
+	public final Ingredient getAddedInput()
+	{
+		return addedInput;
+	}
+
+	@Override
+	public final NonNullList<Ingredient> getIngredients()
+	{
+		NonNullList<Ingredient> list = NonNullList.create();
+		list.add(getBaseInput());
+		list.add(getAddedInput());
+		return list;
+	}
+
+	@Nonnull
+	public final ItemStack getOutput()
+	{
+		return output;
+	}
+
+	@Override
+	public void write(PacketBuffer buffer)
+	{
+		if (texture != null)
+		{
+			buffer.writeBoolean(true);
+			buffer.writeResourceLocation(texture);
+		} else
+		{
+			buffer.writeBoolean(false);
+		}
+
+		baseInput.write(buffer);
+		addedInput.write(buffer);
+		buffer.writeItemStack(output);
+	}
+}

src/main/java/wayoftime/bloodmagic/api/impl/recipe/RecipeBloodAltar.java

@@ -0,0 +1,103 @@
+package wayoftime.bloodmagic.api.impl.recipe;
+
+import javax.annotation.Nonnegative;
+import javax.annotation.Nonnull;
+
+import com.google.common.base.Preconditions;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.Ingredient;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.util.NonNullList;
+import net.minecraft.util.ResourceLocation;
+import wayoftime.bloodmagic.altar.AltarTier;
+
+public abstract class RecipeBloodAltar extends BloodMagicRecipe
+{
+	@Nonnull
+	private final Ingredient input;
+	@Nonnull
+	private final ItemStack output;
+	@Nonnull
+	private final AltarTier minimumTier;
+	@Nonnegative
+	private final int syphon;
+	@Nonnegative
+	private final int consumeRate;
+	@Nonnegative
+	private final int drainRate;
+
+	public RecipeBloodAltar(ResourceLocation id, @Nonnull Ingredient input, @Nonnull ItemStack output, @Nonnegative int minimumTier, @Nonnegative int syphon, @Nonnegative int consumeRate, @Nonnegative int drainRate)
+	{
+		super(id);
+		Preconditions.checkNotNull(input, "input cannot be null.");
+		Preconditions.checkNotNull(output, "output cannot be null.");
+		Preconditions.checkArgument(minimumTier >= 0, "minimumTier cannot be negative.");
+		Preconditions.checkArgument(minimumTier <= AltarTier.MAXTIERS, "minimumTier cannot be higher than max tier");
+		Preconditions.checkArgument(syphon >= 0, "syphon cannot be negative.");
+		Preconditions.checkArgument(consumeRate >= 0, "consumeRate cannot be negative.");
+		Preconditions.checkArgument(drainRate >= 0, "drain cannot be negative.");
+
+		this.input = input;
+		this.output = output;
+		this.minimumTier = AltarTier.values()[minimumTier];
+		this.syphon = syphon;
+		this.consumeRate = consumeRate;
+		this.drainRate = drainRate;
+	}
+
+	@Nonnull
+	public final Ingredient getInput()
+	{
+		return input;
+	}
+
+	@Override
+	public final NonNullList<Ingredient> getIngredients()
+	{
+		NonNullList<Ingredient> list = NonNullList.create();
+		list.add(getInput());
+		return list;
+	}
+
+	@Nonnull
+	public final ItemStack getOutput()
+	{
+		return output;
+	}
+
+	@Nonnull
+	public AltarTier getMinimumTier()
+	{
+		return minimumTier;
+	}
+
+	@Nonnegative
+	public final int getSyphon()
+	{
+		return syphon;
+	}
+
+	@Nonnegative
+	public final int getConsumeRate()
+	{
+		return consumeRate;
+	}
+
+	@Nonnegative
+	public final int getDrainRate()
+	{
+		return drainRate;
+	}
+
+	@Override
+	public void write(PacketBuffer buffer)
+	{
+		input.write(buffer);
+		buffer.writeItemStack(output);
+		buffer.writeInt(minimumTier.ordinal());
+		buffer.writeInt(syphon);
+		buffer.writeInt(consumeRate);
+		buffer.writeInt(drainRate);
+	}
+}

src/main/java/wayoftime/bloodmagic/api/impl/recipe/RecipeTartaricForge.java

@@ -0,0 +1,77 @@
+package wayoftime.bloodmagic.api.impl.recipe;
+
+import java.util.List;
+
+import javax.annotation.Nonnegative;
+import javax.annotation.Nonnull;
+
+import com.google.common.base.Preconditions;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.Ingredient;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.util.ResourceLocation;
+
+public abstract class RecipeTartaricForge extends BloodMagicRecipe
+{
+	@Nonnull
+	private final List<Ingredient> input;
+	@Nonnull
+	private final ItemStack output;
+	@Nonnegative
+	private final double minimumSouls;
+	@Nonnegative
+	private final double soulDrain;
+
+	public RecipeTartaricForge(ResourceLocation id, @Nonnull List<Ingredient> input, @Nonnull ItemStack output, @Nonnegative double minimumSouls, @Nonnegative double soulDrain)
+	{
+		super(id);
+		Preconditions.checkNotNull(input, "input cannot be null.");
+		Preconditions.checkNotNull(output, "output cannot be null.");
+		Preconditions.checkArgument(minimumSouls >= 0, "minimumSouls cannot be negative.");
+		Preconditions.checkArgument(soulDrain >= 0, "soulDrain cannot be negative.");
+
+		this.input = input;
+		this.output = output;
+		this.minimumSouls = minimumSouls;
+		this.soulDrain = soulDrain;
+	}
+
+	@Nonnull
+	public final List<Ingredient> getInput()
+	{
+		return input;
+	}
+
+	@Nonnull
+	public final ItemStack getOutput()
+	{
+		return output;
+	}
+
+	@Nonnegative
+	public final double getMinimumSouls()
+	{
+		return minimumSouls;
+	}
+
+	@Nonnegative
+	public final double getSoulDrain()
+	{
+		return soulDrain;
+	}
+
+	@Override
+	public void write(PacketBuffer buffer)
+	{
+		buffer.writeInt(input.size());
+		for (int i = 0; i < input.size(); i++)
+		{
+			input.get(i).write(buffer);
+		}
+		buffer.writeItemStack(output);
+		buffer.writeDouble(minimumSouls);
+		buffer.writeDouble(soulDrain);
+
+	}
+}

src/main/java/wayoftime/bloodmagic/api/inventory/IgnoredIInventory.java

@@ -0,0 +1,67 @@
+package wayoftime.bloodmagic.api.inventory;
+
+import javax.annotation.Nonnull;
+
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+
+public final class IgnoredIInventory implements IInventory
+{
+	public static final IgnoredIInventory INSTANCE = new IgnoredIInventory();
+
+	private IgnoredIInventory()
+	{
+	}
+
+	@Override
+	public int getSizeInventory()
+	{
+		return 0;
+	}
+
+	@Override
+	public boolean isEmpty()
+	{
+		return true;
+	}
+
+	@Override
+	public ItemStack getStackInSlot(int index)
+	{
+		return ItemStack.EMPTY;
+	}
+
+	@Override
+	public ItemStack decrStackSize(int index, int count)
+	{
+		return ItemStack.EMPTY;
+	}
+
+	@Override
+	public ItemStack removeStackFromSlot(int index)
+	{
+		return ItemStack.EMPTY;
+	}
+
+	@Override
+	public void setInventorySlotContents(int index, @Nonnull ItemStack stack)
+	{
+	}
+
+	@Override
+	public void markDirty()
+	{
+	}
+
+	@Override
+	public boolean isUsableByPlayer(@Nonnull PlayerEntity player)
+	{
+		return false;
+	}
+
+	@Override
+	public void clear()
+	{
+	}
+}

src/main/java/wayoftime/bloodmagic/api/providers/IBaseProvider.java

@@ -0,0 +1,23 @@
+package wayoftime.bloodmagic.api.providers;
+
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TranslationTextComponent;
+import wayoftime.bloodmagic.api.text.IHasTextComponent;
+import wayoftime.bloodmagic.api.text.IHasTranslationKey;
+
+public interface IBaseProvider extends IHasTextComponent, IHasTranslationKey
+{
+	ResourceLocation getRegistryName();
+
+	default String getName()
+	{
+		return getRegistryName().getPath();
+	}
+
+	@Override
+	default ITextComponent getTextComponent()
+	{
+		return new TranslationTextComponent(getTranslationKey());
+	}
+}

src/main/java/wayoftime/bloodmagic/api/providers/IEntityTypeProvider.java

@@ -0,0 +1,32 @@
+package wayoftime.bloodmagic.api.providers;
+
+import javax.annotation.Nonnull;
+
+import net.minecraft.entity.EntityType;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.text.ITextComponent;
+
+public interface IEntityTypeProvider extends IBaseProvider
+{
+
+	@Nonnull
+	EntityType<?> getEntityType();
+
+	@Override
+	default ResourceLocation getRegistryName()
+	{
+		return getEntityType().getRegistryName();
+	}
+
+	@Override
+	default ITextComponent getTextComponent()
+	{
+		return getEntityType().getName();
+	}
+
+	@Override
+	default String getTranslationKey()
+	{
+		return getEntityType().getTranslationKey();
+	}
+}

src/main/java/wayoftime/bloodmagic/api/text/IHasTextComponent.java

@@ -0,0 +1,8 @@
+package wayoftime.bloodmagic.api.text;
+
+import net.minecraft.util.text.ITextComponent;
+
+public interface IHasTextComponent
+{
+	ITextComponent getTextComponent();
+}

src/main/java/wayoftime/bloodmagic/api/text/IHasTranslationKey.java

@@ -0,0 +1,6 @@
+package wayoftime.bloodmagic.api.text;
+
+public interface IHasTranslationKey
+{
+	String getTranslationKey();
+}

src/main/java/wayoftime/bloodmagic/block/enums/BloodRuneType.java

@@ -0,0 +1,28 @@
+package wayoftime.bloodmagic.block.enums;
+
+import java.util.Locale;
+
+import net.minecraft.util.IStringSerializable;
+
+public enum BloodRuneType implements IStringSerializable
+{
+	BLANK, SPEED, EFFICIENCY, SACRIFICE, SELF_SACRIFICE, DISPLACEMENT, CAPACITY, AUGMENTED_CAPACITY, ORB, ACCELERATION,
+	CHARGING;
+
+	@Override
+	public String toString()
+	{
+		return name().toLowerCase(Locale.ENGLISH);
+	}
+
+	/**
+	 * getName()
+	 * 
+	 * @return
+	 */
+	@Override
+	public String getString()
+	{
+		return this.toString();
+	}
+}

src/main/java/wayoftime/bloodmagic/block/enums/EnumRitualController.java

@@ -0,0 +1,23 @@
+package wayoftime.bloodmagic.block.enums;
+
+import java.util.Locale;
+
+import net.minecraft.util.IStringSerializable;
+
+//TODO: Will want to probably discontinue this due to The Flattening
+public enum EnumRitualController implements IStringSerializable
+{
+	MASTER, IMPERFECT, INVERTED,;
+
+	@Override
+	public String toString()
+	{
+		return name().toLowerCase(Locale.ENGLISH);
+	}
+
+	@Override
+	public String getString()
+	{
+		return this.toString();
+	}
+}

src/main/java/wayoftime/bloodmagic/client/ClientEvents.java

@@ -0,0 +1,100 @@
+package wayoftime.bloodmagic.client;
+
+import net.minecraft.client.gui.ScreenManager;
+import net.minecraft.client.world.ClientWorld;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.item.IItemPropertyGetter;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemModelsProperties;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.client.event.ModelRegistryEvent;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.fml.client.registry.ClientRegistry;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.client.render.block.RenderAlchemyArray;
+import wayoftime.bloodmagic.client.render.block.RenderAltar;
+import wayoftime.bloodmagic.client.screens.ScreenAlchemicalReactionChamber;
+import wayoftime.bloodmagic.client.screens.ScreenSoulForge;
+import wayoftime.bloodmagic.common.block.BloodMagicBlocks;
+import wayoftime.bloodmagic.common.item.BloodMagicItems;
+import wayoftime.bloodmagic.common.item.sigil.ItemSigilToggleable;
+import wayoftime.bloodmagic.common.item.soul.ItemSentientSword;
+import wayoftime.bloodmagic.iface.IMultiWillTool;
+import wayoftime.bloodmagic.tile.TileAlchemyArray;
+import wayoftime.bloodmagic.tile.TileAltar;
+
+@Mod.EventBusSubscriber(value = Dist.CLIENT, modid = BloodMagic.MODID, bus = Mod.EventBusSubscriber.Bus.MOD)
+public class ClientEvents
+{
+	@SubscribeEvent
+	public static void registerModels(ModelRegistryEvent event)
+	{
+		ClientRegistry.bindTileEntityRenderer(TileAltar.TYPE, RenderAltar::new);
+		ClientRegistry.bindTileEntityRenderer(TileAlchemyArray.TYPE, RenderAlchemyArray::new);
+//		ClientRegistry.bindTileEntityRenderer(TileSoulForge.TYPE, RenderAlchemyArray::new);
+	}
+
+	public static void registerContainerScreens()
+	{
+		ScreenManager.registerFactory(BloodMagicBlocks.SOUL_FORGE_CONTAINER.get(), ScreenSoulForge::new);
+		ScreenManager.registerFactory(BloodMagicBlocks.ARC_CONTAINER.get(), ScreenAlchemicalReactionChamber::new);
+	}
+
+	public static void registerItemModelProperties(FMLClientSetupEvent event)
+	{
+		registerToggleableProperties(BloodMagicItems.GREEN_GROVE_SIGIL.get());
+		registerToggleableProperties(BloodMagicItems.FAST_MINER_SIGIL.get());
+		registerToggleableProperties(BloodMagicItems.MAGNETISM_SIGIL.get());
+		registerToggleableProperties(BloodMagicItems.ICE_SIGIL.get());
+		registerMultiWillTool(BloodMagicItems.SENTIENT_SWORD.get());
+		registerMultiWillTool(BloodMagicItems.PETTY_GEM.get());
+		registerMultiWillTool(BloodMagicItems.LESSER_GEM.get());
+		registerMultiWillTool(BloodMagicItems.COMMON_GEM.get());
+
+		ItemModelsProperties.registerProperty(BloodMagicItems.SENTIENT_SWORD.get(), BloodMagic.rl("active"), new IItemPropertyGetter()
+		{
+			@Override
+			public float call(ItemStack stack, ClientWorld world, LivingEntity entity)
+			{
+				return ((ItemSentientSword) stack.getItem()).getActivated(stack) ? 1 : 0;
+			}
+		});
+	}
+
+	public static void registerToggleableProperties(Item item)
+	{
+		ItemModelsProperties.registerProperty(item, BloodMagic.rl("active"), new IItemPropertyGetter()
+		{
+			@Override
+			public float call(ItemStack stack, ClientWorld world, LivingEntity entity)
+			{
+				Item item = stack.getItem();
+				if (item instanceof ItemSigilToggleable)
+				{
+					return ((ItemSigilToggleable) item).getActivated(stack) ? 1 : 0;
+				}
+				return 0;
+			}
+		});
+	}
+
+	public static void registerMultiWillTool(Item item)
+	{
+		ItemModelsProperties.registerProperty(item, BloodMagic.rl("type"), new IItemPropertyGetter()
+		{
+			@Override
+			public float call(ItemStack stack, ClientWorld world, LivingEntity entity)
+			{
+				Item item = stack.getItem();
+				if (item instanceof IMultiWillTool)
+				{
+					return ((IMultiWillTool) item).getCurrentType(stack).ordinal();
+				}
+				return 0;
+			}
+		});
+	}
+}

src/main/java/wayoftime/bloodmagic/client/render/BloodMagicRenderer.java

@@ -0,0 +1,104 @@
+package wayoftime.bloodmagic.client.render;
+
+import java.util.Arrays;
+
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.util.Direction;
+import net.minecraft.util.ResourceLocation;
+
+public class BloodMagicRenderer
+{
+	public static float getRed(int color)
+	{
+		return (color >> 16 & 0xFF) / 255.0F;
+	}
+
+	public static float getGreen(int color)
+	{
+		return (color >> 8 & 0xFF) / 255.0F;
+	}
+
+	public static float getBlue(int color)
+	{
+		return (color & 0xFF) / 255.0F;
+	}
+
+	public static float getAlpha(int color)
+	{
+		return (color >> 24 & 0xFF) / 255.0F;
+	}
+
+	public static class Model3D
+	{
+		public double minX, minY, minZ;
+		public double maxX, maxY, maxZ;
+
+		public final TextureAtlasSprite[] textures = new TextureAtlasSprite[6];
+
+		public final boolean[] renderSides = new boolean[]
+		{ true, true, true, true, true, true, false };
+
+		public double sizeX()
+		{
+			return maxX - minX;
+		}
+
+		public double sizeY()
+		{
+			return maxY - minY;
+		}
+
+		public double sizeZ()
+		{
+			return maxZ - minZ;
+		}
+
+		public void setSideRender(Direction side, boolean value)
+		{
+			renderSides[side.ordinal()] = value;
+		}
+
+		public boolean shouldSideRender(Direction side)
+		{
+			return renderSides[side.ordinal()];
+		}
+
+		public void setTexture(TextureAtlasSprite tex)
+		{
+			Arrays.fill(textures, tex);
+		}
+
+		public void setTextures(TextureAtlasSprite down, TextureAtlasSprite up, TextureAtlasSprite north, TextureAtlasSprite south, TextureAtlasSprite west, TextureAtlasSprite east)
+		{
+			textures[0] = down;
+			textures[1] = up;
+			textures[2] = north;
+			textures[3] = south;
+			textures[4] = west;
+			textures[5] = east;
+		}
+	}
+
+	public static class Model2D
+	{
+		public double minX, minY;
+		public double maxX, maxY;
+
+		public ResourceLocation resource;
+
+		public double sizeX()
+		{
+			return maxX - minX;
+		}
+
+		public double sizeY()
+		{
+			return maxY - minY;
+		}
+
+		public void setTexture(ResourceLocation resource)
+		{
+			this.resource = resource;
+		}
+	}
+}

src/main/java/wayoftime/bloodmagic/client/render/RenderResizableCuboid.java

@@ -0,0 +1,168 @@
+package wayoftime.bloodmagic.client.render;
+
+import java.util.Arrays;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.blaze3d.vertex.IVertexBuilder;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.entity.EntityRendererManager;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.util.Direction;
+import net.minecraft.util.Direction.Axis;
+import net.minecraft.util.Direction.AxisDirection;
+import net.minecraft.util.math.vector.Matrix3f;
+import net.minecraft.util.math.vector.Matrix4f;
+import net.minecraft.util.math.vector.Vector3d;
+import net.minecraft.util.math.vector.Vector3f;
+import net.minecraft.util.math.vector.Vector3i;
+import wayoftime.bloodmagic.client.render.BloodMagicRenderer.Model3D;
+
+/**
+ * Adapted from BuildCraft
+ */
+public class RenderResizableCuboid
+{
+	public static final RenderResizableCuboid INSTANCE = new RenderResizableCuboid();
+	private static final Vector3f VEC_ZERO = new Vector3f(0, 0, 0);
+	private static final int U_MIN = 0;
+	private static final int U_MAX = 1;
+	private static final int V_MIN = 2;
+	private static final int V_MAX = 3;
+
+	protected EntityRendererManager manager = Minecraft.getInstance().getRenderManager();
+
+	private static Vector3f withValue(Vector3f vector, Axis axis, float value)
+	{
+		if (axis == Axis.X)
+		{
+			return new Vector3f(value, vector.getY(), vector.getZ());
+		} else if (axis == Axis.Y)
+		{
+			return new Vector3f(vector.getX(), value, vector.getZ());
+		} else if (axis == Axis.Z)
+		{
+			return new Vector3f(vector.getX(), vector.getY(), value);
+		}
+		throw new RuntimeException("Was given a null axis! That was probably not intentional, consider this a bug! (Vector = "
+				+ vector + ")");
+	}
+
+	public static double getValue(Vector3d vector, Axis axis)
+	{
+		if (axis == Axis.X)
+		{
+			return vector.x;
+		} else if (axis == Axis.Y)
+		{
+			return vector.y;
+		} else if (axis == Axis.Z)
+		{
+			return vector.z;
+		}
+		throw new RuntimeException("Was given a null axis! That was probably not intentional, consider this a bug! (Vector = "
+				+ vector + ")");
+	}
+
+	public void renderCube(Model3D cube, MatrixStack matrix, IVertexBuilder buffer, int argb, int light, int overlay)
+	{
+		float red = BloodMagicRenderer.getRed(argb);
+		float green = BloodMagicRenderer.getGreen(argb);
+		float blue = BloodMagicRenderer.getBlue(argb);
+		float alpha = BloodMagicRenderer.getAlpha(argb);
+		Vector3d size = new Vector3d(cube.sizeX(), cube.sizeY(), cube.sizeZ());
+		matrix.push();
+		matrix.translate(cube.minX, cube.minY, cube.minZ);
+		MatrixStack.Entry lastMatrix = matrix.getLast();
+		Matrix4f matrix4f = lastMatrix.getMatrix();
+		Matrix3f normal = lastMatrix.getNormal();
+		for (Direction face : Direction.values())
+		{
+			if (cube.shouldSideRender(face))
+			{
+				int ordinal = face.ordinal();
+				TextureAtlasSprite sprite = cube.textures[ordinal];
+				if (sprite != null)
+				{
+					Axis u = face.getAxis() == Axis.X ? Axis.Z : Axis.X;
+					Axis v = face.getAxis() == Axis.Y ? Axis.Z : Axis.Y;
+					float other = face.getAxisDirection() == AxisDirection.POSITIVE
+							? (float) getValue(size, face.getAxis())
+							: 0;
+
+					// Swap the face if this is positive: the renderer returns indexes that ALWAYS
+					// are for the negative face, so light it properly this way
+					face = face.getAxisDirection() == AxisDirection.NEGATIVE ? face : face.getOpposite();
+					Direction opposite = face.getOpposite();
+
+					float minU = sprite.getMinU();
+					float maxU = sprite.getMaxU();
+					// Flip the v
+					float minV = sprite.getMaxV();
+					float maxV = sprite.getMinV();
+					double sizeU = getValue(size, u);
+					double sizeV = getValue(size, v);
+					// TODO: Look into this more, as it makes tiling of multiple objects not render
+					// properly if they don't fit the full texture.
+					// Example: Mechanical pipes rendering water or lava, makes it relatively easy
+					// to see the texture artifacts
+					for (int uIndex = 0; uIndex < sizeU; uIndex++)
+					{
+						float[] baseUV = new float[]
+						{ minU, maxU, minV, maxV };
+						double addU = 1;
+						// If the size of the texture is greater than the cuboid goes on for then make
+						// sure the texture positions are lowered
+						if (uIndex + addU > sizeU)
+						{
+							addU = sizeU - uIndex;
+							baseUV[U_MAX] = baseUV[U_MIN] + (baseUV[U_MAX] - baseUV[U_MIN]) * (float) addU;
+						}
+						for (int vIndex = 0; vIndex < sizeV; vIndex++)
+						{
+							float[] uv = Arrays.copyOf(baseUV, 4);
+							double addV = 1;
+							if (vIndex + addV > sizeV)
+							{
+								addV = sizeV - vIndex;
+								uv[V_MAX] = uv[V_MIN] + (uv[V_MAX] - uv[V_MIN]) * (float) addV;
+							}
+							float[] xyz = new float[]
+							{ uIndex, (float) (uIndex + addU), vIndex, (float) (vIndex + addV) };
+
+							renderPoint(matrix4f, normal, buffer, face, u, v, other, uv, xyz, true, false, red, green, blue, alpha, light, overlay);
+							renderPoint(matrix4f, normal, buffer, face, u, v, other, uv, xyz, true, true, red, green, blue, alpha, light, overlay);
+							renderPoint(matrix4f, normal, buffer, face, u, v, other, uv, xyz, false, true, red, green, blue, alpha, light, overlay);
+							renderPoint(matrix4f, normal, buffer, face, u, v, other, uv, xyz, false, false, red, green, blue, alpha, light, overlay);
+
+							renderPoint(matrix4f, normal, buffer, opposite, u, v, other, uv, xyz, false, false, red, green, blue, alpha, light, overlay);
+							renderPoint(matrix4f, normal, buffer, opposite, u, v, other, uv, xyz, false, true, red, green, blue, alpha, light, overlay);
+							renderPoint(matrix4f, normal, buffer, opposite, u, v, other, uv, xyz, true, true, red, green, blue, alpha, light, overlay);
+							renderPoint(matrix4f, normal, buffer, opposite, u, v, other, uv, xyz, true, false, red, green, blue, alpha, light, overlay);
+						}
+					}
+				}
+			}
+		}
+		matrix.pop();
+	}
+
+	private void renderPoint(Matrix4f matrix4f, Matrix3f normal, IVertexBuilder buffer, Direction face, Axis u, Axis v,
+			float other, float[] uv, float[] xyz, boolean minU, boolean minV, float red, float green, float blue,
+			float alpha, int light, int overlay)
+	{
+		int U_ARRAY = minU ? U_MIN : U_MAX;
+		int V_ARRAY = minV ? V_MIN : V_MAX;
+		Vector3f vertex = withValue(VEC_ZERO, u, xyz[U_ARRAY]);
+		vertex = withValue(vertex, v, xyz[V_ARRAY]);
+		vertex = withValue(vertex, face.getAxis(), other);
+		Vector3i normalForFace = face.getDirectionVec();
+		// TODO: Figure out how and why this works, it gives about the same brightness
+		// as we used to have but I don't understand why/how
+		float adjustment = 2.5F;
+		Vector3f norm = new Vector3f(normalForFace.getX() + adjustment, normalForFace.getY()
+				+ adjustment, normalForFace.getZ() + adjustment);
+		norm.normalize();
+		buffer.pos(matrix4f, vertex.getX(), vertex.getY(), vertex.getZ()).color(red, green, blue, alpha).tex(uv[U_ARRAY], uv[V_ARRAY]).overlay(overlay).lightmap(light).normal(normal, norm.getX(), norm.getY(), norm.getZ()).endVertex();
+	}
+}

src/main/java/wayoftime/bloodmagic/client/render/RenderResizableQuadrilateral.java

@@ -0,0 +1,167 @@
+package wayoftime.bloodmagic.client.render;
+
+import java.util.Arrays;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.blaze3d.vertex.IVertexBuilder;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.entity.EntityRendererManager;
+import net.minecraft.util.Direction;
+import net.minecraft.util.Direction.Axis;
+import net.minecraft.util.Direction.AxisDirection;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.vector.Matrix3f;
+import net.minecraft.util.math.vector.Matrix4f;
+import net.minecraft.util.math.vector.Vector3d;
+import net.minecraft.util.math.vector.Vector3f;
+import net.minecraft.util.math.vector.Vector3i;
+import wayoftime.bloodmagic.client.render.BloodMagicRenderer.Model2D;
+
+public class RenderResizableQuadrilateral
+{
+	public static final RenderResizableQuadrilateral INSTANCE = new RenderResizableQuadrilateral();
+	private static final Vector3f VEC_ZERO = new Vector3f(0, 0, 0);
+	private static final int U_MIN = 0;
+	private static final int U_MAX = 1;
+	private static final int V_MIN = 2;
+	private static final int V_MAX = 3;
+
+	protected EntityRendererManager manager = Minecraft.getInstance().getRenderManager();
+
+	private static Vector3f withValue(Vector3f vector, Axis axis, float value)
+	{
+		if (axis == Axis.X)
+		{
+			return new Vector3f(value, vector.getY(), vector.getZ());
+		} else if (axis == Axis.Y)
+		{
+			return new Vector3f(vector.getX(), value, vector.getZ());
+		} else if (axis == Axis.Z)
+		{
+			return new Vector3f(vector.getX(), vector.getY(), value);
+		}
+		throw new RuntimeException("Was given a null axis! That was probably not intentional, consider this a bug! (Vector = "
+				+ vector + ")");
+	}
+
+	public static double getValue(Vector3d vector, Axis axis)
+	{
+		if (axis == Axis.X)
+		{
+			return vector.x;
+		} else if (axis == Axis.Y)
+		{
+			return vector.y;
+		} else if (axis == Axis.Z)
+		{
+			return vector.z;
+		}
+		throw new RuntimeException("Was given a null axis! That was probably not intentional, consider this a bug! (Vector = "
+				+ vector + ")");
+	}
+
+	public void renderSquare(Model2D square, MatrixStack matrix, IVertexBuilder buffer, int argb, int light, int overlay)
+	{
+		float red = BloodMagicRenderer.getRed(argb);
+		float green = BloodMagicRenderer.getGreen(argb);
+		float blue = BloodMagicRenderer.getBlue(argb);
+		float alpha = BloodMagicRenderer.getAlpha(argb);
+		Vector3d size = new Vector3d(square.sizeX(), 0, square.sizeY());
+		matrix.push();
+		matrix.translate(square.minX, 0, square.minY);
+		MatrixStack.Entry lastMatrix = matrix.getLast();
+		Matrix4f matrix4f = lastMatrix.getMatrix();
+		Matrix3f normal = lastMatrix.getNormal();
+		Direction face = Direction.UP;
+//		for (Direction face : Direction.values())
+
+		int ordinal = face.ordinal();
+//				TextureAtlasSprite sprite = cube.textures[ordinal];
+		ResourceLocation rl = square.resource;
+		if (rl != null)
+		{
+//					Minecraft.getInstance().textureManager.bindTexture(rl);
+			Axis u = face.getAxis() == Axis.X ? Axis.Z : Axis.X;
+			Axis v = face.getAxis() == Axis.Y ? Axis.Z : Axis.Y;
+			float other = face.getAxisDirection() == AxisDirection.POSITIVE ? (float) getValue(size, face.getAxis())
+					: 0;
+
+			// Swap the face if this is positive: the renderer returns indexes that ALWAYS
+			// are for the negative face, so light it properly this way
+			face = face.getAxisDirection() == AxisDirection.NEGATIVE ? face : face.getOpposite();
+//			Direction opposite = face.getOpposite();
+
+			float minU = 0;
+			float maxU = 1;
+			// Flip the v
+			float minV = 1;
+			float maxV = 0;
+//					float minU = sprite.getMinU();
+//					float maxU = sprite.getMaxU();
+//					// Flip the v
+//					float minV = sprite.getMaxV();
+//					float maxV = sprite.getMinV();
+			double sizeU = getValue(size, u);
+			double sizeV = getValue(size, v);
+			// TODO: Look into this more, as it makes tiling of multiple objects not render
+			// properly if they don't fit the full texture.
+			// Example: Mechanical pipes rendering water or lava, makes it relatively easy
+			// to see the texture artifacts
+			for (int uIndex = 0; uIndex < sizeU; uIndex++)
+			{
+				float[] baseUV = new float[]
+				{ minU, maxU, minV, maxV };
+				double addU = 1;
+				// If the size of the texture is greater than the cuboid goes on for then make
+				// sure the texture positions are lowered
+				if (uIndex + addU > sizeU)
+				{
+//					addU = sizeU - uIndex;
+					baseUV[U_MAX] = baseUV[U_MIN] + (baseUV[U_MAX] - baseUV[U_MIN]) * (float) addU;
+				}
+				for (int vIndex = 0; vIndex < sizeV; vIndex++)
+				{
+					float[] uv = Arrays.copyOf(baseUV, 4);
+					double addV = 1;
+					if (vIndex + addV > sizeV)
+					{
+//						addV = sizeV - vIndex;
+						uv[V_MAX] = uv[V_MIN] + (uv[V_MAX] - uv[V_MIN]) * (float) addV;
+					}
+					float[] xyz = new float[]
+					{ uIndex, (float) (uIndex + addU), vIndex, (float) (vIndex + addV) };
+
+					renderPoint(matrix4f, normal, buffer, face, u, v, other, uv, xyz, true, false, red, green, blue, alpha, light, overlay);
+					renderPoint(matrix4f, normal, buffer, face, u, v, other, uv, xyz, true, true, red, green, blue, alpha, light, overlay);
+					renderPoint(matrix4f, normal, buffer, face, u, v, other, uv, xyz, false, true, red, green, blue, alpha, light, overlay);
+					renderPoint(matrix4f, normal, buffer, face, u, v, other, uv, xyz, false, false, red, green, blue, alpha, light, overlay);
+
+//					renderPoint(matrix4f, normal, buffer, opposite, u, v, other, uv, xyz, false, false, red, green, blue, alpha, light, overlay);
+//					renderPoint(matrix4f, normal, buffer, opposite, u, v, other, uv, xyz, false, true, red, green, blue, alpha, light, overlay);
+//					renderPoint(matrix4f, normal, buffer, opposite, u, v, other, uv, xyz, true, true, red, green, blue, alpha, light, overlay);
+//					renderPoint(matrix4f, normal, buffer, opposite, u, v, other, uv, xyz, true, false, red, green, blue, alpha, light, overlay);
+				}
+
+			}
+		}
+		matrix.pop();
+	}
+
+	private void renderPoint(Matrix4f matrix4f, Matrix3f normal, IVertexBuilder buffer, Direction face, Axis u, Axis v, float other, float[] uv, float[] xyz, boolean minU, boolean minV, float red, float green, float blue, float alpha, int light, int overlay)
+	{
+		int U_ARRAY = minU ? U_MIN : U_MAX;
+		int V_ARRAY = minV ? V_MIN : V_MAX;
+		Vector3f vertex = withValue(VEC_ZERO, u, xyz[U_ARRAY]);
+		vertex = withValue(vertex, v, xyz[V_ARRAY]);
+		vertex = withValue(vertex, face.getAxis(), other);
+		Vector3i normalForFace = face.getDirectionVec();
+		// TODO: Figure out how and why this works, it gives about the same brightness
+		// as we used to have but I don't understand why/how
+		float adjustment = 2.5F;
+		Vector3f norm = new Vector3f(normalForFace.getX() + adjustment, normalForFace.getY()
+				+ adjustment, normalForFace.getZ() + adjustment);
+		norm.normalize();
+		buffer.pos(matrix4f, vertex.getX(), vertex.getY(), vertex.getZ()).color(red, green, blue, alpha).tex(uv[U_ARRAY], uv[V_ARRAY]).overlay(overlay).lightmap(light).normal(normal, norm.getX(), norm.getY(), norm.getZ()).endVertex();
+	}
+}

src/main/java/wayoftime/bloodmagic/client/render/alchemyarray/AlchemyArrayRenderer.java

@@ -0,0 +1,114 @@
+package wayoftime.bloodmagic.client.render.alchemyarray;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.blaze3d.vertex.IVertexBuilder;
+
+import net.minecraft.client.renderer.IRenderTypeBuffer;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.util.Direction;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.vector.Quaternion;
+import wayoftime.bloodmagic.client.render.BloodMagicRenderer;
+import wayoftime.bloodmagic.client.render.BloodMagicRenderer.Model2D;
+import wayoftime.bloodmagic.client.render.RenderResizableQuadrilateral;
+import wayoftime.bloodmagic.tile.TileAlchemyArray;
+
+public class AlchemyArrayRenderer
+{
+	public final ResourceLocation arrayResource;
+
+	public AlchemyArrayRenderer()
+	{
+		this(new ResourceLocation("bloodmagic", "textures/models/alchemyarrays/sightsigil.png"));
+	}
+
+	public AlchemyArrayRenderer(ResourceLocation arrayResource)
+	{
+		this.arrayResource = arrayResource;
+	}
+
+	public float getRotation(float craftTime)
+	{
+		float offset = 2;
+		if (craftTime >= offset)
+		{
+			float modifier = (float) Math.pow(craftTime - offset, 1.5);
+			return modifier * 1f;
+		}
+		return 0;
+	}
+
+	public float getSecondaryRotation(float craftTime)
+	{
+		float offset = 50;
+		if (craftTime >= offset)
+		{
+			float modifier = (float) Math.pow(craftTime - offset, 1.7);
+			return modifier * 0.5f;
+		}
+		return 0;
+	}
+
+	public float getSizeModifier(float craftTime)
+	{
+		if (craftTime >= 150 && craftTime <= 250)
+		{
+			return (200 - craftTime) / 50f;
+		}
+		return 1.0f;
+	}
+
+	public float getVerticalOffset(float craftTime)
+	{
+		if (craftTime >= 5)
+		{
+			if (craftTime <= 40)
+			{
+				return (float) (-0.4 + (0.4) * Math.pow((craftTime - 5) / 35f, 3));
+			} else
+			{
+				return 0;
+			}
+		}
+		return -0.4f;
+	}
+
+	public void renderAt(TileAlchemyArray tileArray, double x, double y, double z, float craftTime, MatrixStack matrixStack, IRenderTypeBuffer renderer, int combinedLightIn, int combinedOverlayIn)
+	{
+		matrixStack.push();
+
+		matrixStack.translate(0.5, 0.5, 0.5);
+
+		float rot = getRotation(craftTime);
+		float secondaryRot = getSecondaryRotation(craftTime);
+
+		float size = 1.0F * getSizeModifier(craftTime);
+		Direction rotation = tileArray.getRotation();
+
+		matrixStack.push();
+		matrixStack.translate(0, getVerticalOffset(craftTime), 0);
+		matrixStack.rotate(new Quaternion(Direction.UP.toVector3f(), -rotation.getHorizontalAngle(), true));
+
+		matrixStack.push();
+
+		matrixStack.rotate(new Quaternion(Direction.UP.toVector3f(), rot, true));
+		matrixStack.rotate(new Quaternion(Direction.NORTH.toVector3f(), secondaryRot, true));
+		matrixStack.rotate(new Quaternion(Direction.EAST.toVector3f(), secondaryRot * 0.45812f, true));
+
+		IVertexBuilder twoDBuffer = renderer.getBuffer(RenderType.getEntityTranslucent(arrayResource));
+		Model2D arrayModel = new BloodMagicRenderer.Model2D();
+		arrayModel.minX = -0.5;
+		arrayModel.maxX = +0.5;
+		arrayModel.minY = -0.5;
+		arrayModel.maxY = +0.5;
+		arrayModel.resource = arrayResource;
+
+		matrixStack.scale(size, size, size);
+
+		RenderResizableQuadrilateral.INSTANCE.renderSquare(arrayModel, matrixStack, twoDBuffer, 0xFFFFFFFF, combinedLightIn, combinedOverlayIn);
+
+		matrixStack.pop();
+		matrixStack.pop();
+		matrixStack.pop();
+	}
+}

src/main/java/wayoftime/bloodmagic/client/render/block/RenderAlchemyArray.java

@@ -0,0 +1,43 @@
+package wayoftime.bloodmagic.client.render.block;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+
+import net.minecraft.client.renderer.IRenderTypeBuffer;
+import net.minecraft.client.renderer.tileentity.TileEntityRenderer;
+import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher;
+import net.minecraft.item.ItemStack;
+import wayoftime.bloodmagic.client.render.alchemyarray.AlchemyArrayRenderer;
+import wayoftime.bloodmagic.core.registry.AlchemyArrayRendererRegistry;
+import wayoftime.bloodmagic.tile.TileAlchemyArray;
+
+public class RenderAlchemyArray extends TileEntityRenderer<TileAlchemyArray>
+{
+	public static final AlchemyArrayRenderer arrayRenderer = new AlchemyArrayRenderer();
+
+	public RenderAlchemyArray(TileEntityRendererDispatcher rendererDispatcherIn)
+	{
+		super(rendererDispatcherIn);
+	}
+
+	@Override
+	public void render(TileAlchemyArray tileArray, float partialTicks, MatrixStack matrixStack, IRenderTypeBuffer buffer, int combinedLightIn, int combinedOverlayIn)
+	{
+		ItemStack inputStack = tileArray.getStackInSlot(0);
+		ItemStack catalystStack = tileArray.getStackInSlot(1);
+//		arrayRenderer.renderAt(tileArray, 0, 0, 0, tileArray.activeCounter
+//				+ partialTicks, matrixStack, buffer, combinedLightIn, combinedOverlayIn);
+
+		AlchemyArrayRenderer renderer = AlchemyArrayRendererRegistry.getRenderer(tileArray.getWorld(), inputStack, catalystStack);
+		if (renderer == null)
+		{
+			renderer = AlchemyArrayRendererRegistry.DEFAULT_RENDERER;
+		}
+
+		renderer.renderAt(tileArray, 0, 0, 0, tileArray.activeCounter
+				+ partialTicks, matrixStack, buffer, combinedLightIn, combinedOverlayIn);
+//		arrayRenderer.renderAt(tileArray, 0, 0, 0, 0, matrixStack, buffer, combinedLightIn, combinedOverlayIn);
+
+//		if (tileAltar.getCurrentTierDisplayed() != AltarTier.ONE)
+//			renderHologram(tileAltar, tileAltar.getCurrentTierDisplayed(), partialTicks);
+	}
+}

src/main/java/wayoftime/bloodmagic/client/render/block/RenderAltar.java

@@ -0,0 +1,279 @@
+package wayoftime.bloodmagic.client.render.block;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.blaze3d.vertex.IVertexBuilder;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.Atlases;
+import net.minecraft.client.renderer.IRenderTypeBuffer;
+import net.minecraft.client.renderer.ItemRenderer;
+import net.minecraft.client.renderer.RenderHelper;
+import net.minecraft.client.renderer.model.IBakedModel;
+import net.minecraft.client.renderer.model.ItemCameraTransforms;
+import net.minecraft.client.renderer.texture.AtlasTexture;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.client.renderer.tileentity.TileEntityRenderer;
+import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.fluid.Fluid;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.vector.Vector3f;
+import net.minecraftforge.fluids.FluidStack;
+import wayoftime.bloodmagic.client.render.BloodMagicRenderer;
+import wayoftime.bloodmagic.client.render.BloodMagicRenderer.Model3D;
+import wayoftime.bloodmagic.client.render.RenderResizableCuboid;
+import wayoftime.bloodmagic.common.block.BloodMagicBlocks;
+import wayoftime.bloodmagic.tile.TileAltar;
+
+public class RenderAltar extends TileEntityRenderer<TileAltar>
+{
+	public RenderAltar(TileEntityRendererDispatcher rendererDispatcherIn)
+	{
+		super(rendererDispatcherIn);
+	}
+
+	private static final float MIN_HEIGHT = 0.499f;
+	private static final float MAX_HEIGHT = 0.745f;
+
+	@Override
+	public void render(TileAltar tileAltar, float partialTicks, MatrixStack matrixStack, IRenderTypeBuffer buffer, int combinedLightIn, int combinedOverlayIn)
+	{
+		ItemStack inputStack = tileAltar.getStackInSlot(0);
+
+		float level = ((float) tileAltar.getCurrentBlood()) / (float) tileAltar.getCapacity();
+
+		this.renderItem(inputStack, tileAltar, matrixStack, buffer, combinedLightIn, combinedOverlayIn);
+
+		renderFluid(level, matrixStack, buffer, combinedLightIn, combinedOverlayIn);
+
+//		if (tileAltar.getCurrentTierDisplayed() != AltarTier.ONE)
+//			renderHologram(tileAltar, tileAltar.getCurrentTierDisplayed(), partialTicks);
+	}
+
+	private void renderFluid(float fluidLevel, MatrixStack matrixStack, IRenderTypeBuffer renderer, int combinedLightIn, int combinedOverlayIn)
+	{
+		Fluid fluid = BloodMagicBlocks.LIFE_ESSENCE_FLUID.get();
+		FluidStack fluidStack = new FluidStack(fluid, 1000);
+
+		FluidRenderData data = new FluidRenderData(fluidStack);
+		matrixStack.push();
+
+		Model3D model = getFluidModel(fluidLevel, data);
+		IVertexBuilder buffer = renderer.getBuffer(Atlases.getTranslucentCullBlockType());
+
+//		matrixStack.translate(data.loca, y, z);
+//		int glow = data.calculateGlowLight(0);
+		RenderResizableCuboid.INSTANCE.renderCube(model, matrixStack, buffer, data.getColorARGB(1), combinedLightIn, combinedOverlayIn);
+
+		matrixStack.pop();
+	}
+
+	public float getRotation(float craftTime)
+	{
+		float offset = 2;
+		if (craftTime >= offset)
+		{
+			float modifier = (float) Math.pow(craftTime - offset, 1.5);
+			return modifier * 1f;
+		}
+		return 0;
+	}
+
+	public float getSecondaryRotation(float craftTime)
+	{
+		float offset = 50;
+		if (craftTime >= offset)
+		{
+			float modifier = (float) Math.pow(craftTime - offset, 1.7);
+			return modifier * 0.5f;
+		}
+		return 0;
+	}
+
+	public float getSizeModifier(float craftTime)
+	{
+		if (craftTime >= 150 && craftTime <= 250)
+		{
+			return (200 - craftTime) / 50f;
+		}
+		return 1.0f;
+	}
+
+	public float getVerticalOffset(float craftTime)
+	{
+		if (craftTime >= 5)
+		{
+			if (craftTime <= 40)
+			{
+				return (float) ((-0.4) * Math.pow((craftTime - 5) / 35f, 3));
+			} else
+			{
+				return -0.4f;
+			}
+		}
+		return 0;
+	}
+
+	private void renderItem(ItemStack stack, TileAltar tileAltar, MatrixStack matrixStack, IRenderTypeBuffer buffer, int combinedLightIn, int combinedOverlayIn)
+	{
+		matrixStack.push();
+		Minecraft mc = Minecraft.getInstance();
+		ItemRenderer itemRenderer = mc.getItemRenderer();
+		if (!stack.isEmpty())
+		{
+			matrixStack.translate(0.5, 1, 0.5);
+			matrixStack.push();
+
+			float rotation = (float) (720.0 * (System.currentTimeMillis() & 0x3FFFL) / 0x3FFFL);
+
+			matrixStack.rotate(Vector3f.YP.rotationDegrees(rotation));
+			matrixStack.scale(0.5F, 0.5F, 0.5F);
+			RenderHelper.enableStandardItemLighting();
+			IBakedModel ibakedmodel = itemRenderer.getItemModelWithOverrides(stack, tileAltar.getWorld(), (LivingEntity) null);
+			itemRenderer.renderItem(stack, ItemCameraTransforms.TransformType.FIXED, true, matrixStack, buffer, combinedLightIn, combinedOverlayIn, ibakedmodel); // renderItem
+			RenderHelper.disableStandardItemLighting();
+
+			matrixStack.pop();
+		}
+
+		matrixStack.pop();
+	}
+
+	private Model3D getFluidModel(float fluidLevel, FluidRenderData data)
+	{
+		Model3D model = new BloodMagicRenderer.Model3D();
+		model.setTexture(data.getTexture());
+		model.minX = 0.1;
+		model.minY = MIN_HEIGHT;
+		model.minZ = 0.1;
+		model.maxX = 0.9;
+		model.maxY = (MAX_HEIGHT - MIN_HEIGHT) * fluidLevel + MIN_HEIGHT;
+		model.maxZ = 0.9;
+
+		return model;
+	}
+
+	public class FluidRenderData
+	{
+		public BlockPos location;
+
+		public int height;
+		public int length;
+		public int width;
+
+		public final FluidStack fluidType;
+
+		public FluidRenderData(FluidStack fluidType)
+		{
+			this.fluidType = fluidType;
+		}
+
+		public TextureAtlasSprite getTexture()
+		{
+			return Minecraft.getInstance().getAtlasSpriteGetter(AtlasTexture.LOCATION_BLOCKS_TEXTURE).apply(fluidType.getFluid().getAttributes().getStillTexture());
+		}
+
+		public boolean isGaseous()
+		{
+			return fluidType.getFluid().getAttributes().isGaseous(fluidType);
+		}
+
+		public int getColorARGB(float scale)
+		{
+			return fluidType.getFluid().getAttributes().getColor(fluidType);
+		}
+
+		public int calculateGlowLight(int light)
+		{
+			return light;
+		}
+
+		@Override
+		public int hashCode()
+		{
+			int code = super.hashCode();
+			code = 31 * code + fluidType.getFluid().getRegistryName().hashCode();
+			if (fluidType.hasTag())
+			{
+				code = 31 * code + fluidType.getTag().hashCode();
+			}
+			return code;
+		}
+
+		@Override
+		public boolean equals(Object data)
+		{
+			return super.equals(data) && data instanceof FluidRenderData
+					&& fluidType.isFluidEqual(((FluidRenderData) data).fluidType);
+		}
+	}
+//
+//	private void renderHologram(TileAltar altar, AltarTier tier, float partialTicks)
+//	{
+//		EntityPlayerSP player = Minecraft.getMinecraft().player;
+//		World world = player.world;
+//
+//		if (tier == AltarTier.ONE)
+//			return;
+//
+//		GlStateManager.pushMatrix();
+//		GlStateManager.enableBlend();
+//		GlStateManager.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+//		GlStateManager.color(1F, 1F, 1F, 0.6125F);
+//
+//		BlockPos vec3, vX;
+//		vec3 = altar.getPos();
+//		double posX = player.lastTickPosX + (player.posX - player.lastTickPosX) * partialTicks;
+//		double posY = player.lastTickPosY + (player.posY - player.lastTickPosY) * partialTicks;
+//		double posZ = player.lastTickPosZ + (player.posZ - player.lastTickPosZ) * partialTicks;
+//
+//		for (AltarComponent altarComponent : tier.getAltarComponents())
+//		{
+//			vX = vec3.add(altarComponent.getOffset());
+//			double minX = vX.getX() - posX;
+//			double minY = vX.getY() - posY;
+//			double minZ = vX.getZ() - posZ;
+//
+//			if (!world.getBlockState(vX).isOpaqueCube())
+//			{
+//				TextureAtlasSprite texture = null;
+//
+//				switch (altarComponent.getComponent())
+//				{
+//				case BLOODRUNE:
+//					texture = ClientHandler.blankBloodRune;
+//					break;
+//				case NOTAIR:
+//					texture = ClientHandler.stoneBrick;
+//					break;
+//				case GLOWSTONE:
+//					texture = ClientHandler.glowstone;
+//					break;
+//				case BLOODSTONE:
+//					texture = ClientHandler.bloodStoneBrick;
+//					break;
+//				case BEACON:
+//					texture = ClientHandler.beacon;
+//					break;
+//				case CRYSTAL:
+//					texture = ClientHandler.crystalCluster;
+//					break;
+//				}
+//
+//				RenderFakeBlocks.drawFakeBlock(texture, minX, minY, minZ);
+//			}
+//		}
+//
+//		GlStateManager.popMatrix();
+//	}
+
+//	private static void setGLColorFromInt(int color)
+//	{
+//		float red = (color >> 16 & 0xFF) / 255.0F;
+//		float green = (color >> 8 & 0xFF) / 255.0F;
+//		float blue = (color & 0xFF) / 255.0F;
+//
+//		GlStateManager.color(red, green, blue, 1.0F);
+//	}
+}

src/main/java/wayoftime/bloodmagic/client/render/block/RenderFakeBlocks.java

@@ -0,0 +1,66 @@
+package wayoftime.bloodmagic.client.render.block;
+
+import org.lwjgl.opengl.GL11;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.texture.AtlasTexture;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+
+public class RenderFakeBlocks
+{
+	public static void drawFakeBlock(TextureAtlasSprite texture, double minX, double minY, double minZ)
+	{
+		if (texture == null)
+			return;
+
+		double maxX = minX + 1;
+		double maxY = minY + 1;
+		double maxZ = minZ + 1;
+		Tessellator tessellator = Tessellator.getInstance();
+		BufferBuilder wr = tessellator.getBuffer();
+
+		Minecraft.getInstance().getAtlasSpriteGetter(AtlasTexture.LOCATION_BLOCKS_TEXTURE).apply(texture.getName());
+
+		wr.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX);
+
+		float texMinU = texture.getMinU();
+		float texMinV = texture.getMinV();
+		float texMaxU = texture.getMaxU();
+		float texMaxV = texture.getMaxV();
+
+		wr.pos(minX, minY, minZ).tex(texMinU, texMinV).endVertex();
+		wr.pos(maxX, minY, minZ).tex(texMaxU, texMinV).endVertex();
+		wr.pos(maxX, minY, maxZ).tex(texMaxU, texMaxV).endVertex();
+		wr.pos(minX, minY, maxZ).tex(texMinU, texMaxV).endVertex();
+
+		wr.pos(minX, maxY, maxZ).tex(texMinU, texMaxV).endVertex();
+		wr.pos(maxX, maxY, maxZ).tex(texMaxU, texMaxV).endVertex();
+		wr.pos(maxX, maxY, minZ).tex(texMaxU, texMinV).endVertex();
+		wr.pos(minX, maxY, minZ).tex(texMinU, texMinV).endVertex();
+
+		wr.pos(maxX, minY, minZ).tex(texMinU, texMaxV).endVertex();
+		wr.pos(minX, minY, minZ).tex(texMaxU, texMaxV).endVertex();
+		wr.pos(minX, maxY, minZ).tex(texMaxU, texMinV).endVertex();
+		wr.pos(maxX, maxY, minZ).tex(texMinU, texMinV).endVertex();
+
+		wr.pos(minX, minY, maxZ).tex(texMinU, texMaxV).endVertex();
+		wr.pos(maxX, minY, maxZ).tex(texMaxU, texMaxV).endVertex();
+		wr.pos(maxX, maxY, maxZ).tex(texMaxU, texMinV).endVertex();
+		wr.pos(minX, maxY, maxZ).tex(texMinU, texMinV).endVertex();
+
+		wr.pos(minX, minY, minZ).tex(texMinU, texMaxV).endVertex();
+		wr.pos(minX, minY, maxZ).tex(texMaxU, texMaxV).endVertex();
+		wr.pos(minX, maxY, maxZ).tex(texMaxU, texMinV).endVertex();
+		wr.pos(minX, maxY, minZ).tex(texMinU, texMinV).endVertex();
+
+		wr.pos(maxX, minY, maxZ).tex(texMinU, texMaxV).endVertex();
+		wr.pos(maxX, minY, minZ).tex(texMaxU, texMaxV).endVertex();
+		wr.pos(maxX, maxY, minZ).tex(texMaxU, texMinV).endVertex();
+		wr.pos(maxX, maxY, maxZ).tex(texMinU, texMinV).endVertex();
+
+		tessellator.draw();
+	}
+}

src/main/java/wayoftime/bloodmagic/client/render/entity/BloodLightRenderer.java

@@ -0,0 +1,24 @@
+package wayoftime.bloodmagic.client.render.entity;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.IRenderTypeBuffer;
+import net.minecraft.client.renderer.entity.EntityRendererManager;
+import net.minecraft.client.renderer.entity.SpriteRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.IRendersAsItem;
+
+public class BloodLightRenderer<T extends Entity & IRendersAsItem> extends SpriteRenderer<T>
+{
+	public BloodLightRenderer(EntityRendererManager renderManagerIn)
+	{
+		super(renderManagerIn, Minecraft.getInstance().getItemRenderer());
+	}
+
+	@Override
+	public void render(T entityIn, float entityYaw, float partialTicks, MatrixStack matrixStackIn, IRenderTypeBuffer bufferIn, int packedLightIn)
+	{
+		super.render(entityIn, entityYaw, partialTicks, matrixStackIn, bufferIn, packedLightIn);
+	}
+}

src/main/java/wayoftime/bloodmagic/client/render/entity/SoulSnareRenderer.java

@@ -0,0 +1,24 @@
+package wayoftime.bloodmagic.client.render.entity;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.IRenderTypeBuffer;
+import net.minecraft.client.renderer.entity.EntityRendererManager;
+import net.minecraft.client.renderer.entity.SpriteRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.IRendersAsItem;
+
+public class SoulSnareRenderer<T extends Entity & IRendersAsItem> extends SpriteRenderer<T>
+{
+	public SoulSnareRenderer(EntityRendererManager renderManagerIn)
+	{
+		super(renderManagerIn, Minecraft.getInstance().getItemRenderer());
+	}
+
+	@Override
+	public void render(T entityIn, float entityYaw, float partialTicks, MatrixStack matrixStackIn, IRenderTypeBuffer bufferIn, int packedLightIn)
+	{
+		super.render(entityIn, entityYaw, partialTicks, matrixStackIn, bufferIn, packedLightIn);
+	}
+}

src/main/java/wayoftime/bloodmagic/client/screens/ScreenAlchemicalReactionChamber.java

@@ -0,0 +1,107 @@
+package wayoftime.bloodmagic.client.screens;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.blaze3d.systems.RenderSystem;
+
+import net.minecraft.entity.player.PlayerInventory;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TranslationTextComponent;
+import net.minecraftforge.fml.client.gui.GuiUtils;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.tile.TileAlchemicalReactionChamber;
+import wayoftime.bloodmagic.tile.contailer.ContainerAlchemicalReactionChamber;
+import wayoftime.bloodmagic.util.handler.event.ClientHandler;
+
+public class ScreenAlchemicalReactionChamber extends ScreenBase<ContainerAlchemicalReactionChamber>
+{
+	private static final ResourceLocation background = new ResourceLocation(BloodMagic.MODID, "textures/gui/arc_gui.png");
+	public TileAlchemicalReactionChamber tileARC;
+
+	public ScreenAlchemicalReactionChamber(ContainerAlchemicalReactionChamber container, PlayerInventory playerInventory, ITextComponent title)
+	{
+		super(container, playerInventory, title);
+		tileARC = container.tileARC;
+		this.xSize = 176;
+		this.ySize = 205;
+	}
+
+	@Override
+	public ResourceLocation getBackground()
+	{
+		return background;
+	}
+
+//	public 
+
+//	public ScreenSoulForge(InventoryPlayer playerInventory, IInventory tileSoulForge)
+//	{
+//		super(new ContainerSoulForge(playerInventory, tileSoulForge));
+//		this.tileSoulForge = tileSoulForge;
+//		this.xSize = 176;
+//		this.ySize = 205;
+//	}
+//
+	@Override
+	public void render(MatrixStack stack, int mouseX, int mouseY, float partialTicks)
+	{
+		super.render(stack, mouseX, mouseY, partialTicks);
+		List<ITextComponent> tooltip = new ArrayList<>();
+//		FluidTank inputTank = new FluidTank(FluidAttributes.BUCKET_VOLUME * 2);
+//		inputTank.fill(new FluidStack(Fluids.WATER, 1000), FluidAction.EXECUTE);
+
+		ClientHandler.handleGuiTank(stack, tileARC.inputTank, this.guiLeft + 8, this.guiTop
+				+ 40, 16, 63, 194, 1, 16, 63, mouseX, mouseY, background.toString(), tooltip);
+		ClientHandler.handleGuiTank(stack, tileARC.outputTank, this.guiLeft + 152, this.guiTop
+				+ 15, 16, 63, 194, 1, 16, 63, mouseX, mouseY, background.toString(), tooltip);
+
+		if (!tooltip.isEmpty())
+			GuiUtils.drawHoveringText(stack, tooltip, mouseX, mouseY, width, height, -1, font);
+	}
+
+//
+	@Override
+	protected void drawGuiContainerForegroundLayer(MatrixStack stack, int mouseX, int mouseY)
+	{
+		this.font.func_243248_b(stack, new TranslationTextComponent("tile.bloodmagic.arc.name"), 8, 5, 4210752);
+		this.font.func_243248_b(stack, new TranslationTextComponent("container.inventory"), 8, 111, 4210752);
+	}
+
+//
+	@Override
+	protected void drawGuiContainerBackgroundLayer(MatrixStack stack, float partialTicks, int mouseX, int mouseY)
+	{
+		RenderSystem.color4f(1.0F, 1.0F, 1.0F, 1.0F);
+		getMinecraft().getTextureManager().bindTexture(background);
+		int i = (this.width - this.xSize) / 2;
+		int j = (this.height - this.ySize) / 2;
+		this.blit(stack, i, j, 0, 0, this.xSize, this.ySize);
+
+//		FluidTank inputTank = new FluidTank(FluidAttributes.BUCKET_VOLUME * 2);
+//		inputTank.fill(new FluidStack(Fluids.WATER, 1000), FluidAction.EXECUTE);
+
+		ClientHandler.handleGuiTank(stack, tileARC.inputTank, this.guiLeft + 8, this.guiTop
+				+ 40, 16, 63, 194, 1, 16, 63, mouseX, mouseY, background.toString(), null);
+		ClientHandler.handleGuiTank(stack, tileARC.outputTank, this.guiLeft + 152, this.guiTop
+				+ 15, 16, 63, 194, 1, 16, 63, mouseX, mouseY, background.toString(), null);
+
+//		int l = this.getCookProgressScaled(90);
+//		this.blit(stack, i + 115, j + 14 + 90 - l, 176, 90 - l, 18, l);
+	}
+
+////
+//	public int getCookProgressScaled(int scale)
+//	{
+//		double progress = ((TileSoulForge) tileSoulForge).getProgressForGui();
+////		if (tileSoulForge != null)
+////		{
+////			System.out.println("Tile is NOT null");
+////		}
+////		double progress = ((float) this.container.data.get(0)) / ((float) this.container.data.get(1));
+////		System.out.println(this.container.data.get(0));
+//		return (int) (progress * scale);
+//	}
+}

src/main/java/wayoftime/bloodmagic/client/screens/ScreenBase.java

@@ -0,0 +1,68 @@
+package wayoftime.bloodmagic.client.screens;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+
+import net.minecraft.client.gui.screen.inventory.ContainerScreen;
+import net.minecraft.entity.player.PlayerInventory;
+import net.minecraft.inventory.container.Container;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TranslationTextComponent;
+import wayoftime.bloodmagic.BloodMagic;
+
+public abstract class ScreenBase<T extends Container> extends ContainerScreen<T>
+{
+	private static final ResourceLocation background = new ResourceLocation(BloodMagic.MODID, "textures/gui/soulforge.png");
+
+	protected final T container;
+
+	public ScreenBase(T container, PlayerInventory playerInventory, ITextComponent title)
+	{
+		super(container, playerInventory, title);
+		this.container = container;
+	}
+
+	public ResourceLocation getBackground()
+	{
+		return background;
+	}
+
+	@Override
+	public void render(MatrixStack stack, int mouseX, int mouseY, float partialTicks)
+	{
+		this.renderBackground(stack);
+		super.render(stack, mouseX, mouseY, partialTicks);
+
+		this.renderHoveredTooltip(stack, mouseX, mouseY); // @mcp: func_230459_a_ = renderHoveredToolTip
+//		if (mouseX > (guiLeft + 7) && mouseX < (guiLeft + 7) + 18 && mouseY > (guiTop + 7)
+//				&& mouseY < (guiTop + 7) + 73)
+//			this.renderTooltip(stack, LanguageMap.getInstance().func_244260_a(Arrays.asList(new TranslationTextComponent("screen.diregoo.energy", MagicHelpers.withSuffix(this.container.getEnergy()), MagicHelpers.withSuffix(this.container.getMaxPower())))), mouseX, mouseY);
+	}
+
+	@Override
+	public void init()
+	{
+		super.init();
+	}
+
+	@Override
+	protected void drawGuiContainerBackgroundLayer(MatrixStack stack, float partialTicks, int mouseX, int mouseY)
+	{
+//		RenderSystem.color4f(1, 1, 1, 1);
+//		getMinecraft().getTextureManager().bindTexture(getBackground());
+//		this.blit(stack, guiLeft, guiTop, 0, 0, xSize, ySize);
+
+//		int maxEnergy = this.container.getMaxPower(), height = 70;
+//		if (maxEnergy > 0)
+//		{
+//			int remaining = (this.container.getEnergy() * height) / maxEnergy;
+//			this.blit(stack, guiLeft + 8, guiTop + 78 - remaining, 176, 84 - remaining, 16, remaining + 1);
+//		}
+	}
+
+//
+	protected static TranslationTextComponent getTrans(String key, Object... args)
+	{
+		return new TranslationTextComponent(BloodMagic.MODID + "." + key, args);
+	}
+}

src/main/java/wayoftime/bloodmagic/client/screens/ScreenSoulForge.java

@@ -0,0 +1,85 @@
+package wayoftime.bloodmagic.client.screens;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.blaze3d.systems.RenderSystem;
+
+import net.minecraft.entity.player.PlayerInventory;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TranslationTextComponent;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.tile.TileSoulForge;
+import wayoftime.bloodmagic.tile.contailer.ContainerSoulForge;
+
+public class ScreenSoulForge extends ScreenBase<ContainerSoulForge>
+{
+	private static final ResourceLocation background = new ResourceLocation(BloodMagic.MODID, "textures/gui/soulforge.png");
+	public IInventory tileSoulForge;
+
+	public ScreenSoulForge(ContainerSoulForge container, PlayerInventory playerInventory, ITextComponent title)
+	{
+		super(container, playerInventory, title);
+		tileSoulForge = container.tileForge;
+		this.xSize = 176;
+		this.ySize = 205;
+	}
+
+	@Override
+	public ResourceLocation getBackground()
+	{
+		return background;
+	}
+
+//	public 
+
+//	public ScreenSoulForge(InventoryPlayer playerInventory, IInventory tileSoulForge)
+//	{
+//		super(new ContainerSoulForge(playerInventory, tileSoulForge));
+//		this.tileSoulForge = tileSoulForge;
+//		this.xSize = 176;
+//		this.ySize = 205;
+//	}
+//
+//	@Override
+//	public void render(MatrixStack stack, int mouseX, int mouseY, float partialTicks)
+//	{
+//		this.drawDefaultBackground();
+//		super.drawScreen(mouseX, mouseY, partialTicks);
+//		this.renderHoveredToolTip(mouseX, mouseY);
+//	}
+//
+	@Override
+	protected void drawGuiContainerForegroundLayer(MatrixStack stack, int mouseX, int mouseY)
+	{
+		this.font.func_243248_b(stack, new TranslationTextComponent("tile.bloodmagic.soulforge.name"), 8, 5, 4210752);
+		this.font.func_243248_b(stack, new TranslationTextComponent("container.inventory"), 8, 111, 4210752);
+	}
+
+//
+	@Override
+	protected void drawGuiContainerBackgroundLayer(MatrixStack stack, float partialTicks, int mouseX, int mouseY)
+	{
+		RenderSystem.color4f(1.0F, 1.0F, 1.0F, 1.0F);
+		getMinecraft().getTextureManager().bindTexture(background);
+		int i = (this.width - this.xSize) / 2;
+		int j = (this.height - this.ySize) / 2;
+		this.blit(stack, i, j, 0, 0, this.xSize, this.ySize);
+
+		int l = this.getCookProgressScaled(90);
+		this.blit(stack, i + 115, j + 14 + 90 - l, 176, 90 - l, 18, l);
+	}
+
+//
+	public int getCookProgressScaled(int scale)
+	{
+		double progress = ((TileSoulForge) tileSoulForge).getProgressForGui();
+//		if (tileSoulForge != null)
+//		{
+//			System.out.println("Tile is NOT null");
+//		}
+//		double progress = ((float) this.container.data.get(0)) / ((float) this.container.data.get(1));
+//		System.out.println(this.container.data.get(0));
+		return (int) (progress * scale);
+	}
+}

src/main/java/wayoftime/bloodmagic/client/utils/BMRenderTypes.java

@@ -0,0 +1,153 @@
+package wayoftime.bloodmagic.client.utils;
+
+import java.util.OptionalDouble;
+import java.util.function.Consumer;
+
+import org.lwjgl.opengl.GL11;
+
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.IVertexBuilder;
+
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.client.renderer.IRenderTypeBuffer;
+import net.minecraft.client.renderer.RenderState;
+import net.minecraft.client.renderer.RenderState.AlphaState;
+import net.minecraft.client.renderer.RenderState.CullState;
+import net.minecraft.client.renderer.RenderState.FogState;
+import net.minecraft.client.renderer.RenderState.LightmapState;
+import net.minecraft.client.renderer.RenderState.LineState;
+import net.minecraft.client.renderer.RenderState.ShadeModelState;
+import net.minecraft.client.renderer.RenderState.TextureState;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.texture.AtlasTexture;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.inventory.container.PlayerContainer;
+import net.minecraft.util.ResourceLocation;
+import wayoftime.bloodmagic.BloodMagic;
+
+public class BMRenderTypes
+{
+	public static final RenderType SOLID_FULLBRIGHT;
+	public static final RenderType TRANSLUCENT_LINES;
+	public static final RenderType LINES;
+	public static final RenderType TRANSLUCENT_TRIANGLES;
+	public static final RenderType TRANSLUCENT_POSITION_COLOR;
+	public static final RenderType TRANSLUCENT_NO_DEPTH;
+	public static final RenderType CHUNK_MARKER;
+	public static final RenderType VEIN_MARKER;
+	public static final RenderType POSITION_COLOR_TEX_LIGHTMAP;
+	public static final RenderType POSITION_COLOR_LIGHTMAP;
+	public static final RenderType ITEM_DAMAGE_BAR;
+	protected static final RenderState.ShadeModelState SHADE_ENABLED = new RenderState.ShadeModelState(true);
+	protected static final RenderState.TextureState BLOCK_SHEET_MIPPED = new RenderState.TextureState(AtlasTexture.LOCATION_BLOCKS_TEXTURE, false, true);
+	protected static final RenderState.LightmapState LIGHTMAP_DISABLED = new RenderState.LightmapState(false);
+	protected static final RenderState.TransparencyState TRANSLUCENT_TRANSPARENCY = new RenderState.TransparencyState("translucent_transparency", () -> {
+		RenderSystem.enableBlend();
+		RenderSystem.defaultBlendFunc();
+	}, RenderSystem::disableBlend);
+	protected static final RenderState.TransparencyState NO_TRANSPARENCY = new RenderState.TransparencyState("no_transparency", RenderSystem::disableBlend, () -> {
+	});
+	protected static final RenderState.DepthTestState DEPTH_ALWAYS = new RenderState.DepthTestState("", GL11.GL_ALWAYS);
+
+	static
+	{
+		RenderType.State fullbrightSolidState = RenderType.State.getBuilder().shadeModel(SHADE_ENABLED).lightmap(LIGHTMAP_DISABLED).texture(BLOCK_SHEET_MIPPED).build(true);
+		SOLID_FULLBRIGHT = RenderType.makeType(BloodMagic.MODID + ":block_fullbright", DefaultVertexFormats.BLOCK, GL11.GL_QUADS, 256, fullbrightSolidState);
+		RenderType.State translucentNoDepthState = RenderType.State.getBuilder().transparency(TRANSLUCENT_TRANSPARENCY).line(new LineState(OptionalDouble.of(2))).texture(new TextureState()).depthTest(DEPTH_ALWAYS).build(false);
+		RenderType.State translucentNoTextureState = RenderType.State.getBuilder().transparency(TRANSLUCENT_TRANSPARENCY).texture(new TextureState()).build(false);
+		TRANSLUCENT_LINES = RenderType.makeType(BloodMagic.MODID + ":translucent_lines", DefaultVertexFormats.POSITION_COLOR, GL11.GL_LINES, 256, translucentNoDepthState);
+		LINES = RenderType.makeType(BloodMagic.MODID + ":lines", DefaultVertexFormats.POSITION_COLOR, GL11.GL_LINES, 256, RenderType.State.getBuilder().build(false));
+		TRANSLUCENT_TRIANGLES = RenderType.makeType(BloodMagic.MODID + ":translucent_triangle_fan", DefaultVertexFormats.POSITION_COLOR, GL11.GL_TRIANGLES, 256, translucentNoDepthState);
+		TRANSLUCENT_POSITION_COLOR = RenderType.makeType(BloodMagic.MODID + ":translucent_pos_color", DefaultVertexFormats.POSITION_COLOR, GL11.GL_QUADS, 256, translucentNoTextureState);
+		TRANSLUCENT_NO_DEPTH = RenderType.makeType(BloodMagic.MODID + ":translucent_no_depth", DefaultVertexFormats.POSITION_COLOR, GL11.GL_QUADS, 256, translucentNoDepthState);
+		RenderType.State chunkMarkerState = RenderType.State.getBuilder().texture(new TextureState()).transparency(TRANSLUCENT_TRANSPARENCY).cull(new CullState(false)).shadeModel(new ShadeModelState(true)).line(new LineState(OptionalDouble.of(5))).build(false);
+		CHUNK_MARKER = RenderType.makeType(BloodMagic.MODID + ":chunk_marker", DefaultVertexFormats.POSITION_COLOR, GL11.GL_LINES, 256, chunkMarkerState);
+		VEIN_MARKER = RenderType.makeType(BloodMagic.MODID + ":vein_marker", DefaultVertexFormats.POSITION_COLOR, GL11.GL_LINE_LOOP, 256, chunkMarkerState);
+		POSITION_COLOR_TEX_LIGHTMAP = RenderType.makeType(BloodMagic.MODID + ":pos_color_tex_lightmap", DefaultVertexFormats.POSITION_COLOR_TEX_LIGHTMAP, GL11.GL_QUADS, 256, RenderType.State.getBuilder().texture(new TextureState(PlayerContainer.LOCATION_BLOCKS_TEXTURE, false, false)).lightmap(new LightmapState(true)).build(false));
+		POSITION_COLOR_LIGHTMAP = RenderType.makeType(BloodMagic.MODID + ":pos_color_lightmap", DefaultVertexFormats.POSITION_COLOR_LIGHTMAP, GL11.GL_QUADS, 256, RenderType.State.getBuilder().texture(new TextureState()).lightmap(new LightmapState(true)).build(false));
+		ITEM_DAMAGE_BAR = RenderType.makeType(BloodMagic.MODID + ":item_damage_bar", DefaultVertexFormats.POSITION_COLOR, GL11.GL_QUADS, 256, RenderType.State.getBuilder().depthTest(DEPTH_ALWAYS).texture(new TextureState()).alpha(new AlphaState(0)).transparency(NO_TRANSPARENCY).build(false));
+	}
+
+	public static RenderType getGui(ResourceLocation texture)
+	{
+		return RenderType.makeType("gui_" + texture, DefaultVertexFormats.POSITION_COLOR_TEX, GL11.GL_QUADS, 256, RenderType.State.getBuilder().texture(new TextureState(texture, false, false)).alpha(new AlphaState(0.5F)).build(false));
+	}
+
+	public static RenderType getLines(float lineWidth)
+	{
+		return RenderType.makeType("lines_color_pos_" + lineWidth, DefaultVertexFormats.POSITION_COLOR, GL11.GL_LINES, 256, RenderType.State.getBuilder().line(new LineState(OptionalDouble.of(lineWidth))).texture(new TextureState()).build(false));
+	}
+
+	public static RenderType getPoints(float pointSize)
+	{
+		// Not really a fog state, but using it like this makes using RenderType.State
+		// with custom states possible
+		FogState setPointSize = new FogState(BloodMagic.MODID + ":pointsize_" + pointSize, () -> GL11.glPointSize(pointSize), () -> {
+			GL11.glPointSize(1);
+		});
+		return RenderType.makeType("point_pos_color_" + pointSize, DefaultVertexFormats.POSITION_COLOR, GL11.GL_POINTS, 256, RenderType.State.getBuilder().fog(setPointSize).texture(new TextureState()).build(false));
+	}
+
+	public static RenderType getPositionTex(ResourceLocation texture)
+	{
+		return RenderType.makeType(BloodMagic.MODID + ":pos_tex_" + texture, DefaultVertexFormats.POSITION_TEX, GL11.GL_QUADS, 256, RenderType.State.getBuilder().texture(new TextureState(texture, false, false)).build(false));
+	}
+
+	public static RenderType getFullbrightTranslucent(ResourceLocation resourceLocation)
+	{
+		RenderType.State glState = RenderType.State.getBuilder().transparency(TRANSLUCENT_TRANSPARENCY).texture(new TextureState(resourceLocation, false, false)).lightmap(new LightmapState(false)).build(false);
+		return RenderType.makeType("BloodMagic:fullbright_translucent_" + resourceLocation, DefaultVertexFormats.BLOCK, GL11.GL_QUADS, 256, glState);
+	}
+
+	public static IRenderTypeBuffer wrapWithStencil(IRenderTypeBuffer in, Consumer<IVertexBuilder> setupStencilArea, String name, int ref)
+	{
+		return wrapWithAdditional(in, "stencil_" + name + "_" + ref, () -> {
+			GL11.glEnable(GL11.GL_STENCIL_TEST);
+			RenderSystem.colorMask(false, false, false, false);
+			RenderSystem.depthMask(false);
+			GL11.glStencilFunc(GL11.GL_NEVER, 1, 0xFF);
+			GL11.glStencilOp(GL11.GL_REPLACE, GL11.GL_KEEP, GL11.GL_KEEP);
+
+			GL11.glStencilMask(0xFF);
+			RenderSystem.clear(GL11.GL_STENCIL_BUFFER_BIT, true);
+			RenderSystem.disableTexture();
+			Tessellator tes = Tessellator.getInstance();
+			BufferBuilder bb = tes.getBuffer();
+			bb.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION);
+			setupStencilArea.accept(bb);
+			tes.draw();
+			RenderSystem.enableTexture();
+			RenderSystem.colorMask(true, true, true, true);
+			RenderSystem.depthMask(true);
+			GL11.glStencilMask(0x00);
+			GL11.glStencilFunc(GL11.GL_EQUAL, ref, 0xFF);
+		}, () -> GL11.glDisable(GL11.GL_STENCIL_TEST));
+	}
+
+	public static IRenderTypeBuffer disableLighting(IRenderTypeBuffer in)
+	{
+		return wrapWithAdditional(in, "no_lighting", RenderSystem::disableLighting, () -> {
+		});
+	}
+
+	public static IRenderTypeBuffer disableCull(IRenderTypeBuffer in)
+	{
+		return wrapWithAdditional(in, "no_cull", RenderSystem::disableCull, RenderSystem::enableCull);
+	}
+
+	private static IRenderTypeBuffer wrapWithAdditional(IRenderTypeBuffer in, String name, Runnable setup, Runnable teardown)
+	{
+		return type -> {
+			return in.getBuffer(new RenderType(BloodMagic.MODID + ":" + type + "_" + name, type.getVertexFormat(), type.getDrawMode(), type.getBufferSize(), type.isUseDelegate(), false, () -> {
+				type.setupRenderState();
+				setup.run();
+			}, () -> {
+				teardown.run();
+				type.clearRenderState();
+			})
+			{
+			});
+		};
+	}
+}

src/main/java/wayoftime/bloodmagic/common/alchemyarray/AlchemyArrayEffect.java

@@ -0,0 +1,15 @@
+package wayoftime.bloodmagic.common.alchemyarray;
+
+import net.minecraft.nbt.CompoundNBT;
+import wayoftime.bloodmagic.tile.TileAlchemyArray;
+
+public abstract class AlchemyArrayEffect
+{
+	public abstract AlchemyArrayEffect getNewCopy();
+
+	public abstract void readFromNBT(CompoundNBT compound);
+
+	public abstract void writeToNBT(CompoundNBT compound);
+
+	public abstract boolean update(TileAlchemyArray array, int activeCounter);
+}

src/main/java/wayoftime/bloodmagic/common/alchemyarray/AlchemyArrayEffectCrafting.java

@@ -0,0 +1,69 @@
+package wayoftime.bloodmagic.common.alchemyarray;
+
+import net.minecraft.entity.item.ItemEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.util.math.BlockPos;
+import wayoftime.bloodmagic.tile.TileAlchemyArray;
+
+public class AlchemyArrayEffectCrafting extends AlchemyArrayEffect
+{
+	public final ItemStack outputStack;
+	public int tickLimit;
+
+	public AlchemyArrayEffectCrafting(ItemStack outputStack)
+	{
+		this(outputStack, 200);
+	}
+
+	public AlchemyArrayEffectCrafting(ItemStack outputStack, int tickLimit)
+	{
+		this.outputStack = outputStack;
+		this.tickLimit = tickLimit;
+	}
+
+	@Override
+	public boolean update(TileAlchemyArray tile, int ticksActive)
+	{
+		// TODO: Add recipe rechecking to verify nothing screwy is going on.
+		if (tile.getWorld().isRemote)
+		{
+			return false;
+		}
+
+		if (ticksActive >= tickLimit)
+		{
+			BlockPos pos = tile.getPos();
+
+			ItemStack output = outputStack.copy();
+
+			ItemEntity outputEntity = new ItemEntity(tile.getWorld(), pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ()
+					+ 0.5, output);
+
+			tile.getWorld().addEntity(outputEntity);
+//			tile.getWorld().spawnEntity(outputEntity);
+
+			return true;
+		}
+
+		return false;
+	}
+
+	@Override
+	public void writeToNBT(CompoundNBT tag)
+	{
+
+	}
+
+	@Override
+	public void readFromNBT(CompoundNBT tag)
+	{
+
+	}
+
+	@Override
+	public AlchemyArrayEffect getNewCopy()
+	{
+		return new AlchemyArrayEffectCrafting(outputStack, tickLimit);
+	}
+}

src/main/java/wayoftime/bloodmagic/common/block/BlockAlchemicalReactionChamber.java

@@ -0,0 +1,162 @@
+package wayoftime.bloodmagic.common.block;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.HorizontalBlock;
+import net.minecraft.block.SoundType;
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.entity.player.ServerPlayerEntity;
+import net.minecraft.inventory.container.INamedContainerProvider;
+import net.minecraft.item.BlockItemUseContext;
+import net.minecraft.item.ItemStack;
+import net.minecraft.state.BooleanProperty;
+import net.minecraft.state.DirectionProperty;
+import net.minecraft.state.StateContainer;
+import net.minecraft.state.properties.BlockStateProperties;
+import net.minecraft.tileentity.AbstractFurnaceTileEntity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ActionResultType;
+import net.minecraft.util.Direction;
+import net.minecraft.util.Hand;
+import net.minecraft.util.Mirror;
+import net.minecraft.util.Rotation;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.BlockRayTraceResult;
+import net.minecraft.world.IBlockReader;
+import net.minecraft.world.IWorld;
+import net.minecraft.world.World;
+import net.minecraftforge.common.ToolType;
+import net.minecraftforge.fml.network.NetworkHooks;
+import wayoftime.bloodmagic.tile.TileAlchemicalReactionChamber;
+
+public class BlockAlchemicalReactionChamber extends Block
+{
+	public static final DirectionProperty FACING = HorizontalBlock.HORIZONTAL_FACING;
+	public static final BooleanProperty LIT = BlockStateProperties.LIT;
+
+	public BlockAlchemicalReactionChamber()
+	{
+		super(Properties.create(Material.ROCK).hardnessAndResistance(2.0F, 5.0F).harvestTool(ToolType.PICKAXE).harvestLevel(2).sound(SoundType.STONE));
+		this.setDefaultState(this.stateContainer.getBaseState().with(FACING, Direction.NORTH).with(LIT, Boolean.valueOf(false)));
+	}
+
+	@Override
+	public boolean hasTileEntity(BlockState state)
+	{
+		return true;
+	}
+
+	@Override
+	public TileEntity createTileEntity(BlockState state, IBlockReader world)
+	{
+		return new TileAlchemicalReactionChamber();
+	}
+
+	@Override
+	public void onPlayerDestroy(IWorld world, BlockPos blockPos, BlockState blockState)
+	{
+		TileAlchemicalReactionChamber arc = (TileAlchemicalReactionChamber) world.getTileEntity(blockPos);
+		if (arc != null)
+			arc.dropItems();
+
+		super.onPlayerDestroy(world, blockPos, blockState);
+	}
+
+	@Override
+	public void onReplaced(BlockState state, World worldIn, BlockPos pos, BlockState newState, boolean isMoving)
+	{
+		if (!state.isIn(newState.getBlock()))
+		{
+			TileEntity tileentity = worldIn.getTileEntity(pos);
+			if (tileentity instanceof TileAlchemicalReactionChamber)
+			{
+				((TileAlchemicalReactionChamber) tileentity).dropItems();
+				worldIn.updateComparatorOutputLevel(pos, this);
+			}
+
+			super.onReplaced(state, worldIn, pos, newState, isMoving);
+		}
+	}
+
+	@Override
+	public ActionResultType onBlockActivated(BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockRayTraceResult blockRayTraceResult)
+	{
+		if (world.isRemote)
+			return ActionResultType.SUCCESS;
+
+		TileEntity tile = world.getTileEntity(pos);
+		if (!(tile instanceof TileAlchemicalReactionChamber))
+			return ActionResultType.FAIL;
+
+		NetworkHooks.openGui((ServerPlayerEntity) player, (INamedContainerProvider) tile, pos);
+//			player.openGui(BloodMagic.instance, Constants.Gui.SOUL_FORGE_GUI, world, pos.getX(), pos.getY(), pos.getZ());
+
+		return ActionResultType.SUCCESS;
+	}
+
+	@Override
+	public BlockState getStateForPlacement(BlockItemUseContext context)
+	{
+		return this.getDefaultState().with(FACING, context.getPlacementHorizontalFacing().getOpposite());
+	}
+
+	/**
+	 * Called by ItemBlocks after a block is set in the world, to allow post-place
+	 * logic
+	 */
+	@Override
+	public void onBlockPlacedBy(World worldIn, BlockPos pos, BlockState state, LivingEntity placer, ItemStack stack)
+	{
+		if (stack.hasDisplayName())
+		{
+			TileEntity tileentity = worldIn.getTileEntity(pos);
+			if (tileentity instanceof AbstractFurnaceTileEntity)
+			{
+				((AbstractFurnaceTileEntity) tileentity).setCustomName(stack.getDisplayName());
+			}
+		}
+
+	}
+
+	/**
+	 * Returns the blockstate with the given rotation from the passed blockstate. If
+	 * inapplicable, returns the passed blockstate.
+	 * 
+	 * @deprecated call via {@link IBlockState#withRotation(Rotation)} whenever
+	 *             possible. Implementing/overriding is fine.
+	 */
+	@Override
+	public BlockState rotate(BlockState state, Rotation rot)
+	{
+		return state.with(FACING, rot.rotate(state.get(FACING)));
+	}
+
+	/**
+	 * Returns the blockstate with the given mirror of the passed blockstate. If
+	 * inapplicable, returns the passed blockstate.
+	 * 
+	 * @deprecated call via {@link IBlockState#withMirror(Mirror)} whenever
+	 *             possible. Implementing/overriding is fine.
+	 */
+	@Override
+	public BlockState mirror(BlockState state, Mirror mirrorIn)
+	{
+		return state.rotate(mirrorIn.toRotation(state.get(FACING)));
+	}
+
+	@Override
+	protected void fillStateContainer(StateContainer.Builder<Block, BlockState> builder)
+	{
+		builder.add(FACING, LIT);
+	}
+
+	public boolean eventReceived(BlockState state, World worldIn, BlockPos pos, int id, int param)
+	{
+		super.eventReceived(state, worldIn, pos, id, param);
+		TileEntity tileentity = worldIn.getTileEntity(pos);
+		return tileentity == null ? false : tileentity.receiveClientEvent(id, param);
+	}
+
+}

src/main/java/wayoftime/bloodmagic/common/block/BlockAlchemyArray.java

@@ -0,0 +1,112 @@
+package wayoftime.bloodmagic.common.block;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockRenderType;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ActionResultType;
+import net.minecraft.util.Hand;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.BlockRayTraceResult;
+import net.minecraft.util.math.shapes.ISelectionContext;
+import net.minecraft.util.math.shapes.VoxelShape;
+import net.minecraft.world.IBlockReader;
+import net.minecraft.world.IWorld;
+import net.minecraft.world.World;
+import wayoftime.bloodmagic.tile.TileAlchemyArray;
+import wayoftime.bloodmagic.util.Utils;
+
+public class BlockAlchemyArray extends Block
+{
+	protected static final VoxelShape BODY = Block.makeCuboidShape(1, 0, 1, 15, 1, 15);
+
+	public BlockAlchemyArray()
+	{
+		super(Properties.create(Material.WOOL).hardnessAndResistance(1.0F, 0).doesNotBlockMovement());
+	}
+
+	@Override
+	public VoxelShape getShape(BlockState state, IBlockReader worldIn, BlockPos pos, ISelectionContext context)
+	{
+		return BODY;
+	}
+
+	@Override
+	public boolean hasTileEntity(BlockState state)
+	{
+		return true;
+	}
+
+	@Override
+	public TileEntity createTileEntity(BlockState state, IBlockReader world)
+	{
+		return new TileAlchemyArray();
+	}
+
+	@Override
+	public BlockRenderType getRenderType(BlockState state)
+	{
+		return BlockRenderType.ENTITYBLOCK_ANIMATED;
+	}
+
+	@Override
+	public ActionResultType onBlockActivated(BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockRayTraceResult blockRayTraceResult)
+	{
+		TileAlchemyArray array = (TileAlchemyArray) world.getTileEntity(pos);
+
+		if (array == null || player.isSneaking())
+			return ActionResultType.FAIL;
+
+		ItemStack playerItem = player.getHeldItem(hand);
+
+		if (!playerItem.isEmpty())
+		{
+			if (array.getStackInSlot(0).isEmpty())
+			{
+				Utils.insertItemToTile(array, player, 0);
+				world.notifyBlockUpdate(pos, state, state, 3);
+			} else if (!array.getStackInSlot(0).isEmpty())
+			{
+				Utils.insertItemToTile(array, player, 1);
+				array.attemptCraft();
+				world.notifyBlockUpdate(pos, state, state, 3);
+			} else
+			{
+				return ActionResultType.SUCCESS;
+			}
+		}
+
+		world.notifyBlockUpdate(pos, state, state, 3);
+		return ActionResultType.SUCCESS;
+	}
+
+	@Override
+	public void onPlayerDestroy(IWorld world, BlockPos blockPos, BlockState blockState)
+	{
+		TileAlchemyArray alchemyArray = (TileAlchemyArray) world.getTileEntity(blockPos);
+		if (alchemyArray != null)
+			alchemyArray.dropItems();
+
+		super.onPlayerDestroy(world, blockPos, blockState);
+	}
+
+	@Override
+	public void onReplaced(BlockState state, World worldIn, BlockPos pos, BlockState newState, boolean isMoving)
+	{
+		if (!state.isIn(newState.getBlock()))
+		{
+			TileEntity tileentity = worldIn.getTileEntity(pos);
+			if (tileentity instanceof TileAlchemyArray)
+			{
+				((TileAlchemyArray) tileentity).dropItems();
+				worldIn.updateComparatorOutputLevel(pos, this);
+			}
+
+			super.onReplaced(state, worldIn, pos, newState, isMoving);
+		}
+	}
+
+}

src/main/java/wayoftime/bloodmagic/common/block/BlockAltar.java

@@ -0,0 +1,100 @@
+package wayoftime.bloodmagic.common.block;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ActionResultType;
+import net.minecraft.util.Hand;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.BlockRayTraceResult;
+import net.minecraft.util.math.shapes.ISelectionContext;
+import net.minecraft.util.math.shapes.VoxelShape;
+import net.minecraft.world.IBlockReader;
+import net.minecraft.world.IWorld;
+import net.minecraft.world.World;
+import net.minecraftforge.common.ToolType;
+import wayoftime.bloodmagic.iface.IAltarReader;
+import wayoftime.bloodmagic.tile.TileAltar;
+import wayoftime.bloodmagic.util.Utils;
+
+public class BlockAltar extends Block
+{
+	protected static final VoxelShape BODY = Block.makeCuboidShape(0, 0, 0, 16, 12, 16);
+
+	public BlockAltar()
+	{
+		super(Properties.create(Material.ROCK).hardnessAndResistance(2.0F, 5.0F).harvestTool(ToolType.PICKAXE).harvestLevel(1));
+	}
+
+	@Override
+	public VoxelShape getShape(BlockState state, IBlockReader worldIn, BlockPos pos, ISelectionContext context)
+	{
+		return BODY;
+	}
+
+	@Override
+	public boolean hasTileEntity(BlockState state)
+	{
+		return true;
+	}
+
+	@Override
+	public TileEntity createTileEntity(BlockState state, IBlockReader world)
+	{
+		return new TileAltar();
+	}
+
+	@Override
+	public ActionResultType onBlockActivated(BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockRayTraceResult blockRayTraceResult)
+	{
+		TileAltar altar = (TileAltar) world.getTileEntity(pos);
+
+		if (altar == null || player.isSneaking())
+			return ActionResultType.FAIL;
+
+		ItemStack playerItem = player.getHeldItem(hand);
+
+		if (playerItem.getItem() instanceof IAltarReader)// || playerItem.getItem() instanceof IAltarManipulator)
+		{
+			playerItem.getItem().onItemRightClick(world, player, hand);
+			return ActionResultType.SUCCESS;
+		}
+
+		if (Utils.insertItemToTile(altar, player))
+			altar.startCycle();
+		else
+			altar.setActive();
+
+		world.notifyBlockUpdate(pos, state, state, 3);
+		return ActionResultType.SUCCESS;
+	}
+
+	@Override
+	public void onPlayerDestroy(IWorld world, BlockPos blockPos, BlockState blockState)
+	{
+		TileAltar altar = (TileAltar) world.getTileEntity(blockPos);
+		if (altar != null)
+			altar.dropItems();
+
+		super.onPlayerDestroy(world, blockPos, blockState);
+	}
+
+	@Override
+	public void onReplaced(BlockState state, World worldIn, BlockPos pos, BlockState newState, boolean isMoving)
+	{
+		if (!state.isIn(newState.getBlock()))
+		{
+			TileEntity tileentity = worldIn.getTileEntity(pos);
+			if (tileentity instanceof TileAltar)
+			{
+				((TileAltar) tileentity).dropItems();
+				worldIn.updateComparatorOutputLevel(pos, this);
+			}
+
+			super.onReplaced(state, worldIn, pos, newState, isMoving);
+		}
+	}
+}

src/main/java/wayoftime/bloodmagic/common/block/BlockBloodLight.java

@@ -0,0 +1,64 @@
+package wayoftime.bloodmagic.common.block;
+
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockRenderType;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.entity.player.ClientPlayerEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.particles.RedstoneParticleData;
+import net.minecraft.util.Hand;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.shapes.ISelectionContext;
+import net.minecraft.util.math.shapes.VoxelShape;
+import net.minecraft.world.IBlockReader;
+import net.minecraft.world.World;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+public class BlockBloodLight extends Block
+{
+	protected static final VoxelShape BODY = Block.makeCuboidShape(7, 7, 7, 9, 9, 9);
+
+	public BlockBloodLight()
+	{
+		super(Properties.create(Material.WOOL).doesNotBlockMovement().setLightLevel((state) -> {
+			return 15;
+		}));
+	}
+
+	@Override
+	public VoxelShape getShape(BlockState state, IBlockReader worldIn, BlockPos pos, ISelectionContext context)
+	{
+		return BODY;
+	}
+
+	@Override
+	public BlockRenderType getRenderType(BlockState state)
+	{
+		return BlockRenderType.ENTITYBLOCK_ANIMATED;
+	}
+
+	@Override
+	@OnlyIn(Dist.CLIENT)
+	public void animateTick(BlockState stateIn, World world, BlockPos pos, Random rand)
+	{
+		ClientPlayerEntity player = Minecraft.getInstance().player;
+
+		if (rand.nextInt(3) != 0)
+		{
+			world.addParticle(RedstoneParticleData.REDSTONE_DUST, pos.getX() + 0.5D
+					+ rand.nextGaussian() / 8, pos.getY() + 0.5D, pos.getZ() + 0.5D + rand.nextGaussian() / 8, 0, 0, 0);
+			ItemStack heldItem = player.getHeldItem(Hand.MAIN_HAND);
+
+//			if (heldItem.isEmpty() || heldItem.getItem() != RegistrarBloodMagicItems.SIGIL_BLOOD_LIGHT)
+//				return;
+//
+//			for (int i = 0; i < 8; i++) world.addParticle(RedstoneParticleData.REDSTONE_DUST, pos.getX() + 0.5D
+//					+ rand.nextGaussian() / 8, pos.getY() + 0.5D, pos.getZ() + 0.5D + rand.nextGaussian() / 8, 0, 0, 0);
+		}
+	}
+}

src/main/java/wayoftime/bloodmagic/common/block/BlockBloodRune.java

@@ -0,0 +1,45 @@
+package wayoftime.bloodmagic.common.block;
+
+import java.util.List;
+
+import javax.annotation.Nullable;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.SoundType;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.util.ITooltipFlag;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TranslationTextComponent;
+import net.minecraft.world.IBlockReader;
+import net.minecraft.world.World;
+import net.minecraftforge.common.ToolType;
+import wayoftime.bloodmagic.block.enums.BloodRuneType;
+import wayoftime.bloodmagic.iface.IBloodRune;
+
+public class BlockBloodRune extends Block implements IBloodRune
+{
+	private final BloodRuneType type;
+
+	public BlockBloodRune(BloodRuneType type)
+	{
+		super(Properties.create(Material.ROCK).hardnessAndResistance(2.0F, 5.0F).harvestTool(ToolType.PICKAXE).harvestLevel(2).sound(SoundType.STONE));
+		this.type = type;
+	}
+
+	@Nullable
+	@Override
+	public BloodRuneType getBloodRune(World world, BlockPos pos)
+	{
+		return type;
+	}
+
+	@Override
+	public void addInformation(ItemStack stack, @Nullable IBlockReader world, List<ITextComponent> tooltip,
+			ITooltipFlag flag)
+	{
+		tooltip.add(new TranslationTextComponent("tooltip.bloodmagic.decoration.safe"));
+		super.addInformation(stack, world, tooltip, flag);
+	}
+}

src/main/java/wayoftime/bloodmagic/common/block/BlockMasterRitualStone.java

@@ -0,0 +1,130 @@
+package wayoftime.bloodmagic.common.block;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.SoundType;
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ActionResultType;
+import net.minecraft.util.Direction;
+import net.minecraft.util.Hand;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.BlockRayTraceResult;
+import net.minecraft.util.text.TranslationTextComponent;
+import net.minecraft.world.Explosion;
+import net.minecraft.world.IBlockReader;
+import net.minecraft.world.IWorld;
+import net.minecraft.world.World;
+import net.minecraftforge.common.ToolType;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.common.item.ItemActivationCrystal;
+import wayoftime.bloodmagic.iface.IBindable;
+import wayoftime.bloodmagic.ritual.Ritual;
+import wayoftime.bloodmagic.tile.TileMasterRitualStone;
+import wayoftime.bloodmagic.util.helper.RitualHelper;
+
+public class BlockMasterRitualStone extends Block
+{
+	public final boolean isInverted;
+
+	public BlockMasterRitualStone(boolean isInverted)
+	{
+		super(Properties.create(Material.ROCK).sound(SoundType.STONE).hardnessAndResistance(2.0F, 5.0F).harvestTool(ToolType.PICKAXE).harvestLevel(2));
+		this.isInverted = isInverted;
+	}
+
+	@Override
+	public ActionResultType onBlockActivated(BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockRayTraceResult blockRayTraceResult)
+	{
+		ItemStack heldItem = player.getHeldItem(hand);
+		TileEntity tile = world.getTileEntity(pos);
+
+		if (tile instanceof TileMasterRitualStone)
+		{
+			if (heldItem.getItem() instanceof ItemActivationCrystal)
+			{
+				if (((IBindable) heldItem.getItem()).getBinding(heldItem) == null)
+					return ActionResultType.FAIL;
+
+				String key = RitualHelper.getValidRitual(world, pos);
+				if (!key.isEmpty())
+				{
+					Ritual ritual = BloodMagic.RITUAL_MANAGER.getRitual(key);
+					if (ritual != null)
+					{
+						Direction direction = RitualHelper.getDirectionOfRitual(world, pos, ritual);
+						// TODO: Give a message stating that this ritual is not a valid ritual.
+						if (direction != null && RitualHelper.checkValidRitual(world, pos, ritual, direction))
+						{
+							if (((TileMasterRitualStone) tile).activateRitual(heldItem, player, BloodMagic.RITUAL_MANAGER.getRitual(key)))
+							{
+								((TileMasterRitualStone) tile).setDirection(direction);
+								if (isInverted)
+									((TileMasterRitualStone) tile).setInverted(true);
+							}
+						} else
+						{
+							player.sendStatusMessage(new TranslationTextComponent("chat.bloodmagic.ritual.notvalid"), true);
+						}
+					} else
+					{
+						player.sendStatusMessage(new TranslationTextComponent("chat.bloodmagic.ritual.notvalid"), true);
+					}
+				} else
+				{
+					player.sendStatusMessage(new TranslationTextComponent("chat.bloodmagic.ritual.notvalid"), true);
+				}
+			}
+		}
+
+		return ActionResultType.FAIL;
+	}
+
+	@Override
+	public void onPlayerDestroy(IWorld world, BlockPos blockPos, BlockState blockState)
+	{
+		TileMasterRitualStone tile = (TileMasterRitualStone) world.getTileEntity(blockPos);
+		if (tile != null)
+			((TileMasterRitualStone) tile).stopRitual(Ritual.BreakType.BREAK_MRS);
+
+		super.onPlayerDestroy(world, blockPos, blockState);
+	}
+
+	@Override
+	public void onReplaced(BlockState state, World worldIn, BlockPos pos, BlockState newState, boolean isMoving)
+	{
+		if (!state.isIn(newState.getBlock()))
+		{
+			TileEntity tile = worldIn.getTileEntity(pos);
+			if (tile instanceof TileMasterRitualStone)
+			{
+				((TileMasterRitualStone) tile).stopRitual(Ritual.BreakType.BREAK_MRS);
+			}
+
+			super.onReplaced(state, worldIn, pos, newState, isMoving);
+		}
+	}
+
+	@Override
+	public void onExplosionDestroy(World world, BlockPos pos, Explosion explosion)
+	{
+		TileEntity tile = world.getTileEntity(pos);
+
+		if (tile instanceof TileMasterRitualStone)
+			((TileMasterRitualStone) tile).stopRitual(Ritual.BreakType.EXPLOSION);
+	}
+
+	@Override
+	public boolean hasTileEntity(BlockState state)
+	{
+		return true;
+	}
+
+	@Override
+	public TileEntity createTileEntity(BlockState state, IBlockReader world)
+	{
+		return new TileMasterRitualStone();
+	}
+}

src/main/java/wayoftime/bloodmagic/common/block/BlockRitualStone.java

@@ -0,0 +1,89 @@
+package wayoftime.bloodmagic.common.block;
+
+import java.util.List;
+
+import javax.annotation.Nullable;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.SoundType;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.util.ITooltipFlag;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TranslationTextComponent;
+import net.minecraft.world.IBlockReader;
+import net.minecraft.world.World;
+import net.minecraftforge.common.ToolType;
+import wayoftime.bloodmagic.ritual.EnumRuneType;
+import wayoftime.bloodmagic.ritual.IRitualStone;
+
+public class BlockRitualStone extends Block implements IRitualStone
+{
+	private final EnumRuneType type;
+
+	public BlockRitualStone(EnumRuneType type)
+	{
+		super(Properties.create(Material.ROCK).hardnessAndResistance(2.0F, 5.0F).sound(SoundType.STONE).harvestTool(ToolType.PICKAXE).harvestLevel(2));
+		this.type = type;
+	}
+
+	@Override
+	public void addInformation(ItemStack stack, @Nullable IBlockReader world, List<ITextComponent> tooltip, ITooltipFlag flag)
+	{
+		tooltip.add(new TranslationTextComponent("tooltip.bloodmagic.decoration.safe"));
+		super.addInformation(stack, world, tooltip, flag);
+	}
+
+//	@Override
+//	public int damageDropped(BlockState state)
+//	{
+//		return 0;
+//	}
+//
+//	@Override
+//	public boolean canSilkHarvest(World world, BlockPos pos, BlockState state, PlayerEntity player)
+//	{
+//		return false;
+//	}
+
+	@Override
+	public boolean isRuneType(World world, BlockPos pos, EnumRuneType runeType)
+	{
+		return type.equals(runeType);
+	}
+
+	@Override
+	public void setRuneType(World world, BlockPos pos, EnumRuneType runeType)
+	{
+		Block runeBlock = this;
+		switch (runeType)
+		{
+		case AIR:
+			runeBlock = BloodMagicBlocks.AIR_RITUAL_STONE.get();
+			break;
+		case BLANK:
+			runeBlock = BloodMagicBlocks.BLANK_RITUAL_STONE.get();
+			break;
+		case DAWN:
+			runeBlock = BloodMagicBlocks.DAWN_RITUAL_STONE.get();
+			break;
+		case DUSK:
+			runeBlock = BloodMagicBlocks.DUSK_RITUAL_STONE.get();
+			break;
+		case EARTH:
+			runeBlock = BloodMagicBlocks.EARTH_RITUAL_STONE.get();
+			break;
+		case FIRE:
+			runeBlock = BloodMagicBlocks.FIRE_RITUAL_STONE.get();
+			break;
+		case WATER:
+			runeBlock = BloodMagicBlocks.WATER_RITUAL_STONE.get();
+			break;
+		}
+
+		BlockState newState = runeBlock.getDefaultState();
+		world.setBlockState(pos, newState);
+	}
+}

src/main/java/wayoftime/bloodmagic/common/block/BlockSoulForge.java

@@ -0,0 +1,98 @@
+package wayoftime.bloodmagic.common.block;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockRenderType;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.entity.player.ServerPlayerEntity;
+import net.minecraft.inventory.container.INamedContainerProvider;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ActionResultType;
+import net.minecraft.util.Hand;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.BlockRayTraceResult;
+import net.minecraft.util.math.shapes.ISelectionContext;
+import net.minecraft.util.math.shapes.VoxelShape;
+import net.minecraft.world.IBlockReader;
+import net.minecraft.world.IWorld;
+import net.minecraft.world.World;
+import net.minecraftforge.common.ToolType;
+import net.minecraftforge.fml.network.NetworkHooks;
+import wayoftime.bloodmagic.tile.TileSoulForge;
+
+public class BlockSoulForge extends Block// implements IBMBlock
+{
+	protected static final VoxelShape BODY = Block.makeCuboidShape(1, 0, 1, 15, 12, 15);
+
+	public BlockSoulForge()
+	{
+		super(Properties.create(Material.IRON).hardnessAndResistance(2.0F, 5.0F).harvestTool(ToolType.PICKAXE).harvestLevel(1));
+	}
+
+	@Override
+	public VoxelShape getShape(BlockState state, IBlockReader worldIn, BlockPos pos, ISelectionContext context)
+	{
+		return BODY;
+	}
+
+	@Override
+	public boolean hasTileEntity(BlockState state)
+	{
+		return true;
+	}
+
+	@Override
+	public TileEntity createTileEntity(BlockState state, IBlockReader world)
+	{
+		return new TileSoulForge();
+	}
+
+	@Override
+	public BlockRenderType getRenderType(BlockState state)
+	{
+		return BlockRenderType.MODEL;
+	}
+
+	@Override
+	public ActionResultType onBlockActivated(BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockRayTraceResult blockRayTraceResult)
+	{
+		if (world.isRemote)
+			return ActionResultType.SUCCESS;
+
+		TileEntity tile = world.getTileEntity(pos);
+		if (!(tile instanceof TileSoulForge))
+			return ActionResultType.FAIL;
+
+		NetworkHooks.openGui((ServerPlayerEntity) player, (INamedContainerProvider) tile, pos);
+//			player.openGui(BloodMagic.instance, Constants.Gui.SOUL_FORGE_GUI, world, pos.getX(), pos.getY(), pos.getZ());
+
+		return ActionResultType.SUCCESS;
+	}
+
+	@Override
+	public void onPlayerDestroy(IWorld world, BlockPos blockPos, BlockState blockState)
+	{
+		TileSoulForge forge = (TileSoulForge) world.getTileEntity(blockPos);
+		if (forge != null)
+			forge.dropItems();
+
+		super.onPlayerDestroy(world, blockPos, blockState);
+	}
+
+	@Override
+	public void onReplaced(BlockState state, World worldIn, BlockPos pos, BlockState newState, boolean isMoving)
+	{
+		if (!state.isIn(newState.getBlock()))
+		{
+			TileEntity tileentity = worldIn.getTileEntity(pos);
+			if (tileentity instanceof TileSoulForge)
+			{
+				((TileSoulForge) tileentity).dropItems();
+				worldIn.updateComparatorOutputLevel(pos, this);
+			}
+
+			super.onReplaced(state, worldIn, pos, newState, isMoving);
+		}
+	}
+}

src/main/java/wayoftime/bloodmagic/common/block/BloodMagicBlocks.java

@@ -0,0 +1,103 @@
+package wayoftime.bloodmagic.common.block;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.FlowingFluidBlock;
+import net.minecraft.fluid.FlowingFluid;
+import net.minecraft.fluid.Fluid;
+import net.minecraft.inventory.container.ContainerType;
+import net.minecraft.item.BucketItem;
+import net.minecraft.item.Item;
+import net.minecraft.item.Items;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.common.extensions.IForgeContainerType;
+import net.minecraftforge.fluids.FluidAttributes;
+import net.minecraftforge.fluids.ForgeFlowingFluid;
+import net.minecraftforge.fml.RegistryObject;
+import net.minecraftforge.registries.DeferredRegister;
+import net.minecraftforge.registries.ForgeRegistries;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.block.enums.BloodRuneType;
+import wayoftime.bloodmagic.common.item.BloodMagicItems;
+import wayoftime.bloodmagic.ritual.EnumRuneType;
+import wayoftime.bloodmagic.tile.contailer.ContainerAlchemicalReactionChamber;
+import wayoftime.bloodmagic.tile.contailer.ContainerSoulForge;
+
+public class BloodMagicBlocks
+{
+	public static final ResourceLocation FLUID_STILL = new ResourceLocation("bloodmagic:block/lifeessencestill");
+	public static final ResourceLocation FLUID_FLOWING = new ResourceLocation("bloodmagic:block/lifeessenceflowing");
+
+	public static final DeferredRegister<Block> BLOCKS = DeferredRegister.create(ForgeRegistries.BLOCKS, BloodMagic.MODID);
+	public static final DeferredRegister<Block> BASICBLOCKS = DeferredRegister.create(ForgeRegistries.BLOCKS, BloodMagic.MODID);
+	public static final DeferredRegister<Item> ITEMS = BloodMagicItems.ITEMS;
+	public static final DeferredRegister<Fluid> FLUIDS = DeferredRegister.create(ForgeRegistries.FLUIDS, BloodMagic.MODID);
+	public static final DeferredRegister<ContainerType<?>> CONTAINERS = DeferredRegister.create(ForgeRegistries.CONTAINERS, BloodMagic.MODID);
+
+//	public static final RegistryObject<Block> BLOODSTONE = BASICBLOCKS.register("ruby_block", BloodstoneBlock::new);
+	public static final RegistryObject<Block> SOUL_FORGE = BLOCKS.register("soulforge", BlockSoulForge::new);
+	public static final RegistryObject<Block> ALCHEMY_ARRAY = BLOCKS.register("alchemyarray", BlockAlchemyArray::new);
+	public static final RegistryObject<Block> BLANK_RUNE = BASICBLOCKS.register("blankrune", () -> new BlockBloodRune(BloodRuneType.BLANK));
+	public static final RegistryObject<Block> SPEED_RUNE = BASICBLOCKS.register("speedrune", () -> new BlockBloodRune(BloodRuneType.SPEED));
+	public static final RegistryObject<Block> SACRIFICE_RUNE = BASICBLOCKS.register("sacrificerune", () -> new BlockBloodRune(BloodRuneType.SACRIFICE));
+	public static final RegistryObject<Block> SELF_SACRIFICE_RUNE = BASICBLOCKS.register("selfsacrificerune", () -> new BlockBloodRune(BloodRuneType.SELF_SACRIFICE));
+	public static final RegistryObject<Block> DISPLACEMENT_RUNE = BASICBLOCKS.register("dislocationrune", () -> new BlockBloodRune(BloodRuneType.DISPLACEMENT));
+	public static final RegistryObject<Block> CAPACITY_RUNE = BASICBLOCKS.register("altarcapacityrune", () -> new BlockBloodRune(BloodRuneType.CAPACITY));
+	public static final RegistryObject<Block> AUGMENTED_CAPACITY_RUNE = BASICBLOCKS.register("bettercapacityrune", () -> new BlockBloodRune(BloodRuneType.AUGMENTED_CAPACITY));
+	public static final RegistryObject<Block> ORB_RUNE = BASICBLOCKS.register("orbcapacityrune", () -> new BlockBloodRune(BloodRuneType.ORB));
+	public static final RegistryObject<Block> ACCELERATION_RUNE = BASICBLOCKS.register("accelerationrune", () -> new BlockBloodRune(BloodRuneType.ACCELERATION));
+	public static final RegistryObject<Block> CHARGING_RUNE = BASICBLOCKS.register("chargingrune", () -> new BlockBloodRune(BloodRuneType.CHARGING));
+
+	public static final RegistryObject<Block> BLOOD_ALTAR = BLOCKS.register("altar", () -> new BlockAltar());
+	public static final RegistryObject<Block> BLOOD_LIGHT = BLOCKS.register("bloodlight", () -> new BlockBloodLight());
+
+	public static final RegistryObject<Block> BLANK_RITUAL_STONE = BLOCKS.register("ritualstone", () -> new BlockRitualStone(EnumRuneType.BLANK));
+	public static final RegistryObject<Block> AIR_RITUAL_STONE = BLOCKS.register("airritualstone", () -> new BlockRitualStone(EnumRuneType.AIR));
+	public static final RegistryObject<Block> WATER_RITUAL_STONE = BLOCKS.register("waterritualstone", () -> new BlockRitualStone(EnumRuneType.WATER));
+	public static final RegistryObject<Block> FIRE_RITUAL_STONE = BLOCKS.register("fireritualstone", () -> new BlockRitualStone(EnumRuneType.FIRE));
+	public static final RegistryObject<Block> EARTH_RITUAL_STONE = BLOCKS.register("earthritualstone", () -> new BlockRitualStone(EnumRuneType.EARTH));
+	public static final RegistryObject<Block> DUSK_RITUAL_STONE = BLOCKS.register("duskritualstone", () -> new BlockRitualStone(EnumRuneType.DUSK));
+	public static final RegistryObject<Block> DAWN_RITUAL_STONE = BLOCKS.register("lightritualstone", () -> new BlockRitualStone(EnumRuneType.DAWN));
+
+	public static final RegistryObject<Block> MASTER_RITUAL_STONE = BASICBLOCKS.register("masterritualstone", () -> new BlockMasterRitualStone(false));
+
+	public static final RegistryObject<Block> ALCHEMICAL_REACTION_CHAMBER = BLOCKS.register("alchemicalreactionchamber", () -> new BlockAlchemicalReactionChamber());
+
+	private static ForgeFlowingFluid.Properties makeProperties()
+	{
+		return new ForgeFlowingFluid.Properties(LIFE_ESSENCE_FLUID, LIFE_ESSENCE_FLUID_FLOWING, FluidAttributes.builder(FLUID_STILL, FLUID_FLOWING)).bucket(LIFE_ESSENCE_BUCKET).block(LIFE_ESSENCE_BLOCK);
+	}
+
+	public static RegistryObject<FlowingFluid> LIFE_ESSENCE_FLUID = FLUIDS.register("life_essence_fluid", () -> new ForgeFlowingFluid.Source(makeProperties()));
+	public static RegistryObject<FlowingFluid> LIFE_ESSENCE_FLUID_FLOWING = FLUIDS.register("life_essence_fluid_flowing", () -> new ForgeFlowingFluid.Flowing(makeProperties()));
+
+	public static RegistryObject<FlowingFluidBlock> LIFE_ESSENCE_BLOCK = BLOCKS.register("life_essence_block", () -> new FlowingFluidBlock(LIFE_ESSENCE_FLUID, Block.Properties.create(net.minecraft.block.material.Material.WATER).doesNotBlockMovement().hardnessAndResistance(100.0F).noDrops()));
+	public static RegistryObject<Item> LIFE_ESSENCE_BUCKET = ITEMS.register("life_essence_bucket", () -> new BucketItem(LIFE_ESSENCE_FLUID, new Item.Properties().containerItem(Items.BUCKET).maxStackSize(1).group(BloodMagic.TAB)));
+
+	public static final RegistryObject<ContainerType<ContainerSoulForge>> SOUL_FORGE_CONTAINER = CONTAINERS.register("soul_forge_container", () -> IForgeContainerType.create(ContainerSoulForge::new));
+	public static final RegistryObject<ContainerType<ContainerAlchemicalReactionChamber>> ARC_CONTAINER = CONTAINERS.register("arc_container", () -> IForgeContainerType.create(ContainerAlchemicalReactionChamber::new));
+//	public static final RegistryObject<BloodstoneBlock> BLOOD_STONE = registerNoItem("blood_stone", () -> new BloodstoneBlock());
+//			
+////	private static <T extends Block> RegistryObject<T> register(String name, Supplier<? extends T> sup, Function<RegistryObject<T>, Supplier<? extends Item>> itemCreator) 
+////	{
+////	    RegistryObject<T> ret = registerNoItem(name, sup);
+////	    ITEMS.register(name, itemCreator.apply(ret));
+////	    return ret;
+////	}
+//	
+//	private static <T extends Block> RegistryObject<T> register(String name, Supplier<? extends T> sup, Function<RegistryObject<T>, Supplier<? extends Item>> itemCreator)
+//	{
+//		RegistryObject<T> ret = registerNoItem(name, sup);
+//	    ITEMS.register(name, itemCreator.apply(ret));
+//	    return ret;
+//	}
+//
+//	private static <T extends Block> RegistryObject<T> registerNoItem(String name, Supplier<? extends T> sup) 
+//	{
+//	    return BLOCKS.register(name, sup);
+//	}
+
+//	  private static Supplier<BlockItem> item(final RegistryObject<? extends Block> block, final Supplier<Callable<ItemStackTileEntityRenderer>> renderMethod) 
+//	  {
+//	    return () -> new BlockItem(block.get(), new Item.Properties().group(IronChests.IRONCHESTS_ITEM_GROUP).setISTER(renderMethod));
+//	  }
+}

src/main/java/wayoftime/bloodmagic/common/block/BloodstoneBlock.java

@@ -0,0 +1,13 @@
+package wayoftime.bloodmagic.common.block;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+
+public class BloodstoneBlock extends Block
+{
+	public BloodstoneBlock() 
+	{
+		super(Properties.create(Material.ROCK));
+		// TODO Auto-generated constructor stub
+	}
+}

src/main/java/wayoftime/bloodmagic/common/data/GeneratorBaseRecipes.java

@@ -0,0 +1,57 @@
+package wayoftime.bloodmagic.common.data;
+
+import java.util.function.Consumer;
+
+import net.minecraft.data.DataGenerator;
+import net.minecraft.data.IFinishedRecipe;
+import net.minecraft.data.ShapedRecipeBuilder;
+import net.minecraft.item.Items;
+import net.minecraft.item.crafting.Ingredient;
+import net.minecraftforge.common.Tags;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.common.block.BloodMagicBlocks;
+import wayoftime.bloodmagic.common.data.recipe.BaseRecipeProvider;
+import wayoftime.bloodmagic.common.item.BloodMagicItems;
+import wayoftime.bloodmagic.core.recipe.IngredientBloodOrb;
+
+public class GeneratorBaseRecipes extends BaseRecipeProvider
+{
+	public GeneratorBaseRecipes(DataGenerator gen)
+	{
+		super(gen, BloodMagic.MODID);
+	}
+
+	@Override
+	protected void registerRecipes(Consumer<IFinishedRecipe> consumer)
+	{
+		addVanillaRecipes(consumer);
+		addBloodOrbRecipes(consumer);
+	}
+
+	private void addVanillaRecipes(Consumer<IFinishedRecipe> consumer)
+	{
+		ShapedRecipeBuilder.shapedRecipe(BloodMagicItems.SACRIFICIAL_DAGGER.get()).key('g', Tags.Items.GLASS).key('G', Tags.Items.INGOTS_GOLD).key('i', Tags.Items.INGOTS_IRON).patternLine("ggg").patternLine(" Gg").patternLine("i g").addCriterion("has_glass", hasItem(Items.GLASS)).build(consumer, BloodMagic.rl("sacrificial_dagger"));
+		ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.BLOOD_ALTAR.get()).key('a', Tags.Items.STONE).key('b', Items.FURNACE).key('c', Tags.Items.INGOTS_GOLD).key('d', BloodMagicItems.MONSTER_SOUL_RAW.get()).patternLine("a a").patternLine("aba").patternLine("cdc").addCriterion("has_will", hasItem(BloodMagicItems.MONSTER_SOUL_RAW.get())).build(consumer, BloodMagic.rl("blood_altar"));
+		ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.SOUL_FORGE.get()).key('s', Tags.Items.STONE).key('g', Tags.Items.INGOTS_GOLD).key('i', Tags.Items.INGOTS_IRON).key('o', Tags.Items.STORAGE_BLOCKS_IRON).patternLine("i i").patternLine("sgs").patternLine("sos").addCriterion("has_gold", hasItem(Items.GOLD_INGOT)).build(consumer, BloodMagic.rl("soul_forge"));
+		ShapedRecipeBuilder.shapedRecipe(BloodMagicItems.SOUL_SNARE.get(), 4).key('r', Tags.Items.DUSTS_REDSTONE).key('s', Tags.Items.STRING).key('i', Tags.Items.INGOTS_IRON).patternLine("sis").patternLine("iri").patternLine("sis").addCriterion("has_redstone", hasItem(Items.REDSTONE)).build(consumer, BloodMagic.rl("soul_snare"));
+		ShapedRecipeBuilder.shapedRecipe(BloodMagicItems.BASE_RITUAL_DIVINER.get()).key('a', BloodMagicItems.AIR_INSCRIPTION_TOOL.get()).key('s', Tags.Items.RODS_WOODEN).key('d', Tags.Items.GEMS_DIAMOND).key('e', BloodMagicItems.EARTH_INSCRIPTION_TOOL.get()).key('f', BloodMagicItems.FIRE_INSCRIPTION_TOOL.get()).key('w', BloodMagicItems.WATER_INSCRIPTION_TOOL.get()).patternLine("dfd").patternLine("ase").patternLine("dwd").addCriterion("has_scribe", hasItem(BloodMagicItems.AIR_INSCRIPTION_TOOL.get())).build(consumer, BloodMagic.rl("ritual_diviner_0"));
+		ShapedRecipeBuilder.shapedRecipe(BloodMagicItems.DUSK_RITUAL_DIVINER.get()).key('S', BloodMagicItems.DEMONIC_SLATE.get()).key('t', BloodMagicItems.DUSK_INSCRIPTION_TOOL.get()).key('d', BloodMagicItems.BASE_RITUAL_DIVINER.get()).patternLine(" S ").patternLine("tdt").patternLine(" S ").addCriterion("has_demon_slate", hasItem(BloodMagicItems.DEMONIC_SLATE.get())).build(consumer, BloodMagic.rl("ritual_diviner_1"));
+	}
+
+	private void addBloodOrbRecipes(Consumer<IFinishedRecipe> consumer)
+	{
+		ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.BLANK_RUNE.get()).key('a', Tags.Items.STONE).key('s', Ingredient.fromItems(BloodMagicItems.SLATE.get())).key('o', IngredientBloodOrb.fromOrb(BloodMagicItems.ORB_WEAK.get())).patternLine("aaa").patternLine("sos").patternLine("aaa").addCriterion("has_weak_orb", hasItem(BloodMagicItems.WEAK_BLOOD_ORB.get())).build(consumer, BloodMagic.rl("blood_rune_blank"));
+		ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.SPEED_RUNE.get()).key('a', Tags.Items.STONE).key('b', Ingredient.fromItems(BloodMagicItems.SLATE.get())).key('c', Ingredient.fromItems(Items.SUGAR)).key('d', BloodMagicBlocks.BLANK_RUNE.get()).patternLine("aba").patternLine("cdc").patternLine("aba").addCriterion("has_blank_rune", hasItem(BloodMagicItems.BLANK_RUNE_ITEM.get())).build(consumer, BloodMagic.rl("blood_rune_speed"));
+		ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.SACRIFICE_RUNE.get()).key('a', Tags.Items.STONE).key('b', BloodMagicItems.REINFORCED_SLATE.get()).key('c', Tags.Items.INGOTS_GOLD).key('d', BloodMagicBlocks.BLANK_RUNE.get()).key('e', IngredientBloodOrb.fromOrb(BloodMagicItems.ORB_APPRENTICE.get())).patternLine("aba").patternLine("cdc").patternLine("aea").addCriterion("has_apprentice_orb", hasItem(BloodMagicItems.APPRENTICE_BLOOD_ORB.get())).build(consumer, BloodMagic.rl("blood_rune_sacrifice"));
+		ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.SELF_SACRIFICE_RUNE.get()).key('a', Tags.Items.STONE).key('b', Ingredient.fromItems(BloodMagicItems.REINFORCED_SLATE.get())).key('c', Ingredient.fromItems(Items.GLOWSTONE_DUST)).key('d', Ingredient.fromItems(BloodMagicItems.BLANK_RUNE_ITEM.get())).key('e', IngredientBloodOrb.fromOrb(BloodMagicItems.ORB_APPRENTICE.get())).patternLine("aba").patternLine("cdc").patternLine("aea").addCriterion("has_apprentice_orb", hasItem(BloodMagicItems.APPRENTICE_BLOOD_ORB.get())).build(consumer, BloodMagic.rl("blood_rune_self_sacrifice"));
+		ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.CAPACITY_RUNE.get()).key('a', Tags.Items.STONE).key('b', Items.BUCKET).key('c', BloodMagicBlocks.BLANK_RUNE.get()).key('d', BloodMagicItems.IMBUED_SLATE.get()).patternLine("aba").patternLine("bcb").patternLine("ada").addCriterion("has_imbued_slate", hasItem(BloodMagicItems.IMBUED_SLATE.get())).build(consumer, BloodMagic.rl("blood_rune_capacity"));
+		ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.ORB_RUNE.get()).key('a', Tags.Items.STONE).key('b', IngredientBloodOrb.fromOrb(BloodMagicItems.ORB_WEAK.get())).key('c', BloodMagicBlocks.BLANK_RUNE.get()).key('d', IngredientBloodOrb.fromOrb(BloodMagicItems.ORB_MASTER.get())).patternLine("aba").patternLine("cdc").patternLine("aba").addCriterion("has_master_orb", hasItem(BloodMagicItems.MASTER_BLOOD_ORB.get())).build(consumer, BloodMagic.rl("blood_rune_orb"));
+		ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.CHARGING_RUNE.get()).key('R', Tags.Items.DUSTS_REDSTONE).key('r', BloodMagicBlocks.BLANK_RUNE.get()).key('s', BloodMagicItems.DEMONIC_SLATE.get()).key('e', IngredientBloodOrb.fromOrb(BloodMagicItems.ORB_MASTER.get())).key('G', Tags.Items.DUSTS_GLOWSTONE).patternLine("RsR").patternLine("GrG").patternLine("ReR").addCriterion("has_master_orb", hasItem(BloodMagicItems.MASTER_BLOOD_ORB.get())).build(consumer, BloodMagic.rl("blood_rune_charging"));
+		ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.BLANK_RITUAL_STONE.get(), 4).key('a', Tags.Items.OBSIDIAN).key('b', BloodMagicItems.REINFORCED_SLATE.get()).key('c', IngredientBloodOrb.fromOrb(BloodMagicItems.ORB_APPRENTICE.get())).patternLine("aba").patternLine("bcb").patternLine("aba").addCriterion("has_apprentice_orb", hasItem(BloodMagicItems.APPRENTICE_BLOOD_ORB.get())).build(consumer, BloodMagic.rl("ritual_stone_blank"));
+		ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.MASTER_RITUAL_STONE.get()).key('a', Tags.Items.OBSIDIAN).key('b', BloodMagicBlocks.BLANK_RITUAL_STONE.get()).key('c', IngredientBloodOrb.fromOrb(BloodMagicItems.ORB_MAGICIAN.get())).patternLine("aba").patternLine("bcb").patternLine("aba").addCriterion("has_magician_orb", hasItem(BloodMagicItems.MAGICIAN_BLOOD_ORB.get())).build(consumer, BloodMagic.rl("ritual_stone_master"));
+
+		ShapedRecipeBuilder.shapedRecipe(BloodMagicItems.LAVA_CRYSTAL.get()).key('a', Tags.Items.GLASS).key('b', Items.LAVA_BUCKET).key('c', IngredientBloodOrb.fromOrb(BloodMagicItems.ORB_WEAK.get())).key('d', Tags.Items.OBSIDIAN).key('e', Tags.Items.GEMS_DIAMOND).patternLine("aba").patternLine("bcb").patternLine("ded").addCriterion("has_weak_orb", hasItem(BloodMagicItems.WEAK_BLOOD_ORB.get())).build(consumer, BloodMagic.rl("lava_crystal"));
+//		ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.SPEED_RUNE.get()).key('s', Items.GLASS).key('o', Ingredient.fromItems(Items.DIAMOND)).patternLine("sss").patternLine("sos").patternLine("sss").addCriterion("has_diamond", hasItem(Items.DIAMOND)).build(consumer, new ResourceLocation(BloodMagic.MODID, "speed_rune_from_standard"));
+//		ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.SPEED_RUNE.get()).key('s', Items.GLASS).key('o', IngredientBloodOrb.fromOrb(BloodMagicItems.ORB_WEAK.get())).patternLine("sss").patternLine("sos").patternLine("sss").addCriterion("has_diamond", hasItem(Items.DIAMOND)).build(consumer, new ResourceLocation(BloodMagic.MODID, "speed_rune_from_orb"));
+	}
+}

src/main/java/wayoftime/bloodmagic/common/data/GeneratorBlockStates.java

@@ -0,0 +1,70 @@
+package wayoftime.bloodmagic.common.data;
+
+import net.minecraft.block.Block;
+import net.minecraft.data.DataGenerator;
+import net.minecraft.util.Direction;
+import net.minecraftforge.client.model.generators.BlockStateProvider;
+import net.minecraftforge.client.model.generators.ConfiguredModel;
+import net.minecraftforge.client.model.generators.ModelFile;
+import net.minecraftforge.client.model.generators.VariantBlockStateBuilder;
+import net.minecraftforge.common.data.ExistingFileHelper;
+import net.minecraftforge.fml.RegistryObject;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.common.block.BlockAlchemicalReactionChamber;
+import wayoftime.bloodmagic.common.block.BloodMagicBlocks;
+
+public class GeneratorBlockStates extends BlockStateProvider
+{
+	public GeneratorBlockStates(DataGenerator gen, ExistingFileHelper exFileHelper)
+	{
+		super(gen, BloodMagic.MODID, exFileHelper);
+	}
+
+	@Override
+	protected void registerStatesAndModels()
+	{
+//		buildCubeAll(BloodMagicBlocks.TARTARICFORGE.get());
+//		buildCubeAll(BloodMagicBlocks.SPEED_RUNE.get());
+
+		for (RegistryObject<Block> block : BloodMagicBlocks.BASICBLOCKS.getEntries())
+		{
+			buildCubeAll(block.get());
+		}
+
+		buildCubeAll(BloodMagicBlocks.BLOOD_LIGHT.get());
+		buildCubeAll(BloodMagicBlocks.BLANK_RITUAL_STONE.get());
+		buildCubeAll(BloodMagicBlocks.AIR_RITUAL_STONE.get());
+		buildCubeAll(BloodMagicBlocks.WATER_RITUAL_STONE.get());
+		buildCubeAll(BloodMagicBlocks.FIRE_RITUAL_STONE.get());
+		buildCubeAll(BloodMagicBlocks.EARTH_RITUAL_STONE.get());
+		buildCubeAll(BloodMagicBlocks.DUSK_RITUAL_STONE.get());
+		buildCubeAll(BloodMagicBlocks.DAWN_RITUAL_STONE.get());
+
+		buildFurnace(BloodMagicBlocks.ALCHEMICAL_REACTION_CHAMBER.get());
+	}
+
+	private void buildCubeAll(Block block)
+	{
+		getVariantBuilder(block).forAllStates(state -> ConfiguredModel.builder().modelFile(cubeAll(block)).build());
+	}
+
+	private void buildFurnace(Block block)
+	{
+//		ConfiguredModel[] furnaceModel = ConfiguredModel.builder().modelFile().build();
+		ModelFile furnace_off = models().orientableWithBottom("alchemicalreactionchamber", BloodMagic.rl("block/arc_side"), BloodMagic.rl("block/arc_front"), BloodMagic.rl("block/arc_bottom"), BloodMagic.rl("block/arc_top"));
+//		getVariantBuilder(block).addModels(block.getDefaultState().with(BlockAlchemicalReactionChamber.FACING, Direction.NORTH).with(BlockAlchemicalReactionChamber.LIT, false), furnaceModel);
+
+		VariantBlockStateBuilder builder = getVariantBuilder(block);
+
+		builder.partialState().with(BlockAlchemicalReactionChamber.FACING, Direction.NORTH).with(BlockAlchemicalReactionChamber.LIT, false).modelForState().modelFile(furnace_off).addModel();
+		builder.partialState().with(BlockAlchemicalReactionChamber.FACING, Direction.EAST).with(BlockAlchemicalReactionChamber.LIT, false).modelForState().modelFile(furnace_off).rotationY(90).addModel();
+		builder.partialState().with(BlockAlchemicalReactionChamber.FACING, Direction.SOUTH).with(BlockAlchemicalReactionChamber.LIT, false).modelForState().modelFile(furnace_off).rotationY(180).addModel();
+		builder.partialState().with(BlockAlchemicalReactionChamber.FACING, Direction.WEST).with(BlockAlchemicalReactionChamber.LIT, false).modelForState().modelFile(furnace_off).rotationY(270).addModel();
+		builder.partialState().with(BlockAlchemicalReactionChamber.FACING, Direction.NORTH).with(BlockAlchemicalReactionChamber.LIT, true).modelForState().modelFile(furnace_off).addModel();
+		builder.partialState().with(BlockAlchemicalReactionChamber.FACING, Direction.EAST).with(BlockAlchemicalReactionChamber.LIT, true).modelForState().modelFile(furnace_off).rotationY(90).addModel();
+		builder.partialState().with(BlockAlchemicalReactionChamber.FACING, Direction.SOUTH).with(BlockAlchemicalReactionChamber.LIT, true).modelForState().modelFile(furnace_off).rotationY(180).addModel();
+		builder.partialState().with(BlockAlchemicalReactionChamber.FACING, Direction.WEST).with(BlockAlchemicalReactionChamber.LIT, true).modelForState().modelFile(furnace_off).rotationY(270).addModel();
+
+//		getVariantBuilder(block).
+	}
+}

src/main/java/wayoftime/bloodmagic/common/data/GeneratorBlockTags.java

@@ -0,0 +1,40 @@
+package wayoftime.bloodmagic.common.data;
+
+import java.nio.file.Path;
+
+import net.minecraft.data.BlockTagsProvider;
+import net.minecraft.data.DataGenerator;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.common.data.ExistingFileHelper;
+import wayoftime.bloodmagic.BloodMagic;
+
+public class GeneratorBlockTags extends BlockTagsProvider
+{
+	public GeneratorBlockTags(DataGenerator generatorIn, ExistingFileHelper exFileHelper)
+	{
+		super(generatorIn, BloodMagic.MODID, exFileHelper);
+	}
+
+	@Override
+	public void registerTags()
+	{
+	}
+
+	/**
+	 * Resolves a Path for the location to save the given tag.
+	 */
+	@Override
+	protected Path makePath(ResourceLocation id)
+	{
+		return this.generator.getOutputFolder().resolve("data/" + id.getNamespace() + "/tags/blocks/" + id.getPath() + ".json");
+	}
+
+	/**
+	 * Gets a name for this provider, to use in logging.
+	 */
+	@Override
+	public String getName()
+	{
+		return "Block Tags";
+	}
+}

src/main/java/wayoftime/bloodmagic/common/data/GeneratorItemModels.java

@@ -0,0 +1,114 @@
+package wayoftime.bloodmagic.common.data;
+
+import net.minecraft.block.Block;
+import net.minecraft.data.DataGenerator;
+import net.minecraft.item.Item;
+import net.minecraftforge.client.model.generators.ItemModelBuilder;
+import net.minecraftforge.client.model.generators.ItemModelProvider;
+import net.minecraftforge.client.model.generators.ModelFile;
+import net.minecraftforge.common.data.ExistingFileHelper;
+import net.minecraftforge.fml.RegistryObject;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.common.block.BloodMagicBlocks;
+import wayoftime.bloodmagic.common.item.BloodMagicItems;
+import wayoftime.bloodmagic.will.EnumDemonWillType;
+
+public class GeneratorItemModels extends ItemModelProvider
+{
+	public GeneratorItemModels(DataGenerator generator, ExistingFileHelper existingFileHelper)
+	{
+		super(generator, BloodMagic.MODID, existingFileHelper);
+	}
+
+	@Override
+	protected void registerModels()
+	{
+//		registerBlockModel(BloodMagicBlocks.TARTARICFORGE.get());
+//		registerBlockModel(BloodMagicBlocks.SPEED_RUNE.get());
+
+		for (RegistryObject<Item> item : BloodMagicItems.BASICITEMS.getEntries())
+		{
+			registerBasicItem(item.get());
+		}
+
+		for (RegistryObject<Block> block : BloodMagicBlocks.BASICBLOCKS.getEntries())
+		{
+			registerBlockModel(block.get());
+		}
+
+		registerBlockModel(BloodMagicBlocks.BLANK_RITUAL_STONE.get());
+		registerBlockModel(BloodMagicBlocks.AIR_RITUAL_STONE.get());
+		registerBlockModel(BloodMagicBlocks.WATER_RITUAL_STONE.get());
+		registerBlockModel(BloodMagicBlocks.FIRE_RITUAL_STONE.get());
+		registerBlockModel(BloodMagicBlocks.EARTH_RITUAL_STONE.get());
+		registerBlockModel(BloodMagicBlocks.DUSK_RITUAL_STONE.get());
+		registerBlockModel(BloodMagicBlocks.DAWN_RITUAL_STONE.get());
+		registerBlockModel(BloodMagicBlocks.ALCHEMICAL_REACTION_CHAMBER.get());
+
+		registerToggleableItem(BloodMagicItems.GREEN_GROVE_SIGIL.get());
+		registerToggleableItem(BloodMagicItems.FAST_MINER_SIGIL.get());
+		registerToggleableItem(BloodMagicItems.MAGNETISM_SIGIL.get());
+		registerToggleableItem(BloodMagicItems.ICE_SIGIL.get());
+		registerDemonWillVariantItem(BloodMagicItems.PETTY_GEM.get());
+		registerDemonWillVariantItem(BloodMagicItems.LESSER_GEM.get());
+		registerDemonWillVariantItem(BloodMagicItems.COMMON_GEM.get());
+		registerDemonSword(BloodMagicItems.SENTIENT_SWORD.get());
+	}
+
+	private void registerBlockModel(Block block)
+	{
+		String path = block.getRegistryName().getPath();
+		getBuilder(path).parent(new ModelFile.UncheckedModelFile(modLoc("block/" + path)));
+	}
+
+	private void registerBasicItem(Item item)
+	{
+		String path = item.getRegistryName().getPath();
+		singleTexture(path, mcLoc("item/handheld"), "layer0", modLoc("item/" + path));
+	}
+
+	private void registerToggleableItem(Item item)
+	{
+		String path = item.getRegistryName().getPath();
+		ModelFile activatedFile = singleTexture("item/variants/" + path + "_activated", mcLoc("item/handheld"), "layer0", modLoc("item/" + path + "_activated"));
+		ModelFile deactivatedFile = singleTexture("item/variants/" + path + "_deactivated", mcLoc("item/handheld"), "layer0", modLoc("item/" + path + "_deactivated"));
+		getBuilder(path).override().predicate(BloodMagic.rl("active"), 0).model(deactivatedFile).end().override().predicate(BloodMagic.rl("active"), 1).model(activatedFile).end();
+	}
+
+	private void registerDemonWillVariantItem(Item item)
+	{
+		String path = item.getRegistryName().getPath();
+		ItemModelBuilder builder = getBuilder(path);
+
+		for (EnumDemonWillType type : EnumDemonWillType.values())
+		{
+			String name = "";
+			if (type.ordinal() != 0)
+			{
+				name = "_" + type.name().toLowerCase();
+			}
+			ModelFile willFile = singleTexture("item/variants/" + path + name, mcLoc("item/handheld"), "layer0", modLoc("item/" + path + name));
+			builder = builder.override().predicate(BloodMagic.rl("type"), type.ordinal()).model(willFile).end();
+		}
+	}
+
+	private void registerDemonSword(Item item)
+	{
+		String path = item.getRegistryName().getPath();
+		ItemModelBuilder builder = getBuilder(path);
+
+		for (int i = 0; i <= 1; i++)
+		{
+			for (EnumDemonWillType type : EnumDemonWillType.values())
+			{
+				String name = i == 0 ? "_deactivated" : "_activated";
+				if (type.ordinal() != 0)
+				{
+					name = "_" + type.name().toLowerCase() + name;
+				}
+				ModelFile willFile = singleTexture("item/variants/" + path + name, mcLoc("item/handheld"), "layer0", modLoc("item/" + path + name));
+				builder = builder.override().predicate(BloodMagic.rl("type"), type.ordinal()).predicate(BloodMagic.rl("active"), i).model(willFile).end();
+			}
+		}
+	}
+}

src/main/java/wayoftime/bloodmagic/common/data/GeneratorItemTags.java

@@ -0,0 +1,48 @@
+package wayoftime.bloodmagic.common.data;
+
+import java.nio.file.Path;
+
+import net.minecraft.data.BlockTagsProvider;
+import net.minecraft.data.DataGenerator;
+import net.minecraft.data.ItemTagsProvider;
+import net.minecraft.item.Items;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.common.data.ExistingFileHelper;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.common.tags.BloodMagicTags;
+
+public class GeneratorItemTags extends ItemTagsProvider
+{
+	public GeneratorItemTags(DataGenerator dataGenerator, BlockTagsProvider blockTagProvider, ExistingFileHelper existingFileHelper)
+	{
+		super(dataGenerator, blockTagProvider, BloodMagic.MODID, existingFileHelper);
+	}
+
+	@Override
+	public void registerTags()
+	{
+		this.getOrCreateBuilder(BloodMagicTags.ARC_TOOL).add(Items.DIAMOND);
+//		this.getOrCreateBuilder(GOORESISTANT).addTag(BlockTags.DOORS);
+//		this.getOrCreateBuilder(GOORESISTANT).addTag(BlockTags.BEDS);
+//		this.getOrCreateBuilder(GOORESISTANT).add(Blocks.PISTON, Blocks.PISTON_HEAD, Blocks.STICKY_PISTON, Blocks.MOVING_PISTON);
+
+	}
+
+	/**
+	 * Resolves a Path for the location to save the given tag.
+	 */
+	@Override
+	protected Path makePath(ResourceLocation id)
+	{
+		return this.generator.getOutputFolder().resolve("data/" + id.getNamespace() + "/tags/items/" + id.getPath() + ".json");
+	}
+
+	/**
+	 * Gets a name for this provider, to use in logging.
+	 */
+	@Override
+	public String getName()
+	{
+		return "Item Tags";
+	}
+}

src/main/java/wayoftime/bloodmagic/common/data/GeneratorLanguage.java

@@ -0,0 +1,249 @@
+package wayoftime.bloodmagic.common.data;
+
+import net.minecraft.data.DataGenerator;
+import net.minecraftforge.common.data.LanguageProvider;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.common.block.BloodMagicBlocks;
+import wayoftime.bloodmagic.common.item.BloodMagicItems;
+
+public class GeneratorLanguage extends LanguageProvider
+{
+	public GeneratorLanguage(DataGenerator gen)
+	{
+		super(gen, BloodMagic.MODID, "en_us");
+	}
+
+	@Override
+	protected void addTranslations()
+	{
+		// Creative Tab
+		add("itemGroup.bloodmagic.creativeTab", "Blood Magic");
+
+		add("chat.bloodmagic.damageSource", "%s's soul became too weak");
+
+		// Tile Entitites
+		add("tile.bloodmagic.soulforge.name", "Hellfire Forge");
+		add("tile.bloodmagic.arc.name", "Alchemical Reaction Chamber");
+
+		// Blood Orb tooltips
+		add("tooltip.bloodmagic.extraInfo", "&9-Hold shift for more info-");
+		add("tooltip.bloodmagic.orb.desc", "Stores raw Life Essence");
+		add("tooltip.bloodmagic.orb.owner", "Added by: %s");
+		add("tooltip.bloodmagic.currentOwner", "Current owner: %s");
+		add("tooltip.bloodmagic.currentTier", "Current tier: %d");
+		add("tooltip.bloodmagic.config.disabled", "Currently disabled in the Config");
+		add("tooltip.bloodmagic.tier", "Tier %d");
+
+		// Sigil tooltips
+		add("tooltip.bloodmagic.sigil.divination.desc", "Peer into the soul");
+		add("tooltip.bloodmagic.sigil.divination.otherNetwork", "Peering into the soul of %s");
+		add("tooltip.bloodmagic.sigil.divination.currentAltarTier", "Current Tier: %d");
+		add("tooltip.bloodmagic.sigil.divination.currentEssence", "Current Essence: %d LP");
+		add("tooltip.bloodmagic.sigil.divination.currentAltarCapacity", "Current Capacity: %d LP");
+		add("tooltip.bloodmagic.sigil.divination.currentTranquility", "Current Tranquility: %d");
+//		add("tooltip.bloodmagic.sigil.divination.currentInversion", "Current Inversion: %d");
+		add("tooltip.bloodmagic.sigil.divination.currentBonus", "Current Bonus: +%d%%");
+
+		add("tooltip.bloodmagic.decoration.safe", "Safe for decoration");
+		add("tooltip.bloodmagic.decoration.notSafe", "Dangerous for decoration");
+
+		// General Tooltips
+		add("tooltip.bloodmagic.arcaneAshes", "Ashes used to draw an alchemy circle");
+		add("tooltip.bloodmagic.will", "Will Quality: %s");
+		add("tooltip.bloodmagic.sentientSword.desc", "Uses demon will to unleash its full potential.");
+		add("tooltip.bloodmagic.sentientAxe.desc", "Uses demon will to unleash its full potential.");
+		add("tooltip.bloodmagic.sentientPickaxe.desc", "Uses demon will to unleash its full potential.");
+		add("tooltip.bloodmagic.sentientShovel.desc", "Uses demon will to unleash its full potential.");
+		add("tooltip.bloodmagic.soulGem.petty", "A gem used to contain a little will");
+		add("tooltip.bloodmagic.soulGem.lesser", "A gem used to contain some will");
+		add("tooltip.bloodmagic.soulGem.common", "A gem used to contain more will");
+		add("tooltip.bloodmagic.soulGem.greater", "A gem used to contain a greater amount of will");
+		add("tooltip.bloodmagic.soulGem.grand", "A gem used to contain a large amount of will");
+		add("tooltip.bloodmagic.soulSnare.desc", "Throw at a monster and then kill them to obtain their demonic will");
+
+		add("tooltip.bloodmagic.currentType.default", "Contains: Raw Will");
+		add("tooltip.bloodmagic.currentType.corrosive", "Contains: Corrosive Will");
+		add("tooltip.bloodmagic.currentType.destructive", "Contains: Destructive Will");
+		add("tooltip.bloodmagic.currentType.vengeful", "Contains: Vengeful Will");
+		add("tooltip.bloodmagic.currentType.steadfast", "Contains: Steadfast Will");
+
+		add("tooltip.bloodmagic.currentBaseType.default", "Raw");
+		add("tooltip.bloodmagic.currentBaseType.corrosive", "Corrosive");
+		add("tooltip.bloodmagic.currentBaseType.destructive", "Destructive");
+		add("tooltip.bloodmagic.currentBaseType.vengeful", "Vengeful");
+		add("tooltip.bloodmagic.currentBaseType.steadfast", "Steadfast");
+		add("tooltip.bloodmagic.sacrificialdagger.desc", "Just a prick of the finger will suffice...");
+		add("tooltip.bloodmagic.slate.desc", "Infused stone inside of a Blood Altar");
+		add("tooltip.bloodmagic.inscriber.desc", "The writing is on the wall...");
+
+		add("tooltip.bloodmagic.sigil.water.desc", "Infinite water, anyone?");
+		add("tooltip.bloodmagic.sigil.lava.desc", "HOT! DO NOT EAT");
+		add("tooltip.bloodmagic.sigil.void.desc", "Better than a Swiffer®!");
+		add("tooltip.bloodmagic.sigil.greengrove.desc", "Environmentally friendly");
+		add("tooltip.bloodmagic.sigil.magnetism.desc", "I have a very magnetic personality");
+		add("tooltip.bloodmagic.sigil.fastminer.desc", "Keep mining, and mining...");
+		add("tooltip.bloodmagic.sigil.air.desc", "I feel lighter already...");
+		add("tooltip.bloodmagic.sigil.bloodlight.desc", "I see a light!");
+
+		add("tooltip.bloodmagic.activationcrystal.weak", "Activates low-level rituals");
+		add("tooltip.bloodmagic.activationcrystal.awakened", "Activates more powerful rituals");
+		add("tooltip.bloodmagic.activationcrystal.creative", "Creative Only - Activates any ritual");
+
+		add("itemGroup.bloodmagictab", "Blood Magic");
+
+		// Ritual info
+		add("tooltip.bloodmagic.diviner.currentRitual", "Current Ritual: %s");
+		add("tooltip.bloodmagic.diviner.blankRune", "Blank Runes: %d");
+		add("tooltip.bloodmagic.diviner.waterRune", "Water Runes: %d");
+		add("tooltip.bloodmagic.diviner.airRune", "Air Runes: %d");
+		add("tooltip.bloodmagic.diviner.fireRune", "Fire Runes: %d");
+		add("tooltip.bloodmagic.diviner.earthRune", "Earth Runes: %d");
+		add("tooltip.bloodmagic.diviner.duskRune", "Dusk Runes: %d");
+		add("tooltip.bloodmagic.diviner.dawnRune", "Dawn Runes: %d");
+		add("tooltip.bloodmagic.diviner.totalRune", "Total Runes: %d");
+		add("tooltip.bloodmagic.diviner.extraInfo", "Press shift for extra info");
+		add("tooltip.bloodmagic.diviner.extraExtraInfo", "-Hold shift + alt for augmentation info-");
+		add("tooltip.bloodmagic.diviner.currentDirection", "Current Direction: %s");
+
+		add("tooltip.bloodmagic.holdShiftForInfo", "Press shift for extra info");
+
+		add("ritual.bloodmagic.testRitual", "Test Ritual");
+		add("ritual.bloodmagic.waterRitual", "Ritual of the Full Spring");
+		add("ritual.bloodmagic.lavaRitual", "Serenade of the Nether");
+		add("ritual.bloodmagic.greenGroveRitual", "Ritual of the Green Grove");
+		add("ritual.bloodmagic.jumpRitual", "Ritual of the High Jump");
+		add("ritual.bloodmagic.wellOfSufferingRitual", "Well of Suffering");
+		add("ritual.bloodmagic.featheredKnifeRitual", "Ritual of the Feathered Knife");
+		add("ritual.bloodmagic.regenerationRitual", "Ritual of Regeneration");
+		add("ritual.bloodmagic.harvestRitual", "Reap of the Harvest Moon");
+		add("ritual.bloodmagic.magneticRitual", "Ritual of Magnetism");
+		add("ritual.bloodmagic.crushingRitual", "Ritual of the Crusher");
+		add("ritual.bloodmagic.fullStomachRitual", "Ritual of the Satiated Stomach");
+		add("ritual.bloodmagic.interdictionRitual", "Ritual of Interdiction");
+		add("ritual.bloodmagic.containmentRitual", "Ritual of Containment");
+		add("ritual.bloodmagic.speedRitual", "Ritual of Speed");
+		add("ritual.bloodmagic.suppressionRitual", "Ritual of Suppression");
+		add("ritual.bloodmagic.expulsionRitual", "Aura of Expulsion");
+		add("ritual.bloodmagic.zephyrRitual", "Call of the Zephyr");
+		add("ritual.bloodmagic.upgradeRemoveRitual", "Sound of the Cleansing Soul");
+		add("ritual.bloodmagic.armourEvolveRitual", "Ritual of Living Evolution");
+		add("ritual.bloodmagic.animalGrowthRitual", "Ritual of the Shepherd");
+
+		add("ritual.bloodmagic.cobblestoneRitual", "Le Vulcanos Frigius");
+		add("ritual.bloodmagic.placerRitual", "The Filler");
+		add("ritual.bloodmagic.fellingRitual", "The Timberman");
+		add("ritual.bloodmagic.pumpRitual", "Hymn of Siphoning");
+		add("ritual.bloodmagic.altarBuilderRitual", "The Assembly of the High Altar");
+		add("ritual.bloodmagic.portalRitual", "The Gate of the Fold");
+
+		// Guide
+		add("guide.bloodmagic.name", "Sanguine Scientiem");
+		add("guide.bloodmagic.landing_text", "\"It is my dear hope that by holding this tome in your hands, I may impart the knowledge of the lost art that is Blood Magic\"$(br)$(o)- Magus Arcana$()");
+
+		// Block names
+		addBlock(BloodMagicBlocks.BLANK_RUNE, "Blank Rune");
+		addBlock(BloodMagicBlocks.SPEED_RUNE, "Speed Rune");
+		addBlock(BloodMagicBlocks.SACRIFICE_RUNE, "Rune of Sacrifice");
+		addBlock(BloodMagicBlocks.SELF_SACRIFICE_RUNE, "Rune of Self Sacrifice");
+		addBlock(BloodMagicBlocks.DISPLACEMENT_RUNE, "DisplacementRune");
+		addBlock(BloodMagicBlocks.CAPACITY_RUNE, "Rune of Capacity");
+		addBlock(BloodMagicBlocks.AUGMENTED_CAPACITY_RUNE, "Rune of Augmented Capacity");
+		addBlock(BloodMagicBlocks.ORB_RUNE, "Rune of the Orb");
+		addBlock(BloodMagicBlocks.ACCELERATION_RUNE, "Acceleration Rune");
+		addBlock(BloodMagicBlocks.CHARGING_RUNE, "Charging Rune");
+		addBlock(BloodMagicBlocks.BLOOD_ALTAR, "Blood Altar");
+		addBlock(BloodMagicBlocks.SOUL_FORGE, "Hellfire Forge");
+		addBlock(BloodMagicBlocks.BLANK_RITUAL_STONE, "Ritual Stone");
+		addBlock(BloodMagicBlocks.AIR_RITUAL_STONE, "Air Ritual Stone");
+		addBlock(BloodMagicBlocks.WATER_RITUAL_STONE, "Water Ritual Stone");
+		addBlock(BloodMagicBlocks.FIRE_RITUAL_STONE, "Fire Ritual Stone");
+		addBlock(BloodMagicBlocks.EARTH_RITUAL_STONE, "Earth Ritual Stone");
+		addBlock(BloodMagicBlocks.DUSK_RITUAL_STONE, "Dusk Ritual Stone");
+		addBlock(BloodMagicBlocks.DAWN_RITUAL_STONE, "Dawn Ritual Stone");
+		addBlock(BloodMagicBlocks.MASTER_RITUAL_STONE, "Master Ritual Stone");
+
+		// Item names
+		addItem(BloodMagicItems.WEAK_BLOOD_ORB, "Weak Blood Orb");
+		addItem(BloodMagicItems.APPRENTICE_BLOOD_ORB, "Apprentice Blood Orb");
+		addItem(BloodMagicItems.MAGICIAN_BLOOD_ORB, "Magician Blood Orb");
+		addItem(BloodMagicItems.MASTER_BLOOD_ORB, "Master Blood Orb");
+		addItem(BloodMagicItems.DIVINATION_SIGIL, "Divination Sigil");
+		addItem(BloodMagicItems.WATER_SIGIL, "Water Sigil");
+		addItem(BloodMagicItems.LAVA_SIGIL, "Lava Sigil");
+		addItem(BloodMagicItems.VOID_SIGIL, "Void Sigil");
+		addItem(BloodMagicItems.GREEN_GROVE_SIGIL, "Sigil of the Green Grove");
+		addItem(BloodMagicItems.FAST_MINER_SIGIL, "Sigil of the Fast Miner");
+		addItem(BloodMagicItems.MAGNETISM_SIGIL, "Sigil of Magnetism");
+		addItem(BloodMagicItems.ICE_SIGIL, "Sigil of the Frozen Lake");
+		addItem(BloodMagicItems.AIR_SIGIL, "Air Sigil");
+		addItem(BloodMagicItems.BLOOD_LIGHT_SIGIL, "Sigil of the Blood Lamp");
+
+		addItem(BloodMagicBlocks.LIFE_ESSENCE_BUCKET, "Bucket of Life");
+		addItem(BloodMagicItems.ARCANE_ASHES, "Arcane Ashes");
+		addItem(BloodMagicItems.SLATE, "Blank Slate");
+		addItem(BloodMagicItems.REINFORCED_SLATE, "Reinforced Slate");
+		addItem(BloodMagicItems.IMBUED_SLATE, "Imbued Slate");
+		addItem(BloodMagicItems.DEMONIC_SLATE, "Demonic Slate");
+		addItem(BloodMagicItems.ETHEREAL_SLATE, "Ethereal Slate");
+
+		addItem(BloodMagicItems.DAGGER_OF_SACRIFICE, "Dagger of Sacrifice");
+		addItem(BloodMagicItems.SACRIFICIAL_DAGGER, "Sacrificial Knife");
+		addItem(BloodMagicItems.LAVA_CRYSTAL, "Lava Crystal");
+
+		addItem(BloodMagicItems.REAGENT_WATER, "Water Reagent");
+		addItem(BloodMagicItems.REAGENT_LAVA, "Lava Reagent");
+		addItem(BloodMagicItems.REAGENT_FAST_MINER, "Mining Reagent");
+		addItem(BloodMagicItems.REAGENT_GROWTH, "Growth Reagent");
+		addItem(BloodMagicItems.REAGENT_VOID, "Void Reagent");
+		addItem(BloodMagicItems.REAGENT_MAGNETISM, "Magnetism Reagent");
+		addItem(BloodMagicItems.REAGENT_AIR, "Air Reagent");
+		addItem(BloodMagicItems.REAGENT_BLOOD_LIGHT, "Blood Lamp Reagent");
+
+		addItem(BloodMagicItems.PETTY_GEM, "Petty Tartaric Gem");
+		addItem(BloodMagicItems.LESSER_GEM, "Lesser Tartaric Gem");
+		addItem(BloodMagicItems.COMMON_GEM, "Common Tartaric Gem");
+		addItem(BloodMagicItems.MONSTER_SOUL_RAW, "Demon Will");
+		addItem(BloodMagicItems.MONSTER_SOUL_CORROSIVE, "Demon Will");
+		addItem(BloodMagicItems.MONSTER_SOUL_DESTRUCTIVE, "Demon Will");
+		addItem(BloodMagicItems.MONSTER_SOUL_STEADFAST, "Demon Will");
+		addItem(BloodMagicItems.MONSTER_SOUL_VENGEFUL, "Demon Will");
+		addItem(BloodMagicItems.SOUL_SNARE, "Soul Snare");
+		addItem(BloodMagicItems.SENTIENT_SWORD, "Sentient Sword");
+
+		addItem(BloodMagicItems.WEAK_ACTIVATION_CRYSTAL, "Weak Activation Crystal");
+		addItem(BloodMagicItems.AWAKENED_ACTIVATION_CRYSTAL, "Awakened Activation Crystal");
+		addItem(BloodMagicItems.CREATIVE_ACTIVATION_CRYSTAL, "Creative Activation Crystal");
+		addItem(BloodMagicItems.WATER_INSCRIPTION_TOOL, "Inscription Tool: Water");
+		addItem(BloodMagicItems.FIRE_INSCRIPTION_TOOL, "Inscription Tool: Fire");
+		addItem(BloodMagicItems.EARTH_INSCRIPTION_TOOL, "Inscription Tool: Earth");
+		addItem(BloodMagicItems.AIR_INSCRIPTION_TOOL, "Inscription Tool: Air");
+		addItem(BloodMagicItems.DUSK_INSCRIPTION_TOOL, "Inscription Tool: Dusk");
+
+		addItem(BloodMagicItems.BASE_RITUAL_DIVINER, "Ritual Diviner");
+		addItem(BloodMagicItems.DUSK_RITUAL_DIVINER, "Ritual Diviner [Dusk]");
+
+//		addItem(BloodMagicItems , "");
+
+		// JEI
+		add("jei.bloodmagic.recipe.minimumsouls", "Minimum: %s Will");
+		add("jei.bloodmagic.recipe.soulsdrained", "Drained: %s Will");
+		add("jei.bloodmagic.recipe.requiredlp", "LP: %d");
+		add("jei.bloodmagic.recipe.requiredtier", "Tier: %d");
+		add("jei.bloodmagic.recipe.consumptionrate", "Consumption: %s LP/t");
+		add("jei.bloodmagic.recipe.drainrate", "Drain: %s LP/t");
+
+		add("jei.bloodmagic.recipe.altar", "Blood Altar");
+		add("jei.bloodmagic.recipe.soulforge", "Hellfire Forge");
+		add("jei.bloodmagic.recipe.alchemyarraycrafting", "Alchemy Array");
+
+		// Chat
+		add("chat.bloodmagic.ritual.weak", "You feel a push, but are too weak to perform this ritual.");
+		add("chat.bloodmagic.ritual.prevent", "The ritual is actively resisting you!");
+		add("chat.bloodmagic.ritual.activate", "A rush of energy flows through the ritual!");
+		add("chat.bloodmagic.ritual.notValid", "You feel that these runes are not configured correctly...");
+
+		// GUI
+		add("gui.bloodmagic.empty", "Empty");
+
+	}
+}

src/main/java/wayoftime/bloodmagic/common/data/GeneratorLootTable.java

@@ -0,0 +1,84 @@
+package wayoftime.bloodmagic.common.data;
+
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+import com.google.common.collect.ImmutableList;
+import com.mojang.datafixers.util.Pair;
+
+import net.minecraft.block.Block;
+import net.minecraft.data.DataGenerator;
+import net.minecraft.data.LootTableProvider;
+import net.minecraft.data.loot.BlockLootTables;
+import net.minecraft.loot.LootParameterSet;
+import net.minecraft.loot.LootParameterSets;
+import net.minecraft.loot.LootPool;
+import net.minecraft.loot.LootTable;
+import net.minecraft.loot.LootTableManager;
+import net.minecraft.loot.ValidationTracker;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.fml.RegistryObject;
+import net.minecraftforge.registries.ForgeRegistries;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.common.block.BloodMagicBlocks;
+
+public class GeneratorLootTable extends LootTableProvider
+{
+	public GeneratorLootTable(DataGenerator dataGeneratorIn)
+	{
+		super(dataGeneratorIn);
+	}
+
+	@Override
+	protected List<Pair<Supplier<Consumer<BiConsumer<ResourceLocation, LootTable.Builder>>>, LootParameterSet>> getTables()
+	{
+		return ImmutableList.of(Pair.of(Blocks::new, LootParameterSets.BLOCK));
+	}
+
+	private static class Blocks extends BlockLootTables
+	{
+		@Override
+		protected void addTables()
+		{
+			for (RegistryObject<Block> block : BloodMagicBlocks.BASICBLOCKS.getEntries())
+			{
+				this.registerDropSelfLootTable(block.get());
+			}
+
+			registerDropSelfLootTable(BloodMagicBlocks.BLOOD_ALTAR.get());
+			registerNoDropLootTable(BloodMagicBlocks.ALCHEMY_ARRAY.get());
+			registerNoDropLootTable(BloodMagicBlocks.BLOOD_LIGHT.get());
+			registerDropSelfLootTable(BloodMagicBlocks.SOUL_FORGE.get());
+			registerDropSelfLootTable(BloodMagicBlocks.BLANK_RITUAL_STONE.get());
+			registerDropping(BloodMagicBlocks.AIR_RITUAL_STONE.get(), BloodMagicBlocks.BLANK_RITUAL_STONE.get());
+			registerDropping(BloodMagicBlocks.WATER_RITUAL_STONE.get(), BloodMagicBlocks.BLANK_RITUAL_STONE.get());
+			registerDropping(BloodMagicBlocks.FIRE_RITUAL_STONE.get(), BloodMagicBlocks.BLANK_RITUAL_STONE.get());
+			registerDropping(BloodMagicBlocks.EARTH_RITUAL_STONE.get(), BloodMagicBlocks.BLANK_RITUAL_STONE.get());
+			registerDropping(BloodMagicBlocks.DUSK_RITUAL_STONE.get(), BloodMagicBlocks.BLANK_RITUAL_STONE.get());
+			registerDropping(BloodMagicBlocks.DAWN_RITUAL_STONE.get(), BloodMagicBlocks.BLANK_RITUAL_STONE.get());
+			registerDropSelfLootTable(BloodMagicBlocks.ALCHEMICAL_REACTION_CHAMBER.get());
+		}
+
+		private void registerNoDropLootTable(Block block)
+		{
+			LootPool.Builder builder = LootPool.builder().name(block.getRegistryName().toString());
+			this.registerLootTable(block, LootTable.builder().addLootPool(builder));
+		}
+
+		@Override
+		protected Iterable<Block> getKnownBlocks()
+		{
+			return ForgeRegistries.BLOCKS.getValues().stream().filter(b -> b.getRegistryName().getNamespace().equals(BloodMagic.MODID)).collect(Collectors.toList());
+		}
+	}
+
+	@Override
+	protected void validate(Map<ResourceLocation, LootTable> map, ValidationTracker validationtracker)
+	{
+		map.forEach((name, table) -> LootTableManager.validateLootTable(validationtracker, name, table));
+	}
+}

src/main/java/wayoftime/bloodmagic/common/data/recipe/BaseRecipeProvider.java

@@ -0,0 +1,44 @@
+package wayoftime.bloodmagic.common.data.recipe;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Consumer;
+
+import net.minecraft.data.DataGenerator;
+import net.minecraft.data.IFinishedRecipe;
+import net.minecraft.data.RecipeProvider;
+import wayoftime.bloodmagic.common.recipe.ISubRecipeProvider;
+
+public abstract class BaseRecipeProvider extends RecipeProvider
+{
+	private final String modid;
+
+	public BaseRecipeProvider(DataGenerator gen, String modid)
+	{
+		super(gen);
+		this.modid = modid;
+	}
+
+	@Override
+	public String getName()
+	{
+		return super.getName() + modid;
+	}
+
+	@Override
+	protected void registerRecipes(Consumer<IFinishedRecipe> consumer)
+	{
+		getSubRecipeProviders().forEach(subRecipeProvider -> subRecipeProvider.addRecipes(consumer));
+	}
+
+	/**
+	 * Gets all the sub/offloaded recipe providers that this recipe provider has.
+	 *
+	 * @implNote This is only called once per provider so there is no need to bother
+	 *           caching the list that this returns
+	 */
+	protected List<ISubRecipeProvider> getSubRecipeProviders()
+	{
+		return Collections.emptyList();
+	}
+}

src/main/java/wayoftime/bloodmagic/common/data/recipe/BloodMagicRecipeBuilder.java

@@ -0,0 +1,145 @@
+package wayoftime.bloodmagic.common.data.recipe;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+
+import net.minecraft.advancements.Advancement;
+import net.minecraft.advancements.AdvancementRewards;
+import net.minecraft.advancements.ICriterionInstance;
+import net.minecraft.advancements.IRequirementsStrategy;
+import net.minecraft.advancements.criterion.RecipeUnlockedTrigger;
+import net.minecraft.data.IFinishedRecipe;
+import net.minecraft.item.crafting.IRecipeSerializer;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.common.crafting.CraftingHelper;
+import net.minecraftforge.common.crafting.conditions.ICondition;
+import net.minecraftforge.registries.ForgeRegistries;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.util.Constants;
+
+public abstract class BloodMagicRecipeBuilder<BUILDER extends BloodMagicRecipeBuilder<BUILDER>>
+{
+
+	protected static ResourceLocation bmSerializer(String name)
+	{
+		return new ResourceLocation(BloodMagic.MODID, name);
+	}
+
+	protected final List<ICondition> conditions = new ArrayList<>();
+	protected final Advancement.Builder advancementBuilder = Advancement.Builder.builder();
+	protected final ResourceLocation serializerName;
+
+	protected BloodMagicRecipeBuilder(ResourceLocation serializerName)
+	{
+		this.serializerName = serializerName;
+	}
+
+	public BUILDER addCriterion(RecipeCriterion criterion)
+	{
+		return addCriterion(criterion.name, criterion.criterion);
+	}
+
+	public BUILDER addCriterion(String name, ICriterionInstance criterion)
+	{
+		advancementBuilder.withCriterion(name, criterion);
+		return (BUILDER) this;
+	}
+
+	public BUILDER addCondition(ICondition condition)
+	{
+		conditions.add(condition);
+		return (BUILDER) this;
+	}
+
+	protected boolean hasCriteria()
+	{
+		return !advancementBuilder.getCriteria().isEmpty();
+	}
+
+	protected abstract RecipeResult getResult(ResourceLocation id);
+
+	protected void validate(ResourceLocation id)
+	{
+	}
+
+	public void build(Consumer<IFinishedRecipe> consumer, ResourceLocation id)
+	{
+		validate(id);
+		if (hasCriteria())
+		{
+			// If there is a way to "unlock" this recipe then add an advancement with the
+			// criteria
+			advancementBuilder.withParentId(new ResourceLocation("recipes/root")).withCriterion("has_the_recipe", RecipeUnlockedTrigger.create(id)).withRewards(AdvancementRewards.Builder.recipe(id)).withRequirementsStrategy(IRequirementsStrategy.OR);
+		}
+		consumer.accept(getResult(id));
+	}
+
+	protected abstract class RecipeResult implements IFinishedRecipe
+	{
+
+		private final ResourceLocation id;
+
+		public RecipeResult(ResourceLocation id)
+		{
+			this.id = id;
+		}
+
+		@Override
+		public JsonObject getRecipeJson()
+		{
+			JsonObject jsonObject = new JsonObject();
+			jsonObject.addProperty(Constants.JSON.TYPE, serializerName.toString());
+			if (!conditions.isEmpty())
+			{
+				JsonArray conditionsArray = new JsonArray();
+				for (ICondition condition : conditions)
+				{
+					conditionsArray.add(CraftingHelper.serialize(condition));
+				}
+				jsonObject.add(Constants.JSON.CONDITIONS, conditionsArray);
+			}
+			this.serialize(jsonObject);
+			return jsonObject;
+		}
+
+		@Nonnull
+		@Override
+		public IRecipeSerializer<?> getSerializer()
+		{
+			// Note: This may be null if something is screwed up but this method isn't
+			// actually used so it shouldn't matter
+			// and in fact it will probably be null if only the API is included. But again,
+			// as we manually just use
+			// the serializer's name this should not effect us
+			return ForgeRegistries.RECIPE_SERIALIZERS.getValue(serializerName);
+		}
+
+		@Nonnull
+		@Override
+		public ResourceLocation getID()
+		{
+			return this.id;
+		}
+
+		@Nullable
+		@Override
+		public JsonObject getAdvancementJson()
+		{
+			return hasCriteria() ? advancementBuilder.serialize() : null;
+		}
+
+		@Nullable
+		@Override
+		public ResourceLocation getAdvancementID()
+		{
+			return new ResourceLocation(id.getNamespace(), "recipes/" + id.getPath());
+		}
+	}
+}

src/main/java/wayoftime/bloodmagic/common/data/recipe/BloodMagicRecipeProvider.java

@@ -0,0 +1,26 @@
+package wayoftime.bloodmagic.common.data.recipe;
+
+import java.util.Arrays;
+import java.util.List;
+
+import net.minecraft.data.DataGenerator;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.common.recipe.ARCRecipeProvider;
+import wayoftime.bloodmagic.common.recipe.AlchemyArrayRecipeProvider;
+import wayoftime.bloodmagic.common.recipe.BloodAltarRecipeProvider;
+import wayoftime.bloodmagic.common.recipe.ISubRecipeProvider;
+import wayoftime.bloodmagic.common.recipe.TartaricForgeRecipeProvider;
+
+public class BloodMagicRecipeProvider extends BaseRecipeProvider
+{
+	public BloodMagicRecipeProvider(DataGenerator gen)
+	{
+		super(gen, BloodMagic.MODID);
+	}
+
+	@Override
+	protected List<ISubRecipeProvider> getSubRecipeProviders()
+	{
+		return Arrays.asList(new BloodAltarRecipeProvider(), new AlchemyArrayRecipeProvider(), new TartaricForgeRecipeProvider(), new ARCRecipeProvider());
+	}
+}

src/main/java/wayoftime/bloodmagic/common/data/recipe/RecipeCriterion.java

@@ -0,0 +1,20 @@
+package wayoftime.bloodmagic.common.data.recipe;
+
+import net.minecraft.advancements.ICriterionInstance;
+
+public class RecipeCriterion
+{
+	public final String name;
+	public final ICriterionInstance criterion;
+
+	private RecipeCriterion(String name, ICriterionInstance criterion)
+	{
+		this.name = name;
+		this.criterion = criterion;
+	}
+
+	public static RecipeCriterion of(String name, ICriterionInstance criterion)
+	{
+		return new RecipeCriterion(name, criterion);
+	}
+}

src/main/java/wayoftime/bloodmagic/common/data/recipe/builder/ARCRecipeBuilder.java

@@ -0,0 +1,101 @@
+package wayoftime.bloodmagic.common.data.recipe.builder;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.annotation.Nonnull;
+
+import org.apache.commons.lang3.tuple.Pair;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.Ingredient;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.fluids.FluidStack;
+import wayoftime.bloodmagic.api.SerializerHelper;
+import wayoftime.bloodmagic.api.event.recipes.FluidStackIngredient;
+import wayoftime.bloodmagic.api.impl.recipe.RecipeARC;
+import wayoftime.bloodmagic.common.data.recipe.BloodMagicRecipeBuilder;
+import wayoftime.bloodmagic.util.Constants;
+
+public class ARCRecipeBuilder extends BloodMagicRecipeBuilder<ARCRecipeBuilder>
+{
+	private final Ingredient input;
+	private final Ingredient arcTool;
+	private final FluidStackIngredient inputFluid;
+	private final ItemStack output;
+	private final FluidStack outputFluid;
+	private final List<Pair<ItemStack, Double>> addedItems = new ArrayList<Pair<ItemStack, Double>>();
+
+	protected ARCRecipeBuilder(Ingredient input, Ingredient arcTool, FluidStackIngredient inputFluid, ItemStack output, FluidStack outputFluid)
+	{
+		super(bmSerializer("arc"));
+		this.input = input;
+		this.arcTool = arcTool;
+		this.inputFluid = inputFluid;
+		this.output = output;
+		this.outputFluid = outputFluid;
+	}
+
+	public static ARCRecipeBuilder arc(Ingredient input, Ingredient arcTool, FluidStackIngredient inputFluid, ItemStack output, FluidStack outputFluid)
+	{
+		return new ARCRecipeBuilder(input, arcTool, inputFluid, output, outputFluid);
+	}
+
+	public ARCRecipeBuilder addRandomOutput(ItemStack stack, double chance)
+	{
+		if (addedItems.size() >= RecipeARC.MAX_RANDOM_OUTPUTS)
+		{
+			return this;
+		}
+
+		addedItems.add(Pair.of(stack, chance));
+
+		return this;
+	}
+
+	@Override
+	protected ARCRecipeResult getResult(ResourceLocation id)
+	{
+		return new ARCRecipeResult(id);
+	}
+
+	public class ARCRecipeResult extends RecipeResult
+	{
+		protected ARCRecipeResult(ResourceLocation id)
+		{
+			super(id);
+		}
+
+		@Override
+		public void serialize(@Nonnull JsonObject json)
+		{
+			json.add(Constants.JSON.INPUT, input.serialize());
+			json.add(Constants.JSON.TOOL, arcTool.serialize());
+
+			if (inputFluid != null)
+				json.add(Constants.JSON.INPUT_FLUID, inputFluid.serialize());
+
+			if (addedItems.size() > 0)
+			{
+				JsonArray mainArray = new JsonArray();
+				for (Pair<ItemStack, Double> pair : addedItems)
+				{
+					JsonObject jsonObj = new JsonObject();
+					jsonObj.addProperty(Constants.JSON.CHANCE, pair.getValue().floatValue());
+					jsonObj.add(Constants.JSON.TYPE, SerializerHelper.serializeItemStack(pair.getKey()));
+					mainArray.add(jsonObj);
+				}
+
+				json.add(Constants.JSON.ADDEDOUTPUT, mainArray);
+			}
+
+			if (outputFluid != null)
+				json.add(Constants.JSON.OUTPUT_FLUID, SerializerHelper.serializeFluidStack(outputFluid));
+
+			json.add(Constants.JSON.OUTPUT, SerializerHelper.serializeItemStack(output));
+		}
+	}
+}

src/main/java/wayoftime/bloodmagic/common/data/recipe/builder/AlchemyArrayRecipeBuilder.java

@@ -0,0 +1,58 @@
+package wayoftime.bloodmagic.common.data.recipe.builder;
+
+import javax.annotation.Nonnull;
+
+import com.google.gson.JsonObject;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.Ingredient;
+import net.minecraft.util.ResourceLocation;
+import wayoftime.bloodmagic.api.SerializerHelper;
+import wayoftime.bloodmagic.common.data.recipe.BloodMagicRecipeBuilder;
+import wayoftime.bloodmagic.util.Constants;
+
+public class AlchemyArrayRecipeBuilder extends BloodMagicRecipeBuilder<AlchemyArrayRecipeBuilder>
+{
+	private final ResourceLocation texture;
+	private final Ingredient baseInput;
+	private final Ingredient addedInput;
+	private final ItemStack output;
+
+	protected AlchemyArrayRecipeBuilder(ResourceLocation texture, Ingredient baseInput, Ingredient addedInput, ItemStack output)
+	{
+		super(bmSerializer("array"));
+		this.texture = texture;
+		this.baseInput = baseInput;
+		this.addedInput = addedInput;
+		this.output = output;
+	}
+
+	public static AlchemyArrayRecipeBuilder array(ResourceLocation texture, Ingredient baseInput, Ingredient addedInput, ItemStack output)
+	{
+		return new AlchemyArrayRecipeBuilder(texture, baseInput, addedInput, output);
+	}
+
+	@Override
+	protected AlchemyArrayRecipeResult getResult(ResourceLocation id)
+	{
+		return new AlchemyArrayRecipeResult(id);
+	}
+
+	public class AlchemyArrayRecipeResult extends RecipeResult
+	{
+		protected AlchemyArrayRecipeResult(ResourceLocation id)
+		{
+			super(id);
+		}
+
+		@Override
+		public void serialize(@Nonnull JsonObject json)
+		{
+			json.addProperty(Constants.JSON.TEXTURE, texture.toString());
+//			JSONUtils.getString(json, );
+			json.add(Constants.JSON.BASEINPUT, baseInput.serialize());
+			json.add(Constants.JSON.ADDEDINPUT, addedInput.serialize());
+			json.add(Constants.JSON.OUTPUT, SerializerHelper.serializeItemStack(output));
+		}
+	}
+}

src/main/java/wayoftime/bloodmagic/common/data/recipe/builder/BloodAltarRecipeBuilder.java

@@ -0,0 +1,63 @@
+package wayoftime.bloodmagic.common.data.recipe.builder;
+
+import javax.annotation.Nonnull;
+
+import com.google.gson.JsonObject;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.Ingredient;
+import net.minecraft.util.ResourceLocation;
+import wayoftime.bloodmagic.api.SerializerHelper;
+import wayoftime.bloodmagic.common.data.recipe.BloodMagicRecipeBuilder;
+import wayoftime.bloodmagic.util.Constants;
+
+public class BloodAltarRecipeBuilder extends BloodMagicRecipeBuilder<BloodAltarRecipeBuilder>
+{
+	private final Ingredient input;
+	private final ItemStack output;
+	private final int minimumTier;
+	private final int syphon;
+	private final int consumeRate;
+	private final int drainRate;
+
+	protected BloodAltarRecipeBuilder(Ingredient input, ItemStack output, int minimumTier, int syphon, int consumeRate, int drainRate)
+	{
+		super(bmSerializer("altar"));
+		this.input = input;
+		this.output = output;
+		this.minimumTier = minimumTier;
+		this.syphon = syphon;
+		this.consumeRate = consumeRate;
+		this.drainRate = drainRate;
+	}
+
+	public static BloodAltarRecipeBuilder altar(Ingredient input, ItemStack output, int minimumTier, int syphon, int consumeRate, int drainRate)
+	{
+		return new BloodAltarRecipeBuilder(input, output, minimumTier, syphon, consumeRate, drainRate);
+	}
+
+	@Override
+	protected BloodAltarRecipeResult getResult(ResourceLocation id)
+	{
+		return new BloodAltarRecipeResult(id);
+	}
+
+	public class BloodAltarRecipeResult extends RecipeResult
+	{
+		protected BloodAltarRecipeResult(ResourceLocation id)
+		{
+			super(id);
+		}
+
+		@Override
+		public void serialize(@Nonnull JsonObject json)
+		{
+			json.add(Constants.JSON.INPUT, input.serialize());
+			json.add(Constants.JSON.OUTPUT, SerializerHelper.serializeItemStack(output));
+			json.addProperty(Constants.JSON.ALTAR_TIER, minimumTier);
+			json.addProperty(Constants.JSON.ALTAR_SYPHON, syphon);
+			json.addProperty(Constants.JSON.ALTAR_CONSUMPTION_RATE, consumeRate);
+			json.addProperty(Constants.JSON.ALTAR_DRAIN_RATE, drainRate);
+		}
+	}
+}

src/main/java/wayoftime/bloodmagic/common/data/recipe/builder/TartaricForgeRecipeBuilder.java

@@ -0,0 +1,75 @@
+package wayoftime.bloodmagic.common.data.recipe.builder;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.annotation.Nonnull;
+
+import com.google.gson.JsonObject;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.Ingredient;
+import net.minecraft.util.ResourceLocation;
+import wayoftime.bloodmagic.api.SerializerHelper;
+import wayoftime.bloodmagic.common.data.recipe.BloodMagicRecipeBuilder;
+import wayoftime.bloodmagic.util.Constants;
+
+public class TartaricForgeRecipeBuilder extends BloodMagicRecipeBuilder<TartaricForgeRecipeBuilder>
+{
+	private final List<Ingredient> input;
+	private final ItemStack output;
+	private final double minimumSouls;
+	private final double soulDrain;
+
+	protected TartaricForgeRecipeBuilder(List<Ingredient> input, ItemStack output, double minimumSouls, double soulDrain)
+	{
+		super(bmSerializer("soulforge"));
+		this.input = input;
+		this.output = output;
+		this.minimumSouls = minimumSouls;
+		this.soulDrain = soulDrain;
+	}
+
+	public static TartaricForgeRecipeBuilder tartaricForge(List<Ingredient> input, ItemStack output, double minimumSouls, double soulDrain)
+	{
+		return new TartaricForgeRecipeBuilder(input, output, minimumSouls, soulDrain);
+	}
+
+	public static TartaricForgeRecipeBuilder tartaricForge(ItemStack output, double minimumSouls, double soulDrain, Ingredient... inputArray)
+	{
+		List<Ingredient> inputList = new ArrayList<Ingredient>();
+		for (int i = 0; i < inputArray.length; i++)
+		{
+			inputList.add(inputArray[i]);
+		}
+		return new TartaricForgeRecipeBuilder(inputList, output, minimumSouls, soulDrain);
+	}
+
+	@Override
+	protected TartaricForgeRecipeResult getResult(ResourceLocation id)
+	{
+		return new TartaricForgeRecipeResult(id);
+	}
+
+	public class TartaricForgeRecipeResult extends RecipeResult
+	{
+		protected TartaricForgeRecipeResult(ResourceLocation id)
+		{
+			super(id);
+		}
+
+		@Override
+		public void serialize(@Nonnull JsonObject json)
+		{
+			for (int i = 0; i < Math.min(input.size(), 4); i++)
+			{
+				json.add(Constants.JSON.INPUT + i, input.get(i).serialize());
+			}
+
+			json.add(Constants.JSON.OUTPUT, SerializerHelper.serializeItemStack(output));
+			json.addProperty(Constants.JSON.TARTARIC_MINIMUM, (float) minimumSouls);
+			json.addProperty(Constants.JSON.TARTARIC_DRAIN, (float) soulDrain);
+
+		}
+	}
+}

src/main/java/wayoftime/bloodmagic/common/item/BMItemTier.java

@@ -0,0 +1,62 @@
+package wayoftime.bloodmagic.common.item;
+
+import java.util.function.Supplier;
+
+import net.minecraft.item.IItemTier;
+import net.minecraft.item.crafting.Ingredient;
+import net.minecraft.util.LazyValue;
+
+public enum BMItemTier implements IItemTier
+{
+	SENTIENT(4, 512, 6.0F, 2.0F, 50, () -> {
+		return Ingredient.fromItems(BloodMagicItems.IMBUED_SLATE.get());
+	});
+
+	private final int harvestLevel;
+	private final int maxUses;
+	private final float efficiency;
+	private final float attackDamage;
+	private final int enchantability;
+	private final LazyValue<Ingredient> repairMaterial;
+
+	private BMItemTier(int harvestLevelIn, int maxUsesIn, float efficiencyIn, float attackDamageIn, int enchantabilityIn, Supplier<Ingredient> repairMaterialIn)
+	{
+		this.harvestLevel = harvestLevelIn;
+		this.maxUses = maxUsesIn;
+		this.efficiency = efficiencyIn;
+		this.attackDamage = attackDamageIn;
+		this.enchantability = enchantabilityIn;
+		this.repairMaterial = new LazyValue<>(repairMaterialIn);
+	}
+
+	public int getMaxUses()
+	{
+		return this.maxUses;
+	}
+
+	public float getEfficiency()
+	{
+		return this.efficiency;
+	}
+
+	public float getAttackDamage()
+	{
+		return this.attackDamage;
+	}
+
+	public int getHarvestLevel()
+	{
+		return this.harvestLevel;
+	}
+
+	public int getEnchantability()
+	{
+		return this.enchantability;
+	}
+
+	public Ingredient getRepairMaterial()
+	{
+		return this.repairMaterial.getValue();
+	}
+
+}

src/main/java/wayoftime/bloodmagic/common/item/BloodMagicItems.java

@@ -0,0 +1,139 @@
+package wayoftime.bloodmagic.common.item;
+
+import net.minecraft.item.BlockItem;
+import net.minecraft.item.Item;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.fml.RegistryObject;
+import net.minecraftforge.registries.DeferredRegister;
+import net.minecraftforge.registries.ForgeRegistries;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.common.block.BloodMagicBlocks;
+import wayoftime.bloodmagic.common.item.sigil.ItemSigilAir;
+import wayoftime.bloodmagic.common.item.sigil.ItemSigilBloodLight;
+import wayoftime.bloodmagic.common.item.sigil.ItemSigilDivination;
+import wayoftime.bloodmagic.common.item.sigil.ItemSigilFastMiner;
+import wayoftime.bloodmagic.common.item.sigil.ItemSigilFrost;
+import wayoftime.bloodmagic.common.item.sigil.ItemSigilGreenGrove;
+import wayoftime.bloodmagic.common.item.sigil.ItemSigilLava;
+import wayoftime.bloodmagic.common.item.sigil.ItemSigilMagnetism;
+import wayoftime.bloodmagic.common.item.sigil.ItemSigilVoid;
+import wayoftime.bloodmagic.common.item.sigil.ItemSigilWater;
+import wayoftime.bloodmagic.common.item.soul.ItemMonsterSoul;
+import wayoftime.bloodmagic.common.item.soul.ItemSentientSword;
+import wayoftime.bloodmagic.common.item.soul.ItemSoulGem;
+import wayoftime.bloodmagic.common.item.soul.ItemSoulSnare;
+import wayoftime.bloodmagic.common.registration.impl.BloodOrbDeferredRegister;
+import wayoftime.bloodmagic.common.registration.impl.BloodOrbRegistryObject;
+import wayoftime.bloodmagic.orb.BloodOrb;
+import wayoftime.bloodmagic.ritual.EnumRuneType;
+import wayoftime.bloodmagic.will.EnumDemonWillType;
+
+public class BloodMagicItems
+{
+//	public static Item.ToolMaterial SOUL_TOOL_MATERIAL = EnumHelper.addToolMaterial("demonic", 4, 520, 7, 8, 50);
+//	public static final BloodOrb WEAK_ORB_INSTANCE = new BloodOrb(new ResourceLocation(BloodMagic.MODID, "weakbloodorb"), 0, 5000, 10);
+	public static final BloodOrbDeferredRegister BLOOD_ORBS = new BloodOrbDeferredRegister(BloodMagic.MODID);
+	public static final DeferredRegister<Item> ITEMS = DeferredRegister.create(ForgeRegistries.ITEMS, BloodMagic.MODID);
+	public static final DeferredRegister<Item> BASICITEMS = DeferredRegister.create(ForgeRegistries.ITEMS, BloodMagic.MODID);
+
+	public static final BloodOrbRegistryObject<BloodOrb> ORB_WEAK = BLOOD_ORBS.register("weakbloodorb", () -> new BloodOrb(new ResourceLocation(BloodMagic.MODID, "weakbloodorb"), 1, 5000, 2));
+	public static final BloodOrbRegistryObject<BloodOrb> ORB_APPRENTICE = BLOOD_ORBS.register("apprenticebloodorb", () -> new BloodOrb(new ResourceLocation(BloodMagic.MODID, "apprenticebloodorb"), 2, 25000, 5));
+	public static final BloodOrbRegistryObject<BloodOrb> ORB_MAGICIAN = BLOOD_ORBS.register("magicianbloodorb", () -> new BloodOrb(new ResourceLocation(BloodMagic.MODID, "magicianbloodorb"), 3, 150000, 15));
+	public static final BloodOrbRegistryObject<BloodOrb> ORB_MASTER = BLOOD_ORBS.register("masterbloodorb", () -> new BloodOrb(new ResourceLocation(BloodMagic.MODID, "masterbloodorb"), 4, 1000000, 25));
+	public static final BloodOrbRegistryObject<BloodOrb> ORB_ARCHMAGE = BLOOD_ORBS.register("archmagebloodorb", () -> new BloodOrb(new ResourceLocation(BloodMagic.MODID, "archmagebloodorb"), 5, 10000000, 50));
+//	public static final DeferredRegister<BloodOrb> BLOOD_ORBS = DeferredRegister.create(RegistrarBloodMagic.BLOOD_ORBS, BloodMagic.MODID);
+
+//	public static final RegistryObject<Item> BLOODSTONE_ITEM = ITEMS.register("ruby_block", () -> new BlockItem(BloodMagicBlocks.BLOODSTONE.get(), new Item.Properties().group(BloodMagic.TAB)));
+	public static final RegistryObject<Item> SOUL_FORGE_ITEM = ITEMS.register("soulforge", () -> new BlockItem(BloodMagicBlocks.SOUL_FORGE.get(), new Item.Properties().group(BloodMagic.TAB)));
+	public static final RegistryObject<Item> BLANK_RUNE_ITEM = ITEMS.register("blankrune", () -> new BlockItem(BloodMagicBlocks.BLANK_RUNE.get(), new Item.Properties().group(BloodMagic.TAB)));
+	public static final RegistryObject<Item> SPEED_RUNE_ITEM = ITEMS.register("speedrune", () -> new BlockItem(BloodMagicBlocks.SPEED_RUNE.get(), new Item.Properties().group(BloodMagic.TAB)));
+	public static final RegistryObject<Item> SACRIFICE_RUNE_ITEM = ITEMS.register("sacrificerune", () -> new BlockItem(BloodMagicBlocks.SACRIFICE_RUNE.get(), new Item.Properties().group(BloodMagic.TAB)));
+	public static final RegistryObject<Item> SELF_SACRIFICE_RUNE_ITEM = ITEMS.register("selfsacrificerune", () -> new BlockItem(BloodMagicBlocks.SELF_SACRIFICE_RUNE.get(), new Item.Properties().group(BloodMagic.TAB)));
+	public static final RegistryObject<Item> DISPLACEMENT_RUNE_ITEM = ITEMS.register("dislocationrune", () -> new BlockItem(BloodMagicBlocks.DISPLACEMENT_RUNE.get(), new Item.Properties().group(BloodMagic.TAB)));
+	public static final RegistryObject<Item> CAPACITY_RUNE_ITEM = ITEMS.register("altarcapacityrune", () -> new BlockItem(BloodMagicBlocks.CAPACITY_RUNE.get(), new Item.Properties().group(BloodMagic.TAB)));
+	public static final RegistryObject<Item> AUGMENTED_CAPACITY_RUNE_ITEM = ITEMS.register("bettercapacityrune", () -> new BlockItem(BloodMagicBlocks.AUGMENTED_CAPACITY_RUNE.get(), new Item.Properties().group(BloodMagic.TAB)));
+	public static final RegistryObject<Item> ORB_RUNE_ITEM = ITEMS.register("orbcapacityrune", () -> new BlockItem(BloodMagicBlocks.ORB_RUNE.get(), new Item.Properties().group(BloodMagic.TAB)));
+	public static final RegistryObject<Item> ACCELERATION_RUNE_ITEM = ITEMS.register("accelerationrune", () -> new BlockItem(BloodMagicBlocks.ACCELERATION_RUNE.get(), new Item.Properties().group(BloodMagic.TAB)));
+	public static final RegistryObject<Item> CHARGING_RUNE_ITEM = ITEMS.register("chargingrune", () -> new BlockItem(BloodMagicBlocks.CHARGING_RUNE.get(), new Item.Properties().group(BloodMagic.TAB)));
+	public static final RegistryObject<Item> BLANK_RITUAL_STONE_ITEM = ITEMS.register("ritualstone", () -> new BlockItem(BloodMagicBlocks.BLANK_RITUAL_STONE.get(), new Item.Properties().group(BloodMagic.TAB)));
+	public static final RegistryObject<Item> AIR_RITUAL_STONE_ITEM = ITEMS.register("airritualstone", () -> new BlockItem(BloodMagicBlocks.AIR_RITUAL_STONE.get(), new Item.Properties().group(BloodMagic.TAB)));
+	public static final RegistryObject<Item> WATER_RITUAL_STONE_ITEM = ITEMS.register("waterritualstone", () -> new BlockItem(BloodMagicBlocks.WATER_RITUAL_STONE.get(), new Item.Properties().group(BloodMagic.TAB)));
+	public static final RegistryObject<Item> FIRE_RITUAL_STONE_ITEM = ITEMS.register("fireritualstone", () -> new BlockItem(BloodMagicBlocks.FIRE_RITUAL_STONE.get(), new Item.Properties().group(BloodMagic.TAB)));
+	public static final RegistryObject<Item> EARTH_RITUAL_STONE_ITEM = ITEMS.register("earthritualstone", () -> new BlockItem(BloodMagicBlocks.EARTH_RITUAL_STONE.get(), new Item.Properties().group(BloodMagic.TAB)));
+	public static final RegistryObject<Item> DUSK_RITUAL_STONE_ITEM = ITEMS.register("duskritualstone", () -> new BlockItem(BloodMagicBlocks.DUSK_RITUAL_STONE.get(), new Item.Properties().group(BloodMagic.TAB)));
+	public static final RegistryObject<Item> DAWN_RITUAL_STONE_ITEM = ITEMS.register("lightritualstone", () -> new BlockItem(BloodMagicBlocks.DAWN_RITUAL_STONE.get(), new Item.Properties().group(BloodMagic.TAB)));
+	public static final RegistryObject<Item> ALCHEMICAL_REACTION_CHAMBER_ITEM = ITEMS.register("alchemicalreactionchamber", () -> new BlockItem(BloodMagicBlocks.ALCHEMICAL_REACTION_CHAMBER.get(), new Item.Properties().group(BloodMagic.TAB)));
+
+	public static final RegistryObject<Item> MASTER_RITUAL_STONE_ITEM = ITEMS.register("masterritualstone", () -> new BlockItem(BloodMagicBlocks.MASTER_RITUAL_STONE.get(), new Item.Properties().group(BloodMagic.TAB)));
+
+	public static final RegistryObject<Item> BLOOD_ALTAR_ITEM = ITEMS.register("altar", () -> new BlockItem(BloodMagicBlocks.BLOOD_ALTAR.get(), new Item.Properties().group(BloodMagic.TAB)));
+
+	// TODO: Need to rework the above instantiations for the ItemBlocks so that it's
+	// done with the Blocks.
+
+//	public static final RegistryObject<Item> WEAK_BLOOD_ORB = BASICITEMS.register("weakbloodorb", ItemBloodOrb::new);
+//	public static final RegistryObject<Item> WEAK_BLOOD_ORB = BASICITEMS.register("weakbloodorb", () -> new ItemBloodOrb(WEAK_ORB_INSTANCE));
+	public static final RegistryObject<Item> WEAK_BLOOD_ORB = BASICITEMS.register("weakbloodorb", () -> new ItemBloodOrb(ORB_WEAK));
+	public static final RegistryObject<Item> APPRENTICE_BLOOD_ORB = BASICITEMS.register("apprenticebloodorb", () -> new ItemBloodOrb(ORB_APPRENTICE));
+	public static final RegistryObject<Item> MAGICIAN_BLOOD_ORB = BASICITEMS.register("magicianbloodorb", () -> new ItemBloodOrb(ORB_MAGICIAN));
+	public static final RegistryObject<Item> MASTER_BLOOD_ORB = BASICITEMS.register("masterbloodorb", () -> new ItemBloodOrb(ORB_MASTER));
+
+	public static final RegistryObject<Item> DIVINATION_SIGIL = BASICITEMS.register("divinationsigil", () -> new ItemSigilDivination(true));
+	public static final RegistryObject<Item> SACRIFICIAL_DAGGER = BASICITEMS.register("sacrificialdagger", () -> new ItemSacrificialDagger());
+	public static final RegistryObject<Item> SLATE = BASICITEMS.register("blankslate", () -> new ItemBase());
+	public static final RegistryObject<Item> REINFORCED_SLATE = BASICITEMS.register("reinforcedslate", () -> new ItemBase());
+	public static final RegistryObject<Item> IMBUED_SLATE = BASICITEMS.register("infusedslate", () -> new ItemBase());
+	public static final RegistryObject<Item> DEMONIC_SLATE = BASICITEMS.register("demonslate", () -> new ItemBase());
+	public static final RegistryObject<Item> ETHEREAL_SLATE = BASICITEMS.register("etherealslate", () -> new ItemBase());
+	public static final RegistryObject<Item> WATER_SIGIL = BASICITEMS.register("watersigil", () -> new ItemSigilWater());
+	public static final RegistryObject<Item> VOID_SIGIL = BASICITEMS.register("voidsigil", () -> new ItemSigilVoid());
+	public static final RegistryObject<Item> LAVA_SIGIL = BASICITEMS.register("lavasigil", () -> new ItemSigilLava());
+	public static final RegistryObject<Item> GREEN_GROVE_SIGIL = ITEMS.register("growthsigil", () -> new ItemSigilGreenGrove());
+	public static final RegistryObject<Item> FAST_MINER_SIGIL = ITEMS.register("miningsigil", () -> new ItemSigilFastMiner());
+	public static final RegistryObject<Item> MAGNETISM_SIGIL = ITEMS.register("sigilofmagnetism", () -> new ItemSigilMagnetism());
+	public static final RegistryObject<Item> ICE_SIGIL = ITEMS.register("icesigil", () -> new ItemSigilFrost());
+	public static final RegistryObject<Item> AIR_SIGIL = BASICITEMS.register("airsigil", ItemSigilAir::new);
+	public static final RegistryObject<Item> BLOOD_LIGHT_SIGIL = BASICITEMS.register("bloodlightsigil", ItemSigilBloodLight::new);
+
+	public static final RegistryObject<Item> ARCANE_ASHES = BASICITEMS.register("arcaneashes", () -> new ItemArcaneAshes());
+	public static final RegistryObject<Item> DAGGER_OF_SACRIFICE = BASICITEMS.register("daggerofsacrifice", () -> new ItemDaggerOfSacrifice());
+	public static final RegistryObject<Item> LAVA_CRYSTAL = BASICITEMS.register("lavacrystal", () -> new ItemLavaCrystal());
+
+	// Ritual stuffs
+	public static final RegistryObject<Item> WEAK_ACTIVATION_CRYSTAL = BASICITEMS.register("activationcrystalweak", () -> new ItemActivationCrystal(ItemActivationCrystal.CrystalType.WEAK));
+	public static final RegistryObject<Item> AWAKENED_ACTIVATION_CRYSTAL = BASICITEMS.register("activationcrystalawakened", () -> new ItemActivationCrystal(ItemActivationCrystal.CrystalType.AWAKENED));
+	public static final RegistryObject<Item> CREATIVE_ACTIVATION_CRYSTAL = BASICITEMS.register("activationcrystalcreative", () -> new ItemActivationCrystal(ItemActivationCrystal.CrystalType.CREATIVE));
+
+	public static final RegistryObject<Item> AIR_INSCRIPTION_TOOL = BASICITEMS.register("airscribetool", () -> new ItemInscriptionTool(EnumRuneType.AIR));
+	public static final RegistryObject<Item> FIRE_INSCRIPTION_TOOL = BASICITEMS.register("firescribetool", () -> new ItemInscriptionTool(EnumRuneType.FIRE));
+	public static final RegistryObject<Item> WATER_INSCRIPTION_TOOL = BASICITEMS.register("waterscribetool", () -> new ItemInscriptionTool(EnumRuneType.WATER));
+	public static final RegistryObject<Item> EARTH_INSCRIPTION_TOOL = BASICITEMS.register("earthscribetool", () -> new ItemInscriptionTool(EnumRuneType.EARTH));
+	public static final RegistryObject<Item> DUSK_INSCRIPTION_TOOL = BASICITEMS.register("duskscribetool", () -> new ItemInscriptionTool(EnumRuneType.DUSK));
+
+	public static final RegistryObject<Item> BASE_RITUAL_DIVINER = BASICITEMS.register("ritualdiviner", () -> new ItemRitualDiviner(0));
+	public static final RegistryObject<Item> DUSK_RITUAL_DIVINER = BASICITEMS.register("ritualdivinerdusk", () -> new ItemRitualDiviner(1));
+
+	// Reagents used to make the Sigils
+	public static final RegistryObject<Item> REAGENT_WATER = BASICITEMS.register("reagentwater", () -> new ItemBase());
+	public static final RegistryObject<Item> REAGENT_LAVA = BASICITEMS.register("reagentlava", () -> new ItemBase());
+	public static final RegistryObject<Item> REAGENT_VOID = BASICITEMS.register("reagentvoid", () -> new ItemBase());
+	public static final RegistryObject<Item> REAGENT_GROWTH = BASICITEMS.register("reagentgrowth", () -> new ItemBase());
+	public static final RegistryObject<Item> REAGENT_FAST_MINER = BASICITEMS.register("reagentfastminer", () -> new ItemBase());
+	public static final RegistryObject<Item> REAGENT_MAGNETISM = BASICITEMS.register("reagentmagnetism", () -> new ItemBase());
+	public static final RegistryObject<Item> REAGENT_AIR = BASICITEMS.register("reagentair", () -> new ItemBase());
+	public static final RegistryObject<Item> REAGENT_BLOOD_LIGHT = BASICITEMS.register("reagentbloodlight", () -> new ItemBase());
+
+	// Tartaric Gems
+	public static final RegistryObject<Item> PETTY_GEM = ITEMS.register("soulgempetty", () -> new ItemSoulGem("petty", 64));
+	public static final RegistryObject<Item> LESSER_GEM = ITEMS.register("soulgemlesser", () -> new ItemSoulGem("lesser", 256));
+	public static final RegistryObject<Item> COMMON_GEM = ITEMS.register("soulgemcommon", () -> new ItemSoulGem("common", 1024));
+
+	public static final RegistryObject<Item> MONSTER_SOUL_RAW = BASICITEMS.register("basemonstersoul", () -> new ItemMonsterSoul(EnumDemonWillType.DEFAULT));
+	public static final RegistryObject<Item> MONSTER_SOUL_CORROSIVE = BASICITEMS.register("basemonstersoul_corrosive", () -> new ItemMonsterSoul(EnumDemonWillType.CORROSIVE));
+	public static final RegistryObject<Item> MONSTER_SOUL_DESTRUCTIVE = BASICITEMS.register("basemonstersoul_destructive", () -> new ItemMonsterSoul(EnumDemonWillType.DESTRUCTIVE));
+	public static final RegistryObject<Item> MONSTER_SOUL_STEADFAST = BASICITEMS.register("basemonstersoul_steadfast", () -> new ItemMonsterSoul(EnumDemonWillType.STEADFAST));
+	public static final RegistryObject<Item> MONSTER_SOUL_VENGEFUL = BASICITEMS.register("basemonstersoul_vengeful", () -> new ItemMonsterSoul(EnumDemonWillType.VENGEFUL));
+
+	public static final RegistryObject<Item> SOUL_SNARE = BASICITEMS.register("soulsnare", ItemSoulSnare::new);
+	public static final RegistryObject<Item> SENTIENT_SWORD = ITEMS.register("soulsword", () -> new ItemSentientSword());
+}

src/main/java/wayoftime/bloodmagic/common/item/IARCTool.java

@@ -0,0 +1,6 @@
+package wayoftime.bloodmagic.common.item;
+
+public interface IARCTool
+{
+
+}

src/main/java/wayoftime/bloodmagic/common/item/ItemActivationCrystal.java

@@ -0,0 +1,72 @@
+package wayoftime.bloodmagic.common.item;
+
+import java.util.List;
+
+import javax.annotation.Nonnull;
+
+import net.minecraft.client.util.ITooltipFlag;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TranslationTextComponent;
+import net.minecraft.world.World;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.core.data.Binding;
+import wayoftime.bloodmagic.iface.IBindable;
+
+public class ItemActivationCrystal extends Item implements IBindable
+{
+	final CrystalType type;
+
+	public ItemActivationCrystal(CrystalType type)
+	{
+		super(new Item.Properties().maxStackSize(1).group(BloodMagic.TAB));
+		this.type = type;
+	}
+
+	@Override
+	@OnlyIn(Dist.CLIENT)
+	public void addInformation(ItemStack stack, World world, List<ITextComponent> tooltip, ITooltipFlag flag)
+	{
+		tooltip.add(new TranslationTextComponent("tooltip.bloodmagic.activationcrystal." + type.name().toLowerCase()));
+
+		if (!stack.hasTag())
+			return;
+
+		Binding binding = getBinding(stack);
+		if (binding != null)
+			tooltip.add(new TranslationTextComponent("tooltip.bloodmagic.currentOwner", binding.getOwnerName()));
+
+		super.addInformation(stack, world, tooltip, flag);
+	}
+
+	public int getCrystalLevel(ItemStack stack)
+	{
+		return this.type.equals(CrystalType.CREATIVE) ? Integer.MAX_VALUE : type.ordinal() + 1;
+	}
+
+	public enum CrystalType
+	{
+		WEAK, AWAKENED, CREATIVE,;
+
+		@Nonnull
+		public static ItemStack getStack(int level)
+		{
+			if (level < 0)
+			{
+				level = 0;
+			}
+			switch (level)
+			{
+			case 0:
+				return new ItemStack(BloodMagicItems.WEAK_ACTIVATION_CRYSTAL.get());
+			case 1:
+				return new ItemStack(BloodMagicItems.AWAKENED_ACTIVATION_CRYSTAL.get());
+			default:
+				return new ItemStack(BloodMagicItems.CREATIVE_ACTIVATION_CRYSTAL.get());
+			}
+		}
+	}
+}

src/main/java/wayoftime/bloodmagic/common/item/ItemArcaneAshes.java

@@ -0,0 +1,98 @@
+package wayoftime.bloodmagic.common.item;
+
+import java.util.List;
+
+import net.minecraft.client.util.ITooltipFlag;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.inventory.EquipmentSlotType;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.ItemUseContext;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ActionResultType;
+import net.minecraft.util.Direction;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TranslationTextComponent;
+import net.minecraft.world.World;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.common.block.BloodMagicBlocks;
+import wayoftime.bloodmagic.tile.TileAlchemyArray;
+
+public class ItemArcaneAshes extends Item
+{
+	public ItemArcaneAshes()
+	{
+		super(new Item.Properties().maxStackSize(1).group(BloodMagic.TAB).maxDamage(20));
+	}
+
+	@Override
+	@OnlyIn(Dist.CLIENT)
+	public void addInformation(ItemStack stack, World world, List<ITextComponent> tooltip, ITooltipFlag flag)
+	{
+		tooltip.add(new TranslationTextComponent("tooltip.bloodmagic.arcaneAshes"));
+	}
+
+	@Override
+	public ActionResultType onItemUse(ItemUseContext context)
+	{
+		ItemStack stack = context.getItem();
+		BlockPos newPos = context.getPos().offset(context.getFace());
+		World world = context.getWorld();
+		PlayerEntity player = context.getPlayer();
+
+		if (world.isAirBlock(newPos))
+		{
+			if (!world.isRemote)
+			{
+				Direction rotation = Direction.fromAngle(player.getRotationYawHead());
+				world.setBlockState(newPos, BloodMagicBlocks.ALCHEMY_ARRAY.get().getDefaultState());
+				TileEntity tile = world.getTileEntity(newPos);
+				if (tile instanceof TileAlchemyArray)
+				{
+					((TileAlchemyArray) tile).setRotation(rotation);
+				}
+
+//				PickaxeItem d;
+				stack.damageItem(1, player, (entity) -> {
+					entity.sendBreakAnimation(EquipmentSlotType.MAINHAND);
+				});
+
+			}
+
+			return ActionResultType.SUCCESS;
+		}
+
+		return ActionResultType.FAIL;
+	}
+
+//	@Override
+//	public ActionResultType onItemUse(PlayerEntity player, World world, BlockPos blockPos, Hand hand, Direction side, float hitX, float hitY, float hitZ)
+//	{
+//		ItemStack stack = player.getHeldItem(hand);
+//		BlockPos newPos = blockPos.offset(side);
+//
+//		if (world.isAirBlock(newPos))
+//		{
+//			if (!world.isRemote)
+//			{
+//				Direction rotation = Direction.fromAngle(player.getRotationYawHead());
+//				world.setBlockState(newPos, RegistrarBloodMagicBlocks.ALCHEMY_ARRAY.getDefaultState());
+//				TileEntity tile = world.getTileEntity(newPos);
+//				if (tile instanceof TileAlchemyArray)
+//				{
+//					((TileAlchemyArray) tile).setRotation(rotation);
+//				}
+//
+//				stack.damageItem(1, player);
+//			}
+//
+//			return ActionResultType.SUCCESS;
+//		}
+//
+//		return ActionResultType.FAIL;
+//	}
+
+}

src/main/java/wayoftime/bloodmagic/common/item/ItemBase.java

@@ -0,0 +1,38 @@
+package wayoftime.bloodmagic.common.item;
+
+import java.util.List;
+
+import net.minecraft.client.util.ITooltipFlag;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TranslationTextComponent;
+import net.minecraft.world.World;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import wayoftime.bloodmagic.BloodMagic;
+
+public class ItemBase extends Item
+{
+	private final String desc;
+
+	public ItemBase()
+	{
+		this("");
+	}
+
+	public ItemBase(String desc)
+	{
+		super(new Item.Properties().maxStackSize(64).group(BloodMagic.TAB));
+		this.desc = desc;
+	}
+
+	@Override
+	@OnlyIn(Dist.CLIENT)
+	public void addInformation(ItemStack stack, World world, List<ITextComponent> tooltip, ITooltipFlag flag)
+	{
+		if (!desc.isEmpty())
+			tooltip.add(new TranslationTextComponent("tooltip.bloodmagic." + desc));
+
+	}
+}

src/main/java/wayoftime/bloodmagic/common/item/ItemBindableBase.java

@@ -0,0 +1,35 @@
+package wayoftime.bloodmagic.common.item;
+
+import java.util.List;
+
+import net.minecraft.client.util.ITooltipFlag;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TranslationTextComponent;
+import net.minecraft.world.World;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.core.data.Binding;
+import wayoftime.bloodmagic.iface.IBindable;
+
+public class ItemBindableBase extends Item implements IBindable
+{
+	public ItemBindableBase()
+	{
+		super(new Item.Properties().maxStackSize(1).group(BloodMagic.TAB));
+	}
+
+	@Override
+	@OnlyIn(Dist.CLIENT)
+	public void addInformation(ItemStack stack, World world, List<ITextComponent> tooltip, ITooltipFlag flag)
+	{
+		if (!stack.hasTag())
+			return;
+
+		Binding binding = getBinding(stack);
+		if (binding != null)
+			tooltip.add(new TranslationTextComponent("tooltip.bloodmagic.currentOwner", binding.getOwnerName()));
+	}
+}

src/main/java/wayoftime/bloodmagic/common/item/ItemBloodOrb.java

@@ -0,0 +1,106 @@
+package wayoftime.bloodmagic.common.item;
+
+import java.util.List;
+import java.util.function.Supplier;
+
+import javax.annotation.Nullable;
+
+import net.minecraft.client.util.ITooltipFlag;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.Hand;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.util.SoundEvents;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TranslationTextComponent;
+import net.minecraft.world.World;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraftforge.common.extensions.IForgeItem;
+import wayoftime.bloodmagic.core.data.Binding;
+import wayoftime.bloodmagic.core.data.SoulNetwork;
+import wayoftime.bloodmagic.core.data.SoulTicket;
+import wayoftime.bloodmagic.orb.BloodOrb;
+import wayoftime.bloodmagic.orb.IBloodOrb;
+import wayoftime.bloodmagic.util.helper.NetworkHelper;
+import wayoftime.bloodmagic.util.helper.PlayerHelper;
+
+public class ItemBloodOrb extends ItemBindableBase implements IBloodOrb, IForgeItem
+{
+	private final Supplier<BloodOrb> sup;
+
+	public ItemBloodOrb(Supplier<BloodOrb> sup)
+	{
+		this.sup = sup;
+	}
+
+	@Override
+	public BloodOrb getOrb(ItemStack stack)
+	{
+		return sup.get();
+	}
+
+	@Override
+	public ActionResult<ItemStack> onItemRightClick(World world, PlayerEntity player, Hand hand)
+	{
+		ItemStack stack = player.getHeldItem(hand);
+		BloodOrb orb = getOrb(stack);
+
+		if (orb == null)
+			return ActionResult.resultFail(stack);
+
+		if (world == null)
+			return super.onItemRightClick(world, player, hand);
+
+		world.playSound(null, player.getPosX(), player.getPosY(), player.getPosZ(), SoundEvents.BLOCK_FIRE_EXTINGUISH, SoundCategory.BLOCKS, 0.5F, 2.6F
+				+ (world.rand.nextFloat() - world.rand.nextFloat()) * 0.8F);
+
+		if (PlayerHelper.isFakePlayer(player))
+			return super.onItemRightClick(world, player, hand);
+
+		if (!stack.hasTag())
+			return super.onItemRightClick(world, player, hand);
+
+		Binding binding = getBinding(stack);
+		if (binding == null)
+			return super.onItemRightClick(world, player, hand);
+
+		if (world.isRemote)
+			return super.onItemRightClick(world, player, hand);
+
+		SoulNetwork ownerNetwork = NetworkHelper.getSoulNetwork(binding);
+		if (binding.getOwnerId().equals(player.getGameProfile().getId()))
+			ownerNetwork.setOrbTier(orb.getTier());
+
+		ownerNetwork.add(SoulTicket.item(stack, world, player, 200), orb.getCapacity()); // Add LP to owner's network
+		ownerNetwork.hurtPlayer(player, 200); // Hurt whoever is using it
+		return super.onItemRightClick(world, player, hand);
+	}
+
+	@Override
+	@OnlyIn(Dist.CLIENT)
+	public void addInformation(ItemStack stack, @Nullable World world, List<ITextComponent> tooltip, ITooltipFlag flag)
+	{
+		tooltip.add(new TranslationTextComponent("tooltip.bloodmagic.orb.desc"));
+
+		BloodOrb orb = getOrb(stack);
+		if (flag.isAdvanced() && orb != null)
+			tooltip.add(new TranslationTextComponent("tooltip.bloodmagic.orb.owner", stack.getItem().getRegistryName()));
+
+		super.addInformation(stack, world, tooltip, flag);
+	}
+
+//
+	@Override
+	public ItemStack getContainerItem(ItemStack stack)
+	{
+		return stack.copy();
+	}
+
+	@Override
+	public boolean hasContainerItem(ItemStack stack)
+	{
+		return true;
+	}
+}

src/main/java/wayoftime/bloodmagic/common/item/ItemDaggerOfSacrifice.java

@@ -0,0 +1,75 @@
+package wayoftime.bloodmagic.common.item;
+
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.entity.monster.IMob;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.entity.player.ServerPlayerEntity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.util.SoundEvents;
+import net.minecraftforge.common.util.FakePlayer;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.util.DamageSourceBloodMagic;
+import wayoftime.bloodmagic.util.helper.PlayerSacrificeHelper;
+
+public class ItemDaggerOfSacrifice extends Item
+{
+	public ItemDaggerOfSacrifice()
+	{
+		super(new Item.Properties().maxStackSize(1).group(BloodMagic.TAB));
+	}
+
+	@Override
+	public boolean hitEntity(ItemStack stack, LivingEntity target, LivingEntity attacker)
+	{
+		if (attacker instanceof FakePlayer)
+			return false;
+
+		if (target == null || attacker == null || attacker.getEntityWorld().isRemote
+				|| (attacker instanceof PlayerEntity && !(attacker instanceof ServerPlayerEntity)))
+			return false;
+
+		if (!target.isNonBoss())
+			return false;
+
+		if (target instanceof PlayerEntity)
+			return false;
+
+		if (target.isChild() && !(target instanceof IMob))
+			return false;
+
+		if (!target.isAlive() || target.getHealth() < 0.5F)
+			return false;
+
+//		EntityEntry entityEntry = EntityRegistry.getEntry(target.getClass());
+//		if (entityEntry == null)
+//			return false;
+//		int lifeEssenceRatio = BloodMagicAPI.INSTANCE.getValueManager().getSacrificial().getOrDefault(entityEntry.getRegistryName(), 25);
+		int lifeEssenceRatio = 25;
+
+		if (lifeEssenceRatio <= 0)
+			return false;
+
+		int lifeEssence = (int) (lifeEssenceRatio * target.getHealth());
+//		if (target instanceof AnimalEntity)
+//		{
+//			lifeEssence = (int) (lifeEssence * (1 + PurificationHelper.getCurrentPurity((AnimalEntity) target)));
+//		}
+
+		if (target.isChild())
+		{
+			lifeEssence *= 0.5F;
+		}
+
+		if (PlayerSacrificeHelper.findAndFillAltar(attacker.getEntityWorld(), target, lifeEssence, true))
+		{
+			target.getEntityWorld().playSound(null, target.getPosX(), target.getPosY(), target.getPosZ(), SoundEvents.BLOCK_FIRE_EXTINGUISH, SoundCategory.BLOCKS, 0.5F, 2.6F
+					+ (target.getEntityWorld().rand.nextFloat() - target.getEntityWorld().rand.nextFloat()) * 0.8F);
+			target.setHealth(-1);
+			target.onDeath(DamageSourceBloodMagic.INSTANCE);
+		}
+
+		return false;
+	}
+}

src/main/java/wayoftime/bloodmagic/common/item/ItemInscriptionTool.java

@@ -0,0 +1,66 @@
+package wayoftime.bloodmagic.common.item;
+
+import java.util.List;
+
+import net.minecraft.block.BlockState;
+import net.minecraft.client.util.ITooltipFlag;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.inventory.EquipmentSlotType;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.ItemUseContext;
+import net.minecraft.util.ActionResultType;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TranslationTextComponent;
+import net.minecraft.world.World;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.common.block.BlockRitualStone;
+import wayoftime.bloodmagic.ritual.EnumRuneType;
+import wayoftime.bloodmagic.util.helper.TextHelper;
+
+public class ItemInscriptionTool extends Item
+{
+	private final EnumRuneType type;
+
+	public ItemInscriptionTool(EnumRuneType type)
+	{
+		super(new Item.Properties().maxStackSize(1).group(BloodMagic.TAB).maxDamage(40));
+
+		this.type = type;
+	}
+
+	@Override
+	public ActionResultType onItemUse(ItemUseContext context)
+	{
+		ItemStack stack = context.getItem();
+		BlockPos pos = context.getPos();
+		World world = context.getWorld();
+		PlayerEntity player = context.getPlayer();
+		BlockState state = world.getBlockState(pos);
+
+		if (state.getBlock() instanceof BlockRitualStone
+				&& !((BlockRitualStone) state.getBlock()).isRuneType(world, pos, type))
+		{
+			((BlockRitualStone) state.getBlock()).setRuneType(world, pos, type);
+			if (!player.isCreative())
+			{
+				stack.damageItem(1, player, (entity) -> {
+					entity.sendBreakAnimation(EquipmentSlotType.MAINHAND);
+				});
+			}
+			return ActionResultType.SUCCESS;
+		}
+
+		return ActionResultType.FAIL;
+	}
+
+	@Override
+	@OnlyIn(Dist.CLIENT)
+	public void addInformation(ItemStack stack, World world, List<ITextComponent> tooltip, ITooltipFlag flag)
+	{
+		tooltip.add(new TranslationTextComponent(TextHelper.localizeEffect("tooltip.bloodmagic.inscriber.desc")));
+	}
+}

src/main/java/wayoftime/bloodmagic/common/item/ItemLavaCrystal.java

@@ -0,0 +1,117 @@
+package wayoftime.bloodmagic.common.item;
+
+import net.minecraft.advancements.CriteriaTriggers;
+import net.minecraft.block.Blocks;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.entity.player.ServerPlayerEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.ItemUseContext;
+import net.minecraft.potion.EffectInstance;
+import net.minecraft.potion.Effects;
+import net.minecraft.util.ActionResultType;
+import net.minecraft.util.Direction;
+import net.minecraft.util.Hand;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.util.SoundEvents;
+import net.minecraft.util.math.BlockPos;
+import wayoftime.bloodmagic.core.data.Binding;
+import wayoftime.bloodmagic.core.data.SoulTicket;
+import wayoftime.bloodmagic.util.helper.NetworkHelper;
+import wayoftime.bloodmagic.util.helper.PlayerHelper;
+
+//TODO: Make some hook somewhere that attaches the pos to the ticket otherwise the tickets are basically useless lmao
+public class ItemLavaCrystal extends ItemBindableBase
+{
+	public ItemLavaCrystal()
+	{
+		super();
+	}
+
+	@Override
+	public ItemStack getContainerItem(ItemStack stack)
+	{
+		Binding binding = getBinding(stack);
+		if (binding != null)
+			NetworkHelper.getSoulNetwork(binding.getOwnerId()).syphon(SoulTicket.item(stack, 50));
+
+		ItemStack returnStack = new ItemStack(this);
+		returnStack.setTag(stack.getTag());
+		return returnStack;
+	}
+
+	@Override
+	public boolean hasContainerItem(ItemStack stack)
+	{
+		return true;
+	}
+
+	@Override
+	public int getBurnTime(ItemStack stack)
+	{
+		Binding binding = getBinding(stack);
+		if (binding == null)
+			return -1;
+
+//		if (NetworkHelper.syphonFromContainer(stack, SoulTicket.item(stack, 25)))
+		if (NetworkHelper.canSyphonFromContainer(stack, 50))
+			return 200;
+		else
+		{
+			PlayerEntity player = PlayerHelper.getPlayerFromUUID(binding.getOwnerId());
+			if (player != null)
+				player.addPotionEffect(new EffectInstance(Effects.NAUSEA, 99));
+		}
+
+		return -1;
+	}
+
+//	@Nullable
+//	@Override
+//	public Binding getBinding(ItemStack stack)
+//	{
+//		if (stack.getTag() == null) // hasTagCompound doesn't work on empty stacks with tags
+//			return null;
+//
+//		NBTBase bindingTag = stack.getTag().get("binding");
+//		if (bindingTag == null || bindingTag.getId() != 10 || bindingTag.isEmpty()) // Make sure it's both a tag
+//																					// compound and that it has actual
+//																					// data.
+//			return null;
+//
+//		NBTTagCompound nbt = (NBTTagCompound) bindingTag;
+//		return new Binding(NBTUtil.getUUIDFromTag(nbt.getCompoundTag("id")), nbt.getString("name"));
+//	}
+
+	@Override
+	public ActionResultType onItemUse(ItemUseContext context)
+	{
+		BlockPos pos = context.getPos();
+		Direction facing = context.getFace();
+		pos = pos.offset(facing);
+		PlayerEntity player = context.getPlayer();
+		Hand hand = context.getHand();
+		ItemStack itemstack = player.getHeldItem(hand);
+
+		Binding binding = getBinding(player.getHeldItem(hand));
+
+		if (binding == null)
+			return ActionResultType.FAIL;
+
+		if (!player.canPlayerEdit(pos, facing, itemstack))
+			return ActionResultType.FAIL;
+
+		if (context.getWorld().isAirBlock(pos)
+				&& NetworkHelper.getSoulNetwork(binding).syphonAndDamage(player, SoulTicket.item(player.getHeldItem(hand), 100)).isSuccess())
+		{
+			context.getWorld().playSound(player, pos, SoundEvents.ITEM_FIRECHARGE_USE, SoundCategory.BLOCKS, 1.0F, random.nextFloat()
+					* 0.4F + 0.8F);
+			context.getWorld().setBlockState(pos, Blocks.FIRE.getDefaultState(), 11);
+		} else
+			return ActionResultType.FAIL;
+
+		if (player instanceof ServerPlayerEntity)
+			CriteriaTriggers.PLACED_BLOCK.trigger((ServerPlayerEntity) player, pos, itemstack);
+
+		return ActionResultType.SUCCESS;
+	}
+}

src/main/java/wayoftime/bloodmagic/common/item/ItemRitualDiviner.java

@@ -0,0 +1,598 @@
+package wayoftime.bloodmagic.common.item;
+
+import java.util.Collections;
+import java.util.List;
+
+import com.google.common.collect.Lists;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.util.ITooltipFlag;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.BlockItem;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.ItemUseContext;
+import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.particles.ParticleTypes;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.ActionResultType;
+import net.minecraft.util.Direction;
+import net.minecraft.util.Hand;
+import net.minecraft.util.NonNullList;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.RayTraceContext;
+import net.minecraft.util.math.RayTraceResult;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.StringTextComponent;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.util.text.TranslationTextComponent;
+import net.minecraft.world.World;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.common.block.BlockRitualStone;
+import wayoftime.bloodmagic.common.block.BloodMagicBlocks;
+import wayoftime.bloodmagic.ritual.EnumRuneType;
+import wayoftime.bloodmagic.ritual.Ritual;
+import wayoftime.bloodmagic.ritual.RitualComponent;
+import wayoftime.bloodmagic.tile.TileMasterRitualStone;
+import wayoftime.bloodmagic.util.Constants;
+import wayoftime.bloodmagic.util.Utils;
+import wayoftime.bloodmagic.util.handler.event.ClientHandler;
+import wayoftime.bloodmagic.util.helper.RitualHelper;
+import wayoftime.bloodmagic.util.helper.TextHelper;
+import wayoftime.bloodmagic.will.EnumDemonWillType;
+
+public class ItemRitualDiviner extends Item
+{
+	final int type;
+	public static final String tooltipBase = "tooltip.bloodmagic.diviner.";
+	public static String[] names =
+	{ "normal", "dusk", "dawn" };
+
+	public ItemRitualDiviner(int type)
+	{
+		super(new Item.Properties().maxStackSize(1).group(BloodMagic.TAB));
+		this.type = type;
+	}
+
+//	@Override
+//	public String getHighlightTip(ItemStack stack, String displayName)
+//	{
+//		if (Strings.isNullOrEmpty(getCurrentRitual(stack)))
+//			return displayName;
+//
+//		Ritual ritual = BloodMagic.RITUAL_MANAGER.getRitual(getCurrentRitual(stack));
+//		if (ritual == null)
+//			return displayName;
+//
+//		return displayName + ": " + TextHelper.localize(ritual.getTranslationKey());
+//	}
+
+	@Override
+	public ActionResultType onItemUse(ItemUseContext context)
+	{
+		ItemStack stack = context.getPlayer().getHeldItem(context.getHand());
+		if (context.getPlayer().isSneaking())
+		{
+			if (context.getWorld().isRemote)
+			{
+				trySetDisplayedRitual(stack, context.getWorld(), context.getPos());
+			}
+
+			return ActionResultType.SUCCESS;
+		} else if (addRuneToRitual(stack, context.getWorld(), context.getPos(), context.getPlayer()))
+		{
+			if (context.getWorld().isRemote)
+			{
+				spawnParticles(context.getWorld(), context.getPos().offset(context.getFace()), 15);
+			}
+
+			return ActionResultType.SUCCESS;
+			// TODO: Have the diviner automagically build the ritual
+		}
+
+		return ActionResultType.PASS;
+	}
+
+	/**
+	 * Adds a single rune to the ritual.
+	 *
+	 * @param stack  - The Ritual Diviner stack
+	 * @param world  - The World
+	 * @param pos    - Block Position of the MRS.
+	 * @param player - The Player attempting to place the ritual
+	 * @return - True if a rune was successfully added
+	 */
+	public boolean addRuneToRitual(ItemStack stack, World world, BlockPos pos, PlayerEntity player)
+	{
+		TileEntity tile = world.getTileEntity(pos);
+
+		if (tile instanceof TileMasterRitualStone)
+		{
+			Ritual ritual = BloodMagic.RITUAL_MANAGER.getRitual(this.getCurrentRitual(stack));
+			if (ritual != null)
+			{
+				Direction direction = getDirection(stack);
+				List<RitualComponent> components = Lists.newArrayList();
+				ritual.gatherComponents(components::add);
+				for (RitualComponent component : components)
+				{
+					if (!canPlaceRitualStone(component.getRuneType(), stack))
+					{
+						return false;
+					}
+					BlockPos offset = component.getOffset(direction);
+					BlockPos newPos = pos.add(offset);
+					BlockState state = world.getBlockState(newPos);
+					Block block = state.getBlock();
+					if (RitualHelper.isRune(world, newPos))
+					{
+						if (RitualHelper.isRuneType(world, newPos, component.getRuneType()))
+						{
+							if (world.isRemote)
+							{
+								undisplayHologram();
+							}
+						} else
+						{
+							// Replace existing ritual stone
+							RitualHelper.setRuneType(world, newPos, component.getRuneType());
+							return true;
+						}
+					} else if (block.isAir(state, world, newPos))// || block.isReplaceable(world, newPos))
+					{
+						if (!consumeStone(stack, world, player))
+						{
+							return false;
+						}
+						((BlockRitualStone) BloodMagicBlocks.BLANK_RITUAL_STONE.get()).setRuneType(world, newPos, component.getRuneType());
+						return true;
+					} else
+					{
+						return false; // TODO: Possibly replace the block with a
+						// ritual stone
+					}
+				}
+			}
+		}
+
+		return false;
+	}
+
+	@OnlyIn(Dist.CLIENT)
+	public void trySetDisplayedRitual(ItemStack itemStack, World world, BlockPos pos)
+	{
+		TileEntity tile = world.getTileEntity(pos);
+
+		if (tile instanceof TileMasterRitualStone)
+		{
+			Ritual ritual = BloodMagic.RITUAL_MANAGER.getRitual(this.getCurrentRitual(itemStack));
+			TileMasterRitualStone masterRitualStone = (TileMasterRitualStone) tile;
+
+			if (ritual != null)
+			{
+				Direction direction = getDirection(itemStack);
+				ClientHandler.setRitualHolo(masterRitualStone, ritual, direction, true);
+			}
+		}
+	}
+
+	@OnlyIn(Dist.CLIENT)
+	public void undisplayHologram()
+	{
+		ClientHandler.setRitualHoloToNull();
+	}
+
+	// TODO: Make this work for any IRitualStone
+	public boolean consumeStone(ItemStack stack, World world, PlayerEntity player)
+	{
+		if (player.isCreative())
+		{
+			return true;
+		}
+
+		NonNullList<ItemStack> inventory = player.inventory.mainInventory;
+		for (ItemStack newStack : inventory)
+		{
+			if (newStack.isEmpty())
+			{
+
+				continue;
+			}
+			Item item = newStack.getItem();
+			if (item instanceof BlockItem)
+			{
+				Block block = ((BlockItem) item).getBlock();
+				if (block instanceof BlockRitualStone)
+				{
+					newStack.shrink(1);
+					return true;
+				}
+			}
+		}
+
+		return false;
+	}
+
+	@Override
+	@OnlyIn(Dist.CLIENT)
+	public void addInformation(ItemStack stack, World world, List<ITextComponent> tooltip, ITooltipFlag flag)
+	{
+		if (!stack.hasTag())
+			return;
+
+		Ritual ritual = BloodMagic.RITUAL_MANAGER.getRitual(this.getCurrentRitual(stack));
+		if (ritual != null)
+		{
+			tooltip.add(new TranslationTextComponent("tooltip.bloodmagic.diviner.currentRitual", new TranslationTextComponent(ritual.getTranslationKey())));
+
+			boolean sneaking = Screen.hasShiftDown();
+//			boolean extraInfo = sneaking && Keyboard.isKeyDown(Keyboard.KEY_M);
+			boolean extraInfo = sneaking && Screen.hasAltDown();
+
+			if (extraInfo)
+			{
+				tooltip.add(new StringTextComponent(""));
+
+				for (EnumDemonWillType type : EnumDemonWillType.values())
+				{
+					if (TextHelper.canTranslate(ritual.getTranslationKey() + "." + type.name().toLowerCase() + ".info"))
+					{
+						tooltip.add(new TranslationTextComponent(ritual.getTranslationKey() + "." + type.name().toLowerCase() + ".info"));
+					}
+				}
+			} else if (sneaking)
+			{
+				tooltip.add(new TranslationTextComponent(tooltipBase + "currentDirection", Utils.toFancyCasing(getDirection(stack).name())));
+				tooltip.add(new StringTextComponent(""));
+				List<RitualComponent> components = Lists.newArrayList();
+				ritual.gatherComponents(components::add);
+
+				int blankRunes = 0;
+				int airRunes = 0;
+				int waterRunes = 0;
+				int fireRunes = 0;
+				int earthRunes = 0;
+				int duskRunes = 0;
+				int dawnRunes = 0;
+				int totalRunes = components.size();
+
+				for (RitualComponent component : components)
+				{
+					switch (component.getRuneType())
+					{
+					case BLANK:
+						blankRunes++;
+						break;
+					case AIR:
+						airRunes++;
+						break;
+					case EARTH:
+						earthRunes++;
+						break;
+					case FIRE:
+						fireRunes++;
+						break;
+					case WATER:
+						waterRunes++;
+						break;
+					case DUSK:
+						duskRunes++;
+						break;
+					case DAWN:
+						dawnRunes++;
+						break;
+					}
+				}
+
+				if (blankRunes > 0)
+					tooltip.add(new TranslationTextComponent(tooltipBase + "blankRune", blankRunes).mergeStyle(EnumRuneType.BLANK.colorCode));
+				if (waterRunes > 0)
+					tooltip.add(new TranslationTextComponent(tooltipBase + "waterRune", waterRunes).mergeStyle(EnumRuneType.WATER.colorCode));
+				if (airRunes > 0)
+					tooltip.add(new TranslationTextComponent(tooltipBase + "airRune", airRunes).mergeStyle(EnumRuneType.AIR.colorCode));
+				if (fireRunes > 0)
+					tooltip.add(new TranslationTextComponent(tooltipBase + "fireRune", fireRunes).mergeStyle(EnumRuneType.FIRE.colorCode));
+				if (earthRunes > 0)
+					tooltip.add(new TranslationTextComponent(tooltipBase + "earthRune", earthRunes).mergeStyle(EnumRuneType.EARTH.colorCode));
+				if (duskRunes > 0)
+					tooltip.add(new TranslationTextComponent(tooltipBase + "duskRune", duskRunes).mergeStyle(EnumRuneType.DUSK.colorCode));
+				if (dawnRunes > 0)
+					tooltip.add(new TranslationTextComponent(tooltipBase + "dawnRune", dawnRunes).mergeStyle(EnumRuneType.DAWN.colorCode));
+
+				tooltip.add(new StringTextComponent(""));
+				tooltip.add(new TranslationTextComponent(tooltipBase + "totalRune", totalRunes));
+			} else
+			{
+				tooltip.add(new StringTextComponent(""));
+				if (TextHelper.canTranslate(ritual.getTranslationKey() + ".info"))
+				{
+					tooltip.add(new TranslationTextComponent(ritual.getTranslationKey() + ".info"));
+					tooltip.add(new StringTextComponent(""));
+				}
+
+				tooltip.add(new TranslationTextComponent(tooltipBase + "extraInfo").mergeStyle(TextFormatting.BLUE));
+				tooltip.add(new TranslationTextComponent(tooltipBase + "extraExtraInfo").mergeStyle(TextFormatting.BLUE));
+			}
+		}
+	}
+
+	@Override
+	public ActionResult<ItemStack> onItemRightClick(World world, PlayerEntity player, Hand hand)
+	{
+		ItemStack stack = player.getHeldItem(hand);
+
+		RayTraceResult ray = rayTrace(world, player, RayTraceContext.FluidMode.NONE);
+
+		if (ray != null && ray.getType() == RayTraceResult.Type.BLOCK)
+		{
+			return new ActionResult<>(ActionResultType.PASS, stack);
+		}
+
+		if (player.isSneaking())
+		{
+			if (!world.isRemote)
+			{
+				cycleRitual(stack, player, false);
+			}
+
+			return new ActionResult<>(ActionResultType.SUCCESS, stack);
+		} else
+		{
+			if (!world.isRemote)
+			{
+				cycleDirection(stack, player);
+			}
+		}
+
+		return new ActionResult<>(ActionResultType.PASS, stack);
+	}
+
+	@Override
+	public void onUse(World worldIn, LivingEntity entityLiving, ItemStack stack, int count)
+	{
+		if (!entityLiving.world.isRemote && entityLiving instanceof PlayerEntity)
+		{
+			PlayerEntity player = (PlayerEntity) entityLiving;
+
+			RayTraceResult ray = rayTrace(player.world, player, RayTraceContext.FluidMode.NONE);
+
+			if (ray != null && ray.getType() == RayTraceResult.Type.BLOCK)
+			{
+				return;
+//				return false;
+			}
+
+			if (!player.isSwingInProgress)
+			{
+				if (player.isSneaking())
+				{
+					cycleRitual(stack, player, true);
+				} else
+				{
+					cycleDirection(stack, player);
+				}
+			}
+		}
+
+//		return false;
+	}
+
+	public void cycleDirection(ItemStack stack, PlayerEntity player)
+	{
+		Direction direction = getDirection(stack);
+		Direction newDirection;
+		switch (direction)
+		{
+		case NORTH:
+			newDirection = Direction.EAST;
+			break;
+		case EAST:
+			newDirection = Direction.SOUTH;
+			break;
+		case SOUTH:
+			newDirection = Direction.WEST;
+			break;
+		case WEST:
+			newDirection = Direction.NORTH;
+			break;
+		default:
+			newDirection = Direction.NORTH;
+		}
+
+		setDirection(stack, newDirection);
+		notifyDirectionChange(newDirection, player);
+	}
+
+	public void notifyDirectionChange(Direction direction, PlayerEntity player)
+	{
+		player.sendStatusMessage(new TranslationTextComponent(tooltipBase + "currentDirection", Utils.toFancyCasing(direction.name())), true);
+	}
+
+	public void setDirection(ItemStack stack, Direction direction)
+	{
+		if (!stack.hasTag())
+		{
+			stack.setTag(new CompoundNBT());
+		}
+
+		CompoundNBT tag = stack.getTag();
+
+		tag.putInt(Constants.NBT.DIRECTION, direction.getIndex());
+	}
+
+	public Direction getDirection(ItemStack stack)
+	{
+		if (!stack.hasTag())
+		{
+			stack.setTag(new CompoundNBT());
+			return Direction.NORTH;
+		}
+
+		CompoundNBT tag = stack.getTag();
+
+		int dir = tag.getInt(Constants.NBT.DIRECTION);
+		if (dir == 0)
+		{
+			return Direction.NORTH;
+		}
+
+		return Direction.values()[tag.getInt(Constants.NBT.DIRECTION)];
+	}
+
+	/**
+	 * Cycles the ritual forward or backward
+	 */
+	public void cycleRitual(ItemStack stack, PlayerEntity player, boolean reverse)
+	{
+		String key = getCurrentRitual(stack);
+		List<Ritual> rituals = BloodMagic.RITUAL_MANAGER.getSortedRituals();
+		if (reverse)
+			Collections.reverse(rituals = Lists.newArrayList(rituals));
+
+		String firstId = "";
+		boolean foundId = false;
+		boolean foundFirst = false;
+
+		for (Ritual ritual : rituals)
+		{
+			String id = BloodMagic.RITUAL_MANAGER.getId(ritual);
+
+			if (!BloodMagic.RITUAL_MANAGER.enabled(id, false) || !canDivinerPerformRitual(stack, ritual))
+			{
+				continue;
+			}
+
+			if (!foundFirst)
+			{
+				firstId = id;
+				foundFirst = true;
+			}
+
+			if (foundId)
+			{
+				setCurrentRitual(stack, id);
+				notifyRitualChange(id, player);
+				return;
+			} else if (id.equals(key))
+			{
+				foundId = true;
+			}
+		}
+
+		if (foundFirst)
+		{
+			setCurrentRitual(stack, firstId);
+			notifyRitualChange(firstId, player);
+		}
+	}
+
+	public boolean canDivinerPerformRitual(ItemStack stack, Ritual ritual)
+	{
+		if (ritual == null)
+		{
+			return false;
+		}
+
+		List<RitualComponent> components = Lists.newArrayList();
+		ritual.gatherComponents(components::add);
+		for (RitualComponent component : components)
+		{
+			if (!canPlaceRitualStone(component.getRuneType(), stack))
+			{
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	public void notifyRitualChange(String key, PlayerEntity player)
+	{
+		Ritual ritual = BloodMagic.RITUAL_MANAGER.getRitual(key);
+		if (ritual != null)
+		{
+			player.sendStatusMessage(new TranslationTextComponent(ritual.getTranslationKey()), true);
+		}
+	}
+
+	public void setCurrentRitual(ItemStack stack, String key)
+	{
+		if (!stack.hasTag())
+		{
+			stack.setTag(new CompoundNBT());
+		}
+
+		CompoundNBT tag = stack.getTag();
+
+		tag.putString("current_ritual", key);
+	}
+
+	public String getCurrentRitual(ItemStack stack)
+	{
+		if (!stack.hasTag())
+		{
+			stack.setTag(new CompoundNBT());
+		}
+
+		CompoundNBT tag = stack.getTag();
+		return tag.getString("current_ritual");
+	}
+
+	public boolean canPlaceRitualStone(EnumRuneType rune, ItemStack stack)
+	{
+		int meta = type;
+		switch (rune)
+		{
+		case BLANK:
+		case AIR:
+		case EARTH:
+		case FIRE:
+		case WATER:
+			return true;
+		case DUSK:
+			return meta >= 1;
+		case DAWN:
+			return meta >= 2;
+		}
+
+		return false;
+	}
+
+	public static void spawnParticles(World worldIn, BlockPos pos, int amount)
+	{
+		BlockState state = worldIn.getBlockState(pos);
+		Block block = worldIn.getBlockState(pos).getBlock();
+
+		if (block.isAir(state, worldIn, pos))
+		{
+			for (int i = 0; i < amount; ++i)
+			{
+				double d0 = random.nextGaussian() * 0.02D;
+				double d1 = random.nextGaussian() * 0.02D;
+				double d2 = random.nextGaussian() * 0.02D;
+				worldIn.addParticle(ParticleTypes.HAPPY_VILLAGER, (double) ((float) pos.getX()
+						+ random.nextFloat()), (double) pos.getY()
+								+ (double) random.nextFloat(), (double) ((float) pos.getZ()
+										+ random.nextFloat()), d0, d1, d2);
+			}
+		} else
+		{
+			for (int i1 = 0; i1 < amount; ++i1)
+			{
+				double d0 = random.nextGaussian() * 0.02D;
+				double d1 = random.nextGaussian() * 0.02D;
+				double d2 = random.nextGaussian() * 0.02D;
+				worldIn.addParticle(ParticleTypes.HAPPY_VILLAGER, (double) ((float) pos.getX()
+						+ random.nextFloat()), (double) pos.getY()
+								+ (double) random.nextFloat()
+										* 1.0f, (double) ((float) pos.getZ() + random.nextFloat()), d0, d1, d2);
+			}
+		}
+	}
+}

src/main/java/wayoftime/bloodmagic/common/item/ItemSacrificialDagger.java

@@ -0,0 +1,204 @@
+package wayoftime.bloodmagic.common.item;
+
+import java.util.List;
+
+import net.minecraft.client.util.ITooltipFlag;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.UseAction;
+import net.minecraft.particles.RedstoneParticleData;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.Hand;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.util.SoundEvents;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TranslationTextComponent;
+import net.minecraft.world.World;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraftforge.common.MinecraftForge;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.ConfigHandler;
+import wayoftime.bloodmagic.event.SacrificeKnifeUsedEvent;
+import wayoftime.bloodmagic.util.Constants;
+import wayoftime.bloodmagic.util.DamageSourceBloodMagic;
+import wayoftime.bloodmagic.util.helper.NBTHelper;
+import wayoftime.bloodmagic.util.helper.PlayerHelper;
+import wayoftime.bloodmagic.util.helper.PlayerSacrificeHelper;
+
+public class ItemSacrificialDagger extends Item
+{
+
+	public ItemSacrificialDagger()
+	{
+		super(new Item.Properties().maxStackSize(1).group(BloodMagic.TAB));
+	}
+
+	@Override
+	@OnlyIn(Dist.CLIENT)
+	public void addInformation(ItemStack stack, World world, List<ITextComponent> tooltip, ITooltipFlag flag)
+	{
+//		tooltip.addAll(Arrays.asList(TextHelper.cutLongString(TextHelper.localizeEffect("tooltip.bloodmagic.sacrificialDagger.desc"))));
+		tooltip.add(new TranslationTextComponent("tooltip.bloodmagic.sacrificialdagger.desc"));
+
+//		if (stack.getItemDamage() == 1)
+//			list.add(TextHelper.localizeEffect("tooltip.bloodmagic.sacrificialDagger.creative"));
+	}
+
+	@Override
+	public void onPlayerStoppedUsing(ItemStack stack, World worldIn, LivingEntity entityLiving, int timeLeft)
+	{
+		if (entityLiving instanceof PlayerEntity && !entityLiving.getEntityWorld().isRemote)
+			PlayerSacrificeHelper.sacrificePlayerHealth((PlayerEntity) entityLiving);
+	}
+
+	@Override
+	public int getUseDuration(ItemStack stack)
+	{
+		return 72000;
+	}
+
+	@Override
+	public UseAction getUseAction(ItemStack stack)
+	{
+		return UseAction.BOW;
+	}
+
+	@Override
+	public ActionResult<ItemStack> onItemRightClick(World world, PlayerEntity player, Hand hand)
+	{
+		ItemStack stack = player.getHeldItem(hand);
+		if (PlayerHelper.isFakePlayer(player))
+			return super.onItemRightClick(world, player, hand);
+
+		if (this.canUseForSacrifice(stack))
+		{
+			player.setActiveHand(hand);
+			return ActionResult.resultSuccess(stack);
+		}
+
+		int lpAdded = ConfigHandler.values.sacrificialDaggerConversion * 2;
+
+//		RayTraceResult rayTrace = rayTrace(world, player, false);
+//		if (rayTrace != null && rayTrace.typeOfHit == RayTraceResult.Type.BLOCK)
+//		{
+//			TileEntity tile = world.getTileEntity(rayTrace.getBlockPos());
+//
+//			if (tile != null && tile instanceof TileAltar && stack.getItemDamage() == 1)
+//				lpAdded = ((TileAltar) tile).getCapacity();
+//		}
+
+		if (!player.abilities.isCreativeMode)
+		{
+			SacrificeKnifeUsedEvent evt = new SacrificeKnifeUsedEvent(player, true, true, 2, lpAdded);
+			if (MinecraftForge.EVENT_BUS.post(evt))
+				return super.onItemRightClick(world, player, hand);
+
+			if (evt.shouldDrainHealth)
+			{
+				player.hurtResistantTime = 0;
+				player.attackEntityFrom(DamageSourceBloodMagic.INSTANCE, 0.001F);
+				player.setHealth(Math.max(player.getHealth() - 1.998F, 0.0001f));
+				if (player.getHealth() <= 0.001f && !world.isRemote)
+				{
+					player.onDeath(DamageSourceBloodMagic.INSTANCE);
+					player.setHealth(0);
+				}
+//                player.attackEntityFrom(BloodMagicAPI.getDamageSource(), 2.0F);
+			}
+
+			if (!evt.shouldFillAltar)
+				return super.onItemRightClick(world, player, hand);
+
+			lpAdded = evt.lpAdded;
+		}
+
+		double posX = player.getPosX();
+		double posY = player.getPosY();
+		double posZ = player.getPosZ();
+		world.playSound(null, posX, posY, posZ, SoundEvents.BLOCK_FIRE_EXTINGUISH, SoundCategory.BLOCKS, 0.5F, 2.6F
+				+ (world.rand.nextFloat() - world.rand.nextFloat()) * 0.8F);
+
+		for (int l = 0; l < 8; ++l) world.addParticle(RedstoneParticleData.REDSTONE_DUST, posX + Math.random()
+				- Math.random(), posY + Math.random() - Math.random(), posZ + Math.random() - Math.random(), 0, 0, 0);
+
+		if (!world.isRemote && PlayerHelper.isFakePlayer(player))
+			return super.onItemRightClick(world, player, hand);
+
+		// TODO - Check if SoulFray is active
+		PlayerSacrificeHelper.findAndFillAltar(world, player, lpAdded, false);
+
+		return super.onItemRightClick(world, player, hand);
+	}
+
+	@Override
+	public void inventoryTick(ItemStack stack, World world, Entity entity, int itemSlot, boolean isSelected)
+	{
+		if (!world.isRemote && entity instanceof PlayerEntity)
+			this.setUseForSacrifice(stack, this.isPlayerPreparedForSacrifice(world, (PlayerEntity) entity));
+	}
+
+	public boolean isPlayerPreparedForSacrifice(World world, PlayerEntity player)
+	{
+		return !world.isRemote && (PlayerSacrificeHelper.getPlayerIncense(player) > 0);
+	}
+
+	public boolean canUseForSacrifice(ItemStack stack)
+	{
+		stack = NBTHelper.checkNBT(stack);
+		return stack.getTag().getBoolean(Constants.NBT.SACRIFICE);
+	}
+
+	public void setUseForSacrifice(ItemStack stack, boolean sacrifice)
+	{
+		stack = NBTHelper.checkNBT(stack);
+		stack.getTag().putBoolean(Constants.NBT.SACRIFICE, sacrifice);
+	}
+
+//	@Override
+//	@SideOnly(Side.CLIENT)
+//	public ItemMeshDefinition getMeshDefinition()
+//	{
+//		return stack -> {
+//			String variant = "type=normal";
+//			if (stack.getItemDamage() != 0)
+//				variant = "type=creative";
+//
+//			if (canUseForSacrifice(stack))
+//				variant = "type=ceremonial";
+//
+//			return new ModelResourceLocation(getRegistryName(), variant);
+//		};
+//	}
+//
+//	@Override
+//	public void gatherVariants(Consumer<String> variants)
+//	{
+//		variants.accept("type=normal");
+//		variants.accept("type=creative");
+//		variants.accept("type=ceremonial");
+//	}
+//
+//	public enum DaggerType implements ISubItem
+//	{
+//
+//		NORMAL, CREATIVE,;
+//
+//		@Nonnull
+//		@Override
+//		public String getInternalName()
+//		{
+//			return name().toLowerCase(Locale.ROOT);
+//		}
+//
+//		@Nonnull
+//		@Override
+//		public ItemStack getStack(int count)
+//		{
+//			return new ItemStack(RegistrarBloodMagicItems.SACRIFICIAL_DAGGER, count, ordinal());
+//		}
+//	}
+}

src/main/java/wayoftime/bloodmagic/common/item/ItemSigil.java

@@ -0,0 +1,64 @@
+package wayoftime.bloodmagic.common.item;
+
+import java.util.List;
+
+import net.minecraft.client.util.ITooltipFlag;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TranslationTextComponent;
+import net.minecraft.world.World;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import wayoftime.bloodmagic.core.data.Binding;
+import wayoftime.bloodmagic.iface.IBindable;
+import wayoftime.bloodmagic.iface.ISigil;
+import wayoftime.bloodmagic.util.Constants;
+import wayoftime.bloodmagic.util.helper.NBTHelper;
+
+/**
+ * Base class for all (static) sigils.
+ */
+public class ItemSigil extends Item implements IBindable, ISigil
+{
+	private int lpUsed;
+
+	public ItemSigil(Properties prop, int lpUsed)
+	{
+		super(prop);
+
+		this.lpUsed = lpUsed;
+	}
+
+	public boolean isUnusable(ItemStack stack)
+	{
+		NBTHelper.checkNBT(stack);
+
+		return stack.getTag().getBoolean(Constants.NBT.UNUSABLE);
+	}
+
+	public ItemStack setUnusable(ItemStack stack, boolean unusable)
+	{
+		NBTHelper.checkNBT(stack);
+
+		stack.getTag().putBoolean(Constants.NBT.UNUSABLE, unusable);
+		return stack;
+	}
+
+	public int getLpUsed()
+	{
+		return lpUsed;
+	}
+
+	@Override
+	@OnlyIn(Dist.CLIENT)
+	public void addInformation(ItemStack stack, World world, List<ITextComponent> tooltip, ITooltipFlag flag)
+	{
+		if (!stack.hasTag())
+			return;
+
+		Binding binding = getBinding(stack);
+		if (binding != null)
+			tooltip.add(new TranslationTextComponent("tooltip.bloodmagic.currentOwner", binding.getOwnerName()));
+	}
+}

src/main/java/wayoftime/bloodmagic/common/item/sigil/ItemSigilAir.java

@@ -0,0 +1,62 @@
+package wayoftime.bloodmagic.common.item.sigil;
+
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.Hand;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.util.SoundEvents;
+import net.minecraft.util.math.vector.Vector3d;
+import net.minecraft.world.World;
+import wayoftime.bloodmagic.core.data.SoulTicket;
+import wayoftime.bloodmagic.iface.ISigil;
+import wayoftime.bloodmagic.util.helper.NetworkHelper;
+import wayoftime.bloodmagic.util.helper.PlayerHelper;
+
+public class ItemSigilAir extends ItemSigilBase
+{
+	public ItemSigilAir()
+	{
+		super("air", 50);
+	}
+
+	@Override
+	public ActionResult<ItemStack> onItemRightClick(World world, PlayerEntity player, Hand hand)
+	{
+		ItemStack stack = player.getHeldItem(hand);
+		if (stack.getItem() instanceof ISigil.Holding)
+			stack = ((Holding) stack.getItem()).getHeldItem(stack, player);
+		if (PlayerHelper.isFakePlayer(player))
+			return ActionResult.resultFail(stack);
+
+		boolean unusable = isUnusable(stack);
+		if (world.isRemote && !unusable)
+		{
+			Vector3d vec = player.getLookVec();
+			double wantedVelocity = 1.7;
+
+			// TODO - Revisit after potions
+//			if (player.isPotionActive(RegistrarBloodMagic.BOOST))
+//			{
+//				int amplifier = player.getActivePotionEffect(RegistrarBloodMagic.BOOST).getAmplifier();
+//				wantedVelocity += (1 + amplifier) * (0.35);
+//			}
+
+			player.setMotion(vec.x * wantedVelocity, vec.y * wantedVelocity, vec.z * wantedVelocity);
+
+			world.playSound(null, player.getPosX(), player.getPosY(), player.getPosZ(), SoundEvents.BLOCK_FIRE_EXTINGUISH, SoundCategory.BLOCKS, 0.5F, 2.6F
+					+ (world.rand.nextFloat() - world.rand.nextFloat()) * 0.8F);
+		}
+
+		if (!world.isRemote)
+		{
+			if (!player.isCreative())
+				this.setUnusable(stack, !NetworkHelper.getSoulNetwork(getBinding(stack)).syphonAndDamage(player, SoulTicket.item(stack, world, player, getLpUsed())).isSuccess());
+
+			if (!unusable)
+				player.fallDistance = 0;
+		}
+
+		return super.onItemRightClick(world, player, hand);
+	}
+}

src/main/java/wayoftime/bloodmagic/common/item/sigil/ItemSigilBase.java

@@ -0,0 +1,51 @@
+package wayoftime.bloodmagic.common.item.sigil;
+
+import java.util.List;
+
+import net.minecraft.client.util.ITooltipFlag;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TranslationTextComponent;
+import net.minecraft.world.World;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import wayoftime.bloodmagic.BloodMagic;
+import wayoftime.bloodmagic.common.item.ItemSigil;
+
+public class ItemSigilBase extends ItemSigil
+{
+	protected final String tooltipBase;
+//	private final String name;
+
+	public ItemSigilBase(String name, int lpUsed)
+	{
+		super(new Item.Properties().maxStackSize(1).group(BloodMagic.TAB), lpUsed);
+//		super(lpUsed);
+
+//		this.name = name;
+		this.tooltipBase = "tooltip.bloodmagic.sigil." + name + ".";
+	}
+
+	public ItemSigilBase(String name)
+	{
+		this(name, 0);
+	}
+
+	@Override
+	@OnlyIn(Dist.CLIENT)
+	public void addInformation(ItemStack stack, World world, List<ITextComponent> tooltip, ITooltipFlag flag)
+	{
+		tooltip.add(new TranslationTextComponent(tooltipBase + "desc"));
+//		if (TextHelper.canTranslate(tooltipBase + "desc"))
+//			tooltip.addAll(Arrays.asList(WordUtils.wrap(TextHelper.localizeEffect(tooltipBase
+//					+ "desc"), 30, "/cut", false).split("/cut")));
+
+		super.addInformation(stack, world, tooltip, flag);
+	}
+
+//	public String getName()
+//	{
+//		return name;
+//	}
+}

src/main/java/wayoftime/bloodmagic/common/item/sigil/ItemSigilBloodLight.java

@@ -0,0 +1,104 @@
+package wayoftime.bloodmagic.common.item.sigil;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.Hand;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.BlockRayTraceResult;
+import net.minecraft.util.math.RayTraceContext;
+import net.minecraft.util.math.RayTraceResult;
+import net.minecraft.world.World;
+import wayoftime.bloodmagic.common.block.BloodMagicBlocks;
+import wayoftime.bloodmagic.core.data.SoulNetwork;
+import wayoftime.bloodmagic.core.data.SoulTicket;
+import wayoftime.bloodmagic.entity.projectile.EntityBloodLight;
+import wayoftime.bloodmagic.iface.ISigil;
+import wayoftime.bloodmagic.util.Constants;
+import wayoftime.bloodmagic.util.helper.NBTHelper;
+import wayoftime.bloodmagic.util.helper.NetworkHelper;
+import wayoftime.bloodmagic.util.helper.PlayerHelper;
+
+public class ItemSigilBloodLight extends ItemSigilBase
+{
+	public ItemSigilBloodLight()
+	{
+		super("bloodlight", 10);
+	}
+
+	@Override
+	public void inventoryTick(ItemStack stack, World worldIn, Entity entityIn, int itemSlot, boolean isSelected)
+	{
+		if (getCooldownRemainder(stack) > 0)
+			reduceCooldown(stack);
+	}
+
+	@Override
+	public ActionResult<ItemStack> onItemRightClick(World world, PlayerEntity player, Hand hand)
+	{
+		ItemStack stack = player.getHeldItem(hand);
+		if (stack.getItem() instanceof ISigil.Holding)
+			stack = ((Holding) stack.getItem()).getHeldItem(stack, player);
+		if (PlayerHelper.isFakePlayer(player))
+			return ActionResult.resultFail(stack);
+
+		RayTraceResult mop = rayTrace(world, player, RayTraceContext.FluidMode.NONE);
+
+		if (getCooldownRemainder(stack) > 0)
+			return super.onItemRightClick(world, player, hand);
+
+		if (mop != null && mop.getType() == RayTraceResult.Type.BLOCK)
+		{
+			BlockRayTraceResult blockRayTrace = (BlockRayTraceResult) mop;
+			BlockPos blockPos = blockRayTrace.getPos().offset(blockRayTrace.getFace());
+
+			if (world.isAirBlock(blockPos))
+			{
+				world.setBlockState(blockPos, BloodMagicBlocks.BLOOD_LIGHT.get().getDefaultState());
+				if (!world.isRemote)
+				{
+					SoulNetwork network = NetworkHelper.getSoulNetwork(getBinding(stack));
+					network.syphonAndDamage(player, SoulTicket.item(stack, world, player, getLpUsed()));
+				}
+				resetCooldown(stack);
+				player.swingArm(hand);
+				return super.onItemRightClick(world, player, hand);
+			}
+		} else
+		{
+			if (!world.isRemote)
+			{
+				SoulNetwork network = NetworkHelper.getSoulNetwork(getBinding(stack));
+				EntityBloodLight light = new EntityBloodLight(world, player);
+				light.func_234612_a_(player, player.rotationPitch, player.rotationYaw, 0.0F, 1.5F, 1.0F);
+				world.addEntity(light);
+				network.syphonAndDamage(player, SoulTicket.item(stack, world, player, getLpUsed()));
+			}
+			resetCooldown(stack);
+		}
+
+		return super.onItemRightClick(world, player, hand);
+	}
+
+	@Override
+	public boolean shouldCauseReequipAnimation(ItemStack oldStack, ItemStack newStack, boolean slotChanged)
+	{
+		return oldStack.getItem() != newStack.getItem();
+	}
+
+	public int getCooldownRemainder(ItemStack stack)
+	{
+		return NBTHelper.checkNBT(stack).getTag().getInt(Constants.NBT.TICKS_REMAINING);
+	}
+
+	public void reduceCooldown(ItemStack stack)
+	{
+		NBTHelper.checkNBT(stack).getTag().putInt(Constants.NBT.TICKS_REMAINING, getCooldownRemainder(stack) - 1);
+	}
+
+	public void resetCooldown(ItemStack stack)
+	{
+		NBTHelper.checkNBT(stack).getTag().putInt(Constants.NBT.TICKS_REMAINING, 10);
+	}
+}

src/main/java/wayoftime/bloodmagic/common/item/sigil/ItemSigilDivination.java

@@ -0,0 +1,114 @@
+package wayoftime.bloodmagic.common.item.sigil;
+
+import java.util.List;
+
+import com.google.common.collect.Lists;
+
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.Hand;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.RayTraceContext.FluidMode;
+import net.minecraft.util.math.RayTraceResult;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TranslationTextComponent;
+import net.minecraft.world.World;
+import wayoftime.bloodmagic.altar.IBloodAltar;
+import wayoftime.bloodmagic.core.data.Binding;
+import wayoftime.bloodmagic.iface.IAltarReader;
+import wayoftime.bloodmagic.iface.ISigil;
+import wayoftime.bloodmagic.util.ChatUtil;
+import wayoftime.bloodmagic.util.helper.NetworkHelper;
+import wayoftime.bloodmagic.util.helper.NumeralHelper;
+import wayoftime.bloodmagic.util.helper.PlayerHelper;
+
+public class ItemSigilDivination extends ItemSigilBase implements IAltarReader
+{
+
+	public ItemSigilDivination(boolean simple)
+	{
+		super(simple ? "divination" : "seer");
+	}
+
+	@Override
+	public ActionResult<ItemStack> onItemRightClick(World world, PlayerEntity player, Hand hand)
+	{
+		ItemStack stack = player.getHeldItem(hand);
+		if (stack.getItem() instanceof ISigil.Holding)
+			stack = ((Holding) stack.getItem()).getHeldItem(stack, player);
+		if (PlayerHelper.isFakePlayer(player))
+			return ActionResult.resultFail(stack);
+
+		if (!world.isRemote)
+		{
+			RayTraceResult position = Item.rayTrace(world, player, FluidMode.NONE);
+
+			if (position == null || position.getType() == RayTraceResult.Type.MISS)
+			{
+				super.onItemRightClick(world, player, hand);
+
+				Binding binding = getBinding(stack);
+				if (binding != null)
+				{
+					int currentEssence = NetworkHelper.getSoulNetwork(binding).getCurrentEssence();
+					List<ITextComponent> toSend = Lists.newArrayList();
+					if (!binding.getOwnerId().equals(player.getGameProfile().getId()))
+						toSend.add(new TranslationTextComponent(tooltipBase + "otherNetwork", binding.getOwnerName()));
+					toSend.add(new TranslationTextComponent(tooltipBase + "currentEssence", currentEssence));
+					ChatUtil.sendNoSpam(player, toSend.toArray(new ITextComponent[toSend.size()]));
+				}
+			} else
+			{
+				if (position.getType() == RayTraceResult.Type.BLOCK)
+				{
+					TileEntity tile = world.getTileEntity(new BlockPos(position.getHitVec()));
+
+					if (tile != null && tile instanceof IBloodAltar)
+					{
+						IBloodAltar altar = (IBloodAltar) tile;
+						int tier = altar.getTier().ordinal() + 1;
+						int currentEssence = altar.getCurrentBlood();
+						int capacity = altar.getCapacity();
+						altar.checkTier();
+						ChatUtil.sendNoSpam(player, new TranslationTextComponent(tooltipBase
+								+ "currentAltarTier", NumeralHelper.toRoman(tier)), new TranslationTextComponent(tooltipBase
+										+ "currentEssence", currentEssence), new TranslationTextComponent(tooltipBase
+												+ "currentAltarCapacity", capacity));
+					}
+//                    else if (tile != null && tile instanceof TileIncenseAltar)
+//                    {
+//                        TileIncenseAltar altar = (TileIncenseAltar) tile;
+//                        altar.recheckConstruction();
+//                        double tranquility = altar.tranquility;
+//                        ChatUtil.sendNoSpam(player, new TextComponentTranslation(tooltipBase + "currentTranquility", (int) ((100D * (int) (100 * tranquility)) / 100d)), new TextComponentTranslation(tooltipBase + "currentBonus", (int) (100 * altar.incenseAddition)));
+//                    } else if (tile != null && tile instanceof TileInversionPillar)
+//                    {
+//                        TileInversionPillar pillar = (TileInversionPillar) tile;
+//                        double inversion = pillar.getCurrentInversion();
+//                        ChatUtil.sendNoSpam(player, new TextComponentTranslation(tooltipBase + "currentInversion", ((int) (10 * inversion)) / 10d));
+//                    } 
+					else
+					{
+						Binding binding = getBinding(stack);
+						if (binding != null)
+						{
+							int currentEssence = NetworkHelper.getSoulNetwork(binding).getCurrentEssence();
+							List<ITextComponent> toSend = Lists.newArrayList();
+							if (!binding.getOwnerId().equals(player.getGameProfile().getId()))
+								toSend.add(new TranslationTextComponent(tooltipBase
+										+ "otherNetwork", binding.getOwnerName()));
+							toSend.add(new TranslationTextComponent(tooltipBase + "currentEssence", currentEssence));
+							ChatUtil.sendNoSpam(player, toSend.toArray(new ITextComponent[toSend.size()]));
+						}
+					}
+				}
+			}
+
+		}
+
+		return super.onItemRightClick(world, player, hand);
+	}
+}

src/main/java/wayoftime/bloodmagic/common/item/sigil/ItemSigilFastMiner.java

@@ -0,0 +1,61 @@
+package wayoftime.bloodmagic.common.item.sigil;
+
+import java.util.List;
+
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.potion.EffectInstance;
+import net.minecraft.potion.Effects;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+import wayoftime.bloodmagic.util.DamageSourceBloodMagic;
+import wayoftime.bloodmagic.util.helper.PlayerHelper;
+
+public class ItemSigilFastMiner extends ItemSigilToggleableBase
+{
+	public ItemSigilFastMiner()
+	{
+		super("fast_miner", 100);
+	}
+
+	@Override
+	public void onSigilUpdate(ItemStack stack, World world, PlayerEntity player, int itemSlot, boolean isSelected)
+	{
+		if (PlayerHelper.isFakePlayer(player))
+			return;
+		player.addPotionEffect(new EffectInstance(Effects.HASTE, 2, 0, true, false));
+	}
+
+	@Override
+	public boolean performArrayEffect(World world, BlockPos pos)
+	{
+		double radius = 10;
+		int ticks = 600;
+		int potionPotency = 2;
+
+		AxisAlignedBB bb = new AxisAlignedBB(pos).grow(radius);
+		List<PlayerEntity> playerList = world.getEntitiesWithinAABB(PlayerEntity.class, bb);
+		for (PlayerEntity player : playerList)
+		{
+			if (!player.isPotionActive(Effects.HASTE) || (player.isPotionActive(Effects.HASTE)
+					&& player.getActivePotionEffect(Effects.HASTE).getAmplifier() < potionPotency))
+			{
+				player.addPotionEffect(new EffectInstance(Effects.HASTE, ticks, potionPotency));
+				if (!player.isCreative())
+				{
+					player.hurtResistantTime = 0;
+					player.attackEntityFrom(DamageSourceBloodMagic.INSTANCE, 1.0F);
+				}
+			}
+		}
+
+		return false;
+	}
+
+	@Override
+	public boolean hasArrayEffect()
+	{
+		return true;
+	}
+}

src/main/java/wayoftime/bloodmagic/common/item/sigil/ItemSigilFluidBase.java

@@ -0,0 +1,149 @@
+package wayoftime.bloodmagic.common.item.sigil;
+
+import javax.annotation.Nullable;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.util.Direction;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidUtil;
+import net.minecraftforge.fluids.capability.IFluidHandler;
+import net.minecraftforge.fluids.capability.IFluidHandler.FluidAction;
+import net.minecraftforge.fluids.capability.wrappers.BlockWrapper;
+
+public abstract class ItemSigilFluidBase extends ItemSigilBase
+{
+	// Class for sigils that interact with fluids, either creating or deleting them.
+	// Sigils still have to define their own onRightClick behavior, but the actual
+	// fluid-interacting code is largely limited to here.
+	public final FluidStack sigilFluid;
+
+	public ItemSigilFluidBase(String name, int lpUsed, FluidStack fluid)
+	{
+		super(name, lpUsed);
+		sigilFluid = fluid;
+	}
+
+	public ItemSigilFluidBase(String name, FluidStack fluid)
+	{
+		super(name);
+		sigilFluid = fluid;
+	}
+
+	public ItemSigilFluidBase(String name)
+	{
+		super(name);
+		sigilFluid = null;
+	}
+
+	// The following are handler functions for fluids, all genericized.
+	// They're all based off of the Forge FluidUtil methods, but directly taking the
+	// sigilFluid constant instead of getting an argument.
+
+	/*
+	 * Gets a fluid handler for the targeted block and siding. Works for both tile
+	 * entity liquid containers and fluid blocks. This one is literally identical to
+	 * the FluidUtil method of the same signature.
+	 */
+	@Nullable
+	protected IFluidHandler getFluidHandler(World world, BlockPos blockPos, @Nullable Direction side)
+	{
+		BlockState state = world.getBlockState(blockPos);
+		Block block = state.getBlock();
+
+		IFluidHandler targetFluidHandler = FluidUtil.getFluidHandler(world, blockPos, side).orElse(null);
+
+		if (targetFluidHandler == null)
+
+		{
+
+		}
+		return targetFluidHandler;
+//		if (block instanceof IFluidBlock)
+//			return new FluidBlockWrapper((IFluidBlock) block, world, blockPos);
+//		else if (block instanceof BlockLiquid)
+//			return new BlockLiquidWrapper((BlockLiquid) block, world, blockPos);
+//		return null;
+	}
+
+	/*
+	 * Tries to insert fluid into a fluid handler. If doTransfer is false, only
+	 * simulate the transfer. If true, actually do so. Returns true if the transfer
+	 * is successful, false otherwise.
+	 */
+	protected boolean tryInsertSigilFluid(IFluidHandler destination, boolean doTransfer)
+	{
+		if (destination == null)
+			return false;
+		return destination.fill(sigilFluid, doTransfer ? FluidAction.EXECUTE : FluidAction.SIMULATE) > 0;
+	}
+
+	/*
+	 * Tries basically the oppostive of the above, removing fluids instead of adding
+	 * them
+	 */
+	protected boolean tryRemoveFluid(IFluidHandler source, int amount, boolean doTransfer)
+	{
+		if (source == null)
+			return false;
+		return source.drain(amount, doTransfer ? FluidAction.EXECUTE : FluidAction.SIMULATE) != null;
+	}
+
+	/*
+	 * Tries to place a fluid block in the world. Returns true if successful,
+	 * otherwise false. This is the big troublesome one, oddly enough. It's
+	 * genericized in case anyone wants to create variant sigils with weird fluids.
+	 */
+	protected boolean tryPlaceSigilFluid(PlayerEntity player, World world, BlockPos blockPos)
+	{
+		BlockState state = sigilFluid.getFluid().getAttributes().getBlock(world, blockPos, sigilFluid.getFluid().getDefaultState());
+		BlockWrapper wrapper = new BlockWrapper(state, world, blockPos);
+		return wrapper.fill(sigilFluid, FluidAction.EXECUTE) > 0;
+//		// Make sure world coordinants are valid
+//		if (world == null || blockPos == null)
+//		{
+//			return false;
+//		}
+//		// Make sure fluid is placeable
+//		Fluid fluid = sigilFluid.getFluid();
+//		if (!fluid.getAttributes().canBePlacedInWorld(world, blockPos, sigilFluid))
+//		{
+//			return false;
+//		}
+//
+//		// Check if the block is an air block or otherwise replaceable
+//		BlockState state = world.getBlockState(blockPos);
+//		Material mat = state.getMaterial();
+//		boolean isDestSolid = mat.isSolid();
+//		boolean isDestReplaceable = state.getBlock().isReplaceable(state, fluid);
+//		if (!world.isAirBlock(blockPos) && isDestSolid && !isDestReplaceable)
+//		{
+//			return false;
+//		}
+//
+////		// If the fluid vaporizes, this exists here in the lava sigil solely so the code
+////		// is usable for other fluids
+////		if (world.provider.doesWaterVaporize() && fluid.doesVaporize(sigilFluid))
+////		{
+////			fluid.vaporize(player, world, blockPos, sigilFluid);
+////			return true;
+////		}
+//
+//		// Finally we've done enough checking to make sure everything at the end is
+//		// safe, let's place some fluid.
+//		IFluidHandler handler;
+//		Block block = fluid.getAttributes().getStateForPlacement(world, blockPos, sigilFluid).getBlockState().getBlock();
+//		if (block instanceof IFluidBlock)
+//		{
+//			handler = new FluidBlockWrapper((IFluidBlock) block, world, blockPos);
+//		} else if (block instanceof BlockLiquid)
+//			handler = new BlockLiquidWrapper((BlockLiquid) block, world, blockPos);
+//		else
+//			handler = new BlockWrapper(block, world, blockPos);
+//		return tryInsertSigilFluid(handler, true);
+////		return false;
+	}
+}

src/main/java/wayoftime/bloodmagic/common/item/sigil/ItemSigilFrost.java

@@ -0,0 +1,24 @@
+package wayoftime.bloodmagic.common.item.sigil;
+
+import net.minecraft.enchantment.FrostWalkerEnchantment;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import wayoftime.bloodmagic.util.helper.PlayerHelper;
+
+public class ItemSigilFrost extends ItemSigilToggleableBase
+{
+	public ItemSigilFrost()
+	{
+		super("frost", 100);
+	}
+
+	@Override
+	public void onSigilUpdate(ItemStack stack, World world, PlayerEntity player, int itemSlot, boolean isSelected)
+	{
+		if (PlayerHelper.isFakePlayer(player))
+			return;
+
+		FrostWalkerEnchantment.freezeNearby(player, world, player.getPosition(), 1);
+	}
+}

src/main/java/wayoftime/bloodmagic/common/item/sigil/ItemSigilGreenGrove.java

@@ -0,0 +1,114 @@
+package wayoftime.bloodmagic.common.item.sigil;
+
+import net.minecraft.block.BlockState;
+import net.minecraft.block.IGrowable;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.Direction;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.vector.Vector3d;
+import net.minecraft.world.World;
+import net.minecraft.world.server.ServerWorld;
+import wayoftime.bloodmagic.core.data.SoulTicket;
+import wayoftime.bloodmagic.util.helper.NetworkHelper;
+import wayoftime.bloodmagic.util.helper.PlayerHelper;
+
+public class ItemSigilGreenGrove extends ItemSigilToggleableBase
+{
+	public ItemSigilGreenGrove()
+	{
+		super("green_grove", 150);
+	}
+
+	@Override
+	public boolean onSigilUse(ItemStack stack, PlayerEntity player, World world, BlockPos blockPos, Direction side, Vector3d vec)
+	{
+		if (PlayerHelper.isFakePlayer(player))
+			return false;
+
+		if (NetworkHelper.getSoulNetwork(player).syphonAndDamage(player, SoulTicket.item(stack, world, player, getLpUsed())).isSuccess()
+				&& applyBonemeal(stack, world, blockPos, player))
+		{
+			if (!world.isRemote)
+			{
+				world.playEvent(2005, blockPos, 0);
+			}
+			return true;
+		}
+
+		return false;
+	}
+
+	@Override
+	public void onSigilUpdate(ItemStack stack, World worldIn, PlayerEntity player, int itemSlot, boolean isSelected)
+	{
+		if (PlayerHelper.isFakePlayer(player))
+			return;
+
+		int range = 3;
+		int verticalRange = 2;
+		int posX = (int) Math.round(player.getPosX() - 0.5f);
+		int posY = (int) player.getPosY();
+		int posZ = (int) Math.round(player.getPosZ() - 0.5f);
+		if (worldIn instanceof ServerWorld)
+		{
+			ServerWorld serverWorld = (ServerWorld) worldIn;
+			for (int ix = posX - range; ix <= posX + range; ix++)
+			{
+				for (int iz = posZ - range; iz <= posZ + range; iz++)
+				{
+					for (int iy = posY - verticalRange; iy <= posY + verticalRange; iy++)
+					{
+						BlockPos blockPos = new BlockPos(ix, iy, iz);
+						BlockState state = worldIn.getBlockState(blockPos);
+
+//						if (!BloodMagicAPI.INSTANCE.getBlacklist().getGreenGrove().contains(state))
+						{
+							if (state.getBlock() instanceof IGrowable)
+							{
+								if (worldIn.rand.nextInt(50) == 0)
+								{
+									BlockState preBlockState = worldIn.getBlockState(blockPos);
+									((IGrowable) state.getBlock()).grow(serverWorld, worldIn.rand, blockPos, state);
+
+									BlockState newState = worldIn.getBlockState(blockPos);
+									if (!newState.equals(preBlockState) && !worldIn.isRemote)
+										worldIn.playEvent(2005, blockPos, 0);
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+
+	}
+
+	private static boolean applyBonemeal(ItemStack stack, World worldIn, BlockPos pos, PlayerEntity player)
+	{
+		BlockState blockstate = worldIn.getBlockState(pos);
+		int hook = net.minecraftforge.event.ForgeEventFactory.onApplyBonemeal(player, worldIn, pos, blockstate, stack);
+		if (hook != 0)
+			return hook > 0;
+		if (blockstate.getBlock() instanceof IGrowable)
+		{
+			IGrowable igrowable = (IGrowable) blockstate.getBlock();
+			if (igrowable.canGrow(worldIn, pos, blockstate, worldIn.isRemote))
+			{
+				if (worldIn instanceof ServerWorld)
+				{
+					if (igrowable.canUseBonemeal(worldIn, worldIn.rand, pos, blockstate))
+					{
+						igrowable.grow((ServerWorld) worldIn, worldIn.rand, pos, blockstate);
+					}
+
+				}
+
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+}

src/main/java/wayoftime/bloodmagic/common/item/sigil/ItemSigilLava.java

@@ -0,0 +1,90 @@
+package wayoftime.bloodmagic.common.item.sigil;
+
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.fluid.Fluids;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.Direction;
+import net.minecraft.util.Hand;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.BlockRayTraceResult;
+import net.minecraft.util.math.RayTraceContext;
+import net.minecraft.util.math.RayTraceResult;
+import net.minecraft.world.World;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.capability.IFluidHandler;
+import wayoftime.bloodmagic.core.data.SoulTicket;
+import wayoftime.bloodmagic.iface.ISigil;
+import wayoftime.bloodmagic.util.helper.NetworkHelper;
+import wayoftime.bloodmagic.util.helper.PlayerHelper;
+
+public class ItemSigilLava extends ItemSigilFluidBase
+{
+	public ItemSigilLava()
+	{
+		super("lava", 1000, new FluidStack(Fluids.LAVA, 10000));
+	}
+
+	@Override
+	public ActionResult<ItemStack> onItemRightClick(World world, PlayerEntity player, Hand hand)
+	{
+		ItemStack stack = player.getHeldItem(hand);
+		if (stack.getItem() instanceof ISigil.Holding)
+			stack = ((Holding) stack.getItem()).getHeldItem(stack, player);
+		if (PlayerHelper.isFakePlayer(player))
+			return ActionResult.resultFail(stack);
+
+		if (!world.isRemote && !isUnusable(stack))
+		{
+			RayTraceResult rayTrace = rayTrace(world, player, RayTraceContext.FluidMode.NONE);
+
+			if (rayTrace == null || rayTrace.getType() != RayTraceResult.Type.BLOCK)
+			{
+				return ActionResult.resultFail(stack);
+			}
+
+			BlockRayTraceResult blockRayTrace = (BlockRayTraceResult) rayTrace;
+			BlockPos blockPos = blockRayTrace.getPos();
+			Direction sideHit = blockRayTrace.getFace();
+			BlockPos blockpos1 = blockPos.offset(sideHit);
+
+			if (world.isBlockModifiable(player, blockPos) && player.canPlayerEdit(blockpos1, sideHit, stack))
+			{
+
+				// Case for if block at blockPos is a fluid handler like a tank
+				// Try to put fluid into tank
+				IFluidHandler destination = getFluidHandler(world, blockPos, null);
+				if (destination != null && tryInsertSigilFluid(destination, false)
+						&& NetworkHelper.getSoulNetwork(getBinding(stack)).syphonAndDamage(player, SoulTicket.item(stack, world, player, getLpUsed())).isSuccess())
+				{
+					boolean result = tryInsertSigilFluid(destination, true);
+					if (result)
+						return ActionResult.resultSuccess(stack);
+				}
+				// Do the same as above, but use sidedness to interact with the fluid handler.
+				IFluidHandler destinationSide = getFluidHandler(world, blockPos, sideHit);
+				if (destinationSide != null && tryInsertSigilFluid(destinationSide, false)
+						&& NetworkHelper.getSoulNetwork(getBinding(stack)).syphonAndDamage(player, SoulTicket.item(stack, world, player, getLpUsed())).isSuccess())
+				{
+					boolean result = tryInsertSigilFluid(destinationSide, true);
+					if (result)
+						return ActionResult.resultSuccess(stack);
+				}
+
+				// Case for if block at blockPos is not a tank
+				// Place fluid in world
+				if (destination == null && destinationSide == null)
+				{
+					BlockPos targetPos = blockPos.offset(sideHit);
+					if (tryPlaceSigilFluid(player, world, targetPos)
+							&& NetworkHelper.getSoulNetwork(getBinding(stack)).syphonAndDamage(player, SoulTicket.item(stack, world, player, getLpUsed())).isSuccess())
+					{
+						return ActionResult.resultSuccess(stack);
+					}
+				}
+			}
+		}
+
+		return super.onItemRightClick(world, player, hand);
+	}
+}

src/main/java/wayoftime/bloodmagic/common/item/sigil/ItemSigilMagnetism.java

@@ -0,0 +1,54 @@
+package wayoftime.bloodmagic.common.item.sigil;
+
+import java.util.List;
+
+import net.minecraft.entity.item.ExperienceOrbEntity;
+import net.minecraft.entity.item.ItemEntity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.world.World;
+import wayoftime.bloodmagic.util.helper.PlayerHelper;
+
+public class ItemSigilMagnetism extends ItemSigilToggleableBase
+{
+	public ItemSigilMagnetism()
+	{
+		super("magnetism", 50);
+	}
+
+	@Override
+	public void onSigilUpdate(ItemStack stack, World world, PlayerEntity player, int itemSlot, boolean isSelected)
+	{
+		if (PlayerHelper.isFakePlayer(player))
+			return;
+
+		int range = 5;
+		int verticalRange = 5;
+		float posX = Math.round(player.getPosX());
+		float posY = (float) (player.getPosY() - player.getEyeHeight());
+		float posZ = Math.round(player.getPosZ());
+		List<ItemEntity> entities = player.getEntityWorld().getEntitiesWithinAABB(ItemEntity.class, new AxisAlignedBB(posX
+				- 0.5f, posY - 0.5f, posZ
+						- 0.5f, posX + 0.5f, posY + 0.5f, posZ + 0.5f).expand(range, verticalRange, range));
+		List<ExperienceOrbEntity> xpOrbs = player.getEntityWorld().getEntitiesWithinAABB(ExperienceOrbEntity.class, new AxisAlignedBB(posX
+				- 0.5f, posY - 0.5f, posZ
+						- 0.5f, posX + 0.5f, posY + 0.5f, posZ + 0.5f).expand(range, verticalRange, range));
+
+		for (ItemEntity entity : entities)
+		{
+			if (entity != null && !world.isRemote && entity.isAlive())
+			{
+				entity.onCollideWithPlayer(player);
+			}
+		}
+
+		for (ExperienceOrbEntity xpOrb : xpOrbs)
+		{
+			if (xpOrb != null && !world.isRemote)
+			{
+				xpOrb.onCollideWithPlayer(player);
+			}
+		}
+	}
+}

src/main/java/wayoftime/bloodmagic/common/item/sigil/ItemSigilToggleable.java

@@ -0,0 +1,119 @@
+package wayoftime.bloodmagic.common.item.sigil;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.ItemUseContext;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.ActionResultType;
+import net.minecraft.util.Direction;
+import net.minecraft.util.Hand;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.vector.Vector3d;
+import net.minecraft.world.World;
+import wayoftime.bloodmagic.common.item.ItemSigil;
+import wayoftime.bloodmagic.core.data.Binding;
+import wayoftime.bloodmagic.core.data.SoulTicket;
+import wayoftime.bloodmagic.iface.IActivatable;
+import wayoftime.bloodmagic.iface.ISigil;
+import wayoftime.bloodmagic.util.Constants;
+import wayoftime.bloodmagic.util.helper.NBTHelper;
+import wayoftime.bloodmagic.util.helper.NetworkHelper;
+import wayoftime.bloodmagic.util.helper.PlayerHelper;
+
+/**
+ * Base class for all toggleable sigils.
+ */
+public class ItemSigilToggleable extends ItemSigil implements IActivatable
+{
+
+	public ItemSigilToggleable(Properties property, int lpUsed)
+	{
+		super(property, lpUsed);
+	}
+
+	@Override
+	public boolean getActivated(ItemStack stack)
+	{
+		return !stack.isEmpty() && NBTHelper.checkNBT(stack).getTag().getBoolean(Constants.NBT.ACTIVATED);
+	}
+
+	@Override
+	public ItemStack setActivatedState(ItemStack stack, boolean activated)
+	{
+		if (!stack.isEmpty())
+		{
+			NBTHelper.checkNBT(stack).getTag().putBoolean(Constants.NBT.ACTIVATED, activated);
+			return stack;
+		}
+
+		return stack;
+	}
+
+	@Override
+	public ActionResult<ItemStack> onItemRightClick(World world, PlayerEntity player, Hand hand)
+	{
+		ItemStack stack = player.getHeldItem(hand);
+		if (stack.getItem() instanceof ISigil.Holding)
+			stack = ((Holding) stack.getItem()).getHeldItem(stack, player);
+		if (PlayerHelper.isFakePlayer(player))
+			return ActionResult.resultFail(stack);
+
+		if (!world.isRemote && !isUnusable(stack))
+		{
+			if (player.isSneaking())
+				setActivatedState(stack, !getActivated(stack));
+			if (getActivated(stack))
+				return super.onItemRightClick(world, player, hand);
+		}
+
+		return super.onItemRightClick(world, player, hand);
+	}
+
+	@Override
+	public ActionResultType onItemUse(ItemUseContext context)
+	{
+		World world = context.getWorld();
+		BlockPos blockpos = context.getPos();
+
+		PlayerEntity player = context.getPlayer();
+		ItemStack stack = context.getItem();
+		if (stack.getItem() instanceof ISigil.Holding)
+			stack = ((Holding) stack.getItem()).getHeldItem(stack, player);
+
+		Binding binding = getBinding(stack);
+		if (binding == null || player.isSneaking()) // Make sure Sigils are bound before handling. Also ignores while
+													// toggling state
+			return ActionResultType.PASS;
+
+		return onSigilUse(stack, player, world, blockpos, context.getFace(), context.getHitVec())
+				? ActionResultType.SUCCESS
+				: ActionResultType.FAIL;
+	}
+
+	public boolean onSigilUse(ItemStack itemStack, PlayerEntity player, World world, BlockPos blockPos, Direction side, Vector3d hitVec)
+	{
+		return false;
+	}
+
+	@Override
+	public void inventoryTick(ItemStack stack, World worldIn, Entity entityIn, int itemSlot, boolean isSelected)
+	{
+		if (!worldIn.isRemote && entityIn instanceof PlayerEntity && getActivated(stack))
+		{
+			if (entityIn.ticksExisted % 100 == 0)
+			{
+				if (!NetworkHelper.getSoulNetwork(getBinding(stack)).syphonAndDamage((PlayerEntity) entityIn, SoulTicket.item(stack, worldIn, entityIn, getLpUsed())).isSuccess())
+				{
+					setActivatedState(stack, false);
+				}
+			}
+
+			onSigilUpdate(stack, worldIn, (PlayerEntity) entityIn, itemSlot, isSelected);
+		}
+	}
+
+	public void onSigilUpdate(ItemStack stack, World world, PlayerEntity player, int itemSlot, boolean isSelected)
+	{
+	}
+}

src/main/java/wayoftime/bloodmagic/common/item/sigil/ItemSigilToggleableBase.java

@@ -0,0 +1,54 @@
+package wayoftime.bloodmagic.common.item.sigil;
+
+import java.util.List;
+
+import net.minecraft.client.util.ITooltipFlag;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TranslationTextComponent;
+import net.minecraft.world.World;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import wayoftime.bloodmagic.BloodMagic;
+
+public class ItemSigilToggleableBase extends ItemSigilToggleable// implements IMeshProvider
+{
+	protected final String tooltipBase;
+	private final String name;
+
+	public ItemSigilToggleableBase(String name, int lpUsed)
+	{
+		super(new Item.Properties().maxStackSize(1).group(BloodMagic.TAB), lpUsed);
+
+		this.name = name;
+		this.tooltipBase = "tooltip.bloodmagic.sigil." + name + ".";
+
+	}
+
+	@Override
+	@OnlyIn(Dist.CLIENT)
+	public void addInformation(ItemStack stack, World world, List<ITextComponent> tooltip, ITooltipFlag flag)
+	{
+		super.addInformation(stack, world, tooltip, flag);
+		if (!stack.hasTag())
+			return;
+
+		tooltip.add(new TranslationTextComponent("tooltip.bloodmagic." + (getActivated(stack) ? "activated"
+				: "deactivated")));
+	}
+
+//	@Override
+//	@SideOnly(Side.CLIENT)
+//	public ItemMeshDefinition getMeshDefinition()
+//	{
+//		return new CustomMeshDefinitionActivatable("sigil_" + name.toLowerCase(Locale.ROOT));
+//	}
+//
+//	@Override
+//	public void gatherVariants(Consumer<String> variants)
+//	{
+//		variants.accept("active=false");
+//		variants.accept("active=true");
+//	}
+}

src/main/java/wayoftime/bloodmagic/common/item/sigil/ItemSigilVoid.java

@@ -0,0 +1,85 @@
+package wayoftime.bloodmagic.common.item.sigil;
+
+import net.minecraft.block.BlockState;
+import net.minecraft.block.IBucketPickupHandler;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.fluid.Fluids;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.Direction;
+import net.minecraft.util.Hand;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.BlockRayTraceResult;
+import net.minecraft.util.math.RayTraceContext;
+import net.minecraft.util.math.RayTraceResult;
+import net.minecraft.world.World;
+import net.minecraftforge.fluids.FluidStack;
+import wayoftime.bloodmagic.core.data.SoulTicket;
+import wayoftime.bloodmagic.iface.ISigil;
+import wayoftime.bloodmagic.util.helper.NetworkHelper;
+import wayoftime.bloodmagic.util.helper.PlayerHelper;
+
+public class ItemSigilVoid extends ItemSigilFluidBase
+{
+	public ItemSigilVoid()
+	{
+		super("void", 50, new FluidStack(Fluids.EMPTY, 1000));
+	}
+
+	@Override
+	public ActionResult<ItemStack> onItemRightClick(World world, PlayerEntity player, Hand hand)
+	{
+		ItemStack stack = player.getHeldItem(hand);
+		if (stack.getItem() instanceof ISigil.Holding)
+			stack = ((Holding) stack.getItem()).getHeldItem(stack, player);
+		if (PlayerHelper.isFakePlayer(player))
+			return ActionResult.resultFail(stack);
+
+		if (!world.isRemote && !isUnusable(stack))
+		{
+			RayTraceResult rayTrace = rayTrace(world, player, RayTraceContext.FluidMode.SOURCE_ONLY);
+
+			if (rayTrace == null || rayTrace.getType() != RayTraceResult.Type.BLOCK)
+			{
+				return ActionResult.resultFail(stack);
+			}
+
+			BlockRayTraceResult blockRayTrace = (BlockRayTraceResult) rayTrace;
+			BlockPos blockPos = blockRayTrace.getPos();
+			Direction sideHit = blockRayTrace.getFace();
+
+			if (world.isBlockModifiable(player, blockPos) && player.canPlayerEdit(blockPos, sideHit, stack))
+			{
+				BlockState blockState = world.getBlockState(blockPos);
+				if (blockState.getBlock() instanceof IBucketPickupHandler)
+				{
+					if (NetworkHelper.getSoulNetwork(getBinding(stack)).syphonAndDamage(player, SoulTicket.item(stack, world, player, getLpUsed())).isSuccess())
+					{
+						((IBucketPickupHandler) blockState.getBlock()).pickupFluid(world, blockPos, blockState);
+						return ActionResult.resultSuccess(stack);
+					}
+				}
+				// Void is simpler than the other fluid sigils, because getFluidHandler grabs
+				// fluid blocks just fine
+				// So extract from fluid tanks with a null side; or drain fluid blocks.
+//				IFluidHandler destination = getFluidHandler(world, blockPos, sideHit);
+//				if (destination != null && tryRemoveFluid(destination, 1000, false)
+//						&& NetworkHelper.getSoulNetwork(getBinding(stack)).syphonAndDamage(player, SoulTicket.item(stack, world, player, getLpUsed())).isSuccess())
+//				{
+//					if (tryRemoveFluid(destination, 1000, true))
+//						return ActionResult.resultSuccess(stack);
+//				}
+//				// Do the same as above, but use sidedness to interact with the fluid handler.
+//				IFluidHandler destinationSide = getFluidHandler(world, blockPos, sideHit);
+//				if (destinationSide != null && tryRemoveFluid(destinationSide, 1000, false)
+//						&& NetworkHelper.getSoulNetwork(getBinding(stack)).syphonAndDamage(player, SoulTicket.item(stack, world, player, getLpUsed())).isSuccess())
+//				{
+//					if (tryRemoveFluid(destinationSide, 1000, true))
+//						return ActionResult.resultSuccess(stack);
+//				}
+			}
+		}
+
+		return super.onItemRightClick(world, player, hand);
+	}
+}