That's one heck of a commit you've got there...

I may have got a bit behind with version control. A lot behind, in fact. Maybe I'll go back and split this sometime - then again, I probably won't. But hey, at least it's here!

src/main/java/electroblob/wizardry/client/renderer/LayerFrost.java

@@ -0,0 +1,153 @@
+package electroblob.wizardry.client.renderer;
+
+import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.block.BlockStatue;
+import electroblob.wizardry.registry.WizardryPotions;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelBiped;
+import net.minecraft.client.model.ModelPlayer;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.GlStateManager.DestFactor;
+import net.minecraft.client.renderer.GlStateManager.SourceFactor;
+import net.minecraft.client.renderer.OpenGlHelper;
+import net.minecraft.client.renderer.entity.Render;
+import net.minecraft.client.renderer.entity.RenderLivingBase;
+import net.minecraft.client.renderer.entity.RenderPlayer;
+import net.minecraft.client.renderer.entity.layers.LayerRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.MathHelper;
+import org.lwjgl.opengl.GL11;
+
+/**
+ * Layer used to render the frost texture on a creature with the frostbite effect. Handles dynamic tiling of the texture.
+ * 
+ * @author Electroblob
+ * @since Wizardry 1.2
+ */
+public class LayerFrost implements LayerRenderer<EntityLivingBase> {
+
+	protected ModelBase model;
+	private final RenderLivingBase<?> renderer;
+
+	private static final ResourceLocation texture = new ResourceLocation(Wizardry.MODID, "textures/entity/frost_overlay.png");
+
+	public static void initialiseLayers(){
+
+		for(Render<? extends Entity> renderer : Minecraft.getMinecraft().getRenderManager().entityRenderMap.values()){
+			// Because the zombie classes are now split properly, their renderers play nicely like everything else.
+			if(renderer instanceof RenderLivingBase){
+				// Adds a frost layer to all the living entity renderers in the game. Whether it is actually rendered
+				// is decided in doRenderLayer below on a per-entity basis.
+				((RenderLivingBase<?>)renderer).addLayer(new LayerFrost((RenderLivingBase<?>)renderer));
+			}
+		}
+
+		for(RenderPlayer renderer : Minecraft.getMinecraft().getRenderManager().getSkinMap().values()){
+			renderer.addLayer(new LayerFrost(renderer));
+		}
+	}
+
+	public LayerFrost(RenderLivingBase<?> renderer){
+		this.renderer = renderer;
+		this.model = renderer.getMainModel();
+	}
+
+	@Override
+	public void doRenderLayer(EntityLivingBase entity, float limbSwing, float limbSwingAmount, float partialTicks,
+			float ageInTicks, float netHeadYaw, float headPitch, float scale){
+
+		if(entity.isPotionActive(WizardryPotions.frost) || entity.getEntityData().getBoolean(BlockStatue.FROZEN_NBT_KEY)){
+
+			GlStateManager.enableLighting();
+			int i = this.getBlockBrightnessForEntity(entity, partialTicks);
+
+			int j = i % 65536;
+			int k = i / 65536;
+			OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, (float)j / 1.0F, (float)k / 1.0F);
+
+			// Frost texture
+			GlStateManager.enableBlend();
+			GlStateManager.blendFunc(SourceFactor.SRC_ALPHA, DestFactor.ONE_MINUS_SRC_ALPHA);
+			this.renderer.bindTexture(texture);
+			this.renderEntityModel(entity, limbSwing, limbSwingAmount, partialTicks, ageInTicks, netHeadYaw,
+					headPitch, scale);
+			GlStateManager.disableBlend();
+			
+		}
+	}
+
+	private int getBlockBrightnessForEntity(Entity entity, float partialTicks){
+
+		BlockPos.MutableBlockPos pos = new BlockPos.MutableBlockPos(MathHelper.floor(entity.posX), 0,
+				MathHelper.floor(entity.posZ));
+
+		if(entity.world.isBlockLoaded(pos)){
+			pos.setY(MathHelper.floor(entity.posY + (double)entity.getEyeHeight()));
+			return entity.world.getCombinedLight(pos, 0);
+		}else{
+			return 0;
+		}
+	}
+
+	private void renderEntityModel(EntityLivingBase entity, float limbSwing, float limbSwingAmount, float partialTicks,
+			float ageInTicks, float netHeadYaw, float headPitch, float scale){
+
+		GlStateManager.pushMatrix();
+		// Enables tiling (Also used for guardian beam, beacon beam and ender crystal beam)
+		GlStateManager.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT);
+		GlStateManager.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT);
+
+		GlStateManager.depthMask(true); // Some entities set depth mask to false (i.e. no sorting of faces by depth)
+		// In particular, LayerSpiderEyes sets it to false when the spider is invisible, for some reason.
+
+		// Changes the scale at which the texture is applied to the model. See LayerCreeper for a similar example,
+		// but with translation instead of scaling.
+		// NOTE: You can do all sorts of fun stuff with this, just by applying transformations in the 2D texture space.
+		GlStateManager.matrixMode(GL11.GL_TEXTURE);
+		GlStateManager.loadIdentity();
+		double scaleX = 1, scaleY = 1;
+		// It's more logical to use the model's texture size, but some classes don't bother setting it properly
+		// (e.g. ModelVillager), so to get the correct dimensions I'm getting them from the first box instead.
+		if(model.boxList != null && model.boxList.get(0) != null){
+			scaleX = (double)model.boxList.get(0).textureWidth / 16d;
+			scaleY = (double)model.boxList.get(0).textureHeight / 16d;
+		}else{ // Fallback to model fields; should never be needed
+			scaleX = (double)model.textureWidth / 16d;
+			scaleY = (double)model.textureHeight / 16d;
+		}
+		GlStateManager.scale(scaleX, scaleY, 1);
+		GlStateManager.matrixMode(GL11.GL_MODELVIEW);
+		
+		// Hides the hat layer for bipeds
+		if(this.model instanceof ModelBiped) ((ModelBiped)this.model).bipedHeadwear.isHidden = true;
+
+		if(this.model instanceof ModelPlayer){
+			((ModelPlayer)this.model).bipedBodyWear.isHidden = true;
+			((ModelPlayer)this.model).bipedLeftArmwear.isHidden = true;
+			((ModelPlayer)this.model).bipedRightArmwear.isHidden = true;
+			((ModelPlayer)this.model).bipedLeftLegwear.isHidden = true;
+			((ModelPlayer)this.model).bipedRightLegwear.isHidden = true;
+		}
+
+		this.model.setLivingAnimations(entity, limbSwing, limbSwingAmount, partialTicks);
+		this.model.render(entity, limbSwing, limbSwingAmount, ageInTicks, netHeadYaw, headPitch, scale);
+
+		if(this.model instanceof ModelBiped) ((ModelBiped)this.model).bipedHeadwear.isHidden = false;
+
+		// Undoes the texture scaling
+		GlStateManager.matrixMode(GL11.GL_TEXTURE);
+		GlStateManager.loadIdentity();
+		GlStateManager.matrixMode(GL11.GL_MODELVIEW);
+
+		GlStateManager.popMatrix();
+	}
+
+	@Override
+	public boolean shouldCombineTextures(){
+		return false;
+	}
+}

src/main/java/electroblob/wizardry/client/renderer/LayerStone.java

@@ -1,9 +1,5 @@
 package electroblob.wizardry.client.renderer;
 
-import java.util.Map.Entry;
-
-import org.lwjgl.opengl.GL11;
-
 import electroblob.wizardry.block.BlockStatue;
 import electroblob.wizardry.client.ClientProxy;
 import net.minecraft.client.Minecraft;
@@ -21,6 +17,7 @@ import net.minecraft.entity.EntityLivingBase;
 import net.minecraft.util.ResourceLocation;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.MathHelper;
+import org.lwjgl.opengl.GL11;
 
 /**
  * Layer used to render the stone texture on a petrified creature. Handles dynamic tiling of the stone texture.
@@ -36,16 +33,14 @@ public class LayerStone implements LayerRenderer<EntityLivingBase> {
 	private static final ResourceLocation texture = new ResourceLocation("textures/blocks/stone.png");
 
 	public static void initialiseLayers(){
-		for(Entry<Class<? extends Entity>, Render<? extends Entity>> entry : Minecraft.getMinecraft()
-				.getRenderManager().entityRenderMap.entrySet()){
+
+		for(Render<? extends Entity> renderer : Minecraft.getMinecraft().getRenderManager().entityRenderMap.values()){
 			// Because the zombie classes are now split properly, their renderers play nicely like everything else.
-			if(entry.getValue() instanceof RenderLivingBase){
+			if(renderer instanceof RenderLivingBase){
 				// Adds a stone layer to all the living entity renderers in the game. Whether it is actually rendered
 				// is decided in doRenderLayer below on a per-entity basis.
-				((RenderLivingBase<?>)entry.getValue()).addLayer(new LayerStone((RenderLivingBase<?>)entry.getValue()));
+				((RenderLivingBase<?>)renderer).addLayer(new LayerStone((RenderLivingBase<?>)renderer));
 			}
-			// NOTE: May have to do some special stuff for players if they are to be added; see
-			// Minecraft.getMinecraft().getRenderManager().getSkinMap()
 		}
 	}
 
@@ -55,12 +50,13 @@ public class LayerStone implements LayerRenderer<EntityLivingBase> {
 	}
 	
 	// FIXME: Does not work with zombie pigmen, I have no idea why.
+	// I believe the issue is with the TESR actually, since LayerFrost works fine
 
 	@Override
 	public void doRenderLayer(EntityLivingBase entity, float limbSwing, float limbSwingAmount, float partialTicks,
 			float ageInTicks, float netHeadYaw, float headPitch, float scale){
 
-		if(entity.getEntityData().getBoolean(BlockStatue.NBT_KEY)){
+		if(entity.getEntityData().getBoolean(BlockStatue.PETRIFIED_NBT_KEY)){
 
 			GlStateManager.enableLighting();
 			int i = this.getBlockBrightnessForEntity(entity, partialTicks);
@@ -108,7 +104,6 @@ public class LayerStone implements LayerRenderer<EntityLivingBase> {
 
 		GlStateManager.pushMatrix();
 		// Enables tiling (Also used for guardian beam, beacon beam and ender crystal beam)
-		// TODO: Backport this improvement
 		GlStateManager.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT);
 		GlStateManager.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT);
 

src/main/java/electroblob/wizardry/client/renderer/LayerStrayMinionClothing.java

@@ -0,0 +1,33 @@
+package electroblob.wizardry.client.renderer;
+
+import electroblob.wizardry.entity.living.EntityStrayMinion;
+import net.minecraft.client.model.ModelSkeleton;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.entity.RenderLivingBase;
+import net.minecraft.client.renderer.entity.layers.LayerRenderer;
+import net.minecraft.util.ResourceLocation;
+
+/** Had to copy this entire class just because of one unnecessarily specific type parameter. The type parameter has been
+ * changed to {@code EntityStrayMinion} and parameter types updated accordingly. Everything else is identical. */
+public class LayerStrayMinionClothing implements LayerRenderer<EntityStrayMinion> {
+
+	private static final ResourceLocation STRAY_CLOTHES_TEXTURES = new ResourceLocation("textures/entity/skeleton/stray_overlay.png");
+	private final RenderLivingBase<?> renderer;
+	private final ModelSkeleton layerModel = new ModelSkeleton(0.25F, true);
+
+	public LayerStrayMinionClothing(RenderLivingBase<?> renderer){
+		this.renderer = renderer;
+	}
+
+	public void doRenderLayer(EntityStrayMinion entity, float limbSwing, float limbSwingAmount, float partialTicks, float ageInTicks, float netHeadYaw, float headPitch, float scale){
+		this.layerModel.setModelAttributes(this.renderer.getMainModel());
+		this.layerModel.setLivingAnimations(entity, limbSwing, limbSwingAmount, partialTicks);
+		GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
+		this.renderer.bindTexture(STRAY_CLOTHES_TEXTURES);
+		this.layerModel.render(entity, limbSwing, limbSwingAmount, ageInTicks, netHeadYaw, headPitch, scale);
+	}
+
+	public boolean shouldCombineTextures(){
+		return true;
+	}
+}

src/main/java/electroblob/wizardry/client/renderer/RenderArcaneLock.java

@@ -0,0 +1,89 @@
+package electroblob.wizardry.client.renderer;
+
+import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.spell.ArcaneLock;
+import electroblob.wizardry.util.WizardryUtilities;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.OpenGlHelper;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.World;
+import net.minecraftforge.client.event.RenderWorldLastEvent;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.relauncher.Side;
+import org.lwjgl.opengl.GL11;
+
+@Mod.EventBusSubscriber(Side.CLIENT)
+public class RenderArcaneLock {
+
+	private static final ResourceLocation[] textures = new ResourceLocation[8];
+
+	static {
+		for(int i=0; i<textures.length; i++){
+			textures[i] = new ResourceLocation(Wizardry.MODID, "textures/entity/arcane_lock_" + i + ".png");
+		}
+	}
+
+	@SubscribeEvent
+	public static void onRenderWorldLastEvent(RenderWorldLastEvent event){
+
+		EntityPlayer player = Minecraft.getMinecraft().player;
+		World world = Minecraft.getMinecraft().world;
+
+		GlStateManager.pushMatrix();
+		GlStateManager.enableBlend();
+		GlStateManager.disableLighting();
+		OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, 240, 240);
+		GlStateManager.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+
+		Vec3d origin = player.getPositionEyes(event.getPartialTicks());
+		GlStateManager.translate(-origin.x, -origin.y + player.getEyeHeight(), -origin.z);
+
+		GlStateManager.color(1, 1, 1, 1);
+
+		Minecraft.getMinecraft().renderEngine.bindTexture(textures[(player.ticksExisted % (textures.length * 2))/2]);
+
+		Tessellator tessellator = Tessellator.getInstance();
+		BufferBuilder buffer = tessellator.getBuffer();
+		buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX);
+
+		for(TileEntity tileentity : world.loadedTileEntityList){
+
+			if(tileentity.getDistanceSq(origin.x, origin.y, origin.z) <= 64*64 && tileentity.getTileData().hasUniqueId(ArcaneLock.NBT_KEY)){
+
+				Vec3d[] vertices = WizardryUtilities.getVertices(world.getBlockState(tileentity.getPos()).getBoundingBox(world, tileentity.getPos()).grow(0.05).offset(tileentity.getPos()));
+
+				drawFace(buffer, vertices[0], vertices[1], vertices[3], vertices[2], 0, 0, 1, 1); // Bottom
+				drawFace(buffer, vertices[6], vertices[7], vertices[2], vertices[3], 0, 0, 1, 1); // South
+				drawFace(buffer, vertices[5], vertices[6], vertices[1], vertices[2], 0, 0, 1, 1); // East
+				drawFace(buffer, vertices[4], vertices[5], vertices[0], vertices[1], 0, 0, 1, 1); // North
+				drawFace(buffer, vertices[7], vertices[4], vertices[3], vertices[0], 0, 0, 1, 1); // West
+				drawFace(buffer, vertices[5], vertices[4], vertices[6], vertices[7], 0, 0, 1, 1); // Top
+
+			}
+		}
+
+		tessellator.draw();
+
+		GlStateManager.disableBlend();
+		GlStateManager.enableTexture2D();
+		GlStateManager.enableLighting();
+		GlStateManager.disableRescaleNormal();
+		GlStateManager.popMatrix();
+	}
+
+	private static void drawFace(BufferBuilder buffer, Vec3d topLeft, Vec3d topRight, Vec3d bottomLeft, Vec3d bottomRight, float u1, float v1, float u2, float v2){
+		buffer.pos(topLeft.x, topLeft.y, topLeft.z).tex(u1, v1).endVertex();
+		buffer.pos(topRight.x, topRight.y, topRight.z).tex(u2, v1).endVertex();
+		buffer.pos(bottomRight.x, bottomRight.y, bottomRight.z).tex(u2, v2).endVertex();
+		buffer.pos(bottomLeft.x, bottomLeft.y, bottomLeft.z).tex(u1, v2).endVertex();
+	}
+
+}

src/main/java/electroblob/wizardry/client/renderer/RenderArcaneWorkbench.java

@@ -1,7 +1,5 @@
 package electroblob.wizardry.client.renderer;
 
-import org.lwjgl.opengl.GL11;
-
 import electroblob.wizardry.Wizardry;
 import electroblob.wizardry.tileentity.ContainerArcaneWorkbench;
 import electroblob.wizardry.tileentity.TileEntityArcaneWorkbench;
@@ -15,6 +13,8 @@ import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
 import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.MathHelper;
+import org.lwjgl.opengl.GL11;
 
 public class RenderArcaneWorkbench extends TileEntitySpecialRenderer<TileEntityArcaneWorkbench> {
 
@@ -30,19 +30,19 @@ public class RenderArcaneWorkbench extends TileEntitySpecialRenderer<TileEntityA
 		GlStateManager.translate((float)x + 0.5F, (float)y + 1.5F, (float)z + 0.5F);
 		GlStateManager.rotate(180, 0F, 0F, 1F);
 		GlStateManager.pushMatrix();
-		double angle = 0.0d;
+		double angle;
 		if(x < -0.5){
 			angle = Math.toDegrees(Math.atan((z + 0.5) / (x + 0.5))) + 180;
 		}else{
 			angle = Math.toDegrees(Math.atan((z + 0.5) / (x + 0.5)));
 		}
-		this.renderEffect(tileentity);
-		this.renderWand(tileentity, angle);
+		this.renderEffect(tileentity, partialTicks);
+		this.renderWand(tileentity, angle, partialTicks);
 		GlStateManager.popMatrix();
 		GlStateManager.popMatrix();
 	}
 
-	private void renderEffect(TileEntityArcaneWorkbench tileentity){
+	private void renderEffect(TileEntityArcaneWorkbench tileentity, float partialTicks){
 
 		ItemStack itemstack = tileentity.getStackInSlot(ContainerArcaneWorkbench.CENTRE_SLOT);
 
@@ -52,7 +52,7 @@ public class RenderArcaneWorkbench extends TileEntitySpecialRenderer<TileEntityA
 			OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, 240f, 240f);
 			GlStateManager.enableBlend();
 			GlStateManager.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); // This line fixes the weird brightness bug.
-			GlStateManager.rotate(tileentity.timer, 0.0f, 1.0f, 0.0f);
+			GlStateManager.rotate(tileentity.timer + partialTicks, 0.0f, 1.0f, 0.0f);
 			GlStateManager.translate(0.0f, 0.65f, 0.0f);
 			Tessellator tessellator = Tessellator.getInstance();
 			BufferBuilder buffer = tessellator.getBuffer();
@@ -76,7 +76,8 @@ public class RenderArcaneWorkbench extends TileEntitySpecialRenderer<TileEntityA
 	 * 
 	 * @param tileentity The instance of the workbench tile entity
 	 */
-	private void renderWand(TileEntityArcaneWorkbench tileentity, double viewAngle){
+	private void renderWand(TileEntityArcaneWorkbench tileentity, double viewAngle, float partialTicks){
+
 		ItemStack stack = tileentity.getStackInSlot(ContainerArcaneWorkbench.CENTRE_SLOT);
 
 		if(!stack.isEmpty()){
@@ -87,8 +88,8 @@ public class RenderArcaneWorkbench extends TileEntitySpecialRenderer<TileEntityA
 
 			GlStateManager.rotate(180, 0, 1, 0);
 			GlStateManager.rotate((float)(viewAngle - 90f), 0, 0, 1);
-			// Does the floaty thing
-			GlStateManager.translate(0.0F, 0.0F, (float)tileentity.yOffset / 5000.0F + 0.55f);
+			// Does the floaty thing		<- #bestcommentever
+			GlStateManager.translate(0.0F, 0.0F, 0.56f + 0.05f * MathHelper.sin((tileentity.timer + partialTicks)/15));//(float)tileentity.yOffset / 5000.0F + 0.55f);
 			GlStateManager.scale(0.75F, 0.75F, 0.75F);
 			// This is what the item frame uses so it's definitely what we want.
 			Minecraft.getMinecraft().getRenderItem().renderItem(stack, TransformType.FIXED);

src/main/java/electroblob/wizardry/client/renderer/RenderBlackHole.java

@@ -1,22 +1,18 @@
 package electroblob.wizardry.client.renderer;
 
-import java.util.ArrayList;
-import java.util.Collections;
-
-import org.lwjgl.opengl.GL11;
-
 import electroblob.wizardry.Wizardry;
 import electroblob.wizardry.entity.construct.EntityBlackHole;
 import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.BufferBuilder;
-import net.minecraft.client.renderer.GlStateManager;
-import net.minecraft.client.renderer.OpenGlHelper;
-import net.minecraft.client.renderer.RenderHelper;
-import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.*;
 import net.minecraft.client.renderer.entity.Render;
 import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
 import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.MathHelper;
+import org.lwjgl.opengl.GL11;
+
+import java.util.ArrayList;
+import java.util.Collections;
 
 public class RenderBlackHole extends Render<EntityBlackHole> {
 
@@ -81,21 +77,21 @@ public class RenderBlackHole extends Render<EntityBlackHole> {
 
 			int sliceAngle = 20 + a;
 
-			double x1 = scale * Math.sin((blackhole.ticksExisted + 40 * j) * (Math.PI / 180));
-			// double y1 = 0.7*Math.cos((blackhole.timer - 40*j)*(Math.PI/180))*j/10;
-			double z1 = scale * Math.cos((blackhole.ticksExisted + 40 * j) * (Math.PI / 180));
+			double x1 = scale * MathHelper.sin((blackhole.ticksExisted + 40 * j) * ((float)Math.PI / 180f));
+			// double y1 = 0.7*MathHelper.cos((blackhole.timer - 40*j)*(Math.PI/180))*j/10;
+			double z1 = scale * MathHelper.cos((blackhole.ticksExisted + 40 * j) * ((float)Math.PI / 180));
 
-			double x2 = scale * Math.sin((blackhole.ticksExisted + 40 * j - sliceAngle) * (Math.PI / 180));
-			// double y2 = 0.7*Math.sin((blackhole.timer - 40*j)*(Math.PI/180))*j/10;
-			double z2 = scale * Math.cos((blackhole.ticksExisted + 40 * j - sliceAngle) * (Math.PI / 180));
+			double x2 = scale * MathHelper.sin((blackhole.ticksExisted + 40 * j - sliceAngle) * ((float)Math.PI / 180));
+			// double y2 = 0.7*MathHelper.sin((blackhole.timer - 40*j)*(Math.PI/180))*j/10;
+			double z2 = scale * MathHelper.cos((blackhole.ticksExisted + 40 * j - sliceAngle) * ((float)Math.PI / 180));
 
-			double absoluteX = x1 * Math.cos(31 * b);
-			double absoluteY = z1 * Math.sin(31 * a) + x1 * Math.cos(31 * a) * Math.sin(31 * b);
-			double absoluteZ = z1 * Math.cos(31 * a);
+			double absoluteX = x1 * MathHelper.cos(31 * b);
+			double absoluteY = z1 * MathHelper.sin(31 * a) + x1 * MathHelper.cos(31 * a) * MathHelper.sin(31 * b);
+			double absoluteZ = z1 * MathHelper.cos(31 * a);
 
-			double absoluteX2 = x2 * Math.cos(31 * b);
-			double absoluteY2 = z2 * Math.sin(31 * a) + x2 * Math.cos(31 * a) * Math.sin(31 * b);
-			double absoluteZ2 = z2 * Math.cos(31 * a);
+			double absoluteX2 = x2 * MathHelper.cos(31 * b);
+			double absoluteY2 = z2 * MathHelper.sin(31 * a) + x2 * MathHelper.cos(31 * a) * MathHelper.sin(31 * b);
+			double absoluteZ2 = z2 * MathHelper.cos(31 * a);
 			/* buffer.begin(0, DefaultVertexFormats.POSITION_TEX);
 			 * 
 			 * tessellator.setColorOpaque(255, 255, 255); GL11.glPointSize(5);

src/main/java/electroblob/wizardry/client/renderer/RenderBubble.java

@@ -1,7 +1,5 @@
 package electroblob.wizardry.client.renderer;
 
-import org.lwjgl.opengl.GL11;
-
 import electroblob.wizardry.Wizardry;
 import electroblob.wizardry.entity.construct.EntityBubble;
 import electroblob.wizardry.util.WizardryUtilities;
@@ -14,6 +12,7 @@ import net.minecraft.client.renderer.entity.Render;
 import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
 import net.minecraft.util.ResourceLocation;
+import org.lwjgl.opengl.GL11;
 
 public class RenderBubble extends Render<EntityBubble> {
 

src/main/java/electroblob/wizardry/client/renderer/RenderContainmentField.java

@@ -0,0 +1,268 @@
+package electroblob.wizardry.client.renderer;
+
+import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.potion.PotionContainment;
+import electroblob.wizardry.registry.WizardryPotions;
+import electroblob.wizardry.util.WizardryUtilities;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.OpenGlHelper;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.nbt.NBTUtil;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.MathHelper;
+import net.minecraft.util.math.Vec3d;
+import net.minecraftforge.client.event.RenderWorldLastEvent;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.relauncher.Side;
+import org.lwjgl.opengl.GL11;
+
+@Mod.EventBusSubscriber(Side.CLIENT)
+public class RenderContainmentField {
+
+	private static final ResourceLocation[] textures = new ResourceLocation[8];
+
+	private static final float ANIMATION_SPEED = 0.004f;
+	private static final float FADE_DISTANCE_SQUARED = 15;
+
+	static {
+		for(int i=0; i<textures.length; i++){
+			textures[i] = new ResourceLocation(Wizardry.MODID, "textures/entity/containment_field_" + i + ".png");
+		}
+	}
+
+	@SubscribeEvent
+	public static void onRenderWorldLastEvent(RenderWorldLastEvent event){
+
+		EntityPlayer player = Minecraft.getMinecraft().player;
+
+		if(player.isPotionActive(WizardryPotions.containment)){
+
+			Vec3d centre = WizardryUtilities.getCentre(NBTUtil.getPosFromTag(player.getEntityData().getCompoundTag(PotionContainment.ENTITY_TAG)));
+			float r = PotionContainment.getContainmentDistance(player.getActivePotionEffect(WizardryPotions.containment).getAmplifier());
+
+			GlStateManager.pushMatrix();
+			GlStateManager.enableBlend();
+			GlStateManager.shadeModel(GL11.GL_SMOOTH); // Allows the vertex colours to produce a gradient
+			GlStateManager.disableLighting();
+			OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, 240, 240);
+			GlStateManager.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+
+			// Enables tiling (Also used for guardian beam, beacon beam and ender crystal beam)
+			GlStateManager.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT);
+			GlStateManager.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT);
+
+			// Translate the texture in the 2D space (like the creeper charge layer)
+			GlStateManager.matrixMode(GL11.GL_TEXTURE);
+			GlStateManager.loadIdentity();
+			float distance = (player.ticksExisted + event.getPartialTicks()) * ANIMATION_SPEED;
+			GlStateManager.translate(distance, distance, 0);
+			GlStateManager.matrixMode(GL11.GL_MODELVIEW);
+
+			GlStateManager.color(1, 1, 1, 1);
+
+			Minecraft.getMinecraft().renderEngine.bindTexture(textures[(player.ticksExisted % (textures.length * 2))/2]);
+
+			Tessellator tessellator = Tessellator.getInstance();
+
+			// The aim here is to have only the bits of the containment field near the player be visible (if any).
+			// There's probably a really neat, advanced way of doing this with OpenGL (stencil buffer...?) but in the
+			// absence of OpenGL skills, I've devised a cheat which kinda achieves the effect we want:
+
+			// - Split each face of the cube into four, where the split point is taken orthogonal to the player (the
+			//   player is taken as (0, 0, 0) for simplicity, unlike most render classes where the entire thing is
+			//   translated first)
+			// - Then have the alpha value for each vertex change based on its distance from the player
+			// - N.B. OpenGL renders quads as two triangles, with the 1st and 3rd vertices forming the line between them.
+			//   This causes weirdness in the interpolation since the interpolation isn't taking the whole square into
+			//   account. The order of the vertices below ensures that the seams between the triangles form an X shape
+			//   on each of the faces, meaning that you always see a square shape appear rather than a random polygon.
+
+			Vec3d relative = centre.subtract(player.getPositionEyes(event.getPartialTicks())).add(0, player.getEyeHeight(), 0);
+
+			double x1 = relative.x - r;
+			double y1 = relative.y - r;
+			double z1 = relative.z - r;
+			double x2 = relative.x + r;
+			double y2 = relative.y + r;
+			double z2 = relative.z + r;
+
+			float alpha = Math.min(1, player.getActivePotionEffect(WizardryPotions.containment).getDuration() / 40f);
+
+			BufferBuilder buffer = tessellator.getBuffer();
+			buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX_COLOR);
+
+			// The following code is mostly an incomprehensible mess of numbers, but unfortunately without a lot of
+			// fancy vector stuff it has to be like this, and besides, this is faster!
+
+			// Bottom
+			drawVertex(buffer, x1, y1, z1, 0, 0, alpha);
+			drawVertex(buffer, x1, y1, 0, 0, -(float)z1, alpha);
+			drawVertex(buffer, 0, y1, 0, -(float)x1, -(float)z1, alpha);
+			drawVertex(buffer, 0, y1, z1, -(float)x1, 0, alpha);
+
+			drawVertex(buffer, 0, y1, 0, -(float)x1, -(float)z1, alpha);
+			drawVertex(buffer, x2, y1, 0, 2*r, -(float)z1, alpha);
+			drawVertex(buffer, x2, y1, z1, 2*r, 0, alpha);
+			drawVertex(buffer, 0, y1, z1, -(float)x1, 0, alpha);
+
+			drawVertex(buffer, x1, y1, z2, 0, 2*r, alpha);
+			drawVertex(buffer, 0, y1, z2, -(float)x1, 2*r, alpha);
+			drawVertex(buffer, 0, y1, 0, -(float)x1, -(float)z1, alpha);
+			drawVertex(buffer, x1, y1, 0, 0, -(float)z1, alpha);
+
+			drawVertex(buffer, 0, y1, 0, -(float)x1, -(float)z1, alpha);
+			drawVertex(buffer, 0, y1, z2, -(float)x1, 2*r, alpha);
+			drawVertex(buffer, x2, y1, z2, 2*r, 2*r, alpha);
+			drawVertex(buffer, x2, y1, 0, 2*r, -(float)z1, alpha);
+
+			// Top
+			drawVertex(buffer, x1, y2, z1, 0, 0, alpha);
+			drawVertex(buffer, 0, y2, z1, -(float)x1, 0, alpha);
+			drawVertex(buffer, 0, y2, 0, -(float)x1, -(float)z1, alpha);
+			drawVertex(buffer, x1, y2, 0, 0, -(float)z1, alpha);
+
+			drawVertex(buffer, x2, y2, z1, 2*r, 0, alpha);
+			drawVertex(buffer, x2, y2, 0, 2*r, -(float)z1, alpha);
+			drawVertex(buffer, 0, y2, 0, -(float)x1, -(float)z1, alpha);
+			drawVertex(buffer, 0, y2, z1, -(float)x1, 0, alpha);
+
+			drawVertex(buffer, 0, y2, 0, -(float)x1, -(float)z1, alpha);
+			drawVertex(buffer, 0, y2, z2, -(float)x1, 2*r, alpha);
+			drawVertex(buffer, x1, y2, z2, 0, 2*r, alpha);
+			drawVertex(buffer, x1, y2, 0, 0, -(float)z1, alpha);
+
+			drawVertex(buffer, 0, y2, 0, -(float)x1, -(float)z1, alpha);
+			drawVertex(buffer, x2, y2, 0, 2*r, -(float)z1, alpha);
+			drawVertex(buffer, x2, y2, z2, 2*r, 2*r, alpha);
+			drawVertex(buffer, 0, y2, z2, -(float)x1, 2*r, alpha);
+
+			// North
+			drawVertex(buffer, x1, y1, z1, 0, 0, alpha);
+			drawVertex(buffer, 0, y1, z1, -(float)x1, 0, alpha);
+			drawVertex(buffer, 0, 0, z1, -(float)x1, -(float)y1, alpha);
+			drawVertex(buffer, x1, 0, z1, 0, -(float)y1, alpha);
+
+			drawVertex(buffer, x2, y1, z1, 2*r, 0, alpha);
+			drawVertex(buffer, x2, 0, z1, 2*r, -(float)y1, alpha);
+			drawVertex(buffer, 0, 0, z1, -(float)x1, -(float)y1, alpha);
+			drawVertex(buffer, 0, y1, z1, -(float)x1, 0, alpha);
+
+			drawVertex(buffer, 0, 0, z1, -(float)x1, -(float)y1, alpha);
+			drawVertex(buffer, 0, y2, z1, -(float)x1, 2*r, alpha);
+			drawVertex(buffer, x1, y2, z1, 0, 2*r, alpha);
+			drawVertex(buffer, x1, 0, z1, 0, -(float)y1, alpha);
+
+			drawVertex(buffer, 0, 0, z1, -(float)x1, -(float)y1, alpha);
+			drawVertex(buffer, x2, 0, z1, 2*r, -(float)y1, alpha);
+			drawVertex(buffer, x2, y2, z1, 2*r, 2*r, alpha);
+			drawVertex(buffer, 0, y2, z1, -(float)x1, 2*r, alpha);
+
+			// South
+			drawVertex(buffer, x1, y1, z2, 0, 0, alpha);
+			drawVertex(buffer, x1, 0, z2, 0, -(float)y1, alpha);
+			drawVertex(buffer, 0, 0, z2, -(float)x1, -(float)y1, alpha);
+			drawVertex(buffer, 0, y1, z2, -(float)x1, 0, alpha);
+
+			drawVertex(buffer, 0, 0, z2, -(float)x1, -(float)y1, alpha);
+			drawVertex(buffer, x2, 0, z2, 2*r, -(float)y1, alpha);
+			drawVertex(buffer, x2, y1, z2, 2*r, 0, alpha);
+			drawVertex(buffer, 0, y1, z2, -(float)x1, 0, alpha);
+
+			drawVertex(buffer, x1, y2, z2, 0, 2*r, alpha);
+			drawVertex(buffer, 0, y2, z2, -(float)x1, 2*r, alpha);
+			drawVertex(buffer, 0, 0, z2, -(float)x1, -(float)y1, alpha);
+			drawVertex(buffer, x1, 0, z2, 0, -(float)y1, alpha);
+
+			drawVertex(buffer, 0, 0, z2, -(float)x1, -(float)y1, alpha);
+			drawVertex(buffer, 0, y2, z2, -(float)x1, 2*r, alpha);
+			drawVertex(buffer, x2, y2, z2, 2*r, 2*r, alpha);
+			drawVertex(buffer, x2, 0, z2, 2*r, -(float)y1, alpha);
+
+			// West
+			drawVertex(buffer, x1, y1, z1, 0, 0, alpha);
+			drawVertex(buffer, x1, 0, z1, 0, -(float)y1, alpha);
+			drawVertex(buffer, x1, 0, 0, -(float)z1, -(float)y1, alpha);
+			drawVertex(buffer, x1, y1, 0, -(float)z1, 0, alpha);
+
+			drawVertex(buffer, x1, 0, 0, -(float)z1, -(float)y1, alpha);
+			drawVertex(buffer, x1, 0, z2, 2*r, -(float)y1, alpha);
+			drawVertex(buffer, x1, y1, z2, 2*r, 0, alpha);
+			drawVertex(buffer, x1, y1, 0, -(float)z1, 0, alpha);
+
+			drawVertex(buffer, x1, y2, z1, 0, 2*r, alpha);
+			drawVertex(buffer, x1, y2, 0, -(float)z1, 2*r, alpha);
+			drawVertex(buffer, x1, 0, 0, -(float)z1, -(float)y1, alpha);
+			drawVertex(buffer, x1, 0, z1, 0, -(float)y1, alpha);
+
+			drawVertex(buffer, x1, 0, 0, -(float)z1, -(float)y1, alpha);
+			drawVertex(buffer, x1, y2, 0, -(float)z1, 2*r, alpha);
+			drawVertex(buffer, x1, y2, z2, 2*r, 2*r, alpha);
+			drawVertex(buffer, x1, 0, z2, 2*r, -(float)y1, alpha);
+
+			// East
+			drawVertex(buffer, x2, y1, z1, 0, 0, alpha);
+			drawVertex(buffer, x2, y1, 0, -(float)z1, 0, alpha);
+			drawVertex(buffer, x2, 0, 0, -(float)z1, -(float)y1, alpha);
+			drawVertex(buffer, x2, 0, z1, 0, -(float)y1, alpha);
+
+			drawVertex(buffer, x2, y1, z2, 2*r, 0, alpha);
+			drawVertex(buffer, x2, 0, z2, 2*r, -(float)y1, alpha);
+			drawVertex(buffer, x2, 0, 0, -(float)z1, -(float)y1, alpha);
+			drawVertex(buffer, x2, y1, 0, -(float)z1, 0, alpha);
+
+			drawVertex(buffer, x2, 0, 0, -(float)z1, -(float)y1, alpha);
+			drawVertex(buffer, x2, y2, 0, -(float)z1, 2*r, alpha);
+			drawVertex(buffer, x2, y2, z1, 0, 2*r, alpha);
+			drawVertex(buffer, x2, 0, z1, 0, -(float)y1, alpha);
+
+			drawVertex(buffer, x2, 0, 0, -(float)z1, -(float)y1, alpha);
+			drawVertex(buffer, x2, 0, z2, 2*r, -(float)y1, alpha);
+			drawVertex(buffer, x2, y2, z2, 2*r, 2*r, alpha);
+			drawVertex(buffer, x2, y2, 0, -(float)z1, 2*r, alpha);
+
+			tessellator.draw();
+
+			// Undoes the texture translation
+			GlStateManager.matrixMode(GL11.GL_TEXTURE);
+			GlStateManager.loadIdentity();
+			GlStateManager.matrixMode(GL11.GL_MODELVIEW);
+
+			GlStateManager.disableBlend();
+			GlStateManager.enableTexture2D();
+			GlStateManager.enableLighting();
+			GlStateManager.disableRescaleNormal();
+			GlStateManager.popMatrix();
+		}
+	}
+
+	private static void drawVertex(BufferBuilder buffer, double x, double y, double z, float u, float v, float alpha){
+		float f = MathHelper.clamp(1 - (float)(x*x + y*y + z*z) / FADE_DISTANCE_SQUARED, 0, 1);
+		buffer.pos(x, y, z).tex(u, v).color(1, 1, 1, f * alpha).endVertex();
+	}
+
+	// Useful to keep this mapping in case I ever want to draw cubes again
+
+//			Vec3d[] vertices = WizardryUtilities.getVertices(entity.getEntityBoundingBox().offset(entity.getPositionVector().scale(-1)));
+//
+//			// Outside
+//			drawFace(tessellator, vertices[0], vertices[1], vertices[3], vertices[2], u1, v1, u2, v2); // Bottom
+//			drawFace(tessellator, vertices[6], vertices[7], vertices[2], vertices[3], u1, v1, u2, v2); // South
+//			drawFace(tessellator, vertices[5], vertices[6], vertices[1], vertices[2], u1, v1, u2, v2); // East
+//			drawFace(tessellator, vertices[4], vertices[5], vertices[0], vertices[1], u1, v1, u2, v2); // North
+//			drawFace(tessellator, vertices[7], vertices[4], vertices[3], vertices[0], u1, v1, u2, v2); // West
+//			drawFace(tessellator, vertices[5], vertices[4], vertices[6], vertices[7], u1, v1, u2, v2); // Top
+//
+//			// Inside
+//			drawFace(tessellator, vertices[1], vertices[0], vertices[2], vertices[3], u1, v1, u2, v2); // Bottom
+//			drawFace(tessellator, vertices[7], vertices[6], vertices[3], vertices[2], u1, v1, u2, v2); // South
+//			drawFace(tessellator, vertices[6], vertices[5], vertices[2], vertices[1], u1, v1, u2, v2); // East
+//			drawFace(tessellator, vertices[5], vertices[4], vertices[1], vertices[0], u1, v1, u2, v2); // North
+//			drawFace(tessellator, vertices[4], vertices[7], vertices[0], vertices[3], u1, v1, u2, v2); // West
+//			drawFace(tessellator, vertices[4], vertices[5], vertices[7], vertices[6], u1, v1, u2, v2); // Top
+
+}

src/main/java/electroblob/wizardry/client/renderer/RenderDecay.java

@@ -1,7 +1,5 @@
 package electroblob.wizardry.client.renderer;
 
-import org.lwjgl.opengl.GL11;
-
 import electroblob.wizardry.Wizardry;
 import electroblob.wizardry.entity.construct.EntityDecay;
 import net.minecraft.client.renderer.BufferBuilder;
@@ -12,6 +10,7 @@ import net.minecraft.client.renderer.entity.Render;
 import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
 import net.minecraft.util.ResourceLocation;
+import org.lwjgl.opengl.GL11;
 
 public class RenderDecay extends Render<EntityDecay> {
 

src/main/java/electroblob/wizardry/client/renderer/RenderDecoy.java

@@ -1,8 +1,5 @@
 package electroblob.wizardry.client.renderer;
 
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-
 import electroblob.wizardry.Wizardry;
 import electroblob.wizardry.entity.living.EntityDecoy;
 import net.minecraft.client.model.ModelBiped;
@@ -12,10 +9,11 @@ import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.entity.Entity;
 import net.minecraft.util.ResourceLocation;
 import net.minecraftforge.fml.relauncher.ReflectionHelper;
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
 
-@SideOnly(Side.CLIENT)
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+//@SideOnly(Side.CLIENT)
 public class RenderDecoy extends RenderBiped<EntityDecoy> {
 
 	private static final ResourceLocation steveTextures = new ResourceLocation("textures/entity/steve.png");

src/main/java/electroblob/wizardry/client/renderer/RenderEvilWizard.java

@@ -7,10 +7,8 @@ import net.minecraft.client.renderer.entity.RenderBiped;
 import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.client.renderer.entity.layers.LayerBipedArmor;
 import net.minecraft.util.ResourceLocation;
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
 
-@SideOnly(Side.CLIENT)
+//@SideOnly(Side.CLIENT)
 public class RenderEvilWizard extends RenderBiped<EntityEvilWizard> {
 	static final ResourceLocation[] textures = new ResourceLocation[6];
 

src/main/java/electroblob/wizardry/client/renderer/RenderFireRing.java

@@ -1,7 +1,5 @@
 package electroblob.wizardry.client.renderer;
 
-import org.lwjgl.opengl.GL11;
-
 import electroblob.wizardry.entity.construct.EntityFireRing;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.BufferBuilder;
@@ -15,6 +13,7 @@ import net.minecraft.client.renderer.texture.TextureMap;
 import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
 import net.minecraft.init.Blocks;
 import net.minecraft.util.ResourceLocation;
+import org.lwjgl.opengl.GL11;
 
 public class RenderFireRing extends Render<EntityFireRing> {
 

src/main/java/electroblob/wizardry/client/renderer/RenderForceArrow.java

@@ -1,7 +1,5 @@
 package electroblob.wizardry.client.renderer;
 
-import org.lwjgl.opengl.GL11;
-
 import electroblob.wizardry.Wizardry;
 import electroblob.wizardry.entity.projectile.EntityForceArrow;
 import net.minecraft.client.renderer.BufferBuilder;
@@ -13,10 +11,9 @@ import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
 import net.minecraft.util.ResourceLocation;
 import net.minecraft.util.math.MathHelper;
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
+import org.lwjgl.opengl.GL11;
 
-@SideOnly(Side.CLIENT)
+//@SideOnly(Side.CLIENT)
 public class RenderForceArrow extends Render<EntityForceArrow> {
 
 	private static final ResourceLocation arrowTextures = new ResourceLocation(Wizardry.MODID,

src/main/java/electroblob/wizardry/client/renderer/RenderForcefield.java

@@ -0,0 +1,124 @@
+package electroblob.wizardry.client.renderer;
+
+import electroblob.wizardry.entity.construct.EntityForcefield;
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.OpenGlHelper;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.entity.Render;
+import net.minecraft.client.renderer.entity.RenderManager;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.MathHelper;
+import org.lwjgl.opengl.GL11;
+
+public class RenderForcefield extends Render<EntityForcefield> {
+
+	private static final float EXPANSION_TIME = 3;
+
+	public RenderForcefield(RenderManager renderManager){
+		super(renderManager);
+	}
+
+	@Override
+	public void doRender(EntityForcefield entity, double x, double y, double z, float yaw, float partialTicks){
+
+		// For now we're just using a UV sphere
+
+		GlStateManager.pushMatrix();
+
+		GlStateManager.disableLighting();
+		GlStateManager.enableBlend();
+		GlStateManager.disableTexture2D();
+		GlStateManager.blendFunc(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA);
+		OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, 240f, 240f);
+
+		GlStateManager.translate(x, y, z);
+
+		float latStep = (float)Math.PI/20;
+		float longStep = (float)Math.PI/20;
+
+		float pulse = MathHelper.sin((entity.ticksExisted + partialTicks)/10f);
+
+		float r = 0.35f, g = 0.55f + 0.05f * pulse, b = 1;
+
+		float radius = entity.getRadius();
+		float a = 0.5f;
+
+		if(entity.ticksExisted > entity.lifetime - EXPANSION_TIME){
+			radius *= 1 + 0.2f * (entity.ticksExisted + partialTicks - (entity.lifetime - EXPANSION_TIME))/EXPANSION_TIME;
+			a *= Math.max(0, 1 - (entity.ticksExisted + partialTicks - (entity.lifetime - EXPANSION_TIME))/EXPANSION_TIME);
+		}else if(entity.ticksExisted < EXPANSION_TIME){
+			radius *= 1 - (EXPANSION_TIME - entity.ticksExisted - partialTicks)/EXPANSION_TIME;
+			a *= 1 - (EXPANSION_TIME - entity.ticksExisted - partialTicks)/EXPANSION_TIME;
+		}
+
+		// Draw the inside first
+		drawSphere(radius - 0.1f - 0.025f * pulse, latStep, longStep, true, r, g, b, a);
+		drawSphere(radius - 0.1f - 0.025f * pulse, latStep, longStep, false, 1, 1, 1, a);
+		drawSphere(radius, latStep, longStep, false, r, g, b, 0.7f * a);
+
+		GlStateManager.enableTexture2D();
+		GlStateManager.enableLighting();
+		GlStateManager.disableBlend();
+
+		GlStateManager.popMatrix();
+	}
+
+	@Override
+	protected ResourceLocation getEntityTexture(EntityForcefield entity){
+		return null;
+	}
+
+	/**
+	 * Draws a sphere (using lat/long triangles) with the given parameters.
+	 * @param radius The radius of the sphere.
+	 * @param latStep The latitude step; smaller is smoother but increases performance cost.
+	 * @param longStep The longitude step; smaller is smoother but increases performance cost.
+	 * @param inside Whether to draw the outside or the inside of the sphere.
+	 * @param r The red component of the sphere colour.
+	 * @param g The green component of the sphere colour.
+	 * @param b The blue component of the sphere colour.
+	 * @param a The alpha component of the sphere colour.
+	 */
+	private static void drawSphere(float radius, float latStep, float longStep, boolean inside, float r, float g, float b, float a){
+
+		Tessellator tessellator = Tessellator.getInstance();
+		BufferBuilder buffer = tessellator.getBuffer();
+
+		buffer.begin(GL11.GL_TRIANGLE_STRIP, DefaultVertexFormats.POSITION_COLOR);
+
+		boolean goingUp = inside;
+
+		buffer.pos(0, goingUp ? -radius : radius, 0).color(r, g, b, a).endVertex(); // Start at the north pole
+
+		for(float longitude = -(float)Math.PI; longitude <= (float)Math.PI; longitude += longStep){
+
+			// Leave the poles out since they only have a single point per stack instead of two
+			for(float theta = (float)Math.PI/2 - latStep; theta >= -(float)Math.PI/2 + latStep; theta -= latStep){
+
+				float latitude = goingUp ? -theta : theta;
+
+				float hRadius = radius * MathHelper.cos(latitude);
+				float vy = radius * MathHelper.sin(latitude);
+				float vx = hRadius * MathHelper.sin(longitude);
+				float vz = hRadius * MathHelper.cos(longitude);
+
+				buffer.pos(vx, vy, vz).color(r, g, b, a).endVertex();
+
+				vx = hRadius * MathHelper.sin(longitude + longStep);
+				vz = hRadius * MathHelper.cos(longitude + longStep);
+
+				buffer.pos(vx, vy, vz).color(r, g, b, a).endVertex();
+			}
+
+			// The next pole
+			buffer.pos(0, goingUp ? radius : -radius, 0).color(r, g, b, a).endVertex();
+
+			goingUp = !goingUp;
+		}
+
+		tessellator.draw();
+	}
+
+}

src/main/java/electroblob/wizardry/client/renderer/RenderHammer.java

@@ -19,11 +19,13 @@ public class RenderHammer extends Render<EntityHammer> {
 	}
 
 	@Override
-	public void doRender(EntityHammer entity, double x, double y, double z, float f, float f1){
+	public void doRender(EntityHammer entity, double x, double y, double z, float yaw, float partialTicks){
 
 		GlStateManager.pushMatrix();
 		GlStateManager.translate(x, y + 1.5, z);
 		GlStateManager.rotate(180, 0F, 0F, 1F);
+		GlStateManager.rotate(yaw, 0, 1, 0);
+		GlStateManager.rotate(entity.prevRotationPitch + (entity.rotationPitch - entity.prevRotationPitch) * partialTicks, 0, 0, 1);
 
 		this.bindTexture(texture);
 

src/main/java/electroblob/wizardry/client/renderer/RenderIceGiant.java

@@ -7,10 +7,8 @@ import net.minecraft.client.renderer.GlStateManager;
 import net.minecraft.client.renderer.entity.RenderLiving;
 import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.util.ResourceLocation;
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
 
-@SideOnly(Side.CLIENT)
+//@SideOnly(Side.CLIENT)
 public class RenderIceGiant extends RenderLiving<EntityIceGiant> {
 
 	private static final ResourceLocation texture = new ResourceLocation(Wizardry.MODID,

src/main/java/electroblob/wizardry/client/renderer/RenderIceSpike.java

@@ -1,7 +1,5 @@
 package electroblob.wizardry.client.renderer;
 
-import org.lwjgl.opengl.GL11;
-
 import electroblob.wizardry.Wizardry;
 import electroblob.wizardry.entity.construct.EntityIceSpike;
 import net.minecraft.client.renderer.BufferBuilder;
@@ -12,6 +10,7 @@ import net.minecraft.client.renderer.entity.Render;
 import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
 import net.minecraft.util.ResourceLocation;
+import org.lwjgl.opengl.GL11;
 
 public class RenderIceSpike extends Render<EntityIceSpike> {
 
@@ -23,13 +22,14 @@ public class RenderIceSpike extends Render<EntityIceSpike> {
 	}
 
 	@Override
-	public void doRender(EntityIceSpike entity, double x, double y, double z, float fa, float partialTickTime){
+	public void doRender(EntityIceSpike entity, double x, double y, double z, float yaw, float partialTickTime){
 
 		GlStateManager.pushMatrix();
 
 		GlStateManager.translate((float)x, (float)y, (float)z);
-		// Apparently, disabling lighting... doesn't disable lighting. Or at least, you can still set the brightness
-		// with setLightmapTextureCoords.
+		GlStateManager.rotate(entity.rotationYaw - 90.0F, 0.0F, 1.0F, 0.0F);
+		GlStateManager.rotate(entity.rotationPitch - 90, 0.0F, 0.0F, 1.0F);
+
 		GlStateManager.disableLighting();
 
 		int j = entity.getBrightnessForRender();

src/main/java/electroblob/wizardry/client/renderer/RenderLightningDisc.java

@@ -1,7 +1,5 @@
 package electroblob.wizardry.client.renderer;
 
-import org.lwjgl.opengl.GL11;
-
 import electroblob.wizardry.entity.projectile.EntityLightningDisc;
 import net.minecraft.client.renderer.BufferBuilder;
 import net.minecraft.client.renderer.GlStateManager;
@@ -11,6 +9,7 @@ import net.minecraft.client.renderer.entity.Render;
 import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
 import net.minecraft.util.ResourceLocation;
+import org.lwjgl.opengl.GL11;
 
 public class RenderLightningDisc extends Render<EntityLightningDisc> {
 

src/main/java/electroblob/wizardry/client/renderer/RenderMagicArrow.java

@@ -1,7 +1,5 @@
 package electroblob.wizardry.client.renderer;
 
-import org.lwjgl.opengl.GL11;
-
 import electroblob.wizardry.entity.projectile.EntityMagicArrow;
 import net.minecraft.client.renderer.BufferBuilder;
 import net.minecraft.client.renderer.GlStateManager;
@@ -12,10 +10,9 @@ import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
 import net.minecraft.util.ResourceLocation;
 import net.minecraft.util.math.MathHelper;
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
+import org.lwjgl.opengl.GL11;
 
-@SideOnly(Side.CLIENT)
+//@SideOnly(Side.CLIENT)
 public class RenderMagicArrow extends Render<EntityMagicArrow> {
 
 	private final ResourceLocation texture;

src/main/java/electroblob/wizardry/client/renderer/RenderMagicLight.java

@@ -1,18 +1,14 @@
 package electroblob.wizardry.client.renderer;
 
-import org.lwjgl.opengl.GL11;
-
 import electroblob.wizardry.Wizardry;
 import electroblob.wizardry.tileentity.TileEntityMagicLight;
 import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.BufferBuilder;
-import net.minecraft.client.renderer.GlStateManager;
-import net.minecraft.client.renderer.OpenGlHelper;
-import net.minecraft.client.renderer.RenderHelper;
-import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.*;
 import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
 import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
 import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.MathHelper;
+import org.lwjgl.opengl.GL11;
 
 public class RenderMagicLight extends TileEntitySpecialRenderer<TileEntityMagicLight> {
 
@@ -40,10 +36,9 @@ public class RenderMagicLight extends TileEntitySpecialRenderer<TileEntityMagicL
 			GlStateManager.scale((float)tileentity.timer / 10, (float)tileentity.timer / 10,
 					(float)tileentity.timer / 10);
 		}
-		if(tileentity.timer > tileentity.maxTimer - 10 && tileentity.timer <= tileentity.maxTimer){
-			GlStateManager.scale((float)(tileentity.maxTimer - tileentity.timer) / 10,
-					(float)(tileentity.maxTimer - tileentity.timer) / 10,
-					(float)(tileentity.maxTimer - tileentity.timer) / 10);
+		if(tileentity.maxTimer > 0 && tileentity.timer > tileentity.maxTimer - 10){
+			float scale = Math.max(0, (float)(tileentity.maxTimer - tileentity.timer) / 10);
+			GlStateManager.scale(scale, scale, scale);
 		}
 
 		// Renders the aura effect
@@ -105,13 +100,13 @@ public class RenderMagicLight extends TileEntitySpecialRenderer<TileEntityMagicL
 				buffer.pos(0, 0, 0).tex(0, 0).color(255, 255, 255, 0).endVertex();
 				buffer.pos(0, 0, 0).tex(0, 1).color(255, 255, 255, 0).endVertex();
 
-				double x1 = scale * Math.sin((tileentity.timer + 40 * j) * (Math.PI / 180));
-				// double y1 = 0.7*Math.cos((timerentity.timer - 40*j)*(Math.PI/180))*j/10;
-				double z1 = scale * Math.cos((tileentity.timer + 40 * j) * (Math.PI / 180));
+				double x1 = scale * MathHelper.sin((tileentity.timer + 40 * j) * ((float)Math.PI / 180));
+				// double y1 = 0.7*MathHelper.cos((timerentity.timer - 40*j)*(Math.PI/180))*j/10;
+				double z1 = scale * MathHelper.cos((tileentity.timer + 40 * j) * ((float)Math.PI / 180));
 
-				double x2 = scale * Math.sin((tileentity.timer + 40 * j - sliceAngle) * (Math.PI / 180));
-				// double y2 = 0.7*Math.sin((timerentity.timer - 40*j)*(Math.PI/180))*j/10;
-				double z2 = scale * Math.cos((tileentity.timer + 40 * j - sliceAngle) * (Math.PI / 180));
+				double x2 = scale * MathHelper.sin((tileentity.timer + 40 * j - sliceAngle) * ((float)Math.PI / 180));
+				// double y2 = 0.7*MathHelper.sin((timerentity.timer - 40*j)*(Math.PI/180))*j/10;
+				double z2 = scale * MathHelper.cos((tileentity.timer + 40 * j - sliceAngle) * ((float)Math.PI / 180));
 
 				buffer.pos(x1, 0, z1).tex(1, 0).color(0, 0, 0, 255).endVertex();
 				buffer.pos(x2, 0, z2).tex(1, 1).color(0, 0, 0, 255).endVertex();

src/main/java/electroblob/wizardry/client/renderer/RenderPhoenix.java

@@ -1,7 +1,5 @@
 package electroblob.wizardry.client.renderer;
 
-import org.lwjgl.opengl.GL11;
-
 import electroblob.wizardry.Wizardry;
 import electroblob.wizardry.client.model.ModelPhoenix;
 import electroblob.wizardry.entity.living.EntityPhoenix;
@@ -10,10 +8,9 @@ import net.minecraft.client.renderer.OpenGlHelper;
 import net.minecraft.client.renderer.entity.RenderLiving;
 import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.util.ResourceLocation;
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
+import org.lwjgl.opengl.GL11;
 
-@SideOnly(Side.CLIENT)
+//@SideOnly(Side.CLIENT)
 public class RenderPhoenix extends RenderLiving<EntityPhoenix> {
 
 	private static final ResourceLocation texture = new ResourceLocation(Wizardry.MODID, "textures/entity/phoenix.png");

src/main/java/electroblob/wizardry/client/renderer/RenderPossessingPlayer.java

@@ -0,0 +1,41 @@
+package electroblob.wizardry.client.renderer;
+
+import electroblob.wizardry.spell.Possession;
+import net.minecraft.client.renderer.entity.Render;
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraftforge.client.event.RenderPlayerEvent;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.relauncher.Side;
+
+@Mod.EventBusSubscriber(Side.CLIENT)
+public class RenderPossessingPlayer {
+
+	@SubscribeEvent
+	@SuppressWarnings("unchecked") // Can't check it due to type erasure
+	public static void onRenderPlayerPreEvent(RenderPlayerEvent.Pre event){
+
+		EntityPlayer player = event.getEntityPlayer();
+		EntityLiving possessee = Possession.getPossessee(player);
+
+		if(possessee != null){
+			// I reject your renderer and substitute my own!
+			Render<EntityLiving> renderer = (Render<EntityLiving>)event.getRenderer().getRenderManager().entityRenderMap.get(possessee.getClass());
+			float yaw = player.prevRotationYaw + (player.rotationYaw - player.prevRotationYaw) * event.getPartialRenderTick();
+			possessee.swingProgress = player.swingProgress;
+			possessee.prevSwingProgress = player.prevSwingProgress;
+			possessee.renderYawOffset = player.renderYawOffset;
+			possessee.prevRenderYawOffset = player.prevRenderYawOffset;
+			possessee.rotationYawHead = player.rotationYawHead;
+			possessee.prevRotationYawHead = player.prevRotationYawHead;
+			possessee.rotationPitch = player.rotationPitch;
+			possessee.prevRotationPitch = player.prevRotationPitch;
+			possessee.limbSwing = player.limbSwing;
+			possessee.limbSwingAmount = player.limbSwingAmount;
+			possessee.prevLimbSwingAmount = player.prevLimbSwingAmount;
+			renderer.doRender(possessee, event.getX(), event.getY(), event.getZ(), yaw, event.getPartialRenderTick());
+			event.setCanceled(true);
+		}
+	}
+}

src/main/java/electroblob/wizardry/client/renderer/RenderProjectile.java

@@ -1,7 +1,5 @@
 package electroblob.wizardry.client.renderer;
 
-import org.lwjgl.opengl.GL11;
-
 import electroblob.wizardry.entity.projectile.EntityMagicProjectile;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.BufferBuilder;
@@ -12,10 +10,9 @@ import net.minecraft.client.renderer.entity.Render;
 import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
 import net.minecraft.util.ResourceLocation;
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
+import org.lwjgl.opengl.GL11;
 
-@SideOnly(Side.CLIENT)
+//@SideOnly(Side.CLIENT)
 public class RenderProjectile extends Render<EntityMagicProjectile> {
 
 	private float scale;

src/main/java/electroblob/wizardry/client/renderer/RenderShadowWard.java

@@ -0,0 +1,148 @@
+package electroblob.wizardry.client.renderer;
+
+import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.registry.Spells;
+import electroblob.wizardry.util.WizardryUtilities;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.OpenGlHelper;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.Vec3d;
+import net.minecraftforge.client.event.RenderPlayerEvent;
+import net.minecraftforge.client.event.RenderWorldLastEvent;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.relauncher.Side;
+import org.lwjgl.opengl.GL11;
+
+@Mod.EventBusSubscriber(Side.CLIENT)
+public class RenderShadowWard {
+
+	private static final ResourceLocation TEXTURE = new ResourceLocation(Wizardry.MODID, "textures/entity/shadow_ward.png");
+
+	// First person
+	@SubscribeEvent
+	public static void onRenderWorldLastEvent(RenderWorldLastEvent event){
+		// Only render in first person
+		if(Minecraft.getMinecraft().gameSettings.thirdPersonView == 0){
+
+			EntityPlayer player = Minecraft.getMinecraft().player;
+
+			if(WizardryUtilities.isCasting(player, Spells.shadow_ward)){
+
+				GlStateManager.pushMatrix();
+
+				GlStateManager.enableBlend();
+				GlStateManager.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+				//GlStateManager.shadeModel(GL11.GL_SMOOTH);
+				GlStateManager.disableLighting();
+				//GlStateManager.disableAlpha();
+				OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, 240f, 240f);
+
+				GlStateManager.translate(0, 1.2, 0);
+				GlStateManager.rotate(-player.rotationYaw, 0, 1, 0);
+				GlStateManager.rotate(player.rotationPitch, 1, 0, 0);
+
+				Minecraft.getMinecraft().renderEngine.bindTexture(TEXTURE);
+
+				GlStateManager.pushMatrix();
+
+				GlStateManager.translate(0, 0, 1.2);
+				GlStateManager.rotate(player.world.getTotalWorldTime() * -2, 0, 0, 1);
+				GlStateManager.scale(1.1, 1.1, 1.1);
+
+				Tessellator tessellator = Tessellator.getInstance();
+				BufferBuilder buffer = tessellator.getBuffer();
+
+				buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX);
+
+				buffer.pos(-0.5, 0.5, -0.5).tex(0, 0).endVertex();
+				buffer.pos(0.5, 0.5, -0.5).tex(1, 0).endVertex();
+				buffer.pos(0.5, -0.5, -0.5).tex(1, 1).endVertex();
+				buffer.pos(-0.5, -0.5, -0.5).tex(0, 1).endVertex();
+
+				tessellator.draw();
+
+				buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX);
+
+				buffer.pos(-0.5, 0.5, -0.5).tex(0, 0).endVertex();
+				buffer.pos(-0.5, -0.5, -0.5).tex(0, 1).endVertex();
+				buffer.pos(0.5, -0.5, -0.5).tex(1, 1).endVertex();
+				buffer.pos(0.5, 0.5, -0.5).tex(1, 0).endVertex();
+
+				tessellator.draw();
+
+				GlStateManager.popMatrix();
+
+				//GlStateManager.shadeModel(GL11.GL_FLAT);
+				GlStateManager.enableLighting();
+				GlStateManager.disableBlend();
+
+				GlStateManager.popMatrix();
+
+			}
+		}
+	}
+
+	// Third person
+	@SubscribeEvent
+	public static void onRenderPlayerEvent(RenderPlayerEvent.Post event){
+
+		EntityPlayer player = event.getEntityPlayer();
+
+		if(WizardryUtilities.isCasting(player, Spells.shadow_ward)){
+
+			GlStateManager.pushMatrix();
+
+			GlStateManager.enableBlend();
+			GlStateManager.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+			GlStateManager.disableLighting();
+			OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, 240f, 240f);
+
+			Vec3d delta = player.getPositionEyes(event.getPartialRenderTick())
+					.subtract(Minecraft.getMinecraft().player.getPositionEyes(event.getPartialRenderTick()));
+			GlStateManager.translate(delta.x, delta.y, delta.z);
+
+			GlStateManager.rotate(180, 0, 1, 0);
+			GlStateManager.rotate(-player.renderYawOffset, 0, 1, 0);
+
+			Minecraft.getMinecraft().renderEngine.bindTexture(TEXTURE);
+
+			Tessellator tessellator = Tessellator.getInstance();
+			BufferBuilder buffer = tessellator.getBuffer();
+
+			GlStateManager.translate(0, 1.2, 0);
+			GlStateManager.rotate(player.world.getTotalWorldTime() * -2, 0, 0, 1);
+			GlStateManager.scale(1.1, 1.1, 1.1);
+
+			buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX);
+
+			buffer.pos(-0.5, 0.5, -0.5).tex(0, 0).endVertex();
+			buffer.pos(0.5, 0.5, -0.5).tex(1, 0).endVertex();
+			buffer.pos(0.5, -0.5, -0.5).tex(1, 1).endVertex();
+			buffer.pos(-0.5, -0.5, -0.5).tex(0, 1).endVertex();
+
+			tessellator.draw();
+
+			buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX);
+
+			buffer.pos(-0.5, 0.5, -0.5).tex(0, 0).endVertex();
+			buffer.pos(-0.5, -0.5, -0.5).tex(0, 1).endVertex();
+			buffer.pos(0.5, -0.5, -0.5).tex(1, 1).endVertex();
+			buffer.pos(0.5, 0.5, -0.5).tex(1, 0).endVertex();
+
+			tessellator.draw();
+
+			GlStateManager.enableLighting();
+			GlStateManager.disableBlend();
+
+			GlStateManager.popMatrix();
+
+		}
+	}
+
+}

src/main/java/electroblob/wizardry/client/renderer/RenderShield.java

@@ -0,0 +1,168 @@
+package electroblob.wizardry.client.renderer;
+
+import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.data.WizardData;
+import electroblob.wizardry.registry.Spells;
+import electroblob.wizardry.spell.Shield;
+import electroblob.wizardry.util.WizardryUtilities;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.OpenGlHelper;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.Vec3d;
+import net.minecraftforge.client.event.RenderPlayerEvent;
+import net.minecraftforge.client.event.RenderWorldLastEvent;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.relauncher.Side;
+import org.lwjgl.opengl.GL11;
+
+@Mod.EventBusSubscriber(Side.CLIENT)
+public class RenderShield {
+
+	private static final ResourceLocation TEXTURE = new ResourceLocation(Wizardry.MODID, "textures/entity/shield.png");
+
+	// First person
+	@SubscribeEvent
+	public static void onRenderWorldLastEvent(RenderWorldLastEvent event){
+		// Only render in first person
+		if(Minecraft.getMinecraft().gameSettings.thirdPersonView == 0){
+
+			EntityPlayer player = Minecraft.getMinecraft().player;
+
+			if(WizardData.get(player).getVariable(Shield.SHIELD_KEY) != null && WizardryUtilities.isCasting(player, Spells.shield)){
+
+				GlStateManager.pushMatrix();
+
+				GlStateManager.disableCull();
+				GlStateManager.enableBlend();
+				GlStateManager.blendFunc(GL11.GL_ONE, GL11.GL_SRC_ALPHA);
+				GlStateManager.shadeModel(GL11.GL_SMOOTH);
+				GlStateManager.disableLighting();
+				OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, 240f, 240f);
+
+				GlStateManager.translate(0, 1.4, 0);
+
+				GlStateManager.rotate(-player.rotationYaw, 0, 1, 0);
+				GlStateManager.rotate(player.rotationPitch, 1, 0, 0);
+
+				GlStateManager.translate(0, 0, 0.8);
+
+				Tessellator tessellator = Tessellator.getInstance();
+
+				Minecraft.getMinecraft().renderEngine.bindTexture(TEXTURE);
+
+				render(tessellator);
+
+				GlStateManager.enableLighting();
+
+				GlStateManager.shadeModel(GL11.GL_FLAT);
+				GlStateManager.enableCull();
+				GlStateManager.disableBlend();
+				// RenderHelper.enableStandardItemLighting();
+
+				GlStateManager.popMatrix();
+			}
+		}
+	}
+
+	// Third person
+	@SubscribeEvent
+	public static void onRenderPlayerEvent(RenderPlayerEvent.Post event){
+
+		EntityPlayer player = event.getEntityPlayer();
+
+		if(WizardData.get(player).getVariable(Shield.SHIELD_KEY) != null && WizardryUtilities.isCasting(player, Spells.shield)){
+
+			GlStateManager.pushMatrix();
+
+			GlStateManager.disableCull();
+			GlStateManager.enableBlend();
+			// For some reason, the old blend function (GL11.GL_SRC_ALPHA, GL11.GL_SRC_ALPHA) caused the inner
+			// edges to appear black, so I have changed it to this, which looks very slightly different.
+			GlStateManager.blendFunc(GL11.GL_ONE, GL11.GL_SRC_ALPHA);
+			GlStateManager.shadeModel(GL11.GL_SMOOTH);
+			GlStateManager.disableLighting();
+			OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, 240f, 240f);
+
+			Vec3d delta = player.getPositionEyes(event.getPartialRenderTick())
+					.subtract(Minecraft.getMinecraft().player.getPositionEyes(event.getPartialRenderTick()));
+			GlStateManager.translate(delta.x, delta.y, delta.z);
+
+			GlStateManager.translate(0, 1.3, 0);
+
+			// GlStateManager.rotate(180, 0, 1, 0);
+			GlStateManager.rotate(-player.renderYawOffset, 0, 1, 0);
+			// GlStateManager.rotate(-player.rotationPitch, 1, 0, 0);
+
+			GlStateManager.translate(0, 0, 0.8);
+
+			Tessellator tessellator = Tessellator.getInstance();
+
+			Minecraft.getMinecraft().renderEngine.bindTexture(TEXTURE);
+
+			render(tessellator);
+
+			GlStateManager.enableLighting();
+
+			GlStateManager.shadeModel(GL11.GL_FLAT);
+			GlStateManager.enableCull();
+			GlStateManager.disableBlend();
+			// RenderHelper.enableStandardItemLighting();
+
+			GlStateManager.popMatrix();
+		}
+	}
+
+	private static void render(Tessellator tessellator){
+
+		BufferBuilder buffer = tessellator.getBuffer();
+
+		double widthOuter = 0.6d;
+		double heightOuter = 0.7d;
+		double widthInner = 0.3d;
+		double heightInner = 0.4d;
+		double depth = 0.2d;
+
+		buffer.begin(GL11.GL_TRIANGLE_STRIP, DefaultVertexFormats.POSITION_TEX_COLOR);
+
+		buffer.pos(-widthOuter, heightInner, -depth).tex(0, 0.2).color(0, 0, 0, 255).endVertex();
+		buffer.pos(-widthInner, heightInner, 0).tex(0.2, 0.2).color(200, 200, 255, 255).endVertex();
+		buffer.pos(-widthInner, heightOuter, -depth).tex(0.2, 0).color(0, 0, 0, 255).endVertex();
+		buffer.pos(-widthInner, heightInner, 0).tex(0.2, 0.2).color(200, 200, 255, 255).endVertex();
+
+		buffer.pos(widthInner, heightOuter, -depth).tex(0.8, 0).color(0, 0, 0, 255).endVertex();
+		buffer.pos(widthInner, heightInner, 0).tex(0.8, 0.2).color(200, 200, 255, 255).endVertex();
+		buffer.pos(widthOuter, heightInner, -depth).tex(1, 0.2).color(0, 0, 0, 255).endVertex();
+		buffer.pos(widthInner, heightInner, 0).tex(0.8, 0.2).color(200, 200, 255, 255).endVertex();
+
+		buffer.pos(widthOuter, -heightInner, -depth).tex(1, 0.8).color(0, 0, 0, 255).endVertex();
+		buffer.pos(widthInner, -heightInner, 0).tex(0.8, 0.8).color(200, 200, 255, 255).endVertex();
+		buffer.pos(widthInner, -heightOuter, -depth).tex(0.8, 1).color(0, 0, 0, 255).endVertex();
+		buffer.pos(widthInner, -heightInner, 0).tex(0.8, 0.8).color(200, 200, 255, 255).endVertex();
+
+		buffer.pos(-widthInner, -heightOuter, -depth).tex(0.2, 1).color(0, 0, 0, 255).endVertex();
+		buffer.pos(-widthInner, -heightInner, 0).tex(0.2, 0.8).color(200, 200, 255, 255).endVertex();
+		buffer.pos(-widthOuter, -heightInner, -depth).tex(0, 0.8).color(0, 0, 0, 255).endVertex();
+		buffer.pos(-widthInner, -heightInner, 0).tex(0.2, 0.8).color(200, 200, 255, 255).endVertex();
+
+		buffer.pos(-widthOuter, heightInner, -depth).tex(0, 0.2).color(0, 0, 0, 255).endVertex();
+		buffer.pos(-widthInner, heightInner, 0).tex(0.2, 0.2).color(200, 200, 255, 255).endVertex();
+
+		tessellator.draw();
+
+		buffer.begin(GL11.GL_TRIANGLE_STRIP, DefaultVertexFormats.POSITION_TEX_COLOR);
+
+		buffer.pos(-widthInner, heightInner, 0).tex(0.2, 0.2).color(200, 200, 255, 255).endVertex();
+		buffer.pos(widthInner, heightInner, 0).tex(0.8, 0.2).color(200, 200, 255, 255).endVertex();
+		buffer.pos(-widthInner, -heightInner, 0).tex(0.2, 0.8).color(200, 200, 255, 255).endVertex();
+		buffer.pos(widthInner, -heightInner, 0).tex(0.8, 0.8).color(200, 200, 255, 255).endVertex();
+
+		tessellator.draw();
+	}
+
+}

src/main/java/electroblob/wizardry/client/renderer/RenderSigil.java

@@ -1,10 +1,8 @@
 package electroblob.wizardry.client.renderer;
 
-import org.lwjgl.opengl.GL11;
-
 import electroblob.wizardry.entity.construct.EntityHealAura;
 import electroblob.wizardry.entity.construct.EntityMagicConstruct;
-import electroblob.wizardry.util.WizardryUtilities;
+import electroblob.wizardry.util.AllyDesignationSystem;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.BufferBuilder;
 import net.minecraft.client.renderer.GlStateManager;
@@ -15,6 +13,7 @@ import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.util.ResourceLocation;
+import org.lwjgl.opengl.GL11;
 
 public class RenderSigil extends Render<EntityMagicConstruct> {
 
@@ -34,8 +33,8 @@ public class RenderSigil extends Render<EntityMagicConstruct> {
 
 		// Makes the sigil invisible to enemies of the player that created it
 		if(this.invisibleToEnemies){
-
-			if(entity.getCaster() instanceof EntityPlayer && !WizardryUtilities
+			// Unfortunately we can't access the caster's allies if they're not online, it only works the other way round
+			if(entity.getCaster() instanceof EntityPlayer && !AllyDesignationSystem
 					.isPlayerAlly((EntityPlayer)entity.getCaster(), Minecraft.getMinecraft().player)){
 				return;
 			}

src/main/java/electroblob/wizardry/client/renderer/RenderSpiritHorse.java

@@ -1,22 +1,23 @@
 package electroblob.wizardry.client.renderer;
 
-import org.lwjgl.opengl.GL11;
-
 import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.entity.living.EntitySpiritHorse;
 import net.minecraft.client.renderer.GlStateManager;
 import net.minecraft.client.renderer.entity.RenderHorse;
 import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.entity.passive.EntityHorse;
 import net.minecraft.util.ResourceLocation;
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
+import org.lwjgl.opengl.GL11;
 
-@SideOnly(Side.CLIENT)
+//@SideOnly(Side.CLIENT)
 public class RenderSpiritHorse extends RenderHorse {
 
 	private static final ResourceLocation texture = new ResourceLocation(Wizardry.MODID,
 			"textures/entity/spirit_horse.png");
 
+//	private static final int GHOST_COPIES = 3;
+//	private static final float DECONVERGENCE = 0.35f;
+
 	public RenderSpiritHorse(RenderManager renderManager){
 		super(renderManager);
 	}
@@ -27,10 +28,36 @@ public class RenderSpiritHorse extends RenderHorse {
 	}
 
 	@Override
-	protected void preRenderCallback(EntityHorse entitylivingbaseIn, float partialTickTime){
-		super.preRenderCallback(entitylivingbaseIn, partialTickTime);
+	protected void preRenderCallback(EntityHorse horse, float partialTickTime){
+		super.preRenderCallback(horse, partialTickTime);
 		GlStateManager.enableBlend();
 		GlStateManager.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+		if(horse instanceof EntitySpiritHorse){ // Always true
+			GlStateManager.color(1, 1, 1, ((EntitySpiritHorse)horse).getOpacity());
+		}
+	}
+
+	@Override
+	public void doRender(EntityHorse entity, double x, double y, double z, float entityYaw, float partialTicks){
+
+		super.doRender(entity, x, y, z, entityYaw, partialTicks);
+
+//		double dx = (entity.posX - entity.prevPosX) * DECONVERGENCE;
+//		double dy = (entity.posY - entity.prevPosY) * DECONVERGENCE;
+//		double dz = (entity.posZ - entity.prevPosZ) * DECONVERGENCE;
+//		float dyaw = (entity.rotationYaw - entity.prevRotationYaw) * DECONVERGENCE;
+//
+//		float opacity = 1;
+//		if(entity instanceof EntitySpiritHorse){ // Always true
+//			opacity = ((EntitySpiritHorse)entity).getOpacity();
+//		}
+//
+//		for(int i = 0; i < GHOST_COPIES; i++){
+//
+//			GlStateManager.color(1, 1, 1, opacity * (0.6f - (float)i/(GHOST_COPIES*2)));
+//
+//			super.doRender(entity, x - dx * i, y - dy * i, z - dz * i, entityYaw - dyaw * i, partialTicks);
+//		}
 	}
 
 }

src/main/java/electroblob/wizardry/client/renderer/RenderSpiritWolf.java

@@ -1,22 +1,23 @@
 package electroblob.wizardry.client.renderer;
 
-import org.lwjgl.opengl.GL11;
-
 import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.entity.living.EntitySpiritWolf;
 import net.minecraft.client.renderer.GlStateManager;
 import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.client.renderer.entity.RenderWolf;
 import net.minecraft.entity.passive.EntityWolf;
 import net.minecraft.util.ResourceLocation;
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
+import org.lwjgl.opengl.GL11;
 
-@SideOnly(Side.CLIENT)
+//@SideOnly(Side.CLIENT)
 public class RenderSpiritWolf extends RenderWolf {
 
 	private static final ResourceLocation texture = new ResourceLocation(Wizardry.MODID,
 			"textures/entity/spirit_wolf.png");
 
+//	private static final int GHOST_COPIES = 3;
+//	private static final float DECONVERGENCE = 0.8f;
+
 	public RenderSpiritWolf(RenderManager renderManager){
 		super(renderManager);
 	}
@@ -31,5 +32,31 @@ public class RenderSpiritWolf extends RenderWolf {
 		super.preRenderCallback(entity, partialTickTime);
 		GlStateManager.enableBlend();
 		GlStateManager.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+		if(entity instanceof EntitySpiritWolf){ // Always true
+			GlStateManager.color(1, 1, 1, ((EntitySpiritWolf)entity).getOpacity());
+		}
+	}
+
+	@Override
+	public void doRender(EntityWolf entity, double x, double y, double z, float entityYaw, float partialTicks){
+
+		super.doRender(entity, x, y, z, entityYaw, partialTicks);
+
+//		double dx = (entity.posX - entity.prevPosX) * DECONVERGENCE;
+//		double dy = (entity.posY - entity.prevPosY) * DECONVERGENCE;
+//		double dz = (entity.posZ - entity.prevPosZ) * DECONVERGENCE;
+//		float dyaw = (entity.rotationYaw - entity.prevRotationYaw) * DECONVERGENCE;
+//
+//		float opacity = 1;
+//		if(entity instanceof EntitySpiritWolf){ // Always true
+//			opacity = ((EntitySpiritWolf)entity).getOpacity();
+//		}
+//
+//		for(int i = 0; i < GHOST_COPIES; i++){
+//
+//			GlStateManager.color(1, 1, 1, opacity * (0.6f - (float)i/(GHOST_COPIES*2)));
+//
+//			super.doRender(entity, x - dx * i, y - dy * i, z - dz * i, entityYaw - dyaw * i, partialTicks);
+//		}
 	}
 }

src/main/java/electroblob/wizardry/client/renderer/RenderStrayMinion.java

@@ -0,0 +1,24 @@
+package electroblob.wizardry.client.renderer;
+
+import net.minecraft.client.renderer.entity.RenderManager;
+import net.minecraft.client.renderer.entity.RenderSkeleton;
+import net.minecraft.entity.monster.AbstractSkeleton;
+import net.minecraft.util.ResourceLocation;
+
+/** This class also had to be copied for the same reason as {@link LayerStrayMinionClothing}. */
+public class RenderStrayMinion extends RenderSkeleton {
+
+	private static final ResourceLocation STRAY_SKELETON_TEXTURES = new ResourceLocation("textures/entity/skeleton/stray.png");
+
+	public RenderStrayMinion(RenderManager manager){
+		super(manager);
+		this.addLayer(new LayerStrayMinionClothing(this)); // This is the only change
+	}
+
+	/**
+	 * Returns the location of an entity's texture. Doesn't seem to be called unless you call Render.bindEntityTexture.
+	 */
+	protected ResourceLocation getEntityTexture(AbstractSkeleton entity){
+		return STRAY_SKELETON_TEXTURES;
+	}
+}

src/main/java/electroblob/wizardry/client/renderer/RenderTransportationUI.java

@@ -0,0 +1,177 @@
+package electroblob.wizardry.client.renderer;
+
+import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.data.WizardData;
+import electroblob.wizardry.item.ISpellCastingItem;
+import electroblob.wizardry.item.ItemArtefact;
+import electroblob.wizardry.registry.Spells;
+import electroblob.wizardry.registry.WizardryItems;
+import electroblob.wizardry.spell.Transportation;
+import electroblob.wizardry.util.Location;
+import electroblob.wizardry.util.WizardryUtilities;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.FontRenderer;
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.OpenGlHelper;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.Vec3d;
+import net.minecraftforge.client.event.RenderWorldLastEvent;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.relauncher.Side;
+import org.lwjgl.opengl.GL11;
+
+import java.util.List;
+
+@Mod.EventBusSubscriber(Side.CLIENT)
+public class RenderTransportationUI {
+
+	private static final ResourceLocation TEXTURE = new ResourceLocation(Wizardry.MODID, "textures/gui/transportation_marker.png");
+
+	// I can't get rid of the view bobbing with RenderWorldLastEvent, is there an alternative?
+	@SubscribeEvent
+	public static void onRenderWorldLastEvent(RenderWorldLastEvent event){
+
+		// Only render in first person
+		if(Minecraft.getMinecraft().gameSettings.thirdPersonView != 0) return;
+
+		EntityPlayer player = Minecraft.getMinecraft().player;
+
+		ItemStack stack = player.getHeldItemMainhand();
+		if(!(stack.getItem() instanceof ISpellCastingItem)){
+			stack = player.getHeldItemOffhand();
+			if(!(stack.getItem() instanceof ISpellCastingItem)) return;
+		}
+
+		if(((ISpellCastingItem)stack.getItem()).getCurrentSpell(stack) == Spells.transportation
+				&& ItemArtefact.isArtefactActive(player, WizardryItems.charm_transportation)){
+
+			WizardData data = WizardData.get(player);
+			if(data == null) return;
+
+			List<Location> locations = data.getVariable(Transportation.LOCATIONS_KEY);
+
+			if(locations == null) return;
+
+			GlStateManager.pushMatrix();
+
+			Vec3d origin = player.getPositionEyes(event.getPartialTicks());
+			GlStateManager.translate(0, origin.y - Minecraft.getMinecraft().getRenderManager().viewerPosY, 0);
+
+			Tessellator tessellator = Tessellator.getInstance();
+			BufferBuilder buffer = tessellator.getBuffer();
+
+			Location target = Transportation.getLocationAimedAt(player, locations, event.getPartialTicks());
+
+			for(Location location : locations){
+
+				if(location.dimension != player.dimension) continue;
+
+				GlStateManager.pushMatrix();
+				GlStateManager.enableBlend();
+				GlStateManager.disableLighting();
+				GlStateManager.disableDepth();
+				OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, 240, 240);
+				GlStateManager.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+				GlStateManager.color(1, 1, 1, 1);
+
+				Minecraft.getMinecraft().renderEngine.bindTexture(TEXTURE);
+
+				buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX_COLOR);
+
+				Vec3d position = WizardryUtilities.getCentre(location.pos).subtract(origin);
+				double distance = position.length();
+				// The icon lines up perfectly if you render it at actual distance, otherwise view bobbing messes things up
+				// However, if that's outside the render distance it won't render at all! To fudge our way around this
+				// problem, we're capping the distance to just below the render distance and adjusting the scale accordingly
+				double distanceCap = Minecraft.getMinecraft().gameSettings.renderDistanceChunks * 16 - 8;
+				double displayDist = distance > distanceCap ? distanceCap : distance;
+				double factor = displayDist/distance;
+
+				GlStateManager.translate(position.x * factor, position.y * factor, position.z * factor);
+
+				GlStateManager.rotate(-Minecraft.getMinecraft().getRenderManager().playerViewY, 0.0F, 1.0F, 0.0F);
+				GlStateManager.rotate(Minecraft.getMinecraft().getRenderManager().playerViewX, 1.0F, 0.0F, 0.0F);
+
+				// Get the angle between the player's look vector and the direction of the stone circle
+				double angle = Transportation.getLookDeviationAngle(player, location.pos, event.getPartialTicks());
+				double iconSize = Transportation.getIconSize(distance);
+
+				// Now apply a fancy formula to make it enlarge with a nice smooth animation:
+				double proximityFactor = Math.max(0, Math.pow(1 - angle/iconSize * angle/iconSize, 3));
+				iconSize *= 1 + 0.3 * proximityFactor;
+				iconSize *= displayDist; // Adjust the icon size for perspective
+
+				float f = location == target ? 1 : 0.5f; // Makes it obvious which one is being aimed at
+
+				buffer.pos(-iconSize, iconSize, 0).tex(0, 0).color(f, 1, f, f).endVertex();
+				buffer.pos(iconSize, iconSize, 0).tex(1, 0).color(f, 1, f, f).endVertex();
+				buffer.pos(iconSize, -iconSize, 0).tex(1, 1).color(f, 1, f, f).endVertex();
+				buffer.pos(-iconSize, -iconSize, 0).tex(0, 1).color(f, 1, f, f).endVertex();
+
+				tessellator.draw();
+
+				GlStateManager.popMatrix();
+
+				if(location == target){
+					String label = location.pos.getX() + ", " + location.pos.getY() + ", " + location.pos.getZ();
+					drawLabel(Minecraft.getMinecraft().fontRenderer, label, (float)(position.x * factor),
+							(float)(position.y * factor + iconSize*1.5f), (float)(position.z * factor), (float)displayDist * 0.2f, 0,
+							Minecraft.getMinecraft().getRenderManager().playerViewY, Minecraft.getMinecraft().getRenderManager().playerViewX);
+				}
+			}
+
+			GlStateManager.disableBlend();
+			GlStateManager.enableTexture2D();
+			GlStateManager.enableLighting();
+			GlStateManager.enableDepth();
+			GlStateManager.disableRescaleNormal();
+			GlStateManager.popMatrix();
+		}
+	}
+
+	// Copied from EntityRenderer#drawNameplate and tweaked a bit
+	private static void drawLabel(FontRenderer fontRendererIn, String str, float x, float y, float z, float scale, int verticalShift, float viewerYaw, float viewerPitch){
+
+		GlStateManager.pushMatrix();
+		GlStateManager.translate(x, y, z);
+		GlStateManager.glNormal3f(0.0F, 1.0F, 0.0F);
+		GlStateManager.rotate(-viewerYaw, 0.0F, 1.0F, 0.0F);
+		GlStateManager.rotate(viewerPitch, 1.0F, 0.0F, 0.0F);
+		GlStateManager.scale(-0.025F, -0.025F, 0.025F);
+		GlStateManager.scale(scale, scale, scale);
+		GlStateManager.disableLighting();
+		GlStateManager.depthMask(false);
+
+		GlStateManager.disableDepth();
+
+		GlStateManager.enableBlend();
+		GlStateManager.tryBlendFuncSeparate(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA, GlStateManager.SourceFactor.ONE, GlStateManager.DestFactor.ZERO);
+		int i = fontRendererIn.getStringWidth(str) / 2;
+		GlStateManager.disableTexture2D();
+		Tessellator tessellator = Tessellator.getInstance();
+		BufferBuilder bufferbuilder = tessellator.getBuffer();
+		bufferbuilder.begin(7, DefaultVertexFormats.POSITION_COLOR);
+		bufferbuilder.pos((double)(-i - 1), (double)(-1 + verticalShift), 0.0D).color(0.0F, 0.0F, 0.0F, 0.25F).endVertex();
+		bufferbuilder.pos((double)(-i - 1), (double)(8 + verticalShift), 0.0D).color(0.0F, 0.0F, 0.0F, 0.25F).endVertex();
+		bufferbuilder.pos((double)(i + 1), (double)(8 + verticalShift), 0.0D).color(0.0F, 0.0F, 0.0F, 0.25F).endVertex();
+		bufferbuilder.pos((double)(i + 1), (double)(-1 + verticalShift), 0.0D).color(0.0F, 0.0F, 0.0F, 0.25F).endVertex();
+		tessellator.draw();
+		GlStateManager.enableTexture2D();
+
+		fontRendererIn.drawString(str, -fontRendererIn.getStringWidth(str) / 2, verticalShift, 0x86ff65);
+		GlStateManager.enableDepth();
+
+		GlStateManager.depthMask(true);
+		fontRendererIn.drawString(str, -fontRendererIn.getStringWidth(str) / 2, verticalShift, 0x86ff65);
+		GlStateManager.enableLighting();
+		GlStateManager.disableBlend();
+		GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
+		GlStateManager.popMatrix();
+	}
+}

src/main/java/electroblob/wizardry/client/renderer/RenderWings.java

@@ -0,0 +1,113 @@
+package electroblob.wizardry.client.renderer;
+
+import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.registry.Spells;
+import electroblob.wizardry.util.WizardryUtilities;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.OpenGlHelper;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.MathHelper;
+import net.minecraft.util.math.Vec3d;
+import net.minecraftforge.client.event.RenderPlayerEvent;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.relauncher.Side;
+import org.lwjgl.opengl.GL11;
+
+@Mod.EventBusSubscriber(Side.CLIENT)
+public class RenderWings {
+
+	private static final ResourceLocation TEXTURE = new ResourceLocation(Wizardry.MODID, "textures/entity/wing.png");
+
+	// No first person in here because you can never see the wings on your back!
+
+	// Third person
+	@SubscribeEvent
+	public static void onRenderPlayerEvent(RenderPlayerEvent.Post event){
+
+		EntityPlayer player = event.getEntityPlayer();
+
+		if(WizardryUtilities.isCasting(player, Spells.flight)){
+
+			GlStateManager.pushMatrix();
+
+			GlStateManager.enableBlend();
+			GlStateManager.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+			GlStateManager.disableLighting();
+			OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, 240f, 240f);
+
+			Vec3d delta = player.getPositionEyes(event.getPartialRenderTick())
+					.subtract(Minecraft.getMinecraft().player.getPositionEyes(event.getPartialRenderTick()));
+			GlStateManager.translate(delta.x, delta.y, delta.z);
+
+			// GlStateManager.rotate(-entityplayer.rotationYawHead, 0, 1, 0);
+			GlStateManager.rotate(-player.renderYawOffset, 0, 1, 0);
+			// GlStateManager.rotate(180, 1, 0, 0);
+
+			Minecraft.getMinecraft().renderEngine.bindTexture(TEXTURE);
+			Tessellator tessellator = Tessellator.getInstance();
+			BufferBuilder buffer = tessellator.getBuffer();
+
+			GlStateManager.pushMatrix();
+
+			GlStateManager.translate(0.1, 0.4, -0.15);
+			GlStateManager.rotate(20 + 20 * MathHelper.sin((player.ticksExisted + event.getPartialRenderTick()) * 0.3f), 0, 1, 0);
+
+			buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX);
+
+			buffer.pos(0, 2, 0).tex(0, 0).endVertex();
+			buffer.pos(2, 2, 0).tex(1, 0).endVertex();
+			buffer.pos(2, 0, 0).tex(1, 1).endVertex();
+			buffer.pos(0, 0, 0).tex(0, 1).endVertex();
+
+			tessellator.draw();
+
+			buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX);
+
+			buffer.pos(0, 2, 0).tex(0, 0).endVertex();
+			buffer.pos(0, 0, 0).tex(0, 1).endVertex();
+			buffer.pos(2, 0, 0).tex(1, 1).endVertex();
+			buffer.pos(2, 2, 0).tex(1, 0).endVertex();
+
+			tessellator.draw();
+
+			GlStateManager.popMatrix();
+
+			GlStateManager.pushMatrix();
+
+			GlStateManager.translate(-0.1, 0.4, -0.15);
+			GlStateManager.rotate(-200 - 20 * MathHelper.sin((player.ticksExisted + event.getPartialRenderTick()) * 0.3f), 0, 1, 0);
+
+			buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX);
+
+			buffer.pos(0, 2, 0).tex(0, 0).endVertex();
+			buffer.pos(2, 2, 0).tex(1, 0).endVertex();
+			buffer.pos(2, 0, 0).tex(1, 1).endVertex();
+			buffer.pos(0, 0, 0).tex(0, 1).endVertex();
+
+			tessellator.draw();
+
+			buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX);
+
+			buffer.pos(0, 2, 0).tex(0, 0).endVertex();
+			buffer.pos(0, 0, 0).tex(0, 1).endVertex();
+			buffer.pos(2, 0, 0).tex(1, 1).endVertex();
+			buffer.pos(2, 2, 0).tex(1, 0).endVertex();
+
+			tessellator.draw();
+
+			GlStateManager.popMatrix();
+
+			GlStateManager.enableLighting();
+			GlStateManager.disableBlend();
+
+			GlStateManager.popMatrix();
+		}
+	}
+
+}

src/main/java/electroblob/wizardry/client/renderer/RenderWizard.java

@@ -7,10 +7,8 @@ import net.minecraft.client.renderer.entity.RenderBiped;
 import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.client.renderer.entity.layers.LayerBipedArmor;
 import net.minecraft.util.ResourceLocation;
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
 
-@SideOnly(Side.CLIENT)
+//@SideOnly(Side.CLIENT)
 public class RenderWizard extends RenderBiped<EntityWizard> {
 
 	static final ResourceLocation[] textures = new ResourceLocation[6];

src/main/java/electroblob/wizardry/client/renderer/RenderWraithMinion.java

@@ -5,10 +5,8 @@ import net.minecraft.client.model.ModelBlaze;
 import net.minecraft.client.renderer.entity.RenderLiving;
 import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.util.ResourceLocation;
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
 
-@SideOnly(Side.CLIENT)
+//@SideOnly(Side.CLIENT)
 public class RenderWraithMinion extends RenderLiving<EntityBlazeMinion> {
 	private ResourceLocation texture = new ResourceLocation("textures/entity/blaze.png");