Adding gitignore

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TEAlchemicCalcinator.java

@@ -0,0 +1,376 @@
+package WayofTime.alchemicalWizardry.common.tileEntity;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+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.minecraftforge.common.util.Constants;
+import net.minecraftforge.common.util.ForgeDirection;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.Reagent;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentContainer;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentRegistry;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentStack;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IBloodOrb;
+import WayofTime.alchemicalWizardry.api.soulNetwork.SoulNetworkHandler;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+
+public class TEAlchemicCalcinator extends TEReagentConduit implements IInventory
+{
+	protected ItemStack[] inv;
+	protected ReagentContainer bufferTank = new ReagentContainer(Reagent.REAGENT_SIZE * 2);
+	
+	protected int bufferTransferRate = 20;
+	
+	private int lpPerTick = 10;
+	private int ticksPerReagent = 200;
+	
+	public int progress;
+	
+	public TEAlchemicCalcinator()
+	{
+		super(1, Reagent.REAGENT_SIZE * 4);
+		this.inv = new ItemStack[2];
+		this.tickRate = 20;
+		this.maxConnextions = 1;
+		this.progress = 0;
+	}
+	
+	@Override
+	public void readFromNBT(NBTTagCompound tag)
+	{
+		super.readFromNBT(tag);
+		bufferTransferRate = tag.getInteger("bufferTransferRate");
+		progress = tag.getInteger("progress");
+		
+		NBTTagCompound bufferTankTag = tag.getCompoundTag("bufferTank");
+		
+		this.bufferTank = ReagentContainer.readFromNBT(bufferTankTag);
+		
+		NBTTagList tagList = tag.getTagList("Inventory",Constants.NBT.TAG_COMPOUND);
+
+        for (int i = 0; i < tagList.tagCount(); i++)
+        {
+            NBTTagCompound savedTag = (NBTTagCompound) tagList.getCompoundTagAt(i);
+            
+            if(savedTag.getBoolean("Empty"))
+            {
+            	inv[i] = null;
+            }else
+            {
+                inv[i] = ItemStack.loadItemStackFromNBT(savedTag);
+            }
+        }
+	}
+	
+	@Override
+	public void writeToNBT(NBTTagCompound tag)
+	{
+		super.writeToNBT(tag);
+		tag.setInteger("bufferTransferRate", bufferTransferRate);
+		tag.setInteger("progress", progress);
+		
+		NBTTagCompound bufferTankTag = new NBTTagCompound();
+		
+		this.bufferTank.writeToNBT(bufferTankTag);
+		
+		tag.setTag("bufferTank", bufferTankTag);
+		
+		NBTTagList itemList = new NBTTagList();
+
+        for (int i = 0; i < inv.length; i++)
+        {
+            ItemStack stack = inv[i];
+            NBTTagCompound savedTag = new NBTTagCompound();
+            
+            if (inv[i] != null)
+            {
+                inv[i].writeToNBT(savedTag);
+            }else
+            {
+            	savedTag.setBoolean("Empty", true);
+            }
+            
+            itemList.appendTag(savedTag);
+        }
+
+        tag.setTag("Inventory", itemList);
+	}
+	
+	@Override
+	public void updateEntity()
+	{
+		super.updateEntity();
+		
+		if(!worldObj.isRemote)
+		{
+			moveBufferToMain();
+			tickProgress();
+		}
+	}
+	
+	public void moveBufferToMain()
+	{
+		ReagentStack amountStack = this.bufferTank.drain(bufferTransferRate, false);
+		int drainAmount = this.fill(ForgeDirection.UNKNOWN, amountStack, false);
+		
+		if(drainAmount > 0)
+		{
+			ReagentStack drainedStack = this.bufferTank.drain(drainAmount, true);
+			this.fill(ForgeDirection.UNKNOWN, drainedStack, true);
+		}
+	}
+	
+	public void tickProgress()
+	{
+		ItemStack reagentItemStack = this.getStackInSlot(1);
+		if(reagentItemStack == null)
+		{
+			progress = 0;
+			return;
+		}
+		
+		ReagentStack possibleReagent = ReagentRegistry.getReagentStackForItem(reagentItemStack);
+		if(possibleReagent == null || !this.canReagentFitBuffer(possibleReagent))
+		{
+			return;
+		}
+		
+		ItemStack orbStack = this.getStackInSlot(0);
+		if(orbStack == null || !(orbStack.getItem() instanceof IBloodOrb))
+		{
+			return;
+		}
+		
+		if(!SoulNetworkHandler.canSyphonFromOnlyNetwork(orbStack, lpPerTick))
+		{
+			SoulNetworkHandler.causeNauseaToPlayer(orbStack);
+			return;
+		}
+		
+		SoulNetworkHandler.syphonFromNetwork(orbStack, lpPerTick);
+		progress++;
+		
+		if (worldObj.getWorldTime() % 4 == 0)
+        {
+            SpellHelper.sendIndexedParticleToAllAround(worldObj, xCoord, yCoord, zCoord, 20, worldObj.provider.dimensionId, 1, xCoord, yCoord, zCoord);
+        }
+		
+		if(progress >= this.ticksPerReagent)
+		{
+			progress = 0;
+			this.bufferTank.fill(possibleReagent, true);
+			this.decrStackSize(1, 1);
+		}
+	}
+	
+	public boolean canReagentFitBuffer(ReagentStack stack)
+	{
+		int amount = this.bufferTank.fill(stack, false);
+
+		return amount >= stack.amount;
+	}
+	
+	@Override
+	public void readClientNBT(NBTTagCompound tag)
+	{
+		super.readClientNBT(tag);
+		
+		NBTTagList tagList = tag.getTagList("reagentTanks", Constants.NBT.TAG_COMPOUND);
+        
+        int size = tagList.tagCount();
+        this.tanks = new ReagentContainer[size];
+        
+        for(int i=0; i<size; i++)
+        {
+        	NBTTagCompound savedTag = tagList.getCompoundTagAt(i);
+        	this.tanks[i] = ReagentContainer.readFromNBT(savedTag);
+        }
+        
+        NBTTagList invTagList = tag.getTagList("Inventory",Constants.NBT.TAG_COMPOUND);
+
+        for (int i = 0; i < invTagList.tagCount(); i++)
+        {
+            NBTTagCompound savedTag = (NBTTagCompound) invTagList.getCompoundTagAt(i);
+            
+            if(savedTag.getBoolean("Empty"))
+            {
+            	inv[i] = null;
+            }else
+            {
+                inv[i] = ItemStack.loadItemStackFromNBT(savedTag);
+            }
+        }
+	}
+	
+	@Override
+	public void writeClientNBT(NBTTagCompound tag)
+	{
+		super.writeClientNBT(tag);
+		
+		NBTTagList tagList = new NBTTagList();
+        
+        for(int i=0; i<this.tanks.length; i++)
+        {
+        	NBTTagCompound savedTag = new NBTTagCompound();
+        	if(this.tanks[i] != null)
+        	{
+        		this.tanks[i].writeToNBT(savedTag);
+        	}
+        	tagList.appendTag(savedTag);
+        }
+        
+        tag.setTag("reagentTanks", tagList);
+        
+        NBTTagList itemList = new NBTTagList();
+
+        for (int i = 0; i < inv.length; i++)
+        {
+            ItemStack stack = inv[i];
+            NBTTagCompound savedTag = new NBTTagCompound();
+            
+            if (inv[i] != null)
+            {
+                inv[i].writeToNBT(savedTag);
+            }else
+            {
+            	savedTag.setBoolean("Empty", true);
+            }
+            
+            itemList.appendTag(savedTag);
+        }
+
+        tag.setTag("Inventory", itemList);
+	}
+	
+	@Override 
+	public Packet getDescriptionPacket() 
+	{ 
+		NBTTagCompound nbttagcompound = new NBTTagCompound(); 
+		writeClientNBT(nbttagcompound); 
+		return new S35PacketUpdateTileEntity(xCoord, yCoord, zCoord, -999, nbttagcompound); 
+	} 
+		 
+	@Override 
+	public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity packet) 
+	{ 
+		super.onDataPacket(net, packet); 
+		readClientNBT(packet.func_148857_g()); 
+	} 
+
+	@Override
+    public int getSizeInventory()
+    {
+        return inv.length;
+    }
+
+    @Override
+    public ItemStack getStackInSlot(int slot)
+    {
+        return inv[slot];
+    }
+
+    @Override
+    public void setInventorySlotContents(int slot, ItemStack stack)
+    {
+        inv[slot] = stack;
+        
+        if (stack != null && stack.stackSize > getInventoryStackLimit())
+        {
+            stack.stackSize = getInventoryStackLimit();
+        }
+        
+        worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+    }
+
+    @Override
+    public ItemStack decrStackSize(int slot, int amt)
+    {
+        ItemStack stack = getStackInSlot(slot);
+
+        if (stack != null)
+        {
+            if (stack.stackSize <= amt)
+            {
+                setInventorySlotContents(slot, null);
+            } else
+            {
+                stack = stack.splitStack(amt);
+
+                if (stack.stackSize == 0)
+                {
+                    setInventorySlotContents(slot, null);
+                }
+            }
+        }
+
+        return stack;
+    }
+
+    @Override
+    public ItemStack getStackInSlotOnClosing(int slot)
+    {
+        ItemStack stack = getStackInSlot(slot);
+
+        if (stack != null)
+        {
+            setInventorySlotContents(slot, null);
+        }
+
+        return stack;
+    }
+
+    @Override
+    public int getInventoryStackLimit()
+    {
+        return 64;
+    }
+
+    @Override
+    public boolean isUseableByPlayer(EntityPlayer player)
+    {
+        return worldObj.getTileEntity(xCoord, yCoord, zCoord) == this && player.getDistanceSq(xCoord + 0.5, yCoord + 0.5, zCoord + 0.5) < 64;
+    }
+
+    @Override
+    public void openInventory()
+    {
+    }
+
+    @Override
+    public void closeInventory()
+    {
+    }
+
+	@Override
+	public String getInventoryName() 
+	{
+		return "AlchemicCalcinator";
+	}
+
+	@Override
+	public boolean hasCustomInventoryName() 
+	{
+		return false;
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int slot, ItemStack itemStack) 
+	{
+		return true;
+	}
+	
+	@Override
+    public int fill(ForgeDirection from, ReagentStack resource, boolean doFill)
+	{
+		if(doFill && !worldObj.isRemote)
+		{
+			worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+		}
+		
+		return super.fill(from, resource, doFill);
+	}
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TEBellJar.java

@@ -0,0 +1,158 @@
+package WayofTime.alchemicalWizardry.common.tileEntity;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraftforge.common.util.Constants;
+import WayofTime.alchemicalWizardry.ModBlocks;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentContainer;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentContainerInfo;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentStack;
+
+public class TEBellJar extends TEReagentConduit 
+{	
+	public TEBellJar()
+	{
+		super(1, 16000);
+		this.maxConnextions = 1;
+		this.affectedByRedstone = false;
+	}
+	
+	public int getRSPowerOutput()
+	{
+		ReagentContainer thisTank = this.tanks[0];
+		if(thisTank != null)
+		{
+			ReagentStack stack = thisTank.getReagent();
+			if(stack != null)
+			{
+				return (15*stack.amount/thisTank.getCapacity());
+			}
+		}
+		return 0;
+	}
+	
+	public static ReagentContainerInfo[] getContainerInfoFromItem(ItemStack stack)
+	{
+		if(stack != null && stack.getItem() instanceof ItemBlock && ModBlocks.blockCrystalBelljar == ((ItemBlock)stack.getItem()).field_150939_a)
+		{
+			NBTTagCompound tag = stack.getTagCompound();
+			if(tag != null)
+			{
+				NBTTagList tagList = tag.getTagList("reagentTanks", Constants.NBT.TAG_COMPOUND);
+		        
+		        int size = tagList.tagCount();
+		        ReagentContainer[] tanks = new ReagentContainer[size];
+		        
+		        ReagentContainerInfo[] infos = new ReagentContainerInfo[size];
+		        
+		        for(int i=0; i<size; i++)
+		        {
+		        	NBTTagCompound savedTag = tagList.getCompoundTagAt(i);
+		        	tanks[i] = ReagentContainer.readFromNBT(savedTag);
+		        	
+		        	if(tanks[i] != null)
+		        	{
+		        		infos[i] = tanks[i].getInfo();
+		        	}
+		        }
+		        
+		        return infos;
+			}
+		}
+		
+		return new ReagentContainerInfo[0];
+	}
+	
+	public void readTankNBTOnPlace(NBTTagCompound tag)
+	{
+		NBTTagList tagList = tag.getTagList("reagentTanks", Constants.NBT.TAG_COMPOUND);
+        
+        int size = tagList.tagCount();
+        this.tanks = new ReagentContainer[size];
+        
+        for(int i=0; i<size; i++)
+        {
+        	NBTTagCompound savedTag = tagList.getCompoundTagAt(i);
+        	this.tanks[i] = ReagentContainer.readFromNBT(savedTag);
+        }
+	}
+	
+	public void writeTankNBT(NBTTagCompound tag)
+	{
+		NBTTagList tagList = new NBTTagList();
+        
+        for(int i=0; i<this.tanks.length; i++)
+        {
+        	NBTTagCompound savedTag = new NBTTagCompound();
+        	if(this.tanks[i] != null)
+        	{
+        		this.tanks[i].writeToNBT(savedTag);
+        	}
+        	tagList.appendTag(savedTag);
+        }
+        
+        tag.setTag("reagentTanks", tagList);
+	}
+	
+//	@Override
+//	public void readClientNBT(NBTTagCompound tag)
+//	{
+//		super.readClientNBT(tag);
+//		
+//		NBTTagList tagList = tag.getTagList("reagentTanks", Constants.NBT.TAG_COMPOUND);
+//        
+//        int size = tagList.tagCount();
+//        this.tanks = new ReagentContainer[size];
+//        
+//        for(int i=0; i<size; i++)
+//        {
+//        	NBTTagCompound savedTag = tagList.getCompoundTagAt(i);
+//        	this.tanks[i] = ReagentContainer.readFromNBT(savedTag);
+//        }
+//	}
+//	
+//	@Override
+//	public void writeClientNBT(NBTTagCompound tag)
+//	{
+//		super.writeClientNBT(tag);
+//		
+//		NBTTagList tagList = new NBTTagList();
+//        
+//        for(int i=0; i<this.tanks.length; i++)
+//        {
+//        	NBTTagCompound savedTag = new NBTTagCompound();
+//        	if(this.tanks[i] != null)
+//        	{
+//        		this.tanks[i].writeToNBT(savedTag);
+//        	}
+//        	tagList.appendTag(savedTag);
+//        }
+//        
+//        tag.setTag("reagentTanks", tagList);
+//	}
+	
+	@Override
+	public void updateEntity()
+	{
+		super.updateEntity();
+		
+		if(hasChanged == 1)
+		{
+			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);
+		}
+	}
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TEConduit.java

@@ -0,0 +1,34 @@
+package WayofTime.alchemicalWizardry.common.tileEntity;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.network.Packet;
+import WayofTime.alchemicalWizardry.common.PacketHandler;
+import WayofTime.alchemicalWizardry.common.spell.complex.SpellParadigm;
+
+public class TEConduit extends TESpellBlock
+{
+    @Override
+    public void readFromNBT(NBTTagCompound par1NBTTagCompound)
+    {
+        super.readFromNBT(par1NBTTagCompound);
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound par1NBTTagCompound)
+    {
+        super.writeToNBT(par1NBTTagCompound);
+    }
+
+    //Logic for the actual block is under here
+    @Override
+    public void updateEntity()
+    {
+
+    }
+
+	@Override
+	protected void applySpellChange(SpellParadigm parad) 
+	{
+		return;		
+	}
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TEHomHeart.java

@@ -0,0 +1,167 @@
+package WayofTime.alchemicalWizardry.common.tileEntity;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.tileentity.TileEntitySkull;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.common.spell.simple.HomSpell;
+import WayofTime.alchemicalWizardry.common.spell.simple.HomSpellRegistry;
+
+public class TEHomHeart extends TileEntity
+{
+    public boolean canCastSpell(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+    {
+        return true;
+    }
+
+    public int castSpell(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+    {
+        HomSpell spell = getSpell();
+
+        if (spell != null)
+        {
+            switch (getModifiedParadigm())
+            {
+                case 0:
+                    spell.onOffensiveRangedRightClick(par1ItemStack, par2World, par3EntityPlayer);
+                    break;
+
+                case 1:
+                    spell.onOffensiveMeleeRightClick(par1ItemStack, par2World, par3EntityPlayer);
+                    break;
+
+                case 2:
+                    spell.onDefensiveRightClick(par1ItemStack, par2World, par3EntityPlayer);
+                    break;
+
+                case 3:
+                    spell.onEnvironmentalRightClick(par1ItemStack, par2World, par3EntityPlayer);
+                    break;
+            }
+
+            //spell.onOffensiveRangedRightClick(par1ItemStack, par2World, par3EntityPlayer);
+        }
+
+        return 0;
+    }
+
+    public HomSpell getSpell()
+    {
+        TileEntity tileEntity = worldObj.getTileEntity(xCoord - 1, yCoord, zCoord);
+
+        if (tileEntity instanceof TEAltar)
+        {
+            ItemStack itemStack = ((TEAltar) tileEntity).getStackInSlot(0);
+
+            if (itemStack != null)
+            {
+                HomSpell spell = HomSpellRegistry.getSpellForItemStack(itemStack);
+
+                if (spell != null)
+                {
+                    return spell;
+                }
+            }
+        }
+
+        tileEntity = worldObj.getTileEntity(xCoord + 1, yCoord, zCoord);
+
+        if (tileEntity instanceof TEAltar)
+        {
+            ItemStack itemStack = ((TEAltar) tileEntity).getStackInSlot(0);
+
+            if (itemStack != null)
+            {
+                HomSpell spell = HomSpellRegistry.getSpellForItemStack(itemStack);
+
+                if (spell != null)
+                {
+                    return spell;
+                }
+            }
+        }
+
+        tileEntity = worldObj.getTileEntity(xCoord, yCoord, zCoord - 1);
+
+        if (tileEntity instanceof TEAltar)
+        {
+            ItemStack itemStack = ((TEAltar) tileEntity).getStackInSlot(0);
+
+            if (itemStack != null)
+            {
+                HomSpell spell = HomSpellRegistry.getSpellForItemStack(itemStack);
+
+                if (spell != null)
+                {
+                    return spell;
+                }
+            }
+        }
+
+        tileEntity = worldObj.getTileEntity(xCoord, yCoord, zCoord + 1);
+
+        if (tileEntity instanceof TEAltar)
+        {
+            ItemStack itemStack = ((TEAltar) tileEntity).getStackInSlot(0);
+
+            if (itemStack != null)
+            {
+                HomSpell spell = HomSpellRegistry.getSpellForItemStack(itemStack);
+
+                if (spell != null)
+                {
+                    return spell;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    public int getModifiedParadigm()
+    {
+        //TODO change so that it works with a Tile Entity for a custom head or whatnot
+        Block block = worldObj.getBlock(xCoord, yCoord + 1, zCoord);
+
+        if (block == Blocks.glowstone)
+        {
+            return 0;
+        } else if (block == Blocks.redstone_block)
+        {
+            return 1;
+        } else if (block == Blocks.anvil)
+        {
+            return 2;
+        } else if (block == Blocks.glass)
+        {
+            return 3;
+        }
+
+        TileEntity tileEntity = worldObj.getTileEntity(xCoord, yCoord + 1, zCoord);
+
+        if (tileEntity instanceof TileEntitySkull)
+        {
+            int skullType = ((TileEntitySkull) tileEntity).func_145904_a();
+
+            switch (skullType)
+            {
+                case 0:
+                    return 0;
+
+                case 1:
+                    return 1;
+
+                case 2:
+                    return 2;
+
+                case 4:
+                    return 3;
+            }
+        }
+
+        return -1;
+    }
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TEImperfectRitualStone.java

@@ -0,0 +1,11 @@
+package WayofTime.alchemicalWizardry.common.tileEntity;
+
+import net.minecraft.tileentity.TileEntity;
+
+public class TEImperfectRitualStone extends TileEntity
+{
+    public TEImperfectRitualStone()
+    {
+        // TODO Auto-generated constructor stub
+    }
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TEMasterStone.java

@@ -0,0 +1,638 @@
+package WayofTime.alchemicalWizardry.common.tileEntity;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import net.minecraft.entity.player.EntityPlayer;
+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.server.MinecraftServer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.Constants;
+import net.minecraftforge.common.util.ForgeDirection;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.Reagent;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentContainer;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentContainerInfo;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentRegistry;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentStack;
+import WayofTime.alchemicalWizardry.api.rituals.IMasterRitualStone;
+import WayofTime.alchemicalWizardry.api.rituals.Rituals;
+import WayofTime.alchemicalWizardry.api.soulNetwork.LifeEssenceNetwork;
+import WayofTime.alchemicalWizardry.common.NewPacketHandler;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+
+public class TEMasterStone extends TileEntity implements IMasterRitualStone
+{
+    private String currentRitualString;
+    private boolean isActive;
+    private String owner;
+    private String varString1;
+    private int cooldown;
+    private int var1;
+    private int direction;
+    public boolean isRunning;
+    public int runningTime;
+    
+    private NBTTagCompound customRitualTag;
+    
+    protected ReagentContainer[] tanks;
+    protected Map<Reagent, Integer> attunedTankMap;
+
+    public TEMasterStone()
+    {
+    	tanks = new ReagentContainer[]{new ReagentContainer(1000),new ReagentContainer(1000),new ReagentContainer(1000)};
+    	this.attunedTankMap = new HashMap();
+    	
+        isActive = false;
+        owner = "";
+        cooldown = 0;
+        var1 = 0;
+        direction = 0;
+        varString1 = "";
+        currentRitualString = "";
+        isRunning = false;
+        runningTime = 0;
+        
+        this.customRitualTag = new NBTTagCompound();
+    }
+
+    public void readClientNBT(NBTTagCompound tag)
+    {
+    	currentRitualString = tag.getString("currentRitualString");
+        isRunning = tag.getBoolean("isRunning");
+        runningTime = tag.getInteger("runningTime");
+        
+        NBTTagList tagList = tag.getTagList("reagentTanks", Constants.NBT.TAG_COMPOUND);
+
+        int size = tagList.tagCount();
+        this.tanks = new ReagentContainer[size];
+        
+        for(int i=0; i<size; i++)
+        {
+        	NBTTagCompound savedTag = tagList.getCompoundTagAt(i);
+        	this.tanks[i] = ReagentContainer.readFromNBT(savedTag);
+        }
+    }
+    
+    public void writeClientNBT(NBTTagCompound tag)
+    {
+    	tag.setString("currentRitualString", currentRitualString);
+        tag.setBoolean("isRunning", isRunning);
+        tag.setInteger("runningTime",runningTime);
+        
+        NBTTagList tagList = new NBTTagList();
+        
+        for(int i=0; i<this.tanks.length; i++)
+        {
+        	NBTTagCompound savedTag = new NBTTagCompound();
+        	if(this.tanks[i] != null)
+        	{
+        		this.tanks[i].writeToNBT(savedTag);
+        	}
+        	tagList.appendTag(savedTag);
+        }
+        
+        tag.setTag("reagentTanks", tagList);
+    }
+    
+    @Override
+    public void readFromNBT(NBTTagCompound tag)
+    {
+        super.readFromNBT(tag);
+        isActive = tag.getBoolean("isActive");
+        owner = tag.getString("owner");
+        cooldown = tag.getInteger("cooldown");
+        var1 = tag.getInteger("var1");
+        direction = tag.getInteger("direction");
+        currentRitualString = tag.getString("currentRitualString");
+        isRunning = tag.getBoolean("isRunning");
+        runningTime = tag.getInteger("runningTime");
+        
+        NBTTagList tagList = tag.getTagList("reagentTanks", Constants.NBT.TAG_COMPOUND);
+
+        int size = tagList.tagCount();
+        this.tanks = new ReagentContainer[size];
+        
+        for(int i=0; i<size; i++)
+        {
+        	NBTTagCompound savedTag = tagList.getCompoundTagAt(i);
+        	this.tanks[i] = ReagentContainer.readFromNBT(savedTag);
+        }
+        
+        NBTTagList attunedTagList = tag.getTagList("attunedTankMap", Constants.NBT.TAG_COMPOUND);
+        
+        for(int i=0; i<attunedTagList.tagCount(); i++)
+        {
+        	NBTTagCompound savedTag = attunedTagList.getCompoundTagAt(i);
+        	Reagent reagent = ReagentRegistry.getReagentForKey(savedTag.getString("reagent"));
+        	this.attunedTankMap.put(reagent, savedTag.getInteger("amount"));
+        }
+        
+        customRitualTag = tag.getCompoundTag("customRitualTag");
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound tag)
+    {
+        super.writeToNBT(tag);
+        tag.setBoolean("isActive", isActive);
+        tag.setString("owner", owner);
+        tag.setInteger("cooldown", cooldown);
+        tag.setInteger("var1", var1);
+        tag.setInteger("direction", direction);
+        tag.setString("currentRitualString", currentRitualString);
+        tag.setBoolean("isRunning", isRunning);
+        tag.setInteger("runningTime",runningTime);
+        
+        NBTTagList tagList = new NBTTagList();
+        
+        for(int i=0; i<this.tanks.length; i++)
+        {
+        	NBTTagCompound savedTag = new NBTTagCompound();
+        	if(this.tanks[i] != null)
+        	{
+        		this.tanks[i].writeToNBT(savedTag);
+        	}
+        	tagList.appendTag(savedTag);
+        }
+        
+        tag.setTag("reagentTanks", tagList);
+        
+        NBTTagList attunedTagList = new NBTTagList();
+        
+        for(Entry<Reagent, Integer> entry : this.attunedTankMap.entrySet())
+        {
+        	NBTTagCompound savedTag = new NBTTagCompound();
+        	savedTag.setString("reagent", ReagentRegistry.getKeyForReagent(entry.getKey()));
+        	savedTag.setInteger("amount", entry.getValue());
+        	attunedTagList.appendTag(savedTag);
+        }
+        
+        tag.setTag("attunedTankMap", attunedTagList);
+        
+        tag.setTag("customRitualTag", customRitualTag);
+    }
+
+    public void activateRitual(World world, int crystalLevel, EntityPlayer player)
+    {
+    	if (world.isRemote)
+        {
+            return;
+        }
+    	
+        String testRitual = Rituals.checkValidRitual(world, xCoord, yCoord, zCoord);
+
+        if (testRitual.equals(""))
+        {
+        	player.addChatMessage(new ChatComponentText("Nothing appears to have happened..."));
+            return;
+        }
+
+        boolean testLevel = Rituals.canCrystalActivate(testRitual, crystalLevel);
+
+        if (!testLevel)
+        {
+        	player.addChatMessage(new ChatComponentText("Your crystal vibrates pathetically."));
+
+            return;
+        }
+
+        World worldSave = MinecraftServer.getServer().worldServers[0];
+        LifeEssenceNetwork data = (LifeEssenceNetwork) worldSave.loadItemData(LifeEssenceNetwork.class, owner);
+
+        if (data == null)
+        {
+            data = new LifeEssenceNetwork(owner);
+            worldSave.setItemData(owner, data);
+        }
+
+        int currentEssence = data.currentEssence;
+
+        if (currentEssence < Rituals.getCostForActivation(testRitual))
+        {
+        	player.addChatMessage(new ChatComponentText("You feel a pull, but you are too weak to push any further."));
+
+            return;
+        }
+
+        if (!world.isRemote)
+        {
+        	if(!Rituals.startRitual(this, testRitual, player))
+        	{
+        		player.addChatMessage(new ChatComponentText("The ritual appears to actively resist you!"));
+        		
+        		return;
+        	}else
+        	{
+        		data.currentEssence = currentEssence - Rituals.getCostForActivation(testRitual);
+                data.markDirty();
+                
+            	player.addChatMessage(new ChatComponentText("A rush of energy flows through the ritual!"));
+
+                for (int i = 0; i < 12; i++)
+                {
+                    SpellHelper.sendIndexedParticleToAllAround(world, xCoord, yCoord, zCoord, 20, worldObj.provider.dimensionId, 1, xCoord, yCoord, zCoord);
+                }
+        	}   
+        }
+
+        cooldown = Rituals.getInitialCooldown(testRitual);
+        var1 = 0;
+        currentRitualString = testRitual;
+        isActive = true;
+        isRunning = true;
+        direction = Rituals.getDirectionOfRitual(world, xCoord, yCoord, zCoord, testRitual);
+        worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+    }
+
+    public void setOwner(String owner)
+    {
+        this.owner = owner;
+    }
+
+    public void useOnRitualBroken()
+    {
+    	Rituals.onRitualBroken(this, this.currentRitualString);
+    }
+    
+    @Override
+    public void updateEntity()
+    {
+    	if(isRunning && runningTime < 100)
+    	{
+    		runningTime++;
+    	}else if(!isRunning && runningTime > 0)
+    	{
+    		runningTime--;
+    	}
+    	
+        if (!isActive)
+        {
+            return;
+        }
+
+        int worldTime = (int) (worldObj.getWorldTime() % 24000);
+
+        if (worldObj.isRemote)
+        {
+            return;
+        }
+
+        if (worldTime % 100 == 0)
+        {
+            boolean testRunes = Rituals.checkDirectionOfRitualValid(worldObj, xCoord, yCoord, zCoord, currentRitualString, direction);
+            SpellHelper.sendIndexedParticleToAllAround(worldObj, xCoord, yCoord, zCoord, 20, worldObj.provider.dimensionId, 1, xCoord, yCoord, zCoord);
+
+            if (!testRunes)
+            {
+            	Rituals.onRitualBroken(this, currentRitualString);
+                isActive = false;
+                currentRitualString = "";
+                worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+                return;
+            }
+        }
+
+        if (worldObj.getBlockPowerInput(xCoord, yCoord, zCoord) > 0)
+        {
+        	if(isRunning)
+        	{
+        		isRunning = false;
+        		worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+        	}
+            return;
+        }else
+        {
+        	if(!isRunning)
+        	{
+        		isRunning = true;
+        		worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+        	}
+        }
+
+        performRitual(worldObj, xCoord, yCoord, zCoord, currentRitualString);
+    }
+
+    public void performRitual(World world, int x, int y, int z, String currentRitualString2)
+    {
+        Rituals.performEffect(this, currentRitualString2);
+    }
+
+    public String getOwner()
+    {
+        return owner;
+    }
+
+    public void setCooldown(int newCooldown)
+    {
+        this.cooldown = newCooldown;
+    }
+
+    public int getCooldown()
+    {
+        return this.cooldown;
+    }
+
+    public void setVar1(int newVar1)
+    {
+        this.var1 = newVar1;
+    }
+
+    public int getVar1()
+    {
+        return this.var1;
+    }
+
+    public void setActive(boolean active)
+    {
+        this.isActive = active;
+        this.isRunning = active;
+        worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+    }
+
+    public int getDirection()
+    {
+        return this.direction;
+    }
+
+	@Override
+	public World getWorld() 
+	{
+		return this.getWorldObj();
+	}
+
+	@Override
+	public int getXCoord() 
+	{
+		return xCoord;
+	}
+
+	@Override
+	public int getYCoord() 
+	{
+		return yCoord;
+	}
+
+	@Override
+	public int getZCoord() 
+	{
+		return zCoord;
+	}
+	
+	public String getCurrentRitual()
+	{
+		return this.currentRitualString;
+	}
+	
+	public void setCurrentRitual(String str)
+	{
+		this.currentRitualString = str;
+	}
+	
+//	@Override
+//    public Packet getDescriptionPacket()
+//    {
+//        return NewPacketHandler.getPacket(this);
+//    }
+	
+	@Override 
+	public Packet getDescriptionPacket() 
+	{ 
+		NBTTagCompound nbttagcompound = new NBTTagCompound(); 
+		writeClientNBT(nbttagcompound); 
+		return new S35PacketUpdateTileEntity(xCoord, yCoord, zCoord, -999, nbttagcompound); 
+	} 
+		 
+	@Override 
+	public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity packet) 
+	{ 
+		super.onDataPacket(net, packet); 
+		readClientNBT(packet.func_148857_g()); 
+	} 
+	
+	public AxisAlignedBB getRenderBoundingBox()
+	{
+		double renderExtention = 1.0d;
+		AxisAlignedBB bb = AxisAlignedBB. getBoundingBox(xCoord-renderExtention, yCoord-renderExtention, zCoord-renderExtention, xCoord+1+renderExtention, yCoord+1+renderExtention, zCoord+1+renderExtention);
+		return bb;
+	}
+	
+	/* ISegmentedReagentHandler */
+    @Override
+    public int fill(ForgeDirection from, ReagentStack resource, boolean doFill)
+    {
+    	if(doFill)
+    	{
+    		worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+    	}
+    	
+    	int totalFill = 0;
+    	
+    	boolean useTankLimit = !this.attunedTankMap.isEmpty();
+    	
+    	if(resource != null)
+    	{
+        	int totalTanksFillable = useTankLimit ? this.getTanksTunedToReagent(resource.reagent) : this.tanks.length;
+        	int tanksFilled = 0;
+
+    		int maxFill = resource.amount;
+    		
+    		for(int i=this.tanks.length-1; i>=0; i--)
+    		{
+    			ReagentStack remainingStack = resource.copy();
+    			remainingStack.amount = maxFill - totalFill;
+    			
+    			boolean doesReagentMatch = tanks[i].getReagent() == null ? false : tanks[i].getReagent().isReagentEqual(remainingStack);
+    			
+    			if(doesReagentMatch)
+    			{
+    				totalFill += tanks[i].fill(remainingStack, doFill);
+    				tanksFilled++;
+    			}else
+    			{
+    				continue;
+    			}
+    			
+    			if(totalFill >= maxFill || tanksFilled >= totalTanksFillable)
+    			{
+    				return totalFill;
+    			}
+    		}
+    		
+    		if(tanksFilled >= totalTanksFillable)
+    		{
+    			return totalFill;
+    		}
+    		
+    		for(int i=this.tanks.length-1; i>=0; i--)
+    		{
+    			ReagentStack remainingStack = resource.copy();
+    			remainingStack.amount = maxFill - totalFill;
+    			
+    			boolean isTankEmpty = tanks[i].getReagent() == null;
+    			
+    			if(isTankEmpty)
+    			{
+    				totalFill += tanks[i].fill(remainingStack, doFill);
+    				tanksFilled++;
+    			}else
+    			{
+    				continue;
+    			}
+    			
+    			if(totalFill >= maxFill || tanksFilled >= totalTanksFillable)
+    			{
+    				return totalFill;
+    			}
+    		}
+    	}
+        return totalFill;
+    }
+
+    @Override
+    public ReagentStack drain(ForgeDirection from, ReagentStack resource, boolean doDrain)
+    {
+    	if(resource == null)
+    	{
+    		return null;
+    	}
+    	
+    	if(doDrain)
+    	{
+    		worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+    	}
+    	
+    	int maxDrain = resource.amount;
+    	Reagent reagent = resource.reagent;
+    	int drained = 0;
+    	
+    	for(int i=0; i<tanks.length; i++)
+    	{
+    		if(drained >= maxDrain)
+    		{
+    			break;
+    		}
+    		
+    		if (resource.isReagentEqual(tanks[i].getReagent()))
+            {
+    			ReagentStack drainStack = tanks[i].drain(maxDrain-drained, doDrain);
+    			if(drainStack != null)
+    			{
+                    drained += drainStack.amount;
+    			}
+            }
+    	}
+        
+        return new ReagentStack(reagent, drained);
+    }
+
+    /* Only returns the amount from the first available tank */
+    @Override
+    public ReagentStack drain(ForgeDirection from, int maxDrain, boolean doDrain)
+    {
+    	for(int i=0; i<tanks.length; i++)
+    	{
+    		ReagentStack stack = tanks[i].drain(maxDrain, doDrain);
+    		if(stack != null)
+    		{
+    			if(doDrain)
+    	    	{
+    	    		worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+    	    	}
+    			
+    			return stack;
+    		}
+    	}
+    	
+    	return null;
+    }
+
+    @Override
+    public boolean canFill(ForgeDirection from, Reagent reagent)
+    {
+        return true;
+    }
+
+    @Override
+    public boolean canDrain(ForgeDirection from, Reagent reagent)
+    {
+        return true;
+    }
+
+    @Override
+    public ReagentContainerInfo[] getContainerInfo(ForgeDirection from)
+    {
+    	ReagentContainerInfo[] info = new ReagentContainerInfo[this.getNumberOfTanks()];
+    	for(int i=0; i<this.getNumberOfTanks(); i++)
+    	{
+    		info[i] = tanks[i].getInfo();
+    	}
+        return info;
+    }
+
+	@Override
+	public int getNumberOfTanks() 
+	{
+		return tanks.length;
+	}
+
+	@Override
+	public int getTanksTunedToReagent(Reagent reagent) 
+	{
+		if(this.attunedTankMap.containsKey(reagent) && this.attunedTankMap.get(reagent) != null)
+		{
+			return this.attunedTankMap.get(reagent);
+		}
+		return 0;
+	}
+
+	@Override
+	public void setTanksTunedToReagent(Reagent reagent, int total) 
+	{
+		if(total == 0 && this.attunedTankMap.containsKey(reagent))
+		{
+			this.attunedTankMap.remove(reagent);
+			return;
+		}
+		
+		this.attunedTankMap.put(reagent, new Integer(total));
+	}
+
+	@Override
+	public Map<Reagent, Integer> getAttunedTankMap()
+	{
+		return this.attunedTankMap;
+	}
+	
+	public boolean areTanksEmpty()
+	{
+		for(int i=0; i<this.tanks.length; i++)
+		{
+			if(tanks[i] != null && tanks[i].getReagent() != null)
+			{
+				return false;
+			}
+		}
+		
+		return true;
+	}
+
+	@Override
+	public NBTTagCompound getCustomRitualTag() 
+	{
+		return this.customRitualTag;
+	}
+
+	@Override
+	public void setCustomRitualTag(NBTTagCompound tag) 
+	{
+		this.customRitualTag = tag;
+	}
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TEOrientable.java

@@ -0,0 +1,109 @@
+package WayofTime.alchemicalWizardry.common.tileEntity;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.network.Packet;
+import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.ForgeDirection;
+import WayofTime.alchemicalWizardry.common.NewPacketHandler;
+import WayofTime.alchemicalWizardry.common.block.IOrientable;
+
+public class TEOrientable extends TileEntity implements IOrientable
+{
+    protected ForgeDirection inputFace;
+    protected ForgeDirection outputFace;
+
+    public TEOrientable()
+    {
+        this.inputFace = ForgeDirection.DOWN;
+        this.outputFace = ForgeDirection.UP;
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound par1NBTTagCompound)
+    {
+        super.readFromNBT(par1NBTTagCompound);
+        this.setInputDirection(ForgeDirection.getOrientation(par1NBTTagCompound.getInteger("inputFace")));
+        this.setOutputDirection(ForgeDirection.getOrientation(par1NBTTagCompound.getInteger("outputFace")));
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound par1NBTTagCompound)
+    {
+        super.writeToNBT(par1NBTTagCompound);
+        par1NBTTagCompound.setInteger("inputFace", TEOrientable.getIntForForgeDirection(this.getInputDirection()));
+        par1NBTTagCompound.setInteger("outputFace", TEOrientable.getIntForForgeDirection(this.getOutputDirection()));
+    }
+
+    @Override
+    public ForgeDirection getInputDirection()
+    {
+        return this.inputFace;
+    }
+
+    @Override
+    public ForgeDirection getOutputDirection()
+    {
+        return this.outputFace;
+    }
+
+    @Override
+    public void setInputDirection(ForgeDirection direction)
+    {
+        this.inputFace = direction;
+    }
+
+    @Override
+    public void setOutputDirection(ForgeDirection direction)
+    {
+        this.outputFace = direction;
+    }
+
+    public static int getIntForForgeDirection(ForgeDirection direction)
+    {
+        switch (direction)
+        {
+            case DOWN:
+                return 0;
+
+            case UP:
+                return 1;
+
+            case NORTH:
+                return 2;
+
+            case SOUTH:
+                return 3;
+
+            case WEST:
+                return 4;
+
+            case EAST:
+                return 5;
+
+            default:
+                return 0;
+        }
+    }
+    
+    @Override
+    public Packet getDescriptionPacket()
+    {
+    	return NewPacketHandler.getPacket(this);
+    }
+
+    
+    public boolean isSideRendered(ForgeDirection side)
+    {
+    	if(side.equals(this.getInputDirection()) || side.equals(this.getOutputDirection()))
+    	{
+    		return true;
+    	}
+    	return false;
+    }
+    
+    public String getResourceLocationForMeta(int meta)
+    {
+    	return "";
+    }
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TEPedestal.java

@@ -0,0 +1,268 @@
+package WayofTime.alchemicalWizardry.common.tileEntity;
+
+import net.minecraft.entity.effect.EntityLightningBolt;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.network.Packet;
+import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.Constants;
+import WayofTime.alchemicalWizardry.common.NewPacketHandler;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+
+public class TEPedestal extends TileEntity implements IInventory
+{
+    private ItemStack[] inv;
+    private int resultID;
+    private int resultDamage;
+    public static final int sizeInv = 1;
+
+    private boolean isActive;
+
+    public TEPedestal()
+    {
+        this.inv = new ItemStack[1];
+        resultID = 0;
+        resultDamage = 0;
+        isActive = false;
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound par1NBTTagCompound)
+    {
+        super.readFromNBT(par1NBTTagCompound);
+        NBTTagList tagList = par1NBTTagCompound.getTagList("Inventory", Constants.NBT.TAG_COMPOUND);
+
+        for (int i = 0; i < tagList.tagCount(); i++)
+        {
+            NBTTagCompound tag = (NBTTagCompound) tagList.getCompoundTagAt(i);
+            int slot = tag.getByte("Slot");
+
+            if (slot >= 0 && slot < inv.length)
+            {
+                inv[slot] = ItemStack.loadItemStackFromNBT(tag);
+            }
+        }
+
+        resultID = par1NBTTagCompound.getInteger("resultID");
+        resultDamage = par1NBTTagCompound.getInteger("resultDamage");
+        isActive = par1NBTTagCompound.getBoolean("isActive");
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound par1NBTTagCompound)
+    {
+        super.writeToNBT(par1NBTTagCompound);
+        NBTTagList itemList = new NBTTagList();
+
+        for (int i = 0; i < inv.length; i++)
+        {
+            ItemStack stack = inv[i];
+
+            if (inv[i] != null)
+            {
+                NBTTagCompound tag = new NBTTagCompound();
+                tag.setByte("Slot", (byte) i);
+                inv[i].writeToNBT(tag);
+                itemList.appendTag(tag);
+            }
+        }
+
+        par1NBTTagCompound.setInteger("resultID", resultID);
+        par1NBTTagCompound.setInteger("resultDamage", resultDamage);
+        par1NBTTagCompound.setTag("Inventory", itemList);
+        par1NBTTagCompound.setBoolean("isActive", isActive);
+    }
+
+    @Override
+    public int getSizeInventory()
+    {
+        return 1;
+    }
+
+    @Override
+    public ItemStack getStackInSlot(int slot)
+    {
+        return inv[slot];
+    }
+
+    @Override
+    public ItemStack decrStackSize(int slot, int amt)
+    {
+        ItemStack stack = getStackInSlot(slot);
+
+        if (stack != null)
+        {
+            if (stack.stackSize <= amt)
+            {
+                setInventorySlotContents(slot, null);
+            } else
+            {
+                stack = stack.splitStack(amt);
+
+                if (stack.stackSize == 0)
+                {
+                    setInventorySlotContents(slot, null);
+                }
+            }
+        }
+
+        return stack;
+    }
+
+    @Override
+    public ItemStack getStackInSlotOnClosing(int slot)
+    {
+        ItemStack stack = getStackInSlot(slot);
+
+        if (stack != null)
+        {
+            setInventorySlotContents(slot, null);
+        }
+
+        return stack;
+    }
+
+    @Override
+    public void setInventorySlotContents(int slot, ItemStack itemStack)
+    {
+        inv[slot] = itemStack;
+
+        if (itemStack != null && itemStack.stackSize > getInventoryStackLimit())
+        {
+            itemStack.stackSize = getInventoryStackLimit();
+        }
+    }
+
+    @Override
+    public String getInventoryName()
+    {
+        return "TEPedestal";
+    }
+
+    @Override
+    public boolean hasCustomInventoryName()
+    {
+        return false;
+    }
+
+    @Override
+    public int getInventoryStackLimit()
+    {
+        return 1;
+    }
+
+    @Override
+    public boolean isUseableByPlayer(EntityPlayer entityPlayer)
+    {
+        return worldObj.getTileEntity(xCoord, yCoord, zCoord) == this && entityPlayer.getDistanceSq(xCoord + 0.5, yCoord + 0.5, zCoord + 0.5) < 64;
+    }
+
+    @Override
+    public void openInventory()
+    {
+        // TODO Auto-generated method stub
+    }
+
+    @Override
+    public void closeInventory()
+    {
+        // TODO Auto-generated method stub
+    }
+
+    //Logic for the actual block is under here
+    @Override
+    public void updateEntity()
+    {
+        super.updateEntity();
+    }
+
+    public void setActive()
+    {
+        isActive = false;
+    }
+
+    public boolean isActive()
+    {
+        return isActive;
+    }
+
+    @Override
+    public Packet getDescriptionPacket()
+    {
+        return NewPacketHandler.getPacket(this);
+    }
+
+    public void handlePacketData(int[] intData)
+    {
+        if (intData == null)
+        {
+            return;
+        }
+
+        if (intData.length == 3)
+        {
+            for (int i = 0; i < 1; i++)
+            {
+                if (intData[i * 3 + 2] != 0)
+                {
+                    ItemStack is = new ItemStack(Item.getItemById(intData[i * 3]), intData[i * 3 + 2], intData[i * 3 + 1]);
+                    inv[i] = is;
+                } else
+                {
+                    inv[i] = null;
+                }
+            }
+        }
+    }
+
+    public int[] buildIntDataList()
+    {
+        int[] sortList = new int[1 * 3];
+        int pos = 0;
+
+        for (ItemStack is : inv)
+        {
+            if (is != null)
+            {
+                sortList[pos++] = Item.getIdFromItem(is.getItem());
+                sortList[pos++] = is.getItemDamage();
+                sortList[pos++] = is.stackSize;
+            } else
+            {
+                sortList[pos++] = 0;
+                sortList[pos++] = 0;
+                sortList[pos++] = 0;
+            }
+        }
+
+        return sortList;
+    }
+
+    @Override
+    public boolean isItemValidForSlot(int slot, ItemStack itemstack)
+    {
+        if (slot == 0)
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    public void onItemDeletion()
+    {
+        //worldObj.createExplosion(null, xCoord+0.5, yCoord+0.5, zCoord+0.5, 1, false);
+        worldObj.addWeatherEffect(new EntityLightningBolt(worldObj, xCoord, yCoord, zCoord));
+
+        for (int i = 0; i < 16; i++)
+        {
+            SpellHelper.sendIndexedParticleToAllAround(worldObj, xCoord, yCoord, zCoord, 20, worldObj.provider.dimensionId, 2, xCoord, yCoord, zCoord);
+        }
+    }
+
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TEPlinth.java

@@ -0,0 +1,694 @@
+package WayofTime.alchemicalWizardry.common.tileEntity;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.network.Packet;
+import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.Constants;
+import net.minecraftforge.oredict.OreDictionary;
+import WayofTime.alchemicalWizardry.api.summoningRegistry.SummoningRegistry;
+import WayofTime.alchemicalWizardry.api.summoningRegistry.SummoningRegistryComponent;
+import WayofTime.alchemicalWizardry.common.IDemon;
+import WayofTime.alchemicalWizardry.common.NewPacketHandler;
+import WayofTime.alchemicalWizardry.common.PlinthComponent;
+import WayofTime.alchemicalWizardry.common.items.EnergyBattery;
+
+public class TEPlinth extends TileEntity implements IInventory
+{
+    private ItemStack[] inv;
+
+    private boolean isActive;
+    private boolean paradigm;
+
+    private ItemStack[] ring1Inv;
+    private ItemStack[] ring2Inv;
+    private ItemStack[] ring3Inv;
+    
+    public static final int sizeInv = 1;
+
+    private int progressInterval;
+    private int progress;
+
+    public static List<PlinthComponent> pedestalPositions = new ArrayList();
+
+    public TEPlinth()
+    {
+        this.inv = new ItemStack[1];
+        this.ring1Inv = new ItemStack[6];
+        this.ring2Inv = new ItemStack[6];
+        this.ring3Inv = new ItemStack[6];
+        isActive = false;
+        progress = 0;
+        progressInterval = 50;
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound par1NBTTagCompound)
+    {
+        super.readFromNBT(par1NBTTagCompound);
+        NBTTagList tagList = par1NBTTagCompound.getTagList("Inventory",Constants.NBT.TAG_COMPOUND);
+
+        for (int i = 0; i < tagList.tagCount(); i++)
+        {
+            NBTTagCompound tag = (NBTTagCompound) tagList.getCompoundTagAt(i);
+            int slot = tag.getByte("Slot");
+
+            if (slot >= 0 && slot < inv.length)
+            {
+                inv[slot] = ItemStack.loadItemStackFromNBT(tag);
+            }
+        }
+
+        NBTTagList ring1TagList = par1NBTTagCompound.getTagList("ring1Inv",Constants.NBT.TAG_COMPOUND);
+
+        for (int i = 0; i < ring1TagList.tagCount(); i++)
+        {
+            NBTTagCompound tag = (NBTTagCompound) ring1TagList.getCompoundTagAt(i);
+            int slot = tag.getByte("Slot");
+
+            if (slot >= 0 && slot < inv.length)
+            {
+                ring1Inv[slot] = ItemStack.loadItemStackFromNBT(tag);
+            }
+        }
+
+        NBTTagList ring2TagList = par1NBTTagCompound.getTagList("ring2Inv",Constants.NBT.TAG_COMPOUND);
+
+        for (int i = 0; i < ring2TagList.tagCount(); i++)
+        {
+            NBTTagCompound tag = (NBTTagCompound) ring2TagList.getCompoundTagAt(i);
+            int slot = tag.getByte("Slot");
+
+            if (slot >= 0 && slot < inv.length)
+            {
+                ring2Inv[slot] = ItemStack.loadItemStackFromNBT(tag);
+            }
+        }
+
+        NBTTagList ring3TagList = par1NBTTagCompound.getTagList("ring3Inv",Constants.NBT.TAG_COMPOUND);
+
+        for (int i = 0; i < ring3TagList.tagCount(); i++)
+        {
+            NBTTagCompound tag = (NBTTagCompound) ring3TagList.getCompoundTagAt(i);
+            int slot = tag.getByte("Slot");
+
+            if (slot >= 0 && slot < inv.length)
+            {
+                ring3Inv[slot] = ItemStack.loadItemStackFromNBT(tag);
+            }
+        }
+
+        progress = par1NBTTagCompound.getInteger("progress");
+        progressInterval = par1NBTTagCompound.getInteger("progressInterval");
+        isActive = par1NBTTagCompound.getBoolean("isActive");
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound par1NBTTagCompound)
+    {
+        super.writeToNBT(par1NBTTagCompound);
+        NBTTagList itemList = new NBTTagList();
+
+        for (int i = 0; i < inv.length; i++)
+        {
+            ItemStack stack = inv[i];
+
+            if (inv[i] != null)
+            {
+                NBTTagCompound tag = new NBTTagCompound();
+                tag.setByte("Slot", (byte) i);
+                inv[i].writeToNBT(tag);
+                itemList.appendTag(tag);
+            }
+        }
+
+        par1NBTTagCompound.setTag("Inventory", itemList);
+        NBTTagList ring1ItemList = new NBTTagList();
+
+        for (int i = 0; i < ring1Inv.length; i++)
+        {
+            ItemStack stack = ring1Inv[i];
+
+            if (ring1Inv[i] != null)
+            {
+                NBTTagCompound tag = new NBTTagCompound();
+                tag.setByte("Slot", (byte) i);
+                ring1Inv[i].writeToNBT(tag);
+                ring1ItemList.appendTag(tag);
+            }
+        }
+
+        par1NBTTagCompound.setTag("ring1Inv", ring1ItemList);
+        NBTTagList ring2ItemList = new NBTTagList();
+
+        for (int i = 0; i < ring2Inv.length; i++)
+        {
+            ItemStack stack = ring2Inv[i];
+
+            if (ring2Inv[i] != null)
+            {
+                NBTTagCompound tag = new NBTTagCompound();
+                tag.setByte("Slot", (byte) i);
+                ring2Inv[i].writeToNBT(tag);
+                ring2ItemList.appendTag(tag);
+            }
+        }
+
+        par1NBTTagCompound.setTag("ring2Inv", ring1ItemList);
+        NBTTagList ring3ItemList = new NBTTagList();
+
+        for (int i = 0; i < ring3Inv.length; i++)
+        {
+            ItemStack stack = ring3Inv[i];
+
+            if (ring3Inv[i] != null)
+            {
+                NBTTagCompound tag = new NBTTagCompound();
+                tag.setByte("Slot", (byte) i);
+                ring3Inv[i].writeToNBT(tag);
+                ring3ItemList.appendTag(tag);
+            }
+        }
+
+        par1NBTTagCompound.setTag("ring3Inv", ring1ItemList);
+        par1NBTTagCompound.setInteger("progress", progress);
+        par1NBTTagCompound.setInteger("progressInterval", progressInterval);
+        par1NBTTagCompound.setBoolean("isActive", isActive);
+    }
+
+    @Override
+    public int getSizeInventory()
+    {
+        return 1;
+    }
+
+    @Override
+    public ItemStack getStackInSlot(int slot)
+    {
+        return inv[slot];
+    }
+
+    @Override
+    public ItemStack decrStackSize(int slot, int amt)
+    {
+        ItemStack stack = getStackInSlot(slot);
+
+        if (stack != null)
+        {
+            if (stack.stackSize <= amt)
+            {
+                setInventorySlotContents(slot, null);
+            } else
+            {
+                stack = stack.splitStack(amt);
+
+                if (stack.stackSize == 0)
+                {
+                    setInventorySlotContents(slot, null);
+                }
+            }
+        }
+
+        return stack;
+    }
+
+    @Override
+    public ItemStack getStackInSlotOnClosing(int slot)
+    {
+        ItemStack stack = getStackInSlot(slot);
+
+        if (stack != null)
+        {
+            setInventorySlotContents(slot, null);
+        }
+
+        return stack;
+    }
+
+    @Override
+    public void setInventorySlotContents(int slot, ItemStack itemStack)
+    {
+        inv[slot] = itemStack;
+
+        if (itemStack != null && itemStack.stackSize > getInventoryStackLimit())
+        {
+            itemStack.stackSize = getInventoryStackLimit();
+        }
+    }
+
+    @Override
+    public String getInventoryName()
+    {
+        return "TEPlinth";
+    }
+
+    @Override
+    public boolean hasCustomInventoryName()
+    {
+        return false;
+    }
+
+    @Override
+    public int getInventoryStackLimit()
+    {
+        return 1;
+    }
+
+    @Override
+    public boolean isUseableByPlayer(EntityPlayer entityPlayer)
+    {
+        return worldObj.getTileEntity(xCoord, yCoord, zCoord) == this && entityPlayer.getDistanceSq(xCoord + 0.5, yCoord + 0.5, zCoord + 0.5) < 64;
+    }
+
+    @Override
+    public void openInventory()
+    {
+        // TODO Auto-generated method stub
+    }
+
+    @Override
+    public void closeInventory()
+    {
+        // TODO Auto-generated method stub
+    }
+
+    //Logic for the actual block is under here
+    @Override
+    public void updateEntity()
+    {
+        super.updateEntity();
+
+        if (worldObj.isRemote)
+        {
+            return;
+        }
+
+        if (!isActive())
+        {
+            if (getStackInSlot(0) != null && getStackInSlot(0).getItem() instanceof EnergyBattery)
+            {
+                int bloodOrbLevel = ((EnergyBattery) getStackInSlot(0).getItem()).getOrbLevel();
+
+                if (SummoningRegistry.isRecipeValid(bloodOrbLevel, composeItemsForRingAndParadigm(1, true), composeItemsForRingAndParadigm(2, true), composeItemsForRingAndParadigm(3, true)))
+                {
+                    SummoningRegistryComponent src = SummoningRegistry.getRegistryComponent(bloodOrbLevel, composeItemsForRingAndParadigm(1, true), composeItemsForRingAndParadigm(2, true), composeItemsForRingAndParadigm(3, true));
+                    isActive = true;
+                    paradigm = true;
+                    progress = 0;
+                    ring1Inv = src.getRingRecipeForRing(1);
+                    ring2Inv = src.getRingRecipeForRing(2);
+                    ring3Inv = src.getRingRecipeForRing(3);
+                } else if (SummoningRegistry.isRecipeValid(bloodOrbLevel, composeItemsForRingAndParadigm(1, false), composeItemsForRingAndParadigm(2, false), composeItemsForRingAndParadigm(3, false)))
+                {
+                    SummoningRegistryComponent src = SummoningRegistry.getRegistryComponent(bloodOrbLevel, composeItemsForRingAndParadigm(1, false), composeItemsForRingAndParadigm(2, false), composeItemsForRingAndParadigm(3, false));
+                    isActive = true;
+                    paradigm = false;
+                    progress = 0;
+                    ring1Inv = src.getRingRecipeForRing(1);
+                    ring2Inv = src.getRingRecipeForRing(2);
+                    ring3Inv = src.getRingRecipeForRing(3);
+                } else
+                {
+                    isActive = false;
+                    progress = 0;
+                }
+            }
+        } else
+        {
+            if (getStackInSlot(0) != null && getStackInSlot(0).getItem() instanceof EnergyBattery)
+            {
+                if (progress % progressInterval == 0)
+                {
+                    int ring = (progress / progressInterval) / 6 + 1;
+                    int slot = (progress / progressInterval) % 6;
+                    ItemStack itemStack;
+
+                    switch (ring)
+                    {
+                        case 1:
+                            itemStack = this.ring1Inv[slot];
+                            break;
+
+                        case 2:
+                            itemStack = this.ring2Inv[slot];
+                            break;
+
+                        case 3:
+                            itemStack = this.ring3Inv[slot];
+                            break;
+
+                        default:
+                            itemStack = null;
+                    }
+
+                    if (itemStack == null)
+                    {
+                        progress += progressInterval;
+                    } else
+                    {
+                        if (this.deleteItemStackInRing(ring, itemStack))
+                        {
+                            progress++;
+                        }
+                    }
+                } else
+                {
+                    progress++;
+                }
+
+                if (progress >= progressInterval * 18)
+                {
+                    int bloodOrbLevel = ((EnergyBattery) getStackInSlot(0).getItem()).getOrbLevel();
+                    EntityLivingBase entity = SummoningRegistry.getEntity(worldObj, bloodOrbLevel, ring1Inv, ring2Inv, ring3Inv);
+                    //EntityLivingBase entity = new EntityFallenAngel(worldObj);
+
+                    if (entity != null)
+                    {
+                        //entity.worldObj = worldObj;
+                        entity.setPosition(xCoord + 0.5, yCoord + 1, zCoord + 0.5);
+                        worldObj.spawnEntityInWorld(entity);
+
+                        if (entity instanceof IDemon)
+                        {
+                            ((IDemon) entity).setSummonedConditions();
+                        }
+
+                        worldObj.createExplosion(entity, entity.posX, entity.posY, entity.posZ, 3, false);
+                        deleteItemsInRing(1);
+                        isActive = false;
+                        progress = 0;
+
+                        if (worldObj != null)
+                        {
+                            worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    public void deleteItemsInRing(int ring)
+    {
+        if (paradigm)
+        {
+            int i = 0;
+
+            for (PlinthComponent pc : pedestalPositions)
+            {
+                if (i < 6 && pc.getRing() == ring)
+                {
+                    TileEntity tileEntity = worldObj.getTileEntity(xCoord + pc.xOffset, yCoord + pc.yOffset, zCoord + pc.zOffset);
+
+                    if (tileEntity instanceof TEPedestal)
+                    {
+                        ((TEPedestal) tileEntity).setInventorySlotContents(0, null);
+                        worldObj.markBlockForUpdate(xCoord + pc.xOffset, yCoord + pc.yOffset, zCoord + pc.zOffset);
+                        i++;
+                    }
+                }
+            }
+        } else
+        {
+            int i = 0;
+
+            for (PlinthComponent pc : pedestalPositions)
+            {
+                if (i < 6 && pc.getRing() == ring)
+                {
+                    TileEntity tileEntity = worldObj.getTileEntity(xCoord + pc.zOffset, yCoord + pc.yOffset, zCoord + pc.xOffset);
+
+                    if (tileEntity instanceof TEPedestal)
+                    {
+                        ((TEPedestal) tileEntity).setInventorySlotContents(0, null);
+                        worldObj.markBlockForUpdate(xCoord + pc.zOffset, yCoord + pc.yOffset, zCoord + pc.xOffset);
+                        i++;
+                    }
+                }
+            }
+        }
+    }
+
+    public boolean deleteItemStackInRing(int ring, ItemStack itemStack)
+    {
+        if (itemStack == null)
+        {
+            return true;
+        }
+
+        if (paradigm)
+        {
+            int i = 0;
+
+            for (PlinthComponent pc : pedestalPositions)
+            {
+                if (i < 6 && pc.getRing() == ring)
+                {
+                    TileEntity tileEntity = worldObj.getTileEntity(xCoord + pc.xOffset, yCoord + pc.yOffset, zCoord + pc.zOffset);
+
+                    if (tileEntity instanceof TEPedestal)
+                    {
+                        ItemStack possibleItem = ((TEPedestal) tileEntity).getStackInSlot(0);
+
+                        if (possibleItem == null)
+                        {
+                            i++;
+                            continue;
+                        }
+
+                        boolean test = false;
+
+                        if (possibleItem.getItem() instanceof ItemBlock)
+                        {
+                            if (itemStack.getItem() instanceof ItemBlock)
+                            {
+                                test = true;
+                            }
+                        } else if (!(itemStack.getItem() instanceof ItemBlock))
+                        {
+                            test = true;
+                        }
+
+                        if (test)
+                        {
+                            if (itemStack.getItem()== possibleItem.getItem() && (itemStack.getItemDamage() == possibleItem.getItemDamage() || itemStack.getItemDamage() == OreDictionary.WILDCARD_VALUE))
+                            {
+                                ((TEPedestal) tileEntity).decrStackSize(0, 1);
+                                if(((TEPedestal) tileEntity).getStackInSlot(0) !=null && ((TEPedestal) tileEntity).getStackInSlot(0).stackSize==0)
+                                {
+                                	((TEPedestal) tileEntity).setInventorySlotContents(0, null);
+                                }
+                                ((TEPedestal) tileEntity).onItemDeletion();
+                                worldObj.markBlockForUpdate(xCoord + pc.xOffset, yCoord + pc.yOffset, zCoord + pc.zOffset);
+                                return true;
+                            }
+                        }
+
+                        i++;
+                    }
+                }
+            }
+        } else
+        {
+            int i = 0;
+
+            for (PlinthComponent pc : pedestalPositions)
+            {
+                if (i < 6 && pc.getRing() == ring)
+                {
+                    TileEntity tileEntity = worldObj.getTileEntity(xCoord + pc.zOffset, yCoord + pc.yOffset, zCoord + pc.xOffset);
+
+                    if (tileEntity instanceof TEPedestal)
+                    {
+                        ItemStack possibleItem = ((TEPedestal) tileEntity).getStackInSlot(0);
+
+                        if (possibleItem == null)
+                        {
+                            i++;
+                            continue;
+                        }
+
+                        boolean test = false;
+
+                        if (possibleItem.getItem() instanceof ItemBlock)
+                        {
+                            if (itemStack.getItem() instanceof ItemBlock)
+                            {
+                                test = true;
+                            }
+                        } else if (!(itemStack.getItem() instanceof ItemBlock))
+                        {
+                            test = true;
+                        }
+
+                        if (test)
+                        {
+                            if (itemStack.getItem() == possibleItem.getItem() && (itemStack.getItemDamage() == possibleItem.getItemDamage() || itemStack.getItemDamage() == OreDictionary.WILDCARD_VALUE))
+                            {
+                                ((TEPedestal) tileEntity).decrStackSize(0, 1);
+                                ((TEPedestal) tileEntity).onItemDeletion();
+                                //worldObj.markBlockForUpdate(xCoord + pc.xOffset, yCoord + pc.yOffset, zCoord + pc.zOffset);
+                                worldObj.markBlockForUpdate(xCoord + pc.zOffset, yCoord + pc.yOffset, zCoord + pc.zOffset);
+                                return true;
+                            }
+                        }
+
+                        i++;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+
+    public ItemStack[] composeItemsForRingAndParadigm(int ring, boolean paradigm)
+    {
+        ItemStack[] composed = new ItemStack[6];
+
+        if (paradigm)
+        {
+            int i = 0;
+
+            for (PlinthComponent pc : pedestalPositions)
+            {
+                if (i < 6 && pc.getRing() == ring)
+                {
+                    TileEntity tileEntity = worldObj.getTileEntity(xCoord + pc.xOffset, yCoord + pc.yOffset, zCoord + pc.zOffset);
+
+                    if (tileEntity instanceof TEPedestal)
+                    {
+                        composed[i] = ((TEPedestal) tileEntity).getStackInSlot(0);
+                        i++;
+                    }
+                }
+            }
+        } else
+        {
+            int i = 0;
+
+            for (PlinthComponent pc : pedestalPositions)
+            {
+                if (i < 6 && pc.getRing() == ring)
+                {
+                    TileEntity tileEntity = worldObj.getTileEntity(xCoord + pc.zOffset, yCoord + pc.yOffset, zCoord + pc.xOffset);
+
+                    if (tileEntity instanceof TEPedestal)
+                    {
+                        composed[i] = ((TEPedestal) tileEntity).getStackInSlot(0);
+                        i++;
+                    }
+                }
+            }
+        }
+
+        return composed;
+    }
+
+    public void setActive()
+    {
+        isActive = false;
+    }
+
+    public boolean isActive()
+    {
+        return isActive;
+    }
+
+    @Override
+    public Packet getDescriptionPacket()
+    {
+        return NewPacketHandler.getPacket(this);
+    }
+
+    public void handlePacketData(int[] intData)
+    {
+        if (intData == null)
+        {
+            return;
+        }
+
+        if (intData.length == 3)
+        {
+            for (int i = 0; i < 1; i++)
+            {
+                if (intData[i * 3 + 2] != 0)
+                {
+                    ItemStack is = new ItemStack(Item.getItemById(intData[i * 3]), intData[i * 3 + 2], intData[i * 3 + 1]);
+                    inv[i] = is;
+                } else
+                {
+                    inv[i] = null;
+                }
+            }
+        }
+    }
+
+    public int[] buildIntDataList()
+    {
+        int[] sortList = new int[1 * 3];
+        int pos = 0;
+
+        for (ItemStack is : inv)
+        {
+            if (is != null)
+            {
+                sortList[pos++] = Item.getIdFromItem(is.getItem());
+                sortList[pos++] = is.getItemDamage();
+                sortList[pos++] = is.stackSize;
+            } else
+            {
+                sortList[pos++] = 0;
+                sortList[pos++] = 0;
+                sortList[pos++] = 0;
+            }
+        }
+
+        return sortList;
+    }
+
+    @Override
+    public boolean isItemValidForSlot(int slot, ItemStack itemstack)
+    {
+        if (slot == 0)
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    public static void initialize()
+    {
+        pedestalPositions.add(new PlinthComponent(1, 0, -2, 1));
+        pedestalPositions.add(new PlinthComponent(2, 0, 0, 1));
+        pedestalPositions.add(new PlinthComponent(1, 0, +2, 1));
+        pedestalPositions.add(new PlinthComponent(-1, 0, -2, 1));
+        pedestalPositions.add(new PlinthComponent(-2, 0, 0, 1));
+        pedestalPositions.add(new PlinthComponent(-1, 0, +2, 1));
+        pedestalPositions.add(new PlinthComponent(3, 1, -5, 2));
+        pedestalPositions.add(new PlinthComponent(6, 1, 0, 2));
+        pedestalPositions.add(new PlinthComponent(3, 1, +5, 2));
+        pedestalPositions.add(new PlinthComponent(-3, 1, -5, 2));
+        pedestalPositions.add(new PlinthComponent(-6, 1, 0, 2));
+        pedestalPositions.add(new PlinthComponent(-3, 1, +5, 2));
+        pedestalPositions.add(new PlinthComponent(0, 2, -9, 3));
+        pedestalPositions.add(new PlinthComponent(7, 2, -4, 3));
+        pedestalPositions.add(new PlinthComponent(7, 2, +4, 3));
+        pedestalPositions.add(new PlinthComponent(0, 2, +9, 3));
+        pedestalPositions.add(new PlinthComponent(-7, 2, -4, 3));
+        pedestalPositions.add(new PlinthComponent(-7, 2, 4, 3));
+    }
+
+
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TEReagentConduit.java

@@ -0,0 +1,544 @@
+package WayofTime.alchemicalWizardry.common.tileEntity;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.entity.player.EntityPlayer;
+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.tileentity.TileEntity;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.Constants;
+import net.minecraftforge.common.util.ForgeDirection;
+import WayofTime.alchemicalWizardry.api.ColourAndCoords;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.IReagentHandler;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.Reagent;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentContainer;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentRegistry;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentStack;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.TileSegmentedReagentHandler;
+import WayofTime.alchemicalWizardry.common.Int3;
+import WayofTime.alchemicalWizardry.common.entity.projectile.EntityParticleBeam;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class TEReagentConduit extends TileSegmentedReagentHandler
+{
+	public List<ColourAndCoords> destinationList; //These are offsets
+	public Map<Reagent, List<Int3>> reagentTargetList;
+	public Map<Reagent, Integer> reagentTankDesignationList;
+	public int tickRate = 20; //Rate that the reagents are sent
+	
+	int hasChanged = 0;
+	public boolean affectedByRedstone = true;
+	
+	public int maxConnextions = 5;
+	
+	public int renderCount = 0;
+	
+	public TEReagentConduit()
+	{
+		this(2, 2000);
+	}
+	
+	public TEReagentConduit(int numberOfTanks, int size) 
+	{
+		super(numberOfTanks, size);
+		
+		destinationList = new LinkedList();
+		reagentTargetList = new HashMap();
+		reagentTankDesignationList = new HashMap();
+	}
+	
+	public Int3 getColour()
+	{
+		int[] redMap = new int[this.tanks.length];
+		int[] greenMap = new int[this.tanks.length];
+		int[] blueMap = new int[this.tanks.length];
+		
+		for(int i=0; i<this.tanks.length; i++)
+		{
+			ReagentContainer container = this.tanks[i];
+			if(container != null && container.getReagent() != null)
+			{
+				Reagent reagent = container.getReagent().reagent;
+				
+				redMap[i] = reagent.getColourRed();
+				greenMap[i] = reagent.getColourGreen();
+				blueMap[i] = reagent.getColourBlue();
+			}
+		}
+		
+		int red = 0;
+		int green = 0;
+		int blue = 0;
+		
+		for(int i=0; i<this.tanks.length; i++)
+		{
+			red += redMap[i];
+			green += greenMap[i];
+			blue += blueMap[i];
+		}
+		
+		red /= this.tanks.length;
+		green /= this.tanks.length;
+		blue /= this.tanks.length;
+		
+		return new Int3(red, green, blue);
+	}
+
+	@Override
+	public void writeToNBT(NBTTagCompound tag)
+	{
+		super.writeToNBT(tag);
+		
+		tag.setInteger("hasChanged", hasChanged);
+		
+		NBTTagList tagList = new NBTTagList();
+		
+		for(int i=0; i<destinationList.size(); i++)
+		{
+			NBTTagCompound savedTag = new NBTTagCompound();
+			tagList.appendTag(destinationList.get(i).writeToNBT(savedTag));
+		}
+		
+		tag.setTag("destinationList", tagList);
+		
+		NBTTagList reagentTagList = new NBTTagList(); //TODO
+		
+		for(Entry<Reagent, List<Int3>> entry : reagentTargetList.entrySet())
+		{
+			NBTTagCompound savedTag = new NBTTagCompound();
+			savedTag.setString("reagent", ReagentRegistry.getKeyForReagent(entry.getKey()));
+			
+			NBTTagList coordinateTagList = new NBTTagList();
+			
+			for(Int3 coord : entry.getValue())
+			{
+				NBTTagCompound coordinateTag = new NBTTagCompound();
+				
+				coord.writeToNBT(coordinateTag);
+				
+				coordinateTagList.appendTag(coordinateTag);
+			}
+			
+			savedTag.setTag("coordinateList", coordinateTagList);
+			
+			reagentTagList.appendTag(savedTag);
+		}
+		
+		tag.setTag("reagentTargetList", reagentTagList);
+
+		NBTTagList tankDesignationList = new NBTTagList();
+		
+		for(Entry<Reagent, Integer> entry : this.reagentTankDesignationList.entrySet())
+		{
+			NBTTagCompound savedTag = new NBTTagCompound();
+			
+			savedTag.setString("reagent", ReagentRegistry.getKeyForReagent(entry.getKey()));
+			savedTag.setInteger("integer", entry.getValue());
+			
+			tankDesignationList.appendTag(savedTag);
+		}
+		
+		tag.setTag("tankDesignationList", tankDesignationList);
+		
+	}
+	
+	@Override
+	public void readFromNBT(NBTTagCompound tag)
+	{
+		super.readFromNBT(tag);
+		
+		hasChanged = tag.getInteger("hasChanged");
+		
+		NBTTagList tagList = tag.getTagList("destinationList", Constants.NBT.TAG_COMPOUND);
+		
+		destinationList = new LinkedList();
+		
+		for(int i=0; i<tagList.tagCount(); i++)
+		{
+			NBTTagCompound savedTag = tagList.getCompoundTagAt(i);
+			
+			destinationList.add(ColourAndCoords.readFromNBT(savedTag));
+		}
+		
+		reagentTargetList = new HashMap();
+		
+		NBTTagList reagentTagList = tag.getTagList("reagentTargetList", Constants.NBT.TAG_COMPOUND);
+		
+		for(int i=0; i<reagentTagList.tagCount(); i++)
+		{
+			NBTTagCompound savedTag = reagentTagList.getCompoundTagAt(i);
+			
+			Reagent reagent = ReagentRegistry.getReagentForKey(savedTag.getString("reagent"));
+			
+			List<Int3> coordList = new LinkedList();
+			
+			NBTTagList coordinateList = savedTag.getTagList("coordinateList", Constants.NBT.TAG_COMPOUND);
+			
+			for(int j=0; j<coordinateList.tagCount(); j++)
+			{
+				coordList.add(Int3.readFromNBT(coordinateList.getCompoundTagAt(j)));
+			}
+			
+			reagentTargetList.put(reagent, coordList);
+		}
+		
+		reagentTankDesignationList = new HashMap();
+		
+		NBTTagList tankDesignationList = tag.getTagList("tankDesignationList", Constants.NBT.TAG_COMPOUND);
+		
+		for(int i=0; i<tankDesignationList.tagCount(); i++)
+		{
+			NBTTagCompound savedTag = tankDesignationList.getCompoundTagAt(i);
+			
+			this.reagentTankDesignationList.put(ReagentRegistry.getReagentForKey(savedTag.getString("reagent")), new Integer(savedTag.getInteger("integer")));
+		}
+	}
+	
+	public void readClientNBT(NBTTagCompound tag)
+	{
+		NBTTagList tagList = tag.getTagList("destinationList", Constants.NBT.TAG_COMPOUND);
+		
+		destinationList = new LinkedList();
+		
+		for(int i=0; i<tagList.tagCount(); i++)
+		{
+			NBTTagCompound savedTag = tagList.getCompoundTagAt(i);
+			
+			destinationList.add(ColourAndCoords.readFromNBT(savedTag));
+		}
+		
+		NBTTagList reagentTagList = tag.getTagList("reagentTanks", Constants.NBT.TAG_COMPOUND);
+        
+        int size = reagentTagList.tagCount();
+        this.tanks = new ReagentContainer[size];
+        
+        for(int i=0; i<size; i++)
+        {
+        	NBTTagCompound savedTag = reagentTagList.getCompoundTagAt(i);
+        	this.tanks[i] = ReagentContainer.readFromNBT(savedTag);
+        }
+	}
+	
+	public void writeClientNBT(NBTTagCompound tag)
+	{
+		NBTTagList tagList = new NBTTagList();
+		
+		for(int i=0; i<destinationList.size(); i++)
+		{
+			NBTTagCompound savedTag = new NBTTagCompound();
+			tagList.appendTag(destinationList.get(i).writeToNBT(savedTag));
+		}
+		
+		tag.setTag("destinationList", tagList);
+		
+		NBTTagList reagentTagList = new NBTTagList();
+        
+        for(int i=0; i<this.tanks.length; i++)
+        {
+        	NBTTagCompound savedTag = new NBTTagCompound();
+        	if(this.tanks[i] != null)
+        	{
+        		this.tanks[i].writeToNBT(savedTag);
+        	}
+        	reagentTagList.appendTag(savedTag);
+        }
+        
+        tag.setTag("reagentTanks", reagentTagList);
+	}
+	
+	@Override
+	public void updateEntity()
+	{
+		if(!worldObj.isRemote)
+		{
+			if(hasChanged > 1)
+			{
+				hasChanged = 1;
+			}else if(hasChanged == 1)
+			{
+				hasChanged = 0;
+			}
+			
+			if(worldObj.getWorldTime() % 100 == 99)
+			{
+				this.updateColourList();
+			}
+			
+			if(affectedByRedstone && worldObj.isBlockIndirectlyGettingPowered(xCoord, yCoord, zCoord))
+			{
+				return;
+			}
+			
+			int totalTransfered = 0;
+			
+			for(Entry<Reagent, List<Int3>> entry : this.reagentTargetList.entrySet())
+			{
+				for(Int3 coord : entry.getValue())
+				{
+					if(totalTransfered >= this.tickRate)
+					{
+						break;
+					}
+					
+					ReagentStack maxDrainAmount = this.drain(ForgeDirection.UNKNOWN, new ReagentStack(entry.getKey(), this.tickRate - totalTransfered), false);
+					
+					if(maxDrainAmount == null)
+					{
+						continue;
+					}
+					
+					int amountLeft = maxDrainAmount.amount;
+									
+					if(amountLeft <= 0)
+					{
+						continue;
+					}
+					
+					int x = xCoord + coord.xCoord;
+					int y = yCoord + coord.yCoord;
+					int z = zCoord + coord.zCoord;
+					
+					TileEntity tile = worldObj.getTileEntity(x, y, z);
+					if(tile instanceof IReagentHandler)
+					{
+						int amount = Math.min(((IReagentHandler) tile).fill(ForgeDirection.UNKNOWN, maxDrainAmount, false), amountLeft);
+						if(amount > 0)
+						{
+							amountLeft -= amount;
+							totalTransfered += amount;
+														
+							ReagentStack stack = this.drain(ForgeDirection.UNKNOWN, new ReagentStack(entry.getKey(), amount), true);
+							((IReagentHandler) tile).fill(ForgeDirection.UNKNOWN, stack, true);
+						}
+					}
+				}
+			}
+		}else
+		{
+			if(affectedByRedstone && worldObj.isBlockIndirectlyGettingPowered(xCoord, yCoord, zCoord))
+			{
+				return;
+			}
+			
+			renderCount++;
+			
+			if(worldObj.getWorldTime() % 100 != 0)
+			{
+				return;
+			}			
+			
+			this.sendPlayerStuffs();
+		}
+	}
+	
+	
+	@SideOnly(Side.CLIENT)
+	public void sendPlayerStuffs()
+	{
+		Minecraft mc = Minecraft.getMinecraft();
+		EntityPlayer player = mc.thePlayer;
+    	World world = mc.theWorld;
+    	if(SpellHelper.canPlayerSeeAlchemy(player))
+		{
+			for(ColourAndCoords colourSet : this.destinationList)
+			{
+				if(!(worldObj.getTileEntity(xCoord + colourSet.xCoord, yCoord + colourSet.yCoord, zCoord + colourSet.zCoord) instanceof IReagentHandler))
+				{
+					continue;
+				}
+				EntityParticleBeam beam = new EntityParticleBeam(worldObj, xCoord + 0.5, yCoord + 0.5, zCoord + 0.5);
+				double velocity = Math.sqrt(Math.pow(colourSet.xCoord, 2) + Math.pow(colourSet.yCoord, 2) + Math.pow(colourSet.zCoord, 2));
+				double wantedVel = 0.3d;
+				beam.setVelocity(wantedVel*colourSet.xCoord/velocity, wantedVel*colourSet.yCoord/velocity, wantedVel*colourSet.zCoord/velocity);
+				beam.setColour(colourSet.colourRed / 255f, colourSet.colourGreen/255f, colourSet.colourBlue/255f);
+				beam.setDestination(xCoord + colourSet.xCoord, yCoord + colourSet.yCoord, zCoord + colourSet.zCoord);
+				worldObj.spawnEntityInWorld(beam);
+			}
+		}
+	}
+	
+	public void updateColourList()
+	{
+		if(worldObj.isRemote)
+		{
+			return;
+		}
+		
+		List<ColourAndCoords> newList = this.compileListForReagentTargets(this.reagentTargetList);
+		
+		if(newList != null && !newList.equals(destinationList))
+		{
+			this.destinationList = newList;
+			worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+		}
+	}
+	
+	public List<ColourAndCoords> compileListForReagentTargets(Map<Reagent, List<Int3>> map)
+	{
+		List<ColourAndCoords> list = new LinkedList();
+		
+		for(Entry<Reagent, List<Int3>> entry : map.entrySet())
+		{
+			if(entry.getValue() != null)
+			{
+				Reagent reagent = entry.getKey();
+				if(reagent == null)
+				{
+					continue;
+				}
+				List<Int3> coords = entry.getValue();
+				for(Int3 coord : coords)
+				{
+					if(coord == null)
+					{
+						continue;
+					}
+					list.add(new ColourAndCoords(reagent.getColourRed(), reagent.getColourGreen(), reagent.getColourBlue(), reagent.getColourIntensity(), coord.xCoord, coord.yCoord, coord.zCoord));
+				}
+			}
+		}
+		
+		return list;
+	}
+	
+	public boolean addDestinationViaOffset(int red, int green, int blue, int intensity, int xOffset, int yOffset, int zOffset)
+	{
+		if(xOffset == 0 && yOffset == 0 && zOffset == 0)
+		{
+			return false;
+		}
+		
+		this.destinationList.add(new ColourAndCoords(red, green, blue, intensity, xOffset, yOffset, zOffset));
+		
+		return true;
+	}
+	
+	public boolean addDestinationViaActual(int red, int green, int blue, int intensity, int x, int y, int z)
+	{
+		return this.addDestinationViaOffset(red, green, blue, intensity, x - this.xCoord, y - this.yCoord, z - this.zCoord);
+	}
+	
+	@Override 
+	public Packet getDescriptionPacket() 
+	{
+		NBTTagCompound nbttagcompound = new NBTTagCompound(); 
+		writeClientNBT(nbttagcompound); 
+		return new S35PacketUpdateTileEntity(xCoord, yCoord, zCoord, 90210, nbttagcompound); 
+	} 
+		 
+	@Override 
+	public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity packet) 
+	{ 
+		super.onDataPacket(net, packet); 
+		readClientNBT(packet.func_148857_g()); 
+	} 
+	
+	public boolean addReagentDestinationViaOffset(Reagent reagent, int xOffset, int yOffset, int zOffset)
+	{
+		int totalConnections = 0;
+		
+		for(Entry<Reagent, List<Int3>> entry : this.reagentTargetList.entrySet())
+		{
+			if(entry.getValue() != null)
+			{
+				totalConnections += entry.getValue().size();
+			}
+		}
+		
+		if(totalConnections >= this.maxConnextions)
+		{
+			//Send message that it cannot be done? Maybe add a Player instance
+			return false;
+		}
+		
+		if(xOffset == 0 && yOffset == 0 && zOffset == 0)
+		{
+			return false;
+		}
+		
+		Int3 newCoord = new Int3(xOffset, yOffset, zOffset);
+		
+		if(this.reagentTargetList.containsKey(reagent))
+		{
+			List<Int3> coordList = this.reagentTargetList.get(reagent);
+			if(coordList == null)
+			{
+				List<Int3> newCoordList = new LinkedList();
+				newCoordList.add(newCoord);
+				this.reagentTargetList.put(reagent, newCoordList);
+			}else
+			{
+				coordList.add(newCoord);
+			}
+			
+			return true;		
+		}else
+		{
+			List<Int3> newCoordList = new LinkedList();
+			newCoordList.add(newCoord);
+			this.reagentTargetList.put(reagent, newCoordList);
+			
+			return true;
+		}
+	}
+	
+	public boolean addReagentDestinationViaActual(Reagent reagent, int x, int y, int z)
+	{
+		return (this.addReagentDestinationViaOffset(reagent, x-xCoord, y-yCoord, z-zCoord));
+	}
+	
+	public boolean removeReagentDestinationViaOffset(Reagent reagent, int xOffset, int yOffset, int zOffset)
+	{
+		if(this.reagentTargetList.containsKey(reagent))
+		{
+			List<Int3> coords = this.reagentTargetList.get(reagent);
+			if(coords != null)
+			{
+				Int3 reference = new Int3(xOffset, yOffset, zOffset);
+				
+				return coords.remove(reference);
+			}
+		}
+		return false;
+	}
+	
+	public boolean removeReagentDestinationViaActual(Reagent reagent, int x, int y, int z)
+	{
+		return this.removeReagentDestinationViaOffset(reagent, x-xCoord, y-yCoord, z-zCoord);
+	}
+	
+	@Override
+    public int fill(ForgeDirection from, ReagentStack resource, boolean doFill)
+	{
+		if(doFill && !worldObj.isRemote)
+		{
+			worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+			hasChanged = 2;
+		}
+		
+		return super.fill(from, resource, doFill);
+	}
+	
+	@Override
+    public ReagentStack drain(ForgeDirection from, ReagentStack resource, boolean doDrain)
+	{
+		if(doDrain && !worldObj.isRemote)
+		{
+			worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+			hasChanged = 2;
+		}
+		
+		return super.drain(from, resource, doDrain);
+	}
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TESchematicSaver.java

@@ -0,0 +1,158 @@
+package WayofTime.alchemicalWizardry.common.tileEntity;
+
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Writer;
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.tileentity.TileEntity;
+import WayofTime.alchemicalWizardry.ModBlocks;
+import WayofTime.alchemicalWizardry.common.demonVillage.BuildingSchematic;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+public class TESchematicSaver extends TileEntity
+{
+	public Block targetBlock = ModBlocks.largeBloodStoneBrick;
+	
+	public void rightClickBlock(EntityPlayer player, int side)
+	{
+		BuildingSchematic schematic = new BuildingSchematic();
+
+		int negX = this.getNegXLimit();
+		int negY = this.getNegYLimit();
+		int negZ = this.getNegZLimit();
+		int posX = this.getPosXLimit();
+		int posY = this.getPosYLimit();
+		int posZ = this.getPosZLimit();
+		
+		for(int i=-negX+1; i<=posX-1; i++)
+		{
+			for(int j=-negY+1; j<=posY-1; j++)
+			{
+				for(int k=-negZ+1; k<=posZ-1; k++)
+				{
+					int meta = worldObj.getBlockMetadata(xCoord + i, yCoord + j, zCoord + k);
+					Block block = worldObj.getBlock(xCoord + i, yCoord + j, zCoord + k);
+					
+					if(!block.isAir(worldObj, xCoord + i, yCoord + j, zCoord + k))
+					{
+						schematic.addBlockWithMeta(block, meta, i, j, k);
+					}
+					
+				}
+			}
+			
+			System.out.println("" + i);
+		}
+		
+		System.out.println("I got here!");
+		Gson gson = new GsonBuilder().setPrettyPrinting().create();
+		String json = gson.toJson(schematic);
+		System.out.println("Here, too!");
+		Writer writer;
+		try 
+		{
+			writer = new FileWriter("config/BloodMagic/schematics/" + new Random().nextInt() + ".json");
+			writer.write(json);
+			writer.close();
+		} 
+		catch (IOException e) 
+		{
+			e.printStackTrace();
+		}	
+	}
+	
+	public int getPosYLimit()
+	{
+		int i=1;
+		while(i<100)
+		{
+			if(targetBlock == (worldObj.getBlock(xCoord, yCoord + i, zCoord)))
+			{
+				return i;
+			}
+			
+			i++;
+		}
+		return 1;
+	}
+	
+	public int getNegYLimit()
+	{
+		int i=1;
+		while(i<100)
+		{
+			if(targetBlock == (worldObj.getBlock(xCoord, yCoord - i, zCoord)))
+			{
+				return i;
+			}
+			
+			i++;
+		}
+		return 1;
+	}
+	
+	public int getPosXLimit()
+	{
+		int i=1;
+		while(i<100)
+		{
+			if(targetBlock == (worldObj.getBlock(xCoord + i, yCoord, zCoord)))
+			{
+				return i;
+			}
+			
+			i++;
+		}
+		return 1;
+	}
+	
+	public int getNegXLimit()
+	{
+		int i=1;
+		while(i<100)
+		{
+			if(targetBlock == (worldObj.getBlock(xCoord - i, yCoord, zCoord)))
+			{
+				return i;
+			}
+			
+			i++;
+		}
+		return 1;
+	}
+	
+	public int getPosZLimit()
+	{
+		int i=1;
+		while(i<100)
+		{
+			if(targetBlock == (worldObj.getBlock(xCoord, yCoord, zCoord + i)))
+			{
+				return i;
+			}
+			
+			i++;
+		}
+		return 1;
+	}
+	
+	public int getNegZLimit()
+	{
+		int i=1;
+		while(i<100)
+		{
+			if(targetBlock == (worldObj.getBlock(xCoord, yCoord, zCoord - i)))
+			{
+				return i;
+			}
+			
+			i++;
+		}
+		return 1;
+	}
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TESocket.java

@@ -0,0 +1,255 @@
+package WayofTime.alchemicalWizardry.common.tileEntity;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.network.Packet;
+import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.Constants;
+import WayofTime.alchemicalWizardry.common.NewPacketHandler;
+
+public class TESocket extends TileEntity implements IInventory
+{
+    private ItemStack[] inv;
+    private int resultID;
+    private int resultDamage;
+    
+    public static final int sizeInv = 1;
+
+    private boolean isActive;
+
+    public TESocket()
+    {
+        this.inv = new ItemStack[1];
+        resultID = 0;
+        resultDamage = 0;
+        isActive = false;
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound par1NBTTagCompound)
+    {
+        super.readFromNBT(par1NBTTagCompound);
+        NBTTagList tagList = par1NBTTagCompound.getTagList("Inventory",Constants.NBT.TAG_COMPOUND);
+
+        for (int i = 0; i < tagList.tagCount(); i++)
+        {
+            NBTTagCompound tag = (NBTTagCompound) tagList.getCompoundTagAt(i);
+            int slot = tag.getByte("Slot");
+
+            if (slot >= 0 && slot < inv.length)
+            {
+                inv[slot] = ItemStack.loadItemStackFromNBT(tag);
+            }
+        }
+
+        resultID = par1NBTTagCompound.getInteger("resultID");
+        resultDamage = par1NBTTagCompound.getInteger("resultDamage");
+        isActive = par1NBTTagCompound.getBoolean("isActive");
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound par1NBTTagCompound)
+    {
+        super.writeToNBT(par1NBTTagCompound);
+        NBTTagList itemList = new NBTTagList();
+
+        for (int i = 0; i < inv.length; i++)
+        {
+            ItemStack stack = inv[i];
+
+            if (inv[i] != null)
+            {
+                NBTTagCompound tag = new NBTTagCompound();
+                tag.setByte("Slot", (byte) i);
+                inv[i].writeToNBT(tag);
+                itemList.appendTag(tag);
+            }
+        }
+
+        par1NBTTagCompound.setInteger("resultID", resultID);
+        par1NBTTagCompound.setInteger("resultDamage", resultDamage);
+        par1NBTTagCompound.setTag("Inventory", itemList);
+        par1NBTTagCompound.setBoolean("isActive", isActive);
+    }
+
+    @Override
+    public int getSizeInventory()
+    {
+        return 1;
+    }
+
+    @Override
+    public ItemStack getStackInSlot(int slot)
+    {
+        return inv[slot];
+    }
+
+    @Override
+    public ItemStack decrStackSize(int slot, int amt)
+    {
+        ItemStack stack = getStackInSlot(slot);
+
+        if (stack != null)
+        {
+            if (stack.stackSize <= amt)
+            {
+                setInventorySlotContents(slot, null);
+            } else
+            {
+                stack = stack.splitStack(amt);
+
+                if (stack.stackSize == 0)
+                {
+                    setInventorySlotContents(slot, null);
+                }
+            }
+        }
+
+        return stack;
+    }
+
+    @Override
+    public ItemStack getStackInSlotOnClosing(int slot)
+    {
+        ItemStack stack = getStackInSlot(slot);
+
+        if (stack != null)
+        {
+            setInventorySlotContents(slot, null);
+        }
+
+        return stack;
+    }
+
+    @Override
+    public void setInventorySlotContents(int slot, ItemStack itemStack)
+    {
+        inv[slot] = itemStack;
+
+        if (itemStack != null && itemStack.stackSize > getInventoryStackLimit())
+        {
+            itemStack.stackSize = getInventoryStackLimit();
+        }
+    }
+
+    @Override
+    public String getInventoryName()
+    {
+        return "TESocket";
+    }
+
+    @Override
+    public boolean hasCustomInventoryName()
+    {
+        return false;
+    }
+
+    @Override
+    public int getInventoryStackLimit()
+    {
+        return 1;
+    }
+
+    @Override
+    public boolean isUseableByPlayer(EntityPlayer entityPlayer)
+    {
+        return worldObj.getTileEntity(xCoord, yCoord, zCoord) == this && entityPlayer.getDistanceSq(xCoord + 0.5, yCoord + 0.5, zCoord + 0.5) < 64;
+    }
+
+    @Override
+    public void openInventory()
+    {
+        // TODO Auto-generated method stub
+    }
+
+    @Override
+    public void closeInventory()
+    {
+        // TODO Auto-generated method stub
+    }
+
+    //Logic for the actual block is under here
+    @Override
+    public void updateEntity()
+    {
+        super.updateEntity();
+    }
+
+    public void setActive()
+    {
+        isActive = false;
+    }
+
+    public boolean isActive()
+    {
+        return isActive;
+    }
+
+    @Override
+    public Packet getDescriptionPacket()
+    {
+        return NewPacketHandler.getPacket(this);
+    }
+
+    public void handlePacketData(int[] intData)
+    {
+        if (intData == null)
+        {
+            return;
+        }
+
+        if (intData.length == 3)
+        {
+            for (int i = 0; i < 1; i++)
+            {
+                if (intData[i * 3 + 2] != 0)
+                {
+                    ItemStack is = new ItemStack(Item.getItemById(intData[i * 3]), intData[i * 3 + 2], intData[i * 3 + 1]);
+                    inv[i] = is;
+                } else
+                {
+                    inv[i] = null;
+                }
+            }
+        }
+    }
+
+    public int[] buildIntDataList()
+    {
+        int[] sortList = new int[1 * 3];
+        int pos = 0;
+
+        for (ItemStack is : inv)
+        {
+            if (is != null)
+            {
+                sortList[pos++] = Item.getIdFromItem(is.getItem());
+                sortList[pos++] = is.getItemDamage();
+                sortList[pos++] = is.stackSize;
+            } else
+            {
+                sortList[pos++] = 0;
+                sortList[pos++] = 0;
+                sortList[pos++] = 0;
+            }
+        }
+
+        return sortList;
+    }
+
+    @Override
+    public boolean isItemValidForSlot(int slot, ItemStack itemstack)
+    {
+        if (slot == 0)
+        {
+            return true;
+        }
+
+        return false;
+    }
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TESpectralBlock.java

@@ -0,0 +1,90 @@
+package WayofTime.alchemicalWizardry.common.tileEntity;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.Constants;
+import net.minecraftforge.fluids.IFluidBlock;
+import WayofTime.alchemicalWizardry.ModBlocks;
+
+public class TESpectralBlock extends TileEntity
+{  
+    private int ticksRemaining;
+
+    public TESpectralBlock()
+    {
+        ticksRemaining = 0;
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound par1NBTTagCompound)
+    {
+        super.readFromNBT(par1NBTTagCompound);
+
+        ticksRemaining = par1NBTTagCompound.getInteger("ticksRemaining");
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound par1NBTTagCompound)
+    {
+        super.writeToNBT(par1NBTTagCompound);
+
+        par1NBTTagCompound.setInteger("ticksRemaining", ticksRemaining); 
+    }
+    
+    @Override
+    public void updateEntity()
+    {
+        super.updateEntity();
+        
+        if(worldObj.isRemote)
+        {
+        	return;
+        }
+        
+        this.ticksRemaining--;
+        
+        if(this.ticksRemaining<=0)
+        {
+        	worldObj.setBlockToAir(xCoord, yCoord, zCoord);
+        }
+    }   
+    
+    public static boolean createSpectralBlockAtLocation(World world, int x, int y, int z, int duration)
+    {
+    	if(!world.isAirBlock(x, y, z))
+    	{
+    		return false;
+    	}
+    	
+    	//if(world.getTileEntity(x, y, z)==null)
+    	{    		
+    		world.setBlock(x, y, z, ModBlocks.spectralBlock);
+    		TileEntity tile = world.getTileEntity(x, y, z);
+    		if(tile instanceof TESpectralBlock)
+    		{
+    			((TESpectralBlock) tile).setDuration(duration);
+    			return true;
+    		}
+    	}
+    	
+    	return false;
+    }
+    
+    public void setDuration(int dur)
+    {
+    	this.ticksRemaining = dur;
+    }
+    
+    public void resetDuration(int dur)
+    {
+    	if(this.ticksRemaining<dur)
+    	{
+    		this.ticksRemaining = dur;
+    	}
+    }
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TESpectralContainer.java

@@ -0,0 +1,149 @@
+package WayofTime.alchemicalWizardry.common.tileEntity;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.Constants;
+import net.minecraftforge.fluids.IFluidBlock;
+import WayofTime.alchemicalWizardry.ModBlocks;
+
+public class TESpectralContainer extends TileEntity
+{
+    private ItemStack[] inv;
+    
+    private int ticksRemaining;
+
+    public TESpectralContainer()
+    {
+        this.inv = new ItemStack[1];
+
+        ticksRemaining = 0;
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound par1NBTTagCompound)
+    {
+        super.readFromNBT(par1NBTTagCompound);
+        NBTTagList tagList = par1NBTTagCompound.getTagList("Inventory", Constants.NBT.TAG_COMPOUND);
+
+        for (int i = 0; i < tagList.tagCount(); i++)
+        {
+            NBTTagCompound tag = (NBTTagCompound) tagList.getCompoundTagAt(i);
+            int slot = tag.getByte("Slot");
+
+            if (slot >= 0 && slot < inv.length)
+            {
+                inv[slot] = ItemStack.loadItemStackFromNBT(tag);
+            }
+        }
+
+        ticksRemaining = par1NBTTagCompound.getInteger("ticksRemaining");
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound par1NBTTagCompound)
+    {
+        super.writeToNBT(par1NBTTagCompound);
+        NBTTagList itemList = new NBTTagList();
+
+        for (int i = 0; i < inv.length; i++)
+        {
+            ItemStack stack = inv[i];
+
+            if (inv[i] != null)
+            {
+                NBTTagCompound tag = new NBTTagCompound();
+                tag.setByte("Slot", (byte) i);
+                inv[i].writeToNBT(tag);
+                itemList.appendTag(tag);
+            }
+        }
+
+        par1NBTTagCompound.setTag("Inventory", itemList);
+        par1NBTTagCompound.setInteger("ticksRemaining", ticksRemaining); 
+    }
+    
+    @Override
+    public void updateEntity()
+    {
+        super.updateEntity();
+        
+        this.ticksRemaining--;
+        
+        if(this.ticksRemaining<=0)
+        {
+        	this.returnContainedBlock();
+        }
+    }   
+    
+    public static boolean createSpectralBlockAtLocation(World world, int x, int y, int z, int duration)
+    {
+    	Block block = world.getBlock(x, y, z);
+    	
+    	if(block==null)
+		{
+			return false;
+		}
+    	
+    	if(world.getTileEntity(x, y, z)==null || block instanceof IFluidBlock)
+    	{
+    		int meta = world.getBlockMetadata(x, y, z);
+    		ItemStack item = new ItemStack(block, 1, meta);
+    		
+    		world.setBlock(x, y, z, ModBlocks.blockSpectralContainer);
+    		TileEntity tile = world.getTileEntity(x, y, z);
+    		if(tile instanceof TESpectralContainer)
+    		{
+    			((TESpectralContainer) tile).setContainedItem(item);
+    			((TESpectralContainer) tile).setDuration(duration);
+    			return true;
+    		}
+    	}
+    	
+    	return false;
+    }
+    
+    public void setDuration(int dur)
+    {
+    	this.ticksRemaining = dur;
+    }
+    
+    public void resetDuration(int dur)
+    {
+    	if(this.ticksRemaining<dur)
+    	{
+    		this.ticksRemaining = dur;
+    	}
+    }
+    
+    public void setContainedItem(ItemStack item)
+    {
+    	this.inv[0] = item;
+    }
+    
+    public void returnContainedBlock()
+    {
+    	ItemStack item = this.inv[0];
+    	if(item!=null)
+    	{
+    		if(item.getItem() instanceof ItemBlock)
+    		{
+    			Block block = ((ItemBlock)item.getItem()).field_150939_a;
+    			int meta = item.getItemDamage();
+            	
+            	if(block != null)
+            	{
+            		this.worldObj.setBlock(xCoord, yCoord, zCoord, block, meta, 6);
+            	}
+    		}
+ 	
+    	}else
+    	{
+    		this.worldObj.setBlockToAir(xCoord, yCoord, zCoord);
+    	}
+    }
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TESpellBlock.java

@@ -0,0 +1,48 @@
+package WayofTime.alchemicalWizardry.common.tileEntity;
+
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.ForgeDirection;
+import WayofTime.alchemicalWizardry.common.spell.complex.SpellParadigm;
+
+public abstract class TESpellBlock extends TEOrientable 
+{
+	public void modifySpellParadigm(SpellParadigm parad)
+	{
+		this.applySpellChange(parad);
+		TileEntity tile = this.getTileAtOutput();
+		if(tile instanceof TESpellBlock)
+		{
+			TESpellBlock outputBlock = (TESpellBlock)tile;
+			outputBlock.modifySpellParadigm(parad);
+		}
+	}
+	
+	protected abstract void applySpellChange(SpellParadigm parad);
+	
+	public TESpellBlock getTileAtOutput()
+	{
+		ForgeDirection output = this.getOutputDirection();
+		int xOffset = output.offsetX;
+		int yOffset = output.offsetY;
+		int zOffset = output.offsetZ;
+		
+		TileEntity tile = worldObj.getTileEntity(xCoord + xOffset, yCoord + yOffset, zCoord + zOffset);
+		
+		if(tile instanceof TESpellBlock && ((TESpellBlock)tile).canInputRecieveOutput(output))
+		{
+			return (TESpellBlock)tile;
+		}
+		
+		return null;
+	}
+	
+	public boolean canInputRecieve()
+	{
+		return true;
+	}
+	
+	public boolean canInputRecieveOutput(ForgeDirection output)
+	{
+		return this.canInputRecieve() && this.getInputDirection().getOpposite()==output;
+	}
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TESpellEffectBlock.java

@@ -0,0 +1,43 @@
+package WayofTime.alchemicalWizardry.common.tileEntity;
+
+import WayofTime.alchemicalWizardry.common.spell.complex.SpellParadigm;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellEffect;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellEffectEarth;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellEffectFire;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellEffectIce;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellEffectWind;
+
+public class TESpellEffectBlock extends TESpellBlock
+{
+	@Override
+	protected void applySpellChange(SpellParadigm parad) 
+	{
+		parad.addBufferedEffect(this.getSpellEffect());
+	}
+	
+	public SpellEffect getSpellEffect()
+	{
+		int meta = worldObj.getBlockMetadata(xCoord, yCoord, zCoord);
+		switch(meta)
+		{
+		case 0: return new SpellEffectFire();
+		case 1: return new SpellEffectIce();
+		case 2: return new SpellEffectWind();
+		case 3: return new SpellEffectEarth();
+		}
+		return new SpellEffectFire();
+	}
+	
+	@Override
+	public String getResourceLocationForMeta(int meta)
+    {
+		switch(meta)
+		{
+		case 0: return "alchemicalwizardry:textures/models/SpellEffectFire.png";
+		case 1: return "alchemicalwizardry:textures/models/SpellEffectIce.png";
+		case 2: return "alchemicalwizardry:textures/models/SpellEffectWind.png";
+		case 3: return "alchemicalwizardry:textures/models/SpellEffectEarth.png";
+		}
+    	return "";
+    }
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TESpellEnhancementBlock.java

@@ -0,0 +1,155 @@
+package WayofTime.alchemicalWizardry.common.tileEntity;
+
+import WayofTime.alchemicalWizardry.common.spell.complex.SpellParadigm;
+import WayofTime.alchemicalWizardry.common.spell.complex.enhancement.SpellEnhancement;
+import WayofTime.alchemicalWizardry.common.spell.complex.enhancement.SpellEnhancementCost;
+import WayofTime.alchemicalWizardry.common.spell.complex.enhancement.SpellEnhancementPotency;
+import WayofTime.alchemicalWizardry.common.spell.complex.enhancement.SpellEnhancementPower;
+
+public class TESpellEnhancementBlock extends TESpellBlock 
+{
+	@Override
+	protected void applySpellChange(SpellParadigm parad) 
+	{
+		int i = -1;
+		
+		switch(this.enhancementType())
+		{
+		case 0:
+			i = parad.getBufferedEffectPower();
+			break;
+		case 1:
+			i = parad.getBufferedEffectCost();
+			break;
+		case 2:
+			i = parad.getBufferedEffectPotency();
+			break;
+		}
+		
+		if(i!=-1 && i<this.getLimit())
+		{
+			parad.applyEnhancement(getSpellEnhancement());
+		}
+		else if(i<this.getLimit())
+		{
+			this.doBadStuff();
+		}
+	}
+	
+	public SpellEnhancement getSpellEnhancement()
+	{
+		int meta = worldObj.getBlockMetadata(xCoord, yCoord, zCoord);
+		switch(meta)
+		{
+		case 0:
+		case 1:
+		case 2:
+		case 3:
+		case 4:
+			return new SpellEnhancementPower();
+		case 5:
+		case 6:
+		case 7:
+		case 8:
+		case 9:
+			return new SpellEnhancementCost();
+		case 10:
+		case 11:
+		case 12:
+		case 13:
+		case 14:
+			return new SpellEnhancementPotency();
+		}
+		return new SpellEnhancementCost();
+	}
+	
+	public int getLimit()
+	{
+		int meta = worldObj.getBlockMetadata(xCoord, yCoord, zCoord);
+		switch(meta)
+		{
+		case 0:
+			return 1;
+		case 1:
+			return 2;
+		case 2:
+			return 3;
+		case 3:
+			return 4;
+		case 4:
+			return 5;
+		case 5:
+			return 1;
+		case 6:
+			return 2;
+		case 7:
+			return 3;
+		case 8:
+			return 4;
+		case 9:
+			return 5;
+		case 10:
+			return 1;
+		case 11:
+			return 2;
+		case 12:
+			return 3;
+		case 13:
+			return 4;
+		case 14:
+			return 5;
+		}
+		return 0;
+	}
+	
+	public int enhancementType() //0 is power, 1 is cost, 2 is potency
+	{
+		int meta = worldObj.getBlockMetadata(xCoord, yCoord, zCoord);
+		switch(meta)
+		{
+		case 0:
+		case 1:
+		case 2:
+		case 3:
+		case 4:
+			return 0;
+		case 5:
+		case 6:
+		case 7:
+		case 8:
+		case 9:
+			return 1;
+		case 10:
+		case 11:
+		case 12:
+		case 13:
+		case 14:
+			return 2;
+		}
+		return 1;
+	}
+	
+	public void doBadStuff()
+	{
+		
+	}
+	
+	@Override
+	public String getResourceLocationForMeta(int meta)
+	{
+		switch(meta)
+		{
+		case 0: return "alchemicalwizardry:textures/models/SpellEnhancementPower1.png";
+		case 1: return "alchemicalwizardry:textures/models/SpellEnhancementPower2.png";
+		case 2: return "alchemicalwizardry:textures/models/SpellEnhancementPower3.png";
+		case 5: return "alchemicalwizardry:textures/models/SpellEnhancementCost1.png";
+		case 6: return "alchemicalwizardry:textures/models/SpellEnhancementCost2.png";
+		case 7: return "alchemicalwizardry:textures/models/SpellEnhancementCost3.png";
+		case 10: return "alchemicalwizardry:textures/models/SpellEnhancementPotency1.png";
+		case 11: return "alchemicalwizardry:textures/models/SpellEnhancementPotency2.png";
+		case 12: return "alchemicalwizardry:textures/models/SpellEnhancementPotency3.png";
+
+		}
+    	return "alchemicalwizardry:textures/models/SpellEnhancementPower1.png";
+	}
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TESpellModifierBlock.java

@@ -0,0 +1,43 @@
+package WayofTime.alchemicalWizardry.common.tileEntity;
+
+import WayofTime.alchemicalWizardry.common.spell.complex.SpellModifier;
+import WayofTime.alchemicalWizardry.common.spell.complex.SpellModifierDefault;
+import WayofTime.alchemicalWizardry.common.spell.complex.SpellModifierDefensive;
+import WayofTime.alchemicalWizardry.common.spell.complex.SpellModifierEnvironmental;
+import WayofTime.alchemicalWizardry.common.spell.complex.SpellModifierOffensive;
+import WayofTime.alchemicalWizardry.common.spell.complex.SpellParadigm;
+
+public class TESpellModifierBlock extends TESpellBlock
+{
+	@Override
+	protected void applySpellChange(SpellParadigm parad) 
+	{
+		parad.modifyBufferedEffect(this.getSpellModifier());
+	}
+	
+	public SpellModifier getSpellModifier()
+	{
+		int meta = worldObj.getBlockMetadata(xCoord, yCoord, zCoord);
+		switch(meta)
+		{
+		case 0: return new SpellModifierDefault();
+		case 1: return new SpellModifierOffensive();
+		case 2: return new SpellModifierDefensive();
+		case 3: return new SpellModifierEnvironmental();
+		}
+		return new SpellModifierDefault();
+	}
+	
+	@Override
+	public String getResourceLocationForMeta(int meta)
+    {
+		switch(meta)
+		{
+		case 0: return "alchemicalwizardry:textures/models/SpellModifierDefault.png";
+		case 1: return "alchemicalwizardry:textures/models/SpellModifierOffensive.png";
+		case 2: return "alchemicalwizardry:textures/models/SpellModifierDefensive.png";
+		case 3: return "alchemicalwizardry:textures/models/SpellModifierEnvironmental.png";
+		}
+    	return "alchemicalwizardry:textures/models/SpellModifierDefault.png";
+    }
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TESpellParadigmBlock.java

@@ -0,0 +1,98 @@
+package WayofTime.alchemicalWizardry.common.tileEntity;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import WayofTime.alchemicalWizardry.common.spell.complex.SpellParadigm;
+import WayofTime.alchemicalWizardry.common.spell.complex.SpellParadigmMelee;
+import WayofTime.alchemicalWizardry.common.spell.complex.SpellParadigmProjectile;
+import WayofTime.alchemicalWizardry.common.spell.complex.SpellParadigmSelf;
+import WayofTime.alchemicalWizardry.common.spell.complex.SpellParadigmTool;
+
+public class TESpellParadigmBlock extends TESpellBlock 
+{
+	public SpellParadigm getSpellParadigm()
+	{
+		int meta = worldObj.getBlockMetadata(xCoord, yCoord, zCoord);
+		switch(meta)
+		{
+		case 0: return new SpellParadigmProjectile();
+		case 1: return new SpellParadigmSelf();
+		case 2: return new SpellParadigmMelee();
+		case 3: return new SpellParadigmTool();
+		}
+		return new SpellParadigmSelf();
+	}
+
+	@Override
+	protected void applySpellChange(SpellParadigm parad) 
+	{
+		return;
+	}
+	
+	public boolean canInputRecieve()
+	{
+		return false;
+	}
+	
+	public void castSpell(World world, EntityPlayer entity, ItemStack spellCasterStack)
+	{
+		SpellParadigm parad = this.getSpellParadigm();
+		this.modifySpellParadigm(parad);
+//		if(parad instanceof SpellParadigmSelf)
+//		{
+//			List<String> stringList = parad.effectList;
+//			SpellParadigmSelf spellParadSelf = SpellParadigmSelf.getParadigmForStringArray(stringList);
+//			for(String str : stringList)
+//			{
+//				ChatMessageComponent chat = new ChatMessageComponent();
+//				chat.addText(str);
+//				entity.sendChatToPlayer(chat);
+//			}
+//			spellParadSelf.castSpell(world, entity, spellCasterStack);
+//		}
+//		else if(parad instanceof SpellParadigmProjectile)
+//		{
+//			List<String> stringList = parad.effectList;
+//			SpellParadigmProjectile spellParadSelf = SpellParadigmProjectile.getParadigmForStringArray(stringList);
+//			for(String str : stringList)
+//			{
+//				ChatMessageComponent chat = new ChatMessageComponent();
+//				chat.addText(str);
+//				entity.sendChatToPlayer(chat);
+//			}
+//			spellParadSelf.castSpell(world, entity, spellCasterStack);
+//		}else
+		{
+			parad.applyAllSpellEffects();
+			parad.castSpell(world, entity, spellCasterStack);
+		}
+		
+	}
+	
+	@Override
+	public String getResourceLocationForMeta(int meta)
+    {
+		switch(meta)
+		{
+		case 0: return "alchemicalwizardry:textures/models/SpellParadigmProjectile.png";
+		case 1: return "alchemicalwizardry:textures/models/SpellParadigmSelf.png";
+		case 2: return "alchemicalwizardry:textures/models/SpellParadigmMelee.png";
+		case 3: return "alchemicalwizardry:textures/models/SpellParadigmTool.png";
+		}
+    	return "alchemicalwizardry:textures/models/SpellParadigmProjectile.png";
+    }
+	
+	@Override
+    public void setInputDirection(ForgeDirection direction)
+    {
+
+    }
+	
+	@Override
+	public ForgeDirection getInputDirection()
+	{
+		return ForgeDirection.UNKNOWN;
+	}
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TETeleposer.java

@@ -0,0 +1,377 @@
+package WayofTime.alchemicalWizardry.common.tileEntity;
+
+import java.util.Iterator;
+import java.util.List;
+
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.network.Packet;
+import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.Constants;
+import WayofTime.alchemicalWizardry.common.NewPacketHandler;
+import WayofTime.alchemicalWizardry.common.block.BlockTeleposer;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import WayofTime.alchemicalWizardry.common.items.TelepositionFocus;
+
+public class TETeleposer extends TileEntity implements IInventory
+{
+    private ItemStack[] inv;
+    private int resultID;
+    private int resultDamage;
+    private int previousInput;
+    
+    public static final int sizeInv = 1;
+
+    private boolean isActive;
+
+    public TETeleposer()
+    {
+        this.inv = new ItemStack[1];
+        resultID = 0;
+        resultDamage = 0;
+        isActive = false;
+        previousInput = 0;
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound par1NBTTagCompound)
+    {
+        super.readFromNBT(par1NBTTagCompound);
+        NBTTagList tagList = par1NBTTagCompound.getTagList("Inventory", Constants.NBT.TAG_COMPOUND);
+
+        for (int i = 0; i < tagList.tagCount(); i++)
+        {
+            NBTTagCompound tag = (NBTTagCompound) tagList.getCompoundTagAt(i);
+            int slot = tag.getByte("Slot");
+
+            if (slot >= 0 && slot < inv.length)
+            {
+                inv[slot] = ItemStack.loadItemStackFromNBT(tag);
+            }
+        }
+
+        resultID = par1NBTTagCompound.getInteger("resultID");
+        resultDamage = par1NBTTagCompound.getInteger("resultDamage");
+        isActive = par1NBTTagCompound.getBoolean("isActive");
+        previousInput = par1NBTTagCompound.getInteger("previousInput");
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound par1NBTTagCompound)
+    {
+        super.writeToNBT(par1NBTTagCompound);
+        NBTTagList itemList = new NBTTagList();
+
+        for (int i = 0; i < inv.length; i++)
+        {
+            ItemStack stack = inv[i];
+
+            if (inv[i] != null)
+            {
+                NBTTagCompound tag = new NBTTagCompound();
+                tag.setByte("Slot", (byte) i);
+                inv[i].writeToNBT(tag);
+                itemList.appendTag(tag);
+            }
+        }
+
+        par1NBTTagCompound.setInteger("resultID", resultID);
+        par1NBTTagCompound.setInteger("resultDamage", resultDamage);
+        par1NBTTagCompound.setTag("Inventory", itemList);
+        par1NBTTagCompound.setBoolean("isActive", isActive);
+        par1NBTTagCompound.setInteger("previousInput", previousInput);
+    }
+
+    @Override
+    public int getSizeInventory()
+    {
+        return 1;
+    }
+
+    @Override
+    public ItemStack getStackInSlot(int slot)
+    {
+        return inv[slot];
+    }
+
+    @Override
+    public ItemStack decrStackSize(int slot, int amt)
+    {
+        ItemStack stack = getStackInSlot(slot);
+
+        if (stack != null)
+        {
+            if (stack.stackSize <= amt)
+            {
+                setInventorySlotContents(slot, null);
+            } else
+            {
+                stack = stack.splitStack(amt);
+
+                if (stack.stackSize == 0)
+                {
+                    setInventorySlotContents(slot, null);
+                }
+            }
+        }
+
+        return stack;
+    }
+
+    @Override
+    public ItemStack getStackInSlotOnClosing(int slot)
+    {
+        ItemStack stack = getStackInSlot(slot);
+
+        if (stack != null)
+        {
+            setInventorySlotContents(slot, null);
+        }
+
+        return stack;
+    }
+
+    @Override
+    public void setInventorySlotContents(int slot, ItemStack itemStack)
+    {
+        inv[slot] = itemStack;
+
+        if (itemStack != null && itemStack.stackSize > getInventoryStackLimit())
+        {
+            itemStack.stackSize = getInventoryStackLimit();
+        }
+    }
+
+    @Override
+    public String getInventoryName()
+    {
+        return "TETeleposer";
+    }
+
+    @Override
+    public boolean hasCustomInventoryName()
+    {
+        return false;
+    }
+
+    @Override
+    public int getInventoryStackLimit()
+    {
+        return 1;
+    }
+
+    @Override
+    public boolean isUseableByPlayer(EntityPlayer entityPlayer)
+    {
+        return worldObj.getTileEntity(xCoord, yCoord, zCoord) == this && entityPlayer.getDistanceSq(xCoord + 0.5, yCoord + 0.5, zCoord + 0.5) < 64;
+    }
+
+    @Override
+    public void openInventory()
+    {
+        // TODO Auto-generated method stub
+    }
+
+    @Override
+    public void closeInventory()
+    {
+        // TODO Auto-generated method stub
+    }
+
+    //Logic for the actual block is under here
+    @Override
+    public void updateEntity()
+    {
+        super.updateEntity();
+        EntityPlayer d;
+
+        if (worldObj.isRemote)
+        {
+            return;
+        }
+
+        int currentInput = worldObj.getBlockPowerInput(xCoord, yCoord, zCoord);
+
+        if (previousInput == 0 && currentInput != 0)
+        {
+            ItemStack focus = this.getStackInSlot(0);
+
+            if (focus != null && focus.getItem() instanceof TelepositionFocus)
+            {
+                TelepositionFocus focusItem = (TelepositionFocus) (focus.getItem());
+                int xf = focusItem.xCoord(focus);
+                int yf = focusItem.yCoord(focus);
+                int zf = focusItem.zCoord(focus);
+                World worldF = focusItem.getWorld(focus);
+                int damage = (int) (0.5f * Math.sqrt((xCoord - xf) * (xCoord - xf) + (yCoord - yf + 1) * (yCoord - yf + 1) + (zCoord - zf) * (zCoord - zf)));
+                int focusLevel = ((TelepositionFocus) focusItem).getFocusLevel();
+                int transportCount = 0;
+                int entityCount = 0;
+
+                if (worldF != null && worldF.getTileEntity(xf, yf, zf) instanceof TETeleposer && !worldF.getTileEntity(xf, yf, zf).equals(this))
+                {
+                    //Prime the teleportation
+                    int d0 = focusLevel - 1;
+                    AxisAlignedBB axisalignedbb1 = AxisAlignedBB.getBoundingBox((double) this.xCoord, (double) this.yCoord + d0 + 1, (double) this.zCoord, (double) (this.xCoord + 1), (double) (this.yCoord + 2 + d0), (double) (this.zCoord + 1)).expand(d0, d0, d0);
+                    axisalignedbb1.maxY = Math.min((double) this.worldObj.getHeight(), this.yCoord + 2 + d0 + d0);
+                    List list1 = this.worldObj.getEntitiesWithinAABB(EntityLivingBase.class, axisalignedbb1);
+                    Iterator iterator1 = list1.iterator();
+                    EntityLivingBase entityplayer1;
+
+                    while (iterator1.hasNext())
+                    {
+                        entityplayer1 = (EntityLivingBase) iterator1.next();
+                        entityCount++;
+                    }
+
+                    //int d0 = focusLevel-1;
+                    AxisAlignedBB axisalignedbb2 = AxisAlignedBB.getBoundingBox(xf, yf + d0 + 1, zf, xf + 1, yf + 2 + d0, zf).expand(d0, d0, d0);
+                    //axisalignedbb2.maxY = Math.min((double)worldF.getHeight(),yf+1+d0+d0);
+                    List list2 = worldF.getEntitiesWithinAABB(EntityLivingBase.class, axisalignedbb2);
+                    Iterator iterator2 = list2.iterator();
+                    EntityLivingBase entityplayer2;
+
+                    while (iterator2.hasNext())
+                    {
+                        entityplayer2 = (EntityLivingBase) iterator2.next();
+                        entityCount++;
+                    }
+
+                    if (EnergyItems.canSyphonInContainer(focus, damage * (focusLevel * 2 - 1) * (focusLevel * 2 - 1) * (focusLevel * 2 - 1) + damage * entityCount))
+                    {
+                        for (int k = 0; k <= (focusLevel * 2 - 2); k++)
+                        //for(int k=(focusLevel*2-1);k>=0;k--)
+                        {
+                            for (int i = -(focusLevel - 1); i <= (focusLevel - 1); i++)
+                            {
+                                for (int j = -(focusLevel - 1); j <= (focusLevel - 1); j++)
+                                {
+                                    {
+                                        if (BlockTeleposer.swapBlocks(worldObj, worldF, xCoord + i, yCoord + 1 + k, zCoord + j, xf + i, yf + 1 + k, zf + j))
+                                        {
+                                            transportCount++;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+
+                        if (!worldF.equals(worldObj))
+                        {
+                            entityCount = 0;
+                        }
+
+                        EnergyItems.syphonWhileInContainer(focus, damage * transportCount + damage * entityCount);
+                        //Teleport
+
+                        if (worldF.equals(worldObj))
+                        {
+                            iterator1 = list1.iterator();
+                            iterator2 = list2.iterator();
+
+                            while (iterator1.hasNext())
+                            {
+                                entityplayer1 = (EntityLivingBase) iterator1.next();
+                                entityplayer1.worldObj = worldF;
+                                entityplayer1.setPositionAndUpdate(entityplayer1.posX - this.xCoord + xf, entityplayer1.posY - this.yCoord + yf, entityplayer1.posZ - this.zCoord + zf);
+                                //entityplayer1.travelToDimension(worldF.provider.dimensionId);
+                            }
+
+                            while (iterator2.hasNext())
+                            {
+                                entityplayer2 = (EntityLivingBase) iterator2.next();
+                                entityplayer2.worldObj = worldF;
+                                entityplayer2.setPositionAndUpdate(entityplayer2.posX + this.xCoord - xf, entityplayer2.posY + this.yCoord - yf, entityplayer2.posZ + this.zCoord - zf);
+                                //entityplayer2.travelToDimension(worldObj.provider.dimensionId);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        previousInput = currentInput;
+    }
+
+    public void setActive()
+    {
+        isActive = false;
+    }
+
+    public boolean isActive()
+    {
+        return isActive;
+    }
+
+    @Override
+    public Packet getDescriptionPacket()
+    {    
+    	return NewPacketHandler.getPacket(this);
+    }
+
+    public void handlePacketData(int[] intData)
+    {
+        if (intData == null)
+        {
+            return;
+        }
+
+        if (intData.length == 3)
+        {
+            for (int i = 0; i < 1; i++)
+            {
+                if (intData[i * 3 + 2] != 0)
+                {
+                    ItemStack is = new ItemStack(Item.getItemById(intData[i * 3]), intData[i * 3 + 2], intData[i * 3 + 1]);
+                    inv[i] = is;
+                } else
+                {
+                    inv[i] = null;
+                }
+            }
+        }
+    }
+
+    public int[] buildIntDataList()
+    {
+        int[] sortList = new int[1 * 3];
+        int pos = 0;
+
+        for (ItemStack is : inv)
+        {
+            if (is != null)
+            {
+                sortList[pos++] = Item.getIdFromItem(is.getItem());
+                sortList[pos++] = is.getItemDamage();
+                sortList[pos++] = is.stackSize;
+            } else
+            {
+                sortList[pos++] = 0;
+                sortList[pos++] = 0;
+                sortList[pos++] = 0;
+            }
+        }
+
+        return sortList;
+    }
+
+    @Override
+    public boolean isItemValidForSlot(int slot, ItemStack itemstack)
+    {
+        if (slot == 0)
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/TEWritingTable.java

@@ -0,0 +1,916 @@
+package WayofTime.alchemicalWizardry.common.tileEntity;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.Constants;
+import net.minecraftforge.oredict.OreDictionary;
+import WayofTime.alchemicalWizardry.ModItems;
+import WayofTime.alchemicalWizardry.api.alchemy.AlchemicalPotionCreationHandler;
+import WayofTime.alchemicalWizardry.api.alchemy.AlchemyRecipe;
+import WayofTime.alchemicalWizardry.api.alchemy.AlchemyRecipeRegistry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IBloodOrb;
+import WayofTime.alchemicalWizardry.common.IBindingAgent;
+import WayofTime.alchemicalWizardry.common.ICatalyst;
+import WayofTime.alchemicalWizardry.common.IFillingAgent;
+import WayofTime.alchemicalWizardry.common.NewPacketHandler;
+import WayofTime.alchemicalWizardry.common.alchemy.CombinedPotionRegistry;
+import WayofTime.alchemicalWizardry.common.alchemy.ICombinationalCatalyst;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import WayofTime.alchemicalWizardry.common.items.potion.AlchemyFlask;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+
+public class TEWritingTable extends TileEntity implements IInventory
+{
+    private ItemStack[] inv;
+    private int progress;
+    private int progressNeeded = 100;
+    private int amountUsed;
+    
+    private int accelerationTime;
+    
+    public static final int sizeInv = 7;
+
+    public TEWritingTable()
+    {
+        inv = new ItemStack[7];
+    }
+
+    @Override
+    public int getSizeInventory()
+    {
+        return inv.length;
+    }
+
+    @Override
+    public ItemStack getStackInSlot(int slot)
+    {
+        return inv[slot];
+    }
+
+    @Override
+    public void setInventorySlotContents(int slot, ItemStack stack)
+    {
+        inv[slot] = stack;
+
+        if (stack != null && stack.stackSize > getInventoryStackLimit())
+        {
+            stack.stackSize = getInventoryStackLimit();
+        }
+    }
+
+    @Override
+    public ItemStack decrStackSize(int slot, int amt)
+    {
+        ItemStack stack = getStackInSlot(slot);
+
+        if (stack != null)
+        {
+            if (stack.stackSize <= amt)
+            {
+                setInventorySlotContents(slot, null);
+            } else
+            {
+                stack = stack.splitStack(amt);
+
+                if (stack.stackSize == 0)
+                {
+                    setInventorySlotContents(slot, null);
+                }
+            }
+        }
+
+        return stack;
+    }
+
+    @Override
+    public ItemStack getStackInSlotOnClosing(int slot)
+    {
+        ItemStack stack = getStackInSlot(slot);
+
+        if (stack != null)
+        {
+            setInventorySlotContents(slot, null);
+        }
+
+        return stack;
+    }
+
+    @Override
+    public int getInventoryStackLimit()
+    {
+        return 64;
+    }
+
+    @Override
+    public boolean isUseableByPlayer(EntityPlayer player)
+    {
+        return worldObj.getTileEntity(xCoord, yCoord, zCoord) == this && player.getDistanceSq(xCoord + 0.5, yCoord + 0.5, zCoord + 0.5) < 64;
+    }
+
+    @Override
+    public void openInventory()
+    {
+    }
+
+    @Override
+    public void closeInventory()
+    {
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound tagCompound)
+    {
+        super.readFromNBT(tagCompound);
+        NBTTagList tagList = tagCompound.getTagList("Inventory",Constants.NBT.TAG_COMPOUND);
+
+        for (int i = 0; i < tagList.tagCount(); i++)
+        {
+            NBTTagCompound tag = (NBTTagCompound) tagList.getCompoundTagAt(i);
+            byte slot = tag.getByte("Slot");
+
+            if (slot >= 0 && slot < inv.length)
+            {
+                inv[slot] = ItemStack.loadItemStackFromNBT(tag);
+            }
+        }
+
+        progress = tagCompound.getInteger("progress");
+        amountUsed = tagCompound.getInteger("amountUsed");
+        
+        accelerationTime = tagCompound.getInteger("accelerationTime");
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound tagCompound)
+    {
+        super.writeToNBT(tagCompound);
+        NBTTagList itemList = new NBTTagList();
+
+        for (int i = 0; i < inv.length; i++)
+        {
+            ItemStack stack = inv[i];
+
+            if (stack != null)
+            {
+                NBTTagCompound tag = new NBTTagCompound();
+                tag.setByte("Slot", (byte) i);
+                stack.writeToNBT(tag);
+                itemList.appendTag(tag);
+            }
+        }
+
+        tagCompound.setTag("Inventory", itemList);
+        tagCompound.setInteger("progress", progress);
+        tagCompound.setInteger("amountUsed", amountUsed);
+        
+        tagCompound.setInteger("accelerationTime", accelerationTime);
+    }
+
+    @Override
+    public String getInventoryName()
+    {
+        return "aw.TEWritingTable";
+    }
+
+    @Override
+    public boolean hasCustomInventoryName()
+    {
+        // TODO Auto-generated method stub
+        return false;
+    }
+
+    @Override
+    public boolean isItemValidForSlot(int i, ItemStack itemstack)
+    {
+        // TODO Auto-generated method stub
+        return false;
+    }
+
+    @Override
+    public net.minecraft.network.Packet getDescriptionPacket()
+    {
+        return NewPacketHandler.getPacket(this);
+    }
+
+    public void handlePacketData(int[] intData)
+    {
+        if (intData == null)
+        {
+            return;
+        }
+
+        if (intData.length == 3 * 7)
+        {
+            for (int i = 0; i < 7; i++)
+            {
+                if (intData[i * 3 + 2] != 0)
+                {
+                    ItemStack is = new ItemStack(Item.getItemById(intData[i * 3]), intData[i * 3 + 2], intData[i * 3 + 1]);
+                    inv[i] = is;
+                } else
+                {
+                    inv[i] = null;
+                }
+            }
+        }
+    }
+
+    public int[] buildIntDataList()
+    {
+        int[] sortList = new int[7 * 3];
+        int pos = 0;
+
+        for (ItemStack is : inv)
+        {
+            if (is != null)
+            {
+                sortList[pos++] = Item.getIdFromItem(is.getItem());
+                sortList[pos++] = is.getItemDamage();
+                sortList[pos++] = is.stackSize;
+            } else
+            {
+                sortList[pos++] = 0;
+                sortList[pos++] = 0;
+                sortList[pos++] = 0;
+            }
+        }
+
+        return sortList;
+    }
+
+    public ItemStack getResultingItemStack()
+    {
+        ItemStack[] composedRecipe = new ItemStack[5];
+
+        for (int i = 0; i < 5; i++)
+        {
+            composedRecipe[i] = inv[i + 1];
+        }
+
+        return AlchemyRecipeRegistry.getResult(composedRecipe, inv[0]);
+    }
+
+    public boolean isRecipeValid()
+    {
+        return (getResultingItemStack() != null);
+    }
+
+    public int getAmountNeeded(ItemStack bloodOrb)
+    {
+        ItemStack[] composedRecipe = new ItemStack[5];
+
+        for (int i = 0; i < 5; i++)
+        {
+            composedRecipe[i] = inv[i + 1];
+        }
+
+        return AlchemyRecipeRegistry.getAmountNeeded(composedRecipe, bloodOrb);
+    }
+
+    public boolean containsPotionFlask()
+    {
+        if (getPotionFlaskPosition() != -1)
+        {
+            return true;
+        } else
+        {
+            return false;
+        }
+    }
+
+    public int getPotionFlaskPosition()
+    {
+        for (int i = 1; i <= 5; i++)
+        {
+            if (inv[i] != null && !(inv[i].getItem() instanceof ItemBlock) && inv[i].getItem() == ModItems.alchemyFlask)
+            {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+    
+    public boolean containsCombinationCatalyst()
+    {
+        if (getCombinationCatalystPosition() != -1)
+        {
+            return true;
+        } else
+        {
+            return false;
+        }
+    }
+
+    public int getCombinationCatalystPosition()
+    {
+        for (int i = 1; i <= 5; i++)
+        {
+            if (inv[i] != null && inv[i].getItem() instanceof ICombinationalCatalyst)
+            {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    public boolean containsRegisteredPotionIngredient()
+    {
+        if (getRegisteredPotionIngredientPosition() != -1)
+        {
+            return true;
+        } else
+        {
+            return false;
+        }
+    }
+
+    public int getRegisteredPotionIngredientPosition()
+    {
+        ItemStack[] composedRecipe = new ItemStack[5];
+
+        for (int i = 0; i < 5; i++)
+        {
+            composedRecipe[i] = inv[i + 1];
+        }
+
+        int location = AlchemicalPotionCreationHandler.getRegisteredPotionIngredientPosition(composedRecipe);
+
+        if (location != -1)
+        {
+            return location + 1;
+        }
+
+        return -1;
+    }
+
+    public boolean containsCatalyst()
+    {
+        if (getCatalystPosition() != -1)
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    public int getCatalystPosition()
+    {
+        for (int i = 0; i < 5; i++)
+        {
+            if (inv[i + 1] != null && inv[i + 1].getItem() instanceof ICatalyst)
+            {
+                return i + 1;
+            }
+        }
+
+        return -1;
+    }
+
+    public boolean containsBindingAgent()
+    {
+        if (getBindingAgentPosition() != -1)
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    public int getBindingAgentPosition()
+    {
+        for (int i = 0; i < 5; i++)
+        {
+            if (inv[i + 1] != null && inv[i + 1].getItem() instanceof IBindingAgent)
+            {
+                return i + 1;
+            }
+        }
+
+        return -1;
+    }
+
+    public boolean containsFillingAgent()
+    {
+        if (getFillingAgentPosition() != -1)
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    public int getFillingAgentPosition()
+    {
+        for (int i = 0; i < 5; i++)
+        {
+            if (inv[i + 1] != null && inv[i + 1].getItem() instanceof IFillingAgent)
+            {
+                return i + 1;
+            }
+        }
+
+        return -1;
+    }
+
+    public boolean containsBlankSlate()
+    {
+        if (getBlankSlatePosition() != -1)
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    public int getBlankSlatePosition()
+    {
+        for (int i = 0; i < 5; i++)
+        {
+            if (inv[i + 1] != null && inv[i + 1].getItem() == ModItems.blankSlate)
+            {
+                return i + 1;
+            }
+        }
+
+        return -1;
+    }
+
+    @Override
+    public void updateEntity()
+    {
+        long worldTime = worldObj.getWorldTime();
+
+        if (worldObj.isRemote)
+        {
+            return;
+        }
+
+//    	if(worldTime%100==0)
+//    	{
+//    		if (worldObj != null)
+//            {
+//                worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+//            }
+//    	}
+
+        if(accelerationTime > 0)
+        {
+        	accelerationTime--;
+        }
+        
+        if (containsPotionFlask() && containsRegisteredPotionIngredient())
+        {
+            if (containsCatalyst())
+            {
+                if (getStackInSlot(6) == null)
+                {
+                    progress++;
+
+                    if (worldTime % 4 == 0)
+                    {
+                        SpellHelper.sendIndexedParticleToAllAround(worldObj, xCoord, yCoord, zCoord, 20, worldObj.provider.dimensionId, 1, xCoord, yCoord, zCoord);
+                    }
+
+                    if (progress >= progressNeeded)
+                    {
+                        ItemStack flaskStack = inv[this.getPotionFlaskPosition()];
+                        ItemStack ingredientStack = inv[this.getRegisteredPotionIngredientPosition()];
+                        ItemStack catalystStack = inv[this.getCatalystPosition()];
+
+                        if (flaskStack == null || ingredientStack == null || catalystStack == null)
+                        {
+                            progress = 0;
+
+                            if (worldObj != null)
+                            {
+                                worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+                            }
+
+                            return;
+                        }
+
+                        int potionID = AlchemicalPotionCreationHandler.getPotionIDForStack(ingredientStack);
+                        int catalystLevel = ((ICatalyst) catalystStack.getItem()).getCatalystLevel();
+                        boolean isConcentration = ((ICatalyst) catalystStack.getItem()).isConcentration();
+
+                        if (potionID == -1 || catalystLevel < 0)
+                        {
+                            progress = 0;
+
+                            if (worldObj != null)
+                            {
+                                worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+                            }
+
+                            return;
+                        }
+
+                        if (isConcentration)
+                        {
+                            ((AlchemyFlask) flaskStack.getItem()).setConcentrationOfPotion(flaskStack, potionID, catalystLevel);
+                        } else
+                        {
+                            ((AlchemyFlask) flaskStack.getItem()).setDurationFactorOfPotion(flaskStack, potionID, catalystLevel);
+                        }
+
+                        //((AlchemyFlask)flaskStack.getItem()).setConcentrationOfPotion(flaskStack, Potion.regeneration.id, 2);
+                        this.setInventorySlotContents(6, flaskStack);
+                        this.decrStackSize(this.getPotionFlaskPosition(), 1);
+                        this.decrStackSize(this.getCatalystPosition(), 1);
+                        this.decrStackSize(this.getRegisteredPotionIngredientPosition(), 1);
+                        progress = 0;
+
+                        if (worldObj != null)
+                        {
+                            worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+                        }
+                    }
+                }
+            } else if (containsBindingAgent())
+            {
+                if (getStackInSlot(6) == null)
+                {
+                    progress++;
+
+                    if (worldTime % 4 == 0)
+                    {
+                        SpellHelper.sendIndexedParticleToAllAround(worldObj, xCoord, yCoord, zCoord, 20, worldObj.provider.dimensionId, 1, xCoord, yCoord, zCoord);
+                    }
+
+                    if (progress >= progressNeeded)
+                    {
+                        ItemStack flaskStack = inv[this.getPotionFlaskPosition()];
+                        ItemStack ingredientStack = inv[this.getRegisteredPotionIngredientPosition()];
+                        ItemStack agentStack = inv[this.getBindingAgentPosition()];
+
+                        if (flaskStack == null || ingredientStack == null || agentStack == null)
+                        {
+                            progress = 0;
+
+                            if (worldObj != null)
+                            {
+                                worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+                            }
+
+                            return;
+                        }
+
+                        int potionEffectNumber = ((AlchemyFlask) flaskStack.getItem()).getNumberOfPotionEffects(flaskStack);
+                        int potionID = AlchemicalPotionCreationHandler.getPotionIDForStack(ingredientStack);
+                        int tickDuration = AlchemicalPotionCreationHandler.getPotionTickDurationForStack(ingredientStack);
+                        float successChance = ((IBindingAgent) agentStack.getItem()).getSuccessRateForPotionNumber(potionEffectNumber);
+                        //boolean isConcentration = ((ICatalyst)catalystStack.getItem()).isConcentration();
+
+                        if (potionID == -1)
+                        {
+                            progress = 0;
+
+                            if (worldObj != null)
+                            {
+                                worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+                            }
+
+                            return;
+                        }
+
+                        ((AlchemyFlask) flaskStack.getItem()).addPotionEffect(flaskStack, potionID, tickDuration);
+
+                        //((AlchemyFlask)flaskStack.getItem()).addPotionEffect(flaskStack, Potion.regeneration.id, 1000);
+
+                        if (successChance > worldObj.rand.nextFloat())
+                        {
+                            this.setInventorySlotContents(6, flaskStack);
+                        } else
+                        {
+                            worldObj.createExplosion(null, xCoord + 0.5, yCoord + 1, zCoord + 0.5, 2, false);
+                        }
+
+                        this.decrStackSize(this.getPotionFlaskPosition(), 1);
+                        this.decrStackSize(this.getBindingAgentPosition(), 1);
+                        this.decrStackSize(this.getRegisteredPotionIngredientPosition(), 1);
+                        progress = 0;
+
+                        if (worldObj != null)
+                        {
+                            worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+                        }
+                    }
+                }
+            }
+        } else if (this.containsBlankSlate() && this.containsPotionFlask())
+        {
+            if (getStackInSlot(6) == null)
+            {
+                progress++;
+
+                if (worldTime % 4 == 0)
+                {
+                    SpellHelper.sendIndexedParticleToAllAround(worldObj, xCoord, yCoord, zCoord, 20, worldObj.provider.dimensionId, 1, xCoord, yCoord, zCoord);
+                }
+
+                if (progress >= progressNeeded)
+                {
+                    ItemStack flaskStack = inv[this.getPotionFlaskPosition()];
+                    //ItemStack ingredientStack = inv[this.getRegisteredPotionIngredientPosition()];
+                    ItemStack blankSlate = inv[this.getBlankSlatePosition()];
+
+                    if (flaskStack == null || blankSlate == null)
+                    {
+                        progress = 0;
+
+                        if (worldObj != null)
+                        {
+                            worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+                        }
+
+                        return;
+                    }
+
+                    //boolean isConcentration = ((ICatalyst)catalystStack.getItem()).isConcentration();
+                    ((AlchemyFlask) flaskStack.getItem()).setIsPotionThrowable(true, flaskStack);
+                    //((AlchemyFlask)flaskStack.getItem()).addPotionEffect(flaskStack, Potion.regeneration.id, 1000);
+                    //if(successChance>worldObj.rand.nextFloat())
+                    this.setInventorySlotContents(6, flaskStack);
+                    this.decrStackSize(this.getPotionFlaskPosition(), 1);
+                    this.decrStackSize(this.getBlankSlatePosition(), 1);
+                    //this.decrStackSize(this.getRegisteredPotionIngredientPosition(), 1);
+                    progress = 0;
+
+                    if (worldObj != null)
+                    {
+                        worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+                    }
+                }
+            }
+        } else if (this.containsFillingAgent() && this.containsPotionFlask())
+        {
+            if (getStackInSlot(6) == null)
+            {
+                progress++;
+
+                if (worldTime % 4 == 0)
+                {
+                    SpellHelper.sendIndexedParticleToAllAround(worldObj, xCoord, yCoord, zCoord, 20, worldObj.provider.dimensionId, 1, xCoord, yCoord, zCoord);
+                }
+
+                if (progress >= progressNeeded)
+                {
+                    ItemStack flaskStack = inv[this.getPotionFlaskPosition()];
+                    //ItemStack ingredientStack = inv[this.getRegisteredPotionIngredientPosition()];
+                    ItemStack fillingAgent = inv[this.getFillingAgentPosition()];
+
+                    if (flaskStack == null || fillingAgent == null)
+                    {
+                        progress = 0;
+
+                        if (worldObj != null)
+                        {
+                            worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+                        }
+
+                        return;
+                    }
+
+                    //boolean isConcentration = ((ICatalyst)catalystStack.getItem()).isConcentration();
+                    int potionEffects = ((AlchemyFlask) flaskStack.getItem()).getNumberOfPotionEffects(flaskStack);
+                    int potionFillAmount = ((IFillingAgent) fillingAgent.getItem()).getFilledAmountForPotionNumber(potionEffects);
+                    flaskStack.setItemDamage(Math.max(0, flaskStack.getItemDamage() - potionFillAmount));
+                    //((AlchemyFlask)flaskStack.getItem()).addPotionEffect(flaskStack, Potion.regeneration.id, 1000);
+                    //if(successChance>worldObj.rand.nextFloat())
+                    this.setInventorySlotContents(6, flaskStack);
+                    this.decrStackSize(this.getPotionFlaskPosition(), 1);
+                    this.decrStackSize(this.getFillingAgentPosition(), 1);
+                    //this.decrStackSize(this.getRegisteredPotionIngredientPosition(), 1);
+                    progress = 0;
+
+                    if (worldObj != null)
+                    {
+                        worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+                    }
+                }
+            }
+        }
+        else if (this.containsPotionFlask() && this.containsCombinationCatalyst())
+        {
+            //TODO
+            if (getStackInSlot(6) == null && CombinedPotionRegistry.hasCombinablePotionEffect(inv[this.getPotionFlaskPosition()]))
+            {
+                progress++;
+
+                if (worldTime % 4 == 0)
+                {
+                    SpellHelper.sendIndexedParticleToAllAround(worldObj, xCoord, yCoord, zCoord, 20, worldObj.provider.dimensionId, 1, xCoord, yCoord, zCoord);
+                }
+
+                if (progress >= progressNeeded)
+                {
+                    ItemStack flaskStack = inv[this.getPotionFlaskPosition()];
+                    //ItemStack ingredientStack = inv[this.getRegisteredPotionIngredientPosition()];
+                    ItemStack combinationCatalyst = inv[this.getCombinationCatalystPosition()];
+
+                    if (flaskStack == null || combinationCatalyst == null)
+                    {
+                        progress = 0;
+
+                        if (worldObj != null)
+                        {
+                            worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+                        }
+
+                        return;
+                    }
+                    
+                    ItemStack newFlask = CombinedPotionRegistry.applyPotionEffect(flaskStack);
+                    if(newFlask != null)
+                    {
+                    	this.setInventorySlotContents(6, newFlask);
+                        this.decrStackSize(this.getPotionFlaskPosition(), 1);
+                        this.decrStackSize(this.getCombinationCatalystPosition(), 1);
+
+                        progress = 0;
+
+                        if (worldObj != null)
+                        {
+                            worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+                        }
+                    }
+                }
+            }
+        }
+        else
+        {
+            if (!isRecipeValid())
+            {
+                progress = 0;
+                return;
+            }
+
+            if (progress <= 0)
+            {
+                progress = 0;
+                amountUsed = this.getAmountNeeded(getStackInSlot(0));
+
+                if (worldObj != null)
+                {
+                    worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+                }
+            }
+            
+            int acceleration = this.getSpeedIncrease();
+
+            if (getStackInSlot(6) == null)
+            {
+                if (!EnergyItems.syphonWhileInContainer(getStackInSlot(0), amountUsed*acceleration))
+                {
+                    return;
+                }
+                
+                if (worldTime % 4 == 0)
+                {
+                    SpellHelper.sendIndexedParticleToAllAround(worldObj, xCoord, yCoord, zCoord, 20, worldObj.provider.dimensionId, 1, xCoord, yCoord, zCoord);
+                }
+
+                progress+=acceleration;
+
+                if (progress >= progressNeeded)
+                {
+                    progress = 0;
+                    this.setInventorySlotContents(6, getResultingItemStack());
+
+                    ItemStack[] composedRecipe = new ItemStack[5];
+
+                    for (int i = 0; i < 5; i++)
+                    {
+                        composedRecipe[i] = inv[i + 1];
+                    }
+
+                    this.decrementSlots(this.getRecipeForItems(composedRecipe, inv[0]));
+
+                    if (worldObj != null)
+                    {
+                        worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+                    }
+                }
+            } else if (getStackInSlot(6).getItem() == getResultingItemStack().getItem() && getResultingItemStack().stackSize <= (getStackInSlot(6).getMaxStackSize() - getStackInSlot(6).stackSize))
+            {
+                if (worldTime % 4 == 0)
+                {
+                    SpellHelper.sendIndexedParticleToAllAround(worldObj, xCoord, yCoord, zCoord, 20, worldObj.provider.dimensionId, 1, xCoord, yCoord, zCoord);
+                }
+
+                if (!EnergyItems.syphonWhileInContainer(getStackInSlot(0), amountUsed*acceleration))
+                {
+                    return;
+                }
+
+                progress+=acceleration;
+
+                if (progress >= progressNeeded)
+                {
+                    progress = 0;
+                    ItemStack result = getResultingItemStack().copy();
+                    result.stackSize += getStackInSlot(6).stackSize;
+                    this.setInventorySlotContents(6, result);
+                    
+                    ItemStack[] composedRecipe = new ItemStack[5];
+
+                    for (int i = 0; i < 5; i++)
+                    {
+                        composedRecipe[i] = inv[i + 1];
+                    }
+
+                    this.decrementSlots(this.getRecipeForItems(composedRecipe, inv[0]));
+
+                    if (worldObj != null)
+                    {
+                        worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+                    }
+                }
+            }
+        }
+
+        //worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+    }
+    
+    public void decrementSlots(ItemStack[] recipe) //TODO Fix this. This doesn't work.
+    {
+		boolean[] decrementedList = new boolean[]{false,false,false,false,false};
+		
+		for(int i=0; i<(Math.min(recipe.length,5)); i++)
+		{
+			ItemStack decStack = recipe[i];
+			
+			if(decStack == null)
+			{
+				continue;
+			}
+			
+			for(int j=0; j<5; j++)
+			{
+				ItemStack testStack = this.getStackInSlot(j+1);
+				
+				if(testStack != null && (testStack.isItemEqual(decStack) || (testStack.getItem() == decStack.getItem() && decStack.getItemDamage() == OreDictionary.WILDCARD_VALUE)) && !(decrementedList[j]))
+				{
+					if(testStack.getItem().hasContainerItem(testStack))
+					{
+						this.inv[j+1] = testStack.getItem().getContainerItem(testStack);
+					}else
+					{
+						this.decrStackSize(j+1, 1);
+					}
+					
+					decrementedList[j] = true;
+					break;
+				}
+			}
+		}	
+    }
+    
+    public ItemStack[] getRecipeForItems(ItemStack[] recipe, ItemStack bloodOrb)
+    {
+    	if (bloodOrb == null)
+        {
+            return null;
+        }
+
+        if (!(bloodOrb.getItem() instanceof IBloodOrb))
+        {
+            return null;
+        }
+
+        int bloodOrbLevel = ((IBloodOrb) bloodOrb.getItem()).getOrbLevel();
+
+        for (AlchemyRecipe ar : AlchemyRecipeRegistry.recipes)
+        {
+            if (ar.doesRecipeMatch(recipe, bloodOrbLevel))
+            {
+                return ar.getRecipe();
+            }
+        }
+
+        return null;
+    }
+    
+    public int getSpeedIncrease()
+    {
+    	return accelerationTime > 0 ? 5 : 1;
+    }
+    
+    public boolean isWorking()
+    {
+    	return this.progress > 0;
+    }
+    
+    public void setAccelerationTime(int accelerationTime)
+    {
+    	this.accelerationTime = accelerationTime;
+    }
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/container/ContainerAltar.java

@@ -0,0 +1,96 @@
+package WayofTime.alchemicalWizardry.common.tileEntity.container;
+
+import WayofTime.alchemicalWizardry.common.tileEntity.TEAltar;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.Container;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.ItemStack;
+
+public class ContainerAltar extends Container
+{
+    protected TEAltar tileEntity;
+
+    public ContainerAltar(InventoryPlayer inventoryPlayer, TEAltar te)
+    {
+        tileEntity = te;
+
+        for (int i = 0; i < 3; i++)
+        {
+            for (int j = 0; j < 3; j++)
+            {
+                addSlotToContainer(new Slot(tileEntity, j + i * 3, 62 + j * 18, 17 + i * 18));
+            }
+        }
+
+        bindPlayerInventory(inventoryPlayer);
+    }
+
+    @Override
+    public boolean canInteractWith(EntityPlayer entityplayer)
+    {
+        return tileEntity.isUseableByPlayer(entityplayer);
+    }
+
+    protected void bindPlayerInventory(InventoryPlayer inventoryPlayer)
+    {
+        for (int i = 0; i < 3; i++)
+        {
+            for (int j = 0; j < 9; j++)
+            {
+                addSlotToContainer(new Slot(inventoryPlayer, j + i * 9 + 9,
+                        8 + j * 18, 84 + i * 18));
+            }
+        }
+
+        for (int i = 0; i < 9; i++)
+        {
+            addSlotToContainer(new Slot(inventoryPlayer, i, 8 + i * 18, 142));
+        }
+    }
+
+    @Override
+    public ItemStack transferStackInSlot(EntityPlayer player, int slot)
+    {
+        ItemStack stack = null;
+        Slot slotObject = (Slot) inventorySlots.get(slot);
+
+        //null checks and checks if the item can be stacked (maxStackSize > 1)
+        if (slotObject != null && slotObject.getHasStack())
+        {
+            ItemStack stackInSlot = slotObject.getStack();
+            stack = stackInSlot.copy();
+
+            //merges the item into player inventory since its in the tileEntity
+            if (slot < 9)
+            {
+                if (!this.mergeItemStack(stackInSlot, 0, 35, true))
+                {
+                    return null;
+                }
+            }
+            //places it into the tileEntity is possible since its in the player inventory
+            else if (!this.mergeItemStack(stackInSlot, 0, 9, false))
+            {
+                return null;
+            }
+
+            if (stackInSlot.stackSize == 0)
+            {
+                slotObject.putStack(null);
+            } else
+            {
+                slotObject.onSlotChanged();
+            }
+
+            if (stackInSlot.stackSize == stack.stackSize)
+            {
+                return null;
+            }
+
+            slotObject.onPickupFromSlot(player, stackInSlot);
+        }
+
+        return stack;
+    }
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/container/ContainerTeleposer.java

@@ -0,0 +1,106 @@
+package WayofTime.alchemicalWizardry.common.tileEntity.container;
+
+import WayofTime.alchemicalWizardry.common.tileEntity.TETeleposer;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.Container;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.ItemStack;
+
+public class ContainerTeleposer extends Container
+{
+    protected TETeleposer tileEntity;
+
+    public ContainerTeleposer(InventoryPlayer inventoryPlayer, TETeleposer te)
+    {
+        tileEntity = te;
+        //the Slot constructor takes the IInventory and the slot number in that it binds to
+        //and the x-y coordinates it resides on-screen
+//            addSlotToContainer(new Slot(tileEntity, 0, 152, 110));
+//            addSlotToContainer(new Slot(tileEntity, 1, 80, 18));
+//            addSlotToContainer(new Slot(tileEntity, 2, 33, 52));
+//            addSlotToContainer(new Slot(tileEntity, 3, 51, 110));
+//            addSlotToContainer(new Slot(tileEntity, 4, 109, 110));
+//            addSlotToContainer(new Slot(tileEntity, 5, 127, 52));
+        addSlotToContainer(new Slot(tileEntity, 0, 80, 67));
+        //commonly used vanilla code that adds the player's inventory
+        bindPlayerInventory(inventoryPlayer);
+    }
+
+    @Override
+    public boolean canInteractWith(EntityPlayer player)
+    {
+        return tileEntity.isUseableByPlayer(player);
+    }
+
+    protected void bindPlayerInventory(InventoryPlayer inventoryPlayer)
+    {
+        for (int i = 0; i < 3; i++)
+        {
+            for (int j = 0; j < 9; j++)
+            {
+                addSlotToContainer(new Slot(inventoryPlayer, j + i * 9 + 9, 8 + j * 18, 140 + i * 18));
+            }
+        }
+
+        for (int i = 0; i < 9; i++)
+        {
+            addSlotToContainer(new Slot(inventoryPlayer, i, 8 + i * 18, 198));
+        }
+    }
+
+    @Override
+    public ItemStack transferStackInSlot(EntityPlayer player, int slot)
+    {
+        ItemStack stack = null;
+        Slot slotObject = (Slot) inventorySlots.get(slot);
+
+        //null checks and checks if the item can be stacked (maxStackSize > 1)
+        if (slotObject != null && slotObject.getHasStack())
+        {
+            ItemStack stackInSlot = slotObject.getStack();
+            stack = stackInSlot.copy();
+
+            if (slot == 7)
+            {
+                if (!this.mergeItemStack(stackInSlot, 7, 35, true))
+                {
+                    return null;
+                }
+
+                slotObject.onSlotChange(stackInSlot, stack);
+            }
+
+            //merges the item into player inventory since its in the tileEntity
+            if (slot < 1)
+            {
+                if (!this.mergeItemStack(stackInSlot, 7, 35, true))
+                {
+                    return null;
+                }
+            }
+            //places it into the tileEntity is possible since its in the player inventory
+            else if (!this.mergeItemStack(stackInSlot, 0, 0, false))
+            {
+                return null;
+            }
+
+            if (stackInSlot.stackSize == 0)
+            {
+                slotObject.putStack(null);
+            } else
+            {
+                slotObject.onSlotChanged();
+            }
+
+            if (stackInSlot.stackSize == stack.stackSize)
+            {
+                return null;
+            }
+
+            slotObject.onPickupFromSlot(player, stackInSlot);
+        }
+
+        return stack;
+    }
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/container/ContainerWritingTable.java

@@ -0,0 +1,104 @@
+package WayofTime.alchemicalWizardry.common.tileEntity.container;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.Container;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.ItemStack;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IBloodOrb;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEWritingTable;
+
+public class ContainerWritingTable extends Container
+{
+    protected TEWritingTable tileEntity;
+
+    public ContainerWritingTable(InventoryPlayer inventoryPlayer, TEWritingTable te)
+    {
+        tileEntity = te;
+        //the Slot constructor takes the IInventory and the slot number in that it binds to
+        //and the x-y coordinates it resides on-screen
+        addSlotToContainer(new Slot(tileEntity, 0, 152, 110));
+        addSlotToContainer(new Slot(tileEntity, 1, 80, 18));
+        addSlotToContainer(new Slot(tileEntity, 2, 33, 52));
+        addSlotToContainer(new Slot(tileEntity, 3, 51, 110));
+        addSlotToContainer(new Slot(tileEntity, 4, 109, 110));
+        addSlotToContainer(new Slot(tileEntity, 5, 127, 52));
+        addSlotToContainer(new Slot(tileEntity, 6, 80, 67));
+        //commonly used vanilla code that adds the player's inventory
+        bindPlayerInventory(inventoryPlayer);
+    }
+
+    @Override
+    public boolean canInteractWith(EntityPlayer player)
+    {
+        return tileEntity.isUseableByPlayer(player);
+    }
+
+    protected void bindPlayerInventory(InventoryPlayer inventoryPlayer)
+    {
+        for (int i = 0; i < 3; i++)
+        {
+            for (int j = 0; j < 9; j++)
+            {
+                addSlotToContainer(new Slot(inventoryPlayer, j + i * 9 + 9, 8 + j * 18, 140 + i * 18));
+            }
+        }
+
+        for (int i = 0; i < 9; i++)
+        {
+            addSlotToContainer(new Slot(inventoryPlayer, i, 8 + i * 18, 198));
+        }
+    }
+
+    @Override
+    public ItemStack transferStackInSlot(EntityPlayer player, int slot)
+    {
+        ItemStack stack = null;
+        Slot slotObject = (Slot) inventorySlots.get(slot);
+
+        //null checks and checks if the item can be stacked (maxStackSize > 1)
+        if (slotObject != null && slotObject.getHasStack())
+        {
+            ItemStack stackInSlot = slotObject.getStack();
+            stack = stackInSlot.copy();
+
+            //merges the item into player inventory since its in the tileEntity
+            if (slot <= 6)
+            {
+                if (!this.mergeItemStack(stackInSlot, 7, 43, true))
+                {
+                    return null;
+                }
+            }
+            else if(stack.getItem() instanceof IBloodOrb)
+            {
+            	if (!this.mergeItemStack(stackInSlot, 0, 1, false))
+                {
+                    return null;
+                }
+            }
+            //places it into the tileEntity is possible since its in the player inventory
+            else if (!this.mergeItemStack(stackInSlot, 1, 6, false))
+            {
+                return null;
+            }
+
+            if (stackInSlot.stackSize == 0)
+            {
+                slotObject.putStack(null);
+            } else
+            {
+                slotObject.onSlotChanged();
+            }
+
+            if (stackInSlot.stackSize == stack.stackSize)
+            {
+                return null;
+            }
+
+            slotObject.onPickupFromSlot(player, stackInSlot);
+        }
+
+        return stack;
+    }
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/gui/GuiHandler.java

@@ -0,0 +1,73 @@
+package WayofTime.alchemicalWizardry.common.tileEntity.gui;
+
+import WayofTime.alchemicalWizardry.common.tileEntity.TETeleposer;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEWritingTable;
+import WayofTime.alchemicalWizardry.common.tileEntity.container.ContainerTeleposer;
+import WayofTime.alchemicalWizardry.common.tileEntity.container.ContainerWritingTable;
+import cpw.mods.fml.common.network.IGuiHandler;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+
+public class GuiHandler implements IGuiHandler
+{
+    //returns an instance of the Container you made earlier
+    @Override
+    public Object getServerGuiElement(int id, EntityPlayer player, World world, int x, int y, int z)
+    {
+        TileEntity tileEntity;
+
+        switch (id)
+        {
+            case 0:
+                tileEntity = world.getTileEntity(x, y, z);
+
+                if (tileEntity instanceof TEWritingTable)
+                {
+                    return new ContainerWritingTable(player.inventory, (TEWritingTable) tileEntity);
+                }
+
+            case 1:
+                tileEntity = world.getTileEntity(x, y, z);
+
+                if (tileEntity instanceof TETeleposer)
+                {
+                    return new ContainerTeleposer(player.inventory, (TETeleposer) tileEntity);
+                }
+        }
+
+        return null;
+    }
+
+    //returns an instance of the Gui you made earlier
+    @Override
+    public Object getClientGuiElement(int id, EntityPlayer player, World world, int x, int y, int z)
+    {
+        TileEntity tileEntity;
+
+        switch (id)
+        {
+            case 0:
+                tileEntity = world.getTileEntity(x, y, z);
+
+                if (tileEntity instanceof TEWritingTable)
+                {
+                    return new GuiWritingTable(player.inventory, (TEWritingTable) tileEntity);
+                }
+
+                break;
+
+            case 1:
+                tileEntity = world.getTileEntity(x, y, z);
+
+                if (tileEntity instanceof TETeleposer)
+                {
+                    return new GuiTeleposer(player.inventory, (TETeleposer) tileEntity);
+                }
+
+                break;
+        }
+
+        return null;
+    }
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/gui/GuiTeleposer.java

@@ -0,0 +1,47 @@
+package WayofTime.alchemicalWizardry.common.tileEntity.gui;
+
+import net.minecraft.client.gui.inventory.GuiBrewingStand;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.StatCollector;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.common.tileEntity.TETeleposer;
+import WayofTime.alchemicalWizardry.common.tileEntity.container.ContainerTeleposer;
+
+public class GuiTeleposer extends GuiContainer
+{
+    public GuiTeleposer(InventoryPlayer inventoryPlayer, TETeleposer tileEntity)
+    {
+        //the container is instanciated and passed to the superclass for handling
+        super(new ContainerTeleposer(inventoryPlayer, tileEntity));
+        xSize = 176;
+        ySize = 222;
+    }
+
+    @Override
+    protected void drawGuiContainerForegroundLayer(int param1, int param2)
+    {
+        //draw text and stuff here
+        //the parameters for drawString are: string, x, y, color
+        fontRendererObj.drawString("Teleposer", 8, 6, 4210752);
+        //draws "Inventory" or your regional equivalent
+        fontRendererObj.drawString(StatCollector.translateToLocal("container.inventory"), 8, 130, 4210752);
+    }
+
+    @Override
+    protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3)
+    {
+        //draw your Gui here, only thing you need to change is the path
+        //ResourceLocation texture = mc.renderEngine.getTexture("/gui/trap.png");
+        ResourceLocation test = new ResourceLocation("alchemicalwizardry", "gui/Teleposer.png");
+        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+        this.mc.getTextureManager().bindTexture(test);
+        int x = (width - xSize) / 2;
+        int y = (height - ySize) / 2;
+        this.drawTexturedModalRect(x, y, 0, 0, xSize, ySize);
+        GuiBrewingStand d;
+    }
+}

src-backup/main/java/WayofTime/alchemicalWizardry/common/tileEntity/gui/GuiWritingTable.java

@@ -0,0 +1,45 @@
+package WayofTime.alchemicalWizardry.common.tileEntity.gui;
+
+import WayofTime.alchemicalWizardry.common.tileEntity.TEWritingTable;
+import WayofTime.alchemicalWizardry.common.tileEntity.container.ContainerWritingTable;
+import net.minecraft.client.gui.inventory.GuiBrewingStand;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.StatCollector;
+import org.lwjgl.opengl.GL11;
+
+public class GuiWritingTable extends GuiContainer
+{
+    public GuiWritingTable(InventoryPlayer inventoryPlayer, TEWritingTable tileEntity)
+    {
+        //the container is instanciated and passed to the superclass for handling
+        super(new ContainerWritingTable(inventoryPlayer, tileEntity));
+        xSize = 176;
+        ySize = 222;
+    }
+
+    @Override
+    protected void drawGuiContainerForegroundLayer(int param1, int param2)
+    {
+        //draw text and stuff here
+        //the parameters for drawString are: string, x, y, color
+        fontRendererObj.drawString("Alchemic Chemistry Set", 8, 6, 4210752);
+        //draws "Inventory" or your regional equivalent
+        fontRendererObj.drawString(StatCollector.translateToLocal("container.inventory"), 8, 130, 4210752);
+    }
+
+    @Override
+    protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3)
+    {
+        //draw your Gui here, only thing you need to change is the path
+        //ResourceLocation texture = mc.renderEngine.getTexture("/gui/trap.png");
+        ResourceLocation test = new ResourceLocation("alchemicalwizardry", "gui/WritingTable.png");
+        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+        this.mc.getTextureManager().bindTexture(test);
+        int x = (width - xSize) / 2;
+        int y = (height - ySize) / 2;
+        this.drawTexturedModalRect(x, y, 0, 0, xSize, ySize);
+        GuiBrewingStand d;
+    }
+}