Guia de scripts
Um script é um pequeno programa em JavaScript que posiciona blocos de Minecraft. Este guia explica como escrever um, executá-lo no navegador e publicá-lo no catálogo público. Qualquer pessoa com uma conta do Bloxelizer pode fazer as três coisas.
Introdução
Os scripts rodam inteiramente no seu navegador, dentro de um interpretador JavaScript isolado. Nada é enviado enquanto você experimenta: você escreve o código de um lado do editor, pressiona Executar e os blocos posicionados aparecem nos visualizadores 2D e 3D do outro lado.
O objetivo de um script, em vez de uma construção avulsa, é que outras pessoas possam executá-lo com configurações diferentes. Um script que declara entradas ganha um painel de controles ao lado do visualizador, para que alguém que nunca leu seu código possa mudar o tamanho, o material ou a seed e exportar o resultado.
Quando estiver satisfeito, pressione Salvar. O script é enviado para análise e, depois de aprovado, ganha a própria página no catálogo de scripts.
Você não precisa de uma conta para experimentar
Escrever e executar scripts é aberto a todos. Só é preciso entrar na conta para salvar um script e enviá-lo para análise.
Seu primeiro script
Abra o editor, substitua o que está lá pelo código a seguir e pressione Executar. Ele cria um piso de pedra de 8 por 8 e coloca uma tocha no meio dele.
function main(context) {
const { Creation } = context;
const creation = Creation('My first build');
creation.fillBox(0, 0, 0, 7, 0, 7, 'minecraft:stone');
creation.setBlock(3, 1, 3, 'minecraft:torch');
return { creation };
}Três coisas merecem atenção. As coordenadas são inteiros e y é o eixo vertical, então a tocha fica um bloco acima do piso. fillBox recebe dois cantos opostos e preenche tudo entre eles, o que é muito mais rápido do que usar um laço. E todo script devolve seu trabalho retornando { creation }; um script que constrói uma creation mas nunca a retorna não produz nada.
Os ids de bloco são os do jogo base, com o namespace minecraft:. O editor os autocompleta assim que você começa a digitar dentro de uma string, então raramente é preciso procurar um.
Anatomia de um script
Um script é JavaScript puro com duas funções especiais de nível superior. Você pode usar a sintaxe do TypeScript se preferir: os tipos são removidos antes de o script ser armazenado ou executado.
main(context, inputs)
Obrigatória. É o que roda quando alguém pressiona Executar. Ela recebe o objeto context, que reúne todos os helpers, e os valores atuais das entradas que você declarou. Deve retornar um objeto contendo uma creation e pode retornar também uma camera.
defineInputs(context)
Opcional. Retorne um mapa de definições de entradas e o editor cria um controle para cada uma. Os valores chegam então como segundo argumento de main, com as mesmas chaves.
function defineInputs(context) {
const { Input } = context;
return {
size: Input.number({
label: 'Size',
description: 'Length of each side, in blocks',
defaultValue: 8,
min: 1,
max: 64,
}),
material: Input.block({
label: 'Material',
defaultValue: 'minecraft:stone',
}),
};
}
function main(context, inputs) {
const { Creation } = context;
const creation = Creation('Platform');
const last = inputs.size - 1;
creation.fillBox(0, 0, 0, last, 0, last, inputs.material);
return { creation };
}defineInputs é executada antes de os recursos carregarem
Nada está carregado ainda quando defineInputs é chamada, então só as chamadas de listagem em Textures estão disponíveis ali, como listBlockNames() ou listMobModels(). Consultas de cor, modelos e sprites pertencem à main.
Posicionando blocos
Uma creation reúne operações de bloco na ordem em que você as faz. Escritas posteriores na mesma célula prevalecem, então você pode criar uma forma sólida e depois escavá-la.
Você não precisa construir na origem. A construção é normalizada para a própria caixa delimitadora na exportação, então coordenadas negativas e os deslocamentos que forem convenientes para as suas contas não são problema.
Para qualquer coisa grande, prefira fillBox a laços aninhados: uma operação que cobre um milhão de blocos é mais barata de produzir, armazenar e renderizar do que um milhão de operações. Use laços só quando a forma realmente varia a cada bloco.
Estados de bloco
Escadas ficam voltadas para uma direção, troncos têm um eixo, portas têm uma metade. Esses são os estados de bloco, e eles são sempre passados como strings, inclusive "true" e "false".
// States are always strings, including "true" and "false".
creation.setBlock(0, 0, 0, 'minecraft:oak_stairs', {
facing: 'east',
half: 'bottom',
shape: 'straight',
waterlogged: 'false',
});
// Ask rather than guess: a bare banner has no placeable default.
const states = Textures.getPlacementStates('minecraft:white_banner');
creation.setBlock(2, 0, 0, 'minecraft:white_banner', states);
// Two-cell blocks place their other half for you, in the right
// direction: this one call leaves a whole bed facing east, so the
// head lands in the cell at x=5.
creation.setBlock(4, 0, 0, 'minecraft:red_bed', { facing: 'east' });Os padrões de um bloco muitas vezes não são posicionáveis, o que é o motivo mais comum de um bloco de uma célula parecer errado no visualizador. Textures.getPlacementStates retorna os estados que permitem a um bloco ficar no chão, e Textures.getStateOptions lista todos os estados que um bloco aceita, com seus valores válidos. Use-os em vez de adivinhar pelo nome do bloco.
O render de um bloco pode ultrapassar a própria célula
Um estandarte em pé é um bloco, mas o tecido é desenhado subindo cerca de 1,6 bloco acima da célula em que está. Isso é um render, não um bloco: não acrescenta nada à contagem de camadas, à lista de materiais nem à altura da construção, então um estandarte na camada superior ainda deixa a construção com uma camada de altura acima do que quer que o sustente.
Blocos de duas células são posicionados inteiros
Portas, camas e flores altas ocupam duas células. Você posiciona uma e o setBlock adiciona a outra metade sozinho, levando seus estados junto e colocando a cabeceira de uma cama na ponta para a qual ela está voltada. Para posicionar uma metade isolada de propósito, nomeie-a: passar { half: 'upper' } ou { part: 'head' } posiciona só aquela.
Entradas
Cada helper de Input produz um controle. O tipo do valor que chega a main depende do helper usado.
| Helper | Valor em main | Opções específicas do tipo |
|---|---|---|
Input.number | number | min, max, step |
Input.string | string | defaultValue |
Input.boolean | boolean | defaultValue |
Input.select | string | options: string[] | { value, label }[] |
Input.multiselect | string[] | options: string[] |
Input.block | string | options: ids de blocos (o padrão é todos os blocos) |
Input.file | ScriptFile | null | accept, required, paintable, allowMultipleFiles |
Opções que toda entrada aceita
| Opção | Tipo | Descrição |
|---|---|---|
label | string | Rótulo do controle. Obrigatório. |
description | string | Texto de ajuda sob o controle. |
defaultValue | varies | Valor usado antes de o visualizador mexer em qualquer coisa. |
folder | string | Agrupa este controle com outros da mesma pasta. |
order | number | Posição de ordenação dentro de uma pasta. Valores menores aparecem primeiro. |
visibleWhen | { input, in?, notIn? } | Oculta o controle, a menos que outra entrada tenha um destes valores. |
resetsInputs | string[] | Redefine estas entradas para os padrões quando esta mudar. |
resetValuesByOption | Record<string, Record<string, unknown>> | Valores predefinidos a aplicar no lugar dos padrões, indexados pelo valor desta entrada. |
folder e order valem a pena assim que um script tem mais do que um punhado de controles, e visibleWhen mantém o painel coerente quando um script se ramifica: uma entrada que só importa em um modo não deve ficar visível no outro.
Arquivos e imagens
Os scripts não acessam a rede, então tudo que vem de fora entra por uma entrada de arquivo. Um arquivo chega como um ScriptFile: name, type, size, além de text para arquivos de texto, dataUrl e imageData para imagens.
imageData é { width, height, data }, em que data é RGBA plano, quatro entradas por pixel, com as linhas indo de cima para baixo. Como o Y cresce para cima em uma construção, você normalmente vai inverter o índice da linha.
function defineInputs(context) {
const { Input } = context;
return {
image: Input.file({
label: 'Image',
accept: 'image/*',
paintable: true,
}),
};
}
function main(context, inputs) {
const { Creation, Textures } = context;
const creation = Creation('Pixel art');
const image = inputs.image;
if (!image || !image.imageData) return { creation };
const { width, height, data } = image.imageData;
for (let y = 0; y < height; y++) {
for (let x = 0; x < width; x++) {
const at = (y * width + x) * 4;
if (data[at + 3] < 128) continue; // Skip transparent pixels.
const block = Textures.findClosestBlockToColor(
data[at],
data[at + 1],
data[at + 2],
);
// Image rows run top-down, Y runs up, so flip the row.
creation.setBlock(x, height - 1 - y, 0, block);
}
}
return { creation };
}Definir paintable: true em uma entrada de imagem dá ao visualizador um editor de pintura no próprio app em vez de um seletor de arquivos, o que é um bom padrão para scripts em que a imagem é um esboço, e não uma foto.
Uma entrada de arquivo com um arquivo de estrutura é especial: o host o interpreta para você antes de main começar, e Structures.getLoadedSchem() devolve os blocos que ele contém. Sem nome, ele resolve a entrada chamada schematic; passe o nome de uma entrada para escolher uma quando um script recebe várias construções, como faz um diff.
function defineInputs(context) {
const { Input } = context;
// The host pre-parses a file input named exactly `schematic`.
return {
schematic: Input.file({ label: 'Build', accept: '.litematic,.schem,.nbt' }),
};
}
function main(context) {
const { Creation, Structures, Logger } = context;
const creation = Creation('Doubled');
const loaded = Structures.getLoadedSchem();
if (!loaded.ok) {
Logger.warn(loaded.error);
return { creation };
}
for (const op of loaded.operations) {
creation.setBlock(op.x * 2, op.y, op.z * 2, op.name, op.states);
}
return { creation };
}Enquadrando o resultado
Retorne uma camera junto com a creation para escolher onde o visualizador 3D começa. É útil quando o lado interessante de uma construção não é aquele em que a câmera padrão cai.
return {
creation,
camera: {
position: [40, 30, 40],
target: [0, 8, 0],
},
};Marcando blocos
Retorne highlights para que o visualizador 3D desenhe uma borda colorida ao redor de células nomeadas. Os blocos mantêm seus modelos, então isso diz algo sobre uma célula sem repintar a construção: quais blocos um diff adicionou, quais células uma verificação sinalizou, quais uma passagem tocou.
Cada entrada é um par { color, blocks }, em que color é uma string hexadecimal como #22c55e e blocks é uma lista de células [x, y, z]. São desenhados até oito grupos e 200.000 células contornadas por execução, e uma entrada que o visualizador não consegue ler é ignorada em vez de fazer o script falhar.
function main(context) {
const { Creation } = context;
const creation = Creation('Review');
const added = [];
creation.setBlock(0, 0, 0, 'minecraft:stone');
added.push([0, 0, 0]);
// Each block still renders as itself; only the border is coloured.
return {
creation,
highlights: [{ color: '#22c55e', blocks: added }],
};
}Referência: context
Tanto defineInputs quanto main recebem um objeto de contexto. Desestruture dele o que precisar em vez de recorrer a globais.
function main(context, inputs) {
const { Creation, Logger, Textures, Structures } = context;
// ...
}| Helper | Finalidade |
|---|---|
Creation | Constrói a saída. |
Logger | Escreve no painel de log do editor. |
Textures | Dados de blocos: nomes, cores, estados, modelos, modelos de mobs e de skins. |
Structures | Estruturas jigsaw do jogo base e o schematic fornecido pelo visualizador. |
Tree, Trees, Rocks, Gradients | Geradores prontos que retornam operações. |
O editor conhece tudo isto
As definições de tipos completas acompanham o editor, então ao passar o mouse sobre um helper ou pressionar Ctrl + Espaço você vê a assinatura e a documentação exatas na hora. Esta página cobre as partes mais usadas.
Referência: Creation
Creation(name?: string): CreationInstanceCria o objeto em que o seu script constrói. A maioria dos scripts cria exatamente um, no início de main.
| Parâmetro | Tipo | Descrição |
|---|---|---|
name | string | Nome levado para as exportações. O padrão é "Untitled". |
Retorna uma nova creation para posicionar blocos.
creation.setBlock(x, y, z, name, states?): voidPosiciona um bloco. Escrever duas vezes na mesma célula mantém a última escrita. Um bloco de duas células também tem a segunda metade posicionada, a menos que os estados informados já indiquem uma metade.
| Parâmetro | Tipo | Descrição |
|---|---|---|
x, y, z | number | Posição. Inteiros; Y é para cima. |
name | string | Id do bloco, por exemplo minecraft:stone. |
states | Record<string, string> | Estados do bloco. Os valores são strings, inclusive "true". |
creation.setBlock(0, 0, 0, 'minecraft:oak_log', { axis: 'y' });creation.fillBox(x1, y1, z1, x2, y2, z2, type): voidPreenche todas as células entre dois cantos. Prefira isto a um laço sempre que o bloco não variar.
| Parâmetro | Tipo | Descrição |
|---|---|---|
x1, y1, z1 | number | Um canto, inclusivo. |
x2, y2, z2 | number | O canto oposto, inclusivo. |
type | string | { name, states } | Id do bloco ou um bloco com estados. |
creation.fillBox(0, 0, 0, 15, 0, 15, {
name: 'minecraft:oak_log',
states: { axis: 'x' },
});creation.addOperations(ops): voidAdiciona operações em lote. É assim que os geradores integrados colocam sua saída em uma creation.
| Parâmetro | Tipo | Descrição |
|---|---|---|
ops | Operation[] | Operações, como as que um gerador retorna. |
creation.getOperations(): Operation[]Retorna tudo o que foi posicionado até agora, o que permite que um script inspecione ou pós-processe a própria saída antes de retornar.
creation.reset(): voidDescarta todas as operações, deixando uma creation vazia.
Referência: Input
Disponível no contexto passado a defineInputs. Veja Entradas acima para as tabelas completas de opções.
Input.number(config)
Input.string(config)
Input.boolean(config)
Input.select(config)
Input.multiselect(config)
Input.block(config)
Input.file(config)Cada uma retorna uma definição de entrada tipada. Retorne-as de defineInputs com a chave do nome que você quer ler em main.
sourceEntity: Input.select({
label: 'Entity',
options: Textures.listMobModels().map((model) => model.id),
visibleWhen: { input: 'sourceType', in: ['entity'] },
})Referência: Logger
Logger.info(...args)
Logger.warn(...args)
Logger.error(...args)
Logger.debug(...args)Escreve uma linha no painel de log abaixo do editor. A saída é limitada a 1.000 linhas por execução, então registre resumos em vez de uma linha por bloco.
Logger.info('placed', creation.getOperations().length, 'operations');Referência: Textures
O maior namespace, e o que transforma um script de gerador de formas em algo que conhece o Minecraft. Só as chamadas de listagem funcionam dentro de defineInputs.
Listando blocos
| Chamada | O que retorna |
|---|---|
listBlockNames(mcVersion?) | Todos os ids de bloco, opcionalmente restritos a uma versão do Minecraft. |
listPaletteBlocks() | Cubos completos, opacos e obteníveis no survival: o conjunto em que uma correspondência de cor pode cair. |
listBuildableBlocks() | Blocos da paleta que também ficam parados, sem areia, concreto em pó e fontes de luz. |
listModelBlocks() | Blocos cujo próprio modelo pode ser voxelizado em uma estátua de si mesmos. |
listItems() | Todos os itens que têm sprite. |
listMobModels() | Modelos de mobs, como { id, displayName }. |
listEntityModels() | Os mesmos modelos que valem uma estátua, incluindo o suporte de armadura. |
listPosePresets() | As poses em que um mob pode ser construído, como { id, displayName }. |
listMinecraftVersions() | As versões pelas quais listBlockNames pode filtrar, da mais antiga à mais nova. |
Correspondência de cores
Textures.findClosestBlockToColor(r, g, b, palette?, options?): stringEncontra o bloco cuja cor processada é mais próxima de um valor RGB. Em blocos estampados, a média padrão pode ser uma cor que não aparece em lugar nenhum da textura, então dominant costuma ser a melhor opção para qualquer coisa esmaltada ou estampada.
| Parâmetro | Tipo | Descrição |
|---|---|---|
r, g, b | number | Componentes de cor, de 0 a 255. |
palette | string[] | Restringe a busca a estes blocos. O padrão é todos os blocos da paleta. |
options | { colorSource?, metric? } | colorSource é "average" ou "dominant"; metric é "lab" ou "ciede2000". |
Retorna o id do bloco mais próximo.
const block = Textures.findClosestBlockToColor(200, 60, 40, palette, {
colorSource: 'dominant',
metric: 'ciede2000',
});Textures.getBlockColor(blockName, colorSource?): { r, g, b } | nullA consulta inversa. Combine-a com findClosestBlockToColor para casar um bloco com outro, como escolher o tapete mais próximo de um piso.
Retorna a cor do bloco ou null quando ele não tem dados de cor.
Estados e formas
Textures.getPlacementStates(blockName): Record<string, string> | nullPasse estes para setBlock em vez de posicionar um bloco puro. Um modelo que escolhe a variante por facing não resolve em nada sem esse estado, botões usam face=wall por padrão e ficam flutuando, e corais vivos usam waterlogged=true por padrão.
Retorna estados que permitem ao bloco ficar no chão ou null.
Textures.getStateOptions(blockName): Record<string, string[]> | nullCombine-o com getPlacementStates quando a forma importar. Um painel, cerca ou muro sem nada para se conectar é desenhado como um poste solto, então peça as conexões que você quer.
Retorna todos os estados que o bloco aceita e seus valores válidos.
Textures.getSecondPart(blockName): { states, offset } | nullPara portas, camas e flores altas; null para qualquer coisa que fica sozinha. O setBlock já posiciona a segunda metade, então use isto só quando um script precisar saber a forma que um bloco terá, como conferir se há espaço antes de posicioná-lo.
Retorna os estados e o deslocamento da outra metade ou null.
Textures.getBlockTraits(blockName): BlockTraits | nullFatos de um bloco relevantes para a construção, para decidir se vale oferecê-lo ou posicioná-lo. É melhor do que adivinhar por trechos do nome do bloco.
Retorna flags como BlockEntity, NeedsSupport e CreativeOnly.
Modelos e texturas
Textures.getBlockModel(blockName, blockProperties?): BlockModel | nullA estrutura bruta do modelo, para voxelizar um bloco em uma estátua maior de si mesmo. Blocos do tipo entidade, como baús e camas, voltam com geometria sintetizada sinalizada por entityModel; os que não têm geometria alguma, como cabeças, retornam null.
Retorna os elementos e as texturas de face do modelo ou null.
Textures.sampleTextureAtUV(textureName, u, v, options?): [r, g, b, a] | nullLê um pixel de uma textura. Sem exact, uma textura não quadrada é tratada como uma tira de animação e um nome desconhecido amostra silenciosamente o canto do atlas, então passe-o quando qualquer um dos dois for possível.
| Parâmetro | Tipo | Descrição |
|---|---|---|
textureName | string | Um nome de textura das faces de um modelo. |
u, v | number | Coordenadas de 0 a 1. |
options | { exact?: boolean } | exact lê o retângulo da própria textura e retorna null quando ela não existe. |
Textures.getTextureSize(textureName): { width, height } | nullPermite voxelizar na resolução em que um bloco foi realmente desenhado: os sprites do jogo base são 16 por 16, e os pacotes de recursos podem ser 32 ou 64.
Retorna o tamanho de um quadro ou null.
Textures.getItemSprite(itemId): { width, height, data } | nullSó o item indicado por uma entrada sourceItem é carregado antes de uma execução, então pedir outro retorna null. Os sprites são fornecidos com 64 pixels para artes feitas em 16, então faça a média de cada bloco de 4 por 4 em vez de ler pixels isolados.
Retorna linhas RGBA, a de cima primeiro, ou null.
Mobs e skins
Textures.getMobModel(name, options?): { blocks, size, sourceBounds } | nullVoxeliza um mob em blocos que você pode posicionar. Passe os blocks retornados para setBlock um de cada vez ou desloque-os antes.
| Parâmetro | Tipo | Descrição |
|---|---|---|
name | string | Um id de modelo de listMobModels ou listEntityModels. |
options | { scale?, offset?, textureName?, palette?, pose? } | Escala dos voxels, deslocamento de posição, os blocos com que montá-lo e como ele fica em pé. |
Textures.listPosePresets(): Array<{ id, displayName }>Passe um id de volta direto como pose ou informe você mesmo os ângulos: headTurn, headTilt, rightArmSwing, rightArmRaise, leftArmSwing, leftArmRaise, rightLegSwing e leftLegSwing, todos em graus. Um swing é para a frente quando positivo, um raise afasta o braço do corpo, e a cabeça vira para a esquerda do mob e inclina para baixo quando positivo. Cada parte gira em torno da própria articulação, então só um mob com corpo de pessoa aceita tudo: um mob de quatro patas vira a cabeça e fica como está. A rotação é reamostrada na grade de blocos, então uma estátua em pose de ângulo acentuado pede uma scale maior para ficar limpa.
Retorna as poses em que um mob pode ser construído, para um seletor.
Textures.getSkinModel(name, options): { blocks, size, sourceBounds } | nullA mesma coisa para um modelo de jogador, com a textura de uma skin enviada no visualizador.
| Parâmetro | Tipo | Descrição |
|---|---|---|
name | string | Um modelo de jogador de getPlayerModels. |
options | { textureFile, scale?, offset?, palette? } | textureFile é um ScriptFile de uma entrada de arquivo com a imagem da skin. |
Referência: Structures
Structures.getLoadedSchem(name?): { ok, operations?, error? }O host interpreta todas as entradas de arquivo de estrutura antes de main rodar, em qualquer formato que o importador de schematics suporte, até quatro por execução. Confira ok antes de ler operations: uma construção ausente ou ilegível informa o próprio error sem afetar as demais.
| Parâmetro | Tipo | Descrição |
|---|---|---|
name | string | A entrada de arquivo a ler. O padrão é a chamada schematic ou a primeira declarada. |
Retorna os blocos interpretados do schematic que essa entrada contém.
Structures.listLoadedSchems(): string[]Na ordem em que getLoadedSchem() as resolve, então a primeira entrada é o que uma chamada sem nome retorna.
Retorna os nomes de entrada sob os quais um schematic foi interpretado.
Structures.generate(options): Promise<string[]>Gera uma estrutura jigsaw do jogo base, como uma vila ou um posto de saqueadores, e a renderiza diretamente.
| Parâmetro | Tipo | Descrição |
|---|---|---|
options.structureId | string | Um pool de estruturas, p. ex. "minecraft:village/plains/town_centers". |
options.depth | number | Quantas peças posicionar. |
options.radius | number | Raio horizontal máximo. |
options.height | number | Altura vertical máxima. |
const chunkIds = await Structures.generate({
structureId: 'minecraft:village/plains/town_centers',
depth: 7,
});Referência: Generators
Quatro namespaces produzem formas prontas. Todos retornam operações setBlock ancoradas na origem em vez de desenhar algo, então você pode deslocar, filtrar ou repetir a saída antes de ela chegar à creation.
function main(context) {
const { Creation, Trees, Rocks } = context;
const creation = Creation('Grove');
// Generators return operations rather than drawing anything themselves,
// so you can filter or offset them before they reach the creation.
creation.addOperations(Trees.generate({ species: 'Oak', seed: 1, count: 3, spread: 12 }));
creation.addOperations(Rocks.generate({ formation: 'Boulder', seed: 7, size: 5 }));
return { creation };
}| Namespace | Gera | Descoberta |
|---|---|---|
Trees | Árvores e bosques detalhados por espécie, com copas, acabamento e cipós. | Trees.species() |
Rocks | Rochas, geodos e colunas de basalto. | Rocks.formations() |
Gradients | Rampas de blocos lineares, radiais e de quatro cantos com dithering. | options: kind, stops, dither, paletteFilter |
Tree | O gerador de árvores mais antigo, orientado por parâmetros. | Tree.getDefaults() |
Sandbox e limites
Os scripts rodam em um interpretador QuickJS isolado. Não há DOM, window, document, temporizadores nem acesso à rede. Um script que precisa de dados externos recebe uma entrada de arquivo.
Enquanto um script roda
| Limite | Valor |
|---|---|
| Memória | 128 MB |
| Tempo de execução | 10 minutos, depois a execução é interrompida |
| Tamanho do código-fonte no editor | 1.000.000 de caracteres |
| Intervalo de coordenadas | ±30,000,000 |
| Saída do log | 1.000 linhas, 2.000 caracteres por linha |
| Blocos posicionados | Sem limite |
Ao enviar
O código enviado é verificado de novo no servidor, e estas regras são mais rígidas que as do editor.
- O código compilado deve ter 100 KB ou menos. Um script muito grande pode, portanto, ser executado localmente, mas não publicado.
- O código não pode conter nenhum dos seguintes itens:
eval(,Function(,setTimeout,setInterval,XMLHttpRequest,fetch(,import(,require(,process.,child_process,fs.,globalThis,global.,__proto__,constructor.constructor. - Código idêntico é rejeitado como duplicado: o servidor calcula o hash do script compilado, então republicar literalmente o trabalho de outra pessoa não passa.
A verificação de padrões é uma correspondência de texto simples
Ele não interpreta seu código, então também dispara dentro de comentários e strings, e uma variável inofensiva chamada fetchRow será rejeitada por conter fetch(. Renomeie-a e envie de novo.
Enviando um script
Pressione Salvar com a conta conectada. Pediremos um título e uma descrição, e o script entra em uma fila de análise.
- Um script pendente só é visível para você. A página dele lista todas as versões que você enviou, com o estado de cada uma.
- Depois de aprovado, o script aparece no catálogo público com página e endereço próprios, e qualquer pessoa pode executá-lo.
- Salvar de novo cria uma nova versão, analisada separadamente. A versão aprovada continua no ar nesse meio tempo, então uma edição nunca quebra o que outras pessoas estão usando.
- Você pode excluir seus próprios scripts a qualquer momento na página do script.
Antes de enviar
- Dê um título de até 100 caracteres e uma descrição de pelo menos 10 que diga o que ele constrói e o que as entradas fazem.
- Confira se ele roda até o fim com as entradas padrão. Um script que só funciona com um arquivo específico é difícil de aprovar.
- Dê a cada entrada um padrão sensato, um rótulo claro e um intervalo que não possa gerar uma construção grande demais para renderizar.
- Títulos e descrições passam por um filtro de conteúdo, e os links em uma descrição são conferidos em uma lista de bloqueio.
O nome e a descrição são fixos
Depois que um script existe, os salvamentos seguintes alteram o código e criam uma versão. Eles não o renomeiam, então escolha um título que você queira manter.
Solução de problemas
Nenhuma função main definida
O script foi interpretado, mas nunca declarou main. Declare-a como uma função de nível superior, não aninhada dentro de outra nem atribuída condicionalmente.
Nome de bloco do script inválido
Uma chamada de setBlock ou fillBox recebeu algo que não é uma string de id de bloco. Isso costuma vir de uma consulta que pode falhar, como um índice de paleta que passou do fim de um array.
Coordenada do script inválida
Uma coordenada era NaN, infinita ou fora de ±30.000.000. Quase sempre é uma divisão por zero ou uma entrada convertida em NaN.
O script roda, mas nada aparece
Confira se main retorna { creation } e se a creation retornada é aquela em que você posicionou os blocos.
Um bloco aparece como um cubo liso ou um poste solto
Ele foi posicionado sem estados utilizáveis. Use Textures.getPlacementStates e Textures.getStateOptions para as conexões de painéis, cercas e muros.
Algo diferente? Fale com a gente pela página de perguntas frequentes.