<本站文本内容除另有声明外,转载时均必须注明出处。(详情…本站文本内容除另有声明外,转载时均必须注明出处。(详情…中文Minecraft Wiki是完全公开的。请勇于扩充与修正内容!中文Minecraft Wiki是完全公开的。请勇于扩充与修正内容!Minecraft中文Wiki微博正在更新!或许有兴趣去看看Minecraft中文Wiki微博正在更新!或许有兴趣去看看想与其他用户进行编辑上的沟通?社区专页正是为此创建的。想与其他用户进行编辑上的沟通?社区专页正是为此创建的。翻译或创建页面之前,不妨看看译名标准化Wiki条例页面。翻译或创建页面之前,不妨看看译名标准化Wiki条例页面。需要管理员的协助?在管理员告示板留言也许可以帮到您。需要管理员的协助?在管理员告示板留言也许可以帮到您。>

基岩版生物群系文档

来自Minecraft Wiki
跳转至: 导航搜索
Ic translate.svg
此条目的(部分)内容需要翻译。

你可以帮助我们来翻译此条目,但请勿使用机器翻译

翻译者从 英文条目翻译下文中的内容时感觉其艰涩难懂

翻译者希望更有能力的翻译者能够帮助改善本条目的行文,所以请先请慎重对待本条目内容。
如果可能,请帮助我们完善此条目的内容。

Information icon.svg
此特性为基岩版独有。
参见:基岩版beta附加包文档

这是基岩版1.14.0生物群系文档

概述[编辑 | 编辑源代码]

生物群系描述了世界上一个区域的外观和行为。通过编写生物群系数据,你可以:

  1. 改变生物群系地形的一般形状。
  2. 改变生成生物群系类型的频率。
  3. 改变构成生物群系的方块,包括表面和下面。
  4. 改变生物群系的环境特征(譬如树木、草等)的分布。
  5. 改变生物群系上生成的生物。
  6. 改变生物群系的气候。

JSON格式[编辑 | 编辑源代码]

所有生物群系都应通过"format_version"字段指定其目标版本。生物群系数据的其余部分被划分为独立的JSON子对象或组件。一般来说,你可以认为一个组件的存在定义了一个生物群系参与的游戏行为,而组件字段定义了它如何参与。大体上有两类组成部分:

  1. 命名空间组件(既带有“name:”前缀的组件)映射到游戏中的特定行为。它们可能具有参数化该行为的字段;仅支持具有有效映射的名称。
  2. 没有命名空间的组件被视为标签:允许使用字母、数字、“.”和“_”组成的任何名称。将标签添加到生物群系,以便代码或数据可以检查其是否存在;标签组件可能没有字段。

有关其他详细信息和命名组件的完整列表,请参见下面的完整生物群系架构。

这是一个生物群系样本:

{
  "format_version": "1.13.0",
  "minecraft:biome": {
    "description": {
      "identifier": "plains"
    },
    "components": {
      "minecraft:climate": {
        "downfall": 0.4,
        "snow_accumulation": [ 0.0, 0.125 ],
        "temperature": 0.8
      },
      "minecraft:overworld_height": {
        "noise_type": "lowlands"
      },
      "minecraft:overworld_surface": {
        "floor_depth": 7,
        "floor_material": "minecraft:gravel",
        "foundation_material": "minecraft:stone",
        "mid_material": "minecraft:dirt",
        "top_material": "minecraft:grass"
      },
      "minecraft:world_generation_rules": {
        "hills_transformation": [
          [ "forest_hills", 1 ],
          [ "forest", 2 ]
        ],
        "mutate_transformation": "sunflower_plains",
        "generate_for_climates": [
          [ "medium", 3 ],
          [ "warm", 1 ],
          [ "cold", 1 ]
        ]
      },

      "animal": {},
      "monster": {},
      "overworld": {},
      "plains": {}
    }
  }
}

添加生物群系[编辑 | 编辑源代码]

从行为包的biome子文件夹中的JSON文件读取生物群系。加载并对每个文件强制执行一个生物群系;文件名和实际的生物群系名称必须匹配;将新名称的文件添加到biome数据位置使其可供游戏使用,而现有的生物群系可以通过与其现有名称匹配的文件覆盖。注意,如果你添加了一个新的生物群系,你将需要编写组件数据,允许它参与世界生成(见下面的完整构架),否则它不会出现在你的世界中。

架构[编辑 | 编辑源代码]

  {
      version "format_version"
      object "minecraft:climate"[0,3] : opt // 描述温度、湿度、降水量等。没有此部分的生物群系将使用默认值。
      {
          float "temperature"
          float "downfall"
          array "snow_accumulation"[2]
          {
              float "0"
              float "1"
          }
      }
      object "minecraft:overworld_height"[0,2] : opt // 用于在主世界中表示地形高度的噪音参数。
      {
          array "noise_params"[2] : opt
          {
              float "0"
              float "1"
          }
          string "noise_type" : opt
      }
      object "minecraft:forced_features"[0,14] : opt // 强制特定的装饰特征(树木、植物等)出现在这个生物群系中,而不考虑正常的装饰规则。
      {
          array "first_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // 生成的分散度。
                  molang "chance_percent" : opt // 出现这种分散的概率(0-100)。不计算每个迭代;要么不运行任何迭代,要么运行全部迭代。
                  molang "x" : opt // 坐标的表达式(每次迭代都计算)。与下面的随机分布对象互斥。
                  object "x" : opt // 坐标分布(每次迭代都计算)。与上面的Molang表达互斥。
                  {
                      enumerated_value "distribution" // 分布类型-均匀随机、高斯(以范围为中心)或网格。
                      int "step_count" : opt // 当分布类型为“网格”时,定义沿该轴的细分数。
                      array "extent"[2]
                      {
                          molang "0" : opt // 散射范围的下限(包括),作为从输入点到周围散射的偏移量。
                          molang "1" : opt // 散点范围的上限(包括),作为从输入点到周围散射的偏移量。
                      }
                  }
                  molang "z" : opt // 坐标的表达式(每次迭代都计算)。与下面的随机分布对象互斥。
                  object "z" : opt // 坐标分布(每次迭代都计算)。与上面的Molang表达相互排斥。
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "before_underground_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  molang "chance_percent" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "underground_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  molang "chance_percent" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "after_underground_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  molang "chance_percent" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "before_surface_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  molang "chance_percent" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "surface_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  molang "chance_percent" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "after_surface_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  molang "chance_percent" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "before_liquids_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  molang "chance_percent" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "liquids_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  molang "chance_percent" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "after_liquids_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  molang "chance_percent" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "before_sky_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  molang "chance_percent" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "sky_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  molang "chance_percent" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "after_sky_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  molang "chance_percent" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "final_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  molang "chance_percent" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
      }
      object "minecraft:automatic_features"[0] : opt // Use normal decorative feature spawn rules to determine the tree, plants, etc. that appear in this biome.
      object "minecraft:overworld_surface"[0,5] : opt // Control the blocks used for the default Minecraft Overworld terrain generation.
      {
          block_reference "top_material" // Controls the block type used for the surface of this biome.
          block_reference "mid_material" // Controls the block type used in a layer below the surface of this biome.
          block_reference "floor_material" // Controls the block type used as a floor for bodies of water in this biome.
          block_reference "foundation_material" // Controls the block type used deep underground in this biome.
          int "floor_depth" // Controls how deep below the world water level the floor should occur.
      }
      object "minecraft:surface_material_adjustments"[0,1] : opt // Specify fine-detail changes to blocks used in terrain generation (based on a noise function)
      {
          array "adjustments" : opt // All adjustments that match the column's noise values will be applied in the order listed.
          {
              object "<any array element>"
              {
                  object "materials"
                  {
                      block_reference "top_material" : opt // Controls the block type used for the surface of this biome when this adjustment is active.
                      block_reference "mid_material" : opt // Controls the block type used in a layer below the surface of this biome when this adjustment is active.
                      block_reference "floor_material" : opt // Controls the block type used as a floor for bodies of water in this biome when this adjustment is active.
                      block_reference "foundation_material" : opt // Controls the block type used deep underground in this biome when this adjustment is active.
                  }
                  array "noise_range"[2] // Defines a range of noise values [min, max) for which this adjustment should be applied.
                  {
                      string "0" : opt
                      float "0" : opt
                      string "1" : opt
                      float "1" : opt
                  }
              }
          }
      }
      object "minecraft:swamp_surface"[0,5] : opt // Similar to overworld_surface.  Adds swamp surface details.
      {
          block_reference "top_material" // Controls the block type used for the surface of this biome.
          block_reference "mid_material" // Controls the block type used in a layer below the surface of this biome.
          block_reference "floor_material" // Controls the block type used as a floor for bodies of water in this biome.
          block_reference "foundation_material" // Controls the block type used deep underground in this biome.
          int "floor_depth" // Controls how deep below the world water level the floor should occur.
      }
      object "minecraft:frozen_ocean_surface"[0,5] : opt // Similar to overworld_surface.  Adds icebergs.
      {
          block_reference "top_material" // Controls the block type used for the surface of this biome.
          block_reference "mid_material" // Controls the block type used in a layer below the surface of this biome.
          block_reference "floor_material" // Controls the block type used as a floor for bodies of water in this biome.
          block_reference "foundation_material" // Controls the block type used deep underground in this biome.
          int "floor_depth" // Controls how deep below the world water level the floor should occur.
      }
      object "minecraft:mesa_surface"[0,9] : opt // Similar to overworld_surface.  Adds colored strata and optional pillars.
      {
          block_reference "top_material" // Controls the block type used for the surface of this biome.
          block_reference "mid_material" // Controls the block type used in a layer below the surface of this biome.
          block_reference "floor_material" // Controls the block type used as a floor for bodies of water in this biome.
          block_reference "foundation_material" // Controls the block type used deep underground in this biome.
          int "floor_depth" // Controls how deep below the world water level the floor should occur.
          block_reference "clay_material"
          block_reference "hard_clay_material"
          bool "bryce_pillars"
          bool "has_forest"
      }
      object "minecraft:nether_surface"[0] : opt // Use default Minecraft Nether terrain generation.
      object "minecraft:the_end_surface"[0] : opt // Use default Minecraft End terrain generation.
      object "minecraft:world_generation_rules"[0,3] : opt // Control how this biome is instantiated (and then potentially modified) during world generation.
      {
          biome_reference "hills_transformation" : opt
          array "hills_transformation" : opt
          {
              biome_reference "<any array element>" : opt
              array "<any array element>"[2] : opt
              {
                  biome_reference "0"
                  int "1"
              }
          }
          biome_reference "mutate_transformation" : opt
          array "mutate_transformation" : opt
          {
              biome_reference "<any array element>" : opt
              array "<any array element>"[2] : opt
              {
                  biome_reference "0"
                  int "1"
              }
          }
          array "generate_for_climates" : opt // Controls the world generation climate categories that this biome can spawn for.  A single biome can be associated with multiple categories with different weightings.
          {
              array "<any array element>"[2]
              {
                  enumerated_value "0" // Name of a climate category
                  int "1" // Weight with which this biome should be selected, relative to other biomes in the same category
              }
          }
      }
      object "[a-z0-9_.:]+"[0] : opt // Attach arbitrary string tags to this biome
  }

另见[编辑 | 编辑源代码]