Crafting

API

Generierung per Code

Wenn Deklarieren nicht reicht, baut dein Code die Welt, während Chunks erzeugt werden: Features, ganze Strukturen, die Form des Landes, welches Biom wohin kommt, Höhlen und die Blöcke des Bodens.

Was du schreiben kannst

Was Kotlin CraftScript
Features: Spitzen, Pflanzen an Wänden, Felsbrocken, alles, was in einem Chunk platziert wird feature("…") { place { } } Nein
Per Code gebaute Strukturen, über mehrere Chunks structure("…") { plan { }; build { } } Ja (plan, build)
Das Land einer Dimension terrain("minecraft:the_end") { } Ja (terrain)
Welches Biom wohin kommt biomes("minecraft:the_end") { } Ja (biome_map)
Carver: Höhlen und Tunnel carver("…", chance) { } Ja (carver)
Der Boden eines Bioms, Block für Block biome("…") { surface { } } Ja (surface: fun(at))
Tags für Blöcke, Gegenstände und Biome tag(TagKind.BIOME, "…", …) Nein

Alles auf dieser Seite läuft, während Chunks erzeugt werden, auf mehreren Threads gleichzeitig. Verwende die Zufallszahlen, die du bekommst (oder den Seed der Welt), statt eigener: Derselbe Seed erzeugt dann dieselbe Welt. Achte in Kotlin darauf, dass alles, was dein Code zwischen Aufrufen teilt, threadsicher ist. In CraftScript sind die Mitglieder von random nicht verfügbar; hole Abwechslung aus den Koordinaten, dem Seed oder dem Standort der Struktur.

Features

Ein Feature ist etwas, das dein Code in einem Chunk baut, der gerade erzeugt wird, in den Biomen, die du auflistest. Crafting wählt die Orte, wie das Spiel es bei seinen eigenen Features tut; deine Funktion place baut dort und gibt true zurück, wenn sie etwas gebaut hat. Features werden in Kotlin geschrieben.

content/CrystalSpikes.ktKotlin
object CrystalSpikes {
    private val CRYSTAL = Identifier.parse("mymod:crystal")

    fun register(content: ContentBuilder) {
        content.feature("crystal_spike") {
            biome("#minecraft:is_overworld")
            count = 2..5
            heights = -54..30
            on = FeatureOn.FLOOR
            underground = true
            step = FeatureStep.UNDERGROUND
            place { world ->
                val (x, y, z) = Triple(world.x, world.y, world.z)
                if (!world.isIn(x, y - 1, z, "#minecraft:base_stone_overworld")) return@place false
                val height = 2 + world.random.nextInt(4)
                for (dy in 0 until height) {
                    if (!world.isAir(x, y + dy, z)) break
                    world.set(x, y + dy, z, CRYSTAL)
                }
                true
            }
        }
    }
}
Option Werte Standard
biome(…) Biome, in denen es platziert wird, per ID oder #tag; mindestens eines —
count Versuche pro Chunk, ein Bereich: 2..5 1..1
chance nur in einem von so vielen Chunks 1
heights jeder Versuch in einer zufälligen Höhe in diesem Bereich null: der Boden der Welt (dein Code findet seinen Platz)
spread true: jeder Versuch in einer zufälligen Spalte des Chunks; false: an der Ecke des Chunks, und dein Code wählt von dort aus true
on FeatureOn.FLOOR oder CEILING: Von seiner Höhe aus wandert es in die Luft neben dem nächsten Boden oder der nächsten Decke, bis zu 32 Blöcke weit; findet es keine, wird es nicht platziert null
underground true: nur unter der Oberfläche, mindestens 2 Blöcke darunter (in Höhlen) false
everyFloor true: auf jedem Boden jeder gewählten Spalte, der Oberfläche und dem Boden jeder Höhle; count sind die Spalten pro Boden false
tries mit everyFloor, wie oft die Böden durchgegangen werden: jedes Mal count weitere Spalten auf jedem Boden, sodass ein tiefes Land mit mehr Versuchen erreicht wird 1..1
step wann es gemacht wird, unter den Schritten, die einen Chunk füllen: LAKES, SURFACE, ORES, UNDERGROUND (was Höhlen schmückt), VEGETATION VEGETATION

Mit everyFloor werden chance, heights und spread nicht verwendet: Die Orte sind die Böden selbst.

content/GlowTufts.ktKotlin
content.feature("glow_tufts") {
    biome("mymod:crystal_glade")
    everyFloor = true
    count = 4..8
    tries = 1..3
    place { world ->
        val tuft = Identifier.parse("mymod:glow_tuft")
        if (world.structures(world.x, world.z).isNotEmpty()) return@place false
        world.canStay(world.x, world.y, world.z, tuft) && world.set(world.x, world.y, world.z, tuft)
    }
}

Was ein Feature sieht

place erhält die Welt, die gerade erzeugt wird, von dem Ort aus gesehen, an dem das Feature platziert wird. Es darf den Chunk, der gerade erzeugt wird, und die Chunks um ihn herum lesen und setzen; Setzen außerhalb davon wird übersprungen. In CraftScript (im build einer Struktur) werden dieselben Mitglieder in snake_case geschrieben.

Mitglied Was es ist
x, y, z wo es platziert wird
random seine eigenen Zufallszahlen: Derselbe Seed erzeugt dasselbe Feature
seed der Seed der Welt, für ein Rauschen, das über die ganze Welt gleich ist
minY, maxY die Höhen der Welt; Blöcke reichen von minY bis unter maxY
block(x, y, z), state(x, y, z, name), isAir(x, y, z) der Block dort, der Wert eines seiner Zustände, ob es Luft ist
isIn(x, y, z, tag) ob der Block dort in einem Tag ("#minecraft:leaves") ist oder dieser Block ist ("minecraft:end_stone")
canStay(x, y, z, block, states) ob ein Block mit diesen Zuständen dort bleiben könnte: eine Pflanze auf ihrem Boden, ein Moos an einer Wand, von ihr abgewandt. states kann weggelassen werden
set(x, y, z, block, states) setzt einen Block, mit Zuständen wie mapOf("facing" to "north"); false, wenn es außerhalb dessen liegt, was gesetzt werden darf, oder hier kein Block ist
inside(x, z) ob die Spalte eine ist, die gelesen und gesetzt werden darf
surface(x, z) der erste Block über dem höchsten, der keine Luft ist, so wie das Land vor den Features war
top(x, z) dasselbe, jetzt, mit dem, was Features seitdem gesetzt haben
flow(x, y, z) lässt das Wasser (oder die Lava oder einen Block, der Wasser hält) dort fließen, sobald der Chunk in der Welt ist. Wasser, das gesetzt wird, während ein Chunk erzeugt wird, bleibt still und würde ohne dies neben Luft hängen
structures(x, z) die Strukturen (IDs, wie minecraft:end_city), deren Bereich den Chunk dieser Spalte umfasst, um ein Feature aus ihnen herauszuhalten
placeFile(file, x, y, z, rotation, mirror, pivotX, pivotZ) platziert eine Strukturdatei; siehe Strukturdateien per Code

Ein Block, den dein Feature nennt und der nicht existiert (aus einer Mod, die nicht installiert ist), wird ausgelassen, mit einer Warnung im Log; set gibt dafür false zurück.

Per Code gebaute Strukturen

Für eine Struktur, die nicht aus Dateien besteht oder dem Land folgen muss, entscheidet dein Code, wo sie ist, und baut sie. Sie braucht zwei Funktionen:

  • plan wird in jedem Chunk, in dem die Welt eine platzieren würde (nach biomes, spacing und separation, wie bei jeder Struktur), gefragt, ob sie dort ist, bevor die Blöcke des Chunks erzeugt werden. Es gibt ihren Standort zurück: ihre Mitte, wie weit sie reicht und was der Bau sonst braucht; oder nichts, dann gibt es dort keine.
  • build baut den Teil des Standorts in jedem Chunk, den er abdeckt, einen Chunk nach dem anderen. Jeder Chunk erhält denselben Standort und dieselben Zufallszahlen, sodass jeder sein Stück derselben Struktur baut. Der Standort wird mit der Welt gespeichert, daher passen nach einem Neustart erzeugte Chunks weiterhin zusammen.
content/stone_ring.craftCraftScript
structure "stone_ring" {
    biomes: ["#minecraft:is_overworld"]
    spacing: 32
    separation: 12
    plan: fun(p) {
        let x = p.chunk_x * 16 + 8
        let z = p.chunk_z * 16 + 8
        let y = p.height(x, z)
        return { x: x, y: y, z: z, radius: 10, min_y: y - 8, max_y: y + 12 }
    }
    build: fun(world, site) {
        for i in 0..15 {
            let a = i * pi() / 8
            let x = site.x + round(cos(a) * 10)
            let z = site.z + round(sin(a) * 10)
            if world.inside(x, z) {
                let ground = world.surface(x, z)
                for dy in 0..2 { world.set(x, ground + dy, z, "minecraft:mossy_cobblestone") }
            }
        }
    }
}
content/StoneRing.ktKotlin
content.structure("stone_ring") {
    biome("#minecraft:is_overworld")
    spacing = 32
    separation = 12
    plan { p ->
        val x = p.chunkX * 16 + 8
        val z = p.chunkZ * 16 + 8
        val y = p.height(x, z)
        StructureSite(x, y, z, radius = 10, minY = y - 8, maxY = y + 12,
            data = mapOf("tall" to p.random.nextBoolean()))
    }
    build { world, site ->
        val stone = Identifier.parse("minecraft:mossy_cobblestone")
        val top = if (site.data["tall"] == true) 4 else 2
        for (i in 0 until 16) {
            val x = site.x + (cos(i * PI / 8) * 10).roundToInt()
            val z = site.z + (sin(i * PI / 8) * 10).roundToInt()
            if (!world.inside(x, z)) continue
            val ground = world.surface(x, z)
            for (dy in 0..top) world.set(x, ground + dy, z, stone)
        }
    }
}

Der Standort (StructureSite in Kotlin, eine Map in CraftScript):

Feld Was es ist Standard in CraftScript
x, y, z ihre Mitte 0
radius wie viele Blöcke um die Mitte sie reicht: die Chunks, die sie abdeckt 8
min_y, max_y (minY, maxY) die Höhen, die sie abdeckt y minus und plus radius
data was der Bau braucht, um in jedem Chunk dasselbe zu bauen: Zahlen, Text, wahr oder falsch leer

In Kotlin hat ein Standort außerdem einen seed, der aus seiner Position gebildet wird. Zahlen in data kommen nach einem Neustart als Dezimalzahlen zurück: Lies sie mit (site.data["n"] as Number).toInt().

Was plan erhält, bevor ein Block des Chunks erzeugt wird:

Mitglied Was es ist
chunkX, chunkZ der Chunk, für den gefragt wird (Block / 16)
seed, random der Seed der Welt und die eigenen Zufallszahlen dieses Ortes
height(x, z) die Höhe, die die Oberfläche dort haben wird (der erste Block darüber)
biome(x, y, z) das Biom dort
column(x, z), minY die Blöcke, die das Land in dieser Spalte haben wird, von minY bis zur Obergrenze der Welt, vor seinem Boden, den Höhlen und allem Gebauten (im End: Endstein und Luft)
fileSize(file) die Größe einer Strukturdatei (x, y, z) oder null, wenn es keine gibt

build erhält dieselbe Welt wie ein Feature, darf aber nur Blöcke des Chunks setzen, der gerade gebaut wird, und sein random kommt vom Standort. Die anderen Optionen einer Struktur, die hier gelten, sind biomes, spacing, separation und, in Kotlin, salt. Eine Struktur aus Code braucht sowohl plan als auch build. Finde sie mit /locate structure, wie jede andere.

Strukturdateien per Code

placeFile platziert eine Strukturdatei dort, wo dein Code es sagt, gedreht und gespiegelt: einen Turm aus deinen Dateien in einer Struktur aus Code oder eine Ruine, die ein Feature in einer Höhle ablegt. Die Datei ist structures/<Pfad>.nbt der Mod ("mymod:watchtower") oder eine des Spiels. Es wird nur der Teil platziert, der innerhalb dessen liegt, was die Welt setzen darf; eine Struktur, die mehrere Chunks abdeckt, platziert ihre Datei also von jedem aus. Strukturblöcke in der Datei werden nicht platziert. Es gibt false zurück, wenn es keine solche Datei gibt.

content/Watchtower.ktKotlin
val TOWER = Identifier.parse("mymod:watchtower")

content.structure("watchtower") {
    biome("minecraft:plains")
    spacing = 40
    separation = 10
    plan { p ->
        val size = p.fileSize(TOWER) ?: return@plan null
        val x = p.chunkX * 16 + 8
        val z = p.chunkZ * 16 + 8
        val y = p.height(x, z)
        StructureSite(x, y, z, radius = maxOf(size.x, size.z), minY = y, maxY = y + size.y,
            data = mapOf("turns" to p.random.nextInt(4), "half_x" to size.x / 2, "half_z" to size.z / 2))
    }
    build { world, site ->
        val hx = (site.data["half_x"] as Number).toInt()
        val hz = (site.data["half_z"] as Number).toInt()
        // Its middle on the site, turned about its middle.
        world.placeFile(TOWER, site.x - hx, site.y, site.z - hz,
            rotation = (site.data["turns"] as Number).toInt(), pivotX = hx, pivotZ = hz)
    }
}
Parameter Werte Standard
file die ID der Datei —
x, y, z wohin ihre Ecke kommt, vor dem Drehen —
rotation Vierteldrehungen im Uhrzeigersinn 0
mirror Mirror.NONE, LEFT_RIGHT (entlang z) oder FRONT_BACK (entlang x) NONE
pivotX, pivotZ der Block der Datei, um den sie gedreht wird 0, 0

Das Land einer Dimension

Du kannst dem Land einer der Dimensionen des Spiels (minecraft:overworld, minecraft:the_nether oder minecraft:the_end) eine Form geben: schwebende Inseln, sanfte Hügel, eine Welt aus Säulen. Deine Form sagt, wie fest jede Stelle ist: über 0 ist Land, unter 0 ist Luft. Das Land besteht aus dem üblichen Stein der Dimension, und der Boden ihrer Biome kommt darauf.

content/hills.craftCraftScript
// Rolling hills over the whole overworld.
terrain "minecraft:overworld" {
    column: fun(x, z, ys, world) {
        let ground = 72 + 14 * sin(x / 60) * cos(z / 60)
        return ys.map(fun(y) { return (ground - y) / 8 })
    }
    has_land: fun(x, z, world) { return true }
}
content/FloatingIslands.ktKotlin
// Round, flattened islands in the End, one every 96 blocks.
content.terrain("minecraft:the_end") { world ->
    val shift = kotlin.random.Random(world.seed).nextInt(96)
    object : TerrainShape {
        fun across(x: Int, z: Int): Double {
            val dx = (x + shift).mod(96) - 48
            val dz = (z + shift).mod(96) - 48
            return sqrt((dx * dx + dz * dz).toDouble())
        }
        override fun column(x: Int, z: Int, ys: IntArray, out: DoubleArray) {
            val flat = across(x, z)
            for (i in ys.indices) {
                val up = (ys[i] - 64) * 2.5
                out[i] = (24 - sqrt(flat * flat + up * up)) / 24
            }
        }
        override fun hasLand(x: Int, z: Int) = across(x, z) < 24
    }
}
Mitglied Was es ist
column(x, z, ys, out) wie fest die Spalte x, z in jeder Höhe von ys ist, in out in derselben Reihenfolge. In CraftScript gibt column(x, z, ys, world) die Liste zurück
hasLand(x, z) (has_land) ob die Spalte überhaupt Land hat. Im End entscheidet es zwischen den Landbiomen und denen der Leere
world.seed der Seed der Welt
world.minY, world.height die Höhen, in denen das Land gemacht wird: ab minY, height Blöcke hoch
world.biome(x, y, z) das Biom an einem Block

Das Spiel fragt deine Form an den Ecken von Zellen, die einige Blöcke breit sind, und blendet dazwischen über, sie muss also nicht Block für Block genau sein. In Kotlin wird deine Funktion einmal pro Welt mit ihrem Seed aufgerufen und gibt die Form zurück. Deine Form macht das ganze Land: Die eigenen Rauschhöhlen des Spiels werden nicht erzeugt (füge einen Carver hinzu), und im End ist auch die zentrale Insel deine Aufgabe. Nur eine Mod darf eine Dimension formen. Eine Form, die fehlschlägt, wird einmal im Log gemeldet und hinterlässt dort kein Land, keinen Absturz.

Eigene Dimensionen werden auf der Seite Dimensionen mit einem der Terrains des Spiels deklariert.

Welches Biom wohin kommt

Standardmäßig übernimmt ein Biom einen Anteil (share) der Orte des Bioms, das es ersetzt (siehe Weltgenerierung). Für eine eigene Karte wählt dein Code das Biom jeder Stelle. Vorerst gilt das für das End (minecraft:the_end).

content/end_map.craftCraftScript
biome_map "minecraft:the_end" {
    biome: fun(x, y, z, land, world) {
        if x * x + z * z < 65536 { return "minecraft:the_end" }      // the central island
        if land == "minecraft:end_highlands" and (floor(x / 64) + floor(z / 64)) % 2 == 0 {
            return "mymod:crystal_glade"
        }
        return land
    }
}
content/EndMap.ktKotlin
content.tag(TagKind.BIOME, "glades", "crystal_glade", "ember_glade")

content.biomes("minecraft:the_end") { world ->
    val glades = world.tagged("mymod:glades")
    val theEnd = Identifier.parse("minecraft:the_end")
    BiomeMap { x, y, z, land ->
        when {
            x.toLong() * x + z.toLong() * z < 256L * 256 -> theEnd            // within 1024 blocks
            land.path != "end_highlands" || glades.isEmpty() -> land
            else -> glades[Math.floorMod((x shr 6) * 31 + (z shr 6), glades.size)]
        }
    }
}

Die Funktion erhält x, y, z in Quarts (das Spiel speichert ein Biom pro 4×4×4 Blöcke: ein Quart ist Block / 4) und land, die Art Land, die das Rauschen des Spiels dort macht, als Biom: minecraft:end_highlands, end_midlands, end_barrens oder small_end_islands. Mit einer eigenen Form ist es end_highlands auf ihrem Land und small_end_islands außerhalb. Du erhältst land auch auf der zentralen Insel, die deine Karte selbst platziert: Das Spiel setzt minecraft:the_end innerhalb von 1024 Blöcken um die Mitte.

Die Antwort muss ein Biom des Ends sein: das des Spiels oder eines von dir, deklariert mit replaces auf ein End-Biom. Jede andere Antwort oder eine Karte, die fehlschlägt, fällt auf die Wahl des Spiels zurück (einmal im Log gemeldet). Das world der Karte hat seed und tagged(tag), die Biome eines Biom-Tags. Nur eine Mod darf die Biome einer Dimension festlegen.

Carver

Ein Carver höhlt Höhlen aus dem Land aus, sobald es erzeugt ist, vor seinem Boden und den Features. Für jeden Chunk, der erzeugt wird, geht das Spiel die Chunks um ihn herum durch (8 auf jeder Seite); in jedem beginnt jeder Carver des Bioms dieses Chunks mit seiner chance (0–1), und deine Funktion markiert, was sie vom Chunk, der gerade erzeugt wird, aushöhlt. Ausgehöhlte Blöcke werden zu Luft (oder zu Wasser unter einem Aquifer), und der Boden wird darüber neu gemacht. Ein Biom verwendet einen Carver, indem es ihn in carvers nennt.

content/round_caves.craftCraftScript
// A round room, 6 blocks across, in some chunks.
carver "round_caves" {
    chance: 0.05
    carve: fun(ctx) {
        let cx = ctx.start_x * 16 + 8
        let cz = ctx.start_z * 16 + 8
        let cy = 20
        for x in cx - 6..cx + 6 {
            for y in cy - 6..cy + 6 {
                for z in cz - 6..cz + 6 {
                    if (x - cx) * (x - cx) + (y - cy) * (y - cy) + (z - cz) * (z - cz) <= 36 { ctx.carve(x, y, z) }
                }
            }
        }
    }
}

biome "hollow_hills" {
    replaces: "minecraft:meadow"
    carvers: ["round_caves"]
}
content/RoundCaves.ktKotlin
content.carver("round_caves", chance = 0.05) { ctx ->
    val r = ctx.random
    val cx = ctx.startX * 16 + r.nextInt(16)
    val cz = ctx.startZ * 16 + r.nextInt(16)
    val cy = r.nextInt(ctx.minY + 10, 40)
    val radius = r.nextInt(4, 9)
    for (x in cx - radius..cx + radius) for (y in cy - radius..cy + radius) for (z in cz - radius..cz + radius) {
        val (dx, dy, dz) = Triple(x - cx, y - cy, z - cz)
        if (dx * dx + dy * dy * 2 + dz * dz <= radius * radius) ctx.carve(x, y, z)
    }
}

content.biome("hollow_hills") {
    replaces = "minecraft:meadow"
    carver("round_caves")
}
Mitglied Was es ist
startX, startZ der Chunk, in dem diese Höhle beginnt (Chunk-Koordinaten: Block / 16)
chunkX, chunkZ der Chunk, der gerade erzeugt wird
minY, maxY die Höhen, die sie aushöhlen darf, beide eingeschlossen
seed, random der Seed der Welt und die Zufallszahlen dieses Starts: Sie ziehen in jedem Chunk, für den der Start gefragt wird, dasselbe, sodass eine Höhle, die Chunks durchquert, zusammenpasst
carve(x, y, z) höhlt diesen Block aus, in Weltkoordinaten; Blöcke außerhalb des Chunks, der gerade erzeugt wird, werden übersprungen

Eine Höhle kann höchstens 8 Chunks weit von ihrem Start reichen. In CraftScript ist chance standardmäßig 1. Ein Carver, der fehlschlägt, höhlt dort nichts aus und wird einmal im Log gemeldet.

Der Boden eines Bioms

surface bedeckt den Boden eines Bioms mit einem Block. Für Schichten, Flecken oder Hänge gib stattdessen eine Funktion an: Während ein Chunk erzeugt wird, fragt das Spiel sie für jeden Block des Bodens des Bioms von oben nach unten, welcher Block dorthin kommt. Keine Antwort überlässt diesen Block der Dimension (ihrem Stein).

content/crystal_glade.craftCraftScript
biome "crystal_glade" {
    replaces: "minecraft:end_highlands"
    share: 0.3
    surface: fun(at) {
        if at.depth_above == 1 { return "mymod:crystal_moss" }
        if at.depth_above <= 3 { return "mymod:crystal_soil" }
        return null
    }
}
content/CrystalGlade.ktKotlin
content.biome("crystal_glade") {
    replaces = "minecraft:end_highlands"
    share = 0.3
    surface { at ->
        val patch = at.noise("minecraft:surface", at.x.toDouble(), 0.0, at.z.toDouble()) > 0.2
        when {
            at.depthAbove == 1 && patch -> Identifier.parse("mymod:glow_moss")
            at.depthAbove == 1 -> Identifier.parse("mymod:crystal_moss")
            at.depthAbove <= 3 -> Identifier.parse("mymod:crystal_soil")
            else -> null
        }
    }
}
Mitglied von at Was es ist
x, y, z der Block, nach dem gefragt wird
depthAbove (depth_above) Blöcke Boden von der offenen Luft darüber bis zu diesem: 1 für den obersten Block des Bodens oder des Bodens einer Höhle
depthBelow (depth_below) Blöcke Boden von diesem bis zur offenen Luft darunter: 1 für den untersten über einer Höhle oder der Leere
surfaceDepth (surface_depth) wie tief die Oberflächenschichten dieser Spalte reichen, so wie das Spiel es variiert
steep ob der Boden so stark abfällt wie dort, wo die Berge des Spiels nackten Stein zeigen
noise(id, x, y, z) eines der Rauschen der Welt nach Namen ("minecraft:surface"), so wie der Seed es macht

Die Funktion hat Vorrang vor surface: Wo sie nichts antwortet, bedeckt ein ebenfalls angegebener surface-Block weiterhin die Oberseite. Eine Funktion, die fehlschlägt, wird einmal gemeldet, und dort, wo sie fehlschlägt, wird der Boden der Dimension verwendet.

Tags

Tags fassen Blöcke, Gegenstände oder Biome unter einem Namen zusammen, sodass ein Feature isIn(x, y, z, "#mymod:crystal_ground") prüfen kann und eine Liste von Biomen "#mymod:glades" sagen kann. Eine Mod ergänzt ihre eigenen Tags oder die von jedem, etwa die des Spiels:

content/Tags.ktKotlin
// Blocks a crystal can grow on, yours and the game's.
content.tag(TagKind.BLOCK, "crystal_ground", "crystal_moss", "crystal_soil", "minecraft:end_stone")
// Biomes a feature or structure can name as "#mymod:glades".
content.tag(TagKind.BIOME, "glades", "crystal_glade", "ember_glade")
// Adding to the game's: a pickaxe mines it faster.
content.tag(TagKind.BLOCK, "minecraft:mineable/pickaxe", "crystal_soil")

TagKind ist BLOCK, ITEM oder BIOME. Werte sind IDs oder #tags; Namen ohne Namespace gehören der Mod. Mehrere Mods können zum selben Tag beitragen, und ein Wert, der nicht existiert, wird ausgelassen, kein Fehler.

Gut zu wissen

  • Nur neue Chunks erhalten, was dein Code macht, wie alles in Weltgenerierung.
  • Fehler halten die Welt nicht an. Code, der eine Ausnahme wirft, lässt aus, was er dort machte, und der Fehler wird ins Log geschrieben.
  • Halte es schnell. Dieser Code läuft für jeden Chunk, tausende Male, während Spieler erkunden; vermeide darin aufwendige Arbeit, und beachte in CraftScript das Schrittlimit der Referenz.