Recipes

The following recipes are supported by KubeJS TFC:

If FirmaLife Modrinth Link CurseForge Link is installed, the following recipes are supported:

If ArborFirmaCraft Modrinth Link CurseForge Link is installed, the following recipes are supported:

If TFC Artisanal Modrinth Link CurseForge Link 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

  • : Accepts a number and sets the minimum anvil tier the recipe can be performed on, defaults to -1
  • : 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)
  • : Accepts an ItemStackProvider and sets the recipe’s output item, defaults to empty
  • : Accepts a FluidStack and sets the recipe’s output fluid, defaults to empty
  • : A convenience method for setting both outputs, identical to calling .outputItem(outputItem).outputFluid(outputFluid)
  • : Accepts an item ingredient and sets the recipe’s input item, will accept counts greater than 1, defaults to empty
  • : Accepts a FluidStackIngredient and sets the recipe’s input fluid, defaults to empty
  • : A convenience method for setting both inputs, identical to calling .inputItem(inputItem).inputFluid(inputFluid)
  • : 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

  • : Accepts an ItemStackProvider and sets the recipe’s output item, defaults to empty
  • : Accepts a FluidStack and sets the recipe’s output fluid, defaults to empty
  • : A convenience method for setting both outputs, identical to calling .outputItem(outputItem).outputFluid(outputFluid)
  • : Accepts an item ingredient and sets the recipe’s input item, will accept counts greater than 1, defaults to empty
  • : Accepts a FluidStackIngredient and sets the recipe’s input fluid, defaults to empty
  • : A convenience method for setting both inputs, identical to .inputItem(inputItem).inputFluid(inputFluid)
  • : 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
  • : Accepts an ItemStackProvider which will be applied when the barrel is sealed
  • : Accepts an ItemStackProvider which will be applied when the barrel is unsealed
  • : 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

  • : An ingredient specifying the chisel, must be in the tfc:chisels tag, defaults to #tfc:chisels
  • : 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)

  • : Accepts an ItemStackProvider and sets the result item of the recipe, defaults to empty
  • : Accepts a FluidStack and sets the result fluid of the recipe, defaults to empty
  • : A convenience method for setting both results, identical to calling .resultItem(resultItem).resultFluid(resultFluid)
  • : Accepts a boolean, determines if the recipe should consider the durability of the item when melting into a fluid
  • : 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

  • : Accepts an item ingredient, used to restrict the recipe input even further from the knapping type’s ingredient, defaults to empty
  • : 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, in °C, that the pot must get to in order to start boiling/start processing the recipe
  • 6th argument: A string, the texture location that is rendered in the pot when it is complete and still has output

Pots will only accept fluids 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, in °C, that the pot must get to in order to start boiling/start processing the recipe

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

Pots will only accept fluids 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, in °C, that the pot must get to in order to start boiling/start processing the recipe

Pots will only accept fluids 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 must have the tfc:scrapable item tag. Additionally, a game restart may be required for placement to become possible

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)
  • : An ItemStack, the item output
  • : A FluidStack, the fluid output
  • : A convenience method for setting both outputs, the same as calling .outputItem(outputItem).outputFluid(outputFluid)
  • : An array of item ingredients, the item inputs
  • : A 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)
  • : An ItemStackProvider, the item output
  • : A FluidStack, the fluid output
  • : A convenience method for setting both outputs, the same as calling .outputItem(itemOutput).outputFluid(outputFluid)
  • : An item ingredient, the item input
  • : A FluidStackIngredient, the fluid input
  • : A convenience method for setting both inputs, the same as calling .inputItem(inputItem).inputFluid(inputFluid)
  • : A number, the number of ticks the vat must process for, defaults to 600
  • : A number, the minimum temperature °C of the vat in order to process, defaults to 300
  • : 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)

  • : Sets the fluid result of the recipe
  • : Sets the minimum temperature °C at which the recipe will be valid, defaults to -50
  • : Sets the maximum temperature °C at which the recipe will be valid, defaults to 50
  • : Sets the maximum and minimum temperatures °C at which will the recipe will be valid
  • : 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
  • : 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('minecraft:water', 2))
        .springOnly(true)
})

Artisanal Scalable Pot

Artisanal’s scalable pot recipe type, similar to the regular pot but scales the output stacks based on how much excess fluid was in the pot

Method Signature 

event.recipes.artisanal.scalable_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, in °C, that the pot must get to in order to start boiling/start processing the recipe

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

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

Example 

ServerEvents.recipes(event => {
    event.recipes.artisanal.scalable_pot(
        [
            'minecraft:dirt',
            'minecraft:cobblestone'
        ],
        Fluid.of('minecraft:lava', 20),
        100,
        5
    ).fluidOutput(
        Fluid.of('minecraft:milk', 50)
    )
})

Artisanal Damage and Catalyst Shapeless Crafting

Artisanal’s damage and catalyst shapeless crafting recipe. Identical to TFC’s damage inputs recipe type except it also ignores item tagged artisanal:crafting_catalysts when determining which items to damage

Method Signature 

event.recipes.artisanal.damage_and_catalyst_shapeless_crafting(
    recipe: ShapelessCraftingRecipe
)
  • 1st argument: A crafting recipe, must be shapeless

Example 

ServerEvents.recipes(event => {
    event.recipes.artisanal.damage_and_catalyst_shapeless_crafting(
        event.recipes.minecraft.crafting_shapeless('2x minecraft:gold_ingot', [
            'tfc:metal/double_ingot/gold',
            '#artisanal:magnifying_glasses',
            '#tfc:saws'
        ])
    )
})

Artisanal Distillery

Artisanal’s distillery recipe type

Method Signature 

event.recipes.artisanal.distillery(
    minTemp: number,
    duration: number
)
    // Additional methods
    .inputItem(ingredient: Ingredient)
    .inputFluid(fluidIngredient: FluidStackIngredient)
    .inputs(ingredient: Ingredient, fluidIngredient: FluidStackIngredient)
    .resultItem(resultItem: ItemStackProvider)
    .resultFluid(resultFluid: FluidStack)
    .results(resultItem: ItemStackProvider, resultFluid: FluidStack)
    .leftoverItem(leftoverItem: ItemStackProvider)
    .leftoverFluid(leftoverFluid: FluidStack)
    .leftovers(leftoverItem: ItemStackProvider, leftoverFluid: FluidStack)
  • 1st argument: A number, the minimum temperature, in °C, the distillery requires to preform the recipe
  • 2nd argument: A number, how long, in ticks, the recipe takes to complete

  • : An item ingredient, the input item
  • : A FluidStackIngredient, the input fluid
  • : A convenience method for setting both inputs, identical to calling .inputItem(ingredient).inputFluid(fluidIngredient)
  • : An ItemStackProvider, the result of the recipe
  • : A FluidStack, the fluid result of the recipe
  • : A convenience method for setting both results, identical to calling .resultItem(resultItem).resultFluid(resultFluid)
  • : An ItemStackProvider, the leftover item
  • : A FluidStack, the leftover fluid
  • : A convenience method for setting both leftovers, identical to calling .leftoverItem(leftoverItem).leftoverFluid(leftoverFluid)

Example 

ServerEvents.recipes(event => {
    event.recipes.artisanal.distillery(450, 20)
        .inputs('minecraft:iron_ingot', TFC.fluidStackIngredient('#minecraft:water', 50))
        .results('minecraft:sculk', Fluid.of('minecraft:lava', 20))
        .leftOverItem('minecraft:beacon')
})

Artisanal Juicing

Artisanal’s juicing recipe type

Method Signature 

event.recipes.artisanal.juicing(
    result: FluidStack,
    ingredient: Ingredient
)
  • 1st argument: A FluidStack, the output of the recipe
  • 2nd argument: An item ingredient, the input item

Example 

ServerEvents.recipes(event => {
    event.recipes.artisanal.juicing(
        Fluid.of('minecraft:milk', 50),
        'tfc:food/barley_grain'
    )
})

Artisanal Only If Flux Makes Limewater Instant Barrel

Artisanal’s only if flux makes limewater instant barrel recipe type, an version of instant barrel recipes which only works if Artisanal’s fluxMakesLimewater config option is enabled

Method Signature 

event.recipes.artisanal.only_if_flux_makes_limewater_instant_barrel()
    // 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)
  • : Accepts an ItemStackProvider and sets the recipe’s output item, defaults to empty
  • : Accepts a FluidStack and sets the recipe’s output fluid, defaults to empty
  • : A convenience method for setting both outputs, identical to calling .outputItem(outputItem).outputFluid(outputFluid)
  • : Accepts an item ingredient and sets the recipe’s input item, will accept counts greater than 1, defaults to empty
  • : Accepts a FluidStackIngredient and sets the recipe’s input fluid, defaults to empty
  • : A convenience method for setting both inputs, identical to calling .inputItem(inputItem).inputFluid(inputFluid)
  • : 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.artisanal.only_if_flux_makes_limewater_instant_barrel()
        .outputs('minecraft:diamond', Fluid.of('minecraft:lava', 50))
        .sound('minecraft:ambient.cave')
        .inputFluid(Fluid.of('tfc:limewater', 500))
})

Artisanal Specific No Remainder Damage Shaped Crafting

Artisanal’s specific no remainder damage shaped crafting, a version of shaped damage inputs crafting which also complete removes the remainders of the specified slot instead of just damaging it

Method Signature 

event.recipes.artisanal.specific_no_remainder_damage_shaped(
    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 to be removed and which the output uses if it is dependent on its inputs
  • 5th argument: A number, the column of the input ingredient to be removed and which the output uses if it is dependent on its inputs

Example 

ServerEvents.recipes(event => {
    event.recipes.artisanal.specific_no_remainder_damage_shaped(
        'minecraft:stick',
        [
            'S S',
            ' A ',
            'S S'
        ],
        {
            S: '#tfc:hammers',
            A: 'minecraft:water_bucket'
        },
        1,
        1
    )
})

Artisanal Specific no Remainder Shaped Crafting

Artisanal’s specific no remainder shaped crafting recipe type, a version of advanced shaped crafting recipes which removes the remainders of the primary ingredient

Method Signature 

event.recipes.artisanal.specific_no_remainder_shaped(
    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 to be removed and which the output uses if it is dependent on its inputs
  • 5th argument: A number, the column of the input ingredient to be removed and which the output uses if it is dependent on its inputs

Example 

ServerEvents.recipes(event => {
    event.recipes.artisanal.specific_no_remainder_shaped(
        'minecraft:iron_sword',
        [
            'SA',
            'AS'
        ],
        {
            S: 'minecraft:water_bucket',
            A: 'minecraft:oak_log'
        },
        1,
        1
    )
})

Artisanal Specific No Remainder Shapeless Crafting

Artisanal’s specific no remainder shapeless crafting recipe type, a version of advanced shapeless crafting recipes which removes the remainders of the primary ingredient

Method Signature 

event.recipes.artisanal.specific_no_remainder_shapeless(
    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 and whose remainder will be discarded on crafting

Example 

ServerEvents.recipes(event => {
    event.recipes.artisanal.specific_no_remainder_shapeless(
        'minecraft:deepslate',
        [
            'minecraft:water_bucket',
            'minecraft:milk_bucket',
            'minecraft:stone'
        ],
        'minecraft:milk_bucket'
    )
})

  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 ↩6

  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