So I've been working on an experimental mod recently, trying to structure the registry side of my mod in a different way (hence 2 forum questions in basically as many days).

So I have this class here that is supposed to ease with the registering of blocks and block items that looks like this:

public class BlockItemRegister<B extends Block> implements Supplier<B> {
	public final Supplier<B> block;
	public final Supplier<Item> item;

	public BlockItemRegister(Supplier<B> _block, Supplier<Item> _item) {
		block = _block;
		item = _item;
	}
	public BlockItemRegister(String id, Supplier<B> _block, Item.Properties prop) {
		this(_block, ModItems.register(id, () -> new BlockItem(_block.get(), prop)) );
	}
	public BlockItemRegister(String id, Supplier<B> _block) {
		this(id, _block, new Item.Properties().tab(ItemGroup.TAB_BUILDING_BLOCKS));
	}

	public B get() {
		return block.get();
	}

	//--------- method created to scare away some generic weirdness
	public static <B extends Block> BlockItemRegister<B>  gen(String id, Supplier<B> _block) {
		return new BlockItemRegister<>( id, ModBlocks.registerBlock(id, _block ) );
	}
	public static <B extends Block> BlockItemRegister<B> gen(String id, Supplier<B> _block, Item.Properties prop) {
		return new BlockItemRegister<>( id, ModBlocks.registerBlock(id, _block ), prop );
	}
	public static <B extends Block> BlockItemRegister<B> gen(String id, Supplier<B> _block, Supplier<Item> _item) {
		return new BlockItemRegister<>( ModBlocks.registerBlock(id, _block ), _item );
	}
}

This references this function in the ModBlocks class:

public static <B extends Block> RegistryObject<B> registerBlock(String name, Supplier<B> block) {
    return BLOCKS.register(name , block);
}

and this one in ModItems:

public static <I extends Item> RegistryObject<I> register(String name, Supplier<I> item) {
    return ITEMS.register(name , item);
}

which is fairly straightforward. I can then register a block item like this and it works fine:

BlockItemRegister<RotatedPillarBlock> log = BlockItemRegister.gen( id, () -> new RotatedPillarBlock(ModBlockProperties.LOG),   ModItems.withTab(ItemGroup.TAB_BUILDING_BLOCKS));

however if I do this:

Supplier<DoorBlock> door_block = () -> new DoorBlock(ModBlockProperties.PLANKS);
BlockItemRegister<DoorBlock> doorBlock = BlockItemRegister.gen( id, door_block, 
                                                               ModItems.register( id, () -> new TallBlockItem(door_block.get(), ModItems.withTab(ItemGroup.TAB_REDSTONE) )));

the block item register holds the door item however when I call .asItem() on the block it returns air which is causing me crashes. I'm struggling to understand why this might be as theoretically these are basically calling the same functions just with and without default functions

Actually I thought I could be nice and tidy up the BlockItemRegister class a bit:

public class BlockItemRegister<B extends Block> implements Supplier<B> {
	public final Supplier<B> block;
	public final Supplier<Item> item;

	public BlockItemRegister(Supplier<B> _block, Supplier<Item> _item) {
		block = _block;
		item = _item;
	}

	public B get() {
		return block.get();
	}

	//------------------ GEN FUNCS ------------------
	public static <B extends Block> BlockItemRegister<B>  gen(String id, Supplier<B> _block) {
		return gen(id, _block, ModItems.withTab(ItemGroup.TAB_BUILDING_BLOCKS));
	}
	public static <B extends Block> BlockItemRegister<B> gen(String id, Supplier<B> _block, Item.Properties prop) {
		return gen(id, _block, () -> new BlockItem(_block.get(), prop) );
	}
	public static <B extends Block> BlockItemRegister<B> gen(String id, Supplier<B> _block, Supplier<Item> _item) {
		return new BlockItemRegister<>( ModBlocks.registerBlock(id, _block ), ModItems.register(id, _item) );
	}
}

And the plot thickens. this organisation of the BlockItemRegister breaks the working code I had, somehow, in the same way where the blockItemRegister itself holds the item but doesn't tie it to the block for block.asitem()

Edited November 16, 20213 yr by Slit_bodmod
typo

3 hours ago, Slit_bodmod said:

new TallBlockItem(door_block.get(), ...

Because door_block is a supplier and you called get() which gives you a new DoorBlock(ModBlockProperties.PLANKS), not the door block you registered.

Edited November 16, 20213 yr by Draco18s

15 hours ago, Draco18s said:

Because door_block is a supplier and you called get() which gives you a new DoorBlock(ModBlockProperties.PLANKS), not the door block you registered.

oh yeah that makes so much sense now. I feel like that's the kinda thing that's so simple I would have never have figured it out lol.

Hmm so now I have to find a way to access the properties of an object that hasn't been constructed yet, in the supplier I'm handing to that object. That or back to the drawing board.

This is why DeferredRegister is great.

Yeah my system is built on top of deferred register. It's kinda a bit of an experiment to see how much milage I can get out of getting the registry system to do most of my mods heavy lifting.

Then you're going to have to pass in either the RegistryObject<> or a supplier that returns such.