Merge remote-tracking branch 'upstream/master'

build.properties

@@ -1,13 +1,13 @@
 #
-#Mon May 11 13:18:11 EDT 2015
+#Sat May 30 11:48:23 EDT 2015
 mod_name=BloodMagic
 forge_version=10.13.3.1374-1.7.10
 ccc_version=1.0.4.29
 nei_version=1.0.3.64
 //=Dependency Information
-guideapi_version=1.0-14
+guideapi_version=1.0.1-19
 package_group=com.wayoftime.bloodmagic
-mod_version=1.3.2aBeta
+mod_version=1.3.3
 minetweaker_version=Dev-1.7.10-3.0.9B
-build_number=8
 mc_version=1.7.10
+build_number=3

src/api/java/pneumaticCraft/api/IHeatExchangerLogic.java

@@ -0,0 +1,77 @@
+package pneumaticCraft.api;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+/**
+ * DO NOT IMPLEMENT THIS CLASS YOURSELF! Use PneumaticRegistry.getInstance().getHeatExchangerLogic() !
+ * @author MineMaarten
+ * www.minemaarten.com
+ */
+public interface IHeatExchangerLogic{
+
+    /**
+     * Call this to tick this logic, and make the heat disperse itself.
+     */
+    public void update();
+
+    /**
+     * When called (preferably on tile entity load and neighbor block/tile entity change) this will add all IHeatExchanger neighbor TileEntities as connected heat exchangers.
+     * It will also take care of blocks like Lava.
+     * 
+     * You don't _have_ to call this method, if this heat exchanger is not connected to the outside world (for example the heat of the liquid
+     * plastic in the Plastic Mixer).
+     * @param world
+     * @param x
+     * @param y
+     * @param z
+     * @param validSides Can be left out as vararg, meaning every side can be connected. When one or more sides are specified this will constrain
+     * this heat exchanger to only connect to other heat exchangers on these sides.
+     */
+    public void initializeAsHull(World world, int x, int y, int z, ForgeDirection... validSides);
+
+    /**
+     * When called, this will connect these two heat exchangers. You should only call this on one of the two heat exchangers. 
+     * @param exchanger
+     */
+    public void addConnectedExchanger(IHeatExchangerLogic exchanger);
+
+    public void removeConnectedExchanger(IHeatExchangerLogic exchanger);
+
+    /**
+     * A heat exchanger starts with 295 degrees Kelvin (20 degrees Celcius) by default.
+     * @param temperature in degrees Kelvin
+     */
+    public void setTemperature(double temperature);
+
+    public double getTemperature();
+
+    /**
+     * The higher the thermal resistance, the slower the heat disperses.
+     * @param thermalResistance By default it's 1.
+     */
+    public void setThermalResistance(double thermalResistance);
+
+    public double getThermalResistance();
+
+    /**
+     * The higher the capacity, the more heat can be 'stored'. This means that an object with a high capacity can heat up an object with a lower
+     * capacity without losing any significant amount of temperature.
+     * @param capacity
+     */
+    public void setThermalCapacity(double capacity);
+
+    public double getThermalCapacity();
+
+    public void writeToNBT(NBTTagCompound tag);
+
+    public void readFromNBT(NBTTagCompound tag);
+
+    /**
+     * Adds heat (= deltaT * Thermal Capacity) to this exchanger. negative values will remove heat.
+     * @param amount
+     */
+    public void addHeat(double amount);
+
+}

src/api/java/pneumaticCraft/api/PneumaticRegistry.java

@@ -0,0 +1,158 @@
+package pneumaticCraft.api;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityCreature;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.fluids.Fluid;
+import pneumaticCraft.api.client.pneumaticHelmet.IBlockTrackEntry;
+import pneumaticCraft.api.client.pneumaticHelmet.IEntityTrackEntry;
+import pneumaticCraft.api.client.pneumaticHelmet.IHackableBlock;
+import pneumaticCraft.api.client.pneumaticHelmet.IHackableEntity;
+import pneumaticCraft.api.drone.ICustomBlockInteract;
+import pneumaticCraft.api.drone.IPathfindHandler;
+import pneumaticCraft.api.item.IInventoryItem;
+
+/**
+ * This class can be used to register and access various things to and from the mod.
+ */
+public class PneumaticRegistry{
+    /**
+     * This field, which is initialized in PneumaticCraft's preInit, will give you access to various registration and access options.
+     * @deprecated This field isn't going to be removed, but it'll be marked private. use getInstance().
+     */
+    @Deprecated
+    public static IPneumaticCraftInterface instance;
+
+    public static IPneumaticCraftInterface getInstance(){
+        return instance;
+    }
+
+    public static void init(IPneumaticCraftInterface inter){
+        if(instance == null) instance = inter;//only allow initialization once; by PneumaticCraft
+    }
+
+    public static interface IPneumaticCraftInterface{
+
+        /*
+         * ------------- Pneumatic Helmet --------------
+         */
+
+        public void registerEntityTrackEntry(Class<? extends IEntityTrackEntry> entry);
+
+        public void registerBlockTrackEntry(IBlockTrackEntry entry);
+
+        public void addHackable(Class<? extends Entity> entityClazz, Class<? extends IHackableEntity> iHackable);
+
+        public void addHackable(Block block, Class<? extends IHackableBlock> iHackable);
+
+        /**
+         * Returns a list of all current successful hacks of a given entity. This is used for example in Enderman hacking, so the user
+         * can only hack an enderman once (more times wouldn't have any effect). This is mostly used for display purposes.
+         * @param entity
+         * @return empty list if no hacks.
+         */
+        public List<IHackableEntity> getCurrentEntityHacks(Entity entity);
+
+        /*
+         * ------------- Drones --------------
+         */
+
+        /**
+         * Normally drones will pathfind through any block that doesn't have any collisions (Block#getBlocksMovement returns true).
+         * With this method you can register custom blocks to allow the drone to pathfind through them. If the block requires any special
+         * handling, like allow pathfinding on certain conditions, you can pass a IPathFindHandler with the registry.
+         * @param block
+         * @param handler can be null, to always allow pathfinding through this block.
+         */
+        public void addPathfindableBlock(Block block, IPathfindHandler handler);
+
+        /**
+         * This will add a puzzle piece that has only a Area white- and blacklist parameter (similar to a GoTo piece).
+         * It will do the specified behaviour. This can be used to create energy import/export widgets.
+         * @param interactor
+         */
+        public void registerCustomBlockInteractor(ICustomBlockInteract interactor);
+
+        /**
+         * Will spawn in a Drone a distance away from the given coordinate. The drone is programmed to travel to go to 5 blocks above the specified
+         * y level, and drop the deliveredStacks. When there isn't a clear path for the items to fall these 5 blocks the Drone will deliver at a
+         * y level above the specified y that _is_ clear. If no clear blocks can be found (when there are only solid blocks), the Drone will
+         * drop the items very high up in the air instead, and drop them there.
+         * 
+         * When the Drone is tried to be catched by a player (by wrenching it), the drone will only the drop the items that it was delivering (or
+         * none if it dropped those items already). The Drone itself never will be dropped.
+         * 
+         * @param x
+         * @param y
+         * @param z
+         * @param deliveredStacks stacks that are delivered by the drone. When no stacks, or more than 65 stacks are given, this will generate a IllegalArgumentException.
+         * @return the drone. You can use this to set a custom name for example (defaults to "Amazon Delivery Drone").
+         */
+        public EntityCreature deliverItemsAmazonStyle(World world, int x, int y, int z, ItemStack... deliveredStacks);
+
+        /*
+         * --------------- Items -------------------
+         */
+        /**
+         * See {@link pneumaticCraft.api.item.IInventoryItem}
+         * @param handler
+         */
+        public void registerInventoryItem(IInventoryItem handler);
+
+        /*
+         * ----------------- Heat System --------------
+         */
+        public IHeatExchangerLogic getHeatExchangerLogic();
+
+        public void registerBlockExchanger(Block block, double temperature, double thermalResistance);
+
+        /*
+         * ---------------- Power Generation -----------
+         */
+
+        /**
+         * Adds a burnable liquid to the Liquid Compressor's available burnable fuels.
+         * @param fluid
+         * @param mLPerBucket the amount of mL generated for 1000mB of the fuel. As comparison, one piece of coal generates 16000mL in an Air Compressor.
+         */
+        public void registerFuel(Fluid fluid, int mLPerBucket);
+
+        /*
+         * --------------- Misc -------------------
+         */
+
+        /**
+         * Returns the amount of Security Stations that disallow interaction with the given coordinate for the given player.
+         * Usually you'd disallow interaction when this returns > 0.
+         * @param world
+         * @param x
+         * @param y
+         * @param z
+         * @param player
+         * @param showRangeLines When true, any Security Station that prevents interaction will show the line grid (server --> client update is handled internally).
+         * @return The amount of Security Stations that disallow interaction for the given player.
+         * This method throws an IllegalArgumentException when tried to be called from the client side!
+         */
+        public int getProtectingSecurityStations(World world, int x, int y, int z, EntityPlayer player, boolean showRangeLines);
+
+        /**
+         * Use this to register ISimpleBlockRenderHandler render id's of full blocks, those of which should be able to be used for the Pneumatic Door Base camouflage.
+         * @param id
+         */
+        public void registerConcealableRenderId(int id);
+
+        /**
+         * Used to register a liquid that represents liquid XP (like MFR mob essence, OpenBlocks liquid XP).
+         * This is used in the Aerial Interface to pump XP in/out of the player.
+         * @param fluid
+         * @param liquidToPointRatio The amount of liquid (in mB) used to get one XP point. In OpenBlocks this is 20 (mB/point).
+         */
+        public void registerXPLiquid(Fluid fluid, int liquidToPointRatio);
+
+    }
+}

src/api/java/pneumaticCraft/api/actuator/IActuator.java

@@ -0,0 +1,32 @@
+package pneumaticCraft.api.actuator;
+
+import java.util.List;
+
+import net.minecraft.tileentity.TileEntity;
+
+public interface IActuator{
+    /**
+     * Same as {@link pneumaticCraft.api.universalSensor.ISensorSetting#getSensorPath()}
+     * @return
+     */
+    public String getSensorPath();
+
+    /**
+     * When returned true, the GUI will enable the textbox writing, otherwise not.
+     * @return
+     */
+    public boolean needsTextBox();
+
+    /**
+     * Should return the description of this sensor displayed in the GUI stat. Information should at least include
+     * when this sensor emits redstone and how (analog (1 through 15), or digital).
+     * @return
+     */
+    public List<String> getDescription();
+
+    /**
+     * 
+     * @param universalActuator
+     */
+    public void actuate(TileEntity universalActuator);
+}

src/api/java/pneumaticCraft/api/block/BlockSupplier.java

@@ -0,0 +1,77 @@
+package pneumaticCraft.api.block;
+
+import net.minecraft.block.Block;
+import cpw.mods.fml.common.registry.GameRegistry;
+
+public class BlockSupplier{
+    // private static Class blockClass;
+
+    /**
+     * @param blockName
+     * @return
+     */
+    public static Block getBlock(String blockName){
+        return GameRegistry.findBlock("PneumaticCraft", blockName);
+        /*try {
+            if(blockClass == null) blockClass = Class.forName("pneumaticCraft.common.block.Blockss");
+            return (Block)blockClass.getField(blockName).get(null);
+        } catch(Exception e) {
+            System.err.println("[PneumaticCraft API] Block supply failed for block: " + blockName);
+            return null;
+        }*/
+    }
+
+    /*
+     The following is a list of all the block names that can be passed as argument in getBlock(String) to get a PneumaticCraft block.
+     
+     
+     pressureTube               meta = tube type
+     airCompressor
+     airCannon
+     pressureChamberWall        meta < 6 ? wall : window
+     pressureChamberValve
+     pressureChamberInterface
+     squidPlant
+     fireFlower
+     creeperPlant
+     slimePlant
+     rainPlant
+     enderPlant
+     lightningPlant
+     adrenalinePlant
+     burstPlant
+     potionPlant
+     repulsionPlant
+     heliumPlant
+     flyingFlower
+     musicPlant
+     propulsionPlant
+     chopperPlant
+     chargingStation
+     elevatorBase
+     elevatorFrame
+     vacuumPump
+     pneumaticDoorBase
+     pneumaticDoor
+     assemblyPlatform
+     assemblyIOUnit
+     assemblyDrill
+     assemblyLaser
+     assemblyController
+     advancedPressureTube       meta = tube type (like 'pressureTube')
+     compressedIron
+     uvLightBox
+     etchingAcid
+     securityStation
+     universalSensor
+     pneumaticGenerator
+     electricCompressor
+     pneumaticEngine
+     kineticCompressor
+     aerialInterface
+     electrostaticCompressor
+     aphorismTile
+     omnidirectionalHopper
+
+     */
+}

src/api/java/pneumaticCraft/api/block/IPneumaticWrenchable.java

@@ -0,0 +1,14 @@
+package pneumaticCraft.api.block;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+/**
+ * Should be implemented by any block that allows to be rotated by a Pneumatic Wrench. It uses almost the same
+ * rotate method as the Vanilla (Forge) method. However it uses energy to rotate (when rotateBlock() return true).
+ */
+public interface IPneumaticWrenchable{
+
+    public boolean rotateBlock(World world, EntityPlayer player, int x, int y, int z, ForgeDirection side);
+}

src/api/java/pneumaticCraft/api/client/GuiAnimatedStatSupplier.java

@@ -0,0 +1,49 @@
+package pneumaticCraft.api.client;
+
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.item.ItemStack;
+
+/**
+ * With this class you can retrieve new instances of the PneumaticCraft's IGuiAnimatedStat implementation. You can use these in Gui's as 
+ * well as anywhere you like. When you use these in Gui's you need to pass a valid GuiScreen instance, if you don't you can just pass
+ * null.
+ */
+public class GuiAnimatedStatSupplier{
+    private static Class animatedStatClass;
+
+    public static IGuiAnimatedStat getAnimatedStat(GuiScreen gui, int backgroundColor){
+        return getAnimatedStat(new Class[]{GuiScreen.class, int.class}, gui, backgroundColor);
+    }
+
+    /**
+     * Returns a GuiAnimatedStat which uses an itemstack as static icon.
+     * @param gui
+     * @param iconStack
+     * @param backgroundColor
+     * @return
+     */
+    public static IGuiAnimatedStat getAnimatedStat(GuiScreen gui, ItemStack iconStack, int backgroundColor){
+        return getAnimatedStat(new Class[]{GuiScreen.class, int.class, ItemStack.class}, gui, backgroundColor, iconStack);
+    }
+
+    /**
+     * Returns a GuiAnimatedStat which uses a texture location as static icon.
+     * @param gui
+     * @param iconTexture / text
+     * @param backgroundColor
+     * @return
+     */
+    public static IGuiAnimatedStat getAnimatedStat(GuiScreen gui, String iconTexture, int backgroundColor){
+        return getAnimatedStat(new Class[]{GuiScreen.class, int.class, String.class}, gui, backgroundColor, iconTexture);
+    }
+
+    private static IGuiAnimatedStat getAnimatedStat(Class[] constructorClasses, Object... constructorParameters){
+        try {
+            if(animatedStatClass == null) animatedStatClass = Class.forName("pneumaticCraft.client.gui.widget.GuiAnimatedStat");
+            return (IGuiAnimatedStat)animatedStatClass.getConstructor(constructorClasses).newInstance(constructorParameters);
+        } catch(Exception e) {
+            System.err.println("Failed to retrieve an GuiAnimatedStat instance from PneumaticCraft.");
+        }
+        return null;
+    }
+}

src/api/java/pneumaticCraft/api/client/GuiElementRenderer.java

@@ -0,0 +1,32 @@
+package pneumaticCraft.api.client;
+
+import java.lang.reflect.Method;
+
+import net.minecraft.client.gui.FontRenderer;
+
+public class GuiElementRenderer{
+    private static Method drawGaugeMethod;
+
+    /**
+     * Draws a Pressure Gauge, the same which is also used in many PneumaticCraft applications.
+     * @param fontRenderer          fontrenderer used to draw the numbers of the pressure gauge.
+     * @param minPressure           The minimal pressure that needs to be displayed (this is -1 in most applications).
+     * @param maxPressure           The maximal pressure that needs to be rendererd (this is 7 for tier one machines, and 25 for tier two).
+     * @param dangerPressure        The transition pressure from green to red (this is 5 for tier one, and 29 for tier two machines).
+     * @param minWorkingPressure    The transition pressure from yellow to green (variates per machine).
+     * @param currentPressure       The pressure that the needle should point to.
+     * @param xPos                  x position of the gauge.
+     * @param yPos                  y position of the gauge.
+     * @param zLevel                z position of the gauge (Gui#zLevel, -90, for in normal GUI's).
+     */
+    public static void drawPressureGauge(FontRenderer fontRenderer, float minPressure, float maxPressure, float dangerPressure, float minWorkingPressure, float currentPressure, int xPos, int yPos, float zLevel){
+        try {
+            if(drawGaugeMethod == null) {
+                drawGaugeMethod = Class.forName("pneumaticCraft.client.gui.GuiUtils").getMethod("drawPressureGauge", FontRenderer.class, float.class, float.class, float.class, float.class, float.class, int.class, int.class, float.class);
+            }
+            drawGaugeMethod.invoke(null, fontRenderer, minPressure, maxPressure, dangerPressure, minWorkingPressure, currentPressure, xPos, yPos, zLevel);
+        } catch(Exception e) {
+            System.err.println("Failed to render a Pressure Gauge from PneumaticCraft.");
+        }
+    }
+}

src/api/java/pneumaticCraft/api/client/IGuiAnimatedStat.java

@@ -0,0 +1,179 @@
+package pneumaticCraft.api.client;
+
+import java.awt.Rectangle;
+import java.util.List;
+
+/**
+ * This interface doesn't have to be implemented. In PneumaticCraft there already is one class which implements this interface
+ * which is used many times in PneumaticCraft (GUI stats, Pneumatic Helmet 2D and 3D stats). You can get an instance of this
+ * class as well. Information about this you can find in GuiAnimatedStatSupplier.java. Implementing your own version of
+ * animated stats can be implemented as well via this interface, and they will interact with the PneumaticCraft GuiAnimatedStats
+ * if you implement it correctly.
+ */
+
+public interface IGuiAnimatedStat{
+
+    /**
+     * When you call this method with a set of coordinates representing the button location and dimensions, you'll get
+     * these parameters back scaled to the GuiAnimatedStat's scale.
+     * @param origX Button start X.
+     * @param origY Button start Y.
+     * @param width Button width.
+     * @param height Button height.
+     * @return rectangle containing the new location and dimensions.
+     */
+    public Rectangle getButtonScaledRectangle(int origX, int origY, int width, int height);
+
+    /**
+     * When passed 0.5F for example, the text of the stat will be half as big (so more text can fit into a certain area).
+     * @param scale
+     */
+    public void scaleTextSize(float scale);
+
+    /**
+     * Returns true if the statistic expands to the left.
+     * @return
+     */
+    public boolean isLeftSided();
+
+    /**
+     * Returns true if the statistic is done with expanding (when text will be displayed).
+     * @return
+     */
+    public boolean isDoneExpanding();
+
+    /**
+     * Pass true if the statistic should expand to the left, otherwise false.
+     * @param leftSided
+     */
+    public void setLeftSided(boolean leftSided);
+
+    /**
+     * Sets the main text of this stat. Every line should be stored in a seperate list element. Upon rendering,
+     * EnumChatFormattings will be respected. When you call this method, Too long lines will be divided into multiple shorter ones
+     * to fit in the GUI.
+     * @param text
+     * @return this, so you can chain calls.
+     */
+    public IGuiAnimatedStat setText(List<String> text);
+
+    /**
+     * Sets the line to a single line. Upon rendering,
+     * EnumChatFormattings will be respected. When you call this method, Too long lines will be divided into multiple shorter ones
+     * to fit in the GUI.
+     * @param text
+     * @return this, so you can chain calls.
+     */
+    public IGuiAnimatedStat setText(String text);
+
+    /**
+     * Sets the main text of this stat. Every line should be stored in a seperate list element. Upon rendering,
+     * EnumChatFormattings will be respected. This version of the text setting doesn't handle too long lines.
+     * @param text
+     */
+    public void setTextWithoutCuttingString(List<String> text);
+
+    /**
+     * Sets the title of this stat. It will automatically get the yellow color assigned.
+     * @param title
+     */
+    public void setTitle(String title);
+
+    /**
+     * Returns the title of this stat (obviously without color prefix).
+     * @return
+     */
+    public String getTitle();
+
+    /**
+     * Defines what dimensions the stat should have when it is not expanded (default 17x17) and resets the stat to these dimensions.
+     * Used in PneumaticCraft by the block/entity tracker stats, they are 0x0 when not expanded so it looks like they expand
+     * (and appear) from nothing.
+     * @param minWidth
+     * @param minHeight
+     */
+    public void setMinDimensionsAndReset(int minWidth, int minHeight);
+
+    /**
+     * When this stat gets a parent stat assigned, the y of this stat will be the same as the parent's plus this stat's
+     * baseY. This will cause this stat to move up and down when the parent's stat expands/moves.
+     * @param stat
+     */
+    public void setParentStat(IGuiAnimatedStat stat);
+
+    /**
+     * Sets the x location of this stat.
+     * @param x
+     */
+    public void setBaseX(int x);
+
+    /**
+     * Sets the base Y of this stat.
+     * @param y
+     */
+    public void setBaseY(int y);
+
+    /**
+     * Returns the real Y of this stat. This is the same as getBaseY when there is no parent stat, but if there is this method
+     * returns the value described in setParentStat(IGuiAnimatedStat stat).
+     * @return
+     */
+    public int getAffectedY();
+
+    public int getBaseX();
+
+    public int getBaseY();
+
+    /**
+     * Returns the Y size of this stat.
+     * @return
+     */
+    public int getHeight();
+
+    /**
+     * Returns the X size of this stat.
+     * @return
+     */
+    public int getWidth();
+
+    public Rectangle getBounds();
+
+    /**
+     * This method should be called every game tick to update the logic of the stat (expanding of the stat).
+     */
+    public void update();
+
+    /**
+     * Should be called every render tick when and where you want to render the stat.
+     * @param mouseX
+     * @param mouseY
+     * @param partialTicks
+     */
+    public void render(int mouseX, int mouseY, float partialTicks);
+
+    /**
+     * This method will handle mouse clicks. This will handle open/closing of the stat when the mouse clicks it.
+     * @param x
+     * @param y
+     * @param button
+     * @return
+     */
+    public void onMouseClicked(int x, int y, int button);
+
+    /**
+     * Forces the stat to close.
+     */
+    public void closeWindow();
+
+    /**
+     * Forces the stat to expand.
+     */
+    public void openWindow();
+
+    /**
+     * Returns true if the stat is expanding.
+     * @return
+     */
+    public boolean isClicked();
+
+}

src/api/java/pneumaticCraft/api/client/assemblymachine/AssemblyRenderOverriding.java

@@ -0,0 +1,55 @@
+package pneumaticCraft.api.client.assemblymachine;
+
+import java.util.HashMap;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+
+public class AssemblyRenderOverriding{
+    public static final HashMap<Integer, IAssemblyRenderOverriding> renderOverrides = new HashMap<Integer, IAssemblyRenderOverriding>();
+
+    public static void addRenderOverride(Block block, IAssemblyRenderOverriding renderOverride){
+        renderOverrides.put(Block.getIdFromBlock(block), renderOverride);
+    }
+
+    public static void addRenderOverride(Item item, IAssemblyRenderOverriding renderOverride){
+        renderOverrides.put(Item.getIdFromItem(item), renderOverride);
+    }
+
+    public static interface IAssemblyRenderOverriding{
+        /**
+         * This method will be called just before the IO Unit's held stack is being rendered. You can insert GL11 calls here to
+         * rotate the model for example. push and pop matrices are not needed, this is done for you.
+         *  You can also choose to do the whole rendering yourself, you'll need to return false then to indicate that
+         *  PneumaticCraft shouldn't render the item.
+         *  @param renderedStack itemStack that is being rendered
+         *  @return true if PneumaticCraft should render the item (after your changes), or false to cancel rendering.
+         */
+        public boolean applyRenderChangeIOUnit(ItemStack renderedStack);
+
+        /**
+         * Same deal as with the applyRenderChangeIOUnit(), but now for the Assembly Platform.
+         * @param renderedStack itemStack that is being rendered
+         * @return true if PneumaticCraft should render the item (after your changes), or false to cancel rendering.
+         */
+        public boolean applyRenderChangePlatform(ItemStack renderedStack);
+
+        /**
+         * Should return the distance the claw travels before it is gripped to the stack.
+         * By default it's 0.0875F for items and 0.00625F for blocks, 0.09375 when the claw is completely closed.
+         * @param renderedStack
+         * @return
+         */
+        public float getIOUnitClawShift(ItemStack renderedStack);
+
+        /**
+         * Should return the distance the claw travels before it is gripped to the stack.
+         * By default it's 0.0875F for items and 0.00625F for blocks, 0.09375 when the claw is completely closed.
+         * @param renderedStack
+         * @return
+         */
+        public float getPlatformClawShift(ItemStack renderedStack);
+
+    }
+}

src/api/java/pneumaticCraft/api/client/pneumaticHelmet/IBlockTrackEntry.java

@@ -0,0 +1,80 @@
+package pneumaticCraft.api.client.pneumaticHelmet;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+
+public interface IBlockTrackEntry{
+    /**
+     * This method should return true if the coordinate checked is one that
+     * should be tracked. Most entries will just return true when the blockID is
+     * the one that they track.
+     * 
+     * @param world
+     *            The world that is examined.
+     * @param x
+     *            The x coordinate of the block examined.
+     * @param y
+     *            The y coordinate of the block examined.
+     * @param z
+     *            The z coordinate of the block examined.
+     * @param block
+     *            The block of the current coordinate. This will save you a
+     *            call to World.getBlock().
+     * @param te  The TileEntity at this x,y,z.
+     * @return true if the coordinate should be tracked by this BlockTrackEntry.
+     */
+    public boolean shouldTrackWithThisEntry(IBlockAccess world, int x, int y, int z, Block block, TileEntity te);
+
+    /**
+     * This method defines if the block should be updated by the server (each 5
+     * seconds). This is specifically aimed at Tile Entities, as the server will
+     * send an NBT packet. This method returns true at for instance Chests and
+     * Mob Spawners, to get the inventory at the client side and the time to the
+     * next spawn respectively.
+     * @param te The TileEntity at the currently checked location.
+     * 
+     * @return true if the Tile Entity should be updated, or false when it
+     *         doesn't have to.
+     */
+    public boolean shouldBeUpdatedFromServer(TileEntity te);
+
+    /**
+     * The return of this method defines at how many tracked blocks of this type
+     * the HUD should stop displaying text at the tracked blocks of this type.
+     * 
+     * @return amount of blocks the HUD should stop displaying the block info.
+     */
+    public int spamThreshold();
+
+    /**
+     * This method is called each render tick to retrieve the blocks additional
+     * information. The method behaves the same as the addInformation method in
+     * the Item class. This method only will be called if
+     * shouldTrackWithThisEntry() returned true and the player hovers over the
+     * coordinate.
+     * 
+     * @param world
+     *            The world the block is in.
+     * @param x
+     *            The x coordinate the block is at.
+     * @param y
+     *            The y coordinate the block is at.
+     * @param z
+     *            The z coordinate the block is at.
+     * @param te  The TileEntity at the x,y,z.
+     * @param infoList
+     *            The list of lines to display.
+     */
+    public void addInformation(World world, int x, int y, int z, TileEntity te, List<String> infoList);
+
+    /**
+     * This method is called when displaying the currently tracked blocks.
+     * Will be tried to be mapped to the localization file first.
+     * @return the name of the group of this entry.
+     */
+    public String getEntryName();
+}

src/api/java/pneumaticCraft/api/client/pneumaticHelmet/IEntityTrackEntry.java

@@ -0,0 +1,49 @@
+package pneumaticCraft.api.client.pneumaticHelmet;
+
+import java.util.List;
+
+import net.minecraft.entity.Entity;
+
+/**
+ * Implement this class and register it by adding it to the entityTrackEntries class.
+ * There needs to be a parameterless constructor. For every entity that's applicable for this definition, an instance is created.
+ */
+public interface IEntityTrackEntry{
+    /**
+     * Return true if you want to add a tooltip for the given entity.
+     * @param entity
+     * @return
+     */
+    public boolean isApplicable(Entity entity);
+
+    /**
+     * Add info to the tab. This is only called when isApplicable returned true.
+     * @param entity
+     * @param curInfo
+     */
+    public void addInfo(Entity entity, List<String> curInfo);
+
+    /**
+     * Update is called every (client) tick, and can be used to update something like a timer (used for the Creeper countdown).
+     * @param entity
+     */
+    public void update(Entity entity);
+
+    /**
+     * Called every render tick, this method can be used to render additional info. Used for Drone AI visualisation.
+     * @param entity
+     * @param partialTicks TODO
+     */
+    public void render(Entity entity, float partialTicks);
+
+    /**
+     * Just a basic implementation class that can be used if an update and render method isn't needed.
+     */
+    public static abstract class EntityTrackEntry implements IEntityTrackEntry{
+        @Override
+        public void update(Entity entity){}
+
+        @Override
+        public void render(Entity entity, float partialTicks){}
+    }
+}

src/api/java/pneumaticCraft/api/client/pneumaticHelmet/IGuiScreen.java

@@ -0,0 +1,15 @@
+package pneumaticCraft.api.client.pneumaticHelmet;
+
+import java.util.List;
+
+import net.minecraft.client.gui.FontRenderer;
+
+/**
+ * Just an interface to give access to GuiSreen#buttonList and GuiScreen#fontRenderer. An instance of this class can
+ * safely be casted to GuiSreen if needed.
+ */
+public interface IGuiScreen{
+    public List getButtonList();
+
+    public FontRenderer getFontRenderer();
+}

src/api/java/pneumaticCraft/api/client/pneumaticHelmet/IHackableBlock.java

@@ -0,0 +1,69 @@
+package pneumaticCraft.api.client.pneumaticHelmet;
+
+import java.util.List;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+
+/**
+Use this interface to specify any hackable block. When it's your block, you can simply implement this interface in the 
+block's class. If you don't have access to the class (vanilla blocks), you can implement this interface in a separate class
+and register it using PneumaticRegistry.registry.addHackable(blockClass, IHackableBlockClass). With the former way there will be one instance only per type. In the latter, there will
+be an IHackableBlock instance for every block.
+*/
+public interface IHackableBlock{
+    /**
+     * Should return a unique id to represent this hackable. Used in NBT saving to be able to trigger the afterHackTime after a server restart.
+     * Null is a valid return: afterHackTick will not be triggered at all in that case.
+     * 
+     * CURRENTLY THIS ISN'T IMPLEMENTED.
+     * @return
+     */
+    public String getId();
+
+    /**
+        Returning true will allow the player to hack this block. This can be used to only allow hacking on certain conditions.
+    */
+    public boolean canHack(IBlockAccess world, int x, int y, int z, EntityPlayer player);
+
+    /**
+        Add info that is displayed on the tracker tooltip here. Text like "Hack to explode" can be added.
+        This method is only called when canHack(World, int, int, int) returned true.
+        The added lines automatically will be tried to get localized.
+    */
+    public void addInfo(World world, int x, int y, int z, List<String> curInfo, EntityPlayer player);
+
+    /**
+     * Add info that is being displayed after hacking, as long as 'afterHackTick' is returning true.
+     * Things like "Neutralized".
+     * The added lines automatically will be tried to get localized.
+     * @param entity
+     * @param curInfo
+     * @param player
+     */
+    public void addPostHackInfo(World world, int x, int y, int z, List<String> curInfo, EntityPlayer player);
+
+    /**
+        Return the time it takes to hack this block in ticks. For more powerful hacks, a longer required hacking time is adviced.
+    */
+    public int getHackTime(IBlockAccess world, int x, int y, int z, EntityPlayer player);
+
+    /**
+        When the player hacked the block for getHackTime(World, int, int, int) ticks this will be called on both server and client side.
+    */
+    public void onHackFinished(World world, int x, int y, int z, EntityPlayer player);
+
+    /**
+     * Called every tick after the hacking finished (on both server and client side). Returning true will keep this going (for mob spawners, to keep them neutralized),
+     * or false to stop ticking (for door/lever hacking).
+     * 
+     * CURRENTLY THIS METHOD WILL STOP GETTING INVOKED AFTER A SERVER RESTART!
+     * @param world
+     * @param x
+     * @param y
+     * @param z
+     * @return
+     */
+    public boolean afterHackTick(World world, int x, int y, int z);
+}

src/api/java/pneumaticCraft/api/client/pneumaticHelmet/IHackableEntity.java

@@ -0,0 +1,59 @@
+package pneumaticCraft.api.client.pneumaticHelmet;
+
+import java.util.List;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+
+/**
+Use this interface to specify any hackable entity. When it's your entity, you can simply implement this interface in the 
+entity's class. If you don't have access to the class (vanilla entities), you can implement this interface in a separate class
+and register it using PneumaticRegistry.registry.addHackable(entityClass, IHackableEntityClass). In both ways there will be an IHackableEntity instance for every entity.
+*/
+public interface IHackableEntity{
+
+    /**
+     * Should return a unique id to represent this hackable. Used in NBT saving to be able to trigger the afterHackTime after a server restart.
+     * Null is a valid return: afterHackTick will not be triggered at all in that case.
+     * @return
+     */
+    public String getId();
+
+    /**
+    Returning true will allow the player to hack this entity. This can be used to only allow hacking on certain conditions.
+    */
+    public boolean canHack(Entity entity, EntityPlayer player);
+
+    /**
+        Add info that is displayed on the tracker tooltip here. Text like "Hack to explode" can be added.
+        This method is only called when canHack(Entity) returned true.
+        The added lines automatically will be tried to get localized.
+    */
+    public void addInfo(Entity entity, List<String> curInfo, EntityPlayer player);
+
+    /**
+     * Add info that is being displayed after hacking, as long as 'afterHackTick' is returning true.
+     * Things like "Neutralized".
+     * The added lines automatically will be tried to get localized.
+     * @param entity
+     * @param curInfo
+     * @param player
+     */
+    public void addPostHackInfo(Entity entity, List<String> curInfo, EntityPlayer player);
+
+    /**
+        Return the time it takes to hack this entity in ticks. For more powerful hacks, a longer required hacking time is adviced.
+    */
+    public int getHackTime(Entity entity, EntityPlayer player);
+
+    /**
+        When the player hacked the entity for getHackTime(Entity) ticks this will be called on both client and server side.
+    */
+    public void onHackFinished(Entity entity, EntityPlayer player);
+
+    /**
+     * Called every tick after the hacking finished. Returning true will keep this going (for mob spawners, to keep them neutralized),
+     * or false to stop ticking (for door/lever hacking).
+     */
+    public boolean afterHackTick(Entity entity);
+}

src/api/java/pneumaticCraft/api/client/pneumaticHelmet/IOptionPage.java

@@ -0,0 +1,46 @@
+package pneumaticCraft.api.client.pneumaticHelmet;
+
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.gui.GuiScreen;
+
+/**
+ * The Option Page is the page you see when you press 'F' (by default) with a Pneumatic Helmet equipped. You can register this class
+ * by returning a new instance of this class at {@link IUpgradeRenderHandler#getGuiOptionsPage()}
+ */
+public interface IOptionPage{
+
+    /**
+     * This string is used in the text of the button of this page.
+     * @return
+     */
+    public String getPageName();
+
+    /**
+     * Here you can initialize your buttons and stuff like with a GuiScreen. For buttons, don't use button id 100 and up, as they
+     * will be used as selection buttons for other option pages in the main GuiScreen.
+     * @param gui
+     */
+    public void initGui(IGuiScreen gui);
+
+    /**
+     * Same as GuiScreen#actionPerformed(GuiButton).
+     * @param button
+     */
+    public void actionPerformed(GuiButton button);
+
+    /**
+     * Same as {@link GuiScreen#drawScreen(int, int, float)}
+     * Here you can render additional things like text.
+     * @param x
+     * @param y
+     * @param partialTicks
+     */
+    public void drawScreen(int x, int y, float partialTicks);
+
+    /**
+     * Same as GuiScreen#keyTyped(char, int).
+     * @param ch
+     * @param key
+     */
+    public void keyTyped(char ch, int key);
+}

src/api/java/pneumaticCraft/api/client/pneumaticHelmet/IUpgradeRenderHandler.java

@@ -0,0 +1,92 @@
+package pneumaticCraft.api.client.pneumaticHelmet;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.config.Configuration;
+import pneumaticCraft.api.client.IGuiAnimatedStat;
+
+/**
+ * To add upgrades for in the Pneumatic Helmet implement this interface. You can add members to this class, however these can only 
+ * be client sided members as this class will be used as singleton. Therefore, only one of these instances exist at the server side
+ * so any member that is used server side will affect every player.
+ *
+ */
+public interface IUpgradeRenderHandler{
+
+    /**
+     * Return here the name of the upgrade. This is displayed in the formatting [upgradeName] + " " + "found"/"not found"  on
+     * initialization of the helmet.
+     * @return
+     */
+    public String getUpgradeName();
+
+    /**
+     * Being called from PneumaticCraft's config handler, you can use this method to read settings like stat positions
+     * @param config PneumaticCraft's config file.
+     */
+    public void initConfig(Configuration config);
+
+    /**
+     * When called this should save the settings to the config file. Called when changed a setting. When you want to use
+     * PneumaticCraft's config file, save a reference of it somewhere in this class when the config gets passed in the
+     * initConfig() method (this always will be called first).
+     */
+    public void saveToConfig();
+
+    /**
+     * This method will be called every client tick, and should be used to update logic like the tracking and velocities of stuff.
+     * @param player
+     * @param rangeUpgrades amount of range upgrades installed in the helmet.
+     */
+    public void update(EntityPlayer player, int rangeUpgrades);
+
+    /**
+     * Called in the 3D render stage (renderWorldLastEvent)
+     * @param partialTicks
+     */
+    public void render3D(float partialTicks);
+
+    /**
+     * Called in the 2D render stage (Render Tick Handler)
+     * @param partialTicks
+     * @param helmetEnabled is true when isEnabled() returned true earlier. Can be used to close AnimatedStats for instance.
+     * However this is already handled if you return an AnimatedStat in getAnimatedStat().
+     */
+    public void render2D(float partialTicks, boolean helmetEnabled);
+
+    /**
+     * You can return a GuiAnimatedStat here, that the HUDHandler will pick up and render. It also automatically opens and closes
+     * the stat when needed. The GuiMoveStat uses this method to retrieve the to be moved stat.
+     * @return null if no stat used.
+     */
+    public IGuiAnimatedStat getAnimatedStat();
+
+    /**
+     * Should return true if this upgrade handler is enabled for the given stacks placed in the helmet.
+     * @param upgradeStacks
+     * @return
+     */
+    public boolean isEnabled(ItemStack[] upgradeStacks);
+
+    /**
+     * Returns the usage in mL/tick when this upgrade handler is enabled.
+     * @param rangeUpgrades amount of range upgrades installed in the helmet.
+     * @param player
+     * @return usage in mL/tick
+     */
+    public float getEnergyUsage(int rangeUpgrades, EntityPlayer player);
+
+    /**
+     * Called when (re-)equipped the helmet this method should be used to clear information like current tracked entities.
+     * So clearing lists and other references as this handler should re-acquire when reinstalled.
+     */
+    public void reset();
+
+    /**
+     * When you have some options for your upgrade handler you could return a new instance of an IOptionsPage.
+     * When you do so, it will automatically get picked up by the options handler, and it will be added to the 
+     * options GUI when this upgrade returns true when calling isEnabled(). Returning null is valid.
+     * @return
+     */
+    public IOptionPage getGuiOptionsPage();
+}

src/api/java/pneumaticCraft/api/client/pneumaticHelmet/RenderHandlerRegistry.java

@@ -0,0 +1,10 @@
+package pneumaticCraft.api.client.pneumaticHelmet;
+
+import java.util.List;
+
+public class RenderHandlerRegistry{
+    /**
+     * With this field you can register your render handlers. This field is initialized in the PreInit phase of PneumaticCraft's loading phase.
+     */
+    public static List<IUpgradeRenderHandler> renderHandlers;
+}

src/api/java/pneumaticCraft/api/drone/DroneConstructingEvent.java

@@ -0,0 +1,11 @@
+package pneumaticCraft.api.drone;
+
+import cpw.mods.fml.common.eventhandler.Event;
+
+public class DroneConstructingEvent extends Event{
+    public IDrone drone;
+
+    public DroneConstructingEvent(IDrone drone){
+        this.drone = drone;
+    }
+}

src/api/java/pneumaticCraft/api/drone/IBlockInteractHandler.java

@@ -0,0 +1,26 @@
+package pneumaticCraft.api.drone;
+
+/**
+ * DON'T IMPLEMENT, just use
+ */
+public interface IBlockInteractHandler{
+
+    /**
+     * Returns a boolean[6] of all sides. when true, this side is accessible
+     * @return
+     */
+    public boolean[] getSides();
+
+    public boolean useCount();
+
+    public void decreaseCount(int count);
+
+    public int getRemainingCount();
+
+    /**
+     * When invoked, the drone will abort searching the area. Could be used to abort early when full of RF energy for example, when importing RF.
+     * (It's useless to search any further)
+     */
+    public void abort();
+
+}

src/api/java/pneumaticCraft/api/drone/ICustomBlockInteract.java

@@ -0,0 +1,45 @@
+package pneumaticCraft.api.drone;
+
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.world.ChunkPosition;
+
+/**
+ * Implement this and register it to PneumaticRegistry.registerCustomBlockInteractor().
+ * This will add a puzzle piece that has only a Area white- and blacklist parameter (similar to a GoTo piece).
+ * It will do the specified behaviour. This can be used to create energy import/export widgets.
+ */
+public interface ICustomBlockInteract{
+
+    /**
+     * Should return a unique Id, used in NBT saving and localization.
+     */
+    public String getName();
+
+    /**
+     * Should return the puzzle piece texture. Should be a multiple of 80x64 (width x height). I'd recommend starting out with copying the Go To widget texture.
+     * @return
+     */
+    public ResourceLocation getTexture();
+
+    /**
+     * The actual interaction.
+     * 
+     * For every position in the selected area the drone will visit every block (ordered from closest to furthest). It will call this method with 'simulate = true'. If this method returns true, the drone will navigate to this location, and call this method again with 'simulate = false' It will keep doing this until this method returns false.
+     * 
+     * When interactHandler.useCount() returns true:
+     * In the interface of the puzzle piece users can specify a 'use count' and fill in the maximum count they want to use. When not simulating, you should only import/export up to interactHandler.getRemainingCount(), and you should notify the removed/added count by doing interactHandler.decreaseCount(int count).
+     * 
+     * @param pos   current visited location
+     * @param drone
+     * @param interactHandler   object you can use to use to get accessible sides and give feedback about counts.
+     * @param simulate  will be true when trying to figure out whether or not the drone should navigate to this block, false when next to this block.
+     * @return
+     */
+    public boolean doInteract(ChunkPosition pos, IDrone drone, IBlockInteractHandler interactHandler, boolean simulate);
+
+    /**
+     * Used for crafting, categorizes the puzzle piece.
+     * @return
+     */
+    public int getCraftingColorIndex();
+}

src/api/java/pneumaticCraft/api/drone/IDrone.java

@@ -0,0 +1,61 @@
+package pneumaticCraft.api.drone;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.ai.EntityAITasks;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.World;
+import net.minecraftforge.common.IExtendedEntityProperties;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.IFluidTank;
+import pneumaticCraft.api.item.IPressurizable;
+
+public interface IDrone extends IPressurizable{
+    /**
+     * 
+     * @param upgradeIndex metadata value of the upgrade item
+     * @return amount of inserted upgrades in the drone
+     */
+    public int getUpgrades(int upgradeIndex);
+
+    public World getWorld();
+
+    public IFluidTank getTank();
+
+    public IInventory getInventory();
+
+    public Vec3 getPosition();
+
+    public IPathNavigator getPathNavigator();
+
+    public void sendWireframeToClient(int x, int y, int z);
+
+    public EntityPlayerMP getFakePlayer();
+
+    public boolean isBlockValidPathfindBlock(int x, int y, int z);
+
+    public void dropItem(ItemStack stack);
+
+    public void setDugBlock(int x, int y, int z);
+
+    public EntityAITasks getTargetAI();
+
+    public IExtendedEntityProperties getProperty(String key);
+
+    public void setProperty(String key, IExtendedEntityProperties property);
+
+    public void setEmittingRedstone(ForgeDirection orientation, int emittingRedstone);
+
+    public void setName(String string);
+
+    public void setCarryingEntity(Entity entity);
+
+    public Entity getCarryingEntity();
+
+    public boolean isAIOverriden();
+
+    public void onItemPickupEvent(EntityItem curPickingUpEntity, int stackSize);
+}

src/api/java/pneumaticCraft/api/drone/IPathNavigator.java

@@ -0,0 +1,11 @@
+package pneumaticCraft.api.drone;
+
+import net.minecraft.entity.Entity;
+
+public interface IPathNavigator{
+    public boolean moveToXYZ(double x, double y, double z);
+
+    public boolean moveToEntity(Entity entity);
+
+    public boolean hasNoPath();
+}

src/api/java/pneumaticCraft/api/drone/IPathfindHandler.java

@@ -0,0 +1,26 @@
+package pneumaticCraft.api.drone;
+
+import net.minecraft.world.World;
+
+public interface IPathfindHandler{
+    /**
+     * When returned true, the drone can pathfind through this block. When false it can't.
+     * @param world
+     * @param x
+     * @param y
+     * @param z
+     * @return
+     */
+    public boolean canPathfindThrough(World world, int x, int y, int z);
+
+    /**
+     * CURRENTLY NOT IMPLEMENTED!
+     * Will be called every tick as long as the drone is < 1 block away from the given coordinate.
+     * can be used to open a door for a drone for example.
+     * @param world
+     * @param x
+     * @param y
+     * @param z
+     */
+    public void onPathingThrough(World world, int x, int y, int z);
+}

src/api/java/pneumaticCraft/api/drone/SpecialVariableRetrievalEvent.java

@@ -0,0 +1,60 @@
+package pneumaticCraft.api.drone;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.ChunkPosition;
+import cpw.mods.fml.common.eventhandler.Event;
+
+/**
+ * Fired when a Drone is trying to get a special coordinate, by accessing a variable with '$' prefix.
+ * These event are posted on the MinecraftForge.EVENT_BUS.
+ */
+public abstract class SpecialVariableRetrievalEvent extends Event{
+
+    /**
+     * The special variable name, with the '$' stripped away.
+     */
+    public final String specialVarName;
+
+    /**
+     * The returning coordinate
+     */
+
+    public SpecialVariableRetrievalEvent(String specialVarName){
+
+        this.specialVarName = specialVarName;
+    }
+
+    public static abstract class CoordinateVariable extends SpecialVariableRetrievalEvent{
+        public ChunkPosition coordinate;
+
+        public CoordinateVariable(String specialVarName){
+            super(specialVarName);
+        }
+
+        public static class Drone extends CoordinateVariable{
+            public final IDrone drone;
+
+            public Drone(IDrone drone, String specialVarName){
+                super(specialVarName);
+                this.drone = drone;
+            }
+        }
+    }
+
+    public static abstract class ItemVariable extends SpecialVariableRetrievalEvent{
+        public ItemStack item;
+
+        public ItemVariable(String specialVarName){
+            super(specialVarName);
+        }
+
+        public static class Drone extends ItemVariable{
+            public final IDrone drone;
+
+            public Drone(IDrone drone, String specialVarName){
+                super(specialVarName);
+                this.drone = drone;
+            }
+        }
+    }
+}

src/api/java/pneumaticCraft/api/item/IInventoryItem.java

@@ -0,0 +1,20 @@
+package pneumaticCraft.api.item;
+
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+
+/**
+ *  Implement this interface for your items that have an inventory. When you don't have access to the item, just create any old class
+ *  that implements this interface and register an instance of it in PneumaticRegistry.
+ *  This will then will be used in the Pneumatic Helmet's item search.
+ *
+ */
+public interface IInventoryItem{
+
+    /**
+     *  @parm stack: Item that potentially has an inventory.
+     *  @parm curStacks: List of all currently added stacks for this item. Add more stacks in here in your implementation when found the right item.
+     */
+    public void getStacksInItem(ItemStack stack, List<ItemStack> curStacks);
+}

src/api/java/pneumaticCraft/api/item/IPressurizable.java

@@ -0,0 +1,35 @@
+package pneumaticCraft.api.item;
+
+import net.minecraft.item.ItemStack;
+
+/**
+ * Any item implementing this interface will be able to (dis)charge in a Charging Station.
+ */
+public interface IPressurizable{
+    /**
+     * This method should return the current pressure of the ItemStack given.
+     * 
+     * @param iStack Stack the pressure is asked from.
+     * @return Pressure in bar.
+     */
+    public float getPressure(ItemStack iStack);
+
+    /**
+     * this method is used to charge or discharge a pneumatic item. when the
+     * value is negative the item should be discharging
+     * 
+     * @param iStack the ItemStack which has to be (dis)charged.
+     * @param amount amount in mL that the item is (dis)charging.
+     */
+    public void addAir(ItemStack iStack, int amount);
+
+    /**
+     * This method should return the maximum pressure of a pneumatic item. If it
+     * has reached this maximum, it won't explode, but it wouldn't (try to)
+     * charge either.
+     * 
+     * @param iStack the stack from which the maximum pressure is asked.
+     * @return maximum pressure in bar.
+     */
+    public float maxPressure(ItemStack iStack);
+}

src/api/java/pneumaticCraft/api/item/IProgrammable.java

@@ -0,0 +1,34 @@
+package pneumaticCraft.api.item;
+
+import net.minecraft.item.ItemStack;
+
+/**
+ * Implement this for items that can get programmed in a Programmer.
+ * For now the only thing you can do with this is make program storages, later more interaction with programming puzzles is planned.
+ * Puzzle pieces will be written onto the implementer's itemstack NBT, using the "progWidget" tag.
+ */
+public interface IProgrammable{
+
+    /**
+     * When returned true, this stack is allowed to be programmed.
+     * Used to allow certain damage values to be programmed while others can't.
+     * @param stack
+     * @return
+     */
+    public boolean canProgram(ItemStack stack);
+
+    /**
+     * When returned true, Programming Puzzles are needed to program this item. When returned false, it's free to program.
+     * Drones and Network API's return true in PneumaticCraft, Network Storages return false.
+     * @param stack
+     * @return
+     */
+    public boolean usesPieces(ItemStack stack);
+
+    /**
+     * When returned true, the implementing item will get a tooltip added of the summary of puzzles used in the stored program.
+     * @return
+     */
+    public boolean showProgramTooltip();
+
+}

src/api/java/pneumaticCraft/api/item/ItemSupplier.java

@@ -0,0 +1,47 @@
+package pneumaticCraft.api.item;
+
+import net.minecraft.item.Item;
+import cpw.mods.fml.common.registry.GameRegistry;
+
+public class ItemSupplier{
+    public static Item getItem(String itemName){
+        return GameRegistry.findItem("PneumaticCraft", itemName);
+    }
+
+    /*
+        The following is a list of all the item names that can be passed as argument in getItem(String) to get a PneumaticCraft item.
+     
+        GPSTool                   Currently tracked coordinated is stored in NBT, with 'x', 'y', 'z' being the tag names for the x,y and z positions respectively.
+        machineUpgrade            damage value = upgrade type.
+        ingotIronCompressed
+        pressureGauge
+        stoneBase
+        cannonBarrel
+        turbineBlade
+        plasticPlant              damage value = plant type. Mapped the same as Vanilla dye in terms of color.
+        plastic                   damage value = plastic type. Mapped the same as Vanilla dye in terms of color.
+        airCanister               implements IPressurizable
+        vortexCannon              implements IPressurizable
+        pneumaticCylinder
+        pneumaticHelmet           implements IPressurizable
+        manometer                 implements IPressurizable
+        turbineRotor
+        assemblyProgram           damage value = program type.
+        emptyPCB
+        unassembledPCB
+        PCBBlueprint
+        bucketEtchingAcid
+        transistor
+        capacitor
+        printedCircuitBoard
+        failedPCB
+        networkComponent          damage value = network component type.
+        stopWorm
+        nukeVirus
+        compressedIronGear
+        pneumaticWrench           implements IPressurizable
+
+     
+     
+     */
+}

src/api/java/pneumaticCraft/api/package-info.java

@@ -0,0 +1,5 @@
+@API(apiVersion = "1.0", owner = "PneumaticCraft", provides = "PneumaticCraftApi")
+package pneumaticCraft.api;
+
+import cpw.mods.fml.common.API;
+

src/api/java/pneumaticCraft/api/recipe/AssemblyRecipe.java

@@ -0,0 +1,49 @@
+package pneumaticCraft.api.recipe;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+
+public class AssemblyRecipe{
+    public static List<AssemblyRecipe> drillRecipes = new ArrayList<AssemblyRecipe>();
+    public static List<AssemblyRecipe> laserRecipes = new ArrayList<AssemblyRecipe>();
+    public static List<AssemblyRecipe> drillLaserRecipes = new ArrayList<AssemblyRecipe>();
+
+    private final ItemStack input;
+    private final ItemStack output;
+
+    public AssemblyRecipe(ItemStack input, ItemStack output){
+        this.input = input;
+        this.output = output;
+    }
+
+    public ItemStack getInput(){
+        return input;
+    }
+
+    public ItemStack getOutput(){
+        return output;
+    }
+
+    public static void addDrillRecipe(Object input, Object output){
+        drillRecipes.add(new AssemblyRecipe(getStackFromObject(input), getStackFromObject(output)));
+    }
+
+    public static void addLaserRecipe(Object input, Object output){
+        laserRecipes.add(new AssemblyRecipe(getStackFromObject(input), getStackFromObject(output)));
+    }
+
+    private static ItemStack getStackFromObject(Object object){
+        if(object instanceof Block) {
+            return new ItemStack((Block)object);
+        } else if(object instanceof Item) {
+            return new ItemStack((Item)object);
+        } else {
+            return (ItemStack)object;
+        }
+    }
+
+}

src/api/java/pneumaticCraft/api/recipe/IPressureChamberRecipe.java

@@ -0,0 +1,34 @@
+package pneumaticCraft.api.recipe;
+
+import net.minecraft.item.ItemStack;
+
+public interface IPressureChamberRecipe{
+
+    /**
+     * Returns the threshold which is minimal to craft the recipe. Negative pressures also work.
+     * @return threshold pressure
+     */
+    public float getCraftingPressure();
+
+    /**
+     * This method should return the used items in the recipe when the right items are provided to craft this recipe.
+     * @param inputStacks
+     * @return usedStacks, return null when the inputStacks aren't valid for this recipe.
+     */
+    public ItemStack[] isValidRecipe(ItemStack[] inputStacks);
+
+    /**
+     * When returned true, only the exact same references of the stacks returned by isValidRecipe() will be removed. This is useful
+     * to remove stacks with a certain NBT value (like Enchanted Books). Return false for normal behaviour.
+     * @return true if exact stacks should be removed only.
+     */
+    public boolean shouldRemoveExactStacks();
+
+    /**
+     * This method will be called when the recipe should output its items. the stacks the recipe output, may be dependent on the input stacks.
+     * @param removedStacks same reference to the stacks returned by isValidRecipe.
+     * @param inputStacks. These stacks can be modified (like adding/removing NBT data eg.)
+     * @return outputStacks. Stacks that will pop 'out of the chamber'
+     */
+    public ItemStack[] craftRecipe(ItemStack[] inputStacks, ItemStack[] removedStacks);
+}

src/api/java/pneumaticCraft/api/recipe/PressureChamberRecipe.java

@@ -0,0 +1,24 @@
+package pneumaticCraft.api.recipe;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+
+public class PressureChamberRecipe{
+    public static List<PressureChamberRecipe> chamberRecipes = new ArrayList<PressureChamberRecipe>();
+    public static List<IPressureChamberRecipe> specialRecipes = new ArrayList<IPressureChamberRecipe>();
+
+    public final ItemStack[] input;
+    public final ItemStack[] output;
+    public final float pressure;
+    public final boolean outputAsBlock;
+
+    public PressureChamberRecipe(ItemStack[] input, float pressureRequired, ItemStack[] output, boolean outputAsBlock){
+        this.input = input;
+        this.output = output;
+        pressure = pressureRequired;
+        this.outputAsBlock = outputAsBlock;
+    }
+
+}

src/api/java/pneumaticCraft/api/tileentity/AirHandlerSupplier.java

@@ -0,0 +1,51 @@
+package pneumaticCraft.api.tileentity;
+
+import java.lang.reflect.Constructor;
+
+public class AirHandlerSupplier{
+    private static Constructor airHandlerConstructor;
+
+    public static IAirHandler getTierOneAirHandler(int volume){
+        return getAirHandler(5F, 7F, volume);
+    }
+
+    public static IAirHandler getTierTwoAirHandler(int volume){
+        return getAirHandler(20F, 25F, volume);
+    }
+
+    /**
+     * Returns a new instance of an IAirHandler. This handler handles everything pressurized air related: Air dispersion,
+     * blowing up when the pressure gets too high, providing a method for releasing air into the atmosphere...
+     * PROVIDED THAT THE FOLLOWING METHODS ARE FORWARDED TO THIS INSTANCE:
+     * {@link net.minecraft.tileentity.TileEntity#updateEntity()}, 
+     * {@link net.minecraft.tileentity.TileEntity#writeToNBT(net.minecraft.nbt.NBTTagCompound)}
+     * {@link net.minecraft.tileentity.TileEntity#readFromNBT(net.minecraft.nbt.NBTTagCompound)}
+     * {@link net.minecraft.tileentity.TileEntity#validate()}
+     * @param dangerPressure minimal pressure on which this machine can explode (the yellow to red transition)
+     * @param criticalPressure the absolute maximum pressure the machine can take 7 bar in tier 1 machines.
+     * @param maxFlow maximum mL/tick that this machine can disperse. Tier one machines do 50mL/tick while Tier two have 200mL/tick.
+     * @param volume Volume of the machine's internal storage. These vary from 1000mL for small machines to 10,000mL for the big ones.
+     * The higher the volume the slower the machine will charge/discharge.
+     * @return
+     */
+    public static IAirHandler getAirHandler(float dangerPressure, float criticalPressure, int volume){
+        IAirHandler airHandler = null;
+        try {
+            if(airHandlerConstructor == null) airHandlerConstructor = Class.forName("pneumaticCraft.common.tileentity.TileEntityPneumaticBase").getConstructor(float.class, float.class, int.class);
+            airHandler = (IAirHandler)airHandlerConstructor.newInstance(dangerPressure, criticalPressure, volume);
+        } catch(Exception e) {
+            System.err.println("[PneumaticCraft API] An error has occured whilst trying to get an AirHandler. Here's a stacktrace:");
+            e.printStackTrace();
+        }
+        return airHandler;
+    }
+
+    /**
+     * Use the version with integer parameters
+     */
+    @Deprecated
+    public static IAirHandler getAirHandler(float dangerPressure, float criticalPressure, float maxFlow, float volume){
+        return getAirHandler(dangerPressure, criticalPressure, (int)volume);
+    }
+
+}

src/api/java/pneumaticCraft/api/tileentity/IAirHandler.java

@@ -0,0 +1,114 @@
+package pneumaticCraft.api.tileentity;
+
+import java.util.List;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.apache.commons.lang3.tuple.Pair;
+
+/**
+ * A way for you to access about everything you need from a pneumatic machine.
+ * DO NOT IMPLEMENT THIS YOURSELF! Use AirHandlerSupplier to get an instance for your TileEntity, and implement IPneumaticMachine instead.
+ */
+
+public interface IAirHandler extends IManoMeasurable{
+
+    /**
+     * -----------Needs to be forwarded by the implementing TileEntity's updateEntity() method.
+     * Updates the pneumatic machine's logic like air dispersion and checking if it needs to explode.
+     */
+    public void updateEntityI();
+
+    /**
+     * -----------Needs to be forwarded by the implementing TileEntity.
+     * @param nbt
+     */
+    public void readFromNBTI(NBTTagCompound nbt);
+
+    /**
+     * -----------Needs to be forwarded by the implementing TileEntity.
+     * @param nbt
+     */
+    public void writeToNBTI(NBTTagCompound nbt);
+
+    /**
+     * -----------Needs to be forwarded by the implementing TileEntity with itself as parameter.
+     * @param parent TileEntity that is referencing this air handler.
+     */
+    public void validateI(TileEntity parent);
+
+    /**
+     * Method to release air in the air. It takes air from a specific side, plays a sound effect, and spawns smoke particles.
+     * It automatically detects if it needs to release air (when under pressure), suck air (when in vacuum) or do nothing.
+     * @param side
+     */
+    public void airLeak(ForgeDirection side);
+
+    /**
+     * Returns a list of all the connecting pneumatics. It takes sides in account.
+     */
+    public List<Pair<ForgeDirection, IPneumaticMachine>> getConnectedPneumatics();
+
+    /**
+     * Adds air to the tank of the given side of this TE. It also updates clients where needed (when they have a GUI opened).
+     * Deprecated: use the version with the integer parameter now.
+     * @param amount
+     * @param side
+     */
+    @Deprecated
+    public void addAir(float amount, ForgeDirection side);
+
+    public void addAir(int amount, ForgeDirection side);
+
+    /**
+     * Sets the volume of this TE's air tank. When the volume decreases the pressure will remain the same, meaning air will
+     * be lost. When the volume increases, the air remains the same, meaning the pressure will drop.
+     * Used in the Volume Upgrade calculations.
+     * Deprecated: use the version with the integer parameter now.
+     * @param newVolume
+     */
+    @Deprecated
+    public void setVolume(float newVolume);
+
+    public void setVolume(int newVolume);
+
+    public int getVolume();
+
+    /**
+     * Returns the pressure at which this TE will explode.
+     * @return
+     */
+    public float getMaxPressure();
+
+    public float getPressure(ForgeDirection sideRequested);
+
+    /**
+     * Returns the amount of air (that has a relation to the pressure: air = pressure * volume)
+     * @param sideRequested
+     * @return
+     */
+    public int getCurrentAir(ForgeDirection sideRequested);
+
+    /**
+     * When your TileEntity is implementing IInventory and has slots that accept PneumaticCraft upgrades, register these slots
+     * to the air handler by calling this method once on initialization of the TileEntity. Then they'll automatically be used to get Volume/Security upgrades.
+     * @param upgradeSlots all upgrade slots stored in an array.
+     */
+    public void setUpgradeSlots(int... upgradeSlots);
+
+    public int[] getUpgradeSlots();
+
+    public int getXCoord();
+
+    public int getYCoord();
+
+    public int getZCoord();
+
+    /**
+     * Needs to be forwarded from the implementing _Block_! Forward the Block's "onNeighborChange" method to this handler.
+     */
+    public void onNeighborChange();
+
+}

src/api/java/pneumaticCraft/api/tileentity/IHeatExchanger.java

@@ -0,0 +1,24 @@
+package pneumaticCraft.api.tileentity;
+
+import net.minecraftforge.common.util.ForgeDirection;
+import pneumaticCraft.api.IHeatExchangerLogic;
+
+/**
+ * Implemented by TileEntities or Blocks which transport heat. Keep in mind that when a Block is implementing it you only can give off a constant
+ * resistance/temperature (like Lava and Ice).
+ * @author MineMaarten
+ * www.minemaarten.com
+ */
+public interface IHeatExchanger{
+
+    /**
+     * Get an instance of IHeatExchangerLogic from PneumaticRegistry.getInstance().getHeatExchangerLogic() and keep a global reference.
+     * Then return it in this method. You can return different exchanger logics for different sides. Keep in mind that when you change
+     * a returned logic, you need to create a neighbor block change to notify the differences. You can return null to indicate no heat can
+     * be exchanged on that side.
+     * @param side
+     * @return
+     */
+    public IHeatExchangerLogic getHeatExchangerLogic(ForgeDirection side);
+
+}

src/api/java/pneumaticCraft/api/tileentity/IManoMeasurable.java

@@ -0,0 +1,14 @@
+package pneumaticCraft.api.tileentity;
+
+import java.util.List;
+
+import net.minecraft.entity.player.EntityPlayer;
+
+public interface IManoMeasurable{
+    /**
+     * This method is invoked by the Manometer when a player right-clicks a TE or Entity with this interface implemented.
+     * @param player that rightclicks the measurable TE, and therefore needs to get the message
+     * @param curInfo list you can append info to. If you don't append any info no air will be used.
+     */
+    public void printManometerMessage(EntityPlayer player, List<String> curInfo);
+}

src/api/java/pneumaticCraft/api/tileentity/IPneumaticMachine.java

@@ -0,0 +1,30 @@
+package pneumaticCraft.api.tileentity;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+public interface IPneumaticMachine{
+
+    /**
+     * In your TileEntity class which is implementing this interface you should keep a reference of an IAirHandler.
+     * You can retrieve one by calling {@link AirHandlerSupplier#getAirHandler(net.minecraft.tileentity.TileEntity, float, float, float, float)}.
+     * Do this when your TileEntity is initialized, i.e. xCoord,yCoord,zCoord and worldObj have a value. 
+     * In this method you need to return this reference.
+     * 
+     * IMPORTANT: You need to forward the {@link net.minecraft.tileentity.TileEntity#updateEntity()}, 
+     * {@link net.minecraft.tileentity.TileEntity#writeToNBT(net.minecraft.nbt.NBTTagCompound)} , 
+     * {@link net.minecraft.tileentity.TileEntity#readFromNBT(net.minecraft.nbt.NBTTagCompound)} and
+     * {@link net.minecraft.tileentity.TileEntity#validate()} (with the implementing TileEntity as additional parameter)
+     * to the IAirHandler.
+     * Apart from that you'll need to forward {@link net.minecraft.block.Block#onNeighborChange(net.minecraft.world.IBlockAccess, int, int, int, int, int, int)}
+     * from the implementing block to the IAirHandler.
+     * @return
+     */
+    public IAirHandler getAirHandler();
+
+    /**
+     * Returns true if the pneumatic logic is connected to the given side.
+     * @param side
+     * @return
+     */
+    public boolean isConnectedTo(ForgeDirection side);
+}

src/api/java/pneumaticCraft/api/universalSensor/EntityPollSensor.java

@@ -0,0 +1,31 @@
+package pneumaticCraft.api.universalSensor;
+
+import java.util.List;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.world.World;
+
+public abstract class EntityPollSensor implements IPollSensorSetting{
+
+    @Override
+    public String getSensorPath(){
+        return "entityTracker";
+    }
+
+    @Override
+    public int getPollFrequency(){
+        return 1;
+    }
+
+    @Override
+    public int getRedstoneValue(World world, int x, int y, int z, int sensorRange, String textBoxText){
+        AxisAlignedBB aabb = AxisAlignedBB.getBoundingBox(x - sensorRange, y - sensorRange, z - sensorRange, x + 1 + sensorRange, y + 1 + sensorRange, z + 1 + sensorRange);
+        return getRedstoneValue(world.getEntitiesWithinAABB(getEntityTracked(), aabb), textBoxText);
+    }
+
+    public abstract Class getEntityTracked();
+
+    public abstract int getRedstoneValue(List<Entity> entities, String textBoxText);
+
+}

src/api/java/pneumaticCraft/api/universalSensor/IBlockAndCoordinateEventSensor.java

@@ -0,0 +1,59 @@
+package pneumaticCraft.api.universalSensor;
+
+import java.util.List;
+
+import net.minecraft.client.gui.FontRenderer;
+import net.minecraft.tileentity.TileEntity;
+
+import org.lwjgl.util.Rectangle;
+
+import cpw.mods.fml.common.eventhandler.Event;
+
+public interface IBlockAndCoordinateEventSensor{
+    /**
+     * See {@link ISensorSetting#getSensorPath()}
+     * @return
+     */
+    public String getSensorPath();
+
+    /**
+     * Extended version of the normal emitRedstoneOnEvent. This method will only invoke with a valid GPS tool, and when the coordinate is within range.
+     * @param event
+     * @param sensor
+     * @param range
+     * @param toolX
+     * @param toolY
+     * @param toolZ
+     * @return
+     */
+    public int emitRedstoneOnEvent(Event event, TileEntity sensor, int range, int toolX, int toolY, int toolZ);
+
+    /**
+     * See {@link IEventSensorSetting#getRedstonePulseLength()}
+     * @return
+     */
+    public int getRedstonePulseLength();
+
+    /**
+     * See {@link ISensorSetting#needsTextBox()}
+     * @return
+     */
+    public boolean needsTextBox();
+
+    /**
+     * See {@link ISensorSetting#needsSlot()}
+     */
+    public Rectangle needsSlot();
+
+    /**
+     * See {@link ISensorSetting#getDescription()}
+     * @return
+     */
+    public List<String> getDescription();
+
+    /**
+     * Called by GuiScreen#drawScreen this method can be used to render additional things like status/info text.
+     * @param fontRenderer
+     */
+    public void drawAdditionalInfo(FontRenderer fontRenderer);
+}

src/api/java/pneumaticCraft/api/universalSensor/IBlockAndCoordinatePollSensor.java

@@ -0,0 +1,63 @@
+package pneumaticCraft.api.universalSensor;
+
+import java.util.List;
+
+import net.minecraft.client.gui.FontRenderer;
+import net.minecraft.world.World;
+
+import org.lwjgl.util.Rectangle;
+
+public interface IBlockAndCoordinatePollSensor{
+    /**
+     * See {@link ISensorSetting#getSensorPath()}
+     * @return
+     */
+    public String getSensorPath();
+
+    /**
+     * See {@link ISensorSetting#needsTextBox()}
+     * @return
+     */
+    public boolean needsTextBox();
+
+    /**
+     * See {@link ISensorSetting#needsSlot()}
+     * @return
+     */
+    public Rectangle needsSlot();
+
+    /**
+     * See {@link ISensorSetting#getDescription()}
+     * @return
+     */
+    public List<String> getDescription();
+
+    /**
+     * See {@link IPollSensorSetting#getRedstoneValue(World, int, int, int, int, String)} , but this has the GPS tracked coordinates
+     * as extra parameters. This method will only be called when the coordinate is within the Universal Sensor's range.
+     * @param world
+     * @param x
+     * @param y
+     * @param z
+     * @param sensorRange
+     * @param textBoxText
+     * @param toolX
+     * @param toolY
+     * @param toolZ
+     * @return
+     */
+    public int getRedstoneValue(World world, int x, int y, int z, int sensorRange, String textBoxText, int toolX, int toolY, int toolZ);
+
+    /**
+     * See {@link IPollSensorSetting#getPollFrequency()}
+     * @return
+     */
+    public int getPollFrequency();
+
+    /**
+     * Called by GuiScreen#drawScreen this method can be used to render additional things like status/info text.
+     * @param fontRenderer
+     */
+    public void drawAdditionalInfo(FontRenderer fontRenderer);
+
+}

src/api/java/pneumaticCraft/api/universalSensor/IEventSensorSetting.java

@@ -0,0 +1,23 @@
+package pneumaticCraft.api.universalSensor;
+
+import net.minecraft.tileentity.TileEntity;
+import cpw.mods.fml.common.eventhandler.Event;
+
+public interface IEventSensorSetting extends ISensorSetting{
+
+    /**
+     * This method is only invoked when a subscribed event is triggered.
+     * @param event
+     * @param sensor
+     * @param range
+     * @param textboxText
+     * @return Redstone strength for the given event.
+     */
+    public int emitRedstoneOnEvent(Event event, TileEntity sensor, int range, String textboxText);
+
+    /**
+     * Should return how long a pulse should hold in ticks. By default this is 5 ticks (1/4 second).
+     * @return
+     */
+    public int getRedstonePulseLength();
+}

src/api/java/pneumaticCraft/api/universalSensor/IPollSensorSetting.java

@@ -0,0 +1,27 @@
+package pneumaticCraft.api.universalSensor;
+
+import net.minecraft.world.World;
+
+public interface IPollSensorSetting extends ISensorSetting{
+
+    /**
+     * The value returned here is the interval between every check in ticks (the interval of calling getRedstoneValue()).
+     * Consider increasing the interval when your sensor method is resource intensive.
+     * @return
+     */
+    public int getPollFrequency();
+
+    /**
+     * The base method. This method should return the outputted redstone value 0-15 of this sensor. When this sensor is
+     * digital, just return 0 or 15.
+     * @param world
+     * @param x
+     * @param y
+     * @param z
+     * @param sensorRange Range of the sensor, based on the amount of Range Upgrades inserted in the Universal Sensor.
+     * @param textBoxText The text typed in the textbox of the Universal Sensor.
+     * @return
+     */
+    public int getRedstoneValue(World world, int x, int y, int z, int sensorRange, String textBoxText);
+
+}

src/api/java/pneumaticCraft/api/universalSensor/ISensorSetting.java

@@ -0,0 +1,59 @@
+package pneumaticCraft.api.universalSensor;
+
+import java.util.List;
+
+import net.minecraft.client.gui.FontRenderer;
+
+import org.lwjgl.util.Rectangle;
+
+public interface ISensorSetting{
+    /**
+     * Should return the button path the player has to follow in which this setting is stored.
+     * For instance, when the sensor should be located in player and is called speed, you should return "entityTracker/player/speed".
+     * "entityTracker" indicates that this sensor needs an Entity Tracker upgrade to run. You can choose from the following upgrades:
+     * 
+     * -entityTracker
+     * -blockTracker
+     * -gpsTool  (so you can use a certain coordinate (within range) to measure on)
+     * -volume
+     * -dispenser
+     * -speed
+     * -itemLife
+     * -itemSearch
+     * -coordinateTracker
+     * -range
+     * -security
+     * 
+     * You can allow only sensors to work by more than one upgrade, by seperating the upgrades with a '_'. For example,
+     * "entityTracker_speed" will only let the sensor be chosen when both an Entity Tracker and a Speed Upgrade are inserted.
+     * @return
+     */
+    public String getSensorPath();
+
+    /**
+     * When returned true, the GUI will enable the textbox writing, otherwise not.
+     * @return
+     */
+    public boolean needsTextBox();
+
+    /**
+     * Called by GuiScreen#drawScreen this method can be used to render additional things like status/info text.
+     * @param fontRenderer
+     */
+    public void drawAdditionalInfo(FontRenderer fontRenderer);
+
+    /**
+     * Should return the description of this sensor displayed in the GUI stat. Information should at least include
+     * when this sensor emits redstone and how (analog (1 through 15), or digital).
+     * @return
+     */
+    public List<String> getDescription();
+
+    /**
+     * Not being used at the moment, I recommend returning null for now. It is going to be used to allow sensors to decide their
+     * status on a item which can be inserted in a slot in the GUI if this method returns a rectangle with the coordinates of
+     * the slot.
+     * @return
+     */
+    public Rectangle needsSlot();
+}

src/api/java/pneumaticCraft/api/universalSensor/PlayerEventSensor.java

@@ -0,0 +1,33 @@
+package pneumaticCraft.api.universalSensor;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.event.entity.player.PlayerEvent;
+import cpw.mods.fml.common.eventhandler.Event;
+
+public abstract class PlayerEventSensor implements IEventSensorSetting{
+
+    @Override
+    public String getSensorPath(){
+        return "entityTracker/Player";
+    }
+
+    @Override
+    public int emitRedstoneOnEvent(Event event, TileEntity sensor, int range, String textboxText){
+        if(event instanceof PlayerEvent) {
+            EntityPlayer player = ((PlayerEvent)event).entityPlayer;
+            if(Math.abs(player.posX - sensor.xCoord + 0.5D) < range + 0.5D && Math.abs(player.posY - sensor.yCoord + 0.5D) < range + 0.5D && Math.abs(player.posZ - sensor.zCoord + 0.5D) < range + 0.5D) {
+                return emitRedstoneOnEvent((PlayerEvent)event, sensor, range);
+            }
+        }
+        return 0;
+    }
+
+    public abstract int emitRedstoneOnEvent(PlayerEvent event, TileEntity sensor, int range);
+
+    @Override
+    public int getRedstonePulseLength(){
+        return 5;
+    }
+
+}

src/api/java/pneumaticCraft/api/universalSensor/SensorRegistrator.java

@@ -0,0 +1,33 @@
+package pneumaticCraft.api.universalSensor;
+
+/**
+ * With this class you can register your own sensors.
+ */
+public class SensorRegistrator{
+    /**
+     * This field will be initialized in the PreInit phase of PneumaticCraft's loading phase.
+     * With this field you can register every Universal Sensor sensor you want. Just pass a new instance
+     * to one of the registerSensor methods. Sensors are singletons.
+     */
+    public static ISensorRegistrator sensorRegistrator;
+
+    public static interface ISensorRegistrator{
+        /**
+         * Registry for IPollSensorSetting, EntityPollSensor and IEventSensorSetting, and any other instance of ISensorSetting.
+         * @param sensor
+         */
+        public void registerSensor(ISensorSetting sensor);
+
+        /**
+         * Registry for IBlockAndCoordinateEventSensor
+         * @param sensor
+         */
+        public void registerSensor(IBlockAndCoordinateEventSensor sensor);
+
+        /**
+         * Registry for IBlockAndCoordinatePollSensor
+         * @param sensor
+         */
+        public void registerSensor(IBlockAndCoordinatePollSensor sensor);
+    }
+}

src/main/java/WayofTime/alchemicalWizardry/AlchemicalWizardry.java

@@ -11,9 +11,6 @@ import java.util.List;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipInputStream;
 
-import WayofTime.alchemicalWizardry.api.bindingRegistry.UnbindingRegistry;
-import WayofTime.alchemicalWizardry.common.items.sigil.holding.HoldingPacketHandler;
-import WayofTime.alchemicalWizardry.common.items.sigil.holding.ScrollHelper;
 import net.minecraft.creativetab.CreativeTabs;
 import net.minecraft.init.Blocks;
 import net.minecraft.init.Items;
@@ -48,6 +45,7 @@ import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentRegistry;
 import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentStack;
 import WayofTime.alchemicalWizardry.api.altarRecipeRegistry.AltarRecipeRegistry;
 import WayofTime.alchemicalWizardry.api.bindingRegistry.BindingRegistry;
+import WayofTime.alchemicalWizardry.api.bindingRegistry.UnbindingRegistry;
 import WayofTime.alchemicalWizardry.api.compress.CompressionRegistry;
 import WayofTime.alchemicalWizardry.api.harvest.HarvestRegistry;
 import WayofTime.alchemicalWizardry.api.items.ShapedBloodOrbRecipe;
@@ -114,10 +112,12 @@ import WayofTime.alchemicalWizardry.common.harvest.BloodMagicHarvestHandler;
 import WayofTime.alchemicalWizardry.common.harvest.CactusReedHarvestHandler;
 import WayofTime.alchemicalWizardry.common.harvest.GourdHarvestHandler;
 import WayofTime.alchemicalWizardry.common.harvest.PamHarvestCompatRegistry;
+import WayofTime.alchemicalWizardry.common.items.ItemIncense;
+import WayofTime.alchemicalWizardry.common.items.ItemMailOrderCatalogue;
 import WayofTime.alchemicalWizardry.common.items.ItemRitualDiviner;
 import WayofTime.alchemicalWizardry.common.items.armour.OmegaArmour;
 import WayofTime.alchemicalWizardry.common.items.forestry.ItemBloodFrame;
-import WayofTime.alchemicalWizardry.common.items.sigil.holding.SigilOfHolding;
+import WayofTime.alchemicalWizardry.common.items.sigil.holding.HoldingPacketHandler;
 import WayofTime.alchemicalWizardry.common.items.thaumcraft.ItemSanguineArmour;
 import WayofTime.alchemicalWizardry.common.omega.OmegaParadigmEarth;
 import WayofTime.alchemicalWizardry.common.omega.OmegaParadigmFire;
@@ -144,6 +144,7 @@ import WayofTime.alchemicalWizardry.common.potion.PotionSoulHarden;
 import WayofTime.alchemicalWizardry.common.renderer.AlchemyCircleRenderer;
 import WayofTime.alchemicalWizardry.common.rituals.RitualEffectAnimalGrowth;
 import WayofTime.alchemicalWizardry.common.rituals.RitualEffectAutoAlchemy;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectBinding;
 import WayofTime.alchemicalWizardry.common.rituals.RitualEffectBiomeChanger;
 import WayofTime.alchemicalWizardry.common.rituals.RitualEffectContainment;
 import WayofTime.alchemicalWizardry.common.rituals.RitualEffectCrafting;
@@ -169,7 +170,6 @@ import WayofTime.alchemicalWizardry.common.rituals.RitualEffectLifeConduit;
 import WayofTime.alchemicalWizardry.common.rituals.RitualEffectMagnetic;
 import WayofTime.alchemicalWizardry.common.rituals.RitualEffectOmegaStalling;
 import WayofTime.alchemicalWizardry.common.rituals.RitualEffectOmegaTest;
-import WayofTime.alchemicalWizardry.common.rituals.RitualEffectBinding;
 import WayofTime.alchemicalWizardry.common.rituals.RitualEffectSpawnWard;
 import WayofTime.alchemicalWizardry.common.rituals.RitualEffectSphereCreator;
 import WayofTime.alchemicalWizardry.common.rituals.RitualEffectSummonMeteor;
@@ -295,7 +295,7 @@ import cpw.mods.fml.common.network.NetworkRegistry;
 import cpw.mods.fml.common.registry.EntityRegistry;
 import cpw.mods.fml.common.registry.GameRegistry;
 
-@Mod(modid = "AWWayofTime", name = "AlchemicalWizardry", version = "v1.3.2", guiFactory = "WayofTime.alchemicalWizardry.client.gui.ConfigGuiFactory")
+@Mod(modid = "AWWayofTime", name = "AlchemicalWizardry", version = "v1.3.3", guiFactory = "WayofTime.alchemicalWizardry.client.gui.ConfigGuiFactory")
 
 public class AlchemicalWizardry
 {
@@ -386,11 +386,38 @@ public class AlchemicalWizardry
     public static boolean ritualDisabledPhantomHands;
     public static boolean ritualDisabledSphereIsland;
 
+    public static boolean potionDisableRegen;
+    public static boolean potionDisableNightVision;
+    public static boolean potionDisableFireResistance;
+    public static boolean potionDisableWaterBreathing;
+    public static boolean potionDisableMoveSpeed;
+    public static boolean potionDisableInstantHealth;
+    public static boolean potionDisablePoison;
+    public static boolean potionDisableBlindness;
+    public static boolean potionDisableWeakness;
+    public static boolean potionDisableStrength;
+    public static boolean potionDisableJumpBoost;
+    public static boolean potionDisableSlowness;
+    public static boolean potionDisableMining;
+    public static boolean potionDisableDrowning;
+    public static boolean potionDisableInvisibility;
+    public static boolean potionDisableResistance;
+    public static boolean potionDisableSaturation;
+    public static boolean potionDisableHealthBoost;
+    public static boolean potionDisableAbsorption;
+    public static boolean potionDisableBoost;
+    public static boolean potionDisableFlight;
+    public static boolean potionDisableReciprocation;
+    public static boolean potionDisablePlanarBinding;
+    public static boolean potionDisableSoulFray;
+    public static boolean potionDisableSoulHarden;
+    public static boolean potionDisableDeafness;
 
     public static boolean isThaumcraftLoaded;
     public static boolean isForestryLoaded;
     public static boolean isBotaniaLoaded;
     public static boolean isFMPLoaded;
+    public static boolean isPneumaticCraftLoaded;
 
     public static boolean wimpySettings;
     public static boolean respawnWithDebuff;
@@ -733,7 +760,6 @@ public class AlchemicalWizardry
         GameRegistry.addRecipe(new ShapedBloodOrbRecipe(new ItemStack(ModItems.itemBloodLightSigil), "btb", "sss", "bob", 'o', magicianBloodOrbStack, 'b', glowstoneBlockStack, 't', new ItemStack(Blocks.torch), 's', imbuedSlateStack));
         GameRegistry.addRecipe(new ItemStack(ModItems.itemKeyOfDiablo), " gw", "gdg", "wg ", 'w', weakBloodShardStack, 'g', goldIngotStack, 'd', diamondStack);
         GameRegistry.addRecipe(new ItemStack(ModItems.itemBloodPack), "gbg","flf","gsg",'s', blankSlateStack,'g', glassStack,'f',new ItemStack(Items.flint,1,craftingConstant),'b', emptyBucketStack, 'l', new ItemStack(Items.leather_chestplate));
-        GameRegistry.addShapelessRecipe(new ItemStack(ModItems.itemMailCatalogue), new ItemStack(Items.book), new ItemStack(Items.dye, 1, 0), new ItemStack(Items.feather), glassStack, glassStack);
         customPotionDrowning = (new PotionDrowning(customPotionDrowningID, true, 0)).setIconIndex(0, 0).setPotionName("Drowning");
         customPotionBoost = (new PotionBoost(customPotionBoostID, false, 0)).setIconIndex(0, 0).setPotionName("Boost");
         customPotionProjProt = (new PotionProjectileProtect(customPotionProjProtID, false, 0)).setIconIndex(0, 0).setPotionName("Whirlwind");
@@ -830,7 +856,6 @@ public class AlchemicalWizardry
         blacklistAccelerators();
 
         MinecraftForge.EVENT_BUS.register(new ModLivingDropsEvent());
-        MinecraftForge.EVENT_BUS.register(new ScrollHelper());
         proxy.InitRendering();
         NetworkRegistry.INSTANCE.registerGuiHandler(this, new GuiHandler());
 
@@ -1121,6 +1146,9 @@ public class AlchemicalWizardry
         AlchemyRecipeRegistry.registerRecipe(new ItemStack(Items.ghast_tear, 2), 100, new ItemStack[]{ghastTearStack, concentratedCatalystStack, weakBloodShardStack, new ItemStack(Blocks.soul_sand), new ItemStack(Blocks.soul_sand)}, 5);
         AlchemyRecipeRegistry.registerRecipe(new ItemStack(Items.coal, 5), 1, new ItemStack[]{new ItemStack(Items.coal, 1, 1), new ItemStack(Items.coal, 1, 1), new ItemStack(Items.coal, 1, 1), new ItemStack(Items.coal, 1, 1), new ItemStack(Items.coal, 1, 1)}, 1);
         AlchemyRecipeRegistry.registerRecipe(new ItemStack(Items.clay_ball, 4), 5, new ItemStack[]{new ItemStack(Blocks.sand), waterBucketStack}, 2);
+        
+        ItemIncense.registerIncenseRecipes();
+        GameRegistry.addRecipe(new ItemStack(ModBlocks.blockCrucible), "i i", "sis", " S ", 's', new ItemStack(Blocks.stone_slab), 'i', ironIngotStack, 'S', stoneStack);
     }
 
     @EventHandler
@@ -1196,6 +1224,10 @@ public class AlchemicalWizardry
         	long finalTime = System.nanoTime();
         	AlchemicalWizardry.logger.info("Recipe Holder initialized: took " + (finalTime - initialTime)/1000000f + "ms.");
         	
+            ModItems.itemMailCatalogue = new ItemMailOrderCatalogue().setUnlocalizedName("itemMailCatalogue");
+            GameRegistry.registerItem(ModItems.itemMailCatalogue, "itemMailCatalogue");
+            GameRegistry.addShapelessRecipe(new ItemStack(ModItems.itemMailCatalogue), new ItemStack(Items.book), new ItemStack(Items.dye, 1, 0), new ItemStack(Items.feather), new ItemStack(Blocks.glass, 1, OreDictionary.WILDCARD_VALUE), new ItemStack(Blocks.glass, 1, OreDictionary.WILDCARD_VALUE));
+
         	registerBMBook();
         }
 
@@ -1235,9 +1267,11 @@ public class AlchemicalWizardry
         }
         
         isBotaniaLoaded = Loader.isModLoaded("Botania");
-        
+        isPneumaticCraftLoaded = Loader.isModLoaded("PneumaticCraft");
         isFMPLoaded = Loader.isModLoaded("ForgeMultipart");
         
+        
+
         BloodMagicConfiguration.loadBlacklist();
 	    BloodMagicConfiguration.blacklistRituals();
 	    
@@ -1329,33 +1363,85 @@ public class AlchemicalWizardry
         }
     }
 
+    //TODO
     public static void initAlchemyPotionRecipes()
     {
+    	if(!AlchemicalWizardry.potionDisableRegen)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.ghast_tear), Potion.regeneration.id, 450);
+    	
+    	if(!AlchemicalWizardry.potionDisableNightVision)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.golden_carrot), Potion.nightVision.id, 2 * 60 * 20);
+        
+    	if(!AlchemicalWizardry.potionDisableFireResistance)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.magma_cream), Potion.fireResistance.id, 2 * 60 * 20);
+        
+    	if(!AlchemicalWizardry.potionDisableWaterBreathing)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.water_bucket), Potion.waterBreathing.id, 2 * 60 * 20);
+        
+    	if(!AlchemicalWizardry.potionDisableMoveSpeed)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.sugar), Potion.moveSpeed.id, 2 * 60 * 20);
+        
+    	if(!AlchemicalWizardry.potionDisableInstantHealth)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.speckled_melon), Potion.heal.id, 2 * 60 * 20);
+        
+    	if(!AlchemicalWizardry.potionDisablePoison)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.spider_eye), Potion.poison.id, 450);
+        
+    	if(!AlchemicalWizardry.potionDisableBlindness)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.dye, 1, 0), Potion.blindness.id, 450);
+        
+    	if(!AlchemicalWizardry.potionDisableWeakness)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.fermented_spider_eye), Potion.weakness.id, 450);
+        
+    	if(!AlchemicalWizardry.potionDisableStrength)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.blaze_powder), Potion.damageBoost.id, 2 * 60 * 20);
+        
+    	if(!AlchemicalWizardry.potionDisableJumpBoost)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(ModItems.aether), Potion.jump.id, 2 * 60 * 20);
+        
+    	if(!AlchemicalWizardry.potionDisableSlowness)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.clay_ball), Potion.moveSlowdown.id, 450);
+        
+    	if(!AlchemicalWizardry.potionDisableMining)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.redstone), Potion.digSpeed.id, 2 * 60 * 20);
+        
+    	if(!AlchemicalWizardry.potionDisableDrowning)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.potionitem, 1, 0), AlchemicalWizardry.customPotionDrowning.id, 450);
+        
+    	if(!AlchemicalWizardry.potionDisableInvisibility)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.glass_bottle), Potion.invisibility.id, 2 * 60 * 20);
+        
+    	if(!AlchemicalWizardry.potionDisableResistance)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.diamond), Potion.resistance.id, 2 * 60 * 20);
+        
+    	if(!AlchemicalWizardry.potionDisableSaturation)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.poisonous_potato), Potion.field_76443_y.id, 2); //saturation
+        
+    	if(!AlchemicalWizardry.potionDisableHealthBoost)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(ModItems.demonBloodShard), Potion.field_76434_w.id, 4 * 60 * 20); //health boost
+        
+    	if(!AlchemicalWizardry.potionDisableAbsorption)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(ModItems.weakBloodShard), Potion.field_76444_x.id, 4 * 60 * 20); //Absorption
+        
+    	if(!AlchemicalWizardry.potionDisableBoost)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(ModItems.terrae), AlchemicalWizardry.customPotionBoost.id, 1 * 60 * 20);
+        
+    	if(!AlchemicalWizardry.potionDisableFlight)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.feather), AlchemicalWizardry.customPotionFlight.id, 1 * 60 * 20);
+        
+    	if(!AlchemicalWizardry.potionDisableReciprocation)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.arrow), AlchemicalWizardry.customPotionReciprocation.id, 1 * 60 * 20);
+        
+    	if(!AlchemicalWizardry.potionDisablePlanarBinding)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.ender_pearl), AlchemicalWizardry.customPotionPlanarBinding.id, 1 * 60 * 20);
+        
+    	if(!AlchemicalWizardry.potionDisableSoulFray)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(Blocks.soul_sand), AlchemicalWizardry.customPotionSoulFray.id, 60 * 20);
+        
+    	if(!AlchemicalWizardry.potionDisableSoulHarden)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(ModItems.baseItems, 1, 16), AlchemicalWizardry.customPotionSoulHarden.id, 60 * 20);
+        
+    	if(!AlchemicalWizardry.potionDisableDeafness)
     		AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.slime_ball), AlchemicalWizardry.customPotionDeaf.id, 60 * 20);
     }
 
@@ -1436,7 +1522,7 @@ public class AlchemicalWizardry
         
         Rituals.registerRitual("AW035PhantomHands", 1, 10000, new RitualEffectItemRouting(), "Orchestra of the Phantom Hands");
         
-        Rituals.registerRitual("AW036SphereIsland", 2, 10000, new RitualEffectSphereCreator(), "Birth of the Bastion");
+        Rituals.registerRitual("AW036SphereIsland", 2, 10000, new RitualEffectSphereCreator(), "Blood of the New Moon");
         //Rituals.registerRitual(1,100,new RitualEffectApiaryOverclock(),"Apiary Overclock"));
     }
 

src/main/java/WayofTime/alchemicalWizardry/BloodMagicConfiguration.java

@@ -146,6 +146,33 @@ public class BloodMagicConfiguration
 		AlchemicalWizardry.ritualDisabledPhantomHands = config.get("Ritual Blacklist", "Orchestra of the Phantom Hands", false).getBoolean(false);
 		AlchemicalWizardry.ritualDisabledSphereIsland = config.get("Ritual Blacklist", "Birth of the Bastion", false).getBoolean(false);
 		
+		AlchemicalWizardry.potionDisableRegen = config.get("Alchemy Potion Blacklist", "Regeneration", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableNightVision = config.get("Alchemy Potion Blacklist", "Night Vision", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableFireResistance = config.get("Alchemy Potion Blacklist", "Fire Resistance", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableWaterBreathing = config.get("Alchemy Potion Blacklist", "Water Breathing", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableMoveSpeed = config.get("Alchemy Potion Blacklist", "Move Speed", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableInstantHealth = config.get("Alchemy Potion Blacklist", "Instant Health", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisablePoison = config.get("Alchemy Potion Blacklist", "Poison", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableBlindness = config.get("Alchemy Potion Blacklist", "Blindness", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableWeakness = config.get("Alchemy Potion Blacklist", "Weakness", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableStrength = config.get("Alchemy Potion Blacklist", "Strength", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableJumpBoost = config.get("Alchemy Potion Blacklist", "Jump Boost", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableSlowness = config.get("Alchemy Potion Blacklist", "Slowness", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableMining = config.get("Alchemy Potion Blacklist", "Mining Speed", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableDrowning = config.get("Alchemy Potion Blacklist", "Drowning", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableInvisibility = config.get("Alchemy Potion Blacklist", "Invisibility", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableResistance = config.get("Alchemy Potion Blacklist", "Resistance", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableSaturation = config.get("Alchemy Potion Blacklist", "Saturation", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableHealthBoost = config.get("Alchemy Potion Blacklist", "Health Boost", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableAbsorption = config.get("Alchemy Potion Blacklist", "Absorption", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableBoost = config.get("Alchemy Potion Blacklist", "Boost", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableFlight = config.get("Alchemy Potion Blacklist", "Flight", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableReciprocation = config.get("Alchemy Potion Blacklist", "Reciprocation", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisablePlanarBinding = config.get("Alchemy Potion Blacklist", "Planar Binding", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableSoulFray = config.get("Alchemy Potion Blacklist", "Soul Fray", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableSoulHarden = config.get("Alchemy Potion Blacklist", "Soul Harden", false).getBoolean(false);
+	    AlchemicalWizardry.potionDisableDeafness = config.get("Alchemy Potion Blacklist", "Deafness", false).getBoolean(false);
+
         teleposerBlacklist = config.get("Teleposer Blacklist", "Blacklist", blacklist, "Stops specified blocks from being teleposed. Put entries on new lines. Valid syntax is: \nmodid:blockname:meta").getStringList();
 
 		String tempDemonConfigs = "Demon Configs";

src/main/java/WayofTime/alchemicalWizardry/ModItems.java

@@ -37,7 +37,6 @@ import WayofTime.alchemicalWizardry.common.items.ItemComplexSpellCrystal;
 import WayofTime.alchemicalWizardry.common.items.ItemComponents;
 import WayofTime.alchemicalWizardry.common.items.ItemDiabloKey;
 import WayofTime.alchemicalWizardry.common.items.ItemIncense;
-import WayofTime.alchemicalWizardry.common.items.ItemMailOrderCatalogue;
 import WayofTime.alchemicalWizardry.common.items.ItemRitualDiviner;
 import WayofTime.alchemicalWizardry.common.items.LavaCrystal;
 import WayofTime.alchemicalWizardry.common.items.LifeBucket;
@@ -73,26 +72,26 @@ import WayofTime.alchemicalWizardry.common.items.potion.WeakFillingAgent;
 import WayofTime.alchemicalWizardry.common.items.routing.InputRoutingFocus;
 import WayofTime.alchemicalWizardry.common.items.routing.OutputRoutingFocus;
 import WayofTime.alchemicalWizardry.common.items.sigil.SigilAir;
-import WayofTime.alchemicalWizardry.common.items.sigil.SigilDivination;
 import WayofTime.alchemicalWizardry.common.items.sigil.SigilBloodLight;
+import WayofTime.alchemicalWizardry.common.items.sigil.SigilDivination;
 import WayofTime.alchemicalWizardry.common.items.sigil.SigilFluid;
 import WayofTime.alchemicalWizardry.common.items.sigil.SigilHarvest;
-import WayofTime.alchemicalWizardry.common.items.sigil.SigilPackRat;
-import WayofTime.alchemicalWizardry.common.items.sigil.SigilSeer;
-import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfEnderSeverance;
-import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfSupression;
-import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfTheAssassin;
 import WayofTime.alchemicalWizardry.common.items.sigil.SigilLava;
 import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfElementalAffinity;
+import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfEnderSeverance;
 import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfGrowth;
 import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfHaste;
-import WayofTime.alchemicalWizardry.common.items.sigil.holding.SigilOfHolding;
 import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfMagnetism;
+import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfSupression;
+import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfTheAssassin;
 import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfTheBridge;
 import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfTheFastMiner;
 import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfWind;
+import WayofTime.alchemicalWizardry.common.items.sigil.SigilPackRat;
+import WayofTime.alchemicalWizardry.common.items.sigil.SigilSeer;
 import WayofTime.alchemicalWizardry.common.items.sigil.SigilVoid;
 import WayofTime.alchemicalWizardry.common.items.sigil.SigilWater;
+import WayofTime.alchemicalWizardry.common.items.sigil.holding.SigilOfHolding;
 import cpw.mods.fml.common.registry.GameRegistry;
 
 /**
@@ -206,7 +205,6 @@ public class ModItems
     public static Item itemTankSegmenter;
     public static Item itemDestinationClearer;
     
-    public static Item itemBloodMagicBook;
     public static Item itemHarvestSigil;
     public static Item itemCompressionSigil;
 
@@ -340,7 +338,6 @@ public class ModItems
         itemAttunedCrystal = new ItemAttunedCrystal().setUnlocalizedName("itemAttunedCrystal");
         itemTankSegmenter = new ItemTankSegmenter().setUnlocalizedName("itemTankSegmenter");
         itemDestinationClearer = new ItemDestinationClearer().setUnlocalizedName("destinationClearer");
-        itemBloodMagicBook = new ItemBMBook().setUnlocalizedName("bmBook");
         
         dawnScribeTool = new DawnScribeTool().setUnlocalizedName("dawnScribeTool");
         
@@ -372,8 +369,6 @@ public class ModItems
         inputRoutingFocus = new InputRoutingFocus().setUnlocalizedName("inputRoutingFocus");
         outputRoutingFocus = new OutputRoutingFocus().setUnlocalizedName("outputRoutingFocus");
                 
-        itemMailCatalogue = new ItemMailOrderCatalogue().setUnlocalizedName("itemMailCatalogue");
-        
         itemIncense = new ItemIncense().setUnlocalizedName("bloodMagicIncenseItem");
     }
 
@@ -474,8 +469,6 @@ public class ModItems
         GameRegistry.registerItem(ModItems.itemTankSegmenter, "itemTankSegmenter");
         GameRegistry.registerItem(ModItems.itemDestinationClearer, "itemDestinationClearer");
         
-        GameRegistry.registerItem(ModItems.itemBloodMagicBook, "itemBloodMagicBook");
-        
         GameRegistry.registerItem(ModItems.baseItems, "bloodMagicBaseItems");
         GameRegistry.registerItem(ModItems.baseAlchemyItems, "bloodMagicBaseAlchemyItems");
         
@@ -509,7 +502,6 @@ public class ModItems
         GameRegistry.registerItem(ModItems.inputRoutingFocus, "inputRoutingFocus");
         GameRegistry.registerItem(ModItems.outputRoutingFocus, "outputRoutingFocus");
         
-        GameRegistry.registerItem(ModItems.itemMailCatalogue, "itemMailCatalogue");
         GameRegistry.registerItem(ModItems.itemIncense, "bloodMagicIncenseItem");
     }
 }

src/main/java/WayofTime/alchemicalWizardry/api/guide/OrbRecipeRenderer.java

@@ -0,0 +1,135 @@
+package WayofTime.alchemicalWizardry.api.guide;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.FontRenderer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.IRecipe;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.StatCollector;
+import WayofTime.alchemicalWizardry.api.items.ShapedBloodOrbRecipe;
+import WayofTime.alchemicalWizardry.api.items.ShapelessBloodOrbRecipe;
+import WayofTime.alchemicalWizardry.api.spell.APISpellHelper;
+import amerifrance.guideapi.ModInformation;
+import amerifrance.guideapi.api.abstraction.CategoryAbstract;
+import amerifrance.guideapi.api.abstraction.EntryAbstract;
+import amerifrance.guideapi.api.abstraction.IRecipeRenderer;
+import amerifrance.guideapi.api.base.Book;
+import amerifrance.guideapi.api.util.GuiHelper;
+import amerifrance.guideapi.gui.GuiBase;
+import cpw.mods.fml.relauncher.ReflectionHelper;
+
+public class OrbRecipeRenderer implements IRecipeRenderer
+{
+	public IRecipe recipe;
+	
+	public OrbRecipeRenderer(IRecipe recipe)
+	{
+		this.recipe = recipe;
+	}
+	
+	@Override
+	public void draw(Book book, CategoryAbstract category, EntryAbstract entry,
+			int guiLeft, int guiTop, int mouseX, int mouseY, GuiBase guiBase,
+			FontRenderer fontRenderer) {
+		Minecraft.getMinecraft().getTextureManager().bindTexture(new ResourceLocation(ModInformation.GUITEXLOC + "recipe_elements.png"));
+        guiBase.drawTexturedModalRect(guiLeft + 42, guiTop + 53, 0, 0, 105, 65);
+
+        guiBase.drawCenteredString(fontRenderer, StatCollector.translateToLocal("text.recipe.shapedOrb"), guiLeft + guiBase.xSize / 2, guiTop + 12, 0);
+        if(recipe instanceof ShapelessBloodOrbRecipe)
+        {
+        	ShapelessBloodOrbRecipe shapelessBloodOrbRecipe = (ShapelessBloodOrbRecipe) recipe;
+        	List<Object> list = shapelessBloodOrbRecipe.getInput();
+        	
+            int width = 3;
+            int height = 3;
+            for (int y = 0; y < height; y++) {
+                for (int x = 0; x < width; x++) {
+                	if(list.size() - 1 < y * width + x)
+                    {
+                    	continue;
+                    }
+                    
+                    int stackX = (x + 1) * 18 + (guiLeft + guiBase.xSize / 7);
+                    int stackY = (y + 1) * 18 + (guiTop + guiBase.ySize / 5);
+                    
+                    Object component = list.get(y * width + x);
+                    if (component != null) {
+                        if (component instanceof ItemStack) {
+                            GuiHelper.drawItemStack((ItemStack) component, stackX, stackY);
+                            if (GuiHelper.isMouseBetween(mouseX, mouseY, stackX, stackY, 15, 15)) {
+                                guiBase.renderToolTip((ItemStack) component, stackX, stackY);
+                            }
+                        } else if (component instanceof Integer) {
+                            GuiHelper.drawItemStack(APISpellHelper.getOrbForLevel((Integer) component), stackX, stackY);
+                            if (GuiHelper.isMouseBetween(mouseX, mouseY, stackX, stackY, 15, 15)) {
+                                guiBase.renderToolTip(APISpellHelper.getOrbForLevel((Integer) component), stackX, stackY);
+                            }
+                        } else {
+                            if (((ArrayList<ItemStack>) component).isEmpty()) return;
+                            GuiHelper.drawItemStack(((ArrayList<ItemStack>) component).get(0), stackX, stackY);
+                            if (GuiHelper.isMouseBetween(mouseX, mouseY, stackX, stackY, 15, 15)) {
+                                guiBase.renderToolTip(((ArrayList<ItemStack>) component).get(0), stackX, stackY);
+                            }
+                        }
+                    }
+                }
+            }
+            int outputX = (5 * 18) + (guiLeft + guiBase.xSize / 7);
+            int outputY = (2 * 18) + (guiTop + guiBase.xSize / 5);
+            GuiHelper.drawItemStack(shapelessBloodOrbRecipe.getRecipeOutput(), outputX, outputY);
+            if (GuiHelper.isMouseBetween(mouseX, mouseY, outputX, outputY, 15, 15)) {
+                guiBase.renderToolTip(shapelessBloodOrbRecipe.getRecipeOutput(), outputX, outputY);
+            }
+        }else
+        {
+            ShapedBloodOrbRecipe shapedBloodOrbRecipe = (ShapedBloodOrbRecipe) recipe;
+            int width = ReflectionHelper.getPrivateValue(ShapedBloodOrbRecipe.class, shapedBloodOrbRecipe, 4);
+            int height = ReflectionHelper.getPrivateValue(ShapedBloodOrbRecipe.class, shapedBloodOrbRecipe, 5);
+            for (int y = 0; y < height; y++) {
+                for (int x = 0; x < width; x++) {
+                    int stackX = (x + 1) * 18 + (guiLeft + guiBase.xSize / 7);
+                    int stackY = (y + 1) * 18 + (guiTop + guiBase.ySize / 5);
+                    Object component = shapedBloodOrbRecipe.getInput()[y * width + x];
+                    if (component != null) {
+                        if (component instanceof ItemStack) {
+                            GuiHelper.drawItemStack((ItemStack) component, stackX, stackY);
+                            if (GuiHelper.isMouseBetween(mouseX, mouseY, stackX, stackY, 15, 15)) {
+                                guiBase.renderToolTip((ItemStack) component, stackX, stackY);
+                            }
+                        } else if (component instanceof Integer) {
+                            GuiHelper.drawItemStack(APISpellHelper.getOrbForLevel((Integer) component), stackX, stackY);
+                            if (GuiHelper.isMouseBetween(mouseX, mouseY, stackX, stackY, 15, 15)) {
+                                guiBase.renderToolTip(APISpellHelper.getOrbForLevel((Integer) component), stackX, stackY);
+                            }
+                        } else {
+                            if (((ArrayList<ItemStack>) component).isEmpty()) return;
+                            GuiHelper.drawItemStack(((ArrayList<ItemStack>) component).get(0), stackX, stackY);
+                            if (GuiHelper.isMouseBetween(mouseX, mouseY, stackX, stackY, 15, 15)) {
+                                guiBase.renderToolTip(((ArrayList<ItemStack>) component).get(0), stackX, stackY);
+                            }
+                        }
+                    }
+                }
+            }
+            int outputX = (5 * 18) + (guiLeft + guiBase.xSize / 7);
+            int outputY = (2 * 18) + (guiTop + guiBase.xSize / 5);
+            GuiHelper.drawItemStack(shapedBloodOrbRecipe.getRecipeOutput(), outputX, outputY);
+            if (GuiHelper.isMouseBetween(mouseX, mouseY, outputX, outputY, 15, 15)) {
+                guiBase.renderToolTip(shapedBloodOrbRecipe.getRecipeOutput(), outputX, outputY);
+            }
+        }
+		
+	}
+
+	@Override
+	public void drawExtras(Book book, CategoryAbstract category,
+			EntryAbstract entry, int guiLeft, int guiTop, int mouseX,
+			int mouseY, GuiBase guiBase, FontRenderer fontRenderer) {
+		// TODO Auto-generated method stub
+		
+	}
+
+}

src/main/java/WayofTime/alchemicalWizardry/api/guide/PageMultiBlock.java

@@ -0,0 +1,145 @@
+package WayofTime.alchemicalWizardry.api.guide;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.FontRenderer;
+import net.minecraft.client.renderer.RenderHelper;
+import net.minecraft.client.renderer.entity.RenderItem;
+import net.minecraft.item.ItemStack;
+
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL12;
+
+import amerifrance.guideapi.api.abstraction.CategoryAbstract;
+import amerifrance.guideapi.api.abstraction.EntryAbstract;
+import amerifrance.guideapi.api.base.Book;
+import amerifrance.guideapi.api.base.PageBase;
+import amerifrance.guideapi.gui.GuiBase;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class PageMultiBlock extends PageBase 
+{
+	ItemStack[][][] structure;
+	boolean canTick = false;
+	int tick = 0;
+	int showLayer = -1;
+	float scaleFactor = 1;
+	
+	boolean renderMouseOver = true;
+	
+    public PageMultiBlock(ItemStack[][][] structure) 
+    {
+    	this.structure = structure;
+    	initPage(structure);
+    }
+    
+    int blockCount=0;
+	int[] countPerLevel;
+	int structureHeight = 0;
+	int structureLength = 0;
+	int structureWidth = 0;
+
+	public void initPage(ItemStack[][][] structure)
+	{
+		structureHeight = structure.length;
+		structureWidth=0;
+		structureLength=0;
+		countPerLevel = new int[structureHeight];
+		blockCount=0;
+		for(int h=0; h<structure.length; h++)
+		{
+			if(structure[h].length-1>structureLength)
+				structureLength = structure[h].length-1;
+			int perLvl=0;
+			for(int l=0; l<structure[h].length; l++)
+			{
+				if(structure[h][l].length-1>structureWidth)
+					structureWidth = structure[h][l].length-1;
+				for(ItemStack ss : structure[h][l])
+					if(ss!=null)
+						perLvl++;
+			}
+			countPerLevel[h] = perLvl;
+			blockCount += perLvl; 
+		}
+		tick= (showLayer==-1?blockCount:countPerLevel[showLayer])*40;
+		int yOff = (structureHeight-1)*12+structureWidth*5+structureLength*5+16;
+//		pageButtons.add(new GuiButtonManualNavigation(gui, 100, x+4,y+yOff/2-5, 10,10, 4));
+//		pageButtons.add(new GuiButtonManualNavigation(gui, 101, x+4,y+yOff/2-8-16, 10,16, 3));
+//		pageButtons.add(new GuiButtonManualNavigation(gui, 102, x+4,y+yOff/2+8, 10,16, 2));
+	}
+	
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void draw(Book book, CategoryAbstract category, EntryAbstract entry, int guiLeft, int guiTop, int mouseX, int mouseY, GuiBase guiBase, FontRenderer fontRenderer) 
+    {
+//    	if(multiblock.getStructureManual()!=null)
+    	Minecraft mc = Minecraft.getMinecraft();
+    	
+    	int x = guiLeft + 32;
+    	int y = guiTop + 30;
+		{
+			if(canTick)
+				tick++;
+
+			int prevLayers = 0;
+			if(showLayer!=-1)
+				for(int ll=0; ll<showLayer; ll++)
+					prevLayers+=countPerLevel[ll];
+			int limiter = prevLayers+ (tick/40)% ((showLayer==-1?blockCount:countPerLevel[showLayer])+4);			
+
+			int xHalf = (structureWidth*5 - structureLength*5);
+			int yOffPartial = (structureHeight-1)*12+structureWidth*5+structureLength*5;
+			int yOffTotal = yOffPartial+16;
+
+			GL11.glDisable(GL11.GL_DEPTH_TEST);
+			
+			GL11.glPushMatrix();
+			GL11.glTranslatef((1-scaleFactor)*(guiLeft + 64), (1-scaleFactor)*(guiTop+60), 0);
+			GL11.glScalef(scaleFactor, scaleFactor, scaleFactor);
+			GL11.glEnable(GL12.GL_RESCALE_NORMAL);
+			RenderHelper.enableGUIStandardItemLighting();
+			RenderItem.getInstance().renderWithColor=true;
+			int i=0;
+			ItemStack highlighted = null;
+			for(int h=0; h<structure.length; h++)
+				if(showLayer==-1 || h<=showLayer)
+				{
+					ItemStack[][] level = structure[h];
+					for(int l=level.length-1; l>=0; l--)
+					{
+						ItemStack[] row = level[l];
+						for(int w=row.length-1; w>=0; w--)
+						{
+							int xx = 60 +xHalf -10*w +10*l -7;
+							int yy = yOffPartial - 5*w - 5*l -12*h;
+							GL11.glTranslated(0, 0, 1);
+							if(row[w]!=null && i<=limiter)
+							{
+								i++;
+								RenderItem.getInstance().renderItemIntoGUI(mc.fontRenderer, mc.renderEngine, row[w], x+xx, y+yy);
+								if(mouseX>=x+xx&&mouseX<x+xx+16 && mouseY>=y+yy&&mouseY<y+yy+16)
+									highlighted = row[w];
+							}
+						}
+					}
+				}
+			GL11.glTranslated(0, 0, -i);
+			RenderHelper.disableStandardItemLighting();
+			GL11.glDisable(GL12.GL_RESCALE_NORMAL);
+			GL11.glPopMatrix();
+			
+			GL11.glEnable(GL11.GL_BLEND);
+			GL11.glEnable(GL11.GL_DEPTH_TEST);
+
+			mc.fontRenderer.setUnicodeFlag(false);
+			if(highlighted!=null && renderMouseOver)
+				guiBase.renderToolTip(highlighted, mouseX, mouseY);
+			RenderHelper.disableStandardItemLighting();
+            
+//			mc.fontRenderer.setUnicodeFlag(true);
+//			if(localizedText!=null&&!localizedText.isEmpty())
+//				manual.fontRenderer.drawSplitString(localizedText, x,y+yOffTotal, 120, manual.getTextColour());
+		}
+    }
+}

src/main/java/WayofTime/alchemicalWizardry/api/guide/PageOrbRecipe.java

@@ -1,78 +0,0 @@
-package WayofTime.alchemicalWizardry.api.guide;
-
-import java.util.ArrayList;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.FontRenderer;
-import net.minecraft.item.ItemStack;
-import net.minecraft.item.crafting.IRecipe;
-import net.minecraft.util.ResourceLocation;
-import net.minecraft.util.StatCollector;
-import WayofTime.alchemicalWizardry.api.items.ShapedBloodOrbRecipe;
-import WayofTime.alchemicalWizardry.api.spell.APISpellHelper;
-import amerifrance.guideapi.ModInformation;
-import amerifrance.guideapi.api.abstraction.CategoryAbstract;
-import amerifrance.guideapi.api.abstraction.EntryAbstract;
-import amerifrance.guideapi.api.base.Book;
-import amerifrance.guideapi.api.util.GuiHelper;
-import amerifrance.guideapi.gui.GuiBase;
-import amerifrance.guideapi.pages.PageIRecipe;
-import cpw.mods.fml.relauncher.ReflectionHelper;
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
-
-public class PageOrbRecipe extends PageIRecipe {
-
-    /**
-     * @param recipe - Recipe to draw
-     */
-    public PageOrbRecipe(IRecipe recipe) 
-    {
-        super(recipe);
-    }
-
-    @Override
-    @SideOnly(Side.CLIENT)
-    public void draw(Book book, CategoryAbstract category, EntryAbstract entry, int guiLeft, int guiTop, int mouseX, int mouseY, GuiBase guiBase, FontRenderer fontRenderer) {
-
-        Minecraft.getMinecraft().getTextureManager().bindTexture(new ResourceLocation(ModInformation.GUITEXLOC + "recipe_elements.png"));
-        guiBase.drawTexturedModalRect(guiLeft + 42, guiTop + 53, 0, 0, 105, 65);
-
-        guiBase.drawCenteredString(fontRenderer, StatCollector.translateToLocal("text.recipe.shapedOrb"), guiLeft + guiBase.xSize / 2, guiTop + 12, 0);
-        ShapedBloodOrbRecipe shapedBloodOrbRecipe = (ShapedBloodOrbRecipe) recipe;
-        int width = ReflectionHelper.getPrivateValue(ShapedBloodOrbRecipe.class, shapedBloodOrbRecipe, 4);
-        int height = ReflectionHelper.getPrivateValue(ShapedBloodOrbRecipe.class, shapedBloodOrbRecipe, 5);
-        for (int y = 0; y < height; y++) {
-            for (int x = 0; x < width; x++) {
-                int stackX = (x + 1) * 20 + (guiLeft + guiBase.xSize / 7);
-                int stackY = (y + 1) * 20 + (guiTop + guiBase.ySize / 5);
-                Object component = shapedBloodOrbRecipe.getInput()[y * width + x];
-                if (component != null) {
-                    if (component instanceof ItemStack) {
-                        GuiHelper.drawItemStack((ItemStack) component, stackX, stackY);
-                        if (GuiHelper.isMouseBetween(mouseX, mouseY, stackX, stackY, 15, 15)) {
-                            guiBase.renderToolTip((ItemStack) component, stackX, stackY);
-                        }
-                    } else if (component instanceof Integer) {
-                        GuiHelper.drawItemStack(APISpellHelper.getOrbForLevel((Integer) component), stackX, stackY);
-                        if (GuiHelper.isMouseBetween(mouseX, mouseY, stackX, stackY, 15, 15)) {
-                            guiBase.renderToolTip(APISpellHelper.getOrbForLevel((Integer) component), stackX, stackY);
-                        }
-                    } else {
-                        if (((ArrayList<ItemStack>) component).isEmpty()) return;
-                        GuiHelper.drawItemStack(((ArrayList<ItemStack>) component).get(0), stackX, stackY);
-                        if (GuiHelper.isMouseBetween(mouseX, mouseY, stackX, stackY, 15, 15)) {
-                            guiBase.renderToolTip(((ArrayList<ItemStack>) component).get(0), stackX, stackY);
-                        }
-                    }
-                }
-            }
-        }
-        int outputX = (5 * 20) + (guiLeft + guiBase.xSize / 7);
-        int outputY = (2 * 20) + (guiTop + guiBase.xSize / 5);
-        GuiHelper.drawItemStack(shapedBloodOrbRecipe.getRecipeOutput(), outputX, outputY);
-        if (GuiHelper.isMouseBetween(mouseX, mouseY, outputX, outputY, 15, 15)) {
-            guiBase.renderToolTip(shapedBloodOrbRecipe.getRecipeOutput(), outputX, outputY);
-        }
-    }
-}

src/main/java/WayofTime/alchemicalWizardry/api/guide/PageRitualMultiBlock.java

@@ -0,0 +1,96 @@
+package WayofTime.alchemicalWizardry.api.guide;
+
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+import WayofTime.alchemicalWizardry.ModBlocks;
+import WayofTime.alchemicalWizardry.api.rituals.RitualComponent;
+import WayofTime.alchemicalWizardry.api.rituals.Rituals;
+
+public class PageRitualMultiBlock extends PageMultiBlock 
+{
+	private static ItemStack blankStone;
+	private static ItemStack waterStone;
+	private static ItemStack fireStone;
+	private static ItemStack earthStone;
+	private static ItemStack airStone;
+	private static ItemStack duskStone;
+	private static ItemStack dawnStone;
+	static
+	{
+		blankStone = new ItemStack(ModBlocks.ritualStone, 1, RitualComponent.BLANK);
+		waterStone = new ItemStack(ModBlocks.ritualStone, 1, RitualComponent.WATER);
+		fireStone = new ItemStack(ModBlocks.ritualStone, 1, RitualComponent.FIRE);
+		earthStone = new ItemStack(ModBlocks.ritualStone, 1, RitualComponent.EARTH);
+		airStone = new ItemStack(ModBlocks.ritualStone, 1, RitualComponent.AIR);
+		duskStone = new ItemStack(ModBlocks.ritualStone, 1, RitualComponent.DUSK);
+		dawnStone = new ItemStack(ModBlocks.ritualStone, 1, RitualComponent.DAWN);
+	}
+	
+	private PageRitualMultiBlock(ItemStack[][][] structure)
+	{
+    	super(structure);
+	}
+	
+	public static PageRitualMultiBlock getPageForRitual(String ritualID)
+	{
+		return getPageForRitual(Rituals.getRitualList(ritualID));
+	}
+	
+	public static PageRitualMultiBlock getPageForRitual(List<RitualComponent> ritualComponents)
+	{
+		int minX = 0;
+		int minY = 0;
+		int minZ = 0;
+		
+		int maxX = 0;
+		int maxY = 0;
+		int maxZ = 0;
+		
+		for(RitualComponent comp : ritualComponents)
+		{
+			minX = Math.min(comp.getX(), minX);
+			minY = Math.min(comp.getY(), minY);
+			minZ = Math.min(comp.getZ(), minZ);
+
+			maxX = Math.max(comp.getX(), maxX);
+			maxY = Math.max(comp.getY(), maxY);
+			maxZ = Math.max(comp.getZ(), maxZ);
+		}
+		
+		System.out.println("Min: (" + minX + ", " + minY + ", " + minZ + "), Max: (" + maxX + ", " + maxY + ", " + maxZ + ")");
+		
+		ItemStack[][][] tempStructure = new ItemStack[maxY-minY+1][maxX-minX+1][maxZ-minZ+1]; //First value is vertical, second is down to the left, third is down to the right
+		
+		for(RitualComponent comp : ritualComponents)
+		{
+			tempStructure[comp.getY() - minY][comp.getX() - minX][comp.getZ() - minZ] = getStackForRitualStone(comp.getStoneType());
+		}
+		
+		tempStructure[-minY][-minX][-minZ] = new ItemStack(ModBlocks.blockMasterStone);
+
+		return new PageRitualMultiBlock(tempStructure);
+	}
+	
+	private static ItemStack getStackForRitualStone(int type)
+	{
+		switch(type)
+		{
+		case RitualComponent.BLANK:
+			return blankStone;
+		case RitualComponent.WATER:
+			return waterStone;
+		case RitualComponent.FIRE:
+			return fireStone;
+		case RitualComponent.EARTH:
+			return earthStone;
+		case RitualComponent.AIR:
+			return airStone;
+		case RitualComponent.DUSK:
+			return duskStone;
+		case RitualComponent.DAWN:
+			return dawnStone;
+		}
+		return blankStone;
+	}
+}

src/main/java/WayofTime/alchemicalWizardry/api/sacrifice/PlayerSacrificeHandler.java

@@ -30,9 +30,11 @@ public class PlayerSacrificeHandler
 			return false;
 		}
 		
-		amount = amount + Math.max(increment, max - amount);
+		amount = amount + Math.min(increment, max - amount);
 		setPlayerIncense(player, amount);
 		
+//		System.out.println("Amount of incense: " + amount + ", Increment: " + increment);
+		
 		return true;
 	}
 	

src/main/java/WayofTime/alchemicalWizardry/client/ClientProxy.java

@@ -1,14 +1,13 @@
 package WayofTime.alchemicalWizardry.client;
 
-import WayofTime.alchemicalWizardry.client.renderer.RitualDivinerRender;
 import net.minecraft.item.ItemBlock;
 import net.minecraft.world.World;
 import net.minecraftforge.client.MinecraftForgeClient;
 import net.minecraftforge.common.MinecraftForge;
 import WayofTime.alchemicalWizardry.ModBlocks;
 import WayofTime.alchemicalWizardry.api.spell.EntitySpellProjectile;
+import WayofTime.alchemicalWizardry.client.renderer.RitualDivinerRender;
 import WayofTime.alchemicalWizardry.common.CommonProxy;
-import WayofTime.alchemicalWizardry.common.book.BUEntries;
 import WayofTime.alchemicalWizardry.common.demonVillage.demonHoard.demon.EntityMinorDemonGrunt;
 import WayofTime.alchemicalWizardry.common.demonVillage.demonHoard.demon.EntityMinorDemonGruntEarth;
 import WayofTime.alchemicalWizardry.common.demonVillage.demonHoard.demon.EntityMinorDemonGruntFire;
@@ -37,6 +36,7 @@ import WayofTime.alchemicalWizardry.common.entity.projectile.EnergyBlastProjecti
 import WayofTime.alchemicalWizardry.common.entity.projectile.EntityEnergyBazookaMainProjectile;
 import WayofTime.alchemicalWizardry.common.entity.projectile.EntityMeteor;
 import WayofTime.alchemicalWizardry.common.entity.projectile.EntityParticleBeam;
+import WayofTime.alchemicalWizardry.common.items.sigil.holding.ScrollHelper;
 import WayofTime.alchemicalWizardry.common.renderer.block.RenderAlchemicCalcinator;
 import WayofTime.alchemicalWizardry.common.renderer.block.RenderConduit;
 import WayofTime.alchemicalWizardry.common.renderer.block.RenderCrystalBelljar;
@@ -110,7 +110,7 @@ public class ClientProxy extends CommonProxy
     @Override
     public void registerPostSideObjects()
     {
-    	BUEntries entries = new BUEntries();
+//    	BUEntries entries = new BUEntries();
 //    	entries.postInit();
     }
     
@@ -193,5 +193,6 @@ public class ClientProxy extends CommonProxy
         FMLCommonHandler.instance().bus().register(ob);
         MinecraftForge.EVENT_BUS.register(ob);
         KeyBindings.init();
+        MinecraftForge.EVENT_BUS.register(new ScrollHelper());
     }
 }

src/main/java/WayofTime/alchemicalWizardry/client/nei/NEIBloodOrbShapedHandler.java

@@ -47,6 +47,11 @@ public class NEIBloodOrbShapedHandler extends ShapedRecipeHandler {
 						PositionedStack stack = new PositionedStack(orbs, 25 + x * 18, 6 + y * 18, false);
 						stack.setMaxSize(1);
 						ingredients.add(stack);
+					}else if(o instanceof List)
+					{
+						PositionedStack stack = new PositionedStack((List)o, 25 + x * 18, 6 + y * 18, false);
+						stack.setMaxSize(1);
+						ingredients.add(stack);
 					}
 				}
 			}

src/main/java/WayofTime/alchemicalWizardry/client/nei/NEIBloodOrbShapelessHandler.java

@@ -44,6 +44,11 @@ public class NEIBloodOrbShapelessHandler extends ShapelessRecipeHandler {
 					PositionedStack stack = new PositionedStack(orbs, 25 + stackorder[ingred][0] * 18, 6 + stackorder[ingred][1] * 18);
 					stack.setMaxSize(1);
 					ingredients.add(stack);
+				}else if(o instanceof List)
+				{
+					PositionedStack stack = new PositionedStack((List)o, 25 + stackorder[ingred][0] * 18, 6 + stackorder[ingred][1] * 18);
+					stack.setMaxSize(1);
+					ingredients.add(stack);
 				}
             }
         }

src/main/java/WayofTime/alchemicalWizardry/common/block/BlockCrucible.java

@@ -2,17 +2,34 @@ package WayofTime.alchemicalWizardry.common.block;
 
 import java.util.Random;
 
+import net.minecraft.block.Block;
 import net.minecraft.block.BlockContainer;
 import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.tileentity.TileEntity;
-import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.IIcon;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
 import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.sacrifice.IIncense;
 import WayofTime.alchemicalWizardry.common.tileEntity.TECrucible;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
 
 public class BlockCrucible extends BlockContainer
 {
+	@SideOnly(Side.CLIENT)
+    private static IIcon topIcon;
+    @SideOnly(Side.CLIENT)
+    private static IIcon sideIcon;
+    @SideOnly(Side.CLIENT)
+    private static IIcon bottomIcon;
+    
 	public BlockCrucible() 
 	{
 		super(Material.anvil);
@@ -20,18 +37,70 @@ public class BlockCrucible extends BlockContainer
 		this.setResistance(1.5f);
 		this.setCreativeTab(AlchemicalWizardry.tabBloodMagic);
 		this.setBlockName("blockCrucible");
+		this.setBlockBounds(0.3125F, 0.0F, 0.3125F, 0.6875F, 0.625F, 0.6875F);
 	}
 	
 	@Override
-	public AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int x, int y, int z)
+    public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int idk, float what, float these, float are)
     {
-        return null;
+        TECrucible tileEntity = (TECrucible) world.getTileEntity(x, y, z);
+
+        if (tileEntity == null || player.isSneaking())
+        {
+            return false;
         }
 
+        ItemStack playerItem = player.getCurrentEquippedItem();
+
+        if (tileEntity.getStackInSlot(0) == null && playerItem != null && playerItem.getItem() instanceof IIncense)
+        {
+            ItemStack newItem = playerItem.copy();
+            newItem.stackSize = 1;
+            --playerItem.stackSize;
+            tileEntity.setInventorySlotContents(0, newItem);
+//        } else if (tileEntity.getStackInSlot(0) != null && playerItem == null) //Disabled currently
+//        {
+//            player.inventory.addItemStackToInventory(tileEntity.getStackInSlot(0));
+//            tileEntity.setInventorySlotContents(0, null);
+        }
+        world.markBlockForUpdate(x, y, z);
+        return true;
+    }
+	
+	@Override
+    @SideOnly(Side.CLIENT)
+    public void registerBlockIcons(IIconRegister iconRegister)
+    {
+        this.topIcon = iconRegister.registerIcon("AlchemicalWizardry:Crucible_Top");
+        this.sideIcon = iconRegister.registerIcon("AlchemicalWizardry:Crucible_Side");
+        this.bottomIcon = iconRegister.registerIcon("AlchemicalWizardry:Crucible_Bottom");
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public IIcon getIcon(int side, int meta)
+    {
+        switch (side)
+        {
+            case 0:
+                return bottomIcon;
+            case 1:
+                return topIcon;
+            default:
+                return sideIcon;
+        }
+    }
+	
+//	@Override
+//	public AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int x, int y, int z)
+//    {
+//        return null;
+//    }
+	
 	@Override
 	public void setBlockBoundsBasedOnState(IBlockAccess world, int x, int y, int z)
     {
-        this.setBlockBounds(0.4F, 0.0F, 0.4F, 0.6F, 0.6F, 0.6F);        
+        this.setBlockBounds(0.3125F, 0.0F, 0.3125F, 0.6875F, 0.625F, 0.6875F);        
     }
 	
 	@Override
@@ -61,4 +130,68 @@ public class BlockCrucible extends BlockContainer
             tile.spawnClientParticle(world, x, y, z, rand);
         }
     }
+	
+	@Override
+    public void breakBlock(World world, int x, int y, int z, Block par5, int par6)
+    {
+        dropItems(world, x, y, z);
+        super.breakBlock(world, x, y, z, par5, par6);
+    }
+	
+	@Override
+    public boolean hasComparatorInputOverride()
+    {
+        return true;
+    }
+
+    @Override
+    public int getComparatorInputOverride(World world, int x, int y, int z, int meta)
+    {
+        TileEntity tile = world.getTileEntity(x, y, z);
+        if (tile instanceof TECrucible)
+        {
+            return ((TECrucible) tile).getRSPowerOutput();
+        }
+        return 15;
+    }
+
+    private void dropItems(World world, int x, int y, int z)
+    {
+        Random rand = new Random();
+        TileEntity tileEntity = world.getTileEntity(x, y, z);
+
+        if (!(tileEntity instanceof IInventory))
+        {
+            return;
+        }
+
+        IInventory inventory = (IInventory) tileEntity;
+
+        for (int i = 0; i < inventory.getSizeInventory(); i++)
+        {
+            ItemStack item = inventory.getStackInSlot(i);
+
+            if (item != null && item.stackSize > 0)
+            {
+                float rx = rand.nextFloat() * 0.8F + 0.1F;
+                float ry = rand.nextFloat() * 0.8F + 0.1F;
+                float rz = rand.nextFloat() * 0.8F + 0.1F;
+                EntityItem entityItem = new EntityItem(world,
+                        x + rx, y + ry, z + rz,
+                        new ItemStack(item.getItem(), item.stackSize, item.getItemDamage()));
+
+                if (item.hasTagCompound())
+                {
+                    entityItem.getEntityItem().setTagCompound((NBTTagCompound) item.getTagCompound().copy());
+                }
+
+                float factor = 0.05F;
+                entityItem.motionX = rand.nextGaussian() * factor;
+                entityItem.motionY = rand.nextGaussian() * factor + 0.2F;
+                entityItem.motionZ = rand.nextGaussian() * factor;
+                world.spawnEntityInWorld(entityItem);
+                item.stackSize = 0;
+            }
+        }
+    }
 }

src/main/java/WayofTime/alchemicalWizardry/common/book/BUEntries.java

@@ -344,7 +344,7 @@ public class BUEntries
 		
 		
 		
-		this.registerCategory(BUEntries.categoryTest, EntryRegistry.test, BookParser.parseTextFile("/assets/alchemicalwizardryBooks/books/book.txt"));
+//		this.registerCategory(BUEntries.categoryTest, EntryRegistry.test, BookParser.parseTextFile("/assets/alchemicalwizardryBooks/books/book.txt"));
 	}
 	
 	public void registerCategory(Category cat, HashMap<String, Entry> entryMap, List<Entry> entries)

src/main/java/WayofTime/alchemicalWizardry/common/book/BloodMagicGuide.java

@@ -5,18 +5,21 @@ import java.util.ArrayList;
 import java.util.List;
 
 import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.IRecipe;
 import net.minecraft.util.ResourceLocation;
 import net.minecraft.util.StatCollector;
 import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModBlocks;
 import WayofTime.alchemicalWizardry.ModItems;
+import WayofTime.alchemicalWizardry.api.guide.OrbRecipeRenderer;
 import WayofTime.alchemicalWizardry.api.guide.PageAltarRecipe;
-import WayofTime.alchemicalWizardry.api.guide.PageOrbRecipe;
 import WayofTime.alchemicalWizardry.common.guide.RecipeHolder;
 import amerifrance.guideapi.api.GuideRegistry;
 import amerifrance.guideapi.api.abstraction.CategoryAbstract;
 import amerifrance.guideapi.api.abstraction.EntryAbstract;
 import amerifrance.guideapi.api.abstraction.IPage;
 import amerifrance.guideapi.api.base.Book;
+import amerifrance.guideapi.api.util.BookBuilder;
 import amerifrance.guideapi.api.util.PageHelper;
 import amerifrance.guideapi.categories.CategoryItemStack;
 import amerifrance.guideapi.entries.EntryUniText;
@@ -31,10 +34,24 @@ public class BloodMagicGuide
 	public static void registerGuide()
 	{
 		registerArchitectBook();
-		bloodMagicGuide = new Book(categories, "guide.BloodMagic.book.title", "guide.BloodMagic.welcomeMessage", "guide.BloodMagic.book.name", new Color(190, 10, 0));
+		registerRitualBook();
+		registerDemonBook();
+		registerSpellBook();
+		registerAlchemyBook();
+		
+		BookBuilder bmBookBuilder = new BookBuilder();
+		bmBookBuilder.setCategories(categories).setUnlocBookTitle("guide.BloodMagic.book.title").setUnlocWelcomeMessage("guide.BloodMagic.welcomeMessage").setUnlocDisplayName("guide.BloodMagic.book.name").setBookColor(new Color(190, 10, 0));
+		
+//		bloodMagicGuide = new Book(categories, "guide.BloodMagic.book.title", "guide.BloodMagic.welcomeMessage", "guide.BloodMagic.book.name", new Color(190, 10, 0));
+		bloodMagicGuide = bmBookBuilder.build();
         GuideRegistry.registerBook(bloodMagicGuide);
 	}
 	
+	public static PageIRecipe getOrbPageForRecipe(IRecipe recipe)
+	{
+		return new PageIRecipe(recipe, new OrbRecipeRenderer(recipe));
+	}
+	
 	public static void registerArchitectBook()
 	{
 		List<EntryAbstract> entries = new ArrayList();
@@ -61,18 +78,18 @@ public class BloodMagicGuide
 		entries.add(new EntryUniText(blankSlatePages, "guide.BloodMagic.entryName.architect.blankSlate"));
 		
 		ArrayList<IPage> divinationSigilPages = new ArrayList();
-		divinationSigilPages.add(new PageOrbRecipe(RecipeHolder.divinationSigilRecipe));
+		divinationSigilPages.add(getOrbPageForRecipe(RecipeHolder.divinationSigilRecipe));
 		divinationSigilPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.divination")));
 		entries.add(new EntryUniText(divinationSigilPages, "guide.BloodMagic.entryName.architect.divination"));
 
 		ArrayList<IPage> waterSigilPages = new ArrayList();
 		waterSigilPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.waterSigil.1")));
-		waterSigilPages.add(new PageOrbRecipe(RecipeHolder.waterSigilRecipe));
+		waterSigilPages.add(getOrbPageForRecipe(RecipeHolder.waterSigilRecipe));
 		waterSigilPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.waterSigil.2")));
 		entries.add(new EntryUniText(waterSigilPages, "guide.BloodMagic.entryName.architect.waterSigil"));
 		
 		ArrayList<IPage> lavaCrystalPages = new ArrayList();
-		lavaCrystalPages.add(new PageOrbRecipe(RecipeHolder.lavaCrystalRecipe));
+		lavaCrystalPages.add(getOrbPageForRecipe(RecipeHolder.lavaCrystalRecipe));
 		lavaCrystalPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.lavaCrystal")));
 		entries.add(new EntryUniText(lavaCrystalPages, "guide.BloodMagic.entryName.architect.lavaCrystal"));
 		
@@ -86,7 +103,7 @@ public class BloodMagicGuide
 		entries.add(new EntryUniText(lavaSigilPages, "guide.BloodMagic.entryName.architect.lavaSigil"));
 
 		ArrayList<IPage> blankRunePages = new ArrayList();
-		blankRunePages.add(new PageOrbRecipe(RecipeHolder.blankRuneRecipe));
+		blankRunePages.add(getOrbPageForRecipe(RecipeHolder.blankRuneRecipe));
 		blankRunePages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.blankRunes.1")));
         blankRunePages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/altars/T2.png"), true));
 		blankRunePages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.blankRunes.2")));
@@ -103,17 +120,17 @@ public class BloodMagicGuide
 		entries.add(new EntryUniText(apprenticeOrbPages, "guide.BloodMagic.entryName.architect.apprenticeOrb"));
 		
 		ArrayList<IPage> voidSigilPages = new ArrayList();
-		voidSigilPages.add(new PageOrbRecipe(RecipeHolder.voidSigilRecipe));
+		voidSigilPages.add(getOrbPageForRecipe(RecipeHolder.voidSigilRecipe));
 		voidSigilPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.voidSigil")));
 		entries.add(new EntryUniText(voidSigilPages, "guide.BloodMagic.entryName.architect.voidSigil"));
 		
 		ArrayList<IPage> airSigilPages = new ArrayList();
-		airSigilPages.add(new PageOrbRecipe(RecipeHolder.airSigilRecipe));
+		airSigilPages.add(getOrbPageForRecipe(RecipeHolder.airSigilRecipe));
 		airSigilPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.airSigil")));
 		entries.add(new EntryUniText(airSigilPages, "guide.BloodMagic.entryName.architect.airSigil"));
 		
 		ArrayList<IPage> sightSigilPages = new ArrayList();
-		sightSigilPages.add(new PageOrbRecipe(RecipeHolder.sightSigilRecipe));
+		sightSigilPages.add(getOrbPageForRecipe(RecipeHolder.sightSigilRecipe));
 		sightSigilPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.sightSigil")));
 		entries.add(new EntryUniText(sightSigilPages, "guide.BloodMagic.entryName.architect.sightSigil"));
 		
@@ -122,7 +139,7 @@ public class BloodMagicGuide
 		entries.add(new EntryUniText(advancedAltarPages, "guide.BloodMagic.entryName.architect.advancedAltar"));
 
 		ArrayList<IPage> fastMinerPages = new ArrayList();
-		fastMinerPages.add(new PageOrbRecipe(RecipeHolder.fastMinerRecipe));
+		fastMinerPages.add(getOrbPageForRecipe(RecipeHolder.fastMinerRecipe));
 		fastMinerPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.fastMiner")));
 		entries.add(new EntryUniText(fastMinerPages, "guide.BloodMagic.entryName.architect.fastMiner"));
 		
@@ -131,7 +148,7 @@ public class BloodMagicGuide
 		entries.add(new EntryUniText(soulFrayPages, "guide.BloodMagic.entryName.architect.soulFray"));
 		
 		ArrayList<IPage> greenGrovePages = new ArrayList();
-		greenGrovePages.add(new PageOrbRecipe(RecipeHolder.greenGroveRecipe));
+		greenGrovePages.add(getOrbPageForRecipe(RecipeHolder.greenGroveRecipe));
 		greenGrovePages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.greenGrove")));
 		entries.add(new EntryUniText(greenGrovePages, "guide.BloodMagic.entryName.architect.greenGrove"));
 		
@@ -141,9 +158,9 @@ public class BloodMagicGuide
 		entries.add(new EntryUniText(daggerPages, "guide.BloodMagic.entryName.architect.dagger"));
 		
 		ArrayList<IPage> sacrificePages = new ArrayList();
-		sacrificePages.add(new PageIRecipe(RecipeHolder.selfSacrificeRuneRecipe));
+		sacrificePages.add(getOrbPageForRecipe(RecipeHolder.selfSacrificeRuneRecipe));
 		sacrificePages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.sacrifice.1")));
-		sacrificePages.add(new PageIRecipe(RecipeHolder.sacrificeRuneRecipe));
+		sacrificePages.add(getOrbPageForRecipe(RecipeHolder.sacrificeRuneRecipe));
 		sacrificePages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.sacrifice.2")));
 		entries.add(new EntryUniText(sacrificePages, "guide.BloodMagic.entryName.architect.sacrifice"));
 		
@@ -167,40 +184,40 @@ public class BloodMagicGuide
 		entries.add(new EntryUniText(magicianOrbPages, "guide.BloodMagic.entryName.architect.magicianOrb"));
 		
 		ArrayList<IPage> newRunePages = new ArrayList();
-		newRunePages.add(new PageOrbRecipe(RecipeHolder.capacityRuneRecipe));
+		newRunePages.add(getOrbPageForRecipe(RecipeHolder.capacityRuneRecipe));
 		newRunePages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.newRune.1")));
-		newRunePages.add(new PageOrbRecipe(RecipeHolder.dislocationRuneRecipe));
+		newRunePages.add(getOrbPageForRecipe(RecipeHolder.dislocationRuneRecipe));
 		newRunePages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.newRune.2")));
 		entries.add(new EntryUniText(newRunePages, "guide.BloodMagic.entryName.architect.newRune"));
 		
 		ArrayList<IPage> magnetismPages = new ArrayList();
-		magnetismPages.add(new PageOrbRecipe(RecipeHolder.magnetismSigilRecipe));
+		magnetismPages.add(getOrbPageForRecipe(RecipeHolder.magnetismSigilRecipe));
 		magnetismPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.magnetism")));
 		entries.add(new EntryUniText(magnetismPages, "guide.BloodMagic.entryName.architect.magnetism"));
 		
 		ArrayList<IPage> phantomBridgePages = new ArrayList();
-		phantomBridgePages.add(new PageOrbRecipe(RecipeHolder.phantomBridgeRecipe));
+		phantomBridgePages.add(getOrbPageForRecipe(RecipeHolder.phantomBridgeRecipe));
 		phantomBridgePages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.phantomBridge")));
 		entries.add(new EntryUniText(phantomBridgePages, "guide.BloodMagic.entryName.architect.phantomBridge"));
 		
 		ArrayList<IPage> holdingPages = new ArrayList();
-		holdingPages.add(new PageOrbRecipe(RecipeHolder.holdingSigilRecipe));
+		holdingPages.add(getOrbPageForRecipe(RecipeHolder.holdingSigilRecipe));
 		holdingPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.holding")));
 		entries.add(new EntryUniText(holdingPages, "guide.BloodMagic.entryName.architect.holding"));
 		
 		ArrayList<IPage> elementalAffinityPages = new ArrayList();
-		elementalAffinityPages.add(new PageOrbRecipe(RecipeHolder.affinitySigilRecipe));
+		elementalAffinityPages.add(getOrbPageForRecipe(RecipeHolder.affinitySigilRecipe));
 		elementalAffinityPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.elementalAffinity")));
 		entries.add(new EntryUniText(elementalAffinityPages, "guide.BloodMagic.entryName.architect.elementalAffinity"));
 		
 		ArrayList<IPage> ritualStonesPages = new ArrayList();
-		ritualStonesPages.add(new PageOrbRecipe(RecipeHolder.ritualStoneRecipe));
-		ritualStonesPages.add(new PageOrbRecipe(RecipeHolder.masterStoneRecipe));
+		ritualStonesPages.add(getOrbPageForRecipe(RecipeHolder.ritualStoneRecipe));
+		ritualStonesPages.add(getOrbPageForRecipe(RecipeHolder.masterStoneRecipe));
 		ritualStonesPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.ritualStones")));
 		entries.add(new EntryUniText(ritualStonesPages, "guide.BloodMagic.entryName.architect.ritualStones"));
 
 		ArrayList<IPage> bloodLampPages = new ArrayList();
-		bloodLampPages.add(new PageOrbRecipe(RecipeHolder.bloodLampRecipe));
+		bloodLampPages.add(getOrbPageForRecipe(RecipeHolder.bloodLampRecipe));
 		bloodLampPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.bloodLamp")));
 		entries.add(new EntryUniText(bloodLampPages, "guide.BloodMagic.entryName.architect.bloodLamp"));
 		
@@ -208,7 +225,7 @@ public class BloodMagicGuide
 		boundArmourPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.boundArmour.1")));
 		boundArmourPages.add(new PageIRecipe(RecipeHolder.emptySocketRecipe));
 		boundArmourPages.add(new PageAltarRecipe(RecipeHolder.filledSocketRecipe));
-		boundArmourPages.add(new PageOrbRecipe(RecipeHolder.soulForgeRecipe));
+		boundArmourPages.add(getOrbPageForRecipe(RecipeHolder.soulForgeRecipe));
 		boundArmourPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.boundArmour.2")));
 		entries.add(new EntryUniText(boundArmourPages, "guide.BloodMagic.entryName.architect.boundArmour"));
 		
@@ -247,17 +264,17 @@ public class BloodMagicGuide
 		entries.add(new EntryUniText(masterOrbPages, "guide.BloodMagic.entryName.architect.masterOrb"));
 		
 		ArrayList<IPage> whirlwindPages = new ArrayList();
-		whirlwindPages.add(new PageOrbRecipe(RecipeHolder.whirlwindSigilRecipe));
+		whirlwindPages.add(getOrbPageForRecipe(RecipeHolder.whirlwindSigilRecipe));
 		whirlwindPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.whirlwind")));
 		entries.add(new EntryUniText(whirlwindPages, "guide.BloodMagic.entryName.architect.whirlwind"));
 		
 		ArrayList<IPage> compressionPages = new ArrayList();
-		compressionPages.add(new PageOrbRecipe(RecipeHolder.compressionSigilRecipe));
+		compressionPages.add(getOrbPageForRecipe(RecipeHolder.compressionSigilRecipe));
 		compressionPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.compression")));
 		entries.add(new EntryUniText(compressionPages, "guide.BloodMagic.entryName.architect.compression"));
 		
 		ArrayList<IPage> severancePages = new ArrayList();
-		severancePages.add(new PageOrbRecipe(RecipeHolder.enderSeveranceSigilRecipe));
+		severancePages.add(getOrbPageForRecipe(RecipeHolder.enderSeveranceSigilRecipe));
 		severancePages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.severance")));
 		entries.add(new EntryUniText(severancePages, "guide.BloodMagic.entryName.architect.severance"));
 		
@@ -268,17 +285,17 @@ public class BloodMagicGuide
 		entries.add(new EntryUniText(teleposerPages, "guide.BloodMagic.entryName.architect.teleposer"));
 		
 		ArrayList<IPage> suppressionPages = new ArrayList();
-		suppressionPages.add(new PageOrbRecipe(RecipeHolder.suppressionSigilRecipe));
+		suppressionPages.add(getOrbPageForRecipe(RecipeHolder.suppressionSigilRecipe));
 		suppressionPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.suppression")));
 		entries.add(new EntryUniText(suppressionPages, "guide.BloodMagic.entryName.architect.suppression"));
 		
 		ArrayList<IPage> superiorCapacityPages = new ArrayList();
-		superiorCapacityPages.add(new PageOrbRecipe(RecipeHolder.superiorCapacityRecipe));
+		superiorCapacityPages.add(getOrbPageForRecipe(RecipeHolder.superiorCapacityRecipe));
 		superiorCapacityPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.superiorCapacity")));
 		entries.add(new EntryUniText(superiorCapacityPages, "guide.BloodMagic.entryName.architect.superiorCapacity"));
 		
 		ArrayList<IPage> orbRunePages = new ArrayList();
-		orbRunePages.add(new PageOrbRecipe(RecipeHolder.orbRuneRecipe));
+		orbRunePages.add(getOrbPageForRecipe(RecipeHolder.orbRuneRecipe));
 		orbRunePages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.orbRune")));
 		entries.add(new EntryUniText(orbRunePages, "guide.BloodMagic.entryName.architect.orbRune"));
 		
@@ -306,17 +323,17 @@ public class BloodMagicGuide
 		entries.add(new EntryUniText(demonicOrbPages, "guide.BloodMagic.entryName.architect.demonicOrb"));
 		
 		ArrayList<IPage> energyBazookaPages = new ArrayList();
-		demonicOrbPages.add(new PageOrbRecipe(RecipeHolder.energyBazookaRecipe));
+		demonicOrbPages.add(getOrbPageForRecipe(RecipeHolder.energyBazookaRecipe));
 		energyBazookaPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.energyBazooka")));
 		entries.add(new EntryUniText(energyBazookaPages, "guide.BloodMagic.entryName.architect.energyBazooka"));
 		
 		ArrayList<IPage> accelerationRunePages = new ArrayList();
-		demonicOrbPages.add(new PageOrbRecipe(RecipeHolder.accelerationRuneRecipe));
+		demonicOrbPages.add(getOrbPageForRecipe(RecipeHolder.accelerationRuneRecipe));
 		accelerationRunePages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.accelerationRune")));
 		entries.add(new EntryUniText(accelerationRunePages, "guide.BloodMagic.entryName.architect.accelerationRune"));
 		
 		ArrayList<IPage> harvestPages = new ArrayList();
-		demonicOrbPages.add(new PageOrbRecipe(RecipeHolder.harvestSigilRecipe));
+		demonicOrbPages.add(getOrbPageForRecipe(RecipeHolder.harvestSigilRecipe));
 		harvestPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.architect.harvest")));
 		entries.add(new EntryUniText(harvestPages, "guide.BloodMagic.entryName.architect.harvest"));
 		
@@ -337,4 +354,483 @@ public class BloodMagicGuide
 		
         categories.add(new CategoryItemStack(entries, "guide.BloodMagic.category.architect", new ItemStack(ModItems.divinationSigil)));
 	}
+	
+	public static void registerRitualBook()
+	{
+		List<EntryAbstract> entries = new ArrayList();
+		
+//		ArrayList<IPage> testPages = new ArrayList();
+//        testPages.add(PageRitualMultiBlock.getPageForRitual("AW031Convocation"));
+//        entries.add(new EntryUniText(testPages, "Test page"));
+        
+		
+		ArrayList<IPage> introPages = new ArrayList();
+        introPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.intro")));
+        entries.add(new EntryUniText(introPages, "guide.BloodMagic.entryName.rituals.intro"));
+        
+        ArrayList<IPage> weakRitualPages = new ArrayList();
+        weakRitualPages.add(getOrbPageForRecipe(RecipeHolder.weakRitualStoneRecipe));
+        weakRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.weakRitual")));
+        entries.add(new EntryUniText(weakRitualPages, "guide.BloodMagic.entryName.rituals.weakRitual"));
+        
+        ArrayList<IPage> ritualsPages = new ArrayList();
+        ritualsPages.add(getOrbPageForRecipe(RecipeHolder.ritualStoneRecipe));
+        ritualsPages.add(getOrbPageForRecipe(RecipeHolder.masterStoneRecipe));
+        ritualsPages.add(new PageAltarRecipe(RecipeHolder.waterScribeTool));
+        ritualsPages.add(new PageAltarRecipe(RecipeHolder.fireScribeTool));
+        ritualsPages.add(new PageAltarRecipe(RecipeHolder.earthScribeTool));
+        ritualsPages.add(new PageAltarRecipe(RecipeHolder.airScribeTool));
+        ritualsPages.add(new PageIRecipe(RecipeHolder.ritualDiviner1Recipe));
+        ritualsPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.rituals")));
+        ritualsPages.add(new PageAltarRecipe(RecipeHolder.weakActivationRecipe));
+        entries.add(new EntryUniText(ritualsPages, "guide.BloodMagic.entryName.rituals.rituals"));
+        
+        ArrayList<IPage> waterRitualPages = new ArrayList();
+        waterRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Water.png"), true));
+        waterRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.waterRitual")));
+        entries.add(new EntryUniText(waterRitualPages, "guide.BloodMagic.entryName.rituals.waterRitual"));
+        
+        ArrayList<IPage> lavaRitualPages = new ArrayList();
+        lavaRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Lava.png"), true));
+        lavaRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.lavaRitual")));
+        entries.add(new EntryUniText(lavaRitualPages, "guide.BloodMagic.entryName.rituals.lavaRitual"));
+        
+        ArrayList<IPage> groveRitualPages = new ArrayList();
+        groveRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/GreenGrove.png"), true));
+        groveRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.groveRitual")));
+        entries.add(new EntryUniText(groveRitualPages, "guide.BloodMagic.entryName.rituals.groveRitual"));
+        
+        ArrayList<IPage> interdictionRitualPages = new ArrayList();
+        interdictionRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Interdiction.png"), true));
+        interdictionRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.interdictionRitual")));
+        entries.add(new EntryUniText(interdictionRitualPages, "guide.BloodMagic.entryName.rituals.interdictionRitual"));
+        
+        ArrayList<IPage> containmentRitualPages = new ArrayList();
+        containmentRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Containment.png"), true));
+        containmentRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.containmentRitual")));
+        entries.add(new EntryUniText(containmentRitualPages, "guide.BloodMagic.entryName.rituals.containmentRitual"));
+        
+        ArrayList<IPage> bindingRitualPages = new ArrayList();
+        bindingRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Binding.png"), true));
+        bindingRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.bindingRitual")));
+        entries.add(new EntryUniText(bindingRitualPages, "guide.BloodMagic.entryName.rituals.bindingRitual"));
+        
+        ArrayList<IPage> beastModePages = new ArrayList();
+        beastModePages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.beastMode")));
+        entries.add(new EntryUniText(beastModePages, "guide.BloodMagic.entryName.rituals.beastMode"));
+        
+        ArrayList<IPage> unbindingRitualPages = new ArrayList();
+        unbindingRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Unbinding.png"), true));
+        unbindingRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.unbindingRitual")));
+        entries.add(new EntryUniText(unbindingRitualPages, "guide.BloodMagic.entryName.rituals.unbindingRitual"));
+        
+        ArrayList<IPage> jumpRitualPages = new ArrayList();
+        jumpRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Jump.png"), true));
+        jumpRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.jumpRitual")));
+        entries.add(new EntryUniText(jumpRitualPages, "guide.BloodMagic.entryName.rituals.jumpRitual"));
+        
+        ArrayList<IPage> duskInkPages = new ArrayList();
+        duskInkPages.add(new PageAltarRecipe(RecipeHolder.duskRecipe));
+        duskInkPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.duskInk")));
+        entries.add(new EntryUniText(duskInkPages, "guide.BloodMagic.entryName.rituals.duskInk"));
+        
+        ArrayList<IPage> magnetismRitualPages = new ArrayList();
+        magnetismRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Magnetism.png"), true));
+        magnetismRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.magnetismRitual")));
+        entries.add(new EntryUniText(magnetismRitualPages, "guide.BloodMagic.entryName.rituals.magnetismRitual"));
+        
+        ArrayList<IPage> crusherRitualPages = new ArrayList();
+        crusherRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Crusher.png"), true));
+        crusherRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.crusherRitual")));
+        entries.add(new EntryUniText(crusherRitualPages, "guide.BloodMagic.entryName.rituals.crusherRitual"));
+        
+        ArrayList<IPage> speedRitualPages = new ArrayList();
+        speedRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Speed.png"), true));
+        speedRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.speedRitual")));
+        entries.add(new EntryUniText(speedRitualPages, "guide.BloodMagic.entryName.rituals.speedRitual"));
+        
+        ArrayList<IPage> shepherdRitualPages = new ArrayList();
+        shepherdRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/AnimalGrowth.png"), true));
+        shepherdRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.shepherdRitual")));
+        entries.add(new EntryUniText(shepherdRitualPages, "guide.BloodMagic.entryName.rituals.shepherdRitual"));
+        
+        ArrayList<IPage> darkMagicPages = new ArrayList();
+        darkMagicPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.darkMagic")));
+        entries.add(new EntryUniText(darkMagicPages, "guide.BloodMagic.entryName.rituals.darkMagic"));
+        
+        ArrayList<IPage> knifeAndSufferingRitualPages = new ArrayList();
+        knifeAndSufferingRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/WellOfSuffering.png"), true));
+        knifeAndSufferingRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.knifeAndSufferingRitual.1")));
+        knifeAndSufferingRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/FeatheredKnife.png"), true));
+        knifeAndSufferingRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.knifeAndSufferingRitual.2")));
+        entries.add(new EntryUniText(knifeAndSufferingRitualPages, "guide.BloodMagic.entryName.rituals.knifeAndSufferingRitual"));
+        
+        ArrayList<IPage> regenerationRitualPages = new ArrayList();
+        regenerationRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Regeneration.png"), true));
+        regenerationRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.regenerationRitual")));
+        entries.add(new EntryUniText(regenerationRitualPages, "guide.BloodMagic.entryName.rituals.regenerationRitual"));
+        
+        ArrayList<IPage> harvestFestivalPages = new ArrayList();
+        harvestFestivalPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.harvestFestival")));
+        entries.add(new EntryUniText(harvestFestivalPages, "guide.BloodMagic.entryName.rituals.harvestFestival"));
+        
+        ArrayList<IPage> thenThereWereFivePages = new ArrayList();
+        thenThereWereFivePages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.thenThereWereFive")));
+        entries.add(new EntryUniText(thenThereWereFivePages, "guide.BloodMagic.entryName.rituals.thenThereWereFive"));
+        
+        ArrayList<IPage> alchemyRitualPages = new ArrayList();
+        alchemyRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Alchemy.png"), true));
+        alchemyRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.alchemyRitual")));
+        entries.add(new EntryUniText(alchemyRitualPages, "guide.BloodMagic.entryName.rituals.alchemyRitual"));
+        
+        ArrayList<IPage> domeRitualPages = new ArrayList();
+        domeRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Dome.png"), true));
+        domeRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.domeRitual")));
+        entries.add(new EntryUniText(domeRitualPages, "guide.BloodMagic.entryName.rituals.domeRitual"));
+        
+        ArrayList<IPage> awakenedCrystalPages = new ArrayList();
+        awakenedCrystalPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.awakenedCrystal")));
+        entries.add(new EntryUniText(awakenedCrystalPages, "guide.BloodMagic.entryName.rituals.awakenedCrystal"));
+        
+        ArrayList<IPage> featheredEarthRitualPages = new ArrayList();
+        featheredEarthRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/FeatheredEarth.png"), true));
+        featheredEarthRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.featheredEarthRitual")));
+        entries.add(new EntryUniText(featheredEarthRitualPages, "guide.BloodMagic.entryName.rituals.featheredEarthRitual"));
+        
+        ArrayList<IPage> gaiaRitualPages = new ArrayList();
+        gaiaRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Gaia.png"), true));
+        gaiaRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.gaiaRitual")));
+        entries.add(new EntryUniText(gaiaRitualPages, "guide.BloodMagic.entryName.rituals.gaiaRitual"));
+        
+        ArrayList<IPage> condorRitualPages = new ArrayList();
+        condorRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Flight.png"), true));
+        condorRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.condorRitual")));
+        entries.add(new EntryUniText(condorRitualPages, "guide.BloodMagic.entryName.rituals.condorRitual"));
+        
+        ArrayList<IPage> meteorRitualPages = new ArrayList();
+        meteorRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Meteor.png"), true));
+        meteorRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.meteorRitual")));
+        entries.add(new EntryUniText(meteorRitualPages, "guide.BloodMagic.entryName.rituals.meteorRitual"));
+        
+        ArrayList<IPage> expulsionRitualPages = new ArrayList();
+        expulsionRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Expulsion.png"), true));
+        expulsionRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.expulsionRitual")));
+        entries.add(new EntryUniText(expulsionRitualPages, "guide.BloodMagic.entryName.rituals.expulsionRitual"));
+        
+        ArrayList<IPage> costOfProgressPages = new ArrayList();
+        costOfProgressPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.costOfProgress.1")));
+        costOfProgressPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.costOfProgress.2")));
+        entries.add(new EntryUniText(costOfProgressPages, "guide.BloodMagic.entryName.rituals.costOfProgress"));
+        
+        ArrayList<IPage> zephyrRitualPages = new ArrayList();
+        zephyrRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Zephyr.png"), true));
+        zephyrRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.zephyrRitual")));
+        entries.add(new EntryUniText(zephyrRitualPages, "guide.BloodMagic.entryName.rituals.zephyrRitual"));
+        
+        ArrayList<IPage> harvestRitualPages = new ArrayList();
+        harvestRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Harvest.png"), true));
+        harvestRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.harvestRitual")));
+        entries.add(new EntryUniText(harvestRitualPages, "guide.BloodMagic.entryName.rituals.harvestRitual"));
+        
+        ArrayList<IPage> eternalSoulRitualPages = new ArrayList();
+        eternalSoulRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/EternalSoul.png"), true));
+        eternalSoulRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.eternalSoulRitual")));
+        entries.add(new EntryUniText(eternalSoulRitualPages, "guide.BloodMagic.entryName.rituals.eternalSoulRitual"));
+        
+        ArrayList<IPage> ellipsoidRitualPages = new ArrayList();
+        ellipsoidRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Ellipsoid.png"), true));
+        ellipsoidRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.ellipsoidRitual")));
+        entries.add(new EntryUniText(ellipsoidRitualPages, "guide.BloodMagic.entryName.rituals.ellipsoidRitual"));
+        
+        ArrayList<IPage> evaporationRitualPages = new ArrayList();
+        evaporationRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Evaporation.png"), true));
+        evaporationRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.evaporationRitual")));
+        entries.add(new EntryUniText(evaporationRitualPages, "guide.BloodMagic.entryName.rituals.evaporationRitual"));
+        
+        ArrayList<IPage> sacrosanctityRitualPages = new ArrayList();
+        sacrosanctityRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Sacrosanctity.png"), true));
+        sacrosanctityRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.sacrosanctityRitual")));
+        entries.add(new EntryUniText(sacrosanctityRitualPages, "guide.BloodMagic.entryName.rituals.sacrosanctityRitual"));
+        
+        ArrayList<IPage> evilRitualPages = new ArrayList();
+        evilRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/VeilOfEvil.png"), true));
+        evilRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.evilRitual")));
+        entries.add(new EntryUniText(evilRitualPages, "guide.BloodMagic.entryName.rituals.evilRitual"));
+        
+        ArrayList<IPage> stomachRitualPages = new ArrayList();
+        stomachRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Stomach.png"), true));
+        stomachRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.stomachRitual")));
+        entries.add(new EntryUniText(stomachRitualPages, "guide.BloodMagic.entryName.rituals.stomachRitual"));
+        
+        ArrayList<IPage> reagentEffectsRitualPages = new ArrayList();
+        for(int i=1; i<=24; i++)
+        {
+            reagentEffectsRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.reagentEffects." + i)));
+        }
+        entries.add(new EntryUniText(reagentEffectsRitualPages, "guide.BloodMagic.entryName.rituals.reagentEffects"));
+        
+        ArrayList<IPage> conclaveOfMagesPages = new ArrayList();
+        conclaveOfMagesPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.conclaveOfMages")));
+        entries.add(new EntryUniText(conclaveOfMagesPages, "guide.BloodMagic.entryName.rituals.conclaveOfMages"));
+        
+        ArrayList<IPage> forbiddenParadisePages = new ArrayList();
+        forbiddenParadisePages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.forbiddenParadise")));
+        entries.add(new EntryUniText(forbiddenParadisePages, "guide.BloodMagic.entryName.rituals.forbiddenParadise"));
+        
+        ArrayList<IPage> convocationRitualPages = new ArrayList();
+        convocationRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/Convocation.png"), true));
+        convocationRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.convocationRitual")));
+        entries.add(new EntryUniText(convocationRitualPages, "guide.BloodMagic.entryName.rituals.convocationRitual"));
+        
+        ArrayList<IPage> longHaulPages = new ArrayList();
+        longHaulPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.longHaul")));
+        entries.add(new EntryUniText(longHaulPages, "guide.BloodMagic.entryName.rituals.longHaul"));
+        
+        ArrayList<IPage> phantomHandsRitualPages = new ArrayList();
+        phantomHandsRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/PhantomHands.png"), true));
+        phantomHandsRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.phantomHandsRitual")));
+        entries.add(new EntryUniText(phantomHandsRitualPages, "guide.BloodMagic.entryName.rituals.phantomHandsRitual"));
+        
+        ArrayList<IPage> anvilRitualPages = new ArrayList();
+        anvilRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/BeatingAnvil.png"), true));
+        anvilRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.anvilRitual")));
+        entries.add(new EntryUniText(anvilRitualPages, "guide.BloodMagic.entryName.rituals.anvilRitual"));
+        
+        ArrayList<IPage> dawnInkPages = new ArrayList();
+        dawnInkPages.add(new PageAltarRecipe(RecipeHolder.dawnRecipe));
+        dawnInkPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.dawnInk")));
+        entries.add(new EntryUniText(dawnInkPages, "guide.BloodMagic.entryName.rituals.dawnInk"));
+        
+        ArrayList<IPage> symmetryRitualPages = new ArrayList();
+        symmetryRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/SymmetryOmega.png"), true));
+        symmetryRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.symmetryRitual")));
+        entries.add(new EntryUniText(symmetryRitualPages, "guide.BloodMagic.entryName.rituals.symmetryRitual"));
+        
+        ArrayList<IPage> stallingRitualPages = new ArrayList();
+        stallingRitualPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/rituals/StallingOmega.png"), true));
+        stallingRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.stallingRitual")));
+        entries.add(new EntryUniText(stallingRitualPages, "guide.BloodMagic.entryName.rituals.stallingRitual"));
+        
+        ArrayList<IPage> newMoonRitualPages = new ArrayList();
+        newMoonRitualPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.rituals.newMoonRitual")));
+        entries.add(new EntryUniText(newMoonRitualPages, "guide.BloodMagic.entryName.rituals.newMoonRitual"));
+		
+		categories.add(new CategoryItemStack(entries, "guide.BloodMagic.category.rituals", new ItemStack(ModBlocks.blockMasterStone)));
+	}
+	
+	public static void registerDemonBook()
+	{
+		List<EntryAbstract> entries = new ArrayList();
+		
+		ArrayList<IPage> ashesPages = new ArrayList();
+        ashesPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.demons.ashes")));
+        entries.add(new EntryUniText(ashesPages, "guide.BloodMagic.entryName.demons.ashes"));
+        
+        ArrayList<IPage> tamedDemonPages = new ArrayList();
+        tamedDemonPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.demons.tamedDemon")));
+        entries.add(new EntryUniText(tamedDemonPages, "guide.BloodMagic.entryName.demons.tamedDemon"));
+        
+        ArrayList<IPage> futurePages = new ArrayList();
+        futurePages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.demons.future")));
+        entries.add(new EntryUniText(futurePages, "guide.BloodMagic.entryName.demons.future"));
+        
+        ArrayList<IPage> knightPages = new ArrayList();
+        knightPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.demons.knight")));
+        entries.add(new EntryUniText(knightPages, "guide.BloodMagic.entryName.demons.knight"));
+        
+        ArrayList<IPage> demonShardPages = new ArrayList();
+        demonShardPages.addAll(PageHelper.pagesForLongText((StatCollector.translateToLocal("aw.entries.demons.demonShard")), new ItemStack(ModItems.demonBloodShard)));
+        entries.add(new EntryUniText(demonShardPages, "guide.BloodMagic.entryName.demons.demonShard"));
+       
+		
+		ArrayList<IPage> demonSummoningPages = new ArrayList();
+		demonSummoningPages.add(new PageIRecipe(RecipeHolder.arcanePedestalRecipe));
+		demonSummoningPages.add(new PageIRecipe(RecipeHolder.arcanePlinthRecipe));
+        demonSummoningPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/demons/Ring1.png"), true));
+        demonSummoningPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/demons/Ring2.png"), true));
+        demonSummoningPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.demons.demonSummoning")));
+        entries.add(new EntryUniText(demonSummoningPages, "guide.BloodMagic.entryName.demons.demonSummoning"));
+        
+        ArrayList<IPage> keysGatePages = new ArrayList();
+        for(int i=1; i<=10; i++)
+        {
+        	keysGatePages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.demons.keysGate." + i)));
+        }
+        entries.add(new EntryUniText(keysGatePages, "guide.BloodMagic.entryName.demons.keysGate"));
+        
+        ArrayList<IPage> futurePlansPages = new ArrayList();
+        futurePlansPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.demons.futurePlans")));
+        entries.add(new EntryUniText(futurePlansPages, "guide.BloodMagic.entryName.demons.futurePlans"));
+        
+        ArrayList<IPage> demonInvasionPages = new ArrayList();
+        demonInvasionPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.demons.demonInvasion")));
+        entries.add(new EntryUniText(demonInvasionPages, "guide.BloodMagic.entryName.demons.demonInvasion"));
+        
+        ArrayList<IPage> observationsPages = new ArrayList();
+        observationsPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.demons.observations")));
+        entries.add(new EntryUniText(observationsPages, "guide.BloodMagic.entryName.demons.observations"));        
+        
+		categories.add(new CategoryItemStack(entries, "guide.BloodMagic.category.demons", new ItemStack(ModItems.demonBloodShard)));
+	}
+	
+	public static void registerSpellBook()
+	{
+		List<EntryAbstract> entries = new ArrayList();
+
+		ArrayList<IPage> demonGirlPages = new ArrayList();
+        demonGirlPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.spells.demonGirl")));
+        entries.add(new EntryUniText(demonGirlPages, "guide.BloodMagic.entryName.spells.demonGirl"));
+        
+        ArrayList<IPage> spellTablePages = new ArrayList();
+        spellTablePages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.spells.spellTable.1")));
+        spellTablePages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/spells/SimpleSpellTable.png"), true));
+        spellTablePages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.spells.spellTable.2")));
+        entries.add(new EntryUniText(spellTablePages, "guide.BloodMagic.entryName.spells.spellTable"));
+        
+        ArrayList<IPage> simpleEffectsPages = new ArrayList();
+        for(int i=1; i<=11; i++)
+        {
+            simpleEffectsPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.spells.simpleEffects." + i)));
+        }
+        entries.add(new EntryUniText(simpleEffectsPages, "guide.BloodMagic.entryName.spells.simpleEffects"));
+        
+        ArrayList<IPage> tableAndSkullsPages = new ArrayList();
+		tableAndSkullsPages.add(new PageAltarRecipe(RecipeHolder.blankSpellRecipe));
+        tableAndSkullsPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.spells.tableAndSkulls.1")));
+		tableAndSkullsPages.add(getOrbPageForRecipe(RecipeHolder.spellTableRecipe));
+        tableAndSkullsPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.spells.tableAndSkulls.2")));
+        entries.add(new EntryUniText(tableAndSkullsPages, "guide.BloodMagic.entryName.spells.tableAndSkulls"));
+        
+        ArrayList<IPage> timePassesPages = new ArrayList();
+        timePassesPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.spells.timePasses")));
+        entries.add(new EntryUniText(timePassesPages, "guide.BloodMagic.entryName.spells.timePasses"));
+        
+        ArrayList<IPage> complexSpellBasicsPages = new ArrayList();
+        complexSpellBasicsPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.spells.complexSpellBasics.1")));
+        complexSpellBasicsPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/spells/Paradigm.png"), true));
+        
+        for(int i=2; i<=6; i++)
+        	complexSpellBasicsPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.spells.complexSpellBasics." + i)));
+        
+        complexSpellBasicsPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/spells/Effect.png"), true));
+        complexSpellBasicsPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.spells.complexSpellBasics.7")));
+        complexSpellBasicsPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/spells/Modifier.png"), true));
+        
+        for(int i=8; i<=12; i++)
+        	complexSpellBasicsPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.spells.complexSpellBasics." + i)));
+        
+        complexSpellBasicsPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/spells/Enhancement.png"), true));
+        
+        for(int i=13; i<=16; i++)
+        	complexSpellBasicsPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.spells.complexSpellBasics." + i)));
+        
+        complexSpellBasicsPages.add(new PageUnlocImage("", new ResourceLocation("alchemicalwizardry:textures/misc/screenshots/spells/Conduit.png"), true));
+        complexSpellBasicsPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.spells.complexSpellBasics.17")));
+
+        entries.add(new EntryUniText(complexSpellBasicsPages, "guide.BloodMagic.entryName.spells.complexSpellBasics"));
+        
+        ArrayList<IPage> complexSpellEffectsPages = new ArrayList();
+        for(int i=1; i<=17; i++)
+        	complexSpellEffectsPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.spells.complexSpellEffects." + i)));
+        entries.add(new EntryUniText(complexSpellEffectsPages, "guide.BloodMagic.entryName.spells.complexSpellEffects"));
+        
+        ArrayList<IPage> offTopicPages = new ArrayList();
+        offTopicPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.spells.offTopic")));
+        entries.add(new EntryUniText(offTopicPages, "guide.BloodMagic.entryName.spells.offTopic"));
+        
+        ArrayList<IPage> demonicPowerPages = new ArrayList();
+        demonicPowerPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.spells.demonicPower")));
+        entries.add(new EntryUniText(demonicPowerPages, "guide.BloodMagic.entryName.spells.demonicPower"));
+        
+		categories.add(new CategoryItemStack(entries, "guide.BloodMagic.category.spells", new ItemStack(ModItems.itemComplexSpellCrystal)));
+	}
+	
+	public static void registerAlchemyBook()
+	{
+		List<EntryAbstract> entries = new ArrayList();
+		
+		ArrayList<IPage> fatedMeetingPages = new ArrayList();
+        fatedMeetingPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.fatedMeeting")));
+        entries.add(new EntryUniText(fatedMeetingPages, "guide.BloodMagic.entryName.alchemy.fatedMeeting"));
+        
+        ArrayList<IPage> firstStepsPages = new ArrayList();
+        firstStepsPages.add(getOrbPageForRecipe(RecipeHolder.alchemySetRecipe));
+        firstStepsPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.firstSteps")));
+        entries.add(new EntryUniText(firstStepsPages, "guide.BloodMagic.entryName.alchemy.firstSteps"));
+        
+        ArrayList<IPage> chemistrySetPages = new ArrayList();
+        for(int i=1; i<=10; i++)
+        	chemistrySetPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.chemistrySet." + i)));
+        entries.add(new EntryUniText(chemistrySetPages, "guide.BloodMagic.entryName.alchemy.chemistrySet"));
+        
+        ArrayList<IPage> incensePages = new ArrayList();
+        incensePages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.incense.1")));
+        incensePages.add(new PageIRecipe(RecipeHolder.crucibleRecipe));
+        incensePages.add(new PageIRecipe(RecipeHolder.woodAshRecipe));
+        incensePages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.incense.2")));
+        incensePages.add(getOrbPageForRecipe(RecipeHolder.byrrusRecipe));
+        incensePages.add(getOrbPageForRecipe(RecipeHolder.livensRecipe));
+        incensePages.add(getOrbPageForRecipe(RecipeHolder.virRecipe));
+        incensePages.add(getOrbPageForRecipe(RecipeHolder.purpuraRecipe));
+        incensePages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.incense.3")));
+        entries.add(new EntryUniText(incensePages, "guide.BloodMagic.entryName.alchemy.incense"));
+        
+        ArrayList<IPage> potionsPages = new ArrayList();
+        potionsPages.add(new PageAltarRecipe(RecipeHolder.flaskRecipe));
+        potionsPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.potions")));
+        entries.add(new EntryUniText(potionsPages, "guide.BloodMagic.entryName.alchemy.potions"));
+        
+        ArrayList<IPage> reagentRevolutionPages = new ArrayList();
+        for(int i=1; i<=8; i++)
+        	reagentRevolutionPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.reagentRevolution." + i)));
+        entries.add(new EntryUniText(reagentRevolutionPages, "guide.BloodMagic.entryName.alchemy.reagentRevolution"));
+        
+        ArrayList<IPage> newPotionsPages = new ArrayList();
+        newPotionsPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.newPotions")));
+        entries.add(new EntryUniText(newPotionsPages, "guide.BloodMagic.entryName.alchemy.newPotions"));
+        
+        ArrayList<IPage> soulSandPages = new ArrayList();
+        soulSandPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.soulSand")));
+        entries.add(new EntryUniText(soulSandPages, "guide.BloodMagic.entryName.alchemy.soulSand"));
+        
+        ArrayList<IPage> timeGoesByPages = new ArrayList();
+        timeGoesByPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.timeGoesBy")));
+        entries.add(new EntryUniText(timeGoesByPages, "guide.BloodMagic.entryName.alchemy.timeGoesBy"));
+        
+        ArrayList<IPage> catalystsPages = new ArrayList();
+        catalystsPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.catalysts")));
+        entries.add(new EntryUniText(catalystsPages, "guide.BloodMagic.entryName.alchemy.catalysts"));
+        
+        ArrayList<IPage> activationCrystalPages = new ArrayList();
+        activationCrystalPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.activationCrystal")));
+        entries.add(new EntryUniText(activationCrystalPages, "guide.BloodMagic.entryName.alchemy.activationCrystal"));
+        
+        ArrayList<IPage> reagentSystemPages = new ArrayList();
+        reagentSystemPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.reagentSystem.1")));
+        reagentSystemPages.add(new PageIRecipe(RecipeHolder.calcinatorRecipe));
+        reagentSystemPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.reagentSystem.2")));
+        reagentSystemPages.add(new PageIRecipe(RecipeHolder.belljarRecipe));
+        reagentSystemPages.add(new PageIRecipe(RecipeHolder.relayRecipe));
+        reagentSystemPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.reagentSystem.3")));
+        reagentSystemPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.reagentSystem.4")));
+        reagentSystemPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.reagentSystem.5")));
+        reagentSystemPages.add(new PageIRecipe(RecipeHolder.routerRecipe));
+        reagentSystemPages.add(new PageIRecipe(RecipeHolder.segmenterRecipe));
+        reagentSystemPages.add(new PageIRecipe(RecipeHolder.cleanserRecipe));
+        reagentSystemPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.reagentSystem.6")));
+        
+        reagentSystemPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.reagentSystem.7")));
+
+        entries.add(new EntryUniText(reagentSystemPages, "guide.BloodMagic.entryName.alchemy.reagentSystem"));
+        
+        ArrayList<IPage> magusSecretPages = new ArrayList();
+        magusSecretPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.magusSecret")));
+        entries.add(new EntryUniText(magusSecretPages, "guide.BloodMagic.entryName.alchemy.magusSecret"));
+        
+        ArrayList<IPage> simpleCreationsPages = new ArrayList();
+        simpleCreationsPages.addAll(PageHelper.pagesForLongText(StatCollector.translateToLocal("aw.entries.alchemy.simpleCreations")));
+        entries.add(new EntryUniText(simpleCreationsPages, "guide.BloodMagic.entryName.alchemy.simpleCreations"));
+		
+		categories.add(new CategoryItemStack(entries, "guide.BloodMagic.category.alchemy", new ItemStack(ModItems.alchemyFlask)));
+	}
 }

src/main/java/WayofTime/alchemicalWizardry/common/entity/mob/MailOrderEntityItem.java

@@ -1,11 +1,15 @@
 package WayofTime.alchemicalWizardry.common.entity.mob;
 
-import WayofTime.alchemicalWizardry.ModItems;
+import pneumaticCraft.api.PneumaticRegistry;
+import cpw.mods.fml.common.Optional;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.effect.EntityLightningBolt;
 import net.minecraft.entity.item.EntityItem;
 import net.minecraft.item.ItemStack;
 import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.book.BloodMagicGuide;
+import amerifrance.guideapi.api.GuideRegistry;
 
 public class MailOrderEntityItem extends EntityItem
 {
@@ -47,12 +51,26 @@ public class MailOrderEntityItem extends EntityItem
 		if(!worldObj.isRemote && this.ticksExisted > 100 && !this.isDead)
 		{
 			worldObj.addWeatherEffect(new EntityLightningBolt(worldObj, this.posX, this.posY, this.posZ));
-			EntityItem entity = new BookEntityItem(worldObj, this.posX, this.posY, this.posZ, new ItemStack(ModItems.itemBloodMagicBook));
+
+			if(AlchemicalWizardry.isPneumaticCraftLoaded)
+			{
+				this.deliverItemViaDrone(this.posX, this.posY, this.posZ);
+			}else
+			{
+				EntityItem entity = new BookEntityItem(worldObj, this.posX, this.posY, this.posZ, GuideRegistry.getItemStackForBook(BloodMagicGuide.bloodMagicGuide));
 				entity.lifespan = 6000;
 				entity.delayBeforeCanPickup = 20;
 				entity.motionY = 1;
 				worldObj.spawnEntityInWorld(entity);
+			}
+			
 			this.setDead();
 		}
 	}
+	
+	@Optional.Method(modid = "PneumaticCraft")
+	public void deliverItemViaDrone(double x, double y, double z)
+	{
+		PneumaticRegistry.getInstance().deliverItemsAmazonStyle(worldObj, (int)x, (int)y, (int)z, GuideRegistry.getItemStackForBook(BloodMagicGuide.bloodMagicGuide));
+	}
 }

src/main/java/WayofTime/alchemicalWizardry/common/guide/RecipeHolder.java

@@ -36,6 +36,7 @@ public class RecipeHolder
 	public static IRecipe phantomBridgeRecipe;
 	public static IRecipe holdingSigilRecipe;
 	public static IRecipe affinitySigilRecipe;
+	public static IRecipe weakRitualStoneRecipe;
 	public static IRecipe ritualStoneRecipe;
 	public static IRecipe masterStoneRecipe;
 	public static IRecipe bloodLampRecipe;
@@ -58,7 +59,24 @@ public class RecipeHolder
 	public static IRecipe accelerationRuneRecipe;
 	public static IRecipe harvestSigilRecipe;
 	public static IRecipe crystalCluserRecipe;
+	public static IRecipe arcanePlinthRecipe;
+	public static IRecipe arcanePedestalRecipe;
+	public static IRecipe spellTableRecipe;
+	public static IRecipe alchemySetRecipe;
+	public static IRecipe crucibleRecipe;
 	
+	public static IRecipe woodAshRecipe;
+	public static IRecipe byrrusRecipe;
+	public static IRecipe livensRecipe;
+	public static IRecipe virRecipe;
+	public static IRecipe purpuraRecipe;
+	
+	public static IRecipe routerRecipe;
+	public static IRecipe segmenterRecipe;
+	public static IRecipe cleanserRecipe;
+	public static IRecipe calcinatorRecipe;
+	public static IRecipe belljarRecipe;
+	public static IRecipe relayRecipe;
 	
 	public static AltarRecipe weakBloodOrbRecipe;
 	public static AltarRecipe apprenticeBloodOrbRecipe;
@@ -76,6 +94,14 @@ public class RecipeHolder
 	public static AltarRecipe weakActivationRecipe;
 	public static AltarRecipe filledSocketRecipe;
 	public static AltarRecipe teleposerFocusRecipe1;
+	public static AltarRecipe blankSpellRecipe;
+	public static AltarRecipe waterScribeTool;
+	public static AltarRecipe fireScribeTool;
+	public static AltarRecipe earthScribeTool;
+	public static AltarRecipe airScribeTool;
+	public static AltarRecipe duskRecipe;
+	public static AltarRecipe dawnRecipe;
+	public static AltarRecipe flaskRecipe;
 	
 	public static void init()
 	{
@@ -125,6 +151,26 @@ public class RecipeHolder
 		accelerationRuneRecipe = getRecipeForItemStack(new ItemStack(ModBlocks.bloodRune, 1, 5));
 		harvestSigilRecipe = getRecipeForItemStack(new ItemStack(ModItems.itemHarvestSigil));
 		crystalCluserRecipe = getRecipeForItemStack(new ItemStack(ModBlocks.blockCrystal));	
+		weakRitualStoneRecipe = getRecipeForItemStack(new ItemStack(ModBlocks.imperfectRitualStone));
+		
+		arcanePlinthRecipe = getRecipeForItemStack(new ItemStack(ModBlocks.blockPlinth));
+		arcanePedestalRecipe = getRecipeForItemStack(new ItemStack(ModBlocks.blockPedestal));
+		spellTableRecipe = getRecipeForItemStack(new ItemStack(ModBlocks.blockHomHeart));
+		
+		alchemySetRecipe = getRecipeForItemStack(new ItemStack(ModBlocks.blockWritingTable));
+		crucibleRecipe = getRecipeForItemStack(new ItemStack(ModBlocks.blockCrucible));
+		woodAshRecipe = getRecipeForItemStack(new ItemStack(ModItems.itemIncense, 1, 0));
+		byrrusRecipe = getRecipeForItemStack(new ItemStack(ModItems.itemIncense, 1, 1));
+		livensRecipe = getRecipeForItemStack(new ItemStack(ModItems.itemIncense, 1, 2));
+		virRecipe = getRecipeForItemStack(new ItemStack(ModItems.itemIncense, 1, 3));
+		purpuraRecipe = getRecipeForItemStack(new ItemStack(ModItems.itemIncense, 1, 4));
+		
+		routerRecipe = getRecipeForItemStack(new ItemStack(ModItems.itemAttunedCrystal));
+		segmenterRecipe = getRecipeForItemStack(new ItemStack(ModItems.itemTankSegmenter));
+		cleanserRecipe = getRecipeForItemStack(new ItemStack(ModItems.itemDestinationClearer));
+		calcinatorRecipe = getRecipeForItemStack(new ItemStack(ModBlocks.blockAlchemicCalcinator));
+		belljarRecipe = getRecipeForItemStack(new ItemStack(ModBlocks.blockCrystalBelljar));
+		relayRecipe = getRecipeForItemStack(new ItemStack(ModBlocks.blockReagentConduit));
 		
 		weakBloodOrbRecipe = getAltarRecipeForItemStack(new ItemStack(ModItems.weakBloodOrb));
 		apprenticeBloodOrbRecipe = getAltarRecipeForItemStack(new ItemStack(ModItems.apprenticeBloodOrb));
@@ -142,6 +188,14 @@ public class RecipeHolder
 		weakActivationRecipe = getAltarRecipeForItemStack(new ItemStack(ModItems.activationCrystal, 1, 0));
 		filledSocketRecipe = getAltarRecipeForItemStack(new ItemStack(ModBlocks.bloodSocket));
 		teleposerFocusRecipe1 = getAltarRecipeForItemStack(new ItemStack(ModItems.telepositionFocus));
+		blankSpellRecipe = getAltarRecipeForItemStack(new ItemStack(ModItems.blankSpell));
+		waterScribeTool = getAltarRecipeForItemStack(new ItemStack(ModItems.waterScribeTool));
+		fireScribeTool = getAltarRecipeForItemStack(new ItemStack(ModItems.fireScribeTool));
+		earthScribeTool = getAltarRecipeForItemStack(new ItemStack(ModItems.earthScribeTool));
+		airScribeTool = getAltarRecipeForItemStack(new ItemStack(ModItems.airScribeTool));
+		duskRecipe = getAltarRecipeForItemStack(new ItemStack(ModItems.duskScribeTool));
+		dawnRecipe = getAltarRecipeForItemStack(new ItemStack(ModItems.dawnScribeTool));
+		flaskRecipe = getAltarRecipeForItemStack(new ItemStack(ModItems.alchemyFlask));
 	}
 	
 	private static IRecipe getRecipeForItemStack(ItemStack stack)

src/main/java/WayofTime/alchemicalWizardry/common/items/ItemIncense.java

@@ -5,19 +5,25 @@ import java.util.List;
 import net.minecraft.client.renderer.texture.IIconRegister;
 import net.minecraft.creativetab.CreativeTabs;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.IIcon;
 import net.minecraft.util.MathHelper;
 import net.minecraft.util.StatCollector;
+import net.minecraftforge.oredict.OreDictionary;
 import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModItems;
+import WayofTime.alchemicalWizardry.api.items.ShapelessBloodOrbRecipe;
 import WayofTime.alchemicalWizardry.api.sacrifice.IIncense;
+import cpw.mods.fml.common.registry.GameRegistry;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
 public class ItemIncense extends Item implements IIncense
 {
-    private static final String[] ITEM_NAMES = new String[]{"Woodash", "Cloves"};
+    private static final String[] ITEM_NAMES = new String[]{"Woodash", "Byrrus", "Livens", "Viridis", "Purpura"};
 
     @SideOnly(Side.CLIENT)
     private IIcon[] icons;
@@ -40,9 +46,17 @@ public class ItemIncense extends Item implements IIncense
     {
         icons = new IIcon[ITEM_NAMES.length];
 
+        IIcon baseIcon = iconRegister.registerIcon("AlchemicalWizardry:" + "baseIncenseItem");
+        
         for (int i = 0; i < ITEM_NAMES.length; ++i)
+        {
+        	if(this.doesIncenseHaveUniqueTexture(i))
         	{
                 icons[i] = iconRegister.registerIcon("AlchemicalWizardry:" + "baseIncenseItem" + ITEM_NAMES[i]);
+        	}else
+        	{
+        		icons[i] = baseIcon;
+        	}
         }
     }
 
@@ -77,66 +91,130 @@ public class ItemIncense extends Item implements IIncense
         }
     }
     
+    @Override
+    @SideOnly(Side.CLIENT)
+    public int getColorFromItemStack(ItemStack stack, int pass)
+    {
+    	if(!this.doesIncenseHaveUniqueTexture(stack.getItemDamage()))
+    	{
+    		EnumIncense inc = EnumIncense.getEnumForIndex(stack.getItemDamage());
+            return (int)((255*inc.redColour * 256 * 256 + 255*inc.greenColour * 256 + 255*inc.blueColour));
+    	}
+
+        return 256 * (256 * 255 + 255) + 255;
+    }
+
 	@Override
 	public int getMinLevel(ItemStack stack) 
 	{
-		switch(stack.getItemDamage())
-		{
-		case 0:
-			return 0;
-		case 1:
-			return 200;
-		}
-		return 0;
+		return EnumIncense.getEnumForIndex(stack.getItemDamage()).minValue;
 	}
 
 	@Override
 	public int getMaxLevel(ItemStack stack) 
 	{
-		switch(stack.getItemDamage())
-		{
-		case 0:
-			return 200;
-		case 1:
-			return 500;
-		}
-		return 100;
+		return EnumIncense.getEnumForIndex(stack.getItemDamage()).maxValue;
 	}
 
 	@Override
 	public int getIncenseDuration(ItemStack stack) 
 	{
-		return 200;
+		return EnumIncense.getEnumForIndex(stack.getItemDamage()).incenseDuration;
 	}
 	
 	@Override
 	public float getTickRate(ItemStack stack)
 	{
-		switch(stack.getItemDamage())
-		{
-		case 0:
-			return 1.0f;
-		case 1:
-			return 0.5f;
-		}
-		return 1.0f;
+		return EnumIncense.getEnumForIndex(stack.getItemDamage()).tickRate;
 	}
 
 	@Override
 	public float getRedColour(ItemStack stack) 
 	{
-		return 1.0f;
+		return EnumIncense.getEnumForIndex(stack.getItemDamage()).redColour;
 	}
 
 	@Override
 	public float getGreenColour(ItemStack stack) 
 	{
-		return 0;
+		return EnumIncense.getEnumForIndex(stack.getItemDamage()).greenColour;
 	}
 
 	@Override
 	public float getBlueColour(ItemStack stack) 
 	{
-		return 0;
+		return EnumIncense.getEnumForIndex(stack.getItemDamage()).blueColour;
+	}
+	
+	public boolean doesIncenseHaveUniqueTexture(int meta)
+	{
+		return false;
+	}
+	
+	public static void registerIncenseRecipes()
+	{
+		int WILDCARD = OreDictionary.WILDCARD_VALUE;
+		ItemStack woodStack = new ItemStack(Blocks.log, 1, WILDCARD);
+		ItemStack charcoalStack = new ItemStack(Items.coal, 1, 1);
+		ItemStack leavesStack = new ItemStack(Blocks.leaves, 1, WILDCARD);
+		ItemStack goldNuggetStack = new ItemStack(Items.gold_nugget, 1, WILDCARD);
+		ItemStack stringStack = new ItemStack(Items.string, 1, WILDCARD);
+		ItemStack glowstoneStack = new ItemStack(Items.glowstone_dust, 1, WILDCARD);
+		ItemStack soulSandStack = new ItemStack(Blocks.soul_sand);
+		ItemStack gunpowderStack = new ItemStack(Items.gunpowder);
+		ItemStack fermentedEyeStack = new ItemStack(Items.fermented_spider_eye);
+		ItemStack quartzStack = new ItemStack(Items.quartz, 1, WILDCARD);
+		ItemStack blazePowderStack = new ItemStack(Items.blaze_powder);
+		ItemStack netherwartStack = new ItemStack(Items.nether_wart);
+		ItemStack fracturedBoneStack = new ItemStack(ModItems.baseAlchemyItems, 1, 5);
+		
+		ItemStack woodashStack = new ItemStack(ModItems.itemIncense, 1, 0);
+		
+		GameRegistry.addRecipe(woodashStack, "WWW", "WCW", "WWW", 'W', woodStack, 'C', charcoalStack); //WOODASH
+		GameRegistry.addRecipe(new ShapelessBloodOrbRecipe(new ItemStack(ModItems.itemIncense, 1, 1), woodashStack, "dyeRed", "dyeRed", new ItemStack(Items.redstone), leavesStack, leavesStack, new ItemStack(ModItems.apprenticeBloodOrb)));
+		GameRegistry.addRecipe(new ShapelessBloodOrbRecipe(new ItemStack(ModItems.itemIncense, 1, 2), woodashStack, "dyeBlue", "dyeBlue", goldNuggetStack, goldNuggetStack, glowstoneStack, stringStack, stringStack, new ItemStack(ModItems.magicianBloodOrb)));
+		GameRegistry.addRecipe(new ShapelessBloodOrbRecipe(new ItemStack(ModItems.itemIncense, 1, 3), woodashStack, "dyeGreen", "dyeGreen", soulSandStack, gunpowderStack, fermentedEyeStack, new ItemStack(ModItems.masterBloodOrb)));
+		GameRegistry.addRecipe(new ShapelessBloodOrbRecipe(new ItemStack(ModItems.itemIncense, 1, 4), woodashStack, "dyePurple", "dyePurple", quartzStack, netherwartStack, blazePowderStack, fracturedBoneStack, goldNuggetStack, new ItemStack(ModItems.archmageBloodOrb)));
+	}
+	
+	public enum EnumIncense
+	{
+		WOODASH(0, 200, 1.0f, 1000, 0.937f, 0.898f, 0.820f),
+		RED(200, 600, 1.5f, 1000, 1.0f, 0, 0),
+		BLUE(600, 1200, 3.0f, 1000, 0, 0, 1.0f),
+		GREEN(1200, 2000, 4.0f, 1000, 0, 1.0f, 0),
+		PURPLE(2000, 3000, 5.0f, 1000, 1.0f, 0, 1.0f);
+		
+		public final int minValue;
+		public final int maxValue;
+		public final float tickRate;
+		public final int incenseDuration;
+		
+		public final float redColour;
+		public final float greenColour;
+		public final float blueColour;
+		
+		private EnumIncense(int minValue, int maxValue, float tickRate, int dur, float red, float green, float blue)
+		{
+			this.minValue = minValue;
+			this.maxValue = maxValue;
+			this.tickRate = tickRate;
+			this.incenseDuration = dur;
+			
+			this.redColour = red;
+			this.greenColour = green;
+			this.blueColour = blue;
+		}
+		
+		public static EnumIncense getEnumForIndex(int index)
+		{
+			if(index > EnumIncense.values().length || index < 0)
+			{
+				return WOODASH;
+			}else
+			{
+				return EnumIncense.values()[index];
+			}
+		}
 	}
 }

src/main/java/WayofTime/alchemicalWizardry/common/items/sigil/holding/SigilOfHolding.java

@@ -1,15 +1,10 @@
 package WayofTime.alchemicalWizardry.common.items.sigil.holding;
 
-import WayofTime.alchemicalWizardry.AlchemicalWizardry;
-import WayofTime.alchemicalWizardry.ModItems;
-import WayofTime.alchemicalWizardry.api.items.interfaces.IHolding;
-import WayofTime.alchemicalWizardry.common.items.EnergyItems;
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
+import java.util.List;
+
 import net.minecraft.client.renderer.texture.IIconRegister;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.nbt.NBTTagList;
@@ -17,10 +12,10 @@ import net.minecraft.util.IIcon;
 import net.minecraft.util.MathHelper;
 import net.minecraft.util.StatCollector;
 import net.minecraft.world.World;
-import net.minecraftforge.common.util.Constants;
-
-import java.util.ArrayList;
-import java.util.List;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
 
 public class SigilOfHolding extends EnergyItems
 {

src/main/java/WayofTime/alchemicalWizardry/common/rituals/RitualEffectEllipsoid.java

@@ -48,7 +48,7 @@ public class RitualEffectEllipsoid extends RitualEffect
         int ySize = item2 == null ? 0 : item2.stackSize;
         int zSize = item3 == null ? 0 : item3.stackSize;
 
-        int cost = (int) Math.pow((xSize + 1) * (ySize + 1) * (zSize + 1), 0.333);
+        int cost = 5;
 
         if (currentEssence < cost)
         {

src/main/java/WayofTime/alchemicalWizardry/common/rituals/RitualEffectExpulsion.java

@@ -65,6 +65,10 @@ public class RitualEffectExpulsion extends RitualEffect
 
             for (EntityPlayer entityplayer : playerList)
             {
+            	if(entityplayer.capabilities.isCreativeMode)
+            	{
+            		continue;
+            	}
                 String playerString = SpellHelper.getUsername(entityplayer);
                 if (!playerString.equals(owner))
                 {

src/main/java/WayofTime/alchemicalWizardry/common/rituals/RitualEffectMagnetic.java

@@ -4,6 +4,8 @@ import java.util.ArrayList;
 import java.util.List;
 
 import net.minecraft.block.Block;
+import net.minecraft.block.BlockOre;
+import net.minecraft.block.BlockRedstoneOre;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.world.World;
@@ -22,6 +24,24 @@ public class RitualEffectMagnetic extends RitualEffect
     private static final int terraeDrain = 10;
     private static final int orbisTerraeDrain = 10;
 
+    public static boolean isBlockOre(Block block, int meta)
+    {
+        if (block == null)
+            return false;
+        
+        if (block instanceof BlockOre || block instanceof BlockRedstoneOre)
+            return true;
+        
+        ItemStack itemStack = new ItemStack(block, 1, meta);
+        for (int id : OreDictionary.getOreIDs(itemStack))
+        {
+            String oreName = OreDictionary.getOreName(id);
+            if (oreName.contains("ore"))
+                return true;
+        }
+        return false;
+    }
+    
     @Override
     public void performEffect(IMasterRitualStone ritualStone)
     {
@@ -67,6 +87,7 @@ public class RitualEffectMagnetic extends RitualEffect
                             yRep = y + j;
                             zRep = z + k;
                             replace = true;
+                            break;
                         }
                     }
                 }
@@ -96,19 +117,7 @@ public class RitualEffectMagnetic extends RitualEffect
                             Block block = world.getBlock(x + i, j, z + k);
                             int meta = world.getBlockMetadata(x + i, j, z + k);
 
-                            if (block == null)
-                            {
-                                continue;
-                            }
-
-                            ItemStack itemStack = new ItemStack(block, 1, meta);
-                            int id = OreDictionary.getOreID(itemStack);
-
-                            if (id != -1)
-                            {
-                                String oreName = OreDictionary.getOreName(id);
-
-                                if (oreName.contains("ore"))
+                            if (isBlockOre(block, meta))
                             {
                                 //Allow swapping code. This means the searched block is an ore.
                                 BlockTeleposer.swapBlocks(this, world, world, x + i, j, z + k, xRep, yRep, zRep);
@@ -133,7 +142,6 @@ public class RitualEffectMagnetic extends RitualEffect
 
                                 return;
                             }
-                            }
                             k++;
                         }
                         k = -radius;

src/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TECrucible.java

@@ -3,19 +3,24 @@ package WayofTime.alchemicalWizardry.common.tileEntity;
 import java.util.List;
 import java.util.Random;
 
+import net.minecraft.block.Block;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
 import net.minecraft.network.NetworkManager;
 import net.minecraft.network.Packet;
 import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.Constants;
 import WayofTime.alchemicalWizardry.api.sacrifice.IIncense;
 import WayofTime.alchemicalWizardry.api.sacrifice.PlayerSacrificeHandler;
 import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
 
 public class TECrucible extends TEInventory
 {
+	private int radius = 5;
+	
 	public float rColour;
 	public float gColour;
 	public float bColour;
@@ -45,6 +50,8 @@ public class TECrucible extends TEInventory
 		if(worldObj.isRemote)
 			return;
 		
+		boolean stateChanged = false;
+		
 		if(ticksRemaining <= 0)
 		{
 			ItemStack stack = this.getStackInSlot(0);
@@ -67,16 +74,17 @@ public class TECrucible extends TEInventory
 				{
 					this.setInventorySlotContents(0, null);
 				}
+				
+				stateChanged = true;
 			}
 		}
 
 		if(ticksRemaining > 0)
 		{
-			List<EntityPlayer> playerList = SpellHelper.getPlayersInRange(worldObj, xCoord + 0.5, yCoord + 0.5, zCoord + 0.5, 3, 3);
+			List<EntityPlayer> playerList = SpellHelper.getPlayersInRange(worldObj, xCoord + 0.5, yCoord + 0.5, zCoord + 0.5, radius, radius);
 			
 			if(playerList != null && !playerList.isEmpty())
 			{
-				boolean stateChanged = false;
 				boolean allAreGood = true;
 				
 				for(EntityPlayer player : playerList)
@@ -100,26 +108,48 @@ public class TECrucible extends TEInventory
 					stateChanged = true;
 				}
 				
+				
+			}else
+			{
+				if(state != 0)
+				{
+					state = 0;
+					worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+					updateNeighbors();
+				}
+			}
+		}else
+		{
+			if(state != 0)
+			{
+				state = 0;
+				worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+				updateNeighbors();
+			}
+		}
+		
 		if(stateChanged)
 		{
 			worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+
+			updateNeighbors();
 		}
-			}else
+	}
+	
+	private void updateNeighbors()
 	{
-				if(state != 0)
-				{
-					state = 0;
-					worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
-				}
-			}
-		}else
-		{
-			if(state != 0)
-			{
-				state = 0;
-				worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
-			}
-		}
+		Block block = worldObj.getBlock(xCoord + 1, yCoord, zCoord);
+        block.onNeighborBlockChange(worldObj, xCoord + 1, yCoord, zCoord, block);
+        block = worldObj.getBlock(xCoord - 1, yCoord, zCoord);
+        block.onNeighborBlockChange(worldObj, xCoord - 1, yCoord, zCoord, block);
+        block = worldObj.getBlock(xCoord, yCoord + 1, zCoord);
+        block.onNeighborBlockChange(worldObj, xCoord, yCoord + 1, zCoord, block);
+        block = worldObj.getBlock(xCoord, yCoord - 1, zCoord);
+        block.onNeighborBlockChange(worldObj, xCoord, yCoord - 1, zCoord, block);
+        block = worldObj.getBlock(xCoord, yCoord, zCoord + 1);
+        block.onNeighborBlockChange(worldObj, xCoord, yCoord, zCoord + 1, block);
+        block = worldObj.getBlock(xCoord, yCoord, zCoord - 1);
+        block.onNeighborBlockChange(worldObj, xCoord, yCoord, zCoord - 1, block); 
 	}
 	
 	public void spawnClientParticle(World world, int x, int y, int z, Random rand)
@@ -127,15 +157,16 @@ public class TECrucible extends TEInventory
 		switch(state)
 		{
 		case 0:
-	        world.spawnParticle("reddust", x + 0.5D + rand.nextGaussian() / 8, y + 0.5D, z + 0.5D + rand.nextGaussian() / 8, 0.15, 0.15, 0.15);
+	        world.spawnParticle("reddust", x + 0.5D + rand.nextGaussian() / 8, y + 0.7D, z + 0.5D + rand.nextGaussian() / 8, 0.15, 0.15, 0.15);
 			break;
 			
 		case 1:
-	        world.spawnParticle("reddust", x + 0.5D + rand.nextGaussian() / 8, y + 0.5D, z + 0.5D + rand.nextGaussian() / 8, 0.9, 0.9, 0.9);
+	        world.spawnParticle("reddust", x + 0.5D + rand.nextGaussian() / 8, y + 0.7D, z + 0.5D + rand.nextGaussian() / 8, 1.0, 1.0, 1.0);
 			break;
 			
 		case 2:
-	        world.spawnParticle("reddust", x + 0.5D + rand.nextGaussian() / 8, y + 0.5D, z + 0.5D + rand.nextGaussian() / 8, rColour, gColour, bColour);
+	        world.spawnParticle("reddust", x + 0.5D + rand.nextGaussian() / 8, y + 0.7D, z + 0.5D + rand.nextGaussian() / 8, rColour, gColour, bColour);
+	        world.spawnParticle("flame", x + 0.5D + rand.nextGaussian() / 32, y + 0.7D, z + 0.5D + rand.nextGaussian() / 32, 0, 0.02, 0);
 			break;
 			
 		case 3:
@@ -152,6 +183,7 @@ public class TECrucible extends TEInventory
     	tag.setInteger("ticksRemaining", ticksRemaining);
     	tag.setInteger("minValue", minValue);
     	tag.setInteger("maxValue", maxValue);
+    	tag.setFloat("increment", this.incrementValue);
         
         this.writeClientNBT(tag);
     }
@@ -164,6 +196,7 @@ public class TECrucible extends TEInventory
     	ticksRemaining = tag.getInteger("ticksRemaining");
     	minValue = tag.getInteger("minValue");
     	maxValue = tag.getInteger("maxValue");
+    	incrementValue = tag.getFloat("increment");
 
         this.readClientNBT(tag);
     }
@@ -174,6 +207,20 @@ public class TECrucible extends TEInventory
     	tag.setFloat("gColour", gColour);
     	tag.setFloat("bColour", bColour);
     	tag.setInteger("state", state);
+    	
+    	NBTTagList invList = new NBTTagList();
+        for (int i = 0; i < inv.length; i++)
+        {
+            if (inv[i] != null)
+            {
+                NBTTagCompound stackTag = new NBTTagCompound();
+                stackTag.setByte("Slot", (byte) i);
+                inv[i].writeToNBT(stackTag);
+                invList.appendTag(stackTag);
+            }
+        }
+
+        tag.setTag("Inventory", invList);
     }
     
     public void readClientNBT(NBTTagCompound tag)
@@ -182,6 +229,17 @@ public class TECrucible extends TEInventory
     	gColour = tag.getFloat("gColour");
     	bColour = tag.getFloat("bColour");
     	state = tag.getInteger("state");
+    	
+    	NBTTagList invList = tag.getTagList("Inventory",
+                Constants.NBT.TAG_COMPOUND);
+        for (int i = 0; i < invList.tagCount(); i++)
+        {
+            NBTTagCompound stackTag = invList.getCompoundTagAt(i);
+            int slot = stackTag.getByte("Slot");
+
+            if (slot >= 0 && slot < inv.length)
+                inv[slot] = ItemStack.loadItemStackFromNBT(stackTag);
+        }
     }
 
     
@@ -211,4 +269,9 @@ public class TECrucible extends TEInventory
     {
         return stack != null ? stack.getItem() instanceof IIncense : false;
     }
+
+	public int getRSPowerOutput() 
+	{
+		return (state == 1 || state == 0) ? 0 : 15;
+	}
 }

src/main/resources/assets/alchemicalwizardry/lang/en_US.lang

@@ -67,6 +67,7 @@ tile.blockMimic.name=Mimic Block
 tile.blockSpectralContainer.name=Spectral Container
 tile.blockBloodLightSource.name=Blood Light
 tile.spectralBlock.name=Spectral Block
+tile.blockCrucible.name=Incense Crucible
 
 #Item Localization
 item.weakBloodOrb.name=Weak Blood Orb
@@ -235,7 +236,11 @@ item.boundPlateWater.name=Water Omega Plate
 item.boundLeggingsWater.name=Water Omega Leggings
 item.boundBootsWater.name=Water Omega Boots
 
-item.bloodMagicIncenseItem.Woodash.name=Testing Incense
+item.bloodMagicIncenseItem.Woodash.name=Wood Ash
+item.bloodMagicIncenseItem.Byrrus.name=Byrrus
+item.bloodMagicIncenseItem.Livens.name=Livens
+item.bloodMagicIncenseItem.Viridis.name=Viridis
+item.bloodMagicIncenseItem.Purpura.name=Purpura
 
 #Creative Tab
 itemGroup.tabBloodMagic=Blood Magic
@@ -417,6 +422,7 @@ tooltip.voidsigil.desc=Better than a Swiffer!
 tooltip.watersigil.desc=Infinite water, anyone?
 tooltip.routingFocus.limit=Limit:
 tooltip.routingFocus.desc=A focus used to route items
+tooltip.alchemy.usedinincense=Purifying incense used in a crucible
 
 #Messages
 message.altar.capacity=Capacity: %s LP

src/main/resources/assets/alchemicalwizardry/lang/zh_TW.lang

@@ -18,7 +18,7 @@ tile.armourForge.name=靈魂裝甲鍛造石
 tile.emptySocket.name=空的血插槽
 tile.bloodStoneBrick.name=血石磚
 tile.largeBloodStoneBrick.name=大血石磚
-tile.blockWritingTable.name=煉金術臺
+tile.blockWritingTable.name=煉金術台
 tile.blockHomHeart.name=符咒桌
 tile.bloodPedestal.name=奧術基座
 tile.bloodPlinth.name=奧術基柱
@@ -51,17 +51,30 @@ tile.blockSpellEffect.fire.name=火焰效應器
 tile.blockSpellEffect.ice.name=冰霜效應器
 tile.blockSpellEffect.wind.name=風暴效應器
 tile.blockSpellEffect.earth.name=塵土效應器
-tile.alchemicCalcinator.name=元素煅燒爐
+tile.alchemicCalcinator.name=煉金鍛燒爐
 tile.crystalBelljar.name=玻璃鐘罩
-tile.blockReagentConduit.name=元素中續器
+tile.blockReagentConduit.name=煉金中續器
 tile.lifeEssenceFluidBlock.name=生命本質
+tile.crystalBlock.fullCrystal.name=碎片集晶
+tile.crystalBlock.crystalBrick.name=碎片集晶磚
+tile.demonPortal.name=惡魔傳送站
+tile.demonChest.name=Demon's Chest
+tile.enchantmentGlyph.enchantability.name=Glyph of the Adept Enchanter
+tile.enchantmentGlyph.enchantmentLevel.name=Glyph of Arcane Potential
+tile.stabilityGlyph.stability1.name=Glyph of Rigid Stability
+tile.schematicSaver.name=Schematic Saver
+tile.blockMimic.name=Mimic Block
+tile.blockSpectralContainer.name=Spectral Container
+tile.blockBloodLightSource.name=Blood Light
+tile.spectralBlock.name=Spectral Block
+tile.blockCrucible.name=Incense Crucible
 
 #Item Localization
 item.weakBloodOrb.name=虛弱氣血寶珠
 item.apprenticeBloodOrb.name=學徒氣血寶珠
-item.magicianBloodOrb.name=法師的氣血寶珠
+item.magicianBloodOrb.name=法師氣血寶珠
 item.masterBloodOrb.name=導師氣血寶珠
-item.archmageBloodOrb.name=大法師的氣血寶珠
+item.archmageBloodOrb.name=賢者氣血寶珠
 item.energyBlast.name=能源爆破槍
 item.energySword.name=約束之劍
 item.lavaCrystal.name=熔岩晶體
@@ -83,8 +96,9 @@ item.fireScribeTool.name=元素銘文：火
 item.earthScribeTool.name=元素銘文：地
 item.airScribeTool.name=元素銘文：風
 item.duskScribeTool.name=元素銘文： 幽暗
-item.activationCrystalWeak.name=[低等]激活水晶
+item.activationCrystalWeak.name=[虛弱]激活水晶
 item.activationCrystalAwakened.name=[覺醒]激活水晶
+item.activationCrystalCreative.name=[創造模式]激活水晶
 item.boundPickaxe.name=約束之鎬
 item.boundAxe.name=約束之斧
 item.boundShovel.name=約束之鍬
@@ -96,7 +110,7 @@ item.weakBloodShard.name=虛弱氣血碎片
 item.growthSigil.name=綠叢印記
 item.blankSpell.name=未綁定的水晶
 item.alchemyFlask.name=藥瓶
-item.standardBindingAgent.name=[標準的]粘合劑
+item.standardBindingAgent.name=[標準的]黏合劑
 item.mundanePowerCatalyst.name=[平凡的]功率催化劑
 item.averagePowerCatalyst.name=[普通的]功率催化劑
 item.greaterPowerCatalyst.name=[更好的]功率催化劑
@@ -124,11 +138,11 @@ item.demonicSlate.name=惡魔石板
 item.sigilOfTheBridge.name=影橋印記
 item.armourInhibitor.name=裝甲約束器
 item.cheatyItem.name=測試寶珠
-item.weakFillingAgent.name=[虚弱的]填充劑
+item.weakFillingAgent.name=[虛弱的]填充劑
 item.standardFillingAgent.name=[標準的]填充劑
 item.enhancedFillingAgent.name=[加強的]填充劑
-item.weakBindingAgent.name=[虚弱的]粘合劑
-item.ritualDiviner.name=儀式推測仗
+item.weakBindingAgent.name=[虛弱的]黏合劑
+item.ritualDiviner.name=儀式推測杖
 item.sigilOfMagnetism.name=磁引印記
 item.itemDiabloKey.name=約束鑰匙
 item.energyBazooka.name=能源火箭筒
@@ -136,10 +150,10 @@ item.bloodLightSigil.name=血光印記
 item.itemComplexSpellCrystal.name=複雜的法術水晶
 item.itemSigilOfSupression.name=抑液印記
 item.itemSigilOfEnderSeverance.name=絕影印記
-item.bucketLive.name=生命之桶
+item.bucketLife.name=生命之桶
 item.bloodMagicBaseItem.QuartzRod.name=石英棍
 item.bloodMagicBaseItem.EmptyCore.name=空白核心
-item.bloodMagicBaseItem.MagicalesCable.name=魔法線纜
+item.bloodMagicBaseItem.MagicalesCable.name=魔法纜線
 item.bloodMagicBaseItem.WoodBrace.name=木支架
 item.bloodMagicBaseItem.StoneBrace.name=石支架
 item.bloodMagicBaseItem.ProjectileCore.name=拋射核心
@@ -147,8 +161,8 @@ item.bloodMagicBaseItem.SelfCore.name=自體核心
 item.bloodMagicBaseItem.MeleeCore.name=格鬥核心
 item.bloodMagicBaseItem.ToolCore.name=工具核心
 item.bloodMagicBaseItem.ParadigmBackPlate.name=範式板
-item.bloodMagicBaseItem.OutputCable.name=法術線纜：輸出
-item.bloodMagicBaseItem.InputCable.name=法術線纜：輸入
+item.bloodMagicBaseItem.OutputCable.name=法術纜線：輸出
+item.bloodMagicBaseItem.InputCable.name=法術纜線：輸入
 item.bloodMagicBaseItem.FlameCore.name=火焰核心
 item.bloodMagicBaseItem.IcyCore.name=冰霜核心
 item.bloodMagicBaseItem.GustCore.name=風暴核心
@@ -165,6 +179,10 @@ item.bloodMagicBaseItem.CostCore.name=代價核心
 item.bloodMagicBaseItem.PotencyCore.name=效能核心
 item.bloodMagicBaseItem.ObsidianBrace.name=黑曜石支架
 item.bloodMagicBaseItem.EtherealSlate.name=懸幽石板
+item.bloodMagicBaseItem.LifeShard.name=生命碎片
+item.bloodMagicBaseItem.SoulShard.name=靈魂碎片
+item.bloodMagicBaseItem.LifeBrace.name=生命支架
+item.bloodMagicBaseItem.SoulRunicPlate.name=靈魂文板
 item.bloodMagicAlchemyItem.Offensa.name=攻勢粉末
 item.bloodMagicAlchemyItem.Praesidium.name=防守粉末
 item.bloodMagicAlchemyItem.OrbisTerrae.name=環境粉末
@@ -190,6 +208,40 @@ item.creativeDagger.name=[創造模式]犧牲匕首
 item.itemBloodPack.name=血液背包
 item.itemHarvestSigil.name=豐收印記
 item.itemCompressionSigil.name=壓縮印記
+item.itemAssassinSigil.name=Sigil of the Assassin
+item.transcendentBloodOrb.name=卓越氣血寶珠
+item.itemMailCatalogue.name=Mail Order Catalogue
+item.inputRoutingFocus.name=Input Routing Focus
+item.bloodMagicBaseItem.EnderShard.name=Ender Shard
+item.outputRoutingFocus.default.name=Default Output Routing Focus
+item.outputRoutingFocus.modItem.name=Output Routing Focus (ModItem)
+item.outputRoutingFocus.ignMeta.name=Output Routing Focus (Ignore Meta)
+item.outputRoutingFocus.matchNBT.name=Output Routing Focus (MatchNBT)
+item.outputRoutingFocus.global.name=Output Routing Focus (Global)
+item.dawnScribeTool.name=Elemental Inscription Tool: Dawn
+item.boundHelmetEarth.name=Earth Omega Helmet
+item.boundPlateEarth.name=Earth Omega Plate
+item.boundLeggingsEarth.name=Earth Omega Leggings
+item.boundBootsEarth.name=Earth Omega Boots
+item.boundHelmetWind.name=Wind Omega Helmet
+item.boundPlateWind.name=Wind Omega Plate
+item.boundLeggingsWind.name=Wind Omega Leggings
+item.boundBootsWind.name=Wind Omega Boots
+item.boundHelmetFire.name=Fire Omega Helmet
+item.boundPlateFire.name=Fire Omega Plate
+item.boundLeggingsFire.name=Fire Omega Leggings
+item.boundBootsFire.name=Fire Omega Boots
+item.boundHelmetWater.name=Water Omega Helmet
+item.boundPlateWater.name=Water Omega Plate
+item.boundLeggingsWater.name=Water Omega Leggings
+item.boundBootsWater.name=Water Omega Boots
+
+item.bloodMagicIncenseItem.Woodash.name=Wood Ash
+item.bloodMagicIncenseItem.Byrrus.name=Byrrus
+item.bloodMagicIncenseItem.Livens.name=Livens
+item.bloodMagicIncenseItem.Viridis.name=Viridis
+item.bloodMagicIncenseItem.Purpura.name=Purpura
+
 #Creative Tab
 itemGroup.tabBloodMagic=血魔法
 
@@ -198,13 +250,17 @@ bm.string.consume=使用
 bm.string.drain=消耗
 bm.string.tier=層數
 bm.string.crafting.orb.shaped=特定血寶珠合成
-bm.string.crafting.orb.shapeless=不定血寶珠合成
+bm.string.crafting.orb.shapeless=無序血寶珠合成
+text.recipe.altar=Blood Altar
+text.recipe.altar.tier=Tier: %s
+text.recipe.altar.bloodRequired=LP: %s
+text.recipe.shapedOrb=Shaped Orb Recipe
 
 #Entities
 entity.AWWayofTime.EarthElemental.name=土之元素精靈
 entity.AWWayofTime.FireElemental.name=火之元素精靈
-entity.AWWayofTime.HolyElemental.name=光之元素精靈
-entity.AWWayofTime.ShadeElemental.name=暗之元素精靈
+entity.AWWayofTime.HolyElemental.name=神聖元素精靈
+entity.AWWayofTime.ShadeElemental.name=暗黑元素精靈
 entity.AWWayofTime.WaterElemental.name=水之元素精靈
 entity.AWWayofTime.AirElemental.name=風之元素精靈
 entity.AWWayofTime.Shade.name=影魔
@@ -215,3 +271,199 @@ entity.AWWayofTime.WingedFireDemon.name=火翼惡魔
 entity.AWWayofTime.BileDemon.name=膽汁惡魔
 entity.AWWayofTime.LowerGuardian.name=低等守護者
 entity.AWWayofTime.FallenAngel.name=墮天使
+entity.AWWayofTime.MinorDemonGruntGuardian.name=格倫魔守衛
+entity.AWWayofTime.MinorDemonGruntGuardianWind.name=風格倫魔守衛
+entity.AWWayofTime.MinorDemonGruntGuardianFire.name=火格倫魔守衛
+entity.AWWayofTime.MinorDemonGruntGuardianIce.name=冰格倫魔守衛
+entity.AWWayofTime.MinorDemonGruntGuardianEarth.name=土格倫魔守衛
+entity.AWWayofTime.MinorDemonGruntWind.name=風格倫魔
+entity.AWWayofTime.MinorDemonGruntFire.name=火格倫魔
+entity.AWWayofTime.MinorDemonGruntIce.name=冰格倫魔
+entity.AWWayofTime.MinorDemonGruntEarth.name=土格倫魔
+entity.AWWayofTime.MinorDemonGrunt.name=格倫魔
+
+#Commands
+commands.soulnetwork.usage=/soulnetwork <玩家>
+commands.bind.usage=/bind <玩家>
+commands.bind.success=物品成功綁定!
+commands.bind.failed.noPlayer=沒有指定玩家
+commands.bind.failed.alreadyBound=物品已經被綁定; 使用 /unbind 來解除綁定
+commands.bind.failed.notBindable=物品無法被綁定
+commands.unbind.usage=/unbind
+commands.unbind.success=物品成功解除綁定!
+commands.unbind.failed.notBindable=物品無法解除綁定
+commands.soulnetwork.usage=/soulnetwork <玩家> <add|subtract|fill|empty|get> [數量]
+commands.soulnetwork.add.success=成功添加 %dLP 到 %s 的靈魂網絡!
+commands.soulnetwork.subtract.success=成功從 %s 的靈魂網絡中減去 %dLP !
+commands.soulnetwork.fill.success=成功填滿 %s 的靈魂網絡!
+commands.soulnetwork.empty.success=成功掏空 %s 的靈魂網絡!
+commands.soulnetwork.get.success=目前有 %dLP 在 %s 的靈魂網絡!
+commands.soulnetwork.noPlayer=沒有指定玩家
+commands.soulnetwork.noCommand=命令不夠詳細
+commands.soulnetwork.notACommand=這不是有效的命令
+
+#Tooltips
+tooltip.activationcrystal.creativeonly=Creative Only - activates any ritual
+tooltip.activationcrystal.lowlevelrituals=Activates low-level rituals
+tooltip.activationcrystal.powerfulrituals=Activates more powerful rituals
+tooltip.airsigil.desc=I feel lighter already...
+tooltip.alchemy.coords=Coords:
+tooltip.alchemy.damage=Damage:
+tooltip.alchemy.dimension=Bound Dimension:
+tooltip.alchemy.direction=Direction:
+tooltip.alchemy.forrecipe=for Recipe
+tooltip.alchemy.press=Press
+tooltip.alchemy.recipe=Recipe:
+tooltip.alchemy.ritualid=RitualID:
+tooltip.alchemy.shift=shift
+tooltip.alchemy.usedinalchemy=Used in Alchemy
+tooltip.alchemyflask.caution=CAUTION: Contents are throwable
+tooltip.alchemyflask.swigsleft=Swigs Left:
+tooltip.armorinhibitor.desc1=Used to suppress a soul's
+tooltip.armorinhibitor.desc2=unnatural abilities.
+tooltip.attunedcrystal.desc1=A tool to tune alchemy
+tooltip.attunedcrystal.desc2=reagent transmission
+tooltip.blankspell.desc=Crystal of infinite possibilities.
+tooltip.bloodframe.desc=Stirs bees into a frenzy.
+tooltip.bloodletterpack.desc=This pack really chaffes...
+tooltip.bloodlightsigil.desc=I see a light!
+tooltip.boundarmor.devprotect=Devilish Protection
+tooltip.boundaxe.desc=Axe me about my puns!
+tooltip.boundpickaxe.desc1=The Souls of the Damned
+tooltip.boundpickaxe.desc2=do not like stone...
+tooltip.boundshovel.desc=No, not that type of spade.
+tooltip.caution.desc1=Caution: may cause
+tooltip.caution.desc2=a bad day...
+tooltip.cheatyitem.desc1=Right-click to fill network,
+tooltip.cheatyitem.desc2=shift-right to empty.
+tooltip.complexspellcrystal.desc=Crystal of unimaginable power
+tooltip.crystalbelljar.contents=Current Contents:
+tooltip.crystalbelljar.empty=- Empty
+tooltip.demonictelepfocus.desc1=A stronger version of the focus,
+tooltip.demonictelepfocus.desc2=using a demonic shard
+tooltip.demonplacer.desc=Used to spawn demons.
+tooltip.destclearer.desc1=Used to clear the destination
+tooltip.destclearer.desc2=list for an alchemy container
+tooltip.diablokey.desc=Binds other items to the owner's network
+tooltip.divinationsigil.desc1=Peer into the soul to
+tooltip.divinationsigil.desc2=get the current essence
+tooltip.energybazooka.desc=Boom.
+tooltip.energybattery.desc=Stores raw Life Essence
+tooltip.energyblast.desc1=Used to fire devastating
+tooltip.energyblast.desc2=projectiles.
+tooltip.enhancedtelepfocus.desc=A focus further enhanced in an altar
+tooltip.fluidsigil.beastmode=Beast Mode
+tooltip.fluidsigil.desc=A sigil with a lovely affinity for fluids
+tooltip.fluidsigil.draintankmode=Drain Tank Mode
+tooltip.fluidsigil.filltankmode=Fill Tank Mode
+tooltip.fluidsigil.fluidplacementmode=Fluid Placement Mode
+tooltip.fluidsigil.forcesyphonmode=Force-syphon Mode
+tooltip.fluidsigil.syphoningmode=Syphoning Mode
+tooltip.harvestsigil.desc=You sow what you reap
+tooltip.infusedstone.desc1=Infused stone inside of
+tooltip.infusedstone.desc2=a blood altar
+tooltip.item.iteminslot=Item in slot
+tooltip.item.currentitem=Current Item:
+tooltip.lavacrystal.desc1=Store life to smelt
+tooltip.lavacrystal.desc2=stuff in the furnace.
+tooltip.lavasigil.desc1=Contact with liquid is
+tooltip.lavasigil.desc2=highly unrecommended.
+tooltip.lp.storedlp=Stored LP:
+tooltip.mode.creative=Creative Only
+tooltip.owner.currentowner=Current Owner:
+tooltip.owner.demonsowner=Demon's Owner:
+tooltip.packratsigil.desc=Hands of Diamonds
+tooltip.reagent.selectedreagent=Currently selected reagent:
+tooltip.reinforcedtelepfocus.desc1=A stronger version of the focus,
+tooltip.reinforcedtelepfocus.desc2=using a weak shard
+tooltip.ritualdiviner.airstones=Air Stones:
+tooltip.ritualdiviner.blankstones=Blank Stones:
+tooltip.ritualdiviner.cannotplace=Can not place Dusk runes
+tooltip.ritualdiviner.canplace=Can place Dusk runes
+tooltip.ritualdiviner.canplacedawn=Can place Dusk and Dawn runes
+tooltip.ritualdiviner.desc=Used to explore new types of rituals
+tooltip.ritualdiviner.duskstones=Dusk Stones:
+tooltip.ritualdiviner.earthstones=Earth Stones:
+tooltip.ritualdiviner.firestones=Fire Stones:
+tooltip.ritualdiviner.moreinfo=Press shift for extended information
+tooltip.ritualdiviner.ritualtunedto=Ritual tuned to face:
+tooltip.ritualdiviner.waterstones=Water Stones:
+tooltip.ritualdiviner.dawnstones=Dawn Stones:
+tooltip.ritualdiviner.totalStones=Total Stones:
+tooltip.sacrificialdagger.desc1=A slight draining feeling tickles your fingers
+tooltip.sacrificialdagger.desc2=Just a prick of the
+tooltip.sacrificialdagger.desc3=finger will suffice...
+tooltip.sanguinearmor.desc1=A pair of goggles imbued with power
+tooltip.sanguinearmor.desc2=Robes imbued with forbidden power
+tooltip.sanguinearmor.visdisc=Vis discount:
+tooltip.scribetool.desc=The writing is on the wall...
+tooltip.seersigil.desc=When seeing all is not enough
+tooltip.sigilofelementalaffinity.desc1=Perfect for a fire-breathing fish
+tooltip.sigilofelementalaffinity.desc2=who is afraid of heights!
+tooltip.sigilofenderseverance.desc=Put those endermen in a Dire situation!
+tooltip.sigilofgrowth.desc1=Who needs a green thumb when
+tooltip.sigilofgrowth.desc2=you have a green slate?
+tooltip.sigilofhaste.desc=One dose of caffeine later...
+tooltip.sigilofholding.desc=Used to hold several Sigils!
+tooltip.sigilofmagnetism.desc=I have a very magnetic personality!
+tooltip.sigilofsupression.desc=Better than telekinesis
+tooltip.sigiloftheassassin.desc=Time to stay stealthy...
+tooltip.sigilofthebridge.desc1=Activate to create a bridge
+tooltip.sigilofthebridge.desc2=beneath your feet.
+tooltip.sigilofthefastminer.desc=Keep going and going and going...
+tooltip.sigilofwind.desc=Best not to wear a skirt.
+tooltip.sigil.state.activated=Activated
+tooltip.sigil.state.deactivated=Deactivated
+tooltip.tanksegmenter.desc1=Used to designate which
+tooltip.tanksegmenter.desc2=reagents can go into a container
+tooltip.telepositionfocus.desc=An Enderpearl imbued with blood
+tooltip.voidsigil.desc=Better than a Swiffer!
+tooltip.watersigil.desc=Infinite water, anyone?
+tooltip.routingFocus.limit=Limit:
+tooltip.routingFocus.desc=A focus used to route items
+tooltip.alchemy.usedinincense=Purifying incense used in a crucible
+
+#Messages
+message.altar.capacity=Capacity: %s LP
+message.altar.consumptionrate=Consumption Rate:
+message.altar.currentessence=Altar's Current Essence: %s LP
+message.altar.currenttier=Altar's Current Tier: %s
+message.altar.progress=Altar's Progress:
+message.altar.inputtank= Input Tank: %s LP
+message.altar.outputtank= Output Tank: %s LP
+message.altar.hunger=[BM] Your high regeneration rate has caused you to become hungry...
+message.attunedcrystal.clearing=Clearing saved container...
+message.attunedcrystal.error.cannotfind=Can no longer find linked container.
+message.attunedcrystal.error.noconnections=Linked container has no connections remaining!
+message.attunedcrystal.error.toofar=Linked container is either too far or is in a different dimension.
+message.attunedcrystal.linked=Container is now linked. Transmitting:
+message.attunedcrystal.linking=Linking to selected container.
+message.attunedcrystal.setto=Attuned Crystal now set to:
+message.demon.shallfollow=I shall follow and protect you!
+message.demon.willstay=I will stay here for now, Master.
+message.destinationclearer.cleared=Destination list now cleared.
+message.divinationsigil.amount=Amount:
+message.divinationsigil.currentessence=Current Essence:
+message.divinationsigil.reagent=Reagent:
+message.masterstone.crystalvibrates=Your crystal vibrates pathetically.
+message.masterstone.energyflows=A rush of energy flows through the ritual!
+message.masterstone.nothinghappened=Nothing appears to have happened...
+message.masterstone.ritualresistyou=The ritual appears to actively resist you!
+message.masterstone.somethingstoppedyou=Something stopped you in your tracks...
+message.masterstone.youfeelapull=You feel a pull, but you are too weak to push any further.
+message.ritual.currentritual=Current Ritual:
+message.ritual.side.east=東
+message.ritual.side.north=北
+message.ritual.side.south=南
+message.ritual.side.west=西
+message.ritualdemonportal.missingjar=A jar on one of the pillars appears to be missing...
+message.tanksegmenter.nowhas=Tank now has
+message.tanksegmenter.setto=Tank Segmenter now set to:
+message.tanksegmenter.tankssetto=tank(s) set to:
+message.routerfocus.limit=Focus' Item Limit set to: 
+
+#Achievements
+achievement.alchemicalwizardry:firstPrick=Your First Prick!
+achievement.alchemicalwizardry:firstPrick.desc=The first drop of life into the Altar...
+achievement.alchemicalwizardry:weakOrb=Faintly Glowing Red...
+achievement.alchemicalwizardry:weakOrb.desc=This orb will suffice...for now...