4.3 合成配方

上次更新：2026 年 1 月 6 日

简单回顾一下，在上一节，我们做了一个红宝石。目前来说，这个红宝石没有任何用途，你拿它是做不了任何事情的。我们可以考虑……用它来合成一些物品！这需要让它成为某个合成配方（Recipe） 的一部分。是的，本节我们来介绍一下如何实现新的合成配方。

工作台配方

有序配方

我们先想象一下用红宝石可以合成什么东西……比如，用它合成一把红宝石剑！当然我们还没有这样的物品，不过不要紧，我们可以先定义一把红宝石剑。

实验 4.3-1

利用上一节的知识，定义一把红宝石剑！

我们先定义红宝石剑的行为包部分，新建ruby_sword.item.json：

BP_test：行为包
- ……
- items：物品定义
  - test：以 test 作为物品的命名空间
    - ruby.item.json：红宝石的定义文件
    - ruby_sword.item.json：红宝石剑的定义文件

写入以下内容，正如我们上一节定义红宝石一样：

ruby_sword.item.json
{
    "format_version": "1.21.50",
    "minecraft:item": {
        "description": {
            "identifier": "test:ruby_sword",
            "menu_category": {
                "category": "equipment"
            }
        },
        "components": {
            "minecraft:icon": "ruby_sword"
        }
    }
}

ruby_sword_3

目前，我们还没有专门讲过那些组件的作用。然而读者如果拥有比较强大的自学能力的话，应该能写出这把剑的雏形来，至少伤害功能应该是没什么问题的。目前来说，我们先实现它基本的显示功能，而不着重考虑功能问题——功能问题就留到下一节去实现吧！

然后，我们来定义资源包部分：

RP_test：资源包
- ……
- texts：翻译文本
  - en_US.lang：英语（美国）翻译
  - zh_CN.lang：中文（中国）翻译
- textures：贴图
  - ……
  - items：物品贴图（将物品贴图放到 items 文件夹内是惯例）
    - ruby.png：红宝石贴图
    - ruby_sword.png：红宝石剑贴图
  - item_texture.json：物品贴图定义文件

对于红宝石剑贴图ruby_sword.png，你可以直接引用下面这张图：

顺便一提，我们是利用取色器取走了红宝石的一个颜色，然后在铁剑上直接使用颜色模式涂画画出来的——没有任何水准的做法，但至少在项目的前期，这么做是很有效的 >wO

ruby_sword_2

然后，改一下物品贴图的定义文件item_texture.json，加上一行红宝石剑贴图路径：

item_texture.json
{
    "texture_data": {
        "ruby": { "textures": "textures/items/ruby" },
        "ruby_sword": { "textures": "textures/items/ruby_sword" }
    }
}

ruby_sword_4

最后改一下语言文件en_US.lang和zh_CN.lang，各自加上对应翻译：

en_US.lang, zh_CN.lang
item.test:ruby_sword=Ruby Sword
item.test:ruby_sword=红宝石剑

ruby_sword_5

其实，可以看到，自定义物品的实现过程中，资源包的实现过程是高度重复的。在后续的自定义物品实现中，为了简化表述，除了必要情况之外，我们日后将只展示物品行为包的定义和物品的贴图，而剩下的过程就交给读者自己完成。

可以看到，目前这把剑和我们预期的差距还是不小的。先不要着急，我们后续会解决这个问题。至少我们得先有这个物品嘛 :)

ruby_sword_6

好，现在我们来着手实现红宝石剑的合成配方！读者可能已经知道，对于工作台配方，有有序配方（Shaped Recipe） 和无序配方（Shapeless Recipe） 之分。所谓有序配方，是指你必须使用这种配方的摆放方式，不能使用其他的摆放方式，比如镐子永远都是：

M M M
  S
  S

其中M代表对应材料，比如钻石、铁锭等，而S代表木棍。使用

    M
S S M
    M

就得不到任何东西，乱放就更得不到任何东西。而无序配方就和有序配方不同，只要有所需材料即可合成，例如打火石：

I S

其中I代表铁锭，而S代表燧石。无论如何摆放，你都能得到一个打火石。包括混凝土粉末，也是同理的。显然，剑是属于有序配方一类的，因为你肯定不希望这样乱放也能得到一把剑：

R
  S  
    R

其中R代表红宝石，而S代表木棍。我们预期的组合应该是

R
R
S

为实现我们预期的组合，我们要在行为包下新建一个recipes文件夹，代表这是一个配方文件夹。然后，在下面创建一个ruby_sword.recipe.json，作为红宝石剑的配方文件。

和物品定义类似地，recipes下面也允许嵌套文件夹，我们可以在其中新建一些文件夹来进行分类，例如定义一个test命名空间文件夹。目前为止，读者的文件应该是如下图所示的：

BP_test：行为包
- ……
- recipes：物品定义
  - test：以 test 作为物品的命名空间
    - ruby_sword.recipe.json：红宝石剑的配方文件

我们打开这个文件，输入以下内容：

ruby_sword.recipe.json
{
    "format_version": "1.21.0",
    "minecraft:recipe_shaped": {
        "description": {
            "identifier": "test:ruby_sword"
        },
        "tags": [ "crafting_table" ],
        "key": {
            "R": { "item": "test:ruby" },
            "S": { "item": "minecraft:stick" }
        },
        "pattern": [
            "R",
            "R",
            "S"
        ],
        "unlock": [
            { "item": "test:ruby" }
        ],
        "result": { "item": "test:ruby_sword" }
    }
}

它的效果如下图所示：

recipe_shaped_1

有了上一节定义物品的经验，这里对于读者来说也会有一定的亲切感。我们来逐行解析：

首先，我们在第 2 行定义了这个配方表的格式版本。
```
"format_version": "1.21.0"
```
现在而言，我们可以定义为高版本（例如1.21.0或1.21.50）。高版本的代价是必须要指定一个解锁条件，不过无伤大雅。
然后，在第 3 行，我们定义了这是一种有序配方。
```
"minecraft:recipe_shaped": {
    ...
}
```
和数驱物品定义的minecraft:item不同，这一段更需要明确定义——因为配方表有很多种，读者可能没有意识到，Minecraft 原版有足足 7 种配方！分别是：工作台的有序配方和无序配方、熔炉配方、酿造台的换容配方和混合配方、锻造台的升级配方和纹饰配方。对于不同的配方，下文所支持的 API 也是不一样的。我们这一节着重介绍工作台配方和熔炉配方，因为其他配方的限制比较多，读者可以通过我们给出的这篇配方表文档自学。
第 4~6 行，我们在description*定义了这个配方表的 ID。
```
"description": {
    "identifier": "test:ruby_sword"
}
```
对于配方相对简单的情况，我们习惯上就直接定义为要合成的物品的 ID，比如上文的test:ruby_sword；而复杂情况（比如蓝色染料），就需要区分不同的配方表 ID 了，习惯上是直接在配方表 ID 中给出合成途径。例如原版的蓝色染料，两个配方表的 ID 就分别为minecraft:blue_dye_from_cornflower和minecraft:blue_dye_from_lapis_lazuli，分别声明了从矢车菊和青金石合成的蓝色染料。
第 7 行，我们在tags*中定义了这个配方表可以用于哪些工作方块。
```
"tags": [ "crafting_table" ]
```
对于有序合成配方，毫无疑问就是工作台了。在其他类型的配方中，我们就可以用其他的工作方块。在后面的自定义方块中，我们将认识到自定义工作台也可以应用到这里。
第 8~16 行，我们在key和pattern中定义了这个配方表的排布方式。
```
"key": {
    "R": { "item": "test:ruby" },
    "S": { "item": "minecraft:stick" }
},
"pattern": [
    "R",
    "R",
    "S"
]
```
这一部分，就是有序配方的核心内容。我们在pattern中定义了配方表的摆放方式，看这段代码，是不是把R和S代入进去之后，就联想出了一把剑的形状？而R和S具体代指什么物品，我们就交给key来定义。看起来很简单对吧？

对于这一段，我们还有要说的。如果是那些需要带空位的合成配方呢？比如……钻石镐？我们来看看原版这一段是怎么定义的：
```
"pattern": [
    "XXX",
    " # ",
    " # "
],
"key": {
    "#": { "item": "minecraft:stick" },
    "X": { "item": "minecraft:diamond" }
}
```
无疑，pattern这个形状已经表明了一切——钻石镐的形状已经清楚地呈现在这里。需要关注的点是，对于空位我们是怎么处理的——加空格！是的，空位就用空格来处理。很简单吧？

对于一个不一定占满 3×3 格子的合成配方，比如面包，就让它占 1 行就好了：
```
"pattern": [
    "###"
],
"key": {
    "#": { "item": "minecraft:wheat" }
}
```
最后，有几个点需要注意：
1. 我们希望读者可以尽可能地采用规范化的写法，也就是在pattern中，2×2 的配方就每行 2 个字符，而 3×3 的配方就每行 3 个字符，举个例子，这么做：
```
"pattern": [
    "## ",
    " ##"
]
```
  而不要这么做：
```
"pattern": [
  "##",
  " ##"
]
```
  上下只有一个空格之差，虽然配方实际上没什么区别，然而这种写法终究容易出事，所以就不要吝惜那个空格啦~
2. 在key中是明显不能指定空格指代什么物品的，因为空格是空位，比如这样就不是一个良好的定义：
```
"key": {
    " ": { "item": "minecraft:wheat" }
}
```
  虽然没有实测过这样会不会出问题（大概率会出问题的），但英文和标点字符那么多，够我们用了。
3. 不要在配方表中定义每行超过 3 个字符，比如这样也不是良好的定义：
```
"pattern": [
    "####"
]
```
  多出去的字符，会被 Minecraft 自动忽视掉，没必要做这样的事情啊。
第 17~19 行，我们在unlock*中定义了这个配方表在什么情况下会解锁。例如，这里就是说，获得红宝石的时候解锁此配方。
```
"unlock": [
    { "item": "test:ruby" }
]
```
我们注意到unlock*是一个数组，这意味着它可以同时设定多个解锁条件。这些解锁条件在满足其中一个的时候，配方就会解锁，也就是这些条件是“或”的关系。例如，如果这么设定，就代表此配方在获得木棍或红宝石的时候解锁。
```
"unlock": [
    { "item": "test:ruby" },
    { "item": "minecraft:stick" }
]
```
配方解锁不仅在获得特定物品的时候解锁，也可以在其他特殊情况下解锁，这时候我们就要提供特殊的解锁条件。写法如下：
```
"unlock": [
    { "context": "AlwaysUnlocked" }
]
```
目前来说，配方表总共支持 3 个解锁条件：
1. AlwaysUnlocked：始终解锁此配方。原版将这个条件用于工作台，以告知玩家可以时刻使用工作台继续合成。我们也可以使用这个条件来完全解除配方解锁的限制。
2. PlayerInWater：玩家入水。原版将这个条件用于船。
3. PlayerHasManyItems：玩家物品栏超过 10 种物品。原版将这个条件用于箱子，以告知玩家可以将这么多物品放到箱子里做整理。
高版本的配方表中，有序配方、无序配方和熔炉配方必须指定解锁条件。如果你嫌麻烦，就直接AlwaysUnlocked吧。
最后，第 20 行，我们在result*中定义了这个配方表输出什么物品。
```
"result": { "item": "test:ruby_sword" }
```
例如，在上文，就输出为红宝石剑了。

这样，我们就将我们给出的配方表解析完了。故而，我们看到，有序配方表主要需要指定 ID、工作方块、原材料、配方表、结果和解锁方法这么几项内容。

除此之外，我们还可以规定配方是否允许对称，用assume_symmetry表示。例如对于锄头，我们知道

M M
  S
  S

和

M M
S
S

是等价的，读者可以看到这两个配方是对称的。默认来说，配方就是假定对称的，代表上面两个配方是等效的。但是我们可以将这个值设定为false使得上面两个配方不等效。例如微软文档给出了一个例子，代表下面两个配方是不等价的：

{
    "format_version": "1.19",
    "minecraft:recipe_shaped": {
        "description": {
            "identifier": "minecraft:zig"
        },
        "tags": [ "crafting_table" ],
        "assume_symmetry": false,
        "pattern": [
            "## ",
            " ##"
        ],
        "key": {
            "#": { "item": "minecraft:planks" }
        },
        "result": { "item": "minecraft:zig" }
    }
}

{
    "format_version": "1.20",
    "minecraft:recipe_shaped": {
        "description": {
            "identifier": "minecraft:zag"
        },
        "tags": [ "crafting_table" ],
        "assume_symmetry": false,
        "pattern": [
            " ##",
            "## "
        ],
        "key": {
            "#": { "item": "minecraft:planks" }
        },
        "result": { "item": "minecraft:zag" }
    }
}

以及，可以使用priority来表现同一个物品的配方的优先级。更具体的用法请读者自行研究。

物品的数量和数据值表达

在上面我们只是指定了物品的类型，事实上，我们还可以指定物品的数量和数据值。格式上，物品的数据可以由以下结构指定：

：代表一个物品的对象。
- item*：物品 ID。
- count：物品数量。默认值为1。
- data：物品数据值。默认值为0。

这些内容在有序配方中，可以在unlock*、key的各字符和result*中指定。其中，只有result*才能指定物品数量，代表合成出的物品数量。例如，对于玻璃板的合成配方，原版是如此定义的：

BP_vanilla/recipes/glass_pane.json
{
    "format_version": "1.20.10",
    "minecraft:recipe_shaped": {
        "description": {
            "identifier": "minecraft:glass_pane"
        },
        "tags": [ "crafting_table" ],
        "pattern": [
            "###",
            "###"
        ],
        "key": {
            "#": { "item": "minecraft:glass" }
        },
        "unlock": [
            { "item": "minecraft:glass" }
        ],
        "result": { "item": "minecraft:glass_pane", "count": 16 }
    }
}

我们重点关注第 18 行，这里的"count": 16就代表这个配方可以合成出 16 个玻璃板。

而因为一些历史原因，有些物品可能需要用数据值来表示。例如下面这个合成蓝色旗帜的原版合成配方：

BP_vanilla/recipes/blue_banner.json
{
    "format_version": "1.20.10",
    "minecraft:recipe_shaped": {
        "description": {
            "identifier": "minecraft:blue_banner"
        },
        "tags": [ "crafting_table" ],
        "group": "banner",
        "pattern": [
            "###",
            "###",
            " | "
        ],
        "key": {
            "#": { "item": "minecraft:blue_wool" },
            "|": { "item": "minecraft:stick" }
        },
        "unlock": [
            { "item": "minecraft:blue_wool" }
        ],
        "result": { "item": "minecraft:banner", "data": 4 }
    }
}

我们重点关注第 21 行，这里的"data": 4是蓝色的数据值代码，代表合成出的旗帜是蓝色旗帜。这种情况在原版的配方表文件中，染色物品和染料上会相对多见。

无序配方

现在让我们把目光转向无序配方。我们知道，无序配方的逻辑要比有序配方简单一些，工作台中只要有特定数量的特定物品，就可以输出物品，而不关心物品究竟是怎么摆的。

对于我们的红宝石，假如说……我们可以“研磨”红宝石成为红石粉！那么，我们可以添加一个新的配方文件redstone_from_ruby.recipe.json：

BP_test：行为包
- ……
- recipes：物品定义
  - test：以 test 作为物品的命名空间
    - ruby_sword.recipe.json：红宝石剑的配方文件
    - redstone_from_ruby.recipe.json：红石粉的配方文件

这里，我们将文件命名为redstone_from_ruby，同时声明了红石粉的来源，是因为原版就有红石粉的合成配方。正如我们前文所说，遇到这种情况的时候，适合在文件名称和 ID 处添加合成途径。我们写入以下内容：

redstone_from_ruby.recipe.json
{
    "format_version": "1.21.0",
    "minecraft:recipe_shapeless": {
        "description": {
            "identifier": "test:redstone_from_ruby"
        },
        "tags": [ "crafting_table" ],
        "unlock": [
            { "item": "test:ruby" }
        ],
        "ingredients": [
            { "item": "test:ruby" }
        ],
        "result": { "item": "minecraft:redstone", "count": 4 }
    }
}

它的效果如下图所示：

recipe_shapeless_1

在上面这个 json 中，除了高亮部分是我们在有序配方中没有讲到的东西之外，读者可以看到其他内容和有序配方是很相似的。这个 json 深刻地给出了有序配方和无序配方的区别，一个是第 3 行的 minecraft:recipe_shapeless*，定义了这是一个无序配方；而另一个不同点则是 ingredients，它定义了这个合成配方所需的材料列表（包括类型、数据值和数量）。具体来说，它允许的内容为：

ingredients：该物品的合成配方所需的材料。
- ：该配方所需的的物品。
  - item*：物品 ID。
  - count：所需的物品数量。数量应保持在1~9之间。默认值为1。
  - data：所需的物品数据值。默认值为0。

我们来举一个例子进一步理解一下，比如原版的甜菜汤，它代表由 6 个甜菜根和 1 个碗即可合成甜菜汤。我们关注第 10 行，这里就可以直接通过count指定 6 个甜菜根。

BP_vanilla/recipes/beetroot_soup.json
{
    "format_version": "1.20.10",
    "minecraft:recipe_shapeless": {
        "description": {
            "identifier": "minecraft:beetroot_soup"
        },
        "tags": [ "crafting_table" ],
        "ingredients": [
            { "item": "minecraft:bowl" },
            { "item": "minecraft:beetroot", "count": 6 }
        ],
        "unlock": [
            { "item": "minecraft:beetroot" }
        ],
        "result": {
            "item": "minecraft:beetroot_soup"
        }
    }
}

无序配方除了适用于工作台之外，也适用于切石机和制图台。我们来看一个切石机切安山岩为安山岩台阶的例子：

BP_vanilla/recipes/stonecutter_andesite_slab.json
{
    "format_version": "1.20.10",
    "minecraft:recipe_shapeless": {
        "description": {
            "identifier": "minecraft:stonecutter_andesite_slab"
        },
        "tags": [ "stonecutter" ],
        "priority": 0,
        "ingredients": [
            { "item": "minecraft:andesite" }
        ],
        "unlock": [
            { "item": "minecraft:andesite" }
        ],
        "result": { "item": "minecraft:andesite_slab", "count": 2 }
    }
}

需要注意，对于切石机，因为它只有一个槽位，所以在切石机配方中，应当注意合成配方所需的材料应当有且仅有一种物品。

熔炉配方

在介绍完有序和无序合成配方之后，我们再来看看熔炉的配方。这里我们就不以红宝石为例子了（~~因为实在想不到该写啥了~~），我们来做一个腐肉可以烧出皮革的配方吧！这个配方和所谓“天堂维度”一样，是典型的“诈骗”配方了 >:)

我们来新增一个配方leather_from_rotten_flesh.recipe.json。顺带地，我们再嵌套两个文件夹来对目前的配方文件做个整理：

BP_test：行为包
- ……
- recipes：物品定义
  - test：以 test 作为物品的命名空间
    - crafting_table：工作台合成配方
      - ruby_sword.recipe.json：红宝石剑的配方文件
      - redstone_from_ruby.recipe.json：红石粉的配方文件
    - furnace：熔炉合成配方
      - leather_from_rotten_flesh.recipe.json：皮革的配方文件

对皮革的配方文件，我们写入以下内容：

redstone_from_ruby.recipe.json
{
    "format_version": "1.21.0",
    "minecraft:recipe_furnace": {
        "description": {
            "identifier": "test:leather_from_rotten_flesh"
        },
        "tags": [ "furnace" ],
        "unlock": [
            { "item": "minecraft:rotten_flesh" }
        ],
        "input": "minecraft:rotten_flesh",
        "output": "minecraft:leather"
    }
}

recipe_furnace_2

它的效果如下图所示，是的，我们亲手把曾经的“诈骗”配方变成了现实！

recipe_furnace_1

现在让我们来关注一下这个文件的结构。同理地，第 3 行的 minecraft:recipe_furnace*定义了这是一个熔炉配方；而第 11~12 行的input*和output*则分别定义了熔炉的输入和输出物品。和前文不同，这里可以直接在输入和输出中写为字符串，我们在上文就是这么做的。上面的代码和下面的代码是等效的，读者可以着重关注第 11~12 行两段代码的区别。

redstone_from_ruby.recipe.json（等效代码）
{
    "format_version": "1.21.0",
    "minecraft:recipe_furnace": {
        "description": {
            "identifier": "test:leather_from_rotten_flesh"
        },
        "tags": [ "furnace" ],
        "unlock": [
            { "item": "minecraft:rotten_flesh" }
        ],
        "input": { "item": "minecraft:rotten_flesh" },
        "output": { "item": "minecraft:leather" }
    }
}

除了熔炉之外，烧炼配方还支持高炉（blast_furnace）、烟熏炉（smoker）、营火（campfire）和灵魂营火（soul_campfire），只需要在tags*中指定这些方块，就可以在它们之上应用。按照原版的逻辑，原则上，一切烧炼配方都应适用于熔炉，矿物类在适用于熔炉的同时适用高炉，而食物类在适用于熔炉的同时适用于烟熏炉营火和灵魂营火。例如，以下为原版牛排的烧制配方：

BP_vanilla/recipes/furnace_beef.json
{
    "format_version": "1.20.10",
    "minecraft:recipe_furnace": {
        "description": {
            "identifier": "minecraft:furnace_beef"
        },
        "unlock": [
            { "item": "minecraft:beef" }
        ],
        "tags": [ "furnace", "smoker", "campfire", "soul_campfire" ],
        "input": "minecraft:beef",
        "output": "minecraft:cooked_beef"
    }
}

刚刚我们介绍了有序配方、无序配方和烧炼配方各自的写法。至于酿造配方和锻造配方，因为限制比较大，就不在教程中展开了，读者若需要可以自行在我们提供的文档中自学，原理都是类似的。

物品标签

现在我们来关注一个问题：我们知道有些合成配方需要的是一类物品，例如木桶的合成配方接受任意的木板和任意的木制台阶，但是现在 Minecraft 一共有十多种木板，就算用的都是相同的木板，挨个定义也很麻烦，就更不用说各种木板的混合合成了。好在，我们可以使用物品标签（Item Tag）来解决这个麻烦的问题！

我们来看木桶的合成配方：

BP_vanilla/recipes/barrel.json
{
    "format_version": "1.20.10",
    "minecraft:recipe_shaped": {
        "description": {
            "identifier": "minecraft:barrel_with_planks"
        },
        "tags": [ "crafting_table" ],
        "pattern": [
            "#-#",
            "# #",
            "#-#"
        ],
        "key": {
            "#": { "tag": "minecraft:planks" },
            "-": { "tag": "minecraft:wooden_slabs" }
        },
        "unlock": [
            { "tag": "minecraft:planks" },
            { "tag": "minecraft:wooden_slabs" }
        ],
        "result": {
            "item": "minecraft:barrel"
        },
        "priority": -1
    }
}

着重看我们高亮的部分，我们清楚地看到这里不再是定义一种具体的木板，而是定义了物品标签，拥有这个标签的物品就可用于合成。

目前来说，原版物品和方块使用的物品标签也可以在我们提供的文档中找到。这可以大幅简化某些情况下的配方的复杂度，当你需要使用一类物品而不是一种特定的物品合成的时候，就请优先想起物品标签吧。

物品组件`minecraft:tags`

那么，我们的自定义物品如何添加物品标签呢？答案是利用物品组件minecraft:tags！我们的文档对这个组件给出了明确的介绍，它的结构如下：

minecraft:tags：根对象。
- tags：物品的标签列表。
  - ：物品标签。

例如，我们一开始所定义的红宝石剑，可以为它加上一个标签minecraft:is_sword：

ruby_sword.item.json
{
    "format_version": "1.21.50",
    "minecraft:item": {
        "description": {
            "identifier": "test:ruby_sword",
            "menu_category": {
                "category": "equipment"
            }
        },
        "components": {
            "minecraft:icon": "ruby_sword",
            "minecraft:tags": {
                "tags": [ "minecraft:is_sword" ]
            }
        }
    }
}

如果需要添加标签来简化合成配方，就可以通过minecraft:tags组件来添加。

*配方命令：`/recipe`

Minecraft 是有一些和配方相关的命令的，也就是命令/recipe。来简单看一眼这条命令的使用方法吧：

/recipe give <玩家: target> <配方: string>
/recipe take <玩家: target> <配方: string>

第一条命令是给予玩家配方，而第二条命令则是夺走玩家配方。配方要填写配方文件的 ID，例如

recipe give @a minecraft:barrel_with_planks

就是令全部玩家获得木桶的合成配方。

配方也可以写为*以指定全部配方。比如

recipe take @a *

就是夺走所有玩家的所有配方表。

*与配方相关的游戏规则

同样地，随着配方解锁的推出，也有一系列的游戏规则加入进游戏，我们在这里给出相关的游戏规则列表¹：

游戏规则	效果
`doLimitedCrafting`	玩家的合成配方是否需要解锁才能使用。
`recipesUnlock`	配方是否需要解锁。
`showRecipeMessages`	是否在解锁新配方时显示消息。

然而，这些游戏规则并不能阻止玩家获得新的配方。因此，配方及相关命令在实际工程中的应用事实上是极为有限的。

总结

在这一节，我们介绍了有关合成配方的许多内容，主要包括以下几个方面：

如何定义一个新的配方。我们在本节详细介绍了有序配方、无序配方和熔炉配方的语法。
- 有序配方要求玩家必须按照特定的搭配方式摆放合成材料才能合成物品。
- 无序配方仅要求有对应类型的合成材料即可。
- 熔炉配方要求玩家必须输入一个有效物品才能烧制为成品。
- 以上 3 种配方，和剩下的 4 种配方一起，都记录在我们给出的配方表文档中，读者需要时请自行查阅。
如何在一个配方里表达一种或一类物品。可以使用以下几种方式：
- 直接使用表达物品，例如"minecraft:black_dye"。
- 使用表达物品，例如{ "item": "minecraft:dye", "data": 0, "count": 1 }。
- 使用物品标签表达一类物品，例如{ "tag": "minecraft:planks" }。原版使用的标签可以在我们给出的物品标签文档中找到，也可以通过物品组件minecraft:tag直接为我们的数驱物品定义标签。
如何使用命令控制配方——即利用/recipe和/gamerule进行控制。因为不能阻止配方的获取，这两条命令在实际工程中的应用有限。

练习

练习 4.2

我们在这节讲解了合成配方，但看看这一章的标题吧——数据驱动物品！所以，我们这一节的练习会是一个承上启下的作用！

本节的练习请认真做完哦，我们下节及后续内容都会用到！

利用我们所定义的红宝石，以及前文所介绍的制作红宝石剑的方法，快速定义出红宝石头盔、胸甲、护腿、靴子、镐斧锹锄。我们下一节都会用到！但是，只需要定义即可，不需要给它们加功能——那也是我们下节要做的事。
然后，基于第 1 问所定义的物品，为它们各自添加配方！
我们知道 2 个下界石英和 2 个圆石合成 2 个闪长岩，而闪长岩和圆石合成 2 个安山岩。请直接做一个无序配方，直接通过圆石和下界石英一步到位合成安山岩！合成材料所需的数量比例请自行计算。
民以食为天，我们来做一些新的食物吧！
1. 首先定义面粉（test:flour）和面团（test:dough），以下为两个参考贴图：
  面粉：面团：（读者可以下载去，~~画功不好请见谅~~）
2. 现在，我们新增两个配方，首先定义一个无序配方，将小麦合成为面粉；然后，定义一个无序配方，使面粉和水桶合成为面团；最后，使面团在熔炉中烧制为面包。

练习题答案

按照上文所介绍的方法（红宝石颜色 + bb 颜色画笔法）分别画出如下所示的图像：
红宝石剑：红宝石镐：红宝石斧：红宝石锹：红宝石锄：红宝石头盔：红宝石胸甲：红宝石护腿：红宝石靴子：
然后，分别定义其他 8 种物品。注意为它们分别加上对应的标签，有些标签是具有特定功能的。

请不要嫌麻烦！定义物品，尤其是一次性定义很多物品的时候就是这样枯燥的过程！再加上翻译，我们的定义就完成了。
基于第 1 问的结果，现在我们为它们分别添加配方。它们使用的配方均为有序配方。

下面是两个我们定义的结果。读者可以看到，对于对称配方，斧头和我们上面定义的摆放方式是对称的，所以也可以合成。如果使用"assume_symmetry": false，那么这样就合成不出东西了。

根据题意，2 下界石英 + 2 圆石 → 2 闪长岩，平均每个闪长岩需要 1 下界石英和 1 圆石。这样，2 个安山岩就平均需要 1 个下界石英和 2 个圆石。我们需要定义这样的无序配方：1 下界石英 + 2 圆石 → 2 安山岩。因此，定义下面的配方即可：

{
    "format_version": "1.21.0",
    "minecraft:recipe_shapeless": {
        "description": {
            "identifier": "test:andesite_from_quartz"
        },
        "tags": [ "crafting_table" ],
        "unlock": [
            { "item": "minecraft:quartz" }
        ],
        "ingredients": [
            { "item": "minecraft:cobblestone", "count": 2 },
            { "item": "minecraft:quartz" }
        ],
        "result": { "item": "minecraft:andesite", "count": 2 }
    }
}

practice_8
读者也可以做 2 下界石英 + 4 圆石 → 4 安山岩的配方。

1. 如图，定义这两个新物品：
2. 按照题意，定义三个新配方：
  
  遗憾的是，我们的自定义配方和原版的蛋糕仍然有不同，这个操作会把桶吞掉，且没有补救措施。

此处参考了中文 Minecraft Wiki。 ↩

工作台配方​

有序配方​

物品的数量和数据值表达​

无序配方​

熔炉配方​

物品标签​

物品组件minecraft:tags​

*配方命令：/recipe​

*与配方相关的游戏规则​

总结​

练习​

Footnotes​