(1.14) Custom IRecipe RecipeManager Help

[pancax]

Hello, my friend and I recently started modding because we thought it would be fun, so far it has!

Unfortunately i have been hard-stuck on this particular problem and i really don't know why.

Basically i have made a custom recipe called a "grinding recipe" for my block the grinder (called firstblock for now) and i would like when you put a firstblock item into the top slot for it to "grind it" and transform it into a firstitem. This is really just a proof of concept before i implement it further with actual items. Once it works i can replicate the success easily (hopefully)

The problem code is this:

                       IRecipe<?> irecipe = this.world.getRecipeManager().getRecipe(Objects.requireNonNull((ModItems.FIRSTITEM).getRegistryName())/*(IRecipeType<AbstractGrindingRecipe>)this.recipeType,this,this.world*/).orElse(null);

getRecipe always returns null no matter what i give it. As you can see by the commented out section i have also tried the other method of getRecipe. 

 

My question is, is it not enough that i have registered my recipe like this

package orebesity.common.recipes;

import net.minecraft.item.crafting.IRecipeSerializer;
import net.minecraftforge.registries.ObjectHolder;

public class ModRecipes {
    @ObjectHolder("orebesity:grinding")
    public static IRecipeSerializer<GrindingRecipe> GRINDING;// = IRecipeSerializer.register("grinding",new GrindingRecipeSerializer<>(GrindingRecipe::new,100));

}

 

and made my recipes item file like this?

 

{
  "type": "orebesity:grinding",
  "ingredient": {
    "item": "orebesity:firstblock"
  },
  "result": "orebesity:firstitem",
  "experience": 0.7,
  "grindingtime": 200
}

 

I have no idea how forge adds recipes to the RecipeManager (or if i even have to) but it seems like minecraft doesn't recognize that my firstitem CAN be grinded from my firstblock. Here is my firstblock tile entity code if that is the problem.

class FirstBlockTile extends TileEntity implements ITickableTileEntity, INamedContainerProvider, IRecipeHolder, ISidedInventory {
    private LazyOptional<IItemHandler> handler = LazyOptional.of(this::getHandler);
    public FirstBlockTile() {
        super(FIRSTBLOCK_TILE);
        recipeType=null;
    }
    public FirstBlockTile(IRecipeType<? extends AbstractGrindingRecipe> recipeType) {
        super(FIRSTBLOCK_TILE);
        this.recipeType = recipeType;
    }
    protected final IRecipeType<? extends AbstractGrindingRecipe> recipeType;
    private int grindingTime=0;
    @Override
    public void tick() {
        if(!this.world.isRemote){

           handler.ifPresent(h->{
               boolean isOn=false;
               ItemStack stack = h.getStackInSlot(0);
               if(stack.getItem()==ModBlocks.FIRSTBLOCK.asItem()){
                   isOn=true;
                   if(!stack.isEmpty()){
                       IRecipe<?> irecipe = this.world.getRecipeManager().getRecipe(Objects.requireNonNull((ModItems.FIRSTITEM).getRegistryName())/*(IRecipeType<AbstractGrindingRecipe>)this.recipeType,this,this.world*/).orElse(null);
                       System.out.println("alligator"+ModItems.FIRSTITEM.getRegistryName());
                       System.out.println("crocodile"+irecipe);
                       if(this.canYouGrind(irecipe)){
                           if(stack.hasContainerItem()){

                           }
                           else{
                               if(!stack.isEmpty()){
                                   Item item = stack.getItem();
                                   stack.shrink(1);
                                   if(stack.isEmpty()){

                                   }
                               }
                           }
                       }

                       if(canYouGrind(irecipe)){
                           ++this.grindingTime;
                           if(this.grindingTime==getDefaultGrindTime(stack.getItem())){
                               this.grindingTime=0;
                               this.itemGrinded(irecipe);
                           }
                       }else{
                           this.grindingTime=0;
                       }

                   }


               }
               if(isOn){
                   this.world.setBlockState(pos,this.world.getBlockState(this.pos).with(FirstBlock.ON,Boolean.valueOf("true")));
               }
               else{
                   this.world.setBlockState(pos,this.world.getBlockState(this.pos).with(FirstBlock.ON,Boolean.valueOf("false")));
               }


           });

        }
    }

    protected int getDefaultGrindTime(Item item){
        if(item==ModBlocks.FIRSTBLOCK.asItem())
            return 100;
        return 0;
    }
    private void itemGrinded(@Nullable IRecipe<?> recipe) {
        if (recipe != null && this.canYouGrind(recipe)) {
            ItemStack itemstack1 = recipe.getRecipeOutput();
            handler.ifPresent(h-> {
                ItemStack itemstack = h.getStackInSlot(0);
                ItemStack itemstack2= h.getStackInSlot(1);
                if (itemstack2.isEmpty()) {
                    itemstack2=itemstack1;
                } else if (itemstack2.getItem() == itemstack1.getItem()) {
                    itemstack2.grow(itemstack1.getCount());
                }

                if (!this.world.isRemote) {
                    this.setRecipeUsed(recipe);
                }
                itemstack.shrink(1);
            });
        }
    }
    protected boolean canYouGrind(@Nullable IRecipe<?> recipeType){

        ItemStack stack = recipeType.getRecipeOutput();
        if(stack.isEmpty()){
            return true;
        }else{
            AtomicReference<ItemStack> resultSlot = null;
            handler.ifPresent((IItemHandler h) -> resultSlot.set(h.getStackInSlot(1)));
            if(resultSlot.get().isEmpty())
            {
                return true;
            }else if (!resultSlot.get().isItemEqual(resultSlot.get())) {
                return false;
            } else if (resultSlot.get().getCount() + resultSlot.get().getCount() <= this.getInventoryStackLimit() && resultSlot.get().getCount() + resultSlot.get().getCount() <= resultSlot.get().getMaxStackSize()) { // Forge fix: make furnace respect stack sizes in furnace recipes
                return true;
            } else {
                return resultSlot.get().getCount() + resultSlot.get().getCount() <= resultSlot.get().getMaxStackSize(); // Forge fix: make furnace respect stack sizes in furnace recipes
            }
        }

    }
    @Override
    public void read(CompoundNBT compound) {
        CompoundNBT invTag = compound.getCompound("inv");

        handler.ifPresent(new NonNullConsumer<IItemHandler>() {
            @Override
            public void accept(@Nonnull IItemHandler h) {
                ((INBTSerializable<CompoundNBT>) h).deserializeNBT(invTag);

            }
        });
        super.read(compound);
    }

    @Override
    public CompoundNBT write(CompoundNBT compound) {

        handler.ifPresent(new NonNullConsumer<IItemHandler>() {
            @Override
            public void accept(@Nonnull IItemHandler h) {
                CompoundNBT c = ((INBTSerializable<CompoundNBT>) h).serializeNBT();
                compound.put("inv", c);
            }
        });

        return super.write(compound);
    }
    private IItemHandler getHandler(){
        return new ItemStackHandler(2){
            @Override
            protected void onContentsChanged(int slot) {
                markDirty();
            }
        };
    }
    @Nonnull
    @Override
    public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable Direction side) {
        if(cap == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) {
            return handler.cast();
        }
        return super.getCapability(cap, side);
    }

    @Override
    public ITextComponent getDisplayName() {
        return new StringTextComponent(getType().getRegistryName().getPath());
    }

    @Nullable
    @Override
    public Container createMenu(int i, PlayerInventory playerInventory, PlayerEntity playerEntity) {
        return new FirstBlockContainer(i,pos,world,playerInventory,playerEntity);
    }

    @Override
    public void setRecipeUsed(@Nullable IRecipe<?> recipe) {

    }

    @Nullable
    @Override
    public IRecipe<?> getRecipeUsed() {
        return null;
    }

    @Override
    public int[] getSlotsForFace(Direction side) {
        return new int[0];
    }

    @Override
    public boolean canInsertItem(int index, ItemStack itemStackIn, @Nullable Direction direction) {
        return false;
    }

    @Override
    public boolean canExtractItem(int index, ItemStack stack, Direction direction) {
        return false;
    }

    @Override
    public int getSizeInventory() {
        return 0;
    }

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

    @Override
    public ItemStack getStackInSlot(int index) {
        return null;
    }

    @Override
    public ItemStack decrStackSize(int index, int count) {
        return null;
    }

    @Override
    public ItemStack removeStackFromSlot(int index) {
        return null;
    }

    @Override
    public void setInventorySlotContents(int index, ItemStack stack) {

    }

    @Override
    public boolean isUsableByPlayer(PlayerEntity player) {
        return false;
    }

    @Override
    public void clear() {

    }
}

 

Thanks for the help ❤️

Edited July 16, 2019 by pancax

[Alpvax]

You haven't actually registered your recipeSerializer.

@ObjectHolder is just a reference to the registered serializer, it doesn't register anything. You need to subscribe to the registry event (Just like you do for items/blocks)

[pancax]

Hello, Thanks for the replay AlpVax! Turns out i have already registered it ( i just forgot to include it in the original post) Here is how i registered it

@SubscribeEvent
        public static void registerRecipes(final RegistryEvent.Register<IRecipeSerializer<?>> event){
            event.getRegistry().register(new GrindingRecipeSerializer<>(GrindingRecipe::new,100));
            LOGGER.info("hello from recipes");

        }

And here is my Grinding Recipe Serializer

 

public class GrindingRecipeSerializer<T extends AbstractGrindingRecipe> extends net.minecraftforge.registries.ForgeRegistryEntry<IRecipeSerializer<?>> implements IRecipeSerializer<T> {
        private final int i;
        private final GrindingRecipeSerializer.IFactory<T> factory;

        public GrindingRecipeSerializer(GrindingRecipeSerializer.IFactory<T> factory, int i){
            this.factory=factory;
            this.i=i;
            setRegistryName("orebesity:grinding");
        }
        @Override
        public T read(ResourceLocation recipeId, JsonObject json) {
            String s = JSONUtils.getString(json, "group", "");
            JsonElement jsonelement = (JsonElement)(JSONUtils.isJsonArray(json, "ingredient") ? JSONUtils.getJsonArray(json, "ingredient") : JSONUtils.getJsonObject(json, "ingredient"));
            Ingredient ingredient = Ingredient.deserialize(jsonelement);
            String s1 = JSONUtils.getString(json, "result");
            ResourceLocation resourcelocation = new ResourceLocation(s1);
            ItemStack itemstack = new ItemStack(Registry.ITEM.getValue(resourcelocation).orElseThrow(() -> new IllegalStateException("Item: " + s1 + " does not exist")));
            float f = JSONUtils.getFloat(json, "experience", 0.0F);
            int i = JSONUtils.getInt(json, "grindingtime", this.i);
            return this.factory.create(recipeId, s, ingredient, itemstack, f, i);
        }

        @Override
        public T read(ResourceLocation recipeId, PacketBuffer buffer) {
            String s = buffer.readString(32767);
            Ingredient ingredient = Ingredient.read(buffer);
            ItemStack itemstack = buffer.readItemStack();
            float f = buffer.readFloat();
            int i = buffer.readVarInt();
            return this.factory.create(recipeId, s, ingredient, itemstack, f, i);
        }

        @Override
        public void write(PacketBuffer buffer, T recipe) {
            buffer.writeString(recipe.group);
            recipe.ingredient.write(buffer);
            buffer.writeItemStack(recipe.result);
            buffer.writeFloat(recipe.experience);
            buffer.writeVarInt(recipe.grindTime);
        }

        public interface IFactory<T extends AbstractGrindingRecipe>{
            T create(ResourceLocation resourcelocation, String name, Ingredient ingredient, ItemStack stack, float f , int i);
        }

}

 

I was wondering if i need to register anything else as well?