Hi!
I'm trying to create a custom tileentity that automatically cooks the item inside, but I don't know how to see if the inserted item has a smelting recipe or not.
How can i see the recipes? I tried to copy from the FurnaceTileEntity, but the IRecipe result aslways null.

 

@Override
    public void setItem(int index, ItemStack stack) {
        assert this.level != null : "Can't happend";
        IRecipe<?> iRecipe = this.level.getRecipeManager().getRecipeFor(IRecipeType.SMELTING, this, this.level).orElse(null);
        ItemStack toInsert;
        if (iRecipe != null) {
            ItemStack resultItem = iRecipe.getResultItem();
            if (resultItem.equals(ItemStack.EMPTY)) {
                toInsert = stack;
            } else {
                toInsert = resultItem;
            }
        } else {
            toInsert = stack;
        }
        this.items.set(index, toInsert);
    }

 

public class SmeltingChestTileEntity extends TileEntity implements IInventory, INamedContainerProvider {
    private NonNullList<ItemStack> items = NonNullList.withSize(27, ItemStack.EMPTY);


    public SmeltingChestTileEntity() {
        super(Blocks.smeltingChestType);
    }

    @Override
    public CompoundNBT save(CompoundNBT nbt) {
        super.save(nbt);
        ItemStackHelper.saveAllItems(nbt, this.items);
        return nbt;
    }

    @Override
    public void load(BlockState state, CompoundNBT nbt) {
        super.load(state, nbt);
        this.items = NonNullList.withSize(this.getContainerSize(), ItemStack.EMPTY);
        ItemStackHelper.loadAllItems(nbt, this.items);
    }

    @Override
    public int getContainerSize() {
        return 27;
    }

    @Override
    public boolean isEmpty() {
        return items.isEmpty();
    }

    @Override
    public ItemStack getItem(int index) {
        return items.get(index);
    }

    @Override
    public ItemStack removeItem(int index, int quantity) {
        ItemStack itemStack = items.get(index);
        if (itemStack.getCount() <= quantity) {
            items.set(index, ItemStack.EMPTY);
            return itemStack;
        } else {
            int count = itemStack.getCount() - quantity;
            itemStack.setCount(count);
            items.set(index, itemStack);
            return new ItemStack(itemStack.getItem(), count);
        }
    }

    @Override
    public ItemStack removeItemNoUpdate(int index) {
        return items.remove(index);
    }

    @Override
    public void setItem(int index, ItemStack stack) {
        assert this.level != null : "Can't happend";
        IRecipe<?> iRecipe = this.level.getRecipeManager().getRecipeFor(IRecipeType.SMELTING, this, this.level).orElse(null);
        ItemStack toInsert;
        hasFuel();
        if (iRecipe != null && hasFuel()) {
            ItemStack resultItem = iRecipe.getResultItem();
            if (resultItem.equals(ItemStack.EMPTY)) {
                toInsert = stack;
            } else {
                toInsert = resultItem;
            }
        } else {
            toInsert = stack;
        }
        this.items.set(index, toInsert);
    }

    private boolean hasFuel() {
        BlockPos blockPos = this.getBlockPos().below();
        assert this.level != null;
        BlockState blockState = this.level.getBlockState(blockPos);
        BlockState lavaState = net.minecraft.block.Blocks.LAVA.defaultBlockState();
        BlockState fireState = net.minecraft.block.Blocks.FIRE.defaultBlockState();
        System.out.println(blockState);
        boolean b = blockState.equals(lavaState) || blockState.equals(fireState);
        System.out.println("Has fuel? " + b);
        return b;
    }

    @Override
    public boolean stillValid(PlayerEntity entity) {
        return true;
    }

    @Override
    public void clearContent() {
        items.clear();
    }

    @Override
    public ITextComponent getDisplayName() {
        return new TranslationTextComponent("smelting_chest");
    }

    @Nullable
    @Override
    public Container createMenu(int id, PlayerInventory inventory, PlayerEntity entity) {
        return ChestContainer.threeRows(id, inventory, this);
    }
}

This is the TileEntity class.

public class SmeltingChestBlock extends ContainerBlock {
    public static final DirectionProperty FACING = HorizontalBlock.FACING;

    public SmeltingChestBlock(Properties p_i48446_1_) {
        super(p_i48446_1_);
        this.setRegistryName(TenChest.MODID, "smelting_chest");
        Blocks.BLOCKS.add(this);
        this.registerDefaultState(this.stateDefinition.any().setValue(FACING, Direction.NORTH));
    }

    /*public static Direction getConnectedDirection(BlockState p_196311_0_) {
        Direction direction = p_196311_0_.getValue(FACING);
        return direction.getClockWise();
    }*/

    public BlockState getStateForPlacement(BlockItemUseContext p_196258_1_) {
        Direction direction = p_196258_1_.getHorizontalDirection().getOpposite();

        return this.defaultBlockState().setValue(FACING, direction);
    }

    public BlockRenderType getRenderShape(BlockState p_149645_1_) {
        return BlockRenderType.MODEL;
    }

    public VoxelShape getShape(BlockState p_220053_1_, IBlockReader p_220053_2_, BlockPos p_220053_3_, ISelectionContext p_220053_4_) {
        return Block.box(1.0D, 0.0D, 1.0D, 15.0D, 14.0D, 15.0D);
    }

    /*@Nullable
    private Direction candidatePartnerFacing(BlockItemUseContext p_196312_1_, Direction p_196312_2_) {
        BlockState blockstate = p_196312_1_.getLevel().getBlockState(p_196312_1_.getClickedPos().relative(p_196312_2_));
        return blockstate.is(this)? blockstate.getValue(FACING) : null;
    }*/

    protected void createBlockStateDefinition(StateContainer.Builder<Block, BlockState> p_206840_1_) {
        p_206840_1_.add(FACING);
    }

    @Override
    public ActionResultType use(BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockRayTraceResult rayTrace) {
        if (world.isClientSide)
            return ActionResultType.SUCCESS;
        INamedContainerProvider menuProvider = getMenuProvider(state, world, pos);
        if (menuProvider != null) {
            player.openMenu(menuProvider);
            player.awardStat(Stats.CUSTOM.get(Stats.OPEN_CHEST));
            PiglinTasks.angerNearbyPiglins(player, true);
        }
        return ActionResultType.CONSUME;
    }

    @Nullable
    @Override
    public TileEntity newBlockEntity(IBlockReader p_196283_1_) {
        return new SmeltingChestTileEntity();
    }

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

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

This is the block class

So I need implements IItemHandler instead of IInventory?

And then how can i get the smelting recipe of an item?

How can i use the RecipeWrapper?
I create a new RecipeWrapper with my ItemHandler, but then how can i get the fuel recipe from an item?

Ok thanks

Edited May 2, 20214 yr by Yurim64