Initial commit

src/main/java/electroblob/wizardry/item/IConjuredItem.java

@@ -0,0 +1,32 @@
+package electroblob.wizardry.item;
+
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+
+/** Allows wizardry to identify items that are conjured (and therefore need destroying if they leave the inventory)
+ * without explicitly referencing each, thereby allowing for better expandibility. */
+public interface IConjuredItem {
+	
+	/** The NBT tag key used to store the duration multiplier for conjured items. */
+	public static final String DURATION_MULTIPLIER_KEY = "durationMultiplier";
+
+	/** Helper method for setting the duration multiplier (via NBT) for conjured items. */
+	public static void setDurationMultiplier(ItemStack stack, float multiplier){
+		if(!stack.hasTagCompound()) stack.setTagCompound(new NBTTagCompound());
+		stack.getTagCompound().setFloat(DURATION_MULTIPLIER_KEY, multiplier);
+	}
+	
+	/** Helper method for returning the max damage of a conjured item based on its NBT data. Centralises the code.
+	 * Implementors will almost certainly want to call this from {@link Item#getMaxDamage(ItemStack stack)}. */
+	public default int getMaxDamageFromNBT(ItemStack stack){
+		if(stack.hasTagCompound() && stack.getTagCompound().hasKey(DURATION_MULTIPLIER_KEY)){
+			return (int)(this.getBaseDuration() * stack.getTagCompound().getFloat(DURATION_MULTIPLIER_KEY));
+		}
+		return this.getBaseDuration();
+	}
+	
+	/** Returns the base duration in ticks for this conjured item. Should be a constant (commonly 600).
+	 * Implementors may want to call this when setting an item's max damage in its constructor. */
+	public int getBaseDuration();
+}

src/main/java/electroblob/wizardry/item/ItemArcaneTome.java

@@ -0,0 +1,59 @@
+package electroblob.wizardry.item;
+
+import java.util.List;
+
+import electroblob.wizardry.constants.Tier;
+import electroblob.wizardry.registry.WizardryTabs;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.EnumRarity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public class ItemArcaneTome extends Item {
+	
+	public ItemArcaneTome() {
+		super();
+		this.setHasSubtypes(true);
+		this.setMaxStackSize(1);
+		this.setCreativeTab(WizardryTabs.WIZARDRY);
+	}
+	
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void getSubItems(Item item, CreativeTabs tab, List<ItemStack> list){
+	    for(int i=1; i<Tier.values().length; i++) {
+	        list.add(new ItemStack(item, 1, i));
+	    }
+	}
+	
+	@Override
+	@SideOnly(Side.CLIENT)
+	public boolean hasEffect(ItemStack stack){
+		return true;
+	}
+	
+	@Override
+	public EnumRarity getRarity(ItemStack stack)
+    {
+    	switch(this.getDamage(stack)){
+    	case 1: return EnumRarity.UNCOMMON;
+    	case 2: return EnumRarity.RARE;
+    	case 3: return EnumRarity.EPIC;
+    	}
+    	return EnumRarity.COMMON;
+    }
+
+    @SideOnly(Side.CLIENT)
+	@Override
+	public void addInformation(ItemStack stack, EntityPlayer player, List<String> tooltip, boolean showAdvanced){
+		Tier tier = Tier.values()[stack.getItemDamage()];
+		Tier tier2 = Tier.values()[stack.getItemDamage()-1];
+		tooltip.add(tier.getDisplayNameWithFormatting());
+		tooltip.add("\u00A77" + net.minecraft.client.resources.I18n.format("item.wizardry:arcane_tome.desc1", tier2.getDisplayNameWithFormatting()));
+		tooltip.add("\u00A77" + net.minecraft.client.resources.I18n.format("item.wizardry:arcane_tome.desc2", tier.getDisplayNameWithFormatting() + "\u00A77"));
+	}
+
+}

src/main/java/electroblob/wizardry/item/ItemArmourUpgrade.java

@@ -0,0 +1,46 @@
+package electroblob.wizardry.item;
+
+import java.util.List;
+
+import electroblob.wizardry.registry.WizardryTabs;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.EnumRarity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public class ItemArmourUpgrade extends Item {
+	
+	public ItemArmourUpgrade() {
+		super();
+		this.setMaxStackSize(1);
+		this.setCreativeTab(WizardryTabs.WIZARDRY);
+	}
+	
+	@Override
+	public EnumRarity getRarity(ItemStack stack){
+        return EnumRarity.EPIC;
+    }
+	
+	@Override
+	@SideOnly(Side.CLIENT)
+	public boolean hasEffect(ItemStack stack){
+		return true;
+	}
+	
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void addInformation(ItemStack stack, EntityPlayer player, List<String> tooltip, boolean advanced){
+		tooltip.add(net.minecraft.client.resources.I18n.format("item.wizardry:armour_upgrade.desc1", "\u00A77"));
+		tooltip.add(net.minecraft.client.resources.I18n.format("item.wizardry:armour_upgrade.desc2", "\u00A77", "\u00A7d"));
+	}
+	
+	@Override
+    @SideOnly(Side.CLIENT)
+    public void getSubItems(Item item, CreativeTabs tab, List<ItemStack> subItems){
+		subItems.add(new ItemStack(this, 1));
+    }
+
+}

src/main/java/electroblob/wizardry/item/ItemFirebomb.java

@@ -0,0 +1,50 @@
+package electroblob.wizardry.item;
+
+import java.util.List;
+
+import electroblob.wizardry.entity.projectile.EntityFirebomb;
+import electroblob.wizardry.registry.WizardryTabs;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.SoundEvents;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.EnumActionResult;
+import net.minecraft.util.EnumHand;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public class ItemFirebomb extends Item {
+
+    public ItemFirebomb(){
+        this.maxStackSize = 16;
+        this.setCreativeTab(WizardryTabs.WIZARDRY);
+    }
+
+    @Override
+    public ActionResult<ItemStack> onItemRightClick(ItemStack stack, World world, EntityPlayer player, EnumHand hand){
+    
+        if(!player.capabilities.isCreativeMode){
+            --stack.stackSize;
+        }
+
+        player.playSound(SoundEvents.ENTITY_SNOWBALL_THROW, 0.5F, 0.4F / (itemRand.nextFloat() * 0.4F + 0.8F));
+
+        if(!world.isRemote){
+        	EntityFirebomb firebomb = new EntityFirebomb(world, player);
+            // This is the standard set of parameters for this method, used by snowballs and ender pearls.
+        	firebomb.setHeadingFromThrower(player, player.rotationPitch, player.rotationYaw, 0.0f, 1.5f, 1.0f);
+            world.spawnEntityInWorld(firebomb);
+        }
+
+        return ActionResult.newResult(EnumActionResult.SUCCESS, stack);
+    }
+    
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void getSubItems(Item parItem, CreativeTabs parTab, List<ItemStack> parListSubItems){
+        parListSubItems.add(new ItemStack(this, 1));
+    }
+}

src/main/java/electroblob/wizardry/item/ItemFlamingAxe.java

@@ -0,0 +1,92 @@
+package electroblob.wizardry.item;
+
+import java.util.List;
+
+import electroblob.wizardry.util.MagicDamage;
+import electroblob.wizardry.util.MagicDamage.DamageType;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemAxe;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public class ItemFlamingAxe extends ItemAxe implements IConjuredItem {
+
+	public ItemFlamingAxe(ToolMaterial material) {
+		super(material, 8, -3);
+		this.setMaxDamage(getBaseDuration());
+		this.setNoRepair();
+		this.setCreativeTab(null);
+	}
+
+	@Override
+	public int getBaseDuration(){
+		return 600;
+	}
+	
+	@Override
+	public int getMaxDamage(ItemStack stack){
+        return this.getMaxDamageFromNBT(stack);
+    }
+	
+	@Override
+	// This method allows the code for the item's timer to be greatly simplified by damaging it directly from
+	// onUpdate() and removing the workaround that involved WizardData and all sorts of crazy stuff.
+	public boolean shouldCauseReequipAnimation(ItemStack oldStack, ItemStack newStack, boolean slotChanged){
+		
+		if(oldStack != null || newStack != null){
+			// We only care about the situation where we specifically want the animation NOT to play.
+			if(oldStack.getItem() == newStack.getItem() && !slotChanged) return false;
+		}
+		
+		return super.shouldCauseReequipAnimation(oldStack, newStack, slotChanged);
+	}
+	
+	@Override
+	public void onUpdate(ItemStack stack, World world, Entity entity, int slot, boolean selected){
+		int damage = stack.getItemDamage();
+		if(damage > stack.getMaxDamage()) entity.replaceItemInInventory(slot, null);
+		stack.setItemDamage(damage + 1);
+	}
+	
+	@Override
+	public boolean hitEntity(ItemStack stack, EntityLivingBase target, EntityLivingBase wielder){
+    	if(!MagicDamage.isEntityImmune(DamageType.FIRE, target)) target.setFire(8);
+        return false;
+    }
+	
+	@Override
+	@SideOnly(Side.CLIENT)
+	public boolean hasEffect(ItemStack stack){
+		return true;
+	}
+	
+	@Override
+	public boolean getIsRepairable(ItemStack stack, ItemStack par2ItemStack){
+        return false;
+    }
+	
+	@Override
+	public int getItemEnchantability(){
+        return 0;
+    }
+	
+	// Cannot be dropped
+	@Override
+	public boolean onDroppedByPlayer(ItemStack item, EntityPlayer player){
+        return false;
+    }
+	
+	@Override
+    @SideOnly(Side.CLIENT)
+	// Why does this method pass in an item as an argument? It is always the same item the method is invoked on.
+    public void getSubItems(Item item, CreativeTabs tab, List<ItemStack> items){
+        items.add(new ItemStack(this, 1));
+    }
+
+}

src/main/java/electroblob/wizardry/item/ItemFrostAxe.java

@@ -0,0 +1,94 @@
+package electroblob.wizardry.item;
+
+import java.util.List;
+
+import electroblob.wizardry.registry.WizardryPotions;
+import electroblob.wizardry.util.MagicDamage;
+import electroblob.wizardry.util.MagicDamage.DamageType;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemAxe;
+import net.minecraft.item.ItemStack;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public class ItemFrostAxe extends ItemAxe implements IConjuredItem {
+
+	public ItemFrostAxe(ToolMaterial material) {
+		super(material, 8, -3);
+		this.setMaxDamage(getBaseDuration());
+		this.setNoRepair();
+		this.setCreativeTab(null);
+	}
+	
+	@Override
+	public int getBaseDuration(){
+		return 600;
+	}
+	
+	@Override
+	public int getMaxDamage(ItemStack stack){
+        return this.getMaxDamageFromNBT(stack);
+    }
+	
+	@Override
+	// This method allows the code for the item's timer to be greatly simplified by damaging it directly from
+	// onUpdate() and removing the workaround that involved WizardData and all sorts of crazy stuff.
+	public boolean shouldCauseReequipAnimation(ItemStack oldStack, ItemStack newStack, boolean slotChanged){
+		
+		if(oldStack != null || newStack != null){
+			// We only care about the situation where we specifically want the animation NOT to play.
+			if(oldStack.getItem() == newStack.getItem() && !slotChanged) return false;
+		}
+		
+		return super.shouldCauseReequipAnimation(oldStack, newStack, slotChanged);
+	}
+	
+	@Override
+	public void onUpdate(ItemStack stack, World world, Entity entity, int slot, boolean selected){
+		int damage = stack.getItemDamage();
+		if(damage > stack.getMaxDamage()) entity.replaceItemInInventory(slot, null);
+		stack.setItemDamage(damage + 1);
+	}
+	
+	@Override
+	public boolean hitEntity(ItemStack stack, EntityLivingBase target, EntityLivingBase wielder)
+    {
+		if(!MagicDamage.isEntityImmune(DamageType.FROST, target)) target.addPotionEffect(new PotionEffect(WizardryPotions.frost, 160, 1));
+        return false;
+    }
+	
+	@Override
+	@SideOnly(Side.CLIENT)
+	public boolean hasEffect(ItemStack stack){
+		return true;
+	}
+	
+	@Override
+	public boolean getIsRepairable(ItemStack stack, ItemStack par2ItemStack){
+        return false;
+    }
+	
+	@Override
+	public int getItemEnchantability(){
+        return 0;
+    }
+	
+	// Cannot be dropped
+	@Override
+	public boolean onDroppedByPlayer(ItemStack item, EntityPlayer player){
+        return false;
+    }
+	
+	@Override
+    @SideOnly(Side.CLIENT)
+    public void getSubItems(Item parItem, CreativeTabs parTab, List<ItemStack> parListSubItems){
+        parListSubItems.add(new ItemStack(this, 1));
+    }
+
+}

src/main/java/electroblob/wizardry/item/ItemIdentificationScroll.java

@@ -0,0 +1,81 @@
+package electroblob.wizardry.item;
+
+import java.util.List;
+
+import electroblob.wizardry.WizardData;
+import electroblob.wizardry.registry.WizardryAchievements;
+import electroblob.wizardry.registry.WizardryTabs;
+import electroblob.wizardry.spell.Spell;
+import electroblob.wizardry.util.WizardryUtilities;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.SoundEvents;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.EnumActionResult;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.text.TextComponentTranslation;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public class ItemIdentificationScroll extends Item {
+
+	public ItemIdentificationScroll() {
+		super();
+		this.setCreativeTab(WizardryTabs.WIZARDRY);
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public boolean hasEffect(ItemStack stack){
+		return true;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void addInformation(ItemStack stack, EntityPlayer player, List<String> tooltip, boolean par4){
+		tooltip.add(net.minecraft.client.resources.I18n.format("item.wizardry:identification_scroll.desc1", "\u00A77"));
+		tooltip.add(net.minecraft.client.resources.I18n.format("item.wizardry:identification_scroll.desc2", "\u00A77"));
+	}
+
+	@Override
+	public ActionResult<ItemStack> onItemRightClick(ItemStack stack, World world, EntityPlayer player, EnumHand hand){
+
+		if(WizardData.get(player) != null){
+
+			WizardData properties = WizardData.get(player);
+
+			for(ItemStack stack1 : WizardryUtilities.getPrioritisedHotbarAndOffhand(player)){
+
+				if(stack1 != null){
+					Spell spell = Spell.get(stack1.getItemDamage());
+					if((stack1.getItem() instanceof ItemSpellBook || stack1.getItem() instanceof ItemScroll)
+							&& !properties.hasSpellBeenDiscovered(spell)){
+
+						// Identification scrolls give the chat readout in creative mode, otherwise it looks like
+						// nothing happens!
+						properties.discoverSpell(spell);
+						player.addStat(WizardryAchievements.identify_spell);
+						player.playSound(SoundEvents.ENTITY_PLAYER_LEVELUP, 1.25f, 1);
+						if(!player.capabilities.isCreativeMode) stack.stackSize--;
+						if(!world.isRemote) player.addChatMessage(new TextComponentTranslation("spell.discover", spell.getNameForTranslationFormatted()));
+
+						return new ActionResult<ItemStack>(EnumActionResult.SUCCESS, stack);
+					}
+				}
+			}
+			// If it found nothing to identify, it says so!
+			if(!world.isRemote) player.addChatMessage(new TextComponentTranslation("item.wizardry:identification_scroll.nothing_to_identify"));
+		}
+
+		return new ActionResult<ItemStack>(EnumActionResult.FAIL, stack);
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void getSubItems(Item parItem, CreativeTabs parTab, List<ItemStack> parListSubItems){
+		parListSubItems.add(new ItemStack(this, 1));
+	}
+}

src/main/java/electroblob/wizardry/item/ItemPoisonBomb.java

@@ -0,0 +1,51 @@
+package electroblob.wizardry.item;
+
+import java.util.List;
+
+import electroblob.wizardry.entity.projectile.EntityPoisonBomb;
+import electroblob.wizardry.registry.WizardryTabs;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.SoundEvents;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.EnumActionResult;
+import net.minecraft.util.EnumHand;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public class ItemPoisonBomb extends Item {
+
+    public ItemPoisonBomb(){
+        this.maxStackSize = 16;
+        this.setCreativeTab(WizardryTabs.WIZARDRY);
+    }
+
+    @Override
+    public ActionResult<ItemStack> onItemRightClick(ItemStack stack, World world, EntityPlayer player, EnumHand hand){
+    
+        if(!player.capabilities.isCreativeMode){
+            --stack.stackSize;
+        }
+
+        player.playSound(SoundEvents.ENTITY_SNOWBALL_THROW, 0.5F, 0.4F / (itemRand.nextFloat() * 0.4F + 0.8F));
+
+        if(!world.isRemote){
+        	EntityPoisonBomb poisonbomb = new EntityPoisonBomb(world, player);
+            // This is the standard set of parameters for this method, used by snowballs and ender pearls.
+        	poisonbomb.setHeadingFromThrower(player, player.rotationPitch, player.rotationYaw, 0.0f, 1.5f, 1.0f);
+            world.spawnEntityInWorld(poisonbomb);
+        }
+
+        return ActionResult.newResult(EnumActionResult.SUCCESS, stack);
+    }
+    
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void getSubItems(Item item, CreativeTabs tab, List<ItemStack> subItems){
+        subItems.add(new ItemStack(this, 1));
+    }
+    
+}

src/main/java/electroblob/wizardry/item/ItemScroll.java

@@ -0,0 +1,139 @@
+package electroblob.wizardry.item;
+
+import java.util.List;
+
+import electroblob.wizardry.WizardData;
+import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.packet.PacketCastSpell;
+import electroblob.wizardry.packet.WizardryPacketHandler;
+import electroblob.wizardry.registry.WizardryPotions;
+import electroblob.wizardry.registry.WizardryTabs;
+import electroblob.wizardry.spell.Spell;
+import electroblob.wizardry.util.SpellModifiers;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.SoundEvents;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.EnumActionResult;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.text.TextComponentTranslation;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public class ItemScroll extends Item {
+
+	public ItemScroll(){
+		super();
+		this.setHasSubtypes(true);
+		this.setMaxStackSize(1);
+		this.setCreativeTab(WizardryTabs.SPELLS);
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void getSubItems(Item item, CreativeTabs par2CreativeTabs, List<ItemStack> list){
+		// Isn't this sooooo much neater with the filter thing?
+		for(Spell spell : Spell.getSpells(Spell.nonContinuousSpells)){
+			list.add(new ItemStack(item, 1, spell.id()));
+		}
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public boolean hasEffect(ItemStack stack){
+		return true;
+	}
+
+	@Override
+	// Item's version of this method is, quite frankly, an abomination. Why is a deprecated method being used as such
+	// an integral part of the code? And what's the point in getUnlocalisedNameInefficiently?
+	public String getItemStackDisplayName(ItemStack stack){
+		
+		/* Ok, so this method can be called from either the client or the server side. Obviously, on the client the
+		 * spell name is either translated or obfuscated, then it is put into the item name as part of that translation.
+		 * On the server side, however, there's a problem: on the one hand, the spell name shouldn't be obfuscated in
+		 * case the server wants to do something with it, and in that case returning world-specific gobbledegook is
+		 * not particularly helpful. On the other hand, something might happen that causes this method to be called on
+		 * the server side, but the result to then be sent to the client, which means broken discovery system.
+		 * Simply put, I can't predict that, and it's not my job to cater for other people's incorrect usage of code,
+		 * especially when that might compromise some perfectly reasonable use (think Bibliocraft's 'best guess' book
+		 * detection). */
+		// TODO: Backport this proxy-based fix.
+		return Wizardry.proxy.getScrollDisplayName(stack);
+
+	}
+
+	@Override
+	public ActionResult<ItemStack> onItemRightClick(ItemStack stack, World world, EntityPlayer player, EnumHand hand){
+
+		if(player.isPotionActive(WizardryPotions.arcane_jammer)) return new ActionResult<ItemStack>(EnumActionResult.FAIL, stack);;
+
+		Spell spell = Spell.get(stack.getItemDamage());
+
+		// If a spell is disabled in the config, it will not work.
+		if(!spell.isEnabled()){
+			if(!world.isRemote) player.addChatMessage(new TextComponentTranslation("spell.disabled", spell.getNameForTranslationFormatted()));
+			return new ActionResult<ItemStack>(EnumActionResult.FAIL, stack);
+		}
+
+		if(!spell.isContinuous){
+
+			/*
+			if(spell.chargeup > 0 && !entityplayer.isUsingItem()){
+				// Spells with a chargeup time are now handled separately.
+				entityplayer.setItemInUse(stack, this.getMaxItemUseDuration(stack));
+				return stack;
+			}
+			 */
+
+			if(!world.isRemote){
+				
+				if(spell.cast(world, player, hand, 0, new SpellModifiers())){
+
+					if(spell.doesSpellRequirePacket()){
+						// Sends a packet to all players in dimension to tell them to spawn particles.
+						IMessage msg = new PacketCastSpell.Message(player.getEntityId(), hand, spell.id(), new SpellModifiers());
+						WizardryPacketHandler.net.sendToDimension(msg, world.provider.getDimension());
+					}
+
+					if(!player.capabilities.isCreativeMode && !WizardData.get(player).hasSpellBeenDiscovered(spell) && Wizardry.settings.discoveryMode){
+						player.playSound(SoundEvents.ENTITY_PLAYER_LEVELUP, 1.25f, 1);
+						if(!player.worldObj.isRemote) player.addChatMessage(new TextComponentTranslation("spell.discover", spell.getNameForTranslationFormatted()));
+					}
+					WizardData.get(player).discoverSpell(spell);
+
+					if(!player.capabilities.isCreativeMode) stack.stackSize--;
+
+					return new ActionResult<ItemStack>(EnumActionResult.SUCCESS, stack);
+				}
+
+			// Client-inconsistent spell casting. The code inside the else if statement only runs client-side.
+			// This else if check was bugging me for AGES! I can't believe I didn't compare to ItemWand before.
+			}else if(!spell.doesSpellRequirePacket()){
+				// This is all that needs to happen, because everything above works fine on just the server side.
+				if(spell.cast(world, player, hand, 0, new SpellModifiers())){
+					// Added in version 1.1.3 to fix the client-side spell discovery not updating for spells with the
+					// packet optimisation.
+					if(WizardData.get(player) != null){
+						WizardData.get(player).discoverSpell(spell);
+					}
+
+					new ActionResult<ItemStack>(EnumActionResult.SUCCESS, stack);
+				}
+			}
+		}
+
+		return new ActionResult<ItemStack>(EnumActionResult.FAIL, stack);
+
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public net.minecraft.client.gui.FontRenderer getFontRenderer(ItemStack stack){
+		return Wizardry.proxy.getFontRenderer(stack);
+	}
+}

src/main/java/electroblob/wizardry/item/ItemSmokeBomb.java

@@ -0,0 +1,50 @@
+package electroblob.wizardry.item;
+
+import java.util.List;
+
+import electroblob.wizardry.entity.projectile.EntitySmokeBomb;
+import electroblob.wizardry.registry.WizardryTabs;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.SoundEvents;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.EnumActionResult;
+import net.minecraft.util.EnumHand;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public class ItemSmokeBomb extends Item {
+
+    public ItemSmokeBomb(){
+        this.maxStackSize = 16;
+        this.setCreativeTab(WizardryTabs.WIZARDRY);
+    }
+
+    @Override
+    public ActionResult<ItemStack> onItemRightClick(ItemStack stack, World world, EntityPlayer player, EnumHand hand){
+    	
+    	if(!player.capabilities.isCreativeMode){
+            --stack.stackSize;
+        }
+
+        player.playSound(SoundEvents.ENTITY_SNOWBALL_THROW, 0.5F, 0.4F / (itemRand.nextFloat() * 0.4F + 0.8F));
+
+        if(!world.isRemote){
+        	EntitySmokeBomb smokebomb = new EntitySmokeBomb(world, player);
+            // This is the standard set of parameters for this method, used by snowballs and ender pearls.
+        	smokebomb.setHeadingFromThrower(player, player.rotationPitch, player.rotationYaw, 0.0f, 1.5f, 1.0f);
+            world.spawnEntityInWorld(smokebomb);
+        }
+
+        return ActionResult.newResult(EnumActionResult.SUCCESS, stack);
+    }
+    
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void getSubItems(Item item, CreativeTabs tab, List<ItemStack> subItems){
+        subItems.add(new ItemStack(this, 1));
+    }
+}

src/main/java/electroblob/wizardry/item/ItemSpectralArmour.java

@@ -0,0 +1,110 @@
+package electroblob.wizardry.item;
+
+import java.util.List;
+
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.EntityEquipmentSlot;
+import net.minecraft.item.EnumRarity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemArmor;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public class ItemSpectralArmour extends ItemArmor implements IConjuredItem {
+
+	public ItemSpectralArmour(ArmorMaterial material, int renderIndex, EntityEquipmentSlot armourType) {
+		
+		super(material, renderIndex, armourType);
+		
+		this.setCreativeTab(null);
+		this.setMaxDamage(getBaseDuration());
+	}
+	
+	@Override
+	public int getBaseDuration(){
+		return 1200;
+	}
+	
+	@Override
+	public int getMaxDamage(ItemStack stack){
+        return this.getMaxDamageFromNBT(stack);
+    }
+	
+	// Overridden to stop the enchantment trick making the name turn blue.
+	@Override
+	public EnumRarity getRarity(ItemStack stack){
+        return EnumRarity.COMMON;
+    }
+	
+	@Override
+	// This method allows the code for the item's timer to be greatly simplified by damaging it directly from
+	// onUpdate() and removing the workaround that involved WizardData and all sorts of crazy stuff.
+	public boolean shouldCauseReequipAnimation(ItemStack oldStack, ItemStack newStack, boolean slotChanged){
+		
+		if(oldStack != null || newStack != null){
+			// We only care about the situation where we specifically want the animation NOT to play.
+			if(oldStack.getItem() == newStack.getItem() && !slotChanged) return false;
+		}
+		
+		return super.shouldCauseReequipAnimation(oldStack, newStack, slotChanged);
+	}
+	
+	@Override
+	public void onArmorTick(World world, EntityPlayer player, ItemStack stack){
+		int damage = stack.getItemDamage();
+		if(damage > stack.getMaxDamage()) player.inventory.clearMatchingItems(this, -1, 1, null);
+		stack.setItemDamage(damage + 1);
+	}
+	
+	@Override
+	@SideOnly(Side.CLIENT)
+	public boolean hasEffect(ItemStack stack){
+		return true;
+	}
+	
+	@Override
+	public boolean getIsRepairable(ItemStack stack, ItemStack par2ItemStack){
+        return false;
+    }
+	
+	@Override
+	public int getItemEnchantability(){
+        return 0;
+    }
+	
+	// Cannot be dropped
+	@Override
+	public boolean onDroppedByPlayer(ItemStack item, EntityPlayer player){
+        return false;
+    }
+	
+	@Override
+	public String getArmorTexture(ItemStack stack, Entity entity, EntityEquipmentSlot slot, String type) {
+		
+		if(slot == EntityEquipmentSlot.LEGS) return "wizardry:textures/armour/spectral_armour_legs.png";
+		
+		return "wizardry:textures/armour/spectral_armour.png";
+	}
+	
+	@Override
+	@SideOnly(Side.CLIENT)
+	public net.minecraft.client.model.ModelBiped getArmorModel(EntityLivingBase entityLiving, ItemStack itemStack, EntityEquipmentSlot armorSlot,
+			net.minecraft.client.model.ModelBiped _default) {
+		net.minecraft.client.renderer.GlStateManager.enableBlend();
+		net.minecraft.client.renderer.GlStateManager.tryBlendFuncSeparate(net.minecraft.client.renderer.GlStateManager.SourceFactor.SRC_ALPHA, net.minecraft.client.renderer.GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA,
+				net.minecraft.client.renderer.GlStateManager.SourceFactor.ONE, net.minecraft.client.renderer.GlStateManager.DestFactor.ZERO);
+		return super.getArmorModel(entityLiving, itemStack, armorSlot, _default);
+	}
+	
+	@Override
+    @SideOnly(Side.CLIENT)
+    public void getSubItems(Item parItem, CreativeTabs parTab, List<ItemStack> parListSubItems){
+        parListSubItems.add(new ItemStack(this, 1));
+    }
+
+}

src/main/java/electroblob/wizardry/item/ItemSpectralBow.java

@@ -0,0 +1,229 @@
+package electroblob.wizardry.item;
+
+import java.util.List;
+
+import javax.annotation.Nullable;
+
+import electroblob.wizardry.Wizardry;
+import net.minecraft.client.Minecraft;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.enchantment.EnchantmentHelper;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.projectile.EntityArrow;
+import net.minecraft.init.Enchantments;
+import net.minecraft.init.Items;
+import net.minecraft.init.SoundEvents;
+import net.minecraft.item.IItemPropertyGetter;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemArrow;
+import net.minecraft.item.ItemBow;
+import net.minecraft.item.ItemStack;
+import net.minecraft.stats.StatList;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.EnumActionResult;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public class ItemSpectralBow extends ItemBow implements IConjuredItem {
+
+	public ItemSpectralBow(){
+		super();
+		this.setMaxDamage(getBaseDuration());
+		this.setNoRepair();
+		this.setCreativeTab(null);
+		this.addPropertyOverride(new ResourceLocation("pull"), new IItemPropertyGetter()
+        {
+            @SideOnly(Side.CLIENT)
+            public float apply(ItemStack stack, @Nullable World worldIn, @Nullable EntityLivingBase entityIn)
+            {
+                if (entityIn == null)
+                {
+                    return 0.0F;
+                }
+                else
+                {
+                    ItemStack itemstack = entityIn.getActiveItemStack();
+                    // Mojang, observe - hardcoding item references into their own classes is NOT good Java.
+                    return itemstack != null && itemstack.getItem() == ItemSpectralBow.this ? (float)(stack.getMaxItemUseDuration() - entityIn.getItemInUseCount()) / 20.0F : 0.0F;
+                }
+            }
+        });
+        this.addPropertyOverride(new ResourceLocation("pulling"), new IItemPropertyGetter()
+        {
+            @SideOnly(Side.CLIENT)
+            public float apply(ItemStack stack, @Nullable World worldIn, @Nullable EntityLivingBase entityIn)
+            {
+                return entityIn != null && entityIn.isHandActive() && entityIn.getActiveItemStack() == stack ? 1.0F : 0.0F;
+            }
+        });
+	}
+
+	@Override
+    @SideOnly(Side.CLIENT)
+	// Why does this still exist? Item models deal with this now, right?
+	public boolean isFull3D(){
+		return true;
+	}
+	
+	@Override
+	public int getBaseDuration(){
+		return 600;
+	}
+	
+	@Override
+	public int getMaxDamage(ItemStack stack){
+        return this.getMaxDamageFromNBT(stack);
+    }
+	
+	@Override
+	// This method allows the code for the item's timer to be greatly simplified by damaging it directly from
+	// onUpdate() and removing the workaround that involved WizardData and all sorts of crazy stuff.
+	public boolean shouldCauseReequipAnimation(ItemStack oldStack, ItemStack newStack, boolean slotChanged){
+		
+		if(oldStack != null && newStack != null){
+			// We only care about the situation where we specifically want the animation NOT to play.
+			if(oldStack.getItem() == newStack.getItem() && !slotChanged
+					// This code should only run on the client side, so using Minecraft is ok.
+					&& !Minecraft.getMinecraft().thePlayer.isHandActive()) return false;
+		}
+		
+		return super.shouldCauseReequipAnimation(oldStack, newStack, slotChanged);
+	}
+	
+	@Override
+	public void onUpdate(ItemStack stack, World world, Entity entity, int slot, boolean selected){
+		int damage = stack.getItemDamage();
+		if(damage > stack.getMaxDamage()) entity.replaceItemInInventory(slot, null);
+		// Can't damage it whilst in use because for some reason it causes the item use to constantly reset.
+		if(!(entity instanceof EntityLivingBase) || !((EntityLivingBase)entity).isHandActive()){
+			stack.setItemDamage(damage + 1);
+		}
+	}
+	
+	// The following two methods re-route the displayed durability through the proxies in order to override the pausing
+	// of the item timer when the bow is being pulled.
+	
+	@Override
+	public double getDurabilityForDisplay(ItemStack stack){
+		return Wizardry.proxy.getConjuredBowDurability(stack);
+	}
+	
+	public double getDefaultDurabilityForDisplay(ItemStack stack){
+		return super.getDurabilityForDisplay(stack);
+	}
+
+	@Override
+	public ActionResult<ItemStack> onItemRightClick(ItemStack stack, World world, EntityPlayer player, EnumHand hand){
+
+		ActionResult<ItemStack> ret = net.minecraftforge.event.ForgeEventFactory.onArrowNock(stack, world, player, hand, true);
+
+		if(ret != null) return ret;
+
+		player.setActiveHand(hand);
+
+		return ActionResult.newResult(EnumActionResult.SUCCESS, stack);
+
+	}
+
+	@Override
+    @SideOnly(Side.CLIENT)
+	public boolean hasEffect(ItemStack stack){
+		return true;
+	}
+
+	@Override
+	public boolean getIsRepairable(ItemStack stack, ItemStack stack2){
+		return false;
+	}
+
+	@Override
+	public int getItemEnchantability(){
+		return 0;
+	}
+
+	// Cannot be dropped
+	@Override
+	public boolean onDroppedByPlayer(ItemStack item, EntityPlayer player){
+		return false;
+	}
+	
+	@Override
+	public void onUsingTick(ItemStack stack, EntityLivingBase player, int count){
+		// player.getItemInUseMaxCount() is named incorrectly; you only have to look at the method to see what it really
+		// does.
+		if(stack.getItemDamage() + player.getItemInUseMaxCount() > stack.getMaxDamage())
+			player.replaceItemInInventory(player.getActiveHand() == EnumHand.MAIN_HAND ? 98 : 99, null);
+	}
+
+	@Override
+	public void onPlayerStoppedUsing(ItemStack stack, World world, EntityLivingBase entity, int timeLeft){
+		// Decreases the timer by the amount it should have been decreased while the bow was in use.
+		if(!world.isRemote) stack.setItemDamage(stack.getItemDamage() + (this.getMaxItemUseDuration(stack) - timeLeft));
+		
+		if (entity instanceof EntityPlayer){
+			
+			EntityPlayer entityplayer = (EntityPlayer)entity;
+
+			int i = this.getMaxItemUseDuration(stack) - timeLeft;
+			i = net.minecraftforge.event.ForgeEventFactory.onArrowLoose(stack, world, (EntityPlayer)entity, i, true);
+			if (i < 0) return;
+
+			float f = getArrowVelocity(i);
+
+			if ((double)f >= 0.1D){
+
+				if (!world.isRemote){
+					
+					ItemArrow itemarrow = (ItemArrow)Items.ARROW;
+					EntityArrow entityarrow = itemarrow.createArrow(world, new ItemStack(itemarrow), entityplayer);
+					entityarrow.setAim(entityplayer, entityplayer.rotationPitch, entityplayer.rotationYaw, 0.0F, f * 3.0F, 1.0F);
+
+					if (f == 1.0F)
+					{
+						entityarrow.setIsCritical(true);
+					}
+
+					int j = EnchantmentHelper.getEnchantmentLevel(Enchantments.POWER, stack);
+
+					if (j > 0)
+					{
+						entityarrow.setDamage(entityarrow.getDamage() + (double)j * 0.5D + 0.5D);
+					}
+
+					int k = EnchantmentHelper.getEnchantmentLevel(Enchantments.PUNCH, stack);
+
+					if (k > 0)
+					{
+						entityarrow.setKnockbackStrength(k);
+					}
+
+					if (EnchantmentHelper.getEnchantmentLevel(Enchantments.FLAME, stack) > 0)
+					{
+						entityarrow.setFire(100);
+					}
+
+					entityarrow.pickupStatus = EntityArrow.PickupStatus.DISALLOWED;
+
+					world.spawnEntityInWorld(entityarrow);
+				}
+
+				world.playSound((EntityPlayer)null, entityplayer.posX, entityplayer.posY, entityplayer.posZ, SoundEvents.ENTITY_ARROW_SHOOT, SoundCategory.NEUTRAL, 1.0F, 1.0F / (itemRand.nextFloat() * 0.4F + 1.2F) + f * 0.5F);
+
+				entityplayer.addStat(StatList.getObjectUseStats(this));
+			}
+		}
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void getSubItems(Item item, CreativeTabs tab, List<ItemStack> subItems){
+		subItems.add(new ItemStack(this, 1));
+	}
+	
+}

src/main/java/electroblob/wizardry/item/ItemSpectralPickaxe.java

@@ -0,0 +1,82 @@
+package electroblob.wizardry.item;
+
+import java.util.List;
+
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemPickaxe;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public class ItemSpectralPickaxe extends ItemPickaxe implements IConjuredItem {
+
+	public ItemSpectralPickaxe(ToolMaterial material){
+		super(material);
+		this.setMaxDamage(getBaseDuration());
+		this.setNoRepair();
+		this.setCreativeTab(null);
+	}
+	
+	@Override
+	public int getBaseDuration(){
+		return 600;
+	}
+	
+	@Override
+	public int getMaxDamage(ItemStack stack){
+        return this.getMaxDamageFromNBT(stack);
+    }
+	
+	@Override
+	// This method allows the code for the item's timer to be greatly simplified by damaging it directly from
+	// onUpdate() and removing the workaround that involved WizardData and all sorts of crazy stuff.
+	public boolean shouldCauseReequipAnimation(ItemStack oldStack, ItemStack newStack, boolean slotChanged){
+		
+		if(oldStack != null || newStack != null){
+			// We only care about the situation where we specifically want the animation NOT to play.
+			if(oldStack.getItem() == newStack.getItem() && !slotChanged) return false;
+		}
+		
+		return super.shouldCauseReequipAnimation(oldStack, newStack, slotChanged);
+	}
+	
+	@Override
+	public void onUpdate(ItemStack stack, World world, Entity entity, int slot, boolean selected){
+		int damage = stack.getItemDamage();
+		if(damage > stack.getMaxDamage()) entity.replaceItemInInventory(slot, null);
+		stack.setItemDamage(damage + 1);
+	}
+	
+	@Override
+    @SideOnly(Side.CLIENT)
+	public boolean hasEffect(ItemStack stack){
+		return true;
+	}
+	
+	@Override
+	public boolean getIsRepairable(ItemStack stack, ItemStack par2ItemStack){
+        return false;
+    }
+	
+	@Override
+	public int getItemEnchantability(){
+        return 0;
+    }
+	
+	// Cannot be dropped
+	@Override
+	public boolean onDroppedByPlayer(ItemStack item, EntityPlayer player){
+        return false;
+    }
+	
+	@Override
+    @SideOnly(Side.CLIENT)
+    public void getSubItems(Item item, CreativeTabs tab, List<ItemStack> subItems){
+        subItems.add(new ItemStack(this, 1));
+    }
+
+}

src/main/java/electroblob/wizardry/item/ItemSpectralSword.java

@@ -0,0 +1,82 @@
+package electroblob.wizardry.item;
+
+import java.util.List;
+
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.ItemSword;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public class ItemSpectralSword extends ItemSword implements IConjuredItem {
+
+	public ItemSpectralSword(ToolMaterial material) {
+		super(material);
+		this.setMaxDamage(getBaseDuration());
+		this.setNoRepair();
+		this.setCreativeTab(null);
+	}
+	
+	@Override
+	public int getBaseDuration(){
+		return 600;
+	}
+	
+	@Override
+	public int getMaxDamage(ItemStack stack){
+        return this.getMaxDamageFromNBT(stack);
+    }
+	
+	@Override
+	// This method allows the code for the item's timer to be greatly simplified by damaging it directly from
+	// onUpdate() and removing the workaround that involved WizardData and all sorts of crazy stuff.
+	public boolean shouldCauseReequipAnimation(ItemStack oldStack, ItemStack newStack, boolean slotChanged){
+		
+		if(oldStack != null || newStack != null){
+			// We only care about the situation where we specifically want the animation NOT to play.
+			if(oldStack.getItem() == newStack.getItem() && !slotChanged) return false;
+		}
+		
+		return super.shouldCauseReequipAnimation(oldStack, newStack, slotChanged);
+	}
+	
+	@Override
+	public void onUpdate(ItemStack stack, World world, Entity entity, int slot, boolean selected){
+		int damage = stack.getItemDamage();
+		if(damage > stack.getMaxDamage()) entity.replaceItemInInventory(slot, null);
+		stack.setItemDamage(damage + 1);
+	}
+	
+	@Override
+    @SideOnly(Side.CLIENT)
+	public boolean hasEffect(ItemStack stack){
+		return true;
+	}
+	
+	@Override
+	public boolean getIsRepairable(ItemStack stack, ItemStack par2ItemStack){
+        return false;
+    }
+	
+	@Override
+	public int getItemEnchantability(){
+        return 0;
+    }
+	
+	// Cannot be dropped
+	@Override
+	public boolean onDroppedByPlayer(ItemStack item, EntityPlayer player){
+        return false;
+    }
+	
+	@Override
+    @SideOnly(Side.CLIENT)
+    public void getSubItems(Item item, CreativeTabs tab, List<ItemStack> subItems){
+        subItems.add(new ItemStack(this, 1));
+    }
+
+}

src/main/java/electroblob/wizardry/item/ItemSpellBook.java

@@ -0,0 +1,82 @@
+package electroblob.wizardry.item;
+
+import java.util.List;
+
+import electroblob.wizardry.SpellGlyphData;
+import electroblob.wizardry.WizardData;
+import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.WizardryGuiHandler;
+import electroblob.wizardry.registry.WizardryTabs;
+import electroblob.wizardry.spell.Spell;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.EnumActionResult;
+import net.minecraft.util.EnumHand;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+import net.minecraftforge.oredict.OreDictionary;
+
+public class ItemSpellBook extends Item {
+	
+	public ItemSpellBook() {
+		super();
+		this.setHasSubtypes(true);
+		this.setMaxStackSize(1);
+		this.setCreativeTab(WizardryTabs.SPELLS);
+	}
+	
+	@Override
+	public void getSubItems(Item item, CreativeTabs tab, List<ItemStack> list){
+		// In this particular case, getTotalSpellCount() is a more efficient way of doing this since the spell instance
+		// is not required, only the id.
+	    for(int i = 0; i < Spell.getTotalSpellCount(); i++){
+	    	// i+1 is used so that the metadata ties up with the id() method. In other words, the none spell has id
+	    	// 0 and since this is not used as a spell book the metadata starts at 1.
+	        list.add(new ItemStack(item, 1, i+1));
+	    }
+	}
+	
+	@Override
+	public ActionResult<ItemStack> onItemRightClick(ItemStack stack, World world, EntityPlayer player, EnumHand hand){
+		player.openGui(Wizardry.instance, WizardryGuiHandler.SPELL_BOOK, world, 0, 0, 0);
+		return ActionResult.newResult(EnumActionResult.SUCCESS, stack);
+	}
+	
+	@Override
+    @SideOnly(Side.CLIENT)
+	public void addInformation(ItemStack itemstack, EntityPlayer player, List<String> tooltip, boolean advanced){
+		// Tooltip is left blank for wizards buying generic spell books.
+		if(itemstack.getItemDamage() != OreDictionary.WILDCARD_VALUE){
+			
+			Spell spell = Spell.get(itemstack.getItemDamage());
+			
+			boolean discovered = true;
+			if(Wizardry.settings.discoveryMode && !player.capabilities.isCreativeMode && WizardData.get(player) != null
+					&& !WizardData.get(player).hasSpellBeenDiscovered(spell)){
+				discovered = false;
+			}
+			
+			// Element colour is not given for undiscovered spells
+			tooltip.add(discovered ? "\u00A77" + spell.getDisplayNameWithFormatting() : "#\u00A79" + SpellGlyphData.getGlyphName(spell, player.worldObj));
+			tooltip.add(spell.tier.getDisplayNameWithFormatting());
+		}
+		/* Removed to streamline the tooltip a bit. Information is now within the book.
+		if(spell.isContinuous){
+			tooltip.add("\u00A79Mana Cost: " + spell.cost + " per second");
+		}else{
+			tooltip.add("\u00A79Mana Cost: " + spell.cost);
+		}
+		*/
+	}
+	
+	@Override
+	@SideOnly(Side.CLIENT)
+	public net.minecraft.client.gui.FontRenderer getFontRenderer(ItemStack stack){
+		return Wizardry.proxy.getFontRenderer(stack);
+	}
+
+}

src/main/java/electroblob/wizardry/item/ItemWand.java

@@ -0,0 +1,430 @@
+package electroblob.wizardry.item;
+
+import java.util.List;
+
+import electroblob.wizardry.SpellGlyphData;
+import electroblob.wizardry.WizardData;
+import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.constants.Constants;
+import electroblob.wizardry.constants.Element;
+import electroblob.wizardry.constants.Tier;
+import electroblob.wizardry.entity.living.ISummonedCreature;
+import electroblob.wizardry.packet.PacketCastSpell;
+import electroblob.wizardry.packet.WizardryPacketHandler;
+import electroblob.wizardry.registry.WizardryAchievements;
+import electroblob.wizardry.registry.WizardryItems;
+import electroblob.wizardry.registry.WizardryPotions;
+import electroblob.wizardry.registry.WizardryTabs;
+import electroblob.wizardry.spell.Spell;
+import electroblob.wizardry.util.SpellModifiers;
+import electroblob.wizardry.util.WandHelper;
+import electroblob.wizardry.util.WizardryUtilities;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.SoundEvents;
+import net.minecraft.inventory.EntityEquipmentSlot;
+import net.minecraft.item.EnumAction;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.EnumActionResult;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.util.math.RayTraceResult;
+import net.minecraft.util.text.TextComponentTranslation;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+/** This class is (literally) where the magic happens! All wand types are single instances of this class. There's a lot
+ * of quite hard-to-read code in here, but unfortunately there's not much I can do about that. For this reason, I have
+ * written the {@link WandHelper} class.<i> I strongly recommend you use it for interacting with wand items wherever
+ * possible.</i>
+ * <p>
+ * It's unikely that anything in this class will be of much use externally, but should you wish to use it for whatever
+ * reason (perhaps if you extend it), it works as follows:
+ * <p>
+ * - onItemRightClick is where non-continuous spells are cast, and it sets the item in use for continuous spells<br>
+ * - onUsingTick does the casting for continuous spells<br>
+ * - onUpdate deals with the cooldowns for the spells
+ * @since Wizardry 1.0 */
+public class ItemWand extends Item {
+
+	public Tier tier;
+	public Element element;
+
+	public ItemWand(Tier tier, Element element) {
+		super();
+		setMaxStackSize(1);
+		if(element == null || tier == Tier.BASIC){
+			setCreativeTab(WizardryTabs.WIZARDRY);
+		}
+		this.tier = tier;
+		this.element = element;
+		this.setMaxDamage(this.tier.maxCharge);
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public boolean isFull3D(){
+		return true;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public net.minecraft.client.gui.FontRenderer getFontRenderer(ItemStack stack){
+		return Wizardry.proxy.getFontRenderer(stack);
+	}
+	
+	@Override
+    @SideOnly(Side.CLIENT)
+    public void getSubItems(Item parItem, CreativeTabs parTab, List<ItemStack> parListSubItems){
+        parListSubItems.add(new ItemStack(this, 1));
+    }
+
+	// Max damage is modifiable with upgrades.
+	@Override
+	public int getMaxDamage(ItemStack itemstack){
+		// + 0.5f corrects small float errors rounding down
+		return (int)(super.getMaxDamage(itemstack)*(1.0f + Constants.STORAGE_INCREASE_PER_LEVEL * WandHelper.getUpgradeLevel(itemstack, WizardryItems.storage_upgrade)) + 0.5f);
+	}
+
+	@Override
+	public void onCreated(ItemStack stack, World par2World, EntityPlayer par3EntityPlayer){
+		/* Removed because of mana flasks, which would cause a new book to be given each time a mana flask
+		 * is crafted with the wand. Handbook is now given on acquiring a crystal.
+		ExtendedPlayer properties = ExtendedPlayer.get(par3EntityPlayer);
+		if(properties != null && !properties.handbookGiven){
+			par3EntityPlayer.inventory.addItemStackToInventory(new ItemStack(Wizardry.wizardHandbook));
+			properties.handbookGiven = true;
+		}*/
+		par3EntityPlayer.addStat(WizardryAchievements.arcane_initiate);
+	}
+
+	@Override
+	public void onUpdate(ItemStack itemstack, World world, Entity entity, int slot, boolean isHeld){
+
+		WandHelper.decrementCooldowns(itemstack);
+
+		// Decrements wand damage (increases mana) every 1.5 seconds if it has a condenser upgrade
+		if(!world.isRemote && itemstack.isItemDamaged() && world.getWorldTime() % 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));
+		}
+
+		if(entity instanceof EntityPlayer && this.element != null && this.element != Element.MAGIC){
+			// As it stands, this will trigger every tick. Not ideal, but I can't find a way to detect if a player
+			// has a certain achievement.
+			// EDIT: There is a way to check, using StatFileWriter#hasAchievementUnlocked, but this ends up calling the same
+			// thing as addStat anyway, meaning there's no point and it's probably not much of a problem anyway.
+			((EntityPlayer)entity).addStat(WizardryAchievements.elemental);
+		}
+	}
+	
+	@Override
+	public boolean shouldCauseReequipAnimation(ItemStack oldStack, ItemStack newStack, boolean slotChanged){
+		
+		// This method does some VERY strange things! Despite its name, it also seems to affect the updating of NBT...
+		
+		if(oldStack != null || newStack != null){
+			// We only care about the situation where we specifically want the animation NOT to play.
+			if(oldStack.getItem() == newStack.getItem() && !slotChanged
+					&& oldStack.getItem() instanceof ItemWand && newStack.getItem() instanceof ItemWand
+					&& WandHelper.getCurrentSpell(oldStack) == WandHelper.getCurrentSpell(newStack)) return false;
+		}
+		
+		return super.shouldCauseReequipAnimation(oldStack, newStack, slotChanged);
+	}
+
+	@Override
+	public EnumAction getItemUseAction(ItemStack itemstack){
+		return WandHelper.getCurrentSpell(itemstack).action;
+	}
+
+	@Override
+	public int getMaxItemUseDuration(ItemStack stack){
+		return 72000;
+	}
+
+	@SideOnly(Side.CLIENT)
+	@Override
+	public void addInformation(ItemStack itemstack, EntityPlayer player, List<String> text, boolean advanced){
+
+		// +0.5f is necessary due to the error in the way floats are calculated.
+		if(element != null) text.add("\u00A78" + net.minecraft.client.resources.I18n.format("item.wizardry:wand.buff", (int)((tier.level+1)*Constants.DAMAGE_INCREASE_PER_TIER*100 + 0.5f) + "%", element.getDisplayName()));
+
+		Spell spell = WandHelper.getCurrentSpell(itemstack);
+
+		boolean discovered = true;
+		if(Wizardry.settings.discoveryMode && !player.capabilities.isCreativeMode && WizardData.get(player) != null
+				&& !WizardData.get(player).hasSpellBeenDiscovered(spell)){
+			discovered = false;
+		}
+
+		text.add("\u00A77" + net.minecraft.client.resources.I18n.format("item.wizardry:wand.spell", discovered ? "\u00A77" + spell.getDisplayNameWithFormatting() : "#\u00A79" + SpellGlyphData.getGlyphName(spell, player.worldObj)));
+
+		text.add("\u00A79" + net.minecraft.client.resources.I18n.format("item.wizardry:wand.mana", (this.getMaxDamage(itemstack) - this.getDamage(itemstack)), this.getMaxDamage(itemstack)));
+	}
+
+	@Override
+	public String getItemStackDisplayName(ItemStack stack){
+		return (this.element == null ? "" : this.element.getFormattingCode()) + super.getItemStackDisplayName(stack);
+	}
+
+	// Continuous spells use the onUsingItemTick method instead of this one.
+	/* An important thing to note about this method: it is only called on the server and the client of the player
+	 * holding the item. This means if you spawn particles here they will not show up on other players' screens.
+	 * Instead, this must be done via packets. */
+	@Override
+	public ActionResult<ItemStack> onItemRightClick(ItemStack stack, World world, EntityPlayer player, EnumHand hand){
+		
+		if(this.selectMinionTarget(player, world)) return new ActionResult<ItemStack>(EnumActionResult.SUCCESS, stack);
+
+		if(player.isPotionActive(WizardryPotions.arcane_jammer)) return new ActionResult<ItemStack>(EnumActionResult.FAIL, stack);
+
+		Spell spell = WandHelper.getCurrentSpell(stack);
+
+		// If a spell is disabled in the config, it will not work.
+		if(!spell.isEnabled()){
+			if(!world.isRemote) player.addChatMessage(new TextComponentTranslation("spell.disabled", spell.getNameForTranslationFormatted()));
+			return new ActionResult<ItemStack>(EnumActionResult.FAIL, stack);
+		}
+
+		// This is here to start the inUse thing, otherwise the onItemUsingTick method will not fire.
+		// If the castSpell method then returns false nothing will happen (continuous spells have no EnumAction
+		// either so setting the item in use has no direct visible effect).
+		// Edit: Strictly speaking this is not true but the spells that do have an action (shield, shadow ward and levitation)
+		// will never return false.
+		if(spell.isContinuous && !player.isHandActive()){
+			player.setActiveHand(hand);
+		}
+
+		// Conditions for the spell to be attempted. The tier check is a failsafe; it should never be false unless the
+		// NBT is modified directly.
+		if(!spell.isContinuous && spell.tier.level <= this.tier.level
+				// Checks that the wand has enough mana to cast the spell
+				&& spell.cost <= (stack.getMaxDamage() - stack.getItemDamage())
+				// Checks that the spell is not in cooldown or that the player is in creative mode
+				&& (WandHelper.getCurrentCooldown(stack) == 0 || player.capabilities.isCreativeMode)){
+
+			// = Spell modifiers =
+			SpellModifiers modifiers = this.calculateModifiers(stack, spell);
+
+			// If the spell does not require a packet, the code is run in the old client-inconsistent way, since this
+			// means that swingItem() doesn't need packets in order to work, improving performance.
+			if(!world.isRemote){
+
+				if(spell.cast(world, player, hand, 0, modifiers)){
+
+					// = Packets =
+					if(spell.doesSpellRequirePacket()){
+						// Sends a packet to all players in dimension to tell them to spawn particles.
+						// Only sent if the spell succeeded, because if the spell failed, you wouldn't
+						// need to spawn any particles!
+						IMessage msg = new PacketCastSpell.Message(player.getEntityId(), hand, spell.id(), modifiers);
+						WizardryPacketHandler.net.sendToDimension(msg, world.provider.getDimension());
+					}
+
+					player.setActiveHand(hand);
+					
+					WizardData data = WizardData.get(player);
+
+					// = Discovery =
+					if(data != null && !player.capabilities.isCreativeMode && !data.hasSpellBeenDiscovered(spell) && Wizardry.settings.discoveryMode){
+						// We are only server side here, so we need to play the sound on the server side to everyone.
+						world.playSound(null, player.posX, player.posY, player.posZ, SoundEvents.ENTITY_PLAYER_LEVELUP,
+								SoundCategory.PLAYERS, 1.25f, 1);
+						player.addChatMessage(new TextComponentTranslation("spell.discover", spell.getNameForTranslationFormatted()));
+					}
+					WizardData.get(player).discoverSpell(spell);
+
+					// = Cooldown =
+					// Spells only have a cooldown in survival
+					if(!player.capabilities.isCreativeMode){
+
+						float cooldownMultiplier = 1.0f - WandHelper.getUpgradeLevel(stack, WizardryItems.cooldown_upgrade)*Constants.COOLDOWN_REDUCTION_PER_LEVEL;
+
+						if(player.isPotionActive(WizardryPotions.font_of_mana)){
+							// Dividing by this rather than setting it takes upgrades and font of mana into account simultaneously
+							cooldownMultiplier /= 2 + player.getActivePotionEffect(WizardryPotions.font_of_mana).getAmplifier();
+						}
+
+						WandHelper.setCurrentCooldown(stack, (int)(spell.cooldown * cooldownMultiplier));
+					}
+
+					// = Mana cost =
+					// The spell costs 20% less for every armour piece of the matching element.
+					int armourPieces = getMatchingArmourCount(player, spell);
+
+					stack.damageItem((int)(spell.cost * (1.0f - armourPieces*Constants.COST_REDUCTION_PER_ARMOUR)), player);
+
+					return new ActionResult<ItemStack>(EnumActionResult.SUCCESS, stack);
+				}
+				
+			// Client-inconsistent spell casting. The code inside the else if statement only runs client-side.
+			}else if(!spell.doesSpellRequirePacket()){
+				// This is all that needs to happen, because everything above works fine on just the server side.
+				if(spell.cast(world, player, hand, 0, new SpellModifiers())){
+					// Added in version 1.1.3 to fix the client-side spell discovery not updating for spells with the
+					// packet optimisation.
+					if(WizardData.get(player) != null){
+						WizardData.get(player).discoverSpell(spell);
+					}
+					
+					new ActionResult<ItemStack>(EnumActionResult.SUCCESS, stack);
+				}
+			}
+		}
+		
+		return new ActionResult<ItemStack>(EnumActionResult.FAIL, stack);
+	}
+
+	// For continuous spells. The count argument actually decrements by 1 each tick.
+	@Override
+	public void onUsingTick(ItemStack stack, EntityLivingBase user, int count){
+		
+		if(user instanceof EntityPlayer){
+	
+			EntityPlayer player = (EntityPlayer)user;
+			
+			Spell spell = WandHelper.getCurrentSpell(stack);
+	
+			WizardData data = WizardData.get(player);
+	
+			// Continuous spells (these must check if they can be cast each tick since the mana changes)
+			if(spell.isContinuous && spell.tier.level <= this.tier.level
+					&& spell.cost/5 <= (stack.getMaxDamage() - stack.getItemDamage())){
+	
+				// = Spell modifiers =
+				SpellModifiers modifiers = this.calculateModifiers(stack, spell);
+	
+				if(spell.cast(player.worldObj, player, player.getActiveHand(), stack.getMaxItemUseDuration() - count, modifiers)){
+	
+					// = Discovery =
+					if(data != null && !player.capabilities.isCreativeMode && !data.hasSpellBeenDiscovered(spell) && Wizardry.settings.discoveryMode){
+						player.playSound(SoundEvents.ENTITY_PLAYER_LEVELUP, 1.25f, 1);
+						if(!player.worldObj.isRemote) player.addChatMessage(new TextComponentTranslation("spell.discover", spell.getNameForTranslationFormatted()));
+					}
+					data.discoverSpell(spell);
+	
+					// = Mana cost =
+					// Divides the mana cost over a second appropriately; since damage is an integer it cannot
+					// just be divided by 20.
+					// Now does five times per second regardless of the spell cost, but each time it does 1/5 of the
+					// cost per second.
+					int tickNumber = (count % 20) + 1;
+					// Tests if the tick counter is a multiple of 4 plus 1, i.e. is true when tickNumber = 1, 5, 9, 13 or 17.
+					// Made a slight adjustment since the counter starts on 1 and not 4.
+					if(tickNumber % 4 == 1){
+	
+						int armourPieces = getMatchingArmourCount(player, spell);
+	
+						switch(armourPieces){
+	
+						case 0: stack.damageItem(spell.cost/5, player);
+						break;
+	
+						case 1: if(tickNumber != 17) stack.damageItem(spell.cost/5, player);
+						break;
+	
+						case 2: if(tickNumber != 9 && tickNumber != 17) stack.damageItem(spell.cost/5, player);
+						break;
+	
+						case 3: if(tickNumber != 5 && tickNumber != 13 && tickNumber != 17) stack.damageItem(spell.cost/5, player);
+						break;
+	
+						case 4: if(tickNumber == 1) stack.damageItem(spell.cost/5, player);
+						break;
+	
+						}
+					}
+				}
+			}
+		}
+	}
+	
+	/** Returns a SpellModifiers object with the appropriate modifiers applied for the given ItemStack and Spell. */
+	protected SpellModifiers calculateModifiers(ItemStack stack, Spell spell){
+		
+		SpellModifiers modifiers = new SpellModifiers();
+		
+		// Now we only need to add multipliers if they are not 1.
+		int level = WandHelper.getUpgradeLevel(stack, WizardryItems.range_upgrade);
+		if(level > 0) modifiers.set(WizardryItems.range_upgrade, 1.0f + level * Constants.RANGE_INCREASE_PER_LEVEL, true);
+		
+		level = WandHelper.getUpgradeLevel(stack, WizardryItems.duration_upgrade);
+		if(level > 0) modifiers.set(WizardryItems.duration_upgrade, 1.0f + level * Constants.DURATION_INCREASE_PER_LEVEL, false);
+		
+		level = WandHelper.getUpgradeLevel(stack, WizardryItems.blast_upgrade);
+		if(level > 0) modifiers.set(WizardryItems.blast_upgrade, 1.0f + level * Constants.BLAST_RADIUS_INCREASE_PER_LEVEL, true);
+
+		// I would have liked to have made potion effects increase in strength according to the damage multiplier,
+		// but the amplifier level is too discrete to make this work. For example, wither 3 for 10 seconds will kill a
+		// normal mob on full 20 health, but wither 2 for the same duration only deals about 6 hearts of damage in total.
+		if(this.element == spell.element){
+			modifiers.set(SpellModifiers.DAMAGE, 1.0f + (this.tier.level + 1) * Constants.DAMAGE_INCREASE_PER_TIER, true);
+		}
+		
+		return modifiers;
+	}
+
+	@Override
+	public boolean itemInteractionForEntity(ItemStack stack, EntityPlayer player, EntityLivingBase entity, EnumHand hand){
+
+		if(player.isSneaking() && entity instanceof EntityPlayer && WizardData.get(player) != null){
+			// This is one of those "the method doing the work looks as if it's just returning a value" situations.
+			// ... I know, right?! I feel very programmer-y. But it's not too confusing here, and it looks neat.
+			String string = WizardData.get(player).toggleAlly((EntityPlayer)entity) ? "item.wizardry:wand.addally" : "item.wizardry:wand.removeally";
+			if(!player.worldObj.isRemote) player.addChatMessage(new TextComponentTranslation(string, entity.getName()));
+			return true;
+		}
+
+		return false;
+	}
+	
+	/** Counts the number of armour pieces the given player is wearing that match the given spell's element. */
+	private int getMatchingArmourCount(EntityPlayer player, Spell spell){
+		
+		int armourPieces = 0;
+
+		for(EntityEquipmentSlot slot : WizardryUtilities.ARMOUR_SLOTS){
+			
+			ItemStack armour = player.getItemStackFromSlot(slot);
+			
+			if(armour != null && armour.getItem() instanceof ItemWizardArmour
+					&& ((ItemWizardArmour)armour.getItem()).element == spell.element) armourPieces++;
+		}
+		
+		return armourPieces;
+	}
+	
+	private boolean selectMinionTarget(EntityPlayer player, World world){
+	
+		RayTraceResult rayTrace = WizardryUtilities.standardEntityRayTrace(world, player, 16);
+		
+		if(rayTrace != null && rayTrace.entityHit instanceof EntityLivingBase){
+			
+			EntityLivingBase entity = (EntityLivingBase)rayTrace.entityHit;
+			
+			// Sets the selected minion's target to the right-clicked entity
+			if(player.isSneaking() && WizardData.get(player) != null && WizardData.get(player).selectedMinion != null){
+				
+				ISummonedCreature minion = WizardData.get(player).selectedMinion.get();
+				
+				if(minion instanceof EntityLiving && minion != entity){
+					// There is now only the new AI! (which greatly improves things)
+					((EntityLiving)minion).setAttackTarget(entity);
+					// Deselects the selected minion
+					WizardData.get(player).selectedMinion = null;
+					return true;
+				}
+			}
+		}
+		
+		return false;
+	}
+}

src/main/java/electroblob/wizardry/item/ItemWizardArmour.java

@@ -0,0 +1,217 @@
+package electroblob.wizardry.item;
+
+import java.util.List;
+
+import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.constants.Constants;
+import electroblob.wizardry.constants.Element;
+import electroblob.wizardry.registry.WizardryTabs;
+import electroblob.wizardry.spell.Petrify;
+import electroblob.wizardry.util.WizardryUtilities;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.EntityEquipmentSlot;
+import net.minecraft.item.EnumAction;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemArmor;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.EnumHandSide;
+import net.minecraftforge.common.ISpecialArmor;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public class ItemWizardArmour extends ItemArmor implements ISpecialArmor {
+
+	public Element element;
+
+	public ItemWizardArmour(ArmorMaterial material, int renderIndex, EntityEquipmentSlot armourType, Element element) {
+		super(material, renderIndex, armourType);
+		this.element = element;
+		this.setCreativeTab(WizardryTabs.WIZARDRY);
+	}
+	
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void addInformation(ItemStack stack, EntityPlayer player, List<String> tooltip, boolean advanced){
+		
+		if(stack.hasTagCompound() && stack.getTagCompound().getBoolean("legendary")) tooltip.add("\u00A7d" + net.minecraft.client.resources.I18n.format("item.wizardry:wizard_armour.legendary"));
+		if(element != null) tooltip.add("\u00A78" + net.minecraft.client.resources.I18n.format("item.wizardry:wizard_armour.buff", (int)(Constants.COST_REDUCTION_PER_ARMOUR*100) + "%", element.getDisplayName()));
+		tooltip.add("\u00A79" + net.minecraft.client.resources.I18n.format("item.wizardry:wizard_armour.mana", (this.getMaxDamage(stack) - this.getDamage(stack)), this.getMaxDamage(stack)));
+	}
+	
+	@Override
+	public String getItemStackDisplayName(ItemStack stack){
+        return ((this.element == null ? "" : this.element.getFormattingCode()) + super.getItemStackDisplayName(stack));
+    }
+	
+	@Override
+	@SideOnly(Side.CLIENT)
+	public boolean hasEffect(ItemStack stack){
+		return stack.hasTagCompound() && stack.getTagCompound().getBoolean("legendary");
+	}
+	
+	@Override
+	@SideOnly(Side.CLIENT)
+	public net.minecraft.client.model.ModelBiped getArmorModel(EntityLivingBase entityLiving, ItemStack itemStack, EntityEquipmentSlot armourSlot, net.minecraft.client.model.ModelBiped _default){
+		
+		net.minecraft.client.model.ModelBiped model = Wizardry.proxy.getWizardArmourModel();
+		
+		// Legs use modelBiped
+		if(armourSlot == EntityEquipmentSlot.LEGS) return null;
+		
+		if(model != null){
+			
+			model.bipedHead.showModel = armourSlot == EntityEquipmentSlot.HEAD;
+			model.bipedHeadwear.showModel = false;
+			model.bipedBody.showModel = armourSlot == EntityEquipmentSlot.CHEST || armourSlot == EntityEquipmentSlot.LEGS;
+			model.bipedRightArm.showModel = armourSlot == EntityEquipmentSlot.CHEST;
+			model.bipedLeftArm.showModel = armourSlot == EntityEquipmentSlot.CHEST;
+			model.bipedRightLeg.showModel = armourSlot == EntityEquipmentSlot.LEGS || armourSlot == EntityEquipmentSlot.FEET;
+			model.bipedLeftLeg.showModel = armourSlot == EntityEquipmentSlot.LEGS || armourSlot == EntityEquipmentSlot.FEET;
+			
+			model.isSneak = entityLiving.isSneaking();
+			model.isRiding = entityLiving.isRiding();
+			model.isChild = entityLiving.isChild();
+			
+			boolean leftHanded = entityLiving.getPrimaryHand() == EnumHandSide.LEFT;
+			
+			ItemStack itemstackR = leftHanded ? entityLiving.getHeldItemOffhand() : entityLiving.getHeldItemMainhand();
+			ItemStack itemstackL = leftHanded ? entityLiving.getHeldItemMainhand() : entityLiving.getHeldItemOffhand();
+
+			if (itemstackR != null)
+            {
+                model.rightArmPose = net.minecraft.client.model.ModelBiped.ArmPose.ITEM;
+
+                if (entityLiving.getItemInUseCount() > 0)
+                {
+                    EnumAction enumaction = itemstackR.getItemUseAction();
+
+                    if (enumaction == EnumAction.BLOCK)
+                    {
+                    	model.rightArmPose = net.minecraft.client.model.ModelBiped.ArmPose.BLOCK;
+                    }
+                    else if (enumaction == EnumAction.BOW)
+                    {
+                    	model.rightArmPose = net.minecraft.client.model.ModelBiped.ArmPose.BOW_AND_ARROW;
+                    }
+                }
+            }
+
+            if (itemstackL != null)
+            {
+            	model.leftArmPose = net.minecraft.client.model.ModelBiped.ArmPose.ITEM;
+
+                if (entityLiving.getItemInUseCount() > 0)
+                {
+                    EnumAction enumaction1 = itemstackL.getItemUseAction();
+
+                    if (enumaction1 == EnumAction.BLOCK)
+                    {
+                    	model.leftArmPose = net.minecraft.client.model.ModelBiped.ArmPose.BLOCK;
+                    }
+                    else if (enumaction1 == EnumAction.BOW)
+                    {
+                    	model.leftArmPose = net.minecraft.client.model.ModelBiped.ArmPose.BOW_AND_ARROW;
+                    }
+                }
+            }
+		}
+		
+        return model;
+    }
+	
+	@Override
+	public String getArmorTexture(ItemStack stack, Entity entity, EntityEquipmentSlot slot, String type) {
+
+		// Returns a completely transparent texture if the player is invisible. This is such an annoyingly easy
+		// fix, considering how long I spent trying to do this before - a bit of lateral thinking was all it took.
+		// Do note however that a texture pack could override this.
+		if(entity instanceof EntityLivingBase && ((EntityLivingBase)entity).isInvisible()
+				&& !entity.getEntityData().getBoolean(Petrify.NBT_KEY)) return "wizardry:textures/armour/invisible_armour.png";
+			
+		if(slot == EntityEquipmentSlot.LEGS) return this.element == null ? "wizardry:textures/armour/wizard_armour_legs.png" :
+        	"wizardry:textures/armour/wizard_armour_" + this.element.getUnlocalisedName() + "_legs.png";
+		
+        return this.element == null ? "wizardry:textures/armour/wizard_armour.png" :
+        	"wizardry:textures/armour/wizard_armour_" + this.element.getUnlocalisedName() + ".png";
+	}
+	
+	@Override
+	public boolean getIsRepairable(ItemStack stack, ItemStack par2ItemStack)
+    {
+        return false;
+    }
+
+	@Override
+	public ArmorProperties getProperties(EntityLivingBase player, ItemStack armor, DamageSource source, double damage, int slotIndex){
+		
+		EntityEquipmentSlot slot = getArmorSlotFromIndex(slotIndex);
+		
+		if (!source.isUnblockable() && armor.getItemDamage() < armor.getMaxDamage()){
+			if(armor.hasTagCompound() && armor.getTagCompound().getBoolean("legendary")){
+				// Legendary armour gives full 10 shields, like diamond.
+				return new ArmorProperties(0, ArmorMaterial.DIAMOND.getDamageReductionAmount(slot) / 25D, armor.getMaxDamage() + 1 - armor.getItemDamage());
+			}else{
+				return new ArmorProperties(0, this.damageReduceAmount / 25D, armor.getMaxDamage() + 1 - armor.getItemDamage());
+			}
+        }else{
+        	return new ArmorProperties(0, 0, 0);
+        }
+	}
+
+	@Override
+	public int getArmorDisplay(EntityPlayer player, ItemStack armor, int slotIndex) {
+		
+		EntityEquipmentSlot slot = getArmorSlotFromIndex(slotIndex);
+		
+		if(armor.getItemDamage() < armor.getMaxDamage()){
+			if(armor.hasTagCompound() && armor.getTagCompound().getBoolean("legendary")){
+				// Legendary armour gives full 10 shields, like diamond.
+				return ArmorMaterial.DIAMOND.getDamageReductionAmount(slot);
+			}else{
+				return this.getArmorMaterial().getDamageReductionAmount(slot);
+			}
+		}else{
+			return 0;
+		}
+	}
+
+	@Override
+	public void damageArmor(EntityLivingBase entity, ItemStack stack, DamageSource source, int damage, int slot){
+		if(stack.getItemDamage() < stack.getMaxDamage()){
+			if(stack.getItemDamage() + damage > stack.getMaxDamage()){
+				// Note for reference: this is the method to use, despite how it sounds attemptDamageItem() is called
+				// by this one, not the other way round.
+				stack.damageItem(stack.getMaxDamage() - stack.getItemDamage(), entity);
+			}else{
+				stack.damageItem(damage, entity);
+			}
+		}
+	}
+	
+	@Override
+    @SideOnly(Side.CLIENT)
+    public void getSubItems(Item item, CreativeTabs tab, List<ItemStack> subItems){
+        subItems.add(new ItemStack(this, 1));
+    }
+	
+	/** Returns the EntityEquipmentSlot for which index() returns an integer equal to the passed in slotIndex and
+	 * which is an armour slot (not a hand slot). This only exists because the 1.10.2 version of Forge still uses
+	 * an integer slot index in ISpecialArmor instead of an EntityEquipmentSlot. */
+	// NOTE: Remove in 1.11.2
+	private EntityEquipmentSlot getArmorSlotFromIndex(int slotIndex) {
+		// Had to pick something to begin with.
+		EntityEquipmentSlot slot = EntityEquipmentSlot.HEAD;
+		
+		for(EntityEquipmentSlot s : WizardryUtilities.ARMOUR_SLOTS){
+			if(s.getIndex() == slotIndex){
+				slot = s;
+			}
+		}
+		return slot;
+	}
+
+}

src/main/java/electroblob/wizardry/item/ItemWizardHandbook.java

@@ -0,0 +1,46 @@
+package electroblob.wizardry.item;
+
+import java.util.List;
+
+import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.WizardryGuiHandler;
+import electroblob.wizardry.registry.WizardryTabs;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.EnumActionResult;
+import net.minecraft.util.EnumHand;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public class ItemWizardHandbook extends Item {
+
+	// Yep, I hardcoded my own name into the mod. Don't want people changing it now, do I?
+	private static final String AUTHOR = "Electroblob";
+	
+	public ItemWizardHandbook() {
+		super();
+		this.setMaxStackSize(1);
+		this.setCreativeTab(WizardryTabs.WIZARDRY);
+	}
+
+	@Override
+	public void addInformation(ItemStack stack, EntityPlayer player, List<String> tooltip, boolean advanced){
+		tooltip.add("\u00A77" + net.minecraft.client.resources.I18n.format("item.wizardry:wizard_handbook.desc", AUTHOR));
+	}
+
+	@Override
+	public ActionResult<ItemStack> onItemRightClick(ItemStack stack, World world, EntityPlayer player, EnumHand hand){
+		player.openGui(Wizardry.instance, WizardryGuiHandler.WIZARD_HANDBOOK, world, 0, 0, 0);
+		return ActionResult.newResult(EnumActionResult.SUCCESS, stack);
+	}
+	
+	@Override
+    @SideOnly(Side.CLIENT)
+    public void getSubItems(Item item, CreativeTabs tab, List<ItemStack> items){
+        items.add(new ItemStack(this, 1));
+    }
+}