<本站文本内容除另有声明外,转载时均必须注明出处。(详情…中文Minecraft Wiki是完全公开的。请勇于扩充与修正内容!Minecraft中文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
  }

參見[編輯 | 編輯原始碼]