API

Weltgenerierung

Erze, Bäume, Blumen, Strukturen und Biome, die von selbst in der Welt erscheinen. Du legst fest, was und wo, und neue Chunks bekommen es.

Erze

content/ruby_ore.craftCraftScript

block "ruby_ore" { hardness: 3, tool: "pickaxe", tier: "iron" }

ore "ruby_ore" {
    replaces: "stone_and_deepslate"
    size: 9
    per_chunk: 8
    height: [-60, 60]
}

Eigenschaft	Werte	Standard
`block`	der Block, der platziert wird: `"mymod:other"`	der Block mit dem Namen des Erzes
`replaces`	`stone`, `deepslate`, `stone_and_deepslate` (Oberwelt), `netherrack` (Nether) oder `end_stone` (End)	`stone_and_deepslate`
`size`	Blöcke pro Ader, 1–64	8
`per_chunk`	Adern, die pro Chunk versucht werden	8
`height`	`[min, max]`, Höhenbereich	`[-64, 64]`
`biomes`	nur in diesen Biomen, per ID oder Tag	jedes Biom, in dem sein Gestein vorkommt

Ohne biomes erscheint das Erz in jedem Biom der Dimension, zu der replaces gehört; ein end_stone-Erz in jedem Biom des Ends. Der Block selbst wird wie jeder andere deklariert, mit Härte, Werkzeug und Beute; siehe Blöcke, Gegenstände und Rezepte.

content/void_ore.craftCraftScript

ore "void_ore" {
    replaces: "end_stone"
    size: 5
    per_chunk: 6
    height: [10, 80]
    biomes: ["mymod:crystal_glade"]
}

Bäume

Ein Baum ist ein gerader Stamm mit einer Kugel aus Blättern. Deklariere die beiden Blöcke, dann den Baum.

content/ruby_tree.craftCraftScript

block "ruby_log" { hardness: 2, tool: "axe", sound: "wood" }
block "ruby_leaves" { hardness: 0.2, transparent: true, sound: "grass" }

tree "ruby_tree" {
    trunk: "ruby_log"
    leaves: "ruby_leaves"
    height: 6
    height_variation: 2
    leaves_radius: 2
    per_chunk: 2
    biomes: ["#minecraft:is_forest", "minecraft:plains"]
}

Eigenschaft	Werte	Standard
`trunk`	der Stammblock, aus der Mod oder dem Spiel: `"ruby_log"`, `"minecraft:oak_log"`	—
`leaves`	der Blätterblock	—
`height`	Höhe des Stamms in Blöcken	5
`height_variation`	wie stark die Höhe von Baum zu Baum schwankt	2
`leaves_radius`	Radius der Blätterkugel in Blöcken	2
`per_chunk`	Bäume, die pro Chunk versucht werden	1
`biomes`	Biome, in denen es erscheint, per ID oder Tag	—

Biome gibst du per ID (minecraft:plains) oder per Tag (#minecraft:is_forest) an, beliebig gemischt. Stamm und Blätter können Blöcke der Mod oder des Spiels sein.

Pflanzen und Pflanzenfelder

Eine Pflanze ist ein Block, der als zwei gekreuzte Bilder gezeichnet wird, wie eine Blume: Nichts kollidiert mit ihr, und Licht scheint hindurch. Ihre Textur ist textures/block/ruby_flower.png, mit transparentem Hintergrund.

content/ruby_flowers.craftCraftScript

block "ruby_flower" { plant: true, hardness: 0 }

patch "ruby_flowers" {
    block: "ruby_flower"
    biomes: ["#minecraft:is_overworld"]
    rarity: 4
    size: 32
    spread: 7
}

Ein Pflanzenfeld verteilt Pflanzen in der Welt:

Eigenschaft	Werte	Standard
`block`	der Pflanzenblock	—
`biomes`	Biome, in denen es erscheint, per ID oder Tag	—
`rarity`	ein Feld alle so viele Chunks	4
`size`	Pflanzen, die jedes Feld zu setzen versucht	32
`spread`	größte Entfernung zur Feldmitte in Blöcken	7

Pflanzen werden nur in der Luft über dem Boden der Oberwelt gesetzt (Gras, Erde, Moos und Schlamm). Für Pflanzen auf anderem Untergrund, an Wänden oder von Decken hängend schreibst du ein Feature: siehe Generierung per Code.

Strukturen

Eine Struktur ist ein Bauwerk, das du selbst baust:

Baue sie im Spiel.
Speichere sie mit einem Strukturblock.
Kopiere die Datei .nbt in den Ordner structures/ der Mod: neben die Skripte bei einer CraftScript-Mod oder nach assets/<Mod-ID>/structures/ in einem Kotlin- oder Java-Jar.

Dann deklarierst du sie:

content/ruby_shrine.craftCraftScript

structure "ruby_shrine" {
    file: "ruby_shrine"
    biomes: ["#minecraft:is_overworld"]
    spacing: 24
    separation: 8
    buried: false
}

Eigenschaft	Werte	Standard
`file`	Name der .nbt-Datei, ohne Endung	die erste Variante oder der Name der Struktur
`biomes`	Biome, in denen es erscheint, per ID oder Tag	—
`spacing`	ungefähr eine Struktur alle so viele Chunks	24
`separation`	nie näher als so viele Chunks; kleiner als spacing	8
`buried`	true versenkt sie im Boden, für Ruinen	false
`offset_y`	Blöcke über der Oberfläche, auf der sie steht; negativ versenkt sie	0
`adapt_ground`	true füllt den Boden unter ihr auf und räumt ihn um sie herum frei; false setzt sie, wie sie ist	`true`
`heights`	`[min, max]`: in einer zufälligen Höhe in diesem Bereich, wo auch immer die Oberfläche liegt, statt auf der Oberfläche (ein Haus im Himmel)	auf der Oberfläche

Finde sie mit /locate structure <Mod-ID>:ruby_shrine und setze sie mit /place structure <Mod-ID>:ruby_shrine.

Varianten, Ersetzungen und Verfall

Eine Struktur kann aus mehreren Dateien stammen, und ihre Blöcke können sich beim Platzieren ändern. So entstehen Ruinen, die nie ganz gleich sind:

content/old_ruins.craftCraftScript

structure "old_ruins" {
    variants: [{ file: "ruins_small", weight: 3 }, "ruins_tower"]
    biomes: ["#minecraft:is_forest"]
    spacing: 20
    separation: 6
    offset_y: -2
    skip: ["minecraft:air"]
    replace: [{ block: "minecraft:stone_bricks", with: "minecraft:cracked_stone_bricks", chance: 0.3 }]
    decay: { left: 0.8, blocks: ["minecraft:stone_bricks", "minecraft:cracked_stone_bricks"] }
}

Eigenschaft	Werte	Standard
`variants`	Dateien, von denen sie eine ist: Namen oder `{ file, weight }`; eine wird zufällig gewählt, nach Gewicht	nur `file`, Gewicht 1
`skip`	Blöcke ihrer Dateien, die nicht platziert werden. `"minecraft:air"` behält die Blöcke der Welt dort, wo die Datei Luft hat	—
`replace`	`[{ block, with, chance }]`: Ein Block ihrer Dateien wird mit dieser Wahrscheinlichkeit zu einem anderen (mehr als 0, bis 1)	chance 1
`decay`	`{ left, blocks }`: Nur `left` (0–1) von `blocks` (IDs oder Tags) bleibt erhalten; ohne `blocks` von jedem Block	alles bleibt erhalten

Strukturen aus zusammenhängenden Teilen

Ein Dorf oder ein Verlies besteht aus Teilen, die sich verbinden: Eine Straße führt zu einem Haus, ein Gang zu einem Raum. Jedes Teil ist eine Datei mit den Verbundblöcken des Spiels darin, und jeder Verbundblock nennt den Pool, aus dem das nächste Teil kommt, als <Mod-ID>:<Pool>. Deklariere die Pools; die Struktur beginnt beim ersten.

content/hamlet.craftCraftScript

structure "hamlet" {
    biomes: ["minecraft:plains"]
    spacing: 34
    separation: 8
    depth: 6
    pools: [
        { name: "hamlet/square", pieces: [{ file: "hamlet/square" }] },
        { name: "hamlet/streets", fallback: "hamlet/street_ends",
          pieces: [{ file: "hamlet/street_straight", weight: 3, follows_ground: true },
                   { file: "hamlet/street_corner", follows_ground: true }],
          replace: [{ block: "minecraft:stone_bricks", with: "minecraft:oak_planks", where: "minecraft:water" }] },
        { name: "hamlet/street_ends", pieces: [{ file: "hamlet/street_end", follows_ground: true }] },
        { name: "hamlet/houses", none: 2,
          pieces: [{ file: "hamlet/house_small", weight: 4 }, { file: "hamlet/house_big" }] },
    ]
}

Eigenschaft	Werte	Standard
`pools`	die Pools der Teile; im ersten beginnt sie	ein Teil, aus `variants` oder `file`
`depth`	wie viele Teile weit sie vom ersten aus reicht	1

Jeder Pool hat:

Schlüssel	Werte	Standard
`name`	der Name, den seine Verbundblöcke verwenden, wie `hamlet/streets`	—
`pieces`	`[{ file, weight, follows_ground }]`. `follows_ground: true` biegt das Teil dem Boden unter ihm an, für Straßen und Wege; false hält es gerade, für Häuser	Gewicht 1, `false`
`features`	`[{ id, weight }]`: ein Feature als Teil, eigenes oder das des Spiels (`minecraft:chorus_plant`)	—
`none`	Gewicht für gar kein Teil, für ein leeres Grundstück	0
`fallback`	der Pool, der verwendet wird, wo kein Teil passt, etwa am Ende einer Straße	nichts
`skip`, `replace`	wie bei einer einzelnen Struktur. In einem Pool kann eine Ersetzung `where` hinzufügen: nur dort, wo die Welt schon diesen Block hat (die Ziegel einer Straße über Wasser werden zu Holzbrettern)	—

Alle Teile bleiben innerhalb von 80 Blöcken vom ersten.

Zwei Optionen gibt es vorerst nur in Kotlin: salt, eine Zahl, die bestimmt, wo in ihrem Abschnitt von spacing Chunks die Struktur landet (zwei Strukturen mit demselben Abstand und Salt landen an denselben Stellen; ohne sie wird eines aus der ID der Struktur gebildet), und aboveBottom, wie viele Blöcke über dem Weltboden ihre Teile bleiben müssen (wo eines tiefer reichen würde, wird die Struktur nicht erzeugt).

Strukturen, die dein Code Block für Block baut, stehen auf der Seite Generierung per Code.

Biome

Ein eigenes Biom übernimmt einen Teil der Orte eines Spielbioms. Es behält, was dort wächst, lebt und ausgehöhlt ist, und bringt sein eigenes Klima und eigene Farben mit.

content/ruby_meadow.craftCraftScript

biome "ruby_meadow" {
    replaces: "minecraft:plains"
    share: 0.5
    temperature: 0.8
    downfall: 0.4
    precipitation: true
    grass_color: "#d05070"
    foliage_color: "#c04060"
    sky_color: "#ff9fb0"
    fog_color: "#ffd0d8"
    water_color: "#ff6080"
    water_fog_color: "#a03050"
}

Eigenschaft	Werte	Standard
`replaces`	das Spielbiom, dessen Orte es übernimmt: `"minecraft:plains"`	`"minecraft:plains"`
`share`	Anteil dieser Orte, den es übernimmt, größer als 0 und bis 1	0.5
`temperature`	Temperatur des Klimas	0.8
`downfall`	wie viel es regnet	0.4
`precipitation`	`true` bei Regen, `false` ohne	`true`
`grass_color`	Grasfarbe, `#rrggbb`	die des ersetzten Bioms
`foliage_color`	Laubfarbe	die des ersetzten Bioms
`sky_color`	Himmelsfarbe	die des ersetzten Bioms
`fog_color`	Nebelfarbe	die des ersetzten Bioms
`water_color`	Wasserfarbe	`#3f76e4`
`water_fog_color`	Farbe des Nebels unter Wasser	die des ersetzten Bioms

share verteilt sich gleichmäßig über die Orte, an denen das ersetzte Biom läge: 0.5 nimmt die Hälfte, jeden zweiten. Das neue Biom erbt, was dort wächst, lebt und ausgehöhlt ist (Vegetation, Erze, Höhlen, Kreaturen, Musik) und alles, was andere Mods diesem Biom hinzufügen. Farben, die du weglässt, bleiben die des ersetzten Bioms.

Mehrere Biome können dasselbe ersetzen: Sie teilen sich dessen Orte. Finde deines mit /locate biome <Mod-ID>:ruby_meadow.

Klang, Boden und Kreaturen

Ein Biom kann auch eigene Musik und eigene Luft haben, seinen Boden mit einem Block von dir bedecken und bestimmen, wer dort lebt:

content/glow_marsh.craftCraftScript

biome "glow_marsh" {
    replaces: "minecraft:swamp"
    share: 0.4
    music: "mymod:music.marsh"
    ambient_sound: "mymod:ambient.marsh_hum"
    particle: { id: "minecraft:glow", chance: 0.005 }
    surface: "mymod:glow_moss"
    spawns: [
        { creature: "minecraft:frog", weight: 10, group: [2, 5] },
        { creature: "mymod:marsh_wisp", weight: 4, group: [1, 2] },
    ]
}

Eigenschaft	Werte	Standard
`music`	eine Sound-ID, die als Musik des Bioms gespielt wird	die des ersetzten Bioms
`ambient_sound`	ein Geräusch, das dort immer weiterläuft (Wind, ein Summen)	das des ersetzten Bioms
`particle`	`{ id, chance }`: ein Partikel, das in seiner Luft schwebt; `chance` pro Stelle in der Nähe des Spielers und Tick (0.001 sind wenige)	das des ersetzten Bioms; chance 0.01
`surface`	der Block, mit dem sein Boden bedeckt ist (der oberste Block jeder Ebene)	der übliche Boden der Dimension
`spawns`	`[{ creature, weight, group }]`: die Kreaturen, die dort leben; wenn es welche nennt, genau diese und keine anderen	die des ersetzten Bioms; weight 10, group `[1, 4]`
`inherits`	`false`: Nur das, was diesem Biom gegeben wird, wird dort generiert (seine `features`, seine `carvers`, was Mods darin platzieren), nicht das, was im ersetzten Biom generiert wird	`true`
`features`	`[{ id, step }]`: bereits vorhandene Features, die des Spiels oder aus Daten, die darin platziert werden. `step` ist `lakes`, `surface`, `ores`, `underground` oder `vegetation`	—
`carvers`	IDs von Carvern, die seine Höhlen aushöhlen, eigene oder die des Spiels; sie laufen in der angegebenen Reihenfolge, vor denen des ersetzten Bioms	—

Mit inherits: false übernimmt das Biom weiterhin die Orte des ersetzten Bioms sowie dessen Kreaturen und Geräusche, sofern du keine eigenen angibst; nur das, was dort wächst und ausgehöhlt wird, kommt nicht mehr mit. Ein Block für Block gemachter Boden und eigene Carver stehen auf der Seite Generierung per Code.

Biome des Ends

Im End übernimmt ein Biom ganze Regionen, etwa 200 Blöcke breit, statt Klimaorte. Ersetzt es minecraft:end_highlands, übernimmt es das gesamte Inselland seiner Regionen (Highlands, Midlands und Barrens); ersetzt es minecraft:small_end_islands, die Leere zwischen den Inseln. Die zentrale Insel bleibt die des Spiels, und die Regionen sind in jeder Welt anders.

content/crystal_glade.craftCraftScript

biome "crystal_glade" {
    replaces: "minecraft:end_highlands"
    share: 0.3
    sky_color: "#2a1840"
    fog_color: "#3c2a5a"
    surface: "mymod:crystal_moss"
    inherits: false
    features: [{ id: "minecraft:end_gateway_return", step: "surface" }]
}

Gut zu wissen

Nur neue Chunks. Bereits generierte Chunks ändern sich nicht; nur Chunks, die nach der Installation der Mod generiert werden, erhalten Erze, Bäume, Pflanzen, Strukturen und Biome. Erkunde neues Gelände, um sie zu finden.
Fehlende Namen werden ausgelassen. Ein Biom oder Tag in biomes, das nicht existiert (etwa das einer anderen Mod, die nicht installiert ist), wird übersprungen, kein Fehler.
Kein Boden, keine Struktur. Eine Struktur, die auf der Oberfläche steht, wird dort nicht erzeugt, wo ihre Spalte gar keinen Boden hat, etwa in der Leere zwischen den End-Inseln.
Features, Strukturen, Land, Biomkarten, Carver und Böden, die in Code geschrieben werden, stehen auf der Seite Generierung per Code.
Ganze eigene Welten stehen auf der Seite Dimensionen.

In Kotlin

content/World.ktKotlin

ore("ruby_ore") {
    replaces = OreHost.STONE_AND_DEEPSLATE
    size = 9
    perChunk = 8
    minY = -60
    maxY = 60
}

ore("void_ore") {
    replaces = OreHost.END_STONE
    biome("mymod:crystal_glade")
}

tree("ruby_tree") {
    trunk = "ruby_log"
    leaves = "ruby_leaves"
    height = 6
    perChunk = 2
    biome("#minecraft:is_forest")
}

block("ruby_flower") { plant = true }

patch("ruby_flowers") {
    block = "ruby_flower"
    rarity = 4
    biome("#minecraft:is_overworld")
}

structure("old_ruins") {
    variant("ruins_small", weight = 3)
    variant("ruins_tower")
    biome("#minecraft:is_forest")
    spacing = 20
    offsetY = -2
    skip("minecraft:air")
    replace("minecraft:stone_bricks", "minecraft:cracked_stone_bricks", chance = 0.3)
    decay(0.8, "minecraft:stone_bricks", "minecraft:cracked_stone_bricks")
    salt = 120457
}

structure("hamlet") {
    biome("minecraft:plains")
    spacing = 34
    depth = 6
    pool("hamlet/square") { piece("hamlet/square") }
    pool("hamlet/streets") {
        piece("hamlet/street_straight", weight = 3, followsGround = true)
        piece("hamlet/street_corner", followsGround = true)
        fallback = "hamlet/street_ends"
        replace("minecraft:stone_bricks", "minecraft:oak_planks", where = "minecraft:water")
    }
    pool("hamlet/street_ends") { piece("hamlet/street_end", followsGround = true) }
    pool("hamlet/houses") {
        piece("hamlet/house_small", weight = 4)
        piece("hamlet/house_big")
        none = 2
    }
}

biome("glow_marsh") {
    replaces = "minecraft:swamp"
    share = 0.4
    music = "mymod:music.marsh"
    ambientSound = "mymod:ambient.marsh_hum"
    particle("minecraft:glow", chance = 0.005)
    surface = "mymod:glow_moss"
    spawn("minecraft:frog", weight = 10, group = 2..5)
}

biome("crystal_glade") {
    replaces = "minecraft:end_highlands"
    share = 0.3
    surface = "mymod:crystal_moss"
    inherits = false
    feature("minecraft:end_gateway_return", FeatureStep.SURFACE)
}