API

Generazione del mondo

Minerali, alberi, fiori, strutture e biomi che compaiono da soli nel mondo. Dichiari cosa e dove, e i nuovi chunk li ricevono.

Minerali

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

Proprietà	Valori	Predefinito
`block`	il blocco da piazzare: `"mymod:other"`	il blocco con il nome del minerale
`replaces`	`stone`, `deepslate`, `stone_and_deepslate` (Overworld), `netherrack` (Nether) o `end_stone` (End)	`stone_and_deepslate`
`size`	blocchi per filone, 1–64	8
`per_chunk`	filoni tentati per chunk	8
`height`	`[min, max]`, intervallo di altezza	`[-64, 64]`
`biomes`	solo in questi biomi, per id o per tag	ogni bioma in cui c’è la sua roccia

Senza biomes, il minerale compare in ogni bioma della dimensione a cui appartiene replaces; un minerale di end_stone, in ogni bioma dell’End. Il blocco si dichiara come qualsiasi altro, con la sua durezza, il suo strumento e il suo bottino; vedi Blocchi, oggetti e ricette.

content/void_ore.craftCraftScript

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

Alberi

Un albero è un tronco dritto con una sfera di foglie. Dichiara i due blocchi, poi l’albero.

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

Proprietà	Valori	Predefinito
`trunk`	il blocco del tronco, della mod o del gioco: `"ruby_log"`, `"minecraft:oak_log"`	—
`leaves`	il blocco delle foglie	—
`height`	altezza del tronco, in blocchi	5
`height_variation`	quanto varia l’altezza da un albero all’altro	2
`leaves_radius`	raggio della sfera di foglie, in blocchi	2
`per_chunk`	alberi tentati per chunk	1
`biomes`	biomi in cui compare, per id o per tag	—

I biomi si indicano per id (minecraft:plains) o per tag (#minecraft:is_forest), mescolati a piacere. Tronco e foglie possono essere blocchi della mod o del gioco.

Piante e macchie

Una pianta è un blocco disegnato come due immagini incrociate, come un fiore: niente ci collide e la luce lo attraversa. La sua texture è textures/block/ruby_flower.png, con sfondo trasparente.

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
}

Una macchia sparge piante nel mondo:

Proprietà	Valori	Predefinito
`block`	il blocco della pianta	—
`biomes`	biomi in cui compare, per id o per tag	—
`rarity`	una macchia ogni tot chunk	4
`size`	piante che ogni macchia prova a piazzare	32
`spread`	distanza massima dal centro della macchia, in blocchi	7

Le piante vengono piazzate solo nell’aria, sul terreno della superficie (erba, terra, muschio e fango). Per piante su altro terreno, sui muri o appese ai soffitti, scrivi una feature: vedi Generazione tramite codice.

Strutture

Una struttura è una costruzione che fai tu:

Costruiscila nel gioco.
Salvala con un blocco struttura.
Copia il file .nbt nella cartella structures/ della mod: accanto agli script in una mod CraftScript, oppure in assets/<id della mod>/structures/ in un jar Kotlin o Java.

Poi dichiarala:

content/ruby_shrine.craftCraftScript

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

Proprietà	Valori	Predefinito
`file`	nome del file .nbt, senza estensione	la prima variante, o il nome della struttura
`biomes`	biomi in cui compare, per id o per tag	—
`spacing`	circa una struttura ogni tot chunk	24
`separation`	mai più vicine di tot chunk; minore di spacing	8
`buried`	true la affonda nel terreno, per le rovine	false
`offset_y`	blocchi sopra la superficie su cui poggia; un valore negativo la affonda	0
`adapt_ground`	true riempie il terreno sotto di essa e lo libera attorno; false la piazza così com’è	`true`
`heights`	`[min, max]`: a un’altezza casuale in questo intervallo, ovunque sia la superficie, invece che sulla superficie (una casa nel cielo)	sulla superficie

Trovala con /locate structure <id della mod>:ruby_shrine e piazzala con /place structure <id della mod>:ruby_shrine.

Varianti, sostituzioni e usura

Una struttura può derivare da più file, e i suoi blocchi possono cambiare mentre viene piazzata. Così si fanno rovine mai del tutto uguali:

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

Proprietà	Valori	Predefinito
`variants`	file di cui è una: nomi, oppure `{ file, weight }`; se ne sceglie una a caso, in base al peso	solo `file`, peso 1
`skip`	blocchi dei suoi file che non vengono piazzati. `"minecraft:air"` mantiene i blocchi del mondo dove il file ha aria	—
`replace`	`[{ block, with, chance }]`: un blocco dei suoi file diventa un altro con quella probabilità (più di 0, fino a 1)	probabilità 1
`decay`	`{ left, blocks }`: si mantiene solo `left` (0–1) di `blocks` (id o tag); senza `blocks`, di qualsiasi blocco	si mantiene tutto

Strutture di pezzi che si incastrano

Un villaggio o un dungeon è fatto di pezzi che si incastrano: una strada porta a una casa, un corridoio a una sala. Ogni pezzo è un file con i blocchi puzzle (jigsaw) del gioco, e ogni blocco jigsaw indica il pool da cui viene il pezzo successivo, come <id della mod>:<pool>. Dichiara i pool; la struttura parte dal primo.

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" }] },
    ]
}

Proprietà	Valori	Predefinito
`pools`	i pool di pezzi; il primo è da dove parte	un pezzo, da `variants` o `file`
`depth`	a quanti pezzi di distanza dal primo arriva	1

Ogni pool ha:

Chiave	Valori	Predefinito
`name`	il nome che usano i suoi blocchi jigsaw, come `hamlet/streets`	—
`pieces`	`[{ file, weight, follows_ground }]`. `follows_ground: true` piega il pezzo seguendo il terreno sotto di esso, per strade e sentieri; false lo mantiene dritto, per le case	peso 1, `false`
`features`	`[{ id, weight }]`: una feature come pezzo, tua o del gioco (`minecraft:chorus_plant`)	—
`none`	peso di nessun pezzo, per un lotto vuoto	0
`fallback`	il pool usato dove nessun pezzo ci sta, come la fine di una strada	niente
`skip`, `replace`	come per una struttura singola. In un pool, una sostituzione può aggiungere `where`: solo dove il mondo ha già quel blocco (i mattoni di una strada sopra l’acqua diventano assi)	—

Tutti i pezzi restano entro 80 blocchi dal primo.

Due opzioni per ora ci sono solo in Kotlin: salt, un numero che sceglie in quale punto del suo tratto di spacing chunk cade la struttura (due strutture con lo stesso spacing e lo stesso salt cadono negli stessi punti; senza, ne viene calcolato uno a partire dall’id della struttura), e aboveBottom, quanti blocchi sopra il fondo del mondo devono restare i suoi pezzi (dove uno arriverebbe più in basso, la struttura non viene creata).

Le strutture che il tuo codice costruisce blocco per blocco sono nella pagina Generazione tramite codice.

Biomi

Un bioma tuo prende una parte dei luoghi di un bioma del gioco. Mantiene ciò che vi cresce, vi vive e vi è scavato, e porta il suo clima e i suoi colori.

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

Proprietà	Valori	Predefinito
`replaces`	il bioma del gioco di cui prende i luoghi: `"minecraft:plains"`	`"minecraft:plains"`
`share`	frazione di quei luoghi che occupa, maggiore di 0 e fino a 1	0.5
`temperature`	temperatura del clima	0.8
`downfall`	quanto piove	0.4
`precipitation`	`true` se piove, `false` se no	`true`
`grass_color`	colore dell’erba, `#rrggbb`	quelli del bioma sostituito
`foliage_color`	colore delle foglie	quelli del bioma sostituito
`sky_color`	colore del cielo	quelli del bioma sostituito
`fog_color`	colore della nebbia	quelli del bioma sostituito
`water_color`	colore dell’acqua	`#3f76e4`
`water_fog_color`	colore della nebbia sott’acqua	quelli del bioma sostituito

share si distribuisce in modo uniforme sui luoghi in cui ci sarebbe il bioma sostituito: 0.5 ne prende la metà, uno su due. Il nuovo bioma eredita ciò che vi cresce, vi vive e vi è scavato (vegetazione, minerali, grotte, creature, musica) e ciò che altre mod aggiungono a quel bioma. I colori omessi restano quelli del bioma sostituito.

Più biomi possono sostituire lo stesso: si dividono i suoi luoghi. Trova il tuo con /locate biome <id della mod>:ruby_meadow.

Suono, suolo e creature

Un bioma può avere anche la propria musica e la propria aria, coprire il suo suolo con un blocco tuo e scegliere chi ci vive:

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

Proprietà	Valori	Predefinito
`music`	un id di suono, riprodotto come musica del bioma	quella del bioma sostituito
`ambient_sound`	un suono che si ripete di continuo lì (vento, un ronzio)	quello del bioma sostituito
`particle`	`{ id, chance }`: una particella che fluttua nella sua aria; `chance` per ogni punto vicino al giocatore a ogni tick (0.001 sono poche)	quella del bioma sostituito; chance 0.01
`surface`	il blocco con cui è coperto il suo suolo (il blocco in cima a ogni pavimento)	il suolo abituale della dimensione
`spawns`	`[{ creature, weight, group }]`: le creature che ci vivono; se ne indica qualcuna, queste e nessun’altra	quelle del bioma sostituito; weight 10, group `[1, 4]`
`inherits`	`false`: lì si genera solo ciò che viene dato a questo bioma (le sue `features`, i suoi `carvers`, ciò che le mod vi piazzano), non ciò che si genera nel bioma sostituito	`true`
`features`	`[{ id, step }]`: feature già esistenti, del gioco o di dati, piazzate in esso. `step` è `lakes`, `surface`, `ores`, `underground` o `vegetation`	—
`carvers`	id di carver che scavano le sue grotte, tuoi o del gioco; vengono eseguiti nell’ordine indicato, prima di quelli del bioma sostituito	—

Con inherits: false il bioma continua a prendere i luoghi del bioma sostituito, e le sue creature e i suoi suoni a meno che tu non dia i tuoi; smette di arrivare solo ciò che vi cresce e vi è scavato. Un suolo fatto blocco per blocco e carver tuoi sono nella pagina Generazione tramite codice.

Biomi dell’End

Nell’End, un bioma prende intere regioni, larghe circa 200 blocchi, invece di luoghi di clima. Se sostituisce minecraft:end_highlands, prende tutta la terra delle isole delle sue regioni (altipiani, terre di mezzo e terre aride); se sostituisce minecraft:small_end_islands, il vuoto tra le isole. L’isola centrale resta quella del gioco, e le regioni sono diverse in ogni mondo.

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

Buono a sapersi

Solo chunk nuovi. I chunk già generati non cambiano; solo quelli generati dopo l’installazione della mod ricevono minerali, alberi, piante, strutture e biomi. Esplora terreno nuovo per trovarli.
I nomi mancanti vengono saltati. Un bioma o un tag in biomes che non esiste (per esempio, di un’altra mod non installata) viene saltato, non è un errore.
Senza terreno, niente struttura. Una struttura che poggia sulla superficie non viene creata dove la sua colonna non ha alcun terreno, come il vuoto tra le isole dell’End.
Feature, strutture, terreno, mappe dei biomi, carver e suoli scritti nel codice sono nella pagina Generazione tramite codice.
I mondi interi tutti tuoi sono nella pagina Dimensioni.

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