Scriptelizer

Guía de scripts

Un script es un pequeño programa de JavaScript que coloca bloques de Minecraft. Esta guía explica cómo escribir uno, ejecutarlo en el navegador y publicarlo en el catálogo público. Cualquiera con una cuenta de Bloxelizer puede hacer las tres cosas.

Introducción

Los scripts se ejecutan por completo en tu navegador, dentro de un intérprete de JavaScript aislado. No se sube nada mientras experimentas: escribes código a un lado del editor, pulsas Ejecutar y los bloques que coloca aparecen en los visores 2D y 3D del otro lado.

La gracia de un script, frente a una construcción puntual, es que otras personas pueden ejecutarlo con ajustes distintos. Un script que declara entradas obtiene un panel de controles junto al visor, de modo que alguien que nunca ha leído tu código puede cambiar el tamaño, el material o la semilla y exportar el resultado.

Cuando estés satisfecho con él, pulsa Guardar. El script se envía a revisión y, una vez aprobado, tiene su propia página en el catálogo de scripts.

No necesitas una cuenta para experimentar

Escribir y ejecutar scripts está abierto a todo el mundo. Iniciar sesión solo es necesario para guardar un script y enviarlo a revisión.

Tu primer script

Abre el editor, reemplaza lo que haya por lo siguiente y pulsa Ejecutar. Coloca un suelo de piedra de 8 por 8 y pone una antorcha en el centro.

script.js
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 };
}

Hay tres cosas que conviene notar. Las coordenadas son números enteros y y es el eje vertical, así que la antorcha queda un bloque por encima del suelo. fillBox toma dos esquinas opuestas y rellena todo lo que hay entre ellas, lo cual es mucho más rápido que un bucle. Y todo script devuelve su trabajo con { creation }; un script que construye una creación pero nunca la devuelve no produce nada.

Los ids de bloque son los de vanilla, con el espacio de nombres minecraft:. El editor los autocompleta en cuanto empiezas a escribir dentro de una cadena, así que rara vez tendrás que buscar uno.

Anatomía de un script

Un script es JavaScript normal con dos funciones especiales de nivel superior. Si lo prefieres, puedes usar sintaxis de TypeScript: los tipos se eliminan antes de guardar o ejecutar el script.

main(context, inputs)

Obligatoria. Es lo que se ejecuta cuando alguien pulsa Ejecutar. Recibe el objeto context, que contiene todos los ayudantes, y los valores actuales de las entradas que declaraste. Debe devolver un objeto que contenga una creation y, opcionalmente, una camera.

defineInputs(context)

Opcional. Devuelve un mapa de definiciones de entradas y el editor muestra un control para cada una. Los valores llegan después como segundo argumento de main, con las mismas claves.

script.js
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 se ejecuta antes de que se carguen los recursos

Cuando se llama a defineInputs todavía no se ha cargado nada, así que ahí solo están disponibles las llamadas de listado de Textures, como listBlockNames() o listMobModels(). Las consultas de color, los modelos y los sprites van en main.

Colocar bloques

Una creación reúne las operaciones de bloques en el orden en que las haces. Las escrituras posteriores en la misma celda prevalecen, así que puedes colocar una forma sólida y luego tallarla.

No hace falta construir en el origen. La construcción se normaliza a su propia caja delimitadora al exportar, así que las coordenadas negativas y los desplazamientos que te convengan para tus cálculos no son un problema.

Para cualquier cosa grande, prefiere fillBox a los bucles anidados: una operación que cubre un millón de bloques es más barata de producir, almacenar y renderizar que un millón de operaciones. Usa bucles solo donde la forma varíe realmente de un bloque a otro.

Estados de bloque

Las escaleras miran en una dirección, los troncos tienen un eje y las puertas tienen una mitad. Son estados de bloque y siempre se pasan como cadenas de texto, incluidos "true" y "false".

script.js
// 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' });

Los valores por defecto de un bloque a menudo no son colocables, que es la razón más común de que un bloque de una sola celda se vea mal en el visor. Textures.getPlacementStates devuelve los estados que permiten que un bloque se sostenga en el suelo, y Textures.getStateOptions enumera todos los estados que acepta un bloque junto con sus valores válidos. Úsalos en lugar de adivinar a partir del nombre del bloque.

El render de un bloque puede salirse de su celda

Un estandarte de pie es un solo bloque, pero su tela se dibuja elevándose unos 1,6 bloques por encima de la celda en la que está. Eso es un render, no un bloque: no añade nada al número de capas, a la lista de materiales ni a la altura de la construcción, así que un estandarte en la capa superior deja la construcción con la misma altura sobre lo que lo sostiene.

Los bloques de dos celdas se colocan enteros

Las puertas, las camas y las flores altas ocupan dos celdas. Tú colocas una y setBlock añade la otra mitad por sí mismo, trasladando tus estados y poniendo la cabecera de una cama en el extremo hacia el que mira. Para colocar una sola mitad a propósito, nómbrala: pasar { half: 'upper' } o { part: 'head' } coloca solo esa.

Entradas

Cada ayudante de Input produce un control. El tipo del valor que llega a main depende del ayudante que hayas usado.

AyudanteValor en mainOpciones específicas del tipo
Input.numbernumbermin, max, step
Input.stringstringdefaultValue
Input.booleanbooleandefaultValue
Input.selectstringoptions: string[] | { value, label }[]
Input.multiselectstring[]options: string[]
Input.blockstringoptions: ids de bloque (por defecto, todos los bloques)
Input.fileScriptFile | nullaccept, required, paintable, allowMultipleFiles

Opciones que acepta toda entrada

OpciónTipoDescripción
labelstringEtiqueta del control. Obligatoria.
descriptionstringTexto de ayuda bajo el control.
defaultValuevariesValor usado antes de que el espectador toque nada.
folderstringAgrupa este control con otros de la misma carpeta.
ordernumberPosición de orden dentro de una carpeta. Los valores menores se muestran primero.
visibleWhen{ input, in?, notIn? }Oculta el control salvo que otra entrada tenga uno de estos valores.
resetsInputsstring[]Restablece estas entradas a sus valores por defecto cuando esta cambia.
resetValuesByOptionRecord<string, Record<string, unknown>>Valores predefinidos que se aplican en lugar de los por defecto, según el valor de esta entrada.

folder y order merecen la pena en cuanto un script tiene más de un puñado de controles, y visibleWhen mantiene el panel coherente cuando un script se ramifica: una entrada que solo importa en un modo no debería verse en el otro.

Archivos e imágenes

Los scripts no pueden acceder a la red, así que todo lo que viene de fuera entra mediante una entrada de archivo. Un archivo llega como un ScriptFile: name, type, size, más text para archivos de texto, dataUrl e imageData para imágenes.

imageData es { width, height, data }, donde data es RGBA plano, con cuatro valores por píxel y las filas de arriba abajo. Como en una construcción Y crece hacia arriba, normalmente tendrás que invertir el índice de fila.

script.js
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 };
}

Si pones paintable: true en una entrada de imagen, el visor ofrece un editor de dibujo integrado en lugar de un selector de archivos, lo cual es una buena opción para scripts donde la imagen es un boceto y no una foto.

Una entrada de archivo que contiene un archivo de estructura es especial: el host lo analiza por ti antes de que empiece main, y Structures.getLoadedSchem() devuelve los bloques que contiene. Sin nombre, resuelve la entrada llamada schematic; pasa un nombre de entrada para elegir una cuando un script recibe varias construcciones, como hace un diff.

script.js
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 };
}

Encuadrar el resultado

Devuelve una camera junto a la creación para elegir desde dónde empieza el visor 3D. Es útil cuando el lado interesante de una construcción no es el que muestra la cámara predeterminada.

return {
  creation,
  camera: {
    position: [40, 30, 40],
    target: [0, 8, 0],
  },
};

Marcar bloques

Devuelve highlights para que el visor 3D dibuje un borde de color alrededor de las celdas indicadas. Los bloques conservan sus propios modelos, así que esto dice algo sobre una celda sin repintar la construcción: qué bloques añadió un diff, qué celdas marcó una comprobación o cuáles tocó una pasada.

Cada entrada es un par { color, blocks }, donde color es una cadena hexadecimal como #22c55e y blocks es una lista de celdas [x, y, z]. En cada ejecución se dibujan hasta ocho grupos y 200 000 celdas con contorno, y una entrada que el visor no pueda leer se omite en lugar de hacer fallar el script.

script.js
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 }],
  };
}

Referencia: context

Tanto defineInputs como main reciben un objeto context. Desestructura lo que necesites en lugar de recurrir a variables globales.

function main(context, inputs) {
  const { Creation, Logger, Textures, Structures } = context;
  // ...
}
AyudanteFinalidad
CreationConstruye la salida.
LoggerEscribe en el panel de registro del editor.
TexturesDatos de bloques: nombres, colores, estados, modelos y modelos de mobs y skins.
StructuresEstructuras jigsaw de vanilla y el schematic que proporcionó el visor.
Tree, Trees, Rocks, GradientsGeneradores predefinidos que devuelven operaciones.

El editor lo sabe todo esto

Las definiciones de tipos completas vienen con el editor, así que al pasar el cursor sobre un ayudante o al pulsar Ctrl + Espacio ves en el propio editor la firma exacta y la documentación. Esta página cubre las partes que más vas a usar.

Referencia: Creation

Creation(name?: string): CreationInstance

Crea el objeto en el que construye tu script. La mayoría de los scripts crean exactamente uno, al principio de main.

ParámetroTipoDescripción
namestringNombre que pasa a las exportaciones. Por defecto es "Untitled".

Devuelve una creación nueva donde colocar bloques.

creation.setBlock(x, y, z, name, states?): void

Coloca un bloque. Si se escribe dos veces en una celda, prevalece la última escritura. Un bloque de dos celdas también coloca su segunda mitad, salvo que los estados que pases ya indiquen una mitad.

ParámetroTipoDescripción
x, y, znumberPosición. Números enteros; Y es hacia arriba.
namestringId de bloque, por ejemplo minecraft:stone.
statesRecord<string, string>Estados del bloque. Los valores son cadenas de texto, incluido "true".
creation.setBlock(0, 0, 0, 'minecraft:oak_log', { axis: 'y' });
creation.fillBox(x1, y1, z1, x2, y2, z2, type): void

Rellena todas las celdas entre dos esquinas. Es preferible a un bucle siempre que el bloque no varíe.

ParámetroTipoDescripción
x1, y1, z1numberUna esquina, incluida.
x2, y2, z2numberLa esquina opuesta, incluida.
typestring | { name, states }Id de bloque, o un bloque con estados.
creation.fillBox(0, 0, 0, 15, 0, 15, {
  name: 'minecraft:oak_log',
  states: { axis: 'x' },
});
creation.addOperations(ops): void

Añade operaciones en bloque. Así es como los generadores integrados incorporan su salida a una creación.

ParámetroTipoDescripción
opsOperation[]Operaciones, como las que devuelve un generador.
creation.getOperations(): Operation[]

Devuelve todo lo colocado hasta ahora, lo que permite a un script inspeccionar o procesar su propia salida antes de devolverla.

creation.reset(): void

Descarta todas las operaciones y deja una creación vacía.

Referencia: Input

Disponible en el contexto que se pasa a defineInputs. Consulta Entradas más arriba para ver las tablas de opciones completas.

Input.number(config) Input.string(config) Input.boolean(config) Input.select(config) Input.multiselect(config) Input.block(config) Input.file(config)

Cada uno devuelve una definición de entrada tipada. Devuélvelas desde defineInputs con el nombre con el que quieras leerlas en main.

sourceEntity: Input.select({
  label: 'Entity',
  options: Textures.listMobModels().map((model) => model.id),
  visibleWhen: { input: 'sourceType', in: ['entity'] },
})

Referencia: Logger

Logger.info(...args) Logger.warn(...args) Logger.error(...args) Logger.debug(...args)

Escribe una línea en el panel de registro bajo el editor. La salida está limitada a 1000 líneas por ejecución, así que registra resúmenes en lugar de una línea por bloque.

Logger.info('placed', creation.getOperations().length, 'operations');

Referencia: Textures

El espacio de nombres más grande, y el que convierte un script de un generador de formas en algo que conoce Minecraft. Dentro de defineInputs solo funcionan las llamadas de listado.

Listar bloques

LlamadaQué devuelve
listBlockNames(mcVersion?)Todos los ids de bloque, opcionalmente limitados a una versión de Minecraft.
listPaletteBlocks()Cubos completos, opacos y obtenibles en supervivencia: el conjunto en el que puede caer una coincidencia de color.
listBuildableBlocks()Bloques de la paleta que además se quedan en su sitio, sin la arena, el cemento en polvo ni las fuentes de luz.
listModelBlocks()Bloques cuyo propio modelo se puede voxelizar en una estatua de sí mismos.
listItems()Todos los ítems que tienen sprite.
listMobModels()Plantillas de modelos de mobs, como { id, displayName }.
listEntityModels()Los mismos modelos de los que vale la pena hacer una estatua, incluido el soporte para armadura.
listPosePresets()Las poses en las que se puede construir un mob, como { id, displayName }.
listMinecraftVersions()Las versiones por las que puede filtrar listBlockNames, de la más antigua a la más reciente.

Coincidencia de color

Textures.findClosestBlockToColor(r, g, b, palette?, options?): string

Encuentra el bloque cuyo color precalculado está más cerca de un valor RGB. En bloques con patrones, la media por defecto puede ser un color que no aparece en ninguna parte de la textura, así que dominant suele ser la mejor opción para cualquier cosa vidriada o con patrones.

ParámetroTipoDescripción
r, g, bnumberComponentes de color, de 0 a 255.
palettestring[]Limita la búsqueda a estos bloques. Por defecto, todos los bloques de la paleta.
options{ colorSource?, metric? }colorSource es "average" o "dominant"; metric es "lab" o "ciede2000".

Devuelve el id del bloque más cercano.

const block = Textures.findClosestBlockToColor(200, 60, 40, palette, {
  colorSource: 'dominant',
  metric: 'ciede2000',
});
Textures.getBlockColor(blockName, colorSource?): { r, g, b } | null

La búsqueda inversa. Combínala con findClosestBlockToColor para emparejar un bloque con otro, por ejemplo para elegir la alfombra más cercana a un suelo.

Devuelve el color del bloque, o null si no tiene datos de color.

Estados y formas

Textures.getPlacementStates(blockName): Record<string, string> | null

Pásalos a setBlock en lugar de colocar un bloque a pelo. Un modelo que elige su variante según facing no se resuelve a nada sin él, los botones usan por defecto face=wall y flotan, y los corales vivos usan por defecto waterlogged=true.

Devuelve estados que permiten que el bloque se sostenga en el suelo, o null.

Textures.getStateOptions(blockName): Record<string, string[]> | null

Combínala con getPlacementStates cuando importe la forma. Un panel, una valla o un muro sin nada con lo que conectarse se dibuja como un poste desnudo, así que pide las conexiones que quieras.

Devuelve todos los estados que acepta el bloque y sus valores válidos.

Textures.getSecondPart(blockName): { states, offset } | null

Para puertas, camas y flores altas; null para todo lo que se sostiene solo. setBlock ya coloca la segunda mitad, así que recurre a esto solo cuando un script necesite saber la forma que tomará un bloque, por ejemplo para comprobar que hay sitio antes de colocarlo.

Devuelve los estados y el desplazamiento de la otra mitad, o null.

Textures.getBlockTraits(blockName): BlockTraits | null

Datos de un bloque relevantes para construir, para decidir si ofrecerlo o colocarlo. Mejor que adivinar a partir de fragmentos del nombre del bloque.

Devuelve indicadores como BlockEntity, NeedsSupport y CreativeOnly.

Modelos y texturas

Textures.getBlockModel(blockName, blockProperties?): BlockModel | null

La estructura bruta del modelo, para voxelizar un bloque en una estatua más grande de sí mismo. Los bloques de tipo entidad, como los cofres y las camas, devuelven geometría sintetizada marcada con entityModel; los que no tienen geometría alguna, como las cabezas, devuelven null.

Devuelve los elementos y las texturas de cara del modelo, o null.

Textures.sampleTextureAtUV(textureName, u, v, options?): [r, g, b, a] | null

Lee un píxel de una textura. Sin exact, una textura no cuadrada se trata como una tira de animación y un nombre desconocido muestrea en silencio la esquina del atlas, así que pásalo cuando cualquiera de los dos casos sea posible.

ParámetroTipoDescripción
textureNamestringUn nombre de textura de las caras de un modelo.
u, vnumberCoordenadas de 0 a 1.
options{ exact?: boolean }exact lee el propio rectángulo de la textura y devuelve null si falta.
Textures.getTextureSize(textureName): { width, height } | null

Te permite voxelizar a la resolución a la que se dibujó realmente un bloque: los sprites de vanilla son de 16 por 16, y los paquetes de recursos pueden ser de 32 o 64.

Devuelve el tamaño de un fotograma, o null.

Textures.getItemSprite(itemId): { width, height, data } | null

Antes de una ejecución solo se carga el ítem indicado por una entrada sourceItem, así que pedir otro devuelve null. Los sprites se proporcionan a 64 píxeles para arte creado a 16, así que promedia cada bloque de 4 por 4 en lugar de leer píxeles sueltos.

Devuelve filas RGBA, la fila superior primero, o null.

Mobs y skins

Textures.getMobModel(name, options?): { blocks, size, sourceBounds } | null

Voxeliza un mob en bloques que puedes colocar. Pasa los blocks devueltos a setBlock uno a uno, o desplázalos antes.

ParámetroTipoDescripción
namestringUn id de modelo de listMobModels o listEntityModels.
options{ scale?, offset?, textureName?, palette?, pose? }Escala de vóxel, desplazamiento de colocación, los bloques con los que construirlo y cómo se mantiene en pie.
Textures.listPosePresets(): Array<{ id, displayName }>

Pasa un id tal cual como pose, o pasa tú mismo los ángulos: headTurn, headTilt, rightArmSwing, rightArmRaise, leftArmSwing, leftArmRaise, rightLegSwing y leftLegSwing, todos en grados. Un balanceo es hacia delante si es positivo, una elevación separa el brazo del cuerpo, y la cabeza gira hacia la izquierda del mob y se inclina hacia abajo si es positivo. Cada parte gira alrededor de su propia articulación, así que solo un mob construido como una persona admite todo: un mob de cuatro patas gira la cabeza y se queda como está. La rotación se remuestrea sobre la cuadrícula de bloques, así que una estatua con una pose muy inclinada necesita una scale mayor para verse limpia.

Devuelve las poses en las que se puede construir un mob, para un selector.

Textures.getSkinModel(name, options): { blocks, size, sourceBounds } | null

Lo mismo para un modelo de jugador, con la textura de una skin que sube el espectador.

ParámetroTipoDescripción
namestringUn modelo de jugador de getPlayerModels.
options{ textureFile, scale?, offset?, palette? }textureFile es un ScriptFile de una entrada de archivo que contiene la imagen de la skin.

Referencia: Structures

Structures.getLoadedSchem(name?): { ok, operations?, error? }

El host analiza todas las entradas de archivo de estructura antes de que se ejecute main, en cualquier formato que admita el importador de schematics, hasta cuatro por ejecución. Comprueba ok antes de leer operations: una construcción que falte o no se pueda leer informa de su propio error sin afectar a las demás.

ParámetroTipoDescripción
namestringLa entrada de archivo que leer. Por defecto, la entrada llamada schematic o, si no, la primera declarada.

Devuelve los bloques analizados del schematic que contiene esa entrada.

Structures.listLoadedSchems(): string[]

En el orden en que los resuelve getLoadedSchem(), de modo que la primera entrada es lo que devuelve una llamada sin nombre.

Devuelve los nombres de entrada con los que se analizó un schematic.

Structures.generate(options): Promise<string[]>

Genera una estructura jigsaw de vanilla, como una aldea o un puesto de saqueadores, y la renderiza directamente.

ParámetroTipoDescripción
options.structureIdstringUn grupo de estructuras, p. ej. "minecraft:village/plains/town_centers".
options.depthnumberCuántas piezas colocar.
options.radiusnumberRadio horizontal máximo.
options.heightnumberAltura vertical máxima.
const chunkIds = await Structures.generate({
  structureId: 'minecraft:village/plains/town_centers',
  depth: 7,
});

Referencia: Generators

Cuatro espacios de nombres producen formas ya hechas. Todos devuelven operaciones setBlock ancladas en el origen en lugar de dibujar nada, de modo que puedes desplazar, filtrar o repetir su salida antes de que llegue a la creación.

script.js
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 };
}
Espacio de nombresGeneraDescubrimiento
TreesÁrboles y arboledas detallados por especie, con copas, adornos y enredaderas.Trees.species()
RocksRocas, geodas y columnas de basalto.Rocks.formations()
GradientsDegradados de bloques lineales, radiales y de cuatro esquinas con tramado.options: kind, stops, dither, paletteFilter
TreeEl generador de árboles anterior, basado en parámetros.Tree.getDefaults()

Sandbox y límites

Los scripts se ejecutan en un intérprete QuickJS aislado. No hay DOM, ni window, ni document, ni temporizadores, ni acceso a la red. Un script que necesite datos externos recibe una entrada de archivo.

Mientras se ejecuta un script

LímiteValor
Memoria128 MB
Tiempo de ejecución10 minutos, tras los cuales se interrumpe la ejecución
Tamaño del código fuente en el editor1 000 000 de caracteres
Rango de coordenadas±30,000,000
Salida del registro1000 líneas, 2000 caracteres por línea
Bloques colocadosSin límite

Al enviarlo

El código enviado se vuelve a comprobar en el servidor, y estas reglas son más estrictas que las del editor.

  • El código compilado debe ocupar 100 KB o menos. Por tanto, un script muy grande se puede ejecutar en local pero no publicar.
  • El código no debe contener nada de lo siguiente: eval(, Function(, setTimeout, setInterval, XMLHttpRequest, fetch(, import(, require(, process., child_process, fs., globalThis, global., __proto__, constructor.constructor.
  • El código idéntico se rechaza por duplicado: el servidor calcula un hash del script compilado, así que republicar literalmente el trabajo de otra persona no pasará.

La comprobación de patrones es una coincidencia de texto simple

No analiza tu código, así que también salta dentro de comentarios y cadenas, y una variable inofensiva llamada fetchRow se rechazará por contener fetch(. Cámbiale el nombre y vuelve a enviarlo.

Enviar un script

Pulsa Guardar con la sesión iniciada. Se te pedirá un título y una descripción, y el script entrará en una cola de revisión.

  1. Un script pendiente solo lo ves tú. Su página enumera todas las versiones que has enviado junto con el estado de cada una.
  2. Una vez aprobado, el script aparece en el catálogo público con su propia página y dirección, y cualquiera puede ejecutarlo.
  3. Guardar de nuevo crea una versión nueva, que se revisa por separado. Mientras tanto, la versión aprobada sigue activa, así que una edición nunca rompe lo que otros están usando.
  4. Puedes eliminar tus propios scripts en cualquier momento desde la página del script.

Antes de enviarlo

  • Ponle un título de hasta 100 caracteres y una descripción de al menos 10 que diga qué construye y qué hacen las entradas.
  • Comprueba que se ejecuta hasta el final con sus entradas por defecto. Un script que solo funciona con un archivo concreto es difícil de aprobar.
  • Da a cada entrada un valor por defecto razonable, una etiqueta clara y un rango que no pueda producir una construcción demasiado grande para renderizarla.
  • Los títulos y las descripciones pasan por un filtro de contenido, y los enlaces de una descripción se comprueban contra una lista de bloqueo.

El nombre y la descripción son fijos

Cuando un script ya existe, los guardados posteriores cambian el código y crean una versión. No lo renombran, así que elige un título con el que estés a gusto.

Solución de problemas

No hay ninguna función main definida

El script se analizó pero nunca declaró main. Decláralo como una función de nivel superior, no anidada dentro de otra ni asignada de forma condicional.

Nombre de bloque de script no válido

Una llamada a setBlock o fillBox recibió algo que no es una cadena de id de bloque. Suele venir de una búsqueda que puede fallar, como un índice de paleta que se pasó del final de un array.

Coordenada de script no válida

Una coordenada era NaN, infinita o estaba fuera de ±30 000 000. Casi siempre es una división entre cero o una entrada convertida en NaN.

El script se ejecuta pero no aparece nada

Comprueba que main devuelve { creation } y que la creación que devuelves es aquella en la que colocaste los bloques.

Un bloque se renderiza como un cubo liso o un poste desnudo

Se colocó sin estados utilizables. Usa Textures.getPlacementStates y Textures.getStateOptions para las conexiones de paneles, vallas y muros.

¿Algo más? Contáctanos desde la página de preguntas frecuentes.