Basic sigils implementation

src/main/java/WayofTime/bloodmagic/altar/BloodAltar.java

@@ -527,6 +527,18 @@ public class BloodAltar {
         return dislocationMultiplier;
     }
 
+    public float getConsumptionMultiplier() {
+        return consumptionMultiplier;
+    }
+
+    public float getConsumptionRate() {
+        return consumptionRate;
+    }
+
+    public int getLiquidRequired() {
+        return liquidRequired;
+    }
+
     public int getBufferCapacity() {
         return bufferCapacity;
     }

src/main/java/WayofTime/bloodmagic/api/Constants.java

@@ -52,6 +52,13 @@ public class Constants {
         public static final String ALTAR_COOLDOWN_AFTER_CRAFTING = "cooldownAfterCrafting";
 
         public static final String ALTARMAKER_CURRENT_TIER = "currentTier";
+
+        public static final String PROJECTILE_TICKS_IN_AIR = "projectileTicksInAir";
+        public static final String PROJECTILE_MAX_TICKS_IN_AIR = "projectileMaxTicksInAir";
+
+        public static final String TICKS_REMAINING = "ticksRemaining";
+        public static final String CONTAINED_BLOCK_NAME = "containedBlockName";
+        public static final String CONTAINED_BLOCK_META = "containedBlockMeta";
     }
 
     public static class Mod {

src/main/java/WayofTime/bloodmagic/api/altar/IBloodAltar.java

@@ -18,6 +18,12 @@ public interface IBloodAltar {
 
     float getDislocationMultiplier();
 
+    float getConsumptionMultiplier();
+
+    float getConsumptionRate();
+
+    int getLiquidRequired();
+
     int getBufferCapacity();
 
     void sacrificialDaggerCall(int amount, boolean b);

src/main/java/WayofTime/bloodmagic/api/util/helper/BindableHelper.java

@@ -48,7 +48,7 @@ public class BindableHelper {
             return true;
         }
 
-        return false;
+        return true;
     }
 
     /**

src/main/java/WayofTime/bloodmagic/block/BlockBloodLight.java

@@ -69,7 +69,7 @@ public class BlockBloodLight extends Block {
             float f1 = f * 0.6F + 0.4F;
             float f2 = f * f * 0.7F - 0.5F;
             float f3 = f * f * 0.6F - 0.7F;
-            worldIn.spawnParticle(EnumParticleTypes.REDSTONE, pos.getX() + 0.5D + rand.nextGaussian() / 8, pos.getY() + 0.5D, pos.getZ() + 0.5D + rand.nextGaussian() / 8, f1, f2, f3);
+            worldIn.spawnParticle(EnumParticleTypes.REDSTONE, pos.getX() + 0.5D + rand.nextGaussian() / 8, pos.getY() + 0.5D, pos.getZ() + 0.5D + rand.nextGaussian() / 8, f1, f2, f3, 0);
         }
     }
 

src/main/java/WayofTime/bloodmagic/block/BlockPhantom.java

@@ -0,0 +1,66 @@
+package WayofTime.bloodmagic.block;
+
+import WayofTime.bloodmagic.api.Constants;
+import WayofTime.bloodmagic.tile.TilePhantomBlock;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.BlockPos;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.EnumWorldBlockLayer;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import java.util.Random;
+
+public class BlockPhantom extends BlockContainer {
+
+    public BlockPhantom() {
+        super(Material.cloth);
+
+        setUnlocalizedName(Constants.Mod.MODID + ".phantom");
+    }
+
+    @Override
+    public boolean isOpaqueCube() {
+        return false;
+    }
+
+    @Override
+    public boolean isFullCube() {
+        return false;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public EnumWorldBlockLayer getBlockLayer() {
+        return EnumWorldBlockLayer.CUTOUT;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public boolean shouldSideBeRendered(IBlockAccess worldIn, BlockPos pos, EnumFacing side) {
+        IBlockState iblockstate = worldIn.getBlockState(pos);
+        Block block = iblockstate.getBlock();
+
+        if (worldIn.getBlockState(pos.offset(side.getOpposite())) != iblockstate) {
+            return true;
+        }
+
+        return block != this && super.shouldSideBeRendered(worldIn, pos, side);
+    }
+
+    @Override
+    public int quantityDropped(Random par1Random) {
+        return 0;
+    }
+
+    @Override
+    public TileEntity createNewTileEntity(World world, int meta) {
+        return new TilePhantomBlock();
+    }
+}

src/main/java/WayofTime/bloodmagic/block/BlockSpectral.java

@@ -0,0 +1,69 @@
+package WayofTime.bloodmagic.block;
+
+import WayofTime.bloodmagic.api.Constants;
+import WayofTime.bloodmagic.tile.TileSpectralBlock;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.Entity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.BlockPos;
+import net.minecraft.util.EnumWorldBlockLayer;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import java.util.List;
+import java.util.Random;
+
+public class BlockSpectral extends BlockContainer {
+
+    public BlockSpectral() {
+        super(Material.cloth);
+
+        setUnlocalizedName(Constants.Mod.MODID + ".spectral");
+        setBlockBounds(0, 0, 0, 0, 0, 0);
+    }
+
+    @Override
+    public boolean isOpaqueCube() {
+        return false;
+    }
+
+    @Override
+    public boolean isFullCube() {
+        return false;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public EnumWorldBlockLayer getBlockLayer() {
+        return EnumWorldBlockLayer.CUTOUT;
+    }
+
+    @Override
+    public void addCollisionBoxesToList(World worldIn, BlockPos pos, IBlockState state, AxisAlignedBB mask, List list, Entity collidingEntity) {
+    }
+
+    @Override
+    public int quantityDropped(Random par1Random) {
+        return 0;
+    }
+
+    @Override
+    public boolean isReplaceable(World world, BlockPos blockPos) {
+        return true;
+    }
+
+    @Override
+    public boolean isAir(IBlockAccess world, BlockPos blockPos) {
+        return true;
+    }
+
+    @Override
+    public TileEntity createNewTileEntity(World world, int meta) {
+        return new TileSpectralBlock();
+    }
+}

src/main/java/WayofTime/bloodmagic/entity/projectile/EntityBloodLight.java

@@ -0,0 +1,174 @@
+package WayofTime.bloodmagic.entity.projectile;
+
+import WayofTime.bloodmagic.api.Constants;
+import WayofTime.bloodmagic.registry.ModBlocks;
+import io.netty.buffer.ByteBuf;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.projectile.EntityThrowable;
+import net.minecraft.init.Blocks;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.*;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.common.registry.IEntityAdditionalSpawnData;
+import net.minecraftforge.fml.common.registry.IThrowableEntity;
+
+public class EntityBloodLight extends EntityThrowable implements IThrowableEntity, IEntityAdditionalSpawnData {
+
+    public EntityLivingBase shootingEntity;
+    protected int ticksInAir = 0;
+    protected int maxTicksInAir = 600;
+
+    public EntityBloodLight(World world) {
+        super(world);
+        this.setSize(0.5F, 0.5F);
+    }
+
+    public EntityBloodLight(World world, double x, double y, double z) {
+        super(world);
+        this.setSize(0.5F, 0.5F);
+        this.setPosition(x, y, z);
+    }
+
+    public EntityBloodLight(World world, EntityLivingBase player) {
+        super(world, player);
+        shootingEntity = player;
+        float par3 = 0.8F;
+        this.setSize(0.5F, 0.5F);
+        this.setLocationAndAngles(player.posX, player.posY + player.getEyeHeight(), player.posZ, player.rotationYaw, player.rotationPitch);
+        posX -= MathHelper.cos(rotationYaw / 180.0F * (float) Math.PI) * 0.16F;
+        posY -= 0.2D;
+        posZ -= MathHelper.sin(rotationYaw / 180.0F * (float) Math.PI) * 0.16F;
+        this.setPosition(posX, posY, posZ);
+        motionX = -MathHelper.sin(rotationYaw / 180.0F * (float) Math.PI) * MathHelper.cos(rotationPitch / 180.0F * (float) Math.PI);
+        motionZ = MathHelper.cos(rotationYaw / 180.0F * (float) Math.PI) * MathHelper.cos(rotationPitch / 180.0F * (float) Math.PI);
+        motionY = -MathHelper.sin(rotationPitch / 180.0F * (float) Math.PI);
+        this.setThrowableHeading(motionX, motionY, motionZ, par3 * 1.5F, 1.0F);
+    }
+
+    @Override
+    protected float getGravityVelocity() {
+        return 0F;
+    }
+
+    @Override
+    protected float getVelocity() {
+        return 1F;
+    }
+
+    @Override
+    public void setThrowableHeading(double var1, double var3, double var5, float var7, float var8) {
+        float var9 = MathHelper.sqrt_double(var1 * var1 + var3 * var3 + var5 * var5);
+        var1 /= var9;
+        var3 /= var9;
+        var5 /= var9;
+        var1 += rand.nextGaussian() * 0.007499999832361937D * var8;
+        var3 += rand.nextGaussian() * 0.007499999832361937D * var8;
+        var5 += rand.nextGaussian() * 0.007499999832361937D * var8;
+        var1 *= var7;
+        var3 *= var7;
+        var5 *= var7;
+        motionX = var1;
+        motionY = var3;
+        motionZ = var5;
+        float var10 = MathHelper.sqrt_double(var1 * var1 + var5 * var5);
+        prevRotationYaw = rotationYaw = (float) (Math.atan2(var1, var5) * 180.0D / Math.PI);
+        prevRotationPitch = rotationPitch = (float) (Math.atan2(var3, var10) * 180.0D / Math.PI);
+    }
+
+    @Override
+    public void onUpdate() {
+        super.onUpdate();
+        if (this.ticksExisted > this.maxTicksInAir) {
+            setDead();
+        }
+    }
+
+    @Override
+    protected void onImpact(MovingObjectPosition mop) {
+        if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.ENTITY && mop.entityHit != null) {
+            if (mop.entityHit == shootingEntity) {
+                return;
+            }
+
+            this.onImpact(mop.entityHit);
+        }
+        else if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK) {
+            EnumFacing sideHit = mop.sideHit;
+            BlockPos blockPos = mop.getBlockPos().offset(sideHit);
+
+            if (worldObj.isAirBlock(blockPos)) {
+                worldObj.setBlockState(blockPos, ModBlocks.bloodLight.getDefaultState());
+            }
+        }
+
+        this.setDead();
+    }
+
+    protected void onImpact(Entity mop) {
+        if (mop == shootingEntity && ticksInAir > 3) {
+            shootingEntity.attackEntityFrom(DamageSource.causeMobDamage(shootingEntity), 1);
+            this.setDead();
+        }
+        else {
+            if (mop instanceof EntityLivingBase) {
+                ((EntityLivingBase) mop).setRevengeTarget(shootingEntity);
+                doDamage(1, mop);
+            }
+        }
+
+        if (worldObj.isAirBlock(new BlockPos((int) this.posX, (int) this.posY, (int) this.posZ))) {
+            worldObj.setBlockState(new BlockPos((int) this.posX, (int) this.posY, (int) this.posZ), Blocks.fire.getDefaultState());
+        }
+
+//        spawnHitParticles("magicCrit", 8);
+        this.setDead();
+    }
+
+    protected void doDamage(int i, Entity mop) {
+        mop.attackEntityFrom(this.getDamageSource(), i);
+    }
+
+    public DamageSource getDamageSource() {
+        return DamageSource.causeMobDamage(shootingEntity);
+    }
+
+    @Override
+    public void writeSpawnData(ByteBuf data) {
+        data.writeByte(this.ticksInAir);
+    }
+
+    @Override
+    public void readSpawnData(ByteBuf data) {
+        this.ticksInAir = data.readByte();
+    }
+
+    @Override
+    public void writeEntityToNBT(NBTTagCompound nbt) {
+        super.writeEntityToNBT(nbt);
+        nbt.setInteger(Constants.NBT.PROJECTILE_TICKS_IN_AIR, ticksInAir);
+        nbt.setInteger(Constants.NBT.PROJECTILE_MAX_TICKS_IN_AIR, maxTicksInAir);
+    }
+
+    @Override
+    public void readEntityFromNBT(NBTTagCompound nbt) {
+        super.readEntityFromNBT(nbt);
+        ticksInAir = nbt.getInteger(Constants.NBT.PROJECTILE_TICKS_IN_AIR);
+        maxTicksInAir = nbt.getInteger(Constants.NBT.PROJECTILE_MAX_TICKS_IN_AIR);
+    }
+
+    @Override
+    protected boolean canTriggerWalking() {
+        return false;
+    }
+
+    @Override
+    public boolean canBeCollidedWith() {
+        return false;
+    }
+
+    @Override
+    public void setThrower(Entity entity) {
+        if (entity instanceof EntityLivingBase) this.shootingEntity = (EntityLivingBase) entity;
+    }
+}

src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilBloodLight.java

@@ -0,0 +1,42 @@
+package WayofTime.bloodmagic.item.sigil;
+
+import WayofTime.bloodmagic.api.util.helper.BindableHelper;
+import WayofTime.bloodmagic.entity.projectile.EntityBloodLight;
+import WayofTime.bloodmagic.item.ItemBindable;
+import WayofTime.bloodmagic.registry.ModBlocks;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.BlockPos;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.world.World;
+import org.lwjgl.Sys;
+
+public class ItemSigilBloodLight extends ItemSigilBase {
+
+    public ItemSigilBloodLight() {
+        super("bloodLight", 10);
+    }
+
+    @Override
+    public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player) {
+        if (BindableHelper.checkAndSetItemOwner(stack, player) && ItemBindable.syphonBatteries(stack, player, getEnergyUsed() * 5) && !world.isRemote)
+            world.spawnEntityInWorld(new EntityBloodLight(world, player));
+
+        return stack;
+    }
+
+    @Override
+    public boolean onItemUseFirst(ItemStack stack, EntityPlayer player, World world, BlockPos blockPos, EnumFacing side, float hitX, float hitY, float hitZ) {
+        if (world.isRemote) return false;
+
+        if (BindableHelper.checkAndSetItemOwner(stack, player) && ItemBindable.syphonBatteries(stack, player, getEnergyUsed())) {
+            BlockPos newPos = blockPos.offset(side);
+
+            if (world.isAirBlock(newPos)) {
+                world.setBlockState(newPos, ModBlocks.bloodLight.getDefaultState());
+            }
+        }
+
+        return true;
+    }
+}

src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilCompression.java

@@ -0,0 +1,4 @@
+package WayofTime.bloodmagic.item.sigil;
+
+public class ItemSigilCompression {
+}

src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilDivination.java

@@ -16,7 +16,7 @@ import net.minecraft.util.ChatComponentText;
 import net.minecraft.util.MovingObjectPosition;
 import net.minecraft.world.World;
 
-public class ItemSigilDivination extends ItemSigilBase implements ISigil, IAltarReader {
+public class ItemSigilDivination extends ItemSigilBase implements IAltarReader {
 
     public ItemSigilDivination() {
         super("divination");

src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilElementalAffinity.java

@@ -0,0 +1,22 @@
+package WayofTime.bloodmagic.item.sigil;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.world.World;
+
+public class ItemSigilElementalAffinity extends ItemSigilToggleable {
+
+    public ItemSigilElementalAffinity() {
+        super("elementalAffinity", 200);
+    }
+
+    @Override
+    public void onSigilUpdate(ItemStack stack, World world, EntityPlayer player, int itemSlot, boolean isSelected) {
+        player.fallDistance = 0;
+        player.extinguish();
+        player.addPotionEffect(new PotionEffect(Potion.fireResistance.id, 2, 1, true, false));
+        player.addPotionEffect(new PotionEffect(Potion.waterBreathing.id, 2, 0, true, false));
+    }
+}

src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilEnderSeverance.java

@@ -0,0 +1,4 @@
+package WayofTime.bloodmagic.item.sigil;
+
+public class ItemSigilEnderSeverance {
+}

src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilFastMiner.java

@@ -0,0 +1,19 @@
+package WayofTime.bloodmagic.item.sigil;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.world.World;
+
+public class ItemSigilFastMiner extends ItemSigilToggleable {
+
+    public ItemSigilFastMiner() {
+        super("fastMiner", 100);
+    }
+
+    @Override
+    public void onSigilUpdate(ItemStack stack, World world, EntityPlayer player, int itemSlot, boolean isSelected) {
+        player.addPotionEffect(new PotionEffect(Potion.digSpeed.id, 2, 0, true, false));
+    }
+}

src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilGreenGrove.java

@@ -0,0 +1,81 @@
+package WayofTime.bloodmagic.item.sigil;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.IGrowable;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.BlockPos;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.world.World;
+import net.minecraftforge.common.IPlantable;
+
+public class ItemSigilGreenGrove extends ItemSigilToggleable {
+
+    public ItemSigilGreenGrove() {
+        super("greenGrove", 150);
+    }
+
+    @Override
+    public boolean onSigilUseFirst(ItemStack stack, EntityPlayer player, World world, BlockPos blockPos, EnumFacing side, float hitX, float hitY, float hitZ) {
+        if (applyBonemeal(stack, world, blockPos)) {
+            world.playAuxSFX(2005, blockPos, 0);
+            return true;
+        }
+
+        return false;
+    }
+
+    @Override
+    public void onSigilUpdate(ItemStack stack, World worldIn, EntityPlayer player, int itemSlot, boolean isSelected) {
+        int range = 3;
+        int verticalRange = 2;
+        int posX = (int) Math.round(player.posX - 0.5f);
+        int posY = (int) player.posY;
+        int posZ = (int) Math.round(player.posZ - 0.5f);
+
+        for (int ix = posX - range; ix <= posX + range; ix++) {
+            for (int iz = posZ - range; iz <= posZ + range; iz++) {
+                for (int iy = posY - verticalRange; iy <= posY + verticalRange; iy++) {
+                    BlockPos blockPos = new BlockPos(ix, iy, iz);
+                    Block block = worldIn.getBlockState(blockPos).getBlock();
+
+                    if (block instanceof IPlantable || block instanceof IGrowable) {
+                        if (worldIn.rand.nextInt(50) == 0) {
+                            IBlockState preBlockState = worldIn.getBlockState(blockPos);
+                            block.updateTick(worldIn, blockPos, worldIn.getBlockState(blockPos), worldIn.rand);
+
+                            if (!worldIn.getBlockState(blockPos).equals(preBlockState))
+                                worldIn.playAuxSFX(2005, blockPos, 0);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private boolean applyBonemeal(ItemStack stack, World worldIn, BlockPos target) {
+        return worldIn instanceof net.minecraft.world.WorldServer && applyBonemeal(stack, worldIn, target, net.minecraftforge.common.util.FakePlayerFactory.getMinecraft((net.minecraft.world.WorldServer) worldIn));
+    }
+
+    private boolean applyBonemeal(ItemStack stack, World worldIn, BlockPos target, EntityPlayer player) {
+        IBlockState iblockstate = worldIn.getBlockState(target);
+
+        int hook = net.minecraftforge.event.ForgeEventFactory.onApplyBonemeal(player, worldIn, target, iblockstate, stack);
+        if (hook != 0) return hook > 0;
+
+        if (iblockstate.getBlock() instanceof IGrowable) {
+            IGrowable igrowable = (IGrowable) iblockstate.getBlock();
+
+            if (igrowable.canGrow(worldIn, target, iblockstate, worldIn.isRemote)) {
+                if (!worldIn.isRemote) {
+                    if (igrowable.canUseBonemeal(worldIn, worldIn.rand, target, iblockstate))
+                        igrowable.grow(worldIn, worldIn.rand, target, iblockstate);
+                }
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilHaste.java

@@ -0,0 +1,19 @@
+package WayofTime.bloodmagic.item.sigil;
+
+import WayofTime.bloodmagic.registry.ModPotions;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.world.World;
+
+public class ItemSigilHaste extends ItemSigilToggleable {
+
+    public ItemSigilHaste() {
+        super("haste", 250);
+    }
+
+    @Override
+    public void onSigilUpdate(ItemStack stack, World world, EntityPlayer player, int itemSlot, boolean isSelected) {
+        player.addPotionEffect(new PotionEffect(ModPotions.boost.id, 2, 0, true, false));
+    }
+}

src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilHurricane.java

@@ -0,0 +1,4 @@
+package WayofTime.bloodmagic.item.sigil;
+
+public class ItemSigilHurricane {
+}

src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilLava.java

@@ -23,7 +23,7 @@ public class ItemSigilLava extends ItemSigilBase {
     @Override
     public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player) {
         if (!world.isRemote && !isUnusable(stack)) {
-            MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(world, player, true);
+            MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(world, player, false);
 
             if (movingobjectposition != null) {
                 ItemStack ret = net.minecraftforge.event.ForgeEventFactory.onBucketUse(player, world, stack, movingobjectposition);
@@ -47,12 +47,10 @@ public class ItemSigilLava extends ItemSigilBase {
                         return stack;
                     }
 
-                    if (this.canPlaceLava(world, blockpos1) && syphonBatteries(stack, player, getEnergyUsed())) {
-                        this.tryPlaceLava(world, blockpos1);
+                    if (this.canPlaceLava(world, blockpos1) && syphonBatteries(stack, player, getEnergyUsed()) && this.tryPlaceLava(world, blockpos1)) {
+                        return stack;
                     }
                 }
-            } else {
-                return stack;
             }
 
             if (!player.capabilities.isCreativeMode)
@@ -86,25 +84,14 @@ public class ItemSigilLava extends ItemSigilBase {
 //            return false;
 //        }
 
-        {
-            int x = blockPos.getX();
-            int y = blockPos.getY();
-            int z = blockPos.getZ();
+        BlockPos newPos = blockPos.offset(side);
 
-            if (side.getIndex() == 0) --y;
-            if (side.getIndex() == 1) ++y;
-            if (side.getIndex() == 2) --z;
-            if (side.getIndex() == 3) ++z;
-            if (side.getIndex() == 4) --x;
-            if (side.getIndex() == 5) ++x;
+        if (!player.canPlayerEdit(newPos, side, stack)) {
+            return false;
+        }
 
-            if (!player.canPlayerEdit(new BlockPos(x, y, z), side, stack)) {
-                return false;
-            }
-
-            if (this.canPlaceLava(world, new BlockPos(x, y, z)) && syphonBatteries(stack, player, getEnergyUsed())) {
-                return this.tryPlaceLava(world, new BlockPos(x, y, z));
-            }
+        if (this.canPlaceLava(world, newPos) && syphonBatteries(stack, player, getEnergyUsed())) {
+            return this.tryPlaceLava(world, newPos);
         }
 
         return false;
@@ -116,7 +103,7 @@ public class ItemSigilLava extends ItemSigilBase {
         } else if ((world.getBlockState(blockPos).getBlock() == Blocks.lava || world.getBlockState(blockPos).getBlock() == Blocks.flowing_lava) && world.getBlockState(blockPos).getBlock().getMetaFromState(world.getBlockState(blockPos)) == 0) {
             return false;
         } else {
-            world.setBlockState(blockPos, Blocks.lava.getBlockState().getBaseState());
+            world.setBlockState(blockPos, Blocks.lava.getBlockState().getBaseState(), 3);
             return true;
         }
     }

src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilMagnetism.java

@@ -0,0 +1,40 @@
+package WayofTime.bloodmagic.item.sigil;
+
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.item.EntityXPOrb;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.world.World;
+
+import java.util.List;
+
+public class ItemSigilMagnetism extends ItemSigilToggleable {
+
+    public ItemSigilMagnetism() {
+        super("magnetism", 50);
+    }
+
+    @Override
+    public void onSigilUpdate(ItemStack stack, World world, EntityPlayer player, int itemSlot, boolean isSelected) {
+        int range = 5;
+        int verticalRange = 5;
+        float posX = Math.round(player.posX);
+        float posY = (float) (player.posY - player.getEyeHeight());
+        float posZ = Math.round(player.posZ);
+        List<EntityItem> entities = player.worldObj.getEntitiesWithinAABB(EntityItem.class, AxisAlignedBB.fromBounds(posX - 0.5f, posY - 0.5f, posZ - 0.5f, posX + 0.5f, posY + 0.5f, posZ + 0.5f).expand(range, verticalRange, range));
+        List<EntityXPOrb> xpOrbs = player.worldObj.getEntitiesWithinAABB(EntityXPOrb.class, AxisAlignedBB.fromBounds(posX - 0.5f, posY - 0.5f, posZ - 0.5f, posX + 0.5f, posY + 0.5f, posZ + 0.5f).expand(range, verticalRange, range));
+
+        for (EntityItem entity : entities) {
+            if (entity != null && !world.isRemote) {
+                entity.onCollideWithPlayer(player);
+            }
+        }
+
+        for (EntityXPOrb xpOrb : xpOrbs) {
+            if (xpOrb != null && !world.isRemote) {
+                xpOrb.onCollideWithPlayer(player);
+            }
+        }
+    }
+}

src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilPhantomBridge.java

@@ -0,0 +1,57 @@
+package WayofTime.bloodmagic.item.sigil;
+
+import WayofTime.bloodmagic.registry.ModBlocks;
+import WayofTime.bloodmagic.tile.TilePhantomBlock;
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.BlockPos;
+import net.minecraft.world.World;
+
+public class ItemSigilPhantomBridge extends ItemSigilToggleable {
+
+    public ItemSigilPhantomBridge() {
+        super("phantomBridge", 100);
+    }
+
+    @Override
+    public void onSigilUpdate(ItemStack stack, World world, EntityPlayer player, int itemSlot, boolean isSelected) {
+        if (!player.onGround && !player.isSneaking())
+            return;
+
+        int range = 2;
+        int verticalOffset = -1;
+
+        if (player.isSneaking())
+            verticalOffset--;
+
+        if (world.isRemote)
+            verticalOffset--;
+
+        int posX = (int) Math.round(player.posX - 0.5f);
+        int posY = (int) player.posY;
+        int posZ = (int) Math.round(player.posZ - 0.5f);
+
+        for (int ix = posX - range; ix <= posX + range; ix++) {
+            for (int iz = posZ - range; iz <= posZ + range; iz++) {
+                BlockPos blockPos = new BlockPos(ix, posY + verticalOffset, iz);
+                Block block = world.getBlockState(blockPos).getBlock();
+
+                if (world.isAirBlock(blockPos)) {
+                    world.setBlockState(blockPos, ModBlocks.phantomBlock.getDefaultState(), 3);
+
+                    TileEntity tile = world.getTileEntity(blockPos);
+                    if (tile instanceof TilePhantomBlock) {
+                        ((TilePhantomBlock) tile).setDuration(100);
+                    }
+                } else if (block == ModBlocks.phantomBlock) {
+                    TileEntity tile = world.getTileEntity(blockPos);
+                    if (tile instanceof TilePhantomBlock) {
+                        ((TilePhantomBlock) tile).setDuration(100);
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilSeer.java

@@ -0,0 +1,73 @@
+package WayofTime.bloodmagic.item.sigil;
+
+import WayofTime.bloodmagic.api.altar.IBloodAltar;
+import WayofTime.bloodmagic.api.iface.IAltarReader;
+import WayofTime.bloodmagic.api.util.helper.BindableHelper;
+import WayofTime.bloodmagic.api.util.helper.NetworkHelper;
+import WayofTime.bloodmagic.api.util.helper.PlayerHelper;
+import WayofTime.bloodmagic.tile.TileInventory;
+import WayofTime.bloodmagic.util.ChatUtil;
+import WayofTime.bloodmagic.util.helper.TextHelper;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+
+public class ItemSigilSeer extends ItemSigilBase implements IAltarReader {
+
+    public ItemSigilSeer() {
+        super("seer");
+    }
+
+    @Override
+    public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player) {
+
+        if (PlayerHelper.isFakePlayer(player))
+            return stack;
+
+        super.onItemRightClick(stack, world, player);
+
+        if (!world.isRemote) {
+            MovingObjectPosition position = getMovingObjectPositionFromPlayer(world, player, false);
+            int currentEssence = NetworkHelper.getSoulNetwork(BindableHelper.getOwnerName(stack), world).getCurrentEssence();
+
+            if (position == null) {
+                ChatUtil.sendNoSpam(player, new ChatComponentText(TextHelper.localize(tooltipBase + "currentEssence", currentEssence)));
+                return stack;
+            } else {
+                if (position.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK) {
+
+                    TileEntity tile = world.getTileEntity(position.getBlockPos());
+
+                    if (tile != null && tile instanceof IBloodAltar) {
+                        IBloodAltar altar = (IBloodAltar) tile;
+                        int tier = altar.getTier().ordinal() + 1;
+                        currentEssence = altar.getCurrentBlood();
+                        int capacity = altar.getCapacity();
+                        altar.checkTier();
+                        if (tile instanceof IInventory) {
+                            if (((IInventory) tile).getStackInSlot(0) != null) {
+                                int progress = altar.getProgress();
+                                int totalLiquidRequired = altar.getLiquidRequired() * ((IInventory) tile).getStackInSlot(0).stackSize;
+                                int consumptionRate = (int) (altar.getConsumptionRate() * (altar.getConsumptionMultiplier() + 1));
+                                ChatUtil.sendNoSpam(player, TextHelper.localize(tooltipBase + "currentAltarProgress", progress, totalLiquidRequired), TextHelper.localize(tooltipBase + "currentAltarConsumptionRate", consumptionRate), TextHelper.localize(tooltipBase + "currentAltarTier", tier), TextHelper.localize(tooltipBase + "currentEssence", currentEssence), TextHelper.localize(tooltipBase + "currentAltarCapacity", capacity));
+                            }
+                            else {
+                                ChatUtil.sendNoSpam(player, TextHelper.localize(tooltipBase + "currentAltarTier", tier), TextHelper.localize(tooltipBase + "currentEssence", currentEssence), TextHelper.localize(tooltipBase + "currentAltarCapacity", capacity));
+                            }
+                        }
+                    } else {
+                        ChatUtil.sendNoSpam(player, TextHelper.localize(tooltipBase + "currentEssence", currentEssence));
+                    }
+
+                    return stack;
+                }
+            }
+        }
+
+        return stack;
+    }
+}

src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilSuppression.java

@@ -0,0 +1,51 @@
+package WayofTime.bloodmagic.item.sigil;
+
+import WayofTime.bloodmagic.tile.TileSpectralBlock;
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.BlockPos;
+import net.minecraft.world.World;
+import net.minecraftforge.fluids.IFluidBlock;
+
+public class ItemSigilSuppression extends ItemSigilToggleable {
+
+    public ItemSigilSuppression() {
+        super("suppression", 400);
+    }
+
+    @Override
+    public void onSigilUpdate(ItemStack stack, World world, EntityPlayer player, int itemSlot, boolean isSelected) {
+        int x = (int) player.posX;
+        int y = (int) player.posY;
+        int z = (int) player.posZ;
+        final int radius = 5;
+        final int refresh = 100;
+
+        for (int i = -radius; i <= radius; i++) {
+            for (int j = -radius; j <= radius; j++) {
+                for (int k = -radius; k <= radius; k++) {
+                    if (i * i + j * j + k * k >= (radius + 0.50f) * (radius + 0.50f)) {
+                        continue;
+                    }
+
+                    BlockPos blockPos = new BlockPos(x + i, y + j, z + k);
+                    Block block = world.getBlockState(blockPos).getBlock();
+
+                    if (isBlockLiquid(block) && world.getTileEntity(blockPos) == null)
+                        TileSpectralBlock.createSpectralBlock(world, blockPos, refresh);
+                    else {
+                        TileEntity tile = world.getTileEntity(blockPos);
+                        if (tile instanceof TileSpectralBlock)
+                            ((TileSpectralBlock) tile).resetDuration(refresh);
+                    }
+                }
+            }
+        }
+    }
+
+    private boolean isBlockLiquid(Block block) {
+        return (block instanceof IFluidBlock || block.getMaterial().isLiquid());
+    }
+}

src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilToggleable.java

@@ -0,0 +1,74 @@
+package WayofTime.bloodmagic.item.sigil;
+
+import WayofTime.bloodmagic.api.util.helper.BindableHelper;
+import WayofTime.bloodmagic.item.ItemBindable;
+import WayofTime.bloodmagic.util.helper.TextHelper;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.BlockPos;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import java.util.List;
+
+public class ItemSigilToggleable extends ItemSigilBase {
+
+    public ItemSigilToggleable(String name, int lpUsed) {
+        super(name, lpUsed);
+        setToggleable();
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    @SuppressWarnings("unchecked")
+    public void addInformation(ItemStack stack, EntityPlayer player, List tooltip, boolean advanced) {
+        super.addInformation(stack, player, tooltip, advanced);
+        if (getActivated(stack))
+            tooltip.add(TextHelper.localize("tooltip.BloodMagic.activated"));
+        else
+            tooltip.add(TextHelper.localize("tooltip.BloodMagic.deactivated"));
+    }
+
+    @Override
+    public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player) {
+        if (!world.isRemote && !isUnusable(stack)) {
+            if (player.isSneaking())
+                setActivated(stack, !getActivated(stack));
+            if (getActivated(stack) && ItemBindable.syphonBatteries(stack, player, getEnergyUsed()))
+                return stack;
+        }
+
+        return stack;
+    }
+
+    @Override
+    public boolean onItemUseFirst(ItemStack stack, EntityPlayer player, World world, BlockPos blockPos, EnumFacing side, float hitX, float hitY, float hitZ) {
+        if (BindableHelper.checkAndSetItemOwner(stack, player) && ItemBindable.syphonBatteries(stack, player, getEnergyUsed()))
+            return onSigilUseFirst(stack, player, world, blockPos, side, hitX, hitY, hitZ);
+
+        return false;
+    }
+
+    public boolean onSigilUseFirst(ItemStack itemStack, EntityPlayer player, World world, BlockPos blockPos, EnumFacing side, float hitX, float hitY, float hitZ) {
+        return false;
+    }
+
+    @Override
+    public void onUpdate(ItemStack stack, World worldIn, Entity entityIn, int itemSlot, boolean isSelected) {
+        if (!worldIn.isRemote && entityIn instanceof EntityPlayerMP && getActivated(stack)) {
+            if (worldIn.getWorldTime() % 100 == 0) {
+                if (!ItemBindable.syphonBatteries(stack, (EntityPlayer) entityIn, getEnergyUsed())) {
+                    setActivated(stack, false);
+                }
+            }
+
+            onSigilUpdate(stack, worldIn, (EntityPlayer) entityIn, itemSlot, isSelected);
+        }
+    }
+
+    public void onSigilUpdate(ItemStack stack, World world, EntityPlayer player, int itemSlot, boolean isSelected) {}
+}

src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilVoid.java

@@ -80,26 +80,15 @@ public class ItemSigilVoid extends ItemSigilBase {
             return false;
         }
 
-        {
-            int x = blockPos.getX();
-            int y = blockPos.getY();
-            int z = blockPos.getZ();
+        BlockPos newPos = blockPos.offset(side);
 
-            if (side.getIndex() == 0) --y;
-            if (side.getIndex() == 1) ++y;
-            if (side.getIndex() == 2) --z;
-            if (side.getIndex() == 3) ++z;
-            if (side.getIndex() == 4) --x;
-            if (side.getIndex() == 5) ++x;
+        if (!player.canPlayerEdit(newPos, side, stack)) {
+            return false;
+        }
 
-            if (!player.canPlayerEdit(new BlockPos(x, y, z), side, stack)) {
-                return false;
-            }
-
-            if (world.getBlockState(new BlockPos(x, y, z)).getBlock() instanceof IFluidBlock && syphonBatteries(stack, player, getEnergyUsed())) {
-                world.setBlockToAir(new BlockPos(x, y, z));
-                return true;
-            }
+        if (world.getBlockState(newPos).getBlock() instanceof IFluidBlock && syphonBatteries(stack, player, getEnergyUsed())) {
+            world.setBlockToAir(newPos);
+            return true;
         }
 
         return false;

src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilWater.java

@@ -24,7 +24,7 @@ public class ItemSigilWater extends ItemSigilBase {
     @Override
     public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player) {
         if (!world.isRemote && !isUnusable(stack)) {
-            MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(world, player, true);
+            MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(world, player, false);
 
             if (movingobjectposition != null) {
                 ItemStack ret = net.minecraftforge.event.ForgeEventFactory.onBucketUse(player, world, stack, movingobjectposition);
@@ -47,12 +47,10 @@ public class ItemSigilWater extends ItemSigilBase {
                         return stack;
                     }
 
-                    if (this.canPlaceWater(world, blockpos1) && syphonBatteries(stack, player, getEnergyUsed())) {
-                        this.tryPlaceWater(world, blockpos1);
+                    if (this.canPlaceWater(world, blockpos1) && syphonBatteries(stack, player, getEnergyUsed()) && this.tryPlaceWater(world, blockpos1)) {
+                        return stack;
                     }
                 }
-            } else {
-                return stack;
             }
 
             if (!player.capabilities.isCreativeMode)
@@ -87,32 +85,27 @@ public class ItemSigilWater extends ItemSigilBase {
 //            return false;
 //        }
 
-        {
-            int x = blockPos.getX();
-            int y = blockPos.getY();
-            int z = blockPos.getZ();
+        BlockPos newPos = blockPos.offset(side);
 
-            if (side.getIndex() == 0) --y;
-            if (side.getIndex() == 1) ++y;
-            if (side.getIndex() == 2) --z;
-            if (side.getIndex() == 3) ++z;
-            if (side.getIndex() == 4) --x;
-            if (side.getIndex() == 5) ++x;
+        if (!player.canPlayerEdit(newPos, side, stack)) {
+            return false;
+        }
 
-            if (!player.canPlayerEdit(new BlockPos(x, y, z), side, stack)) {
-                return false;
-            }
-
-            if (this.canPlaceWater(world, new BlockPos(x, y, z)) && syphonBatteries(stack, player, getEnergyUsed())) {
-                return this.tryPlaceWater(world, new BlockPos(x, y, z));
-            }
+        if (this.canPlaceWater(world, newPos) && syphonBatteries(stack, player, getEnergyUsed())) {
+            return this.tryPlaceWater(world, newPos);
         }
 
         return false;
     }
 
     public boolean canPlaceWater(World world, BlockPos blockPos) {
-        return (world.isAirBlock(blockPos) && !world.getBlockState(blockPos).getBlock().getMaterial().isSolid()) && !((world.getBlockState(blockPos).getBlock() == Blocks.water || world.getBlockState(blockPos).getBlock() == Blocks.flowing_water) && world.getBlockState(blockPos).getBlock().getMetaFromState(world.getBlockState(blockPos)) == 0);
+        if (!world.isAirBlock(blockPos) && world.getBlockState(blockPos).getBlock().getMaterial().isSolid()) {
+            return false;
+        } else if ((world.getBlockState(blockPos).getBlock() == Blocks.water || world.getBlockState(blockPos).getBlock() == Blocks.flowing_water) && world.getBlockState(blockPos).getBlock().getMetaFromState(world.getBlockState(blockPos)) == 0) {
+            return false;
+        } else {
+            return true;
+        }
     }
 
     public boolean tryPlaceWater(World worldIn, BlockPos pos) {

src/main/java/WayofTime/bloodmagic/potion/PotionBloodMagic.java

@@ -0,0 +1,13 @@
+package WayofTime.bloodmagic.potion;
+
+import net.minecraft.potion.Potion;
+import net.minecraft.util.ResourceLocation;
+
+public class PotionBloodMagic extends Potion {
+
+    public PotionBloodMagic(String name, ResourceLocation texture, boolean badEffect, int potionColor, int iconIndexX, int iconIndexY) {
+        super(texture, badEffect, potionColor);
+        this.setPotionName(name);
+        this.setIconIndex(iconIndexX, iconIndexY);
+    }
+}

src/main/java/WayofTime/bloodmagic/potion/PotionEventHandlers.java

@@ -0,0 +1,55 @@
+package WayofTime.bloodmagic.potion;
+
+import WayofTime.bloodmagic.registry.ModPotions;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.living.LivingEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class PotionEventHandlers {
+
+    public PotionEventHandlers() {
+        MinecraftForge.EVENT_BUS.register(this);
+    }
+
+    @SubscribeEvent
+    public void onLivingJumpEvent(LivingEvent.LivingJumpEvent event) {
+        if (event.entityLiving.isPotionActive(ModPotions.boost)) {
+            int i = event.entityLiving.getActivePotionEffect(ModPotions.boost).getAmplifier();
+            event.entityLiving.motionY += (0.1f) * (2 + i);
+        }
+
+//        if (event.entityLiving.isPotionActive(ModPotions.heavyHeart)) {
+//            event.entityLiving.motionY = 0;
+//        }
+    }
+
+    @SubscribeEvent
+    public void onEntityUpdate(LivingEvent.LivingUpdateEvent event) {
+//        EntityLivingBase entityLiving = event.entityLiving;
+//        double x = entityLiving.posX;
+//        double y = entityLiving.posY;
+//        double z = entityLiving.posZ;
+
+
+        if (event.entityLiving.isPotionActive(ModPotions.boost)) {
+            int i = event.entityLiving.getActivePotionEffect(ModPotions.boost).getAmplifier();
+            {
+                float percentIncrease = (i + 1) * 0.05f;
+
+                if (event.entityLiving instanceof EntityPlayer) {
+                    EntityPlayer entityPlayer = (EntityPlayer) event.entityLiving;
+                    entityPlayer.stepHeight = 1.0f;
+
+                    if ((entityPlayer.onGround || entityPlayer.capabilities.isFlying) && entityPlayer.moveForward > 0F)
+                        entityPlayer.moveFlying(0F, 1F, entityPlayer.capabilities.isFlying ? (percentIncrease / 2.0f) : percentIncrease);
+                }
+            }
+        }
+    }
+}

src/main/java/WayofTime/bloodmagic/proxy/ClientProxy.java

@@ -1,15 +1,19 @@
 package WayofTime.bloodmagic.proxy;
 
+import WayofTime.bloodmagic.api.Constants;
+import WayofTime.bloodmagic.client.render.RenderAlchemyArray;
+import WayofTime.bloodmagic.entity.projectile.EntityBloodLight;
+import WayofTime.bloodmagic.registry.ModBlocks;
+import WayofTime.bloodmagic.registry.ModItems;
+import WayofTime.bloodmagic.render.RenderEntityBloodLight;
+import WayofTime.bloodmagic.tile.TileAlchemyArray;
+import WayofTime.bloodmagic.util.helper.InventoryRenderHelper;
+import net.minecraft.client.Minecraft;
 import net.minecraft.client.resources.model.ModelResourceLocation;
 import net.minecraftforge.client.model.ModelLoader;
 import net.minecraftforge.client.model.obj.OBJLoader;
 import net.minecraftforge.fml.client.registry.ClientRegistry;
-import WayofTime.bloodmagic.api.Constants;
-import WayofTime.bloodmagic.client.render.RenderAlchemyArray;
-import WayofTime.bloodmagic.registry.ModBlocks;
-import WayofTime.bloodmagic.registry.ModItems;
-import WayofTime.bloodmagic.tile.TileAlchemyArray;
-import WayofTime.bloodmagic.util.helper.InventoryRenderHelper;
+import net.minecraftforge.fml.client.registry.RenderingRegistry;
 
 public class ClientProxy extends CommonProxy {
 
@@ -25,7 +29,7 @@ public class ClientProxy extends CommonProxy {
 
     @Override
     public void init() {
-
+        RenderingRegistry.registerEntityRenderingHandler(EntityBloodLight.class, new RenderEntityBloodLight(Minecraft.getMinecraft().getRenderManager()));
     }
 
     @Override

src/main/java/WayofTime/bloodmagic/registry/ModBlocks.java

@@ -1,36 +1,16 @@
 package WayofTime.bloodmagic.registry;
 
+import WayofTime.bloodmagic.BloodMagic;
+import WayofTime.bloodmagic.ConfigHandler;
+import WayofTime.bloodmagic.api.Constants;
+import WayofTime.bloodmagic.block.*;
+import WayofTime.bloodmagic.item.block.*;
+import WayofTime.bloodmagic.tile.*;
+import WayofTime.bloodmagic.util.helper.InventoryRenderHelper;
 import net.minecraft.block.Block;
 import net.minecraft.item.ItemBlock;
 import net.minecraftforge.fluids.FluidRegistry;
 import net.minecraftforge.fml.common.registry.GameRegistry;
-import WayofTime.bloodmagic.BloodMagic;
-import WayofTime.bloodmagic.ConfigHandler;
-import WayofTime.bloodmagic.api.Constants;
-import WayofTime.bloodmagic.block.BlockAlchemyArray;
-import WayofTime.bloodmagic.block.BlockAltar;
-import WayofTime.bloodmagic.block.BlockBloodLight;
-import WayofTime.bloodmagic.block.BlockBloodRune;
-import WayofTime.bloodmagic.block.BlockBloodStoneBrick;
-import WayofTime.bloodmagic.block.BlockCrystal;
-import WayofTime.bloodmagic.block.BlockLifeEssence;
-import WayofTime.bloodmagic.block.BlockPedestal;
-import WayofTime.bloodmagic.block.BlockRitualController;
-import WayofTime.bloodmagic.block.BlockRitualStone;
-import WayofTime.bloodmagic.block.BlockTeleposer;
-import WayofTime.bloodmagic.block.BlockTestSpellBlock;
-import WayofTime.bloodmagic.item.block.ItemBlockBloodRune;
-import WayofTime.bloodmagic.item.block.ItemBlockBloodStoneBrick;
-import WayofTime.bloodmagic.item.block.ItemBlockCrystal;
-import WayofTime.bloodmagic.item.block.ItemBlockPedestal;
-import WayofTime.bloodmagic.item.block.ItemBlockRitualController;
-import WayofTime.bloodmagic.item.block.ItemBlockRitualStone;
-import WayofTime.bloodmagic.tile.TileAlchemyArray;
-import WayofTime.bloodmagic.tile.TileAltar;
-import WayofTime.bloodmagic.tile.TileImperfectRitualStone;
-import WayofTime.bloodmagic.tile.TileMasterRitualStone;
-import WayofTime.bloodmagic.tile.TilePlinth;
-import WayofTime.bloodmagic.util.helper.InventoryRenderHelper;
 
 public class ModBlocks {
     public static Block altar;
@@ -42,6 +22,8 @@ public class ModBlocks {
     public static Block pedestal;
     public static Block teleposer;
     public static Block alchemyArray;
+    public static Block spectralBlock;
+    public static Block phantomBlock;
 
     public static Block lifeEssence;
 
@@ -61,6 +43,8 @@ public class ModBlocks {
         pedestal = registerBlock(new BlockPedestal(), ItemBlockPedestal.class);
         teleposer = registerBlock(new BlockTeleposer());
         alchemyArray = registerBlock(new BlockAlchemyArray());
+        spectralBlock = registerBlock(new BlockSpectral());
+        phantomBlock = registerBlock(new BlockPhantom());
         crystal = registerBlock(new BlockCrystal(), ItemBlockCrystal.class);
         bloodStoneBrick = registerBlock(new BlockBloodStoneBrick(), ItemBlockBloodStoneBrick.class);
 
@@ -72,7 +56,9 @@ public class ModBlocks {
         GameRegistry.registerTileEntity(TileImperfectRitualStone.class, Constants.Mod.MODID + ":" + TileImperfectRitualStone.class.getSimpleName());
         GameRegistry.registerTileEntity(TileMasterRitualStone.class, Constants.Mod.MODID + ":" + TileMasterRitualStone.class.getSimpleName());
         GameRegistry.registerTileEntity(TilePlinth.class, Constants.Mod.MODID + ":" + TilePlinth.class.getSimpleName());
-        GameRegistry.registerTileEntity(TileAlchemyArray.class, Constants.Mod.MODID + ":" + TileAlchemyArray.class.getSimpleName());
+        GameRegistry.registerTileEntity(TileAlchemyArray.class, Constants.Mod.MODID + TileAlchemyArray.class.getSimpleName());
+        GameRegistry.registerTileEntity(TileSpectralBlock.class, Constants.Mod.MODID + ":" + TileSpectralBlock.class.getSimpleName());
+        GameRegistry.registerTileEntity(TilePhantomBlock.class, Constants.Mod.MODID + ":" + TilePhantomBlock.class.getSimpleName());
     }
 
     public static void initRenders() {
@@ -107,6 +93,8 @@ public class ModBlocks {
         renderHelper.itemRender(InventoryRenderHelper.getItemFromBlock(pedestal), 1);
         renderHelper.itemRender(InventoryRenderHelper.getItemFromBlock(teleposer));
         renderHelper.itemRender(InventoryRenderHelper.getItemFromBlock(alchemyArray));
+        renderHelper.itemRender(InventoryRenderHelper.getItemFromBlock(spectralBlock));
+        renderHelper.itemRender(InventoryRenderHelper.getItemFromBlock(phantomBlock));
     }
 
     private static Block registerBlock(Block block, Class<? extends ItemBlock> itemBlock, String name) {

src/main/java/WayofTime/bloodmagic/registry/ModEntities.java

@@ -1,8 +1,14 @@
 package WayofTime.bloodmagic.registry;
 
+import WayofTime.bloodmagic.BloodMagic;
+import WayofTime.bloodmagic.entity.projectile.EntityBloodLight;
+import net.minecraftforge.fml.common.registry.EntityRegistry;
+
 public class ModEntities {
 
     public static void init() {
+        int id = 0;
 
+        EntityRegistry.registerModEntity(EntityBloodLight.class, "BloodLight", id++, BloodMagic.instance, 64, 20, true);
     }
 }

src/main/java/WayofTime/bloodmagic/registry/ModItems.java

@@ -2,7 +2,6 @@ package WayofTime.bloodmagic.registry;
 
 import WayofTime.bloodmagic.BloodMagic;
 import WayofTime.bloodmagic.ConfigHandler;
-import WayofTime.bloodmagic.api.BloodMagicAPI;
 import WayofTime.bloodmagic.api.Constants;
 import WayofTime.bloodmagic.api.orb.BloodOrb;
 import WayofTime.bloodmagic.api.registry.OrbRegistry;
@@ -40,6 +39,18 @@ public class ModItems {
     public static Item sigilWater;
     public static Item sigilLava;
     public static Item sigilVoid;
+    public static Item sigilGreenGrove;
+    public static Item sigilBloodLight;
+    public static Item sigilElementalAffinity;
+    public static Item sigilHaste;
+    public static Item sigilMagnetism;
+    public static Item sigilSuppression;
+    public static Item sigilFastMiner;
+    public static Item sigilSeer;
+    public static Item sigilEnderSeverance;
+    public static Item sigilHurricane;
+    public static Item sigilPhantomBridge;
+    public static Item sigilCompression;
 
     public static Item livingArmourHelmet;
     public static Item livingArmourChest;
@@ -78,6 +89,15 @@ public class ModItems {
         sigilWater = registerItem(new ItemSigilWater());
         sigilLava = registerItem(new ItemSigilLava());
         sigilVoid = registerItem(new ItemSigilVoid());
+        sigilGreenGrove = registerItem(new ItemSigilGreenGrove());
+        sigilBloodLight = registerItem(new ItemSigilBloodLight());
+        sigilElementalAffinity = registerItem(new ItemSigilElementalAffinity());
+        sigilMagnetism = registerItem(new ItemSigilMagnetism());
+        sigilSuppression = registerItem(new ItemSigilSuppression());
+        sigilHaste = registerItem(new ItemSigilHaste());
+        sigilFastMiner = registerItem(new ItemSigilFastMiner());
+        sigilSeer = registerItem(new ItemSigilSeer());
+        sigilPhantomBridge = registerItem(new ItemSigilPhantomBridge());
 
         livingArmourHelmet = registerItem(new ItemLivingArmour(0), "ItemLivingArmourHelmet");
         livingArmourChest = registerItem(new ItemLivingArmour(1), "ItemLivingArmourChest");
@@ -127,6 +147,22 @@ public class ModItems {
         renderHelper.itemRender(sigilWater);
         renderHelper.itemRender(sigilLava);
         renderHelper.itemRender(sigilVoid);
+        renderHelper.itemRender(sigilGreenGrove, 0);
+        renderHelper.itemRender(sigilGreenGrove, 1);
+        renderHelper.itemRender(sigilBloodLight);
+        renderHelper.itemRender(sigilElementalAffinity, 0);
+        renderHelper.itemRender(sigilElementalAffinity, 1);
+        renderHelper.itemRender(sigilMagnetism, 0);
+        renderHelper.itemRender(sigilMagnetism, 1);
+        renderHelper.itemRender(sigilSuppression, 0);
+        renderHelper.itemRender(sigilSuppression, 1);
+        renderHelper.itemRender(sigilHaste, 0);
+        renderHelper.itemRender(sigilHaste, 1);
+        renderHelper.itemRender(sigilFastMiner, 0);
+        renderHelper.itemRender(sigilFastMiner, 1);
+        renderHelper.itemRender(sigilSeer);
+        renderHelper.itemRender(sigilPhantomBridge, 0);
+        renderHelper.itemRender(sigilPhantomBridge, 1);
 
         renderHelper.itemRender(livingArmourHelmet);
         renderHelper.itemRender(livingArmourChest);

src/main/java/WayofTime/bloodmagic/registry/ModPotions.java

@@ -1,8 +1,55 @@
 package WayofTime.bloodmagic.registry;
 
+import WayofTime.bloodmagic.api.Constants;
+import WayofTime.bloodmagic.potion.PotionBloodMagic;
+import WayofTime.bloodmagic.potion.PotionEventHandlers;
+import net.minecraft.potion.Potion;
+import net.minecraft.util.ResourceLocation;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+
 public class ModPotions {
 
-    public static void init() {
+    public static Potion drowning;
+    public static Potion boost;
+    public static Potion heavyHeart;
 
+    public static void init() {
+        if (Potion.potionTypes.length < 256) extendPortionArray();
+
+        new PotionEventHandlers();
+
+        //TODO FUTURE MAKE POTION TEXTURES
+
+//        final String resourceLocation = Constants.Mod.MODID + ":textures/potions/";
+
+//        drowning = new PotionBloodMagic("Drowning", new ResourceLocation(resourceLocation + drowning.getName().toLowerCase()), true, 0, 0, 0);
+        boost = new PotionBloodMagic("Boost", new ResourceLocation("Minecraft:textures/gui/container/inventory.png")
+//                new ResourceLocation(resourceLocation + boost.getName().toLowerCase())
+                , false, 0, 0, 0);
+//        heavyHeart = new PotionBloodMagic("Heavy Heart", new ResourceLocation(resourceLocation + heavyHeart.getName().toLowerCase()), true, 0, 0, 0);
+    }
+
+    public static void extendPortionArray() {
+        Potion[] potionTypes;
+
+        for (Field f : Potion.class.getDeclaredFields()) {
+            f.setAccessible(true);
+            try {
+                if (f.getName().equals("potionTypes") || f.getName().equals("field_76425_a")) {
+                    Field field = Field.class.getDeclaredField("modifiers");
+                    field.setAccessible(true);
+                    field.setInt(f, f.getModifiers() & ~Modifier.FINAL);
+
+                    potionTypes = (Potion[]) f.get(null);
+                    final Potion[] newPotionTypes = new Potion[256];
+                    System.arraycopy(potionTypes, 0, newPotionTypes, 0, potionTypes.length);
+                    f.set(null, newPotionTypes);
+                }
+            } catch (Exception e) {
+                System.err.println(e);
+            }
+        }
     }
 }

src/main/java/WayofTime/bloodmagic/render/RenderEntityBloodLight.java

@@ -0,0 +1,53 @@
+package WayofTime.bloodmagic.render;
+
+import WayofTime.bloodmagic.entity.projectile.EntityBloodLight;
+import net.minecraft.client.renderer.GlStateManager;
+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.texture.TextureMap;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.ResourceLocation;
+
+public class RenderEntityBloodLight extends Render {
+
+    public RenderEntityBloodLight(RenderManager renderManager) {
+        super(renderManager);
+        this.shadowSize = 0.0F;
+    }
+
+    public void renderEntityAt(EntityBloodLight entity, double x, double y, double z, float fq, float pticks) {
+        GlStateManager.pushMatrix();
+        GlStateManager.translate(x, y, z);
+        GlStateManager.enableRescaleNormal();
+        GlStateManager.scale(0.1F, 0.1F, 0.1F);
+        this.bindTexture(this.getEntityTexture(entity));
+        Tessellator tessellator = Tessellator.getInstance();
+        GlStateManager.rotate(180.0F - renderManager.playerViewY, 0.0F, 1.0F, 0.0F);
+        GlStateManager.rotate(-renderManager.playerViewX, 1.0F, 0.0F, 0.0F);
+        tessellator.getWorldRenderer().begin(7, DefaultVertexFormats.POSITION_TEX_COLOR_NORMAL); //startDrawingQuads
+//        tessellator.getWorldRenderer().putNormal(0.0F, 1.0F, 0.0F); //setNormal
+        tessellator.getWorldRenderer().pos(-0.5D, -0.25D, 0.0D).tex(0D, 1D).normal(0F, 1F, 0F).endVertex();
+        tessellator.getWorldRenderer().pos(0.5D, -0.25D, 0.0D).tex(1D, 1D).normal(0F, 1F, 0F).endVertex();
+        tessellator.getWorldRenderer().pos(0.5D, 0.75D, 0.0D).tex(1D, 0D).normal(0F, 1F, 0F).endVertex();
+        tessellator.getWorldRenderer().pos(-0.5D, 0.75D, 0.0D).tex(0D, 1D).normal(0F, 1F, 0F).endVertex();
+//        tessellator.getWorldRenderer().addVertexWithUV(-0.5F, -0.25F, 0.0D, 0, 1);
+//        tessellator.getWorldRenderer().addVertexWithUV(0.5F, -0.25F, 0.0D, 1, 1);
+//        tessellator.getWorldRenderer().addVertexWithUV(0.5F, 0.75F, 0.0D, 1, 0);
+//        tessellator.getWorldRenderer().addVertexWithUV(-0.5F, 0.75F, 0.0D, 0, 0);
+        tessellator.draw();
+        GlStateManager.disableRescaleNormal();
+        GlStateManager.popMatrix();
+    }
+
+    @Override
+    public void doRender(Entity entity, double d, double d1, double d2, float f, float f1) {
+        renderEntityAt((EntityBloodLight) entity, d, d1, d2, f, f1);
+    }
+
+    @Override
+    protected ResourceLocation getEntityTexture(Entity entity) {
+        return TextureMap.locationBlocksTexture;
+    }
+}

src/main/java/WayofTime/bloodmagic/tile/TileAltar.java

@@ -156,6 +156,21 @@ public class TileAltar extends TileInventory implements IBloodAltar, ITickable,
 		return bloodAltar.getDislocationMultiplier();
 	}
 
+    @Override
+    public float getConsumptionMultiplier() {
+        return bloodAltar.getConsumptionMultiplier();
+    }
+
+    @Override
+    public float getConsumptionRate() {
+        return bloodAltar.getConsumptionRate();
+    }
+
+    @Override
+    public int getLiquidRequired() {
+        return bloodAltar.getLiquidRequired();
+    }
+
 	@Override
 	public int getBufferCapacity() {
 		return bloodAltar.getBufferCapacity();

src/main/java/WayofTime/bloodmagic/tile/TilePhantomBlock.java

@@ -0,0 +1,39 @@
+package WayofTime.bloodmagic.tile;
+
+import WayofTime.bloodmagic.api.Constants;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ITickable;
+
+public class TilePhantomBlock extends TileEntity implements ITickable {
+
+    private int ticksRemaining;
+
+    public TilePhantomBlock() {
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound tagCompound) {
+        super.readFromNBT(tagCompound);
+        ticksRemaining = tagCompound.getInteger(Constants.NBT.TICKS_REMAINING);
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound tagCompound) {
+        super.writeToNBT(tagCompound);
+        tagCompound.setInteger(Constants.NBT.TICKS_REMAINING, ticksRemaining);
+    }
+
+    @Override
+    public void update() {
+        ticksRemaining--;
+
+        if (ticksRemaining <= 0) {
+            worldObj.setBlockToAir(pos);
+        }
+    }
+
+    public void setDuration(int duration) {
+        ticksRemaining = duration;
+    }
+}

src/main/java/WayofTime/bloodmagic/tile/TileSpectralBlock.java

@@ -0,0 +1,79 @@
+package WayofTime.bloodmagic.tile;
+
+import WayofTime.bloodmagic.api.Constants;
+import WayofTime.bloodmagic.registry.ModBlocks;
+import com.google.common.base.Strings;
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.BlockPos;
+import net.minecraft.util.ITickable;
+import net.minecraft.world.World;
+
+public class TileSpectralBlock extends TileEntity implements ITickable {
+
+    private int ticksRemaining;
+    private String containedBlockName;
+    private int containedBlockMeta;
+
+    public TileSpectralBlock() {
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound tagCompound) {
+        super.readFromNBT(tagCompound);
+        ticksRemaining = tagCompound.getInteger(Constants.NBT.TICKS_REMAINING);
+        containedBlockName = tagCompound.getString(Constants.NBT.CONTAINED_BLOCK_NAME);
+        containedBlockMeta = tagCompound.getInteger(Constants.NBT.CONTAINED_BLOCK_META);
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound tagCompound) {
+        super.writeToNBT(tagCompound);
+        tagCompound.setInteger(Constants.NBT.TICKS_REMAINING, ticksRemaining);
+        tagCompound.setString(Constants.NBT.CONTAINED_BLOCK_NAME, containedBlockName);
+        tagCompound.setInteger(Constants.NBT.CONTAINED_BLOCK_META, containedBlockMeta);
+    }
+
+    @Override
+    public void update() {
+        ticksRemaining--;
+
+        if (ticksRemaining <= 0) {
+            returnContainedBlock();
+        }
+    }
+
+    private void setContainedBlockInfo(IBlockState blockState) {
+        containedBlockName = blockState.getBlock().getUnlocalizedName().substring(5);
+        containedBlockMeta = blockState.getBlock().getMetaFromState(blockState);
+    }
+
+    private void setDuration(int duration) {
+        ticksRemaining = duration;
+    }
+
+    public void resetDuration(int reset) {
+        if (ticksRemaining < reset) ticksRemaining = reset;
+    }
+
+    public void returnContainedBlock() {
+        Block block = null;
+
+        if (!Strings.isNullOrEmpty(containedBlockName))
+            block = Block.getBlockFromName(containedBlockName);
+
+        if (block != null && worldObj.setBlockState(pos, block.getStateFromMeta(containedBlockMeta)))
+            worldObj.markBlockForUpdate(pos);
+    }
+
+    public static void createSpectralBlock(World world, BlockPos blockPos, int duration) {
+        if (world.isAirBlock(blockPos)) return;
+        IBlockState cachedState = world.getBlockState(blockPos);
+        world.setBlockState(blockPos, ModBlocks.spectralBlock.getDefaultState());
+        TileSpectralBlock tile = (TileSpectralBlock) world.getTileEntity(blockPos);
+        tile.setContainedBlockInfo(cachedState);
+        tile.setDuration(duration);
+    }
+}

src/main/resources/assets/bloodmagic/blockstates/BlockPhantom.json

@@ -0,0 +1,10 @@
+{
+    "variants": {
+        "normal": {
+            "model": "bloodmagic:BlockPhantom",
+            "textures": {
+                "all": "bloodmagic:blocks/PhantomBlock"
+            }
+        }
+    }
+}

src/main/resources/assets/bloodmagic/blockstates/BlockSpectral.json

@@ -0,0 +1,10 @@
+{
+    "variants": {
+        "normal": {
+            "model": "bloodmagic:BlockSpectral",
+            "textures": {
+                "all": "bloodmagic:blocks/SpectralBlock"
+            }
+        }
+    }
+}

src/main/resources/assets/bloodmagic/lang/en_US.lang

@@ -66,6 +66,14 @@ item.BloodMagic.sigil.divination.name=Divination Sigil
 item.BloodMagic.sigil.water.name=Water Sigil
 item.BloodMagic.sigil.lava.name=Lava Sigil
 item.BloodMagic.sigil.void.name=Void Sigil
+item.BloodMagic.sigil.greenGrove.name=Sigil of the Green Grove
+item.BloodMagic.sigil.elementalAffinity.name=Sigil of Elemental Affinity
+item.BloodMagic.sigil.haste.name=Sigil of Haste
+item.BloodMagic.sigil.suppression.name=Sigil of Suppression
+item.BloodMagic.sigil.magnetism.name=Sigil of Magnetism
+item.BloodMagic.sigil.fastMiner.name=Sigil of the Fast Miner
+item.BloodMagic.sigil.seer.name=Seer's Sigil
+item.BloodMagic.sigil.phantomBridge.name=Sigil of the Phantom Bridge
 
 item.BloodMagic.altarMaker.name=Altar Maker
 
@@ -104,9 +112,12 @@ tile.BloodMagic.bloodLight.name=Blood Light
 # Tooltips
 tooltip.BloodMagic.orb.desc=Stores raw Life Essence
 tooltip.BloodMagic.orb.owner=Added by: %s
-tooltip.BloodMagic.currentOwner=Owner: %s
+tooltip.BloodMagic.currentOwner=Current owner: %s
 tooltip.BloodMagic.currentTier=Current tier: %d
 
+tooltip.BloodMagic.activated=Activated
+tooltip.BloodMagic.deactivated=Deactivated
+
 tooltip.BloodMagic.sigil.air.desc=&oI feel lighter already...
 tooltip.BloodMagic.sigil.bloodLight.desc=&oI see a light!
 tooltip.BloodMagic.sigil.compression.desc=&oHands of Diamonds
@@ -117,6 +128,19 @@ tooltip.BloodMagic.sigil.divination.currentAltarCapacity=Current Capacity: %d LP
 tooltip.BloodMagic.sigil.water.desc=&oInfinite water, anyone?
 tooltip.BloodMagic.sigil.lava.desc=&oHOT! DO NOT EAT
 tooltip.BloodMagic.sigil.void.desc=&oBetter than a Swiffer®!
+tooltip.BloodMagic.sigil.greenGrove.desc=&oEnvironmentally friendly
+tooltip.BloodMagic.sigil.magnetism.desc=&oI have a very magnetic personality
+tooltip.BloodMagic.sigil.suppression.desc=&oBetter than telekinesis...
+tooltip.BloodMagic.sigil.haste.desc=&o42 doses of caffeine later...
+tooltip.BloodMagic.sigil.fastMiner.desc=&oKeep mining, and mining...
+tooltip.BloodMagic.sigil.elementalAffinity.desc=&oFalling fire fishes!
+tooltip.BloodMagic.sigil.seer.desc=&oWhen seeing all is not enough
+tooltip.BloodMagic.sigil.seer.currentAltarProgress=Current Progress: %d LP/ %s LP
+tooltip.BloodMagic.sigil.seer.currentAltarConsumptionRate=Consumption Rate: %d LP
+tooltip.BloodMagic.sigil.seer.currentAltarTier=Current Tier: %d
+tooltip.BloodMagic.sigil.seer.currentEssence=Current Essence: %d LP
+tooltip.BloodMagic.sigil.seer.currentAltarCapacity=Current Capacity: %d LP
+tooltip.BloodMagic.sigil.phantomBridge.desc=Walking in thin air...
 
 tooltip.BloodMagic.sacrificialDagger.desc=Just a prick of the finger will suffice...
 tooltip.BloodMagic.slate.desc=Infused stone inside of a Blood Altar
@@ -142,4 +166,4 @@ jei.BloodMagic.recipe.binding=Binding Ritual
 jei.BloodMagic.recipe.requiredLP=LP: %d
 jei.BloodMagic.recipe.requiredTier=Tier: %d
 
-jei.BloodMagic.desc.altarBuilder=A creative-only item for use in debugging and testing.\n\nShift + Right click to change the tier to build. Right click an Altar to initiate the build.\n\nBreak an Altar while holding to dismantle it.
+jei.BloodMagic.desc.altarBuilder=A creative-only item for use in debugging and testing.\n\nShift + Right click to change the tier to build. Right click an Altar to initiate the build.\n\nBreak an Altar while holding to dismantle it.

src/main/resources/assets/bloodmagic/models/block/BlockPhantom.json

@@ -0,0 +1,6 @@
+{
+  "parent": "block/cube_all",
+  "textures": {
+    "all": "bloodmagic:blocks/PhantomBlock"
+  }
+}

src/main/resources/assets/bloodmagic/models/item/BlockPhantom.json

@@ -0,0 +1,10 @@
+{
+  "parent": "bloodmagic:block/BlockPhantom",
+  "display": {
+    "thirdperson": {
+      "rotation": [ 10, -45, 170 ],
+      "translation": [ 0, 1.5, -2.75 ],
+      "scale": [ 0.375, 0.375, 0.375 ]
+    }
+  }
+}

src/main/resources/assets/bloodmagic/models/item/BlockSpectral.json

@@ -0,0 +1,10 @@
+{
+  "parent": "bloodmagic:block/BlockSpectral",
+  "display": {
+    "thirdperson": {
+      "rotation": [ 10, -45, 170 ],
+      "translation": [ 0, 1.5, -2.75 ],
+      "scale": [ 0.375, 0.375, 0.375 ]
+    }
+  }
+}

src/main/resources/assets/bloodmagic/models/item/ItemSigilElementalAffinity0.json

@@ -0,0 +1,6 @@
+{
+  "parent":"bloodmagic:item/ItemModelBase",
+  "textures": {
+    "layer0":"bloodmagic:items/ElementalSigil_deactivated"
+  }
+}

src/main/resources/assets/bloodmagic/models/item/ItemSigilElementalAffinity1.json

@@ -0,0 +1,6 @@
+{
+  "parent":"bloodmagic:item/ItemModelBase",
+  "textures": {
+    "layer0":"bloodmagic:items/ElementalSigil_activated"
+  }
+}

src/main/resources/assets/bloodmagic/models/item/ItemSigilFastMiner0.json

@@ -0,0 +1,6 @@
+{
+  "parent":"bloodmagic:item/ItemModelBase",
+  "textures": {
+    "layer0":"bloodmagic:items/MiningSigil_deactivated"
+  }
+}

src/main/resources/assets/bloodmagic/models/item/ItemSigilFastMiner1.json

@@ -0,0 +1,6 @@
+{
+  "parent":"bloodmagic:item/ItemModelBase",
+  "textures": {
+    "layer0":"bloodmagic:items/MiningSigil_activated"
+  }
+}

src/main/resources/assets/bloodmagic/models/item/ItemSigilGreenGrove0.json

@@ -0,0 +1,6 @@
+{
+  "parent":"bloodmagic:item/ItemModelBase",
+  "textures": {
+    "layer0":"bloodmagic:items/GrowthSigil_deactivated"
+  }
+}

src/main/resources/assets/bloodmagic/models/item/ItemSigilGreenGrove1.json

@@ -0,0 +1,6 @@
+{
+  "parent":"bloodmagic:item/ItemModelBase",
+  "textures": {
+    "layer0":"bloodmagic:items/GrowthSigil_activated"
+  }
+}

src/main/resources/assets/bloodmagic/models/item/ItemSigilHaste0.json

@@ -0,0 +1,6 @@
+{
+  "parent":"bloodmagic:item/ItemModelBase",
+  "textures": {
+    "layer0":"bloodmagic:items/HasteSigil_deactivated"
+  }
+}

src/main/resources/assets/bloodmagic/models/item/ItemSigilHaste1.json

@@ -0,0 +1,6 @@
+{
+  "parent":"bloodmagic:item/ItemModelBase",
+  "textures": {
+    "layer0":"bloodmagic:items/HasteSigil_activated"
+  }
+}

src/main/resources/assets/bloodmagic/models/item/ItemSigilMagnetism0.json

@@ -0,0 +1,6 @@
+{
+  "parent":"bloodmagic:item/ItemModelBase",
+  "textures": {
+    "layer0":"bloodmagic:items/SigilOfMagnetism_deactivated"
+  }
+}

src/main/resources/assets/bloodmagic/models/item/ItemSigilMagnetism1.json

@@ -0,0 +1,6 @@
+{
+  "parent":"bloodmagic:item/ItemModelBase",
+  "textures": {
+    "layer0":"bloodmagic:items/SigilOfMagnetism_activated"
+  }
+}

src/main/resources/assets/bloodmagic/models/item/ItemSigilPhantomBridge0.json

@@ -0,0 +1,6 @@
+{
+  "parent":"bloodmagic:item/ItemModelBase",
+  "textures": {
+    "layer0":"bloodmagic:items/BridgeSigil_deactivated"
+  }
+}

src/main/resources/assets/bloodmagic/models/item/ItemSigilPhantomBridge1.json

@@ -0,0 +1,6 @@
+{
+  "parent":"bloodmagic:item/ItemModelBase",
+  "textures": {
+    "layer0":"bloodmagic:items/BridgeSigil_activated"
+  }
+}

src/main/resources/assets/bloodmagic/models/item/ItemSigilSeer.json

@@ -0,0 +1,6 @@
+{
+  "parent":"bloodmagic:item/ItemModelBase",
+  "textures": {
+    "layer0":"bloodmagic:items/SeerSigil"
+  }
+}

src/main/resources/assets/bloodmagic/models/item/ItemSigilSuppression0.json

@@ -0,0 +1,6 @@
+{
+  "parent":"bloodmagic:item/ItemModelBase",
+  "textures": {
+    "layer0":"bloodmagic:items/SigilOfSuppression_deactivated"
+  }
+}

src/main/resources/assets/bloodmagic/models/item/ItemSigilSuppression1.json

@@ -0,0 +1,6 @@
+{
+  "parent":"bloodmagic:item/ItemModelBase",
+  "textures": {
+    "layer0":"bloodmagic:items/SigilOfSuppression_activated"
+  }
+}