[1.8.9][UNSOLVED] Can't get half-slabs to turn into double slabs

[SuperGeniusZeb]

UPDATED 2-9-2016: The game launches, and the slabs sort of work. At this point I haven't created any model,texture, or other .json files for any of the slabs, and neither have I put them in the .lang file. The half-slabs can be placed like regular slabs, and act normal, except that they can't be stacked. Both the regular and the double slabs show up in the creative tab I have created for them, though the double slabs shouldn't be there. Both the half and double variants of the slabs have the same name in the creative menu. (For example, the slab_of_red with a SHADE state of "NORMAL" shows as tile.slab_of_red.normal.name, and its double variant shows with the exact same name, but when viewed in F3+H mode, you can see their actual code names of colore:slab_of_red and colore:slab_of_red_double... I'm not sure if this is normal or not, as I have not tried to create any .json files or textures yet.)

 

Using: Latest version of Forge for 1.8.9 and latest JDK 8.

 

So I've been working on my first mod, Colore, which adds monochrome blocks and items and such. I was trying to implement slabs, but I've been having to stop coding for long periods of time only to come back and be lost, and none of the examples or tutorials I've found have really explained everything to me that well. I know how slabs work in game (they're 2 different blocks: a half-slab block with at least 2 blockstates and a double slab block that's basically just a normal block that drops 2 of the former) and that you're supposed to have an abstract slab class (BlockColoreSlab), a half slab class (BlockColoreSlabHalf), a double slab class (BlockColoreSlabDouble), and an item-block class (ItemBlockColoreSlab), but I have no idea how to get them working right. I have the metadata on the slabs set up with 2 properties: "SHADE" and "HALF". "SHADE" has 5 different values: normal, light, lighter, dark, and darker, and "HALF" has, of course, just 2 values and determines whether the block is a top slab of bottom slab (if it is even a half slab.) So for example I'm trying to add a Slab of Red that uses the metadata to determine both the color and which type of slab it is. (Values 0-4 are bottom slabs and 5-9 are top slabs. Double slabs just have values 0-4.)

 

I don't have any prior experience in modding slabs in any version, and honestly, I feel like I'm starting to get lost in my own code now. Every tutorial/example I've seen seems to do things in an unusual or complicated way that is unnecessary for my purposes, and it's really hard to tell what I'm doing wrong.

 

Anyway, here are the slab classes and the classes I use to register my blocks. If you need to see any more, just let me know. See the top of the post for the current state of how things are working. (I'll update it as I fix things and make progress...)

 

BlockColoreSlab (abstract slab class):

package com.supergeniuszeb.colore.common.blocks;

import net.minecraft.block.Block;
import net.minecraft.block.BlockSlab;
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.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.BlockPos;
import net.minecraft.util.IStringSerializable;
import net.minecraft.util.MovingObjectPosition;
import net.minecraft.world.World;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

import com.supergeniuszeb.colore.common.registry.CreativeTabRegistry;

//An abstract class for both half-slabs and full/double slabs.
public abstract class BlockColoreSlab extends BlockSlab implements IMetaBlockName{

public BlockColoreSlab(String unlocalizedName) {
	super(Material.rock);
	this.setHardness(1.5f);
	this.setHarvestLevel("pickaxe", 0);
	this.setResistance(10.0f);
	this.setUnlocalizedName(unlocalizedName);
	this.useNeighborBrightness = !this.isDouble();
	if (!this.isDouble()) {
            this.setCreativeTab(CreativeTabRegistry.slabTab);
        }

	//Sets default state depending on whether block is a half-slab or double-slab.
	IBlockState blockState = this.blockState.getBaseState();
        blockState = blockState.withProperty(SHADE, EnumShade.NORMAL);
        if (!this.isDouble()) {
            blockState = blockState.withProperty(HALF, EnumBlockHalf.BOTTOM);
        }

        this.setDefaultState(blockState);
}

public enum EnumShade implements IStringSerializable {
	NORMAL(0, "normal"),
	LIGHT(1, "light"),
	LIGHTER(2, "lighter"),
	DARK(3, "dark"),
	DARKER(4, "darker");

	private int ID;
	private String name;

	private EnumShade(int ID, String name) {
		this.ID = ID;
		this.name = name;
	}

	@Override
	public String getName() {
		return name;
	}

	@Override
	public String toString() {
		return getName();
	}

	public int getID() {
        return ID;
    }

}

//The shade ("light", "dark", etc.) of the slab. The "HALF" property is defined in the vanilla BlockSlab class so I don't need to make my own.
public static final PropertyEnum SHADE = PropertyEnum.create("shade", BlockColoreSlab.EnumShade.class);

//Function to get the variant property created above based on the item.
@Override
public final Object getVariant(final ItemStack itemstack) {
	return itemstack.getMetadata();
}

//Function to get the variant property.
@Override
public final IProperty getVariantProperty() {
	return SHADE;
}

@SideOnly(Side.CLIENT)
    @Override
    public final net.minecraft.item.Item getItem(
        final net.minecraft.world.World world,
        final net.minecraft.util.BlockPos blockPos) {
        String blockId = this.getUnlocalizedName();
        return Item.getItemFromBlock(Block.getBlockFromName(blockId));
    }

@Override
protected BlockState createBlockState() {
	return new BlockState(this, new IProperty[] {SHADE, HALF});
}

//Converts an IBlockState into metadata.
@Override
public IBlockState getStateFromMeta(int meta) {

	//A blockState is created, which is assigned the SHADE property depending on its metadata, as well as the HALF property, if it is a half-slab.
	IBlockState blockState = this.getDefaultState();

	if (!this.isDouble()) { //If the block is a BlockColoreHalfSlab
		switch (meta) {
			case 0:
				blockState = blockState.withProperty(SHADE, EnumShade.NORMAL).withProperty(HALF, EnumBlockHalf.BOTTOM);
				break; //Note-to-self: NEVER EVER FORGET TO USE THIS IF RETURN STATEMENTS AREN'T INVOLVED!
			case 1:
				blockState = blockState.withProperty(SHADE, EnumShade.LIGHT).withProperty(HALF, EnumBlockHalf.BOTTOM);
				break;
			case 2:
				blockState = blockState.withProperty(SHADE, EnumShade.LIGHTER).withProperty(HALF, EnumBlockHalf.BOTTOM);
				break;
			case 3:
				blockState = blockState.withProperty(SHADE, EnumShade.DARK).withProperty(HALF, EnumBlockHalf.BOTTOM);
				break;
			case 4:
				blockState = blockState.withProperty(SHADE, EnumShade.DARKER).withProperty(HALF, EnumBlockHalf.BOTTOM);
				break;
			case 5:
				blockState = blockState.withProperty(SHADE, EnumShade.NORMAL).withProperty(HALF, EnumBlockHalf.TOP);
				break;
			case 6:
				blockState = blockState.withProperty(SHADE, EnumShade.LIGHT).withProperty(HALF, EnumBlockHalf.TOP);
				break;
			case 7:
				blockState = blockState.withProperty(SHADE, EnumShade.LIGHTER).withProperty(HALF, EnumBlockHalf.TOP);
				break;
			case 8:
				blockState = blockState.withProperty(SHADE, EnumShade.DARK).withProperty(HALF, EnumBlockHalf.TOP);
				break;
			case 9:
				blockState = blockState.withProperty(SHADE, EnumShade.DARKER).withProperty(HALF, EnumBlockHalf.TOP);
				break;
			default:
				blockState = blockState.withProperty(SHADE, EnumShade.NORMAL).withProperty(HALF, EnumBlockHalf.BOTTOM);
				break;
		}
	} else { //If the block is a BlockColoreDoubleSlab
		switch (meta) {
			case 0:
				blockState = blockState.withProperty(SHADE, EnumShade.NORMAL);
				break;
			case 1:
				blockState = blockState.withProperty(SHADE, EnumShade.LIGHT);
				break;
			case 2:
				blockState = blockState.withProperty(SHADE, EnumShade.LIGHTER);
				break;
			case 3:
				blockState = blockState.withProperty(SHADE, EnumShade.DARK);
				break;
			case 4:
				blockState = blockState.withProperty(SHADE, EnumShade.DARKER);
				break;
			default:
				blockState = blockState.withProperty(SHADE, EnumShade.NORMAL);
				break;
		}
	}

	return blockState;
}

//Converts metadata into an IBlockState.
@Override
public int getMetaFromState(IBlockState state) {

    EnumShade shade = (EnumShade) state.getValue(SHADE);
    
    if (!this.isDouble()) {
    	EnumBlockHalf half = (EnumBlockHalf) state.getValue(HALF);
    	
    	//0-4 are bottom slabs, and 5-9 are the top slabs, so if the HALF property = top,
    	//then 5 is added to the ID integer assigned to the SHADE property. This is done
    	//to match up with how I've assigned the 9 different metadata values. (I hope
    	//this comment made sense so I don't come back later trying to find out why I did
    	//this and get disappointed with my former self's explanatory skills...)
    	if (half == EnumBlockHalf.TOP) {
    		return shade.getID() + 5; 
    	}
    }
    
    return shade.getID();
}

//This insures that  the meta block drops an item-block with the correct metadata when mined. This is
//somewhat trickier than with a regular block since you don't want to drop a "top" or "bottom" half slab.
//You only want to drop... well, just a slab! (Or more technically, a default, or bottom, half slab.
//Of course, if you're breaking a double-slab, it shouldn't drop a block with the HALF property at all.
@Override
public int damageDropped(IBlockState state) {
	if (!this.isDouble()) {
		//Using my neat math tricks in conjuction with how I've set up the 9 metadata values so that
		//0-4 are bottom slabs and 5-9 are top slabs.
		if (getMetaFromState(state) > 5) { //If the block is a top slab, then drop a bottom slab.
			return getMetaFromState(state) - 5;
		}
	}
	//If the block is a bottom slab or double slab, then drop a block with a metadata between 0-4.
	//The value of the SHADE property is assigned to the same 5 integers for both bottom half slabs
	//and double slabs, so this works. Hooray for clever metadata-blockstate-math-stuff!
    return getMetaFromState(state);
}

//Used to get the last part of the unlocalized name for the item-block.
//The structure of the unlocalized name is: tile.blockname.specialname.name
@Override
public String getSpecialName(ItemStack stack) {
	switch (stack.getItemDamage()) {
		case 0:
			return "normal";
		case 1:
			return "light";
		case 2:
			return "lighter";
		case 3:
			return "dark";
		case 4:
			return "darker";
		default:
			return "normal";
	}
}

@Override
    public final String getUnlocalizedName(final int metadata) {
        return this.getUnlocalizedName();
    }

//This ensures that the pick-block button (normally middle-click) will give
//an item-block with the correct metadata.
@Override
public ItemStack getPickBlock(MovingObjectPosition target, World world, BlockPos pos) {
    return new ItemStack(Item.getItemFromBlock(this), 1, this.getMetaFromState(world.getBlockState(pos)));
}

//WIP BEYOND THIS POINT

}

 

BlockColoreSlabHalf:

package com.supergeniuszeb.colore.common.blocks;

import net.minecraft.block.properties.IProperty;
import net.minecraft.item.ItemStack;

public class BlockColoreSlabHalf extends BlockColoreSlab {

public BlockColoreSlabHalf(String unlocalizedName) {
	super(unlocalizedName);
}

@Override
public boolean isDouble() {
	return false;
}

}

 

BlockColoreSlabDouble:

package com.supergeniuszeb.colore.common.blocks;

public class BlockColoreSlabDouble extends BlockColoreSlab {

public BlockColoreSlabDouble(String unlocalizedName) {
	super(unlocalizedName);
}

@Override
public boolean isDouble() {
	return true;
}
}

 

ItemBlockColoreSlab:

package com.supergeniuszeb.colore.common.blocks;

import java.util.ArrayList;
import java.util.List;

import com.supergeniuszeb.colore.common.registry.BlockRegistry;

import net.minecraft.block.Block;
import net.minecraft.item.Item;
import net.minecraft.item.ItemSlab;
import net.minecraft.item.ItemStack;

/*
* Wrapper class to make sure that GameRegistry.registerBlock() calls the right constructor.
*/
public class ItemBlockColoreSlab extends ItemSlab {

public ItemBlockColoreSlab(final Block block, final BlockColoreSlabHalf slab, final BlockColoreSlabDouble doubleSlab, final Boolean stacked) {
	super(block, slab, doubleSlab);
	this.setHasSubtypes(true);
        this.getSubBlocks(slabList, this, 5);
}

public int getMetadata(int damage)
    {
        return damage;
    }

@Override
    public String getUnlocalizedName(ItemStack stack) {
        return super.getUnlocalizedName(stack) + "." + ((IMetaBlockName)this.block).getSpecialName(stack);
    }

public static List slabList = new ArrayList<Item>(5) {};

	//This will add all the different metadata variations of the slabs
	//as "ItemStack"s to the slabList list. Used when adding metadata
	//blocks to the creative tabs.
	public void getSubBlocks(List slabList, Item item, int range) {
		for (int i = 0; i < range; ++i) {
            slabList.add(new ItemStack(item, 1, i));
        }
	}

}

 

(I've commented out the other slabs, since all I really need is to get the red slab working, and then I can just do copying-and-pasting for all the others.)

BlockRegistry (used to register instances of blocks):

package com.supergeniuszeb.colore.common.registry;

import net.minecraftforge.fml.common.registry.GameRegistry;

import com.supergeniuszeb.colore.common.blocks.BlockColore;
import com.supergeniuszeb.colore.common.blocks.BlockColoreOre;
import com.supergeniuszeb.colore.common.blocks.BlockColoreSlab;
import com.supergeniuszeb.colore.common.blocks.BlockColoreSlabDouble;
import com.supergeniuszeb.colore.common.blocks.BlockColoreSlabHalf;
import com.supergeniuszeb.colore.common.blocks.ItemBlockColore;
import com.supergeniuszeb.colore.common.blocks.ItemBlockColoreSlab;

public class BlockRegistry {

//regular blocks
public static BlockColore block_of_red;
public static BlockColore block_of_reddish_orange;
public static BlockColore block_of_orange;
public static BlockColore block_of_orangish_yellow;
public static BlockColore block_of_yellow;
public static BlockColore block_of_yellowish_green;
public static BlockColore block_of_green;
public static BlockColore block_of_cyan;
public static BlockColore block_of_blue;
public static BlockColore block_of_indigo;
public static BlockColore block_of_purple;
public static BlockColore block_of_magenta;
public static BlockColore block_of_brown;
public static BlockColore block_of_grayscale;

//half slabs
public static BlockColoreSlab slab_of_red = new BlockColoreSlabHalf("slab_of_red");
/*	public static BlockColoreSlabHalf slab_of_reddish_orange;
public static BlockColoreSlabHalf slab_of_orange;
public static BlockColoreSlabHalf slab_of_orangish_yellow;
public static BlockColoreSlabHalf slab_of_yellow;
public static BlockColoreSlabHalf slab_of_yellowish_green;
public static BlockColoreSlabHalf slab_of_green;
public static BlockColoreSlabHalf slab_of_cyan;
public static BlockColoreSlabHalf slab_of_blue;
public static BlockColoreSlabHalf slab_of_indigo;
public static BlockColoreSlabHalf slab_of_purple;
public static BlockColoreSlabHalf slab_of_magenta;
public static BlockColoreSlabHalf slab_of_brown;
public static BlockColoreSlabHalf slab_of_grayscale;
*/
//double slabs
public static BlockColoreSlab slab_of_red_double = new BlockColoreSlabDouble("slab_of_red_double");
/*public static BlockColoreSlabDouble slab_of_reddish_orange_double;
public static BlockColoreSlabDouble slab_of_orange_double;
public static BlockColoreSlabDouble slab_of_orangish_yellow_double;
public static BlockColoreSlabDouble slab_of_yellow_double;
public static BlockColoreSlabDouble slab_of_yellowish_green_double;
public static BlockColoreSlabDouble slab_of_green_double;
public static BlockColoreSlabDouble slab_of_cyan_double;
public static BlockColoreSlabDouble slab_of_blue_double;
public static BlockColoreSlabDouble slab_of_indigo_double;
public static BlockColoreSlabDouble slab_of_purple_double;
public static BlockColoreSlabDouble slab_of_magenta_double;
public static BlockColoreSlabDouble slab_of_brown_double;
public static BlockColoreSlabDouble slab_of_grayscale_double;*/

//ore blocks	
public static BlockColoreOre essence_ore;

public static void registerBlocks() {
	//regular blocks
	GameRegistry.registerBlock(block_of_red = new BlockColore("block_of_red"), ItemBlockColore.class, "block_of_red");
	GameRegistry.registerBlock(block_of_reddish_orange = new BlockColore("block_of_reddish_orange"), ItemBlockColore.class, "block_of_reddish_orange");
	GameRegistry.registerBlock(block_of_orange = new BlockColore("block_of_orange"), ItemBlockColore.class, "block_of_orange");
	GameRegistry.registerBlock(block_of_orangish_yellow = new BlockColore("block_of_orangish_yellow"), ItemBlockColore.class, "block_of_orangish_yellow");
	GameRegistry.registerBlock(block_of_yellow = new BlockColore("block_of_yellow"), ItemBlockColore.class, "block_of_yellow");
	GameRegistry.registerBlock(block_of_yellowish_green = new BlockColore("block_of_yellowish_green"), ItemBlockColore.class, "block_of_yellowish_green");
	GameRegistry.registerBlock(block_of_green = new BlockColore("block_of_green"), ItemBlockColore.class, "block_of_green");
	GameRegistry.registerBlock(block_of_cyan = new BlockColore("block_of_cyan"), ItemBlockColore.class, "block_of_cyan");
	GameRegistry.registerBlock(block_of_blue = new BlockColore("block_of_blue"), ItemBlockColore.class, "block_of_blue");
	GameRegistry.registerBlock(block_of_indigo = new BlockColore("block_of_indigo"), ItemBlockColore.class, "block_of_indigo");
	GameRegistry.registerBlock(block_of_purple = new BlockColore("block_of_purple"), ItemBlockColore.class, "block_of_purple");
	GameRegistry.registerBlock(block_of_magenta = new BlockColore("block_of_magenta"), ItemBlockColore.class, "block_of_magenta");
	GameRegistry.registerBlock(block_of_brown = new BlockColore("block_of_brown"), ItemBlockColore.class, "block_of_brown");
	GameRegistry.registerBlock(block_of_grayscale = new BlockColore("block_of_grayscale"), ItemBlockColore.class, "block_of_grayscale");

	//half slabs
	GameRegistry.registerBlock(slab_of_red, ItemBlockColoreSlab.class, "slab_of_red", slab_of_red, slab_of_red_double, false);
	/*GameRegistry.registerBlock(slab_of_reddish_orange = new BlockColoreSlabHalf("slab_of_reddish_orange"), ItemBlockColoreSlab.class, "slab_of_reddish_orange");
	GameRegistry.registerBlock(slab_of_orange = new BlockColoreSlabHalf("slab_of_orange"), ItemBlockColoreSlab.class, "slab_of_orange");
	GameRegistry.registerBlock(slab_of_orangish_yellow = new BlockColoreSlabHalf("slab_of_orangish_yellow"), ItemBlockColoreSlab.class, "slab_of_orangish_yellow");
	GameRegistry.registerBlock(slab_of_yellow = new BlockColoreSlabHalf("slab_of_yellow"), ItemBlockColoreSlab.class, "slab_of_yellow");
	GameRegistry.registerBlock(slab_of_yellowish_green = new BlockColoreSlabHalf("slab_of_yellowish_green"), ItemBlockColoreSlab.class, "slab_of_yellowish_green");
	GameRegistry.registerBlock(slab_of_green = new BlockColoreSlabHalf("slab_of_green"), ItemBlockColoreSlab.class, "slab_of_green");
	GameRegistry.registerBlock(slab_of_cyan = new BlockColoreSlabHalf("slab_of_cyan"), ItemBlockColoreSlab.class, "slab_of_cyan");
	GameRegistry.registerBlock(slab_of_blue = new BlockColoreSlabHalf("slab_of_blue"), ItemBlockColoreSlab.class, "slab_of_blue");
	GameRegistry.registerBlock(slab_of_indigo = new BlockColoreSlabHalf("slab_of_indigo"), ItemBlockColoreSlab.class, "slab_of_indigo");
	GameRegistry.registerBlock(slab_of_purple = new BlockColoreSlabHalf("slab_of_purple"), ItemBlockColoreSlab.class, "slab_of_purple");
	GameRegistry.registerBlock(slab_of_magenta = new BlockColoreSlabHalf("slab_of_magenta"), ItemBlockColoreSlab.class, "slab_of_magenta");
	GameRegistry.registerBlock(slab_of_brown = new BlockColoreSlabHalf("slab_of_brown"), ItemBlockColoreSlab.class, "slab_of_brown");
	GameRegistry.registerBlock(slab_of_grayscale = new BlockColoreSlabHalf("slab_of_grayscale"), ItemBlockColoreSlab.class, "slab_of_grayscale");
	*/
	//double slabs
	GameRegistry.registerBlock(slab_of_red_double, ItemBlockColoreSlab.class, "slab_of_red_double", slab_of_red, slab_of_red_double, true);
	/*GameRegistry.registerBlock(slab_of_reddish_orange_double = new BlockColoreSlabDouble("slab_of_reddish_orange_double"), ItemBlockColoreSlab.class, "slab_of_reddish_orange_double");
	GameRegistry.registerBlock(slab_of_orange_double = new BlockColoreSlabDouble("slab_of_orange_double"), ItemBlockColoreSlab.class, "slab_of_orange_double");
	GameRegistry.registerBlock(slab_of_orangish_yellow_double = new BlockColoreSlabDouble("slab_of_orangish_yellow_double"), ItemBlockColoreSlab.class, "slab_of_orangish_yellow_double");
	GameRegistry.registerBlock(slab_of_yellow_double = new BlockColoreSlabDouble("slab_of_yellow_double"), ItemBlockColoreSlab.class, "slab_of_yellow_double");
	GameRegistry.registerBlock(slab_of_yellowish_green_double = new BlockColoreSlabDouble("slab_of_yellowish_green_double"), ItemBlockColoreSlab.class, "slab_of_yellowish_green_double");
	GameRegistry.registerBlock(slab_of_green_double = new BlockColoreSlabDouble("slab_of_green_double"), ItemBlockColoreSlab.class, "slab_of_green_double");
	GameRegistry.registerBlock(slab_of_cyan_double = new BlockColoreSlabDouble("slab_of_cyan_double"), ItemBlockColoreSlab.class, "slab_of_cyan_double");
	GameRegistry.registerBlock(slab_of_blue_double = new BlockColoreSlabDouble("slab_of_blue_double"), ItemBlockColoreSlab.class, "slab_of_blue_double");
	GameRegistry.registerBlock(slab_of_indigo_double = new BlockColoreSlabDouble("slab_of_indigo_double"), ItemBlockColoreSlab.class, "slab_of_indigo_double");
	GameRegistry.registerBlock(slab_of_purple_double = new BlockColoreSlabDouble("slab_of_purple_double"), ItemBlockColoreSlab.class, "slab_of_purple_double");
	GameRegistry.registerBlock(slab_of_magenta_double = new BlockColoreSlabDouble("slab_of_magenta_double"), ItemBlockColoreSlab.class, "slab_of_magenta_double");
	GameRegistry.registerBlock(slab_of_brown_double = new BlockColoreSlabDouble("slab_of_brown_double"), ItemBlockColoreSlab.class, "slab_of_brown_double");
	GameRegistry.registerBlock(slab_of_grayscale_double = new BlockColoreSlabDouble("slab_of_grayscale_double"), ItemBlockColoreSlab.class, "slab_of_grayscale_double");
*/
	GameRegistry.registerBlock(essence_ore = new BlockColoreOre("essence_ore"), ItemBlockColore.class, "essence_ore");
}
}

 

BlockRenderRegistry (used to register block models and item-block models... I am aware I haven't registered the slab models or anything yet, but nothing in this class affects the functionality of the blocks, so I'm not going to add anything here until the slabs work as intended and all that's left is the rendering side of things.):

	package com.supergeniuszeb.colore.client.render;

import net.minecraft.block.Block;
import net.minecraft.client.Minecraft;
import net.minecraft.client.resources.model.ModelBakery;
import net.minecraft.client.resources.model.ModelResourceLocation;
import net.minecraft.item.Item;
import net.minecraft.util.ResourceLocation;

import com.supergeniuszeb.colore.Reference;
import com.supergeniuszeb.colore.common.registry.BlockRegistry;
import com.supergeniuszeb.colore.utility.ModUtilities;

//All this handles are the item-block models, not the actual block models, which are
//defined in the .json files.
public class BlockRenderRegistry {

//This method is called by the registerRenders method every time it adds an item-block model.
public static void registerRender(Block block) {
	Item item = Item.getItemFromBlock(block);
	Minecraft.getMinecraft().getRenderItem().getItemModelMesher().register(Item.getItemFromBlock(block), 0, new ModelResourceLocation(Reference.MOD_ID + ":" + item.getUnlocalizedName().substring(5), "inventory"));
}

//This method is called by the init method every time it adds a meta item-block model.
public static void registerRender(Block block, int meta, String fileName) {
	Minecraft.getMinecraft().getRenderItem().getItemModelMesher().register(Item.getItemFromBlock(block), meta, new ModelResourceLocation(Reference.MOD_ID + ":" + fileName, "inventory"));
}

public static void preInit() {

	for (String shade : ModUtilities.shadeList) {
		ModelBakery.registerItemVariants(Item.getItemFromBlock(BlockRegistry.block_of_red), new ResourceLocation(Reference.MOD_ID, "block_of_red_" + shade));
		ModelBakery.registerItemVariants(Item.getItemFromBlock(BlockRegistry.block_of_reddish_orange), new ResourceLocation(Reference.MOD_ID, "block_of_reddish_orange_" + shade));
		ModelBakery.registerItemVariants(Item.getItemFromBlock(BlockRegistry.block_of_orange), new ResourceLocation(Reference.MOD_ID, "block_of_orange_" + shade));
		ModelBakery.registerItemVariants(Item.getItemFromBlock(BlockRegistry.block_of_orangish_yellow), new ResourceLocation(Reference.MOD_ID, "block_of_orangish_yellow_" + shade));
		ModelBakery.registerItemVariants(Item.getItemFromBlock(BlockRegistry.block_of_yellow), new ResourceLocation(Reference.MOD_ID, "block_of_yellow_" + shade));
		ModelBakery.registerItemVariants(Item.getItemFromBlock(BlockRegistry.block_of_yellowish_green), new ResourceLocation(Reference.MOD_ID, "block_of_yellowish_green_" + shade));
		ModelBakery.registerItemVariants(Item.getItemFromBlock(BlockRegistry.block_of_green), new ResourceLocation(Reference.MOD_ID, "block_of_green_" + shade));
		ModelBakery.registerItemVariants(Item.getItemFromBlock(BlockRegistry.block_of_cyan), new ResourceLocation(Reference.MOD_ID, "block_of_cyan_" + shade));
		ModelBakery.registerItemVariants(Item.getItemFromBlock(BlockRegistry.block_of_blue), new ResourceLocation(Reference.MOD_ID, "block_of_blue_" + shade));
		ModelBakery.registerItemVariants(Item.getItemFromBlock(BlockRegistry.block_of_indigo), new ResourceLocation(Reference.MOD_ID, "block_of_indigo_" + shade));
		ModelBakery.registerItemVariants(Item.getItemFromBlock(BlockRegistry.block_of_purple), new ResourceLocation(Reference.MOD_ID, "block_of_purple_" + shade));
		ModelBakery.registerItemVariants(Item.getItemFromBlock(BlockRegistry.block_of_magenta), new ResourceLocation(Reference.MOD_ID, "block_of_magenta_" + shade));
		ModelBakery.registerItemVariants(Item.getItemFromBlock(BlockRegistry.block_of_brown), new ResourceLocation(Reference.MOD_ID, "block_of_brown_" + shade));
		ModelBakery.registerItemVariants(Item.getItemFromBlock(BlockRegistry.block_of_grayscale), new ResourceLocation(Reference.MOD_ID, "block_of_grayscale_" + shade));
	}

	for (String color : ModUtilities.baseColorList) {
		ModelBakery.registerItemVariants(Item.getItemFromBlock(BlockRegistry.essence_ore), new ResourceLocation(Reference.MOD_ID, "essence_ore_" + color));
	}
}

public static void init() {

	int i = 0;
	for (String shade : ModUtilities.shadeList) {
		registerRender(BlockRegistry.block_of_red, i, "block_of_red_" + shade);
		registerRender(BlockRegistry.block_of_reddish_orange, i, "block_of_reddish_orange_" + shade);
		registerRender(BlockRegistry.block_of_orange, i, "block_of_orange_" + shade);
		registerRender(BlockRegistry.block_of_orangish_yellow, i, "block_of_orangish_yellow_" + shade);
		registerRender(BlockRegistry.block_of_yellow, i, "block_of_yellow_" + shade);
		registerRender(BlockRegistry.block_of_yellowish_green, i, "block_of_yellowish_green_" + shade);
		registerRender(BlockRegistry.block_of_green, i, "block_of_green_" + shade);
		registerRender(BlockRegistry.block_of_cyan, i, "block_of_cyan_" + shade);
		registerRender(BlockRegistry.block_of_blue, i, "block_of_blue_" + shade);
		registerRender(BlockRegistry.block_of_indigo, i, "block_of_indigo_" + shade);
		registerRender(BlockRegistry.block_of_purple, i, "block_of_purple_" + shade);
		registerRender(BlockRegistry.block_of_magenta, i, "block_of_magenta_" + shade);
		registerRender(BlockRegistry.block_of_brown, i, "block_of_brown_" + shade);
		registerRender(BlockRegistry.block_of_grayscale, i, "block_of_grayscale_" + shade);
		i++;
	}

	i = 0;
	for (String color : ModUtilities.baseColorList) {
		registerRender(BlockRegistry.essence_ore, i, "essence_ore_" + color);
		i++;
	}
}

}

 

I hope you all can help me find what silly mistakes I've made, as well as help me understand all of this better. My head is spinning in squares right now... 

[larsgerrits]

BlockColoreSlab constructor:

blockState = blockState.withProperty(SHADE, "normal");

 

SHADE

is of type

PropertEnum

, but you supply it with a

String

.

[jeffryfisher]

Since the error message complains about "block null" while attempting to set  shade to normal at line 36, you need to look into getBaseState called on line 35 and find out why it returns a BlockState with a null Block in it.

 

BTW, When Eclipse gives you error messages with line numbers, you can click on the references to jump there and see what it is. You can then set breakpoints and re-run in the debugger to step through the erroneous code. Things often become much clearer when you can see what's what (variables, class members, parameter values passed, branches taken).

[SuperGeniusZeb]

  On 2/3/2016 at 7:31 PM, larsgerrits said:

BlockColoreSlab constructor:

blockState = blockState.withProperty(SHADE, "normal");

 

SHADE

is of type

PropertEnum

, but you supply it with a

String

.

 

Fixed. Will update main post with the new crash report I get and the changes I've made...

 

EDIT: Also, @jeffryfisher: Thanks, I found the point at which the game crashes now that I fixed the aforementioned silly mistake... It crashes when I try to call registerBlock on one of the slabs. I know I've done something wrong there, but I'm not sure what exactly it is or how to fix it...

[jeffryfisher]

The problem now looks to be an execution-order error, probably in your main class. Why else would you try to register a null block?

[SuperGeniusZeb]

  On 2/5/2016 at 2:02 AM, jeffryfisher said:

The problem now looks to be an execution-order error, probably in your main class. Why else would you try to register a null block?

Wasn't a problem in my main class. Just me making more dumb mistakes.

 

Before:

public static BlockColoreSlabHalf slab_of_red;

GameRegistry.registerBlock(slab_of_red = new BlockColoreSlabHalf("slab_of_red"), ItemBlockColoreSlab.class, slab_of_red, slab_of_red, slab_of_red_double, false);

After:

public static BlockColoreSlab slab_of_red = new BlockColoreSlabHalf("slab_of_red");

public static BlockColoreSlab slab_of_red_double = new BlockColoreSlabDouble("slab_of_red_double");

GameRegistry.registerBlock(slab_of_red = new BlockColoreSlabHalf("slab_of_red"), ItemBlockColoreSlab.class, "slab_of_red", slab_of_red, slab_of_red_double, false);

 

Aside from inputing some wrong values in the registerBlock functions, I also forgot to give slab_of_red_double a value when I first initialized it, so when its name was called in slab_of_red's registerBlock parameters, it caused null pointer exceptions and stuff. I think there were also a couple of other errors, but they're fixed now. (I think.)

 

The game will now launch without crashing, and you can place down the red slabs, which have no texture but work as half a block and function like a normal slab, except for turning into a double slab. They show up as null.normal.name in the creative menu, but I'm hoping that I can fix that easily.

 

I think I can fix everything else from here, but if not, I'll update the main post with the updated code. Thanks for your help so far.

[SuperGeniusZeb]

  On 2/5/2016 at 3:02 PM, diesieben07 said:

Why do you assign

slab_of_red

twice? That makes no sense.

Fixed.

[SuperGeniusZeb]

And... I'm stuck again. I've updated the main post with the changed code and the current state of how things are working. At least the game isn't crashing anymore.

[SuperGeniusZeb]

Bump. Still need help... see main post for current situation...

[SuperGeniusZeb]

Bump again... anyone know what I need to change in order to get the slabs to work?