Java FurnaceRecipes类代码示例

import net.minecraft.item.crafting.FurnaceRecipes; //导入依赖的package包/类
@SubscribeEvent
public void registerRecipes(RegistryEvent.Register<IRecipe> evt) {	
	IForgeRegistry<IRecipe> r = evt.getRegistry();
	
	for(EnumEdibleMeat meat : EnumEdibleMeat.values()) {
		ItemStack uncraftedRaw = meat.getRawItem().copy(); uncraftedRaw.setCount(9);
		ItemStack uncraftedCooked = meat.getCookedItem().copy(); uncraftedCooked.setCount(9);
		addMeatCompressionRecipe(r, meat, false, meat.getRawItem().copy());
		addMeatCompressionRecipe(r, meat, true,  meat.getCookedItem().copy());
		addMeatUncraftingRecipe(r, meat, false, uncraftedRaw);
		addMeatUncraftingRecipe(r, meat, true, uncraftedCooked);
		
		FurnaceRecipes.instance().addSmeltingRecipe(
				TWItems.meat(meat, false),
				TWItems.meat(meat, true),
				0.0f);
	}
	
	for(BlockGemrock block : TWBlocks.GROUP_GEMROCK) addBrickRecipes(r, block);
	
	//Norfairite can be dyed. This is surprisingly hard to get right.
	addDyeRecipes(r, TWBlocks.NORFAIRITE_CLEAR);
}
 

import net.minecraft.item.crafting.FurnaceRecipes; //导入依赖的package包/类
private boolean tryCookSlot(IItemHandler handler, int slot) {
    ItemStack stack = handler.getStackInSlot(slot);
    if (!stack.isEmpty()) {
        ItemStack result = FurnaceRecipes.instance().getSmeltingResult(stack);
        if (!result.isEmpty()) {
            ItemStack remainder = IOHelper.insert(getTileEntity(), result, true);
            if (remainder.isEmpty()) {
                IOHelper.insert(getTileEntity(), result, false);
                handler.extractItem(slot, 1, false);
                lastValidSlot = slot;
                return true;
            }
        }
    }
    return false;
}
 

import net.minecraft.item.crafting.FurnaceRecipes; //导入依赖的package包/类
@Override
protected float performWork() {
    if (WorkUtils.isDisabled(this.getBlockType())) return 0;

    boolean operation = false;
    for (int i = 0; i < input.getSlots(); ++i) {
        if (input.getStackInSlot(i).isEmpty()) continue;
        if (output.getStackInSlot(i).isEmpty() || (FurnaceRecipes.instance().getSmeltingResult(input.getStackInSlot(i)).isItemEqual(output.getStackInSlot(i)) && output.getStackInSlot(i).getCount() < output.getStackInSlot(i).getMaxStackSize())) {
            output.insertItem(i, FurnaceRecipes.instance().getSmeltingResult(input.getStackInSlot(i)).copy(), false);
            input.getStackInSlot(i).shrink(1);
            tank.fill(new FluidStack(FluidsRegistry.ESSENCE, (int) (FurnaceRecipes.instance().getSmeltingExperience(output.getStackInSlot(i)) * BlockRegistry.resourcefulFurnaceBlock.getExperienceMultiplier())), true);
            operation = true;
        }
    }
    return operation ? 1 : 0;
}
 

import net.minecraft.item.crafting.FurnaceRecipes; //导入依赖的package包/类
@Override
public boolean isItemValid(ItemStack stack) {
	if(!stack.isEmpty())
	{
		boolean flag = false;
       	int[] ids = OreDictionary.getOreIDs(stack);
       	for(int id: ids)
       		if(OreDictionary.getOreName(id).contains("food")){
       			flag = true;
       			break;
       		}
		if(stack.getItem() instanceof ItemFood || flag)
		{
			if(!FurnaceRecipes.instance().getSmeltingResult(stack).isEmpty())
			{
				return true;
			}
		}
	}
	return false;
}
 

import net.minecraft.item.crafting.FurnaceRecipes; //导入依赖的package包/类
@Override
public boolean isItemValid(ItemStack stack) {
	if(!stack.isEmpty())
	{
		if(stack.getItem() instanceof ItemBlock)
		{
			for(ItemStack ore : ores)
				if(OreDictionary.itemMatches(ore, stack, false))
				{
					return true;
				}
		}
		
		else
		{
			ItemStack result = FurnaceRecipes.instance().getSmeltingResult(getStack());
			if (result.getItem().equals(Items.field_191525_da))
			{
				return true;
			}
		}
	}
	return false;
}
 

import net.minecraft.item.crafting.FurnaceRecipes; //导入依赖的package包/类
@Override
public void onUpdate(EntityPlayer player, IRitualHandler tile, World world, BlockPos pos, NBTTagCompound data, int ticks) {
	if (ticks % 40 == 0) {
		List<EntityItem> smeltables = world.getEntitiesWithinAABB(EntityItem.class, new AxisAlignedBB(pos).grow(3), ie -> !FurnaceRecipes.instance().getSmeltingResult(ie.getItem()).isEmpty());
		smeltables.parallelStream().filter(ei -> !ei.getItem().getItem().hasContainerItem(ei.getItem())).findAny().ifPresent(e -> smeltAndSpawn(e));
		if (rng.nextDouble() < 0.1) {
			if (world.getGameRules().getBoolean("doFireTick")) {
				int x = Math.round(pos.getX()) - 5 + rng.nextInt(12);
				int y = Math.round(pos.getY()) - 5 + rng.nextInt(12);
				int z = Math.round(pos.getZ()) - 5 + rng.nextInt(12);
				if (y < 1)
					y = 1;
				if (y > world.getActualHeight())
					y = world.getActualHeight() - 2;
				BlockPos posn = new BlockPos(x, y, z);
				if (canBurn(world, posn))
					world.setBlockState(posn, Blocks.FIRE.getDefaultState());
			}
		}
	}
}
 

import net.minecraft.item.crafting.FurnaceRecipes; //导入依赖的package包/类
@Override
public void loadCraftingRecipes(ItemStack result) {
	result.stackSize = 1;
	if (dummy.isCookResultAcceptable(result)) {
		Map map = FurnaceRecipes.smelting().getSmeltingList();
		Iterator it = map.keySet().iterator();

		while (it.hasNext()) {
			ItemStack itemStack = (ItemStack) it.next();
			if (NEIClientUtils.areStacksSameTypeCrafting(FurnaceRecipes.smelting().getSmeltingResult(itemStack),
					result)) {
				arecipes.add(new CachedOvenRecipe(itemStack, result));
			}
		}

	}
}
 

import net.minecraft.item.crafting.FurnaceRecipes; //导入依赖的package包/类
/** Attempt to smelt the given item.<br>
 * This returns instantly, callously disregarding such frivolous niceties as cooking times or the presence of a furnace.<br>
 * It will, however, consume fuel from the player's inventory.
 * @param player
 * @param input the raw ingredients we want to cook.
 * @return true if cooking was successful.
 */
public static boolean attemptSmelting(EntityPlayerMP player, ItemStack input)
{
    if (player == null || input == null)
        return false;
    List<ItemStack> ingredients = new ArrayList<ItemStack>();
    ingredients.add(input);
    ItemStack isOutput = (ItemStack)FurnaceRecipes.instance().getSmeltingList().get(input);
    if (isOutput == null)
        return false;
    int cookingTime = 200;  // Seems to be hard-coded in TileEntityFurnace.
    if (playerHasIngredients(player, ingredients) && totalBurnTimeInInventory(player) >= cookingTime)
    {
        removeIngredientsFromPlayer(player, ingredients);
        burnInventory(player, cookingTime, input);

        ItemStack resultForInventory = isOutput.copy();
        ItemStack resultForReward = isOutput.copy();
        player.inventory.addItemStackToInventory(resultForInventory);
        RewardForCollectingItemImplementation.GainItemEvent event = new RewardForCollectingItemImplementation.GainItemEvent(resultForReward);
        MinecraftForge.EVENT_BUS.post(event);

        return true;
    }
    return false;
}
 

import net.minecraft.item.crafting.FurnaceRecipes; //导入依赖的package包/类
public static boolean isPartOfRecipe(ResourceLocation list, ItemStack stack)
{
    if (stack.isEmpty())
        return false;

    if (list.toString().equals("minecraft:vanilla"))
    {
        return !FurnaceRecipes.instance().getSmeltingResult(stack).isEmpty();
    }

    for (MachineRecipe recipe : getInstance(list).recipes)
    {
        if (recipe.getRecipeInput().stream()
                  .anyMatch(input -> ItemHelper.stackMatchesRecipeInput(stack, input, false)))
            return true;
    }

    return false;
}
 

import net.minecraft.item.crafting.FurnaceRecipes; //导入依赖的package包/类
/**
 * Returns true if the furnace can smelt an item, i.e. has a source item, destination stack isn't full, etc.
 */
private boolean canSmelt(int id)
{
    int inputIndex = type.getFirstInputSlot(id);
    int outputIndex = type.getFirstOutputSlot(id);

    ItemStack input = itemHandler.getStackInSlot(inputIndex);
    ItemStack output = itemHandler.getStackInSlot(outputIndex);

    if (input.isEmpty())
    {
        return false;
    } else
    {
        ItemStack res = FurnaceRecipes.instance().getSmeltingResult(input);
        if (res.isEmpty())
            return false;
        if (output.isEmpty())
            return true;
        if (!output.isItemEqual(res))
            return false;
        int result = output.getCount() + res.getCount();
        return result <= itemHandler.getSlotLimit(outputIndex) && result <= res.getMaxStackSize();
    }
}
 

import net.minecraft.item.crafting.FurnaceRecipes; //导入依赖的package包/类
public ItemStack apply(ItemStack stack, Random rand, LootContext context)
{
    ItemStack itemstack = FurnaceRecipes.instance().getSmeltingResult(stack);

    if (itemstack.func_190926_b())
    {
        LOGGER.warn("Couldn\'t smelt {} because there is no smelting recipe", new Object[] {stack});
        return stack;
    }
    else
    {
        ItemStack itemstack1 = itemstack.copy();
        itemstack1.func_190920_e(stack.func_190916_E());
        return itemstack1;
    }
}
 

import net.minecraft.item.crafting.FurnaceRecipes; //导入依赖的package包/类
/**
 * Returns true if the furnace can smelt an item, i.e. has a source item, destination stack isn't full, etc.
 */
private boolean canSmelt()
{
    if (((ItemStack)this.furnaceItemStacks.get(0)).func_190926_b())
    {
        return false;
    }
    else
    {
        ItemStack itemstack = FurnaceRecipes.instance().getSmeltingResult((ItemStack)this.furnaceItemStacks.get(0));

        if (itemstack.func_190926_b())
        {
            return false;
        }
        else
        {
            ItemStack itemstack1 = (ItemStack)this.furnaceItemStacks.get(2);
            return itemstack1.func_190926_b() ? true : (!itemstack1.isItemEqual(itemstack) ? false : (itemstack1.func_190916_E() < this.getInventoryStackLimit() && itemstack1.func_190916_E() < itemstack1.getMaxStackSize() ? true : itemstack1.func_190916_E() < itemstack.getMaxStackSize()));
        }
    }
}
 

import net.minecraft.item.crafting.FurnaceRecipes; //导入依赖的package包/类
/**
 * Turn one item from the furnace source stack into the appropriate smelted item in the furnace result stack
 */
public void smeltItem()
{
    if (this.canSmelt())
    {
        ItemStack itemstack = (ItemStack)this.furnaceItemStacks.get(0);
        ItemStack itemstack1 = FurnaceRecipes.instance().getSmeltingResult(itemstack);
        ItemStack itemstack2 = (ItemStack)this.furnaceItemStacks.get(2);

        if (itemstack2.func_190926_b())
        {
            this.furnaceItemStacks.set(2, itemstack1.copy());
        }
        else if (itemstack2.getItem() == itemstack1.getItem())
        {
            itemstack2.func_190917_f(1);
        }

        if (itemstack.getItem() == Item.getItemFromBlock(Blocks.SPONGE) && itemstack.getMetadata() == 1 && !((ItemStack)this.furnaceItemStacks.get(1)).func_190926_b() && ((ItemStack)this.furnaceItemStacks.get(1)).getItem() == Items.BUCKET)
        {
            this.furnaceItemStacks.set(1, new ItemStack(Items.WATER_BUCKET));
        }

        itemstack.func_190918_g(1);
    }
}
 

import net.minecraft.item.crafting.FurnaceRecipes; //导入依赖的package包/类
public ItemStack apply(ItemStack stack, Random rand, LootContext context)
{
    ItemStack itemstack = FurnaceRecipes.instance().getSmeltingResult(stack);

    if (itemstack == null)
    {
        LOGGER.warn("Couldn\'t smelt {} because there is no smelting recipe", new Object[] {stack});
        return stack;
    }
    else
    {
        ItemStack itemstack1 = itemstack.copy();
        itemstack1.stackSize = stack.stackSize;
        return itemstack1;
    }
}
 

import net.minecraft.item.crafting.FurnaceRecipes; //导入依赖的package包/类
/**
 * Returns true if the furnace can smelt an item, i.e. has a source item, destination stack isn't full, etc.
 */
private boolean canSmelt()
{
    if (this.furnaceItemStacks[0] == null)
    {
        return false;
    }
    else
    {
        ItemStack itemstack = FurnaceRecipes.instance().getSmeltingResult(this.furnaceItemStacks[0]);
        if (itemstack == null) return false;
        if (this.furnaceItemStacks[2] == null) return true;
        if (!this.furnaceItemStacks[2].isItemEqual(itemstack)) return false;
        int result = furnaceItemStacks[2].stackSize + itemstack.stackSize;
        return result <= getInventoryStackLimit() && result <= this.furnaceItemStacks[2].getMaxStackSize(); //Forge BugFix: Make it respect stack sizes properly.
    }
}