As of the 1.8 update logs changed. A LOT!

How would one create a custom log in 1.8?

 

Thanks in advance,

- Busti

Class for the log

package mw.blocks;

import java.util.List;

import com.google.common.base.Predicate;

import mw.core.MWTabs;
import mw.core.utils.Utils;
import net.minecraft.block.BlockLog;
import net.minecraft.block.properties.IProperty;
import net.minecraft.block.properties.PropertyEnum;
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;

public class BlockLogMW extends BlockLog
{
    public static final PropertyEnum VARIANT = PropertyEnum.create("variant", BlockPlanksMW.EnumType.class, new Predicate()
    {
        public boolean apply(BlockPlanksMW.EnumType type)
        {
            return type.getMetadata() < 4;
        }
        public boolean apply(Object p_apply_1_)
        {
            return this.apply((BlockPlanksMW.EnumType)p_apply_1_);
        }
    });

    public BlockLogMW()
    {
        this.setDefaultState(this.blockState.getBaseState().withProperty(VARIANT, BlockPlanksMW.EnumType.APPLE).withProperty(LOG_AXIS, BlockLog.EnumAxis.Y));
        this.setCreativeTab(MWTabs.tabBlock);
	Utils.setBlockInfo(this, "log", 2.0F, 5.0F);
    }

    /**
     * returns a list of blocks with the same ID, but different meta (eg: wood returns 4 blocks)
     */
    @SideOnly(Side.CLIENT)
    public void getSubBlocks(Item itemIn, CreativeTabs tab, List list)
    {
        list.add(new ItemStack(itemIn, 1, BlockPlanksMW.EnumType.APPLE.getMetadata()));
        list.add(new ItemStack(itemIn, 1, BlockPlanksMW.EnumType.PALM.getMetadata()));
    }

    /**
     * Convert the given metadata into a BlockState for this Block
     */
    public IBlockState getStateFromMeta(int meta)
    {
        IBlockState iblockstate = this.getDefaultState().withProperty(VARIANT, BlockPlanksMW.EnumType.byMetadata((meta & 3) % 4));

        switch (meta & 12)
        {
            case 0:
                iblockstate = iblockstate.withProperty(LOG_AXIS, BlockLog.EnumAxis.Y);
                break;
            case 4:
                iblockstate = iblockstate.withProperty(LOG_AXIS, BlockLog.EnumAxis.X);
                break;
            case 8:
                iblockstate = iblockstate.withProperty(LOG_AXIS, BlockLog.EnumAxis.Z);
                break;
            default:
                iblockstate = iblockstate.withProperty(LOG_AXIS, BlockLog.EnumAxis.NONE);
        }

        return iblockstate;
    }

    /**
     * Convert the BlockState into the correct metadata value
     */
    public int getMetaFromState(IBlockState state)
    {
        byte b0 = 0;
        int i = b0 | ((BlockPlanksMW.EnumType)state.getValue(VARIANT)).getMetadata();

        switch (BlockLogMW.SwitchEnumAxis.AXIS_LOOKUP[((BlockLogMW.EnumAxis)state.getValue(LOG_AXIS)).ordinal()])
        {
            case 1:
                i |= 4;
                break;
            case 2:
                i |= 8;
                break;
            case 3:
                i |= 12;
        }

        return i;
    }

    protected BlockState createBlockState()
    {
        return new BlockState(this, new IProperty[] {VARIANT, LOG_AXIS});
    }

    protected ItemStack createStackedBlock(IBlockState state)
    {
        return new ItemStack(Item.getItemFromBlock(this), 1, ((BlockPlanksMW.EnumType)state.getValue(VARIANT)).getMetadata());
    }

    /**
     * Get the damage value that this Block should drop
     */
    public int damageDropped(IBlockState state)
    {
        return ((BlockPlanksMW.EnumType)state.getValue(VARIANT)).getMetadata();
    }

    static final class SwitchEnumAxis
        {
            static final int[] AXIS_LOOKUP = new int[blockLog.EnumAxis.values().length];

            static
            {
                try
                {
                    AXIS_LOOKUP[blockLog.EnumAxis.X.ordinal()] = 1;
                }
                catch (NoSuchFieldError var3)
                {
                    ;
                }

                try
                {
                    AXIS_LOOKUP[blockLog.EnumAxis.Z.ordinal()] = 2;
                }
                catch (NoSuchFieldError var2)
                {
                    ;
                }

                try
                {
                    AXIS_LOOKUP[blockLog.EnumAxis.NONE.ordinal()] = 3;
                }
                catch (NoSuchFieldError var1)
                {
                    ;
                }
            }
        }
}

 

Class for the planks (where it takes the variants, you could also do this in the log file)

package mw.blocks;

import java.util.List;

import mw.core.MWTabs;
import mw.core.utils.Utils;
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.BlockState;
import net.minecraft.block.state.IBlockState;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.IStringSerializable;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

public class BlockPlanksMW extends Block
{
    public static final PropertyEnum VARIANT = PropertyEnum.create("variant", BlockPlanksMW.EnumType.class);

    public BlockPlanksMW()
    {
        super(Material.wood);
        this.setDefaultState(this.blockState.getBaseState().withProperty(VARIANT, BlockPlanksMW.EnumType.APPLE));
        this.setCreativeTab(MWTabs.tabBlock);
        Utils.setBlockInfo(this, "planks", 1.5F, 10.0F);
    }

    /**
     * Get the damage value that this Block should drop
     */
    public int damageDropped(IBlockState state)
    {
        return ((BlockPlanksMW.EnumType)state.getValue(VARIANT)).getMetadata();
    }

    /**
     * returns a list of blocks with the same ID, but different meta (eg: wood returns 4 blocks)
     */
    @SideOnly(Side.CLIENT)
    public void getSubBlocks(Item itemIn, CreativeTabs tab, List list)
    {
        BlockPlanksMW.EnumType[] aenumtype = BlockPlanksMW.EnumType.values();
        int i = aenumtype.length;

        for (int j = 0; j < i; ++j)
        {
            BlockPlanksMW.EnumType enumtype = aenumtype[j];
            list.add(new ItemStack(itemIn, 1, enumtype.getMetadata()));
        }
    }

    /**
     * Convert the given metadata into a BlockState for this Block
     */
    public IBlockState getStateFromMeta(int meta)
    {
        return this.getDefaultState().withProperty(VARIANT, BlockPlanksMW.EnumType.byMetadata(meta));
    }

    /**
     * Convert the BlockState into the correct metadata value
     */
    public int getMetaFromState(IBlockState state)
    {
        return ((BlockPlanksMW.EnumType)state.getValue(VARIANT)).getMetadata();
    }

    protected BlockState createBlockState()
    {
        return new BlockState(this, new IProperty[] {VARIANT});
    }

    public static enum EnumType implements IStringSerializable
    {
        APPLE(0, "apple"),
        PALM(1, "palm");
        private static final BlockPlanksMW.EnumType[] META_LOOKUP = new BlockPlanksMW.EnumType[values().length];
        private final int meta;
        private final String name;
        private final String unlocalizedName;


        private EnumType(int meta, String name)
        {
            this(meta, name, name);
        }

        private EnumType(int meta, String name, String unlocalizedName)
        {
            this.meta = meta;
            this.name = name;
            this.unlocalizedName = unlocalizedName;
        }

        public int getMetadata()
        {
            return this.meta;
        }

        public String toString()
        {
            return this.name;
        }

        public static BlockPlanksMW.EnumType byMetadata(int meta)
        {
            if (meta < 0 || meta >= META_LOOKUP.length)
            {
                meta = 0;
            }

            return META_LOOKUP[meta];
        }

        public String getName()
        {
            return this.name;
        }

        public String getUnlocalizedName()
        {
            return this.unlocalizedName;
        }

        static
        {
            BlockPlanksMW.EnumType[] var0 = values();
            int var1 = var0.length;

            for (int var2 = 0; var2 < var1; ++var2)
            {
                BlockPlanksMW.EnumType var3 = var0[var2];
                META_LOOKUP[var3.getMetadata()] = var3;
            }
        }
    }
}

 

Creating the block

public static Block log;
log = new BlockLogMW();
RenderItem renderItem = Minecraft.getMinecraft().getRenderItem();
GameRegistry.registerBlock(log, ItemLog.class, renderItem);
ModelBakery.addVariantName(Item.getItemFromBlock(block), new String[]{MW.MODID + ":" + "log_apple", MW.MODID + ":" + "log_palm"});
		renderItem.getItemModelMesher().register(Item.getItemFromBlock(block), 0, new ModelResourceLocation(MW.MODID + ":" + "log_apple", "inventory"));
		renderItem.getItemModelMesher().register(Item.getItemFromBlock(block), 1, new ModelResourceLocation(MW.MODID + ":" + "log_palm", "inventory"));

And the last class you need, the ItemLog class

package mw.blocks.itemblocks;

import net.minecraft.block.Block;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemStack;

public class ItemLog extends ItemBlock {

private final static String[] subNames = {
	"apple", "palm"
};

public ItemLog(Block id) {
	super(id);
	setHasSubtypes(true);
}

@Override
public int getMetadata (int damageValue) {
	return damageValue;
}

@Override
public String getUnlocalizedName(ItemStack itemstack) {
	return "tile.log_" + subNames[itemstack.getItemDamage()] ;
}
}

 

Then the .json files

Blockstate file

{
    "variants": {
        "axis=y,variant=apple":  { "model": "mw:apple_log" },
        "axis=z,variant=apple":   { "model": "mw:apple_log_side" },
        "axis=x,variant=apple":   { "model": "mw:apple_log_side", "y": 90 },
        "axis=none,variant=apple": { "model": "mw:apple_bark" },
	"axis=y,variant=palm":  { "model": "mw:palm_log" },
        "axis=z,variant=palm":   { "model": "mw:palm_log_side" },
        "axis=x,variant=palm":   { "model": "mw:palm_log_side", "y": 90 },
        "axis=none,variant=palm": { "model": "mw:palm_bark" }
    }
}

 

Item model file (you need to do ONE for every variant, in this case one for the apple variant and one for the palm variant)

{
    "parent": "mw:block/apple_log",
    "display": {
        "thirdperson": {
            "rotation": [ 10, -45, 170 ],
            "translation": [ 0, 1.5, -2.75 ],
            "scale": [ 0.375, 0.375, 0.375 ]
        }
    }
}

 

Block model file (You need to do 3 models file for each variant, so if you have like in this case 2 variants you need to do 3 files for the apple variant and 3 for the palm variant)

Normal file (example: apple_log)

{
    "parent": "block/cube_column",
    "textures": {
        "end": "mw:blocks/log_apple_top",
        "side": "mw:blocks/log_apple"
    }
}

Block model side file (example: apple_log_side)

{
    "parent": "block/column_side",
    "textures": {
        "end": "mw:blocks/log_apple_top",
        "side": "mw:blocks/log_apple"
    }
}

Block model bark side (the log without the top) (example: apple_log_bark)

{
    "parent": "block/cube_all",
    "textures": {
        "all": "mw:blocks/log_apple"
    }
}

If you have doubts about this 3 files just look the blockstate file and you will understand

Wow thanks that would have taken hours to figure it out myself!