Blockores help

package com.hobos.objects.blocks;

import java.util.Random;

import com.hobos.Main;
import com.hobos.init.BlockInit;
import com.hobos.init.ItemInit;
import com.hobos.objects.blocks.item.ItemBlockVariants;
import com.hobos.util.handlers.EnumHandler;
import com.hobos.util.handlers.EnumHandler.EnumType;
import com.hobos.util.interfaces.IHasModel;
import com.hobos.util.interfaces.IMetaName;

import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.block.properties.IProperty;
import net.minecraft.block.properties.PropertyEnum;
import net.minecraft.block.state.BlockStateContainer;
import net.minecraft.block.state.IBlockState;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.NonNullList;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.RayTraceResult;
import net.minecraft.world.World;


public class BlockOres extends Block implements IHasModel, IMetaName{

    public static final PropertyEnum<EnumHandler.EnumType> VARIANT = PropertyEnum.<EnumHandler.EnumType>create("variant", EnumHandler.EnumType.class);


    private String name, dimension;

    public BlockOres(String name, String dimension) {

        super(Material.ROCK);
        setUnlocalizedName(name);
        setRegistryName(name);
        setCreativeTab(CreativeTabs.BUILDING_BLOCKS);
        setDefaultState(this.blockState.getBaseState().withProperty(VARIANT, EnumHandler.EnumType.WATER));
        setDefaultState(this.blockState.getBaseState().withProperty(VARIANT, EnumHandler.EnumType.FIRE));
        setDefaultState(this.blockState.getBaseState().withProperty(VARIANT, EnumHandler.EnumType.ICE));
        setDefaultState(this.blockState.getBaseState().withProperty(VARIANT, EnumHandler.EnumType.NATURE));
        setDefaultState(this.blockState.getBaseState().withProperty(VARIANT, EnumHandler.EnumType.EARTH));
        setDefaultState(this.blockState.getBaseState().withProperty(VARIANT, EnumHandler.EnumType.METAL));

        this.name = name;
        this.dimension = dimension;

        BlockInit.BLOCKS.add(this);
        ItemInit.ITEMS.add(new ItemBlockVariants(this).setRegistryName(this.getRegistryName()));

    }

    @Override
    public int damageDropped(IBlockState state) {

        return ((EnumHandler.EnumType)state.getValue(VARIANT)).getMeta();
    }

    @Override
    public int getMetaFromState(IBlockState state) {

        return ((EnumHandler.EnumType)state.getValue(VARIANT)).getMeta();
    }

    @Override
    public IBlockState getStateFromMeta(int meta) {

        return this.getDefaultState().withProperty(VARIANT, EnumHandler.EnumType.byMetaData(meta));
    }

    @Override
    public ItemStack getPickBlock(IBlockState state, RayTraceResult target, World world, BlockPos pos,
            EntityPlayer player) {

        return new ItemStack(Item.getItemFromBlock(this), 1, getMetaFromState(world.getBlockState(pos)));
    }

    @Override
    public void getSubBlocks(CreativeTabs itemIn, NonNullList<ItemStack> items) {

        for(EnumHandler.EnumType variant : EnumHandler.EnumType.values()){

            items.add(new ItemStack(this, 1, variant.getMeta()));

        }
    }


    @Override
    protected BlockStateContainer createBlockState() {

        return new BlockStateContainer(this, new IProperty[] {VARIANT} );

    }

    @Override
    public String getSpecialName(ItemStack stack) {

        return EnumHandler.EnumType.values()[stack.getItemDamage()].getName();
    }

    @Override
    public void registerModels() {

        for(int i = 0; i < EnumHandler.EnumType.values().length; i++){

            Main.proxy.registerVariantRenderer(Item.getItemFromBlock(this), i, "ore_" + this.dimension + "_" + EnumHandler.EnumType.values()[i].getName(), "inventory");
        }

    }

    @Override
    public Item getItemDropped(IBlockState state, Random rand, int fortune){

        if(state == this.getDefaultState().withProperty(VARIANT, EnumHandler.EnumType.FIRE)){
            return ItemInit.FIRE_MANA_NUGGET;
        }

        if(state == this.getDefaultState().withProperty(VARIANT, EnumHandler.EnumType.WATER)){
            return ItemInit.WATER_MANA_NUGGET;
        }

        if(state == this.getDefaultState().withProperty(VARIANT, EnumHandler.EnumType.ICE)){
            return ItemInit.ICE_MANA_NUGGET;
        }

        if(state == this.getDefaultState().withProperty(VARIANT, EnumHandler.EnumType.METAL)){
            return ItemInit.METAL_MANA_NUGGET;
        }

        if(state == this.getDefaultState().withProperty(VARIANT, EnumHandler.EnumType.NATURE)){
            return ItemInit.NATURE_MANA_NUGGET;
        }

        if(state == this.getDefaultState().withProperty(VARIANT, EnumHandler.EnumType.EARTH)){
            return ItemInit.EARTH_MANA_NUGGET;
        }

        return Item.getItemFromBlock(this);

    }

    @Override
    public int quantityDropped(IBlockState state, int fortune, Random random)
    {
        if(state.getValue(VARIANT) == EnumType.FIRE)
        {
            return 2 + random.nextInt(4 - 2 + fortune + 1);
        }
        if(state.getValue(VARIANT) == EnumType.WATER)
        {
            return 2 + random.nextInt(4 - 2 + fortune + 1);
        }
        if(state.getValue(VARIANT) == EnumType.ICE)
        {
            return 2 + random.nextInt(4 - 2 + fortune + 1);
        }
        if(state.getValue(VARIANT) == EnumType.EARTH)
        {
            return 2 + random.nextInt(4 - 2 + fortune + 1);
        }
        if(state.getValue(VARIANT) == EnumType.METAL)
        {
            return 2 + random.nextInt(4 - 2 + fortune + 1);
        }
        if(state.getValue(VARIANT) == EnumType.NATURE)
        {
            return 2 + random.nextInt(4 - 2 + fortune + 1);
        }

        return fortune + 1;
    }

}