Merge pull request #489 from Arcaratus/1.8-Rewrite

I'm tired and going to sleep

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

@@ -1,122 +1,151 @@
 package WayofTime.bloodmagic.altar;
 
 import WayofTime.bloodmagic.api.BlockStack;
-import WayofTime.bloodmagic.api.altar.AltarComponent;
+import WayofTime.bloodmagic.api.altar.*;
-import WayofTime.bloodmagic.api.altar.IAltarComponent;
+import WayofTime.bloodmagic.block.BlockBloodRune;
-import WayofTime.bloodmagic.api.altar.EnumAltarComponent;
+import WayofTime.bloodmagic.registry.ModBlocks;
-import WayofTime.bloodmagic.api.altar.EnumAltarTier;
 import net.minecraft.block.BlockBeacon;
 import net.minecraft.block.BlockGlowstone;
 import net.minecraft.init.Blocks;
 import net.minecraft.util.BlockPos;
 import net.minecraft.world.World;
 
-public class BloodAltar {
+import java.util.List;
 
-    public static EnumAltarTier getAltarTier(World world, BlockPos pos) {
+public class BloodAltar
+{
+
+    public static EnumAltarTier getAltarTier(World world, BlockPos pos)
+    {
         for (int i = EnumAltarTier.MAXTIERS; i >= 2; i--)
+        {
             if (checkAltarIsValid(world, pos, i))
+            {
                 return EnumAltarTier.values()[i];
+            }
+
+        }
 
         return EnumAltarTier.ONE;
     }
 
-    public static boolean checkAltarIsValid(World world, BlockPos worldPos, int altarTier) {
+    public static boolean checkAltarIsValid(World world, BlockPos worldPos, int altarTier)
-        for (AltarComponent altarComponent : EnumAltarTier.values()[altarTier].getAltarComponents()) {
+    {
+        for (AltarComponent altarComponent : EnumAltarTier.values()[altarTier].getAltarComponents())
+        {
 
             BlockPos componentPos = worldPos.add(altarComponent.getOffset());
             BlockStack worldBlock = new BlockStack(world.getBlockState(componentPos).getBlock(), world.getBlockState(componentPos).getBlock().getMetaFromState(world.getBlockState(componentPos)));
 
-            if (altarComponent.isBloodRune()) {
+            if (altarComponent.isBloodRune())
+            {
                 if (!checkRune(altarComponent, worldBlock))
+                {
                     return false;
-            } else {
+                }
+            }
+            else
+            {
                 if (((altarComponent.getBlockStack().getBlock() != worldBlock.getBlock()) || (altarComponent.getBlockStack().getMeta() != worldBlock.getMeta())) && (altarComponent.getBlockStack().getBlock() == Blocks.air && !world.isAirBlock(componentPos)))
+                {
                     if (!checkSpecials(altarComponent, worldBlock))
+                    {
                         return false;
+                    }
+                }
             }
         }
 
         return true;
     }
 
-//    public static AltarUpgrade getUpgrades(World world, BlockPos pos, int altarTier) {
+    public static AltarUpgrade getUpgrades(World world, BlockPos pos, int altarTier)
-//        if(world.isRemote)
+    {
-//            return null;
+        if (world.isRemote)
-//
+        {
-//        AltarUpgrade upgrades = new AltarUpgrade();
+            return null;
-//        List<AltarComponent> list = EnumAltarTier.values()[altarTier].getAltarComponents();
+        }
-//
-//        for (AltarComponent altarComponent : list) {
-//            BlockPos componentPos = pos.add(altarComponent.getOffset());
-//
-//            if (altarComponent.isUpgradeSlot()) {
-//                BlockStack worldBlock = new BlockStack(world.getBlockState(componentPos).getBlock(), world.getBlockState(componentPos).getBlock().getMetaFromState(world.getBlockState(componentPos)));
-//
-//                if (worldBlock.getBlock() instanceof BlockBloodRune) {
-//                    if (worldBlock.getBlock() instanceof IFadedRune && altarTier > ((IFadedRune)worldBlock.getBlock()).getAltarTierLimit(worldBlock.getMeta()))
-//                        return getUpgrades(world, pos, ((IFadedRune) worldBlock.getBlock()).getAltarTierLimit(worldBlock.getMeta()));
-//
-//                    switch (((BlockBloodRune) worldBlock.getBlock()).getRuneEffect(worldBlock.getMeta())) {
-//                        case 1:
-//                            upgrades.addSpeed();
-//                            break;
-//
-//                        case 2:
-//                            upgrades.addEfficiencyUpgrade();
-//                            break;
-//
-//                        case 3:
-//                            upgrades.addSacrificeUpgrade();
-//                            break;
-//
-//                        case 4:
-//                            upgrades.addSelfSacrificeUpgrade();
-//                            break;
-//
-//                        case 5:
-//                            upgrades.addaltarCapacitiveUpgrade();
-//                            break;
-//
-//                        case 6:
-//                            upgrades.addDisplacementUpgrade();
-//                            break;
-//
-//                        case 7:
-//                            upgrades.addorbCapacitiveUpgrade();
-//                            break;
-//
-//                        case 8:
-//                            upgrades.addBetterCapacitiveUpgrade();
-//                            break;
-//
-//                        case 9:
-//                            upgrades.addAccelerationUpgrade();
-//                            break;
-//                    }
-//                }
-//            }
-//        }
-//
-//        return upgrades;
-//    }
 
-    private static boolean checkRune(AltarComponent altarComponent, BlockStack blockStack) {
+        AltarUpgrade upgrades = new AltarUpgrade();
-//        if (altarComponent.getBlockStack().getBlock() == ModBlocks.rune)
+        List<AltarComponent> list = EnumAltarTier.values()[altarTier].getAltarComponents();
-//            if (blockStack.getBlock() instanceof BlockBloodRune || (blockStack.getBlock() instanceof IAltarComponent && (((IAltarComponent) blockStack.getBlock()).getType(blockStack.getMeta()) == EnumAltarComponent.BLOODRUNE)))
-//                return true;
 
+        for (AltarComponent altarComponent : list)
+        {
+            BlockPos componentPos = pos.add(altarComponent.getOffset());
+
+            if (altarComponent.isUpgradeSlot())
+            {
+                BlockStack worldBlock = new BlockStack(world.getBlockState(componentPos).getBlock(), world.getBlockState(componentPos).getBlock().getMetaFromState(world.getBlockState(componentPos)));
+
+                if (worldBlock.getBlock() instanceof BlockBloodRune)
+                {
+                    switch (((BlockBloodRune) worldBlock.getBlock()).getRuneEffect(worldBlock.getMeta()))
+                    {
+                        case 1:
+                            upgrades.addSpeed();
+                            break;
+
+                        case 2:
+                            upgrades.addEfficiency();
+                            break;
+
+                        case 3:
+                            upgrades.addSacrifice();
+                            break;
+
+                        case 4:
+                            upgrades.addSelfSacrifice();
+                            break;
+
+                        case 5:
+                            upgrades.addCapacity();
+                            break;
+
+                        case 6:
+                            upgrades.addDisplacement();
+                            break;
+
+                        case 7:
+                            upgrades.addOrbCapacity();
+                            break;
+
+                        case 8:
+                            upgrades.addBetterCapacity();
+                            break;
+
+                        case 9:
+                            upgrades.addAcceleration();
+                            break;
+                    }
+                }
+            }
+        }
+
+        return upgrades;
+    }
+
+    private static boolean checkRune(AltarComponent altarComponent, BlockStack blockStack)
+    {
+        if (altarComponent.getBlockStack().getBlock() == ModBlocks.blood_rune)
+        {
+            if (blockStack.getBlock() instanceof BlockBloodRune || (blockStack.getBlock() instanceof IAltarComponent && (((IAltarComponent) blockStack.getBlock()).getType(blockStack.getMeta()) == EnumAltarComponent.BLOODRUNE)))
+            {
+                return true;
+            }
+
+        }
         return false;
     }
 
-    private static boolean checkSpecials(AltarComponent altarComponent, BlockStack blockStack) {
+    private static boolean checkSpecials(AltarComponent altarComponent, BlockStack blockStack)
-//        if (altarComponent.getBlockStack().getBlock() == ModBlocks.bloodStone)
+    {
+        if (altarComponent.getBlockStack().getBlock() == ModBlocks.bloodStone)
 //            if (blockStack.getBlock() instanceof BlockBloodStone || (blockStack.getBlock() instanceof IAltarComponent && (((IAltarComponent) blockStack.getBlock()).getType(blockStack.getMeta()) == EnumAltarComponent.BLOODSTONE)))
-//                return true;
+                return true;
 
-//        if (altarComponent.getBlockStack().getBlock() == ModBlocks.crystal)
+        if (altarComponent.getBlockStack().getBlock() == ModBlocks.crystal)
 //            if (blockStack.getBlock() instanceof BlockCrystal || (blockStack.getBlock() instanceof IAltarComponent && (((IAltarComponent) blockStack.getBlock()).getType(blockStack.getMeta()) == EnumAltarComponent.CRYSTAL)))
-//                return true;
+                return true;
 
         if (altarComponent.getBlockStack().getBlock() == Blocks.glowstone)
             if (blockStack.getBlock() instanceof BlockGlowstone || (blockStack.getBlock() instanceof IAltarComponent && (((IAltarComponent) blockStack.getBlock()).getType(blockStack.getMeta()) == EnumAltarComponent.GLOWSTONE)))

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

@@ -3,18 +3,77 @@ package WayofTime.bloodmagic.api.altar;
 import lombok.Getter;
 
 @Getter
-public class AltarUpgrade {
+public class AltarUpgrade
-
+{
     private int speedCount;
+    private int efficiencyCount;
+    private int sacrificeCount;
+    private int selfSacrificeCount;
+    private int displacementCount;
+    private int capacityCount;
+    private int orbCapacityCount;
+    private int betterCapacityCount;
+    private int accelerationCount;
 
-    public AltarUpgrade() {
+    public AltarUpgrade()
+    {
 
     }
 
     // Adders
 
-    public AltarUpgrade addSpeed() {
+    public AltarUpgrade addSpeed()
+    {
         speedCount++;
         return this;
     }
+
+    public AltarUpgrade addEfficiency()
+    {
+        efficiencyCount++;
+        return this;
+    }
+
+    public AltarUpgrade addSacrifice()
+    {
+        sacrificeCount++;
+        return this;
+    }
+
+    public AltarUpgrade addSelfSacrifice()
+    {
+        selfSacrificeCount++;
+        return this;
+    }
+
+    public AltarUpgrade addDisplacement()
+    {
+        displacementCount++;
+        return this;
+    }
+
+    public AltarUpgrade addCapacity()
+    {
+        capacityCount++;
+        return this;
+    }
+
+    public AltarUpgrade addOrbCapacity()
+    {
+        orbCapacityCount++;
+        return this;
+    }
+
+    public AltarUpgrade addBetterCapacity()
+    {
+        betterCapacityCount++;
+        return this;
+    }
+
+    public AltarUpgrade addAcceleration()
+    {
+        accelerationCount++;
+        return this;
+    }
+
 }

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

@@ -14,28 +14,28 @@ public enum EnumAltarTier {
     TWO() {
         @Override
         public void buildComponents() {
-            altarComponents.add(new AltarComponent(new BlockPos(-1, -1, -1), ModBlocks.rune).setBloodRune());
+            altarComponents.add(new AltarComponent(new BlockPos(-1, -1, -1), ModBlocks.blood_rune).setBloodRune());
-            altarComponents.add(new AltarComponent(new BlockPos(0, -1, -1), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+            altarComponents.add(new AltarComponent(new BlockPos(0, -1, -1), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-            altarComponents.add(new AltarComponent(new BlockPos(1, -1, -1), ModBlocks.rune).setBloodRune());
+            altarComponents.add(new AltarComponent(new BlockPos(1, -1, -1), ModBlocks.blood_rune).setBloodRune());
-            altarComponents.add(new AltarComponent(new BlockPos(-1, -1, 0), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+            altarComponents.add(new AltarComponent(new BlockPos(-1, -1, 0), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-            altarComponents.add(new AltarComponent(new BlockPos(1, -1, 0), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+            altarComponents.add(new AltarComponent(new BlockPos(1, -1, 0), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-            altarComponents.add(new AltarComponent(new BlockPos(-1, -1, 1), ModBlocks.rune).setBloodRune());
+            altarComponents.add(new AltarComponent(new BlockPos(-1, -1, 1), ModBlocks.blood_rune).setBloodRune());
-            altarComponents.add(new AltarComponent(new BlockPos(0, -1, 1), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+            altarComponents.add(new AltarComponent(new BlockPos(0, -1, 1), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-            altarComponents.add(new AltarComponent(new BlockPos(1, -1, 1), ModBlocks.rune).setBloodRune());
+            altarComponents.add(new AltarComponent(new BlockPos(1, -1, 1), ModBlocks.blood_rune).setBloodRune());
         }
     },
     THREE() {
         @Override
         public void buildComponents() {
             altarComponents.addAll(TWO.getAltarComponents());
-            altarComponents.add(new AltarComponent(new BlockPos(-1, -1, -1), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+            altarComponents.add(new AltarComponent(new BlockPos(-1, -1, -1), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-            altarComponents.add(new AltarComponent(new BlockPos(0, -1, -1), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+            altarComponents.add(new AltarComponent(new BlockPos(0, -1, -1), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-            altarComponents.add(new AltarComponent(new BlockPos(1, -1, -1), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+            altarComponents.add(new AltarComponent(new BlockPos(1, -1, -1), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-            altarComponents.add(new AltarComponent(new BlockPos(-1, -1, 0), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+            altarComponents.add(new AltarComponent(new BlockPos(-1, -1, 0), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-            altarComponents.add(new AltarComponent(new BlockPos(1, -1, 0), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+            altarComponents.add(new AltarComponent(new BlockPos(1, -1, 0), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-            altarComponents.add(new AltarComponent(new BlockPos(-1, -1, 1), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+            altarComponents.add(new AltarComponent(new BlockPos(-1, -1, 1), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-            altarComponents.add(new AltarComponent(new BlockPos(0, -1, 1), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+            altarComponents.add(new AltarComponent(new BlockPos(0, -1, 1), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-            altarComponents.add(new AltarComponent(new BlockPos(1, -1, 1), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+            altarComponents.add(new AltarComponent(new BlockPos(1, -1, 1), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
             altarComponents.add(new AltarComponent(new BlockPos(-3, -1, -3)));
             altarComponents.add(new AltarComponent(new BlockPos(-3, 0, -3)));
             altarComponents.add(new AltarComponent(new BlockPos(3, -1, -3)));
@@ -50,10 +50,10 @@ public enum EnumAltarTier {
             altarComponents.add(new AltarComponent(new BlockPos(3, 1, 3), Blocks.glowstone));
 
             for (int i = -2; i <= 2; i++) {
-                altarComponents.add(new AltarComponent(new BlockPos(3, -2, i), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+                altarComponents.add(new AltarComponent(new BlockPos(3, -2, i), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-                altarComponents.add(new AltarComponent(new BlockPos(-3, -2, i), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+                altarComponents.add(new AltarComponent(new BlockPos(-3, -2, i), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-                altarComponents.add(new AltarComponent(new BlockPos(i, -2, 3), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+                altarComponents.add(new AltarComponent(new BlockPos(i, -2, 3), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-                altarComponents.add(new AltarComponent(new BlockPos(i, -2, -3), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+                altarComponents.add(new AltarComponent(new BlockPos(i, -2, -3), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
             }
         }
     },
@@ -63,10 +63,10 @@ public enum EnumAltarTier {
             altarComponents.addAll(THREE.getAltarComponents());
 
             for (int i = -3; i <= 3; i++) {
-                altarComponents.add(new AltarComponent(new BlockPos(5, -3, i), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+                altarComponents.add(new AltarComponent(new BlockPos(5, -3, i), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-                altarComponents.add(new AltarComponent(new BlockPos(-5, -3, i), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+                altarComponents.add(new AltarComponent(new BlockPos(-5, -3, i), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-                altarComponents.add(new AltarComponent(new BlockPos(i, -3, 5), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+                altarComponents.add(new AltarComponent(new BlockPos(i, -3, 5), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-                altarComponents.add(new AltarComponent(new BlockPos(i, -3, -5), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+                altarComponents.add(new AltarComponent(new BlockPos(i, -3, -5), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
             }
 
             for (int i = -2; i <= 1; i++) {
@@ -92,10 +92,10 @@ public enum EnumAltarTier {
             altarComponents.add(new AltarComponent(new BlockPos(8, -3, 8), Blocks.beacon));
 
             for (int i = -6; i <= 6; i++) {
-                altarComponents.add(new AltarComponent(new BlockPos(8, -4, i), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+                altarComponents.add(new AltarComponent(new BlockPos(8, -4, i), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-                altarComponents.add(new AltarComponent(new BlockPos(-8, -4, i), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+                altarComponents.add(new AltarComponent(new BlockPos(-8, -4, i), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-                altarComponents.add(new AltarComponent(new BlockPos(i, -4, 8), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+                altarComponents.add(new AltarComponent(new BlockPos(i, -4, 8), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-                altarComponents.add(new AltarComponent(new BlockPos(i, -4, -8), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+                altarComponents.add(new AltarComponent(new BlockPos(i, -4, -8), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
             }
         }
     },
@@ -117,10 +117,10 @@ public enum EnumAltarTier {
             altarComponents.add(new AltarComponent(new BlockPos(-11, 3, 11), ModBlocks.crystal));
 
             for (int i = -9; i <= 9; i++) {
-                altarComponents.add(new AltarComponent(new BlockPos(11, -5, i), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+                altarComponents.add(new AltarComponent(new BlockPos(11, -5, i), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-                altarComponents.add(new AltarComponent(new BlockPos(-11, -5, i), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+                altarComponents.add(new AltarComponent(new BlockPos(-11, -5, i), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-                altarComponents.add(new AltarComponent(new BlockPos(i, -5, 11), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+                altarComponents.add(new AltarComponent(new BlockPos(i, -5, 11), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
-                altarComponents.add(new AltarComponent(new BlockPos(i, -5, -11), ModBlocks.rune).setUpgradeSlot().setBloodRune());
+                altarComponents.add(new AltarComponent(new BlockPos(i, -5, -11), ModBlocks.blood_rune).setUpgradeSlot().setBloodRune());
             }
         }
     };

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

@@ -0,0 +1,102 @@
+package WayofTime.bloodmagic.block;
+
+import WayofTime.bloodmagic.registry.ModBlocks;
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.block.properties.PropertyInteger;
+import net.minecraft.block.state.BlockState;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import java.util.List;
+
+public class BlockBloodRune extends Block
+{
+    public static final String[] names = { "speed", "efficiency", "sacrifice", "self_sacrifice", "displacement", "capacity", "orb_capacity", "better_capacity", "acceleration" };
+    public static final PropertyInteger INTEGER = PropertyInteger.create("rune", 0, 5);
+
+    public BlockBloodRune()
+    {
+        super(Material.iron);
+        this.setDefaultState(this.blockState.getBaseState().withProperty(INTEGER, 0));
+        setHardness(2.0F);
+        setResistance(5.0F);
+    }
+
+    public int getRuneEffect(int metaData)
+    {
+        switch (metaData)
+        {
+            case 0:
+                return 0;
+
+            case 1: //Altar Capacity rune
+                return 5;
+
+            case 2: //Filling/emptying rune
+                return 6;
+
+            case 3: //Orb Capacity rune
+                return 7;
+
+            case 4: //Better Capacity rune
+                return 8;
+
+            case 5: //Acceleration rune
+                return 9;
+        }
+
+        return 0;
+    }
+
+    @Override
+    protected BlockState createBlockState()
+    {
+        return new BlockState(this, INTEGER);
+    }
+
+    @Override
+    public IBlockState getStateFromMeta(int meta)
+    {
+        return this.getDefaultState().withProperty(INTEGER, meta);
+    }
+
+    @Override
+    public int getMetaFromState(IBlockState state)
+    {
+        return ((Integer)state.getValue(INTEGER)).intValue();
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+
+    /**
+     * returns a list of items with the same ID, but different meta (eg: dye returns 16 items)
+     */
+    public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List par3List)
+    {
+        if (this.equals(ModBlocks.blood_rune))
+        {
+            par3List.add(new ItemStack(par1, 1, 0));
+            par3List.add(new ItemStack(par1, 1, 1));
+            par3List.add(new ItemStack(par1, 1, 2));
+            par3List.add(new ItemStack(par1, 1, 3));
+            par3List.add(new ItemStack(par1, 1, 4));
+            par3List.add(new ItemStack(par1, 1, 5));
+        }
+        else
+        {
+            super.getSubBlocks(par1, par2CreativeTabs, par3List);
+        }
+    }
+
+    @Override
+    public int damageDropped(IBlockState blockState)
+    {
+        return blockState.getBlock().damageDropped(blockState);
+    }
+}

src/main/java/WayofTime/bloodmagic/item/block/ItemBlockBloodRune.java

@@ -0,0 +1,26 @@
+package WayofTime.bloodmagic.item.block;
+
+import WayofTime.bloodmagic.block.BlockBloodRune;
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+
+public class ItemBlockBloodRune extends ItemBlock
+{
+    public ItemBlockBloodRune(Block block)
+    {
+        super(block);
+        setHasSubtypes(true);
+    }
+
+    @Override
+    public String getUnlocalizedName(ItemStack stack)
+    {
+        return super.getUnlocalizedName(stack) + BlockBloodRune.names[stack.getItemDamage()];
+    }
+
+    @Override
+    public int getMetadata(int meta) {
+        return meta;
+    }
+}

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

@@ -3,8 +3,10 @@ package WayofTime.bloodmagic.registry;
 import WayofTime.bloodmagic.BloodMagic;
 import WayofTime.bloodmagic.ConfigHandler;
 import WayofTime.bloodmagic.block.BlockAltar;
+import WayofTime.bloodmagic.block.BlockBloodRune;
 import WayofTime.bloodmagic.block.BlockLifeEssence;
 import WayofTime.bloodmagic.block.BlockRitualController;
+import WayofTime.bloodmagic.item.block.ItemBlockBloodRune;
 import WayofTime.bloodmagic.item.block.ItemBlockRitualController;
 import WayofTime.bloodmagic.tile.TileImperfectRitualStone;
 import WayofTime.bloodmagic.tile.TileMasterRitualStone;
@@ -14,52 +16,65 @@ import net.minecraft.item.ItemBlock;
 import net.minecraftforge.fluids.FluidRegistry;
 import net.minecraftforge.fml.common.registry.GameRegistry;
 
-public class ModBlocks {
+public class ModBlocks
-
+{
     public static Block altar;
+    public static Block blood_rune;
     public static Block ritualStone;
 
     public static Block lifeEssence;
 
     public static Block crystal;
-    public static Block rune;
     public static Block bloodStone;
 
-    public static void init() {
+    public static void init()
+    {
         FluidRegistry.registerFluid(BlockLifeEssence.getLifeEssence());
         lifeEssence = registerBlock(new BlockLifeEssence());
 
         altar = registerBlock(new BlockAltar());
+        blood_rune = registerBlock(new BlockBloodRune(), ItemBlockBloodRune.class);
         ritualStone = registerBlock(new BlockRitualController(), ItemBlockRitualController.class);
 
         initTiles();
     }
 
-    public static void initTiles() {
+    public static void initTiles()
+    {
         GameRegistry.registerTileEntity(TileImperfectRitualStone.class, BloodMagic.MODID + ":" + TileImperfectRitualStone.class.getSimpleName());
         GameRegistry.registerTileEntity(TileMasterRitualStone.class, BloodMagic.MODID + ":" + TileMasterRitualStone.class.getSimpleName());
     }
 
-    public static void initRenders() {
+    public static void initRenders()
+    {
         InventoryRenderHelper renderHelper = BloodMagic.instance.getRenderHelper();
 
         renderHelper.fluidRender(lifeEssence);
+        renderHelper.itemRender(InventoryRenderHelper.getItemFromBlock(blood_rune), 0);
+        renderHelper.itemRender(InventoryRenderHelper.getItemFromBlock(blood_rune), 1);
+        renderHelper.itemRender(InventoryRenderHelper.getItemFromBlock(blood_rune), 2);
+        renderHelper.itemRender(InventoryRenderHelper.getItemFromBlock(blood_rune), 3);
+        renderHelper.itemRender(InventoryRenderHelper.getItemFromBlock(blood_rune), 4);
+        renderHelper.itemRender(InventoryRenderHelper.getItemFromBlock(blood_rune), 5);
         renderHelper.itemRender(InventoryRenderHelper.getItemFromBlock(ritualStone), 0);
         renderHelper.itemRender(InventoryRenderHelper.getItemFromBlock(ritualStone), 1);
     }
 
-    private static Block registerBlock(Block block, Class<? extends ItemBlock> itemBlock, String name) {
+    private static Block registerBlock(Block block, Class<? extends ItemBlock> itemBlock, String name)
+    {
         if (!ConfigHandler.blockBlacklist.contains(name))
             GameRegistry.registerBlock(block, itemBlock, name);
 
         return block;
     }
 
-    private static Block registerBlock(Block block, Class<? extends ItemBlock> itemBlock) {
+    private static Block registerBlock(Block block, Class<? extends ItemBlock> itemBlock)
+    {
         return registerBlock(block, itemBlock, block.getClass().getSimpleName());
     }
 
-    private static Block registerBlock(Block block, String name) {
+    private static Block registerBlock(Block block, String name)
+    {
         if (!ConfigHandler.blockBlacklist.contains(name))
             GameRegistry.registerBlock(block, name);
 

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

@@ -1,74 +1,93 @@
 package WayofTime.bloodmagic.tile;
 
+import WayofTime.bloodmagic.altar.BloodAltar;
 import WayofTime.bloodmagic.api.BloodMagicAPI;
+import WayofTime.bloodmagic.api.altar.AltarRecipe;
 import WayofTime.bloodmagic.api.altar.AltarUpgrade;
+import WayofTime.bloodmagic.api.altar.EnumAltarTier;
+import WayofTime.bloodmagic.api.registry.AltarRecipeRegistry;
 import net.minecraft.server.gui.IUpdatePlayerListBox;
 import net.minecraft.util.EnumFacing;
 import net.minecraftforge.fluids.*;
 
-public class TileAltar extends TileInventory implements IUpdatePlayerListBox, IFluidTank, IFluidHandler {
+public class TileAltar extends TileInventory implements IUpdatePlayerListBox, IFluidTank, IFluidHandler
-
+{
     private int tier;
     private AltarUpgrade upgrade = new AltarUpgrade();
     private FluidStack fluid = new FluidStack(BloodMagicAPI.getLifeEssence(), 0);
     private int capacity;
 
-    public TileAltar() {
+    public TileAltar()
+    {
         super(1, "altar");
 
         this.capacity = 10000;
     }
 
-
-
     @Override
-    public void update() {}
+    public void update()
+    {
+        if (getWorld().isRemote)
+        {
+            return;
+        }
 
-//    @Override
+        if (getWorld().getTotalWorldTime() % (Math.max(20 - getUpgrade().getSpeedCount(), 1)) == 0)
-//    public void update() {
+        {
-//        if (getWorld().isRemote)
+            everySecond();
-//            return;
+        }
-//
-//        if (getWorld().getTotalWorldTime() % (Math.max(20 - getUpgrade().getSpeedCount(), 1)) == 0) {
-//            everySecond();
-//        }
-//
-//        if (getWorld().getTotalWorldTime() % 100 == 0) {
-//            everyFiveSeconds();
-//        }
-//    }
-//
-//    private void everySecond() {
-//
-//        // Do recipes
-//        if (AltarRecipeRegistry.getRecipes().containsKey(getStackInSlot(0))) {
-//            AltarRecipe recipe = AltarRecipeRegistry.getRecipeForInput(getStackInSlot(0));
-//
-//            if (!(tier >= recipe.minTier))
-//                return;
-//
-//
-//        }
-//    }
-//
-//    private void everyFiveSeconds() {
-//        checkTier();
-//    }
-//
-//    private void checkTier() {
-//        // TODO - Write checking for tier stuff
-//    }
 
-    public TileAltar setUpgrade(AltarUpgrade upgrade) {
+        if (getWorld().getTotalWorldTime() % 100 == 0)
+        {
+            everyFiveSeconds();
+        }
+    }
+
+    private void everySecond()
+    {
+        // Do recipes
+        if (AltarRecipeRegistry.getRecipes().containsKey(getStackInSlot(0)))
+        {
+            AltarRecipe recipe = AltarRecipeRegistry.getRecipeForInput(getStackInSlot(0));
+
+            if (!(tier >= recipe.minTier))
+            {
+                return;
+            }
+        }
+    }
+
+    private void everyFiveSeconds()
+    {
+        checkTier();
+    }
+
+    private void checkTier()
+    {
+        // TODO - Write checking for tier stuff
+
+        EnumAltarTier tier = BloodAltar.getAltarTier(getWorld(), getPos());
+
+        if (tier.equals(EnumAltarTier.ONE))
+        {
+            upgrade = new AltarUpgrade();
+            return;
+        }
+    }
+
+    public TileAltar setUpgrade(AltarUpgrade upgrade)
+    {
         this.upgrade = upgrade;
         return this;
     }
 
-    public AltarUpgrade getUpgrade() {
+    public AltarUpgrade getUpgrade()
+    {
         return upgrade;
     }
 
-    public TileAltar setTier(int tier) {
+    public TileAltar setTier(int tier)
+    {
         this.tier = tier;
         return this;
     }