KubeJS Create

This page is still WIP!

Example Recipes

NoThe ~~info~~example ~~yet!~~scripts are only there to show how to create the recipes. They are not meant to be used with the items shown.

Compacting

Syntax: compacting(output[], input[])

Features:

supports multiple inputs and outputs supports .heated() and .superheated() can have a fluid output as long as it has another item output supports chance-based output uses the Mechanical Press, Basin, and optionally a Blaze Burner

ServerEvents.recipes(e => {
  e.recipes.create.compacting('diamond', 'coal_block')
  e.recipes.create.compacting('diamond', 'coal_block').heated()
  e.recipes.create.compacting('diamond', 'coal_block').superheated()
  e.recipes.create.compacting([Fluid.of('water', 10), 'dead_bush'], ['#minecraft:saplings', '#minecraft:saplings'])
  e.recipes.create.compacting(['diamond', Item.of('diamond').withChance(0.3)], 'coal_block')
})

Crushing

Syntax: crushing(output[], input)

Features:

supports multiple chance-based outputs supports .processingTime() uses the Crushing Wheels

ServerEvents.recipes(e => {
  e.recipes.create.crushing('diamond', 'coal_block')
  e.recipes.create.crushing('diamond', 'coal_block').processingTime(500)
  e.recipes.create.crushing(['diamond', Item.of('diamond').withChance(0.5)], 'coal_block')
})

Cutting

Syntax: cutting(output[], input)

Features:

supports multiple chance-based outputs supports .processingTime() uses the Mechanical Saw

ServerEvents.recipes(e => {
  e.recipes.create.cutting('diamond', 'coal_block')
  e.recipes.create.cutting('diamond', 'coal_block').processingTime(500)
  e.recipes.create.cutting(['diamond', Item.of('diamond').withChance(0.5)], 'coal_block')
})

Deploying

Syntax: deploying(output[], input[])

Features:

supports multiple chance-based outputs requires exactly two inputs, the second input is what the Deployer is holding supports .keepHeldItem() uses the Deployer

ServerEvents.recipes(e => {
  e.recipes.create.deploying('diamond', ['coal_block', 'sand'])
  e.recipes.create.deploying(['diamond', 'emerald'], ['coal_block', 'sand']).keepHeldItem()
  e.recipes.create.deploying(['diamond', Item.of('diamond').withChance(0.5)], ['coal_block', 'sand'])
})

Emptying

Syntax: emptying(output[], input)

Features:

requires one input and two outputs, the outputs must be an item and a fluid uses the Item Drain

ServerEvents.recipes(e => {
  e.recipes.create.emptying([Fluid.of('water', 1000), 'bucket'], 'water_bucket')
})

Filling

Syntax: filling(output, input[])

Features:

requires two inputs and one output, the inputs must be an item and a fluid uses the Spout

ServerEvents.recipes(e => {
  e.recipes.create.filling('water_bucket', [Fluid.of('water', 1000), 'bucket'])
})

Haunting

Syntax: haunting(output[], input)

Features:

supports multiple chance-based outputs uses the Encased Fan and Soul Fire

ServerEvents.recipes(e => {
  e.recipes.create.haunting('soul_campfire', 'campfire')
  e.recipes.create.haunting(['wheat', 'oak_sapling'], 'potato')
  e.recipes.create.haunting(['wheat', Item.of('oak_sapling').withChance(0.2)], 'potato')
})

Mechanical Crafting

Syntax: mechanicalCrafting(output, pattern[], keys{})

Features:

mostly identical to the default Shaped Crafting supports up to 9x9 grid size uses the Mechanical Crafter

ServerEvents.recipes(e => {
  e.recipes.create.mechanicalCrafting('emerald', [
    ' DDD ',
    'D   D',
    'D   D',
    'D   D',
    ' DDD '
  ], {
    D: 'dirt'
  })
})

Milling

Syntax: milling(output[], input)

Features:

supports multiple chance-based outputs

uses the Millstone

ServerEvents.recipes(e => {
  e.recipes.create.milling('diamond', 'coal_block')
  e.recipes.create.milling(['diamond', 'emerald'], 'coal_block')
  e.recipes.create.milling(['diamond', Item.of('diamond').withChance(0.5)], 'coal_block')
})

Mixing

Syntax: mixing(output[], input)

Features:

supports multiple chance-based outputs supports fluid inputs and outputs supports .heated() and .superheated() uses the Mechanical Mixer, Basin, and optionally a Blaze Burner

ServerEvents.recipes(e => {
  e.recipes.create.mixing('diamond', 'coal_block')
  e.recipes.create.mixing('diamond', 'coal_block').heated()
  e.recipes.create.mixing('diamond', 'coal_block').superheated()
  e.recipes.create.mixing([Fluid.of('water', 10), 'dead_bush'], ['#minecraft:saplings', '#minecraft:saplings'])
  e.recipes.create.mixing(['diamond', Item.of('diamond').withChance(0.3)], 'coal_block')
})

Pressing

Syntax: pressing(output[], input)

Features:

supports multiple chance-based outputs uses the Mechanical Press

ServerEvents.recipes(e => {
  e.recipes.create.pressing('diamond', 'coal_block')
  e.recipes.create.pressing(['diamond', 'emerald'], 'coal_block')
  e.recipes.create.pressing(['diamond', Item.of('diamond').withChance(0.5)], 'coal_block')
})

Sandpaper Polishing

Syntax: sandpaperPolishing(output, input)

Features:

supports chance-based output uses any item tagged with create:sandpaper

ServerEvents.recipes(e => {
  e.recipes.create.sandpaperPolishing('diamond', 'coal_block')
  e.recipes.create.sandpaperPolishing(Item.of('diamond').withChance(0.5), 'coal_block')
})

Sequenced Assembly

Syntax: sequencedAssembly(output[], input)

WIP Section

Splashing/Washing

Syntax: splashing(output[], input)

Features:

supports multiple chance-based outputs uses the Encased Fan and Water

ServerEvents.recipes(e => {
  e.recipes.create.splashing('soul_campfire', 'campfire')
  e.recipes.create.splashing(['wheat', 'oak_sapling'], 'potato')
  e.recipes.create.splashing(['wheat', Item.of('oak_sapling').withChance(0.2)], 'potato')
})

This section is copied from the old wiki. It is still WIP!

Sequenced Assembly

Syntax

event.recipes.create.sequencedAssembly(output[], input, sequence[]).transitionalItem(transitionalItem).loops(loops)
or
event.recipes.createSequencedAssembly(output[], input, sequence[]).transitionalItem(transitionalItem).loops(loops)

Output is an item or an array of items.

If it is an array:

The first item is the real output, the remainder are scrap. Only one item is chosen, with equal chance of each. You can use Item.of('create:shaft').withChance(2) to double the chance of that specific item to being chosen.

Input is an ingredient.

Transitional Item is any item* and is used during the intermediate stages of the assembly.

Sequence is an array of recipes.

The only legal recipes are:

createCutting createPressing createDeploying createFilling The transitional item needs to be the output of each of these recipes. The transitional item needs to be the an input of each of these recipes.

Loops is the number of time that the recipes repeats. Calling .loops() is optional, and defaults to one.

Examples

onEvent('recipes', event => {
	event.recipes.createSequencedAssembly([ // start the recipe
		Item.of('create:precision_mechanism').withChance(130.0), // this is the item that will appear in JEI as the result
		Item.of('create:golden_sheet').withChance(8.0), // the rest of these items will part of the scrap
		Item.of('create:andesite_alloy').withChance(8.0),
		Item.of('create:cogwheel').withChance(5.0),
		Item.of('create:shaft').withChance(2.0),
		Item.of('create:crushed_gold_ore').withChance(2.0),
		Item.of('2x gold_nugget').withChance(2.0),
		'iron_ingot',
		'clock'
	],'create:golden_sheet',[ // 'create:golden_sheet' is the input
		// the transitional item set by "transitionalItem('create:incomplete_large_cogwheel')" is the item used during the intermediate stages of the assembly
		event.recipes.createDeploying('create:incomplete_precision_mechanism',['create:incomplete_precision_mechanism','create:cogwheel']),
 	 	// like a normal recipe function, is used as a sequence step in this array. Input and output have the transitional item
		event.recipes.createDeploying('create:incomplete_precision_mechanism',['create:incomplete_precision_mechanism','create:large_cogwheel']),
		event.recipes.createDeploying('create:incomplete_precision_mechanism',['create:incomplete_precision_mechanism','create:iron_nugget'])
	]).transitionalItem('create:incomplete_precision_mechanism').loops(5) // set the transitional item and the loops (amount of repetitions)


	// for this code to work, kubejs:incomplete_spore_blossom need to be added to the game
	let inter = 'kubejs:incomplete_spore_blossom' // making a varrible to store the transition item makes the code more readable
	event.recipes.createSequencedAssembly([
			Item.of('spore_blossom').withChance(16.0), // this is the item that will appear in JEI as the result
			Item.of('flowering_azalea_leaves').withChance(16.0), // the rest of these items will part of the scrap
			Item.of('azalea_leaves').withChance(2.0),
			'oak_leaves',
			'spruce_leaves',
			'birch_leaves',
			'jungle_leaves',
			'acacia_leaves',
			'dark_oak_leaves'
		],'flowering_azalea_leaves', [ // 'flowering_azalea_leaves' is the input
			// the transitional item is a varrible, that is "kubejs:incomplete_spore_blossom", and is used during the intermediate stages of the assembly
			event.recipes.createPressing(inter, inter),
			// like a normal recipe function, is used as a sequence step in this array. Input and output have the transitional item
			event.recipes.createDeploying(inter, [inter, 'minecraft:hanging_roots']),
			event.recipes.createFilling(inter, [inter, Fluid.of('minecraft:water',420)]),
			event.recipes.createDeploying(inter, [inter, 'minecraft:moss_carpet']),
  			event.recipes.createCutting(inter, inter)
		]).transitionalItem(inter).loops(2) // set the transitional item and the loops (amount of repetitions)
})

Transitional Items

As mentioned earlier, any item can be a transition item. However, this is not completely recommended.

If you wish to make your own transitional item, it's best if you make the type create:sequenced_assembly.

1.16 syntax

onEvent('item.registry', event => {
	event.create('incomplete_spore_blossom').displayName('Incomplete Spore Blossom').type('create:sequenced_assembly')
})

1.18 syntax

onEvent('item.registry', event => {
	event.create('incomplete_spore_blossom','create:sequenced_assembly')
})

Mysterious Conversion

Mysterious Conversion recipes are client-side only, so the only way to add them currently is using reflection.

Example

Goes inside client scripts and not in an event.

//makes the varribles used
let MysteriousItemConversionCategory = java('com.simibubi.create.compat.jei.category.MysteriousItemConversionCategory')
let ConversionRecipe = java('com.simibubi.create.compat.jei.ConversionRecipe')

//adds in the recipes
MysteriousItemConversionCategory.RECIPES.add(ConversionRecipe.create('minecraft:apple', 'minecraft:carrot'))

MysteriousItemConversionCategory.RECIPES.add(ConversionRecipe.create('minecraft:golden_apple', 'minecraft:golden_carrot'))

Preventing Recipe Auto-Generation

If you don't want a smelting, blasting, smoking, crafting, or stone-cutting to get an auto-generated counterpart, then include manual_only at the end of the recipe id.

Example

onEvent('recipes', event => {
	event.shapeless('wet_sponge',['water_bucket','sponge']).id('kubejs:moisting_the_sponge_manual_only')
})

Other types of prevention, can be done in the create config (the goggles button leads you there).

If it is not in the config, then you can not change it.