Recipes

The following recipes are supported by KubeJS TFC:

If FirmaLife is installed, the following recipes are supported:

If ArborFirmaCraft is installed, the following recipes are supported:

Alloy

See the main page!

Method Signature 

event.recipes.tfc.alloy(
    result: String,
    contents: AlloyPart[]
)
  • 1st argument: A string representing the name of a metal
  • 2nd argument: An array of AlloyParts defining the components and their percentage ranges for the recipe

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.alloy(
        'tfc:metal',
        [
            TFC.alloyPart('tfc:copper', 0.2, 0.3),
            TFC.alloyPart('tfc:rose_gold', 0.4, 0.8),
            TFC.alloyPart('tfc:black_steel', 0.2, 0.5)
        ]
    )
})

Welding

See the main page!

Method signature 

event.recipes.tfc.welding(
    result: ItemStackProvider,
    firstInput: Ingredient,
    secondInput: Ingredient,
    tier?: number
)
  • 1st argument: An ItemStackProvider, the result of the recipe
  • 2nd argument: An item ingredient
  • 3rd argument: An item ingredient
  • Optional 4th argument: A number, the minimum tier of anvil the recipe may be completed on, defaults to -1

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.welding(
        'minecraft:brick',
        'tfc:rock/cobble/dacite',
        'minecraft:clay'
    )
})

Working

See the main page!

Method Signature 

event.recipes.tfc.anvil(
    result: ItemStackProvider,
    input: Ingredient,
    rules: ForgeRule[]
)
    // Additional methods
    .tier(tier: number)
    .bonus(applyBonus: boolean)
  • 1st argument: An ItemStackProvider, the result of the recipe
  • 2nd argument: An item ingredient
  • 3rd argument: An array of up to 3 ForgeRules, see the main page for a full list

  • .tier(tier:number): Accepts a number and sets the minimum anvil tier the recipe can be performed on, defaults to -1
  • .bonus(applyBnus: boolean): Accepts a boolean and sets if the recipe will apply a forging bonus, defaults to false

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.anvil(
        'kubejs:my_cool_shears',
        'kubejs:unworked_shears',
        [
            'hit_not_last',
            'upset_any'
        ]
    ).bonus(true)
})

Barrel Instant Fluid

See the main page!

Method Signature 

event.recipes.tfc.barrel_instant_fluid(
    outputFluid: FluidStack,
    primaryFluid: FluidStackIngredient,
    addedFluid: FluidStackIngredient,
    sound?: String
)
  • 1st argument: A FluidStack, the result of the recipe
  • 2nd argument: A FluidStackIngredient, the input fluid in the barrel
  • 3rd argument: A FluidStackIngredient, the input fluid added via a fluid container
  • Optional 4th argument: A string, the registry name of a sound event, defaults to minecraft:block.brewing_stand.brew1

Barrels will not accept fluids that are not tagged tfc:usable_in_barrel, make sure that both the output fluid and the input fluid(s) are tagged as such

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.barrel_instant_fluid(
        Fluid.of('minecraft:water', 50),
        TFC.fluidStackIngredient('#forge:milk', 30),
        TFC.fluidStackIngredient('minecraft:lava', 20)
    )
})

Barrel Instant

See the main page!

Method Signature 

event.recipes.tfc.barrel_instant()
    // Additional methods
    .outputItem(outputItem: ItemStackProvider)
    .outputFluid(outputFluid: FluidStack)
    .outputs(outputItem: ItemStackProvider, outputFluid: FluidStack)
    .inputItem(inputItem: Ingredient)
    .inputFluid(inputFluid: FluidStackIngredient)
    .inputs(inputItem: Ingredient, inputFluid: FluidStackIngredient)
    .sound(sound: String)
  • .outputItem(otuputItem: ItemStackProvider): Accepts an ItemStackProvider and sets the recipe’s output item, defaults to empty
  • .outputFluid(outputFluid: FluidStack): Accepts a FluidStack and sets the recipe’s output fluid, defaults to empty
  • .outputs(outputItem: ItemStackProvider, outputFluif: FluidStack): A convenience method for setting both outputs, identical to calling .outputItem(outputItem).outputFluid(outputFluid)
  • .inputItem(inputItem: Ingredient): Accepts an item ingredient and sets the recipe’s input item, will accept counts greater than 1, defaults to empty
  • .inputFluid(inputFluid: FluidStackIngredient): Accepts a FluidStackIngredient and sets the recipe’s input fluid, defaults to empty
  • .inputs(inputItem: Ingredient, inputFluid: FluidStackIngredient): A convenience method for setting both inputs, identical to calling .inputItem(inputItem).inputFluid(inputFluid)
  • .sound(sound: String): Accepts a string, representing the registry name of a sound event which is played when a recipe finishes, defaults to minecraft:block.brewing_stand.brew1

An instant barrel recipe must have an input item, input fluid, or both

Barrels will not accept fluids that are not tagged tfc:usable_in_barrel, make sure that the input/output fluid(s) are tagged as such

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.barrel_instant()
        .outputs(TFC.itemStackProvider.of('minecraft:cooked_porkchop').copyFood(), TFC.fluidStackIngredient('kubejs:grease', 50))
        .inputItem('4x minecraft:cooked_beef')
})

Barrel Sealed

See the main page!

Method Signature 

event.recipes.tfc.barrel_sealed(duration: number)
    // Additional methods
    .outputItem(outputItem: ItemStackProvider)
    .outputFluid(outputFluid: FluidStack)
    .outputs(outputItem: ItemStackProvider, outputFluid: FluidStack)
    .inputItem(inputItem: Ingredient)
    .inputFluid(inputFluid: FluidStackIngredient)
    .inputs(inputItem: Ingredient, inputFluid: FluidStackIngredient)
    .sound(sound: String)
    .onSeal(onSeal: ItemStackProvider)
    .onUnseal(onUnseal: ItemStackProvider)
    .seal(onSeal: ItemStackProvider, onUnseal: ItemStackProvider)
  • 1st argument: A number, sets the duration in ticks the barrel must be sealed for, a duration of -1 will make the recipe infinite, one or both of the seal types should be defined

  • .outputItem(outputItem: ItemStackProvider): Accepts an ItemStackProvider and sets the recipe’s output item, defaults to empty
  • .outputFluid(outputFluid: FluidStack): Accepts a FluidStack and sets the recipe’s output fluid, defaults to empty
  • .outputs(outputItem: ItemStackProvider, outputFluid: FluidStack): A convenience method for setting both outputs, identical to calling .outputItem(outputItem).outputFluid(outputFluid)
  • .inputItem(inputItem: Ingredient): Accepts an item ingredient and sets the recipe’s input item, will accept counts greater than 1, defaults to empty
  • .inputFluid(inputFluid: FluidStackIngredient): Accepts a FluidStackIngredient and sets the recipe’s input fluid, defaults to empty
  • .inputs(inputItem: Ingredient, inputFluid: FluidStackIngredeint): A convenience method for setting both inputs, identical to .inputItem(inputItem).inputFluid(inputFluid)
  • .sound(sound: String): Accepts a string, representing the registry name of a sound event which is played when a recipe finishes, defaults to minecraft:block.brewing_stand.brew1
  • .onSeal(onSeal: ItemStackProvider): Accepts an ItemStackProvider which will be applied when the barrel is sealed
  • .onUnseal(onUnseal: ItemStackProvider): Accepts an ItemStackProvider which will be applied when the barrel is unsealed
  • .seal(onSeal: ItemStackProvider, onUnseal: ItemStackProvider): A convenience method for setting both seals, identical to calling .onSeal(onSeal).onUnseal(onUnseal)

A sealed barrel recipe must have an input item, input fluid, or both

Barrels will not accept fluids that are not tagged tfc:usable_in_barrel, make sure that the input/output fluid(s) are tagged as such

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.barrel_sealed(5000)
        .outputItem('8x minecraft:mud')
        .inputs('8x #tfc:dirt', TFC.fluidStackIngredient('#minecraft:water', 1000))
})

Blast Furnace

See the main page!

Method Signature 

event.recipes.tfc.blast_furnace(
    result: FluidStack,
    catalyst: Ingredient,
    fluid: FluidStackIngredient
)
  • 1st argument: A FluidStack, the output fluid of the recipe
  • 2nd argument: An item ingredient specifying the catalyst item
  • 3rd argument: A FluidStackIngredient

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.blast_furnace(
        Fluid.of('tfc:metal/zinc', 5),
        'kubejs:magic_catalyst',
        TFC.fluidStackIngredient(['tfc:metal/copper', 'tfc:metal/nickel'], 90)
    )
})

Bloomery

See the main page!

Method Signature 

event.recipes.tfc.bloomery(
    result: ItemStackProvider,
    catalyst: Ingredient,
    fluid: FluidStackIngredient,
    duration: number
)
  • 1st argument: An ItemStackProvider, the result of the recipe
  • 2nd argument: An item ingredient, the ingredient which catalysts match, will accept amounts greater than 1
  • 3rd argument: A FluidStackIngredient
  • 4th argument: A number, the number of ticks until the recipe is complete

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.bloomery(
        '3x minecraft:dirt',
        '#kubejs:dirt_makers',
        Fluid.of('kubejs:dirt_fluid', 50),
        5000
    )
})

Casting

See the main page!

Method Signature 

event.recipes.tfc.casting(
    result: ItemStackProvider,
    mold: Ingredient,
    fluid: FluidStackIngredient,
    breakChance: number
)
  • 1st argument: An ItemStackProvider, the output of the recipe
  • 2nd argument: An item ingredient, used to match the mold item
  • 3rd argument: A FluidStackIngredient
  • 4th argument: A number in the range [0, 1], the probability that the mold will break upon completion of the recipe, a higher number means a higher chance

All input fluids for the recipe must have the appropriate fluid tag in order for the mold item to accept them, typically this is either tfc:usable_in_ingot_mold or tfc:usable_in_tool_head_mold

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.casting(
        '8x ae2:skystone',
        'kubejs:block_mold',
        TFC.fluidStackIngredient('minecraft:lava', 4000),
        1
    )
})

Chisel

See the main page!

Method Signature 

event.recipes.tfc.chisel(result: BlockState, ingredient: BlockIngredient, mode: ChiselMode)
    // Additional methods
    .itemIngredient(itemIngredient: Ingredient)
    .extraDrop(extraDrop: ItemStackProvider)
  • 1st argument: A BlockState, the result of the recipe
  • 2nd argument: A BlockIngredient, the block to be chiseled for the recipe
  • 3rd argument: A ChiselMode, the chisel mode for the recipe, either smooth, stair, or slab

  • .itemIngredient(itemIngredient: Ingredient): An ingredient specifying the chisel, must be in the tfc:chisels tag, defaults to #tfc:chisels
  • .extraDrop(extraDrop: ItemStackProvider): An ItemStackProvider specifying an extra item to be dropped after chiseling, defaults to empty

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.chisel('minecraft:grass_block[snowy=true]', '#minecraft:flowers', 'smooth')
        .extraDrop('4x minecraft:blue_dye')
})

Collapse/Landslide

See the collapse and landslide main pages! Note: The syntax is exactly the same for both of these recipes, thus they shown together

Method Signature 

event.recipes.tfc.collapse(result?: BlockState, ingredient: BlockIngredient)
event.recipes.tfc.landslide(result?: BlockState, ingredient: BlockIngredient)
  • Optional 1st argument: A BlockState, the result of the recipe, if not provided, the copy_input property of the recipe will be implicitly set to true
  • 2nd argument: A BlockIngredient, the ingredient of the recipe

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.collapse('minecraft:grass[snowy=true]', TFC.blockIngredient(['minecraft:dirt', '#forge:unstable_dirts']))
    event.recipes.tfc.landslide(TFC.blockIngredient('#kubejs:landslides_to_self'))
})

Glassworking

See the main page!

Method Signature 

event.recipes.tfc.glassworking(
    result: ItemStack,
    batch: Ingredient,
    operations: GlassOperation[]
)
  • 1st argument: An item stack, the result of the recipe
  • 2nd argument: An item ingredient, the required item that must be attached to the blowpipe, needs the tfc:glass_batches tag in order to be attached to the blowpipe
  • 3rd argument: An array of GlassOperations, see the main page for a list of all possible operations

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.glassworking(
        '3x minecraft:red_stained_glass_pane',
        'minecraft:red_stained_glass',
        [
            'blow',
            'stretch',
            'stretch'
        ]
    )
})

Heating

See the main page!

Method Signature 

event.recipes.tfc.heating(ingredient: Ingredient, temperature: number)
    // Additional methods
    .resultItem(resultItem: ItemStackProvider)
    .resultFluid(resultFluid: FluidStack)
    .results(resultItem: ItemStackProvider, resultFluid: FluidStack)
    .useDurability(useDurability: boolean)
    .chance(chance: number)
  • 1st argument: An item ingredient, the input of the recipe
  • 2nd argument: A number, the temperature °C at which the inputs will convert to the outputs (if any)

  • .resultItem(resultItem: ItemStackProvider): Accepts an ItemStackProvider and sets the result item of the recipe, defaults to empty
  • .resultFluid(resultFluid: FluidStack): Accepts a FluidStack and sets the result fluid of the recipe, defaults to empty
  • .results(resultItem: ItemStackProvider, resultFluid: FluidStack): A convenience method for setting both results, identical to calling .resultItem(resultItem).resultFluid(resultFluid)
  • .useDurability(useDurability: number): Accepts a boolean, determines if the recipe should consider the durability of the item when melting into a fluid
  • .chance(chance: number): Accepts a number, in the range [0, 1], sets the chance of the item output

The ingredient needs to have an item heat added to it

The recipe may define an item result, a fluid result, both, or neither

If the recipe has a fluid result, the fluid must have a matching metal definition to work with crucibles

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.heating('minecraft:cobblestone', 1500)
        .results('minecraft:stone', Fluid.of('minecraft:lava', 1))
})

Knapping

See the main page!

Method Signature 

event.recipes.tfc.knapping(
    result: ItemStack,
    knappingType: String,
    pattern: String[]
)
    //Additional methods
    .ingredient(ingredient: Ingredient)
    .outsideSlotRequired(required: boolean)
  • 1st argument: An item stack, the result of the recipe
  • 2nd argument: A string, the id of the knapping type of the recipe
  • 3rd argument: An array of strings representing the knapping grid, may be up to 5 x 5. Spaces are empty spots while any other character are a filled spot

  • .ingredient(ingredient: ingredient): Accepts an item ingredient, used to restrict the recipe input even further from the knapping type’s ingredient, defaults to empty
  • .outsideSlotRequired(required: boolean): For recipes with grids less than 5 x 5, defines if the slots outside the grid are required to be filled or not, defaults to true

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.knapping(
        'minecraft:clay',
        'tfc:clay',
        [
            'XXX',
            'X X',
            'XXX'
        ]
    ).outsideSlotRequired(false)
})

Loom

See the main page!

Method Signature 

event.recipes.tfc.loom(
    result: ItemStackProvider,
    ingredient: Ingredient,
    requiredSteps: number,
    inProgressTexture: String
)
  • 1st argument: An ItemStackProvider, the result produced by this recipe
  • 2nd argument: An item ingredient, will accepts counts greater than 1
  • 3rd argument: A number, the number of times the loom must be interacted with to complete the recipe
  • 4th argument: A string, the texture the loom uses to render the recipe while in progress

Example 

ServerEvent.recipes(event => {
    event.recipes.tfc.loom(
        '4x minecraft:red_wool',
        '4x minecraft:blue_wool',
        4,
        'minecraft:block/purple_wool'
    )
})

Jam Pot

See the main page!

Method Signature 

event.recipes.tfc.pot_jam(
    result: ItemStack,
    ingredients: Ingredient[],
    fluidIngredient: FluidStackIngredient,
    duration: number,
    temperature: number,
    texture: String
)
  • 1st argument: The item given to the the player when the pot is clicked with an empty jar
  • 2nd argument: An array of item ingredients that the recipe consumes
  • 3rd argument: A FluidStackIngredient, the fluid needed in the pot
  • 4th argument: A number, the number of ticks the pot must boil for
  • 5th argument: A number, the temperature °C that the pot must be above to start boiling
  • 6th argument: A string, the texture location that is rendered in the pot when it is complete and still has output

Pots will not accept any fluids not tagged tfc:usable_in_pot, make sure the input fluid(s) are tagged as such

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.pot_jam(
        '3x tfc:jar/banana',
        [
            'minecraft:stick',
            TFC.ingredient.notRotten('minecraft:cooked_porkchop')
        ],
        Fluid.of('kubejs:sweet_water', 500),
        50,
        400,
        'tfc:block/jar/banana'
    )
})

Simple Pot

See the main page!

Method Signature 

event.recipes.tfc.pot(
    ingredients: Ingredient[],
    fluidIngredient: FluidStackIngredient,
    duration: number,
    temperature: number
)
    // Additional methods
    .itemOutput(itemOutput: ItemStackProvider[])
    .fluidOutput(fluidOutput: FluidStack)
    .outputs(itemOutput: ItemStackProvider[], fluidOutput: FluidStack)
  • 1st argument: An array of item ingredients that the recipe consumes
  • 2nd argument: A FluidStackIngredient
  • 3rd argument: A number, the number of ticks the pot must boil for
  • 4th argument: A number, the temperature °C that the pot must be above to start boiling

  • .itemOutput(itemOutput: ItemStackProvider[]): An array of ItemStackProviders indicating what items should be left in the pot
  • .fluidOutput(fluidOutput: FluidStack): A FluidStack that the pot produces at the completion of the recipe
  • .outputs(itemOutput: itemStackProvier[], fluidOutput: FluidStack): A convenience method for setting both outputs, identical to .itemOutput(itemOutput).fluidOutput(fluidOutput)

Pots will not accept any fluids not tagged tfc:usable_in_pot, make sure the input/output fluid(s) are tagged as such

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.pot(
        [
            'minecraft:grass',
            'minecraft:stone'
        ],
        Fluid.of('minecraft:lava', 750),
        100,
        750
    ).outputs(
        [
            'minecraft:dirt',
            'minecraft:red_stained_glass'
        ],
        Fluid.of('minecraft:water', 50)
    )
})

Soup Pot

See the main page!

Method Signature 

event.recipes.tfc.pot_soup(
    ingredients: Ingredient[],
    fluidIngredient: FluidStackIngredient,
    duration: number,
    temperature: number
)
  • 1st argument: An array of item ingredients that the recipe consumes
  • 2nd argument: A FluidStackIngredient that the recipe requires
  • 3rd argument: A number, the number of ticks that the pot must boil for
  • 4th argument: A number, the temperature °C that the pot must be above to start boiling

Pots will not accept any fluids not tagged tfc:usable_in_pot, make sure the input fluid(s) are tagged as such

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.pot_soup(
        [
            'minecraft:red_stained_glass',
            '#minecraft:flowers'
        ],
        TFC.fluidStackIngredient('#kubejs:soupy', 750),
        845,
        300
    )
})

Quern

See the main page!

Method Signature 

event.recipes.tfc.quern(result: ItemStackProvider, ingredient: Ingredient)
  • 1st argument: An ItemStackProvider, the output of the recipe
  • 2nd argument: An item ingredient, the input for the recipe

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.quern('minecraft:gravel', 'minecraft:cobblestone')
})

Scraping

See the main page!

Method Signature 

event.recipes.tfc.scraping(
    result: ItemStackProvider,
    ingredient: Ingredient,
    outputTexture: String,
    inputTexture: String,
    extraDrop?: ItemStackProvider
)
  • 1st argument: An ItemStackProvider, the result of the recipe
  • 2nd argument: an item ingredient, the input of the recipe
  • 3rd argument: A string, the texture of the scraped item
  • 4th argument: A string, the texture of the unscraped item
  • Optional 5th argument: An ItemStackProvider, an optional extra drop

In order to actually place an item on a log to scrape it, it must have the tfc:scrapable item tag. Additionally, a game restart may be required for this to enable placement

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.scraping(
        '4x minecraft:paper',
        '#minecraft:flowers',
        'minecraft:block/dirt',
        'minecraft:block/red_stained_glass'
    )
})

Sewing

See the main page! (may not yet exist)

Method Signature 

event.recipes.tfc.sewing(result: ItemStack, stitches: number[45], squares: number[32])
  • 1st argument: An ItemStack, the result of the recipe
  • 2nd argument: An array of 45 numbers (9 wide by 5 tall, as mapped to the corners of the sewing table’s grid spaces), a value of 0 indicates the position does not have a stitch, a value of 1 indicates the position does have a stitch
  • 3rd argument: An array of 32 numbers (8 wide by 4 tall, as mapped to the squares of the sewing table’s grid spaces), a value of -1 indicates the position does not have a cloth, a value of 0 indicates the position has a dark cloth, a value of 1 indicates the position has a light cloth

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.sewing(
        '6x minecraft:dirt',
        [
            0, 0, 0, 0, 0, 0, 0, 0, 0, 
            1, 0, 0, 0, 1, 0, 0, 0, 1,
            0, 1, 1, 1, 0, 1, 1, 1, 0,
            1, 0, 0, 0, 1, 0, 0, 0, 1,
            0, 0, 0, 0, 0, 0, 0, 0, 0
        ], [
            -1, -1, 0, -1, -1, 0, -1, -1,
             0,  0, 1,  0,  0, 1,  0,  0,
             0,  0, 1,  0,  0, 1,  0,  0,
            -1, -1, 0, -1, -1, 0, -1, -1
        ]
    )
})

Advanced Shaped Crafting

See the main page!

This recipe type supports2 Kube’s ingredient and result modifiers. The result modifiers apply after any ISP modifiers.

Method Signature 

event.recipes.tfc.advanced_shaped_crafting(
    result: ItemStackProvider,
    pattern: String[],
    key: Map<Character, Ingredient>,
    row: number,
    column: number
)
  • 1st argument: An ItemStackProvider, the output of the recipe
  • 2nd argument: The pattern for the crafting grid, spaces can be used to indicate an empty slot
  • 3rd argument: A Character to ingredient map, associates the pattern to ingredients
  • 4th argument: A number, the row of the input ingredient the output uses if it is dependent on its inputs
  • 5th argument: A number, the column of the input ingredient the output uses if it is dependent on its inputs

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.advanced_shaped_crafting(
        TFC.itemStackProvider.of('tfc:food/red_apple').addTrait('kubejs:fruity'),
        [
            'FLK',
            'KLF'
        ], {
            F: '#minecraft:flowers',
            L: 'minecraft:dirt',
            K: 'tfc:food/red_apple'
        },
        0,
        0
    )
})

Advanced Shapeless Crafting

See the main page!

This recipe type supports2 Kube’s ingredient and result modifiers. The result modifiers apply after any ISP modifiers.

Method Signature 

event.recipes.tfc.advanced_shapeless_crafting(
    result: ItemStackProvider,
    ingredients: Ingredient[],
    primaryIngredient?: Ingredient
)
  • 1st argument: An ItemStackProvider, the output of the recipe
  • 2nd argument: An array of item ingredients, the inputs of the recipe
  • Optional 3rd argument: An item ingredient, which identifies the which slot of the recipe is used as the ‘input’ if the output is input-dependent

Examples 

ServerEvents.recipes(event => {
    event.recipes.tfc.advanced_shapeless_crafting(
        'minecraft:dirt',
        [
            'minecraft:stone',
            'minecraft:cobblestone'
        ]
    )
    event.recipes.tfc.advanced_shapeless_crafting(
        TFC.itemStackProvider.copyInput().addTrait('kubejs:with_added_stones'),
        [
            'tfc:food/red_apple',
            'tfc:rock/loose/dacite'
        ],
        'tfc:food/red_apple'
    )
})

Damage Inputs Crafting

See the main page!

Method Signatures 

event.recipes.tfc.damage_inputs_shaped_crafting(recipe: ShapedCraftingRecipe)
event.recipes.tfc.damage_inputs_shapeless_crafting(recipe: ShapelessCraftingRecipe)
  • 1st argument: A crafting recipe, must be the same shaped/shapeless type as the type of the damage inputs recipe

Examples 

ServerEvents.recipes(event => {
    event.recipes.tfc.damage_inputs_shaped_crafting(
        event.recipes.minecraft.crafting_shaped(
            'minecraft:dirt',
            [
                'MMN'
            ], {
                M: 'minecraft:stone',
                N: '#tfc:knives'
            }
        )
    )
    event.recipes.tfc.damage_inputs_shapeless_crafting(
        event.recipes.minecraft.crafting_shapeless(
            'minecraft:stone',
            [
                '#minecraft:flowers',
                '#minecraft:axes'
            ]
        )
    )
})

Extra products Crafting

See the main page!

Method Signatures 

event.recipes.tfc.extra_products_shaped_crafting(
    extraProducts: ItemStack[],
    recipe: ShapedCraftingRecipe
)
event.recipes.tfc.extra_products_shapeless_crafting(
    extraProducts: ItemStack[],
    recipe: ShapelessCraftingRecipe
)
  • 1st argument: An array of ItemStacks, the extra products of the recipe
  • 2nd argument: A crafting recipe, must be the same shaped/shapeless type as the type of the extra products recipe

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.extra_products_shaped_crafting(
        '3x minecraft:red_stained_glass',
        event.recipes.minecraft.crafting_shaped(
            'minecraft:dirt',
            [
                'GHJ'
            ], {
                G: '#minecraft:flowers',
                H: 'minecraft:stone',
                J: 'tfc:rock/raw/diorite'
            }
        )
    )
    event.recipes.tfc.extra_products_shapeless_crafting(
        '4x minecraft:green_stained_glass_pane',
        event.recipes.minecraft.crafting_shapeless(
            'minecraft:red_stained_glass',
            [
                'minecraft:dirt',
                '#minecraft:flowers'
            ]
        )
    )
})

No Remainder Crafting

This is a crafting recipe type that prevents any remainders from being left after crafting

Method Signatures 

event.recipes.tfc.no_remainder_shaped_crafting(recipe: ShapedCraftingRecipe)
event.recipes.tfc.no_remainder_shapeless_crafting(recipe: ShapelessCraftingRecipe)
  • 1st argument: A crafting recipe, must be the same shaped/shapeless type as the type of the no remainder recipe

Example 

ServerEvents.recipes(event => {
    event.recipes.tfc.no_remainder_shaped_crafting(
        event.recipes.minecraft.crafting_shaped(
            'minecraft:ice',
            [
                'SAS'
            ], {
                S: 'kubejs:super_cooler',
                A: 'minecraft:water_bucket'
            }
        )
    )
    event.recipes.tfc.no_remainder_shapeless_crafting(
        event.recipes.minecraft.crafting_shapeless(
            'minecraft:obsidian',
            [
                'minecraft:water_bucket',
                'minecraft:lava_bucket'
            ]
        )
    )
})

FirmaLife Drying

See the main page!

Method Signature 

event.recipes.firmalife.drying(
    result: ItemStackProvider,
    ingredient: Ingredient
)
  • 1st argument: An ItemStackProvider, the result of the recipe
  • 2nd argument: An item ingredient

Example 

ServerEvents.recipes(event => {
    event.recipes.firmalife.drying(
        'kubejs:jerky',
        TFC.ingredient.notRotten('#tfc:meat')
    )
})

FirmaLife Smoking

See the main page!

Method Signature 

event.recipes.firmalife.smoking(
    result: ItemStackIngredientJS,
    ingredient: Ingredient
)
  • 1st argument: An ItemStackProvider, the result of the recipe
  • 2nd argument: An item ingredient

Example 

ServerEvents.recipes(event => {
    event.recipes.firmalife.smoking(
        TFC.isp.copyInput().addTrait('kubejs:smoked'),
        TFC.ingredient.notRotten('#tfc:meats')
    )
})

FirmaLife Mixing Bowl

See the main page!

Method Signature 

event.recipes.firmalife.mixing_bowl()
    // Additional Methods
    .outputItem(outputItem: ItemStack)
    .outputFluid(outputFluid: FluidStack)
    .outputs(outputItem: ItemStack, outputFluid: FluidStack)
    .itemIngredients(ingredients: Ingredient[])
    .fluidIngredient(fluidIngredient: FluidStackIngredient)
    .ingredients(ingredients: Ingredient[], fluidIngredient: FluidStackIngredient)
  • .outputItem(outputItem: ItemStack): An ItemStack, the item output
  • .outputFluid(outputFluid: FluidStack): A FluidStack, the fluid output
  • .outputs(outputItem: ItemStack, outputFluid: Fluidstack): A convenience method for setting both outputs, the same as calling .outputItem(outputItem).outputFluid(outputFluid)
  • .itemIngredients(ingredients: Ingredient[]): An array of item ingredients, the item inputs
  • .fluidIngredient(fluidIngredient: FluidStackIgnredient): A FluidStackIngredient
  • .ingredients(ingredients: Ingredient[], fluidIngredient: FluidStackIngredient): A convenience method for setting both inputs, the same as calling .itemIngredients(ingredients).fluidIngredient(fluidIngredient)

Example 

ServerEvents.recipes(event => {
    event.recipes.firmalife.mixing_bowl()
        .outputs('minecraft:dirt', Fluid.of('minecraft:milk', 50))
        .itemIngredients(['minecraft:stone', 'minecraft:deepslate'])
})

FirmaLife Oven

See the main page!

Method Signature 

event.recipes.firmalife.oven(
    ingredient: Ingredient,
    temperature: number,
    duration: number,
    resultItem?: ItemStackProvider
)
  • 1st argument: An item ingredient, the input of the recipe
  • 2nd argument: A number, the minimum temperature °C of the top oven for the recipe to operate
  • 3rd argument: A number, the number of ticks required for the recipe to finish
  • Optional 4th argument: An ItemStackProvider, the output of the recipe, defaults to TFC.itemStackProvider.empty()

Example 

ServerEvents.recipes(event => {
    event.recipes.firmalife.oven(
        'minecraft:spruce_log',
        500,
        100,
        'minecraft:oak_log'
    )
})

FirmaLife Stinky Soup

See the main page!

Method Signature 

event.recipes.firmalife.stinky_soup(
    ingredients: Ingredient[],
    fluidIngredient: FluidStackIngredient,
    duration: number,
    temperature: number
)
  • 1st argument: An array of item ingredients, the item inputs of the recipe
  • 2nd argument: A FluidStackIngredient, the fluid input of the recipe
  • 3rd argument: A number, the number of ticks required for the recipe to finish
  • 4th argument: A number, the minimum temperature °C required for the recipe to operate

Pots will not accept any fluids not tagged tfc:usable_in_pot, make sure the input fluid(s) are tagged as such

Example 

ServerEvents.recipes(event => {
    event.recipes.firmalife.stinky_soup(
        [
            'minecraft:dirt',
            TFC.ingredient.not(TFC.ingredient.notRotten())
        ],
        TFC.fluidStackIngredient('#minecraft:water', 1000),
        500,
        460
    )
})

FirmaLife Vat

See the main page!

Method Signature 

event.recipes.firmalife.vat()
    // Additional methods
    .outputItem(outputProvider: ItemStackProvider)
    .outputFluid(outputFluid: FluidStack)
    .outputs(itemOutput: ItemStackProvider, outputFluid: FluidStack)
    .inputItem(inputItem: Ingredient)
    .inputFluid(inputFluid: FluidStackIngredient)
    .inputs(inputItem: Ingredient, inputFluid: FluidStackIngredient)
    .length(length: number)
    .temperature(temp: number)
    .jar(jar: ItemStack)
  • .outputItem(outputProvier: ItemStackProvider): An ItemStackProvider, the item output
  • .outputFluid(outputFluid: FluidStack): A FluidStack, the fluid output
  • .outputs(itemOutput: ItemStackProvider, outputFluid: FluidStack): A convenience method for setting both outputs, the same as calling .outputItem(itemOutput).outputFluid(outputFluid)
  • .inputItem(inputItem: Ingredient): An item ingredient, the item input
  • .inputFluid(inputFluid: FluidStackIngredient): A FluidStackIngredient, the fluid input
  • .inputs(inputItem: Ingredient, inputFluid: FluidStackIngredient): A convenience method for setting both inputs, the same as calling .inputItem(inputItem).inputFluid(inputFluid)
  • .length(length: number): A number, the number of ticks the vat must process for, defaults to 600
  • .temperature(temp: number): A number, the minimum temperature °C of the vat in order to process, defaults to 300
  • .jar(jar: ItemStack): An ItemStack to be attached, only used for recipes that produce firmalife:fruity_fluid in conjunction with the jarring station

Example 

ServerEvents.recipes(event => {
    event.recipes.firmalife.vat()
        .outputItem('minecraft:dirt')
        .inputFluid(Fluid.of('minecraft:lava', 500))
        .length(60)
})

FirmaLife Stomping

See the main page!

Method Signature 

event.recipes.firmalife.stomping(
    result: ItemStackProvider,
    ingredient, Ingredient,
    inputTexture: String,
    outputTexture: String,
    sound: String
)
  • 1st argument: An ItemStackProvider, the result
  • 2nd argument: An item ingredient, the input
  • 3rd argument: A string, the texture to use in the stomping barrel with the input item
  • 4th argument: A string, the texture to use in the stomping barrel once the recipe has completed
  • 5th argument: A string, the registry name of a sound event1, the sound to play when the barrel is stomped

Example 

ServerEvents.recipes(event => {
    event.recipes.firmalife.stomping(
        'minecraft:dirt',
        'minecraft:stone',
        'tfc:block/charcoal_pile',
        'tfc:block/powder/charcoal',
        'tfc:block.charcoal.fall'
    )
})

FirmaLife Bowl Pot

See the main page!

Method Signature 

event.recipes.firmalife.bowl_pot(
    itemOutput: ItemStack,
    ingredients: Ingredient[],
    fluidIngredient: FluidStackIngredient,
    duration: number,
    temperature: number,
    food: (Consumer<FoodData> | {
        water?: number,
        hunger?: number,
        saturation?: number,
        grain?: number,
        fruit?: number,
        vegetables?: number,
        protein?: number,
        dairy?: number,
        decay_modifier?: number
    })
)
  • 1st argument: An item stack, the output of the recipe
  • 2nd argument: An array of item ingredients, the item inputs of the recipe
  • 3rd argument: A FluidStackIngredient, the fluid ingredient of the recipe
  • 4th argument: A number, the number of ticks the pot will process for
  • 5th argument: A number, the temperature °C that the pot needs to get to for the recipe to begin
  • 6th argument: Either a FoodData consumer or a string to number map containing any of water, saturation, grain, fruit, vegetables, protein, dairy, hunger, and decay_modifier values

Pots will not accept any fluids not tagged tfc:usable_in_pot, make sure the input fluid(s) are tagged as such

Examples 

ServerEvents.recipes(event => {
    event.recipes.firmalife.bowl_pot(
        'minecraft:cooked_beef',
        [
            'minecraft:dirt',
            'minecraft:stone'
        ],
        'minecraft:water',
        20,
        100,
        food => {
            food.hunger(50)
            food.protein(10.6)
            food.saturation(2)
        }
    )
    event.recipes.firmalife.bowl_pot(
        'tfc:food/red_apple',
        [
            'minecraft:poppy',
            'minecraft:oak_log'
        ],
        'minecraft:lava',
        20,
        100,
        {
            hunger: 3,
            fruit: 12,
            decay_modifier: 0.9
        }
    )
})

FirmaLife Press

See the main page!

This recipe type is currently unused by FirmaLife and actually adds itself to the stomping recipe type in JEI

Method Signature 

event.recipes.firmalife.press(
    result: ItemStackProvider,
    ingredient: Ingredient,
    inputTexture: String,
    outputTexture: String,
    sound: String
)
  • 1st argument: An ItemStackProvider, the result
  • 2nd argument: An item ingredient, the input
  • 3rd argument: A string, the texture to use in the stomping barrel with the input item
  • 4th argument: A string, the texture to use in the stomping barrel once the recipe has completed
  • 5th argument: A string, the registry name of a sound event1, the sound to play when the barrel is stomped

Example 

ServerEvents.recipes(event => {
    event.recipes.firmalife.press(
        'minecraft:smooth_stone',
        'minecraft:cobblestone',
        'minecraft:block/cobblestone',
        'minecraft:block/smooth_stone',
        'tfc:block.charcoal.fall'
    )
})

AFC Tree Tap

AFC’s tree tapping recipe type

Method Signature 

event.recipes.afc.tree_tapping(inputBlock: BlockIngredient)
    // Additional methods
    .resultFluid(fluid: FluidStack)
    .minTemp(f: number)
    .maxTemp(f: number)
    .temps(min: number, max: number)
    .requiresNaturalLog(required: boolean)
    .springOnly(springOnly: boolean)

  • .resultFluid(fluid: FluidStack): Sets the fluid result of the recipe
  • .minTemp(f: number): Sets the minimum temperature °C at which the recipe will be valid, defaults to -50
  • .maxTemp(f: number): Sets the maximum temperature °C at which the recipe will be valid, defaults to 50
  • .temps(min: number, max: number): Sets the maximum and minimum temperatures °C at which will the recipe will be valid
  • .requiresNaturalLog(required: boolean): Determines if the recipe needs the input block to have TFC’s branch_direction state property and have a value that is not none to work. Defaults to true
  • .springOnly(springOnly: boolean): Determines if the recipe only works during the spring time, defaults to false

Tree taps can only be placed on blocks with the afc:tappable_logs tag, make sure the input blocks(s) are tagged as such

Example 

ServerEvents.recipes(event => {
    event.recipes.afc.tree_tapping(TFC.blockIngredient('minecraft:oak_log'))
        .resultFluid(Fluid.of('miencraft:water', 2))
        .springOnly(true)
})

  1. A full list of all sound events can be attained by running the command /kubejs dump_registry minecraft:sound_event in-game ↩ ↩2 ↩3 ↩4 ↩5

  2. Technically, the support is implemented through an entirely different recipe type, but this is automatically converted to that type when any of Kube’s ingredient/result modifiers are present. ↩ ↩2