Merge branch '4.3-dev' into 1.12.2

src/main/java/electroblob/wizardry/client/gui/CustomCreativeSearchHandler.java

@@ -0,0 +1,109 @@
+package electroblob.wizardry.client.gui;
+
+import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.client.DrawingUtils;
+import electroblob.wizardry.registry.WizardryTabs;
+import electroblob.wizardry.spell.Spell;
+import net.minecraft.client.gui.GuiTextField;
+import net.minecraft.client.gui.inventory.GuiContainerCreative;
+import net.minecraft.client.resources.I18n;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.util.text.Style;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraftforge.client.event.GuiScreenEvent;
+import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
+import net.minecraftforge.fml.common.ObfuscationReflectionHelper;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.common.gameevent.TickEvent.ClientTickEvent;
+import net.minecraftforge.fml.common.gameevent.TickEvent.Phase;
+import net.minecraftforge.fml.relauncher.Side;
+
+import java.lang.reflect.Field;
+import java.util.Locale;
+
+@EventBusSubscriber(Side.CLIENT)
+public class CustomCreativeSearchHandler {
+
+	private static final int SEARCH_TOOLTIP_HOVER_TIME = 20;
+
+	private static final Style TOOLTIP_SYNTAX = new Style().setColor(TextFormatting.YELLOW);
+	private static final Style TOOLTIP_BODY = new Style().setColor(TextFormatting.WHITE);
+
+	/** Reflected into {@code GuiContainerCreative#searchField} */
+	private static final Field searchField;
+
+	private static GuiTextField currentSearchField = null;
+
+	private static int searchBarHoverTime;
+
+	static {
+		searchField = ObfuscationReflectionHelper.findField(GuiContainerCreative.class, "field_147062_A");
+	}
+
+	@SubscribeEvent
+	public static void onInitGuiEvent(GuiScreenEvent.InitGuiEvent.Post event){
+		// Reduces reflection as much as possible - searchField is created on GUI init and never reassigned so we need
+		// not (and should not!) use reflection to retrieve it every time a key is typed
+		if(event.getGui() instanceof GuiContainerCreative){
+			try{
+				currentSearchField = (GuiTextField)searchField.get(event.getGui());
+			}catch(IllegalAccessException e){
+				e.printStackTrace();
+			}
+		}
+	}
+
+	@SubscribeEvent
+	public static void onKeyboardInputEvent(GuiScreenEvent.KeyboardInputEvent.Post event){
+		// Custom creative tab search behaviour
+		if(event.getGui() instanceof GuiContainerCreative){
+
+			GuiContainerCreative gui = (GuiContainerCreative)event.getGui();
+			CreativeTabs tab = CreativeTabs.CREATIVE_TAB_ARRAY[gui.getSelectedTabIndex()];
+
+			if(tab == WizardryTabs.SPELLS){
+
+				GuiContainerCreative.ContainerCreative container = (GuiContainerCreative.ContainerCreative)gui.inventorySlots;
+				container.itemList.clear(); // Required or duplicates will appear!
+				String searchText = currentSearchField.getText().toLowerCase(Locale.ROOT);
+				tab.displayAllRelevantItems(container.itemList);
+
+				if(!searchText.isEmpty()){
+					container.itemList.removeIf(s -> !Spell.byMetadata(s.getMetadata()).matches(searchText));
+					container.scrollTo(0); // Seems to refresh the GUI somehow so it displays correctly
+				}
+			}
+		}
+	}
+
+	@SubscribeEvent
+	public static void onClientTickEvent(ClientTickEvent event){
+		if(event.phase == Phase.END && searchBarHoverTime > 0 && searchBarHoverTime < SEARCH_TOOLTIP_HOVER_TIME){
+			searchBarHoverTime++;
+		}
+	}
+
+	@SubscribeEvent
+	public static void onDrawScreenPostEvent(GuiScreenEvent.DrawScreenEvent.Post event){
+
+		if(event.getGui() instanceof GuiContainerCreative && currentSearchField != null){
+
+			GuiContainerCreative gui = (GuiContainerCreative)event.getGui();
+			CreativeTabs tab = CreativeTabs.CREATIVE_TAB_ARRAY[gui.getSelectedTabIndex()];
+
+			if(tab == WizardryTabs.SPELLS && DrawingUtils.isPointInRegion(currentSearchField.x, currentSearchField.y, currentSearchField.width, currentSearchField.height, event.getMouseX(), event.getMouseY())){
+
+				if(searchBarHoverTime == 0){
+					searchBarHoverTime++;
+				}else if(searchBarHoverTime == SEARCH_TOOLTIP_HOVER_TIME){
+					event.getGui().drawHoveringText(I18n.format("container." + Wizardry.MODID + ":arcane_workbench.search_tooltip",
+							TOOLTIP_SYNTAX.getFormattingCode(), TOOLTIP_BODY.getFormattingCode()), event.getMouseX(), event.getMouseY());
+				}
+			}
+
+		}else{
+			searchBarHoverTime = 0;
+		}
+	}
+
+}

src/main/java/electroblob/wizardry/client/gui/GuiBookshelf.java

@@ -0,0 +1,54 @@
+package electroblob.wizardry.client.gui;
+
+import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.inventory.ContainerBookshelf;
+import electroblob.wizardry.tileentity.TileEntityBookshelf;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+@SideOnly(Side.CLIENT)
+public class GuiBookshelf extends GuiContainer {
+
+	private static final ResourceLocation TEXTURE = new ResourceLocation(Wizardry.MODID, "textures/gui/container/bookshelf.png");
+	/** The player inventory bound to this GUI. */
+	private final InventoryPlayer playerInventory;
+	/** The inventory contained within the corresponding bookshelf. */
+	public IInventory bookshelfInventory;
+
+	public GuiBookshelf(InventoryPlayer playerInv, TileEntityBookshelf bookshelfInv){
+		super(new ContainerBookshelf(playerInv, bookshelfInv));
+		this.playerInventory = playerInv;
+		this.bookshelfInventory = bookshelfInv;
+		this.allowUserInput = false;
+		this.ySize = 148;
+	}
+
+	@Override
+	public void drawScreen(int mouseX, int mouseY, float partialTicks){
+		this.drawDefaultBackground();
+		super.drawScreen(mouseX, mouseY, partialTicks);
+		this.renderHoveredToolTip(mouseX, mouseY);
+	}
+
+    @Override
+	protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY){
+		String s = this.bookshelfInventory.getDisplayName().getUnformattedText();
+		this.fontRenderer.drawString(s, 8, 6, 4210752);
+		this.fontRenderer.drawString(this.playerInventory.getDisplayName().getUnformattedText(), 8, this.ySize - 96 + 2, 4210752);
+	}
+
+    @Override
+	protected void drawGuiContainerBackgroundLayer(float partialTicks, int mouseX, int mouseY){
+		GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
+		this.mc.getTextureManager().bindTexture(TEXTURE);
+		int i = (this.width - this.xSize) / 2;
+		int j = (this.height - this.ySize) / 2;
+		this.drawTexturedModalRect(i, j, 0, 0, this.xSize, this.ySize);
+	}
+
+}

src/main/java/electroblob/wizardry/client/gui/GuiButtonResurrect.java

@@ -7,8 +7,8 @@ import electroblob.wizardry.packet.WizardryPacketHandler;
 import electroblob.wizardry.registry.Spells;
 import electroblob.wizardry.registry.WizardryItems;
 import electroblob.wizardry.spell.Resurrection;
+import electroblob.wizardry.util.InventoryUtils;
 import electroblob.wizardry.util.SpellModifiers;
-import electroblob.wizardry.util.WizardryUtilities;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.client.gui.GuiGameOver;
@@ -52,7 +52,7 @@ public class GuiButtonResurrect extends GuiButton {
 	public static void onGuiScreenInitEvent(GuiScreenEvent.InitGuiEvent event){
 
 		if(event.getGui() instanceof GuiGameOver && ItemArtefact.isArtefactActive(Minecraft.getMinecraft().player, WizardryItems.amulet_resurrection)
-				&& WizardryUtilities.getHotbar(Minecraft.getMinecraft().player).stream().anyMatch(s -> Resurrection.canStackResurrect(s, Minecraft.getMinecraft().player))){
+				&& InventoryUtils.getHotbar(Minecraft.getMinecraft().player).stream().anyMatch(s -> Resurrection.canStackResurrect(s, Minecraft.getMinecraft().player))){
 
 			event.getButtonList().add(new GuiButtonResurrect(event.getButtonList().size(), event.getGui().width / 2 - 100,
 					event.getGui().height / 4 + 120, "spell." + Spells.resurrection.getRegistryName() + ".button"));
@@ -65,7 +65,7 @@ public class GuiButtonResurrect extends GuiButton {
 
 		if(event.getGui() instanceof GuiGameOver){
 
-			ItemStack stack = WizardryUtilities.getHotbar(Minecraft.getMinecraft().player).stream()
+			ItemStack stack = InventoryUtils.getHotbar(Minecraft.getMinecraft().player).stream()
 					.filter(s -> Resurrection.canStackResurrect(s, Minecraft.getMinecraft().player)).findFirst().orElse(null);
 
 			if(stack != null){

src/main/java/electroblob/wizardry/client/gui/GuiButtonSpellSort.java

@@ -0,0 +1,57 @@
+package electroblob.wizardry.client.gui;
+
+import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.client.DrawingUtils;
+import electroblob.wizardry.util.ISpellSortable;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.resources.I18n;
+import net.minecraft.util.ResourceLocation;
+
+public class GuiButtonSpellSort extends GuiButton {
+
+	private static final ResourceLocation TEXTURE = new ResourceLocation(Wizardry.MODID, "textures/gui/container/spell_sort_buttons.png");
+	private static final int TEXTURE_WIDTH = 32;
+	private static final int TEXTURE_HEIGHT = 32;
+
+	public final ISpellSortable.SortType sortType;
+
+	private final ISpellSortable sortable;
+	private final GuiScreen parent;
+
+	public GuiButtonSpellSort(int id, int x, int y, ISpellSortable.SortType sortType, ISpellSortable sortable, GuiScreen parent){
+		super(id, x, y, 10, 10, I18n.format("container." + Wizardry.MODID + ":arcane_workbench.sort_" + sortType.name));
+		this.sortType = sortType;
+		this.sortable = sortable;
+		this.parent = parent;
+	}
+
+	@Override
+	public void drawButton(Minecraft minecraft, int mouseX, int mouseY, float partialTicks){
+
+		if(this.visible){
+
+			// Whether the button is highlighted
+			this.hovered = mouseX >= this.x && mouseY >= this.y && mouseX < this.x + this.width && mouseY < this.y + this.height;
+
+			int k = 0;
+			int l = this.sortType.ordinal() * this.height;
+
+			if(sortType == sortable.getSortType()){
+				k += this.width;
+				if(sortable.isSortDescending()) k += this.width;
+			}
+
+			parent.mc.getTextureManager().bindTexture(TEXTURE);
+			DrawingUtils.drawTexturedRect(this.x, this.y, k, l, this.width, this.height, TEXTURE_WIDTH, TEXTURE_HEIGHT);
+
+		}
+	}
+
+	@Override
+	public void drawButtonForegroundLayer(int mouseX, int mouseY){
+		if(hovered) parent.drawHoveringText(this.displayString, mouseX, mouseY);
+	}
+
+}

src/main/java/electroblob/wizardry/client/gui/GuiButtonTurnPage.java

@@ -1,6 +1,5 @@
-package electroblob.wizardry.client.gui.handbook;
+package electroblob.wizardry.client.gui;
 
-import electroblob.wizardry.Wizardry;
 import electroblob.wizardry.client.DrawingUtils;
 import electroblob.wizardry.registry.WizardrySounds;
 import net.minecraft.client.Minecraft;
@@ -11,12 +10,12 @@ import net.minecraft.client.renderer.GlStateManager;
 import net.minecraft.util.ResourceLocation;
 
 //@SideOnly(Side.CLIENT)
-class GuiButtonTurnPage extends GuiButton {
+public class GuiButtonTurnPage extends GuiButton {
 
-	static final int WIDTH = 20;
-	static final int HEIGHT = 12;
+	public static final int WIDTH = 20;
+	public static final int HEIGHT = 12;
 
-	enum Type {
+	public enum Type {
 		
 		NEXT_PAGE(0, 196),
 		PREVIOUS_PAGE(0, 208),
@@ -34,11 +33,15 @@ class GuiButtonTurnPage extends GuiButton {
 	
 	public final Type type;
 
-	private static final ResourceLocation texture = new ResourceLocation(Wizardry.MODID, "textures/gui/handbook.png");
+	private final ResourceLocation texture;
+	private final int textureWidth, textureHeight;
 
-	public GuiButtonTurnPage(int id, int x, int y, Type type){
+	public GuiButtonTurnPage(int id, int x, int y, Type type, ResourceLocation texture, int textureWidth, int textureHeight){
 		super(id, x, y, WIDTH, HEIGHT, "");
 		this.type = type;
+		this.texture = texture;
+		this.textureWidth = textureWidth;
+		this.textureHeight = textureHeight;
 	}
 	
 	@Override
@@ -50,12 +53,13 @@ class GuiButtonTurnPage extends GuiButton {
 	public void drawButton(Minecraft minecraft, int mouseX, int mouseY, float partialTicks){
 		
 		if(this.visible){
-			
+
 			boolean flag = mouseX >= this.x && mouseY >= this.y && mouseX < this.x + this.width && mouseY < this.y + this.height;
 			GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
 			minecraft.getTextureManager().bindTexture(texture);
 
-			DrawingUtils.drawTexturedRect(this.x, this.y, flag ? type.u + width : type.u, type.v, width, height, 512, 256);
+			DrawingUtils.drawTexturedRect(this.x, this.y, flag ? type.u + width : type.u, type.v, width, height, textureWidth, textureHeight);
 		}
 	}
+
 }

src/main/java/electroblob/wizardry/client/gui/GuiLectern.java

@@ -0,0 +1,499 @@
+package electroblob.wizardry.client.gui;
+
+import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.block.BlockBookshelf;
+import electroblob.wizardry.client.DrawingUtils;
+import electroblob.wizardry.client.gui.GuiButtonTurnPage.Type;
+import electroblob.wizardry.data.SpellGlyphData;
+import electroblob.wizardry.item.ItemSpellBook;
+import electroblob.wizardry.packet.PacketLectern;
+import electroblob.wizardry.packet.WizardryPacketHandler;
+import electroblob.wizardry.registry.Spells;
+import electroblob.wizardry.registry.WizardrySounds;
+import electroblob.wizardry.spell.Spell;
+import electroblob.wizardry.tileentity.TileEntityLectern;
+import electroblob.wizardry.util.GeometryUtils;
+import electroblob.wizardry.util.ISpellSortable;
+import electroblob.wizardry.util.ParticleBuilder;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.audio.PositionedSoundRecord;
+import net.minecraft.client.audio.SoundHandler;
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.gui.GuiTextField;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.resources.I18n;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.network.play.client.CPacketCloseWindow;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.MathHelper;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.util.text.Style;
+import net.minecraft.util.text.TextFormatting;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.stream.Collectors;
+
+public class GuiLectern extends GuiSpellInfo implements ISpellSortable {
+
+	private static final ResourceLocation TEXTURE = new ResourceLocation(Wizardry.MODID, "textures/gui/container/lectern.png");
+	/** The distance of the page buttons from the bottom outside corners of the GUI. */
+	private static final int PAGE_BUTTON_INSET_X = 22, PAGE_BUTTON_INSET_Y = 13;
+	/** The distance between adjacent page turn buttons. */
+	private static final int PAGE_BUTTON_SPACING = 20;
+	/** The distance of the sort buttons from the top left corner of the GUI. */
+	private static final int SORT_BUTTON_INSET_X = 96, SORT_BUTTON_INSET_Y = 20;
+	/** The distance between adjacent sort buttons. */
+	private static final int SORT_BUTTON_SPACING = 13;
+	/** The distance of the spell buttons from the top outside corners of the GUI. */
+	private static final int SPELL_BUTTON_INSET_X = 23, SPELL_BUTTON_INSET_Y = 44;
+	/** The distance between adjacent spell buttons (in both x and y). */
+	private static final int SPELL_BUTTON_SPACING = 38;
+
+	private static final int SPELL_ROWS = 3, SPELL_COLUMNS = 3;
+	public static final int SPELL_BUTTON_COUNT = SPELL_ROWS * SPELL_COLUMNS * 2; // x2 because there are 2 pages
+
+	private static final int SEARCH_TOOLTIP_HOVER_TIME = 20;
+
+	private static final Style TOOLTIP_SYNTAX = new Style().setColor(TextFormatting.YELLOW);
+	private static final Style TOOLTIP_BODY = new Style().setColor(TextFormatting.WHITE);
+
+	private final TileEntityLectern lectern;
+
+	private GuiButton nextPageButton;
+	private GuiButton prevPageButton;
+	private GuiButton lastPageButton;
+	private GuiButton firstPageButton;
+	private GuiButton indexButton;
+	private GuiButton locateButton;
+
+	private GuiButton[] sortButtons = new GuiButton[3];
+	private GuiButtonSpell[] spellButtons = new GuiButtonSpell[SPELL_BUTTON_COUNT];
+
+	/** The spell currently being viewed, or null if the index is being viewed. */
+	private Spell currentSpell;
+	/** The available spells in nearby bookshelves; should not contain duplicates. */
+	private List<Spell> availableSpells = new ArrayList<>();
+	/** The spells matching the current search criteria, sorted according to the current sort settings. Will be a subset
+	 * of {@link GuiLectern#availableSpells}. */
+	private List<Spell> matchingSpells;
+
+	private ISpellSortable.SortType sortType = ISpellSortable.SortType.TIER;
+	private boolean sortDescending = false;
+
+	private GuiTextField searchField;
+	private boolean searchNeedsClearing;
+	private int searchBarHoverTime;
+
+	private int currentPage = 0;
+
+	public GuiLectern(TileEntityLectern lectern){
+		super(288, 180);
+		this.lectern = lectern;
+		this.currentSpell = lectern.currentSpell;
+		this.setTextureSize(512, 512);
+	}
+
+	@Override
+	public Spell getSpell(){
+		return currentSpell;
+	}
+
+	@Override
+	public ResourceLocation getTexture(){
+		return TEXTURE;
+	}
+
+	@Override
+	public SortType getSortType(){
+		return sortType;
+	}
+
+	@Override
+	public boolean isSortDescending(){
+		return sortDescending;
+	}
+
+	private int getPageCount(){
+		return MathHelper.ceil((float)matchingSpells.size() / SPELL_BUTTON_COUNT);
+	}
+
+	private Spell getSpellForButton(GuiButtonSpell button){
+		return matchingSpells.get(currentPage * SPELL_BUTTON_COUNT + button.index);
+	}
+
+	@Override
+	public void initGui(){
+
+		super.initGui();
+
+		final int left = this.width / 2 - this.xSize / 2;
+		final int top = this.height / 2 - this.ySize / 2;
+
+		int buttonID = 0;
+
+		// Page buttons
+		this.buttonList.add(nextPageButton = new GuiButtonTurnPage(buttonID++, left + xSize - PAGE_BUTTON_INSET_X - GuiButtonTurnPage.WIDTH,
+				top + ySize - PAGE_BUTTON_INSET_Y - GuiButtonTurnPage.HEIGHT, Type.NEXT_PAGE, TEXTURE, textureWidth, textureHeight));
+
+		this.buttonList.add(prevPageButton = new GuiButtonTurnPage(buttonID++, left + PAGE_BUTTON_INSET_X,
+				top + ySize - PAGE_BUTTON_INSET_Y - GuiButtonTurnPage.HEIGHT, Type.PREVIOUS_PAGE, TEXTURE, textureWidth, textureHeight));
+
+		this.buttonList.add(lastPageButton = new GuiButtonTurnPage(buttonID++, left + xSize - PAGE_BUTTON_INSET_X - GuiButtonTurnPage.WIDTH - PAGE_BUTTON_SPACING,
+				top + ySize - PAGE_BUTTON_INSET_Y - GuiButtonTurnPage.HEIGHT, Type.NEXT_SECTION, TEXTURE, textureWidth, textureHeight));
+
+		this.buttonList.add(firstPageButton = new GuiButtonTurnPage(buttonID++, left + PAGE_BUTTON_INSET_X + PAGE_BUTTON_SPACING,
+				top + ySize - PAGE_BUTTON_INSET_Y - GuiButtonTurnPage.HEIGHT, Type.PREVIOUS_SECTION, TEXTURE, textureWidth, textureHeight));
+
+		this.buttonList.add(indexButton = new GuiButtonTurnPage(buttonID++, left + xSize/2 - 23,
+				top + ySize - PAGE_BUTTON_INSET_Y - GuiButtonTurnPage.HEIGHT, Type.CONTENTS, TEXTURE, textureWidth, textureHeight));
+
+		this.buttonList.add(locateButton = new GuiButtonLocateBook(buttonID++, left + xSize/2 - 34,
+				top + ySize - PAGE_BUTTON_INSET_Y - GuiButtonTurnPage.HEIGHT));
+
+		// Sort buttons
+		for(SortType sortType : SortType.values()){
+			this.buttonList.add(sortButtons[sortType.ordinal()] = new GuiButtonSpellSort(buttonID++,
+					left + SORT_BUTTON_INSET_X + SORT_BUTTON_SPACING * sortType.ordinal(),
+					top + SORT_BUTTON_INSET_Y, sortType, this, this));
+		}
+
+		// Spell buttons
+		for(int i = 0; i < SPELL_BUTTON_COUNT; i++){
+
+			int row = i % SPELL_COLUMNS;
+			int column = (i / SPELL_COLUMNS) % SPELL_ROWS;
+
+			int x = i < SPELL_BUTTON_COUNT/2 ? SPELL_BUTTON_INSET_X + row * SPELL_BUTTON_SPACING
+					: xSize - SPELL_BUTTON_INSET_X - GuiButtonSpell.WIDTH - (2-row) * SPELL_BUTTON_SPACING;
+			int y = SPELL_BUTTON_INSET_Y + column * SPELL_BUTTON_SPACING;
+
+			this.buttonList.add(spellButtons[i] = new GuiButtonSpell(buttonID++, left + x, top + y, i));
+		}
+
+		this.searchField = new GuiTextField(0, this.fontRenderer, left + 157, top + 21, 106, this.fontRenderer.FONT_HEIGHT);
+		this.searchField.setMaxStringLength(50);
+		this.searchField.setEnableBackgroundDrawing(false);
+		this.searchField.setVisible(true);
+		this.searchField.setTextColor(16777215);
+		this.searchField.setCanLoseFocus(false);
+		this.searchField.setFocused(true);
+
+		refreshAvailableSpells(); // Must be done last
+
+	}
+
+	@Override
+	public void updateScreen(){
+		super.updateScreen();
+		if(searchBarHoverTime > 0 && searchBarHoverTime < SEARCH_TOOLTIP_HOVER_TIME) searchBarHoverTime++;
+	}
+
+	@Override
+	public void onGuiClosed(){
+		WizardryPacketHandler.net.sendToServer(new PacketLectern.Message(lectern.getPos(), currentSpell));
+		super.onGuiClosed();
+	}
+
+	@Override
+	protected void drawBackgroundLayer(int left, int top, int mouseX, int mouseY){
+		if(currentSpell == Spells.none){
+			drawIndexPage(left, top);
+		}else{
+			super.drawBackgroundLayer(left, top, mouseX, mouseY);
+		}
+	}
+
+	@Override
+	protected void drawForegroundLayer(int left, int top, int mouseX, int mouseY){
+
+		if(currentSpell == Spells.none){
+			this.fontRenderer.drawString(I18n.format("gui." + Wizardry.MODID + ":lectern.title"),
+					left + 20, top + SORT_BUTTON_INSET_Y, 0);
+		}else{
+			super.drawForegroundLayer(left, top, mouseX, mouseY);
+		}
+
+		this.buttonList.forEach(b -> b.drawButtonForegroundLayer(mouseX, mouseY));
+
+		// Search tooltip
+		if(DrawingUtils.isPointInRegion(searchField.x, searchField.y, searchField.width, searchField.height, mouseX, mouseY)){
+			if(searchBarHoverTime == 0){
+				searchBarHoverTime++;
+			}else if(searchBarHoverTime == SEARCH_TOOLTIP_HOVER_TIME){
+				drawHoveringText(I18n.format("container." + Wizardry.MODID + ":arcane_workbench.search_tooltip",
+						TOOLTIP_SYNTAX.getFormattingCode(), TOOLTIP_BODY.getFormattingCode()), mouseX, mouseY);
+			}
+		}else{
+			searchBarHoverTime = 0;
+		}
+	}
+
+	private void drawIndexPage(int left, int top){
+
+		for(int i = 0; i < SPELL_BUTTON_COUNT; i++){
+
+			int index = currentPage * SPELL_BUTTON_COUNT + i;
+			Spell spell = index < matchingSpells.size() ? matchingSpells.get(index) : Spells.none;
+			boolean discovered = Wizardry.proxy.shouldDisplayDiscovered(spell, null);
+
+			Minecraft.getMinecraft().renderEngine.bindTexture(discovered ? spell.getIcon() : Spells.none.getIcon());
+
+			int row = i % SPELL_COLUMNS;
+			int column = (i / SPELL_COLUMNS) % SPELL_ROWS;
+
+			int x = i < SPELL_BUTTON_COUNT/2 ? SPELL_BUTTON_INSET_X + row * SPELL_BUTTON_SPACING
+					: xSize - SPELL_BUTTON_INSET_X - GuiButtonSpell.WIDTH - (2-row) * SPELL_BUTTON_SPACING;
+			int y = SPELL_BUTTON_INSET_Y + column * SPELL_BUTTON_SPACING;
+
+			DrawingUtils.drawTexturedRect(left + x + 1, top + y + 1, 0, 0, 32, 32, 32, 32);
+		}
+
+		mc.renderEngine.bindTexture(getTexture());
+		DrawingUtils.drawTexturedRect(left, top, 0, 256, xSize, ySize, textureWidth, textureHeight);
+
+		this.searchField.drawTextBox();
+
+		GlStateManager.color(1, 1, 1, 1);
+		mc.renderEngine.bindTexture(getTexture());
+
+	}
+
+	@Override
+	protected void mouseClicked(int mouseX, int mouseY, int mouseButton) throws IOException {
+		super.mouseClicked(mouseX, mouseY, mouseButton);
+		searchNeedsClearing = true;
+	}
+
+	@Override
+	protected void actionPerformed(GuiButton button){
+
+		int lastPage = getPageCount() - 1;
+
+		if(button == indexButton){
+			currentSpell = Spells.none;
+//			currentPage = 0;
+
+		}else if(button == locateButton){
+			// Close the GUI
+			this.mc.player.connection.sendPacket(new CPacketCloseWindow(this.mc.player.openContainer.windowId));
+			this.mc.displayGuiScreen(null);
+
+			// Find the location(s) of the current spell's book(s) and highlight them
+			for(IInventory bookshelf : BlockBookshelf.findNearbyBookshelves(lectern.getWorld(), lectern.getPos())){
+
+				for(int i = 0; i < bookshelf.getSizeInventory(); i++){
+
+					ItemStack stack = bookshelf.getStackInSlot(i);
+
+					if(stack.getItem() instanceof ItemSpellBook){
+
+						Spell spell = Spell.byMetadata(stack.getMetadata());
+
+						if(spell == this.currentSpell){
+
+							BlockPos pos = (((TileEntity)bookshelf).getPos());
+
+							for(EnumFacing side : EnumFacing.VALUES){
+								ParticleBuilder.create(ParticleBuilder.Type.BLOCK_HIGHLIGHT).pos(
+												GeometryUtils.getFaceCentre(pos, side)
+												.add(new Vec3d(side.getDirectionVec())
+												.scale(GeometryUtils.ANTI_Z_FIGHTING_OFFSET)))
+										.face(side).clr(0.9f, 0.5f, 0.8f).fade(0.7f, 0, 1).spawn(mc.world);
+							}
+
+							mc.world.playSound(pos, WizardrySounds.BLOCK_LECTERN_LOCATE_SPELL, SoundCategory.BLOCKS, 1, 0.7f, false);
+
+							break; // This bookshelf has the spell, skip to the next bookshelf
+						}
+					}
+				}
+			}
+
+		}else if(button == nextPageButton){
+			if(currentPage < lastPage) currentPage++;
+
+		}else if(button == prevPageButton){
+			if(currentPage > 0) currentPage--;
+
+		}else if(button == lastPageButton){
+			currentPage = lastPage;
+
+		}else if(button == firstPageButton){
+			currentPage = 0;
+
+		}else if(button instanceof GuiButtonSpell){
+			currentSpell = getSpellForButton((GuiButtonSpell)button);
+
+		}else if(button instanceof GuiButtonSpellSort){
+
+			SortType sortType = (((GuiButtonSpellSort)button).sortType);
+
+			if(this.sortType == sortType){
+				this.sortDescending = !this.sortDescending;
+			}else{
+				this.sortType = sortType;
+				this.sortDescending = false;
+			}
+
+			updateMatchingSpells();
+		}
+
+		updateButtonVisiblity();
+
+	}
+
+	@Override
+	protected void keyTyped(char typedChar, int keyCode) throws IOException {
+
+		if(this.searchNeedsClearing){
+			this.searchNeedsClearing = false;
+			this.searchField.setText("");
+			this.currentPage = 0;
+		}
+
+		if(this.searchField.textboxKeyTyped(typedChar, keyCode)){
+			this.currentPage = 0;
+			updateMatchingSpells();
+			updateButtonVisiblity();
+		}else{
+			super.keyTyped(typedChar, keyCode);
+		}
+	}
+
+	private void updateButtonVisiblity(){
+
+		if(currentSpell == Spells.none){
+
+			this.searchField.setVisible(true);
+
+			int lastPage = getPageCount() - 1;
+
+			prevPageButton.visible = currentPage > 0;
+			firstPageButton.visible = currentPage > 0;
+			nextPageButton.visible = currentPage < lastPage;
+			lastPageButton.visible = currentPage < lastPage;
+
+			indexButton.visible = false;
+			locateButton.visible = false;
+
+			for(GuiButton button : sortButtons) button.visible = true;
+
+			for(GuiButtonSpell button : spellButtons){
+				button.visible = currentPage * SPELL_BUTTON_COUNT + button.index < matchingSpells.size();
+			}
+
+		}else{
+			this.searchField.setVisible(false);
+			this.buttonList.forEach(b -> b.visible = false); // Hide all buttons...
+			indexButton.visible = true; // ... except the index button and locate button
+			locateButton.visible = true;
+		}
+	}
+
+	private void updateMatchingSpells(){
+		matchingSpells = availableSpells.stream()
+				.filter(s -> s.matches(searchField.getText().toLowerCase(Locale.ROOT)))
+				.sorted(sortDescending ? sortType.comparator.reversed() : sortType.comparator)
+				.collect(Collectors.toList());
+	}
+
+	// TODO: Config option to always display all spells when in creative
+	/** Called on initialisation and whenever a bookshelf is added or removed, to update the list of spells. */
+	public void refreshAvailableSpells(){
+
+		availableSpells.clear();
+
+		// No need to exclude the lectern TE because it's not an IInventory!
+		for(IInventory bookshelf : BlockBookshelf.findNearbyBookshelves(lectern.getWorld(), lectern.getPos())){
+
+			for(int i=0; i<bookshelf.getSizeInventory(); i++){
+
+				ItemStack stack = bookshelf.getStackInSlot(i);
+
+				if(stack.getItem() instanceof ItemSpellBook){
+					Spell spell = Spell.byMetadata(stack.getMetadata());
+					if(spell != Spells.none && !availableSpells.contains(spell)) availableSpells.add(spell);
+				}
+			}
+		}
+
+		if(!availableSpells.contains(currentSpell)) currentSpell = Spells.none;
+
+		updateMatchingSpells();
+		updateButtonVisiblity();
+
+	}
+
+	private class GuiButtonLocateBook extends GuiButton {
+
+		public GuiButtonLocateBook(int id, int x, int y){
+			super(id, x, y, 12, 12, "");
+		}
+
+		@Override
+		public void drawButton(Minecraft minecraft, int mouseX, int mouseY, float partialTicks){
+
+			if(this.visible){
+
+				boolean flag = mouseX >= this.x && mouseY >= this.y && mouseX < this.x + this.width && mouseY < this.y + this.height;
+				GlStateManager.color(1, 1, 1, 1);
+				minecraft.getTextureManager().bindTexture(TEXTURE);
+
+				DrawingUtils.drawTexturedRect(this.x, this.y, flag ? width : 0, 184, width, height, textureWidth, textureHeight);
+			}
+		}
+
+	}
+
+	private class GuiButtonSpell extends GuiButtonInvisible {
+
+		private static final int WIDTH = 34, HEIGHT = 34;
+
+		private final int index;
+
+		public GuiButtonSpell(int id, int x, int y, int index){
+			super(id, x, y, WIDTH, HEIGHT);
+			this.index = index;
+		}
+
+		@Override
+		public void playPressSound(SoundHandler soundHandler){
+			soundHandler.playSound(PositionedSoundRecord.getMasterRecord(WizardrySounds.MISC_PAGE_TURN, 1));
+		}
+
+		@Override
+		public void drawButton(Minecraft minecraft, int mouseX, int mouseY, float partialTicks){
+			if(visible){
+				super.drawButton(minecraft, mouseX, mouseY, partialTicks);
+				if(hovered){
+					mc.renderEngine.bindTexture(getTexture());
+					DrawingUtils.drawTexturedRect(x, y, 40, 180, width, height, textureWidth, textureHeight);
+				}
+			}
+		}
+
+		@Override
+		public void drawButtonForegroundLayer(int mouseX, int mouseY){
+			if(visible && hovered){
+				Spell spell = getSpellForButton(this);
+				if(Wizardry.proxy.shouldDisplayDiscovered(spell, null)){
+					drawHoveringText(Collections.singletonList(spell.getDisplayName()), mouseX, mouseY, fontRenderer);
+				}else{
+					drawHoveringText(Collections.singletonList(SpellGlyphData.getGlyphName(spell, mc.world)),
+							mouseX, mouseY, mc.standardGalacticFontRenderer);
+				}
+			}
+		}
+
+	}
+
+}

src/main/java/electroblob/wizardry/client/gui/GuiSpellBook.java

@@ -1,113 +1,35 @@
 package electroblob.wizardry.client.gui;
 
-import electroblob.wizardry.Wizardry;
-import electroblob.wizardry.client.DrawingUtils;
-import electroblob.wizardry.constants.Tier;
-import electroblob.wizardry.data.SpellGlyphData;
-import electroblob.wizardry.data.WizardData;
 import electroblob.wizardry.item.ItemSpellBook;
-import electroblob.wizardry.registry.Spells;
-import electroblob.wizardry.registry.WizardrySounds;
 import electroblob.wizardry.spell.Spell;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.audio.PositionedSoundRecord;
-import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.client.renderer.GlStateManager;
-import net.minecraft.client.resources.I18n;
-import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
-import org.lwjgl.input.Keyboard;
+import net.minecraft.util.ResourceLocation;
 
-public class GuiSpellBook extends GuiScreen {
+public class GuiSpellBook extends GuiSpellInfo {
 
-	private int xSize, ySize;
-	private ItemSpellBook book;
-	private Spell spell;
+	private final ItemSpellBook book;
+	private final Spell spell;
 
 	public GuiSpellBook(ItemStack stack){
-		super();
-		xSize = 288;
-		ySize = 180;
-		if(!(stack.getItem() instanceof ItemSpellBook)) throw new ClassCastException("Cannot create spell book GUI for item that does not extend ItemSpellBook!");
+
+		super(288, 180);
+
+		if(!(stack.getItem() instanceof ItemSpellBook)){
+			throw new ClassCastException("Cannot create spell book GUI for item that does not extend ItemSpellBook!");
+		}
+
 		this.book = (ItemSpellBook)stack.getItem();
-		this.spell = Spell.byMetadata(stack.getItemDamage());
+		this.spell = (Spell.byMetadata(stack.getItemDamage()));
 	}
 
 	@Override
-	public void drawScreen(int par1, int par2, float par3){
-
-		int xPos = this.width / 2 - xSize / 2;
-		int yPos = this.height / 2 - this.ySize / 2;
-
-		EntityPlayer player = Minecraft.getMinecraft().player;
-
-		boolean discovered = true;
-		if(Wizardry.settings.discoveryMode && !player.isCreative() && WizardData.get(player) != null
-				&& !WizardData.get(player).hasSpellBeenDiscovered(spell)){
-			discovered = false;
-		}
-
-		GlStateManager.color(1, 1, 1, 1); // Just in case
-
-		// Draws spell illustration on opposite page, underneath the book so it shows through the hole.
-		Minecraft.getMinecraft().renderEngine.bindTexture(discovered ? spell.getIcon() : Spells.none.getIcon());
-		DrawingUtils.drawTexturedRect(xPos + 146, yPos + 20, 0, 0, 128, 128, 128, 128);
-		
-		Minecraft.getMinecraft().renderEngine.bindTexture(book.getGuiTexture(spell));
-		DrawingUtils.drawTexturedRect(xPos, yPos, 0, 0, xSize, ySize, xSize, 256);
-
-		super.drawScreen(par1, par2, par3);
-
-		if(discovered){
-			this.fontRenderer.drawString(spell.getDisplayName(), xPos + 17, yPos + 15, 0);
-			this.fontRenderer.drawString(spell.getType().getDisplayName(), xPos + 17, yPos + 26, 0x777777);
-		}else{
-			this.mc.standardGalacticFontRenderer.drawString(SpellGlyphData.getGlyphName(spell, player.world), xPos + 17,
-					yPos + 15, 0);
-			this.mc.standardGalacticFontRenderer.drawString(spell.getType().getDisplayName(), xPos + 17, yPos + 26,
-					0x777777);
-		}
-
-		// Novice is usually white but this doesn't show up
-		String tier = I18n.format("gui.ebwizardry:spell_book.tier", spell.getTier() == Tier.NOVICE ?
-				"\u00A77" + spell.getTier().getDisplayName() : spell.getTier().getDisplayNameWithFormatting());
-		this.fontRenderer.drawString(tier, xPos + 17, yPos + 45, 0);
-
-		String element = I18n.format("gui.ebwizardry:spell_book.element", spell.getElement().getFormattingCode() + spell.getElement().getDisplayName());
-		if(!discovered) element = I18n.format("gui.ebwizardry:spell_book.element_undiscovered");
-		this.fontRenderer.drawString(element, xPos + 17, yPos + 57, 0);
-
-		String manaCost = I18n.format("gui.ebwizardry:spell_book.mana_cost", spell.getCost());
-		if(spell.isContinuous) manaCost = I18n.format("gui.ebwizardry:spell_book.mana_cost_continuous", spell.getCost());
-		if(!discovered) manaCost = I18n.format("gui.ebwizardry:spell_book.mana_cost_undiscovered");
-		this.fontRenderer.drawString(manaCost, xPos + 17, yPos + 69, 0);
-
-		if(discovered){
-			this.fontRenderer.drawSplitString(spell.getDescription(), xPos + 17, yPos + 83, 118, 0);
-		}else{
-			this.mc.standardGalacticFontRenderer.drawSplitString(
-					SpellGlyphData.getGlyphDescription(spell, player.world), xPos + 17, yPos + 83, 118, 0);
-		}
+	public Spell getSpell(){
+		return spell;
 	}
 
 	@Override
-	public void initGui(){
-		super.initGui();
-		Keyboard.enableRepeatEvents(true);
-		this.buttonList.clear();
-		
-		this.mc.getSoundHandler().playSound(PositionedSoundRecord.getMasterRecord(WizardrySounds.MISC_BOOK_OPEN, 1));
-	}
-
-	@Override
-	public void onGuiClosed(){
-		super.onGuiClosed();
-		Keyboard.enableRepeatEvents(false);
-	}
-
-	@Override
-	public boolean doesGuiPauseGame(){
-		return Wizardry.settings.booksPauseGame;
+	public ResourceLocation getTexture(){
+		return book.getGuiTexture(spell);
 	}
 
 }

src/main/java/electroblob/wizardry/client/gui/GuiSpellDisplay.java

@@ -14,7 +14,7 @@ import electroblob.wizardry.item.ISpellCastingItem;
 import electroblob.wizardry.registry.Spells;
 import electroblob.wizardry.registry.WizardryPotions;
 import electroblob.wizardry.spell.Spell;
-import electroblob.wizardry.util.WandHelper;
+import electroblob.wizardry.util.SpellModifiers;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.FontRenderer;
 import net.minecraft.client.renderer.GlStateManager;
@@ -45,7 +45,8 @@ import java.nio.charset.StandardCharsets;
 public class GuiSpellDisplay {
 
 	private static final ResourceLocation INDEX = new ResourceLocation(Wizardry.MODID, "textures/gui/spell_hud/_index.json");
-	
+	private static final ResourceLocation CHARGE_METER = new ResourceLocation(Wizardry.MODID, "textures/gui/spell_charge_meter.png");
+
 	/** A map which stores all loaded HUD skin objects. This gets wiped on resource pack reload and repopulated with
 	 * mappings as specified by {@code _index.json} (these stack between resource packs). The keys in the map correspond
 	 * to the keys in {@code _index.json}, and are sorted in that order, with skins belonging to resource packs sorted
@@ -54,6 +55,12 @@ public class GuiSpellDisplay {
 	private static final Map<String, Skin> skins = new LinkedHashMap<>(14); // 14 is the number of skins packaged with the mod
 	
 	private static final Gson gson = new Gson();
+	private static final Random random = new Random();
+
+	/** Width of the charge meter. */
+	private static final int CHARGE_METER_WIDTH = 25;
+	/** Height of the charge meter. */
+	private static final int CHARGE_METER_HEIGHT = 9;
 
 	/** Width and height of the spell icon (very unlikely to change!) */
 	private static final int SPELL_ICON_SIZE = 32;
@@ -99,12 +106,9 @@ public class GuiSpellDisplay {
 	@SubscribeEvent
 	public static void draw(RenderGameOverlayEvent.Post event){
 
-		if(event.getType() != RenderGameOverlayEvent.ElementType.TEXT
-				&& event.getType() != RenderGameOverlayEvent.ElementType.HOTBAR) return;
-		
-		Minecraft mc = Minecraft.getMinecraft();
+		if(!Wizardry.settings.showSpellHUD && !Wizardry.settings.showChargeMeter) return; // Optimisation
 
-		EntityPlayer player = mc.player;
+		EntityPlayer player = Minecraft.getMinecraft().player;
 
 		if(player.isSpectator()) return; // Spectators shouldn't have the spell HUD!
 
@@ -117,12 +121,89 @@ public class GuiSpellDisplay {
 			wand = player.getHeldItemOffhand();
 			mainHand = false;
 			// If the player isn't holding a spellcasting item that shows the HUD, then nothing else needs to be done.
-			if(!(wand.getItem() instanceof ISpellCastingItem && ((ISpellCastingItem)wand.getItem()).showSpellHUD(player, wand))) return;
+			if(!(wand.getItem() instanceof ISpellCastingItem && ((ISpellCastingItem)wand.getItem()).showSpellHUD(player, wand)))
+				return;
 		}
 
 		int width = event.getResolution().getScaledWidth();
 		int height = event.getResolution().getScaledHeight();
 
+		switch(event.getType()){
+			case CROSSHAIRS:
+				renderChargeMeter(player, wand, width, height, event.getPartialTicks());
+				break;
+			case HOTBAR:
+				renderSpellHUD(player, wand, mainHand, width, height, event.getPartialTicks(), false);
+				break;
+			case TEXT:
+				renderSpellHUD(player, wand, mainHand, width, height, event.getPartialTicks(), true);
+				break;
+		}
+
+	}
+
+	/**
+	 * Renders the spell charge meter around the crosshairs.
+	 * @param player A reference to the client player
+	 * @param wand The wand the HUD is for
+	 * @param width The width of the screen
+	 * @param height The height of the screen
+	 * @param partialTicks The current partial tick time
+	 */
+	private static void renderChargeMeter(EntityPlayer player, ItemStack wand, int width, int height, float partialTicks){
+
+		if(!Wizardry.settings.showChargeMeter) return;
+		if(Minecraft.getMinecraft().gameSettings.showDebugInfo) return; // Don't show charge meter in the debug screen
+		if(Minecraft.getMinecraft().gameSettings.thirdPersonView != 0) return; // Don't show in third person
+		if(wand != player.getActiveItemStack()) return; // Don't show when using the other held item
+
+		if(!(wand.getItem() instanceof ISpellCastingItem)) throw new IllegalArgumentException("The given stack must contain an ISpellCastingItem!");
+
+		Spell spell = ((ISpellCastingItem)wand.getItem()).getCurrentSpell(wand);
+
+		int chargeup = spell.getChargeup();
+
+		if(WizardData.get(player) != null){
+			// Pretty sure this is accessible client-side since it's only assigned from common code
+			chargeup = (int)(chargeup * WizardData.get(player).itemCastingModifiers.get(SpellModifiers.CHARGEUP));
+		}
+
+		if(chargeup <= 0) return;
+
+		// WHY WHY WHY are these methods named so misleadingly?! Sort yourselves out MCP!
+		// (getItemInUseCount returns the max count MINUS the use count, and getItemInUseMaxCount returns the use count)
+		if(player.getItemInUseMaxCount() == 0) return; // Not charging
+		float charge = (player.getItemInUseMaxCount() + partialTicks) / chargeup;
+		if(charge > 1) return; // Done charging
+
+		Minecraft.getMinecraft().renderEngine.bindTexture(CHARGE_METER);
+
+		int x1 = width/2 - CHARGE_METER_WIDTH/2;
+		int y = height/2 - CHARGE_METER_HEIGHT/2;
+		int w = (int)(CHARGE_METER_WIDTH/2 * charge);
+		int u = CHARGE_METER_WIDTH - w;
+
+		DrawingUtils.drawTexturedRect(x1, y, 0, 0, w, CHARGE_METER_HEIGHT, 32, 32);
+		DrawingUtils.drawTexturedRect(x1 + u, y, u, 0, w, CHARGE_METER_HEIGHT, 32, 32);
+
+	}
+
+	/**
+	 * Renders the main spell HUD in the corner of the screen.
+	 * @param player A reference to the client player
+	 * @param wand The wand the HUD is for
+	 * @param mainHand True if the wand is in the player's main hand, false if it is in their offhand
+	 * @param width The width of the screen
+	 * @param height The height of the screen
+	 * @param partialTicks The current partial tick time
+	 * @param textLayer True to render the text layer, false to render the background (hotbar layer)
+	 */
+	private static void renderSpellHUD(EntityPlayer player, ItemStack wand, boolean mainHand, int width, int height, float partialTicks, boolean textLayer){
+
+		if(!Wizardry.settings.showSpellHUD) return;
+
+		if(!(wand.getItem() instanceof ISpellCastingItem)) throw new IllegalArgumentException("The given stack must contain an ISpellCastingItem!");
+
 		boolean flipX = Wizardry.settings.spellHUDPosition.flipX;
 		boolean flipY = Wizardry.settings.spellHUDPosition.flipY;
 
@@ -130,16 +211,16 @@ public class GuiSpellDisplay {
 			// ............. | This bit is true if the wand is on the left, false if it is on the right
 			flipX = flipX == ((mainHand ? player.getPrimaryHand() : player.getPrimaryHand().opposite()) == EnumHandSide.LEFT);
 		}
-		
+
 		Skin skin = skins.get(Wizardry.settings.spellHUDSkin);
-		
+
 		if(skin == null){
-			
+
 			Wizardry.logger.info("The spell HUD skin '" + Wizardry.settings.spellHUDSkin + "' specified in the config"
 					+ " did not match any of the loaded skins; using the default skin as a fallback.");
-			
+
 			skin = skins.get(Settings.DEFAULT_HUD_SKIN_KEY);
-			
+
 			if(skin == null){
 				Wizardry.logger.warn("The default spell HUD skin is missing! A resource pack must have overridden it"
 						+ " with an invalid JSON file (default.json), please try again without any resource packs.");
@@ -148,7 +229,7 @@ public class GuiSpellDisplay {
 		}
 
 		GlStateManager.pushMatrix();
-		
+
 		// 'Origin' of the spell hud (bottom left corner of the actual texture, always in the corner of the screen)
 		int x = flipX ? width : 0;
 		int y = flipY ? 0: height;
@@ -169,45 +250,45 @@ public class GuiSpellDisplay {
 			y = MathHelper.ceil(y/scale);
 		}
 
-		Spell spell = WandHelper.getCurrentSpell(wand);
-		int cooldown = WandHelper.getCurrentCooldown(wand);
-		int maxCooldown = WandHelper.getCurrentMaxCooldown(wand);
+		Spell spell = ((ISpellCastingItem)wand.getItem()).getCurrentSpell(wand);
+		int cooldown = ((ISpellCastingItem)wand.getItem()).getCurrentCooldown(wand);
+		int maxCooldown = ((ISpellCastingItem)wand.getItem()).getCurrentMaxCooldown(wand);
+
+		if(textLayer){
 
-		if(event.getType() == RenderGameOverlayEvent.ElementType.TEXT){
-			
 			float animationProgress = Math.signum(switchTimer) * ((SPELL_SWITCH_TIME - Math.abs(switchTimer) +
-					event.getPartialTicks()) / SPELL_SWITCH_TIME);
-			
-			String prevSpellName = getFormattedSpellName(WandHelper.getPreviousSpell(wand), player, WandHelper.getPreviousCooldown(wand));
+					partialTicks) / SPELL_SWITCH_TIME);
+
+			String prevSpellName = getFormattedSpellName(((ISpellCastingItem)wand.getItem()).getPreviousSpell(wand), player, 0);
 			String spellName = getFormattedSpellName(spell, player, cooldown);
-			String nextSpellName = getFormattedSpellName(WandHelper.getNextSpell(wand), player, WandHelper.getNextCooldown(wand));
+			String nextSpellName = getFormattedSpellName(((ISpellCastingItem)wand.getItem()).getNextSpell(wand), player, 0);
 
 			skin.drawText(x, y, flipX, flipY, prevSpellName, spellName, nextSpellName, animationProgress);
 
-		}else if(event.getType() == RenderGameOverlayEvent.ElementType.HOTBAR){
+		}else{
 
 			boolean discovered = true;
 
 			if(!player.isCreative() && WizardData.get(player) != null){
 				discovered = WizardData.get(player).hasSpellBeenDiscovered(spell);
 			}
-			
+
 			ResourceLocation icon = discovered ? spell.getIcon() : Spells.none.getIcon();
 
 			float progress = 1;
 			// Doesn't really matter what progress is when in creative, but we might as well avoid the calculation.
-			if(!player.isCreative() && !spell.isContinuous){
+			if(!player.isCreative()){
 				// Subtracted partial tick time to make it smoother
-				progress = maxCooldown == 0 ? 1 : (maxCooldown - (float)cooldown + event.getPartialTicks()) / maxCooldown;
+				progress = maxCooldown == 0 ? 1 : (maxCooldown - (float)cooldown + partialTicks) / maxCooldown;
 			}
-			
-			skin.drawBackground(x, y, flipX, flipY, icon, progress, player.isCreative());
-			
+
+			skin.drawBackground(x, y, flipX, flipY, icon, progress, player.isCreative(), player.isPotionActive(WizardryPotions.arcane_jammer));
+
 		}
 
 		GlStateManager.popMatrix();
 	}
-	
+
 	/**
 	 * Gets the name of the given spell, with formatting added according to its cooldown and whether the given player
 	 * has discovered it.
@@ -224,9 +305,11 @@ public class GuiSpellDisplay {
 			discovered = WizardData.get(player).hasSpellBeenDiscovered(spell);
 		}
 		
-		// Makes spells greyed out if they are in cooldown or if the player has the arcane jammer effect
-		String format = cooldown > 0 || player.isPotionActive(WizardryPotions.arcane_jammer) ? "\u00A78" : spell.getElement().getFormattingCode();
+		// Makes spells greyed out if they are in cooldown
+		String format = cooldown > 0 ? "\u00A78" : spell.getElement().getFormattingCode();
 		if(!discovered) format = "\u00A79";
+		// Obfuscates the spell name if the player has the arcane jammer effect
+		if(player.isPotionActive(WizardryPotions.arcane_jammer)) format = format + "\u00A7k";
 		
 		String name = discovered ? spell.getDisplayName() : SpellGlyphData.getGlyphName(spell, player.world);
 		name = format + name;
@@ -458,8 +541,9 @@ public class GuiSpellDisplay {
 		 * @param icon A {@code ResourceLocation} corresponding to the icon of the selected spell.
 		 * @param cooldownBarProgress The fraction of the cooldown bar to draw; must be between 0 and 1 (inclusive).
 		 * @param creativeMode True to draw the creative mode HUD, false for the survival mode version.
+		 * @param jammed True to show the 'glitch' effect (user for arcane jammer), false to draw normally.
 		 */
-		public void drawBackground(int x, int y, boolean flipX, boolean flipY, ResourceLocation icon, float cooldownBarProgress, boolean creativeMode){
+		public void drawBackground(int x, int y, boolean flipX, boolean flipY, ResourceLocation icon, float cooldownBarProgress, boolean creativeMode, boolean jammed){
 			
 			// Moves the origin if the HUD does not mirror; neatens the rest of the code.
 			if(flipX && !mirrorX) x -= width;
@@ -476,8 +560,13 @@ public class GuiSpellDisplay {
 			int x1 = flipX && mirrorX ? x - spellIconInsetX - SPELL_ICON_SIZE : x + spellIconInsetX;
 			// y is upside-down so this is the other way round
 			int y1 = flipY && mirrorY ? y + spellIconInsetY : y - spellIconInsetY - SPELL_ICON_SIZE;
-			
-			DrawingUtils.drawTexturedRect(x1, y1, 0, 0, SPELL_ICON_SIZE, SPELL_ICON_SIZE, SPELL_ICON_SIZE, SPELL_ICON_SIZE);
+
+			if(jammed){
+				random.setSeed(Minecraft.getMinecraft().world.getTotalWorldTime() / 2);
+				DrawingUtils.drawGlitchRect(random, x1, y1, 0, 0, SPELL_ICON_SIZE, SPELL_ICON_SIZE, SPELL_ICON_SIZE, SPELL_ICON_SIZE, false, false);
+			}else{
+				DrawingUtils.drawTexturedRect(x1, y1, 0, 0, SPELL_ICON_SIZE, SPELL_ICON_SIZE, SPELL_ICON_SIZE, SPELL_ICON_SIZE);
+			}
 
 			// Background of spell hud
 			mc.renderEngine.bindTexture(texture);
@@ -486,7 +575,11 @@ public class GuiSpellDisplay {
 			y1 = flipY && mirrorY ? y : y - height;
 			// The 128 here is a uv value, not a dimension, and hence is left as a hardcoded number.
 			// TODO: Since the HUD is wider than it is tall, perhaps the creative mode texture should be in the bottom half instead of the right half?
-			DrawingUtils.drawTexturedFlippedRect(x1, y1, creativeMode ? 128 : 0, 0, width, height, 256, 256, flipX && mirrorX, flipY && mirrorY);
+			if(jammed){
+				DrawingUtils.drawGlitchRect(random, x1, y1, creativeMode ? 128 : 0, 0, width, height, 256, 256, flipX && mirrorX, flipY && mirrorY);
+			}else{
+				DrawingUtils.drawTexturedFlippedRect(x1, y1, creativeMode ? 128 : 0, 0, width, height, 256, 256, flipX && mirrorX, flipY && mirrorY);
+			}
 
 			// Cooldown bar
 			if(!creativeMode && cooldownBarProgress > 0 && (showCooldownWhenFull || cooldownBarProgress < 1)){
@@ -498,8 +591,12 @@ public class GuiSpellDisplay {
 				
 				int u = cooldownBarX; // This doesn't change, even when cooldownBarMirrorX is true, because it should
 				int v = height;		  // always start with the left-hand in the actual texture file
-				
-				DrawingUtils.drawTexturedFlippedRect(x1, y1, u, v, l, cooldownBarHeight, 256, 256, flipX && cooldownBarMirrorX, flipY && cooldownBarMirrorY);
+
+				if(jammed){
+					DrawingUtils.drawGlitchRect(random, x1, y1, u, v, l, cooldownBarHeight, 256, 256, flipX && cooldownBarMirrorX, flipY && cooldownBarMirrorY);
+				}else{
+					DrawingUtils.drawTexturedFlippedRect(x1, y1, u, v, l, cooldownBarHeight, 256, 256, flipX && cooldownBarMirrorX, flipY && cooldownBarMirrorY);
+				}
 			}
 
 			GlStateManager.popMatrix();

src/main/java/electroblob/wizardry/client/gui/GuiSpellInfo.java

@@ -0,0 +1,138 @@
+package electroblob.wizardry.client.gui;
+
+import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.client.DrawingUtils;
+import electroblob.wizardry.constants.Tier;
+import electroblob.wizardry.data.SpellGlyphData;
+import electroblob.wizardry.registry.Spells;
+import electroblob.wizardry.registry.WizardrySounds;
+import electroblob.wizardry.spell.Spell;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.audio.PositionedSoundRecord;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.resources.I18n;
+import net.minecraft.util.ResourceLocation;
+import org.lwjgl.input.Keyboard;
+
+/** Abstract base class for both {@link GuiSpellBook} and {@link GuiLectern}. Centralises code common to both
+ * those classes. */
+public abstract class GuiSpellInfo extends GuiScreen {
+
+	protected static final String TRANSLATION_KEY_PREFIX = "gui." + Wizardry.MODID + ":spell_book";
+
+	protected final int xSize, ySize;
+	protected int textureWidth = 512;
+	protected int textureHeight = 256;
+
+	public GuiSpellInfo(int xSize, int ySize){
+		super();
+		this.xSize = xSize;
+		this.ySize = ySize;
+	}
+
+	protected void setTextureSize(int width, int height){
+		this.textureWidth = width;
+		this.textureHeight = height;
+	}
+
+	/** Returns the spell to be displayed by this GUI. */
+	public abstract Spell getSpell();
+
+	/** Returns the main texture for the background of this GUI. */
+	public abstract ResourceLocation getTexture();
+
+	@Override
+	public void drawScreen(int mouseX, int mouseY, float partialTicks){
+		int left = this.width/2 - xSize/2;
+		int top = this.height/2 - this.ySize/2;
+		this.drawDefaultBackground();
+		this.drawBackgroundLayer(left, top, mouseX, mouseY);
+		super.drawScreen(mouseX, mouseY, partialTicks); // Just draws the buttons
+		this.drawForegroundLayer(left, top, mouseX, mouseY);
+	}
+
+	/**
+	 * Draws the background of the spell info GUI. This is called before buttons are drawn.
+	 * @param left The x-coordinate of the left-hand edge of the GUI
+	 * @param top The y-coordinate of the top edge of the GUI
+	 * @param mouseX The current x position of the mouse pointer
+	 * @param mouseY The current y position of the mouse pointer
+	 */
+	protected void drawBackgroundLayer(int left, int top, int mouseX, int mouseY){
+
+		boolean discovered = Wizardry.proxy.shouldDisplayDiscovered(getSpell(), null);
+
+		GlStateManager.color(1, 1, 1, 1); // Just in case
+
+		// Draws spell illustration on opposite page, underneath the book so it shows through the hole.
+		Minecraft.getMinecraft().renderEngine.bindTexture(discovered ? getSpell().getIcon() : Spells.none.getIcon());
+		DrawingUtils.drawTexturedRect(left + 146, top + 20, 0, 0, 128, 128, 128, 128);
+
+		Minecraft.getMinecraft().renderEngine.bindTexture(getTexture());
+		DrawingUtils.drawTexturedRect(left, top, 0, 0, xSize, ySize, textureWidth, textureHeight);
+	}
+
+	/**
+	 * Draws the foreground of the spell info GUI. This is called after buttons are drawn.
+	 * @param left The x-coordinate of the left-hand edge of the GUI
+	 * @param top The y-coordinate of the top edge of the GUI
+	 * @param mouseX The current x position of the mouse pointer
+	 * @param mouseY The current y position of the mouse pointer
+	 */
+	protected void drawForegroundLayer(int left, int top, int mouseX, int mouseY){
+
+		boolean discovered = Wizardry.proxy.shouldDisplayDiscovered(getSpell(), null);
+
+		if(discovered){
+			this.fontRenderer.drawString(getSpell().getDisplayName(), left + 17, top + 15, 0);
+			this.fontRenderer.drawString(getSpell().getType().getDisplayName(), left + 17, top + 26, 0x777777);
+		}else{
+			this.mc.standardGalacticFontRenderer.drawString(SpellGlyphData.getGlyphName(getSpell(), mc.world), left + 17,
+					top + 15, 0);
+			this.mc.standardGalacticFontRenderer.drawString(getSpell().getType().getDisplayName(), left + 17, top + 26,
+					0x777777);
+		}
+
+		// Novice is usually white but this doesn't show up
+		String tier = I18n.format(TRANSLATION_KEY_PREFIX + ".tier", getSpell().getTier() == Tier.NOVICE ?
+				"\u00A77" + getSpell().getTier().getDisplayName() : getSpell().getTier().getDisplayNameWithFormatting());
+		this.fontRenderer.drawString(tier, left + 17, top + 45, 0);
+
+		String element = I18n.format(TRANSLATION_KEY_PREFIX + ".element", getSpell().getElement().getFormattingCode() + getSpell().getElement().getDisplayName());
+		if(!discovered) element = I18n.format(TRANSLATION_KEY_PREFIX + ".element_undiscovered");
+		this.fontRenderer.drawString(element, left + 17, top + 57, 0);
+
+		String manaCost = I18n.format(TRANSLATION_KEY_PREFIX + ".mana_cost", getSpell().getCost());
+		if(getSpell().isContinuous) manaCost = I18n.format(TRANSLATION_KEY_PREFIX + ".mana_cost_continuous", getSpell().getCost());
+		if(!discovered) manaCost = I18n.format(TRANSLATION_KEY_PREFIX + ".mana_cost_undiscovered");
+		this.fontRenderer.drawString(manaCost, left + 17, top + 69, 0);
+
+		if(discovered){
+			this.fontRenderer.drawSplitString(getSpell().getDescription(), left + 17, top + 83, 118, 0);
+		}else{
+			this.mc.standardGalacticFontRenderer.drawSplitString(
+					SpellGlyphData.getGlyphDescription(getSpell(), mc.world), left + 17, top + 83, 118, 0);
+		}
+	}
+
+	@Override
+	public void initGui(){
+		super.initGui();
+		Keyboard.enableRepeatEvents(true);
+		this.buttonList.clear();
+		this.mc.getSoundHandler().playSound(PositionedSoundRecord.getMasterRecord(WizardrySounds.MISC_BOOK_OPEN, 1));
+	}
+
+	@Override
+	public void onGuiClosed(){
+		super.onGuiClosed();
+		Keyboard.enableRepeatEvents(false);
+	}
+
+	@Override
+	public boolean doesGuiPauseGame(){
+		return Wizardry.settings.booksPauseGame;
+	}
+
+}

src/main/java/electroblob/wizardry/client/gui/WizardTradeTweaksHandler.java

@@ -0,0 +1,129 @@
+package electroblob.wizardry.client.gui;
+
+import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.client.DrawingUtils;
+import electroblob.wizardry.data.WizardData;
+import electroblob.wizardry.item.ItemSpellBook;
+import electroblob.wizardry.registry.WizardryItems;
+import electroblob.wizardry.spell.Spell;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiMerchant;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.RenderHelper;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.ContainerMerchant;
+import net.minecraft.inventory.Slot;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.village.MerchantRecipe;
+import net.minecraft.village.MerchantRecipeList;
+import net.minecraftforge.client.event.GuiContainerEvent;
+import net.minecraftforge.client.event.GuiOpenEvent;
+import net.minecraftforge.client.event.GuiScreenEvent.ActionPerformedEvent;
+import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
+import net.minecraftforge.fml.common.eventhandler.EventPriority;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.relauncher.Side;
+
+@EventBusSubscriber(Side.CLIENT)
+public class WizardTradeTweaksHandler {
+
+	private static final ResourceLocation NEW_SPELL_ICON = new ResourceLocation(Wizardry.MODID, "textures/gui/container/new_spell_indicator.png");
+
+	private static final int ICON_WIDTH = 8;
+	private static final int ICON_HEIGHT = 8;
+
+	private static final int ANIMATION_FRAMES = 4;
+	private static final int ANIMATION_FRAME_TIME = 2; // In ticks
+	private static final int ANIMATION_PERIOD = 40; // In frame durations
+
+	private static int tradeIndex; // Mirrors GuiMerchant#selectedMerchantRecipe (don't want to reflect into it every frame)
+
+	@SubscribeEvent(priority = EventPriority.LOWEST)
+	public static void onGuiOpenEvent(GuiOpenEvent event){
+		if(event.getGui() instanceof GuiMerchant) tradeIndex = 0;
+	}
+
+	@SubscribeEvent
+	public static void onActionPerformedPostEvent(ActionPerformedEvent.Post event){
+
+		if(event.getGui() instanceof GuiMerchant){
+
+			MerchantRecipeList recipes = ((GuiMerchant)event.getGui()).getMerchant().getRecipes(Minecraft.getMinecraft().player);
+
+			if(recipes == null) return;
+
+			if(event.getButton().id == 1){ // Next
+				tradeIndex = Math.min(tradeIndex + 1, recipes.size());
+			}else if(event.getButton().id == 2){ // Previous
+				tradeIndex = Math.max(tradeIndex - 1, 0);
+			}
+		}
+	}
+
+	// Brute-force fix for crystals not showing up when a wizard is given a spell book in the trade GUI.
+	@SubscribeEvent
+	public static void onGuiDrawForegroundEvent(GuiContainerEvent.DrawForeground event){
+
+		if(event.getGuiContainer() instanceof GuiMerchant){
+
+			GuiMerchant gui = (GuiMerchant)event.getGuiContainer();
+			// Note that gui.getMerchant() returns an NpcMerchant, not an EntityWizard.
+			MerchantRecipeList trades = gui.getMerchant().getRecipes(Minecraft.getMinecraft().player);
+
+			if(trades == null) return;
+
+			// Using == the specific item rather than instanceof because that's how trades do it.
+			if(gui.inventorySlots.getSlot(0).getStack().getItem() == WizardryItems.spell_book
+					|| gui.inventorySlots.getSlot(1).getStack().getItem() == WizardryItems.spell_book){
+
+				for(MerchantRecipe trade : trades){
+					if(trade.getItemToBuy().getItem() == WizardryItems.spell_book && trade.getSecondItemToBuy().isEmpty()){
+						Slot slot = gui.inventorySlots.getSlot(2);
+						// It still doesn't look quite right because the slot highlight is behind the item, but it'll do
+						// until/unless I find a better solution.
+						DrawingUtils.drawItemAndTooltip(gui, trade.getItemToSell(), slot.xPos, slot.yPos, event.getMouseX(), event.getMouseY(),
+								gui.getSlotUnderMouse() == slot);
+					}
+				}
+			}
+
+			// New spell indicator
+			if(gui.inventorySlots instanceof ContainerMerchant){
+
+				// Can't use getCurrentRecipe because that only gets updated when the correct items are given
+				MerchantRecipe recipe = trades.get(tradeIndex);
+
+				if(recipe != null && recipe.getItemToSell().getItem() instanceof ItemSpellBook){
+
+					EntityPlayer player = Minecraft.getMinecraft().player;
+					Spell spell = Spell.byMetadata(recipe.getItemToSell().getMetadata());
+
+					if(Wizardry.settings.discoveryMode && !player.isCreative() && Wizardry.proxy.shouldDisplayDiscovered(spell, recipe.getItemToSell())
+							&& WizardData.get(player) != null && !WizardData.get(player).hasSpellBeenDiscovered(spell)){
+						
+						int x = gui.inventorySlots.getSlot(2).xPos + 14;
+						int y = gui.inventorySlots.getSlot(2).yPos - 17;
+
+						RenderHelper.enableGUIStandardItemLighting();
+						GlStateManager.color(1, 1, 1);
+						Minecraft.getMinecraft().renderEngine.bindTexture(NEW_SPELL_ICON);
+
+						int frame = Math.max(player.ticksExisted/ANIMATION_FRAME_TIME % ANIMATION_PERIOD - (ANIMATION_PERIOD - ANIMATION_FRAMES), 0);
+						DrawingUtils.drawTexturedRect(x, y, 0, frame * ICON_HEIGHT, ICON_WIDTH, ICON_HEIGHT, ICON_WIDTH, ICON_HEIGHT * ANIMATION_FRAMES);
+
+						RenderHelper.disableStandardItemLighting();
+
+//						int mouseX = event.getMouseX() - gui.getGuiLeft();
+//						int mouseY = event.getMouseY() - gui.getGuiTop();
+//
+//						if(mouseX >= x + 1 && mouseX < x + w + 1 && mouseY >= y - 1 && mouseY < y + h + 1){
+//							GuiUtils.drawHoveringText(Collections.singletonList("You haven't discovered this spell yet"), mouseX,
+//									mouseY, gui.width, gui.height, 150, Minecraft.getMinecraft().fontRenderer);
+//						}
+					}
+				}
+			}
+		}
+	}
+
+}

src/main/java/electroblob/wizardry/client/gui/config/GuiConfigWizardry.java

@@ -25,15 +25,18 @@ public class GuiConfigWizardry extends GuiConfig {
 
 	private static List<IConfigElement> getConfigEntries(){
 		
-		List<IConfigElement> configList = new ArrayList<IConfigElement>(1);
+		List<IConfigElement> configList = new ArrayList<>(1);
 
-		configList.add(new DummyCategoryElement("gameplayConfig", "config." + Wizardry.MODID + ".category." + Settings.GAMEPLAY_CATEGORY, GameplayCategory.class));
-		configList.add(new DummyCategoryElement("worldgenConfig", "config." + Wizardry.MODID + ".category." + Settings.WORLDGEN_CATEGORY, WorldgenCategory.class));
-		configList.add(new DummyCategoryElement("commandsConfig", "config." + Wizardry.MODID + ".category." + Settings.COMMANDS_CATEGORY, CommandsCategory.class));
-		configList.add(new DummyCategoryElement("clientConfig", "config." + Wizardry.MODID + ".category." + Settings.CLIENT_CATEGORY, ClientCategory.class));
-		configList.add(new DummyCategoryElement("spellsConfig", "config." + Wizardry.MODID + ".category." + Settings.SPELLS_CATEGORY, SpellsCategory.class));
-		configList.add(new DummyCategoryElement("resistancesConfig", "config." + Wizardry.MODID + ".category." + Settings.RESISTANCES_CATEGORY, ResistancesCategory.class));
-		configList.add(new DummyCategoryElement("compatibilityConfig", "config." + Wizardry.MODID + ".category." + Settings.COMPATIBILITY_CATEGORY, CompatibilityCategory.class));
+		configList.add(new DummyCategoryElement("gameplayConfig",			"config." + Wizardry.MODID + ".category." + Settings.GAMEPLAY_CATEGORY, 		GameplayCategory.class));
+		configList.add(new DummyCategoryElement("difficultyConfig",		"config." + Wizardry.MODID + ".category." + Settings.DIFFICULTY_CATEGORY, 	DifficultyCategory.class));
+		configList.add(new DummyCategoryElement("worldgenConfig",			"config." + Wizardry.MODID + ".category." + Settings.WORLDGEN_CATEGORY, 		WorldgenCategory.class));
+		configList.add(new DummyCategoryElement("tweaksConfig",			"config." + Wizardry.MODID + ".category." + Settings.TWEAKS_CATEGORY, 		TweaksCategory.class));
+		configList.add(new DummyCategoryElement("commandsConfig",			"config." + Wizardry.MODID + ".category." + Settings.COMMANDS_CATEGORY, 		CommandsCategory.class));
+		configList.add(new DummyCategoryElement("clientConfig",			"config." + Wizardry.MODID + ".category." + Settings.CLIENT_CATEGORY, 		ClientCategory.class));
+		configList.add(new DummyCategoryElement("spellsConfig",			"config." + Wizardry.MODID + ".category." + Settings.SPELLS_CATEGORY, 		SpellsCategory.class));
+		configList.add(new DummyCategoryElement("artefactsConfig",		"config." + Wizardry.MODID + ".category." + Settings.ARTEFACTS_CATEGORY, 	ArtefactsCategory.class));
+		configList.add(new DummyCategoryElement("resistancesConfig",		"config." + Wizardry.MODID + ".category." + Settings.RESISTANCES_CATEGORY, 	ResistancesCategory.class));
+		configList.add(new DummyCategoryElement("compatibilityConfig",	"config." + Wizardry.MODID + ".category." + Settings.COMPATIBILITY_CATEGORY, CompatibilityCategory.class));
 
 		configList.addAll(new ConfigElement(Wizardry.settings.getConfigCategory(Configuration.CATEGORY_GENERAL)).getChildElements());
 		
@@ -79,6 +82,16 @@ public class GuiConfigWizardry extends GuiConfig {
 		@Override protected String getCategory() { return Settings.GAMEPLAY_CATEGORY; }
 	}
 
+	/** Difficulty category of the config gui. */
+	public static class DifficultyCategory extends CategoryBase {
+
+		public DifficultyCategory(GuiConfig owningScreen, GuiConfigEntries owningEntryList, IConfigElement prop){
+			super(owningScreen, owningEntryList, prop);
+		}
+
+		@Override protected String getCategory() { return Settings.DIFFICULTY_CATEGORY; }
+	}
+
 	/** Worldgen category of the config gui. */
 	public static class WorldgenCategory extends CategoryBase {
 
@@ -89,6 +102,16 @@ public class GuiConfigWizardry extends GuiConfig {
 		@Override protected String getCategory() { return Settings.WORLDGEN_CATEGORY; }
 	}
 
+	/** Tweaks category of the config gui. */
+	public static class TweaksCategory extends CategoryBase {
+
+		public TweaksCategory(GuiConfig owningScreen, GuiConfigEntries owningEntryList, IConfigElement prop){
+			super(owningScreen, owningEntryList, prop);
+		}
+
+		@Override protected String getCategory() { return Settings.TWEAKS_CATEGORY; }
+	}
+
 	/** Commands category of the config gui. */
 	public static class CommandsCategory extends CategoryBase {
 
@@ -119,6 +142,16 @@ public class GuiConfigWizardry extends GuiConfig {
 		@Override protected String getCategory() { return Settings.SPELLS_CATEGORY; }
 	}
 
+	/** Artefacts category of the config gui. */
+	public static class ArtefactsCategory extends CategoryBase {
+
+		public ArtefactsCategory(GuiConfig owningScreen, GuiConfigEntries owningEntryList, IConfigElement prop){
+			super(owningScreen, owningEntryList, prop);
+		}
+
+		@Override protected String getCategory() { return Settings.ARTEFACTS_CATEGORY; }
+	}
+
 	/** Resistances category of the config gui. */
 	public static class ResistancesCategory extends CategoryBase {
 		

src/main/java/electroblob/wizardry/client/gui/config/GuiSelectHUDSkin.java

@@ -65,15 +65,15 @@ public class GuiSelectHUDSkin extends GuiSelectString {
 			float scale = Math.min((previewRight - previewLeft - 2*previewBorder)/(float)skin.getWidth(),
 									(previewBottom - previewTop - 2*previewBorder)/(float)skin.getHeight());
 			
-			float x = (previewLeft + previewRight)/2 - (skin.getWidth()*scale)/2;
-			float y = (previewBottom + previewTop)/2 + (skin.getHeight()*scale)/2;
+			float x = (previewLeft + previewRight)/2f - (skin.getWidth()*scale)/2;
+			float y = (previewBottom + previewTop)/2f + (skin.getHeight()*scale)/2;
 			
 			GlStateManager.pushMatrix();
 			
 			GlStateManager.scale(scale, scale, scale);
 			
 			skin.drawBackground((int)(x/scale), (int)(y/scale), false, false, 
-					Spells.magic_missile.getIcon(), 0.6f, false);
+					Spells.magic_missile.getIcon(), 0.6f, false, false);
 			
 			skin.drawText((int)(x/scale), (int)(y/scale), false, false, 
 					Spells.none.getDisplayNameWithFormatting(),

src/main/java/electroblob/wizardry/client/gui/handbook/Contents.java

@@ -3,7 +3,7 @@ package electroblob.wizardry.client.gui.handbook;
 import com.google.gson.JsonObject;
 import com.google.gson.JsonSyntaxException;
 import electroblob.wizardry.client.DrawingUtils;
-import electroblob.wizardry.util.WizardryUtilities;
+import electroblob.wizardry.util.JavaUtils;
 import net.minecraft.client.gui.FontRenderer;
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.util.JsonUtils;
@@ -50,7 +50,7 @@ class Contents {
 
 	/** Returns an unmodifiable, flattened collection of all the buttons in this contents. */
 	Collection<GuiButton> getButtons(){
-		return WizardryUtilities.flatten(buttons);
+		return JavaUtils.flatten(buttons);
 	}
 
 	void addEntry(Section section){

src/main/java/electroblob/wizardry/client/gui/handbook/GuiWizardHandbook.java

@@ -8,7 +8,8 @@ import electroblob.wizardry.Wizardry;
 import electroblob.wizardry.client.ClientProxy;
 import electroblob.wizardry.client.DrawingUtils;
 import electroblob.wizardry.client.gui.GuiButtonInvisible;
-import electroblob.wizardry.client.gui.handbook.GuiButtonTurnPage.Type;
+import electroblob.wizardry.client.gui.GuiButtonTurnPage;
+import electroblob.wizardry.client.gui.GuiButtonTurnPage.Type;
 import electroblob.wizardry.constants.Constants;
 import electroblob.wizardry.constants.Element;
 import electroblob.wizardry.constants.Tier;
@@ -54,7 +55,7 @@ public class GuiWizardHandbook extends GuiScreen {
 
 	private static final ResourceLocation DEFAULT = new ResourceLocation(Wizardry.MODID, "texts/handbook_en_us.json");
 
-	static final ResourceLocation texture = new ResourceLocation(Wizardry.MODID, "textures/gui/handbook.png");
+	static final ResourceLocation texture = new ResourceLocation(Wizardry.MODID, "textures/gui/handbook/handbook.png");
 
 	/** Global Gson instance for the handbook. */
 	private static final Gson gson = new Gson();
@@ -244,6 +245,8 @@ public class GuiWizardHandbook extends GuiScreen {
 	@Override
 	public void drawScreen(int mouseX, int mouseY, float partialTicks){
 
+		this.drawDefaultBackground();
+
 		int left = this.width / 2 - GUI_WIDTH / 2;
 		int top = this.height / 2 - GUI_HEIGHT / 2;
 
@@ -349,19 +352,19 @@ public class GuiWizardHandbook extends GuiScreen {
 		this.buttonList.clear();
 
 		this.buttonList.add(next = new GuiButtonTurnPage(nextButtonId++, left + GUI_WIDTH - BUTTON_INSET_X - GuiButtonTurnPage.WIDTH,
-				top + GUI_HEIGHT - BUTTON_INSET_Y - GuiButtonTurnPage.HEIGHT, Type.NEXT_PAGE));
+				top + GUI_HEIGHT - BUTTON_INSET_Y - GuiButtonTurnPage.HEIGHT, Type.NEXT_PAGE, texture, TEXTURE_WIDTH, TEXTURE_HEIGHT));
 
 		this.buttonList.add(previous = new GuiButtonTurnPage(nextButtonId++, left + BUTTON_INSET_X,
-				top + GUI_HEIGHT - BUTTON_INSET_Y - GuiButtonTurnPage.HEIGHT, Type.PREVIOUS_PAGE));
+				top + GUI_HEIGHT - BUTTON_INSET_Y - GuiButtonTurnPage.HEIGHT, Type.PREVIOUS_PAGE, texture, TEXTURE_WIDTH, TEXTURE_HEIGHT));
 
 		this.buttonList.add(nextSection = new GuiButtonTurnPage(nextButtonId++, left + GUI_WIDTH - BUTTON_INSET_X - GuiButtonTurnPage.WIDTH - BUTTON_SPACING,
-				top + GUI_HEIGHT - BUTTON_INSET_Y - GuiButtonTurnPage.HEIGHT, Type.NEXT_SECTION));
+				top + GUI_HEIGHT - BUTTON_INSET_Y - GuiButtonTurnPage.HEIGHT, Type.NEXT_SECTION, texture, TEXTURE_WIDTH, TEXTURE_HEIGHT));
 
 		this.buttonList.add(previousSection = new GuiButtonTurnPage(nextButtonId++, left + BUTTON_INSET_X + BUTTON_SPACING,
-				top + GUI_HEIGHT - BUTTON_INSET_Y - GuiButtonTurnPage.HEIGHT, Type.PREVIOUS_SECTION));
+				top + GUI_HEIGHT - BUTTON_INSET_Y - GuiButtonTurnPage.HEIGHT, Type.PREVIOUS_SECTION, texture, TEXTURE_WIDTH, TEXTURE_HEIGHT));
 
 		this.buttonList.add(menu = new GuiButtonTurnPage(nextButtonId++, left + GUI_WIDTH/2 - 28,
-				top + GUI_HEIGHT - BUTTON_INSET_Y - GuiButtonTurnPage.HEIGHT, Type.CONTENTS));
+				top + GUI_HEIGHT - BUTTON_INSET_Y - GuiButtonTurnPage.HEIGHT, Type.CONTENTS, texture, TEXTURE_WIDTH, TEXTURE_HEIGHT));
 
 		this.buttonList.add(bookmark = new GuiButtonInvisible(nextButtonId++, left + 130, top + 172, 11, 19) {
 			@Override
@@ -398,6 +401,11 @@ public class GuiWizardHandbook extends GuiScreen {
 	 */
 	public static void loadHandbookFile(IResourceManager manager){
 
+		if(manager == null){
+			Wizardry.logger.error("Tried to reload the handbook file, but received a null resource manager. Aborting!");
+			return;
+		}
+
 		IResource handbookFile = getHandbookResource(manager);
 
 		if(handbookFile != null){

src/main/java/electroblob/wizardry/client/gui/handbook/Section.java

@@ -6,7 +6,7 @@ import com.google.gson.JsonObject;
 import com.google.gson.JsonSyntaxException;
 import electroblob.wizardry.Wizardry;
 import electroblob.wizardry.client.DrawingUtils;
-import electroblob.wizardry.util.WizardryUtilities;
+import electroblob.wizardry.util.JavaUtils;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.FontRenderer;
 import net.minecraft.client.gui.GuiButton;
@@ -63,7 +63,7 @@ class Section {
 	}
 
 	Collection<GuiButton> getButtons(){
-		return WizardryUtilities.flatten(buttons);
+		return JavaUtils.flatten(buttons);
 	}
 
 	/**