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.
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.
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".
// 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.
| Ayudante | Valor en main | Opciones específicas del 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 bloque (por defecto, todos los bloques) |
Input.file | ScriptFile | null | accept, required, paintable, allowMultipleFiles |
Opciones que acepta toda entrada
| Opción | Tipo | Descripción |
|---|---|---|
label | string | Etiqueta del control. Obligatoria. |
description | string | Texto de ayuda bajo el control. |
defaultValue | varies | Valor usado antes de que el espectador toque nada. |
folder | string | Agrupa este control con otros de la misma carpeta. |
order | number | Posició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. |
resetsInputs | string[] | Restablece estas entradas a sus valores por defecto cuando esta cambia. |
resetValuesByOption | Record<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.
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.
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.
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;
// ...
}| Ayudante | Finalidad |
|---|---|
Creation | Construye la salida. |
Logger | Escribe en el panel de registro del editor. |
Textures | Datos de bloques: nombres, colores, estados, modelos y modelos de mobs y skins. |
Structures | Estructuras jigsaw de vanilla y el schematic que proporcionó el visor. |
Tree, Trees, Rocks, Gradients | Generadores 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): CreationInstanceCrea el objeto en el que construye tu script. La mayoría de los scripts crean exactamente uno, al principio de main.
| Parámetro | Tipo | Descripción |
|---|---|---|
name | string | Nombre que pasa a las exportaciones. Por defecto es "Untitled". |
Devuelve una creación nueva donde colocar bloques.
creation.setBlock(x, y, z, name, states?): voidColoca 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ámetro | Tipo | Descripción |
|---|---|---|
x, y, z | number | Posición. Números enteros; Y es hacia arriba. |
name | string | Id de bloque, por ejemplo minecraft:stone. |
states | Record<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): voidRellena todas las celdas entre dos esquinas. Es preferible a un bucle siempre que el bloque no varíe.
| Parámetro | Tipo | Descripción |
|---|---|---|
x1, y1, z1 | number | Una esquina, incluida. |
x2, y2, z2 | number | La esquina opuesta, incluida. |
type | string | { 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): voidAñade operaciones en bloque. Así es como los generadores integrados incorporan su salida a una creación.
| Parámetro | Tipo | Descripción |
|---|---|---|
ops | Operation[] | 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(): voidDescarta 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
| Llamada | Qué 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?): stringEncuentra 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ámetro | Tipo | Descripción |
|---|---|---|
r, g, b | number | Componentes de color, de 0 a 255. |
palette | string[] | 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 } | nullLa 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> | nullPá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[]> | nullCombí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 } | nullPara 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 | nullDatos 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 | nullLa 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] | nullLee 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ámetro | Tipo | Descripción |
|---|---|---|
textureName | string | Un nombre de textura de las caras de un modelo. |
u, v | number | Coordenadas 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 } | nullTe 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 } | nullAntes 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 } | nullVoxeliza un mob en bloques que puedes colocar. Pasa los blocks devueltos a setBlock uno a uno, o desplázalos antes.
| Parámetro | Tipo | Descripción |
|---|---|---|
name | string | Un 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 } | nullLo mismo para un modelo de jugador, con la textura de una skin que sube el espectador.
| Parámetro | Tipo | Descripción |
|---|---|---|
name | string | Un 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ámetro | Tipo | Descripción |
|---|---|---|
name | string | La 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ámetro | Tipo | Descripción |
|---|---|---|
options.structureId | string | Un grupo de estructuras, p. ej. "minecraft:village/plains/town_centers". |
options.depth | number | Cuántas piezas colocar. |
options.radius | number | Radio horizontal máximo. |
options.height | number | Altura 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.
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 nombres | Genera | Descubrimiento |
|---|---|---|
Trees | Árboles y arboledas detallados por especie, con copas, adornos y enredaderas. | Trees.species() |
Rocks | Rocas, geodas y columnas de basalto. | Rocks.formations() |
Gradients | Degradados de bloques lineales, radiales y de cuatro esquinas con tramado. | options: kind, stops, dither, paletteFilter |
Tree | El 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ímite | Valor |
|---|---|
| Memoria | 128 MB |
| Tiempo de ejecución | 10 minutos, tras los cuales se interrumpe la ejecución |
| Tamaño del código fuente en el editor | 1 000 000 de caracteres |
| Rango de coordenadas | ±30,000,000 |
| Salida del registro | 1000 líneas, 2000 caracteres por línea |
| Bloques colocados | Sin 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.
- Un script pendiente solo lo ves tú. Su página enumera todas las versiones que has enviado junto con el estado de cada una.
- Una vez aprobado, el script aparece en el catálogo público con su propia página y dirección, y cualquiera puede ejecutarlo.
- 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.
- 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.