Initial commit

src/main/java/electroblob/wizardry/tileentity/ContainerArcaneWorkbench.java

@@ -0,0 +1,265 @@
+package electroblob.wizardry.tileentity;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.item.ItemArcaneTome;
+import electroblob.wizardry.item.ItemArmourUpgrade;
+import electroblob.wizardry.item.ItemSpellBook;
+import electroblob.wizardry.item.ItemWand;
+import electroblob.wizardry.item.ItemWizardArmour;
+import electroblob.wizardry.registry.WizardryItems;
+import electroblob.wizardry.util.WandHelper;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.Container;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+
+public class ContainerArcaneWorkbench extends Container {
+
+	public TileEntityArcaneWorkbench tileEntityArcaneWorkbench;
+
+	public static final ResourceLocation EMPTY_SLOT_CRYSTAL = new ResourceLocation(Wizardry.MODID, "gui/empty_slot_crystal");
+	public static final ResourceLocation EMPTY_SLOT_UPGRADE = new ResourceLocation(Wizardry.MODID, "gui/empty_slot_upgrade");
+
+	public static final int CRYSTAL_SLOT = 8;
+	public static final int WAND_SLOT = 9;
+	public static final int UPGRADE_SLOT = 10;
+	private static final int[][][] SPELL_BOOK_SLOT_COORDS = {
+			{{80, 22}, {121, 51}, {106, 98}, {54, 98}, {39, 51}, {-999, -999}, {-999, -999}, {-999, -999}},
+			{{80, 22}, {117, 43}, {117, 85}, {80, 106}, {43, 85}, {43, 43}, {-999, -999}, {-999, -999}},
+			{{80, 22}, {113, 38}, {121, 74}, {98, 102}, {62, 102}, {39, 74}, {47, 38}, {-999, -999}},
+			{{80, 22}, {111, 33}, {122, 64}, {111, 95}, {80, 106}, {49, 95}, {38, 64}, {49, 33}}
+	};
+
+	public ContainerArcaneWorkbench(IInventory inventory, TileEntityArcaneWorkbench tileentity){
+
+		this.tileEntityArcaneWorkbench = tileentity;
+
+		ItemStack wand = tileentity.getStackInSlot(WAND_SLOT);
+
+		for(int i=0; i<8; i++){
+			this.addSlotToContainer(new SlotItemList(tileentity, i, -999, -999, 1, WizardryItems.spell_book));
+		}
+
+		this.addSlotToContainer(new SlotItemList(tileentity, CRYSTAL_SLOT, 8, 88, 64, WizardryItems.magic_crystal))
+			.setBackgroundName(EMPTY_SLOT_CRYSTAL.toString());
+		
+		this.addSlotToContainer(new SlotWandArmour(tileentity, WAND_SLOT, 80, 64, this));
+		
+		Set<Item> upgrades = new HashSet<Item>(WandHelper.getSpecialUpgrades());
+		upgrades.add(WizardryItems.arcane_tome);
+		upgrades.add(WizardryItems.armour_upgrade);
+		
+		this.addSlotToContainer(new SlotItemList(tileentity, UPGRADE_SLOT, 8, 106, 1, upgrades.toArray(new Item[0])))
+			.setBackgroundName(EMPTY_SLOT_UPGRADE.toString());
+
+		for(int x = 0; x < 9; x++){
+			this.addSlotToContainer(new Slot(inventory, x, 8 + x * 18, 196));
+		}
+
+		for(int y = 0; y < 3; y++){
+			for(int x = 0; x < 9; x++){
+				this.addSlotToContainer(new Slot(inventory, 9 + x + y * 9, 8 + x * 18, 138 + y * 18));
+			}
+		}
+
+		this.onSlotChanged(WAND_SLOT, wand, null);
+	}
+
+	@Override
+	public boolean canInteractWith(EntityPlayer par1EntityPlayer)
+	{
+		return this.tileEntityArcaneWorkbench.isUseableByPlayer(par1EntityPlayer);
+	}
+
+	/**
+	 * Called from the central wand/armour slot when its item is changed or removed.
+	 */
+	// I wrote this!
+	public void onSlotChanged(int slotNumber, ItemStack stack, EntityPlayer player){
+		
+		if(slotNumber == WAND_SLOT){
+
+			if(stack == null || (!(stack.getItem() instanceof ItemWand) && stack.getItem() != WizardryItems.blank_scroll)){
+				// If the stack has been removed
+				for(int i=0; i<CRYSTAL_SLOT; i++){
+					Slot slot1 = this.getSlot(i);
+					// 'Removes' the slot from the container (moves it off the screen)
+					slot1.xDisplayPosition = -100;
+					slot1.yDisplayPosition = -100;
+
+					ItemStack stack1 = slot1.getStack();
+					// This doesn't cause an infinite loop because slot i can never be a SlotWandArmour. In effect, it's
+					// exactly the same as shift-clicking the slot, so why re-invent the wheel?
+					ItemStack remainder = this.transferStackInSlot(player, i);
+
+					if(remainder == null && stack1 != null){
+						slot1.putStack(null);
+						// The second parameter is never used...
+						if(player != null) player.dropItem(stack1, false);
+					}
+				}
+
+			}else{
+
+				if(stack.getItem() == WizardryItems.blank_scroll){
+					// If a blank scroll is added
+					// The first slot is shown
+					this.getSlot(0).xDisplayPosition = ContainerArcaneWorkbench.SPELL_BOOK_SLOT_COORDS[0][0][0];
+					this.getSlot(0).yDisplayPosition = ContainerArcaneWorkbench.SPELL_BOOK_SLOT_COORDS[0][0][1];
+
+					// The rest of the slots are hidden
+					for(int i=1; i<CRYSTAL_SLOT; i++){
+
+						Slot slot1 = this.getSlot(i);
+
+						slot1.xDisplayPosition = -100;
+						slot1.yDisplayPosition = -100;
+
+						ItemStack stack1 = slot1.getStack();
+						// This doesn't cause an infinite loop because slot i can never be a SlotWandArmour. In effect, it's
+						// exactly the same as shift-clicking the slot, so why re-invent the wheel?
+						ItemStack remainder = this.transferStackInSlot(player, i);
+
+						if(remainder == null && stack1 != null){
+							slot1.putStack(null);
+							// The second parameter is never used...
+							if(player != null) player.dropItem(stack1, false);
+						}
+					}
+
+				}else{
+
+					for(int i=0; i<CRYSTAL_SLOT; i++){
+
+						int n = WandHelper.getUpgradeLevel(stack, WizardryItems.attunement_upgrade);
+						int[] coords = ContainerArcaneWorkbench.SPELL_BOOK_SLOT_COORDS[n][i];
+
+						Slot slot1 = this.getSlot(i);
+						// Puts the slot back in the correct position
+						slot1.xDisplayPosition = coords[0];
+						slot1.yDisplayPosition = coords[1];
+
+						if(slot1.xDisplayPosition < 0 || slot1.yDisplayPosition < 0){
+
+							ItemStack stack1 = slot1.getStack();
+							// This doesn't cause an infinite loop because slot i can never be a SlotWandArmour. In effect, it's
+							// exactly the same as shift-clicking the slot, so why re-invent the wheel?
+							ItemStack remainder = this.transferStackInSlot(player, i);
+
+							if(remainder == null && stack1 != null){
+								slot1.putStack(null);
+								// The second parameter is never used...
+								if(player != null) player.dropItem(stack1, false);
+							}
+						}
+					}
+				}
+			}
+		}
+
+		// FIXME: It only seems to be syncing correctly when a stack is put into the slot, not taken out.
+		// Was this broken in 1.7.10 as well?
+		this.tileEntityArcaneWorkbench.sync();
+	}
+
+	@Override
+	public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int clickedSlotId)
+	{
+		ItemStack remainder = null;
+		Slot slot = (Slot)this.inventorySlots.get(clickedSlotId);
+
+		if (slot != null && slot.getHasStack())
+		{
+			ItemStack itemstack = slot.getStack(); // The stack that was there originally
+			remainder = itemstack.copy(); // A copy of that stack
+
+			// Workbench -> inventory
+			if(clickedSlotId <= UPGRADE_SLOT){
+				// Tries to move the stack into the player's inventory. If this fails...
+				if (!this.mergeItemStack(itemstack, UPGRADE_SLOT + 1, this.inventorySlots.size(), true)){
+					return null; // ...nothing else happens.
+				}
+
+				// Inventory -> workbench
+			}else{
+				// The following logic prevents shift-clicking transferring the items to the wrong slot.
+				int minSlotId = 0;
+				int maxSlotId = UPGRADE_SLOT;
+
+				if(itemstack.getItem() instanceof ItemSpellBook){
+					minSlotId = 0;
+					maxSlotId = CRYSTAL_SLOT-1;
+				}
+				else if(itemstack.getItem() == WizardryItems.magic_crystal){
+					minSlotId = CRYSTAL_SLOT;
+					maxSlotId = CRYSTAL_SLOT;
+				}
+				else if(itemstack.getItem() instanceof ItemWand || itemstack.getItem() instanceof ItemWizardArmour
+						|| itemstack.getItem() == WizardryItems.blank_scroll){
+					minSlotId = WAND_SLOT;
+					maxSlotId = WAND_SLOT;
+				}
+				else if(itemstack.getItem() instanceof ItemArcaneTome
+						|| itemstack.getItem() instanceof ItemArmourUpgrade
+						|| itemstack.getItem() == WizardryItems.condenser_upgrade
+						|| itemstack.getItem() == WizardryItems.siphon_upgrade
+						|| itemstack.getItem() == WizardryItems.range_upgrade
+						|| itemstack.getItem() == WizardryItems.cooldown_upgrade
+						|| itemstack.getItem() == WizardryItems.duration_upgrade
+						|| itemstack.getItem() == WizardryItems.storage_upgrade
+						|| itemstack.getItem() == WizardryItems.blast_upgrade
+						|| itemstack.getItem() == WizardryItems.attunement_upgrade){
+					minSlotId = UPGRADE_SLOT;
+					maxSlotId = UPGRADE_SLOT;
+				}
+				else{
+					return null; // If none of the above cases were true, then the item won't fit in the workbench.
+				}
+
+				if(!this.mergeItemStack(itemstack, minSlotId, maxSlotId + 1, false))
+				{
+					return null;
+				}
+			}
+
+			if (itemstack.stackSize == 0)
+			{
+				slot.putStack((ItemStack)null);
+			}
+			else
+			{
+				slot.onSlotChanged();
+			}
+
+			if (itemstack.stackSize == remainder.stackSize)
+			{
+				return null;
+			}
+
+			slot.onPickupFromSlot(par1EntityPlayer, itemstack);
+		}
+
+		return remainder;
+	}
+
+	// Overridden to stop stacks merging into 'removed' slots.
+	@Override
+	protected boolean mergeItemStack(ItemStack stack, int minSlotID, int maxSlotID, boolean p_75135_4_) {
+
+		for(int i=minSlotID; i<maxSlotID; i++){
+			//System.out.println(this.getSlot(i).xDisplayPosition);
+			if(this.getSlot(i).xDisplayPosition >= 0 && this.getSlot(i).yDisplayPosition >= 0 && !this.getSlot(i).getHasStack()){
+				return super.mergeItemStack(stack, minSlotID, maxSlotID, p_75135_4_);
+			}
+		}
+		// Only returns false if none of the slots given are enabled and empty
+		return false;
+	}
+
+}

src/main/java/electroblob/wizardry/tileentity/ContainerPortableWorkbench.java

@@ -0,0 +1,23 @@
+package electroblob.wizardry.tileentity;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.ContainerWorkbench;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+public class ContainerPortableWorkbench extends ContainerWorkbench {
+
+	public ContainerPortableWorkbench(InventoryPlayer inventory, World world, BlockPos pos) {
+		
+		super(inventory, world, pos);
+	}
+
+	// Overriden to stop the crafting gui from closing when there is no crafting table.
+	@Override
+	public boolean canInteractWith(EntityPlayer player)
+    {
+        return true;
+    }
+	
+}

src/main/java/electroblob/wizardry/tileentity/SlotItemList.java

@@ -0,0 +1,36 @@
+package electroblob.wizardry.tileentity;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+
+/**
+ * Simple extension of {@link Slot} which only accepts items from an array defined in the constructor.
+ * @author Electroblob
+ * @since Wizardry 1.0
+ */
+public class SlotItemList extends Slot {
+	
+	private Item[] items;
+	private int stackLimit;
+
+	public SlotItemList(IInventory par1iInventory, int index, int x, int y, int stackLimit, Item... allowedItems) {
+		super(par1iInventory, index, x, y);
+		this.items = allowedItems;
+		this.stackLimit = stackLimit;
+	}
+	
+	public int getSlotStackLimit(){
+        return stackLimit;
+    }
+	
+	public boolean isItemValid(ItemStack par1ItemStack){
+		for(int i=0; i<items.length; i++){
+			if(par1ItemStack != null && (par1ItemStack.getItem() == this.items[i])){
+				return true;
+			}
+    	}
+		return false;
+    }
+}

src/main/java/electroblob/wizardry/tileentity/SlotWandArmour.java

@@ -0,0 +1,49 @@
+package electroblob.wizardry.tileentity;
+
+import electroblob.wizardry.item.ItemWand;
+import electroblob.wizardry.item.ItemWizardArmour;
+import electroblob.wizardry.registry.WizardryItems;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.ItemStack;
+
+/**
+ * The central wand/armour/scroll slot in the arcane workbench GUI.
+ * @author Electroblob
+ * @since Wizardry 1.0
+ */
+public class SlotWandArmour extends Slot {
+	
+	private ContainerArcaneWorkbench container;
+
+	public SlotWandArmour(IInventory par1iInventory, int index, int x, int y, ContainerArcaneWorkbench container) {
+		super(par1iInventory, index, x, y);
+		this.container = container;
+	}
+	
+	@Override
+	public void putStack(ItemStack stack){
+		super.putStack(stack);
+		this.container.onSlotChanged(slotNumber, stack, null);
+	}
+	
+	@Override
+	public void onPickupFromSlot(EntityPlayer player, ItemStack stack) {
+		super.onPickupFromSlot(player, stack);
+		this.container.onSlotChanged(slotNumber, null, player);
+	}
+	
+	@Override
+	public int getSlotStackLimit()
+    {
+        return 1;
+    }
+	
+	@Override
+	public boolean isItemValid(ItemStack itemstack){
+		return itemstack != null && (itemstack.getItem() instanceof ItemWand
+				|| itemstack.getItem() instanceof ItemWizardArmour
+				|| itemstack.getItem() == WizardryItems.blank_scroll);
+    }
+}

src/main/java/electroblob/wizardry/tileentity/TileEntityArcaneWorkbench.java

@@ -0,0 +1,481 @@
+package electroblob.wizardry.tileentity;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import electroblob.wizardry.WizardData;
+import electroblob.wizardry.constants.Constants;
+import electroblob.wizardry.constants.Tier;
+import electroblob.wizardry.item.ItemWand;
+import electroblob.wizardry.item.ItemWizardArmour;
+import electroblob.wizardry.registry.Spells;
+import electroblob.wizardry.registry.WizardryAchievements;
+import electroblob.wizardry.registry.WizardryBlocks;
+import electroblob.wizardry.registry.WizardryItems;
+import electroblob.wizardry.spell.Spell;
+import electroblob.wizardry.util.WandHelper;
+import electroblob.wizardry.util.WizardryUtilities;
+import net.minecraft.block.Block;
+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.NetworkManager;
+import net.minecraft.network.play.server.SPacketUpdateTileEntity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ITickable;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraftforge.common.util.Constants.NBT;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public class TileEntityArcaneWorkbench extends TileEntity implements IInventory, ITickable {
+
+	private ItemStack[] inv;
+	/** Controls the rotation of the rune. */
+	public float timer = 0;
+	/** Controls the change of yOffset. */
+	public int yTimer = 0;
+	/** Controls the height of the wand. */
+	public int yOffset = 300;
+
+	public TileEntityArcaneWorkbench(){
+		inv = new ItemStack[ContainerArcaneWorkbench.UPGRADE_SLOT + 1];
+	}
+	
+	@Override
+	public void onLoad(){
+		timer = 0;
+		yTimer = 0;
+		yOffset = 300;
+	}
+	
+	/** Called to manually sync the tile entity with clients. */
+	public void sync(){
+		this.worldObj.notifyBlockUpdate(pos, worldObj.getBlockState(pos), worldObj.getBlockState(pos), 3);
+	}
+
+	@Override
+	public void update(){
+
+		ItemStack itemstack = this.getStackInSlot(ContainerArcaneWorkbench.WAND_SLOT);
+
+		// Decrements wand damage (increases mana) every 1.5 seconds if it has a condenser upgrade
+		if(itemstack != null && itemstack.getItem() instanceof ItemWand && !this.worldObj.isRemote && itemstack.isItemDamaged()
+				&& this.worldObj.getWorldTime() % electroblob.wizardry.constants.Constants.CONDENSER_TICK_INTERVAL == 0){
+			// If the upgrade level is 0, this does nothing anyway.
+			itemstack.setItemDamage(itemstack.getItemDamage() - WandHelper.getUpgradeLevel(itemstack, WizardryItems.condenser_upgrade));
+		}
+
+		// The server doesn't care what these are, and there's no need for them to be synced or saved.
+		if(this.worldObj.isRemote){
+			if(timer < 359){
+				timer++;
+			}else{
+				timer = 0;
+			}
+			if(yOffset > 0){
+				yTimer--;
+			}else{
+				yTimer++;
+			}
+			yOffset += yTimer;
+		}
+	}
+
+	@Override
+	public int getSizeInventory() {
+		return inv.length;
+	}
+
+	@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 removeStackFromSlot(int slot) {
+		ItemStack stack = getStackInSlot(slot);
+		if (stack != null) {
+			setInventorySlotContents(slot, null);
+		}
+		return stack;
+	}
+
+	@Override
+	public void setInventorySlotContents(int slot, ItemStack stack) {
+		inv[slot] = stack;
+		if (stack != null && stack.stackSize > getInventoryStackLimit()) {
+			stack.stackSize = getInventoryStackLimit();
+		}               
+	}
+
+	@Override
+	public String getName() {
+		return "container.wizardry:arcane_workbench";
+	}
+
+	@Override
+	public boolean hasCustomName() {
+		return false;
+	}
+
+	@Override
+	public int getInventoryStackLimit() {
+		return 64;
+	}
+
+	@Override
+	public boolean isUseableByPlayer(EntityPlayer player) {
+		return worldObj.getTileEntity(pos) == this && player.getDistanceSqToCenter(pos) < 64;
+	}
+
+	@Override
+	public void openInventory(EntityPlayer player) {
+
+	}
+
+	@Override
+	public void closeInventory(EntityPlayer player) {
+
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int slotNumber, ItemStack itemstack) {
+
+		if(itemstack == null) return true;
+
+		if(slotNumber >= 0 && slotNumber < ContainerArcaneWorkbench.CRYSTAL_SLOT){
+			return itemstack.getItem() == WizardryItems.spell_book;
+
+		}else if(slotNumber == ContainerArcaneWorkbench.CRYSTAL_SLOT){
+			return itemstack.getItem() == WizardryItems.magic_crystal;
+
+		}else if(slotNumber == ContainerArcaneWorkbench.WAND_SLOT){
+			return itemstack != null && (itemstack.getItem() instanceof ItemWand
+					|| itemstack.getItem() instanceof ItemWizardArmour
+					|| itemstack.getItem() == WizardryItems.blank_scroll);
+
+		}else if(slotNumber == ContainerArcaneWorkbench.UPGRADE_SLOT){
+			Set<Item> upgrades = new HashSet<Item>(WandHelper.getSpecialUpgrades());
+			upgrades.add(WizardryItems.arcane_tome);
+			upgrades.add(WizardryItems.armour_upgrade);
+			return upgrades.contains(itemstack.getItem());
+		}
+
+		return true;
+
+	}
+	@Override
+	public void readFromNBT(NBTTagCompound tagCompound){
+		
+		super.readFromNBT(tagCompound);
+
+		NBTTagList tagList = tagCompound.getTagList("Inventory", 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);
+			}
+		}
+
+//		timer = tagCompound.getFloat("timer");
+//		yTimer = tagCompound.getInteger("yTimer");
+//		yOffset = tagCompound.getInteger("yOffset");
+	}
+
+	@Override
+	public NBTTagCompound 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.setFloat("timer", timer);
+//		tagCompound.setInteger("yTimer", yTimer);
+//		tagCompound.setInteger("yOffset", yOffset);
+
+		return tagCompound;
+	}
+	
+	@Override
+	public final NBTTagCompound getUpdateTag(){
+		return this.writeToNBT(new NBTTagCompound());
+	}
+
+	@Override
+	public SPacketUpdateTileEntity getUpdatePacket(){
+		return new SPacketUpdateTileEntity(pos, getBlockMetadata(), this.getUpdateTag());
+	}
+
+	@Override
+	public void onDataPacket(NetworkManager net, SPacketUpdateTileEntity pkt) {
+		readFromNBT(pkt.getNbtCompound());
+	}
+
+	@SideOnly(Side.CLIENT)
+	public AxisAlignedBB getRenderBoundingBox()
+	{
+		AxisAlignedBB bb = INFINITE_EXTENT_AABB;
+		Block type = getBlockType();
+		if (type == WizardryBlocks.arcane_workbench)
+		{
+			bb = new AxisAlignedBB(pos, pos.add(1, 1, 1));
+		}
+		else if (type != null)
+		{
+			AxisAlignedBB cbb = this.getWorld().getBlockState(pos).getBoundingBox(worldObj, pos);
+			if (cbb != null)
+			{
+				bb = cbb;
+			}
+		}
+		return bb;
+	}
+
+	// What are all these for?
+
+	@Override
+	public int getField(int id) {
+		return 0;
+	}
+
+	@Override
+	public void setField(int id, int value) {
+
+	}
+
+	@Override
+	public int getFieldCount() {
+		return 0;
+	}
+
+	@Override
+	public void clear() {
+		for(int i=0; i<this.inv.length; i++){
+			this.inv[i] = null;
+		}
+	}
+
+	/** Called (via {@link electroblob.wizardry.packet.PacketControlInput PacketControlInput}) when the apply button
+	 * in the arcane workbench GUI is pressed. */
+	// IDEA: Perhaps this should be in the container class?
+	public void onApplyButtonPressed(EntityPlayer player){
+
+		ItemStack wand = this.getStackInSlot(ContainerArcaneWorkbench.WAND_SLOT);
+		ItemStack[] spellBooks = new ItemStack[ContainerArcaneWorkbench.CRYSTAL_SLOT];
+		for(int i=0; i<spellBooks.length; i++){
+			spellBooks[i] = this.getStackInSlot(i);
+		}
+		ItemStack crystals = this.getStackInSlot(ContainerArcaneWorkbench.CRYSTAL_SLOT);
+		ItemStack upgrade = this.getStackInSlot(ContainerArcaneWorkbench.UPGRADE_SLOT);
+		
+		// TODO: Implement this
+		//if(MinecraftForge.EVENT_BUS.post(new SpellBindEvent(player))) return;
+
+		// Since the workbench now accepts armour as well as wands, this check is needed.
+		if(wand != null && wand.getItem() instanceof ItemWand){
+
+			// Upgrades wand if necessary. Damage is copied, preserving remaining durability,
+			// and also the entire NBT tag compound.
+			if(upgrade != null){
+
+				if(upgrade.getItem() == WizardryItems.arcane_tome){
+
+					ItemStack newWand;
+
+					switch(Tier.values()[upgrade.getItemDamage()]){
+
+					case APPRENTICE: 
+						if(((ItemWand)wand.getItem()).tier == Tier.BASIC){
+							newWand = new ItemStack(WizardryUtilities.getWand(Tier.values()[upgrade.getItemDamage()], ((ItemWand)wand.getItem()).element));
+							newWand.setTagCompound(wand.getTagCompound());
+							// This needs to be done after copying the tag compound so the max damage for the new wand takes storage
+							// upgrades into account.
+							newWand.setItemDamage(newWand.getMaxDamage() - (wand.getMaxDamage() - wand.getItemDamage()));
+							this.setInventorySlotContents(ContainerArcaneWorkbench.WAND_SLOT, newWand);
+							this.setInventorySlotContents(ContainerArcaneWorkbench.UPGRADE_SLOT, null);
+							player.addStat(WizardryAchievements.apprentice, 1);
+						}
+						break;
+
+					case ADVANCED: 
+						if(((ItemWand)wand.getItem()).tier == Tier.APPRENTICE){
+							newWand = new ItemStack(WizardryUtilities.getWand(Tier.values()[upgrade.getItemDamage()], ((ItemWand)wand.getItem()).element));
+							newWand.setTagCompound(wand.getTagCompound());
+							newWand.setItemDamage(newWand.getMaxDamage() - (wand.getMaxDamage() - wand.getItemDamage()));
+							this.setInventorySlotContents(ContainerArcaneWorkbench.WAND_SLOT, newWand);
+							this.setInventorySlotContents(ContainerArcaneWorkbench.UPGRADE_SLOT, null);
+						}
+						break;
+
+					case MASTER:
+						if(((ItemWand)wand.getItem()).tier == Tier.ADVANCED){
+							newWand = new ItemStack(WizardryUtilities.getWand(Tier.values()[upgrade.getItemDamage()], ((ItemWand)wand.getItem()).element));
+							newWand.setTagCompound(wand.getTagCompound());
+							newWand.setItemDamage(newWand.getMaxDamage() - (wand.getMaxDamage() - wand.getItemDamage()));
+							this.setInventorySlotContents(ContainerArcaneWorkbench.WAND_SLOT, newWand);
+							this.setInventorySlotContents(ContainerArcaneWorkbench.UPGRADE_SLOT, null);
+							player.addStat(WizardryAchievements.master, 1);
+						}
+						break;
+
+					default:
+						break;
+					}
+
+					// This needs to happen so the charging works on the new wand, not the old one.
+					wand = this.getStackInSlot(ContainerArcaneWorkbench.WAND_SLOT);
+
+				}else{
+
+					// Special upgrades
+
+					// Used to preserve existing mana when upgrading storage rather than creating free mana.
+					int prevMana = wand.getMaxDamage() - wand.getItemDamage();
+
+					if(WandHelper.getTotalUpgrades(wand) < ((ItemWand)wand.getItem()).tier.upgradeLimit
+							&& WandHelper.getUpgradeLevel(wand, upgrade.getItem()) < Constants.UPGRADE_STACK_LIMIT){
+
+						WandHelper.applyUpgrade(wand, upgrade.getItem());
+
+						// Special behaviours for specific upgrades
+						if(upgrade.getItem() == WizardryItems.storage_upgrade){
+							wand.setItemDamage(wand.getMaxDamage() - prevMana);
+						}
+						if(upgrade.getItem() == WizardryItems.attunement_upgrade){
+
+							Spell[] spells = WandHelper.getSpells(wand);
+							Spell[] newSpells = new Spell[5 + WandHelper.getUpgradeLevel(wand, WizardryItems.attunement_upgrade)];
+
+							for(int i=0; i<newSpells.length; i++){
+								// Prevents both NPEs and AIOOBEs
+								newSpells[i] = i < spells.length && spells[i] != null ? spells[i] : Spells.none;
+							}
+
+							WandHelper.setSpells(wand, newSpells);
+
+							int[] cooldown = WandHelper.getCooldowns(wand);
+							int[] newCooldown = new int[5 + WandHelper.getUpgradeLevel(wand, WizardryItems.attunement_upgrade)];
+
+							if(cooldown.length > 0){
+								for(int i=0; i<cooldown.length; i++){
+									newCooldown[i] = cooldown[i];
+								}
+							}
+
+							WandHelper.setCooldowns(wand, newCooldown);
+						}
+
+						this.decrStackSize(ContainerArcaneWorkbench.UPGRADE_SLOT, 1);
+						player.addStat(WizardryAchievements.special_upgrade, 1);
+
+						if(WandHelper.getTotalUpgrades(wand) == Tier.MASTER.upgradeLimit){
+							player.addStat(WizardryAchievements.max_out_wand, 1);
+						}
+					}
+				}
+			}
+
+			// Reads NBT spell id array to variable, edits this, then writes it back to NBT.
+			// Original spells are preserved; if a slot is left empty the existing spell binding will remain.
+			// Accounts for spells which cannot be applied because they are above the wand's tier; these spells
+			// will not bind but the existing spell in that slot will remain and other applicable spells will
+			// be bound as normal, along with any upgrades and crystals.
+			Spell[] spells = WandHelper.getSpells(wand);
+			if(spells.length <= 0){
+				// 5 here because if the spell array doesn't exist, the wand can't possibly have attunement upgrades
+				spells = new Spell[5];
+			}
+			for(int i=0; i<spells.length; i++){
+				if(spellBooks[i] != null && !(Spell.get(spellBooks[i].getItemDamage()).tier.level > ((ItemWand)wand.getItem()).tier.level)){
+					spells[i] = Spell.get(spellBooks[i].getItemDamage());
+				}
+			}
+			WandHelper.setSpells(wand, spells);
+
+			// Charges wand by appropriate amount
+			if(crystals != null){
+				int chargeDepleted = wand.getItemDamage();
+				//System.out.println("Charge depleted: " + chargeDepleted);
+				//System.out.println("Crystals found: " + crystals.stackSize);
+				if(crystals.stackSize * Constants.MANA_PER_CRYSTAL < chargeDepleted){
+					//System.out.println("charging");
+					wand.setItemDamage(chargeDepleted - crystals.stackSize * Constants.MANA_PER_CRYSTAL);
+					this.decrStackSize(ContainerArcaneWorkbench.CRYSTAL_SLOT, crystals.stackSize);
+				}else if(chargeDepleted != 0){
+					//System.out.println((int)Math.ceil(((double)chargeDepleted)/50));
+					this.decrStackSize(ContainerArcaneWorkbench.CRYSTAL_SLOT, (int)Math.ceil(((double)chargeDepleted)/Constants.MANA_PER_CRYSTAL));
+					wand.setItemDamage(0);
+				}
+			}
+
+			// Armour
+		}else if(wand != null && wand.getItem() instanceof ItemWizardArmour){
+			// Applies legendary upgrade
+			if(upgrade != null && upgrade.getItem() == WizardryItems.armour_upgrade){
+				if(!wand.hasTagCompound()){
+					wand.setTagCompound(new NBTTagCompound());
+				}
+				if(!wand.getTagCompound().hasKey("legendary")){
+					wand.getTagCompound().setBoolean("legendary", true);
+					this.setInventorySlotContents(ContainerArcaneWorkbench.UPGRADE_SLOT, null);
+					player.addStat(WizardryAchievements.legendary);
+				}
+			}
+			// Charges armour by appropriate amount
+			if(crystals != null){
+				int chargeDepleted = wand.getItemDamage();
+				if(crystals.stackSize * Constants.MANA_PER_CRYSTAL < chargeDepleted){
+					wand.setItemDamage(chargeDepleted - crystals.stackSize * Constants.MANA_PER_CRYSTAL);
+					this.decrStackSize(ContainerArcaneWorkbench.CRYSTAL_SLOT, crystals.stackSize);
+				}else if(chargeDepleted != 0){
+					this.decrStackSize(ContainerArcaneWorkbench.CRYSTAL_SLOT, (int)Math.ceil(((double)chargeDepleted)/Constants.MANA_PER_CRYSTAL));
+					wand.setItemDamage(0);
+				}
+			}
+
+			// Scrolls
+		}else if(wand != null && wand.getItem() == WizardryItems.blank_scroll){
+			// Spells can only be bound to scrolls if the player has already cast them (prevents casting of master spells without getting a master wand)
+			// This restriction does not apply in creative mode
+			if(spellBooks[0] != null && (player.capabilities.isCreativeMode || (WizardData.get(player) != null
+					&& WizardData.get(player).hasSpellBeenDiscovered(Spell.get(spellBooks[0].getItemDamage()))))
+					&& crystals != null && crystals.stackSize * Constants.MANA_PER_CRYSTAL > Spell.get(spellBooks[0].getItemDamage()).cost){
+
+				this.decrStackSize(ContainerArcaneWorkbench.CRYSTAL_SLOT, (int)Math.ceil(((double)Spell.get(spellBooks[0].getItemDamage()).cost)/Constants.MANA_PER_CRYSTAL));
+				this.setInventorySlotContents(ContainerArcaneWorkbench.WAND_SLOT, new ItemStack(WizardryItems.scroll, 1, spellBooks[0].getItemDamage()));
+			}
+		}
+	}
+
+}

src/main/java/electroblob/wizardry/tileentity/TileEntityMagicLight.java

@@ -0,0 +1,53 @@
+package electroblob.wizardry.tileentity;
+
+import net.minecraft.nbt.NBTTagCompound;
+
+public class TileEntityMagicLight extends TileEntityTimer {
+	
+	public int[] randomiser;
+	public int[] randomiser2;
+	
+	public TileEntityMagicLight(){
+		super();
+	}
+	
+	public TileEntityMagicLight(int maxTimer){
+		super(maxTimer);
+		randomiser = new int[30];
+		randomiser[0] = -1;
+		randomiser2 = new int[30];
+		randomiser2[0] = -1;
+	}
+	
+	@Override
+	public void update(){
+		
+		if(randomiser.length > 0 && randomiser[0] == -1){
+			for(int i=0; i<randomiser.length; i++){
+				randomiser[i] = this.worldObj.rand.nextInt(10);
+			}
+		}
+		if(randomiser2.length > 0 && randomiser2[0] == -1){
+			for(int i=0; i<randomiser2.length; i++){
+				randomiser2[i] = this.worldObj.rand.nextInt(10);
+			}
+		}
+		super.update();
+	}
+	
+	@Override
+    public void readFromNBT(NBTTagCompound tagCompound) {
+        super.readFromNBT(tagCompound);
+        randomiser = tagCompound.getIntArray("randomiser");
+        randomiser2 = tagCompound.getIntArray("randomiser2");
+    }
+
+    @Override
+    public NBTTagCompound writeToNBT(NBTTagCompound tagCompound) {
+        super.writeToNBT(tagCompound);
+        tagCompound.setIntArray("randomiser", randomiser);
+        tagCompound.setIntArray("randomiser2", randomiser2);
+		return tagCompound;
+    }
+	
+}

src/main/java/electroblob/wizardry/tileentity/TileEntityPlayerSave.java

@@ -0,0 +1,72 @@
+package electroblob.wizardry.tileentity;
+
+import java.lang.ref.WeakReference;
+import java.util.UUID;
+
+import electroblob.wizardry.util.WizardryUtilities;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ITickable;
+
+public class TileEntityPlayerSave extends TileEntity implements ITickable {
+
+	/** The entity that created this construct */
+	private WeakReference<EntityLivingBase> caster;
+	
+	/** The UUID of the caster. Note that this is only for loading purposes; during normal updates
+	 * the actual entity instance is stored (so that getEntityByUUID is not called constantly),
+	 * so this will not always be synced (this is why it is private). */
+	private UUID casterUUID;
+	
+	public TileEntityPlayerSave(EntityLivingBase caster){
+		this.caster = new WeakReference<EntityLivingBase>(caster);
+	}
+	
+	public TileEntityPlayerSave(){
+		
+	}
+	
+	@Override
+	public void update(){
+		if(this.getCaster() == null && this.casterUUID != null){
+			Entity entity = WizardryUtilities.getEntityByUUID(worldObj, casterUUID);
+			if(entity instanceof EntityLivingBase){
+				this.caster = new WeakReference<EntityLivingBase>((EntityLivingBase)entity);
+			}
+		}
+	}
+	
+	@Override
+    public void readFromNBT(NBTTagCompound tagCompound) {
+        super.readFromNBT(tagCompound);
+        casterUUID = tagCompound.getUniqueId("casterUUID");
+    }
+
+    @Override
+    public NBTTagCompound writeToNBT(NBTTagCompound tagCompound) {
+    	
+        super.writeToNBT(tagCompound);
+        
+		if(this.getCaster() != null){
+        	tagCompound.setUniqueId("casterUUID", this.getCaster().getUniqueID());
+        }
+		
+		return tagCompound;
+    }
+    
+    /**
+	 * Returns the EntityLivingBase that created this construct, or null if it no longer exists. Cases where the
+	 * entity may no longer exist are: entity died or was deleted, mob despawned, player logged out, entity teleported
+	 * to another dimension, or this construct simply had no caster in the first place.
+	 */
+	public EntityLivingBase getCaster() {
+		return caster == null ? null : caster.get();
+	}
+	
+	public void setCaster(EntityLivingBase caster){
+		this.caster = new WeakReference<EntityLivingBase>(caster);
+	}
+
+}

src/main/java/electroblob/wizardry/tileentity/TileEntityStatue.java

@@ -0,0 +1,174 @@
+package electroblob.wizardry.tileentity;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.EntityList;
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.network.NetworkManager;
+import net.minecraft.network.play.server.SPacketUpdateTileEntity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ITickable;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public class TileEntityStatue extends TileEntity implements ITickable {
+
+	public EntityLiving creature;
+	private NBTTagCompound entityCompound;
+	private String entityName;
+	private float entityYawHead;
+	private float entityYawOffset;
+	public boolean isIce;
+	private int timer;
+	private int lifetime = 600;
+	/** <b>[Client-side]</b> Keeps track of the destroy stage for the block associated with this tile entity
+	 * for rendering purposes. Will be 0 if position is not 1. */
+	public int destroyStage;
+	
+	public TileEntityStatue(){
+
+	}
+	
+	public TileEntityStatue(boolean isIce){
+		this.isIce = isIce;
+		this.timer = 0;
+	}
+	
+	/** The number of stone blocks that this petrified creature is made of.*/
+	public int parts;
+	
+	/** The position within the petrified creature this particular tileentity holds.
+	 * 1 is at the bottom.*/
+	public int position = 1;
+	
+	public void setCreatureAndPart(EntityLiving entity, int position, int parts){
+		this.creature = entity;
+		this.position = position;
+		this.parts = parts;
+		// Aligns the entity with the block so the render bounding box works correctly, and also for visual effect when
+		// broken out.
+		if(position == 1) creature.setPosition(this.getPos().getX() + 0.5, this.getPos().getY(), this.getPos().getZ() + 0.5);
+	}
+	
+	public void setLifetime(int lifetime){
+		this.lifetime = lifetime;
+	}
+	
+	@SideOnly(Side.CLIENT)
+    public AxisAlignedBB getRenderBoundingBox(){
+		
+        AxisAlignedBB bb = INFINITE_EXTENT_AABB;
+        Block type = getBlockType();
+        // Allows the renderer to render the entity even when the bottom block is not visible.
+        // Was only done for position 1, now done for all positions so the breaking animation works properly.
+        if(this.creature != null){
+        	// Now uses the entity's bounding box
+        	bb = this.creature.getRenderBoundingBox();
+        	//bb = new AxisAlignedBB(xCoord, yCoord, zCoord, xCoord + 1, yCoord + this.parts, zCoord + 1);
+        
+        }else if(type != null){
+        	
+            AxisAlignedBB cbb = this.getWorld().getBlockState(pos).getBoundingBox(worldObj, pos);
+            if (cbb != null)
+            {
+                bb = cbb;
+            }
+        }
+        return bb;
+    }
+	
+	@Override
+	public boolean canRenderBreaking(){
+		return true;
+	}
+	
+	@Override
+	public void update(){
+		
+		this.timer++;
+		
+		//System.out.println(entityName);
+		if(this.creature == null && entityName != null){
+			this.creature = (EntityLiving) EntityList.createEntityByName(this.entityName, this.worldObj);
+			if(this.creature != null){
+				this.creature.readFromNBT(entityCompound);
+				this.creature.rotationYawHead = this.entityYawHead;
+				this.creature.renderYawOffset = this.entityYawOffset;
+			}
+		}
+		
+		//System.out.println("Coords: " + this.xCoord + ", " + this.yCoord + ", " + this.zCoord);
+		// Breaks the block at light levels of 7 or below, with a higher chance the lower the light level.
+		// The chance is (8 - light level)/12, so at light 0 the chance is 3/4 and at light 7 the chance is 1/12.
+		if(!this.worldObj.isRemote && this.timer % 200 == 0 && this.timer > lifetime && !this.isIce && this.position == 1){
+			// TESTME: There are about 10 different light-related methods in world now... is this the right one?
+			if(this.worldObj.getLight(pos) < this.worldObj.rand.nextInt(12) - 3){
+				// This is all that is needed because destroyBlock invokes the breakBlock function in BlockPetrifiedStone
+				// and that function handles all the spawning and stuff.
+				this.worldObj.destroyBlock(pos, false);
+			}
+		}
+		
+		// Breaks the block after 30 secs
+		if(!this.worldObj.isRemote && this.timer > lifetime && this.isIce){
+			if(this.position == 1){
+				// This is all that is needed because destroyBlock invokes the breakBlock function in BlockPetrifiedStone
+				// and that function handles all the spawning and stuff.
+				this.worldObj.destroyBlock(pos, false);
+			}
+		}
+	}
+	
+	@Override
+    public void readFromNBT(NBTTagCompound tagCompound) {
+        super.readFromNBT(tagCompound);
+        position = tagCompound.getInteger("position");
+        parts = tagCompound.getInteger("parts");
+        entityCompound = tagCompound.getCompoundTag("entity");
+        entityName = tagCompound.getString("entityName");
+        timer = tagCompound.getInteger("timer");
+        lifetime = tagCompound.getInteger("lifetime");
+        isIce = tagCompound.getBoolean("isIce");
+        entityYawHead = tagCompound.getFloat("entityYawHead");
+        entityYawOffset = tagCompound.getFloat("entityYawOffset");
+    }
+
+    @Override
+    public NBTTagCompound writeToNBT(NBTTagCompound tagCompound) {
+        super.writeToNBT(tagCompound);
+        tagCompound.setInteger("position", position);
+        tagCompound.setInteger("parts", parts);
+        entityCompound = new NBTTagCompound();
+        if(creature != null){
+        	creature.writeToNBT(entityCompound);
+            tagCompound.setString("entityName", EntityList.getEntityString(creature));
+            tagCompound.setFloat("entityYawHead", creature.rotationYawHead);
+            tagCompound.setFloat("entityYawOffset", creature.renderYawOffset);
+        }
+        tagCompound.setTag("entity", entityCompound);
+        tagCompound.setInteger("timer", timer);
+        tagCompound.setInteger("lifetime", lifetime);
+        tagCompound.setBoolean("isIce", isIce);
+        
+		return tagCompound;
+    }
+    
+    @Override
+	public final NBTTagCompound getUpdateTag(){
+		return this.writeToNBT(new NBTTagCompound());
+	}
+    
+    @Override
+	public SPacketUpdateTileEntity getUpdatePacket(){
+		NBTTagCompound tag = new NBTTagCompound();
+		writeToNBT(tag);
+		return new SPacketUpdateTileEntity(pos, 1, tag);
+	}
+
+    @Override
+	public void onDataPacket(NetworkManager net, SPacketUpdateTileEntity pkt) {
+		NBTTagCompound tag = pkt.getNbtCompound();
+		readFromNBT(tag);
+	}
+}

src/main/java/electroblob/wizardry/tileentity/TileEntityTimer.java

@@ -0,0 +1,76 @@
+package electroblob.wizardry.tileentity;
+
+import electroblob.wizardry.block.BlockVanishingCobweb;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.network.NetworkManager;
+import net.minecraft.network.play.server.SPacketUpdateTileEntity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ITickable;
+
+public class TileEntityTimer extends TileEntity implements ITickable {
+	
+	public int timer = 0;
+	public int maxTimer;
+	
+	public TileEntityTimer(){
+		
+	}
+	
+	public TileEntityTimer(int maxTimer){
+		this.maxTimer = maxTimer;
+	}
+	
+	@Override
+	public void update(){
+		timer++;
+		if(!this.worldObj.isRemote){
+			//System.out.println("Timer: " + timer + "/" + maxTimer);
+		}
+		if(timer > maxTimer && !this.worldObj.isRemote){// && this.worldObj.getBlockId(xCoord, yCoord, zCoord) == Wizardry.magicLight.blockID){
+			if(this.getBlockType() instanceof BlockVanishingCobweb){
+				// destroyBlock breaks the block as if broken by a player, with sound and particles.
+				this.worldObj.destroyBlock(pos, false);
+			}else{
+				this.worldObj.setBlockToAir(pos);
+			}
+		}
+	}
+	
+	public void setLifetime(int lifetime){
+		this.maxTimer = lifetime;
+	}
+	
+	@Override
+    public void readFromNBT(NBTTagCompound tagCompound) {
+        super.readFromNBT(tagCompound);
+        timer = tagCompound.getInteger("timer");
+        maxTimer = tagCompound.getInteger("maxTimer");
+    }
+
+    @Override
+    public NBTTagCompound writeToNBT(NBTTagCompound tagCompound) {
+        super.writeToNBT(tagCompound);
+        tagCompound.setInteger("timer", timer);
+        tagCompound.setInteger("maxTimer", maxTimer);
+		return tagCompound;
+    }
+    
+    @Override
+	public final NBTTagCompound getUpdateTag(){
+		return this.writeToNBT(new NBTTagCompound());
+	}
+    
+    @Override
+	public SPacketUpdateTileEntity getUpdatePacket() {
+		NBTTagCompound tag = new NBTTagCompound();
+		writeToNBT(tag);
+		return new SPacketUpdateTileEntity(pos, 1, tag);
+	}
+
+	@Override
+	public void onDataPacket(NetworkManager net, SPacketUpdateTileEntity pkt) {
+		NBTTagCompound tag = pkt.getNbtCompound();
+		readFromNBT(tag);
+	}
+	
+}