[1.14.4][SOLVED] issues creating custom capabilities

[andGarrett]

I'm trying to create my own custom capability to store data described here and using this guide. There are a few things I need help with:

 

1. in the guide he says " You need to register this event handler to MinecraftForge.EVENT_BUS in your common proxy." I'm guessing "common proxy" is from 1.12-1.13 and I would need to register the event in my main mod class in the same area as I register blocks, item, and tile entities. if so, how, and if not where would I register the event?

 

2. in my "BlockPopulationStorage" class, I'm not sure if NBTPrimitive (copied from said guide) is from and older version of forge or what. I can't seem to find it in 1.14.

 

3. in my "BlockPopulationProvider" class, I'm not sure what to replace "this.instance" with in both the "serializeNBT" and "deserializeNBT" methods. in this post diesieben07 suggests removing the instance field.

 

BlockPopulationStorage class

package com.Garrett.backtobasics.capabilities;

import net.minecraft.nbt.INBT;
import net.minecraft.nbt.IntNBT;
import net.minecraft.util.Direction;
import net.minecraftforge.common.capabilities.Capability;

import javax.annotation.Nullable;

/**
 * This class is responsible for saving and reading block population data from or to server
 */

public class BlockPopulationStorage implements Capability.IStorage<IBlockPopulation> {
    @Nullable
    @Override
    public INBT writeNBT(Capability<IBlockPopulation> capability, IBlockPopulation instance, Direction side) {
        return new IntNBT(instance.getStores());
    }

    @Override
    public void readNBT(Capability<IBlockPopulation> capability, IBlockPopulation instance, Direction side, INBT nbt) {
        instance.setStores(((NBTPrimitive) nbt).getInt());
    }
}

 

 

BlockPopulationProvider class

package com.Garrett.backtobasics.capabilities;

import net.minecraft.nbt.INBT;
import net.minecraft.util.Direction;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.common.capabilities.CapabilityInject;
import net.minecraftforge.common.capabilities.ICapabilitySerializable;
import net.minecraftforge.common.util.LazyOptional;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class BlockPopulationProvider implements ICapabilitySerializable<INBT> {

    @CapabilityInject(IBlockPopulation.class)
    private static final Capability<IBlockPopulation> BLOCK_POPULATION_CAPABILITY = null;

    //private IBlockPopulation instance = BLOCK_POPULATION_CAPABILITY.getDefaultInstance();
    private final LazyOptional<IBlockPopulation> holder = LazyOptional.of(BlockPopulation::new);

    @Nonnull
    @Override
    public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable Direction side) {

        return cap == BLOCK_POPULATION_CAPABILITY ? holder.cast() : LazyOptional.empty();
    }

    @Override
    public INBT serializeNBT() {
        return BLOCK_POPULATION_CAPABILITY.getStorage().writeNBT(BLOCK_POPULATION_CAPABILITY, this.instance, null);
    }

    @Override
    public void deserializeNBT(INBT nbt) {
        BLOCK_POPULATION_CAPABILITY.getStorage().readNBT(BLOCK_POPULATION_CAPABILITY, this.instance, null, nbt);
    }
}

 

[SOLUTION]-------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

1. You should use @EventBusSubscriber to register your event handlers. Read the documentation about events.

2. in my case I needed to use "IntNBT". for a full list of nbt types look in net.minecraft.nbt.INBT.

3. I'm not sure I'm doing this the right way, but it seems to work: I created a "NonNullSupplier":

NonNullSupplier<IBlockPopulation> nonNullSupplier = new NonNullSupplier<IBlockPopulation>() { @Nonnull @Override public IBlockPopulation get() { return null; } };

then I used holder.orElseGet(nonNullSupplier) in place of "this.instance"

 

BlockPopulationStorage class

package com.Garrett.backtobasics.capabilities;

import net.minecraft.nbt.INBT;
import net.minecraft.nbt.IntNBT;
import net.minecraft.util.Direction;
import net.minecraftforge.common.capabilities.Capability;

import javax.annotation.Nullable;

/**
 * This class is responsible for saving and reading block population data from or to server
 */

public class BlockPopulationStorage implements Capability.IStorage<IBlockPopulation> {
    @Nullable
    @Override
    public INBT writeNBT(Capability<IBlockPopulation> capability, IBlockPopulation instance, Direction side) {
        return new IntNBT(instance.getStores());
    }

    @Override
    public void readNBT(Capability<IBlockPopulation> capability, IBlockPopulation instance, Direction side, INBT nbt) {
        instance.setStores(((IntNBT) nbt).getInt());
    }
}

 

BlockPopulationProvider class

package com.Garrett.backtobasics.capabilities;

import net.minecraft.nbt.INBT;
import net.minecraft.util.Direction;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.common.capabilities.CapabilityInject;
import net.minecraftforge.common.capabilities.ICapabilitySerializable;
import net.minecraftforge.common.util.LazyOptional;
import net.minecraftforge.common.util.NonNullSupplier;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class BlockPopulationProvider implements ICapabilitySerializable<INBT> {

    @CapabilityInject(IBlockPopulation.class)
    public static Capability<IBlockPopulation> BLOCK_POPULATION_CAPABILITY = null;

    private final LazyOptional<IBlockPopulation> holder = LazyOptional.of(BlockPopulation::new);

    @Nonnull
    @Override
    public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable Direction side) {

        return cap == BLOCK_POPULATION_CAPABILITY ? holder.cast() : LazyOptional.empty();
    }

    @Override
    public INBT serializeNBT() {
        NonNullSupplier<IBlockPopulation> nonNullSupplier = new NonNullSupplier<IBlockPopulation>() {
            @Nonnull
            @Override
            public IBlockPopulation get() {
                return null;
            }
        };
        return BLOCK_POPULATION_CAPABILITY.getStorage().writeNBT(BLOCK_POPULATION_CAPABILITY, holder.orElseGet(nonNullSupplier), null);
    }

    @Override
    public void deserializeNBT(INBT nbt) {
        NonNullSupplier<IBlockPopulation> nonNullSupplier = new NonNullSupplier<IBlockPopulation>() {
            @Nonnull
            @Override
            public IBlockPopulation get() {
                return null;
            }
        };
        BLOCK_POPULATION_CAPABILITY.getStorage().readNBT(BLOCK_POPULATION_CAPABILITY, holder.orElseGet(nonNullSupplier), null, nbt);
    }
}

 

Edited September 5, 2019 by andGarrett

[andGarrett]

4 hours ago, diesieben07 said:

• CommonProxy was never a good idea. You should use @EventBusSubscriber to register your event handlers. Read the documentation about events.
• You can get the instance out of the LazyCapability using the various methods it provides. Or you can have an instance field and point the LazyOptional at it. Just don't have two instances of your capability.
• If you do not plan on exposing your capability to other mods you do not need to write an interface and implement it. You can simply use the class as the capability.

I was able to get everything set up so that there are no errors, but something still isn't right. I'm not sure if it's something to do with how I subscribed the event or how I'm using the capability. I'm testing it out on one of my blocks in it's onBlockPlacedBy method. nothing seems to happen inside the the lambda expression where I placed: h.addStore(); LOGGER.info("number of stores: " + h.getStores());. Intellij also tells me that when I use "worldIn.getCapability(BlockPopulationProvider.BLOCK_POPULATION_CAPABILITY)..." I am "passing null argument to parameter annotated as @NonNull."

 

package com.Garrett.backtobasics.blocks;

import com.Garrett.backtobasics.capabilities.BlockPopulationProvider;
import net.minecraft.block.Block;
import net.minecraft.block.BlockState;
import net.minecraft.block.SoundType;
import net.minecraft.block.material.Material;
import net.minecraft.entity.LivingEntity;
import net.minecraft.entity.player.PlayerEntity;
import net.minecraft.entity.player.ServerPlayerEntity;
import net.minecraft.inventory.container.INamedContainerProvider;
import net.minecraft.item.BlockItemUseContext;
import net.minecraft.item.ItemStack;
import net.minecraft.state.StateContainer;
import net.minecraft.state.properties.BlockStateProperties;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.Hand;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.BlockRayTraceResult;
import net.minecraft.world.IBlockReader;
import net.minecraft.world.World;
import net.minecraftforge.fml.network.NetworkHooks;

import javax.annotation.Nullable;

public class AutoMiner extends Block {

    public AutoMiner() {

        super(Properties
                .create(Material.IRON)
                .sound(SoundType.METAL)
                .hardnessAndResistance(10, 15)
                .lightValue(0)
                .harvestLevel(0)
        );
        setRegistryName("backtobasics:auto_miner");
    }

    @Override
    public void onBlockPlacedBy(World worldIn, BlockPos pos, BlockState state, @Nullable LivingEntity placer, ItemStack stack) {
        LOGGER.info("onBlockPlacedBY");
        worldIn.getCapability(BlockPopulationProvider.BLOCK_POPULATION_CAPABILITY).ifPresent(h -> {
            h.addStore();
            LOGGER.info("number of stores: " + h.getStores());
        });
    }

    @Override
    public boolean hasTileEntity(BlockState state) {
        return true;
    }

    @Nullable
    @Override
    public TileEntity createTileEntity(BlockState state, IBlockReader world) {
        return new AutoMinerTileEntity();
    }

    // tells block what way to face when placed
    @Nullable
    @Override
    public BlockState getStateForPlacement(BlockItemUseContext context) {
        BlockState blockstate = super.getStateForPlacement(context);
        if (blockstate != null) {
            blockstate = blockstate.with(BlockStateProperties.FACING, context.getNearestLookingDirection());
        }
        return blockstate;
    }

    @Override
    public boolean onBlockActivated(BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockRayTraceResult result) {

        if (!world.isRemote) {
            TileEntity tileEntity = world.getTileEntity(pos);
            if (tileEntity instanceof INamedContainerProvider) {
                NetworkHooks.openGui((ServerPlayerEntity) player, (INamedContainerProvider) tileEntity, tileEntity.getPos());
            } else {
                throw new IllegalStateException("Our named container provider is missing!");
            }
            return true;
        }
        return super.onBlockActivated(state, world, pos, player, hand, result);
    }

    // adds support for "facing" property in block states json files
    @Override
    protected void fillStateContainer(StateContainer.Builder<Block, BlockState> builder) {
        builder.add(BlockStateProperties.FACING);
    }
}

 

Here's where I subscribed the event:

package com.Garrett.backtobasics.capabilities;

import com.Garrett.backtobasics.BackToBasics;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.World;
import net.minecraftforge.event.AttachCapabilitiesEvent;
import net.minecraftforge.eventbus.api.SubscribeEvent;

/**
 * Event handler
 */
public class BackToBasicsEventHandler {

    public static final ResourceLocation BLOCK_POPULATION_CAPABILITY = new ResourceLocation(BackToBasics.MODID, "block_population");
    
    @SubscribeEvent
    public void attachCapability(AttachCapabilitiesEvent<World> event)
    {
        if (!(event.getObject() instanceof World)) return;
        event.addCapability(BLOCK_POPULATION_CAPABILITY, new BlockPopulationProvider());
    }
}

 

Finally, here is how I registered the event handler in my main mod class in it's constructer.

"MinecraftForge.EVENT_BUS.register(BackToBasicsEventHandler.class);"

package com.Garrett.backtobasics;

import com.Garrett.backtobasics.blocks.*;
import com.Garrett.backtobasics.capabilities.BackToBasicsEventHandler;
import com.Garrett.backtobasics.capabilities.BlockPopulation;
import com.Garrett.backtobasics.capabilities.BlockPopulationStorage;
import com.Garrett.backtobasics.capabilities.IBlockPopulation;
import com.Garrett.backtobasics.items.*;
import com.Garrett.backtobasics.world.OreGeneration;
import net.minecraft.block.Block;
import net.minecraft.block.Blocks;
import net.minecraft.inventory.container.ContainerType;
import net.minecraft.item.BlockItem;
import net.minecraft.item.Item;
import net.minecraft.tileentity.TileEntityType;
import net.minecraft.util.math.BlockPos;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.common.capabilities.CapabilityManager;
import net.minecraftforge.common.extensions.IForgeContainerType;
import net.minecraftforge.event.RegistryEvent;
import net.minecraftforge.eventbus.api.SubscribeEvent;
import net.minecraftforge.fml.DistExecutor;
import net.minecraftforge.fml.InterModComms;
import net.minecraftforge.fml.common.Mod;
import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
import net.minecraftforge.fml.event.lifecycle.InterModEnqueueEvent;
import net.minecraftforge.fml.event.lifecycle.InterModProcessEvent;
import net.minecraftforge.fml.event.server.FMLServerStartingEvent;
import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import com.Garrett.backtobasics.setup.ModSetup;
import com.Garrett.backtobasics.setup.*;

import java.util.stream.Collectors;

// The value here should match an entry in the META-INF/mods.toml file
@Mod("backtobasics")
public class BackToBasics
{
    public static final String MODID = "backtobasics";

    public static ModSetup setup = new ModSetup();

    public static IProxy proxy = DistExecutor.runForDist(() -> () -> new ClientProxy(), () -> () -> new ServerProxy());

    // Directly reference a log4j logger.
    private static final Logger LOGGER = LogManager.getLogger();


    public BackToBasics() {
        // Register the setup method for modloading
        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::setup);
        // Register the enqueueIMC method for modloading
        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::enqueueIMC);
        // Register the processIMC method for modloading
        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::processIMC);
        // Register the doClientStuff method for modloading
        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::doClientStuff);
        // Register ourselves for server and other game events we are interested in
        MinecraftForge.EVENT_BUS.register(this);
        MinecraftForge.EVENT_BUS.register(BackToBasicsEventHandler.class);
    }

    private void setup(final FMLCommonSetupEvent event)
    {
        // some preinit code
        setup.init();
        proxy.init();
        LOGGER.info("HELLO FROM PREINIT");
        LOGGER.info("DIRT BLOCK >> {}", Blocks.DIRT.getRegistryName());
        OreGeneration.setupOreGeneration();
        CapabilityManager.INSTANCE.register(IBlockPopulation.class, new BlockPopulationStorage(), BlockPopulation::new);
    }

    private void doClientStuff(final FMLClientSetupEvent event) {
        // do something that can only be done on the client
        LOGGER.info("Got game settings {}", event.getMinecraftSupplier().get().gameSettings);
    }

    private void enqueueIMC(final InterModEnqueueEvent event)
    {
        // some example code to dispatch IMC to another mod
        InterModComms.sendTo("backtobasics", "helloworld", () -> { LOGGER.info("Hello world from the MDK"); return "Hello world";});
    }

    private void processIMC(final InterModProcessEvent event)
    {
        // some example code to receive and process InterModComms from other mods
        LOGGER.info("Got IMC {}", event.getIMCStream().
                map(m->m.getMessageSupplier().get()).
                collect(Collectors.toList()));
    }
    // You can use SubscribeEvent and let the Event Bus discover methods to call
    @SubscribeEvent
    public void onServerStarting(FMLServerStartingEvent event) {
        // do something when the server starts
        LOGGER.info("HELLO from server starting");
    }

    // You can use EventBusSubscriber to automatically subscribe events on the contained class (this is subscribing to the MOD
    // Event bus for receiving Registry Events)
    @Mod.EventBusSubscriber(bus=Mod.EventBusSubscriber.Bus.MOD)
    public static class RegistryEvents {
        @SubscribeEvent
        public static void onBlocksRegistry(final RegistryEvent.Register<Block> blockRegistryEvent) {

            // register a new block here
            LOGGER.info("HELLO from Register Block");
            blockRegistryEvent.getRegistry().register(new AutoMiner());
            blockRegistryEvent.getRegistry().register(new Store());
            blockRegistryEvent.getRegistry().register(new DiamondVein());
            blockRegistryEvent.getRegistry().register(new GoldVein());
            blockRegistryEvent.getRegistry().register(new IronVein());
            blockRegistryEvent.getRegistry().register(new RedstoneVein());
        }
        @SubscribeEvent
        public static void onItemRegistry(final RegistryEvent.Register<Item> ItemRegistryEvent) {

            // register a new item here
            Item.Properties properties = new Item.Properties()
                    .group(setup.itemGroup);
            ItemRegistryEvent.getRegistry().register(new BlockItem(ModBlocks.AUTO_MINER, properties).setRegistryName("backtobasics:auto_miner"));
            ItemRegistryEvent.getRegistry().register(new BlockItem(ModBlocks.STORE, properties).setRegistryName("backtobasics:store"));
            ItemRegistryEvent.getRegistry().register(new BlockItem(ModBlocks.DIAMOND_VEIN, properties).setRegistryName("backtobasics:diamond_vein"));
            ItemRegistryEvent.getRegistry().register(new BlockItem(ModBlocks.GOLD_VEIN, properties).setRegistryName("backtobasics:gold_vein"));
            ItemRegistryEvent.getRegistry().register(new BlockItem(ModBlocks.IRON_VEIN, properties).setRegistryName("backtobasics:iron_vein"));
            ItemRegistryEvent.getRegistry().register(new BlockItem(ModBlocks.REDSTONE_VEIN, properties).setRegistryName("backtobasics:redstone_vein"));
            ItemRegistryEvent.getRegistry().register(new UnrefinedIron());
            ItemRegistryEvent.getRegistry().register(new UnrefinedIronBits());
            ItemRegistryEvent.getRegistry().register(new UnrefinedGold());
            ItemRegistryEvent.getRegistry().register(new UnrefinedGoldBits());
            ItemRegistryEvent.getRegistry().register(new DiamondBits());
            ItemRegistryEvent.getRegistry().register(new RedstoneBits());
            //LOGGER.info("banana");
            //LOGGER.info(ItemRegistryEvent.getRegistry().getValues());
        }
        @SubscribeEvent
        public static void onTileEntityRegistry(final RegistryEvent.Register<TileEntityType<?>> event) {
            event.getRegistry().register(TileEntityType.Builder.create(AutoMinerTileEntity::new, ModBlocks.AUTO_MINER).build(null).setRegistryName("auto_miner"));
            event.getRegistry().register(TileEntityType.Builder.create(StoreTileEntity::new, ModBlocks.STORE).build(null).setRegistryName("store"));
        }

        @SubscribeEvent
        public static void onContainerRegistry(final RegistryEvent.Register<ContainerType<?>> event) {
            event.getRegistry().register(IForgeContainerType.create((windowId, inv, data) -> {
                BlockPos pos = data.readBlockPos();
                return new AutoMinerContainer(windowId, BackToBasics.proxy.getClientWorld(), pos, inv, BackToBasics.proxy.getClientPlayer());
            }).setRegistryName("auto_miner"));

            event.getRegistry().register(IForgeContainerType.create((windowId, inv, data) -> {
                BlockPos pos = data.readBlockPos();
                return new StoreContainer(windowId, BackToBasics.proxy.getClientWorld(), pos, inv, BackToBasics.proxy.getClientPlayer());
            }).setRegistryName("store"));
        }
    }
}

 

[andGarrett]

just checked to see if the capability is present in the onBlockPlaced method for the AutoMiner block, and it never is. wish I had more time to work on this but I must sleep

[Draco18s]

37 minutes ago, diesieben07 said:

If you register a Class instance to the event bus, only static event handlers in that class will be called. Please refer to the event documentation again.

I realize your terminology here is correct, but I would have phrased it differently.

 

"If you register the class to the event bus..."

vs.
"If you register a class instance to the event bus..."

 

Your post sounds more like the second, which uses the non-static methods (and even I had to read it three times to get the intended meaning). While true, you do pass in an instance of type Class, it grammatically doesn't parse that way on the first pass.

[Draco18s]

1 hour ago, diesieben07 said:

Should I say Class object? The class itself cannot be passed around in Java, only the reflective representation, a Class object / instance.

That works for me. It's just the grammatical difference between "Class instance" and "class instance" is too subtle. I knew that if I had a problem reading it correctly that others would as well.

[Draco18s]

17 minutes ago, diesieben07 said:

Not sure what a "class instance" is supposed to be...?

An instance of a(n arbitrarily named) class.

Edited September 5, 2019 by Draco18s

[andGarrett]

2 hours ago, diesieben07 said:

If you register a Class instance to the event bus, only static event handlers in that class will be called. Please refer to the event documentation again.

♥♥♥yup, that was it. Thanks for all the help!♥♥♥

[Draco18s]

7 minutes ago, diesieben07 said:

Now that's what I would call confusing. To me that's "an instance of a class".

Communicative rules of English grammar. "An employee of a government" is the same as "a government employee." "A representative of the company" is the same as "a company representative."

 

Same thing, different words.

 

Quote

But whatever. This is way off topic.

True enough, I'll be done splitting hairs as well. I was just explaining my thought process. But apparently I should know better because no one cares (even when they ask).

Edited September 5, 2019 by Draco18s

[andGarrett]

9 hours ago, diesieben07 said:

If you register a Class instance to the event bus, only static event handlers in that class will be called. Please refer to the event documentation again.

why might I want to use a static event handler vs a non-static event handler?

[Animefan8888]

13 minutes ago, andGarrett said:

why might I want to use a static event handler vs a non-static event handler?

I like to think they are easier to use. Typically you wouldn't register the class itself, but instead use the @EventBusSubscriber annotation. But that's what having the annotation does. It registers the class. 

[Draco18s]

It used to be that you can to register an instance (non-static methods) and someone wanted to just register the class itself. There was a bit of discussion about it that I remember, but eventually someone made the PR to handle the static method way, then it got an annotation, and now the annotation is the "preferred" method due to the simplicity.