Smithing Recipe Generator

Generate smithing transform recipes with cross-mod support

Overview

The SmithingRecipeGenerator is an abstract class that provides a powerful API for generating Minecraft smithing transform recipes. It supports cross-mod compatibility with automatic load conditions for both Fabric and NeoForge.

This class is located in net.more_rpg_classes.datagen.SmithingRecipeGenerator.

Class Definition

public abstract class SmithingRecipeGenerator implements DataProvider

Constructor

output · FabricDataOutput · required

The Fabric data output handler

modId · String · required

Your mod ID for recipe paths

public SmithingRecipeGenerator(FabricDataOutput output, String modId) {
    this.output = output;
    this.modId = modId;
}

Abstract Methods

generate

Implement this method to generate your recipes. This is where you call the recipe creation methods.

public abstract void generate();

Recipe Methods with Load Conditions

These methods create recipes that only load when specific mods are present.

createSmithingTransformRecipe

Creates a smithing transform recipe with Fabric and NeoForge load conditions.

name · String · required

Recipe name (without namespace)

base · Item · required

Base item that will be upgraded

template · Item | Identifier · required

Template item (use Identifier for items from unloaded mods)

addition · Item | Identifier · required

Addition/ingredient item (use Identifier for items from unloaded mods)

result · Item · required

Result item after transformation

requiredMod · String · required

Required mod ID (e.g., “armory_rpgs”)

public void createSmithingTransformRecipe(
    String name,
    Item base,
    Object template,
    Object addition,
    Item result,
    String requiredMod
)

Multiple Required Mods

Overload for multiple mod dependencies:

public void createSmithingTransformRecipe(
    String name,
    Item base,
    Object template,
    Object addition,
    Item result,
    String[] requiredMods
)

createArmorSetUpgrade

Automatically creates smithing recipes for all 4 armor pieces (head, chest, legs, feet).

recipeBaseName · String · required

Base name for the recipes (e.g., “bounty_hunter_from_deadeye”)

baseSet · Armor.Set · required

Base armor set to upgrade from

template · Item | Identifier · required

Template item for all 4 pieces

addition · Item | Identifier · required

Addition item for all 4 pieces

resultSet · Armor.Set · required

Result armor set after upgrade

requiredMod · String · required

Required mod ID

public void createArmorSetUpgrade(
    String recipeBaseName,
    Armor.Set baseSet,
    Object template,
    Object addition,
    Armor.Set resultSet,
    String requiredMod
)

This method automatically generates 4 recipes with suffixes: _head, _chest, _legs, _feet

Multiple Required Mods

Overload for multiple mod dependencies:

public void createArmorSetUpgrade(
    String recipeBaseName,
    Armor.Set baseSet,
    Object template,
    Object addition,
    Armor.Set resultSet,
    String[] requiredMods
)

Recipe Methods without Load Conditions

These methods create recipes for items that are always available (from your own mod).

createSimpleSmithingRecipe

Creates a smithing transform recipe without load conditions.

name · String · required

Recipe name

base · Item · required

Base item

template · Item | Identifier · required

Template item

addition · Item | Identifier · required

Addition item

result · Item · required

Result item

public void createSimpleSmithingRecipe(
    String name,
    Item base,
    Object template,
    Object addition,
    Item result
)

createSimpleArmorSetUpgrade

Creates recipes for all 4 armor pieces without load conditions.

public void createSimpleArmorSetUpgrade(
    String recipeBaseName,
    Armor.Set baseSet,
    Object template,
    Object addition,
    Armor.Set resultSet
)

Usage Examples

Basic Recipe with Load Condition

public class MySmithingRecipes extends SmithingRecipeGenerator {
    public MySmithingRecipes(FabricDataOutput output) {
        super(output, "mymod");
    }

    @Override
    public void generate() {
        // Single recipe with cross-mod support
        createSmithingTransformRecipe(
            "upgrade_sword",
            Items.IRON_SWORD,
            Identifier.of("armory_rpgs", "upgrade_template"),
            Identifier.of("armory_rpgs", "rare_gem"),
            MyItems.LEGENDARY_SWORD,
            "armory_rpgs"
        );
    }
}

Armor Set Upgrade

@Override
public void generate() {
    // Upgrades all 4 armor pieces at once
    createArmorSetUpgrade(
        "bounty_hunter_upgrade",
        DeadeyeArmor.SET,
        Identifier.of("armory_rpgs", "class_token"),
        Identifier.of("armory_rpgs", "bounty_hunter_essence"),
        BountyHunterArmor.SET,
        "armory_rpgs"
    );
}

Multiple Mod Dependencies

@Override
public void generate() {
    createSmithingTransformRecipe(
        "special_upgrade",
        MyItems.BASE_ARMOR,
        Identifier.of("mod_a", "template"),
        Identifier.of("mod_b", "ingredient"),
        MyItems.RESULT_ARMOR,
        new String[]{"mod_a", "mod_b"}
    );
}

Simple Recipe (No Load Conditions)

@Override
public void generate() {
    // For items always available in your mod
    createSimpleSmithingRecipe(
        "basic_upgrade",
        MyItems.BASIC_SWORD,
        Items.NETHERITE_UPGRADE_SMITHING_TEMPLATE,
        Items.NETHERITE_INGOT,
        MyItems.ENHANCED_SWORD
    );
}

Registering the Provider

public class MyDatagen implements DataGeneratorEntrypoint {
    @Override
    public void onInitializeDataGenerator(FabricDataGenerator fabricDataGenerator) {
        FabricDataGenerator.Pack pack = fabricDataGenerator.createPack();
        pack.addProvider(MySmithingRecipes::new);
    }
}

Generated JSON Structure

The generator creates recipes with the following structure:

{
  "fabric:load_conditions": [
    {
      "condition": "fabric:all_mods_loaded",
      "values": ["armory_rpgs"]
    }
  ],
  "neoforge:conditions": [
    {
      "type": "neoforge:mod_loaded",
      "modid": "armory_rpgs"
    }
  ],
  "type": "minecraft:smithing_transform",
  "template": {
    "item": "armory_rpgs:upgrade_template"
  },
  "base": {
    "item": "minecraft:iron_sword"
  },
  "addition": {
    "item": "armory_rpgs:rare_gem"
  },
  "result": {
    "id": "mymod:legendary_sword",
    "count": 1
  }
}

Important Notes

When referencing items from other mods that may not be loaded, always use Identifier instead of Item. Using Item for unloaded mods will cause the item to resolve to minecraft:air and throw an error.

The createArmorSetUpgrade methods automatically extract the armor set name from the result set and append appropriate suffixes (_head, _chest, _legs, _feet) to recipe names.

Related APIs

Data Generation Helpers

Main data generation providers

Advancement Helpers

Create Spell Engine advancements