Поломка рецептов + выдачи лута из кастомной печи.

Kifor4ik · 17 Июл 2020

Времени доброго суток , будет очень много кода.

Создал кастомную , будем называть её печь.
В ней есть 4 слота.
топливо
2 слота входа
выход.

Всё работает адекватно , кроме выхода.
Описываю проблемы
1. Если забиваю рецепт , допустим Кость + Яблоко = Алмаз и Яблоко + Кость = Алмаз , То второй вариант уже не работает .
2. Если забираю со слота выхода левой кнопкой мыши,предмет просто демолекулируется и исчезает во времени и пространстве. Плюс к этому,рецепт который был связан с этим выходом просто перестает работать , вообще.
3. Если предмет выкидывать (навести мышь + нажать Q) , то после смены пары рецептов или просто крафтов , он может начать выдавать не 1 предмет на выходе, а 2 , потом 4 и так повышение вплоть до полного стака.
4. Помогите пожалуйста я уже 4 дня не сплю , фиксить пытаюсь.

Код всех классов прилагаю ниже

Сам Блок :

Код:

public class BlockChemicFire extends BlockBase
{
    public static final PropertyDirection FACING = BlockHorizontal.FACING;
    public static final PropertyBool BURNING = PropertyBool.create("burning");
    
    public BlockChemicFire(String name) 
    {
        super(name, Material.IRON);
        setSoundType(SoundType.METAL);
        this.setDefaultState(this.blockState.getBaseState().withProperty(FACING, EnumFacing.NORTH).withProperty(BURNING, false));
    }
    
    @Override
    public Item getItemDropped(IBlockState state, Random rand, int fortune) 
    {
        return Item.getItemFromBlock(MainBlocks.CHEMIC);
    }
    
    @Override
    public ItemStack getItem(World worldIn, BlockPos pos, IBlockState state)
    {
        return new ItemStack(MainBlocks.CHEMIC);
    }
    
    @Override
    public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) 
    {
        if(!worldIn.isRemote)
        {
            playerIn.openGui(Main.instance, Reference.GUI_CHEMICFIRE, worldIn, pos.getX(), pos.getY(), pos.getZ());
        }
        
        return true;
    }
    
    @Override
    public void onBlockAdded(World worldIn, BlockPos pos, IBlockState state) 
    {
        if (!worldIn.isRemote) 
        {
            IBlockState north = worldIn.getBlockState(pos.north());
            IBlockState south = worldIn.getBlockState(pos.south());
            IBlockState west = worldIn.getBlockState(pos.west());
            IBlockState east = worldIn.getBlockState(pos.east());
            EnumFacing face = (EnumFacing)state.getValue(FACING);

            if (face == EnumFacing.NORTH && north.isFullBlock() && !south.isFullBlock()) face = EnumFacing.SOUTH;
            else if (face == EnumFacing.SOUTH && south.isFullBlock() && !north.isFullBlock()) face = EnumFacing.NORTH;
            else if (face == EnumFacing.WEST && west.isFullBlock() && !east.isFullBlock()) face = EnumFacing.EAST;
            else if (face == EnumFacing.EAST && east.isFullBlock() && !west.isFullBlock()) face = EnumFacing.WEST;
            worldIn.setBlockState(pos, state.withProperty(FACING, face), 2);
        }
    }
    
    public static void setState(boolean active, World worldIn, BlockPos pos) 
    {
        IBlockState state = worldIn.getBlockState(pos);
        TileEntity tileentity = worldIn.getTileEntity(pos);
        
        //if(active) worldIn.setBlockState(pos, BlockInit.SINTERING_FURNACE.getDefaultState().withProperty(FACING, state.getValue(FACING)).withProperty(BURNING, true), 3);
        //else worldIn.setBlockState(pos, BlockInit.SINTERING_FURNACE.getDefaultState().withProperty(FACING, state.getValue(FACING)).withProperty(BURNING, false), 3);
        
        if(tileentity != null) 
        {
            tileentity.validate();
            worldIn.setTileEntity(pos, tileentity);
        }
    }
    
    @Override
    public boolean hasTileEntity(IBlockState state) 
    {
        return true;
    }
    
    
    
    @Override
    public TileEntity createTileEntity(World world, IBlockState state) 
    {
        return new TileEntityChemicFire();
    }
    
    @Override
    public IBlockState getStateForPlacement(World world, BlockPos pos, EnumFacing facing, float hitX, float hitY, float hitZ, int meta, EntityLivingBase placer, EnumHand hand) 
    {
        return this.getDefaultState().withProperty(FACING, placer.getHorizontalFacing().getOpposite());
    }
    
    @Override
    public void onBlockPlacedBy(World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack) 
    {
        worldIn.setBlockState(pos, this.getDefaultState().withProperty(FACING, placer.getHorizontalFacing().getOpposite()), 2);
    }
    
    @Override
    public EnumBlockRenderType getRenderType(IBlockState state) 
    {
        return EnumBlockRenderType.MODEL;
    }
    
    @Override
    public IBlockState withRotation(IBlockState state, Rotation rot)
    {
        return state.withProperty(FACING, rot.rotate((EnumFacing)state.getValue(FACING)));
    }
    
    @Override
    public IBlockState withMirror(IBlockState state, Mirror mirrorIn) 
    {
        return state.withRotation(mirrorIn.toRotation((EnumFacing)state.getValue(FACING)));
    }
    
    @Override
    protected BlockStateContainer createBlockState() 
    {
        return new BlockStateContainer(this, new IProperty[] {BURNING,FACING});
    }
    
    @Override
    public IBlockState getStateFromMeta(int meta) 
    {
        EnumFacing facing = EnumFacing.getFront(meta);
        if(facing.getAxis() == EnumFacing.Axis.Y) facing = EnumFacing.NORTH;
        return this.getDefaultState().withProperty(FACING, facing);
    }
    
    @Override
    public int getMetaFromState(IBlockState state) 
    {
        return ((EnumFacing)state.getValue(FACING)).getIndex();
    }    
}

Контейнер:

Код:

public class ContainerChemicFire extends Container
{
    private final TileEntityChemicFire tileentity;
    private int cookTime, totalCookTime, burnTime, currentBurnTime;
    
    public ContainerChemicFire(InventoryPlayer player, TileEntityChemicFire tileentity) 
    {
       
        this.tileentity = tileentity;
        IItemHandler handler = tileentity.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null);
        
        this.addSlotToContainer(new SlotItemHandler(handler, 0, 26, 11));
        this.addSlotToContainer(new SlotItemHandler(handler, 1, 26, 59));
        this.addSlotToContainer(new SlotFuel(handler, 2, 7, 35));
        this.addSlotToContainer(new SlotOutPut(Minecraft.getMinecraft().player, handler, 3, 81, 35));
        
        for(int y = 0; y < 3; y++)
        {
            for(int x = 0; x < 9; x++)
            {
                this.addSlotToContainer(new Slot(player, x + y*9 + 9, 8 + x*18, 84 + y*18));
            }
        }
        
        for(int x = 0; x < 9; x++)
        {
            this.addSlotToContainer(new Slot(player, x, 8 + x * 18, 142));
        }
    }
    
    @Override
    public void detectAndSendChanges() 
    {
        super.detectAndSendChanges();
        
        for(int i = 0; i < this.listeners.size(); ++i) 
        {
            IContainerListener listener = (IContainerListener)this.listeners.get(i);
            
            if(this.cookTime != this.tileentity.getField(2)) listener.sendWindowProperty(this, 2, this.tileentity.getField(2));
            if(this.burnTime != this.tileentity.getField(0)) listener.sendWindowProperty(this, 0, this.tileentity.getField(0));
            if(this.currentBurnTime != this.tileentity.getField(1)) listener.sendWindowProperty(this, 1, this.tileentity.getField(1));
            if(this.totalCookTime != this.tileentity.getField(3)) listener.sendWindowProperty(this, 3, this.tileentity.getField(3));
        }
        
        this.cookTime = this.tileentity.getField(2);
        this.burnTime = this.tileentity.getField(0);
        this.currentBurnTime = this.tileentity.getField(1);
        this.totalCookTime = this.tileentity.getField(3);
    }
    
    @Override
    @SideOnly(Side.CLIENT)
    public void updateProgressBar(int id, int data) 
    {
        this.tileentity.setField(id, data);
    }
    
    @Override
    public boolean canInteractWith(EntityPlayer playerIn) 
    {
        return this.tileentity.isUsableByPlayer(playerIn);
    }
    
    @Override
    public ItemStack transferStackInSlot(EntityPlayer playerIn, int index) 
    {
        ItemStack stack = ItemStack.EMPTY;
        Slot slot = (Slot)this.inventorySlots.get(index);
        
        if(slot != null && slot.getHasStack()) 
        {
            ItemStack stack1 = slot.getStack();
            stack = stack1.copy();
            
            if(index == 3) 
            {
                if(!this.mergeItemStack(stack1, 4, 40, true)) return ItemStack.EMPTY;
                slot.onSlotChange(stack1, stack);
            }
            else if(index != 2 && index != 1 && index != 0) 
            {        
                Slot slot1 = (Slot)this.inventorySlots.get(index + 1);
                
                if(!RecipesChemicFire.getInstance().getSinteringResult(stack1, slot1.getStack()).isEmpty())
                {
                    if(!this.mergeItemStack(stack1, 0, 2, false)) 
                    {
                        return ItemStack.EMPTY;
                    }
                    else if(TileEntityChemicFire.isItemFuel(stack1))
                    {
                        if(!this.mergeItemStack(stack1, 2, 3, false)) return ItemStack.EMPTY;
                    }
                    else if(TileEntityChemicFire.isItemFuel(stack1))
                    {
                        if(!this.mergeItemStack(stack1, 2, 3, false)) return ItemStack.EMPTY;
                    }
                    else if(TileEntityChemicFire.isItemFuel(stack1))
                    {
                        if(!this.mergeItemStack(stack1, 2, 3, false)) return ItemStack.EMPTY;
                    }
                    else if(index >= 4 && index < 31)
                    {
                        if(!this.mergeItemStack(stack1, 31, 40, false)) return ItemStack.EMPTY;
                    }
                    else if(index >= 31 && index < 40 && !this.mergeItemStack(stack1, 4, 31, false))
                    {
                        return ItemStack.EMPTY;
                    }
                }
            } 
            else if(!this.mergeItemStack(stack1, 4, 40, false)) 
            {
                return ItemStack.EMPTY;
            }
            if(stack1.isEmpty())
            {
                slot.putStack(ItemStack.EMPTY);
            }
            else
            {
                slot.onSlotChanged();

            }
            if(stack1.getCount() == stack.getCount()) return ItemStack.EMPTY;
            slot.onTake(playerIn, stack1);
        }
        return stack;
    }
}

TileEntity:

Код:

public class TileEntityChemicFire extends TileEntity implements ITickable
{
    private ItemStackHandler handler = new ItemStackHandler(4);
    private String customName;
    private ItemStack smelting = ItemStack.EMPTY;
    
    private int burnTime;
    private int currentBurnTime;
    private int cookTime;
    private int totalCookTime = 80;

    @Override
    public boolean hasCapability(Capability<?> capability, EnumFacing facing) 
    {
        if(capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) return true;
        else return false;
    }
    
    @Override
    public <T> T getCapability(Capability<T> capability, EnumFacing facing) 
    {
        if(capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) return (T) this.handler;
        return super.getCapability(capability, facing);
    }
    
    public boolean hasCustomName() 
    {
        return this.customName != null && !this.customName.isEmpty();
    }
    
    public void setCustomName(String customName) 
    {
        this.customName = customName;
    }
    
    @Override
    public ITextComponent getDisplayName() 
    {
        return this.hasCustomName() ? new TextComponentString(this.customName) : new TextComponentTranslation("");
    }
    
    @Override
    public void readFromNBT(NBTTagCompound compound)
    {
        super.readFromNBT(compound);
        this.handler.deserializeNBT(compound.getCompoundTag("Inventory"));
        this.burnTime = compound.getInteger("BurnTime");
        this.cookTime = compound.getInteger("CookTime");
        this.totalCookTime = compound.getInteger("CookTimeTotal");
        this.currentBurnTime = getItemBurnTime((ItemStack)this.handler.getStackInSlot(2));
        
        if(compound.hasKey("CustomName", 8)) this.setCustomName(compound.getString("CustomName"));
    }
    
    @Override
    public NBTTagCompound writeToNBT(NBTTagCompound compound) 
    {
        super.writeToNBT(compound);
        compound.setInteger("BurnTime", (short)this.burnTime);
        compound.setInteger("CookTime", (short)this.cookTime);
        compound.setInteger("CookTimeTotal", (short)this.totalCookTime);
        compound.setTag("Inventory", this.handler.serializeNBT());
        
        if(this.hasCustomName()) compound.setString("CustomName", this.customName);
        return compound;
    }
    
    public boolean isBurning() 
    {
        return this.burnTime > 0;
    }
    
    @SideOnly(Side.CLIENT)
    public static boolean isBurning(TileEntityChemicFire te) 
    {
        return te.getField(0) > 0;
    }
    
    public void update() 
    {    
        
        
        ItemStack fuel = this.handler.getStackInSlot(2);
        ItemStack output = RecipesChemicFire.getInstance().getSinteringResult(this.handler.getStackInSlot(0), this.handler.getStackInSlot(1) );
        ItemStack slotUP = this.handler.getStackInSlot(0);
        ItemStack slotDOWN = this.handler.getStackInSlot(1);
        smelting = output;
        if(this.isBurning() ) {
            --this.burnTime;
        }
        if(cookTime > 0 && !this.canSmelt() ) {
            --this.cookTime;
        }
        
        if(!this.isBurning() && !fuel.isEmpty()) {
            this.burnTime = getItemBurnTime(fuel);
            this.currentBurnTime = burnTime;
            fuel.shrink(1);
        }
        
        // recipes
        if(this.isBurning() && this.canSmelt() && !this.handler.getStackInSlot(0).isEmpty() && !this.handler.getStackInSlot(1).isEmpty() && this.handler.getStackInSlot(3).isEmpty() ) {
            this.cookTime++;
            if(cookTime == totalCookTime ) {
                this.handler.getStackInSlot(0).shrink(1);
                this.handler.getStackInSlot(1).shrink(1);
                this.handler.insertItem(3, smelting, false);
                cookTime = 0;
            }
        }
        
    }
    
    
    private boolean canSmelt() 
    {
        if(((ItemStack)this.handler.getStackInSlot(0)).isEmpty() || ((ItemStack)this.handler.getStackInSlot(1)).isEmpty()) return false;
        else 
        {
            
            ItemStack result = RecipesChemicFire.getInstance().getSinteringResult((ItemStack)this.handler.getStackInSlot(0), (ItemStack)this.handler.getStackInSlot(1));    
            if(result.isEmpty()) return false;
            else
            {    
                if (this.handler.getStackInSlot(3).isEmpty() == true) return true;
                else return false;

            }
        }
    }
    
    
    public static int getItemBurnTime(ItemStack fuel) 
    {
        if(fuel.isEmpty()) return 0;
        else 
        {
            Item item = fuel.getItem();

            if (item instanceof ItemBlock && Block.getBlockFromItem(item) != Blocks.AIR) 
            {
                Block block = Block.getBlockFromItem(item);

                if (block == Blocks.WOODEN_SLAB) return 150;
                if (block.getDefaultState().getMaterial() == Material.WOOD) return 300;
                if (block == Blocks.COAL_BLOCK) return 16000;
            }

            if (item instanceof ItemTool && "WOOD".equals(((ItemTool)item).getToolMaterialName())) return 200;
            if (item instanceof ItemSword && "WOOD".equals(((ItemSword)item).getToolMaterialName())) return 200;
            if (item instanceof ItemHoe && "WOOD".equals(((ItemHoe)item).getMaterialName())) return 200;
            if (item == Items.STICK) return 100;
            if (item == Items.COAL) return 1600;
            if (item == Items.LAVA_BUCKET) return 20000;
            if (item == Item.getItemFromBlock(Blocks.SAPLING)) return 100;
            if (item == Items.BLAZE_ROD) return 2400;

            return GameRegistry.getFuelValue(fuel);
        }
    }
        
    public static boolean isItemFuel(ItemStack fuel)
    {
        return getItemBurnTime(fuel) > 0;
    }
    
    public boolean isUsableByPlayer(EntityPlayer player) 
    {
        return this.world.getTileEntity(this.pos) != this ? false : player.getDistanceSq((double)this.pos.getX() + 0.5D, (double)this.pos.getY() + 0.5D, (double)this.pos.getZ() + 0.5D) <= 64.0D;
    }

    public int getField(int id) 
    {
        switch(id) 
        {
        case 0:
            return this.burnTime;
        case 1:
            return this.currentBurnTime;
        case 2:
            return this.cookTime;
        case 3:
            return this.totalCookTime;
        default:
            return 0;
        }
    }

    public void setField(int id, int value) 
    {
        switch(id) 
        {
        case 0:
            this.burnTime = value;
            break;
        case 1:
            this.currentBurnTime = value;
            break;
        case 2:
            this.cookTime = value;
            break;
        case 3:
            this.totalCookTime = value;
        }
    }
}

GUI:

Код:

public class GuiChemicFire extends GuiContainer
{
    private static final ResourceLocation TEXTURES = new ResourceLocation(Reference.MODID + ":textures/gui/chemic.png");
    private final InventoryPlayer player;
    private final TileEntityChemicFire tileentity;
    
    public GuiChemicFire(InventoryPlayer player, TileEntityChemicFire tileentity) 
    {
        super(new ContainerChemicFire(player, tileentity));
        this.player = player;
        this.tileentity = tileentity;
    }
    
    @Override
    protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY) 
    {
        String tileName = this.tileentity.getDisplayName().getUnformattedText();
        this.fontRenderer.drawString(tileName, (this.xSize / 2 - this.fontRenderer.getStringWidth(tileName) / 2) + 3, 8, 4210752);
        this.fontRenderer.drawString(this.player.getDisplayName().getUnformattedText(), 122, this.ySize - 96 + 2, 4210752);
    }
    
    @Override
    protected void drawGuiContainerBackgroundLayer(float partialTicks, int mouseX, int mouseY)
    {
        GlStateManager.color(1.0f, 1.0f, 1.0f, 1.0f);
        this.mc.getTextureManager().bindTexture(TEXTURES);
        this.drawTexturedModalRect(this.guiLeft, this.guiTop, 0, 0, this.xSize, this.ySize);
        
        if(TileEntityChemicFire.isBurning(tileentity))
        {
            int k = this.getBurnLeftScaled(13);
            this.drawTexturedModalRect(this.guiLeft + 8, this.guiTop + 54 + 12 - k, 176, 12 - k, 14, k + 1);
        }
        
        int l = this.getCookProgressScaled(24);
        this.drawTexturedModalRect(this.guiLeft + 44, this.guiTop + 36, 176, 14, l + 1, 16);
    }
    
    private int getBurnLeftScaled(int pixels)
    {
        int i = this.tileentity.getField(1);
        if(i == 0) i = 200;
        return this.tileentity.getField(0) * pixels / i;
    }
    
    private int getCookProgressScaled(int pixels)
    {
        int i = this.tileentity.getField(2);
        int j = this.tileentity.getField(3);
        return j != 0 && i != 0 ? i * pixels / j : 0;
    }
}

Рецепты:

Код:

public class RecipesChemicFire 
{    
    private static final RecipesChemicFire INSTANCE = new RecipesChemicFire();
    private final Table<ItemStack, ItemStack, ItemStack> smeltingList = HashBasedTable.<ItemStack, ItemStack, ItemStack>create();
    private final Map<ItemStack, Float> experienceList = Maps.<ItemStack, Float>newHashMap();
    
    public static RecipesChemicFire getInstance()
    {
        return INSTANCE;
    }
    
    
    
    private RecipesChemicFire() 
    {
        addSinteringRecipe(new ItemStack(Items.BONE), new ItemStack(MainItems.POTION_WATER), new ItemStack(MainItems.POTION_HEAL_5), 0.0F);
        addSinteringRecipe(new ItemStack(Items.APPLE), new ItemStack(MainItems.POTION_WATER), new ItemStack(MainItems.POTION_REGEN_1), 0.0F);
        addSinteringRecipe(new ItemStack(Items.CARROT), new ItemStack(MainItems.POTION_WATER), new ItemStack(MainItems.POTION_NIGHTVISION), 0.0F);
    }
    

    
    public void addSinteringRecipe(ItemStack input1, ItemStack input2, ItemStack result, float experience) 
    {
        if(getSinteringResult(input1, input2) != ItemStack.EMPTY) return;
        this.smeltingList.put(input1, input2, result);
        this.experienceList.put(result, Float.valueOf(experience));
    }
    
    public ItemStack getSinteringResult(ItemStack input1, ItemStack input2) 
    {
        for(Entry<ItemStack, Map<ItemStack, ItemStack>> entry : this.smeltingList.columnMap().entrySet()) 
        {
            if(this.compareItemStacks(input1, (ItemStack)entry.getKey())) 
            {
                for(Entry<ItemStack, ItemStack> ent : entry.getValue().entrySet()) 
                {
                    if(this.compareItemStacks(input2, (ItemStack)ent.getKey())) 
                    {
                        return (ItemStack)ent.getValue();
                    }
                }
            }
        }
        return ItemStack.EMPTY;
    }
    
    private boolean compareItemStacks(ItemStack stack1, ItemStack stack2)
    {
        return stack2.getItem() == stack1.getItem() && (stack2.getMetadata() == 32767 || stack2.getMetadata() == stack1.getMetadata());
    }
    
    public Table<ItemStack, ItemStack, ItemStack> getDualSmeltingList() 
    {
        return this.smeltingList;
    }
    
    public float getSinteringExperience(ItemStack stack)
    {
        for (Entry<ItemStack, Float> entry : this.experienceList.entrySet()) 
        {
            if(this.compareItemStacks(stack, (ItemStack)entry.getKey())) 
            {
                return ((Float)entry.getValue()).floatValue();
            }
        }
        return 0.0F;
    }
}

Слот топлива:

Код:

public class SlotFuel extends SlotItemHandler {
    
    public SlotFuel(IItemHandler itemHandler, int index, int xPosition, int yPosition) {
        super(itemHandler, index, xPosition, yPosition);
    }

    @Override
    public boolean isItemValid(ItemStack stack) {
        return TileEntityFurnace.isItemFuel(stack) || net.minecraft.inventory.SlotFurnaceFuel.isBucket(stack);
    }
    
    @Override
    public int getItemStackLimit(ItemStack stack) {
        return net.minecraft.inventory.SlotFurnaceFuel.isBucket(stack) ? 1 : super.getItemStackLimit(stack);
    }

}

Слот Выхода:

Код:

public class SlotOutPut extends SlotItemHandler {

    private final EntityPlayer player;
    private int removeCount;

    public SlotOutPut(EntityPlayer player, IItemHandler itemHandler, int index,
            int xPosition, int yPosition) {
        super(itemHandler, index, xPosition, yPosition);
        this.player = player;
    }

    @Override
    public boolean isItemValid(ItemStack stack) {
        return false;
    }

    @Override
    public ItemStack decrStackSize(int amount) {
        if (this.getHasStack())
            this.removeCount += Math.min(amount, this.getStack().getCount());
        return super.decrStackSize(amount);
    }

    @Override
    public ItemStack onTake(EntityPlayer player, ItemStack stack) {
        this.onCrafting(stack);
        super.onTake(player, stack);
        return stack;
    }

    @Override
    protected void onCrafting(ItemStack stack, int amount) {
        this.removeCount += amount;
        this.onCrafting(stack);
    }

    @Override
    protected void onCrafting(ItemStack stack) {
        stack.onCrafting(this.player.world, this.player, this.removeCount);

        if (!this.player.world.isRemote) {
            int i = this.removeCount;
            float f = RecipesChemicFire.getInstance().getSinteringExperience(stack);

            if (f == 0.0F) {
                i = 0;
            } else if (f < 1.0F) {
                int j = MathHelper.floor((float) i * f);
                
                if (j < MathHelper.ceil((float) i * f) && Math.random() < (double) ((float) i * f - (float) j))
                    j++;

                i = j;
            }

            while (i > 0) {
                int k = EntityXPOrb.getXPSplit(i);
                i -= k;
                this.player.world.spawnEntity(new EntityXPOrb(this.player.world, this.player.posX,
                        this.player.posY + 0.5D, this.player.posZ + 0.5D, k));
            }
        }

        this.removeCount = 0;

        FMLCommonHandler.instance().firePlayerSmeltedEvent(this.player, stack);

    }

}

hohserg · 20 Июл 2020

Пример кастомной печки:

https://github.com/EndersMagic/EnderMagic/blob/master/src/main/scala/ru/mousecray/endmagic/blocks/BlockBlastFurnace.java

https://github.com/EndersMagic/EnderMagic/blob/master/src/main/scala/ru/mousecray/endmagic/tileentity/TileBlastFurnace.java

EnderMagic/src/main/scala/ru/mousecray/endmagic/inventory at master · EndersMagic/EnderMagic

Mod adds a variety of things related to The End and Teleportation. - EndersMagic/EnderMagic

github.com

Поломка рецептов + выдачи лута из кастомной печи.

Kifor4ik

EnderMagic/src/main/scala/ru/mousecray/endmagic/inventory at master · EndersMagic/EnderMagic

hohserg

EnderMagic/src/main/scala/ru/mousecray/endmagic/inventory at master · EndersMagic/EnderMagic