Paglikha gamit ang code

Kapag hindi sapat ang pagdedeklara, ang code mo ang bumubuo sa mundo habang ginagawa ang mga chunk: mga feature, buong istruktura, ang hugis ng lupain, kung aling biome ang nasaan, mga kuweba at ang mga block ng lupa.

Ano ang puwede mong isulat

Ano	Kotlin	CraftScript
Mga feature: mga tinik, halaman sa dingding, malalaking bato, anumang inilalagay sa isang chunk	feature("…") { place { } }	Hindi
Mga istrukturang binuo ng code, sa ilang chunk	structure("…") { plan { }; build { } }	Oo (plan, build)
Ang lupain ng isang dimension	terrain("minecraft:the_end") { }	Oo (terrain)
Kung aling biome ang nasaan	biomes("minecraft:the_end") { }	Oo (biome_map)
Mga carver: mga kuweba at tunnel	carver("…", chance) { }	Oo (carver)
Ang lupa ng isang biome, block por block	biome("…") { surface { } }	Oo (surface: fun(at))
Mga tag ng mga block, item at biome	tag(TagKind.BIOME, "…", …)	Hindi

Lahat ng nasa pahinang ito ay tumatakbo habang ginagawa ang mga chunk, sa ilang thread nang sabay-sabay. Gamitin ang mga random na numerong ibinibigay sa iyo (o ang seed ng mundo) sa halip na sarili mo: gagawa ng parehong mundo ang parehong seed. Sa Kotlin, tiyaking ligtas sa mga thread ang anumang pinagsasaluhan ng code mo sa pagitan ng mga tawag. Sa CraftScript, hindi available ang mga member ng random; kumuha ng pagkakaiba-iba sa mga coordinate, sa seed o sa site ng istruktura.

Mga feature

Ang feature ay bagay na binubuo ng code mo sa chunk na ginagawa, sa mga biome na inilista mo. Pinipili ng Crafting ang mga lugar, gaya ng ginagawa ng laro para sa sarili nitong mga feature; binubuo ng place function mo roon at nagre-return ng true kapag may nabuo ito. Isinusulat sa Kotlin ang mga feature.

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
            }
        }
    }
}

Opsyon	Mga value	Default
biome(…)	mga biome kung saan ito inilalagay, sa id o #tag; kahit isa	—
count	mga subok kada chunk, isang range: 2..5	1..1
chance	sa isa lang sa bawat ganitong dami ng chunk	1
heights	bawat subok sa random na taas sa range na ito	null: ang ilalim ng mundo (ang code mo ang humahanap ng lugar)
spread	true: bawat subok sa random na column ng chunk; false: sa sulok ng chunk, at ang code mo ang pumipili mula roon	true
on	FeatureOn.FLOOR o CEILING: mula sa taas nito, lilipat ito sa hangin sa tabi ng pinakamalapit na sahig o kisame, hanggang 32 block ang layo; kapag wala, hindi ito inilalagay	null
underground	true: sa ilalim lang ng ibabaw, kahit 2 block sa ibaba nito (sa mga kuweba)	false
everyFloor	true: sa bawat sahig ng bawat column na napili, ang ibabaw at ang sahig ng bawat kuweba; ang count ay ang mga column kada sahig	false
tries	kasama ng everyFloor, ilang beses dadaanan ang mga sahig: bawat beses ay count pang column sa bawat sahig, kaya mas maraming subok ang naaabot ng malalim na lupa	1..1
step	kailan ito ginagawa, sa mga hakbang na pumupuno sa chunk: LAKES, SURFACE, ORES, UNDERGROUND (ang nagpapaganda sa mga kuweba), VEGETATION	VEGETATION

Kapag may everyFloor, hindi ginagamit ang chance, heights at spread: ang mga sahig mismo ang mga lugar.

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)
    }
}

Ano ang nakikita ng feature

Nakukuha ng place ang mundong ginagawa, ayon sa tanaw mula sa pinaglalagyan ng feature. Puwede itong magbasa at mag-set sa chunk na ginagawa at sa mga chunk sa paligid nito; nilalaktawan ang pag-set sa labas ng mga iyon. Sa CraftScript (sa build ng istruktura), nakasulat sa snake_case ang parehong mga member.

Member	Ano ito
x, y, z	kung saan ito inilalagay
random	sarili nitong mga random na numero: gumagawa ng parehong feature ang parehong seed
seed	ang seed ng mundo, para sa noise na pareho sa buong mundo
minY, maxY	ang mga taas ng mundo; ang mga block ay mula minY pataas hanggang sa ibaba ng maxY
block(x, y, z), state(x, y, z, name), isAir(x, y, z)	ang block doon, ang value ng isa sa mga state nito, kung hangin ba ito
isIn(x, y, z, tag)	kung ang block doon ay nasa isang tag ("#minecraft:leaves") o ang mismong block na iyon ("minecraft:end_stone")
canStay(x, y, z, block, states)	kung puwedeng manatili roon ang isang block, na may mga state na iyon: halaman sa lupa nito, lumot sa dingding na nakaharap palayo rito. Puwedeng alisin ang states
set(x, y, z, block, states)	nagse-set ng block, na may mga state gaya ng mapOf("facing" to "north"); false kapag nasa labas ito ng puwedeng i-set o hindi block dito
inside(x, z)	kung ang column ay isa na puwedeng basahin at i-set
surface(x, z)	ang unang block sa itaas ng pinakamataas na hindi hangin, gaya ng lupa bago ang mga feature
top(x, z)	pareho, ngayon, kasama ang mga na-set ng mga feature mula noon
flow(x, y, z)	hinahayaang dumaloy ang tubig (o lava, o block na may tubig) doon kapag nasa mundo na ang chunk. Nananatiling tahimik ang tubig na na-set habang ginagawa ang chunk, at mabibitin sa tabi ng hangin kung wala ito
structures(x, z)	ang mga istruktura (mga id, gaya ng minecraft:end_city) na sakop ang chunk ng column na iyon, para ilayo ang isang feature sa kanila
placeFile(file, x, y, z, rotation, mirror, pivotX, pivotZ)	naglalagay ng structure file; tingnan ang Mga structure file mula sa code

Ang block na pinangalanan ng feature mo na hindi umiiral (mula sa mod na hindi naka-install) ay nilalaktawan, na may isang babala sa log; nagre-return ng false ang set para rito.

Mga istrukturang binuo ng code

Para sa istrukturang hindi gawa sa mga file, o kailangang sumunod sa lupain, ang code mo ang nagpapasya kung nasaan ito at bumubuo nito. Dalawang function ang kailangan:

• plan ang tinatanong, sa bawat chunk kung saan maglalagay ng isa ang mundo (ayon sa biomes, spacing at separation, gaya ng anumang istruktura), kung naroon ba ito, bago gawin ang mga block ng chunk. Ibinabalik nito ang site nito: ang gitna nito, hanggang saan ito aabot at anumang kailangan ng pagbuo; o wala, at walang istruktura roon.
• build ang bumubuo sa bahagi ng site sa bawat chunk na sakop nito, isang chunk bawat beses. Nakukuha ng bawat chunk ang parehong site at parehong random na numero, kaya bawat isa ay bumubuo sa bahagi nito ng parehong istruktura. Iniingatan ang site kasama ng mundo, kaya tugma pa rin ang mga chunk na ginawa pagkatapos ng restart.

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.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)
        }
    }
}

Ang site (StructureSite sa Kotlin, isang map sa CraftScript):

Field	Ano ito	Default sa CraftScript
x, y, z	ang gitna nito	0
radius	ilang block sa paligid ng gitna ang inaabot nito: ang mga chunk na sakop nito	8
min_y, max_y (minY, maxY)	ang mga taas na sakop nito	y binawasan at dinagdagan ng radius
data	ang kailangan ng pagbuo para makabuo ng pareho sa bawat chunk: mga numero, text, true o false	walang laman

Sa Kotlin, may seed din ang site na galing sa posisyon nito. Bumabalik na decimal ang mga numero sa data pagkatapos ng restart: basahin ang mga ito gamit ang (site.data["n"] as Number).toInt().

Ang nakukuha ng plan, bago gawin ang anumang block ng chunk:

Member	Ano ito
chunkX, chunkZ	ang chunk na pinagtatanungan (block / 16)
seed, random	ang seed ng mundo, at ang sariling random na numero ng lugar na ito
height(x, z)	ang taas na magiging ibabaw doon (ang unang block sa itaas nito)
biome(x, y, z)	ang biome doon
column(x, z), minY	ang mga block na magiging lupain sa column na iyon, mula minY pataas hanggang sa tuktok ng mundo, bago ang lupa nito, mga kuweba at anumang binuo (sa End: end stone at hangin)
fileSize(file)	ang laki ng structure file (x, y, z), o null kung wala

Nakukuha ng build ang parehong mundo gaya ng feature, pero mga block lang ng chunk na binubuo ang puwede nitong i-set, at galing sa site ang random nito. Ang iba pang opsyon ng istruktura na naaangkop dito ay biomes, spacing, separation at, sa Kotlin, salt. Kailangan ng istruktura ng code ang parehong plan at build. Hanapin ito gamit ang /locate structure, gaya ng iba.

Mga structure file mula sa code

Inilalagay ng placeFile ang isang structure file kung saan sabihin ng code mo, na iniikot at sinalamin: isang tore mula sa mga file mo sa loob ng istruktura ng code, o isang guho na ibinababa ng feature sa kuweba. Ang file ay ang structures/<path>.nbt ng mod ("mymod:watchtower") o isa sa mga file ng laro. Ang bahaging nasa loob lang ng puwedeng i-set ng mundo ang inilalagay, kaya ang istrukturang sumasakop sa ilang chunk ay naglalagay ng file nito mula sa bawat isa. Hindi inilalagay ang mga structure block sa file. Nagre-return ng false kung walang ganoong file.

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	Mga value	Default
file	ang id ng file	—
x, y, z	kung saan ilalagay ang sulok nito, bago iikot	—
rotation	mga kapat na ikot pakanan	0
mirror	Mirror.NONE, LEFT_RIGHT (sa kahabaan ng z) o FRONT_BACK (sa kahabaan ng x)	NONE
pivotX, pivotZ	ang block ng file na pinag-iikutan nito	0, 0

Ang lupain ng isang dimension

Puwede mong ibigay ang hugis ng lupain ng isa sa mga dimension ng laro (minecraft:overworld, minecraft:the_nether o minecraft:the_end): mga lumulutang na isla, mga burol, mundo ng mga haligi. Sinasabi ng hugis mo kung gaano katigas ang bawat lugar: sa itaas ng 0 ay lupa, sa ibaba ng 0 ay hangin. Ang lupain ay gawa sa karaniwang bato ng dimension, at ang lupa ng mga biome nito ang nasa ibabaw.

// 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 }
}

// 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
    }
}

Member	Ano ito
column(x, z, ys, out)	gaano katigas ang column na x, z sa bawat taas ng ys, sa out sa parehong pagkakasunod. Sa CraftScript, nagre-return ng list ang column(x, z, ys, world)
hasLand(x, z) (has_land)	kung may anumang lupa ang column. Sa End, ito ang nagpapasya sa pagitan ng mga biome ng lupa at ng sa kawalan
world.seed	ang seed ng mundo
world.minY, world.height	ang mga taas kung saan ginagawa ang lupa: mula minY, height na block pataas
world.biome(x, y, z)	ang biome sa isang block

Tinatanong ng laro ang hugis mo sa mga sulok ng mga cell na ilang block ang lapad at nagbabalanse sa pagitan nila, kaya hindi ito kailangang eksakto block por block. Sa Kotlin, isang beses kada mundo tinatawag ang function mo, kasama ang seed nito, at nagre-return ito ng hugis. Ang hugis mo ang gumagawa ng lahat ng lupa: hindi gagawin ang sariling noise cave ng laro (magdagdag ng carver), at sa End, ikaw din ang gagawa ng gitnang isla. Isang mod lang ang puwedeng humubog sa isang dimension. Ang hugis na pumapalya ay sinasabi nang isang beses sa log at walang iiwang lupa roon, hindi crash.

Idinedeklara ang sarili mong mga dimension sa pahinang Mga dimension gamit ang isa sa mga terrain ng laro.

Kung aling biome ang nasaan

Bilang default, kumukuha ang isang biome ng share ng mga lugar ng pinapalitan nito (tingnan ang World generation). Para sa sarili mong mapa, ang code mo ang pumipili ng biome ng bawat lugar. Sa ngayon, para ito sa End (minecraft:the_end).

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.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)]
        }
    }
}

Nakukuha ng function ang x, y, z sa mga quart (isang biome kada 4×4×4 na block ang iniingatan ng laro: ang quart ay block / 4) at ang land, ang uri ng lupa na ginagawa roon ng noise ng laro, bilang biome: minecraft:end_highlands, end_midlands, end_barrens o small_end_islands. Kapag may sarili kang hugis, end_highlands sa lupa nito at small_end_islands sa labas nito. Nakukuha mo rin ang land sa gitnang isla, na ang mapa mo mismo ang naglalagay: inilalagay ng laro ang minecraft:the_end sa loob ng 1024 na block mula sa gitna.

Dapat biome ng End ang sagot: sa laro, o isa sa mga sa iyo na idineklara na may replaces na nakatakda sa biome ng End. Ang anumang ibang sagot, o mapang pumapalya, ay babalik sa pinili ng laro (sinasabi nang isang beses sa log). May seed at tagged(tag) ang world ng mapa, ang mga biome sa isang biome tag. Isang mod lang ang puwedeng pumili sa mga biome ng isang dimension.

Mga carver

Ang carver ay naghuhukay ng mga kuweba sa lupa kapag nagawa na ito, bago ang lupa at mga feature nito. Para sa bawat chunk na ginagawa, dinadaanan ng laro ang mga chunk sa paligid (8 sa bawat gilid); sa bawat isa, nagsisimula ang bawat carver ng biome ng chunk na iyon ayon sa chance nito (0–1), at minamarkahan ng function mo ang huhukayin nito sa chunk na ginagawa. Nagiging hangin ang mga hinukay na block (o tubig sa ilalim ng aquifer), at ginagawang muli ang lupa sa ibabaw ng mga ito. Gumagamit ng carver ang biome sa pamamagitan ng pagpapangalan dito sa carvers.

// 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.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")
}

Member	Ano ito
startX, startZ	ang chunk kung saan nagsisimula ang kuwebang ito (mga coordinate ng chunk: block / 16)
chunkX, chunkZ	ang chunk na ginagawa
minY, maxY	ang mga taas na puwedeng hukayin, kasama ang dalawa
seed, random	ang seed ng mundo, at ang mga random na numero ng simulang ito: pareho ang iginuguhit nila sa bawat chunk na pinagtatanungan ng simula, kaya nagtutugma ang kuwebang tumatawid sa mga chunk
carve(x, y, z)	hinuhukay ang block na iyon, sa mga coordinate ng mundo; nilalaktawan ang mga block sa labas ng chunk na ginagawa

Hanggang 8 chunk lang ang maaabot ng kuweba mula sa pinagsimulan nito. Sa CraftScript, 1 ang default ng chance. Ang carver na pumapalya ay walang hinuhukay roon, at sinasabi nang isang beses sa log.

Ang lupa ng isang biome

Tinatakpan ng surface ang lupa ng biome ng isang block. Para sa mga patong, bahagi o dalisdis, bigyan ito ng function: habang ginagawa ang chunk, tinatanong ito ng laro, para sa bawat block ng lupa ng biome mula itaas pababa, kung aling block ang ilalagay doon. Kapag walang sagot, ang block ay ipinauubaya sa dimension (ang bato nito).

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.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
        }
    }
}

Member ng at	Ano ito
x, y, z	ang block na tinatanong
depthAbove (depth_above)	mga block ng lupa mula sa bukas na hangin sa itaas hanggang dito: 1 para sa pinakaitaas na block ng lupa o ng sahig ng kuweba
depthBelow (depth_below)	mga block ng lupa mula rito hanggang sa bukas na hangin sa ilalim nito: 1 para sa pinakamababa sa ibabaw ng kuweba o ng kawalan
surfaceDepth (surface_depth)	gaano kalalim ang mga patong sa ibabaw ng column na ito, ayon sa pagkakaiba-iba ng laro
steep	kung kasingtarik ba ang dalisdis ng kung saan nagpapakita ng hubad na bato ang mga bundok ng laro
noise(id, x, y, z)	isa sa mga noise ng mundo sa pangalan ("minecraft:surface"), ayon sa gawa ng seed

Nauuna ang function sa surface: kung saan wala itong sagot, tinatakpan pa rin ang itaas ng block na ibinigay sa surface, kung mayroon din. Ang function na pumapalya ay sinasabi nang isang beses, at ginagamit ang lupa ng dimension kung saan ito pumapalya.

Mga tag

Pinagsasama ng mga tag ang mga block, item o biome sa ilalim ng isang pangalan, para masubok ng feature ang isIn(x, y, z, "#mymod:crystal_ground") at masabi ng listahan ng mga biome ang "#mymod:glades". Nagdaragdag ang mod sa sarili nitong mga tag o sa kaninuman, gaya ng sa laro:

// 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")

Ang TagKind ay BLOCK, ITEM o BIOME. Ang mga value ay mga id o #tag; ang mga pangalang walang namespace ay sa mod. Maraming mod ang puwedeng magdagdag sa iisang tag, at ang value na hindi umiiral ay nilalaktawan, hindi error.

Mabuting malaman

• Mga bagong chunk lang ang nakakakuha ng ginagawa ng code mo, gaya ng lahat ng nasa World generation.
• Hindi pinahihinto ng mga error ang mundo. Ang code na nagta-throw ay nag-iiwan ng wala sa ginagawa nito roon, at isinusulat ang error sa log.
• Gawing mabilis. Tumatakbo ang code na ito para sa bawat chunk, libu-libong beses habang nage-explore ang mga manlalaro; iwasan ang mabibigat na gawain dito, at sa CraftScript, tandaan ang limitasyon sa mga hakbang sa sanggunian.