API

Geração de mundo

Minérios, árvores, flores, estruturas e biomas que aparecem sozinhos no mundo. Você declara o quê e onde, e os chunks novos os recebem.

Minérios

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

Propriedade	Valores	Padrão
`block`	o bloco a colocar: `"mymod:other"`	o bloco com o mesmo nome do minério
`replaces`	`stone`, `deepslate`, `stone_and_deepslate` (Overworld), `netherrack` (Nether) ou `end_stone` (End)	`stone_and_deepslate`
`size`	blocos por veio, 1–64	8
`per_chunk`	veios tentados por chunk	8
`height`	`[min, max]`, faixa de altura	`[-64, 64]`
`biomes`	só nesses biomas, por id ou por tag	todos os biomas onde está a sua rocha

Sem biomes, o minério aparece em todos os biomas da dimensão a que replaces pertence; um minério de end_stone, em todos os biomas do End. O bloco em si é declarado como qualquer outro, com sua dureza, ferramenta e loot; veja Blocos, itens e receitas.

content/void_ore.craftCraftScript

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

Árvores

Uma árvore é um tronco reto com uma bola de folhas. Declare os dois blocos e depois a árvore.

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

Propriedade	Valores	Padrão
`trunk`	o bloco do tronco, do mod ou do jogo: `"ruby_log"`, `"minecraft:oak_log"`	—
`leaves`	o bloco das folhas	—
`height`	altura do tronco, em blocos	5
`height_variation`	quanto a altura varia de uma árvore para outra	2
`leaves_radius`	raio da bola de folhas, em blocos	2
`per_chunk`	árvores tentadas por chunk	1
`biomes`	biomas onde aparece, por id ou por tag	—

Os biomas são indicados por id (minecraft:plains) ou por tag (#minecraft:is_forest), misturados à vontade. O tronco e as folhas podem ser blocos do mod ou do jogo.

Plantas e canteiros

Uma planta é um bloco desenhado como duas imagens cruzadas, como uma flor: nada colide com ela e a luz a atravessa. Sua textura é textures/block/ruby_flower.png, com fundo transparente.

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
}

Um canteiro espalha plantas pelo mundo:

Propriedade	Valores	Padrão
`block`	o bloco da planta	—
`biomes`	biomas onde aparece, por id ou por tag	—
`rarity`	um canteiro a cada tantos chunks	4
`size`	plantas que cada canteiro tenta colocar	32
`spread`	distância máxima do centro do canteiro, em blocos	7

As plantas só são colocadas no ar, sobre o solo da superfície (grama, terra, musgo e lama). Para plantas em outro solo, em paredes ou penduradas em tetos, escreva uma feature: veja Geração por código.

Estruturas

Uma estrutura é uma construção que você mesmo faz:

Construa-a no jogo.
Salve-a com um bloco de estrutura.
Copie o arquivo .nbt para a pasta structures/ do mod: junto dos scripts em um mod CraftScript, ou em assets/<id do mod>/structures/ em um jar de Kotlin ou Java.

Depois declare-a:

content/ruby_shrine.craftCraftScript

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

Propriedade	Valores	Padrão
`file`	nome do arquivo .nbt, sem extensão	a primeira variante, ou o nome da estrutura
`biomes`	biomas onde aparece, por id ou por tag	—
`spacing`	cerca de uma estrutura a cada tantos chunks	24
`separation`	nunca mais perto do que tantos chunks; menor que spacing	8
`buried`	true a afunda no solo, para ruínas	false
`offset_y`	blocos acima da superfície em que ela fica; um valor negativo a afunda	0
`adapt_ground`	true preenche o solo embaixo dela e o limpa ao redor; false a coloca como está	`true`
`heights`	`[min, max]`: a uma altura aleatória dentro desta faixa, onde quer que esteja a superfície, em vez de sobre a superfície (uma casa no céu)	sobre a superfície

Encontre-a com /locate structure <id do mod>:ruby_shrine e coloque-a com /place structure <id do mod>:ruby_shrine.

Variantes, substituições e desgaste

Uma estrutura pode vir de vários arquivos, e os seus blocos podem mudar ao ser colocada. Isso faz ruínas que nunca são exatamente iguais:

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

Propriedade	Valores	Padrão
`variants`	arquivos de que ela é uma: nomes, ou `{ file, weight }`; uma é escolhida ao acaso, conforme o peso	só `file`, peso 1
`skip`	blocos dos seus arquivos que não são colocados. `"minecraft:air"` mantém os blocos do mundo onde o arquivo tem ar	—
`replace`	`[{ block, with, chance }]`: um bloco dos seus arquivos vira outro com essa chance (mais que 0, até 1)	chance 1
`decay`	`{ left, blocks }`: só `left` (0–1) de `blocks` (ids ou tags) é mantido; sem `blocks`, de qualquer bloco	tudo é mantido

Estruturas de peças que se encaixam

Uma vila ou uma masmorra é feita de peças que se encaixam: uma rua leva a uma casa, um corredor a uma sala. Cada peça é um arquivo com blocos de quebra-cabeça (jigsaw) do jogo, e cada bloco jigsaw nomeia o pool de onde sai a próxima peça, como <id do mod>:<pool>. Declare os pools; a estrutura começa pelo primeiro.

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

Propriedade	Valores	Padrão
`pools`	os pools de peças; o primeiro é onde ela começa	uma peça, de `variants` ou `file`
`depth`	a quantas peças de distância da primeira ela chega	1

Cada pool tem:

Chave	Valores	Padrão
`name`	o nome que os seus blocos jigsaw usam, como `hamlet/streets`	—
`pieces`	`[{ file, weight, follows_ground }]`. `follows_ground: true` curva a peça conforme o solo embaixo dela, para ruas e caminhos; false a mantém reta, para casas	peso 1, `false`
`features`	`[{ id, weight }]`: uma feature como peça, sua ou do jogo (`minecraft:chorus_plant`)	—
`none`	peso de nenhuma peça, para um lote vazio	0
`fallback`	o pool usado onde nenhuma peça cabe, como o fim de uma rua	nada
`skip`, `replace`	como em uma estrutura simples. Em um pool, uma substituição pode acrescentar `where`: só onde o mundo já tem esse bloco (os tijolos de uma rua sobre a água viram tábuas)	—

Todas as peças ficam a até 80 blocos da primeira.

Duas opções por enquanto só existem em Kotlin: salt, um número que escolhe em que ponto do seu trecho de spacing chunks a estrutura cai (duas estruturas com o mesmo spacing e salt caem nos mesmos lugares; sem ele, um é calculado a partir do id da estrutura), e aboveBottom, quantos blocos acima do fundo do mundo as suas peças precisam ficar (onde uma chegaria mais baixo, a estrutura não é criada).

As estruturas que o seu código constrói bloco a bloco estão na página Geração por código.

Biomas

Um bioma próprio ocupa uma parte dos lugares de um bioma do jogo. Mantém o que cresce, vive e é escavado ali, e traz seu próprio clima e suas próprias cores.

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

Propriedade	Valores	Padrão
`replaces`	o bioma do jogo cujos lugares ele toma: `"minecraft:plains"`	`"minecraft:plains"`
`share`	fração desses lugares que ele ocupa, maior que 0 e até 1	0.5
`temperature`	temperatura do clima	0.8
`downfall`	quanto chove	0.4
`precipitation`	`true` para chuva, `false` sem chuva	`true`
`grass_color`	cor da grama, `#rrggbb`	as do bioma substituído
`foliage_color`	cor das folhas	as do bioma substituído
`sky_color`	cor do céu	as do bioma substituído
`fog_color`	cor da névoa	as do bioma substituído
`water_color`	cor da água	`#3f76e4`
`water_fog_color`	cor da névoa debaixo d’água	as do bioma substituído

share se distribui de modo uniforme pelos lugares onde estaria o bioma substituído: 0.5 toma metade, um em cada dois. O novo bioma herda o que cresce, vive e é escavado ali (vegetação, minérios, cavernas, criaturas, música) e o que outros mods adicionarem a esse bioma. As cores que você omitir continuam as do bioma substituído.

Vários biomas podem substituir o mesmo: eles dividem os lugares dele. Encontre o seu com /locate biome <id do mod>:ruby_meadow.

Som, solo e criaturas

Um bioma também pode ter a sua própria música e o seu próprio ambiente, cobrir o seu solo com um bloco seu e escolher quem vive nele:

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

Propriedade	Valores	Padrão
`music`	um id de som, tocado como a música do bioma	a do bioma substituído
`ambient_sound`	um som que toca sem parar ali (vento, um zumbido)	o do bioma substituído
`particle`	`{ id, chance }`: uma partícula flutuando no seu ar; `chance` por ponto perto do jogador a cada tick (0.001 são algumas poucas)	a do bioma substituído; chance 0.01
`surface`	o bloco com que o seu solo é coberto (o bloco de cima de cada chão)	o solo habitual da dimensão
`spawns`	`[{ creature, weight, group }]`: as criaturas que vivem ali; se nomear alguma, essas e nenhuma outra	as do bioma substituído; weight 10, group `[1, 4]`
`inherits`	`false`: só o que é dado a este bioma é gerado ali (as suas `features`, os seus `carvers`, o que os mods colocam nele), não o que é gerado no bioma substituído	`true`
`features`	`[{ id, step }]`: features que já existem, do jogo ou de dados, colocadas nele. `step` é `lakes`, `surface`, `ores`, `underground` ou `vegetation`	—
`carvers`	ids de carvers que escavam as suas cavernas, seus ou do jogo; rodam na ordem dada, antes dos do bioma substituído	—

Com inherits: false o bioma continua tomando os lugares do bioma substituído, e as suas criaturas e sons, a menos que você dê os seus; só deixa de vir junto o que cresce e é escavado ali. Um solo feito bloco a bloco e carvers próprios estão na página Geração por código.

Biomas do End

No End, um bioma toma regiões inteiras, com cerca de 200 blocos de largura, em vez de lugares de clima. Substituindo minecraft:end_highlands, ele toma toda a terra de ilha das suas regiões (terras altas, médias e áridas); substituindo minecraft:small_end_islands, o vazio entre as ilhas. A ilha central continua a do jogo, e as regiões são diferentes em cada mundo.

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

Bom saber

Só chunks novos. Chunks já gerados não mudam; só os gerados depois de instalar o mod recebem minérios, árvores, plantas, estruturas e biomas. Explore terreno novo para encontrá-los.
Nomes ausentes são ignorados. Um bioma ou tag em biomes que não existe (por exemplo, de outro mod que não está instalado) é ignorado, não é um erro.
Sem solo, sem estrutura. Uma estrutura que fica na superfície não é criada onde a sua coluna não tem solo nenhum, como o vazio entre as ilhas do End.
Features, estruturas, terreno, mapas de biomas, carvers e solos escritos em código estão na página Geração por código.
Mundos inteiros próprios estão na página Dimensões.

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