モジュール:LootChest

提供: Minecraft Wiki
移動先: 案内検索

メンテナンス[ソースを編集]

Java Editionのリリースバージョンについてのデータは、1.14.4時点のものです。(1.15.2の確認および更新が必要です) 2019/8/6 22:13(UTC)
Java Editionのスナップショットについてのデータは、1.14.4 Pre-Release 5時点のものです。(20w14aの確認および更新が必要です) 2019/7/14 04:00(UTC)
Bedrock Editionのリリースバージョンについてのデータは、1.12.0時点のものです。(1.14.30の確認および更新が必要です) 2019/7/14 04:00(UTC)
Bedrock EditionのBetaバージョンについてのデータは、beta 1.13.0.2時点のものです。(beta 1.16.0.55の確認および更新が必要です) 2019/7/14 04:00(UTC)

.base の使用法 (テンプレート:LootChest)[ソースを編集]

指定されたチェストの中身の表を生成し、それらのアイテムの入手可能性に関する様々な統計情報に対応する列を持つ。

呼び出し[ソースを編集]

chestパラメータとcolumnパラメータを順番に指定することなく、任意の数のchestパラメータと任意の数のcolumnパラメータを取得する。

chestパラメータがリストされていない場合は、すべてのchestパラメータが表示される。

{{#invoke:LootChest|base
 [ |<chestParam1> ... |<chestParamN> ]
 [ |<columnHideParam1> ... |<columnHideParamN> ]
}}

Chestパラメータ[ソースを編集]

bonus,
buried-treasure,
desert-temple ( desert ),
dungeon,
end-city,
igloo,
jungle-temple ( jungle ),
jungle-temple-dispenser,
mineshaft,
nether-fortress ( nether, fortress ),
pillager-outpost ( outpost ),
shipwreck-map,
shipwreck-supply,
shipwreck-treasure,
stronghold-altar ( altar ),
stronghold-library ( library ),
stronghold-storeroom ( storeroom ),
underwater-ruin-big,
underwater-ruin-small,
village-armorer ( armorer ),
village-butcher ( butcher ),
village-cartographer ( cartographer ),
village-desert-house ( desert-house ),
village-fisherman ( fisherman ),
village-fletcher ( fletcher ),
village-mason ( mason ),
village-plains-house ( plains-house ),
village-savanna-house ( savanna-house ),
village-shepherd ( shepherd ),
village-snowy-house ( snowy-house ),
village-taiga-house ( taiga-house ),
village-tannery ( tannery ),
village-temple ( temple ),
village-toolsmith ( toolsmith ),
village-weaponsmith ( weaponsmith ),
woodland-mansion ( mansion )

Columnパラメータ[ソースを編集]

chance: 1つのチェストの中に、このアイテムが発見される確率,
chests: このアイテムを発見するのに必要なチェストの探索個数の期待値,
items: 多数のチェストを平均した、1つのチェストあたりのアイテム数の期待値,
stacksize: チェスト内のアイテムのスタックの大きさ(またはスタックできないアイテムの数),
weight: チェスト内の他のアイテムと比較した場合のこのアイテムの割合

使用例[ソースを編集]

{{#invoke:LootChest|base}} → 全てのchestと全てのcolumn

{{#invoke:LootChest|base|blacksmith|jungle|bonus|chance|stacksize}} → 鍛冶屋とジャングルの箱だけ、そして「stacksize」と「chance」のcolumnだけ

.base2 の使用法 (テンプレート:LootChestItem)[ソースを編集]

このアイテムが様々なワールドに生成されるチェストで入手できる概要を印刷する

呼び出し[ソースを編集]

これは、パラメータとして正確に1つの項目名を受け取る。

{{#invoke:LootChest|base2|<itemParam>}}

Itemパラメータ[ソースを編集]

acacia-log, acacia-sapling, activator-rail, apple, arrow, bamboo, barrel, beetroot, beetroot-seeds, beetroot-soup, birch-log, birch-sapling, black-wool, blue-ice, bone, book, book-and-quill, bottle-o'-enchanting, bread, brown-mushroom, brown-wool, bucket, buried-treasure-map, cactus, cake, carrot, chainmail-boots, chainmail-chestplate, chainmail-helmet, chainmail-leggings, clay, clock, coal, cocoa-beans, compass, cooked-cod, cooked-salmon, crossbow, dandelion, dark-oak-log, dark-oak-sapling, dead-bush, detector-rail, diamond, diamond-chestplate, diamond-hoe, diamond-horse-armor, disc-13, disc-cat, disc-mellohi, disc-wait, egg, emerald, empty, empty-map, enchanted-book, enchanted-book-rnd, enchanted-book-rnd-treasure, enchanted-diamond-boots, enchanted-diamond-chestplate, enchanted-diamond-helmet, enchanted-diamond-leggings, enchanted-diamond-pickaxe, enchanted-diamond-shovel, enchanted-diamond-sword, enchanted-fishing-rod, enchanted-golden-apple, enchanted-iron-boots, enchanted-iron-chestplate, enchanted-iron-helmet, enchanted-iron-leggings, enchanted-iron-pickaxe, enchanted-iron-shovel, enchanted-iron-sword, enchanted-leather-boots, enchanted-leather-cap, enchanted-leather-pants, enchanted-leather-tunic, ender-pearl, feather, fern, flint, flint-and-steel, flower-pot, furnace, gold-ingot, gold-nugget, golden-apple, golden-chestplate, golden-helmet, golden-horse-armor, golden-sword, grass, gray-wool, green-dye, gunpowder, heart-of-the-sea, ink-sac, iron-boots, iron-chestplate, iron-helmet, iron-horse-armor, iron-ingot, iron-leggings, iron-nugget, iron-pickaxe, iron-shovel, iron-sword, jungle-log, jungle-sapling, lapis-lazuli, large-fern, lead, leather, leather-boots, leather-cap, leather-pants, leather-tunic, light-gray-wool, map, melon-seeds, name-tag, nether-wart, oak-log, oak-planks, oak-sapling, oak-sign, obsidian, paper, poisonous-potato, poppy, potato, potion-of-regeneration, potion-of-water-breathing, powered-rail, prismarine-crystals, pumpkin, pumpkin-pie, pumpkin-seeds, rail, raw-beef, raw-cod, raw-mutton, raw-porkchop, raw-salmon, redstone, rotten-flesh, saddle, sand, shears, smooth-stone, snow-block, snowball, spider-eye, spruce-log, spruce-sapling, spruce-sign, stick, stone, stone-axe, stone-bricks, stone-pickaxe, string, suspicious-stew, sweet-berries, tall-grass, tnt, torch, tripwire-hook, water-bucket, wheat, wheat-seeds, white-wool, wooden-axe, wooden-hoe, wooden-pickaxe, yellow-dye

使用例[ソースを編集]

{{#invoke:LootChest|base2|iron-ingot}} → 鉄インゴットは、54.2%の確率での防具鍛冶のチェストの中に、30.5%の確率でピリジャーの前哨基地のチェストの中に、1–3個生成される。23.3%の確率で要塞の祭壇のチェストの中に、41.2%の確率での道具鍛冶のチェストの中に、97.4%の確率で難破船のトレジャーチェストの中に、34.3%の確率で要塞の倉庫のチェストの中に、45.1%の確率での武器鍛冶のチェストの中に、19.0%の確率でネザー要塞のチェストの中に、37.4%の確率でジャングルの寺院のチェストの中に、18.0%の確率で砂漠の寺院のチェストの中に、31.6%の確率で廃坑チェスト付きトロッコの中に、全て1–5個生成される。38.4%の確率でエンドシティのチェストの中に、4–8個生成される。また、18.5%の確率でダンジョンのチェストの中に、18.5%の確率で森の洋館のチェストの中に、99.4%の確率で埋もれた宝のチェストの中に、全て1–4個生成される。

Bedrock Editionでは、これらは、57.2%の確率で埋もれた宝のチェストの中に、3–5個生成される。また、22.6%の確率で要塞の祭壇のチェストの中に、28.5%の確率で要塞の倉庫のチェストの中に、37.3%の確率でジャングルの寺院のチェストの中に、全て1–5個生成される。

{{#invoke:LootChest|base2|emerald}} → エメラルドは、14.9%の確率で大きな海底遺跡のチェストの中に、24.2%の確率での漁師のチェストの中に、31.8%の確率での防具鍛冶のチェストの中に、12.3%の確率での羊飼いのチェストの中に、10.2%の確率での肉屋のチェストの中に、16.4%の確率で小さな海底遺跡のチェストの中に、12.3%の確率での矢細工師のチェストの中に、7.6%の確率でイグルーのチェストの中に、20.8%の確率での石工のチェストの中に、全て1個生成される。25.4%の確率での寺院のチェストの中に、21.5%の確率での家のチェストの中に、9.9%の確率での家のチェストの中に、22.8%の確率での家のチェストの中に、18.6%の確率での家のチェストの中に、17.3%の確率での革細工師のチェストの中に、全て1–4個生成される。73.7%の確率で難破船のトレジャーチェストの中に、1–5個生成される。53.1%の確率で埋もれた宝のチェストの中に、4–8個生成される。14.3%の確率での家のチェストの中に、8.7%の確率でジャングルの寺院のチェストの中に、18.0%の確率で砂漠の寺院のチェストの中に、全て1–3個生成される。また、9.0%の確率でエンドシティのチェストの中に、2–6個生成される。

Bedrock Editionでは、これらは、7.2%の確率で要塞の祭壇のチェストの中に、8.7%の確率でジャングルの寺院のチェストの中に、1–3個生成される。また、20.3%の確率での家のチェストの中に、1–4個生成される。

ソース[ソースを編集]

  • データはp内に設定されているため、マインクラフトのルートテーブルファイルから直接引っ張ってくることができる(または直接比較することができる)。
  • ここで与えられた(そしてコード中で与えられた)スタックサイズはアイテムのスタック可能サイズよりも大きくなる可能性がある(特にエンチャントされた本の場合)。しかし、ゲームが適切な数のアイテムを置くが、スタックされていないため、この事実は計算値には影響しない。

データ構造[ソースを編集]

  • p.items
'<item-id>' = {
このキーは[[[:Module:BlockSprite]]または[[[:Module:ItemSprite]]で定義されたアイテム/ブロックのスプライト名と一致しなければならない。
'<sprite-type>'
itemまたはblockのいずれか。
[, id='<sprite-id>']
これは[[[:Module:BlockSprite]]や[[[:Module:ItemSprite]]で定義されたスプライトを指定する際に使用する。 それ以外の場合は、item-idで指定された名前のスプライトを使用する。
[, link='<item-link>']
sprite-id名とは別のページへのリンク。Template:LootChestで使用する。
[, title='<item-text>']
スプライトID名とは異なるアイテムの名前。
[, cannot_stack=false]
これは、アイテムがスタックではなくグループで来ることを示すために使用する。Template:LootChestItem で使用する。
[, plural=(false|'<custom-plural-word>')]
'Nether Wart' のように複数形がない場合は false を使用する。'Bottles o' Enchanting'のように、ベースとなる単語に's'を追加して複数形にすることができない場合は、カスタムの複数形を使用する。Template:LootChestItemで使用する。
[, preserve_case=false]
アイテム名がtitleで指定された大文字小文字に従うべきで、'TNT'のように文の大文字小文字に従わない場合は、falseを使用する。
[, note='<note-name>']
表のこの項目の隣に注意書きが表示されることを示す。(注意書きは項目リストの直下に定義されている)
}
  • p.notes
'<note-name>' = '<note-full-text>'
  • p.chests[n].poolsJava[n]
  • p.chests[n].poolsJavaUpcoming[n]
  • p.chests[n].poolsBedrock[n]
  • p.chests[n].poolsBedrockUpcoming[n]
    • roll
{ <min-number-of-stacks>, <max-number-of-stacks> }
  • p.chests[n].poolsJava[n].items
  • p.chests[n].poolsJavaUpcoming[n].items
  • p.chests[n].poolsBedrock[n].items
  • p.chests[n].poolsBedrockUpcoming[n].items
'<item-id>' = { <min-stack-size>, <max-stack-size>, <item-weight> }
  • p.synonyms
'<chest-name-synonym>' = '<original-interally-valid-chest-name>'
p.chestsで定義されているものに加えて、追加のチェスト名をパラメータとして使用できるようにする。
  • p.display_names
'<chest-name-given-via-parameter>' = '<name-displayed-in-single-chest-table>'
1つのchestパラメータが使用されている場合、テーブルの上の要約文で呼び出される名前を定義する。
  • p.columns
'<column-name>' = '<column-full-description>'
columnの説明は、columnヘッダーのツールチップ、または表の上の要約文のいずれかに記載されている。

関数[ソースを編集]

ファイルの先頭に以下の機能を用意し、閲覧しやすくしている。

  • calc_average_amount_this_item_per_chest
あるアイテムのチェストあたり(構造あたりではなく)の平均数(スタック数ではなく)
  • calc_chance_any_of_this_item_per_chest
チェストごとに(構造ごとではなく)、あるアイテムのうち少なくとも1つのアイテムが見つかる確率。

テスト[ソースを編集]

{{#invoke:LootChest|base2_test}}



TNTは、8.1%の確率で難破船のサプライチェストの中に、62.7%の確率で埋もれた宝のチェストの中に、1–2個生成される。

Bedrock Editionでは、これらは、34.3%の確率で埋もれた宝のチェストの中に、1–2個生成される。

Bedrock Editionでは、イカスミは、40.0%の確率で要塞の倉庫のチェストの中に、1–3個生成される。

Bedrock Editionでは、エンチャントの本[注釈 1]は、17.5%の確率で森の洋館のチェストの中に、1つ生成される。

Bedrock Editionでは、オークの看板は、10.7%の確率での家のチェストの中に、1個生成される。

Bedrock Editionでは、カカオ豆は、40.0%の確率でボーナスチェストの中に、1–2個生成される。

Bedrock Editionでは、ケーキは、4.1%の確率で埋もれた宝のチェストの中に、1個生成される。

Bedrock Editionでは、シラカバの苗木は、14.3%の確率でボーナスチェストの中に、4個生成される。

Bedrock Editionでは、ジャングルの苗木は、28.6%の確率でボーナスチェストの中に、4個生成される。

Bedrock Editionでは、ダークオークの苗木は、14.3%の確率でボーナスチェストの中に、4個生成される。

Bedrock Editionでは、チェーンのブーツは、57.2%の確率で埋もれた宝のチェストの中に、1つ生成される。

Bedrock Editionでは、チェーンのヘルメットは、57.2%の確率で埋もれた宝のチェストの中に、1つ生成される。

Bedrock Editionでは、チェーンのレギンスは、57.2%の確率で埋もれた宝のチェストの中に、1つ生成される。

Bedrock Editionでは、レコード(mellohi)は、18.9%の確率で埋もれた宝のチェストの中に、1つ生成される。

Bedrock Editionでは、レコード(wait)は、18.9%の確率で埋もれた宝のチェストの中に、1つ生成される。

Bedrock Editionでは、再生のポーションは、34.3%の確率で埋もれた宝のチェストの中に、1個生成される。

Bedrock Editionでは、地図[注釈 5]は、7.7%の確率で難破船のマップチェストの中に、10.5%の確率で要塞の図書室のチェストの中に、1個生成される。また、46.2%の確率での製図家のチェストの中に、1–3個生成される。

Bedrock Editionでは、本と羽根ペンは、18.9%の確率で埋もれた宝のチェストの中に、1–2個生成される。

Bedrock Editionでは、水中呼吸のポーションは、46.9%の確率で埋もれた宝のチェストの中に、1個生成される。

Bedrock Editionでは、茶色のキノコは、全てボーナスチェストの中に、1–2個生成される。

かまどは、9.9%の確率での家のチェストの中に、1個生成される。

なし[注釈 6]は、18.0%の確率で砂漠の寺院のチェストの中に、7.0%の確率で廃坑チェスト付きトロッコの中に、1個生成される。

アカシアの原木は、28.0%の確率でボーナスチェストの中に、1–3個生成される。

Bedrock Editionでは、これらは、50.0%の確率でボーナスチェストの中に、1–3個生成される。

アカシアの苗木は、71.7%の確率での家のチェストの中に、1–2個生成される。

Bedrock Editionでは、これらは、14.3%の確率でボーナスチェストの中に、4個生成される。

アクティベーターレールは、27.1%の確率で廃坑チェスト付きトロッコの中に、1–4個生成される。

エメラルドは、14.9%の確率で大きな海底遺跡のチェストの中に、24.2%の確率での漁師のチェストの中に、31.8%の確率での防具鍛冶のチェストの中に、12.3%の確率での羊飼いのチェストの中に、10.2%の確率での肉屋のチェストの中に、16.4%の確率で小さな海底遺跡のチェストの中に、12.3%の確率での矢細工師のチェストの中に、7.6%の確率でイグルーのチェストの中に、20.8%の確率での石工のチェストの中に、全て1個生成される。25.4%の確率での寺院のチェストの中に、21.5%の確率での家のチェストの中に、9.9%の確率での家のチェストの中に、22.8%の確率での家のチェストの中に、18.6%の確率での家のチェストの中に、17.3%の確率での革細工師のチェストの中に、全て1–4個生成される。73.7%の確率で難破船のトレジャーチェストの中に、1–5個生成される。53.1%の確率で埋もれた宝のチェストの中に、4–8個生成される。14.3%の確率での家のチェストの中に、8.7%の確率でジャングルの寺院のチェストの中に、18.0%の確率で砂漠の寺院のチェストの中に、全て1–3個生成される。また、9.0%の確率でエンドシティのチェストの中に、2–6個生成される。

Bedrock Editionでは、これらは、7.2%の確率で要塞の祭壇のチェストの中に、8.7%の確率でジャングルの寺院のチェストの中に、1–3個生成される。また、20.3%の確率での家のチェストの中に、1–4個生成される。

エンダーパールは、23.3%の確率で要塞の祭壇のチェストの中に、1個生成される。

Bedrock Editionでは、これらは、22.6%の確率で要塞の祭壇のチェストの中に、1個生成される。

エンチャントされたダイヤモンドのシャベル[注釈 2]は、13.3%の確率でエンドシティのチェストの中に、1つ生成される。

エンチャントされたダイヤモンドのチェストプレート[注釈 2]は、13.3%の確率でエンドシティのチェストの中に、1つ生成される。

エンチャントされたダイヤモンドのツルハシ[注釈 2]は、13.3%の確率でエンドシティのチェストの中に、1つ生成される。

エンチャントされたダイヤモンドのブーツ[注釈 2]は、13.3%の確率でエンドシティのチェストの中に、1つ生成される。

エンチャントされたダイヤモンドのヘルメット[注釈 2]は、13.3%の確率でエンドシティのチェストの中に、1つ生成される。

エンチャントされたダイヤモンドのレギンス[注釈 2]は、13.3%の確率でエンドシティのチェストの中に、1つ生成される。

エンチャントされたダイヤモンドの剣[注釈 2]は、13.3%の確率でエンドシティのチェストの中に、1つ生成される。

エンチャントされた金のリンゴは、3.1%の確率でダンジョンのチェストの中に、2.6%の確率で砂漠の寺院のチェストの中に、1.4%の確率で廃坑チェスト付きトロッコの中に、3.1%の確率で森の洋館のチェストの中に、全て1個生成される。

Bedrock Editionでは、これらは、3.1%の確率で森の洋館のチェストの中に、1個生成される。

エンチャントされた釣竿[注釈 4]は、21.7%の確率で大きな海底遺跡のチェストの中に、41.7%の確率で小さな海底遺跡のチェストの中に、1つ生成される。

エンチャントされた鉄のシャベル[注釈 2]は、13.3%の確率でエンドシティのチェストの中に、1つ生成される。

エンチャントされた鉄のチェストプレート[注釈 2]は、13.3%の確率でエンドシティのチェストの中に、1つ生成される。

エンチャントされた鉄のツルハシ[注釈 2]は、13.3%の確率でエンドシティのチェストの中に、1つ生成される。

エンチャントされた鉄のブーツ[注釈 2]は、13.3%の確率でエンドシティのチェストの中に、1つ生成される。

エンチャントされた鉄のヘルメット[注釈 2]は、13.3%の確率でエンドシティのチェストの中に、1つ生成される。

エンチャントされた鉄のレギンス[注釈 2]は、13.3%の確率でエンドシティのチェストの中に、1つ生成される。

エンチャントされた鉄の剣[注釈 2]は、13.3%の確率でエンドシティのチェストの中に、1つ生成される。

エンチャントされた革のズボン[注釈 4]は、22.4%の確率で難破船のサプライチェストの中に、1つ生成される。

エンチャントされた革のブーツ[注釈 4]は、22.4%の確率で難破船のサプライチェストの中に、1つ生成される。

エンチャントされた革の上着[注釈 4]は、22.4%の確率で難破船のサプライチェストの中に、1つ生成される。

エンチャントされた革の帽子[注釈 4]は、22.4%の確率で難破船のサプライチェストの中に、1つ生成される。

エンチャントの本[注釈 3]は、2.5%の確率で要塞の祭壇のチェストの中に、4.0%の確率で要塞の倉庫のチェストの中に、4.5%の確率でジャングルの寺院のチェストの中に、67.8%の確率で要塞の図書室のチェストの中に、全て1つ生成される。

Bedrock Editionでは、これらは、2.9%の確率で要塞の祭壇のチェストの中に、3.8%の確率で要塞の倉庫のチェストの中に、5.3%の確率でジャングルの寺院のチェストの中に、72.9%の確率で要塞の図書室のチェストの中に、全て1つ生成される。

エンチャントの本[注釈 4]は、21.7%の確率で大きな海底遺跡のチェストの中に、14.9%の確率でダンジョンのチェストの中に、23.5%の確率で砂漠の寺院のチェストの中に、11.0%の確率でピリジャーの前哨基地のチェストの中に、14.1%の確率で廃坑チェスト付きトロッコの中に、14.9%の確率で森の洋館のチェストの中に、全て1つ生成される。

エンチャントの瓶は、14.1%の確率で難破船のトレジャーチェストの中に、60.9%の確率でピリジャーの前哨基地のチェストの中に、1個生成される。

Bedrock Editionでは、これらは、11.8%の確率で埋もれた宝のチェストの中に、1個生成される。

オークの原木は、28.0%の確率でボーナスチェストの中に、1–3個生成される。

Bedrock Editionでは、これらは、25.0%の確率でボーナスチェストの中に、1–3個生成される。

オークの木材は、70.5%の確率でボーナスチェストの中に、1–12個生成される。

Bedrock Editionでは、これらは、全てボーナスチェストの中に、1–12個生成される。

オークの苗木は、48.2%の確率での家のチェストの中に、1–2個生成される。また、25.6%の確率での武器鍛冶のチェストの中に、3–7個生成される。

Bedrock Editionでは、これらは、14.3%の確率でボーナスチェストの中に、4個生成される。また、26.3%の確率での製図家のチェストの中に、1–2個生成される。

カボチャの種は、40.6%の確率での家のチェストの中に、1–5個生成される。また、18.5%の確率でダンジョンのチェストの中に、31.6%の確率で廃坑チェスト付きトロッコの中に、18.5%の確率で森の洋館のチェストの中に、全て2–4個生成される。

Bedrock Editionでは、これらは、33.3%の確率でボーナスチェストの中に、1–2個生成される。また、43.7%の確率での家のチェストの中に、1–5個生成される。

カボチャは、15.6%の確率で難破船のサプライチェストの中に、1–3個生成される。

クモの目は、28.7%の確率で砂漠の寺院のチェストの中に、1–3個生成される。

クロスボウは、全てピリジャーの前哨基地のチェストの中に、1つ生成される。

コンパスは、7.7%の確率で難破船のマップチェストの中に、26.3%の確率での製図家のチェストの中に、10.9%の確率で要塞の図書室のチェストの中に、全て1個生成される。

Bedrock Editionでは、これらは、10.5%の確率で要塞の図書室のチェストの中に、1個生成される。

サボテンは、80.6%の確率での家のチェストの中に、1–4個生成される。

Bedrock Editionでは、これらは、60.0%の確率でボーナスチェストの中に、1–2個生成される。

シダは、18.6%の確率での家のチェストの中に、1個生成される。

Bedrock Editionでは、これらは、20.3%の確率での家のチェストの中に、1個生成される。

シラカバの原木は、28.0%の確率でボーナスチェストの中に、1–3個生成される。

Bedrock Editionでは、これらは、25.0%の確率でボーナスチェストの中に、1–3個生成される。

ジャガイモは、44.9%の確率で難破船のサプライチェストの中に、2–6個生成される。66.3%の確率での家のチェストの中に、74.2%の確率での家のチェストの中に、65.6%の確率での家のチェストの中に、全て1–7個生成される。また、57.5%の確率でピリジャーの前哨基地のチェストの中に、2–5個生成される。

Bedrock Editionでは、これらは、50.0%の確率でボーナスチェストの中に、1–2個生成される。また、69.3%の確率での家のチェストの中に、1–7個生成される。

ジャングルの原木は、28.0%の確率でボーナスチェストの中に、1–3個生成される。

Bedrock Editionでは、これらは、25.0%の確率でボーナスチェストの中に、1–3個生成される。

スイカの種は、18.5%の確率でダンジョンのチェストの中に、31.6%の確率で廃坑チェスト付きトロッコの中に、18.5%の確率で森の洋館のチェストの中に、全て2–4個生成される。

Bedrock Editionでは、これらは、33.3%の確率でボーナスチェストの中に、1–2個生成される。

スイートベリーは、40.6%の確率での家のチェストの中に、1–7個生成される。

タンポポは、22.8%の確率での家のチェストの中に、1個生成される。

ダイヤのクワは、21.8%の確率で森の洋館のチェストの中に、1つ生成される。

Bedrock Editionでは、これらは、21.5%の確率で森の洋館のチェストの中に、1つ生成される。

ダイヤのチェストプレートは、7.7%の確率で森の洋館のチェストの中に、1つ生成される。

Bedrock Editionでは、これらは、7.6%の確率で森の洋館のチェストの中に、1つ生成される。

ダイヤの馬鎧は、2.5%の確率で要塞の祭壇のチェストの中に、5.7%の確率での武器鍛冶のチェストの中に、7.7%の確率でダンジョンのチェストの中に、11.8%の確率でネザー要塞のチェストの中に、4.5%の確率でジャングルの寺院のチェストの中に、6.3%の確率で砂漠の寺院のチェストの中に、4.6%の確率でエンドシティのチェストの中に、全て1つ生成される。

Bedrock Editionでは、これらは、2.4%の確率で要塞の祭壇のチェストの中に、4.4%の確率でジャングルの寺院のチェストの中に、1つ生成される。

ダイヤモンドは、14.1%の確率で難破船のトレジャーチェストの中に、1個生成される。7.4%の確率で要塞の祭壇のチェストの中に、9.9%の確率での道具鍛冶のチェストの中に、16.2%の確率での武器鍛冶のチェストの中に、19.0%の確率でネザー要塞のチェストの中に、12.9%の確率でジャングルの寺院のチェストの中に、6.3%の確率で砂漠の寺院のチェストの中に、全て1–3個生成される。10.4%の確率で廃坑チェスト付きトロッコの中に、53.1%の確率で埋もれた宝のチェストの中に、1–2個生成される。また、21.2%の確率でエンドシティのチェストの中に、2–7個生成される。

Bedrock Editionでは、これらは、46.9%の確率で埋もれた宝のチェストの中に、1個生成される。また、7.2%の確率で要塞の祭壇のチェストの中に、12.8%の確率でジャングルの寺院のチェストの中に、1–3個生成される。

ダークオークの原木は、28.0%の確率でボーナスチェストの中に、1–3個生成される。また、全てピリジャーの前哨基地のチェストの中に、2–3個生成される。

Bedrock Editionでは、これらは、50.0%の確率でボーナスチェストの中に、1–3個生成される。

チェーンのチェストプレートは、14.9%の確率で森の洋館のチェストの中に、1つ生成される。

Bedrock Editionでは、これらは、14.7%の確率で森の洋館のチェストの中に、57.2%の確率で埋もれた宝のチェストの中に、1つ生成される。

ディテクターレールは、27.1%の確率で廃坑チェスト付きトロッコの中に、1–4個生成される。

トリップワイヤーフックは、30.5%の確率でピリジャーの前哨基地のチェストの中に、1–3個生成される。

ニンジンは、44.9%の確率で難破船のサプライチェストの中に、4–8個生成される。また、57.5%の確率でピリジャーの前哨基地のチェストの中に、3–5個生成される。

Bedrock Editionでは、これらは、50.0%の確率でボーナスチェストの中に、1–2個生成される。

ネザーウォートは、19.0%の確率でネザー要塞のチェストの中に、3–7個生成される。

ハサミは、12.3%の確率での羊飼いのチェストの中に、1つ生成される。

バケツは、18.5%の確率でダンジョンのチェストの中に、11.3%の確率での家のチェストの中に、18.5%の確率で森の洋館のチェストの中に、全て1個生成される。

パワードレールは、27.1%の確率で廃坑チェスト付きトロッコの中に、1–4個生成される。

パンは、34.1%の確率でダンジョンのチェストの中に、34.1%の確率で森の洋館のチェストの中に、1個生成される。33.5%の確率で要塞の祭壇のチェストの中に、81.2%の確率での道具鍛冶のチェストの中に、47.5%の確率で要塞の倉庫のチェストの中に、59.8%の確率での武器鍛冶のチェストの中に、44.3%の確率で廃坑チェスト付きトロッコの中に、全て1–3個生成される。61.5%の確率でボーナスチェストの中に、1–2個生成される。また、89.3%の確率での寺院のチェストの中に、80.6%の確率での防具鍛冶のチェストの中に、80.6%の確率での家のチェストの中に、61.2%の確率での製図家のチェストの中に、71.7%の確率での家のチェストの中に、66.3%の確率での家のチェストの中に、74.2%の確率での家のチェストの中に、62.2%の確率での石工のチェストの中に、65.6%の確率での家のチェストの中に、62.8%の確率での革細工師のチェストの中に、全て1–4個生成される。

Bedrock Editionでは、これらは、69.3%の確率での家のチェストの中に、1–4個生成される。全てボーナスチェストの中に、1–2個生成される。また、32.5%の確率で要塞の祭壇のチェストの中に、40.0%の確率で要塞の倉庫のチェストの中に、1–3個生成される。

パンプキンパイは、9.7%の確率での家のチェストの中に、1個生成される。

Bedrock Editionでは、これらは、10.7%の確率での家のチェストの中に、1個生成される。

ビートルートの種は、18.5%の確率でダンジョンのチェストの中に、31.6%の確率で廃坑チェスト付きトロッコの中に、18.5%の確率で森の洋館のチェストの中に、全て2–4個生成される。21.2%の確率でエンドシティのチェストの中に、1–10個生成される。また、66.3%の確率での家のチェストの中に、1–5個生成される。

Bedrock Editionでは、これらは、33.3%の確率でボーナスチェストの中に、1–2個生成される。

ビートルートスープは、9.9%の確率での家のチェストの中に、1つ生成される。

プリズマリンクリスタルは、53.1%の確率で埋もれた宝のチェストの中に、1–5個生成される。

Bedrock Editionでは、これらは、18.9%の確率で埋もれた宝のチェストの中に、1–5個生成される。

ポピーは、12.1%の確率での家のチェストの中に、1個生成される。

マツの原木は、28.0%の確率でボーナスチェストの中に、1–3個生成される。また、65.6%の確率での家のチェストの中に、1–5個生成される。

Bedrock Editionでは、これらは、25.0%の確率でボーナスチェストの中に、1–3個生成される。また、69.3%の確率での家のチェストの中に、1–5個生成される。

マツの看板は、9.7%の確率での家のチェストの中に、1個生成される。

マツの苗木は、40.6%の確率での家のチェストの中に、1–5個生成される。

Bedrock Editionでは、これらは、14.3%の確率でボーナスチェストの中に、4個生成される。また、43.7%の確率での家のチェストの中に、1–5個生成される。

ラピスラズリは、25.4%の確率での寺院のチェストの中に、1–4個生成される。61.5%の確率で難破船のトレジャーチェストの中に、1–10個生成される。また、16.9%の確率で廃坑チェスト付きトロッコの中に、4–9個生成される。

リンゴは、33.5%の確率で要塞の祭壇のチェストの中に、47.5%の確率で要塞の倉庫のチェストの中に、59.8%の確率での武器鍛冶のチェストの中に、70.4%の確率でイグルーのチェストの中に、全て1–3個生成される。74.2%の確率での家のチェストの中に、1–5個生成される。また、83.8%の確率でボーナスチェストの中に、1–2個生成される。

Bedrock Editionでは、これらは、32.5%の確率で要塞の祭壇のチェストの中に、40.0%の確率で要塞の倉庫のチェストの中に、1–3個生成される。また、全てボーナスチェストの中に、1–2個生成される。

リードは、28.3%の確率で森の洋館のチェストの中に、1個生成される。

Bedrock Editionでは、これらは、27.9%の確率で森の洋館のチェストの中に、1個生成される。また、34.3%の確率で埋もれた宝のチェストの中に、1–3個生成される。

レコード(13)は、21.8%の確率でダンジョンのチェストの中に、21.8%の確率で森の洋館のチェストの中に、1つ生成される。

Bedrock Editionでは、これらは、21.5%の確率で森の洋館のチェストの中に、1つ生成される。

レコード(cat)は、21.8%の確率でダンジョンのチェストの中に、21.8%の確率で森の洋館のチェストの中に、1つ生成される。

Bedrock Editionでは、これらは、21.5%の確率で森の洋館のチェストの中に、1つ生成される。

レッドストーンダストは、44.8%の確率での寺院のチェストの中に、26.6%の確率でダンジョンのチェストの中に、26.6%の確率で森の洋館のチェストの中に、全て1–4個生成される。また、12.1%の確率で要塞の祭壇のチェストの中に、18.6%の確率で要塞の倉庫のチェストの中に、16.9%の確率で廃坑チェスト付きトロッコの中に、全て4–9個生成される。

Bedrock Editionでは、これらは、11.8%の確率で要塞の祭壇のチェストの中に、15.2%の確率で要塞の倉庫のチェストの中に、4–9個生成される。

レールは、78.4%の確率で廃坑チェスト付きトロッコの中に、4–8個生成される。

卵は、23.3%の確率での矢細工師のチェストの中に、1–3個生成される。

名札は、28.3%の確率でダンジョンのチェストの中に、42.3%の確率で廃坑チェスト付きトロッコの中に、28.3%の確率で森の洋館のチェストの中に、全て1個生成される。

Bedrock Editionでは、これらは、27.9%の確率で森の洋館のチェストの中に、34.3%の確率で埋もれた宝のチェストの中に、1個生成される。

大きなシダは、18.6%の確率での家のチェストの中に、1個生成される。

Bedrock Editionでは、これらは、20.3%の確率での家のチェストの中に、1個生成される。

宝の地図は、43.5%の確率で大きな海底遺跡のチェストの中に、41.7%の確率で小さな海底遺跡のチェストの中に、全て難破船のマップチェストの中に、全て1個生成される。

小麦の種は、57.5%の確率での漁師のチェストの中に、1–3個生成される。また、71.7%の確率での家のチェストの中に、1–5個生成される。

小麦は、34.1%の確率でダンジョンのチェストの中に、34.1%の確率で森の洋館のチェストの中に、1–4個生成される。80.6%の確率での家のチェストの中に、1–7個生成される。81.0%の確率で大きな海底遺跡のチェストの中に、84.2%の確率で小さな海底遺跡のチェストの中に、55.3%の確率でイグルーのチェストの中に、全て2–3個生成される。48.6%の確率での肉屋のチェストの中に、1–3個生成される。72.5%の確率でピリジャーの前哨基地のチェストの中に、3–5個生成される。44.9%の確率で難破船のサプライチェストの中に、8–21個生成される。また、55.8%の確率での羊飼いのチェストの中に、1–6個生成される。

怪しげなシチュー[注釈 7]は、57.4%の確率で難破船のサプライチェストの中に、1個生成される。

時計は、7.7%の確率で難破船のマップチェストの中に、1個生成される。

木のツルハシは、75.0%の確率でボーナスチェストの中に、1つ生成される。

木の斧は、75.0%の確率でボーナスチェストの中に、1つ生成される。

本は、14.3%の確率での家のチェストの中に、12.1%の確率での家のチェストの中に、1個生成される。89.2%の確率で要塞の図書室のチェストの中に、1–3個生成される。また、34.5%の確率で難破船のマップチェストの中に、1–5個生成される。

Bedrock Editionでは、これらは、88.3%の確率で要塞の図書室のチェストの中に、1–3個生成される。

松明は、65.7%の確率で廃坑チェスト付きトロッコの中に、1–16個生成される。また、11.3%の確率での家のチェストの中に、1–2個生成される。

枯れ木は、26.6%の確率での家のチェストの中に、1–3個生成される。

棒は、90.0%の確率での道具鍛冶のチェストの中に、55.8%の確率での矢細工師のチェストの中に、1–3個生成される。26.3%の確率での製図家のチェストの中に、1–2個生成される。また、70.5%の確率でボーナスチェストの中に、1–12個生成される。

Bedrock Editionでは、これらは、全てボーナスチェストの中に、1–12個生成される。

植木鉢は、20.8%の確率での石工のチェストの中に、1個生成される。

樽は、24.2%の確率での漁師のチェストの中に、1–3個生成される。

水入りバケツは、24.2%の確率での漁師のチェストの中に、1–3つ生成される。

海洋の心は、全て埋もれた宝のチェストの中に、1個生成される。

滑らかな石は、20.8%の確率での石工のチェストの中に、1個生成される。

火打石と打ち金は、19.0%の確率でネザー要塞のチェストの中に、1つ生成される。

火打石は、55.8%の確率での矢細工師のチェストの中に、1–3個生成される。

火薬は、22.4%の確率で難破船のサプライチェストの中に、1–5個生成される。また、57.8%の確率でダンジョンのチェストの中に、59.0%の確率で砂漠の寺院のチェストの中に、57.8%の確率で森の洋館のチェストの中に、全て1–8個生成される。

灰色の羊毛は、23.3%の確率での羊飼いのチェストの中に、1–3個生成される。

焼き鮭は、75.0%の確率で埋もれた宝のチェストの中に、2–4個生成される。

焼き鱈は、75.0%の確率で埋もれた宝のチェストの中に、2–4個生成される。

生の牛肉は、48.6%の確率での肉屋のチェストの中に、1–3個生成される。

生の羊肉は、48.6%の確率での肉屋のチェストの中に、1–3個生成される。

生の豚肉は、48.6%の確率での肉屋のチェストの中に、1–3個生成される。

生鮭は、24.2%の確率での漁師のチェストの中に、1–3個生成される。また、61.5%の確率でボーナスチェストの中に、1–2個生成される。

Bedrock Editionでは、これらは、全てボーナスチェストの中に、1–2個生成される。

生鱈は、43.0%の確率での漁師のチェストの中に、1–3個生成される。

白紙の地図は、7.7%の確率で難破船のマップチェストの中に、10.9%の確率で要塞の図書室のチェストの中に、1個生成される。また、46.2%の確率での製図家のチェストの中に、1–3個生成される。

白色の羊毛は、55.8%の確率での羊飼いのチェストの中に、1–8個生成される。

矢は、23.3%の確率での矢細工師のチェストの中に、1–3個生成される。また、全てジャングルの寺院ディスペンサーの中に、39.1%の確率でピリジャーの前哨基地のチェストの中に、2–7個生成される。

石のツルハシは、25.0%の確率でボーナスチェストの中に、1つ生成される。

石の斧は、30.2%の確率で小さな海底遺跡のチェストの中に、14.7%の確率でイグルーのチェストの中に、25.0%の確率でボーナスチェストの中に、全て1つ生成される。

石は、37.7%の確率での石工のチェストの中に、1個生成される。

石レンガは、37.7%の確率での石工のチェストの中に、1個生成される。

石炭は、43.0%の確率での漁師のチェストの中に、9.9%の確率での道具鍛冶のチェストの中に、27.9%の確率での肉屋のチェストの中に、全て1–3個生成される。40.0%の確率で難破船のサプライチェストの中に、2–8個生成される。81.0%の確率で大きな海底遺跡のチェストの中に、84.2%の確率で小さな海底遺跡のチェストの中に、26.6%の確率でダンジョンのチェストの中に、70.4%の確率でイグルーのチェストの中に、41.2%の確率での家のチェストの中に、26.6%の確率で森の洋館のチェストの中に、全て1–4個生成される。また、34.3%の確率で要塞の倉庫のチェストの中に、31.6%の確率で廃坑チェスト付きトロッコの中に、3–8個生成される。

Bedrock Editionでは、これらは、28.5%の確率で要塞の倉庫のチェストの中に、3–8個生成される。

砂は、59.0%の確率で砂漠の寺院のチェストの中に、1–8個生成される。

竹は、15.6%の確率で難破船のサプライチェストの中に、51.0%の確率でジャングルの寺院のチェストの中に、1–3個生成される。

Bedrock Editionでは、これらは、50.9%の確率でジャングルの寺院のチェストの中に、1–3個生成される。

粘土は、14.3%の確率での家のチェストの中に、1個生成される。また、20.8%の確率での石工のチェストの中に、1–3個生成される。

糸は、39.1%の確率でピリジャーの前哨基地のチェストの中に、1–6個生成される。また、57.8%の確率でダンジョンのチェストの中に、59.0%の確率で砂漠の寺院のチェストの中に、57.8%の確率で森の洋館のチェストの中に、全て1–8個生成される。

紙は、49.4%の確率で難破船のサプライチェストの中に、1–12個生成される。89.4%の確率で難破船のマップチェストの中に、1–10個生成される。89.2%の確率で要塞の図書室のチェストの中に、2–7個生成される。また、61.2%の確率での製図家のチェストの中に、1–5個生成される。

Bedrock Editionでは、これらは、88.3%の確率で要塞の図書室のチェストの中に、2–7個生成される。

緑色の染料は、14.3%の確率での家のチェストの中に、1個生成される。

羽根は、12.1%の確率での家のチェストの中に、1個生成される。55.8%の確率での矢細工師のチェストの中に、1–3個生成される。また、60.0%の確率で難破船のマップチェストの中に、1–5個生成される。

腐った肉は、59.6%の確率で小さな海底遺跡のチェストの中に、55.3%の確率でイグルーのチェストの中に、1個生成される。89.3%の確率での寺院のチェストの中に、1–4個生成される。57.8%の確率でダンジョンのチェストの中に、59.0%の確率で砂漠の寺院のチェストの中に、57.8%の確率で森の洋館のチェストの中に、全て1–8個生成される。34.6%の確率で難破船のサプライチェストの中に、5–24個生成される。また、53.4%の確率でジャングルの寺院のチェストの中に、28.7%の確率で砂漠の寺院のチェストの中に、3–7個生成される。

Bedrock Editionでは、これらは、53.3%の確率でジャングルの寺院のチェストの中に、3–7個生成される。

茶色の羊毛は、23.3%の確率での羊飼いのチェストの中に、1–3個生成される。

草は、45.9%の確率での家のチェストの中に、1個生成される。

薄灰色の羊毛は、23.3%の確率での羊飼いのチェストの中に、1–3個生成される。

金のチェストプレートは、19.0%の確率でネザー要塞のチェストの中に、1つ生成される。

金のヘルメットは、4.3%の確率で大きな海底遺跡のチェストの中に、8.3%の確率で小さな海底遺跡のチェストの中に、1つ生成される。

金のリンゴは、2.5%の確率で要塞の祭壇のチェストの中に、4.3%の確率で大きな海底遺跡のチェストの中に、21.8%の確率でダンジョンのチェストの中に、全てイグルーのチェストの中に、23.5%の確率で砂漠の寺院のチェストの中に、28.2%の確率で廃坑チェスト付きトロッコの中に、21.8%の確率で森の洋館のチェストの中に、全て1個生成される。

Bedrock Editionでは、これらは、2.4%の確率で要塞の祭壇のチェストの中に、21.5%の確率で森の洋館のチェストの中に、1個生成される。

金の剣は、19.0%の確率でネザー要塞のチェストの中に、1つ生成される。

金の馬鎧は、2.5%の確率で要塞の祭壇のチェストの中に、5.7%の確率での武器鍛冶のチェストの中に、14.9%の確率でダンジョンのチェストの中に、29.1%の確率でネザー要塞のチェストの中に、4.5%の確率でジャングルの寺院のチェストの中に、12.3%の確率で砂漠の寺院のチェストの中に、4.6%の確率でエンドシティのチェストの中に、全て1つ生成される。

Bedrock Editionでは、これらは、2.4%の確率で要塞の祭壇のチェストの中に、4.4%の確率でジャングルの寺院のチェストの中に、1つ生成される。

金インゴットは、25.4%の確率での寺院のチェストの中に、9.6%の確率でダンジョンのチェストの中に、9.6%の確率で森の洋館のチェストの中に、88.0%の確率で埋もれた宝のチェストの中に、全て1–4個生成される。26.5%の確率で難破船のトレジャーチェストの中に、1–5個生成される。51.0%の確率でジャングルの寺院のチェストの中に、18.0%の確率で砂漠の寺院のチェストの中に、52.3%の確率でエンドシティのチェストの中に、全て2–7個生成される。また、12.1%の確率で要塞の祭壇のチェストの中に、9.9%の確率での道具鍛冶のチェストの中に、18.6%の確率で要塞の倉庫のチェストの中に、25.6%の確率での武器鍛冶のチェストの中に、49.0%の確率でネザー要塞のチェストの中に、16.9%の確率で廃坑チェスト付きトロッコの中に、全て1–3個生成される。

Bedrock Editionでは、これらは、11.8%の確率で要塞の祭壇のチェストの中に、15.2%の確率で要塞の倉庫のチェストの中に、1–3個生成される。34.3%の確率で埋もれた宝のチェストの中に、1–5個生成される。また、50.9%の確率でジャングルの寺院のチェストの中に、2–7個生成される。

金塊は、81.0%の確率で大きな海底遺跡のチェストの中に、55.3%の確率でイグルーのチェストの中に、11.3%の確率での家のチェストの中に、12.1%の確率での家のチェストの中に、全て1–3個生成される。また、36.6%の確率で難破船のトレジャーチェストの中に、1–10個生成される。

鉄のシャベルは、41.2%の確率での道具鍛冶のチェストの中に、1つ生成される。

鉄のチェストプレートは、12.1%の確率で要塞の祭壇のチェストの中に、25.6%の確率での武器鍛冶のチェストの中に、1つ生成される。

Bedrock Editionでは、これらは、11.8%の確率で要塞の祭壇のチェストの中に、1つ生成される。

鉄のツルハシは、12.1%の確率で要塞の祭壇のチェストの中に、41.2%の確率での道具鍛冶のチェストの中に、4.0%の確率で要塞の倉庫のチェストの中に、25.6%の確率での武器鍛冶のチェストの中に、7.0%の確率で廃坑チェスト付きトロッコの中に、全て1つ生成される。

Bedrock Editionでは、これらは、11.8%の確率で要塞の祭壇のチェストの中に、3.2%の確率で要塞の倉庫のチェストの中に、1つ生成される。

鉄のブーツは、12.1%の確率で要塞の祭壇のチェストの中に、25.6%の確率での武器鍛冶のチェストの中に、1つ生成される。

Bedrock Editionでは、これらは、11.8%の確率で要塞の祭壇のチェストの中に、1つ生成される。

鉄のヘルメットは、12.1%の確率で要塞の祭壇のチェストの中に、31.8%の確率での防具鍛冶のチェストの中に、25.6%の確率での武器鍛冶のチェストの中に、全て1つ生成される。

Bedrock Editionでは、これらは、11.8%の確率で要塞の祭壇のチェストの中に、1つ生成される。

鉄のレギンスは、12.1%の確率で要塞の祭壇のチェストの中に、25.6%の確率での武器鍛冶のチェストの中に、1つ生成される。

Bedrock Editionでは、これらは、11.8%の確率で要塞の祭壇のチェストの中に、1つ生成される。

鉄の剣は、12.1%の確率で要塞の祭壇のチェストの中に、25.6%の確率での武器鍛冶のチェストの中に、75.0%の確率で埋もれた宝のチェストの中に、全て1つ生成される。

Bedrock Editionでは、これらは、11.8%の確率で要塞の祭壇のチェストの中に、1つ生成される。

鉄の馬鎧は、2.5%の確率で要塞の祭壇のチェストの中に、5.7%の確率での武器鍛冶のチェストの中に、21.8%の確率でダンジョンのチェストの中に、19.0%の確率でネザー要塞のチェストの中に、4.5%の確率でジャングルの寺院のチェストの中に、18.0%の確率で砂漠の寺院のチェストの中に、4.6%の確率でエンドシティのチェストの中に、全て1つ生成される。

Bedrock Editionでは、これらは、2.4%の確率で要塞の祭壇のチェストの中に、4.4%の確率でジャングルの寺院のチェストの中に、1つ生成される。

鉄インゴットは、54.2%の確率での防具鍛冶のチェストの中に、30.5%の確率でピリジャーの前哨基地のチェストの中に、1–3個生成される。23.3%の確率で要塞の祭壇のチェストの中に、41.2%の確率での道具鍛冶のチェストの中に、97.4%の確率で難破船のトレジャーチェストの中に、34.3%の確率で要塞の倉庫のチェストの中に、45.1%の確率での武器鍛冶のチェストの中に、19.0%の確率でネザー要塞のチェストの中に、37.4%の確率でジャングルの寺院のチェストの中に、18.0%の確率で砂漠の寺院のチェストの中に、31.6%の確率で廃坑チェスト付きトロッコの中に、全て1–5個生成される。38.4%の確率でエンドシティのチェストの中に、4–8個生成される。また、18.5%の確率でダンジョンのチェストの中に、18.5%の確率で森の洋館のチェストの中に、99.4%の確率で埋もれた宝のチェストの中に、全て1–4個生成される。

Bedrock Editionでは、これらは、57.2%の確率で埋もれた宝のチェストの中に、3–5個生成される。また、22.6%の確率で要塞の祭壇のチェストの中に、28.5%の確率で要塞の倉庫のチェストの中に、37.3%の確率でジャングルの寺院のチェストの中に、全て1–5個生成される。

鉄塊は、9.7%の確率での家のチェストの中に、1–5個生成される。また、94.5%の確率で難破船のトレジャーチェストの中に、1–10個生成される。

Bedrock Editionでは、これらは、10.7%の確率での家のチェストの中に、1–5個生成される。

雪ブロックは、34.5%の確率での家のチェストの中に、1個生成される。

雪玉は、66.3%の確率での家のチェストの中に、1–7個生成される。

青くなったジャガイモは、44.9%の確率で難破船のサプライチェストの中に、2–6個生成される。

青氷は、9.9%の確率での家のチェストの中に、1個生成される。

革のズボンは、31.8%の確率での革細工師のチェストの中に、1つ生成される。

革のブーツは、31.8%の確率での革細工師のチェストの中に、1つ生成される。

革の上着は、4.3%の確率で大きな海底遺跡のチェストの中に、8.3%の確率で小さな海底遺跡のチェストの中に、75.0%の確率で埋もれた宝のチェストの中に、31.8%の確率での革細工師のチェストの中に、全て1つ生成される。

革の帽子は、31.8%の確率での革細工師のチェストの中に、1つ生成される。

革は、17.3%の確率での革細工師のチェストの中に、1–3個生成される。

鞍は、2.5%の確率で要塞の祭壇のチェストの中に、16.2%の確率での武器鍛冶のチェストの中に、28.3%の確率でダンジョンのチェストの中に、11.3%の確率での家のチェストの中に、35.3%の確率でネザー要塞のチェストの中に、12.9%の確率でジャングルの寺院のチェストの中に、23.5%の確率で砂漠の寺院のチェストの中に、13.3%の確率でエンドシティのチェストの中に、17.3%の確率での革細工師のチェストの中に、全て1つ生成される。

Bedrock Editionでは、これらは、2.4%の確率で要塞の祭壇のチェストの中に、12.8%の確率でジャングルの寺院のチェストの中に、1つ生成される。

骨は、61.9%の確率でジャングルの寺院のチェストの中に、28.7%の確率で砂漠の寺院のチェストの中に、4–6個生成される。また、57.8%の確率でダンジョンのチェストの中に、59.0%の確率で砂漠の寺院のチェストの中に、57.8%の確率で森の洋館のチェストの中に、全て1–8個生成される。

Bedrock Editionでは、これらは、61.8%の確率でジャングルの寺院のチェストの中に、4–6個生成される。

高い草は、45.9%の確率での家のチェストの中に、1個生成される。

黄色の染料は、20.8%の確率での石工のチェストの中に、1個生成される。

黒曜石は、8.0%の確率でネザー要塞のチェストの中に、2–4個生成される。また、25.6%の確率での武器鍛冶のチェストの中に、3–7個生成される。

黒色の羊毛は、33.0%の確率での羊飼いのチェストの中に、1–3個生成される。


注釈[ソースを編集]

  1. 全てのエンチャントの付与される確率は同じであり、宝のエンチャントを含む全てのエンチャントのレベルは等しくなる。
  2. a b c d e f g h i j k l m n エンチャントの確率はレベル30の上限を持たないエンチャントテーブルでレベル20からレベル39のエンチャントをした時と同じで、宝のエンチャントが付く場合があり、エンチャントが複数される確率は減少していない。
  3. エンチャントの確率はエンチャントテーブルでレベル30のエンチャントをした時と同じで、宝のエンチャントが付く場合があり、エンチャントが複数される確率は減少していない。
  4. a b c d e f 全てのエンチャントの付与される確率は同じであり、宝のエンチャントを除いてエンチャントのレベルは等しくなる。
  5. Named unknown map, but changed to map 0, the scale level is 1:4, Maps from the same stack are stackable, but maps which are not stacked are unstackable despite looking identical.
  6. 「なし」はチェストが空だということではなく、ランダムな戦利品の生成が行われない可能性があることを指す。
  7. シチューからは、以下のステータス効果から1つが付与される: 盲目 5〜7秒、跳躍力上昇 7〜10秒、 10〜20秒、満腹度回復 7〜10秒、移動速度上昇 7〜10秒、弱体化 6〜8秒。
[閲覧 | 編集 | 履歴 | キャッシュ破棄]上記の解説は、モジュール:LootChest/docから参照されています。
local p = {

	calc_average_amount_this_item_per_pool = function( 
			min_stacksize, max_stacksize,
			min_pool_rolls, max_pool_rolls, 
			item_weight, pool_total_item_weight )

		local avg_stacksize = ( min_stacksize + max_stacksize ) / 2
		local avg_rolls = ( min_pool_rolls + max_pool_rolls ) / 2
		
		return avg_stacksize * avg_rolls * item_weight / pool_total_item_weight
		
	end,
	
	calc_chance_any_of_this_item_per_pool = function( 
			min_pool_rolls, max_pool_rolls,
			item_weight, pool_total_item_weight )

		local inverse_result = 0 -- 1 - inverse_result = return value
		local inverse_item_weight = pool_total_item_weight - item_weight
		
		-- will be used for the division in the for loop to avoid the slightly
		-- less performant math.pow(). The divisor already includes the probability
		-- of picking any specific number of rolls.
		local cur_dividend = inverse_item_weight
		local cur_divisor = pool_total_item_weight * (max_pool_rolls - min_pool_rolls + 1)
		
		for i = 1, max_pool_rolls do
			if i >= min_pool_rolls then
				inverse_result = inverse_result + cur_dividend / cur_divisor
			end
			cur_dividend = cur_dividend * inverse_item_weight -- simulate pow
			cur_divisor = cur_divisor * pool_total_item_weight -- simulate pow
		end
		
		return 1 - inverse_result
		
	end,
	
	java = '[[Java Edition]]では、[[カテゴリ:Java Edition限定]]',
	['java-upcoming'] = '[[Java Edition 1.15]]{{upcoming}}では、[[カテゴリ:Java Edition限定]]',
	bedrock = '[[Bedrock Edition]]では、[[カテゴリ:Bedrock Edition限定]]',
	['bedrock-upcoming'] = '[[Bedrock Edition 1.14]]{{upcoming}}では、[[カテゴリ:Bedrock Edition限定]]',
	
	-- These 'items' define which sprite, label and link to use in the table.
	-- Properties 'cannot_stack', 'preserve_case', and 'plural' describe how to display the single-item summary in p.base2.
	-- Order within this 'items' list doesn't matter.

	items = {
		["acacia-log"]          = { "block", link="原木" },
		["acacia-sapling"]      = { "block", link="苗木" },
		["activator-rail"]      = { "block" },
		["apple"]               = { "item" },
		["arrow"]               = { "item" },
		["bamboo"]              = { "item", plural=false },
		["barrel"]              = { "block" },
		["beetroot"]            = { "item" },
		["beetroot-seeds"]      = { "item", plural=false },
		["beetroot-soup"]		= { "item", plural=false, cannot_stack=true },
		["birch-log"]           = { "block", link="原木" },
		["birch-sapling"]       = { "block", link="苗木" },
		["black-wool"]          = { "block", link="羊毛", plural=false },
		["blue-ice"]			= { "block" },
		["bone"]                = { "item" },
		["book"]                = { "item" },
		["book-and-quill"]      = { "item", plural=false, title="本と羽根ペン" },
		["bottle-o'-enchanting"] = { "item", title="エンチャントの瓶" },
		["bread"]               = { "item", plural=false },
		["brown-mushroom"]      = { "block", link="キノコ" },
		["brown-wool"]          = { "block", link="羊毛", plural=false },
		["bucket"]              = { "item" },
		["buried-treasure-map"] = { "item", link="探検家の地図" },
		["cactus"]              = { "block", plural=false },
		["cake"]                = { "block", plural=false },
		["carrot"]              = { "item" },
		["chainmail-boots"]     = { "item", link="防具", cannot_stack=true, plural=false },
		["chainmail-chestplate"] = { "item", link="防具", cannot_stack=true },
		["chainmail-helmet"]    = { "item", link="防具", cannot_stack=true },
		["chainmail-leggings"]  = { "item", link="防具", cannot_stack=true, plural=false },
		["clay"]				= { "item" },
		["clock"]				= { "item" },
		["coal"]                = { "item", plural=false },
		["cocoa-beans"]         = { "item", plural=false },
		["cooked-cod"]          = { "item", plural=false, link="焼き鱈" },
		["cooked-salmon"]       = { "item", plural=false, link="焼き鮭" },
		["compass"]             = { "item" },
		["crossbow"]            = { "item", cannot_stack=true },
		["dandelion"]			= { "block", link="花" },
		["dark-oak-log"]        = { "block", link="原木" },
		["dark-oak-sapling"]    = { "block", link="苗木" },
		["dead-bush"]			= { "block", link="枯れ木" },
		["detector-rail"]       = { "block" },
		["diamond"]             = { "item" },
		["diamond-chestplate"]  = { "item", link="防具", cannot_stack=true },
		["diamond-hoe"]         = { "item", link="クワ", cannot_stack=true },
		["diamond-horse-armor"] = { "item", link="馬鎧", cannot_stack=true, plural=false },
		["disc-13"]             = { "item", id='music-disc-13', title="レコード(13)", link="レコード", cannot_stack=true, plural=false },
		["disc-cat"]            = { "item", id='music-disc-cat', title="レコード(Cat)", link="レコード", cannot_stack=true, plural=false },
		["disc-mellohi"]        = { "item", id='music-disc-mellohi', title="レコード(Mellohi)", link="レコード", cannot_stack=true, plural=false },
		["disc-wait"]           = { "item", id='music-disc-wait', title="レコード(Wait)", link="レコード", cannot_stack=true, plural=false },
		["egg"]                 = { "item" },
		["emerald"]             = { "item" },
		["empty-map"]           = { "item", link="地図", title="白紙の地図" },
		["enchanted-book"]      = { "item", id='enchanted-book', title="エンチャントの本", link="エンチャントの本", cannot_stack=true, note="enchant-with-levels-30" },
		["enchanted-book-rnd"]  = { "item", id='enchanted-book', title="エンチャントの本", link="エンチャントの本", cannot_stack=true, note="enchant-randomly" },
		["enchanted-book-rnd-treasure"] = { "item", id='enchanted-book', title="エンチャントの本", link="エンチャントの本", cannot_stack=true, note="enchant-randomly-treasure" },
		["enchanted-fishing-rod"] = { "item", id="fishing-rod", link="釣竿", cannot_stack=true, note="enchant-randomly", title="エンチャントされた釣竿" },
		["enchanted-golden-apple"] = { "item", id='golden-apple', link="金のリンゴ" },
		["ender-pearl"]         = { "item" },
		["feather"]             = { "item" },
		["fern"]				= { "block", link="草" },
		["flint"]               = { "item", plural=false },
		["flint-and-steel"]     = { "item", cannot_stack=true, plural=false },
		["flower-pot"]			= { "item" },
		["furnace"]             = { "block" },
		["golden-apple"]        = { "item" },
		["golden-chestplate"]   = { "item", link="防具", cannot_stack=true },
		["golden-helmet"]       = { "item", link="防具", cannot_stack=true },
		["golden-horse-armor"]  = { "item", link="馬鎧", cannot_stack=true, plural=false },
		["golden-sword"]        = { "item", link="剣", cannot_stack=true },
		["gold-ingot"]          = { "item" },
		["gold-nugget"]         = { "item" },
		["grass"]				= { "block", link="草" },
		["gray-wool"]           = { "block", link="羊毛", plural=false },
		["green-dye"]			= { "item", link="染料" },
		["gunpowder"]           = { "item", plural=false },
		["heart-of-the-sea"]    = { "item", plural=false, link="海洋の心" },
		["ink-sac"]             = { "item" },
		["iron-boots"]          = { "item", link="防具", cannot_stack=true, plural=false },
		["iron-chestplate"]     = { "item", link="防具", cannot_stack=true },
		["iron-helmet"]         = { "item", link="防具", cannot_stack=true },
		["iron-horse-armor"]    = { "item", link="馬鎧", cannot_stack=true, plural=false },
		["iron-ingot"]          = { "item" },
		["iron-leggings"]       = { "item", link="防具", cannot_stack=true, plural=false },
		["iron-nugget"]         = { "item" },
		["iron-pickaxe"]        = { "item", link="ツルハシ", cannot_stack=true },
		["iron-shovel"]         = { "item", link="シャベル", cannot_stack=true },
		["iron-sword"]          = { "item", link="剣", cannot_stack=true },
		["jungle-log"]          = { "block", link="原木" },
		["jungle-sapling"]      = { "block", link="苗木" },
		["lapis-lazuli"]        = { "item", plural=false },
		["large-fern"]			= { "block", link="草" },
		["lead"]                = { "item" },
		["leather"]      		= { "item", plural=false },
		["leather-boots"]       = { "item", link="防具", cannot_stack=true, plural=false },
		["leather-cap"]         = { "item", link="防具", cannot_stack=true },
		["leather-pants"]       = { "item", link="防具", cannot_stack=true, plural=false },
		["leather-tunic"]       = { "item", link="防具", cannot_stack=true },
		["light-gray-wool"]     = { "block", link="羊毛", plural=false },
		["melon-seeds"]         = { "item", plural=false },
		["name-tag"]            = { "item" },
		["nether-wart"]         = { "item", plural=false },
		["oak-log"]             = { "block", link="原木" },
		["oak-planks"]          = { "block", link="木材", id="oak-wood-planks", plural=false },
		["oak-sapling"]         = { "block", link="苗木" },
		["oak-sign"]            = { "item", link="看板" },
		["obsidian"]            = { "block", plural=false },
		["paper"]               = { "item", plural=false },
		["poisonous-potato"]    = { "item" },
		["poppy"]				= { "block", link="Flower" },
		["potato"]              = { "item" },
		["potion-of-regeneration"] = { "item", link="ポーション", title="再生のポーション", plural=false, preserve_case=true },
		["potion-of-water-breathing"] = { "item", link="ポーション", title="水中呼吸のポーション", plural=false, preserve_case=true },
		["powered-rail"]        = { "block", title="パワードレール", plural=false },
		["prismarine-crystals"] = { "item", plural=false },
		["pumpkin"]             = { "block" },
		["pumpkin-pie"]         = { "item" },
		["pumpkin-seeds"]       = { "item", plural=false },
		["rail"]                = { "block", title="レール", plural=false },
		["raw-beef"]		    = { "item", link="生の牛肉", plural=false },
		["raw-cod"]             = { "item", link="生鱈", plural=false },
		["raw-mutton"]			= { "item", link="生の羊肉" },
		["raw-porkchop"]		= { "item", link="生の豚肉" },
		["raw-salmon"]          = { "item", link="生鮭", plural=false },
		["redstone"]            = { "item", id="redstone-dust", title="レッドストーンダスト", plural=false },
		["rotten-flesh"]        = { "item", plural=false },
		["saddle"]              = { "item", cannot_stack=true },
		["sand"]                = { "block", plural=false },
		["shears"]              = { "item", plural=false, cannot_stack=true },
		["smooth-stone"]		= { "block", plural=false },
		["snowball"]			= { "item", link="雪玉" },
		["snow-block"]			= { "block", link="雪ブロック" },
		["spider-eye"]          = { "item" },
		["spruce-log"]          = { "block", link="原木" },
		["spruce-sapling"]      = { "block", link="苗木" },
		["spruce-sign"]     	= { "item", link="看板" },
		["stick"]               = { "item" },
		["stone"]               = { "block", plural=false },
		["stone-axe"]           = { "item", link="斧", cannot_stack=true },
		["stone-bricks"]        = { "block", plural=false },
		["stone-pickaxe"]       = { "item", link="ツルハシ", cannot_stack=true },
		["string"]              = { "item", plural=false },
		["suspicious-stew"]     = { "item", plural=false, note="suspicious-stew" },
		["sweet-berries"]       = { "item", plural=false },
		["tall-grass"]			= { "block", link="草" },
		["tnt"]                 = { "block", title="TNT", plural=false, preserve_case=true },
		["torch"]               = { "block" },
		["tripwire-hook"]       = { "block" },
		["water-bucket"]        = { "item", cannot_stack=true },
		["wheat"]               = { "item", plural=false },
		["wheat-seeds"]         = { "item", plural=false },
		["white-wool"]          = { "block", link="羊毛", plural=false },
		["wooden-axe"]          = { "item", link="斧", cannot_stack=true },
		["wooden-hoe"]          = { "item", link="クワ", cannot_stack=true },
		["wooden-pickaxe"]      = { "item", link="ツルハシ", cannot_stack=true },
		["yellow-dye"]			= { "item", link="染料", plural=false },
		["map"]                 = { "item", link="地図", note="map" },

		["enchanted-diamond-boots"]      = { "item", id="diamond-boots", link="防具", title="エンチャントされたダイヤモンドのブーツ", note="enchant-with-levels-20-39", cannot_stack=true, plural=false },
		["enchanted-diamond-chestplate"] = { "item", id="diamond-chestplate", link="防具", title="エンチャントされたダイヤモンドのチェストプレート", note="enchant-with-levels-20-39", cannot_stack=true },
		["enchanted-diamond-helmet"]     = { "item", id="diamond-helmet", link="防具", title="エンチャントされたダイヤモンドのヘルメット", note="enchant-with-levels-20-39", cannot_stack=true },
		["enchanted-diamond-leggings"]   = { "item", id="diamond-leggings", link="防具", title="エンチャントされたダイヤモンドのレギンス", note="enchant-with-levels-20-39", cannot_stack=true, plural=false },
		["enchanted-diamond-pickaxe"]    = { "item", id="diamond-pickaxe", link="ツルハシ", title="エンチャントされたダイヤモンドのツルハシ", note="enchant-with-levels-20-39", cannot_stack=true },
		["enchanted-diamond-shovel"]     = { "item", id="diamond-shovel", link="シャベル", title="エンチャントされたダイヤモンドのシャベル", note="enchant-with-levels-20-39", cannot_stack=true },
		["enchanted-diamond-sword"]      = { "item", id="diamond-sword", link="剣", title="エンチャントされたダイヤモンドの剣", note="enchant-with-levels-20-39", cannot_stack=true },
		["enchanted-iron-boots"]         = { "item", id="iron-boots", link="防具", title="エンチャントされた鉄のブーツ", note="enchant-with-levels-20-39", cannot_stack=true, plural=false },
		["enchanted-iron-chestplate"]    = { "item", id="iron-chestplate", link="防具", title="エンチャントされた鉄のチェストプレート", note="enchant-with-levels-20-39", cannot_stack=true },
		["enchanted-iron-helmet"]        = { "item", id="iron-helmet", link="防具", title="エンチャントされた鉄のヘルメット", note="enchant-with-levels-20-39", cannot_stack=true },
		["enchanted-iron-leggings"]      = { "item", id="iron-leggings", link="防具", title="エンチャントされた鉄のレギンス", note="enchant-with-levels-20-39", cannot_stack=true, plural=false },
		["enchanted-iron-pickaxe"]       = { "item", id="iron-pickaxe", link="ツルハシ", title="エンチャントされた鉄のツルハシ", note="enchant-with-levels-20-39", cannot_stack=true },
		["enchanted-iron-shovel"]        = { "item", id="iron-shovel", link="シャベル", title="エンチャントされた鉄のシャベル", note="enchant-with-levels-20-39", cannot_stack=true },
		["enchanted-iron-sword"]         = { "item", id="iron-sword", link="剣", title="エンチャントされた鉄の剣", note="enchant-with-levels-20-39", cannot_stack=true },
		["enchanted-leather-boots"]      = { "item", id="leather-boots", link="防具", title="エンチャントされた革のブーツ", note="enchant-randomly", cannot_stack=true, plural=false },
		["enchanted-leather-cap"]        = { "item", id="leather-cap", link="防具", title="エンチャントされた革の帽子", note="enchant-randomly", cannot_stack=true },
		["enchanted-leather-pants"]      = { "item", id="leather-pants", link="防具", title="エンチャントされた革のズボン", note="enchant-randomly", cannot_stack=true, plural=false },
		["enchanted-leather-tunic"]      = { "item", id="leather-tunic", link="防具", title="エンチャントされた革の上着", note="enchant-randomly", cannot_stack=true },

		["empty"]                        = { "block", id="air", link='', title='なし', plural=false, note="nothing" },
	},

	notes = {
		["enchant-randomly"] = "全てのエンチャントの付与される確率は同じであり、[[宝のエンチャント]]を除いてエンチャントのレベルは等しくなる。",
		["enchant-randomly-treasure"] = "全てのエンチャントの付与される確率は同じであり、[[宝のエンチャント]]を含む全てのエンチャントのレベルは等しくなる。",
		["enchant-with-levels-20-39"] = "エンチャントの確率はレベル30の上限を持たない[[エンチャントテーブル]]でレベル20からレベル39の[[エンチャントの仕組み|エンチャント]]をした時と同じで、[[宝のエンチャント]]が付く場合があり、エンチャントが複数される確率は減少していない。",
		["enchant-with-levels-30"] = "エンチャントの確率は[[エンチャントテーブル]]でレベル30のエンチャントをした時と同じで、[[宝のエンチャント]]が付く場合があり、エンチャントが複数される確率は減少していない。",
		["nothing"] = "「なし」はチェストが空だということではなく、ランダムな戦利品の生成が行われない可能性があることを指す。",
		["suspicious-stew"] = "シチューからは、以下のステータス効果から1つが付与される: [[盲目]] 5〜7秒、[[跳躍力上昇]] 7〜10秒、[[毒]] 10〜20秒、[[満腹度回復]] 7〜10秒、[[移動速度上昇]] 7〜10秒、[[弱体化]] 6〜8秒。",
		["map"] = "Named unknown map, but changed to map 0, the scale level is 1:4, Maps from the same stack are stackable, but maps which are not stacked are unstackable despite looking identical."
	},

	-- <ref group='注釈' name='enchant-randomly'>
	
	-- NOTE: order here doesn't matter.  
	--		 * in the table, chests will sort in alphabetical order
	--       * in the table, items will sort by chance, then by avg#, then alphabetically.
	--       * If poolsJavaUpcoming is omitted, poolsJava will be used. To omit a pool entirely, set it to {}.
	--       * If poolsBedrock is omitted, it implies that Bedrock has the same pools as Java.  This is a shortcoming; it ought to be made explicit somehow.
	
	chests = {
		["shipwreck-map"] = { -- shipwreck_map.json
			header = "Map",
			superheader = "[[難破船]]",
			link   = "[[難破船]]のマップチェスト",
			structure = "難破船",
			container = "マップチェスト",
			structID = "shipwreck",
			chest_type = "shipwreck", -- 日本語対応
			poolsJava = {
				{
					rolls = {1,1},
					items = {
						["buried-treasure-map"] = {1,1,1},
					}
				},
				{
					rolls = {3,3},
					items = {
						["compass"]             = {1,1,1},
						["empty-map"]           = {1,1,1},
						["clock"]               = {1,1,1},
						["paper"]               = {1,10,20},
						["feather"]             = {1,5,10},
						["book"]                = {1,5,5},
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {
				{
					rolls = {1,1},
					items = {
						["buried-treasure-map"] = {1,1,1},
					}
				},
				{
					rolls = {3,3},
					items = {
						["compass"]             = {1,1,1},
						["map"]                 = {1,1,1},
						["clock"]               = {1,1,1},
						["paper"]               = {1,10,20},
						["feather"]             = {1,5,10},
						["book"]                = {1,5,5},
					}
				},
			},
			poolsBedrockUpcoming = {}
		},
		["shipwreck-supply"] = { -- shipwreck_supply.json
			header = "Supply",
			superheader = "[[難破船]]",
			link   = "[[難破船]]のサプライチェスト",
			structure = "難破船",
			container = "サプライチェスト",
			structID = "shipwreck",
			chest_type = "shipwreck", -- 日本語対応
			poolsJava = {
				{
					rolls = {3,10},
					items = {
						["paper"]               = {1,12,8},
						["potato"]              = {2,6,7},
						["poisonous-potato"]    = {2,6,7},
						["carrot"]              = {4,8,7},
						["wheat"]               = {8,21,7},
						["coal"]                = {2,8,6},
						["rotten-flesh"]        = {5,24,5},
						["bamboo"]              = {1,3,2},
						["suspicious-stew"]     = {1,1,10},
						["pumpkin"]             = {1,3,2},
						["gunpowder"]           = {1,5,3},
						["tnt"]                 = {1,2,1},
						["enchanted-leather-cap"]         = {1,1,3},
						["enchanted-leather-tunic"]       = {1,1,3},
						["enchanted-leather-pants"]       = {1,1,3},
						["enchanted-leather-boots"]       = {1,1,3},
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["shipwreck-treasure"] = { -- shipwreck_treasure.json
			header = "Treasure",
			superheader = "[[難破船]]",
			link   = "[[難破船]]のトレジャーチェスト",
			structure = "難破船",
			container = "トレジャーチェスト",
			structID = "shipwreck",
			chest_type = "shipwreck", -- 日本語対応
			poolsJava = {
				{
					rolls = {3,6},
					items = {
						["iron-ingot"]          = {1,5,90},
						["gold-ingot"]          = {1,5,10},
						["emerald"]             = {1,5,40},
						["diamond"]             = {1,1,5},
						["bottle-o'-enchanting"] = {1,1,5},
					}
				},
				{
					rolls = {2,5},
					items = {
						["iron-nugget"]         = {1,10,50},
						["gold-nugget"]         = {1,10,10},
						["lapis-lazuli"]        = {1,10,20},
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["buried-treasure"] = { -- buried_treasure.json
			header = "[[埋もれた宝]]",
			link   = "[[埋もれた宝]]",
			structure = "埋もれた宝",
			container = "",
			structID = "buried-treasure",
			poolsJava = {
				{
					rolls = {1,1},
					items = {
						["heart-of-the-sea"]    = {1,1,1},
					}
				},
				{
					rolls = {5,8},
					items = {
						["iron-ingot"]          = {1,4,20},
						["gold-ingot"]          = {1,4,10},
						["tnt"]                 = {1,2,5},
					}
				},
				{
					rolls = {1,3},
					items = {
						["emerald"]             = {4,8,5},
						["diamond"]             = {1,2,5},
						["prismarine-crystals"] = {1,5,5},
					}
				},
				{
					rolls = {0,1},
					items = {
						["leather-tunic"]       = {1,1,1},
						["iron-sword"]          = {1,1,1},
					}
				},
				{
					rolls = {2,2},
					items = {
						["cooked-cod"]          = {2,4,1},
						["cooked-salmon"]       = {2,4,1},
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {
				{
					rolls = {1,1},
					items = {
						["heart-of-the-sea"]    = {1,1,1},
					}
				},
				{
					rolls = {5,12},
					items = {
						["prismarine-crystals"] = {1,5,5},
						["iron-ingot"]          = {3,5,20},
						["gold-ingot"]          = {1,5,10},
						["tnt"]                 = {1,2,10},
						["diamond"]             = {1,1,15},
						["disc-wait"]           = {1,1,5},
						["disc-mellohi"]        = {1,1,5},
						["name-tag"]            = {1,1,10},
						["chainmail-chestplate"] = {1,1,20},
						["chainmail-helmet"]    = {1,1,20},
						["chainmail-leggings"]  = {1,1,20},
						["chainmail-boots"]     = {1,1,20},
						["book-and-quill"]      = {1,2,5},
						["lead"]                = {1,3,10},
						["bottle-o'-enchanting"] = {1,1,3},
						["potion-of-water-breathing"] = {1,1,15},
						["potion-of-regeneration"] = {1,1,10},
						["cake"]                = {1,1,1},
					}
				},
			},
			poolsBedrockUpcoming = {}
		},
		["underwater-ruin-big"] = { -- underwater_ruin_big.json
			header = "大",
			superheader = "[[海底遺跡]]",
			link   = "大きな[[海底遺跡]]",
			structure = "海底遺跡",
			container = "大きな海底遺跡のチェスト",
			structID = "underwater-ruins",
			poolsJava = {
				{
					rolls = {2,8},
					items = {
						["coal"]                = {1,4,10},
						["gold-nugget"]         = {1,3,10},
						["emerald"]             = {1,1,1},
						["wheat"]               = {2,3,10},
					}
				},
				{
					rolls = {1,1},
					items = {
						["golden-apple"]        = {1,1,1},
						["enchanted-book-rnd"]  = {1,1,5},
						["leather-tunic"]       = {1,1,1},
						["golden-helmet"]       = {1,1,1},
						["enchanted-fishing-rod"] = {1,1,5},
						["buried-treasure-map"] = {1,1,10},
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["underwater-ruin-small"] = { -- underwater_ruin_small.json
			header = "小",
			superheader = "[[海底遺跡]]",
			link   = "小さな[[海底遺跡]]",
			structure = "海底遺跡",
			container = "小さな海底遺跡のチェスト",
			structID = "underwater-ruins",
			poolsJava = {
				{
					rolls = {2,8},
					items = {
						["coal"]                = {1,4,10},
						["stone-axe"]           = {1,1,2},
						["rotten-flesh"]        = {1,1,5},
						["emerald"]             = {1,1,1},
						["wheat"]               = {2,3,10},
					}
				},
				{
					rolls = {1,1},
					items = {
						["leather-tunic"]       = {1,1,1},
						["golden-helmet"]       = {1,1,1},
						["enchanted-fishing-rod"] = {1,1,5},
						["buried-treasure-map"] = {1,1,5},
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		
		["village-armorer"] = { -- village\village_armorer.json
			header = "防具鍛冶",
			superheader = "[[村]]",
			link   = "[[村]]の防具鍛冶",
			structure = "村",
			container = "防具鍛冶のチェスト",
			structID = "village",
			poolsJava = {
				{
					rolls = {1,5},
					items = {
						["iron-ingot"]     = {1,3,2},
						["bread"]          = {1,4,4},
						["iron-helmet"]    = {1,1,1},
						["emerald"]        = {1,1,1}
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["village-butcher"] = { -- village\village_butcher.json
			header = "肉屋",
			superheader = "[[村]]",
			link   = "[[村]]の肉屋",
			structure = "村",
			container = "肉屋のチェスト",
			structID = "village",
			poolsJava = {
				{
					rolls = {1,5},
					items = {
						["emerald"]        = {1,1,1},
						["raw-porkchop"]   = {1,3,6},
						["wheat"]          = {1,3,6},
						["raw-beef"]       = {1,3,6},
						["raw-mutton"]     = {1,3,6},
						["coal"]           = {1,3,3}
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["village-cartographer"] = { -- village\village_cartographer.json
			header = "製図家",
			superheader = "[[村]]",
			link   = "[[村]]の製図家",
			structure = "村",
			container = "製図家のチェスト",
			structID = "village",
			poolsJava = {
				{
					rolls = {1,5},
					items = {
						["empty-map"]      = {1,3,10},
						["paper"]          = {1,5,15},
						["compass"]        = {1,1,5},
						["bread"]          = {1,4,15},
						["stick"]          = {1,2,5}
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {
				{
					rolls = {1,5},
					items = {
						["map"]            = {1,3,10},
						["paper"]          = {1,5,15},
						["compass"]        = {1,1,5},
						["bread"]          = {1,4,15},
						["oak-sapling"]    = {1,2,5}
					}
				},
			},
			poolsBedrockUpcoming = {}
		},
		["village-fisherman"] = { -- village\village_fisher.json, Java-exclusive as of Java 1.14 / Bedrock 1.12
			header = "漁師",
			superheader = "[[村]]",
			link   = "[[村]]の漁師",
			structure = "村",
			container = "漁師のチェスト",
			structID = "village",
			poolsJava = {
				{
					rolls = {1,5},
					items = {
						["emerald"]         = {1,1,1},
						["raw-cod"]         = {1,3,2},
						["raw-salmon"]      = {1,3,1},
						["water-bucket"]    = {1,3,1},
						["barrel"]          = {1,3,1},
						["wheat-seeds"]     = {1,3,3},
						["coal"]            = {1,3,2}
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["village-fletcher"] = { -- village\village_fletcher.json
			header = "矢細工師",
			superheader = "[[村]]",
			link   = "[[村]]の矢細工師",
			structure = "村",
			container = "矢細工師のチェスト",
			structID = "village",
			poolsJava = {
				{
					rolls = {1,5},
					items = {
						["emerald"]         = {1,1,1},
						["arrow"]           = {1,3,2},
						["feather"]         = {1,3,6},
						["egg"]             = {1,3,2},
						["flint"]           = {1,3,6},
						["stick"]           = {1,3,6}
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["village-mason"] = { -- village\village_mason.json
			header = "石工",
			superheader = "[[村]]",
			link   = "[[村]]の石工",
			structure = "村",
			container = "石工のチェスト",
			structID = "village",
			poolsJava = {
				{
					rolls = {1,5},
					items = {
						["clay"]           = {1,3,1},
						["flower-pot"]     = {1,1,1},
						["stone"]          = {1,1,2},
						["stone-bricks"]   = {1,1,2},
						["bread"]          = {1,4,4},
						["yellow-dye"]     = {1,1,1},
						["smooth-stone"]   = {1,1,1},
						["emerald"]        = {1,1,1}
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["village-shepherd"] = { -- village\village_shepherd.json
			header = "羊飼い",
			superheader = "[[村]]",
			link   = "[[村]]の羊飼い",
			structure = "村",
			container = "羊飼いのチェスト",
			structID = "village",
			poolsJava = {
				{
					rolls = {1,5},
					items = {
						["white-wool"]      = {1,8,6},
						["black-wool"]      = {1,3,3},
						["gray-wool"]       = {1,3,2},
						["brown-wool"]      = {1,3,2},
						["light-gray-wool"] = {1,3,2},
						["emerald"]         = {1,1,1},
						["shears"]          = {1,1,1},
						["wheat"]           = {1,6,6}
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["village-tannery"] = { -- village\village_tannery.json
			header = "革細工師",
			superheader = "[[村]]",
			link   = "[[村]]の革細工師",
			structure = "村",
			container = "革細工師のチェスト",
			structID = "village",
			poolsJava = {
				{
					rolls = {1,5},
					items = {
						["leather"]         = {1,3,1},
						["leather-tunic"]   = {1,1,2},
						["leather-boots"]   = {1,1,2},
						["leather-cap"]     = {1,1,2},
						["bread"]           = {1,4,5},
						["leather-pants"]   = {1,1,2},
						["saddle"]          = {1,1,1},
						["emerald"]         = {1,4,1}
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["village-temple"] = { -- village\village_temple.json
			header = "寺院",
			superheader = "[[村]]",
			link   = "[[村]]の寺院",
			structure = "村",
			container = "寺院のチェスト",
			structID = "village",
			poolsJava = {
				{
					rolls = {3,8},
					items = {
						["redstone"]        = {1,4,2},
						["bread"]           = {1,4,7},
						["rotten-flesh"]    = {1,4,7},
						["lapis-lazuli"]    = {1,4,1},
						["gold-ingot"]      = {1,4,1},
						["emerald"]         = {1,4,1}
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["village-toolsmith"] = { -- village\village_toolsmith.json
			header = "道具鍛冶",
			superheader = "[[村]]",
			link   = "[[村]]の道具鍛冶",
			structure = "村",
			container = "道具鍛冶のチェスト",
			structID = "village",
			poolsJava = {
				{
					rolls = {3,8},
					items = {
						["diamond"]         = {1,3,1},
						["iron-ingot"]      = {1,5,5},
						["gold-ingot"]      = {1,3,1},
						["bread"]           = {1,3,15},
						["iron-pickaxe"]    = {1,1,5},
						["coal"]            = {1,3,1},
						["stick"]           = {1,3,20},
						["iron-shovel"]     = {1,1,5}
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["village-weaponsmith"] = { -- village\village_weaponsmith.json
			header = "武器鍛冶",
			superheader = "[[村]]",
			link   = "[[村]]の武器鍛冶",
			structure = "村",
			container = "武器鍛冶のチェスト",
			structID = "village",
			poolsJava = {
				{
					rolls = {3,8},
					items = {
						["diamond"]             = {1,3,3},
						["iron-ingot"]          = {1,5,10},
						["gold-ingot"]          = {1,3,5},
						["bread"]               = {1,3,15},
						["apple"]               = {1,3,15},
						["iron-pickaxe"]        = {1,1,5},
						["iron-sword"]          = {1,1,5},
						["iron-chestplate"]     = {1,1,5},
						["iron-helmet"]         = {1,1,5},
						["iron-leggings"]       = {1,1,5},
						["iron-boots"]          = {1,1,5},
						["obsidian"]            = {3,7,5},
						["oak-sapling"]         = {3,7,5},
						["saddle"]              = {1,1,3},
						["iron-horse-armor"]    = {1,1,1},
						["golden-horse-armor"]  = {1,1,1},
						["diamond-horse-armor"] = {1,1,1}
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		
		["village-desert-house"] = { -- village\village_desert_house.json
			header = "砂漠の家",
			superheader = "[[村]]",
			link   = "[[村]]の家",
			structure = "村",
			container = "砂漠の村のチェスト",
			structID = "village",
			poolsJava = {
				{
					rolls = {3,8},
					items = {
						["clay"]            = {1,1,1},
						["green-dye"]       = {1,1,1},
						["cactus"]          = {1,4,10},
						["wheat"]           = {1,7,10},
						["bread"]           = {1,4,10},
						["book"]            = {1,1,1},
						["dead-bush"]       = {1,3,2},
						["emerald"]         = {1,3,1}
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["village-plains-house"] = { -- village\village_plains_house.json
			header = "平原の家",
			superheader = "[[村]]",
			link   = "[[村]]の家",
			structure = "村",
			container = "平原の村のチェスト",
			structID = "village",
			poolsJava = {
				{
					rolls = {3,8},
					items = {
						["gold-nugget"]     = {1,3,1},
						["dandelion"]       = {1,1,2},
						["poppy"]           = {1,1,1},
						["potato"]          = {1,7,10},
						["bread"]           = {1,4,10},
						["apple"]           = {1,5,10},
						["book"]            = {1,1,1},
						["feather"]         = {1,1,1},
						["emerald"]         = {1,4,2},
						["oak-sapling"]     = {1,2,5}
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["village-savanna-house"] = { -- village\village_savanna_house.json
			header = "サバンナの家",
			superheader = "[[村]]",
			link   = "[[村]]の家",
			structure = "村",
			container = "サバンナの村のチェスト",
			structID = "village",
			poolsJava = {
				{
					rolls = {3,8},
					items = {
						["gold-nugget"]     = {1,3,1},
						["grass"]           = {1,1,5},
						["tall-grass"]      = {1,1,5},
						["bread"]           = {1,4,10},
						["wheat-seeds"]     = {1,5,10},
						["emerald"]         = {1,4,2},
						["acacia-sapling"]  = {1,2,10},
						["saddle"]          = {1,1,1},
						["torch"]           = {1,2,1},
						["bucket"]          = {1,1,1}
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["village-snowy-house"] = { -- village\village_snowy_house.json
			header = "雪の家",
			superheader = "[[村]]",
			link   = "[[村]]の家",
			structure = "村",
			container = "雪の村のチェスト",
			structID = "village",
			poolsJava = {
				{
					rolls = {3,8},
					items = {
						["blue-ice"]        = {1,1,1},
						["snow-block"]      = {1,1,4},
						["potato"]          = {1,7,10},
						["bread"]           = {1,4,10},
						["beetroot-seeds"]  = {1,5,10},
						["beetroot-soup"]   = {1,1,1},
						["furnace"]         = {1,1,1},
						["emerald"]         = {1,4,1},
						["snowball"]        = {1,7,10},
						["coal"]            = {1,4,5}
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["village-taiga-house"] = { -- village\village_taiga_house.json
			header = "タイガの家",
			superheader = "[[村]]",
			link   = "[[村]]の家",
			structure = "村",
			container = "タイガの村の家",
			structID = "village",
			poolsJava = {
				{
					rolls = {3,8},
					items = {
						["iron-nugget"]     = {1,5,1},
						["fern"]            = {1,1,2},
						["large-fern"]      = {1,1,2},
						["potato"]          = {1,7,10},
						["sweet-berries"]   = {1,7,5},
						["bread"]           = {1,4,10},
						["pumpkin-seeds"]   = {1,5,5},
						["pumpkin-pie"]     = {1,1,1},
						["emerald"]         = {1,4,2},
						["spruce-sapling"]  = {1,5,5},
						["spruce-sign"]     = {1,1,1},
						["spruce-log"]      = {1,5,10}
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {
				{
					rolls = {3,8},
					items = {
						["iron-nugget"]     = {1,5,1},
						["fern"]            = {1,1,2},
						["large-fern"]      = {1,1,2},
						["potato"]          = {1,7,10},
						["bread"]           = {1,4,10},
						["pumpkin-seeds"]   = {1,5,5},
						["pumpkin-pie"]     = {1,1,1},
						["emerald"]         = {1,4,2},
						["spruce-sapling"]  = {1,5,5},
						["oak-sign"]        = {1,1,1},
						["spruce-log"]      = {1,5,10}
					}
				},
			},
			poolsBedrockUpcoming = {}
		},
		
		["stronghold-altar"] = { -- stronghold_corridor.json
			header      = "祭壇",
			superheader = "[[要塞]]",
			link        = "[[要塞]]の祭壇",
			structure = "要塞",
			container = "祭壇のチェスト",
			structID = "stronghold",
			poolsJava = {
				{
					rolls = {2,3},
					items = {
						["ender-pearl"]         = {1,1,10},
						["diamond"]             = {1,3,3},
						["iron-ingot"]          = {1,5,10},
						["gold-ingot"]          = {1,3,5},
						["redstone"]            = {4,9,5},
						["bread"]               = {1,3,15},
						["apple"]               = {1,3,15},
						["iron-pickaxe"]        = {1,1,5},
						["iron-sword"]          = {1,1,5},
						["iron-chestplate"]     = {1,1,5},
						["iron-helmet"]         = {1,1,5},
						["iron-leggings"]       = {1,1,5},
						["iron-boots"]          = {1,1,5},
						["golden-apple"]        = {1,1,1},
						["saddle"]              = {1,1,1},
						["iron-horse-armor"]    = {1,1,1},
						["golden-horse-armor"]  = {1,1,1},
						["diamond-horse-armor"] = {1,1,1},
						["enchanted-book"]      = {1,1,1},
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {
				{
					rolls = {2,3},
					items = {
						["ender-pearl"]         = {1,1,50},
						["emerald"]             = {1,3,15},
						["diamond"]             = {1,3,15},
						["iron-ingot"]          = {1,5,50},
						["gold-ingot"]          = {1,3,25},
						["redstone"]            = {4,9,25},
						["bread"]               = {1,3,75},
						["apple"]               = {1,3,75},
						["iron-pickaxe"]        = {1,1,25},
						["iron-sword"]          = {1,1,25},
						["iron-chestplate"]     = {1,1,25},
						["iron-helmet"]         = {1,1,25},
						["iron-leggings"]       = {1,1,25},
						["iron-boots"]          = {1,1,25},
						["golden-apple"]        = {1,1,5},
						["saddle"]              = {1,1,5},
						["iron-horse-armor"]    = {1,1,5},
						["golden-horse-armor"]  = {1,1,5},
						["diamond-horse-armor"] = {1,1,5},
						["enchanted-book"]      = {1,1,6},
					}
				},
			},
			poolsBedrockUpcoming = {}
		},
		["stronghold-library"] = { -- stronghold_library.json
			header      = "図書室",
			superheader = "[[要塞]]",
			link        = "[[要塞]]の図書室",
			structure = "要塞",
			container = "図書室のチェスト",
			structID = "stronghold",
			poolsJava = {
				{
					rolls = {2,10},
					items = {
						["book"]                = {1,3,20},
						["paper"]               = {2,7,20},
						["empty-map"]           = {1,1,1},
						["compass"]             = {1,1,1},
						["enchanted-book"]      = {1,1,10},
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {
				{
					rolls = {2,10},
					items = {
						["book"]                = {1,3,100},
						["paper"]               = {2,7,100},
						["map"]                 = {1,1,5},
						["compass"]             = {1,1,5},
						["enchanted-book"]      = {1,1,60},
					}
				},
			},
			poolsBedrockUpcoming = {}
		},
		["stronghold-storeroom"] = { -- stronghold_crossing.json
			header      = "倉庫",
			superheader = "[[要塞]]",
			link        = "[[要塞]]の倉庫",
			structure = "要塞",
			container = "倉庫のチェスト",
			structID = "stronghold",
			poolsJava = {
				{
					rolls = {1,4},
					items = {
						["iron-ingot"]          = {1,5,10},
						["gold-ingot"]          = {1,3,5},
						["redstone"]            = {4,9,5},
						["coal"]                = {3,8,10},
						["bread"]               = {1,3,15},
						["apple"]               = {1,3,15},
						["iron-pickaxe"]        = {1,1,1},
						["enchanted-book"]      = {1,1,1},
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {
				{
					rolls = {1,4},
					items = {
						["iron-ingot"]          = {1,5,50},
						["gold-ingot"]          = {1,3,25},
						["redstone"]            = {4,9,25},
						["coal"]                = {3,8,50},
						["bread"]               = {1,3,75},
						["apple"]               = {1,3,75},
						["iron-pickaxe"]        = {1,1,5},
						["enchanted-book"]      = {1,1,6},
						["ink-sac"]             = {1,3,75},
					}
				},
			},
			poolsBedrockUpcoming = {}
		},
		["bonus"] = { -- spawn_bonus_chest.json
			header = "[[チェスト#ボーナスチェスト|ボーナスチェスト]]",
			link   = "[[チェスト#ボーナスチェスト|ボーナスチェスト]]",
			structure = "ボーナスチェスト",
			container = "",
			structID = "day",
			chest_type = "bonus", -- 日本語対応
			poolsJava = {
				{
					rolls = {1,1},
					items = {
						["stone-axe"]           = {1,1,1},
						["wooden-axe"]          = {1,1,3},
					}
				},
				{
					rolls = {1,1},
					items = {
						["stone-pickaxe"]       = {1,1,1},
						["wooden-pickaxe"]      = {1,1,3}
					}
				},
				{
					rolls = {3,3},
					items = {
						["apple"]               = {1,2,5},
						["bread"]               = {1,2,3},
						["raw-salmon"]          = {1,2,3},
					}
				},
				{
					rolls = {4,4},
					items = {
						["stick"]               = {1,12,10},
						["oak-planks"]          = {1,12,10},
						["oak-log"]             = {1,3,3},
						["spruce-log"]          = {1,3,3},
						["birch-log"]           = {1,3,3},
						["jungle-log"]          = {1,3,3},
						["acacia-log"]          = {1,3,3},
						["dark-oak-log"]        = {1,3,3},
					}
				},
			},
		    poolsJavaUpcoming = {},
			poolsBedrock = {
				{
					rolls = {1,1},
					items = {
						["stone-axe"]           = {1,1,1},
						["wooden-axe"]          = {1,1,3},
					}
				},
				{
					rolls = {1,1},
					items = {
						["stone-pickaxe"]       = {1,1,1},
						["wooden-pickaxe"]      = {1,1,3}
					}
				},
				{
					rolls = {1,1},
					items = {
						["apple"]               = {1,2,1}
					}
				},
				{
					rolls = {1,1},
					items = {
						["bread"]               = {1,2,1}
					}
				},
				{
					rolls = {1,1},
					items = {
						["raw-salmon"]          = {1,2,1}
					}
				},
				{
					rolls = {1,1},
					items = {
						["stick"]               = {1,12,1}
					}  
				},
				{
					rolls = {1,1},
					items = {
						["oak-planks"]          = {1,12,1}
					}  
				},
				{
					rolls = {1,1},
					items = {
						["dark-oak-log"]        = {1,3,1},
						["acacia-log"]          = {1,3,1},
					}
				},
				{
					rolls = {1,1},
					items = {
						["oak-log"]             = {1,3,1},
						["spruce-log"]          = {1,3,1},
						["birch-log"]           = {1,3,1},
						["jungle-log"]          = {1,3,1},
					}
				},
				{
					rolls = {1,1},
					items = {
						["potato"]              = {1,2,3},
						["carrot"]              = {1,2,3},
					}
				},
				{
					rolls = {1,1},
					items = {
						["oak-sapling"]         = {4,4,2},
						["spruce-sapling"]      = {4,4,2},
						["birch-sapling"]       = {4,4,2},
						["jungle-sapling"]      = {4,4,4},
						["dark-oak-sapling"]    = {4,4,2},
						["acacia-sapling"]      = {4,4,2},
					}
				},
				{
					rolls = {1,1},
					items = {
						["melon-seeds"]         = {1,2,3},
						["pumpkin-seeds"]       = {1,2,3},
						["beetroot-seeds"]      = {1,2,3},
					}
				},
				{
					rolls = {1,1},
					items = {
						["cactus"]              = {1,2,3},
						["cocoa-beans"]         = {1,2,2},
					}
				},
				{
					rolls = {1,1},
					items = {
						["brown-mushroom"]              = {1,2,2},
					}
				},
			},
			poolsBedrockUpcoming = {}
		},
		["dungeon"] = { -- simple_dungeon.json
			header = "[[ダンジョン]]",
			link   = "[[ダンジョン]]",
			structure = "ダンジョン",
			container = "",
			structID = "Dungeon",
			poolsJava = {
				{
					rolls = {1,3},
					items = {
						["saddle"]              = {1,1,20},
						["golden-apple"]        = {1,1,15},
						["enchanted-golden-apple"] = {1,1,2},
						["disc-13"]             = {1,1,15},
						["disc-cat"]            = {1,1,15},
						["name-tag"]            = {1,1,20},
						["golden-horse-armor"]  = {1,1,10},
						["iron-horse-armor"]    = {1,1,15},
						["diamond-horse-armor"] = {1,1,5},
						["enchanted-book-rnd"]  = {1,1,10},
					}
				},
				{
					rolls = {1,4},
					items = {
						["iron-ingot"]          = {1,4,10},
						["gold-ingot"]          = {1,4,5},
						["bread"]               = {1,1,20},
						["wheat"]               = {1,4,20},
						["bucket"]              = {1,1,10},
						["redstone"]            = {1,4,15},
						["coal"]                = {1,4,15},
						["melon-seeds"]         = {2,4,10},
						["pumpkin-seeds"]       = {2,4,10},
						["beetroot-seeds"]      = {2,4,10},
					}
				},
				{
					rolls = {3,3},
					items = {
						["bone"]                = {1,8,10},
						["gunpowder"]           = {1,8,10},
						["rotten-flesh"]        = {1,8,10},
						["string"]              = {1,8,10},
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["mineshaft"] = { -- abandoned_mineshaft.json
			chest_type = "minecart with chest",
			header = "[[廃坑]]",
			link   = "[[廃坑]]",
			structure = "廃坑",
			container = "",
			structID = "abandoned-mineshaft",
			poolsJava = {
				{
					rolls = {1,1},
					items = {
						["golden-apple"]        = {1,1,20},
						["enchanted-golden-apple"] = {1,1,1},
						["name-tag"]            = {1,1,30},
						["enchanted-book-rnd"]  = {1,1,10},
						["iron-pickaxe"]        = {1,1,5},
						["empty"]				= {1,1,5},
					}
				},
				{
					rolls = {2,4},
					items = {
						["iron-ingot"]          = {1,5,10},
						["gold-ingot"]          = {1,3,5},
						["redstone"]            = {4,9,5},
						["lapis-lazuli"]        = {4,9,5},
						["diamond"]             = {1,2,3},
						["coal"]                = {3,8,10},
						["bread"]               = {1,3,15},
						["melon-seeds"]         = {2,4,10},
						["pumpkin-seeds"]       = {2,4,10},
						["beetroot-seeds"]      = {2,4,10},
					}
				},
				{
					rolls = {3,3},
					items = {
						["rail"]                = {4,8,20},
						["powered-rail"]        = {1,4,5},
						["detector-rail"]       = {1,4,5},
						["activator-rail"]      = {1,4,5},
						["torch"]               = {1,16,15},
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["nether-fortress"] = { -- nether_bridge.json
			header = "[[ネザー要塞]]",
			link   = "[[ネザー要塞]]",
			structure = "ネザー要塞",
			container = "",
			structID = "nether-fortress",
			poolsJava = {
				{
					rolls = {2,4},
					items = {
						["diamond"]             = {1,3,5},
						["iron-ingot"]          = {1,5,5},
						["gold-ingot"]          = {1,3,15},
						["golden-sword"]        = {1,1,5},
						["golden-chestplate"]   = {1,1,5},
						["flint-and-steel"]     = {1,1,5},
						["nether-wart"]         = {3,7,5},
						["saddle"]              = {1,1,10},
						["golden-horse-armor"]    = {1,1,8},
						["iron-horse-armor"]    = {1,1,5},
						["diamond-horse-armor"] = {1,1,3},
						["obsidian"]            = {2,4,2},
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["desert-temple"] = { -- desert_pyramid.json
			header = "[[砂漠の寺院]]",
			link   = "[[砂漠の寺院]]",
			structure = "砂漠の寺院",
			container = "",
			structID = "desert-temple",
			poolsJava = {
				{
					rolls = {2,4},
					items = {
						["diamond"]             = {1,3,5},
						["iron-ingot"]          = {1,5,15},
						["gold-ingot"]          = {2,7,15},
						["emerald"]             = {1,3,15},
						["bone"]                = {4,6,25},
						["spider-eye"]          = {1,3,25},
						["rotten-flesh"]        = {3,7,25},
						["saddle"]              = {1,1,20},
						["iron-horse-armor"]    = {1,1,15},
						["golden-horse-armor"]  = {1,1,10},
						["diamond-horse-armor"] = {1,1,5},
						["enchanted-book-rnd"]  = {1,1,20},
						["golden-apple"]        = {1,1,20},
						["enchanted-golden-apple"] = {1,1,2},
						["empty"]               = {1,1,15},
					}
				},
				{
					rolls = {4,4},
					items = {
						["bone"]                = {1,8,10},
						["gunpowder"]           = {1,8,10},
						["rotten-flesh"]        = {1,8,10},
						["string"]              = {1,8,10},
						["sand"]                = {1,8,10},
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["jungle-temple"] = { -- jungle_temple.json
			header = "[[ジャングルの寺院]]",
			link   = "[[ジャングルの寺院]]",
			structure = "ジャングルの寺院",
			container = "チェスト",
			structID = "jungle-temple",
			poolsJava = {
				{
					rolls = {2,6},
					items = {
						["diamond"]             = {1,3,3},
						["iron-ingot"]          = {1,5,10},
						["gold-ingot"]          = {2,7,15},
						["emerald"]             = {1,3,2},
						["bone"]                = {4,6,20},
						["bamboo"]              = {1,3,15},
						["rotten-flesh"]        = {3,7,16},
						["saddle"]              = {1,1,3},
						["iron-horse-armor"]    = {1,1,1},
						["golden-horse-armor"]  = {1,1,1},
						["diamond-horse-armor"] = {1,1,1},
						["enchanted-book"]      = {1,1,1}
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {
				{
					rolls = {2,6},
					items = {
						["diamond"]             = {1,3,15},
						["iron-ingot"]          = {1,5,50},
						["gold-ingot"]          = {2,7,75},
						["emerald"]             = {1,3,10},
						["bone"]                = {4,6,100},
						["rotten-flesh"]        = {3,7,80},
						["bamboo"]              = {1,3,75},
						["saddle"]              = {1,1,15},
						["iron-horse-armor"]    = {1,1,5},
						["golden-horse-armor"]  = {1,1,5},
						["diamond-horse-armor"] = {1,1,5},
						["enchanted-book"]      = {1,1,6}
					}
				},
			},
			poolsBedrockUpcoming = {},
		},
		["jungle-temple-dispenser"] = { -- jungle_temple_dispenser.json
			chest_type = "dispenser",
			link   = "[[ジャングルの寺院]]",
			structure = "ジャングルの寺院",
			container = "ディスペンサー",
			structID = "jungle-temple",
			poolsJava = {
				{
					rolls = {1,2},
					items = {
						["arrow"] = {2,7,30}
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {
				{
					rolls = {2,2},
					items = {
						["arrow"] = {2,7,30}
					}
				},
			},
			poolsBedrockUpcoming = {}
		},
		["end-city"] = { -- end_city_treasure.json
			header = "[[エンドシティ]]",
			link   = "[[エンドシティ]]",
			structure = "エンドシティ",
			container = "",
			structID = "end-city",
			poolsJava = {
				{
					rolls = {2,6},
					items = {
						["diamond"]             = {2,7,5},
						["iron-ingot"]          = {4,8,10},
						["gold-ingot"]          = {2,7,15},
						["emerald"]             = {2,6,2},
						["beetroot-seeds"]      = {1,10,5},
						["saddle"]              = {1,1,3},
						["iron-horse-armor"]    = {1,1,1},
						["golden-horse-armor"]  = {1,1,1},
						["diamond-horse-armor"] = {1,1,1},
						["enchanted-diamond-sword"]      = {1,1,3},
						["enchanted-diamond-boots"]      = {1,1,3},
						["enchanted-diamond-chestplate"] = {1,1,3},
						["enchanted-diamond-leggings"]   = {1,1,3},
						["enchanted-diamond-helmet"]     = {1,1,3},
						["enchanted-diamond-pickaxe"]    = {1,1,3},
						["enchanted-diamond-shovel"]     = {1,1,3},
						["enchanted-iron-sword"]         = {1,1,3},
						["enchanted-iron-boots"]         = {1,1,3},
						["enchanted-iron-chestplate"]    = {1,1,3},
						["enchanted-iron-leggings"]      = {1,1,3},
						["enchanted-iron-helmet"]        = {1,1,3},
						["enchanted-iron-pickaxe"]       = {1,1,3},
						["enchanted-iron-shovel"]        = {1,1,3},
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["igloo"] = {
			header = "[[イグルー]]",
			link   = "[[イグルー]]",
			structure = "イグルー",
			container = "",
			structID = "igloo",
			poolsJava = {
				{
					rolls = {2,8},
					items = {
						["apple"]               = {1,3,15},
						["coal"]                = {1,4,15},
						["gold-nugget"]         = {1,3,10},
						["stone-axe"]           = {1,1,2},
						["rotten-flesh"]        = {1,1,10},
						["emerald"]             = {1,1,1},
						["wheat"]               = {2,3,10}
					}
				},
				{
					rolls = {1,1},
					items = {
						["golden-apple"]        = {1,1,1},
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["pillager-outpost"] = {
			header = "[[ピリジャーの前哨基地]]",
			link   = "[[ピリジャーの前哨基地]]",
			structure = "ピリジャーの前哨基地",
			container = "",
			structID = "pillager-outpost",
			poolsJava = {			
				{
					rolls = {0,1},
					items = {
						["crossbow"]             = {1,1,1},
					}
				},
				{
					rolls = {2,3},
					items = {
						["wheat"]                = {3,5,7},
						["potato"]               = {2,5,5},
						["carrot"]               = {3,5,5}
					}
				},
				{
					rolls = {1,3},
					items = {
						["dark-oak-log"]         = {2,3,1}
					}
				},
				{
					rolls = {2,3},
					items = {
						["bottle-o'-enchanting"] = {1,1,7},
						["string"]               = {1,6,4},
						["arrow"]                = {2,7,4},
						["tripwire-hook"]        = {1,3,3},
						["iron-ingot"]           = {1,3,3},
						["enchanted-book-rnd"]   = {1,1,1}
					}
				}
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {},
			poolsBedrockUpcoming = {}
		},
		["woodland-mansion"] = { -- woodland_mansion.json
			header = "[[森の洋館]]",
			link   = "[[森の洋館]]",
			structure = "森の洋館",
			container = "",
			structID = "woodland-mansion",
			poolsJava = {
				{
					rolls = {1,3},
					items = {
						["lead"]                  = {1,1,20},
						["golden-apple"]          = {1,1,15},
						["enchanted-golden-apple"] = {1,1,2},
						["disc-13"]               = {1,1,15},
						["disc-cat"]              = {1,1,15},
						["name-tag"]              = {1,1,20},
						["chainmail-chestplate"]  = {1,1,10},
						["diamond-hoe"]           = {1,1,15},
						["diamond-chestplate"]    = {1,1,5},
						["enchanted-book-rnd"]    = {1,1,10},
					}
				},
				{
					rolls = {1,4},
					items = {
						["iron-ingot"]            = {1,4,10},
						["gold-ingot"]            = {1,4,5},
						["bread"]                 = {1,1,20},
						["wheat"]                 = {1,4,20},
						["bucket"]                = {1,1,10},
						["redstone"]              = {1,4,15},
						["coal"]                  = {1,4,15},
						["melon-seeds"]           = {2,4,10},
						["pumpkin-seeds"]         = {2,4,10},
						["beetroot-seeds"]        = {2,4,10},
					}
				},
				{
					rolls = {3,3},
					items = {
						["bone"]                  = {1,8,10},
						["gunpowder"]             = {1,8,10},
						["rotten-flesh"]          = {1,8,10},
						["string"]                = {1,8,10},
					}
				},
			},
			poolsJavaUpcoming = {},
			poolsBedrock = {
				{
					rolls = {1,3},
					items = {
						["lead"]                  = {1,1,100},
						["golden-apple"]          = {1,1,75},
						["enchanted-golden-apple"] = {1,1,10},
						["disc-13"]               = {1,1,75},
						["disc-cat"]              = {1,1,75},
						["name-tag"]              = {1,1,100},
						["chainmail-chestplate"]  = {1,1,50},
						["diamond-hoe"]           = {1,1,75},
						["diamond-chestplate"]    = {1,1,25},
						["enchanted-book-rnd-treasure"] = {1,1,60},
					}
				},
				{
					rolls = {1,4},
					items = {
						["iron-ingot"]            = {1,4,50},
						["gold-ingot"]            = {1,4,25},
						["bread"]                 = {1,1,100},
						["wheat"]                 = {1,4,100},
						["bucket"]                = {1,1,50},
						["redstone"]              = {1,4,75},
						["coal"]                  = {1,4,75},
						["melon-seeds"]           = {2,4,50},
						["pumpkin-seeds"]         = {2,4,50},
						["beetroot-seeds"]        = {2,4,50},
					}
				},
				{
					rolls = {3,3},
					items = {
						["bone"]                  = {1,8,50},
						["gunpowder"]             = {1,8,50},
						["rotten-flesh"]          = {1,8,50},
						["string"]                = {1,8,50},
					}
				},
			},
			poolsBedrockUpcoming = {}
		},
	},

	-- these values are used:
	-- * in place of the keys, when the key is used as a parameter
	
	-- chest-param -> internally-valid-chest-param
	
	synonyms = {
		["desert"] = "desert-temple",
		["jungle"] = "jungle-temple",
		["nether"] = "nether-fortress",
		["fortress"] = "nether-fortress",
		
		["armorer"]       = "village-armorer",
		["butcher"]       = "village-butcher",
		["cartographer"]  = "village-cartographer",
		["fisherman"]     = "village-fisherman",
		["fletcher"]      = "village-fletcher",
		["mason"]         = "village-mason",
		["shepherd"]      = "village-shepherd",
		["tannery"]       = "village-tannery",
		["temple"]        = "village-temple",
		["toolsmith"]     = "village-toolsmith",
		["weaponsmith"]   = "village-weaponsmith",

		["desert-house"]  = "village-desert-house",
		["plains-house"]  = "village-plains-house",
		["savanna-house"] = "village-savanna-house",
		["snowy-house"]   = "village-snowy-house",
		["taiga-house"]   = "village-taiga-house",
		
		["altar"] = "stronghold-altar",
		["storeroom"] = "stronghold-storeroom",
		["library"] = "stronghold-library",
		["outpost"] = "pillager-outpost",
		["mansion"] = "woodland-mansion"
	},

	-- these values are used:
	-- * in the header-description of a table showing only a single chest
	-- * if the key is not here, but it is a valid chest parameter,
	--   that header-description will default to use the key string from p.chests,
	--   e.g. "nether-fortress"
	
	-- chest-param -> description-string
	
	display_names = {
		["nether-fortress"] = "ネザー要塞",
		["nether"] = "ネザー要塞",
		["fortress"] = "ネザー要塞",
		["desert"] = "砂漠の寺院",
		["jungle"] = "ジャングルの寺院",
		["desert-temple"] = "砂漠の寺院",
		["jungle-temple"] = "ジャングルの寺院",
		["dungeon"] = "ダンジョン",
		["igloo"] = "イグルー",
		["end-city"] = "エンドシティ",
		["village-two-room-house"] = "村の2つの部屋の家",
		["village-blacksmith"] = "村の鍛冶屋",
		["village"] = "村の鍛冶屋",
		["blacksmith"] = "村の鍛冶屋",
		["stronghold-altar"] = "要塞の祭壇",
		["stronghold-storeroom"] = "要塞の倉庫",
		["stronghold-library"] = "要塞の図書室",
		["altar"] = "要塞の祭壇",
		["storeroom"] = "要塞の倉庫",
		["library"] = "要塞の図書室",
		["mineshaft"] = "廃坑",
		["woodland-mansion"] = "森の洋館",
		["jungle-temple-dispenser"] = "ジャングルの寺院のディスペンサー", 
		["bonus"] = "ボーナスチェスト",
		["underwater-ruin-big"] = "大きな海底遺跡",
		["underwater-ruin-small"] = "小さな海底遺跡",
		["shipwreck-supply"] = "難破船のサプライチェスト",
		["shipwreck-map"] = "難破船のマップチェスト",
		["shipwreck-treasure"] = "難破船のトレジャーチェスト",
		["buried-treasure"] = "埋もれた宝"
	},
	
	-- these descriptions are used:
	-- * in column <abbr> titles,
	-- * and above the table when only a single column-type is chosen
	
	columns = {
		["stacksize"] = 'チェスト内のアイテムのスタックの大きさ(またはスタックできないアイテムの数)',
		["weight"] = 'チェスト内の他のアイテムと比較した場合のこのアイテムの割合',
		["items"] = '多数のチェストを平均した、1つのチェストあたりのアイテム数の期待値',
		["chance"] = '1つのチェストの中に、このアイテムが発見される確率',
		["chests"] = 'このアイテムを発見するのに必要なチェストの探索個数の期待値'
	},
	
	current_frame = nil
}

p.base = function( ... )

	p.current_frame = mw.getCurrentFrame()

	local args = { ... }
	if args[1] == p.current_frame then 
		args = require( 'モジュール:ProcessArgs' ).merge( true )
	else
		args = args[1]
	end
	
	-- transform args into usable list
	
	local chests, columns = q.massage_args( args )
	
	if #chests == 0 then
		return "<span style='font-style:italic; color:red;'>モジュール:LootChest: 有効な引数がありません</span>"
	end

	q.fill_in_chest_derivative_data( chests )
	
	-- construct an ordered list dictating the order of the rows
	
	local ordered_item_rows_java = {}
	local ordered_item_rows_java_upcoming = {}
	local ordered_item_rows_bedrock = {}
	local ordered_item_rows_bedrock_upcoming = {}

	local ret = {}
	
	local java_specified             = args.java                and args.java ~= '0';
	local java_upcoming_specified    = args['java-upcoming']    and args['java-upcoming'] ~= '0';
	local bedrock_specified          = args.bedrock             and args.bedrock ~= '0';
	local bedrock_upcoming_specified = args['bedrock-upcoming'] and args['bedrock-upcoming'] ~= '0';
	
	local any_specified = java_specified or java_upcoming_specified or bedrock_specified or bedrock_upcoming_specified
	
	if any_specified then
	
		if java_specified then
			ordered_item_rows_java = q.construct_ordered_item_rows( chests, 'Java' )
		end	
		if java_upcoming_specified then
			ordered_item_rows_java_upcoming = q.construct_ordered_item_rows( chests, 'JavaUpcoming' )
		end	
		if bedrock_specified then
			ordered_item_rows_bedrock = q.construct_ordered_item_rows( chests, 'Bedrock' )
		end	
		if bedrock_upcoming_specified then
			ordered_item_rows_bedrock_upcoming = q.construct_ordered_item_rows( chests, 'BedrockUpcoming' )
		end
	
	else
	
		local java_excluded             = args.java                and args.java == '0';
		local java_upcoming_excluded    = args['java-upcoming']    and args['java-upcoming'] == '0';
		local bedrock_excluded          = args.bedrock             and args.bedrock == '0';
		local bedrock_upcoming_excluded = args['bedrock-upcoming'] and args['bedrock-upcoming'] == '0';
		
		if not java_excluded then
			ordered_item_rows_java = q.construct_ordered_item_rows( chests, 'Java' )
		end	
		if not java_upcoming_excluded then
			ordered_item_rows_java_upcoming = q.construct_ordered_item_rows( chests, 'JavaUpcoming' )
		end	
		if not bedrock_excluded then
			ordered_item_rows_bedrock = q.construct_ordered_item_rows( chests, 'Bedrock' )
		end	
		if not bedrock_upcoming_excluded then
			ordered_item_rows_bedrock_upcoming = q.construct_ordered_item_rows( chests, 'BedrockUpcoming' )
		end
	
	end
	
	if q.tablelength( ordered_item_rows_java ) > 0 then
		table.insert( ret, q.print_table( chests, columns, ordered_item_rows_java, 'Java' ) )
	end
	if q.tablelength( ordered_item_rows_java_upcoming ) > 0 and q.compare_tables( ordered_item_rows_java, ordered_item_rows_java_upcoming ) then
		table.insert( ret, p.current_frame:preprocess( p['java-upcoming'] ) .. q.lcfirst( q.print_table( chests, columns, ordered_item_rows_java_upcoming, 'JavaUpcoming' ) ) )
	end
	if q.tablelength( ordered_item_rows_bedrock ) > 0 and q.compare_tables( ordered_item_rows_java, ordered_item_rows_bedrock ) then
		table.insert( ret, p.current_frame:preprocess( p.bedrock ) .. q.lcfirst( q.print_table( chests, columns, ordered_item_rows_bedrock, 'Bedrock' ) ) .. '[[カテゴリ:Bedrock Edition限定]]' )
	end
	if q.tablelength( ordered_item_rows_bedrock_upcoming ) > 0 and q.compare_tables( ordered_item_rows, ordered_item_rows_bedrock_upcoming ) then
		table.insert( ret, p.current_frame:preprocess( p['bedrock-upcoming'] ) .. q.lcfirst( q.print_table( chests, columns, ordered_item_rows_bedrock_upcoming, 'BedrockUpcoming' ) ) .. '[[カテゴリ:Bedrock Edition限定]]' )
	end
	
	return table.concat( ret, '\n\n' )
end

p.doc = function()

	local valid_args = {}
	for chest_name, val in pairs(p.chests) do
		local synonyms = {}
		for syn, orig in pairs(p.synonyms) do
			if orig == chest_name then
				table.insert( synonyms, syn )
			end
		end
		if #synonyms > 0 then
			chest_name = chest_name .. " ( " .. table.concat( synonyms, ", " ) .. " )"
		end
		table.insert( valid_args, chest_name )
	end
	table.sort( valid_args )
	return table.concat( valid_args, ",\n<br>" )

end

p.doc2 = function()

	local valid_args = {}
	for column_name, val in pairs(p.columns) do
		table.insert( valid_args, column_name .. ": " .. val )
	end
	table.sort( valid_args )
	return table.concat( valid_args, ",\n<br>" )

end

p.doc3 = function()

	local valid_args = {}
	for item_name, val in pairs(p.items) do
		table.insert( valid_args, item_name )
	end
	table.sort( valid_args )
	return table.concat( valid_args, ", " )

end

p.base2 = function( ... )

	p.current_frame = mw.getCurrentFrame()

	local args = { ... }
	if args[1] == p.current_frame then 
		args = require( 'モジュール:ProcessArgs' ).merge( true )
	else
		args = args[1]
	end
	
	local itemname = args[1]
	
	if p.items[itemname] == nil then
		return '<span style="color:red;">"' .. itemname .. '"は未知のアイテムです。</span>'
	end
	
	if args.java and args.java ~= '0' then
		javaChances = q.single_item_find_values( itemname, 'poolsJava' )
		javaUpcomingChances = {}
		bedrockChances = {}
		bedrockUpcomingChances = {}
	else
		if args['java-upcoming'] and args['java-upcoming'] ~= '0' then
			javaChances = q.single_item_find_values( itemname, 'poolsJavaUpcoming' )
			javaUpcomingChances = {}
			bedrockChances = {}
			bedrockUpcomingChances = {}
		else
			if args.bedrock and args.bedrock ~= '0' then
				javaChances = q.single_item_find_values( itemname, 'poolsBedrock' )
				javaUpcomingChances = {}
				bedrockChances = {}
				bedrockUpcomingChances = {}
			else
				if args['bedrock-upcoming'] and args['bedrock-upcoming'] ~= '0' then
					javaChances = q.single_item_find_values( itemname, 'poolsBedrockUpcoming' )
					javaUpcomingChances = {}
					bedrockChances = {}
					bedrockUpcomingChances = {}
				else
					javaChances = q.single_item_find_values( itemname, 'poolsJava' )
					javaUpcomingChances = q.single_item_find_values( itemname, 'poolsJavaUpcoming', javaChances )
					bedrockChances = q.single_item_find_values( itemname, 'poolsBedrock', javaChances )
					bedrockUpcomingChances = q.single_item_find_values( itemname, 'poolsBedrockUpcoming', javaChances, bedrockChances )
				end
			end
		end
	end
	
	local html = {}
	
	local any_current = q.tablelength( javaChances ) > 0
	local any_changes_upcoming = q.tablelength( javaUpcomingChances ) > 0 and q.compare_tables( javaChances, javaUpcomingChances )
	local any_standard = any_current or any_changes_upcoming
	
	local any_bedrock_current = q.tablelength( bedrockChances ) > 0
	local any_bedrock_upcoming = q.tablelength( bedrockUpcomingChances ) > 0 and q.compare_tables( bedrockChances, bedrockUpcomingChances )
	local any_bedrock = any_bedrock_current or any_bedrock_upcoming
	
	local change_case = p.items[itemname].preserve_case == nil or p.items[itemname].preserve_case ~= true

	if any_current then
		table.insert( html, p.base2_sub( itemname, javaChances ) )
	end
	if any_changes_upcoming then
		table.insert( html, p.current_frame:preprocess( p['java-upcoming']  ) .. ( change_case and q.lcfirst( p.base2_sub( itemname, javaUpcomingChances, any_current ) ) or p.base2_sub( itemname, javaUpcomingChances, any_current ) ) )
	end
	if any_bedrock_current then
		table.insert( html, ( any_standard and '\n\n' or '' ) .. p.current_frame:preprocess( p.bedrock ) .. ( change_case and q.lcfirst( p.base2_sub( itemname, bedrockChances, any_standard ) ) or p.base2_sub( itemname, bedrockChances, any_standard ) ) )
	end
	if any_bedrock_upcoming then
		table.insert( html, ( any_standard and not any_bedrock_current and '\n\n' or '' ) .. p.current_frame:preprocess( p['bedrock-upcoming'] ) .. ( change_case and q.lcfirst( p.base2_sub( itemname, bedrockUpcomingChances, any_bedrock_current or any_standard ) ) or p.base2_sub( itemname, bedrockUpcomingChances, any_bedrock_current or any_standard ) ) )
	end

	if args.nocat then
	else
		table.insert( html, '[[カテゴリ:テンプレート:LootChestItemを読み込んでいるページ]]' )
		if p.items[itemname].category ~= nil and p.items[itemname].category ~= false then
			table.insert( html, '[[カテゴリ:Edition限定の戦利品を含むページ]]' )
		end
		if any_bedrock then
			table.insert( html, '[[カテゴリ:Bedrock Edition限定]]' )
		end
	end
	
	return table.concat( html, ' ' )
end

p.base2_sub = function( itemname, chances, use_they )

	local html = {}
	local item_display_name = ''
	
	if use_they then
		item_display_name = 'これら'
	else
		if p.items[itemname].plural ~= nil and p.items[itemname].plural ~= false then
			item_display_name = p.items[itemname].plural
		else
			if p.items[itemname].title ~= nil then
				item_display_name = p.items[itemname].title
			else
				item_display_name = string.gsub( itemname, '-', ' ' )
			end
			--if p.items[itemname].plural == nil or p.items[itemname].plural ~= false then
			--    item_display_name = q.single_item_plural( item_display_name )
			--end
		end
		
		local Autolink = require( 'モジュール:Autolink' )
		item_display_name = Autolink.invlink(item_display_name, 'nolink')
		
		if p.items[itemname].preserve_case == nil or p.items[itemname].preserve_case ~= true then
			item_display_name = q.capitalize( item_display_name )
		end
		
		if p.items[itemname].note and p.notes[p.items[itemname].note] then
			item_display_name = item_display_name .. p.current_frame:extensionTag( 'ref', p.notes[p.items[itemname].note], { group='注釈', name=p.items[itemname].note } )
		end
	end
	
	table.insert( html, item_display_name )
	table.insert( html, 'は、' )

	local html_stacks = {}
	local stack_sep = '。'
	local ns = q.tablelength( chances )
	local s = 0

	for stacksize, chest_details in pairs( chances ) do
		s = s + 1
	
		local html_per_stack = { '' }
		local c = 0
		local nc = q.tablelength( chest_details )
		local sep = ( nc > 2 and '、' or '、' )
		if nc > 2 and s ~= ns then
			stack_sep = '。'
		end
		for k, chest in pairs( chest_details ) do
			c = c + 1
			if c == nc and nc > 1 then
				table.insert( html_per_stack, '' )
			end
			if chest.chance == 1 then
				table.insert( html_per_stack, "全て" )
			else
				table.insert( html_per_stack, string.format("%.1f", chest.chance*100) )
				table.insert( html_per_stack, "%の確率で" )
			end
			if chest.chest_type == 'minecart with chest' then
				table.insert( html_per_stack, p.chests[chest.chest_name].link )
				table.insert( html_per_stack, 'の[[チェスト付きトロッコ]]の中に' )
			elseif chest.chest_type == 'dispenser' then
				table.insert( html_per_stack, p.chests[chest.chest_name].link )
				table.insert( html_per_stack, 'の[[ディスペンサー]]の中に' )
			elseif chest.chest_type == 'shipwreck' or chest.chest_type == 'bonus' then -- 日本語対応
				table.insert( html_per_stack, p.chests[chest.chest_name].link )
				table.insert( html_per_stack, 'の中に' )
			else
				table.insert( html_per_stack, p.chests[chest.chest_name].link )
				table.insert( html_per_stack, 'のチェストの中に' )
			end
			table.insert( html_per_stack, sep )
		end
		if nc > 2 then
			table.insert( html_per_stack, '全て' )
		end
		table.insert( html_per_stack, stacksize )
		if p.items[itemname].cannot_stack ~= nil then
			table.insert( html_per_stack, 'つ' )
		else
			table.insert( html_per_stack, '個' )
		end
		table.insert( html_per_stack, '生成される' )
	
		table.insert( html_stacks, table.concat( html_per_stack ) )
	end
	
	local stackwise_summaries = ''
	if #html_stacks == 1 then
		table.insert( html, html_stacks[1] )
	else
		for i = 1, #html_stacks - 1 do
			table.insert( html, html_stacks[ i ] )
			table.insert( html, stack_sep ) 
		end
		table.insert( html, 'また、' )
		table.insert( html, html_stacks[#html_stacks] )
	end
	
	table.insert( html, '。' )
	
	return table.concat( html )
	
end

p.base2_test = function()

	items = {}
	for item_name, v in pairs( p.items ) do
		table.insert( items, p.base2{ item_name, ["nocat"]=true } .. '\n\n' )
	end

	table.sort( items )
	
	return table.concat(items)
end








p.base3 = function( ... )

	p.current_frame = mw.getCurrentFrame()

	local args = { ... }
	if args[1] == p.current_frame then 
		args = require( 'Module:ProcessArgs' ).merge( true )
	else
		args = args[1]
	end
	
	local z = args[1]
	
	local html_java = {}
	local html_java_u = {}
	local html_bedrock = {}
	local html_bedrock_u = {}
	
	local rErr = ""
	
	local zT = {}
	if args[1] == "!!!ALL!!!" then
		for item_name, v in pairs( p.items ) do
			table.insert( zT, item_name )
			table.sort( zT )
		end
	else
		zT = mw.text.split( args[1], ',' )
	end
	
	for x, itemname in pairs( zT ) do
	
		if p.items[itemname] == nil then
			rErr = rErr .. "<span class='error'>" .. itemname .. " は不明なアイテムです。</span>\n"
		else
			
			local javaChances, javaUpcomingChances, bedrockChances, bedrockUpcomingChances
			
			if args.java and args.java ~= '0' then
				javaChances = q.single_item_find_values( itemname, 'poolsJava' )
				javaUpcomingChances = {}
				bedrockChances = {}
				bedrockUpcomingChances = {}
			else
				if args['java-upcoming'] and args['java-upcoming'] ~= '0' then
					javaChances = q.single_item_find_values( itemname, 'poolsJavaUpcoming' )
					javaUpcomingChances = {}
					bedrockChances = {}
					bedrockUpcomingChances = {}
				else
					if args.bedrock and args.bedrock ~= '0' then
						javaChances = q.single_item_find_values( itemname, 'poolsBedrock' )
						javaUpcomingChances = {}
						bedrockChances = {}
						bedrockUpcomingChances = {}
					else
						if args['bedrock-upcoming'] and args['bedrock-upcoming'] ~= '0' then
							javaChances = q.single_item_find_values( itemname, 'poolsBedrockUpcoming' )
							javaUpcomingChances = {}
							bedrockChances = {}
							bedrockUpcomingChances = {}
						else
							javaChances = q.single_item_find_values( itemname, 'poolsJava' )
							javaUpcomingChances = q.single_item_find_values( itemname, 'poolsJavaUpcoming', javaChances )
							bedrockChances = q.single_item_find_values( itemname, 'poolsBedrock', javaChances )
							bedrockUpcomingChances = q.single_item_find_values( itemname, 'poolsBedrockUpcoming', javaChances, bedrockChances )
						end
					end
				end
			end
			
			local any_current = q.tablelength( javaChances ) > 0
			local any_changes_upcoming = q.tablelength( javaUpcomingChances ) > 0 and q.compare_tables( javaChances, javaUpcomingChances )
			local any_standard = any_current or any_changes_upcoming
			
			local any_bedrock_current = q.tablelength( bedrockChances ) > 0
			local any_bedrock_upcoming = q.tablelength( bedrockUpcomingChances ) > 0 and q.compare_tables( bedrockChances, bedrockUpcomingChances )
			local any_bedrock = any_bedrock_current or any_bedrock_upcoming
			
			if any_current then
				table.insert( html_java, p.base3_sub( itemname, javaChances ) )
			end
			if any_changes_upcoming then
				table.insert( html_java_u, p.base3_sub( itemname, javaUpcomingChances ) )
			end
			if any_bedrock_current then
				table.insert( html_bedrock, p.base3_sub( itemname, bedrockChances ) )
			end
			if any_bedrock_upcoming then
				table.insert( html_bedrock_u, p.base3_sub( itemname, bedrockUpcomingChances ) )
			end
			
		end	
	end
	
	local output = rErr .. '{| class="wikitable sortable" \n! Item \n! Structure \n! Container \n! Quantity \n! Chance \n' .. table.concat( html_java )
	if q.tablelength( html_java_u ) > 0 then
		output = output .. '|-\n!colspan=5|' .. p['java-upcoming'] .. ' \n' .. table.concat( html_java_u ) 
	end
	if q.tablelength( html_bedrock ) > 0 then
		output = output .. '|-\n!colspan=5|' .. p.bedrock .. ' \n' .. table.concat( html_bedrock ) 
	end
	if q.tablelength( html_bedrock_u ) > 0 then
		output = output .. '|-\n!colspan=5|' .. p['bedrock-upcoming'] .. ' \n' .. table.concat( html_bedrock_u ) 
	end
	output = output .. '|}' .. p.current_frame:extensionTag( 'references', "", { group="note" } )
	
	return output
end

p.base3_sub = function( itemname, chances )
	local html = {}
	local item_display_name = ''
	local output = ""
	lang = mw.getContentLanguage()
	
	if p.items[itemname].title ~= nil then
		item_display_name = p.items[itemname].title
	else
		item_display_name = q.titlecase( string.gsub( itemname, '-', ' ' ) )
	end
	
	local objectList = {}
	local ns = q.tablelength( chances )
	local s = 0
	local m = 0
	
	local rn = 0

	for stacksize, chest_details in pairs( chances ) do
		s = s + 1
		
		local nc = q.tablelength( chest_details )
		local c = 0
		for k, chest in pairs( chest_details ) do
			c = c + 1
			rn = rn + 1
			local r = ""
			
			r = r .. '|' .. p.chests[chest.chest_name].container  .. '\n|' .. stacksize .. '\n|' .. lang:formatNum( math.floor( chest.chance*1000 + 0.5 ) /10 ) .. ' %' .. '\n'
			if ns ~= s or nc ~= c then
				r = r 
			end
			
			table.insert( objectList , { p.chests[chest.chest_name].structID , p.chests[chest.chest_name].structure, r } )
			
		end
		m = m + nc
	end
	table.sort( objectList, function(a,b) return a[1] < b[1] end )
	local struct = ""
	local t = ""
	local nt = 1
	local ntt = 0
	for v, w  in pairs( objectList ) do
		ntt = ntt + 1
		if w[1] ~= struct then
			if t ~= "" then
				output = output .. "|rowspan=" .. nt .. t
			end
			t = "|'''" .. p.current_frame:expandTemplate{ title = 'EnvLink', args = { w[2],  id = w[1] } } .. "'''\n" .. w[3]
			struct = w[1]
			nt = 1
		else
			t = t .. w[3]
			nt = nt + 1
		end
		if ntt == m then
			output = output .. "|rowspan=" .. nt .. t
		else
			t = t .. '|-' .. '\n'
		end
	end

	return "|-\n| rowspan=" .. m .. "|'''" .. p.getItem(itemname, item_display_name) .. "'''\n" .. output
	
end

p.getItem = function( itemname, item_display_name )
	local s = ""
	local k = item_display_name
	local link = item_display_name
	local m = itemname
	
	if p.items[itemname].title ~= nil then
		k = p.items[itemname].title
	end
	if p.items[itemname].link ~= nil then
		link = p.items[itemname].link
	end
	if p.items[itemname].id ~= nil then
		m = p.items[itemname].id
	end
	
	if p.items[itemname][1] == "item" then
		s = p.current_frame:expandTemplate{ title = 'ItemLink', args = { link , k , id = m } }
	elseif p.items[itemname][1] == "block" then
		s = p.current_frame:expandTemplate{ title = 'BlockLink', args = { link , k , id = m } }
	end
	if p.items[itemname].note ~= nil and p.items[itemname].note ~= "" then
		s = s .. p.current_frame:extensionTag( 'ref', p.notes3[p.items[itemname].note], { group='注釈', name=p.items[itemname].note } )
	end
	return s
	
end








q = {

	tablelength = function(T)
		local count = 0
		for _ in pairs(T) do count = count + 1 end
		return count
	end,
	
	deepcopy = function(orig)
	    local orig_type = type(orig)
	    local copy
	    if orig_type == 'table' then
	        copy = {}
	        for orig_key, orig_value in next, orig, nil do
	            copy[q.deepcopy(orig_key)] = q.deepcopy(orig_value)
	        end
	        setmetatable(copy, q.deepcopy(getmetatable(orig)))
	    else -- number, string, boolean, etc
	        copy = orig
	    end
	    return copy
	end,
	
	single_item_find_values = function( itemname, poolsKey, exclusions_param, other_exclusions_param )
	
		local chances = {}
		
		local exclusions = q.deepcopy(exclusions_param or {})
		local other_exclusions = q.deepcopy(other_exclusions_param or {})
		
		for stacksize, other_exclusion_list in pairs(other_exclusions) do
			if exclusions[stacksize] == nil then
				exclusions[stacksize] = {}
			end 
			for _, other_exclusion in pairs(other_exclusion_list) do
				local already_in_here = false
				for _, exclusion in pairs(exclusions[stacksize]) do
					if exclusion["chest_name"] == other_exclusion["chest_name"] and exclusion["chance"] == other_exclusion["chance"] then
						already_in_here = true
						break 
					end
				end
				if not already_in_here then
					table.insert( exclusions[stacksize], other_exclusion )
				end 
			end
		end

		for chest_name, chest in pairs( p.chests ) do
			local poolchances = {}
			for k, pool in pairs( chest[poolsKey] or chest.poolsJava or {} ) do
				local poolitem = pool.items[itemname]
				if poolitem ~= nil then
				
					local stacksize = poolitem[1]
					if poolitem[1] ~= poolitem[2] then
						stacksize = stacksize .. "–" .. poolitem[2]
					end
					
					local itemweight = poolitem[3]
					
					local pool_total_item_weight = 0
					for itemname, item in pairs(pool.items) do
						pool_total_item_weight = pool_total_item_weight + item[3]
					end
				
					local chance = p.calc_chance_any_of_this_item_per_pool( 
						pool.rolls[1], pool.rolls[2],
						itemweight, pool_total_item_weight )

					if poolchances[stacksize] == nil then
						poolchances[stacksize] = chance
					else
						poolchances[stacksize] = poolchances[stacksize] + (1 - poolchances[stacksize]) * chance
					end
				end
			end
			for stacksize, chance in pairs( poolchances ) do
				local excluded = false
				for _, exclusion in pairs( exclusions[stacksize] or {} ) do
					if exclusion["chest_name"] == chest_name and exclusion["chance"] == chance then
						excluded = true
						break 
					end
				end
				if not excluded then
					if chances[stacksize] == nil then
						chances[stacksize] = {}
					end
					table.insert( chances[stacksize], { ["chance"]=chance, ["chest_name"]=chest_name, ["chest_type"]=( chest.chest_type or "chest" ) } )
				end
			end
		end

		return chances
		
	end,
	
	single_item_plural = function( itemname )
	
		if string.sub( itemname, -2 ) == 'ss' 
			or string.sub( itemname, -2 ) == 'ch' 
			or string.sub( itemname, -2 ) == 'sh' 
			or string.sub( itemname, -1 ) == 's' then 
				return itemname .. 'es' 
		end
		
		return itemname .. 's'
	
	end,
	
	massage_args = function( args )

		-- find what columns to put
		
		local columns = {}
		
		for k, _arg in pairs(args) do
			if p.columns[_arg] ~= nil then
				columns[_arg] = true
			end
		end
		
		if q.tablelength(columns) == 0 then
			for column_name, v in pairs(p.columns) do
				columns[column_name] = true
			end
		end
		
		-- find what chests to show

		local chests = {}
		
		for k, _arg in pairs(args) do
			if p.chests[_arg] ~= nil then
				table.insert( chests, _arg )
			elseif p.synonyms[_arg] ~= nil then 
				table.insert( chests, p.synonyms[_arg] )
			end
			if p.display_names[_arg] ~= nil then
				local chestname = _arg
				if p.chests[chestname] == nil then 
					chestname = p.synonyms[_arg]
				end
				p.chests[chestname].display_name = p.display_names[_arg]
			end
		end
		
		if #chests == 0 then
			for chest_name, chest in pairs(p.chests) do
				local chest_type = ( chest.chest_type or "chest" )
				if chest_type == "chest" or chest_type == "minecart with chest" then
					table.insert( chests, chest_name )
				end
			end
		end
		
		table.sort( chests )
		
		return chests, columns
		
	end,

	sort_items = function( e1, e2 )
		
		if e1.chanceany ~= e2.chanceany then return ( e1.chanceany > e2.chanceany ) end
		if e1.avgamount ~= e2.avgamount then return ( e1.avgamount > e2.avgamount ) end
		
		if e1.material == nil then
			
			e1.material = 0
			if string.find( e1.itemname, "leather" ) ~= nil then e1.material = 1 end
			if string.find( e1.itemname, "iron" ) ~= nil then e1.material = 2 end
			if string.find( e1.itemname, "gold" ) ~= nil then e1.material = 3 end
			if string.find( e1.itemname, "diamond" ) ~= nil then e1.material = 4 end
			e1.armor = 0
			if string.find( e1.itemname, "helmet" ) ~= nil or string.find( e1.itemname, "cap" ) ~= nil then e1.armor = 1 end
			if string.find( e1.itemname, "chestplate" ) ~= nil or string.find( e1.itemname, "tunic" ) ~= nil then e1.armor = 2 end
			if string.find( e1.itemname, "leggings" ) ~= nil or string.find( e1.itemname, "pants" ) ~= nil then e1.armor = 3 end
			if string.find( e1.itemname, "boots" ) ~= nil then e1.armor = 4 end
			
		end
		
		if e2.material == nil then
			
			e2.material = 0
			if string.find( e2.itemname, "leather" ) ~= nil then e2.material = 1 end
			if string.find( e2.itemname, "iron" ) ~= nil then e2.material = 2 end
			if string.find( e2.itemname, "gold" ) ~= nil then e2.material = 3 end
			if string.find( e2.itemname, "diamond" ) ~= nil then e2.material = 4 end
			e2.armor = 0
			if string.find( e2.itemname, "helmet" ) ~= nil or string.find( e2.itemname, "cap" ) ~= nil then e2.armor = 1 end
			if string.find( e2.itemname, "chestplate" ) ~= nil or string.find( e2.itemname, "tunic" ) ~= nil then e2.armor = 2 end
			if string.find( e2.itemname, "leggings" ) ~= nil or string.find( e2.itemname, "pants" ) ~= nil then e2.armor = 3 end
			if string.find( e2.itemname, "boots" ) ~= nil then e2.armor = 4 end
		
		end
		
		if e1.material ~= e2.material then return ( e1.material < e2.material ) end
		if e1.armor ~= e2.armor then return ( e1.armor < e2.armor ) end
		
		return ( e1.itemname < e2.itemname )
		
	end,
	
	fill_in_chest_derivative_data = function( chest_names )

		for k, chest_name in pairs(chest_names) do
			local chest = p.chests[chest_name]
			if chest == nil then break end

			chest.allRollsJava = {}
			chest.itemDataJava = {}
			for k, pool in pairs( chest.poolsJava or {} ) do
				table.insert( chest.allRollsJava, ( pool.rolls[1] == pool.rolls[2] and pool.rolls[1] or pool.rolls[1]..'–'..pool.rolls[2] ) )

				local total_weight = 0
				for itemname, item in pairs(pool.items) do
					total_weight = total_weight + item[3]
				end
				pool.totalweight = total_weight

				q.fill_in_chest_item_details( chest.itemDataJava, pool, #chest.allRollsJava )
			end

			chest.allRollsJavaUpcoming = {}
			chest.itemDataJavaUpcoming = {}
			for k, pool in pairs( chest.poolsJavaUpcoming or chest.poolsJava or {} ) do
				table.insert( chest.allRollsJavaUpcoming, ( pool.rolls[1] == pool.rolls[2] and pool.rolls[1] or pool.rolls[1]..'–'..pool.rolls[2] ) )

				local total_weight = 0
				for itemname, item in pairs(pool.items) do
					total_weight = total_weight + item[3]
				end
				pool.totalweight = total_weight

				q.fill_in_chest_item_details( chest.itemDataJavaUpcoming, pool, #chest.allRollsJavaUpcoming )
			end

			chest.allRollsBedrock = {}
			chest.itemDataBedrock = {}
			for k, pool in pairs( chest.poolsBedrock or chest.poolsJava or {} ) do
				table.insert( chest.allRollsBedrock, ( pool.rolls[1] == pool.rolls[2] and pool.rolls[1] or pool.rolls[1]..'–'..pool.rolls[2] ) )

				local total_weight = 0
				for itemname, item in pairs(pool.items) do
					total_weight = total_weight + item[3]
				end
				pool.totalweight = total_weight

				q.fill_in_chest_item_details( chest.itemDataBedrock, pool, #chest.allRollsBedrock )
			end

			chest.allRollsBedrockUpcoming = {}
			chest.itemDataBedrockUpcoming = {}
			for k, pool in pairs( chest.poolsBedrockUpcoming or chest.poolsJava or {} ) do
				table.insert( chest.allRollsBedrockUpcoming, ( pool.rolls[1] == pool.rolls[2] and pool.rolls[1] or pool.rolls[1]..'–'..pool.rolls[2] ) )

				local total_weight = 0
				for itemname, item in pairs(pool.items) do
					total_weight = total_weight + item[3]
				end
				pool.totalweight = total_weight

				q.fill_in_chest_item_details( chest.itemDataBedrockUpcoming, pool, #chest.allRollsBedrockUpcoming )
			end
		end
	end,

	fill_in_chest_item_details = function( data, pool, ct )
		for item_name, item in pairs(pool.items) do
			if p.items[item_name] then
				local min_stacksize = item[1]
				local max_stacksize = item[2]
				local min_pool_rolls = pool.rolls[1]
				local max_pool_rolls = pool.rolls[2]
				local item_weight = item[3]
			
				if data[item_name] == nil then
					data[item_name] = {
						avgamount = 0,
						chanceany = 0,
						itemname = item_name,
						sortsize = {},
						sortweight = {},
						sizes = {},
						weights = {},
					}
					for i = 1, ct-1 do
						data[item_name].sortsize[i] = 0
						data[item_name].sortweight[i] = 0
						data[item_name].sizes[i] = '—'
						data[item_name].weights[i] = '—'
					end
				end

				data[item_name].avgamount = data[item_name].avgamount + p.calc_average_amount_this_item_per_pool( 
					min_stacksize, max_stacksize, 
					min_pool_rolls, max_pool_rolls, 
					item_weight, pool.totalweight )
					
				data[item_name].chanceany = data[item_name].chanceany + (1 - data[item_name].chanceany) * p.calc_chance_any_of_this_item_per_pool(
					min_pool_rolls, max_pool_rolls, 
					item_weight, pool.totalweight )

				data[item_name].sortsize[ct] = ( min_stacksize + max_stacksize ) / 2
				data[item_name].sortweight[ct] = item_weight;
				data[item_name].sizes[ct] = ( min_stacksize == max_stacksize and min_stacksize or min_stacksize .. '–' .. max_stacksize )
				data[item_name].weights[ct] = p.current_frame:expandTemplate{ title = 'frac', args = { item_weight, pool.totalweight } }
			end
		end

		for item_name, d in pairs(data) do
			if not d.sizes[ct] then
				d.sortsize[ct] = 0
				d.sortweight[ct] = 0
				d.sizes[ct] = '—'
				d.weights[ct] = '—'
			end
		end
	end,

	construct_ordered_items_from_first_chest = function( chest_names, suffix )
		local items_from_first_table = {}
		local item_chests = {}
		local item_names_ordered = {}
		for item_name, item in pairs( p.chests[chest_names[1]]['itemData'..suffix] ) do
			table.insert( items_from_first_table, item )
		end
		
		table.sort( items_from_first_table, q.sort_items )
		
		for k, item in pairs( items_from_first_table ) do
			table.insert( item_names_ordered, item.itemname )
			item_chests[item.itemname] = true
		end
		
		return item_names_ordered, item_chests
	end,

	get_ordered_items_from_other_chests = function( chest_names, item_chests, suffix )
		local items_not_from_first_table = {}
		
		for chest_idx = 2, #chest_names do
			for item_name, item in pairs( p.chests[chest_names[chest_idx]]['itemData'..suffix] ) do
				if item_chests[item_name] == nil then
					p.items[item_name].itemname = item_name
					table.insert( items_not_from_first_table, p.chests[chest_names[chest_idx]]['itemData'..suffix][item_name] )
					item_chests[item_name] = true
				end
			end
		end

		table.sort( items_not_from_first_table, q.sort_items )
		
		return items_not_from_first_table
	end,

	add_other_items_to_first_list = function( chest_names, item_names_ordered, item_chests, items_not_from_first_table )
		for k, item in pairs( items_not_from_first_table ) do
			table.insert( item_names_ordered, item.itemname )
		end
		
		return item_names_ordered
	end,

	set_up_ordered_item_rows = function( chest_names, item_names_ordered, suffix )
		for k, itemname in pairs(item_names_ordered) do
			item_names_ordered[k] = {itemname}
			for chest_idx = 1, #chest_names do
				if suffix == 'JavaUpcoming' or p.chests[chest_names[chest_idx]]['pools'..suffix] ~= nil then
					local item_data = p.chests[chest_names[chest_idx]]['itemData'..suffix][itemname]
					if item_data == nil then
						table.insert( item_names_ordered[k], false )
					else
						table.insert( item_names_ordered[k], item_data )
					end				
				end
			end
		end

		return item_names_ordered
	end,

	construct_ordered_item_rows = function( chest_names, suffix )
		-- for the first chest, sort its by chance desc, then by avg amount desc, then alphabetically asc
		local item_names_ordered, item_chests = q.construct_ordered_items_from_first_chest( chest_names, suffix )
		
		if #chest_names > 1 then
			-- after that, sort all the remaining items in list order
			local items_not_from_first_table = q.get_ordered_items_from_other_chests( chest_names, item_chests, suffix )
			item_names_ordered = q.add_other_items_to_first_list( chest_names, item_names_ordered, item_chests, items_not_from_first_table )
		end

		-- set up item_names_ordered so that each is a row, representing chest values
		item_names_ordered = q.set_up_ordered_item_rows( chest_names, item_names_ordered, suffix )
		
		return item_names_ordered
	end,

	print_table = function( chest_names, columns, ordered_item_rows, suffix )

		local html = {}
		
		local use_roll_row = false
		local use_superheader = false
		local superheader_sizes = {}
		for i = 1, #chest_names do
			sh = p.chests[chest_names[i]].superheader
			if sh ~= nil then
				if superheader_sizes[sh] == nil then
					superheader_sizes[sh] = 0
				end
				superheader_sizes[sh] = superheader_sizes[sh] + 1
				use_superheader = true
			end
			local allRolls = p.chests[chest_names[i]]['allRolls'..suffix]
			if #allRolls > 1 then
				use_roll_row = true
			end
		end
		if columns['stacksize'] == nil and columns['weight'] == nil then
			use_roll_row = false
		end
		
		local rowspan = ( #chest_names > 1 and 1 or 0 ) + ( use_superheader and 1 or 0 ) + 1
		local hide_col_description = rowspan > 1 and q.tablelength(columns) == 1
		if use_roll_row then
			rowspan = rowspan + 1
		end
		
		if q.tablelength(columns) == 1 then
			for column_name, v in pairs(columns) do
				if(suffix ~= '') then
					table.insert( html, "での" )
				end
				table.insert( html, p.columns[column_name] )
				table.insert( html, "\n" )
			end
		end

		if #chest_names == 1 then
		
			if q.tablelength(columns) == 1 then
				table.insert( html, "<br>" )
			end
		
			local chest_name = chest_names[1]
			local allRolls = p.chests[chest_name]['allRolls'..suffix]
			local chest_type = p.chests[chest_name].chest_type or "chest"

			local display_name = p.chests[chest_name].display_name

			chest_name = chest_name:gsub( "-", " " )
			
			if(suffix ~= '') then
				table.insert( html, "での" )
			end
			
			table.insert( html, display_name or chest_name )
			if chest_type ~= 'chest' and chest_type ~= 'minecart with chest' then
				table.insert( html, "には" )
			else
				table.insert( html, "のチェストには" )
			end
			  table.insert( html, '、' )
			  table.insert( html, 'アイテムが')
			if #allRolls == 1 then
				table.insert( html, allRolls[1] )
				table.insert( html, '個生成される。' )
			else
				local s = ( #allRolls > 2 and '個、' or '個と' )
				for i = 1, #allRolls-1 do
					table.insert( html, allRolls[i] )
					table.insert( html, s )
				end
				table.insert( html, '' )
				table.insert( html, allRolls[#allRolls] )
				table.insert( html, '個のスタック数で' )
				table.insert( html, #allRolls )
				table.insert( html, 'つのグループに分けられ生成される。' )
			end
			table.insert( html, "これらは以下の表のようになっている: \n" )
		end
		
		table.insert( html, '<div style="overflow:auto">\n' )
		table.insert( html, "<table class='wikitable sortable jquery-tablesorter'>\n" )
		table.insert( html, "<tr>\n" )
		table.insert( html, "<th rowspan=" )
		table.insert( html, ( rowspan - ( hide_col_description and 1 or 0 ) ) )
		table.insert( html, "></th>\n" )
		
		local superheader_cols_used = {}
		
		if #chest_names > 1 then
			local row1, row2 = {}, {}

			for i = 1, #chest_names do
			
				if suffix == 'JavaUpcoming' or p.chests[chest_names[i]]['pools'..suffix] ~= nil then
					local allRolls = p.chests[chest_names[i]]['allRolls'..suffix]
					local colspan = q.tablelength(columns)
					local allRollsSpan = #allRolls == 0 and 1 or #allRolls
					if columns['stacksize'] ~= nil then
						colspan = colspan - 1 + allRollsSpan
					end
					if columns['weight'] ~= nil then
						colspan = colspan - 1 + allRollsSpan
					end
					local row = row1
					
					rowspan = 1
					if use_superheader then
						sh = p.chests[chest_names[i]].superheader
						if sh ~= nil then
							if superheader_cols_used[sh] == nil then
								table.insert( row, "<th colspan=" )
								table.insert( row, ( colspan * superheader_sizes[sh] ) )
								table.insert( row, ">" )
								table.insert( row, sh )
								table.insert( row, "</th>\n" )
								superheader_cols_used[sh] = 0
							end
							row = row2
						else
							rowspan = rowspan + 1
						end
					end
					if use_roll_row and hide_col_description and #allRolls < 2 then
						rowspan = rowspan + 1
					end

					table.insert( row, "<th colspan=" )
					table.insert( row, colspan )
					if rowspan > 1 then
						table.insert( row, " rowspan=" )
						table.insert( row, rowspan )
					end
					table.insert( row, ">" )
					table.insert( row, p.chests[ chest_names[i] ].header )
					if #allRolls > 0 then
						table.insert( row, ' <br><span style="font-weight:normal; font-style:italic; font-size:11px;">(' )
						if #allRolls == 1 then
							table.insert( row, allRolls[1] )
						else
							local s = ( #allRolls > 2 and '、' or '' )
							for i = 1, #allRolls-1 do
								table.insert( row, allRolls[i] )
								table.insert( row, s )
							end
							table.insert( row, '、および' )
							table.insert( row, allRolls[#allRolls] )
						end
						table.insert( row, 'スタック)</span>' )
					end
					table.insert( row, "</th>\n" )
				end
			end
			
			table.insert( html, table.concat( row1 ) )
			table.insert( html, "</tr><tr>\n" )
			if #row2 then
				table.insert( html, table.concat( row2 ) )
				table.insert( html, "</tr><tr>\n" )
			end
		end

		if not hide_col_description then
			local headersort_th_open
			if use_roll_row then
				headersort_th_open = "<th rowspan='2' class='headersort' role='columnheader button' data-sort-type='number'> <abbr title='"
			else
				headersort_th_open = "<th class='headersort' role='columnheader button' data-sort-type='number'> <abbr title='"
			end
			for i = 1, #chest_names do
				if suffix == 'JavaUpcoming' or p.chests[chest_names[i]]['pools'..suffix] ~= nil then
					local allRolls = p.chests[chest_names[i]]['allRolls'..suffix]
					local allRollsSpan = #allRolls == 0 and 1 or #allRolls
					local headersort_th_colspan_open
					if #allRolls > 1 then
						headersort_th_colspan_open = "<th colspan='" .. allRollsSpan .. "' role='columnheader'> <abbr title='"
					else
						headersort_th_colspan_open = headersort_th_open
					end

					if columns['stacksize'] ~= nil then
						table.insert( html, headersort_th_colspan_open )
						table.insert( html, p.columns['stacksize'] )
						table.insert( html, "'> スタック数 </abbr></th>\n" )
					end
					if columns['weight'] ~= nil then
						table.insert( html, headersort_th_colspan_open )
						table.insert( html, p.columns['weight'] )
						table.insert( html, "'> 割合" )
						table.insert( html, "</abbr></th>\n" )
					end
					if columns['items'] ~= nil then
						table.insert( html, headersort_th_open )
						table.insert( html, p.columns['items'] )
						table.insert( html, "'> アイテム数 </abbr></th>\n" )
					end
					if columns['chance'] ~= nil then
						table.insert( html, headersort_th_open )
						table.insert( html, p.columns['chance'] )
						table.insert( html, "'> 確率 </abbr></th>\n" )
					end
					if columns['chests'] ~= nil then
						table.insert( html, headersort_th_open )
						table.insert( html, p.columns['chests'] )
						table.insert( html, "'> チェスト数 </abbr></th>\n" )
					end
				end
			end
			table.insert( html, "</tr><tr>\n" )
		end
		
		if use_roll_row then
			local rowcols = ( columns['stacksize'] ~= nil and 1 or 0 ) + ( columns['weight'] ~= nil and 1 or 0 )
			for i = 1, #chest_names do
				local allRolls = p.chests[chest_names[i]]['allRolls'..suffix]
				if #allRolls > 1 then
					for j = 1, rowcols do
						for k = 1, #allRolls do
							table.insert( html, "<th class='headersort' role='columnheader button' data-sort-type='number' style='font-weight:normal'><abbr title='チェストには、このグループからランダムに" )
							table.insert( html, allRolls[k] )
							table.insert( html, "個のスタックのアイテムが生成される'>" )
							table.insert( html, allRolls[k] )
							table.insert( html, "×</abbr></th>\n" )
						end
					end
				end
			end
			table.insert( html, "</tr><tr>\n" )
		end

		for i = 1, #ordered_item_rows do
			if type( ordered_item_rows[i] ) == "table" then
				for j = 1, #ordered_item_rows[i] do

					local chest_item = ordered_item_rows[i][j]
					
					if type( chest_item ) == "table" then
					
						local avg_amount = string.format("%.3f", chest_item.avgamount)
						local chance_any = string.format("%.1f", chest_item.chanceany*100) .. "%"
						local num_chests = string.format("%.1f", 1/chest_item.chanceany)
						
						table.insert( html, "\n" )
						if columns['stacksize'] ~= nil then
							for k = 1, #chest_item.sizes do
								table.insert( html, "<td style='text-align:center;' data-sort-value='" )
								table.insert( html, ( chest_item.sortsize[k] == 0 and "9e99" or chest_item.sortsize[k] ) )
								table.insert( html, "'>" )
								table.insert( html, chest_item.sizes[k] )
								table.insert( html, "</td>" )
							end
						end
						if columns['weight'] ~= nil then
							for k = 1, #chest_item.sizes do
								table.insert( html, "<td style='text-align:center;' data-sort-value='" )
								table.insert( html, ( chest_item.sortweight[k] == 0 and "9e99" or chest_item.sortweight[k] ) )
								table.insert( html, "'>" )
								table.insert( html, chest_item.weights[k] )
								table.insert( html, "</td>" )
							end
						end
						if columns['items'] ~= nil then
							table.insert( html, "<td style='text-align:center;'>" )
							table.insert( html, avg_amount )
							table.insert( html, "</td>" )
						end
						if columns['chance'] ~= nil then
							table.insert( html, "<td style='text-align:center;'>" )
							table.insert( html, chance_any )
							table.insert( html, "</td>" )
						end
						if columns['chests'] ~= nil then
							table.insert( html, "<td style='text-align:center;'>" )
							table.insert( html, num_chests )
							table.insert( html, "</td>" )
						end
							
					elseif type( chest_item ) == "boolean" then
						local allRolls = p.chests[chest_names[j-1]]['allRolls'..suffix]
						local allRollsSpan = #allRolls == 0 and 1 or #allRolls

						table.insert( html, "\n" )
						if columns['stacksize'] ~= nil then
							for k = 1, allRollsSpan do
								table.insert( html, "<td data-sort-value='9e99' style='text-align:center;'>—</td>" )
							end
						end
						if columns['weight'] ~= nil then
							for k = 1, allRollsSpan do
								table.insert( html, "<td data-sort-value='9e99' style='text-align:center;'>—</td>" )
							end
						end
						if columns['items'] ~= nil then
							table.insert( html, "<td data-sort-value='9e99' style='text-align:center;'>—</td>" )
						end
						if columns['chance'] ~= nil then
							table.insert( html, "<td data-sort-value='9e99' style='text-align:center;'>—</td>" )
						end
						if columns['chests'] ~= nil then
							table.insert( html, "<td data-sort-value='9e99' style='text-align:center;'>—</td>" )
						end
					else
						if i > 1 then
							table.insert( html, "</tr><tr>" )
						end
						
						local item = p.items[chest_item]
						
						local s = require( 'モジュール:Sprite' )
						table.insert( html, "\n<td>" )
						local image, spriteCat = s.link{ 
							id=item.id or chest_item, 
							link=item.link or string.gsub(chest_item,'-',' '), 
							text=item.title or q.titlecase(string.gsub(chest_item,'-',' ')), 
							data= ( item[1] == 'item' and 'ItemSprite' or 'BlockSprite' )
						}
						table.insert( html, image )
						table.insert( html, spriteCat )
						if item.note and p.notes[item.note] then
							table.insert( html, p.current_frame:extensionTag( 'ref', p.notes[item.note], { group='注釈', name=item.note } ) )
						end
						table.insert( html, "</td>" )
					end
					
					if j == #ordered_item_rows[i] then
						table.insert( html, "</tr>" )
					end
					
				end
				table.insert( html, "\n" )
			end
		end
		
		table.insert( html, "</table></div>" )
		
		return table.concat( html )
		
	end,
	
	titlecase = function( str )
		local buf = {}
		for word in string.gfind(str, "%S+") do
			if word == "and" then
				table.insert( buf, word )
			else
				local first, rest = string.sub( word, 1, 1 ), string.sub( word, 2 )
				table.insert( buf, string.upper(first) .. string.lower(rest) )
			end
		end    
		return table.concat( buf, " " )
	end,
	
	capitalize = function( str )
		return ( string.lower(str):gsub( "^%l", string.upper ) )
	end,

	lcfirst = function( str )
		return ( string.gsub( str, "^%u", string.lower ) )
	end,
	
	compare_tables = function( a, b )
		local seen = {}
		for k, v in pairs( a ) do
			if type( v ) ~= type( b[k] ) then
				return true
			end
			if v ~= b[k] then
				return true
			end
			if type( v ) == 'table' and q.compare_tables( v, b[k] ) then
				return true
			end
			seen[k] = true
		end
		for k, v in pairs( b ) do
			if not seen[k] then
				return true
			end
		end
		return false
	end,
}

string.lpad = function(str, len, char)
	if char == nil then char = ' ' end
	return string.rep(char, len - #(''..str)) .. str
end

return p