//AE2
//Grinder
//InputStack, OutputStack1, Turns, OutputStack2, OutputStackChance2, OutputStack3, OutputStackChance3
mods.appeng.Grinder.addRecipe(<minecraft:sandstone>, <minecraft:sand> * 2, 4, <minecraft:sand>, 0.8, <minecraft:sand>, 0.6);
//OutputStack
mods.appeng.Grinder.removeRecipe(<minecraft:flint>);

//Inscriber
//InputArray, plateA, plateB, OutputStack, TypeString //TypeStrings avaible are "Inscribe" and "Press"
mods.appeng.Inscriber.addRecipe([<minecraft:gold_block>], <appliedenergistics2:item.ItemMultiMaterial:15>, null, <appliedenergistics2:item.ItemMultiMaterial:18> * 9, "Press");
mods.appeng.Inscriber.addRecipe([<minecraft:iron_ingot>], <minecraft:redstone>, <minecraft:cobblestone>, <minecraft:piston>, "Inscribe");
//OutputStack
mods.appeng.Inscriber.removeRecipe(<appliedenergistics2:item.ItemMultiMaterial:15>);

//Chisel
//Groups
//Group
mods.chisel.Groups.addGroup("hardenedclay"); 
//Group
mods.chisel.Groups.removeGroup("andesite"); 

//Variations
//Group, ItemStack
mods.chisel.Groups.addVariation("hardenedclay", <minecraft:stained_hardened_clay:*>);
//ItemStack
mods.chisel.Groups.removeVariation(<chisel:hexPlating>);

//ex nihilo
//Composting
//InputStack, FillAmount, HexColor
mods.exnihilo.Composting.addRecipe(<minecraft:hay_block>, 0.72, "E3E162");
//InputStack
mods.exnihilo.Composting.removeRecipe(<minecraft:sapling>);

//Crucible
//BlockStack, OutputFluid
mods.exnihilo.Crucible.addRecipe(<minecraft:packed_ice>, <liquid:water> * 1000);
//OutputFluid
mods.exnihilo.Crucible.removeRecipe(<liquid:lava>);
//BlockStack, HeatValue
mods.exnihilo.Crucible.addHeatSource(<minecraft:coal_block>, 0.1);
//BlockStack
mods.exnihilo.Crucible.removeHeatSource(<minecraft:lava>);

//Hammer
//BlockStack, OuputStack OR OutputArray, Chance OR ChanceArray, LuckModifier OR LuckModifierArray
mods.exnihilo.Hammer.addRecipe(<minecraft:cactus>, <minecraft:dye:2>, 0.45, 1.25);
mods.exnihilo.Hammer.addRecipe(<minecraft:tnt>, [<minecraft:gunpowder>, <minecraft:sand>], [0.25, 0.50], [1.00, 1.50]);
//BlockStack
mods.exnihilo.Hammer.removeRecipe(<minecraft:sand>);

//Sieve
//BlockStack, OutputStack OR OutputArray, Rarity OR RarityArray (Rarity goes in Fractions, 1 = 100Pe, 2 = 50Pe, 3 = 33Pe)
mods.exnihilo.Sieve.addRecipe(<minecraft:clay>, <minecraft:waterlily>, 5);
mods.exnihilo.Sieve.addRecipe(<minecraft:mycelium>, [<minecraft:red_mushroom>, <minecraft:brown_mushroom>], [2, 2]); 
//OutputStack
mods.exnihilo.Sieve.removeRecipe(<minecraft:dirt>);

//Extra Utilities
//QED Recipes
//OutputStack, InputArray
 mods.extraUtils.QED.addShapedRecipe(<ExtraUtilities:decorativeBlock1:1> * 8, [[null, <minecraft:obsidian>, null],
                                                                               [<minecraft:obsidian>, <minecraft:ender_pearl>, <minecraft:obsidian>], 
                                                                               [null, <minecraft:obsidian>, null]]); 
 //OutputStack
 mods.extraUtils.QED.removeRecipe(<ExtraUtilities:extractor_base_remote>);
 
 //Forestry
 //Carpenter
//OutputStack, InputArray, InputFluid, Time in Ticks, BoxStack
mods.forestry.Carpenter.addRecipe(<Forestry:oakStick> * 2, [[null, <minecraft:planks>, null],
                                                            [<minecraft:planks>, null, <minecraft:planks>], 
                                                            [null, <minecraft:planks>, null]], <liquid:seedoil> * 100, 20, <minecraft:log>);
//OutputStack, InputFluid
mods.forestry.Carpenter.removeRecipe(<Forestry:impregnatedCasing>, <liquid:seedoil>);

//Centrifuge
//OutputArray + %, Time in Ticks, InputStack
mods.forestry.Centrifuge.addRecipe([<minecraft:leaves> % 200, <minecraft:stick> % 80, <Forestry:beeCombs> % 20], 20, <minecraft:sapling>);
//InputStack
mods.forestry.Centrifuge.removeRecipe(<Forestry:beeCombs>);

//Fermenter
//OutputFluid, InputStack, FluidInput, FermentationValue, FloatModifier //FermentationValue [Amount of InputFluid] * FloatModifier [Multiplier for OutputFluid] = Amount of OutputFluid
mods.forestry.Fermenter.addRecipe(<liquid:honey>, <minecraft:sugar>, <liquid:water>, 100, 2);
//InputStack
mods.forestry.Fermenter.removeRecipe(<minecraft:reeds>);
//InputStack, CycleAmount, BurnDuration
mods.forestry.Fermenter.addFuel(<minecraft:dirt:2>, 1000, 1000);
//InputStack
mods.forestry.Fermenter.removeFuel(<Forestry:mulch>);

//Moistener
//OutputStack, InputStack, Time in Ticks
mods.forestry.Moistener.addRecipe(<minecraft:dirt:2>, <minecraft:grass>, 5000);
//OutputStack
mods.forestry.Moistener.removeRecipe(<minecraft:mycelium>);

//Squeezer
//OutputFluid, OutputStack + %, InputArray, Time in Ticks
mods.forestry.Squeezer.addRecipe(<liquid:ice> * 1000, <Forestry:craftingMaterial:5> % 200, [<minecraft:packed_ice> * 4, <minecraft:snowball>], 20); 
//OutputFluid, InputArray
mods.forestry.Squeezer.removeRecipe(<liquid:water>, [<Forestry:canWater>]);

//Still
//OutputFluid, InputFluid, Time in Ticks
mods.forestry.Still.addRecipe(<liquid:bioethanol> * 20, <liquid:juice> * 20, 100); 
//OutputFluid, InputFluid
mods.forestry.Still.removeRecipe(<liquid:bioethanol>, <liquid:biomass>);

//Thermionic Fabricator
//MoltenGlassOutput, InputStack, MeltingTemperature, //MoltenGlassOutput: Glass & Sand = 1000mB; Glass Pane = 375mB + MeltingTemperature: Glass & Glass Pane = 1000; Sand = 3000
mods.forestry.ThermionicFabricator.addSmelting(375, <minecraft:stained_glass_pane>, 1000); 
//InputStack
mods.forestry.ThermionicFabricator.removeSmelting(<minecraft:sand>); 
//OutputStack, InputArray, MoltenGlassInput, CastInput
mods.forestry.ThermionicFabricator.addCast(<minecraft:beacon>, [[null, null, null], 
                                                                [null, <minecraft:nether_star>, null], 
                                                                [<minecraft:obsidian>, <minecraft:obsidian>, <minecraft:obsidian>]], 1000, <Forestry:waxCast:*>);
//OutputStack
mods.forestry.ThermionicFabricator.removeCast(<minecraft:stained_glass>);

//Mekanism
//Chemical Crystallizer
//InputGas, OutputStack
mods.mekanism.chemical.Crystallizer.addRecipe(<gas:water>, <minecraft:ice>);
//OutputStack, InputGas
mods.mekanism.chemical.Crystallizer.removeRecipe(<Mekanism:OtherDust:4>, <gas:lithium>);

//Chemical Dissolution Chamber
//InputStack, OutputGas
mods.mekanism.chemical.Dissolution.addRecipe(<minecraft:ice>, <gas:water>);
//OutputGas, InputStack
mods.mekanism.chemical.Dissolution.removeRecipe(<gas:osmium>, <Mekanism:OreBlock>);

//Chemical Infuser
//InputGas1, InputGas2, OutputGas
mods.mekanism.chemical.Infuser.addRecipe(<gas:water>, <gas:deuterium>, <gas:steam>);
//OutputGas, InputGas1, InputGas2
mods.mekanism.chemical.Infuser.removeRecipe(<gas:hydrogenchloride>, <gas:hydrogen>, <gas:chlorine>);

//Chemical Injection Chamber
//InputStack, InputGas, OutputStack
//InputGas only accepts "<gas:sulfuricAcid>", "<gas:water>" or "<gas:hydrogenChloride>"
mods.mekanism.chemical.Injection.addRecipe(<minecraft:hardened_clay:1>, <gas:water>, <minecraft:clay>);
//OutputStack, InputStack, InputGas
mods.mekanism.chemical.Injection.removeRecipe(<Mekanism:Shard:2>, <Mekanism:OreBlock>, <gas:hydrogenchloride>);

//Chemical Oxidizer
//InputStack, OutputGas
mods.mekanism.chemical.Oxidizer.addRecipe(<Mekanism:Dust:2>, <gas:cleanOsmium>);
//OutputGas, InputStack
mods.mekanism.chemical.Oxidizer.removeRecipe(<gas:brine>, <Mekanism:Salt>);

//Chemical Washer
//InputGas, OutputGas
mods.mekanism.chemical.Washer.addRecipe(<gas:steam>, <gas:water>);
//OutputGas, InputGas
mods.mekanism.chemical.Washer.removeRecipe(<gas:cleanLead>, <gas:lead>);

//Combiner
//InputStack, InputGas, OutputStack
mods.mekanism.Combiner.addRecipe(<minecraft:stone> * 4, <gas:liquidStone>, <minecraft:stonebrick>);
//OutputStack, InputStack, InputGas
mods.mekanism.Combiner.removeRecipe(<minecraft:gravel>, <minecraft:flint>, <gas:liquidStone>);

//Osmium Compressor
//InputStack, InputGas, OutputStack
mods.mekanism.Compressor.addRecipe(<Mekanism:BasicBlock:3>, <gas:liquidOsmium>, <minecraft:bedrock>);
//OutputStack, InputStack, InputGas
mods.mekanism.Compressor.removeRecipe(<Mekanism:Ingot>, <Mekanism:OtherDust:5>, <gas:liquidOsmium>);

//Crusher
//InputStack, OutputStack
mods.mekanism.Crusher.addRecipe(<minecraft:double_plant:4>, <minecraft:dye:1> * 5);
//OutputStack, InputStack
mods.mekanism.Crusher.removeRecipe(<minecraft:sand>, <minecraft:gravel>);

//Energized Smelter
//InputStack, OutputStack
mods.mekanism.Smelter.addRecipe(<minecraft:tallgrass:1>, <minecraft:deadbush>);
//InputStack, OutputStack
mods.mekanism.Smelter.removeRecipe(<minecraft:sand>, <minecraft:glass>);

//Enrichment Chamber
//InputStack, OutputStack
mods.mekanism.Enrichment.addRecipe(<minecraft:coal_block>, <Mekanism:CompressedCarbon> * 9);
//InputStack, OutputStack
mods.mekanism.Enrichment.removeRecipe(<minecraft:mossy_cobblestone>, <minecraft:cobblestone>);

//Metallurgic Infuser
//InfusionString, InputInfusion, InputStack, OutputStack //InfusionString = CARBON;TIN;DIAMOND;REDSTONE;FUNGI;BIO;OBSIDIAN
mods.mekanism.Infuser.addRecipe("OBSIDIAN", 20, <minecraft:coal_block>, <minecraft:obsidian>);
//OutputStack, InputStack, InfusionString
mods.mekanism.Infuser.removeRecipe(<minecraft:mycelium>);

//Purification Chamber
//InputStack, InputGas, OutputStack
mods.mekanism.Purification.addRecipe(<minecraft:wool:1>, <gas:hydrogenchloride>, <minecraft:wool>);
//OutputStack, InputStack, InputGas
mods.mekanism.Purification.removeRecipe(<Mekanism:Clump:2>, <Mekanism:Shard:2>, <gas:oxygen>);

//Pressurised Reaction Chamber
//InputStack, InputFluid, InputGas, OutputStack, OutputGas, InputRF, Time in Ticks
mods.mekanism.Reaction.addRecipe(<Mekanism:Polyethene>, <liquid:ethene>, <gas:oxygen>, <Mekanism:Polyethene> * 8, <gas:oxygen>, 50000, 2000);
//OutputStack, OutputGas, InputStack, InputFluid, InputGas
mods.mekanism.Reaction.removeRecipe(<Mekanism:Substrate>, <gas:ethene>, <Mekanism:BioFuel>, <liquid:water>, <gas:hydrogen>);

//Precision Sawmill
//InputStack, OutputStack1, OutputStack2, Chance
mods.mekanism.Sawmill.addRecipe(<minecraft:bow>, <minecraft:stick> * 3, <minecraft:string> * 3, 0.5);
//InputStack, OutputStack1, OutputStack2
mods.mekanism.Sawmill.removeRecipe(<minecraft:bed>, <minecraft:planks>, <minecraft:wool>);

//Electrolytic Separator
//InputFluid, InputRF, OutputGas1, OutputGas2
mods.mekanism.Separator.addRecipe(<liquid:fusionfueldt>, 5000, <gas:deuterium>, <gas:tritium>);
//InputFluid, OutputGas1, OutputGas2
mods.mekanism.Separator.removeRecipe(<liquid:heavywater>, <gas:deuterium>, <gas:oxygen>);

//Solar Evaporation
//InputFluid, OutputFluid
mods.mekanism.SolarEvaporation.addRecipe(<liquid:lava>, <liquid:fusionfueldt>);
//InputFluid, OutputFluid
mods.mekanism.SolarEvaporation.removeRecipe(<liquid:water>, <liquid:brine>);

//Solar Neutron Activator 
//InputGas, OutputGas
mods.mekanism.SolarNeutronActivator.addRecipe(<gas:liquidStone>, <gas:liquidOsmium>);
//InputGas, OutputGas
mods.mekanism.SolarNeutronActivator.removeRecipe(<gas:lithium>, <gas:tritium>);

//PneumaticCraft
//Assembly
//Drill
//InputStack, OutputStack
mods.pneumaticcraft.Assembly.addDrillRecipe(<minecraft:diamond>, <minecraft:dye:6> * 6);
//OutputStack
mods.pneumaticcraft.Assembly.removeDrillRecipe(<minecraft:dye:1>);
//Laser
//InputStack, OutputStack
mods.pneumaticcraft.Assembly.addLaserRecipe(<PneumaticCraft:fuelBucket>, <minecraft:lava_bucket>);
//OutputStack
mods.pneumaticcraft.Assembly.removeLaserRecipe(<PneumaticCraft:aphorismTile>);
//Laser Drill
//InputStack, OutputStack
mods.pneumaticcraft.Assembly.addLaserDrillRecipe(<PneumaticCraft:airCompressor>, <PneumaticCraft:advancedAirCompressor>);
//OutputStack
mods.pneumaticcraft.Assembly.removeLaserDrillRecipe(<PneumaticCraft:advancedPressureTube>); 

//Pressure Chamber
//InputArray, PressureRequired, OutputArray, asBlock
mods.pneumaticcraft.Pressure.addRecipe([<minecraft:iron_ingot>, <minecraft:iron_bars> * 4], 2, [<PneumaticCraft:compressedIronGear>], true);
//OutputArray
mods.pneumaticcraft.Pressure.removeRecipe([<minecraft:diamond>]);

//Thaumcraft
//Arcane Workbench
//ResearchString, OutputStack, AspectString, InputArray
mods.thaumcraft.Arcane.addShaped("ASPECTS", <minecraft:stonebrick:3> * 4, "ordo 1", [[<minecraft:stonebrick>, <minecraft:stonebrick>, null], 
                                                                                     [<minecraft:stonebrick>, <minecraft:stonebrick>, null],
                                                                                     [null, null, null]]);
//ResearchString, OutputStack, AspectString, InputArray
mods.thaumcraft.Arcane.addShapeless("VOIDMETAL", <minecraft:ghast_tear>, "aqua 6, terra 6, perditio 6, ordo 6, aer 6, ignis 6", [<minecraft:ender_pearl>, <Thaumcraft:ItemResource:17>]);
//OutputStack
mods.thaumcraft.Arcane.removeRecipe(<Thaumcraft:ItemArcaneDoor>);
 
//Aspects
//InputStack, AspectString
mods.thaumcraft.Aspects.add(<minecraft:saddle>, "motus 4");
//InputStack, AspectString
mods.thaumcraft.Aspects.set(<Thaumcraft:ItemBucketPure>, "aqua 4, metallum 8, vacous 1, sano 2, auram 2");
//InputStack, AspectString
mods.thaumcraft.Aspects.remove(<minecraft:glowstone_dust>, "lux 2");
//EntityString, AspectString
mods.thaumcraft.Aspects.addEntity("Skeleton", "lucrum 2, mortuus 1");
//EntityString, AspectString
mods.thaumcraft.Aspects.setEntity("Arrow", "telum 1");
//EntityString, AspectString
mods.thaumcraft.Aspects.removeEntity("Creeper", "ignis 2");

//Crucible
//ResearchString, OutputStack, InputStack, AspectString
mods.thaumcraft.Crucible.addRecipe("ENTROPICPROCESSING", <minecraft:dirt>, <minecraft:sapling>, "terra 2, perditio 4");
//OutputStack
mods.thaumcraft.Crucible.removeRecipe(<Thaumcraft:ItemResource:2>);

//Infusion
//ResearchString, MainInputStack, InputArray, AspectString, OutputStack, InstabilityAmount
mods.thaumcraft.Infusion.addRecipe("NITOR", <Thaumcraft:ItemResource:1>, [<minecraft:fire_charge>, <Thaumcraft:ItemResource>, <minecraft:flint_and_steel>], "ignis 20, potentia 10, permutatio 12", <minecraft:fire> * 4, 5);
//OutputStack
mods.thaumcraft.Infusion.removeRecipe(<Thaumcraft:ItemAmuletVis:1>);
//ResearchString, EnchantmentID, InstabilityAmount, AspectString, InputArray,
mods.thaumcraft.Infusion.addEnchantment("XPBOOST", 45, 5, "victus 10, cognitio 8, vitreus 6",  [<minecraft:experience_bottle>, <minecraft:experience_bottle>, <minecraft:experience_bottle>, <Thaumcraft:ItemResource:14>]);
//EnchantmentID
mods.thaumcraft.Infusion.removeEnchant(1);

//Loot
//InputStack, Weight
mods.thaumcraft.Loot.addCommonLoot(<Thaumcraft:ItemNugget:16>, 40);
mods.thaumcraft.Loot.addUncommonLoot(<Thaumcraft:ItemNugget:31>, 20);
mods.thaumcraft.Loot.addRareLoot(<Thaumcraft:ItemEldritchObject:3>, 5);
//InputStack
mods.thaumcraft.Loot.removeCommonLoot(<Thaumcraft:ItemBaubleBlanks>);
mods.thaumcraft.Loot.removeUncommonLoot(<Thaumcraft:ItemRingRunic>);
mods.thaumcraft.Loot.removeRareLoot(<minecraft:golden_apple:1>);

//Warp
//ResearchString, WarpAmount
mods.thaumcraft.Warp.addToResearch("BATHSALTS", 5);
//InputStack, WarpAmount
mods.thaumcraft.Warp.addToItem(<Thaumcraft:ItemBathSalts>, 5);
//ResearchString
mods.thaumcraft.Warp.removeFromResearch("BOTTLETAINT");
//InputStack
mods.thaumcraft.Warp.removeFromItem(<Thaumcraft:ItemBottleTaint>);
//Overall Warp Removal
mods.thaumcraft.Warp.removeAll();
mods.thaumcraft.Warp.removeAllResearch();
mods.thaumcraft.Warp.removeAllItems();

//Thermal Expansion
//Magma Crucible
//InputRF, InputStack, OutputFluid
mods.thermalexpansion.Crucible.addRecipe(500000, <minecraft:dragon_egg>, <liquid:ender> * 8000);
//InputStack
mods.thermalexpansion.Crucible.removeRecipe(<minecraft:netherrack>);

//Redstone Furnace
//InputRF, InputStack, OutputStack
mods.thermalexpansion.Furnace.addRecipe(16000, <minecraft:obsidian>, <minecraft:netherrack>);
//InputStack //Recommended to sync with "furnace.remove();" function
mods.thermalexpansion.Furnace.removeRecipe(<minecraft:potato>);

//Phytogenic Insolator
//InputRF, InputStack1, InputStack2, OutputStack1, OutputStack2, Chance
mods.thermalexpansion.Insolator.addRecipe(7200, <ThermalExpansion:material:516>, <minecraft:mycelium>, <minecraft:mycelium>, <minecraft:brown_mushroom>, 50);
mods.thermalexpansion.Insolator.addRecipe(9600, <ThermalExpansion:material:517>, <minecraft:mycelium>, <minecraft:mycelium> * 3, <minecraft:brown_mushroom>, 50);
//InputStack1, InputStack2
mods.thermalexpansion.Insolator.removeRecipe(<ThermalExpansion:material:516>, <minecraft:cactus>);
mods.thermalexpansion.Insolator.removeRecipe(<ThermalExpansion:material:517>, <minecraft:cactus>);

//Pulverizer
//InputRF, InputStack, OutputStack1, OutputStack2, Chance
mods.thermalexpansion.Pulverizer.addRecipe(3000, <minecraft:flint_and_steel>, <minecraft:flint>, <minecraft:iron_ingot>, 80);
//InputStack
mods.thermalexpansion.Pulverizer.removeRecipe(<minecraft:reeds>);

//Sawmill
//InputRF, InputStack, OutputStack1, OutputStack2, Chance
mods.thermalexpansion.Sawmill.addRecipe(2400, <minecraft:ladder>, <minecraft:stick> * 5, <ThermalExpansion:material:512>, 100);
//InputStack
mods.thermalexpansion.Sawmill.removeRecipe(<minecraft:bed>);

//Induction Smelter
//InputRF, InputStack, InputStack2, OutputStack1, OutputStack2, Chance
mods.thermalexpansion.Smelter.addRecipe(800, <minecraft:dye:1>, <minecraft:sand>, <minecraft:stained_glass:14>, <ThermalExpansion:material:514>, 25);
//InputStack, InputStack1
mods.thermalexpansion.Smelter.removeRecipe(<minecraft:sand>, <minecraft:redstone_ore>);

//Fluid Transposer
//InputRF, InputStack, OutputStack, InputFluid
mods.thermalexpansion.Transposer.addFillRecipe(2000, <minecraft:gunpowder>, <minecraft:tnt> * 2, <liquid:redstone> * 100);
//InputRF, InputStack, InputFluid, OutputStack, Chance
mods.thermalexpansion.Transposer.addExtractRecipe(2000, <minecraft:leaves>, <liquid:water> * 50, <minecraft:stick>, 100);
//InputStack, InputFluid
mods.thermalexpansion.Transposer.removeFillRecipe(<minecraft:glass_bottle>, <liquid:water>);
//InputStack
mods.thermalexpansion.Transposer.removeExtractRecipe(<minecraft:water_bucket>);

//Tinkers Construct
//Casting
//OutputStack, InputFluid, CastStack, ConsumeCast, Time in Ticks
mods.tconstruct.Casting.addBasinRecipe(<TConstruct:MeatBlock>, <liquid:pigiron.molten> * 1152, <minecraft:bone>, true, 20);
//OutputStack, InputFluid, CastStack, ConsumeCast, Time in Ticks
mods.tconstruct.Casting.addTableRecipe(<TConstruct:strangeFood:2>, <liquid:pigiron.molten> * 57, null, false, 20);
//OutputStack
mods.tconstruct.Casting.removeBasinRecipe(<minecraft:iron_block>);
mods.tconstruct.Casting.removeTableRecipe(<minecraft:iron_ingot>);

//Drying Rack
//InputStack, OutputStack, Time in Ticks
mods.tconstruct.Drying.addRecipe(<minecraft:tallgrass:1>, <minecraft:deadbush>, 50);
//OutputStack
mods.tconstruct.Drying.removeRecipe(<TConstruct:jerky>);

//Modifiers
//ModifierString
mods.tconstruct.Modifiers.remove("Blaze");

//Smeltery
//InputStack, OutputFluid, TemperatureAmount, BlockRender
mods.tconstruct.Smeltery.addMelting(<minecraft:porkchop>, <liquid:blood> * 200, 200, <TConstruct:MeatBlock>);
//InputStack
mods.tconstruct.Smeltery.removeMelting(<TConstruct:strangeFood:1>);
//OutputFluid, InputFluidArray
mods.tconstruct.Smeltery.addAlloy(<liquid:aluminumbrass.molten> * 64, [<liquid:aluminum.molten> * 48, <liquid:gold.molten> * 16]);
//OutputFluid
mods.tconstruct.Smeltery.removeAlloy(<liquid:manyullyn.molten>);
//InputFluid, TemperatureAmount, Time in Ticks
mods.tconstruct.Smeltery.addFuel(<liquid:iron.molten>, 64, 64);
//InputFluid
mods.tconstruct.Smeltery.removeFuel(<liquid:lava>);

//Repair Materials
//InputStack, MaterialString, ValueAmount
mods.tconstruct.Tweaks.addRepairMaterial(<minecraft:stonebrick>, "Stone", 2);
//InputStack, MaterialString
mods.tconstruct.Tweaks.removeRepairMaterial(<minecraft:stone>, "Stone");

//Tool Stats
//MaterialString, DisplayName, HarvestLevel, DurabilityValue, SpeedValue, DamageValue, HandleModifier, ReinforcedLevel, StoneboundLevel, StyleString, Colour
mods.tconstruct.ToolStats.setStats("Stone", "Modtweaker Stone", 47, 108, 112, 83, 0.5, 102, 0.5, "gold", 484848);
//MaterialString, DisplayName
mods.tconstruct.ToolStats.setDisplayName("Wood", "Modtweaker Wood");
//MaterialString, HarvestLevel
mods.tconstruct.ToolStats.setHarvestLevel("Wood", 1);
//MaterialString, DurabilityValue
mods.tconstruct.ToolStats.setDurability("Wood", 3000);
//MaterialString, SpeedValue
mods.tconstruct.ToolStats.setSpeed("Wood", 30);
//MaterialString, DamageValue
mods.tconstruct.ToolStats.setDamage("Wood", 9001);
//MaterialString, HandleModifier
mods.tconstruct.ToolStats.setHandleModifier("Wood", 50.5);
//MaterialString, ReinforcedLevel
mods.tconstruct.ToolStats.setReinforcedLevel("Wood", 4);
//MaterialString, StoneboundLevel
mods.tconstruct.ToolStats.setStoneboundLevel("Wood", 6);
//MaterialString, StyleString
mods.tconstruct.ToolStats.setStyle("Wood", "§4");
//MaterialString, AbilityString
mods.tconstruct.ToolStats.setAbility("Wood", "Stonebound");
//MaterialString, DurabilityValue, DrawSpeedValue, FlightSpeedValue
mods.tconstruct.ToolStats.setBowStats("Stone", 100, 21, 12.5F);
//MaterialString, DurabilityValue
mods.tconstruct.ToolStats.setBowDurability("Wood", 2000);
//MaterialString, DrawSpeedValue
mods.tconstruct.ToolStats.setBowDrawspeed("Wood", 250);
//MaterialString, FlightSpeedValue
mods.tconstruct.ToolStats.setBowFlightSpeed("Wood", 6.5F);
//MaterialString, MassValue, BreakChanceValue, AccuracyValue
mods.tconstruct.ToolStats.setArrowStats("Stone", 2.5F, 5.0F, 100F)
//MaterialString, MassValue
mods.tconstruct.ToolStats.setArrowMass("Wood", 3.5F);
//MaterialString, BreakChanceValue
mods.tconstruct.ToolStats.setArrowBreakChance("Wood", 25F);
//MaterialString, AccuracyValue
mods.tconstruct.TooLStats.setArrowAccuracy("Wood", 20F);

//Blood Magic
//Blood Altar
//InputStack, OutputStack, TierRequired, LPRequired, UsageRate, DrainRate
mods.bloodmagic.Altar.addRecipe(<minecraft:glowstone_dust>, <minecraft:redstone>, 3, 5000, 20, 20);
//OutputStack
mods.bloodmagic.Altar.removeRecipe(<AWWayofTime:blankSlate>);

//Blood Orb Shaped and Shapeless Recipes
//OutputStack, InputArray
mods.bloodmagic.BloodOrb.addShaped(<minecraft:ender_pearl>, [[<AWWayofTime:weakBloodShard>, <AWWayofTime:crystallos>,<AWWayofTime:weakBloodShard>], [<AWWayofTime:magicales>, <AWWayofTime:magicianBloodOrb>, <AWWayofTime:magicales>], [<AWWayofTime:weakBloodShard>, <AWWayofTime:crystallos>, <AWWayofTime:weakBloodShard>]]);
//OutputStack, InputArray
mods.bloodmagic.BloodOrb.addShapeless(<AWWayofTime:demonBloodShard> * 5, [<AWWayofTime:archmageBloodOrb>, <AWWayofTime:demonBloodShard>, <AWWayofTime:bloodMagicBaseItems:27>]);

//Alchemical Chemistry Set
//OutputStack, InputArray, TierRequired, LPRequired
mods.bloodmagic.Alchemy.addRecipe(<minecraft:clay> * 2, [<minecraft:hardened_clay>, <minecraft:hardened_clay>, <minecraft:water_bucket>], 1, 100);
//OutputStack
mods.bloodmagic.Alchemy.removeRecipe(<minecraft:ice>);

//Buildcraft 
//Assembly Table
//OutputStack, InputRF, InputArray
mods.buildcraft.AssemblyTable.addRecipe(<BuildCraft|Transport:pipePlug>, 5000, [<minecraft:gravel>, <minecraft:cobblestone> * 2, <minecraft:glass>]);
//OutputStack, InputArray, isWildcard
mods.buildcraft.AssemblyTable.removeRecipe(<BuildCraft|Silicon:redstoneChipset>, [<minecraft:redstone>], false);

//Combustion Engine
//InputFluid, OutputRF per Cycle, BurningTime in Ticks
mods.buildcraft.Fuels.addCombustionEngineFuel(<liquid:lava>, 5000, 200);
//InputFluid
mods.buildcraft.Fuels.removeCombustionEngineFuel(<liquid:fuel);
//InputFluid, OutputCooling by mB
mods.buildcraft.Fuels.addCombustionEngineCoolant(<liquid:oil>, 100);
//InputStack, OutputFluid
mods.buildcraft.Fuels.addCoolantItem(<minecraft:ice>, <liquid:water> * 1000);
//InputStack, OutputFluid, Multiplier
mods.buildcraft.Fuels.addCoolantItemWithMultiplier(<minecraft:packed_ice>, <liquid:water> * 4000, 2);
//InputFluid
mods.buildcraft.Fuels.removeCombustionEngineCoolant(<liquid:water);
//InputStack
mods.buildcraft.Fuels.removeCoolantItem(<minecraft:water_bucket>);

//Integration Table
//W.I.P

//Refinery
//OutputFluid, RF per mB, Ticks per mB, InputFluid1, InputFluid2
mods.buildcraft.Refinery.addRecipe(<liquid:oil> * 2, 25, 25, <liquid:water>, <liquid:lava>);
//OutputFluid
mods.buildcraft.Refinery.removeRecipe(<liquid:fuel);

//IC2
val chainsaw = <IC2:itemToolChainsaw>.anyDamage();
recipes.addShapeless(<minecraft:stick> * 3, [<ore:plankWood>, chainsaw.onlyIC2ChargeAtLeast(100).transformIC2Discharge(100)]);
Machines
The following machines are supported:

Canner
Compressor
Extractor
Macerator
Metal Former
Ore Washer
Recycler
Thermal Centrifuge
Each of these machines can have new recipes added:

import mods.ic2.Canner;
import mods.ic2.Compressor;
import mods.ic2.Extractor;
import mods.ic2.Macerator;
import mods.ic2.MetalFormer;
import mods.ic2.OreWasher;
import mods.ic2.ThermalCentrifuge;

// TODO: make some proper examples and test them
Canner.addBottleRecipe(output, container, fillIngredient);
Canner.addBottleRecipe(output, container, water);
Canner.addEnrichRecipe(output, input, additiveItem);
Canner.addEnrichRecipe(output, input, additiveLiquid);

Compressor.addRecipe(<minecraft:planks>, <minecraft:stick>);
Extractor.addRecipe(<minecraft:wheat>, <minecraft:bread>);
Macerator.addRecipe(<minecraft:wheat> * 2, <minecraft:bread>);
MetalFormer.addCuttingRecipe(<minecraft:stick> * 3, <minecraft:planks:*>);
MetalFormer.addExtrudingRecipe(<minecraft:stick> * 3, <minecraft:planks:*>);
MetalFormer.addRollingRecipe(<minecraft:stick> * 3, <minecraft:planks:*>);
OreWasher.addRecipe([<minecraft:wheat>, <minecraft:wheat_seeds>], <minecraft:bread>, 1000); // 1000 = water usage
ThermalCentrifuge.addRecipe([<minecraft:wheat>, <minecraft:wheat_seeds>], <minecraft:bread>, 1000); // 1000 = minimum temperature
Recycler blacklist
You can add additional items to the recycler blacklist:

import mods.ic2.Recycler;

Recycler.addBlacklist(<minecraft:planks:*>);
Semifluid generator
It is possible to add new fuels to the semifluid generator:

import mods.ic2.SemiFluidGenerator;

// first argument is the amount of liquid used per cycle, the second the energy production / tick
SemiFluidGenerator.addFluid(<liquid:lava> * 10, 5);
Scrapbox
You can register new items to the scrapbox:

import mods.ic2.ScrapBox;

ScrapBox.addDrop(<minecraft:emerald>.weight(0.05));
As a reference, diamond has weight 0.1, dirt has weight 5 and wooden tools have weight 1.

//ImmersiveEngineering
//Arc Furnace
//OutputStack, InputStack, SlagOutput, Time in Ticks, Energy per Tick, AdditiveArray, RecipeTypeString //Either create your own NEI pages with custom strings or use original ones
mods.immersiveengineering.ArcFurnace.addRecipe(<minecraft:gravel>, <minecraft:dirt> * 9, <ImmersiveEngineering:material:13>, 4600, 3600, [<ImmersiveEngineering:fluidContainers:4>], "Purifying");
//OutputStack
mods.immersiveengineering.ArcFurnace.removeRecipe(<ImmersiveEngineering:metal:7>);

//Blast Furnace
//Smelting
//OutputStack, InputStack, Time in Ticks, SlagOutput
mods.immersiveengineering.BlastFurnace.addRecipe(<ImmersiveEngineering:material:12>, <ImmersiveEngineering:material:11>, 4800, <ImmersiveEngineering:material:13>);
//OutputStack
mods.immersiveengineering.BlastFurnace.removeRecipe(<ImmersiveEngineering:metal:7>);
//Fuel
//InputStack, Time in Ticks
mods.immersiveengineering.BlastFurnace.addFuel(<ImmersiveEngineering:metal:17>, 1200);
//InputStack
mods.immersiveengineering.BlastFurnace.removeFuel(<ImmersiveEngineering:material:6>);

//Bottling Machine
//OutputStack, InputStack, InputFluid
mods.immersiveengineering.BottlingMachine.addRecipe(<minecraft:packed_ice>, <minecraft:ice>, <liquid:water> * 1000);
//OutputStack
mods.immersiveengineering.BottlingMachine.removeRecipe(<minecraft:water_bucket>); 

//Coke Oven
//OutputStack, FuelOutput, InputStack, Time in Ticks
mods.immersiveengineering.CokeOven.addRecipe(<minecraft:coal:1> * 2, 500, <minecraft:chest>, 1800);
//OutputStack
mods.immersiveengineering.CokeOven.removeRecipe(<ImmersiveEngineering:material:6>);

//Crusher
//OutputStack1, InputStack, Energy, OutputStack2, OutputStack2Chance //Chance in Decimals
mods.immersiveengineering.Crusher.addRecipe(<ImmersiveEngineering:metal> * 8, <ImmersiveEngineering:storage:8>, 8000, <minecraft:iron_ingot>, 0.5);
//OutputStack
mods.immersiveengineering.Crusher.removeRecipe(<minecraft:blaze_powder>);

//Excavator
//MineralString, MineralWeight, FailChance, OreStringArray, OreChanceArray, DimensionIDArray, isWhitelistOrBlacklist //true=blacklist; false=whitelist
mods.immersiveengineering.Excavator.addMineral("Sediment", 30, 15, ["sand", "sandstone"], [50, 15], [0, 1], false);
//MineralString
mods.immersiveengineering.Excavator.removeMineral("Bauxite");
//MineralString + OreString, Chance
mods.immersiveengineering.Excavator.getMineral("Magnetite").addOre("oreNickel", 0.75);
//MineralString + OreString
mods.immersiveengineering.Excavator.getMineral("Magnetite").removeOre("oreGold");

//Fermenter
//OutputStack, OutputFluid, InputStack, Time in Ticks
mods.immersiveengineering.Fermenter.addRecipe(<minecraft:blaze_powder>, <liquid:lava> * 80, <minecraft:nether_wart>, 80);
//OutputStack
mods.immersiveengineering.Fermenter.removeItemRecipe(<minecraft:blaze_powder>);
//OutputFluid
mods.immersiveengineering.Fermenter.removeFluidRecipe(<liquid:ethanol>);

//Metal Press
//OutputStack, InputStack, MoldStack, Energy, SizeValue
mods.immersiveengineering.MetalPress.addRecipe(<minecraft:stone_slab> * 2, <minecraft:stone>, <ImmersiveEngineering:mold>, 500, 50);
//OutputStack
mods.immersiveengineering.MetalPress.removeRecipe(<ImmersiveEngineering:metal:30>);
//MoldStack
mods.immersiveengineering.MetalPress.removeRecipeByMold(<ImmersiveEngineering:mold:2>);

//Refinery
//OutputFluid, InputFluid1, InputFluid2
mods.immersiveengineering.Refinery.addRecipe(<liquid:lava> * 16, <liquid:plantoil> * 8, <liquid:biodiesel> * 8);
//OutputStack
mods.immersiveengineering.Refinery.removeRecipe(<liquid:biodiesel>);

//Squeezer
//OutputStack, OutputFluid, InputStack, Time in Ticks
mods.immersiveengineering.Squeezer.addRecipe(<minecraft:melon_seeds> * 4, <liquid:water> * 500, <minecraft:melon_block>, 240);
//OutputStack
mods.immersiveengineering.Squeezer.removeItemRecipe(<minecraft:melon_seeds>);
//OutputFluid
mods.immersiveengineering.Squeezer.removeFluidRecipe(<liquid:plantoil>);

//MFR
import mods.mfr.AutoSpawner;

# Substitute with the desired entity class name
AutoSpawner.addBlacklist("mods.natura.entity.NitroCreeper");
AutoSpawner.removeBlacklist("mods.natura.entity.NitroCreeper");
The given entity class name must be a valid living entity. If you want to know which entity names exist in the game, use the /mt entities command to generate the list for you.

Fertilizer
(Unfinished)

Fruit Picker
(Unfinished)

Grinder
(Unfinished)

Harvester
New blocks can be added to the harvester for harvesting:

import mods.mfr.Harvester;

// cherry tree - be aware that logs have a different meta value when oriented differently
// use /mt blockinfo to check the correct meta values for the leaves
Harvester.addHarvestable(<BiomesOPlenty:logs1:*>,"tree");
Harvester.addHarvestable(<BiomesOPlenty:leaves3:9>,"treeLeaf");

// magical tree
Harvester.addHarvestable(<BiomesOPlenty:logs2:*>,"tree");
Harvester.addHarvestable(<BiomesOPlenty:leaves1:10>, "treeLeaf");
The second argument is the harvestable type. "tree" will follow the MFR algorithm to cut trees, cutting the leaves first. "treeLeaf" is used for leaves. "normal" is used for single blocks and "column" for plants like cactuses and reeds. "treeFlipped" is supposedly used for trees growing upside down. Natura, anyone?

Normally the harvester will generate the items that are dropped by breaking the blocks. Other items can be dropped by specifying them:

Harvester.addHarvestable(<BiomesOPlenty:logs2:*>, <minecraft:stick> * 4, "tree");
Harvester.addHarvestable(<BiomesOPlenty:logs1:*>, [<minecraft:stick> * 4, <BiomesOPlenty:woodenDoubleSlab1:1> % 25], "tree");
If custom items are specified, the default drops are ignored.

Mining Laser
It is possible to add and remove ores from the mining laser:

import mods.mfr.MiningLaser;

MiningLaser.addOre(<tile.stone>.weight(1000)); # Let's be an asshole and make it generate stone most of the time
MiningLaser.addOre((<tile.stone> * 2).withTag({Display: {Name: "Funny Stone"}}).weight(1000)); # works with stack sizes and tags
MiningLaser.removeOre(<tile.oreIron>); # can use ore dictionary entries, too (will remove all matching items)

MiningLaser.addPreferredOre(1, <tile.oreIron>); # color codes are the same as the wool meta values
MiningLaser.removePreferredOre(1, <tile.oreIron>);

To see which laser ores exist, use the /mt mfr laserores command. It also prints the preferred laser ore list to see the laser's color preferences.

Planter
You can define new plantable items in the planter:

import mods.mfr.Planter;

Planter.addPlantable(<BiomesOPlenty:saplings:10>);
(More functions available but unfinished)

Rancher
(Unfinished)

RedNet
(Unfinished)

Rubber Tree
Does your favorite worldgen mod not spawn rubber trees in the right biome? Fix it easily:

import mods.mfr.RubberTree;

RubberTree.addBiome("SuperXLBiome");
RubberTree.removeBiome("SuperXLBiome");
To find the list of biome names, use /mt biomes !

Safari Net
(Unfinished)

Sludge Boiler
Drops can be added and removed:

import mods.mfr.SludgeBoiler;

SludgeBoiler.addDrop(<minecraft:stick> * 16);
SludgeBoiler.addDrop(<TConstruct:CraftedSoil:4>.weight(10));
SludgeBoiler.removeDrop(<minecraft:dirt:1>);
Use /mt mfr sludgedrops to have the list of sludge drops generated in minetweaker.log.

MFR Biofuel Generator
This machine can't have its acceptable items altered. Instead, anything that works with the planter should work in this generator.

//NEI
import mods.nei.NEI;

NEI.hide(<minecraft:bread>);
NEI.addEntry(<minecraft:bread>.withTag({display: {Name: "Tasty bread", Lore: ["Thanks to MineTweaker,", "We can now have tastier bread"]}}));
NEI.overrideName(<minecraft:stick>, "Sticky");

//vanila
Tutorial:Introduction
Contents [hide] 
1 Introduction
1.1 Scripts
1.2 Writing a first script
1.3 The Minetweaker log
1.4 Reloading
1.5 Comments
Introduction
Ever went into building a modpack and then found that just throwing in a bunch of mods didn't give you an integrated experience? As mods are developed relatively independently from each other, one may feel overpowered in comparison to the other. Or you may believe that there would be a better recipe for some of the items. Or perhaps you'd want to remove an item from the game without having to remove the entire mod. Or you may discover that some ore dictionary entries have too many or too few items. Now you can do all of that - each with just a single instruction to MineTweaker.

In addition to the core functionality provided to support Vanilla minecraft, mod integration libraries are provided with the mod to enable you to not only modify vanilla recipes, but also the mod machine recipes and mod behavior.

Scripts
To make the functionality available in a clear and concise manner, a custom scripting language is provided. The language is easy to learn - and for basic operations you can just follow the tutorials.

For multiplayer games, scripts are always stored server-side. That means you will never have to worry about keeping scripts up-to date with your friends! This makes MineTweaker a great modpack and server admin tool - it makes it possible to wrap a modpack with a certain set of mods and have different servers use MineTweaker to alter the details according to the preferences of the server owners.

Likewise, scripts can be bundled with worlds, making it possible to make modifications available to specific worlds only - handy if you want to do some playtesting in a certain world. Also handy for mapmakers wanting to have specific behavior programmed with their map.

MineTweaker has two script directories:

The shared script directory: the scripts directory, directly inside your minecraft directory. Scripts stored in this directory will apply to all worlds hosted by that minecraft instance - including Single-player games. They will NOT apply when you join another server, as scripts are always loaded from the server.
The world-specific script directory: this directory is also called scripts, but is stored in the savegame directory (world/scripts if you are setting up a dedicated server)
Inside these directories, any file with the .zs extension is considered a MineTweaker script and will be ran automatically when a game is started. Any number of script files can be stored in these directories - they will all be executed, in no particular order.

Writing a first script
To get used to the scripting system in MineTweaker, we can create a very basic file. Create a file hello.zs in your .minecraft/scripts directory (create it if it doesn't already exist) with the following line:

print("Hello world!");
Now open Minecraft and start a new game (or open an existing one).

The script should have run now. Now where did MineTweaker print its text?

The Minetweaker log
When you put a print statement in MineTweaker, it will output to the minetweaker.log file in your minecraft directory. Open this log and you should see the output:

INFO: Hello world!
Cool, huh? Although printing a test string to the log is not so interesting in and by itself, it is good to know that any errors and warnings will print to this file. Additionally, many in-game commands output to this file since the in-game console simply cannot hold much data.

Do you still have the game open? Try the following command in the in-game console:

/minetweaker names
This command dumps a list of each and every item in the game to the minetweaker log. If you have a lot of mods installed, expect a huge list. But since it outputs to the log, you can open the file with your favorite editor and search for a specific item name. (still stuck with Notepad? Try notepad++!)

Reloading
While developing, there is no need to restart minecraft for every change you are making. You can reload scripts in-game.

Change your printed text to something else, such as:

print("Hello guys!");
Now, in-game, enter the command /minetweaker reload.

This will append the following line in the MineTweaker log:

INFO: Hello guys!
MineTweaker reloaded your scripts from disk and executed it again. Handy! There is more to script reloading, as it will not only reload the script but also any recipes that have been changed. More about that in the next tutorial.

Comments
To document your scripts, MineTweaker supports 3 styles of comments:

// this is a single line comment
# this is a single line comment
/* this is
a
multiline comment */
Use these to make your scripts more understandable!

Navigation menu
Log inPageDiscussionReadView sourceView history

Search
Go
Main page
Recent changes
Random page
Help
Tools
What links here
Related changes
Special pages
Printable version
Permanent link
Page information
This page was last modified on 21 April 2015, at 07:14.
This page has been accessed 50,951 times.
Privacy policyAbout MineTweaker 3DisclaimersPowered by MediaWiki

Tutorial:Basic Recipes
Contents [hide] 
1 Using MineTweaker RecipeMaker
2 Using recipe notation
3 Basic Recipes
3.1 Other kinds of recipes
3.2 Specific recipe removal
3.3 Subitems and damage values
3.4 Reloading and recipes
3.5 Using variables
Using MineTweaker RecipeMaker
If you want to create or remove recipes without having to code, you can also check out this nice mod by DoubleDoorDevelopment: http://minecraft.curseforge.com/mc-mods/226294-minetweaker-recipemaker

Using recipe notation
The most basic modifications you can perform in MineTweaker are recipe addition and removal. There is no visual editor, only a scripting language, so you have to understand how to write your recipes as text.

In order to define its functionality, you have to call functions. An example function is print, which you have seen before, and which takes a single argument:

print("My text");
This was easy. A more useful function, for instance, is the function to add a shaped recipe:

recipes.addShaped(recipe output, recipe contents);
This line essentially means "call the addShaped function on the recipes object". The recipes object is a special object that is available from anywhere in your code and contains all the functions related to adding and removing crafting recipes. Note that only crafting recipes are managed by the recipes object - furnace recipes, for instance, are managed by the furnace object (which you will learn about in a later tutorial) and mods machines have yet different methods to manage recipes.

Now, how do we call the addShaped function with proper arguments? We need to tell it what the output should be and what the recipe should be like.

Let's take, for instance, the recipe for iron leggings, which is this one:

Recipe leggings iron.png

The MineTweaker notation for this recipe is the following one:

[[<minecraft:iron_ingot>, <minecraft:iron_ingot>, <minecraft:iron_ingot>],
 [<minecraft:iron_ingot>, null, <minecraft:iron_ingot>],
 [<minecraft:iron_ingot>, null, <minecraft:iron_ingot>]]
This may look cryptic if you haven't been programming before, but the principle is quite simple. You can visualize the recipe as follows:

Recipe leggings iron brackets.png

Each item in minetweaker has its own name - surrounded by the angled brackets to tell it "retrieve me the item with this name". This angled bracket notation will be used in many places - from retrieving items to ore dictionary entries to liquid names. The item name for the iron ingot is <minecraft:iron_ingot> and iron leggings is <minecraft:iron_leggings>.

What about the empty spots? You cannot just skip the entries - you have to put something to indicate "this is empty". MineTweaker has a special word for such objects, and it's "null".

We can thus define the leggings recipe with the following code:

recipes.addShaped(<minecraft:iron_leggings>,
 [[<minecraft:iron_ingot>, <minecraft:iron_ingot>, <minecraft:iron_ingot>],
  [<minecraft:iron_ingot>, null, <minecraft:iron_ingot>],
  [<minecraft:iron_ingot>, null, <minecraft:iron_ingot>]]);
Or you can split the line differently for readability, since MineTweaker doesn't care how you split your code into lines. You could also retrieve the iron ingot once, assign it to a variable and then reuse it, as will be described at the end of this tutorial.

Basic Recipes
There is no visual editor, so you have to understand how to write your recipes as text.

As a little introduction, let's consider the recipe for sticks. In vanilla minecraft, it takes 2 wood planks to make 4 sticks, and they have to put above each other. But what if we want to change that? What if, say, we find it more logical to put the two wood block diagonally instead? (this stick is diagonal, right?)

Modifying the sticks recipe is wonderfully easy. Make a script with the following contents:

recipes.remove(<minecraft:stick>);
recipes.addShaped(<minecraft:stick> * 4, [[<minecraft:planks>, null], [null, <minecraft:planks>]]);
Open a new game (or reload scripts, if you are already in a game). Now take 2 oak wood planks and test your recipe.

It works? Great! But now you may have noticed a flaw in the recipe: if you put birch or spruce wood, it doesn't work!

Why doesn't it work? The "planks" item has subitems that are distinguished by not only the item name, but also by its meta value. By default, if you retrieve an item with the bracket syntax, MineTweaker assumes you want the item with meta value 0. And that's what it returned - the "oak planks" item. But we want an ingredient which essentially means "any kind of wood".

Luckily, this is easy to fix. When using the bracket syntax, besides the name, we can also define a meta value. For instance, <minecraft:planks:1> refers to spruce wood. We can also use the wildcard (*) to get an item meaning "any meta value is good": <minecraft:planks:*>.

Thus, change your recipe and reload:

recipes.remove(<minecraft:stick>);
recipes.addShaped(<minecraft:stick> * 4, [[<minecraft:planks:*>, null], [null, <minecraft:planks:*>]]);
Fixed! Of course, you should use the ore dictionary entry for planks, which would be even better as it would be compatible with mod-added planks :)

If need the full name of an item, you can hold it in your hand and use the /minetweaker hand command. It will print the name and copy it to the clipboard, so you can just paste it directly in your script.

Other kinds of recipes
Shaped recipes are recipes where the ingredients must be placed in the right shape in order for it to work. Not all Minecraft recipes are shaped - some don't care about the shape. MineTweaker supports those with the addShapeless function:

recipes.addShapeless(<minecraft:stick> * 4, [<ore:plankWood>, <ore:plankWood>]);
Now it doesn't matter how you place your planks - you can always craft sticks. Note that in this example, though, you can no longer craft the wooden pressure plate.

Since 3.0.7, it's also possible to register mirrored recipes. Continuing with our sticks (make sure to remove the previous recipes first):

recipes.addShapedMirrored(<minecraft:stick> * 4, [[<minecraft:planks:*>, null], [null, <minecraft:planks:*>]]);
Now it doesn't matter if you mirror the recipe - it still works!

Specific recipe removal
So far we decided that we would be removing all recipes for the stick. In vanilla minecraft, there is also only one, so that's not an issue. But what if we want to be more specific? Often there are multiple recipes for the same item, and we may want to remove one yet keep the others.

It is possible to be more specific in that case:

recipes.removeShaped(<minecraft:stick>, [[<minecraft:planks:*>], [<minecraft:planks:*>]]);
This will remove only a single recipe - even if there are other recipes.

It is also possible to remove all recipes that are shaped, or all recipes that are shapeless, by simply calling:

recipes.removeShaped(<minecraft:stick>);
recipes.removeShapeless(<minecraft:stick>);
Also, wildcard patterns can be used to indicate that any kind of item would match for a certain position, as long as it's not empty:

recipes.removeShaped(<minecraft:stick>, [[<*>], [<*>]]);
Likewise, when removing shapeless recipes, it is possible to only specify one or more ingredients of the shapeless recipe and then tell minetweaker that the remainder of the recipe may contain anything:

recipes.removeShapeless(<minecraft:wool:*>, [<minecraft:wool>]); // removes all wool coloring recipes
Subitems and damage values
Quite often, items have multiple subitems. A very well-known example are coal and charcoal. Both have the same ID (minecraft:coal) but have a different meta value.

When loading an item, you can specify the meta value for the subitem:

var coal = <minecraft:coal:0>; // same as <minecraft:coal>
var charcoal = <minecraft:coal:1>;
When the subitem is not specified, :0 is filled in for the subitem.

If you want a recipe to match any subitem, you can use the wildcard syntax:

var anyCoal = <minecraft:coal:*>;

Many kinds of items can also be damaged. When using such item as ingredient for a recipe, by default, no damage is allowed. For instance:

var pick = <minecraft:stone_pickaxe>;
var iron = <minecraft:iron_ingot>;
// upgrade pick recipe :)
recipes.addRecipe(<minecraft:iron_pickaxe>, [[iron, iron, iron], [null, pick, null]]);
In the recipe above, a damaged pickaxe would not be accepted. This can be changed easily with the .anyDamage() modifier:

var pick = <minecraft:stone_pickaxe>.anyDamage();
var iron = <minecraft:iron_ingot>;
// upgrade pick recipe :)
recipes.addShaped(<minecraft:iron_pickaxe>, [[iron, iron, iron], [null, pick, null]]);
Reloading and recipes
When you reloaded the scripts, you may have noticed that if you reloaded a script, the recipe is not duplicated. Likewise, if a recipe addition is removed from the script and the script is reloaded, the recipe is effectively removed from the game even though there may be no statement explicitly requesting such removal.

MineTweaker remembers actions such as recipe addition and removal. When a script is reloaded (or loaded by joining a different server), MineTweaker will first undo all the recorded changes that were made before it executes the new script.

Many mod machines, however, do not support such recipe removal. In that case, the recipe will be "stuck" in the game until the entire game is reloaded. For a server, this means that the recipe will be stuck in the list until the server is restarted; for a client, it means that the recipe will be shown and acted upon as if it existed, though when a crafting attempt is made, actual crafting would fail. There is no fix to such behavior; it is up to the respective mod authors to provide a sufficient API to ensure that recipe removal is possible.

Using variables
Do you find yourself looking up the same item over and over again using the bracket syntax? It may be handy to remember the value for later; which can be done with the val and var statements:

val stick = <minecraft:stick>;
val planks = <minecraft:planks:*>;
recipes.remove(stick);
recipes.addShaped(stick * 4, [[planks, null], [null, planks]]);
In this example, var can be used to:

var stick = <minecraft:stick>;
var planks = <minecraft:planks:*>;
recipes.remove(stick);
recipes.addShaped(stick * 4, [[planks, null], [null, planks]]);
The difference between var and val is that a val cannot be modified after it is declared:

val stick = <minecraft:stick>;
stick = <minecraft:bread>; // fails
Navigation menu
Log inPageDiscussionReadView sourceView history

Search
Go
Main page
Recent changes
Random page
Help
Tools
What links here
Related changes
Special pages
Printable version
Permanent link
Page information
This page was last modified on 21 April 2015, at 07:16.
This page has been accessed 67,220 times.
Privacy policyAbout MineTweaker 3DisclaimersPowered by MediaWiki

Tutorial:Ore Dictionary
Contents [hide] 
1 Ore Dictionary
1.1 Modifying the ore dictionary
1.2 Adding new ore dictionary entries
1.3 Merging and unifying two ore dictionary entries
1.4 Using ore entries in recipe removal
1.5 Iterating over the values in an oredict entry
Ore Dictionary
Now that we've gotten our feet wet (you did follow the previous tutorials, right?), let's try this recipe: (IC2 required)

val copper = <IC2:itemIngotCopper>;
val tin = <IC2:itemIngotTin>;
val iron = <minecraft:iron_ingot>;

// actually IC2 uses bronze and not copper. but that doesn't matter since this is just for demonstration
recipes.addShaped(<IC2:itemPartAlloy>, [[iron, iron, iron], [copper, copper, copper], [tin, tin, tin]]);
If you try the recipe, it's going to work... but not if you use the copper ingots from, say, Thermal Expansion or Tinkers Construct! The items are different!

Luckily, this issue exists for quite a while already and has been solved through the use of the ore dictionary. In essence, the ore dictionary groups items by their meaning and allows mods to add their own items to the ore dictionary. For instance, the copper ore dictionary is named <ore:ingotCopper>.

These ore dictionary entries can be used in recipes easily:

val copper = <ore:ingotCopper>;
val tin = <ore:ingotTin>;
val iron = <ore:ingotIron>;

// actually IC2 uses bronze and not copper. but that doesn't matter since this is just for demonstration
recipes.addShaped(<IC2:itemPartAlloy>, [[iron, iron, iron], [copper, copper, copper], [tin, tin, tin]]);
... and that should fix it! Try installing a few mods that add copper ore, and all of their ingots should now be compatible.

The ore dictionary is used for more than just ores and ingots. Many ingredients have their own ore dictionary entry, allowing multiple substitutes for a specific ingredient.

Modifying the ore dictionary
Not satisfied with the contents that mods put into the ore dictionary? Did some mod forget to add an item to the proper entry? Or do you believe a certain ingredient substitute makes recicpes too cheap? MineTweaker makes it possible to alter the contents of the ore dictionary.

Once you retrieve an ore dictionary entry, you can modify it by adding or removing ores. Let's modify our script a bit:

val copper = <ore:ingotCopper>;
val tin = <ore:ingotTin>;
val iron = <ore:ingotIron>;
iron.add(<minecraft:coal>);

// actually IC2 uses bronze and not copper. but that doesn't matter since this is just for demonstration
recipes.addShaped(<IC2:itemPartAlloy>, [[iron, iron, iron], [copper, copper, copper], [tin, tin, tin]]);
If you reload the scripts and check the recipe, you will notice that iron can now be substituted with coal.

Likewise, you could even remove iron from its entry:

val copper = <ore:ingotCopper>;
val tin = <ore:ingotTin>;
val iron = <ore:ingotIron>;
iron.add(<minecraft:coal>);
iron.remove(<minecraft:iron_ingot>);

// actually IC2 uses bronze and not copper. but that doesn't matter since this is just for demonstration
recipes.addShaped(<IC2:itemPartAlloy>, [[iron, iron, iron], [copper, copper, copper], [tin, tin, tin]]);
Now this ore dictionary modification may not be very useful, but it does illustrate how the ore dictionary can be modified easily.

If you ever come across a mod dictionary entry of which you believe they should both actually be the same, it's now possible to mirror ore dictionary entries:

<ore:ingotIron>.mirror(<ore:ingotTin>);
Now doing that will link iron to be the same as tin. Iron will then essentially be overridden by tin, and any changes made to tin will automatically reflect in iron.

Adding new ore dictionary entries
When you use an ore dictionary entry, it doesn't matter if it already exists or not. If you use one that doesn't exist, it will simply return an empty one. Thus, all you need is to reference the ore dictionary you want to make as if it already exists, and add items to it:

val myEntry = <ore:myOwnEntry>;
myEntry.add(<minecraft:coal>);
myEntry.add(<minecraft:iron_ingot>);
Merging and unifying two ore dictionary entries
When playing with many mods, you'll find them reimplementing similar ores, similar items and yet register them in different ore dictionaries. Now you can unify the ore dictionary entries to a certain extent. Let's say multiple mods add salt ores to the game, and have chosen to register them under different names. Now, you ensure that the two dictionaries contain the exact same items, by executing these two commands.

<ore:dustSalt>.addAll(<ore:foodSalt>);
<ore:foodSalt>.mirror(<ore:dustSalt>); 
Now each mod can utilise the others' items in its own recipes. This allows easier cross-mod interactions in recipes (no more hoarding of items), and a fluid gameplay overall.

Using ore entries in recipe removal
Ore dictionary entries can also be used to remove recipes containing ore entries, or as wildcard meaning "you can match any item in the ore entry". Note that an ore dictionary entry with a single item is considered equivalent to the item. (this in contrast with MineTweaker 2)

Iterating over the values in an oredict entry
Sometimes there is need to perform a certain action for every item in the ore dictionary. This is possible with a simple for loop:

for item in <ore:ingotCopper>.items {
    doSomething();
}
//Furnace
furnace.remove(<minecraft:gold_ingot>);
// alternatively, you can specify the input item
furnace.remove(<*>, <minecraft:iron_ore>);
furnace.addRecipe(<minecraft:coal:0>, <minecraft:coal:1>);
// or, if you want to generate 0.5 XP by doing so
furnace.addRecipe(<minecraft:coal:0>, <minecraft:coal:1>, 0.5);
furnace.setFuel(<minecraft:rotten_flesh>, 100);

//Advanced Recipes
val stick = <minecraft:stick>;
val pick = <minecraft:stone_pickaxe>;
val damagedPick = pick.withDamage(10);
val stickedPick = pick.withTag({display: {Name: "Sticked pick", Lore: ["This pick", "Has been sticked"]}});

recipes.addShaped(damagedPick, [[pick, stick]]);
recipes.addShaped(stickedPick, [[pick, stick], [stick, stick]]);

val stick = <minecraft:stick>;
val pick = <minecraft:stone_pickaxe>;
val damagedPick = pick.withDamage(10);
val stickedPick = pick.withTag({display: {Name: "Sticked pick", Lore: ["This pick", "Has been sticked"]}});

recipes.addShaped(damagedPick, [[pick, stick]]);
recipes.addShaped(stickedPick, [[pick, stick], [stick, stick]]);

val stonedPick = pick.withTag({display: {Name: "Stoned pick", Lore: ["This pick", "Has been experimenting too much"]}});
val onlyStickedPick = pick.onlyWithTag({display: {Name: "Sticked pick"}});
val cobble = <minecraft:cobblestone>;
recipes.addShaped(stonedPick, [[onlyStickedPick, cobble], [cobble, cobble]]);
What about the lore part in our sticked pick? Since your condition only contains the name, the lore part is ignored - when setting a condition on the data tag, MineTweaker only cares about the contents that you specified and ignores everything else.

Note the difference between withTag and onlyWithTag. withTag is for an output and is the exact tag that will be output. onlyWithTag is for input and sets a condition. Applying withTag on an input has no effect on the recipe.

Other conditions exist too:

myItem.onlyDamaged(); // only accepts damaged items
myItem.onlyDamageAtLeast(15); // only accepts items with a damage of at least 15
myItem.onlyDamageAtMost(100); // only accepts items with a damage of at most 100
myItem.onlyDamageBetween(15, 100); // only accepts items with a damage between 15 and 100
Multiple conditions can be added to a single ingredient, too:

myItem.onlyDamaged().onlyWithTag({display: {Name: "Sticked pick"}});
Output reuse and transformations
Since MineTweaker 3.0.2, it is now possible to reuse items, return empty buckets to the crafting grid (or whatever item you want) or damage items upon crafting.

We could for instance make a recipe to get more sticks out of wood by using an axe:

recipes.addShapeless(<minecraft:stick> * 3, [<minecraft:stone_axe>, <ore:woodPlanks>]);
Nice. But the stone axe gets consumed, and that is sort of annoying. We can fix this with the reuse modifier:

recipes.addShapeless(<minecraft:stick> * 3, [<minecraft:stone_axe>.reuse(), <ore:plankWood>]);
Great! We can reuse the axe. Now what if we also wanted the axe to be damaged when you use it?

recipes.addShapeless(<minecraft:stick> * 3, [<minecraft:stone_axe>.transformDamage(), <ore:plankWood>]);
We can also deal more than 1 damage upon crafting:

recipes.addShapeless(<minecraft:stick> * 3, [<minecraft:stone_axe>.transformDamage(4), <ore:plankWood>]);
Imagine we'd want to make a recipe to turn dirt into grass by combining dirt, a water bucket and wheat. We could make this recipe:

recipes.addShapeless(<minecraft:grass>, [<minecraft:dirt>, <minecraft:water_bucket>, <minecraft:wheat>]);
However, crafting this will consume the bucket. We can tell MineTweaker to return the empty bucket afterwards:

recipes.addShaped(<minecraft:grass>, [[
	<minecraft:dirt>,
	<minecraft:water_bucket>.transformReplace(<minecraft:bucket>),
	<minecraft:wheat>
]]);
Now, crafting a grass block will return the empty crafting bucket in the crafting grid.

Sometimes mods define their own behavior when you use their items while crafting. Likewise, Minecraft will return you an empty bucket when you use it in a crafting recipe. If you don't want that, you can tell the item to not return anything at all:

recipes.addShaped(<minecraft:grass>, [[
	<minecraft:dirt>,
	<minecraft:water_bucket>.noReturn(),
	<minecraft:wheat>
]]);
If you want to give something back, but not in the crafting inventory, you can also use giveBack. GiveBack can be used without arguments, in which case it will return the original item, or it can be used with an item, in which case that item will be given back into the player inventory:

recipes.addShaped(<minecraft:grass>, [[
	<minecraft:dirt>,
	<minecraft:water_bucket>.giveBack(<minecraft:iron_ore> * 3),
	<minecraft:wheat>
]]);
GiveBack will usually also have the side-effect of suppressing mod item return behavior. It may thus be a handy alternative to the transformReplace modifier in those cases.

Function recipes
When adding a recipe, you may also supply an additional argument, which is a custom function. This function can programmatically determine the output of your recipe.

To demonstrate how this works, let's make a recipe that repairs a stone pickaxe when you craft it with cobblestone. The output of our recipe depends on the pickaxe that is provided (its damage), thus a regular recipe won't work in this case.

Let's start by adding the function to it:

recipes.addShapeless(<minecraft:stone_pickaxe>, [<minecraft:stone_pickaxe>, <minecraft:cobblestone>], function(output, inputs, crafting) {
  // to be implemented
}
Now we need to look at the value of the pickaxe. In order to retrieve the actual values of the inputs, we need to mark them with a name, and MineTweaker will store it in the inputs list:

recipes.addShapeless(<minecraft:stone_pickaxe>, [<minecraft:stone_pickaxe>.marked("pick"), <minecraft:cobblestone>], function(output, inputs, crafting) {
  // to be implemented. inputs.pick now contains the pickaxe used as input
}
Then it's just a matter of writing the code to fix the pickaxe:

recipes.addShapeless(<minecraft:stone_pickaxe>, [<minecraft:stone_pickaxe>.anyDamage().marked("pick"), <minecraft:cobblestone>], function(output, inputs, crafting) {
  // the max is there to make sure that the damage doesn't go negative
  // fixes 25 damage per cobblestone
  return inputs.pick.withDamage(max(0, inputs.pick.damage - 25));
});
More will come to function recipes later!

Navigation menu
Log inPageDiscussionReadView sourceView history

Search
Go
Main page
Recent changes
Random page
Help
Tools
What links here
Related changes
Special pages
Printable version
Permanent link
Page information
This page was last modified on 5 September 2015, at 18:37.
This page has been accessed 28,586 times.
Privacy policyAbout MineTweaker 3DisclaimersPowered by MediaWiki

Tutorial:Item Renaming
Not happy with an item name? Want to correct a type typo made by the mod author? Did some translation go missing?

Although a resource pack can fix that, it may be less cumbersome to use MineTweaker instead:

print(<minecraft:chest>.displayName); // prints the original name
<minecraft:chest>.displayName = "Storage Box";
That's all it takes!

Note that there exist some mod items with broken internal names. These cannot have their names modified with this method. Neither can they be modified through translations files, and as such these mod items should be considered bugged. If NEI is installed, you can still use the NEI.overrideName function, which will change the name in most places.


Unlike most script types, renaming requires a client restart, and not simply a script reload.

Navigation menu
Log inPageDiscussionReadView sourceView history

Search
Go
Main page
Recent changes
Random page
Help
Tools
What links here
Related changes
Special pages
Printable version
Permanent link
Page information
This page was last modified on 22 February 2016, at 19:04.
This page has been accessed 11,680 times.
Privacy policyAbout MineTweaker 3DisclaimersPowered by MediaWiki

Tutorial:Tooltips
Since MineTweaker 3.0.8, you can now add tooltips to items.

Adding tooltips can be done directly on any kind of ingredient:

<ore:plankWood>.addTooltip("These are wood planks");
<minecraft:stick>.addTooltip("These are sticks");
Two kinds of tooltips are available: regular tooltips and tooltips that only appear when the shift key is being pressed:

<minecraft:stick>.addShiftTooltip("Only appears with shift");
Markup
Tooltips can be colored and styled using the format functions:

<minecraft:stick>.addTooltip(format.green("This is green text"));
The following formatting functions are available:

format.black
format.darkBlue
format.darkGreen
format.darkAqua
format.darkRed
format.darkPurple
format.gold
format.gray
format.darkGray
format.blue
format.green
format.aqua
format.red
format.lightPurple
format.yellow
format.white

format.obfuscated
format.bold
format.strikethrough
format.underline
format.italic
Strings (and formatted strings) can be concatenated and nested easily:

<minecraft:stick>.addTooltip(format.green(format.italic("This is a stick") + " with " + format.strikethrough("text")) + " in multiple styles");
Be careful to match the brackets properly!

Navigation menu
Log inPageDiscussionReadView sourceView history

Search
Go
Main page
Recent changes
Random page
Help
Tools
What links here
Related changes
Special pages
Printable version
Permanent link
Page information
This page was last modified on 31 August 2014, at 18:44.
This page has been accessed 9,143 times.
Privacy policyAbout MineTweaker 3DisclaimersPowered by MediaWiki

Tutorial:Control Structures
The MineTweaker scripting engine (ZenScript) is still under heavy development. Control structures are currently only partially implemented, but it is already possible to use looping structures to aid you in your development.

When we make use of looping structures, we generally have to store some variables first. When storing items or ingredients into variables, you never had to worry about item types. Likewise, when you use arrays or dictionaries in recipes or tag values, you could just provide the right syntax and everything worked.

However, MineTweaker is *strongly typed*. As long as it can infer the type from your expression, you don't have to provide any typing information, but when you declare such a thing as an array it won't work anymore. This would fail:

var myItems = [<minecraft:stick>, <minecraft:stone>];
The problem is that MineTweaker doesn't know your array type. It did in all the examples given before, since it could infer the array type from the function you were calling, but when you assign it to a variable it can't do that since it doesn't know your type yet. To fix this, you need to cast the array to a specific type, as such:

import minetweaker.item.IItemStack;

var myItems = [<minecraft:stick>, <minecraft:stone>] as IItemStack[];
IItemStack is the type that you get when you resolve an item variable such as <minecraft:stick>. IItemStack denotes a specific object and can be used either as a crafting ingredient or as crafting output, as you very likely already did.

Its friends is IIngredient, which is more general than an item. Ore dictionary entries, for instance, are ingredients. They cannot be used as output, but they can be used as input for crafting. Additionally, if you add transformations or conditions to an IItemStack, it will become an IIngredient:

import minetweaker.item.IIngredient;

var myIngredients = [<ore:plankWood>, <minecraft:stick>.onlyWithTag({display:{Name: "Something"}})] as IIngredient[];
var myIngredients2 = [<minecraft:stick>, <ore:plankWood>] as IIngredient[]; // will work since an IItemStack can be casted to an IIngredient
When you define arrays of items, you can use looping operators on them to make your scripts shorter. For instance, let's say we want default log to wood recipes to have low yield yet improve it when crafting it with axes, and have the type of axe determine the amount of planks we have:

import minetweaker.item.IItemStack;

var myLogs = [<minecraft:log:0>, <minecraft:log:1>, <minecraft:log:2>, <minecraft:log:3>, <minecraft:log:4>, <minecraft:log:5>] as IItemStack[];
var myPlanks = [<minecraft:planks:0>, <minecraft:planks:1>, <minecraft:planks:2>, <minecraft:planks:3>, <minecraft:planks:4>, <minecraft:planks:5>] as IItemStack[];

var stoneAxe = <minecraft:stone_axe>.anyDamage().transformDamage();
var ironAxe = <minecraft:iron_axe>.anyDamage().transformDamage();
var goldenAxe = <minecraft:golden_axe>.anyDamage().transformDamage();
var diamondAxe = <minecraft:diamond_axe>.anyDamage().transformDamage();

for i, log in myLogs {
    var plank = myPlanks[i];
    
    recipes.removeShapeless(plank, [log]);
    recipes.addShapeless(plank * 2, [log]);
    recipes.addShapeless(plank * 3, [log, stoneAxe]);
    recipes.addShapeless(plank * 4, [log, ironAxe]);
    recipes.addShapeless(plank * 5, [log, goldenAxe]);
    recipes.addShapeless(plank * 6, [log, diamondAxe]);
}
Now you can put all of your mod-added planks into the array, as well as their logs, and have the for loop do the heavy lifting for you!

Sometimes you may find the need to assign NBT tags inside a for loop. You can define an NBT value in a variable outside the loop, but only when you cast it to IData. IData is the datatype for an NBT tag. Expanding our former example a little bit:

import minetweaker.data.IData;
import minetweaker.item.IItemStack;

var myData = {display: {Name: "Axed plank"}} as IData;
var myLogs = [<minecraft:log:0>, <minecraft:log:1>, <minecraft:log:2>, <minecraft:log:3>, <minecraft:log:4>, <minecraft:log:5>] as IItemStack[];
var myPlanks = [<minecraft:planks:0>, <minecraft:planks:1>, <minecraft:planks:2>, <minecraft:planks:3>, <minecraft:planks:4>,<minecraft:planks:5>] as IItemStack[]; 
var stoneAxe = <minecraft:stone_axe>.anyDamage().transformDamage();
var ironAxe = <minecraft:iron_axe>.anyDamage().transformDamage();
var goldenAxe = <minecraft:golden_axe>.anyDamage().transformDamage();
var diamondAxe = <minecraft:diamond_axe>.anyDamage().transformDamage();

for i, log in myLogs {
    var plank = myPlanks[i].withTag(myData);
    
    recipes.removeShapeless(plank, [log]);
    recipes.addShapeless(plank * 2, [log]);
    recipes.addShapeless(plank * 3, [log, stoneAxe]);
    recipes.addShapeless(plank * 4, [log, ironAxe]);
    recipes.addShapeless(plank * 5, [log, goldenAxe]);
    recipes.addShapeless(plank * 6, [log, diamondAxe]);
}
Navigation menu
Log inPageDiscussionReadView sourceView history

Search
Go
Main page
Recent changes
Random page
Help
Tools
What links here
Related changes
Special pages
Printable version
Permanent link
Page information
This page was last modified on 2 September 2014, at 20:51.
This page has been accessed 11,541 times.
Privacy policyAbout MineTweaker 3DisclaimersPowered by MediaWiki

Tutorial:Localization
Since MineTweaker 3.0.8, it is possible to change localization strings.

Two variants of the function exist - one that sets the translation no matter the current language, and one that overrides a translation but only when the given language matches the current language:

// Set translation but only if language is en_US
game.setLocalization("en_US", "nei.inventory.prev", "Past");

//KEY, TEXT - You will want to use this one most of the time, it overrides no matter the language
game.setLocalization("nei.inventory.next", "Future");
To find localizations, check the localization files in the assets of Minecraft or the mods you want to alter.

Navigation menu
Log inPageDiscussionReadView sourceView history

Search
Go
Main page
Recent changes
Random page
Help
Tools
What links here
Related changes
Special pages
Printable version
Permanent link
Page information
This page was last modified on 5 September 2015, at 18:41.
This page has been accessed 7,936 times.
Privacy policyAbout MineTweaker 3DisclaimersPowered by MediaWiki
//modtweaker

ModTweaker
ModTweaker logo.png

ModTweaker is an addon for MineTweaker 3. Minetweaker lets you adjust recipes, remove them entirely, or add new recipes. While it has decent mod support, there are many mods that use custom crafting handlers that are not supported natively. ModTweaker plans to provide additional support for as many of these mods over time as possible.

Contents [hide] 
1 Download
2 General Usage
3 Difference between IItemStack and IIngredient
4 Mod Support
4.1 Currently Supported Mods
4.2 Mods for which Support is Planned
4.3 Mods Suggested for Support
4.4 Mods that Will NOT be Supported
4.5 Older Version Wiki
Download
You can find ModTweaker on curseforge: ModTweaker Download

General Usage
In general, for all of the supported mods, you can either import them or call them directly.

Throughout the tutorial examples, I will be using the latter just to keep everything concise.

Example with the Botania Apothecary recipes:

import mods.botania.Apothecary;

Apothecary.addRecipe(<minecraft:melon>, [<ore:petalLime>, <ore:petalRed>, <ore:petalRed>]);
or:

mods.botania.Apothecary.addRecipe(<minecraft:melon>, [<ore:petalLime>, <ore:petalRed>, <ore:petalRed>]);