Tu primera partícula

Las partículas son las pequeñas imágenes planas que ves por todas partes en Minecraft: el humo de una fogata, los corazones sobre un animal contento, las burbujas bajo el agua. En esta guía vas a crear la tuya: un destello de rubí. Es un estallido de pequeños brillos rojos que suben flotando, centellean y se desvanecen.

Aprenderás qué va en un archivo de partícula, cómo dibujar su textura, cómo hacer que cambie con el tiempo y cómo mostrarla en el juego con un comando, una animación o un script.

Los archivos

RP/
  particles/
    ruby_sparkle.json
    ruby_dust.json
  textures/
    particle/
      ruby_sparkle.png

El juego carga todos los archivos .json de la carpeta particles. El nombre del archivo da igual, pero si coincide con el nombre de la partícula será más fácil encontrarlo.

Emisores y partículas

Antes de escribir nada, conviene conocer las dos partes de todo efecto:

• El emisor es un generador invisible. Decide cuántas partículas aparecen, dónde empiezan y durante cuánto tiempo sigue generándolas.
• Las partículas son las pequeñas imágenes. Cada una decide cómo se mueve, qué aspecto tiene y cuándo desaparece.

Por eso los componentes de partícula se dividen en dos familias. Los nombres que empiezan por minecraft:emitter_ configuran el generador. Los que empiezan por minecraft:particle_ configuran cada imagen. Puedes escribirlos en cualquier orden.

Paso 1: la textura

Dibuja un PNG de 8x8 y guárdalo como RP/textures/particle/ruby_sparkle.png. Una pequeña estrella de cuatro puntas queda bien.

Dibújala en blanco y gris claro, no en rojo. Más adelante la teñirás con un color, y un tinte multiplica los píxeles. El blanco se convierte en el color que quieras, pero una imagen roja teñida de azul quedaría casi negra.

Deja el fondo totalmente transparente. Las partículas siempre son cuadrados planos, así que los píxeles transparentes son los que les dan su forma.

Paso 2: la descripción

Crea el archivo de partícula y empieza con su nombre y su aspecto:

{
  "format_version": "1.10.0",
  "particle_effect": {
    "description": {
      "identifier": "wiki:ruby_sparkle",
      "basic_render_parameters": {
        "material": "particles_alpha",
        "texture": "textures/particle/ruby_sparkle"
      }
    },
    "components": {}
  }
}

• identifier es el nombre que usas para mostrar la partícula. Dale siempre tu propio espacio de nombres (aquí wiki:), para que nunca choque con el juego base ni con otro complemento.
• texture es la ruta a tu PNG desde la raíz del paquete de recursos, sin .png.
• material decide cómo se dibujan los píxeles transparentes:

Nuestro destello debe brillar, así que cambia el material a particles_add cuando funcione. Empieza con particles_alpha mientras pruebas, porque es el que más fácil se ve.

Paso 3: el emisor

Ahora rellena components. Primero el generador. Queremos un estallido rápido de 12 destellos, repartidos alrededor de una pequeña esfera:

"minecraft:emitter_lifetime_once": {
  "active_time": 0.5
},
"minecraft:emitter_rate_instant": {
  "num_particles": 12
},
"minecraft:emitter_shape_sphere": {
  "radius": 0.4,
  "direction": "outwards"
},

• emitter_lifetime_once ejecuta el emisor una vez y luego lo elimina.
• emitter_rate_instant genera las 12 partículas en el mismo instante.
• emitter_shape_sphere las coloca dentro de una esfera de 0.4 bloques de radio, cada una apuntando hacia fuera del centro.

Todo emisor necesita un componente de duración y un componente de ritmo. Sin ellos no se genera nada. La forma es opcional: si la omites, todas las partículas empiezan exactamente en el centro.

Paso 4: las partículas

Ahora dile a cada destello cómo moverse y qué aspecto tener. Añade esto después de los componentes del emisor:

"minecraft:particle_lifetime_expression": {
  "max_lifetime": "math.random(0.6, 1.2)"
},
"minecraft:particle_initial_speed": 1.5,
"minecraft:particle_motion_dynamic": {
  "linear_acceleration": [0, 1.2, 0],
  "linear_drag_coefficient": 3
},
"minecraft:particle_appearance_billboard": {
  "size": [0.12, 0.12],
  "facing_camera_mode": "lookat_xyz",
  "uv": {
    "texture_width": 8,
    "texture_height": 8,
    "uv": [0, 0],
    "uv_size": [8, 8]
  }
},
"minecraft:particle_appearance_tinting": {
  "color": [1, 0.15, 0.3, 1]
}

Esto es lo que hace cada uno:

• Duración. Cada destello vive entre 0.6 y 1.2 segundos. math.random elige un número nuevo para cada partícula, así que no desaparecen todas a la vez. Esto es Molang, el pequeño lenguaje matemático que usa Bedrock.
• Velocidad. Salen disparados a 1.5 bloques por segundo, en la dirección que les dio la esfera.
• Movimiento. linear_acceleration los empuja un poco hacia arriba cada segundo, así que flotan como brasas. linear_drag_coefficient es la resistencia del aire: frena rápido el primer estallido.
• Billboard. Cada partícula es un cuadrado plano. size es la mitad de su anchura y altura en bloques, así que 0.12 da un cuadrado de aproximadamente un cuarto de bloque de ancho. lookat_xyz hace que siempre mire al jugador.
• UV. Elige qué parte de la textura se muestra. Nuestra textura es una sola imagen de 8x8, así que la usamos entera: empezamos en 0, 0 y tomamos 8, 8.
• Tinte. Rojo, verde, azul y alfa, cada uno de 0 a 1. [1, 0.15, 0.3, 1] es un rojo rubí. También puedes escribir "#FF2650".

Guarda, carga el mundo y escribe:

/particle wiki:ruby_sparkle ~ ~1 ~

Deberías ver una pequeña nube roja que sube delante de ti. Si no ves nada, mira la tabla al final de esta página.

Paso 5: hazla centellear con una curva

Ahora mismo cada destello mantiene el mismo tamaño hasta que desaparece de golpe. Una curva lo arregla. Es un valor que sigue una forma que dibujas con unos pocos números.

Añade un bloque curves junto a description y components:

"curves": {
  "variable.ruby_size": {
    "type": "linear",
    "input": "variable.particle_age / variable.particle_lifetime",
    "nodes": [0.2, 1, 0.6, 0]
  }
},

• El nombre debe empezar por variable.. El juego calcula la curva para cada partícula en cada fotograma y guarda el resultado en esa variable.
• input es en qué punto de la curva estamos. La edad dividida entre la duración va de 0 (recién nacida) a 1 (a punto de desaparecer).
• nodes son los valores a lo largo del camino, repartidos por igual de principio a fin. Nuestro destello empieza pequeño (0.2), crece hasta su tamaño completo (1), se encoge (0.6) y termina en nada (0).
• type es cómo se mueve la curva entre nodos. linear traza líneas rectas. catmull_rom y bezier hacen curvas suaves, y bezier_chain te deja fijar tú mismo cada punto y su pendiente.

Ahora usa la variable en el tamaño del billboard:

"size": ["0.12 * variable.ruby_size", "0.12 * variable.ruby_size"],

Para un fundido, el tinte también puede cambiar de color a lo largo de la vida de la partícula. Un gradient enumera colores, e interpolant elige en qué punto estamos entre ellos:

"minecraft:particle_appearance_tinting": {
  "color": {
    "gradient": ["#FFFF8FA8", "#FFFF2650", "#00A0002A"],
    "interpolant": "variable.particle_age / variable.particle_lifetime"
  }
}

Aquí cada color se escribe como #AARRGGBB, así que las dos primeras letras son el alfa. El destello empieza rosa pálido, se vuelve rojo rubí y termina oscuro e invisible. Con particles_add, los colores oscuros se desvanecen hasta desaparecer, algo que queda precioso en los efectos luminosos.

Paso 6: añade un estallido con un evento

Los eventos hacen que pasen cosas en un momento concreto. Vamos a dejar una pequeña nube de polvo donde desaparece cada destello.

Primero crea el polvo. Es un segundo efecto, más pequeño:

{
  "format_version": "1.10.0",
  "particle_effect": {
    "description": {
      "identifier": "wiki:ruby_dust",
      "basic_render_parameters": {
        "material": "particles_add",
        "texture": "textures/particle/ruby_sparkle"
      }
    },
    "components": {
      "minecraft:emitter_lifetime_once": { "active_time": 0.2 },
      "minecraft:emitter_rate_instant": { "num_particles": 3 },
      "minecraft:emitter_shape_point": {},
      "minecraft:particle_initial_speed": 0.4,
      "minecraft:particle_lifetime_expression": { "max_lifetime": 0.3 },
      "minecraft:particle_appearance_billboard": {
        "size": [0.04, 0.04],
        "facing_camera_mode": "lookat_xyz",
        "uv": {
          "texture_width": 8,
          "texture_height": 8,
          "uv": [0, 0],
          "uv_size": [8, 8]
        }
      },
      "minecraft:particle_appearance_tinting": { "color": "#FF7A0F2E" }
    }
  }
}

Luego, de vuelta en ruby_sparkle.json, ponle nombre a un evento y di qué hace:

"events": {
  "pop": {
    "particle_effect": {
      "effect": "wiki:ruby_dust",
      "type": "emitter"
    }
  }
},

Por último, lanza el evento cuando a cada destello se le acaba la vida:

"minecraft:particle_lifetime_events": {
  "expiration_event": "pop"
}

Un evento puede hacer más que generar partículas:

El archivo terminado

Aquí tienes el destello completo, con el material luminoso activado:

{
  "format_version": "1.10.0",
  "particle_effect": {
    "description": {
      "identifier": "wiki:ruby_sparkle",
      "basic_render_parameters": {
        "material": "particles_add",
        "texture": "textures/particle/ruby_sparkle"
      }
    },
    "curves": {
      "variable.ruby_size": {
        "type": "linear",
        "input": "variable.particle_age / variable.particle_lifetime",
        "nodes": [0.2, 1, 0.6, 0]
      }
    },
    "events": {
      "pop": {
        "particle_effect": {
          "effect": "wiki:ruby_dust",
          "type": "emitter"
        }
      }
    },
    "components": {
      "minecraft:emitter_lifetime_once": {
        "active_time": 0.5
      },
      "minecraft:emitter_rate_instant": {
        "num_particles": 12
      },
      "minecraft:emitter_shape_sphere": {
        "radius": 0.4,
        "direction": "outwards"
      },
      "minecraft:particle_lifetime_expression": {
        "max_lifetime": "math.random(0.6, 1.2)"
      },
      "minecraft:particle_lifetime_events": {
        "expiration_event": "pop"
      },
      "minecraft:particle_initial_speed": 1.5,
      "minecraft:particle_initial_spin": {
        "rotation": "math.random(0, 360)",
        "rotation_rate": 90
      },
      "minecraft:particle_motion_dynamic": {
        "linear_acceleration": [0, 1.2, 0],
        "linear_drag_coefficient": 3
      },
      "minecraft:particle_appearance_billboard": {
        "size": ["0.12 * variable.ruby_size", "0.12 * variable.ruby_size"],
        "facing_camera_mode": "lookat_xyz",
        "uv": {
          "texture_width": 8,
          "texture_height": 8,
          "uv": [0, 0],
          "uv_size": [8, 8]
        }
      },
      "minecraft:particle_appearance_tinting": {
        "color": {
          "gradient": ["#FFFF8FA8", "#FFFF2650", "#00A0002A"],
          "interpolant": "variable.particle_age / variable.particle_lifetime"
        }
      }
    }
  }
}

También hemos colado particle_initial_spin: cada destello empieza en un ángulo aleatorio y gira despacio, así que no hay dos iguales.

Mostrar la partícula

Con un comando

/particle muestra un efecto en una posición. Necesita los trucos activados.

/particle wiki:ruby_sparkle ~ ~1 ~

También puedes ponerlo en una función o en un bloque de comandos. Usa execute para mostrarlo sobre alguien: /execute as @a at @s run particle wiki:ruby_sparkle ~ ~2 ~ muestra un destello sobre la cabeza de cada jugador.

Desde la animación de una criatura

Una criatura puede mostrar partículas desde sus animaciones. Esto se hace en el archivo de entidad de cliente del paquete de recursos, así que consulta primero Tu primera criatura personalizada si todavía no has hecho ninguna.

1. Dale al efecto un nombre corto en la description de la entidad de cliente:

"particle_effects": {
  "sparkle": "wiki:ruby_sparkle"
}

2. Lánzalo desde una animación en un momento concreto. locator es opcional: es un punto con nombre del modelo, y el efecto lo sigue mientras la criatura se mueve. Sin él, el efecto sale a los pies de la criatura.

"particle_effects": {
  "0.5": {
    "effect": "sparkle",
    "locator": "head"
  }
}

3. O lánzalo desde un estado de un controlador de animación. Empieza cuando la criatura entra en el estado:

"particle_effects": [
  { "effect": "sparkle" }
]

Cada uno de estos también puede tener un pre_effect_script: un poco de Molang que se ejecuta justo antes de que empiece el efecto. Úsalo para pasar valores al archivo de partícula, como un color que dependa de la criatura.

Desde un script

Los scripts pueden mostrar partículas en cualquier lugar y en cualquier momento. Tu paquete de comportamiento necesita un módulo de script en su manifiesto: Preparar el proyecto explica cómo.

import { world } from "@minecraft/server";

world.afterEvents.itemUse.subscribe(({ source, itemStack }) => {
  if (itemStack.typeId !== "wiki:ruby_wand") return;

  const { x, y, z } = source.location;
  source.dimension.spawnParticle("wiki:ruby_sparkle", { x, y: y + 1.5, z });
});

Cada vez que un jugador usa un objeto wiki:ruby_wand, un destello estalla sobre él. dimension.spawnParticle muestra el efecto a todos los que estén cerca. player.spawnParticle funciona igual, pero solo lo ve ese jugador.

Los scripts también pueden pasar valores a la partícula con un MolangVariableMap. Así un solo archivo de partícula puede crear destellos de cualquier color:

import { MolangVariableMap } from "@minecraft/server";

// Inside the same itemUse handler as above:
const vars = new MolangVariableMap();
vars.setColorRGB("variable.tint", { red: 0.2, green: 0.6, blue: 1 });
source.dimension.spawnParticle("wiki:ruby_sparkle", { x, y: y + 1.5, z }, vars);

En el archivo de partícula, lee las tres partes del color como variable.tint.r, variable.tint.g y variable.tint.b:

"minecraft:particle_appearance_tinting": {
  "color": ["variable.tint.r", "variable.tint.g", "variable.tint.b", 1]
}

Variables de Molang útiles

El juego rellena estos valores por ti. Úsalos en cualquier campo de Molang.

variable.particle_random_1 es genial para dar variedad. Por ejemplo, "0.1 + variable.particle_random_1 * 0.05" le da a cada destello un tamaño ligeramente distinto.

Cuando algo sale mal

Tienes más ayuda en Solución de problemas. ¿Quieres más? Todos los ajustes del emisor están en Componentes del emisor, y todos los ajustes de las partículas en Componentes de partícula.